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