projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ALSA: virtuoso: add Xonar DS headphone jack detection
[deliverable/linux.git] / sound / pci / oxygen / xonar_wm87x6.c
1 /*
2 * card driver for models with WM8776/WM8766 DACs (Xonar DS)
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, see <http://www.gnu.org/licenses/>.
17 */
18
19 /*
20 * Xonar DS
21 * --------
22 *
23 * CMI8788:
24 *
25 * SPI 0 -> WM8766 (surround, center/LFE, back)
26 * SPI 1 -> WM8776 (front, input)
27 *
28 * GPIO 4 <- headphone detect, 0 = plugged
29 * GPIO 6 -> route input jack to mic-in (0) or line-in (1)
30 * GPIO 7 -> enable output to speakers
31 * GPIO 8 -> enable output to speakers
32 *
33 * WM8766:
34 *
35 * input 1 <- line
36 * input 2 <- mic
37 * input 3 <- front mic
38 * input 4 <- aux
39 */
40
41 #include <linux/pci.h>
42 #include <linux/delay.h>
43 #include <sound/control.h>
44 #include <sound/core.h>
45 #include <sound/jack.h>
46 #include <sound/pcm.h>
47 #include <sound/pcm_params.h>
48 #include <sound/tlv.h>
49 #include "xonar.h"
50 #include "wm8776.h"
51 #include "wm8766.h"
52
53 #define GPIO_DS_HP_DETECT 0x0010
54 #define GPIO_DS_INPUT_ROUTE 0x0040
55 #define GPIO_DS_OUTPUT_ENABLE 0x0180
56
57 #define LC_CONTROL_LIMITER 0x40000000
58 #define LC_CONTROL_ALC 0x20000000
59
60 struct xonar_wm87x6 {
61 struct xonar_generic generic;
62 u16 wm8776_regs[0x17];
63 u16 wm8766_regs[0x10];
64 struct snd_kcontrol *line_adcmux_control;
65 struct snd_kcontrol *mic_adcmux_control;
66 struct snd_kcontrol *lc_controls[13];
67 struct snd_jack *hp_jack;
68 };
69
70 static void wm8776_write(struct oxygen *chip,
71 unsigned int reg, unsigned int value)
72 {
73 struct xonar_wm87x6 *data = chip->model_data;
74
75 oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |
76 OXYGEN_SPI_DATA_LENGTH_2 |
77 OXYGEN_SPI_CLOCK_160 |
78 (1 << OXYGEN_SPI_CODEC_SHIFT) |
79 OXYGEN_SPI_CEN_LATCH_CLOCK_LO,
80 (reg << 9) | value);
81 if (reg < ARRAY_SIZE(data->wm8776_regs)) {
82 if (reg >= WM8776_HPLVOL && reg <= WM8776_DACMASTER)
83 value &= ~WM8776_UPDATE;
84 data->wm8776_regs[reg] = value;
85 }
86 }
87
88 static void wm8776_write_cached(struct oxygen *chip,
89 unsigned int reg, unsigned int value)
90 {
91 struct xonar_wm87x6 *data = chip->model_data;
92
93 if (reg >= ARRAY_SIZE(data->wm8776_regs) ||
94 value != data->wm8776_regs[reg])
95 wm8776_write(chip, reg, value);
96 }
97
98 static void wm8766_write(struct oxygen *chip,
99 unsigned int reg, unsigned int value)
100 {
101 struct xonar_wm87x6 *data = chip->model_data;
102
103 oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |
104 OXYGEN_SPI_DATA_LENGTH_2 |
105 OXYGEN_SPI_CLOCK_160 |
106 (0 << OXYGEN_SPI_CODEC_SHIFT) |
107 OXYGEN_SPI_CEN_LATCH_CLOCK_LO,
108 (reg << 9) | value);
109 if (reg < ARRAY_SIZE(data->wm8766_regs)) {
110 if ((reg >= WM8766_LDA1 && reg <= WM8766_RDA1) ||
111 (reg >= WM8766_LDA2 && reg <= WM8766_MASTDA))
112 value &= ~WM8766_UPDATE;
113 data->wm8766_regs[reg] = value;
114 }
115 }
116
117 static void wm8766_write_cached(struct oxygen *chip,
118 unsigned int reg, unsigned int value)
119 {
120 struct xonar_wm87x6 *data = chip->model_data;
121
122 if (reg >= ARRAY_SIZE(data->wm8766_regs) ||
123 value != data->wm8766_regs[reg])
124 wm8766_write(chip, reg, value);
125 }
126
127 static void wm8776_registers_init(struct oxygen *chip)
128 {
129 struct xonar_wm87x6 *data = chip->model_data;
130
131 wm8776_write(chip, WM8776_RESET, 0);
132 wm8776_write(chip, WM8776_DACCTRL1, WM8776_DZCEN |
133 WM8776_PL_LEFT_LEFT | WM8776_PL_RIGHT_RIGHT);
134 wm8776_write(chip, WM8776_DACMUTE, chip->dac_mute ? WM8776_DMUTE : 0);
135 wm8776_write(chip, WM8776_DACIFCTRL,
136 WM8776_DACFMT_LJUST | WM8776_DACWL_24);
137 wm8776_write(chip, WM8776_ADCIFCTRL,
138 data->wm8776_regs[WM8776_ADCIFCTRL]);
139 wm8776_write(chip, WM8776_MSTRCTRL, data->wm8776_regs[WM8776_MSTRCTRL]);
140 wm8776_write(chip, WM8776_PWRDOWN, data->wm8776_regs[WM8776_PWRDOWN]);
141 wm8776_write(chip, WM8776_HPLVOL, data->wm8776_regs[WM8776_HPLVOL]);
142 wm8776_write(chip, WM8776_HPRVOL, data->wm8776_regs[WM8776_HPRVOL] |
143 WM8776_UPDATE);
144 wm8776_write(chip, WM8776_ADCLVOL, data->wm8776_regs[WM8776_ADCLVOL]);
145 wm8776_write(chip, WM8776_ADCRVOL, data->wm8776_regs[WM8776_ADCRVOL]);
146 wm8776_write(chip, WM8776_ADCMUX, data->wm8776_regs[WM8776_ADCMUX]);
147 wm8776_write(chip, WM8776_DACLVOL, chip->dac_volume[0]);
148 wm8776_write(chip, WM8776_DACRVOL, chip->dac_volume[1] | WM8776_UPDATE);
149 }
150
151 static void wm8766_registers_init(struct oxygen *chip)
152 {
153 wm8766_write(chip, WM8766_RESET, 0);
154 wm8766_write(chip, WM8766_INT_CTRL, WM8766_FMT_LJUST | WM8766_IWL_24);
155 wm8766_write(chip, WM8766_DAC_CTRL2,
156 WM8766_ZCD | (chip->dac_mute ? WM8766_DMUTE_MASK : 0));
157 wm8766_write(chip, WM8766_LDA1, chip->dac_volume[2]);
158 wm8766_write(chip, WM8766_RDA1, chip->dac_volume[3]);
159 wm8766_write(chip, WM8766_LDA2, chip->dac_volume[4]);
160 wm8766_write(chip, WM8766_RDA2, chip->dac_volume[5]);
161 wm8766_write(chip, WM8766_LDA3, chip->dac_volume[6]);
162 wm8766_write(chip, WM8766_RDA3, chip->dac_volume[7] | WM8766_UPDATE);
163 }
164
165 static void wm8776_init(struct oxygen *chip)
166 {
167 struct xonar_wm87x6 *data = chip->model_data;
168
169 data->wm8776_regs[WM8776_HPLVOL] = (0x79 - 60) | WM8776_HPZCEN;
170 data->wm8776_regs[WM8776_HPRVOL] = (0x79 - 60) | WM8776_HPZCEN;
171 data->wm8776_regs[WM8776_ADCIFCTRL] =
172 WM8776_ADCFMT_LJUST | WM8776_ADCWL_24 | WM8776_ADCMCLK;
173 data->wm8776_regs[WM8776_MSTRCTRL] =
174 WM8776_ADCRATE_256 | WM8776_DACRATE_256;
175 data->wm8776_regs[WM8776_PWRDOWN] = WM8776_HPPD;
176 data->wm8776_regs[WM8776_ADCLVOL] = 0xa5 | WM8776_ZCA;
177 data->wm8776_regs[WM8776_ADCRVOL] = 0xa5 | WM8776_ZCA;
178 data->wm8776_regs[WM8776_ADCMUX] = 0x001;
179 wm8776_registers_init(chip);
180 }
181
182 static void xonar_ds_report_hp_jack(struct oxygen *chip)
183 {
184 struct xonar_wm87x6 *data = chip->model_data;
185 u16 bits;
186
187 bits = oxygen_read16(chip, OXYGEN_GPIO_DATA);
188 snd_jack_report(data->hp_jack,
189 bits & GPIO_DS_HP_DETECT ? 0 : SND_JACK_HEADPHONE);
190 }
191
192 static void xonar_ds_init(struct oxygen *chip)
193 {
194 struct xonar_wm87x6 *data = chip->model_data;
195
196 data->generic.anti_pop_delay = 300;
197 data->generic.output_enable_bit = GPIO_DS_OUTPUT_ENABLE;
198
199 wm8776_init(chip);
200 wm8766_registers_init(chip);
201
202 oxygen_write16_masked(chip, OXYGEN_GPIO_CONTROL, GPIO_DS_INPUT_ROUTE,
203 GPIO_DS_HP_DETECT | GPIO_DS_INPUT_ROUTE);
204 oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DS_INPUT_ROUTE);
205 oxygen_set_bits16(chip, OXYGEN_GPIO_INTERRUPT_MASK, GPIO_DS_HP_DETECT);
206 chip->interrupt_mask |= OXYGEN_INT_GPIO;
207
208 xonar_enable_output(chip);
209
210 snd_jack_new(chip->card, "Headphone",
211 SND_JACK_HEADPHONE, &data->hp_jack);
212 xonar_ds_report_hp_jack(chip);
213
214 snd_component_add(chip->card, "WM8776");
215 snd_component_add(chip->card, "WM8766");
216 }
217
218 static void xonar_ds_cleanup(struct oxygen *chip)
219 {
220 xonar_disable_output(chip);
221 wm8776_write(chip, WM8776_RESET, 0);
222 }
223
224 static void xonar_ds_suspend(struct oxygen *chip)
225 {
226 xonar_ds_cleanup(chip);
227 }
228
229 static void xonar_ds_resume(struct oxygen *chip)
230 {
231 wm8776_registers_init(chip);
232 wm8766_registers_init(chip);
233 xonar_enable_output(chip);
234 }
235
236 static void wm8776_adc_hardware_filter(unsigned int channel,
237 struct snd_pcm_hardware *hardware)
238 {
239 if (channel == PCM_A) {
240 hardware->rates = SNDRV_PCM_RATE_32000 |
241 SNDRV_PCM_RATE_44100 |
242 SNDRV_PCM_RATE_48000 |
243 SNDRV_PCM_RATE_64000 |
244 SNDRV_PCM_RATE_88200 |
245 SNDRV_PCM_RATE_96000;
246 hardware->rate_max = 96000;
247 }
248 }
249
250 static void set_wm87x6_dac_params(struct oxygen *chip,
251 struct snd_pcm_hw_params *params)
252 {
253 }
254
255 static void set_wm8776_adc_params(struct oxygen *chip,
256 struct snd_pcm_hw_params *params)
257 {
258 u16 reg;
259
260 reg = WM8776_ADCRATE_256 | WM8776_DACRATE_256;
261 if (params_rate(params) > 48000)
262 reg |= WM8776_ADCOSR;
263 wm8776_write_cached(chip, WM8776_MSTRCTRL, reg);
264 }
265
266 static void update_wm8776_volume(struct oxygen *chip)
267 {
268 struct xonar_wm87x6 *data = chip->model_data;
269 u8 to_change;
270
271 if (chip->dac_volume[0] == chip->dac_volume[1]) {
272 if (chip->dac_volume[0] != data->wm8776_regs[WM8776_DACLVOL] ||
273 chip->dac_volume[1] != data->wm8776_regs[WM8776_DACRVOL]) {
274 wm8776_write(chip, WM8776_DACMASTER,
275 chip->dac_volume[0] | WM8776_UPDATE);
276 data->wm8776_regs[WM8776_DACLVOL] = chip->dac_volume[0];
277 data->wm8776_regs[WM8776_DACRVOL] = chip->dac_volume[0];
278 }
279 } else {
280 to_change = (chip->dac_volume[0] !=
281 data->wm8776_regs[WM8776_DACLVOL]) << 0;
282 to_change |= (chip->dac_volume[1] !=
283 data->wm8776_regs[WM8776_DACLVOL]) << 1;
284 if (to_change & 1)
285 wm8776_write(chip, WM8776_DACLVOL, chip->dac_volume[0] |
286 ((to_change & 2) ? 0 : WM8776_UPDATE));
287 if (to_change & 2)
288 wm8776_write(chip, WM8776_DACRVOL,
289 chip->dac_volume[1] | WM8776_UPDATE);
290 }
291 }
292
293 static void update_wm87x6_volume(struct oxygen *chip)
294 {
295 static const u8 wm8766_regs[6] = {
296 WM8766_LDA1, WM8766_RDA1,
297 WM8766_LDA2, WM8766_RDA2,
298 WM8766_LDA3, WM8766_RDA3,
299 };
300 struct xonar_wm87x6 *data = chip->model_data;
301 unsigned int i;
302 u8 to_change;
303
304 update_wm8776_volume(chip);
305 if (chip->dac_volume[2] == chip->dac_volume[3] &&
306 chip->dac_volume[2] == chip->dac_volume[4] &&
307 chip->dac_volume[2] == chip->dac_volume[5] &&
308 chip->dac_volume[2] == chip->dac_volume[6] &&
309 chip->dac_volume[2] == chip->dac_volume[7]) {
310 to_change = 0;
311 for (i = 0; i < 6; ++i)
312 if (chip->dac_volume[2] !=
313 data->wm8766_regs[wm8766_regs[i]])
314 to_change = 1;
315 if (to_change) {
316 wm8766_write(chip, WM8766_MASTDA,
317 chip->dac_volume[2] | WM8766_UPDATE);
318 for (i = 0; i < 6; ++i)
319 data->wm8766_regs[wm8766_regs[i]] =
320 chip->dac_volume[2];
321 }
322 } else {
323 to_change = 0;
324 for (i = 0; i < 6; ++i)
325 to_change |= (chip->dac_volume[2 + i] !=
326 data->wm8766_regs[wm8766_regs[i]]) << i;
327 for (i = 0; i < 6; ++i)
328 if (to_change & (1 << i))
329 wm8766_write(chip, wm8766_regs[i],
330 chip->dac_volume[2 + i] |
331 ((to_change & (0x3e << i))
332 ? 0 : WM8766_UPDATE));
333 }
334 }
335
336 static void update_wm8776_mute(struct oxygen *chip)
337 {
338 wm8776_write_cached(chip, WM8776_DACMUTE,
339 chip->dac_mute ? WM8776_DMUTE : 0);
340 }
341
342 static void update_wm87x6_mute(struct oxygen *chip)
343 {
344 update_wm8776_mute(chip);
345 wm8766_write_cached(chip, WM8766_DAC_CTRL2, WM8766_ZCD |
346 (chip->dac_mute ? WM8766_DMUTE_MASK : 0));
347 }
348
349 static void xonar_ds_gpio_changed(struct oxygen *chip)
350 {
351 xonar_ds_report_hp_jack(chip);
352 }
353
354 static int wm8776_bit_switch_get(struct snd_kcontrol *ctl,
355 struct snd_ctl_elem_value *value)
356 {
357 struct oxygen *chip = ctl->private_data;
358 struct xonar_wm87x6 *data = chip->model_data;
359 u16 bit = ctl->private_value & 0xffff;
360 unsigned int reg_index = (ctl->private_value >> 16) & 0xff;
361 bool invert = (ctl->private_value >> 24) & 1;
362
363 value->value.integer.value[0] =
364 ((data->wm8776_regs[reg_index] & bit) != 0) ^ invert;
365 return 0;
366 }
367
368 static int wm8776_bit_switch_put(struct snd_kcontrol *ctl,
369 struct snd_ctl_elem_value *value)
370 {
371 struct oxygen *chip = ctl->private_data;
372 struct xonar_wm87x6 *data = chip->model_data;
373 u16 bit = ctl->private_value & 0xffff;
374 u16 reg_value;
375 unsigned int reg_index = (ctl->private_value >> 16) & 0xff;
376 bool invert = (ctl->private_value >> 24) & 1;
377 int changed;
378
379 mutex_lock(&chip->mutex);
380 reg_value = data->wm8776_regs[reg_index] & ~bit;
381 if (value->value.integer.value[0] ^ invert)
382 reg_value |= bit;
383 changed = reg_value != data->wm8776_regs[reg_index];
384 if (changed)
385 wm8776_write(chip, reg_index, reg_value);
386 mutex_unlock(&chip->mutex);
387 return changed;
388 }
389
390 static int wm8776_field_enum_info(struct snd_kcontrol *ctl,
391 struct snd_ctl_elem_info *info)
392 {
393 static const char *const hld[16] = {
394 "0 ms", "2.67 ms", "5.33 ms", "10.6 ms",
395 "21.3 ms", "42.7 ms", "85.3 ms", "171 ms",
396 "341 ms", "683 ms", "1.37 s", "2.73 s",
397 "5.46 s", "10.9 s", "21.8 s", "43.7 s",
398 };
399 static const char *const atk_lim[11] = {
400 "0.25 ms", "0.5 ms", "1 ms", "2 ms",
401 "4 ms", "8 ms", "16 ms", "32 ms",
402 "64 ms", "128 ms", "256 ms",
403 };
404 static const char *const atk_alc[11] = {
405 "8.40 ms", "16.8 ms", "33.6 ms", "67.2 ms",
406 "134 ms", "269 ms", "538 ms", "1.08 s",
407 "2.15 s", "4.3 s", "8.6 s",
408 };
409 static const char *const dcy_lim[11] = {
410 "1.2 ms", "2.4 ms", "4.8 ms", "9.6 ms",
411 "19.2 ms", "38.4 ms", "76.8 ms", "154 ms",
412 "307 ms", "614 ms", "1.23 s",
413 };
414 static const char *const dcy_alc[11] = {
415 "33.5 ms", "67.0 ms", "134 ms", "268 ms",
416 "536 ms", "1.07 s", "2.14 s", "4.29 s",
417 "8.58 s", "17.2 s", "34.3 s",
418 };
419 static const char *const tranwin[8] = {
420 "0 us", "62.5 us", "125 us", "250 us",
421 "500 us", "1 ms", "2 ms", "4 ms",
422 };
423 u8 max;
424 const char *const *names;
425
426 max = (ctl->private_value >> 12) & 0xf;
427 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
428 info->count = 1;
429 info->value.enumerated.items = max + 1;
430 if (info->value.enumerated.item > max)
431 info->value.enumerated.item = max;
432 switch ((ctl->private_value >> 24) & 0x1f) {
433 case WM8776_ALCCTRL2:
434 names = hld;
435 break;
436 case WM8776_ALCCTRL3:
437 if (((ctl->private_value >> 20) & 0xf) == 0) {
438 if (ctl->private_value & LC_CONTROL_LIMITER)
439 names = atk_lim;
440 else
441 names = atk_alc;
442 } else {
443 if (ctl->private_value & LC_CONTROL_LIMITER)
444 names = dcy_lim;
445 else
446 names = dcy_alc;
447 }
448 break;
449 case WM8776_LIMITER:
450 names = tranwin;
451 break;
452 default:
453 return -ENXIO;
454 }
455 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
456 return 0;
457 }
458
459 static int wm8776_field_volume_info(struct snd_kcontrol *ctl,
460 struct snd_ctl_elem_info *info)
461 {
462 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
463 info->count = 1;
464 info->value.integer.min = (ctl->private_value >> 8) & 0xf;
465 info->value.integer.max = (ctl->private_value >> 12) & 0xf;
466 return 0;
467 }
468
469 static void wm8776_field_set_from_ctl(struct snd_kcontrol *ctl)
470 {
471 struct oxygen *chip = ctl->private_data;
472 struct xonar_wm87x6 *data = chip->model_data;
473 unsigned int value, reg_index, mode;
474 u8 min, max, shift;
475 u16 mask, reg_value;
476 bool invert;
477
478 if ((data->wm8776_regs[WM8776_ALCCTRL1] & WM8776_LCSEL_MASK) ==
479 WM8776_LCSEL_LIMITER)
480 mode = LC_CONTROL_LIMITER;
481 else
482 mode = LC_CONTROL_ALC;
483 if (!(ctl->private_value & mode))
484 return;
485
486 value = ctl->private_value & 0xf;
487 min = (ctl->private_value >> 8) & 0xf;
488 max = (ctl->private_value >> 12) & 0xf;
489 mask = (ctl->private_value >> 16) & 0xf;
490 shift = (ctl->private_value >> 20) & 0xf;
491 reg_index = (ctl->private_value >> 24) & 0x1f;
492 invert = (ctl->private_value >> 29) & 0x1;
493
494 if (invert)
495 value = max - (value - min);
496 reg_value = data->wm8776_regs[reg_index];
497 reg_value &= ~(mask << shift);
498 reg_value |= value << shift;
499 wm8776_write_cached(chip, reg_index, reg_value);
500 }
501
502 static int wm8776_field_set(struct snd_kcontrol *ctl, unsigned int value)
503 {
504 struct oxygen *chip = ctl->private_data;
505 u8 min, max;
506 int changed;
507
508 min = (ctl->private_value >> 8) & 0xf;
509 max = (ctl->private_value >> 12) & 0xf;
510 if (value < min || value > max)
511 return -EINVAL;
512 mutex_lock(&chip->mutex);
513 changed = value != (ctl->private_value & 0xf);
514 if (changed) {
515 ctl->private_value = (ctl->private_value & ~0xf) | value;
516 wm8776_field_set_from_ctl(ctl);
517 }
518 mutex_unlock(&chip->mutex);
519 return changed;
520 }
521
522 static int wm8776_field_enum_get(struct snd_kcontrol *ctl,
523 struct snd_ctl_elem_value *value)
524 {
525 value->value.enumerated.item[0] = ctl->private_value & 0xf;
526 return 0;
527 }
528
529 static int wm8776_field_volume_get(struct snd_kcontrol *ctl,
530 struct snd_ctl_elem_value *value)
531 {
532 value->value.integer.value[0] = ctl->private_value & 0xf;
533 return 0;
534 }
535
536 static int wm8776_field_enum_put(struct snd_kcontrol *ctl,
537 struct snd_ctl_elem_value *value)
538 {
539 return wm8776_field_set(ctl, value->value.enumerated.item[0]);
540 }
541
542 static int wm8776_field_volume_put(struct snd_kcontrol *ctl,
543 struct snd_ctl_elem_value *value)
544 {
545 return wm8776_field_set(ctl, value->value.integer.value[0]);
546 }
547
548 static int wm8776_hp_vol_info(struct snd_kcontrol *ctl,
549 struct snd_ctl_elem_info *info)
550 {
551 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
552 info->count = 2;
553 info->value.integer.min = 0x79 - 60;
554 info->value.integer.max = 0x7f;
555 return 0;
556 }
557
558 static int wm8776_hp_vol_get(struct snd_kcontrol *ctl,
559 struct snd_ctl_elem_value *value)
560 {
561 struct oxygen *chip = ctl->private_data;
562 struct xonar_wm87x6 *data = chip->model_data;
563
564 mutex_lock(&chip->mutex);
565 value->value.integer.value[0] =
566 data->wm8776_regs[WM8776_HPLVOL] & WM8776_HPATT_MASK;
567 value->value.integer.value[1] =
568 data->wm8776_regs[WM8776_HPRVOL] & WM8776_HPATT_MASK;
569 mutex_unlock(&chip->mutex);
570 return 0;
571 }
572
573 static int wm8776_hp_vol_put(struct snd_kcontrol *ctl,
574 struct snd_ctl_elem_value *value)
575 {
576 struct oxygen *chip = ctl->private_data;
577 struct xonar_wm87x6 *data = chip->model_data;
578 u8 to_update;
579
580 mutex_lock(&chip->mutex);
581 to_update = (value->value.integer.value[0] !=
582 (data->wm8776_regs[WM8776_HPLVOL] & WM8776_HPATT_MASK))
583 << 0;
584 to_update |= (value->value.integer.value[1] !=
585 (data->wm8776_regs[WM8776_HPRVOL] & WM8776_HPATT_MASK))
586 << 1;
587 if (value->value.integer.value[0] == value->value.integer.value[1]) {
588 if (to_update) {
589 wm8776_write(chip, WM8776_HPMASTER,
590 value->value.integer.value[0] |
591 WM8776_HPZCEN | WM8776_UPDATE);
592 data->wm8776_regs[WM8776_HPLVOL] =
593 value->value.integer.value[0] | WM8776_HPZCEN;
594 data->wm8776_regs[WM8776_HPRVOL] =
595 value->value.integer.value[0] | WM8776_HPZCEN;
596 }
597 } else {
598 if (to_update & 1)
599 wm8776_write(chip, WM8776_HPLVOL,
600 value->value.integer.value[0] |
601 WM8776_HPZCEN |
602 ((to_update & 2) ? 0 : WM8776_UPDATE));
603 if (to_update & 2)
604 wm8776_write(chip, WM8776_HPRVOL,
605 value->value.integer.value[1] |
606 WM8776_HPZCEN | WM8776_UPDATE);
607 }
608 mutex_unlock(&chip->mutex);
609 return to_update != 0;
610 }
611
612 static int wm8776_input_mux_get(struct snd_kcontrol *ctl,
613 struct snd_ctl_elem_value *value)
614 {
615 struct oxygen *chip = ctl->private_data;
616 struct xonar_wm87x6 *data = chip->model_data;
617 unsigned int mux_bit = ctl->private_value;
618
619 value->value.integer.value[0] =
620 !!(data->wm8776_regs[WM8776_ADCMUX] & mux_bit);
621 return 0;
622 }
623
624 static int wm8776_input_mux_put(struct snd_kcontrol *ctl,
625 struct snd_ctl_elem_value *value)
626 {
627 struct oxygen *chip = ctl->private_data;
628 struct xonar_wm87x6 *data = chip->model_data;
629 struct snd_kcontrol *other_ctl;
630 unsigned int mux_bit = ctl->private_value;
631 u16 reg;
632 int changed;
633
634 mutex_lock(&chip->mutex);
635 reg = data->wm8776_regs[WM8776_ADCMUX];
636 if (value->value.integer.value[0]) {
637 reg |= mux_bit;
638 /* line-in and mic-in are exclusive */
639 mux_bit ^= 3;
640 if (reg & mux_bit) {
641 reg &= ~mux_bit;
642 if (mux_bit == 1)
643 other_ctl = data->line_adcmux_control;
644 else
645 other_ctl = data->mic_adcmux_control;
646 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
647 &other_ctl->id);
648 }
649 } else
650 reg &= ~mux_bit;
651 changed = reg != data->wm8776_regs[WM8776_ADCMUX];
652 if (changed) {
653 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
654 reg & 1 ? GPIO_DS_INPUT_ROUTE : 0,
655 GPIO_DS_INPUT_ROUTE);
656 wm8776_write(chip, WM8776_ADCMUX, reg);
657 }
658 mutex_unlock(&chip->mutex);
659 return changed;
660 }
661
662 static int wm8776_input_vol_info(struct snd_kcontrol *ctl,
663 struct snd_ctl_elem_info *info)
664 {
665 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
666 info->count = 2;
667 info->value.integer.min = 0xa5;
668 info->value.integer.max = 0xff;
669 return 0;
670 }
671
672 static int wm8776_input_vol_get(struct snd_kcontrol *ctl,
673 struct snd_ctl_elem_value *value)
674 {
675 struct oxygen *chip = ctl->private_data;
676 struct xonar_wm87x6 *data = chip->model_data;
677
678 mutex_lock(&chip->mutex);
679 value->value.integer.value[0] =
680 data->wm8776_regs[WM8776_ADCLVOL] & WM8776_AGMASK;
681 value->value.integer.value[1] =
682 data->wm8776_regs[WM8776_ADCRVOL] & WM8776_AGMASK;
683 mutex_unlock(&chip->mutex);
684 return 0;
685 }
686
687 static int wm8776_input_vol_put(struct snd_kcontrol *ctl,
688 struct snd_ctl_elem_value *value)
689 {
690 struct oxygen *chip = ctl->private_data;
691 struct xonar_wm87x6 *data = chip->model_data;
692 int changed = 0;
693
694 mutex_lock(&chip->mutex);
695 changed = (value->value.integer.value[0] !=
696 (data->wm8776_regs[WM8776_ADCLVOL] & WM8776_AGMASK)) ||
697 (value->value.integer.value[1] !=
698 (data->wm8776_regs[WM8776_ADCRVOL] & WM8776_AGMASK));
699 wm8776_write_cached(chip, WM8776_ADCLVOL,
700 value->value.integer.value[0] | WM8776_ZCA);
701 wm8776_write_cached(chip, WM8776_ADCRVOL,
702 value->value.integer.value[1] | WM8776_ZCA);
703 mutex_unlock(&chip->mutex);
704 return changed;
705 }
706
707 static int wm8776_level_control_info(struct snd_kcontrol *ctl,
708 struct snd_ctl_elem_info *info)
709 {
710 static const char *const names[3] = {
711 "None", "Peak Limiter", "Automatic Level Control"
712 };
713 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
714 info->count = 1;
715 info->value.enumerated.items = 3;
716 if (info->value.enumerated.item >= 3)
717 info->value.enumerated.item = 2;
718 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
719 return 0;
720 }
721
722 static int wm8776_level_control_get(struct snd_kcontrol *ctl,
723 struct snd_ctl_elem_value *value)
724 {
725 struct oxygen *chip = ctl->private_data;
726 struct xonar_wm87x6 *data = chip->model_data;
727
728 if (!(data->wm8776_regs[WM8776_ALCCTRL2] & WM8776_LCEN))
729 value->value.enumerated.item[0] = 0;
730 else if ((data->wm8776_regs[WM8776_ALCCTRL1] & WM8776_LCSEL_MASK) ==
731 WM8776_LCSEL_LIMITER)
732 value->value.enumerated.item[0] = 1;
733 else
734 value->value.enumerated.item[0] = 2;
735 return 0;
736 }
737
738 static void activate_control(struct oxygen *chip,
739 struct snd_kcontrol *ctl, unsigned int mode)
740 {
741 unsigned int access;
742
743 if (ctl->private_value & mode)
744 access = 0;
745 else
746 access = SNDRV_CTL_ELEM_ACCESS_INACTIVE;
747 if ((ctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_INACTIVE) != access) {
748 ctl->vd[0].access ^= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
749 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
750 }
751 }
752
753 static int wm8776_level_control_put(struct snd_kcontrol *ctl,
754 struct snd_ctl_elem_value *value)
755 {
756 struct oxygen *chip = ctl->private_data;
757 struct xonar_wm87x6 *data = chip->model_data;
758 unsigned int mode = 0, i;
759 u16 ctrl1, ctrl2;
760 int changed;
761
762 if (value->value.enumerated.item[0] >= 3)
763 return -EINVAL;
764 mutex_lock(&chip->mutex);
765 changed = value->value.enumerated.item[0] != ctl->private_value;
766 if (changed) {
767 ctl->private_value = value->value.enumerated.item[0];
768 ctrl1 = data->wm8776_regs[WM8776_ALCCTRL1];
769 ctrl2 = data->wm8776_regs[WM8776_ALCCTRL2];
770 switch (value->value.enumerated.item[0]) {
771 default:
772 wm8776_write_cached(chip, WM8776_ALCCTRL2,
773 ctrl2 & ~WM8776_LCEN);
774 break;
775 case 1:
776 wm8776_write_cached(chip, WM8776_ALCCTRL1,
777 (ctrl1 & ~WM8776_LCSEL_MASK) |
778 WM8776_LCSEL_LIMITER);
779 wm8776_write_cached(chip, WM8776_ALCCTRL2,
780 ctrl2 | WM8776_LCEN);
781 mode = LC_CONTROL_LIMITER;
782 break;
783 case 2:
784 wm8776_write_cached(chip, WM8776_ALCCTRL1,
785 (ctrl1 & ~WM8776_LCSEL_MASK) |
786 WM8776_LCSEL_ALC_STEREO);
787 wm8776_write_cached(chip, WM8776_ALCCTRL2,
788 ctrl2 | WM8776_LCEN);
789 mode = LC_CONTROL_ALC;
790 break;
791 }
792 for (i = 0; i < ARRAY_SIZE(data->lc_controls); ++i)
793 activate_control(chip, data->lc_controls[i], mode);
794 }
795 mutex_unlock(&chip->mutex);
796 return changed;
797 }
798
799 static int hpf_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
800 {
801 static const char *const names[2] = {
802 "None", "High-pass Filter"
803 };
804
805 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
806 info->count = 1;
807 info->value.enumerated.items = 2;
808 if (info->value.enumerated.item >= 2)
809 info->value.enumerated.item = 1;
810 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
811 return 0;
812 }
813
814 static int hpf_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
815 {
816 struct oxygen *chip = ctl->private_data;
817 struct xonar_wm87x6 *data = chip->model_data;
818
819 value->value.enumerated.item[0] =
820 !(data->wm8776_regs[WM8776_ADCIFCTRL] & WM8776_ADCHPD);
821 return 0;
822 }
823
824 static int hpf_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
825 {
826 struct oxygen *chip = ctl->private_data;
827 struct xonar_wm87x6 *data = chip->model_data;
828 unsigned int reg;
829 int changed;
830
831 mutex_lock(&chip->mutex);
832 reg = data->wm8776_regs[WM8776_ADCIFCTRL] & ~WM8776_ADCHPD;
833 if (!value->value.enumerated.item[0])
834 reg |= WM8776_ADCHPD;
835 changed = reg != data->wm8776_regs[WM8776_ADCIFCTRL];
836 if (changed)
837 wm8776_write(chip, WM8776_ADCIFCTRL, reg);
838 mutex_unlock(&chip->mutex);
839 return changed;
840 }
841
842 #define WM8776_BIT_SWITCH(xname, reg, bit, invert, flags) { \
843 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
844 .name = xname, \
845 .info = snd_ctl_boolean_mono_info, \
846 .get = wm8776_bit_switch_get, \
847 .put = wm8776_bit_switch_put, \
848 .private_value = ((reg) << 16) | (bit) | ((invert) << 24) | (flags), \
849 }
850 #define _WM8776_FIELD_CTL(xname, reg, shift, initval, min, max, mask, flags) \
851 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
852 .name = xname, \
853 .private_value = (initval) | ((min) << 8) | ((max) << 12) | \
854 ((mask) << 16) | ((shift) << 20) | ((reg) << 24) | (flags)
855 #define WM8776_FIELD_CTL_ENUM(xname, reg, shift, init, min, max, mask, flags) {\
856 _WM8776_FIELD_CTL(xname " Capture Enum", \
857 reg, shift, init, min, max, mask, flags), \
858 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
859 SNDRV_CTL_ELEM_ACCESS_INACTIVE, \
860 .info = wm8776_field_enum_info, \
861 .get = wm8776_field_enum_get, \
862 .put = wm8776_field_enum_put, \
863 }
864 #define WM8776_FIELD_CTL_VOLUME(a, b, c, d, e, f, g, h, tlv_p) { \
865 _WM8776_FIELD_CTL(a " Capture Volume", b, c, d, e, f, g, h), \
866 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
867 SNDRV_CTL_ELEM_ACCESS_INACTIVE | \
868 SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
869 .info = wm8776_field_volume_info, \
870 .get = wm8776_field_volume_get, \
871 .put = wm8776_field_volume_put, \
872 .tlv = { .p = tlv_p }, \
873 }
874
875 static const DECLARE_TLV_DB_SCALE(wm87x6_dac_db_scale, -6000, 50, 0);
876 static const DECLARE_TLV_DB_SCALE(wm8776_adc_db_scale, -2100, 50, 0);
877 static const DECLARE_TLV_DB_SCALE(wm8776_hp_db_scale, -6000, 100, 0);
878 static const DECLARE_TLV_DB_SCALE(wm8776_lct_db_scale, -1600, 100, 0);
879 static const DECLARE_TLV_DB_SCALE(wm8776_maxgain_db_scale, 0, 400, 0);
880 static const DECLARE_TLV_DB_SCALE(wm8776_ngth_db_scale, -7800, 600, 0);
881 static const DECLARE_TLV_DB_SCALE(wm8776_maxatten_lim_db_scale, -1200, 100, 0);
882 static const DECLARE_TLV_DB_SCALE(wm8776_maxatten_alc_db_scale, -2100, 400, 0);
883
884 static const struct snd_kcontrol_new ds_controls[] = {
885 {
886 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
887 .name = "Headphone Playback Volume",
888 .info = wm8776_hp_vol_info,
889 .get = wm8776_hp_vol_get,
890 .put = wm8776_hp_vol_put,
891 .tlv = { .p = wm8776_hp_db_scale },
892 },
893 WM8776_BIT_SWITCH("Headphone Playback Switch",
894 WM8776_PWRDOWN, WM8776_HPPD, 1, 0),
895 {
896 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
897 .name = "Input Capture Volume",
898 .info = wm8776_input_vol_info,
899 .get = wm8776_input_vol_get,
900 .put = wm8776_input_vol_put,
901 .tlv = { .p = wm8776_adc_db_scale },
902 },
903 {
904 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
905 .name = "Line Capture Switch",
906 .info = snd_ctl_boolean_mono_info,
907 .get = wm8776_input_mux_get,
908 .put = wm8776_input_mux_put,
909 .private_value = 1 << 0,
910 },
911 {
912 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
913 .name = "Mic Capture Switch",
914 .info = snd_ctl_boolean_mono_info,
915 .get = wm8776_input_mux_get,
916 .put = wm8776_input_mux_put,
917 .private_value = 1 << 1,
918 },
919 WM8776_BIT_SWITCH("Front Mic Capture Switch",
920 WM8776_ADCMUX, 1 << 2, 0, 0),
921 WM8776_BIT_SWITCH("Aux Capture Switch",
922 WM8776_ADCMUX, 1 << 3, 0, 0),
923 {
924 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
925 .name = "ADC Filter Capture Enum",
926 .info = hpf_info,
927 .get = hpf_get,
928 .put = hpf_put,
929 },
930 {
931 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
932 .name = "Level Control Capture Enum",
933 .info = wm8776_level_control_info,
934 .get = wm8776_level_control_get,
935 .put = wm8776_level_control_put,
936 .private_value = 0,
937 },
938 };
939 static const struct snd_kcontrol_new lc_controls[] = {
940 WM8776_FIELD_CTL_VOLUME("Limiter Threshold",
941 WM8776_ALCCTRL1, 0, 11, 0, 15, 0xf,
942 LC_CONTROL_LIMITER, wm8776_lct_db_scale),
943 WM8776_FIELD_CTL_ENUM("Limiter Attack Time",
944 WM8776_ALCCTRL3, 0, 2, 0, 10, 0xf,
945 LC_CONTROL_LIMITER),
946 WM8776_FIELD_CTL_ENUM("Limiter Decay Time",
947 WM8776_ALCCTRL3, 4, 3, 0, 10, 0xf,
948 LC_CONTROL_LIMITER),
949 WM8776_FIELD_CTL_ENUM("Limiter Transient Window",
950 WM8776_LIMITER, 4, 2, 0, 7, 0x7,
951 LC_CONTROL_LIMITER),
952 WM8776_FIELD_CTL_VOLUME("Limiter Maximum Attenuation",
953 WM8776_LIMITER, 0, 6, 3, 12, 0xf,
954 LC_CONTROL_LIMITER,
955 wm8776_maxatten_lim_db_scale),
956 WM8776_FIELD_CTL_VOLUME("ALC Target Level",
957 WM8776_ALCCTRL1, 0, 11, 0, 15, 0xf,
958 LC_CONTROL_ALC, wm8776_lct_db_scale),
959 WM8776_FIELD_CTL_ENUM("ALC Attack Time",
960 WM8776_ALCCTRL3, 0, 2, 0, 10, 0xf,
961 LC_CONTROL_ALC),
962 WM8776_FIELD_CTL_ENUM("ALC Decay Time",
963 WM8776_ALCCTRL3, 4, 3, 0, 10, 0xf,
964 LC_CONTROL_ALC),
965 WM8776_FIELD_CTL_VOLUME("ALC Maximum Gain",
966 WM8776_ALCCTRL1, 4, 7, 1, 7, 0x7,
967 LC_CONTROL_ALC, wm8776_maxgain_db_scale),
968 WM8776_FIELD_CTL_VOLUME("ALC Maximum Attenuation",
969 WM8776_LIMITER, 0, 10, 10, 15, 0xf,
970 LC_CONTROL_ALC, wm8776_maxatten_alc_db_scale),
971 WM8776_FIELD_CTL_ENUM("ALC Hold Time",
972 WM8776_ALCCTRL2, 0, 0, 0, 15, 0xf,
973 LC_CONTROL_ALC),
974 WM8776_BIT_SWITCH("Noise Gate Capture Switch",
975 WM8776_NOISEGATE, WM8776_NGAT, 0,
976 LC_CONTROL_ALC),
977 WM8776_FIELD_CTL_VOLUME("Noise Gate Threshold",
978 WM8776_NOISEGATE, 2, 0, 0, 7, 0x7,
979 LC_CONTROL_ALC, wm8776_ngth_db_scale),
980 };
981
982 static int xonar_ds_control_filter(struct snd_kcontrol_new *template)
983 {
984 if (!strncmp(template->name, "CD Capture ", 11))
985 return 1; /* no CD input */
986 return 0;
987 }
988
989 static int xonar_ds_mixer_init(struct oxygen *chip)
990 {
991 struct xonar_wm87x6 *data = chip->model_data;
992 unsigned int i;
993 struct snd_kcontrol *ctl;
994 int err;
995
996 for (i = 0; i < ARRAY_SIZE(ds_controls); ++i) {
997 ctl = snd_ctl_new1(&ds_controls[i], chip);
998 if (!ctl)
999 return -ENOMEM;
1000 err = snd_ctl_add(chip->card, ctl);
1001 if (err < 0)
1002 return err;
1003 if (!strcmp(ctl->id.name, "Line Capture Switch"))
1004 data->line_adcmux_control = ctl;
1005 else if (!strcmp(ctl->id.name, "Mic Capture Switch"))
1006 data->mic_adcmux_control = ctl;
1007 }
1008 if (!data->line_adcmux_control || !data->mic_adcmux_control)
1009 return -ENXIO;
1010 BUILD_BUG_ON(ARRAY_SIZE(lc_controls) != ARRAY_SIZE(data->lc_controls));
1011 for (i = 0; i < ARRAY_SIZE(lc_controls); ++i) {
1012 ctl = snd_ctl_new1(&lc_controls[i], chip);
1013 if (!ctl)
1014 return -ENOMEM;
1015 err = snd_ctl_add(chip->card, ctl);
1016 if (err < 0)
1017 return err;
1018 data->lc_controls[i] = ctl;
1019 }
1020 return 0;
1021 }
1022
1023 static const struct oxygen_model model_xonar_ds = {
1024 .shortname = "Xonar DS",
1025 .longname = "Asus Virtuoso 200",
1026 .chip = "AV200",
1027 .init = xonar_ds_init,
1028 .control_filter = xonar_ds_control_filter,
1029 .mixer_init = xonar_ds_mixer_init,
1030 .cleanup = xonar_ds_cleanup,
1031 .suspend = xonar_ds_suspend,
1032 .resume = xonar_ds_resume,
1033 .pcm_hardware_filter = wm8776_adc_hardware_filter,
1034 .get_i2s_mclk = oxygen_default_i2s_mclk,
1035 .set_dac_params = set_wm87x6_dac_params,
1036 .set_adc_params = set_wm8776_adc_params,
1037 .update_dac_volume = update_wm87x6_volume,
1038 .update_dac_mute = update_wm87x6_mute,
1039 .gpio_changed = xonar_ds_gpio_changed,
1040 .dac_tlv = wm87x6_dac_db_scale,
1041 .model_data_size = sizeof(struct xonar_wm87x6),
1042 .device_config = PLAYBACK_0_TO_I2S |
1043 PLAYBACK_1_TO_SPDIF |
1044 CAPTURE_0_FROM_I2S_1,
1045 .dac_channels = 8,
1046 .dac_volume_min = 255 - 2*60,
1047 .dac_volume_max = 255,
1048 .function_flags = OXYGEN_FUNCTION_SPI,
1049 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1050 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1051 };
1052
1053 int __devinit get_xonar_wm87x6_model(struct oxygen *chip,
1054 const struct pci_device_id *id)
1055 {
1056 switch (id->subdevice) {
1057 case 0x838e:
1058 chip->model = model_xonar_ds;
1059 break;
1060 default:
1061 return -EINVAL;
1062 }
1063 return 0;
1064 }
Linux kernel - Deliverables
This page took 0.070723 seconds and 5 git commands to generate.