[ALSA] Remove sound/driver.h
[linux-2.6.git] / sound / isa / sb / sb8_main.c
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_OUTPUT) {
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)