]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - sound/oss/msnd_pinnacle.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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