2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Driver for Digigram VX soundcards
|
|
|
|
*
|
|
|
|
* PCM part
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002,2003 by Takashi Iwai <tiwai@suse.de>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* STRATEGY
|
|
|
|
* for playback, we send series of "chunks", which size is equal with the
|
|
|
|
* IBL size, typically 126 samples. at each end of chunk, the end-of-buffer
|
|
|
|
* interrupt is notified, and the interrupt handler will feed the next chunk.
|
|
|
|
*
|
|
|
|
* the current position is calculated from the sample count RMH.
|
|
|
|
* pipe->transferred is the counter of data which has been already transferred.
|
|
|
|
* if this counter reaches to the period size, snd_pcm_period_elapsed() will
|
|
|
|
* be issued.
|
|
|
|
*
|
|
|
|
* for capture, the situation is much easier.
|
|
|
|
* to get a low latency response, we'll check the capture streams at each
|
|
|
|
* interrupt (capture stream has no EOB notification). if the pending
|
|
|
|
* data is accumulated to the period size, snd_pcm_period_elapsed() is
|
|
|
|
* called and the pointer is updated.
|
|
|
|
*
|
|
|
|
* the current point of read buffer is kept in pipe->hw_ptr. note that
|
|
|
|
* this is in bytes.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* TODO
|
|
|
|
* - linked trigger for full-duplex mode.
|
|
|
|
* - scheduled action on the stream.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sound/driver.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <sound/core.h>
|
|
|
|
#include <sound/asoundef.h>
|
|
|
|
#include <sound/pcm.h>
|
|
|
|
#include <sound/vx_core.h>
|
|
|
|
#include "vx_cmd.h"
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* we use a vmalloc'ed (sg-)buffer
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* get the physical page pointer on the given offset */
|
|
|
|
static struct page *snd_pcm_get_vmalloc_page(snd_pcm_substream_t *subs, unsigned long offset)
|
|
|
|
{
|
|
|
|
void *pageptr = subs->runtime->dma_area + offset;
|
|
|
|
return vmalloc_to_page(pageptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* allocate a buffer via vmalloc_32().
|
|
|
|
* called from hw_params
|
|
|
|
* NOTE: this may be called not only once per pcm open!
|
|
|
|
*/
|
|
|
|
static int snd_pcm_alloc_vmalloc_buffer(snd_pcm_substream_t *subs, size_t size)
|
|
|
|
{
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
if (runtime->dma_area) {
|
|
|
|
/* already allocated */
|
|
|
|
if (runtime->dma_bytes >= size)
|
|
|
|
return 0; /* already enough large */
|
2005-10-10 11:56:31 +02:00
|
|
|
vfree(runtime->dma_area);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
runtime->dma_area = vmalloc_32(size);
|
|
|
|
if (! runtime->dma_area)
|
|
|
|
return -ENOMEM;
|
|
|
|
memset(runtime->dma_area, 0, size);
|
|
|
|
runtime->dma_bytes = size;
|
|
|
|
return 1; /* changed */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* free the buffer.
|
|
|
|
* called from hw_free callback
|
|
|
|
* NOTE: this may be called not only once per pcm open!
|
|
|
|
*/
|
|
|
|
static int snd_pcm_free_vmalloc_buffer(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
if (runtime->dma_area) {
|
2005-10-10 11:56:31 +02:00
|
|
|
vfree(runtime->dma_area);
|
2005-04-17 00:20:36 +02:00
|
|
|
runtime->dma_area = NULL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* read three pending pcm bytes via inb()
|
|
|
|
*/
|
|
|
|
static void vx_pcm_read_per_bytes(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
int offset = pipe->hw_ptr;
|
|
|
|
unsigned char *buf = (unsigned char *)(runtime->dma_area + offset);
|
|
|
|
*buf++ = vx_inb(chip, RXH);
|
|
|
|
if (++offset >= pipe->buffer_bytes) {
|
|
|
|
offset = 0;
|
|
|
|
buf = (unsigned char *)runtime->dma_area;
|
|
|
|
}
|
|
|
|
*buf++ = vx_inb(chip, RXM);
|
|
|
|
if (++offset >= pipe->buffer_bytes) {
|
|
|
|
offset = 0;
|
|
|
|
buf = (unsigned char *)runtime->dma_area;
|
|
|
|
}
|
|
|
|
*buf++ = vx_inb(chip, RXL);
|
|
|
|
if (++offset >= pipe->buffer_bytes) {
|
|
|
|
offset = 0;
|
|
|
|
buf = (unsigned char *)runtime->dma_area;
|
|
|
|
}
|
|
|
|
pipe->hw_ptr = offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_set_pcx_time - convert from the PC time to the RMH status time.
|
|
|
|
* @pc_time: the pointer for the PC-time to set
|
|
|
|
* @dsp_time: the pointer for RMH status time array
|
|
|
|
*/
|
|
|
|
static void vx_set_pcx_time(vx_core_t *chip, pcx_time_t *pc_time, unsigned int *dsp_time)
|
|
|
|
{
|
|
|
|
dsp_time[0] = (unsigned int)((*pc_time) >> 24) & PCX_TIME_HI_MASK;
|
|
|
|
dsp_time[1] = (unsigned int)(*pc_time) & MASK_DSP_WORD;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_set_differed_time - set the differed time if specified
|
|
|
|
* @rmh: the rmh record to modify
|
|
|
|
* @pipe: the pipe to be checked
|
|
|
|
*
|
|
|
|
* if the pipe is programmed with the differed time, set the DSP time
|
|
|
|
* on the rmh and changes its command length.
|
|
|
|
*
|
|
|
|
* returns the increase of the command length.
|
|
|
|
*/
|
|
|
|
static int vx_set_differed_time(vx_core_t *chip, struct vx_rmh *rmh, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
/* Update The length added to the RMH command by the timestamp */
|
|
|
|
if (! (pipe->differed_type & DC_DIFFERED_DELAY))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Set the T bit */
|
|
|
|
rmh->Cmd[0] |= DSP_DIFFERED_COMMAND_MASK;
|
|
|
|
|
|
|
|
/* Time stamp is the 1st following parameter */
|
|
|
|
vx_set_pcx_time(chip, &pipe->pcx_time, &rmh->Cmd[1]);
|
|
|
|
|
|
|
|
/* Add the flags to a notified differed command */
|
|
|
|
if (pipe->differed_type & DC_NOTIFY_DELAY)
|
|
|
|
rmh->Cmd[1] |= NOTIFY_MASK_TIME_HIGH ;
|
|
|
|
|
|
|
|
/* Add the flags to a multiple differed command */
|
|
|
|
if (pipe->differed_type & DC_MULTIPLE_DELAY)
|
|
|
|
rmh->Cmd[1] |= MULTIPLE_MASK_TIME_HIGH;
|
|
|
|
|
|
|
|
/* Add the flags to a stream-time differed command */
|
|
|
|
if (pipe->differed_type & DC_STREAM_TIME_DELAY)
|
|
|
|
rmh->Cmd[1] |= STREAM_MASK_TIME_HIGH;
|
|
|
|
|
|
|
|
rmh->LgCmd += 2;
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_set_stream_format - send the stream format command
|
|
|
|
* @pipe: the affected pipe
|
|
|
|
* @data: format bitmask
|
|
|
|
*/
|
|
|
|
static int vx_set_stream_format(vx_core_t *chip, vx_pipe_t *pipe, unsigned int data)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, pipe->is_capture ?
|
|
|
|
CMD_FORMAT_STREAM_IN : CMD_FORMAT_STREAM_OUT);
|
|
|
|
rmh.Cmd[0] |= pipe->number << FIELD_SIZE;
|
|
|
|
|
|
|
|
/* Command might be longer since we may have to add a timestamp */
|
|
|
|
vx_set_differed_time(chip, &rmh, pipe);
|
|
|
|
|
|
|
|
rmh.Cmd[rmh.LgCmd] = (data & 0xFFFFFF00) >> 8;
|
|
|
|
rmh.Cmd[rmh.LgCmd + 1] = (data & 0xFF) << 16 /*| (datal & 0xFFFF00) >> 8*/;
|
|
|
|
rmh.LgCmd += 2;
|
|
|
|
|
|
|
|
return vx_send_msg(chip, &rmh);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_set_format - set the format of a pipe
|
|
|
|
* @pipe: the affected pipe
|
|
|
|
* @runtime: pcm runtime instance to be referred
|
|
|
|
*
|
|
|
|
* returns 0 if successful, or a negative error code.
|
|
|
|
*/
|
|
|
|
static int vx_set_format(vx_core_t *chip, vx_pipe_t *pipe,
|
|
|
|
snd_pcm_runtime_t *runtime)
|
|
|
|
{
|
|
|
|
unsigned int header = HEADER_FMT_BASE;
|
|
|
|
|
|
|
|
if (runtime->channels == 1)
|
|
|
|
header |= HEADER_FMT_MONO;
|
|
|
|
if (snd_pcm_format_little_endian(runtime->format))
|
|
|
|
header |= HEADER_FMT_INTEL;
|
|
|
|
if (runtime->rate < 32000 && runtime->rate > 11025)
|
|
|
|
header |= HEADER_FMT_UPTO32;
|
|
|
|
else if (runtime->rate <= 11025)
|
|
|
|
header |= HEADER_FMT_UPTO11;
|
|
|
|
|
|
|
|
switch (snd_pcm_format_physical_width(runtime->format)) {
|
|
|
|
// case 8: break;
|
|
|
|
case 16: header |= HEADER_FMT_16BITS; break;
|
|
|
|
case 24: header |= HEADER_FMT_24BITS; break;
|
|
|
|
default :
|
|
|
|
snd_BUG();
|
|
|
|
return -EINVAL;
|
|
|
|
};
|
|
|
|
|
|
|
|
return vx_set_stream_format(chip, pipe, header);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set / query the IBL size
|
|
|
|
*/
|
|
|
|
static int vx_set_ibl(vx_core_t *chip, struct vx_ibl_info *info)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_IBL);
|
|
|
|
rmh.Cmd[0] |= info->size & 0x03ffff;
|
|
|
|
err = vx_send_msg(chip, &rmh);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
info->size = rmh.Stat[0];
|
|
|
|
info->max_size = rmh.Stat[1];
|
|
|
|
info->min_size = rmh.Stat[2];
|
|
|
|
info->granularity = rmh.Stat[3];
|
|
|
|
snd_printdd(KERN_DEBUG "vx_set_ibl: size = %d, max = %d, min = %d, gran = %d\n",
|
|
|
|
info->size, info->max_size, info->min_size, info->granularity);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_get_pipe_state - get the state of a pipe
|
|
|
|
* @pipe: the pipe to be checked
|
|
|
|
* @state: the pointer for the returned state
|
|
|
|
*
|
|
|
|
* checks the state of a given pipe, and stores the state (1 = running,
|
|
|
|
* 0 = paused) on the given pointer.
|
|
|
|
*
|
|
|
|
* called from trigger callback only
|
|
|
|
*/
|
|
|
|
static int vx_get_pipe_state(vx_core_t *chip, vx_pipe_t *pipe, int *state)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_PIPE_STATE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
|
|
|
|
err = vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */
|
|
|
|
if (! err)
|
|
|
|
*state = (rmh.Stat[0] & (1 << pipe->number)) ? 1 : 0;
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_query_hbuffer_size - query available h-buffer size in bytes
|
|
|
|
* @pipe: the pipe to be checked
|
|
|
|
*
|
|
|
|
* return the available size on h-buffer in bytes,
|
|
|
|
* or a negative error code.
|
|
|
|
*
|
|
|
|
* NOTE: calling this function always switches to the stream mode.
|
|
|
|
* you'll need to disconnect the host to get back to the
|
|
|
|
* normal mode.
|
|
|
|
*/
|
|
|
|
static int vx_query_hbuffer_size(vx_core_t *chip, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
int result;
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_SIZE_HBUFFER);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
|
|
|
|
if (pipe->is_capture)
|
|
|
|
rmh.Cmd[0] |= 0x00000001;
|
|
|
|
result = vx_send_msg(chip, &rmh);
|
|
|
|
if (! result)
|
|
|
|
result = rmh.Stat[0] & 0xffff;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pipe_can_start - query whether a pipe is ready for start
|
|
|
|
* @pipe: the pipe to be checked
|
|
|
|
*
|
|
|
|
* return 1 if ready, 0 if not ready, and negative value on error.
|
|
|
|
*
|
|
|
|
* called from trigger callback only
|
|
|
|
*/
|
|
|
|
static int vx_pipe_can_start(vx_core_t *chip, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_CAN_START_PIPE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
|
|
|
|
rmh.Cmd[0] |= 1;
|
|
|
|
|
|
|
|
err = vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */
|
|
|
|
if (! err) {
|
|
|
|
if (rmh.Stat[0])
|
|
|
|
err = 1;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_conf_pipe - tell the pipe to stand by and wait for IRQA.
|
|
|
|
* @pipe: the pipe to be configured
|
|
|
|
*/
|
|
|
|
static int vx_conf_pipe(vx_core_t *chip, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_CONF_PIPE);
|
|
|
|
if (pipe->is_capture)
|
|
|
|
rmh.Cmd[0] |= COMMAND_RECORD_MASK;
|
|
|
|
rmh.Cmd[1] = 1 << pipe->number;
|
|
|
|
return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_send_irqa - trigger IRQA
|
|
|
|
*/
|
|
|
|
static int vx_send_irqa(vx_core_t *chip)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_SEND_IRQA);
|
|
|
|
return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#define MAX_WAIT_FOR_DSP 250
|
|
|
|
/*
|
|
|
|
* vx boards do not support inter-card sync, besides
|
|
|
|
* only 126 samples require to be prepared before a pipe can start
|
|
|
|
*/
|
|
|
|
#define CAN_START_DELAY 2 /* wait 2ms only before asking if the pipe is ready*/
|
|
|
|
#define WAIT_STATE_DELAY 2 /* wait 2ms after irqA was requested and check if the pipe state toggled*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_toggle_pipe - start / pause a pipe
|
|
|
|
* @pipe: the pipe to be triggered
|
|
|
|
* @state: start = 1, pause = 0
|
|
|
|
*
|
|
|
|
* called from trigger callback only
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static int vx_toggle_pipe(vx_core_t *chip, vx_pipe_t *pipe, int state)
|
|
|
|
{
|
|
|
|
int err, i, cur_state;
|
|
|
|
|
|
|
|
/* Check the pipe is not already in the requested state */
|
|
|
|
if (vx_get_pipe_state(chip, pipe, &cur_state) < 0)
|
|
|
|
return -EBADFD;
|
|
|
|
if (state == cur_state)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* If a start is requested, ask the DSP to get prepared
|
|
|
|
* and wait for a positive acknowledge (when there are
|
|
|
|
* enough sound buffer for this pipe)
|
|
|
|
*/
|
|
|
|
if (state) {
|
|
|
|
for (i = 0 ; i < MAX_WAIT_FOR_DSP; i++) {
|
|
|
|
err = vx_pipe_can_start(chip, pipe);
|
|
|
|
if (err > 0)
|
|
|
|
break;
|
|
|
|
/* Wait for a few, before asking again
|
|
|
|
* to avoid flooding the DSP with our requests
|
|
|
|
*/
|
|
|
|
mdelay(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((err = vx_conf_pipe(chip, pipe)) < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if ((err = vx_send_irqa(chip)) < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* If it completes successfully, wait for the pipes
|
|
|
|
* reaching the expected state before returning
|
|
|
|
* Check one pipe only (since they are synchronous)
|
|
|
|
*/
|
|
|
|
for (i = 0; i < MAX_WAIT_FOR_DSP; i++) {
|
|
|
|
err = vx_get_pipe_state(chip, pipe, &cur_state);
|
|
|
|
if (err < 0 || cur_state == state)
|
|
|
|
break;
|
|
|
|
err = -EIO;
|
|
|
|
mdelay(1);
|
|
|
|
}
|
|
|
|
return err < 0 ? -EIO : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_stop_pipe - stop a pipe
|
|
|
|
* @pipe: the pipe to be stopped
|
|
|
|
*
|
|
|
|
* called from trigger callback only
|
|
|
|
*/
|
|
|
|
static int vx_stop_pipe(vx_core_t *chip, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
vx_init_rmh(&rmh, CMD_STOP_PIPE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
|
|
|
|
return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_alloc_pipe - allocate a pipe and initialize the pipe instance
|
|
|
|
* @capture: 0 = playback, 1 = capture operation
|
|
|
|
* @audioid: the audio id to be assigned
|
|
|
|
* @num_audio: number of audio channels
|
|
|
|
* @pipep: the returned pipe instance
|
|
|
|
*
|
|
|
|
* return 0 on success, or a negative error code.
|
|
|
|
*/
|
|
|
|
static int vx_alloc_pipe(vx_core_t *chip, int capture,
|
|
|
|
int audioid, int num_audio,
|
|
|
|
vx_pipe_t **pipep)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
vx_pipe_t *pipe;
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
int data_mode;
|
|
|
|
|
|
|
|
*pipep = NULL;
|
|
|
|
vx_init_rmh(&rmh, CMD_RES_PIPE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, capture, audioid, num_audio);
|
|
|
|
#if 0 // NYI
|
|
|
|
if (underrun_skip_sound)
|
|
|
|
rmh.Cmd[0] |= BIT_SKIP_SOUND;
|
|
|
|
#endif // NYI
|
|
|
|
data_mode = (chip->uer_bits & IEC958_AES0_NONAUDIO) != 0;
|
|
|
|
if (! capture && data_mode)
|
|
|
|
rmh.Cmd[0] |= BIT_DATA_MODE;
|
|
|
|
err = vx_send_msg(chip, &rmh);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* initialize the pipe record */
|
[ALSA] Replace with kzalloc() - others
Documentation,SA11xx UDA1341 driver,Generic drivers,MPU401 UART,OPL3
OPL4,Digigram VX core,I2C cs8427,I2C lib core,I2C tea6330t,L3 drivers
AK4114 receiver,AK4117 receiver,PDAudioCF driver,PPC PMAC driver
SPARC AMD7930 driver,SPARC cs4231 driver,Synth,Common EMU synth
USB generic driver,USB USX2Y
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 14:22:34 +02:00
|
|
|
pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (! pipe) {
|
|
|
|
/* release the pipe */
|
|
|
|
vx_init_rmh(&rmh, CMD_FREE_PIPE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, capture, audioid, 0);
|
|
|
|
vx_send_msg(chip, &rmh);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* the pipe index should be identical with the audio index */
|
|
|
|
pipe->number = audioid;
|
|
|
|
pipe->is_capture = capture;
|
|
|
|
pipe->channels = num_audio;
|
|
|
|
pipe->differed_type = 0;
|
|
|
|
pipe->pcx_time = 0;
|
|
|
|
pipe->data_mode = data_mode;
|
|
|
|
*pipep = pipe;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_free_pipe - release a pipe
|
|
|
|
* @pipe: pipe to be released
|
|
|
|
*/
|
|
|
|
static int vx_free_pipe(vx_core_t *chip, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_FREE_PIPE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
|
|
|
|
vx_send_msg(chip, &rmh);
|
|
|
|
|
|
|
|
kfree(pipe);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_start_stream - start the stream
|
|
|
|
*
|
|
|
|
* called from trigger callback only
|
|
|
|
*/
|
|
|
|
static int vx_start_stream(vx_core_t *chip, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_START_ONE_STREAM);
|
|
|
|
vx_set_stream_cmd_params(&rmh, pipe->is_capture, pipe->number);
|
|
|
|
vx_set_differed_time(chip, &rmh, pipe);
|
|
|
|
return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_stop_stream - stop the stream
|
|
|
|
*
|
|
|
|
* called from trigger callback only
|
|
|
|
*/
|
|
|
|
static int vx_stop_stream(vx_core_t *chip, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_STOP_STREAM);
|
|
|
|
vx_set_stream_cmd_params(&rmh, pipe->is_capture, pipe->number);
|
|
|
|
return vx_send_msg_nolock(chip, &rmh); /* no lock needed for trigger */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* playback hw information
|
|
|
|
*/
|
|
|
|
|
|
|
|
static snd_pcm_hardware_t vx_pcm_playback_hw = {
|
|
|
|
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
|
2005-08-18 13:43:12 +02:00
|
|
|
SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
|
|
|
|
/*SNDRV_PCM_INFO_RESUME*/),
|
2005-04-17 00:20:36 +02:00
|
|
|
.formats = /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
|
|
|
|
.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
|
|
|
|
.rate_min = 5000,
|
|
|
|
.rate_max = 48000,
|
|
|
|
.channels_min = 1,
|
|
|
|
.channels_max = 2,
|
|
|
|
.buffer_bytes_max = (128*1024),
|
|
|
|
.period_bytes_min = 126,
|
|
|
|
.period_bytes_max = (128*1024),
|
|
|
|
.periods_min = 2,
|
|
|
|
.periods_max = VX_MAX_PERIODS,
|
|
|
|
.fifo_size = 126,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static void vx_pcm_delayed_start(unsigned long arg);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_playback_open - open callback for playback
|
|
|
|
*/
|
|
|
|
static int vx_pcm_playback_open(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
vx_core_t *chip = snd_pcm_substream_chip(subs);
|
|
|
|
vx_pipe_t *pipe = NULL;
|
|
|
|
unsigned int audio;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (chip->chip_status & VX_STAT_IS_STALE)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
audio = subs->pcm->device * 2;
|
|
|
|
snd_assert(audio < chip->audio_outs, return -EINVAL);
|
|
|
|
|
|
|
|
/* playback pipe may have been already allocated for monitoring */
|
|
|
|
pipe = chip->playback_pipes[audio];
|
|
|
|
if (! pipe) {
|
|
|
|
/* not allocated yet */
|
|
|
|
err = vx_alloc_pipe(chip, 0, audio, 2, &pipe); /* stereo playback */
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
chip->playback_pipes[audio] = pipe;
|
|
|
|
}
|
|
|
|
/* open for playback */
|
|
|
|
pipe->references++;
|
|
|
|
|
|
|
|
pipe->substream = subs;
|
|
|
|
tasklet_init(&pipe->start_tq, vx_pcm_delayed_start, (unsigned long)subs);
|
|
|
|
chip->playback_pipes[audio] = pipe;
|
|
|
|
|
|
|
|
runtime->hw = vx_pcm_playback_hw;
|
|
|
|
runtime->hw.period_bytes_min = chip->ibl.size;
|
|
|
|
runtime->private_data = pipe;
|
|
|
|
|
|
|
|
/* align to 4 bytes (otherwise will be problematic when 24bit is used) */
|
|
|
|
snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4);
|
|
|
|
snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_playback_close - close callback for playback
|
|
|
|
*/
|
|
|
|
static int vx_pcm_playback_close(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
vx_core_t *chip = snd_pcm_substream_chip(subs);
|
|
|
|
vx_pipe_t *pipe;
|
|
|
|
|
|
|
|
if (! subs->runtime->private_data)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pipe = subs->runtime->private_data;
|
|
|
|
|
|
|
|
if (--pipe->references == 0) {
|
|
|
|
chip->playback_pipes[pipe->number] = NULL;
|
|
|
|
vx_free_pipe(chip, pipe);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_notify_end_of_buffer - send "end-of-buffer" notifier at the given pipe
|
|
|
|
* @pipe: the pipe to notify
|
|
|
|
*
|
|
|
|
* NB: call with a certain lock.
|
|
|
|
*/
|
|
|
|
static int vx_notify_end_of_buffer(vx_core_t *chip, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct vx_rmh rmh; /* use a temporary rmh here */
|
|
|
|
|
|
|
|
/* Toggle Dsp Host Interface into Message mode */
|
|
|
|
vx_send_rih_nolock(chip, IRQ_PAUSE_START_CONNECT);
|
|
|
|
vx_init_rmh(&rmh, CMD_NOTIFY_END_OF_BUFFER);
|
|
|
|
vx_set_stream_cmd_params(&rmh, 0, pipe->number);
|
|
|
|
err = vx_send_msg_nolock(chip, &rmh);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
/* Toggle Dsp Host Interface back to sound transfer mode */
|
|
|
|
vx_send_rih_nolock(chip, IRQ_PAUSE_START_CONNECT);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_playback_transfer_chunk - transfer a single chunk
|
|
|
|
* @subs: substream
|
|
|
|
* @pipe: the pipe to transfer
|
|
|
|
* @size: chunk size in bytes
|
|
|
|
*
|
|
|
|
* transfer a single buffer chunk. EOB notificaton is added after that.
|
|
|
|
* called from the interrupt handler, too.
|
|
|
|
*
|
|
|
|
* return 0 if ok.
|
|
|
|
*/
|
|
|
|
static int vx_pcm_playback_transfer_chunk(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe, int size)
|
|
|
|
{
|
|
|
|
int space, err = 0;
|
|
|
|
|
|
|
|
space = vx_query_hbuffer_size(chip, pipe);
|
|
|
|
if (space < 0) {
|
|
|
|
/* disconnect the host, SIZE_HBUF command always switches to the stream mode */
|
|
|
|
vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
|
|
|
|
snd_printd("error hbuffer\n");
|
|
|
|
return space;
|
|
|
|
}
|
|
|
|
if (space < size) {
|
|
|
|
vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
|
|
|
|
snd_printd("no enough hbuffer space %d\n", space);
|
|
|
|
return -EIO; /* XRUN */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we don't need irqsave here, because this function
|
|
|
|
* is called from either trigger callback or irq handler
|
|
|
|
*/
|
|
|
|
spin_lock(&chip->lock);
|
|
|
|
vx_pseudo_dma_write(chip, runtime, pipe, size);
|
|
|
|
err = vx_notify_end_of_buffer(chip, pipe);
|
|
|
|
/* disconnect the host, SIZE_HBUF command always switches to the stream mode */
|
|
|
|
vx_send_rih_nolock(chip, IRQ_CONNECT_STREAM_NEXT);
|
|
|
|
spin_unlock(&chip->lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* update the position of the given pipe.
|
|
|
|
* pipe->position is updated and wrapped within the buffer size.
|
|
|
|
* pipe->transferred is updated, too, but the size is not wrapped,
|
|
|
|
* so that the caller can check the total transferred size later
|
|
|
|
* (to call snd_pcm_period_elapsed).
|
|
|
|
*/
|
|
|
|
static int vx_update_pipe_position(vx_core_t *chip, snd_pcm_runtime_t *runtime, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
int err, update;
|
|
|
|
u64 count;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_STREAM_SAMPLE_COUNT);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
|
|
|
|
err = vx_send_msg(chip, &rmh);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
count = ((u64)(rmh.Stat[0] & 0xfffff) << 24) | (u64)rmh.Stat[1];
|
|
|
|
update = (int)(count - pipe->cur_count);
|
|
|
|
pipe->cur_count = count;
|
|
|
|
pipe->position += update;
|
|
|
|
if (pipe->position >= (int)runtime->buffer_size)
|
|
|
|
pipe->position %= runtime->buffer_size;
|
|
|
|
pipe->transferred += update;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* transfer the pending playback buffer data to DSP
|
|
|
|
* called from interrupt handler
|
|
|
|
*/
|
|
|
|
static void vx_pcm_playback_transfer(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe, int nchunks)
|
|
|
|
{
|
|
|
|
int i, err;
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
|
|
|
|
if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE))
|
|
|
|
return;
|
|
|
|
for (i = 0; i < nchunks; i++) {
|
|
|
|
if ((err = vx_pcm_playback_transfer_chunk(chip, runtime, pipe,
|
|
|
|
chip->ibl.size)) < 0)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* update the playback position and call snd_pcm_period_elapsed() if necessary
|
|
|
|
* called from interrupt handler
|
|
|
|
*/
|
|
|
|
static void vx_pcm_playback_update(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
|
|
|
|
if (pipe->running && ! (chip->chip_status & VX_STAT_IS_STALE)) {
|
|
|
|
if ((err = vx_update_pipe_position(chip, runtime, pipe)) < 0)
|
|
|
|
return;
|
|
|
|
if (pipe->transferred >= (int)runtime->period_size) {
|
|
|
|
pipe->transferred %= runtime->period_size;
|
|
|
|
snd_pcm_period_elapsed(subs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* start the stream and pipe.
|
|
|
|
* this function is called from tasklet, which is invoked by the trigger
|
|
|
|
* START callback.
|
|
|
|
*/
|
|
|
|
static void vx_pcm_delayed_start(unsigned long arg)
|
|
|
|
{
|
|
|
|
snd_pcm_substream_t *subs = (snd_pcm_substream_t *)arg;
|
|
|
|
vx_core_t *chip = subs->pcm->private_data;
|
|
|
|
vx_pipe_t *pipe = subs->runtime->private_data;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* printk( KERN_DEBUG "DDDD tasklet delayed start jiffies = %ld\n", jiffies);*/
|
|
|
|
|
|
|
|
if ((err = vx_start_stream(chip, pipe)) < 0) {
|
|
|
|
snd_printk(KERN_ERR "vx: cannot start stream\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if ((err = vx_toggle_pipe(chip, pipe, 1)) < 0) {
|
|
|
|
snd_printk(KERN_ERR "vx: cannot start pipe\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* printk( KERN_DEBUG "dddd tasklet delayed start jiffies = %ld \n", jiffies);*/
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_playback_trigger - trigger callback for playback
|
|
|
|
*/
|
|
|
|
static int vx_pcm_trigger(snd_pcm_substream_t *subs, int cmd)
|
|
|
|
{
|
|
|
|
vx_core_t *chip = snd_pcm_substream_chip(subs);
|
|
|
|
vx_pipe_t *pipe = subs->runtime->private_data;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (chip->chip_status & VX_STAT_IS_STALE)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case SNDRV_PCM_TRIGGER_START:
|
|
|
|
case SNDRV_PCM_TRIGGER_RESUME:
|
|
|
|
if (! pipe->is_capture)
|
|
|
|
vx_pcm_playback_transfer(chip, subs, pipe, 2);
|
|
|
|
/* FIXME:
|
|
|
|
* we trigger the pipe using tasklet, so that the interrupts are
|
|
|
|
* issued surely after the trigger is completed.
|
|
|
|
*/
|
|
|
|
tasklet_hi_schedule(&pipe->start_tq);
|
|
|
|
chip->pcm_running++;
|
|
|
|
pipe->running = 1;
|
|
|
|
break;
|
|
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
|
|
case SNDRV_PCM_TRIGGER_SUSPEND:
|
|
|
|
vx_toggle_pipe(chip, pipe, 0);
|
|
|
|
vx_stop_pipe(chip, pipe);
|
|
|
|
vx_stop_stream(chip, pipe);
|
|
|
|
chip->pcm_running--;
|
|
|
|
pipe->running = 0;
|
|
|
|
break;
|
|
|
|
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
|
|
|
|
if ((err = vx_toggle_pipe(chip, pipe, 0)) < 0)
|
|
|
|
return err;
|
|
|
|
break;
|
|
|
|
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
|
|
|
|
if ((err = vx_toggle_pipe(chip, pipe, 1)) < 0)
|
|
|
|
return err;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_playback_pointer - pointer callback for playback
|
|
|
|
*/
|
|
|
|
static snd_pcm_uframes_t vx_pcm_playback_pointer(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
vx_pipe_t *pipe = runtime->private_data;
|
|
|
|
return pipe->position;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_hw_params - hw_params callback for playback and capture
|
|
|
|
*/
|
|
|
|
static int vx_pcm_hw_params(snd_pcm_substream_t *subs,
|
|
|
|
snd_pcm_hw_params_t *hw_params)
|
|
|
|
{
|
|
|
|
return snd_pcm_alloc_vmalloc_buffer(subs, params_buffer_bytes(hw_params));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_hw_free - hw_free callback for playback and capture
|
|
|
|
*/
|
|
|
|
static int vx_pcm_hw_free(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
return snd_pcm_free_vmalloc_buffer(subs);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_prepare - prepare callback for playback and capture
|
|
|
|
*/
|
|
|
|
static int vx_pcm_prepare(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
vx_core_t *chip = snd_pcm_substream_chip(subs);
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
vx_pipe_t *pipe = runtime->private_data;
|
|
|
|
int err, data_mode;
|
|
|
|
// int max_size, nchunks;
|
|
|
|
|
|
|
|
if (chip->chip_status & VX_STAT_IS_STALE)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
data_mode = (chip->uer_bits & IEC958_AES0_NONAUDIO) != 0;
|
|
|
|
if (data_mode != pipe->data_mode && ! pipe->is_capture) {
|
|
|
|
/* IEC958 status (raw-mode) was changed */
|
|
|
|
/* we reopen the pipe */
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
snd_printdd(KERN_DEBUG "reopen the pipe with data_mode = %d\n", data_mode);
|
|
|
|
vx_init_rmh(&rmh, CMD_FREE_PIPE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, 0, pipe->number, 0);
|
|
|
|
if ((err = vx_send_msg(chip, &rmh)) < 0)
|
|
|
|
return err;
|
|
|
|
vx_init_rmh(&rmh, CMD_RES_PIPE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, 0, pipe->number, pipe->channels);
|
|
|
|
if (data_mode)
|
|
|
|
rmh.Cmd[0] |= BIT_DATA_MODE;
|
|
|
|
if ((err = vx_send_msg(chip, &rmh)) < 0)
|
|
|
|
return err;
|
|
|
|
pipe->data_mode = data_mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (chip->pcm_running && chip->freq != runtime->rate) {
|
|
|
|
snd_printk(KERN_ERR "vx: cannot set different clock %d from the current %d\n", runtime->rate, chip->freq);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
vx_set_clock(chip, runtime->rate);
|
|
|
|
|
|
|
|
if ((err = vx_set_format(chip, pipe, runtime)) < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (vx_is_pcmcia(chip)) {
|
|
|
|
pipe->align = 2; /* 16bit word */
|
|
|
|
} else {
|
|
|
|
pipe->align = 4; /* 32bit word */
|
|
|
|
}
|
|
|
|
|
|
|
|
pipe->buffer_bytes = frames_to_bytes(runtime, runtime->buffer_size);
|
|
|
|
pipe->period_bytes = frames_to_bytes(runtime, runtime->period_size);
|
|
|
|
pipe->hw_ptr = 0;
|
|
|
|
|
|
|
|
/* set the timestamp */
|
|
|
|
vx_update_pipe_position(chip, runtime, pipe);
|
|
|
|
/* clear again */
|
|
|
|
pipe->transferred = 0;
|
|
|
|
pipe->position = 0;
|
|
|
|
|
|
|
|
pipe->prepared = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* operators for PCM playback
|
|
|
|
*/
|
|
|
|
static snd_pcm_ops_t vx_pcm_playback_ops = {
|
|
|
|
.open = vx_pcm_playback_open,
|
|
|
|
.close = vx_pcm_playback_close,
|
|
|
|
.ioctl = snd_pcm_lib_ioctl,
|
|
|
|
.hw_params = vx_pcm_hw_params,
|
|
|
|
.hw_free = vx_pcm_hw_free,
|
|
|
|
.prepare = vx_pcm_prepare,
|
|
|
|
.trigger = vx_pcm_trigger,
|
|
|
|
.pointer = vx_pcm_playback_pointer,
|
|
|
|
.page = snd_pcm_get_vmalloc_page,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* playback hw information
|
|
|
|
*/
|
|
|
|
|
|
|
|
static snd_pcm_hardware_t vx_pcm_capture_hw = {
|
|
|
|
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
|
2005-08-18 13:43:12 +02:00
|
|
|
SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
|
|
|
|
/*SNDRV_PCM_INFO_RESUME*/),
|
2005-04-17 00:20:36 +02:00
|
|
|
.formats = /*SNDRV_PCM_FMTBIT_U8 |*/ SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE,
|
|
|
|
.rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
|
|
|
|
.rate_min = 5000,
|
|
|
|
.rate_max = 48000,
|
|
|
|
.channels_min = 1,
|
|
|
|
.channels_max = 2,
|
|
|
|
.buffer_bytes_max = (128*1024),
|
|
|
|
.period_bytes_min = 126,
|
|
|
|
.period_bytes_max = (128*1024),
|
|
|
|
.periods_min = 2,
|
|
|
|
.periods_max = VX_MAX_PERIODS,
|
|
|
|
.fifo_size = 126,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_capture_open - open callback for capture
|
|
|
|
*/
|
|
|
|
static int vx_pcm_capture_open(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
vx_core_t *chip = snd_pcm_substream_chip(subs);
|
|
|
|
vx_pipe_t *pipe;
|
|
|
|
vx_pipe_t *pipe_out_monitoring = NULL;
|
|
|
|
unsigned int audio;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (chip->chip_status & VX_STAT_IS_STALE)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
audio = subs->pcm->device * 2;
|
|
|
|
snd_assert(audio < chip->audio_ins, return -EINVAL);
|
|
|
|
err = vx_alloc_pipe(chip, 1, audio, 2, &pipe);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
pipe->substream = subs;
|
|
|
|
tasklet_init(&pipe->start_tq, vx_pcm_delayed_start, (unsigned long)subs);
|
|
|
|
chip->capture_pipes[audio] = pipe;
|
|
|
|
|
|
|
|
/* check if monitoring is needed */
|
|
|
|
if (chip->audio_monitor_active[audio]) {
|
|
|
|
pipe_out_monitoring = chip->playback_pipes[audio];
|
|
|
|
if (! pipe_out_monitoring) {
|
|
|
|
/* allocate a pipe */
|
|
|
|
err = vx_alloc_pipe(chip, 0, audio, 2, &pipe_out_monitoring);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
chip->playback_pipes[audio] = pipe_out_monitoring;
|
|
|
|
}
|
|
|
|
pipe_out_monitoring->references++;
|
|
|
|
/*
|
|
|
|
if an output pipe is available, it's audios still may need to be
|
|
|
|
unmuted. hence we'll have to call a mixer entry point.
|
|
|
|
*/
|
|
|
|
vx_set_monitor_level(chip, audio, chip->audio_monitor[audio], chip->audio_monitor_active[audio]);
|
|
|
|
/* assuming stereo */
|
|
|
|
vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1], chip->audio_monitor_active[audio+1]);
|
|
|
|
}
|
|
|
|
|
|
|
|
pipe->monitoring_pipe = pipe_out_monitoring; /* default value NULL */
|
|
|
|
|
|
|
|
runtime->hw = vx_pcm_capture_hw;
|
|
|
|
runtime->hw.period_bytes_min = chip->ibl.size;
|
|
|
|
runtime->private_data = pipe;
|
|
|
|
|
|
|
|
/* align to 4 bytes (otherwise will be problematic when 24bit is used) */
|
|
|
|
snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 4);
|
|
|
|
snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 4);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_capture_close - close callback for capture
|
|
|
|
*/
|
|
|
|
static int vx_pcm_capture_close(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
vx_core_t *chip = snd_pcm_substream_chip(subs);
|
|
|
|
vx_pipe_t *pipe;
|
|
|
|
vx_pipe_t *pipe_out_monitoring;
|
|
|
|
|
|
|
|
if (! subs->runtime->private_data)
|
|
|
|
return -EINVAL;
|
|
|
|
pipe = subs->runtime->private_data;
|
|
|
|
chip->capture_pipes[pipe->number] = NULL;
|
|
|
|
|
|
|
|
pipe_out_monitoring = pipe->monitoring_pipe;
|
|
|
|
|
|
|
|
/*
|
|
|
|
if an output pipe is attached to this input,
|
|
|
|
check if it needs to be released.
|
|
|
|
*/
|
|
|
|
if (pipe_out_monitoring) {
|
|
|
|
if (--pipe_out_monitoring->references == 0) {
|
|
|
|
vx_free_pipe(chip, pipe_out_monitoring);
|
|
|
|
chip->playback_pipes[pipe->number] = NULL;
|
|
|
|
pipe->monitoring_pipe = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vx_free_pipe(chip, pipe);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#define DMA_READ_ALIGN 6 /* hardware alignment for read */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_capture_update - update the capture buffer
|
|
|
|
*/
|
|
|
|
static void vx_pcm_capture_update(vx_core_t *chip, snd_pcm_substream_t *subs, vx_pipe_t *pipe)
|
|
|
|
{
|
|
|
|
int size, space, count;
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
|
|
|
|
if (! pipe->prepared || (chip->chip_status & VX_STAT_IS_STALE))
|
|
|
|
return;
|
|
|
|
|
|
|
|
size = runtime->buffer_size - snd_pcm_capture_avail(runtime);
|
|
|
|
if (! size)
|
|
|
|
return;
|
|
|
|
size = frames_to_bytes(runtime, size);
|
|
|
|
space = vx_query_hbuffer_size(chip, pipe);
|
|
|
|
if (space < 0)
|
|
|
|
goto _error;
|
|
|
|
if (size > space)
|
|
|
|
size = space;
|
|
|
|
size = (size / 3) * 3; /* align to 3 bytes */
|
|
|
|
if (size < DMA_READ_ALIGN)
|
|
|
|
goto _error;
|
|
|
|
|
|
|
|
/* keep the last 6 bytes, they will be read after disconnection */
|
|
|
|
count = size - DMA_READ_ALIGN;
|
|
|
|
/* read bytes until the current pointer reaches to the aligned position
|
|
|
|
* for word-transfer
|
|
|
|
*/
|
|
|
|
while (count > 0) {
|
|
|
|
if ((pipe->hw_ptr % pipe->align) == 0)
|
|
|
|
break;
|
|
|
|
if (vx_wait_for_rx_full(chip) < 0)
|
|
|
|
goto _error;
|
|
|
|
vx_pcm_read_per_bytes(chip, runtime, pipe);
|
|
|
|
count -= 3;
|
|
|
|
}
|
|
|
|
if (count > 0) {
|
|
|
|
/* ok, let's accelerate! */
|
|
|
|
int align = pipe->align * 3;
|
|
|
|
space = (count / align) * align;
|
|
|
|
vx_pseudo_dma_read(chip, runtime, pipe, space);
|
|
|
|
count -= space;
|
|
|
|
}
|
|
|
|
/* read the rest of bytes */
|
|
|
|
while (count > 0) {
|
|
|
|
if (vx_wait_for_rx_full(chip) < 0)
|
|
|
|
goto _error;
|
|
|
|
vx_pcm_read_per_bytes(chip, runtime, pipe);
|
|
|
|
count -= 3;
|
|
|
|
}
|
|
|
|
/* disconnect the host, SIZE_HBUF command always switches to the stream mode */
|
|
|
|
vx_send_rih_nolock(chip, IRQ_CONNECT_STREAM_NEXT);
|
|
|
|
/* read the last pending 6 bytes */
|
|
|
|
count = DMA_READ_ALIGN;
|
|
|
|
while (count > 0) {
|
|
|
|
vx_pcm_read_per_bytes(chip, runtime, pipe);
|
|
|
|
count -= 3;
|
|
|
|
}
|
|
|
|
/* update the position */
|
|
|
|
pipe->transferred += size;
|
|
|
|
if (pipe->transferred >= pipe->period_bytes) {
|
|
|
|
pipe->transferred %= pipe->period_bytes;
|
|
|
|
snd_pcm_period_elapsed(subs);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
_error:
|
|
|
|
/* disconnect the host, SIZE_HBUF command always switches to the stream mode */
|
|
|
|
vx_send_rih_nolock(chip, IRQ_CONNECT_STREAM_NEXT);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_capture_pointer - pointer callback for capture
|
|
|
|
*/
|
|
|
|
static snd_pcm_uframes_t vx_pcm_capture_pointer(snd_pcm_substream_t *subs)
|
|
|
|
{
|
|
|
|
snd_pcm_runtime_t *runtime = subs->runtime;
|
|
|
|
vx_pipe_t *pipe = runtime->private_data;
|
|
|
|
return bytes_to_frames(runtime, pipe->hw_ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* operators for PCM capture
|
|
|
|
*/
|
|
|
|
static snd_pcm_ops_t vx_pcm_capture_ops = {
|
|
|
|
.open = vx_pcm_capture_open,
|
|
|
|
.close = vx_pcm_capture_close,
|
|
|
|
.ioctl = snd_pcm_lib_ioctl,
|
|
|
|
.hw_params = vx_pcm_hw_params,
|
|
|
|
.hw_free = vx_pcm_hw_free,
|
|
|
|
.prepare = vx_pcm_prepare,
|
|
|
|
.trigger = vx_pcm_trigger,
|
|
|
|
.pointer = vx_pcm_capture_pointer,
|
|
|
|
.page = snd_pcm_get_vmalloc_page,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* interrupt handler for pcm streams
|
|
|
|
*/
|
|
|
|
void vx_pcm_update_intr(vx_core_t *chip, unsigned int events)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
vx_pipe_t *pipe;
|
|
|
|
|
|
|
|
#define EVENT_MASK (END_OF_BUFFER_EVENTS_PENDING|ASYNC_EVENTS_PENDING)
|
|
|
|
|
|
|
|
if (events & EVENT_MASK) {
|
|
|
|
vx_init_rmh(&chip->irq_rmh, CMD_ASYNC);
|
|
|
|
if (events & ASYNC_EVENTS_PENDING)
|
|
|
|
chip->irq_rmh.Cmd[0] |= 0x00000001; /* SEL_ASYNC_EVENTS */
|
|
|
|
if (events & END_OF_BUFFER_EVENTS_PENDING)
|
|
|
|
chip->irq_rmh.Cmd[0] |= 0x00000002; /* SEL_END_OF_BUF_EVENTS */
|
|
|
|
|
|
|
|
if (vx_send_msg(chip, &chip->irq_rmh) < 0) {
|
|
|
|
snd_printdd(KERN_ERR "msg send error!!\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
i = 1;
|
|
|
|
while (i < chip->irq_rmh.LgStat) {
|
|
|
|
int p, buf, capture, eob;
|
|
|
|
p = chip->irq_rmh.Stat[i] & MASK_FIRST_FIELD;
|
|
|
|
capture = (chip->irq_rmh.Stat[i] & 0x400000) ? 1 : 0;
|
|
|
|
eob = (chip->irq_rmh.Stat[i] & 0x800000) ? 1 : 0;
|
|
|
|
i++;
|
|
|
|
if (events & ASYNC_EVENTS_PENDING)
|
|
|
|
i++;
|
|
|
|
buf = 1; /* force to transfer */
|
|
|
|
if (events & END_OF_BUFFER_EVENTS_PENDING) {
|
|
|
|
if (eob)
|
|
|
|
buf = chip->irq_rmh.Stat[i];
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (capture)
|
|
|
|
continue;
|
|
|
|
snd_assert(p >= 0 && (unsigned int)p < chip->audio_outs,);
|
|
|
|
pipe = chip->playback_pipes[p];
|
|
|
|
if (pipe && pipe->substream) {
|
|
|
|
vx_pcm_playback_update(chip, pipe->substream, pipe);
|
|
|
|
vx_pcm_playback_transfer(chip, pipe->substream, pipe, buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update the capture pcm pointers as frequently as possible */
|
|
|
|
for (i = 0; i < chip->audio_ins; i++) {
|
|
|
|
pipe = chip->capture_pipes[i];
|
|
|
|
if (pipe && pipe->substream)
|
|
|
|
vx_pcm_capture_update(chip, pipe->substream, pipe);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_init_audio_io - check the availabe audio i/o and allocate pipe arrays
|
|
|
|
*/
|
|
|
|
static int vx_init_audio_io(vx_core_t *chip)
|
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
int preferred;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_SUPPORTED);
|
|
|
|
if (vx_send_msg(chip, &rmh) < 0) {
|
|
|
|
snd_printk(KERN_ERR "vx: cannot get the supported audio data\n");
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
chip->audio_outs = rmh.Stat[0] & MASK_FIRST_FIELD;
|
|
|
|
chip->audio_ins = (rmh.Stat[0] >> (FIELD_SIZE*2)) & MASK_FIRST_FIELD;
|
|
|
|
chip->audio_info = rmh.Stat[1];
|
|
|
|
|
|
|
|
/* allocate pipes */
|
|
|
|
chip->playback_pipes = kmalloc(sizeof(vx_pipe_t *) * chip->audio_outs, GFP_KERNEL);
|
|
|
|
chip->capture_pipes = kmalloc(sizeof(vx_pipe_t *) * chip->audio_ins, GFP_KERNEL);
|
|
|
|
if (! chip->playback_pipes || ! chip->capture_pipes)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
memset(chip->playback_pipes, 0, sizeof(vx_pipe_t *) * chip->audio_outs);
|
|
|
|
memset(chip->capture_pipes, 0, sizeof(vx_pipe_t *) * chip->audio_ins);
|
|
|
|
|
|
|
|
preferred = chip->ibl.size;
|
|
|
|
chip->ibl.size = 0;
|
|
|
|
vx_set_ibl(chip, &chip->ibl); /* query the info */
|
|
|
|
if (preferred > 0) {
|
|
|
|
chip->ibl.size = ((preferred + chip->ibl.granularity - 1) / chip->ibl.granularity) * chip->ibl.granularity;
|
|
|
|
if (chip->ibl.size > chip->ibl.max_size)
|
|
|
|
chip->ibl.size = chip->ibl.max_size;
|
|
|
|
} else
|
|
|
|
chip->ibl.size = chip->ibl.min_size; /* set to the minimum */
|
|
|
|
vx_set_ibl(chip, &chip->ibl);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* free callback for pcm
|
|
|
|
*/
|
|
|
|
static void snd_vx_pcm_free(snd_pcm_t *pcm)
|
|
|
|
{
|
|
|
|
vx_core_t *chip = pcm->private_data;
|
|
|
|
chip->pcm[pcm->device] = NULL;
|
[ALSA] Remove redundant NULL checks before kfree
Timer Midlevel,ALSA sequencer,ALSA<-OSS sequencer,Digigram VX core
I2C tea6330t,GUS Library,VIA82xx driver,VIA82xx-modem driver
CA0106 driver,CS46xx driver,EMU10K1/EMU10K2 driver,YMFPCI driver
Digigram VX Pocket driver,Common EMU synth,USB generic driver,USB USX2Y
Checking a pointer for NULL before calling kfree() on it is redundant,
kfree() deals with NULL pointers just fine.
This patch removes such checks from sound/
This patch also makes another, but closely related, change.
It avoids casting pointers about to be kfree()'ed.
Signed-off-by: Jesper Juhl <juhl-lkml@dif.dk>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-05-30 17:30:32 +02:00
|
|
|
kfree(chip->playback_pipes);
|
|
|
|
chip->playback_pipes = NULL;
|
|
|
|
kfree(chip->capture_pipes);
|
|
|
|
chip->capture_pipes = NULL;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* snd_vx_pcm_new - create and initialize a pcm
|
|
|
|
*/
|
|
|
|
int snd_vx_pcm_new(vx_core_t *chip)
|
|
|
|
{
|
|
|
|
snd_pcm_t *pcm;
|
|
|
|
unsigned int i;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if ((err = vx_init_audio_io(chip)) < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
for (i = 0; i < chip->hw->num_codecs; i++) {
|
|
|
|
unsigned int outs, ins;
|
|
|
|
outs = chip->audio_outs > i * 2 ? 1 : 0;
|
|
|
|
ins = chip->audio_ins > i * 2 ? 1 : 0;
|
|
|
|
if (! outs && ! ins)
|
|
|
|
break;
|
|
|
|
err = snd_pcm_new(chip->card, "VX PCM", i,
|
|
|
|
outs, ins, &pcm);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (outs)
|
|
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &vx_pcm_playback_ops);
|
|
|
|
if (ins)
|
|
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &vx_pcm_capture_ops);
|
|
|
|
|
|
|
|
pcm->private_data = chip;
|
|
|
|
pcm->private_free = snd_vx_pcm_free;
|
|
|
|
pcm->info_flags = 0;
|
|
|
|
strcpy(pcm->name, chip->card->shortname);
|
|
|
|
chip->pcm[i] = pcm;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|