63e20df1e5
The current code deals with the stream start / stop solely via line6_pcm_acquire() and line6_pcm_release(). This was (supposedly) intended to avoid the races, but it doesn't work as expected. The concurrent acquire and release calls can be performed without proper protections, thus this might result in memory corruption. Furthermore, we can't take a mutex to protect the whole function because it can be called from the PCM trigger callback that is an atomic context. Also spinlock isn't appropriate because the function allocates with kmalloc with GFP_KERNEL. That is, these function just lead to singular problems. This is an attempt to reduce the existing races. First off, separate both the stream buffer management and the stream URB management. The former is protected via a newly introduced state_mutex while the latter is protected via each line6_pcm_stream lock. Secondly, the stream state are now managed in opened and running bit flags of each line6_pcm_stream. Not only this a bit clearer than previous combined bit flags, this also gives a better abstraction. These rewrites allows us to make common hw_params and hw_free callbacks for both playback and capture directions. For the monitor and impulse operations, still line6_pcm_acquire() and line6_pcm_release() are used. They call internally the corresponding functions for both playback and capture streams with proper lock or mutex. Unlike the previous versions, these function don't take the bit masks but the only single type value. Also they are supposed to be applied only as duplex operations. Tested-by: Chris Rorvick <chris@rorvick.com> Signed-off-by: Takashi Iwai <tiwai@suse.de>
573 lines
14 KiB
C
573 lines
14 KiB
C
/*
|
|
* Line 6 Linux USB driver
|
|
*
|
|
* Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
|
|
*
|
|
* 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, version 2.
|
|
*
|
|
*/
|
|
|
|
#include <linux/slab.h>
|
|
#include <linux/export.h>
|
|
#include <sound/core.h>
|
|
#include <sound/control.h>
|
|
#include <sound/pcm.h>
|
|
#include <sound/pcm_params.h>
|
|
|
|
#include "capture.h"
|
|
#include "driver.h"
|
|
#include "playback.h"
|
|
|
|
/* impulse response volume controls */
|
|
static int snd_line6_impulse_volume_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 1;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = 255;
|
|
return 0;
|
|
}
|
|
|
|
static int snd_line6_impulse_volume_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
|
|
|
|
ucontrol->value.integer.value[0] = line6pcm->impulse_volume;
|
|
return 0;
|
|
}
|
|
|
|
static int snd_line6_impulse_volume_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
|
|
int value = ucontrol->value.integer.value[0];
|
|
|
|
if (line6pcm->impulse_volume == value)
|
|
return 0;
|
|
|
|
line6pcm->impulse_volume = value;
|
|
if (value > 0)
|
|
line6_pcm_acquire(line6pcm, LINE6_STREAM_IMPULSE);
|
|
else
|
|
line6_pcm_release(line6pcm, LINE6_STREAM_IMPULSE);
|
|
return 1;
|
|
}
|
|
|
|
/* impulse response period controls */
|
|
static int snd_line6_impulse_period_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 1;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = 2000;
|
|
return 0;
|
|
}
|
|
|
|
static int snd_line6_impulse_period_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
|
|
|
|
ucontrol->value.integer.value[0] = line6pcm->impulse_period;
|
|
return 0;
|
|
}
|
|
|
|
static int snd_line6_impulse_period_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
|
|
int value = ucontrol->value.integer.value[0];
|
|
|
|
if (line6pcm->impulse_period == value)
|
|
return 0;
|
|
|
|
line6pcm->impulse_period = value;
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
Unlink all currently active URBs.
|
|
*/
|
|
static void line6_unlink_audio_urbs(struct snd_line6_pcm *line6pcm,
|
|
struct line6_pcm_stream *pcms)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < LINE6_ISO_BUFFERS; i++) {
|
|
if (test_bit(i, &pcms->active_urbs)) {
|
|
if (!test_and_set_bit(i, &pcms->unlink_urbs))
|
|
usb_unlink_urb(pcms->urbs[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
Wait until unlinking of all currently active URBs has been finished.
|
|
*/
|
|
static void line6_wait_clear_audio_urbs(struct snd_line6_pcm *line6pcm,
|
|
struct line6_pcm_stream *pcms)
|
|
{
|
|
int timeout = HZ;
|
|
int i;
|
|
int alive;
|
|
|
|
do {
|
|
alive = 0;
|
|
for (i = 0; i < LINE6_ISO_BUFFERS; i++) {
|
|
if (test_bit(i, &pcms->active_urbs))
|
|
alive++;
|
|
}
|
|
if (!alive)
|
|
break;
|
|
set_current_state(TASK_UNINTERRUPTIBLE);
|
|
schedule_timeout(1);
|
|
} while (--timeout > 0);
|
|
if (alive)
|
|
dev_err(line6pcm->line6->ifcdev,
|
|
"timeout: still %d active urbs..\n", alive);
|
|
}
|
|
|
|
static inline struct line6_pcm_stream *
|
|
get_stream(struct snd_line6_pcm *line6pcm, int direction)
|
|
{
|
|
return (direction == SNDRV_PCM_STREAM_PLAYBACK) ?
|
|
&line6pcm->out : &line6pcm->in;
|
|
}
|
|
|
|
/* allocate a buffer if not opened yet;
|
|
* call this in line6pcm.state_change mutex
|
|
*/
|
|
static int line6_buffer_acquire(struct snd_line6_pcm *line6pcm,
|
|
struct line6_pcm_stream *pstr, int type)
|
|
{
|
|
/* Invoked multiple times in a row so allocate once only */
|
|
if (!test_and_set_bit(type, &pstr->opened) && !pstr->buffer) {
|
|
pstr->buffer = kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS *
|
|
line6pcm->max_packet_size, GFP_KERNEL);
|
|
if (!pstr->buffer)
|
|
return -ENOMEM;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* free a buffer if all streams are closed;
|
|
* call this in line6pcm.state_change mutex
|
|
*/
|
|
static void line6_buffer_release(struct snd_line6_pcm *line6pcm,
|
|
struct line6_pcm_stream *pstr, int type)
|
|
{
|
|
|
|
clear_bit(type, &pstr->opened);
|
|
if (!pstr->opened) {
|
|
line6_wait_clear_audio_urbs(line6pcm, pstr);
|
|
kfree(pstr->buffer);
|
|
pstr->buffer = NULL;
|
|
}
|
|
}
|
|
|
|
/* start a PCM stream */
|
|
static int line6_stream_start(struct snd_line6_pcm *line6pcm, int direction,
|
|
int type)
|
|
{
|
|
unsigned long flags;
|
|
struct line6_pcm_stream *pstr = get_stream(line6pcm, direction);
|
|
int ret = 0;
|
|
|
|
spin_lock_irqsave(&pstr->lock, flags);
|
|
if (!test_and_set_bit(type, &pstr->running)) {
|
|
if (pstr->active_urbs || pstr->unlink_urbs) {
|
|
ret = -EBUSY;
|
|
goto error;
|
|
}
|
|
|
|
pstr->count = 0;
|
|
/* Submit all currently available URBs */
|
|
if (direction == SNDRV_PCM_STREAM_PLAYBACK)
|
|
ret = line6_submit_audio_out_all_urbs(line6pcm);
|
|
else
|
|
ret = line6_submit_audio_in_all_urbs(line6pcm);
|
|
}
|
|
error:
|
|
if (ret < 0)
|
|
clear_bit(type, &pstr->running);
|
|
spin_unlock_irqrestore(&pstr->lock, flags);
|
|
return ret;
|
|
}
|
|
|
|
/* stop a PCM stream; this doesn't sync with the unlinked URBs */
|
|
static void line6_stream_stop(struct snd_line6_pcm *line6pcm, int direction,
|
|
int type)
|
|
{
|
|
unsigned long flags;
|
|
struct line6_pcm_stream *pstr = get_stream(line6pcm, direction);
|
|
|
|
spin_lock_irqsave(&pstr->lock, flags);
|
|
clear_bit(type, &pstr->running);
|
|
if (!pstr->running) {
|
|
line6_unlink_audio_urbs(line6pcm, pstr);
|
|
if (direction == SNDRV_PCM_STREAM_CAPTURE) {
|
|
line6pcm->prev_fbuf = NULL;
|
|
line6pcm->prev_fsize = 0;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&pstr->lock, flags);
|
|
}
|
|
|
|
/* common PCM trigger callback */
|
|
int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd)
|
|
{
|
|
struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
|
|
struct snd_pcm_substream *s;
|
|
int err;
|
|
|
|
clear_bit(LINE6_FLAG_PREPARED, &line6pcm->flags);
|
|
|
|
snd_pcm_group_for_each_entry(s, substream) {
|
|
if (s->pcm->card != substream->pcm->card)
|
|
continue;
|
|
|
|
switch (cmd) {
|
|
case SNDRV_PCM_TRIGGER_START:
|
|
case SNDRV_PCM_TRIGGER_RESUME:
|
|
err = line6_stream_start(line6pcm, s->stream,
|
|
LINE6_STREAM_PCM);
|
|
if (err < 0)
|
|
return err;
|
|
break;
|
|
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
case SNDRV_PCM_TRIGGER_SUSPEND:
|
|
line6_stream_stop(line6pcm, s->stream,
|
|
LINE6_STREAM_PCM);
|
|
break;
|
|
|
|
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
|
|
if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
|
|
return -EINVAL;
|
|
set_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags);
|
|
break;
|
|
|
|
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
|
|
if (s->stream != SNDRV_PCM_STREAM_PLAYBACK)
|
|
return -EINVAL;
|
|
clear_bit(LINE6_FLAG_PAUSE_PLAYBACK, &line6pcm->flags);
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Acquire and start duplex streams:
|
|
* type is either LINE6_STREAM_IMPULSE or LINE6_STREAM_MONITOR
|
|
*/
|
|
int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int type)
|
|
{
|
|
struct line6_pcm_stream *pstr;
|
|
int ret = 0, dir;
|
|
|
|
mutex_lock(&line6pcm->state_mutex);
|
|
for (dir = 0; dir < 2; dir++) {
|
|
pstr = get_stream(line6pcm, dir);
|
|
ret = line6_buffer_acquire(line6pcm, pstr, type);
|
|
if (ret < 0)
|
|
goto error;
|
|
if (!pstr->running)
|
|
line6_wait_clear_audio_urbs(line6pcm, pstr);
|
|
}
|
|
for (dir = 0; dir < 2; dir++) {
|
|
ret = line6_stream_start(line6pcm, dir, type);
|
|
if (ret < 0)
|
|
goto error;
|
|
}
|
|
error:
|
|
mutex_unlock(&line6pcm->state_mutex);
|
|
if (ret < 0)
|
|
line6_pcm_release(line6pcm, type);
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(line6_pcm_acquire);
|
|
|
|
/* Stop and release duplex streams */
|
|
void line6_pcm_release(struct snd_line6_pcm *line6pcm, int type)
|
|
{
|
|
struct line6_pcm_stream *pstr;
|
|
int dir;
|
|
|
|
mutex_lock(&line6pcm->state_mutex);
|
|
for (dir = 0; dir < 2; dir++)
|
|
line6_stream_stop(line6pcm, dir, type);
|
|
for (dir = 0; dir < 2; dir++) {
|
|
pstr = get_stream(line6pcm, dir);
|
|
line6_buffer_release(line6pcm, pstr, type);
|
|
}
|
|
mutex_unlock(&line6pcm->state_mutex);
|
|
}
|
|
EXPORT_SYMBOL_GPL(line6_pcm_release);
|
|
|
|
/* common PCM hw_params callback */
|
|
int snd_line6_hw_params(struct snd_pcm_substream *substream,
|
|
struct snd_pcm_hw_params *hw_params)
|
|
{
|
|
int ret;
|
|
struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
|
|
struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream);
|
|
|
|
mutex_lock(&line6pcm->state_mutex);
|
|
ret = line6_buffer_acquire(line6pcm, pstr, LINE6_STREAM_PCM);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
ret = snd_pcm_lib_malloc_pages(substream,
|
|
params_buffer_bytes(hw_params));
|
|
if (ret < 0) {
|
|
line6_buffer_release(line6pcm, pstr, LINE6_STREAM_PCM);
|
|
goto error;
|
|
}
|
|
|
|
pstr->period = params_period_bytes(hw_params);
|
|
error:
|
|
mutex_unlock(&line6pcm->state_mutex);
|
|
return ret;
|
|
}
|
|
|
|
/* common PCM hw_free callback */
|
|
int snd_line6_hw_free(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
|
|
struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream);
|
|
|
|
mutex_lock(&line6pcm->state_mutex);
|
|
line6_buffer_release(line6pcm, pstr, LINE6_STREAM_PCM);
|
|
mutex_unlock(&line6pcm->state_mutex);
|
|
return snd_pcm_lib_free_pages(substream);
|
|
}
|
|
|
|
|
|
/* control info callback */
|
|
static int snd_line6_control_playback_info(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = 2;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = 256;
|
|
return 0;
|
|
}
|
|
|
|
/* control get callback */
|
|
static int snd_line6_control_playback_get(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
int i;
|
|
struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
|
|
|
|
for (i = 0; i < 2; i++)
|
|
ucontrol->value.integer.value[i] = line6pcm->volume_playback[i];
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* control put callback */
|
|
static int snd_line6_control_playback_put(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
int i, changed = 0;
|
|
struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
|
|
|
|
for (i = 0; i < 2; i++)
|
|
if (line6pcm->volume_playback[i] !=
|
|
ucontrol->value.integer.value[i]) {
|
|
line6pcm->volume_playback[i] =
|
|
ucontrol->value.integer.value[i];
|
|
changed = 1;
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
/* control definition */
|
|
static struct snd_kcontrol_new line6_controls[] = {
|
|
{
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "PCM Playback Volume",
|
|
.info = snd_line6_control_playback_info,
|
|
.get = snd_line6_control_playback_get,
|
|
.put = snd_line6_control_playback_put
|
|
},
|
|
{
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Impulse Response Volume",
|
|
.info = snd_line6_impulse_volume_info,
|
|
.get = snd_line6_impulse_volume_get,
|
|
.put = snd_line6_impulse_volume_put
|
|
},
|
|
{
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "Impulse Response Period",
|
|
.info = snd_line6_impulse_period_info,
|
|
.get = snd_line6_impulse_period_get,
|
|
.put = snd_line6_impulse_period_put
|
|
},
|
|
};
|
|
|
|
/*
|
|
Cleanup the PCM device.
|
|
*/
|
|
static void cleanup_urbs(struct line6_pcm_stream *pcms)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < LINE6_ISO_BUFFERS; i++) {
|
|
if (pcms->urbs[i]) {
|
|
usb_kill_urb(pcms->urbs[i]);
|
|
usb_free_urb(pcms->urbs[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void line6_cleanup_pcm(struct snd_pcm *pcm)
|
|
{
|
|
struct snd_line6_pcm *line6pcm = snd_pcm_chip(pcm);
|
|
|
|
cleanup_urbs(&line6pcm->out);
|
|
cleanup_urbs(&line6pcm->in);
|
|
kfree(line6pcm);
|
|
}
|
|
|
|
/* create a PCM device */
|
|
static int snd_line6_new_pcm(struct usb_line6 *line6, struct snd_pcm **pcm_ret)
|
|
{
|
|
struct snd_pcm *pcm;
|
|
int err;
|
|
|
|
err = snd_pcm_new(line6->card, (char *)line6->properties->name,
|
|
0, 1, 1, pcm_ret);
|
|
if (err < 0)
|
|
return err;
|
|
pcm = *pcm_ret;
|
|
strcpy(pcm->name, line6->properties->name);
|
|
|
|
/* set operators */
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
|
|
&snd_line6_playback_ops);
|
|
snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_line6_capture_ops);
|
|
|
|
/* pre-allocation of buffers */
|
|
snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
|
|
snd_dma_continuous_data
|
|
(GFP_KERNEL), 64 * 1024,
|
|
128 * 1024);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
Sync with PCM stream stops.
|
|
*/
|
|
void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm)
|
|
{
|
|
line6_unlink_audio_urbs(line6pcm, &line6pcm->out);
|
|
line6_unlink_audio_urbs(line6pcm, &line6pcm->in);
|
|
line6_wait_clear_audio_urbs(line6pcm, &line6pcm->out);
|
|
line6_wait_clear_audio_urbs(line6pcm, &line6pcm->in);
|
|
}
|
|
|
|
/*
|
|
Create and register the PCM device and mixer entries.
|
|
Create URBs for playback and capture.
|
|
*/
|
|
int line6_init_pcm(struct usb_line6 *line6,
|
|
struct line6_pcm_properties *properties)
|
|
{
|
|
int i, err;
|
|
unsigned ep_read = line6->properties->ep_audio_r;
|
|
unsigned ep_write = line6->properties->ep_audio_w;
|
|
struct snd_pcm *pcm;
|
|
struct snd_line6_pcm *line6pcm;
|
|
|
|
if (!(line6->properties->capabilities & LINE6_CAP_PCM))
|
|
return 0; /* skip PCM initialization and report success */
|
|
|
|
err = snd_line6_new_pcm(line6, &pcm);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
line6pcm = kzalloc(sizeof(*line6pcm), GFP_KERNEL);
|
|
if (!line6pcm)
|
|
return -ENOMEM;
|
|
|
|
mutex_init(&line6pcm->state_mutex);
|
|
line6pcm->pcm = pcm;
|
|
line6pcm->properties = properties;
|
|
line6pcm->volume_playback[0] = line6pcm->volume_playback[1] = 255;
|
|
line6pcm->volume_monitor = 255;
|
|
line6pcm->line6 = line6;
|
|
|
|
/* Read and write buffers are sized identically, so choose minimum */
|
|
line6pcm->max_packet_size = min(
|
|
usb_maxpacket(line6->usbdev,
|
|
usb_rcvisocpipe(line6->usbdev, ep_read), 0),
|
|
usb_maxpacket(line6->usbdev,
|
|
usb_sndisocpipe(line6->usbdev, ep_write), 1));
|
|
|
|
spin_lock_init(&line6pcm->out.lock);
|
|
spin_lock_init(&line6pcm->in.lock);
|
|
line6pcm->impulse_period = LINE6_IMPULSE_DEFAULT_PERIOD;
|
|
|
|
line6->line6pcm = line6pcm;
|
|
|
|
pcm->private_data = line6pcm;
|
|
pcm->private_free = line6_cleanup_pcm;
|
|
|
|
err = line6_create_audio_out_urbs(line6pcm);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = line6_create_audio_in_urbs(line6pcm);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* mixer: */
|
|
for (i = 0; i < ARRAY_SIZE(line6_controls); i++) {
|
|
err = snd_ctl_add(line6->card,
|
|
snd_ctl_new1(&line6_controls[i], line6pcm));
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(line6_init_pcm);
|
|
|
|
/* prepare pcm callback */
|
|
int snd_line6_prepare(struct snd_pcm_substream *substream)
|
|
{
|
|
struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
|
|
struct line6_pcm_stream *pstr = get_stream(line6pcm, substream->stream);
|
|
|
|
mutex_lock(&line6pcm->state_mutex);
|
|
if (!pstr->running)
|
|
line6_wait_clear_audio_urbs(line6pcm, pstr);
|
|
|
|
if (!test_and_set_bit(LINE6_FLAG_PREPARED, &line6pcm->flags)) {
|
|
line6pcm->out.count = 0;
|
|
line6pcm->out.pos = 0;
|
|
line6pcm->out.pos_done = 0;
|
|
line6pcm->out.bytes = 0;
|
|
line6pcm->in.count = 0;
|
|
line6pcm->in.pos_done = 0;
|
|
line6pcm->in.bytes = 0;
|
|
}
|
|
|
|
mutex_unlock(&line6pcm->state_mutex);
|
|
return 0;
|
|
}
|