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