sound/drivers/vx/vx_mixer.c

   1 /*
   2  * Driver for Digigram VX soundcards
   3  *
   4  * Common mixer part
   5  *
   6  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
   7  *
   8  *   This program is free software; you can redistribute it and/or modify
   9  *   it under the terms of the GNU General Public License as published by
  10  *   the Free Software Foundation; either version 2 of the License, or
  11  *   (at your option) any later version.
  12  *
  13  *   This program is distributed in the hope that it will be useful,
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *   GNU General Public License for more details.
  17  *
  18  *   You should have received a copy of the GNU General Public License
  19  *   along with this program; if not, write to the Free Software
  20  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 #include <sound/core.h>
  24 #include <sound/control.h>
  25 #include <sound/tlv.h>
  26 #include <sound/vx_core.h>
  27 #include "vx_cmd.h"
  28
  29
  30 /*
  31  * write a codec data (24bit)
  32  */
  33 static void vx_write_codec_reg(struct vx_core *chip, int codec, unsigned int data)
  34 {
  35         if (snd_BUG_ON(!chip->ops->write_codec))
  36                 return;
  37
  38         if (chip->chip_status & VX_STAT_IS_STALE)
  39                 return;
  40
  41         mutex_lock(&chip->lock);
  42         chip->ops->write_codec(chip, codec, data);
  43         mutex_unlock(&chip->lock);
  44 }
  45
  46 /*
  47  * Data type used to access the Codec
  48  */
  49 union vx_codec_data {
  50         u32 l;
  51 #ifdef SNDRV_BIG_ENDIAN
  52         struct w {
  53                 u16 h;
  54                 u16 l;
  55         } w;
  56         struct b {
  57                 u8 hh;
  58                 u8 mh;
  59                 u8 ml;
  60                 u8 ll;
  61         } b;
  62 #else /* LITTLE_ENDIAN */
  63         struct w {
  64                 u16 l;
  65                 u16 h;
  66         } w;
  67         struct b {
  68                 u8 ll;
  69                 u8 ml;
  70                 u8 mh;
  71                 u8 hh;
  72         } b;
  73 #endif
  74 };
  75
  76 #define SET_CDC_DATA_SEL(di,s)          ((di).b.mh = (u8) (s))
  77 #define SET_CDC_DATA_REG(di,r)          ((di).b.ml = (u8) (r))
  78 #define SET_CDC_DATA_VAL(di,d)          ((di).b.ll = (u8) (d))
  79 #define SET_CDC_DATA_INIT(di)           ((di).l = 0L, SET_CDC_DATA_SEL(di,XX_CODEC_SELECTOR))
  80
  81 /*
  82  * set up codec register and write the value
  83  * @codec: the codec id, 0 or 1
  84  * @reg: register index
  85  * @val: data value
  86  */
  87 static void vx_set_codec_reg(struct vx_core *chip, int codec, int reg, int val)
  88 {
  89         union vx_codec_data data;
  90         /* DAC control register */
  91         SET_CDC_DATA_INIT(data);
  92         SET_CDC_DATA_REG(data, reg);
  93         SET_CDC_DATA_VAL(data, val);
  94         vx_write_codec_reg(chip, codec, data.l);
  95 }
  96
  97
  98 /*
  99  * vx_set_analog_output_level - set the output attenuation level
 100  * @codec: the output codec, 0 or 1.  (1 for VXP440 only)
 101  * @left: left output level, 0 = mute
 102  * @right: right output level
 103  */
 104 static void vx_set_analog_output_level(struct vx_core *chip, int codec, int left, int right)
 105 {
 106         left  = chip->hw->output_level_max - left;
 107         right = chip->hw->output_level_max - right;
 108
 109         if (chip->ops->akm_write) {
 110                 chip->ops->akm_write(chip, XX_CODEC_LEVEL_LEFT_REGISTER, left);
 111                 chip->ops->akm_write(chip, XX_CODEC_LEVEL_RIGHT_REGISTER, right);
 112         } else {
 113                 /* convert to attenuation level: 0 = 0dB (max), 0xe3 = -113.5 dB (min) */
 114                 vx_set_codec_reg(chip, codec, XX_CODEC_LEVEL_LEFT_REGISTER, left);
 115                 vx_set_codec_reg(chip, codec, XX_CODEC_LEVEL_RIGHT_REGISTER, right);
 116         }
 117 }
 118
 119
 120 /*
 121  * vx_toggle_dac_mute -  mute/unmute DAC
 122  * @mute: 0 = unmute, 1 = mute
 123  */
 124
 125 #define DAC_ATTEN_MIN   0x08
 126 #define DAC_ATTEN_MAX   0x38
 127
 128 void vx_toggle_dac_mute(struct vx_core *chip, int mute)
 129 {
 130         unsigned int i;
 131         for (i = 0; i < chip->hw->num_codecs; i++) {
 132                 if (chip->ops->akm_write)
 133                         chip->ops->akm_write(chip, XX_CODEC_DAC_CONTROL_REGISTER, mute); /* XXX */
 134                 else
 135                         vx_set_codec_reg(chip, i, XX_CODEC_DAC_CONTROL_REGISTER,
 136                                          mute ? DAC_ATTEN_MAX : DAC_ATTEN_MIN);
 137         }
 138 }
 139
 140 /*
 141  * vx_reset_codec - reset and initialize the codecs
 142  */
 143 void vx_reset_codec(struct vx_core *chip, int cold_reset)
 144 {
 145         unsigned int i;
 146         int port = chip->type >= VX_TYPE_VXPOCKET ? 0x75 : 0x65;
 147
 148         chip->ops->reset_codec(chip);
 149
 150         /* AKM codecs should be initialized in reset_codec callback */
 151         if (! chip->ops->akm_write) {
 152                 /* initialize old codecs */
 153                 for (i = 0; i < chip->hw->num_codecs; i++) {
 154                         /* DAC control register (change level when zero crossing + mute) */
 155                         vx_set_codec_reg(chip, i, XX_CODEC_DAC_CONTROL_REGISTER, DAC_ATTEN_MAX);
 156                         /* ADC control register */
 157                         vx_set_codec_reg(chip, i, XX_CODEC_ADC_CONTROL_REGISTER, 0x00);
 158                         /* Port mode register */
 159                         vx_set_codec_reg(chip, i, XX_CODEC_PORT_MODE_REGISTER, port);
 160                         /* Clock control register */
 161                         vx_set_codec_reg(chip, i, XX_CODEC_CLOCK_CONTROL_REGISTER, 0x00);
 162                 }
 163         }
 164
 165         /* mute analog output */
 166         for (i = 0; i < chip->hw->num_codecs; i++) {
 167                 chip->output_level[i][0] = 0;
 168                 chip->output_level[i][1] = 0;
 169                 vx_set_analog_output_level(chip, i, 0, 0);
 170         }
 171 }
 172
 173 /*
 174  * change the audio input source
 175  * @src: the target source (VX_AUDIO_SRC_XXX)
 176  */
 177 static void vx_change_audio_source(struct vx_core *chip, int src)
 178 {
 179         if (chip->chip_status & VX_STAT_IS_STALE)
 180                 return;
 181
 182         mutex_lock(&chip->lock);
 183         chip->ops->change_audio_source(chip, src);
 184         mutex_unlock(&chip->lock);
 185 }
 186
 187
 188 /*
 189  * change the audio source if necessary and possible
 190  * returns 1 if the source is actually changed.
 191  */
 192 int vx_sync_audio_source(struct vx_core *chip)
 193 {
 194         if (chip->audio_source_target == chip->audio_source ||
 195             chip->pcm_running)
 196                 return 0;
 197         vx_change_audio_source(chip, chip->audio_source_target);
 198         chip->audio_source = chip->audio_source_target;
 199         return 1;
 200 }
 201
 202
 203 /*
 204  * audio level, mute, monitoring
 205  */
 206 struct vx_audio_level {
 207         unsigned int has_level: 1;
 208         unsigned int has_monitor_level: 1;
 209         unsigned int has_mute: 1;
 210         unsigned int has_monitor_mute: 1;
 211         unsigned int mute;
 212         unsigned int monitor_mute;
 213         short level;
 214         short monitor_level;
 215 };
 216
 217 static int vx_adjust_audio_level(struct vx_core *chip, int audio, int capture,
 218                                  struct vx_audio_level *info)
 219 {
 220         struct vx_rmh rmh;
 221
 222         if (chip->chip_status & VX_STAT_IS_STALE)
 223                 return -EBUSY;
 224
 225         vx_init_rmh(&rmh, CMD_AUDIO_LEVEL_ADJUST);
 226         if (capture)
 227                 rmh.Cmd[0] |= COMMAND_RECORD_MASK;
 228         /* Add Audio IO mask */
 229         rmh.Cmd[1] = 1 << audio;
 230         rmh.Cmd[2] = 0;
 231         if (info->has_level) {
 232                 rmh.Cmd[0] |=  VALID_AUDIO_IO_DIGITAL_LEVEL;
 233                 rmh.Cmd[2] |= info->level;
 234         }
 235         if (info->has_monitor_level) {
 236                 rmh.Cmd[0] |=  VALID_AUDIO_IO_MONITORING_LEVEL;
 237                 rmh.Cmd[2] |= ((unsigned int)info->monitor_level << 10);
 238         }
 239         if (info->has_mute) {
 240                 rmh.Cmd[0] |= VALID_AUDIO_IO_MUTE_LEVEL;
 241                 if (info->mute)
 242                         rmh.Cmd[2] |= AUDIO_IO_HAS_MUTE_LEVEL;
 243         }
 244         if (info->has_monitor_mute) {
 245                 /* validate flag for M2 at least to unmute it */
 246                 rmh.Cmd[0] |=  VALID_AUDIO_IO_MUTE_MONITORING_1 | VALID_AUDIO_IO_MUTE_MONITORING_2;
 247                 if (info->monitor_mute)
 248                         rmh.Cmd[2] |= AUDIO_IO_HAS_MUTE_MONITORING_1;
 249         }
 250
 251         return vx_send_msg(chip, &rmh);
 252 }
 253
 254
 255 #if 0 // not used
 256 static int vx_read_audio_level(struct vx_core *chip, int audio, int capture,
 257                                struct vx_audio_level *info)
 258 {
 259         int err;
 260         struct vx_rmh rmh;
 261
 262         memset(info, 0, sizeof(*info));
 263         vx_init_rmh(&rmh, CMD_GET_AUDIO_LEVELS);
 264         if (capture)
 265                 rmh.Cmd[0] |= COMMAND_RECORD_MASK;
 266         /* Add Audio IO mask */
 267         rmh.Cmd[1] = 1 << audio;
 268         err = vx_send_msg(chip, &rmh);
 269         if (err < 0)
 270                 return err;
 271         info.level = rmh.Stat[0] & MASK_DSP_WORD_LEVEL;
 272         info.monitor_level = (rmh.Stat[0] >> 10) & MASK_DSP_WORD_LEVEL;
 273         info.mute = (rmh.Stat[i] & AUDIO_IO_HAS_MUTE_LEVEL) ? 1 : 0;
 274         info.monitor_mute = (rmh.Stat[i] & AUDIO_IO_HAS_MUTE_MONITORING_1) ? 1 : 0;
 275         return 0;
 276 }
 277 #endif // not used
 278
 279 /*
 280  * set the monitoring level and mute state of the given audio
 281  * no more static, because must be called from vx_pcm to demute monitoring
 282  */
 283 int vx_set_monitor_level(struct vx_core *chip, int audio, int level, int active)
 284 {
 285         struct vx_audio_level info;
 286
 287         memset(&info, 0, sizeof(info));
 288         info.has_monitor_level = 1;
 289         info.monitor_level = level;
 290         info.has_monitor_mute = 1;
 291         info.monitor_mute = !active;
 292         chip->audio_monitor[audio] = level;
 293         chip->audio_monitor_active[audio] = active;
 294         return vx_adjust_audio_level(chip, audio, 0, &info); /* playback only */
 295 }
 296
 297
 298 /*
 299  * set the mute status of the given audio
 300  */
 301 static int vx_set_audio_switch(struct vx_core *chip, int audio, int active)
 302 {
 303         struct vx_audio_level info;
 304
 305         memset(&info, 0, sizeof(info));
 306         info.has_mute = 1;
 307         info.mute = !active;
 308         chip->audio_active[audio] = active;
 309         return vx_adjust_audio_level(chip, audio, 0, &info); /* playback only */
 310 }
 311
 312 /*
 313  * set the mute status of the given audio
 314  */
 315 static int vx_set_audio_gain(struct vx_core *chip, int audio, int capture, int level)
 316 {
 317         struct vx_audio_level info;
 318
 319         memset(&info, 0, sizeof(info));
 320         info.has_level = 1;
 321         info.level = level;
 322         chip->audio_gain[capture][audio] = level;
 323         return vx_adjust_audio_level(chip, audio, capture, &info);
 324 }
 325
 326 /*
 327  * reset all audio levels
 328  */
 329 static void vx_reset_audio_levels(struct vx_core *chip)
 330 {
 331         unsigned int i, c;
 332         struct vx_audio_level info;
 333
 334         memset(chip->audio_gain, 0, sizeof(chip->audio_gain));
 335         memset(chip->audio_active, 0, sizeof(chip->audio_active));
 336         memset(chip->audio_monitor, 0, sizeof(chip->audio_monitor));
 337         memset(chip->audio_monitor_active, 0, sizeof(chip->audio_monitor_active));
 338
 339         for (c = 0; c < 2; c++) {
 340                 for (i = 0; i < chip->hw->num_ins * 2; i++) {
 341                         memset(&info, 0, sizeof(info));
 342                         if (c == 0) {
 343                                 info.has_monitor_level = 1;
 344                                 info.has_mute = 1;
 345                                 info.has_monitor_mute = 1;
 346                         }
 347                         info.has_level = 1;
 348                         info.level = CVAL_0DB; /* default: 0dB */
 349                         vx_adjust_audio_level(chip, i, c, &info);
 350                         chip->audio_gain[c][i] = CVAL_0DB;
 351                         chip->audio_monitor[i] = CVAL_0DB;
 352                 }
 353         }
 354 }
 355
 356
 357 /*
 358  * VU, peak meter record
 359  */
 360
 361 #define VU_METER_CHANNELS       2
 362
 363 struct vx_vu_meter {
 364         int saturated;
 365         int vu_level;
 366         int peak_level;
 367 };
 368
 369 /*
 370  * get the VU and peak meter values
 371  * @audio: the audio index
 372  * @capture: 0 = playback, 1 = capture operation
 373  * @info: the array of vx_vu_meter records (size = 2).
 374  */
 375 static int vx_get_audio_vu_meter(struct vx_core *chip, int audio, int capture, struct vx_vu_meter *info)
 376 {
 377         struct vx_rmh rmh;
 378         int i, err;
 379
 380         if (chip->chip_status & VX_STAT_IS_STALE)
 381                 return -EBUSY;
 382
 383         vx_init_rmh(&rmh, CMD_AUDIO_VU_PIC_METER);
 384         rmh.LgStat += 2 * VU_METER_CHANNELS;
 385         if (capture)
 386                 rmh.Cmd[0] |= COMMAND_RECORD_MASK;
 387
 388         /* Add Audio IO mask */
 389         rmh.Cmd[1] = 0;
 390         for (i = 0; i < VU_METER_CHANNELS; i++)
 391                 rmh.Cmd[1] |= 1 << (audio + i);
 392         err = vx_send_msg(chip, &rmh);
 393         if (err < 0)
 394                 return err;
 395         /* Read response */
 396         for (i = 0; i < 2 * VU_METER_CHANNELS; i +=2) {
 397                 info->saturated = (rmh.Stat[0] & (1 << (audio + i))) ? 1 : 0;
 398                 info->vu_level = rmh.Stat[i + 1];
 399                 info->peak_level = rmh.Stat[i + 2];
 400                 info++;
 401         }
 402         return 0;
 403 }
 404
 405
 406 /*
 407  * control API entries
 408  */
 409
 410 /*
 411  * output level control
 412  */
 413 static int vx_output_level_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 414 {
 415         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 416         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 417         uinfo->count = 2;
 418         uinfo->value.integer.min = 0;
 419         uinfo->value.integer.max = chip->hw->output_level_max;
 420         return 0;
 421 }
 422
 423 static int vx_output_level_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 424 {
 425         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 426         int codec = kcontrol->id.index;
 427         mutex_lock(&chip->mixer_mutex);
 428         ucontrol->value.integer.value[0] = chip->output_level[codec][0];
 429         ucontrol->value.integer.value[1] = chip->output_level[codec][1];
 430         mutex_unlock(&chip->mixer_mutex);
 431         return 0;
 432 }
 433
 434 static int vx_output_level_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 435 {
 436         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 437         int codec = kcontrol->id.index;
 438         unsigned int val[2], vmax;
 439
 440         vmax = chip->hw->output_level_max;
 441         val[0] = ucontrol->value.integer.value[0];
 442         val[1] = ucontrol->value.integer.value[1];
 443         if (val[0] > vmax || val[1] > vmax)
 444                 return -EINVAL;
 445         mutex_lock(&chip->mixer_mutex);
 446         if (val[0] != chip->output_level[codec][0] ||
 447             val[1] != chip->output_level[codec][1]) {
 448                 vx_set_analog_output_level(chip, codec, val[0], val[1]);
 449                 chip->output_level[codec][0] = val[0];
 450                 chip->output_level[codec][1] = val[1];
 451                 mutex_unlock(&chip->mixer_mutex);
 452                 return 1;
 453         }
 454         mutex_unlock(&chip->mixer_mutex);
 455         return 0;
 456 }
 457
 458 static struct snd_kcontrol_new vx_control_output_level = {
 459         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 460         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 461                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 462         .name =         "Master Playback Volume",
 463         .info =         vx_output_level_info,
 464         .get =          vx_output_level_get,
 465         .put =          vx_output_level_put,
 466         /* tlv will be filled later */
 467 };
 468
 469 /*
 470  * audio source select
 471  */
 472 static int vx_audio_src_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 473 {
 474         static char *texts_mic[3] = {
 475                 "Digital", "Line", "Mic"
 476         };
 477         static char *texts_vx2[2] = {
 478                 "Digital", "Analog"
 479         };
 480         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 481
 482         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 483         uinfo->count = 1;
 484         if (chip->type >= VX_TYPE_VXPOCKET) {
 485                 uinfo->value.enumerated.items = 3;
 486                 if (uinfo->value.enumerated.item > 2)
 487                         uinfo->value.enumerated.item = 2;
 488                 strcpy(uinfo->value.enumerated.name,
 489                        texts_mic[uinfo->value.enumerated.item]);
 490         } else {
 491                 uinfo->value.enumerated.items = 2;
 492                 if (uinfo->value.enumerated.item > 1)
 493                         uinfo->value.enumerated.item = 1;
 494                 strcpy(uinfo->value.enumerated.name,
 495                        texts_vx2[uinfo->value.enumerated.item]);
 496         }
 497         return 0;
 498 }
 499
 500 static int vx_audio_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 501 {
 502         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 503         ucontrol->value.enumerated.item[0] = chip->audio_source_target;
 504         return 0;
 505 }
 506
 507 static int vx_audio_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 508 {
 509         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 510
 511         if (chip->type >= VX_TYPE_VXPOCKET) {
 512                 if (ucontrol->value.enumerated.item[0] > 2)
 513                         return -EINVAL;
 514         } else {
 515                 if (ucontrol->value.enumerated.item[0] > 1)
 516                         return -EINVAL;
 517         }
 518         mutex_lock(&chip->mixer_mutex);
 519         if (chip->audio_source_target != ucontrol->value.enumerated.item[0]) {
 520                 chip->audio_source_target = ucontrol->value.enumerated.item[0];
 521                 vx_sync_audio_source(chip);
 522                 mutex_unlock(&chip->mixer_mutex);
 523                 return 1;
 524         }
 525         mutex_unlock(&chip->mixer_mutex);
 526         return 0;
 527 }
 528
 529 static struct snd_kcontrol_new vx_control_audio_src = {
 530         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 531         .name =         "Capture Source",
 532         .info =         vx_audio_src_info,
 533         .get =          vx_audio_src_get,
 534         .put =          vx_audio_src_put,
 535 };
 536
 537 /*
 538  * clock mode selection
 539  */
 540 static int vx_clock_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 541 {
 542         static char *texts[3] = {
 543                 "Auto", "Internal", "External"
 544         };
 545
 546         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 547         uinfo->count = 1;
 548         uinfo->value.enumerated.items = 3;
 549         if (uinfo->value.enumerated.item > 2)
 550                 uinfo->value.enumerated.item = 2;
 551         strcpy(uinfo->value.enumerated.name,
 552                texts[uinfo->value.enumerated.item]);
 553         return 0;
 554 }
 555
 556 static int vx_clock_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 557 {
 558         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 559         ucontrol->value.enumerated.item[0] = chip->clock_mode;
 560         return 0;
 561 }
 562
 563 static int vx_clock_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 564 {
 565         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 566
 567         if (ucontrol->value.enumerated.item[0] > 2)
 568                 return -EINVAL;
 569         mutex_lock(&chip->mixer_mutex);
 570         if (chip->clock_mode != ucontrol->value.enumerated.item[0]) {
 571                 chip->clock_mode = ucontrol->value.enumerated.item[0];
 572                 vx_set_clock(chip, chip->freq);
 573                 mutex_unlock(&chip->mixer_mutex);
 574                 return 1;
 575         }
 576         mutex_unlock(&chip->mixer_mutex);
 577         return 0;
 578 }
 579
 580 static struct snd_kcontrol_new vx_control_clock_mode = {
 581         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 582         .name =         "Clock Mode",
 583         .info =         vx_clock_mode_info,
 584         .get =          vx_clock_mode_get,
 585         .put =          vx_clock_mode_put,
 586 };
 587
 588 /*
 589  * Audio Gain
 590  */
 591 static int vx_audio_gain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 592 {
 593         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 594         uinfo->count = 2;
 595         uinfo->value.integer.min = 0;
 596         uinfo->value.integer.max = CVAL_MAX;
 597         return 0;
 598 }
 599
 600 static int vx_audio_gain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 601 {
 602         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 603         int audio = kcontrol->private_value & 0xff;
 604         int capture = (kcontrol->private_value >> 8) & 1;
 605
 606         mutex_lock(&chip->mixer_mutex);
 607         ucontrol->value.integer.value[0] = chip->audio_gain[capture][audio];
 608         ucontrol->value.integer.value[1] = chip->audio_gain[capture][audio+1];
 609         mutex_unlock(&chip->mixer_mutex);
 610         return 0;
 611 }
 612
 613 static int vx_audio_gain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 614 {
 615         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 616         int audio = kcontrol->private_value & 0xff;
 617         int capture = (kcontrol->private_value >> 8) & 1;
 618         unsigned int val[2];
 619
 620         val[0] = ucontrol->value.integer.value[0];
 621         val[1] = ucontrol->value.integer.value[1];
 622         if (val[0] > CVAL_MAX || val[1] > CVAL_MAX)
 623                 return -EINVAL;
 624         mutex_lock(&chip->mixer_mutex);
 625         if (val[0] != chip->audio_gain[capture][audio] ||
 626             val[1] != chip->audio_gain[capture][audio+1]) {
 627                 vx_set_audio_gain(chip, audio, capture, val[0]);
 628                 vx_set_audio_gain(chip, audio+1, capture, val[1]);
 629                 mutex_unlock(&chip->mixer_mutex);
 630                 return 1;
 631         }
 632         mutex_unlock(&chip->mixer_mutex);
 633         return 0;
 634 }
 635
 636 static int vx_audio_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 637 {
 638         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 639         int audio = kcontrol->private_value & 0xff;
 640
 641         mutex_lock(&chip->mixer_mutex);
 642         ucontrol->value.integer.value[0] = chip->audio_monitor[audio];
 643         ucontrol->value.integer.value[1] = chip->audio_monitor[audio+1];
 644         mutex_unlock(&chip->mixer_mutex);
 645         return 0;
 646 }
 647
 648 static int vx_audio_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 649 {
 650         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 651         int audio = kcontrol->private_value & 0xff;
 652         unsigned int val[2];
 653
 654         val[0] = ucontrol->value.integer.value[0];
 655         val[1] = ucontrol->value.integer.value[1];
 656         if (val[0] > CVAL_MAX || val[1] > CVAL_MAX)
 657                 return -EINVAL;
 658
 659         mutex_lock(&chip->mixer_mutex);
 660         if (val[0] != chip->audio_monitor[audio] ||
 661             val[1] != chip->audio_monitor[audio+1]) {
 662                 vx_set_monitor_level(chip, audio, val[0],
 663                                      chip->audio_monitor_active[audio]);
 664                 vx_set_monitor_level(chip, audio+1, val[1],
 665                                      chip->audio_monitor_active[audio+1]);
 666                 mutex_unlock(&chip->mixer_mutex);
 667                 return 1;
 668         }
 669         mutex_unlock(&chip->mixer_mutex);
 670         return 0;
 671 }
 672
 673 #define vx_audio_sw_info        snd_ctl_boolean_stereo_info
 674
 675 static int vx_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 676 {
 677         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 678         int audio = kcontrol->private_value & 0xff;
 679
 680         mutex_lock(&chip->mixer_mutex);
 681         ucontrol->value.integer.value[0] = chip->audio_active[audio];
 682         ucontrol->value.integer.value[1] = chip->audio_active[audio+1];
 683         mutex_unlock(&chip->mixer_mutex);
 684         return 0;
 685 }
 686
 687 static int vx_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 688 {
 689         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 690         int audio = kcontrol->private_value & 0xff;
 691
 692         mutex_lock(&chip->mixer_mutex);
 693         if (ucontrol->value.integer.value[0] != chip->audio_active[audio] ||
 694             ucontrol->value.integer.value[1] != chip->audio_active[audio+1]) {
 695                 vx_set_audio_switch(chip, audio,
 696                                     !!ucontrol->value.integer.value[0]);
 697                 vx_set_audio_switch(chip, audio+1,
 698                                     !!ucontrol->value.integer.value[1]);
 699                 mutex_unlock(&chip->mixer_mutex);
 700                 return 1;
 701         }
 702         mutex_unlock(&chip->mixer_mutex);
 703         return 0;
 704 }
 705
 706 static int vx_monitor_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 707 {
 708         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 709         int audio = kcontrol->private_value & 0xff;
 710
 711         mutex_lock(&chip->mixer_mutex);
 712         ucontrol->value.integer.value[0] = chip->audio_monitor_active[audio];
 713         ucontrol->value.integer.value[1] = chip->audio_monitor_active[audio+1];
 714         mutex_unlock(&chip->mixer_mutex);
 715         return 0;
 716 }
 717
 718 static int vx_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 719 {
 720         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 721         int audio = kcontrol->private_value & 0xff;
 722
 723         mutex_lock(&chip->mixer_mutex);
 724         if (ucontrol->value.integer.value[0] != chip->audio_monitor_active[audio] ||
 725             ucontrol->value.integer.value[1] != chip->audio_monitor_active[audio+1]) {
 726                 vx_set_monitor_level(chip, audio, chip->audio_monitor[audio],
 727                                      !!ucontrol->value.integer.value[0]);
 728                 vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1],
 729                                      !!ucontrol->value.integer.value[1]);
 730                 mutex_unlock(&chip->mixer_mutex);
 731                 return 1;
 732         }
 733         mutex_unlock(&chip->mixer_mutex);
 734         return 0;
 735 }
 736
 737 static const DECLARE_TLV_DB_SCALE(db_scale_audio_gain, -10975, 25, 0);
 738
 739 static struct snd_kcontrol_new vx_control_audio_gain = {
 740         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 741         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 742                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 743         /* name will be filled later */
 744         .info =         vx_audio_gain_info,
 745         .get =          vx_audio_gain_get,
 746         .put =          vx_audio_gain_put,
 747         .tlv = { .p = db_scale_audio_gain },
 748 };
 749 static struct snd_kcontrol_new vx_control_output_switch = {
 750         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 751         .name =         "PCM Playback Switch",
 752         .info =         vx_audio_sw_info,
 753         .get =          vx_audio_sw_get,
 754         .put =          vx_audio_sw_put
 755 };
 756 static struct snd_kcontrol_new vx_control_monitor_gain = {
 757         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 758         .name =         "Monitoring Volume",
 759         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 760                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 761         .info =         vx_audio_gain_info,     /* shared */
 762         .get =          vx_audio_monitor_get,
 763         .put =          vx_audio_monitor_put,
 764         .tlv = { .p = db_scale_audio_gain },
 765 };
 766 static struct snd_kcontrol_new vx_control_monitor_switch = {
 767         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 768         .name =         "Monitoring Switch",
 769         .info =         vx_audio_sw_info,       /* shared */
 770         .get =          vx_monitor_sw_get,
 771         .put =          vx_monitor_sw_put
 772 };
 773
 774
 775 /*
 776  * IEC958 status bits
 777  */
 778 static int vx_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 779 {
 780         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 781         uinfo->count = 1;
 782         return 0;
 783 }
 784
 785 static int vx_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 786 {
 787         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 788
 789         mutex_lock(&chip->mixer_mutex);
 790         ucontrol->value.iec958.status[0] = (chip->uer_bits >> 0) & 0xff;
 791         ucontrol->value.iec958.status[1] = (chip->uer_bits >> 8) & 0xff;
 792         ucontrol->value.iec958.status[2] = (chip->uer_bits >> 16) & 0xff;
 793         ucontrol->value.iec958.status[3] = (chip->uer_bits >> 24) & 0xff;
 794         mutex_unlock(&chip->mixer_mutex);
 795         return 0;
 796 }
 797
 798 static int vx_iec958_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 799 {
 800         ucontrol->value.iec958.status[0] = 0xff;
 801         ucontrol->value.iec958.status[1] = 0xff;
 802         ucontrol->value.iec958.status[2] = 0xff;
 803         ucontrol->value.iec958.status[3] = 0xff;
 804         return 0;
 805 }
 806
 807 static int vx_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 808 {
 809         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 810         unsigned int val;
 811
 812         val = (ucontrol->value.iec958.status[0] << 0) |
 813               (ucontrol->value.iec958.status[1] << 8) |
 814               (ucontrol->value.iec958.status[2] << 16) |
 815               (ucontrol->value.iec958.status[3] << 24);
 816         mutex_lock(&chip->mixer_mutex);
 817         if (chip->uer_bits != val) {
 818                 chip->uer_bits = val;
 819                 vx_set_iec958_status(chip, val);
 820                 mutex_unlock(&chip->mixer_mutex);
 821                 return 1;
 822         }
 823         mutex_unlock(&chip->mixer_mutex);
 824         return 0;
 825 }
 826
 827 static struct snd_kcontrol_new vx_control_iec958_mask = {
 828         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 829         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 830         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
 831         .info =         vx_iec958_info, /* shared */
 832         .get =          vx_iec958_mask_get,
 833 };
 834
 835 static struct snd_kcontrol_new vx_control_iec958 = {
 836         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 837         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 838         .info =         vx_iec958_info,
 839         .get =          vx_iec958_get,
 840         .put =          vx_iec958_put
 841 };
 842
 843
 844 /*
 845  * VU meter
 846  */
 847
 848 #define METER_MAX       0xff
 849 #define METER_SHIFT     16
 850
 851 static int vx_vu_meter_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 852 {
 853         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 854         uinfo->count = 2;
 855         uinfo->value.integer.min = 0;
 856         uinfo->value.integer.max = METER_MAX;
 857         return 0;
 858 }
 859
 860 static int vx_vu_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 861 {
 862         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 863         struct vx_vu_meter meter[2];
 864         int audio = kcontrol->private_value & 0xff;
 865         int capture = (kcontrol->private_value >> 8) & 1;
 866
 867         vx_get_audio_vu_meter(chip, audio, capture, meter);
 868         ucontrol->value.integer.value[0] = meter[0].vu_level >> METER_SHIFT;
 869         ucontrol->value.integer.value[1] = meter[1].vu_level >> METER_SHIFT;
 870         return 0;
 871 }
 872
 873 static int vx_peak_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 874 {
 875         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 876         struct vx_vu_meter meter[2];
 877         int audio = kcontrol->private_value & 0xff;
 878         int capture = (kcontrol->private_value >> 8) & 1;
 879
 880         vx_get_audio_vu_meter(chip, audio, capture, meter);
 881         ucontrol->value.integer.value[0] = meter[0].peak_level >> METER_SHIFT;
 882         ucontrol->value.integer.value[1] = meter[1].peak_level >> METER_SHIFT;
 883         return 0;
 884 }
 885
 886 #define vx_saturation_info      snd_ctl_boolean_stereo_info
 887
 888 static int vx_saturation_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 889 {
 890         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 891         struct vx_vu_meter meter[2];
 892         int audio = kcontrol->private_value & 0xff;
 893
 894         vx_get_audio_vu_meter(chip, audio, 1, meter); /* capture only */
 895         ucontrol->value.integer.value[0] = meter[0].saturated;
 896         ucontrol->value.integer.value[1] = meter[1].saturated;
 897         return 0;
 898 }
 899
 900 static struct snd_kcontrol_new vx_control_vu_meter = {
 901         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 902         .access =       SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
 903         /* name will be filled later */
 904         .info =         vx_vu_meter_info,
 905         .get =          vx_vu_meter_get,
 906 };
 907
 908 static struct snd_kcontrol_new vx_control_peak_meter = {
 909         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 910         .access =       SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
 911         /* name will be filled later */
 912         .info =         vx_vu_meter_info,       /* shared */
 913         .get =          vx_peak_meter_get,
 914 };
 915
 916 static struct snd_kcontrol_new vx_control_saturation = {
 917         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 918         .name =         "Input Saturation",
 919         .access =       SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
 920         .info =         vx_saturation_info,
 921         .get =          vx_saturation_get,
 922 };
 923
 924
 925
 926 /*
 927  *
 928  */
 929
 930 int snd_vx_mixer_new(struct vx_core *chip)
 931 {
 932         unsigned int i, c;
 933         int err;
 934         struct snd_kcontrol_new temp;
 935         struct snd_card *card = chip->card;
 936         char name[32];
 937
 938         strcpy(card->mixername, card->driver);
 939
 940         /* output level controls */
 941         for (i = 0; i < chip->hw->num_outs; i++) {
 942                 temp = vx_control_output_level;
 943                 temp.index = i;
 944                 temp.tlv.p = chip->hw->output_level_db_scale;
 945                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 946                         return err;
 947         }
 948
 949         /* PCM volumes, switches, monitoring */
 950         for (i = 0; i < chip->hw->num_outs; i++) {
 951                 int val = i * 2;
 952                 temp = vx_control_audio_gain;
 953                 temp.index = i;
 954                 temp.name = "PCM Playback Volume";
 955                 temp.private_value = val;
 956                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 957                         return err;
 958                 temp = vx_control_output_switch;
 959                 temp.index = i;
 960                 temp.private_value = val;
 961                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 962                         return err;
 963                 temp = vx_control_monitor_gain;
 964                 temp.index = i;
 965                 temp.private_value = val;
 966                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 967                         return err;
 968                 temp = vx_control_monitor_switch;
 969                 temp.index = i;
 970                 temp.private_value = val;
 971                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 972                         return err;
 973         }
 974         for (i = 0; i < chip->hw->num_outs; i++) {
 975                 temp = vx_control_audio_gain;
 976                 temp.index = i;
 977                 temp.name = "PCM Capture Volume";
 978                 temp.private_value = (i * 2) | (1 << 8);
 979                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 980                         return err;
 981         }
 982
 983         /* Audio source */
 984         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_audio_src, chip))) < 0)
 985                 return err;
 986         /* clock mode */
 987         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_clock_mode, chip))) < 0)
 988                 return err;
 989         /* IEC958 controls */
 990         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958_mask, chip))) < 0)
 991                 return err;
 992         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958, chip))) < 0)
 993                 return err;
 994         /* VU, peak, saturation meters */
 995         for (c = 0; c < 2; c++) {
 996                 static char *dir[2] = { "Output", "Input" };
 997                 for (i = 0; i < chip->hw->num_ins; i++) {
 998                         int val = (i * 2) | (c << 8);
 999                         if (c == 1) {
1000                                 temp = vx_control_saturation;
1001                                 temp.index = i;
1002                                 temp.private_value = val;
1003                                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
1004                                         return err;
1005                         }
1006                         sprintf(name, "%s VU Meter", dir[c]);
1007                         temp = vx_control_vu_meter;
1008                         temp.index = i;
1009                         temp.name = name;
1010                         temp.private_value = val;
1011                         if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
1012                                 return err;
1013                         sprintf(name, "%s Peak Meter", dir[c]);
1014                         temp = vx_control_peak_meter;
1015                         temp.index = i;
1016                         temp.name = name;
1017                         temp.private_value = val;
1018                         if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
1019                                 return err;
1020                 }
1021         }
1022         vx_reset_audio_levels(chip);
1023         return 0;
1024 }