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