Merge branches 'ns9x' and 'machtypes' into devel
[linux-2.6] / sound / pci / oxygen / oxygen_mixer.c
1 /*
2  * C-Media CMI8788 driver - mixer code
3  *
4  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
5  *
6  *
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.
9  *
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.
14  *
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
18  */
19
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>
25 #include "oxygen.h"
26 #include "cm9780.h"
27
28 static int dac_volume_info(struct snd_kcontrol *ctl,
29                            struct snd_ctl_elem_info *info)
30 {
31         struct oxygen *chip = ctl->private_data;
32
33         info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
34         info->count = chip->model->dac_channels;
35         info->value.integer.min = chip->model->dac_volume_min;
36         info->value.integer.max = chip->model->dac_volume_max;
37         return 0;
38 }
39
40 static int dac_volume_get(struct snd_kcontrol *ctl,
41                           struct snd_ctl_elem_value *value)
42 {
43         struct oxygen *chip = ctl->private_data;
44         unsigned int i;
45
46         mutex_lock(&chip->mutex);
47         for (i = 0; i < chip->model->dac_channels; ++i)
48                 value->value.integer.value[i] = chip->dac_volume[i];
49         mutex_unlock(&chip->mutex);
50         return 0;
51 }
52
53 static int dac_volume_put(struct snd_kcontrol *ctl,
54                           struct snd_ctl_elem_value *value)
55 {
56         struct oxygen *chip = ctl->private_data;
57         unsigned int i;
58         int changed;
59
60         changed = 0;
61         mutex_lock(&chip->mutex);
62         for (i = 0; i < chip->model->dac_channels; ++i)
63                 if (value->value.integer.value[i] != chip->dac_volume[i]) {
64                         chip->dac_volume[i] = value->value.integer.value[i];
65                         changed = 1;
66                 }
67         if (changed)
68                 chip->model->update_dac_volume(chip);
69         mutex_unlock(&chip->mutex);
70         return changed;
71 }
72
73 static int dac_mute_get(struct snd_kcontrol *ctl,
74                         struct snd_ctl_elem_value *value)
75 {
76         struct oxygen *chip = ctl->private_data;
77
78         mutex_lock(&chip->mutex);
79         value->value.integer.value[0] = !chip->dac_mute;
80         mutex_unlock(&chip->mutex);
81         return 0;
82 }
83
84 static int dac_mute_put(struct snd_kcontrol *ctl,
85                           struct snd_ctl_elem_value *value)
86 {
87         struct oxygen *chip = ctl->private_data;
88         int changed;
89
90         mutex_lock(&chip->mutex);
91         changed = !value->value.integer.value[0] != chip->dac_mute;
92         if (changed) {
93                 chip->dac_mute = !value->value.integer.value[0];
94                 chip->model->update_dac_mute(chip);
95         }
96         mutex_unlock(&chip->mutex);
97         return changed;
98 }
99
100 static int upmix_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
101 {
102         static const char *const names[3] = {
103                 "Front", "Front+Surround", "Front+Surround+Back"
104         };
105         struct oxygen *chip = ctl->private_data;
106         unsigned int count = 2 + (chip->model->dac_channels == 8);
107
108         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
109         info->count = 1;
110         info->value.enumerated.items = count;
111         if (info->value.enumerated.item >= count)
112                 info->value.enumerated.item = count - 1;
113         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
114         return 0;
115 }
116
117 static int upmix_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
118 {
119         struct oxygen *chip = ctl->private_data;
120
121         mutex_lock(&chip->mutex);
122         value->value.enumerated.item[0] = chip->dac_routing;
123         mutex_unlock(&chip->mutex);
124         return 0;
125 }
126
127 void oxygen_update_dac_routing(struct oxygen *chip)
128 {
129         /* DAC 0: front, DAC 1: surround, DAC 2: center/LFE, DAC 3: back */
130         static const unsigned int reg_values[3] = {
131                 /* stereo -> front */
132                 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
133                 (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
134                 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
135                 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
136                 /* stereo -> front+surround */
137                 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
138                 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
139                 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
140                 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
141                 /* stereo -> front+surround+back */
142                 (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
143                 (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
144                 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
145                 (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
146         };
147         u8 channels;
148         unsigned int reg_value;
149
150         channels = oxygen_read8(chip, OXYGEN_PLAY_CHANNELS) &
151                 OXYGEN_PLAY_CHANNELS_MASK;
152         if (channels == OXYGEN_PLAY_CHANNELS_2)
153                 reg_value = reg_values[chip->dac_routing];
154         else if (channels == OXYGEN_PLAY_CHANNELS_8)
155                 /* in 7.1 mode, "rear" channels go to the "back" jack */
156                 reg_value = (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
157                             (3 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
158                             (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
159                             (1 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT);
160         else
161                 reg_value = (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
162                             (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
163                             (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
164                             (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT);
165         oxygen_write16_masked(chip, OXYGEN_PLAY_ROUTING, reg_value,
166                               OXYGEN_PLAY_DAC0_SOURCE_MASK |
167                               OXYGEN_PLAY_DAC1_SOURCE_MASK |
168                               OXYGEN_PLAY_DAC2_SOURCE_MASK |
169                               OXYGEN_PLAY_DAC3_SOURCE_MASK);
170 }
171
172 static int upmix_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
173 {
174         struct oxygen *chip = ctl->private_data;
175         unsigned int count = 2 + (chip->model->dac_channels == 8);
176         int changed;
177
178         mutex_lock(&chip->mutex);
179         changed = value->value.enumerated.item[0] != chip->dac_routing;
180         if (changed) {
181                 chip->dac_routing = min(value->value.enumerated.item[0],
182                                         count - 1);
183                 spin_lock_irq(&chip->reg_lock);
184                 oxygen_update_dac_routing(chip);
185                 spin_unlock_irq(&chip->reg_lock);
186         }
187         mutex_unlock(&chip->mutex);
188         return changed;
189 }
190
191 static int spdif_switch_get(struct snd_kcontrol *ctl,
192                             struct snd_ctl_elem_value *value)
193 {
194         struct oxygen *chip = ctl->private_data;
195
196         mutex_lock(&chip->mutex);
197         value->value.integer.value[0] = chip->spdif_playback_enable;
198         mutex_unlock(&chip->mutex);
199         return 0;
200 }
201
202 static unsigned int oxygen_spdif_rate(unsigned int oxygen_rate)
203 {
204         switch (oxygen_rate) {
205         case OXYGEN_RATE_32000:
206                 return IEC958_AES3_CON_FS_32000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
207         case OXYGEN_RATE_44100:
208                 return IEC958_AES3_CON_FS_44100 << OXYGEN_SPDIF_CS_RATE_SHIFT;
209         default: /* OXYGEN_RATE_48000 */
210                 return IEC958_AES3_CON_FS_48000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
211         case OXYGEN_RATE_64000:
212                 return 0xb << OXYGEN_SPDIF_CS_RATE_SHIFT;
213         case OXYGEN_RATE_88200:
214                 return 0x8 << OXYGEN_SPDIF_CS_RATE_SHIFT;
215         case OXYGEN_RATE_96000:
216                 return 0xa << OXYGEN_SPDIF_CS_RATE_SHIFT;
217         case OXYGEN_RATE_176400:
218                 return 0xc << OXYGEN_SPDIF_CS_RATE_SHIFT;
219         case OXYGEN_RATE_192000:
220                 return 0xe << OXYGEN_SPDIF_CS_RATE_SHIFT;
221         }
222 }
223
224 void oxygen_update_spdif_source(struct oxygen *chip)
225 {
226         u32 old_control, new_control;
227         u16 old_routing, new_routing;
228         unsigned int oxygen_rate;
229
230         old_control = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL);
231         old_routing = oxygen_read16(chip, OXYGEN_PLAY_ROUTING);
232         if (chip->pcm_active & (1 << PCM_SPDIF)) {
233                 new_control = old_control | OXYGEN_SPDIF_OUT_ENABLE;
234                 new_routing = (old_routing & ~OXYGEN_PLAY_SPDIF_MASK)
235                         | OXYGEN_PLAY_SPDIF_SPDIF;
236                 oxygen_rate = (old_control >> OXYGEN_SPDIF_OUT_RATE_SHIFT)
237                         & OXYGEN_I2S_RATE_MASK;
238                 /* S/PDIF rate was already set by the caller */
239         } else if ((chip->pcm_active & (1 << PCM_MULTICH)) &&
240                    chip->spdif_playback_enable) {
241                 new_routing = (old_routing & ~OXYGEN_PLAY_SPDIF_MASK)
242                         | OXYGEN_PLAY_SPDIF_MULTICH_01;
243                 oxygen_rate = oxygen_read16(chip, OXYGEN_I2S_MULTICH_FORMAT)
244                         & OXYGEN_I2S_RATE_MASK;
245                 new_control = (old_control & ~OXYGEN_SPDIF_OUT_RATE_MASK) |
246                         (oxygen_rate << OXYGEN_SPDIF_OUT_RATE_SHIFT) |
247                         OXYGEN_SPDIF_OUT_ENABLE;
248         } else {
249                 new_control = old_control & ~OXYGEN_SPDIF_OUT_ENABLE;
250                 new_routing = old_routing;
251                 oxygen_rate = OXYGEN_RATE_44100;
252         }
253         if (old_routing != new_routing) {
254                 oxygen_write32(chip, OXYGEN_SPDIF_CONTROL,
255                                new_control & ~OXYGEN_SPDIF_OUT_ENABLE);
256                 oxygen_write16(chip, OXYGEN_PLAY_ROUTING, new_routing);
257         }
258         if (new_control & OXYGEN_SPDIF_OUT_ENABLE)
259                 oxygen_write32(chip, OXYGEN_SPDIF_OUTPUT_BITS,
260                                oxygen_spdif_rate(oxygen_rate) |
261                                ((chip->pcm_active & (1 << PCM_SPDIF)) ?
262                                 chip->spdif_pcm_bits : chip->spdif_bits));
263         oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, new_control);
264 }
265
266 static int spdif_switch_put(struct snd_kcontrol *ctl,
267                             struct snd_ctl_elem_value *value)
268 {
269         struct oxygen *chip = ctl->private_data;
270         int changed;
271
272         mutex_lock(&chip->mutex);
273         changed = value->value.integer.value[0] != chip->spdif_playback_enable;
274         if (changed) {
275                 chip->spdif_playback_enable = !!value->value.integer.value[0];
276                 spin_lock_irq(&chip->reg_lock);
277                 oxygen_update_spdif_source(chip);
278                 spin_unlock_irq(&chip->reg_lock);
279         }
280         mutex_unlock(&chip->mutex);
281         return changed;
282 }
283
284 static int spdif_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
285 {
286         info->type = SNDRV_CTL_ELEM_TYPE_IEC958;
287         info->count = 1;
288         return 0;
289 }
290
291 static void oxygen_to_iec958(u32 bits, struct snd_ctl_elem_value *value)
292 {
293         value->value.iec958.status[0] =
294                 bits & (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C |
295                         OXYGEN_SPDIF_PREEMPHASIS);
296         value->value.iec958.status[1] = /* category and original */
297                 bits >> OXYGEN_SPDIF_CATEGORY_SHIFT;
298 }
299
300 static u32 iec958_to_oxygen(struct snd_ctl_elem_value *value)
301 {
302         u32 bits;
303
304         bits = value->value.iec958.status[0] &
305                 (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C |
306                  OXYGEN_SPDIF_PREEMPHASIS);
307         bits |= value->value.iec958.status[1] << OXYGEN_SPDIF_CATEGORY_SHIFT;
308         if (bits & OXYGEN_SPDIF_NONAUDIO)
309                 bits |= OXYGEN_SPDIF_V;
310         return bits;
311 }
312
313 static inline void write_spdif_bits(struct oxygen *chip, u32 bits)
314 {
315         oxygen_write32_masked(chip, OXYGEN_SPDIF_OUTPUT_BITS, bits,
316                               OXYGEN_SPDIF_NONAUDIO |
317                               OXYGEN_SPDIF_C |
318                               OXYGEN_SPDIF_PREEMPHASIS |
319                               OXYGEN_SPDIF_CATEGORY_MASK |
320                               OXYGEN_SPDIF_ORIGINAL |
321                               OXYGEN_SPDIF_V);
322 }
323
324 static int spdif_default_get(struct snd_kcontrol *ctl,
325                              struct snd_ctl_elem_value *value)
326 {
327         struct oxygen *chip = ctl->private_data;
328
329         mutex_lock(&chip->mutex);
330         oxygen_to_iec958(chip->spdif_bits, value);
331         mutex_unlock(&chip->mutex);
332         return 0;
333 }
334
335 static int spdif_default_put(struct snd_kcontrol *ctl,
336                              struct snd_ctl_elem_value *value)
337 {
338         struct oxygen *chip = ctl->private_data;
339         u32 new_bits;
340         int changed;
341
342         new_bits = iec958_to_oxygen(value);
343         mutex_lock(&chip->mutex);
344         changed = new_bits != chip->spdif_bits;
345         if (changed) {
346                 chip->spdif_bits = new_bits;
347                 if (!(chip->pcm_active & (1 << PCM_SPDIF)))
348                         write_spdif_bits(chip, new_bits);
349         }
350         mutex_unlock(&chip->mutex);
351         return changed;
352 }
353
354 static int spdif_mask_get(struct snd_kcontrol *ctl,
355                           struct snd_ctl_elem_value *value)
356 {
357         value->value.iec958.status[0] = IEC958_AES0_NONAUDIO |
358                 IEC958_AES0_CON_NOT_COPYRIGHT | IEC958_AES0_CON_EMPHASIS;
359         value->value.iec958.status[1] =
360                 IEC958_AES1_CON_CATEGORY | IEC958_AES1_CON_ORIGINAL;
361         return 0;
362 }
363
364 static int spdif_pcm_get(struct snd_kcontrol *ctl,
365                          struct snd_ctl_elem_value *value)
366 {
367         struct oxygen *chip = ctl->private_data;
368
369         mutex_lock(&chip->mutex);
370         oxygen_to_iec958(chip->spdif_pcm_bits, value);
371         mutex_unlock(&chip->mutex);
372         return 0;
373 }
374
375 static int spdif_pcm_put(struct snd_kcontrol *ctl,
376                          struct snd_ctl_elem_value *value)
377 {
378         struct oxygen *chip = ctl->private_data;
379         u32 new_bits;
380         int changed;
381
382         new_bits = iec958_to_oxygen(value);
383         mutex_lock(&chip->mutex);
384         changed = new_bits != chip->spdif_pcm_bits;
385         if (changed) {
386                 chip->spdif_pcm_bits = new_bits;
387                 if (chip->pcm_active & (1 << PCM_SPDIF))
388                         write_spdif_bits(chip, new_bits);
389         }
390         mutex_unlock(&chip->mutex);
391         return changed;
392 }
393
394 static int spdif_input_mask_get(struct snd_kcontrol *ctl,
395                                 struct snd_ctl_elem_value *value)
396 {
397         value->value.iec958.status[0] = 0xff;
398         value->value.iec958.status[1] = 0xff;
399         value->value.iec958.status[2] = 0xff;
400         value->value.iec958.status[3] = 0xff;
401         return 0;
402 }
403
404 static int spdif_input_default_get(struct snd_kcontrol *ctl,
405                                    struct snd_ctl_elem_value *value)
406 {
407         struct oxygen *chip = ctl->private_data;
408         u32 bits;
409
410         bits = oxygen_read32(chip, OXYGEN_SPDIF_INPUT_BITS);
411         value->value.iec958.status[0] = bits;
412         value->value.iec958.status[1] = bits >> 8;
413         value->value.iec958.status[2] = bits >> 16;
414         value->value.iec958.status[3] = bits >> 24;
415         return 0;
416 }
417
418 static int spdif_loopback_get(struct snd_kcontrol *ctl,
419                               struct snd_ctl_elem_value *value)
420 {
421         struct oxygen *chip = ctl->private_data;
422
423         value->value.integer.value[0] =
424                 !!(oxygen_read32(chip, OXYGEN_SPDIF_CONTROL)
425                    & OXYGEN_SPDIF_LOOPBACK);
426         return 0;
427 }
428
429 static int spdif_loopback_put(struct snd_kcontrol *ctl,
430                               struct snd_ctl_elem_value *value)
431 {
432         struct oxygen *chip = ctl->private_data;
433         u32 oldreg, newreg;
434         int changed;
435
436         spin_lock_irq(&chip->reg_lock);
437         oldreg = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL);
438         if (value->value.integer.value[0])
439                 newreg = oldreg | OXYGEN_SPDIF_LOOPBACK;
440         else
441                 newreg = oldreg & ~OXYGEN_SPDIF_LOOPBACK;
442         changed = newreg != oldreg;
443         if (changed)
444                 oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, newreg);
445         spin_unlock_irq(&chip->reg_lock);
446         return changed;
447 }
448
449 static int monitor_volume_info(struct snd_kcontrol *ctl,
450                                struct snd_ctl_elem_info *info)
451 {
452         info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
453         info->count = 1;
454         info->value.integer.min = 0;
455         info->value.integer.max = 1;
456         return 0;
457 }
458
459 static int monitor_get(struct snd_kcontrol *ctl,
460                        struct snd_ctl_elem_value *value)
461 {
462         struct oxygen *chip = ctl->private_data;
463         u8 bit = ctl->private_value;
464         int invert = ctl->private_value & (1 << 8);
465
466         value->value.integer.value[0] =
467                 !!invert ^ !!(oxygen_read8(chip, OXYGEN_ADC_MONITOR) & bit);
468         return 0;
469 }
470
471 static int monitor_put(struct snd_kcontrol *ctl,
472                        struct snd_ctl_elem_value *value)
473 {
474         struct oxygen *chip = ctl->private_data;
475         u8 bit = ctl->private_value;
476         int invert = ctl->private_value & (1 << 8);
477         u8 oldreg, newreg;
478         int changed;
479
480         spin_lock_irq(&chip->reg_lock);
481         oldreg = oxygen_read8(chip, OXYGEN_ADC_MONITOR);
482         if ((!!value->value.integer.value[0] ^ !!invert) != 0)
483                 newreg = oldreg | bit;
484         else
485                 newreg = oldreg & ~bit;
486         changed = newreg != oldreg;
487         if (changed)
488                 oxygen_write8(chip, OXYGEN_ADC_MONITOR, newreg);
489         spin_unlock_irq(&chip->reg_lock);
490         return changed;
491 }
492
493 static int ac97_switch_get(struct snd_kcontrol *ctl,
494                            struct snd_ctl_elem_value *value)
495 {
496         struct oxygen *chip = ctl->private_data;
497         unsigned int codec = (ctl->private_value >> 24) & 1;
498         unsigned int index = ctl->private_value & 0xff;
499         unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
500         int invert = ctl->private_value & (1 << 16);
501         u16 reg;
502
503         mutex_lock(&chip->mutex);
504         reg = oxygen_read_ac97(chip, codec, index);
505         mutex_unlock(&chip->mutex);
506         if (!(reg & (1 << bitnr)) ^ !invert)
507                 value->value.integer.value[0] = 1;
508         else
509                 value->value.integer.value[0] = 0;
510         return 0;
511 }
512
513 static void mute_ac97_ctl(struct oxygen *chip, unsigned int control)
514 {
515         unsigned int priv_idx = chip->controls[control]->private_value & 0xff;
516         u16 value;
517
518         value = oxygen_read_ac97(chip, 0, priv_idx);
519         if (!(value & 0x8000)) {
520                 oxygen_write_ac97(chip, 0, priv_idx, value | 0x8000);
521                 if (chip->model->ac97_switch)
522                         chip->model->ac97_switch(chip, priv_idx, 0x8000);
523                 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
524                                &chip->controls[control]->id);
525         }
526 }
527
528 static int ac97_switch_put(struct snd_kcontrol *ctl,
529                            struct snd_ctl_elem_value *value)
530 {
531         struct oxygen *chip = ctl->private_data;
532         unsigned int codec = (ctl->private_value >> 24) & 1;
533         unsigned int index = ctl->private_value & 0xff;
534         unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
535         int invert = ctl->private_value & (1 << 16);
536         u16 oldreg, newreg;
537         int change;
538
539         mutex_lock(&chip->mutex);
540         oldreg = oxygen_read_ac97(chip, codec, index);
541         newreg = oldreg;
542         if (!value->value.integer.value[0] ^ !invert)
543                 newreg |= 1 << bitnr;
544         else
545                 newreg &= ~(1 << bitnr);
546         change = newreg != oldreg;
547         if (change) {
548                 oxygen_write_ac97(chip, codec, index, newreg);
549                 if (codec == 0 && chip->model->ac97_switch)
550                         chip->model->ac97_switch(chip, index, newreg & 0x8000);
551                 if (index == AC97_LINE) {
552                         oxygen_write_ac97_masked(chip, 0, CM9780_GPIO_STATUS,
553                                                  newreg & 0x8000 ?
554                                                  CM9780_GPO0 : 0, CM9780_GPO0);
555                         if (!(newreg & 0x8000)) {
556                                 mute_ac97_ctl(chip, CONTROL_MIC_CAPTURE_SWITCH);
557                                 mute_ac97_ctl(chip, CONTROL_CD_CAPTURE_SWITCH);
558                                 mute_ac97_ctl(chip, CONTROL_AUX_CAPTURE_SWITCH);
559                         }
560                 } else if ((index == AC97_MIC || index == AC97_CD ||
561                             index == AC97_VIDEO || index == AC97_AUX) &&
562                            bitnr == 15 && !(newreg & 0x8000)) {
563                         mute_ac97_ctl(chip, CONTROL_LINE_CAPTURE_SWITCH);
564                         oxygen_write_ac97_masked(chip, 0, CM9780_GPIO_STATUS,
565                                                  CM9780_GPO0, CM9780_GPO0);
566                 }
567         }
568         mutex_unlock(&chip->mutex);
569         return change;
570 }
571
572 static int ac97_volume_info(struct snd_kcontrol *ctl,
573                             struct snd_ctl_elem_info *info)
574 {
575         info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
576         info->count = 2;
577         info->value.integer.min = 0;
578         info->value.integer.max = 0x1f;
579         return 0;
580 }
581
582 static int ac97_volume_get(struct snd_kcontrol *ctl,
583                            struct snd_ctl_elem_value *value)
584 {
585         struct oxygen *chip = ctl->private_data;
586         unsigned int codec = (ctl->private_value >> 24) & 1;
587         unsigned int index = ctl->private_value & 0xff;
588         u16 reg;
589
590         mutex_lock(&chip->mutex);
591         reg = oxygen_read_ac97(chip, codec, index);
592         mutex_unlock(&chip->mutex);
593         value->value.integer.value[0] = 31 - (reg & 0x1f);
594         value->value.integer.value[1] = 31 - ((reg >> 8) & 0x1f);
595         return 0;
596 }
597
598 static int ac97_volume_put(struct snd_kcontrol *ctl,
599                            struct snd_ctl_elem_value *value)
600 {
601         struct oxygen *chip = ctl->private_data;
602         unsigned int codec = (ctl->private_value >> 24) & 1;
603         unsigned int index = ctl->private_value & 0xff;
604         u16 oldreg, newreg;
605         int change;
606
607         mutex_lock(&chip->mutex);
608         oldreg = oxygen_read_ac97(chip, codec, index);
609         newreg = oldreg;
610         newreg = (newreg & ~0x1f) |
611                 (31 - (value->value.integer.value[0] & 0x1f));
612         newreg = (newreg & ~0x1f00) |
613                 ((31 - (value->value.integer.value[0] & 0x1f)) << 8);
614         change = newreg != oldreg;
615         if (change)
616                 oxygen_write_ac97(chip, codec, index, newreg);
617         mutex_unlock(&chip->mutex);
618         return change;
619 }
620
621 static int ac97_fp_rec_volume_info(struct snd_kcontrol *ctl,
622                                    struct snd_ctl_elem_info *info)
623 {
624         info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
625         info->count = 2;
626         info->value.integer.min = 0;
627         info->value.integer.max = 7;
628         return 0;
629 }
630
631 static int ac97_fp_rec_volume_get(struct snd_kcontrol *ctl,
632                                   struct snd_ctl_elem_value *value)
633 {
634         struct oxygen *chip = ctl->private_data;
635         u16 reg;
636
637         mutex_lock(&chip->mutex);
638         reg = oxygen_read_ac97(chip, 1, AC97_REC_GAIN);
639         mutex_unlock(&chip->mutex);
640         value->value.integer.value[0] = reg & 7;
641         value->value.integer.value[1] = (reg >> 8) & 7;
642         return 0;
643 }
644
645 static int ac97_fp_rec_volume_put(struct snd_kcontrol *ctl,
646                                   struct snd_ctl_elem_value *value)
647 {
648         struct oxygen *chip = ctl->private_data;
649         u16 oldreg, newreg;
650         int change;
651
652         mutex_lock(&chip->mutex);
653         oldreg = oxygen_read_ac97(chip, 1, AC97_REC_GAIN);
654         newreg = oldreg & ~0x0707;
655         newreg = newreg | (value->value.integer.value[0] & 7);
656         newreg = newreg | ((value->value.integer.value[0] & 7) << 8);
657         change = newreg != oldreg;
658         if (change)
659                 oxygen_write_ac97(chip, 1, AC97_REC_GAIN, newreg);
660         mutex_unlock(&chip->mutex);
661         return change;
662 }
663
664 #define AC97_SWITCH(xname, codec, index, bitnr, invert) { \
665                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
666                 .name = xname, \
667                 .info = snd_ctl_boolean_mono_info, \
668                 .get = ac97_switch_get, \
669                 .put = ac97_switch_put, \
670                 .private_value = ((codec) << 24) | ((invert) << 16) | \
671                                  ((bitnr) << 8) | (index), \
672         }
673 #define AC97_VOLUME(xname, codec, index) { \
674                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
675                 .name = xname, \
676                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
677                           SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
678                 .info = ac97_volume_info, \
679                 .get = ac97_volume_get, \
680                 .put = ac97_volume_put, \
681                 .tlv = { .p = ac97_db_scale, }, \
682                 .private_value = ((codec) << 24) | (index), \
683         }
684
685 static DECLARE_TLV_DB_SCALE(monitor_db_scale, -1000, 1000, 0);
686 static DECLARE_TLV_DB_SCALE(ac97_db_scale, -3450, 150, 0);
687 static DECLARE_TLV_DB_SCALE(ac97_rec_db_scale, 0, 150, 0);
688
689 static const struct snd_kcontrol_new controls[] = {
690         {
691                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
692                 .name = "Master Playback Volume",
693                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
694                 .info = dac_volume_info,
695                 .get = dac_volume_get,
696                 .put = dac_volume_put,
697         },
698         {
699                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
700                 .name = "Master Playback Switch",
701                 .info = snd_ctl_boolean_mono_info,
702                 .get = dac_mute_get,
703                 .put = dac_mute_put,
704         },
705         {
706                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
707                 .name = "Stereo Upmixing",
708                 .info = upmix_info,
709                 .get = upmix_get,
710                 .put = upmix_put,
711         },
712         {
713                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
714                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
715                 .info = snd_ctl_boolean_mono_info,
716                 .get = spdif_switch_get,
717                 .put = spdif_switch_put,
718         },
719         {
720                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
721                 .device = 1,
722                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
723                 .info = spdif_info,
724                 .get = spdif_default_get,
725                 .put = spdif_default_put,
726         },
727         {
728                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
729                 .device = 1,
730                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
731                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
732                 .info = spdif_info,
733                 .get = spdif_mask_get,
734         },
735         {
736                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
737                 .device = 1,
738                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
739                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
740                           SNDRV_CTL_ELEM_ACCESS_INACTIVE,
741                 .info = spdif_info,
742                 .get = spdif_pcm_get,
743                 .put = spdif_pcm_put,
744         },
745 };
746
747 static const struct snd_kcontrol_new spdif_input_controls[] = {
748         {
749                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
750                 .device = 1,
751                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK),
752                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
753                 .info = spdif_info,
754                 .get = spdif_input_mask_get,
755         },
756         {
757                 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
758                 .device = 1,
759                 .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
760                 .access = SNDRV_CTL_ELEM_ACCESS_READ,
761                 .info = spdif_info,
762                 .get = spdif_input_default_get,
763         },
764         {
765                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
766                 .name = SNDRV_CTL_NAME_IEC958("Loopback ", NONE, SWITCH),
767                 .info = snd_ctl_boolean_mono_info,
768                 .get = spdif_loopback_get,
769                 .put = spdif_loopback_put,
770         },
771 };
772
773 static const struct {
774         unsigned int pcm_dev;
775         struct snd_kcontrol_new controls[2];
776 } monitor_controls[] = {
777         {
778                 .pcm_dev = CAPTURE_0_FROM_I2S_1,
779                 .controls = {
780                         {
781                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
782                                 .name = "Analog Input Monitor Switch",
783                                 .info = snd_ctl_boolean_mono_info,
784                                 .get = monitor_get,
785                                 .put = monitor_put,
786                                 .private_value = OXYGEN_ADC_MONITOR_A,
787                         },
788                         {
789                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
790                                 .name = "Analog Input Monitor Volume",
791                                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
792                                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
793                                 .info = monitor_volume_info,
794                                 .get = monitor_get,
795                                 .put = monitor_put,
796                                 .private_value = OXYGEN_ADC_MONITOR_A_HALF_VOL
797                                                 | (1 << 8),
798                                 .tlv = { .p = monitor_db_scale, },
799                         },
800                 },
801         },
802         {
803                 .pcm_dev = CAPTURE_0_FROM_I2S_2,
804                 .controls = {
805                         {
806                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
807                                 .name = "Analog Input Monitor Switch",
808                                 .info = snd_ctl_boolean_mono_info,
809                                 .get = monitor_get,
810                                 .put = monitor_put,
811                                 .private_value = OXYGEN_ADC_MONITOR_B,
812                         },
813                         {
814                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
815                                 .name = "Analog Input Monitor Volume",
816                                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
817                                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
818                                 .info = monitor_volume_info,
819                                 .get = monitor_get,
820                                 .put = monitor_put,
821                                 .private_value = OXYGEN_ADC_MONITOR_B_HALF_VOL
822                                                 | (1 << 8),
823                                 .tlv = { .p = monitor_db_scale, },
824                         },
825                 },
826         },
827         {
828                 .pcm_dev = CAPTURE_2_FROM_I2S_2,
829                 .controls = {
830                         {
831                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
832                                 .name = "Analog Input Monitor Switch",
833                                 .index = 1,
834                                 .info = snd_ctl_boolean_mono_info,
835                                 .get = monitor_get,
836                                 .put = monitor_put,
837                                 .private_value = OXYGEN_ADC_MONITOR_B,
838                         },
839                         {
840                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
841                                 .name = "Analog Input Monitor Volume",
842                                 .index = 1,
843                                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
844                                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
845                                 .info = monitor_volume_info,
846                                 .get = monitor_get,
847                                 .put = monitor_put,
848                                 .private_value = OXYGEN_ADC_MONITOR_B_HALF_VOL
849                                                 | (1 << 8),
850                                 .tlv = { .p = monitor_db_scale, },
851                         },
852                 },
853         },
854         {
855                 .pcm_dev = CAPTURE_1_FROM_SPDIF,
856                 .controls = {
857                         {
858                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
859                                 .name = "Digital Input Monitor Switch",
860                                 .info = snd_ctl_boolean_mono_info,
861                                 .get = monitor_get,
862                                 .put = monitor_put,
863                                 .private_value = OXYGEN_ADC_MONITOR_C,
864                         },
865                         {
866                                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
867                                 .name = "Digital Input Monitor Volume",
868                                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
869                                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
870                                 .info = monitor_volume_info,
871                                 .get = monitor_get,
872                                 .put = monitor_put,
873                                 .private_value = OXYGEN_ADC_MONITOR_C_HALF_VOL
874                                                 | (1 << 8),
875                                 .tlv = { .p = monitor_db_scale, },
876                         },
877                 },
878         },
879 };
880
881 static const struct snd_kcontrol_new ac97_controls[] = {
882         AC97_VOLUME("Mic Capture Volume", 0, AC97_MIC),
883         AC97_SWITCH("Mic Capture Switch", 0, AC97_MIC, 15, 1),
884         AC97_SWITCH("Mic Boost (+20dB)", 0, AC97_MIC, 6, 0),
885         AC97_SWITCH("Line Capture Switch", 0, AC97_LINE, 15, 1),
886         AC97_VOLUME("CD Capture Volume", 0, AC97_CD),
887         AC97_SWITCH("CD Capture Switch", 0, AC97_CD, 15, 1),
888         AC97_VOLUME("Aux Capture Volume", 0, AC97_AUX),
889         AC97_SWITCH("Aux Capture Switch", 0, AC97_AUX, 15, 1),
890 };
891
892 static const struct snd_kcontrol_new ac97_fp_controls[] = {
893         AC97_VOLUME("Front Panel Playback Volume", 1, AC97_HEADPHONE),
894         AC97_SWITCH("Front Panel Playback Switch", 1, AC97_HEADPHONE, 15, 1),
895         {
896                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
897                 .name = "Front Panel Capture Volume",
898                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
899                           SNDRV_CTL_ELEM_ACCESS_TLV_READ,
900                 .info = ac97_fp_rec_volume_info,
901                 .get = ac97_fp_rec_volume_get,
902                 .put = ac97_fp_rec_volume_put,
903                 .tlv = { .p = ac97_rec_db_scale, },
904         },
905         AC97_SWITCH("Front Panel Capture Switch", 1, AC97_REC_GAIN, 15, 1),
906 };
907
908 static void oxygen_any_ctl_free(struct snd_kcontrol *ctl)
909 {
910         struct oxygen *chip = ctl->private_data;
911         unsigned int i;
912
913         /* I'm too lazy to write a function for each control :-) */
914         for (i = 0; i < ARRAY_SIZE(chip->controls); ++i)
915                 chip->controls[i] = NULL;
916 }
917
918 static int add_controls(struct oxygen *chip,
919                         const struct snd_kcontrol_new controls[],
920                         unsigned int count)
921 {
922         static const char *const known_ctl_names[CONTROL_COUNT] = {
923                 [CONTROL_SPDIF_PCM] =
924                         SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
925                 [CONTROL_SPDIF_INPUT_BITS] =
926                         SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
927                 [CONTROL_MIC_CAPTURE_SWITCH] = "Mic Capture Switch",
928                 [CONTROL_LINE_CAPTURE_SWITCH] = "Line Capture Switch",
929                 [CONTROL_CD_CAPTURE_SWITCH] = "CD Capture Switch",
930                 [CONTROL_AUX_CAPTURE_SWITCH] = "Aux Capture Switch",
931         };
932         unsigned int i, j;
933         struct snd_kcontrol_new template;
934         struct snd_kcontrol *ctl;
935         int err;
936
937         for (i = 0; i < count; ++i) {
938                 template = controls[i];
939                 if (chip->model->control_filter) {
940                         err = chip->model->control_filter(&template);
941                         if (err < 0)
942                                 return err;
943                         if (err == 1)
944                                 continue;
945                 }
946                 if (!strcmp(template.name, "Master Playback Volume") &&
947                     chip->model->dac_tlv) {
948                         template.tlv.p = chip->model->dac_tlv;
949                         template.access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
950                 }
951                 ctl = snd_ctl_new1(&template, chip);
952                 if (!ctl)
953                         return -ENOMEM;
954                 err = snd_ctl_add(chip->card, ctl);
955                 if (err < 0)
956                         return err;
957                 for (j = 0; j < CONTROL_COUNT; ++j)
958                         if (!strcmp(ctl->id.name, known_ctl_names[j])) {
959                                 chip->controls[j] = ctl;
960                                 ctl->private_free = oxygen_any_ctl_free;
961                         }
962         }
963         return 0;
964 }
965
966 int oxygen_mixer_init(struct oxygen *chip)
967 {
968         unsigned int i;
969         int err;
970
971         err = add_controls(chip, controls, ARRAY_SIZE(controls));
972         if (err < 0)
973                 return err;
974         if (chip->model->pcm_dev_cfg & CAPTURE_1_FROM_SPDIF) {
975                 err = add_controls(chip, spdif_input_controls,
976                                    ARRAY_SIZE(spdif_input_controls));
977                 if (err < 0)
978                         return err;
979         }
980         for (i = 0; i < ARRAY_SIZE(monitor_controls); ++i) {
981                 if (!(chip->model->pcm_dev_cfg & monitor_controls[i].pcm_dev))
982                         continue;
983                 err = add_controls(chip, monitor_controls[i].controls,
984                                    ARRAY_SIZE(monitor_controls[i].controls));
985                 if (err < 0)
986                         return err;
987         }
988         if (chip->has_ac97_0) {
989                 err = add_controls(chip, ac97_controls,
990                                    ARRAY_SIZE(ac97_controls));
991                 if (err < 0)
992                         return err;
993         }
994         if (chip->has_ac97_1) {
995                 err = add_controls(chip, ac97_fp_controls,
996                                    ARRAY_SIZE(ac97_fp_controls));
997                 if (err < 0)
998                         return err;
999         }
1000         return chip->model->mixer_init ? chip->model->mixer_init(chip) : 0;
1001 }