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; |
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 | s = speed * devc->channels; |
456 | devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff; |
457 | tmp = 256 - devc->tconst; |
458 | speed = ((1000000 + tmp / 2) / tmp) / devc->channels; |
459 | |
460 | devc->speed = speed; |
461 | } |
462 | return devc->speed; |
463 | } |
464 | |
465 | /* |
466 | * SB Pro specific routines |
467 | */ |
468 | |
469 | static int sbpro_audio_prepare_for_input(int dev, int bsize, int bcount) |
470 | { /* For SB Pro and Jazz16 */ |
471 | sb_devc *devc = audio_devs[dev]->devc; |
472 | unsigned long flags; |
473 | unsigned char bits = 0; |
474 | |
475 | if (devc->dma16 >= 0 && devc->dma16 != devc->dma8) |
476 | audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = |
477 | devc->bits == 16 ? devc->dma16 : devc->dma8; |
478 | |
479 | if (devc->model == MDL_JAZZ || devc->model == MDL_SMW) |
480 | if (devc->bits == AFMT_S16_LE) |
481 | bits = 0x04; /* 16 bit mode */ |
482 | |
483 | spin_lock_irqsave(&devc->lock, flags); |
484 | if (sb_dsp_command(devc, 0x40)) |
485 | sb_dsp_command(devc, devc->tconst); |
486 | sb_dsp_command(devc, DSP_CMD_SPKOFF); |
487 | if (devc->channels == 1) |
488 | sb_dsp_command(devc, 0xa0 | bits); /* Mono input */ |
489 | else |
490 | sb_dsp_command(devc, 0xa8 | bits); /* Stereo input */ |
491 | spin_unlock_irqrestore(&devc->lock, flags); |
492 | |
493 | devc->trigger_bits = 0; |
494 | return 0; |
495 | } |
496 | |
497 | static int sbpro_audio_prepare_for_output(int dev, int bsize, int bcount) |
498 | { /* For SB Pro and Jazz16 */ |
499 | sb_devc *devc = audio_devs[dev]->devc; |
500 | unsigned long flags; |
501 | unsigned char tmp; |
502 | unsigned char bits = 0; |
503 | |
504 | if (devc->dma16 >= 0 && devc->dma16 != devc->dma8) |
505 | audio_devs[dev]->dmap_out->dma = audio_devs[dev]->dmap_in->dma = devc->bits == 16 ? devc->dma16 : devc->dma8; |
506 | if (devc->model == MDL_SBPRO) |
507 | sb_mixer_set_stereo(devc, devc->channels == 2); |
508 | |
509 | spin_lock_irqsave(&devc->lock, flags); |
510 | if (sb_dsp_command(devc, 0x40)) |
511 | sb_dsp_command(devc, devc->tconst); |
512 | sb_dsp_command(devc, DSP_CMD_SPKON); |
513 | |
514 | if (devc->model == MDL_JAZZ || devc->model == MDL_SMW) |
515 | { |
516 | if (devc->bits == AFMT_S16_LE) |
517 | bits = 0x04; /* 16 bit mode */ |
518 | |
519 | if (devc->channels == 1) |
520 | sb_dsp_command(devc, 0xa0 | bits); /* Mono output */ |
521 | else |
522 | sb_dsp_command(devc, 0xa8 | bits); /* Stereo output */ |
523 | spin_unlock_irqrestore(&devc->lock, flags); |
524 | } |
525 | else |
526 | { |
527 | spin_unlock_irqrestore(&devc->lock, flags); |
528 | tmp = sb_getmixer(devc, 0x0e); |
529 | if (devc->channels == 1) |
530 | tmp &= ~0x02; |
531 | else |
532 | tmp |= 0x02; |
533 | sb_setmixer(devc, 0x0e, tmp); |
534 | } |
535 | devc->trigger_bits = 0; |
536 | return 0; |
537 | } |
538 | |
539 | static int sbpro_audio_set_speed(int dev, int speed) |
540 | { |
541 | sb_devc *devc = audio_devs[dev]->devc; |
542 | |
543 | if (speed > 0) |
544 | { |
545 | if (speed < 4000) |
546 | speed = 4000; |
547 | if (speed > 44100) |
548 | speed = 44100; |
549 | if (devc->channels > 1 && speed > 22050) |
550 | speed = 22050; |
551 | sb201_audio_set_speed(dev, speed); |
552 | } |
553 | return devc->speed; |
554 | } |
555 | |
556 | static short sbpro_audio_set_channels(int dev, short channels) |
557 | { |
558 | sb_devc *devc = audio_devs[dev]->devc; |
559 | |
560 | if (channels == 1 || channels == 2) |
561 | { |
562 | if (channels != devc->channels) |
563 | { |
564 | devc->channels = channels; |
565 | if (devc->model == MDL_SBPRO && devc->channels == 2) |
566 | sbpro_audio_set_speed(dev, devc->speed); |
567 | } |
568 | } |
569 | return devc->channels; |
570 | } |
571 | |
572 | static int jazz16_audio_set_speed(int dev, int speed) |
573 | { |
574 | sb_devc *devc = audio_devs[dev]->devc; |
575 | |
576 | if (speed > 0) |
577 | { |
578 | int tmp; |
579 | int s; |
580 | |
581 | if (speed < 5000) |
582 | speed = 5000; |
583 | if (speed > 44100) |
584 | speed = 44100; |
585 | |
586 | s = speed * devc->channels; |
587 | |
588 | devc->tconst = (256 - ((1000000 + s / 2) / s)) & 0xff; |
589 | |
590 | tmp = 256 - devc->tconst; |
591 | speed = ((1000000 + tmp / 2) / tmp) / devc->channels; |
592 | |
593 | devc->speed = speed; |
594 | } |
595 | return devc->speed; |
596 | } |
597 | |
598 | /* |
599 | * SB16 specific routines |
600 | */ |
601 | |
602 | static int sb16_audio_set_speed(int dev, int speed) |
603 | { |
604 | sb_devc *devc = audio_devs[dev]->devc; |
605 | int max_speed = devc->submodel == SUBMDL_ALS100 ? 48000 : 44100; |
606 | |
607 | if (speed > 0) |
608 | { |
609 | if (speed < 5000) |
610 | speed = 5000; |
611 | |
612 | if (speed > max_speed) |
613 | speed = max_speed; |
614 | |
615 | devc->speed = speed; |
616 | } |
617 | return devc->speed; |
618 | } |
619 | |
620 | static unsigned int sb16_audio_set_bits(int dev, unsigned int bits) |
621 | { |
622 | sb_devc *devc = audio_devs[dev]->devc; |
623 | |
624 | if (bits != 0) |
625 | { |
626 | if (bits == AFMT_U8 || bits == AFMT_S16_LE) |
627 | devc->bits = bits; |
628 | else |
629 | devc->bits = AFMT_U8; |
630 | } |
631 | |
632 | return devc->bits; |
633 | } |
634 | |
635 | static int sb16_audio_prepare_for_input(int dev, int bsize, int bcount) |
636 | { |
637 | sb_devc *devc = audio_devs[dev]->devc; |
638 | |
639 | if (!devc->fullduplex) |
640 | { |
641 | audio_devs[dev]->dmap_out->dma = |
642 | audio_devs[dev]->dmap_in->dma = |
643 | devc->bits == AFMT_S16_LE ? |
644 | devc->dma16 : devc->dma8; |
645 | } |
646 | else if (devc->bits == AFMT_S16_LE) |
647 | { |
648 | audio_devs[dev]->dmap_out->dma = devc->dma8; |
649 | audio_devs[dev]->dmap_in->dma = devc->dma16; |
650 | } |
651 | else |
652 | { |
653 | audio_devs[dev]->dmap_out->dma = devc->dma16; |
654 | audio_devs[dev]->dmap_in->dma = devc->dma8; |
655 | } |
656 | |
657 | devc->trigger_bits = 0; |
658 | return 0; |
659 | } |
660 | |
661 | static int sb16_audio_prepare_for_output(int dev, int bsize, int bcount) |
662 | { |
663 | sb_devc *devc = audio_devs[dev]->devc; |
664 | |
665 | if (!devc->fullduplex) |
666 | { |
667 | audio_devs[dev]->dmap_out->dma = |
668 | audio_devs[dev]->dmap_in->dma = |
669 | devc->bits == AFMT_S16_LE ? |
670 | devc->dma16 : devc->dma8; |
671 | } |
672 | else if (devc->bits == AFMT_S16_LE) |
673 | { |
674 | audio_devs[dev]->dmap_out->dma = devc->dma8; |
675 | audio_devs[dev]->dmap_in->dma = devc->dma16; |
676 | } |
677 | else |
678 | { |
679 | audio_devs[dev]->dmap_out->dma = devc->dma16; |
680 | audio_devs[dev]->dmap_in->dma = devc->dma8; |
681 | } |
682 | |
683 | devc->trigger_bits = 0; |
684 | return 0; |
685 | } |
686 | |
687 | static void sb16_audio_output_block(int dev, unsigned long buf, int count, |
688 | int intrflag) |
689 | { |
690 | unsigned long flags, cnt; |
691 | sb_devc *devc = audio_devs[dev]->devc; |
692 | unsigned long bits; |
693 | |
694 | if (!devc->fullduplex || devc->bits == AFMT_S16_LE) |
695 | { |
696 | devc->irq_mode = IMODE_OUTPUT; |
697 | devc->intr_active = 1; |
698 | } |
699 | else |
700 | { |
701 | devc->irq_mode_16 = IMODE_OUTPUT; |
702 | devc->intr_active_16 = 1; |
703 | } |
704 | |
705 | /* save value */ |
706 | spin_lock_irqsave(&devc->lock, flags); |
707 | bits = devc->bits; |
708 | if (devc->fullduplex) |
709 | devc->bits = (devc->bits == AFMT_S16_LE) ? |
710 | AFMT_U8 : AFMT_S16_LE; |
711 | spin_unlock_irqrestore(&devc->lock, flags); |
712 | |
713 | cnt = count; |
714 | if (devc->bits == AFMT_S16_LE) |
715 | cnt >>= 1; |
716 | cnt--; |
717 | |
718 | spin_lock_irqsave(&devc->lock, flags); |
719 | |
720 | /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_WRITE); */ |
721 | |
722 | sb_dsp_command(devc, 0x41); |
723 | sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff)); |
724 | sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff)); |
725 | |
726 | sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xb6 : 0xc6)); |
727 | sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) + |
728 | (devc->bits == AFMT_S16_LE ? 0x10 : 0))); |
729 | sb_dsp_command(devc, (unsigned char) (cnt & 0xff)); |
730 | sb_dsp_command(devc, (unsigned char) (cnt >> 8)); |
731 | |
732 | /* restore real value after all programming */ |
733 | devc->bits = bits; |
734 | spin_unlock_irqrestore(&devc->lock, flags); |
735 | } |
736 | |
737 | |
738 | /* |
739 | * This fails on the Cyrix MediaGX. If you don't have the DMA enabled |
740 | * before the first sample arrives it locks up. However even if you |
741 | * do enable the DMA in time you just get DMA timeouts and missing |
742 | * interrupts and stuff, so for now I've not bothered fixing this either. |
743 | */ |
744 | |
745 | static void sb16_audio_start_input(int dev, unsigned long buf, int count, int intrflag) |
746 | { |
747 | unsigned long flags, cnt; |
748 | sb_devc *devc = audio_devs[dev]->devc; |
749 | |
750 | if (!devc->fullduplex || devc->bits != AFMT_S16_LE) |
751 | { |
752 | devc->irq_mode = IMODE_INPUT; |
753 | devc->intr_active = 1; |
754 | } |
755 | else |
756 | { |
757 | devc->irq_mode_16 = IMODE_INPUT; |
758 | devc->intr_active_16 = 1; |
759 | } |
760 | |
761 | cnt = count; |
762 | if (devc->bits == AFMT_S16_LE) |
763 | cnt >>= 1; |
764 | cnt--; |
765 | |
766 | spin_lock_irqsave(&devc->lock, flags); |
767 | |
768 | /* DMAbuf_start_dma (dev, buf, count, DMA_MODE_READ); */ |
769 | |
770 | sb_dsp_command(devc, 0x42); |
771 | sb_dsp_command(devc, (unsigned char) ((devc->speed >> 8) & 0xff)); |
772 | sb_dsp_command(devc, (unsigned char) (devc->speed & 0xff)); |
773 | |
774 | sb_dsp_command(devc, (devc->bits == AFMT_S16_LE ? 0xbe : 0xce)); |
775 | sb_dsp_command(devc, ((devc->channels == 2 ? 0x20 : 0) + |
776 | (devc->bits == AFMT_S16_LE ? 0x10 : 0))); |
777 | sb_dsp_command(devc, (unsigned char) (cnt & 0xff)); |
778 | sb_dsp_command(devc, (unsigned char) (cnt >> 8)); |
779 | |
780 | spin_unlock_irqrestore(&devc->lock, flags); |
781 | } |
782 | |
783 | static void sb16_audio_trigger(int dev, int bits) |
784 | { |
785 | sb_devc *devc = audio_devs[dev]->devc; |
786 | |
787 | int bits_16 = bits & devc->irq_mode_16; |
788 | bits &= devc->irq_mode; |
789 | |
790 | if (!bits && !bits_16) |
791 | sb_dsp_command(devc, 0xd0); /* Halt DMA */ |
792 | else |
793 | { |
794 | if (bits) |
795 | { |
796 | switch (devc->irq_mode) |
797 | { |
798 | case IMODE_INPUT: |
799 | sb16_audio_start_input(dev, |
800 | devc->trg_buf, |
801 | devc->trg_bytes, |
802 | devc->trg_intrflag); |
803 | break; |
804 | |
805 | case IMODE_OUTPUT: |
806 | sb16_audio_output_block(dev, |
807 | devc->trg_buf, |
808 | devc->trg_bytes, |
809 | devc->trg_intrflag); |
810 | break; |
811 | } |
812 | } |
813 | if (bits_16) |
814 | { |
815 | switch (devc->irq_mode_16) |
816 | { |
817 | case IMODE_INPUT: |
818 | sb16_audio_start_input(dev, |
819 | devc->trg_buf_16, |
820 | devc->trg_bytes_16, |
821 | devc->trg_intrflag_16); |
822 | break; |
823 | |
824 | case IMODE_OUTPUT: |
825 | sb16_audio_output_block(dev, |
826 | devc->trg_buf_16, |
827 | devc->trg_bytes_16, |
828 | devc->trg_intrflag_16); |
829 | break; |
830 | } |
831 | } |
832 | } |
833 | |
834 | devc->trigger_bits = bits | bits_16; |
835 | } |
836 | |
837 | static unsigned char lbuf8[2048]; |
838 | static signed short *lbuf16 = (signed short *)lbuf8; |
839 | #define LBUFCOPYSIZE 1024 |
840 | static void |
841 | sb16_copy_from_user(int dev, |
842 | char *localbuf, int localoffs, |
843 | const char __user *userbuf, int useroffs, |
844 | int max_in, int max_out, |
845 | int *used, int *returned, |
846 | int len) |
847 | { |
848 | sb_devc *devc = audio_devs[dev]->devc; |
849 | int i, c, p, locallen; |
850 | unsigned char *buf8; |
851 | signed short *buf16; |
852 | |
853 | /* if not duplex no conversion */ |
854 | if (!devc->fullduplex) |
855 | { |
856 | if (copy_from_user(localbuf + localoffs, |
857 | userbuf + useroffs, len)) |
858 | return; |
859 | *used = len; |
860 | *returned = len; |
861 | } |
862 | else if (devc->bits == AFMT_S16_LE) |
863 | { |
864 | /* 16 -> 8 */ |
865 | /* max_in >> 1, max number of samples in ( 16 bits ) */ |
866 | /* max_out, max number of samples out ( 8 bits ) */ |
867 | /* len, number of samples that will be taken ( 16 bits )*/ |
868 | /* c, count of samples remaining in buffer ( 16 bits )*/ |
869 | /* p, count of samples already processed ( 16 bits )*/ |
870 | len = ( (max_in >> 1) > max_out) ? max_out : (max_in >> 1); |
871 | c = len; |
872 | p = 0; |
873 | buf8 = (unsigned char *)(localbuf + localoffs); |
874 | while (c) |
875 | { |
876 | locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c); |
877 | /* << 1 in order to get 16 bit samples */ |
878 | if (copy_from_user(lbuf16, |
879 | userbuf + useroffs + (p << 1), |
880 | locallen << 1)) |
881 | return; |
882 | for (i = 0; i < locallen; i++) |
883 | { |
884 | buf8[p+i] = ~((lbuf16[i] >> 8) & 0xff) ^ 0x80; |
885 | } |
886 | c -= locallen; p += locallen; |
887 | } |
888 | /* used = ( samples * 16 bits size ) */ |
889 | *used = max_in > ( max_out << 1) ? (max_out << 1) : max_in; |
890 | /* returned = ( samples * 8 bits size ) */ |
891 | *returned = len; |
892 | } |
893 | else |
894 | { |
895 | /* 8 -> 16 */ |
896 | /* max_in, max number of samples in ( 8 bits ) */ |
897 | /* max_out >> 1, max number of samples out ( 16 bits ) */ |
898 | /* len, number of samples that will be taken ( 8 bits )*/ |
899 | /* c, count of samples remaining in buffer ( 8 bits )*/ |
900 | /* p, count of samples already processed ( 8 bits )*/ |
901 | len = max_in > (max_out >> 1) ? (max_out >> 1) : max_in; |
902 | c = len; |
903 | p = 0; |
904 | buf16 = (signed short *)(localbuf + localoffs); |
905 | while (c) |
906 | { |
907 | locallen = (c >= LBUFCOPYSIZE ? LBUFCOPYSIZE : c); |
908 | if (copy_from_user(lbuf8, |
909 | userbuf+useroffs + p, |
910 | locallen)) |
911 | return; |
912 | for (i = 0; i < locallen; i++) |
913 | { |
914 | buf16[p+i] = (~lbuf8[i] ^ 0x80) << 8; |
915 | } |
916 | c -= locallen; p += locallen; |
917 | } |
918 | /* used = ( samples * 8 bits size ) */ |
919 | *used = len; |
920 | /* returned = ( samples * 16 bits size ) */ |
921 | *returned = len << 1; |
922 | } |
923 | } |
924 | |
925 | static void |
926 | sb16_audio_mmap(int dev) |
927 | { |
928 | sb_devc *devc = audio_devs[dev]->devc; |
929 | devc->fullduplex = 0; |
930 | } |
931 | |
932 | static struct audio_driver sb1_audio_driver = /* SB1.x */ |
933 | { |
934 | .owner = THIS_MODULE, |
935 | .open = sb_audio_open, |
936 | .close = sb_audio_close, |
937 | .output_block = sb_set_output_parms, |
938 | .start_input = sb_set_input_parms, |
939 | .prepare_for_input = sb1_audio_prepare_for_input, |
940 | .prepare_for_output = sb1_audio_prepare_for_output, |
941 | .halt_io = sb1_audio_halt_xfer, |
942 | .trigger = sb1_audio_trigger, |
943 | .set_speed = sb1_audio_set_speed, |
944 | .set_bits = sb1_audio_set_bits, |
945 | .set_channels = sb1_audio_set_channels |
946 | }; |
947 | |
948 | static struct audio_driver sb20_audio_driver = /* SB2.0 */ |
949 | { |
950 | .owner = THIS_MODULE, |
951 | .open = sb_audio_open, |
952 | .close = sb_audio_close, |
953 | .output_block = sb_set_output_parms, |
954 | .start_input = sb_set_input_parms, |
955 | .prepare_for_input = sb1_audio_prepare_for_input, |
956 | .prepare_for_output = sb1_audio_prepare_for_output, |
957 | .halt_io = sb1_audio_halt_xfer, |
958 | .trigger = sb20_audio_trigger, |
959 | .set_speed = sb1_audio_set_speed, |
960 | .set_bits = sb1_audio_set_bits, |
961 | .set_channels = sb1_audio_set_channels |
962 | }; |
963 | |
964 | static struct audio_driver sb201_audio_driver = /* SB2.01 */ |
965 | { |
966 | .owner = THIS_MODULE, |
967 | .open = sb_audio_open, |
968 | .close = sb_audio_close, |
969 | .output_block = sb_set_output_parms, |
970 | .start_input = sb_set_input_parms, |
971 | .prepare_for_input = sb1_audio_prepare_for_input, |
972 | .prepare_for_output = sb1_audio_prepare_for_output, |
973 | .halt_io = sb1_audio_halt_xfer, |
974 | .trigger = sb20_audio_trigger, |
975 | .set_speed = sb201_audio_set_speed, |
976 | .set_bits = sb1_audio_set_bits, |
977 | .set_channels = sb1_audio_set_channels |
978 | }; |
979 | |
980 | static struct audio_driver sbpro_audio_driver = /* SB Pro */ |
981 | { |
982 | .owner = THIS_MODULE, |
983 | .open = sb_audio_open, |
984 | .close = sb_audio_close, |
985 | .output_block = sb_set_output_parms, |
986 | .start_input = sb_set_input_parms, |
987 | .prepare_for_input = sbpro_audio_prepare_for_input, |
988 | .prepare_for_output = sbpro_audio_prepare_for_output, |
989 | .halt_io = sb1_audio_halt_xfer, |
990 | .trigger = sb20_audio_trigger, |
991 | .set_speed = sbpro_audio_set_speed, |
992 | .set_bits = sb1_audio_set_bits, |
993 | .set_channels = sbpro_audio_set_channels |
994 | }; |
995 | |
996 | static struct audio_driver jazz16_audio_driver = /* Jazz16 and SM Wave */ |
997 | { |
998 | .owner = THIS_MODULE, |
999 | .open = sb_audio_open, |
1000 | .close = sb_audio_close, |
1001 | .output_block = sb_set_output_parms, |
1002 | .start_input = sb_set_input_parms, |
1003 | .prepare_for_input = sbpro_audio_prepare_for_input, |
1004 | .prepare_for_output = sbpro_audio_prepare_for_output, |
1005 | .halt_io = sb1_audio_halt_xfer, |
1006 | .trigger = sb20_audio_trigger, |
1007 | .set_speed = jazz16_audio_set_speed, |
1008 | .set_bits = sb16_audio_set_bits, |
1009 | .set_channels = sbpro_audio_set_channels |
1010 | }; |
1011 | |
1012 | static struct audio_driver sb16_audio_driver = /* SB16 */ |
1013 | { |
1014 | .owner = THIS_MODULE, |
1015 | .open = sb_audio_open, |
1016 | .close = sb_audio_close, |
1017 | .output_block = sb_set_output_parms, |
1018 | .start_input = sb_set_input_parms, |
1019 | .prepare_for_input = sb16_audio_prepare_for_input, |
1020 | .prepare_for_output = sb16_audio_prepare_for_output, |
1021 | .halt_io = sb1_audio_halt_xfer, |
1022 | .copy_user = sb16_copy_from_user, |
1023 | .trigger = sb16_audio_trigger, |
1024 | .set_speed = sb16_audio_set_speed, |
1025 | .set_bits = sb16_audio_set_bits, |
1026 | .set_channels = sbpro_audio_set_channels, |
1027 | .mmap = sb16_audio_mmap |
1028 | }; |
1029 | |
1030 | void sb_audio_init(sb_devc * devc, char *name, struct module *owner) |
1031 | { |
1032 | int audio_flags = 0; |
1033 | int format_mask = AFMT_U8; |
1034 | |
1035 | struct audio_driver *driver = &sb1_audio_driver; |
1036 | |
1037 | switch (devc->model) |
1038 | { |
1039 | case MDL_SB1: /* SB1.0 or SB 1.5 */ |
1040 | DDB(printk("Will use standard SB1.x driver\n")); |
1041 | audio_flags = DMA_HARDSTOP; |
1042 | break; |
1043 | |
1044 | case MDL_SB2: |
1045 | DDB(printk("Will use SB2.0 driver\n")); |
1046 | audio_flags = DMA_AUTOMODE; |
1047 | driver = &sb20_audio_driver; |
1048 | break; |
1049 | |
1050 | case MDL_SB201: |
1051 | DDB(printk("Will use SB2.01 (high speed) driver\n")); |
1052 | audio_flags = DMA_AUTOMODE; |
1053 | driver = &sb201_audio_driver; |
1054 | break; |
1055 | |
1056 | case MDL_JAZZ: |
1057 | case MDL_SMW: |
1058 | DDB(printk("Will use Jazz16 driver\n")); |
1059 | audio_flags = DMA_AUTOMODE; |
1060 | format_mask |= AFMT_S16_LE; |
1061 | driver = &jazz16_audio_driver; |
1062 | break; |
1063 | |
1064 | case MDL_ESS: |
1065 | DDB(printk("Will use ESS ES688/1688 driver\n")); |
1066 | driver = ess_audio_init (devc, &audio_flags, &format_mask); |
1067 | break; |
1068 | |
1069 | case MDL_SB16: |
1070 | DDB(printk("Will use SB16 driver\n")); |
1071 | audio_flags = DMA_AUTOMODE; |
1072 | format_mask |= AFMT_S16_LE; |
1073 | if (devc->dma8 != devc->dma16 && devc->dma16 != -1) |
1074 | { |
1075 | audio_flags |= DMA_DUPLEX; |
1076 | devc->duplex = 1; |
1077 | } |
1078 | driver = &sb16_audio_driver; |
1079 | break; |
1080 | |
1081 | default: |
1082 | DDB(printk("Will use SB Pro driver\n")); |
1083 | audio_flags = DMA_AUTOMODE; |
1084 | driver = &sbpro_audio_driver; |
1085 | } |
1086 | |
1087 | if (owner) |
1088 | driver->owner = owner; |
1089 | |
1090 | if ((devc->dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, |
1091 | name,driver, sizeof(struct audio_driver), |
1092 | audio_flags, format_mask, devc, |
1093 | devc->dma8, |
1094 | devc->duplex ? devc->dma16 : devc->dma8)) < 0) |
1095 | { |
1096 | printk(KERN_ERR "Sound Blaster: unable to install audio.\n"); |
1097 | return; |
1098 | } |
1099 | audio_devs[devc->dev]->mixer_dev = devc->my_mixerdev; |
1100 | audio_devs[devc->dev]->min_fragment = 5; |
1101 | } |
1102 |
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