Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
f30c2269 | 2 | * sound/oss/sb_audio.c |
1da177e4 LT |
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; | |
379170a4 | 445 | int s; |
1da177e4 LT |
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; | |
379170a4 | 455 | s = speed * devc->channels; |
1da177e4 LT |
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; | |
94f3ec6b | 579 | int s; |
1da177e4 LT |
580 | |
581 | if (speed < 5000) | |
582 | speed = 5000; | |
583 | if (speed > 44100) | |
584 | speed = 44100; | |
585 | ||
94f3ec6b DC |
586 | s = speed * devc->channels; |
587 | ||
1da177e4 LT |
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 | } |