aboutsummaryrefslogtreecommitdiffstats
path: root/sound/pci/au88x0/au88x0_pcm.c
diff options
context:
space:
mode:
Diffstat (limited to 'sound/pci/au88x0/au88x0_pcm.c')
-rw-r--r--sound/pci/au88x0/au88x0_pcm.c548
1 files changed, 548 insertions, 0 deletions
diff --git a/sound/pci/au88x0/au88x0_pcm.c b/sound/pci/au88x0/au88x0_pcm.c
new file mode 100644
index 000000000000..04dcefd8b8ff
--- /dev/null
+++ b/sound/pci/au88x0/au88x0_pcm.c
@@ -0,0 +1,548 @@
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU Library General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
15 */
16
17/*
18 * Vortex PCM ALSA driver.
19 *
20 * Supports ADB and WT DMA. Unfortunately, WT channels do not run yet.
21 * It remains stuck,and DMA transfers do not happen.
22 */
23#include <sound/asoundef.h>
24#include <sound/driver.h>
25#include <linux/time.h>
26#include <sound/core.h>
27#include <sound/pcm.h>
28#include <sound/pcm_params.h>
29#include "au88x0.h"
30
31#define VORTEX_PCM_TYPE(x) (x->name[40])
32
33/* hardware definition */
34static snd_pcm_hardware_t snd_vortex_playback_hw_adb = {
35 .info =
36 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_RESUME |
37 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
38 SNDRV_PCM_INFO_MMAP_VALID),
39 .formats =
40 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
41 SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW,
42 .rates = SNDRV_PCM_RATE_CONTINUOUS,
43 .rate_min = 5000,
44 .rate_max = 48000,
45 .channels_min = 1,
46#ifdef CHIP_AU8830
47 .channels_max = 4,
48#else
49 .channels_max = 2,
50#endif
51 .buffer_bytes_max = 0x10000,
52 .period_bytes_min = 0x1,
53 .period_bytes_max = 0x1000,
54 .periods_min = 2,
55 .periods_max = 32,
56};
57
58#ifndef CHIP_AU8820
59static snd_pcm_hardware_t snd_vortex_playback_hw_a3d = {
60 .info =
61 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_RESUME |
62 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
63 SNDRV_PCM_INFO_MMAP_VALID),
64 .formats =
65 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
66 SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW,
67 .rates = SNDRV_PCM_RATE_CONTINUOUS,
68 .rate_min = 5000,
69 .rate_max = 48000,
70 .channels_min = 1,
71 .channels_max = 1,
72 .buffer_bytes_max = 0x10000,
73 .period_bytes_min = 0x100,
74 .period_bytes_max = 0x1000,
75 .periods_min = 2,
76 .periods_max = 64,
77};
78#endif
79static snd_pcm_hardware_t snd_vortex_playback_hw_spdif = {
80 .info =
81 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_RESUME |
82 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
83 SNDRV_PCM_INFO_MMAP_VALID),
84 .formats =
85 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
86 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE | SNDRV_PCM_FMTBIT_MU_LAW |
87 SNDRV_PCM_FMTBIT_A_LAW,
88 .rates =
89 SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
90 .rate_min = 32000,
91 .rate_max = 48000,
92 .channels_min = 1,
93 .channels_max = 2,
94 .buffer_bytes_max = 0x10000,
95 .period_bytes_min = 0x100,
96 .period_bytes_max = 0x1000,
97 .periods_min = 2,
98 .periods_max = 64,
99};
100
101#ifndef CHIP_AU8810
102static snd_pcm_hardware_t snd_vortex_playback_hw_wt = {
103 .info = (SNDRV_PCM_INFO_MMAP |
104 SNDRV_PCM_INFO_INTERLEAVED |
105 SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
106 .formats = SNDRV_PCM_FMTBIT_S16_LE,
107 .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_CONTINUOUS, // SNDRV_PCM_RATE_48000,
108 .rate_min = 8000,
109 .rate_max = 48000,
110 .channels_min = 1,
111 .channels_max = 2,
112 .buffer_bytes_max = 0x10000,
113 .period_bytes_min = 0x0400,
114 .period_bytes_max = 0x1000,
115 .periods_min = 2,
116 .periods_max = 64,
117};
118#endif
119/* open callback */
120static int snd_vortex_pcm_open(snd_pcm_substream_t * substream)
121{
122 vortex_t *vortex = snd_pcm_substream_chip(substream);
123 snd_pcm_runtime_t *runtime = substream->runtime;
124 int err;
125
126 /* Force equal size periods */
127 if ((err =
128 snd_pcm_hw_constraint_integer(runtime,
129 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
130 return err;
131 /* Avoid PAGE_SIZE boundary to fall inside of a period. */
132 if ((err =
133 snd_pcm_hw_constraint_pow2(runtime, 0,
134 SNDRV_PCM_HW_PARAM_PERIOD_BYTES)) < 0)
135 return err;
136
137 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
138#ifndef CHIP_AU8820
139 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_A3D) {
140 runtime->hw = snd_vortex_playback_hw_a3d;
141 }
142#endif
143 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_SPDIF) {
144 runtime->hw = snd_vortex_playback_hw_spdif;
145 switch (vortex->spdif_sr) {
146 case 32000:
147 runtime->hw.rates = SNDRV_PCM_RATE_32000;
148 break;
149 case 44100:
150 runtime->hw.rates = SNDRV_PCM_RATE_44100;
151 break;
152 case 48000:
153 runtime->hw.rates = SNDRV_PCM_RATE_48000;
154 break;
155 }
156 }
157 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB
158 || VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_I2S)
159 runtime->hw = snd_vortex_playback_hw_adb;
160 substream->runtime->private_data = NULL;
161 }
162#ifndef CHIP_AU8810
163 else {
164 runtime->hw = snd_vortex_playback_hw_wt;
165 substream->runtime->private_data = NULL;
166 }
167#endif
168 return 0;
169}
170
171/* close callback */
172static int snd_vortex_pcm_close(snd_pcm_substream_t * substream)
173{
174 //vortex_t *chip = snd_pcm_substream_chip(substream);
175 stream_t *stream = (stream_t *) substream->runtime->private_data;
176
177 // the hardware-specific codes will be here
178 if (stream != NULL) {
179 stream->substream = NULL;
180 stream->nr_ch = 0;
181 }
182 substream->runtime->private_data = NULL;
183 return 0;
184}
185
186/* hw_params callback */
187static int
188snd_vortex_pcm_hw_params(snd_pcm_substream_t * substream,
189 snd_pcm_hw_params_t * hw_params)
190{
191 vortex_t *chip = snd_pcm_substream_chip(substream);
192 stream_t *stream = (stream_t *) (substream->runtime->private_data);
193 snd_pcm_sgbuf_t *sgbuf;
194 int err;
195
196 // Alloc buffer memory.
197 err =
198 snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
199 if (err < 0) {
200 printk(KERN_ERR "Vortex: pcm page alloc failed!\n");
201 return err;
202 }
203 //sgbuf = (snd_pcm_sgbuf_t *) substream->runtime->dma_private;
204 sgbuf = snd_pcm_substream_sgbuf(substream);
205 /*
206 printk(KERN_INFO "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params),
207 params_period_bytes(hw_params), params_channels(hw_params));
208 */
209 spin_lock_irq(&chip->lock);
210 // Make audio routes and config buffer DMA.
211 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
212 int dma, type = VORTEX_PCM_TYPE(substream->pcm);
213 /* Dealloc any routes. */
214 if (stream != NULL)
215 vortex_adb_allocroute(chip, stream->dma,
216 stream->nr_ch, stream->dir,
217 stream->type);
218 /* Alloc routes. */
219 dma =
220 vortex_adb_allocroute(chip, -1,
221 params_channels(hw_params),
222 substream->stream, type);
223 if (dma < 0)
224 return dma;
225 stream = substream->runtime->private_data = &chip->dma_adb[dma];
226 stream->substream = substream;
227 /* Setup Buffers. */
228 vortex_adbdma_setbuffers(chip, dma, sgbuf,
229 params_period_bytes(hw_params),
230 params_periods(hw_params));
231 }
232#ifndef CHIP_AU8810
233 else {
234 /* if (stream != NULL)
235 vortex_wt_allocroute(chip, substream->number, 0); */
236 vortex_wt_allocroute(chip, substream->number,
237 params_channels(hw_params));
238 stream = substream->runtime->private_data =
239 &chip->dma_wt[substream->number];
240 stream->dma = substream->number;
241 stream->substream = substream;
242 vortex_wtdma_setbuffers(chip, substream->number, sgbuf,
243 params_period_bytes(hw_params),
244 params_periods(hw_params));
245 }
246#endif
247 spin_unlock_irq(&chip->lock);
248 return 0;
249}
250
251/* hw_free callback */
252static int snd_vortex_pcm_hw_free(snd_pcm_substream_t * substream)
253{
254 vortex_t *chip = snd_pcm_substream_chip(substream);
255 stream_t *stream = (stream_t *) (substream->runtime->private_data);
256
257 spin_lock_irq(&chip->lock);
258 // Delete audio routes.
259 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
260 if (stream != NULL)
261 vortex_adb_allocroute(chip, stream->dma,
262 stream->nr_ch, stream->dir,
263 stream->type);
264 }
265#ifndef CHIP_AU8810
266 else {
267 if (stream != NULL)
268 vortex_wt_allocroute(chip, stream->dma, 0);
269 }
270#endif
271 substream->runtime->private_data = NULL;
272 spin_unlock_irq(&chip->lock);
273
274 return snd_pcm_lib_free_pages(substream);
275}
276
277/* prepare callback */
278static int snd_vortex_pcm_prepare(snd_pcm_substream_t * substream)
279{
280 vortex_t *chip = snd_pcm_substream_chip(substream);
281 snd_pcm_runtime_t *runtime = substream->runtime;
282 stream_t *stream = (stream_t *) substream->runtime->private_data;
283 int dma = stream->dma, fmt, dir;
284
285 // set up the hardware with the current configuration.
286 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
287 dir = 1;
288 else
289 dir = 0;
290 fmt = vortex_alsafmt_aspfmt(runtime->format);
291 spin_lock_irq(&chip->lock);
292 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
293 vortex_adbdma_setmode(chip, dma, 1, dir, fmt, 0 /*? */ ,
294 0);
295 vortex_adbdma_setstartbuffer(chip, dma, 0);
296 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_SPDIF)
297 vortex_adb_setsrc(chip, dma, runtime->rate, dir);
298 }
299#ifndef CHIP_AU8810
300 else {
301 vortex_wtdma_setmode(chip, dma, 1, fmt, 0, 0);
302 // FIXME: Set rate (i guess using vortex_wt_writereg() somehow).
303 vortex_wtdma_setstartbuffer(chip, dma, 0);
304 }
305#endif
306 spin_unlock_irq(&chip->lock);
307 return 0;
308}
309
310/* trigger callback */
311static int snd_vortex_pcm_trigger(snd_pcm_substream_t * substream, int cmd)
312{
313 vortex_t *chip = snd_pcm_substream_chip(substream);
314 stream_t *stream = (stream_t *) substream->runtime->private_data;
315 int dma = stream->dma;
316
317 spin_lock(&chip->lock);
318 switch (cmd) {
319 case SNDRV_PCM_TRIGGER_START:
320 // do something to start the PCM engine
321 //printk(KERN_INFO "vortex: start %d\n", dma);
322 stream->fifo_enabled = 1;
323 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
324 vortex_adbdma_resetup(chip, dma);
325 vortex_adbdma_startfifo(chip, dma);
326 }
327#ifndef CHIP_AU8810
328 else {
329 printk(KERN_INFO "vortex: wt start %d\n", dma);
330 vortex_wtdma_startfifo(chip, dma);
331 }
332#endif
333 break;
334 case SNDRV_PCM_TRIGGER_STOP:
335 // do something to stop the PCM engine
336 //printk(KERN_INFO "vortex: stop %d\n", dma);
337 stream->fifo_enabled = 0;
338 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
339 vortex_adbdma_pausefifo(chip, dma);
340 //vortex_adbdma_stopfifo(chip, dma);
341#ifndef CHIP_AU8810
342 else {
343 printk(KERN_INFO "vortex: wt stop %d\n", dma);
344 vortex_wtdma_stopfifo(chip, dma);
345 }
346#endif
347 break;
348 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
349 //printk(KERN_INFO "vortex: pause %d\n", dma);
350 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
351 vortex_adbdma_pausefifo(chip, dma);
352#ifndef CHIP_AU8810
353 else
354 vortex_wtdma_pausefifo(chip, dma);
355#endif
356 break;
357 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
358 //printk(KERN_INFO "vortex: resume %d\n", dma);
359 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
360 vortex_adbdma_resumefifo(chip, dma);
361#ifndef CHIP_AU8810
362 else
363 vortex_wtdma_resumefifo(chip, dma);
364#endif
365 break;
366 default:
367 spin_unlock(&chip->lock);
368 return -EINVAL;
369 }
370 spin_unlock(&chip->lock);
371 return 0;
372}
373
374/* pointer callback */
375static snd_pcm_uframes_t snd_vortex_pcm_pointer(snd_pcm_substream_t * substream)
376{
377 vortex_t *chip = snd_pcm_substream_chip(substream);
378 stream_t *stream = (stream_t *) substream->runtime->private_data;
379 int dma = stream->dma;
380 snd_pcm_uframes_t current_ptr = 0;
381
382 spin_lock(&chip->lock);
383 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
384 current_ptr = vortex_adbdma_getlinearpos(chip, dma);
385#ifndef CHIP_AU8810
386 else
387 current_ptr = vortex_wtdma_getlinearpos(chip, dma);
388#endif
389 //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr);
390 spin_unlock(&chip->lock);
391 return (bytes_to_frames(substream->runtime, current_ptr));
392}
393
394/* Page callback. */
395/*
396static struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset) {
397
398
399}
400*/
401/* operators */
402static snd_pcm_ops_t snd_vortex_playback_ops = {
403 .open = snd_vortex_pcm_open,
404 .close = snd_vortex_pcm_close,
405 .ioctl = snd_pcm_lib_ioctl,
406 .hw_params = snd_vortex_pcm_hw_params,
407 .hw_free = snd_vortex_pcm_hw_free,
408 .prepare = snd_vortex_pcm_prepare,
409 .trigger = snd_vortex_pcm_trigger,
410 .pointer = snd_vortex_pcm_pointer,
411 .page = snd_pcm_sgbuf_ops_page,
412};
413
414/*
415* definitions of capture are omitted here...
416*/
417
418static char *vortex_pcm_prettyname[VORTEX_PCM_LAST] = {
419 "AU88x0 ADB",
420 "AU88x0 SPDIF",
421 "AU88x0 A3D",
422 "AU88x0 WT",
423 "AU88x0 I2S",
424};
425static char *vortex_pcm_name[VORTEX_PCM_LAST] = {
426 "adb",
427 "spdif",
428 "a3d",
429 "wt",
430 "i2s",
431};
432
433/* SPDIF kcontrol */
434
435static int snd_vortex_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
436{
437 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
438 uinfo->count = 1;
439 return 0;
440}
441
442static int snd_vortex_spdif_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
443{
444 ucontrol->value.iec958.status[0] = 0xff;
445 ucontrol->value.iec958.status[1] = 0xff;
446 ucontrol->value.iec958.status[2] = 0xff;
447 ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
448 return 0;
449}
450
451static int snd_vortex_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
452{
453 vortex_t *vortex = snd_kcontrol_chip(kcontrol);
454 ucontrol->value.iec958.status[0] = 0x00;
455 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_ORIGINAL|IEC958_AES1_CON_DIGDIGCONV_ID;
456 ucontrol->value.iec958.status[2] = 0x00;
457 switch (vortex->spdif_sr) {
458 case 32000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_32000; break;
459 case 44100: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_44100; break;
460 case 48000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_48000; break;
461 }
462 return 0;
463}
464
465static int snd_vortex_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
466{
467 vortex_t *vortex = snd_kcontrol_chip(kcontrol);
468 int spdif_sr = 48000;
469 switch (ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) {
470 case IEC958_AES3_CON_FS_32000: spdif_sr = 32000; break;
471 case IEC958_AES3_CON_FS_44100: spdif_sr = 44100; break;
472 case IEC958_AES3_CON_FS_48000: spdif_sr = 48000; break;
473 }
474 if (spdif_sr == vortex->spdif_sr)
475 return 0;
476 vortex->spdif_sr = spdif_sr;
477 vortex_spdif_init(vortex, vortex->spdif_sr, 1);
478 return 1;
479}
480
481/* spdif controls */
482static snd_kcontrol_new_t snd_vortex_mixer_spdif[] __devinitdata = {
483 {
484 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
485 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
486 .info = snd_vortex_spdif_info,
487 .get = snd_vortex_spdif_get,
488 .put = snd_vortex_spdif_put,
489 },
490 {
491 .access = SNDRV_CTL_ELEM_ACCESS_READ,
492 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
493 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
494 .info = snd_vortex_spdif_info,
495 .get = snd_vortex_spdif_mask_get
496 },
497};
498
499/* create a pcm device */
500static int __devinit snd_vortex_new_pcm(vortex_t * chip, int idx, int nr)
501{
502 snd_pcm_t *pcm;
503 snd_kcontrol_t *kctl;
504 int i;
505 int err, nr_capt;
506
507 if ((chip == 0) || (idx < 0) || (idx > VORTEX_PCM_LAST))
508 return -ENODEV;
509
510 /* idx indicates which kind of PCM device. ADB, SPDIF, I2S and A3D share the
511 * same dma engine. WT uses it own separate dma engine whcih cant capture. */
512 if (idx == VORTEX_PCM_ADB)
513 nr_capt = nr;
514 else
515 nr_capt = 0;
516 if ((err =
517 snd_pcm_new(chip->card, vortex_pcm_prettyname[idx], idx, nr,
518 nr_capt, &pcm)) < 0)
519 return err;
520 strcpy(pcm->name, vortex_pcm_name[idx]);
521 chip->pcm[idx] = pcm;
522 // This is an evil hack, but it saves a lot of duplicated code.
523 VORTEX_PCM_TYPE(pcm) = idx;
524 pcm->private_data = chip;
525 /* set operators */
526 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
527 &snd_vortex_playback_ops);
528 if (idx == VORTEX_PCM_ADB)
529 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
530 &snd_vortex_playback_ops);
531
532 /* pre-allocation of Scatter-Gather buffers */
533
534 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
535 snd_dma_pci_data(chip->pci_dev),
536 0x10000, 0x10000);
537
538 if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_SPDIF) {
539 for (i = 0; i < ARRAY_SIZE(snd_vortex_mixer_spdif); i++) {
540 kctl = snd_ctl_new1(&snd_vortex_mixer_spdif[i], chip);
541 if (!kctl)
542 return -ENOMEM;
543 if ((err = snd_ctl_add(chip->card, kctl)) < 0)
544 return err;
545 }
546 }
547 return 0;
548}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-20 22:06:33 -0500