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