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 <sound/driver.h>
  25 #include <linux/time.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/init.h>
  28 #include <linux/mutex.h>
  29 #include <sound/core.h>
  30 #include "pcxhr.h"
  31 #include "pcxhr_hwdep.h"
  32 #include "pcxhr_core.h"
  33 #include <sound/control.h>
  34 #include <sound/tlv.h>
  35 #include <sound/asoundef.h>
  36 #include "pcxhr_mixer.h"
  37
  38
  39 #define PCXHR_ANALOG_CAPTURE_LEVEL_MIN   0      /* -96.0 dB */
  40 #define PCXHR_ANALOG_CAPTURE_LEVEL_MAX   255    /* +31.5 dB */
  41 #define PCXHR_ANALOG_CAPTURE_ZERO_LEVEL  224    /* +16.0 dB ( +31.5 dB - fix level +15.5 dB ) */
  42
  43 #define PCXHR_ANALOG_PLAYBACK_LEVEL_MIN  0      /* -128.0 dB */
  44 #define PCXHR_ANALOG_PLAYBACK_LEVEL_MAX  128    /*    0.0 dB */
  45 #define PCXHR_ANALOG_PLAYBACK_ZERO_LEVEL 104    /*  -24.0 dB ( 0.0 dB - fix level +24.0 dB ) */
  46
  47 static DECLARE_TLV_DB_SCALE(db_scale_analog_capture, -9600, 50, 0);
  48 static DECLARE_TLV_DB_SCALE(db_scale_analog_playback, -12800, 100, 0);
  49
  50 static int pcxhr_update_analog_audio_level(struct snd_pcxhr *chip, int is_capture, int channel)
  51 {
  52         int err, vol;
  53         struct pcxhr_rmh rmh;
  54
  55         pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);
  56         if (is_capture) {
  57                 rmh.cmd[0] |= IO_NUM_REG_IN_ANA_LEVEL;
  58                 rmh.cmd[2] = chip->analog_capture_volume[channel];
  59         } else {
  60                 rmh.cmd[0] |= IO_NUM_REG_OUT_ANA_LEVEL;
  61                 if (chip->analog_playback_active[channel])
  62                         vol = chip->analog_playback_volume[channel];
  63                 else
  64                         vol = PCXHR_ANALOG_PLAYBACK_LEVEL_MIN;
  65                 rmh.cmd[2] = PCXHR_ANALOG_PLAYBACK_LEVEL_MAX - vol;     /* playback analog levels are inversed */
  66         }
  67         rmh.cmd[1]  = 1 << ((2 * chip->chip_idx) + channel);    /* audio mask */
  68         rmh.cmd_len = 3;
  69         err = pcxhr_send_msg(chip->mgr, &rmh);
  70         if (err < 0) {
  71                 snd_printk(KERN_DEBUG "error update_analog_audio_level card(%d) "
  72                            "is_capture(%d) err(%x)\n", chip->chip_idx, is_capture, err);
  73                 return -EINVAL;
  74         }
  75         return 0;
  76 }
  77
  78 /*
  79  * analog level control
  80  */
  81 static int pcxhr_analog_vol_info(struct snd_kcontrol *kcontrol,
  82                                  struct snd_ctl_elem_info *uinfo)
  83 {
  84         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  85         uinfo->count = 2;
  86         if (kcontrol->private_value == 0) {     /* playback */
  87                 uinfo->value.integer.min = PCXHR_ANALOG_PLAYBACK_LEVEL_MIN;     /* -128 dB */
  88                 uinfo->value.integer.max = PCXHR_ANALOG_PLAYBACK_LEVEL_MAX;     /* 0 dB */
  89         } else {                                /* capture */
  90                 uinfo->value.integer.min = PCXHR_ANALOG_CAPTURE_LEVEL_MIN;      /* -96 dB */
  91                 uinfo->value.integer.max = PCXHR_ANALOG_CAPTURE_LEVEL_MAX;      /* 31.5 dB */
  92         }
  93         return 0;
  94 }
  95
  96 static int pcxhr_analog_vol_get(struct snd_kcontrol *kcontrol,
  97                                 struct snd_ctl_elem_value *ucontrol)
  98 {
  99         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 100         mutex_lock(&chip->mgr->mixer_mutex);
 101         if (kcontrol->private_value == 0) {     /* playback */
 102                 ucontrol->value.integer.value[0] = chip->analog_playback_volume[0];
 103                 ucontrol->value.integer.value[1] = chip->analog_playback_volume[1];
 104         } else {                                /* capture */
 105                 ucontrol->value.integer.value[0] = chip->analog_capture_volume[0];
 106                 ucontrol->value.integer.value[1] = chip->analog_capture_volume[1];
 107         }
 108         mutex_unlock(&chip->mgr->mixer_mutex);
 109         return 0;
 110 }
 111
 112 static int pcxhr_analog_vol_put(struct snd_kcontrol *kcontrol,
 113                                 struct snd_ctl_elem_value *ucontrol)
 114 {
 115         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 116         int changed = 0;
 117         int is_capture, i;
 118
 119         mutex_lock(&chip->mgr->mixer_mutex);
 120         is_capture = (kcontrol->private_value != 0);
 121         for (i = 0; i < 2; i++) {
 122                 int  new_volume = ucontrol->value.integer.value[i];
 123                 int* stored_volume = is_capture ? &chip->analog_capture_volume[i] :
 124                         &chip->analog_playback_volume[i];
 125                 if (*stored_volume != new_volume) {
 126                         *stored_volume = new_volume;
 127                         changed = 1;
 128                         pcxhr_update_analog_audio_level(chip, is_capture, i);
 129                 }
 130         }
 131         mutex_unlock(&chip->mgr->mixer_mutex);
 132         return changed;
 133 }
 134
 135 static struct snd_kcontrol_new pcxhr_control_analog_level = {
 136         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 137         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 138                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 139         /* name will be filled later */
 140         .info =         pcxhr_analog_vol_info,
 141         .get =          pcxhr_analog_vol_get,
 142         .put =          pcxhr_analog_vol_put,
 143         /* tlv will be filled later */
 144 };
 145
 146 /* shared */
 147 static int pcxhr_sw_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 148 {
 149         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 150         uinfo->count = 2;
 151         uinfo->value.integer.min = 0;
 152         uinfo->value.integer.max = 1;
 153         return 0;
 154 }
 155
 156 static int pcxhr_audio_sw_get(struct snd_kcontrol *kcontrol,
 157                               struct snd_ctl_elem_value *ucontrol)
 158 {
 159         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 160
 161         mutex_lock(&chip->mgr->mixer_mutex);
 162         ucontrol->value.integer.value[0] = chip->analog_playback_active[0];
 163         ucontrol->value.integer.value[1] = chip->analog_playback_active[1];
 164         mutex_unlock(&chip->mgr->mixer_mutex);
 165         return 0;
 166 }
 167
 168 static int pcxhr_audio_sw_put(struct snd_kcontrol *kcontrol,
 169                               struct snd_ctl_elem_value *ucontrol)
 170 {
 171         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 172         int i, changed = 0;
 173         mutex_lock(&chip->mgr->mixer_mutex);
 174         for(i = 0; i < 2; i++) {
 175                 if (chip->analog_playback_active[i] != ucontrol->value.integer.value[i]) {
 176                         chip->analog_playback_active[i] = ucontrol->value.integer.value[i];
 177                         changed = 1;
 178                         pcxhr_update_analog_audio_level(chip, 0, i);    /* update playback levels */
 179                 }
 180         }
 181         mutex_unlock(&chip->mgr->mixer_mutex);
 182         return changed;
 183 }
 184
 185 static struct snd_kcontrol_new pcxhr_control_output_switch = {
 186         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 187         .name =         "Master Playback Switch",
 188         .info =         pcxhr_sw_info,          /* shared */
 189         .get =          pcxhr_audio_sw_get,
 190         .put =          pcxhr_audio_sw_put
 191 };
 192
 193
 194 #define PCXHR_DIGITAL_LEVEL_MIN         0x000   /* -110 dB */
 195 #define PCXHR_DIGITAL_LEVEL_MAX         0x1ff   /* +18 dB */
 196 #define PCXHR_DIGITAL_ZERO_LEVEL        0x1b7   /*  0 dB */
 197
 198 static DECLARE_TLV_DB_SCALE(db_scale_digital, -10950, 50, 0);
 199
 200 #define MORE_THAN_ONE_STREAM_LEVEL      0x000001
 201 #define VALID_STREAM_PAN_LEVEL_MASK     0x800000
 202 #define VALID_STREAM_LEVEL_MASK         0x400000
 203 #define VALID_STREAM_LEVEL_1_MASK       0x200000
 204 #define VALID_STREAM_LEVEL_2_MASK       0x100000
 205
 206 static int pcxhr_update_playback_stream_level(struct snd_pcxhr* chip, int idx)
 207 {
 208         int err;
 209         struct pcxhr_rmh rmh;
 210         struct pcxhr_pipe *pipe = &chip->playback_pipe;
 211         int left, right;
 212
 213         if (chip->digital_playback_active[idx][0])
 214                 left = chip->digital_playback_volume[idx][0];
 215         else
 216                 left = PCXHR_DIGITAL_LEVEL_MIN;
 217         if (chip->digital_playback_active[idx][1])
 218                 right = chip->digital_playback_volume[idx][1];
 219         else
 220                 right = PCXHR_DIGITAL_LEVEL_MIN;
 221
 222         pcxhr_init_rmh(&rmh, CMD_STREAM_OUT_LEVEL_ADJUST);
 223         /* add pipe and stream mask */
 224         pcxhr_set_pipe_cmd_params(&rmh, 0, pipe->first_audio, 0, 1<<idx);
 225         /* volume left->left / right->right panoramic level */
 226         rmh.cmd[0] |= MORE_THAN_ONE_STREAM_LEVEL;
 227         rmh.cmd[2]  = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_1_MASK;
 228         rmh.cmd[2] |= (left << 10);
 229         rmh.cmd[3]  = VALID_STREAM_PAN_LEVEL_MASK | VALID_STREAM_LEVEL_2_MASK;
 230         rmh.cmd[3] |= right;
 231         rmh.cmd_len = 4;
 232
 233         err = pcxhr_send_msg(chip->mgr, &rmh);
 234         if (err < 0) {
 235                 snd_printk(KERN_DEBUG "error update_playback_stream_level "
 236                            "card(%d) err(%x)\n", chip->chip_idx, err);
 237                 return -EINVAL;
 238         }
 239         return 0;
 240 }
 241
 242 #define AUDIO_IO_HAS_MUTE_LEVEL         0x400000
 243 #define AUDIO_IO_HAS_MUTE_MONITOR_1     0x200000
 244 #define VALID_AUDIO_IO_DIGITAL_LEVEL    0x000001
 245 #define VALID_AUDIO_IO_MONITOR_LEVEL    0x000002
 246 #define VALID_AUDIO_IO_MUTE_LEVEL       0x000004
 247 #define VALID_AUDIO_IO_MUTE_MONITOR_1   0x000008
 248
 249 static int pcxhr_update_audio_pipe_level(struct snd_pcxhr* chip, int capture, int channel)
 250 {
 251         int err;
 252         struct pcxhr_rmh rmh;
 253         struct pcxhr_pipe *pipe;
 254
 255         if (capture)
 256                 pipe = &chip->capture_pipe[0];
 257         else
 258                 pipe = &chip->playback_pipe;
 259
 260         pcxhr_init_rmh(&rmh, CMD_AUDIO_LEVEL_ADJUST);
 261         /* add channel mask */
 262         pcxhr_set_pipe_cmd_params(&rmh, capture, 0, 0, 1 << (channel + pipe->first_audio));
 263         /* TODO : if mask (3 << pipe->first_audio) is used, left and right channel
 264          * will be programmed to the same params
 265          */
 266         if (capture) {
 267                 rmh.cmd[0] |= VALID_AUDIO_IO_DIGITAL_LEVEL;
 268                 /* VALID_AUDIO_IO_MUTE_LEVEL not yet handled (capture pipe level) */
 269                 rmh.cmd[2] = chip->digital_capture_volume[channel];
 270         } else {
 271                 rmh.cmd[0] |= VALID_AUDIO_IO_MONITOR_LEVEL | VALID_AUDIO_IO_MUTE_MONITOR_1;
 272                 /* VALID_AUDIO_IO_DIGITAL_LEVEL and VALID_AUDIO_IO_MUTE_LEVEL not yet
 273                  * handled (playback pipe level)
 274                  */
 275                 rmh.cmd[2] = chip->monitoring_volume[channel] << 10;
 276                 if (chip->monitoring_active[channel] == 0)
 277                         rmh.cmd[2] |= AUDIO_IO_HAS_MUTE_MONITOR_1;
 278         }
 279         rmh.cmd_len = 3;
 280
 281         err = pcxhr_send_msg(chip->mgr, &rmh);
 282         if(err<0) {
 283                 snd_printk(KERN_DEBUG "error update_audio_level card(%d) err(%x)\n",
 284                            chip->chip_idx, err);
 285                 return -EINVAL;
 286         }
 287         return 0;
 288 }
 289
 290
 291 /* shared */
 292 static int pcxhr_digital_vol_info(struct snd_kcontrol *kcontrol,
 293                                   struct snd_ctl_elem_info *uinfo)
 294 {
 295         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 296         uinfo->count = 2;
 297         uinfo->value.integer.min = PCXHR_DIGITAL_LEVEL_MIN;   /* -109.5 dB */
 298         uinfo->value.integer.max = PCXHR_DIGITAL_LEVEL_MAX;   /*   18.0 dB */
 299         return 0;
 300 }
 301
 302
 303 static int pcxhr_pcm_vol_get(struct snd_kcontrol *kcontrol,
 304                              struct snd_ctl_elem_value *ucontrol)
 305 {
 306         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 307         int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);         /* index */
 308         int *stored_volume;
 309         int is_capture = kcontrol->private_value;
 310
 311         mutex_lock(&chip->mgr->mixer_mutex);
 312         if (is_capture)
 313                 stored_volume = chip->digital_capture_volume;           /* digital capture */
 314         else
 315                 stored_volume = chip->digital_playback_volume[idx];     /* digital playback */
 316         ucontrol->value.integer.value[0] = stored_volume[0];
 317         ucontrol->value.integer.value[1] = stored_volume[1];
 318         mutex_unlock(&chip->mgr->mixer_mutex);
 319         return 0;
 320 }
 321
 322 static int pcxhr_pcm_vol_put(struct snd_kcontrol *kcontrol,
 323                              struct snd_ctl_elem_value *ucontrol)
 324 {
 325         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 326         int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);         /* index */
 327         int changed = 0;
 328         int is_capture = kcontrol->private_value;
 329         int *stored_volume;
 330         int i;
 331
 332         mutex_lock(&chip->mgr->mixer_mutex);
 333         if (is_capture)
 334                 stored_volume = chip->digital_capture_volume;           /* digital capture */
 335         else
 336                 stored_volume = chip->digital_playback_volume[idx];     /* digital playback */
 337         for (i = 0; i < 2; i++) {
 338                 if (stored_volume[i] != ucontrol->value.integer.value[i]) {
 339                         stored_volume[i] = ucontrol->value.integer.value[i];
 340                         changed = 1;
 341                         if (is_capture) /* update capture volume */
 342                                 pcxhr_update_audio_pipe_level(chip, 1, i);
 343                 }
 344         }
 345         if (! is_capture && changed)
 346                 pcxhr_update_playback_stream_level(chip, idx);  /* update playback volume */
 347         mutex_unlock(&chip->mgr->mixer_mutex);
 348         return changed;
 349 }
 350
 351 static struct snd_kcontrol_new snd_pcxhr_pcm_vol =
 352 {
 353         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 354         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 355                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 356         /* name will be filled later */
 357         /* count will be filled later */
 358         .info =         pcxhr_digital_vol_info,         /* shared */
 359         .get =          pcxhr_pcm_vol_get,
 360         .put =          pcxhr_pcm_vol_put,
 361         .tlv = { .p = db_scale_digital },
 362 };
 363
 364
 365 static int pcxhr_pcm_sw_get(struct snd_kcontrol *kcontrol,
 366                             struct snd_ctl_elem_value *ucontrol)
 367 {
 368         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 369         int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */
 370
 371         mutex_lock(&chip->mgr->mixer_mutex);
 372         ucontrol->value.integer.value[0] = chip->digital_playback_active[idx][0];
 373         ucontrol->value.integer.value[1] = chip->digital_playback_active[idx][1];
 374         mutex_unlock(&chip->mgr->mixer_mutex);
 375         return 0;
 376 }
 377
 378 static int pcxhr_pcm_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 379 {
 380         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 381         int changed = 0;
 382         int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); /* index */
 383         int i, j;
 384
 385         mutex_lock(&chip->mgr->mixer_mutex);
 386         j = idx;
 387         for (i = 0; i < 2; i++) {
 388                 if (chip->digital_playback_active[j][i] != ucontrol->value.integer.value[i]) {
 389                         chip->digital_playback_active[j][i] = ucontrol->value.integer.value[i];
 390                         changed = 1;
 391                 }
 392         }
 393         if (changed)
 394                 pcxhr_update_playback_stream_level(chip, idx);
 395         mutex_unlock(&chip->mgr->mixer_mutex);
 396         return changed;
 397 }
 398
 399 static struct snd_kcontrol_new pcxhr_control_pcm_switch = {
 400         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 401         .name =         "PCM Playback Switch",
 402         .count =        PCXHR_PLAYBACK_STREAMS,
 403         .info =         pcxhr_sw_info,          /* shared */
 404         .get =          pcxhr_pcm_sw_get,
 405         .put =          pcxhr_pcm_sw_put
 406 };
 407
 408
 409 /*
 410  * monitoring level control
 411  */
 412
 413 static int pcxhr_monitor_vol_get(struct snd_kcontrol *kcontrol,
 414                                  struct snd_ctl_elem_value *ucontrol)
 415 {
 416         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 417         mutex_lock(&chip->mgr->mixer_mutex);
 418         ucontrol->value.integer.value[0] = chip->monitoring_volume[0];
 419         ucontrol->value.integer.value[1] = chip->monitoring_volume[1];
 420         mutex_unlock(&chip->mgr->mixer_mutex);
 421         return 0;
 422 }
 423
 424 static int pcxhr_monitor_vol_put(struct snd_kcontrol *kcontrol,
 425                                  struct snd_ctl_elem_value *ucontrol)
 426 {
 427         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 428         int changed = 0;
 429         int i;
 430
 431         mutex_lock(&chip->mgr->mixer_mutex);
 432         for (i = 0; i < 2; i++) {
 433                 if (chip->monitoring_volume[i] != ucontrol->value.integer.value[i]) {
 434                         chip->monitoring_volume[i] = ucontrol->value.integer.value[i];
 435                         if(chip->monitoring_active[i])  /* do only when monitoring is unmuted */
 436                                 /* update monitoring volume and mute */
 437                                 pcxhr_update_audio_pipe_level(chip, 0, i);
 438                         changed = 1;
 439                 }
 440         }
 441         mutex_unlock(&chip->mgr->mixer_mutex);
 442         return changed;
 443 }
 444
 445 static struct snd_kcontrol_new pcxhr_control_monitor_vol = {
 446         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 447         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 448                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 449         .name =         "Monitoring Volume",
 450         .info =         pcxhr_digital_vol_info,         /* shared */
 451         .get =          pcxhr_monitor_vol_get,
 452         .put =          pcxhr_monitor_vol_put,
 453         .tlv = { .p = db_scale_digital },
 454 };
 455
 456 /*
 457  * monitoring switch control
 458  */
 459
 460 static int pcxhr_monitor_sw_get(struct snd_kcontrol *kcontrol,
 461                                 struct snd_ctl_elem_value *ucontrol)
 462 {
 463         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 464         mutex_lock(&chip->mgr->mixer_mutex);
 465         ucontrol->value.integer.value[0] = chip->monitoring_active[0];
 466         ucontrol->value.integer.value[1] = chip->monitoring_active[1];
 467         mutex_unlock(&chip->mgr->mixer_mutex);
 468         return 0;
 469 }
 470
 471 static int pcxhr_monitor_sw_put(struct snd_kcontrol *kcontrol,
 472                                 struct snd_ctl_elem_value *ucontrol)
 473 {
 474         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 475         int changed = 0;
 476         int i;
 477
 478         mutex_lock(&chip->mgr->mixer_mutex);
 479         for (i = 0; i < 2; i++) {
 480                 if (chip->monitoring_active[i] != ucontrol->value.integer.value[i]) {
 481                         chip->monitoring_active[i] = ucontrol->value.integer.value[i];
 482                         changed |= (1<<i); /* mask 0x01 and 0x02 */
 483                 }
 484         }
 485         if(changed & 0x01)
 486                 /* update left monitoring volume and mute */
 487                 pcxhr_update_audio_pipe_level(chip, 0, 0);
 488         if(changed & 0x02)
 489                 /* update right monitoring volume and mute */
 490                 pcxhr_update_audio_pipe_level(chip, 0, 1);
 491
 492         mutex_unlock(&chip->mgr->mixer_mutex);
 493         return (changed != 0);
 494 }
 495
 496 static struct snd_kcontrol_new pcxhr_control_monitor_sw = {
 497         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 498         .name =         "Monitoring Switch",
 499         .info =         pcxhr_sw_info,          /* shared */
 500         .get =          pcxhr_monitor_sw_get,
 501         .put =          pcxhr_monitor_sw_put
 502 };
 503
 504
 505
 506 /*
 507  * audio source select
 508  */
 509 #define PCXHR_SOURCE_AUDIO01_UER        0x000100
 510 #define PCXHR_SOURCE_AUDIO01_SYNC       0x000200
 511 #define PCXHR_SOURCE_AUDIO23_UER        0x000400
 512 #define PCXHR_SOURCE_AUDIO45_UER        0x001000
 513 #define PCXHR_SOURCE_AUDIO67_UER        0x040000
 514
 515 static int pcxhr_set_audio_source(struct snd_pcxhr* chip)
 516 {
 517         struct pcxhr_rmh rmh;
 518         unsigned int mask, reg;
 519         unsigned int codec;
 520         int err, use_src, changed;
 521
 522         switch (chip->chip_idx) {
 523         case 0 : mask = PCXHR_SOURCE_AUDIO01_UER; codec = CS8420_01_CS; break;
 524         case 1 : mask = PCXHR_SOURCE_AUDIO23_UER; codec = CS8420_23_CS; break;
 525         case 2 : mask = PCXHR_SOURCE_AUDIO45_UER; codec = CS8420_45_CS; break;
 526         case 3 : mask = PCXHR_SOURCE_AUDIO67_UER; codec = CS8420_67_CS; break;
 527         default: return -EINVAL;
 528         }
 529         reg = 0;        /* audio source from analog plug */
 530         use_src = 0;    /* do not activate codec SRC */
 531
 532         if (chip->audio_capture_source != 0) {
 533                 reg = mask;     /* audio source from digital plug */
 534                 if (chip->audio_capture_source == 2)
 535                         use_src = 1;
 536         }
 537         /* set the input source */
 538         pcxhr_write_io_num_reg_cont(chip->mgr, mask, reg, &changed);
 539         /* resync them (otherwise channel inversion possible) */
 540         if (changed) {
 541                 pcxhr_init_rmh(&rmh, CMD_RESYNC_AUDIO_INPUTS);
 542                 rmh.cmd[0] |= (1 << chip->chip_idx);
 543                 err = pcxhr_send_msg(chip->mgr, &rmh);
 544                 if (err)
 545                         return err;
 546         }
 547         pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);      /* set codec SRC on off */
 548         rmh.cmd_len = 3;
 549         rmh.cmd[0] |= IO_NUM_UER_CHIP_REG;
 550         rmh.cmd[1] = codec;
 551         rmh.cmd[2] = (CS8420_DATA_FLOW_CTL & CHIP_SIG_AND_MAP_SPI) | (use_src ? 0x41 : 0x54);
 552         err = pcxhr_send_msg(chip->mgr, &rmh);
 553         if(err)
 554                 return err;
 555         rmh.cmd[2] = (CS8420_CLOCK_SRC_CTL & CHIP_SIG_AND_MAP_SPI) | (use_src ? 0x41 : 0x49);
 556         err = pcxhr_send_msg(chip->mgr, &rmh);
 557         return err;
 558 }
 559
 560 static int pcxhr_audio_src_info(struct snd_kcontrol *kcontrol,
 561                                 struct snd_ctl_elem_info *uinfo)
 562 {
 563         static char *texts[3] = {"Analog", "Digital", "Digi+SRC"};
 564
 565         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 566         uinfo->count = 1;
 567         uinfo->value.enumerated.items = 3;
 568         if (uinfo->value.enumerated.item > 2)
 569                 uinfo->value.enumerated.item = 2;
 570         strcpy(uinfo->value.enumerated.name,
 571                 texts[uinfo->value.enumerated.item]);
 572         return 0;
 573 }
 574
 575 static int pcxhr_audio_src_get(struct snd_kcontrol *kcontrol,
 576                                struct snd_ctl_elem_value *ucontrol)
 577 {
 578         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 579         ucontrol->value.enumerated.item[0] = chip->audio_capture_source;
 580         return 0;
 581 }
 582
 583 static int pcxhr_audio_src_put(struct snd_kcontrol *kcontrol,
 584                                struct snd_ctl_elem_value *ucontrol)
 585 {
 586         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 587         int ret = 0;
 588
 589         mutex_lock(&chip->mgr->mixer_mutex);
 590         if (chip->audio_capture_source != ucontrol->value.enumerated.item[0]) {
 591                 chip->audio_capture_source = ucontrol->value.enumerated.item[0];
 592                 pcxhr_set_audio_source(chip);
 593                 ret = 1;
 594         }
 595         mutex_unlock(&chip->mgr->mixer_mutex);
 596         return ret;
 597 }
 598
 599 static struct snd_kcontrol_new pcxhr_control_audio_src = {
 600         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 601         .name =         "Capture Source",
 602         .info =         pcxhr_audio_src_info,
 603         .get =          pcxhr_audio_src_get,
 604         .put =          pcxhr_audio_src_put,
 605 };
 606
 607
 608 /*
 609  * clock type selection
 610  * enum pcxhr_clock_type {
 611  *              PCXHR_CLOCK_TYPE_INTERNAL = 0,
 612  *              PCXHR_CLOCK_TYPE_WORD_CLOCK,
 613  *              PCXHR_CLOCK_TYPE_AES_SYNC,
 614  *              PCXHR_CLOCK_TYPE_AES_1,
 615  *              PCXHR_CLOCK_TYPE_AES_2,
 616  *              PCXHR_CLOCK_TYPE_AES_3,
 617  *              PCXHR_CLOCK_TYPE_AES_4,
 618  *      };
 619  */
 620
 621 static int pcxhr_clock_type_info(struct snd_kcontrol *kcontrol,
 622                                  struct snd_ctl_elem_info *uinfo)
 623 {
 624         static char *texts[7] = {
 625                 "Internal", "WordClock", "AES Sync", "AES 1", "AES 2", "AES 3", "AES 4"
 626         };
 627         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 628         int clock_items = 3 + mgr->capture_chips;
 629
 630         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 631         uinfo->count = 1;
 632         uinfo->value.enumerated.items = clock_items;
 633         if (uinfo->value.enumerated.item >= clock_items)
 634                 uinfo->value.enumerated.item = clock_items-1;
 635         strcpy(uinfo->value.enumerated.name,
 636                 texts[uinfo->value.enumerated.item]);
 637         return 0;
 638 }
 639
 640 static int pcxhr_clock_type_get(struct snd_kcontrol *kcontrol,
 641                                 struct snd_ctl_elem_value *ucontrol)
 642 {
 643         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 644         ucontrol->value.enumerated.item[0] = mgr->use_clock_type;
 645         return 0;
 646 }
 647
 648 static int pcxhr_clock_type_put(struct snd_kcontrol *kcontrol,
 649                                 struct snd_ctl_elem_value *ucontrol)
 650 {
 651         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 652         int rate, ret = 0;
 653
 654         mutex_lock(&mgr->mixer_mutex);
 655         if (mgr->use_clock_type != ucontrol->value.enumerated.item[0]) {
 656                 mutex_lock(&mgr->setup_mutex);
 657                 mgr->use_clock_type = ucontrol->value.enumerated.item[0];
 658                 if (mgr->use_clock_type)
 659                         pcxhr_get_external_clock(mgr, mgr->use_clock_type, &rate);
 660                 else
 661                         rate = mgr->sample_rate;
 662                 if (rate) {
 663                         pcxhr_set_clock(mgr, rate);
 664                         if (mgr->sample_rate)
 665                                 mgr->sample_rate = rate;
 666                 }
 667                 mutex_unlock(&mgr->setup_mutex);
 668                 ret = 1;        /* return 1 even if the set was not done. ok ? */
 669         }
 670         mutex_unlock(&mgr->mixer_mutex);
 671         return ret;
 672 }
 673
 674 static struct snd_kcontrol_new pcxhr_control_clock_type = {
 675         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 676         .name =         "Clock Mode",
 677         .info =         pcxhr_clock_type_info,
 678         .get =          pcxhr_clock_type_get,
 679         .put =          pcxhr_clock_type_put,
 680 };
 681
 682 /*
 683  * clock rate control
 684  * specific control that scans the sample rates on the external plugs
 685  */
 686 static int pcxhr_clock_rate_info(struct snd_kcontrol *kcontrol,
 687                                  struct snd_ctl_elem_info *uinfo)
 688 {
 689         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 690         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 691         uinfo->count = 3 + mgr->capture_chips;
 692         uinfo->value.integer.min = 0;           /* clock not present */
 693         uinfo->value.integer.max = 192000;      /* max sample rate 192 kHz */
 694         return 0;
 695 }
 696
 697 static int pcxhr_clock_rate_get(struct snd_kcontrol *kcontrol,
 698                                 struct snd_ctl_elem_value *ucontrol)
 699 {
 700         struct pcxhr_mgr *mgr = snd_kcontrol_chip(kcontrol);
 701         int i, err, rate;
 702
 703         mutex_lock(&mgr->mixer_mutex);
 704         for(i = 0; i < 3 + mgr->capture_chips; i++) {
 705                 if (i == PCXHR_CLOCK_TYPE_INTERNAL)
 706                         rate = mgr->sample_rate_real;
 707                 else {
 708                         err = pcxhr_get_external_clock(mgr, i, &rate);
 709                         if (err)
 710                                 break;
 711                 }
 712                 ucontrol->value.integer.value[i] = rate;
 713         }
 714         mutex_unlock(&mgr->mixer_mutex);
 715         return 0;
 716 }
 717
 718 static struct snd_kcontrol_new pcxhr_control_clock_rate = {
 719         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 720         .iface =        SNDRV_CTL_ELEM_IFACE_CARD,
 721         .name =         "Clock Rates",
 722         .info =         pcxhr_clock_rate_info,
 723         .get =          pcxhr_clock_rate_get,
 724 };
 725
 726 /*
 727  * IEC958 status bits
 728  */
 729 static int pcxhr_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 730 {
 731         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 732         uinfo->count = 1;
 733         return 0;
 734 }
 735
 736 static int pcxhr_iec958_capture_byte(struct snd_pcxhr *chip, int aes_idx, unsigned char* aes_bits)
 737 {
 738         int i, err;
 739         unsigned char temp;
 740         struct pcxhr_rmh rmh;
 741
 742         pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_READ);
 743         rmh.cmd[0] |= IO_NUM_UER_CHIP_REG;
 744         switch (chip->chip_idx) {
 745         case 0: rmh.cmd[1] = CS8420_01_CS; break;       /* use CS8416_01_CS for AES SYNC plug */
 746         case 1: rmh.cmd[1] = CS8420_23_CS; break;
 747         case 2: rmh.cmd[1] = CS8420_45_CS; break;
 748         case 3: rmh.cmd[1] = CS8420_67_CS; break;
 749         default: return -EINVAL;
 750         }
 751         switch (aes_idx) {
 752         case 0: rmh.cmd[2] = CS8420_CSB0; break;        /* use CS8416_CSBx for AES SYNC plug */
 753         case 1: rmh.cmd[2] = CS8420_CSB1; break;
 754         case 2: rmh.cmd[2] = CS8420_CSB2; break;
 755         case 3: rmh.cmd[2] = CS8420_CSB3; break;
 756         case 4: rmh.cmd[2] = CS8420_CSB4; break;
 757         default: return -EINVAL;
 758         }
 759         rmh.cmd[1] &= 0x0fffff;                 /* size and code the chip id for the fpga */
 760         rmh.cmd[2] &= CHIP_SIG_AND_MAP_SPI;     /* chip signature + map for spi read */
 761         rmh.cmd_len = 3;
 762         err = pcxhr_send_msg(chip->mgr, &rmh);
 763         if (err)
 764                 return err;
 765         temp = 0;
 766         for (i = 0; i < 8; i++) {
 767                 /* attention : reversed bit order (not with CS8416_01_CS) */
 768                 temp <<= 1;
 769                 if (rmh.stat[1] & (1 << i))
 770                         temp |= 1;
 771         }
 772         snd_printdd("read iec958 AES %d byte %d = 0x%x\n", chip->chip_idx, aes_idx, temp);
 773         *aes_bits = temp;
 774         return 0;
 775 }
 776
 777 static int pcxhr_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 778 {
 779         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 780         unsigned char aes_bits;
 781         int i, err;
 782
 783         mutex_lock(&chip->mgr->mixer_mutex);
 784         for(i = 0; i < 5; i++) {
 785                 if (kcontrol->private_value == 0)       /* playback */
 786                         aes_bits = chip->aes_bits[i];
 787                 else {                          /* capture */
 788                         err = pcxhr_iec958_capture_byte(chip, i, &aes_bits);
 789                         if (err)
 790                                 break;
 791                 }
 792                 ucontrol->value.iec958.status[i] = aes_bits;
 793         }
 794         mutex_unlock(&chip->mgr->mixer_mutex);
 795         return 0;
 796 }
 797
 798 static int pcxhr_iec958_mask_get(struct snd_kcontrol *kcontrol,
 799                                  struct snd_ctl_elem_value *ucontrol)
 800 {
 801         int i;
 802         for (i = 0; i < 5; i++)
 803                 ucontrol->value.iec958.status[i] = 0xff;
 804         return 0;
 805 }
 806
 807 static int pcxhr_iec958_update_byte(struct snd_pcxhr *chip, int aes_idx, unsigned char aes_bits)
 808 {
 809         int i, err, cmd;
 810         unsigned char new_bits = aes_bits;
 811         unsigned char old_bits = chip->aes_bits[aes_idx];
 812         struct pcxhr_rmh rmh;
 813
 814         for (i = 0; i < 8; i++) {
 815                 if ((old_bits & 0x01) != (new_bits & 0x01)) {
 816                         cmd = chip->chip_idx & 0x03;            /* chip index 0..3 */
 817                         if(chip->chip_idx > 3)
 818                                 /* new bit used if chip_idx>3 (PCX1222HR) */
 819                                 cmd |= 1 << 22;
 820                         cmd |= ((aes_idx << 3) + i) << 2;       /* add bit offset */
 821                         cmd |= (new_bits & 0x01) << 23;         /* add bit value */
 822                         pcxhr_init_rmh(&rmh, CMD_ACCESS_IO_WRITE);
 823                         rmh.cmd[0] |= IO_NUM_REG_CUER;
 824                         rmh.cmd[1] = cmd;
 825                         rmh.cmd_len = 2;
 826                         snd_printdd("write iec958 AES %d byte %d bit %d (cmd %x)\n",
 827                                     chip->chip_idx, aes_idx, i, cmd);
 828                         err = pcxhr_send_msg(chip->mgr, &rmh);
 829                         if (err)
 830                                 return err;
 831                 }
 832                 old_bits >>= 1;
 833                 new_bits >>= 1;
 834         }
 835         chip->aes_bits[aes_idx] = aes_bits;
 836         return 0;
 837 }
 838
 839 static int pcxhr_iec958_put(struct snd_kcontrol *kcontrol,
 840                             struct snd_ctl_elem_value *ucontrol)
 841 {
 842         struct snd_pcxhr *chip = snd_kcontrol_chip(kcontrol);
 843         int i, changed = 0;
 844
 845         /* playback */
 846         mutex_lock(&chip->mgr->mixer_mutex);
 847         for (i = 0; i < 5; i++) {
 848                 if (ucontrol->value.iec958.status[i] != chip->aes_bits[i]) {
 849                         pcxhr_iec958_update_byte(chip, i, ucontrol->value.iec958.status[i]);
 850                         changed = 1;
 851                 }
 852         }
 853         mutex_unlock(&chip->mgr->mixer_mutex);
 854         return changed;
 855 }
 856
 857 static struct snd_kcontrol_new pcxhr_control_playback_iec958_mask = {
 858         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 859         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 860         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
 861         .info =         pcxhr_iec958_info,
 862         .get =          pcxhr_iec958_mask_get
 863 };
 864 static struct snd_kcontrol_new pcxhr_control_playback_iec958 = {
 865         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 866         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 867         .info =         pcxhr_iec958_info,
 868         .get =          pcxhr_iec958_get,
 869         .put =          pcxhr_iec958_put,
 870         .private_value = 0 /* playback */
 871 };
 872
 873 static struct snd_kcontrol_new pcxhr_control_capture_iec958_mask = {
 874         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 875         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 876         .name =         SNDRV_CTL_NAME_IEC958("",CAPTURE,MASK),
 877         .info =         pcxhr_iec958_info,
 878         .get =          pcxhr_iec958_mask_get
 879 };
 880 static struct snd_kcontrol_new pcxhr_control_capture_iec958 = {
 881         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 882         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 883         .name =         SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
 884         .info =         pcxhr_iec958_info,
 885         .get =          pcxhr_iec958_get,
 886         .private_value = 1 /* capture */
 887 };
 888
 889 static void pcxhr_init_audio_levels(struct snd_pcxhr *chip)
 890 {
 891         int i;
 892
 893         for (i = 0; i < 2; i++) {
 894                 if (chip->nb_streams_play) {
 895                         int j;
 896                         /* at boot time the digital volumes are unmuted 0dB */
 897                         for (j = 0; j < PCXHR_PLAYBACK_STREAMS; j++) {
 898                                 chip->digital_playback_active[j][i] = 1;
 899                                 chip->digital_playback_volume[j][i] = PCXHR_DIGITAL_ZERO_LEVEL;
 900                         }
 901                         /* after boot, only two bits are set on the uer interface */
 902                         chip->aes_bits[0] = IEC958_AES0_PROFESSIONAL | IEC958_AES0_PRO_FS_48000;
 903 /* only for test purpose, remove later */
 904 #ifdef CONFIG_SND_DEBUG
 905                         /* analog volumes for playback (is LEVEL_MIN after boot) */
 906                         chip->analog_playback_active[i] = 1;
 907                         chip->analog_playback_volume[i] = PCXHR_ANALOG_PLAYBACK_ZERO_LEVEL;
 908                         pcxhr_update_analog_audio_level(chip, 0, i);
 909 #endif
 910 /* test end */
 911                 }
 912                 if (chip->nb_streams_capt) {
 913                         /* at boot time the digital volumes are unmuted 0dB */
 914                         chip->digital_capture_volume[i] = PCXHR_DIGITAL_ZERO_LEVEL;
 915 /* only for test purpose, remove later */
 916 #ifdef CONFIG_SND_DEBUG
 917                         /* analog volumes for playback (is LEVEL_MIN after boot) */
 918                         chip->analog_capture_volume[i]  = PCXHR_ANALOG_CAPTURE_ZERO_LEVEL;
 919                         pcxhr_update_analog_audio_level(chip, 1, i);
 920 #endif
 921 /* test end */
 922                 }
 923         }
 924
 925         return;
 926 }
 927
 928
 929 int pcxhr_create_mixer(struct pcxhr_mgr *mgr)
 930 {
 931         struct snd_pcxhr *chip;
 932         int err, i;
 933
 934         mutex_init(&mgr->mixer_mutex); /* can be in another place */
 935
 936         for (i = 0; i < mgr->num_cards; i++) {
 937                 struct snd_kcontrol_new temp;
 938                 chip = mgr->chip[i];
 939
 940                 if (chip->nb_streams_play) {
 941                         /* analog output level control */
 942                         temp = pcxhr_control_analog_level;
 943                         temp.name = "Master Playback Volume";
 944                         temp.private_value = 0; /* playback */
 945                         temp.tlv.p = db_scale_analog_playback;
 946                         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0)
 947                                 return err;
 948                         /* output mute controls */
 949                         if ((err = snd_ctl_add(chip->card,
 950                                                snd_ctl_new1(&pcxhr_control_output_switch,
 951                                                             chip))) < 0)
 952                                 return err;
 953
 954                         temp = snd_pcxhr_pcm_vol;
 955                         temp.name = "PCM Playback Volume";
 956                         temp.count = PCXHR_PLAYBACK_STREAMS;
 957                         temp.private_value = 0; /* playback */
 958                         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0)
 959                                 return err;
 960
 961                         if ((err = snd_ctl_add(chip->card,
 962                                                snd_ctl_new1(&pcxhr_control_pcm_switch,
 963                                                             chip))) < 0)
 964                                 return err;
 965
 966                         /* IEC958 controls */
 967                         if ((err = snd_ctl_add(chip->card,
 968                                                snd_ctl_new1(&pcxhr_control_playback_iec958_mask,
 969                                                             chip))) < 0)
 970                                 return err;
 971                         if ((err = snd_ctl_add(chip->card,
 972                                                snd_ctl_new1(&pcxhr_control_playback_iec958,
 973                                                             chip))) < 0)
 974                                 return err;
 975                 }
 976                 if (chip->nb_streams_capt) {
 977                         /* analog input level control only on first two chips !*/
 978                         temp = pcxhr_control_analog_level;
 979                         temp.name = "Master Capture Volume";
 980                         temp.private_value = 1; /* capture */
 981                         temp.tlv.p = db_scale_analog_capture;
 982                         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0)
 983                                 return err;
 984
 985                         temp = snd_pcxhr_pcm_vol;
 986                         temp.name = "PCM Capture Volume";
 987                         temp.count = 1;
 988                         temp.private_value = 1; /* capture */
 989                         if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&temp, chip))) < 0)
 990                                 return err;
 991                         /* Audio source */
 992                         if ((err = snd_ctl_add(chip->card,
 993                                                snd_ctl_new1(&pcxhr_control_audio_src,
 994                                                             chip))) < 0)
 995                                 return err;
 996                         /* IEC958 controls */
 997                         if ((err = snd_ctl_add(chip->card,
 998                                                snd_ctl_new1(&pcxhr_control_capture_iec958_mask,
 999                                                             chip))) < 0)
1000                                 return err;
1001                         if ((err = snd_ctl_add(chip->card,
1002                                                snd_ctl_new1(&pcxhr_control_capture_iec958,
1003                                                             chip))) < 0)
1004                                 return err;
1005                 }
1006                 /* monitoring only if playback and capture device available */
1007                 if (chip->nb_streams_capt > 0 && chip->nb_streams_play > 0) {
1008                         /* monitoring */
1009                         if ((err = snd_ctl_add(chip->card,
1010                                                snd_ctl_new1(&pcxhr_control_monitor_vol,
1011                                                             chip))) < 0)
1012                                 return err;
1013                         if ((err = snd_ctl_add(chip->card,
1014                                                snd_ctl_new1(&pcxhr_control_monitor_sw,
1015                                                             chip))) < 0)
1016                                 return err;
1017                 }
1018
1019                 if (i == 0) {
1020                         /* clock mode only one control per pcxhr */
1021                         if ((err = snd_ctl_add(chip->card,
1022                                                snd_ctl_new1(&pcxhr_control_clock_type,
1023                                                             mgr))) < 0)
1024                                 return err;
1025                         /* non standard control used to scan the external clock presence/frequencies */
1026                         if ((err = snd_ctl_add(chip->card,
1027                                                snd_ctl_new1(&pcxhr_control_clock_rate,
1028                                                             mgr))) < 0)
1029                                 return err;
1030                 }
1031
1032                 /* init values for the mixer data */
1033                 pcxhr_init_audio_levels(chip);
1034         }
1035
1036         return 0;
1037 }