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