linux/sound/drivers/vx/vx_mixer.c
<<
>>
Prefs
   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 */
  33static 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 */
  49union 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 */
  87static 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 */
 104static 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
 128void 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 */
 143void 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 */
 177static 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 */
 192int 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 */
 206struct 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
 217static 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
 256static 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 */
 283int 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 */
 301static 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 */
 315static 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 */
 329static 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
 363struct 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 */
 375static 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 */
 413static 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
 423static 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
 434static 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
 458static const 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 */
 472static 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
 488static 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
 495static 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
 517static const 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 */
 528static 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
 537static 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
 544static 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
 561static const 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 */
 572static 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
 581static 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
 594static 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
 617static 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
 629static 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
 656static 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
 668static 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
 687static 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
 699static 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
 718static const DECLARE_TLV_DB_SCALE(db_scale_audio_gain, -10975, 25, 0);
 719
 720static const 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};
 730static const 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};
 737static const 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};
 747static const 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 */
 759static 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
 766static 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
 779static 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
 788static 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
 808static const 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
 816static const 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
 832static 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
 841static 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
 854static 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
 869static 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
 881static const 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
 889static const 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
 897static const 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
 911int 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}
1006