?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / sound / oss / ad1816.c
blob22dae5d0fda3f392f787b46cc5f0fc943fdc4207
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 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");
Verdex Pro support