blob: 5b9d6c18bc45a0479d1374480d64a47151b4801c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Jaroslav Kyselac1017a42007-10-15 09:50:19 +02002 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 * Routines for control of CS4231(A)/CS4232/InterWave & compatible chips
4 *
5 * Bugs:
Krzysztof Helt9295aea2008-07-31 21:00:17 +02006 * - sometimes record brokes playback with WSS portion of
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Yamaha OPL3-SA3 chip
8 * - CS4231 (GUS MAX) - still trouble with occasional noises
Krzysztof Helt7779f752008-07-31 21:03:41 +02009 * - broken initialization?
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/delay.h>
28#include <linux/pm.h>
29#include <linux/init.h>
30#include <linux/interrupt.h>
31#include <linux/slab.h>
32#include <linux/ioport.h>
33#include <sound/core.h>
Krzysztof Helt61ef19d2008-07-31 21:02:42 +020034#include <sound/wss.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <sound/pcm_params.h>
Krzysztof Helt5664daa2008-07-31 21:08:32 +020036#include <sound/tlv.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38#include <asm/io.h>
39#include <asm/dma.h>
40#include <asm/irq.h>
41
Jaroslav Kyselac1017a42007-10-15 09:50:19 +020042MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
Linus Torvalds1da177e2005-04-16 15:20:36 -070043MODULE_DESCRIPTION("Routines for control of CS4231(A)/CS4232/InterWave & compatible chips");
44MODULE_LICENSE("GPL");
45
46#if 0
47#define SNDRV_DEBUG_MCE
48#endif
49
50/*
51 * Some variables
52 */
53
54static unsigned char freq_bits[14] = {
55 /* 5510 */ 0x00 | CS4231_XTAL2,
56 /* 6620 */ 0x0E | CS4231_XTAL2,
57 /* 8000 */ 0x00 | CS4231_XTAL1,
58 /* 9600 */ 0x0E | CS4231_XTAL1,
59 /* 11025 */ 0x02 | CS4231_XTAL2,
60 /* 16000 */ 0x02 | CS4231_XTAL1,
61 /* 18900 */ 0x04 | CS4231_XTAL2,
62 /* 22050 */ 0x06 | CS4231_XTAL2,
63 /* 27042 */ 0x04 | CS4231_XTAL1,
64 /* 32000 */ 0x06 | CS4231_XTAL1,
65 /* 33075 */ 0x0C | CS4231_XTAL2,
66 /* 37800 */ 0x08 | CS4231_XTAL2,
67 /* 44100 */ 0x0A | CS4231_XTAL2,
68 /* 48000 */ 0x0C | CS4231_XTAL1
69};
70
71static unsigned int rates[14] = {
72 5510, 6620, 8000, 9600, 11025, 16000, 18900, 22050,
73 27042, 32000, 33075, 37800, 44100, 48000
74};
75
Takashi Iwaiba2375a2005-11-17 14:30:42 +010076static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
Krzysztof Helt6c041b52007-09-06 15:03:59 +020077 .count = ARRAY_SIZE(rates),
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 .list = rates,
79 .mask = 0,
80};
81
Krzysztof Helt7779f752008-07-31 21:03:41 +020082static int snd_wss_xrate(struct snd_pcm_runtime *runtime)
Linus Torvalds1da177e2005-04-16 15:20:36 -070083{
Krzysztof Helt7779f752008-07-31 21:03:41 +020084 return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
85 &hw_constraints_rates);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
Krzysztof Helt7779f752008-07-31 21:03:41 +020088static unsigned char snd_wss_original_image[32] =
Linus Torvalds1da177e2005-04-16 15:20:36 -070089{
90 0x00, /* 00/00 - lic */
91 0x00, /* 01/01 - ric */
92 0x9f, /* 02/02 - la1ic */
93 0x9f, /* 03/03 - ra1ic */
94 0x9f, /* 04/04 - la2ic */
95 0x9f, /* 05/05 - ra2ic */
96 0xbf, /* 06/06 - loc */
97 0xbf, /* 07/07 - roc */
98 0x20, /* 08/08 - pdfr */
99 CS4231_AUTOCALIB, /* 09/09 - ic */
100 0x00, /* 0a/10 - pc */
101 0x00, /* 0b/11 - ti */
102 CS4231_MODE2, /* 0c/12 - mi */
103 0xfc, /* 0d/13 - lbc */
104 0x00, /* 0e/14 - pbru */
105 0x00, /* 0f/15 - pbrl */
106 0x80, /* 10/16 - afei */
107 0x01, /* 11/17 - afeii */
108 0x9f, /* 12/18 - llic */
109 0x9f, /* 13/19 - rlic */
110 0x00, /* 14/20 - tlb */
111 0x00, /* 15/21 - thb */
112 0x00, /* 16/22 - la3mic/reserved */
113 0x00, /* 17/23 - ra3mic/reserved */
114 0x00, /* 18/24 - afs */
115 0x00, /* 19/25 - lamoc/version */
116 0xcf, /* 1a/26 - mioc */
117 0x00, /* 1b/27 - ramoc/reserved */
118 0x20, /* 1c/28 - cdfr */
119 0x00, /* 1d/29 - res4 */
120 0x00, /* 1e/30 - cbru */
121 0x00, /* 1f/31 - cbrl */
122};
123
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +0200124static unsigned char snd_opti93x_original_image[32] =
125{
126 0x00, /* 00/00 - l_mixout_outctrl */
127 0x00, /* 01/01 - r_mixout_outctrl */
128 0x88, /* 02/02 - l_cd_inctrl */
129 0x88, /* 03/03 - r_cd_inctrl */
130 0x88, /* 04/04 - l_a1/fm_inctrl */
131 0x88, /* 05/05 - r_a1/fm_inctrl */
132 0x80, /* 06/06 - l_dac_inctrl */
133 0x80, /* 07/07 - r_dac_inctrl */
134 0x00, /* 08/08 - ply_dataform_reg */
135 0x00, /* 09/09 - if_conf */
136 0x00, /* 0a/10 - pin_ctrl */
137 0x00, /* 0b/11 - err_init_reg */
138 0x0a, /* 0c/12 - id_reg */
139 0x00, /* 0d/13 - reserved */
140 0x00, /* 0e/14 - ply_upcount_reg */
141 0x00, /* 0f/15 - ply_lowcount_reg */
142 0x88, /* 10/16 - reserved/l_a1_inctrl */
143 0x88, /* 11/17 - reserved/r_a1_inctrl */
144 0x88, /* 12/18 - l_line_inctrl */
145 0x88, /* 13/19 - r_line_inctrl */
146 0x88, /* 14/20 - l_mic_inctrl */
147 0x88, /* 15/21 - r_mic_inctrl */
148 0x80, /* 16/22 - l_out_outctrl */
149 0x80, /* 17/23 - r_out_outctrl */
150 0x00, /* 18/24 - reserved */
151 0x00, /* 19/25 - reserved */
152 0x00, /* 1a/26 - reserved */
153 0x00, /* 1b/27 - reserved */
154 0x00, /* 1c/28 - cap_dataform_reg */
155 0x00, /* 1d/29 - reserved */
156 0x00, /* 1e/30 - cap_upcount_reg */
157 0x00 /* 1f/31 - cap_lowcount_reg */
158};
159
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160/*
161 * Basic I/O functions
162 */
163
Krzysztof Helt7779f752008-07-31 21:03:41 +0200164static inline void wss_outb(struct snd_wss *chip, u8 offset, u8 val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 outb(val, chip->port + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Krzysztof Helt7779f752008-07-31 21:03:41 +0200169static inline u8 wss_inb(struct snd_wss *chip, u8 offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return inb(chip->port + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172}
173
Krzysztof Helt7779f752008-07-31 21:03:41 +0200174static void snd_wss_wait(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175{
176 int timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
178 for (timeout = 250;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200179 timeout > 0 && (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 timeout--)
Krzysztof Helt9295aea2008-07-31 21:00:17 +0200181 udelay(100);
Krzysztof Helt6c041b52007-09-06 15:03:59 +0200182}
183
Krzysztof Helt7779f752008-07-31 21:03:41 +0200184static void snd_wss_dout(struct snd_wss *chip, unsigned char reg,
185 unsigned char value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186{
187 int timeout;
188
189 for (timeout = 250;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200190 timeout > 0 && (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 timeout--)
Krzysztof Helt9295aea2008-07-31 21:00:17 +0200192 udelay(10);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200193 wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
194 wss_outb(chip, CS4231P(REG), value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 mb();
196}
197
Krzysztof Helt7779f752008-07-31 21:03:41 +0200198void snd_wss_out(struct snd_wss *chip, unsigned char reg, unsigned char value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200200 snd_wss_wait(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201#ifdef CONFIG_SND_DEBUG
Krzysztof Helt7779f752008-07-31 21:03:41 +0200202 if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
Takashi Iwai76d498e2009-02-05 15:45:05 +0100203 snd_printk(KERN_DEBUG "out: auto calibration time out "
204 "- reg = 0x%x, value = 0x%x\n", reg, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205#endif
Krzysztof Helt7779f752008-07-31 21:03:41 +0200206 wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
207 wss_outb(chip, CS4231P(REG), value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 chip->image[reg] = value;
209 mb();
Krzysztof Helt6c041b52007-09-06 15:03:59 +0200210 snd_printdd("codec out - reg 0x%x = 0x%x\n",
211 chip->mce_bit | reg, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212}
Krzysztof Helt7779f752008-07-31 21:03:41 +0200213EXPORT_SYMBOL(snd_wss_out);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
Krzysztof Helt7779f752008-07-31 21:03:41 +0200215unsigned char snd_wss_in(struct snd_wss *chip, unsigned char reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200217 snd_wss_wait(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218#ifdef CONFIG_SND_DEBUG
Krzysztof Helt7779f752008-07-31 21:03:41 +0200219 if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
Takashi Iwai76d498e2009-02-05 15:45:05 +0100220 snd_printk(KERN_DEBUG "in: auto calibration time out "
221 "- reg = 0x%x\n", reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222#endif
Krzysztof Helt7779f752008-07-31 21:03:41 +0200223 wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 mb();
Krzysztof Helt7779f752008-07-31 21:03:41 +0200225 return wss_inb(chip, CS4231P(REG));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226}
Krzysztof Helt7779f752008-07-31 21:03:41 +0200227EXPORT_SYMBOL(snd_wss_in);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Krzysztof Helt7779f752008-07-31 21:03:41 +0200229void snd_cs4236_ext_out(struct snd_wss *chip, unsigned char reg,
230 unsigned char val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200232 wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | 0x17);
233 wss_outb(chip, CS4231P(REG),
234 reg | (chip->image[CS4236_EXT_REG] & 0x01));
235 wss_outb(chip, CS4231P(REG), val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 chip->eimage[CS4236_REG(reg)] = val;
237#if 0
Takashi Iwai76d498e2009-02-05 15:45:05 +0100238 printk(KERN_DEBUG "ext out : reg = 0x%x, val = 0x%x\n", reg, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239#endif
240}
Krzysztof Helt7779f752008-07-31 21:03:41 +0200241EXPORT_SYMBOL(snd_cs4236_ext_out);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
Krzysztof Helt7779f752008-07-31 21:03:41 +0200243unsigned char snd_cs4236_ext_in(struct snd_wss *chip, unsigned char reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200245 wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | 0x17);
246 wss_outb(chip, CS4231P(REG),
247 reg | (chip->image[CS4236_EXT_REG] & 0x01));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248#if 1
Krzysztof Helt7779f752008-07-31 21:03:41 +0200249 return wss_inb(chip, CS4231P(REG));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250#else
251 {
252 unsigned char res;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200253 res = wss_inb(chip, CS4231P(REG));
Takashi Iwai76d498e2009-02-05 15:45:05 +0100254 printk(KERN_DEBUG "ext in : reg = 0x%x, val = 0x%x\n",
255 reg, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 return res;
257 }
258#endif
259}
Krzysztof Helt7779f752008-07-31 21:03:41 +0200260EXPORT_SYMBOL(snd_cs4236_ext_in);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
262#if 0
263
Krzysztof Helt7779f752008-07-31 21:03:41 +0200264static void snd_wss_debug(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200266 printk(KERN_DEBUG
267 "CS4231 REGS: INDEX = 0x%02x "
268 " STATUS = 0x%02x\n",
Rene Herman3caf8c02008-08-08 16:39:21 +0200269 wss_inb(chip, CS4231P(REGSEL)),
Krzysztof Helt7779f752008-07-31 21:03:41 +0200270 wss_inb(chip, CS4231P(STATUS)));
271 printk(KERN_DEBUG
272 " 0x00: left input = 0x%02x "
273 " 0x10: alt 1 (CFIG 2) = 0x%02x\n",
274 snd_wss_in(chip, 0x00),
275 snd_wss_in(chip, 0x10));
276 printk(KERN_DEBUG
277 " 0x01: right input = 0x%02x "
278 " 0x11: alt 2 (CFIG 3) = 0x%02x\n",
279 snd_wss_in(chip, 0x01),
280 snd_wss_in(chip, 0x11));
281 printk(KERN_DEBUG
282 " 0x02: GF1 left input = 0x%02x "
283 " 0x12: left line in = 0x%02x\n",
284 snd_wss_in(chip, 0x02),
285 snd_wss_in(chip, 0x12));
286 printk(KERN_DEBUG
287 " 0x03: GF1 right input = 0x%02x "
288 " 0x13: right line in = 0x%02x\n",
289 snd_wss_in(chip, 0x03),
290 snd_wss_in(chip, 0x13));
291 printk(KERN_DEBUG
292 " 0x04: CD left input = 0x%02x "
293 " 0x14: timer low = 0x%02x\n",
294 snd_wss_in(chip, 0x04),
295 snd_wss_in(chip, 0x14));
296 printk(KERN_DEBUG
297 " 0x05: CD right input = 0x%02x "
298 " 0x15: timer high = 0x%02x\n",
299 snd_wss_in(chip, 0x05),
300 snd_wss_in(chip, 0x15));
301 printk(KERN_DEBUG
302 " 0x06: left output = 0x%02x "
303 " 0x16: left MIC (PnP) = 0x%02x\n",
304 snd_wss_in(chip, 0x06),
305 snd_wss_in(chip, 0x16));
306 printk(KERN_DEBUG
307 " 0x07: right output = 0x%02x "
308 " 0x17: right MIC (PnP) = 0x%02x\n",
309 snd_wss_in(chip, 0x07),
310 snd_wss_in(chip, 0x17));
311 printk(KERN_DEBUG
312 " 0x08: playback format = 0x%02x "
313 " 0x18: IRQ status = 0x%02x\n",
314 snd_wss_in(chip, 0x08),
315 snd_wss_in(chip, 0x18));
316 printk(KERN_DEBUG
317 " 0x09: iface (CFIG 1) = 0x%02x "
318 " 0x19: left line out = 0x%02x\n",
319 snd_wss_in(chip, 0x09),
320 snd_wss_in(chip, 0x19));
321 printk(KERN_DEBUG
322 " 0x0a: pin control = 0x%02x "
323 " 0x1a: mono control = 0x%02x\n",
324 snd_wss_in(chip, 0x0a),
325 snd_wss_in(chip, 0x1a));
326 printk(KERN_DEBUG
327 " 0x0b: init & status = 0x%02x "
328 " 0x1b: right line out = 0x%02x\n",
329 snd_wss_in(chip, 0x0b),
330 snd_wss_in(chip, 0x1b));
331 printk(KERN_DEBUG
332 " 0x0c: revision & mode = 0x%02x "
333 " 0x1c: record format = 0x%02x\n",
334 snd_wss_in(chip, 0x0c),
335 snd_wss_in(chip, 0x1c));
336 printk(KERN_DEBUG
337 " 0x0d: loopback = 0x%02x "
338 " 0x1d: var freq (PnP) = 0x%02x\n",
339 snd_wss_in(chip, 0x0d),
340 snd_wss_in(chip, 0x1d));
341 printk(KERN_DEBUG
342 " 0x0e: ply upr count = 0x%02x "
343 " 0x1e: ply lwr count = 0x%02x\n",
344 snd_wss_in(chip, 0x0e),
345 snd_wss_in(chip, 0x1e));
346 printk(KERN_DEBUG
347 " 0x0f: rec upr count = 0x%02x "
348 " 0x1f: rec lwr count = 0x%02x\n",
349 snd_wss_in(chip, 0x0f),
350 snd_wss_in(chip, 0x1f));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
353#endif
354
355/*
356 * CS4231 detection / MCE routines
357 */
358
Krzysztof Helt7779f752008-07-31 21:03:41 +0200359static void snd_wss_busy_wait(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
361 int timeout;
362
363 /* huh.. looks like this sequence is proper for CS4231A chip (GUS MAX) */
364 for (timeout = 5; timeout > 0; timeout--)
Krzysztof Helt7779f752008-07-31 21:03:41 +0200365 wss_inb(chip, CS4231P(REGSEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 /* end of cleanup sequence */
Krzysztof Heltead893c2008-07-31 21:09:32 +0200367 for (timeout = 25000;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200368 timeout > 0 && (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 timeout--)
Krzysztof Helt9295aea2008-07-31 21:00:17 +0200370 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371}
372
Krzysztof Helt7779f752008-07-31 21:03:41 +0200373void snd_wss_mce_up(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374{
375 unsigned long flags;
376 int timeout;
377
Krzysztof Helt7779f752008-07-31 21:03:41 +0200378 snd_wss_wait(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379#ifdef CONFIG_SND_DEBUG
Krzysztof Helt7779f752008-07-31 21:03:41 +0200380 if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
Takashi Iwai76d498e2009-02-05 15:45:05 +0100381 snd_printk(KERN_DEBUG
382 "mce_up - auto calibration time out (0)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383#endif
384 spin_lock_irqsave(&chip->reg_lock, flags);
385 chip->mce_bit |= CS4231_MCE;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200386 timeout = wss_inb(chip, CS4231P(REGSEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 if (timeout == 0x80)
Takashi Iwai76d498e2009-02-05 15:45:05 +0100388 snd_printk(KERN_DEBUG "mce_up [0x%lx]: "
389 "serious init problem - codec still busy\n",
390 chip->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 if (!(timeout & CS4231_MCE))
Krzysztof Helt7779f752008-07-31 21:03:41 +0200392 wss_outb(chip, CS4231P(REGSEL),
393 chip->mce_bit | (timeout & 0x1f));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 spin_unlock_irqrestore(&chip->reg_lock, flags);
395}
Krzysztof Helt7779f752008-07-31 21:03:41 +0200396EXPORT_SYMBOL(snd_wss_mce_up);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Krzysztof Helt7779f752008-07-31 21:03:41 +0200398void snd_wss_mce_down(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399{
400 unsigned long flags;
Takashi Iwaib875d652007-09-11 10:12:14 +0200401 unsigned long end_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 int timeout;
Krzysztof Heltead893c2008-07-31 21:09:32 +0200403 int hw_mask = WSS_HW_CS4231_MASK | WSS_HW_CS4232_MASK | WSS_HW_AD1848;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
Krzysztof Helt7779f752008-07-31 21:03:41 +0200405 snd_wss_busy_wait(chip);
Rene Hermand44df2d2007-09-10 23:22:55 +0200406
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407#ifdef CONFIG_SND_DEBUG
Krzysztof Helt7779f752008-07-31 21:03:41 +0200408 if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
Takashi Iwai76d498e2009-02-05 15:45:05 +0100409 snd_printk(KERN_DEBUG "mce_down [0x%lx] - "
410 "auto calibration time out (0)\n",
411 (long)CS4231P(REGSEL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412#endif
413 spin_lock_irqsave(&chip->reg_lock, flags);
414 chip->mce_bit &= ~CS4231_MCE;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200415 timeout = wss_inb(chip, CS4231P(REGSEL));
416 wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 spin_unlock_irqrestore(&chip->reg_lock, flags);
418 if (timeout == 0x80)
Takashi Iwai76d498e2009-02-05 15:45:05 +0100419 snd_printk(KERN_DEBUG "mce_down [0x%lx]: "
420 "serious init problem - codec still busy\n",
421 chip->port);
Krzysztof Heltead893c2008-07-31 21:09:32 +0200422 if ((timeout & CS4231_MCE) == 0 || !(chip->hardware & hw_mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
Rene Herman90cf9b82007-09-10 23:19:55 +0200425 /*
426 * Wait for (possible -- during init auto-calibration may not be set)
427 * calibration process to start. Needs upto 5 sample periods on AD1848
428 * which at the slowest possible rate of 5.5125 kHz means 907 us.
429 */
430 msleep(1);
Rene Hermand44df2d2007-09-10 23:22:55 +0200431
432 snd_printdd("(1) jiffies = %lu\n", jiffies);
433
Krzysztof Helt23d46352007-09-11 00:40:42 +0200434 /* check condition up to 250 ms */
Takashi Iwaib875d652007-09-11 10:12:14 +0200435 end_time = jiffies + msecs_to_jiffies(250);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200436 while (snd_wss_in(chip, CS4231_TEST_INIT) &
Krzysztof Helt23d46352007-09-11 00:40:42 +0200437 CS4231_CALIB_IN_PROGRESS) {
438
Takashi Iwaib875d652007-09-11 10:12:14 +0200439 if (time_after(jiffies, end_time)) {
Krzysztof Helt23d46352007-09-11 00:40:42 +0200440 snd_printk(KERN_ERR "mce_down - "
441 "auto calibration time out (2)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 return;
443 }
Takashi Iwaib875d652007-09-11 10:12:14 +0200444 msleep(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 }
Rene Hermand44df2d2007-09-10 23:22:55 +0200446
447 snd_printdd("(2) jiffies = %lu\n", jiffies);
448
Krzysztof Helt23d46352007-09-11 00:40:42 +0200449 /* check condition up to 100 ms */
Takashi Iwaib875d652007-09-11 10:12:14 +0200450 end_time = jiffies + msecs_to_jiffies(100);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200451 while (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT) {
Takashi Iwaib875d652007-09-11 10:12:14 +0200452 if (time_after(jiffies, end_time)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 snd_printk(KERN_ERR "mce_down - auto calibration time out (3)\n");
454 return;
455 }
Takashi Iwaib875d652007-09-11 10:12:14 +0200456 msleep(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 }
Rene Hermand44df2d2007-09-10 23:22:55 +0200458
459 snd_printdd("(3) jiffies = %lu\n", jiffies);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200460 snd_printd("mce_down - exit = 0x%x\n", wss_inb(chip, CS4231P(REGSEL)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461}
Krzysztof Helt7779f752008-07-31 21:03:41 +0200462EXPORT_SYMBOL(snd_wss_mce_down);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Krzysztof Helt7779f752008-07-31 21:03:41 +0200464static unsigned int snd_wss_get_count(unsigned char format, unsigned int size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
466 switch (format & 0xe0) {
467 case CS4231_LINEAR_16:
468 case CS4231_LINEAR_16_BIG:
469 size >>= 1;
470 break;
471 case CS4231_ADPCM_16:
472 return size >> 2;
473 }
474 if (format & CS4231_STEREO)
475 size >>= 1;
476 return size;
477}
478
Krzysztof Helt7779f752008-07-31 21:03:41 +0200479static int snd_wss_trigger(struct snd_pcm_substream *substream,
480 int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200482 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 int result = 0;
484 unsigned int what;
Takashi Iwaiba2375a2005-11-17 14:30:42 +0100485 struct snd_pcm_substream *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 int do_start;
487
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 switch (cmd) {
489 case SNDRV_PCM_TRIGGER_START:
490 case SNDRV_PCM_TRIGGER_RESUME:
491 do_start = 1; break;
492 case SNDRV_PCM_TRIGGER_STOP:
493 case SNDRV_PCM_TRIGGER_SUSPEND:
494 do_start = 0; break;
495 default:
496 return -EINVAL;
497 }
498
499 what = 0;
Takashi Iwaief991b92007-02-22 12:52:53 +0100500 snd_pcm_group_for_each_entry(s, substream) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 if (s == chip->playback_substream) {
502 what |= CS4231_PLAYBACK_ENABLE;
503 snd_pcm_trigger_done(s, substream);
504 } else if (s == chip->capture_substream) {
505 what |= CS4231_RECORD_ENABLE;
506 snd_pcm_trigger_done(s, substream);
507 }
508 }
509 spin_lock(&chip->reg_lock);
510 if (do_start) {
511 chip->image[CS4231_IFACE_CTRL] |= what;
512 if (chip->trigger)
513 chip->trigger(chip, what, 1);
514 } else {
515 chip->image[CS4231_IFACE_CTRL] &= ~what;
516 if (chip->trigger)
517 chip->trigger(chip, what, 0);
518 }
Krzysztof Helt7779f752008-07-31 21:03:41 +0200519 snd_wss_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 spin_unlock(&chip->reg_lock);
521#if 0
Krzysztof Helt7779f752008-07-31 21:03:41 +0200522 snd_wss_debug(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523#endif
524 return result;
525}
526
527/*
528 * CODEC I/O
529 */
530
Krzysztof Helt7779f752008-07-31 21:03:41 +0200531static unsigned char snd_wss_get_rate(unsigned int rate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532{
533 int i;
534
Krzysztof Helt6c041b52007-09-06 15:03:59 +0200535 for (i = 0; i < ARRAY_SIZE(rates); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 if (rate == rates[i])
537 return freq_bits[i];
538 // snd_BUG();
Krzysztof Helt6c041b52007-09-06 15:03:59 +0200539 return freq_bits[ARRAY_SIZE(rates) - 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540}
541
Krzysztof Helt7779f752008-07-31 21:03:41 +0200542static unsigned char snd_wss_get_format(struct snd_wss *chip,
543 int format,
544 int channels)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545{
546 unsigned char rformat;
547
548 rformat = CS4231_LINEAR_8;
549 switch (format) {
550 case SNDRV_PCM_FORMAT_MU_LAW: rformat = CS4231_ULAW_8; break;
551 case SNDRV_PCM_FORMAT_A_LAW: rformat = CS4231_ALAW_8; break;
552 case SNDRV_PCM_FORMAT_S16_LE: rformat = CS4231_LINEAR_16; break;
553 case SNDRV_PCM_FORMAT_S16_BE: rformat = CS4231_LINEAR_16_BIG; break;
554 case SNDRV_PCM_FORMAT_IMA_ADPCM: rformat = CS4231_ADPCM_16; break;
555 }
556 if (channels > 1)
557 rformat |= CS4231_STEREO;
558#if 0
Takashi Iwai76d498e2009-02-05 15:45:05 +0100559 snd_printk(KERN_DEBUG "get_format: 0x%x (mode=0x%x)\n", format, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560#endif
561 return rformat;
562}
563
Krzysztof Helt7779f752008-07-31 21:03:41 +0200564static void snd_wss_calibrate_mute(struct snd_wss *chip, int mute)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
566 unsigned long flags;
567
Krzysztof Heltace457c2008-08-17 22:38:27 +0200568 mute = mute ? 0x80 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 spin_lock_irqsave(&chip->reg_lock, flags);
570 if (chip->calibrate_mute == mute) {
571 spin_unlock_irqrestore(&chip->reg_lock, flags);
572 return;
573 }
574 if (!mute) {
Krzysztof Helt7779f752008-07-31 21:03:41 +0200575 snd_wss_dout(chip, CS4231_LEFT_INPUT,
576 chip->image[CS4231_LEFT_INPUT]);
577 snd_wss_dout(chip, CS4231_RIGHT_INPUT,
578 chip->image[CS4231_RIGHT_INPUT]);
579 snd_wss_dout(chip, CS4231_LOOPBACK,
580 chip->image[CS4231_LOOPBACK]);
Krzysztof Helt9ef344f2009-01-16 22:47:30 +0100581 } else {
582 snd_wss_dout(chip, CS4231_LEFT_INPUT,
583 0);
584 snd_wss_dout(chip, CS4231_RIGHT_INPUT,
585 0);
586 snd_wss_dout(chip, CS4231_LOOPBACK,
587 0xfd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 }
Krzysztof Helt9ef344f2009-01-16 22:47:30 +0100589
Krzysztof Helt7779f752008-07-31 21:03:41 +0200590 snd_wss_dout(chip, CS4231_AUX1_LEFT_INPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200591 mute | chip->image[CS4231_AUX1_LEFT_INPUT]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200592 snd_wss_dout(chip, CS4231_AUX1_RIGHT_INPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200593 mute | chip->image[CS4231_AUX1_RIGHT_INPUT]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200594 snd_wss_dout(chip, CS4231_AUX2_LEFT_INPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200595 mute | chip->image[CS4231_AUX2_LEFT_INPUT]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200596 snd_wss_dout(chip, CS4231_AUX2_RIGHT_INPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200597 mute | chip->image[CS4231_AUX2_RIGHT_INPUT]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200598 snd_wss_dout(chip, CS4231_LEFT_OUTPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200599 mute | chip->image[CS4231_LEFT_OUTPUT]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200600 snd_wss_dout(chip, CS4231_RIGHT_OUTPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200601 mute | chip->image[CS4231_RIGHT_OUTPUT]);
Krzysztof Heltead893c2008-07-31 21:09:32 +0200602 if (!(chip->hardware & WSS_HW_AD1848_MASK)) {
603 snd_wss_dout(chip, CS4231_LEFT_LINE_IN,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200604 mute | chip->image[CS4231_LEFT_LINE_IN]);
Krzysztof Heltead893c2008-07-31 21:09:32 +0200605 snd_wss_dout(chip, CS4231_RIGHT_LINE_IN,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200606 mute | chip->image[CS4231_RIGHT_LINE_IN]);
Krzysztof Heltead893c2008-07-31 21:09:32 +0200607 snd_wss_dout(chip, CS4231_MONO_CTRL,
608 mute ? 0xc0 : chip->image[CS4231_MONO_CTRL]);
609 }
Krzysztof Helt7779f752008-07-31 21:03:41 +0200610 if (chip->hardware == WSS_HW_INTERWAVE) {
611 snd_wss_dout(chip, CS4231_LEFT_MIC_INPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200612 mute | chip->image[CS4231_LEFT_MIC_INPUT]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200613 snd_wss_dout(chip, CS4231_RIGHT_MIC_INPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200614 mute | chip->image[CS4231_RIGHT_MIC_INPUT]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200615 snd_wss_dout(chip, CS4231_LINE_LEFT_OUTPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200616 mute | chip->image[CS4231_LINE_LEFT_OUTPUT]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200617 snd_wss_dout(chip, CS4231_LINE_RIGHT_OUTPUT,
Krzysztof Heltace457c2008-08-17 22:38:27 +0200618 mute | chip->image[CS4231_LINE_RIGHT_OUTPUT]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 }
620 chip->calibrate_mute = mute;
621 spin_unlock_irqrestore(&chip->reg_lock, flags);
622}
623
Krzysztof Helt7779f752008-07-31 21:03:41 +0200624static void snd_wss_playback_format(struct snd_wss *chip,
Takashi Iwaiba2375a2005-11-17 14:30:42 +0100625 struct snd_pcm_hw_params *params,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 unsigned char pdfr)
627{
628 unsigned long flags;
629 int full_calib = 1;
630
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100631 mutex_lock(&chip->mce_mutex);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200632 if (chip->hardware == WSS_HW_CS4231A ||
633 (chip->hardware & WSS_HW_CS4232_MASK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 spin_lock_irqsave(&chip->reg_lock, flags);
635 if ((chip->image[CS4231_PLAYBK_FORMAT] & 0x0f) == (pdfr & 0x0f)) { /* rate is same? */
Krzysztof Helt7779f752008-07-31 21:03:41 +0200636 snd_wss_out(chip, CS4231_ALT_FEATURE_1,
637 chip->image[CS4231_ALT_FEATURE_1] | 0x10);
638 chip->image[CS4231_PLAYBK_FORMAT] = pdfr;
639 snd_wss_out(chip, CS4231_PLAYBK_FORMAT,
640 chip->image[CS4231_PLAYBK_FORMAT]);
641 snd_wss_out(chip, CS4231_ALT_FEATURE_1,
642 chip->image[CS4231_ALT_FEATURE_1] &= ~0x10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 udelay(100); /* Fixes audible clicks at least on GUS MAX */
644 full_calib = 0;
645 }
646 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt199f7972009-01-09 23:10:52 +0100647 } else if (chip->hardware == WSS_HW_AD1845) {
648 unsigned rate = params_rate(params);
649
650 /*
651 * Program the AD1845 correctly for the playback stream.
652 * Note that we do NOT need to toggle the MCE bit because
653 * the PLAYBACK_ENABLE bit of the Interface Configuration
654 * register is set.
655 *
656 * NOTE: We seem to need to write to the MSB before the LSB
657 * to get the correct sample frequency.
658 */
659 spin_lock_irqsave(&chip->reg_lock, flags);
660 snd_wss_out(chip, CS4231_PLAYBK_FORMAT, (pdfr & 0xf0));
661 snd_wss_out(chip, AD1845_UPR_FREQ_SEL, (rate >> 8) & 0xff);
662 snd_wss_out(chip, AD1845_LWR_FREQ_SEL, rate & 0xff);
663 full_calib = 0;
664 spin_unlock_irqrestore(&chip->reg_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 }
666 if (full_calib) {
Krzysztof Helt7779f752008-07-31 21:03:41 +0200667 snd_wss_mce_up(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200669 if (chip->hardware != WSS_HW_INTERWAVE && !chip->single_dma) {
670 if (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE)
671 pdfr = (pdfr & 0xf0) |
672 (chip->image[CS4231_REC_FORMAT] & 0x0f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 } else {
Krzysztof Helt7779f752008-07-31 21:03:41 +0200674 chip->image[CS4231_PLAYBK_FORMAT] = pdfr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
Krzysztof Helt7779f752008-07-31 21:03:41 +0200676 snd_wss_out(chip, CS4231_PLAYBK_FORMAT, pdfr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200678 if (chip->hardware == WSS_HW_OPL3SA2)
Paul Vojtae2340462007-07-27 12:20:38 +0200679 udelay(100); /* this seems to help */
Krzysztof Helt7779f752008-07-31 21:03:41 +0200680 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 }
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100682 mutex_unlock(&chip->mce_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683}
684
Krzysztof Helt7779f752008-07-31 21:03:41 +0200685static void snd_wss_capture_format(struct snd_wss *chip,
686 struct snd_pcm_hw_params *params,
687 unsigned char cdfr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688{
689 unsigned long flags;
690 int full_calib = 1;
691
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100692 mutex_lock(&chip->mce_mutex);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200693 if (chip->hardware == WSS_HW_CS4231A ||
694 (chip->hardware & WSS_HW_CS4232_MASK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 spin_lock_irqsave(&chip->reg_lock, flags);
696 if ((chip->image[CS4231_PLAYBK_FORMAT] & 0x0f) == (cdfr & 0x0f) || /* rate is same? */
697 (chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) {
Krzysztof Helt7779f752008-07-31 21:03:41 +0200698 snd_wss_out(chip, CS4231_ALT_FEATURE_1,
699 chip->image[CS4231_ALT_FEATURE_1] | 0x20);
700 snd_wss_out(chip, CS4231_REC_FORMAT,
701 chip->image[CS4231_REC_FORMAT] = cdfr);
702 snd_wss_out(chip, CS4231_ALT_FEATURE_1,
703 chip->image[CS4231_ALT_FEATURE_1] &= ~0x20);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 full_calib = 0;
705 }
706 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt199f7972009-01-09 23:10:52 +0100707 } else if (chip->hardware == WSS_HW_AD1845) {
708 unsigned rate = params_rate(params);
709
710 /*
711 * Program the AD1845 correctly for the capture stream.
712 * Note that we do NOT need to toggle the MCE bit because
713 * the PLAYBACK_ENABLE bit of the Interface Configuration
714 * register is set.
715 *
716 * NOTE: We seem to need to write to the MSB before the LSB
717 * to get the correct sample frequency.
718 */
719 spin_lock_irqsave(&chip->reg_lock, flags);
720 snd_wss_out(chip, CS4231_REC_FORMAT, (cdfr & 0xf0));
721 snd_wss_out(chip, AD1845_UPR_FREQ_SEL, (rate >> 8) & 0xff);
722 snd_wss_out(chip, AD1845_LWR_FREQ_SEL, rate & 0xff);
723 full_calib = 0;
724 spin_unlock_irqrestore(&chip->reg_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 }
726 if (full_calib) {
Krzysztof Helt7779f752008-07-31 21:03:41 +0200727 snd_wss_mce_up(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200729 if (chip->hardware != WSS_HW_INTERWAVE &&
730 !(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) {
731 if (chip->single_dma)
732 snd_wss_out(chip, CS4231_PLAYBK_FORMAT, cdfr);
733 else
734 snd_wss_out(chip, CS4231_PLAYBK_FORMAT,
735 (chip->image[CS4231_PLAYBK_FORMAT] & 0xf0) |
736 (cdfr & 0x0f));
737 spin_unlock_irqrestore(&chip->reg_lock, flags);
738 snd_wss_mce_down(chip);
739 snd_wss_mce_up(chip);
740 spin_lock_irqsave(&chip->reg_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 }
Krzysztof Heltead893c2008-07-31 21:09:32 +0200742 if (chip->hardware & WSS_HW_AD1848_MASK)
743 snd_wss_out(chip, CS4231_PLAYBK_FORMAT, cdfr);
744 else
745 snd_wss_out(chip, CS4231_REC_FORMAT, cdfr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200747 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 }
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100749 mutex_unlock(&chip->mce_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750}
751
752/*
753 * Timer interface
754 */
755
Krzysztof Helt7779f752008-07-31 21:03:41 +0200756static unsigned long snd_wss_timer_resolution(struct snd_timer *timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200758 struct snd_wss *chip = snd_timer_chip(timer);
759 if (chip->hardware & WSS_HW_CS4236B_MASK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 return 14467;
761 else
762 return chip->image[CS4231_PLAYBK_FORMAT] & 1 ? 9969 : 9920;
763}
764
Krzysztof Helt7779f752008-07-31 21:03:41 +0200765static int snd_wss_timer_start(struct snd_timer *timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766{
767 unsigned long flags;
768 unsigned int ticks;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200769 struct snd_wss *chip = snd_timer_chip(timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 spin_lock_irqsave(&chip->reg_lock, flags);
771 ticks = timer->sticks;
772 if ((chip->image[CS4231_ALT_FEATURE_1] & CS4231_TIMER_ENABLE) == 0 ||
773 (unsigned char)(ticks >> 8) != chip->image[CS4231_TIMER_HIGH] ||
774 (unsigned char)ticks != chip->image[CS4231_TIMER_LOW]) {
Krzysztof Helt7779f752008-07-31 21:03:41 +0200775 chip->image[CS4231_TIMER_HIGH] = (unsigned char) (ticks >> 8);
776 snd_wss_out(chip, CS4231_TIMER_HIGH,
777 chip->image[CS4231_TIMER_HIGH]);
778 chip->image[CS4231_TIMER_LOW] = (unsigned char) ticks;
779 snd_wss_out(chip, CS4231_TIMER_LOW,
780 chip->image[CS4231_TIMER_LOW]);
781 snd_wss_out(chip, CS4231_ALT_FEATURE_1,
782 chip->image[CS4231_ALT_FEATURE_1] |
783 CS4231_TIMER_ENABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 }
785 spin_unlock_irqrestore(&chip->reg_lock, flags);
786 return 0;
787}
788
Krzysztof Helt7779f752008-07-31 21:03:41 +0200789static int snd_wss_timer_stop(struct snd_timer *timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790{
791 unsigned long flags;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200792 struct snd_wss *chip = snd_timer_chip(timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200794 chip->image[CS4231_ALT_FEATURE_1] &= ~CS4231_TIMER_ENABLE;
795 snd_wss_out(chip, CS4231_ALT_FEATURE_1,
796 chip->image[CS4231_ALT_FEATURE_1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 spin_unlock_irqrestore(&chip->reg_lock, flags);
798 return 0;
799}
800
Krzysztof Helt7779f752008-07-31 21:03:41 +0200801static void snd_wss_init(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802{
803 unsigned long flags;
804
Krzysztof Helt9ef344f2009-01-16 22:47:30 +0100805 snd_wss_calibrate_mute(chip, 1);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200806 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
808#ifdef SNDRV_DEBUG_MCE
Takashi Iwai76d498e2009-02-05 15:45:05 +0100809 snd_printk(KERN_DEBUG "init: (1)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810#endif
Krzysztof Helt7779f752008-07-31 21:03:41 +0200811 snd_wss_mce_up(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200813 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE |
814 CS4231_PLAYBACK_PIO |
815 CS4231_RECORD_ENABLE |
816 CS4231_RECORD_PIO |
817 CS4231_CALIB_MODE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 chip->image[CS4231_IFACE_CTRL] |= CS4231_AUTOCALIB;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200819 snd_wss_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200821 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
823#ifdef SNDRV_DEBUG_MCE
Takashi Iwai76d498e2009-02-05 15:45:05 +0100824 snd_printk(KERN_DEBUG "init: (2)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825#endif
826
Krzysztof Helt7779f752008-07-31 21:03:41 +0200827 snd_wss_mce_up(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt9ef344f2009-01-16 22:47:30 +0100829 chip->image[CS4231_IFACE_CTRL] &= ~CS4231_AUTOCALIB;
830 snd_wss_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200831 snd_wss_out(chip,
832 CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200834 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
836#ifdef SNDRV_DEBUG_MCE
Takashi Iwai76d498e2009-02-05 15:45:05 +0100837 snd_printk(KERN_DEBUG "init: (3) - afei = 0x%x\n",
Krzysztof Helt7779f752008-07-31 21:03:41 +0200838 chip->image[CS4231_ALT_FEATURE_1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839#endif
840
841 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200842 snd_wss_out(chip, CS4231_ALT_FEATURE_2,
843 chip->image[CS4231_ALT_FEATURE_2]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 spin_unlock_irqrestore(&chip->reg_lock, flags);
845
Krzysztof Helt7779f752008-07-31 21:03:41 +0200846 snd_wss_mce_up(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200848 snd_wss_out(chip, CS4231_PLAYBK_FORMAT,
849 chip->image[CS4231_PLAYBK_FORMAT]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200851 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
853#ifdef SNDRV_DEBUG_MCE
Takashi Iwai76d498e2009-02-05 15:45:05 +0100854 snd_printk(KERN_DEBUG "init: (4)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855#endif
856
Krzysztof Helt7779f752008-07-31 21:03:41 +0200857 snd_wss_mce_up(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Heltead893c2008-07-31 21:09:32 +0200859 if (!(chip->hardware & WSS_HW_AD1848_MASK))
860 snd_wss_out(chip, CS4231_REC_FORMAT,
861 chip->image[CS4231_REC_FORMAT]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200863 snd_wss_mce_down(chip);
Krzysztof Helt9ef344f2009-01-16 22:47:30 +0100864 snd_wss_calibrate_mute(chip, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
866#ifdef SNDRV_DEBUG_MCE
Takashi Iwai76d498e2009-02-05 15:45:05 +0100867 snd_printk(KERN_DEBUG "init: (5)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868#endif
869}
870
Krzysztof Helt7779f752008-07-31 21:03:41 +0200871static int snd_wss_open(struct snd_wss *chip, unsigned int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872{
873 unsigned long flags;
874
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100875 mutex_lock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 if ((chip->mode & mode) ||
Krzysztof Helt7779f752008-07-31 21:03:41 +0200877 ((chip->mode & WSS_MODE_OPEN) && chip->single_dma)) {
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100878 mutex_unlock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 return -EAGAIN;
880 }
Krzysztof Helt7779f752008-07-31 21:03:41 +0200881 if (chip->mode & WSS_MODE_OPEN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 chip->mode |= mode;
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100883 mutex_unlock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 return 0;
885 }
886 /* ok. now enable and ack CODEC IRQ */
887 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Heltead893c2008-07-31 21:09:32 +0200888 if (!(chip->hardware & WSS_HW_AD1848_MASK)) {
889 snd_wss_out(chip, CS4231_IRQ_STATUS,
890 CS4231_PLAYBACK_IRQ |
891 CS4231_RECORD_IRQ |
892 CS4231_TIMER_IRQ);
893 snd_wss_out(chip, CS4231_IRQ_STATUS, 0);
894 }
Krzysztof Helt7779f752008-07-31 21:03:41 +0200895 wss_outb(chip, CS4231P(STATUS), 0); /* clear IRQ */
896 wss_outb(chip, CS4231P(STATUS), 0); /* clear IRQ */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 chip->image[CS4231_PIN_CTRL] |= CS4231_IRQ_ENABLE;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200898 snd_wss_out(chip, CS4231_PIN_CTRL, chip->image[CS4231_PIN_CTRL]);
Krzysztof Heltead893c2008-07-31 21:09:32 +0200899 if (!(chip->hardware & WSS_HW_AD1848_MASK)) {
900 snd_wss_out(chip, CS4231_IRQ_STATUS,
901 CS4231_PLAYBACK_IRQ |
902 CS4231_RECORD_IRQ |
903 CS4231_TIMER_IRQ);
904 snd_wss_out(chip, CS4231_IRQ_STATUS, 0);
905 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 spin_unlock_irqrestore(&chip->reg_lock, flags);
907
908 chip->mode = mode;
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100909 mutex_unlock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 return 0;
911}
912
Krzysztof Helt7779f752008-07-31 21:03:41 +0200913static void snd_wss_close(struct snd_wss *chip, unsigned int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914{
915 unsigned long flags;
916
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100917 mutex_lock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 chip->mode &= ~mode;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200919 if (chip->mode & WSS_MODE_OPEN) {
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100920 mutex_unlock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 return;
922 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 /* disable IRQ */
924 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Heltead893c2008-07-31 21:09:32 +0200925 if (!(chip->hardware & WSS_HW_AD1848_MASK))
926 snd_wss_out(chip, CS4231_IRQ_STATUS, 0);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200927 wss_outb(chip, CS4231P(STATUS), 0); /* clear IRQ */
928 wss_outb(chip, CS4231P(STATUS), 0); /* clear IRQ */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 chip->image[CS4231_PIN_CTRL] &= ~CS4231_IRQ_ENABLE;
Krzysztof Helt7779f752008-07-31 21:03:41 +0200930 snd_wss_out(chip, CS4231_PIN_CTRL, chip->image[CS4231_PIN_CTRL]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
932 /* now disable record & playback */
933
934 if (chip->image[CS4231_IFACE_CTRL] & (CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO |
935 CS4231_RECORD_ENABLE | CS4231_RECORD_PIO)) {
936 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200937 snd_wss_mce_up(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 spin_lock_irqsave(&chip->reg_lock, flags);
939 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO |
940 CS4231_RECORD_ENABLE | CS4231_RECORD_PIO);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200941 snd_wss_out(chip, CS4231_IFACE_CTRL,
942 chip->image[CS4231_IFACE_CTRL]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200944 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 spin_lock_irqsave(&chip->reg_lock, flags);
946 }
947
948 /* clear IRQ again */
Krzysztof Heltead893c2008-07-31 21:09:32 +0200949 if (!(chip->hardware & WSS_HW_AD1848_MASK))
950 snd_wss_out(chip, CS4231_IRQ_STATUS, 0);
Krzysztof Helt7779f752008-07-31 21:03:41 +0200951 wss_outb(chip, CS4231P(STATUS), 0); /* clear IRQ */
952 wss_outb(chip, CS4231P(STATUS), 0); /* clear IRQ */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 spin_unlock_irqrestore(&chip->reg_lock, flags);
954
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 chip->mode = 0;
Ingo Molnar8b7547f2006-01-16 16:33:08 +0100956 mutex_unlock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957}
958
959/*
960 * timer open/close
961 */
962
Krzysztof Helt7779f752008-07-31 21:03:41 +0200963static int snd_wss_timer_open(struct snd_timer *timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200965 struct snd_wss *chip = snd_timer_chip(timer);
966 snd_wss_open(chip, WSS_MODE_TIMER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 return 0;
968}
969
Krzysztof Helt7779f752008-07-31 21:03:41 +0200970static int snd_wss_timer_close(struct snd_timer *timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200972 struct snd_wss *chip = snd_timer_chip(timer);
973 snd_wss_close(chip, WSS_MODE_TIMER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 return 0;
975}
976
Krzysztof Helt7779f752008-07-31 21:03:41 +0200977static struct snd_timer_hardware snd_wss_timer_table =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978{
979 .flags = SNDRV_TIMER_HW_AUTO,
980 .resolution = 9945,
981 .ticks = 65535,
Krzysztof Helt7779f752008-07-31 21:03:41 +0200982 .open = snd_wss_timer_open,
983 .close = snd_wss_timer_close,
984 .c_resolution = snd_wss_timer_resolution,
985 .start = snd_wss_timer_start,
986 .stop = snd_wss_timer_stop,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987};
988
989/*
990 * ok.. exported functions..
991 */
992
Krzysztof Helt7779f752008-07-31 21:03:41 +0200993static int snd_wss_playback_hw_params(struct snd_pcm_substream *substream,
Takashi Iwaiba2375a2005-11-17 14:30:42 +0100994 struct snd_pcm_hw_params *hw_params)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995{
Krzysztof Helt7779f752008-07-31 21:03:41 +0200996 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 unsigned char new_pdfr;
998 int err;
999
1000 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
1001 return err;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001002 new_pdfr = snd_wss_get_format(chip, params_format(hw_params),
1003 params_channels(hw_params)) |
1004 snd_wss_get_rate(params_rate(hw_params));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 chip->set_playback_format(chip, hw_params, new_pdfr);
1006 return 0;
1007}
1008
Krzysztof Helt7779f752008-07-31 21:03:41 +02001009static int snd_wss_playback_hw_free(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010{
1011 return snd_pcm_lib_free_pages(substream);
1012}
1013
Krzysztof Helt7779f752008-07-31 21:03:41 +02001014static int snd_wss_playback_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001016 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001017 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 unsigned long flags;
1019 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
1020 unsigned int count = snd_pcm_lib_period_bytes(substream);
1021
1022 spin_lock_irqsave(&chip->reg_lock, flags);
1023 chip->p_dma_size = size;
1024 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO);
1025 snd_dma_program(chip->dma1, runtime->dma_addr, size, DMA_MODE_WRITE | DMA_AUTOINIT);
Krzysztof Helt7779f752008-07-31 21:03:41 +02001026 count = snd_wss_get_count(chip->image[CS4231_PLAYBK_FORMAT], count) - 1;
1027 snd_wss_out(chip, CS4231_PLY_LWR_CNT, (unsigned char) count);
1028 snd_wss_out(chip, CS4231_PLY_UPR_CNT, (unsigned char) (count >> 8));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 spin_unlock_irqrestore(&chip->reg_lock, flags);
1030#if 0
Krzysztof Helt7779f752008-07-31 21:03:41 +02001031 snd_wss_debug(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032#endif
1033 return 0;
1034}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
Krzysztof Helt7779f752008-07-31 21:03:41 +02001036static int snd_wss_capture_hw_params(struct snd_pcm_substream *substream,
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001037 struct snd_pcm_hw_params *hw_params)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001039 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 unsigned char new_cdfr;
1041 int err;
1042
1043 if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
1044 return err;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001045 new_cdfr = snd_wss_get_format(chip, params_format(hw_params),
1046 params_channels(hw_params)) |
1047 snd_wss_get_rate(params_rate(hw_params));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 chip->set_capture_format(chip, hw_params, new_cdfr);
1049 return 0;
1050}
1051
Krzysztof Helt7779f752008-07-31 21:03:41 +02001052static int snd_wss_capture_hw_free(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053{
1054 return snd_pcm_lib_free_pages(substream);
1055}
1056
Krzysztof Helt7779f752008-07-31 21:03:41 +02001057static int snd_wss_capture_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001059 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001060 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 unsigned long flags;
1062 unsigned int size = snd_pcm_lib_buffer_bytes(substream);
1063 unsigned int count = snd_pcm_lib_period_bytes(substream);
1064
1065 spin_lock_irqsave(&chip->reg_lock, flags);
1066 chip->c_dma_size = size;
1067 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_RECORD_ENABLE | CS4231_RECORD_PIO);
1068 snd_dma_program(chip->dma2, runtime->dma_addr, size, DMA_MODE_READ | DMA_AUTOINIT);
Krzysztof Heltead893c2008-07-31 21:09:32 +02001069 if (chip->hardware & WSS_HW_AD1848_MASK)
1070 count = snd_wss_get_count(chip->image[CS4231_PLAYBK_FORMAT],
1071 count);
1072 else
1073 count = snd_wss_get_count(chip->image[CS4231_REC_FORMAT],
1074 count);
1075 count--;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001076 if (chip->single_dma && chip->hardware != WSS_HW_INTERWAVE) {
1077 snd_wss_out(chip, CS4231_PLY_LWR_CNT, (unsigned char) count);
1078 snd_wss_out(chip, CS4231_PLY_UPR_CNT,
1079 (unsigned char) (count >> 8));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 } else {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001081 snd_wss_out(chip, CS4231_REC_LWR_CNT, (unsigned char) count);
1082 snd_wss_out(chip, CS4231_REC_UPR_CNT,
1083 (unsigned char) (count >> 8));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 }
1085 spin_unlock_irqrestore(&chip->reg_lock, flags);
1086 return 0;
1087}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
Krzysztof Helt7779f752008-07-31 21:03:41 +02001089void snd_wss_overrange(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090{
1091 unsigned long flags;
1092 unsigned char res;
1093
1094 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +02001095 res = snd_wss_in(chip, CS4231_TEST_INIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 spin_unlock_irqrestore(&chip->reg_lock, flags);
1097 if (res & (0x08 | 0x02)) /* detect overrange only above 0dB; may be user selectable? */
1098 chip->capture_substream->runtime->overrange++;
1099}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001100EXPORT_SYMBOL(snd_wss_overrange);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
Krzysztof Helt7779f752008-07-31 21:03:41 +02001102irqreturn_t snd_wss_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001104 struct snd_wss *chip = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 unsigned char status;
1106
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001107 if (chip->hardware & WSS_HW_AD1848_MASK)
1108 /* pretend it was the only possible irq for AD1848 */
1109 status = CS4231_PLAYBACK_IRQ;
1110 else
1111 status = snd_wss_in(chip, CS4231_IRQ_STATUS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 if (status & CS4231_TIMER_IRQ) {
1113 if (chip->timer)
1114 snd_timer_interrupt(chip->timer, chip->timer->sticks);
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001115 }
Krzysztof Helt7779f752008-07-31 21:03:41 +02001116 if (chip->single_dma && chip->hardware != WSS_HW_INTERWAVE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 if (status & CS4231_PLAYBACK_IRQ) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001118 if (chip->mode & WSS_MODE_PLAY) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 if (chip->playback_substream)
1120 snd_pcm_period_elapsed(chip->playback_substream);
1121 }
Krzysztof Helt7779f752008-07-31 21:03:41 +02001122 if (chip->mode & WSS_MODE_RECORD) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 if (chip->capture_substream) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001124 snd_wss_overrange(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 snd_pcm_period_elapsed(chip->capture_substream);
1126 }
1127 }
1128 }
1129 } else {
1130 if (status & CS4231_PLAYBACK_IRQ) {
1131 if (chip->playback_substream)
1132 snd_pcm_period_elapsed(chip->playback_substream);
1133 }
1134 if (status & CS4231_RECORD_IRQ) {
1135 if (chip->capture_substream) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001136 snd_wss_overrange(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 snd_pcm_period_elapsed(chip->capture_substream);
1138 }
1139 }
1140 }
1141
1142 spin_lock(&chip->reg_lock);
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001143 status = ~CS4231_ALL_IRQS | ~status;
1144 if (chip->hardware & WSS_HW_AD1848_MASK)
1145 wss_outb(chip, CS4231P(STATUS), 0);
1146 else
Krzysztof Helt9ef344f2009-01-16 22:47:30 +01001147 snd_wss_out(chip, CS4231_IRQ_STATUS, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 spin_unlock(&chip->reg_lock);
1149 return IRQ_HANDLED;
1150}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001151EXPORT_SYMBOL(snd_wss_interrupt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
Krzysztof Helt7779f752008-07-31 21:03:41 +02001153static snd_pcm_uframes_t snd_wss_playback_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001155 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 size_t ptr;
1157
1158 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE))
1159 return 0;
1160 ptr = snd_dma_pointer(chip->dma1, chip->p_dma_size);
1161 return bytes_to_frames(substream->runtime, ptr);
1162}
1163
Krzysztof Helt7779f752008-07-31 21:03:41 +02001164static snd_pcm_uframes_t snd_wss_capture_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001166 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 size_t ptr;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001168
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE))
1170 return 0;
1171 ptr = snd_dma_pointer(chip->dma2, chip->c_dma_size);
1172 return bytes_to_frames(substream->runtime, ptr);
1173}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174
1175/*
1176
1177 */
1178
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001179static int snd_ad1848_probe(struct snd_wss *chip)
1180{
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001181 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001182 unsigned long flags;
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001183 unsigned char r;
1184 unsigned short hardware = 0;
1185 int err = 0;
1186 int i;
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001187
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001188 while (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT) {
1189 if (time_after(jiffies, timeout))
1190 return -ENODEV;
1191 cond_resched();
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001192 }
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001193 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001194
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001195 /* set CS423x MODE 1 */
Krzysztof Heltf83a59c2008-08-24 18:08:03 +02001196 snd_wss_dout(chip, CS4231_MISC_INFO, 0);
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001197
Krzysztof Heltf83a59c2008-08-24 18:08:03 +02001198 snd_wss_dout(chip, CS4231_RIGHT_INPUT, 0x45); /* 0x55 & ~0x10 */
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001199 r = snd_wss_in(chip, CS4231_RIGHT_INPUT);
1200 if (r != 0x45) {
1201 /* RMGE always high on AD1847 */
1202 if ((r & ~CS4231_ENABLE_MIC_GAIN) != 0x45) {
1203 err = -ENODEV;
1204 goto out;
1205 }
1206 hardware = WSS_HW_AD1847;
1207 } else {
Krzysztof Heltf83a59c2008-08-24 18:08:03 +02001208 snd_wss_dout(chip, CS4231_LEFT_INPUT, 0xaa);
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001209 r = snd_wss_in(chip, CS4231_LEFT_INPUT);
1210 /* L/RMGE always low on AT2320 */
1211 if ((r | CS4231_ENABLE_MIC_GAIN) != 0xaa) {
1212 err = -ENODEV;
1213 goto out;
1214 }
1215 }
1216
1217 /* clear pending IRQ */
1218 wss_inb(chip, CS4231P(STATUS));
1219 wss_outb(chip, CS4231P(STATUS), 0);
1220 mb();
1221
1222 if ((chip->hardware & WSS_HW_TYPE_MASK) != WSS_HW_DETECT)
1223 goto out;
1224
1225 if (hardware) {
1226 chip->hardware = hardware;
1227 goto out;
1228 }
1229
1230 r = snd_wss_in(chip, CS4231_MISC_INFO);
1231
1232 /* set CS423x MODE 2 */
Krzysztof Heltf83a59c2008-08-24 18:08:03 +02001233 snd_wss_dout(chip, CS4231_MISC_INFO, CS4231_MODE2);
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001234 for (i = 0; i < 16; i++) {
1235 if (snd_wss_in(chip, i) != snd_wss_in(chip, 16 + i)) {
1236 /* we have more than 16 registers: check ID */
1237 if ((r & 0xf) != 0xa)
1238 goto out_mode;
1239 /*
1240 * on CMI8330, CS4231_VERSION is volume control and
1241 * can be set to 0
1242 */
1243 snd_wss_dout(chip, CS4231_VERSION, 0);
1244 r = snd_wss_in(chip, CS4231_VERSION) & 0xe7;
1245 if (!r)
1246 chip->hardware = WSS_HW_CMI8330;
1247 goto out_mode;
1248 }
1249 }
1250 if (r & 0x80)
1251 chip->hardware = WSS_HW_CS4248;
1252 else
1253 chip->hardware = WSS_HW_AD1848;
1254out_mode:
Krzysztof Heltf83a59c2008-08-24 18:08:03 +02001255 snd_wss_dout(chip, CS4231_MISC_INFO, 0);
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001256out:
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001257 spin_unlock_irqrestore(&chip->reg_lock, flags);
Rene Hermanc9a7dc22008-08-06 08:09:34 +02001258 return err;
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001259}
1260
Krzysztof Helt7779f752008-07-31 21:03:41 +02001261static int snd_wss_probe(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262{
1263 unsigned long flags;
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001264 int i, id, rev, regnum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 unsigned char *ptr;
1266 unsigned int hw;
1267
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001268 id = snd_ad1848_probe(chip);
1269 if (id < 0)
1270 return id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Krzysztof Helt7779f752008-07-31 21:03:41 +02001272 hw = chip->hardware;
1273 if ((hw & WSS_HW_TYPE_MASK) == WSS_HW_DETECT) {
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001274 for (i = 0; i < 50; i++) {
1275 mb();
1276 if (wss_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
1277 msleep(2);
1278 else {
1279 spin_lock_irqsave(&chip->reg_lock, flags);
1280 snd_wss_out(chip, CS4231_MISC_INFO,
1281 CS4231_MODE2);
1282 id = snd_wss_in(chip, CS4231_MISC_INFO) & 0x0f;
1283 spin_unlock_irqrestore(&chip->reg_lock, flags);
1284 if (id == 0x0a)
1285 break; /* this is valid value */
1286 }
1287 }
1288 snd_printdd("wss: port = 0x%lx, id = 0x%x\n", chip->port, id);
1289 if (id != 0x0a)
1290 return -ENODEV; /* no valid device found */
1291
Krzysztof Helt7779f752008-07-31 21:03:41 +02001292 rev = snd_wss_in(chip, CS4231_VERSION) & 0xe7;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 snd_printdd("CS4231: VERSION (I25) = 0x%x\n", rev);
1294 if (rev == 0x80) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001295 unsigned char tmp = snd_wss_in(chip, 23);
1296 snd_wss_out(chip, 23, ~tmp);
1297 if (snd_wss_in(chip, 23) != tmp)
1298 chip->hardware = WSS_HW_AD1845;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 else
Krzysztof Helt7779f752008-07-31 21:03:41 +02001300 chip->hardware = WSS_HW_CS4231;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 } else if (rev == 0xa0) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001302 chip->hardware = WSS_HW_CS4231A;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 } else if (rev == 0xa2) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001304 chip->hardware = WSS_HW_CS4232;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 } else if (rev == 0xb2) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001306 chip->hardware = WSS_HW_CS4232A;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 } else if (rev == 0x83) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001308 chip->hardware = WSS_HW_CS4236;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 } else if (rev == 0x03) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001310 chip->hardware = WSS_HW_CS4236B;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 } else {
Takashi Iwai76d498e2009-02-05 15:45:05 +01001312 snd_printk(KERN_ERR
1313 "unknown CS chip with version 0x%x\n", rev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 return -ENODEV; /* unknown CS4231 chip? */
1315 }
1316 }
1317 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +02001318 wss_inb(chip, CS4231P(STATUS)); /* clear any pendings IRQ */
1319 wss_outb(chip, CS4231P(STATUS), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 mb();
1321 spin_unlock_irqrestore(&chip->reg_lock, flags);
1322
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001323 if (!(chip->hardware & WSS_HW_AD1848_MASK))
1324 chip->image[CS4231_MISC_INFO] = CS4231_MODE2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 switch (chip->hardware) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001326 case WSS_HW_INTERWAVE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 chip->image[CS4231_MISC_INFO] = CS4231_IW_MODE3;
1328 break;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001329 case WSS_HW_CS4235:
1330 case WSS_HW_CS4236B:
1331 case WSS_HW_CS4237B:
1332 case WSS_HW_CS4238B:
1333 case WSS_HW_CS4239:
1334 if (hw == WSS_HW_DETECT3)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 chip->image[CS4231_MISC_INFO] = CS4231_4236_MODE3;
1336 else
Krzysztof Helt7779f752008-07-31 21:03:41 +02001337 chip->hardware = WSS_HW_CS4236;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 break;
1339 }
1340
1341 chip->image[CS4231_IFACE_CTRL] =
1342 (chip->image[CS4231_IFACE_CTRL] & ~CS4231_SINGLE_DMA) |
1343 (chip->single_dma ? CS4231_SINGLE_DMA : 0);
Krzysztof Helt7779f752008-07-31 21:03:41 +02001344 if (chip->hardware != WSS_HW_OPTI93X) {
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02001345 chip->image[CS4231_ALT_FEATURE_1] = 0x80;
1346 chip->image[CS4231_ALT_FEATURE_2] =
Krzysztof Helt7779f752008-07-31 21:03:41 +02001347 chip->hardware == WSS_HW_INTERWAVE ? 0xc2 : 0x01;
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02001348 }
Krzysztof Helt199f7972009-01-09 23:10:52 +01001349 /* enable fine grained frequency selection */
1350 if (chip->hardware == WSS_HW_AD1845)
1351 chip->image[AD1845_PWR_DOWN] = 8;
1352
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 ptr = (unsigned char *) &chip->image;
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001354 regnum = (chip->hardware & WSS_HW_AD1848_MASK) ? 16 : 32;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001355 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001357 for (i = 0; i < regnum; i++) /* ok.. fill all registers */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001358 snd_wss_out(chip, i, *ptr++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Helt7779f752008-07-31 21:03:41 +02001360 snd_wss_mce_up(chip);
1361 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
1363 mdelay(2);
1364
1365 /* ok.. try check hardware version for CS4236+ chips */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001366 if ((hw & WSS_HW_TYPE_MASK) == WSS_HW_DETECT) {
1367 if (chip->hardware == WSS_HW_CS4236B) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 rev = snd_cs4236_ext_in(chip, CS4236_VERSION);
1369 snd_cs4236_ext_out(chip, CS4236_VERSION, 0xff);
1370 id = snd_cs4236_ext_in(chip, CS4236_VERSION);
1371 snd_cs4236_ext_out(chip, CS4236_VERSION, rev);
1372 snd_printdd("CS4231: ext version; rev = 0x%x, id = 0x%x\n", rev, id);
1373 if ((id & 0x1f) == 0x1d) { /* CS4235 */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001374 chip->hardware = WSS_HW_CS4235;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 switch (id >> 5) {
1376 case 4:
1377 case 5:
1378 case 6:
1379 break;
1380 default:
Takashi Iwai76d498e2009-02-05 15:45:05 +01001381 snd_printk(KERN_WARNING
1382 "unknown CS4235 chip "
1383 "(enhanced version = 0x%x)\n",
1384 id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 }
1386 } else if ((id & 0x1f) == 0x0b) { /* CS4236/B */
1387 switch (id >> 5) {
1388 case 4:
1389 case 5:
1390 case 6:
1391 case 7:
Krzysztof Helt7779f752008-07-31 21:03:41 +02001392 chip->hardware = WSS_HW_CS4236B;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 break;
1394 default:
Takashi Iwai76d498e2009-02-05 15:45:05 +01001395 snd_printk(KERN_WARNING
1396 "unknown CS4236 chip "
1397 "(enhanced version = 0x%x)\n",
1398 id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 }
1400 } else if ((id & 0x1f) == 0x08) { /* CS4237B */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001401 chip->hardware = WSS_HW_CS4237B;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 switch (id >> 5) {
1403 case 4:
1404 case 5:
1405 case 6:
1406 case 7:
1407 break;
1408 default:
Takashi Iwai76d498e2009-02-05 15:45:05 +01001409 snd_printk(KERN_WARNING
1410 "unknown CS4237B chip "
1411 "(enhanced version = 0x%x)\n",
1412 id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 }
1414 } else if ((id & 0x1f) == 0x09) { /* CS4238B */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001415 chip->hardware = WSS_HW_CS4238B;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 switch (id >> 5) {
1417 case 5:
1418 case 6:
1419 case 7:
1420 break;
1421 default:
Takashi Iwai76d498e2009-02-05 15:45:05 +01001422 snd_printk(KERN_WARNING
1423 "unknown CS4238B chip "
1424 "(enhanced version = 0x%x)\n",
1425 id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 }
1427 } else if ((id & 0x1f) == 0x1e) { /* CS4239 */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001428 chip->hardware = WSS_HW_CS4239;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 switch (id >> 5) {
1430 case 4:
1431 case 5:
1432 case 6:
1433 break;
1434 default:
Takashi Iwai76d498e2009-02-05 15:45:05 +01001435 snd_printk(KERN_WARNING
1436 "unknown CS4239 chip "
1437 "(enhanced version = 0x%x)\n",
1438 id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 }
1440 } else {
Takashi Iwai76d498e2009-02-05 15:45:05 +01001441 snd_printk(KERN_WARNING
1442 "unknown CS4236/CS423xB chip "
1443 "(enhanced version = 0x%x)\n", id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 }
1445 }
1446 }
1447 return 0; /* all things are ok.. */
1448}
1449
1450/*
1451
1452 */
1453
Krzysztof Helt7779f752008-07-31 21:03:41 +02001454static struct snd_pcm_hardware snd_wss_playback =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455{
1456 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1457 SNDRV_PCM_INFO_MMAP_VALID |
1458 SNDRV_PCM_INFO_RESUME |
1459 SNDRV_PCM_INFO_SYNC_START),
1460 .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM |
1461 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE),
1462 .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000,
1463 .rate_min = 5510,
1464 .rate_max = 48000,
1465 .channels_min = 1,
1466 .channels_max = 2,
1467 .buffer_bytes_max = (128*1024),
1468 .period_bytes_min = 64,
1469 .period_bytes_max = (128*1024),
1470 .periods_min = 1,
1471 .periods_max = 1024,
1472 .fifo_size = 0,
1473};
1474
Krzysztof Helt7779f752008-07-31 21:03:41 +02001475static struct snd_pcm_hardware snd_wss_capture =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476{
1477 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1478 SNDRV_PCM_INFO_MMAP_VALID |
1479 SNDRV_PCM_INFO_RESUME |
1480 SNDRV_PCM_INFO_SYNC_START),
1481 .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM |
1482 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE),
1483 .rates = SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000,
1484 .rate_min = 5510,
1485 .rate_max = 48000,
1486 .channels_min = 1,
1487 .channels_max = 2,
1488 .buffer_bytes_max = (128*1024),
1489 .period_bytes_min = 64,
1490 .period_bytes_max = (128*1024),
1491 .periods_min = 1,
1492 .periods_max = 1024,
1493 .fifo_size = 0,
1494};
1495
1496/*
1497
1498 */
1499
Krzysztof Helt7779f752008-07-31 21:03:41 +02001500static int snd_wss_playback_open(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001502 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001503 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 int err;
1505
Krzysztof Helt7779f752008-07-31 21:03:41 +02001506 runtime->hw = snd_wss_playback;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507
Krzysztof Heltead893c2008-07-31 21:09:32 +02001508 /* hardware limitation of older chipsets */
1509 if (chip->hardware & WSS_HW_AD1848_MASK)
1510 runtime->hw.formats &= ~(SNDRV_PCM_FMTBIT_IMA_ADPCM |
1511 SNDRV_PCM_FMTBIT_S16_BE);
1512
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513 /* hardware bug in InterWave chipset */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001514 if (chip->hardware == WSS_HW_INTERWAVE && chip->dma1 > 3)
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001515 runtime->hw.formats &= ~SNDRV_PCM_FMTBIT_MU_LAW;
1516
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 /* hardware limitation of cheap chips */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001518 if (chip->hardware == WSS_HW_CS4235 ||
1519 chip->hardware == WSS_HW_CS4239)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE;
1521
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.buffer_bytes_max);
1523 snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.period_bytes_max);
1524
1525 if (chip->claim_dma) {
1526 if ((err = chip->claim_dma(chip, chip->dma_private_data, chip->dma1)) < 0)
1527 return err;
1528 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529
Krzysztof Helt7779f752008-07-31 21:03:41 +02001530 err = snd_wss_open(chip, WSS_MODE_PLAY);
1531 if (err < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 if (chip->release_dma)
1533 chip->release_dma(chip, chip->dma_private_data, chip->dma1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534 snd_free_pages(runtime->dma_area, runtime->dma_bytes);
1535 return err;
1536 }
1537 chip->playback_substream = substream;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 snd_pcm_set_sync(substream);
1539 chip->rate_constraint(runtime);
1540 return 0;
1541}
1542
Krzysztof Helt7779f752008-07-31 21:03:41 +02001543static int snd_wss_capture_open(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001545 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001546 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 int err;
1548
Krzysztof Helt7779f752008-07-31 21:03:41 +02001549 runtime->hw = snd_wss_capture;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550
Krzysztof Heltead893c2008-07-31 21:09:32 +02001551 /* hardware limitation of older chipsets */
1552 if (chip->hardware & WSS_HW_AD1848_MASK)
1553 runtime->hw.formats &= ~(SNDRV_PCM_FMTBIT_IMA_ADPCM |
1554 SNDRV_PCM_FMTBIT_S16_BE);
1555
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 /* hardware limitation of cheap chips */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001557 if (chip->hardware == WSS_HW_CS4235 ||
Krzysztof Helt31eca302008-07-31 21:11:46 +02001558 chip->hardware == WSS_HW_CS4239 ||
1559 chip->hardware == WSS_HW_OPTI93X)
1560 runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 |
1561 SNDRV_PCM_FMTBIT_S16_LE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.buffer_bytes_max);
1564 snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.period_bytes_max);
1565
1566 if (chip->claim_dma) {
1567 if ((err = chip->claim_dma(chip, chip->dma_private_data, chip->dma2)) < 0)
1568 return err;
1569 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
Krzysztof Helt7779f752008-07-31 21:03:41 +02001571 err = snd_wss_open(chip, WSS_MODE_RECORD);
1572 if (err < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 if (chip->release_dma)
1574 chip->release_dma(chip, chip->dma_private_data, chip->dma2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 snd_free_pages(runtime->dma_area, runtime->dma_bytes);
1576 return err;
1577 }
1578 chip->capture_substream = substream;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579 snd_pcm_set_sync(substream);
1580 chip->rate_constraint(runtime);
1581 return 0;
1582}
1583
Krzysztof Helt7779f752008-07-31 21:03:41 +02001584static int snd_wss_playback_close(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001586 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587
1588 chip->playback_substream = NULL;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001589 snd_wss_close(chip, WSS_MODE_PLAY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 return 0;
1591}
1592
Krzysztof Helt7779f752008-07-31 21:03:41 +02001593static int snd_wss_capture_close(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001595 struct snd_wss *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
1597 chip->capture_substream = NULL;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001598 snd_wss_close(chip, WSS_MODE_RECORD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 return 0;
1600}
1601
Krzysztof Heltead893c2008-07-31 21:09:32 +02001602static void snd_wss_thinkpad_twiddle(struct snd_wss *chip, int on)
1603{
1604 int tmp;
1605
1606 if (!chip->thinkpad_flag)
1607 return;
1608
1609 outb(0x1c, AD1848_THINKPAD_CTL_PORT1);
1610 tmp = inb(AD1848_THINKPAD_CTL_PORT2);
1611
1612 if (on)
1613 /* turn it on */
1614 tmp |= AD1848_THINKPAD_CS4248_ENABLE_BIT;
1615 else
1616 /* turn it off */
1617 tmp &= ~AD1848_THINKPAD_CS4248_ENABLE_BIT;
1618
1619 outb(tmp, AD1848_THINKPAD_CTL_PORT2);
1620}
1621
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622#ifdef CONFIG_PM
1623
1624/* lowlevel suspend callback for CS4231 */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001625static void snd_wss_suspend(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626{
1627 int reg;
1628 unsigned long flags;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001629
Takashi Iwai7bb35e202005-11-17 17:00:17 +01001630 snd_pcm_suspend_all(chip->pcm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 spin_lock_irqsave(&chip->reg_lock, flags);
1632 for (reg = 0; reg < 32; reg++)
Krzysztof Helt7779f752008-07-31 21:03:41 +02001633 chip->image[reg] = snd_wss_in(chip, reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 spin_unlock_irqrestore(&chip->reg_lock, flags);
Krzysztof Heltead893c2008-07-31 21:09:32 +02001635 if (chip->thinkpad_flag)
1636 snd_wss_thinkpad_twiddle(chip, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637}
1638
1639/* lowlevel resume callback for CS4231 */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001640static void snd_wss_resume(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641{
1642 int reg;
1643 unsigned long flags;
Takashi Iwaia2c855b2005-11-18 18:52:39 +01001644 /* int timeout; */
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001645
Krzysztof Heltead893c2008-07-31 21:09:32 +02001646 if (chip->thinkpad_flag)
1647 snd_wss_thinkpad_twiddle(chip, 1);
Krzysztof Helt7779f752008-07-31 21:03:41 +02001648 snd_wss_mce_up(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 spin_lock_irqsave(&chip->reg_lock, flags);
1650 for (reg = 0; reg < 32; reg++) {
1651 switch (reg) {
1652 case CS4231_VERSION:
1653 break;
1654 default:
Krzysztof Helt7779f752008-07-31 21:03:41 +02001655 snd_wss_out(chip, reg, chip->image[reg]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 break;
1657 }
1658 }
1659 spin_unlock_irqrestore(&chip->reg_lock, flags);
Takashi Iwaifa55f832005-11-17 17:48:30 +01001660#if 1
Krzysztof Helt7779f752008-07-31 21:03:41 +02001661 snd_wss_mce_down(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662#else
1663 /* The following is a workaround to avoid freeze after resume on TP600E.
Krzysztof Helt7779f752008-07-31 21:03:41 +02001664 This is the first half of copy of snd_wss_mce_down(), but doesn't
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 include rescheduling. -- iwai
1666 */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001667 snd_wss_busy_wait(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 spin_lock_irqsave(&chip->reg_lock, flags);
1669 chip->mce_bit &= ~CS4231_MCE;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001670 timeout = wss_inb(chip, CS4231P(REGSEL));
1671 wss_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 spin_unlock_irqrestore(&chip->reg_lock, flags);
1673 if (timeout == 0x80)
Takashi Iwai76d498e2009-02-05 15:45:05 +01001674 snd_printk(KERN_ERR "down [0x%lx]: serious init problem "
1675 "- codec still busy\n", chip->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 if ((timeout & CS4231_MCE) == 0 ||
Krzysztof Helt7779f752008-07-31 21:03:41 +02001677 !(chip->hardware & (WSS_HW_CS4231_MASK | WSS_HW_CS4232_MASK))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 return;
1679 }
Krzysztof Helt7779f752008-07-31 21:03:41 +02001680 snd_wss_busy_wait(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681#endif
1682}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683#endif /* CONFIG_PM */
1684
Krzysztof Heltd114cd82009-11-05 18:32:41 +01001685static int snd_wss_free(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686{
Takashi Iwaib1d57762005-10-10 11:56:31 +02001687 release_and_free_resource(chip->res_port);
1688 release_and_free_resource(chip->res_cport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 if (chip->irq >= 0) {
1690 disable_irq(chip->irq);
Krzysztof Helt7779f752008-07-31 21:03:41 +02001691 if (!(chip->hwshare & WSS_HWSHARE_IRQ))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 free_irq(chip->irq, (void *) chip);
1693 }
Krzysztof Helt7779f752008-07-31 21:03:41 +02001694 if (!(chip->hwshare & WSS_HWSHARE_DMA1) && chip->dma1 >= 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 snd_dma_disable(chip->dma1);
1696 free_dma(chip->dma1);
1697 }
Krzysztof Helt7779f752008-07-31 21:03:41 +02001698 if (!(chip->hwshare & WSS_HWSHARE_DMA2) &&
1699 chip->dma2 >= 0 && chip->dma2 != chip->dma1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 snd_dma_disable(chip->dma2);
1701 free_dma(chip->dma2);
1702 }
1703 if (chip->timer)
1704 snd_device_free(chip->card, chip->timer);
1705 kfree(chip);
1706 return 0;
1707}
1708
Krzysztof Helt7779f752008-07-31 21:03:41 +02001709static int snd_wss_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001711 struct snd_wss *chip = device->device_data;
1712 return snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713}
1714
Krzysztof Helt7779f752008-07-31 21:03:41 +02001715const char *snd_wss_chip_id(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716{
1717 switch (chip->hardware) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001718 case WSS_HW_CS4231:
1719 return "CS4231";
1720 case WSS_HW_CS4231A:
1721 return "CS4231A";
1722 case WSS_HW_CS4232:
1723 return "CS4232";
1724 case WSS_HW_CS4232A:
1725 return "CS4232A";
1726 case WSS_HW_CS4235:
1727 return "CS4235";
1728 case WSS_HW_CS4236:
1729 return "CS4236";
1730 case WSS_HW_CS4236B:
1731 return "CS4236B";
1732 case WSS_HW_CS4237B:
1733 return "CS4237B";
1734 case WSS_HW_CS4238B:
1735 return "CS4238B";
1736 case WSS_HW_CS4239:
1737 return "CS4239";
1738 case WSS_HW_INTERWAVE:
1739 return "AMD InterWave";
1740 case WSS_HW_OPL3SA2:
1741 return chip->card->shortname;
1742 case WSS_HW_AD1845:
1743 return "AD1845";
1744 case WSS_HW_OPTI93X:
1745 return "OPTi 93x";
Krzysztof Heltead893c2008-07-31 21:09:32 +02001746 case WSS_HW_AD1847:
1747 return "AD1847";
1748 case WSS_HW_AD1848:
1749 return "AD1848";
1750 case WSS_HW_CS4248:
1751 return "CS4248";
1752 case WSS_HW_CMI8330:
1753 return "CMI8330/C3D";
Krzysztof Helt7779f752008-07-31 21:03:41 +02001754 default:
1755 return "???";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 }
1757}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001758EXPORT_SYMBOL(snd_wss_chip_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
Krzysztof Helt7779f752008-07-31 21:03:41 +02001760static int snd_wss_new(struct snd_card *card,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 unsigned short hardware,
1762 unsigned short hwshare,
Krzysztof Helt7779f752008-07-31 21:03:41 +02001763 struct snd_wss **rchip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001765 struct snd_wss *chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
1767 *rchip = NULL;
Takashi Iwai9e76a762005-09-09 14:21:17 +02001768 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 if (chip == NULL)
1770 return -ENOMEM;
1771 chip->hardware = hardware;
1772 chip->hwshare = hwshare;
1773
1774 spin_lock_init(&chip->reg_lock);
Ingo Molnar8b7547f2006-01-16 16:33:08 +01001775 mutex_init(&chip->mce_mutex);
1776 mutex_init(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 chip->card = card;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001778 chip->rate_constraint = snd_wss_xrate;
1779 chip->set_playback_format = snd_wss_playback_format;
1780 chip->set_capture_format = snd_wss_capture_format;
1781 if (chip->hardware == WSS_HW_OPTI93X)
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02001782 memcpy(&chip->image, &snd_opti93x_original_image,
1783 sizeof(snd_opti93x_original_image));
1784 else
Krzysztof Helt7779f752008-07-31 21:03:41 +02001785 memcpy(&chip->image, &snd_wss_original_image,
1786 sizeof(snd_wss_original_image));
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001787 if (chip->hardware & WSS_HW_AD1848_MASK) {
1788 chip->image[CS4231_PIN_CTRL] = 0;
1789 chip->image[CS4231_TEST_INIT] = 0;
1790 }
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02001791
Krzysztof Helt7779f752008-07-31 21:03:41 +02001792 *rchip = chip;
1793 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794}
1795
Krzysztof Helt7779f752008-07-31 21:03:41 +02001796int snd_wss_create(struct snd_card *card,
1797 unsigned long port,
1798 unsigned long cport,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 int irq, int dma1, int dma2,
1800 unsigned short hardware,
1801 unsigned short hwshare,
Krzysztof Helt7779f752008-07-31 21:03:41 +02001802 struct snd_wss **rchip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803{
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001804 static struct snd_device_ops ops = {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001805 .dev_free = snd_wss_dev_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 };
Krzysztof Helt7779f752008-07-31 21:03:41 +02001807 struct snd_wss *chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 int err;
1809
Krzysztof Helt7779f752008-07-31 21:03:41 +02001810 err = snd_wss_new(card, hardware, hwshare, &chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 if (err < 0)
1812 return err;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001813
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 chip->irq = -1;
1815 chip->dma1 = -1;
1816 chip->dma2 = -1;
1817
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001818 chip->res_port = request_region(port, 4, "WSS");
Krzysztof Helt7779f752008-07-31 21:03:41 +02001819 if (!chip->res_port) {
1820 snd_printk(KERN_ERR "wss: can't grab port 0x%lx\n", port);
1821 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 return -EBUSY;
1823 }
1824 chip->port = port;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001825 if ((long)cport >= 0) {
1826 chip->res_cport = request_region(cport, 8, "CS4232 Control");
1827 if (!chip->res_cport) {
1828 snd_printk(KERN_ERR
1829 "wss: can't grab control port 0x%lx\n", cport);
1830 snd_wss_free(chip);
1831 return -ENODEV;
1832 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 }
1834 chip->cport = cport;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001835 if (!(hwshare & WSS_HWSHARE_IRQ))
1836 if (request_irq(irq, snd_wss_interrupt, IRQF_DISABLED,
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001837 "WSS", (void *) chip)) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001838 snd_printk(KERN_ERR "wss: can't grab IRQ %d\n", irq);
1839 snd_wss_free(chip);
1840 return -EBUSY;
1841 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 chip->irq = irq;
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001843 if (!(hwshare & WSS_HWSHARE_DMA1) && request_dma(dma1, "WSS - 1")) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001844 snd_printk(KERN_ERR "wss: can't grab DMA1 %d\n", dma1);
1845 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 return -EBUSY;
1847 }
1848 chip->dma1 = dma1;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001849 if (!(hwshare & WSS_HWSHARE_DMA2) && dma1 != dma2 &&
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001850 dma2 >= 0 && request_dma(dma2, "WSS - 2")) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001851 snd_printk(KERN_ERR "wss: can't grab DMA2 %d\n", dma2);
1852 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 return -EBUSY;
1854 }
1855 if (dma1 == dma2 || dma2 < 0) {
1856 chip->single_dma = 1;
1857 chip->dma2 = chip->dma1;
1858 } else
1859 chip->dma2 = dma2;
1860
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001861 if (hardware == WSS_HW_THINKPAD) {
1862 chip->thinkpad_flag = 1;
1863 chip->hardware = WSS_HW_DETECT; /* reset */
1864 snd_wss_thinkpad_twiddle(chip, 1);
1865 }
1866
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 /* global setup */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001868 if (snd_wss_probe(chip) < 0) {
1869 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 return -ENODEV;
1871 }
Krzysztof Helt7779f752008-07-31 21:03:41 +02001872 snd_wss_init(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
Takashi Iwaia9824c82005-11-17 17:51:00 +01001874#if 0
Krzysztof Helt7779f752008-07-31 21:03:41 +02001875 if (chip->hardware & WSS_HW_CS4232_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 if (chip->res_cport == NULL)
Takashi Iwai76d498e2009-02-05 15:45:05 +01001877 snd_printk(KERN_ERR "CS4232 control port features are "
1878 "not accessible\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 }
Takashi Iwaia9824c82005-11-17 17:51:00 +01001880#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881
1882 /* Register device */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001883 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
1884 if (err < 0) {
1885 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 return err;
1887 }
1888
1889#ifdef CONFIG_PM
1890 /* Power Management */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001891 chip->suspend = snd_wss_suspend;
1892 chip->resume = snd_wss_resume;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893#endif
1894
1895 *rchip = chip;
1896 return 0;
1897}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001898EXPORT_SYMBOL(snd_wss_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899
Krzysztof Helt7779f752008-07-31 21:03:41 +02001900static struct snd_pcm_ops snd_wss_playback_ops = {
1901 .open = snd_wss_playback_open,
1902 .close = snd_wss_playback_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 .ioctl = snd_pcm_lib_ioctl,
Krzysztof Helt7779f752008-07-31 21:03:41 +02001904 .hw_params = snd_wss_playback_hw_params,
1905 .hw_free = snd_wss_playback_hw_free,
1906 .prepare = snd_wss_playback_prepare,
1907 .trigger = snd_wss_trigger,
1908 .pointer = snd_wss_playback_pointer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909};
1910
Krzysztof Helt7779f752008-07-31 21:03:41 +02001911static struct snd_pcm_ops snd_wss_capture_ops = {
1912 .open = snd_wss_capture_open,
1913 .close = snd_wss_capture_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 .ioctl = snd_pcm_lib_ioctl,
Krzysztof Helt7779f752008-07-31 21:03:41 +02001915 .hw_params = snd_wss_capture_hw_params,
1916 .hw_free = snd_wss_capture_hw_free,
1917 .prepare = snd_wss_capture_prepare,
1918 .trigger = snd_wss_trigger,
1919 .pointer = snd_wss_capture_pointer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920};
1921
Krzysztof Helt7779f752008-07-31 21:03:41 +02001922int snd_wss_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923{
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001924 struct snd_pcm *pcm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 int err;
1926
Krzysztof Heltead893c2008-07-31 21:09:32 +02001927 err = snd_pcm_new(chip->card, "WSS", device, 1, 1, &pcm);
1928 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 return err;
1930
Krzysztof Helt7779f752008-07-31 21:03:41 +02001931 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_wss_playback_ops);
1932 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_wss_capture_ops);
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001933
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934 /* global setup */
1935 pcm->private_data = chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 pcm->info_flags = 0;
1937 if (chip->single_dma)
1938 pcm->info_flags |= SNDRV_PCM_INFO_HALF_DUPLEX;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001939 if (chip->hardware != WSS_HW_INTERWAVE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 pcm->info_flags |= SNDRV_PCM_INFO_JOINT_DUPLEX;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001941 strcpy(pcm->name, snd_wss_chip_id(chip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1944 snd_dma_isa_data(),
1945 64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
1947 chip->pcm = pcm;
1948 if (rpcm)
1949 *rpcm = pcm;
1950 return 0;
1951}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001952EXPORT_SYMBOL(snd_wss_pcm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953
Krzysztof Helt7779f752008-07-31 21:03:41 +02001954static void snd_wss_timer_free(struct snd_timer *timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001956 struct snd_wss *chip = timer->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 chip->timer = NULL;
1958}
1959
Krzysztof Helt7779f752008-07-31 21:03:41 +02001960int snd_wss_timer(struct snd_wss *chip, int device, struct snd_timer **rtimer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961{
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001962 struct snd_timer *timer;
1963 struct snd_timer_id tid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 int err;
1965
1966 /* Timer initialization */
1967 tid.dev_class = SNDRV_TIMER_CLASS_CARD;
1968 tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1969 tid.card = chip->card->number;
1970 tid.device = device;
1971 tid.subdevice = 0;
1972 if ((err = snd_timer_new(chip->card, "CS4231", &tid, &timer)) < 0)
1973 return err;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001974 strcpy(timer->name, snd_wss_chip_id(chip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 timer->private_data = chip;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001976 timer->private_free = snd_wss_timer_free;
1977 timer->hw = snd_wss_timer_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 chip->timer = timer;
1979 if (rtimer)
1980 *rtimer = timer;
1981 return 0;
1982}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001983EXPORT_SYMBOL(snd_wss_timer);
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001984
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985/*
1986 * MIXER part
1987 */
1988
Krzysztof Helt7779f752008-07-31 21:03:41 +02001989static int snd_wss_info_mux(struct snd_kcontrol *kcontrol,
1990 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991{
1992 static char *texts[4] = {
1993 "Line", "Aux", "Mic", "Mix"
1994 };
1995 static char *opl3sa_texts[4] = {
1996 "Line", "CD", "Mic", "Mix"
1997 };
1998 static char *gusmax_texts[4] = {
1999 "Line", "Synth", "Mic", "Mix"
2000 };
2001 char **ptexts = texts;
Krzysztof Helt7779f752008-07-31 21:03:41 +02002002 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003
Takashi Iwai622207d2008-08-08 17:11:45 +02002004 if (snd_BUG_ON(!chip->card))
2005 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2007 uinfo->count = 2;
2008 uinfo->value.enumerated.items = 4;
2009 if (uinfo->value.enumerated.item > 3)
2010 uinfo->value.enumerated.item = 3;
2011 if (!strcmp(chip->card->driver, "GUS MAX"))
2012 ptexts = gusmax_texts;
2013 switch (chip->hardware) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02002014 case WSS_HW_INTERWAVE:
2015 ptexts = gusmax_texts;
2016 break;
2017 case WSS_HW_OPL3SA2:
2018 ptexts = opl3sa_texts;
2019 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 }
2021 strcpy(uinfo->value.enumerated.name, ptexts[uinfo->value.enumerated.item]);
2022 return 0;
2023}
2024
Krzysztof Helt7779f752008-07-31 21:03:41 +02002025static int snd_wss_get_mux(struct snd_kcontrol *kcontrol,
2026 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002028 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 unsigned long flags;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002030
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 spin_lock_irqsave(&chip->reg_lock, flags);
2032 ucontrol->value.enumerated.item[0] = (chip->image[CS4231_LEFT_INPUT] & CS4231_MIXS_ALL) >> 6;
2033 ucontrol->value.enumerated.item[1] = (chip->image[CS4231_RIGHT_INPUT] & CS4231_MIXS_ALL) >> 6;
2034 spin_unlock_irqrestore(&chip->reg_lock, flags);
2035 return 0;
2036}
2037
Krzysztof Helt7779f752008-07-31 21:03:41 +02002038static int snd_wss_put_mux(struct snd_kcontrol *kcontrol,
2039 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002041 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 unsigned long flags;
2043 unsigned short left, right;
2044 int change;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002045
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 if (ucontrol->value.enumerated.item[0] > 3 ||
2047 ucontrol->value.enumerated.item[1] > 3)
2048 return -EINVAL;
2049 left = ucontrol->value.enumerated.item[0] << 6;
2050 right = ucontrol->value.enumerated.item[1] << 6;
2051 spin_lock_irqsave(&chip->reg_lock, flags);
2052 left = (chip->image[CS4231_LEFT_INPUT] & ~CS4231_MIXS_ALL) | left;
2053 right = (chip->image[CS4231_RIGHT_INPUT] & ~CS4231_MIXS_ALL) | right;
2054 change = left != chip->image[CS4231_LEFT_INPUT] ||
Krzysztof Helt7779f752008-07-31 21:03:41 +02002055 right != chip->image[CS4231_RIGHT_INPUT];
2056 snd_wss_out(chip, CS4231_LEFT_INPUT, left);
2057 snd_wss_out(chip, CS4231_RIGHT_INPUT, right);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 spin_unlock_irqrestore(&chip->reg_lock, flags);
2059 return change;
2060}
2061
Krzysztof Helt7779f752008-07-31 21:03:41 +02002062int snd_wss_info_single(struct snd_kcontrol *kcontrol,
2063 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064{
2065 int mask = (kcontrol->private_value >> 16) & 0xff;
2066
2067 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
2068 uinfo->count = 1;
2069 uinfo->value.integer.min = 0;
2070 uinfo->value.integer.max = mask;
2071 return 0;
2072}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002073EXPORT_SYMBOL(snd_wss_info_single);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074
Krzysztof Helt7779f752008-07-31 21:03:41 +02002075int snd_wss_get_single(struct snd_kcontrol *kcontrol,
2076 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002078 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 unsigned long flags;
2080 int reg = kcontrol->private_value & 0xff;
2081 int shift = (kcontrol->private_value >> 8) & 0xff;
2082 int mask = (kcontrol->private_value >> 16) & 0xff;
2083 int invert = (kcontrol->private_value >> 24) & 0xff;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002084
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 spin_lock_irqsave(&chip->reg_lock, flags);
2086 ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask;
2087 spin_unlock_irqrestore(&chip->reg_lock, flags);
2088 if (invert)
2089 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
2090 return 0;
2091}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002092EXPORT_SYMBOL(snd_wss_get_single);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093
Krzysztof Helt7779f752008-07-31 21:03:41 +02002094int snd_wss_put_single(struct snd_kcontrol *kcontrol,
2095 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002097 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098 unsigned long flags;
2099 int reg = kcontrol->private_value & 0xff;
2100 int shift = (kcontrol->private_value >> 8) & 0xff;
2101 int mask = (kcontrol->private_value >> 16) & 0xff;
2102 int invert = (kcontrol->private_value >> 24) & 0xff;
2103 int change;
2104 unsigned short val;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002105
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 val = (ucontrol->value.integer.value[0] & mask);
2107 if (invert)
2108 val = mask - val;
2109 val <<= shift;
2110 spin_lock_irqsave(&chip->reg_lock, flags);
2111 val = (chip->image[reg] & ~(mask << shift)) | val;
2112 change = val != chip->image[reg];
Krzysztof Helt7779f752008-07-31 21:03:41 +02002113 snd_wss_out(chip, reg, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 spin_unlock_irqrestore(&chip->reg_lock, flags);
2115 return change;
2116}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002117EXPORT_SYMBOL(snd_wss_put_single);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118
Krzysztof Helt7779f752008-07-31 21:03:41 +02002119int snd_wss_info_double(struct snd_kcontrol *kcontrol,
2120 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121{
2122 int mask = (kcontrol->private_value >> 24) & 0xff;
2123
2124 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
2125 uinfo->count = 2;
2126 uinfo->value.integer.min = 0;
2127 uinfo->value.integer.max = mask;
2128 return 0;
2129}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002130EXPORT_SYMBOL(snd_wss_info_double);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131
Krzysztof Helt7779f752008-07-31 21:03:41 +02002132int snd_wss_get_double(struct snd_kcontrol *kcontrol,
2133 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002135 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 unsigned long flags;
2137 int left_reg = kcontrol->private_value & 0xff;
2138 int right_reg = (kcontrol->private_value >> 8) & 0xff;
2139 int shift_left = (kcontrol->private_value >> 16) & 0x07;
2140 int shift_right = (kcontrol->private_value >> 19) & 0x07;
2141 int mask = (kcontrol->private_value >> 24) & 0xff;
2142 int invert = (kcontrol->private_value >> 22) & 1;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002143
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 spin_lock_irqsave(&chip->reg_lock, flags);
2145 ucontrol->value.integer.value[0] = (chip->image[left_reg] >> shift_left) & mask;
2146 ucontrol->value.integer.value[1] = (chip->image[right_reg] >> shift_right) & mask;
2147 spin_unlock_irqrestore(&chip->reg_lock, flags);
2148 if (invert) {
2149 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
2150 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
2151 }
2152 return 0;
2153}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002154EXPORT_SYMBOL(snd_wss_get_double);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002155
Krzysztof Helt7779f752008-07-31 21:03:41 +02002156int snd_wss_put_double(struct snd_kcontrol *kcontrol,
2157 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002159 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 unsigned long flags;
2161 int left_reg = kcontrol->private_value & 0xff;
2162 int right_reg = (kcontrol->private_value >> 8) & 0xff;
2163 int shift_left = (kcontrol->private_value >> 16) & 0x07;
2164 int shift_right = (kcontrol->private_value >> 19) & 0x07;
2165 int mask = (kcontrol->private_value >> 24) & 0xff;
2166 int invert = (kcontrol->private_value >> 22) & 1;
2167 int change;
2168 unsigned short val1, val2;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002169
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170 val1 = ucontrol->value.integer.value[0] & mask;
2171 val2 = ucontrol->value.integer.value[1] & mask;
2172 if (invert) {
2173 val1 = mask - val1;
2174 val2 = mask - val2;
2175 }
2176 val1 <<= shift_left;
2177 val2 <<= shift_right;
2178 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt5664daa2008-07-31 21:08:32 +02002179 if (left_reg != right_reg) {
2180 val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1;
2181 val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2;
2182 change = val1 != chip->image[left_reg] ||
2183 val2 != chip->image[right_reg];
2184 snd_wss_out(chip, left_reg, val1);
2185 snd_wss_out(chip, right_reg, val2);
2186 } else {
2187 mask = (mask << shift_left) | (mask << shift_right);
2188 val1 = (chip->image[left_reg] & ~mask) | val1 | val2;
2189 change = val1 != chip->image[left_reg];
2190 snd_wss_out(chip, left_reg, val1);
2191 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 spin_unlock_irqrestore(&chip->reg_lock, flags);
2193 return change;
2194}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002195EXPORT_SYMBOL(snd_wss_put_double);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196
Krzysztof Helt5664daa2008-07-31 21:08:32 +02002197static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
2198static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
2199static const DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
Krzysztof Heltabd134d2009-10-10 10:25:39 +02002200static const DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
Krzysztof Helt5664daa2008-07-31 21:08:32 +02002201
Krzysztof Helt7779f752008-07-31 21:03:41 +02002202static struct snd_kcontrol_new snd_wss_controls[] = {
2203WSS_DOUBLE("PCM Playback Switch", 0,
2204 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
Krzysztof Heltabd134d2009-10-10 10:25:39 +02002205WSS_DOUBLE_TLV("PCM Playback Volume", 0,
2206 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1,
2207 db_scale_6bit),
Krzysztof Helt7779f752008-07-31 21:03:41 +02002208WSS_DOUBLE("Aux Playback Switch", 0,
2209 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
Krzysztof Heltabd134d2009-10-10 10:25:39 +02002210WSS_DOUBLE_TLV("Aux Playback Volume", 0,
2211 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1,
2212 db_scale_5bit_12db_max),
Krzysztof Helt7779f752008-07-31 21:03:41 +02002213WSS_DOUBLE("Aux Playback Switch", 1,
2214 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
Krzysztof Heltabd134d2009-10-10 10:25:39 +02002215WSS_DOUBLE_TLV("Aux Playback Volume", 1,
2216 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1,
2217 db_scale_5bit_12db_max),
Krzysztof Heltabd134d2009-10-10 10:25:39 +02002218WSS_DOUBLE_TLV("Capture Volume", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT,
2219 0, 0, 15, 0, db_scale_rec_gain),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220{
2221 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2222 .name = "Capture Source",
Krzysztof Helt7779f752008-07-31 21:03:41 +02002223 .info = snd_wss_info_mux,
2224 .get = snd_wss_get_mux,
2225 .put = snd_wss_put_mux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226},
Krzysztof Heltb753e032009-11-17 18:34:54 +01002227WSS_DOUBLE("Mic Boost (+20dB)", 0,
Krzysztof Helt7779f752008-07-31 21:03:41 +02002228 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 5, 5, 1, 0),
2229WSS_SINGLE("Loopback Capture Switch", 0,
2230 CS4231_LOOPBACK, 0, 1, 0),
Krzysztof Heltabd134d2009-10-10 10:25:39 +02002231WSS_SINGLE_TLV("Loopback Capture Volume", 0, CS4231_LOOPBACK, 2, 63, 1,
2232 db_scale_6bit),
Krzysztof Helt633c7e92009-10-11 12:38:49 +02002233WSS_DOUBLE("Line Playback Switch", 0,
2234 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
2235WSS_DOUBLE_TLV("Line Playback Volume", 0,
2236 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1,
2237 db_scale_5bit_12db_max),
Krzysztof Heltb753e032009-11-17 18:34:54 +01002238WSS_SINGLE("Beep Playback Switch", 0,
Krzysztof Helt633c7e92009-10-11 12:38:49 +02002239 CS4231_MONO_CTRL, 7, 1, 1),
Krzysztof Heltb753e032009-11-17 18:34:54 +01002240WSS_SINGLE_TLV("Beep Playback Volume", 0,
Krzysztof Helt633c7e92009-10-11 12:38:49 +02002241 CS4231_MONO_CTRL, 0, 15, 1,
2242 db_scale_4bit),
2243WSS_SINGLE("Mono Output Playback Switch", 0,
2244 CS4231_MONO_CTRL, 6, 1, 1),
Krzysztof Heltb753e032009-11-17 18:34:54 +01002245WSS_SINGLE("Beep Bypass Playback Switch", 0,
Krzysztof Helt633c7e92009-10-11 12:38:49 +02002246 CS4231_MONO_CTRL, 5, 1, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247};
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002248
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002249static struct snd_kcontrol_new snd_opti93x_controls[] = {
Krzysztof Helt7779f752008-07-31 21:03:41 +02002250WSS_DOUBLE("Master Playback Switch", 0,
2251 OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 7, 7, 1, 1),
Krzysztof Heltabd134d2009-10-10 10:25:39 +02002252WSS_DOUBLE_TLV("Master Playback Volume", 0,
2253 OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 1, 1, 31, 1,
2254 db_scale_6bit),
Krzysztof Helt7779f752008-07-31 21:03:41 +02002255WSS_DOUBLE("PCM Playback Switch", 0,
2256 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
2257WSS_DOUBLE("PCM Playback Volume", 0,
2258 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 31, 1),
2259WSS_DOUBLE("FM Playback Switch", 0,
2260 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
2261WSS_DOUBLE("FM Playback Volume", 0,
2262 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 1, 1, 15, 1),
2263WSS_DOUBLE("Line Playback Switch", 0,
2264 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
2265WSS_DOUBLE("Line Playback Volume", 0,
2266 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 15, 1),
2267WSS_DOUBLE("Mic Playback Switch", 0,
2268 OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 7, 7, 1, 1),
2269WSS_DOUBLE("Mic Playback Volume", 0,
2270 OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 1, 1, 15, 1),
2271WSS_DOUBLE("Mic Boost", 0,
2272 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 5, 5, 1, 0),
2273WSS_DOUBLE("CD Playback Switch", 0,
2274 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
2275WSS_DOUBLE("CD Playback Volume", 0,
2276 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 1, 1, 15, 1),
2277WSS_DOUBLE("Aux Playback Switch", 0,
2278 OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 7, 7, 1, 1),
2279WSS_DOUBLE("Aux Playback Volume", 0,
2280 OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 1, 1, 15, 1),
2281WSS_DOUBLE("Capture Volume", 0,
2282 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 0, 0, 15, 0),
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002283{
2284 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2285 .name = "Capture Source",
Krzysztof Helt7779f752008-07-31 21:03:41 +02002286 .info = snd_wss_info_mux,
2287 .get = snd_wss_get_mux,
2288 .put = snd_wss_put_mux,
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002289}
2290};
2291
Krzysztof Helt7779f752008-07-31 21:03:41 +02002292int snd_wss_mixer(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293{
Takashi Iwaiba2375a2005-11-17 14:30:42 +01002294 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 unsigned int idx;
2296 int err;
2297
Takashi Iwai622207d2008-08-08 17:11:45 +02002298 if (snd_BUG_ON(!chip || !chip->pcm))
2299 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300
2301 card = chip->card;
2302
2303 strcpy(card->mixername, chip->pcm->name);
2304
Krzysztof Helt7779f752008-07-31 21:03:41 +02002305 if (chip->hardware == WSS_HW_OPTI93X)
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002306 for (idx = 0; idx < ARRAY_SIZE(snd_opti93x_controls); idx++) {
2307 err = snd_ctl_add(card,
2308 snd_ctl_new1(&snd_opti93x_controls[idx],
2309 chip));
2310 if (err < 0)
2311 return err;
2312 }
Krzysztof Helt633c7e92009-10-11 12:38:49 +02002313 else {
2314 int count = ARRAY_SIZE(snd_wss_controls);
2315
2316 /* Use only the first 11 entries on AD1848 */
2317 if (chip->hardware & WSS_HW_AD1848_MASK)
2318 count = 11;
2319
2320 for (idx = 0; idx < count; idx++) {
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002321 err = snd_ctl_add(card,
Krzysztof Helt7779f752008-07-31 21:03:41 +02002322 snd_ctl_new1(&snd_wss_controls[idx],
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002323 chip));
2324 if (err < 0)
2325 return err;
2326 }
Krzysztof Helt633c7e92009-10-11 12:38:49 +02002327 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 return 0;
2329}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002330EXPORT_SYMBOL(snd_wss_mixer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331
Krzysztof Heltead893c2008-07-31 21:09:32 +02002332const struct snd_pcm_ops *snd_wss_get_pcm_ops(int direction)
2333{
2334 return direction == SNDRV_PCM_STREAM_PLAYBACK ?
2335 &snd_wss_playback_ops : &snd_wss_capture_ops;
2336}
2337EXPORT_SYMBOL(snd_wss_get_pcm_ops);
2338
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339/*
2340 * INIT part
2341 */
2342
Krzysztof Helt7779f752008-07-31 21:03:41 +02002343static int __init alsa_wss_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344{
2345 return 0;
2346}
2347
Krzysztof Helt7779f752008-07-31 21:03:41 +02002348static void __exit alsa_wss_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349{
2350}
2351
Krzysztof Helt7779f752008-07-31 21:03:41 +02002352module_init(alsa_wss_init);
2353module_exit(alsa_wss_exit);