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