2 * card driver for models with PCM1796 DACs (Xonar D2/D2X/HDAV1.3/ST/STX)
4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
7 * This driver is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License, version 2.
10 * This driver is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this driver; if not, see <http://www.gnu.org/licenses/>.
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)
30 * GPIO 2 -> M0 of CS5381
31 * GPIO 3 -> M1 of CS5381
32 * GPIO 5 <- external power present (D2X only)
34 * GPIO 8 -> enable output to speakers
38 * LINE_OUT -> input of ADC
44 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
48 * Xonar HDAV1.3 (Deluxe)
49 * ----------------------
53 * I²C <-> PCM1796 (addr 1001100) (front)
55 * GPI 0 <- external power present
57 * GPIO 0 -> enable HDMI (0) or speaker (1) output
58 * GPIO 2 -> M0 of CS5381
59 * GPIO 3 -> M1 of CS5381
60 * GPIO 4 <- daughterboard detection
61 * GPIO 5 <- daughterboard detection
64 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
66 * UART <-> HDMI controller
70 * LINE_OUT -> input of ADC
76 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
89 * I²C <-> PCM1796 (addr 1001101) (surround)
90 * <-> PCM1796 (addr 1001110) (center/LFE)
91 * <-> PCM1796 (addr 1001111) (back)
93 * unknown daughterboard
94 * ---------------------
99 * I²C <-> CS4362A (addr 0011000) (surround, center/LFE, back)
103 * Xonar Essence ST (Deluxe)/STX
104 * -----------------------------
108 * I²C <-> PCM1792A (addr 1001100)
109 * <-> CS2000 (addr 1001110) (ST only)
111 * ADC1 MCLK -> REF_CLK of CS2000 (ST only)
113 * GPI 0 <- external power present (STX only)
115 * GPIO 0 -> enable output to speakers
116 * GPIO 1 -> route HP to front panel (0) or rear jack (1)
117 * GPIO 2 -> M0 of CS5381
118 * GPIO 3 -> M1 of CS5381
119 * GPIO 4 <- daughterboard detection
120 * GPIO 5 <- daughterboard detection
122 * GPIO 7 -> route output to speaker jacks (0) or HP (1)
123 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
127 * SCK <- CLK_OUT of CS2000 (ST only)
131 * LINE_OUT -> input of ADC
136 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
151 * I²C <-> PCM1796 (addr 1001100) (front)
152 * <-> CS4362A (addr 0011000) (surround, center/LFE, back)
153 * <-> CS2000 (addr 1001110)
155 * ADC1 MCLK -> REF_CLK of CS2000
157 * GPI 0 <- external power present
159 * GPIO 0 -> enable output
160 * GPIO 1 -> route HP to front panel (0) or rear jack (1)
161 * GPIO 2 -> M0 of CS5381
162 * GPIO 3 -> M1 of CS5381
163 * GPIO 4 -> enable output
164 * GPIO 5 -> enable output
166 * GPIO 7 -> route output to HP (0) or speaker (1)
167 * GPIO 8 -> route input jack to mic-in (0) or line-in (1)
171 * LINE_OUT -> input of ADC
177 * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
178 * GPO 1 -> route mic-in from input jack (0) or front panel header (1)
181 #include <linux/pci.h>
182 #include <linux/delay.h>
183 #include <linux/mutex.h>
184 #include <sound/ac97_codec.h>
185 #include <sound/control.h>
186 #include <sound/core.h>
187 #include <sound/info.h>
188 #include <sound/pcm.h>
189 #include <sound/pcm_params.h>
190 #include <sound/tlv.h>
197 #define GPIO_D2X_EXT_POWER 0x0020
198 #define GPIO_D2_ALT 0x0080
199 #define GPIO_D2_OUTPUT_ENABLE 0x0100
201 #define GPI_EXT_POWER 0x01
202 #define GPIO_INPUT_ROUTE 0x0100
204 #define GPIO_HDAV_OUTPUT_ENABLE 0x0001
205 #define GPIO_HDAV_MAGIC 0x00c0
207 #define GPIO_DB_MASK 0x0030
208 #define GPIO_DB_H6 0x0000
210 #define GPIO_ST_OUTPUT_ENABLE 0x0001
211 #define GPIO_ST_HP_REAR 0x0002
212 #define GPIO_ST_MAGIC 0x0040
213 #define GPIO_ST_HP 0x0080
215 #define I2C_DEVICE_PCM1796(i) (0x98 + ((i) << 1)) /* 10011, ii, /W=0 */
216 #define I2C_DEVICE_CS2000 0x9c /* 100111, 0, /W=0 */
218 #define PCM1796_REG_BASE 16
221 struct xonar_pcm179x
{
222 struct xonar_generic generic
;
224 u8 pcm1796_regs
[4][5];
225 unsigned int current_rate
;
230 u8 cs2000_regs
[0x1f];
234 struct xonar_pcm179x pcm179x
;
235 struct xonar_hdmi hdmi
;
239 static inline void pcm1796_write_spi(struct oxygen
*chip
, unsigned int codec
,
242 /* maps ALSA channel pair number to SPI output */
243 static const u8 codec_map
[4] = {
246 oxygen_write_spi(chip
, OXYGEN_SPI_TRIGGER
|
247 OXYGEN_SPI_DATA_LENGTH_2
|
248 OXYGEN_SPI_CLOCK_160
|
249 (codec_map
[codec
] << OXYGEN_SPI_CODEC_SHIFT
) |
250 OXYGEN_SPI_CEN_LATCH_CLOCK_HI
,
254 static inline void pcm1796_write_i2c(struct oxygen
*chip
, unsigned int codec
,
257 oxygen_write_i2c(chip
, I2C_DEVICE_PCM1796(codec
), reg
, value
);
260 static void pcm1796_write(struct oxygen
*chip
, unsigned int codec
,
263 struct xonar_pcm179x
*data
= chip
->model_data
;
265 if ((chip
->model
.function_flags
& OXYGEN_FUNCTION_2WIRE_SPI_MASK
) ==
267 pcm1796_write_spi(chip
, codec
, reg
, value
);
269 pcm1796_write_i2c(chip
, codec
, reg
, value
);
270 if ((unsigned int)(reg
- PCM1796_REG_BASE
)
271 < ARRAY_SIZE(data
->pcm1796_regs
[codec
]))
272 data
->pcm1796_regs
[codec
][reg
- PCM1796_REG_BASE
] = value
;
275 static void pcm1796_write_cached(struct oxygen
*chip
, unsigned int codec
,
278 struct xonar_pcm179x
*data
= chip
->model_data
;
280 if (value
!= data
->pcm1796_regs
[codec
][reg
- PCM1796_REG_BASE
])
281 pcm1796_write(chip
, codec
, reg
, value
);
284 static void cs2000_write(struct oxygen
*chip
, u8 reg
, u8 value
)
286 struct xonar_pcm179x
*data
= chip
->model_data
;
288 oxygen_write_i2c(chip
, I2C_DEVICE_CS2000
, reg
, value
);
289 data
->cs2000_regs
[reg
] = value
;
292 static void cs2000_write_cached(struct oxygen
*chip
, u8 reg
, u8 value
)
294 struct xonar_pcm179x
*data
= chip
->model_data
;
296 if (value
!= data
->cs2000_regs
[reg
])
297 cs2000_write(chip
, reg
, value
);
300 static void pcm1796_registers_init(struct oxygen
*chip
)
302 struct xonar_pcm179x
*data
= chip
->model_data
;
306 gain_offset
= data
->hp_active
? data
->hp_gain_offset
: 0;
307 for (i
= 0; i
< data
->dacs
; ++i
) {
308 /* set ATLD before ATL/ATR */
309 pcm1796_write(chip
, i
, 18,
310 data
->pcm1796_regs
[0][18 - PCM1796_REG_BASE
]);
311 pcm1796_write(chip
, i
, 16, chip
->dac_volume
[i
* 2]
313 pcm1796_write(chip
, i
, 17, chip
->dac_volume
[i
* 2 + 1]
315 pcm1796_write(chip
, i
, 19,
316 data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
]);
317 pcm1796_write(chip
, i
, 20,
318 data
->pcm1796_regs
[0][20 - PCM1796_REG_BASE
]);
319 pcm1796_write(chip
, i
, 21, 0);
323 static void pcm1796_init(struct oxygen
*chip
)
325 struct xonar_pcm179x
*data
= chip
->model_data
;
327 data
->pcm1796_regs
[0][18 - PCM1796_REG_BASE
] = PCM1796_MUTE
|
328 PCM1796_DMF_DISABLED
| PCM1796_FMT_24_LJUST
| PCM1796_ATLD
;
329 data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
] =
330 PCM1796_FLT_SHARP
| PCM1796_ATS_1
;
331 data
->pcm1796_regs
[0][20 - PCM1796_REG_BASE
] = PCM1796_OS_64
;
332 pcm1796_registers_init(chip
);
333 data
->current_rate
= 48000;
336 static void xonar_d2_init(struct oxygen
*chip
)
338 struct xonar_pcm179x
*data
= chip
->model_data
;
340 data
->generic
.anti_pop_delay
= 300;
341 data
->generic
.output_enable_bit
= GPIO_D2_OUTPUT_ENABLE
;
346 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2_ALT
);
347 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_D2_ALT
);
349 oxygen_ac97_set_bits(chip
, 0, CM9780_JACK
, CM9780_FMIC2MIC
);
351 xonar_init_cs53x1(chip
);
352 xonar_enable_output(chip
);
354 snd_component_add(chip
->card
, "PCM1796");
355 snd_component_add(chip
->card
, "CS5381");
358 static void xonar_d2x_init(struct oxygen
*chip
)
360 struct xonar_pcm179x
*data
= chip
->model_data
;
362 data
->generic
.ext_power_reg
= OXYGEN_GPIO_DATA
;
363 data
->generic
.ext_power_int_reg
= OXYGEN_GPIO_INTERRUPT_MASK
;
364 data
->generic
.ext_power_bit
= GPIO_D2X_EXT_POWER
;
365 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2X_EXT_POWER
);
366 xonar_init_ext_power(chip
);
370 static void xonar_hdav_init(struct oxygen
*chip
)
372 struct xonar_hdav
*data
= chip
->model_data
;
374 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
375 OXYGEN_2WIRE_LENGTH_8
|
376 OXYGEN_2WIRE_INTERRUPT_MASK
|
377 OXYGEN_2WIRE_SPEED_FAST
);
379 data
->pcm179x
.generic
.anti_pop_delay
= 100;
380 data
->pcm179x
.generic
.output_enable_bit
= GPIO_HDAV_OUTPUT_ENABLE
;
381 data
->pcm179x
.generic
.ext_power_reg
= OXYGEN_GPI_DATA
;
382 data
->pcm179x
.generic
.ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
383 data
->pcm179x
.generic
.ext_power_bit
= GPI_EXT_POWER
;
384 data
->pcm179x
.dacs
= chip
->model
.private_data
? 4 : 1;
388 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
389 GPIO_HDAV_MAGIC
| GPIO_INPUT_ROUTE
);
390 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_INPUT_ROUTE
);
392 xonar_init_cs53x1(chip
);
393 xonar_init_ext_power(chip
);
394 xonar_hdmi_init(chip
, &data
->hdmi
);
395 xonar_enable_output(chip
);
397 snd_component_add(chip
->card
, "PCM1796");
398 snd_component_add(chip
->card
, "CS5381");
401 static void xonar_st_init_i2c(struct oxygen
*chip
)
403 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
404 OXYGEN_2WIRE_LENGTH_8
|
405 OXYGEN_2WIRE_INTERRUPT_MASK
|
406 OXYGEN_2WIRE_SPEED_FAST
);
409 static void xonar_st_init_common(struct oxygen
*chip
)
411 struct xonar_pcm179x
*data
= chip
->model_data
;
413 data
->generic
.output_enable_bit
= GPIO_ST_OUTPUT_ENABLE
;
414 data
->dacs
= chip
->model
.private_data
? 4 : 1;
415 data
->hp_gain_offset
= 2*-18;
419 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
420 GPIO_INPUT_ROUTE
| GPIO_ST_HP_REAR
|
421 GPIO_ST_MAGIC
| GPIO_ST_HP
);
422 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
,
423 GPIO_INPUT_ROUTE
| GPIO_ST_HP_REAR
| GPIO_ST_HP
);
425 xonar_init_cs53x1(chip
);
426 xonar_enable_output(chip
);
428 snd_component_add(chip
->card
, "PCM1792A");
429 snd_component_add(chip
->card
, "CS5381");
432 static void cs2000_registers_init(struct oxygen
*chip
)
434 struct xonar_pcm179x
*data
= chip
->model_data
;
436 cs2000_write(chip
, CS2000_GLOBAL_CFG
, CS2000_FREEZE
);
437 cs2000_write(chip
, CS2000_DEV_CTRL
, 0);
438 cs2000_write(chip
, CS2000_DEV_CFG_1
,
440 (0 << CS2000_R_SEL_SHIFT
) |
441 CS2000_AUX_OUT_SRC_REF_CLK
|
442 CS2000_EN_DEV_CFG_1
);
443 cs2000_write(chip
, CS2000_DEV_CFG_2
,
444 (0 << CS2000_LOCK_CLK_SHIFT
) |
445 CS2000_FRAC_N_SRC_STATIC
);
446 cs2000_write(chip
, CS2000_RATIO_0
+ 0, 0x00); /* 1.0 */
447 cs2000_write(chip
, CS2000_RATIO_0
+ 1, 0x10);
448 cs2000_write(chip
, CS2000_RATIO_0
+ 2, 0x00);
449 cs2000_write(chip
, CS2000_RATIO_0
+ 3, 0x00);
450 cs2000_write(chip
, CS2000_FUN_CFG_1
,
451 data
->cs2000_regs
[CS2000_FUN_CFG_1
]);
452 cs2000_write(chip
, CS2000_FUN_CFG_2
, 0);
453 cs2000_write(chip
, CS2000_GLOBAL_CFG
, CS2000_EN_DEV_CFG_2
);
456 static void xonar_st_init(struct oxygen
*chip
)
458 struct xonar_pcm179x
*data
= chip
->model_data
;
460 data
->generic
.anti_pop_delay
= 100;
461 data
->has_cs2000
= 1;
462 data
->cs2000_regs
[CS2000_FUN_CFG_1
] = CS2000_REF_CLK_DIV_1
;
464 oxygen_write16(chip
, OXYGEN_I2S_A_FORMAT
,
465 OXYGEN_RATE_48000
| OXYGEN_I2S_FORMAT_I2S
|
466 OXYGEN_I2S_MCLK_128
| OXYGEN_I2S_BITS_16
|
467 OXYGEN_I2S_MASTER
| OXYGEN_I2S_BCLK_64
);
469 xonar_st_init_i2c(chip
);
470 cs2000_registers_init(chip
);
471 xonar_st_init_common(chip
);
473 snd_component_add(chip
->card
, "CS2000");
476 static void xonar_stx_init(struct oxygen
*chip
)
478 struct xonar_pcm179x
*data
= chip
->model_data
;
480 xonar_st_init_i2c(chip
);
481 data
->generic
.anti_pop_delay
= 800;
482 data
->generic
.ext_power_reg
= OXYGEN_GPI_DATA
;
483 data
->generic
.ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
484 data
->generic
.ext_power_bit
= GPI_EXT_POWER
;
485 xonar_init_ext_power(chip
);
486 xonar_st_init_common(chip
);
489 static void xonar_d2_cleanup(struct oxygen
*chip
)
491 xonar_disable_output(chip
);
494 static void xonar_hdav_cleanup(struct oxygen
*chip
)
496 xonar_hdmi_cleanup(chip
);
497 xonar_disable_output(chip
);
501 static void xonar_st_cleanup(struct oxygen
*chip
)
503 xonar_disable_output(chip
);
506 static void xonar_d2_suspend(struct oxygen
*chip
)
508 xonar_d2_cleanup(chip
);
511 static void xonar_hdav_suspend(struct oxygen
*chip
)
513 xonar_hdav_cleanup(chip
);
516 static void xonar_st_suspend(struct oxygen
*chip
)
518 xonar_st_cleanup(chip
);
521 static void xonar_d2_resume(struct oxygen
*chip
)
523 pcm1796_registers_init(chip
);
524 xonar_enable_output(chip
);
527 static void xonar_hdav_resume(struct oxygen
*chip
)
529 struct xonar_hdav
*data
= chip
->model_data
;
531 pcm1796_registers_init(chip
);
532 xonar_hdmi_resume(chip
, &data
->hdmi
);
533 xonar_enable_output(chip
);
536 static void xonar_stx_resume(struct oxygen
*chip
)
538 pcm1796_registers_init(chip
);
539 xonar_enable_output(chip
);
542 static void xonar_st_resume(struct oxygen
*chip
)
544 cs2000_registers_init(chip
);
545 xonar_stx_resume(chip
);
548 static unsigned int mclk_from_rate(struct oxygen
*chip
, unsigned int rate
)
550 struct xonar_pcm179x
*data
= chip
->model_data
;
553 return OXYGEN_I2S_MCLK_512
;
554 else if (rate
<= 48000 && data
->os_128
)
555 return OXYGEN_I2S_MCLK_512
;
556 else if (rate
<= 96000)
557 return OXYGEN_I2S_MCLK_256
;
559 return OXYGEN_I2S_MCLK_128
;
562 static unsigned int get_pcm1796_i2s_mclk(struct oxygen
*chip
,
563 unsigned int channel
,
564 struct snd_pcm_hw_params
*params
)
566 if (channel
== PCM_MULTICH
)
567 return mclk_from_rate(chip
, params_rate(params
));
569 return oxygen_default_i2s_mclk(chip
, channel
, params
);
572 static void update_pcm1796_oversampling(struct oxygen
*chip
)
574 struct xonar_pcm179x
*data
= chip
->model_data
;
578 if (data
->current_rate
<= 32000)
579 reg
= PCM1796_OS_128
;
580 else if (data
->current_rate
<= 48000 && data
->os_128
)
581 reg
= PCM1796_OS_128
;
582 else if (data
->current_rate
<= 96000 || data
->os_128
)
586 for (i
= 0; i
< data
->dacs
; ++i
)
587 pcm1796_write_cached(chip
, i
, 20, reg
);
590 static void set_pcm1796_params(struct oxygen
*chip
,
591 struct snd_pcm_hw_params
*params
)
593 struct xonar_pcm179x
*data
= chip
->model_data
;
595 data
->current_rate
= params_rate(params
);
596 update_pcm1796_oversampling(chip
);
599 static void update_pcm1796_volume(struct oxygen
*chip
)
601 struct xonar_pcm179x
*data
= chip
->model_data
;
605 gain_offset
= data
->hp_active
? data
->hp_gain_offset
: 0;
606 for (i
= 0; i
< data
->dacs
; ++i
) {
607 pcm1796_write_cached(chip
, i
, 16, chip
->dac_volume
[i
* 2]
609 pcm1796_write_cached(chip
, i
, 17, chip
->dac_volume
[i
* 2 + 1]
614 static void update_pcm1796_mute(struct oxygen
*chip
)
616 struct xonar_pcm179x
*data
= chip
->model_data
;
620 value
= PCM1796_DMF_DISABLED
| PCM1796_FMT_24_LJUST
| PCM1796_ATLD
;
622 value
|= PCM1796_MUTE
;
623 for (i
= 0; i
< data
->dacs
; ++i
)
624 pcm1796_write_cached(chip
, i
, 18, value
);
627 static void update_cs2000_rate(struct oxygen
*chip
, unsigned int rate
)
629 struct xonar_pcm179x
*data
= chip
->model_data
;
633 /* XXX Why is the I2S A MCLK half the actual I2S MCLK? */
635 rate_mclk
= OXYGEN_RATE_32000
| OXYGEN_I2S_MCLK_256
;
639 rate_mclk
= OXYGEN_RATE_44100
| OXYGEN_I2S_MCLK_256
;
641 rate_mclk
= OXYGEN_RATE_44100
| OXYGEN_I2S_MCLK_128
;
645 rate_mclk
= OXYGEN_RATE_48000
| OXYGEN_I2S_MCLK_256
;
647 rate_mclk
= OXYGEN_RATE_48000
| OXYGEN_I2S_MCLK_128
;
650 rate_mclk
= OXYGEN_RATE_32000
| OXYGEN_I2S_MCLK_256
;
653 rate_mclk
= OXYGEN_RATE_44100
| OXYGEN_I2S_MCLK_256
;
656 rate_mclk
= OXYGEN_RATE_48000
| OXYGEN_I2S_MCLK_256
;
659 rate_mclk
= OXYGEN_RATE_44100
| OXYGEN_I2S_MCLK_256
;
662 rate_mclk
= OXYGEN_RATE_48000
| OXYGEN_I2S_MCLK_256
;
665 oxygen_write16_masked(chip
, OXYGEN_I2S_A_FORMAT
, rate_mclk
,
666 OXYGEN_I2S_RATE_MASK
| OXYGEN_I2S_MCLK_MASK
);
667 if ((rate_mclk
& OXYGEN_I2S_MCLK_MASK
) <= OXYGEN_I2S_MCLK_128
)
668 reg
= CS2000_REF_CLK_DIV_1
;
670 reg
= CS2000_REF_CLK_DIV_2
;
671 cs2000_write_cached(chip
, CS2000_FUN_CFG_1
, reg
);
674 static void set_st_params(struct oxygen
*chip
,
675 struct snd_pcm_hw_params
*params
)
677 update_cs2000_rate(chip
, params_rate(params
));
678 set_pcm1796_params(chip
, params
);
681 static void set_hdav_params(struct oxygen
*chip
,
682 struct snd_pcm_hw_params
*params
)
684 struct xonar_hdav
*data
= chip
->model_data
;
686 set_pcm1796_params(chip
, params
);
687 xonar_set_hdmi_params(chip
, &data
->hdmi
, params
);
690 static const struct snd_kcontrol_new alt_switch
= {
691 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
692 .name
= "Analog Loopback Switch",
693 .info
= snd_ctl_boolean_mono_info
,
694 .get
= xonar_gpio_bit_switch_get
,
695 .put
= xonar_gpio_bit_switch_put
,
696 .private_value
= GPIO_D2_ALT
,
699 static int rolloff_info(struct snd_kcontrol
*ctl
,
700 struct snd_ctl_elem_info
*info
)
702 static const char *const names
[2] = {
703 "Sharp Roll-off", "Slow Roll-off"
706 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
708 info
->value
.enumerated
.items
= 2;
709 if (info
->value
.enumerated
.item
>= 2)
710 info
->value
.enumerated
.item
= 1;
711 strcpy(info
->value
.enumerated
.name
, names
[info
->value
.enumerated
.item
]);
715 static int rolloff_get(struct snd_kcontrol
*ctl
,
716 struct snd_ctl_elem_value
*value
)
718 struct oxygen
*chip
= ctl
->private_data
;
719 struct xonar_pcm179x
*data
= chip
->model_data
;
721 value
->value
.enumerated
.item
[0] =
722 (data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
] &
723 PCM1796_FLT_MASK
) != PCM1796_FLT_SHARP
;
727 static int rolloff_put(struct snd_kcontrol
*ctl
,
728 struct snd_ctl_elem_value
*value
)
730 struct oxygen
*chip
= ctl
->private_data
;
731 struct xonar_pcm179x
*data
= chip
->model_data
;
736 mutex_lock(&chip
->mutex
);
737 reg
= data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
];
738 reg
&= ~PCM1796_FLT_MASK
;
739 if (!value
->value
.enumerated
.item
[0])
740 reg
|= PCM1796_FLT_SHARP
;
742 reg
|= PCM1796_FLT_SLOW
;
743 changed
= reg
!= data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
];
745 for (i
= 0; i
< data
->dacs
; ++i
)
746 pcm1796_write(chip
, i
, 19, reg
);
748 mutex_unlock(&chip
->mutex
);
752 static const struct snd_kcontrol_new rolloff_control
= {
753 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
754 .name
= "DAC Filter Playback Enum",
755 .info
= rolloff_info
,
760 static int os_128_info(struct snd_kcontrol
*ctl
, struct snd_ctl_elem_info
*info
)
762 static const char *const names
[2] = { "64x", "128x" };
764 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
766 info
->value
.enumerated
.items
= 2;
767 if (info
->value
.enumerated
.item
>= 2)
768 info
->value
.enumerated
.item
= 1;
769 strcpy(info
->value
.enumerated
.name
, names
[info
->value
.enumerated
.item
]);
773 static int os_128_get(struct snd_kcontrol
*ctl
,
774 struct snd_ctl_elem_value
*value
)
776 struct oxygen
*chip
= ctl
->private_data
;
777 struct xonar_pcm179x
*data
= chip
->model_data
;
779 value
->value
.enumerated
.item
[0] = data
->os_128
;
783 static int os_128_put(struct snd_kcontrol
*ctl
,
784 struct snd_ctl_elem_value
*value
)
786 struct oxygen
*chip
= ctl
->private_data
;
787 struct xonar_pcm179x
*data
= chip
->model_data
;
790 mutex_lock(&chip
->mutex
);
791 changed
= value
->value
.enumerated
.item
[0] != data
->os_128
;
793 data
->os_128
= value
->value
.enumerated
.item
[0];
794 if (data
->has_cs2000
)
795 update_cs2000_rate(chip
, data
->current_rate
);
796 oxygen_write16_masked(chip
, OXYGEN_I2S_MULTICH_FORMAT
,
797 mclk_from_rate(chip
, data
->current_rate
),
798 OXYGEN_I2S_MCLK_MASK
);
799 update_pcm1796_oversampling(chip
);
801 mutex_unlock(&chip
->mutex
);
805 static const struct snd_kcontrol_new os_128_control
= {
806 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
807 .name
= "DAC Oversampling Playback Enum",
813 static const struct snd_kcontrol_new hdav_hdmi_control
= {
814 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
815 .name
= "HDMI Playback Switch",
816 .info
= snd_ctl_boolean_mono_info
,
817 .get
= xonar_gpio_bit_switch_get
,
818 .put
= xonar_gpio_bit_switch_put
,
819 .private_value
= GPIO_HDAV_OUTPUT_ENABLE
| XONAR_GPIO_BIT_INVERT
,
822 static int st_output_switch_info(struct snd_kcontrol
*ctl
,
823 struct snd_ctl_elem_info
*info
)
825 static const char *const names
[3] = {
826 "Speakers", "Headphones", "FP Headphones"
829 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
831 info
->value
.enumerated
.items
= 3;
832 if (info
->value
.enumerated
.item
>= 3)
833 info
->value
.enumerated
.item
= 2;
834 strcpy(info
->value
.enumerated
.name
, names
[info
->value
.enumerated
.item
]);
838 static int st_output_switch_get(struct snd_kcontrol
*ctl
,
839 struct snd_ctl_elem_value
*value
)
841 struct oxygen
*chip
= ctl
->private_data
;
844 gpio
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
845 if (!(gpio
& GPIO_ST_HP
))
846 value
->value
.enumerated
.item
[0] = 0;
847 else if (gpio
& GPIO_ST_HP_REAR
)
848 value
->value
.enumerated
.item
[0] = 1;
850 value
->value
.enumerated
.item
[0] = 2;
855 static int st_output_switch_put(struct snd_kcontrol
*ctl
,
856 struct snd_ctl_elem_value
*value
)
858 struct oxygen
*chip
= ctl
->private_data
;
859 struct xonar_pcm179x
*data
= chip
->model_data
;
862 mutex_lock(&chip
->mutex
);
863 gpio_old
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
865 switch (value
->value
.enumerated
.item
[0]) {
867 gpio
&= ~(GPIO_ST_HP
| GPIO_ST_HP_REAR
);
870 gpio
|= GPIO_ST_HP
| GPIO_ST_HP_REAR
;
873 gpio
= (gpio
| GPIO_ST_HP
) & ~GPIO_ST_HP_REAR
;
876 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, gpio
);
877 data
->hp_active
= gpio
& GPIO_ST_HP
;
878 update_pcm1796_volume(chip
);
879 mutex_unlock(&chip
->mutex
);
880 return gpio
!= gpio_old
;
883 static int st_hp_volume_offset_info(struct snd_kcontrol
*ctl
,
884 struct snd_ctl_elem_info
*info
)
886 static const char *const names
[3] = {
887 "< 64 ohms", "64-300 ohms", "300-600 ohms"
890 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
892 info
->value
.enumerated
.items
= 3;
893 if (info
->value
.enumerated
.item
> 2)
894 info
->value
.enumerated
.item
= 2;
895 strcpy(info
->value
.enumerated
.name
, names
[info
->value
.enumerated
.item
]);
899 static int st_hp_volume_offset_get(struct snd_kcontrol
*ctl
,
900 struct snd_ctl_elem_value
*value
)
902 struct oxygen
*chip
= ctl
->private_data
;
903 struct xonar_pcm179x
*data
= chip
->model_data
;
905 mutex_lock(&chip
->mutex
);
906 if (data
->hp_gain_offset
< 2*-6)
907 value
->value
.enumerated
.item
[0] = 0;
908 else if (data
->hp_gain_offset
< 0)
909 value
->value
.enumerated
.item
[0] = 1;
911 value
->value
.enumerated
.item
[0] = 2;
912 mutex_unlock(&chip
->mutex
);
917 static int st_hp_volume_offset_put(struct snd_kcontrol
*ctl
,
918 struct snd_ctl_elem_value
*value
)
920 static const s8 offsets
[] = { 2*-18, 2*-6, 0 };
921 struct oxygen
*chip
= ctl
->private_data
;
922 struct xonar_pcm179x
*data
= chip
->model_data
;
926 if (value
->value
.enumerated
.item
[0] > 2)
928 offset
= offsets
[value
->value
.enumerated
.item
[0]];
929 mutex_lock(&chip
->mutex
);
930 changed
= offset
!= data
->hp_gain_offset
;
932 data
->hp_gain_offset
= offset
;
933 update_pcm1796_volume(chip
);
935 mutex_unlock(&chip
->mutex
);
939 static const struct snd_kcontrol_new st_controls
[] = {
941 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
942 .name
= "Analog Output",
943 .info
= st_output_switch_info
,
944 .get
= st_output_switch_get
,
945 .put
= st_output_switch_put
,
948 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
949 .name
= "Headphones Impedance Playback Enum",
950 .info
= st_hp_volume_offset_info
,
951 .get
= st_hp_volume_offset_get
,
952 .put
= st_hp_volume_offset_put
,
956 static void xonar_line_mic_ac97_switch(struct oxygen
*chip
,
957 unsigned int reg
, unsigned int mute
)
959 if (reg
== AC97_LINE
) {
960 spin_lock_irq(&chip
->reg_lock
);
961 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
962 mute
? GPIO_INPUT_ROUTE
: 0,
964 spin_unlock_irq(&chip
->reg_lock
);
968 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale
, -6000, 50, 0);
970 static int xonar_d2_control_filter(struct snd_kcontrol_new
*template)
972 if (!strncmp(template->name
, "CD Capture ", 11))
973 /* CD in is actually connected to the video in pin */
974 template->private_value
^= AC97_CD
^ AC97_VIDEO
;
978 static int add_pcm1796_controls(struct oxygen
*chip
)
982 err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&rolloff_control
, chip
));
985 err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&os_128_control
, chip
));
991 static int xonar_d2_mixer_init(struct oxygen
*chip
)
995 err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&alt_switch
, chip
));
998 err
= add_pcm1796_controls(chip
);
1004 static int xonar_hdav_mixer_init(struct oxygen
*chip
)
1008 err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&hdav_hdmi_control
, chip
));
1011 err
= add_pcm1796_controls(chip
);
1017 static int xonar_st_mixer_init(struct oxygen
*chip
)
1022 for (i
= 0; i
< ARRAY_SIZE(st_controls
); ++i
) {
1023 err
= snd_ctl_add(chip
->card
,
1024 snd_ctl_new1(&st_controls
[i
], chip
));
1028 err
= add_pcm1796_controls(chip
);
1034 static void dump_pcm1796_registers(struct oxygen
*chip
,
1035 struct snd_info_buffer
*buffer
)
1037 struct xonar_pcm179x
*data
= chip
->model_data
;
1038 unsigned int dac
, i
;
1040 for (dac
= 0; dac
< data
->dacs
; ++dac
) {
1041 snd_iprintf(buffer
, "\nPCM1796 %u:", dac
+ 1);
1042 for (i
= 0; i
< 5; ++i
)
1043 snd_iprintf(buffer
, " %02x",
1044 data
->pcm1796_regs
[dac
][i
]);
1046 snd_iprintf(buffer
, "\n");
1049 static void dump_cs2000_registers(struct oxygen
*chip
,
1050 struct snd_info_buffer
*buffer
)
1052 struct xonar_pcm179x
*data
= chip
->model_data
;
1055 if (data
->has_cs2000
) {
1056 snd_iprintf(buffer
, "\nCS2000:\n00: ");
1057 for (i
= 1; i
< 0x10; ++i
)
1058 snd_iprintf(buffer
, " %02x", data
->cs2000_regs
[i
]);
1059 snd_iprintf(buffer
, "\n10:");
1060 for (i
= 0x10; i
< 0x1f; ++i
)
1061 snd_iprintf(buffer
, " %02x", data
->cs2000_regs
[i
]);
1062 snd_iprintf(buffer
, "\n");
1066 static void dump_st_registers(struct oxygen
*chip
,
1067 struct snd_info_buffer
*buffer
)
1069 dump_pcm1796_registers(chip
, buffer
);
1070 dump_cs2000_registers(chip
, buffer
);
1073 static const struct oxygen_model model_xonar_d2
= {
1074 .longname
= "Asus Virtuoso 200",
1076 .init
= xonar_d2_init
,
1077 .control_filter
= xonar_d2_control_filter
,
1078 .mixer_init
= xonar_d2_mixer_init
,
1079 .cleanup
= xonar_d2_cleanup
,
1080 .suspend
= xonar_d2_suspend
,
1081 .resume
= xonar_d2_resume
,
1082 .get_i2s_mclk
= get_pcm1796_i2s_mclk
,
1083 .set_dac_params
= set_pcm1796_params
,
1084 .set_adc_params
= xonar_set_cs53x1_params
,
1085 .update_dac_volume
= update_pcm1796_volume
,
1086 .update_dac_mute
= update_pcm1796_mute
,
1087 .dump_registers
= dump_pcm1796_registers
,
1088 .dac_tlv
= pcm1796_db_scale
,
1089 .model_data_size
= sizeof(struct xonar_pcm179x
),
1090 .device_config
= PLAYBACK_0_TO_I2S
|
1091 PLAYBACK_1_TO_SPDIF
|
1092 CAPTURE_0_FROM_I2S_2
|
1093 CAPTURE_1_FROM_SPDIF
|
1098 .dac_volume_min
= 255 - 2*60,
1099 .dac_volume_max
= 255,
1100 .misc_flags
= OXYGEN_MISC_MIDI
,
1101 .function_flags
= OXYGEN_FUNCTION_SPI
|
1102 OXYGEN_FUNCTION_ENABLE_SPI_4_5
,
1103 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1104 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1107 static const struct oxygen_model model_xonar_hdav
= {
1108 .longname
= "Asus Virtuoso 200",
1110 .init
= xonar_hdav_init
,
1111 .mixer_init
= xonar_hdav_mixer_init
,
1112 .cleanup
= xonar_hdav_cleanup
,
1113 .suspend
= xonar_hdav_suspend
,
1114 .resume
= xonar_hdav_resume
,
1115 .pcm_hardware_filter
= xonar_hdmi_pcm_hardware_filter
,
1116 .get_i2s_mclk
= get_pcm1796_i2s_mclk
,
1117 .set_dac_params
= set_hdav_params
,
1118 .set_adc_params
= xonar_set_cs53x1_params
,
1119 .update_dac_volume
= update_pcm1796_volume
,
1120 .update_dac_mute
= update_pcm1796_mute
,
1121 .uart_input
= xonar_hdmi_uart_input
,
1122 .ac97_switch
= xonar_line_mic_ac97_switch
,
1123 .dump_registers
= dump_pcm1796_registers
,
1124 .dac_tlv
= pcm1796_db_scale
,
1125 .model_data_size
= sizeof(struct xonar_hdav
),
1126 .device_config
= PLAYBACK_0_TO_I2S
|
1127 PLAYBACK_1_TO_SPDIF
|
1128 CAPTURE_0_FROM_I2S_2
|
1129 CAPTURE_1_FROM_SPDIF
,
1131 .dac_volume_min
= 255 - 2*60,
1132 .dac_volume_max
= 255,
1133 .misc_flags
= OXYGEN_MISC_MIDI
,
1134 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
1135 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1136 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1139 static const struct oxygen_model model_xonar_st
= {
1140 .longname
= "Asus Virtuoso 100",
1142 .init
= xonar_st_init
,
1143 .mixer_init
= xonar_st_mixer_init
,
1144 .cleanup
= xonar_st_cleanup
,
1145 .suspend
= xonar_st_suspend
,
1146 .resume
= xonar_st_resume
,
1147 .get_i2s_mclk
= get_pcm1796_i2s_mclk
,
1148 .set_dac_params
= set_st_params
,
1149 .set_adc_params
= xonar_set_cs53x1_params
,
1150 .update_dac_volume
= update_pcm1796_volume
,
1151 .update_dac_mute
= update_pcm1796_mute
,
1152 .ac97_switch
= xonar_line_mic_ac97_switch
,
1153 .dump_registers
= dump_st_registers
,
1154 .dac_tlv
= pcm1796_db_scale
,
1155 .model_data_size
= sizeof(struct xonar_pcm179x
),
1156 .device_config
= PLAYBACK_0_TO_I2S
|
1157 PLAYBACK_1_TO_SPDIF
|
1158 CAPTURE_0_FROM_I2S_2
|
1161 .dac_volume_min
= 255 - 2*60,
1162 .dac_volume_max
= 255,
1163 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
1164 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1165 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1168 int __devinit
get_xonar_pcm179x_model(struct oxygen
*chip
,
1169 const struct pci_device_id
*id
)
1171 switch (id
->subdevice
) {
1173 chip
->model
= model_xonar_d2
;
1174 chip
->model
.shortname
= "Xonar D2";
1177 chip
->model
= model_xonar_d2
;
1178 chip
->model
.shortname
= "Xonar D2X";
1179 chip
->model
.init
= xonar_d2x_init
;
1182 chip
->model
= model_xonar_hdav
;
1183 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_DB_MASK
);
1184 switch (oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & GPIO_DB_MASK
) {
1186 chip
->model
.shortname
= "Xonar HDAV1.3";
1189 chip
->model
.shortname
= "Xonar HDAV1.3+H6";
1190 chip
->model
.private_data
= 1;
1195 chip
->model
= model_xonar_st
;
1196 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_DB_MASK
);
1197 switch (oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & GPIO_DB_MASK
) {
1199 chip
->model
.shortname
= "Xonar ST";
1202 chip
->model
.shortname
= "Xonar ST+H6";
1203 chip
->model
.dac_channels
= 8;
1204 chip
->model
.private_data
= 1;
1209 chip
->model
= model_xonar_st
;
1210 chip
->model
.shortname
= "Xonar STX";
1211 chip
->model
.init
= xonar_stx_init
;
1212 chip
->model
.resume
= xonar_stx_resume
;
1213 chip
->model
.set_dac_params
= set_pcm1796_params
;
1216 snd_printk(KERN_ERR
"the HDAV1.3 Slim is not supported\n");