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