ALSA: firewire-tascam: add streaming functionality

This commit adds streaming functionality for both direction. To utilize
the sequence of the number of data blocks in packets, full duplex with
synchronization is applied.

Besides, TASCAM FireWire series allows drivers to decide which PCM data
channels are enabled. For convenience, this driver always enable whole the
data channels.

Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

diff --git a/sound/firewire/tascam/Makefile b/sound/firewire/tascam/Makefile
index d06c737ae261f2a14b24146aef60f085cdee34b5..0a1c38732805d3a8ed8198d3e22524225d2c8790 100644 (file)
--- a/sound/firewire/tascam/Makefile
+++ b/sound/firewire/tascam/Makefile
@@ -1,2 +1,3 @@
-snd-firewire-tascam-objs := tascam-proc.o amdtp-tascam.o tascam.o
+snd-firewire-tascam-objs := tascam-proc.o amdtp-tascam.o tascam-stream.o \
+                           tascam.o
 obj-$(CONFIG_SND_FIREWIRE_TASCAM) += snd-firewire-tascam.o

diff --git a/sound/firewire/tascam/tascam-stream.c b/sound/firewire/tascam/tascam-stream.c
new file mode 100644 (file)
index 0000000..0732f7f
--- /dev/null
+++ b/sound/firewire/tascam/tascam-stream.c
@@ -0,0 +1,457 @@
+/*
+ * 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->tx_stream) ||
+           amdtp_streaming_error(&tscm->rx_stream)) {
+               finish_session(tscm);
+
+               amdtp_stream_stop(&tscm->tx_stream);
+               amdtp_stream_stop(&tscm->rx_stream);
+
+               release_resources(tscm);
+       }
+
+       if (!amdtp_stream_running(&tscm->tx_stream)) {
+               amdtp_stream_set_sync(CIP_SYNC_TO_DEVICE,
+                                     &tscm->tx_stream, &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->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;
+               }
+       }
+
+       if (!amdtp_stream_running(&tscm->rx_stream)) {
+               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;
+               }
+       }
+
+       return 0;
+error:
+       amdtp_stream_stop(&tscm->tx_stream);
+       amdtp_stream_stop(&tscm->rx_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);
+}

diff --git a/sound/firewire/tascam/tascam.c b/sound/firewire/tascam/tascam.c
index d7418c065f4e92e0a35d40c6a7c067292c27d03e..c2563606ac70af0623fbebbc2d2e7056b7f778df 100644 (file)
--- a/sound/firewire/tascam/tascam.c
+++ b/sound/firewire/tascam/tascam.c
@@ -82,6 +82,8 @@ static void tscm_card_free(struct snd_card *card)
 {
        struct snd_tscm *tscm = card->private_data;
 
+       snd_tscm_stream_destroy_duplex(tscm);
+
        fw_unit_put(tscm->unit);
 
        mutex_destroy(&tscm->mutex);
@@ -115,6 +117,10 @@ static int snd_tscm_probe(struct fw_unit *unit,
 
        snd_tscm_proc_init(tscm);
 
+       err = snd_tscm_stream_init_duplex(tscm);
+       if (err < 0)
+               goto error;
+
        err = snd_card_register(card);
        if (err < 0)
                goto error;
@@ -129,7 +135,11 @@ error:
 
 static void snd_tscm_update(struct fw_unit *unit)
 {
-       return;
+       struct snd_tscm *tscm = dev_get_drvdata(&unit->device);
+
+       mutex_lock(&tscm->mutex);
+       snd_tscm_stream_update_duplex(tscm);
+       mutex_unlock(&tscm->mutex);
 }
 
 static void snd_tscm_remove(struct fw_unit *unit)

diff --git a/sound/firewire/tascam/tascam.h b/sound/firewire/tascam/tascam.h
index 195be0bfb054494dd4762d3de5616240ca90e8b9..41fe3a974b90e33fe2c02cc46d9ad212957b32b0 100644 (file)
--- a/sound/firewire/tascam/tascam.h
+++ b/sound/firewire/tascam/tascam.h
@@ -26,6 +26,7 @@
 
 #include "../lib.h"
 #include "../amdtp-stream.h"
+#include "../iso-resources.h"
 
 struct snd_tscm_spec {
        const char *const name;
@@ -45,6 +46,12 @@ struct snd_tscm {
        struct mutex mutex;
 
        const struct snd_tscm_spec *spec;
+
+       struct fw_iso_resources tx_resources;
+       struct fw_iso_resources rx_resources;
+       struct amdtp_stream tx_stream;
+       struct amdtp_stream rx_stream;
+       unsigned int substreams_counter;
 };
 
 #define TSCM_ADDR_BASE                 0xffff00000000ull
@@ -54,6 +61,26 @@ struct snd_tscm {
 #define TSCM_OFFSET_FIRMWARE_ARM       0x0008
 #define TSCM_OFFSET_FIRMWARE_HW                0x000c
 
+#define TSCM_OFFSET_ISOC_TX_CH         0x0200
+#define TSCM_OFFSET_UNKNOWN            0x0204
+#define TSCM_OFFSET_START_STREAMING    0x0208
+#define TSCM_OFFSET_ISOC_RX_CH         0x020c
+#define TSCM_OFFSET_ISOC_RX_ON         0x0210  /* Little conviction. */
+#define TSCM_OFFSET_TX_PCM_CHANNELS    0x0214
+#define TSCM_OFFSET_RX_PCM_CHANNELS    0x0218
+#define TSCM_OFFSET_MULTIPLEX_MODE     0x021c
+#define TSCM_OFFSET_ISOC_TX_ON         0x0220
+/* Unknown                             0x0224 */
+#define TSCM_OFFSET_CLOCK_STATUS       0x0228
+#define TSCM_OFFSET_SET_OPTION         0x022c
+
+enum snd_tscm_clock {
+       SND_TSCM_CLOCK_INTERNAL = 0,
+       SND_TSCM_CLOCK_WORD     = 1,
+       SND_TSCM_CLOCK_SPDIF    = 2,
+       SND_TSCM_CLOCK_ADAT     = 3,
+};
+
 int amdtp_tscm_init(struct amdtp_stream *s, struct fw_unit *unit,
                  enum amdtp_stream_direction dir, unsigned int pcm_channels);
 int amdtp_tscm_set_parameters(struct amdtp_stream *s, unsigned int rate);
@@ -61,6 +88,15 @@ int amdtp_tscm_add_pcm_hw_constraints(struct amdtp_stream *s,
                                      struct snd_pcm_runtime *runtime);
 void amdtp_tscm_set_pcm_format(struct amdtp_stream *s, snd_pcm_format_t format);
 
+int snd_tscm_stream_get_rate(struct snd_tscm *tscm, unsigned int *rate);
+int snd_tscm_stream_get_clock(struct snd_tscm *tscm,
+                             enum snd_tscm_clock *clock);
+int snd_tscm_stream_init_duplex(struct snd_tscm *tscm);
+void snd_tscm_stream_update_duplex(struct snd_tscm *tscm);
+void snd_tscm_stream_destroy_duplex(struct snd_tscm *tscm);
+int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate);
+void snd_tscm_stream_stop_duplex(struct snd_tscm *tscm);
+
 void snd_tscm_proc_init(struct snd_tscm *tscm);
 
 #endif