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];
235 struct xonar_pcm179x pcm179x
;
236 struct xonar_hdmi hdmi
;
240 static inline void pcm1796_write_spi(struct oxygen
*chip
, unsigned int codec
,
243 /* maps ALSA channel pair number to SPI output */
244 static const u8 codec_map
[4] = {
247 oxygen_write_spi(chip
, OXYGEN_SPI_TRIGGER
|
248 OXYGEN_SPI_DATA_LENGTH_2
|
249 OXYGEN_SPI_CLOCK_160
|
250 (codec_map
[codec
] << OXYGEN_SPI_CODEC_SHIFT
) |
251 OXYGEN_SPI_CEN_LATCH_CLOCK_HI
,
255 static inline void pcm1796_write_i2c(struct oxygen
*chip
, unsigned int codec
,
258 oxygen_write_i2c(chip
, I2C_DEVICE_PCM1796(codec
), reg
, value
);
261 static void pcm1796_write(struct oxygen
*chip
, unsigned int codec
,
264 struct xonar_pcm179x
*data
= chip
->model_data
;
266 if ((chip
->model
.function_flags
& OXYGEN_FUNCTION_2WIRE_SPI_MASK
) ==
268 pcm1796_write_spi(chip
, codec
, reg
, value
);
270 pcm1796_write_i2c(chip
, codec
, reg
, value
);
271 if ((unsigned int)(reg
- PCM1796_REG_BASE
)
272 < ARRAY_SIZE(data
->pcm1796_regs
[codec
]))
273 data
->pcm1796_regs
[codec
][reg
- PCM1796_REG_BASE
] = value
;
276 static void pcm1796_write_cached(struct oxygen
*chip
, unsigned int codec
,
279 struct xonar_pcm179x
*data
= chip
->model_data
;
281 if (value
!= data
->pcm1796_regs
[codec
][reg
- PCM1796_REG_BASE
])
282 pcm1796_write(chip
, codec
, reg
, value
);
285 static void cs2000_write(struct oxygen
*chip
, u8 reg
, u8 value
)
287 struct xonar_pcm179x
*data
= chip
->model_data
;
289 oxygen_write_i2c(chip
, I2C_DEVICE_CS2000
, reg
, value
);
290 data
->cs2000_regs
[reg
] = value
;
293 static void cs2000_write_cached(struct oxygen
*chip
, u8 reg
, u8 value
)
295 struct xonar_pcm179x
*data
= chip
->model_data
;
297 if (value
!= data
->cs2000_regs
[reg
])
298 cs2000_write(chip
, reg
, value
);
301 static void pcm1796_registers_init(struct oxygen
*chip
)
303 struct xonar_pcm179x
*data
= chip
->model_data
;
308 gain_offset
= data
->hp_active
? data
->hp_gain_offset
: 0;
309 for (i
= 0; i
< data
->dacs
; ++i
) {
310 /* set ATLD before ATL/ATR */
311 pcm1796_write(chip
, i
, 18,
312 data
->pcm1796_regs
[0][18 - PCM1796_REG_BASE
]);
313 pcm1796_write(chip
, i
, 16, chip
->dac_volume
[i
* 2]
315 pcm1796_write(chip
, i
, 17, chip
->dac_volume
[i
* 2 + 1]
317 pcm1796_write(chip
, i
, 19,
318 data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
]);
319 pcm1796_write(chip
, i
, 20,
320 data
->pcm1796_regs
[0][20 - PCM1796_REG_BASE
]);
321 pcm1796_write(chip
, i
, 21, 0);
326 static void pcm1796_init(struct oxygen
*chip
)
328 struct xonar_pcm179x
*data
= chip
->model_data
;
330 data
->pcm1796_regs
[0][18 - PCM1796_REG_BASE
] = PCM1796_MUTE
|
331 PCM1796_DMF_DISABLED
| PCM1796_FMT_24_I2S
| PCM1796_ATLD
;
332 data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
] =
333 PCM1796_FLT_SHARP
| PCM1796_ATS_1
;
334 data
->pcm1796_regs
[0][20 - PCM1796_REG_BASE
] =
335 data
->h6
? PCM1796_OS_64
: PCM1796_OS_128
;
336 pcm1796_registers_init(chip
);
337 data
->current_rate
= 48000;
340 static void xonar_d2_init(struct oxygen
*chip
)
342 struct xonar_pcm179x
*data
= chip
->model_data
;
344 data
->generic
.anti_pop_delay
= 300;
345 data
->generic
.output_enable_bit
= GPIO_D2_OUTPUT_ENABLE
;
350 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2_ALT
);
351 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_D2_ALT
);
353 oxygen_ac97_set_bits(chip
, 0, CM9780_JACK
, CM9780_FMIC2MIC
);
355 xonar_init_cs53x1(chip
);
356 xonar_enable_output(chip
);
358 snd_component_add(chip
->card
, "PCM1796");
359 snd_component_add(chip
->card
, "CS5381");
362 static void xonar_d2x_init(struct oxygen
*chip
)
364 struct xonar_pcm179x
*data
= chip
->model_data
;
366 data
->generic
.ext_power_reg
= OXYGEN_GPIO_DATA
;
367 data
->generic
.ext_power_int_reg
= OXYGEN_GPIO_INTERRUPT_MASK
;
368 data
->generic
.ext_power_bit
= GPIO_D2X_EXT_POWER
;
369 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2X_EXT_POWER
);
370 xonar_init_ext_power(chip
);
374 static void xonar_hdav_init(struct oxygen
*chip
)
376 struct xonar_hdav
*data
= chip
->model_data
;
378 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
379 OXYGEN_2WIRE_LENGTH_8
|
380 OXYGEN_2WIRE_INTERRUPT_MASK
|
381 OXYGEN_2WIRE_SPEED_STANDARD
);
383 data
->pcm179x
.generic
.anti_pop_delay
= 100;
384 data
->pcm179x
.generic
.output_enable_bit
= GPIO_HDAV_OUTPUT_ENABLE
;
385 data
->pcm179x
.generic
.ext_power_reg
= OXYGEN_GPI_DATA
;
386 data
->pcm179x
.generic
.ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
387 data
->pcm179x
.generic
.ext_power_bit
= GPI_EXT_POWER
;
388 data
->pcm179x
.dacs
= chip
->model
.dac_channels_mixer
/ 2;
389 data
->pcm179x
.h6
= chip
->model
.dac_channels_mixer
> 2;
393 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
394 GPIO_HDAV_MAGIC
| GPIO_INPUT_ROUTE
);
395 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_INPUT_ROUTE
);
397 xonar_init_cs53x1(chip
);
398 xonar_init_ext_power(chip
);
399 xonar_hdmi_init(chip
, &data
->hdmi
);
400 xonar_enable_output(chip
);
402 snd_component_add(chip
->card
, "PCM1796");
403 snd_component_add(chip
->card
, "CS5381");
406 static void xonar_st_init_i2c(struct oxygen
*chip
)
408 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
409 OXYGEN_2WIRE_LENGTH_8
|
410 OXYGEN_2WIRE_INTERRUPT_MASK
|
411 OXYGEN_2WIRE_SPEED_STANDARD
);
414 static void xonar_st_init_common(struct oxygen
*chip
)
416 struct xonar_pcm179x
*data
= chip
->model_data
;
418 data
->generic
.output_enable_bit
= GPIO_ST_OUTPUT_ENABLE
;
419 data
->dacs
= chip
->model
.dac_channels_mixer
/ 2;
420 data
->hp_gain_offset
= 2*-18;
424 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
425 GPIO_INPUT_ROUTE
| GPIO_ST_HP_REAR
|
426 GPIO_ST_MAGIC
| GPIO_ST_HP
);
427 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
,
428 GPIO_INPUT_ROUTE
| GPIO_ST_HP_REAR
| GPIO_ST_HP
);
430 xonar_init_cs53x1(chip
);
431 xonar_enable_output(chip
);
433 snd_component_add(chip
->card
, "PCM1792A");
434 snd_component_add(chip
->card
, "CS5381");
437 static void cs2000_registers_init(struct oxygen
*chip
)
439 struct xonar_pcm179x
*data
= chip
->model_data
;
441 cs2000_write(chip
, CS2000_GLOBAL_CFG
, CS2000_FREEZE
);
442 cs2000_write(chip
, CS2000_DEV_CTRL
, 0);
443 cs2000_write(chip
, CS2000_DEV_CFG_1
,
445 (0 << CS2000_R_SEL_SHIFT
) |
446 CS2000_AUX_OUT_SRC_REF_CLK
|
447 CS2000_EN_DEV_CFG_1
);
448 cs2000_write(chip
, CS2000_DEV_CFG_2
,
449 (0 << CS2000_LOCK_CLK_SHIFT
) |
450 CS2000_FRAC_N_SRC_STATIC
);
451 cs2000_write(chip
, CS2000_RATIO_0
+ 0, 0x00); /* 1.0 */
452 cs2000_write(chip
, CS2000_RATIO_0
+ 1, 0x10);
453 cs2000_write(chip
, CS2000_RATIO_0
+ 2, 0x00);
454 cs2000_write(chip
, CS2000_RATIO_0
+ 3, 0x00);
455 cs2000_write(chip
, CS2000_FUN_CFG_1
,
456 data
->cs2000_regs
[CS2000_FUN_CFG_1
]);
457 cs2000_write(chip
, CS2000_FUN_CFG_2
, 0);
458 cs2000_write(chip
, CS2000_GLOBAL_CFG
, CS2000_EN_DEV_CFG_2
);
459 msleep(3); /* PLL lock delay */
462 static void xonar_st_init(struct oxygen
*chip
)
464 struct xonar_pcm179x
*data
= chip
->model_data
;
466 data
->generic
.anti_pop_delay
= 100;
467 data
->h6
= chip
->model
.dac_channels_mixer
> 2;
468 data
->has_cs2000
= 1;
469 data
->cs2000_regs
[CS2000_FUN_CFG_1
] = CS2000_REF_CLK_DIV_1
;
470 data
->broken_i2c
= true;
472 oxygen_write16(chip
, OXYGEN_I2S_A_FORMAT
,
474 OXYGEN_I2S_FORMAT_I2S
|
475 OXYGEN_I2S_MCLK(data
->h6
? MCLK_256
: MCLK_512
) |
480 xonar_st_init_i2c(chip
);
481 cs2000_registers_init(chip
);
482 xonar_st_init_common(chip
);
484 snd_component_add(chip
->card
, "CS2000");
487 static void xonar_stx_init(struct oxygen
*chip
)
489 struct xonar_pcm179x
*data
= chip
->model_data
;
491 xonar_st_init_i2c(chip
);
492 data
->generic
.anti_pop_delay
= 800;
493 data
->generic
.ext_power_reg
= OXYGEN_GPI_DATA
;
494 data
->generic
.ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
495 data
->generic
.ext_power_bit
= GPI_EXT_POWER
;
496 xonar_init_ext_power(chip
);
497 xonar_st_init_common(chip
);
500 static void xonar_d2_cleanup(struct oxygen
*chip
)
502 xonar_disable_output(chip
);
505 static void xonar_hdav_cleanup(struct oxygen
*chip
)
507 xonar_hdmi_cleanup(chip
);
508 xonar_disable_output(chip
);
512 static void xonar_st_cleanup(struct oxygen
*chip
)
514 xonar_disable_output(chip
);
517 static void xonar_d2_suspend(struct oxygen
*chip
)
519 xonar_d2_cleanup(chip
);
522 static void xonar_hdav_suspend(struct oxygen
*chip
)
524 xonar_hdav_cleanup(chip
);
527 static void xonar_st_suspend(struct oxygen
*chip
)
529 xonar_st_cleanup(chip
);
532 static void xonar_d2_resume(struct oxygen
*chip
)
534 pcm1796_registers_init(chip
);
535 xonar_enable_output(chip
);
538 static void xonar_hdav_resume(struct oxygen
*chip
)
540 struct xonar_hdav
*data
= chip
->model_data
;
542 pcm1796_registers_init(chip
);
543 xonar_hdmi_resume(chip
, &data
->hdmi
);
544 xonar_enable_output(chip
);
547 static void xonar_stx_resume(struct oxygen
*chip
)
549 pcm1796_registers_init(chip
);
550 xonar_enable_output(chip
);
553 static void xonar_st_resume(struct oxygen
*chip
)
555 cs2000_registers_init(chip
);
556 xonar_stx_resume(chip
);
559 static void update_pcm1796_oversampling(struct oxygen
*chip
)
561 struct xonar_pcm179x
*data
= chip
->model_data
;
565 if (data
->current_rate
<= 48000 && !data
->h6
)
566 reg
= PCM1796_OS_128
;
569 for (i
= 0; i
< data
->dacs
; ++i
)
570 pcm1796_write_cached(chip
, i
, 20, reg
);
573 static void set_pcm1796_params(struct oxygen
*chip
,
574 struct snd_pcm_hw_params
*params
)
576 struct xonar_pcm179x
*data
= chip
->model_data
;
579 data
->current_rate
= params_rate(params
);
580 update_pcm1796_oversampling(chip
);
583 static void update_pcm1796_volume(struct oxygen
*chip
)
585 struct xonar_pcm179x
*data
= chip
->model_data
;
589 gain_offset
= data
->hp_active
? data
->hp_gain_offset
: 0;
590 for (i
= 0; i
< data
->dacs
; ++i
) {
591 pcm1796_write_cached(chip
, i
, 16, chip
->dac_volume
[i
* 2]
593 pcm1796_write_cached(chip
, i
, 17, chip
->dac_volume
[i
* 2 + 1]
599 static void update_pcm1796_mute(struct oxygen
*chip
)
601 struct xonar_pcm179x
*data
= chip
->model_data
;
605 value
= PCM1796_DMF_DISABLED
| PCM1796_FMT_24_I2S
| PCM1796_ATLD
;
607 value
|= PCM1796_MUTE
;
608 for (i
= 0; i
< data
->dacs
; ++i
)
609 pcm1796_write_cached(chip
, i
, 18, value
);
612 static void update_cs2000_rate(struct oxygen
*chip
, unsigned int rate
)
614 struct xonar_pcm179x
*data
= chip
->model_data
;
620 rate_mclk
= OXYGEN_RATE_32000
;
625 rate_mclk
= OXYGEN_RATE_44100
;
631 rate_mclk
= OXYGEN_RATE_48000
;
635 if (rate
<= 96000 && (rate
> 48000 || data
->h6
)) {
636 rate_mclk
|= OXYGEN_I2S_MCLK(MCLK_256
);
637 reg
= CS2000_REF_CLK_DIV_1
;
639 rate_mclk
|= OXYGEN_I2S_MCLK(MCLK_512
);
640 reg
= CS2000_REF_CLK_DIV_2
;
643 oxygen_write16_masked(chip
, OXYGEN_I2S_A_FORMAT
, rate_mclk
,
644 OXYGEN_I2S_RATE_MASK
| OXYGEN_I2S_MCLK_MASK
);
645 cs2000_write_cached(chip
, CS2000_FUN_CFG_1
, reg
);
646 msleep(3); /* PLL lock delay */
649 static void set_st_params(struct oxygen
*chip
,
650 struct snd_pcm_hw_params
*params
)
652 update_cs2000_rate(chip
, params_rate(params
));
653 set_pcm1796_params(chip
, params
);
656 static void set_hdav_params(struct oxygen
*chip
,
657 struct snd_pcm_hw_params
*params
)
659 struct xonar_hdav
*data
= chip
->model_data
;
661 set_pcm1796_params(chip
, params
);
662 xonar_set_hdmi_params(chip
, &data
->hdmi
, params
);
665 static const struct snd_kcontrol_new alt_switch
= {
666 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
667 .name
= "Analog Loopback Switch",
668 .info
= snd_ctl_boolean_mono_info
,
669 .get
= xonar_gpio_bit_switch_get
,
670 .put
= xonar_gpio_bit_switch_put
,
671 .private_value
= GPIO_D2_ALT
,
674 static int rolloff_info(struct snd_kcontrol
*ctl
,
675 struct snd_ctl_elem_info
*info
)
677 static const char *const names
[2] = {
678 "Sharp Roll-off", "Slow Roll-off"
681 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
683 info
->value
.enumerated
.items
= 2;
684 if (info
->value
.enumerated
.item
>= 2)
685 info
->value
.enumerated
.item
= 1;
686 strcpy(info
->value
.enumerated
.name
, names
[info
->value
.enumerated
.item
]);
690 static int rolloff_get(struct snd_kcontrol
*ctl
,
691 struct snd_ctl_elem_value
*value
)
693 struct oxygen
*chip
= ctl
->private_data
;
694 struct xonar_pcm179x
*data
= chip
->model_data
;
696 value
->value
.enumerated
.item
[0] =
697 (data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
] &
698 PCM1796_FLT_MASK
) != PCM1796_FLT_SHARP
;
702 static int rolloff_put(struct snd_kcontrol
*ctl
,
703 struct snd_ctl_elem_value
*value
)
705 struct oxygen
*chip
= ctl
->private_data
;
706 struct xonar_pcm179x
*data
= chip
->model_data
;
711 mutex_lock(&chip
->mutex
);
712 reg
= data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
];
713 reg
&= ~PCM1796_FLT_MASK
;
714 if (!value
->value
.enumerated
.item
[0])
715 reg
|= PCM1796_FLT_SHARP
;
717 reg
|= PCM1796_FLT_SLOW
;
718 changed
= reg
!= data
->pcm1796_regs
[0][19 - PCM1796_REG_BASE
];
720 for (i
= 0; i
< data
->dacs
; ++i
)
721 pcm1796_write(chip
, i
, 19, reg
);
723 mutex_unlock(&chip
->mutex
);
727 static const struct snd_kcontrol_new rolloff_control
= {
728 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
729 .name
= "DAC Filter Playback Enum",
730 .info
= rolloff_info
,
735 static const struct snd_kcontrol_new hdav_hdmi_control
= {
736 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
737 .name
= "HDMI Playback Switch",
738 .info
= snd_ctl_boolean_mono_info
,
739 .get
= xonar_gpio_bit_switch_get
,
740 .put
= xonar_gpio_bit_switch_put
,
741 .private_value
= GPIO_HDAV_OUTPUT_ENABLE
| XONAR_GPIO_BIT_INVERT
,
744 static int st_output_switch_info(struct snd_kcontrol
*ctl
,
745 struct snd_ctl_elem_info
*info
)
747 static const char *const names
[3] = {
748 "Speakers", "Headphones", "FP Headphones"
751 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
753 info
->value
.enumerated
.items
= 3;
754 if (info
->value
.enumerated
.item
>= 3)
755 info
->value
.enumerated
.item
= 2;
756 strcpy(info
->value
.enumerated
.name
, names
[info
->value
.enumerated
.item
]);
760 static int st_output_switch_get(struct snd_kcontrol
*ctl
,
761 struct snd_ctl_elem_value
*value
)
763 struct oxygen
*chip
= ctl
->private_data
;
766 gpio
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
767 if (!(gpio
& GPIO_ST_HP
))
768 value
->value
.enumerated
.item
[0] = 0;
769 else if (gpio
& GPIO_ST_HP_REAR
)
770 value
->value
.enumerated
.item
[0] = 1;
772 value
->value
.enumerated
.item
[0] = 2;
777 static int st_output_switch_put(struct snd_kcontrol
*ctl
,
778 struct snd_ctl_elem_value
*value
)
780 struct oxygen
*chip
= ctl
->private_data
;
781 struct xonar_pcm179x
*data
= chip
->model_data
;
784 mutex_lock(&chip
->mutex
);
785 gpio_old
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
787 switch (value
->value
.enumerated
.item
[0]) {
789 gpio
&= ~(GPIO_ST_HP
| GPIO_ST_HP_REAR
);
792 gpio
|= GPIO_ST_HP
| GPIO_ST_HP_REAR
;
795 gpio
= (gpio
| GPIO_ST_HP
) & ~GPIO_ST_HP_REAR
;
798 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, gpio
);
799 data
->hp_active
= gpio
& GPIO_ST_HP
;
800 update_pcm1796_volume(chip
);
801 mutex_unlock(&chip
->mutex
);
802 return gpio
!= gpio_old
;
805 static int st_hp_volume_offset_info(struct snd_kcontrol
*ctl
,
806 struct snd_ctl_elem_info
*info
)
808 static const char *const names
[3] = {
809 "< 64 ohms", "64-300 ohms", "300-600 ohms"
812 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
814 info
->value
.enumerated
.items
= 3;
815 if (info
->value
.enumerated
.item
> 2)
816 info
->value
.enumerated
.item
= 2;
817 strcpy(info
->value
.enumerated
.name
, names
[info
->value
.enumerated
.item
]);
821 static int st_hp_volume_offset_get(struct snd_kcontrol
*ctl
,
822 struct snd_ctl_elem_value
*value
)
824 struct oxygen
*chip
= ctl
->private_data
;
825 struct xonar_pcm179x
*data
= chip
->model_data
;
827 mutex_lock(&chip
->mutex
);
828 if (data
->hp_gain_offset
< 2*-6)
829 value
->value
.enumerated
.item
[0] = 0;
830 else if (data
->hp_gain_offset
< 0)
831 value
->value
.enumerated
.item
[0] = 1;
833 value
->value
.enumerated
.item
[0] = 2;
834 mutex_unlock(&chip
->mutex
);
839 static int st_hp_volume_offset_put(struct snd_kcontrol
*ctl
,
840 struct snd_ctl_elem_value
*value
)
842 static const s8 offsets
[] = { 2*-18, 2*-6, 0 };
843 struct oxygen
*chip
= ctl
->private_data
;
844 struct xonar_pcm179x
*data
= chip
->model_data
;
848 if (value
->value
.enumerated
.item
[0] > 2)
850 offset
= offsets
[value
->value
.enumerated
.item
[0]];
851 mutex_lock(&chip
->mutex
);
852 changed
= offset
!= data
->hp_gain_offset
;
854 data
->hp_gain_offset
= offset
;
855 update_pcm1796_volume(chip
);
857 mutex_unlock(&chip
->mutex
);
861 static const struct snd_kcontrol_new st_controls
[] = {
863 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
864 .name
= "Analog Output",
865 .info
= st_output_switch_info
,
866 .get
= st_output_switch_get
,
867 .put
= st_output_switch_put
,
870 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
871 .name
= "Headphones Impedance Playback Enum",
872 .info
= st_hp_volume_offset_info
,
873 .get
= st_hp_volume_offset_get
,
874 .put
= st_hp_volume_offset_put
,
878 static void xonar_line_mic_ac97_switch(struct oxygen
*chip
,
879 unsigned int reg
, unsigned int mute
)
881 if (reg
== AC97_LINE
) {
882 spin_lock_irq(&chip
->reg_lock
);
883 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
884 mute
? GPIO_INPUT_ROUTE
: 0,
886 spin_unlock_irq(&chip
->reg_lock
);
890 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale
, -6000, 50, 0);
892 static int xonar_d2_control_filter(struct snd_kcontrol_new
*template)
894 if (!strncmp(template->name
, "CD Capture ", 11))
895 /* CD in is actually connected to the video in pin */
896 template->private_value
^= AC97_CD
^ AC97_VIDEO
;
900 static int xonar_st_h6_control_filter(struct snd_kcontrol_new
*template)
902 if (!strncmp(template->name
, "Master Playback ", 16))
903 /* no volume/mute, as I²C to the third DAC does not work */
908 static int add_pcm1796_controls(struct oxygen
*chip
)
910 struct xonar_pcm179x
*data
= chip
->model_data
;
913 if (!data
->broken_i2c
) {
914 err
= snd_ctl_add(chip
->card
,
915 snd_ctl_new1(&rolloff_control
, chip
));
922 static int xonar_d2_mixer_init(struct oxygen
*chip
)
926 err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&alt_switch
, chip
));
929 err
= add_pcm1796_controls(chip
);
935 static int xonar_hdav_mixer_init(struct oxygen
*chip
)
939 err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&hdav_hdmi_control
, chip
));
942 err
= add_pcm1796_controls(chip
);
948 static int xonar_st_mixer_init(struct oxygen
*chip
)
953 for (i
= 0; i
< ARRAY_SIZE(st_controls
); ++i
) {
954 err
= snd_ctl_add(chip
->card
,
955 snd_ctl_new1(&st_controls
[i
], chip
));
959 err
= add_pcm1796_controls(chip
);
965 static void dump_pcm1796_registers(struct oxygen
*chip
,
966 struct snd_info_buffer
*buffer
)
968 struct xonar_pcm179x
*data
= chip
->model_data
;
971 for (dac
= 0; dac
< data
->dacs
; ++dac
) {
972 snd_iprintf(buffer
, "\nPCM1796 %u:", dac
+ 1);
973 for (i
= 0; i
< 5; ++i
)
974 snd_iprintf(buffer
, " %02x",
975 data
->pcm1796_regs
[dac
][i
]);
977 snd_iprintf(buffer
, "\n");
980 static void dump_cs2000_registers(struct oxygen
*chip
,
981 struct snd_info_buffer
*buffer
)
983 struct xonar_pcm179x
*data
= chip
->model_data
;
986 if (data
->has_cs2000
) {
987 snd_iprintf(buffer
, "\nCS2000:\n00: ");
988 for (i
= 1; i
< 0x10; ++i
)
989 snd_iprintf(buffer
, " %02x", data
->cs2000_regs
[i
]);
990 snd_iprintf(buffer
, "\n10:");
991 for (i
= 0x10; i
< 0x1f; ++i
)
992 snd_iprintf(buffer
, " %02x", data
->cs2000_regs
[i
]);
993 snd_iprintf(buffer
, "\n");
997 static void dump_st_registers(struct oxygen
*chip
,
998 struct snd_info_buffer
*buffer
)
1000 dump_pcm1796_registers(chip
, buffer
);
1001 dump_cs2000_registers(chip
, buffer
);
1004 static const struct oxygen_model model_xonar_d2
= {
1005 .longname
= "Asus Virtuoso 200",
1007 .init
= xonar_d2_init
,
1008 .control_filter
= xonar_d2_control_filter
,
1009 .mixer_init
= xonar_d2_mixer_init
,
1010 .cleanup
= xonar_d2_cleanup
,
1011 .suspend
= xonar_d2_suspend
,
1012 .resume
= xonar_d2_resume
,
1013 .set_dac_params
= set_pcm1796_params
,
1014 .set_adc_params
= xonar_set_cs53x1_params
,
1015 .update_dac_volume
= update_pcm1796_volume
,
1016 .update_dac_mute
= update_pcm1796_mute
,
1017 .dump_registers
= dump_pcm1796_registers
,
1018 .dac_tlv
= pcm1796_db_scale
,
1019 .model_data_size
= sizeof(struct xonar_pcm179x
),
1020 .device_config
= PLAYBACK_0_TO_I2S
|
1021 PLAYBACK_1_TO_SPDIF
|
1022 CAPTURE_0_FROM_I2S_2
|
1023 CAPTURE_1_FROM_SPDIF
|
1027 .dac_channels_pcm
= 8,
1028 .dac_channels_mixer
= 8,
1029 .dac_volume_min
= 255 - 2*60,
1030 .dac_volume_max
= 255,
1031 .misc_flags
= OXYGEN_MISC_MIDI
,
1032 .function_flags
= OXYGEN_FUNCTION_SPI
|
1033 OXYGEN_FUNCTION_ENABLE_SPI_4_5
,
1034 .dac_mclks
= OXYGEN_MCLKS(512, 128, 128),
1035 .adc_mclks
= OXYGEN_MCLKS(256, 128, 128),
1036 .dac_i2s_format
= OXYGEN_I2S_FORMAT_I2S
,
1037 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1040 static const struct oxygen_model model_xonar_hdav
= {
1041 .longname
= "Asus Virtuoso 200",
1043 .init
= xonar_hdav_init
,
1044 .mixer_init
= xonar_hdav_mixer_init
,
1045 .cleanup
= xonar_hdav_cleanup
,
1046 .suspend
= xonar_hdav_suspend
,
1047 .resume
= xonar_hdav_resume
,
1048 .pcm_hardware_filter
= xonar_hdmi_pcm_hardware_filter
,
1049 .set_dac_params
= set_hdav_params
,
1050 .set_adc_params
= xonar_set_cs53x1_params
,
1051 .update_dac_volume
= update_pcm1796_volume
,
1052 .update_dac_mute
= update_pcm1796_mute
,
1053 .uart_input
= xonar_hdmi_uart_input
,
1054 .ac97_switch
= xonar_line_mic_ac97_switch
,
1055 .dump_registers
= dump_pcm1796_registers
,
1056 .dac_tlv
= pcm1796_db_scale
,
1057 .model_data_size
= sizeof(struct xonar_hdav
),
1058 .device_config
= PLAYBACK_0_TO_I2S
|
1059 PLAYBACK_1_TO_SPDIF
|
1060 CAPTURE_0_FROM_I2S_2
|
1061 CAPTURE_1_FROM_SPDIF
,
1062 .dac_channels_pcm
= 8,
1063 .dac_channels_mixer
= 2,
1064 .dac_volume_min
= 255 - 2*60,
1065 .dac_volume_max
= 255,
1066 .misc_flags
= OXYGEN_MISC_MIDI
,
1067 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
1068 .dac_mclks
= OXYGEN_MCLKS(512, 128, 128),
1069 .adc_mclks
= OXYGEN_MCLKS(256, 128, 128),
1070 .dac_i2s_format
= OXYGEN_I2S_FORMAT_I2S
,
1071 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1074 static const struct oxygen_model model_xonar_st
= {
1075 .longname
= "Asus Virtuoso 100",
1077 .init
= xonar_st_init
,
1078 .mixer_init
= xonar_st_mixer_init
,
1079 .cleanup
= xonar_st_cleanup
,
1080 .suspend
= xonar_st_suspend
,
1081 .resume
= xonar_st_resume
,
1082 .set_dac_params
= set_st_params
,
1083 .set_adc_params
= xonar_set_cs53x1_params
,
1084 .update_dac_volume
= update_pcm1796_volume
,
1085 .update_dac_mute
= update_pcm1796_mute
,
1086 .ac97_switch
= xonar_line_mic_ac97_switch
,
1087 .dump_registers
= dump_st_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
|
1094 .dac_channels_pcm
= 2,
1095 .dac_channels_mixer
= 2,
1096 .dac_volume_min
= 255 - 2*60,
1097 .dac_volume_max
= 255,
1098 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
1099 .dac_mclks
= OXYGEN_MCLKS(512, 128, 128),
1100 .adc_mclks
= OXYGEN_MCLKS(256, 128, 128),
1101 .dac_i2s_format
= OXYGEN_I2S_FORMAT_I2S
,
1102 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1105 int __devinit
get_xonar_pcm179x_model(struct oxygen
*chip
,
1106 const struct pci_device_id
*id
)
1108 switch (id
->subdevice
) {
1110 chip
->model
= model_xonar_d2
;
1111 chip
->model
.shortname
= "Xonar D2";
1114 chip
->model
= model_xonar_d2
;
1115 chip
->model
.shortname
= "Xonar D2X";
1116 chip
->model
.init
= xonar_d2x_init
;
1119 chip
->model
= model_xonar_hdav
;
1120 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_DB_MASK
);
1121 switch (oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & GPIO_DB_MASK
) {
1123 chip
->model
.shortname
= "Xonar HDAV1.3";
1126 chip
->model
.shortname
= "Xonar HDAV1.3+H6";
1127 chip
->model
.dac_channels_mixer
= 8;
1128 chip
->model
.dac_mclks
= OXYGEN_MCLKS(256, 128, 128);
1133 chip
->model
= model_xonar_st
;
1134 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_DB_MASK
);
1135 switch (oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & GPIO_DB_MASK
) {
1137 chip
->model
.shortname
= "Xonar ST";
1140 chip
->model
.shortname
= "Xonar ST+H6";
1141 chip
->model
.control_filter
= xonar_st_h6_control_filter
;
1142 chip
->model
.dac_channels_pcm
= 8;
1143 chip
->model
.dac_channels_mixer
= 8;
1144 chip
->model
.dac_mclks
= OXYGEN_MCLKS(256, 128, 128);
1149 chip
->model
= model_xonar_st
;
1150 chip
->model
.shortname
= "Xonar STX";
1151 chip
->model
.init
= xonar_stx_init
;
1152 chip
->model
.resume
= xonar_stx_resume
;
1153 chip
->model
.set_dac_params
= set_pcm1796_params
;