1 /*
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
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 <asm/io.h>
37 #include <asm/dma.h>
38 #include <linux/init.h>
39 #include <linux/time.h>
40 #include <linux/module.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@perex.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
snd_sb16_csp_playback_prepare(struct snd_sb * chip,struct snd_pcm_runtime * runtime)53 static void snd_sb16_csp_playback_prepare(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
54 {
55 	if (chip->hardware == SB_HW_16CSP) {
56 		struct snd_sb_csp *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 
snd_sb16_csp_capture_prepare(struct snd_sb * chip,struct snd_pcm_runtime * runtime)101 static void snd_sb16_csp_capture_prepare(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
102 {
103 	if (chip->hardware == SB_HW_16CSP) {
104 		struct snd_sb_csp *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 
snd_sb16_csp_update(struct snd_sb * chip)139 static void snd_sb16_csp_update(struct snd_sb *chip)
140 {
141 	if (chip->hardware == SB_HW_16CSP) {
142 		struct snd_sb_csp *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 
snd_sb16_csp_playback_open(struct snd_sb * chip,struct snd_pcm_runtime * runtime)152 static void snd_sb16_csp_playback_open(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
153 {
154 	/* CSP decoders (QSound excluded) support only 16bit transfers */
155 	if (chip->hardware == SB_HW_16CSP) {
156 		struct snd_sb_csp *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 
snd_sb16_csp_playback_close(struct snd_sb * chip)171 static void snd_sb16_csp_playback_close(struct snd_sb *chip)
172 {
173 	if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_WRITE)) {
174 		struct snd_sb_csp *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 
snd_sb16_csp_capture_open(struct snd_sb * chip,struct snd_pcm_runtime * runtime)183 static void snd_sb16_csp_capture_open(struct snd_sb *chip, struct snd_pcm_runtime *runtime)
184 {
185 	/* CSP coders support only 16bit transfers */
186 	if (chip->hardware == SB_HW_16CSP) {
187 		struct snd_sb_csp *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 
snd_sb16_csp_capture_close(struct snd_sb * chip)202 static void snd_sb16_csp_capture_close(struct snd_sb *chip)
203 {
204 	if ((chip->hardware == SB_HW_16CSP) && (chip->open == SNDRV_SB_CSP_MODE_DSP_READ)) {
205 		struct snd_sb_csp *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 
snd_sb16_setup_rate(struct snd_sb * chip,unsigned short rate,int channel)224 static void snd_sb16_setup_rate(struct snd_sb *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 
snd_sb16_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hw_params)247 static int snd_sb16_hw_params(struct snd_pcm_substream *substream,
248 			      struct snd_pcm_hw_params *hw_params)
249 {
250 	return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
251 }
252 
snd_sb16_hw_free(struct snd_pcm_substream * substream)253 static int snd_sb16_hw_free(struct snd_pcm_substream *substream)
254 {
255 	snd_pcm_lib_free_pages(substream);
256 	return 0;
257 }
258 
snd_sb16_playback_prepare(struct snd_pcm_substream * substream)259 static int snd_sb16_playback_prepare(struct snd_pcm_substream *substream)
260 {
261 	unsigned long flags;
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;
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 
snd_sb16_playback_trigger(struct snd_pcm_substream * substream,int cmd)301 static int snd_sb16_playback_trigger(struct snd_pcm_substream *substream,
302 				     int cmd)
303 {
304 	struct snd_sb *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 	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);
313 		break;
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;
321 		break;
322 	default:
323 		result = -EINVAL;
324 	}
325 	spin_unlock(&chip->reg_lock);
326 	return result;
327 }
328 
snd_sb16_capture_prepare(struct snd_pcm_substream * substream)329 static int snd_sb16_capture_prepare(struct snd_pcm_substream *substream)
330 {
331 	unsigned long flags;
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;
336 
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;
340 	} else {
341 		format = runtime->channels > 1 ? SB_DSP4_MODE_SIGN_STEREO : SB_DSP4_MODE_SIGN_MONO;
342 	}
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);
347 
348 	count = snd_pcm_lib_period_bytes(substream);
349 	spin_lock_irqsave(&chip->reg_lock, flags);
350 	if (chip->mode & SB_MODE_CAPTURE_16) {
351 		count >>= 1;
352 		count--;
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);
358 	} else {
359 		count--;
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);
365 	}
366 	spin_unlock_irqrestore(&chip->reg_lock, flags);
367 	return 0;
368 }
369 
snd_sb16_capture_trigger(struct snd_pcm_substream * substream,int cmd)370 static int snd_sb16_capture_trigger(struct snd_pcm_substream *substream,
371 				    int cmd)
372 {
373 	struct snd_sb *chip = snd_pcm_substream_chip(substream);
374 	int result = 0;
375 
376 	spin_lock(&chip->reg_lock);
377 	switch (cmd) {
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);
382 		break;
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;
390 		break;
391 	default:
392 		result = -EINVAL;
393 	}
394 	spin_unlock(&chip->reg_lock);
395 	return result;
396 }
397 
snd_sb16dsp_interrupt(int irq,void * dev_id)398 irqreturn_t snd_sb16dsp_interrupt(int irq, void *dev_id)
399 {
400 	struct snd_sb *chip = dev_id;
401 	unsigned char status;
402 	int ok;
403 
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) {
410 		ok = 0;
411 		if (chip->mode & SB_MODE_PLAYBACK_8) {
412 			snd_pcm_period_elapsed(chip->playback_substream);
413 			snd_sb16_csp_update(chip);
414 			ok++;
415 		}
416 		if (chip->mode & SB_MODE_CAPTURE_8) {
417 			snd_pcm_period_elapsed(chip->capture_substream);
418 			ok++;
419 		}
420 		spin_lock(&chip->reg_lock);
421 		if (!ok)
422 			snd_sbdsp_command(chip, SB_DSP_DMA8_OFF);
423 		snd_sb_ack_8bit(chip);
424 		spin_unlock(&chip->reg_lock);
425 	}
426 	if (status & SB_IRQTYPE_16BIT) {
427 		ok = 0;
428 		if (chip->mode & SB_MODE_PLAYBACK_16) {
429 			snd_pcm_period_elapsed(chip->playback_substream);
430 			snd_sb16_csp_update(chip);
431 			ok++;
432 		}
433 		if (chip->mode & SB_MODE_CAPTURE_16) {
434 			snd_pcm_period_elapsed(chip->capture_substream);
435 			ok++;
436 		}
437 		spin_lock(&chip->reg_lock);
438 		if (!ok)
439 			snd_sbdsp_command(chip, SB_DSP_DMA16_OFF);
440 		snd_sb_ack_16bit(chip);
441 		spin_unlock(&chip->reg_lock);
442 	}
443 	return IRQ_HANDLED;
444 }
445 
446 /*
447 
448  */
449 
snd_sb16_playback_pointer(struct snd_pcm_substream * substream)450 static snd_pcm_uframes_t snd_sb16_playback_pointer(struct snd_pcm_substream *substream)
451 {
452 	struct snd_sb *chip = snd_pcm_substream_chip(substream);
453 	unsigned int dma;
454 	size_t ptr;
455 
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);
459 }
460 
snd_sb16_capture_pointer(struct snd_pcm_substream * substream)461 static snd_pcm_uframes_t snd_sb16_capture_pointer(struct snd_pcm_substream *substream)
462 {
463 	struct snd_sb *chip = snd_pcm_substream_chip(substream);
464 	unsigned int dma;
465 	size_t ptr;
466 
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);
470 }
471 
472 /*
473 
474  */
475 
476 static struct snd_pcm_hardware snd_sb16_playback =
477 {
478 	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
479 				 SNDRV_PCM_INFO_MMAP_VALID),
480 	.formats =		0,
481 	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_44100,
482 	.rate_min =		4000,
483 	.rate_max =		44100,
484 	.channels_min =		1,
485 	.channels_max =		2,
486 	.buffer_bytes_max =	(128*1024),
487 	.period_bytes_min =	64,
488 	.period_bytes_max =	(128*1024),
489 	.periods_min =		1,
490 	.periods_max =		1024,
491 	.fifo_size =		0,
492 };
493 
494 static struct snd_pcm_hardware snd_sb16_capture =
495 {
496 	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
497 				 SNDRV_PCM_INFO_MMAP_VALID),
498 	.formats =		0,
499 	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_44100,
500 	.rate_min =		4000,
501 	.rate_max =		44100,
502 	.channels_min =		1,
503 	.channels_max =		2,
504 	.buffer_bytes_max =	(128*1024),
505 	.period_bytes_min =	64,
506 	.period_bytes_max =	(128*1024),
507 	.periods_min =		1,
508 	.periods_max =		1024,
509 	.fifo_size =		0,
510 };
511 
512 /*
513  *  open/close
514  */
515 
snd_sb16_playback_open(struct snd_pcm_substream * substream)516 static int snd_sb16_playback_open(struct snd_pcm_substream *substream)
517 {
518 	unsigned long flags;
519 	struct snd_sb *chip = snd_pcm_substream_chip(substream);
520 	struct snd_pcm_runtime *runtime = substream->runtime;
521 
522 	spin_lock_irqsave(&chip->open_lock, flags);
523 	if (chip->mode & SB_MODE_PLAYBACK) {
524 		spin_unlock_irqrestore(&chip->open_lock, flags);
525 		return -EAGAIN;
526 	}
527 	runtime->hw = snd_sb16_playback;
528 
529 	/* skip if 16 bit DMA was reserved for capture */
530 	if (chip->force_mode16 & SB_MODE_CAPTURE_16)
531 		goto __skip_16bit;
532 
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;
536 		/* Vibra16X hack */
537 		if (chip->dma16 <= 3) {
538 			runtime->hw.buffer_bytes_max =
539 			runtime->hw.period_bytes_max = 64 * 1024;
540 		} else {
541 			snd_sb16_csp_playback_open(chip, runtime);
542 		}
543 		goto __open_ok;
544 	}
545 
546       __skip_16bit:
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;
553 		} else {
554 			runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8;
555 		}
556 		runtime->hw.buffer_bytes_max =
557 		runtime->hw.period_bytes_max = 64 * 1024;
558 		goto __open_ok;
559 	}
560 	spin_unlock_irqrestore(&chip->open_lock, flags);
561 	return -EAGAIN;
562 
563       __open_ok:
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;
570 	}
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);
575 	return 0;
576 }
577 
snd_sb16_playback_close(struct snd_pcm_substream * substream)578 static int snd_sb16_playback_close(struct snd_pcm_substream *substream)
579 {
580 	unsigned long flags;
581 	struct snd_sb *chip = snd_pcm_substream_chip(substream);
582 
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);
588 	return 0;
589 }
590 
snd_sb16_capture_open(struct snd_pcm_substream * substream)591 static int snd_sb16_capture_open(struct snd_pcm_substream *substream)
592 {
593 	unsigned long flags;
594 	struct snd_sb *chip = snd_pcm_substream_chip(substream);
595 	struct snd_pcm_runtime *runtime = substream->runtime;
596 
597 	spin_lock_irqsave(&chip->open_lock, flags);
598 	if (chip->mode & SB_MODE_CAPTURE) {
599 		spin_unlock_irqrestore(&chip->open_lock, flags);
600 		return -EAGAIN;
601 	}
602 	runtime->hw = snd_sb16_capture;
603 
604 	/* skip if 16 bit DMA was reserved for playback */
605 	if (chip->force_mode16 & SB_MODE_PLAYBACK_16)
606 		goto __skip_16bit;
607 
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;
611 		/* Vibra16X hack */
612 		if (chip->dma16 <= 3) {
613 			runtime->hw.buffer_bytes_max =
614 			runtime->hw.period_bytes_max = 64 * 1024;
615 		} else {
616 			snd_sb16_csp_capture_open(chip, runtime);
617 		}
618 		goto __open_ok;
619 	}
620 
621       __skip_16bit:
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;
628 		} else {
629 			runtime->hw.formats = SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8;
630 		}
631 		runtime->hw.buffer_bytes_max =
632 		runtime->hw.period_bytes_max = 64 * 1024;
633 		goto __open_ok;
634 	}
635 	spin_unlock_irqrestore(&chip->open_lock, flags);
636 	return -EAGAIN;
637 
638       __open_ok:
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;
645 	}
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);
650 	return 0;
651 }
652 
snd_sb16_capture_close(struct snd_pcm_substream * substream)653 static int snd_sb16_capture_close(struct snd_pcm_substream *substream)
654 {
655 	unsigned long flags;
656 	struct snd_sb *chip = snd_pcm_substream_chip(substream);
657 
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);
663 	return 0;
664 }
665 
666 /*
667  *  DMA control interface
668  */
669 
snd_sb16_set_dma_mode(struct snd_sb * chip,int what)670 static int snd_sb16_set_dma_mode(struct snd_sb *chip, int what)
671 {
672 	if (chip->dma8 < 0 || chip->dma16 < 0) {
673 		if (snd_BUG_ON(what))
674 			return -EINVAL;
675 		return 0;
676 	}
677 	if (what == 0) {
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;
683 	} else {
684 		return -EINVAL;
685 	}
686 	return 0;
687 }
688 
snd_sb16_get_dma_mode(struct snd_sb * chip)689 static int snd_sb16_get_dma_mode(struct snd_sb *chip)
690 {
691 	if (chip->dma8 < 0 || chip->dma16 < 0)
692 		return 0;
693 	switch (chip->force_mode16) {
694 	case SB_MODE_PLAYBACK_16:
695 		return 1;
696 	case SB_MODE_CAPTURE_16:
697 		return 2;
698 	default:
699 		return 0;
700 	}
701 }
702 
snd_sb16_dma_control_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)703 static int snd_sb16_dma_control_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
704 {
705 	static char *texts[3] = {
706 		"Auto", "Playback", "Capture"
707 	};
708 
709 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
710 	uinfo->count = 1;
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]);
715 	return 0;
716 }
717 
snd_sb16_dma_control_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)718 static int snd_sb16_dma_control_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
719 {
720 	struct snd_sb *chip = snd_kcontrol_chip(kcontrol);
721 	unsigned long flags;
722 
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);
726 	return 0;
727 }
728 
snd_sb16_dma_control_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)729 static int snd_sb16_dma_control_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
730 {
731 	struct snd_sb *chip = snd_kcontrol_chip(kcontrol);
732 	unsigned long flags;
733 	unsigned char nval, oval;
734 	int change;
735 
736 	if ((nval = ucontrol->value.enumerated.item[0]) > 2)
737 		return -EINVAL;
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);
743 	return change;
744 }
745 
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
752 };
753 
754 /*
755  *  Initialization part
756  */
757 
snd_sb16dsp_configure(struct snd_sb * chip)758 int snd_sb16dsp_configure(struct snd_sb * chip)
759 {
760 	unsigned long flags;
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 */
764 
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);
769 	switch (chip->irq) {
770 	case 2:
771 	case 9:
772 		irqreg |= SB_IRQSETUP_IRQ9;
773 		break;
774 	case 5:
775 		irqreg |= SB_IRQSETUP_IRQ5;
776 		break;
777 	case 7:
778 		irqreg |= SB_IRQSETUP_IRQ7;
779 		break;
780 	case 10:
781 		irqreg |= SB_IRQSETUP_IRQ10;
782 		break;
783 	default:
784 		return -EINVAL;
785 	}
786 	if (chip->dma8 >= 0) {
787 		switch (chip->dma8) {
788 		case 0:
789 			dmareg |= SB_DMASETUP_DMA0;
790 			break;
791 		case 1:
792 			dmareg |= SB_DMASETUP_DMA1;
793 			break;
794 		case 3:
795 			dmareg |= SB_DMASETUP_DMA3;
796 			break;
797 		default:
798 			return -EINVAL;
799 		}
800 	}
801 	if (chip->dma16 >= 0 && chip->dma16 != chip->dma8) {
802 		switch (chip->dma16) {
803 		case 5:
804 			dmareg |= SB_DMASETUP_DMA5;
805 			break;
806 		case 6:
807 			dmareg |= SB_DMASETUP_DMA6;
808 			break;
809 		case 7:
810 			dmareg |= SB_DMASETUP_DMA7;
811 			break;
812 		default:
813 			return -EINVAL;
814 		}
815 	}
816 	switch (chip->mpu_port) {
817 	case 0x300:
818 		mpureg |= 0x04;
819 		break;
820 	case 0x330:
821 		mpureg |= 0x00;
822 		break;
823 	default:
824 		mpureg |= 0x02;	/* disable MPU */
825 	}
826 	spin_lock_irqsave(&chip->mixer_lock, flags);
827 
828 	snd_sbmixer_write(chip, SB_DSP4_IRQSETUP, irqreg);
829 	realirq = snd_sbmixer_read(chip, SB_DSP4_IRQSETUP);
830 
831 	snd_sbmixer_write(chip, SB_DSP4_DMASETUP, dmareg);
832 	realdma = snd_sbmixer_read(chip, SB_DSP4_DMASETUP);
833 
834 	snd_sbmixer_write(chip, SB_DSP4_MPUSETUP, mpureg);
835 	realmpureg = snd_sbmixer_read(chip, SB_DSP4_MPUSETUP);
836 
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);
842 		return -ENODEV;
843 	}
844 	return 0;
845 }
846 
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,
856 };
857 
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,
867 };
868 
snd_sb16dsp_pcm(struct snd_sb * chip,int device,struct snd_pcm ** rpcm)869 int snd_sb16dsp_pcm(struct snd_sb * chip, int device, struct snd_pcm ** rpcm)
870 {
871 	struct snd_card *card = chip->card;
872 	struct snd_pcm *pcm;
873 	int err;
874 
875 	if (rpcm)
876 		*rpcm = NULL;
877 	if ((err = snd_pcm_new(card, "SB16 DSP", device, 1, 1, &pcm)) < 0)
878 		return err;
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;
882 
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);
885 
886 	if (chip->dma16 >= 0 && chip->dma8 != chip->dma16)
887 		snd_ctl_add(card, snd_ctl_new1(&snd_sb16_dma_control, chip));
888 	else
889 		pcm->info_flags = SNDRV_PCM_INFO_HALF_DUPLEX;
890 
891 	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
892 					      snd_dma_isa_data(),
893 					      64*1024, 128*1024);
894 
895 	if (rpcm)
896 		*rpcm = pcm;
897 	return 0;
898 }
899 
snd_sb16dsp_get_pcm_ops(int direction)900 const struct snd_pcm_ops *snd_sb16dsp_get_pcm_ops(int direction)
901 {
902 	return direction == SNDRV_PCM_STREAM_PLAYBACK ?
903 		&snd_sb16_playback_ops : &snd_sb16_capture_ops;
904 }
905 
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);
910 
911 /*
912  *  INIT part
913  */
914 
alsa_sb16_init(void)915 static int __init alsa_sb16_init(void)
916 {
917 	return 0;
918 }
919 
alsa_sb16_exit(void)920 static void __exit alsa_sb16_exit(void)
921 {
922 }
923 
924 module_init(alsa_sb16_init)
925 module_exit(alsa_sb16_exit)
926