2 * C-Media CMI8788 driver - mixer code
4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License, version 2.
10 * This driver is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this driver; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #include <linux/mutex.h>
21 #include <sound/ac97_codec.h>
22 #include <sound/asoundef.h>
23 #include <sound/control.h>
24 #include <sound/tlv.h>
27 static int dac_volume_info(struct snd_kcontrol *ctl,
28 struct snd_ctl_elem_info *info)
30 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
32 info->value.integer.min = 0;
33 info->value.integer.max = 0xff;
37 static int dac_volume_get(struct snd_kcontrol *ctl,
38 struct snd_ctl_elem_value *value)
40 struct oxygen *chip = ctl->private_data;
43 mutex_lock(&chip->mutex);
44 for (i = 0; i < 8; ++i)
45 value->value.integer.value[i] = chip->dac_volume[i];
46 mutex_unlock(&chip->mutex);
50 static int dac_volume_put(struct snd_kcontrol *ctl,
51 struct snd_ctl_elem_value *value)
53 struct oxygen *chip = ctl->private_data;
58 mutex_lock(&chip->mutex);
59 for (i = 0; i < 8; ++i)
60 if (value->value.integer.value[i] != chip->dac_volume[i]) {
61 chip->dac_volume[i] = value->value.integer.value[i];
65 chip->model->update_dac_volume(chip);
66 mutex_unlock(&chip->mutex);
70 static int dac_mute_get(struct snd_kcontrol *ctl,
71 struct snd_ctl_elem_value *value)
73 struct oxygen *chip = ctl->private_data;
75 mutex_lock(&chip->mutex);
76 value->value.integer.value[0] = !chip->dac_mute;
77 mutex_unlock(&chip->mutex);
81 static int dac_mute_put(struct snd_kcontrol *ctl,
82 struct snd_ctl_elem_value *value)
84 struct oxygen *chip = ctl->private_data;
87 mutex_lock(&chip->mutex);
88 changed = !value->value.integer.value[0] != chip->dac_mute;
90 chip->dac_mute = !value->value.integer.value[0];
91 chip->model->update_dac_mute(chip);
93 mutex_unlock(&chip->mutex);
97 static int upmix_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
99 static const char *const names[3] = {
100 "Front", "Front+Surround", "Front+Surround+Back"
102 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
104 info->value.enumerated.items = 3;
105 if (info->value.enumerated.item > 2)
106 info->value.enumerated.item = 2;
107 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
111 static int upmix_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
113 struct oxygen *chip = ctl->private_data;
115 mutex_lock(&chip->mutex);
116 value->value.enumerated.item[0] = chip->dac_routing;
117 mutex_unlock(&chip->mutex);
121 void oxygen_update_dac_routing(struct oxygen *chip)
123 /* DAC 0: front, DAC 1: surround, DAC 2: center/LFE, DAC 3: back */
124 static const unsigned int reg_values[3] = {
125 /* stereo -> front */
126 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
127 (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
128 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
129 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
130 /* stereo -> front+surround */
131 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
132 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
133 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
134 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
135 /* stereo -> front+surround+back */
136 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
137 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
138 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
139 (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
142 unsigned int reg_value;
144 channels = oxygen_read8(chip, OXYGEN_PLAY_CHANNELS) &
145 OXYGEN_PLAY_CHANNELS_MASK;
146 if (channels == OXYGEN_PLAY_CHANNELS_2)
147 reg_value = reg_values[chip->dac_routing];
148 else if (channels == OXYGEN_PLAY_CHANNELS_8)
149 /* in 7.1 mode, "rear" channels go to the "back" jack */
150 reg_value = (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
151 (3 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
152 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
153 (1 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT);
155 reg_value = (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
156 (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
157 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
158 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT);
159 oxygen_write16_masked(chip, OXYGEN_PLAY_ROUTING, reg_value,
160 OXYGEN_PLAY_DAC0_SOURCE_MASK |
161 OXYGEN_PLAY_DAC1_SOURCE_MASK |
162 OXYGEN_PLAY_DAC2_SOURCE_MASK |
163 OXYGEN_PLAY_DAC3_SOURCE_MASK);
166 static int upmix_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
168 struct oxygen *chip = ctl->private_data;
171 mutex_lock(&chip->mutex);
172 changed = value->value.enumerated.item[0] != chip->dac_routing;
174 chip->dac_routing = min(value->value.enumerated.item[0], 2u);
175 spin_lock_irq(&chip->reg_lock);
176 oxygen_update_dac_routing(chip);
177 spin_unlock_irq(&chip->reg_lock);
179 mutex_unlock(&chip->mutex);
183 static int spdif_switch_get(struct snd_kcontrol *ctl,
184 struct snd_ctl_elem_value *value)
186 struct oxygen *chip = ctl->private_data;
188 mutex_lock(&chip->mutex);
189 value->value.integer.value[0] = chip->spdif_playback_enable;
190 mutex_unlock(&chip->mutex);
194 static unsigned int oxygen_spdif_rate(unsigned int oxygen_rate)
196 switch (oxygen_rate) {
197 case OXYGEN_RATE_32000:
198 return IEC958_AES3_CON_FS_32000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
199 case OXYGEN_RATE_44100:
200 return IEC958_AES3_CON_FS_44100 << OXYGEN_SPDIF_CS_RATE_SHIFT;
201 default: /* OXYGEN_RATE_48000 */
202 return IEC958_AES3_CON_FS_48000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
203 case OXYGEN_RATE_64000:
204 return 0xb << OXYGEN_SPDIF_CS_RATE_SHIFT;
205 case OXYGEN_RATE_88200:
206 return 0x8 << OXYGEN_SPDIF_CS_RATE_SHIFT;
207 case OXYGEN_RATE_96000:
208 return 0xa << OXYGEN_SPDIF_CS_RATE_SHIFT;
209 case OXYGEN_RATE_176400:
210 return 0xc << OXYGEN_SPDIF_CS_RATE_SHIFT;
211 case OXYGEN_RATE_192000:
212 return 0xe << OXYGEN_SPDIF_CS_RATE_SHIFT;
216 void oxygen_update_spdif_source(struct oxygen *chip)
218 u32 old_control, new_control;
219 u16 old_routing, new_routing;
220 unsigned int oxygen_rate;
222 old_control = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL);
223 old_routing = oxygen_read16(chip, OXYGEN_PLAY_ROUTING);
224 if (chip->pcm_active & (1 << PCM_SPDIF)) {
225 new_control = old_control | OXYGEN_SPDIF_OUT_ENABLE;
226 new_routing = (old_routing & ~OXYGEN_PLAY_SPDIF_MASK)
227 | OXYGEN_PLAY_SPDIF_SPDIF;
228 oxygen_rate = (old_control >> OXYGEN_SPDIF_OUT_RATE_SHIFT)
229 & OXYGEN_I2S_RATE_MASK;
230 /* S/PDIF rate was already set by the caller */
231 } else if ((chip->pcm_active & (1 << PCM_MULTICH)) &&
232 chip->spdif_playback_enable) {
233 new_routing = (old_routing & ~OXYGEN_PLAY_SPDIF_MASK)
234 | OXYGEN_PLAY_SPDIF_MULTICH_01;
235 oxygen_rate = oxygen_read16(chip, OXYGEN_I2S_MULTICH_FORMAT)
236 & OXYGEN_I2S_RATE_MASK;
237 new_control = (old_control & ~OXYGEN_SPDIF_OUT_RATE_MASK) |
238 (oxygen_rate << OXYGEN_SPDIF_OUT_RATE_SHIFT) |
239 OXYGEN_SPDIF_OUT_ENABLE;
241 new_control = old_control & ~OXYGEN_SPDIF_OUT_ENABLE;
242 new_routing = old_routing;
243 oxygen_rate = OXYGEN_RATE_44100;
245 if (old_routing != new_routing) {
246 oxygen_write32(chip, OXYGEN_SPDIF_CONTROL,
247 new_control & ~OXYGEN_SPDIF_OUT_ENABLE);
248 oxygen_write16(chip, OXYGEN_PLAY_ROUTING, new_routing);
250 if (new_control & OXYGEN_SPDIF_OUT_ENABLE)
251 oxygen_write32(chip, OXYGEN_SPDIF_OUTPUT_BITS,
252 oxygen_spdif_rate(oxygen_rate) |
253 ((chip->pcm_active & (1 << PCM_SPDIF)) ?
254 chip->spdif_pcm_bits : chip->spdif_bits));
255 oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, new_control);
258 static int spdif_switch_put(struct snd_kcontrol *ctl,
259 struct snd_ctl_elem_value *value)
261 struct oxygen *chip = ctl->private_data;
264 mutex_lock(&chip->mutex);
265 changed = value->value.integer.value[0] != chip->spdif_playback_enable;
267 chip->spdif_playback_enable = !!value->value.integer.value[0];
268 spin_lock_irq(&chip->reg_lock);
269 oxygen_update_spdif_source(chip);
270 spin_unlock_irq(&chip->reg_lock);
272 mutex_unlock(&chip->mutex);
276 static int spdif_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
278 info->type = SNDRV_CTL_ELEM_TYPE_IEC958;
283 static void oxygen_to_iec958(u32 bits, struct snd_ctl_elem_value *value)
285 value->value.iec958.status[0] =
286 bits & (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C |
287 OXYGEN_SPDIF_PREEMPHASIS);
288 value->value.iec958.status[1] = /* category and original */
289 bits >> OXYGEN_SPDIF_CATEGORY_SHIFT;
292 static u32 iec958_to_oxygen(struct snd_ctl_elem_value *value)
296 bits = value->value.iec958.status[0] &
297 (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C |
298 OXYGEN_SPDIF_PREEMPHASIS);
299 bits |= value->value.iec958.status[1] << OXYGEN_SPDIF_CATEGORY_SHIFT;
300 if (bits & OXYGEN_SPDIF_NONAUDIO)
301 bits |= OXYGEN_SPDIF_V;
305 static inline void write_spdif_bits(struct oxygen *chip, u32 bits)
307 oxygen_write32_masked(chip, OXYGEN_SPDIF_OUTPUT_BITS, bits,
308 OXYGEN_SPDIF_NONAUDIO |
310 OXYGEN_SPDIF_PREEMPHASIS |
311 OXYGEN_SPDIF_CATEGORY_MASK |
312 OXYGEN_SPDIF_ORIGINAL |
316 static int spdif_default_get(struct snd_kcontrol *ctl,
317 struct snd_ctl_elem_value *value)
319 struct oxygen *chip = ctl->private_data;
321 mutex_lock(&chip->mutex);
322 oxygen_to_iec958(chip->spdif_bits, value);
323 mutex_unlock(&chip->mutex);
327 static int spdif_default_put(struct snd_kcontrol *ctl,
328 struct snd_ctl_elem_value *value)
330 struct oxygen *chip = ctl->private_data;
334 new_bits = iec958_to_oxygen(value);
335 mutex_lock(&chip->mutex);
336 changed = new_bits != chip->spdif_bits;
338 chip->spdif_bits = new_bits;
339 if (!(chip->pcm_active & (1 << PCM_SPDIF)))
340 write_spdif_bits(chip, new_bits);
342 mutex_unlock(&chip->mutex);
346 static int spdif_mask_get(struct snd_kcontrol *ctl,
347 struct snd_ctl_elem_value *value)
349 value->value.iec958.status[0] = IEC958_AES0_NONAUDIO |
350 IEC958_AES0_CON_NOT_COPYRIGHT | IEC958_AES0_CON_EMPHASIS;
351 value->value.iec958.status[1] =
352 IEC958_AES1_CON_CATEGORY | IEC958_AES1_CON_ORIGINAL;
356 static int spdif_pcm_get(struct snd_kcontrol *ctl,
357 struct snd_ctl_elem_value *value)
359 struct oxygen *chip = ctl->private_data;
361 mutex_lock(&chip->mutex);
362 oxygen_to_iec958(chip->spdif_pcm_bits, value);
363 mutex_unlock(&chip->mutex);
367 static int spdif_pcm_put(struct snd_kcontrol *ctl,
368 struct snd_ctl_elem_value *value)
370 struct oxygen *chip = ctl->private_data;
374 new_bits = iec958_to_oxygen(value);
375 mutex_lock(&chip->mutex);
376 changed = new_bits != chip->spdif_pcm_bits;
378 chip->spdif_pcm_bits = new_bits;
379 if (chip->pcm_active & (1 << PCM_SPDIF))
380 write_spdif_bits(chip, new_bits);
382 mutex_unlock(&chip->mutex);
386 static int spdif_input_mask_get(struct snd_kcontrol *ctl,
387 struct snd_ctl_elem_value *value)
389 value->value.iec958.status[0] = 0xff;
390 value->value.iec958.status[1] = 0xff;
391 value->value.iec958.status[2] = 0xff;
392 value->value.iec958.status[3] = 0xff;
396 static int spdif_input_default_get(struct snd_kcontrol *ctl,
397 struct snd_ctl_elem_value *value)
399 struct oxygen *chip = ctl->private_data;
402 bits = oxygen_read32(chip, OXYGEN_SPDIF_INPUT_BITS);
403 value->value.iec958.status[0] = bits;
404 value->value.iec958.status[1] = bits >> 8;
405 value->value.iec958.status[2] = bits >> 16;
406 value->value.iec958.status[3] = bits >> 24;
410 static int ac97_switch_get(struct snd_kcontrol *ctl,
411 struct snd_ctl_elem_value *value)
413 struct oxygen *chip = ctl->private_data;
414 unsigned int index = ctl->private_value & 0xff;
415 unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
416 int invert = ctl->private_value & (1 << 16);
419 mutex_lock(&chip->mutex);
420 reg = oxygen_read_ac97(chip, 0, index);
421 mutex_unlock(&chip->mutex);
422 if (!(reg & (1 << bitnr)) ^ !invert)
423 value->value.integer.value[0] = 1;
425 value->value.integer.value[0] = 0;
429 static void ac97_mute_ctl(struct oxygen *chip, unsigned int control)
431 unsigned int index = chip->controls[control]->private_value & 0xff;
434 value = oxygen_read_ac97(chip, 0, index);
435 if (!(value & 0x8000)) {
436 oxygen_write_ac97(chip, 0, index, value | 0x8000);
437 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
438 &chip->controls[control]->id);
442 static int ac97_switch_put(struct snd_kcontrol *ctl,
443 struct snd_ctl_elem_value *value)
445 struct oxygen *chip = ctl->private_data;
446 unsigned int index = ctl->private_value & 0xff;
447 unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
448 int invert = ctl->private_value & (1 << 16);
452 mutex_lock(&chip->mutex);
453 oldreg = oxygen_read_ac97(chip, 0, index);
455 if (!value->value.integer.value[0] ^ !invert)
456 newreg |= 1 << bitnr;
458 newreg &= ~(1 << bitnr);
459 change = newreg != oldreg;
461 oxygen_write_ac97(chip, 0, index, newreg);
462 if (index == AC97_LINE) {
463 oxygen_write_ac97_masked(chip, 0, 0x72,
464 !!(newreg & 0x8000), 0x0001);
465 if (!(newreg & 0x8000)) {
466 ac97_mute_ctl(chip, CONTROL_MIC_CAPTURE_SWITCH);
467 ac97_mute_ctl(chip, CONTROL_CD_CAPTURE_SWITCH);
468 ac97_mute_ctl(chip, CONTROL_AUX_CAPTURE_SWITCH);
470 } else if ((index == AC97_MIC || index == AC97_CD ||
471 index == AC97_VIDEO || index == AC97_AUX) &&
472 bitnr == 15 && !(newreg & 0x8000)) {
473 ac97_mute_ctl(chip, CONTROL_LINE_CAPTURE_SWITCH);
474 oxygen_write_ac97_masked(chip, 0, 0x72, 0x0001, 0x0001);
477 mutex_unlock(&chip->mutex);
481 static int ac97_volume_info(struct snd_kcontrol *ctl,
482 struct snd_ctl_elem_info *info)
484 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
486 info->value.integer.min = 0;
487 info->value.integer.max = 0x1f;
491 static int ac97_volume_get(struct snd_kcontrol *ctl,
492 struct snd_ctl_elem_value *value)
494 struct oxygen *chip = ctl->private_data;
495 unsigned int index = ctl->private_value;
498 mutex_lock(&chip->mutex);
499 reg = oxygen_read_ac97(chip, 0, index);
500 mutex_unlock(&chip->mutex);
501 value->value.integer.value[0] = 31 - (reg & 0x1f);
502 value->value.integer.value[1] = 31 - ((reg >> 8) & 0x1f);
506 static int ac97_volume_put(struct snd_kcontrol *ctl,
507 struct snd_ctl_elem_value *value)
509 struct oxygen *chip = ctl->private_data;
510 unsigned int index = ctl->private_value;
514 mutex_lock(&chip->mutex);
515 oldreg = oxygen_read_ac97(chip, 0, index);
517 newreg = (newreg & ~0x1f) |
518 (31 - (value->value.integer.value[0] & 0x1f));
519 newreg = (newreg & ~0x1f00) |
520 ((31 - (value->value.integer.value[0] & 0x1f)) << 8);
521 change = newreg != oldreg;
523 oxygen_write_ac97(chip, 0, index, newreg);
524 mutex_unlock(&chip->mutex);
528 #define AC97_SWITCH(xname, index, bitnr, invert) { \
529 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
531 .info = snd_ctl_boolean_mono_info, \
532 .get = ac97_switch_get, \
533 .put = ac97_switch_put, \
534 .private_value = ((invert) << 16) | ((bitnr) << 8) | (index), \
536 #define AC97_VOLUME(xname, index) { \
537 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
539 .info = ac97_volume_info, \
540 .get = ac97_volume_get, \
541 .put = ac97_volume_put, \
542 .tlv = { .p = ac97_db_scale, }, \
543 .private_value = (index), \
546 static DECLARE_TLV_DB_SCALE(ac97_db_scale, -3450, 150, 0);
548 static const struct snd_kcontrol_new controls[] = {
550 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
551 .name = "Master Playback Volume",
552 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
553 .info = dac_volume_info,
554 .get = dac_volume_get,
555 .put = dac_volume_put,
558 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
559 .name = "Master Playback Switch",
560 .info = snd_ctl_boolean_mono_info,
565 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
566 .name = "Stereo Upmixing",
572 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
573 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
574 .info = snd_ctl_boolean_mono_info,
575 .get = spdif_switch_get,
576 .put = spdif_switch_put,
579 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
581 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
583 .get = spdif_default_get,
584 .put = spdif_default_put,
587 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
589 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
590 .access = SNDRV_CTL_ELEM_ACCESS_READ,
592 .get = spdif_mask_get,
595 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
597 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
598 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
599 SNDRV_CTL_ELEM_ACCESS_INACTIVE,
601 .get = spdif_pcm_get,
602 .put = spdif_pcm_put,
605 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
607 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK),
608 .access = SNDRV_CTL_ELEM_ACCESS_READ,
610 .get = spdif_input_mask_get,
613 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
615 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
616 .access = SNDRV_CTL_ELEM_ACCESS_READ,
618 .get = spdif_input_default_get,
622 static const struct snd_kcontrol_new ac97_controls[] = {
623 AC97_VOLUME("Mic Capture Volume", AC97_MIC),
624 AC97_SWITCH("Mic Capture Switch", AC97_MIC, 15, 1),
625 AC97_SWITCH("Mic Boost (+20dB)", AC97_MIC, 6, 0),
626 AC97_SWITCH("Line Capture Switch", AC97_LINE, 15, 1),
627 AC97_VOLUME("CD Capture Volume", AC97_CD),
628 AC97_SWITCH("CD Capture Switch", AC97_CD, 15, 1),
629 AC97_VOLUME("Aux Capture Volume", AC97_AUX),
630 AC97_SWITCH("Aux Capture Switch", AC97_AUX, 15, 1),
633 static void oxygen_any_ctl_free(struct snd_kcontrol *ctl)
635 struct oxygen *chip = ctl->private_data;
638 /* I'm too lazy to write a function for each control :-) */
639 for (i = 0; i < ARRAY_SIZE(chip->controls); ++i)
640 chip->controls[i] = NULL;
643 static int add_controls(struct oxygen *chip,
644 const struct snd_kcontrol_new controls[],
647 static const char *const known_ctl_names[CONTROL_COUNT] = {
648 [CONTROL_SPDIF_PCM] =
649 SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
650 [CONTROL_SPDIF_INPUT_BITS] =
651 SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
652 [CONTROL_MIC_CAPTURE_SWITCH] = "Mic Capture Switch",
653 [CONTROL_LINE_CAPTURE_SWITCH] = "Line Capture Switch",
654 [CONTROL_CD_CAPTURE_SWITCH] = "CD Capture Switch",
655 [CONTROL_AUX_CAPTURE_SWITCH] = "Aux Capture Switch",
658 struct snd_kcontrol_new template;
659 struct snd_kcontrol *ctl;
662 for (i = 0; i < count; ++i) {
663 template = controls[i];
664 err = chip->model->control_filter(&template);
667 ctl = snd_ctl_new1(&controls[i], chip);
670 err = snd_ctl_add(chip->card, ctl);
673 for (j = 0; j < CONTROL_COUNT; ++j)
674 if (!strcmp(ctl->id.name, known_ctl_names[j])) {
675 chip->controls[j] = ctl;
676 ctl->private_free = oxygen_any_ctl_free;
682 int oxygen_mixer_init(struct oxygen *chip)
686 err = add_controls(chip, controls, ARRAY_SIZE(controls));
689 if (chip->has_ac97_0) {
690 err = add_controls(chip, ac97_controls,
691 ARRAY_SIZE(ac97_controls));
695 return chip->model->mixer_init ? chip->model->mixer_init(chip) : 0;