Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
sb16_main.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) by Jaroslav Kysela <[email protected]>
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 <[email protected]>");
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(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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
915 static int __init alsa_sb16_init(void)
916 {
917  return 0;
918 }
919 
920 static void __exit alsa_sb16_exit(void)
921 {
922 }
923 
924 module_init(alsa_sb16_init)
925 module_exit(alsa_sb16_exit)
Generated on Thu Jan 10 2013 15:04:56 for Linux Kernel by   doxygen 1.8.2