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