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)
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");
103 static struct pci_device_id xonar_ids
[] __devinitdata
= {
104 { OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data
= MODEL_D2
},
105 { OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data
= MODEL_DX
},
106 { OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data
= MODEL_D2X
},
107 { OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data
= MODEL_D1
},
110 MODULE_DEVICE_TABLE(pci
, xonar_ids
);
113 #define GPIO_CS53x1_M_MASK 0x000c
114 #define GPIO_CS53x1_M_SINGLE 0x0000
115 #define GPIO_CS53x1_M_DOUBLE 0x0004
116 #define GPIO_CS53x1_M_QUAD 0x0008
118 #define GPIO_D2X_EXT_POWER 0x0020
119 #define GPIO_D2_ALT 0x0080
120 #define GPIO_D2_OUTPUT_ENABLE 0x0100
122 #define GPI_DX_EXT_POWER 0x01
123 #define GPIO_DX_OUTPUT_ENABLE 0x0001
124 #define GPIO_DX_FRONT_PANEL 0x0002
125 #define GPIO_DX_INPUT_ROUTE 0x0100
127 #define I2C_DEVICE_PCM1796(i) (0x98 + ((i) << 1)) /* 10011, ADx=i, /W=0 */
128 #define I2C_DEVICE_CS4398 0x9e /* 10011, AD1=1, AD0=1, /W=0 */
129 #define I2C_DEVICE_CS4362A 0x30 /* 001100, AD0=0, /W=0 */
133 unsigned int anti_pop_delay
;
134 u16 output_enable_bit
;
136 u8 ext_power_int_reg
;
139 u8 pcm1796_oversampling
;
144 static void xonar_gpio_changed(struct oxygen
*chip
);
146 static inline void pcm1796_write_spi(struct oxygen
*chip
, unsigned int codec
,
149 /* maps ALSA channel pair number to SPI output */
150 static const u8 codec_map
[4] = {
153 oxygen_write_spi(chip
, OXYGEN_SPI_TRIGGER
|
154 OXYGEN_SPI_DATA_LENGTH_2
|
155 OXYGEN_SPI_CLOCK_160
|
156 (codec_map
[codec
] << OXYGEN_SPI_CODEC_SHIFT
) |
157 OXYGEN_SPI_CEN_LATCH_CLOCK_HI
,
161 static inline void pcm1796_write_i2c(struct oxygen
*chip
, unsigned int codec
,
164 oxygen_write_i2c(chip
, I2C_DEVICE_PCM1796(codec
), reg
, value
);
167 static void pcm1796_write(struct oxygen
*chip
, unsigned int codec
,
170 if ((chip
->model
.function_flags
& OXYGEN_FUNCTION_2WIRE_SPI_MASK
) ==
172 pcm1796_write_spi(chip
, codec
, reg
, value
);
174 pcm1796_write_i2c(chip
, codec
, reg
, value
);
177 static void cs4398_write(struct oxygen
*chip
, u8 reg
, u8 value
)
179 oxygen_write_i2c(chip
, I2C_DEVICE_CS4398
, reg
, value
);
182 static void cs4362a_write(struct oxygen
*chip
, u8 reg
, u8 value
)
184 oxygen_write_i2c(chip
, I2C_DEVICE_CS4362A
, reg
, value
);
187 static void xonar_enable_output(struct oxygen
*chip
)
189 struct xonar_data
*data
= chip
->model_data
;
191 msleep(data
->anti_pop_delay
);
192 oxygen_set_bits16(chip
, OXYGEN_GPIO_DATA
, data
->output_enable_bit
);
195 static void xonar_common_init(struct oxygen
*chip
)
197 struct xonar_data
*data
= chip
->model_data
;
199 if (data
->ext_power_reg
) {
200 oxygen_set_bits8(chip
, data
->ext_power_int_reg
,
201 data
->ext_power_bit
);
202 chip
->interrupt_mask
|= OXYGEN_INT_GPIO
;
203 chip
->model
.gpio_changed
= xonar_gpio_changed
;
204 data
->has_power
= !!(oxygen_read8(chip
, data
->ext_power_reg
)
205 & data
->ext_power_bit
);
207 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
208 GPIO_CS53x1_M_MASK
| data
->output_enable_bit
);
209 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
210 GPIO_CS53x1_M_SINGLE
, GPIO_CS53x1_M_MASK
);
211 oxygen_ac97_set_bits(chip
, 0, CM9780_JACK
, CM9780_FMIC2MIC
);
212 xonar_enable_output(chip
);
215 static void update_pcm1796_volume(struct oxygen
*chip
)
219 for (i
= 0; i
< 4; ++i
) {
220 pcm1796_write(chip
, i
, 16, chip
->dac_volume
[i
* 2]);
221 pcm1796_write(chip
, i
, 17, chip
->dac_volume
[i
* 2 + 1]);
225 static void update_pcm1796_mute(struct oxygen
*chip
)
230 value
= PCM1796_DMF_DISABLED
| PCM1796_FMT_24_LJUST
| PCM1796_ATLD
;
232 value
|= PCM1796_MUTE
;
233 for (i
= 0; i
< 4; ++i
)
234 pcm1796_write(chip
, i
, 18, value
);
237 static void pcm1796_init(struct oxygen
*chip
)
239 struct xonar_data
*data
= chip
->model_data
;
242 for (i
= 0; i
< 4; ++i
) {
243 pcm1796_write(chip
, i
, 19, PCM1796_FLT_SHARP
| PCM1796_ATS_1
);
244 pcm1796_write(chip
, i
, 20, data
->pcm1796_oversampling
);
245 pcm1796_write(chip
, i
, 21, 0);
247 update_pcm1796_mute(chip
); /* set ATLD before ATL/ATR */
248 update_pcm1796_volume(chip
);
251 static void xonar_d2_init(struct oxygen
*chip
)
253 struct xonar_data
*data
= chip
->model_data
;
255 data
->anti_pop_delay
= 300;
256 data
->output_enable_bit
= GPIO_D2_OUTPUT_ENABLE
;
257 data
->pcm1796_oversampling
= PCM1796_OS_64
;
258 if (data
->model
== MODEL_D2X
) {
259 data
->ext_power_reg
= OXYGEN_GPIO_DATA
;
260 data
->ext_power_int_reg
= OXYGEN_GPIO_INTERRUPT_MASK
;
261 data
->ext_power_bit
= GPIO_D2X_EXT_POWER
;
262 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
,
268 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2_ALT
);
269 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_D2_ALT
);
271 xonar_common_init(chip
);
273 snd_component_add(chip
->card
, "PCM1796");
274 snd_component_add(chip
->card
, "CS5381");
277 static void update_cs4362a_volumes(struct oxygen
*chip
)
281 mute
= chip
->dac_mute
? CS4362A_MUTE
: 0;
282 cs4362a_write(chip
, 7, (127 - chip
->dac_volume
[2]) | mute
);
283 cs4362a_write(chip
, 8, (127 - chip
->dac_volume
[3]) | mute
);
284 cs4362a_write(chip
, 10, (127 - chip
->dac_volume
[4]) | mute
);
285 cs4362a_write(chip
, 11, (127 - chip
->dac_volume
[5]) | mute
);
286 cs4362a_write(chip
, 13, (127 - chip
->dac_volume
[6]) | mute
);
287 cs4362a_write(chip
, 14, (127 - chip
->dac_volume
[7]) | mute
);
290 static void update_cs43xx_volume(struct oxygen
*chip
)
292 cs4398_write(chip
, 5, (127 - chip
->dac_volume
[0]) * 2);
293 cs4398_write(chip
, 6, (127 - chip
->dac_volume
[1]) * 2);
294 update_cs4362a_volumes(chip
);
297 static void update_cs43xx_mute(struct oxygen
*chip
)
301 reg
= CS4398_MUTEP_LOW
| CS4398_PAMUTE
;
303 reg
|= CS4398_MUTE_B
| CS4398_MUTE_A
;
304 cs4398_write(chip
, 4, reg
);
305 update_cs4362a_volumes(chip
);
308 static void cs43xx_init(struct oxygen
*chip
)
310 struct xonar_data
*data
= chip
->model_data
;
312 /* set CPEN (control port mode) and power down */
313 cs4398_write(chip
, 8, CS4398_CPEN
| CS4398_PDN
);
314 cs4362a_write(chip
, 0x01, CS4362A_PDN
| CS4362A_CPEN
);
316 cs4398_write(chip
, 2, data
->cs4398_fm
);
317 cs4398_write(chip
, 3, CS4398_ATAPI_B_R
| CS4398_ATAPI_A_L
);
318 cs4398_write(chip
, 7, CS4398_RMP_DN
| CS4398_RMP_UP
|
319 CS4398_ZERO_CROSS
| CS4398_SOFT_RAMP
);
320 cs4362a_write(chip
, 0x02, CS4362A_DIF_LJUST
);
321 cs4362a_write(chip
, 0x03, CS4362A_MUTEC_6
| CS4362A_AMUTE
|
322 CS4362A_RMP_UP
| CS4362A_ZERO_CROSS
| CS4362A_SOFT_RAMP
);
323 cs4362a_write(chip
, 0x04, CS4362A_RMP_DN
| CS4362A_DEM_NONE
);
324 cs4362a_write(chip
, 0x05, 0);
325 cs4362a_write(chip
, 0x06, data
->cs4362a_fm
);
326 cs4362a_write(chip
, 0x09, data
->cs4362a_fm
);
327 cs4362a_write(chip
, 0x0c, data
->cs4362a_fm
);
328 update_cs43xx_volume(chip
);
329 update_cs43xx_mute(chip
);
330 /* clear power down */
331 cs4398_write(chip
, 8, CS4398_CPEN
);
332 cs4362a_write(chip
, 0x01, CS4362A_CPEN
);
335 static void xonar_d1_init(struct oxygen
*chip
)
337 struct xonar_data
*data
= chip
->model_data
;
339 data
->anti_pop_delay
= 800;
340 data
->output_enable_bit
= GPIO_DX_OUTPUT_ENABLE
;
341 data
->cs4398_fm
= CS4398_FM_SINGLE
| CS4398_DEM_NONE
| CS4398_DIF_LJUST
;
342 data
->cs4362a_fm
= CS4362A_FM_SINGLE
|
343 CS4362A_ATAPI_B_R
| CS4362A_ATAPI_A_L
;
344 if (data
->model
== MODEL_DX
) {
345 data
->ext_power_reg
= OXYGEN_GPI_DATA
;
346 data
->ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
347 data
->ext_power_bit
= GPI_DX_EXT_POWER
;
350 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
351 OXYGEN_2WIRE_LENGTH_8
|
352 OXYGEN_2WIRE_INTERRUPT_MASK
|
353 OXYGEN_2WIRE_SPEED_FAST
);
357 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
358 GPIO_DX_FRONT_PANEL
| GPIO_DX_INPUT_ROUTE
);
359 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
,
360 GPIO_DX_FRONT_PANEL
| GPIO_DX_INPUT_ROUTE
);
362 xonar_common_init(chip
);
364 snd_component_add(chip
->card
, "CS4398");
365 snd_component_add(chip
->card
, "CS4362A");
366 snd_component_add(chip
->card
, "CS5361");
369 static void xonar_disable_output(struct oxygen
*chip
)
371 struct xonar_data
*data
= chip
->model_data
;
373 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, data
->output_enable_bit
);
376 static void xonar_d2_cleanup(struct oxygen
*chip
)
378 xonar_disable_output(chip
);
381 static void xonar_d1_cleanup(struct oxygen
*chip
)
383 xonar_disable_output(chip
);
384 cs4362a_write(chip
, 0x01, CS4362A_PDN
| CS4362A_CPEN
);
385 oxygen_clear_bits8(chip
, OXYGEN_FUNCTION
, OXYGEN_FUNCTION_RESET_CODEC
);
388 static void xonar_d2_suspend(struct oxygen
*chip
)
390 xonar_d2_cleanup(chip
);
393 static void xonar_d1_suspend(struct oxygen
*chip
)
395 xonar_d1_cleanup(chip
);
398 static void xonar_d2_resume(struct oxygen
*chip
)
401 xonar_enable_output(chip
);
404 static void xonar_d1_resume(struct oxygen
*chip
)
407 xonar_enable_output(chip
);
410 static void set_pcm1796_params(struct oxygen
*chip
,
411 struct snd_pcm_hw_params
*params
)
413 struct xonar_data
*data
= chip
->model_data
;
416 data
->pcm1796_oversampling
=
417 params_rate(params
) >= 96000 ? PCM1796_OS_32
: PCM1796_OS_64
;
418 for (i
= 0; i
< 4; ++i
)
419 pcm1796_write(chip
, i
, 20, data
->pcm1796_oversampling
);
422 static void set_cs53x1_params(struct oxygen
*chip
,
423 struct snd_pcm_hw_params
*params
)
427 if (params_rate(params
) <= 54000)
428 value
= GPIO_CS53x1_M_SINGLE
;
429 else if (params_rate(params
) <= 108000)
430 value
= GPIO_CS53x1_M_DOUBLE
;
432 value
= GPIO_CS53x1_M_QUAD
;
433 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
434 value
, GPIO_CS53x1_M_MASK
);
437 static void set_cs43xx_params(struct oxygen
*chip
,
438 struct snd_pcm_hw_params
*params
)
440 struct xonar_data
*data
= chip
->model_data
;
442 data
->cs4398_fm
= CS4398_DEM_NONE
| CS4398_DIF_LJUST
;
443 data
->cs4362a_fm
= CS4362A_ATAPI_B_R
| CS4362A_ATAPI_A_L
;
444 if (params_rate(params
) <= 50000) {
445 data
->cs4398_fm
|= CS4398_FM_SINGLE
;
446 data
->cs4362a_fm
|= CS4362A_FM_SINGLE
;
447 } else if (params_rate(params
) <= 100000) {
448 data
->cs4398_fm
|= CS4398_FM_DOUBLE
;
449 data
->cs4362a_fm
|= CS4362A_FM_DOUBLE
;
451 data
->cs4398_fm
|= CS4398_FM_QUAD
;
452 data
->cs4362a_fm
|= CS4362A_FM_QUAD
;
454 cs4398_write(chip
, 2, data
->cs4398_fm
);
455 cs4362a_write(chip
, 0x06, data
->cs4362a_fm
);
456 cs4362a_write(chip
, 0x09, data
->cs4362a_fm
);
457 cs4362a_write(chip
, 0x0c, data
->cs4362a_fm
);
460 static void xonar_gpio_changed(struct oxygen
*chip
)
462 struct xonar_data
*data
= chip
->model_data
;
465 has_power
= !!(oxygen_read8(chip
, data
->ext_power_reg
)
466 & data
->ext_power_bit
);
467 if (has_power
!= data
->has_power
) {
468 data
->has_power
= has_power
;
470 snd_printk(KERN_NOTICE
"power restored\n");
473 "Hey! Don't unplug the power cable!\n");
474 /* TODO: stop PCMs */
479 static int gpio_bit_switch_get(struct snd_kcontrol
*ctl
,
480 struct snd_ctl_elem_value
*value
)
482 struct oxygen
*chip
= ctl
->private_data
;
483 u16 bit
= ctl
->private_value
;
485 value
->value
.integer
.value
[0] =
486 !!(oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & bit
);
490 static int gpio_bit_switch_put(struct snd_kcontrol
*ctl
,
491 struct snd_ctl_elem_value
*value
)
493 struct oxygen
*chip
= ctl
->private_data
;
494 u16 bit
= ctl
->private_value
;
495 u16 old_bits
, new_bits
;
498 spin_lock_irq(&chip
->reg_lock
);
499 old_bits
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
500 if (value
->value
.integer
.value
[0])
501 new_bits
= old_bits
| bit
;
503 new_bits
= old_bits
& ~bit
;
504 changed
= new_bits
!= old_bits
;
506 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, new_bits
);
507 spin_unlock_irq(&chip
->reg_lock
);
511 static const struct snd_kcontrol_new alt_switch
= {
512 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
513 .name
= "Analog Loopback Switch",
514 .info
= snd_ctl_boolean_mono_info
,
515 .get
= gpio_bit_switch_get
,
516 .put
= gpio_bit_switch_put
,
517 .private_value
= GPIO_D2_ALT
,
520 static const struct snd_kcontrol_new front_panel_switch
= {
521 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
522 .name
= "Front Panel Switch",
523 .info
= snd_ctl_boolean_mono_info
,
524 .get
= gpio_bit_switch_get
,
525 .put
= gpio_bit_switch_put
,
526 .private_value
= GPIO_DX_FRONT_PANEL
,
529 static void xonar_d1_ac97_switch(struct oxygen
*chip
,
530 unsigned int reg
, unsigned int mute
)
532 if (reg
== AC97_LINE
) {
533 spin_lock_irq(&chip
->reg_lock
);
534 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
535 mute
? GPIO_DX_INPUT_ROUTE
: 0,
536 GPIO_DX_INPUT_ROUTE
);
537 spin_unlock_irq(&chip
->reg_lock
);
541 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale
, -12000, 50, 0);
542 static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale
, -12700, 100, 0);
544 static int xonar_d2_control_filter(struct snd_kcontrol_new
*template)
546 if (!strncmp(template->name
, "CD Capture ", 11))
547 /* CD in is actually connected to the video in pin */
548 template->private_value
^= AC97_CD
^ AC97_VIDEO
;
552 static int xonar_d1_control_filter(struct snd_kcontrol_new
*template)
554 if (!strncmp(template->name
, "CD Capture ", 11))
555 return 1; /* no CD input */
559 static int xonar_d2_mixer_init(struct oxygen
*chip
)
561 return snd_ctl_add(chip
->card
, snd_ctl_new1(&alt_switch
, chip
));
564 static int xonar_d1_mixer_init(struct oxygen
*chip
)
566 return snd_ctl_add(chip
->card
, snd_ctl_new1(&front_panel_switch
, chip
));
569 static int xonar_model_probe(struct oxygen
*chip
, unsigned long driver_data
)
571 static const char *const names
[] = {
572 [MODEL_D1
] = "Xonar D1",
573 [MODEL_DX
] = "Xonar DX",
574 [MODEL_D2
] = "Xonar D2",
575 [MODEL_D2X
] = "Xonar D2X",
577 struct xonar_data
*data
= chip
->model_data
;
579 data
->model
= driver_data
;
580 chip
->model
.shortname
= names
[data
->model
];
584 static const struct oxygen_model model_xonar_d2
= {
585 .longname
= "Asus Virtuoso 200",
587 .owner
= THIS_MODULE
,
588 .probe
= xonar_model_probe
,
589 .init
= xonar_d2_init
,
590 .control_filter
= xonar_d2_control_filter
,
591 .mixer_init
= xonar_d2_mixer_init
,
592 .cleanup
= xonar_d2_cleanup
,
593 .suspend
= xonar_d2_suspend
,
594 .resume
= xonar_d2_resume
,
595 .set_dac_params
= set_pcm1796_params
,
596 .set_adc_params
= set_cs53x1_params
,
597 .update_dac_volume
= update_pcm1796_volume
,
598 .update_dac_mute
= update_pcm1796_mute
,
599 .dac_tlv
= pcm1796_db_scale
,
600 .model_data_size
= sizeof(struct xonar_data
),
601 .device_config
= PLAYBACK_0_TO_I2S
|
602 PLAYBACK_1_TO_SPDIF
|
603 CAPTURE_0_FROM_I2S_2
|
604 CAPTURE_1_FROM_SPDIF
|
608 .dac_volume_min
= 0x0f,
609 .dac_volume_max
= 0xff,
610 .misc_flags
= OXYGEN_MISC_MIDI
,
611 .function_flags
= OXYGEN_FUNCTION_SPI
|
612 OXYGEN_FUNCTION_ENABLE_SPI_4_5
,
613 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
614 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
617 static const struct oxygen_model model_xonar_d1
= {
618 .longname
= "Asus Virtuoso 100",
620 .owner
= THIS_MODULE
,
621 .probe
= xonar_model_probe
,
622 .init
= xonar_d1_init
,
623 .control_filter
= xonar_d1_control_filter
,
624 .mixer_init
= xonar_d1_mixer_init
,
625 .cleanup
= xonar_d1_cleanup
,
626 .suspend
= xonar_d1_suspend
,
627 .resume
= xonar_d1_resume
,
628 .set_dac_params
= set_cs43xx_params
,
629 .set_adc_params
= set_cs53x1_params
,
630 .update_dac_volume
= update_cs43xx_volume
,
631 .update_dac_mute
= update_cs43xx_mute
,
632 .ac97_switch
= xonar_d1_ac97_switch
,
633 .dac_tlv
= cs4362a_db_scale
,
634 .model_data_size
= sizeof(struct xonar_data
),
635 .device_config
= PLAYBACK_0_TO_I2S
|
636 PLAYBACK_1_TO_SPDIF
|
637 CAPTURE_0_FROM_I2S_2
,
640 .dac_volume_max
= 127,
641 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
642 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
643 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
646 static int __devinit
xonar_probe(struct pci_dev
*pci
,
647 const struct pci_device_id
*pci_id
)
649 static const struct oxygen_model
*const models
[] = {
650 [MODEL_D1
] = &model_xonar_d1
,
651 [MODEL_DX
] = &model_xonar_d1
,
652 [MODEL_D2
] = &model_xonar_d2
,
653 [MODEL_D2X
] = &model_xonar_d2
,
658 if (dev
>= SNDRV_CARDS
)
664 BUG_ON(pci_id
->driver_data
>= ARRAY_SIZE(models
));
665 err
= oxygen_pci_probe(pci
, index
[dev
], id
[dev
],
666 models
[pci_id
->driver_data
],
667 pci_id
->driver_data
);
673 static struct pci_driver xonar_driver
= {
675 .id_table
= xonar_ids
,
676 .probe
= xonar_probe
,
677 .remove
= __devexit_p(oxygen_pci_remove
),
679 .suspend
= oxygen_pci_suspend
,
680 .resume
= oxygen_pci_resume
,
684 static int __init
alsa_card_xonar_init(void)
686 return pci_register_driver(&xonar_driver
);
689 static void __exit
alsa_card_xonar_exit(void)
691 pci_unregister_driver(&xonar_driver
);
694 module_init(alsa_card_xonar_init
)
695 module_exit(alsa_card_xonar_exit
)