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 * $Id: msnd_pinnacle.c,v 1.8 2000/12/30 00:33:21 sycamore Exp $
34 * 12-3-2000 Modified IO port validation Steve Sycamore
37 * $$$: msnd_pinnacle.c,v 1.75 1999/03/21 16:50:09 andrewtv $$$ $
39 ********************************************************************/
41 #include <linux/kernel.h>
42 #include <linux/config.h>
43 #include <linux/module.h>
44 #include <linux/slab.h>
45 #include <linux/types.h>
46 #include <linux/delay.h>
47 #include <linux/init.h>
48 #include <linux/interrupt.h>
49 #include <linux/smp_lock.h>
52 #include "sound_config.h"
53 #include "sound_firmware.h"
61 # ifdef CONFIG_MSNDCLAS_HAVE_BOOT
62 # define HAVE_DSPCODEH
64 # include "msnd_classic.h"
65 # define LOGNAME "msnd_classic"
67 # ifdef CONFIG_MSNDPIN_HAVE_BOOT
68 # define HAVE_DSPCODEH
70 # include "msnd_pinnacle.h"
71 # define LOGNAME "msnd_pinnacle"
74 #ifndef CONFIG_MSND_WRITE_NDELAY
75 # define CONFIG_MSND_WRITE_NDELAY 1
78 #define get_play_delay_jiffies(size) ((size) * HZ * \
79 dev.play_sample_size / 8 / \
80 dev.play_sample_rate / \
83 #define get_rec_delay_jiffies(size) ((size) * HZ * \
84 dev.rec_sample_size / 8 / \
85 dev.rec_sample_rate / \
88 static multisound_dev_t dev;
91 static char *dspini, *permini;
92 static int sizeof_dspini, sizeof_permini;
95 static int dsp_full_reset(void);
96 static void dsp_write_flush(void);
98 static __inline__ int chk_send_dsp_cmd(multisound_dev_t *dev, register BYTE cmd)
100 if (msnd_send_dsp_cmd(dev, cmd) == 0)
103 return msnd_send_dsp_cmd(dev, cmd);
106 static void reset_play_queue(void)
111 dev.last_playbank = -1;
112 isa_writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wHead);
113 isa_writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DAPQ + JQS_wTail);
115 for (n = 0, lpDAQ = dev.base + DAPQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
116 isa_writew(PCTODSP_BASED((DWORD)(DAP_BUFF_SIZE * n)), lpDAQ + DAQDS_wStart);
117 isa_writew(0, lpDAQ + DAQDS_wSize);
118 isa_writew(1, lpDAQ + DAQDS_wFormat);
119 isa_writew(dev.play_sample_size, lpDAQ + DAQDS_wSampleSize);
120 isa_writew(dev.play_channels, lpDAQ + DAQDS_wChannels);
121 isa_writew(dev.play_sample_rate, lpDAQ + DAQDS_wSampleRate);
122 isa_writew(HIMT_PLAY_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
123 isa_writew(n, lpDAQ + DAQDS_wFlags);
127 static void reset_record_queue(void)
133 dev.last_recbank = 2;
134 isa_writew(PCTODSP_OFFSET(0 * DAQDS__size), dev.DARQ + JQS_wHead);
135 isa_writew(PCTODSP_OFFSET(dev.last_recbank * DAQDS__size), dev.DARQ + JQS_wTail);
137 /* Critical section: bank 1 access */
138 spin_lock_irqsave(&dev.lock, flags);
139 outb(HPBLKSEL_1, dev.io + HP_BLKS);
140 isa_memset_io(dev.base, 0, DAR_BUFF_SIZE * 3);
141 outb(HPBLKSEL_0, dev.io + HP_BLKS);
142 spin_unlock_irqrestore(&dev.lock, flags);
144 for (n = 0, lpDAQ = dev.base + DARQ_DATA_BUFF; n < 3; ++n, lpDAQ += DAQDS__size) {
145 isa_writew(PCTODSP_BASED((DWORD)(DAR_BUFF_SIZE * n)) + 0x4000, lpDAQ + DAQDS_wStart);
146 isa_writew(DAR_BUFF_SIZE, lpDAQ + DAQDS_wSize);
147 isa_writew(1, lpDAQ + DAQDS_wFormat);
148 isa_writew(dev.rec_sample_size, lpDAQ + DAQDS_wSampleSize);
149 isa_writew(dev.rec_channels, lpDAQ + DAQDS_wChannels);
150 isa_writew(dev.rec_sample_rate, lpDAQ + DAQDS_wSampleRate);
151 isa_writew(HIMT_RECORD_DONE * 0x100 + n, lpDAQ + DAQDS_wIntMsg);
152 isa_writew(n, lpDAQ + DAQDS_wFlags);
156 static void reset_queues(void)
158 if (dev.mode & FMODE_WRITE) {
159 msnd_fifo_make_empty(&dev.DAPF);
162 if (dev.mode & FMODE_READ) {
163 msnd_fifo_make_empty(&dev.DARF);
164 reset_record_queue();
168 static int dsp_set_format(struct file *file, int val)
171 LPDAQD lpDAQ, lpDARQ;
173 lpDAQ = dev.base + DAPQ_DATA_BUFF;
174 lpDARQ = dev.base + DARQ_DATA_BUFF;
182 data = DEFSAMPLESIZE;
186 for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
187 if (file->f_mode & FMODE_WRITE)
188 isa_writew(data, lpDAQ + DAQDS_wSampleSize);
189 if (file->f_mode & FMODE_READ)
190 isa_writew(data, lpDARQ + DAQDS_wSampleSize);
192 if (file->f_mode & FMODE_WRITE)
193 dev.play_sample_size = data;
194 if (file->f_mode & FMODE_READ)
195 dev.rec_sample_size = data;
200 static int dsp_get_frag_size(void)
203 size = dev.fifosize / 4;
204 if (size > 32 * 1024)
209 static int dsp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
211 int val, i, data, tmp;
212 LPDAQD lpDAQ, lpDARQ;
213 audio_buf_info abinfo;
216 lpDAQ = dev.base + DAPQ_DATA_BUFF;
217 lpDARQ = dev.base + DARQ_DATA_BUFF;
220 case SNDCTL_DSP_SUBDIVIDE:
221 case SNDCTL_DSP_SETFRAGMENT:
222 case SNDCTL_DSP_SETDUPLEX:
223 case SNDCTL_DSP_POST:
226 case SNDCTL_DSP_GETIPTR:
227 case SNDCTL_DSP_GETOPTR:
228 case SNDCTL_DSP_MAPINBUF:
229 case SNDCTL_DSP_MAPOUTBUF:
232 case SNDCTL_DSP_GETOSPACE:
233 if (!(file->f_mode & FMODE_WRITE))
235 spin_lock_irqsave(&dev.lock, flags);
236 abinfo.fragsize = dsp_get_frag_size();
237 abinfo.bytes = dev.DAPF.n - dev.DAPF.len;
238 abinfo.fragstotal = dev.DAPF.n / abinfo.fragsize;
239 abinfo.fragments = abinfo.bytes / abinfo.fragsize;
240 spin_unlock_irqrestore(&dev.lock, flags);
241 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
243 case SNDCTL_DSP_GETISPACE:
244 if (!(file->f_mode & FMODE_READ))
246 spin_lock_irqsave(&dev.lock, flags);
247 abinfo.fragsize = dsp_get_frag_size();
248 abinfo.bytes = dev.DARF.n - dev.DARF.len;
249 abinfo.fragstotal = dev.DARF.n / abinfo.fragsize;
250 abinfo.fragments = abinfo.bytes / abinfo.fragsize;
251 spin_unlock_irqrestore(&dev.lock, flags);
252 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
254 case SNDCTL_DSP_RESET:
259 case SNDCTL_DSP_SYNC:
263 case SNDCTL_DSP_GETBLKSIZE:
264 tmp = dsp_get_frag_size();
265 if (put_user(tmp, (int *)arg))
269 case SNDCTL_DSP_GETFMTS:
270 val = AFMT_S16_LE | AFMT_U8;
271 if (put_user(val, (int *)arg))
275 case SNDCTL_DSP_SETFMT:
276 if (get_user(val, (int *)arg))
279 if (file->f_mode & FMODE_WRITE)
280 data = val == AFMT_QUERY
281 ? dev.play_sample_size
282 : dsp_set_format(file, val);
284 data = val == AFMT_QUERY
285 ? dev.rec_sample_size
286 : dsp_set_format(file, val);
288 if (put_user(data, (int *)arg))
292 case SNDCTL_DSP_NONBLOCK:
293 if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags) &&
294 file->f_mode & FMODE_WRITE)
296 if (file->f_mode & FMODE_READ)
300 case SNDCTL_DSP_GETCAPS:
301 val = DSP_CAP_DUPLEX | DSP_CAP_BATCH;
302 if (put_user(val, (int *)arg))
306 case SNDCTL_DSP_SPEED:
307 if (get_user(val, (int *)arg))
318 for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
319 if (file->f_mode & FMODE_WRITE)
320 isa_writew(data, lpDAQ + DAQDS_wSampleRate);
321 if (file->f_mode & FMODE_READ)
322 isa_writew(data, lpDARQ + DAQDS_wSampleRate);
324 if (file->f_mode & FMODE_WRITE)
325 dev.play_sample_rate = data;
326 if (file->f_mode & FMODE_READ)
327 dev.rec_sample_rate = data;
329 if (put_user(data, (int *)arg))
333 case SNDCTL_DSP_CHANNELS:
334 case SNDCTL_DSP_STEREO:
335 if (get_user(val, (int *)arg))
338 if (cmd == SNDCTL_DSP_CHANNELS) {
361 for (i = 0; i < 3; ++i, lpDAQ += DAQDS__size, lpDARQ += DAQDS__size) {
362 if (file->f_mode & FMODE_WRITE)
363 isa_writew(data, lpDAQ + DAQDS_wChannels);
364 if (file->f_mode & FMODE_READ)
365 isa_writew(data, lpDARQ + DAQDS_wChannels);
367 if (file->f_mode & FMODE_WRITE)
368 dev.play_channels = data;
369 if (file->f_mode & FMODE_READ)
370 dev.rec_channels = data;
372 if (put_user(val, (int *)arg))
380 static int mixer_get(int d)
386 case SOUND_MIXER_VOLUME:
387 case SOUND_MIXER_PCM:
388 case SOUND_MIXER_LINE:
389 case SOUND_MIXER_IMIX:
390 case SOUND_MIXER_LINE1:
392 case SOUND_MIXER_MIC:
393 case SOUND_MIXER_SYNTH:
395 return (dev.left_levels[d] >> 8) * 100 / 0xff |
396 (((dev.right_levels[d] >> 8) * 100 / 0xff) << 8);
402 #define update_volm(a,b) \
403 isa_writew((dev.left_levels[a] >> 1) * \
404 isa_readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff, \
405 dev.SMA + SMA_##b##Left); \
406 isa_writew((dev.right_levels[a] >> 1) * \
407 isa_readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff, \
408 dev.SMA + SMA_##b##Right);
410 #define update_potm(d,s,ar) \
411 isa_writeb((dev.left_levels[d] >> 8) * \
412 isa_readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff, \
413 dev.SMA + SMA_##s##Left); \
414 isa_writeb((dev.right_levels[d] >> 8) * \
415 isa_readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff, \
416 dev.SMA + SMA_##s##Right); \
417 if (msnd_send_word(&dev, 0, 0, ar) == 0) \
418 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
420 #define update_pot(d,s,ar) \
421 isa_writeb(dev.left_levels[d] >> 8, \
422 dev.SMA + SMA_##s##Left); \
423 isa_writeb(dev.right_levels[d] >> 8, \
424 dev.SMA + SMA_##s##Right); \
425 if (msnd_send_word(&dev, 0, 0, ar) == 0) \
426 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
428 static int mixer_set(int d, int value)
430 int left = value & 0x000000ff;
431 int right = (value & 0x0000ff00) >> 8;
434 int updatemaster = 0;
439 bLeft = left * 0xff / 100;
440 wLeft = left * 0xffff / 100;
442 bRight = right * 0xff / 100;
443 wRight = right * 0xffff / 100;
445 dev.left_levels[d] = wLeft;
446 dev.right_levels[d] = wRight;
449 /* master volume unscaled controls */
450 case SOUND_MIXER_LINE: /* line pot control */
451 /* scaled by IMIX in digital mix */
452 isa_writeb(bLeft, dev.SMA + SMA_bInPotPosLeft);
453 isa_writeb(bRight, dev.SMA + SMA_bInPotPosRight);
454 if (msnd_send_word(&dev, 0, 0, HDEXAR_IN_SET_POTS) == 0)
455 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
458 case SOUND_MIXER_MIC: /* mic pot control */
459 /* scaled by IMIX in digital mix */
460 isa_writeb(bLeft, dev.SMA + SMA_bMicPotPosLeft);
461 isa_writeb(bRight, dev.SMA + SMA_bMicPotPosRight);
462 if (msnd_send_word(&dev, 0, 0, HDEXAR_MIC_SET_POTS) == 0)
463 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
466 case SOUND_MIXER_VOLUME: /* master volume */
467 isa_writew(wLeft, dev.SMA + SMA_wCurrMastVolLeft);
468 isa_writew(wRight, dev.SMA + SMA_wCurrMastVolRight);
471 case SOUND_MIXER_LINE1: /* aux pot control */
472 /* scaled by master volume */
475 /* digital controls */
476 case SOUND_MIXER_SYNTH: /* synth vol (dsp mix) */
477 case SOUND_MIXER_PCM: /* pcm vol (dsp mix) */
478 case SOUND_MIXER_IMIX: /* input monitor (dsp mix) */
479 /* scaled by master volume */
488 /* update master volume scaled controls */
489 update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
490 update_volm(SOUND_MIXER_IMIX, wCurrInVol);
492 update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
494 update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
500 static void mixer_setup(void)
502 update_pot(SOUND_MIXER_LINE, bInPotPos, HDEXAR_IN_SET_POTS);
503 update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
504 update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
505 update_volm(SOUND_MIXER_IMIX, wCurrInVol);
507 update_pot(SOUND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
508 update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
512 static unsigned long set_recsrc(unsigned long recsrc)
514 if (dev.recsrc == recsrc)
517 else if (recsrc == 0)
521 dev.recsrc ^= recsrc;
524 if (dev.recsrc & SOUND_MASK_IMIX) {
525 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
526 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
528 else if (dev.recsrc & SOUND_MASK_SYNTH) {
529 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_SYNTH_IN) == 0)
530 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
532 else if ((dev.recsrc & SOUND_MASK_DIGITAL1) && test_bit(F_HAVEDIGITAL, &dev.flags)) {
533 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_DAT_IN) == 0)
534 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
538 /* Select no input (?) */
541 dev.recsrc = SOUND_MASK_IMIX;
542 if (msnd_send_word(&dev, 0, 0, HDEXAR_SET_ANA_IN) == 0)
543 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
546 #endif /* MSND_CLASSIC */
551 static unsigned long force_recsrc(unsigned long recsrc)
554 return set_recsrc(recsrc);
557 #define set_mixer_info() \
558 memset(&info, 0, sizeof(info)); \
559 strlcpy(info.id, "MSNDMIXER", sizeof(info.id)); \
560 strlcpy(info.name, "MultiSound Mixer", sizeof(info.name));
562 static int mixer_ioctl(unsigned int cmd, unsigned long arg)
564 if (cmd == SOUND_MIXER_INFO) {
567 info.modify_counter = dev.mixer_mod_count;
568 if (copy_to_user((void *)arg, &info, sizeof(info)))
571 } else if (cmd == SOUND_OLD_MIXER_INFO) {
572 _old_mixer_info info;
574 if (copy_to_user((void *)arg, &info, sizeof(info)))
577 } else if (cmd == SOUND_MIXER_PRIVATE1) {
581 } else if (((cmd >> 8) & 0xff) == 'M') {
584 if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
585 switch (cmd & 0xff) {
586 case SOUND_MIXER_RECSRC:
587 if (get_user(val, (int *)arg))
589 val = set_recsrc(val);
593 if (get_user(val, (int *)arg))
595 val = mixer_set(cmd & 0xff, val);
598 ++dev.mixer_mod_count;
599 return put_user(val, (int *)arg);
601 switch (cmd & 0xff) {
602 case SOUND_MIXER_RECSRC:
606 case SOUND_MIXER_DEVMASK:
607 case SOUND_MIXER_STEREODEVS:
608 val = SOUND_MASK_PCM |
619 case SOUND_MIXER_RECMASK:
623 val = SOUND_MASK_IMIX |
625 if (test_bit(F_HAVEDIGITAL, &dev.flags))
626 val |= SOUND_MASK_DIGITAL1;
630 case SOUND_MIXER_CAPS:
631 val = SOUND_CAP_EXCL_INPUT;
635 if ((val = mixer_get(cmd & 0xff)) < 0)
641 return put_user(val, (int *)arg);
647 static int dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
649 int minor = iminor(inode);
651 if (cmd == OSS_GETVERSION) {
652 int sound_version = SOUND_VERSION;
653 return put_user(sound_version, (int *)arg);
656 if (minor == dev.dsp_minor)
657 return dsp_ioctl(file, cmd, arg);
658 else if (minor == dev.mixer_minor)
659 return 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);
764 if (minor == dev.dsp_minor) {
765 if ((file->f_mode & FMODE_WRITE &&
766 test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
767 (file->f_mode & FMODE_READ &&
768 test_bit(F_AUDIO_READ_INUSE, &dev.flags)))
771 if ((err = dsp_open(file)) >= 0) {
773 if (file->f_mode & FMODE_WRITE) {
774 set_default_play_audio_parameters();
775 if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags))
776 dev.play_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
780 if (file->f_mode & FMODE_READ) {
781 set_default_rec_audio_parameters();
782 dev.rec_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
786 else if (minor == dev.mixer_minor) {
794 static int dev_release(struct inode *inode, struct file *file)
796 int minor = iminor(inode);
800 if (minor == dev.dsp_minor)
801 err = dsp_release(file);
802 else if (minor == dev.mixer_minor) {
810 static __inline__ int pack_DARQ_to_DARF(register int bank)
812 register int size, n, timeout = 3;
816 /* Increment the tail and check for queue wrap */
817 wTmp = isa_readw(dev.DARQ + JQS_wTail) + PCTODSP_OFFSET(DAQDS__size);
818 if (wTmp > isa_readw(dev.DARQ + JQS_wSize))
820 while (wTmp == isa_readw(dev.DARQ + JQS_wHead) && timeout--)
822 isa_writew(wTmp, dev.DARQ + JQS_wTail);
824 /* Get our digital audio queue struct */
825 DAQD = bank * DAQDS__size + dev.base + DARQ_DATA_BUFF;
827 /* Get length of data */
828 size = isa_readw(DAQD + DAQDS_wSize);
830 /* Read data from the head (unprotected bank 1 access okay
831 since this is only called inside an interrupt) */
832 outb(HPBLKSEL_1, dev.io + HP_BLKS);
833 if ((n = msnd_fifo_write(
835 (char *)(dev.base + bank * DAR_BUFF_SIZE),
837 outb(HPBLKSEL_0, dev.io + HP_BLKS);
840 outb(HPBLKSEL_0, dev.io + HP_BLKS);
845 static __inline__ int pack_DAPF_to_DAPQ(register int start)
847 register WORD DAPQ_tail;
848 register int protect = start, nbanks = 0;
851 DAPQ_tail = isa_readw(dev.DAPQ + JQS_wTail);
852 while (DAPQ_tail != isa_readw(dev.DAPQ + JQS_wHead) || start) {
853 register int bank_num = DAPQ_tail / PCTODSP_OFFSET(DAQDS__size);
857 /* Write the data to the new tail */
859 /* Critical section: protect fifo in non-interrupt */
860 spin_lock_irqsave(&dev.lock, flags);
861 if ((n = msnd_fifo_read(
863 (char *)(dev.base + bank_num * DAP_BUFF_SIZE),
864 DAP_BUFF_SIZE, 0)) < 0) {
865 spin_unlock_irqrestore(&dev.lock, flags);
868 spin_unlock_irqrestore(&dev.lock, flags);
870 if ((n = msnd_fifo_read(
872 (char *)(dev.base + bank_num * DAP_BUFF_SIZE),
873 DAP_BUFF_SIZE, 0)) < 0) {
883 /* Get our digital audio queue struct */
884 DAQD = bank_num * DAQDS__size + dev.base + DAPQ_DATA_BUFF;
886 /* Write size of this bank */
887 isa_writew(n, DAQD + DAQDS_wSize);
890 /* Then advance the tail */
891 DAPQ_tail = (++bank_num % 3) * PCTODSP_OFFSET(DAQDS__size);
892 isa_writew(DAPQ_tail, dev.DAPQ + JQS_wTail);
893 /* Tell the DSP to play the bank */
894 msnd_send_dsp_cmd(&dev, HDEX_PLAY_START);
899 static int dsp_read(char *buf, size_t len)
907 /* Critical section: protect fifo in non-interrupt */
908 spin_lock_irqsave(&dev.lock, flags);
909 if ((n = msnd_fifo_read(&dev.DARF, buf, count, 1)) < 0) {
910 printk(KERN_WARNING LOGNAME ": FIFO read error\n");
911 spin_unlock_irqrestore(&dev.lock, flags);
914 spin_unlock_irqrestore(&dev.lock, flags);
918 if (!test_bit(F_READING, &dev.flags) && dev.mode & FMODE_READ) {
919 dev.last_recbank = -1;
920 if (chk_send_dsp_cmd(&dev, HDEX_RECORD_START) == 0)
921 set_bit(F_READING, &dev.flags);
925 return count == len ? -EAGAIN : len - count;
928 set_bit(F_READBLOCK, &dev.flags);
929 if (!interruptible_sleep_on_timeout(
931 get_rec_delay_jiffies(DAR_BUFF_SIZE)))
932 clear_bit(F_READING, &dev.flags);
933 clear_bit(F_READBLOCK, &dev.flags);
934 if (signal_pending(current))
942 static int dsp_write(const char *buf, size_t len)
950 /* Critical section: protect fifo in non-interrupt */
951 spin_lock_irqsave(&dev.lock, flags);
952 if ((n = msnd_fifo_write(&dev.DAPF, buf, count, 1)) < 0) {
953 printk(KERN_WARNING LOGNAME ": FIFO write error\n");
954 spin_unlock_irqrestore(&dev.lock, flags);
957 spin_unlock_irqrestore(&dev.lock, flags);
961 if (!test_bit(F_WRITING, &dev.flags) && (dev.mode & FMODE_WRITE)) {
962 dev.last_playbank = -1;
963 if (pack_DAPF_to_DAPQ(1) > 0)
964 set_bit(F_WRITING, &dev.flags);
968 return count == len ? -EAGAIN : len - count;
971 set_bit(F_WRITEBLOCK, &dev.flags);
972 interruptible_sleep_on_timeout(
974 get_play_delay_jiffies(DAP_BUFF_SIZE));
975 clear_bit(F_WRITEBLOCK, &dev.flags);
976 if (signal_pending(current))
984 static ssize_t dev_read(struct file *file, char *buf, size_t count, loff_t *off)
986 int minor = iminor(file->f_dentry->d_inode);
987 if (minor == dev.dsp_minor)
988 return dsp_read(buf, count);
993 static ssize_t dev_write(struct file *file, const char *buf, size_t count, loff_t *off)
995 int minor = iminor(file->f_dentry->d_inode);
996 if (minor == dev.dsp_minor)
997 return dsp_write(buf, count);
1002 static __inline__ void eval_dsp_msg(register WORD wMessage)
1004 switch (HIBYTE(wMessage)) {
1005 case HIMT_PLAY_DONE:
1006 if (dev.last_playbank == LOBYTE(wMessage) || !test_bit(F_WRITING, &dev.flags))
1008 dev.last_playbank = LOBYTE(wMessage);
1010 if (pack_DAPF_to_DAPQ(0) <= 0) {
1011 if (!test_bit(F_WRITEBLOCK, &dev.flags)) {
1012 if (test_and_clear_bit(F_WRITEFLUSH, &dev.flags))
1013 wake_up_interruptible(&dev.writeflush);
1015 clear_bit(F_WRITING, &dev.flags);
1018 if (test_bit(F_WRITEBLOCK, &dev.flags))
1019 wake_up_interruptible(&dev.writeblock);
1022 case HIMT_RECORD_DONE:
1023 if (dev.last_recbank == LOBYTE(wMessage))
1025 dev.last_recbank = LOBYTE(wMessage);
1027 pack_DARQ_to_DARF(dev.last_recbank);
1029 if (test_bit(F_READBLOCK, &dev.flags))
1030 wake_up_interruptible(&dev.readblock);
1034 switch (LOBYTE(wMessage)) {
1035 #ifndef MSND_CLASSIC
1036 case HIDSP_PLAY_UNDER:
1038 case HIDSP_INT_PLAY_UNDER:
1039 /* printk(KERN_DEBUG LOGNAME ": Play underflow\n"); */
1040 clear_bit(F_WRITING, &dev.flags);
1043 case HIDSP_INT_RECORD_OVER:
1044 /* printk(KERN_DEBUG LOGNAME ": Record overflow\n"); */
1045 clear_bit(F_READING, &dev.flags);
1049 /* printk(KERN_DEBUG LOGNAME ": DSP message %d 0x%02x\n",
1050 LOBYTE(wMessage), LOBYTE(wMessage)); */
1055 case HIMT_MIDI_IN_UCHAR:
1056 if (dev.midi_in_interrupt)
1057 (*dev.midi_in_interrupt)(&dev);
1061 /* printk(KERN_DEBUG LOGNAME ": HIMT message %d 0x%02x\n", HIBYTE(wMessage), HIBYTE(wMessage)); */
1066 static irqreturn_t intr(int irq, void *dev_id, struct pt_regs *regs)
1068 /* Send ack to DSP */
1069 inb(dev.io + HP_RXL);
1071 /* Evaluate queued DSP messages */
1072 while (isa_readw(dev.DSPQ + JQS_wTail) != isa_readw(dev.DSPQ + JQS_wHead)) {
1075 eval_dsp_msg(isa_readw(dev.pwDSPQData + 2*isa_readw(dev.DSPQ + JQS_wHead)));
1077 if ((wTmp = isa_readw(dev.DSPQ + JQS_wHead) + 1) > isa_readw(dev.DSPQ + JQS_wSize))
1078 isa_writew(0, dev.DSPQ + JQS_wHead);
1080 isa_writew(wTmp, dev.DSPQ + JQS_wHead);
1085 static struct file_operations dev_fileops = {
1086 .owner = THIS_MODULE,
1091 .release = dev_release,
1094 static int reset_dsp(void)
1098 outb(HPDSPRESET_ON, dev.io + HP_DSPR);
1100 #ifndef MSND_CLASSIC
1101 dev.info = inb(dev.io + HP_INFO);
1103 outb(HPDSPRESET_OFF, dev.io + HP_DSPR);
1105 while (timeout-- > 0) {
1106 if (inb(dev.io + HP_CVR) == HP_CVR_DEF)
1110 printk(KERN_ERR LOGNAME ": Cannot reset DSP\n");
1115 static int __init probe_multisound(void)
1117 #ifndef MSND_CLASSIC
1118 char *xv, *rev = NULL;
1119 char *pin = "Pinnacle", *fiji = "Fiji";
1120 char *pinfiji = "Pinnacle/Fiji";
1123 if (check_region(dev.io, dev.numio)) {
1124 printk(KERN_ERR LOGNAME ": I/O port conflict\n");
1127 request_region(dev.io, dev.numio, "probing");
1129 if (reset_dsp() < 0) {
1130 release_region(dev.io, dev.numio);
1135 dev.name = "Classic/Tahiti/Monterey";
1136 printk(KERN_INFO LOGNAME ": %s, "
1138 switch (dev.info >> 4) {
1139 case 0xf: xv = "<= 1.15"; break;
1140 case 0x1: xv = "1.18/1.2"; break;
1141 case 0x2: xv = "1.3"; break;
1142 case 0x3: xv = "1.4"; break;
1143 default: xv = "unknown"; break;
1146 switch (dev.info & 0x7) {
1147 case 0x0: rev = "I"; dev.name = pin; break;
1148 case 0x1: rev = "F"; dev.name = pin; break;
1149 case 0x2: rev = "G"; dev.name = pin; break;
1150 case 0x3: rev = "H"; dev.name = pin; break;
1151 case 0x4: rev = "E"; dev.name = fiji; break;
1152 case 0x5: rev = "C"; dev.name = fiji; break;
1153 case 0x6: rev = "D"; dev.name = fiji; break;
1155 rev = "A-B (Fiji) or A-E (Pinnacle)";
1159 printk(KERN_INFO LOGNAME ": %s revision %s, Xilinx version %s, "
1160 #endif /* MSND_CLASSIC */
1161 "I/O 0x%x-0x%x, IRQ %d, memory mapped to 0x%lX-0x%lX\n",
1163 #ifndef MSND_CLASSIC
1166 dev.io, dev.io + dev.numio - 1,
1168 dev.base, dev.base + 0x7fff);
1170 release_region(dev.io, dev.numio);
1174 static int init_sma(void)
1177 WORD mastVolLeft, mastVolRight;
1178 unsigned long flags;
1181 outb(dev.memid, dev.io + HP_MEMM);
1183 outb(HPBLKSEL_0, dev.io + HP_BLKS);
1185 mastVolLeft = isa_readw(dev.SMA + SMA_wCurrMastVolLeft);
1186 mastVolRight = isa_readw(dev.SMA + SMA_wCurrMastVolRight);
1188 mastVolLeft = mastVolRight = 0;
1189 isa_memset_io(dev.base, 0, 0x8000);
1191 /* Critical section: bank 1 access */
1192 spin_lock_irqsave(&dev.lock, flags);
1193 outb(HPBLKSEL_1, dev.io + HP_BLKS);
1194 isa_memset_io(dev.base, 0, 0x8000);
1195 outb(HPBLKSEL_0, dev.io + HP_BLKS);
1196 spin_unlock_irqrestore(&dev.lock, flags);
1198 dev.pwDSPQData = (dev.base + DSPQ_DATA_BUFF);
1199 dev.pwMODQData = (dev.base + MODQ_DATA_BUFF);
1200 dev.pwMIDQData = (dev.base + MIDQ_DATA_BUFF);
1202 /* Motorola 56k shared memory base */
1203 dev.SMA = dev.base + SMA_STRUCT_START;
1205 /* Digital audio play queue */
1206 dev.DAPQ = dev.base + DAPQ_OFFSET;
1207 msnd_init_queue(dev.DAPQ, DAPQ_DATA_BUFF, DAPQ_BUFF_SIZE);
1209 /* Digital audio record queue */
1210 dev.DARQ = dev.base + DARQ_OFFSET;
1211 msnd_init_queue(dev.DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE);
1213 /* MIDI out queue */
1214 dev.MODQ = dev.base + MODQ_OFFSET;
1215 msnd_init_queue(dev.MODQ, MODQ_DATA_BUFF, MODQ_BUFF_SIZE);
1218 dev.MIDQ = dev.base + MIDQ_OFFSET;
1219 msnd_init_queue(dev.MIDQ, MIDQ_DATA_BUFF, MIDQ_BUFF_SIZE);
1221 /* DSP -> host message queue */
1222 dev.DSPQ = dev.base + DSPQ_OFFSET;
1223 msnd_init_queue(dev.DSPQ, DSPQ_DATA_BUFF, DSPQ_BUFF_SIZE);
1225 /* Setup some DSP values */
1226 #ifndef MSND_CLASSIC
1227 isa_writew(1, dev.SMA + SMA_wCurrPlayFormat);
1228 isa_writew(dev.play_sample_size, dev.SMA + SMA_wCurrPlaySampleSize);
1229 isa_writew(dev.play_channels, dev.SMA + SMA_wCurrPlayChannels);
1230 isa_writew(dev.play_sample_rate, dev.SMA + SMA_wCurrPlaySampleRate);
1232 isa_writew(dev.play_sample_rate, dev.SMA + SMA_wCalFreqAtoD);
1233 isa_writew(mastVolLeft, dev.SMA + SMA_wCurrMastVolLeft);
1234 isa_writew(mastVolRight, dev.SMA + SMA_wCurrMastVolRight);
1235 #ifndef MSND_CLASSIC
1236 isa_writel(0x00010000, dev.SMA + SMA_dwCurrPlayPitch);
1237 isa_writel(0x00000001, dev.SMA + SMA_dwCurrPlayRate);
1239 isa_writew(0x303, dev.SMA + SMA_wCurrInputTagBits);
1246 static int __init calibrate_adc(WORD srate)
1248 isa_writew(srate, dev.SMA + SMA_wCalFreqAtoD);
1249 if (dev.calibrate_signal == 0)
1250 isa_writew(isa_readw(dev.SMA + SMA_wCurrHostStatusFlags)
1251 | 0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
1253 isa_writew(isa_readw(dev.SMA + SMA_wCurrHostStatusFlags)
1254 & ~0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
1255 if (msnd_send_word(&dev, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
1256 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ) == 0) {
1257 current->state = TASK_INTERRUPTIBLE;
1258 schedule_timeout(HZ / 3);
1261 printk(KERN_WARNING LOGNAME ": ADC calibration failed\n");
1266 static int upload_dsp_code(void)
1268 outb(HPBLKSEL_0, dev.io + HP_BLKS);
1269 #ifndef HAVE_DSPCODEH
1270 INITCODESIZE = mod_firmware_load(INITCODEFILE, &INITCODE);
1272 printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
1276 PERMCODESIZE = mod_firmware_load(PERMCODEFILE, &PERMCODE);
1278 printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
1283 isa_memcpy_toio(dev.base, PERMCODE, PERMCODESIZE);
1284 if (msnd_upload_host(&dev, INITCODE, INITCODESIZE) < 0) {
1285 printk(KERN_WARNING LOGNAME ": Error uploading to DSP\n");
1288 #ifdef HAVE_DSPCODEH
1289 printk(KERN_INFO LOGNAME ": DSP firmware uploaded (resident)\n");
1291 printk(KERN_INFO LOGNAME ": DSP firmware uploaded\n");
1294 #ifndef HAVE_DSPCODEH
1303 static void reset_proteus(void)
1305 outb(HPPRORESET_ON, dev.io + HP_PROR);
1306 mdelay(TIME_PRO_RESET);
1307 outb(HPPRORESET_OFF, dev.io + HP_PROR);
1308 mdelay(TIME_PRO_RESET_DONE);
1312 static int initialize(void)
1317 outb(HPWAITSTATE_0, dev.io + HP_WAIT);
1318 outb(HPBITMODE_16, dev.io + HP_BITM);
1322 if ((err = init_sma()) < 0) {
1323 printk(KERN_WARNING LOGNAME ": Cannot initialize SMA\n");
1327 if ((err = reset_dsp()) < 0)
1330 if ((err = upload_dsp_code()) < 0) {
1331 printk(KERN_WARNING LOGNAME ": Cannot upload DSP code\n");
1336 while (isa_readw(dev.base)) {
1339 printk(KERN_DEBUG LOGNAME ": DSP reset timeout\n");
1349 static int dsp_full_reset(void)
1353 if (test_bit(F_RESETTING, &dev.flags) || ++dev.nresets > 10)
1356 set_bit(F_RESETTING, &dev.flags);
1357 printk(KERN_INFO LOGNAME ": DSP reset\n");
1358 dsp_halt(NULL); /* Unconditionally halt */
1359 if ((rv = initialize()))
1360 printk(KERN_WARNING LOGNAME ": DSP reset failed\n");
1361 force_recsrc(dev.recsrc);
1363 clear_bit(F_RESETTING, &dev.flags);
1368 static int __init attach_multisound(void)
1372 if ((err = request_irq(dev.irq, intr, 0, dev.name, &dev)) < 0) {
1373 printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
1376 request_region(dev.io, dev.numio, dev.name);
1378 if ((err = dsp_full_reset()) < 0) {
1379 release_region(dev.io, dev.numio);
1380 free_irq(dev.irq, &dev);
1384 if ((err = msnd_register(&dev)) < 0) {
1385 printk(KERN_ERR LOGNAME ": Unable to register MultiSound\n");
1386 release_region(dev.io, dev.numio);
1387 free_irq(dev.irq, &dev);
1391 if ((dev.dsp_minor = register_sound_dsp(&dev_fileops, -1)) < 0) {
1392 printk(KERN_ERR LOGNAME ": Unable to register DSP operations\n");
1393 msnd_unregister(&dev);
1394 release_region(dev.io, dev.numio);
1395 free_irq(dev.irq, &dev);
1396 return dev.dsp_minor;
1399 if ((dev.mixer_minor = register_sound_mixer(&dev_fileops, -1)) < 0) {
1400 printk(KERN_ERR LOGNAME ": Unable to register mixer operations\n");
1401 unregister_sound_mixer(dev.mixer_minor);
1402 msnd_unregister(&dev);
1403 release_region(dev.io, dev.numio);
1404 free_irq(dev.irq, &dev);
1405 return dev.mixer_minor;
1408 dev.ext_midi_dev = dev.hdr_midi_dev = -1;
1410 disable_irq(dev.irq);
1411 calibrate_adc(dev.play_sample_rate);
1412 #ifndef MSND_CLASSIC
1413 force_recsrc(SOUND_MASK_IMIX);
1419 static void __exit unload_multisound(void)
1421 release_region(dev.io, dev.numio);
1422 free_irq(dev.irq, &dev);
1423 unregister_sound_mixer(dev.mixer_minor);
1424 unregister_sound_dsp(dev.dsp_minor);
1425 msnd_unregister(&dev);
1428 #ifndef MSND_CLASSIC
1430 /* Pinnacle/Fiji Logical Device Configuration */
1432 static int __init msnd_write_cfg(int cfg, int reg, int value)
1435 outb(value, cfg + 1);
1436 if (value != inb(cfg + 1)) {
1437 printk(KERN_ERR LOGNAME ": msnd_write_cfg: I/O error\n");
1443 static int __init msnd_write_cfg_io0(int cfg, int num, WORD io)
1445 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1447 if (msnd_write_cfg(cfg, IREG_IO0_BASEHI, HIBYTE(io)))
1449 if (msnd_write_cfg(cfg, IREG_IO0_BASELO, LOBYTE(io)))
1454 static int __init msnd_write_cfg_io1(int cfg, int num, WORD io)
1456 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1458 if (msnd_write_cfg(cfg, IREG_IO1_BASEHI, HIBYTE(io)))
1460 if (msnd_write_cfg(cfg, IREG_IO1_BASELO, LOBYTE(io)))
1465 static int __init msnd_write_cfg_irq(int cfg, int num, WORD irq)
1467 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1469 if (msnd_write_cfg(cfg, IREG_IRQ_NUMBER, LOBYTE(irq)))
1471 if (msnd_write_cfg(cfg, IREG_IRQ_TYPE, IRQTYPE_EDGE))
1476 static int __init msnd_write_cfg_mem(int cfg, int num, int mem)
1483 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1485 if (msnd_write_cfg(cfg, IREG_MEMBASEHI, HIBYTE(wmem)))
1487 if (msnd_write_cfg(cfg, IREG_MEMBASELO, LOBYTE(wmem)))
1489 if (wmem && msnd_write_cfg(cfg, IREG_MEMCONTROL, (MEMTYPE_HIADDR | MEMTYPE_16BIT)))
1494 static int __init msnd_activate_logical(int cfg, int num)
1496 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1498 if (msnd_write_cfg(cfg, IREG_ACTIVATE, LD_ACTIVATE))
1503 static int __init msnd_write_cfg_logical(int cfg, int num, WORD io0, WORD io1, WORD irq, int mem)
1505 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1507 if (msnd_write_cfg_io0(cfg, num, io0))
1509 if (msnd_write_cfg_io1(cfg, num, io1))
1511 if (msnd_write_cfg_irq(cfg, num, irq))
1513 if (msnd_write_cfg_mem(cfg, num, mem))
1515 if (msnd_activate_logical(cfg, num))
1520 typedef struct msnd_pinnacle_cfg_device {
1523 } msnd_pinnacle_cfg_t[4];
1525 static int __init msnd_pinnacle_cfg_devices(int cfg, int reset, msnd_pinnacle_cfg_t device)
1529 /* Reset devices if told to */
1531 printk(KERN_INFO LOGNAME ": Resetting all devices\n");
1532 for (i = 0; i < 4; ++i)
1533 if (msnd_write_cfg_logical(cfg, i, 0, 0, 0, 0))
1537 /* Configure specified devices */
1538 for (i = 0; i < 4; ++i) {
1542 if (!(device[i].io0 && device[i].irq && device[i].mem))
1546 if (!(device[i].io0 && device[i].irq))
1548 printk(KERN_INFO LOGNAME
1549 ": Configuring MPU to I/O 0x%x IRQ %d\n",
1550 device[i].io0, device[i].irq);
1553 if (!(device[i].io0 && device[i].io1 && device[i].irq))
1555 printk(KERN_INFO LOGNAME
1556 ": Configuring IDE to I/O 0x%x, 0x%x IRQ %d\n",
1557 device[i].io0, device[i].io1, device[i].irq);
1559 case 3: /* Joystick */
1560 if (!(device[i].io0))
1562 printk(KERN_INFO LOGNAME
1563 ": Configuring joystick to I/O 0x%x\n",
1568 /* Configure the device */
1569 if (msnd_write_cfg_logical(cfg, i, device[i].io0, device[i].io1, device[i].irq, device[i].mem))
1578 MODULE_AUTHOR ("Andrew Veliath <andrewtv@usa.net>");
1579 MODULE_DESCRIPTION ("Turtle Beach " LONGNAME " Linux Driver");
1580 MODULE_LICENSE("GPL");
1582 MODULE_PARM (io, "i");
1583 MODULE_PARM (irq, "i");
1584 MODULE_PARM (mem, "i");
1585 MODULE_PARM (write_ndelay, "i");
1586 MODULE_PARM (fifosize, "i");
1587 MODULE_PARM (calibrate_signal, "i");
1588 #ifndef MSND_CLASSIC
1589 MODULE_PARM (digital, "i");
1590 MODULE_PARM (cfg, "i");
1591 MODULE_PARM (reset, "i");
1592 MODULE_PARM (mpu_io, "i");
1593 MODULE_PARM (mpu_irq, "i");
1594 MODULE_PARM (ide_io0, "i");
1595 MODULE_PARM (ide_io1, "i");
1596 MODULE_PARM (ide_irq, "i");
1597 MODULE_PARM (joystick_io, "i");
1600 static int io __initdata = -1;
1601 static int irq __initdata = -1;
1602 static int mem __initdata = -1;
1603 static int write_ndelay __initdata = -1;
1605 #ifndef MSND_CLASSIC
1606 /* Pinnacle/Fiji non-PnP Config Port */
1607 static int cfg __initdata = -1;
1609 /* Extra Peripheral Configuration */
1610 static int reset __initdata = 0;
1611 static int mpu_io __initdata = 0;
1612 static int mpu_irq __initdata = 0;
1613 static int ide_io0 __initdata = 0;
1614 static int ide_io1 __initdata = 0;
1615 static int ide_irq __initdata = 0;
1616 static int joystick_io __initdata = 0;
1618 /* If we have the digital daugherboard... */
1619 static int digital __initdata = 0;
1622 static int fifosize __initdata = DEFFIFOSIZE;
1623 static int calibrate_signal __initdata = 0;
1625 #else /* not a module */
1627 static int write_ndelay __initdata = -1;
1630 static int io __initdata = CONFIG_MSNDCLAS_IO;
1631 static int irq __initdata = CONFIG_MSNDCLAS_IRQ;
1632 static int mem __initdata = CONFIG_MSNDCLAS_MEM;
1633 #else /* Pinnacle/Fiji */
1635 static int io __initdata = CONFIG_MSNDPIN_IO;
1636 static int irq __initdata = CONFIG_MSNDPIN_IRQ;
1637 static int mem __initdata = CONFIG_MSNDPIN_MEM;
1639 /* Pinnacle/Fiji non-PnP Config Port */
1640 #ifdef CONFIG_MSNDPIN_NONPNP
1641 # ifndef CONFIG_MSNDPIN_CFG
1642 # define CONFIG_MSNDPIN_CFG 0x250
1645 # ifdef CONFIG_MSNDPIN_CFG
1646 # undef CONFIG_MSNDPIN_CFG
1648 # define CONFIG_MSNDPIN_CFG -1
1650 static int cfg __initdata = CONFIG_MSNDPIN_CFG;
1651 /* If not a module, we don't need to bother with reset=1 */
1654 /* Extra Peripheral Configuration (Default: Disable) */
1655 #ifndef CONFIG_MSNDPIN_MPU_IO
1656 # define CONFIG_MSNDPIN_MPU_IO 0
1658 static int mpu_io __initdata = CONFIG_MSNDPIN_MPU_IO;
1660 #ifndef CONFIG_MSNDPIN_MPU_IRQ
1661 # define CONFIG_MSNDPIN_MPU_IRQ 0
1663 static int mpu_irq __initdata = CONFIG_MSNDPIN_MPU_IRQ;
1665 #ifndef CONFIG_MSNDPIN_IDE_IO0
1666 # define CONFIG_MSNDPIN_IDE_IO0 0
1668 static int ide_io0 __initdata = CONFIG_MSNDPIN_IDE_IO0;
1670 #ifndef CONFIG_MSNDPIN_IDE_IO1
1671 # define CONFIG_MSNDPIN_IDE_IO1 0
1673 static int ide_io1 __initdata = CONFIG_MSNDPIN_IDE_IO1;
1675 #ifndef CONFIG_MSNDPIN_IDE_IRQ
1676 # define CONFIG_MSNDPIN_IDE_IRQ 0
1678 static int ide_irq __initdata = CONFIG_MSNDPIN_IDE_IRQ;
1680 #ifndef CONFIG_MSNDPIN_JOYSTICK_IO
1681 # define CONFIG_MSNDPIN_JOYSTICK_IO 0
1683 static int joystick_io __initdata = CONFIG_MSNDPIN_JOYSTICK_IO;
1685 /* Have SPDIF (Digital) Daughterboard */
1686 #ifndef CONFIG_MSNDPIN_DIGITAL
1687 # define CONFIG_MSNDPIN_DIGITAL 0
1689 static int digital __initdata = CONFIG_MSNDPIN_DIGITAL;
1691 #endif /* MSND_CLASSIC */
1693 #ifndef CONFIG_MSND_FIFOSIZE
1694 # define CONFIG_MSND_FIFOSIZE DEFFIFOSIZE
1696 static int fifosize __initdata = CONFIG_MSND_FIFOSIZE;
1698 #ifndef CONFIG_MSND_CALSIGNAL
1699 # define CONFIG_MSND_CALSIGNAL 0
1702 calibrate_signal __initdata = CONFIG_MSND_CALSIGNAL;
1706 static int __init msnd_init(void)
1709 #ifndef MSND_CLASSIC
1710 static msnd_pinnacle_cfg_t pinnacle_devs;
1711 #endif /* MSND_CLASSIC */
1713 printk(KERN_INFO LOGNAME ": Turtle Beach " LONGNAME " Linux Driver Version "
1714 VERSION ", Copyright (C) 1998 Andrew Veliath\n");
1716 if (io == -1 || irq == -1 || mem == -1)
1717 printk(KERN_WARNING LOGNAME ": io, irq and mem must be set\n");
1729 printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must be set to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, or 0x3E0\n");
1737 printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must within the range 0x100 to 0x3E0 and must be evenly divisible by 0x10\n");
1740 #endif /* MSND_CLASSIC */
1749 printk(KERN_ERR LOGNAME ": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
1760 printk(KERN_ERR LOGNAME ": \"mem\" - must be set to "
1761 "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or 0xe8000\n");
1767 case 5: dev.irqid = HPIRQ_5; break;
1768 case 7: dev.irqid = HPIRQ_7; break;
1769 case 9: dev.irqid = HPIRQ_9; break;
1770 case 10: dev.irqid = HPIRQ_10; break;
1771 case 11: dev.irqid = HPIRQ_11; break;
1772 case 12: dev.irqid = HPIRQ_12; break;
1776 case 0xb0000: dev.memid = HPMEM_B000; break;
1777 case 0xc8000: dev.memid = HPMEM_C800; break;
1778 case 0xd0000: dev.memid = HPMEM_D000; break;
1779 case 0xd8000: dev.memid = HPMEM_D800; break;
1780 case 0xe0000: dev.memid = HPMEM_E000; break;
1781 case 0xe8000: dev.memid = HPMEM_E800; break;
1785 printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
1786 } else if (cfg != 0x250 && cfg != 0x260 && cfg != 0x270) {
1787 printk(KERN_INFO LOGNAME ": Config port must be 0x250, 0x260 or 0x270 (or unspecified for PnP mode)\n");
1790 printk(KERN_INFO LOGNAME ": Non-PnP mode: configuring at port 0x%x\n", cfg);
1793 pinnacle_devs[0].io0 = io;
1794 pinnacle_devs[0].irq = irq;
1795 pinnacle_devs[0].mem = mem;
1797 /* The following are Pinnacle specific */
1800 pinnacle_devs[1].io0 = mpu_io;
1801 pinnacle_devs[1].irq = mpu_irq;
1804 pinnacle_devs[2].io0 = ide_io0;
1805 pinnacle_devs[2].io1 = ide_io1;
1806 pinnacle_devs[2].irq = ide_irq;
1809 pinnacle_devs[3].io0 = joystick_io;
1811 if (check_region(cfg, 2)) {
1812 printk(KERN_ERR LOGNAME ": Config port 0x%x conflict\n", cfg);
1816 request_region(cfg, 2, "Pinnacle/Fiji Config");
1817 if (msnd_pinnacle_cfg_devices(cfg, reset, pinnacle_devs)) {
1818 printk(KERN_ERR LOGNAME ": Device configuration error\n");
1819 release_region(cfg, 2);
1822 release_region(cfg, 2);
1824 #endif /* MSND_CLASSIC */
1829 if (fifosize > 1024)
1832 set_default_audio_parameters();
1834 dev.type = msndClassic;
1836 dev.type = msndPinnacle;
1839 dev.numio = DSP_NUMIO;
1842 dev.fifosize = fifosize * 1024;
1843 dev.calibrate_signal = calibrate_signal ? 1 : 0;
1845 dev.dspq_data_buff = DSPQ_DATA_BUFF;
1846 dev.dspq_buff_size = DSPQ_BUFF_SIZE;
1847 if (write_ndelay == -1)
1848 write_ndelay = CONFIG_MSND_WRITE_NDELAY;
1850 clear_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
1852 set_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
1853 #ifndef MSND_CLASSIC
1855 set_bit(F_HAVEDIGITAL, &dev.flags);
1857 init_waitqueue_head(&dev.writeblock);
1858 init_waitqueue_head(&dev.readblock);
1859 init_waitqueue_head(&dev.writeflush);
1860 msnd_fifo_init(&dev.DAPF);
1861 msnd_fifo_init(&dev.DARF);
1862 spin_lock_init(&dev.lock);
1863 printk(KERN_INFO LOGNAME ": %u byte audio FIFOs (x2)\n", dev.fifosize);
1864 if ((err = msnd_fifo_alloc(&dev.DAPF, dev.fifosize)) < 0) {
1865 printk(KERN_ERR LOGNAME ": Couldn't allocate write FIFO\n");
1869 if ((err = msnd_fifo_alloc(&dev.DARF, dev.fifosize)) < 0) {
1870 printk(KERN_ERR LOGNAME ": Couldn't allocate read FIFO\n");
1871 msnd_fifo_free(&dev.DAPF);
1875 if ((err = probe_multisound()) < 0) {
1876 printk(KERN_ERR LOGNAME ": Probe failed\n");
1877 msnd_fifo_free(&dev.DAPF);
1878 msnd_fifo_free(&dev.DARF);
1882 if ((err = attach_multisound()) < 0) {
1883 printk(KERN_ERR LOGNAME ": Attach failed\n");
1884 msnd_fifo_free(&dev.DAPF);
1885 msnd_fifo_free(&dev.DARF);
1892 static void __exit msdn_cleanup(void)
1894 unload_multisound();
1895 msnd_fifo_free(&dev.DAPF);
1896 msnd_fifo_free(&dev.DARF);
1899 module_init(msnd_init);
1900 module_exit(msdn_cleanup);