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
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)
65 #include <linux/pci.h>
66 #include <linux/delay.h>
67 #include <linux/mutex.h>
68 #include <sound/ac97_codec.h>
69 #include <sound/control.h>
70 #include <sound/core.h>
71 #include <sound/initval.h>
72 #include <sound/pcm.h>
73 #include <sound/tlv.h>
80 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
81 MODULE_DESCRIPTION("Asus AVx00 driver");
82 MODULE_LICENSE("GPL v2");
83 MODULE_SUPPORTED_DEVICE("{{Asus,AV100},{Asus,AV200}}");
85 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
86 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
87 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
89 module_param_array(index
, int, NULL
, 0444);
90 MODULE_PARM_DESC(index
, "card index");
91 module_param_array(id
, charp
, NULL
, 0444);
92 MODULE_PARM_DESC(id
, "ID string");
93 module_param_array(enable
, bool, NULL
, 0444);
94 MODULE_PARM_DESC(enable
, "enable card");
102 static struct pci_device_id xonar_ids
[] __devinitdata
= {
103 { OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data
= MODEL_D2
},
104 { OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data
= MODEL_DX
},
105 { OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data
= MODEL_D2X
},
108 MODULE_DEVICE_TABLE(pci
, xonar_ids
);
111 #define GPIO_CS53x1_M_MASK 0x000c
112 #define GPIO_CS53x1_M_SINGLE 0x0000
113 #define GPIO_CS53x1_M_DOUBLE 0x0004
114 #define GPIO_CS53x1_M_QUAD 0x0008
116 #define GPIO_D2X_EXT_POWER 0x0020
117 #define GPIO_D2_ALT 0x0080
118 #define GPIO_D2_OUTPUT_ENABLE 0x0100
120 #define GPI_DX_EXT_POWER 0x01
121 #define GPIO_DX_OUTPUT_ENABLE 0x0001
122 #define GPIO_DX_FRONT_PANEL 0x0002
123 #define GPIO_DX_INPUT_ROUTE 0x0100
125 #define I2C_DEVICE_CS4398 0x9e /* 10011, AD1=1, AD0=1, /W=0 */
126 #define I2C_DEVICE_CS4362A 0x30 /* 001100, AD0=0, /W=0 */
129 unsigned int anti_pop_delay
;
130 u16 output_enable_bit
;
132 u8 ext_power_int_reg
;
135 u8 pcm1796_oversampling
;
140 static void pcm1796_write(struct oxygen
*chip
, unsigned int codec
,
143 /* maps ALSA channel pair number to SPI output */
144 static const u8 codec_map
[4] = {
147 oxygen_write_spi(chip
, OXYGEN_SPI_TRIGGER
|
148 OXYGEN_SPI_DATA_LENGTH_2
|
149 OXYGEN_SPI_CLOCK_160
|
150 (codec_map
[codec
] << OXYGEN_SPI_CODEC_SHIFT
) |
151 OXYGEN_SPI_CEN_LATCH_CLOCK_HI
,
155 static void cs4398_write(struct oxygen
*chip
, u8 reg
, u8 value
)
157 oxygen_write_i2c(chip
, I2C_DEVICE_CS4398
, reg
, value
);
160 static void cs4362a_write(struct oxygen
*chip
, u8 reg
, u8 value
)
162 oxygen_write_i2c(chip
, I2C_DEVICE_CS4362A
, reg
, value
);
165 static void xonar_enable_output(struct oxygen
*chip
)
167 struct xonar_data
*data
= chip
->model_data
;
169 msleep(data
->anti_pop_delay
);
170 oxygen_set_bits16(chip
, OXYGEN_GPIO_DATA
, data
->output_enable_bit
);
173 static void xonar_common_init(struct oxygen
*chip
)
175 struct xonar_data
*data
= chip
->model_data
;
177 if (data
->ext_power_reg
) {
178 oxygen_set_bits8(chip
, data
->ext_power_int_reg
,
179 data
->ext_power_bit
);
180 chip
->interrupt_mask
|= OXYGEN_INT_GPIO
;
181 data
->has_power
= !!(oxygen_read8(chip
, data
->ext_power_reg
)
182 & data
->ext_power_bit
);
184 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
185 GPIO_CS53x1_M_MASK
| data
->output_enable_bit
);
186 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
187 GPIO_CS53x1_M_SINGLE
, GPIO_CS53x1_M_MASK
);
188 oxygen_ac97_set_bits(chip
, 0, CM9780_JACK
, CM9780_FMIC2MIC
);
189 xonar_enable_output(chip
);
192 static void update_pcm1796_volume(struct oxygen
*chip
)
196 for (i
= 0; i
< 4; ++i
) {
197 pcm1796_write(chip
, i
, 16, chip
->dac_volume
[i
* 2]);
198 pcm1796_write(chip
, i
, 17, chip
->dac_volume
[i
* 2 + 1]);
202 static void update_pcm1796_mute(struct oxygen
*chip
)
207 value
= PCM1796_DMF_DISABLED
| PCM1796_FMT_24_LJUST
| PCM1796_ATLD
;
209 value
|= PCM1796_MUTE
;
210 for (i
= 0; i
< 4; ++i
)
211 pcm1796_write(chip
, i
, 18, value
);
214 static void pcm1796_init(struct oxygen
*chip
)
216 struct xonar_data
*data
= chip
->model_data
;
219 for (i
= 0; i
< 4; ++i
) {
220 pcm1796_write(chip
, i
, 19, PCM1796_FLT_SHARP
| PCM1796_ATS_1
);
221 pcm1796_write(chip
, i
, 20, data
->pcm1796_oversampling
);
222 pcm1796_write(chip
, i
, 21, 0);
224 update_pcm1796_mute(chip
); /* set ATLD before ATL/ATR */
225 update_pcm1796_volume(chip
);
228 static void xonar_d2_init(struct oxygen
*chip
)
230 struct xonar_data
*data
= chip
->model_data
;
232 data
->anti_pop_delay
= 300;
233 data
->output_enable_bit
= GPIO_D2_OUTPUT_ENABLE
;
234 data
->pcm1796_oversampling
= PCM1796_OS_64
;
238 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2_ALT
);
239 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_D2_ALT
);
241 xonar_common_init(chip
);
243 snd_component_add(chip
->card
, "PCM1796");
244 snd_component_add(chip
->card
, "CS5381");
247 static void xonar_d2x_init(struct oxygen
*chip
)
249 struct xonar_data
*data
= chip
->model_data
;
251 data
->ext_power_reg
= OXYGEN_GPIO_DATA
;
252 data
->ext_power_int_reg
= OXYGEN_GPIO_INTERRUPT_MASK
;
253 data
->ext_power_bit
= GPIO_D2X_EXT_POWER
;
254 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2X_EXT_POWER
);
258 static void update_cs4362a_volumes(struct oxygen
*chip
)
262 mute
= chip
->dac_mute
? CS4362A_MUTE
: 0;
263 cs4362a_write(chip
, 7, (127 - chip
->dac_volume
[2]) | mute
);
264 cs4362a_write(chip
, 8, (127 - chip
->dac_volume
[3]) | mute
);
265 cs4362a_write(chip
, 10, (127 - chip
->dac_volume
[4]) | mute
);
266 cs4362a_write(chip
, 11, (127 - chip
->dac_volume
[5]) | mute
);
267 cs4362a_write(chip
, 13, (127 - chip
->dac_volume
[6]) | mute
);
268 cs4362a_write(chip
, 14, (127 - chip
->dac_volume
[7]) | mute
);
271 static void update_cs43xx_volume(struct oxygen
*chip
)
273 cs4398_write(chip
, 5, (127 - chip
->dac_volume
[0]) * 2);
274 cs4398_write(chip
, 6, (127 - chip
->dac_volume
[1]) * 2);
275 update_cs4362a_volumes(chip
);
278 static void update_cs43xx_mute(struct oxygen
*chip
)
282 reg
= CS4398_MUTEP_LOW
| CS4398_PAMUTE
;
284 reg
|= CS4398_MUTE_B
| CS4398_MUTE_A
;
285 cs4398_write(chip
, 4, reg
);
286 update_cs4362a_volumes(chip
);
289 static void cs43xx_init(struct oxygen
*chip
)
291 struct xonar_data
*data
= chip
->model_data
;
293 /* set CPEN (control port mode) and power down */
294 cs4398_write(chip
, 8, CS4398_CPEN
| CS4398_PDN
);
295 cs4362a_write(chip
, 0x01, CS4362A_PDN
| CS4362A_CPEN
);
297 cs4398_write(chip
, 2, data
->cs4398_fm
);
298 cs4398_write(chip
, 3, CS4398_ATAPI_B_R
| CS4398_ATAPI_A_L
);
299 cs4398_write(chip
, 7, CS4398_RMP_DN
| CS4398_RMP_UP
|
300 CS4398_ZERO_CROSS
| CS4398_SOFT_RAMP
);
301 cs4362a_write(chip
, 0x02, CS4362A_DIF_LJUST
);
302 cs4362a_write(chip
, 0x03, CS4362A_MUTEC_6
| CS4362A_AMUTE
|
303 CS4362A_RMP_UP
| CS4362A_ZERO_CROSS
| CS4362A_SOFT_RAMP
);
304 cs4362a_write(chip
, 0x04, CS4362A_RMP_DN
| CS4362A_DEM_NONE
);
305 cs4362a_write(chip
, 0x05, 0);
306 cs4362a_write(chip
, 0x06, data
->cs4362a_fm
);
307 cs4362a_write(chip
, 0x09, data
->cs4362a_fm
);
308 cs4362a_write(chip
, 0x0c, data
->cs4362a_fm
);
309 update_cs43xx_volume(chip
);
310 update_cs43xx_mute(chip
);
311 /* clear power down */
312 cs4398_write(chip
, 8, CS4398_CPEN
);
313 cs4362a_write(chip
, 0x01, CS4362A_CPEN
);
316 static void xonar_dx_init(struct oxygen
*chip
)
318 struct xonar_data
*data
= chip
->model_data
;
320 data
->anti_pop_delay
= 800;
321 data
->output_enable_bit
= GPIO_DX_OUTPUT_ENABLE
;
322 data
->ext_power_reg
= OXYGEN_GPI_DATA
;
323 data
->ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
324 data
->ext_power_bit
= GPI_DX_EXT_POWER
;
325 data
->cs4398_fm
= CS4398_FM_SINGLE
| CS4398_DEM_NONE
| CS4398_DIF_LJUST
;
326 data
->cs4362a_fm
= CS4362A_FM_SINGLE
|
327 CS4362A_ATAPI_B_R
| CS4362A_ATAPI_A_L
;
329 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
330 OXYGEN_2WIRE_LENGTH_8
|
331 OXYGEN_2WIRE_INTERRUPT_MASK
|
332 OXYGEN_2WIRE_SPEED_FAST
);
336 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
337 GPIO_DX_FRONT_PANEL
| GPIO_DX_INPUT_ROUTE
);
338 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
,
339 GPIO_DX_FRONT_PANEL
| GPIO_DX_INPUT_ROUTE
);
341 xonar_common_init(chip
);
343 snd_component_add(chip
->card
, "CS4398");
344 snd_component_add(chip
->card
, "CS4362A");
345 snd_component_add(chip
->card
, "CS5361");
348 static void xonar_cleanup(struct oxygen
*chip
)
350 struct xonar_data
*data
= chip
->model_data
;
352 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, data
->output_enable_bit
);
355 static void xonar_dx_cleanup(struct oxygen
*chip
)
358 cs4362a_write(chip
, 0x01, CS4362A_PDN
| CS4362A_CPEN
);
359 oxygen_clear_bits8(chip
, OXYGEN_FUNCTION
, OXYGEN_FUNCTION_RESET_CODEC
);
362 static void xonar_d2_resume(struct oxygen
*chip
)
365 xonar_enable_output(chip
);
368 static void xonar_dx_resume(struct oxygen
*chip
)
371 xonar_enable_output(chip
);
374 static void set_pcm1796_params(struct oxygen
*chip
,
375 struct snd_pcm_hw_params
*params
)
377 struct xonar_data
*data
= chip
->model_data
;
380 data
->pcm1796_oversampling
=
381 params_rate(params
) >= 96000 ? PCM1796_OS_32
: PCM1796_OS_64
;
382 for (i
= 0; i
< 4; ++i
)
383 pcm1796_write(chip
, i
, 20, data
->pcm1796_oversampling
);
386 static void set_cs53x1_params(struct oxygen
*chip
,
387 struct snd_pcm_hw_params
*params
)
391 if (params_rate(params
) <= 54000)
392 value
= GPIO_CS53x1_M_SINGLE
;
393 else if (params_rate(params
) <= 108000)
394 value
= GPIO_CS53x1_M_DOUBLE
;
396 value
= GPIO_CS53x1_M_QUAD
;
397 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
398 value
, GPIO_CS53x1_M_MASK
);
401 static void set_cs43xx_params(struct oxygen
*chip
,
402 struct snd_pcm_hw_params
*params
)
404 struct xonar_data
*data
= chip
->model_data
;
406 data
->cs4398_fm
= CS4398_DEM_NONE
| CS4398_DIF_LJUST
;
407 data
->cs4362a_fm
= CS4362A_ATAPI_B_R
| CS4362A_ATAPI_A_L
;
408 if (params_rate(params
) <= 50000) {
409 data
->cs4398_fm
|= CS4398_FM_SINGLE
;
410 data
->cs4362a_fm
|= CS4362A_FM_SINGLE
;
411 } else if (params_rate(params
) <= 100000) {
412 data
->cs4398_fm
|= CS4398_FM_DOUBLE
;
413 data
->cs4362a_fm
|= CS4362A_FM_DOUBLE
;
415 data
->cs4398_fm
|= CS4398_FM_QUAD
;
416 data
->cs4362a_fm
|= CS4362A_FM_QUAD
;
418 cs4398_write(chip
, 2, data
->cs4398_fm
);
419 cs4362a_write(chip
, 0x06, data
->cs4362a_fm
);
420 cs4362a_write(chip
, 0x09, data
->cs4362a_fm
);
421 cs4362a_write(chip
, 0x0c, data
->cs4362a_fm
);
424 static void xonar_gpio_changed(struct oxygen
*chip
)
426 struct xonar_data
*data
= chip
->model_data
;
429 has_power
= !!(oxygen_read8(chip
, data
->ext_power_reg
)
430 & data
->ext_power_bit
);
431 if (has_power
!= data
->has_power
) {
432 data
->has_power
= has_power
;
434 snd_printk(KERN_NOTICE
"power restored\n");
437 "Hey! Don't unplug the power cable!\n");
438 /* TODO: stop PCMs */
443 static int alt_switch_get(struct snd_kcontrol
*ctl
,
444 struct snd_ctl_elem_value
*value
)
446 struct oxygen
*chip
= ctl
->private_data
;
448 value
->value
.integer
.value
[0] =
449 !!(oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & GPIO_D2_ALT
);
453 static int alt_switch_put(struct snd_kcontrol
*ctl
,
454 struct snd_ctl_elem_value
*value
)
456 struct oxygen
*chip
= ctl
->private_data
;
457 u16 old_bits
, new_bits
;
460 spin_lock_irq(&chip
->reg_lock
);
461 old_bits
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
462 if (value
->value
.integer
.value
[0])
463 new_bits
= old_bits
| GPIO_D2_ALT
;
465 new_bits
= old_bits
& ~GPIO_D2_ALT
;
466 changed
= new_bits
!= old_bits
;
468 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, new_bits
);
469 spin_unlock_irq(&chip
->reg_lock
);
473 static const struct snd_kcontrol_new alt_switch
= {
474 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
475 .name
= "Analog Loopback Switch",
476 .info
= snd_ctl_boolean_mono_info
,
477 .get
= alt_switch_get
,
478 .put
= alt_switch_put
,
481 static int front_panel_get(struct snd_kcontrol
*ctl
,
482 struct snd_ctl_elem_value
*value
)
484 struct oxygen
*chip
= ctl
->private_data
;
486 value
->value
.integer
.value
[0] =
487 !!(oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & GPIO_DX_FRONT_PANEL
);
491 static int front_panel_put(struct snd_kcontrol
*ctl
,
492 struct snd_ctl_elem_value
*value
)
494 struct oxygen
*chip
= ctl
->private_data
;
495 u16 old_reg
, new_reg
;
497 spin_lock_irq(&chip
->reg_lock
);
498 old_reg
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
499 if (value
->value
.integer
.value
[0])
500 new_reg
= old_reg
| GPIO_DX_FRONT_PANEL
;
502 new_reg
= old_reg
& ~GPIO_DX_FRONT_PANEL
;
503 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, new_reg
);
504 spin_unlock_irq(&chip
->reg_lock
);
505 return old_reg
!= new_reg
;
508 static const struct snd_kcontrol_new front_panel_switch
= {
509 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
510 .name
= "Front Panel Switch",
511 .info
= snd_ctl_boolean_mono_info
,
512 .get
= front_panel_get
,
513 .put
= front_panel_put
,
516 static void xonar_dx_ac97_switch(struct oxygen
*chip
,
517 unsigned int reg
, unsigned int mute
)
519 if (reg
== AC97_LINE
) {
520 spin_lock_irq(&chip
->reg_lock
);
521 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
522 mute
? GPIO_DX_INPUT_ROUTE
: 0,
523 GPIO_DX_INPUT_ROUTE
);
524 spin_unlock_irq(&chip
->reg_lock
);
528 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale
, -12000, 50, 0);
529 static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale
, -12700, 100, 0);
531 static int xonar_d2_control_filter(struct snd_kcontrol_new
*template)
533 if (!strncmp(template->name
, "CD Capture ", 11))
534 /* CD in is actually connected to the video in pin */
535 template->private_value
^= AC97_CD
^ AC97_VIDEO
;
539 static int xonar_dx_control_filter(struct snd_kcontrol_new
*template)
541 if (!strncmp(template->name
, "CD Capture ", 11))
542 return 1; /* no CD input */
546 static int xonar_mixer_init(struct oxygen
*chip
)
548 return snd_ctl_add(chip
->card
, snd_ctl_new1(&alt_switch
, chip
));
551 static int xonar_dx_mixer_init(struct oxygen
*chip
)
553 return snd_ctl_add(chip
->card
, snd_ctl_new1(&front_panel_switch
, chip
));
556 static const struct oxygen_model xonar_models
[] = {
558 .shortname
= "Xonar D2",
559 .longname
= "Asus Virtuoso 200",
561 .owner
= THIS_MODULE
,
562 .init
= xonar_d2_init
,
563 .control_filter
= xonar_d2_control_filter
,
564 .mixer_init
= xonar_mixer_init
,
565 .cleanup
= xonar_cleanup
,
566 .suspend
= xonar_cleanup
,
567 .resume
= xonar_d2_resume
,
568 .set_dac_params
= set_pcm1796_params
,
569 .set_adc_params
= set_cs53x1_params
,
570 .update_dac_volume
= update_pcm1796_volume
,
571 .update_dac_mute
= update_pcm1796_mute
,
572 .dac_tlv
= pcm1796_db_scale
,
573 .model_data_size
= sizeof(struct xonar_data
),
574 .pcm_dev_cfg
= PLAYBACK_0_TO_I2S
|
575 PLAYBACK_1_TO_SPDIF
|
576 CAPTURE_0_FROM_I2S_2
|
577 CAPTURE_1_FROM_SPDIF
,
579 .dac_volume_min
= 0x0f,
580 .dac_volume_max
= 0xff,
581 .misc_flags
= OXYGEN_MISC_MIDI
,
582 .function_flags
= OXYGEN_FUNCTION_SPI
|
583 OXYGEN_FUNCTION_ENABLE_SPI_4_5
,
584 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
585 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
588 .shortname
= "Xonar D2X",
589 .longname
= "Asus Virtuoso 200",
591 .owner
= THIS_MODULE
,
592 .init
= xonar_d2x_init
,
593 .control_filter
= xonar_d2_control_filter
,
594 .mixer_init
= xonar_mixer_init
,
595 .cleanup
= xonar_cleanup
,
596 .suspend
= xonar_cleanup
,
597 .resume
= xonar_d2_resume
,
598 .set_dac_params
= set_pcm1796_params
,
599 .set_adc_params
= set_cs53x1_params
,
600 .update_dac_volume
= update_pcm1796_volume
,
601 .update_dac_mute
= update_pcm1796_mute
,
602 .gpio_changed
= xonar_gpio_changed
,
603 .dac_tlv
= pcm1796_db_scale
,
604 .model_data_size
= sizeof(struct xonar_data
),
605 .pcm_dev_cfg
= PLAYBACK_0_TO_I2S
|
606 PLAYBACK_1_TO_SPDIF
|
607 CAPTURE_0_FROM_I2S_2
|
608 CAPTURE_1_FROM_SPDIF
,
610 .dac_volume_min
= 0x0f,
611 .dac_volume_max
= 0xff,
612 .misc_flags
= OXYGEN_MISC_MIDI
,
613 .function_flags
= OXYGEN_FUNCTION_SPI
|
614 OXYGEN_FUNCTION_ENABLE_SPI_4_5
,
615 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
616 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
619 .shortname
= "Xonar DX",
620 .longname
= "Asus Virtuoso 100",
622 .owner
= THIS_MODULE
,
623 .init
= xonar_dx_init
,
624 .control_filter
= xonar_dx_control_filter
,
625 .mixer_init
= xonar_dx_mixer_init
,
626 .cleanup
= xonar_dx_cleanup
,
627 .suspend
= xonar_dx_cleanup
,
628 .resume
= xonar_dx_resume
,
629 .set_dac_params
= set_cs43xx_params
,
630 .set_adc_params
= set_cs53x1_params
,
631 .update_dac_volume
= update_cs43xx_volume
,
632 .update_dac_mute
= update_cs43xx_mute
,
633 .gpio_changed
= xonar_gpio_changed
,
634 .ac97_switch
= xonar_dx_ac97_switch
,
635 .dac_tlv
= cs4362a_db_scale
,
636 .model_data_size
= sizeof(struct xonar_data
),
637 .pcm_dev_cfg
= PLAYBACK_0_TO_I2S
|
638 PLAYBACK_1_TO_SPDIF
|
639 CAPTURE_0_FROM_I2S_2
,
642 .dac_volume_max
= 127,
643 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
644 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
645 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
649 static int __devinit
xonar_probe(struct pci_dev
*pci
,
650 const struct pci_device_id
*pci_id
)
655 if (dev
>= SNDRV_CARDS
)
661 err
= oxygen_pci_probe(pci
, index
[dev
], id
[dev
],
662 &xonar_models
[pci_id
->driver_data
]);
668 static struct pci_driver xonar_driver
= {
670 .id_table
= xonar_ids
,
671 .probe
= xonar_probe
,
672 .remove
= __devexit_p(oxygen_pci_remove
),
674 .suspend
= oxygen_pci_suspend
,
675 .resume
= oxygen_pci_resume
,
679 static int __init
alsa_card_xonar_init(void)
681 return pci_register_driver(&xonar_driver
);
684 static void __exit
alsa_card_xonar_exit(void)
686 pci_unregister_driver(&xonar_driver
);
689 module_init(alsa_card_xonar_init
)
690 module_exit(alsa_card_xonar_exit
)