--- /dev/null
+/*
+ * 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 <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()
+ */
+static void vx_pcm_read_per_bytes(struct vx_core *chip, struct snd_pcm_runtime *runtime,
+ struct vx_pipe *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(struct vx_core *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(struct vx_core *chip, struct vx_rmh *rmh,
+ struct vx_pipe *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(struct vx_core *chip, struct vx_pipe *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(struct vx_core *chip, struct vx_pipe *pipe,
+ struct snd_pcm_runtime *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(struct vx_core *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(struct vx_core *chip, struct vx_pipe *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(chip, &rmh);
+ 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(struct vx_core *chip, struct vx_pipe *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(struct vx_core *chip, struct vx_pipe *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(chip, &rmh);
+ 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(struct vx_core *chip, struct vx_pipe *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(chip, &rmh);
+}
+
+/*
+ * vx_send_irqa - trigger IRQA
+ */
+static int vx_send_irqa(struct vx_core *chip)
+{
+ struct vx_rmh rmh;
+
+ vx_init_rmh(&rmh, CMD_SEND_IRQA);
+ return vx_send_msg(chip, &rmh);
+}
+
+
+#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(struct vx_core *chip, struct vx_pipe *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(struct vx_core *chip, struct vx_pipe *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(chip, &rmh);
+}
+
+
+/*
+ * 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(struct vx_core *chip, int capture,
+ int audioid, int num_audio,
+ struct vx_pipe **pipep)
+{
+ int err;
+ struct vx_pipe *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 */
+ pipe = kzalloc(sizeof(*pipe), GFP_KERNEL);
+ 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(struct vx_core *chip, struct vx_pipe *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(struct vx_core *chip, struct vx_pipe *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(chip, &rmh);
+}
+
+
+/*
+ * vx_stop_stream - stop the stream
+ *
+ * called from trigger callback only
+ */
+static int vx_stop_stream(struct vx_core *chip, struct vx_pipe *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(chip, &rmh);
+}
+
+
+/*
+ * playback hw information
+ */
+
+static struct snd_pcm_hardware vx_pcm_playback_hw = {
+ .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
+ SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
+ /*SNDRV_PCM_INFO_RESUME*/),
+ .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_playback_open - open callback for playback
+ */
+static int vx_pcm_playback_open(struct snd_pcm_substream *subs)
+{
+ struct snd_pcm_runtime *runtime = subs->runtime;
+ struct vx_core *chip = snd_pcm_substream_chip(subs);
+ struct vx_pipe *pipe = NULL;
+ unsigned int audio;
+ int err;
+
+ if (chip->chip_status & VX_STAT_IS_STALE)
+ return -EBUSY;
+
+ audio = subs->pcm->device * 2;
+ if (snd_BUG_ON(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;
+ 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(struct snd_pcm_substream *subs)
+{
+ struct vx_core *chip = snd_pcm_substream_chip(subs);
+ struct vx_pipe *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(struct vx_core *chip, struct vx_pipe *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(struct vx_core *chip,
+ struct snd_pcm_runtime *runtime,
+ struct vx_pipe *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
+ */
+ mutex_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);
+ mutex_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(struct vx_core *chip,
+ struct snd_pcm_runtime *runtime,
+ struct vx_pipe *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(struct vx_core *chip,
+ struct snd_pcm_substream *subs,
+ struct vx_pipe *pipe, int nchunks)
+{
+ int i, err;
+ struct snd_pcm_runtime *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(struct vx_core *chip,
+ struct snd_pcm_substream *subs,
+ struct vx_pipe *pipe)
+{
+ int err;
+ struct snd_pcm_runtime *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);
+ }
+ }
+}
+
+/*
+ * vx_pcm_playback_trigger - trigger callback for playback
+ */
+static int vx_pcm_trigger(struct snd_pcm_substream *subs, int cmd)
+{
+ struct vx_core *chip = snd_pcm_substream_chip(subs);
+ struct vx_pipe *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);
+ 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;
+ }
+ 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(struct snd_pcm_substream *subs)
+{
+ struct snd_pcm_runtime *runtime = subs->runtime;
+ struct vx_pipe *pipe = runtime->private_data;
+ return pipe->position;
+}
+
+/*
+ * vx_pcm_hw_params - hw_params callback for playback and capture
+ */
+static int vx_pcm_hw_params(struct snd_pcm_substream *subs,
+ struct snd_pcm_hw_params *hw_params)
+{
+ return snd_pcm_lib_alloc_vmalloc_32_buffer
+ (subs, params_buffer_bytes(hw_params));
+}
+
+/*
+ * vx_pcm_hw_free - hw_free callback for playback and capture
+ */
+static int vx_pcm_hw_free(struct snd_pcm_substream *subs)
+{
+ return snd_pcm_lib_free_vmalloc_buffer(subs);
+}
+
+/*
+ * vx_pcm_prepare - prepare callback for playback and capture
+ */
+static int vx_pcm_prepare(struct snd_pcm_substream *subs)
+{
+ struct vx_core *chip = snd_pcm_substream_chip(subs);
+ struct snd_pcm_runtime *runtime = subs->runtime;
+ struct vx_pipe *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 struct snd_pcm_ops 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_lib_get_vmalloc_page,
+ .mmap = snd_pcm_lib_mmap_vmalloc,
+};
+
+
+/*
+ * playback hw information
+ */
+
+static struct snd_pcm_hardware vx_pcm_capture_hw = {
+ .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
+ SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP_VALID /*|*/
+ /*SNDRV_PCM_INFO_RESUME*/),
+ .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(struct snd_pcm_substream *subs)
+{
+ 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;
+ unsigned int audio;
+ int err;
+
+ if (chip->chip_status & VX_STAT_IS_STALE)
+ return -EBUSY;
+
+ audio = subs->pcm->device * 2;
+ if (snd_BUG_ON(audio >= chip->audio_ins))
+ return -EINVAL;
+ 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.
+ */
+ 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(struct snd_pcm_substream *subs)
+{
+ struct vx_core *chip = snd_pcm_substream_chip(subs);
+ struct vx_pipe *pipe;
+ struct vx_pipe *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(struct vx_core *chip, struct snd_pcm_substream *subs,
+ struct vx_pipe *pipe)
+{
+ int size, space, count;
+ struct snd_pcm_runtime *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(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(chip, IRQ_CONNECT_STREAM_NEXT);
+ return;
+}
+
+/*
+ * vx_pcm_capture_pointer - pointer callback for capture
+ */
+static snd_pcm_uframes_t vx_pcm_capture_pointer(struct snd_pcm_substream *subs)
+{
+ struct snd_pcm_runtime *runtime = subs->runtime;
+ struct vx_pipe *pipe = runtime->private_data;
+ return bytes_to_frames(runtime, pipe->hw_ptr);
+}
+
+/*
+ * operators for PCM capture
+ */
+static struct snd_pcm_ops 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_lib_get_vmalloc_page,
+ .mmap = snd_pcm_lib_mmap_vmalloc,
+};
+
+
+/*
+ * interrupt handler for pcm streams
+ */
+void vx_pcm_update_intr(struct vx_core *chip, unsigned int events)
+{
+ unsigned int i;
+ struct vx_pipe *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;
+ if (snd_BUG_ON(p < 0 || p >= chip->audio_outs))
+ continue;
+ 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 available audio i/o and allocate pipe arrays
+ */
+static int vx_init_audio_io(struct vx_core *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 = kcalloc(chip->audio_outs, sizeof(struct vx_pipe *), GFP_KERNEL);
+ if (!chip->playback_pipes)
+ return -ENOMEM;
+ chip->capture_pipes = kcalloc(chip->audio_ins, sizeof(struct vx_pipe *), GFP_KERNEL);
+ if (!chip->capture_pipes) {
+ kfree(chip->playback_pipes);
+ return -ENOMEM;
+ }
+
+ 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(struct snd_pcm *pcm)
+{
+ struct vx_core *chip = pcm->private_data;
+ chip->pcm[pcm->device] = NULL;
+ kfree(chip->playback_pipes);
+ chip->playback_pipes = NULL;
+ kfree(chip->capture_pipes);
+ chip->capture_pipes = NULL;
+}
+
+/*
+ * snd_vx_pcm_new - create and initialize a pcm
+ */
+int snd_vx_pcm_new(struct vx_core *chip)
+{
+ struct snd_pcm *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;
+ pcm->nonatomic = true;
+ strcpy(pcm->name, chip->card->shortname);
+ chip->pcm[i] = pcm;
+ }
+
+ return 0;
+}
Code Review / kvmfornfv.git / blobdiff