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