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