1 /*********************************************************************
3 * Turtle Beach MultiSound Sound Card Driver for Linux
4 * Linux 2.0/2.2 Version
6 * msnd_pinnacle.c / msnd_classic.c
8 * -- If MSND_CLASSIC is defined:
10 * -> driver for Turtle Beach Classic/Monterey/Tahiti
14 * -> driver for Turtle Beach Pinnacle/Fiji
16 * Copyright (C) 1998 Andrew Veliath
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; either version 2 of the License, or
21 * (at your option) any later version.
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
28 * You should have received a copy of the GNU General Public License
29 * along with this program; if not, write to the Free Software
30 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32 * 12-3-2000 Modified IO port validation Steve Sycamore
34 ********************************************************************/
36 #include <linux/kernel.h>
37 #include <linux/module.h>
38 #include <linux/types.h>
39 #include <linux/delay.h>
40 #include <linux/init.h>
41 #include <linux/interrupt.h>
42 #include <linux/smp_lock.h>
43 #include <linux/gfp.h>
46 #include "sound_config.h"
47 #include "sound_firmware.h"
55 # ifdef CONFIG_MSNDCLAS_HAVE_BOOT
56 # define HAVE_DSPCODEH
58 # include "msnd_classic.h"
59 # define LOGNAME "msnd_classic"
61 # ifdef CONFIG_MSNDPIN_HAVE_BOOT
62 # define HAVE_DSPCODEH
64 # include "msnd_pinnacle.h"
65 # define LOGNAME "msnd_pinnacle"
68 #ifndef CONFIG_MSND_WRITE_NDELAY
69 # define CONFIG_MSND_WRITE_NDELAY 1
72 #define get_play_delay_jiffies(size) ((size) * HZ * \
73 dev.play_sample_size / 8 / \
74 dev.play_sample_rate / \
77 #define get_rec_delay_jiffies(size) ((size) * HZ * \
78 dev.rec_sample_size / 8 / \
79 dev.rec_sample_rate / \
82 static multisound_dev_t dev;
85 static char *dspini, *permini;
86 static int sizeof_dspini, sizeof_permini;
89 static int dsp_full_reset(void);
90 static void dsp_write_flush(void);
92 static __inline__ int chk_send_dsp_cmd(multisound_dev_t *dev, register BYTE cmd)
94 if (msnd_send_dsp_cmd(dev, cmd) == 0)
97 return msnd_send_dsp_cmd(dev, cmd);
100 static void reset_play_queue(void)
105 dev.last_playbank = -1;
106 writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wHead);
107 writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wTail);
109 for (n = 0, lpDAQ = dev.base + DAPQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
110 writew(PCTODSP_BASED((DWORD)(DAP_BUFF_SIZE * n)), lpDAQ + DAQDS_wStart);
111 writew(0, lpDAQ + DAQDS_wSize);
112 writew(1, lpDAQ + DAQDS_wFormat);
113 writew(dev.play_sample_size, lpDAQ + DAQDS_wSampleSize);
114 writew(dev.play_channels, lpDAQ + DAQDS_wChannels);
115 writew(dev.play_sample_rate, lpDAQ + DAQDS_wSampleRate);
116 writew(HIMT_PLAY_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
117 writew(n, lpDAQ + DAQDS_wFlags);
121 static void reset_record_queue(void)
127 dev.last_recbank = 2;
128 writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DARQ + JQS_wHead);
129 writew(PCTODSP_OFFSET(dev.last_recbank * DAQDS__size), dev.DARQ + JQS_wTail);
131 /* Critical section: bank 1 access */
132 spin_lock_irqsave(&dev.lock, flags);
133 msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
134 memset_io(dev.base, 0, DAR_BUFF_SIZE * 3);
135 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
136 spin_unlock_irqrestore(&dev.lock, flags);
138 for (n = 0, lpDAQ = dev.base + DARQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
139 writew(PCTODSP_BASED((DWORD)(DAR_BUFF_SIZE * n)) + 0x4000, lpDAQ + DAQDS_wStart);
140 writew(DAR_BUFF_SIZE, lpDAQ + DAQDS_wSize);
141 writew(1, lpDAQ + DAQDS_wFormat);
142 writew(dev.rec_sample_size, lpDAQ + DAQDS_wSampleSize);
143 writew(dev.rec_channels, lpDAQ + DAQDS_wChannels);
144 writew(dev.rec_sample_rate, lpDAQ + DAQDS_wSampleRate);
145 writew(HIMT_RECORD_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
146 writew(n, lpDAQ + DAQDS_wFlags);
150 static void reset_queues(void)
152 if (dev.mode & FMODE_WRITE) {
153 msnd_fifo_make_empty(&dev.DAPF);
156 if (dev.mode & FMODE_READ) {
157 msnd_fifo_make_empty(&dev.DARF);
158 reset_record_queue();
162 static int dsp_set_format(struct file *file, int val)
165 LPDAQD lpDAQ, lpDARQ;
167 lpDAQ = dev.base + DAPQ_DATA_BUFF;
168 lpDARQ = dev.base + DARQ_DATA_BUFF;
176 data = DEFSAMPLESIZE;
180 for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
181 if (file->f_mode & FMODE_WRITE)
182 writew(data, lpDAQ + DAQDS_wSampleSize);
183 if (file->f_mode & FMODE_READ)
184 writew(data, lpDARQ + DAQDS_wSampleSize);
186 if (file->f_mode & FMODE_WRITE)
187 dev.play_sample_size = data;
188 if (file->f_mode & FMODE_READ)
189 dev.rec_sample_size = data;
194 static int dsp_get_frag_size(void)
197 size = dev.fifosize / 4;
198 if (size > 32 * 1024)
203 static int dsp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
205 int val, i, data, tmp;
206 LPDAQD lpDAQ, lpDARQ;
207 audio_buf_info abinfo;
209 int __user *p = (int __user *)arg;
211 lpDAQ = dev.base + DAPQ_DATA_BUFF;
212 lpDARQ = dev.base + DARQ_DATA_BUFF;
215 case SNDCTL_DSP_SUBDIVIDE:
216 case SNDCTL_DSP_SETFRAGMENT:
217 case SNDCTL_DSP_SETDUPLEX:
218 case SNDCTL_DSP_POST:
221 case SNDCTL_DSP_GETIPTR:
222 case SNDCTL_DSP_GETOPTR:
223 case SNDCTL_DSP_MAPINBUF:
224 case SNDCTL_DSP_MAPOUTBUF:
227 case SNDCTL_DSP_GETOSPACE:
228 if (!(file->f_mode & FMODE_WRITE))
230 spin_lock_irqsave(&dev.lock, flags);
231 abinfo.fragsize = dsp_get_frag_size();
232 abinfo.bytes = dev.DAPF.n - dev.DAPF.len;
233 abinfo.fragstotal = dev.DAPF.n / abinfo.fragsize;
234 abinfo.fragments = abinfo.bytes / abinfo.fragsize;
235 spin_unlock_irqrestore(&dev.lock, flags);
236 return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
238 case SNDCTL_DSP_GETISPACE:
239 if (!(file->f_mode & FMODE_READ))
241 spin_lock_irqsave(&dev.lock, flags);
242 abinfo.fragsize = dsp_get_frag_size();
243 abinfo.bytes = dev.DARF.n - dev.DARF.len;
244 abinfo.fragstotal = dev.DARF.n / abinfo.fragsize;
245 abinfo.fragments = abinfo.bytes / abinfo.fragsize;
246 spin_unlock_irqrestore(&dev.lock, flags);
247 return copy_to_user((void __user *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
249 case SNDCTL_DSP_RESET:
254 case SNDCTL_DSP_SYNC:
258 case SNDCTL_DSP_GETBLKSIZE:
259 tmp = dsp_get_frag_size();
260 if (put_user(tmp, p))
264 case SNDCTL_DSP_GETFMTS:
265 val = AFMT_S16_LE | AFMT_U8;
266 if (put_user(val, p))
270 case SNDCTL_DSP_SETFMT:
271 if (get_user(val, p))
274 if (file->f_mode & FMODE_WRITE)
275 data = val == AFMT_QUERY
276 ? dev.play_sample_size
277 : dsp_set_format(file, val);
279 data = val == AFMT_QUERY
280 ? dev.rec_sample_size
281 : dsp_set_format(file, val);
283 if (put_user(data, p))
287 case SNDCTL_DSP_NONBLOCK:
288 if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags) &&
289 file->f_mode & FMODE_WRITE)
291 if (file->f_mode & FMODE_READ)
295 case SNDCTL_DSP_GETCAPS:
296 val = DSP_CAP_DUPLEX | DSP_CAP_BATCH;
297 if (put_user(val, p))
301 case SNDCTL_DSP_SPEED:
302 if (get_user(val, p))
313 for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
314 if (file->f_mode & FMODE_WRITE)
315 writew(data, lpDAQ + DAQDS_wSampleRate);
316 if (file->f_mode & FMODE_READ)
317 writew(data, lpDARQ + DAQDS_wSampleRate);
319 if (file->f_mode & FMODE_WRITE)
320 dev.play_sample_rate = data;
321 if (file->f_mode & FMODE_READ)
322 dev.rec_sample_rate = data;
324 if (put_user(data, p))
328 case SNDCTL_DSP_CHANNELS:
329 case SNDCTL_DSP_STEREO:
330 if (get_user(val, p))
333 if (cmd == SNDCTL_DSP_CHANNELS) {
356 for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
357 if (file->f_mode & FMODE_WRITE)
358 writew(data, lpDAQ + DAQDS_wChannels);
359 if (file->f_mode & FMODE_READ)
360 writew(data, lpDARQ + DAQDS_wChannels);
362 if (file->f_mode & FMODE_WRITE)
363 dev.play_channels = data;
364 if (file->f_mode & FMODE_READ)
365 dev.rec_channels = data;
367 if (put_user(val, p))
375 static int mixer_get(int d)
381 case SOUND_MIXER_VOLUME:
382 case SOUND_MIXER_PCM:
383 case SOUND_MIXER_LINE:
384 case SOUND_MIXER_IMIX:
385 case SOUND_MIXER_LINE1:
387 case SOUND_MIXER_MIC:
388 case SOUND_MIXER_SYNTH:
390 return (dev.left_levels[d] >> 8) * 100 / 0xff |
391 (((dev.right_levels[d] >> 8) * 100 / 0xff) << 8);
397 #define update_volm(a,b) \
398 writew((dev.left_levels[a] >> 1) * \
399 readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff, \
400 dev.SMA + SMA_##b##Left); \
401 writew((dev.right_levels[a] >> 1) * \
402 readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff, \
403 dev.SMA + SMA_##b##Right);
405 #define update_potm(d,s,ar) \
406 writeb((dev.left_levels[d] >> 8) * \
407 readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff, \
408 dev.SMA + SMA_##s##Left); \
409 writeb((dev.right_levels[d] >> 8) * \
410 readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff, \
411 dev.SMA + SMA_##s##Right); \
412 if (msnd_send_word(&dev, 0, 0, ar) == 0) \
413 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
415 #define update_pot(d,s,ar) \
416 writeb(dev.left_levels[d] >> 8, \
417 dev.SMA + SMA_##s##Left); \
418 writeb(dev.right_levels[d] >> 8, \
419 dev.SMA + SMA_##s##Right); \
420 if (msnd_send_word(&dev, 0, 0, ar) == 0) \
421 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
423 static int mixer_set(int d, int value)
425 int left = value & 0x000000ff;
426 int right = (value & 0x0000ff00) >> 8;
429 int updatemaster = 0;
434 bLeft = left * 0xff / 100;
435 wLeft = left * 0xffff / 100;
437 bRight = right * 0xff / 100;
438 wRight = right * 0xffff / 100;
440 dev.left_levels[d] = wLeft;
441 dev.right_levels[d] = wRight;
444 /* master volume unscaled controls */
445 case SOUND_MIXER_LINE: /* line pot control */
446 /* scaled by IMIX in digital mix */
447 writeb(bLeft, dev.SMA + SMA_bInPotPosLeft);
448 writeb(bRight, dev.SMA + SMA_bInPotPosRight);
449 if (msnd_send_word(&dev, 0, 0, HDEXAR_IN_SET_POTS) == 0)
450 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
453 case SOUND_MIXER_MIC: /* mic pot control */
454 /* scaled by IMIX in digital mix */
455 writeb(bLeft, dev.SMA + SMA_bMicPotPosLeft);
456 writeb(bRight, dev.SMA + SMA_bMicPotPosRight);
457 if (msnd_send_word(&dev, 0, 0, HDEXAR_MIC_SET_POTS) == 0)
458 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
461 case SOUND_MIXER_VOLUME: /* master volume */
462 writew(wLeft, dev.SMA + SMA_wCurrMastVolLeft);
463 writew(wRight, dev.SMA + SMA_wCurrMastVolRight);
466 case SOUND_MIXER_LINE1: /* aux pot control */
467 /* scaled by master volume */
470 /* digital controls */
471 case SOUND_MIXER_SYNTH: /* synth vol (dsp mix) */
472 case SOUND_MIXER_PCM: /* pcm vol (dsp mix) */
473 case SOUND_MIXER_IMIX: /* input monitor (dsp mix) */
474 /* scaled by master volume */
483 /* update master volume scaled controls */
484 update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
485 update_volm(SOUND_MIXER_IMIX, wCurrInVol);
487 update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
489 update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
495 static void mixer_setup(void)
497 update_pot(SOUND_MIXER_LINE, bInPotPos, HDEXAR_IN_SET_POTS);
498 update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
499 update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
500 update_volm(SOUND_MIXER_IMIX, wCurrInVol);
502 update_pot(SOUND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
503 update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
507 static unsigned long set_recsrc(unsigned long recsrc)
509 if (dev.recsrc == recsrc)
512 else if (recsrc == 0)
516 dev.recsrc ^= recsrc;
519 if (dev.recsrc & SOUND_MASK_IMIX) {
520 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
521 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
523 else if (dev.recsrc & SOUND_MASK_SYNTH) {
524 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_SYNTH_IN) == 0)
525 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
527 else if ((dev.recsrc & SOUND_MASK_DIGITAL1) && test_bit(F_HAVEDIGITAL, &dev.flags)) {
528 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_DAT_IN) == 0)
529 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
533 /* Select no input (?) */
536 dev.recsrc = SOUND_MASK_IMIX;
537 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
538 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
541 #endif /* MSND_CLASSIC */
546 static unsigned long force_recsrc(unsigned long recsrc)
549 return set_recsrc(recsrc);
552 #define set_mixer_info() \
553 memset(&info, 0, sizeof(info)); \
554 strlcpy(info.id, "MSNDMIXER", sizeof(info.id)); \
555 strlcpy(info.name, "MultiSound Mixer", sizeof(info.name));
557 static int mixer_ioctl(unsigned int cmd, unsigned long arg)
559 if (cmd == SOUND_MIXER_INFO) {
562 info.modify_counter = dev.mixer_mod_count;
563 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
566 } else if (cmd == SOUND_OLD_MIXER_INFO) {
567 _old_mixer_info info;
569 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
572 } else if (cmd == SOUND_MIXER_PRIVATE1) {
576 } else if (((cmd >> 8) & 0xff) == 'M') {
579 if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
580 switch (cmd & 0xff) {
581 case SOUND_MIXER_RECSRC:
582 if (get_user(val, (int __user *)arg))
584 val = set_recsrc(val);
588 if (get_user(val, (int __user *)arg))
590 val = mixer_set(cmd & 0xff, val);
593 ++dev.mixer_mod_count;
594 return put_user(val, (int __user *)arg);
596 switch (cmd & 0xff) {
597 case SOUND_MIXER_RECSRC:
601 case SOUND_MIXER_DEVMASK:
602 case SOUND_MIXER_STEREODEVS:
603 val = SOUND_MASK_PCM |
614 case SOUND_MIXER_RECMASK:
618 val = SOUND_MASK_IMIX |
620 if (test_bit(F_HAVEDIGITAL, &dev.flags))
621 val |= SOUND_MASK_DIGITAL1;
625 case SOUND_MIXER_CAPS:
626 val = SOUND_CAP_EXCL_INPUT;
630 if ((val = mixer_get(cmd & 0xff)) < 0)
636 return put_user(val, (int __user *)arg);
642 static long dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
644 int minor = iminor(file->f_path.dentry->d_inode);
647 if (cmd == OSS_GETVERSION) {
648 int sound_version = SOUND_VERSION;
649 return put_user(sound_version, (int __user *)arg);
655 if (minor == dev.dsp_minor)
656 ret = dsp_ioctl(file, cmd, arg);
657 else if (minor == dev.mixer_minor)
658 ret = mixer_ioctl(cmd, arg);
664 static void dsp_write_flush(void)
666 if (!(dev.mode & FMODE_WRITE) || !test_bit(F_WRITING, &dev.flags))
668 set_bit(F_WRITEFLUSH, &dev.flags);
669 interruptible_sleep_on_timeout(
671 get_play_delay_jiffies(dev.DAPF.len));
672 clear_bit(F_WRITEFLUSH, &dev.flags);
673 if (!signal_pending(current)) {
674 current->state = TASK_INTERRUPTIBLE;
675 schedule_timeout(get_play_delay_jiffies(DAP_BUFF_SIZE));
677 clear_bit(F_WRITING, &dev.flags);
680 static void dsp_halt(struct file *file)
682 if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
683 clear_bit(F_READING, &dev.flags);
684 chk_send_dsp_cmd(&dev, HDEX_RECORD_STOP);
685 msnd_disable_irq(&dev);
687 printk(KERN_DEBUG LOGNAME ": Stopping read for %p\n", file);
688 dev.mode &= ~FMODE_READ;
690 clear_bit(F_AUDIO_READ_INUSE, &dev.flags);
692 if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
693 if (test_bit(F_WRITING, &dev.flags)) {
695 chk_send_dsp_cmd(&dev, HDEX_PLAY_STOP);
697 msnd_disable_irq(&dev);
699 printk(KERN_DEBUG LOGNAME ": Stopping write for %p\n", file);
700 dev.mode &= ~FMODE_WRITE;
702 clear_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
706 static int dsp_release(struct file *file)
712 static int dsp_open(struct file *file)
714 if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
715 set_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
716 clear_bit(F_WRITING, &dev.flags);
717 msnd_fifo_make_empty(&dev.DAPF);
720 printk(KERN_DEBUG LOGNAME ": Starting write for %p\n", file);
721 dev.mode |= FMODE_WRITE;
723 msnd_enable_irq(&dev);
725 if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
726 set_bit(F_AUDIO_READ_INUSE, &dev.flags);
727 clear_bit(F_READING, &dev.flags);
728 msnd_fifo_make_empty(&dev.DARF);
729 reset_record_queue();
731 printk(KERN_DEBUG LOGNAME ": Starting read for %p\n", file);
732 dev.mode |= FMODE_READ;
734 msnd_enable_irq(&dev);
739 static void set_default_play_audio_parameters(void)
741 dev.play_sample_size = DEFSAMPLESIZE;
742 dev.play_sample_rate = DEFSAMPLERATE;
743 dev.play_channels = DEFCHANNELS;
746 static void set_default_rec_audio_parameters(void)
748 dev.rec_sample_size = DEFSAMPLESIZE;
749 dev.rec_sample_rate = DEFSAMPLERATE;
750 dev.rec_channels = DEFCHANNELS;
753 static void set_default_audio_parameters(void)
755 set_default_play_audio_parameters();
756 set_default_rec_audio_parameters();
759 static int dev_open(struct inode *inode, struct file *file)
761 int minor = iminor(inode);
765 if (minor == dev.dsp_minor) {
766 if ((file->f_mode & FMODE_WRITE &&
767 test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
768 (file->f_mode & FMODE_READ &&
769 test_bit(F_AUDIO_READ_INUSE, &dev.flags))) {
774 if ((err = dsp_open(file)) >= 0) {
776 if (file->f_mode & FMODE_WRITE) {
777 set_default_play_audio_parameters();
778 if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags))
779 dev.play_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
783 if (file->f_mode & FMODE_READ) {
784 set_default_rec_audio_parameters();
785 dev.rec_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
789 else if (minor == dev.mixer_minor) {
798 static int dev_release(struct inode *inode, struct file *file)
800 int minor = iminor(inode);
804 if (minor == dev.dsp_minor)
805 err = dsp_release(file);
806 else if (minor == dev.mixer_minor) {
814 static __inline__ int pack_DARQ_to_DARF(register int bank)
816 register int size, timeout = 3;
820 /* Increment the tail and check for queue wrap */
821 wTmp = readw(dev.DARQ + JQS_wTail) + PCTODSP_OFFSET(DAQDS__size);
822 if (wTmp > readw(dev.DARQ + JQS_wSize))
824 while (wTmp == readw(dev.DARQ + JQS_wHead) && timeout--)
826 writew(wTmp, dev.DARQ + JQS_wTail);
828 /* Get our digital audio queue struct */
829 DAQD = bank * DAQDS__size + dev.base + DARQ_DATA_BUFF;
831 /* Get length of data */
832 size = readw(DAQD + DAQDS_wSize);
834 /* Read data from the head (unprotected bank 1 access okay
835 since this is only called inside an interrupt) */
836 msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
839 dev.base + bank * DAR_BUFF_SIZE,
841 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
846 static __inline__ int pack_DAPF_to_DAPQ(register int start)
848 register WORD DAPQ_tail;
849 register int protect = start, nbanks = 0;
852 DAPQ_tail = readw(dev.DAPQ + JQS_wTail);
853 while (DAPQ_tail != readw(dev.DAPQ + JQS_wHead) || start) {
854 register int bank_num = DAPQ_tail / PCTODSP_OFFSET(DAQDS__size);
858 /* Write the data to the new tail */
860 /* Critical section: protect fifo in non-interrupt */
861 spin_lock_irqsave(&dev.lock, flags);
862 n = msnd_fifo_read_io(
864 dev.base + bank_num * DAP_BUFF_SIZE,
866 spin_unlock_irqrestore(&dev.lock, flags);
868 n = msnd_fifo_read_io(
870 dev.base + bank_num * DAP_BUFF_SIZE,
879 /* Get our digital audio queue struct */
880 DAQD = bank_num * DAQDS__size + dev.base + DAPQ_DATA_BUFF;
882 /* Write size of this bank */
883 writew(n, DAQD + DAQDS_wSize);
886 /* Then advance the tail */
887 DAPQ_tail = (++bank_num % 3) * PCTODSP_OFFSET(DAQDS__size);
888 writew(DAPQ_tail, dev.DAPQ + JQS_wTail);
889 /* Tell the DSP to play the bank */
890 msnd_send_dsp_cmd(&dev, HDEX_PLAY_START);
895 static int dsp_read(char __user *buf, size_t len)
898 char *page = (char *)__get_free_page(GFP_KERNEL);
911 /* Critical section: protect fifo in non-interrupt */
912 spin_lock_irqsave(&dev.lock, flags);
913 n = msnd_fifo_read(&dev.DARF, page, k);
914 spin_unlock_irqrestore(&dev.lock, flags);
915 if (copy_to_user(buf, page, n)) {
916 free_page((unsigned long)page);
925 if (!test_bit(F_READING, &dev.flags) && dev.mode & FMODE_READ) {
926 dev.last_recbank = -1;
927 if (chk_send_dsp_cmd(&dev, HDEX_RECORD_START) == 0)
928 set_bit(F_READING, &dev.flags);
931 if (dev.rec_ndelay) {
932 free_page((unsigned long)page);
933 return count == len ? -EAGAIN : len - count;
937 set_bit(F_READBLOCK, &dev.flags);
938 if (!interruptible_sleep_on_timeout(
940 get_rec_delay_jiffies(DAR_BUFF_SIZE)))
941 clear_bit(F_READING, &dev.flags);
942 clear_bit(F_READBLOCK, &dev.flags);
943 if (signal_pending(current)) {
944 free_page((unsigned long)page);
949 free_page((unsigned long)page);
953 static int dsp_write(const char __user *buf, size_t len)
956 char *page = (char *)__get_free_page(GFP_KERNEL);
969 if (copy_from_user(page, buf, k)) {
970 free_page((unsigned long)page);
974 /* Critical section: protect fifo in non-interrupt */
975 spin_lock_irqsave(&dev.lock, flags);
976 n = msnd_fifo_write(&dev.DAPF, page, k);
977 spin_unlock_irqrestore(&dev.lock, flags);
984 if (!test_bit(F_WRITING, &dev.flags) && (dev.mode & FMODE_WRITE)) {
985 dev.last_playbank = -1;
986 if (pack_DAPF_to_DAPQ(1) > 0)
987 set_bit(F_WRITING, &dev.flags);
990 if (dev.play_ndelay) {
991 free_page((unsigned long)page);
992 return count == len ? -EAGAIN : len - count;
996 set_bit(F_WRITEBLOCK, &dev.flags);
997 interruptible_sleep_on_timeout(
999 get_play_delay_jiffies(DAP_BUFF_SIZE));
1000 clear_bit(F_WRITEBLOCK, &dev.flags);
1001 if (signal_pending(current)) {
1002 free_page((unsigned long)page);
1008 free_page((unsigned long)page);
1012 static ssize_t dev_read(struct file *file, char __user *buf, size_t count, loff_t *off)
1014 int minor = iminor(file->f_path.dentry->d_inode);
1015 if (minor == dev.dsp_minor)
1016 return dsp_read(buf, count);
1021 static ssize_t dev_write(struct file *file, const char __user *buf, size_t count, loff_t *off)
1023 int minor = iminor(file->f_path.dentry->d_inode);
1024 if (minor == dev.dsp_minor)
1025 return dsp_write(buf, count);
1030 static __inline__ void eval_dsp_msg(register WORD wMessage)
1032 switch (HIBYTE(wMessage)) {
1033 case HIMT_PLAY_DONE:
1034 if (dev.last_playbank == LOBYTE(wMessage) || !test_bit(F_WRITING, &dev.flags))
1036 dev.last_playbank = LOBYTE(wMessage);
1038 if (pack_DAPF_to_DAPQ(0) <= 0) {
1039 if (!test_bit(F_WRITEBLOCK, &dev.flags)) {
1040 if (test_and_clear_bit(F_WRITEFLUSH, &dev.flags))
1041 wake_up_interruptible(&dev.writeflush);
1043 clear_bit(F_WRITING, &dev.flags);
1046 if (test_bit(F_WRITEBLOCK, &dev.flags))
1047 wake_up_interruptible(&dev.writeblock);
1050 case HIMT_RECORD_DONE:
1051 if (dev.last_recbank == LOBYTE(wMessage))
1053 dev.last_recbank = LOBYTE(wMessage);
1055 pack_DARQ_to_DARF(dev.last_recbank);
1057 if (test_bit(F_READBLOCK, &dev.flags))
1058 wake_up_interruptible(&dev.readblock);
1062 switch (LOBYTE(wMessage)) {
1063 #ifndef MSND_CLASSIC
1064 case HIDSP_PLAY_UNDER:
1066 case HIDSP_INT_PLAY_UNDER:
1067 /* printk(KERN_DEBUG LOGNAME ": Play underflow\n"); */
1068 clear_bit(F_WRITING, &dev.flags);
1071 case HIDSP_INT_RECORD_OVER:
1072 /* printk(KERN_DEBUG LOGNAME ": Record overflow\n"); */
1073 clear_bit(F_READING, &dev.flags);
1077 /* printk(KERN_DEBUG LOGNAME ": DSP message %d 0x%02x\n",
1078 LOBYTE(wMessage), LOBYTE(wMessage)); */
1083 case HIMT_MIDI_IN_UCHAR:
1084 if (dev.midi_in_interrupt)
1085 (*dev.midi_in_interrupt)(&dev);
1089 /* printk(KERN_DEBUG LOGNAME ": HIMT message %d 0x%02x\n", HIBYTE(wMessage), HIBYTE(wMessage)); */
1094 static irqreturn_t intr(int irq, void *dev_id)
1096 /* Send ack to DSP */
1097 msnd_inb(dev.io + HP_RXL);
1099 /* Evaluate queued DSP messages */
1100 while (readw(dev.DSPQ + JQS_wTail) != readw(dev.DSPQ + JQS_wHead)) {
1103 eval_dsp_msg(readw(dev.pwDSPQData + 2*readw(dev.DSPQ + JQS_wHead)));
1105 if ((wTmp = readw(dev.DSPQ + JQS_wHead) + 1) > readw(dev.DSPQ + JQS_wSize))
1106 writew(0, dev.DSPQ + JQS_wHead);
1108 writew(wTmp, dev.DSPQ + JQS_wHead);
1113 static const struct file_operations dev_fileops = {
1114 .owner = THIS_MODULE,
1117 .unlocked_ioctl = dev_ioctl,
1119 .release = dev_release,
1120 .llseek = noop_llseek,
1123 static int reset_dsp(void)
1127 msnd_outb(HPDSPRESET_ON, dev.io + HP_DSPR);
1129 #ifndef MSND_CLASSIC
1130 dev.info = msnd_inb(dev.io + HP_INFO);
1132 msnd_outb(HPDSPRESET_OFF, dev.io + HP_DSPR);
1134 while (timeout-- > 0) {
1135 if (msnd_inb(dev.io + HP_CVR) == HP_CVR_DEF)
1139 printk(KERN_ERR LOGNAME ": Cannot reset DSP\n");
1144 static int __init probe_multisound(void)
1146 #ifndef MSND_CLASSIC
1147 char *xv, *rev = NULL;
1148 char *pin = "Pinnacle", *fiji = "Fiji";
1149 char *pinfiji = "Pinnacle/Fiji";
1152 if (!request_region(dev.io, dev.numio, "probing")) {
1153 printk(KERN_ERR LOGNAME ": I/O port conflict\n");
1157 if (reset_dsp() < 0) {
1158 release_region(dev.io, dev.numio);
1163 dev.name = "Classic/Tahiti/Monterey";
1164 printk(KERN_INFO LOGNAME ": %s, "
1166 switch (dev.info >> 4) {
1167 case 0xf: xv = "<= 1.15"; break;
1168 case 0x1: xv = "1.18/1.2"; break;
1169 case 0x2: xv = "1.3"; break;
1170 case 0x3: xv = "1.4"; break;
1171 default: xv = "unknown"; break;
1174 switch (dev.info & 0x7) {
1175 case 0x0: rev = "I"; dev.name = pin; break;
1176 case 0x1: rev = "F"; dev.name = pin; break;
1177 case 0x2: rev = "G"; dev.name = pin; break;
1178 case 0x3: rev = "H"; dev.name = pin; break;
1179 case 0x4: rev = "E"; dev.name = fiji; break;
1180 case 0x5: rev = "C"; dev.name = fiji; break;
1181 case 0x6: rev = "D"; dev.name = fiji; break;
1183 rev = "A-B (Fiji) or A-E (Pinnacle)";
1187 printk(KERN_INFO LOGNAME ": %s revision %s, Xilinx version %s, "
1188 #endif /* MSND_CLASSIC */
1189 "I/O 0x%x-0x%x, IRQ %d, memory mapped to %p-%p\n",
1191 #ifndef MSND_CLASSIC
1194 dev.io, dev.io + dev.numio - 1,
1196 dev.base, dev.base + 0x7fff);
1198 release_region(dev.io, dev.numio);
1202 static int init_sma(void)
1205 WORD mastVolLeft, mastVolRight;
1206 unsigned long flags;
1209 msnd_outb(dev.memid, dev.io + HP_MEMM);
1211 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
1213 mastVolLeft = readw(dev.SMA + SMA_wCurrMastVolLeft);
1214 mastVolRight = readw(dev.SMA + SMA_wCurrMastVolRight);
1216 mastVolLeft = mastVolRight = 0;
1217 memset_io(dev.base, 0, 0x8000);
1219 /* Critical section: bank 1 access */
1220 spin_lock_irqsave(&dev.lock, flags);
1221 msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
1222 memset_io(dev.base, 0, 0x8000);
1223 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
1224 spin_unlock_irqrestore(&dev.lock, flags);
1226 dev.pwDSPQData = (dev.base + DSPQ_DATA_BUFF);
1227 dev.pwMODQData = (dev.base + MODQ_DATA_BUFF);
1228 dev.pwMIDQData = (dev.base + MIDQ_DATA_BUFF);
1230 /* Motorola 56k shared memory base */
1231 dev.SMA = dev.base + SMA_STRUCT_START;
1233 /* Digital audio play queue */
1234 dev.DAPQ = dev.base + DAPQ_OFFSET;
1235 msnd_init_queue(dev.DAPQ, DAPQ_DATA_BUFF, DAPQ_BUFF_SIZE);
1237 /* Digital audio record queue */
1238 dev.DARQ = dev.base + DARQ_OFFSET;
1239 msnd_init_queue(dev.DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE);
1241 /* MIDI out queue */
1242 dev.MODQ = dev.base + MODQ_OFFSET;
1243 msnd_init_queue(dev.MODQ, MODQ_DATA_BUFF, MODQ_BUFF_SIZE);
1246 dev.MIDQ = dev.base + MIDQ_OFFSET;
1247 msnd_init_queue(dev.MIDQ, MIDQ_DATA_BUFF, MIDQ_BUFF_SIZE);
1249 /* DSP -> host message queue */
1250 dev.DSPQ = dev.base + DSPQ_OFFSET;
1251 msnd_init_queue(dev.DSPQ, DSPQ_DATA_BUFF, DSPQ_BUFF_SIZE);
1253 /* Setup some DSP values */
1254 #ifndef MSND_CLASSIC
1255 writew(1, dev.SMA + SMA_wCurrPlayFormat);
1256 writew(dev.play_sample_size, dev.SMA + SMA_wCurrPlaySampleSize);
1257 writew(dev.play_channels, dev.SMA + SMA_wCurrPlayChannels);
1258 writew(dev.play_sample_rate, dev.SMA + SMA_wCurrPlaySampleRate);
1260 writew(dev.play_sample_rate, dev.SMA + SMA_wCalFreqAtoD);
1261 writew(mastVolLeft, dev.SMA + SMA_wCurrMastVolLeft);
1262 writew(mastVolRight, dev.SMA + SMA_wCurrMastVolRight);
1263 #ifndef MSND_CLASSIC
1264 writel(0x00010000, dev.SMA + SMA_dwCurrPlayPitch);
1265 writel(0x00000001, dev.SMA + SMA_dwCurrPlayRate);
1267 writew(0x303, dev.SMA + SMA_wCurrInputTagBits);
1274 static int __init calibrate_adc(WORD srate)
1276 writew(srate, dev.SMA + SMA_wCalFreqAtoD);
1277 if (dev.calibrate_signal == 0)
1278 writew(readw(dev.SMA + SMA_wCurrHostStatusFlags)
1279 | 0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
1281 writew(readw(dev.SMA + SMA_wCurrHostStatusFlags)
1282 & ~0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
1283 if (msnd_send_word(&dev, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
1284 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ) == 0) {
1285 current->state = TASK_INTERRUPTIBLE;
1286 schedule_timeout(HZ / 3);
1289 printk(KERN_WARNING LOGNAME ": ADC calibration failed\n");
1294 static int upload_dsp_code(void)
1296 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
1297 #ifndef HAVE_DSPCODEH
1298 INITCODESIZE = mod_firmware_load(INITCODEFILE, &INITCODE);
1300 printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
1304 PERMCODESIZE = mod_firmware_load(PERMCODEFILE, &PERMCODE);
1306 printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
1311 memcpy_toio(dev.base, PERMCODE, PERMCODESIZE);
1312 if (msnd_upload_host(&dev, INITCODE, INITCODESIZE) < 0) {
1313 printk(KERN_WARNING LOGNAME ": Error uploading to DSP\n");
1316 #ifdef HAVE_DSPCODEH
1317 printk(KERN_INFO LOGNAME ": DSP firmware uploaded (resident)\n");
1319 printk(KERN_INFO LOGNAME ": DSP firmware uploaded\n");
1322 #ifndef HAVE_DSPCODEH
1331 static void reset_proteus(void)
1333 msnd_outb(HPPRORESET_ON, dev.io + HP_PROR);
1334 mdelay(TIME_PRO_RESET);
1335 msnd_outb(HPPRORESET_OFF, dev.io + HP_PROR);
1336 mdelay(TIME_PRO_RESET_DONE);
1340 static int initialize(void)
1345 msnd_outb(HPWAITSTATE_0, dev.io + HP_WAIT);
1346 msnd_outb(HPBITMODE_16, dev.io + HP_BITM);
1350 if ((err = init_sma()) < 0) {
1351 printk(KERN_WARNING LOGNAME ": Cannot initialize SMA\n");
1355 if ((err = reset_dsp()) < 0)
1358 if ((err = upload_dsp_code()) < 0) {
1359 printk(KERN_WARNING LOGNAME ": Cannot upload DSP code\n");
1364 while (readw(dev.base)) {
1367 printk(KERN_DEBUG LOGNAME ": DSP reset timeout\n");
1377 static int dsp_full_reset(void)
1381 if (test_bit(F_RESETTING, &dev.flags) || ++dev.nresets > 10)
1384 set_bit(F_RESETTING, &dev.flags);
1385 printk(KERN_INFO LOGNAME ": DSP reset\n");
1386 dsp_halt(NULL); /* Unconditionally halt */
1387 if ((rv = initialize()))
1388 printk(KERN_WARNING LOGNAME ": DSP reset failed\n");
1389 force_recsrc(dev.recsrc);
1391 clear_bit(F_RESETTING, &dev.flags);
1396 static int __init attach_multisound(void)
1400 if ((err = request_irq(dev.irq, intr, 0, dev.name, &dev)) < 0) {
1401 printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
1404 if (request_region(dev.io, dev.numio, dev.name) == NULL) {
1405 free_irq(dev.irq, &dev);
1409 err = dsp_full_reset();
1411 release_region(dev.io, dev.numio);
1412 free_irq(dev.irq, &dev);
1416 if ((err = msnd_register(&dev)) < 0) {
1417 printk(KERN_ERR LOGNAME ": Unable to register MultiSound\n");
1418 release_region(dev.io, dev.numio);
1419 free_irq(dev.irq, &dev);
1423 if ((dev.dsp_minor = register_sound_dsp(&dev_fileops, -1)) < 0) {
1424 printk(KERN_ERR LOGNAME ": Unable to register DSP operations\n");
1425 msnd_unregister(&dev);
1426 release_region(dev.io, dev.numio);
1427 free_irq(dev.irq, &dev);
1428 return dev.dsp_minor;
1431 if ((dev.mixer_minor = register_sound_mixer(&dev_fileops, -1)) < 0) {
1432 printk(KERN_ERR LOGNAME ": Unable to register mixer operations\n");
1433 unregister_sound_mixer(dev.mixer_minor);
1434 msnd_unregister(&dev);
1435 release_region(dev.io, dev.numio);
1436 free_irq(dev.irq, &dev);
1437 return dev.mixer_minor;
1440 dev.ext_midi_dev = dev.hdr_midi_dev = -1;
1442 disable_irq(dev.irq);
1443 calibrate_adc(dev.play_sample_rate);
1444 #ifndef MSND_CLASSIC
1445 force_recsrc(SOUND_MASK_IMIX);
1451 static void __exit unload_multisound(void)
1453 release_region(dev.io, dev.numio);
1454 free_irq(dev.irq, &dev);
1455 unregister_sound_mixer(dev.mixer_minor);
1456 unregister_sound_dsp(dev.dsp_minor);
1457 msnd_unregister(&dev);
1460 #ifndef MSND_CLASSIC
1462 /* Pinnacle/Fiji Logical Device Configuration */
1464 static int __init msnd_write_cfg(int cfg, int reg, int value)
1466 msnd_outb(reg, cfg);
1467 msnd_outb(value, cfg + 1);
1468 if (value != msnd_inb(cfg + 1)) {
1469 printk(KERN_ERR LOGNAME ": msnd_write_cfg: I/O error\n");
1475 static int __init msnd_write_cfg_io0(int cfg, int num, WORD io)
1477 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1479 if (msnd_write_cfg(cfg, IREG_IO0_BASEHI, HIBYTE(io)))
1481 if (msnd_write_cfg(cfg, IREG_IO0_BASELO, LOBYTE(io)))
1486 static int __init msnd_write_cfg_io1(int cfg, int num, WORD io)
1488 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1490 if (msnd_write_cfg(cfg, IREG_IO1_BASEHI, HIBYTE(io)))
1492 if (msnd_write_cfg(cfg, IREG_IO1_BASELO, LOBYTE(io)))
1497 static int __init msnd_write_cfg_irq(int cfg, int num, WORD irq)
1499 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1501 if (msnd_write_cfg(cfg, IREG_IRQ_NUMBER, LOBYTE(irq)))
1503 if (msnd_write_cfg(cfg, IREG_IRQ_TYPE, IRQTYPE_EDGE))
1508 static int __init msnd_write_cfg_mem(int cfg, int num, int mem)
1515 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1517 if (msnd_write_cfg(cfg, IREG_MEMBASEHI, HIBYTE(wmem)))
1519 if (msnd_write_cfg(cfg, IREG_MEMBASELO, LOBYTE(wmem)))
1521 if (wmem && msnd_write_cfg(cfg, IREG_MEMCONTROL, (MEMTYPE_HIADDR | MEMTYPE_16BIT)))
1526 static int __init msnd_activate_logical(int cfg, int num)
1528 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1530 if (msnd_write_cfg(cfg, IREG_ACTIVATE, LD_ACTIVATE))
1535 static int __init msnd_write_cfg_logical(int cfg, int num, WORD io0, WORD io1, WORD irq, int mem)
1537 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1539 if (msnd_write_cfg_io0(cfg, num, io0))
1541 if (msnd_write_cfg_io1(cfg, num, io1))
1543 if (msnd_write_cfg_irq(cfg, num, irq))
1545 if (msnd_write_cfg_mem(cfg, num, mem))
1547 if (msnd_activate_logical(cfg, num))
1552 typedef struct msnd_pinnacle_cfg_device {
1555 } msnd_pinnacle_cfg_t[4];
1557 static int __init msnd_pinnacle_cfg_devices(int cfg, int reset, msnd_pinnacle_cfg_t device)
1561 /* Reset devices if told to */
1563 printk(KERN_INFO LOGNAME ": Resetting all devices\n");
1564 for (i = 0; i < 4; ++i)
1565 if (msnd_write_cfg_logical(cfg, i, 0, 0, 0, 0))
1569 /* Configure specified devices */
1570 for (i = 0; i < 4; ++i) {
1574 if (!(device[i].io0 && device[i].irq && device[i].mem))
1578 if (!(device[i].io0 && device[i].irq))
1580 printk(KERN_INFO LOGNAME
1581 ": Configuring MPU to I/O 0x%x IRQ %d\n",
1582 device[i].io0, device[i].irq);
1585 if (!(device[i].io0 && device[i].io1 && device[i].irq))
1587 printk(KERN_INFO LOGNAME
1588 ": Configuring IDE to I/O 0x%x, 0x%x IRQ %d\n",
1589 device[i].io0, device[i].io1, device[i].irq);
1591 case 3: /* Joystick */
1592 if (!(device[i].io0))
1594 printk(KERN_INFO LOGNAME
1595 ": Configuring joystick to I/O 0x%x\n",
1600 /* Configure the device */
1601 if (msnd_write_cfg_logical(cfg, i, device[i].io0, device[i].io1, device[i].irq, device[i].mem))
1610 MODULE_AUTHOR ("Andrew Veliath <andrewtv@usa.net>");
1611 MODULE_DESCRIPTION ("Turtle Beach " LONGNAME " Linux Driver");
1612 MODULE_LICENSE("GPL");
1614 static int io __initdata = -1;
1615 static int irq __initdata = -1;
1616 static int mem __initdata = -1;
1617 static int write_ndelay __initdata = -1;
1619 #ifndef MSND_CLASSIC
1620 /* Pinnacle/Fiji non-PnP Config Port */
1621 static int cfg __initdata = -1;
1623 /* Extra Peripheral Configuration */
1624 static int reset __initdata = 0;
1625 static int mpu_io __initdata = 0;
1626 static int mpu_irq __initdata = 0;
1627 static int ide_io0 __initdata = 0;
1628 static int ide_io1 __initdata = 0;
1629 static int ide_irq __initdata = 0;
1630 static int joystick_io __initdata = 0;
1632 /* If we have the digital daugherboard... */
1633 static int digital __initdata = 0;
1636 static int fifosize __initdata = DEFFIFOSIZE;
1637 static int calibrate_signal __initdata = 0;
1639 #else /* not a module */
1641 static int write_ndelay __initdata = -1;
1644 static int io __initdata = CONFIG_MSNDCLAS_IO;
1645 static int irq __initdata = CONFIG_MSNDCLAS_IRQ;
1646 static int mem __initdata = CONFIG_MSNDCLAS_MEM;
1647 #else /* Pinnacle/Fiji */
1649 static int io __initdata = CONFIG_MSNDPIN_IO;
1650 static int irq __initdata = CONFIG_MSNDPIN_IRQ;
1651 static int mem __initdata = CONFIG_MSNDPIN_MEM;
1653 /* Pinnacle/Fiji non-PnP Config Port */
1654 #ifdef CONFIG_MSNDPIN_NONPNP
1655 # ifndef CONFIG_MSNDPIN_CFG
1656 # define CONFIG_MSNDPIN_CFG 0x250
1659 # ifdef CONFIG_MSNDPIN_CFG
1660 # undef CONFIG_MSNDPIN_CFG
1662 # define CONFIG_MSNDPIN_CFG -1
1664 static int cfg __initdata = CONFIG_MSNDPIN_CFG;
1665 /* If not a module, we don't need to bother with reset=1 */
1668 /* Extra Peripheral Configuration (Default: Disable) */
1669 #ifndef CONFIG_MSNDPIN_MPU_IO
1670 # define CONFIG_MSNDPIN_MPU_IO 0
1672 static int mpu_io __initdata = CONFIG_MSNDPIN_MPU_IO;
1674 #ifndef CONFIG_MSNDPIN_MPU_IRQ
1675 # define CONFIG_MSNDPIN_MPU_IRQ 0
1677 static int mpu_irq __initdata = CONFIG_MSNDPIN_MPU_IRQ;
1679 #ifndef CONFIG_MSNDPIN_IDE_IO0
1680 # define CONFIG_MSNDPIN_IDE_IO0 0
1682 static int ide_io0 __initdata = CONFIG_MSNDPIN_IDE_IO0;
1684 #ifndef CONFIG_MSNDPIN_IDE_IO1
1685 # define CONFIG_MSNDPIN_IDE_IO1 0
1687 static int ide_io1 __initdata = CONFIG_MSNDPIN_IDE_IO1;
1689 #ifndef CONFIG_MSNDPIN_IDE_IRQ
1690 # define CONFIG_MSNDPIN_IDE_IRQ 0
1692 static int ide_irq __initdata = CONFIG_MSNDPIN_IDE_IRQ;
1694 #ifndef CONFIG_MSNDPIN_JOYSTICK_IO
1695 # define CONFIG_MSNDPIN_JOYSTICK_IO 0
1697 static int joystick_io __initdata = CONFIG_MSNDPIN_JOYSTICK_IO;
1699 /* Have SPDIF (Digital) Daughterboard */
1700 #ifndef CONFIG_MSNDPIN_DIGITAL
1701 # define CONFIG_MSNDPIN_DIGITAL 0
1703 static int digital __initdata = CONFIG_MSNDPIN_DIGITAL;
1705 #endif /* MSND_CLASSIC */
1707 #ifndef CONFIG_MSND_FIFOSIZE
1708 # define CONFIG_MSND_FIFOSIZE DEFFIFOSIZE
1710 static int fifosize __initdata = CONFIG_MSND_FIFOSIZE;
1712 #ifndef CONFIG_MSND_CALSIGNAL
1713 # define CONFIG_MSND_CALSIGNAL 0
1716 calibrate_signal __initdata = CONFIG_MSND_CALSIGNAL;
1719 module_param (io, int, 0);
1720 module_param (irq, int, 0);
1721 module_param (mem, int, 0);
1722 module_param (write_ndelay, int, 0);
1723 module_param (fifosize, int, 0);
1724 module_param (calibrate_signal, int, 0);
1725 #ifndef MSND_CLASSIC
1726 module_param (digital, bool, 0);
1727 module_param (cfg, int, 0);
1728 module_param (reset, int, 0);
1729 module_param (mpu_io, int, 0);
1730 module_param (mpu_irq, int, 0);
1731 module_param (ide_io0, int, 0);
1732 module_param (ide_io1, int, 0);
1733 module_param (ide_irq, int, 0);
1734 module_param (joystick_io, int, 0);
1737 static int __init msnd_init(void)
1740 #ifndef MSND_CLASSIC
1741 static msnd_pinnacle_cfg_t pinnacle_devs;
1742 #endif /* MSND_CLASSIC */
1744 printk(KERN_INFO LOGNAME ": Turtle Beach " LONGNAME " Linux Driver Version "
1745 VERSION ", Copyright (C) 1998 Andrew Veliath\n");
1747 if (io == -1 || irq == -1 || mem == -1)
1748 printk(KERN_WARNING LOGNAME ": io, irq and mem must be set\n");
1760 printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must be set to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, or 0x3E0\n");
1768 printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must within the range 0x100 to 0x3E0 and must be evenly divisible by 0x10\n");
1771 #endif /* MSND_CLASSIC */
1780 printk(KERN_ERR LOGNAME ": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
1791 printk(KERN_ERR LOGNAME ": \"mem\" - must be set to "
1792 "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or 0xe8000\n");
1798 case 5: dev.irqid = HPIRQ_5; break;
1799 case 7: dev.irqid = HPIRQ_7; break;
1800 case 9: dev.irqid = HPIRQ_9; break;
1801 case 10: dev.irqid = HPIRQ_10; break;
1802 case 11: dev.irqid = HPIRQ_11; break;
1803 case 12: dev.irqid = HPIRQ_12; break;
1807 case 0xb0000: dev.memid = HPMEM_B000; break;
1808 case 0xc8000: dev.memid = HPMEM_C800; break;
1809 case 0xd0000: dev.memid = HPMEM_D000; break;
1810 case 0xd8000: dev.memid = HPMEM_D800; break;
1811 case 0xe0000: dev.memid = HPMEM_E000; break;
1812 case 0xe8000: dev.memid = HPMEM_E800; break;
1816 printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
1817 } else if (cfg != 0x250 && cfg != 0x260 && cfg != 0x270) {
1818 printk(KERN_INFO LOGNAME ": Config port must be 0x250, 0x260 or 0x270 (or unspecified for PnP mode)\n");
1821 printk(KERN_INFO LOGNAME ": Non-PnP mode: configuring at port 0x%x\n", cfg);
1824 pinnacle_devs[0].io0 = io;
1825 pinnacle_devs[0].irq = irq;
1826 pinnacle_devs[0].mem = mem;
1828 /* The following are Pinnacle specific */
1831 pinnacle_devs[1].io0 = mpu_io;
1832 pinnacle_devs[1].irq = mpu_irq;
1835 pinnacle_devs[2].io0 = ide_io0;
1836 pinnacle_devs[2].io1 = ide_io1;
1837 pinnacle_devs[2].irq = ide_irq;
1840 pinnacle_devs[3].io0 = joystick_io;
1842 if (!request_region(cfg, 2, "Pinnacle/Fiji Config")) {
1843 printk(KERN_ERR LOGNAME ": Config port 0x%x conflict\n", cfg);
1847 if (msnd_pinnacle_cfg_devices(cfg, reset, pinnacle_devs)) {
1848 printk(KERN_ERR LOGNAME ": Device configuration error\n");
1849 release_region(cfg, 2);
1852 release_region(cfg, 2);
1854 #endif /* MSND_CLASSIC */
1859 if (fifosize > 1024)
1862 set_default_audio_parameters();
1864 dev.type = msndClassic;
1866 dev.type = msndPinnacle;
1869 dev.numio = DSP_NUMIO;
1871 dev.base = ioremap(mem, 0x8000);
1872 dev.fifosize = fifosize * 1024;
1873 dev.calibrate_signal = calibrate_signal ? 1 : 0;
1875 dev.dspq_data_buff = DSPQ_DATA_BUFF;
1876 dev.dspq_buff_size = DSPQ_BUFF_SIZE;
1877 if (write_ndelay == -1)
1878 write_ndelay = CONFIG_MSND_WRITE_NDELAY;
1880 clear_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
1882 set_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
1883 #ifndef MSND_CLASSIC
1885 set_bit(F_HAVEDIGITAL, &dev.flags);
1887 init_waitqueue_head(&dev.writeblock);
1888 init_waitqueue_head(&dev.readblock);
1889 init_waitqueue_head(&dev.writeflush);
1890 msnd_fifo_init(&dev.DAPF);
1891 msnd_fifo_init(&dev.DARF);
1892 spin_lock_init(&dev.lock);
1893 printk(KERN_INFO LOGNAME ": %u byte audio FIFOs (x2)\n", dev.fifosize);
1894 if ((err = msnd_fifo_alloc(&dev.DAPF, dev.fifosize)) < 0) {
1895 printk(KERN_ERR LOGNAME ": Couldn't allocate write FIFO\n");
1899 if ((err = msnd_fifo_alloc(&dev.DARF, dev.fifosize)) < 0) {
1900 printk(KERN_ERR LOGNAME ": Couldn't allocate read FIFO\n");
1901 msnd_fifo_free(&dev.DAPF);
1905 if ((err = probe_multisound()) < 0) {
1906 printk(KERN_ERR LOGNAME ": Probe failed\n");
1907 msnd_fifo_free(&dev.DAPF);
1908 msnd_fifo_free(&dev.DARF);
1912 if ((err = attach_multisound()) < 0) {
1913 printk(KERN_ERR LOGNAME ": Attach failed\n");
1914 msnd_fifo_free(&dev.DAPF);
1915 msnd_fifo_free(&dev.DARF);
1922 static void __exit msdn_cleanup(void)
1924 unload_multisound();
1925 msnd_fifo_free(&dev.DAPF);
1926 msnd_fifo_free(&dev.DARF);
1929 module_init(msnd_init);
1930 module_exit(msdn_cleanup);