blob: 45427d85045e0484527eebe3c10704fd343c07d1 [file] [log] [blame]
Clemens Ladischd0ce9942007-12-23 19:50:57 +01001/*
Clemens Ladisch873591d2009-03-09 09:12:55 +01002 * C-Media CMI8788 driver for C-Media's reference design and similar models
Clemens Ladischd0ce9942007-12-23 19:50:57 +01003 *
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/*
Clemens Ladischdc0adf42009-09-28 11:17:36 +020021 * CMI8788:
22 *
Clemens Ladischde664932010-12-02 11:42:48 +010023 * SPI 0 -> 1st AK4396 (front)
24 * SPI 1 -> 2nd AK4396 (surround)
25 * SPI 2 -> 3rd AK4396 (center/LFE)
26 * SPI 3 -> WM8785
27 * SPI 4 -> 4th AK4396 (back)
Clemens Ladischd0ce9942007-12-23 19:50:57 +010028 *
Clemens Ladischde664932010-12-02 11:42:48 +010029 * GPIO 0 -> DFS0 of AK5385
30 * GPIO 1 -> DFS1 of AK5385
31 * GPIO 8 -> enable headphone amplifier on HT-Omega models
Clemens Ladischdc0adf42009-09-28 11:17:36 +020032 *
33 * CM9780:
34 *
Clemens Ladischde664932010-12-02 11:42:48 +010035 * LINE_OUT -> input of ADC
36 *
37 * AUX_IN <- aux
38 * CD_IN <- CD
39 * MIC_IN <- mic
40 *
41 * GPO 0 -> route line-in (0) or AC97 output (1) to ADC input
Clemens Ladischd0ce9942007-12-23 19:50:57 +010042 */
43
Clemens Ladischdf91bc22008-08-29 13:08:34 +020044#include <linux/delay.h>
Clemens Ladisch902b05c2008-02-22 18:40:56 +010045#include <linux/mutex.h>
Clemens Ladischd0ce9942007-12-23 19:50:57 +010046#include <linux/pci.h>
Clemens Ladisch902b05c2008-02-22 18:40:56 +010047#include <sound/ac97_codec.h>
Clemens Ladischccc80fb2008-01-16 08:32:08 +010048#include <sound/control.h>
Clemens Ladischd0ce9942007-12-23 19:50:57 +010049#include <sound/core.h>
Clemens Ladisch9719fca2010-12-02 11:41:10 +010050#include <sound/info.h>
Clemens Ladischd0ce9942007-12-23 19:50:57 +010051#include <sound/initval.h>
52#include <sound/pcm.h>
53#include <sound/pcm_params.h>
54#include <sound/tlv.h>
55#include "oxygen.h"
Clemens Ladisch66410bf2011-01-10 16:20:29 +010056#include "xonar_dg.h"
Clemens Ladischc6260262008-01-25 08:41:52 +010057#include "ak4396.h"
Clemens Ladischf5b23682008-03-19 08:14:01 +010058#include "wm8785.h"
Clemens Ladischd0ce9942007-12-23 19:50:57 +010059
60MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
61MODULE_DESCRIPTION("C-Media CMI8788 driver");
Clemens Ladischd023dc02008-05-13 09:18:27 +020062MODULE_LICENSE("GPL v2");
Clemens Ladisch66410bf2011-01-10 16:20:29 +010063MODULE_SUPPORTED_DEVICE("{{C-Media,CMI8786}"
64 ",{C-Media,CMI8787}"
65 ",{C-Media,CMI8788}}");
Clemens Ladischd0ce9942007-12-23 19:50:57 +010066
67static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
68static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
69static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
70
71module_param_array(index, int, NULL, 0444);
72MODULE_PARM_DESC(index, "card index");
73module_param_array(id, charp, NULL, 0444);
74MODULE_PARM_DESC(id, "ID string");
75module_param_array(enable, bool, NULL, 0444);
76MODULE_PARM_DESC(enable, "enable card");
77
Clemens Ladisch2f1b0ec2008-09-22 08:57:24 +020078enum {
Clemens Ladisch18f24832010-11-03 11:36:33 +010079 MODEL_CMEDIA_REF,
80 MODEL_MERIDIAN,
81 MODEL_CLARO,
82 MODEL_CLARO_HALO,
Clemens Ladisch2146dcf2010-11-03 12:26:35 +010083 MODEL_FANTASIA,
84 MODEL_2CH_OUTPUT,
Clemens Ladisch66410bf2011-01-10 16:20:29 +010085 MODEL_XONAR_DG,
Clemens Ladisch2f1b0ec2008-09-22 08:57:24 +020086};
87
Alexey Dobriyancebe41d2010-02-06 00:21:03 +020088static DEFINE_PCI_DEVICE_TABLE(oxygen_ids) = {
Clemens Ladisch18f24832010-11-03 11:36:33 +010089 /* C-Media's reference design */
Clemens Ladisch2f1b0ec2008-09-22 08:57:24 +020090 { OXYGEN_PCI_SUBID(0x10b0, 0x0216), .driver_data = MODEL_CMEDIA_REF },
Clemens Ladisch8c50b752011-01-10 16:16:32 +010091 { OXYGEN_PCI_SUBID(0x10b0, 0x0217), .driver_data = MODEL_CMEDIA_REF },
Clemens Ladisch2f1b0ec2008-09-22 08:57:24 +020092 { OXYGEN_PCI_SUBID(0x10b0, 0x0218), .driver_data = MODEL_CMEDIA_REF },
93 { OXYGEN_PCI_SUBID(0x10b0, 0x0219), .driver_data = MODEL_CMEDIA_REF },
94 { OXYGEN_PCI_SUBID(0x13f6, 0x0001), .driver_data = MODEL_CMEDIA_REF },
95 { OXYGEN_PCI_SUBID(0x13f6, 0x0010), .driver_data = MODEL_CMEDIA_REF },
96 { OXYGEN_PCI_SUBID(0x13f6, 0x8788), .driver_data = MODEL_CMEDIA_REF },
97 { OXYGEN_PCI_SUBID(0x147a, 0xa017), .driver_data = MODEL_CMEDIA_REF },
Clemens Ladisch18f24832010-11-03 11:36:33 +010098 { OXYGEN_PCI_SUBID(0x1a58, 0x0910), .driver_data = MODEL_CMEDIA_REF },
Clemens Ladisch66410bf2011-01-10 16:20:29 +010099 /* Asus Xonar DG */
100 { OXYGEN_PCI_SUBID(0x1043, 0x8467), .driver_data = MODEL_XONAR_DG },
Clemens Ladisch8c50b752011-01-10 16:16:32 +0100101 /* PCI 2.0 HD Audio */
102 { OXYGEN_PCI_SUBID(0x13f6, 0x8782), .driver_data = MODEL_2CH_OUTPUT },
Clemens Ladisch18f24832010-11-03 11:36:33 +0100103 /* Kuroutoshikou CMI8787-HG2PCI */
Clemens Ladisch2146dcf2010-11-03 12:26:35 +0100104 { OXYGEN_PCI_SUBID(0x13f6, 0xffff), .driver_data = MODEL_2CH_OUTPUT },
Clemens Ladisch18f24832010-11-03 11:36:33 +0100105 /* TempoTec HiFier Fantasia */
Clemens Ladisch2146dcf2010-11-03 12:26:35 +0100106 { OXYGEN_PCI_SUBID(0x14c3, 0x1710), .driver_data = MODEL_FANTASIA },
107 /* TempoTec HiFier Serenade */
108 { OXYGEN_PCI_SUBID(0x14c3, 0x1711), .driver_data = MODEL_2CH_OUTPUT },
Clemens Ladisch18f24832010-11-03 11:36:33 +0100109 /* AuzenTech X-Meridian */
Clemens Ladisch2f1b0ec2008-09-22 08:57:24 +0200110 { OXYGEN_PCI_SUBID(0x415a, 0x5431), .driver_data = MODEL_MERIDIAN },
Clemens Ladisch8443d2e2011-01-10 16:17:26 +0100111 /* AuzenTech X-Meridian 2G */
112 { OXYGEN_PCI_SUBID(0x5431, 0x017a), .driver_data = MODEL_MERIDIAN },
Clemens Ladisch18f24832010-11-03 11:36:33 +0100113 /* HT-Omega Claro */
Clemens Ladisch873591d2009-03-09 09:12:55 +0100114 { OXYGEN_PCI_SUBID(0x7284, 0x9761), .driver_data = MODEL_CLARO },
Clemens Ladisch18f24832010-11-03 11:36:33 +0100115 /* HT-Omega Claro halo */
Clemens Ladisch873591d2009-03-09 09:12:55 +0100116 { OXYGEN_PCI_SUBID(0x7284, 0x9781), .driver_data = MODEL_CLARO_HALO },
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100117 { }
118};
119MODULE_DEVICE_TABLE(pci, oxygen_ids);
120
Clemens Ladisch878ac3e2008-01-21 08:50:19 +0100121
122#define GPIO_AK5385_DFS_MASK 0x0003
123#define GPIO_AK5385_DFS_NORMAL 0x0000
124#define GPIO_AK5385_DFS_DOUBLE 0x0001
125#define GPIO_AK5385_DFS_QUAD 0x0002
126
Clemens Ladisch873591d2009-03-09 09:12:55 +0100127#define GPIO_CLARO_HP 0x0100
128
Clemens Ladisch7ef37cd2008-01-21 08:51:55 +0100129struct generic_data {
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100130 unsigned int dacs;
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200131 u8 ak4396_regs[4][5];
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200132 u16 wm8785_regs[3];
Clemens Ladisch7ef37cd2008-01-21 08:51:55 +0100133};
134
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100135static void ak4396_write(struct oxygen *chip, unsigned int codec,
136 u8 reg, u8 value)
137{
138 /* maps ALSA channel pair number to SPI output */
139 static const u8 codec_spi_map[4] = {
Clemens Ladisch7113e952008-01-14 08:55:03 +0100140 0, 1, 2, 4
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100141 };
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200142 struct generic_data *data = chip->model_data;
143
Clemens Ladischc2353a02008-01-18 09:17:53 +0100144 oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100145 OXYGEN_SPI_DATA_LENGTH_2 |
Clemens Ladisch2ea85982008-01-30 08:38:30 +0100146 OXYGEN_SPI_CLOCK_160 |
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100147 (codec_spi_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
Clemens Ladischc2353a02008-01-18 09:17:53 +0100148 OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100149 AK4396_WRITE | (reg << 8) | value);
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200150 data->ak4396_regs[codec][reg] = value;
151}
152
153static void ak4396_write_cached(struct oxygen *chip, unsigned int codec,
154 u8 reg, u8 value)
155{
156 struct generic_data *data = chip->model_data;
157
158 if (value != data->ak4396_regs[codec][reg])
159 ak4396_write(chip, codec, reg, value);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100160}
161
162static void wm8785_write(struct oxygen *chip, u8 reg, unsigned int value)
163{
Clemens Ladische58aee92008-05-13 09:20:51 +0200164 struct generic_data *data = chip->model_data;
165
Clemens Ladischc2353a02008-01-18 09:17:53 +0100166 oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER |
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100167 OXYGEN_SPI_DATA_LENGTH_2 |
Clemens Ladisch2ea85982008-01-30 08:38:30 +0100168 OXYGEN_SPI_CLOCK_160 |
Clemens Ladischc2353a02008-01-18 09:17:53 +0100169 (3 << OXYGEN_SPI_CODEC_SHIFT) |
170 OXYGEN_SPI_CEN_LATCH_CLOCK_LO,
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100171 (reg << 9) | value);
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200172 if (reg < ARRAY_SIZE(data->wm8785_regs))
173 data->wm8785_regs[reg] = value;
Clemens Ladischbbbfb552008-05-13 09:21:48 +0200174}
175
Clemens Ladisch75146fc2008-05-13 09:22:43 +0200176static void ak4396_registers_init(struct oxygen *chip)
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100177{
Clemens Ladisch7ef37cd2008-01-21 08:51:55 +0100178 struct generic_data *data = chip->model_data;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100179 unsigned int i;
180
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100181 for (i = 0; i < data->dacs; ++i) {
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200182 ak4396_write(chip, i, AK4396_CONTROL_1,
183 AK4396_DIF_24_MSB | AK4396_RSTN);
184 ak4396_write(chip, i, AK4396_CONTROL_2,
185 data->ak4396_regs[0][AK4396_CONTROL_2]);
186 ak4396_write(chip, i, AK4396_CONTROL_3,
187 AK4396_PCM);
188 ak4396_write(chip, i, AK4396_LCH_ATT,
189 chip->dac_volume[i * 2]);
190 ak4396_write(chip, i, AK4396_RCH_ATT,
191 chip->dac_volume[i * 2 + 1]);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100192 }
Clemens Ladisch75146fc2008-05-13 09:22:43 +0200193}
194
195static void ak4396_init(struct oxygen *chip)
196{
197 struct generic_data *data = chip->model_data;
198
Clemens Ladisch1f4d7be2011-01-10 15:59:38 +0100199 data->dacs = chip->model.dac_channels_pcm / 2;
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200200 data->ak4396_regs[0][AK4396_CONTROL_2] =
201 AK4396_SMUTE | AK4396_DEM_OFF | AK4396_DFS_NORMAL;
Clemens Ladisch75146fc2008-05-13 09:22:43 +0200202 ak4396_registers_init(chip);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100203 snd_component_add(chip->card, "AK4396");
204}
205
206static void ak5385_init(struct oxygen *chip)
207{
Clemens Ladisch878ac3e2008-01-21 08:50:19 +0100208 oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_AK5385_DFS_MASK);
209 oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_AK5385_DFS_MASK);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100210 snd_component_add(chip->card, "AK5385");
211}
212
Clemens Ladisch75146fc2008-05-13 09:22:43 +0200213static void wm8785_registers_init(struct oxygen *chip)
214{
215 struct generic_data *data = chip->model_data;
216
217 wm8785_write(chip, WM8785_R7, 0);
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200218 wm8785_write(chip, WM8785_R0, data->wm8785_regs[0]);
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200219 wm8785_write(chip, WM8785_R2, data->wm8785_regs[2]);
Clemens Ladisch75146fc2008-05-13 09:22:43 +0200220}
221
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100222static void wm8785_init(struct oxygen *chip)
223{
Clemens Ladische58aee92008-05-13 09:20:51 +0200224 struct generic_data *data = chip->model_data;
225
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200226 data->wm8785_regs[0] =
227 WM8785_MCR_SLAVE | WM8785_OSR_SINGLE | WM8785_FORMAT_LJUST;
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200228 data->wm8785_regs[2] = WM8785_HPFR | WM8785_HPFL;
Clemens Ladisch75146fc2008-05-13 09:22:43 +0200229 wm8785_registers_init(chip);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100230 snd_component_add(chip->card, "WM8785");
231}
232
233static void generic_init(struct oxygen *chip)
234{
235 ak4396_init(chip);
236 wm8785_init(chip);
237}
238
239static void meridian_init(struct oxygen *chip)
240{
241 ak4396_init(chip);
242 ak5385_init(chip);
243}
244
Clemens Ladisch873591d2009-03-09 09:12:55 +0100245static void claro_enable_hp(struct oxygen *chip)
246{
247 msleep(300);
248 oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_CLARO_HP);
249 oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, GPIO_CLARO_HP);
250}
251
252static void claro_init(struct oxygen *chip)
253{
254 ak4396_init(chip);
255 wm8785_init(chip);
256 claro_enable_hp(chip);
257}
258
259static void claro_halo_init(struct oxygen *chip)
Clemens Ladischd91b4242009-02-20 09:31:14 +0100260{
261 ak4396_init(chip);
262 ak5385_init(chip);
Clemens Ladisch873591d2009-03-09 09:12:55 +0100263 claro_enable_hp(chip);
Clemens Ladischd91b4242009-02-20 09:31:14 +0100264}
265
Clemens Ladisch2146dcf2010-11-03 12:26:35 +0100266static void fantasia_init(struct oxygen *chip)
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100267{
268 ak4396_init(chip);
269 snd_component_add(chip->card, "CS5340");
270}
271
Clemens Ladisch2146dcf2010-11-03 12:26:35 +0100272static void stereo_output_init(struct oxygen *chip)
Clemens Ladisch31f86ba2010-11-02 17:18:23 +0100273{
274 ak4396_init(chip);
275}
276
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100277static void generic_cleanup(struct oxygen *chip)
278{
279}
280
Clemens Ladisch873591d2009-03-09 09:12:55 +0100281static void claro_disable_hp(struct oxygen *chip)
282{
283 oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_CLARO_HP);
284}
285
286static void claro_cleanup(struct oxygen *chip)
287{
288 claro_disable_hp(chip);
289}
290
291static void claro_suspend(struct oxygen *chip)
292{
293 claro_disable_hp(chip);
294}
295
Clemens Ladisch4a4bc532008-05-13 09:24:39 +0200296static void generic_resume(struct oxygen *chip)
297{
298 ak4396_registers_init(chip);
299 wm8785_registers_init(chip);
300}
301
Clemens Ladischc2bc4ff2008-09-22 09:05:29 +0200302static void meridian_resume(struct oxygen *chip)
303{
304 ak4396_registers_init(chip);
305}
306
Clemens Ladisch873591d2009-03-09 09:12:55 +0100307static void claro_resume(struct oxygen *chip)
Clemens Ladischd91b4242009-02-20 09:31:14 +0100308{
309 ak4396_registers_init(chip);
Clemens Ladisch873591d2009-03-09 09:12:55 +0100310 claro_enable_hp(chip);
Clemens Ladischd91b4242009-02-20 09:31:14 +0100311}
312
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100313static void stereo_resume(struct oxygen *chip)
314{
315 ak4396_registers_init(chip);
316}
317
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100318static void set_ak4396_params(struct oxygen *chip,
319 struct snd_pcm_hw_params *params)
320{
Clemens Ladisch7ef37cd2008-01-21 08:51:55 +0100321 struct generic_data *data = chip->model_data;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100322 unsigned int i;
323 u8 value;
324
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200325 value = data->ak4396_regs[0][AK4396_CONTROL_2] & ~AK4396_DFS_MASK;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100326 if (params_rate(params) <= 54000)
327 value |= AK4396_DFS_NORMAL;
Clemens Ladisch236c4922008-01-28 08:32:58 +0100328 else if (params_rate(params) <= 108000)
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100329 value |= AK4396_DFS_DOUBLE;
330 else
331 value |= AK4396_DFS_QUAD;
Clemens Ladischdf91bc22008-08-29 13:08:34 +0200332
333 msleep(1); /* wait for the new MCLK to become stable */
334
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200335 if (value != data->ak4396_regs[0][AK4396_CONTROL_2]) {
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100336 for (i = 0; i < data->dacs; ++i) {
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200337 ak4396_write(chip, i, AK4396_CONTROL_1,
338 AK4396_DIF_24_MSB);
339 ak4396_write(chip, i, AK4396_CONTROL_2, value);
340 ak4396_write(chip, i, AK4396_CONTROL_1,
341 AK4396_DIF_24_MSB | AK4396_RSTN);
342 }
343 }
344}
345
346static void update_ak4396_volume(struct oxygen *chip)
347{
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100348 struct generic_data *data = chip->model_data;
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200349 unsigned int i;
350
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100351 for (i = 0; i < data->dacs; ++i) {
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200352 ak4396_write_cached(chip, i, AK4396_LCH_ATT,
353 chip->dac_volume[i * 2]);
354 ak4396_write_cached(chip, i, AK4396_RCH_ATT,
355 chip->dac_volume[i * 2 + 1]);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100356 }
357}
358
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100359static void update_ak4396_mute(struct oxygen *chip)
360{
Clemens Ladisch7ef37cd2008-01-21 08:51:55 +0100361 struct generic_data *data = chip->model_data;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100362 unsigned int i;
363 u8 value;
364
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200365 value = data->ak4396_regs[0][AK4396_CONTROL_2] & ~AK4396_SMUTE;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100366 if (chip->dac_mute)
367 value |= AK4396_SMUTE;
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100368 for (i = 0; i < data->dacs; ++i)
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200369 ak4396_write_cached(chip, i, AK4396_CONTROL_2, value);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100370}
371
372static void set_wm8785_params(struct oxygen *chip,
373 struct snd_pcm_hw_params *params)
374{
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200375 struct generic_data *data = chip->model_data;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100376 unsigned int value;
377
Clemens Ladisch878ac3e2008-01-21 08:50:19 +0100378 value = WM8785_MCR_SLAVE | WM8785_FORMAT_LJUST;
Clemens Ladisch71e22a42008-01-21 08:50:51 +0100379 if (params_rate(params) <= 48000)
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100380 value |= WM8785_OSR_SINGLE;
Clemens Ladisch71e22a42008-01-21 08:50:51 +0100381 else if (params_rate(params) <= 96000)
382 value |= WM8785_OSR_DOUBLE;
383 else
384 value |= WM8785_OSR_QUAD;
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200385 if (value != data->wm8785_regs[0]) {
386 wm8785_write(chip, WM8785_R7, 0);
387 wm8785_write(chip, WM8785_R0, value);
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200388 wm8785_write(chip, WM8785_R2, data->wm8785_regs[2]);
Clemens Ladisch6f0de3c2009-09-28 11:18:45 +0200389 }
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100390}
391
392static void set_ak5385_params(struct oxygen *chip,
393 struct snd_pcm_hw_params *params)
394{
395 unsigned int value;
396
397 if (params_rate(params) <= 54000)
Clemens Ladisch878ac3e2008-01-21 08:50:19 +0100398 value = GPIO_AK5385_DFS_NORMAL;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100399 else if (params_rate(params) <= 108000)
Clemens Ladisch878ac3e2008-01-21 08:50:19 +0100400 value = GPIO_AK5385_DFS_DOUBLE;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100401 else
Clemens Ladisch878ac3e2008-01-21 08:50:19 +0100402 value = GPIO_AK5385_DFS_QUAD;
403 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
404 value, GPIO_AK5385_DFS_MASK);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100405}
406
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100407static void set_no_params(struct oxygen *chip, struct snd_pcm_hw_params *params)
408{
409}
410
Clemens Ladisch4852ad02009-09-28 11:21:21 +0200411static int rolloff_info(struct snd_kcontrol *ctl,
412 struct snd_ctl_elem_info *info)
413{
414 static const char *const names[2] = {
415 "Sharp Roll-off", "Slow Roll-off"
416 };
417
Clemens Ladisch96007322011-01-10 16:25:44 +0100418 return snd_ctl_enum_info(info, 1, 2, names);
Clemens Ladisch4852ad02009-09-28 11:21:21 +0200419}
420
421static int rolloff_get(struct snd_kcontrol *ctl,
422 struct snd_ctl_elem_value *value)
423{
424 struct oxygen *chip = ctl->private_data;
425 struct generic_data *data = chip->model_data;
426
427 value->value.enumerated.item[0] =
428 (data->ak4396_regs[0][AK4396_CONTROL_2] & AK4396_SLOW) != 0;
429 return 0;
430}
431
432static int rolloff_put(struct snd_kcontrol *ctl,
433 struct snd_ctl_elem_value *value)
434{
435 struct oxygen *chip = ctl->private_data;
436 struct generic_data *data = chip->model_data;
437 unsigned int i;
438 int changed;
439 u8 reg;
440
441 mutex_lock(&chip->mutex);
442 reg = data->ak4396_regs[0][AK4396_CONTROL_2];
443 if (value->value.enumerated.item[0])
444 reg |= AK4396_SLOW;
445 else
446 reg &= ~AK4396_SLOW;
447 changed = reg != data->ak4396_regs[0][AK4396_CONTROL_2];
448 if (changed) {
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100449 for (i = 0; i < data->dacs; ++i)
Clemens Ladisch4852ad02009-09-28 11:21:21 +0200450 ak4396_write(chip, i, AK4396_CONTROL_2, reg);
451 }
452 mutex_unlock(&chip->mutex);
453 return changed;
454}
455
456static const struct snd_kcontrol_new rolloff_control = {
457 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
458 .name = "DAC Filter Playback Enum",
459 .info = rolloff_info,
460 .get = rolloff_get,
461 .put = rolloff_put,
462};
463
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200464static int hpf_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
465{
466 static const char *const names[2] = {
467 "None", "High-pass Filter"
468 };
469
Clemens Ladisch96007322011-01-10 16:25:44 +0100470 return snd_ctl_enum_info(info, 1, 2, names);
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200471}
472
473static int hpf_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
474{
475 struct oxygen *chip = ctl->private_data;
476 struct generic_data *data = chip->model_data;
477
478 value->value.enumerated.item[0] =
479 (data->wm8785_regs[WM8785_R2] & WM8785_HPFR) != 0;
480 return 0;
481}
482
483static int hpf_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
484{
485 struct oxygen *chip = ctl->private_data;
486 struct generic_data *data = chip->model_data;
487 unsigned int reg;
488 int changed;
489
490 mutex_lock(&chip->mutex);
491 reg = data->wm8785_regs[WM8785_R2] & ~(WM8785_HPFR | WM8785_HPFL);
492 if (value->value.enumerated.item[0])
493 reg |= WM8785_HPFR | WM8785_HPFL;
494 changed = reg != data->wm8785_regs[WM8785_R2];
495 if (changed)
496 wm8785_write(chip, WM8785_R2, reg);
497 mutex_unlock(&chip->mutex);
498 return changed;
499}
500
501static const struct snd_kcontrol_new hpf_control = {
502 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
503 .name = "ADC Filter Capture Enum",
504 .info = hpf_info,
505 .get = hpf_get,
506 .put = hpf_put,
507};
508
Clemens Ladisch4852ad02009-09-28 11:21:21 +0200509static int generic_mixer_init(struct oxygen *chip)
510{
511 return snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
512}
513
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200514static int generic_wm8785_mixer_init(struct oxygen *chip)
515{
516 int err;
517
518 err = generic_mixer_init(chip);
519 if (err < 0)
520 return err;
521 err = snd_ctl_add(chip->card, snd_ctl_new1(&hpf_control, chip));
522 if (err < 0)
523 return err;
524 return 0;
525}
526
Clemens Ladisch9719fca2010-12-02 11:41:10 +0100527static void dump_ak4396_registers(struct oxygen *chip,
528 struct snd_info_buffer *buffer)
529{
530 struct generic_data *data = chip->model_data;
531 unsigned int dac, i;
532
533 for (dac = 0; dac < data->dacs; ++dac) {
534 snd_iprintf(buffer, "\nAK4396 %u:", dac + 1);
535 for (i = 0; i < 5; ++i)
536 snd_iprintf(buffer, " %02x", data->ak4396_regs[dac][i]);
537 }
538 snd_iprintf(buffer, "\n");
539}
540
541static void dump_wm8785_registers(struct oxygen *chip,
542 struct snd_info_buffer *buffer)
543{
544 struct generic_data *data = chip->model_data;
545 unsigned int i;
546
547 snd_iprintf(buffer, "\nWM8785:");
548 for (i = 0; i < 3; ++i)
549 snd_iprintf(buffer, " %03x", data->wm8785_regs[i]);
550 snd_iprintf(buffer, "\n");
551}
552
553static void dump_oxygen_registers(struct oxygen *chip,
554 struct snd_info_buffer *buffer)
555{
556 dump_ak4396_registers(chip, buffer);
557 dump_wm8785_registers(chip, buffer);
558}
559
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100560static const DECLARE_TLV_DB_LINEAR(ak4396_db_scale, TLV_DB_GAIN_MUTE, 0);
561
562static const struct oxygen_model model_generic = {
563 .shortname = "C-Media CMI8788",
564 .longname = "C-Media Oxygen HD Audio",
565 .chip = "CMI8788",
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100566 .init = generic_init,
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200567 .mixer_init = generic_wm8785_mixer_init,
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100568 .cleanup = generic_cleanup,
Clemens Ladisch4a4bc532008-05-13 09:24:39 +0200569 .resume = generic_resume,
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100570 .set_dac_params = set_ak4396_params,
571 .set_adc_params = set_wm8785_params,
572 .update_dac_volume = update_ak4396_volume,
573 .update_dac_mute = update_ak4396_mute,
Clemens Ladisch9719fca2010-12-02 11:41:10 +0100574 .dump_registers = dump_oxygen_registers,
Clemens Ladisch4972a172008-04-16 09:15:45 +0200575 .dac_tlv = ak4396_db_scale,
Clemens Ladisch7ef37cd2008-01-21 08:51:55 +0100576 .model_data_size = sizeof(struct generic_data),
Clemens Ladischd76596b2008-09-22 09:02:08 +0200577 .device_config = PLAYBACK_0_TO_I2S |
578 PLAYBACK_1_TO_SPDIF |
579 PLAYBACK_2_TO_AC97_1 |
580 CAPTURE_0_FROM_I2S_1 |
581 CAPTURE_1_FROM_SPDIF |
Clemens Ladischb6ca8ab2010-10-04 13:21:52 +0200582 CAPTURE_2_FROM_AC97_1 |
583 AC97_CD_INPUT,
Clemens Ladisch1f4d7be2011-01-10 15:59:38 +0100584 .dac_channels_pcm = 8,
585 .dac_channels_mixer = 8,
Clemens Ladisch193e8132008-04-16 09:13:36 +0200586 .dac_volume_min = 0,
587 .dac_volume_max = 255,
Clemens Ladisch87eedd22008-03-19 08:20:13 +0100588 .function_flags = OXYGEN_FUNCTION_SPI |
589 OXYGEN_FUNCTION_ENABLE_SPI_4_5,
Clemens Ladischce2c4922011-01-10 16:16:08 +0100590 .dac_mclks = OXYGEN_MCLKS(256, 128, 128),
Clemens Ladisch5b8bf2a2011-01-10 16:14:52 +0100591 .adc_mclks = OXYGEN_MCLKS(256, 256, 128),
Clemens Ladisch05855ba2008-01-17 09:05:09 +0100592 .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
593 .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100594};
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100595
Clemens Ladisch30459d72009-02-19 08:42:44 +0100596static int __devinit get_oxygen_model(struct oxygen *chip,
597 const struct pci_device_id *id)
598{
599 chip->model = model_generic;
600 switch (id->driver_data) {
601 case MODEL_MERIDIAN:
602 chip->model.init = meridian_init;
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200603 chip->model.mixer_init = generic_mixer_init;
Clemens Ladisch30459d72009-02-19 08:42:44 +0100604 chip->model.resume = meridian_resume;
605 chip->model.set_adc_params = set_ak5385_params;
Clemens Ladisch9719fca2010-12-02 11:41:10 +0100606 chip->model.dump_registers = dump_ak4396_registers;
Clemens Ladisch30459d72009-02-19 08:42:44 +0100607 chip->model.device_config = PLAYBACK_0_TO_I2S |
608 PLAYBACK_1_TO_SPDIF |
609 CAPTURE_0_FROM_I2S_2 |
610 CAPTURE_1_FROM_SPDIF;
611 break;
Clemens Ladisch873591d2009-03-09 09:12:55 +0100612 case MODEL_CLARO:
613 chip->model.init = claro_init;
614 chip->model.cleanup = claro_cleanup;
615 chip->model.suspend = claro_suspend;
616 chip->model.resume = claro_resume;
617 break;
618 case MODEL_CLARO_HALO:
619 chip->model.init = claro_halo_init;
Clemens Ladisch1ff04882009-09-28 11:21:51 +0200620 chip->model.mixer_init = generic_mixer_init;
Clemens Ladisch873591d2009-03-09 09:12:55 +0100621 chip->model.cleanup = claro_cleanup;
622 chip->model.suspend = claro_suspend;
623 chip->model.resume = claro_resume;
Clemens Ladischd91b4242009-02-20 09:31:14 +0100624 chip->model.set_adc_params = set_ak5385_params;
Clemens Ladisch9719fca2010-12-02 11:41:10 +0100625 chip->model.dump_registers = dump_ak4396_registers;
Erik J. Staab0873a5a2010-09-22 11:07:41 +0200626 chip->model.device_config = PLAYBACK_0_TO_I2S |
627 PLAYBACK_1_TO_SPDIF |
628 CAPTURE_0_FROM_I2S_2 |
629 CAPTURE_1_FROM_SPDIF;
Clemens Ladischd91b4242009-02-20 09:31:14 +0100630 break;
Clemens Ladisch2146dcf2010-11-03 12:26:35 +0100631 case MODEL_FANTASIA:
632 case MODEL_2CH_OUTPUT:
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100633 chip->model.shortname = "C-Media CMI8787";
634 chip->model.chip = "CMI8787";
Clemens Ladisch2146dcf2010-11-03 12:26:35 +0100635 if (id->driver_data == MODEL_FANTASIA)
636 chip->model.init = fantasia_init;
Clemens Ladisch31f86ba2010-11-02 17:18:23 +0100637 else
Clemens Ladisch2146dcf2010-11-03 12:26:35 +0100638 chip->model.init = stereo_output_init;
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100639 chip->model.resume = stereo_resume;
640 chip->model.mixer_init = generic_mixer_init;
641 chip->model.set_adc_params = set_no_params;
Clemens Ladisch9719fca2010-12-02 11:41:10 +0100642 chip->model.dump_registers = dump_ak4396_registers;
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100643 chip->model.device_config = PLAYBACK_0_TO_I2S |
Clemens Ladisch31f86ba2010-11-02 17:18:23 +0100644 PLAYBACK_1_TO_SPDIF;
Clemens Ladischce2c4922011-01-10 16:16:08 +0100645 if (id->driver_data == MODEL_FANTASIA) {
Clemens Ladisch31f86ba2010-11-02 17:18:23 +0100646 chip->model.device_config |= CAPTURE_0_FROM_I2S_1;
Clemens Ladischce2c4922011-01-10 16:16:08 +0100647 chip->model.adc_mclks = OXYGEN_MCLKS(256, 128, 128);
648 }
Clemens Ladisch1f4d7be2011-01-10 15:59:38 +0100649 chip->model.dac_channels_pcm = 2;
650 chip->model.dac_channels_mixer = 2;
Clemens Ladisch45c1de82010-11-02 17:08:37 +0100651 break;
Clemens Ladisch66410bf2011-01-10 16:20:29 +0100652 case MODEL_XONAR_DG:
653 chip->model = model_xonar_dg;
654 break;
Clemens Ladisch30459d72009-02-19 08:42:44 +0100655 }
656 if (id->driver_data == MODEL_MERIDIAN ||
Clemens Ladisch873591d2009-03-09 09:12:55 +0100657 id->driver_data == MODEL_CLARO_HALO) {
Clemens Ladisch30459d72009-02-19 08:42:44 +0100658 chip->model.misc_flags = OXYGEN_MISC_MIDI;
659 chip->model.device_config |= MIDI_OUTPUT | MIDI_INPUT;
660 }
661 return 0;
662}
663
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100664static int __devinit generic_oxygen_probe(struct pci_dev *pci,
665 const struct pci_device_id *pci_id)
666{
667 static int dev;
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100668 int err;
669
670 if (dev >= SNDRV_CARDS)
671 return -ENODEV;
672 if (!enable[dev]) {
673 ++dev;
674 return -ENOENT;
675 }
Clemens Ladischbb718582009-02-19 08:37:13 +0100676 err = oxygen_pci_probe(pci, index[dev], id[dev], THIS_MODULE,
Clemens Ladisch30459d72009-02-19 08:42:44 +0100677 oxygen_ids, get_oxygen_model);
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100678 if (err >= 0)
679 ++dev;
680 return err;
681}
682
683static struct pci_driver oxygen_driver = {
684 .name = "CMI8788",
685 .id_table = oxygen_ids,
686 .probe = generic_oxygen_probe,
687 .remove = __devexit_p(oxygen_pci_remove),
Clemens Ladisch4a4bc532008-05-13 09:24:39 +0200688#ifdef CONFIG_PM
689 .suspend = oxygen_pci_suspend,
690 .resume = oxygen_pci_resume,
691#endif
Clemens Ladischd0ce9942007-12-23 19:50:57 +0100692};
693
694static int __init alsa_card_oxygen_init(void)
695{
696 return pci_register_driver(&oxygen_driver);
697}
698
699static void __exit alsa_card_oxygen_exit(void)
700{
701 pci_unregister_driver(&oxygen_driver);
702}
703
704module_init(alsa_card_oxygen_init)
705module_exit(alsa_card_oxygen_exit)