blob: 5d2ba1b749abef59839210b177944cd3c9a8a24c [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 Heltc2b73d12009-02-16 21:38:37 +01001685int 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}
Krzysztof Heltc2b73d12009-02-16 21:38:37 +01001708EXPORT_SYMBOL(snd_wss_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709
Krzysztof Helt7779f752008-07-31 21:03:41 +02001710static int snd_wss_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001712 struct snd_wss *chip = device->device_data;
1713 return snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714}
1715
Krzysztof Helt7779f752008-07-31 21:03:41 +02001716const char *snd_wss_chip_id(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717{
1718 switch (chip->hardware) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001719 case WSS_HW_CS4231:
1720 return "CS4231";
1721 case WSS_HW_CS4231A:
1722 return "CS4231A";
1723 case WSS_HW_CS4232:
1724 return "CS4232";
1725 case WSS_HW_CS4232A:
1726 return "CS4232A";
1727 case WSS_HW_CS4235:
1728 return "CS4235";
1729 case WSS_HW_CS4236:
1730 return "CS4236";
1731 case WSS_HW_CS4236B:
1732 return "CS4236B";
1733 case WSS_HW_CS4237B:
1734 return "CS4237B";
1735 case WSS_HW_CS4238B:
1736 return "CS4238B";
1737 case WSS_HW_CS4239:
1738 return "CS4239";
1739 case WSS_HW_INTERWAVE:
1740 return "AMD InterWave";
1741 case WSS_HW_OPL3SA2:
1742 return chip->card->shortname;
1743 case WSS_HW_AD1845:
1744 return "AD1845";
1745 case WSS_HW_OPTI93X:
1746 return "OPTi 93x";
Krzysztof Heltead893c2008-07-31 21:09:32 +02001747 case WSS_HW_AD1847:
1748 return "AD1847";
1749 case WSS_HW_AD1848:
1750 return "AD1848";
1751 case WSS_HW_CS4248:
1752 return "CS4248";
1753 case WSS_HW_CMI8330:
1754 return "CMI8330/C3D";
Krzysztof Helt7779f752008-07-31 21:03:41 +02001755 default:
1756 return "???";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 }
1758}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001759EXPORT_SYMBOL(snd_wss_chip_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760
Krzysztof Helt7779f752008-07-31 21:03:41 +02001761static int snd_wss_new(struct snd_card *card,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 unsigned short hardware,
1763 unsigned short hwshare,
Krzysztof Helt7779f752008-07-31 21:03:41 +02001764 struct snd_wss **rchip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001766 struct snd_wss *chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
1768 *rchip = NULL;
Takashi Iwai9e76a762005-09-09 14:21:17 +02001769 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 if (chip == NULL)
1771 return -ENOMEM;
1772 chip->hardware = hardware;
1773 chip->hwshare = hwshare;
1774
1775 spin_lock_init(&chip->reg_lock);
Ingo Molnar8b7547f2006-01-16 16:33:08 +01001776 mutex_init(&chip->mce_mutex);
1777 mutex_init(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 chip->card = card;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001779 chip->rate_constraint = snd_wss_xrate;
1780 chip->set_playback_format = snd_wss_playback_format;
1781 chip->set_capture_format = snd_wss_capture_format;
1782 if (chip->hardware == WSS_HW_OPTI93X)
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02001783 memcpy(&chip->image, &snd_opti93x_original_image,
1784 sizeof(snd_opti93x_original_image));
1785 else
Krzysztof Helt7779f752008-07-31 21:03:41 +02001786 memcpy(&chip->image, &snd_wss_original_image,
1787 sizeof(snd_wss_original_image));
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001788 if (chip->hardware & WSS_HW_AD1848_MASK) {
1789 chip->image[CS4231_PIN_CTRL] = 0;
1790 chip->image[CS4231_TEST_INIT] = 0;
1791 }
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02001792
Krzysztof Helt7779f752008-07-31 21:03:41 +02001793 *rchip = chip;
1794 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795}
1796
Krzysztof Helt7779f752008-07-31 21:03:41 +02001797int snd_wss_create(struct snd_card *card,
1798 unsigned long port,
1799 unsigned long cport,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 int irq, int dma1, int dma2,
1801 unsigned short hardware,
1802 unsigned short hwshare,
Krzysztof Helt7779f752008-07-31 21:03:41 +02001803 struct snd_wss **rchip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804{
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001805 static struct snd_device_ops ops = {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001806 .dev_free = snd_wss_dev_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 };
Krzysztof Helt7779f752008-07-31 21:03:41 +02001808 struct snd_wss *chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809 int err;
1810
Krzysztof Helt7779f752008-07-31 21:03:41 +02001811 err = snd_wss_new(card, hardware, hwshare, &chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 if (err < 0)
1813 return err;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001814
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 chip->irq = -1;
1816 chip->dma1 = -1;
1817 chip->dma2 = -1;
1818
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001819 chip->res_port = request_region(port, 4, "WSS");
Krzysztof Helt7779f752008-07-31 21:03:41 +02001820 if (!chip->res_port) {
1821 snd_printk(KERN_ERR "wss: can't grab port 0x%lx\n", port);
1822 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 return -EBUSY;
1824 }
1825 chip->port = port;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001826 if ((long)cport >= 0) {
1827 chip->res_cport = request_region(cport, 8, "CS4232 Control");
1828 if (!chip->res_cport) {
1829 snd_printk(KERN_ERR
1830 "wss: can't grab control port 0x%lx\n", cport);
1831 snd_wss_free(chip);
1832 return -ENODEV;
1833 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 }
1835 chip->cport = cport;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001836 if (!(hwshare & WSS_HWSHARE_IRQ))
1837 if (request_irq(irq, snd_wss_interrupt, IRQF_DISABLED,
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001838 "WSS", (void *) chip)) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001839 snd_printk(KERN_ERR "wss: can't grab IRQ %d\n", irq);
1840 snd_wss_free(chip);
1841 return -EBUSY;
1842 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 chip->irq = irq;
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001844 if (!(hwshare & WSS_HWSHARE_DMA1) && request_dma(dma1, "WSS - 1")) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001845 snd_printk(KERN_ERR "wss: can't grab DMA1 %d\n", dma1);
1846 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 return -EBUSY;
1848 }
1849 chip->dma1 = dma1;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001850 if (!(hwshare & WSS_HWSHARE_DMA2) && dma1 != dma2 &&
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001851 dma2 >= 0 && request_dma(dma2, "WSS - 2")) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02001852 snd_printk(KERN_ERR "wss: can't grab DMA2 %d\n", dma2);
1853 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 return -EBUSY;
1855 }
1856 if (dma1 == dma2 || dma2 < 0) {
1857 chip->single_dma = 1;
1858 chip->dma2 = chip->dma1;
1859 } else
1860 chip->dma2 = dma2;
1861
Krzysztof Helt760fc6b2008-07-31 21:10:47 +02001862 if (hardware == WSS_HW_THINKPAD) {
1863 chip->thinkpad_flag = 1;
1864 chip->hardware = WSS_HW_DETECT; /* reset */
1865 snd_wss_thinkpad_twiddle(chip, 1);
1866 }
1867
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868 /* global setup */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001869 if (snd_wss_probe(chip) < 0) {
1870 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 return -ENODEV;
1872 }
Krzysztof Helt7779f752008-07-31 21:03:41 +02001873 snd_wss_init(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874
Takashi Iwaia9824c82005-11-17 17:51:00 +01001875#if 0
Krzysztof Helt7779f752008-07-31 21:03:41 +02001876 if (chip->hardware & WSS_HW_CS4232_MASK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 if (chip->res_cport == NULL)
Takashi Iwai76d498e2009-02-05 15:45:05 +01001878 snd_printk(KERN_ERR "CS4232 control port features are "
1879 "not accessible\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 }
Takashi Iwaia9824c82005-11-17 17:51:00 +01001881#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882
1883 /* Register device */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001884 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
1885 if (err < 0) {
1886 snd_wss_free(chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 return err;
1888 }
1889
1890#ifdef CONFIG_PM
1891 /* Power Management */
Krzysztof Helt7779f752008-07-31 21:03:41 +02001892 chip->suspend = snd_wss_suspend;
1893 chip->resume = snd_wss_resume;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894#endif
1895
1896 *rchip = chip;
1897 return 0;
1898}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001899EXPORT_SYMBOL(snd_wss_create);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900
Krzysztof Helt7779f752008-07-31 21:03:41 +02001901static struct snd_pcm_ops snd_wss_playback_ops = {
1902 .open = snd_wss_playback_open,
1903 .close = snd_wss_playback_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 .ioctl = snd_pcm_lib_ioctl,
Krzysztof Helt7779f752008-07-31 21:03:41 +02001905 .hw_params = snd_wss_playback_hw_params,
1906 .hw_free = snd_wss_playback_hw_free,
1907 .prepare = snd_wss_playback_prepare,
1908 .trigger = snd_wss_trigger,
1909 .pointer = snd_wss_playback_pointer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910};
1911
Krzysztof Helt7779f752008-07-31 21:03:41 +02001912static struct snd_pcm_ops snd_wss_capture_ops = {
1913 .open = snd_wss_capture_open,
1914 .close = snd_wss_capture_close,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 .ioctl = snd_pcm_lib_ioctl,
Krzysztof Helt7779f752008-07-31 21:03:41 +02001916 .hw_params = snd_wss_capture_hw_params,
1917 .hw_free = snd_wss_capture_hw_free,
1918 .prepare = snd_wss_capture_prepare,
1919 .trigger = snd_wss_trigger,
1920 .pointer = snd_wss_capture_pointer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921};
1922
Krzysztof Helt7779f752008-07-31 21:03:41 +02001923int snd_wss_pcm(struct snd_wss *chip, int device, struct snd_pcm **rpcm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924{
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001925 struct snd_pcm *pcm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 int err;
1927
Krzysztof Heltead893c2008-07-31 21:09:32 +02001928 err = snd_pcm_new(chip->card, "WSS", device, 1, 1, &pcm);
1929 if (err < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 return err;
1931
Krzysztof Helt7779f752008-07-31 21:03:41 +02001932 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_wss_playback_ops);
1933 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_wss_capture_ops);
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001934
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 /* global setup */
1936 pcm->private_data = chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 pcm->info_flags = 0;
1938 if (chip->single_dma)
1939 pcm->info_flags |= SNDRV_PCM_INFO_HALF_DUPLEX;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001940 if (chip->hardware != WSS_HW_INTERWAVE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 pcm->info_flags |= SNDRV_PCM_INFO_JOINT_DUPLEX;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001942 strcpy(pcm->name, snd_wss_chip_id(chip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1945 snd_dma_isa_data(),
1946 64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947
1948 chip->pcm = pcm;
1949 if (rpcm)
1950 *rpcm = pcm;
1951 return 0;
1952}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001953EXPORT_SYMBOL(snd_wss_pcm);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954
Krzysztof Helt7779f752008-07-31 21:03:41 +02001955static void snd_wss_timer_free(struct snd_timer *timer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956{
Krzysztof Helt7779f752008-07-31 21:03:41 +02001957 struct snd_wss *chip = timer->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 chip->timer = NULL;
1959}
1960
Krzysztof Helt7779f752008-07-31 21:03:41 +02001961int snd_wss_timer(struct snd_wss *chip, int device, struct snd_timer **rtimer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962{
Takashi Iwaiba2375a2005-11-17 14:30:42 +01001963 struct snd_timer *timer;
1964 struct snd_timer_id tid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 int err;
1966
1967 /* Timer initialization */
1968 tid.dev_class = SNDRV_TIMER_CLASS_CARD;
1969 tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1970 tid.card = chip->card->number;
1971 tid.device = device;
1972 tid.subdevice = 0;
1973 if ((err = snd_timer_new(chip->card, "CS4231", &tid, &timer)) < 0)
1974 return err;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001975 strcpy(timer->name, snd_wss_chip_id(chip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 timer->private_data = chip;
Krzysztof Helt7779f752008-07-31 21:03:41 +02001977 timer->private_free = snd_wss_timer_free;
1978 timer->hw = snd_wss_timer_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 chip->timer = timer;
1980 if (rtimer)
1981 *rtimer = timer;
1982 return 0;
1983}
Krzysztof Helt7779f752008-07-31 21:03:41 +02001984EXPORT_SYMBOL(snd_wss_timer);
Krzysztof Helt9295aea2008-07-31 21:00:17 +02001985
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986/*
1987 * MIXER part
1988 */
1989
Krzysztof Helt7779f752008-07-31 21:03:41 +02001990static int snd_wss_info_mux(struct snd_kcontrol *kcontrol,
1991 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992{
1993 static char *texts[4] = {
1994 "Line", "Aux", "Mic", "Mix"
1995 };
1996 static char *opl3sa_texts[4] = {
1997 "Line", "CD", "Mic", "Mix"
1998 };
1999 static char *gusmax_texts[4] = {
2000 "Line", "Synth", "Mic", "Mix"
2001 };
2002 char **ptexts = texts;
Krzysztof Helt7779f752008-07-31 21:03:41 +02002003 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004
Takashi Iwai622207d2008-08-08 17:11:45 +02002005 if (snd_BUG_ON(!chip->card))
2006 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2008 uinfo->count = 2;
2009 uinfo->value.enumerated.items = 4;
2010 if (uinfo->value.enumerated.item > 3)
2011 uinfo->value.enumerated.item = 3;
2012 if (!strcmp(chip->card->driver, "GUS MAX"))
2013 ptexts = gusmax_texts;
2014 switch (chip->hardware) {
Krzysztof Helt7779f752008-07-31 21:03:41 +02002015 case WSS_HW_INTERWAVE:
2016 ptexts = gusmax_texts;
2017 break;
2018 case WSS_HW_OPL3SA2:
2019 ptexts = opl3sa_texts;
2020 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 }
2022 strcpy(uinfo->value.enumerated.name, ptexts[uinfo->value.enumerated.item]);
2023 return 0;
2024}
2025
Krzysztof Helt7779f752008-07-31 21:03:41 +02002026static int snd_wss_get_mux(struct snd_kcontrol *kcontrol,
2027 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002029 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 unsigned long flags;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002031
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032 spin_lock_irqsave(&chip->reg_lock, flags);
2033 ucontrol->value.enumerated.item[0] = (chip->image[CS4231_LEFT_INPUT] & CS4231_MIXS_ALL) >> 6;
2034 ucontrol->value.enumerated.item[1] = (chip->image[CS4231_RIGHT_INPUT] & CS4231_MIXS_ALL) >> 6;
2035 spin_unlock_irqrestore(&chip->reg_lock, flags);
2036 return 0;
2037}
2038
Krzysztof Helt7779f752008-07-31 21:03:41 +02002039static int snd_wss_put_mux(struct snd_kcontrol *kcontrol,
2040 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002042 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 unsigned long flags;
2044 unsigned short left, right;
2045 int change;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002046
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 if (ucontrol->value.enumerated.item[0] > 3 ||
2048 ucontrol->value.enumerated.item[1] > 3)
2049 return -EINVAL;
2050 left = ucontrol->value.enumerated.item[0] << 6;
2051 right = ucontrol->value.enumerated.item[1] << 6;
2052 spin_lock_irqsave(&chip->reg_lock, flags);
2053 left = (chip->image[CS4231_LEFT_INPUT] & ~CS4231_MIXS_ALL) | left;
2054 right = (chip->image[CS4231_RIGHT_INPUT] & ~CS4231_MIXS_ALL) | right;
2055 change = left != chip->image[CS4231_LEFT_INPUT] ||
Krzysztof Helt7779f752008-07-31 21:03:41 +02002056 right != chip->image[CS4231_RIGHT_INPUT];
2057 snd_wss_out(chip, CS4231_LEFT_INPUT, left);
2058 snd_wss_out(chip, CS4231_RIGHT_INPUT, right);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 spin_unlock_irqrestore(&chip->reg_lock, flags);
2060 return change;
2061}
2062
Krzysztof Helt7779f752008-07-31 21:03:41 +02002063int snd_wss_info_single(struct snd_kcontrol *kcontrol,
2064 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065{
2066 int mask = (kcontrol->private_value >> 16) & 0xff;
2067
2068 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
2069 uinfo->count = 1;
2070 uinfo->value.integer.min = 0;
2071 uinfo->value.integer.max = mask;
2072 return 0;
2073}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002074EXPORT_SYMBOL(snd_wss_info_single);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075
Krzysztof Helt7779f752008-07-31 21:03:41 +02002076int snd_wss_get_single(struct snd_kcontrol *kcontrol,
2077 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002079 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 unsigned long flags;
2081 int reg = kcontrol->private_value & 0xff;
2082 int shift = (kcontrol->private_value >> 8) & 0xff;
2083 int mask = (kcontrol->private_value >> 16) & 0xff;
2084 int invert = (kcontrol->private_value >> 24) & 0xff;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002085
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 spin_lock_irqsave(&chip->reg_lock, flags);
2087 ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask;
2088 spin_unlock_irqrestore(&chip->reg_lock, flags);
2089 if (invert)
2090 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
2091 return 0;
2092}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002093EXPORT_SYMBOL(snd_wss_get_single);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094
Krzysztof Helt7779f752008-07-31 21:03:41 +02002095int snd_wss_put_single(struct snd_kcontrol *kcontrol,
2096 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002098 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 unsigned long flags;
2100 int reg = kcontrol->private_value & 0xff;
2101 int shift = (kcontrol->private_value >> 8) & 0xff;
2102 int mask = (kcontrol->private_value >> 16) & 0xff;
2103 int invert = (kcontrol->private_value >> 24) & 0xff;
2104 int change;
2105 unsigned short val;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002106
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 val = (ucontrol->value.integer.value[0] & mask);
2108 if (invert)
2109 val = mask - val;
2110 val <<= shift;
2111 spin_lock_irqsave(&chip->reg_lock, flags);
2112 val = (chip->image[reg] & ~(mask << shift)) | val;
2113 change = val != chip->image[reg];
Krzysztof Helt7779f752008-07-31 21:03:41 +02002114 snd_wss_out(chip, reg, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 spin_unlock_irqrestore(&chip->reg_lock, flags);
2116 return change;
2117}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002118EXPORT_SYMBOL(snd_wss_put_single);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119
Krzysztof Helt7779f752008-07-31 21:03:41 +02002120int snd_wss_info_double(struct snd_kcontrol *kcontrol,
2121 struct snd_ctl_elem_info *uinfo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122{
2123 int mask = (kcontrol->private_value >> 24) & 0xff;
2124
2125 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
2126 uinfo->count = 2;
2127 uinfo->value.integer.min = 0;
2128 uinfo->value.integer.max = mask;
2129 return 0;
2130}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002131EXPORT_SYMBOL(snd_wss_info_double);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132
Krzysztof Helt7779f752008-07-31 21:03:41 +02002133int snd_wss_get_double(struct snd_kcontrol *kcontrol,
2134 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002136 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 unsigned long flags;
2138 int left_reg = kcontrol->private_value & 0xff;
2139 int right_reg = (kcontrol->private_value >> 8) & 0xff;
2140 int shift_left = (kcontrol->private_value >> 16) & 0x07;
2141 int shift_right = (kcontrol->private_value >> 19) & 0x07;
2142 int mask = (kcontrol->private_value >> 24) & 0xff;
2143 int invert = (kcontrol->private_value >> 22) & 1;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002144
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 spin_lock_irqsave(&chip->reg_lock, flags);
2146 ucontrol->value.integer.value[0] = (chip->image[left_reg] >> shift_left) & mask;
2147 ucontrol->value.integer.value[1] = (chip->image[right_reg] >> shift_right) & mask;
2148 spin_unlock_irqrestore(&chip->reg_lock, flags);
2149 if (invert) {
2150 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
2151 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
2152 }
2153 return 0;
2154}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002155EXPORT_SYMBOL(snd_wss_get_double);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156
Krzysztof Helt7779f752008-07-31 21:03:41 +02002157int snd_wss_put_double(struct snd_kcontrol *kcontrol,
2158 struct snd_ctl_elem_value *ucontrol)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159{
Krzysztof Helt7779f752008-07-31 21:03:41 +02002160 struct snd_wss *chip = snd_kcontrol_chip(kcontrol);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 unsigned long flags;
2162 int left_reg = kcontrol->private_value & 0xff;
2163 int right_reg = (kcontrol->private_value >> 8) & 0xff;
2164 int shift_left = (kcontrol->private_value >> 16) & 0x07;
2165 int shift_right = (kcontrol->private_value >> 19) & 0x07;
2166 int mask = (kcontrol->private_value >> 24) & 0xff;
2167 int invert = (kcontrol->private_value >> 22) & 1;
2168 int change;
2169 unsigned short val1, val2;
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002170
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 val1 = ucontrol->value.integer.value[0] & mask;
2172 val2 = ucontrol->value.integer.value[1] & mask;
2173 if (invert) {
2174 val1 = mask - val1;
2175 val2 = mask - val2;
2176 }
2177 val1 <<= shift_left;
2178 val2 <<= shift_right;
2179 spin_lock_irqsave(&chip->reg_lock, flags);
Krzysztof Helt5664daa2008-07-31 21:08:32 +02002180 if (left_reg != right_reg) {
2181 val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1;
2182 val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2;
2183 change = val1 != chip->image[left_reg] ||
2184 val2 != chip->image[right_reg];
2185 snd_wss_out(chip, left_reg, val1);
2186 snd_wss_out(chip, right_reg, val2);
2187 } else {
2188 mask = (mask << shift_left) | (mask << shift_right);
2189 val1 = (chip->image[left_reg] & ~mask) | val1 | val2;
2190 change = val1 != chip->image[left_reg];
2191 snd_wss_out(chip, left_reg, val1);
2192 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 spin_unlock_irqrestore(&chip->reg_lock, flags);
2194 return change;
2195}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002196EXPORT_SYMBOL(snd_wss_put_double);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197
Krzysztof Helt5664daa2008-07-31 21:08:32 +02002198static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
2199static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
2200static const DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
2201
2202static struct snd_kcontrol_new snd_ad1848_controls[] = {
2203WSS_DOUBLE("PCM Playback Switch", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT,
2204 7, 7, 1, 1),
2205WSS_DOUBLE_TLV("PCM Playback Volume", 0,
2206 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1,
2207 db_scale_6bit),
2208WSS_DOUBLE("Aux Playback Switch", 0,
2209 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
2210WSS_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),
2213WSS_DOUBLE("Aux Playback Switch", 1,
2214 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
2215WSS_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),
2218WSS_DOUBLE_TLV("Capture Volume", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT,
2219 0, 0, 15, 0, db_scale_rec_gain),
2220{
2221 .name = "Capture Source",
2222 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2223 .info = snd_wss_info_mux,
2224 .get = snd_wss_get_mux,
2225 .put = snd_wss_put_mux,
2226},
2227WSS_SINGLE("Loopback Capture Switch", 0, CS4231_LOOPBACK, 0, 1, 0),
2228WSS_SINGLE_TLV("Loopback Capture Volume", 0, CS4231_LOOPBACK, 1, 63, 0,
2229 db_scale_6bit),
2230};
2231
Krzysztof Helt7779f752008-07-31 21:03:41 +02002232static struct snd_kcontrol_new snd_wss_controls[] = {
2233WSS_DOUBLE("PCM Playback Switch", 0,
2234 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
2235WSS_DOUBLE("PCM Playback Volume", 0,
2236 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1),
2237WSS_DOUBLE("Line Playback Switch", 0,
2238 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
2239WSS_DOUBLE("Line Playback Volume", 0,
2240 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1),
2241WSS_DOUBLE("Aux Playback Switch", 0,
2242 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
2243WSS_DOUBLE("Aux Playback Volume", 0,
2244 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1),
2245WSS_DOUBLE("Aux Playback Switch", 1,
2246 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
2247WSS_DOUBLE("Aux Playback Volume", 1,
2248 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1),
2249WSS_SINGLE("Mono Playback Switch", 0,
2250 CS4231_MONO_CTRL, 7, 1, 1),
2251WSS_SINGLE("Mono Playback Volume", 0,
2252 CS4231_MONO_CTRL, 0, 15, 1),
2253WSS_SINGLE("Mono Output Playback Switch", 0,
2254 CS4231_MONO_CTRL, 6, 1, 1),
2255WSS_SINGLE("Mono Output Playback Bypass", 0,
2256 CS4231_MONO_CTRL, 5, 1, 0),
2257WSS_DOUBLE("Capture Volume", 0,
2258 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 0, 0, 15, 0),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259{
2260 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2261 .name = "Capture Source",
Krzysztof Helt7779f752008-07-31 21:03:41 +02002262 .info = snd_wss_info_mux,
2263 .get = snd_wss_get_mux,
2264 .put = snd_wss_put_mux,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002265},
Krzysztof Helt7779f752008-07-31 21:03:41 +02002266WSS_DOUBLE("Mic Boost", 0,
2267 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 5, 5, 1, 0),
2268WSS_SINGLE("Loopback Capture Switch", 0,
2269 CS4231_LOOPBACK, 0, 1, 0),
2270WSS_SINGLE("Loopback Capture Volume", 0,
2271 CS4231_LOOPBACK, 2, 63, 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272};
Krzysztof Helt9295aea2008-07-31 21:00:17 +02002273
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002274static struct snd_kcontrol_new snd_opti93x_controls[] = {
Krzysztof Helt7779f752008-07-31 21:03:41 +02002275WSS_DOUBLE("Master Playback Switch", 0,
2276 OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 7, 7, 1, 1),
2277WSS_DOUBLE("Master Playback Volume", 0,
2278 OPTi93X_OUT_LEFT, OPTi93X_OUT_RIGHT, 1, 1, 31, 1),
2279WSS_DOUBLE("PCM Playback Switch", 0,
2280 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
2281WSS_DOUBLE("PCM Playback Volume", 0,
2282 CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 31, 1),
2283WSS_DOUBLE("FM Playback Switch", 0,
2284 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
2285WSS_DOUBLE("FM Playback Volume", 0,
2286 CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 1, 1, 15, 1),
2287WSS_DOUBLE("Line Playback Switch", 0,
2288 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
2289WSS_DOUBLE("Line Playback Volume", 0,
2290 CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 15, 1),
2291WSS_DOUBLE("Mic Playback Switch", 0,
2292 OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 7, 7, 1, 1),
2293WSS_DOUBLE("Mic Playback Volume", 0,
2294 OPTi93X_MIC_LEFT_INPUT, OPTi93X_MIC_RIGHT_INPUT, 1, 1, 15, 1),
2295WSS_DOUBLE("Mic Boost", 0,
2296 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 5, 5, 1, 0),
2297WSS_DOUBLE("CD Playback Switch", 0,
2298 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
2299WSS_DOUBLE("CD Playback Volume", 0,
2300 CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 1, 1, 15, 1),
2301WSS_DOUBLE("Aux Playback Switch", 0,
2302 OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 7, 7, 1, 1),
2303WSS_DOUBLE("Aux Playback Volume", 0,
2304 OPTi931_AUX_LEFT_INPUT, OPTi931_AUX_RIGHT_INPUT, 1, 1, 15, 1),
2305WSS_DOUBLE("Capture Volume", 0,
2306 CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 0, 0, 15, 0),
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002307{
2308 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2309 .name = "Capture Source",
Krzysztof Helt7779f752008-07-31 21:03:41 +02002310 .info = snd_wss_info_mux,
2311 .get = snd_wss_get_mux,
2312 .put = snd_wss_put_mux,
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002313}
2314};
2315
Krzysztof Helt7779f752008-07-31 21:03:41 +02002316int snd_wss_mixer(struct snd_wss *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317{
Takashi Iwaiba2375a2005-11-17 14:30:42 +01002318 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 unsigned int idx;
2320 int err;
2321
Takashi Iwai622207d2008-08-08 17:11:45 +02002322 if (snd_BUG_ON(!chip || !chip->pcm))
2323 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324
2325 card = chip->card;
2326
2327 strcpy(card->mixername, chip->pcm->name);
2328
Krzysztof Helt7779f752008-07-31 21:03:41 +02002329 if (chip->hardware == WSS_HW_OPTI93X)
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002330 for (idx = 0; idx < ARRAY_SIZE(snd_opti93x_controls); idx++) {
2331 err = snd_ctl_add(card,
2332 snd_ctl_new1(&snd_opti93x_controls[idx],
2333 chip));
2334 if (err < 0)
2335 return err;
2336 }
Krzysztof Helt5664daa2008-07-31 21:08:32 +02002337 else if (chip->hardware & WSS_HW_AD1848_MASK)
2338 for (idx = 0; idx < ARRAY_SIZE(snd_ad1848_controls); idx++) {
2339 err = snd_ctl_add(card,
2340 snd_ctl_new1(&snd_ad1848_controls[idx],
2341 chip));
2342 if (err < 0)
2343 return err;
2344 }
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002345 else
Krzysztof Helt7779f752008-07-31 21:03:41 +02002346 for (idx = 0; idx < ARRAY_SIZE(snd_wss_controls); idx++) {
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002347 err = snd_ctl_add(card,
Krzysztof Helt7779f752008-07-31 21:03:41 +02002348 snd_ctl_new1(&snd_wss_controls[idx],
Krzysztof Heltabf1f5a2008-06-09 23:07:28 +02002349 chip));
2350 if (err < 0)
2351 return err;
2352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353 return 0;
2354}
Krzysztof Helt7779f752008-07-31 21:03:41 +02002355EXPORT_SYMBOL(snd_wss_mixer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356
Krzysztof Heltead893c2008-07-31 21:09:32 +02002357const struct snd_pcm_ops *snd_wss_get_pcm_ops(int direction)
2358{
2359 return direction == SNDRV_PCM_STREAM_PLAYBACK ?
2360 &snd_wss_playback_ops : &snd_wss_capture_ops;
2361}
2362EXPORT_SYMBOL(snd_wss_get_pcm_ops);
2363
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364/*
2365 * INIT part
2366 */
2367
Krzysztof Helt7779f752008-07-31 21:03:41 +02002368static int __init alsa_wss_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369{
2370 return 0;
2371}
2372
Krzysztof Helt7779f752008-07-31 21:03:41 +02002373static void __exit alsa_wss_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374{
2375}
2376
Krzysztof Helt7779f752008-07-31 21:03:41 +02002377module_init(alsa_wss_init);
2378module_exit(alsa_wss_exit);