sound/pci/pcxhr/pcxhr_mixer.c

   1 #define __NO_VERSION__
   2 /*
   3  * Driver for Digigram pcxhr compatible soundcards
   4  *
   5  * mixer callbacks
   6  *
   7  * Copyright (c) 2004 by Digigram <alsa@digigram.com>
   8  *
   9  *   This program is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation; either version 2 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This program is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU General Public License
  20  *   along with this program; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  22  */
  23
  24 #include <linux/time.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/init.h>
  27 #include <linux/mutex.h>
  28 #include <sound/core.h>
  29 #include "pcxhr.h"
  30 #include "pcxhr_hwdep.h"
  31 #include "pcxhr_core.h"
  32 #include <sound/control.h>
  33 #include <sound/tlv.h>
  34 #include <sound/asoundef.h>
  35 #include "pcxhr_mixer.h"
  36 #include "pcxhr_mix22.h"
  37
  38 #define PCXHR_LINE_CAPTURE_LEVEL_MIN   0        /* -112.0 dB */
  39 #define PCXHR_LINE_CAPTURE_LEVEL_MAX   255      /* +15.5 dB */
  40 #define PCXHR_LINE_CAPTURE_ZERO_LEVEL  224      /* 0.0 dB ( 0 dBu -> 0 dBFS ) */
  41
  42 #define PCXHR_LINE_PLAYBACK_LEVEL_MIN  0        /* -104.0 dB */
  43 #define PCXHR_LINE_PLAYBACK_LEVEL_MAX  128      /* +24.0 dB */
  44 #define PCXHR_LINE_PLAYBACK_ZERO_LEVEL 104      /* 0.0 dB ( 0 dBFS -> 0 dBu ) */
  45
  46 static const DECLARE_TLV_DB_SCALE(db_scale_analog_capture, -11200, 50, 1550);
  47 static const DECLARE_TLV_DB_SCALE(db_scale_analog_playback, -10400, 100, 2400);
  48
  49 static const DECLARE_TLV_DB_SCALE(db_scale_a_hr222_capture, -11150, 50, 1600);
  50 static const DECLARE_TLV_DB_SCALE(db_scale_a_hr222_playback, -2550, 50, 2400);
  51
  52 static int pcxhr_update_analog_audio_level(struct snd_pcxhr *chip,
  53                                            int is_capture, int channel)
  54 {
  55         int err, vol;
  56         struct pcxhr_rmh rmh;
  57
  58         pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);
  59         if (is_capture) {
  60                 rmh.cmd[0] |= IO_NUM_REG_IN_ANA_LEVEL;
  61                 rmh.cmd[2] = chip->analog_capture_volume[channel];
  62         } else {
  63                 rmh.cmd[0] |= IO_NUM_REG_OUT_ANA_LEVEL;
  64                 if (chip->analog_playback_active[channel])
  65                         vol = chip->analog_playback_volume[channel];
  66                 else
  67                         vol = PCXHR_LINE_PLAYBACK_LEVEL_MIN;
  68                 /* playback analog levels are inversed */
  69                 rmh.cmd[2] = PCXHR_LINE_PLAYBACK_LEVEL_MAX - vol;
  70         }
  71         rmh.cmd[1]  = 1 << ((2 * chip->chip_idx) + channel);    /* audio mask */
  72         rmh.cmd_len = 3;
  73         err = pcxhr_send_msg(chip->mgr, &rmh);
  74         if (err < 0) {
  75                 snd_printk(KERN_DEBUG "error update_analog_audio_level card(%d)"
  76                            " is_capture(%d) err(%x)\n",
  77                            chip->chip_idx, is_capture, err);
  78                 return -EINVAL;
  79         }
  80         return 0;
  81 }
  82
  83 /*
  84  * analog level control
  85  */
  86 static int pcxhr_analog_vol_info(struct snd_kcontrol *kcontrol,
  87                                  struct snd_ctl_elem_info *uinfo)
  88 {
  89         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
  90
  91         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  92         uinfo->count = 2;
  93         if (kcontrol->private_value == 0) {     /* playback */
  94             if (chip->mgr->is_hr_stereo) {
  95                 uinfo->value.integer.min =
  96                         HR222_LINE_PLAYBACK_LEVEL_MIN;  /* -25 dB */
  97                 uinfo->value.integer.max =
  98                         HR222_LINE_PLAYBACK_LEVEL_MAX;  /* +24 dB */
  99             } else {
 100                 uinfo->value.integer.min =
 101                         PCXHR_LINE_PLAYBACK_LEVEL_MIN;  /*-104 dB */
 102                 uinfo->value.integer.max =
 103                         PCXHR_LINE_PLAYBACK_LEVEL_MAX;  /* +24 dB */
 104             }
 105         } else {                                /* capture */
 106             if (chip->mgr->is_hr_stereo) {
 107                 uinfo->value.integer.min =
 108                         HR222_LINE_CAPTURE_LEVEL_MIN;   /*-112 dB */
 109                 uinfo->value.integer.max =
 110                         HR222_LINE_CAPTURE_LEVEL_MAX;   /* +15.5 dB */
 111             } else {
 112                 uinfo->value.integer.min =
 113                         PCXHR_LINE_CAPTURE_LEVEL_MIN;   /*-112 dB */
 114                 uinfo->value.integer.max =
 115                         PCXHR_LINE_CAPTURE_LEVEL_MAX;   /* +15.5 dB */
 116             }
 117         }
 118         return 0;
 119 }
 120
 121 static int pcxhr_analog_vol_get(struct snd_kcontrol *kcontrol,
 122                                 struct snd_ctl_elem_value *ucontrol)
 123 {
 124         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 125         mutex_lock(&chip->mgr->mixer_mutex);
 126         if (kcontrol->private_value == 0) {     /* playback */
 127           ucontrol->value.integer.value[0] = chip->analog_playback_volume[0];
 128           ucontrol->value.integer.value[1] = chip->analog_playback_volume[1];
 129         } else {                                /* capture */
 130           ucontrol->value.integer.value[0] = chip->analog_capture_volume[0];
 131           ucontrol->value.integer.value[1] = chip->analog_capture_volume[1];
 132         }
 133         mutex_unlock(&chip->mgr->mixer_mutex);
 134         return 0;
 135 }
 136
 137 static int pcxhr_analog_vol_put(struct snd_kcontrol *kcontrol,
 138                                 struct snd_ctl_elem_value *ucontrol)
 139 {
 140         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 141         int changed = 0;
 142         int is_capture, i;
 143
 144         mutex_lock(&chip->mgr->mixer_mutex);
 145         is_capture = (kcontrol->private_value != 0);
 146         for (i = 0; i < 2; i++) {
 147                 int  new_volume = ucontrol->value.integer.value[i];
 148                 int *stored_volume = is_capture ?
 149                         &chip->analog_capture_volume[i] :
 150                         &chip->analog_playback_volume[i];
 151                 if (is_capture) {
 152                         if (chip->mgr->is_hr_stereo) {
 153                                 if (new_volume < HR222_LINE_CAPTURE_LEVEL_MIN ||
 154                                     new_volume > HR222_LINE_CAPTURE_LEVEL_MAX)
 155                                         continue;
 156                         } else {
 157                                 if (new_volume < PCXHR_LINE_CAPTURE_LEVEL_MIN ||
 158                                     new_volume > PCXHR_LINE_CAPTURE_LEVEL_MAX)
 159                                         continue;
 160                         }
 161                 } else {
 162                         if (chip->mgr->is_hr_stereo) {
 163                                 if (new_volume < HR222_LINE_PLAYBACK_LEVEL_MIN ||
 164                                     new_volume > HR222_LINE_PLAYBACK_LEVEL_MAX)
 165                                         continue;
 166                         } else {
 167                                 if (new_volume < PCXHR_LINE_PLAYBACK_LEVEL_MIN ||
 168                                     new_volume > PCXHR_LINE_PLAYBACK_LEVEL_MAX)
 169                                         continue;
 170                         }
 171                 }
 172                 if (*stored_volume != new_volume) {
 173                         *stored_volume = new_volume;
 174                         changed = 1;
 175                         if (chip->mgr->is_hr_stereo)
 176                                 hr222_update_analog_audio_level(chip,
 177                                                                 is_capture, i);
 178                         else
 179                                 pcxhr_update_analog_audio_level(chip,
 180                                                                 is_capture, i);
 181                 }
 182         }
 183         mutex_unlock(&chip->mgr->mixer_mutex);
 184         return changed;
 185 }
 186
 187 static struct snd_kcontrol_new pcxhr_control_analog_level = {
 188         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 189         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 190                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 191         /* name will be filled later */
 192         .info =         pcxhr_analog_vol_info,
 193         .get =          pcxhr_analog_vol_get,
 194         .put =          pcxhr_analog_vol_put,
 195         /* tlv will be filled later */
 196 };
 197
 198 /* shared */
 199
 200 #define pcxhr_sw_info           snd_ctl_boolean_stereo_info
 201
 202 static int pcxhr_audio_sw_get(struct snd_kcontrol *kcontrol,
 203                               struct snd_ctl_elem_value *ucontrol)
 204 {
 205         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 206
 207         mutex_lock(&chip->mgr->mixer_mutex);
 208         ucontrol->value.integer.value[0] = chip->analog_playback_active[0];
 209         ucontrol->value.integer.value[1] = chip->analog_playback_active[1];
 210         mutex_unlock(&chip->mgr->mixer_mutex);
 211         return 0;
 212 }
 213
 214 static int pcxhr_audio_sw_put(struct snd_kcontrol *kcontrol,
 215                               struct snd_ctl_elem_value *ucontrol)
 216 {
 217         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 218         int i, changed = 0;
 219         mutex_lock(&chip->mgr->mixer_mutex);
 220         for(i = 0; i < 2; i++) {
 221                 if (chip->analog_playback_active[i] !=
 222                     ucontrol->value.integer.value[i]) {
 223                         chip->analog_playback_active[i] =
 224                                 !!ucontrol->value.integer.value[i];
 225                         changed = 1;
 226                         /* update playback levels */
 227                         if (chip->mgr->is_hr_stereo)
 228                                 hr222_update_analog_audio_level(chip, 0, i);
 229                         else
 230                                 pcxhr_update_analog_audio_level(chip, 0, i);
 231                 }
 232         }
 233         mutex_unlock(&chip->mgr->mixer_mutex);
 234         return changed;
 235 }
 236
 237 static struct snd_kcontrol_new pcxhr_control_output_switch = {
 238         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 239         .name =         "Master Playback Switch",
 240         .info =         pcxhr_sw_info,          /* shared */
 241         .get =          pcxhr_audio_sw_get,
 242         .put =          pcxhr_audio_sw_put
 243 };
 244
 245
 246 #define PCXHR_DIGITAL_LEVEL_MIN         0x000   /* -110 dB */
 247 #define PCXHR_DIGITAL_LEVEL_MAX         0x1ff   /* +18 dB */
 248 #define PCXHR_DIGITAL_ZERO_LEVEL        0x1b7   /*  0 dB */
 249
 250 static const DECLARE_TLV_DB_SCALE(db_scale_digital, -10975, 25, 1800);
 251
 252 #define MORE_THAN_ONE_STREAM_LEVEL      0x000001
 253 #define VALID_STREAM_PAN_LEVEL_MASK     0x800000
 254 #define VALID_STREAM_LEVEL_MASK         0x400000
 255 #define VALID_STREAM_LEVEL_1_MASK       0x200000
 256 #define VALID_STREAM_LEVEL_2_MASK       0x100000
 257
 258 static int pcxhr_update_playback_stream_level(struct snd_pcxhr* chip, int idx)
 259 {
 260         int err;
 261         struct pcxhr_rmh rmh;
 262         struct pcxhr_pipe *pipe = &chip->playback_pipe;
 263         int left, right;
 264
 265         if (chip->digital_playback_active[idx][0])
 266                 left = chip->digital_playback_volume[idx][0];
 267         else
 268                 left = PCXHR_DIGITAL_LEVEL_MIN;
 269         if (chip->digital_playback_active[idx][1])
 270                 right = chip->digital_playback_volume[idx][1];
 271         else
 272                 right = PCXHR_DIGITAL_LEVEL_MIN;
 273
 274         pcxhr_init_rmh(&rmh, CMD_STREAM_OUT_LEVEL_ADJUST);
 275         /* add pipe and stream mask */
 276         pcxhr_set_pipe_cmd_params(&rmh, 0, pipe->first_audio, 0, 1<<idx);
 277         /* volume left->left / right->right panoramic level */
 278         rmh.cmd[0] |= MORE_THAN_ONE_STREAM_LEVEL;
 279         rmh.cmd[2]  = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_1_MASK;
 280         rmh.cmd[2] |= (left << 10);
 281         rmh.cmd[3]  = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_2_MASK;
 282         rmh.cmd[3] |= right;
 283         rmh.cmd_len = 4;
 284
 285         err = pcxhr_send_msg(chip->mgr, &rmh);
 286         if (err < 0) {
 287                 snd_printk(KERN_DEBUG "error update_playback_stream_level "
 288                            "card(%d) err(%x)\n", chip->chip_idx, err);
 289                 return -EINVAL;
 290         }
 291         return 0;
 292 }
 293
 294 #define AUDIO_IO_HAS_MUTE_LEVEL         0x400000
 295 #define AUDIO_IO_HAS_MUTE_MONITOR_1     0x200000
 296 #define VALID_AUDIO_IO_DIGITAL_LEVEL    0x000001
 297 #define VALID_AUDIO_IO_MONITOR_LEVEL    0x000002
 298 #define VALID_AUDIO_IO_MUTE_LEVEL       0x000004
 299 #define VALID_AUDIO_IO_MUTE_MONITOR_1   0x000008
 300
 301 static int pcxhr_update_audio_pipe_level(struct snd_pcxhr *chip,
 302                                          int capture, int channel)
 303 {
 304         int err;
 305         struct pcxhr_rmh rmh;
 306         struct pcxhr_pipe *pipe;
 307
 308         if (capture)
 309                 pipe = &chip->capture_pipe[0];
 310         else
 311                 pipe = &chip->playback_pipe;
 312
 313         pcxhr_init_rmh(&rmh, CMD_AUDIO_LEVEL_ADJUST);
 314         /* add channel mask */
 315         pcxhr_set_pipe_cmd_params(&rmh, capture, 0, 0,
 316                                   1 << (channel + pipe->first_audio));
 317         /* TODO : if mask (3 << pipe->first_audio) is used, left and right
 318          * channel will be programmed to the same params */
 319         if (capture) {
 320                 rmh.cmd[0] |= VALID_AUDIO_IO_DIGITAL_LEVEL;
 321                 /* VALID_AUDIO_IO_MUTE_LEVEL not yet handled
 322                  * (capture pipe level) */
 323                 rmh.cmd[2] = chip->digital_capture_volume[channel];
 324         } else {
 325                 rmh.cmd[0] |=   VALID_AUDIO_IO_MONITOR_LEVEL |
 326                                 VALID_AUDIO_IO_MUTE_MONITOR_1;
 327                 /* VALID_AUDIO_IO_DIGITAL_LEVEL and VALID_AUDIO_IO_MUTE_LEVEL
 328                  * not yet handled (playback pipe level)
 329                  */
 330                 rmh.cmd[2] = chip->monitoring_volume[channel] << 10;
 331                 if (chip->monitoring_active[channel] == 0)
 332                         rmh.cmd[2] |= AUDIO_IO_HAS_MUTE_MONITOR_1;
 333         }
 334         rmh.cmd_len = 3;
 335
 336         err = pcxhr_send_msg(chip->mgr, &rmh);
 337         if (err < 0) {
 338                 snd_printk(KERN_DEBUG "error update_audio_level(%d) err=%x\n",
 339                            chip->chip_idx, err);
 340                 return -EINVAL;
 341         }
 342         return 0;
 343 }
 344
 345
 346 /* shared */
 347 static int pcxhr_digital_vol_info(struct snd_kcontrol *kcontrol,
 348                                   struct snd_ctl_elem_info *uinfo)
 349 {
 350         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 351         uinfo->count = 2;
 352         uinfo->value.integer.min = PCXHR_DIGITAL_LEVEL_MIN;   /* -109.5 dB */
 353         uinfo->value.integer.max = PCXHR_DIGITAL_LEVEL_MAX;   /*   18.0 dB */
 354         return 0;
 355 }
 356
 357
 358 static int pcxhr_pcm_vol_get(struct snd_kcontrol *kcontrol,
 359                              struct snd_ctl_elem_value *ucontrol)
 360 {
 361         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 362         int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */
 363         int *stored_volume;
 364         int is_capture = kcontrol->private_value;
 365
 366         mutex_lock(&chip->mgr->mixer_mutex);
 367         if (is_capture)         /* digital capture */
 368                 stored_volume = chip->digital_capture_volume;
 369         else                    /* digital playback */
 370                 stored_volume = chip->digital_playback_volume[idx];
 371         ucontrol->value.integer.value[0] = stored_volume[0];
 372         ucontrol->value.integer.value[1] = stored_volume[1];
 373         mutex_unlock(&chip->mgr->mixer_mutex);
 374         return 0;
 375 }
 376
 377 static int pcxhr_pcm_vol_put(struct snd_kcontrol *kcontrol,
 378                              struct snd_ctl_elem_value *ucontrol)
 379 {
 380         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 381         int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */
 382         int changed = 0;
 383         int is_capture = kcontrol->private_value;
 384         int *stored_volume;
 385         int i;
 386
 387         mutex_lock(&chip->mgr->mixer_mutex);
 388         if (is_capture)         /* digital capture */
 389                 stored_volume = chip->digital_capture_volume;
 390         else                    /* digital playback */
 391                 stored_volume = chip->digital_playback_volume[idx];
 392         for (i = 0; i < 2; i++) {
 393                 int vol = ucontrol->value.integer.value[i];
 394                 if (vol < PCXHR_DIGITAL_LEVEL_MIN ||
 395                     vol > PCXHR_DIGITAL_LEVEL_MAX)
 396                         continue;
 397                 if (stored_volume[i] != vol) {
 398                         stored_volume[i] = vol;
 399                         changed = 1;
 400                         if (is_capture) /* update capture volume */
 401                                 pcxhr_update_audio_pipe_level(chip, 1, i);
 402                 }
 403         }
 404         if (!is_capture && changed)     /* update playback volume */
 405                 pcxhr_update_playback_stream_level(chip, idx);
 406         mutex_unlock(&chip->mgr->mixer_mutex);
 407         return changed;
 408 }
 409
 410 static struct snd_kcontrol_new snd_pcxhr_pcm_vol =
 411 {
 412         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 413         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 414                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 415         /* name will be filled later */
 416         /* count will be filled later */
 417         .info =         pcxhr_digital_vol_info,         /* shared */
 418         .get =          pcxhr_pcm_vol_get,
 419         .put =          pcxhr_pcm_vol_put,
 420         .tlv = { .p = db_scale_digital },
 421 };
 422
 423
 424 static int pcxhr_pcm_sw_get(struct snd_kcontrol *kcontrol,
 425                             struct snd_ctl_elem_value *ucontrol)
 426 {
 427         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 428         int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */
 429
 430         mutex_lock(&chip->mgr->mixer_mutex);
 431         ucontrol->value.integer.value[0] = chip->digital_playback_active[idx][0];
 432         ucontrol->value.integer.value[1] = chip->digital_playback_active[idx][1];
 433         mutex_unlock(&chip->mgr->mixer_mutex);
 434         return 0;
 435 }
 436
 437 static int pcxhr_pcm_sw_put(struct snd_kcontrol *kcontrol,
 438                             struct snd_ctl_elem_value *ucontrol)
 439 {
 440         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 441         int changed = 0;
 442         int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */
 443         int i, j;
 444
 445         mutex_lock(&chip->mgr->mixer_mutex);
 446         j = idx;
 447         for (i = 0; i < 2; i++) {
 448                 if (chip->digital_playback_active[j][i] !=
 449                     ucontrol->value.integer.value[i]) {
 450                         chip->digital_playback_active[j][i] =
 451                                 !!ucontrol->value.integer.value[i];
 452                         changed = 1;
 453                 }
 454         }
 455         if (changed)
 456                 pcxhr_update_playback_stream_level(chip, idx);
 457         mutex_unlock(&chip->mgr->mixer_mutex);
 458         return changed;
 459 }
 460
 461 static struct snd_kcontrol_new pcxhr_control_pcm_switch = {
 462         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 463         .name =         "PCM Playback Switch",
 464         .count =        PCXHR_PLAYBACK_STREAMS,
 465         .info =         pcxhr_sw_info,          /* shared */
 466         .get =          pcxhr_pcm_sw_get,
 467         .put =          pcxhr_pcm_sw_put
 468 };
 469
 470
 471 /*
 472  * monitoring level control
 473  */
 474
 475 static int pcxhr_monitor_vol_get(struct snd_kcontrol *kcontrol,
 476                                  struct snd_ctl_elem_value *ucontrol)
 477 {
 478         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 479         mutex_lock(&chip->mgr->mixer_mutex);
 480         ucontrol->value.integer.value[0] = chip->monitoring_volume[0];
 481         ucontrol->value.integer.value[1] = chip->monitoring_volume[1];
 482         mutex_unlock(&chip->mgr->mixer_mutex);
 483         return 0;
 484 }
 485
 486 static int pcxhr_monitor_vol_put(struct snd_kcontrol *kcontrol,
 487                                  struct snd_ctl_elem_value *ucontrol)
 488 {
 489         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 490         int changed = 0;
 491         int i;
 492
 493         mutex_lock(&chip->mgr->mixer_mutex);
 494         for (i = 0; i < 2; i++) {
 495                 if (chip->monitoring_volume[i] !=
 496                     ucontrol->value.integer.value[i]) {
 497                         chip->monitoring_volume[i] =
 498                                 ucontrol->value.integer.value[i];
 499                         if (chip->monitoring_active[i])
 500                                 /* update monitoring volume and mute */
 501                                 /* do only when monitoring is unmuted */
 502                                 pcxhr_update_audio_pipe_level(chip, 0, i);
 503                         changed = 1;
 504                 }
 505         }
 506         mutex_unlock(&chip->mgr->mixer_mutex);
 507         return changed;
 508 }
 509
 510 static struct snd_kcontrol_new pcxhr_control_monitor_vol = {
 511         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 512         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 513                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 514         .name =         "Monitoring Playback Volume",
 515         .info =         pcxhr_digital_vol_info,         /* shared */
 516         .get =          pcxhr_monitor_vol_get,
 517         .put =          pcxhr_monitor_vol_put,
 518         .tlv = { .p = db_scale_digital },
 519 };
 520
 521 /*
 522  * monitoring switch control
 523  */
 524
 525 static int pcxhr_monitor_sw_get(struct snd_kcontrol *kcontrol,
 526                                 struct snd_ctl_elem_value *ucontrol)
 527 {
 528         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 529         mutex_lock(&chip->mgr->mixer_mutex);
 530         ucontrol->value.integer.value[0] = chip->monitoring_active[0];
 531         ucontrol->value.integer.value[1] = chip->monitoring_active[1];
 532         mutex_unlock(&chip->mgr->mixer_mutex);
 533         return 0;
 534 }
 535
 536 static int pcxhr_monitor_sw_put(struct snd_kcontrol *kcontrol,
 537                                 struct snd_ctl_elem_value *ucontrol)
 538 {
 539         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 540         int changed = 0;
 541         int i;
 542
 543         mutex_lock(&chip->mgr->mixer_mutex);
 544         for (i = 0; i < 2; i++) {
 545                 if (chip->monitoring_active[i] !=
 546                     ucontrol->value.integer.value[i]) {
 547                         chip->monitoring_active[i] =
 548                                 !!ucontrol->value.integer.value[i];
 549                         changed |= (1<<i); /* mask 0x01 and 0x02 */
 550                 }
 551         }
 552         if (changed & 0x01)
 553                 /* update left monitoring volume and mute */
 554                 pcxhr_update_audio_pipe_level(chip, 0, 0);
 555         if (changed & 0x02)
 556                 /* update right monitoring volume and mute */
 557                 pcxhr_update_audio_pipe_level(chip, 0, 1);
 558
 559         mutex_unlock(&chip->mgr->mixer_mutex);
 560         return (changed != 0);
 561 }
 562
 563 static struct snd_kcontrol_new pcxhr_control_monitor_sw = {
 564         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 565         .name =         "Monitoring Playback Switch",
 566         .info =         pcxhr_sw_info,          /* shared */
 567         .get =          pcxhr_monitor_sw_get,
 568         .put =          pcxhr_monitor_sw_put
 569 };
 570
 571
 572
 573 /*
 574  * audio source select
 575  */
 576 #define PCXHR_SOURCE_AUDIO01_UER        0x000100
 577 #define PCXHR_SOURCE_AUDIO01_SYNC       0x000200
 578 #define PCXHR_SOURCE_AUDIO23_UER        0x000400
 579 #define PCXHR_SOURCE_AUDIO45_UER        0x001000
 580 #define PCXHR_SOURCE_AUDIO67_UER        0x040000
 581
 582 static int pcxhr_set_audio_source(struct snd_pcxhr* chip)
 583 {
 584         struct pcxhr_rmh rmh;
 585         unsigned int mask, reg;
 586         unsigned int codec;
 587         int err, changed;
 588
 589         switch (chip->chip_idx) {
 590         case 0 : mask = PCXHR_SOURCE_AUDIO01_UER; codec = CS8420_01_CS; break;
 591         case 1 : mask = PCXHR_SOURCE_AUDIO23_UER; codec = CS8420_23_CS; break;
 592         case 2 : mask = PCXHR_SOURCE_AUDIO45_UER; codec = CS8420_45_CS; break;
 593         case 3 : mask = PCXHR_SOURCE_AUDIO67_UER; codec = CS8420_67_CS; break;
 594         default: return -EINVAL;
 595         }
 596         if (chip->audio_capture_source != 0) {
 597                 reg = mask;     /* audio source from digital plug */
 598         } else {
 599                 reg = 0;        /* audio source from analog plug */
 600         }
 601         /* set the input source */
 602         pcxhr_write_io_num_reg_cont(chip->mgr, mask, reg, &changed);
 603         /* resync them (otherwise channel inversion possible) */
 604         if (changed) {
 605                 pcxhr_init_rmh(&rmh, CMD_RESYNC_AUDIO_INPUTS);
 606                 rmh.cmd[0] |= (1 << chip->chip_idx);
 607                 err = pcxhr_send_msg(chip->mgr, &rmh);
 608                 if (err)
 609                         return err;
 610         }
 611         if (chip->mgr->board_aes_in_192k) {
 612                 int i;
 613                 unsigned int src_config = 0xC0;
 614                 /* update all src configs with one call */
 615                 for (i = 0; (i < 4) && (i < chip->mgr->capture_chips); i++) {
 616                         if (chip->mgr->chip[i]->audio_capture_source == 2)
 617                                 src_config |= (1 << (3 - i));
 618                 }
 619                 /* set codec SRC on off */
 620                 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);
 621                 rmh.cmd_len = 2;
 622                 rmh.cmd[0] |= IO_NUM_REG_CONFIG_SRC;
 623                 rmh.cmd[1] = src_config;
 624                 err = pcxhr_send_msg(chip->mgr, &rmh);
 625         } else {
 626                 int use_src = 0;
 627                 if (chip->audio_capture_source == 2)
 628                         use_src = 1;
 629                 /* set codec SRC on off */
 630                 pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);
 631                 rmh.cmd_len = 3;
 632                 rmh.cmd[0] |= IO_NUM_UER_CHIP_REG;
 633                 rmh.cmd[1] = codec;
 634                 rmh.cmd[2] = ((CS8420_DATA_FLOW_CTL & CHIP_SIG_AND_MAP_SPI) |
 635                               (use_src ? 0x41 : 0x54));
 636                 err = pcxhr_send_msg(chip->mgr, &rmh);
 637                 if (err)
 638                         return err;
 639                 rmh.cmd[2] = ((CS8420_CLOCK_SRC_CTL & CHIP_SIG_AND_MAP_SPI) |
 640                               (use_src ? 0x41 : 0x49));
 641                 err = pcxhr_send_msg(chip->mgr, &rmh);
 642         }
 643         return err;
 644 }
 645
 646 static int pcxhr_audio_src_info(struct snd_kcontrol *kcontrol,
 647                                 struct snd_ctl_elem_info *uinfo)
 648 {
 649         static const char *texts[5] = {
 650                 "Line", "Digital", "Digi+SRC", "Mic", "Line+Mic"
 651         };
 652         int i;
 653         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 654
 655         i = 2;                  /* no SRC, no Mic available */
 656         if (chip->mgr->board_has_aes1) {
 657                 i = 3;          /* SRC available */
 658                 if (chip->mgr->board_has_mic)
 659                         i = 5;  /* Mic and MicroMix available */
 660         }
 661         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 662         uinfo->count = 1;
 663         uinfo->value.enumerated.items = i;
 664         if (uinfo->value.enumerated.item > (i-1))
 665                 uinfo->value.enumerated.item = i-1;
 666         strcpy(uinfo->value.enumerated.name,
 667                 texts[uinfo->value.enumerated.item]);
 668         return 0;
 669 }
 670
 671 static int pcxhr_audio_src_get(struct snd_kcontrol *kcontrol,
 672                                struct snd_ctl_elem_value *ucontrol)
 673 {
 674         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 675         ucontrol->value.enumerated.item[0] = chip->audio_capture_source;
 676         return 0;
 677 }
 678
 679 static int pcxhr_audio_src_put(struct snd_kcontrol *kcontrol,
 680                                struct snd_ctl_elem_value *ucontrol)
 681 {
 682         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 683         int ret = 0;
 684         int i = 2;              /* no SRC, no Mic available */
 685         if (chip->mgr->board_has_aes1) {
 686                 i = 3;          /* SRC available */
 687                 if (chip->mgr->board_has_mic)
 688                         i = 5;  /* Mic and MicroMix available */
 689         }
 690         if (ucontrol->value.enumerated.item[0] >= i)
 691                 return -EINVAL;
 692         mutex_lock(&chip->mgr->mixer_mutex);
 693         if (chip->audio_capture_source != ucontrol->value.enumerated.item[0]) {
 694                 chip->audio_capture_source = ucontrol->value.enumerated.item[0];
 695                 if (chip->mgr->is_hr_stereo)
 696                         hr222_set_audio_source(chip);
 697                 else
 698                         pcxhr_set_audio_source(chip);
 699                 ret = 1;
 700         }
 701         mutex_unlock(&chip->mgr->mixer_mutex);
 702         return ret;
 703 }
 704
 705 static struct snd_kcontrol_new pcxhr_control_audio_src = {
 706         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 707         .name =         "Capture Source",
 708         .info =         pcxhr_audio_src_info,
 709         .get =          pcxhr_audio_src_get,
 710         .put =          pcxhr_audio_src_put,
 711 };
 712
 713
 714 /*
 715  * clock type selection
 716  * enum pcxhr_clock_type {
 717  *      PCXHR_CLOCK_TYPE_INTERNAL = 0,
 718  *      PCXHR_CLOCK_TYPE_WORD_CLOCK,
 719  *      PCXHR_CLOCK_TYPE_AES_SYNC,
 720  *      PCXHR_CLOCK_TYPE_AES_1,
 721  *      PCXHR_CLOCK_TYPE_AES_2,
 722  *      PCXHR_CLOCK_TYPE_AES_3,
 723  *      PCXHR_CLOCK_TYPE_AES_4,
 724  *      PCXHR_CLOCK_TYPE_MAX = PCXHR_CLOCK_TYPE_AES_4,
 725  *      HR22_CLOCK_TYPE_INTERNAL = PCXHR_CLOCK_TYPE_INTERNAL,
 726  *      HR22_CLOCK_TYPE_AES_SYNC,
 727  *      HR22_CLOCK_TYPE_AES_1,
 728  *      HR22_CLOCK_TYPE_MAX = HR22_CLOCK_TYPE_AES_1,
 729  * };
 730  */
 731
 732 static int pcxhr_clock_type_info(struct snd_kcontrol *kcontrol,
 733                                  struct snd_ctl_elem_info *uinfo)
 734 {
 735         static const char *textsPCXHR[7] = {
 736                 "Internal", "WordClock", "AES Sync",
 737                 "AES 1", "AES 2", "AES 3", "AES 4"
 738         };
 739         static const char *textsHR22[3] = {
 740                 "Internal", "AES Sync", "AES 1"
 741         };
 742         const char **texts;
 743         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 744         int clock_items = 2;    /* at least Internal and AES Sync clock */
 745         if (mgr->board_has_aes1) {
 746                 clock_items += mgr->capture_chips;      /* add AES x */
 747                 if (!mgr->is_hr_stereo)
 748                         clock_items += 1;               /* add word clock */
 749         }
 750         if (mgr->is_hr_stereo) {
 751                 texts = textsHR22;
 752                 snd_BUG_ON(clock_items > (HR22_CLOCK_TYPE_MAX+1));
 753         } else {
 754                 texts = textsPCXHR;
 755                 snd_BUG_ON(clock_items > (PCXHR_CLOCK_TYPE_MAX+1));
 756         }
 757         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 758         uinfo->count = 1;
 759         uinfo->value.enumerated.items = clock_items;
 760         if (uinfo->value.enumerated.item >= clock_items)
 761                 uinfo->value.enumerated.item = clock_items-1;
 762         strcpy(uinfo->value.enumerated.name,
 763                 texts[uinfo->value.enumerated.item]);
 764         return 0;
 765 }
 766
 767 static int pcxhr_clock_type_get(struct snd_kcontrol *kcontrol,
 768                                 struct snd_ctl_elem_value *ucontrol)
 769 {
 770         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 771         ucontrol->value.enumerated.item[0] = mgr->use_clock_type;
 772         return 0;
 773 }
 774
 775 static int pcxhr_clock_type_put(struct snd_kcontrol *kcontrol,
 776                                 struct snd_ctl_elem_value *ucontrol)
 777 {
 778         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 779         int rate, ret = 0;
 780         unsigned int clock_items = 2; /* at least Internal and AES Sync clock */
 781         if (mgr->board_has_aes1) {
 782                 clock_items += mgr->capture_chips;      /* add AES x */
 783                 if (!mgr->is_hr_stereo)
 784                         clock_items += 1;               /* add word clock */
 785         }
 786         if (ucontrol->value.enumerated.item[0] >= clock_items)
 787                 return -EINVAL;
 788         mutex_lock(&mgr->mixer_mutex);
 789         if (mgr->use_clock_type != ucontrol->value.enumerated.item[0]) {
 790                 mutex_lock(&mgr->setup_mutex);
 791                 mgr->use_clock_type = ucontrol->value.enumerated.item[0];
 792                 rate = 0;
 793                 if (mgr->use_clock_type != PCXHR_CLOCK_TYPE_INTERNAL) {
 794                         pcxhr_get_external_clock(mgr, mgr->use_clock_type,
 795                                                  &rate);
 796                 } else {
 797                         rate = mgr->sample_rate;
 798                         if (!rate)
 799                                 rate = 48000;
 800                 }
 801                 if (rate) {
 802                         pcxhr_set_clock(mgr, rate);
 803                         if (mgr->sample_rate)
 804                                 mgr->sample_rate = rate;
 805                 }
 806                 mutex_unlock(&mgr->setup_mutex);
 807                 ret = 1; /* return 1 even if the set was not done. ok ? */
 808         }
 809         mutex_unlock(&mgr->mixer_mutex);
 810         return ret;
 811 }
 812
 813 static struct snd_kcontrol_new pcxhr_control_clock_type = {
 814         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 815         .name =         "Clock Mode",
 816         .info =         pcxhr_clock_type_info,
 817         .get =          pcxhr_clock_type_get,
 818         .put =          pcxhr_clock_type_put,
 819 };
 820
 821 /*
 822  * clock rate control
 823  * specific control that scans the sample rates on the external plugs
 824  */
 825 static int pcxhr_clock_rate_info(struct snd_kcontrol *kcontrol,
 826                                  struct snd_ctl_elem_info *uinfo)
 827 {
 828         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 829         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 830         uinfo->count = 3 + mgr->capture_chips;
 831         uinfo->value.integer.min = 0;           /* clock not present */
 832         uinfo->value.integer.max = 192000;      /* max sample rate 192 kHz */
 833         return 0;
 834 }
 835
 836 static int pcxhr_clock_rate_get(struct snd_kcontrol *kcontrol,
 837                                 struct snd_ctl_elem_value *ucontrol)
 838 {
 839         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 840         int i, err, rate;
 841
 842         mutex_lock(&mgr->mixer_mutex);
 843         for(i = 0; i < 3 + mgr->capture_chips; i++) {
 844                 if (i == PCXHR_CLOCK_TYPE_INTERNAL)
 845                         rate = mgr->sample_rate_real;
 846                 else {
 847                         err = pcxhr_get_external_clock(mgr, i, &rate);
 848                         if (err)
 849                                 break;
 850                 }
 851                 ucontrol->value.integer.value[i] = rate;
 852         }
 853         mutex_unlock(&mgr->mixer_mutex);
 854         return 0;
 855 }
 856
 857 static struct snd_kcontrol_new pcxhr_control_clock_rate = {
 858         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 859         .iface =        SNDRV_CTL_ELEM_IFACE_CARD,
 860         .name =         "Clock Rates",
 861         .info =         pcxhr_clock_rate_info,
 862         .get =          pcxhr_clock_rate_get,
 863 };
 864
 865 /*
 866  * IEC958 status bits
 867  */
 868 static int pcxhr_iec958_info(struct snd_kcontrol *kcontrol,
 869                              struct snd_ctl_elem_info *uinfo)
 870 {
 871         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 872         uinfo->count = 1;
 873         return 0;
 874 }
 875
 876 static int pcxhr_iec958_capture_byte(struct snd_pcxhr *chip,
 877                                      int aes_idx, unsigned char *aes_bits)
 878 {
 879         int i, err;
 880         unsigned char temp;
 881         struct pcxhr_rmh rmh;
 882
 883         pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ);
 884         rmh.cmd[0] |= IO_NUM_UER_CHIP_REG;
 885         switch (chip->chip_idx) {
 886           /* instead of CS8420_01_CS use CS8416_01_CS for AES SYNC plug */
 887         case 0: rmh.cmd[1] = CS8420_01_CS; break;
 888         case 1: rmh.cmd[1] = CS8420_23_CS; break;
 889         case 2: rmh.cmd[1] = CS8420_45_CS; break;
 890         case 3: rmh.cmd[1] = CS8420_67_CS; break;
 891         default: return -EINVAL;
 892         }
 893         if (chip->mgr->board_aes_in_192k) {
 894                 switch (aes_idx) {
 895                 case 0: rmh.cmd[2] = CS8416_CSB0; break;
 896                 case 1: rmh.cmd[2] = CS8416_CSB1; break;
 897                 case 2: rmh.cmd[2] = CS8416_CSB2; break;
 898                 case 3: rmh.cmd[2] = CS8416_CSB3; break;
 899                 case 4: rmh.cmd[2] = CS8416_CSB4; break;
 900                 default: return -EINVAL;
 901                 }
 902         } else {
 903                 switch (aes_idx) {
 904                   /* instead of CS8420_CSB0 use CS8416_CSBx for AES SYNC plug */
 905                 case 0: rmh.cmd[2] = CS8420_CSB0; break;
 906                 case 1: rmh.cmd[2] = CS8420_CSB1; break;
 907                 case 2: rmh.cmd[2] = CS8420_CSB2; break;
 908                 case 3: rmh.cmd[2] = CS8420_CSB3; break;
 909                 case 4: rmh.cmd[2] = CS8420_CSB4; break;
 910                 default: return -EINVAL;
 911                 }
 912         }
 913         /* size and code the chip id for the fpga */
 914         rmh.cmd[1] &= 0x0fffff;
 915         /* chip signature + map for spi read */
 916         rmh.cmd[2] &= CHIP_SIG_AND_MAP_SPI;
 917         rmh.cmd_len = 3;
 918         err = pcxhr_send_msg(chip->mgr, &rmh);
 919         if (err)
 920                 return err;
 921
 922         if (chip->mgr->board_aes_in_192k) {
 923                 temp = (unsigned char)rmh.stat[1];
 924         } else {
 925                 temp = 0;
 926                 /* reversed bit order (not with CS8416_01_CS) */
 927                 for (i = 0; i < 8; i++) {
 928                         temp <<= 1;
 929                         if (rmh.stat[1] & (1 << i))
 930                                 temp |= 1;
 931                 }
 932         }
 933         snd_printdd("read iec958 AES %d byte %d = 0x%x\n",
 934                     chip->chip_idx, aes_idx, temp);
 935         *aes_bits = temp;
 936         return 0;
 937 }
 938
 939 static int pcxhr_iec958_get(struct snd_kcontrol *kcontrol,
 940                             struct snd_ctl_elem_value *ucontrol)
 941 {
 942         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 943         unsigned char aes_bits;
 944         int i, err;
 945
 946         mutex_lock(&chip->mgr->mixer_mutex);
 947         for(i = 0; i < 5; i++) {
 948                 if (kcontrol->private_value == 0)       /* playback */
 949                         aes_bits = chip->aes_bits[i];
 950                 else {                          /* capture */
 951                         if (chip->mgr->is_hr_stereo)
 952                                 err = hr222_iec958_capture_byte(chip, i,
 953                                                                 &aes_bits);
 954                         else
 955                                 err = pcxhr_iec958_capture_byte(chip, i,
 956                                                                 &aes_bits);
 957                         if (err)
 958                                 break;
 959                 }
 960                 ucontrol->value.iec958.status[i] = aes_bits;
 961         }
 962         mutex_unlock(&chip->mgr->mixer_mutex);
 963         return 0;
 964 }
 965
 966 static int pcxhr_iec958_mask_get(struct snd_kcontrol *kcontrol,
 967                                  struct snd_ctl_elem_value *ucontrol)
 968 {
 969         int i;
 970         for (i = 0; i < 5; i++)
 971                 ucontrol->value.iec958.status[i] = 0xff;
 972         return 0;
 973 }
 974
 975 static int pcxhr_iec958_update_byte(struct snd_pcxhr *chip,
 976                                     int aes_idx, unsigned char aes_bits)
 977 {
 978         int i, err, cmd;
 979         unsigned char new_bits = aes_bits;
 980         unsigned char old_bits = chip->aes_bits[aes_idx];
 981         struct pcxhr_rmh rmh;
 982
 983         for (i = 0; i < 8; i++) {
 984                 if ((old_bits & 0x01) != (new_bits & 0x01)) {
 985                         cmd = chip->chip_idx & 0x03;      /* chip index 0..3 */
 986                         if (chip->chip_idx > 3)
 987                                 /* new bit used if chip_idx>3 (PCX1222HR) */
 988                                 cmd |= 1 << 22;
 989                         cmd |= ((aes_idx << 3) + i) << 2; /* add bit offset */
 990                         cmd |= (new_bits & 0x01) << 23;   /* add bit value */
 991                         pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);
 992                         rmh.cmd[0] |= IO_NUM_REG_CUER;
 993                         rmh.cmd[1] = cmd;
 994                         rmh.cmd_len = 2;
 995                         snd_printdd("write iec958 AES %d byte %d bit %d (cmd %x)\n",
 996                                     chip->chip_idx, aes_idx, i, cmd);
 997                         err = pcxhr_send_msg(chip->mgr, &rmh);
 998                         if (err)
 999                                 return err;
1000                 }
1001                 old_bits >>= 1;
1002                 new_bits >>= 1;
1003         }
1004         chip->aes_bits[aes_idx] = aes_bits;
1005         return 0;
1006 }
1007
1008 static int pcxhr_iec958_put(struct snd_kcontrol *kcontrol,
1009                             struct snd_ctl_elem_value *ucontrol)
1010 {
1011         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
1012         int i, changed = 0;
1013
1014         /* playback */
1015         mutex_lock(&chip->mgr->mixer_mutex);
1016         for (i = 0; i < 5; i++) {
1017                 if (ucontrol->value.iec958.status[i] != chip->aes_bits[i]) {
1018                         if (chip->mgr->is_hr_stereo)
1019                                 hr222_iec958_update_byte(chip, i,
1020                                         ucontrol->value.iec958.status[i]);
1021                         else
1022                                 pcxhr_iec958_update_byte(chip, i,
1023                                         ucontrol->value.iec958.status[i]);
1024                         changed = 1;
1025                 }
1026         }
1027         mutex_unlock(&chip->mgr->mixer_mutex);
1028         return changed;
1029 }
1030
1031 static struct snd_kcontrol_new pcxhr_control_playback_iec958_mask = {
1032         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
1033         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1034         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
1035         .info =         pcxhr_iec958_info,
1036         .get =          pcxhr_iec958_mask_get
1037 };
1038 static struct snd_kcontrol_new pcxhr_control_playback_iec958 = {
1039         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1040         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
1041         .info =         pcxhr_iec958_info,
1042         .get =          pcxhr_iec958_get,
1043         .put =          pcxhr_iec958_put,
1044         .private_value = 0 /* playback */
1045 };
1046
1047 static struct snd_kcontrol_new pcxhr_control_capture_iec958_mask = {
1048         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
1049         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1050         .name =         SNDRV_CTL_NAME_IEC958("",CAPTURE,MASK),
1051         .info =         pcxhr_iec958_info,
1052         .get =          pcxhr_iec958_mask_get
1053 };
1054 static struct snd_kcontrol_new pcxhr_control_capture_iec958 = {
1055         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
1056         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
1057         .name =         SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
1058         .info =         pcxhr_iec958_info,
1059         .get =          pcxhr_iec958_get,
1060         .private_value = 1 /* capture */
1061 };
1062
1063 static void pcxhr_init_audio_levels(struct snd_pcxhr *chip)
1064 {
1065         int i;
1066
1067         for (i = 0; i < 2; i++) {
1068                 if (chip->nb_streams_play) {
1069                         int j;
1070                         /* at boot time the digital volumes are unmuted 0dB */
1071                         for (j = 0; j < PCXHR_PLAYBACK_STREAMS; j++) {
1072                                 chip->digital_playback_active[j][i] = 1;
1073                                 chip->digital_playback_volume[j][i] =
1074                                         PCXHR_DIGITAL_ZERO_LEVEL;
1075                         }
1076                         /* after boot, only two bits are set on the uer
1077                          * interface
1078                          */
1079                         chip->aes_bits[0] = (IEC958_AES0_PROFESSIONAL |
1080                                              IEC958_AES0_PRO_FS_48000);
1081 #ifdef CONFIG_SND_DEBUG
1082                         /* analog volumes for playback
1083                          * (is LEVEL_MIN after boot)
1084                          */
1085                         chip->analog_playback_active[i] = 1;
1086                         if (chip->mgr->is_hr_stereo)
1087                                 chip->analog_playback_volume[i] =
1088                                         HR222_LINE_PLAYBACK_ZERO_LEVEL;
1089                         else {
1090                                 chip->analog_playback_volume[i] =
1091                                         PCXHR_LINE_PLAYBACK_ZERO_LEVEL;
1092                                 pcxhr_update_analog_audio_level(chip, 0, i);
1093                         }
1094 #endif
1095                         /* stereo cards need to be initialised after boot */
1096                         if (chip->mgr->is_hr_stereo)
1097                                 hr222_update_analog_audio_level(chip, 0, i);
1098                 }
1099                 if (chip->nb_streams_capt) {
1100                         /* at boot time the digital volumes are unmuted 0dB */
1101                         chip->digital_capture_volume[i] =
1102                                 PCXHR_DIGITAL_ZERO_LEVEL;
1103                         chip->analog_capture_active = 1;
1104 #ifdef CONFIG_SND_DEBUG
1105                         /* analog volumes for playback
1106                          * (is LEVEL_MIN after boot)
1107                          */
1108                         if (chip->mgr->is_hr_stereo)
1109                                 chip->analog_capture_volume[i] =
1110                                         HR222_LINE_CAPTURE_ZERO_LEVEL;
1111                         else {
1112                                 chip->analog_capture_volume[i] =
1113                                         PCXHR_LINE_CAPTURE_ZERO_LEVEL;
1114                                 pcxhr_update_analog_audio_level(chip, 1, i);
1115                         }
1116 #endif
1117                         /* stereo cards need to be initialised after boot */
1118                         if (chip->mgr->is_hr_stereo)
1119                                 hr222_update_analog_audio_level(chip, 1, i);
1120                 }
1121         }
1122
1123         return;
1124 }
1125
1126
1127 int pcxhr_create_mixer(struct pcxhr_mgr *mgr)
1128 {
1129         struct snd_pcxhr *chip;
1130         int err, i;
1131
1132         mutex_init(&mgr->mixer_mutex); /* can be in another place */
1133
1134         for (i = 0; i < mgr->num_cards; i++) {
1135                 struct snd_kcontrol_new temp;
1136                 chip = mgr->chip[i];
1137
1138                 if (chip->nb_streams_play) {
1139                         /* analog output level control */
1140                         temp = pcxhr_control_analog_level;
1141                         temp.name = "Master Playback Volume";
1142                         temp.private_value = 0; /* playback */
1143                         if (mgr->is_hr_stereo)
1144                                 temp.tlv.p = db_scale_a_hr222_playback;
1145                         else
1146                                 temp.tlv.p = db_scale_analog_playback;
1147                         err = snd_ctl_add(chip->card,
1148                                           snd_ctl_new1(&temp, chip));
1149                         if (err < 0)
1150                                 return err;
1151
1152                         /* output mute controls */
1153                         err = snd_ctl_add(chip->card,
1154                                 snd_ctl_new1(&pcxhr_control_output_switch,
1155                                              chip));
1156                         if (err < 0)
1157                                 return err;
1158
1159                         temp = snd_pcxhr_pcm_vol;
1160                         temp.name = "PCM Playback Volume";
1161                         temp.count = PCXHR_PLAYBACK_STREAMS;
1162                         temp.private_value = 0; /* playback */
1163                         err = snd_ctl_add(chip->card,
1164                                           snd_ctl_new1(&temp, chip));
1165                         if (err < 0)
1166                                 return err;
1167
1168                         err = snd_ctl_add(chip->card,
1169                                 snd_ctl_new1(&pcxhr_control_pcm_switch, chip));
1170                         if (err < 0)
1171                                 return err;
1172
1173                         /* IEC958 controls */
1174                         err = snd_ctl_add(chip->card,
1175                                 snd_ctl_new1(&pcxhr_control_playback_iec958_mask,
1176                                              chip));
1177                         if (err < 0)
1178                                 return err;
1179
1180                         err = snd_ctl_add(chip->card,
1181                                 snd_ctl_new1(&pcxhr_control_playback_iec958,
1182                                              chip));
1183                         if (err < 0)
1184                                 return err;
1185                 }
1186                 if (chip->nb_streams_capt) {
1187                         /* analog input level control */
1188                         temp = pcxhr_control_analog_level;
1189                         temp.name = "Line Capture Volume";
1190                         temp.private_value = 1; /* capture */
1191                         if (mgr->is_hr_stereo)
1192                                 temp.tlv.p = db_scale_a_hr222_capture;
1193                         else
1194                                 temp.tlv.p = db_scale_analog_capture;
1195
1196                         err = snd_ctl_add(chip->card,
1197                                           snd_ctl_new1(&temp, chip));
1198                         if (err < 0)
1199                                 return err;
1200
1201                         temp = snd_pcxhr_pcm_vol;
1202                         temp.name = "PCM Capture Volume";
1203                         temp.count = 1;
1204                         temp.private_value = 1; /* capture */
1205
1206                         err = snd_ctl_add(chip->card,
1207                                           snd_ctl_new1(&temp, chip));
1208                         if (err < 0)
1209                                 return err;
1210
1211                         /* Audio source */
1212                         err = snd_ctl_add(chip->card,
1213                                 snd_ctl_new1(&pcxhr_control_audio_src, chip));
1214                         if (err < 0)
1215                                 return err;
1216
1217                         /* IEC958 controls */
1218                         err = snd_ctl_add(chip->card,
1219                                 snd_ctl_new1(&pcxhr_control_capture_iec958_mask,
1220                                              chip));
1221                         if (err < 0)
1222                                 return err;
1223
1224                         err = snd_ctl_add(chip->card,
1225                                 snd_ctl_new1(&pcxhr_control_capture_iec958,
1226                                              chip));
1227                         if (err < 0)
1228                                 return err;
1229
1230                         if (mgr->is_hr_stereo) {
1231                                 err = hr222_add_mic_controls(chip);
1232                                 if (err < 0)
1233                                         return err;
1234                         }
1235                 }
1236                 /* monitoring only if playback and capture device available */
1237                 if (chip->nb_streams_capt > 0 && chip->nb_streams_play > 0) {
1238                         /* monitoring */
1239                         err = snd_ctl_add(chip->card,
1240                                 snd_ctl_new1(&pcxhr_control_monitor_vol, chip));
1241                         if (err < 0)
1242                                 return err;
1243
1244                         err = snd_ctl_add(chip->card,
1245                                 snd_ctl_new1(&pcxhr_control_monitor_sw, chip));
1246                         if (err < 0)
1247                                 return err;
1248                 }
1249
1250                 if (i == 0) {
1251                         /* clock mode only one control per pcxhr */
1252                         err = snd_ctl_add(chip->card,
1253                                 snd_ctl_new1(&pcxhr_control_clock_type, mgr));
1254                         if (err < 0)
1255                                 return err;
1256                         /* non standard control used to scan
1257                          * the external clock presence/frequencies
1258                          */
1259                         err = snd_ctl_add(chip->card,
1260                                 snd_ctl_new1(&pcxhr_control_clock_rate, mgr));
1261                         if (err < 0)
1262                                 return err;
1263                 }
1264
1265                 /* init values for the mixer data */
1266                 pcxhr_init_audio_levels(chip);
1267         }
1268
1269         return 0;
1270 }