Pull context-bitmap into release branch
[linux-2.6] / sound / oss / ad1816.c
1 /*
2  *
3  * AD1816 lowlevel sound driver for Linux 2.6.0 and above
4  *
5  * Copyright (C) 1998-2003 by Thorsten Knabe <linux@thorsten-knabe.de>
6  *
7  * Based on the CS4232/AD1848 driver Copyright (C) by Hannu Savolainen 1993-1996
8  *
9  *
10  * version: 1.5
11  * status: beta
12  * date: 2003/07/15
13  *
14  * Changes:
15  *      Oleg Drokin: Some cleanup of load/unload functions.     1998/11/24
16  *      
17  *      Thorsten Knabe: attach and unload rewritten, 
18  *      some argument checks added                              1998/11/30
19  *
20  *      Thorsten Knabe: Buggy isa bridge workaround added       1999/01/16
21  *      
22  *      David Moews/Thorsten Knabe: Introduced options 
23  *      parameter. Added slightly modified patch from 
24  *      David Moews to disable dsp audio sources by setting 
25  *      bit 0 of options parameter. This seems to be
26  *      required by some Aztech/Newcom SC-16 cards.             1999/04/18
27  *
28  *      Christoph Hellwig: Adapted to module_init/module_exit.  2000/03/03
29  *
30  *      Christoph Hellwig: Added isapnp support                 2000/03/15
31  *
32  *      Arnaldo Carvalho de Melo: get rid of check_region       2001/10/07
33  *      
34  *      Thorsten Knabe: Compiling with CONFIG_PNP enabled
35  *      works again. It is now possible to use more than one 
36  *      AD1816 sound card. Sample rate now may be changed during
37  *      playback/capture. printk() uses log levels everywhere.
38  *      SMP fixes. DMA handling fixes.
39  *      Other minor code cleanup.                               2003/07/15
40  *
41  */
42
43
44 #include <linux/config.h>
45 #include <linux/module.h>
46 #include <linux/init.h>
47 #include <linux/interrupt.h>
48 #include <linux/isapnp.h>
49 #include <linux/stddef.h>
50 #include <linux/spinlock.h>
51 #include "sound_config.h"
52
53 #define DEBUGNOISE(x)
54
55 #define CHECK_FOR_POWER { int timeout=100; \
56   while (timeout > 0 && (inb(devc->base)&0x80)!= 0x80) {\
57           timeout--; \
58   } \
59   if (timeout==0) {\
60           printk(KERN_WARNING "ad1816: Check for power failed in %s line: %d\n",__FILE__,__LINE__); \
61   } \
62 }
63
64 /* structure to hold device specific information */
65 typedef struct
66 {
67         int            base;          /* set in attach */
68         int            irq;
69         int            dma_playback;
70         int            dma_capture;
71   
72         int            opened;         /* open */
73         int            speed;   
74         int            channels;
75         int            audio_format;
76         int            audio_mode; 
77   
78         int            recmask;        /* setup */
79         unsigned char  format_bits;
80         int            supported_devices;
81         int            supported_rec_devices;
82         unsigned short levels[SOUND_MIXER_NRDEVICES];
83                                         /* misc */
84         struct pnp_dev *pnpdev;  /* configured via pnp */
85         int            dev_no;   /* this is the # in audio_devs and NOT 
86                                     in ad1816_info */
87         spinlock_t      lock;  
88 } ad1816_info;
89
90 static int nr_ad1816_devs;
91 static int ad1816_clockfreq = 33000;
92 static int options;
93
94 /* supported audio formats */
95 static int  ad_format_mask =
96 AFMT_U8 | AFMT_S16_LE | AFMT_S16_BE | AFMT_MU_LAW | AFMT_A_LAW;
97
98 /* array of device info structures */
99 static ad1816_info dev_info[MAX_AUDIO_DEV];
100
101
102 /* ------------------------------------------------------------------- */
103
104 /* functions for easier access to inderect registers */
105
106 static int ad_read (ad1816_info * devc, int reg)
107 {
108         int result;
109         
110         CHECK_FOR_POWER;
111         outb ((unsigned char) (reg & 0x3f), devc->base+0);
112         result = inb(devc->base+2);
113         result+= inb(devc->base+3)<<8;
114         return (result);
115 }
116
117
118 static void ad_write (ad1816_info * devc, int reg, int data)
119 {
120         CHECK_FOR_POWER;
121         outb ((unsigned char) (reg & 0xff), devc->base+0);
122         outb ((unsigned char) (data & 0xff),devc->base+2);
123         outb ((unsigned char) ((data>>8)&0xff),devc->base+3);
124 }
125
126 /* ------------------------------------------------------------------- */
127
128 /* function interface required by struct audio_driver */
129
130 static void ad1816_halt_input (int dev)
131 {
132         unsigned long flags;
133         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
134         unsigned char buffer;
135         
136         DEBUGNOISE(printk(KERN_DEBUG "ad1816: halt_input called\n"));
137         
138         spin_lock_irqsave(&devc->lock,flags); 
139         
140         if(!isa_dma_bridge_buggy) {
141                 disable_dma(audio_devs[dev]->dmap_in->dma);
142         }
143         
144         buffer=inb(devc->base+9);
145         if (buffer & 0x01) {
146                 /* disable capture */
147                 outb(buffer & ~0x01,devc->base+9); 
148         }
149
150         if(!isa_dma_bridge_buggy) {
151                 enable_dma(audio_devs[dev]->dmap_in->dma);
152         }
153
154         /* Clear interrupt status */
155         outb (~0x40, devc->base+1);     
156         
157         devc->audio_mode &= ~PCM_ENABLE_INPUT;
158         spin_unlock_irqrestore(&devc->lock,flags);
159 }
160
161 static void ad1816_halt_output (int dev)
162 {
163         unsigned long  flags;
164         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
165         
166         unsigned char buffer;
167
168         DEBUGNOISE(printk(KERN_DEBUG "ad1816: halt_output called!\n"));
169
170         spin_lock_irqsave(&devc->lock,flags); 
171         /* Mute pcm output */
172         ad_write(devc, 4, ad_read(devc,4)|0x8080);
173
174         if(!isa_dma_bridge_buggy) {
175                 disable_dma(audio_devs[dev]->dmap_out->dma);
176         }
177
178         buffer=inb(devc->base+8);
179         if (buffer & 0x01) {
180                 /* disable capture */
181                 outb(buffer & ~0x01,devc->base+8); 
182         }
183
184         if(!isa_dma_bridge_buggy) {
185                 enable_dma(audio_devs[dev]->dmap_out->dma);
186         }
187
188         /* Clear interrupt status */
189         outb ((unsigned char)~0x80, devc->base+1);      
190
191         devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
192         spin_unlock_irqrestore(&devc->lock,flags);
193 }
194
195 static void ad1816_output_block (int dev, unsigned long buf, 
196                                  int count, int intrflag)
197 {
198         unsigned long flags;
199         unsigned long cnt;
200         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
201         
202         DEBUGNOISE(printk(KERN_DEBUG "ad1816: output_block called buf=%ld count=%d flags=%d\n",buf,count,intrflag));
203   
204         cnt = count/4 - 1;
205   
206         spin_lock_irqsave(&devc->lock,flags);
207         
208         /* set transfer count */
209         ad_write (devc, 8, cnt & 0xffff); 
210         
211         devc->audio_mode |= PCM_ENABLE_OUTPUT; 
212         spin_unlock_irqrestore(&devc->lock,flags);
213 }
214
215
216 static void ad1816_start_input (int dev, unsigned long buf, int count,
217                                 int intrflag)
218 {
219         unsigned long flags;
220         unsigned long  cnt;
221         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
222         
223         DEBUGNOISE(printk(KERN_DEBUG "ad1816: start_input called buf=%ld count=%d flags=%d\n",buf,count,intrflag));
224
225         cnt = count/4 - 1;
226
227         spin_lock_irqsave(&devc->lock,flags);
228
229         /* set transfer count */
230         ad_write (devc, 10, cnt & 0xffff); 
231         devc->audio_mode |= PCM_ENABLE_INPUT;
232         spin_unlock_irqrestore(&devc->lock,flags);
233 }
234
235 static int ad1816_prepare_for_input (int dev, int bsize, int bcount)
236 {
237         unsigned long flags;
238         unsigned int freq;
239         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
240         unsigned char fmt_bits;
241         
242         DEBUGNOISE(printk(KERN_DEBUG "ad1816: prepare_for_input called: bsize=%d bcount=%d\n",bsize,bcount));
243
244         spin_lock_irqsave(&devc->lock,flags);
245         fmt_bits= (devc->format_bits&0x7)<<3;
246         
247         /* set mono/stereo mode */
248         if (devc->channels > 1) {
249                 fmt_bits |=0x4;
250         }
251         /* set Mono/Stereo in playback/capture register */
252         outb( (inb(devc->base+8) & ~0x3C)|fmt_bits, devc->base+8); 
253         outb( (inb(devc->base+9) & ~0x3C)|fmt_bits, devc->base+9);
254
255         freq=((unsigned int)devc->speed*33000)/ad1816_clockfreq; 
256
257         /* write playback/capture speeds */
258         ad_write (devc, 2, freq & 0xffff);      
259         ad_write (devc, 3, freq & 0xffff);      
260
261         spin_unlock_irqrestore(&devc->lock,flags);
262
263         ad1816_halt_input(dev);
264         return 0;
265 }
266
267 static int ad1816_prepare_for_output (int dev, int bsize, int bcount)
268 {
269         unsigned long flags;
270         unsigned int freq;
271         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
272         unsigned char fmt_bits;
273
274         DEBUGNOISE(printk(KERN_DEBUG "ad1816: prepare_for_output called: bsize=%d bcount=%d\n",bsize,bcount));
275
276         spin_lock_irqsave(&devc->lock,flags);
277
278         fmt_bits= (devc->format_bits&0x7)<<3;
279         /* set mono/stereo mode */
280         if (devc->channels > 1) {
281                 fmt_bits |=0x4;
282         }
283
284         /* write format bits to playback/capture registers */
285         outb( (inb(devc->base+8) & ~0x3C)|fmt_bits, devc->base+8); 
286         outb( (inb(devc->base+9) & ~0x3C)|fmt_bits, devc->base+9);
287   
288         freq=((unsigned int)devc->speed*33000)/ad1816_clockfreq; 
289         
290         /* write playback/capture speeds */
291         ad_write (devc, 2, freq & 0xffff);
292         ad_write (devc, 3, freq & 0xffff);
293
294         spin_unlock_irqrestore(&devc->lock,flags);
295         
296         ad1816_halt_output(dev);
297         return 0;
298
299 }
300
301 static void ad1816_trigger (int dev, int state) 
302 {
303         unsigned long flags;
304         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
305
306         DEBUGNOISE(printk(KERN_DEBUG "ad1816: trigger called! (devc=%d,devc->base=%d\n", devc, devc->base));
307
308         /* mode may have changed */
309
310         spin_lock_irqsave(&devc->lock,flags);
311
312         /* mask out modes not specified on open call */
313         state &= devc->audio_mode; 
314                                 
315         /* setup soundchip to new io-mode */
316         if (state & PCM_ENABLE_INPUT) {
317                 /* enable capture */
318                 outb(inb(devc->base+9)|0x01, devc->base+9);
319         } else {
320                 /* disable capture */
321                 outb(inb(devc->base+9)&~0x01, devc->base+9);
322         }
323
324         if (state & PCM_ENABLE_OUTPUT) {
325                 /* enable playback */
326                 outb(inb(devc->base+8)|0x01, devc->base+8);
327                 /* unmute pcm output */
328                 ad_write(devc, 4, ad_read(devc,4)&~0x8080);
329         } else {
330                 /* mute pcm output */
331                 ad_write(devc, 4, ad_read(devc,4)|0x8080);
332                 /* disable capture */
333                 outb(inb(devc->base+8)&~0x01, devc->base+8);
334         }
335         spin_unlock_irqrestore(&devc->lock,flags);
336 }
337
338
339 /* halt input & output */
340 static void ad1816_halt (int dev)
341 {
342         ad1816_halt_input(dev);
343         ad1816_halt_output(dev);
344 }
345
346 static void ad1816_reset (int dev)
347 {
348         ad1816_halt (dev);
349 }
350
351 /* set playback speed */
352 static int ad1816_set_speed (int dev, int arg)
353 {
354         unsigned long flags;
355         unsigned int freq;
356         int ret;
357
358         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
359         
360         spin_lock_irqsave(&devc->lock, flags);
361         if (arg == 0) {
362                 ret = devc->speed;
363                 spin_unlock_irqrestore(&devc->lock, flags);
364                 return ret;
365         }
366         /* range checking */
367         if (arg < 4000) {
368                 arg = 4000;
369         }
370         if (arg > 55000) {
371                 arg = 55000;
372         }
373         devc->speed = arg;
374
375         /* change speed during playback */
376         freq=((unsigned int)devc->speed*33000)/ad1816_clockfreq; 
377         /* write playback/capture speeds */
378         ad_write (devc, 2, freq & 0xffff);      
379         ad_write (devc, 3, freq & 0xffff);      
380
381         ret = devc->speed;
382         spin_unlock_irqrestore(&devc->lock, flags);
383         return ret;
384
385 }
386
387 static unsigned int ad1816_set_bits (int dev, unsigned int arg)
388 {
389         unsigned long flags;
390         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
391         
392         static struct format_tbl {
393                 int             format;
394                 unsigned char   bits;
395         } format2bits[] = {
396                 { 0, 0 },
397                 { AFMT_MU_LAW, 1 },
398                 { AFMT_A_LAW, 3 },
399                 { AFMT_IMA_ADPCM, 0 },
400                 { AFMT_U8, 0 },
401                 { AFMT_S16_LE, 2 },
402                 { AFMT_S16_BE, 6 },
403                 { AFMT_S8, 0 },
404                 { AFMT_U16_LE, 0 },
405                 { AFMT_U16_BE, 0 }
406         };
407
408         int  i, n = sizeof (format2bits) / sizeof (struct format_tbl);
409
410         spin_lock_irqsave(&devc->lock, flags);
411         /* return current format */
412         if (arg == 0) {
413                 arg = devc->audio_format;
414                 spin_unlock_irqrestore(&devc->lock, flags);
415                 return arg;
416         }
417         devc->audio_format = arg;
418
419         /* search matching format bits */
420         for (i = 0; i < n; i++)
421                 if (format2bits[i].format == arg) {
422                         devc->format_bits = format2bits[i].bits;
423                         devc->audio_format = arg;
424                         spin_unlock_irqrestore(&devc->lock, flags);
425                         return arg;
426                 }
427
428         /* Still hanging here. Something must be terribly wrong */
429         devc->format_bits = 0;
430         devc->audio_format = AFMT_U8;
431         spin_unlock_irqrestore(&devc->lock, flags);
432         return(AFMT_U8); 
433 }
434
435 static short ad1816_set_channels (int dev, short arg)
436 {
437         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
438
439         if (arg != 1 && arg != 2)
440                 return devc->channels;
441
442         devc->channels = arg;
443         return arg;
444 }
445
446 /* open device */
447 static int ad1816_open (int dev, int mode) 
448 {
449         ad1816_info    *devc = NULL;
450         unsigned long   flags;
451
452         /* is device number valid ? */
453         if (dev < 0 || dev >= num_audiodevs)
454                 return -(ENXIO);
455
456         /* get device info of this dev */
457         devc = (ad1816_info *) audio_devs[dev]->devc; 
458
459         /* make check if device already open atomic */
460         spin_lock_irqsave(&devc->lock,flags);
461
462         if (devc->opened) {
463                 spin_unlock_irqrestore(&devc->lock,flags);
464                 return -(EBUSY);
465         }
466
467         /* mark device as open */
468         devc->opened = 1; 
469
470         devc->audio_mode = 0;
471         devc->speed = 8000;
472         devc->audio_format=AFMT_U8;
473         devc->channels=1;
474         spin_unlock_irqrestore(&devc->lock,flags);
475         ad1816_reset(devc->dev_no); /* halt all pending output */
476         return 0;
477 }
478
479 static void ad1816_close (int dev) /* close device */
480 {
481         unsigned long flags;
482         ad1816_info    *devc = (ad1816_info *) audio_devs[dev]->devc;
483
484         /* halt all pending output */
485         ad1816_reset(devc->dev_no); 
486
487         spin_lock_irqsave(&devc->lock,flags);
488         devc->opened = 0;
489         devc->audio_mode = 0;
490         devc->speed = 8000;
491         devc->audio_format=AFMT_U8;
492         devc->format_bits = 0;
493         spin_unlock_irqrestore(&devc->lock,flags);
494 }
495
496
497 /* ------------------------------------------------------------------- */
498
499 /* Audio driver structure */
500
501 static struct audio_driver ad1816_audio_driver =
502 {
503         .owner                  = THIS_MODULE,
504         .open                   = ad1816_open,
505         .close                  = ad1816_close,
506         .output_block           = ad1816_output_block,
507         .start_input            = ad1816_start_input,
508         .prepare_for_input      = ad1816_prepare_for_input,
509         .prepare_for_output     = ad1816_prepare_for_output,
510         .halt_io                = ad1816_halt,
511         .halt_input             = ad1816_halt_input,
512         .halt_output            = ad1816_halt_output,
513         .trigger                = ad1816_trigger,
514         .set_speed              = ad1816_set_speed,
515         .set_bits               = ad1816_set_bits,
516         .set_channels           = ad1816_set_channels,
517 };
518
519
520 /* ------------------------------------------------------------------- */
521
522 /* Interrupt handler */
523
524
525 static irqreturn_t ad1816_interrupt (int irq, void *dev_id, struct pt_regs *dummy)
526 {
527         unsigned char   status;
528         ad1816_info     *devc = (ad1816_info *)dev_id;
529         
530         if (irq < 0 || irq > 15) {
531                 printk(KERN_WARNING "ad1816: Got bogus interrupt %d\n", irq);
532                 return IRQ_NONE;
533         }
534
535         spin_lock(&devc->lock);
536
537         /* read interrupt register */
538         status = inb (devc->base+1); 
539         /* Clear all interrupt  */
540         outb (~status, devc->base+1);   
541
542         DEBUGNOISE(printk(KERN_DEBUG "ad1816: Got interrupt subclass %d\n",status));
543
544         if (status == 0) {
545                 DEBUGNOISE(printk(KERN_DEBUG "ad1816: interrupt: Got interrupt, but no source.\n"));
546                 spin_unlock(&devc->lock);
547                 return IRQ_NONE;
548         }
549
550         if (devc->opened && (devc->audio_mode & PCM_ENABLE_INPUT) && (status&64))
551                 DMAbuf_inputintr (devc->dev_no);
552
553         if (devc->opened && (devc->audio_mode & PCM_ENABLE_OUTPUT) && (status & 128))
554                 DMAbuf_outputintr (devc->dev_no, 1);
555
556         spin_unlock(&devc->lock);
557         return IRQ_HANDLED;
558 }
559
560 /* ------------------------------------------------------------------- */
561
562 /* Mixer stuff */
563
564 struct mixer_def {
565         unsigned int regno: 7;
566         unsigned int polarity:1;        /* 0=normal, 1=reversed */
567         unsigned int bitpos:4;
568         unsigned int nbits:4;
569 };
570
571 static char mix_cvt[101] = {
572          0, 0, 3, 7,10,13,16,19,21,23,26,28,30,32,34,35,37,39,40,42,
573         43,45,46,47,49,50,51,52,53,55,56,57,58,59,60,61,62,63,64,65,
574         65,66,67,68,69,70,70,71,72,73,73,74,75,75,76,77,77,78,79,79,
575         80,81,81,82,82,83,84,84,85,85,86,86,87,87,88,88,89,89,90,90,
576         91,91,92,92,93,93,94,94,95,95,96,96,96,97,97,98,98,98,99,99,
577         100
578 };
579
580 typedef struct mixer_def mixer_ent;
581
582 /*
583  * Most of the mixer entries work in backwards. Setting the polarity field
584  * makes them to work correctly.
585  *
586  * The channel numbering used by individual soundcards is not fixed. Some
587  * cards have assigned different meanings for the AUX1, AUX2 and LINE inputs.
588  * The current version doesn't try to compensate this.
589  */
590
591 #define MIX_ENT(name, reg_l, pola_l, pos_l, len_l, reg_r, pola_r, pos_r, len_r) \
592   {{reg_l, pola_l, pos_l, len_l}, {reg_r, pola_r, pos_r, len_r}}
593
594
595 static mixer_ent mix_devices[SOUND_MIXER_NRDEVICES][2] = {
596 MIX_ENT(SOUND_MIXER_VOLUME,     14, 1, 8, 5,    14, 1, 0, 5),
597 MIX_ENT(SOUND_MIXER_BASS,        0, 0, 0, 0,     0, 0, 0, 0),
598 MIX_ENT(SOUND_MIXER_TREBLE,      0, 0, 0, 0,     0, 0, 0, 0),
599 MIX_ENT(SOUND_MIXER_SYNTH,       5, 1, 8, 6,     5, 1, 0, 6),
600 MIX_ENT(SOUND_MIXER_PCM,         4, 1, 8, 6,     4, 1, 0, 6),
601 MIX_ENT(SOUND_MIXER_SPEAKER,     0, 0, 0, 0,     0, 0, 0, 0),
602 MIX_ENT(SOUND_MIXER_LINE,       18, 1, 8, 5,    18, 1, 0, 5),
603 MIX_ENT(SOUND_MIXER_MIC,        19, 1, 8, 5,    19, 1, 0, 5),
604 MIX_ENT(SOUND_MIXER_CD,         15, 1, 8, 5,    15, 1, 0, 5),
605 MIX_ENT(SOUND_MIXER_IMIX,        0, 0, 0, 0,     0, 0, 0, 0),
606 MIX_ENT(SOUND_MIXER_ALTPCM,      0, 0, 0, 0,     0, 0, 0, 0),
607 MIX_ENT(SOUND_MIXER_RECLEV,     20, 0, 8, 4,    20, 0, 0, 4),
608 MIX_ENT(SOUND_MIXER_IGAIN,       0, 0, 0, 0,     0, 0, 0, 0),
609 MIX_ENT(SOUND_MIXER_OGAIN,       0, 0, 0, 0,     0, 0, 0, 0),
610 MIX_ENT(SOUND_MIXER_LINE1,      17, 1, 8, 5,    17, 1, 0, 5),
611 MIX_ENT(SOUND_MIXER_LINE2,      16, 1, 8, 5,    16, 1, 0, 5),
612 MIX_ENT(SOUND_MIXER_LINE3,      39, 0, 9, 4,    39, 1, 0, 5)
613 };
614
615
616 static unsigned short default_mixer_levels[SOUND_MIXER_NRDEVICES] =
617 {
618         0x4343,         /* Master Volume */
619         0x3232,         /* Bass */
620         0x3232,         /* Treble */
621         0x0000,         /* FM */
622         0x4343,         /* PCM */
623         0x0000,         /* PC Speaker */
624         0x0000,         /* Ext Line */
625         0x0000,         /* Mic */
626         0x0000,         /* CD */
627         0x0000,         /* Recording monitor */
628         0x0000,         /* SB PCM */
629         0x0000,         /* Recording level */
630         0x0000,         /* Input gain */
631         0x0000,         /* Output gain */
632         0x0000,         /* Line1 */
633         0x0000,         /* Line2 */
634         0x0000          /* Line3 (usually line in)*/
635 };
636
637 #define LEFT_CHN        0
638 #define RIGHT_CHN       1
639
640
641
642 static int
643 ad1816_set_recmask (ad1816_info * devc, int mask)
644 {
645         unsigned long   flags;
646         unsigned char   recdev;
647         int             i, n;
648         
649         spin_lock_irqsave(&devc->lock, flags);
650         mask &= devc->supported_rec_devices;
651         
652         n = 0;
653         /* Count selected device bits */
654         for (i = 0; i < 32; i++)
655                 if (mask & (1 << i))
656                         n++;
657         
658         if (n == 0)
659                 mask = SOUND_MASK_MIC;
660         else if (n != 1) { /* Too many devices selected */
661                 /* Filter out active settings */
662                 mask &= ~devc->recmask; 
663                 
664                 n = 0;
665                 /* Count selected device bits */
666                 for (i = 0; i < 32; i++) 
667                         if (mask & (1 << i))
668                                 n++;
669                 
670                 if (n != 1)
671                         mask = SOUND_MASK_MIC;
672         }
673         
674         switch (mask) {
675         case SOUND_MASK_MIC:
676                 recdev = 5;
677                 break;
678                 
679         case SOUND_MASK_LINE:
680                 recdev = 0;
681                 break;
682                 
683         case SOUND_MASK_CD:
684                 recdev = 2;
685                 break;
686                 
687         case SOUND_MASK_LINE1:
688                 recdev = 4;
689                 break;
690                 
691         case SOUND_MASK_LINE2:
692                 recdev = 3;
693                 break;
694                 
695         case SOUND_MASK_VOLUME:
696                 recdev = 1;
697                 break;
698                 
699         default:
700                 mask = SOUND_MASK_MIC;
701                 recdev = 5;
702         }
703         
704         recdev <<= 4;
705         ad_write (devc, 20, 
706                   (ad_read (devc, 20) & 0x8f8f) | recdev | (recdev<<8));
707
708         devc->recmask = mask;
709         spin_unlock_irqrestore(&devc->lock, flags);
710         return mask;
711 }
712
713 static void
714 change_bits (int *regval, int dev, int chn, int newval)
715 {
716         unsigned char   mask;
717         int             shift;
718   
719         /* Reverse polarity*/
720
721         if (mix_devices[dev][chn].polarity == 1) 
722                 newval = 100 - newval;
723
724         mask = (1 << mix_devices[dev][chn].nbits) - 1;
725         shift = mix_devices[dev][chn].bitpos;
726         /* Scale it */
727         newval = (int) ((newval * mask) + 50) / 100;    
728         /* Clear bits */
729         *regval &= ~(mask << shift);    
730         /* Set new value */
731         *regval |= (newval & mask) << shift;    
732 }
733
734 static int
735 ad1816_mixer_get (ad1816_info * devc, int dev)
736 {
737         DEBUGNOISE(printk(KERN_DEBUG "ad1816: mixer_get called!\n"));
738         
739         /* range check + supported mixer check */
740         if (dev < 0 || dev >= SOUND_MIXER_NRDEVICES )
741                 return (-(EINVAL));
742         if (!((1 << dev) & devc->supported_devices))
743                 return -(EINVAL);
744         
745         return devc->levels[dev];
746 }
747
748 static int
749 ad1816_mixer_set (ad1816_info * devc, int dev, int value)
750 {
751         int   left = value & 0x000000ff;
752         int   right = (value & 0x0000ff00) >> 8;
753         int   retvol;
754
755         int   regoffs;
756         int   val;
757         int   valmute;
758         unsigned long flags;
759
760         DEBUGNOISE(printk(KERN_DEBUG "ad1816: mixer_set called!\n"));
761         
762         if (dev < 0 || dev >= SOUND_MIXER_NRDEVICES )
763                 return -(EINVAL);
764
765         if (left > 100)
766                 left = 100;
767         if (left < 0)
768                 left = 0;
769         if (right > 100)
770                 right = 100;
771         if (right < 0)
772                 right = 0;
773         
774         /* Mono control */
775         if (mix_devices[dev][RIGHT_CHN].nbits == 0) 
776                 right = left;
777         retvol = left | (right << 8);
778         
779         /* Scale it */
780         
781         left = mix_cvt[left];
782         right = mix_cvt[right];
783
784         /* reject all mixers that are not supported */
785         if (!(devc->supported_devices & (1 << dev)))
786                 return -(EINVAL);
787         
788         /* sanity check */
789         if (mix_devices[dev][LEFT_CHN].nbits == 0)
790                 return -(EINVAL);
791         spin_lock_irqsave(&devc->lock, flags);
792
793         /* keep precise volume internal */
794         devc->levels[dev] = retvol;
795
796         /* Set the left channel */
797         regoffs = mix_devices[dev][LEFT_CHN].regno;
798         val = ad_read (devc, regoffs);
799         change_bits (&val, dev, LEFT_CHN, left);
800
801         valmute=val;
802
803         /* Mute bit masking on some registers */
804         if ( regoffs==5 || regoffs==14 || regoffs==15 ||
805              regoffs==16 || regoffs==17 || regoffs==18 || 
806              regoffs==19 || regoffs==39) {
807                 if (left==0)
808                         valmute |= 0x8000;
809                 else
810                         valmute &= ~0x8000;
811         }
812         ad_write (devc, regoffs, valmute); /* mute */
813
814         /*
815          * Set the right channel
816          */
817  
818         /* Was just a mono channel */
819         if (mix_devices[dev][RIGHT_CHN].nbits == 0) {
820                 spin_unlock_irqrestore(&devc->lock, flags);
821                 return retvol;          
822         }
823
824         regoffs = mix_devices[dev][RIGHT_CHN].regno;
825         val = ad_read (devc, regoffs);
826         change_bits (&val, dev, RIGHT_CHN, right);
827
828         valmute=val;
829         if ( regoffs==5 || regoffs==14 || regoffs==15 ||
830              regoffs==16 || regoffs==17 || regoffs==18 || 
831              regoffs==19 || regoffs==39) {
832                 if (right==0)
833                         valmute |= 0x80;
834                 else
835                         valmute &= ~0x80;
836         }
837         ad_write (devc, regoffs, valmute); /* mute */
838         spin_unlock_irqrestore(&devc->lock, flags);
839         return retvol;
840 }
841
842 #define MIXER_DEVICES ( SOUND_MASK_VOLUME | \
843                         SOUND_MASK_SYNTH | \
844                         SOUND_MASK_PCM | \
845                         SOUND_MASK_LINE | \
846                         SOUND_MASK_LINE1 | \
847                         SOUND_MASK_LINE2 | \
848                         SOUND_MASK_LINE3 | \
849                         SOUND_MASK_MIC | \
850                         SOUND_MASK_CD | \
851                         SOUND_MASK_RECLEV  \
852                         )
853 #define REC_DEVICES ( SOUND_MASK_LINE2 |\
854                       SOUND_MASK_LINE |\
855                       SOUND_MASK_LINE1 |\
856                       SOUND_MASK_MIC |\
857                       SOUND_MASK_CD |\
858                       SOUND_MASK_VOLUME \
859                       )
860      
861 static void
862 ad1816_mixer_reset (ad1816_info * devc)
863 {
864         int  i;
865
866         devc->supported_devices = MIXER_DEVICES;
867         
868         devc->supported_rec_devices = REC_DEVICES;
869
870         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
871                 if (devc->supported_devices & (1 << i))
872                         ad1816_mixer_set (devc, i, default_mixer_levels[i]);
873         ad1816_set_recmask (devc, SOUND_MASK_MIC);
874 }
875
876 static int
877 ad1816_mixer_ioctl (int dev, unsigned int cmd, void __user * arg)
878 {
879         ad1816_info    *devc = mixer_devs[dev]->devc;
880         int val;
881         int __user *p = arg;
882   
883         DEBUGNOISE(printk(KERN_DEBUG "ad1816: mixer_ioctl called!\n"));
884   
885         /* Mixer ioctl */
886         if (((cmd >> 8) & 0xff) == 'M') { 
887                 
888                 /* set ioctl */
889                 if (_SIOC_DIR (cmd) & _SIOC_WRITE) { 
890                         switch (cmd & 0xff){
891                         case SOUND_MIXER_RECSRC:
892                                 
893                                 if (get_user(val, p))
894                                         return -EFAULT;
895                                 val=ad1816_set_recmask (devc, val);
896                                 return put_user(val, p);
897                                 break;
898                                 
899                         default:
900                                 if (get_user(val, p))
901                                         return -EFAULT;
902                                 if ((val=ad1816_mixer_set (devc, cmd & 0xff, val))<0)
903                                         return val;
904                                 else
905                                         return put_user(val, p);
906                         }
907                 } else { 
908                         /* read ioctl */
909                         switch (cmd & 0xff) {
910                                 
911                         case SOUND_MIXER_RECSRC:
912                                 val=devc->recmask;
913                                 return put_user(val, p);
914                                 break;
915                                 
916                         case SOUND_MIXER_DEVMASK:
917                                 val=devc->supported_devices;
918                                 return put_user(val, p);
919                                 break;
920
921                         case SOUND_MIXER_STEREODEVS:
922                                 val=devc->supported_devices & ~(SOUND_MASK_SPEAKER | SOUND_MASK_IMIX);
923                                 return put_user(val, p);
924                                 break;
925                                 
926                         case SOUND_MIXER_RECMASK:
927                                 val=devc->supported_rec_devices;
928                                 return put_user(val, p);
929                                 break;
930                                 
931                         case SOUND_MIXER_CAPS:
932                                 val=SOUND_CAP_EXCL_INPUT;
933                                 return put_user(val, p);
934                                 break;
935                                 
936                         default:
937                                 if ((val=ad1816_mixer_get (devc, cmd & 0xff))<0)
938                                         return val;
939                                 else
940                                         return put_user(val, p);
941                         }
942                 }
943         } else
944                 /* not for mixer */
945                 return -(EINVAL);
946 }
947
948 /* ------------------------------------------------------------------- */
949
950 /* Mixer structure */
951
952 static struct mixer_operations ad1816_mixer_operations = {
953         .owner  = THIS_MODULE,
954         .id     = "AD1816",
955         .name   = "AD1816 Mixer",
956         .ioctl  = ad1816_mixer_ioctl
957 };
958
959
960 /* ------------------------------------------------------------------- */
961
962 /* stuff for card recognition, init and unloading PNP ...*/
963
964
965 /* check if AD1816 present at specified hw_config and register device with OS 
966  * return 1 if initialization was successful, 0 otherwise
967  */
968 static int __init ad1816_init_card (struct address_info *hw_config, 
969         struct pnp_dev *pnp)
970 {
971         ad1816_info    *devc = NULL;
972         int tmp;
973         int oss_devno = -1;
974
975         printk(KERN_INFO "ad1816: initializing card: io=0x%x, irq=%d, dma=%d, "
976                          "dma2=%d, clockfreq=%d, options=%d isadmabug=%d "
977                          "%s\n",
978                hw_config->io_base,
979                hw_config->irq,
980                hw_config->dma,
981                hw_config->dma2,
982                ad1816_clockfreq,
983                options,
984                isa_dma_bridge_buggy,
985                pnp?"(PNP)":"");
986
987         /* ad1816_info structure remaining ? */
988         if (nr_ad1816_devs >= MAX_AUDIO_DEV) {
989                 printk(KERN_WARNING "ad1816: no more ad1816_info structures "
990                         "left\n");
991                 goto out;
992         }
993
994         devc = &dev_info[nr_ad1816_devs];
995         devc->base = hw_config->io_base;
996         devc->irq = hw_config->irq;
997         devc->dma_playback=hw_config->dma;
998         devc->dma_capture=hw_config->dma2;
999         devc->opened = 0;
1000         devc->pnpdev = pnp;
1001         spin_lock_init(&devc->lock);
1002
1003         if (!request_region(devc->base, 16, "AD1816 Sound")) {
1004                 printk(KERN_WARNING "ad1816: I/O port 0x%03x not free\n",
1005                                     devc->base);
1006                 goto out;
1007         }
1008
1009         printk(KERN_INFO "ad1816: Examining AD1816 at address 0x%03x.\n", 
1010                 devc->base);
1011         
1012
1013         /* tests for ad1816 */
1014         /* base+0: bit 1 must be set but not 255 */
1015         tmp=inb(devc->base);
1016         if ( (tmp&0x80)==0 || tmp==255 ) {
1017                 printk (KERN_INFO "ad1816: Chip is not an AD1816 or chip "
1018                         "is not active (Test 0)\n");
1019                 goto out_release_region;
1020         }
1021
1022         /* writes to ireg 8 are copied to ireg 9 */
1023         ad_write(devc,8,12345); 
1024         if (ad_read(devc,9)!=12345) {
1025                 printk(KERN_INFO "ad1816: Chip is not an AD1816 (Test 1)\n");
1026                 goto out_release_region;
1027         }
1028   
1029         /* writes to ireg 8 are copied to ireg 9 */
1030         ad_write(devc,8,54321); 
1031         if (ad_read(devc,9)!=54321) {
1032                 printk(KERN_INFO "ad1816: Chip is not an AD1816 (Test 2)\n");
1033                 goto out_release_region;
1034         }
1035
1036         /* writes to ireg 10 are copied to ireg 11 */
1037         ad_write(devc,10,54321); 
1038         if (ad_read(devc,11)!=54321) {
1039                 printk (KERN_INFO "ad1816: Chip is not an AD1816 (Test 3)\n");
1040                 goto out_release_region;
1041         }
1042
1043         /* writes to ireg 10 are copied to ireg 11 */
1044         ad_write(devc,10,12345); 
1045         if (ad_read(devc,11)!=12345) {
1046                 printk (KERN_INFO "ad1816: Chip is not an AD1816 (Test 4)\n");
1047                 goto out_release_region;
1048         }
1049
1050         /* bit in base +1 cannot be set to 1 */
1051         tmp=inb(devc->base+1);
1052         outb(0xff,devc->base+1); 
1053         if (inb(devc->base+1)!=tmp) {
1054                 printk(KERN_INFO "ad1816: Chip is not an AD1816 (Test 5)\n");
1055                 goto out_release_region;
1056         }
1057   
1058         printk(KERN_INFO "ad1816: AD1816 (version %d) successfully detected!\n",
1059                 ad_read(devc,45));
1060
1061         /* disable all interrupts */
1062         ad_write(devc,1,0);     
1063
1064         /* Clear pending interrupts */
1065         outb (0, devc->base+1); 
1066
1067         /* allocate irq */
1068         if (devc->irq < 0 || devc->irq > 15)
1069                 goto out_release_region;
1070         if (request_irq(devc->irq, ad1816_interrupt,0,
1071                         "SoundPort", devc) < 0) {
1072                 printk(KERN_WARNING "ad1816: IRQ in use\n");
1073                 goto out_release_region;
1074         }
1075
1076         /* DMA stuff */
1077         if (sound_alloc_dma (devc->dma_playback, "Sound System")) {
1078                 printk(KERN_WARNING "ad1816: Can't allocate DMA%d\n",
1079                                     devc->dma_playback);
1080                 goto out_free_irq;
1081         }
1082         
1083         if ( devc->dma_capture >= 0 && 
1084                 devc->dma_capture != devc->dma_playback) {
1085                 if (sound_alloc_dma(devc->dma_capture,
1086                                     "Sound System (capture)")) {
1087                         printk(KERN_WARNING "ad1816: Can't allocate DMA%d\n",
1088                                             devc->dma_capture);
1089                         goto out_free_dma;
1090                 }
1091                 devc->audio_mode=DMA_AUTOMODE|DMA_DUPLEX;
1092         } else {
1093                 printk(KERN_WARNING "ad1816: Only one DMA channel "
1094                         "available/configured. No duplex operation possible\n");
1095                 devc->audio_mode=DMA_AUTOMODE;
1096         }
1097
1098         conf_printf2 ("AD1816 audio driver",
1099                       devc->base, devc->irq, devc->dma_playback, 
1100                       devc->dma_capture);
1101
1102         /* register device */
1103         if ((oss_devno = sound_install_audiodrv (AUDIO_DRIVER_VERSION,
1104                                               "AD1816 audio driver",
1105                                               &ad1816_audio_driver,
1106                                               sizeof (struct audio_driver),
1107                                               devc->audio_mode,
1108                                               ad_format_mask,
1109                                               devc,
1110                                               devc->dma_playback, 
1111                                               devc->dma_capture)) < 0) {
1112                 printk(KERN_WARNING "ad1816: Can't install sound driver\n");
1113                 goto out_free_dma_2;
1114         }
1115
1116
1117         ad_write(devc,32,0x80f0); /* sound system mode */
1118         if (options&1) {
1119                 ad_write(devc,33,0); /* disable all audiosources for dsp */
1120         } else {
1121                 ad_write(devc,33,0x03f8); /* enable all audiosources for dsp */
1122         }
1123         ad_write(devc,4,0x8080);  /* default values for volumes (muted)*/
1124         ad_write(devc,5,0x8080);
1125         ad_write(devc,6,0x8080);
1126         ad_write(devc,7,0x8080);
1127         ad_write(devc,15,0x8888);
1128         ad_write(devc,16,0x8888);
1129         ad_write(devc,17,0x8888);
1130         ad_write(devc,18,0x8888);
1131         ad_write(devc,19,0xc888); /* +20db mic active */
1132         ad_write(devc,14,0x0000); /* Master volume unmuted */
1133         ad_write(devc,39,0x009f); /* 3D effect on 0% phone out muted */
1134         ad_write(devc,44,0x0080); /* everything on power, 3d enabled for d/a */
1135         outb(0x10,devc->base+8); /* set dma mode */
1136         outb(0x10,devc->base+9);
1137   
1138         /* enable capture + playback interrupt */
1139         ad_write(devc,1,0xc000); 
1140         
1141         /* set mixer defaults */
1142         ad1816_mixer_reset (devc); 
1143   
1144         /* register mixer */
1145         if ((audio_devs[oss_devno]->mixer_dev=sound_install_mixer(
1146                                        MIXER_DRIVER_VERSION,
1147                                        "AD1816 audio driver",
1148                                        &ad1816_mixer_operations,
1149                                        sizeof (struct mixer_operations),
1150                                        devc)) < 0) {
1151                 printk(KERN_WARNING "Can't install mixer\n");
1152         }
1153         /* make ad1816_info active */
1154         nr_ad1816_devs++;
1155         printk(KERN_INFO "ad1816: card successfully installed!\n");
1156         return 1;
1157         /* error handling */
1158 out_free_dma_2:
1159         if (devc->dma_capture >= 0 && devc->dma_capture != devc->dma_playback)
1160                 sound_free_dma(devc->dma_capture);
1161 out_free_dma:
1162         sound_free_dma(devc->dma_playback);
1163 out_free_irq:
1164         free_irq(devc->irq, devc);
1165 out_release_region:
1166         release_region(devc->base, 16);
1167 out:
1168         return 0;
1169 }
1170
1171 static void __exit unload_card(ad1816_info *devc)
1172 {
1173         int  mixer, dev = 0;
1174         
1175         if (devc != NULL) {
1176                 printk("ad1816: Unloading card at address 0x%03x\n",devc->base);
1177                 
1178                 dev = devc->dev_no;
1179                 mixer = audio_devs[dev]->mixer_dev;
1180
1181                 /* unreg mixer*/
1182                 if(mixer>=0) {
1183                         sound_unload_mixerdev(mixer);
1184                 }
1185                 /* unreg audiodev */
1186                 sound_unload_audiodev(dev);
1187                 
1188                 /* free dma channels */
1189                 if (devc->dma_capture>=0 && 
1190                         devc->dma_capture != devc->dma_playback) {
1191                         sound_free_dma(devc->dma_capture);
1192                 }
1193                 sound_free_dma (devc->dma_playback);
1194                 /* free irq */
1195                 free_irq(devc->irq, devc);
1196                 /* free io */
1197                 release_region (devc->base, 16);
1198 #ifdef __ISAPNP__
1199                 if (devc->pnpdev) {
1200                         pnp_disable_dev(devc->pnpdev);
1201                         pnp_device_detach(devc->pnpdev);
1202                 }
1203 #endif
1204                 
1205         } else
1206                 printk(KERN_WARNING "ad1816: no device/card specified\n");
1207 }
1208
1209 static int __initdata io = -1;
1210 static int __initdata irq = -1;
1211 static int __initdata dma = -1;
1212 static int __initdata dma2 = -1;
1213
1214 #ifdef __ISAPNP__
1215 /* use isapnp for configuration */
1216 static int isapnp       = 1;
1217 static int isapnpjump;
1218 module_param(isapnp, bool, 0);
1219 module_param(isapnpjump, int, 0);
1220 #endif
1221
1222 module_param(io, int, 0);
1223 module_param(irq, int, 0);
1224 module_param(dma, int, 0);
1225 module_param(dma2, int, 0);
1226 module_param(ad1816_clockfreq, int, 0);
1227 module_param(options, int, 0);
1228
1229 #ifdef __ISAPNP__
1230 static struct {
1231         unsigned short card_vendor, card_device;
1232         unsigned short vendor;
1233         unsigned short function;
1234         struct ad1816_data *data;
1235 } isapnp_ad1816_list[] __initdata = {
1236         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
1237                 ISAPNP_VENDOR('A','D','S'), ISAPNP_FUNCTION(0x7150), 
1238                 NULL },
1239         {       ISAPNP_ANY_ID, ISAPNP_ANY_ID,
1240                 ISAPNP_VENDOR('A','D','S'), ISAPNP_FUNCTION(0x7180),
1241                 NULL },
1242         {0}
1243 };
1244
1245 MODULE_DEVICE_TABLE(isapnp, isapnp_ad1816_list);
1246
1247
1248 static void __init ad1816_config_pnp_card(struct pnp_card *card,
1249                                           unsigned short vendor,
1250                                           unsigned short function)
1251 {
1252         struct address_info cfg;
1253         struct pnp_dev *card_dev = pnp_find_dev(card, vendor, function, NULL);
1254         if (!card_dev) return;
1255         if (pnp_device_attach(card_dev) < 0) {
1256                 printk(KERN_WARNING "ad1816: Failed to attach PnP device\n");
1257                 return;
1258         }
1259         if (pnp_activate_dev(card_dev) < 0) {
1260                 printk(KERN_WARNING "ad1816: Failed to activate PnP device\n");
1261                 pnp_device_detach(card_dev);
1262                 return;
1263         }
1264         cfg.io_base = pnp_port_start(card_dev, 2);
1265         cfg.irq = pnp_irq(card_dev, 0);
1266         cfg.dma = pnp_irq(card_dev, 0);
1267         cfg.dma2 = pnp_irq(card_dev, 1);
1268         if (!ad1816_init_card(&cfg, card_dev)) {
1269                 pnp_disable_dev(card_dev);
1270                 pnp_device_detach(card_dev);
1271         }
1272 }
1273
1274 static void __init ad1816_config_pnp_cards(void)
1275 {
1276         int nr_pnp_cfg;
1277         int i;
1278         
1279         /* Count entries in isapnp_ad1816_list */
1280         for (nr_pnp_cfg = 0; isapnp_ad1816_list[nr_pnp_cfg].card_vendor != 0; 
1281                 nr_pnp_cfg++);
1282         /* Check and adjust isapnpjump */
1283         if( isapnpjump < 0 || isapnpjump >= nr_pnp_cfg) {
1284                 printk(KERN_WARNING 
1285                         "ad1816: Valid range for isapnpjump is 0-%d. "
1286                         "Adjusted to 0.\n", nr_pnp_cfg-1);
1287                 isapnpjump = 0;
1288         }
1289         for (i = isapnpjump; isapnp_ad1816_list[i].card_vendor != 0; i++) {
1290                 struct pnp_card *card = NULL;
1291                 /* iterate over all pnp cards */                
1292                 while ((card = pnp_find_card(isapnp_ad1816_list[i].card_vendor,
1293                                 isapnp_ad1816_list[i].card_device, card))) 
1294                         ad1816_config_pnp_card(card, 
1295                                 isapnp_ad1816_list[i].vendor,
1296                                 isapnp_ad1816_list[i].function);
1297         }
1298 }
1299 #endif
1300
1301 /* module initialization */
1302 static int __init init_ad1816(void)
1303 {
1304         printk(KERN_INFO "ad1816: AD1816 sounddriver "
1305                          "Copyright (C) 1998-2003 by Thorsten Knabe and "
1306                          "others\n");
1307 #ifdef AD1816_CLOCK 
1308         /* set ad1816_clockfreq if set during compilation */
1309         ad1816_clockfreq=AD1816_CLOCK;
1310 #endif
1311         if (ad1816_clockfreq<5000 || ad1816_clockfreq>100000) {
1312                 ad1816_clockfreq=33000;
1313         }
1314
1315 #ifdef __ISAPNP__
1316         /* configure PnP cards */
1317         if(isapnp) ad1816_config_pnp_cards();
1318 #endif
1319         /* configure card by module params */
1320         if (io != -1 && irq != -1 && dma != -1) {
1321                 struct address_info cfg;
1322                 cfg.io_base = io;
1323                 cfg.irq = irq;
1324                 cfg.dma = dma;
1325                 cfg.dma2 = dma2;
1326                 ad1816_init_card(&cfg, NULL);
1327         }
1328         if (nr_ad1816_devs <= 0)
1329                 return -ENODEV;
1330         return 0;
1331 }
1332
1333 /* module cleanup */
1334 static void __exit cleanup_ad1816 (void)
1335 {
1336         int          i;
1337         ad1816_info  *devc = NULL;
1338   
1339         /* remove any soundcard */
1340         for (i = 0;  i < nr_ad1816_devs; i++) {
1341                 devc = &dev_info[i];
1342                 unload_card(devc);
1343         }     
1344         nr_ad1816_devs=0;
1345         printk(KERN_INFO "ad1816: driver unloaded!\n");
1346 }
1347
1348 module_init(init_ad1816);
1349 module_exit(cleanup_ad1816);
1350
1351 #ifndef MODULE
1352 /* kernel command line parameter evaluation */
1353 static int __init setup_ad1816(char *str)
1354 {
1355         /* io, irq, dma, dma2 */
1356         int ints[5];
1357         
1358         str = get_options(str, ARRAY_SIZE(ints), ints);
1359         
1360         io      = ints[1];
1361         irq     = ints[2];
1362         dma     = ints[3];
1363         dma2    = ints[4];
1364         return 1;
1365 }
1366
1367 __setup("ad1816=", setup_ad1816);
1368 #endif
1369 MODULE_LICENSE("GPL");