?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: virtuoso: fix Xonar STX anti-pop delay
[firewire-audio.git] / sound / pci / oxygen / xonar_pcm179x.c
blobd491fd6c0be239906380ae6af8864f1bfe0e4f6f
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.output_enable_bit = GPIO_ST_OUTPUT_ENABLE;
378 data->dacs = chip->model.private_data ? 4 : 1;
379 data->hp_gain_offset = 2*-18;
380
381 pcm1796_init(chip);
382
383 oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
384 GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
385 oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
386 GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
387
388 xonar_init_cs53x1(chip);
389 xonar_enable_output(chip);
390
391 snd_component_add(chip->card, "PCM1792A");
392 snd_component_add(chip->card, "CS5381");
393 }
394
395 static void cs2000_registers_init(struct oxygen *chip)
396 {
397 struct xonar_pcm179x *data = chip->model_data;
398
399 cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_FREEZE);
400 cs2000_write(chip, CS2000_DEV_CTRL, 0);
401 cs2000_write(chip, CS2000_DEV_CFG_1,
402 CS2000_R_MOD_SEL_1 |
403 (0 << CS2000_R_SEL_SHIFT) |
404 CS2000_AUX_OUT_SRC_REF_CLK |
405 CS2000_EN_DEV_CFG_1);
406 cs2000_write(chip, CS2000_DEV_CFG_2,
407 (0 << CS2000_LOCK_CLK_SHIFT) |
408 CS2000_FRAC_N_SRC_STATIC);
409 cs2000_write(chip, CS2000_RATIO_0 + 0, 0x00); /* 1.0 */
410 cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10);
411 cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00);
412 cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00);
413 cs2000_write(chip, CS2000_FUN_CFG_1, data->cs2000_fun_cfg_1);
414 cs2000_write(chip, CS2000_FUN_CFG_2, 0);
415 cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2);
416 }
417
418 static void xonar_st_init(struct oxygen *chip)
419 {
420 struct xonar_pcm179x *data = chip->model_data;
421
422 data->generic.anti_pop_delay = 100;
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.anti_pop_delay = 800;
444 data->generic.ext_power_reg = OXYGEN_GPI_DATA;
445 data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
446 data->generic.ext_power_bit = GPI_EXT_POWER;
447 xonar_init_ext_power(chip);
448 xonar_st_init_common(chip);
449 }
450
451 static void xonar_d2_cleanup(struct oxygen *chip)
452 {
453 xonar_disable_output(chip);
454 }
455
456 static void xonar_hdav_cleanup(struct oxygen *chip)
457 {
458 xonar_hdmi_cleanup(chip);
459 xonar_disable_output(chip);
460 msleep(2);
461 }
462
463 static void xonar_st_cleanup(struct oxygen *chip)
464 {
465 xonar_disable_output(chip);
466 }
467
468 static void xonar_d2_suspend(struct oxygen *chip)
469 {
470 xonar_d2_cleanup(chip);
471 }
472
473 static void xonar_hdav_suspend(struct oxygen *chip)
474 {
475 xonar_hdav_cleanup(chip);
476 }
477
478 static void xonar_st_suspend(struct oxygen *chip)
479 {
480 xonar_st_cleanup(chip);
481 }
482
483 static void xonar_d2_resume(struct oxygen *chip)
484 {
485 pcm1796_registers_init(chip);
486 xonar_enable_output(chip);
487 }
488
489 static void xonar_hdav_resume(struct oxygen *chip)
490 {
491 struct xonar_hdav *data = chip->model_data;
492
493 pcm1796_registers_init(chip);
494 xonar_hdmi_resume(chip, &data->hdmi);
495 xonar_enable_output(chip);
496 }
497
498 static void xonar_stx_resume(struct oxygen *chip)
499 {
500 pcm1796_registers_init(chip);
501 xonar_enable_output(chip);
502 }
503
504 static void xonar_st_resume(struct oxygen *chip)
505 {
506 cs2000_registers_init(chip);
507 xonar_stx_resume(chip);
508 }
509
510 static unsigned int mclk_from_rate(struct oxygen *chip, unsigned int rate)
511 {
512 struct xonar_pcm179x *data = chip->model_data;
513
514 if (rate <= 32000)
515 return OXYGEN_I2S_MCLK_512;
516 else if (rate <= 48000 && data->os_128)
517 return OXYGEN_I2S_MCLK_512;
518 else if (rate <= 96000)
519 return OXYGEN_I2S_MCLK_256;
520 else
521 return OXYGEN_I2S_MCLK_128;
522 }
523
524 static unsigned int get_pcm1796_i2s_mclk(struct oxygen *chip,
525 unsigned int channel,
526 struct snd_pcm_hw_params *params)
527 {
528 if (channel == PCM_MULTICH)
529 return mclk_from_rate(chip, params_rate(params));
530 else
531 return oxygen_default_i2s_mclk(chip, channel, params);
532 }
533
534 static void update_pcm1796_oversampling(struct oxygen *chip)
535 {
536 struct xonar_pcm179x *data = chip->model_data;
537 unsigned int i;
538 u8 reg;
539
540 if (data->current_rate <= 32000)
541 reg = PCM1796_OS_128;
542 else if (data->current_rate <= 48000 && data->os_128)
543 reg = PCM1796_OS_128;
544 else if (data->current_rate <= 96000 || data->os_128)
545 reg = PCM1796_OS_64;
546 else
547 reg = PCM1796_OS_32;
548 for (i = 0; i < data->dacs; ++i)
549 pcm1796_write_cached(chip, i, 20, reg);
550 }
551
552 static void set_pcm1796_params(struct oxygen *chip,
553 struct snd_pcm_hw_params *params)
554 {
555 struct xonar_pcm179x *data = chip->model_data;
556
557 data->current_rate = params_rate(params);
558 update_pcm1796_oversampling(chip);
559 }
560
561 static void update_pcm1796_volume(struct oxygen *chip)
562 {
563 struct xonar_pcm179x *data = chip->model_data;
564 unsigned int i;
565 s8 gain_offset;
566
567 gain_offset = data->hp_active ? data->hp_gain_offset : 0;
568 for (i = 0; i < data->dacs; ++i) {
569 pcm1796_write_cached(chip, i, 16, chip->dac_volume[i * 2]
570 + gain_offset);
571 pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1]
572 + gain_offset);
573 }
574 }
575
576 static void update_pcm1796_mute(struct oxygen *chip)
577 {
578 struct xonar_pcm179x *data = chip->model_data;
579 unsigned int i;
580 u8 value;
581
582 value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
583 if (chip->dac_mute)
584 value |= PCM1796_MUTE;
585 for (i = 0; i < data->dacs; ++i)
586 pcm1796_write_cached(chip, i, 18, value);
587 }
588
589 static void update_cs2000_rate(struct oxygen *chip, unsigned int rate)
590 {
591 struct xonar_pcm179x *data = chip->model_data;
592 u8 rate_mclk, reg;
593
594 switch (rate) {
595 /* XXX Why is the I2S A MCLK half the actual I2S MCLK? */
596 case 32000:
597 rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
598 break;
599 case 44100:
600 if (data->os_128)
601 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
602 else
603 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_128;
604 break;
605 default: /* 48000 */
606 if (data->os_128)
607 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
608 else
609 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_128;
610 break;
611 case 64000:
612 rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
613 break;
614 case 88200:
615 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
616 break;
617 case 96000:
618 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
619 break;
620 case 176400:
621 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
622 break;
623 case 192000:
624 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
625 break;
626 }
627 oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk,
628 OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK);
629 if ((rate_mclk & OXYGEN_I2S_MCLK_MASK) <= OXYGEN_I2S_MCLK_128)
630 reg = CS2000_REF_CLK_DIV_1;
631 else
632 reg = CS2000_REF_CLK_DIV_2;
633 cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg);
634 }
635
636 static void set_st_params(struct oxygen *chip,
637 struct snd_pcm_hw_params *params)
638 {
639 update_cs2000_rate(chip, params_rate(params));
640 set_pcm1796_params(chip, params);
641 }
642
643 static void set_hdav_params(struct oxygen *chip,
644 struct snd_pcm_hw_params *params)
645 {
646 struct xonar_hdav *data = chip->model_data;
647
648 set_pcm1796_params(chip, params);
649 xonar_set_hdmi_params(chip, &data->hdmi, params);
650 }
651
652 static const struct snd_kcontrol_new alt_switch = {
653 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
654 .name = "Analog Loopback Switch",
655 .info = snd_ctl_boolean_mono_info,
656 .get = xonar_gpio_bit_switch_get,
657 .put = xonar_gpio_bit_switch_put,
658 .private_value = GPIO_D2_ALT,
659 };
660
661 static int rolloff_info(struct snd_kcontrol *ctl,
662 struct snd_ctl_elem_info *info)
663 {
664 static const char *const names[2] = {
665 "Sharp Roll-off", "Slow Roll-off"
666 };
667
668 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
669 info->count = 1;
670 info->value.enumerated.items = 2;
671 if (info->value.enumerated.item >= 2)
672 info->value.enumerated.item = 1;
673 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
674 return 0;
675 }
676
677 static int rolloff_get(struct snd_kcontrol *ctl,
678 struct snd_ctl_elem_value *value)
679 {
680 struct oxygen *chip = ctl->private_data;
681 struct xonar_pcm179x *data = chip->model_data;
682
683 value->value.enumerated.item[0] =
684 (data->pcm1796_regs[0][19 - PCM1796_REG_BASE] &
685 PCM1796_FLT_MASK) != PCM1796_FLT_SHARP;
686 return 0;
687 }
688
689 static int rolloff_put(struct snd_kcontrol *ctl,
690 struct snd_ctl_elem_value *value)
691 {
692 struct oxygen *chip = ctl->private_data;
693 struct xonar_pcm179x *data = chip->model_data;
694 unsigned int i;
695 int changed;
696 u8 reg;
697
698 mutex_lock(&chip->mutex);
699 reg = data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
700 reg &= ~PCM1796_FLT_MASK;
701 if (!value->value.enumerated.item[0])
702 reg |= PCM1796_FLT_SHARP;
703 else
704 reg |= PCM1796_FLT_SLOW;
705 changed = reg != data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
706 if (changed) {
707 for (i = 0; i < data->dacs; ++i)
708 pcm1796_write(chip, i, 19, reg);
709 }
710 mutex_unlock(&chip->mutex);
711 return changed;
712 }
713
714 static const struct snd_kcontrol_new rolloff_control = {
715 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
716 .name = "DAC Filter Playback Enum",
717 .info = rolloff_info,
718 .get = rolloff_get,
719 .put = rolloff_put,
720 };
721
722 static int os_128_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
723 {
724 static const char *const names[2] = { "64x", "128x" };
725
726 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
727 info->count = 1;
728 info->value.enumerated.items = 2;
729 if (info->value.enumerated.item >= 2)
730 info->value.enumerated.item = 1;
731 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
732 return 0;
733 }
734
735 static int os_128_get(struct snd_kcontrol *ctl,
736 struct snd_ctl_elem_value *value)
737 {
738 struct oxygen *chip = ctl->private_data;
739 struct xonar_pcm179x *data = chip->model_data;
740
741 value->value.enumerated.item[0] = data->os_128;
742 return 0;
743 }
744
745 static int os_128_put(struct snd_kcontrol *ctl,
746 struct snd_ctl_elem_value *value)
747 {
748 struct oxygen *chip = ctl->private_data;
749 struct xonar_pcm179x *data = chip->model_data;
750 int changed;
751
752 mutex_lock(&chip->mutex);
753 changed = value->value.enumerated.item[0] != data->os_128;
754 if (changed) {
755 data->os_128 = value->value.enumerated.item[0];
756 if (data->has_cs2000)
757 update_cs2000_rate(chip, data->current_rate);
758 oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT,
759 mclk_from_rate(chip, data->current_rate),
760 OXYGEN_I2S_MCLK_MASK);
761 update_pcm1796_oversampling(chip);
762 }
763 mutex_unlock(&chip->mutex);
764 return changed;
765 }
766
767 static const struct snd_kcontrol_new os_128_control = {
768 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
769 .name = "DAC Oversampling Playback Enum",
770 .info = os_128_info,
771 .get = os_128_get,
772 .put = os_128_put,
773 };
774
775 static int st_output_switch_info(struct snd_kcontrol *ctl,
776 struct snd_ctl_elem_info *info)
777 {
778 static const char *const names[3] = {
779 "Speakers", "Headphones", "FP Headphones"
780 };
781
782 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
783 info->count = 1;
784 info->value.enumerated.items = 3;
785 if (info->value.enumerated.item >= 3)
786 info->value.enumerated.item = 2;
787 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
788 return 0;
789 }
790
791 static int st_output_switch_get(struct snd_kcontrol *ctl,
792 struct snd_ctl_elem_value *value)
793 {
794 struct oxygen *chip = ctl->private_data;
795 u16 gpio;
796
797 gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
798 if (!(gpio & GPIO_ST_HP))
799 value->value.enumerated.item[0] = 0;
800 else if (gpio & GPIO_ST_HP_REAR)
801 value->value.enumerated.item[0] = 1;
802 else
803 value->value.enumerated.item[0] = 2;
804 return 0;
805 }
806
807
808 static int st_output_switch_put(struct snd_kcontrol *ctl,
809 struct snd_ctl_elem_value *value)
810 {
811 struct oxygen *chip = ctl->private_data;
812 struct xonar_pcm179x *data = chip->model_data;
813 u16 gpio_old, gpio;
814
815 mutex_lock(&chip->mutex);
816 gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
817 gpio = gpio_old;
818 switch (value->value.enumerated.item[0]) {
819 case 0:
820 gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
821 break;
822 case 1:
823 gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
824 break;
825 case 2:
826 gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
827 break;
828 }
829 oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
830 data->hp_active = gpio & GPIO_ST_HP;
831 update_pcm1796_volume(chip);
832 mutex_unlock(&chip->mutex);
833 return gpio != gpio_old;
834 }
835
836 static int st_hp_volume_offset_info(struct snd_kcontrol *ctl,
837 struct snd_ctl_elem_info *info)
838 {
839 static const char *const names[3] = {
840 "< 64 ohms", "64-300 ohms", "300-600 ohms"
841 };
842
843 info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
844 info->count = 1;
845 info->value.enumerated.items = 3;
846 if (info->value.enumerated.item > 2)
847 info->value.enumerated.item = 2;
848 strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
849 return 0;
850 }
851
852 static int st_hp_volume_offset_get(struct snd_kcontrol *ctl,
853 struct snd_ctl_elem_value *value)
854 {
855 struct oxygen *chip = ctl->private_data;
856 struct xonar_pcm179x *data = chip->model_data;
857
858 mutex_lock(&chip->mutex);
859 if (data->hp_gain_offset < 2*-6)
860 value->value.enumerated.item[0] = 0;
861 else if (data->hp_gain_offset < 0)
862 value->value.enumerated.item[0] = 1;
863 else
864 value->value.enumerated.item[0] = 2;
865 mutex_unlock(&chip->mutex);
866 return 0;
867 }
868
869
870 static int st_hp_volume_offset_put(struct snd_kcontrol *ctl,
871 struct snd_ctl_elem_value *value)
872 {
873 static const s8 offsets[] = { 2*-18, 2*-6, 0 };
874 struct oxygen *chip = ctl->private_data;
875 struct xonar_pcm179x *data = chip->model_data;
876 s8 offset;
877 int changed;
878
879 if (value->value.enumerated.item[0] > 2)
880 return -EINVAL;
881 offset = offsets[value->value.enumerated.item[0]];
882 mutex_lock(&chip->mutex);
883 changed = offset != data->hp_gain_offset;
884 if (changed) {
885 data->hp_gain_offset = offset;
886 update_pcm1796_volume(chip);
887 }
888 mutex_unlock(&chip->mutex);
889 return changed;
890 }
891
892 static const struct snd_kcontrol_new st_controls[] = {
893 {
894 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
895 .name = "Analog Output",
896 .info = st_output_switch_info,
897 .get = st_output_switch_get,
898 .put = st_output_switch_put,
899 },
900 {
901 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
902 .name = "Headphones Impedance Playback Enum",
903 .info = st_hp_volume_offset_info,
904 .get = st_hp_volume_offset_get,
905 .put = st_hp_volume_offset_put,
906 },
907 };
908
909 static void xonar_line_mic_ac97_switch(struct oxygen *chip,
910 unsigned int reg, unsigned int mute)
911 {
912 if (reg == AC97_LINE) {
913 spin_lock_irq(&chip->reg_lock);
914 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
915 mute ? GPIO_INPUT_ROUTE : 0,
916 GPIO_INPUT_ROUTE);
917 spin_unlock_irq(&chip->reg_lock);
918 }
919 }
920
921 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
922
923 static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
924 {
925 if (!strncmp(template->name, "CD Capture ", 11))
926 /* CD in is actually connected to the video in pin */
927 template->private_value ^= AC97_CD ^ AC97_VIDEO;
928 return 0;
929 }
930
931 static int add_pcm1796_controls(struct oxygen *chip)
932 {
933 int err;
934
935 err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
936 if (err < 0)
937 return err;
938 err = snd_ctl_add(chip->card, snd_ctl_new1(&os_128_control, chip));
939 if (err < 0)
940 return err;
941 return 0;
942 }
943
944 static int xonar_d2_mixer_init(struct oxygen *chip)
945 {
946 int err;
947
948 err = snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
949 if (err < 0)
950 return err;
951 err = add_pcm1796_controls(chip);
952 if (err < 0)
953 return err;
954 return 0;
955 }
956
957 static int xonar_hdav_mixer_init(struct oxygen *chip)
958 {
959 return add_pcm1796_controls(chip);
960 }
961
962 static int xonar_st_mixer_init(struct oxygen *chip)
963 {
964 unsigned int i;
965 int err;
966
967 for (i = 0; i < ARRAY_SIZE(st_controls); ++i) {
968 err = snd_ctl_add(chip->card,
969 snd_ctl_new1(&st_controls[i], chip));
970 if (err < 0)
971 return err;
972 }
973 err = add_pcm1796_controls(chip);
974 if (err < 0)
975 return err;
976 return 0;
977 }
978
979 static const struct oxygen_model model_xonar_d2 = {
980 .longname = "Asus Virtuoso 200",
981 .chip = "AV200",
982 .init = xonar_d2_init,
983 .control_filter = xonar_d2_control_filter,
984 .mixer_init = xonar_d2_mixer_init,
985 .cleanup = xonar_d2_cleanup,
986 .suspend = xonar_d2_suspend,
987 .resume = xonar_d2_resume,
988 .get_i2s_mclk = get_pcm1796_i2s_mclk,
989 .set_dac_params = set_pcm1796_params,
990 .set_adc_params = xonar_set_cs53x1_params,
991 .update_dac_volume = update_pcm1796_volume,
992 .update_dac_mute = update_pcm1796_mute,
993 .dac_tlv = pcm1796_db_scale,
994 .model_data_size = sizeof(struct xonar_pcm179x),
995 .device_config = PLAYBACK_0_TO_I2S |
996 PLAYBACK_1_TO_SPDIF |
997 CAPTURE_0_FROM_I2S_2 |
998 CAPTURE_1_FROM_SPDIF |
999 MIDI_OUTPUT |
1000 MIDI_INPUT |
1001 AC97_CD_INPUT,
1002 .dac_channels = 8,
1003 .dac_volume_min = 255 - 2*60,
1004 .dac_volume_max = 255,
1005 .misc_flags = OXYGEN_MISC_MIDI,
1006 .function_flags = OXYGEN_FUNCTION_SPI |
1007 OXYGEN_FUNCTION_ENABLE_SPI_4_5,
1008 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1009 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1010 };
1011
1012 static const struct oxygen_model model_xonar_hdav = {
1013 .longname = "Asus Virtuoso 200",
1014 .chip = "AV200",
1015 .init = xonar_hdav_init,
1016 .mixer_init = xonar_hdav_mixer_init,
1017 .cleanup = xonar_hdav_cleanup,
1018 .suspend = xonar_hdav_suspend,
1019 .resume = xonar_hdav_resume,
1020 .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter,
1021 .get_i2s_mclk = get_pcm1796_i2s_mclk,
1022 .set_dac_params = set_hdav_params,
1023 .set_adc_params = xonar_set_cs53x1_params,
1024 .update_dac_volume = update_pcm1796_volume,
1025 .update_dac_mute = update_pcm1796_mute,
1026 .uart_input = xonar_hdmi_uart_input,
1027 .ac97_switch = xonar_line_mic_ac97_switch,
1028 .dac_tlv = pcm1796_db_scale,
1029 .model_data_size = sizeof(struct xonar_hdav),
1030 .device_config = PLAYBACK_0_TO_I2S |
1031 PLAYBACK_1_TO_SPDIF |
1032 CAPTURE_0_FROM_I2S_2 |
1033 CAPTURE_1_FROM_SPDIF,
1034 .dac_channels = 8,
1035 .dac_volume_min = 255 - 2*60,
1036 .dac_volume_max = 255,
1037 .misc_flags = OXYGEN_MISC_MIDI,
1038 .function_flags = OXYGEN_FUNCTION_2WIRE,
1039 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1040 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1041 };
1042
1043 static const struct oxygen_model model_xonar_st = {
1044 .longname = "Asus Virtuoso 100",
1045 .chip = "AV200",
1046 .init = xonar_st_init,
1047 .mixer_init = xonar_st_mixer_init,
1048 .cleanup = xonar_st_cleanup,
1049 .suspend = xonar_st_suspend,
1050 .resume = xonar_st_resume,
1051 .get_i2s_mclk = get_pcm1796_i2s_mclk,
1052 .set_dac_params = set_st_params,
1053 .set_adc_params = xonar_set_cs53x1_params,
1054 .update_dac_volume = update_pcm1796_volume,
1055 .update_dac_mute = update_pcm1796_mute,
1056 .ac97_switch = xonar_line_mic_ac97_switch,
1057 .dac_tlv = pcm1796_db_scale,
1058 .model_data_size = sizeof(struct xonar_pcm179x),
1059 .device_config = PLAYBACK_0_TO_I2S |
1060 PLAYBACK_1_TO_SPDIF |
1061 CAPTURE_0_FROM_I2S_2,
1062 .dac_channels = 2,
1063 .dac_volume_min = 255 - 2*60,
1064 .dac_volume_max = 255,
1065 .function_flags = OXYGEN_FUNCTION_2WIRE,
1066 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1067 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1068 };
1069
1070 int __devinit get_xonar_pcm179x_model(struct oxygen *chip,
1071 const struct pci_device_id *id)
1072 {
1073 switch (id->subdevice) {
1074 case 0x8269:
1075 chip->model = model_xonar_d2;
1076 chip->model.shortname = "Xonar D2";
1077 break;
1078 case 0x82b7:
1079 chip->model = model_xonar_d2;
1080 chip->model.shortname = "Xonar D2X";
1081 chip->model.init = xonar_d2x_init;
1082 break;
1083 case 0x8314:
1084 chip->model = model_xonar_hdav;
1085 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1086 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1087 default:
1088 chip->model.shortname = "Xonar HDAV1.3";
1089 break;
1090 case GPIO_DB_H6:
1091 chip->model.shortname = "Xonar HDAV1.3+H6";
1092 chip->model.private_data = 1;
1093 break;
1094 }
1095 break;
1096 case 0x835d:
1097 chip->model = model_xonar_st;
1098 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1099 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1100 default:
1101 chip->model.shortname = "Xonar ST";
1102 break;
1103 case GPIO_DB_H6:
1104 chip->model.shortname = "Xonar ST+H6";
1105 chip->model.dac_channels = 8;
1106 chip->model.private_data = 1;
1107 break;
1108 }
1109 break;
1110 case 0x835c:
1111 chip->model = model_xonar_st;
1112 chip->model.shortname = "Xonar STX";
1113 chip->model.init = xonar_stx_init;
1114 chip->model.resume = xonar_stx_resume;
1115 chip->model.set_dac_params = set_pcm1796_params;
1116 break;
1117 case 0x835e:
1118 snd_printk(KERN_ERR "the HDAV1.3 Slim is not supported\n");
1119 return -ENODEV;
1120 default:
1121 return -EINVAL;
1122 }
1123 return 0;
1124 }
AMDTP streaming driver for the Linux FireWire stack (Juju)