Commit | Line | Data |
---|---|---|
1b8ff22f CL |
1 | /* |
2 | * C-Media CMI8788 driver for Asus Xonar cards | |
3 | * | |
4 | * Copyright (c) Clemens Ladisch <clemens@ladisch.de> | |
5 | * | |
6 | * | |
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. | |
9 | * | |
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. | |
14 | * | |
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 | |
18 | */ | |
19 | ||
20 | /* | |
a9d3cc48 CL |
21 | * Xonar D2/D2X |
22 | * ------------ | |
23 | * | |
878ac3ee CL |
24 | * CMI8788: |
25 | * | |
1b8ff22f | 26 | * SPI 0 -> 1st PCM1796 (front) |
7113e958 | 27 | * SPI 1 -> 2nd PCM1796 (surround) |
1b8ff22f | 28 | * SPI 2 -> 3rd PCM1796 (center/LFE) |
6ce6c473 | 29 | * SPI 4 -> 4th PCM1796 (back) |
1b8ff22f CL |
30 | * |
31 | * GPIO 2 -> M0 of CS5381 | |
32 | * GPIO 3 -> M1 of CS5381 | |
878ac3ee | 33 | * GPIO 5 <- external power present (D2X only) |
1b8ff22f | 34 | * GPIO 7 -> ALT |
878ac3ee | 35 | * GPIO 8 -> enable output to speakers |
1b8ff22f CL |
36 | */ |
37 | ||
a9d3cc48 | 38 | /* |
5430c72b CL |
39 | * Xonar D1/DX |
40 | * ----------- | |
a9d3cc48 CL |
41 | * |
42 | * CMI8788: | |
43 | * | |
44 | * I²C <-> CS4398 (front) | |
45 | * <-> CS4362A (surround, center/LFE, back) | |
46 | * | |
5430c72b | 47 | * GPI 0 <- external power present (DX only) |
a9d3cc48 CL |
48 | * |
49 | * GPIO 0 -> enable output to speakers | |
a8bb1bad | 50 | * GPIO 1 -> enable front panel I/O |
a9d3cc48 CL |
51 | * GPIO 2 -> M0 of CS5361 |
52 | * GPIO 3 -> M1 of CS5361 | |
11864b4b | 53 | * GPIO 8 -> route input jack to line-in (0) or mic-in (1) |
a9d3cc48 CL |
54 | * |
55 | * CS4398: | |
56 | * | |
57 | * AD0 <- 1 | |
58 | * AD1 <- 1 | |
59 | * | |
60 | * CS4362A: | |
61 | * | |
62 | * AD0 <- 0 | |
63 | */ | |
64 | ||
7407a2e4 CL |
65 | /* |
66 | * Xonar HDAV1.3 (Deluxe) | |
67 | * ---------------------- | |
68 | * | |
69 | * CMI8788: | |
70 | * | |
71 | * I²C <-> PCM1796 (front) | |
72 | * | |
73 | * GPI 0 <- external power present | |
74 | * | |
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) | |
79 | * | |
80 | * TXD -> HDMI controller | |
81 | * RXD <- HDMI controller | |
82 | * | |
83 | * PCM1796 front: AD1,0 <- 0,0 | |
84 | * | |
85 | * no daughterboard | |
86 | * ---------------- | |
87 | * | |
88 | * GPIO 4 <- 1 | |
89 | * | |
90 | * H6 daughterboard | |
91 | * ---------------- | |
92 | * | |
93 | * GPIO 4 <- 0 | |
94 | * GPIO 5 <- 0 | |
95 | * | |
96 | * I²C <-> PCM1796 (surround) | |
97 | * <-> PCM1796 (center/LFE) | |
98 | * <-> PCM1796 (back) | |
99 | * | |
100 | * PCM1796 surround: AD1,0 <- 0,1 | |
101 | * PCM1796 center/LFE: AD1,0 <- 1,0 | |
102 | * PCM1796 back: AD1,0 <- 1,1 | |
103 | * | |
104 | * unknown daughterboard | |
105 | * --------------------- | |
106 | * | |
107 | * GPIO 4 <- 0 | |
108 | * GPIO 5 <- 1 | |
109 | * | |
110 | * I²C <-> CS4362A (surround, center/LFE, back) | |
111 | * | |
112 | * CS4362A: AD0 <- 0 | |
113 | */ | |
114 | ||
930738de | 115 | /* |
04f9890d CL |
116 | * Xonar Essence ST (Deluxe)/STX |
117 | * ----------------------------- | |
930738de CL |
118 | * |
119 | * CMI8788: | |
120 | * | |
121 | * I²C <-> PCM1792A | |
122 | * | |
123 | * GPI 0 <- external power present | |
124 | * | |
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) | |
131 | * | |
132 | * PCM1792A: | |
133 | * | |
134 | * AD0 <- 0 | |
135 | * | |
136 | * H6 daughterboard | |
137 | * ---------------- | |
138 | * | |
139 | * GPIO 4 <- 0 | |
140 | * GPIO 5 <- 0 | |
141 | */ | |
142 | ||
1b8ff22f CL |
143 | #include <linux/pci.h> |
144 | #include <linux/delay.h> | |
ccc80fb4 CL |
145 | #include <linux/mutex.h> |
146 | #include <sound/ac97_codec.h> | |
7407a2e4 | 147 | #include <sound/asoundef.h> |
1b8ff22f CL |
148 | #include <sound/control.h> |
149 | #include <sound/core.h> | |
150 | #include <sound/initval.h> | |
151 | #include <sound/pcm.h> | |
7407a2e4 | 152 | #include <sound/pcm_params.h> |
1b8ff22f CL |
153 | #include <sound/tlv.h> |
154 | #include "oxygen.h" | |
878ac3ee | 155 | #include "cm9780.h" |
33fa724e | 156 | #include "pcm1796.h" |
a9d3cc48 CL |
157 | #include "cs4398.h" |
158 | #include "cs4362a.h" | |
1b8ff22f CL |
159 | |
160 | MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); | |
a9d3cc48 | 161 | MODULE_DESCRIPTION("Asus AVx00 driver"); |
d023dc0a | 162 | MODULE_LICENSE("GPL v2"); |
a9d3cc48 | 163 | MODULE_SUPPORTED_DEVICE("{{Asus,AV100},{Asus,AV200}}"); |
1b8ff22f CL |
164 | |
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; | |
168 | ||
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"); | |
175 | ||
271ebfca CL |
176 | enum { |
177 | MODEL_D2, | |
178 | MODEL_D2X, | |
5430c72b | 179 | MODEL_D1, |
a9d3cc48 | 180 | MODEL_DX, |
7407a2e4 CL |
181 | MODEL_HDAV, /* without daughterboard */ |
182 | MODEL_HDAV_H6, /* with H6 daughterboard */ | |
04f9890d CL |
183 | MODEL_ST, |
184 | MODEL_ST_H6, | |
930738de | 185 | MODEL_STX, |
271ebfca CL |
186 | }; |
187 | ||
1b8ff22f | 188 | static struct pci_device_id xonar_ids[] __devinitdata = { |
271ebfca | 189 | { OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data = MODEL_D2 }, |
a9d3cc48 | 190 | { OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data = MODEL_DX }, |
271ebfca | 191 | { OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data = MODEL_D2X }, |
7407a2e4 | 192 | { OXYGEN_PCI_SUBID(0x1043, 0x8314), .driver_data = MODEL_HDAV }, |
53bb705d | 193 | { OXYGEN_PCI_SUBID(0x1043, 0x8327), .driver_data = MODEL_DX }, |
5430c72b | 194 | { OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data = MODEL_D1 }, |
930738de | 195 | { OXYGEN_PCI_SUBID(0x1043, 0x835c), .driver_data = MODEL_STX }, |
04f9890d | 196 | { OXYGEN_PCI_SUBID(0x1043, 0x835d), .driver_data = MODEL_ST }, |
30459d7b | 197 | { OXYGEN_PCI_SUBID_BROKEN_EEPROM }, |
1b8ff22f CL |
198 | { } |
199 | }; | |
200 | MODULE_DEVICE_TABLE(pci, xonar_ids); | |
201 | ||
878ac3ee | 202 | |
a694a6a0 CL |
203 | #define GPIO_CS53x1_M_MASK 0x000c |
204 | #define GPIO_CS53x1_M_SINGLE 0x0000 | |
205 | #define GPIO_CS53x1_M_DOUBLE 0x0004 | |
206 | #define GPIO_CS53x1_M_QUAD 0x0008 | |
207 | ||
af9af174 CL |
208 | #define GPIO_D2X_EXT_POWER 0x0020 |
209 | #define GPIO_D2_ALT 0x0080 | |
210 | #define GPIO_D2_OUTPUT_ENABLE 0x0100 | |
878ac3ee | 211 | |
a9d3cc48 CL |
212 | #define GPI_DX_EXT_POWER 0x01 |
213 | #define GPIO_DX_OUTPUT_ENABLE 0x0001 | |
a8bb1bad | 214 | #define GPIO_DX_FRONT_PANEL 0x0002 |
11864b4b | 215 | #define GPIO_DX_INPUT_ROUTE 0x0100 |
a9d3cc48 | 216 | |
04f9890d CL |
217 | #define GPIO_DB_MASK 0x0030 |
218 | #define GPIO_DB_H6 0x0000 | |
219 | #define GPIO_DB_XX 0x0020 | |
7407a2e4 | 220 | |
930738de CL |
221 | #define GPIO_ST_HP_REAR 0x0002 |
222 | #define GPIO_ST_HP 0x0080 | |
223 | ||
4f50d2fd | 224 | #define I2C_DEVICE_PCM1796(i) (0x98 + ((i) << 1)) /* 10011, ADx=i, /W=0 */ |
a9d3cc48 CL |
225 | #define I2C_DEVICE_CS4398 0x9e /* 10011, AD1=1, AD0=1, /W=0 */ |
226 | #define I2C_DEVICE_CS4362A 0x30 /* 001100, AD0=0, /W=0 */ | |
227 | ||
7c014159 | 228 | struct xonar_data { |
af9af174 | 229 | unsigned int anti_pop_delay; |
70c27d34 | 230 | unsigned int dacs; |
af9af174 CL |
231 | u16 output_enable_bit; |
232 | u8 ext_power_reg; | |
233 | u8 ext_power_int_reg; | |
234 | u8 ext_power_bit; | |
7c014159 | 235 | u8 has_power; |
e58aee95 CL |
236 | u8 pcm1796_oversampling; |
237 | u8 cs4398_fm; | |
238 | u8 cs4362a_fm; | |
7407a2e4 | 239 | u8 hdmi_params[5]; |
7c014159 CL |
240 | }; |
241 | ||
fe10662c CL |
242 | static void xonar_gpio_changed(struct oxygen *chip); |
243 | ||
4f50d2fd CL |
244 | static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec, |
245 | u8 reg, u8 value) | |
1b8ff22f CL |
246 | { |
247 | /* maps ALSA channel pair number to SPI output */ | |
248 | static const u8 codec_map[4] = { | |
7113e958 | 249 | 0, 1, 2, 4 |
1b8ff22f | 250 | }; |
c2353a08 | 251 | oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER | |
1b8ff22f | 252 | OXYGEN_SPI_DATA_LENGTH_2 | |
c2353a08 | 253 | OXYGEN_SPI_CLOCK_160 | |
1b8ff22f | 254 | (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) | |
c2353a08 | 255 | OXYGEN_SPI_CEN_LATCH_CLOCK_HI, |
1b8ff22f CL |
256 | (reg << 8) | value); |
257 | } | |
258 | ||
4f50d2fd CL |
259 | static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec, |
260 | u8 reg, u8 value) | |
261 | { | |
262 | oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value); | |
263 | } | |
264 | ||
265 | static void pcm1796_write(struct oxygen *chip, unsigned int codec, | |
266 | u8 reg, u8 value) | |
267 | { | |
268 | if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) == | |
269 | OXYGEN_FUNCTION_SPI) | |
270 | pcm1796_write_spi(chip, codec, reg, value); | |
271 | else | |
272 | pcm1796_write_i2c(chip, codec, reg, value); | |
273 | } | |
274 | ||
a9d3cc48 CL |
275 | static void cs4398_write(struct oxygen *chip, u8 reg, u8 value) |
276 | { | |
277 | oxygen_write_i2c(chip, I2C_DEVICE_CS4398, reg, value); | |
278 | } | |
279 | ||
280 | static void cs4362a_write(struct oxygen *chip, u8 reg, u8 value) | |
281 | { | |
282 | oxygen_write_i2c(chip, I2C_DEVICE_CS4362A, reg, value); | |
283 | } | |
284 | ||
7407a2e4 CL |
285 | static void hdmi_write_command(struct oxygen *chip, u8 command, |
286 | unsigned int count, const u8 *params) | |
287 | { | |
288 | unsigned int i; | |
289 | u8 checksum; | |
290 | ||
291 | oxygen_write_uart(chip, 0xfb); | |
292 | oxygen_write_uart(chip, 0xef); | |
293 | oxygen_write_uart(chip, command); | |
294 | oxygen_write_uart(chip, count); | |
295 | for (i = 0; i < count; ++i) | |
296 | oxygen_write_uart(chip, params[i]); | |
297 | checksum = 0xfb + 0xef + command + count; | |
298 | for (i = 0; i < count; ++i) | |
299 | checksum += params[i]; | |
300 | oxygen_write_uart(chip, checksum); | |
301 | } | |
302 | ||
92215f3a CL |
303 | static void xonar_enable_output(struct oxygen *chip) |
304 | { | |
305 | struct xonar_data *data = chip->model_data; | |
306 | ||
307 | msleep(data->anti_pop_delay); | |
308 | oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit); | |
309 | } | |
310 | ||
af9af174 CL |
311 | static void xonar_common_init(struct oxygen *chip) |
312 | { | |
313 | struct xonar_data *data = chip->model_data; | |
314 | ||
315 | if (data->ext_power_reg) { | |
316 | oxygen_set_bits8(chip, data->ext_power_int_reg, | |
317 | data->ext_power_bit); | |
318 | chip->interrupt_mask |= OXYGEN_INT_GPIO; | |
fe10662c | 319 | chip->model.gpio_changed = xonar_gpio_changed; |
af9af174 CL |
320 | data->has_power = !!(oxygen_read8(chip, data->ext_power_reg) |
321 | & data->ext_power_bit); | |
322 | } | |
92215f3a CL |
323 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, |
324 | GPIO_CS53x1_M_MASK | data->output_enable_bit); | |
af9af174 CL |
325 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, |
326 | GPIO_CS53x1_M_SINGLE, GPIO_CS53x1_M_MASK); | |
327 | oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC); | |
92215f3a | 328 | xonar_enable_output(chip); |
af9af174 CL |
329 | } |
330 | ||
bbbfb552 CL |
331 | static void update_pcm1796_volume(struct oxygen *chip) |
332 | { | |
70c27d34 | 333 | struct xonar_data *data = chip->model_data; |
bbbfb552 CL |
334 | unsigned int i; |
335 | ||
70c27d34 | 336 | for (i = 0; i < data->dacs; ++i) { |
bbbfb552 CL |
337 | pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]); |
338 | pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]); | |
339 | } | |
340 | } | |
341 | ||
342 | static void update_pcm1796_mute(struct oxygen *chip) | |
343 | { | |
70c27d34 | 344 | struct xonar_data *data = chip->model_data; |
bbbfb552 CL |
345 | unsigned int i; |
346 | u8 value; | |
347 | ||
348 | value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD; | |
349 | if (chip->dac_mute) | |
350 | value |= PCM1796_MUTE; | |
70c27d34 | 351 | for (i = 0; i < data->dacs; ++i) |
bbbfb552 CL |
352 | pcm1796_write(chip, i, 18, value); |
353 | } | |
354 | ||
75146fc0 | 355 | static void pcm1796_init(struct oxygen *chip) |
1b8ff22f | 356 | { |
af9af174 | 357 | struct xonar_data *data = chip->model_data; |
1b8ff22f CL |
358 | unsigned int i; |
359 | ||
70c27d34 | 360 | for (i = 0; i < data->dacs; ++i) { |
878ac3ee | 361 | pcm1796_write(chip, i, 19, PCM1796_FLT_SHARP | PCM1796_ATS_1); |
e58aee95 | 362 | pcm1796_write(chip, i, 20, data->pcm1796_oversampling); |
878ac3ee | 363 | pcm1796_write(chip, i, 21, 0); |
1b8ff22f | 364 | } |
bbbfb552 CL |
365 | update_pcm1796_mute(chip); /* set ATLD before ATL/ATR */ |
366 | update_pcm1796_volume(chip); | |
75146fc0 CL |
367 | } |
368 | ||
369 | static void xonar_d2_init(struct oxygen *chip) | |
370 | { | |
371 | struct xonar_data *data = chip->model_data; | |
372 | ||
373 | data->anti_pop_delay = 300; | |
30459d7b | 374 | data->dacs = 4; |
75146fc0 CL |
375 | data->output_enable_bit = GPIO_D2_OUTPUT_ENABLE; |
376 | data->pcm1796_oversampling = PCM1796_OS_64; | |
377 | ||
378 | pcm1796_init(chip); | |
1b8ff22f | 379 | |
af9af174 CL |
380 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT); |
381 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT); | |
382 | ||
383 | xonar_common_init(chip); | |
1b8ff22f CL |
384 | |
385 | snd_component_add(chip->card, "PCM1796"); | |
386 | snd_component_add(chip->card, "CS5381"); | |
387 | } | |
388 | ||
30459d7b CL |
389 | static void xonar_d2x_init(struct oxygen *chip) |
390 | { | |
391 | struct xonar_data *data = chip->model_data; | |
392 | ||
393 | data->ext_power_reg = OXYGEN_GPIO_DATA; | |
394 | data->ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK; | |
395 | data->ext_power_bit = GPIO_D2X_EXT_POWER; | |
396 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER); | |
397 | ||
398 | xonar_d2_init(chip); | |
399 | } | |
400 | ||
bbbfb552 CL |
401 | static void update_cs4362a_volumes(struct oxygen *chip) |
402 | { | |
403 | u8 mute; | |
404 | ||
405 | mute = chip->dac_mute ? CS4362A_MUTE : 0; | |
406 | cs4362a_write(chip, 7, (127 - chip->dac_volume[2]) | mute); | |
407 | cs4362a_write(chip, 8, (127 - chip->dac_volume[3]) | mute); | |
408 | cs4362a_write(chip, 10, (127 - chip->dac_volume[4]) | mute); | |
409 | cs4362a_write(chip, 11, (127 - chip->dac_volume[5]) | mute); | |
410 | cs4362a_write(chip, 13, (127 - chip->dac_volume[6]) | mute); | |
411 | cs4362a_write(chip, 14, (127 - chip->dac_volume[7]) | mute); | |
412 | } | |
413 | ||
414 | static void update_cs43xx_volume(struct oxygen *chip) | |
415 | { | |
416 | cs4398_write(chip, 5, (127 - chip->dac_volume[0]) * 2); | |
417 | cs4398_write(chip, 6, (127 - chip->dac_volume[1]) * 2); | |
418 | update_cs4362a_volumes(chip); | |
419 | } | |
420 | ||
421 | static void update_cs43xx_mute(struct oxygen *chip) | |
422 | { | |
423 | u8 reg; | |
424 | ||
425 | reg = CS4398_MUTEP_LOW | CS4398_PAMUTE; | |
426 | if (chip->dac_mute) | |
427 | reg |= CS4398_MUTE_B | CS4398_MUTE_A; | |
428 | cs4398_write(chip, 4, reg); | |
429 | update_cs4362a_volumes(chip); | |
430 | } | |
431 | ||
75146fc0 | 432 | static void cs43xx_init(struct oxygen *chip) |
a9d3cc48 CL |
433 | { |
434 | struct xonar_data *data = chip->model_data; | |
a9d3cc48 | 435 | |
a9d3cc48 CL |
436 | /* set CPEN (control port mode) and power down */ |
437 | cs4398_write(chip, 8, CS4398_CPEN | CS4398_PDN); | |
438 | cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN); | |
439 | /* configure */ | |
e58aee95 | 440 | cs4398_write(chip, 2, data->cs4398_fm); |
a9d3cc48 | 441 | cs4398_write(chip, 3, CS4398_ATAPI_B_R | CS4398_ATAPI_A_L); |
a9d3cc48 CL |
442 | cs4398_write(chip, 7, CS4398_RMP_DN | CS4398_RMP_UP | |
443 | CS4398_ZERO_CROSS | CS4398_SOFT_RAMP); | |
444 | cs4362a_write(chip, 0x02, CS4362A_DIF_LJUST); | |
445 | cs4362a_write(chip, 0x03, CS4362A_MUTEC_6 | CS4362A_AMUTE | | |
446 | CS4362A_RMP_UP | CS4362A_ZERO_CROSS | CS4362A_SOFT_RAMP); | |
447 | cs4362a_write(chip, 0x04, CS4362A_RMP_DN | CS4362A_DEM_NONE); | |
448 | cs4362a_write(chip, 0x05, 0); | |
e58aee95 | 449 | cs4362a_write(chip, 0x06, data->cs4362a_fm); |
e58aee95 | 450 | cs4362a_write(chip, 0x09, data->cs4362a_fm); |
e58aee95 | 451 | cs4362a_write(chip, 0x0c, data->cs4362a_fm); |
bbbfb552 CL |
452 | update_cs43xx_volume(chip); |
453 | update_cs43xx_mute(chip); | |
a9d3cc48 CL |
454 | /* clear power down */ |
455 | cs4398_write(chip, 8, CS4398_CPEN); | |
456 | cs4362a_write(chip, 0x01, CS4362A_CPEN); | |
75146fc0 CL |
457 | } |
458 | ||
5430c72b | 459 | static void xonar_d1_init(struct oxygen *chip) |
75146fc0 CL |
460 | { |
461 | struct xonar_data *data = chip->model_data; | |
462 | ||
463 | data->anti_pop_delay = 800; | |
464 | data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE; | |
75146fc0 CL |
465 | data->cs4398_fm = CS4398_FM_SINGLE | CS4398_DEM_NONE | CS4398_DIF_LJUST; |
466 | data->cs4362a_fm = CS4362A_FM_SINGLE | | |
467 | CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L; | |
468 | ||
469 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | |
470 | OXYGEN_2WIRE_LENGTH_8 | | |
471 | OXYGEN_2WIRE_INTERRUPT_MASK | | |
472 | OXYGEN_2WIRE_SPEED_FAST); | |
473 | ||
474 | cs43xx_init(chip); | |
a9d3cc48 CL |
475 | |
476 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, | |
a8bb1bad CL |
477 | GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE); |
478 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, | |
479 | GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE); | |
a9d3cc48 CL |
480 | |
481 | xonar_common_init(chip); | |
482 | ||
483 | snd_component_add(chip->card, "CS4398"); | |
484 | snd_component_add(chip->card, "CS4362A"); | |
485 | snd_component_add(chip->card, "CS5361"); | |
486 | } | |
487 | ||
30459d7b CL |
488 | static void xonar_dx_init(struct oxygen *chip) |
489 | { | |
490 | struct xonar_data *data = chip->model_data; | |
491 | ||
492 | data->ext_power_reg = OXYGEN_GPI_DATA; | |
493 | data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | |
494 | data->ext_power_bit = GPI_DX_EXT_POWER; | |
495 | ||
496 | xonar_d1_init(chip); | |
497 | } | |
498 | ||
7407a2e4 CL |
499 | static void xonar_hdav_init(struct oxygen *chip) |
500 | { | |
501 | struct xonar_data *data = chip->model_data; | |
502 | u8 param; | |
503 | ||
504 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | |
505 | OXYGEN_2WIRE_LENGTH_8 | | |
506 | OXYGEN_2WIRE_INTERRUPT_MASK | | |
507 | OXYGEN_2WIRE_SPEED_FAST); | |
508 | ||
509 | data->anti_pop_delay = 100; | |
30459d7b | 510 | data->dacs = chip->model.private_data == MODEL_HDAV_H6 ? 4 : 1; |
7407a2e4 CL |
511 | data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE; |
512 | data->ext_power_reg = OXYGEN_GPI_DATA; | |
513 | data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | |
514 | data->ext_power_bit = GPI_DX_EXT_POWER; | |
515 | data->pcm1796_oversampling = PCM1796_OS_64; | |
516 | ||
517 | pcm1796_init(chip); | |
518 | ||
519 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DX_INPUT_ROUTE); | |
520 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DX_INPUT_ROUTE); | |
521 | ||
522 | oxygen_reset_uart(chip); | |
523 | param = 0; | |
524 | hdmi_write_command(chip, 0x61, 1, ¶m); | |
525 | param = 1; | |
526 | hdmi_write_command(chip, 0x74, 1, ¶m); | |
527 | data->hdmi_params[1] = IEC958_AES3_CON_FS_48000; | |
528 | data->hdmi_params[4] = 1; | |
529 | hdmi_write_command(chip, 0x54, 5, data->hdmi_params); | |
530 | ||
531 | xonar_common_init(chip); | |
532 | ||
533 | snd_component_add(chip->card, "PCM1796"); | |
534 | snd_component_add(chip->card, "CS5381"); | |
535 | } | |
536 | ||
04f9890d | 537 | static void xonar_st_init(struct oxygen *chip) |
930738de CL |
538 | { |
539 | struct xonar_data *data = chip->model_data; | |
540 | ||
541 | oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS, | |
542 | OXYGEN_2WIRE_LENGTH_8 | | |
543 | OXYGEN_2WIRE_INTERRUPT_MASK | | |
544 | OXYGEN_2WIRE_SPEED_FAST); | |
545 | ||
04f9890d CL |
546 | if (chip->model.private_data == MODEL_ST_H6) |
547 | chip->model.dac_channels = 8; | |
930738de | 548 | data->anti_pop_delay = 100; |
04f9890d | 549 | data->dacs = chip->model.private_data == MODEL_ST_H6 ? 4 : 1; |
930738de | 550 | data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE; |
930738de CL |
551 | data->pcm1796_oversampling = PCM1796_OS_64; |
552 | ||
553 | pcm1796_init(chip); | |
554 | ||
555 | oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, | |
556 | GPIO_DX_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP); | |
557 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, | |
558 | GPIO_DX_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP); | |
559 | ||
560 | xonar_common_init(chip); | |
561 | ||
562 | snd_component_add(chip->card, "PCM1792A"); | |
563 | snd_component_add(chip->card, "CS5381"); | |
564 | } | |
565 | ||
04f9890d CL |
566 | static void xonar_stx_init(struct oxygen *chip) |
567 | { | |
568 | struct xonar_data *data = chip->model_data; | |
569 | ||
570 | data->ext_power_reg = OXYGEN_GPI_DATA; | |
571 | data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; | |
572 | data->ext_power_bit = GPI_DX_EXT_POWER; | |
573 | ||
574 | xonar_st_init(chip); | |
575 | } | |
576 | ||
c2bc4ff5 | 577 | static void xonar_disable_output(struct oxygen *chip) |
1b8ff22f | 578 | { |
af9af174 CL |
579 | struct xonar_data *data = chip->model_data; |
580 | ||
581 | oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit); | |
1b8ff22f CL |
582 | } |
583 | ||
c2bc4ff5 CL |
584 | static void xonar_d2_cleanup(struct oxygen *chip) |
585 | { | |
586 | xonar_disable_output(chip); | |
587 | } | |
588 | ||
5430c72b | 589 | static void xonar_d1_cleanup(struct oxygen *chip) |
a9d3cc48 | 590 | { |
c2bc4ff5 | 591 | xonar_disable_output(chip); |
a9d3cc48 CL |
592 | cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN); |
593 | oxygen_clear_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC); | |
594 | } | |
595 | ||
7407a2e4 CL |
596 | static void xonar_hdav_cleanup(struct oxygen *chip) |
597 | { | |
598 | u8 param = 0; | |
599 | ||
600 | hdmi_write_command(chip, 0x74, 1, ¶m); | |
601 | xonar_disable_output(chip); | |
602 | } | |
603 | ||
930738de CL |
604 | static void xonar_st_cleanup(struct oxygen *chip) |
605 | { | |
606 | xonar_disable_output(chip); | |
607 | } | |
608 | ||
c2bc4ff5 CL |
609 | static void xonar_d2_suspend(struct oxygen *chip) |
610 | { | |
611 | xonar_d2_cleanup(chip); | |
612 | } | |
613 | ||
614 | static void xonar_d1_suspend(struct oxygen *chip) | |
615 | { | |
616 | xonar_d1_cleanup(chip); | |
617 | } | |
618 | ||
7407a2e4 CL |
619 | static void xonar_hdav_suspend(struct oxygen *chip) |
620 | { | |
621 | xonar_hdav_cleanup(chip); | |
622 | msleep(2); | |
623 | } | |
624 | ||
930738de CL |
625 | static void xonar_st_suspend(struct oxygen *chip) |
626 | { | |
627 | xonar_st_cleanup(chip); | |
628 | } | |
629 | ||
4a4bc53b CL |
630 | static void xonar_d2_resume(struct oxygen *chip) |
631 | { | |
632 | pcm1796_init(chip); | |
633 | xonar_enable_output(chip); | |
634 | } | |
635 | ||
5430c72b | 636 | static void xonar_d1_resume(struct oxygen *chip) |
4a4bc53b | 637 | { |
82639079 CL |
638 | oxygen_set_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC); |
639 | msleep(1); | |
4a4bc53b CL |
640 | cs43xx_init(chip); |
641 | xonar_enable_output(chip); | |
642 | } | |
643 | ||
7407a2e4 CL |
644 | static void xonar_hdav_resume(struct oxygen *chip) |
645 | { | |
646 | struct xonar_data *data = chip->model_data; | |
647 | u8 param; | |
648 | ||
649 | oxygen_reset_uart(chip); | |
650 | param = 0; | |
651 | hdmi_write_command(chip, 0x61, 1, ¶m); | |
652 | param = 1; | |
653 | hdmi_write_command(chip, 0x74, 1, ¶m); | |
654 | hdmi_write_command(chip, 0x54, 5, data->hdmi_params); | |
655 | pcm1796_init(chip); | |
656 | xonar_enable_output(chip); | |
657 | } | |
658 | ||
930738de CL |
659 | static void xonar_st_resume(struct oxygen *chip) |
660 | { | |
661 | pcm1796_init(chip); | |
662 | xonar_enable_output(chip); | |
663 | } | |
664 | ||
7407a2e4 CL |
665 | static void xonar_hdav_pcm_hardware_filter(unsigned int channel, |
666 | struct snd_pcm_hardware *hardware) | |
667 | { | |
668 | if (channel == PCM_MULTICH) { | |
669 | hardware->rates = SNDRV_PCM_RATE_44100 | | |
670 | SNDRV_PCM_RATE_48000 | | |
671 | SNDRV_PCM_RATE_96000 | | |
672 | SNDRV_PCM_RATE_192000; | |
673 | hardware->rate_min = 44100; | |
674 | } | |
675 | } | |
676 | ||
1b8ff22f CL |
677 | static void set_pcm1796_params(struct oxygen *chip, |
678 | struct snd_pcm_hw_params *params) | |
679 | { | |
e58aee95 | 680 | struct xonar_data *data = chip->model_data; |
1b8ff22f | 681 | unsigned int i; |
1b8ff22f | 682 | |
e58aee95 CL |
683 | data->pcm1796_oversampling = |
684 | params_rate(params) >= 96000 ? PCM1796_OS_32 : PCM1796_OS_64; | |
70c27d34 | 685 | for (i = 0; i < data->dacs; ++i) |
e58aee95 | 686 | pcm1796_write(chip, i, 20, data->pcm1796_oversampling); |
1b8ff22f CL |
687 | } |
688 | ||
a694a6a0 | 689 | static void set_cs53x1_params(struct oxygen *chip, |
1b8ff22f CL |
690 | struct snd_pcm_hw_params *params) |
691 | { | |
692 | unsigned int value; | |
693 | ||
694 | if (params_rate(params) <= 54000) | |
a694a6a0 | 695 | value = GPIO_CS53x1_M_SINGLE; |
1b8ff22f | 696 | else if (params_rate(params) <= 108000) |
a694a6a0 | 697 | value = GPIO_CS53x1_M_DOUBLE; |
1b8ff22f | 698 | else |
a694a6a0 | 699 | value = GPIO_CS53x1_M_QUAD; |
878ac3ee | 700 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, |
a694a6a0 | 701 | value, GPIO_CS53x1_M_MASK); |
1b8ff22f CL |
702 | } |
703 | ||
a9d3cc48 CL |
704 | static void set_cs43xx_params(struct oxygen *chip, |
705 | struct snd_pcm_hw_params *params) | |
706 | { | |
e58aee95 | 707 | struct xonar_data *data = chip->model_data; |
a9d3cc48 | 708 | |
e58aee95 CL |
709 | data->cs4398_fm = CS4398_DEM_NONE | CS4398_DIF_LJUST; |
710 | data->cs4362a_fm = CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L; | |
a9d3cc48 | 711 | if (params_rate(params) <= 50000) { |
e58aee95 CL |
712 | data->cs4398_fm |= CS4398_FM_SINGLE; |
713 | data->cs4362a_fm |= CS4362A_FM_SINGLE; | |
a9d3cc48 | 714 | } else if (params_rate(params) <= 100000) { |
e58aee95 CL |
715 | data->cs4398_fm |= CS4398_FM_DOUBLE; |
716 | data->cs4362a_fm |= CS4362A_FM_DOUBLE; | |
a9d3cc48 | 717 | } else { |
e58aee95 CL |
718 | data->cs4398_fm |= CS4398_FM_QUAD; |
719 | data->cs4362a_fm |= CS4362A_FM_QUAD; | |
a9d3cc48 | 720 | } |
e58aee95 CL |
721 | cs4398_write(chip, 2, data->cs4398_fm); |
722 | cs4362a_write(chip, 0x06, data->cs4362a_fm); | |
723 | cs4362a_write(chip, 0x09, data->cs4362a_fm); | |
724 | cs4362a_write(chip, 0x0c, data->cs4362a_fm); | |
a9d3cc48 CL |
725 | } |
726 | ||
7407a2e4 CL |
727 | static void set_hdmi_params(struct oxygen *chip, |
728 | struct snd_pcm_hw_params *params) | |
729 | { | |
730 | struct xonar_data *data = chip->model_data; | |
731 | ||
732 | data->hdmi_params[0] = 0; /* 1 = non-audio */ | |
733 | switch (params_rate(params)) { | |
734 | case 44100: | |
735 | data->hdmi_params[1] = IEC958_AES3_CON_FS_44100; | |
736 | break; | |
737 | case 48000: | |
738 | data->hdmi_params[1] = IEC958_AES3_CON_FS_48000; | |
739 | break; | |
740 | default: /* 96000 */ | |
741 | data->hdmi_params[1] = IEC958_AES3_CON_FS_96000; | |
742 | break; | |
743 | case 192000: | |
744 | data->hdmi_params[1] = IEC958_AES3_CON_FS_192000; | |
745 | break; | |
746 | } | |
747 | data->hdmi_params[2] = params_channels(params) / 2 - 1; | |
748 | if (params_format(params) == SNDRV_PCM_FORMAT_S16_LE) | |
749 | data->hdmi_params[3] = 0; | |
750 | else | |
751 | data->hdmi_params[3] = 0xc0; | |
752 | data->hdmi_params[4] = 1; /* ? */ | |
753 | hdmi_write_command(chip, 0x54, 5, data->hdmi_params); | |
754 | } | |
755 | ||
756 | static void set_hdav_params(struct oxygen *chip, | |
757 | struct snd_pcm_hw_params *params) | |
758 | { | |
759 | set_pcm1796_params(chip, params); | |
760 | set_hdmi_params(chip, params); | |
761 | } | |
762 | ||
7c014159 CL |
763 | static void xonar_gpio_changed(struct oxygen *chip) |
764 | { | |
765 | struct xonar_data *data = chip->model_data; | |
766 | u8 has_power; | |
767 | ||
af9af174 CL |
768 | has_power = !!(oxygen_read8(chip, data->ext_power_reg) |
769 | & data->ext_power_bit); | |
7c014159 CL |
770 | if (has_power != data->has_power) { |
771 | data->has_power = has_power; | |
772 | if (has_power) { | |
773 | snd_printk(KERN_NOTICE "power restored\n"); | |
774 | } else { | |
775 | snd_printk(KERN_CRIT | |
776 | "Hey! Don't unplug the power cable!\n"); | |
777 | /* TODO: stop PCMs */ | |
778 | } | |
779 | } | |
780 | } | |
781 | ||
7407a2e4 CL |
782 | static void xonar_hdav_uart_input(struct oxygen *chip) |
783 | { | |
784 | if (chip->uart_input_count >= 2 && | |
785 | chip->uart_input[chip->uart_input_count - 2] == 'O' && | |
786 | chip->uart_input[chip->uart_input_count - 1] == 'K') { | |
45bf8101 | 787 | printk(KERN_DEBUG "message from Xonar HDAV HDMI chip received:\n"); |
7407a2e4 CL |
788 | print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, |
789 | chip->uart_input, chip->uart_input_count); | |
790 | chip->uart_input_count = 0; | |
791 | } | |
792 | } | |
793 | ||
c3f00739 CL |
794 | static int gpio_bit_switch_get(struct snd_kcontrol *ctl, |
795 | struct snd_ctl_elem_value *value) | |
1b8ff22f CL |
796 | { |
797 | struct oxygen *chip = ctl->private_data; | |
c3f00739 | 798 | u16 bit = ctl->private_value; |
1b8ff22f CL |
799 | |
800 | value->value.integer.value[0] = | |
c3f00739 | 801 | !!(oxygen_read16(chip, OXYGEN_GPIO_DATA) & bit); |
1b8ff22f CL |
802 | return 0; |
803 | } | |
804 | ||
c3f00739 CL |
805 | static int gpio_bit_switch_put(struct snd_kcontrol *ctl, |
806 | struct snd_ctl_elem_value *value) | |
1b8ff22f CL |
807 | { |
808 | struct oxygen *chip = ctl->private_data; | |
c3f00739 | 809 | u16 bit = ctl->private_value; |
1b8ff22f CL |
810 | u16 old_bits, new_bits; |
811 | int changed; | |
812 | ||
813 | spin_lock_irq(&chip->reg_lock); | |
814 | old_bits = oxygen_read16(chip, OXYGEN_GPIO_DATA); | |
815 | if (value->value.integer.value[0]) | |
c3f00739 | 816 | new_bits = old_bits | bit; |
1b8ff22f | 817 | else |
c3f00739 | 818 | new_bits = old_bits & ~bit; |
1b8ff22f CL |
819 | changed = new_bits != old_bits; |
820 | if (changed) | |
821 | oxygen_write16(chip, OXYGEN_GPIO_DATA, new_bits); | |
822 | spin_unlock_irq(&chip->reg_lock); | |
823 | return changed; | |
824 | } | |
825 | ||
826 | static const struct snd_kcontrol_new alt_switch = { | |
827 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | |
828 | .name = "Analog Loopback Switch", | |
829 | .info = snd_ctl_boolean_mono_info, | |
c3f00739 CL |
830 | .get = gpio_bit_switch_get, |
831 | .put = gpio_bit_switch_put, | |
832 | .private_value = GPIO_D2_ALT, | |
1b8ff22f CL |
833 | }; |
834 | ||
a8bb1bad | 835 | static const struct snd_kcontrol_new front_panel_switch = { |
387fb6a2 | 836 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
a8bb1bad CL |
837 | .name = "Front Panel Switch", |
838 | .info = snd_ctl_boolean_mono_info, | |
c3f00739 CL |
839 | .get = gpio_bit_switch_get, |
840 | .put = gpio_bit_switch_put, | |
841 | .private_value = GPIO_DX_FRONT_PANEL, | |
387fb6a2 CL |
842 | }; |
843 | ||
930738de CL |
844 | static int st_output_switch_info(struct snd_kcontrol *ctl, |
845 | struct snd_ctl_elem_info *info) | |
846 | { | |
847 | static const char *const names[3] = { | |
848 | "Speakers", "Headphones", "FP Headphones" | |
849 | }; | |
850 | ||
851 | info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; | |
852 | info->count = 1; | |
853 | info->value.enumerated.items = 3; | |
854 | if (info->value.enumerated.item >= 3) | |
855 | info->value.enumerated.item = 2; | |
856 | strcpy(info->value.enumerated.name, names[info->value.enumerated.item]); | |
857 | return 0; | |
858 | } | |
859 | ||
860 | static int st_output_switch_get(struct snd_kcontrol *ctl, | |
861 | struct snd_ctl_elem_value *value) | |
862 | { | |
863 | struct oxygen *chip = ctl->private_data; | |
864 | u16 gpio; | |
865 | ||
866 | gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA); | |
867 | if (!(gpio & GPIO_ST_HP)) | |
868 | value->value.enumerated.item[0] = 0; | |
869 | else if (gpio & GPIO_ST_HP_REAR) | |
870 | value->value.enumerated.item[0] = 1; | |
871 | else | |
872 | value->value.enumerated.item[0] = 2; | |
873 | return 0; | |
874 | } | |
875 | ||
876 | ||
877 | static int st_output_switch_put(struct snd_kcontrol *ctl, | |
878 | struct snd_ctl_elem_value *value) | |
879 | { | |
880 | struct oxygen *chip = ctl->private_data; | |
881 | u16 gpio_old, gpio; | |
882 | ||
883 | mutex_lock(&chip->mutex); | |
884 | gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA); | |
885 | gpio = gpio_old; | |
886 | switch (value->value.enumerated.item[0]) { | |
887 | case 0: | |
888 | gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR); | |
889 | break; | |
890 | case 1: | |
891 | gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR; | |
892 | break; | |
893 | case 2: | |
894 | gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR; | |
895 | break; | |
896 | } | |
897 | oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio); | |
898 | mutex_unlock(&chip->mutex); | |
899 | return gpio != gpio_old; | |
900 | } | |
901 | ||
902 | static const struct snd_kcontrol_new st_output_switch = { | |
903 | .iface = SNDRV_CTL_ELEM_IFACE_MIXER, | |
904 | .name = "Analog Output", | |
905 | .info = st_output_switch_info, | |
906 | .get = st_output_switch_get, | |
907 | .put = st_output_switch_put, | |
908 | }; | |
909 | ||
c871c4a8 CL |
910 | static void xonar_line_mic_ac97_switch(struct oxygen *chip, |
911 | unsigned int reg, unsigned int mute) | |
11864b4b CL |
912 | { |
913 | if (reg == AC97_LINE) { | |
914 | spin_lock_irq(&chip->reg_lock); | |
915 | oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, | |
916 | mute ? GPIO_DX_INPUT_ROUTE : 0, | |
917 | GPIO_DX_INPUT_ROUTE); | |
918 | spin_unlock_irq(&chip->reg_lock); | |
919 | } | |
920 | } | |
921 | ||
eacbb9db CL |
922 | static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0); |
923 | static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -6000, 100, 0); | |
1b8ff22f | 924 | |
af9af174 | 925 | static int xonar_d2_control_filter(struct snd_kcontrol_new *template) |
ccc80fb4 | 926 | { |
4972a177 | 927 | if (!strncmp(template->name, "CD Capture ", 11)) |
911b499a | 928 | /* CD in is actually connected to the video in pin */ |
ccc80fb4 | 929 | template->private_value ^= AC97_CD ^ AC97_VIDEO; |
ccc80fb4 CL |
930 | return 0; |
931 | } | |
932 | ||
5430c72b | 933 | static int xonar_d1_control_filter(struct snd_kcontrol_new *template) |
a9d3cc48 | 934 | { |
4972a177 | 935 | if (!strncmp(template->name, "CD Capture ", 11)) |
a9d3cc48 | 936 | return 1; /* no CD input */ |
a9d3cc48 CL |
937 | return 0; |
938 | } | |
939 | ||
930738de CL |
940 | static int xonar_st_control_filter(struct snd_kcontrol_new *template) |
941 | { | |
942 | if (!strncmp(template->name, "CD Capture ", 11)) | |
943 | return 1; /* no CD input */ | |
944 | if (!strcmp(template->name, "Stereo Upmixing")) | |
945 | return 1; /* stereo only - we don't need upmixing */ | |
946 | return 0; | |
947 | } | |
948 | ||
fe10662c | 949 | static int xonar_d2_mixer_init(struct oxygen *chip) |
1b8ff22f CL |
950 | { |
951 | return snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip)); | |
952 | } | |
953 | ||
5430c72b | 954 | static int xonar_d1_mixer_init(struct oxygen *chip) |
387fb6a2 | 955 | { |
a8bb1bad | 956 | return snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip)); |
387fb6a2 CL |
957 | } |
958 | ||
930738de CL |
959 | static int xonar_st_mixer_init(struct oxygen *chip) |
960 | { | |
961 | return snd_ctl_add(chip->card, snd_ctl_new1(&st_output_switch, chip)); | |
962 | } | |
963 | ||
fe10662c CL |
964 | static const struct oxygen_model model_xonar_d2 = { |
965 | .longname = "Asus Virtuoso 200", | |
966 | .chip = "AV200", | |
fe10662c CL |
967 | .init = xonar_d2_init, |
968 | .control_filter = xonar_d2_control_filter, | |
969 | .mixer_init = xonar_d2_mixer_init, | |
c2bc4ff5 CL |
970 | .cleanup = xonar_d2_cleanup, |
971 | .suspend = xonar_d2_suspend, | |
fe10662c CL |
972 | .resume = xonar_d2_resume, |
973 | .set_dac_params = set_pcm1796_params, | |
974 | .set_adc_params = set_cs53x1_params, | |
975 | .update_dac_volume = update_pcm1796_volume, | |
976 | .update_dac_mute = update_pcm1796_mute, | |
977 | .dac_tlv = pcm1796_db_scale, | |
978 | .model_data_size = sizeof(struct xonar_data), | |
d76596b1 CL |
979 | .device_config = PLAYBACK_0_TO_I2S | |
980 | PLAYBACK_1_TO_SPDIF | | |
981 | CAPTURE_0_FROM_I2S_2 | | |
dbbbd674 CL |
982 | CAPTURE_1_FROM_SPDIF | |
983 | MIDI_OUTPUT | | |
984 | MIDI_INPUT, | |
fe10662c | 985 | .dac_channels = 8, |
eacbb9db CL |
986 | .dac_volume_min = 255 - 2*60, |
987 | .dac_volume_max = 255, | |
fe10662c | 988 | .misc_flags = OXYGEN_MISC_MIDI, |
6ce6c473 CL |
989 | .function_flags = OXYGEN_FUNCTION_SPI | |
990 | OXYGEN_FUNCTION_ENABLE_SPI_4_5, | |
991 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | |
fe10662c CL |
992 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, |
993 | }; | |
994 | ||
995 | static const struct oxygen_model model_xonar_d1 = { | |
996 | .longname = "Asus Virtuoso 100", | |
997 | .chip = "AV200", | |
fe10662c CL |
998 | .init = xonar_d1_init, |
999 | .control_filter = xonar_d1_control_filter, | |
1000 | .mixer_init = xonar_d1_mixer_init, | |
1001 | .cleanup = xonar_d1_cleanup, | |
c2bc4ff5 | 1002 | .suspend = xonar_d1_suspend, |
fe10662c CL |
1003 | .resume = xonar_d1_resume, |
1004 | .set_dac_params = set_cs43xx_params, | |
1005 | .set_adc_params = set_cs53x1_params, | |
1006 | .update_dac_volume = update_cs43xx_volume, | |
1007 | .update_dac_mute = update_cs43xx_mute, | |
c871c4a8 | 1008 | .ac97_switch = xonar_line_mic_ac97_switch, |
fe10662c CL |
1009 | .dac_tlv = cs4362a_db_scale, |
1010 | .model_data_size = sizeof(struct xonar_data), | |
d76596b1 CL |
1011 | .device_config = PLAYBACK_0_TO_I2S | |
1012 | PLAYBACK_1_TO_SPDIF | | |
1013 | CAPTURE_0_FROM_I2S_2, | |
fe10662c | 1014 | .dac_channels = 8, |
eacbb9db | 1015 | .dac_volume_min = 127 - 60, |
fe10662c CL |
1016 | .dac_volume_max = 127, |
1017 | .function_flags = OXYGEN_FUNCTION_2WIRE, | |
1018 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | |
1019 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | |
1b8ff22f CL |
1020 | }; |
1021 | ||
7407a2e4 CL |
1022 | static const struct oxygen_model model_xonar_hdav = { |
1023 | .longname = "Asus Virtuoso 200", | |
1024 | .chip = "AV200", | |
7407a2e4 CL |
1025 | .init = xonar_hdav_init, |
1026 | .cleanup = xonar_hdav_cleanup, | |
1027 | .suspend = xonar_hdav_suspend, | |
1028 | .resume = xonar_hdav_resume, | |
1029 | .pcm_hardware_filter = xonar_hdav_pcm_hardware_filter, | |
1030 | .set_dac_params = set_hdav_params, | |
1031 | .set_adc_params = set_cs53x1_params, | |
1032 | .update_dac_volume = update_pcm1796_volume, | |
1033 | .update_dac_mute = update_pcm1796_mute, | |
1034 | .uart_input = xonar_hdav_uart_input, | |
1035 | .ac97_switch = xonar_line_mic_ac97_switch, | |
1036 | .dac_tlv = pcm1796_db_scale, | |
1037 | .model_data_size = sizeof(struct xonar_data), | |
1038 | .device_config = PLAYBACK_0_TO_I2S | | |
1039 | PLAYBACK_1_TO_SPDIF | | |
b990ae96 CL |
1040 | CAPTURE_0_FROM_I2S_2 | |
1041 | CAPTURE_1_FROM_SPDIF, | |
7407a2e4 | 1042 | .dac_channels = 8, |
eacbb9db CL |
1043 | .dac_volume_min = 255 - 2*60, |
1044 | .dac_volume_max = 255, | |
22c73378 | 1045 | .misc_flags = OXYGEN_MISC_MIDI, |
7407a2e4 CL |
1046 | .function_flags = OXYGEN_FUNCTION_2WIRE, |
1047 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | |
1048 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | |
1049 | }; | |
1050 | ||
930738de CL |
1051 | static const struct oxygen_model model_xonar_st = { |
1052 | .longname = "Asus Virtuoso 100", | |
1053 | .chip = "AV200", | |
04f9890d | 1054 | .init = xonar_st_init, |
930738de CL |
1055 | .control_filter = xonar_st_control_filter, |
1056 | .mixer_init = xonar_st_mixer_init, | |
1057 | .cleanup = xonar_st_cleanup, | |
1058 | .suspend = xonar_st_suspend, | |
1059 | .resume = xonar_st_resume, | |
1060 | .set_dac_params = set_pcm1796_params, | |
1061 | .set_adc_params = set_cs53x1_params, | |
1062 | .update_dac_volume = update_pcm1796_volume, | |
1063 | .update_dac_mute = update_pcm1796_mute, | |
1064 | .ac97_switch = xonar_line_mic_ac97_switch, | |
1065 | .dac_tlv = pcm1796_db_scale, | |
1066 | .model_data_size = sizeof(struct xonar_data), | |
1067 | .device_config = PLAYBACK_0_TO_I2S | | |
1068 | PLAYBACK_1_TO_SPDIF | | |
1069 | CAPTURE_0_FROM_I2S_2, | |
1070 | .dac_channels = 2, | |
1071 | .dac_volume_min = 255 - 2*60, | |
1072 | .dac_volume_max = 255, | |
1073 | .function_flags = OXYGEN_FUNCTION_2WIRE, | |
1074 | .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | |
1075 | .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST, | |
1076 | }; | |
1077 | ||
30459d7b CL |
1078 | static int __devinit get_xonar_model(struct oxygen *chip, |
1079 | const struct pci_device_id *id) | |
1b8ff22f | 1080 | { |
fe10662c CL |
1081 | static const struct oxygen_model *const models[] = { |
1082 | [MODEL_D1] = &model_xonar_d1, | |
1083 | [MODEL_DX] = &model_xonar_d1, | |
1084 | [MODEL_D2] = &model_xonar_d2, | |
1085 | [MODEL_D2X] = &model_xonar_d2, | |
7407a2e4 | 1086 | [MODEL_HDAV] = &model_xonar_hdav, |
04f9890d | 1087 | [MODEL_ST] = &model_xonar_st, |
930738de | 1088 | [MODEL_STX] = &model_xonar_st, |
fe10662c | 1089 | }; |
30459d7b CL |
1090 | static const char *const names[] = { |
1091 | [MODEL_D1] = "Xonar D1", | |
1092 | [MODEL_DX] = "Xonar DX", | |
1093 | [MODEL_D2] = "Xonar D2", | |
1094 | [MODEL_D2X] = "Xonar D2X", | |
1095 | [MODEL_HDAV] = "Xonar HDAV1.3", | |
1096 | [MODEL_HDAV_H6] = "Xonar HDAV1.3+H6", | |
04f9890d CL |
1097 | [MODEL_ST] = "Xonar Essence ST", |
1098 | [MODEL_ST_H6] = "Xonar Essence ST+H6", | |
930738de | 1099 | [MODEL_STX] = "Xonar Essence STX", |
30459d7b CL |
1100 | }; |
1101 | unsigned int model = id->driver_data; | |
1102 | ||
1103 | if (model >= ARRAY_SIZE(models) || !models[model]) | |
1104 | return -EINVAL; | |
1105 | chip->model = *models[model]; | |
1106 | ||
1107 | switch (model) { | |
1108 | case MODEL_D2X: | |
1109 | chip->model.init = xonar_d2x_init; | |
1110 | break; | |
1111 | case MODEL_DX: | |
1112 | chip->model.init = xonar_dx_init; | |
1113 | break; | |
1114 | case MODEL_HDAV: | |
04f9890d CL |
1115 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK); |
1116 | switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) { | |
1117 | case GPIO_DB_H6: | |
30459d7b CL |
1118 | model = MODEL_HDAV_H6; |
1119 | break; | |
04f9890d | 1120 | case GPIO_DB_XX: |
30459d7b CL |
1121 | snd_printk(KERN_ERR "unknown daughterboard\n"); |
1122 | return -ENODEV; | |
1123 | } | |
1124 | break; | |
04f9890d CL |
1125 | case MODEL_ST: |
1126 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK); | |
1127 | switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) { | |
1128 | case GPIO_DB_H6: | |
1129 | model = MODEL_ST_H6; | |
1130 | break; | |
1131 | } | |
1132 | break; | |
930738de | 1133 | case MODEL_STX: |
04f9890d CL |
1134 | chip->model.init = xonar_stx_init; |
1135 | oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK); | |
930738de | 1136 | break; |
30459d7b CL |
1137 | } |
1138 | ||
1139 | chip->model.shortname = names[model]; | |
1140 | chip->model.private_data = model; | |
1141 | return 0; | |
1142 | } | |
1143 | ||
1144 | static int __devinit xonar_probe(struct pci_dev *pci, | |
1145 | const struct pci_device_id *pci_id) | |
1146 | { | |
1b8ff22f CL |
1147 | static int dev; |
1148 | int err; | |
1149 | ||
1150 | if (dev >= SNDRV_CARDS) | |
1151 | return -ENODEV; | |
1152 | if (!enable[dev]) { | |
1153 | ++dev; | |
1154 | return -ENOENT; | |
1155 | } | |
bb718588 | 1156 | err = oxygen_pci_probe(pci, index[dev], id[dev], THIS_MODULE, |
30459d7b | 1157 | xonar_ids, get_xonar_model); |
1b8ff22f CL |
1158 | if (err >= 0) |
1159 | ++dev; | |
1160 | return err; | |
1161 | } | |
1162 | ||
1163 | static struct pci_driver xonar_driver = { | |
1164 | .name = "AV200", | |
1165 | .id_table = xonar_ids, | |
1166 | .probe = xonar_probe, | |
1167 | .remove = __devexit_p(oxygen_pci_remove), | |
4a4bc53b CL |
1168 | #ifdef CONFIG_PM |
1169 | .suspend = oxygen_pci_suspend, | |
1170 | .resume = oxygen_pci_resume, | |
1171 | #endif | |
1b8ff22f CL |
1172 | }; |
1173 | ||
1174 | static int __init alsa_card_xonar_init(void) | |
1175 | { | |
1176 | return pci_register_driver(&xonar_driver); | |
1177 | } | |
1178 | ||
1179 | static void __exit alsa_card_xonar_exit(void) | |
1180 | { | |
1181 | pci_unregister_driver(&xonar_driver); | |
1182 | } | |
1183 | ||
1184 | module_init(alsa_card_xonar_init) | |
1185 | module_exit(alsa_card_xonar_exit) |