1 /*
2 * sound/sb_audio.c
3 *
4 * Audio routines for Sound Blaster compatible cards.
5 *
6 *
7 * Copyright (C) by Hannu Savolainen 1993-1997
8 *
9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
11 * for more info.
12 *
13 * Changes
14 * Alan Cox : Formatting and clean ups
15 *
16 * Status
17 * Mostly working. Weird uart bug causing irq storms
18 *
19 * Daniel J. Rodriksson: Changes to make sb16 work full duplex.
20 * Maybe other 16 bit cards in this code could behave
21 * the same.
22 */
23
24 #include "sound_config.h"
25
26 #include "sb_mixer.h"
27 #include "sb.h"
28
29 #include "sb_ess.h"
30
31 int sb_audio_open(int dev, int mode)
32 {
33 sb_devc *devc = audio_devs[dev]->devc;
34 unsigned long flags;
35
36 if (devc == NULL)
37 {
38 printk(KERN_ERR "Sound Blaster: incomplete initialization.\n");
39 return -ENXIO;
40 }
41 if (devc->caps & SB_NO_RECORDING && mode & OPEN_READ)
42 {
43 if (mode == OPEN_READ)
44 return -EPERM;
45 }
46 save_flags(flags);
47 cli();
48 if (devc->opened)
49 {
50 restore_flags(flags);
51 return -EBUSY;
52 }
53 if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex)
54 {
55 if (sound_open_dma(devc->dma16, "Sound Blaster 16 bit"))
56 {
57 restore_flags(flags);
58 return -EBUSY;
59 }
60 }
61 devc->opened = mode;
62 restore_flags(flags);
63
64 devc->irq_mode = IMODE_NONE;
65 devc->irq_mode_16 = IMODE_NONE;
66 devc->fullduplex = devc->duplex &&
67 ((mode & OPEN_READ) && (mode & OPEN_WRITE));
68 sb_dsp_reset(devc);
69
70 /* At first glance this check isn't enough, some ESS chips might not
71 * have a RECLEV. However if they don't common_mixer_set will refuse
72 * cause devc->iomap has no register mapping for RECLEV
73 */
74 if (devc->model == MDL_ESS) ess_mixer_reload (devc, SOUND_MIXER_RECLEV);
75
76 /* The ALS007 seems to require that the DSP be removed from the output */
77 /* in order for recording to be activated properly. This is done by */
78 /* setting the appropriate bits of the output control register 4ch to */
79 /* zero. This code assumes that the output control registers are not */
80 /* used anywhere else and therefore the DSP bits are *always* ON for */
81 /* output and OFF for sampling. */
82
83 if (devc->submodel == SUBMDL_ALS007)
84 {
85 if (mode & OPEN_READ)
86 sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
87 sb_getmixer(devc,ALS007_OUTPUT_CTRL2) & 0xf9);
88 else
89 sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
90 sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
91 }
92 return 0;
93 }
94
95 void sb_audio_close(int dev)
96 {
97 sb_devc *devc = audio_devs[dev]->devc;
98
99 /* fix things if mmap turned off fullduplex */
100 if(devc->duplex
101 && !devc->fullduplex
102 && (devc->opened & OPEN_READ) && (devc->opened & OPEN_WRITE))
103 {
104 struct dma_buffparms *dmap_temp;
105 dmap_temp = audio_devs[dev]->dmap_out;
106 audio_devs[dev]->dmap_out = audio_devs[dev]->dmap_in;
107 audio_devs[dev]->dmap_in = dmap_temp;
108 }
109 audio_devs[dev]->dmap_out->dma = devc->dma8;
110 audio_devs[dev]->dmap_in->dma = ( devc->duplex ) ?
111 devc->dma16 : devc->dma8;
112
113 if (devc->dma16 != -1 && devc->dma16 != devc->dma8 && !devc->duplex)
114 sound_close_dma(devc->dma16);
115
116 /* For ALS007, turn DSP output back on if closing the device for read */
117
118 if ((devc->submodel == SUBMDL_ALS007) && (devc->opened & OPEN_READ))
119 {
120 sb_setmixer(devc,ALS007_OUTPUT_CTRL2,
121 sb_getmixer(devc,ALS007_OUTPUT_CTRL2) | 0x06);
122 }
123 devc->opened = 0;
124 }
125
126 static void sb_set_output_parms(int dev, unsigned long buf, int nr_bytes,
127 int intrflag)
128 {
129 sb_devc *devc = audio_devs[dev]->devc;
130
131 if (!devc->fullduplex || devc->bits == AFMT_S16_LE)
132 {
133 devc->trg_buf = buf;
134 devc->trg_bytes = nr_bytes;
135 devc->trg_intrflag = intrflag;
136 devc->irq_mode = IMODE_OUTPUT;
137 }
138 else
139 {
140 devc->trg_buf_16 = buf;
141 devc->trg_bytes_16 = nr_bytes;
142 devc->trg_intrflag_16 = intrflag;
143 devc->irq_mode_16 = IMODE_OUTPUT;
144 }
145 }
146
147 static void sb_set_input_parms(int dev, unsigned long buf, int count, int intrflag)
148 {
149 sb_devc *devc = audio_devs[dev]->devc;
150
151 if (!devc->fullduplex || devc->bits != AFMT_S16_LE)
152 {
153 devc->trg_buf = buf;
154 devc->trg_bytes = count;
155 devc->trg_intrflag = intrflag;
156 devc->irq_mode = IMODE_INPUT;
157 }
158 else
159 {
160 devc->trg_buf_16 = buf;
161 devc->trg_bytes_16 = count;
162 devc->trg_intrflag_16 = intrflag;
163 devc->irq_mode_16 = IMODE_INPUT;
164 }
165 }
166
167 /*
168 * SB1.x compatible routines
169 */
170
171 static void sb1_audio_output_block(int dev, unsigned long buf, int nr_bytes, int intrflag)
172 {
173 unsigned long flags;
174 int count = nr_bytes;
175 sb_devc *devc = audio_devs[dev]->devc;
176
177 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
178
179 if (audio_devs[dev]->dmap_out->dma > 3)
180 count >>= 1;
181 count--;
182
183 devc->irq_mode = IMODE_OUTPUT;
184
185 save_flags(flags);
186 cli();
187 if (sb_dsp_command(devc, 0x14)) /* 8 bit DAC using DMA */
188 {
189 sb_dsp_command(devc, (unsigned char) (count & 0xff));
190 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
191 }
192 else
193 printk(KERN_WARNING "Sound Blaster: unable to start DAC.\n");
194 restore_flags(flags);
195 devc->intr_active = 1;
196 }
197
198 static void sb1_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
199 {
200 unsigned long flags;
201 int count = nr_bytes;
202 sb_devc *devc = audio_devs[dev]->devc;
203
204 /*
205 * Start a DMA input to the buffer pointed by dmaqtail
206 */
207
208 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
209
210 if (audio_devs[dev]->dmap_out->dma > 3)
211 count >>= 1;
212 count--;
213
214 devc->irq_mode = IMODE_INPUT;
215
216 save_flags(flags);
217 cli();
218 if (sb_dsp_command(devc, 0x24)) /* 8 bit ADC using DMA */
219 {
220 sb_dsp_command(devc, (unsigned char) (count & 0xff));
221 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
222 }
223 else
224 printk(KERN_ERR "Sound Blaster: unable to start ADC.\n");
225 restore_flags(flags);
226
227 devc->intr_active = 1;
228 }
229
230 static void sb1_audio_trigger(int dev, int bits)
231 {
232 sb_devc *devc = audio_devs[dev]->devc;
233
234 bits &= devc->irq_mode;
235
236 if (!bits)
237 sb_dsp_command(devc, 0xd0); /* Halt DMA */
238 else
239 {
240 switch (devc->irq_mode)
241 {
242 case IMODE_INPUT:
243 sb1_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
244 devc->trg_intrflag);
245 break;
246
247 case IMODE_OUTPUT:
248 sb1_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
249 devc->trg_intrflag);
250 break;
251 }
252 }
253 devc->trigger_bits = bits;
254 }
255
256 static int sb1_audio_prepare_for_input(int dev, int bsize, int bcount)
257 {
258 sb_devc *devc = audio_devs[dev]->devc;
259 unsigned long flags;
260
261 save_flags(flags);
262 cli();
263 if (sb_dsp_command(devc, 0x40))
264 sb_dsp_command(devc, devc->tconst);
265 sb_dsp_command(devc, DSP_CMD_SPKOFF);
266 restore_flags(flags);
267
268 devc->trigger_bits = 0;
269 return 0;
270 }
271
272 static int sb1_audio_prepare_for_output(int dev, int bsize, int bcount)
273 {
274 sb_devc *devc = audio_devs[dev]->devc;
275 unsigned long flags;
276
277 save_flags(flags);
278 cli();
279 if (sb_dsp_command(devc, 0x40))
280 sb_dsp_command(devc, devc->tconst);
281 sb_dsp_command(devc, DSP_CMD_SPKON);
282 restore_flags(flags);
283 devc->trigger_bits = 0;
284 return 0;
285 }
286
287 static int sb1_audio_set_speed(int dev, int speed)
288 {
289 int max_speed = 23000;
290 sb_devc *devc = audio_devs[dev]->devc;
291 int tmp;
292
293 if (devc->opened & OPEN_READ)
294 max_speed = 13000;
295
296 if (speed > 0)
297 {
298 if (speed < 4000)
299 speed = 4000;
300
301 if (speed > max_speed)
302 speed = max_speed;
303
304 devc->tconst = (256 - ((1000000 + speed / 2) / speed)) & 0xff;
305 tmp = 256 - devc->tconst;
306 speed = (1000000 + tmp / 2) / tmp;
307
308 devc->speed = speed;
309 }
310 return devc->speed;
311 }
312
313 static short sb1_audio_set_channels(int dev, short channels)
314 {
315 sb_devc *devc = audio_devs[dev]->devc;
316 return devc->channels = 1;
317 }
318
319 static unsigned int sb1_audio_set_bits(int dev, unsigned int bits)
320 {
321 sb_devc *devc = audio_devs[dev]->devc;
322 return devc->bits = 8;
323 }
324
325 static void sb1_audio_halt_xfer(int dev)
326 {
327 unsigned long flags;
328 sb_devc *devc = audio_devs[dev]->devc;
329
330 save_flags(flags);
331 cli();
332 sb_dsp_reset(devc);
333 restore_flags(flags);
334 }
335
336 /*
337 * SB 2.0 and SB 2.01 compatible routines
338 */
339
340 static void sb20_audio_output_block(int dev, unsigned long buf, int nr_bytes,
341 int intrflag)
342 {
343 unsigned long flags;
344 int count = nr_bytes;
345 sb_devc *devc = audio_devs[dev]->devc;
346 unsigned char cmd;
347
348 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
349
350 if (audio_devs[dev]->dmap_out->dma > 3)
351 count >>= 1;
352 count--;
353
354 devc->irq_mode = IMODE_OUTPUT;
355
356 save_flags(flags);
357 cli();
358 if (sb_dsp_command(devc, 0x48)) /* DSP Block size */
359 {
360 sb_dsp_command(devc, (unsigned char) (count & 0xff));
361 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
362
363 if (devc->speed * devc->channels <= 23000)
364 cmd = 0x1c; /* 8 bit PCM output */
365 else
366 cmd = 0x90; /* 8 bit high speed PCM output (SB2.01/Pro) */
367
368 if (!sb_dsp_command(devc, cmd))
369 printk(KERN_ERR "Sound Blaster: unable to start DAC.\n");
370 }
371 else
372 printk(KERN_ERR "Sound Blaster: unable to start DAC.\n");
373 restore_flags(flags);
374 devc->intr_active = 1;
375 }
376
377 static void sb20_audio_start_input(int dev, unsigned long buf, int nr_bytes, int intrflag)
378 {
379 unsigned long flags;
380 int count = nr_bytes;
381 sb_devc *devc = audio_devs[dev]->devc;
382 unsigned char cmd;
383
384 /*
385 * Start a DMA input to the buffer pointed by dmaqtail
386 */
387
388 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
389
390 if (audio_devs[dev]->dmap_out->dma > 3)
391 count >>= 1;
392 count--;
393
394 devc->irq_mode = IMODE_INPUT;
395
396 save_flags(flags);
397 cli();
398 if (sb_dsp_command(devc, 0x48)) /* DSP Block size */
399 {
400 sb_dsp_command(devc, (unsigned char) (count & 0xff));
401 sb_dsp_command(devc, (unsigned char) ((count >> 8) & 0xff));
402
403 if (devc->speed * devc->channels <= (devc->major == 3 ? 23000 : 13000))
404 cmd = 0x2c; /* 8 bit PCM input */
405 else
406 cmd = 0x98; /* 8 bit high speed PCM input (SB2.01/Pro) */
407
408 if (!sb_dsp_command(devc, cmd))
409 printk(KERN_ERR "Sound Blaster: unable to start ADC.\n");
410 }
411 else
412 printk(KERN_ERR "Sound Blaster: unable to start ADC.\n");
413 restore_flags(flags);
414 devc->intr_active = 1;
415 }
416
417 static void sb20_audio_trigger(int dev, int bits)
418 {
419 sb_devc *devc = audio_devs[dev]->devc;
420 bits &= devc->irq_mode;
421
422 if (!bits)
423 sb_dsp_command(devc, 0xd0); /* Halt DMA */
424 else
425 {
426 switch (devc->irq_mode)
427 {
428 case IMODE_INPUT:
429 sb20_audio_start_input(dev, devc->trg_buf, devc->trg_bytes,
430 devc->trg_intrflag);
431 break;
432
433 case IMODE_OUTPUT:
434 sb20_audio_output_block(dev, devc->trg_buf, devc->trg_bytes,
435 devc->trg_intrflag);
436 break;
437 }
438 }
439 devc->trigger_bits = bits;
440 }
441
442 /*
443 * SB2.01 specific speed setup
444 */
445
446 static int sb201_audio_set_speed(int dev, int speed)
447 {
448 sb_devc *devc = audio_devs[dev]->devc;
449 int tmp;
450 int s = speed * devc->channels;
451
452 if (speed > 0)
453 {
454 if (speed < 4000)
455 speed = 4000;
456 if (speed > 44100)
457 speed = 44100;
458 if (devc->opened & OPEN_READ && speed > 15000)
459 speed = 15000;
460 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff;
461 tmp = 256 - devc->tconst;
462 speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
463
464 devc->speed = speed;
465 }
466 return devc->speed;
467 }
468
469 /*
470 * SB Pro specific routines
471 */
472
473 static int sbpro_audio_prepare_for_input(int dev, int bsize, int bcount)
474 { /* For SB Pro and Jazz16 */
475 sb_devc *devc = audio_devs[dev]->devc;
476 unsigned long flags;
477 unsigned char bits = 0;
478
479 if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
480 audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma =
481 devc->bits == 16 ? devc->dma16 : devc->dma8;
482
483 if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
484 if (devc->bits == AFMT_S16_LE)
485 bits = 0x04; /* 16 bit mode */
486
487 save_flags(flags);
488 cli();
489 if (sb_dsp_command(devc, 0x40))
490 sb_dsp_command(devc, devc->tconst);
491 sb_dsp_command(devc, DSP_CMD_SPKOFF);
492 if (devc->channels == 1)
493 sb_dsp_command(devc, 0xa0 | bits); /* Mono input */
494 else
495 sb_dsp_command(devc, 0xa8 | bits); /* Stereo input */
496 restore_flags(flags);
497
498 devc->trigger_bits = 0;
499 return 0;
500 }
501
502 static int sbpro_audio_prepare_for_output(int dev, int bsize, int bcount)
503 { /* For SB Pro and Jazz16 */
504 sb_devc *devc = audio_devs[dev]->devc;
505 unsigned long flags;
506 unsigned char tmp;
507 unsigned char bits = 0;
508
509 if (devc->dma16 >= 0 && devc->dma16 != devc->dma8)
510 audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = devc->bits == 16 ? devc->dma16 : devc->dma8;
511 if (devc->model == MDL_SBPRO)
512 sb_mixer_set_stereo(devc, devc->channels == 2);
513
514 save_flags(flags);
515 cli();
516 if (sb_dsp_command(devc, 0x40))
517 sb_dsp_command(devc, devc->tconst);
518 sb_dsp_command(devc, DSP_CMD_SPKON);
519
520 if (devc->model == MDL_JAZZ || devc->model == MDL_SMW)
521 {
522 if (devc->bits == AFMT_S16_LE)
523 bits = 0x04; /* 16 bit mode */
524
525 if (devc->channels == 1)
526 sb_dsp_command(devc, 0xa0 | bits); /* Mono output */
527 else
528 sb_dsp_command(devc, 0xa8 | bits); /* Stereo output */
529 }
530 else
531 {
532 tmp = sb_getmixer(devc, 0x0e);
533 if (devc->channels == 1)
534 tmp &= ~0x02;
535 else
536 tmp |= 0x02;
537 sb_setmixer(devc, 0x0e, tmp);
538 }
539 restore_flags(flags);
540 devc->trigger_bits = 0;
541 return 0;
542 }
543
544 static int sbpro_audio_set_speed(int dev, int speed)
545 {
546 sb_devc *devc = audio_devs[dev]->devc;
547
548 if (speed > 0)
549 {
550 if (speed < 4000)
551 speed = 4000;
552 if (speed > 44100)
553 speed = 44100;
554 if (devc->channels > 1 && speed > 22050)
555 speed = 22050;
556 sb201_audio_set_speed(dev, speed);
557 }
558 return devc->speed;
559 }
560
561 static short sbpro_audio_set_channels(int dev, short channels)
562 {
563 sb_devc *devc = audio_devs[dev]->devc;
564
565 if (channels == 1 || channels == 2)
566 {
567 if (channels != devc->channels)
568 {
569 devc->channels = channels;
570 if (devc->model == MDL_SBPRO && devc->channels == 2)
571 sbpro_audio_set_speed(dev, devc->speed);
572 }
573 }
574 return devc->channels;
575 }
576
577 static int jazz16_audio_set_speed(int dev, int speed)
578 {
579 sb_devc *devc = audio_devs[dev]->devc;
580
581 if (speed > 0)
582 {
583 int tmp;
584 int s = speed * devc->channels;
585
586 if (speed < 5000)
587 speed = 5000;
588 if (speed > 44100)
589 speed = 44100;
590
591 devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff;
592
593 tmp = 256 - devc->tconst;
594 speed = ((1000000 + tmp / 2) / tmp) / devc->channels;
595
596 devc->speed = speed;
597 }
598 return devc->speed;
599 }
600
601 /*
602 * SB16 specific routines
603 */
604
605 static int sb16_audio_set_speed(int dev, int speed)
606 {
607 sb_devc *devc = audio_devs[dev]->devc;
608 int max_speed = devc->submodel == SUBMDL_ALS100 ? 48000 : 44100;
609
610 if (speed > 0)
611 {
612 if (speed < 5000) /* which of these */
613 speed = 4000; /* is correct ??? */
614
615 if (speed > max_speed)
616 speed = max_speed;
617
618 devc->speed = speed;
619 }
620 return devc->speed;
621 }
622
623 static unsigned int sb16_audio_set_bits(int dev, unsigned int bits)
624 {
625 sb_devc *devc = audio_devs[dev]->devc;
626
627 if (bits != 0)
628 {
629 if (bits == AFMT_U8 || bits == AFMT_S16_LE)
630 devc->bits = bits;
631 else
632 devc->bits = AFMT_U8;
633 }
634
635 return devc->bits;
636 }
637
638 static int sb16_audio_prepare_for_input(int dev, int bsize, int bcount)
639 {
640 sb_devc *devc = audio_devs[dev]->devc;
641
642 if (!devc->fullduplex)
643 {
644 audio_devs[dev]->dmap_out->dma =
645 audio_devs[dev]->dmap_in->dma =
646 devc->bits == AFMT_S16_LE ?
647 devc->dma16 : devc->dma8;
648 }
649 else if (devc->bits == AFMT_S16_LE)
650 {
651 audio_devs[dev]->dmap_out->dma = devc->dma8;
652 audio_devs[dev]->dmap_in->dma = devc->dma16;
653 }
654 else
655 {
656 audio_devs[dev]->dmap_out->dma = devc->dma16;
657 audio_devs[dev]->dmap_in->dma = devc->dma8;
658 }
659
660 devc->trigger_bits = 0;
661 return 0;
662 }
663
664 static int sb16_audio_prepare_for_output(int dev, int bsize, int bcount)
665 {
666 sb_devc *devc = audio_devs[dev]->devc;
667
668 if (!devc->fullduplex)
669 {
670 audio_devs[dev]->dmap_out->dma =
671 audio_devs[dev]->dmap_in->dma =
672 devc->bits == AFMT_S16_LE ?
673 devc->dma16 : devc->dma8;
674 }
675 else if (devc->bits == AFMT_S16_LE)
676 {
677 audio_devs[dev]->dmap_out->dma = devc->dma8;
678 audio_devs[dev]->dmap_in->dma = devc->dma16;
679 }
680 else
681 {
682 audio_devs[dev]->dmap_out->dma = devc->dma16;
683 audio_devs[dev]->dmap_in->dma = devc->dma8;
684 }
685
686 devc->trigger_bits = 0;
687 return 0;
688 }
689
690 static void sb16_audio_output_block(int dev, unsigned long buf, int count,
691 int intrflag)
692 {
693 unsigned long flags, cnt;
694 sb_devc *devc = audio_devs[dev]->devc;
695 unsigned long bits;
696
697 if (!devc->fullduplex || devc->bits == AFMT_S16_LE)
698 {
699 devc->irq_mode = IMODE_OUTPUT;
700 devc->intr_active = 1;
701 }
702 else
703 {
704 devc->irq_mode_16 = IMODE_OUTPUT;
705 devc->intr_active_16 = 1;
706 }
707
708 /* save value */
709 save_flags (flags);
710 cli ();
711 bits = devc->bits;
712 if (devc->fullduplex)
713 devc->bits = (devc->bits == AFMT_S16_LE) ?
714 AFMT_U8 : AFMT_S16_LE;
715 restore_flags (flags);
716
717 cnt = count;
718 if (devc->bits == AFMT_S16_LE)
719 cnt >>= 1;
720 cnt--;
721
722 save_flags(flags);
723 cli();
724
725 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */
726
727 sb_dsp_command(devc, 0x41);
728 sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff));
729 sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff));
730
731 sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xb6 : 0xc6));
732 sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) +
733 (devc->bits == AFMT_S16_LE ? 0x10 : 0)));
734 sb_dsp_command(devc, (unsigned char) (cnt & 0xff));
735 sb_dsp_command(devc, (unsigned char) (cnt >> 8));
736
737 /* restore real value after all programming */
738 devc->bits = bits;
739 restore_flags(flags);
740 }
741
742
743 /*
744 * This fails on the Cyrix MediaGX. If you don't have the DMA enabled
745 * before the first sample arrives it locks up. However even if you
746 * do enable the DMA in time you just get DMA timeouts and missing
747 * interrupts and stuff, so for now I've not bothered fixing this either.
748 */
749
750 static void sb16_audio_start_input(int dev, unsigned long buf, int count, int intrflag)
751 {
752 unsigned long flags, cnt;
753 sb_devc *devc = audio_devs[dev]->devc;
754
755 if (!devc->fullduplex || devc->bits != AFMT_S16_LE)
756 {
757 devc->irq_mode = IMODE_INPUT;
758 devc->intr_active = 1;
759 }
760 else
761 {
762 devc->irq_mode_16 = IMODE_INPUT;
763 devc->intr_active_16 = 1;
764 }
765
766 cnt = count;
767 if (devc->bits == AFMT_S16_LE)
768 cnt >>= 1;
769 cnt--;
770
771 save_flags(flags);
772 cli();
773
774 /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */
775
776 sb_dsp_command(devc, 0x42);
777 sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff));
778 sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff));
779
780 sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xbe : 0xce));
781 sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) +
782 (devc->bits == AFMT_S16_LE ? 0x10 : 0)));
783 sb_dsp_command(devc, (unsigned char) (cnt & 0xff));
784 sb_dsp_command(devc, (unsigned char) (cnt >> 8));
785
786 restore_flags(flags);
787 }
788
789 static void sb16_audio_trigger(int dev, int bits)
790 {
791 sb_devc *devc = audio_devs[dev]->devc;
792
793 int bits_16 = bits & devc->irq_mode_16;
794 bits &= devc->irq_mode;
795
796 if (!bits && !bits_16)
797 sb_dsp_command(devc, 0xd0); /* Halt DMA */
798 else
799 {
800 if (bits)
801 {
802 switch (devc->irq_mode)
803 {
804 case IMODE_INPUT:
805 sb16_audio_start_input(dev,
806 devc->trg_buf,
807 devc->trg_bytes,
808 devc->trg_intrflag);
809 break;
810
811 case IMODE_OUTPUT:
812 sb16_audio_output_block(dev,
813 devc->trg_buf,
814 devc->trg_bytes,
815 devc->trg_intrflag);
816 break;
817 }
818 }
819 if (bits_16)
820 {
821 switch (devc->irq_mode_16)
822 {
823 case IMODE_INPUT:
824 sb16_audio_start_input(dev,
825 devc->trg_buf_16,
826 devc->trg_bytes_16,
827 devc->trg_intrflag_16);
828 break;
829
830 case IMODE_OUTPUT:
831 sb16_audio_output_block(dev,
832 devc->trg_buf_16,
833 devc->trg_bytes_16,
834 devc->trg_intrflag_16);
835 break;
836 }
837 }
838 }
839
840 devc->trigger_bits = bits | bits_16;
841 }
842
843 static unsigned char lbuf8[2048];
844 static signed short *lbuf16 = (signed short *)lbuf8;
845 #define LBUFCOPYSIZE 1024
846 static void
847 sb16_copy_from_user(int dev,
848 char *localbuf, int localoffs,
849 const char *userbuf, int useroffs,
850 int max_in, int max_out,
851 int *used, int *returned,
852 int len)
853 {
854 sb_devc *devc = audio_devs[dev]->devc;
855 int i, c, p, locallen;
856 unsigned char *buf8;
857 signed short *buf16;
858
859 /* if not duplex no conversion */
860 if (!devc->fullduplex)
861 {
862 copy_from_user (localbuf + localoffs, userbuf + useroffs, len);
863 *used = len;
864 *returned = len;
865 }
866 else if (devc->bits == AFMT_S16_LE)
867 {
868 /* 16 -> 8 */
869 /* max_in >> 1, max number of samples in ( 16 bits ) */
870 /* max_out, max number of samples out ( 8 bits ) */
871 /* len, number of samples that will be taken ( 16 bits )*/
872 /* c, count of samples remaining in buffer ( 16 bits )*/
873 /* p, count of samples already processed ( 16 bits )*/
874 len = ( (max_in >> 1) > max_out) ? max_out : (max_in >> 1);
875 c = len;
876 p = 0;
877 buf8 = (unsigned char *)(localbuf + localoffs);
878 while (c)
879 {
880 locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c);
881 /* << 1 in order to get 16 bit samples */
882 copy_from_user (lbuf16,
883 userbuf+useroffs + (p << 1),
884 locallen << 1);
885 for (i = 0; i < locallen; i++)
886 {
887 buf8[p+i] = ~((lbuf16[i] >> 8) & 0xff) ^ 0x80;
888 }
889 c -= locallen; p += locallen;
890 }
891 /* used = ( samples * 16 bits size ) */
892 *used = len << 1;
893 /* returned = ( samples * 8 bits size ) */
894 *returned = len;
895 }
896 else
897 {
898 /* 8 -> 16 */
899 /* max_in, max number of samples in ( 8 bits ) */
900 /* max_out >> 1, max number of samples out ( 16 bits ) */
901 /* len, number of samples that will be taken ( 8 bits )*/
902 /* c, count of samples remaining in buffer ( 8 bits )*/
903 /* p, count of samples already processed ( 8 bits )*/
904 len = max_in > (max_out >> 1) ? (max_out >> 1) : max_in;
905 c = len;
906 p = 0;
907 buf16 = (signed short *)(localbuf + localoffs);
908 while (c)
909 {
910 locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c);
911 copy_from_user (lbuf8,
912 userbuf+useroffs + p,
913 locallen);
914 for (i = 0; i < locallen; i++)
915 {
916 buf16[p+i] = (~lbuf8[i] ^ 0x80) << 8;
917 }
918 c -= locallen; p += locallen;
919 }
920 /* used = ( samples * 8 bits size ) */
921 *used = len;
922 /* returned = ( samples * 16 bits size ) */
923 *returned = len << 1;
924 }
925 }
926
927 static void
928 sb16_audio_mmap(int dev)
929 {
930 sb_devc *devc = audio_devs[dev]->devc;
931 devc->fullduplex = 0;
932 }
933
934 static struct audio_driver sb1_audio_driver = /* SB1.x */
935 {
936 owner: THIS_MODULE,
937 open: sb_audio_open,
938 close: sb_audio_close,
939 output_block: sb_set_output_parms,
940 start_input: sb_set_input_parms,
941 prepare_for_input: sb1_audio_prepare_for_input,
942 prepare_for_output: sb1_audio_prepare_for_output,
943 halt_io: sb1_audio_halt_xfer,
944 trigger: sb1_audio_trigger,
945 set_speed: sb1_audio_set_speed,
946 set_bits: sb1_audio_set_bits,
947 set_channels: sb1_audio_set_channels
948 };
949
950 static struct audio_driver sb20_audio_driver = /* SB2.0 */
951 {
952 owner: THIS_MODULE,
953 open: sb_audio_open,
954 close: sb_audio_close,
955 output_block: sb_set_output_parms,
956 start_input: sb_set_input_parms,
957 prepare_for_input: sb1_audio_prepare_for_input,
958 prepare_for_output: sb1_audio_prepare_for_output,
959 halt_io: sb1_audio_halt_xfer,
960 trigger: sb20_audio_trigger,
961 set_speed: sb1_audio_set_speed,
962 set_bits: sb1_audio_set_bits,
963 set_channels: sb1_audio_set_channels
964 };
965
966 static struct audio_driver sb201_audio_driver = /* SB2.01 */
967 {
968 owner: THIS_MODULE,
969 open: sb_audio_open,
970 close: sb_audio_close,
971 output_block: sb_set_output_parms,
972 start_input: sb_set_input_parms,
973 prepare_for_input: sb1_audio_prepare_for_input,
974 prepare_for_output: sb1_audio_prepare_for_output,
975 halt_io: sb1_audio_halt_xfer,
976 trigger: sb20_audio_trigger,
977 set_speed: sb201_audio_set_speed,
978 set_bits: sb1_audio_set_bits,
979 set_channels: sb1_audio_set_channels
980 };
981
982 static struct audio_driver sbpro_audio_driver = /* SB Pro */
983 {
984 owner: THIS_MODULE,
985 open: sb_audio_open,
986 close: sb_audio_close,
987 output_block: sb_set_output_parms,
988 start_input: sb_set_input_parms,
989 prepare_for_input: sbpro_audio_prepare_for_input,
990 prepare_for_output: sbpro_audio_prepare_for_output,
991 halt_io: sb1_audio_halt_xfer,
992 trigger: sb20_audio_trigger,
993 set_speed: sbpro_audio_set_speed,
994 set_bits: sb1_audio_set_bits,
995 set_channels: sbpro_audio_set_channels
996 };
997
998 static struct audio_driver jazz16_audio_driver = /* Jazz16 and SM Wave */
999 {
1000 owner: THIS_MODULE,
1001 open: sb_audio_open,
1002 close: sb_audio_close,
1003 output_block: sb_set_output_parms,
1004 start_input: sb_set_input_parms,
1005 prepare_for_input: sbpro_audio_prepare_for_input,
1006 prepare_for_output: sbpro_audio_prepare_for_output,
1007 halt_io: sb1_audio_halt_xfer,
1008 trigger: sb20_audio_trigger,
1009 set_speed: jazz16_audio_set_speed,
1010 set_bits: sb16_audio_set_bits,
1011 set_channels: sbpro_audio_set_channels
1012 };
1013
1014 static struct audio_driver sb16_audio_driver = /* SB16 */
1015 {
1016 owner: THIS_MODULE,
1017 open: sb_audio_open,
1018 close: sb_audio_close,
1019 output_block: sb_set_output_parms,
1020 start_input: sb_set_input_parms,
1021 prepare_for_input: sb16_audio_prepare_for_input,
1022 prepare_for_output: sb16_audio_prepare_for_output,
1023 halt_io: sb1_audio_halt_xfer,
1024 copy_user: sb16_copy_from_user,
1025 trigger: sb16_audio_trigger,
1026 set_speed: sb16_audio_set_speed,
1027 set_bits: sb16_audio_set_bits,
1028 set_channels: sbpro_audio_set_channels,
1029 mmap: sb16_audio_mmap
1030 };
1031
1032 void sb_audio_init(sb_devc * devc, char *name, struct module *owner)
1033 {
1034 int audio_flags = 0;
1035 int format_mask = AFMT_U8;
1036
1037 struct audio_driver *driver = &sb1_audio_driver;
1038
1039 switch (devc->model)
1040 {
1041 case MDL_SB1: /* SB1.0 or SB 1.5 */
1042 DDB(printk("Will use standard SB1.x driver\n"));
1043 audio_flags = DMA_HARDSTOP;
1044 break;
1045
1046 case MDL_SB2:
1047 DDB(printk("Will use SB2.0 driver\n"));
1048 audio_flags = DMA_AUTOMODE;
1049 driver = &sb20_audio_driver;
1050 break;
1051
1052 case MDL_SB201:
1053 DDB(printk("Will use SB2.01 (high speed) driver\n"));
1054 audio_flags = DMA_AUTOMODE;
1055 driver = &sb201_audio_driver;
1056 break;
1057
1058 case MDL_JAZZ:
1059 case MDL_SMW:
1060 DDB(printk("Will use Jazz16 driver\n"));
1061 audio_flags = DMA_AUTOMODE;
1062 format_mask |= AFMT_S16_LE;
1063 driver = &jazz16_audio_driver;
1064 break;
1065
1066 case MDL_ESS:
1067 DDB(printk("Will use ESS ES688/1688 driver\n"));
1068 driver = ess_audio_init (devc, &audio_flags, &format_mask);
1069 break;
1070
1071 case MDL_SB16:
1072 DDB(printk("Will use SB16 driver\n"));
1073 audio_flags = DMA_AUTOMODE;
1074 format_mask |= AFMT_S16_LE;
1075 if (devc->dma8 != devc->dma16 && devc->dma16 != -1)
1076 {
1077 audio_flags |= DMA_DUPLEX;
1078 devc->duplex = 1;
1079 }
1080 driver = &sb16_audio_driver;
1081 break;
1082
1083 default:
1084 DDB(printk("Will use SB Pro driver\n"));
1085 audio_flags = DMA_AUTOMODE;
1086 driver = &sbpro_audio_driver;
1087 }
1088
1089 if (owner)
1090 driver->owner = owner;
1091
1092 if ((devc->dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION,
1093 name,driver, sizeof(struct audio_driver),
1094 audio_flags, format_mask, devc,
1095 devc->dma8,
1096 devc->duplex ? devc->dma16 : devc->dma8)) < 0)
1097 {
1098 printk(KERN_ERR "Sound Blaster: unable to install audio.\n");
1099 return;
1100 }
1101 audio_devs[devc->dev]->mixer_dev = devc->my_mixerdev;
1102 audio_devs[devc->dev]->min_fragment = 5;
1103 }
1104
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.