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.75 1999/03/21 16:50:09 andrewtv Exp $
34 ********************************************************************/
36 #include <linux/kernel.h>
37 #include <linux/config.h>
38 #include <linux/version.h>
39 #include <linux/module.h>
40 #include <linux/malloc.h>
41 #include <linux/types.h>
42 #include <linux/delay.h>
43 #include <linux/init.h>
44 #include <linux/smp_lock.h>
47 #include "sound_config.h"
48 #include "sound_firmware.h"
54 # ifdef CONFIG_MSNDCLAS_HAVE_BOOT
55 # define HAVE_DSPCODEH
57 # include "msnd_classic.h"
58 # define LOGNAME "msnd_classic"
60 # ifdef CONFIG_MSNDPIN_HAVE_BOOT
61 # define HAVE_DSPCODEH
63 # include "msnd_pinnacle.h"
64 # define LOGNAME "msnd_pinnacle"
67 #ifndef CONFIG_MSND_WRITE_NDELAY
68 # define CONFIG_MSND_WRITE_NDELAY 1
71 #define get_play_delay_jiffies(size) ((size) * HZ * \
72 dev.play_sample_size / 8 / \
73 dev.play_sample_rate / \
76 #define get_rec_delay_jiffies(size) ((size) * HZ * \
77 dev.rec_sample_size / 8 / \
78 dev.rec_sample_rate / \
81 static multisound_dev_t dev
;
84 static char *dspini
, *permini
;
85 static int sizeof_dspini
, sizeof_permini
;
88 static int dsp_full_reset(void);
89 static void dsp_write_flush(void);
91 static __inline__
int chk_send_dsp_cmd(multisound_dev_t
*dev
, register BYTE cmd
)
93 if (msnd_send_dsp_cmd(dev
, cmd
) == 0)
96 return msnd_send_dsp_cmd(dev
, cmd
);
99 static void reset_play_queue(void)
104 dev
.last_playbank
= -1;
105 isa_writew(PCTODSP_OFFSET(0 * DAQDS__size
), dev
.DAPQ
+ JQS_wHead
);
106 isa_writew(PCTODSP_OFFSET(0 * DAQDS__size
), dev
.DAPQ
+ JQS_wTail
);
108 for (n
= 0, lpDAQ
= dev
.base
+ DAPQ_DATA_BUFF
; n
< 3; ++n
, lpDAQ
+= DAQDS__size
) {
109 isa_writew(PCTODSP_BASED((DWORD
)(DAP_BUFF_SIZE
* n
)), lpDAQ
+ DAQDS_wStart
);
110 isa_writew(0, lpDAQ
+ DAQDS_wSize
);
111 isa_writew(1, lpDAQ
+ DAQDS_wFormat
);
112 isa_writew(dev
.play_sample_size
, lpDAQ
+ DAQDS_wSampleSize
);
113 isa_writew(dev
.play_channels
, lpDAQ
+ DAQDS_wChannels
);
114 isa_writew(dev
.play_sample_rate
, lpDAQ
+ DAQDS_wSampleRate
);
115 isa_writew(HIMT_PLAY_DONE
* 0x100 + n
, lpDAQ
+ DAQDS_wIntMsg
);
116 isa_writew(n
, lpDAQ
+ DAQDS_wFlags
);
120 static void reset_record_queue(void)
126 dev
.last_recbank
= 2;
127 isa_writew(PCTODSP_OFFSET(0 * DAQDS__size
), dev
.DARQ
+ JQS_wHead
);
128 isa_writew(PCTODSP_OFFSET(dev
.last_recbank
* DAQDS__size
), dev
.DARQ
+ JQS_wTail
);
130 /* Critical section: bank 1 access */
131 spin_lock_irqsave(&dev
.lock
, flags
);
132 outb(HPBLKSEL_1
, dev
.io
+ HP_BLKS
);
133 isa_memset_io(dev
.base
, 0, DAR_BUFF_SIZE
* 3);
134 outb(HPBLKSEL_0
, dev
.io
+ HP_BLKS
);
135 spin_unlock_irqrestore(&dev
.lock
, flags
);
137 for (n
= 0, lpDAQ
= dev
.base
+ DARQ_DATA_BUFF
; n
< 3; ++n
, lpDAQ
+= DAQDS__size
) {
138 isa_writew(PCTODSP_BASED((DWORD
)(DAR_BUFF_SIZE
* n
)) + 0x4000, lpDAQ
+ DAQDS_wStart
);
139 isa_writew(DAR_BUFF_SIZE
, lpDAQ
+ DAQDS_wSize
);
140 isa_writew(1, lpDAQ
+ DAQDS_wFormat
);
141 isa_writew(dev
.rec_sample_size
, lpDAQ
+ DAQDS_wSampleSize
);
142 isa_writew(dev
.rec_channels
, lpDAQ
+ DAQDS_wChannels
);
143 isa_writew(dev
.rec_sample_rate
, lpDAQ
+ DAQDS_wSampleRate
);
144 isa_writew(HIMT_RECORD_DONE
* 0x100 + n
, lpDAQ
+ DAQDS_wIntMsg
);
145 isa_writew(n
, lpDAQ
+ DAQDS_wFlags
);
149 static void reset_queues(void)
151 if (dev
.mode
& FMODE_WRITE
) {
152 msnd_fifo_make_empty(&dev
.DAPF
);
155 if (dev
.mode
& FMODE_READ
) {
156 msnd_fifo_make_empty(&dev
.DARF
);
157 reset_record_queue();
161 static int dsp_set_format(struct file
*file
, int val
)
164 LPDAQD lpDAQ
, lpDARQ
;
166 lpDAQ
= dev
.base
+ DAPQ_DATA_BUFF
;
167 lpDARQ
= dev
.base
+ DARQ_DATA_BUFF
;
175 data
= DEFSAMPLESIZE
;
179 for (i
= 0; i
< 3; ++i
, lpDAQ
+= DAQDS__size
, lpDARQ
+= DAQDS__size
) {
180 if (file
->f_mode
& FMODE_WRITE
)
181 isa_writew(data
, lpDAQ
+ DAQDS_wSampleSize
);
182 if (file
->f_mode
& FMODE_READ
)
183 isa_writew(data
, lpDARQ
+ DAQDS_wSampleSize
);
185 if (file
->f_mode
& FMODE_WRITE
)
186 dev
.play_sample_size
= data
;
187 if (file
->f_mode
& FMODE_READ
)
188 dev
.rec_sample_size
= data
;
193 static int dsp_get_frag_size(void)
196 size
= dev
.fifosize
/ 4;
197 if (size
> 32 * 1024)
202 static int dsp_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
204 int val
, i
, data
, tmp
;
205 LPDAQD lpDAQ
, lpDARQ
;
206 audio_buf_info abinfo
;
209 lpDAQ
= dev
.base
+ DAPQ_DATA_BUFF
;
210 lpDARQ
= dev
.base
+ DARQ_DATA_BUFF
;
213 case SNDCTL_DSP_SUBDIVIDE
:
214 case SNDCTL_DSP_SETFRAGMENT
:
215 case SNDCTL_DSP_SETDUPLEX
:
216 case SNDCTL_DSP_POST
:
219 case SNDCTL_DSP_GETIPTR
:
220 case SNDCTL_DSP_GETOPTR
:
221 case SNDCTL_DSP_MAPINBUF
:
222 case SNDCTL_DSP_MAPOUTBUF
:
225 case SNDCTL_DSP_GETOSPACE
:
226 if (!(file
->f_mode
& FMODE_WRITE
))
228 spin_lock_irqsave(&dev
.lock
, flags
);
229 abinfo
.fragsize
= dsp_get_frag_size();
230 abinfo
.bytes
= dev
.DAPF
.n
- dev
.DAPF
.len
;
231 abinfo
.fragstotal
= dev
.DAPF
.n
/ abinfo
.fragsize
;
232 abinfo
.fragments
= abinfo
.bytes
/ abinfo
.fragsize
;
233 spin_unlock_irqrestore(&dev
.lock
, flags
);
234 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
236 case SNDCTL_DSP_GETISPACE
:
237 if (!(file
->f_mode
& FMODE_READ
))
239 spin_lock_irqsave(&dev
.lock
, flags
);
240 abinfo
.fragsize
= dsp_get_frag_size();
241 abinfo
.bytes
= dev
.DARF
.n
- dev
.DARF
.len
;
242 abinfo
.fragstotal
= dev
.DARF
.n
/ abinfo
.fragsize
;
243 abinfo
.fragments
= abinfo
.bytes
/ abinfo
.fragsize
;
244 spin_unlock_irqrestore(&dev
.lock
, flags
);
245 return copy_to_user((void *)arg
, &abinfo
, sizeof(abinfo
)) ? -EFAULT
: 0;
247 case SNDCTL_DSP_RESET
:
252 case SNDCTL_DSP_SYNC
:
256 case SNDCTL_DSP_GETBLKSIZE
:
257 tmp
= dsp_get_frag_size();
258 if (put_user(tmp
, (int *)arg
))
262 case SNDCTL_DSP_GETFMTS
:
263 val
= AFMT_S16_LE
| AFMT_U8
;
264 if (put_user(val
, (int *)arg
))
268 case SNDCTL_DSP_SETFMT
:
269 if (get_user(val
, (int *)arg
))
272 if (file
->f_mode
& FMODE_WRITE
)
273 data
= val
== AFMT_QUERY
274 ? dev
.play_sample_size
275 : dsp_set_format(file
, val
);
277 data
= val
== AFMT_QUERY
278 ? dev
.rec_sample_size
279 : dsp_set_format(file
, val
);
281 if (put_user(data
, (int *)arg
))
285 case SNDCTL_DSP_NONBLOCK
:
286 if (!test_bit(F_DISABLE_WRITE_NDELAY
, &dev
.flags
) &&
287 file
->f_mode
& FMODE_WRITE
)
289 if (file
->f_mode
& FMODE_READ
)
293 case SNDCTL_DSP_GETCAPS
:
294 val
= DSP_CAP_DUPLEX
| DSP_CAP_BATCH
;
295 if (put_user(val
, (int *)arg
))
299 case SNDCTL_DSP_SPEED
:
300 if (get_user(val
, (int *)arg
))
311 for (i
= 0; i
< 3; ++i
, lpDAQ
+= DAQDS__size
, lpDARQ
+= DAQDS__size
) {
312 if (file
->f_mode
& FMODE_WRITE
)
313 isa_writew(data
, lpDAQ
+ DAQDS_wSampleRate
);
314 if (file
->f_mode
& FMODE_READ
)
315 isa_writew(data
, lpDARQ
+ DAQDS_wSampleRate
);
317 if (file
->f_mode
& FMODE_WRITE
)
318 dev
.play_sample_rate
= data
;
319 if (file
->f_mode
& FMODE_READ
)
320 dev
.rec_sample_rate
= data
;
322 if (put_user(data
, (int *)arg
))
326 case SNDCTL_DSP_CHANNELS
:
327 case SNDCTL_DSP_STEREO
:
328 if (get_user(val
, (int *)arg
))
331 if (cmd
== SNDCTL_DSP_CHANNELS
) {
354 for (i
= 0; i
< 3; ++i
, lpDAQ
+= DAQDS__size
, lpDARQ
+= DAQDS__size
) {
355 if (file
->f_mode
& FMODE_WRITE
)
356 isa_writew(data
, lpDAQ
+ DAQDS_wChannels
);
357 if (file
->f_mode
& FMODE_READ
)
358 isa_writew(data
, lpDARQ
+ DAQDS_wChannels
);
360 if (file
->f_mode
& FMODE_WRITE
)
361 dev
.play_channels
= data
;
362 if (file
->f_mode
& FMODE_READ
)
363 dev
.rec_channels
= data
;
365 if (put_user(val
, (int *)arg
))
373 static int mixer_get(int d
)
379 case SOUND_MIXER_VOLUME
:
380 case SOUND_MIXER_PCM
:
381 case SOUND_MIXER_LINE
:
382 case SOUND_MIXER_IMIX
:
383 case SOUND_MIXER_LINE1
:
385 case SOUND_MIXER_MIC
:
386 case SOUND_MIXER_SYNTH
:
388 return (dev
.left_levels
[d
] >> 8) * 100 / 0xff |
389 (((dev
.right_levels
[d
] >> 8) * 100 / 0xff) << 8);
395 #define update_volm(a,b) \
396 isa_writew((dev.left_levels[a] >> 1) * \
397 isa_readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff, \
398 dev.SMA + SMA_##b##Left); \
399 isa_writew((dev.right_levels[a] >> 1) * \
400 isa_readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff, \
401 dev.SMA + SMA_##b##Right);
403 #define update_potm(d,s,ar) \
404 isa_writeb((dev.left_levels[d] >> 8) * \
405 isa_readw(dev.SMA + SMA_wCurrMastVolLeft) / 0xffff, \
406 dev.SMA + SMA_##s##Left); \
407 isa_writeb((dev.right_levels[d] >> 8) * \
408 isa_readw(dev.SMA + SMA_wCurrMastVolRight) / 0xffff, \
409 dev.SMA + SMA_##s##Right); \
410 if (msnd_send_word(&dev, 0, 0, ar) == 0) \
411 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
413 #define update_pot(d,s,ar) \
414 isa_writeb(dev.left_levels[d] >> 8, \
415 dev.SMA + SMA_##s##Left); \
416 isa_writeb(dev.right_levels[d] >> 8, \
417 dev.SMA + SMA_##s##Right); \
418 if (msnd_send_word(&dev, 0, 0, ar) == 0) \
419 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ);
421 static int mixer_set(int d
, int value
)
423 int left
= value
& 0x000000ff;
424 int right
= (value
& 0x0000ff00) >> 8;
427 int updatemaster
= 0;
432 bLeft
= left
* 0xff / 100;
433 wLeft
= left
* 0xffff / 100;
435 bRight
= right
* 0xff / 100;
436 wRight
= right
* 0xffff / 100;
438 dev
.left_levels
[d
] = wLeft
;
439 dev
.right_levels
[d
] = wRight
;
442 /* master volume unscaled controls */
443 case SOUND_MIXER_LINE
: /* line pot control */
444 /* scaled by IMIX in digital mix */
445 isa_writeb(bLeft
, dev
.SMA
+ SMA_bInPotPosLeft
);
446 isa_writeb(bRight
, dev
.SMA
+ SMA_bInPotPosRight
);
447 if (msnd_send_word(&dev
, 0, 0, HDEXAR_IN_SET_POTS
) == 0)
448 chk_send_dsp_cmd(&dev
, HDEX_AUX_REQ
);
451 case SOUND_MIXER_MIC
: /* mic pot control */
452 /* scaled by IMIX in digital mix */
453 isa_writeb(bLeft
, dev
.SMA
+ SMA_bMicPotPosLeft
);
454 isa_writeb(bRight
, dev
.SMA
+ SMA_bMicPotPosRight
);
455 if (msnd_send_word(&dev
, 0, 0, HDEXAR_MIC_SET_POTS
) == 0)
456 chk_send_dsp_cmd(&dev
, HDEX_AUX_REQ
);
459 case SOUND_MIXER_VOLUME
: /* master volume */
460 isa_writew(wLeft
, dev
.SMA
+ SMA_wCurrMastVolLeft
);
461 isa_writew(wRight
, dev
.SMA
+ SMA_wCurrMastVolRight
);
464 case SOUND_MIXER_LINE1
: /* aux pot control */
465 /* scaled by master volume */
468 /* digital controls */
469 case SOUND_MIXER_SYNTH
: /* synth vol (dsp mix) */
470 case SOUND_MIXER_PCM
: /* pcm vol (dsp mix) */
471 case SOUND_MIXER_IMIX
: /* input monitor (dsp mix) */
472 /* scaled by master volume */
481 /* update master volume scaled controls */
482 update_volm(SOUND_MIXER_PCM
, wCurrPlayVol
);
483 update_volm(SOUND_MIXER_IMIX
, wCurrInVol
);
485 update_volm(SOUND_MIXER_SYNTH
, wCurrMHdrVol
);
487 update_potm(SOUND_MIXER_LINE1
, bAuxPotPos
, HDEXAR_AUX_SET_POTS
);
493 static void mixer_setup(void)
495 update_pot(SOUND_MIXER_LINE
, bInPotPos
, HDEXAR_IN_SET_POTS
);
496 update_potm(SOUND_MIXER_LINE1
, bAuxPotPos
, HDEXAR_AUX_SET_POTS
);
497 update_volm(SOUND_MIXER_PCM
, wCurrPlayVol
);
498 update_volm(SOUND_MIXER_IMIX
, wCurrInVol
);
500 update_pot(SOUND_MIXER_MIC
, bMicPotPos
, HDEXAR_MIC_SET_POTS
);
501 update_volm(SOUND_MIXER_SYNTH
, wCurrMHdrVol
);
505 static unsigned long set_recsrc(unsigned long recsrc
)
507 if (dev
.recsrc
== recsrc
)
510 else if (recsrc
== 0)
514 dev
.recsrc
^= recsrc
;
517 if (dev
.recsrc
& SOUND_MASK_IMIX
) {
518 if (msnd_send_word(&dev
, 0, 0, HDEXAR_SET_ANA_IN
) == 0)
519 chk_send_dsp_cmd(&dev
, HDEX_AUX_REQ
);
521 else if (dev
.recsrc
& SOUND_MASK_SYNTH
) {
522 if (msnd_send_word(&dev
, 0, 0, HDEXAR_SET_SYNTH_IN
) == 0)
523 chk_send_dsp_cmd(&dev
, HDEX_AUX_REQ
);
525 else if ((dev
.recsrc
& SOUND_MASK_DIGITAL1
) && test_bit(F_HAVEDIGITAL
, &dev
.flags
)) {
526 if (msnd_send_word(&dev
, 0, 0, HDEXAR_SET_DAT_IN
) == 0)
527 chk_send_dsp_cmd(&dev
, HDEX_AUX_REQ
);
531 /* Select no input (?) */
534 dev
.recsrc
= SOUND_MASK_IMIX
;
535 if (msnd_send_word(&dev
, 0, 0, HDEXAR_SET_ANA_IN
) == 0)
536 chk_send_dsp_cmd(&dev
, HDEX_AUX_REQ
);
539 #endif /* MSND_CLASSIC */
544 static unsigned long force_recsrc(unsigned long recsrc
)
547 return set_recsrc(recsrc
);
550 #define set_mixer_info() \
551 strncpy(info.id, "MSNDMIXER", sizeof(info.id)); \
552 strncpy(info.name, "MultiSound Mixer", sizeof(info.name));
554 static int mixer_ioctl(unsigned int cmd
, unsigned long arg
)
556 if (cmd
== SOUND_MIXER_INFO
) {
559 info
.modify_counter
= dev
.mixer_mod_count
;
560 return copy_to_user((void *)arg
, &info
, sizeof(info
));
561 } else if (cmd
== SOUND_OLD_MIXER_INFO
) {
562 _old_mixer_info info
;
564 return copy_to_user((void *)arg
, &info
, sizeof(info
));
565 } else if (cmd
== SOUND_MIXER_PRIVATE1
) {
569 } else if (((cmd
>> 8) & 0xff) == 'M') {
572 if (_SIOC_DIR(cmd
) & _SIOC_WRITE
) {
573 switch (cmd
& 0xff) {
574 case SOUND_MIXER_RECSRC
:
575 if (get_user(val
, (int *)arg
))
577 val
= set_recsrc(val
);
581 if (get_user(val
, (int *)arg
))
583 val
= mixer_set(cmd
& 0xff, val
);
586 ++dev
.mixer_mod_count
;
587 return put_user(val
, (int *)arg
);
589 switch (cmd
& 0xff) {
590 case SOUND_MIXER_RECSRC
:
594 case SOUND_MIXER_DEVMASK
:
595 case SOUND_MIXER_STEREODEVS
:
596 val
= SOUND_MASK_PCM
|
607 case SOUND_MIXER_RECMASK
:
611 val
= SOUND_MASK_IMIX
|
613 if (test_bit(F_HAVEDIGITAL
, &dev
.flags
))
614 val
|= SOUND_MASK_DIGITAL1
;
618 case SOUND_MIXER_CAPS
:
619 val
= SOUND_CAP_EXCL_INPUT
;
623 if ((val
= mixer_get(cmd
& 0xff)) < 0)
629 return put_user(val
, (int *)arg
);
635 static int dev_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
637 int minor
= MINOR(inode
->i_rdev
);
639 if (cmd
== OSS_GETVERSION
) {
640 int sound_version
= SOUND_VERSION
;
641 return put_user(sound_version
, (int *)arg
);
644 if (minor
== dev
.dsp_minor
)
645 return dsp_ioctl(file
, cmd
, arg
);
646 else if (minor
== dev
.mixer_minor
)
647 return mixer_ioctl(cmd
, arg
);
652 static void dsp_write_flush(void)
654 if (!(dev
.mode
& FMODE_WRITE
) || !test_bit(F_WRITING
, &dev
.flags
))
656 set_bit(F_WRITEFLUSH
, &dev
.flags
);
657 interruptible_sleep_on_timeout(
659 get_play_delay_jiffies(dev
.DAPF
.len
));
660 clear_bit(F_WRITEFLUSH
, &dev
.flags
);
661 if (!signal_pending(current
)) {
662 current
->state
= TASK_INTERRUPTIBLE
;
663 schedule_timeout(get_play_delay_jiffies(DAP_BUFF_SIZE
));
665 clear_bit(F_WRITING
, &dev
.flags
);
668 static void dsp_halt(struct file
*file
)
670 if ((file
? file
->f_mode
: dev
.mode
) & FMODE_READ
) {
671 clear_bit(F_READING
, &dev
.flags
);
672 chk_send_dsp_cmd(&dev
, HDEX_RECORD_STOP
);
673 msnd_disable_irq(&dev
);
675 printk(KERN_DEBUG LOGNAME
": Stopping read for %p\n", file
);
676 dev
.mode
&= ~FMODE_READ
;
678 clear_bit(F_AUDIO_READ_INUSE
, &dev
.flags
);
680 if ((file
? file
->f_mode
: dev
.mode
) & FMODE_WRITE
) {
681 if (test_bit(F_WRITING
, &dev
.flags
)) {
683 chk_send_dsp_cmd(&dev
, HDEX_PLAY_STOP
);
685 msnd_disable_irq(&dev
);
687 printk(KERN_DEBUG LOGNAME
": Stopping write for %p\n", file
);
688 dev
.mode
&= ~FMODE_WRITE
;
690 clear_bit(F_AUDIO_WRITE_INUSE
, &dev
.flags
);
694 static int dsp_release(struct file
*file
)
700 static int dsp_open(struct file
*file
)
702 if ((file
? file
->f_mode
: dev
.mode
) & FMODE_WRITE
) {
703 set_bit(F_AUDIO_WRITE_INUSE
, &dev
.flags
);
704 clear_bit(F_WRITING
, &dev
.flags
);
705 msnd_fifo_make_empty(&dev
.DAPF
);
708 printk(KERN_DEBUG LOGNAME
": Starting write for %p\n", file
);
709 dev
.mode
|= FMODE_WRITE
;
711 msnd_enable_irq(&dev
);
713 if ((file
? file
->f_mode
: dev
.mode
) & FMODE_READ
) {
714 set_bit(F_AUDIO_READ_INUSE
, &dev
.flags
);
715 clear_bit(F_READING
, &dev
.flags
);
716 msnd_fifo_make_empty(&dev
.DARF
);
717 reset_record_queue();
719 printk(KERN_DEBUG LOGNAME
": Starting read for %p\n", file
);
720 dev
.mode
|= FMODE_READ
;
722 msnd_enable_irq(&dev
);
727 static void set_default_play_audio_parameters(void)
729 dev
.play_sample_size
= DEFSAMPLESIZE
;
730 dev
.play_sample_rate
= DEFSAMPLERATE
;
731 dev
.play_channels
= DEFCHANNELS
;
734 static void set_default_rec_audio_parameters(void)
736 dev
.rec_sample_size
= DEFSAMPLESIZE
;
737 dev
.rec_sample_rate
= DEFSAMPLERATE
;
738 dev
.rec_channels
= DEFCHANNELS
;
741 static void set_default_audio_parameters(void)
743 set_default_play_audio_parameters();
744 set_default_rec_audio_parameters();
747 static int dev_open(struct inode
*inode
, struct file
*file
)
749 int minor
= MINOR(inode
->i_rdev
);
752 if (minor
== dev
.dsp_minor
) {
753 if ((file
->f_mode
& FMODE_WRITE
&&
754 test_bit(F_AUDIO_WRITE_INUSE
, &dev
.flags
)) ||
755 (file
->f_mode
& FMODE_READ
&&
756 test_bit(F_AUDIO_READ_INUSE
, &dev
.flags
)))
759 if ((err
= dsp_open(file
)) >= 0) {
761 if (file
->f_mode
& FMODE_WRITE
) {
762 set_default_play_audio_parameters();
763 if (!test_bit(F_DISABLE_WRITE_NDELAY
, &dev
.flags
))
764 dev
.play_ndelay
= (file
->f_flags
& O_NDELAY
) ? 1 : 0;
768 if (file
->f_mode
& FMODE_READ
) {
769 set_default_rec_audio_parameters();
770 dev
.rec_ndelay
= (file
->f_flags
& O_NDELAY
) ? 1 : 0;
774 else if (minor
== dev
.mixer_minor
) {
782 static int dev_release(struct inode
*inode
, struct file
*file
)
784 int minor
= MINOR(inode
->i_rdev
);
788 if (minor
== dev
.dsp_minor
)
789 err
= dsp_release(file
);
790 else if (minor
== dev
.mixer_minor
) {
798 static __inline__
int pack_DARQ_to_DARF(register int bank
)
800 register int size
, n
, timeout
= 3;
804 /* Increment the tail and check for queue wrap */
805 wTmp
= isa_readw(dev
.DARQ
+ JQS_wTail
) + PCTODSP_OFFSET(DAQDS__size
);
806 if (wTmp
> isa_readw(dev
.DARQ
+ JQS_wSize
))
808 while (wTmp
== isa_readw(dev
.DARQ
+ JQS_wHead
) && timeout
--)
810 isa_writew(wTmp
, dev
.DARQ
+ JQS_wTail
);
812 /* Get our digital audio queue struct */
813 DAQD
= bank
* DAQDS__size
+ dev
.base
+ DARQ_DATA_BUFF
;
815 /* Get length of data */
816 size
= isa_readw(DAQD
+ DAQDS_wSize
);
818 /* Read data from the head (unprotected bank 1 access okay
819 since this is only called inside an interrupt) */
820 outb(HPBLKSEL_1
, dev
.io
+ HP_BLKS
);
821 if ((n
= msnd_fifo_write(
823 (char *)(dev
.base
+ bank
* DAR_BUFF_SIZE
),
825 outb(HPBLKSEL_0
, dev
.io
+ HP_BLKS
);
828 outb(HPBLKSEL_0
, dev
.io
+ HP_BLKS
);
833 static __inline__
int pack_DAPF_to_DAPQ(register int start
)
835 register WORD DAPQ_tail
;
836 register int protect
= start
, nbanks
= 0;
839 DAPQ_tail
= isa_readw(dev
.DAPQ
+ JQS_wTail
);
840 while (DAPQ_tail
!= isa_readw(dev
.DAPQ
+ JQS_wHead
) || start
) {
841 register int bank_num
= DAPQ_tail
/ PCTODSP_OFFSET(DAQDS__size
);
845 /* Write the data to the new tail */
847 /* Critical section: protect fifo in non-interrupt */
848 spin_lock_irqsave(&dev
.lock
, flags
);
849 if ((n
= msnd_fifo_read(
851 (char *)(dev
.base
+ bank_num
* DAP_BUFF_SIZE
),
852 DAP_BUFF_SIZE
, 0)) < 0) {
853 spin_unlock_irqrestore(&dev
.lock
, flags
);
856 spin_unlock_irqrestore(&dev
.lock
, flags
);
858 if ((n
= msnd_fifo_read(
860 (char *)(dev
.base
+ bank_num
* DAP_BUFF_SIZE
),
861 DAP_BUFF_SIZE
, 0)) < 0) {
871 /* Get our digital audio queue struct */
872 DAQD
= bank_num
* DAQDS__size
+ dev
.base
+ DAPQ_DATA_BUFF
;
874 /* Write size of this bank */
875 isa_writew(n
, DAQD
+ DAQDS_wSize
);
878 /* Then advance the tail */
879 DAPQ_tail
= (++bank_num
% 3) * PCTODSP_OFFSET(DAQDS__size
);
880 isa_writew(DAPQ_tail
, dev
.DAPQ
+ JQS_wTail
);
881 /* Tell the DSP to play the bank */
882 msnd_send_dsp_cmd(&dev
, HDEX_PLAY_START
);
887 static int dsp_read(char *buf
, size_t len
)
895 /* Critical section: protect fifo in non-interrupt */
896 spin_lock_irqsave(&dev
.lock
, flags
);
897 if ((n
= msnd_fifo_read(&dev
.DARF
, buf
, count
, 1)) < 0) {
898 printk(KERN_WARNING LOGNAME
": FIFO read error\n");
899 spin_unlock_irqrestore(&dev
.lock
, flags
);
902 spin_unlock_irqrestore(&dev
.lock
, flags
);
906 if (!test_bit(F_READING
, &dev
.flags
) && dev
.mode
& FMODE_READ
) {
907 dev
.last_recbank
= -1;
908 if (chk_send_dsp_cmd(&dev
, HDEX_RECORD_START
) == 0)
909 set_bit(F_READING
, &dev
.flags
);
913 return count
== len
? -EAGAIN
: len
- count
;
916 set_bit(F_READBLOCK
, &dev
.flags
);
917 if (!interruptible_sleep_on_timeout(
919 get_rec_delay_jiffies(DAR_BUFF_SIZE
)))
920 clear_bit(F_READING
, &dev
.flags
);
921 clear_bit(F_READBLOCK
, &dev
.flags
);
922 if (signal_pending(current
))
930 static int dsp_write(const char *buf
, size_t len
)
938 /* Critical section: protect fifo in non-interrupt */
939 spin_lock_irqsave(&dev
.lock
, flags
);
940 if ((n
= msnd_fifo_write(&dev
.DAPF
, buf
, count
, 1)) < 0) {
941 printk(KERN_WARNING LOGNAME
": FIFO write error\n");
942 spin_unlock_irqrestore(&dev
.lock
, flags
);
945 spin_unlock_irqrestore(&dev
.lock
, flags
);
949 if (!test_bit(F_WRITING
, &dev
.flags
) && (dev
.mode
& FMODE_WRITE
)) {
950 dev
.last_playbank
= -1;
951 if (pack_DAPF_to_DAPQ(1) > 0)
952 set_bit(F_WRITING
, &dev
.flags
);
956 return count
== len
? -EAGAIN
: len
- count
;
959 set_bit(F_WRITEBLOCK
, &dev
.flags
);
960 interruptible_sleep_on_timeout(
962 get_play_delay_jiffies(DAP_BUFF_SIZE
));
963 clear_bit(F_WRITEBLOCK
, &dev
.flags
);
964 if (signal_pending(current
))
972 static ssize_t
dev_read(struct file
*file
, char *buf
, size_t count
, loff_t
*off
)
974 int minor
= MINOR(file
->f_dentry
->d_inode
->i_rdev
);
975 if (minor
== dev
.dsp_minor
)
976 return dsp_read(buf
, count
);
981 static ssize_t
dev_write(struct file
*file
, const char *buf
, size_t count
, loff_t
*off
)
983 int minor
= MINOR(file
->f_dentry
->d_inode
->i_rdev
);
984 if (minor
== dev
.dsp_minor
)
985 return dsp_write(buf
, count
);
990 static __inline__
void eval_dsp_msg(register WORD wMessage
)
992 switch (HIBYTE(wMessage
)) {
994 if (dev
.last_playbank
== LOBYTE(wMessage
) || !test_bit(F_WRITING
, &dev
.flags
))
996 dev
.last_playbank
= LOBYTE(wMessage
);
998 if (pack_DAPF_to_DAPQ(0) <= 0) {
999 if (!test_bit(F_WRITEBLOCK
, &dev
.flags
)) {
1000 if (test_and_clear_bit(F_WRITEFLUSH
, &dev
.flags
))
1001 wake_up_interruptible(&dev
.writeflush
);
1003 clear_bit(F_WRITING
, &dev
.flags
);
1006 if (test_bit(F_WRITEBLOCK
, &dev
.flags
))
1007 wake_up_interruptible(&dev
.writeblock
);
1010 case HIMT_RECORD_DONE
:
1011 if (dev
.last_recbank
== LOBYTE(wMessage
))
1013 dev
.last_recbank
= LOBYTE(wMessage
);
1015 pack_DARQ_to_DARF(dev
.last_recbank
);
1017 if (test_bit(F_READBLOCK
, &dev
.flags
))
1018 wake_up_interruptible(&dev
.readblock
);
1022 switch (LOBYTE(wMessage
)) {
1023 #ifndef MSND_CLASSIC
1024 case HIDSP_PLAY_UNDER
:
1026 case HIDSP_INT_PLAY_UNDER
:
1027 /* printk(KERN_DEBUG LOGNAME ": Play underflow\n"); */
1028 clear_bit(F_WRITING
, &dev
.flags
);
1031 case HIDSP_INT_RECORD_OVER
:
1032 /* printk(KERN_DEBUG LOGNAME ": Record overflow\n"); */
1033 clear_bit(F_READING
, &dev
.flags
);
1037 /* printk(KERN_DEBUG LOGNAME ": DSP message %d 0x%02x\n",
1038 LOBYTE(wMessage), LOBYTE(wMessage)); */
1043 case HIMT_MIDI_IN_UCHAR
:
1044 if (dev
.midi_in_interrupt
)
1045 (*dev
.midi_in_interrupt
)(&dev
);
1049 /* printk(KERN_DEBUG LOGNAME ": HIMT message %d 0x%02x\n", HIBYTE(wMessage), HIBYTE(wMessage)); */
1054 static void intr(int irq
, void *dev_id
, struct pt_regs
*regs
)
1056 /* Send ack to DSP */
1057 inb(dev
.io
+ HP_RXL
);
1059 /* Evaluate queued DSP messages */
1060 while (isa_readw(dev
.DSPQ
+ JQS_wTail
) != isa_readw(dev
.DSPQ
+ JQS_wHead
)) {
1063 eval_dsp_msg(isa_readw(dev
.pwDSPQData
+ 2*isa_readw(dev
.DSPQ
+ JQS_wHead
)));
1065 if ((wTmp
= isa_readw(dev
.DSPQ
+ JQS_wHead
) + 1) > isa_readw(dev
.DSPQ
+ JQS_wSize
))
1066 isa_writew(0, dev
.DSPQ
+ JQS_wHead
);
1068 isa_writew(wTmp
, dev
.DSPQ
+ JQS_wHead
);
1072 static struct file_operations dev_fileops
= {
1078 release
: dev_release
,
1081 static int reset_dsp(void)
1085 outb(HPDSPRESET_ON
, dev
.io
+ HP_DSPR
);
1087 #ifndef MSND_CLASSIC
1088 dev
.info
= inb(dev
.io
+ HP_INFO
);
1090 outb(HPDSPRESET_OFF
, dev
.io
+ HP_DSPR
);
1092 while (timeout
-- > 0) {
1093 if (inb(dev
.io
+ HP_CVR
) == HP_CVR_DEF
)
1097 printk(KERN_ERR LOGNAME
": Cannot reset DSP\n");
1102 static int __init
probe_multisound(void)
1104 #ifndef MSND_CLASSIC
1105 char *xv
, *rev
= NULL
;
1106 char *pin
= "Pinnacle", *fiji
= "Fiji";
1107 char *pinfiji
= "Pinnacle/Fiji";
1110 if (check_region(dev
.io
, dev
.numio
)) {
1111 printk(KERN_ERR LOGNAME
": I/O port conflict\n");
1114 request_region(dev
.io
, dev
.numio
, "probing");
1116 if (reset_dsp() < 0) {
1117 release_region(dev
.io
, dev
.numio
);
1122 dev
.name
= "Classic/Tahiti/Monterey";
1123 printk(KERN_INFO LOGNAME
": %s, "
1125 switch (dev
.info
>> 4) {
1126 case 0xf: xv
= "<= 1.15"; break;
1127 case 0x1: xv
= "1.18/1.2"; break;
1128 case 0x2: xv
= "1.3"; break;
1129 case 0x3: xv
= "1.4"; break;
1130 default: xv
= "unknown"; break;
1133 switch (dev
.info
& 0x7) {
1134 case 0x0: rev
= "I"; dev
.name
= pin
; break;
1135 case 0x1: rev
= "F"; dev
.name
= pin
; break;
1136 case 0x2: rev
= "G"; dev
.name
= pin
; break;
1137 case 0x3: rev
= "H"; dev
.name
= pin
; break;
1138 case 0x4: rev
= "E"; dev
.name
= fiji
; break;
1139 case 0x5: rev
= "C"; dev
.name
= fiji
; break;
1140 case 0x6: rev
= "D"; dev
.name
= fiji
; break;
1142 rev
= "A-B (Fiji) or A-E (Pinnacle)";
1146 printk(KERN_INFO LOGNAME
": %s revision %s, Xilinx version %s, "
1147 #endif /* MSND_CLASSIC */
1148 "I/O 0x%x-0x%x, IRQ %d, memory mapped to 0x%lX-0x%lX\n",
1150 #ifndef MSND_CLASSIC
1153 dev
.io
, dev
.io
+ dev
.numio
- 1,
1155 dev
.base
, dev
.base
+ 0x7fff);
1157 release_region(dev
.io
, dev
.numio
);
1161 static int init_sma(void)
1164 WORD mastVolLeft
, mastVolRight
;
1165 unsigned long flags
;
1168 outb(dev
.memid
, dev
.io
+ HP_MEMM
);
1170 outb(HPBLKSEL_0
, dev
.io
+ HP_BLKS
);
1172 mastVolLeft
= isa_readw(dev
.SMA
+ SMA_wCurrMastVolLeft
);
1173 mastVolRight
= isa_readw(dev
.SMA
+ SMA_wCurrMastVolRight
);
1175 mastVolLeft
= mastVolRight
= 0;
1176 isa_memset_io(dev
.base
, 0, 0x8000);
1178 /* Critical section: bank 1 access */
1179 spin_lock_irqsave(&dev
.lock
, flags
);
1180 outb(HPBLKSEL_1
, dev
.io
+ HP_BLKS
);
1181 isa_memset_io(dev
.base
, 0, 0x8000);
1182 outb(HPBLKSEL_0
, dev
.io
+ HP_BLKS
);
1183 spin_unlock_irqrestore(&dev
.lock
, flags
);
1185 dev
.pwDSPQData
= (dev
.base
+ DSPQ_DATA_BUFF
);
1186 dev
.pwMODQData
= (dev
.base
+ MODQ_DATA_BUFF
);
1187 dev
.pwMIDQData
= (dev
.base
+ MIDQ_DATA_BUFF
);
1189 /* Motorola 56k shared memory base */
1190 dev
.SMA
= dev
.base
+ SMA_STRUCT_START
;
1192 /* Digital audio play queue */
1193 dev
.DAPQ
= dev
.base
+ DAPQ_OFFSET
;
1194 msnd_init_queue(dev
.DAPQ
, DAPQ_DATA_BUFF
, DAPQ_BUFF_SIZE
);
1196 /* Digital audio record queue */
1197 dev
.DARQ
= dev
.base
+ DARQ_OFFSET
;
1198 msnd_init_queue(dev
.DARQ
, DARQ_DATA_BUFF
, DARQ_BUFF_SIZE
);
1200 /* MIDI out queue */
1201 dev
.MODQ
= dev
.base
+ MODQ_OFFSET
;
1202 msnd_init_queue(dev
.MODQ
, MODQ_DATA_BUFF
, MODQ_BUFF_SIZE
);
1205 dev
.MIDQ
= dev
.base
+ MIDQ_OFFSET
;
1206 msnd_init_queue(dev
.MIDQ
, MIDQ_DATA_BUFF
, MIDQ_BUFF_SIZE
);
1208 /* DSP -> host message queue */
1209 dev
.DSPQ
= dev
.base
+ DSPQ_OFFSET
;
1210 msnd_init_queue(dev
.DSPQ
, DSPQ_DATA_BUFF
, DSPQ_BUFF_SIZE
);
1212 /* Setup some DSP values */
1213 #ifndef MSND_CLASSIC
1214 isa_writew(1, dev
.SMA
+ SMA_wCurrPlayFormat
);
1215 isa_writew(dev
.play_sample_size
, dev
.SMA
+ SMA_wCurrPlaySampleSize
);
1216 isa_writew(dev
.play_channels
, dev
.SMA
+ SMA_wCurrPlayChannels
);
1217 isa_writew(dev
.play_sample_rate
, dev
.SMA
+ SMA_wCurrPlaySampleRate
);
1219 isa_writew(dev
.play_sample_rate
, dev
.SMA
+ SMA_wCalFreqAtoD
);
1220 isa_writew(mastVolLeft
, dev
.SMA
+ SMA_wCurrMastVolLeft
);
1221 isa_writew(mastVolRight
, dev
.SMA
+ SMA_wCurrMastVolRight
);
1222 #ifndef MSND_CLASSIC
1223 isa_writel(0x00010000, dev
.SMA
+ SMA_dwCurrPlayPitch
);
1224 isa_writel(0x00000001, dev
.SMA
+ SMA_dwCurrPlayRate
);
1226 isa_writew(0x303, dev
.SMA
+ SMA_wCurrInputTagBits
);
1233 static int __init
calibrate_adc(WORD srate
)
1235 isa_writew(srate
, dev
.SMA
+ SMA_wCalFreqAtoD
);
1236 if (dev
.calibrate_signal
== 0)
1237 isa_writew(isa_readw(dev
.SMA
+ SMA_wCurrHostStatusFlags
)
1238 | 0x0001, dev
.SMA
+ SMA_wCurrHostStatusFlags
);
1240 isa_writew(isa_readw(dev
.SMA
+ SMA_wCurrHostStatusFlags
)
1241 & ~0x0001, dev
.SMA
+ SMA_wCurrHostStatusFlags
);
1242 if (msnd_send_word(&dev
, 0, 0, HDEXAR_CAL_A_TO_D
) == 0 &&
1243 chk_send_dsp_cmd(&dev
, HDEX_AUX_REQ
) == 0) {
1244 current
->state
= TASK_INTERRUPTIBLE
;
1245 schedule_timeout(HZ
/ 3);
1248 printk(KERN_WARNING LOGNAME
": ADC calibration failed\n");
1253 static int upload_dsp_code(void)
1255 outb(HPBLKSEL_0
, dev
.io
+ HP_BLKS
);
1256 #ifndef HAVE_DSPCODEH
1257 INITCODESIZE
= mod_firmware_load(INITCODEFILE
, &INITCODE
);
1259 printk(KERN_ERR LOGNAME
": Error loading " INITCODEFILE
);
1263 PERMCODESIZE
= mod_firmware_load(PERMCODEFILE
, &PERMCODE
);
1265 printk(KERN_ERR LOGNAME
": Error loading " PERMCODEFILE
);
1270 isa_memcpy_toio(dev
.base
, PERMCODE
, PERMCODESIZE
);
1271 if (msnd_upload_host(&dev
, INITCODE
, INITCODESIZE
) < 0) {
1272 printk(KERN_WARNING LOGNAME
": Error uploading to DSP\n");
1275 #ifdef HAVE_DSPCODEH
1276 printk(KERN_INFO LOGNAME
": DSP firmware uploaded (resident)\n");
1278 printk(KERN_INFO LOGNAME
": DSP firmware uploaded\n");
1281 #ifndef HAVE_DSPCODEH
1290 static void reset_proteus(void)
1292 outb(HPPRORESET_ON
, dev
.io
+ HP_PROR
);
1293 mdelay(TIME_PRO_RESET
);
1294 outb(HPPRORESET_OFF
, dev
.io
+ HP_PROR
);
1295 mdelay(TIME_PRO_RESET_DONE
);
1299 static int initialize(void)
1304 outb(HPWAITSTATE_0
, dev
.io
+ HP_WAIT
);
1305 outb(HPBITMODE_16
, dev
.io
+ HP_BITM
);
1309 if ((err
= init_sma()) < 0) {
1310 printk(KERN_WARNING LOGNAME
": Cannot initialize SMA\n");
1314 if ((err
= reset_dsp()) < 0)
1317 if ((err
= upload_dsp_code()) < 0) {
1318 printk(KERN_WARNING LOGNAME
": Cannot upload DSP code\n");
1323 while (isa_readw(dev
.base
)) {
1326 printk(KERN_DEBUG LOGNAME
": DSP reset timeout\n");
1336 static int dsp_full_reset(void)
1340 if (test_bit(F_RESETTING
, &dev
.flags
) || ++dev
.nresets
> 10)
1343 set_bit(F_RESETTING
, &dev
.flags
);
1344 printk(KERN_INFO LOGNAME
": DSP reset\n");
1345 dsp_halt(NULL
); /* Unconditionally halt */
1346 if ((rv
= initialize()))
1347 printk(KERN_WARNING LOGNAME
": DSP reset failed\n");
1348 force_recsrc(dev
.recsrc
);
1350 clear_bit(F_RESETTING
, &dev
.flags
);
1355 static int __init
attach_multisound(void)
1359 if ((err
= request_irq(dev
.irq
, intr
, 0, dev
.name
, &dev
)) < 0) {
1360 printk(KERN_ERR LOGNAME
": Couldn't grab IRQ %d\n", dev
.irq
);
1363 request_region(dev
.io
, dev
.numio
, dev
.name
);
1365 if ((err
= dsp_full_reset()) < 0) {
1366 release_region(dev
.io
, dev
.numio
);
1367 free_irq(dev
.irq
, &dev
);
1371 if ((err
= msnd_register(&dev
)) < 0) {
1372 printk(KERN_ERR LOGNAME
": Unable to register MultiSound\n");
1373 release_region(dev
.io
, dev
.numio
);
1374 free_irq(dev
.irq
, &dev
);
1378 if ((dev
.dsp_minor
= register_sound_dsp(&dev_fileops
, -1)) < 0) {
1379 printk(KERN_ERR LOGNAME
": Unable to register DSP operations\n");
1380 msnd_unregister(&dev
);
1381 release_region(dev
.io
, dev
.numio
);
1382 free_irq(dev
.irq
, &dev
);
1383 return dev
.dsp_minor
;
1386 if ((dev
.mixer_minor
= register_sound_mixer(&dev_fileops
, -1)) < 0) {
1387 printk(KERN_ERR LOGNAME
": Unable to register mixer operations\n");
1388 unregister_sound_mixer(dev
.mixer_minor
);
1389 msnd_unregister(&dev
);
1390 release_region(dev
.io
, dev
.numio
);
1391 free_irq(dev
.irq
, &dev
);
1392 return dev
.mixer_minor
;
1395 dev
.ext_midi_dev
= dev
.hdr_midi_dev
= -1;
1397 disable_irq(dev
.irq
);
1398 calibrate_adc(dev
.play_sample_rate
);
1399 #ifndef MSND_CLASSIC
1400 force_recsrc(SOUND_MASK_IMIX
);
1407 static void unload_multisound(void)
1409 release_region(dev
.io
, dev
.numio
);
1410 free_irq(dev
.irq
, &dev
);
1411 unregister_sound_mixer(dev
.mixer_minor
);
1412 unregister_sound_dsp(dev
.dsp_minor
);
1413 msnd_unregister(&dev
);
1417 #ifndef MSND_CLASSIC
1419 /* Pinnacle/Fiji Logical Device Configuration */
1421 static int __init
msnd_write_cfg(int cfg
, int reg
, int value
)
1424 outb(value
, cfg
+ 1);
1425 if (value
!= inb(cfg
+ 1)) {
1426 printk(KERN_ERR LOGNAME
": msnd_write_cfg: I/O error\n");
1432 static int __init
msnd_write_cfg_io0(int cfg
, int num
, WORD io
)
1434 if (msnd_write_cfg(cfg
, IREG_LOGDEVICE
, num
))
1436 if (msnd_write_cfg(cfg
, IREG_IO0_BASEHI
, HIBYTE(io
)))
1438 if (msnd_write_cfg(cfg
, IREG_IO0_BASELO
, LOBYTE(io
)))
1443 static int __init
msnd_write_cfg_io1(int cfg
, int num
, WORD io
)
1445 if (msnd_write_cfg(cfg
, IREG_LOGDEVICE
, num
))
1447 if (msnd_write_cfg(cfg
, IREG_IO1_BASEHI
, HIBYTE(io
)))
1449 if (msnd_write_cfg(cfg
, IREG_IO1_BASELO
, LOBYTE(io
)))
1454 static int __init
msnd_write_cfg_irq(int cfg
, int num
, WORD irq
)
1456 if (msnd_write_cfg(cfg
, IREG_LOGDEVICE
, num
))
1458 if (msnd_write_cfg(cfg
, IREG_IRQ_NUMBER
, LOBYTE(irq
)))
1460 if (msnd_write_cfg(cfg
, IREG_IRQ_TYPE
, IRQTYPE_EDGE
))
1465 static int __init
msnd_write_cfg_mem(int cfg
, int num
, int mem
)
1472 if (msnd_write_cfg(cfg
, IREG_LOGDEVICE
, num
))
1474 if (msnd_write_cfg(cfg
, IREG_MEMBASEHI
, HIBYTE(wmem
)))
1476 if (msnd_write_cfg(cfg
, IREG_MEMBASELO
, LOBYTE(wmem
)))
1478 if (wmem
&& msnd_write_cfg(cfg
, IREG_MEMCONTROL
, (MEMTYPE_HIADDR
| MEMTYPE_16BIT
)))
1483 static int __init
msnd_activate_logical(int cfg
, int num
)
1485 if (msnd_write_cfg(cfg
, IREG_LOGDEVICE
, num
))
1487 if (msnd_write_cfg(cfg
, IREG_ACTIVATE
, LD_ACTIVATE
))
1492 static int __init
msnd_write_cfg_logical(int cfg
, int num
, WORD io0
, WORD io1
, WORD irq
, int mem
)
1494 if (msnd_write_cfg(cfg
, IREG_LOGDEVICE
, num
))
1496 if (msnd_write_cfg_io0(cfg
, num
, io0
))
1498 if (msnd_write_cfg_io1(cfg
, num
, io1
))
1500 if (msnd_write_cfg_irq(cfg
, num
, irq
))
1502 if (msnd_write_cfg_mem(cfg
, num
, mem
))
1504 if (msnd_activate_logical(cfg
, num
))
1509 typedef struct msnd_pinnacle_cfg_device
{
1512 } msnd_pinnacle_cfg_t
[4];
1514 static int __init
msnd_pinnacle_cfg_devices(int cfg
, int reset
, msnd_pinnacle_cfg_t device
)
1518 /* Reset devices if told to */
1520 printk(KERN_INFO LOGNAME
": Resetting all devices\n");
1521 for (i
= 0; i
< 4; ++i
)
1522 if (msnd_write_cfg_logical(cfg
, i
, 0, 0, 0, 0))
1526 /* Configure specified devices */
1527 for (i
= 0; i
< 4; ++i
) {
1531 if (!(device
[i
].io0
&& device
[i
].irq
&& device
[i
].mem
))
1535 if (!(device
[i
].io0
&& device
[i
].irq
))
1537 printk(KERN_INFO LOGNAME
1538 ": Configuring MPU to I/O 0x%x IRQ %d\n",
1539 device
[i
].io0
, device
[i
].irq
);
1542 if (!(device
[i
].io0
&& device
[i
].io1
&& device
[i
].irq
))
1544 printk(KERN_INFO LOGNAME
1545 ": Configuring IDE to I/O 0x%x, 0x%x IRQ %d\n",
1546 device
[i
].io0
, device
[i
].io1
, device
[i
].irq
);
1548 case 3: /* Joystick */
1549 if (!(device
[i
].io0
))
1551 printk(KERN_INFO LOGNAME
1552 ": Configuring joystick to I/O 0x%x\n",
1557 /* Configure the device */
1558 if (msnd_write_cfg_logical(cfg
, i
, device
[i
].io0
, device
[i
].io1
, device
[i
].irq
, device
[i
].mem
))
1567 MODULE_AUTHOR ("Andrew Veliath <andrewtv@usa.net>");
1568 MODULE_DESCRIPTION ("Turtle Beach " LONGNAME
" Linux Driver");
1569 MODULE_PARM (io
, "i");
1570 MODULE_PARM (irq
, "i");
1571 MODULE_PARM (mem
, "i");
1572 MODULE_PARM (write_ndelay
, "i");
1573 MODULE_PARM (major
, "i");
1574 MODULE_PARM (fifosize
, "i");
1575 MODULE_PARM (calibrate_signal
, "i");
1576 #ifndef MSND_CLASSIC
1577 MODULE_PARM (digital
, "i");
1578 MODULE_PARM (cfg
, "i");
1579 MODULE_PARM (reset
, "i");
1580 MODULE_PARM (mpu_io
, "i");
1581 MODULE_PARM (mpu_irq
, "i");
1582 MODULE_PARM (ide_io0
, "i");
1583 MODULE_PARM (ide_io1
, "i");
1584 MODULE_PARM (ide_irq
, "i");
1585 MODULE_PARM (joystick_io
, "i");
1588 static int io __initdata
= -1;
1589 static int irq __initdata
= -1;
1590 static int mem __initdata
= -1;
1591 static int write_ndelay __initdata
= -1;
1593 #ifndef MSND_CLASSIC
1594 /* Pinnacle/Fiji non-PnP Config Port */
1595 static int cfg __initdata
= -1;
1597 /* Extra Peripheral Configuration */
1598 static int reset __initdata
;
1599 static int mpu_io __initdata
;
1600 static int mpu_irq __initdata
;
1601 static int ide_io0 __initdata
;
1602 static int ide_io1 __initdata
;
1603 static int ide_irq __initdata
;
1604 static int joystick_io __initdata
;
1606 /* If we have the digital daugherboard... */
1607 static int digital __initdata
;
1610 static int fifosize __initdata
= DEFFIFOSIZE
;
1611 static int calibrate_signal __initdata
;
1613 /* If we're a module, this is just init_module */
1615 int init_module(void)
1617 #else /* not a module */
1619 static int write_ndelay __initdata
= -1;
1622 static int io __initdata
= CONFIG_MSNDCLAS_IO
;
1623 static int irq __initdata
= CONFIG_MSNDCLAS_IRQ
;
1624 static int mem __initdata
= CONFIG_MSNDCLAS_MEM
;
1625 #else /* Pinnacle/Fiji */
1627 static int io __initdata
= CONFIG_MSNDPIN_IO
;
1628 static int irq __initdata
= CONFIG_MSNDPIN_IRQ
;
1629 static int mem __initdata
= CONFIG_MSNDPIN_MEM
;
1631 /* Pinnacle/Fiji non-PnP Config Port */
1632 #ifdef CONFIG_MSNDPIN_NONPNP
1633 # ifndef CONFIG_MSNDPIN_CFG
1634 # define CONFIG_MSNDPIN_CFG 0x250
1637 # ifdef CONFIG_MSNDPIN_CFG
1638 # undef CONFIG_MSNDPIN_CFG
1640 # define CONFIG_MSNDPIN_CFG -1
1642 static int cfg __initdata
= CONFIG_MSNDPIN_CFG
;
1643 /* If not a module, we don't need to bother with reset=1 */
1646 /* Extra Peripheral Configuration (Default: Disable) */
1647 #ifndef CONFIG_MSNDPIN_MPU_IO
1648 # define CONFIG_MSNDPIN_MPU_IO 0
1650 static int mpu_io __initdata
= CONFIG_MSNDPIN_MPU_IO
;
1652 #ifndef CONFIG_MSNDPIN_MPU_IRQ
1653 # define CONFIG_MSNDPIN_MPU_IRQ 0
1655 static int mpu_irq __initdata
= CONFIG_MSNDPIN_MPU_IRQ
;
1657 #ifndef CONFIG_MSNDPIN_IDE_IO0
1658 # define CONFIG_MSNDPIN_IDE_IO0 0
1660 static int ide_io0 __initdata
= CONFIG_MSNDPIN_IDE_IO0
;
1662 #ifndef CONFIG_MSNDPIN_IDE_IO1
1663 # define CONFIG_MSNDPIN_IDE_IO1 0
1665 static int ide_io1 __initdata
= CONFIG_MSNDPIN_IDE_IO1
;
1667 #ifndef CONFIG_MSNDPIN_IDE_IRQ
1668 # define CONFIG_MSNDPIN_IDE_IRQ 0
1670 static int ide_irq __initdata
= CONFIG_MSNDPIN_IDE_IRQ
;
1672 #ifndef CONFIG_MSNDPIN_JOYSTICK_IO
1673 # define CONFIG_MSNDPIN_JOYSTICK_IO 0
1675 static int joystick_io __initdata
= CONFIG_MSNDPIN_JOYSTICK_IO
;
1677 /* Have SPDIF (Digital) Daughterboard */
1678 #ifndef CONFIG_MSNDPIN_DIGITAL
1679 # define CONFIG_MSNDPIN_DIGITAL 0
1681 static int digital __initdata
= CONFIG_MSNDPIN_DIGITAL
;
1683 #endif /* MSND_CLASSIC */
1685 #ifndef CONFIG_MSND_FIFOSIZE
1686 # define CONFIG_MSND_FIFOSIZE DEFFIFOSIZE
1688 static int fifosize __initdata
= CONFIG_MSND_FIFOSIZE
;
1690 #ifndef CONFIG_MSND_CALSIGNAL
1691 # define CONFIG_MSND_CALSIGNAL 0
1694 calibrate_signal __initdata
= CONFIG_MSND_CALSIGNAL
;
1697 int __init
msnd_classic_init(void)
1699 int __init
msnd_pinnacle_init(void)
1700 #endif /* MSND_CLASSIC */
1705 #ifndef MSND_CLASSIC
1706 static msnd_pinnacle_cfg_t pinnacle_devs
;
1707 #endif /* MSND_CLASSIC */
1709 printk(KERN_INFO LOGNAME
": Turtle Beach " LONGNAME
" Linux Driver Version "
1710 VERSION
", Copyright (C) 1998 Andrew Veliath\n");
1712 if (io
== -1 || irq
== -1 || mem
== -1)
1713 printk(KERN_WARNING LOGNAME
": io, irq and mem must be set\n");
1724 printk(KERN_ERR LOGNAME
": \"io\" - DSP I/O base must be set to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, or 0x3E0\n");
1735 printk(KERN_ERR LOGNAME
": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
1746 printk(KERN_ERR LOGNAME
": \"mem\" - must be set to "
1747 "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or 0xe8000\n");
1753 case 5: dev
.irqid
= HPIRQ_5
; break;
1754 case 7: dev
.irqid
= HPIRQ_7
; break;
1755 case 9: dev
.irqid
= HPIRQ_9
; break;
1756 case 10: dev
.irqid
= HPIRQ_10
; break;
1757 case 11: dev
.irqid
= HPIRQ_11
; break;
1758 case 12: dev
.irqid
= HPIRQ_12
; break;
1762 case 0xb0000: dev
.memid
= HPMEM_B000
; break;
1763 case 0xc8000: dev
.memid
= HPMEM_C800
; break;
1764 case 0xd0000: dev
.memid
= HPMEM_D000
; break;
1765 case 0xd8000: dev
.memid
= HPMEM_D800
; break;
1766 case 0xe0000: dev
.memid
= HPMEM_E000
; break;
1767 case 0xe8000: dev
.memid
= HPMEM_E800
; break;
1771 printk(KERN_INFO LOGNAME
": Assuming PnP mode\n");
1772 } else if (cfg
!= 0x250 && cfg
!= 0x260 && cfg
!= 0x270) {
1773 printk(KERN_INFO LOGNAME
": Config port must be 0x250, 0x260 or 0x270 (or unspecified for PnP mode)\n");
1776 printk(KERN_INFO LOGNAME
": Non-PnP mode: configuring at port 0x%x\n", cfg
);
1779 pinnacle_devs
[0].io0
= io
;
1780 pinnacle_devs
[0].irq
= irq
;
1781 pinnacle_devs
[0].mem
= mem
;
1783 /* The following are Pinnacle specific */
1786 pinnacle_devs
[1].io0
= mpu_io
;
1787 pinnacle_devs
[1].irq
= mpu_irq
;
1790 pinnacle_devs
[2].io0
= ide_io0
;
1791 pinnacle_devs
[2].io1
= ide_io1
;
1792 pinnacle_devs
[2].irq
= ide_irq
;
1795 pinnacle_devs
[3].io0
= joystick_io
;
1797 if (check_region(cfg
, 2)) {
1798 printk(KERN_ERR LOGNAME
": Config port 0x%x conflict\n", cfg
);
1802 request_region(cfg
, 2, "Pinnacle/Fiji Config");
1803 if (msnd_pinnacle_cfg_devices(cfg
, reset
, pinnacle_devs
)) {
1804 printk(KERN_ERR LOGNAME
": Device configuration error\n");
1805 release_region(cfg
, 2);
1808 release_region(cfg
, 2);
1810 #endif /* MSND_CLASSIC */
1815 if (fifosize
> 1024)
1818 set_default_audio_parameters();
1820 dev
.type
= msndClassic
;
1822 dev
.type
= msndPinnacle
;
1825 dev
.numio
= DSP_NUMIO
;
1828 dev
.fifosize
= fifosize
* 1024;
1829 dev
.calibrate_signal
= calibrate_signal
? 1 : 0;
1831 dev
.dspq_data_buff
= DSPQ_DATA_BUFF
;
1832 dev
.dspq_buff_size
= DSPQ_BUFF_SIZE
;
1833 if (write_ndelay
== -1)
1834 write_ndelay
= CONFIG_MSND_WRITE_NDELAY
;
1836 clear_bit(F_DISABLE_WRITE_NDELAY
, &dev
.flags
);
1838 set_bit(F_DISABLE_WRITE_NDELAY
, &dev
.flags
);
1839 #ifndef MSND_CLASSIC
1841 set_bit(F_HAVEDIGITAL
, &dev
.flags
);
1843 init_waitqueue_head(&dev
.writeblock
);
1844 init_waitqueue_head(&dev
.readblock
);
1845 init_waitqueue_head(&dev
.writeflush
);
1846 msnd_fifo_init(&dev
.DAPF
);
1847 msnd_fifo_init(&dev
.DARF
);
1848 spin_lock_init(&dev
.lock
);
1849 printk(KERN_INFO LOGNAME
": %u byte audio FIFOs (x2)\n", dev
.fifosize
);
1850 if ((err
= msnd_fifo_alloc(&dev
.DAPF
, dev
.fifosize
)) < 0) {
1851 printk(KERN_ERR LOGNAME
": Couldn't allocate write FIFO\n");
1855 if ((err
= msnd_fifo_alloc(&dev
.DARF
, dev
.fifosize
)) < 0) {
1856 printk(KERN_ERR LOGNAME
": Couldn't allocate read FIFO\n");
1857 msnd_fifo_free(&dev
.DAPF
);
1861 if ((err
= probe_multisound()) < 0) {
1862 printk(KERN_ERR LOGNAME
": Probe failed\n");
1863 msnd_fifo_free(&dev
.DAPF
);
1864 msnd_fifo_free(&dev
.DARF
);
1868 if ((err
= attach_multisound()) < 0) {
1869 printk(KERN_ERR LOGNAME
": Attach failed\n");
1870 msnd_fifo_free(&dev
.DAPF
);
1871 msnd_fifo_free(&dev
.DARF
);
1879 void cleanup_module(void)
1881 unload_multisound();
1882 msnd_fifo_free(&dev
.DAPF
);
1883 msnd_fifo_free(&dev
.DARF
);