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 const char * const texts_mic[3] = {
 475                 "Digital", "Line", "Mic"
 476         };
 477         static const char * const texts_vx2[2] = {
 478                 "Digital", "Analog"
 479         };
 480         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 481
 482         if (chip->type >= VX_TYPE_VXPOCKET)
 483                 return snd_ctl_enum_info(uinfo, 1, 3, texts_mic);
 484         else
 485                 return snd_ctl_enum_info(uinfo, 1, 2, texts_vx2);
 486 }
 487
 488 static int vx_audio_src_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 489 {
 490         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 491         ucontrol->value.enumerated.item[0] = chip->audio_source_target;
 492         return 0;
 493 }
 494
 495 static int vx_audio_src_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 496 {
 497         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 498
 499         if (chip->type >= VX_TYPE_VXPOCKET) {
 500                 if (ucontrol->value.enumerated.item[0] > 2)
 501                         return -EINVAL;
 502         } else {
 503                 if (ucontrol->value.enumerated.item[0] > 1)
 504                         return -EINVAL;
 505         }
 506         mutex_lock(&chip->mixer_mutex);
 507         if (chip->audio_source_target != ucontrol->value.enumerated.item[0]) {
 508                 chip->audio_source_target = ucontrol->value.enumerated.item[0];
 509                 vx_sync_audio_source(chip);
 510                 mutex_unlock(&chip->mixer_mutex);
 511                 return 1;
 512         }
 513         mutex_unlock(&chip->mixer_mutex);
 514         return 0;
 515 }
 516
 517 static struct snd_kcontrol_new vx_control_audio_src = {
 518         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 519         .name =         "Capture Source",
 520         .info =         vx_audio_src_info,
 521         .get =          vx_audio_src_get,
 522         .put =          vx_audio_src_put,
 523 };
 524
 525 /*
 526  * clock mode selection
 527  */
 528 static int vx_clock_mode_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 529 {
 530         static const char * const texts[3] = {
 531                 "Auto", "Internal", "External"
 532         };
 533
 534         return snd_ctl_enum_info(uinfo, 1, 3, texts);
 535 }
 536
 537 static int vx_clock_mode_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 538 {
 539         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 540         ucontrol->value.enumerated.item[0] = chip->clock_mode;
 541         return 0;
 542 }
 543
 544 static int vx_clock_mode_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 545 {
 546         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 547
 548         if (ucontrol->value.enumerated.item[0] > 2)
 549                 return -EINVAL;
 550         mutex_lock(&chip->mixer_mutex);
 551         if (chip->clock_mode != ucontrol->value.enumerated.item[0]) {
 552                 chip->clock_mode = ucontrol->value.enumerated.item[0];
 553                 vx_set_clock(chip, chip->freq);
 554                 mutex_unlock(&chip->mixer_mutex);
 555                 return 1;
 556         }
 557         mutex_unlock(&chip->mixer_mutex);
 558         return 0;
 559 }
 560
 561 static struct snd_kcontrol_new vx_control_clock_mode = {
 562         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 563         .name =         "Clock Mode",
 564         .info =         vx_clock_mode_info,
 565         .get =          vx_clock_mode_get,
 566         .put =          vx_clock_mode_put,
 567 };
 568
 569 /*
 570  * Audio Gain
 571  */
 572 static int vx_audio_gain_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 573 {
 574         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 575         uinfo->count = 2;
 576         uinfo->value.integer.min = 0;
 577         uinfo->value.integer.max = CVAL_MAX;
 578         return 0;
 579 }
 580
 581 static int vx_audio_gain_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 582 {
 583         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 584         int audio = kcontrol->private_value & 0xff;
 585         int capture = (kcontrol->private_value >> 8) & 1;
 586
 587         mutex_lock(&chip->mixer_mutex);
 588         ucontrol->value.integer.value[0] = chip->audio_gain[capture][audio];
 589         ucontrol->value.integer.value[1] = chip->audio_gain[capture][audio+1];
 590         mutex_unlock(&chip->mixer_mutex);
 591         return 0;
 592 }
 593
 594 static int vx_audio_gain_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 595 {
 596         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 597         int audio = kcontrol->private_value & 0xff;
 598         int capture = (kcontrol->private_value >> 8) & 1;
 599         unsigned int val[2];
 600
 601         val[0] = ucontrol->value.integer.value[0];
 602         val[1] = ucontrol->value.integer.value[1];
 603         if (val[0] > CVAL_MAX || val[1] > CVAL_MAX)
 604                 return -EINVAL;
 605         mutex_lock(&chip->mixer_mutex);
 606         if (val[0] != chip->audio_gain[capture][audio] ||
 607             val[1] != chip->audio_gain[capture][audio+1]) {
 608                 vx_set_audio_gain(chip, audio, capture, val[0]);
 609                 vx_set_audio_gain(chip, audio+1, capture, val[1]);
 610                 mutex_unlock(&chip->mixer_mutex);
 611                 return 1;
 612         }
 613         mutex_unlock(&chip->mixer_mutex);
 614         return 0;
 615 }
 616
 617 static int vx_audio_monitor_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 618 {
 619         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 620         int audio = kcontrol->private_value & 0xff;
 621
 622         mutex_lock(&chip->mixer_mutex);
 623         ucontrol->value.integer.value[0] = chip->audio_monitor[audio];
 624         ucontrol->value.integer.value[1] = chip->audio_monitor[audio+1];
 625         mutex_unlock(&chip->mixer_mutex);
 626         return 0;
 627 }
 628
 629 static int vx_audio_monitor_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 630 {
 631         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 632         int audio = kcontrol->private_value & 0xff;
 633         unsigned int val[2];
 634
 635         val[0] = ucontrol->value.integer.value[0];
 636         val[1] = ucontrol->value.integer.value[1];
 637         if (val[0] > CVAL_MAX || val[1] > CVAL_MAX)
 638                 return -EINVAL;
 639
 640         mutex_lock(&chip->mixer_mutex);
 641         if (val[0] != chip->audio_monitor[audio] ||
 642             val[1] != chip->audio_monitor[audio+1]) {
 643                 vx_set_monitor_level(chip, audio, val[0],
 644                                      chip->audio_monitor_active[audio]);
 645                 vx_set_monitor_level(chip, audio+1, val[1],
 646                                      chip->audio_monitor_active[audio+1]);
 647                 mutex_unlock(&chip->mixer_mutex);
 648                 return 1;
 649         }
 650         mutex_unlock(&chip->mixer_mutex);
 651         return 0;
 652 }
 653
 654 #define vx_audio_sw_info        snd_ctl_boolean_stereo_info
 655
 656 static int vx_audio_sw_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 657 {
 658         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 659         int audio = kcontrol->private_value & 0xff;
 660
 661         mutex_lock(&chip->mixer_mutex);
 662         ucontrol->value.integer.value[0] = chip->audio_active[audio];
 663         ucontrol->value.integer.value[1] = chip->audio_active[audio+1];
 664         mutex_unlock(&chip->mixer_mutex);
 665         return 0;
 666 }
 667
 668 static int vx_audio_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 669 {
 670         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 671         int audio = kcontrol->private_value & 0xff;
 672
 673         mutex_lock(&chip->mixer_mutex);
 674         if (ucontrol->value.integer.value[0] != chip->audio_active[audio] ||
 675             ucontrol->value.integer.value[1] != chip->audio_active[audio+1]) {
 676                 vx_set_audio_switch(chip, audio,
 677                                     !!ucontrol->value.integer.value[0]);
 678                 vx_set_audio_switch(chip, audio+1,
 679                                     !!ucontrol->value.integer.value[1]);
 680                 mutex_unlock(&chip->mixer_mutex);
 681                 return 1;
 682         }
 683         mutex_unlock(&chip->mixer_mutex);
 684         return 0;
 685 }
 686
 687 static int vx_monitor_sw_get(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         ucontrol->value.integer.value[0] = chip->audio_monitor_active[audio];
 694         ucontrol->value.integer.value[1] = chip->audio_monitor_active[audio+1];
 695         mutex_unlock(&chip->mixer_mutex);
 696         return 0;
 697 }
 698
 699 static int vx_monitor_sw_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 700 {
 701         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 702         int audio = kcontrol->private_value & 0xff;
 703
 704         mutex_lock(&chip->mixer_mutex);
 705         if (ucontrol->value.integer.value[0] != chip->audio_monitor_active[audio] ||
 706             ucontrol->value.integer.value[1] != chip->audio_monitor_active[audio+1]) {
 707                 vx_set_monitor_level(chip, audio, chip->audio_monitor[audio],
 708                                      !!ucontrol->value.integer.value[0]);
 709                 vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1],
 710                                      !!ucontrol->value.integer.value[1]);
 711                 mutex_unlock(&chip->mixer_mutex);
 712                 return 1;
 713         }
 714         mutex_unlock(&chip->mixer_mutex);
 715         return 0;
 716 }
 717
 718 static const DECLARE_TLV_DB_SCALE(db_scale_audio_gain, -10975, 25, 0);
 719
 720 static struct snd_kcontrol_new vx_control_audio_gain = {
 721         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 722         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 723                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 724         /* name will be filled later */
 725         .info =         vx_audio_gain_info,
 726         .get =          vx_audio_gain_get,
 727         .put =          vx_audio_gain_put,
 728         .tlv = { .p = db_scale_audio_gain },
 729 };
 730 static struct snd_kcontrol_new vx_control_output_switch = {
 731         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 732         .name =         "PCM Playback Switch",
 733         .info =         vx_audio_sw_info,
 734         .get =          vx_audio_sw_get,
 735         .put =          vx_audio_sw_put
 736 };
 737 static struct snd_kcontrol_new vx_control_monitor_gain = {
 738         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 739         .name =         "Monitoring Volume",
 740         .access =       (SNDRV_CTL_ELEM_ACCESS_READWRITE |
 741                          SNDRV_CTL_ELEM_ACCESS_TLV_READ),
 742         .info =         vx_audio_gain_info,     /* shared */
 743         .get =          vx_audio_monitor_get,
 744         .put =          vx_audio_monitor_put,
 745         .tlv = { .p = db_scale_audio_gain },
 746 };
 747 static struct snd_kcontrol_new vx_control_monitor_switch = {
 748         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 749         .name =         "Monitoring Switch",
 750         .info =         vx_audio_sw_info,       /* shared */
 751         .get =          vx_monitor_sw_get,
 752         .put =          vx_monitor_sw_put
 753 };
 754
 755
 756 /*
 757  * IEC958 status bits
 758  */
 759 static int vx_iec958_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 760 {
 761         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 762         uinfo->count = 1;
 763         return 0;
 764 }
 765
 766 static int vx_iec958_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 767 {
 768         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 769
 770         mutex_lock(&chip->mixer_mutex);
 771         ucontrol->value.iec958.status[0] = (chip->uer_bits >> 0) & 0xff;
 772         ucontrol->value.iec958.status[1] = (chip->uer_bits >> 8) & 0xff;
 773         ucontrol->value.iec958.status[2] = (chip->uer_bits >> 16) & 0xff;
 774         ucontrol->value.iec958.status[3] = (chip->uer_bits >> 24) & 0xff;
 775         mutex_unlock(&chip->mixer_mutex);
 776         return 0;
 777 }
 778
 779 static int vx_iec958_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 780 {
 781         ucontrol->value.iec958.status[0] = 0xff;
 782         ucontrol->value.iec958.status[1] = 0xff;
 783         ucontrol->value.iec958.status[2] = 0xff;
 784         ucontrol->value.iec958.status[3] = 0xff;
 785         return 0;
 786 }
 787
 788 static int vx_iec958_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 789 {
 790         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 791         unsigned int val;
 792
 793         val = (ucontrol->value.iec958.status[0] << 0) |
 794               (ucontrol->value.iec958.status[1] << 8) |
 795               (ucontrol->value.iec958.status[2] << 16) |
 796               (ucontrol->value.iec958.status[3] << 24);
 797         mutex_lock(&chip->mixer_mutex);
 798         if (chip->uer_bits != val) {
 799                 chip->uer_bits = val;
 800                 vx_set_iec958_status(chip, val);
 801                 mutex_unlock(&chip->mixer_mutex);
 802                 return 1;
 803         }
 804         mutex_unlock(&chip->mixer_mutex);
 805         return 0;
 806 }
 807
 808 static struct snd_kcontrol_new vx_control_iec958_mask = {
 809         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 810         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 811         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
 812         .info =         vx_iec958_info, /* shared */
 813         .get =          vx_iec958_mask_get,
 814 };
 815
 816 static struct snd_kcontrol_new vx_control_iec958 = {
 817         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 818         .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 819         .info =         vx_iec958_info,
 820         .get =          vx_iec958_get,
 821         .put =          vx_iec958_put
 822 };
 823
 824
 825 /*
 826  * VU meter
 827  */
 828
 829 #define METER_MAX       0xff
 830 #define METER_SHIFT     16
 831
 832 static int vx_vu_meter_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 833 {
 834         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 835         uinfo->count = 2;
 836         uinfo->value.integer.min = 0;
 837         uinfo->value.integer.max = METER_MAX;
 838         return 0;
 839 }
 840
 841 static int vx_vu_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 842 {
 843         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 844         struct vx_vu_meter meter[2];
 845         int audio = kcontrol->private_value & 0xff;
 846         int capture = (kcontrol->private_value >> 8) & 1;
 847
 848         vx_get_audio_vu_meter(chip, audio, capture, meter);
 849         ucontrol->value.integer.value[0] = meter[0].vu_level >> METER_SHIFT;
 850         ucontrol->value.integer.value[1] = meter[1].vu_level >> METER_SHIFT;
 851         return 0;
 852 }
 853
 854 static int vx_peak_meter_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 855 {
 856         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 857         struct vx_vu_meter meter[2];
 858         int audio = kcontrol->private_value & 0xff;
 859         int capture = (kcontrol->private_value >> 8) & 1;
 860
 861         vx_get_audio_vu_meter(chip, audio, capture, meter);
 862         ucontrol->value.integer.value[0] = meter[0].peak_level >> METER_SHIFT;
 863         ucontrol->value.integer.value[1] = meter[1].peak_level >> METER_SHIFT;
 864         return 0;
 865 }
 866
 867 #define vx_saturation_info      snd_ctl_boolean_stereo_info
 868
 869 static int vx_saturation_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 870 {
 871         struct vx_core *chip = snd_kcontrol_chip(kcontrol);
 872         struct vx_vu_meter meter[2];
 873         int audio = kcontrol->private_value & 0xff;
 874
 875         vx_get_audio_vu_meter(chip, audio, 1, meter); /* capture only */
 876         ucontrol->value.integer.value[0] = meter[0].saturated;
 877         ucontrol->value.integer.value[1] = meter[1].saturated;
 878         return 0;
 879 }
 880
 881 static struct snd_kcontrol_new vx_control_vu_meter = {
 882         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 883         .access =       SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
 884         /* name will be filled later */
 885         .info =         vx_vu_meter_info,
 886         .get =          vx_vu_meter_get,
 887 };
 888
 889 static struct snd_kcontrol_new vx_control_peak_meter = {
 890         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 891         .access =       SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
 892         /* name will be filled later */
 893         .info =         vx_vu_meter_info,       /* shared */
 894         .get =          vx_peak_meter_get,
 895 };
 896
 897 static struct snd_kcontrol_new vx_control_saturation = {
 898         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 899         .name =         "Input Saturation",
 900         .access =       SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
 901         .info =         vx_saturation_info,
 902         .get =          vx_saturation_get,
 903 };
 904
 905
 906
 907 /*
 908  *
 909  */
 910
 911 int snd_vx_mixer_new(struct vx_core *chip)
 912 {
 913         unsigned int i, c;
 914         int err;
 915         struct snd_kcontrol_new temp;
 916         struct snd_card *card = chip->card;
 917         char name[32];
 918
 919         strcpy(card->mixername, card->driver);
 920
 921         /* output level controls */
 922         for (i = 0; i < chip->hw->num_outs; i++) {
 923                 temp = vx_control_output_level;
 924                 temp.index = i;
 925                 temp.tlv.p = chip->hw->output_level_db_scale;
 926                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 927                         return err;
 928         }
 929
 930         /* PCM volumes, switches, monitoring */
 931         for (i = 0; i < chip->hw->num_outs; i++) {
 932                 int val = i * 2;
 933                 temp = vx_control_audio_gain;
 934                 temp.index = i;
 935                 temp.name = "PCM Playback Volume";
 936                 temp.private_value = val;
 937                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 938                         return err;
 939                 temp = vx_control_output_switch;
 940                 temp.index = i;
 941                 temp.private_value = val;
 942                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 943                         return err;
 944                 temp = vx_control_monitor_gain;
 945                 temp.index = i;
 946                 temp.private_value = val;
 947                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 948                         return err;
 949                 temp = vx_control_monitor_switch;
 950                 temp.index = i;
 951                 temp.private_value = val;
 952                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 953                         return err;
 954         }
 955         for (i = 0; i < chip->hw->num_outs; i++) {
 956                 temp = vx_control_audio_gain;
 957                 temp.index = i;
 958                 temp.name = "PCM Capture Volume";
 959                 temp.private_value = (i * 2) | (1 << 8);
 960                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 961                         return err;
 962         }
 963
 964         /* Audio source */
 965         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_audio_src, chip))) < 0)
 966                 return err;
 967         /* clock mode */
 968         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_clock_mode, chip))) < 0)
 969                 return err;
 970         /* IEC958 controls */
 971         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958_mask, chip))) < 0)
 972                 return err;
 973         if ((err = snd_ctl_add(card, snd_ctl_new1(&vx_control_iec958, chip))) < 0)
 974                 return err;
 975         /* VU, peak, saturation meters */
 976         for (c = 0; c < 2; c++) {
 977                 static char *dir[2] = { "Output", "Input" };
 978                 for (i = 0; i < chip->hw->num_ins; i++) {
 979                         int val = (i * 2) | (c << 8);
 980                         if (c == 1) {
 981                                 temp = vx_control_saturation;
 982                                 temp.index = i;
 983                                 temp.private_value = val;
 984                                 if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 985                                         return err;
 986                         }
 987                         sprintf(name, "%s VU Meter", dir[c]);
 988                         temp = vx_control_vu_meter;
 989                         temp.index = i;
 990                         temp.name = name;
 991                         temp.private_value = val;
 992                         if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
 993                                 return err;
 994                         sprintf(name, "%s Peak Meter", dir[c]);
 995                         temp = vx_control_peak_meter;
 996                         temp.index = i;
 997                         temp.name = name;
 998                         temp.private_value = val;
 999                         if ((err = snd_ctl_add(card, snd_ctl_new1(&temp, chip))) < 0)
1000                                 return err;
1001                 }
1002         }
1003         vx_reset_audio_levels(chip);
1004         return 0;
1005 }