1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 * Routines for control of 16-bit SoundBlaster cards and clones
5 * Note: This is very ugly hardware which uses one 8-bit DMA channel and
6 * second 16-bit DMA channel. Unfortunately 8-bit DMA channel can't
7 * transfer 16-bit samples and 16-bit DMA channels can't transfer
8 * 8-bit samples. This make full duplex more complicated than
9 * can be... People, don't buy these soundcards for full 16-bit
11 * Note: 16-bit wide is assigned to first direction which made request.
12 * With full duplex - playback is preferred with abstract layer.
14 * Note: Some chip revisions have hardware bug. Changing capture
15 * channel from full-duplex 8bit DMA to 16bit DMA will block
16 * 16bit DMA transfers from DSP chip (capture) until 8bit transfer
17 * to DSP chip (playback) starts. This bug can be avoided with
18 * "16bit DMA Allocation" setting set to Playback or Capture.
23 #include <linux/init.h>
24 #include <linux/time.h>
25 #include <linux/module.h>
26 #include <sound/core.h>
28 #include <sound/sb16_csp.h>
29 #include <sound/mpu401.h>
30 #include <sound/control.h>
31 #include <sound/info.h>
33 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
34 MODULE_DESCRIPTION("Routines for control of 16-bit SoundBlaster cards and clones");
35 MODULE_LICENSE("GPL");
37 #define runtime_format_bits(runtime) \
38 ((unsigned int)pcm_format_to_bits((runtime)->format))
40 #ifdef CONFIG_SND_SB16_CSP
41 static void snd_sb16_csp_playback_prepare(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
43 if (chip->hardware == SB_HW_16CSP) {
44 struct snd_sb_csp *csp = chip->csp;
46 if (csp->running & SNDRV_SB_CSP_ST_LOADED) {
47 /* manually loaded codec */
48 if ((csp->mode & SNDRV_SB_CSP_MODE_DSP_WRITE) &&
49 (runtime_format_bits(runtime) == csp->acc_format)) {
50 /* Supported runtime PCM format for playback */
51 if (csp->ops.csp_use(csp) == 0) {
52 /* If CSP was successfully acquired */
55 } else if ((csp->mode & SNDRV_SB_CSP_MODE_QSOUND) && (csp->q_enabled)) {
56 /* QSound decoder is loaded and enabled */
57 if (runtime_format_bits(runtime) & (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 |
58 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE)) {
59 /* Only for simple PCM formats */
60 if (csp->ops.csp_use(csp) == 0) {
61 /* If CSP was successfully acquired */
66 } else if (csp->ops.csp_use(csp) == 0) {
67 /* Acquire CSP and try to autoload hardware codec */
68 if (csp->ops.csp_autoload(csp, runtime->format, SNDRV_SB_CSP_MODE_DSP_WRITE)) {
69 /* Unsupported format, release CSP */
70 csp->ops.csp_unuse(csp);
73 /* Try to start CSP */
74 if (csp->ops.csp_start(csp, (chip->mode & SB_MODE_PLAYBACK_16) ?
75 SNDRV_SB_CSP_SAMPLE_16BIT : SNDRV_SB_CSP_SAMPLE_8BIT,
76 (runtime->channels > 1) ?
77 SNDRV_SB_CSP_STEREO : SNDRV_SB_CSP_MONO)) {
78 /* Failed, release CSP */
79 csp->ops.csp_unuse(csp);
81 /* Success, CSP acquired and running */
82 chip->open = SNDRV_SB_CSP_MODE_DSP_WRITE;
89 static void snd_sb16_csp_capture_prepare(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
91 if (chip->hardware == SB_HW_16CSP) {
92 struct snd_sb_csp *csp = chip->csp;
94 if (csp->running & SNDRV_SB_CSP_ST_LOADED) {
95 /* manually loaded codec */
96 if ((csp->mode & SNDRV_SB_CSP_MODE_DSP_READ) &&
97 (runtime_format_bits(runtime) == csp->acc_format)) {
98 /* Supported runtime PCM format for capture */
99 if (csp->ops.csp_use(csp) == 0) {
100 /* If CSP was successfully acquired */
104 } else if (csp->ops.csp_use(csp) == 0) {
105 /* Acquire CSP and try to autoload hardware codec */
106 if (csp->ops.csp_autoload(csp, runtime->format, SNDRV_SB_CSP_MODE_DSP_READ)) {
107 /* Unsupported format, release CSP */
108 csp->ops.csp_unuse(csp);
111 /* Try to start CSP */
112 if (csp->ops.csp_start(csp, (chip->mode & SB_MODE_CAPTURE_16) ?
113 SNDRV_SB_CSP_SAMPLE_16BIT : SNDRV_SB_CSP_SAMPLE_8BIT,
114 (runtime->channels > 1) ?
115 SNDRV_SB_CSP_STEREO : SNDRV_SB_CSP_MONO)) {
116 /* Failed, release CSP */
117 csp->ops.csp_unuse(csp);
119 /* Success, CSP acquired and running */
120 chip->open = SNDRV_SB_CSP_MODE_DSP_READ;
127 static void snd_sb16_csp_update(struct snd_sb *chip)
129 if (chip->hardware == SB_HW_16CSP) {
130 struct snd_sb_csp *csp = chip->csp;
132 if (csp->qpos_changed) {
133 spin_lock(&chip->reg_lock);
134 csp->ops.csp_qsound_transfer (csp);
135 spin_unlock(&chip->reg_lock);
140 static void snd_sb16_csp_playback_open(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
142 /* CSP decoders (QSound excluded) support only 16bit transfers */
143 if (chip->hardware == SB_HW_16CSP) {
144 struct snd_sb_csp *csp = chip->csp;
146 if (csp->running & SNDRV_SB_CSP_ST_LOADED) {
147 /* manually loaded codec */
148 if (csp->mode & SNDRV_SB_CSP_MODE_DSP_WRITE) {
149 runtime->hw.formats |= csp->acc_format;
152 /* autoloaded codecs */
153 runtime->hw.formats |= SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
154 SNDRV_PCM_FMTBIT_IMA_ADPCM;
159 static void snd_sb16_csp_playback_close(struct snd_sb *chip)
161 if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_WRITE)) {
162 struct snd_sb_csp *csp = chip->csp;
164 if (csp->ops.csp_stop(csp) == 0) {
165 csp->ops.csp_unuse(csp);
171 static void snd_sb16_csp_capture_open(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
173 /* CSP coders support only 16bit transfers */
174 if (chip->hardware == SB_HW_16CSP) {
175 struct snd_sb_csp *csp = chip->csp;
177 if (csp->running & SNDRV_SB_CSP_ST_LOADED) {
178 /* manually loaded codec */
179 if (csp->mode & SNDRV_SB_CSP_MODE_DSP_READ) {
180 runtime->hw.formats |= csp->acc_format;
183 /* autoloaded codecs */
184 runtime->hw.formats |= SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
185 SNDRV_PCM_FMTBIT_IMA_ADPCM;
190 static void snd_sb16_csp_capture_close(struct snd_sb *chip)
192 if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_READ)) {
193 struct snd_sb_csp *csp = chip->csp;
195 if (csp->ops.csp_stop(csp) == 0) {
196 csp->ops.csp_unuse(csp);
202 #define snd_sb16_csp_playback_prepare(chip, runtime) /*nop*/
203 #define snd_sb16_csp_capture_prepare(chip, runtime) /*nop*/
204 #define snd_sb16_csp_update(chip) /*nop*/
205 #define snd_sb16_csp_playback_open(chip, runtime) /*nop*/
206 #define snd_sb16_csp_playback_close(chip) /*nop*/
207 #define snd_sb16_csp_capture_open(chip, runtime) /*nop*/
208 #define snd_sb16_csp_capture_close(chip) /*nop*/
212 static void snd_sb16_setup_rate(struct snd_sb *chip,
218 spin_lock_irqsave(&chip->reg_lock, flags);
219 if (chip->mode & (channel == SNDRV_PCM_STREAM_PLAYBACK ? SB_MODE_PLAYBACK_16 : SB_MODE_CAPTURE_16))
220 snd_sb_ack_16bit(chip);
222 snd_sb_ack_8bit(chip);
223 if (!(chip->mode & SB_RATE_LOCK)) {
224 chip->locked_rate = rate;
225 snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE_IN);
226 snd_sbdsp_command(chip, rate >> 8);
227 snd_sbdsp_command(chip, rate & 0xff);
228 snd_sbdsp_command(chip, SB_DSP_SAMPLE_RATE_OUT);
229 snd_sbdsp_command(chip, rate >> 8);
230 snd_sbdsp_command(chip, rate & 0xff);
232 spin_unlock_irqrestore(&chip->reg_lock, flags);
235 static int snd_sb16_hw_params(struct snd_pcm_substream *substream,
236 struct snd_pcm_hw_params *hw_params)
238 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
241 static int snd_sb16_hw_free(struct snd_pcm_substream *substream)
243 snd_pcm_lib_free_pages(substream);
247 static int snd_sb16_playback_prepare(struct snd_pcm_substream *substream)
250 struct snd_sb *chip = snd_pcm_substream_chip(substream);
251 struct snd_pcm_runtime *runtime = substream->runtime;
252 unsigned char format;
253 unsigned int size, count, dma;
255 snd_sb16_csp_playback_prepare(chip, runtime);
256 if (snd_pcm_format_unsigned(runtime->format) > 0) {
257 format = runtime->channels > 1 ? SB_DSP4_MODE_UNS_STEREO : SB_DSP4_MODE_UNS_MONO;
259 format = runtime->channels > 1 ? SB_DSP4_MODE_SIGN_STEREO : SB_DSP4_MODE_SIGN_MONO;
262 snd_sb16_setup_rate(chip, runtime->rate, SNDRV_PCM_STREAM_PLAYBACK);
263 size = chip->p_dma_size = snd_pcm_lib_buffer_bytes(substream);
264 dma = (chip->mode & SB_MODE_PLAYBACK_8) ? chip->dma8 : chip->dma16;
265 snd_dma_program(dma, runtime->dma_addr, size, DMA_MODE_WRITE | DMA_AUTOINIT);
267 count = snd_pcm_lib_period_bytes(substream);
268 spin_lock_irqsave(&chip->reg_lock, flags);
269 if (chip->mode & SB_MODE_PLAYBACK_16) {
272 snd_sbdsp_command(chip, SB_DSP4_OUT16_AI);
273 snd_sbdsp_command(chip, format);
274 snd_sbdsp_command(chip, count & 0xff);
275 snd_sbdsp_command(chip, count >> 8);
276 snd_sbdsp_command(chip, SB_DSP_DMA16_OFF);
279 snd_sbdsp_command(chip, SB_DSP4_OUT8_AI);
280 snd_sbdsp_command(chip, format);
281 snd_sbdsp_command(chip, count & 0xff);
282 snd_sbdsp_command(chip, count >> 8);
283 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
285 spin_unlock_irqrestore(&chip->reg_lock, flags);
289 static int snd_sb16_playback_trigger(struct snd_pcm_substream *substream,
292 struct snd_sb *chip = snd_pcm_substream_chip(substream);
295 spin_lock(&chip->reg_lock);
297 case SNDRV_PCM_TRIGGER_START:
298 case SNDRV_PCM_TRIGGER_RESUME:
299 chip->mode |= SB_RATE_LOCK_PLAYBACK;
300 snd_sbdsp_command(chip, chip->mode & SB_MODE_PLAYBACK_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
302 case SNDRV_PCM_TRIGGER_STOP:
303 case SNDRV_PCM_TRIGGER_SUSPEND:
304 snd_sbdsp_command(chip, chip->mode & SB_MODE_PLAYBACK_16 ? SB_DSP_DMA16_OFF : SB_DSP_DMA8_OFF);
305 /* next two lines are needed for some types of DSP4 (SB AWE 32 - 4.13) */
306 if (chip->mode & SB_RATE_LOCK_CAPTURE)
307 snd_sbdsp_command(chip, chip->mode & SB_MODE_CAPTURE_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
308 chip->mode &= ~SB_RATE_LOCK_PLAYBACK;
313 spin_unlock(&chip->reg_lock);
317 static int snd_sb16_capture_prepare(struct snd_pcm_substream *substream)
320 struct snd_sb *chip = snd_pcm_substream_chip(substream);
321 struct snd_pcm_runtime *runtime = substream->runtime;
322 unsigned char format;
323 unsigned int size, count, dma;
325 snd_sb16_csp_capture_prepare(chip, runtime);
326 if (snd_pcm_format_unsigned(runtime->format) > 0) {
327 format = runtime->channels > 1 ? SB_DSP4_MODE_UNS_STEREO : SB_DSP4_MODE_UNS_MONO;
329 format = runtime->channels > 1 ? SB_DSP4_MODE_SIGN_STEREO : SB_DSP4_MODE_SIGN_MONO;
331 snd_sb16_setup_rate(chip, runtime->rate, SNDRV_PCM_STREAM_CAPTURE);
332 size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream);
333 dma = (chip->mode & SB_MODE_CAPTURE_8) ? chip->dma8 : chip->dma16;
334 snd_dma_program(dma, runtime->dma_addr, size, DMA_MODE_READ | DMA_AUTOINIT);
336 count = snd_pcm_lib_period_bytes(substream);
337 spin_lock_irqsave(&chip->reg_lock, flags);
338 if (chip->mode & SB_MODE_CAPTURE_16) {
341 snd_sbdsp_command(chip, SB_DSP4_IN16_AI);
342 snd_sbdsp_command(chip, format);
343 snd_sbdsp_command(chip, count & 0xff);
344 snd_sbdsp_command(chip, count >> 8);
345 snd_sbdsp_command(chip, SB_DSP_DMA16_OFF);
348 snd_sbdsp_command(chip, SB_DSP4_IN8_AI);
349 snd_sbdsp_command(chip, format);
350 snd_sbdsp_command(chip, count & 0xff);
351 snd_sbdsp_command(chip, count >> 8);
352 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
354 spin_unlock_irqrestore(&chip->reg_lock, flags);
358 static int snd_sb16_capture_trigger(struct snd_pcm_substream *substream,
361 struct snd_sb *chip = snd_pcm_substream_chip(substream);
364 spin_lock(&chip->reg_lock);
366 case SNDRV_PCM_TRIGGER_START:
367 case SNDRV_PCM_TRIGGER_RESUME:
368 chip->mode |= SB_RATE_LOCK_CAPTURE;
369 snd_sbdsp_command(chip, chip->mode & SB_MODE_CAPTURE_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
371 case SNDRV_PCM_TRIGGER_STOP:
372 case SNDRV_PCM_TRIGGER_SUSPEND:
373 snd_sbdsp_command(chip, chip->mode & SB_MODE_CAPTURE_16 ? SB_DSP_DMA16_OFF : SB_DSP_DMA8_OFF);
374 /* next two lines are needed for some types of DSP4 (SB AWE 32 - 4.13) */
375 if (chip->mode & SB_RATE_LOCK_PLAYBACK)
376 snd_sbdsp_command(chip, chip->mode & SB_MODE_PLAYBACK_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
377 chip->mode &= ~SB_RATE_LOCK_CAPTURE;
382 spin_unlock(&chip->reg_lock);
386 irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id)
388 struct snd_sb *chip = dev_id;
389 unsigned char status;
392 spin_lock(&chip->mixer_lock);
393 status = snd_sbmixer_read(chip, SB_DSP4_IRQSTATUS);
394 spin_unlock(&chip->mixer_lock);
395 if ((status & SB_IRQTYPE_MPUIN) && chip->rmidi_callback)
396 chip->rmidi_callback(irq, chip->rmidi->private_data);
397 if (status & SB_IRQTYPE_8BIT) {
399 if (chip->mode & SB_MODE_PLAYBACK_8) {
400 snd_pcm_period_elapsed(chip->playback_substream);
401 snd_sb16_csp_update(chip);
404 if (chip->mode & SB_MODE_CAPTURE_8) {
405 snd_pcm_period_elapsed(chip->capture_substream);
408 spin_lock(&chip->reg_lock);
410 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
411 snd_sb_ack_8bit(chip);
412 spin_unlock(&chip->reg_lock);
414 if (status & SB_IRQTYPE_16BIT) {
416 if (chip->mode & SB_MODE_PLAYBACK_16) {
417 snd_pcm_period_elapsed(chip->playback_substream);
418 snd_sb16_csp_update(chip);
421 if (chip->mode & SB_MODE_CAPTURE_16) {
422 snd_pcm_period_elapsed(chip->capture_substream);
425 spin_lock(&chip->reg_lock);
427 snd_sbdsp_command(chip, SB_DSP_DMA16_OFF);
428 snd_sb_ack_16bit(chip);
429 spin_unlock(&chip->reg_lock);
438 static snd_pcm_uframes_t snd_sb16_playback_pointer(struct snd_pcm_substream *substream)
440 struct snd_sb *chip = snd_pcm_substream_chip(substream);
444 dma = (chip->mode & SB_MODE_PLAYBACK_8) ? chip->dma8 : chip->dma16;
445 ptr = snd_dma_pointer(dma, chip->p_dma_size);
446 return bytes_to_frames(substream->runtime, ptr);
449 static snd_pcm_uframes_t snd_sb16_capture_pointer(struct snd_pcm_substream *substream)
451 struct snd_sb *chip = snd_pcm_substream_chip(substream);
455 dma = (chip->mode & SB_MODE_CAPTURE_8) ? chip->dma8 : chip->dma16;
456 ptr = snd_dma_pointer(dma, chip->c_dma_size);
457 return bytes_to_frames(substream->runtime, ptr);
464 static const struct snd_pcm_hardware snd_sb16_playback =
466 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
467 SNDRV_PCM_INFO_MMAP_VALID),
469 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_44100,
474 .buffer_bytes_max = (128*1024),
475 .period_bytes_min = 64,
476 .period_bytes_max = (128*1024),
482 static const struct snd_pcm_hardware snd_sb16_capture =
484 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
485 SNDRV_PCM_INFO_MMAP_VALID),
487 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_44100,
492 .buffer_bytes_max = (128*1024),
493 .period_bytes_min = 64,
494 .period_bytes_max = (128*1024),
504 static int snd_sb16_playback_open(struct snd_pcm_substream *substream)
507 struct snd_sb *chip = snd_pcm_substream_chip(substream);
508 struct snd_pcm_runtime *runtime = substream->runtime;
510 spin_lock_irqsave(&chip->open_lock, flags);
511 if (chip->mode & SB_MODE_PLAYBACK) {
512 spin_unlock_irqrestore(&chip->open_lock, flags);
515 runtime->hw = snd_sb16_playback;
517 /* skip if 16 bit DMA was reserved for capture */
518 if (chip->force_mode16 & SB_MODE_CAPTURE_16)
521 if (chip->dma16 >= 0 && !(chip->mode & SB_MODE_CAPTURE_16)) {
522 chip->mode |= SB_MODE_PLAYBACK_16;
523 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE;
525 if (chip->dma16 <= 3) {
526 runtime->hw.buffer_bytes_max =
527 runtime->hw.period_bytes_max = 64 * 1024;
529 snd_sb16_csp_playback_open(chip, runtime);
535 if (chip->dma8 >= 0 && !(chip->mode & SB_MODE_CAPTURE_8)) {
536 chip->mode |= SB_MODE_PLAYBACK_8;
537 /* DSP v 4.xx can transfer 16bit data through 8bit DMA channel, SBHWPG 2-7 */
538 if (chip->dma16 < 0) {
539 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE;
540 chip->mode |= SB_MODE_PLAYBACK_16;
542 runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8;
544 runtime->hw.buffer_bytes_max =
545 runtime->hw.period_bytes_max = 64 * 1024;
548 spin_unlock_irqrestore(&chip->open_lock, flags);
552 if (chip->hardware == SB_HW_ALS100)
553 runtime->hw.rate_max = 48000;
554 if (chip->hardware == SB_HW_CS5530) {
555 runtime->hw.buffer_bytes_max = 32 * 1024;
556 runtime->hw.periods_min = 2;
557 runtime->hw.rate_min = 44100;
559 if (chip->mode & SB_RATE_LOCK)
560 runtime->hw.rate_min = runtime->hw.rate_max = chip->locked_rate;
561 chip->playback_substream = substream;
562 spin_unlock_irqrestore(&chip->open_lock, flags);
566 static int snd_sb16_playback_close(struct snd_pcm_substream *substream)
569 struct snd_sb *chip = snd_pcm_substream_chip(substream);
571 snd_sb16_csp_playback_close(chip);
572 spin_lock_irqsave(&chip->open_lock, flags);
573 chip->playback_substream = NULL;
574 chip->mode &= ~SB_MODE_PLAYBACK;
575 spin_unlock_irqrestore(&chip->open_lock, flags);
579 static int snd_sb16_capture_open(struct snd_pcm_substream *substream)
582 struct snd_sb *chip = snd_pcm_substream_chip(substream);
583 struct snd_pcm_runtime *runtime = substream->runtime;
585 spin_lock_irqsave(&chip->open_lock, flags);
586 if (chip->mode & SB_MODE_CAPTURE) {
587 spin_unlock_irqrestore(&chip->open_lock, flags);
590 runtime->hw = snd_sb16_capture;
592 /* skip if 16 bit DMA was reserved for playback */
593 if (chip->force_mode16 & SB_MODE_PLAYBACK_16)
596 if (chip->dma16 >= 0 && !(chip->mode & SB_MODE_PLAYBACK_16)) {
597 chip->mode |= SB_MODE_CAPTURE_16;
598 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE;
600 if (chip->dma16 <= 3) {
601 runtime->hw.buffer_bytes_max =
602 runtime->hw.period_bytes_max = 64 * 1024;
604 snd_sb16_csp_capture_open(chip, runtime);
610 if (chip->dma8 >= 0 && !(chip->mode & SB_MODE_PLAYBACK_8)) {
611 chip->mode |= SB_MODE_CAPTURE_8;
612 /* DSP v 4.xx can transfer 16bit data through 8bit DMA channel, SBHWPG 2-7 */
613 if (chip->dma16 < 0) {
614 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE;
615 chip->mode |= SB_MODE_CAPTURE_16;
617 runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8;
619 runtime->hw.buffer_bytes_max =
620 runtime->hw.period_bytes_max = 64 * 1024;
623 spin_unlock_irqrestore(&chip->open_lock, flags);
627 if (chip->hardware == SB_HW_ALS100)
628 runtime->hw.rate_max = 48000;
629 if (chip->hardware == SB_HW_CS5530) {
630 runtime->hw.buffer_bytes_max = 32 * 1024;
631 runtime->hw.periods_min = 2;
632 runtime->hw.rate_min = 44100;
634 if (chip->mode & SB_RATE_LOCK)
635 runtime->hw.rate_min = runtime->hw.rate_max = chip->locked_rate;
636 chip->capture_substream = substream;
637 spin_unlock_irqrestore(&chip->open_lock, flags);
641 static int snd_sb16_capture_close(struct snd_pcm_substream *substream)
644 struct snd_sb *chip = snd_pcm_substream_chip(substream);
646 snd_sb16_csp_capture_close(chip);
647 spin_lock_irqsave(&chip->open_lock, flags);
648 chip->capture_substream = NULL;
649 chip->mode &= ~SB_MODE_CAPTURE;
650 spin_unlock_irqrestore(&chip->open_lock, flags);
655 * DMA control interface
658 static int snd_sb16_set_dma_mode(struct snd_sb *chip, int what)
660 if (chip->dma8 < 0 || chip->dma16 < 0) {
661 if (snd_BUG_ON(what))
666 chip->force_mode16 = 0;
667 } else if (what == 1) {
668 chip->force_mode16 = SB_MODE_PLAYBACK_16;
669 } else if (what == 2) {
670 chip->force_mode16 = SB_MODE_CAPTURE_16;
677 static int snd_sb16_get_dma_mode(struct snd_sb *chip)
679 if (chip->dma8 < 0 || chip->dma16 < 0)
681 switch (chip->force_mode16) {
682 case SB_MODE_PLAYBACK_16:
684 case SB_MODE_CAPTURE_16:
691 static int snd_sb16_dma_control_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
693 static const char * const texts[3] = {
694 "Auto", "Playback", "Capture"
697 return snd_ctl_enum_info(uinfo, 1, 3, texts);
700 static int snd_sb16_dma_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
702 struct snd_sb *chip = snd_kcontrol_chip(kcontrol);
705 spin_lock_irqsave(&chip->reg_lock, flags);
706 ucontrol->value.enumerated.item[0] = snd_sb16_get_dma_mode(chip);
707 spin_unlock_irqrestore(&chip->reg_lock, flags);
711 static int snd_sb16_dma_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
713 struct snd_sb *chip = snd_kcontrol_chip(kcontrol);
715 unsigned char nval, oval;
718 if ((nval = ucontrol->value.enumerated.item[0]) > 2)
720 spin_lock_irqsave(&chip->reg_lock, flags);
721 oval = snd_sb16_get_dma_mode(chip);
722 change = nval != oval;
723 snd_sb16_set_dma_mode(chip, nval);
724 spin_unlock_irqrestore(&chip->reg_lock, flags);
728 static const struct snd_kcontrol_new snd_sb16_dma_control = {
729 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
730 .name = "16-bit DMA Allocation",
731 .info = snd_sb16_dma_control_info,
732 .get = snd_sb16_dma_control_get,
733 .put = snd_sb16_dma_control_put
737 * Initialization part
740 int snd_sb16dsp_configure(struct snd_sb * chip)
743 unsigned char irqreg = 0, dmareg = 0, mpureg;
744 unsigned char realirq, realdma, realmpureg;
745 /* note: mpu register should be present only on SB16 Vibra soundcards */
747 // printk(KERN_DEBUG "codec->irq=%i, codec->dma8=%i, codec->dma16=%i\n", chip->irq, chip->dma8, chip->dma16);
748 spin_lock_irqsave(&chip->mixer_lock, flags);
749 mpureg = snd_sbmixer_read(chip, SB_DSP4_MPUSETUP) & ~0x06;
750 spin_unlock_irqrestore(&chip->mixer_lock, flags);
754 irqreg |= SB_IRQSETUP_IRQ9;
757 irqreg |= SB_IRQSETUP_IRQ5;
760 irqreg |= SB_IRQSETUP_IRQ7;
763 irqreg |= SB_IRQSETUP_IRQ10;
768 if (chip->dma8 >= 0) {
769 switch (chip->dma8) {
771 dmareg |= SB_DMASETUP_DMA0;
774 dmareg |= SB_DMASETUP_DMA1;
777 dmareg |= SB_DMASETUP_DMA3;
783 if (chip->dma16 >= 0 && chip->dma16 != chip->dma8) {
784 switch (chip->dma16) {
786 dmareg |= SB_DMASETUP_DMA5;
789 dmareg |= SB_DMASETUP_DMA6;
792 dmareg |= SB_DMASETUP_DMA7;
798 switch (chip->mpu_port) {
806 mpureg |= 0x02; /* disable MPU */
808 spin_lock_irqsave(&chip->mixer_lock, flags);
810 snd_sbmixer_write(chip, SB_DSP4_IRQSETUP, irqreg);
811 realirq = snd_sbmixer_read(chip, SB_DSP4_IRQSETUP);
813 snd_sbmixer_write(chip, SB_DSP4_DMASETUP, dmareg);
814 realdma = snd_sbmixer_read(chip, SB_DSP4_DMASETUP);
816 snd_sbmixer_write(chip, SB_DSP4_MPUSETUP, mpureg);
817 realmpureg = snd_sbmixer_read(chip, SB_DSP4_MPUSETUP);
819 spin_unlock_irqrestore(&chip->mixer_lock, flags);
820 if ((~realirq) & irqreg || (~realdma) & dmareg) {
821 snd_printk(KERN_ERR "SB16 [0x%lx]: unable to set DMA & IRQ (PnP device?)\n", chip->port);
822 snd_printk(KERN_ERR "SB16 [0x%lx]: wanted: irqreg=0x%x, dmareg=0x%x, mpureg = 0x%x\n", chip->port, realirq, realdma, realmpureg);
823 snd_printk(KERN_ERR "SB16 [0x%lx]: got: irqreg=0x%x, dmareg=0x%x, mpureg = 0x%x\n", chip->port, irqreg, dmareg, mpureg);
829 static const struct snd_pcm_ops snd_sb16_playback_ops = {
830 .open = snd_sb16_playback_open,
831 .close = snd_sb16_playback_close,
832 .ioctl = snd_pcm_lib_ioctl,
833 .hw_params = snd_sb16_hw_params,
834 .hw_free = snd_sb16_hw_free,
835 .prepare = snd_sb16_playback_prepare,
836 .trigger = snd_sb16_playback_trigger,
837 .pointer = snd_sb16_playback_pointer,
840 static const struct snd_pcm_ops snd_sb16_capture_ops = {
841 .open = snd_sb16_capture_open,
842 .close = snd_sb16_capture_close,
843 .ioctl = snd_pcm_lib_ioctl,
844 .hw_params = snd_sb16_hw_params,
845 .hw_free = snd_sb16_hw_free,
846 .prepare = snd_sb16_capture_prepare,
847 .trigger = snd_sb16_capture_trigger,
848 .pointer = snd_sb16_capture_pointer,
851 int snd_sb16dsp_pcm(struct snd_sb *chip, int device)
853 struct snd_card *card = chip->card;
857 if ((err = snd_pcm_new(card, "SB16 DSP", device, 1, 1, &pcm)) < 0)
859 sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff);
860 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
861 pcm->private_data = chip;
864 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb16_playback_ops);
865 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb16_capture_ops);
867 if (chip->dma16 >= 0 && chip->dma8 != chip->dma16)
868 snd_ctl_add(card, snd_ctl_new1(&snd_sb16_dma_control, chip));
870 pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
872 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
878 const struct snd_pcm_ops *snd_sb16dsp_get_pcm_ops(int direction)
880 return direction == SNDRV_PCM_STREAM_PLAYBACK ?
881 &snd_sb16_playback_ops : &snd_sb16_capture_ops;
884 EXPORT_SYMBOL(snd_sb16dsp_pcm);
885 EXPORT_SYMBOL(snd_sb16dsp_get_pcm_ops);
886 EXPORT_SYMBOL(snd_sb16dsp_configure);
887 EXPORT_SYMBOL(snd_sb16dsp_interrupt);