[ALSA] cs4231-lib: replace common delay loop by function
[linux-2.6.git] / sound / isa / cs423x / cs4231_lib.c
1 /*
2  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3  *  Routines for control of CS4231(A)/CS4232/InterWave & compatible chips
4  *
5  *  Bugs:
6  *     - sometimes record brokes playback with WSS portion of 
7  *       Yamaha OPL3-SA3 chip
8  *     - CS4231 (GUS MAX) - still trouble with occasional noises
9  *                        - broken initialization?
10  *
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
27 #include <sound/driver.h>
28 #include <linux/delay.h>
29 #include <linux/pm.h>
30 #include <linux/init.h>
31 #include <linux/interrupt.h>
32 #include <linux/slab.h>
33 #include <linux/ioport.h>
34 #include <sound/core.h>
35 #include <sound/cs4231.h>
36 #include <sound/pcm_params.h>
37
38 #include <asm/io.h>
39 #include <asm/dma.h>
40 #include <asm/irq.h>
41
42 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
43 MODULE_DESCRIPTION("Routines for control of CS4231(A)/CS4232/InterWave & compatible chips");
44 MODULE_LICENSE("GPL");
45
46 #if 0
47 #define SNDRV_DEBUG_MCE
48 #endif
49
50 /*
51  *  Some variables
52  */
53
54 static 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
71 static unsigned int rates[14] = {
72         5510, 6620, 8000, 9600, 11025, 16000, 18900, 22050,
73         27042, 32000, 33075, 37800, 44100, 48000
74 };
75
76 static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
77         .count = ARRAY_SIZE(rates),
78         .list = rates,
79         .mask = 0,
80 };
81
82 static int snd_cs4231_xrate(struct snd_pcm_runtime *runtime)
83 {
84         return snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hw_constraints_rates);
85 }
86
87 static unsigned char snd_cs4231_original_image[32] =
88 {
89         0x00,                   /* 00/00 - lic */
90         0x00,                   /* 01/01 - ric */
91         0x9f,                   /* 02/02 - la1ic */
92         0x9f,                   /* 03/03 - ra1ic */
93         0x9f,                   /* 04/04 - la2ic */
94         0x9f,                   /* 05/05 - ra2ic */
95         0xbf,                   /* 06/06 - loc */
96         0xbf,                   /* 07/07 - roc */
97         0x20,                   /* 08/08 - pdfr */
98         CS4231_AUTOCALIB,       /* 09/09 - ic */
99         0x00,                   /* 0a/10 - pc */
100         0x00,                   /* 0b/11 - ti */
101         CS4231_MODE2,           /* 0c/12 - mi */
102         0xfc,                   /* 0d/13 - lbc */
103         0x00,                   /* 0e/14 - pbru */
104         0x00,                   /* 0f/15 - pbrl */
105         0x80,                   /* 10/16 - afei */
106         0x01,                   /* 11/17 - afeii */
107         0x9f,                   /* 12/18 - llic */
108         0x9f,                   /* 13/19 - rlic */
109         0x00,                   /* 14/20 - tlb */
110         0x00,                   /* 15/21 - thb */
111         0x00,                   /* 16/22 - la3mic/reserved */
112         0x00,                   /* 17/23 - ra3mic/reserved */
113         0x00,                   /* 18/24 - afs */
114         0x00,                   /* 19/25 - lamoc/version */
115         0xcf,                   /* 1a/26 - mioc */
116         0x00,                   /* 1b/27 - ramoc/reserved */
117         0x20,                   /* 1c/28 - cdfr */
118         0x00,                   /* 1d/29 - res4 */
119         0x00,                   /* 1e/30 - cbru */
120         0x00,                   /* 1f/31 - cbrl */
121 };
122
123 /*
124  *  Basic I/O functions
125  */
126
127 static inline void cs4231_outb(struct snd_cs4231 *chip, u8 offset, u8 val)
128 {
129         outb(val, chip->port + offset);
130 }
131
132 static inline u8 cs4231_inb(struct snd_cs4231 *chip, u8 offset)
133 {
134         return inb(chip->port + offset);
135 }
136
137 static void snd_cs4231_wait(struct snd_cs4231 *chip)
138 {
139         int timeout;
140
141         for (timeout = 250;
142              timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
143              timeout--)
144                 udelay(100);
145 }
146
147 static void snd_cs4231_outm(struct snd_cs4231 *chip, unsigned char reg,
148                             unsigned char mask, unsigned char value)
149 {
150         unsigned char tmp = (chip->image[reg] & mask) | value;
151
152         snd_cs4231_wait(chip);
153 #ifdef CONFIG_SND_DEBUG
154         if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
155                 snd_printk("outm: auto calibration time out - reg = 0x%x, value = 0x%x\n", reg, value);
156 #endif
157         chip->image[reg] = tmp;
158         if (!chip->calibrate_mute) {
159                 cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
160                 wmb();
161                 cs4231_outb(chip, CS4231P(REG), tmp);
162                 mb();
163         }
164 }
165
166 static void snd_cs4231_dout(struct snd_cs4231 *chip, unsigned char reg, unsigned char value)
167 {
168         int timeout;
169
170         for (timeout = 250;
171              timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
172              timeout--)
173                 udelay(10);
174         cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
175         cs4231_outb(chip, CS4231P(REG), value);
176         mb();
177 }
178
179 void snd_cs4231_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char value)
180 {
181         snd_cs4231_wait(chip);
182 #ifdef CONFIG_SND_DEBUG
183         if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
184                 snd_printk("out: auto calibration time out - reg = 0x%x, value = 0x%x\n", reg, value);
185 #endif
186         cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
187         cs4231_outb(chip, CS4231P(REG), value);
188         chip->image[reg] = value;
189         mb();
190         snd_printdd("codec out - reg 0x%x = 0x%x\n",
191                         chip->mce_bit | reg, value);
192 }
193
194 unsigned char snd_cs4231_in(struct snd_cs4231 *chip, unsigned char reg)
195 {
196         snd_cs4231_wait(chip);
197 #ifdef CONFIG_SND_DEBUG
198         if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
199                 snd_printk("in: auto calibration time out - reg = 0x%x\n", reg);
200 #endif
201         cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | reg);
202         mb();
203         return cs4231_inb(chip, CS4231P(REG));
204 }
205
206 void snd_cs4236_ext_out(struct snd_cs4231 *chip, unsigned char reg, unsigned char val)
207 {
208         cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | 0x17);
209         cs4231_outb(chip, CS4231P(REG), reg | (chip->image[CS4236_EXT_REG] & 0x01));
210         cs4231_outb(chip, CS4231P(REG), val);
211         chip->eimage[CS4236_REG(reg)] = val;
212 #if 0
213         printk("ext out : reg = 0x%x, val = 0x%x\n", reg, val);
214 #endif
215 }
216
217 unsigned char snd_cs4236_ext_in(struct snd_cs4231 *chip, unsigned char reg)
218 {
219         cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | 0x17);
220         cs4231_outb(chip, CS4231P(REG), reg | (chip->image[CS4236_EXT_REG] & 0x01));
221 #if 1
222         return cs4231_inb(chip, CS4231P(REG));
223 #else
224         {
225                 unsigned char res;
226                 res = cs4231_inb(chip, CS4231P(REG));
227                 printk("ext in : reg = 0x%x, val = 0x%x\n", reg, res);
228                 return res;
229         }
230 #endif
231 }
232
233 #if 0
234
235 static void snd_cs4231_debug(struct snd_cs4231 *chip)
236 {
237         printk("CS4231 REGS:      INDEX = 0x%02x  ", cs4231_inb(chip, CS4231P(REGSEL)));
238         printk("                 STATUS = 0x%02x\n", cs4231_inb(chip, CS4231P(STATUS)));
239         printk("  0x00: left input      = 0x%02x  ", snd_cs4231_in(chip, 0x00));
240         printk("  0x10: alt 1 (CFIG 2)  = 0x%02x\n", snd_cs4231_in(chip, 0x10));
241         printk("  0x01: right input     = 0x%02x  ", snd_cs4231_in(chip, 0x01));
242         printk("  0x11: alt 2 (CFIG 3)  = 0x%02x\n", snd_cs4231_in(chip, 0x11));
243         printk("  0x02: GF1 left input  = 0x%02x  ", snd_cs4231_in(chip, 0x02));
244         printk("  0x12: left line in    = 0x%02x\n", snd_cs4231_in(chip, 0x12));
245         printk("  0x03: GF1 right input = 0x%02x  ", snd_cs4231_in(chip, 0x03));
246         printk("  0x13: right line in   = 0x%02x\n", snd_cs4231_in(chip, 0x13));
247         printk("  0x04: CD left input   = 0x%02x  ", snd_cs4231_in(chip, 0x04));
248         printk("  0x14: timer low       = 0x%02x\n", snd_cs4231_in(chip, 0x14));
249         printk("  0x05: CD right input  = 0x%02x  ", snd_cs4231_in(chip, 0x05));
250         printk("  0x15: timer high      = 0x%02x\n", snd_cs4231_in(chip, 0x15));
251         printk("  0x06: left output     = 0x%02x  ", snd_cs4231_in(chip, 0x06));
252         printk("  0x16: left MIC (PnP)  = 0x%02x\n", snd_cs4231_in(chip, 0x16));
253         printk("  0x07: right output    = 0x%02x  ", snd_cs4231_in(chip, 0x07));
254         printk("  0x17: right MIC (PnP) = 0x%02x\n", snd_cs4231_in(chip, 0x17));
255         printk("  0x08: playback format = 0x%02x  ", snd_cs4231_in(chip, 0x08));
256         printk("  0x18: IRQ status      = 0x%02x\n", snd_cs4231_in(chip, 0x18));
257         printk("  0x09: iface (CFIG 1)  = 0x%02x  ", snd_cs4231_in(chip, 0x09));
258         printk("  0x19: left line out   = 0x%02x\n", snd_cs4231_in(chip, 0x19));
259         printk("  0x0a: pin control     = 0x%02x  ", snd_cs4231_in(chip, 0x0a));
260         printk("  0x1a: mono control    = 0x%02x\n", snd_cs4231_in(chip, 0x1a));
261         printk("  0x0b: init & status   = 0x%02x  ", snd_cs4231_in(chip, 0x0b));
262         printk("  0x1b: right line out  = 0x%02x\n", snd_cs4231_in(chip, 0x1b));
263         printk("  0x0c: revision & mode = 0x%02x  ", snd_cs4231_in(chip, 0x0c));
264         printk("  0x1c: record format   = 0x%02x\n", snd_cs4231_in(chip, 0x1c));
265         printk("  0x0d: loopback        = 0x%02x  ", snd_cs4231_in(chip, 0x0d));
266         printk("  0x1d: var freq (PnP)  = 0x%02x\n", snd_cs4231_in(chip, 0x1d));
267         printk("  0x0e: ply upr count   = 0x%02x  ", snd_cs4231_in(chip, 0x0e));
268         printk("  0x1e: ply lwr count   = 0x%02x\n", snd_cs4231_in(chip, 0x1e));
269         printk("  0x0f: rec upr count   = 0x%02x  ", snd_cs4231_in(chip, 0x0f));
270         printk("  0x1f: rec lwr count   = 0x%02x\n", snd_cs4231_in(chip, 0x1f));
271 }
272
273 #endif
274
275 /*
276  *  CS4231 detection / MCE routines
277  */
278
279 static void snd_cs4231_busy_wait(struct snd_cs4231 *chip)
280 {
281         int timeout;
282
283         /* huh.. looks like this sequence is proper for CS4231A chip (GUS MAX) */
284         for (timeout = 5; timeout > 0; timeout--)
285                 cs4231_inb(chip, CS4231P(REGSEL));
286         /* end of cleanup sequence */
287         for (timeout = 250;
288              timeout > 0 && (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT);
289              timeout--)
290                 udelay(10);
291 }
292
293 void snd_cs4231_mce_up(struct snd_cs4231 *chip)
294 {
295         unsigned long flags;
296         int timeout;
297
298         snd_cs4231_wait(chip);
299 #ifdef CONFIG_SND_DEBUG
300         if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
301                 snd_printk("mce_up - auto calibration time out (0)\n");
302 #endif
303         spin_lock_irqsave(&chip->reg_lock, flags);
304         chip->mce_bit |= CS4231_MCE;
305         timeout = cs4231_inb(chip, CS4231P(REGSEL));
306         if (timeout == 0x80)
307                 snd_printk("mce_up [0x%lx]: serious init problem - codec still busy\n", chip->port);
308         if (!(timeout & CS4231_MCE))
309                 cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
310         spin_unlock_irqrestore(&chip->reg_lock, flags);
311 }
312
313 void snd_cs4231_mce_down(struct snd_cs4231 *chip)
314 {
315         unsigned long flags;
316         int timeout;
317
318         snd_cs4231_busy_wait(chip);
319 #if 0
320         printk("(1) timeout = %i\n", timeout);
321 #endif
322 #ifdef CONFIG_SND_DEBUG
323         if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
324                 snd_printk("mce_down [0x%lx] - auto calibration time out (0)\n", (long)CS4231P(REGSEL));
325 #endif
326         spin_lock_irqsave(&chip->reg_lock, flags);
327         chip->mce_bit &= ~CS4231_MCE;
328         timeout = cs4231_inb(chip, CS4231P(REGSEL));
329         cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
330         spin_unlock_irqrestore(&chip->reg_lock, flags);
331         if (timeout == 0x80)
332                 snd_printk("mce_down [0x%lx]: serious init problem - codec still busy\n", chip->port);
333         if ((timeout & CS4231_MCE) == 0 ||
334             !(chip->hardware & (CS4231_HW_CS4231_MASK | CS4231_HW_CS4232_MASK))) {
335                 return;
336         }
337         snd_cs4231_busy_wait(chip);
338
339         /* calibration process */
340
341         for (timeout = 500; timeout > 0 && (snd_cs4231_in(chip, CS4231_TEST_INIT) & CS4231_CALIB_IN_PROGRESS) == 0; timeout--)
342                 udelay(10);
343         if ((snd_cs4231_in(chip, CS4231_TEST_INIT) & CS4231_CALIB_IN_PROGRESS) == 0) {
344                 snd_printd("cs4231_mce_down - auto calibration time out (1)\n");
345                 return;
346         }
347 #if 0
348         printk("(2) timeout = %i, jiffies = %li\n", timeout, jiffies);
349 #endif
350         /* in 10 ms increments, check condition, up to 250 ms */
351         timeout = 25;
352         while (snd_cs4231_in(chip, CS4231_TEST_INIT) & CS4231_CALIB_IN_PROGRESS) {
353                 if (--timeout < 0) {
354                         snd_printk("mce_down - auto calibration time out (2)\n");
355                         return;
356                 }
357                 msleep(10);
358         }
359 #if 0
360         printk("(3) jiffies = %li\n", jiffies);
361 #endif
362         /* in 10 ms increments, check condition, up to 100 ms */
363         timeout = 10;
364         while (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT) {
365                 if (--timeout < 0) {
366                         snd_printk(KERN_ERR "mce_down - auto calibration time out (3)\n");
367                         return;
368                 }
369                 msleep(10);
370         }
371 #if 0
372         printk("(4) jiffies = %li\n", jiffies);
373         snd_printk("mce_down - exit = 0x%x\n", cs4231_inb(chip, CS4231P(REGSEL)));
374 #endif
375 }
376
377 static unsigned int snd_cs4231_get_count(unsigned char format, unsigned int size)
378 {
379         switch (format & 0xe0) {
380         case CS4231_LINEAR_16:
381         case CS4231_LINEAR_16_BIG:
382                 size >>= 1;
383                 break;
384         case CS4231_ADPCM_16:
385                 return size >> 2;
386         }
387         if (format & CS4231_STEREO)
388                 size >>= 1;
389         return size;
390 }
391
392 static int snd_cs4231_trigger(struct snd_pcm_substream *substream,
393                               int cmd)
394 {
395         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
396         int result = 0;
397         unsigned int what;
398         struct snd_pcm_substream *s;
399         int do_start;
400
401 #if 0
402         printk("codec trigger!!! - what = %i, enable = %i, status = 0x%x\n", what, enable, cs4231_inb(chip, CS4231P(STATUS)));
403 #endif
404
405         switch (cmd) {
406         case SNDRV_PCM_TRIGGER_START:
407         case SNDRV_PCM_TRIGGER_RESUME:
408                 do_start = 1; break;
409         case SNDRV_PCM_TRIGGER_STOP:
410         case SNDRV_PCM_TRIGGER_SUSPEND:
411                 do_start = 0; break;
412         default:
413                 return -EINVAL;
414         }
415
416         what = 0;
417         snd_pcm_group_for_each_entry(s, substream) {
418                 if (s == chip->playback_substream) {
419                         what |= CS4231_PLAYBACK_ENABLE;
420                         snd_pcm_trigger_done(s, substream);
421                 } else if (s == chip->capture_substream) {
422                         what |= CS4231_RECORD_ENABLE;
423                         snd_pcm_trigger_done(s, substream);
424                 }
425         }
426         spin_lock(&chip->reg_lock);
427         if (do_start) {
428                 chip->image[CS4231_IFACE_CTRL] |= what;
429                 if (chip->trigger)
430                         chip->trigger(chip, what, 1);
431         } else {
432                 chip->image[CS4231_IFACE_CTRL] &= ~what;
433                 if (chip->trigger)
434                         chip->trigger(chip, what, 0);
435         }
436         snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
437         spin_unlock(&chip->reg_lock);
438 #if 0
439         snd_cs4231_debug(chip);
440 #endif
441         return result;
442 }
443
444 /*
445  *  CODEC I/O
446  */
447
448 static unsigned char snd_cs4231_get_rate(unsigned int rate)
449 {
450         int i;
451
452         for (i = 0; i < ARRAY_SIZE(rates); i++)
453                 if (rate == rates[i])
454                         return freq_bits[i];
455         // snd_BUG();
456         return freq_bits[ARRAY_SIZE(rates) - 1];
457 }
458
459 static unsigned char snd_cs4231_get_format(struct snd_cs4231 *chip,
460                                            int format,
461                                            int channels)
462 {
463         unsigned char rformat;
464
465         rformat = CS4231_LINEAR_8;
466         switch (format) {
467         case SNDRV_PCM_FORMAT_MU_LAW:   rformat = CS4231_ULAW_8; break;
468         case SNDRV_PCM_FORMAT_A_LAW:    rformat = CS4231_ALAW_8; break;
469         case SNDRV_PCM_FORMAT_S16_LE:   rformat = CS4231_LINEAR_16; break;
470         case SNDRV_PCM_FORMAT_S16_BE:   rformat = CS4231_LINEAR_16_BIG; break;
471         case SNDRV_PCM_FORMAT_IMA_ADPCM:        rformat = CS4231_ADPCM_16; break;
472         }
473         if (channels > 1)
474                 rformat |= CS4231_STEREO;
475 #if 0
476         snd_printk("get_format: 0x%x (mode=0x%x)\n", format, mode);
477 #endif
478         return rformat;
479 }
480
481 static void snd_cs4231_calibrate_mute(struct snd_cs4231 *chip, int mute)
482 {
483         unsigned long flags;
484
485         mute = mute ? 1 : 0;
486         spin_lock_irqsave(&chip->reg_lock, flags);
487         if (chip->calibrate_mute == mute) {
488                 spin_unlock_irqrestore(&chip->reg_lock, flags);
489                 return;
490         }
491         if (!mute) {
492                 snd_cs4231_dout(chip, CS4231_LEFT_INPUT, chip->image[CS4231_LEFT_INPUT]);
493                 snd_cs4231_dout(chip, CS4231_RIGHT_INPUT, chip->image[CS4231_RIGHT_INPUT]);
494                 snd_cs4231_dout(chip, CS4231_LOOPBACK, chip->image[CS4231_LOOPBACK]);
495         }
496         snd_cs4231_dout(chip, CS4231_AUX1_LEFT_INPUT, mute ? 0x80 : chip->image[CS4231_AUX1_LEFT_INPUT]);
497         snd_cs4231_dout(chip, CS4231_AUX1_RIGHT_INPUT, mute ? 0x80 : chip->image[CS4231_AUX1_RIGHT_INPUT]);
498         snd_cs4231_dout(chip, CS4231_AUX2_LEFT_INPUT, mute ? 0x80 : chip->image[CS4231_AUX2_LEFT_INPUT]);
499         snd_cs4231_dout(chip, CS4231_AUX2_RIGHT_INPUT, mute ? 0x80 : chip->image[CS4231_AUX2_RIGHT_INPUT]);
500         snd_cs4231_dout(chip, CS4231_LEFT_OUTPUT, mute ? 0x80 : chip->image[CS4231_LEFT_OUTPUT]);
501         snd_cs4231_dout(chip, CS4231_RIGHT_OUTPUT, mute ? 0x80 : chip->image[CS4231_RIGHT_OUTPUT]);
502         snd_cs4231_dout(chip, CS4231_LEFT_LINE_IN, mute ? 0x80 : chip->image[CS4231_LEFT_LINE_IN]);
503         snd_cs4231_dout(chip, CS4231_RIGHT_LINE_IN, mute ? 0x80 : chip->image[CS4231_RIGHT_LINE_IN]);
504         snd_cs4231_dout(chip, CS4231_MONO_CTRL, mute ? 0xc0 : chip->image[CS4231_MONO_CTRL]);
505         if (chip->hardware == CS4231_HW_INTERWAVE) {
506                 snd_cs4231_dout(chip, CS4231_LEFT_MIC_INPUT, mute ? 0x80 : chip->image[CS4231_LEFT_MIC_INPUT]);
507                 snd_cs4231_dout(chip, CS4231_RIGHT_MIC_INPUT, mute ? 0x80 : chip->image[CS4231_RIGHT_MIC_INPUT]);               
508                 snd_cs4231_dout(chip, CS4231_LINE_LEFT_OUTPUT, mute ? 0x80 : chip->image[CS4231_LINE_LEFT_OUTPUT]);
509                 snd_cs4231_dout(chip, CS4231_LINE_RIGHT_OUTPUT, mute ? 0x80 : chip->image[CS4231_LINE_RIGHT_OUTPUT]);
510         }
511         chip->calibrate_mute = mute;
512         spin_unlock_irqrestore(&chip->reg_lock, flags);
513 }
514
515 static void snd_cs4231_playback_format(struct snd_cs4231 *chip,
516                                        struct snd_pcm_hw_params *params,
517                                        unsigned char pdfr)
518 {
519         unsigned long flags;
520         int full_calib = 1;
521
522         mutex_lock(&chip->mce_mutex);
523         snd_cs4231_calibrate_mute(chip, 1);
524         if (chip->hardware == CS4231_HW_CS4231A ||
525             (chip->hardware & CS4231_HW_CS4232_MASK)) {
526                 spin_lock_irqsave(&chip->reg_lock, flags);
527                 if ((chip->image[CS4231_PLAYBK_FORMAT] & 0x0f) == (pdfr & 0x0f)) {      /* rate is same? */
528                         snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] | 0x10);
529                         snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, chip->image[CS4231_PLAYBK_FORMAT] = pdfr);
530                         snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] &= ~0x10);
531                         udelay(100); /* Fixes audible clicks at least on GUS MAX */
532                         full_calib = 0;
533                 }
534                 spin_unlock_irqrestore(&chip->reg_lock, flags);
535         }
536         if (full_calib) {
537                 snd_cs4231_mce_up(chip);
538                 spin_lock_irqsave(&chip->reg_lock, flags);
539                 if (chip->hardware != CS4231_HW_INTERWAVE && !chip->single_dma) {
540                         snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT,
541                                         (chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE) ?
542                                         (pdfr & 0xf0) | (chip->image[CS4231_REC_FORMAT] & 0x0f) :
543                                         pdfr);
544                 } else {
545                         snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, chip->image[CS4231_PLAYBK_FORMAT] = pdfr);
546                 }
547                 spin_unlock_irqrestore(&chip->reg_lock, flags);
548                 if (chip->hardware == CS4231_HW_OPL3SA2)
549                         udelay(100);    /* this seems to help */
550                 snd_cs4231_mce_down(chip);
551         }
552         snd_cs4231_calibrate_mute(chip, 0);
553         mutex_unlock(&chip->mce_mutex);
554 }
555
556 static void snd_cs4231_capture_format(struct snd_cs4231 *chip,
557                                       struct snd_pcm_hw_params *params,
558                                       unsigned char cdfr)
559 {
560         unsigned long flags;
561         int full_calib = 1;
562
563         mutex_lock(&chip->mce_mutex);
564         snd_cs4231_calibrate_mute(chip, 1);
565         if (chip->hardware == CS4231_HW_CS4231A ||
566             (chip->hardware & CS4231_HW_CS4232_MASK)) {
567                 spin_lock_irqsave(&chip->reg_lock, flags);
568                 if ((chip->image[CS4231_PLAYBK_FORMAT] & 0x0f) == (cdfr & 0x0f) ||      /* rate is same? */
569                     (chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) {
570                         snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] | 0x20);
571                         snd_cs4231_out(chip, CS4231_REC_FORMAT, chip->image[CS4231_REC_FORMAT] = cdfr);
572                         snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] &= ~0x20);
573                         full_calib = 0;
574                 }
575                 spin_unlock_irqrestore(&chip->reg_lock, flags);
576         }
577         if (full_calib) {
578                 snd_cs4231_mce_up(chip);
579                 spin_lock_irqsave(&chip->reg_lock, flags);
580                 if (chip->hardware != CS4231_HW_INTERWAVE) {
581                         if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE)) {
582                                 snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT,
583                                                ((chip->single_dma ? cdfr : chip->image[CS4231_PLAYBK_FORMAT]) & 0xf0) |
584                                                (cdfr & 0x0f));
585                                 spin_unlock_irqrestore(&chip->reg_lock, flags);
586                                 snd_cs4231_mce_down(chip);
587                                 snd_cs4231_mce_up(chip);
588                                 spin_lock_irqsave(&chip->reg_lock, flags);
589                         }
590                 }
591                 snd_cs4231_out(chip, CS4231_REC_FORMAT, cdfr);
592                 spin_unlock_irqrestore(&chip->reg_lock, flags);
593                 snd_cs4231_mce_down(chip);
594         }
595         snd_cs4231_calibrate_mute(chip, 0);
596         mutex_unlock(&chip->mce_mutex);
597 }
598
599 /*
600  *  Timer interface
601  */
602
603 static unsigned long snd_cs4231_timer_resolution(struct snd_timer * timer)
604 {
605         struct snd_cs4231 *chip = snd_timer_chip(timer);
606         if (chip->hardware & CS4231_HW_CS4236B_MASK)
607                 return 14467;
608         else
609                 return chip->image[CS4231_PLAYBK_FORMAT] & 1 ? 9969 : 9920;
610 }
611
612 static int snd_cs4231_timer_start(struct snd_timer * timer)
613 {
614         unsigned long flags;
615         unsigned int ticks;
616         struct snd_cs4231 *chip = snd_timer_chip(timer);
617         spin_lock_irqsave(&chip->reg_lock, flags);
618         ticks = timer->sticks;
619         if ((chip->image[CS4231_ALT_FEATURE_1] & CS4231_TIMER_ENABLE) == 0 ||
620             (unsigned char)(ticks >> 8) != chip->image[CS4231_TIMER_HIGH] ||
621             (unsigned char)ticks != chip->image[CS4231_TIMER_LOW]) {
622                 snd_cs4231_out(chip, CS4231_TIMER_HIGH, chip->image[CS4231_TIMER_HIGH] = (unsigned char) (ticks >> 8));
623                 snd_cs4231_out(chip, CS4231_TIMER_LOW, chip->image[CS4231_TIMER_LOW] = (unsigned char) ticks);
624                 snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] | CS4231_TIMER_ENABLE);
625         }
626         spin_unlock_irqrestore(&chip->reg_lock, flags);
627         return 0;
628 }
629
630 static int snd_cs4231_timer_stop(struct snd_timer * timer)
631 {
632         unsigned long flags;
633         struct snd_cs4231 *chip = snd_timer_chip(timer);
634         spin_lock_irqsave(&chip->reg_lock, flags);
635         snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1] &= ~CS4231_TIMER_ENABLE);
636         spin_unlock_irqrestore(&chip->reg_lock, flags);
637         return 0;
638 }
639
640 static void snd_cs4231_init(struct snd_cs4231 *chip)
641 {
642         unsigned long flags;
643
644         snd_cs4231_mce_down(chip);
645
646 #ifdef SNDRV_DEBUG_MCE
647         snd_printk("init: (1)\n");
648 #endif
649         snd_cs4231_mce_up(chip);
650         spin_lock_irqsave(&chip->reg_lock, flags);
651         chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO |
652                              CS4231_RECORD_ENABLE | CS4231_RECORD_PIO |
653                              CS4231_CALIB_MODE);
654         chip->image[CS4231_IFACE_CTRL] |= CS4231_AUTOCALIB;
655         snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
656         spin_unlock_irqrestore(&chip->reg_lock, flags);
657         snd_cs4231_mce_down(chip);
658
659 #ifdef SNDRV_DEBUG_MCE
660         snd_printk("init: (2)\n");
661 #endif
662
663         snd_cs4231_mce_up(chip);
664         spin_lock_irqsave(&chip->reg_lock, flags);
665         snd_cs4231_out(chip, CS4231_ALT_FEATURE_1, chip->image[CS4231_ALT_FEATURE_1]);
666         spin_unlock_irqrestore(&chip->reg_lock, flags);
667         snd_cs4231_mce_down(chip);
668
669 #ifdef SNDRV_DEBUG_MCE
670         snd_printk("init: (3) - afei = 0x%x\n", chip->image[CS4231_ALT_FEATURE_1]);
671 #endif
672
673         spin_lock_irqsave(&chip->reg_lock, flags);
674         snd_cs4231_out(chip, CS4231_ALT_FEATURE_2, chip->image[CS4231_ALT_FEATURE_2]);
675         spin_unlock_irqrestore(&chip->reg_lock, flags);
676
677         snd_cs4231_mce_up(chip);
678         spin_lock_irqsave(&chip->reg_lock, flags);
679         snd_cs4231_out(chip, CS4231_PLAYBK_FORMAT, chip->image[CS4231_PLAYBK_FORMAT]);
680         spin_unlock_irqrestore(&chip->reg_lock, flags);
681         snd_cs4231_mce_down(chip);
682
683 #ifdef SNDRV_DEBUG_MCE
684         snd_printk("init: (4)\n");
685 #endif
686
687         snd_cs4231_mce_up(chip);
688         spin_lock_irqsave(&chip->reg_lock, flags);
689         snd_cs4231_out(chip, CS4231_REC_FORMAT, chip->image[CS4231_REC_FORMAT]);
690         spin_unlock_irqrestore(&chip->reg_lock, flags);
691         snd_cs4231_mce_down(chip);
692
693 #ifdef SNDRV_DEBUG_MCE
694         snd_printk("init: (5)\n");
695 #endif
696 }
697
698 static int snd_cs4231_open(struct snd_cs4231 *chip, unsigned int mode)
699 {
700         unsigned long flags;
701
702         mutex_lock(&chip->open_mutex);
703         if ((chip->mode & mode) ||
704             ((chip->mode & CS4231_MODE_OPEN) && chip->single_dma)) {
705                 mutex_unlock(&chip->open_mutex);
706                 return -EAGAIN;
707         }
708         if (chip->mode & CS4231_MODE_OPEN) {
709                 chip->mode |= mode;
710                 mutex_unlock(&chip->open_mutex);
711                 return 0;
712         }
713         /* ok. now enable and ack CODEC IRQ */
714         spin_lock_irqsave(&chip->reg_lock, flags);
715         snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ |
716                        CS4231_RECORD_IRQ |
717                        CS4231_TIMER_IRQ);
718         snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
719         cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
720         cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
721         chip->image[CS4231_PIN_CTRL] |= CS4231_IRQ_ENABLE;
722         snd_cs4231_out(chip, CS4231_PIN_CTRL, chip->image[CS4231_PIN_CTRL]);
723         snd_cs4231_out(chip, CS4231_IRQ_STATUS, CS4231_PLAYBACK_IRQ |
724                        CS4231_RECORD_IRQ |
725                        CS4231_TIMER_IRQ);
726         snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
727         spin_unlock_irqrestore(&chip->reg_lock, flags);
728
729         chip->mode = mode;
730         mutex_unlock(&chip->open_mutex);
731         return 0;
732 }
733
734 static void snd_cs4231_close(struct snd_cs4231 *chip, unsigned int mode)
735 {
736         unsigned long flags;
737
738         mutex_lock(&chip->open_mutex);
739         chip->mode &= ~mode;
740         if (chip->mode & CS4231_MODE_OPEN) {
741                 mutex_unlock(&chip->open_mutex);
742                 return;
743         }
744         snd_cs4231_calibrate_mute(chip, 1);
745
746         /* disable IRQ */
747         spin_lock_irqsave(&chip->reg_lock, flags);
748         snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
749         cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
750         cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
751         chip->image[CS4231_PIN_CTRL] &= ~CS4231_IRQ_ENABLE;
752         snd_cs4231_out(chip, CS4231_PIN_CTRL, chip->image[CS4231_PIN_CTRL]);
753
754         /* now disable record & playback */
755
756         if (chip->image[CS4231_IFACE_CTRL] & (CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO |
757                                                CS4231_RECORD_ENABLE | CS4231_RECORD_PIO)) {
758                 spin_unlock_irqrestore(&chip->reg_lock, flags);
759                 snd_cs4231_mce_up(chip);
760                 spin_lock_irqsave(&chip->reg_lock, flags);
761                 chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO |
762                                                      CS4231_RECORD_ENABLE | CS4231_RECORD_PIO);
763                 snd_cs4231_out(chip, CS4231_IFACE_CTRL, chip->image[CS4231_IFACE_CTRL]);
764                 spin_unlock_irqrestore(&chip->reg_lock, flags);
765                 snd_cs4231_mce_down(chip);
766                 spin_lock_irqsave(&chip->reg_lock, flags);
767         }
768
769         /* clear IRQ again */
770         snd_cs4231_out(chip, CS4231_IRQ_STATUS, 0);
771         cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
772         cs4231_outb(chip, CS4231P(STATUS), 0);  /* clear IRQ */
773         spin_unlock_irqrestore(&chip->reg_lock, flags);
774
775         snd_cs4231_calibrate_mute(chip, 0);
776
777         chip->mode = 0;
778         mutex_unlock(&chip->open_mutex);
779 }
780
781 /*
782  *  timer open/close
783  */
784
785 static int snd_cs4231_timer_open(struct snd_timer * timer)
786 {
787         struct snd_cs4231 *chip = snd_timer_chip(timer);
788         snd_cs4231_open(chip, CS4231_MODE_TIMER);
789         return 0;
790 }
791
792 static int snd_cs4231_timer_close(struct snd_timer * timer)
793 {
794         struct snd_cs4231 *chip = snd_timer_chip(timer);
795         snd_cs4231_close(chip, CS4231_MODE_TIMER);
796         return 0;
797 }
798
799 static struct snd_timer_hardware snd_cs4231_timer_table =
800 {
801         .flags =        SNDRV_TIMER_HW_AUTO,
802         .resolution =   9945,
803         .ticks =        65535,
804         .open =         snd_cs4231_timer_open,
805         .close =        snd_cs4231_timer_close,
806         .c_resolution = snd_cs4231_timer_resolution,
807         .start =        snd_cs4231_timer_start,
808         .stop =         snd_cs4231_timer_stop,
809 };
810
811 /*
812  *  ok.. exported functions..
813  */
814
815 static int snd_cs4231_playback_hw_params(struct snd_pcm_substream *substream,
816                                          struct snd_pcm_hw_params *hw_params)
817 {
818         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
819         unsigned char new_pdfr;
820         int err;
821
822         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
823                 return err;
824         new_pdfr = snd_cs4231_get_format(chip, params_format(hw_params), params_channels(hw_params)) |
825                    snd_cs4231_get_rate(params_rate(hw_params));
826         chip->set_playback_format(chip, hw_params, new_pdfr);
827         return 0;
828 }
829
830 static int snd_cs4231_playback_hw_free(struct snd_pcm_substream *substream)
831 {
832         return snd_pcm_lib_free_pages(substream);
833 }
834
835 static int snd_cs4231_playback_prepare(struct snd_pcm_substream *substream)
836 {
837         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
838         struct snd_pcm_runtime *runtime = substream->runtime;
839         unsigned long flags;
840         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
841         unsigned int count = snd_pcm_lib_period_bytes(substream);
842
843         spin_lock_irqsave(&chip->reg_lock, flags);
844         chip->p_dma_size = size;
845         chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_PLAYBACK_ENABLE | CS4231_PLAYBACK_PIO);
846         snd_dma_program(chip->dma1, runtime->dma_addr, size, DMA_MODE_WRITE | DMA_AUTOINIT);
847         count = snd_cs4231_get_count(chip->image[CS4231_PLAYBK_FORMAT], count) - 1;
848         snd_cs4231_out(chip, CS4231_PLY_LWR_CNT, (unsigned char) count);
849         snd_cs4231_out(chip, CS4231_PLY_UPR_CNT, (unsigned char) (count >> 8));
850         spin_unlock_irqrestore(&chip->reg_lock, flags);
851 #if 0
852         snd_cs4231_debug(chip);
853 #endif
854         return 0;
855 }
856
857 static int snd_cs4231_capture_hw_params(struct snd_pcm_substream *substream,
858                                         struct snd_pcm_hw_params *hw_params)
859 {
860         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
861         unsigned char new_cdfr;
862         int err;
863
864         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
865                 return err;
866         new_cdfr = snd_cs4231_get_format(chip, params_format(hw_params), params_channels(hw_params)) |
867                    snd_cs4231_get_rate(params_rate(hw_params));
868         chip->set_capture_format(chip, hw_params, new_cdfr);
869         return 0;
870 }
871
872 static int snd_cs4231_capture_hw_free(struct snd_pcm_substream *substream)
873 {
874         return snd_pcm_lib_free_pages(substream);
875 }
876
877 static int snd_cs4231_capture_prepare(struct snd_pcm_substream *substream)
878 {
879         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
880         struct snd_pcm_runtime *runtime = substream->runtime;
881         unsigned long flags;
882         unsigned int size = snd_pcm_lib_buffer_bytes(substream);
883         unsigned int count = snd_pcm_lib_period_bytes(substream);
884
885         spin_lock_irqsave(&chip->reg_lock, flags);
886         chip->c_dma_size = size;
887         chip->image[CS4231_IFACE_CTRL] &= ~(CS4231_RECORD_ENABLE | CS4231_RECORD_PIO);
888         snd_dma_program(chip->dma2, runtime->dma_addr, size, DMA_MODE_READ | DMA_AUTOINIT);
889         count = snd_cs4231_get_count(chip->image[CS4231_REC_FORMAT], count) - 1;
890         if (chip->single_dma && chip->hardware != CS4231_HW_INTERWAVE) {
891                 snd_cs4231_out(chip, CS4231_PLY_LWR_CNT, (unsigned char) count);
892                 snd_cs4231_out(chip, CS4231_PLY_UPR_CNT, (unsigned char) (count >> 8));
893         } else {
894                 snd_cs4231_out(chip, CS4231_REC_LWR_CNT, (unsigned char) count);
895                 snd_cs4231_out(chip, CS4231_REC_UPR_CNT, (unsigned char) (count >> 8));
896         }
897         spin_unlock_irqrestore(&chip->reg_lock, flags);
898         return 0;
899 }
900
901 static void snd_cs4231_overrange(struct snd_cs4231 *chip)
902 {
903         unsigned long flags;
904         unsigned char res;
905
906         spin_lock_irqsave(&chip->reg_lock, flags);
907         res = snd_cs4231_in(chip, CS4231_TEST_INIT);
908         spin_unlock_irqrestore(&chip->reg_lock, flags);
909         if (res & (0x08 | 0x02))        /* detect overrange only above 0dB; may be user selectable? */
910                 chip->capture_substream->runtime->overrange++;
911 }
912
913 irqreturn_t snd_cs4231_interrupt(int irq, void *dev_id)
914 {
915         struct snd_cs4231 *chip = dev_id;
916         unsigned char status;
917
918         status = snd_cs4231_in(chip, CS4231_IRQ_STATUS);
919         if (status & CS4231_TIMER_IRQ) {
920                 if (chip->timer)
921                         snd_timer_interrupt(chip->timer, chip->timer->sticks);
922         }               
923         if (chip->single_dma && chip->hardware != CS4231_HW_INTERWAVE) {
924                 if (status & CS4231_PLAYBACK_IRQ) {
925                         if (chip->mode & CS4231_MODE_PLAY) {
926                                 if (chip->playback_substream)
927                                         snd_pcm_period_elapsed(chip->playback_substream);
928                         }
929                         if (chip->mode & CS4231_MODE_RECORD) {
930                                 if (chip->capture_substream) {
931                                         snd_cs4231_overrange(chip);
932                                         snd_pcm_period_elapsed(chip->capture_substream);
933                                 }
934                         }
935                 }
936         } else {
937                 if (status & CS4231_PLAYBACK_IRQ) {
938                         if (chip->playback_substream)
939                                 snd_pcm_period_elapsed(chip->playback_substream);
940                 }
941                 if (status & CS4231_RECORD_IRQ) {
942                         if (chip->capture_substream) {
943                                 snd_cs4231_overrange(chip);
944                                 snd_pcm_period_elapsed(chip->capture_substream);
945                         }
946                 }
947         }
948
949         spin_lock(&chip->reg_lock);
950         snd_cs4231_outm(chip, CS4231_IRQ_STATUS, ~CS4231_ALL_IRQS | ~status, 0);
951         spin_unlock(&chip->reg_lock);
952         return IRQ_HANDLED;
953 }
954
955 static snd_pcm_uframes_t snd_cs4231_playback_pointer(struct snd_pcm_substream *substream)
956 {
957         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
958         size_t ptr;
959
960         if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_PLAYBACK_ENABLE))
961                 return 0;
962         ptr = snd_dma_pointer(chip->dma1, chip->p_dma_size);
963         return bytes_to_frames(substream->runtime, ptr);
964 }
965
966 static snd_pcm_uframes_t snd_cs4231_capture_pointer(struct snd_pcm_substream *substream)
967 {
968         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
969         size_t ptr;
970         
971         if (!(chip->image[CS4231_IFACE_CTRL] & CS4231_RECORD_ENABLE))
972                 return 0;
973         ptr = snd_dma_pointer(chip->dma2, chip->c_dma_size);
974         return bytes_to_frames(substream->runtime, ptr);
975 }
976
977 /*
978
979  */
980
981 static int snd_cs4231_probe(struct snd_cs4231 *chip)
982 {
983         unsigned long flags;
984         int i, id, rev;
985         unsigned char *ptr;
986         unsigned int hw;
987
988 #if 0
989         snd_cs4231_debug(chip);
990 #endif
991         id = 0;
992         for (i = 0; i < 50; i++) {
993                 mb();
994                 if (cs4231_inb(chip, CS4231P(REGSEL)) & CS4231_INIT)
995                         udelay(2000);
996                 else {
997                         spin_lock_irqsave(&chip->reg_lock, flags);
998                         snd_cs4231_out(chip, CS4231_MISC_INFO, CS4231_MODE2);
999                         id = snd_cs4231_in(chip, CS4231_MISC_INFO) & 0x0f;
1000                         spin_unlock_irqrestore(&chip->reg_lock, flags);
1001                         if (id == 0x0a)
1002                                 break;  /* this is valid value */
1003                 }
1004         }
1005         snd_printdd("cs4231: port = 0x%lx, id = 0x%x\n", chip->port, id);
1006         if (id != 0x0a)
1007                 return -ENODEV; /* no valid device found */
1008
1009         if (((hw = chip->hardware) & CS4231_HW_TYPE_MASK) == CS4231_HW_DETECT) {
1010                 rev = snd_cs4231_in(chip, CS4231_VERSION) & 0xe7;
1011                 snd_printdd("CS4231: VERSION (I25) = 0x%x\n", rev);
1012                 if (rev == 0x80) {
1013                         unsigned char tmp = snd_cs4231_in(chip, 23);
1014                         snd_cs4231_out(chip, 23, ~tmp);
1015                         if (snd_cs4231_in(chip, 23) != tmp)
1016                                 chip->hardware = CS4231_HW_AD1845;
1017                         else
1018                                 chip->hardware = CS4231_HW_CS4231;
1019                 } else if (rev == 0xa0) {
1020                         chip->hardware = CS4231_HW_CS4231A;
1021                 } else if (rev == 0xa2) {
1022                         chip->hardware = CS4231_HW_CS4232;
1023                 } else if (rev == 0xb2) {
1024                         chip->hardware = CS4231_HW_CS4232A;
1025                 } else if (rev == 0x83) {
1026                         chip->hardware = CS4231_HW_CS4236;
1027                 } else if (rev == 0x03) {
1028                         chip->hardware = CS4231_HW_CS4236B;
1029                 } else {
1030                         snd_printk("unknown CS chip with version 0x%x\n", rev);
1031                         return -ENODEV;         /* unknown CS4231 chip? */
1032                 }
1033         }
1034         spin_lock_irqsave(&chip->reg_lock, flags);
1035         cs4231_inb(chip, CS4231P(STATUS));      /* clear any pendings IRQ */
1036         cs4231_outb(chip, CS4231P(STATUS), 0);
1037         mb();
1038         spin_unlock_irqrestore(&chip->reg_lock, flags);
1039
1040         chip->image[CS4231_MISC_INFO] = CS4231_MODE2;
1041         switch (chip->hardware) {
1042         case CS4231_HW_INTERWAVE:
1043                 chip->image[CS4231_MISC_INFO] = CS4231_IW_MODE3;
1044                 break;
1045         case CS4231_HW_CS4235:
1046         case CS4231_HW_CS4236B:
1047         case CS4231_HW_CS4237B:
1048         case CS4231_HW_CS4238B:
1049         case CS4231_HW_CS4239:
1050                 if (hw == CS4231_HW_DETECT3)
1051                         chip->image[CS4231_MISC_INFO] = CS4231_4236_MODE3;
1052                 else
1053                         chip->hardware = CS4231_HW_CS4236;
1054                 break;
1055         }
1056
1057         chip->image[CS4231_IFACE_CTRL] =
1058             (chip->image[CS4231_IFACE_CTRL] & ~CS4231_SINGLE_DMA) |
1059             (chip->single_dma ? CS4231_SINGLE_DMA : 0);
1060         chip->image[CS4231_ALT_FEATURE_1] = 0x80;
1061         chip->image[CS4231_ALT_FEATURE_2] = chip->hardware == CS4231_HW_INTERWAVE ? 0xc2 : 0x01;
1062         ptr = (unsigned char *) &chip->image;
1063         snd_cs4231_mce_down(chip);
1064         spin_lock_irqsave(&chip->reg_lock, flags);
1065         for (i = 0; i < 32; i++)        /* ok.. fill all CS4231 registers */
1066                 snd_cs4231_out(chip, i, *ptr++);
1067         spin_unlock_irqrestore(&chip->reg_lock, flags);
1068         snd_cs4231_mce_up(chip);
1069         snd_cs4231_mce_down(chip);
1070
1071         mdelay(2);
1072
1073         /* ok.. try check hardware version for CS4236+ chips */
1074         if ((hw & CS4231_HW_TYPE_MASK) == CS4231_HW_DETECT) {
1075                 if (chip->hardware == CS4231_HW_CS4236B) {
1076                         rev = snd_cs4236_ext_in(chip, CS4236_VERSION);
1077                         snd_cs4236_ext_out(chip, CS4236_VERSION, 0xff);
1078                         id = snd_cs4236_ext_in(chip, CS4236_VERSION);
1079                         snd_cs4236_ext_out(chip, CS4236_VERSION, rev);
1080                         snd_printdd("CS4231: ext version; rev = 0x%x, id = 0x%x\n", rev, id);
1081                         if ((id & 0x1f) == 0x1d) {      /* CS4235 */
1082                                 chip->hardware = CS4231_HW_CS4235;
1083                                 switch (id >> 5) {
1084                                 case 4:
1085                                 case 5:
1086                                 case 6:
1087                                         break;
1088                                 default:
1089                                         snd_printk("unknown CS4235 chip (enhanced version = 0x%x)\n", id);
1090                                 }
1091                         } else if ((id & 0x1f) == 0x0b) {       /* CS4236/B */
1092                                 switch (id >> 5) {
1093                                 case 4:
1094                                 case 5:
1095                                 case 6:
1096                                 case 7:
1097                                         chip->hardware = CS4231_HW_CS4236B;
1098                                         break;
1099                                 default:
1100                                         snd_printk("unknown CS4236 chip (enhanced version = 0x%x)\n", id);
1101                                 }
1102                         } else if ((id & 0x1f) == 0x08) {       /* CS4237B */
1103                                 chip->hardware = CS4231_HW_CS4237B;
1104                                 switch (id >> 5) {
1105                                 case 4:
1106                                 case 5:
1107                                 case 6:
1108                                 case 7:
1109                                         break;
1110                                 default:
1111                                         snd_printk("unknown CS4237B chip (enhanced version = 0x%x)\n", id);
1112                                 }
1113                         } else if ((id & 0x1f) == 0x09) {       /* CS4238B */
1114                                 chip->hardware = CS4231_HW_CS4238B;
1115                                 switch (id >> 5) {
1116                                 case 5:
1117                                 case 6:
1118                                 case 7:
1119                                         break;
1120                                 default:
1121                                         snd_printk("unknown CS4238B chip (enhanced version = 0x%x)\n", id);
1122                                 }
1123                         } else if ((id & 0x1f) == 0x1e) {       /* CS4239 */
1124                                 chip->hardware = CS4231_HW_CS4239;
1125                                 switch (id >> 5) {
1126                                 case 4:
1127                                 case 5:
1128                                 case 6:
1129                                         break;
1130                                 default:
1131                                         snd_printk("unknown CS4239 chip (enhanced version = 0x%x)\n", id);
1132                                 }
1133                         } else {
1134                                 snd_printk("unknown CS4236/CS423xB chip (enhanced version = 0x%x)\n", id);
1135                         }
1136                 }
1137         }
1138         return 0;               /* all things are ok.. */
1139 }
1140
1141 /*
1142
1143  */
1144
1145 static struct snd_pcm_hardware snd_cs4231_playback =
1146 {
1147         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1148                                  SNDRV_PCM_INFO_MMAP_VALID |
1149                                  SNDRV_PCM_INFO_RESUME |
1150                                  SNDRV_PCM_INFO_SYNC_START),
1151         .formats =              (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM |
1152                                  SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE),
1153         .rates =                SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000,
1154         .rate_min =             5510,
1155         .rate_max =             48000,
1156         .channels_min =         1,
1157         .channels_max =         2,
1158         .buffer_bytes_max =     (128*1024),
1159         .period_bytes_min =     64,
1160         .period_bytes_max =     (128*1024),
1161         .periods_min =          1,
1162         .periods_max =          1024,
1163         .fifo_size =            0,
1164 };
1165
1166 static struct snd_pcm_hardware snd_cs4231_capture =
1167 {
1168         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
1169                                  SNDRV_PCM_INFO_MMAP_VALID |
1170                                  SNDRV_PCM_INFO_RESUME |
1171                                  SNDRV_PCM_INFO_SYNC_START),
1172         .formats =              (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW | SNDRV_PCM_FMTBIT_IMA_ADPCM |
1173                                  SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE),
1174         .rates =                SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_8000_48000,
1175         .rate_min =             5510,
1176         .rate_max =             48000,
1177         .channels_min =         1,
1178         .channels_max =         2,
1179         .buffer_bytes_max =     (128*1024),
1180         .period_bytes_min =     64,
1181         .period_bytes_max =     (128*1024),
1182         .periods_min =          1,
1183         .periods_max =          1024,
1184         .fifo_size =            0,
1185 };
1186
1187 /*
1188
1189  */
1190
1191 static int snd_cs4231_playback_open(struct snd_pcm_substream *substream)
1192 {
1193         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1194         struct snd_pcm_runtime *runtime = substream->runtime;
1195         int err;
1196
1197         runtime->hw = snd_cs4231_playback;
1198
1199         /* hardware bug in InterWave chipset */
1200         if (chip->hardware == CS4231_HW_INTERWAVE && chip->dma1 > 3)
1201                 runtime->hw.formats &= ~SNDRV_PCM_FMTBIT_MU_LAW;
1202         
1203         /* hardware limitation of cheap chips */
1204         if (chip->hardware == CS4231_HW_CS4235 ||
1205             chip->hardware == CS4231_HW_CS4239)
1206                 runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE;
1207
1208         snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.buffer_bytes_max);
1209         snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.period_bytes_max);
1210
1211         if (chip->claim_dma) {
1212                 if ((err = chip->claim_dma(chip, chip->dma_private_data, chip->dma1)) < 0)
1213                         return err;
1214         }
1215
1216         if ((err = snd_cs4231_open(chip, CS4231_MODE_PLAY)) < 0) {
1217                 if (chip->release_dma)
1218                         chip->release_dma(chip, chip->dma_private_data, chip->dma1);
1219                 snd_free_pages(runtime->dma_area, runtime->dma_bytes);
1220                 return err;
1221         }
1222         chip->playback_substream = substream;
1223         snd_pcm_set_sync(substream);
1224         chip->rate_constraint(runtime);
1225         return 0;
1226 }
1227
1228 static int snd_cs4231_capture_open(struct snd_pcm_substream *substream)
1229 {
1230         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1231         struct snd_pcm_runtime *runtime = substream->runtime;
1232         int err;
1233
1234         runtime->hw = snd_cs4231_capture;
1235
1236         /* hardware limitation of cheap chips */
1237         if (chip->hardware == CS4231_HW_CS4235 ||
1238             chip->hardware == CS4231_HW_CS4239)
1239                 runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE;
1240
1241         snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.buffer_bytes_max);
1242         snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.period_bytes_max);
1243
1244         if (chip->claim_dma) {
1245                 if ((err = chip->claim_dma(chip, chip->dma_private_data, chip->dma2)) < 0)
1246                         return err;
1247         }
1248
1249         if ((err = snd_cs4231_open(chip, CS4231_MODE_RECORD)) < 0) {
1250                 if (chip->release_dma)
1251                         chip->release_dma(chip, chip->dma_private_data, chip->dma2);
1252                 snd_free_pages(runtime->dma_area, runtime->dma_bytes);
1253                 return err;
1254         }
1255         chip->capture_substream = substream;
1256         snd_pcm_set_sync(substream);
1257         chip->rate_constraint(runtime);
1258         return 0;
1259 }
1260
1261 static int snd_cs4231_playback_close(struct snd_pcm_substream *substream)
1262 {
1263         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1264
1265         chip->playback_substream = NULL;
1266         snd_cs4231_close(chip, CS4231_MODE_PLAY);
1267         return 0;
1268 }
1269
1270 static int snd_cs4231_capture_close(struct snd_pcm_substream *substream)
1271 {
1272         struct snd_cs4231 *chip = snd_pcm_substream_chip(substream);
1273
1274         chip->capture_substream = NULL;
1275         snd_cs4231_close(chip, CS4231_MODE_RECORD);
1276         return 0;
1277 }
1278
1279 #ifdef CONFIG_PM
1280
1281 /* lowlevel suspend callback for CS4231 */
1282 static void snd_cs4231_suspend(struct snd_cs4231 *chip)
1283 {
1284         int reg;
1285         unsigned long flags;
1286         
1287         snd_pcm_suspend_all(chip->pcm);
1288         spin_lock_irqsave(&chip->reg_lock, flags);
1289         for (reg = 0; reg < 32; reg++)
1290                 chip->image[reg] = snd_cs4231_in(chip, reg);
1291         spin_unlock_irqrestore(&chip->reg_lock, flags);
1292 }
1293
1294 /* lowlevel resume callback for CS4231 */
1295 static void snd_cs4231_resume(struct snd_cs4231 *chip)
1296 {
1297         int reg;
1298         unsigned long flags;
1299         /* int timeout; */
1300         
1301         snd_cs4231_mce_up(chip);
1302         spin_lock_irqsave(&chip->reg_lock, flags);
1303         for (reg = 0; reg < 32; reg++) {
1304                 switch (reg) {
1305                 case CS4231_VERSION:
1306                         break;
1307                 default:
1308                         snd_cs4231_out(chip, reg, chip->image[reg]);
1309                         break;
1310                 }
1311         }
1312         spin_unlock_irqrestore(&chip->reg_lock, flags);
1313 #if 1
1314         snd_cs4231_mce_down(chip);
1315 #else
1316         /* The following is a workaround to avoid freeze after resume on TP600E.
1317            This is the first half of copy of snd_cs4231_mce_down(), but doesn't
1318            include rescheduling.  -- iwai
1319            */
1320         snd_cs4231_busy_wait(chip);
1321         spin_lock_irqsave(&chip->reg_lock, flags);
1322         chip->mce_bit &= ~CS4231_MCE;
1323         timeout = cs4231_inb(chip, CS4231P(REGSEL));
1324         cs4231_outb(chip, CS4231P(REGSEL), chip->mce_bit | (timeout & 0x1f));
1325         spin_unlock_irqrestore(&chip->reg_lock, flags);
1326         if (timeout == 0x80)
1327                 snd_printk("down [0x%lx]: serious init problem - codec still busy\n", chip->port);
1328         if ((timeout & CS4231_MCE) == 0 ||
1329             !(chip->hardware & (CS4231_HW_CS4231_MASK | CS4231_HW_CS4232_MASK))) {
1330                 return;
1331         }
1332         snd_cs4231_busy_wait(chip);
1333 #endif
1334 }
1335 #endif /* CONFIG_PM */
1336
1337 static int snd_cs4231_free(struct snd_cs4231 *chip)
1338 {
1339         release_and_free_resource(chip->res_port);
1340         release_and_free_resource(chip->res_cport);
1341         if (chip->irq >= 0) {
1342                 disable_irq(chip->irq);
1343                 if (!(chip->hwshare & CS4231_HWSHARE_IRQ))
1344                         free_irq(chip->irq, (void *) chip);
1345         }
1346         if (!(chip->hwshare & CS4231_HWSHARE_DMA1) && chip->dma1 >= 0) {
1347                 snd_dma_disable(chip->dma1);
1348                 free_dma(chip->dma1);
1349         }
1350         if (!(chip->hwshare & CS4231_HWSHARE_DMA2) && chip->dma2 >= 0 && chip->dma2 != chip->dma1) {
1351                 snd_dma_disable(chip->dma2);
1352                 free_dma(chip->dma2);
1353         }
1354         if (chip->timer)
1355                 snd_device_free(chip->card, chip->timer);
1356         kfree(chip);
1357         return 0;
1358 }
1359
1360 static int snd_cs4231_dev_free(struct snd_device *device)
1361 {
1362         struct snd_cs4231 *chip = device->device_data;
1363         return snd_cs4231_free(chip);   
1364 }
1365
1366 const char *snd_cs4231_chip_id(struct snd_cs4231 *chip)
1367 {
1368         switch (chip->hardware) {
1369         case CS4231_HW_CS4231:  return "CS4231";
1370         case CS4231_HW_CS4231A: return "CS4231A";
1371         case CS4231_HW_CS4232:  return "CS4232";
1372         case CS4231_HW_CS4232A: return "CS4232A";
1373         case CS4231_HW_CS4235:  return "CS4235";
1374         case CS4231_HW_CS4236:  return "CS4236";
1375         case CS4231_HW_CS4236B: return "CS4236B";
1376         case CS4231_HW_CS4237B: return "CS4237B";
1377         case CS4231_HW_CS4238B: return "CS4238B";
1378         case CS4231_HW_CS4239:  return "CS4239";
1379         case CS4231_HW_INTERWAVE: return "AMD InterWave";
1380         case CS4231_HW_OPL3SA2: return chip->card->shortname;
1381         case CS4231_HW_AD1845: return "AD1845";
1382         default: return "???";
1383         }
1384 }
1385
1386 static int snd_cs4231_new(struct snd_card *card,
1387                           unsigned short hardware,
1388                           unsigned short hwshare,
1389                           struct snd_cs4231 ** rchip)
1390 {
1391         struct snd_cs4231 *chip;
1392
1393         *rchip = NULL;
1394         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1395         if (chip == NULL)
1396                 return -ENOMEM;
1397         chip->hardware = hardware;
1398         chip->hwshare = hwshare;
1399
1400         spin_lock_init(&chip->reg_lock);
1401         mutex_init(&chip->mce_mutex);
1402         mutex_init(&chip->open_mutex);
1403         chip->card = card;
1404         chip->rate_constraint = snd_cs4231_xrate;
1405         chip->set_playback_format = snd_cs4231_playback_format;
1406         chip->set_capture_format = snd_cs4231_capture_format;
1407         memcpy(&chip->image, &snd_cs4231_original_image, sizeof(snd_cs4231_original_image));
1408         
1409         *rchip = chip;
1410         return 0;
1411 }
1412
1413 int snd_cs4231_create(struct snd_card *card,
1414                       unsigned long port,
1415                       unsigned long cport,
1416                       int irq, int dma1, int dma2,
1417                       unsigned short hardware,
1418                       unsigned short hwshare,
1419                       struct snd_cs4231 ** rchip)
1420 {
1421         static struct snd_device_ops ops = {
1422                 .dev_free =     snd_cs4231_dev_free,
1423         };
1424         struct snd_cs4231 *chip;
1425         int err;
1426
1427         err = snd_cs4231_new(card, hardware, hwshare, &chip);
1428         if (err < 0)
1429                 return err;
1430         
1431         chip->irq = -1;
1432         chip->dma1 = -1;
1433         chip->dma2 = -1;
1434
1435         if ((chip->res_port = request_region(port, 4, "CS4231")) == NULL) {
1436                 snd_printk(KERN_ERR "cs4231: can't grab port 0x%lx\n", port);
1437                 snd_cs4231_free(chip);
1438                 return -EBUSY;
1439         }
1440         chip->port = port;
1441         if ((long)cport >= 0 && (chip->res_cport = request_region(cport, 8, "CS4232 Control")) == NULL) {
1442                 snd_printk(KERN_ERR "cs4231: can't grab control port 0x%lx\n", cport);
1443                 snd_cs4231_free(chip);
1444                 return -ENODEV;
1445         }
1446         chip->cport = cport;
1447         if (!(hwshare & CS4231_HWSHARE_IRQ) && request_irq(irq, snd_cs4231_interrupt, IRQF_DISABLED, "CS4231", (void *) chip)) {
1448                 snd_printk(KERN_ERR "cs4231: can't grab IRQ %d\n", irq);
1449                 snd_cs4231_free(chip);
1450                 return -EBUSY;
1451         }
1452         chip->irq = irq;
1453         if (!(hwshare & CS4231_HWSHARE_DMA1) && request_dma(dma1, "CS4231 - 1")) {
1454                 snd_printk(KERN_ERR "cs4231: can't grab DMA1 %d\n", dma1);
1455                 snd_cs4231_free(chip);
1456                 return -EBUSY;
1457         }
1458         chip->dma1 = dma1;
1459         if (!(hwshare & CS4231_HWSHARE_DMA2) && dma1 != dma2 && dma2 >= 0 && request_dma(dma2, "CS4231 - 2")) {
1460                 snd_printk(KERN_ERR "cs4231: can't grab DMA2 %d\n", dma2);
1461                 snd_cs4231_free(chip);
1462                 return -EBUSY;
1463         }
1464         if (dma1 == dma2 || dma2 < 0) {
1465                 chip->single_dma = 1;
1466                 chip->dma2 = chip->dma1;
1467         } else
1468                 chip->dma2 = dma2;
1469
1470         /* global setup */
1471         if (snd_cs4231_probe(chip) < 0) {
1472                 snd_cs4231_free(chip);
1473                 return -ENODEV;
1474         }
1475         snd_cs4231_init(chip);
1476
1477 #if 0
1478         if (chip->hardware & CS4231_HW_CS4232_MASK) {
1479                 if (chip->res_cport == NULL)
1480                         snd_printk("CS4232 control port features are not accessible\n");
1481         }
1482 #endif
1483
1484         /* Register device */
1485         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1486                 snd_cs4231_free(chip);
1487                 return err;
1488         }
1489
1490 #ifdef CONFIG_PM
1491         /* Power Management */
1492         chip->suspend = snd_cs4231_suspend;
1493         chip->resume = snd_cs4231_resume;
1494 #endif
1495
1496         *rchip = chip;
1497         return 0;
1498 }
1499
1500 static struct snd_pcm_ops snd_cs4231_playback_ops = {
1501         .open =         snd_cs4231_playback_open,
1502         .close =        snd_cs4231_playback_close,
1503         .ioctl =        snd_pcm_lib_ioctl,
1504         .hw_params =    snd_cs4231_playback_hw_params,
1505         .hw_free =      snd_cs4231_playback_hw_free,
1506         .prepare =      snd_cs4231_playback_prepare,
1507         .trigger =      snd_cs4231_trigger,
1508         .pointer =      snd_cs4231_playback_pointer,
1509 };
1510
1511 static struct snd_pcm_ops snd_cs4231_capture_ops = {
1512         .open =         snd_cs4231_capture_open,
1513         .close =        snd_cs4231_capture_close,
1514         .ioctl =        snd_pcm_lib_ioctl,
1515         .hw_params =    snd_cs4231_capture_hw_params,
1516         .hw_free =      snd_cs4231_capture_hw_free,
1517         .prepare =      snd_cs4231_capture_prepare,
1518         .trigger =      snd_cs4231_trigger,
1519         .pointer =      snd_cs4231_capture_pointer,
1520 };
1521
1522 int snd_cs4231_pcm(struct snd_cs4231 *chip, int device, struct snd_pcm **rpcm)
1523 {
1524         struct snd_pcm *pcm;
1525         int err;
1526
1527         if ((err = snd_pcm_new(chip->card, "CS4231", device, 1, 1, &pcm)) < 0)
1528                 return err;
1529
1530         spin_lock_init(&chip->reg_lock);
1531         mutex_init(&chip->mce_mutex);
1532         mutex_init(&chip->open_mutex);
1533
1534         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_cs4231_playback_ops);
1535         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cs4231_capture_ops);
1536         
1537         /* global setup */
1538         pcm->private_data = chip;
1539         pcm->info_flags = 0;
1540         if (chip->single_dma)
1541                 pcm->info_flags |= SNDRV_PCM_INFO_HALF_DUPLEX;
1542         if (chip->hardware != CS4231_HW_INTERWAVE)
1543                 pcm->info_flags |= SNDRV_PCM_INFO_JOINT_DUPLEX;
1544         strcpy(pcm->name, snd_cs4231_chip_id(chip));
1545
1546         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1547                                               snd_dma_isa_data(),
1548                                               64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
1549
1550         chip->pcm = pcm;
1551         if (rpcm)
1552                 *rpcm = pcm;
1553         return 0;
1554 }
1555
1556 static void snd_cs4231_timer_free(struct snd_timer *timer)
1557 {
1558         struct snd_cs4231 *chip = timer->private_data;
1559         chip->timer = NULL;
1560 }
1561
1562 int snd_cs4231_timer(struct snd_cs4231 *chip, int device, struct snd_timer **rtimer)
1563 {
1564         struct snd_timer *timer;
1565         struct snd_timer_id tid;
1566         int err;
1567
1568         /* Timer initialization */
1569         tid.dev_class = SNDRV_TIMER_CLASS_CARD;
1570         tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1571         tid.card = chip->card->number;
1572         tid.device = device;
1573         tid.subdevice = 0;
1574         if ((err = snd_timer_new(chip->card, "CS4231", &tid, &timer)) < 0)
1575                 return err;
1576         strcpy(timer->name, snd_cs4231_chip_id(chip));
1577         timer->private_data = chip;
1578         timer->private_free = snd_cs4231_timer_free;
1579         timer->hw = snd_cs4231_timer_table;
1580         chip->timer = timer;
1581         if (rtimer)
1582                 *rtimer = timer;
1583         return 0;
1584 }
1585         
1586 /*
1587  *  MIXER part
1588  */
1589
1590 static int snd_cs4231_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1591 {
1592         static char *texts[4] = {
1593                 "Line", "Aux", "Mic", "Mix"
1594         };
1595         static char *opl3sa_texts[4] = {
1596                 "Line", "CD", "Mic", "Mix"
1597         };
1598         static char *gusmax_texts[4] = {
1599                 "Line", "Synth", "Mic", "Mix"
1600         };
1601         char **ptexts = texts;
1602         struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1603
1604         snd_assert(chip->card != NULL, return -EINVAL);
1605         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1606         uinfo->count = 2;
1607         uinfo->value.enumerated.items = 4;
1608         if (uinfo->value.enumerated.item > 3)
1609                 uinfo->value.enumerated.item = 3;
1610         if (!strcmp(chip->card->driver, "GUS MAX"))
1611                 ptexts = gusmax_texts;
1612         switch (chip->hardware) {
1613         case CS4231_HW_INTERWAVE: ptexts = gusmax_texts; break;
1614         case CS4231_HW_OPL3SA2: ptexts = opl3sa_texts; break;
1615         }
1616         strcpy(uinfo->value.enumerated.name, ptexts[uinfo->value.enumerated.item]);
1617         return 0;
1618 }
1619
1620 static int snd_cs4231_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1621 {
1622         struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1623         unsigned long flags;
1624         
1625         spin_lock_irqsave(&chip->reg_lock, flags);
1626         ucontrol->value.enumerated.item[0] = (chip->image[CS4231_LEFT_INPUT] & CS4231_MIXS_ALL) >> 6;
1627         ucontrol->value.enumerated.item[1] = (chip->image[CS4231_RIGHT_INPUT] & CS4231_MIXS_ALL) >> 6;
1628         spin_unlock_irqrestore(&chip->reg_lock, flags);
1629         return 0;
1630 }
1631
1632 static int snd_cs4231_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1633 {
1634         struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1635         unsigned long flags;
1636         unsigned short left, right;
1637         int change;
1638         
1639         if (ucontrol->value.enumerated.item[0] > 3 ||
1640             ucontrol->value.enumerated.item[1] > 3)
1641                 return -EINVAL;
1642         left = ucontrol->value.enumerated.item[0] << 6;
1643         right = ucontrol->value.enumerated.item[1] << 6;
1644         spin_lock_irqsave(&chip->reg_lock, flags);
1645         left = (chip->image[CS4231_LEFT_INPUT] & ~CS4231_MIXS_ALL) | left;
1646         right = (chip->image[CS4231_RIGHT_INPUT] & ~CS4231_MIXS_ALL) | right;
1647         change = left != chip->image[CS4231_LEFT_INPUT] ||
1648                  right != chip->image[CS4231_RIGHT_INPUT];
1649         snd_cs4231_out(chip, CS4231_LEFT_INPUT, left);
1650         snd_cs4231_out(chip, CS4231_RIGHT_INPUT, right);
1651         spin_unlock_irqrestore(&chip->reg_lock, flags);
1652         return change;
1653 }
1654
1655 int snd_cs4231_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1656 {
1657         int mask = (kcontrol->private_value >> 16) & 0xff;
1658
1659         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1660         uinfo->count = 1;
1661         uinfo->value.integer.min = 0;
1662         uinfo->value.integer.max = mask;
1663         return 0;
1664 }
1665
1666 int snd_cs4231_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1667 {
1668         struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1669         unsigned long flags;
1670         int reg = kcontrol->private_value & 0xff;
1671         int shift = (kcontrol->private_value >> 8) & 0xff;
1672         int mask = (kcontrol->private_value >> 16) & 0xff;
1673         int invert = (kcontrol->private_value >> 24) & 0xff;
1674         
1675         spin_lock_irqsave(&chip->reg_lock, flags);
1676         ucontrol->value.integer.value[0] = (chip->image[reg] >> shift) & mask;
1677         spin_unlock_irqrestore(&chip->reg_lock, flags);
1678         if (invert)
1679                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1680         return 0;
1681 }
1682
1683 int snd_cs4231_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1684 {
1685         struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1686         unsigned long flags;
1687         int reg = kcontrol->private_value & 0xff;
1688         int shift = (kcontrol->private_value >> 8) & 0xff;
1689         int mask = (kcontrol->private_value >> 16) & 0xff;
1690         int invert = (kcontrol->private_value >> 24) & 0xff;
1691         int change;
1692         unsigned short val;
1693         
1694         val = (ucontrol->value.integer.value[0] & mask);
1695         if (invert)
1696                 val = mask - val;
1697         val <<= shift;
1698         spin_lock_irqsave(&chip->reg_lock, flags);
1699         val = (chip->image[reg] & ~(mask << shift)) | val;
1700         change = val != chip->image[reg];
1701         snd_cs4231_out(chip, reg, val);
1702         spin_unlock_irqrestore(&chip->reg_lock, flags);
1703         return change;
1704 }
1705
1706 int snd_cs4231_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1707 {
1708         int mask = (kcontrol->private_value >> 24) & 0xff;
1709
1710         uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
1711         uinfo->count = 2;
1712         uinfo->value.integer.min = 0;
1713         uinfo->value.integer.max = mask;
1714         return 0;
1715 }
1716
1717 int snd_cs4231_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1718 {
1719         struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1720         unsigned long flags;
1721         int left_reg = kcontrol->private_value & 0xff;
1722         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1723         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1724         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1725         int mask = (kcontrol->private_value >> 24) & 0xff;
1726         int invert = (kcontrol->private_value >> 22) & 1;
1727         
1728         spin_lock_irqsave(&chip->reg_lock, flags);
1729         ucontrol->value.integer.value[0] = (chip->image[left_reg] >> shift_left) & mask;
1730         ucontrol->value.integer.value[1] = (chip->image[right_reg] >> shift_right) & mask;
1731         spin_unlock_irqrestore(&chip->reg_lock, flags);
1732         if (invert) {
1733                 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
1734                 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
1735         }
1736         return 0;
1737 }
1738
1739 int snd_cs4231_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1740 {
1741         struct snd_cs4231 *chip = snd_kcontrol_chip(kcontrol);
1742         unsigned long flags;
1743         int left_reg = kcontrol->private_value & 0xff;
1744         int right_reg = (kcontrol->private_value >> 8) & 0xff;
1745         int shift_left = (kcontrol->private_value >> 16) & 0x07;
1746         int shift_right = (kcontrol->private_value >> 19) & 0x07;
1747         int mask = (kcontrol->private_value >> 24) & 0xff;
1748         int invert = (kcontrol->private_value >> 22) & 1;
1749         int change;
1750         unsigned short val1, val2;
1751         
1752         val1 = ucontrol->value.integer.value[0] & mask;
1753         val2 = ucontrol->value.integer.value[1] & mask;
1754         if (invert) {
1755                 val1 = mask - val1;
1756                 val2 = mask - val2;
1757         }
1758         val1 <<= shift_left;
1759         val2 <<= shift_right;
1760         spin_lock_irqsave(&chip->reg_lock, flags);
1761         val1 = (chip->image[left_reg] & ~(mask << shift_left)) | val1;
1762         val2 = (chip->image[right_reg] & ~(mask << shift_right)) | val2;
1763         change = val1 != chip->image[left_reg] || val2 != chip->image[right_reg];
1764         snd_cs4231_out(chip, left_reg, val1);
1765         snd_cs4231_out(chip, right_reg, val2);
1766         spin_unlock_irqrestore(&chip->reg_lock, flags);
1767         return change;
1768 }
1769
1770 static struct snd_kcontrol_new snd_cs4231_controls[] = {
1771 CS4231_DOUBLE("PCM Playback Switch", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 7, 7, 1, 1),
1772 CS4231_DOUBLE("PCM Playback Volume", 0, CS4231_LEFT_OUTPUT, CS4231_RIGHT_OUTPUT, 0, 0, 63, 1),
1773 CS4231_DOUBLE("Line Playback Switch", 0, CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 7, 7, 1, 1),
1774 CS4231_DOUBLE("Line Playback Volume", 0, CS4231_LEFT_LINE_IN, CS4231_RIGHT_LINE_IN, 0, 0, 31, 1),
1775 CS4231_DOUBLE("Aux Playback Switch", 0, CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 7, 7, 1, 1),
1776 CS4231_DOUBLE("Aux Playback Volume", 0, CS4231_AUX1_LEFT_INPUT, CS4231_AUX1_RIGHT_INPUT, 0, 0, 31, 1),
1777 CS4231_DOUBLE("Aux Playback Switch", 1, CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 7, 7, 1, 1),
1778 CS4231_DOUBLE("Aux Playback Volume", 1, CS4231_AUX2_LEFT_INPUT, CS4231_AUX2_RIGHT_INPUT, 0, 0, 31, 1),
1779 CS4231_SINGLE("Mono Playback Switch", 0, CS4231_MONO_CTRL, 7, 1, 1),
1780 CS4231_SINGLE("Mono Playback Volume", 0, CS4231_MONO_CTRL, 0, 15, 1),
1781 CS4231_SINGLE("Mono Output Playback Switch", 0, CS4231_MONO_CTRL, 6, 1, 1),
1782 CS4231_SINGLE("Mono Output Playback Bypass", 0, CS4231_MONO_CTRL, 5, 1, 0),
1783 CS4231_DOUBLE("Capture Volume", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 0, 0, 15, 0),
1784 {
1785         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1786         .name = "Capture Source",
1787         .info = snd_cs4231_info_mux,
1788         .get = snd_cs4231_get_mux,
1789         .put = snd_cs4231_put_mux,
1790 },
1791 CS4231_DOUBLE("Mic Boost", 0, CS4231_LEFT_INPUT, CS4231_RIGHT_INPUT, 5, 5, 1, 0),
1792 CS4231_SINGLE("Loopback Capture Switch", 0, CS4231_LOOPBACK, 0, 1, 0),
1793 CS4231_SINGLE("Loopback Capture Volume", 0, CS4231_LOOPBACK, 2, 63, 1)
1794 };
1795                                         
1796 int snd_cs4231_mixer(struct snd_cs4231 *chip)
1797 {
1798         struct snd_card *card;
1799         unsigned int idx;
1800         int err;
1801
1802         snd_assert(chip != NULL && chip->pcm != NULL, return -EINVAL);
1803
1804         card = chip->card;
1805
1806         strcpy(card->mixername, chip->pcm->name);
1807
1808         for (idx = 0; idx < ARRAY_SIZE(snd_cs4231_controls); idx++) {
1809                 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_cs4231_controls[idx], chip))) < 0)
1810                         return err;
1811         }
1812         return 0;
1813 }
1814
1815 EXPORT_SYMBOL(snd_cs4231_out);
1816 EXPORT_SYMBOL(snd_cs4231_in);
1817 EXPORT_SYMBOL(snd_cs4236_ext_out);
1818 EXPORT_SYMBOL(snd_cs4236_ext_in);
1819 EXPORT_SYMBOL(snd_cs4231_mce_up);
1820 EXPORT_SYMBOL(snd_cs4231_mce_down);
1821 EXPORT_SYMBOL(snd_cs4231_interrupt);
1822 EXPORT_SYMBOL(snd_cs4231_chip_id);
1823 EXPORT_SYMBOL(snd_cs4231_create);
1824 EXPORT_SYMBOL(snd_cs4231_pcm);
1825 EXPORT_SYMBOL(snd_cs4231_mixer);
1826 EXPORT_SYMBOL(snd_cs4231_timer);
1827 EXPORT_SYMBOL(snd_cs4231_info_single);
1828 EXPORT_SYMBOL(snd_cs4231_get_single);
1829 EXPORT_SYMBOL(snd_cs4231_put_single);
1830 EXPORT_SYMBOL(snd_cs4231_info_double);
1831 EXPORT_SYMBOL(snd_cs4231_get_double);
1832 EXPORT_SYMBOL(snd_cs4231_put_double);
1833
1834 /*
1835  *  INIT part
1836  */
1837
1838 static int __init alsa_cs4231_init(void)
1839 {
1840         return 0;
1841 }
1842
1843 static void __exit alsa_cs4231_exit(void)
1844 {
1845 }
1846
1847 module_init(alsa_cs4231_init)
1848 module_exit(alsa_cs4231_exit)