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