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_CS4398 0x9e /* 10011, AD1=1, AD0=1, /W=0 */
128 #define I2C_DEVICE_CS4362A 0x30 /* 001100, AD0=0, /W=0 */
132 unsigned int anti_pop_delay
;
133 u16 output_enable_bit
;
135 u8 ext_power_int_reg
;
138 u8 pcm1796_oversampling
;
143 static void xonar_gpio_changed(struct oxygen
*chip
);
145 static void pcm1796_write(struct oxygen
*chip
, unsigned int codec
,
148 /* maps ALSA channel pair number to SPI output */
149 static const u8 codec_map
[4] = {
152 oxygen_write_spi(chip
, OXYGEN_SPI_TRIGGER
|
153 OXYGEN_SPI_DATA_LENGTH_2
|
154 OXYGEN_SPI_CLOCK_160
|
155 (codec_map
[codec
] << OXYGEN_SPI_CODEC_SHIFT
) |
156 OXYGEN_SPI_CEN_LATCH_CLOCK_HI
,
160 static void cs4398_write(struct oxygen
*chip
, u8 reg
, u8 value
)
162 oxygen_write_i2c(chip
, I2C_DEVICE_CS4398
, reg
, value
);
165 static void cs4362a_write(struct oxygen
*chip
, u8 reg
, u8 value
)
167 oxygen_write_i2c(chip
, I2C_DEVICE_CS4362A
, reg
, value
);
170 static void xonar_enable_output(struct oxygen
*chip
)
172 struct xonar_data
*data
= chip
->model_data
;
174 msleep(data
->anti_pop_delay
);
175 oxygen_set_bits16(chip
, OXYGEN_GPIO_DATA
, data
->output_enable_bit
);
178 static void xonar_common_init(struct oxygen
*chip
)
180 struct xonar_data
*data
= chip
->model_data
;
182 if (data
->ext_power_reg
) {
183 oxygen_set_bits8(chip
, data
->ext_power_int_reg
,
184 data
->ext_power_bit
);
185 chip
->interrupt_mask
|= OXYGEN_INT_GPIO
;
186 chip
->model
.gpio_changed
= xonar_gpio_changed
;
187 data
->has_power
= !!(oxygen_read8(chip
, data
->ext_power_reg
)
188 & data
->ext_power_bit
);
190 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
191 GPIO_CS53x1_M_MASK
| data
->output_enable_bit
);
192 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
193 GPIO_CS53x1_M_SINGLE
, GPIO_CS53x1_M_MASK
);
194 oxygen_ac97_set_bits(chip
, 0, CM9780_JACK
, CM9780_FMIC2MIC
);
195 xonar_enable_output(chip
);
198 static void update_pcm1796_volume(struct oxygen
*chip
)
202 for (i
= 0; i
< 4; ++i
) {
203 pcm1796_write(chip
, i
, 16, chip
->dac_volume
[i
* 2]);
204 pcm1796_write(chip
, i
, 17, chip
->dac_volume
[i
* 2 + 1]);
208 static void update_pcm1796_mute(struct oxygen
*chip
)
213 value
= PCM1796_DMF_DISABLED
| PCM1796_FMT_24_LJUST
| PCM1796_ATLD
;
215 value
|= PCM1796_MUTE
;
216 for (i
= 0; i
< 4; ++i
)
217 pcm1796_write(chip
, i
, 18, value
);
220 static void pcm1796_init(struct oxygen
*chip
)
222 struct xonar_data
*data
= chip
->model_data
;
225 for (i
= 0; i
< 4; ++i
) {
226 pcm1796_write(chip
, i
, 19, PCM1796_FLT_SHARP
| PCM1796_ATS_1
);
227 pcm1796_write(chip
, i
, 20, data
->pcm1796_oversampling
);
228 pcm1796_write(chip
, i
, 21, 0);
230 update_pcm1796_mute(chip
); /* set ATLD before ATL/ATR */
231 update_pcm1796_volume(chip
);
234 static void xonar_d2_init(struct oxygen
*chip
)
236 struct xonar_data
*data
= chip
->model_data
;
238 data
->anti_pop_delay
= 300;
239 data
->output_enable_bit
= GPIO_D2_OUTPUT_ENABLE
;
240 data
->pcm1796_oversampling
= PCM1796_OS_64
;
241 if (data
->model
== MODEL_D2X
) {
242 data
->ext_power_reg
= OXYGEN_GPIO_DATA
;
243 data
->ext_power_int_reg
= OXYGEN_GPIO_INTERRUPT_MASK
;
244 data
->ext_power_bit
= GPIO_D2X_EXT_POWER
;
245 oxygen_clear_bits16(chip
, OXYGEN_GPIO_CONTROL
,
251 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_D2_ALT
);
252 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_D2_ALT
);
254 xonar_common_init(chip
);
256 snd_component_add(chip
->card
, "PCM1796");
257 snd_component_add(chip
->card
, "CS5381");
260 static void update_cs4362a_volumes(struct oxygen
*chip
)
264 mute
= chip
->dac_mute
? CS4362A_MUTE
: 0;
265 cs4362a_write(chip
, 7, (127 - chip
->dac_volume
[2]) | mute
);
266 cs4362a_write(chip
, 8, (127 - chip
->dac_volume
[3]) | mute
);
267 cs4362a_write(chip
, 10, (127 - chip
->dac_volume
[4]) | mute
);
268 cs4362a_write(chip
, 11, (127 - chip
->dac_volume
[5]) | mute
);
269 cs4362a_write(chip
, 13, (127 - chip
->dac_volume
[6]) | mute
);
270 cs4362a_write(chip
, 14, (127 - chip
->dac_volume
[7]) | mute
);
273 static void update_cs43xx_volume(struct oxygen
*chip
)
275 cs4398_write(chip
, 5, (127 - chip
->dac_volume
[0]) * 2);
276 cs4398_write(chip
, 6, (127 - chip
->dac_volume
[1]) * 2);
277 update_cs4362a_volumes(chip
);
280 static void update_cs43xx_mute(struct oxygen
*chip
)
284 reg
= CS4398_MUTEP_LOW
| CS4398_PAMUTE
;
286 reg
|= CS4398_MUTE_B
| CS4398_MUTE_A
;
287 cs4398_write(chip
, 4, reg
);
288 update_cs4362a_volumes(chip
);
291 static void cs43xx_init(struct oxygen
*chip
)
293 struct xonar_data
*data
= chip
->model_data
;
295 /* set CPEN (control port mode) and power down */
296 cs4398_write(chip
, 8, CS4398_CPEN
| CS4398_PDN
);
297 cs4362a_write(chip
, 0x01, CS4362A_PDN
| CS4362A_CPEN
);
299 cs4398_write(chip
, 2, data
->cs4398_fm
);
300 cs4398_write(chip
, 3, CS4398_ATAPI_B_R
| CS4398_ATAPI_A_L
);
301 cs4398_write(chip
, 7, CS4398_RMP_DN
| CS4398_RMP_UP
|
302 CS4398_ZERO_CROSS
| CS4398_SOFT_RAMP
);
303 cs4362a_write(chip
, 0x02, CS4362A_DIF_LJUST
);
304 cs4362a_write(chip
, 0x03, CS4362A_MUTEC_6
| CS4362A_AMUTE
|
305 CS4362A_RMP_UP
| CS4362A_ZERO_CROSS
| CS4362A_SOFT_RAMP
);
306 cs4362a_write(chip
, 0x04, CS4362A_RMP_DN
| CS4362A_DEM_NONE
);
307 cs4362a_write(chip
, 0x05, 0);
308 cs4362a_write(chip
, 0x06, data
->cs4362a_fm
);
309 cs4362a_write(chip
, 0x09, data
->cs4362a_fm
);
310 cs4362a_write(chip
, 0x0c, data
->cs4362a_fm
);
311 update_cs43xx_volume(chip
);
312 update_cs43xx_mute(chip
);
313 /* clear power down */
314 cs4398_write(chip
, 8, CS4398_CPEN
);
315 cs4362a_write(chip
, 0x01, CS4362A_CPEN
);
318 static void xonar_d1_init(struct oxygen
*chip
)
320 struct xonar_data
*data
= chip
->model_data
;
322 data
->anti_pop_delay
= 800;
323 data
->output_enable_bit
= GPIO_DX_OUTPUT_ENABLE
;
324 data
->cs4398_fm
= CS4398_FM_SINGLE
| CS4398_DEM_NONE
| CS4398_DIF_LJUST
;
325 data
->cs4362a_fm
= CS4362A_FM_SINGLE
|
326 CS4362A_ATAPI_B_R
| CS4362A_ATAPI_A_L
;
327 if (data
->model
== MODEL_DX
) {
328 data
->ext_power_reg
= OXYGEN_GPI_DATA
;
329 data
->ext_power_int_reg
= OXYGEN_GPI_INTERRUPT_MASK
;
330 data
->ext_power_bit
= GPI_DX_EXT_POWER
;
333 oxygen_write16(chip
, OXYGEN_2WIRE_BUS_STATUS
,
334 OXYGEN_2WIRE_LENGTH_8
|
335 OXYGEN_2WIRE_INTERRUPT_MASK
|
336 OXYGEN_2WIRE_SPEED_FAST
);
340 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
341 GPIO_DX_FRONT_PANEL
| GPIO_DX_INPUT_ROUTE
);
342 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
,
343 GPIO_DX_FRONT_PANEL
| GPIO_DX_INPUT_ROUTE
);
345 xonar_common_init(chip
);
347 snd_component_add(chip
->card
, "CS4398");
348 snd_component_add(chip
->card
, "CS4362A");
349 snd_component_add(chip
->card
, "CS5361");
352 static void xonar_cleanup(struct oxygen
*chip
)
354 struct xonar_data
*data
= chip
->model_data
;
356 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, data
->output_enable_bit
);
359 static void xonar_d1_cleanup(struct oxygen
*chip
)
362 cs4362a_write(chip
, 0x01, CS4362A_PDN
| CS4362A_CPEN
);
363 oxygen_clear_bits8(chip
, OXYGEN_FUNCTION
, OXYGEN_FUNCTION_RESET_CODEC
);
366 static void xonar_d2_resume(struct oxygen
*chip
)
369 xonar_enable_output(chip
);
372 static void xonar_d1_resume(struct oxygen
*chip
)
375 xonar_enable_output(chip
);
378 static void set_pcm1796_params(struct oxygen
*chip
,
379 struct snd_pcm_hw_params
*params
)
381 struct xonar_data
*data
= chip
->model_data
;
384 data
->pcm1796_oversampling
=
385 params_rate(params
) >= 96000 ? PCM1796_OS_32
: PCM1796_OS_64
;
386 for (i
= 0; i
< 4; ++i
)
387 pcm1796_write(chip
, i
, 20, data
->pcm1796_oversampling
);
390 static void set_cs53x1_params(struct oxygen
*chip
,
391 struct snd_pcm_hw_params
*params
)
395 if (params_rate(params
) <= 54000)
396 value
= GPIO_CS53x1_M_SINGLE
;
397 else if (params_rate(params
) <= 108000)
398 value
= GPIO_CS53x1_M_DOUBLE
;
400 value
= GPIO_CS53x1_M_QUAD
;
401 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
402 value
, GPIO_CS53x1_M_MASK
);
405 static void set_cs43xx_params(struct oxygen
*chip
,
406 struct snd_pcm_hw_params
*params
)
408 struct xonar_data
*data
= chip
->model_data
;
410 data
->cs4398_fm
= CS4398_DEM_NONE
| CS4398_DIF_LJUST
;
411 data
->cs4362a_fm
= CS4362A_ATAPI_B_R
| CS4362A_ATAPI_A_L
;
412 if (params_rate(params
) <= 50000) {
413 data
->cs4398_fm
|= CS4398_FM_SINGLE
;
414 data
->cs4362a_fm
|= CS4362A_FM_SINGLE
;
415 } else if (params_rate(params
) <= 100000) {
416 data
->cs4398_fm
|= CS4398_FM_DOUBLE
;
417 data
->cs4362a_fm
|= CS4362A_FM_DOUBLE
;
419 data
->cs4398_fm
|= CS4398_FM_QUAD
;
420 data
->cs4362a_fm
|= CS4362A_FM_QUAD
;
422 cs4398_write(chip
, 2, data
->cs4398_fm
);
423 cs4362a_write(chip
, 0x06, data
->cs4362a_fm
);
424 cs4362a_write(chip
, 0x09, data
->cs4362a_fm
);
425 cs4362a_write(chip
, 0x0c, data
->cs4362a_fm
);
428 static void xonar_gpio_changed(struct oxygen
*chip
)
430 struct xonar_data
*data
= chip
->model_data
;
433 has_power
= !!(oxygen_read8(chip
, data
->ext_power_reg
)
434 & data
->ext_power_bit
);
435 if (has_power
!= data
->has_power
) {
436 data
->has_power
= has_power
;
438 snd_printk(KERN_NOTICE
"power restored\n");
441 "Hey! Don't unplug the power cable!\n");
442 /* TODO: stop PCMs */
447 static int gpio_bit_switch_get(struct snd_kcontrol
*ctl
,
448 struct snd_ctl_elem_value
*value
)
450 struct oxygen
*chip
= ctl
->private_data
;
451 u16 bit
= ctl
->private_value
;
453 value
->value
.integer
.value
[0] =
454 !!(oxygen_read16(chip
, OXYGEN_GPIO_DATA
) & bit
);
458 static int gpio_bit_switch_put(struct snd_kcontrol
*ctl
,
459 struct snd_ctl_elem_value
*value
)
461 struct oxygen
*chip
= ctl
->private_data
;
462 u16 bit
= ctl
->private_value
;
463 u16 old_bits
, new_bits
;
466 spin_lock_irq(&chip
->reg_lock
);
467 old_bits
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
468 if (value
->value
.integer
.value
[0])
469 new_bits
= old_bits
| bit
;
471 new_bits
= old_bits
& ~bit
;
472 changed
= new_bits
!= old_bits
;
474 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, new_bits
);
475 spin_unlock_irq(&chip
->reg_lock
);
479 static const struct snd_kcontrol_new alt_switch
= {
480 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
481 .name
= "Analog Loopback Switch",
482 .info
= snd_ctl_boolean_mono_info
,
483 .get
= gpio_bit_switch_get
,
484 .put
= gpio_bit_switch_put
,
485 .private_value
= GPIO_D2_ALT
,
488 static const struct snd_kcontrol_new front_panel_switch
= {
489 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
490 .name
= "Front Panel Switch",
491 .info
= snd_ctl_boolean_mono_info
,
492 .get
= gpio_bit_switch_get
,
493 .put
= gpio_bit_switch_put
,
494 .private_value
= GPIO_DX_FRONT_PANEL
,
497 static void xonar_d1_ac97_switch(struct oxygen
*chip
,
498 unsigned int reg
, unsigned int mute
)
500 if (reg
== AC97_LINE
) {
501 spin_lock_irq(&chip
->reg_lock
);
502 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
503 mute
? GPIO_DX_INPUT_ROUTE
: 0,
504 GPIO_DX_INPUT_ROUTE
);
505 spin_unlock_irq(&chip
->reg_lock
);
509 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale
, -12000, 50, 0);
510 static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale
, -12700, 100, 0);
512 static int xonar_d2_control_filter(struct snd_kcontrol_new
*template)
514 if (!strncmp(template->name
, "CD Capture ", 11))
515 /* CD in is actually connected to the video in pin */
516 template->private_value
^= AC97_CD
^ AC97_VIDEO
;
520 static int xonar_d1_control_filter(struct snd_kcontrol_new
*template)
522 if (!strncmp(template->name
, "CD Capture ", 11))
523 return 1; /* no CD input */
527 static int xonar_d2_mixer_init(struct oxygen
*chip
)
529 return snd_ctl_add(chip
->card
, snd_ctl_new1(&alt_switch
, chip
));
532 static int xonar_d1_mixer_init(struct oxygen
*chip
)
534 return snd_ctl_add(chip
->card
, snd_ctl_new1(&front_panel_switch
, chip
));
537 static int xonar_model_probe(struct oxygen
*chip
, unsigned long driver_data
)
539 static const char *const names
[] = {
540 [MODEL_D1
] = "Xonar D1",
541 [MODEL_DX
] = "Xonar DX",
542 [MODEL_D2
] = "Xonar D2",
543 [MODEL_D2X
] = "Xonar D2X",
545 struct xonar_data
*data
= chip
->model_data
;
547 data
->model
= driver_data
;
548 chip
->model
.shortname
= names
[data
->model
];
552 static const struct oxygen_model model_xonar_d2
= {
553 .longname
= "Asus Virtuoso 200",
555 .owner
= THIS_MODULE
,
556 .probe
= xonar_model_probe
,
557 .init
= xonar_d2_init
,
558 .control_filter
= xonar_d2_control_filter
,
559 .mixer_init
= xonar_d2_mixer_init
,
560 .cleanup
= xonar_cleanup
,
561 .suspend
= xonar_cleanup
,
562 .resume
= xonar_d2_resume
,
563 .set_dac_params
= set_pcm1796_params
,
564 .set_adc_params
= set_cs53x1_params
,
565 .update_dac_volume
= update_pcm1796_volume
,
566 .update_dac_mute
= update_pcm1796_mute
,
567 .dac_tlv
= pcm1796_db_scale
,
568 .model_data_size
= sizeof(struct xonar_data
),
569 .pcm_dev_cfg
= PLAYBACK_0_TO_I2S
|
570 PLAYBACK_1_TO_SPDIF
|
571 CAPTURE_0_FROM_I2S_2
|
572 CAPTURE_1_FROM_SPDIF
,
574 .dac_volume_min
= 0x0f,
575 .dac_volume_max
= 0xff,
576 .misc_flags
= OXYGEN_MISC_MIDI
,
577 .function_flags
= OXYGEN_FUNCTION_SPI
|
578 OXYGEN_FUNCTION_ENABLE_SPI_4_5
,
579 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
580 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
583 static const struct oxygen_model model_xonar_d1
= {
584 .longname
= "Asus Virtuoso 100",
586 .owner
= THIS_MODULE
,
587 .probe
= xonar_model_probe
,
588 .init
= xonar_d1_init
,
589 .control_filter
= xonar_d1_control_filter
,
590 .mixer_init
= xonar_d1_mixer_init
,
591 .cleanup
= xonar_d1_cleanup
,
592 .suspend
= xonar_d1_cleanup
,
593 .resume
= xonar_d1_resume
,
594 .set_dac_params
= set_cs43xx_params
,
595 .set_adc_params
= set_cs53x1_params
,
596 .update_dac_volume
= update_cs43xx_volume
,
597 .update_dac_mute
= update_cs43xx_mute
,
598 .ac97_switch
= xonar_d1_ac97_switch
,
599 .dac_tlv
= cs4362a_db_scale
,
600 .model_data_size
= sizeof(struct xonar_data
),
601 .pcm_dev_cfg
= PLAYBACK_0_TO_I2S
|
602 PLAYBACK_1_TO_SPDIF
|
603 CAPTURE_0_FROM_I2S_2
,
606 .dac_volume_max
= 127,
607 .function_flags
= OXYGEN_FUNCTION_2WIRE
,
608 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
609 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
612 static int __devinit
xonar_probe(struct pci_dev
*pci
,
613 const struct pci_device_id
*pci_id
)
615 static const struct oxygen_model
*const models
[] = {
616 [MODEL_D1
] = &model_xonar_d1
,
617 [MODEL_DX
] = &model_xonar_d1
,
618 [MODEL_D2
] = &model_xonar_d2
,
619 [MODEL_D2X
] = &model_xonar_d2
,
624 if (dev
>= SNDRV_CARDS
)
630 BUG_ON(pci_id
->driver_data
>= ARRAY_SIZE(models
));
631 err
= oxygen_pci_probe(pci
, index
[dev
], id
[dev
],
632 models
[pci_id
->driver_data
],
633 pci_id
->driver_data
);
639 static struct pci_driver xonar_driver
= {
641 .id_table
= xonar_ids
,
642 .probe
= xonar_probe
,
643 .remove
= __devexit_p(oxygen_pci_remove
),
645 .suspend
= oxygen_pci_suspend
,
646 .resume
= oxygen_pci_resume
,
650 static int __init
alsa_card_xonar_init(void)
652 return pci_register_driver(&xonar_driver
);
655 static void __exit
alsa_card_xonar_exit(void)
657 pci_unregister_driver(&xonar_driver
);
660 module_init(alsa_card_xonar_init
)
661 module_exit(alsa_card_xonar_exit
)