2 * C-Media CMI8788 driver for C-Media's reference design and similar models
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
23 * SPI 0 -> 1st AK4396 (front)
24 * SPI 1 -> 2nd AK4396 (surround)
25 * SPI 2 -> 3rd AK4396 (center/LFE)
27 * SPI 4 -> 4th AK4396 (back)
29 * GPIO 0 -> DFS0 of AK5385
30 * GPIO 1 -> DFS1 of AK5385
33 * GPIO 4 -> enable extension S/PDIF input
34 * GPIO 6 -> enable on-board S/PDIF input
37 * GPIO 8 -> enable headphone amplifier
41 * LINE_OUT -> input of ADC
47 * GPO 0 -> route line-in (0) or AC97 output (1) to ADC input
50 #include <linux/delay.h>
51 #include <linux/mutex.h>
52 #include <linux/pci.h>
53 #include <sound/ac97_codec.h>
54 #include <sound/control.h>
55 #include <sound/core.h>
56 #include <sound/info.h>
57 #include <sound/initval.h>
58 #include <sound/pcm.h>
59 #include <sound/pcm_params.h>
60 #include <sound/tlv.h>
66 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
67 MODULE_DESCRIPTION("C-Media CMI8788 driver");
68 MODULE_LICENSE("GPL v2");
69 MODULE_SUPPORTED_DEVICE("{{C-Media,CMI8786}"
71 ",{C-Media,CMI8788}}");
73 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
74 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
75 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
77 module_param_array(index
, int, NULL
, 0444);
78 MODULE_PARM_DESC(index
, "card index");
79 module_param_array(id
, charp
, NULL
, 0444);
80 MODULE_PARM_DESC(id
, "ID string");
81 module_param_array(enable
, bool, NULL
, 0444);
82 MODULE_PARM_DESC(enable
, "enable card");
97 static DEFINE_PCI_DEVICE_TABLE(oxygen_ids
) = {
98 /* C-Media's reference design */
99 { OXYGEN_PCI_SUBID(0x10b0, 0x0216), .driver_data
= MODEL_CMEDIA_REF
},
100 { OXYGEN_PCI_SUBID(0x10b0, 0x0217), .driver_data
= MODEL_CMEDIA_REF
},
101 { OXYGEN_PCI_SUBID(0x10b0, 0x0218), .driver_data
= MODEL_CMEDIA_REF
},
102 { OXYGEN_PCI_SUBID(0x10b0, 0x0219), .driver_data
= MODEL_CMEDIA_REF
},
103 { OXYGEN_PCI_SUBID(0x13f6, 0x0001), .driver_data
= MODEL_CMEDIA_REF
},
104 { OXYGEN_PCI_SUBID(0x13f6, 0x0010), .driver_data
= MODEL_CMEDIA_REF
},
105 { OXYGEN_PCI_SUBID(0x13f6, 0x8788), .driver_data
= MODEL_CMEDIA_REF
},
106 { OXYGEN_PCI_SUBID(0x147a, 0xa017), .driver_data
= MODEL_CMEDIA_REF
},
107 { OXYGEN_PCI_SUBID(0x1a58, 0x0910), .driver_data
= MODEL_CMEDIA_REF
},
109 { OXYGEN_PCI_SUBID(0x1043, 0x8467), .driver_data
= MODEL_XONAR_DG
},
110 /* PCI 2.0 HD Audio */
111 { OXYGEN_PCI_SUBID(0x13f6, 0x8782), .driver_data
= MODEL_2CH_OUTPUT
},
112 /* Kuroutoshikou CMI8787-HG2PCI */
113 { OXYGEN_PCI_SUBID(0x13f6, 0xffff), .driver_data
= MODEL_HG2PCI
},
114 /* TempoTec HiFier Fantasia */
115 { OXYGEN_PCI_SUBID(0x14c3, 0x1710), .driver_data
= MODEL_FANTASIA
},
116 /* TempoTec HiFier Serenade */
117 { OXYGEN_PCI_SUBID(0x14c3, 0x1711), .driver_data
= MODEL_SERENADE
},
118 /* AuzenTech X-Meridian */
119 { OXYGEN_PCI_SUBID(0x415a, 0x5431), .driver_data
= MODEL_MERIDIAN
},
120 /* AuzenTech X-Meridian 2G */
121 { OXYGEN_PCI_SUBID(0x5431, 0x017a), .driver_data
= MODEL_MERIDIAN_2G
},
123 { OXYGEN_PCI_SUBID(0x7284, 0x9761), .driver_data
= MODEL_CLARO
},
124 /* HT-Omega Claro halo */
125 { OXYGEN_PCI_SUBID(0x7284, 0x9781), .driver_data
= MODEL_CLARO_HALO
},
128 MODULE_DEVICE_TABLE(pci
, oxygen_ids
);
131 #define GPIO_AK5385_DFS_MASK 0x0003
132 #define GPIO_AK5385_DFS_NORMAL 0x0000
133 #define GPIO_AK5385_DFS_DOUBLE 0x0001
134 #define GPIO_AK5385_DFS_QUAD 0x0002
136 #define GPIO_MERIDIAN_DIG_MASK 0x0050
137 #define GPIO_MERIDIAN_DIG_EXT 0x0010
138 #define GPIO_MERIDIAN_DIG_BOARD 0x0040
140 #define GPIO_CLARO_HP 0x0100
142 struct generic_data
{
144 u8 ak4396_regs
[4][5];
148 static void ak4396_write(struct oxygen
*chip
, unsigned int codec
,
151 /* maps ALSA channel pair number to SPI output */
152 static const u8 codec_spi_map
[4] = {
155 struct generic_data
*data
= chip
->model_data
;
157 oxygen_write_spi(chip
, OXYGEN_SPI_TRIGGER
|
158 OXYGEN_SPI_DATA_LENGTH_2
|
159 OXYGEN_SPI_CLOCK_160
|
160 (codec_spi_map
[codec
] << OXYGEN_SPI_CODEC_SHIFT
) |
161 OXYGEN_SPI_CEN_LATCH_CLOCK_HI
,
162 AK4396_WRITE
| (reg
<< 8) | value
);
163 data
->ak4396_regs
[codec
][reg
] = value
;
166 static void ak4396_write_cached(struct oxygen
*chip
, unsigned int codec
,
169 struct generic_data
*data
= chip
->model_data
;
171 if (value
!= data
->ak4396_regs
[codec
][reg
])
172 ak4396_write(chip
, codec
, reg
, value
);
175 static void wm8785_write(struct oxygen
*chip
, u8 reg
, unsigned int value
)
177 struct generic_data
*data
= chip
->model_data
;
179 oxygen_write_spi(chip
, OXYGEN_SPI_TRIGGER
|
180 OXYGEN_SPI_DATA_LENGTH_2
|
181 OXYGEN_SPI_CLOCK_160
|
182 (3 << OXYGEN_SPI_CODEC_SHIFT
) |
183 OXYGEN_SPI_CEN_LATCH_CLOCK_LO
,
185 if (reg
< ARRAY_SIZE(data
->wm8785_regs
))
186 data
->wm8785_regs
[reg
] = value
;
189 static void ak4396_registers_init(struct oxygen
*chip
)
191 struct generic_data
*data
= chip
->model_data
;
194 for (i
= 0; i
< data
->dacs
; ++i
) {
195 ak4396_write(chip
, i
, AK4396_CONTROL_1
,
196 AK4396_DIF_24_MSB
| AK4396_RSTN
);
197 ak4396_write(chip
, i
, AK4396_CONTROL_2
,
198 data
->ak4396_regs
[0][AK4396_CONTROL_2
]);
199 ak4396_write(chip
, i
, AK4396_CONTROL_3
,
201 ak4396_write(chip
, i
, AK4396_LCH_ATT
,
202 chip
->dac_volume
[i
* 2]);
203 ak4396_write(chip
, i
, AK4396_RCH_ATT
,
204 chip
->dac_volume
[i
* 2 + 1]);
208 static void ak4396_init(struct oxygen
*chip
)
210 struct generic_data
*data
= chip
->model_data
;
212 data
->dacs
= chip
->model
.dac_channels_pcm
/ 2;
213 data
->ak4396_regs
[0][AK4396_CONTROL_2
] =
214 AK4396_SMUTE
| AK4396_DEM_OFF
| AK4396_DFS_NORMAL
;
215 ak4396_registers_init(chip
);
216 snd_component_add(chip
->card
, "AK4396");
219 static void ak5385_init(struct oxygen
*chip
)
221 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_AK5385_DFS_MASK
);
222 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_AK5385_DFS_MASK
);
223 snd_component_add(chip
->card
, "AK5385");
226 static void wm8785_registers_init(struct oxygen
*chip
)
228 struct generic_data
*data
= chip
->model_data
;
230 wm8785_write(chip
, WM8785_R7
, 0);
231 wm8785_write(chip
, WM8785_R0
, data
->wm8785_regs
[0]);
232 wm8785_write(chip
, WM8785_R2
, data
->wm8785_regs
[2]);
235 static void wm8785_init(struct oxygen
*chip
)
237 struct generic_data
*data
= chip
->model_data
;
239 data
->wm8785_regs
[0] =
240 WM8785_MCR_SLAVE
| WM8785_OSR_SINGLE
| WM8785_FORMAT_LJUST
;
241 data
->wm8785_regs
[2] = WM8785_HPFR
| WM8785_HPFL
;
242 wm8785_registers_init(chip
);
243 snd_component_add(chip
->card
, "WM8785");
246 static void generic_init(struct oxygen
*chip
)
252 static void meridian_init(struct oxygen
*chip
)
254 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
,
255 GPIO_MERIDIAN_DIG_MASK
);
256 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
257 GPIO_MERIDIAN_DIG_BOARD
, GPIO_MERIDIAN_DIG_MASK
);
262 static void claro_enable_hp(struct oxygen
*chip
)
265 oxygen_set_bits16(chip
, OXYGEN_GPIO_CONTROL
, GPIO_CLARO_HP
);
266 oxygen_set_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_CLARO_HP
);
269 static void claro_init(struct oxygen
*chip
)
273 claro_enable_hp(chip
);
276 static void claro_halo_init(struct oxygen
*chip
)
280 claro_enable_hp(chip
);
283 static void fantasia_init(struct oxygen
*chip
)
286 snd_component_add(chip
->card
, "CS5340");
289 static void stereo_output_init(struct oxygen
*chip
)
294 static void generic_cleanup(struct oxygen
*chip
)
298 static void claro_disable_hp(struct oxygen
*chip
)
300 oxygen_clear_bits16(chip
, OXYGEN_GPIO_DATA
, GPIO_CLARO_HP
);
303 static void claro_cleanup(struct oxygen
*chip
)
305 claro_disable_hp(chip
);
308 static void claro_suspend(struct oxygen
*chip
)
310 claro_disable_hp(chip
);
313 static void generic_resume(struct oxygen
*chip
)
315 ak4396_registers_init(chip
);
316 wm8785_registers_init(chip
);
319 static void meridian_resume(struct oxygen
*chip
)
321 ak4396_registers_init(chip
);
324 static void claro_resume(struct oxygen
*chip
)
326 ak4396_registers_init(chip
);
327 claro_enable_hp(chip
);
330 static void stereo_resume(struct oxygen
*chip
)
332 ak4396_registers_init(chip
);
335 static void set_ak4396_params(struct oxygen
*chip
,
336 struct snd_pcm_hw_params
*params
)
338 struct generic_data
*data
= chip
->model_data
;
342 value
= data
->ak4396_regs
[0][AK4396_CONTROL_2
] & ~AK4396_DFS_MASK
;
343 if (params_rate(params
) <= 54000)
344 value
|= AK4396_DFS_NORMAL
;
345 else if (params_rate(params
) <= 108000)
346 value
|= AK4396_DFS_DOUBLE
;
348 value
|= AK4396_DFS_QUAD
;
350 msleep(1); /* wait for the new MCLK to become stable */
352 if (value
!= data
->ak4396_regs
[0][AK4396_CONTROL_2
]) {
353 for (i
= 0; i
< data
->dacs
; ++i
) {
354 ak4396_write(chip
, i
, AK4396_CONTROL_1
,
356 ak4396_write(chip
, i
, AK4396_CONTROL_2
, value
);
357 ak4396_write(chip
, i
, AK4396_CONTROL_1
,
358 AK4396_DIF_24_MSB
| AK4396_RSTN
);
363 static void update_ak4396_volume(struct oxygen
*chip
)
365 struct generic_data
*data
= chip
->model_data
;
368 for (i
= 0; i
< data
->dacs
; ++i
) {
369 ak4396_write_cached(chip
, i
, AK4396_LCH_ATT
,
370 chip
->dac_volume
[i
* 2]);
371 ak4396_write_cached(chip
, i
, AK4396_RCH_ATT
,
372 chip
->dac_volume
[i
* 2 + 1]);
376 static void update_ak4396_mute(struct oxygen
*chip
)
378 struct generic_data
*data
= chip
->model_data
;
382 value
= data
->ak4396_regs
[0][AK4396_CONTROL_2
] & ~AK4396_SMUTE
;
384 value
|= AK4396_SMUTE
;
385 for (i
= 0; i
< data
->dacs
; ++i
)
386 ak4396_write_cached(chip
, i
, AK4396_CONTROL_2
, value
);
389 static void set_wm8785_params(struct oxygen
*chip
,
390 struct snd_pcm_hw_params
*params
)
392 struct generic_data
*data
= chip
->model_data
;
395 value
= WM8785_MCR_SLAVE
| WM8785_FORMAT_LJUST
;
396 if (params_rate(params
) <= 48000)
397 value
|= WM8785_OSR_SINGLE
;
398 else if (params_rate(params
) <= 96000)
399 value
|= WM8785_OSR_DOUBLE
;
401 value
|= WM8785_OSR_QUAD
;
402 if (value
!= data
->wm8785_regs
[0]) {
403 wm8785_write(chip
, WM8785_R7
, 0);
404 wm8785_write(chip
, WM8785_R0
, value
);
405 wm8785_write(chip
, WM8785_R2
, data
->wm8785_regs
[2]);
409 static void set_ak5385_params(struct oxygen
*chip
,
410 struct snd_pcm_hw_params
*params
)
414 if (params_rate(params
) <= 54000)
415 value
= GPIO_AK5385_DFS_NORMAL
;
416 else if (params_rate(params
) <= 108000)
417 value
= GPIO_AK5385_DFS_DOUBLE
;
419 value
= GPIO_AK5385_DFS_QUAD
;
420 oxygen_write16_masked(chip
, OXYGEN_GPIO_DATA
,
421 value
, GPIO_AK5385_DFS_MASK
);
424 static void set_no_params(struct oxygen
*chip
, struct snd_pcm_hw_params
*params
)
428 static int rolloff_info(struct snd_kcontrol
*ctl
,
429 struct snd_ctl_elem_info
*info
)
431 static const char *const names
[2] = {
432 "Sharp Roll-off", "Slow Roll-off"
435 return snd_ctl_enum_info(info
, 1, 2, names
);
438 static int rolloff_get(struct snd_kcontrol
*ctl
,
439 struct snd_ctl_elem_value
*value
)
441 struct oxygen
*chip
= ctl
->private_data
;
442 struct generic_data
*data
= chip
->model_data
;
444 value
->value
.enumerated
.item
[0] =
445 (data
->ak4396_regs
[0][AK4396_CONTROL_2
] & AK4396_SLOW
) != 0;
449 static int rolloff_put(struct snd_kcontrol
*ctl
,
450 struct snd_ctl_elem_value
*value
)
452 struct oxygen
*chip
= ctl
->private_data
;
453 struct generic_data
*data
= chip
->model_data
;
458 mutex_lock(&chip
->mutex
);
459 reg
= data
->ak4396_regs
[0][AK4396_CONTROL_2
];
460 if (value
->value
.enumerated
.item
[0])
464 changed
= reg
!= data
->ak4396_regs
[0][AK4396_CONTROL_2
];
466 for (i
= 0; i
< data
->dacs
; ++i
)
467 ak4396_write(chip
, i
, AK4396_CONTROL_2
, reg
);
469 mutex_unlock(&chip
->mutex
);
473 static const struct snd_kcontrol_new rolloff_control
= {
474 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
475 .name
= "DAC Filter Playback Enum",
476 .info
= rolloff_info
,
481 static int hpf_info(struct snd_kcontrol
*ctl
, struct snd_ctl_elem_info
*info
)
483 static const char *const names
[2] = {
484 "None", "High-pass Filter"
487 return snd_ctl_enum_info(info
, 1, 2, names
);
490 static int hpf_get(struct snd_kcontrol
*ctl
, struct snd_ctl_elem_value
*value
)
492 struct oxygen
*chip
= ctl
->private_data
;
493 struct generic_data
*data
= chip
->model_data
;
495 value
->value
.enumerated
.item
[0] =
496 (data
->wm8785_regs
[WM8785_R2
] & WM8785_HPFR
) != 0;
500 static int hpf_put(struct snd_kcontrol
*ctl
, struct snd_ctl_elem_value
*value
)
502 struct oxygen
*chip
= ctl
->private_data
;
503 struct generic_data
*data
= chip
->model_data
;
507 mutex_lock(&chip
->mutex
);
508 reg
= data
->wm8785_regs
[WM8785_R2
] & ~(WM8785_HPFR
| WM8785_HPFL
);
509 if (value
->value
.enumerated
.item
[0])
510 reg
|= WM8785_HPFR
| WM8785_HPFL
;
511 changed
= reg
!= data
->wm8785_regs
[WM8785_R2
];
513 wm8785_write(chip
, WM8785_R2
, reg
);
514 mutex_unlock(&chip
->mutex
);
518 static const struct snd_kcontrol_new hpf_control
= {
519 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
520 .name
= "ADC Filter Capture Enum",
526 static int meridian_dig_source_info(struct snd_kcontrol
*ctl
, struct snd_ctl_elem_info
*info
)
528 static const char *const names
[2] = { "On-board", "Extension" };
530 return snd_ctl_enum_info(info
, 1, 2, names
);
533 static int meridian_dig_source_get(struct snd_kcontrol
*ctl
, struct snd_ctl_elem_value
*value
)
535 struct oxygen
*chip
= ctl
->private_data
;
537 value
->value
.enumerated
.item
[0] =
538 !!(oxygen_read16(chip
, OXYGEN_GPIO_DATA
) &
539 GPIO_MERIDIAN_DIG_EXT
);
543 static int meridian_dig_source_put(struct snd_kcontrol
*ctl
, struct snd_ctl_elem_value
*value
)
545 struct oxygen
*chip
= ctl
->private_data
;
546 u16 old_reg
, new_reg
;
549 mutex_lock(&chip
->mutex
);
550 old_reg
= oxygen_read16(chip
, OXYGEN_GPIO_DATA
);
551 new_reg
= old_reg
& ~GPIO_MERIDIAN_DIG_MASK
;
552 if (value
->value
.enumerated
.item
[0] == 0)
553 new_reg
|= GPIO_MERIDIAN_DIG_BOARD
;
555 new_reg
|= GPIO_MERIDIAN_DIG_EXT
;
556 changed
= new_reg
!= old_reg
;
558 oxygen_write16(chip
, OXYGEN_GPIO_DATA
, new_reg
);
559 mutex_unlock(&chip
->mutex
);
563 static const struct snd_kcontrol_new meridian_dig_source_control
= {
564 .iface
= SNDRV_CTL_ELEM_IFACE_MIXER
,
565 .name
= "IEC958 Source Capture Enum",
566 .info
= meridian_dig_source_info
,
567 .get
= meridian_dig_source_get
,
568 .put
= meridian_dig_source_put
,
571 static int generic_mixer_init(struct oxygen
*chip
)
573 return snd_ctl_add(chip
->card
, snd_ctl_new1(&rolloff_control
, chip
));
576 static int generic_wm8785_mixer_init(struct oxygen
*chip
)
580 err
= generic_mixer_init(chip
);
583 err
= snd_ctl_add(chip
->card
, snd_ctl_new1(&hpf_control
, chip
));
589 static int meridian_mixer_init(struct oxygen
*chip
)
593 err
= generic_mixer_init(chip
);
596 err
= snd_ctl_add(chip
->card
,
597 snd_ctl_new1(&meridian_dig_source_control
, chip
));
603 static void dump_ak4396_registers(struct oxygen
*chip
,
604 struct snd_info_buffer
*buffer
)
606 struct generic_data
*data
= chip
->model_data
;
609 for (dac
= 0; dac
< data
->dacs
; ++dac
) {
610 snd_iprintf(buffer
, "\nAK4396 %u:", dac
+ 1);
611 for (i
= 0; i
< 5; ++i
)
612 snd_iprintf(buffer
, " %02x", data
->ak4396_regs
[dac
][i
]);
614 snd_iprintf(buffer
, "\n");
617 static void dump_wm8785_registers(struct oxygen
*chip
,
618 struct snd_info_buffer
*buffer
)
620 struct generic_data
*data
= chip
->model_data
;
623 snd_iprintf(buffer
, "\nWM8785:");
624 for (i
= 0; i
< 3; ++i
)
625 snd_iprintf(buffer
, " %03x", data
->wm8785_regs
[i
]);
626 snd_iprintf(buffer
, "\n");
629 static void dump_oxygen_registers(struct oxygen
*chip
,
630 struct snd_info_buffer
*buffer
)
632 dump_ak4396_registers(chip
, buffer
);
633 dump_wm8785_registers(chip
, buffer
);
636 static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale
, TLV_DB_GAIN_MUTE
, 0);
638 static const struct oxygen_model model_generic
= {
639 .shortname
= "C-Media CMI8788",
640 .longname
= "C-Media Oxygen HD Audio",
642 .init
= generic_init
,
643 .mixer_init
= generic_wm8785_mixer_init
,
644 .cleanup
= generic_cleanup
,
645 .resume
= generic_resume
,
646 .set_dac_params
= set_ak4396_params
,
647 .set_adc_params
= set_wm8785_params
,
648 .update_dac_volume
= update_ak4396_volume
,
649 .update_dac_mute
= update_ak4396_mute
,
650 .dump_registers
= dump_oxygen_registers
,
651 .dac_tlv
= ak4396_db_scale
,
652 .model_data_size
= sizeof(struct generic_data
),
653 .device_config
= PLAYBACK_0_TO_I2S
|
654 PLAYBACK_1_TO_SPDIF
|
655 PLAYBACK_2_TO_AC97_1
|
656 CAPTURE_0_FROM_I2S_1
|
657 CAPTURE_1_FROM_SPDIF
|
658 CAPTURE_2_FROM_AC97_1
|
660 .dac_channels_pcm
= 8,
661 .dac_channels_mixer
= 8,
663 .dac_volume_max
= 255,
664 .function_flags
= OXYGEN_FUNCTION_SPI
|
665 OXYGEN_FUNCTION_ENABLE_SPI_4_5
,
666 .dac_mclks
= OXYGEN_MCLKS(256, 128, 128),
667 .adc_mclks
= OXYGEN_MCLKS(256, 256, 128),
668 .dac_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
669 .adc_i2s_format
= OXYGEN_I2S_FORMAT_LJUST
,
672 static int __devinit
get_oxygen_model(struct oxygen
*chip
,
673 const struct pci_device_id
*id
)
675 static const char *const names
[] = {
676 [MODEL_MERIDIAN
] = "AuzenTech X-Meridian",
677 [MODEL_MERIDIAN_2G
] = "AuzenTech X-Meridian 2G",
678 [MODEL_CLARO
] = "HT-Omega Claro",
679 [MODEL_CLARO_HALO
] = "HT-Omega Claro halo",
680 [MODEL_FANTASIA
] = "TempoTec HiFier Fantasia",
681 [MODEL_SERENADE
] = "TempoTec HiFier Serenade",
682 [MODEL_HG2PCI
] = "CMI8787-HG2PCI",
685 chip
->model
= model_generic
;
686 switch (id
->driver_data
) {
688 case MODEL_MERIDIAN_2G
:
689 chip
->model
.init
= meridian_init
;
690 chip
->model
.mixer_init
= meridian_mixer_init
;
691 chip
->model
.resume
= meridian_resume
;
692 chip
->model
.set_adc_params
= set_ak5385_params
;
693 chip
->model
.dump_registers
= dump_ak4396_registers
;
694 chip
->model
.device_config
= PLAYBACK_0_TO_I2S
|
695 PLAYBACK_1_TO_SPDIF
|
696 CAPTURE_0_FROM_I2S_2
|
697 CAPTURE_1_FROM_SPDIF
;
698 if (id
->driver_data
== MODEL_MERIDIAN
)
699 chip
->model
.device_config
|= AC97_CD_INPUT
;
702 chip
->model
.init
= claro_init
;
703 chip
->model
.cleanup
= claro_cleanup
;
704 chip
->model
.suspend
= claro_suspend
;
705 chip
->model
.resume
= claro_resume
;
707 case MODEL_CLARO_HALO
:
708 chip
->model
.init
= claro_halo_init
;
709 chip
->model
.mixer_init
= generic_mixer_init
;
710 chip
->model
.cleanup
= claro_cleanup
;
711 chip
->model
.suspend
= claro_suspend
;
712 chip
->model
.resume
= claro_resume
;
713 chip
->model
.set_adc_params
= set_ak5385_params
;
714 chip
->model
.dump_registers
= dump_ak4396_registers
;
715 chip
->model
.device_config
= PLAYBACK_0_TO_I2S
|
716 PLAYBACK_1_TO_SPDIF
|
717 CAPTURE_0_FROM_I2S_2
|
718 CAPTURE_1_FROM_SPDIF
;
722 case MODEL_2CH_OUTPUT
:
724 chip
->model
.shortname
= "C-Media CMI8787";
725 chip
->model
.chip
= "CMI8787";
726 if (id
->driver_data
== MODEL_FANTASIA
)
727 chip
->model
.init
= fantasia_init
;
729 chip
->model
.init
= stereo_output_init
;
730 chip
->model
.resume
= stereo_resume
;
731 chip
->model
.mixer_init
= generic_mixer_init
;
732 chip
->model
.set_adc_params
= set_no_params
;
733 chip
->model
.dump_registers
= dump_ak4396_registers
;
734 chip
->model
.device_config
= PLAYBACK_0_TO_I2S
|
736 if (id
->driver_data
== MODEL_FANTASIA
) {
737 chip
->model
.device_config
|= CAPTURE_0_FROM_I2S_1
;
738 chip
->model
.adc_mclks
= OXYGEN_MCLKS(256, 128, 128);
740 chip
->model
.dac_channels_pcm
= 2;
741 chip
->model
.dac_channels_mixer
= 2;
744 chip
->model
= model_xonar_dg
;
747 if (id
->driver_data
== MODEL_MERIDIAN
||
748 id
->driver_data
== MODEL_MERIDIAN_2G
||
749 id
->driver_data
== MODEL_CLARO_HALO
) {
750 chip
->model
.misc_flags
= OXYGEN_MISC_MIDI
;
751 chip
->model
.device_config
|= MIDI_OUTPUT
| MIDI_INPUT
;
753 if (id
->driver_data
< ARRAY_SIZE(names
) && names
[id
->driver_data
])
754 chip
->model
.shortname
= names
[id
->driver_data
];
758 static int __devinit
generic_oxygen_probe(struct pci_dev
*pci
,
759 const struct pci_device_id
*pci_id
)
764 if (dev
>= SNDRV_CARDS
)
770 err
= oxygen_pci_probe(pci
, index
[dev
], id
[dev
], THIS_MODULE
,
771 oxygen_ids
, get_oxygen_model
);
777 static struct pci_driver oxygen_driver
= {
779 .id_table
= oxygen_ids
,
780 .probe
= generic_oxygen_probe
,
781 .remove
= __devexit_p(oxygen_pci_remove
),
783 .suspend
= oxygen_pci_suspend
,
784 .resume
= oxygen_pci_resume
,
788 static int __init
alsa_card_oxygen_init(void)
790 return pci_register_driver(&oxygen_driver
);
793 static void __exit
alsa_card_oxygen_exit(void)
795 pci_unregister_driver(&oxygen_driver
);
798 module_init(alsa_card_oxygen_init
)
799 module_exit(alsa_card_oxygen_exit
)