?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with 2.4.0-test3-pre4.
[linux-2.6/linux-mips.git] / drivers / sound / pss.c
blob7e883a625aec667fb79683b19ab594ad7137b900
1 /*
2 * sound/pss.c
3 *
4 * The low level driver for the Personal Sound System (ECHO ESC614).
5 *
6 *
7 * Copyright (C) by Hannu Savolainen 1993-1997
8 *
9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
11 * for more info.
12 *
13 *
14 * Thomas Sailer ioctl code reworked (vmalloc/vfree removed)
15 * Alan Cox modularisation, clean up.
16 *
17 * 98-02-21: Vladimir Michl <vladimir.michl@upol.cz>
18 * Added mixer device for Beethoven ADSP-16 (master volume,
19 * bass, treble, synth), only for speakers.
20 * Fixed bug in pss_write (exchange parameters)
21 * Fixed config port of SB
22 * Requested two regions for PSS (PSS mixer, PSS config)
23 * Modified pss_download_boot
24 * To probe_pss_mss added test for initialize AD1848
25 * 98-05-28: Vladimir Michl <vladimir.michl@upol.cz>
26 * Fixed computation of mixer volumes
27 * 00-03-03: Christoph Hellwig <chhellwig@gmx.net>
28 * Adapted to module_init/module_exit
29 */
30
31
32 #include <linux/config.h>
33 #include <linux/init.h>
34 #include <linux/module.h>
35
36 #include "sound_config.h"
37 #include "sound_firmware.h"
38 #include "soundmodule.h"
39
40 #include "ad1848.h"
41 #include "mpu401.h"
42
43 /*
44 * PSS registers.
45 */
46 #define REG(x) (devc->base+x)
47 #define PSS_DATA 0
48 #define PSS_STATUS 2
49 #define PSS_CONTROL 2
50 #define PSS_ID 4
51 #define PSS_IRQACK 4
52 #define PSS_PIO 0x1a
53
54 /*
55 * Config registers
56 */
57 #define CONF_PSS 0x10
58 #define CONF_WSS 0x12
59 #define CONF_SB 0x14
60 #define CONF_CDROM 0x16
61 #define CONF_MIDI 0x18
62
63 /*
64 * Status bits.
65 */
66 #define PSS_FLAG3 0x0800
67 #define PSS_FLAG2 0x0400
68 #define PSS_FLAG1 0x1000
69 #define PSS_FLAG0 0x0800
70 #define PSS_WRITE_EMPTY 0x8000
71 #define PSS_READ_FULL 0x4000
72
73 /*
74 * WSS registers
75 */
76 #define WSS_INDEX 4
77 #define WSS_DATA 5
78
79 /*
80 * WSS status bits
81 */
82 #define WSS_INITIALIZING 0x80
83 #define WSS_AUTOCALIBRATION 0x20
84
85 #define NO_WSS_MIXER -1
86
87 #include "coproc.h"
88 #include "pss_boot.h"
89
90 /* If compiled into kernel, it enable or disable pss mixer */
91 #ifdef CONFIG_PSS_MIXER
92 static unsigned char pss_mixer = 1;
93 #else
94 static unsigned char pss_mixer = 0;
95 #endif
96
97
98 typedef struct pss_mixerdata {
99 unsigned int volume_l;
100 unsigned int volume_r;
101 unsigned int bass;
102 unsigned int treble;
103 unsigned int synth;
104 } pss_mixerdata;
105
106 typedef struct pss_confdata {
107 int base;
108 int irq;
109 int dma;
110 int *osp;
111 pss_mixerdata mixer;
112 int ad_mixer_dev;
113 } pss_confdata;
114
115 static pss_confdata pss_data;
116 static pss_confdata *devc = &pss_data;
117
118 static int pss_initialized = 0;
119 static int nonstandard_microcode = 0;
120
121 static void pss_write(pss_confdata *devc, int data)
122 {
123 int i, limit;
124
125 limit = jiffies + HZ/10; /* The timeout is 0.1 seconds */
126 /*
127 * Note! the i<5000000 is an emergency exit. The dsp_command() is sometimes
128 * called while interrupts are disabled. This means that the timer is
129 * disabled also. However the timeout situation is a abnormal condition.
130 * Normally the DSP should be ready to accept commands after just couple of
131 * loops.
132 */
133
134 for (i = 0; i < 5000000 && time_before(jiffies, limit); i++)
135 {
136 if (inw(REG(PSS_STATUS)) & PSS_WRITE_EMPTY)
137 {
138 outw(data, REG(PSS_DATA));
139 return;
140 }
141 }
142 printk(KERN_WARNING "PSS: DSP Command (%04x) Timeout.\n", data);
143 }
144
145 int probe_pss(struct address_info *hw_config)
146 {
147 unsigned short id;
148 int irq, dma;
149
150 devc->base = hw_config->io_base;
151 irq = devc->irq = hw_config->irq;
152 dma = devc->dma = hw_config->dma;
153 devc->osp = hw_config->osp;
154
155 if (devc->base != 0x220 && devc->base != 0x240)
156 if (devc->base != 0x230 && devc->base != 0x250) /* Some cards use these */
157 return 0;
158
159 if (check_region(devc->base, 0x19 /*16*/)) {
160 printk(KERN_ERR "PSS: I/O port conflict\n");
161 return 0;
162 }
163 id = inw(REG(PSS_ID));
164 if ((id >> 8) != 'E') {
165 printk(KERN_ERR "No PSS signature detected at 0x%x (0x%x)\n", devc->base, id);
166 return 0;
167 }
168 return 1;
169 }
170
171 static int set_irq(pss_confdata * devc, int dev, int irq)
172 {
173 static unsigned short irq_bits[16] =
174 {
175 0x0000, 0x0000, 0x0000, 0x0008,
176 0x0000, 0x0010, 0x0000, 0x0018,
177 0x0000, 0x0020, 0x0028, 0x0030,
178 0x0038, 0x0000, 0x0000, 0x0000
179 };
180
181 unsigned short tmp, bits;
182
183 if (irq < 0 || irq > 15)
184 return 0;
185
186 tmp = inw(REG(dev)) & ~0x38; /* Load confreg, mask IRQ bits out */
187
188 if ((bits = irq_bits[irq]) == 0 && irq != 0)
189 {
190 printk(KERN_ERR "PSS: Invalid IRQ %d\n", irq);
191 return 0;
192 }
193 outw(tmp | bits, REG(dev));
194 return 1;
195 }
196
197 static int set_io_base(pss_confdata * devc, int dev, int base)
198 {
199 unsigned short tmp = inw(REG(dev)) & 0x003f;
200 unsigned short bits = (base & 0x0ffc) << 4;
201
202 outw(bits | tmp, REG(dev));
203
204 return 1;
205 }
206
207 static int set_dma(pss_confdata * devc, int dev, int dma)
208 {
209 static unsigned short dma_bits[8] =
210 {
211 0x0001, 0x0002, 0x0000, 0x0003,
212 0x0000, 0x0005, 0x0006, 0x0007
213 };
214
215 unsigned short tmp, bits;
216
217 if (dma < 0 || dma > 7)
218 return 0;
219
220 tmp = inw(REG(dev)) & ~0x07; /* Load confreg, mask DMA bits out */
221
222 if ((bits = dma_bits[dma]) == 0 && dma != 4)
223 {
224 printk(KERN_ERR "PSS: Invalid DMA %d\n", dma);
225 return 0;
226 }
227 outw(tmp | bits, REG(dev));
228 return 1;
229 }
230
231 static int pss_reset_dsp(pss_confdata * devc)
232 {
233 unsigned long i, limit = jiffies + HZ/10;
234
235 outw(0x2000, REG(PSS_CONTROL));
236 for (i = 0; i < 32768 && (limit-jiffies >= 0); i++)
237 inw(REG(PSS_CONTROL));
238 outw(0x0000, REG(PSS_CONTROL));
239 return 1;
240 }
241
242 static int pss_put_dspword(pss_confdata * devc, unsigned short word)
243 {
244 int i, val;
245
246 for (i = 0; i < 327680; i++)
247 {
248 val = inw(REG(PSS_STATUS));
249 if (val & PSS_WRITE_EMPTY)
250 {
251 outw(word, REG(PSS_DATA));
252 return 1;
253 }
254 }
255 return 0;
256 }
257
258 static int pss_get_dspword(pss_confdata * devc, unsigned short *word)
259 {
260 int i, val;
261
262 for (i = 0; i < 327680; i++)
263 {
264 val = inw(REG(PSS_STATUS));
265 if (val & PSS_READ_FULL)
266 {
267 *word = inw(REG(PSS_DATA));
268 return 1;
269 }
270 }
271 return 0;
272 }
273
274 static int pss_download_boot(pss_confdata * devc, unsigned char *block, int size, int flags)
275 {
276 int i, limit, val, count;
277
278 if (flags & CPF_FIRST)
279 {
280 /*_____ Warn DSP software that a boot is coming */
281 outw(0x00fe, REG(PSS_DATA));
282
283 limit = jiffies + HZ/10;
284 for (i = 0; i < 32768 && time_before(jiffies, limit); i++)
285 if (inw(REG(PSS_DATA)) == 0x5500)
286 break;
287
288 outw(*block++, REG(PSS_DATA));
289 pss_reset_dsp(devc);
290 }
291 count = 1;
292 while ((flags&CPF_LAST) || count<size )
293 {
294 int j;
295
296 for (j = 0; j < 327670; j++)
297 {
298 /*_____ Wait for BG to appear */
299 if (inw(REG(PSS_STATUS)) & PSS_FLAG3)
300 break;
301 }
302
303 if (j == 327670)
304 {
305 /* It's ok we timed out when the file was empty */
306 if (count >= size && flags & CPF_LAST)
307 break;
308 else
309 {
310 printk("\n");
311 printk(KERN_ERR "PSS: Download timeout problems, byte %d=%d\n", count, size);
312 return 0;
313 }
314 }
315 /*_____ Send the next byte */
316 if (count >= size)
317 {
318 /* If not data in block send 0xffff */
319 outw (0xffff, REG (PSS_DATA));
320 }
321 else
322 {
323 /*_____ Send the next byte */
324 outw (*block++, REG (PSS_DATA));
325 };
326 count++;
327 }
328
329 if (flags & CPF_LAST)
330 {
331 /*_____ Why */
332 outw(0, REG(PSS_DATA));
333
334 limit = jiffies + HZ/10;
335 for (i = 0; i < 32768 && (limit - jiffies >= 0); i++)
336 val = inw(REG(PSS_STATUS));
337
338 limit = jiffies + HZ/10;
339 for (i = 0; i < 32768 && (limit-jiffies >= 0); i++)
340 {
341 val = inw(REG(PSS_STATUS));
342 if (val & 0x4000)
343 break;
344 }
345
346 /* now read the version */
347 for (i = 0; i < 32000; i++)
348 {
349 val = inw(REG(PSS_STATUS));
350 if (val & PSS_READ_FULL)
351 break;
352 }
353 if (i == 32000)
354 return 0;
355
356 val = inw(REG(PSS_DATA));
357 /* printk( "<PSS: microcode version %d.%d loaded>", val/16, val % 16); */
358 }
359 return 1;
360 }
361
362 /* Mixer */
363 static void set_master_volume(pss_confdata *devc, int left, int right)
364 {
365 static unsigned char log_scale[101] = {
366 0xdb, 0xe0, 0xe3, 0xe5, 0xe7, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xed, 0xee,
367 0xef, 0xef, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3,
368 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7,
369 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9,
370 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb,
371 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc,
372 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd,
373 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
374 0xfe, 0xfe, 0xff, 0xff, 0xff
375 };
376 pss_write(devc, 0x0010);
377 pss_write(devc, log_scale[left] | 0x0000);
378 pss_write(devc, 0x0010);
379 pss_write(devc, log_scale[right] | 0x0100);
380 }
381
382 static void set_synth_volume(pss_confdata *devc, int volume)
383 {
384 int vol = ((0x8000*volume)/100L);
385 pss_write(devc, 0x0080);
386 pss_write(devc, vol);
387 pss_write(devc, 0x0081);
388 pss_write(devc, vol);
389 }
390
391 static void set_bass(pss_confdata *devc, int level)
392 {
393 int vol = (int)(((0xfd - 0xf0) * level)/100L) + 0xf0;
394 pss_write(devc, 0x0010);
395 pss_write(devc, vol | 0x0200);
396 };
397
398 static void set_treble(pss_confdata *devc, int level)
399 {
400 int vol = (((0xfd - 0xf0) * level)/100L) + 0xf0;
401 pss_write(devc, 0x0010);
402 pss_write(devc, vol | 0x0300);
403 };
404
405 static void pss_mixer_reset(pss_confdata *devc)
406 {
407 set_master_volume(devc, 33, 33);
408 set_bass(devc, 50);
409 set_treble(devc, 50);
410 set_synth_volume(devc, 30);
411 pss_write (devc, 0x0010);
412 pss_write (devc, 0x0800 | 0xce); /* Stereo */
413
414 if(pss_mixer)
415 {
416 devc->mixer.volume_l = devc->mixer.volume_r = 33;
417 devc->mixer.bass = 50;
418 devc->mixer.treble = 50;
419 devc->mixer.synth = 30;
420 }
421 }
422
423 static void arg_to_volume_mono(unsigned int volume, int *aleft)
424 {
425 int left;
426
427 left = volume & 0x00ff;
428 if (left > 100)
429 left = 100;
430 *aleft = left;
431 }
432
433 static void arg_to_volume_stereo(unsigned int volume, int *aleft, int *aright)
434 {
435 arg_to_volume_mono(volume, aleft);
436 arg_to_volume_mono(volume >> 8, aright);
437 }
438
439 static int ret_vol_mono(int left)
440 {
441 return ((left << 8) | left);
442 }
443
444 static int ret_vol_stereo(int left, int right)
445 {
446 return ((right << 8) | left);
447 }
448
449 static int call_ad_mixer(pss_confdata *devc,unsigned int cmd, caddr_t arg)
450 {
451 if (devc->ad_mixer_dev != NO_WSS_MIXER)
452 return mixer_devs[devc->ad_mixer_dev]->ioctl(devc->ad_mixer_dev, cmd, arg);
453 else
454 return -EINVAL;
455 }
456
457 static int pss_mixer_ioctl (int dev, unsigned int cmd, caddr_t arg)
458 {
459 pss_confdata *devc = mixer_devs[dev]->devc;
460 int cmdf = cmd & 0xff;
461
462 if ((cmdf != SOUND_MIXER_VOLUME) && (cmdf != SOUND_MIXER_BASS) &&
463 (cmdf != SOUND_MIXER_TREBLE) && (cmdf != SOUND_MIXER_SYNTH) &&
464 (cmdf != SOUND_MIXER_DEVMASK) && (cmdf != SOUND_MIXER_STEREODEVS) &&
465 (cmdf != SOUND_MIXER_RECMASK) && (cmdf != SOUND_MIXER_CAPS) &&
466 (cmdf != SOUND_MIXER_RECSRC))
467 {
468 return call_ad_mixer(devc, cmd, arg);
469 }
470
471 if (((cmd >> 8) & 0xff) != 'M')
472 return -EINVAL;
473
474 if (_SIOC_DIR (cmd) & _SIOC_WRITE)
475 {
476 switch (cmdf)
477 {
478 case SOUND_MIXER_RECSRC:
479 if (devc->ad_mixer_dev != NO_WSS_MIXER)
480 return call_ad_mixer(devc, cmd, arg);
481 else
482 {
483 if (*(int *)arg != 0)
484 return -EINVAL;
485 return 0;
486 }
487 case SOUND_MIXER_VOLUME:
488 arg_to_volume_stereo(*(unsigned int *)arg, &devc->mixer.volume_l,
489 &devc->mixer.volume_r);
490 set_master_volume(devc, devc->mixer.volume_l,
491 devc->mixer.volume_r);
492 return ret_vol_stereo(devc->mixer.volume_l,
493 devc->mixer.volume_r);
494
495 case SOUND_MIXER_BASS:
496 arg_to_volume_mono(*(unsigned int *)arg,
497 &devc->mixer.bass);
498 set_bass(devc, devc->mixer.bass);
499 return ret_vol_mono(devc->mixer.bass);
500
501 case SOUND_MIXER_TREBLE:
502 arg_to_volume_mono(*(unsigned int *)arg,
503 &devc->mixer.treble);
504 set_treble(devc, devc->mixer.treble);
505 return ret_vol_mono(devc->mixer.treble);
506
507 case SOUND_MIXER_SYNTH:
508 arg_to_volume_mono(*(unsigned int *)arg,
509 &devc->mixer.synth);
510 set_synth_volume(devc, devc->mixer.synth);
511 return ret_vol_mono(devc->mixer.synth);
512
513 default:
514 return -EINVAL;
515 }
516 }
517 else
518 {
519 /*
520 * Return parameters
521 */
522 switch (cmdf)
523 {
524
525 case SOUND_MIXER_DEVMASK:
526 if (call_ad_mixer(devc, cmd, arg) == -EINVAL)
527 *(int *)arg = 0; /* no mixer devices */
528 return (*(int *)arg |= SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE | SOUND_MASK_SYNTH);
529
530 case SOUND_MIXER_STEREODEVS:
531 if (call_ad_mixer(devc, cmd, arg) == -EINVAL)
532 *(int *)arg = 0; /* no stereo devices */
533 return (*(int *)arg |= SOUND_MASK_VOLUME);
534
535 case SOUND_MIXER_RECMASK:
536 if (devc->ad_mixer_dev != NO_WSS_MIXER)
537 return call_ad_mixer(devc, cmd, arg);
538 else
539 return (*(int *)arg = 0); /* no record devices */
540
541 case SOUND_MIXER_CAPS:
542 if (devc->ad_mixer_dev != NO_WSS_MIXER)
543 return call_ad_mixer(devc, cmd, arg);
544 else
545 return (*(int *)arg = SOUND_CAP_EXCL_INPUT);
546
547 case SOUND_MIXER_RECSRC:
548 if (devc->ad_mixer_dev != NO_WSS_MIXER)
549 return call_ad_mixer(devc, cmd, arg);
550 else
551 return (*(int *)arg = 0); /* no record source */
552
553 case SOUND_MIXER_VOLUME:
554 return (*(int *)arg = ret_vol_stereo(devc->mixer.volume_l, devc->mixer.volume_r));
555
556 case SOUND_MIXER_BASS:
557 return (*(int *)arg = ret_vol_mono(devc->mixer.bass));
558
559 case SOUND_MIXER_TREBLE:
560 return (*(int *)arg = ret_vol_mono(devc->mixer.treble));
561
562 case SOUND_MIXER_SYNTH:
563 return (*(int *)arg = ret_vol_mono(devc->mixer.synth));
564 default:
565 return -EINVAL;
566 }
567 }
568 }
569
570 static struct mixer_operations pss_mixer_operations =
571 {
572 "SOUNDPORT",
573 "PSS-AD1848",
574 pss_mixer_ioctl
575 };
576
577 void attach_pss(struct address_info *hw_config)
578 {
579 unsigned short id;
580 char tmp[100];
581
582 devc->base = hw_config->io_base;
583 devc->irq = hw_config->irq;
584 devc->dma = hw_config->dma;
585 devc->osp = hw_config->osp;
586 devc->ad_mixer_dev = NO_WSS_MIXER;
587
588 if (!probe_pss(hw_config))
589 return;
590
591 request_region(hw_config->io_base, 0x10, "PSS mixer, SB emulation");
592 request_region(hw_config->io_base + 0x10, 0x9, "PSS config");
593
594 id = inw(REG(PSS_ID)) & 0x00ff;
595
596 /*
597 * Disable all emulations. Will be enabled later (if required).
598 */
599 outw(0x0000, REG(CONF_PSS)); /* 0x0400 enables joystick */
600 outw(0x0000, REG(CONF_WSS));
601 outw(0x0000, REG(CONF_SB));
602 outw(0x0000, REG(CONF_MIDI));
603 outw(0x0000, REG(CONF_CDROM));
604
605 #if YOU_REALLY_WANT_TO_ALLOCATE_THESE_RESOURCES
606 if (sound_alloc_dma(hw_config->dma, "PSS"))
607 {
608 printk("pss.c: Can't allocate DMA channel.\n");
609 return;
610 }
611 if (!set_irq(devc, CONF_PSS, devc->irq))
612 {
613 printk("PSS: IRQ allocation error.\n");
614 return;
615 }
616 if (!set_dma(devc, CONF_PSS, devc->dma))
617 {
618 printk(KERN_ERR "PSS: DMA allocation error\n");
619 return;
620 }
621 #endif
622
623 pss_initialized = 1;
624 sprintf(tmp, "ECHO-PSS Rev. %d", id);
625 conf_printf(tmp, hw_config);
626 }
627
628 int probe_pss_mpu(struct address_info *hw_config)
629 {
630 int timeout;
631
632 if (!pss_initialized)
633 return 0;
634
635 if (check_region(hw_config->io_base, 2))
636 {
637 printk(KERN_ERR "PSS: MPU I/O port conflict\n");
638 return 0;
639 }
640 if (!set_io_base(devc, CONF_MIDI, hw_config->io_base))
641 {
642 printk(KERN_ERR "PSS: MIDI base could not be set.\n");
643 return 0;
644 }
645 if (!set_irq(devc, CONF_MIDI, hw_config->irq))
646 {
647 printk(KERN_ERR "PSS: MIDI IRQ allocation error.\n");
648 return 0;
649 }
650 if (!pss_synthLen)
651 {
652 printk(KERN_ERR "PSS: Can't enable MPU. MIDI synth microcode not available.\n");
653 return 0;
654 }
655 if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
656 {
657 printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
658 return 0;
659 }
660
661 /*
662 * Finally wait until the DSP algorithm has initialized itself and
663 * deactivates receive interrupt.
664 */
665
666 for (timeout = 900000; timeout > 0; timeout--)
667 {
668 if ((inb(hw_config->io_base + 1) & 0x80) == 0) /* Input data avail */
669 inb(hw_config->io_base); /* Discard it */
670 else
671 break; /* No more input */
672 }
673
674 return probe_mpu401(hw_config);
675 }
676
677 static int pss_coproc_open(void *dev_info, int sub_device)
678 {
679 switch (sub_device)
680 {
681 case COPR_MIDI:
682 if (pss_synthLen == 0)
683 {
684 printk(KERN_ERR "PSS: MIDI synth microcode not available.\n");
685 return -EIO;
686 }
687 if (nonstandard_microcode)
688 if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
689 {
690 printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
691 return -EIO;
692 }
693 nonstandard_microcode = 0;
694 break;
695
696 default:
697 }
698 return 0;
699 }
700
701 static void pss_coproc_close(void *dev_info, int sub_device)
702 {
703 return;
704 }
705
706 static void pss_coproc_reset(void *dev_info)
707 {
708 if (pss_synthLen)
709 if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
710 {
711 printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
712 }
713 nonstandard_microcode = 0;
714 }
715
716 static int download_boot_block(void *dev_info, copr_buffer * buf)
717 {
718 if (buf->len <= 0 || buf->len > sizeof(buf->data))
719 return -EINVAL;
720
721 if (!pss_download_boot(devc, buf->data, buf->len, buf->flags))
722 {
723 printk(KERN_ERR "PSS: Unable to load microcode block to DSP.\n");
724 return -EIO;
725 }
726 nonstandard_microcode = 1; /* The MIDI microcode has been overwritten */
727 return 0;
728 }
729
730 static int pss_coproc_ioctl(void *dev_info, unsigned int cmd, caddr_t arg, int local)
731 {
732 copr_buffer *buf;
733 copr_msg *mbuf;
734 copr_debug_buf dbuf;
735 unsigned short tmp;
736 unsigned long flags;
737 unsigned short *data;
738 int i, err;
739 /* printk( "PSS coproc ioctl %x %x %d\n", cmd, arg, local); */
740
741 switch (cmd)
742 {
743 case SNDCTL_COPR_RESET:
744 pss_coproc_reset(dev_info);
745 return 0;
746
747 case SNDCTL_COPR_LOAD:
748 buf = (copr_buffer *) vmalloc(sizeof(copr_buffer));
749 if (buf == NULL)
750 return -ENOSPC;
751 if (copy_from_user(buf, arg, sizeof(copr_buffer))) {
752 vfree(buf);
753 return -EFAULT;
754 }
755 err = download_boot_block(dev_info, buf);
756 vfree(buf);
757 return err;
758
759 case SNDCTL_COPR_SENDMSG:
760 mbuf = (copr_msg *)vmalloc(sizeof(copr_msg));
761 if (mbuf == NULL)
762 return -ENOSPC;
763 if (copy_from_user(mbuf, arg, sizeof(copr_msg))) {
764 vfree(mbuf);
765 return -EFAULT;
766 }
767 data = (unsigned short *)(mbuf->data);
768 save_flags(flags);
769 cli();
770 for (i = 0; i < mbuf->len; i++) {
771 if (!pss_put_dspword(devc, *data++)) {
772 restore_flags(flags);
773 mbuf->len = i; /* feed back number of WORDs sent */
774 err = copy_to_user(arg, mbuf, sizeof(copr_msg));
775 vfree(mbuf);
776 return err ? -EFAULT : -EIO;
777 }
778 }
779 restore_flags(flags);
780 vfree(mbuf);
781 return 0;
782
783 case SNDCTL_COPR_RCVMSG:
784 err = 0;
785 mbuf = (copr_msg *)vmalloc(sizeof(copr_msg));
786 if (mbuf == NULL)
787 return -ENOSPC;
788 data = (unsigned short *)mbuf->data;
789 save_flags(flags);
790 cli();
791 for (i = 0; i < sizeof(mbuf->data)/sizeof(unsigned short); i++) {
792 mbuf->len = i; /* feed back number of WORDs read */
793 if (!pss_get_dspword(devc, data++)) {
794 if (i == 0)
795 err = -EIO;
796 break;
797 }
798 }
799 restore_flags(flags);
800 if (copy_to_user(arg, mbuf, sizeof(copr_msg)))
801 err = -EFAULT;
802 vfree(mbuf);
803 return err;
804
805 case SNDCTL_COPR_RDATA:
806 if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
807 return -EFAULT;
808 save_flags(flags);
809 cli();
810 if (!pss_put_dspword(devc, 0x00d0)) {
811 restore_flags(flags);
812 return -EIO;
813 }
814 if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
815 restore_flags(flags);
816 return -EIO;
817 }
818 if (!pss_get_dspword(devc, &tmp)) {
819 restore_flags(flags);
820 return -EIO;
821 }
822 dbuf.parm1 = tmp;
823 restore_flags(flags);
824 if (copy_to_user(arg, &dbuf, sizeof(dbuf)))
825 return -EFAULT;
826 return 0;
827
828 case SNDCTL_COPR_WDATA:
829 if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
830 return -EFAULT;
831 save_flags(flags);
832 cli();
833 if (!pss_put_dspword(devc, 0x00d1)) {
834 restore_flags(flags);
835 return -EIO;
836 }
837 if (!pss_put_dspword(devc, (unsigned short) (dbuf.parm1 & 0xffff))) {
838 restore_flags(flags);
839 return -EIO;
840 }
841 tmp = (unsigned int)dbuf.parm2 & 0xffff;
842 if (!pss_put_dspword(devc, tmp)) {
843 restore_flags(flags);
844 return -EIO;
845 }
846 restore_flags(flags);
847 return 0;
848
849 case SNDCTL_COPR_WCODE:
850 if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
851 return -EFAULT;
852 save_flags(flags);
853 cli();
854 if (!pss_put_dspword(devc, 0x00d3)) {
855 restore_flags(flags);
856 return -EIO;
857 }
858 if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
859 restore_flags(flags);
860 return -EIO;
861 }
862 tmp = (unsigned int)dbuf.parm2 & 0x00ff;
863 if (!pss_put_dspword(devc, tmp)) {
864 restore_flags(flags);
865 return -EIO;
866 }
867 tmp = ((unsigned int)dbuf.parm2 >> 8) & 0xffff;
868 if (!pss_put_dspword(devc, tmp)) {
869 restore_flags(flags);
870 return -EIO;
871 }
872 restore_flags(flags);
873 return 0;
874
875 case SNDCTL_COPR_RCODE:
876 if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
877 return -EFAULT;
878 save_flags(flags);
879 cli();
880 if (!pss_put_dspword(devc, 0x00d2)) {
881 restore_flags(flags);
882 return -EIO;
883 }
884 if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
885 restore_flags(flags);
886 return -EIO;
887 }
888 if (!pss_get_dspword(devc, &tmp)) { /* Read MSB */
889 restore_flags(flags);
890 return -EIO;
891 }
892 dbuf.parm1 = tmp << 8;
893 if (!pss_get_dspword(devc, &tmp)) { /* Read LSB */
894 restore_flags(flags);
895 return -EIO;
896 }
897 dbuf.parm1 |= tmp & 0x00ff;
898 restore_flags(flags);
899 if (copy_to_user(arg, &dbuf, sizeof(dbuf)))
900 return -EFAULT;
901 return 0;
902
903 default:
904 return -EINVAL;
905 }
906 return -EINVAL;
907 }
908
909 static coproc_operations pss_coproc_operations =
910 {
911 "ADSP-2115",
912 pss_coproc_open,
913 pss_coproc_close,
914 pss_coproc_ioctl,
915 pss_coproc_reset,
916 &pss_data
917 };
918
919 static void __init attach_pss_mpu(struct address_info *hw_config)
920 {
921 attach_mpu401(hw_config); /* Slot 1 */
922 if (hw_config->slots[1] != -1) /* The MPU driver installed itself */
923 midi_devs[hw_config->slots[1]]->coproc = &pss_coproc_operations;
924 }
925
926 static int __init probe_pss_mss(struct address_info *hw_config)
927 {
928 volatile int timeout;
929
930 if (!pss_initialized)
931 return 0;
932
933 if (check_region(hw_config->io_base, 8))
934 {
935 printk(KERN_ERR "PSS: WSS I/O port conflicts.\n");
936 return 0;
937 }
938 if (!set_io_base(devc, CONF_WSS, hw_config->io_base))
939 {
940 printk("PSS: WSS base not settable.\n");
941 return 0;
942 }
943 if (!set_irq(devc, CONF_WSS, hw_config->irq))
944 {
945 printk("PSS: WSS IRQ allocation error.\n");
946 return 0;
947 }
948 if (!set_dma(devc, CONF_WSS, hw_config->dma))
949 {
950 printk(KERN_ERR "PSS: WSS DMA allocation error\n");
951 return 0;
952 }
953 /*
954 * For some reason the card returns 0xff in the WSS status register
955 * immediately after boot. Probably MIDI+SB emulation algorithm
956 * downloaded to the ADSP2115 spends some time initializing the card.
957 * Let's try to wait until it finishes this task.
958 */
959 for (timeout = 0; timeout < 100000 && (inb(hw_config->io_base + WSS_INDEX) &
960 WSS_INITIALIZING); timeout++)
961 ;
962
963 outb((0x0b), hw_config->io_base + WSS_INDEX); /* Required by some cards */
964
965 for (timeout = 0; (inb(hw_config->io_base + WSS_DATA) & WSS_AUTOCALIBRATION) &&
966 (timeout < 100000); timeout++)
967 ;
968
969 return probe_ms_sound(hw_config);
970 }
971
972 static void __init attach_pss_mss(struct address_info *hw_config)
973 {
974 int my_mix = -999; /* gcc shut up */
975
976 devc->ad_mixer_dev = NO_WSS_MIXER;
977 if (pss_mixer)
978 {
979 if ((my_mix = sound_install_mixer (MIXER_DRIVER_VERSION,
980 "PSS-SPEAKERS and AD1848 (through MSS audio codec)",
981 &pss_mixer_operations,
982 sizeof (struct mixer_operations),
983 devc)) < 0)
984 {
985 printk(KERN_ERR "Could not install PSS mixer\n");
986 return;
987 }
988 }
989 pss_mixer_reset(devc);
990 attach_ms_sound(hw_config); /* Slot 0 */
991
992 if (hw_config->slots[0] != -1)
993 {
994 /* The MSS driver installed itself */
995 audio_devs[hw_config->slots[0]]->coproc = &pss_coproc_operations;
996 if (pss_mixer && (num_mixers == (my_mix + 2)))
997 {
998 /* The MSS mixer installed */
999 devc->ad_mixer_dev = audio_devs[hw_config->slots[0]]->mixer_dev;
1000 }
1001 }
1002 }
1003
1004 static inline void __exit unload_pss(struct address_info *hw_config)
1005 {
1006 release_region(hw_config->io_base, 0x10);
1007 release_region(hw_config->io_base+0x10, 0x9);
1008 }
1009
1010 static inline void __exit unload_pss_mpu(struct address_info *hw_config)
1011 {
1012 unload_mpu401(hw_config);
1013 }
1014
1015 static inline void __exit unload_pss_mss(struct address_info *hw_config)
1016 {
1017 unload_ms_sound(hw_config);
1018 }
1019
1020
1021 static struct address_info cfg;
1022 static struct address_info cfg2;
1023 static struct address_info cfg_mpu;
1024
1025 static int pss_io __initdata = -1;
1026 static int mss_io __initdata = -1;
1027 static int mss_irq __initdata = -1;
1028 static int mss_dma __initdata = -1;
1029 static int mpu_io __initdata = -1;
1030 static int mpu_irq __initdata = -1;
1031
1032 MODULE_PARM(pss_io, "i");
1033 MODULE_PARM_DESC(pss_io, "Set i/o base of PSS card (probably 0x220 or 0x240)");
1034 MODULE_PARM(mss_io, "i");
1035 MODULE_PARM_DESC(mss_io, "Set WSS (audio) i/o base (0x530, 0x604, 0xE80, 0xF40, or other. Address must end in 0 or 4 and must be from 0x100 to 0xFF4)");
1036 MODULE_PARM(mss_irq, "i");
1037 MODULE_PARM_DESC(mss_irq, "Set WSS (audio) IRQ (3, 5, 7, 9, 10, 11, 12)");
1038 MODULE_PARM(mss_dma, "i");
1039 MODULE_PARM_DESC(mss_dma, "Set WSS (audio) DMA (0, 1, 3)");
1040 MODULE_PARM(mpu_io, "i");
1041 MODULE_PARM_DESC(mpu_io, "Set MIDI i/o base (0x330 or other. Address must be on 4 location boundaries and must be from 0x100 to 0xFFC)");
1042 MODULE_PARM(mpu_irq, "i");
1043 MODULE_PARM_DESC(mpu_irq, "Set MIDI IRQ (3, 5, 7, 9, 10, 11, 12)");
1044 MODULE_PARM(pss_mixer, "b");
1045 MODULE_PARM_DESC(pss_mixer, "Enable (1) or disable (0) PSS mixer (controlling of output volume, bass, treble, synth volume). The mixer is not available on all PSS cards.");
1046 MODULE_AUTHOR("Hannu Savolainen, Vladimir Michl");
1047 MODULE_DESCRIPTION("Module for PSS sound cards (based on AD1848, ADSP-2115 and ESC614). This module includes control of output amplifier and synth volume of the Beethoven ADSP-16 card (this may work with other PSS cards).\n");
1048
1049 static int fw_load = 0;
1050 static int pssmpu = 0, pssmss = 0;
1051
1052 /*
1053 * Load a PSS sound card module
1054 */
1055
1056 static int __init init_pss(void)
1057 {
1058 cfg.io_base = pss_io;
1059
1060 cfg2.io_base = mss_io;
1061 cfg2.irq = mss_irq;
1062 cfg2.dma = mss_dma;
1063
1064 cfg_mpu.io_base = mpu_io;
1065 cfg_mpu.irq = mpu_irq;
1066
1067 if (cfg.io_base == -1 || cfg2.io_base == -1 || cfg2.irq == -1 || cfg.dma == -1) {
1068 printk(KERN_INFO "pss: mss_io, mss_dma, mss_irq and pss_io must be set.\n");
1069 return -EINVAL;
1070 }
1071
1072 if (!pss_synth) {
1073 fw_load = 1;
1074 pss_synthLen = mod_firmware_load("/etc/sound/pss_synth", (void *) &pss_synth);
1075 }
1076 if (!probe_pss(&cfg))
1077 return -ENODEV;
1078 attach_pss(&cfg);
1079 /*
1080 * Attach stuff
1081 */
1082 if (probe_pss_mpu(&cfg_mpu)) {
1083 pssmpu = 1;
1084 attach_pss_mpu(&cfg_mpu);
1085 }
1086 if (probe_pss_mss(&cfg2)) {
1087 pssmss = 1;
1088 attach_pss_mss(&cfg2);
1089 }
1090 SOUND_LOCK;
1091 return 0;
1092 }
1093
1094 static void __exit cleanup_pss(void)
1095 {
1096 if (fw_load && pss_synth)
1097 vfree(pss_synth);
1098 if (pssmss)
1099 unload_pss_mss(&cfg2);
1100 if (pssmpu)
1101 unload_pss_mpu(&cfg_mpu);
1102 unload_pss(&cfg);
1103 SOUND_LOCK_END;
1104 }
1105
1106 module_init(init_pss);
1107 module_exit(cleanup_pss);
1108
1109 #ifndef MODULE
1110 static int __init setup_pss(char *str)
1111 {
1112 /* io, mss_io, mss_irq, mss_dma, mpu_io, mpu_irq */
1113 int ints[7];
1114
1115 str = get_options(str, ARRAY_SIZE(ints), ints);
1116
1117 pss_io = ints[1];
1118 mss_io = ints[2];
1119 mss_irq = ints[3];
1120 mss_dma = ints[4];
1121 mpu_io = ints[5];
1122 mpu_irq = ints[6];
1123
1124 return 1;
1125 }
1126
1127 __setup("pss=", setup_pss);
1128 #endif
Mirror of the linux-mips.org kernel tree