Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pss.c
Go to the documentation of this file.
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 <[email protected]>
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 <[email protected]>
26  * Fixed computation of mixer volumes
27  * 04-05-1999: Anthony Barbachan <[email protected]>
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 <[email protected]>
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 <[email protected]>
48  * Added module parameter pss_firmware to allow the user to tell
49  * the driver where the firmware file is located. The default
50  * setting is the previous hardcoded setting "/etc/sound/pss_synth".
51  * 00-03-03: Christoph Hellwig <[email protected]>
52  * Adapted to module_init/module_exit
53  * 11-10-2000: Bartlomiej Zolnierkiewicz <[email protected]>
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 bool pss_mixer = 1;
121 #else
122 static bool 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 bool 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 void 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 
243 static int set_dma(pss_confdata * devc, int dev, int dma)
244 {
245  static unsigned short dma_bits[8] =
246  {
247  0x0001, 0x0002, 0x0000, 0x0003,
248  0x0000, 0x0005, 0x0006, 0x0007
249  };
250 
251  unsigned short tmp, bits;
252 
253  if (dma < 0 || dma > 7)
254  return 0;
255 
256  tmp = inw(REG(dev)) & ~0x07; /* Load confreg, mask DMA bits out */
257 
258  if ((bits = dma_bits[dma]) == 0 && dma != 4)
259  {
260  printk(KERN_ERR "PSS: Invalid DMA %d\n", dma);
261  return 0;
262  }
263  outw(tmp | bits, REG(dev));
264  return 1;
265 }
266 
267 static int pss_reset_dsp(pss_confdata * devc)
268 {
269  unsigned long i, limit = jiffies + HZ/10;
270 
271  outw(0x2000, REG(PSS_CONTROL));
272  for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
273  inw(REG(PSS_CONTROL));
274  outw(0x0000, REG(PSS_CONTROL));
275  return 1;
276 }
277 
278 static int pss_put_dspword(pss_confdata * devc, unsigned short word)
279 {
280  int i, val;
281 
282  for (i = 0; i < 327680; i++)
283  {
284  val = inw(REG(PSS_STATUS));
285  if (val & PSS_WRITE_EMPTY)
286  {
287  outw(word, REG(PSS_DATA));
288  return 1;
289  }
290  }
291  return 0;
292 }
293 
294 static int pss_get_dspword(pss_confdata * devc, unsigned short *word)
295 {
296  int i, val;
297 
298  for (i = 0; i < 327680; i++)
299  {
300  val = inw(REG(PSS_STATUS));
301  if (val & PSS_READ_FULL)
302  {
303  *word = inw(REG(PSS_DATA));
304  return 1;
305  }
306  }
307  return 0;
308 }
309 
310 static int pss_download_boot(pss_confdata * devc, unsigned char *block, int size, int flags)
311 {
312  int i, val, count;
313  unsigned long limit;
314 
315  if (flags & CPF_FIRST)
316  {
317 /*_____ Warn DSP software that a boot is coming */
318  outw(0x00fe, REG(PSS_DATA));
319 
320  limit = jiffies + HZ/10;
321  for (i = 0; i < 32768 && time_before(jiffies, limit); i++)
322  if (inw(REG(PSS_DATA)) == 0x5500)
323  break;
324 
325  outw(*block++, REG(PSS_DATA));
326  pss_reset_dsp(devc);
327  }
328  count = 1;
329  while ((flags&CPF_LAST) || count<size )
330  {
331  int j;
332 
333  for (j = 0; j < 327670; j++)
334  {
335 /*_____ Wait for BG to appear */
336  if (inw(REG(PSS_STATUS)) & PSS_FLAG3)
337  break;
338  }
339 
340  if (j == 327670)
341  {
342  /* It's ok we timed out when the file was empty */
343  if (count >= size && flags & CPF_LAST)
344  break;
345  else
346  {
347  printk("\n");
348  printk(KERN_ERR "PSS: Download timeout problems, byte %d=%d\n", count, size);
349  return 0;
350  }
351  }
352 /*_____ Send the next byte */
353  if (count >= size)
354  {
355  /* If not data in block send 0xffff */
356  outw (0xffff, REG (PSS_DATA));
357  }
358  else
359  {
360  /*_____ Send the next byte */
361  outw (*block++, REG (PSS_DATA));
362  }
363  count++;
364  }
365 
366  if (flags & CPF_LAST)
367  {
368 /*_____ Why */
369  outw(0, REG(PSS_DATA));
370 
371  limit = jiffies + HZ/10;
372  for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
373  val = inw(REG(PSS_STATUS));
374 
375  limit = jiffies + HZ/10;
376  for (i = 0; i < 32768 && time_after_eq(limit, jiffies); i++)
377  {
378  val = inw(REG(PSS_STATUS));
379  if (val & 0x4000)
380  break;
381  }
382 
383  /* now read the version */
384  for (i = 0; i < 32000; i++)
385  {
386  val = inw(REG(PSS_STATUS));
387  if (val & PSS_READ_FULL)
388  break;
389  }
390  if (i == 32000)
391  return 0;
392 
393  val = inw(REG(PSS_DATA));
394  /* printk( "<PSS: microcode version %d.%d loaded>", val/16, val % 16); */
395  }
396  return 1;
397 }
398 
399 /* Mixer */
400 static void set_master_volume(pss_confdata *devc, int left, int right)
401 {
402  static unsigned char log_scale[101] = {
403  0xdb, 0xe0, 0xe3, 0xe5, 0xe7, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xed, 0xee,
404  0xef, 0xef, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3,
405  0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7,
406  0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9,
407  0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb,
408  0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc,
409  0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd,
410  0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe,
411  0xfe, 0xfe, 0xff, 0xff, 0xff
412  };
413  pss_write(devc, 0x0010);
414  pss_write(devc, log_scale[left] | 0x0000);
415  pss_write(devc, 0x0010);
416  pss_write(devc, log_scale[right] | 0x0100);
417 }
418 
419 static void set_synth_volume(pss_confdata *devc, int volume)
420 {
421  int vol = ((0x8000*volume)/100L);
422  pss_write(devc, 0x0080);
423  pss_write(devc, vol);
424  pss_write(devc, 0x0081);
425  pss_write(devc, vol);
426 }
427 
428 static void set_bass(pss_confdata *devc, int level)
429 {
430  int vol = (int)(((0xfd - 0xf0) * level)/100L) + 0xf0;
431  pss_write(devc, 0x0010);
432  pss_write(devc, vol | 0x0200);
433 };
434 
435 static void set_treble(pss_confdata *devc, int level)
436 {
437  int vol = (((0xfd - 0xf0) * level)/100L) + 0xf0;
438  pss_write(devc, 0x0010);
439  pss_write(devc, vol | 0x0300);
440 };
441 
442 static void pss_mixer_reset(pss_confdata *devc)
443 {
444  set_master_volume(devc, 33, 33);
445  set_bass(devc, 50);
446  set_treble(devc, 50);
447  set_synth_volume(devc, 30);
448  pss_write (devc, 0x0010);
449  pss_write (devc, 0x0800 | 0xce); /* Stereo */
450 
451  if(pss_mixer)
452  {
453  devc->mixer.volume_l = devc->mixer.volume_r = 33;
454  devc->mixer.bass = 50;
455  devc->mixer.treble = 50;
456  devc->mixer.synth = 30;
457  }
458 }
459 
460 static int set_volume_mono(unsigned __user *p, unsigned int *aleft)
461 {
462  unsigned int left, volume;
463  if (get_user(volume, p))
464  return -EFAULT;
465 
466  left = volume & 0xff;
467  if (left > 100)
468  left = 100;
469  *aleft = left;
470  return 0;
471 }
472 
473 static int set_volume_stereo(unsigned __user *p,
474  unsigned int *aleft,
475  unsigned int *aright)
476 {
477  unsigned int left, right, volume;
478  if (get_user(volume, p))
479  return -EFAULT;
480 
481  left = volume & 0xff;
482  if (left > 100)
483  left = 100;
484  right = (volume >> 8) & 0xff;
485  if (right > 100)
486  right = 100;
487  *aleft = left;
488  *aright = right;
489  return 0;
490 }
491 
492 static int ret_vol_mono(int left)
493 {
494  return ((left << 8) | left);
495 }
496 
497 static int ret_vol_stereo(int left, int right)
498 {
499  return ((right << 8) | left);
500 }
501 
502 static int call_ad_mixer(pss_confdata *devc,unsigned int cmd, void __user *arg)
503 {
504  if (devc->ad_mixer_dev != NO_WSS_MIXER)
505  return mixer_devs[devc->ad_mixer_dev]->ioctl(devc->ad_mixer_dev, cmd, arg);
506  else
507  return -EINVAL;
508 }
509 
510 static int pss_mixer_ioctl (int dev, unsigned int cmd, void __user *arg)
511 {
512  pss_confdata *devc = mixer_devs[dev]->devc;
513  int cmdf = cmd & 0xff;
514 
515  if ((cmdf != SOUND_MIXER_VOLUME) && (cmdf != SOUND_MIXER_BASS) &&
516  (cmdf != SOUND_MIXER_TREBLE) && (cmdf != SOUND_MIXER_SYNTH) &&
517  (cmdf != SOUND_MIXER_DEVMASK) && (cmdf != SOUND_MIXER_STEREODEVS) &&
518  (cmdf != SOUND_MIXER_RECMASK) && (cmdf != SOUND_MIXER_CAPS) &&
519  (cmdf != SOUND_MIXER_RECSRC))
520  {
521  return call_ad_mixer(devc, cmd, arg);
522  }
523 
524  if (((cmd >> 8) & 0xff) != 'M')
525  return -EINVAL;
526 
527  if (_SIOC_DIR (cmd) & _SIOC_WRITE)
528  {
529  switch (cmdf)
530  {
531  case SOUND_MIXER_RECSRC:
532  if (devc->ad_mixer_dev != NO_WSS_MIXER)
533  return call_ad_mixer(devc, cmd, arg);
534  else
535  {
536  int v;
537  if (get_user(v, (int __user *)arg))
538  return -EFAULT;
539  if (v != 0)
540  return -EINVAL;
541  return 0;
542  }
543  case SOUND_MIXER_VOLUME:
544  if (set_volume_stereo(arg,
545  &devc->mixer.volume_l,
546  &devc->mixer.volume_r))
547  return -EFAULT;
548  set_master_volume(devc, devc->mixer.volume_l,
549  devc->mixer.volume_r);
550  return ret_vol_stereo(devc->mixer.volume_l,
551  devc->mixer.volume_r);
552 
553  case SOUND_MIXER_BASS:
554  if (set_volume_mono(arg, &devc->mixer.bass))
555  return -EFAULT;
556  set_bass(devc, devc->mixer.bass);
557  return ret_vol_mono(devc->mixer.bass);
558 
559  case SOUND_MIXER_TREBLE:
560  if (set_volume_mono(arg, &devc->mixer.treble))
561  return -EFAULT;
562  set_treble(devc, devc->mixer.treble);
563  return ret_vol_mono(devc->mixer.treble);
564 
565  case SOUND_MIXER_SYNTH:
566  if (set_volume_mono(arg, &devc->mixer.synth))
567  return -EFAULT;
568  set_synth_volume(devc, devc->mixer.synth);
569  return ret_vol_mono(devc->mixer.synth);
570 
571  default:
572  return -EINVAL;
573  }
574  }
575  else
576  {
577  int val, and_mask = 0, or_mask = 0;
578  /*
579  * Return parameters
580  */
581  switch (cmdf)
582  {
583  case SOUND_MIXER_DEVMASK:
584  if (call_ad_mixer(devc, cmd, arg) == -EINVAL)
585  break;
586  and_mask = ~0;
587  or_mask = SOUND_MASK_VOLUME | SOUND_MASK_BASS | SOUND_MASK_TREBLE | SOUND_MASK_SYNTH;
588  break;
589 
590  case SOUND_MIXER_STEREODEVS:
591  if (call_ad_mixer(devc, cmd, arg) == -EINVAL)
592  break;
593  and_mask = ~0;
594  or_mask = SOUND_MASK_VOLUME;
595  break;
596 
597  case SOUND_MIXER_RECMASK:
598  if (devc->ad_mixer_dev != NO_WSS_MIXER)
599  return call_ad_mixer(devc, cmd, arg);
600  break;
601 
602  case SOUND_MIXER_CAPS:
603  if (devc->ad_mixer_dev != NO_WSS_MIXER)
604  return call_ad_mixer(devc, cmd, arg);
605  or_mask = SOUND_CAP_EXCL_INPUT;
606  break;
607 
608  case SOUND_MIXER_RECSRC:
609  if (devc->ad_mixer_dev != NO_WSS_MIXER)
610  return call_ad_mixer(devc, cmd, arg);
611  break;
612 
613  case SOUND_MIXER_VOLUME:
614  or_mask = ret_vol_stereo(devc->mixer.volume_l, devc->mixer.volume_r);
615  break;
616 
617  case SOUND_MIXER_BASS:
618  or_mask = ret_vol_mono(devc->mixer.bass);
619  break;
620 
621  case SOUND_MIXER_TREBLE:
622  or_mask = ret_vol_mono(devc->mixer.treble);
623  break;
624 
625  case SOUND_MIXER_SYNTH:
626  or_mask = ret_vol_mono(devc->mixer.synth);
627  break;
628  default:
629  return -EINVAL;
630  }
631  if (get_user(val, (int __user *)arg))
632  return -EFAULT;
633  val &= and_mask;
634  val |= or_mask;
635  if (put_user(val, (int __user *)arg))
636  return -EFAULT;
637  return val;
638  }
639 }
640 
641 static struct mixer_operations pss_mixer_operations =
642 {
643  .owner = THIS_MODULE,
644  .id = "SOUNDPORT",
645  .name = "PSS-AD1848",
646  .ioctl = pss_mixer_ioctl
647 };
648 
649 static void disable_all_emulations(void)
650 {
651  outw(0x0000, REG(CONF_PSS)); /* 0x0400 enables joystick */
652  outw(0x0000, REG(CONF_WSS));
653  outw(0x0000, REG(CONF_SB));
654  outw(0x0000, REG(CONF_MIDI));
655  outw(0x0000, REG(CONF_CDROM));
656 }
657 
658 static void configure_nonsound_components(void)
659 {
660  /* Configure Joystick port */
661 
662  if(pss_enable_joystick)
663  {
664  outw(0x0400, REG(CONF_PSS)); /* 0x0400 enables joystick */
665  printk(KERN_INFO "PSS: joystick enabled.\n");
666  }
667  else
668  {
669  printk(KERN_INFO "PSS: joystick port not enabled.\n");
670  }
671 
672  /* Configure CDROM port */
673 
674  if (pss_cdrom_port == -1) { /* If cdrom port enablation wasn't requested */
675  printk(KERN_INFO "PSS: CDROM port not enabled.\n");
676  } else if (!request_region(pss_cdrom_port, 2, "PSS CDROM")) {
677  pss_cdrom_port = -1;
678  printk(KERN_ERR "PSS: CDROM I/O port conflict.\n");
679  } else {
680  set_io_base(devc, CONF_CDROM, pss_cdrom_port);
681  printk(KERN_INFO "PSS: CDROM I/O port set to 0x%x.\n", pss_cdrom_port);
682  }
683 }
684 
685 static int __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 0;
698 
699  id = inw(REG(PSS_ID)) & 0x00ff;
700 
701  /*
702  * Disable all emulations. Will be enabled later (if required).
703  */
704 
705  disable_all_emulations();
706 
707 #ifdef YOU_REALLY_WANT_TO_ALLOCATE_THESE_RESOURCES
708  if (sound_alloc_dma(hw_config->dma, "PSS"))
709  {
710  printk("pss.c: Can't allocate DMA channel.\n");
711  release_region(hw_config->io_base, 0x10);
712  release_region(hw_config->io_base+0x10, 0x9);
713  return 0;
714  }
715  if (!set_irq(devc, CONF_PSS, devc->irq))
716  {
717  printk("PSS: IRQ allocation error.\n");
718  release_region(hw_config->io_base, 0x10);
719  release_region(hw_config->io_base+0x10, 0x9);
720  return 0;
721  }
722  if (!set_dma(devc, CONF_PSS, devc->dma))
723  {
724  printk(KERN_ERR "PSS: DMA allocation error\n");
725  release_region(hw_config->io_base, 0x10);
726  release_region(hw_config->io_base+0x10, 0x9);
727  return 0;
728  }
729 #endif
730 
731  configure_nonsound_components();
732  pss_initialized = 1;
733  sprintf(tmp, "ECHO-PSS Rev. %d", id);
734  conf_printf(tmp, hw_config);
735  return 1;
736 }
737 
738 static int __init probe_pss_mpu(struct address_info *hw_config)
739 {
740  struct resource *ports;
741  int timeout;
742 
743  if (!pss_initialized)
744  return 0;
745 
746  ports = request_region(hw_config->io_base, 2, "mpu401");
747 
748  if (!ports) {
749  printk(KERN_ERR "PSS: MPU I/O port conflict\n");
750  return 0;
751  }
752  set_io_base(devc, CONF_MIDI, hw_config->io_base);
753  if (!set_irq(devc, CONF_MIDI, hw_config->irq)) {
754  printk(KERN_ERR "PSS: MIDI IRQ allocation error.\n");
755  goto fail;
756  }
757  if (!pss_synthLen) {
758  printk(KERN_ERR "PSS: Can't enable MPU. MIDI synth microcode not available.\n");
759  goto fail;
760  }
761  if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST)) {
762  printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
763  goto fail;
764  }
765 
766  /*
767  * Finally wait until the DSP algorithm has initialized itself and
768  * deactivates receive interrupt.
769  */
770 
771  for (timeout = 900000; timeout > 0; timeout--)
772  {
773  if ((inb(hw_config->io_base + 1) & 0x80) == 0) /* Input data avail */
774  inb(hw_config->io_base); /* Discard it */
775  else
776  break; /* No more input */
777  }
778 
779  if (!probe_mpu401(hw_config, ports))
780  goto fail;
781 
782  attach_mpu401(hw_config, THIS_MODULE); /* Slot 1 */
783  if (hw_config->slots[1] != -1) /* The MPU driver installed itself */
784  midi_devs[hw_config->slots[1]]->coproc = &pss_coproc_operations;
785  return 1;
786 fail:
787  release_region(hw_config->io_base, 2);
788  return 0;
789 }
790 
791 static int pss_coproc_open(void *dev_info, int sub_device)
792 {
793  switch (sub_device)
794  {
795  case COPR_MIDI:
796  if (pss_synthLen == 0)
797  {
798  printk(KERN_ERR "PSS: MIDI synth microcode not available.\n");
799  return -EIO;
800  }
801  if (nonstandard_microcode)
802  if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
803  {
804  printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
805  return -EIO;
806  }
807  nonstandard_microcode = 0;
808  break;
809 
810  default:
811  break;
812  }
813  return 0;
814 }
815 
816 static void pss_coproc_close(void *dev_info, int sub_device)
817 {
818  return;
819 }
820 
821 static void pss_coproc_reset(void *dev_info)
822 {
823  if (pss_synthLen)
824  if (!pss_download_boot(devc, pss_synth, pss_synthLen, CPF_FIRST | CPF_LAST))
825  {
826  printk(KERN_ERR "PSS: Unable to load MIDI synth microcode to DSP.\n");
827  }
828  nonstandard_microcode = 0;
829 }
830 
831 static int download_boot_block(void *dev_info, copr_buffer * buf)
832 {
833  if (buf->len <= 0 || buf->len > sizeof(buf->data))
834  return -EINVAL;
835 
836  if (!pss_download_boot(devc, buf->data, buf->len, buf->flags))
837  {
838  printk(KERN_ERR "PSS: Unable to load microcode block to DSP.\n");
839  return -EIO;
840  }
841  nonstandard_microcode = 1; /* The MIDI microcode has been overwritten */
842  return 0;
843 }
844 
845 static int pss_coproc_ioctl(void *dev_info, unsigned int cmd, void __user *arg, int local)
846 {
847  copr_buffer *buf;
848  copr_msg *mbuf;
849  copr_debug_buf dbuf;
850  unsigned short tmp;
851  unsigned long flags;
852  unsigned short *data;
853  int i, err;
854  /* printk( "PSS coproc ioctl %x %x %d\n", cmd, arg, local); */
855 
856  switch (cmd)
857  {
858  case SNDCTL_COPR_RESET:
859  pss_coproc_reset(dev_info);
860  return 0;
861 
862  case SNDCTL_COPR_LOAD:
863  buf = vmalloc(sizeof(copr_buffer));
864  if (buf == NULL)
865  return -ENOSPC;
866  if (copy_from_user(buf, arg, sizeof(copr_buffer))) {
867  vfree(buf);
868  return -EFAULT;
869  }
870  err = download_boot_block(dev_info, buf);
871  vfree(buf);
872  return err;
873 
874  case SNDCTL_COPR_SENDMSG:
875  mbuf = vmalloc(sizeof(copr_msg));
876  if (mbuf == NULL)
877  return -ENOSPC;
878  if (copy_from_user(mbuf, arg, sizeof(copr_msg))) {
879  vfree(mbuf);
880  return -EFAULT;
881  }
882  data = (unsigned short *)(mbuf->data);
883  spin_lock_irqsave(&lock, flags);
884  for (i = 0; i < mbuf->len; i++) {
885  if (!pss_put_dspword(devc, *data++)) {
886  spin_unlock_irqrestore(&lock,flags);
887  mbuf->len = i; /* feed back number of WORDs sent */
888  err = copy_to_user(arg, mbuf, sizeof(copr_msg));
889  vfree(mbuf);
890  return err ? -EFAULT : -EIO;
891  }
892  }
893  spin_unlock_irqrestore(&lock,flags);
894  vfree(mbuf);
895  return 0;
896 
897  case SNDCTL_COPR_RCVMSG:
898  err = 0;
899  mbuf = vmalloc(sizeof(copr_msg));
900  if (mbuf == NULL)
901  return -ENOSPC;
902  data = (unsigned short *)mbuf->data;
903  spin_lock_irqsave(&lock, flags);
904  for (i = 0; i < sizeof(mbuf->data)/sizeof(unsigned short); i++) {
905  mbuf->len = i; /* feed back number of WORDs read */
906  if (!pss_get_dspword(devc, data++)) {
907  if (i == 0)
908  err = -EIO;
909  break;
910  }
911  }
912  spin_unlock_irqrestore(&lock,flags);
913  if (copy_to_user(arg, mbuf, sizeof(copr_msg)))
914  err = -EFAULT;
915  vfree(mbuf);
916  return err;
917 
918  case SNDCTL_COPR_RDATA:
919  if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
920  return -EFAULT;
921  spin_lock_irqsave(&lock, flags);
922  if (!pss_put_dspword(devc, 0x00d0)) {
923  spin_unlock_irqrestore(&lock,flags);
924  return -EIO;
925  }
926  if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
927  spin_unlock_irqrestore(&lock,flags);
928  return -EIO;
929  }
930  if (!pss_get_dspword(devc, &tmp)) {
931  spin_unlock_irqrestore(&lock,flags);
932  return -EIO;
933  }
934  dbuf.parm1 = tmp;
935  spin_unlock_irqrestore(&lock,flags);
936  if (copy_to_user(arg, &dbuf, sizeof(dbuf)))
937  return -EFAULT;
938  return 0;
939 
940  case SNDCTL_COPR_WDATA:
941  if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
942  return -EFAULT;
943  spin_lock_irqsave(&lock, flags);
944  if (!pss_put_dspword(devc, 0x00d1)) {
945  spin_unlock_irqrestore(&lock,flags);
946  return -EIO;
947  }
948  if (!pss_put_dspword(devc, (unsigned short) (dbuf.parm1 & 0xffff))) {
949  spin_unlock_irqrestore(&lock,flags);
950  return -EIO;
951  }
952  tmp = (unsigned int)dbuf.parm2 & 0xffff;
953  if (!pss_put_dspword(devc, tmp)) {
954  spin_unlock_irqrestore(&lock,flags);
955  return -EIO;
956  }
957  spin_unlock_irqrestore(&lock,flags);
958  return 0;
959 
960  case SNDCTL_COPR_WCODE:
961  if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
962  return -EFAULT;
963  spin_lock_irqsave(&lock, flags);
964  if (!pss_put_dspword(devc, 0x00d3)) {
965  spin_unlock_irqrestore(&lock,flags);
966  return -EIO;
967  }
968  if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
969  spin_unlock_irqrestore(&lock,flags);
970  return -EIO;
971  }
972  tmp = (unsigned int)dbuf.parm2 & 0x00ff;
973  if (!pss_put_dspword(devc, tmp)) {
974  spin_unlock_irqrestore(&lock,flags);
975  return -EIO;
976  }
977  tmp = ((unsigned int)dbuf.parm2 >> 8) & 0xffff;
978  if (!pss_put_dspword(devc, tmp)) {
979  spin_unlock_irqrestore(&lock,flags);
980  return -EIO;
981  }
982  spin_unlock_irqrestore(&lock,flags);
983  return 0;
984 
985  case SNDCTL_COPR_RCODE:
986  if (copy_from_user(&dbuf, arg, sizeof(dbuf)))
987  return -EFAULT;
988  spin_lock_irqsave(&lock, flags);
989  if (!pss_put_dspword(devc, 0x00d2)) {
990  spin_unlock_irqrestore(&lock,flags);
991  return -EIO;
992  }
993  if (!pss_put_dspword(devc, (unsigned short)(dbuf.parm1 & 0xffff))) {
994  spin_unlock_irqrestore(&lock,flags);
995  return -EIO;
996  }
997  if (!pss_get_dspword(devc, &tmp)) { /* Read MSB */
998  spin_unlock_irqrestore(&lock,flags);
999  return -EIO;
1000  }
1001  dbuf.parm1 = tmp << 8;
1002  if (!pss_get_dspword(devc, &tmp)) { /* Read LSB */
1003  spin_unlock_irqrestore(&lock,flags);
1004  return -EIO;
1005  }
1006  dbuf.parm1 |= tmp & 0x00ff;
1007  spin_unlock_irqrestore(&lock,flags);
1008  if (copy_to_user(arg, &dbuf, sizeof(dbuf)))
1009  return -EFAULT;
1010  return 0;
1011 
1012  default:
1013  return -EINVAL;
1014  }
1015  return -EINVAL;
1016 }
1017 
1018 static coproc_operations pss_coproc_operations =
1019 {
1020  "ADSP-2115",
1021  THIS_MODULE,
1022  pss_coproc_open,
1023  pss_coproc_close,
1024  pss_coproc_ioctl,
1025  pss_coproc_reset,
1026  &pss_data
1027 };
1028 
1029 static int __init probe_pss_mss(struct address_info *hw_config)
1030 {
1031  volatile int timeout;
1032  struct resource *ports;
1033  int my_mix = -999; /* gcc shut up */
1034 
1035  if (!pss_initialized)
1036  return 0;
1037 
1038  if (!request_region(hw_config->io_base, 4, "WSS config")) {
1039  printk(KERN_ERR "PSS: WSS I/O port conflicts.\n");
1040  return 0;
1041  }
1042  ports = request_region(hw_config->io_base + 4, 4, "ad1848");
1043  if (!ports) {
1044  printk(KERN_ERR "PSS: WSS I/O port conflicts.\n");
1045  release_region(hw_config->io_base, 4);
1046  return 0;
1047  }
1048  set_io_base(devc, CONF_WSS, hw_config->io_base);
1049  if (!set_irq(devc, CONF_WSS, hw_config->irq)) {
1050  printk("PSS: WSS IRQ allocation error.\n");
1051  goto fail;
1052  }
1053  if (!set_dma(devc, CONF_WSS, hw_config->dma)) {
1054  printk(KERN_ERR "PSS: WSS DMA allocation error\n");
1055  goto fail;
1056  }
1057  /*
1058  * For some reason the card returns 0xff in the WSS status register
1059  * immediately after boot. Probably MIDI+SB emulation algorithm
1060  * downloaded to the ADSP2115 spends some time initializing the card.
1061  * Let's try to wait until it finishes this task.
1062  */
1063  for (timeout = 0; timeout < 100000 && (inb(hw_config->io_base + WSS_INDEX) &
1064  WSS_INITIALIZING); timeout++)
1065  ;
1066 
1067  outb((0x0b), hw_config->io_base + WSS_INDEX); /* Required by some cards */
1068 
1069  for (timeout = 0; (inb(hw_config->io_base + WSS_DATA) & WSS_AUTOCALIBRATION) &&
1070  (timeout < 100000); timeout++)
1071  ;
1072 
1073  if (!probe_ms_sound(hw_config, ports))
1074  goto fail;
1075 
1076  devc->ad_mixer_dev = NO_WSS_MIXER;
1077  if (pss_mixer)
1078  {
1079  if ((my_mix = sound_install_mixer (MIXER_DRIVER_VERSION,
1080  "PSS-SPEAKERS and AD1848 (through MSS audio codec)",
1081  &pss_mixer_operations,
1082  sizeof (struct mixer_operations),
1083  devc)) < 0)
1084  {
1085  printk(KERN_ERR "Could not install PSS mixer\n");
1086  goto fail;
1087  }
1088  }
1089  pss_mixer_reset(devc);
1090  attach_ms_sound(hw_config, ports, THIS_MODULE); /* Slot 0 */
1091 
1092  if (hw_config->slots[0] != -1)
1093  {
1094  /* The MSS driver installed itself */
1095  audio_devs[hw_config->slots[0]]->coproc = &pss_coproc_operations;
1096  if (pss_mixer && (num_mixers == (my_mix + 2)))
1097  {
1098  /* The MSS mixer installed */
1099  devc->ad_mixer_dev = audio_devs[hw_config->slots[0]]->mixer_dev;
1100  }
1101  }
1102  return 1;
1103 fail:
1104  release_region(hw_config->io_base + 4, 4);
1105  release_region(hw_config->io_base, 4);
1106  return 0;
1107 }
1108 
1109 static inline void __exit unload_pss(struct address_info *hw_config)
1110 {
1111  release_region(hw_config->io_base, 0x10);
1112  release_region(hw_config->io_base+0x10, 0x9);
1113 }
1114 
1115 static inline void __exit unload_pss_mpu(struct address_info *hw_config)
1116 {
1117  unload_mpu401(hw_config);
1118 }
1119 
1120 static inline void __exit unload_pss_mss(struct address_info *hw_config)
1121 {
1122  unload_ms_sound(hw_config);
1123 }
1124 
1125 
1126 static struct address_info cfg;
1127 static struct address_info cfg2;
1128 static struct address_info cfg_mpu;
1129 
1130 static int pss_io __initdata = -1;
1131 static int mss_io __initdata = -1;
1132 static int mss_irq __initdata = -1;
1133 static int mss_dma __initdata = -1;
1134 static int mpu_io __initdata = -1;
1135 static int mpu_irq __initdata = -1;
1136 static bool pss_no_sound = 0; /* Just configure non-sound components */
1137 static bool pss_keep_settings = 1; /* Keep hardware settings at module exit */
1138 static char *pss_firmware = "/etc/sound/pss_synth";
1139 
1140 module_param(pss_io, int, 0);
1141 MODULE_PARM_DESC(pss_io, "Set i/o base of PSS card (probably 0x220 or 0x240)");
1142 module_param(mss_io, int, 0);
1143 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)");
1144 module_param(mss_irq, int, 0);
1145 MODULE_PARM_DESC(mss_irq, "Set WSS (audio) IRQ (3, 5, 7, 9, 10, 11, 12)");
1146 module_param(mss_dma, int, 0);
1147 MODULE_PARM_DESC(mss_dma, "Set WSS (audio) DMA (0, 1, 3)");
1148 module_param(mpu_io, int, 0);
1149 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)");
1150 module_param(mpu_irq, int, 0);
1151 MODULE_PARM_DESC(mpu_irq, "Set MIDI IRQ (3, 5, 7, 9, 10, 11, 12)");
1152 module_param(pss_cdrom_port, int, 0);
1153 MODULE_PARM_DESC(pss_cdrom_port, "Set the PSS CDROM port i/o base (0x340 or other)");
1154 module_param(pss_enable_joystick, bool, 0);
1155 MODULE_PARM_DESC(pss_enable_joystick, "Enables the PSS joystick port (1 to enable, 0 to disable)");
1156 module_param(pss_no_sound, bool, 0);
1157 MODULE_PARM_DESC(pss_no_sound, "Configure sound compoents (0 - no, 1 - yes)");
1158 module_param(pss_keep_settings, bool, 0);
1159 MODULE_PARM_DESC(pss_keep_settings, "Keep hardware setting at driver unloading (0 - no, 1 - yes)");
1160 module_param(pss_firmware, charp, 0);
1161 MODULE_PARM_DESC(pss_firmware, "Location of the firmware file (default - /etc/sound/pss_synth)");
1162 module_param(pss_mixer, bool, 0);
1163 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.");
1164 MODULE_AUTHOR("Hannu Savolainen, Vladimir Michl");
1165 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).");
1166 MODULE_LICENSE("GPL");
1167 
1168 
1169 static int fw_load = 0;
1170 static int pssmpu = 0, pssmss = 0;
1171 
1172 /*
1173  * Load a PSS sound card module
1174  */
1175 
1176 static int __init init_pss(void)
1177 {
1178 
1179  if(pss_no_sound) /* If configuring only nonsound components */
1180  {
1181  cfg.io_base = pss_io;
1182  if(!probe_pss(&cfg))
1183  return -ENODEV;
1184  printk(KERN_INFO "ECHO-PSS Rev. %d\n", inw(REG(PSS_ID)) & 0x00ff);
1185  printk(KERN_INFO "PSS: loading in no sound mode.\n");
1186  disable_all_emulations();
1187  configure_nonsound_components();
1188  release_region(pss_io, 0x10);
1189  release_region(pss_io + 0x10, 0x9);
1190  return 0;
1191  }
1192 
1193  cfg.io_base = pss_io;
1194 
1195  cfg2.io_base = mss_io;
1196  cfg2.irq = mss_irq;
1197  cfg2.dma = mss_dma;
1198 
1199  cfg_mpu.io_base = mpu_io;
1200  cfg_mpu.irq = mpu_irq;
1201 
1202  if (cfg.io_base == -1 || cfg2.io_base == -1 || cfg2.irq == -1 || cfg.dma == -1) {
1203  printk(KERN_INFO "pss: mss_io, mss_dma, mss_irq and pss_io must be set.\n");
1204  return -EINVAL;
1205  }
1206 
1207  if (!pss_synth) {
1208  fw_load = 1;
1209  pss_synthLen = mod_firmware_load(pss_firmware, (void *) &pss_synth);
1210  }
1211  if (!attach_pss(&cfg))
1212  return -ENODEV;
1213  /*
1214  * Attach stuff
1215  */
1216  if (probe_pss_mpu(&cfg_mpu))
1217  pssmpu = 1;
1218 
1219  if (probe_pss_mss(&cfg2))
1220  pssmss = 1;
1221 
1222  return 0;
1223 }
1224 
1225 static void __exit cleanup_pss(void)
1226 {
1227  if(!pss_no_sound)
1228  {
1229  if(fw_load && pss_synth)
1230  vfree(pss_synth);
1231  if(pssmss)
1232  unload_pss_mss(&cfg2);
1233  if(pssmpu)
1234  unload_pss_mpu(&cfg_mpu);
1235  unload_pss(&cfg);
1236  } else if (pss_cdrom_port != -1)
1237  release_region(pss_cdrom_port, 2);
1238 
1239  if(!pss_keep_settings) /* Keep hardware settings if asked */
1240  {
1241  disable_all_emulations();
1242  printk(KERN_INFO "Resetting PSS sound card configurations.\n");
1243  }
1244 }
1245 
1246 module_init(init_pss);
1247 module_exit(cleanup_pss);
1248 
1249 #ifndef MODULE
1250 static int __init setup_pss(char *str)
1251 {
1252  /* io, mss_io, mss_irq, mss_dma, mpu_io, mpu_irq */
1253  int ints[7];
1254 
1255  str = get_options(str, ARRAY_SIZE(ints), ints);
1256 
1257  pss_io = ints[1];
1258  mss_io = ints[2];
1259  mss_irq = ints[3];
1260  mss_dma = ints[4];
1261  mpu_io = ints[5];
1262  mpu_irq = ints[6];
1263 
1264  return 1;
1265 }
1266 
1267 __setup("pss=", setup_pss);
1268 #endif
Generated on Thu Jan 10 2013 15:05:18 for Linux Kernel by   doxygen 1.8.2