2019-05-27 14:55:05 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Driver for Digigram VX soundcards
|
|
|
|
*
|
|
|
|
* PCM part
|
|
|
|
*
|
|
|
|
* Copyright (c) 2002,2003 by Takashi Iwai <tiwai@suse.de>
|
|
|
|
*
|
|
|
|
* 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 <linux/slab.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"
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* read three pending pcm bytes via inb()
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static void vx_pcm_read_per_bytes(struct vx_core *chip, struct snd_pcm_runtime *runtime,
|
|
|
|
struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static void vx_set_pcx_time(struct vx_core *chip, pcx_time_t *pc_time,
|
|
|
|
unsigned int *dsp_time)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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.
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_set_differed_time(struct vx_core *chip, struct vx_rmh *rmh,
|
|
|
|
struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
/* 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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_set_stream_format(struct vx_core *chip, struct vx_pipe *pipe,
|
|
|
|
unsigned int data)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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.
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_set_format(struct vx_core *chip, struct vx_pipe *pipe,
|
|
|
|
struct snd_pcm_runtime *runtime)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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;
|
2012-09-28 17:24:57 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return vx_set_stream_format(chip, pipe, header);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set / query the IBL size
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_set_ibl(struct vx_core *chip, struct vx_ibl_info *info)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_get_pipe_state(struct vx_core *chip, struct vx_pipe *pipe, int *state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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);
|
2014-09-09 23:17:20 +08:00
|
|
|
err = vx_send_msg(chip, &rmh);
|
2005-04-17 06:20:36 +08:00
|
|
|
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.
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_query_hbuffer_size(struct vx_core *chip, struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_pipe_can_start(struct vx_core *chip, struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2014-09-09 23:17:20 +08:00
|
|
|
err = vx_send_msg(chip, &rmh);
|
2005-04-17 06:20:36 +08:00
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_conf_pipe(struct vx_core *chip, struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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;
|
2014-09-09 23:17:20 +08:00
|
|
|
return vx_send_msg(chip, &rmh);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_send_irqa - trigger IRQA
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_send_irqa(struct vx_core *chip)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_SEND_IRQA);
|
2014-09-09 23:17:20 +08:00
|
|
|
return vx_send_msg(chip, &rmh);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#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
|
|
|
|
*
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_toggle_pipe(struct vx_core *chip, struct vx_pipe *pipe, int state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_stop_pipe(struct vx_core *chip, struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
vx_init_rmh(&rmh, CMD_STOP_PIPE);
|
|
|
|
vx_set_pipe_cmd_params(&rmh, pipe->is_capture, pipe->number, 0);
|
2014-09-09 23:17:20 +08:00
|
|
|
return vx_send_msg(chip, &rmh);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_alloc_pipe(struct vx_core *chip, int capture,
|
2005-04-17 06:20:36 +08:00
|
|
|
int audioid, int num_audio,
|
2005-11-17 21:46:59 +08:00
|
|
|
struct vx_pipe **pipep)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int err;
|
2005-11-17 21:46:59 +08:00
|
|
|
struct vx_pipe *pipe;
|
2005-04-17 06:20:36 +08:00
|
|
|
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 20:22:34 +08:00
|
|
|
pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
|
2005-04-17 06:20:36 +08: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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_free_pipe(struct vx_core *chip, struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_start_stream(struct vx_core *chip, struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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);
|
2014-09-09 23:17:20 +08:00
|
|
|
return vx_send_msg(chip, &rmh);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_stop_stream - stop the stream
|
|
|
|
*
|
|
|
|
* called from trigger callback only
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_stop_stream(struct vx_core *chip, struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct vx_rmh rmh;
|
|
|
|
|
|
|
|
vx_init_rmh(&rmh, CMD_STOP_STREAM);
|
|
|
|
vx_set_stream_cmd_params(&rmh, pipe->is_capture, pipe->number);
|
2014-09-09 23:17:20 +08:00
|
|
|
return vx_send_msg(chip, &rmh);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* playback hw information
|
|
|
|
*/
|
|
|
|
|
2017-08-17 17:15:51 +08:00
|
|
|
static const struct snd_pcm_hardware vx_pcm_playback_hw = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
|
2005-08-18 19:43:12 +08:00
|
|
|
SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
|
|
|
|
/*SNDRV_PCM_INFO_RESUME*/),
|
2005-11-17 21:46:59 +08:00
|
|
|
.formats = (/*SNDRV_PCM_FMTBIT_U8 |*/
|
|
|
|
SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE),
|
2005-04-17 06:20:36 +08:00
|
|
|
.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_playback_open - open callback for playback
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_pcm_playback_open(struct snd_pcm_substream *subs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct snd_pcm_runtime *runtime = subs->runtime;
|
|
|
|
struct vx_core *chip = snd_pcm_substream_chip(subs);
|
|
|
|
struct vx_pipe *pipe = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int audio;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (chip->chip_status & VX_STAT_IS_STALE)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
audio = subs->pcm->device * 2;
|
2008-08-08 23:12:47 +08:00
|
|
|
if (snd_BUG_ON(audio >= chip->audio_outs))
|
|
|
|
return -EINVAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_pcm_playback_close(struct snd_pcm_substream *subs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct vx_core *chip = snd_pcm_substream_chip(subs);
|
|
|
|
struct vx_pipe *pipe;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_notify_end_of_buffer(struct vx_core *chip, struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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.
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_pcm_playback_transfer_chunk(struct vx_core *chip,
|
|
|
|
struct snd_pcm_runtime *runtime,
|
|
|
|
struct vx_pipe *pipe, int size)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2014-09-09 23:17:20 +08:00
|
|
|
mutex_lock(&chip->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
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);
|
2014-09-09 23:17:20 +08:00
|
|
|
mutex_unlock(&chip->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
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).
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_update_pipe_position(struct vx_core *chip,
|
|
|
|
struct snd_pcm_runtime *runtime,
|
|
|
|
struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static void vx_pcm_playback_transfer(struct vx_core *chip,
|
|
|
|
struct snd_pcm_substream *subs,
|
|
|
|
struct vx_pipe *pipe, int nchunks)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i, err;
|
2005-11-17 21:46:59 +08:00
|
|
|
struct snd_pcm_runtime *runtime = subs->runtime;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static void vx_pcm_playback_update(struct vx_core *chip,
|
|
|
|
struct snd_pcm_substream *subs,
|
|
|
|
struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int err;
|
2005-11-17 21:46:59 +08:00
|
|
|
struct snd_pcm_runtime *runtime = subs->runtime;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_playback_trigger - trigger callback for playback
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_pcm_trigger(struct snd_pcm_substream *subs, int cmd)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct vx_core *chip = snd_pcm_substream_chip(subs);
|
|
|
|
struct vx_pipe *pipe = subs->runtime->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
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);
|
2014-09-09 23:17:20 +08:00
|
|
|
err = vx_start_stream(chip, pipe);
|
|
|
|
if (err < 0) {
|
|
|
|
pr_debug("vx: cannot start stream\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
err = vx_toggle_pipe(chip, pipe, 1);
|
|
|
|
if (err < 0) {
|
|
|
|
pr_debug("vx: cannot start pipe\n");
|
|
|
|
vx_stop_stream(chip, pipe);
|
|
|
|
return err;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static snd_pcm_uframes_t vx_pcm_playback_pointer(struct snd_pcm_substream *subs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct snd_pcm_runtime *runtime = subs->runtime;
|
|
|
|
struct vx_pipe *pipe = runtime->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
return pipe->position;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_prepare - prepare callback for playback and capture
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_pcm_prepare(struct snd_pcm_substream *subs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct vx_core *chip = snd_pcm_substream_chip(subs);
|
|
|
|
struct snd_pcm_runtime *runtime = subs->runtime;
|
|
|
|
struct vx_pipe *pipe = runtime->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
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) {
|
2005-11-17 21:46:59 +08:00
|
|
|
snd_printk(KERN_ERR "vx: cannot set different clock %d "
|
|
|
|
"from the current %d\n", runtime->rate, chip->freq);
|
2005-04-17 06:20:36 +08:00
|
|
|
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
|
|
|
|
*/
|
2017-06-09 15:05:43 +08:00
|
|
|
static const struct snd_pcm_ops vx_pcm_playback_ops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.open = vx_pcm_playback_open,
|
|
|
|
.close = vx_pcm_playback_close,
|
|
|
|
.prepare = vx_pcm_prepare,
|
|
|
|
.trigger = vx_pcm_trigger,
|
|
|
|
.pointer = vx_pcm_playback_pointer,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* playback hw information
|
|
|
|
*/
|
|
|
|
|
2017-08-17 17:15:51 +08:00
|
|
|
static const struct snd_pcm_hardware vx_pcm_capture_hw = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
|
2005-08-18 19:43:12 +08:00
|
|
|
SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
|
|
|
|
/*SNDRV_PCM_INFO_RESUME*/),
|
2005-11-17 21:46:59 +08:00
|
|
|
.formats = (/*SNDRV_PCM_FMTBIT_U8 |*/
|
|
|
|
SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_3LE),
|
2005-04-17 06:20:36 +08:00
|
|
|
.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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_pcm_capture_open(struct snd_pcm_substream *subs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct snd_pcm_runtime *runtime = subs->runtime;
|
|
|
|
struct vx_core *chip = snd_pcm_substream_chip(subs);
|
|
|
|
struct vx_pipe *pipe;
|
|
|
|
struct vx_pipe *pipe_out_monitoring = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int audio;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (chip->chip_status & VX_STAT_IS_STALE)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
audio = subs->pcm->device * 2;
|
2008-08-08 23:12:47 +08:00
|
|
|
if (snd_BUG_ON(audio >= chip->audio_ins))
|
|
|
|
return -EINVAL;
|
2005-04-17 06:20:36 +08:00
|
|
|
err = vx_alloc_pipe(chip, 1, audio, 2, &pipe);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
pipe->substream = 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.
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
vx_set_monitor_level(chip, audio, chip->audio_monitor[audio],
|
|
|
|
chip->audio_monitor_active[audio]);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* assuming stereo */
|
2005-11-17 21:46:59 +08:00
|
|
|
vx_set_monitor_level(chip, audio+1, chip->audio_monitor[audio+1],
|
|
|
|
chip->audio_monitor_active[audio+1]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_pcm_capture_close(struct snd_pcm_substream *subs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct vx_core *chip = snd_pcm_substream_chip(subs);
|
|
|
|
struct vx_pipe *pipe;
|
|
|
|
struct vx_pipe *pipe_out_monitoring;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static void vx_pcm_capture_update(struct vx_core *chip, struct snd_pcm_substream *subs,
|
|
|
|
struct vx_pipe *pipe)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int size, space, count;
|
2005-11-17 21:46:59 +08:00
|
|
|
struct snd_pcm_runtime *runtime = subs->runtime;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-01-04 19:34:14 +08:00
|
|
|
if (!pipe->running || (chip->chip_status & VX_STAT_IS_STALE))
|
2005-04-17 06:20:36 +08:00
|
|
|
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;
|
2017-01-04 19:19:15 +08:00
|
|
|
if (space > 0) {
|
|
|
|
vx_pseudo_dma_read(chip, runtime, pipe, space);
|
|
|
|
count -= space;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
/* 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 */
|
2014-09-09 23:17:20 +08:00
|
|
|
vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* 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 */
|
2014-09-09 23:17:20 +08:00
|
|
|
vx_send_rih(chip, IRQ_CONNECT_STREAM_NEXT);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* vx_pcm_capture_pointer - pointer callback for capture
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static snd_pcm_uframes_t vx_pcm_capture_pointer(struct snd_pcm_substream *subs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct snd_pcm_runtime *runtime = subs->runtime;
|
|
|
|
struct vx_pipe *pipe = runtime->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
return bytes_to_frames(runtime, pipe->hw_ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* operators for PCM capture
|
|
|
|
*/
|
2017-06-09 15:05:43 +08:00
|
|
|
static const struct snd_pcm_ops vx_pcm_capture_ops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.open = vx_pcm_capture_open,
|
|
|
|
.close = vx_pcm_capture_close,
|
|
|
|
.prepare = vx_pcm_prepare,
|
|
|
|
.trigger = vx_pcm_trigger,
|
|
|
|
.pointer = vx_pcm_capture_pointer,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* interrupt handler for pcm streams
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
void vx_pcm_update_intr(struct vx_core *chip, unsigned int events)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned int i;
|
2005-11-17 21:46:59 +08:00
|
|
|
struct vx_pipe *pipe;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#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;
|
2008-08-08 23:12:47 +08:00
|
|
|
if (snd_BUG_ON(p < 0 || p >= chip->audio_outs))
|
|
|
|
continue;
|
2005-04-17 06:20:36 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
2011-03-31 09:57:33 +08:00
|
|
|
* vx_init_audio_io - check the available audio i/o and allocate pipe arrays
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static int vx_init_audio_io(struct vx_core *chip)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
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 */
|
2006-07-25 21:28:03 +08:00
|
|
|
chip->playback_pipes = kcalloc(chip->audio_outs, sizeof(struct vx_pipe *), GFP_KERNEL);
|
2006-03-06 20:21:30 +08:00
|
|
|
if (!chip->playback_pipes)
|
|
|
|
return -ENOMEM;
|
2006-07-25 21:28:03 +08:00
|
|
|
chip->capture_pipes = kcalloc(chip->audio_ins, sizeof(struct vx_pipe *), GFP_KERNEL);
|
2006-03-06 20:21:30 +08:00
|
|
|
if (!chip->capture_pipes) {
|
|
|
|
kfree(chip->playback_pipes);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENOMEM;
|
2006-03-06 20:21:30 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
preferred = chip->ibl.size;
|
|
|
|
chip->ibl.size = 0;
|
|
|
|
vx_set_ibl(chip, &chip->ibl); /* query the info */
|
|
|
|
if (preferred > 0) {
|
2005-11-17 21:46:59 +08:00
|
|
|
chip->ibl.size = ((preferred + chip->ibl.granularity - 1) /
|
|
|
|
chip->ibl.granularity) * chip->ibl.granularity;
|
2005-04-17 06:20:36 +08:00
|
|
|
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
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
static void snd_vx_pcm_free(struct snd_pcm *pcm)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct vx_core *chip = pcm->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
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 23:30:32 +08:00
|
|
|
kfree(chip->playback_pipes);
|
|
|
|
chip->playback_pipes = NULL;
|
|
|
|
kfree(chip->capture_pipes);
|
|
|
|
chip->capture_pipes = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* snd_vx_pcm_new - create and initialize a pcm
|
|
|
|
*/
|
2005-11-17 21:46:59 +08:00
|
|
|
int snd_vx_pcm_new(struct vx_core *chip)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:46:59 +08:00
|
|
|
struct snd_pcm *pcm;
|
2005-04-17 06:20:36 +08:00
|
|
|
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);
|
2019-12-09 17:48:40 +08:00
|
|
|
snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC,
|
|
|
|
snd_dma_continuous_data(GFP_KERNEL | GFP_DMA32),
|
|
|
|
0, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
pcm->private_data = chip;
|
|
|
|
pcm->private_free = snd_vx_pcm_free;
|
|
|
|
pcm->info_flags = 0;
|
2014-09-09 23:17:20 +08:00
|
|
|
pcm->nonatomic = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
strcpy(pcm->name, chip->card->shortname);
|
|
|
|
chip->pcm[i] = pcm;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|