?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.25.20
[linux/fpc-iii.git] / sound / isa / sb / sb8_main.c
blobfe03bb820532beed11afd25dbfe8c67959ead1fa
1 /*
2 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
3 * Uros Bizjak <uros@kss-loka.si>
4 *
5 * Routines for control of 8-bit SoundBlaster cards and clones
6 * Please note: I don't have access to old SB8 soundcards.
7 *
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 * --
24 *
25 * Thu Apr 29 20:36:17 BST 1999 George David Morrison <gdm@gedamo.demon.co.uk>
26 * DSP can't respond to commands whilst in "high speed" mode. Caused
27 * glitching during playback. Fixed.
28 *
29 * Wed Jul 12 22:02:55 CEST 2000 Uros Bizjak <uros@kss-loka.si>
30 * Cleaned up and rewrote lowlevel routines.
31 */
32
33 #include <asm/io.h>
34 #include <asm/dma.h>
35 #include <linux/init.h>
36 #include <linux/time.h>
37 #include <sound/core.h>
38 #include <sound/sb.h>
39
40 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Uros Bizjak <uros@kss-loka.si>");
41 MODULE_DESCRIPTION("Routines for control of 8-bit SoundBlaster cards and clones");
42 MODULE_LICENSE("GPL");
43
44 #define SB8_CLOCK 1000000
45 #define SB8_DEN(v) ((SB8_CLOCK + (v) / 2) / (v))
46 #define SB8_RATE(v) (SB8_CLOCK / SB8_DEN(v))
47
48 static struct snd_ratnum clock = {
49 .num = SB8_CLOCK,
50 .den_min = 1,
51 .den_max = 256,
52 .den_step = 1,
53 };
54
55 static struct snd_pcm_hw_constraint_ratnums hw_constraints_clock = {
56 .nrats = 1,
57 .rats = &clock,
58 };
59
60 static struct snd_ratnum stereo_clocks[] = {
61 {
62 .num = SB8_CLOCK,
63 .den_min = SB8_DEN(22050),
64 .den_max = SB8_DEN(22050),
65 .den_step = 1,
66 },
67 {
68 .num = SB8_CLOCK,
69 .den_min = SB8_DEN(11025),
70 .den_max = SB8_DEN(11025),
71 .den_step = 1,
72 }
73 };
74
75 static int snd_sb8_hw_constraint_rate_channels(struct snd_pcm_hw_params *params,
76 struct snd_pcm_hw_rule *rule)
77 {
78 struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
79 if (c->min > 1) {
80 unsigned int num = 0, den = 0;
81 int err = snd_interval_ratnum(hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE),
82 2, stereo_clocks, &num, &den);
83 if (err >= 0 && den) {
84 params->rate_num = num;
85 params->rate_den = den;
86 }
87 return err;
88 }
89 return 0;
90 }
91
92 static int snd_sb8_hw_constraint_channels_rate(struct snd_pcm_hw_params *params,
93 struct snd_pcm_hw_rule *rule)
94 {
95 struct snd_interval *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
96 if (r->min > SB8_RATE(22050) || r->max <= SB8_RATE(11025)) {
97 struct snd_interval t = { .min = 1, .max = 1 };
98 return snd_interval_refine(hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS), &t);
99 }
100 return 0;
101 }
102
103 static int snd_sb8_playback_prepare(struct snd_pcm_substream *substream)
104 {
105 unsigned long flags;
106 struct snd_sb *chip = snd_pcm_substream_chip(substream);
107 struct snd_pcm_runtime *runtime = substream->runtime;
108 unsigned int mixreg, rate, size, count;
109
110 rate = runtime->rate;
111 switch (chip->hardware) {
112 case SB_HW_PRO:
113 if (runtime->channels > 1) {
114 snd_assert(rate == SB8_RATE(11025) || rate == SB8_RATE(22050), return -EINVAL);
115 chip->playback_format = SB_DSP_HI_OUTPUT_AUTO;
116 break;
117 }
118 /* fallthru */
119 case SB_HW_201:
120 if (rate > 23000) {
121 chip->playback_format = SB_DSP_HI_OUTPUT_AUTO;
122 break;
123 }
124 /* fallthru */
125 case SB_HW_20:
126 chip->playback_format = SB_DSP_LO_OUTPUT_AUTO;
127 break;
128 case SB_HW_10:
129 chip->playback_format = SB_DSP_OUTPUT;
130 break;
131 default:
132 return -EINVAL;
133 }
134 size = chip->p_dma_size = snd_pcm_lib_buffer_bytes(substream);
135 count = chip->p_period_size = snd_pcm_lib_period_bytes(substream);
136 spin_lock_irqsave(&chip->reg_lock, flags);
137 snd_sbdsp_command(chip, SB_DSP_SPEAKER_ON);
138 if (runtime->channels > 1) {
139 /* set playback stereo mode */
140 spin_lock(&chip->mixer_lock);
141 mixreg = snd_sbmixer_read(chip, SB_DSP_STEREO_SW);
142 snd_sbmixer_write(chip, SB_DSP_STEREO_SW, mixreg | 0x02);
143 spin_unlock(&chip->mixer_lock);
144
145 /* Soundblaster hardware programming reference guide, 3-23 */
146 snd_sbdsp_command(chip, SB_DSP_DMA8_EXIT);
147 runtime->dma_area[0] = 0x80;
148 snd_dma_program(chip->dma8, runtime->dma_addr, 1, DMA_MODE_WRITE);
149 /* force interrupt */
150 chip->mode = SB_MODE_HALT;
151 snd_sbdsp_command(chip, SB_DSP_OUTPUT);
152 snd_sbdsp_command(chip, 0);
153 snd_sbdsp_command(chip, 0);
154 }
155 snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);
156 if (runtime->channels > 1) {
157 snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);
158 spin_lock(&chip->mixer_lock);
159 /* save output filter status and turn it off */
160 mixreg = snd_sbmixer_read(chip, SB_DSP_PLAYBACK_FILT);
161 snd_sbmixer_write(chip, SB_DSP_PLAYBACK_FILT, mixreg | 0x20);
162 spin_unlock(&chip->mixer_lock);
163 /* just use force_mode16 for temporary storate... */
164 chip->force_mode16 = mixreg;
165 } else {
166 snd_sbdsp_command(chip, 256 - runtime->rate_den);
167 }
168 if (chip->playback_format != SB_DSP_OUTPUT) {
169 count--;
170 snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);
171 snd_sbdsp_command(chip, count & 0xff);
172 snd_sbdsp_command(chip, count >> 8);
173 }
174 spin_unlock_irqrestore(&chip->reg_lock, flags);
175 snd_dma_program(chip->dma8, runtime->dma_addr,
176 size, DMA_MODE_WRITE | DMA_AUTOINIT);
177 return 0;
178 }
179
180 static int snd_sb8_playback_trigger(struct snd_pcm_substream *substream,
181 int cmd)
182 {
183 unsigned long flags;
184 struct snd_sb *chip = snd_pcm_substream_chip(substream);
185 unsigned int count;
186
187 spin_lock_irqsave(&chip->reg_lock, flags);
188 switch (cmd) {
189 case SNDRV_PCM_TRIGGER_START:
190 snd_sbdsp_command(chip, chip->playback_format);
191 if (chip->playback_format == SB_DSP_OUTPUT) {
192 count = chip->p_period_size - 1;
193 snd_sbdsp_command(chip, count & 0xff);
194 snd_sbdsp_command(chip, count >> 8);
195 }
196 break;
197 case SNDRV_PCM_TRIGGER_STOP:
198 if (chip->playback_format == SB_DSP_HI_OUTPUT_AUTO) {
199 struct snd_pcm_runtime *runtime = substream->runtime;
200 snd_sbdsp_reset(chip);
201 if (runtime->channels > 1) {
202 spin_lock(&chip->mixer_lock);
203 /* restore output filter and set hardware to mono mode */
204 snd_sbmixer_write(chip, SB_DSP_STEREO_SW, chip->force_mode16 & ~0x02);
205 spin_unlock(&chip->mixer_lock);
206 }
207 } else {
208 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
209 }
210 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
211 }
212 spin_unlock_irqrestore(&chip->reg_lock, flags);
213 chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_PLAYBACK_8 : SB_MODE_HALT;
214 return 0;
215 }
216
217 static int snd_sb8_hw_params(struct snd_pcm_substream *substream,
218 struct snd_pcm_hw_params *hw_params)
219 {
220 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
221 }
222
223 static int snd_sb8_hw_free(struct snd_pcm_substream *substream)
224 {
225 snd_pcm_lib_free_pages(substream);
226 return 0;
227 }
228
229 static int snd_sb8_capture_prepare(struct snd_pcm_substream *substream)
230 {
231 unsigned long flags;
232 struct snd_sb *chip = snd_pcm_substream_chip(substream);
233 struct snd_pcm_runtime *runtime = substream->runtime;
234 unsigned int mixreg, rate, size, count;
235
236 rate = runtime->rate;
237 switch (chip->hardware) {
238 case SB_HW_PRO:
239 if (runtime->channels > 1) {
240 snd_assert(rate == SB8_RATE(11025) || rate == SB8_RATE(22050), return -EINVAL);
241 chip->capture_format = SB_DSP_HI_INPUT_AUTO;
242 break;
243 }
244 chip->capture_format = (rate > 23000) ? SB_DSP_HI_INPUT_AUTO : SB_DSP_LO_INPUT_AUTO;
245 break;
246 case SB_HW_201:
247 if (rate > 13000) {
248 chip->capture_format = SB_DSP_HI_INPUT_AUTO;
249 break;
250 }
251 /* fallthru */
252 case SB_HW_20:
253 chip->capture_format = SB_DSP_LO_INPUT_AUTO;
254 break;
255 case SB_HW_10:
256 chip->capture_format = SB_DSP_INPUT;
257 break;
258 default:
259 return -EINVAL;
260 }
261 size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream);
262 count = chip->c_period_size = snd_pcm_lib_period_bytes(substream);
263 spin_lock_irqsave(&chip->reg_lock, flags);
264 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
265 if (runtime->channels > 1)
266 snd_sbdsp_command(chip, SB_DSP_STEREO_8BIT);
267 snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE);
268 if (runtime->channels > 1) {
269 snd_sbdsp_command(chip, 256 - runtime->rate_den / 2);
270 spin_lock(&chip->mixer_lock);
271 /* save input filter status and turn it off */
272 mixreg = snd_sbmixer_read(chip, SB_DSP_CAPTURE_FILT);
273 snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, mixreg | 0x20);
274 spin_unlock(&chip->mixer_lock);
275 /* just use force_mode16 for temporary storate... */
276 chip->force_mode16 = mixreg;
277 } else {
278 snd_sbdsp_command(chip, 256 - runtime->rate_den);
279 }
280 if (chip->capture_format != SB_DSP_INPUT) {
281 count--;
282 snd_sbdsp_command(chip, SB_DSP_BLOCK_SIZE);
283 snd_sbdsp_command(chip, count & 0xff);
284 snd_sbdsp_command(chip, count >> 8);
285 }
286 spin_unlock_irqrestore(&chip->reg_lock, flags);
287 snd_dma_program(chip->dma8, runtime->dma_addr,
288 size, DMA_MODE_READ | DMA_AUTOINIT);
289 return 0;
290 }
291
292 static int snd_sb8_capture_trigger(struct snd_pcm_substream *substream,
293 int cmd)
294 {
295 unsigned long flags;
296 struct snd_sb *chip = snd_pcm_substream_chip(substream);
297 unsigned int count;
298
299 spin_lock_irqsave(&chip->reg_lock, flags);
300 switch (cmd) {
301 case SNDRV_PCM_TRIGGER_START:
302 snd_sbdsp_command(chip, chip->capture_format);
303 if (chip->capture_format == SB_DSP_INPUT) {
304 count = chip->c_period_size - 1;
305 snd_sbdsp_command(chip, count & 0xff);
306 snd_sbdsp_command(chip, count >> 8);
307 }
308 break;
309 case SNDRV_PCM_TRIGGER_STOP:
310 if (chip->capture_format == SB_DSP_HI_INPUT_AUTO) {
311 struct snd_pcm_runtime *runtime = substream->runtime;
312 snd_sbdsp_reset(chip);
313 if (runtime->channels > 1) {
314 /* restore input filter status */
315 spin_lock(&chip->mixer_lock);
316 snd_sbmixer_write(chip, SB_DSP_CAPTURE_FILT, chip->force_mode16);
317 spin_unlock(&chip->mixer_lock);
318 /* set hardware to mono mode */
319 snd_sbdsp_command(chip, SB_DSP_MONO_8BIT);
320 }
321 } else {
322 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
323 }
324 snd_sbdsp_command(chip, SB_DSP_SPEAKER_OFF);
325 }
326 spin_unlock_irqrestore(&chip->reg_lock, flags);
327 chip->mode = (cmd == SNDRV_PCM_TRIGGER_START) ? SB_MODE_CAPTURE_8 : SB_MODE_HALT;
328 return 0;
329 }
330
331 irqreturn_t snd_sb8dsp_interrupt(struct snd_sb *chip)
332 {
333 struct snd_pcm_substream *substream;
334 struct snd_pcm_runtime *runtime;
335
336 snd_sb_ack_8bit(chip);
337 switch (chip->mode) {
338 case SB_MODE_PLAYBACK_8: /* ok.. playback is active */
339 substream = chip->playback_substream;
340 runtime = substream->runtime;
341 if (chip->playback_format == SB_DSP_OUTPUT)
342 snd_sb8_playback_trigger(substream, SNDRV_PCM_TRIGGER_START);
343 snd_pcm_period_elapsed(substream);
344 break;
345 case SB_MODE_CAPTURE_8:
346 substream = chip->capture_substream;
347 runtime = substream->runtime;
348 if (chip->capture_format == SB_DSP_INPUT)
349 snd_sb8_capture_trigger(substream, SNDRV_PCM_TRIGGER_START);
350 snd_pcm_period_elapsed(substream);
351 break;
352 }
353 return IRQ_HANDLED;
354 }
355
356 static snd_pcm_uframes_t snd_sb8_playback_pointer(struct snd_pcm_substream *substream)
357 {
358 struct snd_sb *chip = snd_pcm_substream_chip(substream);
359 size_t ptr;
360
361 if (chip->mode != SB_MODE_PLAYBACK_8)
362 return 0;
363 ptr = snd_dma_pointer(chip->dma8, chip->p_dma_size);
364 return bytes_to_frames(substream->runtime, ptr);
365 }
366
367 static snd_pcm_uframes_t snd_sb8_capture_pointer(struct snd_pcm_substream *substream)
368 {
369 struct snd_sb *chip = snd_pcm_substream_chip(substream);
370 size_t ptr;
371
372 if (chip->mode != SB_MODE_CAPTURE_8)
373 return 0;
374 ptr = snd_dma_pointer(chip->dma8, chip->c_dma_size);
375 return bytes_to_frames(substream->runtime, ptr);
376 }
377
378 /*
379
380 */
381
382 static struct snd_pcm_hardware snd_sb8_playback =
383 {
384 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
385 SNDRV_PCM_INFO_MMAP_VALID),
386 .formats = SNDRV_PCM_FMTBIT_U8,
387 .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 |
388 SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_22050),
389 .rate_min = 4000,
390 .rate_max = 23000,
391 .channels_min = 1,
392 .channels_max = 1,
393 .buffer_bytes_max = 65536,
394 .period_bytes_min = 64,
395 .period_bytes_max = 65536,
396 .periods_min = 1,
397 .periods_max = 1024,
398 .fifo_size = 0,
399 };
400
401 static struct snd_pcm_hardware snd_sb8_capture =
402 {
403 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
404 SNDRV_PCM_INFO_MMAP_VALID),
405 .formats = SNDRV_PCM_FMTBIT_U8,
406 .rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000 |
407 SNDRV_PCM_RATE_11025),
408 .rate_min = 4000,
409 .rate_max = 13000,
410 .channels_min = 1,
411 .channels_max = 1,
412 .buffer_bytes_max = 65536,
413 .period_bytes_min = 64,
414 .period_bytes_max = 65536,
415 .periods_min = 1,
416 .periods_max = 1024,
417 .fifo_size = 0,
418 };
419
420 /*
421 *
422 */
423
424 static int snd_sb8_open(struct snd_pcm_substream *substream)
425 {
426 struct snd_sb *chip = snd_pcm_substream_chip(substream);
427 struct snd_pcm_runtime *runtime = substream->runtime;
428 unsigned long flags;
429
430 spin_lock_irqsave(&chip->open_lock, flags);
431 if (chip->open) {
432 spin_unlock_irqrestore(&chip->open_lock, flags);
433 return -EAGAIN;
434 }
435 chip->open |= SB_OPEN_PCM;
436 spin_unlock_irqrestore(&chip->open_lock, flags);
437 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
438 chip->playback_substream = substream;
439 runtime->hw = snd_sb8_playback;
440 } else {
441 chip->capture_substream = substream;
442 runtime->hw = snd_sb8_capture;
443 }
444 switch (chip->hardware) {
445 case SB_HW_PRO:
446 runtime->hw.rate_max = 44100;
447 runtime->hw.channels_max = 2;
448 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
449 snd_sb8_hw_constraint_rate_channels, NULL,
450 SNDRV_PCM_HW_PARAM_CHANNELS,
451 SNDRV_PCM_HW_PARAM_RATE, -1);
452 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
453 snd_sb8_hw_constraint_channels_rate, NULL,
454 SNDRV_PCM_HW_PARAM_RATE, -1);
455 break;
456 case SB_HW_201:
457 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
458 runtime->hw.rate_max = 44100;
459 } else {
460 runtime->hw.rate_max = 15000;
461 }
462 default:
463 break;
464 }
465 snd_pcm_hw_constraint_ratnums(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
466 &hw_constraints_clock);
467 return 0;
468 }
469
470 static int snd_sb8_close(struct snd_pcm_substream *substream)
471 {
472 unsigned long flags;
473 struct snd_sb *chip = snd_pcm_substream_chip(substream);
474
475 chip->playback_substream = NULL;
476 chip->capture_substream = NULL;
477 spin_lock_irqsave(&chip->open_lock, flags);
478 chip->open &= ~SB_OPEN_PCM;
479 spin_unlock_irqrestore(&chip->open_lock, flags);
480 return 0;
481 }
482
483 /*
484 * Initialization part
485 */
486
487 static struct snd_pcm_ops snd_sb8_playback_ops = {
488 .open = snd_sb8_open,
489 .close = snd_sb8_close,
490 .ioctl = snd_pcm_lib_ioctl,
491 .hw_params = snd_sb8_hw_params,
492 .hw_free = snd_sb8_hw_free,
493 .prepare = snd_sb8_playback_prepare,
494 .trigger = snd_sb8_playback_trigger,
495 .pointer = snd_sb8_playback_pointer,
496 };
497
498 static struct snd_pcm_ops snd_sb8_capture_ops = {
499 .open = snd_sb8_open,
500 .close = snd_sb8_close,
501 .ioctl = snd_pcm_lib_ioctl,
502 .hw_params = snd_sb8_hw_params,
503 .hw_free = snd_sb8_hw_free,
504 .prepare = snd_sb8_capture_prepare,
505 .trigger = snd_sb8_capture_trigger,
506 .pointer = snd_sb8_capture_pointer,
507 };
508
509 int snd_sb8dsp_pcm(struct snd_sb *chip, int device, struct snd_pcm ** rpcm)
510 {
511 struct snd_card *card = chip->card;
512 struct snd_pcm *pcm;
513 int err;
514
515 if (rpcm)
516 *rpcm = NULL;
517 if ((err = snd_pcm_new(card, "SB8 DSP", device, 1, 1, &pcm)) < 0)
518 return err;
519 sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff);
520 pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
521 pcm->private_data = chip;
522
523 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb8_playback_ops);
524 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb8_capture_ops);
525
526 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
527 snd_dma_isa_data(),
528 64*1024, 64*1024);
529
530 if (rpcm)
531 *rpcm = pcm;
532 return 0;
533 }
534
535 EXPORT_SYMBOL(snd_sb8dsp_pcm);
536 EXPORT_SYMBOL(snd_sb8dsp_interrupt);
537 /* sb8_midi.c */
538 EXPORT_SYMBOL(snd_sb8dsp_midi_interrupt);
539 EXPORT_SYMBOL(snd_sb8dsp_midi);
540
541 /*
542 * INIT part
543 */
544
545 static int __init alsa_sb8_init(void)
546 {
547 return 0;
548 }
549
550 static void __exit alsa_sb8_exit(void)
551 {
552 }
553
554 module_init(alsa_sb8_init)
555 module_exit(alsa_sb8_exit)
Linux with added FPC-III support