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.
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.
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.
18 * Vortex PCM ALSA driver.
20 * Supports ADB and WT DMA. Unfortunately, WT channels do not run yet.
21 * It remains stuck,and DMA transfers do not happen.
23 #include <sound/asoundef.h>
24 #include <linux/time.h>
25 #include <sound/core.h>
26 #include <sound/pcm.h>
27 #include <sound/pcm_params.h>
30 #define VORTEX_PCM_TYPE(x) (x->name[40])
32 /* hardware definition */
33 static struct snd_pcm_hardware snd_vortex_playback_hw_adb
= {
35 (SNDRV_PCM_INFO_MMAP
| /* SNDRV_PCM_INFO_RESUME | */
36 SNDRV_PCM_INFO_PAUSE
| SNDRV_PCM_INFO_INTERLEAVED
|
37 SNDRV_PCM_INFO_MMAP_VALID
),
39 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U8
|
40 SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
,
41 .rates
= SNDRV_PCM_RATE_CONTINUOUS
,
46 .buffer_bytes_max
= 0x10000,
47 .period_bytes_min
= 0x1,
48 .period_bytes_max
= 0x1000,
54 static struct snd_pcm_hardware snd_vortex_playback_hw_a3d
= {
56 (SNDRV_PCM_INFO_MMAP
| /* SNDRV_PCM_INFO_RESUME | */
57 SNDRV_PCM_INFO_PAUSE
| SNDRV_PCM_INFO_INTERLEAVED
|
58 SNDRV_PCM_INFO_MMAP_VALID
),
60 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U8
|
61 SNDRV_PCM_FMTBIT_MU_LAW
| SNDRV_PCM_FMTBIT_A_LAW
,
62 .rates
= SNDRV_PCM_RATE_CONTINUOUS
,
67 .buffer_bytes_max
= 0x10000,
68 .period_bytes_min
= 0x100,
69 .period_bytes_max
= 0x1000,
74 static struct snd_pcm_hardware snd_vortex_playback_hw_spdif
= {
76 (SNDRV_PCM_INFO_MMAP
| /* SNDRV_PCM_INFO_RESUME | */
77 SNDRV_PCM_INFO_PAUSE
| SNDRV_PCM_INFO_INTERLEAVED
|
78 SNDRV_PCM_INFO_MMAP_VALID
),
80 SNDRV_PCM_FMTBIT_S16_LE
| SNDRV_PCM_FMTBIT_U8
|
81 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
| SNDRV_PCM_FMTBIT_MU_LAW
|
82 SNDRV_PCM_FMTBIT_A_LAW
,
84 SNDRV_PCM_RATE_32000
| SNDRV_PCM_RATE_44100
| SNDRV_PCM_RATE_48000
,
89 .buffer_bytes_max
= 0x10000,
90 .period_bytes_min
= 0x100,
91 .period_bytes_max
= 0x1000,
97 static struct snd_pcm_hardware snd_vortex_playback_hw_wt
= {
98 .info
= (SNDRV_PCM_INFO_MMAP
|
99 SNDRV_PCM_INFO_INTERLEAVED
|
100 SNDRV_PCM_INFO_BLOCK_TRANSFER
| SNDRV_PCM_INFO_MMAP_VALID
),
101 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
102 .rates
= SNDRV_PCM_RATE_8000_48000
| SNDRV_PCM_RATE_CONTINUOUS
, // SNDRV_PCM_RATE_48000,
107 .buffer_bytes_max
= 0x10000,
108 .period_bytes_min
= 0x0400,
109 .period_bytes_max
= 0x1000,
115 static unsigned int au8830_channels
[3] = {
119 static struct snd_pcm_hw_constraint_list hw_constraints_au8830_channels
= {
120 .count
= ARRAY_SIZE(au8830_channels
),
121 .list
= au8830_channels
,
126 static int snd_vortex_pcm_open(struct snd_pcm_substream
*substream
)
128 vortex_t
*vortex
= snd_pcm_substream_chip(substream
);
129 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
132 /* Force equal size periods */
134 snd_pcm_hw_constraint_integer(runtime
,
135 SNDRV_PCM_HW_PARAM_PERIODS
)) < 0)
137 /* Avoid PAGE_SIZE boundary to fall inside of a period. */
139 snd_pcm_hw_constraint_pow2(runtime
, 0,
140 SNDRV_PCM_HW_PARAM_PERIOD_BYTES
)) < 0)
143 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
) {
145 if (VORTEX_PCM_TYPE(substream
->pcm
) == VORTEX_PCM_A3D
) {
146 runtime
->hw
= snd_vortex_playback_hw_a3d
;
149 if (VORTEX_PCM_TYPE(substream
->pcm
) == VORTEX_PCM_SPDIF
) {
150 runtime
->hw
= snd_vortex_playback_hw_spdif
;
151 switch (vortex
->spdif_sr
) {
153 runtime
->hw
.rates
= SNDRV_PCM_RATE_32000
;
156 runtime
->hw
.rates
= SNDRV_PCM_RATE_44100
;
159 runtime
->hw
.rates
= SNDRV_PCM_RATE_48000
;
163 if (VORTEX_PCM_TYPE(substream
->pcm
) == VORTEX_PCM_ADB
164 || VORTEX_PCM_TYPE(substream
->pcm
) == VORTEX_PCM_I2S
)
165 runtime
->hw
= snd_vortex_playback_hw_adb
;
167 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
&&
168 VORTEX_PCM_TYPE(substream
->pcm
) == VORTEX_PCM_ADB
) {
169 runtime
->hw
.channels_max
= 4;
170 snd_pcm_hw_constraint_list(runtime
, 0,
171 SNDRV_PCM_HW_PARAM_CHANNELS
,
172 &hw_constraints_au8830_channels
);
175 substream
->runtime
->private_data
= NULL
;
179 runtime
->hw
= snd_vortex_playback_hw_wt
;
180 substream
->runtime
->private_data
= NULL
;
187 static int snd_vortex_pcm_close(struct snd_pcm_substream
*substream
)
189 //vortex_t *chip = snd_pcm_substream_chip(substream);
190 stream_t
*stream
= (stream_t
*) substream
->runtime
->private_data
;
192 // the hardware-specific codes will be here
193 if (stream
!= NULL
) {
194 stream
->substream
= NULL
;
197 substream
->runtime
->private_data
= NULL
;
201 /* hw_params callback */
203 snd_vortex_pcm_hw_params(struct snd_pcm_substream
*substream
,
204 struct snd_pcm_hw_params
*hw_params
)
206 vortex_t
*chip
= snd_pcm_substream_chip(substream
);
207 stream_t
*stream
= (stream_t
*) (substream
->runtime
->private_data
);
210 // Alloc buffer memory.
212 snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
214 printk(KERN_ERR
"Vortex: pcm page alloc failed!\n");
218 printk(KERN_INFO "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params),
219 params_period_bytes(hw_params), params_channels(hw_params));
221 spin_lock_irq(&chip
->lock
);
222 // Make audio routes and config buffer DMA.
223 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
) {
224 int dma
, type
= VORTEX_PCM_TYPE(substream
->pcm
);
225 /* Dealloc any routes. */
227 vortex_adb_allocroute(chip
, stream
->dma
,
228 stream
->nr_ch
, stream
->dir
,
232 vortex_adb_allocroute(chip
, -1,
233 params_channels(hw_params
),
234 substream
->stream
, type
);
236 spin_unlock_irq(&chip
->lock
);
239 stream
= substream
->runtime
->private_data
= &chip
->dma_adb
[dma
];
240 stream
->substream
= substream
;
242 vortex_adbdma_setbuffers(chip
, dma
,
243 params_period_bytes(hw_params
),
244 params_periods(hw_params
));
248 /* if (stream != NULL)
249 vortex_wt_allocroute(chip, substream->number, 0); */
250 vortex_wt_allocroute(chip
, substream
->number
,
251 params_channels(hw_params
));
252 stream
= substream
->runtime
->private_data
=
253 &chip
->dma_wt
[substream
->number
];
254 stream
->dma
= substream
->number
;
255 stream
->substream
= substream
;
256 vortex_wtdma_setbuffers(chip
, substream
->number
,
257 params_period_bytes(hw_params
),
258 params_periods(hw_params
));
261 spin_unlock_irq(&chip
->lock
);
265 /* hw_free callback */
266 static int snd_vortex_pcm_hw_free(struct snd_pcm_substream
*substream
)
268 vortex_t
*chip
= snd_pcm_substream_chip(substream
);
269 stream_t
*stream
= (stream_t
*) (substream
->runtime
->private_data
);
271 spin_lock_irq(&chip
->lock
);
272 // Delete audio routes.
273 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
) {
275 vortex_adb_allocroute(chip
, stream
->dma
,
276 stream
->nr_ch
, stream
->dir
,
282 vortex_wt_allocroute(chip
, stream
->dma
, 0);
285 substream
->runtime
->private_data
= NULL
;
286 spin_unlock_irq(&chip
->lock
);
288 return snd_pcm_lib_free_pages(substream
);
291 /* prepare callback */
292 static int snd_vortex_pcm_prepare(struct snd_pcm_substream
*substream
)
294 vortex_t
*chip
= snd_pcm_substream_chip(substream
);
295 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
296 stream_t
*stream
= (stream_t
*) substream
->runtime
->private_data
;
297 int dma
= stream
->dma
, fmt
, dir
;
299 // set up the hardware with the current configuration.
300 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
304 fmt
= vortex_alsafmt_aspfmt(runtime
->format
);
305 spin_lock_irq(&chip
->lock
);
306 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
) {
307 vortex_adbdma_setmode(chip
, dma
, 1, dir
, fmt
, 0 /*? */ ,
309 vortex_adbdma_setstartbuffer(chip
, dma
, 0);
310 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_SPDIF
)
311 vortex_adb_setsrc(chip
, dma
, runtime
->rate
, dir
);
315 vortex_wtdma_setmode(chip
, dma
, 1, fmt
, 0, 0);
316 vortex_wtdma_setstartbuffer(chip
, dma
, 0);
319 spin_unlock_irq(&chip
->lock
);
323 /* trigger callback */
324 static int snd_vortex_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
326 vortex_t
*chip
= snd_pcm_substream_chip(substream
);
327 stream_t
*stream
= (stream_t
*) substream
->runtime
->private_data
;
328 int dma
= stream
->dma
;
330 spin_lock(&chip
->lock
);
332 case SNDRV_PCM_TRIGGER_START
:
333 // do something to start the PCM engine
334 //printk(KERN_INFO "vortex: start %d\n", dma);
335 stream
->fifo_enabled
= 1;
336 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
) {
337 vortex_adbdma_resetup(chip
, dma
);
338 vortex_adbdma_startfifo(chip
, dma
);
342 printk(KERN_INFO
"vortex: wt start %d\n", dma
);
343 vortex_wtdma_startfifo(chip
, dma
);
347 case SNDRV_PCM_TRIGGER_STOP
:
348 // do something to stop the PCM engine
349 //printk(KERN_INFO "vortex: stop %d\n", dma);
350 stream
->fifo_enabled
= 0;
351 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
)
352 vortex_adbdma_pausefifo(chip
, dma
);
353 //vortex_adbdma_stopfifo(chip, dma);
356 printk(KERN_INFO
"vortex: wt stop %d\n", dma
);
357 vortex_wtdma_stopfifo(chip
, dma
);
361 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
362 //printk(KERN_INFO "vortex: pause %d\n", dma);
363 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
)
364 vortex_adbdma_pausefifo(chip
, dma
);
367 vortex_wtdma_pausefifo(chip
, dma
);
370 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
371 //printk(KERN_INFO "vortex: resume %d\n", dma);
372 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
)
373 vortex_adbdma_resumefifo(chip
, dma
);
376 vortex_wtdma_resumefifo(chip
, dma
);
380 spin_unlock(&chip
->lock
);
383 spin_unlock(&chip
->lock
);
387 /* pointer callback */
388 static snd_pcm_uframes_t
snd_vortex_pcm_pointer(struct snd_pcm_substream
*substream
)
390 vortex_t
*chip
= snd_pcm_substream_chip(substream
);
391 stream_t
*stream
= (stream_t
*) substream
->runtime
->private_data
;
392 int dma
= stream
->dma
;
393 snd_pcm_uframes_t current_ptr
= 0;
395 spin_lock(&chip
->lock
);
396 if (VORTEX_PCM_TYPE(substream
->pcm
) != VORTEX_PCM_WT
)
397 current_ptr
= vortex_adbdma_getlinearpos(chip
, dma
);
400 current_ptr
= vortex_wtdma_getlinearpos(chip
, dma
);
402 //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr);
403 spin_unlock(&chip
->lock
);
404 return (bytes_to_frames(substream
->runtime
, current_ptr
));
408 static struct snd_pcm_ops snd_vortex_playback_ops
= {
409 .open
= snd_vortex_pcm_open
,
410 .close
= snd_vortex_pcm_close
,
411 .ioctl
= snd_pcm_lib_ioctl
,
412 .hw_params
= snd_vortex_pcm_hw_params
,
413 .hw_free
= snd_vortex_pcm_hw_free
,
414 .prepare
= snd_vortex_pcm_prepare
,
415 .trigger
= snd_vortex_pcm_trigger
,
416 .pointer
= snd_vortex_pcm_pointer
,
417 .page
= snd_pcm_sgbuf_ops_page
,
421 * definitions of capture are omitted here...
424 static char *vortex_pcm_prettyname
[VORTEX_PCM_LAST
] = {
431 static char *vortex_pcm_name
[VORTEX_PCM_LAST
] = {
441 static int snd_vortex_spdif_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
443 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
448 static int snd_vortex_spdif_mask_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
450 ucontrol
->value
.iec958
.status
[0] = 0xff;
451 ucontrol
->value
.iec958
.status
[1] = 0xff;
452 ucontrol
->value
.iec958
.status
[2] = 0xff;
453 ucontrol
->value
.iec958
.status
[3] = IEC958_AES3_CON_FS
;
457 static int snd_vortex_spdif_get(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
459 vortex_t
*vortex
= snd_kcontrol_chip(kcontrol
);
460 ucontrol
->value
.iec958
.status
[0] = 0x00;
461 ucontrol
->value
.iec958
.status
[1] = IEC958_AES1_CON_ORIGINAL
|IEC958_AES1_CON_DIGDIGCONV_ID
;
462 ucontrol
->value
.iec958
.status
[2] = 0x00;
463 switch (vortex
->spdif_sr
) {
464 case 32000: ucontrol
->value
.iec958
.status
[3] = IEC958_AES3_CON_FS_32000
; break;
465 case 44100: ucontrol
->value
.iec958
.status
[3] = IEC958_AES3_CON_FS_44100
; break;
466 case 48000: ucontrol
->value
.iec958
.status
[3] = IEC958_AES3_CON_FS_48000
; break;
471 static int snd_vortex_spdif_put(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_value
*ucontrol
)
473 vortex_t
*vortex
= snd_kcontrol_chip(kcontrol
);
474 int spdif_sr
= 48000;
475 switch (ucontrol
->value
.iec958
.status
[3] & IEC958_AES3_CON_FS
) {
476 case IEC958_AES3_CON_FS_32000
: spdif_sr
= 32000; break;
477 case IEC958_AES3_CON_FS_44100
: spdif_sr
= 44100; break;
478 case IEC958_AES3_CON_FS_48000
: spdif_sr
= 48000; break;
480 if (spdif_sr
== vortex
->spdif_sr
)
482 vortex
->spdif_sr
= spdif_sr
;
483 vortex_spdif_init(vortex
, vortex
->spdif_sr
, 1);
488 static struct snd_kcontrol_new snd_vortex_mixer_spdif
[] __devinitdata
= {
490 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
491 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
492 .info
= snd_vortex_spdif_info
,
493 .get
= snd_vortex_spdif_get
,
494 .put
= snd_vortex_spdif_put
,
497 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
498 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
499 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,CON_MASK
),
500 .info
= snd_vortex_spdif_info
,
501 .get
= snd_vortex_spdif_mask_get
505 /* create a pcm device */
506 static int __devinit
snd_vortex_new_pcm(vortex_t
*chip
, int idx
, int nr
)
509 struct snd_kcontrol
*kctl
;
513 if (!chip
|| idx
< 0 || idx
>= VORTEX_PCM_LAST
)
516 /* idx indicates which kind of PCM device. ADB, SPDIF, I2S and A3D share the
517 * same dma engine. WT uses it own separate dma engine whcih cant capture. */
518 if (idx
== VORTEX_PCM_ADB
)
522 err
= snd_pcm_new(chip
->card
, vortex_pcm_prettyname
[idx
], idx
, nr
,
526 strcpy(pcm
->name
, vortex_pcm_name
[idx
]);
527 chip
->pcm
[idx
] = pcm
;
528 // This is an evil hack, but it saves a lot of duplicated code.
529 VORTEX_PCM_TYPE(pcm
) = idx
;
530 pcm
->private_data
= chip
;
532 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
533 &snd_vortex_playback_ops
);
534 if (idx
== VORTEX_PCM_ADB
)
535 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
,
536 &snd_vortex_playback_ops
);
538 /* pre-allocation of Scatter-Gather buffers */
540 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV_SG
,
541 snd_dma_pci_data(chip
->pci_dev
),
544 if (VORTEX_PCM_TYPE(pcm
) == VORTEX_PCM_SPDIF
) {
545 for (i
= 0; i
< ARRAY_SIZE(snd_vortex_mixer_spdif
); i
++) {
546 kctl
= snd_ctl_new1(&snd_vortex_mixer_spdif
[i
], chip
);
549 if ((err
= snd_ctl_add(chip
->card
, kctl
)) < 0)