?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
xen: xenfs: privcmd: check put_user() return code
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / sound / oss / ad1848.c
blob4d2a6ae978f720baa57faa391b665b060018da47
1 /*
2 * sound/oss/ad1848.c
3 *
4 * The low level driver for the AD1848/CS4248 codec chip which
5 * is used for example in the MS Sound System.
6 *
7 * The CS4231 which is used in the GUS MAX and some other cards is
8 * upwards compatible with AD1848 and this driver is able to drive it.
9 *
10 * CS4231A and AD1845 are upward compatible with CS4231. However
11 * the new features of these chips are different.
12 *
13 * CS4232 is a PnP audio chip which contains a CS4231A (and SB, MPU).
14 * CS4232A is an improved version of CS4232.
15 *
16 *
17 *
18 * Copyright (C) by Hannu Savolainen 1993-1997
19 *
20 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
21 * Version 2 (June 1991). See the "COPYING" file distributed with this software
22 * for more info.
23 *
24 *
25 * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
26 * general sleep/wakeup clean up.
27 * Alan Cox : reformatted. Fixed SMP bugs. Moved to kernel alloc/free
28 * of irqs. Use dev_id.
29 * Christoph Hellwig : adapted to module_init/module_exit
30 * Aki Laukkanen : added power management support
31 * Arnaldo C. de Melo : added missing restore_flags in ad1848_resume
32 * Miguel Freitas : added ISA PnP support
33 * Alan Cox : Added CS4236->4239 identification
34 * Daniel T. Cobra : Alernate config/mixer for later chips
35 * Alan Cox : Merged chip idents and config code
36 *
37 * TODO
38 * APM save restore assist code on IBM thinkpad
39 *
40 * Status:
41 * Tested. Believed fully functional.
42 */
43
44 #include <linux/init.h>
45 #include <linux/interrupt.h>
46 #include <linux/module.h>
47 #include <linux/stddef.h>
48 #include <linux/slab.h>
49 #include <linux/isapnp.h>
50 #include <linux/pnp.h>
51 #include <linux/spinlock.h>
52
53 #define DEB(x)
54 #define DEB1(x)
55 #include "sound_config.h"
56
57 #include "ad1848.h"
58 #include "ad1848_mixer.h"
59
60 typedef struct
61 {
62 spinlock_t lock;
63 int base;
64 int irq;
65 int dma1, dma2;
66 int dual_dma; /* 1, when two DMA channels allocated */
67 int subtype;
68 unsigned char MCE_bit;
69 unsigned char saved_regs[64]; /* Includes extended register space */
70 int debug_flag;
71
72 int audio_flags;
73 int record_dev, playback_dev;
74
75 int xfer_count;
76 int audio_mode;
77 int open_mode;
78 int intr_active;
79 char *chip_name, *name;
80 int model;
81 #define MD_1848 1
82 #define MD_4231 2
83 #define MD_4231A 3
84 #define MD_1845 4
85 #define MD_4232 5
86 #define MD_C930 6
87 #define MD_IWAVE 7
88 #define MD_4235 8 /* Crystal Audio CS4235 */
89 #define MD_1845_SSCAPE 9 /* Ensoniq Soundscape PNP*/
90 #define MD_4236 10 /* 4236 and higher */
91 #define MD_42xB 11 /* CS 42xB */
92 #define MD_4239 12 /* CS4239 */
93
94 /* Mixer parameters */
95 int recmask;
96 int supported_devices, orig_devices;
97 int supported_rec_devices, orig_rec_devices;
98 int *levels;
99 short mixer_reroute[32];
100 int dev_no;
101 volatile unsigned long timer_ticks;
102 int timer_running;
103 int irq_ok;
104 mixer_ents *mix_devices;
105 int mixer_output_port;
106 } ad1848_info;
107
108 typedef struct ad1848_port_info
109 {
110 int open_mode;
111 int speed;
112 unsigned char speed_bits;
113 int channels;
114 int audio_format;
115 unsigned char format_bits;
116 }
117 ad1848_port_info;
118
119 static struct address_info cfg;
120 static int nr_ad1848_devs;
121
122 static int deskpro_xl;
123 static int deskpro_m;
124 static int soundpro;
125
126 static volatile signed char irq2dev[17] = {
127 -1, -1, -1, -1, -1, -1, -1, -1,
128 -1, -1, -1, -1, -1, -1, -1, -1, -1
129 };
130
131 #ifndef EXCLUDE_TIMERS
132 static int timer_installed = -1;
133 #endif
134
135 static int loaded;
136
137 static int ad_format_mask[13 /*devc->model */ ] =
138 {
139 0,
140 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW,
141 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW | AFMT_S16_BE | AFMT_IMA_ADPCM,
142 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW | AFMT_S16_BE | AFMT_IMA_ADPCM,
143 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW, /* AD1845 */
144 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW | AFMT_S16_BE | AFMT_IMA_ADPCM,
145 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW | AFMT_S16_BE | AFMT_IMA_ADPCM,
146 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW | AFMT_S16_BE | AFMT_IMA_ADPCM,
147 AFMT_U8 | AFMT_S16_LE /* CS4235 */,
148 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW /* Ensoniq Soundscape*/,
149 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW | AFMT_S16_BE | AFMT_IMA_ADPCM,
150 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW | AFMT_S16_BE | AFMT_IMA_ADPCM,
151 AFMT_U8 | AFMT_S16_LE | AFMT_MU_LAW | AFMT_A_LAW | AFMT_S16_BE | AFMT_IMA_ADPCM
152 };
153
154 static ad1848_info adev_info[MAX_AUDIO_DEV];
155
156 #define io_Index_Addr(d) ((d)->base)
157 #define io_Indexed_Data(d) ((d)->base+1)
158 #define io_Status(d) ((d)->base+2)
159 #define io_Polled_IO(d) ((d)->base+3)
160
161 static struct {
162 unsigned char flags;
163 #define CAP_F_TIMER 0x01
164 } capabilities [10 /*devc->model */ ] = {
165 {0}
166 ,{0} /* MD_1848 */
167 ,{CAP_F_TIMER} /* MD_4231 */
168 ,{CAP_F_TIMER} /* MD_4231A */
169 ,{CAP_F_TIMER} /* MD_1845 */
170 ,{CAP_F_TIMER} /* MD_4232 */
171 ,{0} /* MD_C930 */
172 ,{CAP_F_TIMER} /* MD_IWAVE */
173 ,{0} /* MD_4235 */
174 ,{CAP_F_TIMER} /* MD_1845_SSCAPE */
175 };
176
177 #ifdef CONFIG_PNP
178 static int isapnp = 1;
179 static int isapnpjump;
180 static int reverse;
181
182 static int audio_activated;
183 #else
184 static int isapnp;
185 #endif
186
187
188
189 static int ad1848_open(int dev, int mode);
190 static void ad1848_close(int dev);
191 static void ad1848_output_block(int dev, unsigned long buf, int count, int intrflag);
192 static void ad1848_start_input(int dev, unsigned long buf, int count, int intrflag);
193 static int ad1848_prepare_for_output(int dev, int bsize, int bcount);
194 static int ad1848_prepare_for_input(int dev, int bsize, int bcount);
195 static void ad1848_halt(int dev);
196 static void ad1848_halt_input(int dev);
197 static void ad1848_halt_output(int dev);
198 static void ad1848_trigger(int dev, int bits);
199 static irqreturn_t adintr(int irq, void *dev_id);
200
201 #ifndef EXCLUDE_TIMERS
202 static int ad1848_tmr_install(int dev);
203 static void ad1848_tmr_reprogram(int dev);
204 #endif
205
206 static int ad_read(ad1848_info * devc, int reg)
207 {
208 int x;
209 int timeout = 900000;
210
211 while (timeout > 0 && inb(devc->base) == 0x80) /*Are we initializing */
212 timeout--;
213
214 if(reg < 32)
215 {
216 outb(((unsigned char) (reg & 0xff) | devc->MCE_bit), io_Index_Addr(devc));
217 x = inb(io_Indexed_Data(devc));
218 }
219 else
220 {
221 int xreg, xra;
222
223 xreg = (reg & 0xff) - 32;
224 xra = (((xreg & 0x0f) << 4) & 0xf0) | 0x08 | ((xreg & 0x10) >> 2);
225 outb(((unsigned char) (23 & 0xff) | devc->MCE_bit), io_Index_Addr(devc));
226 outb(((unsigned char) (xra & 0xff)), io_Indexed_Data(devc));
227 x = inb(io_Indexed_Data(devc));
228 }
229
230 return x;
231 }
232
233 static void ad_write(ad1848_info * devc, int reg, int data)
234 {
235 int timeout = 900000;
236
237 while (timeout > 0 && inb(devc->base) == 0x80) /* Are we initializing */
238 timeout--;
239
240 if(reg < 32)
241 {
242 outb(((unsigned char) (reg & 0xff) | devc->MCE_bit), io_Index_Addr(devc));
243 outb(((unsigned char) (data & 0xff)), io_Indexed_Data(devc));
244 }
245 else
246 {
247 int xreg, xra;
248
249 xreg = (reg & 0xff) - 32;
250 xra = (((xreg & 0x0f) << 4) & 0xf0) | 0x08 | ((xreg & 0x10) >> 2);
251 outb(((unsigned char) (23 & 0xff) | devc->MCE_bit), io_Index_Addr(devc));
252 outb(((unsigned char) (xra & 0xff)), io_Indexed_Data(devc));
253 outb((unsigned char) (data & 0xff), io_Indexed_Data(devc));
254 }
255 }
256
257 static void wait_for_calibration(ad1848_info * devc)
258 {
259 int timeout = 0;
260
261 /*
262 * Wait until the auto calibration process has finished.
263 *
264 * 1) Wait until the chip becomes ready (reads don't return 0x80).
265 * 2) Wait until the ACI bit of I11 gets on and then off.
266 */
267
268 timeout = 100000;
269 while (timeout > 0 && inb(devc->base) == 0x80)
270 timeout--;
271 if (inb(devc->base) & 0x80)
272 printk(KERN_WARNING "ad1848: Auto calibration timed out(1).\n");
273
274 timeout = 100;
275 while (timeout > 0 && !(ad_read(devc, 11) & 0x20))
276 timeout--;
277 if (!(ad_read(devc, 11) & 0x20))
278 return;
279
280 timeout = 80000;
281 while (timeout > 0 && (ad_read(devc, 11) & 0x20))
282 timeout--;
283 if (ad_read(devc, 11) & 0x20)
284 if ((devc->model != MD_1845) && (devc->model != MD_1845_SSCAPE))
285 printk(KERN_WARNING "ad1848: Auto calibration timed out(3).\n");
286 }
287
288 static void ad_mute(ad1848_info * devc)
289 {
290 int i;
291 unsigned char prev;
292
293 /*
294 * Save old register settings and mute output channels
295 */
296
297 for (i = 6; i < 8; i++)
298 {
299 prev = devc->saved_regs[i] = ad_read(devc, i);
300 }
301
302 }
303
304 static void ad_unmute(ad1848_info * devc)
305 {
306 }
307
308 static void ad_enter_MCE(ad1848_info * devc)
309 {
310 int timeout = 1000;
311 unsigned short prev;
312
313 while (timeout > 0 && inb(devc->base) == 0x80) /*Are we initializing */
314 timeout--;
315
316 devc->MCE_bit = 0x40;
317 prev = inb(io_Index_Addr(devc));
318 if (prev & 0x40)
319 {
320 return;
321 }
322 outb((devc->MCE_bit), io_Index_Addr(devc));
323 }
324
325 static void ad_leave_MCE(ad1848_info * devc)
326 {
327 unsigned char prev, acal;
328 int timeout = 1000;
329
330 while (timeout > 0 && inb(devc->base) == 0x80) /*Are we initializing */
331 timeout--;
332
333 acal = ad_read(devc, 9);
334
335 devc->MCE_bit = 0x00;
336 prev = inb(io_Index_Addr(devc));
337 outb((0x00), io_Index_Addr(devc)); /* Clear the MCE bit */
338
339 if ((prev & 0x40) == 0) /* Not in MCE mode */
340 {
341 return;
342 }
343 outb((0x00), io_Index_Addr(devc)); /* Clear the MCE bit */
344 if (acal & 0x08) /* Auto calibration is enabled */
345 wait_for_calibration(devc);
346 }
347
348 static int ad1848_set_recmask(ad1848_info * devc, int mask)
349 {
350 unsigned char recdev;
351 int i, n;
352 unsigned long flags;
353
354 mask &= devc->supported_rec_devices;
355
356 /* Rename the mixer bits if necessary */
357 for (i = 0; i < 32; i++)
358 {
359 if (devc->mixer_reroute[i] != i)
360 {
361 if (mask & (1 << i))
362 {
363 mask &= ~(1 << i);
364 mask |= (1 << devc->mixer_reroute[i]);
365 }
366 }
367 }
368
369 n = 0;
370 for (i = 0; i < 32; i++) /* Count selected device bits */
371 if (mask & (1 << i))
372 n++;
373
374 spin_lock_irqsave(&devc->lock,flags);
375 if (!soundpro) {
376 if (n == 0)
377 mask = SOUND_MASK_MIC;
378 else if (n != 1) { /* Too many devices selected */
379 mask &= ~devc->recmask; /* Filter out active settings */
380
381 n = 0;
382 for (i = 0; i < 32; i++) /* Count selected device bits */
383 if (mask & (1 << i))
384 n++;
385
386 if (n != 1)
387 mask = SOUND_MASK_MIC;
388 }
389 switch (mask) {
390 case SOUND_MASK_MIC:
391 recdev = 2;
392 break;
393
394 case SOUND_MASK_LINE:
395 case SOUND_MASK_LINE3:
396 recdev = 0;
397 break;
398
399 case SOUND_MASK_CD:
400 case SOUND_MASK_LINE1:
401 recdev = 1;
402 break;
403
404 case SOUND_MASK_IMIX:
405 recdev = 3;
406 break;
407
408 default:
409 mask = SOUND_MASK_MIC;
410 recdev = 2;
411 }
412
413 recdev <<= 6;
414 ad_write(devc, 0, (ad_read(devc, 0) & 0x3f) | recdev);
415 ad_write(devc, 1, (ad_read(devc, 1) & 0x3f) | recdev);
416 } else { /* soundpro */
417 unsigned char val;
418 int set_rec_bit;
419 int j;
420
421 for (i = 0; i < 32; i++) { /* For each bit */
422 if ((devc->supported_rec_devices & (1 << i)) == 0)
423 continue; /* Device not supported */
424
425 for (j = LEFT_CHN; j <= RIGHT_CHN; j++) {
426 if (devc->mix_devices[i][j].nbits == 0) /* Inexistent channel */
427 continue;
428
429 /*
430 * This is tricky:
431 * set_rec_bit becomes 1 if the corresponding bit in mask is set
432 * then it gets flipped if the polarity is inverse
433 */
434 set_rec_bit = ((mask & (1 << i)) != 0) ^ devc->mix_devices[i][j].recpol;
435
436 val = ad_read(devc, devc->mix_devices[i][j].recreg);
437 val &= ~(1 << devc->mix_devices[i][j].recpos);
438 val |= (set_rec_bit << devc->mix_devices[i][j].recpos);
439 ad_write(devc, devc->mix_devices[i][j].recreg, val);
440 }
441 }
442 }
443 spin_unlock_irqrestore(&devc->lock,flags);
444
445 /* Rename the mixer bits back if necessary */
446 for (i = 0; i < 32; i++)
447 {
448 if (devc->mixer_reroute[i] != i)
449 {
450 if (mask & (1 << devc->mixer_reroute[i]))
451 {
452 mask &= ~(1 << devc->mixer_reroute[i]);
453 mask |= (1 << i);
454 }
455 }
456 }
457 devc->recmask = mask;
458 return mask;
459 }
460
461 static void change_bits(ad1848_info * devc, unsigned char *regval,
462 unsigned char *muteval, int dev, int chn, int newval)
463 {
464 unsigned char mask;
465 int shift;
466 int mute;
467 int mutemask;
468 int set_mute_bit;
469
470 set_mute_bit = (newval == 0) ^ devc->mix_devices[dev][chn].mutepol;
471
472 if (devc->mix_devices[dev][chn].polarity == 1) /* Reverse */
473 newval = 100 - newval;
474
475 mask = (1 << devc->mix_devices[dev][chn].nbits) - 1;
476 shift = devc->mix_devices[dev][chn].bitpos;
477
478 if (devc->mix_devices[dev][chn].mutepos == 8)
479 { /* if there is no mute bit */
480 mute = 0; /* No mute bit; do nothing special */
481 mutemask = ~0; /* No mute bit; do nothing special */
482 }
483 else
484 {
485 mute = (set_mute_bit << devc->mix_devices[dev][chn].mutepos);
486 mutemask = ~(1 << devc->mix_devices[dev][chn].mutepos);
487 }
488
489 newval = (int) ((newval * mask) + 50) / 100; /* Scale it */
490 *regval &= ~(mask << shift); /* Clear bits */
491 *regval |= (newval & mask) << shift; /* Set new value */
492
493 *muteval &= mutemask;
494 *muteval |= mute;
495 }
496
497 static int ad1848_mixer_get(ad1848_info * devc, int dev)
498 {
499 if (!((1 << dev) & devc->supported_devices))
500 return -EINVAL;
501
502 dev = devc->mixer_reroute[dev];
503
504 return devc->levels[dev];
505 }
506
507 static void ad1848_mixer_set_channel(ad1848_info *devc, int dev, int value, int channel)
508 {
509 int regoffs, muteregoffs;
510 unsigned char val, muteval;
511 unsigned long flags;
512
513 regoffs = devc->mix_devices[dev][channel].regno;
514 muteregoffs = devc->mix_devices[dev][channel].mutereg;
515 val = ad_read(devc, regoffs);
516
517 if (muteregoffs != regoffs) {
518 muteval = ad_read(devc, muteregoffs);
519 change_bits(devc, &val, &muteval, dev, channel, value);
520 }
521 else
522 change_bits(devc, &val, &val, dev, channel, value);
523
524 spin_lock_irqsave(&devc->lock,flags);
525 ad_write(devc, regoffs, val);
526 devc->saved_regs[regoffs] = val;
527 if (muteregoffs != regoffs) {
528 ad_write(devc, muteregoffs, muteval);
529 devc->saved_regs[muteregoffs] = muteval;
530 }
531 spin_unlock_irqrestore(&devc->lock,flags);
532 }
533
534 static int ad1848_mixer_set(ad1848_info * devc, int dev, int value)
535 {
536 int left = value & 0x000000ff;
537 int right = (value & 0x0000ff00) >> 8;
538 int retvol;
539
540 if (dev > 31)
541 return -EINVAL;
542
543 if (!(devc->supported_devices & (1 << dev)))
544 return -EINVAL;
545
546 dev = devc->mixer_reroute[dev];
547
548 if (devc->mix_devices[dev][LEFT_CHN].nbits == 0)
549 return -EINVAL;
550
551 if (left > 100)
552 left = 100;
553 if (right > 100)
554 right = 100;
555
556 if (devc->mix_devices[dev][RIGHT_CHN].nbits == 0) /* Mono control */
557 right = left;
558
559 retvol = left | (right << 8);
560
561 /* Scale volumes */
562 left = mix_cvt[left];
563 right = mix_cvt[right];
564
565 devc->levels[dev] = retvol;
566
567 /*
568 * Set the left channel
569 */
570 ad1848_mixer_set_channel(devc, dev, left, LEFT_CHN);
571
572 /*
573 * Set the right channel
574 */
575 if (devc->mix_devices[dev][RIGHT_CHN].nbits == 0)
576 goto out;
577 ad1848_mixer_set_channel(devc, dev, right, RIGHT_CHN);
578
579 out:
580 return retvol;
581 }
582
583 static void ad1848_mixer_reset(ad1848_info * devc)
584 {
585 int i;
586 char name[32];
587 unsigned long flags;
588
589 devc->mix_devices = &(ad1848_mix_devices[0]);
590
591 sprintf(name, "%s_%d", devc->chip_name, nr_ad1848_devs);
592
593 for (i = 0; i < 32; i++)
594 devc->mixer_reroute[i] = i;
595
596 devc->supported_rec_devices = MODE1_REC_DEVICES;
597
598 switch (devc->model)
599 {
600 case MD_4231:
601 case MD_4231A:
602 case MD_1845:
603 case MD_1845_SSCAPE:
604 devc->supported_devices = MODE2_MIXER_DEVICES;
605 break;
606
607 case MD_C930:
608 devc->supported_devices = C930_MIXER_DEVICES;
609 devc->mix_devices = &(c930_mix_devices[0]);
610 break;
611
612 case MD_IWAVE:
613 devc->supported_devices = MODE3_MIXER_DEVICES;
614 devc->mix_devices = &(iwave_mix_devices[0]);
615 break;
616
617 case MD_42xB:
618 case MD_4239:
619 devc->mix_devices = &(cs42xb_mix_devices[0]);
620 devc->supported_devices = MODE3_MIXER_DEVICES;
621 break;
622 case MD_4232:
623 case MD_4235:
624 case MD_4236:
625 devc->supported_devices = MODE3_MIXER_DEVICES;
626 break;
627
628 case MD_1848:
629 if (soundpro) {
630 devc->supported_devices = SPRO_MIXER_DEVICES;
631 devc->supported_rec_devices = SPRO_REC_DEVICES;
632 devc->mix_devices = &(spro_mix_devices[0]);
633 break;
634 }
635
636 default:
637 devc->supported_devices = MODE1_MIXER_DEVICES;
638 }
639
640 devc->orig_devices = devc->supported_devices;
641 devc->orig_rec_devices = devc->supported_rec_devices;
642
643 devc->levels = load_mixer_volumes(name, default_mixer_levels, 1);
644
645 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
646 {
647 if (devc->supported_devices & (1 << i))
648 ad1848_mixer_set(devc, i, devc->levels[i]);
649 }
650
651 ad1848_set_recmask(devc, SOUND_MASK_MIC);
652
653 devc->mixer_output_port = devc->levels[31] | AUDIO_HEADPHONE | AUDIO_LINE_OUT;
654
655 spin_lock_irqsave(&devc->lock,flags);
656 if (!soundpro) {
657 if (devc->mixer_output_port & AUDIO_SPEAKER)
658 ad_write(devc, 26, ad_read(devc, 26) & ~0x40); /* Unmute mono out */
659 else
660 ad_write(devc, 26, ad_read(devc, 26) | 0x40); /* Mute mono out */
661 } else {
662 /*
663 * From the "wouldn't it be nice if the mixer API had (better)
664 * support for custom stuff" category
665 */
666 /* Enable surround mode and SB16 mixer */
667 ad_write(devc, 16, 0x60);
668 }
669 spin_unlock_irqrestore(&devc->lock,flags);
670 }
671
672 static int ad1848_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
673 {
674 ad1848_info *devc = mixer_devs[dev]->devc;
675 int val;
676
677 if (cmd == SOUND_MIXER_PRIVATE1)
678 {
679 if (get_user(val, (int __user *)arg))
680 return -EFAULT;
681
682 if (val != 0xffff)
683 {
684 unsigned long flags;
685 val &= (AUDIO_SPEAKER | AUDIO_HEADPHONE | AUDIO_LINE_OUT);
686 devc->mixer_output_port = val;
687 val |= AUDIO_HEADPHONE | AUDIO_LINE_OUT; /* Always on */
688 devc->mixer_output_port = val;
689 spin_lock_irqsave(&devc->lock,flags);
690 if (val & AUDIO_SPEAKER)
691 ad_write(devc, 26, ad_read(devc, 26) & ~0x40); /* Unmute mono out */
692 else
693 ad_write(devc, 26, ad_read(devc, 26) | 0x40); /* Mute mono out */
694 spin_unlock_irqrestore(&devc->lock,flags);
695 }
696 val = devc->mixer_output_port;
697 return put_user(val, (int __user *)arg);
698 }
699 if (cmd == SOUND_MIXER_PRIVATE2)
700 {
701 if (get_user(val, (int __user *)arg))
702 return -EFAULT;
703 return(ad1848_control(AD1848_MIXER_REROUTE, val));
704 }
705 if (((cmd >> 8) & 0xff) == 'M')
706 {
707 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
708 {
709 switch (cmd & 0xff)
710 {
711 case SOUND_MIXER_RECSRC:
712 if (get_user(val, (int __user *)arg))
713 return -EFAULT;
714 val = ad1848_set_recmask(devc, val);
715 break;
716
717 default:
718 if (get_user(val, (int __user *)arg))
719 return -EFAULT;
720 val = ad1848_mixer_set(devc, cmd & 0xff, val);
721 break;
722 }
723 return put_user(val, (int __user *)arg);
724 }
725 else
726 {
727 switch (cmd & 0xff)
728 {
729 /*
730 * Return parameters
731 */
732
733 case SOUND_MIXER_RECSRC:
734 val = devc->recmask;
735 break;
736
737 case SOUND_MIXER_DEVMASK:
738 val = devc->supported_devices;
739 break;
740
741 case SOUND_MIXER_STEREODEVS:
742 val = devc->supported_devices;
743 if (devc->model != MD_C930)
744 val &= ~(SOUND_MASK_SPEAKER | SOUND_MASK_IMIX);
745 break;
746
747 case SOUND_MIXER_RECMASK:
748 val = devc->supported_rec_devices;
749 break;
750
751 case SOUND_MIXER_CAPS:
752 val=SOUND_CAP_EXCL_INPUT;
753 break;
754
755 default:
756 val = ad1848_mixer_get(devc, cmd & 0xff);
757 break;
758 }
759 return put_user(val, (int __user *)arg);
760 }
761 }
762 else
763 return -EINVAL;
764 }
765
766 static int ad1848_set_speed(int dev, int arg)
767 {
768 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
769 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
770
771 /*
772 * The sampling speed is encoded in the least significant nibble of I8. The
773 * LSB selects the clock source (0=24.576 MHz, 1=16.9344 MHz) and other
774 * three bits select the divisor (indirectly):
775 *
776 * The available speeds are in the following table. Keep the speeds in
777 * the increasing order.
778 */
779 typedef struct
780 {
781 int speed;
782 unsigned char bits;
783 }
784 speed_struct;
785
786 static speed_struct speed_table[] =
787 {
788 {5510, (0 << 1) | 1},
789 {5510, (0 << 1) | 1},
790 {6620, (7 << 1) | 1},
791 {8000, (0 << 1) | 0},
792 {9600, (7 << 1) | 0},
793 {11025, (1 << 1) | 1},
794 {16000, (1 << 1) | 0},
795 {18900, (2 << 1) | 1},
796 {22050, (3 << 1) | 1},
797 {27420, (2 << 1) | 0},
798 {32000, (3 << 1) | 0},
799 {33075, (6 << 1) | 1},
800 {37800, (4 << 1) | 1},
801 {44100, (5 << 1) | 1},
802 {48000, (6 << 1) | 0}
803 };
804
805 int i, n, selected = -1;
806
807 n = sizeof(speed_table) / sizeof(speed_struct);
808
809 if (arg <= 0)
810 return portc->speed;
811
812 if (devc->model == MD_1845 || devc->model == MD_1845_SSCAPE) /* AD1845 has different timer than others */
813 {
814 if (arg < 4000)
815 arg = 4000;
816 if (arg > 50000)
817 arg = 50000;
818
819 portc->speed = arg;
820 portc->speed_bits = speed_table[3].bits;
821 return portc->speed;
822 }
823 if (arg < speed_table[0].speed)
824 selected = 0;
825 if (arg > speed_table[n - 1].speed)
826 selected = n - 1;
827
828 for (i = 1 /*really */ ; selected == -1 && i < n; i++)
829 {
830 if (speed_table[i].speed == arg)
831 selected = i;
832 else if (speed_table[i].speed > arg)
833 {
834 int diff1, diff2;
835
836 diff1 = arg - speed_table[i - 1].speed;
837 diff2 = speed_table[i].speed - arg;
838
839 if (diff1 < diff2)
840 selected = i - 1;
841 else
842 selected = i;
843 }
844 }
845 if (selected == -1)
846 {
847 printk(KERN_WARNING "ad1848: Can't find speed???\n");
848 selected = 3;
849 }
850 portc->speed = speed_table[selected].speed;
851 portc->speed_bits = speed_table[selected].bits;
852 return portc->speed;
853 }
854
855 static short ad1848_set_channels(int dev, short arg)
856 {
857 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
858
859 if (arg != 1 && arg != 2)
860 return portc->channels;
861
862 portc->channels = arg;
863 return arg;
864 }
865
866 static unsigned int ad1848_set_bits(int dev, unsigned int arg)
867 {
868 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
869 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
870
871 static struct format_tbl
872 {
873 int format;
874 unsigned char bits;
875 }
876 format2bits[] =
877 {
878 {
879 0, 0
880 }
881 ,
882 {
883 AFMT_MU_LAW, 1
884 }
885 ,
886 {
887 AFMT_A_LAW, 3
888 }
889 ,
890 {
891 AFMT_IMA_ADPCM, 5
892 }
893 ,
894 {
895 AFMT_U8, 0
896 }
897 ,
898 {
899 AFMT_S16_LE, 2
900 }
901 ,
902 {
903 AFMT_S16_BE, 6
904 }
905 ,
906 {
907 AFMT_S8, 0
908 }
909 ,
910 {
911 AFMT_U16_LE, 0
912 }
913 ,
914 {
915 AFMT_U16_BE, 0
916 }
917 };
918 int i, n = sizeof(format2bits) / sizeof(struct format_tbl);
919
920 if (arg == 0)
921 return portc->audio_format;
922
923 if (!(arg & ad_format_mask[devc->model]))
924 arg = AFMT_U8;
925
926 portc->audio_format = arg;
927
928 for (i = 0; i < n; i++)
929 if (format2bits[i].format == arg)
930 {
931 if ((portc->format_bits = format2bits[i].bits) == 0)
932 return portc->audio_format = AFMT_U8; /* Was not supported */
933
934 return arg;
935 }
936 /* Still hanging here. Something must be terribly wrong */
937 portc->format_bits = 0;
938 return portc->audio_format = AFMT_U8;
939 }
940
941 static struct audio_driver ad1848_audio_driver =
942 {
943 .owner = THIS_MODULE,
944 .open = ad1848_open,
945 .close = ad1848_close,
946 .output_block = ad1848_output_block,
947 .start_input = ad1848_start_input,
948 .prepare_for_input = ad1848_prepare_for_input,
949 .prepare_for_output = ad1848_prepare_for_output,
950 .halt_io = ad1848_halt,
951 .halt_input = ad1848_halt_input,
952 .halt_output = ad1848_halt_output,
953 .trigger = ad1848_trigger,
954 .set_speed = ad1848_set_speed,
955 .set_bits = ad1848_set_bits,
956 .set_channels = ad1848_set_channels
957 };
958
959 static struct mixer_operations ad1848_mixer_operations =
960 {
961 .owner = THIS_MODULE,
962 .id = "SOUNDPORT",
963 .name = "AD1848/CS4248/CS4231",
964 .ioctl = ad1848_mixer_ioctl
965 };
966
967 static int ad1848_open(int dev, int mode)
968 {
969 ad1848_info *devc;
970 ad1848_port_info *portc;
971 unsigned long flags;
972
973 if (dev < 0 || dev >= num_audiodevs)
974 return -ENXIO;
975
976 devc = (ad1848_info *) audio_devs[dev]->devc;
977 portc = (ad1848_port_info *) audio_devs[dev]->portc;
978
979 /* here we don't have to protect against intr */
980 spin_lock(&devc->lock);
981 if (portc->open_mode || (devc->open_mode & mode))
982 {
983 spin_unlock(&devc->lock);
984 return -EBUSY;
985 }
986 devc->dual_dma = 0;
987
988 if (audio_devs[dev]->flags & DMA_DUPLEX)
989 {
990 devc->dual_dma = 1;
991 }
992 devc->intr_active = 0;
993 devc->audio_mode = 0;
994 devc->open_mode |= mode;
995 portc->open_mode = mode;
996 spin_unlock(&devc->lock);
997 ad1848_trigger(dev, 0);
998
999 if (mode & OPEN_READ)
1000 devc->record_dev = dev;
1001 if (mode & OPEN_WRITE)
1002 devc->playback_dev = dev;
1003 /*
1004 * Mute output until the playback really starts. This decreases clicking (hope so).
1005 */
1006 spin_lock_irqsave(&devc->lock,flags);
1007 ad_mute(devc);
1008 spin_unlock_irqrestore(&devc->lock,flags);
1009
1010 return 0;
1011 }
1012
1013 static void ad1848_close(int dev)
1014 {
1015 unsigned long flags;
1016 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1017 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
1018
1019 DEB(printk("ad1848_close(void)\n"));
1020
1021 devc->intr_active = 0;
1022 ad1848_halt(dev);
1023
1024 spin_lock_irqsave(&devc->lock,flags);
1025
1026 devc->audio_mode = 0;
1027 devc->open_mode &= ~portc->open_mode;
1028 portc->open_mode = 0;
1029
1030 ad_unmute(devc);
1031 spin_unlock_irqrestore(&devc->lock,flags);
1032 }
1033
1034 static void ad1848_output_block(int dev, unsigned long buf, int count, int intrflag)
1035 {
1036 unsigned long flags, cnt;
1037 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1038 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
1039
1040 cnt = count;
1041
1042 if (portc->audio_format == AFMT_IMA_ADPCM)
1043 {
1044 cnt /= 4;
1045 }
1046 else
1047 {
1048 if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE)) /* 16 bit data */
1049 cnt >>= 1;
1050 }
1051 if (portc->channels > 1)
1052 cnt >>= 1;
1053 cnt--;
1054
1055 if ((devc->audio_mode & PCM_ENABLE_OUTPUT) && (audio_devs[dev]->flags & DMA_AUTOMODE) &&
1056 intrflag &&
1057 cnt == devc->xfer_count)
1058 {
1059 devc->audio_mode |= PCM_ENABLE_OUTPUT;
1060 devc->intr_active = 1;
1061 return; /*
1062 * Auto DMA mode on. No need to react
1063 */
1064 }
1065 spin_lock_irqsave(&devc->lock,flags);
1066
1067 ad_write(devc, 15, (unsigned char) (cnt & 0xff));
1068 ad_write(devc, 14, (unsigned char) ((cnt >> 8) & 0xff));
1069
1070 devc->xfer_count = cnt;
1071 devc->audio_mode |= PCM_ENABLE_OUTPUT;
1072 devc->intr_active = 1;
1073 spin_unlock_irqrestore(&devc->lock,flags);
1074 }
1075
1076 static void ad1848_start_input(int dev, unsigned long buf, int count, int intrflag)
1077 {
1078 unsigned long flags, cnt;
1079 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1080 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
1081
1082 cnt = count;
1083 if (portc->audio_format == AFMT_IMA_ADPCM)
1084 {
1085 cnt /= 4;
1086 }
1087 else
1088 {
1089 if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE)) /* 16 bit data */
1090 cnt >>= 1;
1091 }
1092 if (portc->channels > 1)
1093 cnt >>= 1;
1094 cnt--;
1095
1096 if ((devc->audio_mode & PCM_ENABLE_INPUT) && (audio_devs[dev]->flags & DMA_AUTOMODE) &&
1097 intrflag &&
1098 cnt == devc->xfer_count)
1099 {
1100 devc->audio_mode |= PCM_ENABLE_INPUT;
1101 devc->intr_active = 1;
1102 return; /*
1103 * Auto DMA mode on. No need to react
1104 */
1105 }
1106 spin_lock_irqsave(&devc->lock,flags);
1107
1108 if (devc->model == MD_1848)
1109 {
1110 ad_write(devc, 15, (unsigned char) (cnt & 0xff));
1111 ad_write(devc, 14, (unsigned char) ((cnt >> 8) & 0xff));
1112 }
1113 else
1114 {
1115 ad_write(devc, 31, (unsigned char) (cnt & 0xff));
1116 ad_write(devc, 30, (unsigned char) ((cnt >> 8) & 0xff));
1117 }
1118
1119 ad_unmute(devc);
1120
1121 devc->xfer_count = cnt;
1122 devc->audio_mode |= PCM_ENABLE_INPUT;
1123 devc->intr_active = 1;
1124 spin_unlock_irqrestore(&devc->lock,flags);
1125 }
1126
1127 static int ad1848_prepare_for_output(int dev, int bsize, int bcount)
1128 {
1129 int timeout;
1130 unsigned char fs, old_fs, tmp = 0;
1131 unsigned long flags;
1132 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1133 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
1134
1135 ad_mute(devc);
1136
1137 spin_lock_irqsave(&devc->lock,flags);
1138 fs = portc->speed_bits | (portc->format_bits << 5);
1139
1140 if (portc->channels > 1)
1141 fs |= 0x10;
1142
1143 ad_enter_MCE(devc); /* Enables changes to the format select reg */
1144
1145 if (devc->model == MD_1845 || devc->model == MD_1845_SSCAPE) /* Use alternate speed select registers */
1146 {
1147 fs &= 0xf0; /* Mask off the rate select bits */
1148
1149 ad_write(devc, 22, (portc->speed >> 8) & 0xff); /* Speed MSB */
1150 ad_write(devc, 23, portc->speed & 0xff); /* Speed LSB */
1151 }
1152 old_fs = ad_read(devc, 8);
1153
1154 if (devc->model == MD_4232 || devc->model >= MD_4236)
1155 {
1156 tmp = ad_read(devc, 16);
1157 ad_write(devc, 16, tmp | 0x30);
1158 }
1159 if (devc->model == MD_IWAVE)
1160 ad_write(devc, 17, 0xc2); /* Disable variable frequency select */
1161
1162 ad_write(devc, 8, fs);
1163
1164 /*
1165 * Write to I8 starts resynchronization. Wait until it completes.
1166 */
1167
1168 timeout = 0;
1169 while (timeout < 100 && inb(devc->base) != 0x80)
1170 timeout++;
1171 timeout = 0;
1172 while (timeout < 10000 && inb(devc->base) == 0x80)
1173 timeout++;
1174
1175 if (devc->model >= MD_4232)
1176 ad_write(devc, 16, tmp & ~0x30);
1177
1178 ad_leave_MCE(devc); /*
1179 * Starts the calibration process.
1180 */
1181 spin_unlock_irqrestore(&devc->lock,flags);
1182 devc->xfer_count = 0;
1183
1184 #ifndef EXCLUDE_TIMERS
1185 if (dev == timer_installed && devc->timer_running)
1186 if ((fs & 0x01) != (old_fs & 0x01))
1187 {
1188 ad1848_tmr_reprogram(dev);
1189 }
1190 #endif
1191 ad1848_halt_output(dev);
1192 return 0;
1193 }
1194
1195 static int ad1848_prepare_for_input(int dev, int bsize, int bcount)
1196 {
1197 int timeout;
1198 unsigned char fs, old_fs, tmp = 0;
1199 unsigned long flags;
1200 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1201 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
1202
1203 if (devc->audio_mode)
1204 return 0;
1205
1206 spin_lock_irqsave(&devc->lock,flags);
1207 fs = portc->speed_bits | (portc->format_bits << 5);
1208
1209 if (portc->channels > 1)
1210 fs |= 0x10;
1211
1212 ad_enter_MCE(devc); /* Enables changes to the format select reg */
1213
1214 if ((devc->model == MD_1845) || (devc->model == MD_1845_SSCAPE)) /* Use alternate speed select registers */
1215 {
1216 fs &= 0xf0; /* Mask off the rate select bits */
1217
1218 ad_write(devc, 22, (portc->speed >> 8) & 0xff); /* Speed MSB */
1219 ad_write(devc, 23, portc->speed & 0xff); /* Speed LSB */
1220 }
1221 if (devc->model == MD_4232)
1222 {
1223 tmp = ad_read(devc, 16);
1224 ad_write(devc, 16, tmp | 0x30);
1225 }
1226 if (devc->model == MD_IWAVE)
1227 ad_write(devc, 17, 0xc2); /* Disable variable frequency select */
1228
1229 /*
1230 * If mode >= 2 (CS4231), set I28. It's the capture format register.
1231 */
1232
1233 if (devc->model != MD_1848)
1234 {
1235 old_fs = ad_read(devc, 28);
1236 ad_write(devc, 28, fs);
1237
1238 /*
1239 * Write to I28 starts resynchronization. Wait until it completes.
1240 */
1241
1242 timeout = 0;
1243 while (timeout < 100 && inb(devc->base) != 0x80)
1244 timeout++;
1245
1246 timeout = 0;
1247 while (timeout < 10000 && inb(devc->base) == 0x80)
1248 timeout++;
1249
1250 if (devc->model != MD_1848 && devc->model != MD_1845 && devc->model != MD_1845_SSCAPE)
1251 {
1252 /*
1253 * CS4231 compatible devices don't have separate sampling rate selection
1254 * register for recording an playback. The I8 register is shared so we have to
1255 * set the speed encoding bits of it too.
1256 */
1257 unsigned char tmp = portc->speed_bits | (ad_read(devc, 8) & 0xf0);
1258
1259 ad_write(devc, 8, tmp);
1260 /*
1261 * Write to I8 starts resynchronization. Wait until it completes.
1262 */
1263 timeout = 0;
1264 while (timeout < 100 && inb(devc->base) != 0x80)
1265 timeout++;
1266
1267 timeout = 0;
1268 while (timeout < 10000 && inb(devc->base) == 0x80)
1269 timeout++;
1270 }
1271 }
1272 else
1273 { /* For AD1848 set I8. */
1274
1275 old_fs = ad_read(devc, 8);
1276 ad_write(devc, 8, fs);
1277 /*
1278 * Write to I8 starts resynchronization. Wait until it completes.
1279 */
1280 timeout = 0;
1281 while (timeout < 100 && inb(devc->base) != 0x80)
1282 timeout++;
1283 timeout = 0;
1284 while (timeout < 10000 && inb(devc->base) == 0x80)
1285 timeout++;
1286 }
1287
1288 if (devc->model == MD_4232)
1289 ad_write(devc, 16, tmp & ~0x30);
1290
1291 ad_leave_MCE(devc); /*
1292 * Starts the calibration process.
1293 */
1294 spin_unlock_irqrestore(&devc->lock,flags);
1295 devc->xfer_count = 0;
1296
1297 #ifndef EXCLUDE_TIMERS
1298 if (dev == timer_installed && devc->timer_running)
1299 {
1300 if ((fs & 0x01) != (old_fs & 0x01))
1301 {
1302 ad1848_tmr_reprogram(dev);
1303 }
1304 }
1305 #endif
1306 ad1848_halt_input(dev);
1307 return 0;
1308 }
1309
1310 static void ad1848_halt(int dev)
1311 {
1312 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1313 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
1314
1315 unsigned char bits = ad_read(devc, 9);
1316
1317 if (bits & 0x01 && (portc->open_mode & OPEN_WRITE))
1318 ad1848_halt_output(dev);
1319
1320 if (bits & 0x02 && (portc->open_mode & OPEN_READ))
1321 ad1848_halt_input(dev);
1322 devc->audio_mode = 0;
1323 }
1324
1325 static void ad1848_halt_input(int dev)
1326 {
1327 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1328 unsigned long flags;
1329
1330 if (!(ad_read(devc, 9) & 0x02))
1331 return; /* Capture not enabled */
1332
1333 spin_lock_irqsave(&devc->lock,flags);
1334
1335 ad_mute(devc);
1336
1337 {
1338 int tmout;
1339
1340 if(!isa_dma_bridge_buggy)
1341 disable_dma(audio_devs[dev]->dmap_in->dma);
1342
1343 for (tmout = 0; tmout < 100000; tmout++)
1344 if (ad_read(devc, 11) & 0x10)
1345 break;
1346 ad_write(devc, 9, ad_read(devc, 9) & ~0x02); /* Stop capture */
1347
1348 if(!isa_dma_bridge_buggy)
1349 enable_dma(audio_devs[dev]->dmap_in->dma);
1350 devc->audio_mode &= ~PCM_ENABLE_INPUT;
1351 }
1352
1353 outb(0, io_Status(devc)); /* Clear interrupt status */
1354 outb(0, io_Status(devc)); /* Clear interrupt status */
1355
1356 devc->audio_mode &= ~PCM_ENABLE_INPUT;
1357
1358 spin_unlock_irqrestore(&devc->lock,flags);
1359 }
1360
1361 static void ad1848_halt_output(int dev)
1362 {
1363 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1364 unsigned long flags;
1365
1366 if (!(ad_read(devc, 9) & 0x01))
1367 return; /* Playback not enabled */
1368
1369 spin_lock_irqsave(&devc->lock,flags);
1370
1371 ad_mute(devc);
1372 {
1373 int tmout;
1374
1375 if(!isa_dma_bridge_buggy)
1376 disable_dma(audio_devs[dev]->dmap_out->dma);
1377
1378 for (tmout = 0; tmout < 100000; tmout++)
1379 if (ad_read(devc, 11) & 0x10)
1380 break;
1381 ad_write(devc, 9, ad_read(devc, 9) & ~0x01); /* Stop playback */
1382
1383 if(!isa_dma_bridge_buggy)
1384 enable_dma(audio_devs[dev]->dmap_out->dma);
1385
1386 devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
1387 }
1388
1389 outb((0), io_Status(devc)); /* Clear interrupt status */
1390 outb((0), io_Status(devc)); /* Clear interrupt status */
1391
1392 devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
1393
1394 spin_unlock_irqrestore(&devc->lock,flags);
1395 }
1396
1397 static void ad1848_trigger(int dev, int state)
1398 {
1399 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
1400 ad1848_port_info *portc = (ad1848_port_info *) audio_devs[dev]->portc;
1401 unsigned long flags;
1402 unsigned char tmp, old;
1403
1404 spin_lock_irqsave(&devc->lock,flags);
1405 state &= devc->audio_mode;
1406
1407 tmp = old = ad_read(devc, 9);
1408
1409 if (portc->open_mode & OPEN_READ)
1410 {
1411 if (state & PCM_ENABLE_INPUT)
1412 tmp |= 0x02;
1413 else
1414 tmp &= ~0x02;
1415 }
1416 if (portc->open_mode & OPEN_WRITE)
1417 {
1418 if (state & PCM_ENABLE_OUTPUT)
1419 tmp |= 0x01;
1420 else
1421 tmp &= ~0x01;
1422 }
1423 /* ad_mute(devc); */
1424 if (tmp != old)
1425 {
1426 ad_write(devc, 9, tmp);
1427 ad_unmute(devc);
1428 }
1429 spin_unlock_irqrestore(&devc->lock,flags);
1430 }
1431
1432 static void ad1848_init_hw(ad1848_info * devc)
1433 {
1434 int i;
1435 int *init_values;
1436
1437 /*
1438 * Initial values for the indirect registers of CS4248/AD1848.
1439 */
1440 static int init_values_a[] =
1441 {
1442 0xa8, 0xa8, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
1443 0x00, 0x0c, 0x02, 0x00, 0x8a, 0x01, 0x00, 0x00,
1444
1445 /* Positions 16 to 31 just for CS4231/2 and ad1845 */
1446 0x80, 0x00, 0x10, 0x10, 0x00, 0x00, 0x1f, 0x40,
1447 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1448 };
1449
1450 static int init_values_b[] =
1451 {
1452 /*
1453 Values for the newer chips
1454 Some of the register initialization values were changed. In
1455 order to get rid of the click that preceded PCM playback,
1456 calibration was disabled on the 10th byte. On that same byte,
1457 dual DMA was enabled; on the 11th byte, ADC dithering was
1458 enabled, since that is theoretically desirable; on the 13th
1459 byte, Mode 3 was selected, to enable access to extended
1460 registers.
1461 */
1462 0xa8, 0xa8, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
1463 0x00, 0x00, 0x06, 0x00, 0xe0, 0x01, 0x00, 0x00,
1464 0x80, 0x00, 0x10, 0x10, 0x00, 0x00, 0x1f, 0x40,
1465 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1466 };
1467
1468 /*
1469 * Select initialisation data
1470 */
1471
1472 init_values = init_values_a;
1473 if(devc->model >= MD_4236)
1474 init_values = init_values_b;
1475
1476 for (i = 0; i < 16; i++)
1477 ad_write(devc, i, init_values[i]);
1478
1479
1480 ad_mute(devc); /* Initialize some variables */
1481 ad_unmute(devc); /* Leave it unmuted now */
1482
1483 if (devc->model > MD_1848)
1484 {
1485 if (devc->model == MD_1845_SSCAPE)
1486 ad_write(devc, 12, ad_read(devc, 12) | 0x50);
1487 else
1488 ad_write(devc, 12, ad_read(devc, 12) | 0x40); /* Mode2 = enabled */
1489
1490 if (devc->model == MD_IWAVE)
1491 ad_write(devc, 12, 0x6c); /* Select codec mode 3 */
1492
1493 if (devc->model != MD_1845_SSCAPE)
1494 for (i = 16; i < 32; i++)
1495 ad_write(devc, i, init_values[i]);
1496
1497 if (devc->model == MD_IWAVE)
1498 ad_write(devc, 16, 0x30); /* Playback and capture counters enabled */
1499 }
1500 if (devc->model > MD_1848)
1501 {
1502 if (devc->audio_flags & DMA_DUPLEX)
1503 ad_write(devc, 9, ad_read(devc, 9) & ~0x04); /* Dual DMA mode */
1504 else
1505 ad_write(devc, 9, ad_read(devc, 9) | 0x04); /* Single DMA mode */
1506
1507 if (devc->model == MD_1845 || devc->model == MD_1845_SSCAPE)
1508 ad_write(devc, 27, ad_read(devc, 27) | 0x08); /* Alternate freq select enabled */
1509
1510 if (devc->model == MD_IWAVE)
1511 { /* Some magic Interwave specific initialization */
1512 ad_write(devc, 12, 0x6c); /* Select codec mode 3 */
1513 ad_write(devc, 16, 0x30); /* Playback and capture counters enabled */
1514 ad_write(devc, 17, 0xc2); /* Alternate feature enable */
1515 }
1516 }
1517 else
1518 {
1519 devc->audio_flags &= ~DMA_DUPLEX;
1520 ad_write(devc, 9, ad_read(devc, 9) | 0x04); /* Single DMA mode */
1521 if (soundpro)
1522 ad_write(devc, 12, ad_read(devc, 12) | 0x40); /* Mode2 = enabled */
1523 }
1524
1525 outb((0), io_Status(devc)); /* Clear pending interrupts */
1526
1527 /*
1528 * Toggle the MCE bit. It completes the initialization phase.
1529 */
1530
1531 ad_enter_MCE(devc); /* In case the bit was off */
1532 ad_leave_MCE(devc);
1533
1534 ad1848_mixer_reset(devc);
1535 }
1536
1537 int ad1848_detect(struct resource *ports, int *ad_flags, int *osp)
1538 {
1539 unsigned char tmp;
1540 ad1848_info *devc = &adev_info[nr_ad1848_devs];
1541 unsigned char tmp1 = 0xff, tmp2 = 0xff;
1542 int optiC930 = 0; /* OPTi 82C930 flag */
1543 int interwave = 0;
1544 int ad1847_flag = 0;
1545 int cs4248_flag = 0;
1546 int sscape_flag = 0;
1547 int io_base = ports->start;
1548
1549 int i;
1550
1551 DDB(printk("ad1848_detect(%x)\n", io_base));
1552
1553 if (ad_flags)
1554 {
1555 if (*ad_flags == 0x12345678)
1556 {
1557 interwave = 1;
1558 *ad_flags = 0;
1559 }
1560
1561 if (*ad_flags == 0x87654321)
1562 {
1563 sscape_flag = 1;
1564 *ad_flags = 0;
1565 }
1566
1567 if (*ad_flags == 0x12345677)
1568 {
1569 cs4248_flag = 1;
1570 *ad_flags = 0;
1571 }
1572 }
1573 if (nr_ad1848_devs >= MAX_AUDIO_DEV)
1574 {
1575 printk(KERN_ERR "ad1848 - Too many audio devices\n");
1576 return 0;
1577 }
1578 spin_lock_init(&devc->lock);
1579 devc->base = io_base;
1580 devc->irq_ok = 0;
1581 devc->timer_running = 0;
1582 devc->MCE_bit = 0x40;
1583 devc->irq = 0;
1584 devc->open_mode = 0;
1585 devc->chip_name = devc->name = "AD1848";
1586 devc->model = MD_1848; /* AD1848 or CS4248 */
1587 devc->levels = NULL;
1588 devc->debug_flag = 0;
1589
1590 /*
1591 * Check that the I/O address is in use.
1592 *
1593 * The bit 0x80 of the base I/O port is known to be 0 after the
1594 * chip has performed its power on initialization. Just assume
1595 * this has happened before the OS is starting.
1596 *
1597 * If the I/O address is unused, it typically returns 0xff.
1598 */
1599
1600 if (inb(devc->base) == 0xff)
1601 {
1602 DDB(printk("ad1848_detect: The base I/O address appears to be dead\n"));
1603 }
1604
1605 /*
1606 * Wait for the device to stop initialization
1607 */
1608
1609 DDB(printk("ad1848_detect() - step 0\n"));
1610
1611 for (i = 0; i < 10000000; i++)
1612 {
1613 unsigned char x = inb(devc->base);
1614
1615 if (x == 0xff || !(x & 0x80))
1616 break;
1617 }
1618
1619 DDB(printk("ad1848_detect() - step A\n"));
1620
1621 if (inb(devc->base) == 0x80) /* Not ready. Let's wait */
1622 ad_leave_MCE(devc);
1623
1624 if ((inb(devc->base) & 0x80) != 0x00) /* Not a AD1848 */
1625 {
1626 DDB(printk("ad1848 detect error - step A (%02x)\n", (int) inb(devc->base)));
1627 return 0;
1628 }
1629
1630 /*
1631 * Test if it's possible to change contents of the indirect registers.
1632 * Registers 0 and 1 are ADC volume registers. The bit 0x10 is read only
1633 * so try to avoid using it.
1634 */
1635
1636 DDB(printk("ad1848_detect() - step B\n"));
1637 ad_write(devc, 0, 0xaa);
1638 ad_write(devc, 1, 0x45); /* 0x55 with bit 0x10 clear */
1639
1640 if ((tmp1 = ad_read(devc, 0)) != 0xaa || (tmp2 = ad_read(devc, 1)) != 0x45)
1641 {
1642 if (tmp2 == 0x65) /* AD1847 has couple of bits hardcoded to 1 */
1643 ad1847_flag = 1;
1644 else
1645 {
1646 DDB(printk("ad1848 detect error - step B (%x/%x)\n", tmp1, tmp2));
1647 return 0;
1648 }
1649 }
1650 DDB(printk("ad1848_detect() - step C\n"));
1651 ad_write(devc, 0, 0x45);
1652 ad_write(devc, 1, 0xaa);
1653
1654 if ((tmp1 = ad_read(devc, 0)) != 0x45 || (tmp2 = ad_read(devc, 1)) != 0xaa)
1655 {
1656 if (tmp2 == 0x8a) /* AD1847 has few bits hardcoded to 1 */
1657 ad1847_flag = 1;
1658 else
1659 {
1660 DDB(printk("ad1848 detect error - step C (%x/%x)\n", tmp1, tmp2));
1661 return 0;
1662 }
1663 }
1664
1665 /*
1666 * The indirect register I12 has some read only bits. Let's
1667 * try to change them.
1668 */
1669
1670 DDB(printk("ad1848_detect() - step D\n"));
1671 tmp = ad_read(devc, 12);
1672 ad_write(devc, 12, (~tmp) & 0x0f);
1673
1674 if ((tmp & 0x0f) != ((tmp1 = ad_read(devc, 12)) & 0x0f))
1675 {
1676 DDB(printk("ad1848 detect error - step D (%x)\n", tmp1));
1677 return 0;
1678 }
1679
1680 /*
1681 * NOTE! Last 4 bits of the reg I12 tell the chip revision.
1682 * 0x01=RevB and 0x0A=RevC.
1683 */
1684
1685 /*
1686 * The original AD1848/CS4248 has just 15 indirect registers. This means
1687 * that I0 and I16 should return the same value (etc.).
1688 * However this doesn't work with CS4248. Actually it seems to be impossible
1689 * to detect if the chip is a CS4231 or CS4248.
1690 * Ensure that the Mode2 enable bit of I12 is 0. Otherwise this test fails
1691 * with CS4231.
1692 */
1693
1694 /*
1695 * OPTi 82C930 has mode2 control bit in another place. This test will fail
1696 * with it. Accept this situation as a possible indication of this chip.
1697 */
1698
1699 DDB(printk("ad1848_detect() - step F\n"));
1700 ad_write(devc, 12, 0); /* Mode2=disabled */
1701
1702 for (i = 0; i < 16; i++)
1703 {
1704 if ((tmp1 = ad_read(devc, i)) != (tmp2 = ad_read(devc, i + 16)))
1705 {
1706 DDB(printk("ad1848 detect step F(%d/%x/%x) - OPTi chip???\n", i, tmp1, tmp2));
1707 if (!ad1847_flag)
1708 optiC930 = 1;
1709 break;
1710 }
1711 }
1712
1713 /*
1714 * Try to switch the chip to mode2 (CS4231) by setting the MODE2 bit (0x40).
1715 * The bit 0x80 is always 1 in CS4248 and CS4231.
1716 */
1717
1718 DDB(printk("ad1848_detect() - step G\n"));
1719
1720 if (ad_flags && *ad_flags == 400)
1721 *ad_flags = 0;
1722 else
1723 ad_write(devc, 12, 0x40); /* Set mode2, clear 0x80 */
1724
1725
1726 if (ad_flags)
1727 *ad_flags = 0;
1728
1729 tmp1 = ad_read(devc, 12);
1730 if (tmp1 & 0x80)
1731 {
1732 if (ad_flags)
1733 *ad_flags |= AD_F_CS4248;
1734
1735 devc->chip_name = "CS4248"; /* Our best knowledge just now */
1736 }
1737 if (optiC930 || (tmp1 & 0xc0) == (0x80 | 0x40))
1738 {
1739 /*
1740 * CS4231 detected - is it?
1741 *
1742 * Verify that setting I0 doesn't change I16.
1743 */
1744
1745 DDB(printk("ad1848_detect() - step H\n"));
1746 ad_write(devc, 16, 0); /* Set I16 to known value */
1747
1748 ad_write(devc, 0, 0x45);
1749 if ((tmp1 = ad_read(devc, 16)) != 0x45) /* No change -> CS4231? */
1750 {
1751 ad_write(devc, 0, 0xaa);
1752 if ((tmp1 = ad_read(devc, 16)) == 0xaa) /* Rotten bits? */
1753 {
1754 DDB(printk("ad1848 detect error - step H(%x)\n", tmp1));
1755 return 0;
1756 }
1757
1758 /*
1759 * Verify that some bits of I25 are read only.
1760 */
1761
1762 DDB(printk("ad1848_detect() - step I\n"));
1763 tmp1 = ad_read(devc, 25); /* Original bits */
1764 ad_write(devc, 25, ~tmp1); /* Invert all bits */
1765 if ((ad_read(devc, 25) & 0xe7) == (tmp1 & 0xe7))
1766 {
1767 int id;
1768
1769 /*
1770 * It's at least CS4231
1771 */
1772
1773 devc->chip_name = "CS4231";
1774 devc->model = MD_4231;
1775
1776 /*
1777 * It could be an AD1845 or CS4231A as well.
1778 * CS4231 and AD1845 report the same revision info in I25
1779 * while the CS4231A reports different.
1780 */
1781
1782 id = ad_read(devc, 25);
1783 if ((id & 0xe7) == 0x80) /* Device busy??? */
1784 id = ad_read(devc, 25);
1785 if ((id & 0xe7) == 0x80) /* Device still busy??? */
1786 id = ad_read(devc, 25);
1787 DDB(printk("ad1848_detect() - step J (%02x/%02x)\n", id, ad_read(devc, 25)));
1788
1789 if ((id & 0xe7) == 0x80) {
1790 /*
1791 * It must be a CS4231 or AD1845. The register I23 of
1792 * CS4231 is undefined and it appears to be read only.
1793 * AD1845 uses I23 for setting sample rate. Assume
1794 * the chip is AD1845 if I23 is changeable.
1795 */
1796
1797 unsigned char tmp = ad_read(devc, 23);
1798 ad_write(devc, 23, ~tmp);
1799
1800 if (interwave)
1801 {
1802 devc->model = MD_IWAVE;
1803 devc->chip_name = "IWave";
1804 }
1805 else if (ad_read(devc, 23) != tmp) /* AD1845 ? */
1806 {
1807 devc->chip_name = "AD1845";
1808 devc->model = MD_1845;
1809 }
1810 else if (cs4248_flag)
1811 {
1812 if (ad_flags)
1813 *ad_flags |= AD_F_CS4248;
1814 devc->chip_name = "CS4248";
1815 devc->model = MD_1848;
1816 ad_write(devc, 12, ad_read(devc, 12) & ~0x40); /* Mode2 off */
1817 }
1818 ad_write(devc, 23, tmp); /* Restore */
1819 }
1820 else
1821 {
1822 switch (id & 0x1f) {
1823 case 3: /* CS4236/CS4235/CS42xB/CS4239 */
1824 {
1825 int xid;
1826 ad_write(devc, 12, ad_read(devc, 12) | 0x60); /* switch to mode 3 */
1827 ad_write(devc, 23, 0x9c); /* select extended register 25 */
1828 xid = inb(io_Indexed_Data(devc));
1829 ad_write(devc, 12, ad_read(devc, 12) & ~0x60); /* back to mode 0 */
1830 switch (xid & 0x1f)
1831 {
1832 case 0x00:
1833 devc->chip_name = "CS4237B(B)";
1834 devc->model = MD_42xB;
1835 break;
1836 case 0x08:
1837 /* Seems to be a 4238 ?? */
1838 devc->chip_name = "CS4238";
1839 devc->model = MD_42xB;
1840 break;
1841 case 0x09:
1842 devc->chip_name = "CS4238B";
1843 devc->model = MD_42xB;
1844 break;
1845 case 0x0b:
1846 devc->chip_name = "CS4236B";
1847 devc->model = MD_4236;
1848 break;
1849 case 0x10:
1850 devc->chip_name = "CS4237B";
1851 devc->model = MD_42xB;
1852 break;
1853 case 0x1d:
1854 devc->chip_name = "CS4235";
1855 devc->model = MD_4235;
1856 break;
1857 case 0x1e:
1858 devc->chip_name = "CS4239";
1859 devc->model = MD_4239;
1860 break;
1861 default:
1862 printk("Chip ident is %X.\n", xid&0x1F);
1863 devc->chip_name = "CS42xx";
1864 devc->model = MD_4232;
1865 break;
1866 }
1867 }
1868 break;
1869
1870 case 2: /* CS4232/CS4232A */
1871 devc->chip_name = "CS4232";
1872 devc->model = MD_4232;
1873 break;
1874
1875 case 0:
1876 if ((id & 0xe0) == 0xa0)
1877 {
1878 devc->chip_name = "CS4231A";
1879 devc->model = MD_4231A;
1880 }
1881 else
1882 {
1883 devc->chip_name = "CS4321";
1884 devc->model = MD_4231;
1885 }
1886 break;
1887
1888 default: /* maybe */
1889 DDB(printk("ad1848: I25 = %02x/%02x\n", ad_read(devc, 25), ad_read(devc, 25) & 0xe7));
1890 if (optiC930)
1891 {
1892 devc->chip_name = "82C930";
1893 devc->model = MD_C930;
1894 }
1895 else
1896 {
1897 devc->chip_name = "CS4231";
1898 devc->model = MD_4231;
1899 }
1900 }
1901 }
1902 }
1903 ad_write(devc, 25, tmp1); /* Restore bits */
1904
1905 DDB(printk("ad1848_detect() - step K\n"));
1906 }
1907 } else if (tmp1 == 0x0a) {
1908 /*
1909 * Is it perhaps a SoundPro CMI8330?
1910 * If so, then we should be able to change indirect registers
1911 * greater than I15 after activating MODE2, even though reading
1912 * back I12 does not show it.
1913 */
1914
1915 /*
1916 * Let's try comparing register values
1917 */
1918 for (i = 0; i < 16; i++) {
1919 if ((tmp1 = ad_read(devc, i)) != (tmp2 = ad_read(devc, i + 16))) {
1920 DDB(printk("ad1848 detect step H(%d/%x/%x) - SoundPro chip?\n", i, tmp1, tmp2));
1921 soundpro = 1;
1922 devc->chip_name = "SoundPro CMI 8330";
1923 break;
1924 }
1925 }
1926 }
1927
1928 DDB(printk("ad1848_detect() - step L\n"));
1929 if (ad_flags)
1930 {
1931 if (devc->model != MD_1848)
1932 *ad_flags |= AD_F_CS4231;
1933 }
1934 DDB(printk("ad1848_detect() - Detected OK\n"));
1935
1936 if (devc->model == MD_1848 && ad1847_flag)
1937 devc->chip_name = "AD1847";
1938
1939
1940 if (sscape_flag == 1)
1941 devc->model = MD_1845_SSCAPE;
1942
1943 return 1;
1944 }
1945
1946 int ad1848_init (char *name, struct resource *ports, int irq, int dma_playback,
1947 int dma_capture, int share_dma, int *osp, struct module *owner)
1948 {
1949 /*
1950 * NOTE! If irq < 0, there is another driver which has allocated the IRQ
1951 * so that this driver doesn't need to allocate/deallocate it.
1952 * The actually used IRQ is ABS(irq).
1953 */
1954
1955 int my_dev;
1956 char dev_name[100];
1957 int e;
1958
1959 ad1848_info *devc = &adev_info[nr_ad1848_devs];
1960
1961 ad1848_port_info *portc = NULL;
1962
1963 devc->irq = (irq > 0) ? irq : 0;
1964 devc->open_mode = 0;
1965 devc->timer_ticks = 0;
1966 devc->dma1 = dma_playback;
1967 devc->dma2 = dma_capture;
1968 devc->subtype = cfg.card_subtype;
1969 devc->audio_flags = DMA_AUTOMODE;
1970 devc->playback_dev = devc->record_dev = 0;
1971 if (name != NULL)
1972 devc->name = name;
1973
1974 if (name != NULL && name[0] != 0)
1975 sprintf(dev_name,
1976 "%s (%s)", name, devc->chip_name);
1977 else
1978 sprintf(dev_name,
1979 "Generic audio codec (%s)", devc->chip_name);
1980
1981 rename_region(ports, devc->name);
1982
1983 conf_printf2(dev_name, devc->base, devc->irq, dma_playback, dma_capture);
1984
1985 if (devc->model == MD_1848 || devc->model == MD_C930)
1986 devc->audio_flags |= DMA_HARDSTOP;
1987
1988 if (devc->model > MD_1848)
1989 {
1990 if (devc->dma1 == devc->dma2 || devc->dma2 == -1 || devc->dma1 == -1)
1991 devc->audio_flags &= ~DMA_DUPLEX;
1992 else
1993 devc->audio_flags |= DMA_DUPLEX;
1994 }
1995
1996 portc = kmalloc(sizeof(ad1848_port_info), GFP_KERNEL);
1997 if(portc==NULL) {
1998 release_region(devc->base, 4);
1999 return -1;
2000 }
2001
2002 if ((my_dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION,
2003 dev_name,
2004 &ad1848_audio_driver,
2005 sizeof(struct audio_driver),
2006 devc->audio_flags,
2007 ad_format_mask[devc->model],
2008 devc,
2009 dma_playback,
2010 dma_capture)) < 0)
2011 {
2012 release_region(devc->base, 4);
2013 kfree(portc);
2014 return -1;
2015 }
2016
2017 audio_devs[my_dev]->portc = portc;
2018 audio_devs[my_dev]->mixer_dev = -1;
2019 if (owner)
2020 audio_devs[my_dev]->d->owner = owner;
2021 memset((char *) portc, 0, sizeof(*portc));
2022
2023 nr_ad1848_devs++;
2024
2025 ad1848_init_hw(devc);
2026
2027 if (irq > 0)
2028 {
2029 devc->dev_no = my_dev;
2030 if (request_irq(devc->irq, adintr, 0, devc->name,
2031 (void *)(long)my_dev) < 0)
2032 {
2033 printk(KERN_WARNING "ad1848: Unable to allocate IRQ\n");
2034 /* Don't free it either then.. */
2035 devc->irq = 0;
2036 }
2037 if (capabilities[devc->model].flags & CAP_F_TIMER)
2038 {
2039 #ifndef CONFIG_SMP
2040 int x;
2041 unsigned char tmp = ad_read(devc, 16);
2042 #endif
2043
2044 devc->timer_ticks = 0;
2045
2046 ad_write(devc, 21, 0x00); /* Timer MSB */
2047 ad_write(devc, 20, 0x10); /* Timer LSB */
2048 #ifndef CONFIG_SMP
2049 ad_write(devc, 16, tmp | 0x40); /* Enable timer */
2050 for (x = 0; x < 100000 && devc->timer_ticks == 0; x++);
2051 ad_write(devc, 16, tmp & ~0x40); /* Disable timer */
2052
2053 if (devc->timer_ticks == 0)
2054 printk(KERN_WARNING "ad1848: Interrupt test failed (IRQ%d)\n", irq);
2055 else
2056 {
2057 DDB(printk("Interrupt test OK\n"));
2058 devc->irq_ok = 1;
2059 }
2060 #else
2061 devc->irq_ok = 1;
2062 #endif
2063 }
2064 else
2065 devc->irq_ok = 1; /* Couldn't test. assume it's OK */
2066 } else if (irq < 0)
2067 irq2dev[-irq] = devc->dev_no = my_dev;
2068
2069 #ifndef EXCLUDE_TIMERS
2070 if ((capabilities[devc->model].flags & CAP_F_TIMER) &&
2071 devc->irq_ok)
2072 ad1848_tmr_install(my_dev);
2073 #endif
2074
2075 if (!share_dma)
2076 {
2077 if (sound_alloc_dma(dma_playback, devc->name))
2078 printk(KERN_WARNING "ad1848.c: Can't allocate DMA%d\n", dma_playback);
2079
2080 if (dma_capture != dma_playback)
2081 if (sound_alloc_dma(dma_capture, devc->name))
2082 printk(KERN_WARNING "ad1848.c: Can't allocate DMA%d\n", dma_capture);
2083 }
2084
2085 if ((e = sound_install_mixer(MIXER_DRIVER_VERSION,
2086 dev_name,
2087 &ad1848_mixer_operations,
2088 sizeof(struct mixer_operations),
2089 devc)) >= 0)
2090 {
2091 audio_devs[my_dev]->mixer_dev = e;
2092 if (owner)
2093 mixer_devs[e]->owner = owner;
2094 }
2095 return my_dev;
2096 }
2097
2098 int ad1848_control(int cmd, int arg)
2099 {
2100 ad1848_info *devc;
2101 unsigned long flags;
2102
2103 if (nr_ad1848_devs < 1)
2104 return -ENODEV;
2105
2106 devc = &adev_info[nr_ad1848_devs - 1];
2107
2108 switch (cmd)
2109 {
2110 case AD1848_SET_XTAL: /* Change clock frequency of AD1845 (only ) */
2111 if (devc->model != MD_1845 && devc->model != MD_1845_SSCAPE)
2112 return -EINVAL;
2113 spin_lock_irqsave(&devc->lock,flags);
2114 ad_enter_MCE(devc);
2115 ad_write(devc, 29, (ad_read(devc, 29) & 0x1f) | (arg << 5));
2116 ad_leave_MCE(devc);
2117 spin_unlock_irqrestore(&devc->lock,flags);
2118 break;
2119
2120 case AD1848_MIXER_REROUTE:
2121 {
2122 int o = (arg >> 8) & 0xff;
2123 int n = arg & 0xff;
2124
2125 if (o < 0 || o >= SOUND_MIXER_NRDEVICES)
2126 return -EINVAL;
2127
2128 if (!(devc->supported_devices & (1 << o)) &&
2129 !(devc->supported_rec_devices & (1 << o)))
2130 return -EINVAL;
2131
2132 if (n == SOUND_MIXER_NONE)
2133 { /* Just hide this control */
2134 ad1848_mixer_set(devc, o, 0); /* Shut up it */
2135 devc->supported_devices &= ~(1 << o);
2136 devc->supported_rec_devices &= ~(1 << o);
2137 break;
2138 }
2139
2140 /* Make the mixer control identified by o to appear as n */
2141 if (n < 0 || n >= SOUND_MIXER_NRDEVICES)
2142 return -EINVAL;
2143
2144 devc->mixer_reroute[n] = o; /* Rename the control */
2145 if (devc->supported_devices & (1 << o))
2146 devc->supported_devices |= (1 << n);
2147 if (devc->supported_rec_devices & (1 << o))
2148 devc->supported_rec_devices |= (1 << n);
2149
2150 devc->supported_devices &= ~(1 << o);
2151 devc->supported_rec_devices &= ~(1 << o);
2152 }
2153 break;
2154 }
2155 return 0;
2156 }
2157
2158 void ad1848_unload(int io_base, int irq, int dma_playback, int dma_capture, int share_dma)
2159 {
2160 int i, mixer, dev = 0;
2161 ad1848_info *devc = NULL;
2162
2163 for (i = 0; devc == NULL && i < nr_ad1848_devs; i++)
2164 {
2165 if (adev_info[i].base == io_base)
2166 {
2167 devc = &adev_info[i];
2168 dev = devc->dev_no;
2169 }
2170 }
2171
2172 if (devc != NULL)
2173 {
2174 kfree(audio_devs[dev]->portc);
2175 release_region(devc->base, 4);
2176
2177 if (!share_dma)
2178 {
2179 if (devc->irq > 0) /* There is no point in freeing irq, if it wasn't allocated */
2180 free_irq(devc->irq, (void *)(long)devc->dev_no);
2181
2182 sound_free_dma(dma_playback);
2183
2184 if (dma_playback != dma_capture)
2185 sound_free_dma(dma_capture);
2186
2187 }
2188 mixer = audio_devs[devc->dev_no]->mixer_dev;
2189 if(mixer>=0)
2190 sound_unload_mixerdev(mixer);
2191
2192 nr_ad1848_devs--;
2193 for ( ; i < nr_ad1848_devs ; i++)
2194 adev_info[i] = adev_info[i+1];
2195 }
2196 else
2197 printk(KERN_ERR "ad1848: Can't find device to be unloaded. Base=%x\n", io_base);
2198 }
2199
2200 static irqreturn_t adintr(int irq, void *dev_id)
2201 {
2202 unsigned char status;
2203 ad1848_info *devc;
2204 int dev;
2205 int alt_stat = 0xff;
2206 unsigned char c930_stat = 0;
2207 int cnt = 0;
2208
2209 dev = (long)dev_id;
2210 devc = (ad1848_info *) audio_devs[dev]->devc;
2211
2212 interrupt_again: /* Jump back here if int status doesn't reset */
2213
2214 status = inb(io_Status(devc));
2215
2216 if (status == 0x80)
2217 printk(KERN_DEBUG "adintr: Why?\n");
2218 if (devc->model == MD_1848)
2219 outb((0), io_Status(devc)); /* Clear interrupt status */
2220
2221 if (status & 0x01)
2222 {
2223 if (devc->model == MD_C930)
2224 { /* 82C930 has interrupt status register in MAD16 register MC11 */
2225
2226 spin_lock(&devc->lock);
2227
2228 /* 0xe0e is C930 address port
2229 * 0xe0f is C930 data port
2230 */
2231 outb(11, 0xe0e);
2232 c930_stat = inb(0xe0f);
2233 outb((~c930_stat), 0xe0f);
2234
2235 spin_unlock(&devc->lock);
2236
2237 alt_stat = (c930_stat << 2) & 0x30;
2238 }
2239 else if (devc->model != MD_1848)
2240 {
2241 spin_lock(&devc->lock);
2242 alt_stat = ad_read(devc, 24);
2243 ad_write(devc, 24, ad_read(devc, 24) & ~alt_stat); /* Selective ack */
2244 spin_unlock(&devc->lock);
2245 }
2246
2247 if ((devc->open_mode & OPEN_READ) && (devc->audio_mode & PCM_ENABLE_INPUT) && (alt_stat & 0x20))
2248 {
2249 DMAbuf_inputintr(devc->record_dev);
2250 }
2251 if ((devc->open_mode & OPEN_WRITE) && (devc->audio_mode & PCM_ENABLE_OUTPUT) &&
2252 (alt_stat & 0x10))
2253 {
2254 DMAbuf_outputintr(devc->playback_dev, 1);
2255 }
2256 if (devc->model != MD_1848 && (alt_stat & 0x40)) /* Timer interrupt */
2257 {
2258 devc->timer_ticks++;
2259 #ifndef EXCLUDE_TIMERS
2260 if (timer_installed == dev && devc->timer_running)
2261 sound_timer_interrupt();
2262 #endif
2263 }
2264 }
2265 /*
2266 * Sometimes playback or capture interrupts occur while a timer interrupt
2267 * is being handled. The interrupt will not be retriggered if we don't
2268 * handle it now. Check if an interrupt is still pending and restart
2269 * the handler in this case.
2270 */
2271 if (inb(io_Status(devc)) & 0x01 && cnt++ < 4)
2272 {
2273 goto interrupt_again;
2274 }
2275 return IRQ_HANDLED;
2276 }
2277
2278 /*
2279 * Experimental initialization sequence for the integrated sound system
2280 * of the Compaq Deskpro M.
2281 */
2282
2283 static int init_deskpro_m(struct address_info *hw_config)
2284 {
2285 unsigned char tmp;
2286
2287 if ((tmp = inb(0xc44)) == 0xff)
2288 {
2289 DDB(printk("init_deskpro_m: Dead port 0xc44\n"));
2290 return 0;
2291 }
2292
2293 outb(0x10, 0xc44);
2294 outb(0x40, 0xc45);
2295 outb(0x00, 0xc46);
2296 outb(0xe8, 0xc47);
2297 outb(0x14, 0xc44);
2298 outb(0x40, 0xc45);
2299 outb(0x00, 0xc46);
2300 outb(0xe8, 0xc47);
2301 outb(0x10, 0xc44);
2302
2303 return 1;
2304 }
2305
2306 /*
2307 * Experimental initialization sequence for the integrated sound system
2308 * of Compaq Deskpro XL.
2309 */
2310
2311 static int init_deskpro(struct address_info *hw_config)
2312 {
2313 unsigned char tmp;
2314
2315 if ((tmp = inb(0xc44)) == 0xff)
2316 {
2317 DDB(printk("init_deskpro: Dead port 0xc44\n"));
2318 return 0;
2319 }
2320 outb((tmp | 0x04), 0xc44); /* Select bank 1 */
2321 if (inb(0xc44) != 0x04)
2322 {
2323 DDB(printk("init_deskpro: Invalid bank1 signature in port 0xc44\n"));
2324 return 0;
2325 }
2326 /*
2327 * OK. It looks like a Deskpro so let's proceed.
2328 */
2329
2330 /*
2331 * I/O port 0xc44 Audio configuration register.
2332 *
2333 * bits 0xc0: Audio revision bits
2334 * 0x00 = Compaq Business Audio
2335 * 0x40 = MS Sound System Compatible (reset default)
2336 * 0x80 = Reserved
2337 * 0xc0 = Reserved
2338 * bit 0x20: No Wait State Enable
2339 * 0x00 = Disabled (reset default, DMA mode)
2340 * 0x20 = Enabled (programmed I/O mode)
2341 * bit 0x10: MS Sound System Decode Enable
2342 * 0x00 = Decoding disabled (reset default)
2343 * 0x10 = Decoding enabled
2344 * bit 0x08: FM Synthesis Decode Enable
2345 * 0x00 = Decoding Disabled (reset default)
2346 * 0x08 = Decoding enabled
2347 * bit 0x04 Bank select
2348 * 0x00 = Bank 0
2349 * 0x04 = Bank 1
2350 * bits 0x03 MSS Base address
2351 * 0x00 = 0x530 (reset default)
2352 * 0x01 = 0x604
2353 * 0x02 = 0xf40
2354 * 0x03 = 0xe80
2355 */
2356
2357 #ifdef DEBUGXL
2358 /* Debug printing */
2359 printk("Port 0xc44 (before): ");
2360 outb((tmp & ~0x04), 0xc44);
2361 printk("%02x ", inb(0xc44));
2362 outb((tmp | 0x04), 0xc44);
2363 printk("%02x\n", inb(0xc44));
2364 #endif
2365
2366 /* Set bank 1 of the register */
2367 tmp = 0x58; /* MSS Mode, MSS&FM decode enabled */
2368
2369 switch (hw_config->io_base)
2370 {
2371 case 0x530:
2372 tmp |= 0x00;
2373 break;
2374 case 0x604:
2375 tmp |= 0x01;
2376 break;
2377 case 0xf40:
2378 tmp |= 0x02;
2379 break;
2380 case 0xe80:
2381 tmp |= 0x03;
2382 break;
2383 default:
2384 DDB(printk("init_deskpro: Invalid MSS port %x\n", hw_config->io_base));
2385 return 0;
2386 }
2387 outb((tmp & ~0x04), 0xc44); /* Write to bank=0 */
2388
2389 #ifdef DEBUGXL
2390 /* Debug printing */
2391 printk("Port 0xc44 (after): ");
2392 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2393 printk("%02x ", inb(0xc44));
2394 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2395 printk("%02x\n", inb(0xc44));
2396 #endif
2397
2398 /*
2399 * I/O port 0xc45 FM Address Decode/MSS ID Register.
2400 *
2401 * bank=0, bits 0xfe: FM synthesis Decode Compare bits 7:1 (default=0x88)
2402 * bank=0, bit 0x01: SBIC Power Control Bit
2403 * 0x00 = Powered up
2404 * 0x01 = Powered down
2405 * bank=1, bits 0xfc: MSS ID (default=0x40)
2406 */
2407
2408 #ifdef DEBUGXL
2409 /* Debug printing */
2410 printk("Port 0xc45 (before): ");
2411 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2412 printk("%02x ", inb(0xc45));
2413 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2414 printk("%02x\n", inb(0xc45));
2415 #endif
2416
2417 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2418 outb((0x88), 0xc45); /* FM base 7:0 = 0x88 */
2419 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2420 outb((0x10), 0xc45); /* MSS ID = 0x10 (MSS port returns 0x04) */
2421
2422 #ifdef DEBUGXL
2423 /* Debug printing */
2424 printk("Port 0xc45 (after): ");
2425 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2426 printk("%02x ", inb(0xc45));
2427 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2428 printk("%02x\n", inb(0xc45));
2429 #endif
2430
2431
2432 /*
2433 * I/O port 0xc46 FM Address Decode/Address ASIC Revision Register.
2434 *
2435 * bank=0, bits 0xff: FM synthesis Decode Compare bits 15:8 (default=0x03)
2436 * bank=1, bits 0xff: Audio addressing ASIC id
2437 */
2438
2439 #ifdef DEBUGXL
2440 /* Debug printing */
2441 printk("Port 0xc46 (before): ");
2442 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2443 printk("%02x ", inb(0xc46));
2444 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2445 printk("%02x\n", inb(0xc46));
2446 #endif
2447
2448 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2449 outb((0x03), 0xc46); /* FM base 15:8 = 0x03 */
2450 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2451 outb((0x11), 0xc46); /* ASIC ID = 0x11 */
2452
2453 #ifdef DEBUGXL
2454 /* Debug printing */
2455 printk("Port 0xc46 (after): ");
2456 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2457 printk("%02x ", inb(0xc46));
2458 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2459 printk("%02x\n", inb(0xc46));
2460 #endif
2461
2462 /*
2463 * I/O port 0xc47 FM Address Decode Register.
2464 *
2465 * bank=0, bits 0xff: Decode enable selection for various FM address bits
2466 * bank=1, bits 0xff: Reserved
2467 */
2468
2469 #ifdef DEBUGXL
2470 /* Debug printing */
2471 printk("Port 0xc47 (before): ");
2472 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2473 printk("%02x ", inb(0xc47));
2474 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2475 printk("%02x\n", inb(0xc47));
2476 #endif
2477
2478 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2479 outb((0x7c), 0xc47); /* FM decode enable bits = 0x7c */
2480 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2481 outb((0x00), 0xc47); /* Reserved bank1 = 0x00 */
2482
2483 #ifdef DEBUGXL
2484 /* Debug printing */
2485 printk("Port 0xc47 (after): ");
2486 outb((tmp & ~0x04), 0xc44); /* Select bank=0 */
2487 printk("%02x ", inb(0xc47));
2488 outb((tmp | 0x04), 0xc44); /* Select bank=1 */
2489 printk("%02x\n", inb(0xc47));
2490 #endif
2491
2492 /*
2493 * I/O port 0xc6f = Audio Disable Function Register
2494 */
2495
2496 #ifdef DEBUGXL
2497 printk("Port 0xc6f (before) = %02x\n", inb(0xc6f));
2498 #endif
2499
2500 outb((0x80), 0xc6f);
2501
2502 #ifdef DEBUGXL
2503 printk("Port 0xc6f (after) = %02x\n", inb(0xc6f));
2504 #endif
2505
2506 return 1;
2507 }
2508
2509 int probe_ms_sound(struct address_info *hw_config, struct resource *ports)
2510 {
2511 unsigned char tmp;
2512
2513 DDB(printk("Entered probe_ms_sound(%x, %d)\n", hw_config->io_base, hw_config->card_subtype));
2514
2515 if (hw_config->card_subtype == 1) /* Has no IRQ/DMA registers */
2516 {
2517 /* check_opl3(0x388, hw_config); */
2518 return ad1848_detect(ports, NULL, hw_config->osp);
2519 }
2520
2521 if (deskpro_xl && hw_config->card_subtype == 2) /* Compaq Deskpro XL */
2522 {
2523 if (!init_deskpro(hw_config))
2524 return 0;
2525 }
2526
2527 if (deskpro_m) /* Compaq Deskpro M */
2528 {
2529 if (!init_deskpro_m(hw_config))
2530 return 0;
2531 }
2532
2533 /*
2534 * Check if the IO port returns valid signature. The original MS Sound
2535 * system returns 0x04 while some cards (AudioTrix Pro for example)
2536 * return 0x00 or 0x0f.
2537 */
2538
2539 if ((tmp = inb(hw_config->io_base + 3)) == 0xff) /* Bus float */
2540 {
2541 int ret;
2542
2543 DDB(printk("I/O address is inactive (%x)\n", tmp));
2544 if (!(ret = ad1848_detect(ports, NULL, hw_config->osp)))
2545 return 0;
2546 return 1;
2547 }
2548 DDB(printk("MSS signature = %x\n", tmp & 0x3f));
2549 if ((tmp & 0x3f) != 0x04 &&
2550 (tmp & 0x3f) != 0x0f &&
2551 (tmp & 0x3f) != 0x00)
2552 {
2553 int ret;
2554
2555 MDB(printk(KERN_ERR "No MSS signature detected on port 0x%x (0x%x)\n", hw_config->io_base, (int) inb(hw_config->io_base + 3)));
2556 DDB(printk("Trying to detect codec anyway but IRQ/DMA may not work\n"));
2557 if (!(ret = ad1848_detect(ports, NULL, hw_config->osp)))
2558 return 0;
2559
2560 hw_config->card_subtype = 1;
2561 return 1;
2562 }
2563 if ((hw_config->irq != 5) &&
2564 (hw_config->irq != 7) &&
2565 (hw_config->irq != 9) &&
2566 (hw_config->irq != 10) &&
2567 (hw_config->irq != 11) &&
2568 (hw_config->irq != 12))
2569 {
2570 printk(KERN_ERR "MSS: Bad IRQ %d\n", hw_config->irq);
2571 return 0;
2572 }
2573 if (hw_config->dma != 0 && hw_config->dma != 1 && hw_config->dma != 3)
2574 {
2575 printk(KERN_ERR "MSS: Bad DMA %d\n", hw_config->dma);
2576 return 0;
2577 }
2578 /*
2579 * Check that DMA0 is not in use with a 8 bit board.
2580 */
2581
2582 if (hw_config->dma == 0 && inb(hw_config->io_base + 3) & 0x80)
2583 {
2584 printk(KERN_ERR "MSS: Can't use DMA0 with a 8 bit card/slot\n");
2585 return 0;
2586 }
2587 if (hw_config->irq > 7 && hw_config->irq != 9 && inb(hw_config->io_base + 3) & 0x80)
2588 {
2589 printk(KERN_ERR "MSS: Can't use IRQ%d with a 8 bit card/slot\n", hw_config->irq);
2590 return 0;
2591 }
2592 return ad1848_detect(ports, NULL, hw_config->osp);
2593 }
2594
2595 void attach_ms_sound(struct address_info *hw_config, struct resource *ports, struct module *owner)
2596 {
2597 static signed char interrupt_bits[12] =
2598 {
2599 -1, -1, -1, -1, -1, 0x00, -1, 0x08, -1, 0x10, 0x18, 0x20
2600 };
2601 signed char bits;
2602 char dma2_bit = 0;
2603
2604 static char dma_bits[4] =
2605 {
2606 1, 2, 0, 3
2607 };
2608
2609 int config_port = hw_config->io_base + 0;
2610 int version_port = hw_config->io_base + 3;
2611 int dma = hw_config->dma;
2612 int dma2 = hw_config->dma2;
2613
2614 if (hw_config->card_subtype == 1) /* Has no IRQ/DMA registers */
2615 {
2616 hw_config->slots[0] = ad1848_init("MS Sound System", ports,
2617 hw_config->irq,
2618 hw_config->dma,
2619 hw_config->dma2, 0,
2620 hw_config->osp,
2621 owner);
2622 return;
2623 }
2624 /*
2625 * Set the IRQ and DMA addresses.
2626 */
2627
2628 bits = interrupt_bits[hw_config->irq];
2629 if (bits == -1)
2630 {
2631 printk(KERN_ERR "MSS: Bad IRQ %d\n", hw_config->irq);
2632 release_region(ports->start, 4);
2633 release_region(ports->start - 4, 4);
2634 return;
2635 }
2636 outb((bits | 0x40), config_port);
2637 if ((inb(version_port) & 0x40) == 0)
2638 printk(KERN_ERR "[MSS: IRQ Conflict?]\n");
2639
2640 /*
2641 * Handle the capture DMA channel
2642 */
2643
2644 if (dma2 != -1 && dma2 != dma)
2645 {
2646 if (!((dma == 0 && dma2 == 1) ||
2647 (dma == 1 && dma2 == 0) ||
2648 (dma == 3 && dma2 == 0)))
2649 { /* Unsupported combination. Try to swap channels */
2650 int tmp = dma;
2651
2652 dma = dma2;
2653 dma2 = tmp;
2654 }
2655 if ((dma == 0 && dma2 == 1) ||
2656 (dma == 1 && dma2 == 0) ||
2657 (dma == 3 && dma2 == 0))
2658 {
2659 dma2_bit = 0x04; /* Enable capture DMA */
2660 }
2661 else
2662 {
2663 printk(KERN_WARNING "MSS: Invalid capture DMA\n");
2664 dma2 = dma;
2665 }
2666 }
2667 else
2668 {
2669 dma2 = dma;
2670 }
2671
2672 hw_config->dma = dma;
2673 hw_config->dma2 = dma2;
2674
2675 outb((bits | dma_bits[dma] | dma2_bit), config_port); /* Write IRQ+DMA setup */
2676
2677 hw_config->slots[0] = ad1848_init("MS Sound System", ports,
2678 hw_config->irq,
2679 dma, dma2, 0,
2680 hw_config->osp,
2681 THIS_MODULE);
2682 }
2683
2684 void unload_ms_sound(struct address_info *hw_config)
2685 {
2686 ad1848_unload(hw_config->io_base + 4,
2687 hw_config->irq,
2688 hw_config->dma,
2689 hw_config->dma2, 0);
2690 sound_unload_audiodev(hw_config->slots[0]);
2691 release_region(hw_config->io_base, 4);
2692 }
2693
2694 #ifndef EXCLUDE_TIMERS
2695
2696 /*
2697 * Timer stuff (for /dev/music).
2698 */
2699
2700 static unsigned int current_interval;
2701
2702 static unsigned int ad1848_tmr_start(int dev, unsigned int usecs)
2703 {
2704 unsigned long flags;
2705 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
2706 unsigned long xtal_nsecs; /* nanoseconds per xtal oscillator tick */
2707 unsigned long divider;
2708
2709 spin_lock_irqsave(&devc->lock,flags);
2710
2711 /*
2712 * Length of the timer interval (in nanoseconds) depends on the
2713 * selected crystal oscillator. Check this from bit 0x01 of I8.
2714 *
2715 * AD1845 has just one oscillator which has cycle time of 10.050 us
2716 * (when a 24.576 MHz xtal oscillator is used).
2717 *
2718 * Convert requested interval to nanoseconds before computing
2719 * the timer divider.
2720 */
2721
2722 if (devc->model == MD_1845 || devc->model == MD_1845_SSCAPE)
2723 xtal_nsecs = 10050;
2724 else if (ad_read(devc, 8) & 0x01)
2725 xtal_nsecs = 9920;
2726 else
2727 xtal_nsecs = 9969;
2728
2729 divider = (usecs * 1000 + xtal_nsecs / 2) / xtal_nsecs;
2730
2731 if (divider < 100) /* Don't allow shorter intervals than about 1ms */
2732 divider = 100;
2733
2734 if (divider > 65535) /* Overflow check */
2735 divider = 65535;
2736
2737 ad_write(devc, 21, (divider >> 8) & 0xff); /* Set upper bits */
2738 ad_write(devc, 20, divider & 0xff); /* Set lower bits */
2739 ad_write(devc, 16, ad_read(devc, 16) | 0x40); /* Start the timer */
2740 devc->timer_running = 1;
2741 spin_unlock_irqrestore(&devc->lock,flags);
2742
2743 return current_interval = (divider * xtal_nsecs + 500) / 1000;
2744 }
2745
2746 static void ad1848_tmr_reprogram(int dev)
2747 {
2748 /*
2749 * Audio driver has changed sampling rate so that a different xtal
2750 * oscillator was selected. We have to reprogram the timer rate.
2751 */
2752
2753 ad1848_tmr_start(dev, current_interval);
2754 sound_timer_syncinterval(current_interval);
2755 }
2756
2757 static void ad1848_tmr_disable(int dev)
2758 {
2759 unsigned long flags;
2760 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
2761
2762 spin_lock_irqsave(&devc->lock,flags);
2763 ad_write(devc, 16, ad_read(devc, 16) & ~0x40);
2764 devc->timer_running = 0;
2765 spin_unlock_irqrestore(&devc->lock,flags);
2766 }
2767
2768 static void ad1848_tmr_restart(int dev)
2769 {
2770 unsigned long flags;
2771 ad1848_info *devc = (ad1848_info *) audio_devs[dev]->devc;
2772
2773 if (current_interval == 0)
2774 return;
2775
2776 spin_lock_irqsave(&devc->lock,flags);
2777 ad_write(devc, 16, ad_read(devc, 16) | 0x40);
2778 devc->timer_running = 1;
2779 spin_unlock_irqrestore(&devc->lock,flags);
2780 }
2781
2782 static struct sound_lowlev_timer ad1848_tmr =
2783 {
2784 0,
2785 2,
2786 ad1848_tmr_start,
2787 ad1848_tmr_disable,
2788 ad1848_tmr_restart
2789 };
2790
2791 static int ad1848_tmr_install(int dev)
2792 {
2793 if (timer_installed != -1)
2794 return 0; /* Don't install another timer */
2795
2796 timer_installed = ad1848_tmr.dev = dev;
2797 sound_timer_init(&ad1848_tmr, audio_devs[dev]->name);
2798
2799 return 1;
2800 }
2801 #endif /* EXCLUDE_TIMERS */
2802
2803 EXPORT_SYMBOL(ad1848_detect);
2804 EXPORT_SYMBOL(ad1848_init);
2805 EXPORT_SYMBOL(ad1848_unload);
2806 EXPORT_SYMBOL(ad1848_control);
2807 EXPORT_SYMBOL(probe_ms_sound);
2808 EXPORT_SYMBOL(attach_ms_sound);
2809 EXPORT_SYMBOL(unload_ms_sound);
2810
2811 static int __initdata io = -1;
2812 static int __initdata irq = -1;
2813 static int __initdata dma = -1;
2814 static int __initdata dma2 = -1;
2815 static int __initdata type = 0;
2816
2817 module_param(io, int, 0); /* I/O for a raw AD1848 card */
2818 module_param(irq, int, 0); /* IRQ to use */
2819 module_param(dma, int, 0); /* First DMA channel */
2820 module_param(dma2, int, 0); /* Second DMA channel */
2821 module_param(type, int, 0); /* Card type */
2822 module_param(deskpro_xl, bool, 0); /* Special magic for Deskpro XL boxen */
2823 module_param(deskpro_m, bool, 0); /* Special magic for Deskpro M box */
2824 module_param(soundpro, bool, 0); /* More special magic for SoundPro chips */
2825
2826 #ifdef CONFIG_PNP
2827 module_param(isapnp, int, 0);
2828 module_param(isapnpjump, int, 0);
2829 module_param(reverse, bool, 0);
2830 MODULE_PARM_DESC(isapnp, "When set to 0, Plug & Play support will be disabled");
2831 MODULE_PARM_DESC(isapnpjump, "Jumps to a specific slot in the driver's PnP table. Use the source, Luke.");
2832 MODULE_PARM_DESC(reverse, "When set to 1, will reverse ISAPnP search order");
2833
2834 static struct pnp_dev *ad1848_dev = NULL;
2835
2836 /* Please add new entries at the end of the table */
2837 static struct {
2838 char *name;
2839 unsigned short card_vendor, card_device,
2840 vendor, function;
2841 short mss_io, irq, dma, dma2; /* index into isapnp table */
2842 int type;
2843 } ad1848_isapnp_list[] __initdata = {
2844 {"CMI 8330 SoundPRO",
2845 ISAPNP_VENDOR('C','M','I'), ISAPNP_DEVICE(0x0001),
2846 ISAPNP_VENDOR('@','@','@'), ISAPNP_FUNCTION(0x0001),
2847 0, 0, 0,-1, 0},
2848 {"CS4232 based card",
2849 ISAPNP_ANY_ID, ISAPNP_ANY_ID,
2850 ISAPNP_VENDOR('C','S','C'), ISAPNP_FUNCTION(0x0000),
2851 0, 0, 0, 1, 0},
2852 {"CS4232 based card",
2853 ISAPNP_ANY_ID, ISAPNP_ANY_ID,
2854 ISAPNP_VENDOR('C','S','C'), ISAPNP_FUNCTION(0x0100),
2855 0, 0, 0, 1, 0},
2856 {"OPL3-SA2 WSS mode",
2857 ISAPNP_ANY_ID, ISAPNP_ANY_ID,
2858 ISAPNP_VENDOR('Y','M','H'), ISAPNP_FUNCTION(0x0021),
2859 1, 0, 0, 1, 1},
2860 {"Advanced Gravis InterWave Audio",
2861 ISAPNP_VENDOR('G','R','V'), ISAPNP_DEVICE(0x0001),
2862 ISAPNP_VENDOR('G','R','V'), ISAPNP_FUNCTION(0x0000),
2863 0, 0, 0, 1, 0},
2864 {NULL}
2865 };
2866
2867 static struct isapnp_device_id id_table[] __devinitdata = {
2868 { ISAPNP_VENDOR('C','M','I'), ISAPNP_DEVICE(0x0001),
2869 ISAPNP_VENDOR('@','@','@'), ISAPNP_FUNCTION(0x0001), 0 },
2870 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
2871 ISAPNP_VENDOR('C','S','C'), ISAPNP_FUNCTION(0x0000), 0 },
2872 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
2873 ISAPNP_VENDOR('C','S','C'), ISAPNP_FUNCTION(0x0100), 0 },
2874 /* The main driver for this card is opl3sa2
2875 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
2876 ISAPNP_VENDOR('Y','M','H'), ISAPNP_FUNCTION(0x0021), 0 },
2877 */
2878 { ISAPNP_VENDOR('G','R','V'), ISAPNP_DEVICE(0x0001),
2879 ISAPNP_VENDOR('G','R','V'), ISAPNP_FUNCTION(0x0000), 0 },
2880 {0}
2881 };
2882
2883 MODULE_DEVICE_TABLE(isapnp, id_table);
2884
2885 static struct pnp_dev *activate_dev(char *devname, char *resname, struct pnp_dev *dev)
2886 {
2887 int err;
2888
2889 err = pnp_device_attach(dev);
2890 if (err < 0)
2891 return(NULL);
2892
2893 if((err = pnp_activate_dev(dev)) < 0) {
2894 printk(KERN_ERR "ad1848: %s %s config failed (out of resources?)[%d]\n", devname, resname, err);
2895
2896 pnp_device_detach(dev);
2897
2898 return(NULL);
2899 }
2900 audio_activated = 1;
2901 return(dev);
2902 }
2903
2904 static struct pnp_dev __init *ad1848_init_generic(struct pnp_card *bus,
2905 struct address_info *hw_config, int slot)
2906 {
2907
2908 /* Configure Audio device */
2909 if((ad1848_dev = pnp_find_dev(bus, ad1848_isapnp_list[slot].vendor, ad1848_isapnp_list[slot].function, NULL)))
2910 {
2911 if((ad1848_dev = activate_dev(ad1848_isapnp_list[slot].name, "ad1848", ad1848_dev)))
2912 {
2913 hw_config->io_base = pnp_port_start(ad1848_dev, ad1848_isapnp_list[slot].mss_io);
2914 hw_config->irq = pnp_irq(ad1848_dev, ad1848_isapnp_list[slot].irq);
2915 hw_config->dma = pnp_dma(ad1848_dev, ad1848_isapnp_list[slot].dma);
2916 if(ad1848_isapnp_list[slot].dma2 != -1)
2917 hw_config->dma2 = pnp_dma(ad1848_dev, ad1848_isapnp_list[slot].dma2);
2918 else
2919 hw_config->dma2 = -1;
2920 hw_config->card_subtype = ad1848_isapnp_list[slot].type;
2921 } else
2922 return(NULL);
2923 } else
2924 return(NULL);
2925
2926 return(ad1848_dev);
2927 }
2928
2929 static int __init ad1848_isapnp_init(struct address_info *hw_config, struct pnp_card *bus, int slot)
2930 {
2931 char *busname = bus->name[0] ? bus->name : ad1848_isapnp_list[slot].name;
2932
2933 /* Initialize this baby. */
2934
2935 if(ad1848_init_generic(bus, hw_config, slot)) {
2936 /* We got it. */
2937
2938 printk(KERN_NOTICE "ad1848: PnP reports '%s' at i/o %#x, irq %d, dma %d, %d\n",
2939 busname,
2940 hw_config->io_base, hw_config->irq, hw_config->dma,
2941 hw_config->dma2);
2942 return 1;
2943 }
2944 return 0;
2945 }
2946
2947 static int __init ad1848_isapnp_probe(struct address_info *hw_config)
2948 {
2949 static int first = 1;
2950 int i;
2951
2952 /* Count entries in sb_isapnp_list */
2953 for (i = 0; ad1848_isapnp_list[i].card_vendor != 0; i++);
2954 i--;
2955
2956 /* Check and adjust isapnpjump */
2957 if( isapnpjump < 0 || isapnpjump > i) {
2958 isapnpjump = reverse ? i : 0;
2959 printk(KERN_ERR "ad1848: Valid range for isapnpjump is 0-%d. Adjusted to %d.\n", i, isapnpjump);
2960 }
2961
2962 if(!first || !reverse)
2963 i = isapnpjump;
2964 first = 0;
2965 while(ad1848_isapnp_list[i].card_vendor != 0) {
2966 static struct pnp_card *bus = NULL;
2967
2968 while ((bus = pnp_find_card(
2969 ad1848_isapnp_list[i].card_vendor,
2970 ad1848_isapnp_list[i].card_device,
2971 bus))) {
2972
2973 if(ad1848_isapnp_init(hw_config, bus, i)) {
2974 isapnpjump = i; /* start next search from here */
2975 return 0;
2976 }
2977 }
2978 i += reverse ? -1 : 1;
2979 }
2980
2981 return -ENODEV;
2982 }
2983 #endif
2984
2985
2986 static int __init init_ad1848(void)
2987 {
2988 printk(KERN_INFO "ad1848/cs4248 codec driver Copyright (C) by Hannu Savolainen 1993-1996\n");
2989
2990 #ifdef CONFIG_PNP
2991 if(isapnp && (ad1848_isapnp_probe(&cfg) < 0) ) {
2992 printk(KERN_NOTICE "ad1848: No ISAPnP cards found, trying standard ones...\n");
2993 isapnp = 0;
2994 }
2995 #endif
2996
2997 if(io != -1) {
2998 struct resource *ports;
2999 if( isapnp == 0 )
3000 {
3001 if(irq == -1 || dma == -1) {
3002 printk(KERN_WARNING "ad1848: must give I/O , IRQ and DMA.\n");
3003 return -EINVAL;
3004 }
3005
3006 cfg.irq = irq;
3007 cfg.io_base = io;
3008 cfg.dma = dma;
3009 cfg.dma2 = dma2;
3010 cfg.card_subtype = type;
3011 }
3012
3013 ports = request_region(io + 4, 4, "ad1848");
3014
3015 if (!ports)
3016 return -EBUSY;
3017
3018 if (!request_region(io, 4, "WSS config")) {
3019 release_region(io + 4, 4);
3020 return -EBUSY;
3021 }
3022
3023 if (!probe_ms_sound(&cfg, ports)) {
3024 release_region(io + 4, 4);
3025 release_region(io, 4);
3026 return -ENODEV;
3027 }
3028 attach_ms_sound(&cfg, ports, THIS_MODULE);
3029 loaded = 1;
3030 }
3031 return 0;
3032 }
3033
3034 static void __exit cleanup_ad1848(void)
3035 {
3036 if(loaded)
3037 unload_ms_sound(&cfg);
3038
3039 #ifdef CONFIG_PNP
3040 if(ad1848_dev){
3041 if(audio_activated)
3042 pnp_device_detach(ad1848_dev);
3043 }
3044 #endif
3045 }
3046
3047 module_init(init_ad1848);
3048 module_exit(cleanup_ad1848);
3049
3050 #ifndef MODULE
3051 static int __init setup_ad1848(char *str)
3052 {
3053 /* io, irq, dma, dma2, type */
3054 int ints[6];
3055
3056 str = get_options(str, ARRAY_SIZE(ints), ints);
3057
3058 io = ints[1];
3059 irq = ints[2];
3060 dma = ints[3];
3061 dma2 = ints[4];
3062 type = ints[5];
3063
3064 return 1;
3065 }
3066
3067 __setup("ad1848=", setup_ad1848);
3068 #endif
3069 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree