2 * C-Media CMI8788 driver for Asus Xonar cards
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, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 * SPI 0 -> 1st PCM1796 (front)
27 * SPI 1 -> 2nd PCM1796 (surround)
28 * SPI 2 -> 3rd PCM1796 (center/LFE)
29 * SPI 4 -> 4th PCM1796 (back)
31 * GPIO 2 -> M0 of CS5381
32 * GPIO 3 -> M1 of CS5381
33 * GPIO 5 <- external power present (D2X only)
35 * GPIO 8 -> enable output to speakers
44 * I²C <-> CS4398 (front)
45 * <-> CS4362A (surround, center/LFE, back)
47 * GPI 0 <- external power present (DX only)
49 * GPIO 0 -> enable output to speakers
50 * GPIO 1 -> enable front panel I/O
51 * GPIO 2 -> M0 of CS5361
52 * GPIO 3 -> M1 of CS5361
53 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
66 * Xonar HDAV1.3 (Deluxe)
67 * ----------------------
71 * I²C <-> PCM1796 (front)
73 * GPI 0 <- external power present
75 * GPIO 0 -> enable output to speakers
76 * GPIO 2 -> M0 of CS5381
77 * GPIO 3 -> M1 of CS5381
78 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
80 * TXD -> HDMI controller
81 * RXD <- HDMI controller
83 * PCM1796 front: AD1,0 <- 0,0
96 * I²C <-> PCM1796 (surround)
97 * <-> PCM1796 (center/LFE)
100 * PCM1796 surround: AD1,0 <- 0,1
101 * PCM1796 center/LFE: AD1,0 <- 1,0
102 * PCM1796 back: AD1,0 <- 1,1
104 * unknown daughterboard
105 * ---------------------
110 * I²C <-> CS4362A (surround, center/LFE, back)
123 * GPI 0 <- external power present
125 * GPIO 0 -> enable output to speakers
126 * GPIO 1 -> route HP to front panel (0) or rear jack (1)
127 * GPIO 2 -> M0 of CS5381
128 * GPIO 3 -> M1 of CS5381
129 * GPIO 7 -> route output to speaker jacks (0) or HP (1)
130 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
143 #include <linux/pci.h>
144 #include <linux/delay.h>
145 #include <linux/mutex.h>
146 #include <sound/ac97_codec.h>
147 #include <sound/asoundef.h>
148 #include <sound/control.h>
149 #include <sound/core.h>
150 #include <sound/initval.h>
151 #include <sound/pcm.h>
152 #include <sound/pcm_params.h>
153 #include <sound/tlv.h>
160 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
161 MODULE_DESCRIPTION("Asus AVx00 driver");
162 MODULE_LICENSE("GPL v2");
163 MODULE_SUPPORTED_DEVICE("{{Asus,AV100},{Asus,AV200}}");
165 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
166 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
167 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
169 module_param_array(index
, int, NULL
, 0444);
170 MODULE_PARM_DESC(index
, "card index");
171 module_param_array(id
, charp
, NULL
, 0444);
172 MODULE_PARM_DESC(id
, "ID string");
173 module_param_array(enable
, bool, NULL
, 0444);
174 MODULE_PARM_DESC(enable
, "enable card");
181 MODEL_HDAV
, /* without daughterboard */
182 MODEL_HDAV_H6
, /* with H6 daughterboard */
186 static struct pci_device_id xonar_ids
[] __devinitdata
= {
187 { OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data
= MODEL_D2
},
188 { OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data
= MODEL_DX
},
189 { OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data
= MODEL_D2X
},
190 { OXYGEN_PCI_SUBID(0x1043, 0x8314), .driver_data
= MODEL_HDAV
},
191 { OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data
= MODEL_D1
},
192 { OXYGEN_PCI_SUBID(0x1043, 0x835c), .driver_data
= MODEL_STX
},
193 { OXYGEN_PCI_SUBID_BROKEN_EEPROM
},
196 MODULE_DEVICE_TABLE(pci
, xonar_ids
);
199 #define GPIO_CS53x1_M_MASK 0x000c
200 #define GPIO_CS53x1_M_SINGLE 0x0000
201 #define GPIO_CS53x1_M_DOUBLE 0x0004
202 #define GPIO_CS53x1_M_QUAD 0x0008
204 #define GPIO_D2X_EXT_POWER 0x0020
205 #define GPIO_D2_ALT 0x0080
206 #define GPIO_D2_OUTPUT_ENABLE 0x0100
208 #define GPI_DX_EXT_POWER 0x01
209 #define GPIO_DX_OUTPUT_ENABLE 0x0001
210 #define GPIO_DX_FRONT_PANEL 0x0002
211 #define GPIO_DX_INPUT_ROUTE 0x0100
213 #define GPIO_HDAV_DB_MASK 0x0030
214 #define GPIO_HDAV_DB_H6 0x0000
215 #define GPIO_HDAV_DB_XX 0x0020
217 #define GPIO_ST_HP_REAR 0x0002
218 #define GPIO_ST_HP 0x0080
220 #define I2C_DEVICE_PCM1796(i) (0x98 + ((i) << 1)) /* 10011, ADx=i, /W=0 */
221 #define I2C_DEVICE_CS4398 0x9e /* 10011, AD1=1, AD0=1, /W=0 */
222 #define I2C_DEVICE_CS4362A 0x30 /* 001100, AD0=0, /W=0 */
225 unsigned int anti_pop_delay
;
227 u16 output_enable_bit
;
229 u8 ext_power_int_reg
;
232 u8 pcm1796_oversampling
;
238 static void xonar_gpio_changed(struct oxygen
*chip
);
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 if ((chip
->model
.function_flags
& OXYGEN_FUNCTION_2WIRE_SPI_MASK
) ==
266 pcm1796_write_spi(chip
, codec
, reg
, value
);
268 pcm1796_write_i2c(chip
, codec
, reg
, value
);
271 static void cs4398_write(struct oxygen
*chip
, u8 reg
, u8 value
)
273 oxygen_write_i2c(chip
, I2C_DEVICE_CS4398
, reg
, value
);
276 static void cs4362a_write(struct oxygen
*chip
, u8 reg
, u8 value
)
278 oxygen_write_i2c(chip
, I2C_DEVICE_CS4362A
, reg
, value
);
281 static void hdmi_write_command(struct oxygen
*chip
, u8 command
,
282 unsigned int count
, const u8
*params
)
287 oxygen_write_uart(chip
, 0xfb);
288 oxygen_write_uart(chip
, 0xef);
289 oxygen_write_uart(chip
, command
);
290 oxygen_write_uart(chip
, count
);
291 for (i
= 0; i
< count
; ++i
)
292 oxygen_write_uart(chip
, params
[i
]);
293 checksum
= 0xfb + 0xef + command
+ count
;
294 for (i
= 0; i
< count
; ++i
)
295 checksum
+= params
[i
];
296 oxygen_write_uart(chip
, checksum
);
299 static void xonar_enable_output(struct oxygen
*chip
)
301 struct xonar_data
*data
= chip
->model_data
;
303 msleep(data
->anti_pop_delay
);
304 oxygen_set_bits16(chip
, OXYGEN_GPIO_DATA
, data
->output_enable_bit
);
307 static void xonar_common_init(struct oxygen
*chip
)
309 struct xonar_data
*data
= chip
->model_data
;
311 if (data
->ext_power_reg
) {
312 oxygen_set_bits8(chip
, data
->ext_power_int_reg
,
313 data
->ext_power_bit
);
314 chip
->interrupt_mask
|= OXYGEN_INT_GPIO
;
315 chip
->model
.gpio_changed
= xonar_gpio_changed
;
316 data
->has_power
= !!(oxygen_read8(chip
, data
->ext_power_reg
)
317 & data
->ext_power_bit
);
319 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
320 GPIO_CS53x1_M_MASK
| data
->output_enable_bit
);
321 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
322 GPIO_CS53x1_M_SINGLE
, GPIO_CS53x1_M_MASK
);
323 oxygen_ac97_set_bits(chip
, 0, CM9780_JACK
, CM9780_FMIC2MIC
);
324 xonar_enable_output(chip
);
327 static void update_pcm1796_volume(struct oxygen
*chip
)
329 struct xonar_data
*data
= chip
->model_data
;
332 for (i
= 0; i
< data
->dacs
; ++i
) {
333 pcm1796_write(chip
, i
, 16, chip
->dac_volume
[i
* 2]);
334 pcm1796_write(chip
, i
, 17, chip
->dac_volume
[i
* 2 + 1]);
338 static void update_pcm1796_mute(struct oxygen
*chip
)
340 struct xonar_data
*data
= chip
->model_data
;
344 value
= PCM1796_DMF_DISABLED
| PCM1796_FMT_24_LJUST
| PCM1796_ATLD
;
346 value
|= PCM1796_MUTE
;
347 for (i
= 0; i
< data
->dacs
; ++i
)
348 pcm1796_write(chip
, i
, 18, value
);
351 static void pcm1796_init(struct oxygen
*chip
)
353 struct xonar_data
*data
= chip
->model_data
;
356 for (i
= 0; i
< data
->dacs
; ++i
) {
357 pcm1796_write(chip
, i
, 19, PCM1796_FLT_SHARP
| PCM1796_ATS_1
);
358 pcm1796_write(chip
, i
, 20, data
->pcm1796_oversampling
);
359 pcm1796_write(chip
, i
, 21, 0);
361 update_pcm1796_mute(chip
); /* set ATLD before ATL/ATR */
362 update_pcm1796_volume(chip
);
365 static void xonar_d2_init(struct oxygen
*chip
)
367 struct xonar_data
*data
= chip
->model_data
;
369 data
->anti_pop_delay
= 300;
371 data
->output_enable_bit
= GPIO_D2_OUTPUT_ENABLE
;
372 data
->pcm1796_oversampling
= PCM1796_OS_64
;
376 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2_ALT
);
377 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_D2_ALT
);
379 xonar_common_init(chip
);
381 snd_component_add(chip
->card
, "PCM1796");
382 snd_component_add(chip
->card
, "CS5381");
385 static void xonar_d2x_init(struct oxygen
*chip
)
387 struct xonar_data
*data
= chip
->model_data
;
389 data
->ext_power_reg
= OXYGEN_GPIO_DATA
;
390 data
->ext_power_int_reg
= OXYGEN_GPIO_INTERRUPT_MASK
;
391 data
->ext_power_bit
= GPIO_D2X_EXT_POWER
;
392 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2X_EXT_POWER
);
397 static void update_cs4362a_volumes(struct oxygen
*chip
)
401 mute
= chip
->dac_mute
? CS4362A_MUTE
: 0;
402 cs4362a_write(chip
, 7, (127 - chip
->dac_volume
[2]) | mute
);
403 cs4362a_write(chip
, 8, (127 - chip
->dac_volume
[3]) | mute
);
404 cs4362a_write(chip
, 10, (127 - chip
->dac_volume
[4]) | mute
);
405 cs4362a_write(chip
, 11, (127 - chip
->dac_volume
[5]) | mute
);
406 cs4362a_write(chip
, 13, (127 - chip
->dac_volume
[6]) | mute
);
407 cs4362a_write(chip
, 14, (127 - chip
->dac_volume
[7]) | mute
);
410 static void update_cs43xx_volume(struct oxygen
*chip
)
412 cs4398_write(chip
, 5, (127 - chip
->dac_volume
[0]) * 2);
413 cs4398_write(chip
, 6, (127 - chip
->dac_volume
[1]) * 2);
414 update_cs4362a_volumes(chip
);
417 static void update_cs43xx_mute(struct oxygen
*chip
)
421 reg
= CS4398_MUTEP_LOW
| CS4398_PAMUTE
;
423 reg
|= CS4398_MUTE_B
| CS4398_MUTE_A
;
424 cs4398_write(chip
, 4, reg
);
425 update_cs4362a_volumes(chip
);
428 static void cs43xx_init(struct oxygen
*chip
)
430 struct xonar_data
*data
= chip
->model_data
;
432 /* set CPEN (control port mode) and power down */
433 cs4398_write(chip
, 8, CS4398_CPEN
| CS4398_PDN
);
434 cs4362a_write(chip
, 0x01, CS4362A_PDN
| CS4362A_CPEN
);
436 cs4398_write(chip
, 2, data
->cs4398_fm
);
437 cs4398_write(chip
, 3, CS4398_ATAPI_B_R
| CS4398_ATAPI_A_L
);
438 cs4398_write(chip
, 7, CS4398_RMP_DN
| CS4398_RMP_UP
|
439 CS4398_ZERO_CROSS
| CS4398_SOFT_RAMP
);
440 cs4362a_write(chip
, 0x02, CS4362A_DIF_LJUST
);
441 cs4362a_write(chip
, 0x03, CS4362A_MUTEC_6
| CS4362A_AMUTE
|
442 CS4362A_RMP_UP
| CS4362A_ZERO_CROSS
| CS4362A_SOFT_RAMP
);
443 cs4362a_write(chip
, 0x04, CS4362A_RMP_DN
| CS4362A_DEM_NONE
);
444 cs4362a_write(chip
, 0x05, 0);
445 cs4362a_write(chip
, 0x06, data
->cs4362a_fm
);
446 cs4362a_write(chip
, 0x09, data
->cs4362a_fm
);
447 cs4362a_write(chip
, 0x0c, data
->cs4362a_fm
);
448 update_cs43xx_volume(chip
);
449 update_cs43xx_mute(chip
);
450 /* clear power down */
451 cs4398_write(chip
, 8, CS4398_CPEN
);
452 cs4362a_write(chip
, 0x01, CS4362A_CPEN
);
455 static void xonar_d1_init(struct oxygen
*chip
)
457 struct xonar_data
*data
= chip
->model_data
;
459 data
->anti_pop_delay
= 800;
460 data
->output_enable_bit
= GPIO_DX_OUTPUT_ENABLE
;
461 data
->cs4398_fm
= CS4398_FM_SINGLE
| CS4398_DEM_NONE
| CS4398_DIF_LJUST
;
462 data
->cs4362a_fm
= CS4362A_FM_SINGLE
|
463 CS4362A_ATAPI_B_R
| CS4362A_ATAPI_A_L
;
465 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
466 OXYGEN_2WIRE_LENGTH_8
|
467 OXYGEN_2WIRE_INTERRUPT_MASK
|
468 OXYGEN_2WIRE_SPEED_FAST
);
472 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
473 GPIO_DX_FRONT_PANEL
| GPIO_DX_INPUT_ROUTE
);
474 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
,
475 GPIO_DX_FRONT_PANEL
| GPIO_DX_INPUT_ROUTE
);
477 xonar_common_init(chip
);
479 snd_component_add(chip
->card
, "CS4398");
480 snd_component_add(chip
->card
, "CS4362A");
481 snd_component_add(chip
->card
, "CS5361");
484 static void xonar_dx_init(struct oxygen
*chip
)
486 struct xonar_data
*data
= chip
->model_data
;
488 data
->ext_power_reg
= OXYGEN_GPI_DATA
;
489 data
->ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
490 data
->ext_power_bit
= GPI_DX_EXT_POWER
;
495 static void xonar_hdav_init(struct oxygen
*chip
)
497 struct xonar_data
*data
= chip
->model_data
;
500 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
501 OXYGEN_2WIRE_LENGTH_8
|
502 OXYGEN_2WIRE_INTERRUPT_MASK
|
503 OXYGEN_2WIRE_SPEED_FAST
);
505 data
->anti_pop_delay
= 100;
506 data
->dacs
= chip
->model
.private_data
== MODEL_HDAV_H6
? 4 : 1;
507 data
->output_enable_bit
= GPIO_DX_OUTPUT_ENABLE
;
508 data
->ext_power_reg
= OXYGEN_GPI_DATA
;
509 data
->ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
510 data
->ext_power_bit
= GPI_DX_EXT_POWER
;
511 data
->pcm1796_oversampling
= PCM1796_OS_64
;
515 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_DX_INPUT_ROUTE
);
516 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_DX_INPUT_ROUTE
);
518 oxygen_reset_uart(chip
);
520 hdmi_write_command(chip
, 0x61, 1, ¶m
);
522 hdmi_write_command(chip
, 0x74, 1, ¶m
);
523 data
->hdmi_params
[1] = IEC958_AES3_CON_FS_48000
;
524 data
->hdmi_params
[4] = 1;
525 hdmi_write_command(chip
, 0x54, 5, data
->hdmi_params
);
527 xonar_common_init(chip
);
529 snd_component_add(chip
->card
, "PCM1796");
530 snd_component_add(chip
->card
, "CS5381");
533 static void xonar_stx_init(struct oxygen
*chip
)
535 struct xonar_data
*data
= chip
->model_data
;
537 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
538 OXYGEN_2WIRE_LENGTH_8
|
539 OXYGEN_2WIRE_INTERRUPT_MASK
|
540 OXYGEN_2WIRE_SPEED_FAST
);
542 data
->anti_pop_delay
= 100;
544 data
->output_enable_bit
= GPIO_DX_OUTPUT_ENABLE
;
545 data
->ext_power_reg
= OXYGEN_GPI_DATA
;
546 data
->ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
547 data
->ext_power_bit
= GPI_DX_EXT_POWER
;
548 data
->pcm1796_oversampling
= PCM1796_OS_64
;
552 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
553 GPIO_DX_INPUT_ROUTE
| GPIO_ST_HP_REAR
| GPIO_ST_HP
);
554 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
,
555 GPIO_DX_INPUT_ROUTE
| GPIO_ST_HP_REAR
| GPIO_ST_HP
);
557 xonar_common_init(chip
);
559 snd_component_add(chip
->card
, "PCM1792A");
560 snd_component_add(chip
->card
, "CS5381");
563 static void xonar_disable_output(struct oxygen
*chip
)
565 struct xonar_data
*data
= chip
->model_data
;
567 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, data
->output_enable_bit
);
570 static void xonar_d2_cleanup(struct oxygen
*chip
)
572 xonar_disable_output(chip
);
575 static void xonar_d1_cleanup(struct oxygen
*chip
)
577 xonar_disable_output(chip
);
578 cs4362a_write(chip
, 0x01, CS4362A_PDN
| CS4362A_CPEN
);
579 oxygen_clear_bits8(chip
, OXYGEN_FUNCTION
, OXYGEN_FUNCTION_RESET_CODEC
);
582 static void xonar_hdav_cleanup(struct oxygen
*chip
)
586 hdmi_write_command(chip
, 0x74, 1, ¶m
);
587 xonar_disable_output(chip
);
590 static void xonar_st_cleanup(struct oxygen
*chip
)
592 xonar_disable_output(chip
);
595 static void xonar_d2_suspend(struct oxygen
*chip
)
597 xonar_d2_cleanup(chip
);
600 static void xonar_d1_suspend(struct oxygen
*chip
)
602 xonar_d1_cleanup(chip
);
605 static void xonar_hdav_suspend(struct oxygen
*chip
)
607 xonar_hdav_cleanup(chip
);
611 static void xonar_st_suspend(struct oxygen
*chip
)
613 xonar_st_cleanup(chip
);
616 static void xonar_d2_resume(struct oxygen
*chip
)
619 xonar_enable_output(chip
);
622 static void xonar_d1_resume(struct oxygen
*chip
)
624 oxygen_set_bits8(chip
, OXYGEN_FUNCTION
, OXYGEN_FUNCTION_RESET_CODEC
);
627 xonar_enable_output(chip
);
630 static void xonar_hdav_resume(struct oxygen
*chip
)
632 struct xonar_data
*data
= chip
->model_data
;
635 oxygen_reset_uart(chip
);
637 hdmi_write_command(chip
, 0x61, 1, ¶m
);
639 hdmi_write_command(chip
, 0x74, 1, ¶m
);
640 hdmi_write_command(chip
, 0x54, 5, data
->hdmi_params
);
642 xonar_enable_output(chip
);
645 static void xonar_st_resume(struct oxygen
*chip
)
648 xonar_enable_output(chip
);
651 static void xonar_hdav_pcm_hardware_filter(unsigned int channel
,
652 struct snd_pcm_hardware
*hardware
)
654 if (channel
== PCM_MULTICH
) {
655 hardware
->rates
= SNDRV_PCM_RATE_44100
|
656 SNDRV_PCM_RATE_48000
|
657 SNDRV_PCM_RATE_96000
|
658 SNDRV_PCM_RATE_192000
;
659 hardware
->rate_min
= 44100;
663 static void set_pcm1796_params(struct oxygen
*chip
,
664 struct snd_pcm_hw_params
*params
)
666 struct xonar_data
*data
= chip
->model_data
;
669 data
->pcm1796_oversampling
=
670 params_rate(params
) >= 96000 ? PCM1796_OS_32
: PCM1796_OS_64
;
671 for (i
= 0; i
< data
->dacs
; ++i
)
672 pcm1796_write(chip
, i
, 20, data
->pcm1796_oversampling
);
675 static void set_cs53x1_params(struct oxygen
*chip
,
676 struct snd_pcm_hw_params
*params
)
680 if (params_rate(params
) <= 54000)
681 value
= GPIO_CS53x1_M_SINGLE
;
682 else if (params_rate(params
) <= 108000)
683 value
= GPIO_CS53x1_M_DOUBLE
;
685 value
= GPIO_CS53x1_M_QUAD
;
686 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
687 value
, GPIO_CS53x1_M_MASK
);
690 static void set_cs43xx_params(struct oxygen
*chip
,
691 struct snd_pcm_hw_params
*params
)
693 struct xonar_data
*data
= chip
->model_data
;
695 data
->cs4398_fm
= CS4398_DEM_NONE
| CS4398_DIF_LJUST
;
696 data
->cs4362a_fm
= CS4362A_ATAPI_B_R
| CS4362A_ATAPI_A_L
;
697 if (params_rate(params
) <= 50000) {
698 data
->cs4398_fm
|= CS4398_FM_SINGLE
;
699 data
->cs4362a_fm
|= CS4362A_FM_SINGLE
;
700 } else if (params_rate(params
) <= 100000) {
701 data
->cs4398_fm
|= CS4398_FM_DOUBLE
;
702 data
->cs4362a_fm
|= CS4362A_FM_DOUBLE
;
704 data
->cs4398_fm
|= CS4398_FM_QUAD
;
705 data
->cs4362a_fm
|= CS4362A_FM_QUAD
;
707 cs4398_write(chip
, 2, data
->cs4398_fm
);
708 cs4362a_write(chip
, 0x06, data
->cs4362a_fm
);
709 cs4362a_write(chip
, 0x09, data
->cs4362a_fm
);
710 cs4362a_write(chip
, 0x0c, data
->cs4362a_fm
);
713 static void set_hdmi_params(struct oxygen
*chip
,
714 struct snd_pcm_hw_params
*params
)
716 struct xonar_data
*data
= chip
->model_data
;
718 data
->hdmi_params
[0] = 0; /* 1 = non-audio */
719 switch (params_rate(params
)) {
721 data
->hdmi_params
[1] = IEC958_AES3_CON_FS_44100
;
724 data
->hdmi_params
[1] = IEC958_AES3_CON_FS_48000
;
727 data
->hdmi_params
[1] = IEC958_AES3_CON_FS_96000
;
730 data
->hdmi_params
[1] = IEC958_AES3_CON_FS_192000
;
733 data
->hdmi_params
[2] = params_channels(params
) / 2 - 1;
734 if (params_format(params
) == SNDRV_PCM_FORMAT_S16_LE
)
735 data
->hdmi_params
[3] = 0;
737 data
->hdmi_params
[3] = 0xc0;
738 data
->hdmi_params
[4] = 1; /* ? */
739 hdmi_write_command(chip
, 0x54, 5, data
->hdmi_params
);
742 static void set_hdav_params(struct oxygen
*chip
,
743 struct snd_pcm_hw_params
*params
)
745 set_pcm1796_params(chip
, params
);
746 set_hdmi_params(chip
, params
);
749 static void xonar_gpio_changed(struct oxygen
*chip
)
751 struct xonar_data
*data
= chip
->model_data
;
754 has_power
= !!(oxygen_read8(chip
, data
->ext_power_reg
)
755 & data
->ext_power_bit
);
756 if (has_power
!= data
->has_power
) {
757 data
->has_power
= has_power
;
759 snd_printk(KERN_NOTICE
"power restored\n");
762 "Hey! Don't unplug the power cable!\n");
763 /* TODO: stop PCMs */
768 static void xonar_hdav_uart_input(struct oxygen
*chip
)
770 if (chip
->uart_input_count
>= 2 &&
771 chip
->uart_input
[chip
->uart_input_count
- 2] == 'O' &&
772 chip
->uart_input
[chip
->uart_input_count
- 1] == 'K') {
773 printk(KERN_DEBUG
"message from Xonar HDAV HDMI chip received:\n");
774 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET
,
775 chip
->uart_input
, chip
->uart_input_count
);
776 chip
->uart_input_count
= 0;
780 static int gpio_bit_switch_get(struct snd_kcontrol
*ctl
,
781 struct snd_ctl_elem_value
*value
)
783 struct oxygen
*chip
= ctl
->private_data
;
784 u16 bit
= ctl
->private_value
;
786 value
->value
.integer
.value
[0] =
787 !!(oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & bit
);
791 static int gpio_bit_switch_put(struct snd_kcontrol
*ctl
,
792 struct snd_ctl_elem_value
*value
)
794 struct oxygen
*chip
= ctl
->private_data
;
795 u16 bit
= ctl
->private_value
;
796 u16 old_bits
, new_bits
;
799 spin_lock_irq(&chip
->reg_lock
);
800 old_bits
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
801 if (value
->value
.integer
.value
[0])
802 new_bits
= old_bits
| bit
;
804 new_bits
= old_bits
& ~bit
;
805 changed
= new_bits
!= old_bits
;
807 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, new_bits
);
808 spin_unlock_irq(&chip
->reg_lock
);
812 static const struct snd_kcontrol_new alt_switch
= {
813 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
814 .name
= "Analog Loopback Switch",
815 .info
= snd_ctl_boolean_mono_info
,
816 .get
= gpio_bit_switch_get
,
817 .put
= gpio_bit_switch_put
,
818 .private_value
= GPIO_D2_ALT
,
821 static const struct snd_kcontrol_new front_panel_switch
= {
822 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
823 .name
= "Front Panel Switch",
824 .info
= snd_ctl_boolean_mono_info
,
825 .get
= gpio_bit_switch_get
,
826 .put
= gpio_bit_switch_put
,
827 .private_value
= GPIO_DX_FRONT_PANEL
,
830 static int st_output_switch_info(struct snd_kcontrol
*ctl
,
831 struct snd_ctl_elem_info
*info
)
833 static const char *const names
[3] = {
834 "Speakers", "Headphones", "FP Headphones"
837 info
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
839 info
->value
.enumerated
.items
= 3;
840 if (info
->value
.enumerated
.item
>= 3)
841 info
->value
.enumerated
.item
= 2;
842 strcpy(info
->value
.enumerated
.name
, names
[info
->value
.enumerated
.item
]);
846 static int st_output_switch_get(struct snd_kcontrol
*ctl
,
847 struct snd_ctl_elem_value
*value
)
849 struct oxygen
*chip
= ctl
->private_data
;
852 gpio
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
853 if (!(gpio
& GPIO_ST_HP
))
854 value
->value
.enumerated
.item
[0] = 0;
855 else if (gpio
& GPIO_ST_HP_REAR
)
856 value
->value
.enumerated
.item
[0] = 1;
858 value
->value
.enumerated
.item
[0] = 2;
863 static int st_output_switch_put(struct snd_kcontrol
*ctl
,
864 struct snd_ctl_elem_value
*value
)
866 struct oxygen
*chip
= ctl
->private_data
;
869 mutex_lock(&chip
->mutex
);
870 gpio_old
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
872 switch (value
->value
.enumerated
.item
[0]) {
874 gpio
&= ~(GPIO_ST_HP
| GPIO_ST_HP_REAR
);
877 gpio
|= GPIO_ST_HP
| GPIO_ST_HP_REAR
;
880 gpio
= (gpio
| GPIO_ST_HP
) & ~GPIO_ST_HP_REAR
;
883 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, gpio
);
884 mutex_unlock(&chip
->mutex
);
885 return gpio
!= gpio_old
;
888 static const struct snd_kcontrol_new st_output_switch
= {
889 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
890 .name
= "Analog Output",
891 .info
= st_output_switch_info
,
892 .get
= st_output_switch_get
,
893 .put
= st_output_switch_put
,
896 static void xonar_line_mic_ac97_switch(struct oxygen
*chip
,
897 unsigned int reg
, unsigned int mute
)
899 if (reg
== AC97_LINE
) {
900 spin_lock_irq(&chip
->reg_lock
);
901 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
902 mute
? GPIO_DX_INPUT_ROUTE
: 0,
903 GPIO_DX_INPUT_ROUTE
);
904 spin_unlock_irq(&chip
->reg_lock
);
908 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale
, -6000, 50, 0);
909 static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale
, -6000, 100, 0);
911 static int xonar_d2_control_filter(struct snd_kcontrol_new
*template)
913 if (!strncmp(template->name
, "CD Capture ", 11))
914 /* CD in is actually connected to the video in pin */
915 template->private_value
^= AC97_CD
^ AC97_VIDEO
;
919 static int xonar_d1_control_filter(struct snd_kcontrol_new
*template)
921 if (!strncmp(template->name
, "CD Capture ", 11))
922 return 1; /* no CD input */
926 static int xonar_st_control_filter(struct snd_kcontrol_new
*template)
928 if (!strncmp(template->name
, "CD Capture ", 11))
929 return 1; /* no CD input */
930 if (!strcmp(template->name
, "Stereo Upmixing"))
931 return 1; /* stereo only - we don't need upmixing */
935 static int xonar_d2_mixer_init(struct oxygen
*chip
)
937 return snd_ctl_add(chip
->card
, snd_ctl_new1(&alt_switch
, chip
));
940 static int xonar_d1_mixer_init(struct oxygen
*chip
)
942 return snd_ctl_add(chip
->card
, snd_ctl_new1(&front_panel_switch
, chip
));
945 static int xonar_st_mixer_init(struct oxygen
*chip
)
947 return snd_ctl_add(chip
->card
, snd_ctl_new1(&st_output_switch
, chip
));
950 static const struct oxygen_model model_xonar_d2
= {
951 .longname
= "Asus Virtuoso 200",
953 .init
= xonar_d2_init
,
954 .control_filter
= xonar_d2_control_filter
,
955 .mixer_init
= xonar_d2_mixer_init
,
956 .cleanup
= xonar_d2_cleanup
,
957 .suspend
= xonar_d2_suspend
,
958 .resume
= xonar_d2_resume
,
959 .set_dac_params
= set_pcm1796_params
,
960 .set_adc_params
= set_cs53x1_params
,
961 .update_dac_volume
= update_pcm1796_volume
,
962 .update_dac_mute
= update_pcm1796_mute
,
963 .dac_tlv
= pcm1796_db_scale
,
964 .model_data_size
= sizeof(struct xonar_data
),
965 .device_config
= PLAYBACK_0_TO_I2S
|
966 PLAYBACK_1_TO_SPDIF
|
967 CAPTURE_0_FROM_I2S_2
|
968 CAPTURE_1_FROM_SPDIF
|
972 .dac_volume_min
= 255 - 2*60,
973 .dac_volume_max
= 255,
974 .misc_flags
= OXYGEN_MISC_MIDI
,
975 .function_flags
= OXYGEN_FUNCTION_SPI
|
976 OXYGEN_FUNCTION_ENABLE_SPI_4_5
,
977 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
978 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
981 static const struct oxygen_model model_xonar_d1
= {
982 .longname
= "Asus Virtuoso 100",
984 .init
= xonar_d1_init
,
985 .control_filter
= xonar_d1_control_filter
,
986 .mixer_init
= xonar_d1_mixer_init
,
987 .cleanup
= xonar_d1_cleanup
,
988 .suspend
= xonar_d1_suspend
,
989 .resume
= xonar_d1_resume
,
990 .set_dac_params
= set_cs43xx_params
,
991 .set_adc_params
= set_cs53x1_params
,
992 .update_dac_volume
= update_cs43xx_volume
,
993 .update_dac_mute
= update_cs43xx_mute
,
994 .ac97_switch
= xonar_line_mic_ac97_switch
,
995 .dac_tlv
= cs4362a_db_scale
,
996 .model_data_size
= sizeof(struct xonar_data
),
997 .device_config
= PLAYBACK_0_TO_I2S
|
998 PLAYBACK_1_TO_SPDIF
|
999 CAPTURE_0_FROM_I2S_2
,
1001 .dac_volume_min
= 127 - 60,
1002 .dac_volume_max
= 127,
1003 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
1004 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1005 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1008 static const struct oxygen_model model_xonar_hdav
= {
1009 .longname
= "Asus Virtuoso 200",
1011 .init
= xonar_hdav_init
,
1012 .cleanup
= xonar_hdav_cleanup
,
1013 .suspend
= xonar_hdav_suspend
,
1014 .resume
= xonar_hdav_resume
,
1015 .pcm_hardware_filter
= xonar_hdav_pcm_hardware_filter
,
1016 .set_dac_params
= set_hdav_params
,
1017 .set_adc_params
= set_cs53x1_params
,
1018 .update_dac_volume
= update_pcm1796_volume
,
1019 .update_dac_mute
= update_pcm1796_mute
,
1020 .uart_input
= xonar_hdav_uart_input
,
1021 .ac97_switch
= xonar_line_mic_ac97_switch
,
1022 .dac_tlv
= pcm1796_db_scale
,
1023 .model_data_size
= sizeof(struct xonar_data
),
1024 .device_config
= PLAYBACK_0_TO_I2S
|
1025 PLAYBACK_1_TO_SPDIF
|
1026 CAPTURE_0_FROM_I2S_2
,
1028 .dac_volume_min
= 255 - 2*60,
1029 .dac_volume_max
= 255,
1030 .misc_flags
= OXYGEN_MISC_MIDI
,
1031 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
1032 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1033 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1036 static const struct oxygen_model model_xonar_st
= {
1037 .longname
= "Asus Virtuoso 100",
1039 .init
= xonar_stx_init
,
1040 .control_filter
= xonar_st_control_filter
,
1041 .mixer_init
= xonar_st_mixer_init
,
1042 .cleanup
= xonar_st_cleanup
,
1043 .suspend
= xonar_st_suspend
,
1044 .resume
= xonar_st_resume
,
1045 .set_dac_params
= set_pcm1796_params
,
1046 .set_adc_params
= set_cs53x1_params
,
1047 .update_dac_volume
= update_pcm1796_volume
,
1048 .update_dac_mute
= update_pcm1796_mute
,
1049 .ac97_switch
= xonar_line_mic_ac97_switch
,
1050 .dac_tlv
= pcm1796_db_scale
,
1051 .model_data_size
= sizeof(struct xonar_data
),
1052 .device_config
= PLAYBACK_0_TO_I2S
|
1053 PLAYBACK_1_TO_SPDIF
|
1054 CAPTURE_0_FROM_I2S_2
,
1056 .dac_volume_min
= 255 - 2*60,
1057 .dac_volume_max
= 255,
1058 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
1059 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1060 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
1063 static int __devinit
get_xonar_model(struct oxygen
*chip
,
1064 const struct pci_device_id
*id
)
1066 static const struct oxygen_model
*const models
[] = {
1067 [MODEL_D1
] = &model_xonar_d1
,
1068 [MODEL_DX
] = &model_xonar_d1
,
1069 [MODEL_D2
] = &model_xonar_d2
,
1070 [MODEL_D2X
] = &model_xonar_d2
,
1071 [MODEL_HDAV
] = &model_xonar_hdav
,
1072 [MODEL_STX
] = &model_xonar_st
,
1074 static const char *const names
[] = {
1075 [MODEL_D1
] = "Xonar D1",
1076 [MODEL_DX
] = "Xonar DX",
1077 [MODEL_D2
] = "Xonar D2",
1078 [MODEL_D2X
] = "Xonar D2X",
1079 [MODEL_HDAV
] = "Xonar HDAV1.3",
1080 [MODEL_HDAV_H6
] = "Xonar HDAV1.3+H6",
1081 [MODEL_STX
] = "Xonar Essence STX",
1083 unsigned int model
= id
->driver_data
;
1085 if (model
>= ARRAY_SIZE(models
) || !models
[model
])
1087 chip
->model
= *models
[model
];
1091 chip
->model
.init
= xonar_d2x_init
;
1094 chip
->model
.init
= xonar_dx_init
;
1097 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
,
1099 switch (oxygen_read16(chip
, OXYGEN_GPIO_DATA
) &
1100 GPIO_HDAV_DB_MASK
) {
1101 case GPIO_HDAV_DB_H6
:
1102 model
= MODEL_HDAV_H6
;
1104 case GPIO_HDAV_DB_XX
:
1105 snd_printk(KERN_ERR
"unknown daughterboard\n");
1110 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
,
1115 chip
->model
.shortname
= names
[model
];
1116 chip
->model
.private_data
= model
;
1120 static int __devinit
xonar_probe(struct pci_dev
*pci
,
1121 const struct pci_device_id
*pci_id
)
1126 if (dev
>= SNDRV_CARDS
)
1132 err
= oxygen_pci_probe(pci
, index
[dev
], id
[dev
], THIS_MODULE
,
1133 xonar_ids
, get_xonar_model
);
1139 static struct pci_driver xonar_driver
= {
1141 .id_table
= xonar_ids
,
1142 .probe
= xonar_probe
,
1143 .remove
= __devexit_p(oxygen_pci_remove
),
1145 .suspend
= oxygen_pci_suspend
,
1146 .resume
= oxygen_pci_resume
,
1150 static int __init
alsa_card_xonar_init(void)
1152 return pci_register_driver(&xonar_driver
);
1155 static void __exit
alsa_card_xonar_exit(void)
1157 pci_unregister_driver(&xonar_driver
);
1160 module_init(alsa_card_xonar_init
)
1161 module_exit(alsa_card_xonar_exit
)