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	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 */
  51union 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 */
  89static 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 */
 106static 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
 130void 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 */
 145void 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 */
 179static 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 */
 196int 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 */
 210struct 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
 221static 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
 260static 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 */
 287int 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 */
 305static 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 */
 319static 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 */
 333static 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
 367struct 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 */
 379static 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 */
 417static 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
 427static 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
 438static 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
 462static 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 */
 476static 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
 504static 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
 511static 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
 533static 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 */
 544static 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
 560static 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
 567static 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
 584static 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 */
 595static 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
 604static 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
 617static 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
 640static 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
 652static 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
 679static 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
 691static 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
 710static 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
 722static 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
 741static const DECLARE_TLV_DB_SCALE(db_scale_audio_gain, -10975, 25, 0);
 742
 743static 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};
 753static 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};
 760static 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};
 770static 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 */
 782static 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
 789static 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
 802static 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
 811static 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
 831static 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
 839static 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
 855static 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
 864static 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
 877static 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
 892static 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
 904static 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
 912static 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
 920static 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
 934int 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}