?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
writeback: split writeback_inodes_wb
[linux-2.6/next.git] / sound / oss / waveartist.c
blobe688dde6bbdeb0b54ae26c761eaba38b1ede5a95
1 /*
2 * linux/sound/oss/waveartist.c
3 *
4 * The low level driver for the RWA010 Rockwell Wave Artist
5 * codec chip used in the Rebel.com NetWinder.
6 *
7 * Cleaned up and integrated into 2.1 by Russell King (rmk@arm.linux.org.uk)
8 * and Pat Beirne (patb@corel.ca)
9 *
10 *
11 * Copyright (C) by Rebel.com 1998-1999
12 *
13 * RWA010 specs received under NDA from Rockwell
14 *
15 * Copyright (C) by Hannu Savolainen 1993-1997
16 *
17 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
18 * Version 2 (June 1991). See the "COPYING" file distributed with this software
19 * for more info.
20 *
21 * Changes:
22 * 11-10-2000 Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
23 * Added __init to waveartist_init()
24 */
25
26 /* Debugging */
27 #define DEBUG_CMD 1
28 #define DEBUG_OUT 2
29 #define DEBUG_IN 4
30 #define DEBUG_INTR 8
31 #define DEBUG_MIXER 16
32 #define DEBUG_TRIGGER 32
33
34 #define debug_flg (0)
35
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/slab.h>
39 #include <linux/sched.h>
40 #include <linux/interrupt.h>
41 #include <linux/delay.h>
42 #include <linux/spinlock.h>
43 #include <linux/bitops.h>
44
45 #include <asm/system.h>
46
47 #include "sound_config.h"
48 #include "waveartist.h"
49
50 #ifdef CONFIG_ARM
51 #include <mach/hardware.h>
52 #include <asm/mach-types.h>
53 #endif
54
55 #ifndef NO_DMA
56 #define NO_DMA 255
57 #endif
58
59 #define SUPPORTED_MIXER_DEVICES (SOUND_MASK_SYNTH |\
60 SOUND_MASK_PCM |\
61 SOUND_MASK_LINE |\
62 SOUND_MASK_MIC |\
63 SOUND_MASK_LINE1 |\
64 SOUND_MASK_RECLEV |\
65 SOUND_MASK_VOLUME |\
66 SOUND_MASK_IMIX)
67
68 static unsigned short levels[SOUND_MIXER_NRDEVICES] = {
69 0x5555, /* Master Volume */
70 0x0000, /* Bass */
71 0x0000, /* Treble */
72 0x2323, /* Synth (FM) */
73 0x4b4b, /* PCM */
74 0x6464, /* PC Speaker */
75 0x0000, /* Ext Line */
76 0x0000, /* Mic */
77 0x0000, /* CD */
78 0x6464, /* Recording monitor */
79 0x0000, /* SB PCM (ALT PCM) */
80 0x0000, /* Recording level */
81 0x6464, /* Input gain */
82 0x6464, /* Output gain */
83 0x0000, /* Line1 (Aux1) */
84 0x0000, /* Line2 (Aux2) */
85 0x0000, /* Line3 (Aux3) */
86 0x0000, /* Digital1 */
87 0x0000, /* Digital2 */
88 0x0000, /* Digital3 */
89 0x0000, /* Phone In */
90 0x6464, /* Phone Out */
91 0x0000, /* Video */
92 0x0000, /* Radio */
93 0x0000 /* Monitor */
94 };
95
96 typedef struct {
97 struct address_info hw; /* hardware */
98 char *chip_name;
99
100 int xfer_count;
101 int audio_mode;
102 int open_mode;
103 int audio_flags;
104 int record_dev;
105 int playback_dev;
106 int dev_no;
107
108 /* Mixer parameters */
109 const struct waveartist_mixer_info *mix;
110
111 unsigned short *levels; /* cache of volume settings */
112 int recmask; /* currently enabled recording device! */
113
114 #ifdef CONFIG_ARCH_NETWINDER
115 signed int slider_vol; /* hardware slider volume */
116 unsigned int handset_detect :1;
117 unsigned int telephone_detect:1;
118 unsigned int no_autoselect :1;/* handset/telephone autoselects a path */
119 unsigned int spkr_mute_state :1;/* set by ioctl or autoselect */
120 unsigned int line_mute_state :1;/* set by ioctl or autoselect */
121 unsigned int use_slider :1;/* use slider setting for o/p vol */
122 #endif
123 } wavnc_info;
124
125 /*
126 * This is the implementation specific mixer information.
127 */
128 struct waveartist_mixer_info {
129 unsigned int supported_devs; /* Supported devices */
130 unsigned int recording_devs; /* Recordable devies */
131 unsigned int stereo_devs; /* Stereo devices */
132
133 unsigned int (*select_input)(wavnc_info *, unsigned int,
134 unsigned char *, unsigned char *);
135 int (*decode_mixer)(wavnc_info *, int,
136 unsigned char, unsigned char);
137 int (*get_mixer)(wavnc_info *, int);
138 };
139
140 typedef struct wavnc_port_info {
141 int open_mode;
142 int speed;
143 int channels;
144 int audio_format;
145 } wavnc_port_info;
146
147 static int nr_waveartist_devs;
148 static wavnc_info adev_info[MAX_AUDIO_DEV];
149 static DEFINE_SPINLOCK(waveartist_lock);
150
151 #ifndef CONFIG_ARCH_NETWINDER
152 #define machine_is_netwinder() 0
153 #else
154 static struct timer_list vnc_timer;
155 static void vnc_configure_mixer(wavnc_info *devc, unsigned int input_mask);
156 static int vnc_private_ioctl(int dev, unsigned int cmd, int __user *arg);
157 static void vnc_slider_tick(unsigned long data);
158 #endif
159
160 static inline void
161 waveartist_set_ctlr(struct address_info *hw, unsigned char clear, unsigned char set)
162 {
163 unsigned int ctlr_port = hw->io_base + CTLR;
164
165 clear = ~clear & inb(ctlr_port);
166
167 outb(clear | set, ctlr_port);
168 }
169
170 /* Toggle IRQ acknowledge line
171 */
172 static inline void
173 waveartist_iack(wavnc_info *devc)
174 {
175 unsigned int ctlr_port = devc->hw.io_base + CTLR;
176 int old_ctlr;
177
178 old_ctlr = inb(ctlr_port) & ~IRQ_ACK;
179
180 outb(old_ctlr | IRQ_ACK, ctlr_port);
181 outb(old_ctlr, ctlr_port);
182 }
183
184 static inline int
185 waveartist_sleep(int timeout_ms)
186 {
187 unsigned int timeout = timeout_ms * 10 * HZ / 100;
188
189 do {
190 set_current_state(TASK_INTERRUPTIBLE);
191 timeout = schedule_timeout(timeout);
192 } while (timeout);
193
194 return 0;
195 }
196
197 static int
198 waveartist_reset(wavnc_info *devc)
199 {
200 struct address_info *hw = &devc->hw;
201 unsigned int timeout, res = -1;
202
203 waveartist_set_ctlr(hw, -1, RESET);
204 waveartist_sleep(2);
205 waveartist_set_ctlr(hw, RESET, 0);
206
207 timeout = 500;
208 do {
209 mdelay(2);
210
211 if (inb(hw->io_base + STATR) & CMD_RF) {
212 res = inw(hw->io_base + CMDR);
213 if (res == 0x55aa)
214 break;
215 }
216 } while (--timeout);
217
218 if (timeout == 0) {
219 printk(KERN_WARNING "WaveArtist: reset timeout ");
220 if (res != (unsigned int)-1)
221 printk("(res=%04X)", res);
222 printk("\n");
223 return 1;
224 }
225 return 0;
226 }
227
228 /* Helper function to send and receive words
229 * from WaveArtist. It handles all the handshaking
230 * and can send or receive multiple words.
231 */
232 static int
233 waveartist_cmd(wavnc_info *devc,
234 int nr_cmd, unsigned int *cmd,
235 int nr_resp, unsigned int *resp)
236 {
237 unsigned int io_base = devc->hw.io_base;
238 unsigned int timed_out = 0;
239 unsigned int i;
240
241 if (debug_flg & DEBUG_CMD) {
242 printk("waveartist_cmd: cmd=");
243
244 for (i = 0; i < nr_cmd; i++)
245 printk("%04X ", cmd[i]);
246
247 printk("\n");
248 }
249
250 if (inb(io_base + STATR) & CMD_RF) {
251 int old_data;
252
253 /* flush the port
254 */
255
256 old_data = inw(io_base + CMDR);
257
258 if (debug_flg & DEBUG_CMD)
259 printk("flushed %04X...", old_data);
260
261 udelay(10);
262 }
263
264 for (i = 0; !timed_out && i < nr_cmd; i++) {
265 int count;
266
267 for (count = 5000; count; count--)
268 if (inb(io_base + STATR) & CMD_WE)
269 break;
270
271 if (!count)
272 timed_out = 1;
273 else
274 outw(cmd[i], io_base + CMDR);
275 }
276
277 for (i = 0; !timed_out && i < nr_resp; i++) {
278 int count;
279
280 for (count = 5000; count; count--)
281 if (inb(io_base + STATR) & CMD_RF)
282 break;
283
284 if (!count)
285 timed_out = 1;
286 else
287 resp[i] = inw(io_base + CMDR);
288 }
289
290 if (debug_flg & DEBUG_CMD) {
291 if (!timed_out) {
292 printk("waveartist_cmd: resp=");
293
294 for (i = 0; i < nr_resp; i++)
295 printk("%04X ", resp[i]);
296
297 printk("\n");
298 } else
299 printk("waveartist_cmd: timed out\n");
300 }
301
302 return timed_out ? 1 : 0;
303 }
304
305 /*
306 * Send one command word
307 */
308 static inline int
309 waveartist_cmd1(wavnc_info *devc, unsigned int cmd)
310 {
311 return waveartist_cmd(devc, 1, &cmd, 0, NULL);
312 }
313
314 /*
315 * Send one command, receive one word
316 */
317 static inline unsigned int
318 waveartist_cmd1_r(wavnc_info *devc, unsigned int cmd)
319 {
320 unsigned int ret;
321
322 waveartist_cmd(devc, 1, &cmd, 1, &ret);
323
324 return ret;
325 }
326
327 /*
328 * Send a double command, receive one
329 * word (and throw it away)
330 */
331 static inline int
332 waveartist_cmd2(wavnc_info *devc, unsigned int cmd, unsigned int arg)
333 {
334 unsigned int vals[2];
335
336 vals[0] = cmd;
337 vals[1] = arg;
338
339 return waveartist_cmd(devc, 2, vals, 1, vals);
340 }
341
342 /*
343 * Send a triple command
344 */
345 static inline int
346 waveartist_cmd3(wavnc_info *devc, unsigned int cmd,
347 unsigned int arg1, unsigned int arg2)
348 {
349 unsigned int vals[3];
350
351 vals[0] = cmd;
352 vals[1] = arg1;
353 vals[2] = arg2;
354
355 return waveartist_cmd(devc, 3, vals, 0, NULL);
356 }
357
358 static int
359 waveartist_getrev(wavnc_info *devc, char *rev)
360 {
361 unsigned int temp[2];
362 unsigned int cmd = WACMD_GETREV;
363
364 waveartist_cmd(devc, 1, &cmd, 2, temp);
365
366 rev[0] = temp[0] >> 8;
367 rev[1] = temp[0] & 255;
368 rev[2] = '\0';
369
370 return temp[0];
371 }
372
373 static void waveartist_halt_output(int dev);
374 static void waveartist_halt_input(int dev);
375 static void waveartist_halt(int dev);
376 static void waveartist_trigger(int dev, int state);
377
378 static int
379 waveartist_open(int dev, int mode)
380 {
381 wavnc_info *devc;
382 wavnc_port_info *portc;
383 unsigned long flags;
384
385 if (dev < 0 || dev >= num_audiodevs)
386 return -ENXIO;
387
388 devc = (wavnc_info *) audio_devs[dev]->devc;
389 portc = (wavnc_port_info *) audio_devs[dev]->portc;
390
391 spin_lock_irqsave(&waveartist_lock, flags);
392 if (portc->open_mode || (devc->open_mode & mode)) {
393 spin_unlock_irqrestore(&waveartist_lock, flags);
394 return -EBUSY;
395 }
396
397 devc->audio_mode = 0;
398 devc->open_mode |= mode;
399 portc->open_mode = mode;
400 waveartist_trigger(dev, 0);
401
402 if (mode & OPEN_READ)
403 devc->record_dev = dev;
404 if (mode & OPEN_WRITE)
405 devc->playback_dev = dev;
406 spin_unlock_irqrestore(&waveartist_lock, flags);
407
408 return 0;
409 }
410
411 static void
412 waveartist_close(int dev)
413 {
414 wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
415 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
416 unsigned long flags;
417
418 spin_lock_irqsave(&waveartist_lock, flags);
419
420 waveartist_halt(dev);
421
422 devc->audio_mode = 0;
423 devc->open_mode &= ~portc->open_mode;
424 portc->open_mode = 0;
425
426 spin_unlock_irqrestore(&waveartist_lock, flags);
427 }
428
429 static void
430 waveartist_output_block(int dev, unsigned long buf, int __count, int intrflag)
431 {
432 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
433 wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
434 unsigned long flags;
435 unsigned int count = __count;
436
437 if (debug_flg & DEBUG_OUT)
438 printk("waveartist: output block, buf=0x%lx, count=0x%x...\n",
439 buf, count);
440 /*
441 * 16 bit data
442 */
443 if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE))
444 count >>= 1;
445
446 if (portc->channels > 1)
447 count >>= 1;
448
449 count -= 1;
450
451 if (devc->audio_mode & PCM_ENABLE_OUTPUT &&
452 audio_devs[dev]->flags & DMA_AUTOMODE &&
453 intrflag &&
454 count == devc->xfer_count) {
455 devc->audio_mode |= PCM_ENABLE_OUTPUT;
456 return; /*
457 * Auto DMA mode on. No need to react
458 */
459 }
460
461 spin_lock_irqsave(&waveartist_lock, flags);
462
463 /*
464 * set sample count
465 */
466 waveartist_cmd2(devc, WACMD_OUTPUTSIZE, count);
467
468 devc->xfer_count = count;
469 devc->audio_mode |= PCM_ENABLE_OUTPUT;
470
471 spin_unlock_irqrestore(&waveartist_lock, flags);
472 }
473
474 static void
475 waveartist_start_input(int dev, unsigned long buf, int __count, int intrflag)
476 {
477 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
478 wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
479 unsigned long flags;
480 unsigned int count = __count;
481
482 if (debug_flg & DEBUG_IN)
483 printk("waveartist: start input, buf=0x%lx, count=0x%x...\n",
484 buf, count);
485
486 if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE)) /* 16 bit data */
487 count >>= 1;
488
489 if (portc->channels > 1)
490 count >>= 1;
491
492 count -= 1;
493
494 if (devc->audio_mode & PCM_ENABLE_INPUT &&
495 audio_devs[dev]->flags & DMA_AUTOMODE &&
496 intrflag &&
497 count == devc->xfer_count) {
498 devc->audio_mode |= PCM_ENABLE_INPUT;
499 return; /*
500 * Auto DMA mode on. No need to react
501 */
502 }
503
504 spin_lock_irqsave(&waveartist_lock, flags);
505
506 /*
507 * set sample count
508 */
509 waveartist_cmd2(devc, WACMD_INPUTSIZE, count);
510
511 devc->xfer_count = count;
512 devc->audio_mode |= PCM_ENABLE_INPUT;
513
514 spin_unlock_irqrestore(&waveartist_lock, flags);
515 }
516
517 static int
518 waveartist_ioctl(int dev, unsigned int cmd, void __user * arg)
519 {
520 return -EINVAL;
521 }
522
523 static unsigned int
524 waveartist_get_speed(wavnc_port_info *portc)
525 {
526 unsigned int speed;
527
528 /*
529 * program the speed, channels, bits
530 */
531 if (portc->speed == 8000)
532 speed = 0x2E71;
533 else if (portc->speed == 11025)
534 speed = 0x4000;
535 else if (portc->speed == 22050)
536 speed = 0x8000;
537 else if (portc->speed == 44100)
538 speed = 0x0;
539 else {
540 /*
541 * non-standard - just calculate
542 */
543 speed = portc->speed << 16;
544
545 speed = (speed / 44100) & 65535;
546 }
547
548 return speed;
549 }
550
551 static unsigned int
552 waveartist_get_bits(wavnc_port_info *portc)
553 {
554 unsigned int bits;
555
556 if (portc->audio_format == AFMT_S16_LE)
557 bits = 1;
558 else if (portc->audio_format == AFMT_S8)
559 bits = 0;
560 else
561 bits = 2; //default AFMT_U8
562
563 return bits;
564 }
565
566 static int
567 waveartist_prepare_for_input(int dev, int bsize, int bcount)
568 {
569 unsigned long flags;
570 wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
571 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
572 unsigned int speed, bits;
573
574 if (devc->audio_mode)
575 return 0;
576
577 speed = waveartist_get_speed(portc);
578 bits = waveartist_get_bits(portc);
579
580 spin_lock_irqsave(&waveartist_lock, flags);
581
582 if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
583 printk(KERN_WARNING "waveartist: error setting the "
584 "record format to %d\n", portc->audio_format);
585
586 if (waveartist_cmd2(devc, WACMD_INPUTCHANNELS, portc->channels))
587 printk(KERN_WARNING "waveartist: error setting record "
588 "to %d channels\n", portc->channels);
589
590 /*
591 * write cmd SetSampleSpeedTimeConstant
592 */
593 if (waveartist_cmd2(devc, WACMD_INPUTSPEED, speed))
594 printk(KERN_WARNING "waveartist: error setting the record "
595 "speed to %dHz.\n", portc->speed);
596
597 if (waveartist_cmd2(devc, WACMD_INPUTDMA, 1))
598 printk(KERN_WARNING "waveartist: error setting the record "
599 "data path to 0x%X\n", 1);
600
601 if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
602 printk(KERN_WARNING "waveartist: error setting the record "
603 "format to %d\n", portc->audio_format);
604
605 devc->xfer_count = 0;
606 spin_unlock_irqrestore(&waveartist_lock, flags);
607 waveartist_halt_input(dev);
608
609 if (debug_flg & DEBUG_INTR) {
610 printk("WA CTLR reg: 0x%02X.\n",
611 inb(devc->hw.io_base + CTLR));
612 printk("WA STAT reg: 0x%02X.\n",
613 inb(devc->hw.io_base + STATR));
614 printk("WA IRQS reg: 0x%02X.\n",
615 inb(devc->hw.io_base + IRQSTAT));
616 }
617
618 return 0;
619 }
620
621 static int
622 waveartist_prepare_for_output(int dev, int bsize, int bcount)
623 {
624 unsigned long flags;
625 wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
626 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
627 unsigned int speed, bits;
628
629 /*
630 * program the speed, channels, bits
631 */
632 speed = waveartist_get_speed(portc);
633 bits = waveartist_get_bits(portc);
634
635 spin_lock_irqsave(&waveartist_lock, flags);
636
637 if (waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed) &&
638 waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed))
639 printk(KERN_WARNING "waveartist: error setting the playback "
640 "speed to %dHz.\n", portc->speed);
641
642 if (waveartist_cmd2(devc, WACMD_OUTPUTCHANNELS, portc->channels))
643 printk(KERN_WARNING "waveartist: error setting the playback "
644 "to %d channels\n", portc->channels);
645
646 if (waveartist_cmd2(devc, WACMD_OUTPUTDMA, 0))
647 printk(KERN_WARNING "waveartist: error setting the playback "
648 "data path to 0x%X\n", 0);
649
650 if (waveartist_cmd2(devc, WACMD_OUTPUTFORMAT, bits))
651 printk(KERN_WARNING "waveartist: error setting the playback "
652 "format to %d\n", portc->audio_format);
653
654 devc->xfer_count = 0;
655 spin_unlock_irqrestore(&waveartist_lock, flags);
656 waveartist_halt_output(dev);
657
658 if (debug_flg & DEBUG_INTR) {
659 printk("WA CTLR reg: 0x%02X.\n",inb(devc->hw.io_base + CTLR));
660 printk("WA STAT reg: 0x%02X.\n",inb(devc->hw.io_base + STATR));
661 printk("WA IRQS reg: 0x%02X.\n",inb(devc->hw.io_base + IRQSTAT));
662 }
663
664 return 0;
665 }
666
667 static void
668 waveartist_halt(int dev)
669 {
670 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
671 wavnc_info *devc;
672
673 if (portc->open_mode & OPEN_WRITE)
674 waveartist_halt_output(dev);
675
676 if (portc->open_mode & OPEN_READ)
677 waveartist_halt_input(dev);
678
679 devc = (wavnc_info *) audio_devs[dev]->devc;
680 devc->audio_mode = 0;
681 }
682
683 static void
684 waveartist_halt_input(int dev)
685 {
686 wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
687 unsigned long flags;
688
689 spin_lock_irqsave(&waveartist_lock, flags);
690
691 /*
692 * Stop capture
693 */
694 waveartist_cmd1(devc, WACMD_INPUTSTOP);
695
696 devc->audio_mode &= ~PCM_ENABLE_INPUT;
697
698 /*
699 * Clear interrupt by toggling
700 * the IRQ_ACK bit in CTRL
701 */
702 if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
703 waveartist_iack(devc);
704
705 // devc->audio_mode &= ~PCM_ENABLE_INPUT;
706
707 spin_unlock_irqrestore(&waveartist_lock, flags);
708 }
709
710 static void
711 waveartist_halt_output(int dev)
712 {
713 wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
714 unsigned long flags;
715
716 spin_lock_irqsave(&waveartist_lock, flags);
717
718 waveartist_cmd1(devc, WACMD_OUTPUTSTOP);
719
720 devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
721
722 /*
723 * Clear interrupt by toggling
724 * the IRQ_ACK bit in CTRL
725 */
726 if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
727 waveartist_iack(devc);
728
729 // devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
730
731 spin_unlock_irqrestore(&waveartist_lock, flags);
732 }
733
734 static void
735 waveartist_trigger(int dev, int state)
736 {
737 wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
738 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
739 unsigned long flags;
740
741 if (debug_flg & DEBUG_TRIGGER) {
742 printk("wavnc: audio trigger ");
743 if (state & PCM_ENABLE_INPUT)
744 printk("in ");
745 if (state & PCM_ENABLE_OUTPUT)
746 printk("out");
747 printk("\n");
748 }
749
750 spin_lock_irqsave(&waveartist_lock, flags);
751
752 state &= devc->audio_mode;
753
754 if (portc->open_mode & OPEN_READ &&
755 state & PCM_ENABLE_INPUT)
756 /*
757 * enable ADC Data Transfer to PC
758 */
759 waveartist_cmd1(devc, WACMD_INPUTSTART);
760
761 if (portc->open_mode & OPEN_WRITE &&
762 state & PCM_ENABLE_OUTPUT)
763 /*
764 * enable DAC data transfer from PC
765 */
766 waveartist_cmd1(devc, WACMD_OUTPUTSTART);
767
768 spin_unlock_irqrestore(&waveartist_lock, flags);
769 }
770
771 static int
772 waveartist_set_speed(int dev, int arg)
773 {
774 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
775
776 if (arg <= 0)
777 return portc->speed;
778
779 if (arg < 5000)
780 arg = 5000;
781 if (arg > 44100)
782 arg = 44100;
783
784 portc->speed = arg;
785 return portc->speed;
786
787 }
788
789 static short
790 waveartist_set_channels(int dev, short arg)
791 {
792 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
793
794 if (arg != 1 && arg != 2)
795 return portc->channels;
796
797 portc->channels = arg;
798 return arg;
799 }
800
801 static unsigned int
802 waveartist_set_bits(int dev, unsigned int arg)
803 {
804 wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
805
806 if (arg == 0)
807 return portc->audio_format;
808
809 if ((arg != AFMT_U8) && (arg != AFMT_S16_LE) && (arg != AFMT_S8))
810 arg = AFMT_U8;
811
812 portc->audio_format = arg;
813
814 return arg;
815 }
816
817 static struct audio_driver waveartist_audio_driver = {
818 .owner = THIS_MODULE,
819 .open = waveartist_open,
820 .close = waveartist_close,
821 .output_block = waveartist_output_block,
822 .start_input = waveartist_start_input,
823 .ioctl = waveartist_ioctl,
824 .prepare_for_input = waveartist_prepare_for_input,
825 .prepare_for_output = waveartist_prepare_for_output,
826 .halt_io = waveartist_halt,
827 .halt_input = waveartist_halt_input,
828 .halt_output = waveartist_halt_output,
829 .trigger = waveartist_trigger,
830 .set_speed = waveartist_set_speed,
831 .set_bits = waveartist_set_bits,
832 .set_channels = waveartist_set_channels
833 };
834
835
836 static irqreturn_t
837 waveartist_intr(int irq, void *dev_id)
838 {
839 wavnc_info *devc = dev_id;
840 int irqstatus, status;
841
842 spin_lock(&waveartist_lock);
843 irqstatus = inb(devc->hw.io_base + IRQSTAT);
844 status = inb(devc->hw.io_base + STATR);
845
846 if (debug_flg & DEBUG_INTR)
847 printk("waveartist_intr: stat=%02x, irqstat=%02x\n",
848 status, irqstatus);
849
850 if (status & IRQ_REQ) /* Clear interrupt */
851 waveartist_iack(devc);
852 else
853 printk(KERN_WARNING "waveartist: unexpected interrupt\n");
854
855 if (irqstatus & 0x01) {
856 int temp = 1;
857
858 /* PCM buffer done
859 */
860 if ((status & DMA0) && (devc->audio_mode & PCM_ENABLE_OUTPUT)) {
861 DMAbuf_outputintr(devc->playback_dev, 1);
862 temp = 0;
863 }
864 if ((status & DMA1) && (devc->audio_mode & PCM_ENABLE_INPUT)) {
865 DMAbuf_inputintr(devc->record_dev);
866 temp = 0;
867 }
868 if (temp) //default:
869 printk(KERN_WARNING "waveartist: Unknown interrupt\n");
870 }
871 if (irqstatus & 0x2)
872 // We do not use SB mode natively...
873 printk(KERN_WARNING "waveartist: Unexpected SB interrupt...\n");
874 spin_unlock(&waveartist_lock);
875 return IRQ_HANDLED;
876 }
877
878 /* -------------------------------------------------------------------------
879 * Mixer stuff
880 */
881 struct mix_ent {
882 unsigned char reg_l;
883 unsigned char reg_r;
884 unsigned char shift;
885 unsigned char max;
886 };
887
888 static const struct mix_ent mix_devs[SOUND_MIXER_NRDEVICES] = {
889 { 2, 6, 1, 7 }, /* SOUND_MIXER_VOLUME */
890 { 0, 0, 0, 0 }, /* SOUND_MIXER_BASS */
891 { 0, 0, 0, 0 }, /* SOUND_MIXER_TREBLE */
892 { 0, 0, 0, 0 }, /* SOUND_MIXER_SYNTH */
893 { 0, 0, 0, 0 }, /* SOUND_MIXER_PCM */
894 { 0, 0, 0, 0 }, /* SOUND_MIXER_SPEAKER */
895 { 0, 4, 6, 31 }, /* SOUND_MIXER_LINE */
896 { 2, 6, 4, 3 }, /* SOUND_MIXER_MIC */
897 { 0, 0, 0, 0 }, /* SOUND_MIXER_CD */
898 { 0, 0, 0, 0 }, /* SOUND_MIXER_IMIX */
899 { 0, 0, 0, 0 }, /* SOUND_MIXER_ALTPCM */
900 #if 0
901 { 3, 7, 0, 10 }, /* SOUND_MIXER_RECLEV */
902 { 0, 0, 0, 0 }, /* SOUND_MIXER_IGAIN */
903 #else
904 { 0, 0, 0, 0 }, /* SOUND_MIXER_RECLEV */
905 { 3, 7, 0, 7 }, /* SOUND_MIXER_IGAIN */
906 #endif
907 { 0, 0, 0, 0 }, /* SOUND_MIXER_OGAIN */
908 { 0, 4, 1, 31 }, /* SOUND_MIXER_LINE1 */
909 { 1, 5, 6, 31 }, /* SOUND_MIXER_LINE2 */
910 { 0, 0, 0, 0 }, /* SOUND_MIXER_LINE3 */
911 { 0, 0, 0, 0 }, /* SOUND_MIXER_DIGITAL1 */
912 { 0, 0, 0, 0 }, /* SOUND_MIXER_DIGITAL2 */
913 { 0, 0, 0, 0 }, /* SOUND_MIXER_DIGITAL3 */
914 { 0, 0, 0, 0 }, /* SOUND_MIXER_PHONEIN */
915 { 0, 0, 0, 0 }, /* SOUND_MIXER_PHONEOUT */
916 { 0, 0, 0, 0 }, /* SOUND_MIXER_VIDEO */
917 { 0, 0, 0, 0 }, /* SOUND_MIXER_RADIO */
918 { 0, 0, 0, 0 } /* SOUND_MIXER_MONITOR */
919 };
920
921 static void
922 waveartist_mixer_update(wavnc_info *devc, int whichDev)
923 {
924 unsigned int lev_left, lev_right;
925
926 lev_left = devc->levels[whichDev] & 0xff;
927 lev_right = devc->levels[whichDev] >> 8;
928
929 if (lev_left > 100)
930 lev_left = 100;
931 if (lev_right > 100)
932 lev_right = 100;
933
934 #define SCALE(lev,max) ((lev) * (max) / 100)
935
936 if (machine_is_netwinder() && whichDev == SOUND_MIXER_PHONEOUT)
937 whichDev = SOUND_MIXER_VOLUME;
938
939 if (mix_devs[whichDev].reg_l || mix_devs[whichDev].reg_r) {
940 const struct mix_ent *mix = mix_devs + whichDev;
941 unsigned int mask, left, right;
942
943 mask = mix->max << mix->shift;
944 lev_left = SCALE(lev_left, mix->max) << mix->shift;
945 lev_right = SCALE(lev_right, mix->max) << mix->shift;
946
947 /* read left setting */
948 left = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
949 mix->reg_l << 8);
950
951 /* read right setting */
952 right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
953 mix->reg_r << 8);
954
955 left = (left & ~mask) | (lev_left & mask);
956 right = (right & ~mask) | (lev_right & mask);
957
958 /* write left,right back */
959 waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
960 } else {
961 switch(whichDev) {
962 case SOUND_MIXER_PCM:
963 waveartist_cmd3(devc, WACMD_SET_LEVEL,
964 SCALE(lev_left, 32767),
965 SCALE(lev_right, 32767));
966 break;
967
968 case SOUND_MIXER_SYNTH:
969 waveartist_cmd3(devc, 0x0100 | WACMD_SET_LEVEL,
970 SCALE(lev_left, 32767),
971 SCALE(lev_right, 32767));
972 break;
973 }
974 }
975 }
976
977 /*
978 * Set the ADC MUX to the specified values. We do NOT do any
979 * checking of the values passed, since we assume that the
980 * relevant *_select_input function has done that for us.
981 */
982 static void
983 waveartist_set_adc_mux(wavnc_info *devc, char left_dev, char right_dev)
984 {
985 unsigned int reg_08, reg_09;
986
987 reg_08 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0800);
988 reg_09 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0900);
989
990 reg_08 = (reg_08 & ~0x3f) | right_dev << 3 | left_dev;
991
992 waveartist_cmd3(devc, WACMD_SET_MIXER, reg_08, reg_09);
993 }
994
995 /*
996 * Decode a recording mask into a mixer selection as follows:
997 *
998 * OSS Source WA Source Actual source
999 * SOUND_MASK_IMIX Mixer Mixer output (same as AD1848)
1000 * SOUND_MASK_LINE Line Line in
1001 * SOUND_MASK_LINE1 Aux 1 Aux 1 in
1002 * SOUND_MASK_LINE2 Aux 2 Aux 2 in
1003 * SOUND_MASK_MIC Mic Microphone
1004 */
1005 static unsigned int
1006 waveartist_select_input(wavnc_info *devc, unsigned int recmask,
1007 unsigned char *dev_l, unsigned char *dev_r)
1008 {
1009 unsigned int recdev = ADC_MUX_NONE;
1010
1011 if (recmask & SOUND_MASK_IMIX) {
1012 recmask = SOUND_MASK_IMIX;
1013 recdev = ADC_MUX_MIXER;
1014 } else if (recmask & SOUND_MASK_LINE2) {
1015 recmask = SOUND_MASK_LINE2;
1016 recdev = ADC_MUX_AUX2;
1017 } else if (recmask & SOUND_MASK_LINE1) {
1018 recmask = SOUND_MASK_LINE1;
1019 recdev = ADC_MUX_AUX1;
1020 } else if (recmask & SOUND_MASK_LINE) {
1021 recmask = SOUND_MASK_LINE;
1022 recdev = ADC_MUX_LINE;
1023 } else if (recmask & SOUND_MASK_MIC) {
1024 recmask = SOUND_MASK_MIC;
1025 recdev = ADC_MUX_MIC;
1026 }
1027
1028 *dev_l = *dev_r = recdev;
1029
1030 return recmask;
1031 }
1032
1033 static int
1034 waveartist_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
1035 unsigned char lev_r)
1036 {
1037 switch (dev) {
1038 case SOUND_MIXER_VOLUME:
1039 case SOUND_MIXER_SYNTH:
1040 case SOUND_MIXER_PCM:
1041 case SOUND_MIXER_LINE:
1042 case SOUND_MIXER_MIC:
1043 case SOUND_MIXER_IGAIN:
1044 case SOUND_MIXER_LINE1:
1045 case SOUND_MIXER_LINE2:
1046 devc->levels[dev] = lev_l | lev_r << 8;
1047 break;
1048
1049 case SOUND_MIXER_IMIX:
1050 break;
1051
1052 default:
1053 dev = -EINVAL;
1054 break;
1055 }
1056
1057 return dev;
1058 }
1059
1060 static int waveartist_get_mixer(wavnc_info *devc, int dev)
1061 {
1062 return devc->levels[dev];
1063 }
1064
1065 static const struct waveartist_mixer_info waveartist_mixer = {
1066 .supported_devs = SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN,
1067 .recording_devs = SOUND_MASK_LINE | SOUND_MASK_MIC |
1068 SOUND_MASK_LINE1 | SOUND_MASK_LINE2 |
1069 SOUND_MASK_IMIX,
1070 .stereo_devs = (SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN) & ~
1071 (SOUND_MASK_SPEAKER | SOUND_MASK_IMIX),
1072 .select_input = waveartist_select_input,
1073 .decode_mixer = waveartist_decode_mixer,
1074 .get_mixer = waveartist_get_mixer,
1075 };
1076
1077 static void
1078 waveartist_set_recmask(wavnc_info *devc, unsigned int recmask)
1079 {
1080 unsigned char dev_l, dev_r;
1081
1082 recmask &= devc->mix->recording_devs;
1083
1084 /*
1085 * If more than one recording device selected,
1086 * disable the device that is currently in use.
1087 */
1088 if (hweight32(recmask) > 1)
1089 recmask &= ~devc->recmask;
1090
1091 /*
1092 * Translate the recording device mask into
1093 * the ADC multiplexer settings.
1094 */
1095 devc->recmask = devc->mix->select_input(devc, recmask,
1096 &dev_l, &dev_r);
1097
1098 waveartist_set_adc_mux(devc, dev_l, dev_r);
1099 }
1100
1101 static int
1102 waveartist_set_mixer(wavnc_info *devc, int dev, unsigned int level)
1103 {
1104 unsigned int lev_left = level & 0x00ff;
1105 unsigned int lev_right = (level & 0xff00) >> 8;
1106
1107 if (lev_left > 100)
1108 lev_left = 100;
1109 if (lev_right > 100)
1110 lev_right = 100;
1111
1112 /*
1113 * Mono devices have their right volume forced to their
1114 * left volume. (from ALSA driver OSS emulation).
1115 */
1116 if (!(devc->mix->stereo_devs & (1 << dev)))
1117 lev_right = lev_left;
1118
1119 dev = devc->mix->decode_mixer(devc, dev, lev_left, lev_right);
1120
1121 if (dev >= 0)
1122 waveartist_mixer_update(devc, dev);
1123
1124 return dev < 0 ? dev : 0;
1125 }
1126
1127 static int
1128 waveartist_mixer_ioctl(int dev, unsigned int cmd, void __user * arg)
1129 {
1130 wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
1131 int ret = 0, val, nr;
1132
1133 /*
1134 * All SOUND_MIXER_* ioctls use type 'M'
1135 */
1136 if (((cmd >> 8) & 255) != 'M')
1137 return -ENOIOCTLCMD;
1138
1139 #ifdef CONFIG_ARCH_NETWINDER
1140 if (machine_is_netwinder()) {
1141 ret = vnc_private_ioctl(dev, cmd, arg);
1142 if (ret != -ENOIOCTLCMD)
1143 return ret;
1144 else
1145 ret = 0;
1146 }
1147 #endif
1148
1149 nr = cmd & 0xff;
1150
1151 if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
1152 if (get_user(val, (int __user *)arg))
1153 return -EFAULT;
1154
1155 switch (nr) {
1156 case SOUND_MIXER_RECSRC:
1157 waveartist_set_recmask(devc, val);
1158 break;
1159
1160 default:
1161 ret = -EINVAL;
1162 if (nr < SOUND_MIXER_NRDEVICES &&
1163 devc->mix->supported_devs & (1 << nr))
1164 ret = waveartist_set_mixer(devc, nr, val);
1165 }
1166 }
1167
1168 if (ret == 0 && _SIOC_DIR(cmd) & _SIOC_READ) {
1169 ret = -EINVAL;
1170
1171 switch (nr) {
1172 case SOUND_MIXER_RECSRC:
1173 ret = devc->recmask;
1174 break;
1175
1176 case SOUND_MIXER_DEVMASK:
1177 ret = devc->mix->supported_devs;
1178 break;
1179
1180 case SOUND_MIXER_STEREODEVS:
1181 ret = devc->mix->stereo_devs;
1182 break;
1183
1184 case SOUND_MIXER_RECMASK:
1185 ret = devc->mix->recording_devs;
1186 break;
1187
1188 case SOUND_MIXER_CAPS:
1189 ret = SOUND_CAP_EXCL_INPUT;
1190 break;
1191
1192 default:
1193 if (nr < SOUND_MIXER_NRDEVICES)
1194 ret = devc->mix->get_mixer(devc, nr);
1195 break;
1196 }
1197
1198 if (ret >= 0)
1199 ret = put_user(ret, (int __user *)arg) ? -EFAULT : 0;
1200 }
1201
1202 return ret;
1203 }
1204
1205 static struct mixer_operations waveartist_mixer_operations =
1206 {
1207 .owner = THIS_MODULE,
1208 .id = "WaveArtist",
1209 .name = "WaveArtist",
1210 .ioctl = waveartist_mixer_ioctl
1211 };
1212
1213 static void
1214 waveartist_mixer_reset(wavnc_info *devc)
1215 {
1216 int i;
1217
1218 if (debug_flg & DEBUG_MIXER)
1219 printk("%s: mixer_reset\n", devc->hw.name);
1220
1221 /*
1222 * reset mixer cmd
1223 */
1224 waveartist_cmd1(devc, WACMD_RST_MIXER);
1225
1226 /*
1227 * set input for ADC to come from 'quiet'
1228 * turn on default modes
1229 */
1230 waveartist_cmd3(devc, WACMD_SET_MIXER, 0x9800, 0xa836);
1231
1232 /*
1233 * set mixer input select to none, RX filter gains 0 dB
1234 */
1235 waveartist_cmd3(devc, WACMD_SET_MIXER, 0x4c00, 0x8c00);
1236
1237 /*
1238 * set bit 0 reg 2 to 1 - unmute MonoOut
1239 */
1240 waveartist_cmd3(devc, WACMD_SET_MIXER, 0x2801, 0x6800);
1241
1242 /* set default input device = internal mic
1243 * current recording device = none
1244 */
1245 waveartist_set_recmask(devc, 0);
1246
1247 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
1248 waveartist_mixer_update(devc, i);
1249 }
1250
1251 static int __init waveartist_init(wavnc_info *devc)
1252 {
1253 wavnc_port_info *portc;
1254 char rev[3], dev_name[64];
1255 int my_dev;
1256
1257 if (waveartist_reset(devc))
1258 return -ENODEV;
1259
1260 sprintf(dev_name, "%s (%s", devc->hw.name, devc->chip_name);
1261
1262 if (waveartist_getrev(devc, rev)) {
1263 strcat(dev_name, " rev. ");
1264 strcat(dev_name, rev);
1265 }
1266 strcat(dev_name, ")");
1267
1268 conf_printf2(dev_name, devc->hw.io_base, devc->hw.irq,
1269 devc->hw.dma, devc->hw.dma2);
1270
1271 portc = kzalloc(sizeof(wavnc_port_info), GFP_KERNEL);
1272 if (portc == NULL)
1273 goto nomem;
1274
1275 my_dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, dev_name,
1276 &waveartist_audio_driver, sizeof(struct audio_driver),
1277 devc->audio_flags, AFMT_U8 | AFMT_S16_LE | AFMT_S8,
1278 devc, devc->hw.dma, devc->hw.dma2);
1279
1280 if (my_dev < 0)
1281 goto free;
1282
1283 audio_devs[my_dev]->portc = portc;
1284
1285 waveartist_mixer_reset(devc);
1286
1287 /*
1288 * clear any pending interrupt
1289 */
1290 waveartist_iack(devc);
1291
1292 if (request_irq(devc->hw.irq, waveartist_intr, 0, devc->hw.name, devc) < 0) {
1293 printk(KERN_ERR "%s: IRQ %d in use\n",
1294 devc->hw.name, devc->hw.irq);
1295 goto uninstall;
1296 }
1297
1298 if (sound_alloc_dma(devc->hw.dma, devc->hw.name)) {
1299 printk(KERN_ERR "%s: Can't allocate DMA%d\n",
1300 devc->hw.name, devc->hw.dma);
1301 goto uninstall_irq;
1302 }
1303
1304 if (devc->hw.dma != devc->hw.dma2 && devc->hw.dma2 != NO_DMA)
1305 if (sound_alloc_dma(devc->hw.dma2, devc->hw.name)) {
1306 printk(KERN_ERR "%s: can't allocate DMA%d\n",
1307 devc->hw.name, devc->hw.dma2);
1308 goto uninstall_dma;
1309 }
1310
1311 waveartist_set_ctlr(&devc->hw, 0, DMA1_IE | DMA0_IE);
1312
1313 audio_devs[my_dev]->mixer_dev =
1314 sound_install_mixer(MIXER_DRIVER_VERSION,
1315 dev_name,
1316 &waveartist_mixer_operations,
1317 sizeof(struct mixer_operations),
1318 devc);
1319
1320 return my_dev;
1321
1322 uninstall_dma:
1323 sound_free_dma(devc->hw.dma);
1324
1325 uninstall_irq:
1326 free_irq(devc->hw.irq, devc);
1327
1328 uninstall:
1329 sound_unload_audiodev(my_dev);
1330
1331 free:
1332 kfree(portc);
1333
1334 nomem:
1335 return -1;
1336 }
1337
1338 static int __init probe_waveartist(struct address_info *hw_config)
1339 {
1340 wavnc_info *devc = &adev_info[nr_waveartist_devs];
1341
1342 if (nr_waveartist_devs >= MAX_AUDIO_DEV) {
1343 printk(KERN_WARNING "waveartist: too many audio devices\n");
1344 return 0;
1345 }
1346
1347 if (!request_region(hw_config->io_base, 15, hw_config->name)) {
1348 printk(KERN_WARNING "WaveArtist: I/O port conflict\n");
1349 return 0;
1350 }
1351
1352 if (hw_config->irq > 15 || hw_config->irq < 0) {
1353 release_region(hw_config->io_base, 15);
1354 printk(KERN_WARNING "WaveArtist: Bad IRQ %d\n",
1355 hw_config->irq);
1356 return 0;
1357 }
1358
1359 if (hw_config->dma != 3) {
1360 release_region(hw_config->io_base, 15);
1361 printk(KERN_WARNING "WaveArtist: Bad DMA %d\n",
1362 hw_config->dma);
1363 return 0;
1364 }
1365
1366 hw_config->name = "WaveArtist";
1367 devc->hw = *hw_config;
1368 devc->open_mode = 0;
1369 devc->chip_name = "RWA-010";
1370
1371 return 1;
1372 }
1373
1374 static void __init
1375 attach_waveartist(struct address_info *hw, const struct waveartist_mixer_info *mix)
1376 {
1377 wavnc_info *devc = &adev_info[nr_waveartist_devs];
1378
1379 /*
1380 * NOTE! If irq < 0, there is another driver which has allocated the
1381 * IRQ so that this driver doesn't need to allocate/deallocate it.
1382 * The actually used IRQ is ABS(irq).
1383 */
1384 devc->hw = *hw;
1385 devc->hw.irq = (hw->irq > 0) ? hw->irq : 0;
1386 devc->open_mode = 0;
1387 devc->playback_dev = 0;
1388 devc->record_dev = 0;
1389 devc->audio_flags = DMA_AUTOMODE;
1390 devc->levels = levels;
1391
1392 if (hw->dma != hw->dma2 && hw->dma2 != NO_DMA)
1393 devc->audio_flags |= DMA_DUPLEX;
1394
1395 devc->mix = mix;
1396 devc->dev_no = waveartist_init(devc);
1397
1398 if (devc->dev_no < 0)
1399 release_region(hw->io_base, 15);
1400 else {
1401 #ifdef CONFIG_ARCH_NETWINDER
1402 if (machine_is_netwinder()) {
1403 init_timer(&vnc_timer);
1404 vnc_timer.function = vnc_slider_tick;
1405 vnc_timer.expires = jiffies;
1406 vnc_timer.data = nr_waveartist_devs;
1407 add_timer(&vnc_timer);
1408
1409 vnc_configure_mixer(devc, 0);
1410
1411 devc->no_autoselect = 1;
1412 }
1413 #endif
1414 nr_waveartist_devs += 1;
1415 }
1416 }
1417
1418 static void __exit unload_waveartist(struct address_info *hw)
1419 {
1420 wavnc_info *devc = NULL;
1421 int i;
1422
1423 for (i = 0; i < nr_waveartist_devs; i++)
1424 if (hw->io_base == adev_info[i].hw.io_base) {
1425 devc = adev_info + i;
1426 break;
1427 }
1428
1429 if (devc != NULL) {
1430 int mixer;
1431
1432 #ifdef CONFIG_ARCH_NETWINDER
1433 if (machine_is_netwinder())
1434 del_timer(&vnc_timer);
1435 #endif
1436
1437 release_region(devc->hw.io_base, 15);
1438
1439 waveartist_set_ctlr(&devc->hw, DMA1_IE|DMA0_IE, 0);
1440
1441 if (devc->hw.irq >= 0)
1442 free_irq(devc->hw.irq, devc);
1443
1444 sound_free_dma(devc->hw.dma);
1445
1446 if (devc->hw.dma != devc->hw.dma2 &&
1447 devc->hw.dma2 != NO_DMA)
1448 sound_free_dma(devc->hw.dma2);
1449
1450 mixer = audio_devs[devc->dev_no]->mixer_dev;
1451
1452 if (mixer >= 0)
1453 sound_unload_mixerdev(mixer);
1454
1455 if (devc->dev_no >= 0)
1456 sound_unload_audiodev(devc->dev_no);
1457
1458 nr_waveartist_devs -= 1;
1459
1460 for (; i < nr_waveartist_devs; i++)
1461 adev_info[i] = adev_info[i + 1];
1462 } else
1463 printk(KERN_WARNING "waveartist: can't find device "
1464 "to unload\n");
1465 }
1466
1467 #ifdef CONFIG_ARCH_NETWINDER
1468
1469 /*
1470 * Rebel.com Netwinder specifics...
1471 */
1472
1473 #include <asm/hardware/dec21285.h>
1474
1475 #define VNC_TIMER_PERIOD (HZ/4) //check slider 4 times/sec
1476
1477 #define MIXER_PRIVATE3_RESET 0x53570000
1478 #define MIXER_PRIVATE3_READ 0x53570001
1479 #define MIXER_PRIVATE3_WRITE 0x53570002
1480
1481 #define VNC_MUTE_INTERNAL_SPKR 0x01 //the sw mute on/off control bit
1482 #define VNC_MUTE_LINE_OUT 0x10
1483 #define VNC_PHONE_DETECT 0x20
1484 #define VNC_HANDSET_DETECT 0x40
1485 #define VNC_DISABLE_AUTOSWITCH 0x80
1486
1487 static inline void
1488 vnc_mute_spkr(wavnc_info *devc)
1489 {
1490 unsigned long flags;
1491
1492 spin_lock_irqsave(&nw_gpio_lock, flags);
1493 nw_cpld_modify(CPLD_UNMUTE, devc->spkr_mute_state ? 0 : CPLD_UNMUTE);
1494 spin_unlock_irqrestore(&nw_gpio_lock, flags);
1495 }
1496
1497 static void
1498 vnc_mute_lout(wavnc_info *devc)
1499 {
1500 unsigned int left, right;
1501
1502 left = waveartist_cmd1_r(devc, WACMD_GET_LEVEL);
1503 right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x400);
1504
1505 if (devc->line_mute_state) {
1506 left &= ~1;
1507 right &= ~1;
1508 } else {
1509 left |= 1;
1510 right |= 1;
1511 }
1512 waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
1513
1514 }
1515
1516 static int
1517 vnc_volume_slider(wavnc_info *devc)
1518 {
1519 static signed int old_slider_volume;
1520 unsigned long flags;
1521 signed int volume = 255;
1522
1523 *CSR_TIMER1_LOAD = 0x00ffffff;
1524
1525 spin_lock_irqsave(&waveartist_lock, flags);
1526
1527 outb(0xFF, 0x201);
1528 *CSR_TIMER1_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_DIV1;
1529
1530 while (volume && (inb(0x201) & 0x01))
1531 volume--;
1532
1533 *CSR_TIMER1_CNTL = 0;
1534
1535 spin_unlock_irqrestore(&waveartist_lock,flags);
1536
1537 volume = 0x00ffffff - *CSR_TIMER1_VALUE;
1538
1539
1540 #ifndef REVERSE
1541 volume = 150 - (volume >> 5);
1542 #else
1543 volume = (volume >> 6) - 25;
1544 #endif
1545
1546 if (volume < 0)
1547 volume = 0;
1548
1549 if (volume > 100)
1550 volume = 100;
1551
1552 /*
1553 * slider quite often reads +-8, so debounce this random noise
1554 */
1555 if (abs(volume - old_slider_volume) > 7) {
1556 old_slider_volume = volume;
1557
1558 if (debug_flg & DEBUG_MIXER)
1559 printk(KERN_DEBUG "Slider volume: %d.\n", volume);
1560 }
1561
1562 return old_slider_volume;
1563 }
1564
1565 /*
1566 * Decode a recording mask into a mixer selection on the NetWinder
1567 * as follows:
1568 *
1569 * OSS Source WA Source Actual source
1570 * SOUND_MASK_IMIX Mixer Mixer output (same as AD1848)
1571 * SOUND_MASK_LINE Line Line in
1572 * SOUND_MASK_LINE1 Left Mic Handset
1573 * SOUND_MASK_PHONEIN Left Aux Telephone microphone
1574 * SOUND_MASK_MIC Right Mic Builtin microphone
1575 */
1576 static unsigned int
1577 netwinder_select_input(wavnc_info *devc, unsigned int recmask,
1578 unsigned char *dev_l, unsigned char *dev_r)
1579 {
1580 unsigned int recdev_l = ADC_MUX_NONE, recdev_r = ADC_MUX_NONE;
1581
1582 if (recmask & SOUND_MASK_IMIX) {
1583 recmask = SOUND_MASK_IMIX;
1584 recdev_l = ADC_MUX_MIXER;
1585 recdev_r = ADC_MUX_MIXER;
1586 } else if (recmask & SOUND_MASK_LINE) {
1587 recmask = SOUND_MASK_LINE;
1588 recdev_l = ADC_MUX_LINE;
1589 recdev_r = ADC_MUX_LINE;
1590 } else if (recmask & SOUND_MASK_LINE1) {
1591 recmask = SOUND_MASK_LINE1;
1592 waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
1593 recdev_l = ADC_MUX_MIC;
1594 recdev_r = ADC_MUX_NONE;
1595 } else if (recmask & SOUND_MASK_PHONEIN) {
1596 recmask = SOUND_MASK_PHONEIN;
1597 waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
1598 recdev_l = ADC_MUX_AUX1;
1599 recdev_r = ADC_MUX_NONE;
1600 } else if (recmask & SOUND_MASK_MIC) {
1601 recmask = SOUND_MASK_MIC;
1602 waveartist_cmd1(devc, WACMD_SET_MONO | 0x100); /* right */
1603 recdev_l = ADC_MUX_NONE;
1604 recdev_r = ADC_MUX_MIC;
1605 }
1606
1607 *dev_l = recdev_l;
1608 *dev_r = recdev_r;
1609
1610 return recmask;
1611 }
1612
1613 static int
1614 netwinder_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
1615 unsigned char lev_r)
1616 {
1617 switch (dev) {
1618 case SOUND_MIXER_VOLUME:
1619 case SOUND_MIXER_SYNTH:
1620 case SOUND_MIXER_PCM:
1621 case SOUND_MIXER_LINE:
1622 case SOUND_MIXER_IGAIN:
1623 devc->levels[dev] = lev_l | lev_r << 8;
1624 break;
1625
1626 case SOUND_MIXER_MIC: /* right mic only */
1627 devc->levels[SOUND_MIXER_MIC] &= 0xff;
1628 devc->levels[SOUND_MIXER_MIC] |= lev_l << 8;
1629 break;
1630
1631 case SOUND_MIXER_LINE1: /* left mic only */
1632 devc->levels[SOUND_MIXER_MIC] &= 0xff00;
1633 devc->levels[SOUND_MIXER_MIC] |= lev_l;
1634 dev = SOUND_MIXER_MIC;
1635 break;
1636
1637 case SOUND_MIXER_PHONEIN: /* left aux only */
1638 devc->levels[SOUND_MIXER_LINE1] = lev_l;
1639 dev = SOUND_MIXER_LINE1;
1640 break;
1641
1642 case SOUND_MIXER_IMIX:
1643 case SOUND_MIXER_PHONEOUT:
1644 break;
1645
1646 default:
1647 dev = -EINVAL;
1648 break;
1649 }
1650 return dev;
1651 }
1652
1653 static int netwinder_get_mixer(wavnc_info *devc, int dev)
1654 {
1655 int levels;
1656
1657 switch (dev) {
1658 case SOUND_MIXER_VOLUME:
1659 case SOUND_MIXER_SYNTH:
1660 case SOUND_MIXER_PCM:
1661 case SOUND_MIXER_LINE:
1662 case SOUND_MIXER_IGAIN:
1663 levels = devc->levels[dev];
1664 break;
1665
1666 case SOUND_MIXER_MIC: /* builtin mic: right mic only */
1667 levels = devc->levels[SOUND_MIXER_MIC] >> 8;
1668 levels |= levels << 8;
1669 break;
1670
1671 case SOUND_MIXER_LINE1: /* handset mic: left mic only */
1672 levels = devc->levels[SOUND_MIXER_MIC] & 0xff;
1673 levels |= levels << 8;
1674 break;
1675
1676 case SOUND_MIXER_PHONEIN: /* phone mic: left aux1 only */
1677 levels = devc->levels[SOUND_MIXER_LINE1] & 0xff;
1678 levels |= levels << 8;
1679 break;
1680
1681 default:
1682 levels = 0;
1683 }
1684
1685 return levels;
1686 }
1687
1688 /*
1689 * Waveartist specific mixer information.
1690 */
1691 static const struct waveartist_mixer_info netwinder_mixer = {
1692 .supported_devs = SOUND_MASK_VOLUME | SOUND_MASK_SYNTH |
1693 SOUND_MASK_PCM | SOUND_MASK_SPEAKER |
1694 SOUND_MASK_LINE | SOUND_MASK_MIC |
1695 SOUND_MASK_IMIX | SOUND_MASK_LINE1 |
1696 SOUND_MASK_PHONEIN | SOUND_MASK_PHONEOUT|
1697 SOUND_MASK_IGAIN,
1698
1699 .recording_devs = SOUND_MASK_LINE | SOUND_MASK_MIC |
1700 SOUND_MASK_IMIX | SOUND_MASK_LINE1 |
1701 SOUND_MASK_PHONEIN,
1702
1703 .stereo_devs = SOUND_MASK_VOLUME | SOUND_MASK_SYNTH |
1704 SOUND_MASK_PCM | SOUND_MASK_LINE |
1705 SOUND_MASK_IMIX | SOUND_MASK_IGAIN,
1706
1707 .select_input = netwinder_select_input,
1708 .decode_mixer = netwinder_decode_mixer,
1709 .get_mixer = netwinder_get_mixer,
1710 };
1711
1712 static void
1713 vnc_configure_mixer(wavnc_info *devc, unsigned int recmask)
1714 {
1715 if (!devc->no_autoselect) {
1716 if (devc->handset_detect) {
1717 recmask = SOUND_MASK_LINE1;
1718 devc->spkr_mute_state = devc->line_mute_state = 1;
1719 } else if (devc->telephone_detect) {
1720 recmask = SOUND_MASK_PHONEIN;
1721 devc->spkr_mute_state = devc->line_mute_state = 1;
1722 } else {
1723 /* unless someone has asked for LINE-IN,
1724 * we default to MIC
1725 */
1726 if ((devc->recmask & SOUND_MASK_LINE) == 0)
1727 devc->recmask = SOUND_MASK_MIC;
1728 devc->spkr_mute_state = devc->line_mute_state = 0;
1729 }
1730 vnc_mute_spkr(devc);
1731 vnc_mute_lout(devc);
1732
1733 if (recmask != devc->recmask)
1734 waveartist_set_recmask(devc, recmask);
1735 }
1736 }
1737
1738 static int
1739 vnc_slider(wavnc_info *devc)
1740 {
1741 signed int slider_volume;
1742 unsigned int temp, old_hs, old_td;
1743
1744 /*
1745 * read the "buttons" state.
1746 * Bit 4 = 0 means handset present
1747 * Bit 5 = 1 means phone offhook
1748 */
1749 temp = inb(0x201);
1750
1751 old_hs = devc->handset_detect;
1752 old_td = devc->telephone_detect;
1753
1754 devc->handset_detect = !(temp & 0x10);
1755 devc->telephone_detect = !!(temp & 0x20);
1756
1757 if (!devc->no_autoselect &&
1758 (old_hs != devc->handset_detect ||
1759 old_td != devc->telephone_detect))
1760 vnc_configure_mixer(devc, devc->recmask);
1761
1762 slider_volume = vnc_volume_slider(devc);
1763
1764 /*
1765 * If we're using software controlled volume, and
1766 * the slider moves by more than 20%, then we
1767 * switch back to slider controlled volume.
1768 */
1769 if (abs(devc->slider_vol - slider_volume) > 20)
1770 devc->use_slider = 1;
1771
1772 /*
1773 * use only left channel
1774 */
1775 temp = levels[SOUND_MIXER_VOLUME] & 0xFF;
1776
1777 if (slider_volume != temp && devc->use_slider) {
1778 devc->slider_vol = slider_volume;
1779
1780 waveartist_set_mixer(devc, SOUND_MIXER_VOLUME,
1781 slider_volume | slider_volume << 8);
1782
1783 return 1;
1784 }
1785
1786 return 0;
1787 }
1788
1789 static void
1790 vnc_slider_tick(unsigned long data)
1791 {
1792 int next_timeout;
1793
1794 if (vnc_slider(adev_info + data))
1795 next_timeout = 5; // mixer reported change
1796 else
1797 next_timeout = VNC_TIMER_PERIOD;
1798
1799 mod_timer(&vnc_timer, jiffies + next_timeout);
1800 }
1801
1802 static int
1803 vnc_private_ioctl(int dev, unsigned int cmd, int __user * arg)
1804 {
1805 wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
1806 int val;
1807
1808 switch (cmd) {
1809 case SOUND_MIXER_PRIVATE1:
1810 {
1811 u_int prev_spkr_mute, prev_line_mute, prev_auto_state;
1812 int val;
1813
1814 if (get_user(val, arg))
1815 return -EFAULT;
1816
1817 /* check if parameter is logical */
1818 if (val & ~(VNC_MUTE_INTERNAL_SPKR |
1819 VNC_MUTE_LINE_OUT |
1820 VNC_DISABLE_AUTOSWITCH))
1821 return -EINVAL;
1822
1823 prev_auto_state = devc->no_autoselect;
1824 prev_spkr_mute = devc->spkr_mute_state;
1825 prev_line_mute = devc->line_mute_state;
1826
1827 devc->no_autoselect = (val & VNC_DISABLE_AUTOSWITCH) ? 1 : 0;
1828 devc->spkr_mute_state = (val & VNC_MUTE_INTERNAL_SPKR) ? 1 : 0;
1829 devc->line_mute_state = (val & VNC_MUTE_LINE_OUT) ? 1 : 0;
1830
1831 if (prev_spkr_mute != devc->spkr_mute_state)
1832 vnc_mute_spkr(devc);
1833
1834 if (prev_line_mute != devc->line_mute_state)
1835 vnc_mute_lout(devc);
1836
1837 if (prev_auto_state != devc->no_autoselect)
1838 vnc_configure_mixer(devc, devc->recmask);
1839
1840 return 0;
1841 }
1842
1843 case SOUND_MIXER_PRIVATE2:
1844 if (get_user(val, arg))
1845 return -EFAULT;
1846
1847 switch (val) {
1848 #define VNC_SOUND_PAUSE 0x53 //to pause the DSP
1849 #define VNC_SOUND_RESUME 0x57 //to unpause the DSP
1850 case VNC_SOUND_PAUSE:
1851 waveartist_cmd1(devc, 0x16);
1852 break;
1853
1854 case VNC_SOUND_RESUME:
1855 waveartist_cmd1(devc, 0x18);
1856 break;
1857
1858 default:
1859 return -EINVAL;
1860 }
1861 return 0;
1862
1863 /* private ioctl to allow bulk access to waveartist */
1864 case SOUND_MIXER_PRIVATE3:
1865 {
1866 unsigned long flags;
1867 int mixer_reg[15], i, val;
1868
1869 if (get_user(val, arg))
1870 return -EFAULT;
1871 if (copy_from_user(mixer_reg, (void *)val, sizeof(mixer_reg)))
1872 return -EFAULT;
1873
1874 switch (mixer_reg[14]) {
1875 case MIXER_PRIVATE3_RESET:
1876 waveartist_mixer_reset(devc);
1877 break;
1878
1879 case MIXER_PRIVATE3_WRITE:
1880 waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[0], mixer_reg[4]);
1881 waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[1], mixer_reg[5]);
1882 waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[2], mixer_reg[6]);
1883 waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[3], mixer_reg[7]);
1884 waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[8], mixer_reg[9]);
1885
1886 waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[10], mixer_reg[11]);
1887 waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[12], mixer_reg[13]);
1888 break;
1889
1890 case MIXER_PRIVATE3_READ:
1891 spin_lock_irqsave(&waveartist_lock, flags);
1892
1893 for (i = 0x30; i < 14 << 8; i += 1 << 8)
1894 waveartist_cmd(devc, 1, &i, 1, mixer_reg + (i >> 8));
1895
1896 spin_unlock_irqrestore(&waveartist_lock, flags);
1897
1898 if (copy_to_user((void *)val, mixer_reg, sizeof(mixer_reg)))
1899 return -EFAULT;
1900 break;
1901
1902 default:
1903 return -EINVAL;
1904 }
1905 return 0;
1906 }
1907
1908 /* read back the state from PRIVATE1 */
1909 case SOUND_MIXER_PRIVATE4:
1910 val = (devc->spkr_mute_state ? VNC_MUTE_INTERNAL_SPKR : 0) |
1911 (devc->line_mute_state ? VNC_MUTE_LINE_OUT : 0) |
1912 (devc->handset_detect ? VNC_HANDSET_DETECT : 0) |
1913 (devc->telephone_detect ? VNC_PHONE_DETECT : 0) |
1914 (devc->no_autoselect ? VNC_DISABLE_AUTOSWITCH : 0);
1915
1916 return put_user(val, arg) ? -EFAULT : 0;
1917 }
1918
1919 if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
1920 /*
1921 * special case for master volume: if we
1922 * received this call - switch from hw
1923 * volume control to a software volume
1924 * control, till the hw volume is modified
1925 * to signal that user wants to be back in
1926 * hardware...
1927 */
1928 if ((cmd & 0xff) == SOUND_MIXER_VOLUME)
1929 devc->use_slider = 0;
1930
1931 /* speaker output */
1932 if ((cmd & 0xff) == SOUND_MIXER_SPEAKER) {
1933 unsigned int val, l, r;
1934
1935 if (get_user(val, arg))
1936 return -EFAULT;
1937
1938 l = val & 0x7f;
1939 r = (val & 0x7f00) >> 8;
1940 val = (l + r) / 2;
1941 devc->levels[SOUND_MIXER_SPEAKER] = val | (val << 8);
1942 devc->spkr_mute_state = (val <= 50);
1943 vnc_mute_spkr(devc);
1944 return 0;
1945 }
1946 }
1947
1948 return -ENOIOCTLCMD;
1949 }
1950
1951 #endif
1952
1953 static struct address_info cfg;
1954
1955 static int attached;
1956
1957 static int __initdata io = 0;
1958 static int __initdata irq = 0;
1959 static int __initdata dma = 0;
1960 static int __initdata dma2 = 0;
1961
1962
1963 static int __init init_waveartist(void)
1964 {
1965 const struct waveartist_mixer_info *mix;
1966
1967 if (!io && machine_is_netwinder()) {
1968 /*
1969 * The NetWinder WaveArtist is at a fixed address.
1970 * If the user does not supply an address, use the
1971 * well-known parameters.
1972 */
1973 io = 0x250;
1974 irq = 12;
1975 dma = 3;
1976 dma2 = 7;
1977 }
1978
1979 mix = &waveartist_mixer;
1980 #ifdef CONFIG_ARCH_NETWINDER
1981 if (machine_is_netwinder())
1982 mix = &netwinder_mixer;
1983 #endif
1984
1985 cfg.io_base = io;
1986 cfg.irq = irq;
1987 cfg.dma = dma;
1988 cfg.dma2 = dma2;
1989
1990 if (!probe_waveartist(&cfg))
1991 return -ENODEV;
1992
1993 attach_waveartist(&cfg, mix);
1994 attached = 1;
1995
1996 return 0;
1997 }
1998
1999 static void __exit cleanup_waveartist(void)
2000 {
2001 if (attached)
2002 unload_waveartist(&cfg);
2003 }
2004
2005 module_init(init_waveartist);
2006 module_exit(cleanup_waveartist);
2007
2008 #ifndef MODULE
2009 static int __init setup_waveartist(char *str)
2010 {
2011 /* io, irq, dma, dma2 */
2012 int ints[5];
2013
2014 str = get_options(str, ARRAY_SIZE(ints), ints);
2015
2016 io = ints[1];
2017 irq = ints[2];
2018 dma = ints[3];
2019 dma2 = ints[4];
2020
2021 return 1;
2022 }
2023 __setup("waveartist=", setup_waveartist);
2024 #endif
2025
2026 MODULE_DESCRIPTION("Rockwell WaveArtist RWA-010 sound driver");
2027 module_param(io, int, 0); /* IO base */
2028 module_param(irq, int, 0); /* IRQ */
2029 module_param(dma, int, 0); /* DMA */
2030 module_param(dma2, int, 0); /* DMA2 */
2031 MODULE_LICENSE("GPL");
linux-next