lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f307ab6dce
linux-kernel-test/sound/firewire/tascam/tascam-stream.c
Takashi Sakamoto 28e64f5176 ALSA: firewire-tascam: drop reuse of incoming packet parameter for outgoing packet parameter 
In packet streaming protocol applied to TASCAM FireWire series, the value
of SYT field in CIP header is always zero, therefore it has no meaning.
There's no need to synchronize packets in both direction for the series.

In current implementation of ALSA firewire stack, driver for the series
uses incoming packet parameter for outgoing packet parameter to calculate
the number of data blocks. This can be simplified because the task of
corresponding driver is to transfer data blocks enough to sampling transfer
frequency.

This commit purges support of full duplex synchronization to prevent
over-engineering implementation.

Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2016-05-10 17:03:59 +02:00

495 lines
11 KiB
C
Raw Blame History

/*
* tascam-stream.c - a part of driver for TASCAM FireWire series
*
* Copyright (c) 2015 Takashi Sakamoto
*
* Licensed under the terms of the GNU General Public License, version 2.
*/
#include <linux/delay.h>
#include "tascam.h"
#define CALLBACK_TIMEOUT 500
static int get_clock(struct snd_tscm *tscm, u32 *data)
{
__be32 reg;
int err;
err = snd_fw_transaction(tscm->unit, TCODE_READ_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
&reg, sizeof(reg), 0);
if (err >= 0)
*data = be32_to_cpu(reg);
return err;
}
static int set_clock(struct snd_tscm *tscm, unsigned int rate,
enum snd_tscm_clock clock)
{
u32 data;
__be32 reg;
int err;
err = get_clock(tscm, &data);
if (err < 0)
return err;
data &= 0x0000ffff;
if (rate > 0) {
data &= 0x000000ff;
/* Base rate. */
if ((rate % 44100) == 0) {
data |= 0x00000100;
/* Multiplier. */
if (rate / 44100 == 2)
data |= 0x00008000;
} else if ((rate % 48000) == 0) {
data |= 0x00000200;
/* Multiplier. */
if (rate / 48000 == 2)
data |= 0x00008000;
} else {
return -EAGAIN;
}
}
if (clock != INT_MAX) {
data &= 0x0000ff00;
data |= clock + 1;
}
reg = cpu_to_be32(data);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
&reg, sizeof(reg), 0);
if (err < 0)
return err;
if (data & 0x00008000)
reg = cpu_to_be32(0x0000001a);
else
reg = cpu_to_be32(0x0000000d);
return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_MULTIPLEX_MODE,
&reg, sizeof(reg), 0);
}
int snd_tscm_stream_get_rate(struct snd_tscm *tscm, unsigned int *rate)
{
u32 data = 0x0;
unsigned int trials = 0;
int err;
while (data == 0x0 || trials++ < 5) {
err = get_clock(tscm, &data);
if (err < 0)
return err;
data = (data & 0xff000000) >> 24;
}
/* Check base rate. */
if ((data & 0x0f) == 0x01)
*rate = 44100;
else if ((data & 0x0f) == 0x02)
*rate = 48000;
else
return -EAGAIN;
/* Check multiplier. */
if ((data & 0xf0) == 0x80)
*rate *= 2;
else if ((data & 0xf0) != 0x00)
return -EAGAIN;
return err;
}
int snd_tscm_stream_get_clock(struct snd_tscm *tscm, enum snd_tscm_clock *clock)
{
u32 data;
int err;
err = get_clock(tscm, &data);
if (err < 0)
return err;
*clock = ((data & 0x00ff0000) >> 16) - 1;
if (*clock < 0 || *clock > SND_TSCM_CLOCK_ADAT)
return -EIO;
return 0;
}
static int enable_data_channels(struct snd_tscm *tscm)
{
__be32 reg;
u32 data;
unsigned int i;
int err;
data = 0;
for (i = 0; i < tscm->spec->pcm_capture_analog_channels; ++i)
data |= BIT(i);
if (tscm->spec->has_adat)
data |= 0x0000ff00;
if (tscm->spec->has_spdif)
data |= 0x00030000;
reg = cpu_to_be32(data);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_TX_PCM_CHANNELS,
&reg, sizeof(reg), 0);
if (err < 0)
return err;
data = 0;
for (i = 0; i < tscm->spec->pcm_playback_analog_channels; ++i)
data |= BIT(i);
if (tscm->spec->has_adat)
data |= 0x0000ff00;
if (tscm->spec->has_spdif)
data |= 0x00030000;
reg = cpu_to_be32(data);
return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_RX_PCM_CHANNELS,
&reg, sizeof(reg), 0);
}
static int set_stream_formats(struct snd_tscm *tscm, unsigned int rate)
{
__be32 reg;
int err;
/* Set an option for unknown purpose. */
reg = cpu_to_be32(0x00200000);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
&reg, sizeof(reg), 0);
if (err < 0)
return err;
err = enable_data_channels(tscm);
if (err < 0)
return err;
return set_clock(tscm, rate, INT_MAX);
}
static void finish_session(struct snd_tscm *tscm)
{
__be32 reg;
reg = 0;
snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
&reg, sizeof(reg), 0);
reg = 0;
snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
&reg, sizeof(reg), 0);
}
static int begin_session(struct snd_tscm *tscm)
{
__be32 reg;
int err;
reg = cpu_to_be32(0x00000001);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
&reg, sizeof(reg), 0);
if (err < 0)
return err;
reg = cpu_to_be32(0x00000001);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
&reg, sizeof(reg), 0);
if (err < 0)
return err;
/* Set an option for unknown purpose. */
reg = cpu_to_be32(0x00002000);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
&reg, sizeof(reg), 0);
if (err < 0)
return err;
/* Start multiplexing PCM samples on packets. */
reg = cpu_to_be32(0x00000001);
return snd_fw_transaction(tscm->unit,
TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_ON,
&reg, sizeof(reg), 0);
}
static void release_resources(struct snd_tscm *tscm)
{
__be32 reg;
/* Unregister channels. */
reg = cpu_to_be32(0x00000000);
snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
&reg, sizeof(reg), 0);
reg = cpu_to_be32(0x00000000);
snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
&reg, sizeof(reg), 0);
reg = cpu_to_be32(0x00000000);
snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
&reg, sizeof(reg), 0);
/* Release isochronous resources. */
fw_iso_resources_free(&tscm->tx_resources);
fw_iso_resources_free(&tscm->rx_resources);
}
static int keep_resources(struct snd_tscm *tscm, unsigned int rate)
{
__be32 reg;
int err;
/* Keep resources for in-stream. */
err = amdtp_tscm_set_parameters(&tscm->tx_stream, rate);
if (err < 0)
return err;
err = fw_iso_resources_allocate(&tscm->tx_resources,
amdtp_stream_get_max_payload(&tscm->tx_stream),
fw_parent_device(tscm->unit)->max_speed);
if (err < 0)
goto error;
/* Keep resources for out-stream. */
err = amdtp_tscm_set_parameters(&tscm->rx_stream, rate);
if (err < 0)
return err;
err = fw_iso_resources_allocate(&tscm->rx_resources,
amdtp_stream_get_max_payload(&tscm->rx_stream),
fw_parent_device(tscm->unit)->max_speed);
if (err < 0)
return err;
/* Register the isochronous channel for transmitting stream. */
reg = cpu_to_be32(tscm->tx_resources.channel);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
&reg, sizeof(reg), 0);
if (err < 0)
goto error;
/* Unknown */
reg = cpu_to_be32(0x00000002);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
&reg, sizeof(reg), 0);
if (err < 0)
goto error;
/* Register the isochronous channel for receiving stream. */
reg = cpu_to_be32(tscm->rx_resources.channel);
err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
&reg, sizeof(reg), 0);
if (err < 0)
goto error;
return 0;
error:
release_resources(tscm);
return err;
}
int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
{
unsigned int pcm_channels;
int err;
/* For out-stream. */
err = fw_iso_resources_init(&tscm->rx_resources, tscm->unit);
if (err < 0)
return err;
pcm_channels = tscm->spec->pcm_playback_analog_channels;
if (tscm->spec->has_adat)
pcm_channels += 8;
if (tscm->spec->has_spdif)
pcm_channels += 2;
err = amdtp_tscm_init(&tscm->rx_stream, tscm->unit, AMDTP_OUT_STREAM,
pcm_channels);
if (err < 0)
return err;
/* For in-stream. */
err = fw_iso_resources_init(&tscm->tx_resources, tscm->unit);
if (err < 0)
return err;
pcm_channels = tscm->spec->pcm_capture_analog_channels;
if (tscm->spec->has_adat)
pcm_channels += 8;
if (tscm->spec->has_spdif)
pcm_channels += 2;
err = amdtp_tscm_init(&tscm->tx_stream, tscm->unit, AMDTP_IN_STREAM,
pcm_channels);
if (err < 0)
amdtp_stream_destroy(&tscm->rx_stream);
return 0;
}
/* At bus reset, streaming is stopped and some registers are clear. */
void snd_tscm_stream_update_duplex(struct snd_tscm *tscm)
{
amdtp_stream_pcm_abort(&tscm->tx_stream);
amdtp_stream_stop(&tscm->tx_stream);
amdtp_stream_pcm_abort(&tscm->rx_stream);
amdtp_stream_stop(&tscm->rx_stream);
}
/*
* This function should be called before starting streams or after stopping
* streams.
*/
void snd_tscm_stream_destroy_duplex(struct snd_tscm *tscm)
{
amdtp_stream_destroy(&tscm->rx_stream);
amdtp_stream_destroy(&tscm->tx_stream);
fw_iso_resources_destroy(&tscm->rx_resources);
fw_iso_resources_destroy(&tscm->tx_resources);
}
int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
{
unsigned int curr_rate;
int err;
if (tscm->substreams_counter == 0)
return 0;
err = snd_tscm_stream_get_rate(tscm, &curr_rate);
if (err < 0)
return err;
if (curr_rate != rate ||
amdtp_streaming_error(&tscm->rx_stream) ||
amdtp_streaming_error(&tscm->tx_stream)) {
finish_session(tscm);
amdtp_stream_stop(&tscm->rx_stream);
amdtp_stream_stop(&tscm->tx_stream);
release_resources(tscm);
}
if (!amdtp_stream_running(&tscm->rx_stream)) {
err = keep_resources(tscm, rate);
if (err < 0)
goto error;
err = set_stream_formats(tscm, rate);
if (err < 0)
goto error;
err = begin_session(tscm);
if (err < 0)
goto error;
err = amdtp_stream_start(&tscm->rx_stream,
tscm->rx_resources.channel,
fw_parent_device(tscm->unit)->max_speed);
if (err < 0)
goto error;
if (!amdtp_stream_wait_callback(&tscm->rx_stream,
CALLBACK_TIMEOUT)) {
err = -ETIMEDOUT;
goto error;
}
}
if (!amdtp_stream_running(&tscm->tx_stream)) {
err = amdtp_stream_start(&tscm->tx_stream,
tscm->tx_resources.channel,
fw_parent_device(tscm->unit)->max_speed);
if (err < 0)
goto error;
if (!amdtp_stream_wait_callback(&tscm->tx_stream,
CALLBACK_TIMEOUT)) {
err = -ETIMEDOUT;
goto error;
}
}
return 0;
error:
amdtp_stream_stop(&tscm->rx_stream);
amdtp_stream_stop(&tscm->tx_stream);
finish_session(tscm);
release_resources(tscm);
return err;
}
void snd_tscm_stream_stop_duplex(struct snd_tscm *tscm)
{
if (tscm->substreams_counter > 0)
return;
amdtp_stream_stop(&tscm->tx_stream);
amdtp_stream_stop(&tscm->rx_stream);
finish_session(tscm);
release_resources(tscm);
}
void snd_tscm_stream_lock_changed(struct snd_tscm *tscm)
{
tscm->dev_lock_changed = true;
wake_up(&tscm->hwdep_wait);
}
int snd_tscm_stream_lock_try(struct snd_tscm *tscm)
{
int err;
spin_lock_irq(&tscm->lock);
/* user land lock this */
if (tscm->dev_lock_count < 0) {
err = -EBUSY;
goto end;
}
/* this is the first time */
if (tscm->dev_lock_count++ == 0)
snd_tscm_stream_lock_changed(tscm);
err = 0;
end:
spin_unlock_irq(&tscm->lock);
return err;
}
void snd_tscm_stream_lock_release(struct snd_tscm *tscm)
{
spin_lock_irq(&tscm->lock);
if (WARN_ON(tscm->dev_lock_count <= 0))
goto end;
if (--tscm->dev_lock_count == 0)
snd_tscm_stream_lock_changed(tscm);
end:
spin_unlock_irq(&tscm->lock);
}
Reference in New Issue View Git Blame Copy Permalink