?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] sparc64: Reduce ptrace cache flushing
[linux-2.6/kvm.git] / sound / isa / sb / sb16_main.c
bloba6a0fa51626840fd741a4532535f57a96a3dadb1
1 /*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.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
9 * duplex!!!
10 * Note: 16-bit wide is assigned to first direction which made request.
11 * With full duplex - playback is preferred with abstract layer.
12 *
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.
18 *
19 *
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.
24 *
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.
29 *
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
33 *
34 */
35
36 #include <sound/driver.h>
37 #include <asm/io.h>
38 #include <asm/dma.h>
39 #include <linux/init.h>
40 #include <linux/time.h>
41 #include <sound/core.h>
42 #include <sound/sb.h>
43 #include <sound/sb16_csp.h>
44 #include <sound/mpu401.h>
45 #include <sound/control.h>
46 #include <sound/info.h>
47
48 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
49 MODULE_DESCRIPTION("Routines for control of 16-bit SoundBlaster cards and clones");
50 MODULE_LICENSE("GPL");
51
52 #ifdef CONFIG_SND_SB16_CSP
53 static void snd_sb16_csp_playback_prepare(sb_t *chip, snd_pcm_runtime_t *runtime)
54 {
55 if (chip->hardware == SB_HW_16CSP) {
56 snd_sb_csp_t *csp = chip->csp;
57
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 */
65 goto __start_CSP;
66 }
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 */
74 goto __start_CSP;
75 }
76 }
77 }
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);
83 } else {
84 __start_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);
92 } else {
93 /* Success, CSP acquired and running */
94 chip->open = SNDRV_SB_CSP_MODE_DSP_WRITE;
95 }
96 }
97 }
98 }
99 }
100
101 static void snd_sb16_csp_capture_prepare(sb_t *chip, snd_pcm_runtime_t *runtime)
102 {
103 if (chip->hardware == SB_HW_16CSP) {
104 snd_sb_csp_t *csp = chip->csp;
105
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 */
113 goto __start_CSP;
114 }
115 }
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);
121 } else {
122 __start_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);
130 } else {
131 /* Success, CSP acquired and running */
132 chip->open = SNDRV_SB_CSP_MODE_DSP_READ;
133 }
134 }
135 }
136 }
137 }
138
139 static void snd_sb16_csp_update(sb_t *chip)
140 {
141 if (chip->hardware == SB_HW_16CSP) {
142 snd_sb_csp_t *csp = chip->csp;
143
144 if (csp->qpos_changed) {
145 spin_lock(&chip->reg_lock);
146 csp->ops.csp_qsound_transfer (csp);
147 spin_unlock(&chip->reg_lock);
148 }
149 }
150 }
151
152 static void snd_sb16_csp_playback_open(sb_t *chip, snd_pcm_runtime_t *runtime)
153 {
154 /* CSP decoders (QSound excluded) support only 16bit transfers */
155 if (chip->hardware == SB_HW_16CSP) {
156 snd_sb_csp_t *csp = chip->csp;
157
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;
162 }
163 } else {
164 /* autoloaded codecs */
165 runtime->hw.formats |= SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
166 SNDRV_PCM_FMTBIT_IMA_ADPCM;
167 }
168 }
169 }
170
171 static void snd_sb16_csp_playback_close(sb_t *chip)
172 {
173 if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_WRITE)) {
174 snd_sb_csp_t *csp = chip->csp;
175
176 if (csp->ops.csp_stop(csp) == 0) {
177 csp->ops.csp_unuse(csp);
178 chip->open = 0;
179 }
180 }
181 }
182
183 static void snd_sb16_csp_capture_open(sb_t *chip, snd_pcm_runtime_t *runtime)
184 {
185 /* CSP coders support only 16bit transfers */
186 if (chip->hardware == SB_HW_16CSP) {
187 snd_sb_csp_t *csp = chip->csp;
188
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;
193 }
194 } else {
195 /* autoloaded codecs */
196 runtime->hw.formats |= SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
197 SNDRV_PCM_FMTBIT_IMA_ADPCM;
198 }
199 }
200 }
201
202 static void snd_sb16_csp_capture_close(sb_t *chip)
203 {
204 if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_READ)) {
205 snd_sb_csp_t *csp = chip->csp;
206
207 if (csp->ops.csp_stop(csp) == 0) {
208 csp->ops.csp_unuse(csp);
209 chip->open = 0;
210 }
211 }
212 }
213 #else
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*/
221 #endif
222
223
224 static void snd_sb16_setup_rate(sb_t *chip,
225 unsigned short rate,
226 int channel)
227 {
228 unsigned long flags;
229
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);
233 else
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);
243 }
244 spin_unlock_irqrestore(&chip->reg_lock, flags);
245 }
246
247 static int snd_sb16_hw_params(snd_pcm_substream_t * substream,
248 snd_pcm_hw_params_t * hw_params)
249 {
250 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
251 }
252
253 static int snd_sb16_hw_free(snd_pcm_substream_t * substream)
254 {
255 snd_pcm_lib_free_pages(substream);
256 return 0;
257 }
258
259 static int snd_sb16_playback_prepare(snd_pcm_substream_t * substream)
260 {
261 unsigned long flags;
262 sb_t *chip = snd_pcm_substream_chip(substream);
263 snd_pcm_runtime_t *runtime = substream->runtime;
264 unsigned char format;
265 unsigned int size, count, dma;
266
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;
270 } else {
271 format = runtime->channels > 1 ? SB_DSP4_MODE_SIGN_STEREO : SB_DSP4_MODE_SIGN_MONO;
272 }
273
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);
278
279 count = snd_pcm_lib_period_bytes(substream);
280 spin_lock_irqsave(&chip->reg_lock, flags);
281 if (chip->mode & SB_MODE_PLAYBACK_16) {
282 count >>= 1;
283 count--;
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);
289 } else {
290 count--;
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);
296 }
297 spin_unlock_irqrestore(&chip->reg_lock, flags);
298 return 0;
299 }
300
301 static int snd_sb16_playback_trigger(snd_pcm_substream_t * substream,
302 int cmd)
303 {
304 sb_t *chip = snd_pcm_substream_chip(substream);
305 int result = 0;
306
307 spin_lock(&chip->reg_lock);
308 switch (cmd) {
309 case SNDRV_PCM_TRIGGER_START:
310 chip->mode |= SB_RATE_LOCK_PLAYBACK;
311 snd_sbdsp_command(chip, chip->mode & SB_MODE_PLAYBACK_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
312 break;
313 case SNDRV_PCM_TRIGGER_STOP:
314 snd_sbdsp_command(chip, chip->mode & SB_MODE_PLAYBACK_16 ? SB_DSP_DMA16_OFF : SB_DSP_DMA8_OFF);
315 /* next two lines are needed for some types of DSP4 (SB AWE 32 - 4.13) */
316 if (chip->mode & SB_RATE_LOCK_CAPTURE)
317 snd_sbdsp_command(chip, chip->mode & SB_MODE_CAPTURE_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
318 chip->mode &= ~SB_RATE_LOCK_PLAYBACK;
319 break;
320 default:
321 result = -EINVAL;
322 }
323 spin_unlock(&chip->reg_lock);
324 return result;
325 }
326
327 static int snd_sb16_capture_prepare(snd_pcm_substream_t * substream)
328 {
329 unsigned long flags;
330 sb_t *chip = snd_pcm_substream_chip(substream);
331 snd_pcm_runtime_t *runtime = substream->runtime;
332 unsigned char format;
333 unsigned int size, count, dma;
334
335 snd_sb16_csp_capture_prepare(chip, runtime);
336 if (snd_pcm_format_unsigned(runtime->format) > 0) {
337 format = runtime->channels > 1 ? SB_DSP4_MODE_UNS_STEREO : SB_DSP4_MODE_UNS_MONO;
338 } else {
339 format = runtime->channels > 1 ? SB_DSP4_MODE_SIGN_STEREO : SB_DSP4_MODE_SIGN_MONO;
340 }
341 snd_sb16_setup_rate(chip, runtime->rate, SNDRV_PCM_STREAM_CAPTURE);
342 size = chip->c_dma_size = snd_pcm_lib_buffer_bytes(substream);
343 dma = (chip->mode & SB_MODE_CAPTURE_8) ? chip->dma8 : chip->dma16;
344 snd_dma_program(dma, runtime->dma_addr, size, DMA_MODE_READ | DMA_AUTOINIT);
345
346 count = snd_pcm_lib_period_bytes(substream);
347 spin_lock_irqsave(&chip->reg_lock, flags);
348 if (chip->mode & SB_MODE_CAPTURE_16) {
349 count >>= 1;
350 count--;
351 snd_sbdsp_command(chip, SB_DSP4_IN16_AI);
352 snd_sbdsp_command(chip, format);
353 snd_sbdsp_command(chip, count & 0xff);
354 snd_sbdsp_command(chip, count >> 8);
355 snd_sbdsp_command(chip, SB_DSP_DMA16_OFF);
356 } else {
357 count--;
358 snd_sbdsp_command(chip, SB_DSP4_IN8_AI);
359 snd_sbdsp_command(chip, format);
360 snd_sbdsp_command(chip, count & 0xff);
361 snd_sbdsp_command(chip, count >> 8);
362 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
363 }
364 spin_unlock_irqrestore(&chip->reg_lock, flags);
365 return 0;
366 }
367
368 static int snd_sb16_capture_trigger(snd_pcm_substream_t * substream,
369 int cmd)
370 {
371 sb_t *chip = snd_pcm_substream_chip(substream);
372 int result = 0;
373
374 spin_lock(&chip->reg_lock);
375 switch (cmd) {
376 case SNDRV_PCM_TRIGGER_START:
377 chip->mode |= SB_RATE_LOCK_CAPTURE;
378 snd_sbdsp_command(chip, chip->mode & SB_MODE_CAPTURE_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
379 break;
380 case SNDRV_PCM_TRIGGER_STOP:
381 snd_sbdsp_command(chip, chip->mode & SB_MODE_CAPTURE_16 ? SB_DSP_DMA16_OFF : SB_DSP_DMA8_OFF);
382 /* next two lines are needed for some types of DSP4 (SB AWE 32 - 4.13) */
383 if (chip->mode & SB_RATE_LOCK_PLAYBACK)
384 snd_sbdsp_command(chip, chip->mode & SB_MODE_PLAYBACK_16 ? SB_DSP_DMA16_ON : SB_DSP_DMA8_ON);
385 chip->mode &= ~SB_RATE_LOCK_CAPTURE;
386 break;
387 default:
388 result = -EINVAL;
389 }
390 spin_unlock(&chip->reg_lock);
391 return result;
392 }
393
394 irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
395 {
396 sb_t *chip = dev_id;
397 unsigned char status;
398 int ok;
399
400 spin_lock(&chip->mixer_lock);
401 status = snd_sbmixer_read(chip, SB_DSP4_IRQSTATUS);
402 spin_unlock(&chip->mixer_lock);
403 if ((status & SB_IRQTYPE_MPUIN) && chip->rmidi_callback)
404 chip->rmidi_callback(irq, chip->rmidi->private_data, regs);
405 if (status & SB_IRQTYPE_8BIT) {
406 ok = 0;
407 if (chip->mode & SB_MODE_PLAYBACK_8) {
408 snd_pcm_period_elapsed(chip->playback_substream);
409 snd_sb16_csp_update(chip);
410 ok++;
411 }
412 if (chip->mode & SB_MODE_CAPTURE_8) {
413 snd_pcm_period_elapsed(chip->capture_substream);
414 ok++;
415 }
416 spin_lock(&chip->reg_lock);
417 if (!ok)
418 snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
419 snd_sb_ack_8bit(chip);
420 spin_unlock(&chip->reg_lock);
421 }
422 if (status & SB_IRQTYPE_16BIT) {
423 ok = 0;
424 if (chip->mode & SB_MODE_PLAYBACK_16) {
425 snd_pcm_period_elapsed(chip->playback_substream);
426 snd_sb16_csp_update(chip);
427 ok++;
428 }
429 if (chip->mode & SB_MODE_CAPTURE_16) {
430 snd_pcm_period_elapsed(chip->capture_substream);
431 ok++;
432 }
433 spin_lock(&chip->reg_lock);
434 if (!ok)
435 snd_sbdsp_command(chip, SB_DSP_DMA16_OFF);
436 snd_sb_ack_16bit(chip);
437 spin_unlock(&chip->reg_lock);
438 }
439 return IRQ_HANDLED;
440 }
441
442 /*
443
444 */
445
446 static snd_pcm_uframes_t snd_sb16_playback_pointer(snd_pcm_substream_t * substream)
447 {
448 sb_t *chip = snd_pcm_substream_chip(substream);
449 unsigned int dma;
450 size_t ptr;
451
452 dma = (chip->mode & SB_MODE_PLAYBACK_8) ? chip->dma8 : chip->dma16;
453 ptr = snd_dma_pointer(dma, chip->p_dma_size);
454 return bytes_to_frames(substream->runtime, ptr);
455 }
456
457 static snd_pcm_uframes_t snd_sb16_capture_pointer(snd_pcm_substream_t * substream)
458 {
459 sb_t *chip = snd_pcm_substream_chip(substream);
460 unsigned int dma;
461 size_t ptr;
462
463 dma = (chip->mode & SB_MODE_CAPTURE_8) ? chip->dma8 : chip->dma16;
464 ptr = snd_dma_pointer(dma, chip->c_dma_size);
465 return bytes_to_frames(substream->runtime, ptr);
466 }
467
468 /*
469
470 */
471
472 static snd_pcm_hardware_t snd_sb16_playback =
473 {
474 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
475 SNDRV_PCM_INFO_MMAP_VALID),
476 .formats = 0,
477 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_44100,
478 .rate_min = 4000,
479 .rate_max = 44100,
480 .channels_min = 1,
481 .channels_max = 2,
482 .buffer_bytes_max = (128*1024),
483 .period_bytes_min = 64,
484 .period_bytes_max = (128*1024),
485 .periods_min = 1,
486 .periods_max = 1024,
487 .fifo_size = 0,
488 };
489
490 static snd_pcm_hardware_t snd_sb16_capture =
491 {
492 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
493 SNDRV_PCM_INFO_MMAP_VALID),
494 .formats = 0,
495 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_44100,
496 .rate_min = 4000,
497 .rate_max = 44100,
498 .channels_min = 1,
499 .channels_max = 2,
500 .buffer_bytes_max = (128*1024),
501 .period_bytes_min = 64,
502 .period_bytes_max = (128*1024),
503 .periods_min = 1,
504 .periods_max = 1024,
505 .fifo_size = 0,
506 };
507
508 /*
509 * open/close
510 */
511
512 static int snd_sb16_playback_open(snd_pcm_substream_t * substream)
513 {
514 unsigned long flags;
515 sb_t *chip = snd_pcm_substream_chip(substream);
516 snd_pcm_runtime_t *runtime = substream->runtime;
517
518 spin_lock_irqsave(&chip->open_lock, flags);
519 if (chip->mode & SB_MODE_PLAYBACK) {
520 spin_unlock_irqrestore(&chip->open_lock, flags);
521 return -EAGAIN;
522 }
523 runtime->hw = snd_sb16_playback;
524
525 /* skip if 16 bit DMA was reserved for capture */
526 if (chip->force_mode16 & SB_MODE_CAPTURE_16)
527 goto __skip_16bit;
528
529 if (chip->dma16 >= 0 && !(chip->mode & SB_MODE_CAPTURE_16)) {
530 chip->mode |= SB_MODE_PLAYBACK_16;
531 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE;
532 /* Vibra16X hack */
533 if (chip->dma16 <= 3) {
534 runtime->hw.buffer_bytes_max =
535 runtime->hw.period_bytes_max = 64 * 1024;
536 } else {
537 snd_sb16_csp_playback_open(chip, runtime);
538 }
539 goto __open_ok;
540 }
541
542 __skip_16bit:
543 if (chip->dma8 >= 0 && !(chip->mode & SB_MODE_CAPTURE_8)) {
544 chip->mode |= SB_MODE_PLAYBACK_8;
545 /* DSP v 4.xx can transfer 16bit data through 8bit DMA channel, SBHWPG 2-7 */
546 if (chip->dma16 < 0) {
547 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE;
548 chip->mode |= SB_MODE_PLAYBACK_16;
549 } else {
550 runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8;
551 }
552 runtime->hw.buffer_bytes_max =
553 runtime->hw.period_bytes_max = 64 * 1024;
554 goto __open_ok;
555 }
556 spin_unlock_irqrestore(&chip->open_lock, flags);
557 return -EAGAIN;
558
559 __open_ok:
560 if (chip->hardware == SB_HW_ALS100)
561 runtime->hw.rate_max = 48000;
562 if (chip->mode & SB_RATE_LOCK)
563 runtime->hw.rate_min = runtime->hw.rate_max = chip->locked_rate;
564 chip->playback_substream = substream;
565 spin_unlock_irqrestore(&chip->open_lock, flags);
566 return 0;
567 }
568
569 static int snd_sb16_playback_close(snd_pcm_substream_t * substream)
570 {
571 unsigned long flags;
572 sb_t *chip = snd_pcm_substream_chip(substream);
573
574 snd_sb16_csp_playback_close(chip);
575 spin_lock_irqsave(&chip->open_lock, flags);
576 chip->playback_substream = NULL;
577 chip->mode &= ~SB_MODE_PLAYBACK;
578 spin_unlock_irqrestore(&chip->open_lock, flags);
579 return 0;
580 }
581
582 static int snd_sb16_capture_open(snd_pcm_substream_t * substream)
583 {
584 unsigned long flags;
585 sb_t *chip = snd_pcm_substream_chip(substream);
586 snd_pcm_runtime_t *runtime = substream->runtime;
587
588 spin_lock_irqsave(&chip->open_lock, flags);
589 if (chip->mode & SB_MODE_CAPTURE) {
590 spin_unlock_irqrestore(&chip->open_lock, flags);
591 return -EAGAIN;
592 }
593 runtime->hw = snd_sb16_capture;
594
595 /* skip if 16 bit DMA was reserved for playback */
596 if (chip->force_mode16 & SB_MODE_PLAYBACK_16)
597 goto __skip_16bit;
598
599 if (chip->dma16 >= 0 && !(chip->mode & SB_MODE_PLAYBACK_16)) {
600 chip->mode |= SB_MODE_CAPTURE_16;
601 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE;
602 /* Vibra16X hack */
603 if (chip->dma16 <= 3) {
604 runtime->hw.buffer_bytes_max =
605 runtime->hw.period_bytes_max = 64 * 1024;
606 } else {
607 snd_sb16_csp_capture_open(chip, runtime);
608 }
609 goto __open_ok;
610 }
611
612 __skip_16bit:
613 if (chip->dma8 >= 0 && !(chip->mode & SB_MODE_PLAYBACK_8)) {
614 chip->mode |= SB_MODE_CAPTURE_8;
615 /* DSP v 4.xx can transfer 16bit data through 8bit DMA channel, SBHWPG 2-7 */
616 if (chip->dma16 < 0) {
617 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U16_LE;
618 chip->mode |= SB_MODE_CAPTURE_16;
619 } else {
620 runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8;
621 }
622 runtime->hw.buffer_bytes_max =
623 runtime->hw.period_bytes_max = 64 * 1024;
624 goto __open_ok;
625 }
626 spin_unlock_irqrestore(&chip->open_lock, flags);
627 return -EAGAIN;
628
629 __open_ok:
630 if (chip->hardware == SB_HW_ALS100)
631 runtime->hw.rate_max = 48000;
632 if (chip->mode & SB_RATE_LOCK)
633 runtime->hw.rate_min = runtime->hw.rate_max = chip->locked_rate;
634 chip->capture_substream = substream;
635 spin_unlock_irqrestore(&chip->open_lock, flags);
636 return 0;
637 }
638
639 static int snd_sb16_capture_close(snd_pcm_substream_t * substream)
640 {
641 unsigned long flags;
642 sb_t *chip = snd_pcm_substream_chip(substream);
643
644 snd_sb16_csp_capture_close(chip);
645 spin_lock_irqsave(&chip->open_lock, flags);
646 chip->capture_substream = NULL;
647 chip->mode &= ~SB_MODE_CAPTURE;
648 spin_unlock_irqrestore(&chip->open_lock, flags);
649 return 0;
650 }
651
652 /*
653 * DMA control interface
654 */
655
656 static int snd_sb16_set_dma_mode(sb_t *chip, int what)
657 {
658 if (chip->dma8 < 0 || chip->dma16 < 0) {
659 snd_assert(what == 0, return -EINVAL);
660 return 0;
661 }
662 if (what == 0) {
663 chip->force_mode16 = 0;
664 } else if (what == 1) {
665 chip->force_mode16 = SB_MODE_PLAYBACK_16;
666 } else if (what == 2) {
667 chip->force_mode16 = SB_MODE_CAPTURE_16;
668 } else {
669 return -EINVAL;
670 }
671 return 0;
672 }
673
674 static int snd_sb16_get_dma_mode(sb_t *chip)
675 {
676 if (chip->dma8 < 0 || chip->dma16 < 0)
677 return 0;
678 switch (chip->force_mode16) {
679 case SB_MODE_PLAYBACK_16:
680 return 1;
681 case SB_MODE_CAPTURE_16:
682 return 2;
683 default:
684 return 0;
685 }
686 }
687
688 static int snd_sb16_dma_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
689 {
690 static char *texts[3] = {
691 "Auto", "Playback", "Capture"
692 };
693
694 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
695 uinfo->count = 1;
696 uinfo->value.enumerated.items = 3;
697 if (uinfo->value.enumerated.item > 2)
698 uinfo->value.enumerated.item = 2;
699 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
700 return 0;
701 }
702
703 static int snd_sb16_dma_control_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
704 {
705 sb_t *chip = snd_kcontrol_chip(kcontrol);
706 unsigned long flags;
707
708 spin_lock_irqsave(&chip->reg_lock, flags);
709 ucontrol->value.enumerated.item[0] = snd_sb16_get_dma_mode(chip);
710 spin_unlock_irqrestore(&chip->reg_lock, flags);
711 return 0;
712 }
713
714 static int snd_sb16_dma_control_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
715 {
716 sb_t *chip = snd_kcontrol_chip(kcontrol);
717 unsigned long flags;
718 unsigned char nval, oval;
719 int change;
720
721 if ((nval = ucontrol->value.enumerated.item[0]) > 2)
722 return -EINVAL;
723 spin_lock_irqsave(&chip->reg_lock, flags);
724 oval = snd_sb16_get_dma_mode(chip);
725 change = nval != oval;
726 snd_sb16_set_dma_mode(chip, nval);
727 spin_unlock_irqrestore(&chip->reg_lock, flags);
728 return change;
729 }
730
731 static snd_kcontrol_new_t snd_sb16_dma_control = {
732 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
733 .name = "16-bit DMA Allocation",
734 .info = snd_sb16_dma_control_info,
735 .get = snd_sb16_dma_control_get,
736 .put = snd_sb16_dma_control_put
737 };
738
739 /*
740 * Initialization part
741 */
742
743 int snd_sb16dsp_configure(sb_t * chip)
744 {
745 unsigned long flags;
746 unsigned char irqreg = 0, dmareg = 0, mpureg;
747 unsigned char realirq, realdma, realmpureg;
748 /* note: mpu register should be present only on SB16 Vibra soundcards */
749
750 // printk("codec->irq=%i, codec->dma8=%i, codec->dma16=%i\n", chip->irq, chip->dma8, chip->dma16);
751 spin_lock_irqsave(&chip->mixer_lock, flags);
752 mpureg = snd_sbmixer_read(chip, SB_DSP4_MPUSETUP) & ~0x06;
753 spin_unlock_irqrestore(&chip->mixer_lock, flags);
754 switch (chip->irq) {
755 case 2:
756 case 9:
757 irqreg |= SB_IRQSETUP_IRQ9;
758 break;
759 case 5:
760 irqreg |= SB_IRQSETUP_IRQ5;
761 break;
762 case 7:
763 irqreg |= SB_IRQSETUP_IRQ7;
764 break;
765 case 10:
766 irqreg |= SB_IRQSETUP_IRQ10;
767 break;
768 default:
769 return -EINVAL;
770 }
771 if (chip->dma8 >= 0) {
772 switch (chip->dma8) {
773 case 0:
774 dmareg |= SB_DMASETUP_DMA0;
775 break;
776 case 1:
777 dmareg |= SB_DMASETUP_DMA1;
778 break;
779 case 3:
780 dmareg |= SB_DMASETUP_DMA3;
781 break;
782 default:
783 return -EINVAL;
784 }
785 }
786 if (chip->dma16 >= 0 && chip->dma16 != chip->dma8) {
787 switch (chip->dma16) {
788 case 5:
789 dmareg |= SB_DMASETUP_DMA5;
790 break;
791 case 6:
792 dmareg |= SB_DMASETUP_DMA6;
793 break;
794 case 7:
795 dmareg |= SB_DMASETUP_DMA7;
796 break;
797 default:
798 return -EINVAL;
799 }
800 }
801 switch (chip->mpu_port) {
802 case 0x300:
803 mpureg |= 0x04;
804 break;
805 case 0x330:
806 mpureg |= 0x00;
807 break;
808 default:
809 mpureg |= 0x02; /* disable MPU */
810 }
811 spin_lock_irqsave(&chip->mixer_lock, flags);
812
813 snd_sbmixer_write(chip, SB_DSP4_IRQSETUP, irqreg);
814 realirq = snd_sbmixer_read(chip, SB_DSP4_IRQSETUP);
815
816 snd_sbmixer_write(chip, SB_DSP4_DMASETUP, dmareg);
817 realdma = snd_sbmixer_read(chip, SB_DSP4_DMASETUP);
818
819 snd_sbmixer_write(chip, SB_DSP4_MPUSETUP, mpureg);
820 realmpureg = snd_sbmixer_read(chip, SB_DSP4_MPUSETUP);
821
822 spin_unlock_irqrestore(&chip->mixer_lock, flags);
823 if ((~realirq) & irqreg || (~realdma) & dmareg) {
824 snd_printk("SB16 [0x%lx]: unable to set DMA & IRQ (PnP device?)\n", chip->port);
825 snd_printk("SB16 [0x%lx]: wanted: irqreg=0x%x, dmareg=0x%x, mpureg = 0x%x\n", chip->port, realirq, realdma, realmpureg);
826 snd_printk("SB16 [0x%lx]: got: irqreg=0x%x, dmareg=0x%x, mpureg = 0x%x\n", chip->port, irqreg, dmareg, mpureg);
827 return -ENODEV;
828 }
829 return 0;
830 }
831
832 static snd_pcm_ops_t snd_sb16_playback_ops = {
833 .open = snd_sb16_playback_open,
834 .close = snd_sb16_playback_close,
835 .ioctl = snd_pcm_lib_ioctl,
836 .hw_params = snd_sb16_hw_params,
837 .hw_free = snd_sb16_hw_free,
838 .prepare = snd_sb16_playback_prepare,
839 .trigger = snd_sb16_playback_trigger,
840 .pointer = snd_sb16_playback_pointer,
841 };
842
843 static snd_pcm_ops_t snd_sb16_capture_ops = {
844 .open = snd_sb16_capture_open,
845 .close = snd_sb16_capture_close,
846 .ioctl = snd_pcm_lib_ioctl,
847 .hw_params = snd_sb16_hw_params,
848 .hw_free = snd_sb16_hw_free,
849 .prepare = snd_sb16_capture_prepare,
850 .trigger = snd_sb16_capture_trigger,
851 .pointer = snd_sb16_capture_pointer,
852 };
853
854 static void snd_sb16dsp_pcm_free(snd_pcm_t *pcm)
855 {
856 snd_pcm_lib_preallocate_free_for_all(pcm);
857 }
858
859 int snd_sb16dsp_pcm(sb_t * chip, int device, snd_pcm_t ** rpcm)
860 {
861 snd_card_t *card = chip->card;
862 snd_pcm_t *pcm;
863 int err;
864
865 if (rpcm)
866 *rpcm = NULL;
867 if ((err = snd_pcm_new(card, "SB16 DSP", device, 1, 1, &pcm)) < 0)
868 return err;
869 sprintf(pcm->name, "DSP v%i.%i", chip->version >> 8, chip->version & 0xff);
870 pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
871 pcm->private_data = chip;
872 pcm->private_free = snd_sb16dsp_pcm_free;
873
874 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sb16_playback_ops);
875 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sb16_capture_ops);
876
877 if (chip->dma16 >= 0 && chip->dma8 != chip->dma16)
878 snd_ctl_add(card, snd_ctl_new1(&snd_sb16_dma_control, chip));
879 else
880 pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
881
882 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
883 snd_dma_isa_data(),
884 64*1024, 128*1024);
885
886 if (rpcm)
887 *rpcm = pcm;
888 return 0;
889 }
890
891 const snd_pcm_ops_t *snd_sb16dsp_get_pcm_ops(int direction)
892 {
893 return direction == SNDRV_PCM_STREAM_PLAYBACK ?
894 &snd_sb16_playback_ops : &snd_sb16_capture_ops;
895 }
896
897 EXPORT_SYMBOL(snd_sb16dsp_pcm);
898 EXPORT_SYMBOL(snd_sb16dsp_get_pcm_ops);
899 EXPORT_SYMBOL(snd_sb16dsp_configure);
900 EXPORT_SYMBOL(snd_sb16dsp_interrupt);
901
902 /*
903 * INIT part
904 */
905
906 static int __init alsa_sb16_init(void)
907 {
908 return 0;
909 }
910
911 static void __exit alsa_sb16_exit(void)
912 {
913 }
914
915 module_init(alsa_sb16_init)
916 module_exit(alsa_sb16_exit)
kernel-based virtual machine