2 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
3 * Routines for control of 16-bit SoundBlaster cards and clones
4 * Note: This is very ugly hardware which uses one 8-bit DMA channel and
5 * second 16-bit DMA channel. Unfortunately 8-bit DMA channel can't
6 * transfer 16-bit samples and 16-bit DMA channels can't transfer
7 * 8-bit samples. This make full duplex more complicated than
8 * can be... People, don't buy these soundcards for full 16-bit
10 * Note: 16-bit wide is assigned to first direction which made request.
11 * With full duplex - playback is preferred with abstract layer.
13 * Note: Some chip revisions have hardware bug. Changing capture
14 * channel from full-duplex 8bit DMA to 16bit DMA will block
15 * 16bit DMA transfers from DSP chip (capture) until 8bit transfer
16 * to DSP chip (playback) starts. This bug can be avoided with
17 * "16bit DMA Allocation" setting set to Playback or Capture.
20 * This program is free software; you can redistribute it and/or modify
21 * it under the terms of the GNU General Public License as published by
22 * the Free Software Foundation; either version 2 of the License, or
23 * (at your option) any later version.
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU General Public License for more details.
30 * You should have received a copy of the GNU General Public License
31 * along with this program; if not, write to the Free Software
32 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
38 #include <linux/init.h>
39 #include <linux/time.h>
40 #include <linux/module.h>
41 #include <sound/core.h>
43 #include <sound/sb16_csp.h>
44 #include <sound/mpu401.h>
45 #include <sound/control.h>
46 #include <sound/info.h>
48 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
49 MODULE_DESCRIPTION("Routines for control of 16-bit SoundBlaster cards and clones");
50 MODULE_LICENSE("GPL");
52 #ifdef CONFIG_SND_SB16_CSP
53 static void snd_sb16_csp_playback_prepare(struct snd_sb
*chip
, struct snd_pcm_runtime
*runtime
)
55 if (chip
->hardware
== SB_HW_16CSP
) {
56 struct snd_sb_csp
*csp
= chip
->csp
;
58 if (csp
->running
& SNDRV_SB_CSP_ST_LOADED
) {
59 /* manually loaded codec */
60 if ((csp
->mode
& SNDRV_SB_CSP_MODE_DSP_WRITE
) &&
61 ((1U << runtime
->format
) == csp
->acc_format
)) {
62 /* Supported runtime PCM format for playback */
63 if (csp
->ops
.csp_use(csp
) == 0) {
64 /* If CSP was successfully acquired */
67 } else if ((csp
->mode
& SNDRV_SB_CSP_MODE_QSOUND
) && (csp
->q_enabled
)) {
68 /* QSound decoder is loaded and enabled */
69 if ((1 << runtime
->format
) & (SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U8
|
70 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
)) {
71 /* Only for simple PCM formats */
72 if (csp
->ops
.csp_use(csp
) == 0) {
73 /* If CSP was successfully acquired */
78 } else if (csp
->ops
.csp_use(csp
) == 0) {
79 /* Acquire CSP and try to autoload hardware codec */
80 if (csp
->ops
.csp_autoload(csp
, runtime
->format
, SNDRV_SB_CSP_MODE_DSP_WRITE
)) {
81 /* Unsupported format, release CSP */
82 csp
->ops
.csp_unuse(csp
);
85 /* Try to start CSP */
86 if (csp
->ops
.csp_start(csp
, (chip
->mode
& SB_MODE_PLAYBACK_16
) ?
87 SNDRV_SB_CSP_SAMPLE_16BIT
: SNDRV_SB_CSP_SAMPLE_8BIT
,
88 (runtime
->channels
> 1) ?
89 SNDRV_SB_CSP_STEREO
: SNDRV_SB_CSP_MONO
)) {
90 /* Failed, release CSP */
91 csp
->ops
.csp_unuse(csp
);
93 /* Success, CSP acquired and running */
94 chip
->open
= SNDRV_SB_CSP_MODE_DSP_WRITE
;
101 static void snd_sb16_csp_capture_prepare(struct snd_sb
*chip
, struct snd_pcm_runtime
*runtime
)
103 if (chip
->hardware
== SB_HW_16CSP
) {
104 struct snd_sb_csp
*csp
= chip
->csp
;
106 if (csp
->running
& SNDRV_SB_CSP_ST_LOADED
) {
107 /* manually loaded codec */
108 if ((csp
->mode
& SNDRV_SB_CSP_MODE_DSP_READ
) &&
109 ((1U << runtime
->format
) == csp
->acc_format
)) {
110 /* Supported runtime PCM format for capture */
111 if (csp
->ops
.csp_use(csp
) == 0) {
112 /* If CSP was successfully acquired */
116 } else if (csp
->ops
.csp_use(csp
) == 0) {
117 /* Acquire CSP and try to autoload hardware codec */
118 if (csp
->ops
.csp_autoload(csp
, runtime
->format
, SNDRV_SB_CSP_MODE_DSP_READ
)) {
119 /* Unsupported format, release CSP */
120 csp
->ops
.csp_unuse(csp
);
123 /* Try to start CSP */
124 if (csp
->ops
.csp_start(csp
, (chip
->mode
& SB_MODE_CAPTURE_16
) ?
125 SNDRV_SB_CSP_SAMPLE_16BIT
: SNDRV_SB_CSP_SAMPLE_8BIT
,
126 (runtime
->channels
> 1) ?
127 SNDRV_SB_CSP_STEREO
: SNDRV_SB_CSP_MONO
)) {
128 /* Failed, release CSP */
129 csp
->ops
.csp_unuse(csp
);
131 /* Success, CSP acquired and running */
132 chip
->open
= SNDRV_SB_CSP_MODE_DSP_READ
;
139 static void snd_sb16_csp_update(struct snd_sb
*chip
)
141 if (chip
->hardware
== SB_HW_16CSP
) {
142 struct snd_sb_csp
*csp
= chip
->csp
;
144 if (csp
->qpos_changed
) {
145 spin_lock(&chip
->reg_lock
);
146 csp
->ops
.csp_qsound_transfer (csp
);
147 spin_unlock(&chip
->reg_lock
);
152 static void snd_sb16_csp_playback_open(struct snd_sb
*chip
, struct snd_pcm_runtime
*runtime
)
154 /* CSP decoders (QSound excluded) support only 16bit transfers */
155 if (chip
->hardware
== SB_HW_16CSP
) {
156 struct snd_sb_csp
*csp
= chip
->csp
;
158 if (csp
->running
& SNDRV_SB_CSP_ST_LOADED
) {
159 /* manually loaded codec */
160 if (csp
->mode
& SNDRV_SB_CSP_MODE_DSP_WRITE
) {
161 runtime
->hw
.formats
|= csp
->acc_format
;
164 /* autoloaded codecs */
165 runtime
->hw
.formats
|= SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
|
166 SNDRV_PCM_FMTBIT_IMA_ADPCM
;
171 static void snd_sb16_csp_playback_close(struct snd_sb
*chip
)
173 if ((chip
->hardware
== SB_HW_16CSP
) && (chip
->open
== SNDRV_SB_CSP_MODE_DSP_WRITE
)) {
174 struct snd_sb_csp
*csp
= chip
->csp
;
176 if (csp
->ops
.csp_stop(csp
) == 0) {
177 csp
->ops
.csp_unuse(csp
);
183 static void snd_sb16_csp_capture_open(struct snd_sb
*chip
, struct snd_pcm_runtime
*runtime
)
185 /* CSP coders support only 16bit transfers */
186 if (chip
->hardware
== SB_HW_16CSP
) {
187 struct snd_sb_csp
*csp
= chip
->csp
;
189 if (csp
->running
& SNDRV_SB_CSP_ST_LOADED
) {
190 /* manually loaded codec */
191 if (csp
->mode
& SNDRV_SB_CSP_MODE_DSP_READ
) {
192 runtime
->hw
.formats
|= csp
->acc_format
;
195 /* autoloaded codecs */
196 runtime
->hw
.formats
|= SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
|
197 SNDRV_PCM_FMTBIT_IMA_ADPCM
;
202 static void snd_sb16_csp_capture_close(struct snd_sb
*chip
)
204 if ((chip
->hardware
== SB_HW_16CSP
) && (chip
->open
== SNDRV_SB_CSP_MODE_DSP_READ
)) {
205 struct snd_sb_csp
*csp
= chip
->csp
;
207 if (csp
->ops
.csp_stop(csp
) == 0) {
208 csp
->ops
.csp_unuse(csp
);
214 #define snd_sb16_csp_playback_prepare(chip, runtime) /*nop*/
215 #define snd_sb16_csp_capture_prepare(chip, runtime) /*nop*/
216 #define snd_sb16_csp_update(chip) /*nop*/
217 #define snd_sb16_csp_playback_open(chip, runtime) /*nop*/
218 #define snd_sb16_csp_playback_close(chip) /*nop*/
219 #define snd_sb16_csp_capture_open(chip, runtime) /*nop*/
220 #define snd_sb16_csp_capture_close(chip) /*nop*/
224 static void snd_sb16_setup_rate(struct snd_sb
*chip
,
230 spin_lock_irqsave(&chip
->reg_lock
, flags
);
231 if (chip
->mode
& (channel
== SNDRV_PCM_STREAM_PLAYBACK
? SB_MODE_PLAYBACK_16
: SB_MODE_CAPTURE_16
))
232 snd_sb_ack_16bit(chip
);
234 snd_sb_ack_8bit(chip
);
235 if (!(chip
->mode
& SB_RATE_LOCK
)) {
236 chip
->locked_rate
= rate
;
237 snd_sbdsp_command(chip
, SB_DSP_SAMPLE_RATE_IN
);
238 snd_sbdsp_command(chip
, rate
>> 8);
239 snd_sbdsp_command(chip
, rate
& 0xff);
240 snd_sbdsp_command(chip
, SB_DSP_SAMPLE_RATE_OUT
);
241 snd_sbdsp_command(chip
, rate
>> 8);
242 snd_sbdsp_command(chip
, rate
& 0xff);
244 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
247 static int snd_sb16_hw_params(struct snd_pcm_substream
*substream
,
248 struct snd_pcm_hw_params
*hw_params
)
250 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
253 static int snd_sb16_hw_free(struct snd_pcm_substream
*substream
)
255 snd_pcm_lib_free_pages(substream
);
259 static int snd_sb16_playback_prepare(struct snd_pcm_substream
*substream
)
262 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
263 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
264 unsigned char format
;
265 unsigned int size
, count
, dma
;
267 snd_sb16_csp_playback_prepare(chip
, runtime
);
268 if (snd_pcm_format_unsigned(runtime
->format
) > 0) {
269 format
= runtime
->channels
> 1 ? SB_DSP4_MODE_UNS_STEREO
: SB_DSP4_MODE_UNS_MONO
;
271 format
= runtime
->channels
> 1 ? SB_DSP4_MODE_SIGN_STEREO
: SB_DSP4_MODE_SIGN_MONO
;
274 snd_sb16_setup_rate(chip
, runtime
->rate
, SNDRV_PCM_STREAM_PLAYBACK
);
275 size
= chip
->p_dma_size
= snd_pcm_lib_buffer_bytes(substream
);
276 dma
= (chip
->mode
& SB_MODE_PLAYBACK_8
) ? chip
->dma8
: chip
->dma16
;
277 snd_dma_program(dma
, runtime
->dma_addr
, size
, DMA_MODE_WRITE
| DMA_AUTOINIT
);
279 count
= snd_pcm_lib_period_bytes(substream
);
280 spin_lock_irqsave(&chip
->reg_lock
, flags
);
281 if (chip
->mode
& SB_MODE_PLAYBACK_16
) {
284 snd_sbdsp_command(chip
, SB_DSP4_OUT16_AI
);
285 snd_sbdsp_command(chip
, format
);
286 snd_sbdsp_command(chip
, count
& 0xff);
287 snd_sbdsp_command(chip
, count
>> 8);
288 snd_sbdsp_command(chip
, SB_DSP_DMA16_OFF
);
291 snd_sbdsp_command(chip
, SB_DSP4_OUT8_AI
);
292 snd_sbdsp_command(chip
, format
);
293 snd_sbdsp_command(chip
, count
& 0xff);
294 snd_sbdsp_command(chip
, count
>> 8);
295 snd_sbdsp_command(chip
, SB_DSP_DMA8_OFF
);
297 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
301 static int snd_sb16_playback_trigger(struct snd_pcm_substream
*substream
,
304 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
307 spin_lock(&chip
->reg_lock
);
309 case SNDRV_PCM_TRIGGER_START
:
310 case SNDRV_PCM_TRIGGER_RESUME
:
311 chip
->mode
|= SB_RATE_LOCK_PLAYBACK
;
312 snd_sbdsp_command(chip
, chip
->mode
& SB_MODE_PLAYBACK_16
? SB_DSP_DMA16_ON
: SB_DSP_DMA8_ON
);
314 case SNDRV_PCM_TRIGGER_STOP
:
315 case SNDRV_PCM_TRIGGER_SUSPEND
:
316 snd_sbdsp_command(chip
, chip
->mode
& SB_MODE_PLAYBACK_16
? SB_DSP_DMA16_OFF
: SB_DSP_DMA8_OFF
);
317 /* next two lines are needed for some types of DSP4 (SB AWE 32 - 4.13) */
318 if (chip
->mode
& SB_RATE_LOCK_CAPTURE
)
319 snd_sbdsp_command(chip
, chip
->mode
& SB_MODE_CAPTURE_16
? SB_DSP_DMA16_ON
: SB_DSP_DMA8_ON
);
320 chip
->mode
&= ~SB_RATE_LOCK_PLAYBACK
;
325 spin_unlock(&chip
->reg_lock
);
329 static int snd_sb16_capture_prepare(struct snd_pcm_substream
*substream
)
332 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
333 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
334 unsigned char format
;
335 unsigned int size
, count
, dma
;
337 snd_sb16_csp_capture_prepare(chip
, runtime
);
338 if (snd_pcm_format_unsigned(runtime
->format
) > 0) {
339 format
= runtime
->channels
> 1 ? SB_DSP4_MODE_UNS_STEREO
: SB_DSP4_MODE_UNS_MONO
;
341 format
= runtime
->channels
> 1 ? SB_DSP4_MODE_SIGN_STEREO
: SB_DSP4_MODE_SIGN_MONO
;
343 snd_sb16_setup_rate(chip
, runtime
->rate
, SNDRV_PCM_STREAM_CAPTURE
);
344 size
= chip
->c_dma_size
= snd_pcm_lib_buffer_bytes(substream
);
345 dma
= (chip
->mode
& SB_MODE_CAPTURE_8
) ? chip
->dma8
: chip
->dma16
;
346 snd_dma_program(dma
, runtime
->dma_addr
, size
, DMA_MODE_READ
| DMA_AUTOINIT
);
348 count
= snd_pcm_lib_period_bytes(substream
);
349 spin_lock_irqsave(&chip
->reg_lock
, flags
);
350 if (chip
->mode
& SB_MODE_CAPTURE_16
) {
353 snd_sbdsp_command(chip
, SB_DSP4_IN16_AI
);
354 snd_sbdsp_command(chip
, format
);
355 snd_sbdsp_command(chip
, count
& 0xff);
356 snd_sbdsp_command(chip
, count
>> 8);
357 snd_sbdsp_command(chip
, SB_DSP_DMA16_OFF
);
360 snd_sbdsp_command(chip
, SB_DSP4_IN8_AI
);
361 snd_sbdsp_command(chip
, format
);
362 snd_sbdsp_command(chip
, count
& 0xff);
363 snd_sbdsp_command(chip
, count
>> 8);
364 snd_sbdsp_command(chip
, SB_DSP_DMA8_OFF
);
366 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
370 static int snd_sb16_capture_trigger(struct snd_pcm_substream
*substream
,
373 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
376 spin_lock(&chip
->reg_lock
);
378 case SNDRV_PCM_TRIGGER_START
:
379 case SNDRV_PCM_TRIGGER_RESUME
:
380 chip
->mode
|= SB_RATE_LOCK_CAPTURE
;
381 snd_sbdsp_command(chip
, chip
->mode
& SB_MODE_CAPTURE_16
? SB_DSP_DMA16_ON
: SB_DSP_DMA8_ON
);
383 case SNDRV_PCM_TRIGGER_STOP
:
384 case SNDRV_PCM_TRIGGER_SUSPEND
:
385 snd_sbdsp_command(chip
, chip
->mode
& SB_MODE_CAPTURE_16
? SB_DSP_DMA16_OFF
: SB_DSP_DMA8_OFF
);
386 /* next two lines are needed for some types of DSP4 (SB AWE 32 - 4.13) */
387 if (chip
->mode
& SB_RATE_LOCK_PLAYBACK
)
388 snd_sbdsp_command(chip
, chip
->mode
& SB_MODE_PLAYBACK_16
? SB_DSP_DMA16_ON
: SB_DSP_DMA8_ON
);
389 chip
->mode
&= ~SB_RATE_LOCK_CAPTURE
;
394 spin_unlock(&chip
->reg_lock
);
398 irqreturn_t
snd_sb16dsp_interrupt(int irq
, void *dev_id
)
400 struct snd_sb
*chip
= dev_id
;
401 unsigned char status
;
404 spin_lock(&chip
->mixer_lock
);
405 status
= snd_sbmixer_read(chip
, SB_DSP4_IRQSTATUS
);
406 spin_unlock(&chip
->mixer_lock
);
407 if ((status
& SB_IRQTYPE_MPUIN
) && chip
->rmidi_callback
)
408 chip
->rmidi_callback(irq
, chip
->rmidi
->private_data
);
409 if (status
& SB_IRQTYPE_8BIT
) {
411 if (chip
->mode
& SB_MODE_PLAYBACK_8
) {
412 snd_pcm_period_elapsed(chip
->playback_substream
);
413 snd_sb16_csp_update(chip
);
416 if (chip
->mode
& SB_MODE_CAPTURE_8
) {
417 snd_pcm_period_elapsed(chip
->capture_substream
);
420 spin_lock(&chip
->reg_lock
);
422 snd_sbdsp_command(chip
, SB_DSP_DMA8_OFF
);
423 snd_sb_ack_8bit(chip
);
424 spin_unlock(&chip
->reg_lock
);
426 if (status
& SB_IRQTYPE_16BIT
) {
428 if (chip
->mode
& SB_MODE_PLAYBACK_16
) {
429 snd_pcm_period_elapsed(chip
->playback_substream
);
430 snd_sb16_csp_update(chip
);
433 if (chip
->mode
& SB_MODE_CAPTURE_16
) {
434 snd_pcm_period_elapsed(chip
->capture_substream
);
437 spin_lock(&chip
->reg_lock
);
439 snd_sbdsp_command(chip
, SB_DSP_DMA16_OFF
);
440 snd_sb_ack_16bit(chip
);
441 spin_unlock(&chip
->reg_lock
);
450 static snd_pcm_uframes_t
snd_sb16_playback_pointer(struct snd_pcm_substream
*substream
)
452 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
456 dma
= (chip
->mode
& SB_MODE_PLAYBACK_8
) ? chip
->dma8
: chip
->dma16
;
457 ptr
= snd_dma_pointer(dma
, chip
->p_dma_size
);
458 return bytes_to_frames(substream
->runtime
, ptr
);
461 static snd_pcm_uframes_t
snd_sb16_capture_pointer(struct snd_pcm_substream
*substream
)
463 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
467 dma
= (chip
->mode
& SB_MODE_CAPTURE_8
) ? chip
->dma8
: chip
->dma16
;
468 ptr
= snd_dma_pointer(dma
, chip
->c_dma_size
);
469 return bytes_to_frames(substream
->runtime
, ptr
);
476 static struct snd_pcm_hardware snd_sb16_playback
=
478 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
479 SNDRV_PCM_INFO_MMAP_VALID
),
481 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_44100
,
486 .buffer_bytes_max
= (128*1024),
487 .period_bytes_min
= 64,
488 .period_bytes_max
= (128*1024),
494 static struct snd_pcm_hardware snd_sb16_capture
=
496 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
497 SNDRV_PCM_INFO_MMAP_VALID
),
499 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_44100
,
504 .buffer_bytes_max
= (128*1024),
505 .period_bytes_min
= 64,
506 .period_bytes_max
= (128*1024),
516 static int snd_sb16_playback_open(struct snd_pcm_substream
*substream
)
519 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
520 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
522 spin_lock_irqsave(&chip
->open_lock
, flags
);
523 if (chip
->mode
& SB_MODE_PLAYBACK
) {
524 spin_unlock_irqrestore(&chip
->open_lock
, flags
);
527 runtime
->hw
= snd_sb16_playback
;
529 /* skip if 16 bit DMA was reserved for capture */
530 if (chip
->force_mode16
& SB_MODE_CAPTURE_16
)
533 if (chip
->dma16
>= 0 && !(chip
->mode
& SB_MODE_CAPTURE_16
)) {
534 chip
->mode
|= SB_MODE_PLAYBACK_16
;
535 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
;
537 if (chip
->dma16
<= 3) {
538 runtime
->hw
.buffer_bytes_max
=
539 runtime
->hw
.period_bytes_max
= 64 * 1024;
541 snd_sb16_csp_playback_open(chip
, runtime
);
547 if (chip
->dma8
>= 0 && !(chip
->mode
& SB_MODE_CAPTURE_8
)) {
548 chip
->mode
|= SB_MODE_PLAYBACK_8
;
549 /* DSP v 4.xx can transfer 16bit data through 8bit DMA channel, SBHWPG 2-7 */
550 if (chip
->dma16
< 0) {
551 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
;
552 chip
->mode
|= SB_MODE_PLAYBACK_16
;
554 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S8
;
556 runtime
->hw
.buffer_bytes_max
=
557 runtime
->hw
.period_bytes_max
= 64 * 1024;
560 spin_unlock_irqrestore(&chip
->open_lock
, flags
);
564 if (chip
->hardware
== SB_HW_ALS100
)
565 runtime
->hw
.rate_max
= 48000;
566 if (chip
->hardware
== SB_HW_CS5530
) {
567 runtime
->hw
.buffer_bytes_max
= 32 * 1024;
568 runtime
->hw
.periods_min
= 2;
569 runtime
->hw
.rate_min
= 44100;
571 if (chip
->mode
& SB_RATE_LOCK
)
572 runtime
->hw
.rate_min
= runtime
->hw
.rate_max
= chip
->locked_rate
;
573 chip
->playback_substream
= substream
;
574 spin_unlock_irqrestore(&chip
->open_lock
, flags
);
578 static int snd_sb16_playback_close(struct snd_pcm_substream
*substream
)
581 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
583 snd_sb16_csp_playback_close(chip
);
584 spin_lock_irqsave(&chip
->open_lock
, flags
);
585 chip
->playback_substream
= NULL
;
586 chip
->mode
&= ~SB_MODE_PLAYBACK
;
587 spin_unlock_irqrestore(&chip
->open_lock
, flags
);
591 static int snd_sb16_capture_open(struct snd_pcm_substream
*substream
)
594 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
595 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
597 spin_lock_irqsave(&chip
->open_lock
, flags
);
598 if (chip
->mode
& SB_MODE_CAPTURE
) {
599 spin_unlock_irqrestore(&chip
->open_lock
, flags
);
602 runtime
->hw
= snd_sb16_capture
;
604 /* skip if 16 bit DMA was reserved for playback */
605 if (chip
->force_mode16
& SB_MODE_PLAYBACK_16
)
608 if (chip
->dma16
>= 0 && !(chip
->mode
& SB_MODE_PLAYBACK_16
)) {
609 chip
->mode
|= SB_MODE_CAPTURE_16
;
610 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
;
612 if (chip
->dma16
<= 3) {
613 runtime
->hw
.buffer_bytes_max
=
614 runtime
->hw
.period_bytes_max
= 64 * 1024;
616 snd_sb16_csp_capture_open(chip
, runtime
);
622 if (chip
->dma8
>= 0 && !(chip
->mode
& SB_MODE_PLAYBACK_8
)) {
623 chip
->mode
|= SB_MODE_CAPTURE_8
;
624 /* DSP v 4.xx can transfer 16bit data through 8bit DMA channel, SBHWPG 2-7 */
625 if (chip
->dma16
< 0) {
626 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U16_LE
;
627 chip
->mode
|= SB_MODE_CAPTURE_16
;
629 runtime
->hw
.formats
= SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S8
;
631 runtime
->hw
.buffer_bytes_max
=
632 runtime
->hw
.period_bytes_max
= 64 * 1024;
635 spin_unlock_irqrestore(&chip
->open_lock
, flags
);
639 if (chip
->hardware
== SB_HW_ALS100
)
640 runtime
->hw
.rate_max
= 48000;
641 if (chip
->hardware
== SB_HW_CS5530
) {
642 runtime
->hw
.buffer_bytes_max
= 32 * 1024;
643 runtime
->hw
.periods_min
= 2;
644 runtime
->hw
.rate_min
= 44100;
646 if (chip
->mode
& SB_RATE_LOCK
)
647 runtime
->hw
.rate_min
= runtime
->hw
.rate_max
= chip
->locked_rate
;
648 chip
->capture_substream
= substream
;
649 spin_unlock_irqrestore(&chip
->open_lock
, flags
);
653 static int snd_sb16_capture_close(struct snd_pcm_substream
*substream
)
656 struct snd_sb
*chip
= snd_pcm_substream_chip(substream
);
658 snd_sb16_csp_capture_close(chip
);
659 spin_lock_irqsave(&chip
->open_lock
, flags
);
660 chip
->capture_substream
= NULL
;
661 chip
->mode
&= ~SB_MODE_CAPTURE
;
662 spin_unlock_irqrestore(&chip
->open_lock
, flags
);
667 * DMA control interface
670 static int snd_sb16_set_dma_mode(struct snd_sb
*chip
, int what
)
672 if (chip
->dma8
< 0 || chip
->dma16
< 0) {
673 if (snd_BUG_ON(what
))
678 chip
->force_mode16
= 0;
679 } else if (what
== 1) {
680 chip
->force_mode16
= SB_MODE_PLAYBACK_16
;
681 } else if (what
== 2) {
682 chip
->force_mode16
= SB_MODE_CAPTURE_16
;
689 static int snd_sb16_get_dma_mode(struct snd_sb
*chip
)
691 if (chip
->dma8
< 0 || chip
->dma16
< 0)
693 switch (chip
->force_mode16
) {
694 case SB_MODE_PLAYBACK_16
:
696 case SB_MODE_CAPTURE_16
:
703 static int snd_sb16_dma_control_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
705 static char *texts
[3] = {
706 "Auto", "Playback", "Capture"
709 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_ENUMERATED
;
711 uinfo
->value
.enumerated
.items
= 3;
712 if (uinfo
->value
.enumerated
.item
> 2)
713 uinfo
->value
.enumerated
.item
= 2;
714 strcpy(uinfo
->value
.enumerated
.name
, texts
[uinfo
->value
.enumerated
.item
]);
718 static int snd_sb16_dma_control_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
720 struct snd_sb
*chip
= snd_kcontrol_chip(kcontrol
);
723 spin_lock_irqsave(&chip
->reg_lock
, flags
);
724 ucontrol
->value
.enumerated
.item
[0] = snd_sb16_get_dma_mode(chip
);
725 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
729 static int snd_sb16_dma_control_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
731 struct snd_sb
*chip
= snd_kcontrol_chip(kcontrol
);
733 unsigned char nval
, oval
;
736 if ((nval
= ucontrol
->value
.enumerated
.item
[0]) > 2)
738 spin_lock_irqsave(&chip
->reg_lock
, flags
);
739 oval
= snd_sb16_get_dma_mode(chip
);
740 change
= nval
!= oval
;
741 snd_sb16_set_dma_mode(chip
, nval
);
742 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
746 static struct snd_kcontrol_new snd_sb16_dma_control
= {
747 .iface
= SNDRV_CTL_ELEM_IFACE_CARD
,
748 .name
= "16-bit DMA Allocation",
749 .info
= snd_sb16_dma_control_info
,
750 .get
= snd_sb16_dma_control_get
,
751 .put
= snd_sb16_dma_control_put
755 * Initialization part
758 int snd_sb16dsp_configure(struct snd_sb
* chip
)
761 unsigned char irqreg
= 0, dmareg
= 0, mpureg
;
762 unsigned char realirq
, realdma
, realmpureg
;
763 /* note: mpu register should be present only on SB16 Vibra soundcards */
765 // printk(KERN_DEBUG "codec->irq=%i, codec->dma8=%i, codec->dma16=%i\n", chip->irq, chip->dma8, chip->dma16);
766 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
767 mpureg
= snd_sbmixer_read(chip
, SB_DSP4_MPUSETUP
) & ~0x06;
768 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
772 irqreg
|= SB_IRQSETUP_IRQ9
;
775 irqreg
|= SB_IRQSETUP_IRQ5
;
778 irqreg
|= SB_IRQSETUP_IRQ7
;
781 irqreg
|= SB_IRQSETUP_IRQ10
;
786 if (chip
->dma8
>= 0) {
787 switch (chip
->dma8
) {
789 dmareg
|= SB_DMASETUP_DMA0
;
792 dmareg
|= SB_DMASETUP_DMA1
;
795 dmareg
|= SB_DMASETUP_DMA3
;
801 if (chip
->dma16
>= 0 && chip
->dma16
!= chip
->dma8
) {
802 switch (chip
->dma16
) {
804 dmareg
|= SB_DMASETUP_DMA5
;
807 dmareg
|= SB_DMASETUP_DMA6
;
810 dmareg
|= SB_DMASETUP_DMA7
;
816 switch (chip
->mpu_port
) {
824 mpureg
|= 0x02; /* disable MPU */
826 spin_lock_irqsave(&chip
->mixer_lock
, flags
);
828 snd_sbmixer_write(chip
, SB_DSP4_IRQSETUP
, irqreg
);
829 realirq
= snd_sbmixer_read(chip
, SB_DSP4_IRQSETUP
);
831 snd_sbmixer_write(chip
, SB_DSP4_DMASETUP
, dmareg
);
832 realdma
= snd_sbmixer_read(chip
, SB_DSP4_DMASETUP
);
834 snd_sbmixer_write(chip
, SB_DSP4_MPUSETUP
, mpureg
);
835 realmpureg
= snd_sbmixer_read(chip
, SB_DSP4_MPUSETUP
);
837 spin_unlock_irqrestore(&chip
->mixer_lock
, flags
);
838 if ((~realirq
) & irqreg
|| (~realdma
) & dmareg
) {
839 snd_printk(KERN_ERR
"SB16 [0x%lx]: unable to set DMA & IRQ (PnP device?)\n", chip
->port
);
840 snd_printk(KERN_ERR
"SB16 [0x%lx]: wanted: irqreg=0x%x, dmareg=0x%x, mpureg = 0x%x\n", chip
->port
, realirq
, realdma
, realmpureg
);
841 snd_printk(KERN_ERR
"SB16 [0x%lx]: got: irqreg=0x%x, dmareg=0x%x, mpureg = 0x%x\n", chip
->port
, irqreg
, dmareg
, mpureg
);
847 static struct snd_pcm_ops snd_sb16_playback_ops
= {
848 .open
= snd_sb16_playback_open
,
849 .close
= snd_sb16_playback_close
,
850 .ioctl
= snd_pcm_lib_ioctl
,
851 .hw_params
= snd_sb16_hw_params
,
852 .hw_free
= snd_sb16_hw_free
,
853 .prepare
= snd_sb16_playback_prepare
,
854 .trigger
= snd_sb16_playback_trigger
,
855 .pointer
= snd_sb16_playback_pointer
,
858 static struct snd_pcm_ops snd_sb16_capture_ops
= {
859 .open
= snd_sb16_capture_open
,
860 .close
= snd_sb16_capture_close
,
861 .ioctl
= snd_pcm_lib_ioctl
,
862 .hw_params
= snd_sb16_hw_params
,
863 .hw_free
= snd_sb16_hw_free
,
864 .prepare
= snd_sb16_capture_prepare
,
865 .trigger
= snd_sb16_capture_trigger
,
866 .pointer
= snd_sb16_capture_pointer
,
869 int snd_sb16dsp_pcm(struct snd_sb
* chip
, int device
, struct snd_pcm
** rpcm
)
871 struct snd_card
*card
= chip
->card
;
877 if ((err
= snd_pcm_new(card
, "SB16 DSP", device
, 1, 1, &pcm
)) < 0)
879 sprintf(pcm
->name
, "DSP v%i.%i", chip
->version
>> 8, chip
->version
& 0xff);
880 pcm
->info_flags
= SNDRV_PCM_INFO_JOINT_DUPLEX
;
881 pcm
->private_data
= chip
;
883 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &snd_sb16_playback_ops
);
884 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &snd_sb16_capture_ops
);
886 if (chip
->dma16
>= 0 && chip
->dma8
!= chip
->dma16
)
887 snd_ctl_add(card
, snd_ctl_new1(&snd_sb16_dma_control
, chip
));
889 pcm
->info_flags
= SNDRV_PCM_INFO_HALF_DUPLEX
;
891 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
900 const struct snd_pcm_ops
*snd_sb16dsp_get_pcm_ops(int direction
)
902 return direction
== SNDRV_PCM_STREAM_PLAYBACK
?
903 &snd_sb16_playback_ops
: &snd_sb16_capture_ops
;
906 EXPORT_SYMBOL(snd_sb16dsp_pcm
);
907 EXPORT_SYMBOL(snd_sb16dsp_get_pcm_ops
);
908 EXPORT_SYMBOL(snd_sb16dsp_configure
);
909 EXPORT_SYMBOL(snd_sb16dsp_interrupt
);
915 static int __init
alsa_sb16_init(void)
920 static void __exit
alsa_sb16_exit(void)
924 module_init(alsa_sb16_init
)
925 module_exit(alsa_sb16_exit
)