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