projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
sound: push BKL into open functions
[linux-2.6-block.git] / sound / oss / msnd_pinnacle.c
CommitLineData
1da177e4
LT		 1/*********************************************************************
2 *
3 * Turtle Beach MultiSound Sound Card Driver for Linux
4 * Linux 2.0/2.2 Version
5 *
6 * msnd_pinnacle.c / msnd_classic.c
7 *
8 * -- If MSND_CLASSIC is defined:
9 *
10 * -> driver for Turtle Beach Classic/Monterey/Tahiti
11 *
12 * -- Else
13 *
14 * -> driver for Turtle Beach Pinnacle/Fiji
15 *
16 * Copyright (C) 1998 Andrew Veliath
17 *
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.
22 *
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.
27 *
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.
31 *
1da177e4
LT		 32 * 12-3-2000 Modified IO port validation Steve Sycamore
33 *
1da177e4
LT		 34 ********************************************************************/
35
36#include <linux/kernel.h>
1da177e4 37#include <linux/module.h>
1da177e4
LT		 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>
5a0e3ad6 43#include <linux/gfp.h>
1da177e4
LT		 44#include <asm/irq.h>
45#include <asm/io.h>
46#include "sound_config.h"
47#include "sound_firmware.h"
48#ifdef MSND_CLASSIC
49# ifndef __alpha__
50# define SLOWIO
51# endif
52#endif
53#include "msnd.h"
54#ifdef MSND_CLASSIC
55# ifdef CONFIG_MSNDCLAS_HAVE_BOOT
56# define HAVE_DSPCODEH
57# endif
58# include "msnd_classic.h"
59# define LOGNAME "msnd_classic"
60#else
61# ifdef CONFIG_MSNDPIN_HAVE_BOOT
62# define HAVE_DSPCODEH
63# endif
64# include "msnd_pinnacle.h"
65# define LOGNAME "msnd_pinnacle"
66#endif
67
68#ifndef CONFIG_MSND_WRITE_NDELAY
69# define CONFIG_MSND_WRITE_NDELAY 1
70#endif
71
72#define get_play_delay_jiffies(size) ((size) * HZ * \
73 dev.play_sample_size / 8 / \
74 dev.play_sample_rate / \
75 dev.play_channels)
76
77#define get_rec_delay_jiffies(size) ((size) * HZ * \
78 dev.rec_sample_size / 8 / \
79 dev.rec_sample_rate / \
80 dev.rec_channels)
81
82static multisound_dev_t dev;
83
84#ifndef HAVE_DSPCODEH
85static char *dspini, *permini;
86static int sizeof_dspini, sizeof_permini;
87#endif
88
89static int dsp_full_reset(void);
90static void dsp_write_flush(void);
91
92static __inline__ int chk_send_dsp_cmd(multisound_dev_t *dev, register BYTE cmd)
93{
94 if (msnd_send_dsp_cmd(dev, cmd) == 0)
95 return 0;
96 dsp_full_reset();
97 return msnd_send_dsp_cmd(dev, cmd);
98}
99
100static void reset_play_queue(void)
101{
102 int n;
103 LPDAQD lpDAQ;
104
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);
108
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);
118 }
119}
120
121static void reset_record_queue(void)
122{
123 int n;
124 LPDAQD lpDAQ;
125 unsigned long flags;
126
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);
130
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);
137
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);
147 }
148}
149
150static void reset_queues(void)
151{
152 if (dev.mode & FMODE_WRITE) {
153 msnd_fifo_make_empty(&dev.DAPF);
154 reset_play_queue();
155 }
156 if (dev.mode & FMODE_READ) {
157 msnd_fifo_make_empty(&dev.DARF);
158 reset_record_queue();
159 }
160}
161
162static int dsp_set_format(struct file *file, int val)
163{
164 int data, i;
165 LPDAQD lpDAQ, lpDARQ;
166
167 lpDAQ = dev.base + DAPQ_DATA_BUFF;
168 lpDARQ = dev.base + DARQ_DATA_BUFF;
169
170 switch (val) {
171 case AFMT_U8:
172 case AFMT_S16_LE:
173 data = val;
174 break;
175 default:
176 data = DEFSAMPLESIZE;
177 break;
178 }
179
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);
185 }
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;
190
191 return data;
192}
193
194static int dsp_get_frag_size(void)
195{
196 int size;
197 size = dev.fifosize / 4;
198 if (size > 32 * 1024)
199 size = 32 * 1024;
200 return size;
201}
202
203static int dsp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
204{
205 int val, i, data, tmp;
206 LPDAQD lpDAQ, lpDARQ;
207 audio_buf_info abinfo;
208 unsigned long flags;
209 int __user *p = (int __user *)arg;
210
211 lpDAQ = dev.base + DAPQ_DATA_BUFF;
212 lpDARQ = dev.base + DARQ_DATA_BUFF;
213
214 switch (cmd) {
215 case SNDCTL_DSP_SUBDIVIDE:
216 case SNDCTL_DSP_SETFRAGMENT:
217 case SNDCTL_DSP_SETDUPLEX:
218 case SNDCTL_DSP_POST:
219 return 0;
220
221 case SNDCTL_DSP_GETIPTR:
222 case SNDCTL_DSP_GETOPTR:
223 case SNDCTL_DSP_MAPINBUF:
224 case SNDCTL_DSP_MAPOUTBUF:
225 return -EINVAL;
226
227 case SNDCTL_DSP_GETOSPACE:
228 if (!(file->f_mode & FMODE_WRITE))
229 return -EINVAL;
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;
237
238 case SNDCTL_DSP_GETISPACE:
239 if (!(file->f_mode & FMODE_READ))
240 return -EINVAL;
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;
248
249 case SNDCTL_DSP_RESET:
250 dev.nresets = 0;
251 reset_queues();
252 return 0;
253
254 case SNDCTL_DSP_SYNC:
255 dsp_write_flush();
256 return 0;
257
258 case SNDCTL_DSP_GETBLKSIZE:
259 tmp = dsp_get_frag_size();
260 if (put_user(tmp, p))
261 return -EFAULT;
262 return 0;
263
264 case SNDCTL_DSP_GETFMTS:
265 val = AFMT_S16_LE | AFMT_U8;
266 if (put_user(val, p))
267 return -EFAULT;
268 return 0;
269
270 case SNDCTL_DSP_SETFMT:
271 if (get_user(val, p))
272 return -EFAULT;
273
274 if (file->f_mode & FMODE_WRITE)
275 data = val == AFMT_QUERY
276 ? dev.play_sample_size
277 : dsp_set_format(file, val);
278 else
279 data = val == AFMT_QUERY
280 ? dev.rec_sample_size
281 : dsp_set_format(file, val);
282
283 if (put_user(data, p))
284 return -EFAULT;
285 return 0;
286
287 case SNDCTL_DSP_NONBLOCK:
288 if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags) &&
289 file->f_mode & FMODE_WRITE)
290 dev.play_ndelay = 1;
291 if (file->f_mode & FMODE_READ)
292 dev.rec_ndelay = 1;
293 return 0;
294
295 case SNDCTL_DSP_GETCAPS:
296 val = DSP_CAP_DUPLEX | DSP_CAP_BATCH;
297 if (put_user(val, p))
298 return -EFAULT;
299 return 0;
300
301 case SNDCTL_DSP_SPEED:
302 if (get_user(val, p))
303 return -EFAULT;
304
305 if (val < 8000)
306 val = 8000;
307
308 if (val > 48000)
309 val = 48000;
310
311 data = val;
312
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);
318 }
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;
323
324 if (put_user(data, p))
325 return -EFAULT;
326 return 0;
327
328 case SNDCTL_DSP_CHANNELS:
329 case SNDCTL_DSP_STEREO:
330 if (get_user(val, p))
331 return -EFAULT;
332
333 if (cmd == SNDCTL_DSP_CHANNELS) {
334 switch (val) {
335 case 1:
336 case 2:
337 data = val;
338 break;
339 default:
340 val = data = 2;
341 break;
342 }
343 } else {
344 switch (val) {
345 case 0:
346 data = 1;
347 break;
348 default:
349 val = 1;
350 case 1:
351 data = 2;
352 break;
353 }
354 }
355
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);
361 }
362 if (file->f_mode & FMODE_WRITE)
363 dev.play_channels = data;
364 if (file->f_mode & FMODE_READ)
365 dev.rec_channels = data;
366
367 if (put_user(val, p))
368 return -EFAULT;
369 return 0;
370 }
371
372 return -EINVAL;
373}
374
375static int mixer_get(int d)
376{
377 if (d > 31)
378 return -EINVAL;
379
380 switch (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:
386#ifndef MSND_CLASSIC
387 case SOUND_MIXER_MIC:
388 case SOUND_MIXER_SYNTH:
389#endif
390 return (dev.left_levels[d] >> 8) * 100 / 0xff |
391 (((dev.right_levels[d] >> 8) * 100 / 0xff) << 8);
392 default:
393 return 0;
394 }
395}
396
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);
404
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);
414
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);
422
423static int mixer_set(int d, int value)
424{
425 int left = value & 0x000000ff;
426 int right = (value & 0x0000ff00) >> 8;
427 int bLeft, bRight;
428 int wLeft, wRight;
429 int updatemaster = 0;
430
431 if (d > 31)
432 return -EINVAL;
433
434 bLeft = left * 0xff / 100;
435 wLeft = left * 0xffff / 100;
436
437 bRight = right * 0xff / 100;
438 wRight = right * 0xffff / 100;
439
440 dev.left_levels[d] = wLeft;
441 dev.right_levels[d] = wRight;
442
443 switch (d) {
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);
451 break;
452#ifndef MSND_CLASSIC
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);
459 break;
460#endif
461 case SOUND_MIXER_VOLUME: /* master volume */
462 writew(wLeft, dev.SMA + SMA_wCurrMastVolLeft);
463 writew(wRight, dev.SMA + SMA_wCurrMastVolRight);
464 /* fall through */
465
466 case SOUND_MIXER_LINE1: /* aux pot control */
467 /* scaled by master volume */
468 /* fall through */
469
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 */
475 updatemaster = 1;
476 break;
477
478 default:
479 return 0;
480 }
481
482 if (updatemaster) {
483 /* update master volume scaled controls */
484 update_volm(SOUND_MIXER_PCM, wCurrPlayVol);
485 update_volm(SOUND_MIXER_IMIX, wCurrInVol);
486#ifndef MSND_CLASSIC
487 update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
488#endif
489 update_potm(SOUND_MIXER_LINE1, bAuxPotPos, HDEXAR_AUX_SET_POTS);
490 }
491
492 return mixer_get(d);
493}
494
495static void mixer_setup(void)
496{
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);
501#ifndef MSND_CLASSIC
502 update_pot(SOUND_MIXER_MIC, bMicPotPos, HDEXAR_MIC_SET_POTS);
503 update_volm(SOUND_MIXER_SYNTH, wCurrMHdrVol);
504#endif
505}
506
507static unsigned long set_recsrc(unsigned long recsrc)
508{
509 if (dev.recsrc == recsrc)
510 return dev.recsrc;
511#ifdef HAVE_NORECSRC
512 else if (recsrc == 0)
513 dev.recsrc = 0;
514#endif
515 else
516 dev.recsrc ^= recsrc;
517
518#ifndef MSND_CLASSIC
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);
522 }
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);
526 }
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);
530 }
531 else {
532#ifdef HAVE_NORECSRC
533 /* Select no input (?) */
534 dev.recsrc = 0;
535#else
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);
539#endif
540 }
541#endif /* MSND_CLASSIC */
542
543 return dev.recsrc;
544}
545
546static unsigned long force_recsrc(unsigned long recsrc)
547{
548 dev.recsrc = 0;
549 return set_recsrc(recsrc);
550}
551
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));
556
557static int mixer_ioctl(unsigned int cmd, unsigned long arg)
558{
559 if (cmd == SOUND_MIXER_INFO) {
560 mixer_info info;
561 set_mixer_info();
562 info.modify_counter = dev.mixer_mod_count;
563 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
564 return -EFAULT;
565 return 0;
566 } else if (cmd == SOUND_OLD_MIXER_INFO) {
567 _old_mixer_info info;
568 set_mixer_info();
569 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
570 return -EFAULT;
571 return 0;
572 } else if (cmd == SOUND_MIXER_PRIVATE1) {
573 dev.nresets = 0;
574 dsp_full_reset();
575 return 0;
576 } else if (((cmd >> 8) & 0xff) == 'M') {
577 int val = 0;
578
579 if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
580 switch (cmd & 0xff) {
581 case SOUND_MIXER_RECSRC:
582 if (get_user(val, (int __user *)arg))
583 return -EFAULT;
584 val = set_recsrc(val);
585 break;
586
587 default:
588 if (get_user(val, (int __user *)arg))
589 return -EFAULT;
590 val = mixer_set(cmd & 0xff, val);
591 break;
592 }
593 ++dev.mixer_mod_count;
594 return put_user(val, (int __user *)arg);
595 } else {
596 switch (cmd & 0xff) {
597 case SOUND_MIXER_RECSRC:
598 val = dev.recsrc;
599 break;
600
601 case SOUND_MIXER_DEVMASK:
602 case SOUND_MIXER_STEREODEVS:
603 val = SOUND_MASK_PCM |
604 SOUND_MASK_LINE |
605 SOUND_MASK_IMIX |
606 SOUND_MASK_LINE1 |
607#ifndef MSND_CLASSIC
608 SOUND_MASK_MIC |
609 SOUND_MASK_SYNTH |
610#endif
611 SOUND_MASK_VOLUME;
612 break;
613
614 case SOUND_MIXER_RECMASK:
615#ifdef MSND_CLASSIC
616 val = 0;
617#else
618 val = SOUND_MASK_IMIX |
619 SOUND_MASK_SYNTH;
620 if (test_bit(F_HAVEDIGITAL, &dev.flags))
621 val |= SOUND_MASK_DIGITAL1;
622#endif
623 break;
624
625 case SOUND_MIXER_CAPS:
626 val = SOUND_CAP_EXCL_INPUT;
627 break;
628
629 default:
630 if ((val = mixer_get(cmd & 0xff)) < 0)
631 return -EINVAL;
632 break;
633 }
634 }
635
636 return put_user(val, (int __user *)arg);
637 }
638
639 return -EINVAL;
640}
641
642static int dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
643{
644 int minor = iminor(inode);
645
646 if (cmd == OSS_GETVERSION) {
647 int sound_version = SOUND_VERSION;
648 return put_user(sound_version, (int __user *)arg);
649 }
650
651 if (minor == dev.dsp_minor)
652 return dsp_ioctl(file, cmd, arg);
653 else if (minor == dev.mixer_minor)
654 return mixer_ioctl(cmd, arg);
655
656 return -EINVAL;
657}
658
659static void dsp_write_flush(void)
660{
661 if (!(dev.mode & FMODE_WRITE) || !test_bit(F_WRITING, &dev.flags))
662 return;
663 set_bit(F_WRITEFLUSH, &dev.flags);
664 interruptible_sleep_on_timeout(
665 &dev.writeflush,
666 get_play_delay_jiffies(dev.DAPF.len));
667 clear_bit(F_WRITEFLUSH, &dev.flags);
668 if (!signal_pending(current)) {
669 current->state = TASK_INTERRUPTIBLE;
670 schedule_timeout(get_play_delay_jiffies(DAP_BUFF_SIZE));
671 }
672 clear_bit(F_WRITING, &dev.flags);
673}
674
675static void dsp_halt(struct file *file)
676{
677 if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
678 clear_bit(F_READING, &dev.flags);
679 chk_send_dsp_cmd(&dev, HDEX_RECORD_STOP);
680 msnd_disable_irq(&dev);
681 if (file) {
682 printk(KERN_DEBUG LOGNAME ": Stopping read for %p\n", file);
683 dev.mode &= ~FMODE_READ;
684 }
685 clear_bit(F_AUDIO_READ_INUSE, &dev.flags);
686 }
687 if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
688 if (test_bit(F_WRITING, &dev.flags)) {
689 dsp_write_flush();
690 chk_send_dsp_cmd(&dev, HDEX_PLAY_STOP);
691 }
692 msnd_disable_irq(&dev);
693 if (file) {
694 printk(KERN_DEBUG LOGNAME ": Stopping write for %p\n", file);
695 dev.mode &= ~FMODE_WRITE;
696 }
697 clear_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
698 }
699}
700
701static int dsp_release(struct file *file)
702{
703 dsp_halt(file);
704 return 0;
705}
706
707static int dsp_open(struct file *file)
708{
709 if ((file ? file->f_mode : dev.mode) & FMODE_WRITE) {
710 set_bit(F_AUDIO_WRITE_INUSE, &dev.flags);
711 clear_bit(F_WRITING, &dev.flags);
712 msnd_fifo_make_empty(&dev.DAPF);
713 reset_play_queue();
714 if (file) {
715 printk(KERN_DEBUG LOGNAME ": Starting write for %p\n", file);
716 dev.mode |= FMODE_WRITE;
717 }
718 msnd_enable_irq(&dev);
719 }
720 if ((file ? file->f_mode : dev.mode) & FMODE_READ) {
721 set_bit(F_AUDIO_READ_INUSE, &dev.flags);
722 clear_bit(F_READING, &dev.flags);
723 msnd_fifo_make_empty(&dev.DARF);
724 reset_record_queue();
725 if (file) {
726 printk(KERN_DEBUG LOGNAME ": Starting read for %p\n", file);
727 dev.mode |= FMODE_READ;
728 }
729 msnd_enable_irq(&dev);
730 }
731 return 0;
732}
733
734static void set_default_play_audio_parameters(void)
735{
736 dev.play_sample_size = DEFSAMPLESIZE;
737 dev.play_sample_rate = DEFSAMPLERATE;
738 dev.play_channels = DEFCHANNELS;
739}
740
741static void set_default_rec_audio_parameters(void)
742{
743 dev.rec_sample_size = DEFSAMPLESIZE;
744 dev.rec_sample_rate = DEFSAMPLERATE;
745 dev.rec_channels = DEFCHANNELS;
746}
747
748static void set_default_audio_parameters(void)
749{
750 set_default_play_audio_parameters();
751 set_default_rec_audio_parameters();
752}
753
754static int dev_open(struct inode *inode, struct file *file)
755{
756 int minor = iminor(inode);
757 int err = 0;
758
90dc763f 759 lock_kernel();
1da177e4
LT		 760 if (minor == dev.dsp_minor) {
761 if ((file->f_mode & FMODE_WRITE &&
762 test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) ||
763 (file->f_mode & FMODE_READ &&
90dc763f
AB		 764 test_bit(F_AUDIO_READ_INUSE, &dev.flags))) {
765 err = -EBUSY;
766 goto out;
767 }
1da177e4
LT		 768
769 if ((err = dsp_open(file)) >= 0) {
770 dev.nresets = 0;
771 if (file->f_mode & FMODE_WRITE) {
772 set_default_play_audio_parameters();
773 if (!test_bit(F_DISABLE_WRITE_NDELAY, &dev.flags))
774 dev.play_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
775 else
776 dev.play_ndelay = 0;
777 }
778 if (file->f_mode & FMODE_READ) {
779 set_default_rec_audio_parameters();
780 dev.rec_ndelay = (file->f_flags & O_NDELAY) ? 1 : 0;
781 }
782 }
783 }
784 else if (minor == dev.mixer_minor) {
785 /* nothing */
786 } else
787 err = -EINVAL;
90dc763f
AB		 788out:
789 unlock_kernel();
1da177e4
LT		 790 return err;
791}
792
793static int dev_release(struct inode *inode, struct file *file)
794{
795 int minor = iminor(inode);
796 int err = 0;
797
798 lock_kernel();
799 if (minor == dev.dsp_minor)
800 err = dsp_release(file);
801 else if (minor == dev.mixer_minor) {
802 /* nothing */
803 } else
804 err = -EINVAL;
805 unlock_kernel();
806 return err;
807}
808
809static __inline__ int pack_DARQ_to_DARF(register int bank)
810{
811 register int size, timeout = 3;
812 register WORD wTmp;
813 LPDAQD DAQD;
814
815 /* Increment the tail and check for queue wrap */
816 wTmp = readw(dev.DARQ + JQS_wTail) + PCTODSP_OFFSET(DAQDS__size);
817 if (wTmp > readw(dev.DARQ + JQS_wSize))
818 wTmp = 0;
819 while (wTmp == readw(dev.DARQ + JQS_wHead) && timeout--)
820 udelay(1);
821 writew(wTmp, dev.DARQ + JQS_wTail);
822
823 /* Get our digital audio queue struct */
824 DAQD = bank * DAQDS__size + dev.base + DARQ_DATA_BUFF;
825
826 /* Get length of data */
827 size = readw(DAQD + DAQDS_wSize);
828
829 /* Read data from the head (unprotected bank 1 access okay
830 since this is only called inside an interrupt) */
831 msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
832 msnd_fifo_write_io(
833 &dev.DARF,
834 dev.base + bank * DAR_BUFF_SIZE,
835 size);
836 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
837
838 return 1;
839}
840
841static __inline__ int pack_DAPF_to_DAPQ(register int start)
842{
843 register WORD DAPQ_tail;
844 register int protect = start, nbanks = 0;
845 LPDAQD DAQD;
846
847 DAPQ_tail = readw(dev.DAPQ + JQS_wTail);
848 while (DAPQ_tail != readw(dev.DAPQ + JQS_wHead) || start) {
849 register int bank_num = DAPQ_tail / PCTODSP_OFFSET(DAQDS__size);
850 register int n;
851 unsigned long flags;
852
853 /* Write the data to the new tail */
854 if (protect) {
855 /* Critical section: protect fifo in non-interrupt */
856 spin_lock_irqsave(&dev.lock, flags);
857 n = msnd_fifo_read_io(
858 &dev.DAPF,
859 dev.base + bank_num * DAP_BUFF_SIZE,
860 DAP_BUFF_SIZE);
861 spin_unlock_irqrestore(&dev.lock, flags);
862 } else {
863 n = msnd_fifo_read_io(
864 &dev.DAPF,
865 dev.base + bank_num * DAP_BUFF_SIZE,
866 DAP_BUFF_SIZE);
867 }
868 if (!n)
869 break;
870
871 if (start)
872 start = 0;
873
874 /* Get our digital audio queue struct */
875 DAQD = bank_num * DAQDS__size + dev.base + DAPQ_DATA_BUFF;
876
877 /* Write size of this bank */
878 writew(n, DAQD + DAQDS_wSize);
879 ++nbanks;
880
881 /* Then advance the tail */
882 DAPQ_tail = (++bank_num % 3) * PCTODSP_OFFSET(DAQDS__size);
883 writew(DAPQ_tail, dev.DAPQ + JQS_wTail);
884 /* Tell the DSP to play the bank */
885 msnd_send_dsp_cmd(&dev, HDEX_PLAY_START);
886 }
887 return nbanks;
888}
889
890static int dsp_read(char __user *buf, size_t len)
891{
892 int count = len;
fa732f55 893 char *page = (char *)__get_free_page(GFP_KERNEL);
1da177e4
LT		 894
895 if (!page)
896 return -ENOMEM;
897
898 while (count > 0) {
899 int n, k;
900 unsigned long flags;
901
902 k = PAGE_SIZE;
903 if (k > count)
904 k = count;
905
906 /* Critical section: protect fifo in non-interrupt */
907 spin_lock_irqsave(&dev.lock, flags);
908 n = msnd_fifo_read(&dev.DARF, page, k);
909 spin_unlock_irqrestore(&dev.lock, flags);
910 if (copy_to_user(buf, page, n)) {
911 free_page((unsigned long)page);
912 return -EFAULT;
913 }
914 buf += n;
915 count -= n;
916
917 if (n == k && count)
918 continue;
919
920 if (!test_bit(F_READING, &dev.flags) && dev.mode & FMODE_READ) {
921 dev.last_recbank = -1;
922 if (chk_send_dsp_cmd(&dev, HDEX_RECORD_START) == 0)
923 set_bit(F_READING, &dev.flags);
924 }
925
926 if (dev.rec_ndelay) {
927 free_page((unsigned long)page);
928 return count == len ? -EAGAIN : len - count;
929 }
930
931 if (count > 0) {
932 set_bit(F_READBLOCK, &dev.flags);
933 if (!interruptible_sleep_on_timeout(
934 &dev.readblock,
935 get_rec_delay_jiffies(DAR_BUFF_SIZE)))
936 clear_bit(F_READING, &dev.flags);
937 clear_bit(F_READBLOCK, &dev.flags);
938 if (signal_pending(current)) {
939 free_page((unsigned long)page);
940 return -EINTR;
941 }
942 }
943 }
944 free_page((unsigned long)page);
945 return len - count;
946}
947
948static int dsp_write(const char __user *buf, size_t len)
949{
950 int count = len;
951 char *page = (char *)__get_free_page(GFP_KERNEL);
952
953 if (!page)
954 return -ENOMEM;
955
956 while (count > 0) {
957 int n, k;
958 unsigned long flags;
959
960 k = PAGE_SIZE;
961 if (k > count)
962 k = count;
963
964 if (copy_from_user(page, buf, k)) {
965 free_page((unsigned long)page);
966 return -EFAULT;
967 }
968
969 /* Critical section: protect fifo in non-interrupt */
970 spin_lock_irqsave(&dev.lock, flags);
971 n = msnd_fifo_write(&dev.DAPF, page, k);
972 spin_unlock_irqrestore(&dev.lock, flags);
973 buf += n;
974 count -= n;
975
976 if (count && n == k)
977 continue;
978
979 if (!test_bit(F_WRITING, &dev.flags) && (dev.mode & FMODE_WRITE)) {
980 dev.last_playbank = -1;
981 if (pack_DAPF_to_DAPQ(1) > 0)
982 set_bit(F_WRITING, &dev.flags);
983 }
984
985 if (dev.play_ndelay) {
986 free_page((unsigned long)page);
987 return count == len ? -EAGAIN : len - count;
988 }
989
990 if (count > 0) {
991 set_bit(F_WRITEBLOCK, &dev.flags);
992 interruptible_sleep_on_timeout(
993 &dev.writeblock,
994 get_play_delay_jiffies(DAP_BUFF_SIZE));
995 clear_bit(F_WRITEBLOCK, &dev.flags);
996 if (signal_pending(current)) {
997 free_page((unsigned long)page);
998 return -EINTR;
999 }
1000 }
1001 }
1002
1003 free_page((unsigned long)page);
1004 return len - count;
1005}
1006
1007static ssize_t dev_read(struct file *file, char __user *buf, size_t count, loff_t *off)
1008{
7bc56323 1009 int minor = iminor(file->f_path.dentry->d_inode);
1da177e4
LT		 1010 if (minor == dev.dsp_minor)
1011 return dsp_read(buf, count);
1012 else
1013 return -EINVAL;
1014}
1015
1016static ssize_t dev_write(struct file *file, const char __user *buf, size_t count, loff_t *off)
1017{
7bc56323 1018 int minor = iminor(file->f_path.dentry->d_inode);
1da177e4
LT		 1019 if (minor == dev.dsp_minor)
1020 return dsp_write(buf, count);
1021 else
1022 return -EINVAL;
1023}
1024
1025static __inline__ void eval_dsp_msg(register WORD wMessage)
1026{
1027 switch (HIBYTE(wMessage)) {
1028 case HIMT_PLAY_DONE:
1029 if (dev.last_playbank == LOBYTE(wMessage) || !test_bit(F_WRITING, &dev.flags))
1030 break;
1031 dev.last_playbank = LOBYTE(wMessage);
1032
1033 if (pack_DAPF_to_DAPQ(0) <= 0) {
1034 if (!test_bit(F_WRITEBLOCK, &dev.flags)) {
1035 if (test_and_clear_bit(F_WRITEFLUSH, &dev.flags))
1036 wake_up_interruptible(&dev.writeflush);
1037 }
1038 clear_bit(F_WRITING, &dev.flags);
1039 }
1040
1041 if (test_bit(F_WRITEBLOCK, &dev.flags))
1042 wake_up_interruptible(&dev.writeblock);
1043 break;
1044
1045 case HIMT_RECORD_DONE:
1046 if (dev.last_recbank == LOBYTE(wMessage))
1047 break;
1048 dev.last_recbank = LOBYTE(wMessage);
1049
1050 pack_DARQ_to_DARF(dev.last_recbank);
1051
1052 if (test_bit(F_READBLOCK, &dev.flags))
1053 wake_up_interruptible(&dev.readblock);
1054 break;
1055
1056 case HIMT_DSP:
1057 switch (LOBYTE(wMessage)) {
1058#ifndef MSND_CLASSIC
1059 case HIDSP_PLAY_UNDER:
1060#endif
1061 case HIDSP_INT_PLAY_UNDER:
1062/* printk(KERN_DEBUG LOGNAME ": Play underflow\n"); */
1063 clear_bit(F_WRITING, &dev.flags);
1064 break;
1065
1066 case HIDSP_INT_RECORD_OVER:
1067/* printk(KERN_DEBUG LOGNAME ": Record overflow\n"); */
1068 clear_bit(F_READING, &dev.flags);
1069 break;
1070
1071 default:
1072/* printk(KERN_DEBUG LOGNAME ": DSP message %d 0x%02x\n",
1073 LOBYTE(wMessage), LOBYTE(wMessage)); */
1074 break;
1075 }
1076 break;
1077
1078 case HIMT_MIDI_IN_UCHAR:
1079 if (dev.midi_in_interrupt)
1080 (*dev.midi_in_interrupt)(&dev);
1081 break;
1082
1083 default:
1084/* printk(KERN_DEBUG LOGNAME ": HIMT message %d 0x%02x\n", HIBYTE(wMessage), HIBYTE(wMessage)); */
1085 break;
1086 }
1087}
1088
7d12e780 1089static irqreturn_t intr(int irq, void *dev_id)
1da177e4
LT		 1090{
1091 /* Send ack to DSP */
1092 msnd_inb(dev.io + HP_RXL);
1093
1094 /* Evaluate queued DSP messages */
1095 while (readw(dev.DSPQ + JQS_wTail) != readw(dev.DSPQ + JQS_wHead)) {
1096 register WORD wTmp;
1097
1098 eval_dsp_msg(readw(dev.pwDSPQData + 2*readw(dev.DSPQ + JQS_wHead)));
1099
1100 if ((wTmp = readw(dev.DSPQ + JQS_wHead) + 1) > readw(dev.DSPQ + JQS_wSize))
1101 writew(0, dev.DSPQ + JQS_wHead);
1102 else
1103 writew(wTmp, dev.DSPQ + JQS_wHead);
1104 }
1105 return IRQ_HANDLED;
1106}
1107
9c2e08c5 1108static const struct file_operations dev_fileops = {
1da177e4
LT		 1109 .owner = THIS_MODULE,
1110 .read = dev_read,
1111 .write = dev_write,
1112 .ioctl = dev_ioctl,
1113 .open = dev_open,
1114 .release = dev_release,
1115};
1116
1117static int reset_dsp(void)
1118{
1119 int timeout = 100;
1120
1121 msnd_outb(HPDSPRESET_ON, dev.io + HP_DSPR);
1122 mdelay(1);
1123#ifndef MSND_CLASSIC
1124 dev.info = msnd_inb(dev.io + HP_INFO);
1125#endif
1126 msnd_outb(HPDSPRESET_OFF, dev.io + HP_DSPR);
1127 mdelay(1);
1128 while (timeout-- > 0) {
1129 if (msnd_inb(dev.io + HP_CVR) == HP_CVR_DEF)
1130 return 0;
1131 mdelay(1);
1132 }
1133 printk(KERN_ERR LOGNAME ": Cannot reset DSP\n");
1134
1135 return -EIO;
1136}
1137
1138static int __init probe_multisound(void)
1139{
1140#ifndef MSND_CLASSIC
1141 char *xv, *rev = NULL;
1142 char *pin = "Pinnacle", *fiji = "Fiji";
1143 char *pinfiji = "Pinnacle/Fiji";
1144#endif
1145
1146 if (!request_region(dev.io, dev.numio, "probing")) {
1147 printk(KERN_ERR LOGNAME ": I/O port conflict\n");
1148 return -ENODEV;
1149 }
1150
1151 if (reset_dsp() < 0) {
1152 release_region(dev.io, dev.numio);
1153 return -ENODEV;
1154 }
1155
1156#ifdef MSND_CLASSIC
1157 dev.name = "Classic/Tahiti/Monterey";
1158 printk(KERN_INFO LOGNAME ": %s, "
1159#else
1160 switch (dev.info >> 4) {
1161 case 0xf: xv = "<= 1.15"; break;
1162 case 0x1: xv = "1.18/1.2"; break;
1163 case 0x2: xv = "1.3"; break;
1164 case 0x3: xv = "1.4"; break;
1165 default: xv = "unknown"; break;
1166 }
1167
1168 switch (dev.info & 0x7) {
1169 case 0x0: rev = "I"; dev.name = pin; break;
1170 case 0x1: rev = "F"; dev.name = pin; break;
1171 case 0x2: rev = "G"; dev.name = pin; break;
1172 case 0x3: rev = "H"; dev.name = pin; break;
1173 case 0x4: rev = "E"; dev.name = fiji; break;
1174 case 0x5: rev = "C"; dev.name = fiji; break;
1175 case 0x6: rev = "D"; dev.name = fiji; break;
1176 case 0x7:
1177 rev = "A-B (Fiji) or A-E (Pinnacle)";
1178 dev.name = pinfiji;
1179 break;
1180 }
1181 printk(KERN_INFO LOGNAME ": %s revision %s, Xilinx version %s, "
1182#endif /* MSND_CLASSIC */
1183 "I/O 0x%x-0x%x, IRQ %d, memory mapped to %p-%p\n",
1184 dev.name,
1185#ifndef MSND_CLASSIC
1186 rev, xv,
1187#endif
1188 dev.io, dev.io + dev.numio - 1,
1189 dev.irq,
1190 dev.base, dev.base + 0x7fff);
1191
1192 release_region(dev.io, dev.numio);
1193 return 0;
1194}
1195
1196static int init_sma(void)
1197{
1198 static int initted;
1199 WORD mastVolLeft, mastVolRight;
1200 unsigned long flags;
1201
1202#ifdef MSND_CLASSIC
1203 msnd_outb(dev.memid, dev.io + HP_MEMM);
1204#endif
1205 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
1206 if (initted) {
1207 mastVolLeft = readw(dev.SMA + SMA_wCurrMastVolLeft);
1208 mastVolRight = readw(dev.SMA + SMA_wCurrMastVolRight);
1209 } else
1210 mastVolLeft = mastVolRight = 0;
1211 memset_io(dev.base, 0, 0x8000);
1212
1213 /* Critical section: bank 1 access */
1214 spin_lock_irqsave(&dev.lock, flags);
1215 msnd_outb(HPBLKSEL_1, dev.io + HP_BLKS);
1216 memset_io(dev.base, 0, 0x8000);
1217 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
1218 spin_unlock_irqrestore(&dev.lock, flags);
1219
1220 dev.pwDSPQData = (dev.base + DSPQ_DATA_BUFF);
1221 dev.pwMODQData = (dev.base + MODQ_DATA_BUFF);
1222 dev.pwMIDQData = (dev.base + MIDQ_DATA_BUFF);
1223
1224 /* Motorola 56k shared memory base */
1225 dev.SMA = dev.base + SMA_STRUCT_START;
1226
1227 /* Digital audio play queue */
1228 dev.DAPQ = dev.base + DAPQ_OFFSET;
1229 msnd_init_queue(dev.DAPQ, DAPQ_DATA_BUFF, DAPQ_BUFF_SIZE);
1230
1231 /* Digital audio record queue */
1232 dev.DARQ = dev.base + DARQ_OFFSET;
1233 msnd_init_queue(dev.DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE);
1234
1235 /* MIDI out queue */
1236 dev.MODQ = dev.base + MODQ_OFFSET;
1237 msnd_init_queue(dev.MODQ, MODQ_DATA_BUFF, MODQ_BUFF_SIZE);
1238
1239 /* MIDI in queue */
1240 dev.MIDQ = dev.base + MIDQ_OFFSET;
1241 msnd_init_queue(dev.MIDQ, MIDQ_DATA_BUFF, MIDQ_BUFF_SIZE);
1242
1243 /* DSP -> host message queue */
1244 dev.DSPQ = dev.base + DSPQ_OFFSET;
1245 msnd_init_queue(dev.DSPQ, DSPQ_DATA_BUFF, DSPQ_BUFF_SIZE);
1246
1247 /* Setup some DSP values */
1248#ifndef MSND_CLASSIC
1249 writew(1, dev.SMA + SMA_wCurrPlayFormat);
1250 writew(dev.play_sample_size, dev.SMA + SMA_wCurrPlaySampleSize);
1251 writew(dev.play_channels, dev.SMA + SMA_wCurrPlayChannels);
1252 writew(dev.play_sample_rate, dev.SMA + SMA_wCurrPlaySampleRate);
1253#endif
1254 writew(dev.play_sample_rate, dev.SMA + SMA_wCalFreqAtoD);
1255 writew(mastVolLeft, dev.SMA + SMA_wCurrMastVolLeft);
1256 writew(mastVolRight, dev.SMA + SMA_wCurrMastVolRight);
1257#ifndef MSND_CLASSIC
1258 writel(0x00010000, dev.SMA + SMA_dwCurrPlayPitch);
1259 writel(0x00000001, dev.SMA + SMA_dwCurrPlayRate);
1260#endif
1261 writew(0x303, dev.SMA + SMA_wCurrInputTagBits);
1262
1263 initted = 1;
1264
1265 return 0;
1266}
1267
1268static int __init calibrate_adc(WORD srate)
1269{
1270 writew(srate, dev.SMA + SMA_wCalFreqAtoD);
1271 if (dev.calibrate_signal == 0)
1272 writew(readw(dev.SMA + SMA_wCurrHostStatusFlags)
1273 | 0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
1274 else
1275 writew(readw(dev.SMA + SMA_wCurrHostStatusFlags)
1276 & ~0x0001, dev.SMA + SMA_wCurrHostStatusFlags);
1277 if (msnd_send_word(&dev, 0, 0, HDEXAR_CAL_A_TO_D) == 0 &&
1278 chk_send_dsp_cmd(&dev, HDEX_AUX_REQ) == 0) {
1279 current->state = TASK_INTERRUPTIBLE;
1280 schedule_timeout(HZ / 3);
1281 return 0;
1282 }
1283 printk(KERN_WARNING LOGNAME ": ADC calibration failed\n");
1284
1285 return -EIO;
1286}
1287
1288static int upload_dsp_code(void)
1289{
1290 msnd_outb(HPBLKSEL_0, dev.io + HP_BLKS);
1291#ifndef HAVE_DSPCODEH
1292 INITCODESIZE = mod_firmware_load(INITCODEFILE, &INITCODE);
1293 if (!INITCODE) {
1294 printk(KERN_ERR LOGNAME ": Error loading " INITCODEFILE);
1295 return -EBUSY;
1296 }
1297
1298 PERMCODESIZE = mod_firmware_load(PERMCODEFILE, &PERMCODE);
1299 if (!PERMCODE) {
1300 printk(KERN_ERR LOGNAME ": Error loading " PERMCODEFILE);
1301 vfree(INITCODE);
1302 return -EBUSY;
1303 }
1304#endif
1305 memcpy_toio(dev.base, PERMCODE, PERMCODESIZE);
1306 if (msnd_upload_host(&dev, INITCODE, INITCODESIZE) < 0) {
1307 printk(KERN_WARNING LOGNAME ": Error uploading to DSP\n");
1308 return -ENODEV;
1309 }
1310#ifdef HAVE_DSPCODEH
1311 printk(KERN_INFO LOGNAME ": DSP firmware uploaded (resident)\n");
1312#else
1313 printk(KERN_INFO LOGNAME ": DSP firmware uploaded\n");
1314#endif
1315
1316#ifndef HAVE_DSPCODEH
1317 vfree(INITCODE);
1318 vfree(PERMCODE);
1319#endif
1320
1321 return 0;
1322}
1323
1324#ifdef MSND_CLASSIC
1325static void reset_proteus(void)
1326{
1327 msnd_outb(HPPRORESET_ON, dev.io + HP_PROR);
1328 mdelay(TIME_PRO_RESET);
1329 msnd_outb(HPPRORESET_OFF, dev.io + HP_PROR);
1330 mdelay(TIME_PRO_RESET_DONE);
1331}
1332#endif
1333
1334static int initialize(void)
1335{
1336 int err, timeout;
1337
1338#ifdef MSND_CLASSIC
1339 msnd_outb(HPWAITSTATE_0, dev.io + HP_WAIT);
1340 msnd_outb(HPBITMODE_16, dev.io + HP_BITM);
1341
1342 reset_proteus();
1343#endif
1344 if ((err = init_sma()) < 0) {
1345 printk(KERN_WARNING LOGNAME ": Cannot initialize SMA\n");
1346 return err;
1347 }
1348
1349 if ((err = reset_dsp()) < 0)
1350 return err;
1351
1352 if ((err = upload_dsp_code()) < 0) {
1353 printk(KERN_WARNING LOGNAME ": Cannot upload DSP code\n");
1354 return err;
1355 }
1356
1357 timeout = 200;
1358 while (readw(dev.base)) {
1359 mdelay(1);
1360 if (!timeout--) {
1361 printk(KERN_DEBUG LOGNAME ": DSP reset timeout\n");
1362 return -EIO;
1363 }
1364 }
1365
1366 mixer_setup();
1367
1368 return 0;
1369}
1370
1371static int dsp_full_reset(void)
1372{
1373 int rv;
1374
1375 if (test_bit(F_RESETTING, &dev.flags) || ++dev.nresets > 10)
1376 return 0;
1377
1378 set_bit(F_RESETTING, &dev.flags);
1379 printk(KERN_INFO LOGNAME ": DSP reset\n");
1380 dsp_halt(NULL); /* Unconditionally halt */
1381 if ((rv = initialize()))
1382 printk(KERN_WARNING LOGNAME ": DSP reset failed\n");
1383 force_recsrc(dev.recsrc);
1384 dsp_open(NULL);
1385 clear_bit(F_RESETTING, &dev.flags);
1386
1387 return rv;
1388}
1389
1390static int __init attach_multisound(void)
1391{
1392 int err;
1393
1394 if ((err = request_irq(dev.irq, intr, 0, dev.name, &dev)) < 0) {
1395 printk(KERN_ERR LOGNAME ": Couldn't grab IRQ %d\n", dev.irq);
1396 return err;
1397 }
1398 request_region(dev.io, dev.numio, dev.name);
1399
1400 if ((err = dsp_full_reset()) < 0) {
1401 release_region(dev.io, dev.numio);
1402 free_irq(dev.irq, &dev);
1403 return err;
1404 }
1405
1406 if ((err = msnd_register(&dev)) < 0) {
1407 printk(KERN_ERR LOGNAME ": Unable to register MultiSound\n");
1408 release_region(dev.io, dev.numio);
1409 free_irq(dev.irq, &dev);
1410 return err;
1411 }
1412
1413 if ((dev.dsp_minor = register_sound_dsp(&dev_fileops, -1)) < 0) {
1414 printk(KERN_ERR LOGNAME ": Unable to register DSP operations\n");
1415 msnd_unregister(&dev);
1416 release_region(dev.io, dev.numio);
1417 free_irq(dev.irq, &dev);
1418 return dev.dsp_minor;
1419 }
1420
1421 if ((dev.mixer_minor = register_sound_mixer(&dev_fileops, -1)) < 0) {
1422 printk(KERN_ERR LOGNAME ": Unable to register mixer operations\n");
1423 unregister_sound_mixer(dev.mixer_minor);
1424 msnd_unregister(&dev);
1425 release_region(dev.io, dev.numio);
1426 free_irq(dev.irq, &dev);
1427 return dev.mixer_minor;
1428 }
1429
1430 dev.ext_midi_dev = dev.hdr_midi_dev = -1;
1431
1432 disable_irq(dev.irq);
1433 calibrate_adc(dev.play_sample_rate);
1434#ifndef MSND_CLASSIC
1435 force_recsrc(SOUND_MASK_IMIX);
1436#endif
1437
1438 return 0;
1439}
1440
1441static void __exit unload_multisound(void)
1442{
1443 release_region(dev.io, dev.numio);
1444 free_irq(dev.irq, &dev);
1445 unregister_sound_mixer(dev.mixer_minor);
1446 unregister_sound_dsp(dev.dsp_minor);
1447 msnd_unregister(&dev);
1448}
1449
1450#ifndef MSND_CLASSIC
1451
1452/* Pinnacle/Fiji Logical Device Configuration */
1453
1454static int __init msnd_write_cfg(int cfg, int reg, int value)
1455{
1456 msnd_outb(reg, cfg);
1457 msnd_outb(value, cfg + 1);
1458 if (value != msnd_inb(cfg + 1)) {
1459 printk(KERN_ERR LOGNAME ": msnd_write_cfg: I/O error\n");
1460 return -EIO;
1461 }
1462 return 0;
1463}
1464
1465static int __init msnd_write_cfg_io0(int cfg, int num, WORD io)
1466{
1467 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1468 return -EIO;
1469 if (msnd_write_cfg(cfg, IREG_IO0_BASEHI, HIBYTE(io)))
1470 return -EIO;
1471 if (msnd_write_cfg(cfg, IREG_IO0_BASELO, LOBYTE(io)))
1472 return -EIO;
1473 return 0;
1474}
1475
1476static int __init msnd_write_cfg_io1(int cfg, int num, WORD io)
1477{
1478 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1479 return -EIO;
1480 if (msnd_write_cfg(cfg, IREG_IO1_BASEHI, HIBYTE(io)))
1481 return -EIO;
1482 if (msnd_write_cfg(cfg, IREG_IO1_BASELO, LOBYTE(io)))
1483 return -EIO;
1484 return 0;
1485}
1486
1487static int __init msnd_write_cfg_irq(int cfg, int num, WORD irq)
1488{
1489 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1490 return -EIO;
1491 if (msnd_write_cfg(cfg, IREG_IRQ_NUMBER, LOBYTE(irq)))
1492 return -EIO;
1493 if (msnd_write_cfg(cfg, IREG_IRQ_TYPE, IRQTYPE_EDGE))
1494 return -EIO;
1495 return 0;
1496}
1497
1498static int __init msnd_write_cfg_mem(int cfg, int num, int mem)
1499{
1500 WORD wmem;
1501
1502 mem >>= 8;
1503 mem &= 0xfff;
1504 wmem = (WORD)mem;
1505 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1506 return -EIO;
1507 if (msnd_write_cfg(cfg, IREG_MEMBASEHI, HIBYTE(wmem)))
1508 return -EIO;
1509 if (msnd_write_cfg(cfg, IREG_MEMBASELO, LOBYTE(wmem)))
1510 return -EIO;
1511 if (wmem && msnd_write_cfg(cfg, IREG_MEMCONTROL, (MEMTYPE_HIADDR | MEMTYPE_16BIT)))
1512 return -EIO;
1513 return 0;
1514}
1515
1516static int __init msnd_activate_logical(int cfg, int num)
1517{
1518 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1519 return -EIO;
1520 if (msnd_write_cfg(cfg, IREG_ACTIVATE, LD_ACTIVATE))
1521 return -EIO;
1522 return 0;
1523}
1524
1525static int __init msnd_write_cfg_logical(int cfg, int num, WORD io0, WORD io1, WORD irq, int mem)
1526{
1527 if (msnd_write_cfg(cfg, IREG_LOGDEVICE, num))
1528 return -EIO;
1529 if (msnd_write_cfg_io0(cfg, num, io0))
1530 return -EIO;
1531 if (msnd_write_cfg_io1(cfg, num, io1))
1532 return -EIO;
1533 if (msnd_write_cfg_irq(cfg, num, irq))
1534 return -EIO;
1535 if (msnd_write_cfg_mem(cfg, num, mem))
1536 return -EIO;
1537 if (msnd_activate_logical(cfg, num))
1538 return -EIO;
1539 return 0;
1540}
1541
1542typedef struct msnd_pinnacle_cfg_device {
1543 WORD io0, io1, irq;
1544 int mem;
1545} msnd_pinnacle_cfg_t[4];
1546
1547static int __init msnd_pinnacle_cfg_devices(int cfg, int reset, msnd_pinnacle_cfg_t device)
1548{
1549 int i;
1550
1551 /* Reset devices if told to */
1552 if (reset) {
1553 printk(KERN_INFO LOGNAME ": Resetting all devices\n");
1554 for (i = 0; i < 4; ++i)
1555 if (msnd_write_cfg_logical(cfg, i, 0, 0, 0, 0))
1556 return -EIO;
1557 }
1558
1559 /* Configure specified devices */
1560 for (i = 0; i < 4; ++i) {
1561
1562 switch (i) {
1563 case 0: /* DSP */
1564 if (!(device[i].io0 && device[i].irq && device[i].mem))
1565 continue;
1566 break;
1567 case 1: /* MPU */
1568 if (!(device[i].io0 && device[i].irq))
1569 continue;
1570 printk(KERN_INFO LOGNAME
1571 ": Configuring MPU to I/O 0x%x IRQ %d\n",
1572 device[i].io0, device[i].irq);
1573 break;
1574 case 2: /* IDE */
1575 if (!(device[i].io0 && device[i].io1 && device[i].irq))
1576 continue;
1577 printk(KERN_INFO LOGNAME
1578 ": Configuring IDE to I/O 0x%x, 0x%x IRQ %d\n",
1579 device[i].io0, device[i].io1, device[i].irq);
1580 break;
1581 case 3: /* Joystick */
1582 if (!(device[i].io0))
1583 continue;
1584 printk(KERN_INFO LOGNAME
1585 ": Configuring joystick to I/O 0x%x\n",
1586 device[i].io0);
1587 break;
1588 }
1589
1590 /* Configure the device */
1591 if (msnd_write_cfg_logical(cfg, i, device[i].io0, device[i].io1, device[i].irq, device[i].mem))
1592 return -EIO;
1593 }
1594
1595 return 0;
1596}
1597#endif
1598
1599#ifdef MODULE
1600MODULE_AUTHOR ("Andrew Veliath <andrewtv@usa.net>");
1601MODULE_DESCRIPTION ("Turtle Beach " LONGNAME " Linux Driver");
1602MODULE_LICENSE("GPL");
1603
1604static int io __initdata = -1;
1605static int irq __initdata = -1;
1606static int mem __initdata = -1;
1607static int write_ndelay __initdata = -1;
1608
1609#ifndef MSND_CLASSIC
1610/* Pinnacle/Fiji non-PnP Config Port */
1611static int cfg __initdata = -1;
1612
1613/* Extra Peripheral Configuration */
1614static int reset __initdata = 0;
1615static int mpu_io __initdata = 0;
1616static int mpu_irq __initdata = 0;
1617static int ide_io0 __initdata = 0;
1618static int ide_io1 __initdata = 0;
1619static int ide_irq __initdata = 0;
1620static int joystick_io __initdata = 0;
1621
1622/* If we have the digital daugherboard... */
1623static int digital __initdata = 0;
1624#endif
1625
1626static int fifosize __initdata = DEFFIFOSIZE;
1627static int calibrate_signal __initdata = 0;
1628
1629#else /* not a module */
1630
1631static int write_ndelay __initdata = -1;
1632
1633#ifdef MSND_CLASSIC
1634static int io __initdata = CONFIG_MSNDCLAS_IO;
1635static int irq __initdata = CONFIG_MSNDCLAS_IRQ;
1636static int mem __initdata = CONFIG_MSNDCLAS_MEM;
1637#else /* Pinnacle/Fiji */
1638
1639static int io __initdata = CONFIG_MSNDPIN_IO;
1640static int irq __initdata = CONFIG_MSNDPIN_IRQ;
1641static int mem __initdata = CONFIG_MSNDPIN_MEM;
1642
1643/* Pinnacle/Fiji non-PnP Config Port */
1644#ifdef CONFIG_MSNDPIN_NONPNP
1645# ifndef CONFIG_MSNDPIN_CFG
1646# define CONFIG_MSNDPIN_CFG 0x250
1647# endif
1648#else
1649# ifdef CONFIG_MSNDPIN_CFG
1650# undef CONFIG_MSNDPIN_CFG
1651# endif
1652# define CONFIG_MSNDPIN_CFG -1
1653#endif
1654static int cfg __initdata = CONFIG_MSNDPIN_CFG;
1655/* If not a module, we don't need to bother with reset=1 */
1656static int reset;
1657
1658/* Extra Peripheral Configuration (Default: Disable) */
1659#ifndef CONFIG_MSNDPIN_MPU_IO
1660# define CONFIG_MSNDPIN_MPU_IO 0
1661#endif
1662static int mpu_io __initdata = CONFIG_MSNDPIN_MPU_IO;
1663
1664#ifndef CONFIG_MSNDPIN_MPU_IRQ
1665# define CONFIG_MSNDPIN_MPU_IRQ 0
1666#endif
1667static int mpu_irq __initdata = CONFIG_MSNDPIN_MPU_IRQ;
1668
1669#ifndef CONFIG_MSNDPIN_IDE_IO0
1670# define CONFIG_MSNDPIN_IDE_IO0 0
1671#endif
1672static int ide_io0 __initdata = CONFIG_MSNDPIN_IDE_IO0;
1673
1674#ifndef CONFIG_MSNDPIN_IDE_IO1
1675# define CONFIG_MSNDPIN_IDE_IO1 0
1676#endif
1677static int ide_io1 __initdata = CONFIG_MSNDPIN_IDE_IO1;
1678
1679#ifndef CONFIG_MSNDPIN_IDE_IRQ
1680# define CONFIG_MSNDPIN_IDE_IRQ 0
1681#endif
1682static int ide_irq __initdata = CONFIG_MSNDPIN_IDE_IRQ;
1683
1684#ifndef CONFIG_MSNDPIN_JOYSTICK_IO
1685# define CONFIG_MSNDPIN_JOYSTICK_IO 0
1686#endif
1687static int joystick_io __initdata = CONFIG_MSNDPIN_JOYSTICK_IO;
1688
1689/* Have SPDIF (Digital) Daughterboard */
1690#ifndef CONFIG_MSNDPIN_DIGITAL
1691# define CONFIG_MSNDPIN_DIGITAL 0
1692#endif
1693static int digital __initdata = CONFIG_MSNDPIN_DIGITAL;
1694
1695#endif /* MSND_CLASSIC */
1696
1697#ifndef CONFIG_MSND_FIFOSIZE
1698# define CONFIG_MSND_FIFOSIZE DEFFIFOSIZE
1699#endif
1700static int fifosize __initdata = CONFIG_MSND_FIFOSIZE;
1701
1702#ifndef CONFIG_MSND_CALSIGNAL
1703# define CONFIG_MSND_CALSIGNAL 0
1704#endif
1705static int
1706calibrate_signal __initdata = CONFIG_MSND_CALSIGNAL;
1707#endif /* MODULE */
1708
1709module_param (io, int, 0);
1710module_param (irq, int, 0);
1711module_param (mem, int, 0);
1712module_param (write_ndelay, int, 0);
1713module_param (fifosize, int, 0);
1714module_param (calibrate_signal, int, 0);
1715#ifndef MSND_CLASSIC
1716module_param (digital, bool, 0);
1717module_param (cfg, int, 0);
1718module_param (reset, int, 0);
1719module_param (mpu_io, int, 0);
1720module_param (mpu_irq, int, 0);
1721module_param (ide_io0, int, 0);
1722module_param (ide_io1, int, 0);
1723module_param (ide_irq, int, 0);
1724module_param (joystick_io, int, 0);
1725#endif
1726
1727static int __init msnd_init(void)
1728{
1729 int err;
1730#ifndef MSND_CLASSIC
1731 static msnd_pinnacle_cfg_t pinnacle_devs;
1732#endif /* MSND_CLASSIC */
1733
1734 printk(KERN_INFO LOGNAME ": Turtle Beach " LONGNAME " Linux Driver Version "
1735 VERSION ", Copyright (C) 1998 Andrew Veliath\n");
1736
1737 if (io == -1 || irq == -1 || mem == -1)
1738 printk(KERN_WARNING LOGNAME ": io, irq and mem must be set\n");
1739
1740#ifdef MSND_CLASSIC
1741 if (io == -1 ||
1742 !(io == 0x290 ||
1743 io == 0x260 ||
1744 io == 0x250 ||
1745 io == 0x240 ||
1746 io == 0x230 ||
1747 io == 0x220 ||
1748 io == 0x210 ||
1749 io == 0x3e0)) {
1750 printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must be set to 0x210, 0x220, 0x230, 0x240, 0x250, 0x260, 0x290, or 0x3E0\n");
1751 return -EINVAL;
1752 }
1753#else
1754 if (io == -1 ||
1755 io < 0x100 ||
1756 io > 0x3e0 ||
1757 (io % 0x10) != 0) {
1758 printk(KERN_ERR LOGNAME ": \"io\" - DSP I/O base must within the range 0x100 to 0x3E0 and must be evenly divisible by 0x10\n");
1759 return -EINVAL;
1760 }
1761#endif /* MSND_CLASSIC */
1762
1763 if (irq == -1 ||
1764 !(irq == 5 ||
1765 irq == 7 ||
1766 irq == 9 ||
1767 irq == 10 ||
1768 irq == 11 ||
1769 irq == 12)) {
1770 printk(KERN_ERR LOGNAME ": \"irq\" - must be set to 5, 7, 9, 10, 11 or 12\n");
1771 return -EINVAL;
1772 }
1773
1774 if (mem == -1 ||
1775 !(mem == 0xb0000 ||
1776 mem == 0xc8000 ||
1777 mem == 0xd0000 ||
1778 mem == 0xd8000 ||
1779 mem == 0xe0000 ||
1780 mem == 0xe8000)) {
1781 printk(KERN_ERR LOGNAME ": \"mem\" - must be set to "
1782 "0xb0000, 0xc8000, 0xd0000, 0xd8000, 0xe0000 or 0xe8000\n");
1783 return -EINVAL;
1784 }
1785
1786#ifdef MSND_CLASSIC
1787 switch (irq) {
1788 case 5: dev.irqid = HPIRQ_5; break;
1789 case 7: dev.irqid = HPIRQ_7; break;
1790 case 9: dev.irqid = HPIRQ_9; break;
1791 case 10: dev.irqid = HPIRQ_10; break;
1792 case 11: dev.irqid = HPIRQ_11; break;
1793 case 12: dev.irqid = HPIRQ_12; break;
1794 }
1795
1796 switch (mem) {
1797 case 0xb0000: dev.memid = HPMEM_B000; break;
1798 case 0xc8000: dev.memid = HPMEM_C800; break;
1799 case 0xd0000: dev.memid = HPMEM_D000; break;
1800 case 0xd8000: dev.memid = HPMEM_D800; break;
1801 case 0xe0000: dev.memid = HPMEM_E000; break;
1802 case 0xe8000: dev.memid = HPMEM_E800; break;
1803 }
1804#else
1805 if (cfg == -1) {
1806 printk(KERN_INFO LOGNAME ": Assuming PnP mode\n");
1807 } else if (cfg != 0x250 && cfg != 0x260 && cfg != 0x270) {
1808 printk(KERN_INFO LOGNAME ": Config port must be 0x250, 0x260 or 0x270 (or unspecified for PnP mode)\n");
1809 return -EINVAL;
1810 } else {
1811 printk(KERN_INFO LOGNAME ": Non-PnP mode: configuring at port 0x%x\n", cfg);
1812
1813 /* DSP */
1814 pinnacle_devs[0].io0 = io;
1815 pinnacle_devs[0].irq = irq;
1816 pinnacle_devs[0].mem = mem;
1817
1818 /* The following are Pinnacle specific */
1819
1820 /* MPU */
1821 pinnacle_devs[1].io0 = mpu_io;
1822 pinnacle_devs[1].irq = mpu_irq;
1823
1824 /* IDE */
1825 pinnacle_devs[2].io0 = ide_io0;
1826 pinnacle_devs[2].io1 = ide_io1;
1827 pinnacle_devs[2].irq = ide_irq;
1828
1829 /* Joystick */
1830 pinnacle_devs[3].io0 = joystick_io;
1831
1832 if (!request_region(cfg, 2, "Pinnacle/Fiji Config")) {
1833 printk(KERN_ERR LOGNAME ": Config port 0x%x conflict\n", cfg);
1834 return -EIO;
1835 }
1836
1837 if (msnd_pinnacle_cfg_devices(cfg, reset, pinnacle_devs)) {
1838 printk(KERN_ERR LOGNAME ": Device configuration error\n");
1839 release_region(cfg, 2);
1840 return -EIO;
1841 }
1842 release_region(cfg, 2);
1843 }
1844#endif /* MSND_CLASSIC */
1845
1846 if (fifosize < 16)
1847 fifosize = 16;
1848
1849 if (fifosize > 1024)
1850 fifosize = 1024;
1851
1852 set_default_audio_parameters();
1853#ifdef MSND_CLASSIC
1854 dev.type = msndClassic;
1855#else
1856 dev.type = msndPinnacle;
1857#endif
1858 dev.io = io;
1859 dev.numio = DSP_NUMIO;
1860 dev.irq = irq;
1861 dev.base = ioremap(mem, 0x8000);
1862 dev.fifosize = fifosize * 1024;
1863 dev.calibrate_signal = calibrate_signal ? 1 : 0;
1864 dev.recsrc = 0;
1865 dev.dspq_data_buff = DSPQ_DATA_BUFF;
1866 dev.dspq_buff_size = DSPQ_BUFF_SIZE;
1867 if (write_ndelay == -1)
1868 write_ndelay = CONFIG_MSND_WRITE_NDELAY;
1869 if (write_ndelay)
1870 clear_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
1871 else
1872 set_bit(F_DISABLE_WRITE_NDELAY, &dev.flags);
1873#ifndef MSND_CLASSIC
1874 if (digital)
1875 set_bit(F_HAVEDIGITAL, &dev.flags);
1876#endif
1877 init_waitqueue_head(&dev.writeblock);
1878 init_waitqueue_head(&dev.readblock);
1879 init_waitqueue_head(&dev.writeflush);
1880 msnd_fifo_init(&dev.DAPF);
1881 msnd_fifo_init(&dev.DARF);
1882 spin_lock_init(&dev.lock);
1883 printk(KERN_INFO LOGNAME ": %u byte audio FIFOs (x2)\n", dev.fifosize);
1884 if ((err = msnd_fifo_alloc(&dev.DAPF, dev.fifosize)) < 0) {
1885 printk(KERN_ERR LOGNAME ": Couldn't allocate write FIFO\n");
1886 return err;
1887 }
1888
1889 if ((err = msnd_fifo_alloc(&dev.DARF, dev.fifosize)) < 0) {
1890 printk(KERN_ERR LOGNAME ": Couldn't allocate read FIFO\n");
1891 msnd_fifo_free(&dev.DAPF);
1892 return err;
1893 }
1894
1895 if ((err = probe_multisound()) < 0) {
1896 printk(KERN_ERR LOGNAME ": Probe failed\n");
1897 msnd_fifo_free(&dev.DAPF);
1898 msnd_fifo_free(&dev.DARF);
1899 return err;
1900 }
1901
1902 if ((err = attach_multisound()) < 0) {
1903 printk(KERN_ERR LOGNAME ": Attach failed\n");
1904 msnd_fifo_free(&dev.DAPF);
1905 msnd_fifo_free(&dev.DARF);
1906 return err;
1907 }
1908
1909 return 0;
1910}
1911
1912static void __exit msdn_cleanup(void)
1913{
1914 unload_multisound();
1915 msnd_fifo_free(&dev.DAPF);
1916 msnd_fifo_free(&dev.DARF);
1917}
1918
1919module_init(msnd_init);
1920module_exit(msdn_cleanup);
Linux 6.x block layer and io_uring tree(s)