?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: virtuoso: add HDAV1.3 Slim PCI ID
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / sound / pci / oxygen / xonar_pcm179x.c
blob571d0ae42afbc89da9ad9da903f826700359134d
1 /*
2 * card driver for models with PCM1796 DACs (Xonar D2/D2X/HDAV1.3/ST/STX)
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 D2/D2X
21 * ------------
22 *
23 * CMI8788:
24 *
25 * SPI 0 -> 1st PCM1796 (front)
26 * SPI 1 -> 2nd PCM1796 (surround)
27 * SPI 2 -> 3rd PCM1796 (center/LFE)
28 * SPI 4 -> 4th PCM1796 (back)
29 *
30 * GPIO 2 -> M0 of CS5381
31 * GPIO 3 -> M1 of CS5381
32 * GPIO 5 <- external power present (D2X only)
33 * GPIO 7 -> ALT
34 * GPIO 8 -> enable output to speakers
35 *
36 * CM9780:
37 *
38 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
39 */
40
41 /*
42 * Xonar HDAV1.3 (Deluxe)
43 * ----------------------
44 *
45 * CMI8788:
46 *
47 * I²C <-> PCM1796 (front)
48 *
49 * GPI 0 <- external power present
50 *
51 * GPIO 0 -> enable output to speakers
52 * GPIO 2 -> M0 of CS5381
53 * GPIO 3 -> M1 of CS5381
54 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
55 *
56 * TXD -> HDMI controller
57 * RXD <- HDMI controller
58 *
59 * PCM1796 front: AD1,0 <- 0,0
60 *
61 * CM9780:
62 *
63 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
64 *
65 * no daughterboard
66 * ----------------
67 *
68 * GPIO 4 <- 1
69 *
70 * H6 daughterboard
71 * ----------------
72 *
73 * GPIO 4 <- 0
74 * GPIO 5 <- 0
75 *
76 * I²C <-> PCM1796 (surround)
77 * <-> PCM1796 (center/LFE)
78 * <-> PCM1796 (back)
79 *
80 * PCM1796 surround: AD1,0 <- 0,1
81 * PCM1796 center/LFE: AD1,0 <- 1,0
82 * PCM1796 back: AD1,0 <- 1,1
83 *
84 * unknown daughterboard
85 * ---------------------
86 *
87 * GPIO 4 <- 0
88 * GPIO 5 <- 1
89 *
90 * I²C <-> CS4362A (surround, center/LFE, back)
91 *
92 * CS4362A: AD0 <- 0
93 */
94
95 /*
96 * Xonar Essence ST (Deluxe)/STX
97 * -----------------------------
98 *
99 * CMI8788:
100 *
101 * I²C <-> PCM1792A
102 * <-> CS2000 (ST only)
103 *
104 * ADC1 MCLK -> REF_CLK of CS2000 (ST only)
105 *
106 * GPI 0 <- external power present (STX only)
107 *
108 * GPIO 0 -> enable output to speakers
109 * GPIO 1 -> route HP to front panel (0) or rear jack (1)
110 * GPIO 2 -> M0 of CS5381
111 * GPIO 3 -> M1 of CS5381
112 * GPIO 7 -> route output to speaker jacks (0) or HP (1)
113 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
114 *
115 * PCM1792A:
116 *
117 * AD1,0 <- 0,0
118 * SCK <- CLK_OUT of CS2000 (ST only)
119 *
120 * CS2000:
121 *
122 * AD0 <- 0
123 *
124 * CM9780:
125 *
126 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
127 *
128 * H6 daughterboard
129 * ----------------
130 *
131 * GPIO 4 <- 0
132 * GPIO 5 <- 0
133 */
134
135 /*
136 * Xonar HDAV1.3 Slim
137 * ------------------
138 *
139 * CMI8788:
140 *
141 * GPIO 1 -> enable output
142 *
143 * TXD -> HDMI controller
144 * RXD <- HDMI controller
145 */
146
147 #include <linux/pci.h>
148 #include <linux/delay.h>
149 #include <linux/mutex.h>
150 #include <sound/ac97_codec.h>
151 #include <sound/control.h>
152 #include <sound/core.h>
153 #include <sound/pcm.h>
154 #include <sound/pcm_params.h>
155 #include <sound/tlv.h>
156 #include "xonar.h"
157 #include "cm9780.h"
158 #include "pcm1796.h"
159 #include "cs2000.h"
160
161
162 #define GPIO_D2X_EXT_POWER 0x0020
163 #define GPIO_D2_ALT 0x0080
164 #define GPIO_D2_OUTPUT_ENABLE 0x0100
165
166 #define GPI_EXT_POWER 0x01
167 #define GPIO_INPUT_ROUTE 0x0100
168
169 #define GPIO_HDAV_OUTPUT_ENABLE 0x0001
170
171 #define GPIO_DB_MASK 0x0030
172 #define GPIO_DB_H6 0x0000
173
174 #define GPIO_ST_OUTPUT_ENABLE 0x0001
175 #define GPIO_ST_HP_REAR 0x0002
176 #define GPIO_ST_HP 0x0080
177
178 #define I2C_DEVICE_PCM1796(i) (0x98 + ((i) << 1)) /* 10011, ii, /W=0 */
179 #define I2C_DEVICE_CS2000 0x9c /* 100111, 0, /W=0 */
180
181 #define PCM1796_REG_BASE 16
182
183
184 struct xonar_pcm179x {
185 struct xonar_generic generic;
186 unsigned int dacs;
187 u8 pcm1796_regs[4][5];
188 unsigned int current_rate;
189 bool os_128;
190 bool hp_active;
191 s8 hp_gain_offset;
192 bool has_cs2000;
193 u8 cs2000_fun_cfg_1;
194 };
195
196 struct xonar_hdav {
197 struct xonar_pcm179x pcm179x;
198 struct xonar_hdmi hdmi;
199 };
200
201
202 static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
203 u8 reg, u8 value)
204 {
205 /* maps ALSA channel pair number to SPI output */
206 static const u8 codec_map[4] = {
207 0, 1, 2, 4
208 };
209 oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |
210 OXYGEN_SPI_DATA_LENGTH_2 |
211 OXYGEN_SPI_CLOCK_160 |
212 (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
213 OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
214 (reg << 8) | value);
215 }
216
217 static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec,
218 u8 reg, u8 value)
219 {
220 oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value);
221 }
222
223 static void pcm1796_write(struct oxygen *chip, unsigned int codec,
224 u8 reg, u8 value)
225 {
226 struct xonar_pcm179x *data = chip->model_data;
227
228 if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) ==
229 OXYGEN_FUNCTION_SPI)
230 pcm1796_write_spi(chip, codec, reg, value);
231 else
232 pcm1796_write_i2c(chip, codec, reg, value);
233 if ((unsigned int)(reg - PCM1796_REG_BASE)
234 < ARRAY_SIZE(data->pcm1796_regs[codec]))
235 data->pcm1796_regs[codec][reg - PCM1796_REG_BASE] = value;
236 }
237
238 static void pcm1796_write_cached(struct oxygen *chip, unsigned int codec,
239 u8 reg, u8 value)
240 {
241 struct xonar_pcm179x *data = chip->model_data;
242
243 if (value != data->pcm1796_regs[codec][reg - PCM1796_REG_BASE])
244 pcm1796_write(chip, codec, reg, value);
245 }
246
247 static void cs2000_write(struct oxygen *chip, u8 reg, u8 value)
248 {
249 struct xonar_pcm179x *data = chip->model_data;
250
251 oxygen_write_i2c(chip, I2C_DEVICE_CS2000, reg, value);
252 if (reg == CS2000_FUN_CFG_1)
253 data->cs2000_fun_cfg_1 = value;
254 }
255
256 static void cs2000_write_cached(struct oxygen *chip, u8 reg, u8 value)
257 {
258 struct xonar_pcm179x *data = chip->model_data;
259
260 if (reg != CS2000_FUN_CFG_1 ||
261 value != data->cs2000_fun_cfg_1)
262 cs2000_write(chip, reg, value);
263 }
264
265 static void pcm1796_registers_init(struct oxygen *chip)
266 {
267 struct xonar_pcm179x *data = chip->model_data;
268 unsigned int i;
269 s8 gain_offset;
270
271 gain_offset = data->hp_active ? data->hp_gain_offset : 0;
272 for (i = 0; i < data->dacs; ++i) {
273 /* set ATLD before ATL/ATR */
274 pcm1796_write(chip, i, 18,
275 data->pcm1796_regs[0][18 - PCM1796_REG_BASE]);
276 pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]
277 + gain_offset);
278 pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]
279 + gain_offset);
280 pcm1796_write(chip, i, 19,
281 data->pcm1796_regs[0][19 - PCM1796_REG_BASE]);
282 pcm1796_write(chip, i, 20,
283 data->pcm1796_regs[0][20 - PCM1796_REG_BASE]);
284 pcm1796_write(chip, i, 21, 0);
285 }
286 }
287
288 static void pcm1796_init(struct oxygen *chip)
289 {
290 struct xonar_pcm179x *data = chip->model_data;
291
292 data->pcm1796_regs[0][18 - PCM1796_REG_BASE] = PCM1796_MUTE |
293 PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
294 data->pcm1796_regs[0][19 - PCM1796_REG_BASE] =
295 PCM1796_FLT_SHARP | PCM1796_ATS_1;
296 data->pcm1796_regs[0][20 - PCM1796_REG_BASE] = PCM1796_OS_64;
297 pcm1796_registers_init(chip);
298 data->current_rate = 48000;
299 }
300
301 static void xonar_d2_init(struct oxygen *chip)
302 {
303 struct xonar_pcm179x *data = chip->model_data;
304
305 data->generic.anti_pop_delay = 300;
306 data->generic.output_enable_bit = GPIO_D2_OUTPUT_ENABLE;
307 data->dacs = 4;
308
309 pcm1796_init(chip);
310
311 oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT);
312 oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT);
313
314 oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC);
315
316 xonar_init_cs53x1(chip);
317 xonar_enable_output(chip);
318
319 snd_component_add(chip->card, "PCM1796");
320 snd_component_add(chip->card, "CS5381");
321 }
322
323 static void xonar_d2x_init(struct oxygen *chip)
324 {
325 struct xonar_pcm179x *data = chip->model_data;
326
327 data->generic.ext_power_reg = OXYGEN_GPIO_DATA;
328 data->generic.ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
329 data->generic.ext_power_bit = GPIO_D2X_EXT_POWER;
330 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER);
331 xonar_init_ext_power(chip);
332 xonar_d2_init(chip);
333 }
334
335 static void xonar_hdav_init(struct oxygen *chip)
336 {
337 struct xonar_hdav *data = chip->model_data;
338
339 oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
340 OXYGEN_2WIRE_LENGTH_8 |
341 OXYGEN_2WIRE_INTERRUPT_MASK |
342 OXYGEN_2WIRE_SPEED_FAST);
343
344 data->pcm179x.generic.anti_pop_delay = 100;
345 data->pcm179x.generic.output_enable_bit = GPIO_HDAV_OUTPUT_ENABLE;
346 data->pcm179x.generic.ext_power_reg = OXYGEN_GPI_DATA;
347 data->pcm179x.generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
348 data->pcm179x.generic.ext_power_bit = GPI_EXT_POWER;
349 data->pcm179x.dacs = chip->model.private_data ? 4 : 1;
350
351 pcm1796_init(chip);
352
353 oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_INPUT_ROUTE);
354 oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_INPUT_ROUTE);
355
356 xonar_init_cs53x1(chip);
357 xonar_init_ext_power(chip);
358 xonar_hdmi_init(chip, &data->hdmi);
359 xonar_enable_output(chip);
360
361 snd_component_add(chip->card, "PCM1796");
362 snd_component_add(chip->card, "CS5381");
363 }
364
365 static void xonar_st_init_i2c(struct oxygen *chip)
366 {
367 oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
368 OXYGEN_2WIRE_LENGTH_8 |
369 OXYGEN_2WIRE_INTERRUPT_MASK |
370 OXYGEN_2WIRE_SPEED_FAST);
371 }
372
373 static void xonar_st_init_common(struct oxygen *chip)
374 {
375 struct xonar_pcm179x *data = chip->model_data;
376
377 data->generic.anti_pop_delay = 100;
378 data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE;
379 data->dacs = chip->model.private_data ? 4 : 1;
380 data->hp_gain_offset = 2*-18;
381
382 pcm1796_init(chip);
383
384 oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
385 GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
386 oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
387 GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
388
389 xonar_init_cs53x1(chip);
390 xonar_enable_output(chip);
391
392 snd_component_add(chip->card, "PCM1792A");
393 snd_component_add(chip->card, "CS5381");
394 }
395
396 static void cs2000_registers_init(struct oxygen *chip)
397 {
398 struct xonar_pcm179x *data = chip->model_data;
399
400 cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_FREEZE);
401 cs2000_write(chip, CS2000_DEV_CTRL, 0);
402 cs2000_write(chip, CS2000_DEV_CFG_1,
403 CS2000_R_MOD_SEL_1 |
404 (0 << CS2000_R_SEL_SHIFT) |
405 CS2000_AUX_OUT_SRC_REF_CLK |
406 CS2000_EN_DEV_CFG_1);
407 cs2000_write(chip, CS2000_DEV_CFG_2,
408 (0 << CS2000_LOCK_CLK_SHIFT) |
409 CS2000_FRAC_N_SRC_STATIC);
410 cs2000_write(chip, CS2000_RATIO_0 + 0, 0x00); /* 1.0 */
411 cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10);
412 cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00);
413 cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00);
414 cs2000_write(chip, CS2000_FUN_CFG_1, data->cs2000_fun_cfg_1);
415 cs2000_write(chip, CS2000_FUN_CFG_2, 0);
416 cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2);
417 }
418
419 static void xonar_st_init(struct oxygen *chip)
420 {
421 struct xonar_pcm179x *data = chip->model_data;
422
423 data->has_cs2000 = 1;
424 data->cs2000_fun_cfg_1 = CS2000_REF_CLK_DIV_1;
425
426 oxygen_write16(chip, OXYGEN_I2S_A_FORMAT,
427 OXYGEN_RATE_48000 | OXYGEN_I2S_FORMAT_I2S |
428 OXYGEN_I2S_MCLK_128 | OXYGEN_I2S_BITS_16 |
429 OXYGEN_I2S_MASTER | OXYGEN_I2S_BCLK_64);
430
431 xonar_st_init_i2c(chip);
432 cs2000_registers_init(chip);
433 xonar_st_init_common(chip);
434
435 snd_component_add(chip->card, "CS2000");
436 }
437
438 static void xonar_stx_init(struct oxygen *chip)
439 {
440 struct xonar_pcm179x *data = chip->model_data;
441
442 xonar_st_init_i2c(chip);
443 data->generic.ext_power_reg = OXYGEN_GPI_DATA;
444 data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
445 data->generic.ext_power_bit = GPI_EXT_POWER;
446 xonar_init_ext_power(chip);
447 xonar_st_init_common(chip);
448 }
449
450 static void xonar_d2_cleanup(struct oxygen *chip)
451 {
452 xonar_disable_output(chip);
453 }
454
455 static void xonar_hdav_cleanup(struct oxygen *chip)
456 {
457 xonar_hdmi_cleanup(chip);
458 xonar_disable_output(chip);
459 msleep(2);
460 }
461
462 static void xonar_st_cleanup(struct oxygen *chip)
463 {
464 xonar_disable_output(chip);
465 }
466
467 static void xonar_d2_suspend(struct oxygen *chip)
468 {
469 xonar_d2_cleanup(chip);
470 }
471
472 static void xonar_hdav_suspend(struct oxygen *chip)
473 {
474 xonar_hdav_cleanup(chip);
475 }
476
477 static void xonar_st_suspend(struct oxygen *chip)
478 {
479 xonar_st_cleanup(chip);
480 }
481
482 static void xonar_d2_resume(struct oxygen *chip)
483 {
484 pcm1796_registers_init(chip);
485 xonar_enable_output(chip);
486 }
487
488 static void xonar_hdav_resume(struct oxygen *chip)
489 {
490 struct xonar_hdav *data = chip->model_data;
491
492 pcm1796_registers_init(chip);
493 xonar_hdmi_resume(chip, &data->hdmi);
494 xonar_enable_output(chip);
495 }
496
497 static void xonar_stx_resume(struct oxygen *chip)
498 {
499 pcm1796_registers_init(chip);
500 xonar_enable_output(chip);
501 }
502
503 static void xonar_st_resume(struct oxygen *chip)
504 {
505 cs2000_registers_init(chip);
506 xonar_stx_resume(chip);
507 }
508
509 static unsigned int mclk_from_rate(struct oxygen *chip, unsigned int rate)
510 {
511 struct xonar_pcm179x *data = chip->model_data;
512
513 if (rate <= 32000)
514 return OXYGEN_I2S_MCLK_512;
515 else if (rate <= 48000 && data->os_128)
516 return OXYGEN_I2S_MCLK_512;
517 else if (rate <= 96000)
518 return OXYGEN_I2S_MCLK_256;
519 else
520 return OXYGEN_I2S_MCLK_128;
521 }
522
523 static unsigned int get_pcm1796_i2s_mclk(struct oxygen *chip,
524 unsigned int channel,
525 struct snd_pcm_hw_params *params)
526 {
527 if (channel == PCM_MULTICH)
528 return mclk_from_rate(chip, params_rate(params));
529 else
530 return oxygen_default_i2s_mclk(chip, channel, params);
531 }
532
533 static void update_pcm1796_oversampling(struct oxygen *chip)
534 {
535 struct xonar_pcm179x *data = chip->model_data;
536 unsigned int i;
537 u8 reg;
538
539 if (data->current_rate <= 32000)
540 reg = PCM1796_OS_128;
541 else if (data->current_rate <= 48000 && data->os_128)
542 reg = PCM1796_OS_128;
543 else if (data->current_rate <= 96000 || data->os_128)
544 reg = PCM1796_OS_64;
545 else
546 reg = PCM1796_OS_32;
547 for (i = 0; i < data->dacs; ++i)
548 pcm1796_write_cached(chip, i, 20, reg);
549 }
550
551 static void set_pcm1796_params(struct oxygen *chip,
552 struct snd_pcm_hw_params *params)
553 {
554 struct xonar_pcm179x *data = chip->model_data;
555
556 data->current_rate = params_rate(params);
557 update_pcm1796_oversampling(chip);
558 }
559
560 static void update_pcm1796_volume(struct oxygen *chip)
561 {
562 struct xonar_pcm179x *data = chip->model_data;
563 unsigned int i;
564 s8 gain_offset;
565
566 gain_offset = data->hp_active ? data->hp_gain_offset : 0;
567 for (i = 0; i < data->dacs; ++i) {
568 pcm1796_write_cached(chip, i, 16, chip->dac_volume[i * 2]
569 + gain_offset);
570 pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1]
571 + gain_offset);
572 }
573 }
574
575 static void update_pcm1796_mute(struct oxygen *chip)
576 {
577 struct xonar_pcm179x *data = chip->model_data;
578 unsigned int i;
579 u8 value;
580
581 value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
582 if (chip->dac_mute)
583 value |= PCM1796_MUTE;
584 for (i = 0; i < data->dacs; ++i)
585 pcm1796_write_cached(chip, i, 18, value);
586 }
587
588 static void update_cs2000_rate(struct oxygen *chip, unsigned int rate)
589 {
590 struct xonar_pcm179x *data = chip->model_data;
591 u8 rate_mclk, reg;
592
593 switch (rate) {
594 /* XXX Why is the I2S A MCLK half the actual I2S MCLK? */
595 case 32000:
596 rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
597 break;
598 case 44100:
599 if (data->os_128)
600 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
601 else
602 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_128;
603 break;
604 default: /* 48000 */
605 if (data->os_128)
606 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
607 else
608 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_128;
609 break;
610 case 64000:
611 rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
612 break;
613 case 88200:
614 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
615 break;
616 case 96000:
617 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
618 break;
619 case 176400:
620 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
621 break;
622 case 192000:
623 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
624 break;
625 }
626 oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk,
627 OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK);
628 if ((rate_mclk & OXYGEN_I2S_MCLK_MASK) <= OXYGEN_I2S_MCLK_128)
629 reg = CS2000_REF_CLK_DIV_1;
630 else
631 reg = CS2000_REF_CLK_DIV_2;
632 cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg);
633 }
634
635 static void set_st_params(struct oxygen *chip,
636 struct snd_pcm_hw_params *params)
637 {
638 update_cs2000_rate(chip, params_rate(params));
639 set_pcm1796_params(chip, params);
640 }
641
642 static void set_hdav_params(struct oxygen *chip,
643 struct snd_pcm_hw_params *params)
644 {
645 struct xonar_hdav *data = chip->model_data;
646
647 set_pcm1796_params(chip, params);
648 xonar_set_hdmi_params(chip, &data->hdmi, params);
649 }
650
651 static const struct snd_kcontrol_new alt_switch = {
652 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
653 .name = "Analog Loopback Switch",
654 .info = snd_ctl_boolean_mono_info,
655 .get = xonar_gpio_bit_switch_get,
656 .put = xonar_gpio_bit_switch_put,
657 .private_value = GPIO_D2_ALT,
658 };
659
660 static int rolloff_info(struct snd_kcontrol *ctl,
661 struct snd_ctl_elem_info *info)
662 {
663 static const char *const names[2] = {
664 "Sharp Roll-off", "Slow Roll-off"
665 };
666
667 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
668 info->count = 1;
669 info->value.enumerated.items = 2;
670 if (info->value.enumerated.item >= 2)
671 info->value.enumerated.item = 1;
672 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
673 return 0;
674 }
675
676 static int rolloff_get(struct snd_kcontrol *ctl,
677 struct snd_ctl_elem_value *value)
678 {
679 struct oxygen *chip = ctl->private_data;
680 struct xonar_pcm179x *data = chip->model_data;
681
682 value->value.enumerated.item[0] =
683 (data->pcm1796_regs[0][19 - PCM1796_REG_BASE] &
684 PCM1796_FLT_MASK) != PCM1796_FLT_SHARP;
685 return 0;
686 }
687
688 static int rolloff_put(struct snd_kcontrol *ctl,
689 struct snd_ctl_elem_value *value)
690 {
691 struct oxygen *chip = ctl->private_data;
692 struct xonar_pcm179x *data = chip->model_data;
693 unsigned int i;
694 int changed;
695 u8 reg;
696
697 mutex_lock(&chip->mutex);
698 reg = data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
699 reg &= ~PCM1796_FLT_MASK;
700 if (!value->value.enumerated.item[0])
701 reg |= PCM1796_FLT_SHARP;
702 else
703 reg |= PCM1796_FLT_SLOW;
704 changed = reg != data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
705 if (changed) {
706 for (i = 0; i < data->dacs; ++i)
707 pcm1796_write(chip, i, 19, reg);
708 }
709 mutex_unlock(&chip->mutex);
710 return changed;
711 }
712
713 static const struct snd_kcontrol_new rolloff_control = {
714 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
715 .name = "DAC Filter Playback Enum",
716 .info = rolloff_info,
717 .get = rolloff_get,
718 .put = rolloff_put,
719 };
720
721 static int os_128_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
722 {
723 static const char *const names[2] = { "64x", "128x" };
724
725 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
726 info->count = 1;
727 info->value.enumerated.items = 2;
728 if (info->value.enumerated.item >= 2)
729 info->value.enumerated.item = 1;
730 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
731 return 0;
732 }
733
734 static int os_128_get(struct snd_kcontrol *ctl,
735 struct snd_ctl_elem_value *value)
736 {
737 struct oxygen *chip = ctl->private_data;
738 struct xonar_pcm179x *data = chip->model_data;
739
740 value->value.enumerated.item[0] = data->os_128;
741 return 0;
742 }
743
744 static int os_128_put(struct snd_kcontrol *ctl,
745 struct snd_ctl_elem_value *value)
746 {
747 struct oxygen *chip = ctl->private_data;
748 struct xonar_pcm179x *data = chip->model_data;
749 int changed;
750
751 mutex_lock(&chip->mutex);
752 changed = value->value.enumerated.item[0] != data->os_128;
753 if (changed) {
754 data->os_128 = value->value.enumerated.item[0];
755 if (data->has_cs2000)
756 update_cs2000_rate(chip, data->current_rate);
757 oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT,
758 mclk_from_rate(chip, data->current_rate),
759 OXYGEN_I2S_MCLK_MASK);
760 update_pcm1796_oversampling(chip);
761 }
762 mutex_unlock(&chip->mutex);
763 return changed;
764 }
765
766 static const struct snd_kcontrol_new os_128_control = {
767 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
768 .name = "DAC Oversampling Playback Enum",
769 .info = os_128_info,
770 .get = os_128_get,
771 .put = os_128_put,
772 };
773
774 static int st_output_switch_info(struct snd_kcontrol *ctl,
775 struct snd_ctl_elem_info *info)
776 {
777 static const char *const names[3] = {
778 "Speakers", "Headphones", "FP Headphones"
779 };
780
781 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
782 info->count = 1;
783 info->value.enumerated.items = 3;
784 if (info->value.enumerated.item >= 3)
785 info->value.enumerated.item = 2;
786 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
787 return 0;
788 }
789
790 static int st_output_switch_get(struct snd_kcontrol *ctl,
791 struct snd_ctl_elem_value *value)
792 {
793 struct oxygen *chip = ctl->private_data;
794 u16 gpio;
795
796 gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
797 if (!(gpio & GPIO_ST_HP))
798 value->value.enumerated.item[0] = 0;
799 else if (gpio & GPIO_ST_HP_REAR)
800 value->value.enumerated.item[0] = 1;
801 else
802 value->value.enumerated.item[0] = 2;
803 return 0;
804 }
805
806
807 static int st_output_switch_put(struct snd_kcontrol *ctl,
808 struct snd_ctl_elem_value *value)
809 {
810 struct oxygen *chip = ctl->private_data;
811 struct xonar_pcm179x *data = chip->model_data;
812 u16 gpio_old, gpio;
813
814 mutex_lock(&chip->mutex);
815 gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
816 gpio = gpio_old;
817 switch (value->value.enumerated.item[0]) {
818 case 0:
819 gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
820 break;
821 case 1:
822 gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
823 break;
824 case 2:
825 gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
826 break;
827 }
828 oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
829 data->hp_active = gpio & GPIO_ST_HP;
830 update_pcm1796_volume(chip);
831 mutex_unlock(&chip->mutex);
832 return gpio != gpio_old;
833 }
834
835 static int st_hp_volume_offset_info(struct snd_kcontrol *ctl,
836 struct snd_ctl_elem_info *info)
837 {
838 static const char *const names[3] = {
839 "< 64 ohms", "64-300 ohms", "300-600 ohms"
840 };
841
842 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
843 info->count = 1;
844 info->value.enumerated.items = 3;
845 if (info->value.enumerated.item > 2)
846 info->value.enumerated.item = 2;
847 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
848 return 0;
849 }
850
851 static int st_hp_volume_offset_get(struct snd_kcontrol *ctl,
852 struct snd_ctl_elem_value *value)
853 {
854 struct oxygen *chip = ctl->private_data;
855 struct xonar_pcm179x *data = chip->model_data;
856
857 mutex_lock(&chip->mutex);
858 if (data->hp_gain_offset < 2*-6)
859 value->value.enumerated.item[0] = 0;
860 else if (data->hp_gain_offset < 0)
861 value->value.enumerated.item[0] = 1;
862 else
863 value->value.enumerated.item[0] = 2;
864 mutex_unlock(&chip->mutex);
865 return 0;
866 }
867
868
869 static int st_hp_volume_offset_put(struct snd_kcontrol *ctl,
870 struct snd_ctl_elem_value *value)
871 {
872 static const s8 offsets[] = { 2*-18, 2*-6, 0 };
873 struct oxygen *chip = ctl->private_data;
874 struct xonar_pcm179x *data = chip->model_data;
875 s8 offset;
876 int changed;
877
878 if (value->value.enumerated.item[0] > 2)
879 return -EINVAL;
880 offset = offsets[value->value.enumerated.item[0]];
881 mutex_lock(&chip->mutex);
882 changed = offset != data->hp_gain_offset;
883 if (changed) {
884 data->hp_gain_offset = offset;
885 update_pcm1796_volume(chip);
886 }
887 mutex_unlock(&chip->mutex);
888 return changed;
889 }
890
891 static const struct snd_kcontrol_new st_controls[] = {
892 {
893 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
894 .name = "Analog Output",
895 .info = st_output_switch_info,
896 .get = st_output_switch_get,
897 .put = st_output_switch_put,
898 },
899 {
900 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
901 .name = "Headphones Impedance Playback Enum",
902 .info = st_hp_volume_offset_info,
903 .get = st_hp_volume_offset_get,
904 .put = st_hp_volume_offset_put,
905 },
906 };
907
908 static void xonar_line_mic_ac97_switch(struct oxygen *chip,
909 unsigned int reg, unsigned int mute)
910 {
911 if (reg == AC97_LINE) {
912 spin_lock_irq(&chip->reg_lock);
913 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
914 mute ? GPIO_INPUT_ROUTE : 0,
915 GPIO_INPUT_ROUTE);
916 spin_unlock_irq(&chip->reg_lock);
917 }
918 }
919
920 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
921
922 static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
923 {
924 if (!strncmp(template->name, "CD Capture ", 11))
925 /* CD in is actually connected to the video in pin */
926 template->private_value ^= AC97_CD ^ AC97_VIDEO;
927 return 0;
928 }
929
930 static int add_pcm1796_controls(struct oxygen *chip)
931 {
932 int err;
933
934 err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
935 if (err < 0)
936 return err;
937 err = snd_ctl_add(chip->card, snd_ctl_new1(&os_128_control, chip));
938 if (err < 0)
939 return err;
940 return 0;
941 }
942
943 static int xonar_d2_mixer_init(struct oxygen *chip)
944 {
945 int err;
946
947 err = snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
948 if (err < 0)
949 return err;
950 err = add_pcm1796_controls(chip);
951 if (err < 0)
952 return err;
953 return 0;
954 }
955
956 static int xonar_hdav_mixer_init(struct oxygen *chip)
957 {
958 return add_pcm1796_controls(chip);
959 }
960
961 static int xonar_st_mixer_init(struct oxygen *chip)
962 {
963 unsigned int i;
964 int err;
965
966 for (i = 0; i < ARRAY_SIZE(st_controls); ++i) {
967 err = snd_ctl_add(chip->card,
968 snd_ctl_new1(&st_controls[i], chip));
969 if (err < 0)
970 return err;
971 }
972 err = add_pcm1796_controls(chip);
973 if (err < 0)
974 return err;
975 return 0;
976 }
977
978 static const struct oxygen_model model_xonar_d2 = {
979 .longname = "Asus Virtuoso 200",
980 .chip = "AV200",
981 .init = xonar_d2_init,
982 .control_filter = xonar_d2_control_filter,
983 .mixer_init = xonar_d2_mixer_init,
984 .cleanup = xonar_d2_cleanup,
985 .suspend = xonar_d2_suspend,
986 .resume = xonar_d2_resume,
987 .get_i2s_mclk = get_pcm1796_i2s_mclk,
988 .set_dac_params = set_pcm1796_params,
989 .set_adc_params = xonar_set_cs53x1_params,
990 .update_dac_volume = update_pcm1796_volume,
991 .update_dac_mute = update_pcm1796_mute,
992 .dac_tlv = pcm1796_db_scale,
993 .model_data_size = sizeof(struct xonar_pcm179x),
994 .device_config = PLAYBACK_0_TO_I2S |
995 PLAYBACK_1_TO_SPDIF |
996 CAPTURE_0_FROM_I2S_2 |
997 CAPTURE_1_FROM_SPDIF |
998 MIDI_OUTPUT |
999 MIDI_INPUT |
1000 AC97_CD_INPUT,
1001 .dac_channels = 8,
1002 .dac_volume_min = 255 - 2*60,
1003 .dac_volume_max = 255,
1004 .misc_flags = OXYGEN_MISC_MIDI,
1005 .function_flags = OXYGEN_FUNCTION_SPI |
1006 OXYGEN_FUNCTION_ENABLE_SPI_4_5,
1007 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1008 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1009 };
1010
1011 static const struct oxygen_model model_xonar_hdav = {
1012 .longname = "Asus Virtuoso 200",
1013 .chip = "AV200",
1014 .init = xonar_hdav_init,
1015 .mixer_init = xonar_hdav_mixer_init,
1016 .cleanup = xonar_hdav_cleanup,
1017 .suspend = xonar_hdav_suspend,
1018 .resume = xonar_hdav_resume,
1019 .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter,
1020 .get_i2s_mclk = get_pcm1796_i2s_mclk,
1021 .set_dac_params = set_hdav_params,
1022 .set_adc_params = xonar_set_cs53x1_params,
1023 .update_dac_volume = update_pcm1796_volume,
1024 .update_dac_mute = update_pcm1796_mute,
1025 .uart_input = xonar_hdmi_uart_input,
1026 .ac97_switch = xonar_line_mic_ac97_switch,
1027 .dac_tlv = pcm1796_db_scale,
1028 .model_data_size = sizeof(struct xonar_hdav),
1029 .device_config = PLAYBACK_0_TO_I2S |
1030 PLAYBACK_1_TO_SPDIF |
1031 CAPTURE_0_FROM_I2S_2 |
1032 CAPTURE_1_FROM_SPDIF,
1033 .dac_channels = 8,
1034 .dac_volume_min = 255 - 2*60,
1035 .dac_volume_max = 255,
1036 .misc_flags = OXYGEN_MISC_MIDI,
1037 .function_flags = OXYGEN_FUNCTION_2WIRE,
1038 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1039 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1040 };
1041
1042 static const struct oxygen_model model_xonar_st = {
1043 .longname = "Asus Virtuoso 100",
1044 .chip = "AV200",
1045 .init = xonar_st_init,
1046 .mixer_init = xonar_st_mixer_init,
1047 .cleanup = xonar_st_cleanup,
1048 .suspend = xonar_st_suspend,
1049 .resume = xonar_st_resume,
1050 .get_i2s_mclk = get_pcm1796_i2s_mclk,
1051 .set_dac_params = set_st_params,
1052 .set_adc_params = xonar_set_cs53x1_params,
1053 .update_dac_volume = update_pcm1796_volume,
1054 .update_dac_mute = update_pcm1796_mute,
1055 .ac97_switch = xonar_line_mic_ac97_switch,
1056 .dac_tlv = pcm1796_db_scale,
1057 .model_data_size = sizeof(struct xonar_pcm179x),
1058 .device_config = PLAYBACK_0_TO_I2S |
1059 PLAYBACK_1_TO_SPDIF |
1060 CAPTURE_0_FROM_I2S_2,
1061 .dac_channels = 2,
1062 .dac_volume_min = 255 - 2*60,
1063 .dac_volume_max = 255,
1064 .function_flags = OXYGEN_FUNCTION_2WIRE,
1065 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1066 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1067 };
1068
1069 int __devinit get_xonar_pcm179x_model(struct oxygen *chip,
1070 const struct pci_device_id *id)
1071 {
1072 switch (id->subdevice) {
1073 case 0x8269:
1074 chip->model = model_xonar_d2;
1075 chip->model.shortname = "Xonar D2";
1076 break;
1077 case 0x82b7:
1078 chip->model = model_xonar_d2;
1079 chip->model.shortname = "Xonar D2X";
1080 chip->model.init = xonar_d2x_init;
1081 break;
1082 case 0x8314:
1083 chip->model = model_xonar_hdav;
1084 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1085 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1086 default:
1087 chip->model.shortname = "Xonar HDAV1.3";
1088 break;
1089 case GPIO_DB_H6:
1090 chip->model.shortname = "Xonar HDAV1.3+H6";
1091 chip->model.private_data = 1;
1092 break;
1093 }
1094 break;
1095 case 0x835d:
1096 chip->model = model_xonar_st;
1097 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1098 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1099 default:
1100 chip->model.shortname = "Xonar ST";
1101 break;
1102 case GPIO_DB_H6:
1103 chip->model.shortname = "Xonar ST+H6";
1104 chip->model.dac_channels = 8;
1105 chip->model.private_data = 1;
1106 break;
1107 }
1108 break;
1109 case 0x835c:
1110 chip->model = model_xonar_st;
1111 chip->model.shortname = "Xonar STX";
1112 chip->model.init = xonar_stx_init;
1113 chip->model.resume = xonar_stx_resume;
1114 chip->model.set_dac_params = set_pcm1796_params;
1115 break;
1116 case 0x835e:
1117 snd_printk(KERN_ERR "the HDAV1.3 Slim is not supported\n");
1118 return -ENODEV;
1119 default:
1120 return -EINVAL;
1121 }
1122 return 0;
1123 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree