ALSA: add LaCie FireWire Speakers/Griffin FireWave Surround driver

Add a driver for two playback-only FireWire devices based on the OXFW970 chip. v2: better AMDTP API abstraction; fix fw_unit leak; small fixes v3: cache the iPCR value v4: FireWave constraints; fix fw_device reference counting; fix PCR caching; small changes and fixes v5: volume/mute support; fix crashing due to pcm stop races v6: fix build; one-channel volume for LaCie v7: use signed values to make volume (range checks) work; fix function block IDs for volume/mute; always use channel 0 for LaCie volume Signed-off-by: Clemens Ladisch <clemens@ladisch.de> Acked-by: Stefan Richter <stefanr@s5r6.in-berlin.de> Tested-by: Jay Fenlason <fenlason@redhat.com> Signed-off-by: Takashi Iwai <tiwai@suse.de>

ALSA: add LaCie FireWire Speakers/Griffin FireWave Surround driver
Add a driver for two playback-only FireWire devices based on the OXFW970 chip. v2: better AMDTP API abstraction; fix fw_unit leak; small fixes v3: cache the iPCR value v4: FireWave constraints; fix fw_device reference counting; fix PCR caching; small changes and fixes v5: volume/mute support; fix crashing due to pcm stop races v6: fix build; one-channel volume for LaCie v7: use signed values to make volume (range checks) work; fix function block IDs for volume/mute; always use channel 0 for LaCie volume Signed-off-by: Clemens Ladisch <clemens@ladisch.de> Acked-by: Stefan Richter <stefanr@s5r6.in-berlin.de> Tested-by: Jay Fenlason <fenlason@redhat.com> Signed-off-by: Takashi Iwai <tiwai@suse.de>
Clemens Ladisch · Takashi Iwai
1 parent a5abba989d
Showing 20 changed files with 2651 additions and 4 deletions Side-by-side Diff
drivers/firewire/core-iso.c
drivers/firewire/core.h
include/linux/firewire.h
sound/Kconfig
sound/Makefile
sound/firewire/Kconfig
sound/firewire/Makefile
sound/firewire/amdtp.c
sound/firewire/amdtp.h
sound/firewire/cmp.c
sound/firewire/cmp.h
sound/firewire/fcp.c
sound/firewire/fcp.h
sound/firewire/iso-resources.c
sound/firewire/iso-resources.h
sound/firewire/lib.c
sound/firewire/lib.h
sound/firewire/packets-buffer.c
sound/firewire/packets-buffer.h
sound/firewire/speakers.c
@@ -362,4 +362,5 @@
 		*channel = ret;
 	}
 }
+EXPORT_SYMBOL(fw_iso_resource_manage);
@@ -147,9 +147,6 @@
 /* -iso */
  
 int fw_iso_buffer_map(struct fw_iso_buffer *buffer, struct vm_area_struct *vma);
-void fw_iso_resource_manage(struct fw_card *card, int generation,
-			    u64 channels_mask, int *channel, int *bandwidth,
-			    bool allocate, __be32 buffer[2]);
  
  
 /* -topology */
@@ -42,6 +42,10 @@
 #define CSR_BROADCAST_CHANNEL		0x234
 #define CSR_CONFIG_ROM			0x400
 #define CSR_CONFIG_ROM_END		0x800
+#define CSR_OMPR			0x900
+#define CSR_OPCR(i)			(0x904 + (i) * 4)
+#define CSR_IMPR			0x980
+#define CSR_IPCR(i)			(0x984 + (i) * 4)
 #define CSR_FCP_COMMAND			0xB00
 #define CSR_FCP_RESPONSE		0xD00
 #define CSR_FCP_END			0xF00
@@ -441,6 +445,9 @@
 			 int cycle, int sync, int tags);
 int fw_iso_context_stop(struct fw_iso_context *ctx);
 void fw_iso_context_destroy(struct fw_iso_context *ctx);
+void fw_iso_resource_manage(struct fw_card *card, int generation,
+			    u64 channels_mask, int *channel, int *bandwidth,
+			    bool allocate, __be32 buffer[2]);
  
 #endif /* _LINUX_FIREWIRE_H */
@@ -97,6 +97,8 @@
 # here assuming USB is defined before ALSA
 source "sound/usb/Kconfig"
  
+source "sound/firewire/Kconfig"
+
 # the following will depend on the order of config.
 # here assuming PCMCIA is defined before ALSA
 source "sound/pcmcia/Kconfig"
@@ -6,7 +6,7 @@
 obj-$(CONFIG_SOUND_PRIME) += oss/
 obj-$(CONFIG_DMASOUND) += oss/
 obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ sh/ synth/ usb/ \
-	sparc/ spi/ parisc/ pcmcia/ mips/ soc/ atmel/
+	firewire/ sparc/ spi/ parisc/ pcmcia/ mips/ soc/ atmel/
 obj-$(CONFIG_SND_AOA) += aoa/
  
 # This one must be compilable even if sound is configured out
+menuconfig SND_FIREWIRE
+	bool "FireWire sound devices"
+	depends on FIREWIRE
+	default y
+	help
+	  Support for IEEE-1394/FireWire/iLink sound devices.
+
+if SND_FIREWIRE && FIREWIRE
+
+config SND_FIREWIRE_LIB
+	tristate
+	depends on SND_PCM
+
+config SND_FIREWIRE_SPEAKERS
+	tristate "FireWire speakers"
+	select SND_PCM
+	select SND_FIREWIRE_LIB
+	help
+	  Say Y here to include support for the Griffin FireWave Surround
+	  and the LaCie FireWire Speakers.
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called snd-firewire-speakers.
+
+endif # SND_FIREWIRE
+snd-firewire-lib-objs := lib.o iso-resources.o packets-buffer.o \
+			 fcp.o cmp.o amdtp.o
+snd-firewire-speakers-objs := speakers.o
+
+obj-$(CONFIG_SND_FIREWIRE_LIB) += snd-firewire-lib.o
+obj-$(CONFIG_SND_FIREWIRE_SPEAKERS) += snd-firewire-speakers.o
+/*
+ * Audio and Music Data Transmission Protocol (IEC 61883-6) streams
+ * with Common Isochronous Packet (IEC 61883-1) headers
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/firewire.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <sound/pcm.h>
+#include "amdtp.h"
+
+#define TICKS_PER_CYCLE		3072
+#define CYCLES_PER_SECOND	8000
+#define TICKS_PER_SECOND	(TICKS_PER_CYCLE * CYCLES_PER_SECOND)
+
+#define TRANSFER_DELAY_TICKS	0x2e00 /* 479.17 µs */
+
+#define TAG_CIP			1
+
+#define CIP_EOH			(1u << 31)
+#define CIP_FMT_AM		(0x10 << 24)
+#define AMDTP_FDF_AM824		(0 << 19)
+#define AMDTP_FDF_SFC_SHIFT	16
+
+/* TODO: make these configurable */
+#define INTERRUPT_INTERVAL	16
+#define QUEUE_LENGTH		48
+
+/**
+ * amdtp_out_stream_init - initialize an AMDTP output stream structure
+ * @s: the AMDTP output stream to initialize
+ * @unit: the target of the stream
+ * @flags: the packet transmission method to use
+ */
+int amdtp_out_stream_init(struct amdtp_out_stream *s, struct fw_unit *unit,
+			  enum cip_out_flags flags)
+{
+	if (flags != CIP_NONBLOCKING)
+		return -EINVAL;
+
+	s->unit = fw_unit_get(unit);
+	s->flags = flags;
+	s->context = ERR_PTR(-1);
+	mutex_init(&s->mutex);
+
+	return 0;
+}
+EXPORT_SYMBOL(amdtp_out_stream_init);
+
+/**
+ * amdtp_out_stream_destroy - free stream resources
+ * @s: the AMDTP output stream to destroy
+ */
+void amdtp_out_stream_destroy(struct amdtp_out_stream *s)
+{
+	WARN_ON(!IS_ERR(s->context));
+	mutex_destroy(&s->mutex);
+	fw_unit_put(s->unit);
+}
+EXPORT_SYMBOL(amdtp_out_stream_destroy);
+
+/**
+ * amdtp_out_stream_set_rate - set the sample rate
+ * @s: the AMDTP output stream to configure
+ * @rate: the sample rate
+ *
+ * The sample rate must be set before the stream is started, and must not be
+ * changed while the stream is running.
+ */
+void amdtp_out_stream_set_rate(struct amdtp_out_stream *s, unsigned int rate)
+{
+	static const struct {
+		unsigned int rate;
+		unsigned int syt_interval;
+	} rate_info[] = {
+		[CIP_SFC_32000]  = {  32000,  8, },
+		[CIP_SFC_44100]  = {  44100,  8, },
+		[CIP_SFC_48000]  = {  48000,  8, },
+		[CIP_SFC_88200]  = {  88200, 16, },
+		[CIP_SFC_96000]  = {  96000, 16, },
+		[CIP_SFC_176400] = { 176400, 32, },
+		[CIP_SFC_192000] = { 192000, 32, },
+	};
+	unsigned int sfc;
+
+	if (WARN_ON(!IS_ERR(s->context)))
+		return;
+
+	for (sfc = 0; sfc < ARRAY_SIZE(rate_info); ++sfc)
+		if (rate_info[sfc].rate == rate) {
+			s->sfc = sfc;
+			s->syt_interval = rate_info[sfc].syt_interval;
+			return;
+		}
+	WARN_ON(1);
+}
+EXPORT_SYMBOL(amdtp_out_stream_set_rate);
+
+/**
+ * amdtp_out_stream_get_max_payload - get the stream's packet size
+ * @s: the AMDTP output stream
+ *
+ * This function must not be called before the stream has been configured
+ * with amdtp_out_stream_set_hw_params(), amdtp_out_stream_set_pcm(), and
+ * amdtp_out_stream_set_midi().
+ */
+unsigned int amdtp_out_stream_get_max_payload(struct amdtp_out_stream *s)
+{
+	static const unsigned int max_data_blocks[] = {
+		[CIP_SFC_32000]  =  4,
+		[CIP_SFC_44100]  =  6,
+		[CIP_SFC_48000]  =  6,
+		[CIP_SFC_88200]  = 12,
+		[CIP_SFC_96000]  = 12,
+		[CIP_SFC_176400] = 23,
+		[CIP_SFC_192000] = 24,
+	};
+
+	s->data_block_quadlets = s->pcm_channels;
+	s->data_block_quadlets += DIV_ROUND_UP(s->midi_ports, 8);
+
+	return 8 + max_data_blocks[s->sfc] * 4 * s->data_block_quadlets;
+}
+EXPORT_SYMBOL(amdtp_out_stream_get_max_payload);
+
+static void amdtp_write_s16(struct amdtp_out_stream *s,
+			    struct snd_pcm_substream *pcm,
+			    __be32 *buffer, unsigned int frames);
+static void amdtp_write_s32(struct amdtp_out_stream *s,
+			    struct snd_pcm_substream *pcm,
+			    __be32 *buffer, unsigned int frames);
+
+/**
+ * amdtp_out_stream_set_pcm_format - set the PCM format
+ * @s: the AMDTP output stream to configure
+ * @format: the format of the ALSA PCM device
+ *
+ * The sample format must be set before the stream is started, and must not be
+ * changed while the stream is running.
+ */
+void amdtp_out_stream_set_pcm_format(struct amdtp_out_stream *s,
+				     snd_pcm_format_t format)
+{
+	if (WARN_ON(!IS_ERR(s->context)))
+		return;
+
+	switch (format) {
+	default:
+		WARN_ON(1);
+		/* fall through */
+	case SNDRV_PCM_FORMAT_S16:
+		s->transfer_samples = amdtp_write_s16;
+		break;
+	case SNDRV_PCM_FORMAT_S32:
+		s->transfer_samples = amdtp_write_s32;
+		break;
+	}
+}
+EXPORT_SYMBOL(amdtp_out_stream_set_pcm_format);
+
+static unsigned int calculate_data_blocks(struct amdtp_out_stream *s)
+{
+	unsigned int phase, data_blocks;
+
+	if (!cip_sfc_is_base_44100(s->sfc)) {
+		/* Sample_rate / 8000 is an integer, and precomputed. */
+		data_blocks = s->data_block_state;
+	} else {
+		phase = s->data_block_state;
+
+		/*
+		 * This calculates the number of data blocks per packet so that
+		 * 1) the overall rate is correct and exactly synchronized to
+		 *    the bus clock, and
+		 * 2) packets with a rounded-up number of blocks occur as early
+		 *    as possible in the sequence (to prevent underruns of the
+		 *    device's buffer).
+		 */
+		if (s->sfc == CIP_SFC_44100)
+			/* 6 6 5 6 5 6 5 ... */
+			data_blocks = 5 + ((phase & 1) ^
+					   (phase == 0 || phase >= 40));
+		else
+			/* 12 11 11 11 11 ... or 23 22 22 22 22 ... */
+			data_blocks = 11 * (s->sfc >> 1) + (phase == 0);
+		if (++phase >= (80 >> (s->sfc >> 1)))
+			phase = 0;
+		s->data_block_state = phase;
+	}
+
+	return data_blocks;
+}
+
+static unsigned int calculate_syt(struct amdtp_out_stream *s,
+				  unsigned int cycle)
+{
+	unsigned int syt_offset, phase, index, syt;
+
+	if (s->last_syt_offset < TICKS_PER_CYCLE) {
+		if (!cip_sfc_is_base_44100(s->sfc))
+			syt_offset = s->last_syt_offset + s->syt_offset_state;
+		else {
+		/*
+		 * The time, in ticks, of the n'th SYT_INTERVAL sample is:
+		 *   n * SYT_INTERVAL * 24576000 / sample_rate
+		 * Modulo TICKS_PER_CYCLE, the difference between successive
+		 * elements is about 1386.23.  Rounding the results of this
+		 * formula to the SYT precision results in a sequence of
+		 * differences that begins with:
+		 *   1386 1386 1387 1386 1386 1386 1387 1386 1386 1386 1387 ...
+		 * This code generates _exactly_ the same sequence.
+		 */
+			phase = s->syt_offset_state;
+			index = phase % 13;
+			syt_offset = s->last_syt_offset;
+			syt_offset += 1386 + ((index && !(index & 3)) ||
+					      phase == 146);
+			if (++phase >= 147)
+				phase = 0;
+			s->syt_offset_state = phase;
+		}
+	} else
+		syt_offset = s->last_syt_offset - TICKS_PER_CYCLE;
+	s->last_syt_offset = syt_offset;
+
+	syt_offset += TRANSFER_DELAY_TICKS - TICKS_PER_CYCLE;
+	syt = (cycle + syt_offset / TICKS_PER_CYCLE) << 12;
+	syt += syt_offset % TICKS_PER_CYCLE;
+
+	return syt & 0xffff;
+}
+
+static void amdtp_write_s32(struct amdtp_out_stream *s,
+			    struct snd_pcm_substream *pcm,
+			    __be32 *buffer, unsigned int frames)
+{
+	struct snd_pcm_runtime *runtime = pcm->runtime;
+	unsigned int channels, remaining_frames, frame_step, i, c;
+	const u32 *src;
+
+	channels = s->pcm_channels;
+	src = (void *)runtime->dma_area +
+			s->pcm_buffer_pointer * (runtime->frame_bits / 8);
+	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+	frame_step = s->data_block_quadlets - channels;
+
+	for (i = 0; i < frames; ++i) {
+		for (c = 0; c < channels; ++c) {
+			*buffer = cpu_to_be32((*src >> 8) | 0x40000000);
+			src++;
+			buffer++;
+		}
+		buffer += frame_step;
+		if (--remaining_frames == 0)
+			src = (void *)runtime->dma_area;
+	}
+}
+
+static void amdtp_write_s16(struct amdtp_out_stream *s,
+			    struct snd_pcm_substream *pcm,
+			    __be32 *buffer, unsigned int frames)
+{
+	struct snd_pcm_runtime *runtime = pcm->runtime;
+	unsigned int channels, remaining_frames, frame_step, i, c;
+	const u16 *src;
+
+	channels = s->pcm_channels;
+	src = (void *)runtime->dma_area +
+			s->pcm_buffer_pointer * (runtime->frame_bits / 8);
+	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
+	frame_step = s->data_block_quadlets - channels;
+
+	for (i = 0; i < frames; ++i) {
+		for (c = 0; c < channels; ++c) {
+			*buffer = cpu_to_be32((*src << 8) | 0x40000000);
+			src++;
+			buffer++;
+		}
+		buffer += frame_step;
+		if (--remaining_frames == 0)
+			src = (void *)runtime->dma_area;
+	}
+}
+
+static void amdtp_fill_pcm_silence(struct amdtp_out_stream *s,
+				   __be32 *buffer, unsigned int frames)
+{
+	unsigned int i, c;
+
+	for (i = 0; i < frames; ++i) {
+		for (c = 0; c < s->pcm_channels; ++c)
+			buffer[c] = cpu_to_be32(0x40000000);
+		buffer += s->data_block_quadlets;
+	}
+}
+
+static void amdtp_fill_midi(struct amdtp_out_stream *s,
+			    __be32 *buffer, unsigned int frames)
+{
+	unsigned int i;
+
+	for (i = 0; i < frames; ++i)
+		buffer[s->pcm_channels + i * s->data_block_quadlets] =
+						cpu_to_be32(0x80000000);
+}
+
+static void queue_out_packet(struct amdtp_out_stream *s, unsigned int cycle)
+{
+	__be32 *buffer;
+	unsigned int data_blocks, syt, ptr;
+	struct snd_pcm_substream *pcm;
+	struct fw_iso_packet packet;
+	int err;
+
+	data_blocks = calculate_data_blocks(s);
+	syt = calculate_syt(s, cycle);
+
+	buffer = s->buffer.packets[s->packet_counter].buffer;
+	buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) |
+				(s->data_block_quadlets << 16) |
+				s->data_block_counter);
+	buffer[1] = cpu_to_be32(CIP_EOH | CIP_FMT_AM | AMDTP_FDF_AM824 |
+				(s->sfc << AMDTP_FDF_SFC_SHIFT) | syt);
+	buffer += 2;
+
+	pcm = ACCESS_ONCE(s->pcm);
+	if (pcm)
+		s->transfer_samples(s, pcm, buffer, data_blocks);
+	else
+		amdtp_fill_pcm_silence(s, buffer, data_blocks);
+	if (s->midi_ports)
+		amdtp_fill_midi(s, buffer, data_blocks);
+
+	s->data_block_counter = (s->data_block_counter + data_blocks) & 0xff;
+
+	packet.payload_length = 8 + data_blocks * 4 * s->data_block_quadlets;
+	packet.interrupt = IS_ALIGNED(s->packet_counter + 1,
+				      INTERRUPT_INTERVAL);
+	packet.skip = 0;
+	packet.tag = TAG_CIP;
+	packet.sy = 0;
+	packet.header_length = 0;
+
+	err = fw_iso_context_queue(s->context, &packet, &s->buffer.iso_buffer,
+				   s->buffer.packets[s->packet_counter].offset);
+	if (err < 0)
+		dev_err(&s->unit->device, "queueing error: %d\n", err);
+
+	if (++s->packet_counter >= QUEUE_LENGTH)
+		s->packet_counter = 0;
+
+	if (pcm) {
+		ptr = s->pcm_buffer_pointer + data_blocks;
+		if (ptr >= pcm->runtime->buffer_size)
+			ptr -= pcm->runtime->buffer_size;
+		ACCESS_ONCE(s->pcm_buffer_pointer) = ptr;
+
+		s->pcm_period_pointer += data_blocks;
+		if (s->pcm_period_pointer >= pcm->runtime->period_size) {
+			s->pcm_period_pointer -= pcm->runtime->period_size;
+			snd_pcm_period_elapsed(pcm);
+		}
+	}
+}
+
+static void out_packet_callback(struct fw_iso_context *context, u32 cycle,
+				size_t header_length, void *header, void *data)
+{
+	struct amdtp_out_stream *s = data;
+	unsigned int i, packets = header_length / 4;
+
+	/*
+	 * Compute the cycle of the last queued packet.
+	 * (We need only the four lowest bits for the SYT, so we can ignore
+	 * that bits 0-11 must wrap around at 3072.)
+	 */
+	cycle += QUEUE_LENGTH - packets;
+
+	for (i = 0; i < packets; ++i)
+		queue_out_packet(s, ++cycle);
+}
+
+static int queue_initial_skip_packets(struct amdtp_out_stream *s)
+{
+	struct fw_iso_packet skip_packet = {
+		.skip = 1,
+	};
+	unsigned int i;
+	int err;
+
+	for (i = 0; i < QUEUE_LENGTH; ++i) {
+		skip_packet.interrupt = IS_ALIGNED(s->packet_counter + 1,
+						   INTERRUPT_INTERVAL);
+		err = fw_iso_context_queue(s->context, &skip_packet, NULL, 0);
+		if (err < 0)
+			return err;
+		if (++s->packet_counter >= QUEUE_LENGTH)
+			s->packet_counter = 0;
+	}
+
+	return 0;
+}
+
+/**
+ * amdtp_out_stream_start - start sending packets
+ * @s: the AMDTP output stream to start
+ * @channel: the isochronous channel on the bus
+ * @speed: firewire speed code
+ *
+ * The stream cannot be started until it has been configured with
+ * amdtp_out_stream_set_hw_params(), amdtp_out_stream_set_pcm(), and
+ * amdtp_out_stream_set_midi(); and it must be started before any
+ * PCM or MIDI device can be started.
+ */
+int amdtp_out_stream_start(struct amdtp_out_stream *s, int channel, int speed)
+{
+	static const struct {
+		unsigned int data_block;
+		unsigned int syt_offset;
+	} initial_state[] = {
+		[CIP_SFC_32000]  = {  4, 3072 },
+		[CIP_SFC_48000]  = {  6, 1024 },
+		[CIP_SFC_96000]  = { 12, 1024 },
+		[CIP_SFC_192000] = { 24, 1024 },
+		[CIP_SFC_44100]  = {  0,   67 },
+		[CIP_SFC_88200]  = {  0,   67 },
+		[CIP_SFC_176400] = {  0,   67 },
+	};
+	int err;
+
+	mutex_lock(&s->mutex);
+
+	if (WARN_ON(!IS_ERR(s->context) ||
+		    (!s->pcm_channels && !s->midi_ports))) {
+		err = -EBADFD;
+		goto err_unlock;
+	}
+
+	s->data_block_state = initial_state[s->sfc].data_block;
+	s->syt_offset_state = initial_state[s->sfc].syt_offset;
+	s->last_syt_offset = TICKS_PER_CYCLE;
+
+	err = iso_packets_buffer_init(&s->buffer, s->unit, QUEUE_LENGTH,
+				      amdtp_out_stream_get_max_payload(s),
+				      DMA_TO_DEVICE);
+	if (err < 0)
+		goto err_unlock;
+
+	s->context = fw_iso_context_create(fw_parent_device(s->unit)->card,
+					   FW_ISO_CONTEXT_TRANSMIT,
+					   channel, speed, 0,
+					   out_packet_callback, s);
+	if (IS_ERR(s->context)) {
+		err = PTR_ERR(s->context);
+		if (err == -EBUSY)
+			dev_err(&s->unit->device,
+				"no free output stream on this controller\n");
+		goto err_buffer;
+	}
+
+	amdtp_out_stream_update(s);
+
+	s->packet_counter = 0;
+	s->data_block_counter = 0;
+	err = queue_initial_skip_packets(s);
+	if (err < 0)
+		goto err_context;
+
+	err = fw_iso_context_start(s->context, -1, 0, 0);
+	if (err < 0)
+		goto err_context;
+
+	mutex_unlock(&s->mutex);
+
+	return 0;
+
+err_context:
+	fw_iso_context_destroy(s->context);
+	s->context = ERR_PTR(-1);
+err_buffer:
+	iso_packets_buffer_destroy(&s->buffer, s->unit);
+err_unlock:
+	mutex_unlock(&s->mutex);
+
+	return err;
+}
+EXPORT_SYMBOL(amdtp_out_stream_start);
+
+/**
+ * amdtp_out_stream_update - update the stream after a bus reset
+ * @s: the AMDTP output stream
+ */
+void amdtp_out_stream_update(struct amdtp_out_stream *s)
+{
+	ACCESS_ONCE(s->source_node_id_field) =
+		(fw_parent_device(s->unit)->card->node_id & 0x3f) << 24;
+}
+EXPORT_SYMBOL(amdtp_out_stream_update);
+
+/**
+ * amdtp_out_stream_stop - stop sending packets
+ * @s: the AMDTP output stream to stop
+ *
+ * All PCM and MIDI devices of the stream must be stopped before the stream
+ * itself can be stopped.
+ */
+void amdtp_out_stream_stop(struct amdtp_out_stream *s)
+{
+	mutex_lock(&s->mutex);
+
+	if (IS_ERR(s->context)) {
+		mutex_unlock(&s->mutex);
+		return;
+	}
+
+	fw_iso_context_stop(s->context);
+	fw_iso_context_destroy(s->context);
+	s->context = ERR_PTR(-1);
+	iso_packets_buffer_destroy(&s->buffer, s->unit);
+
+	mutex_unlock(&s->mutex);
+}
+EXPORT_SYMBOL(amdtp_out_stream_stop);
+
+/**
+ * amdtp_out_stream_pcm_abort - abort the running PCM device
+ * @s: the AMDTP stream about to be stopped
+ *
+ * If the isochronous stream needs to be stopped asynchronously, call this
+ * function first to stop the PCM device.
+ */
+void amdtp_out_stream_pcm_abort(struct amdtp_out_stream *s)
+{
+	struct snd_pcm_substream *pcm;
+
+	pcm = ACCESS_ONCE(s->pcm);
+	if (pcm) {
+		snd_pcm_stream_lock_irq(pcm);
+		if (snd_pcm_running(pcm))
+			snd_pcm_stop(pcm, SNDRV_PCM_STATE_XRUN);
+		snd_pcm_stream_unlock_irq(pcm);
+	}
+}
+EXPORT_SYMBOL(amdtp_out_stream_pcm_abort);
+#ifndef SOUND_FIREWIRE_AMDTP_H_INCLUDED
+#define SOUND_FIREWIRE_AMDTP_H_INCLUDED
+
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+#include "packets-buffer.h"
+
+/**
+ * enum cip_out_flags - describes details of the streaming protocol
+ * @CIP_NONBLOCKING: In non-blocking mode, each packet contains
+ *	sample_rate/8000 samples, with rounding up or down to adjust
+ *	for clock skew and left-over fractional samples.  This should
+ *	be used if supported by the device.
+ */
+enum cip_out_flags {
+	CIP_NONBLOCKING = 0,
+};
+
+/**
+ * enum cip_sfc - a stream's sample rate
+ */
+enum cip_sfc {
+	CIP_SFC_32000  = 0,
+	CIP_SFC_44100  = 1,
+	CIP_SFC_48000  = 2,
+	CIP_SFC_88200  = 3,
+	CIP_SFC_96000  = 4,
+	CIP_SFC_176400 = 5,
+	CIP_SFC_192000 = 6,
+};
+
+#define AMDTP_OUT_PCM_FORMAT_BITS	(SNDRV_PCM_FMTBIT_S16 | \
+					 SNDRV_PCM_FMTBIT_S32)
+
+struct fw_unit;
+struct fw_iso_context;
+struct snd_pcm_substream;
+
+struct amdtp_out_stream {
+	struct fw_unit *unit;
+	enum cip_out_flags flags;
+	struct fw_iso_context *context;
+	struct mutex mutex;
+
+	enum cip_sfc sfc;
+	unsigned int data_block_quadlets;
+	unsigned int pcm_channels;
+	unsigned int midi_ports;
+	void (*transfer_samples)(struct amdtp_out_stream *s,
+				 struct snd_pcm_substream *pcm,
+				 __be32 *buffer, unsigned int frames);
+
+	unsigned int syt_interval;
+	unsigned int source_node_id_field;
+	struct iso_packets_buffer buffer;
+
+	struct snd_pcm_substream *pcm;
+
+	unsigned int packet_counter;
+	unsigned int data_block_counter;
+
+	unsigned int data_block_state;
+
+	unsigned int last_syt_offset;
+	unsigned int syt_offset_state;
+
+	unsigned int pcm_buffer_pointer;
+	unsigned int pcm_period_pointer;
+};
+
+int amdtp_out_stream_init(struct amdtp_out_stream *s, struct fw_unit *unit,
+			  enum cip_out_flags flags);
+void amdtp_out_stream_destroy(struct amdtp_out_stream *s);
+
+void amdtp_out_stream_set_rate(struct amdtp_out_stream *s, unsigned int rate);
+unsigned int amdtp_out_stream_get_max_payload(struct amdtp_out_stream *s);
+
+int amdtp_out_stream_start(struct amdtp_out_stream *s, int channel, int speed);
+void amdtp_out_stream_update(struct amdtp_out_stream *s);
+void amdtp_out_stream_stop(struct amdtp_out_stream *s);
+
+void amdtp_out_stream_set_pcm_format(struct amdtp_out_stream *s,
+				     snd_pcm_format_t format);
+void amdtp_out_stream_pcm_abort(struct amdtp_out_stream *s);
+
+/**
+ * amdtp_out_stream_set_pcm - configure format of PCM samples
+ * @s: the AMDTP output stream to be configured
+ * @pcm_channels: the number of PCM samples in each data block, to be encoded
+ *                as AM824 multi-bit linear audio
+ *
+ * This function must not be called while the stream is running.
+ */
+static inline void amdtp_out_stream_set_pcm(struct amdtp_out_stream *s,
+					    unsigned int pcm_channels)
+{
+	s->pcm_channels = pcm_channels;
+}
+
+/**
+ * amdtp_out_stream_set_midi - configure format of MIDI data
+ * @s: the AMDTP output stream to be configured
+ * @midi_ports: the number of MIDI ports (i.e., MPX-MIDI Data Channels)
+ *
+ * This function must not be called while the stream is running.
+ */
+static inline void amdtp_out_stream_set_midi(struct amdtp_out_stream *s,
+					     unsigned int midi_ports)
+{
+	s->midi_ports = midi_ports;
+}
+
+/**
+ * amdtp_out_stream_pcm_prepare - prepare PCM device for running
+ * @s: the AMDTP output stream
+ *
+ * This function should be called from the PCM device's .prepare callback.
+ */
+static inline void amdtp_out_stream_pcm_prepare(struct amdtp_out_stream *s)
+{
+	s->pcm_buffer_pointer = 0;
+	s->pcm_period_pointer = 0;
+}
+
+/**
+ * amdtp_out_stream_pcm_trigger - start/stop playback from a PCM device
+ * @s: the AMDTP output stream
+ * @pcm: the PCM device to be started, or %NULL to stop the current device
+ *
+ * Call this function on a running isochronous stream to enable the actual
+ * transmission of PCM data.  This function should be called from the PCM
+ * device's .trigger callback.
+ */
+static inline void amdtp_out_stream_pcm_trigger(struct amdtp_out_stream *s,
+						struct snd_pcm_substream *pcm)
+{
+	ACCESS_ONCE(s->pcm) = pcm;
+}
+
+/**
+ * amdtp_out_stream_pcm_pointer - get the PCM buffer position
+ * @s: the AMDTP output stream that transports the PCM data
+ *
+ * Returns the current buffer position, in frames.
+ */
+static inline unsigned long
+amdtp_out_stream_pcm_pointer(struct amdtp_out_stream *s)
+{
+	return ACCESS_ONCE(s->pcm_buffer_pointer);
+}
+
+static inline bool cip_sfc_is_base_44100(enum cip_sfc sfc)
+{
+	return sfc & 1;
+}
+
+#endif
+/*
+ * Connection Management Procedures (IEC 61883-1) helper functions
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#include <linux/device.h>
+#include <linux/firewire.h>
+#include <linux/firewire-constants.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include "lib.h"
+#include "iso-resources.h"
+#include "cmp.h"
+
+#define IMPR_SPEED_MASK		0xc0000000
+#define IMPR_SPEED_SHIFT	30
+#define IMPR_XSPEED_MASK	0x00000060
+#define IMPR_XSPEED_SHIFT	5
+#define IMPR_PLUGS_MASK		0x0000001f
+
+#define IPCR_ONLINE		0x80000000
+#define IPCR_BCAST_CONN		0x40000000
+#define IPCR_P2P_CONN_MASK	0x3f000000
+#define IPCR_P2P_CONN_SHIFT	24
+#define IPCR_CHANNEL_MASK	0x003f0000
+#define IPCR_CHANNEL_SHIFT	16
+
+enum bus_reset_handling {
+	ABORT_ON_BUS_RESET,
+	SUCCEED_ON_BUS_RESET,
+};
+
+static __attribute__((format(printf, 2, 3)))
+void cmp_error(struct cmp_connection *c, const char *fmt, ...)
+{
+	va_list va;
+
+	va_start(va, fmt);
+	dev_err(&c->resources.unit->device, "%cPCR%u: %pV",
+		'i', c->pcr_index, &(struct va_format){ fmt, &va });
+	va_end(va);
+}
+
+static int pcr_modify(struct cmp_connection *c,
+		      __be32 (*modify)(struct cmp_connection *c, __be32 old),
+		      int (*check)(struct cmp_connection *c, __be32 pcr),
+		      enum bus_reset_handling bus_reset_handling)
+{
+	struct fw_device *device = fw_parent_device(c->resources.unit);
+	__be32 *buffer = c->resources.buffer;
+	int generation = c->resources.generation;
+	int rcode, errors = 0;
+	__be32 old_arg;
+	int err;
+
+	buffer[0] = c->last_pcr_value;
+	for (;;) {
+		old_arg = buffer[0];
+		buffer[1] = modify(c, buffer[0]);
+
+		rcode = fw_run_transaction(
+				device->card, TCODE_LOCK_COMPARE_SWAP,
+				device->node_id, generation, device->max_speed,
+				CSR_REGISTER_BASE + CSR_IPCR(c->pcr_index),
+				buffer, 8);
+
+		if (rcode == RCODE_COMPLETE) {
+			if (buffer[0] == old_arg) /* success? */
+				break;
+
+			if (check) {
+				err = check(c, buffer[0]);
+				if (err < 0)
+					return err;
+			}
+		} else if (rcode == RCODE_GENERATION)
+			goto bus_reset;
+		else if (rcode_is_permanent_error(rcode) || ++errors >= 3)
+			goto io_error;
+	}
+	c->last_pcr_value = buffer[1];
+
+	return 0;
+
+io_error:
+	cmp_error(c, "transaction failed: %s\n", rcode_string(rcode));
+	return -EIO;
+
+bus_reset:
+	return bus_reset_handling == ABORT_ON_BUS_RESET ? -EAGAIN : 0;
+}
+
+
+/**
+ * cmp_connection_init - initializes a connection manager
+ * @c: the connection manager to initialize
+ * @unit: a unit of the target device
+ * @ipcr_index: the index of the iPCR on the target device
+ */
+int cmp_connection_init(struct cmp_connection *c,
+			struct fw_unit *unit,
+			unsigned int ipcr_index)
+{
+	__be32 impr_be;
+	u32 impr;
+	int err;
+
+	err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST,
+				 CSR_REGISTER_BASE + CSR_IMPR,
+				 &impr_be, 4);
+	if (err < 0)
+		return err;
+	impr = be32_to_cpu(impr_be);
+
+	if (ipcr_index >= (impr & IMPR_PLUGS_MASK))
+		return -EINVAL;
+
+	c->connected = false;
+	mutex_init(&c->mutex);
+	fw_iso_resources_init(&c->resources, unit);
+	c->last_pcr_value = cpu_to_be32(0x80000000);
+	c->pcr_index = ipcr_index;
+	c->max_speed = (impr & IMPR_SPEED_MASK) >> IMPR_SPEED_SHIFT;
+	if (c->max_speed == SCODE_BETA)
+		c->max_speed += (impr & IMPR_XSPEED_MASK) >> IMPR_XSPEED_SHIFT;
+
+	return 0;
+}
+EXPORT_SYMBOL(cmp_connection_init);
+
+/**
+ * cmp_connection_destroy - free connection manager resources
+ * @c: the connection manager
+ */
+void cmp_connection_destroy(struct cmp_connection *c)
+{
+	WARN_ON(c->connected);
+	mutex_destroy(&c->mutex);
+	fw_iso_resources_destroy(&c->resources);
+}
+EXPORT_SYMBOL(cmp_connection_destroy);
+
+
+static __be32 ipcr_set_modify(struct cmp_connection *c, __be32 ipcr)
+{
+	ipcr &= ~cpu_to_be32(IPCR_BCAST_CONN |
+			     IPCR_P2P_CONN_MASK |
+			     IPCR_CHANNEL_MASK);
+	ipcr |= cpu_to_be32(1 << IPCR_P2P_CONN_SHIFT);
+	ipcr |= cpu_to_be32(c->resources.channel << IPCR_CHANNEL_SHIFT);
+
+	return ipcr;
+}
+
+static int ipcr_set_check(struct cmp_connection *c, __be32 ipcr)
+{
+	if (ipcr & cpu_to_be32(IPCR_BCAST_CONN |
+			       IPCR_P2P_CONN_MASK)) {
+		cmp_error(c, "plug is already in use\n");
+		return -EBUSY;
+	}
+	if (!(ipcr & cpu_to_be32(IPCR_ONLINE))) {
+		cmp_error(c, "plug is not on-line\n");
+		return -ECONNREFUSED;
+	}
+
+	return 0;
+}
+
+/**
+ * cmp_connection_establish - establish a connection to the target
+ * @c: the connection manager
+ * @max_payload_bytes: the amount of data (including CIP headers) per packet
+ *
+ * This function establishes a point-to-point connection from the local
+ * computer to the target by allocating isochronous resources (channel and
+ * bandwidth) and setting the target's input plug control register.  When this
+ * function succeeds, the caller is responsible for starting transmitting
+ * packets.
+ */
+int cmp_connection_establish(struct cmp_connection *c,
+			     unsigned int max_payload_bytes)
+{
+	int err;
+
+	if (WARN_ON(c->connected))
+		return -EISCONN;
+
+	c->speed = min(c->max_speed,
+		       fw_parent_device(c->resources.unit)->max_speed);
+
+	mutex_lock(&c->mutex);
+
+retry_after_bus_reset:
+	err = fw_iso_resources_allocate(&c->resources,
+					max_payload_bytes, c->speed);
+	if (err < 0)
+		goto err_mutex;
+
+	err = pcr_modify(c, ipcr_set_modify, ipcr_set_check,
+			 ABORT_ON_BUS_RESET);
+	if (err == -EAGAIN) {
+		fw_iso_resources_free(&c->resources);
+		goto retry_after_bus_reset;
+	}
+	if (err < 0)
+		goto err_resources;
+
+	c->connected = true;
+
+	mutex_unlock(&c->mutex);
+
+	return 0;
+
+err_resources:
+	fw_iso_resources_free(&c->resources);
+err_mutex:
+	mutex_unlock(&c->mutex);
+
+	return err;
+}
+EXPORT_SYMBOL(cmp_connection_establish);
+
+/**
+ * cmp_connection_update - update the connection after a bus reset
+ * @c: the connection manager
+ *
+ * This function must be called from the driver's .update handler to reestablish
+ * any connection that might have been active.
+ *
+ * Returns zero on success, or a negative error code.  On an error, the
+ * connection is broken and the caller must stop transmitting iso packets.
+ */
+int cmp_connection_update(struct cmp_connection *c)
+{
+	int err;
+
+	mutex_lock(&c->mutex);
+
+	if (!c->connected) {
+		mutex_unlock(&c->mutex);
+		return 0;
+	}
+
+	err = fw_iso_resources_update(&c->resources);
+	if (err < 0)
+		goto err_unconnect;
+
+	err = pcr_modify(c, ipcr_set_modify, ipcr_set_check,
+			 SUCCEED_ON_BUS_RESET);
+	if (err < 0)
+		goto err_resources;
+
+	mutex_unlock(&c->mutex);
+
+	return 0;
+
+err_resources:
+	fw_iso_resources_free(&c->resources);
+err_unconnect:
+	c->connected = false;
+	mutex_unlock(&c->mutex);
+
+	return err;
+}
+EXPORT_SYMBOL(cmp_connection_update);
+
+
+static __be32 ipcr_break_modify(struct cmp_connection *c, __be32 ipcr)
+{
+	return ipcr & ~cpu_to_be32(IPCR_BCAST_CONN | IPCR_P2P_CONN_MASK);
+}
+
+/**
+ * cmp_connection_break - break the connection to the target
+ * @c: the connection manager
+ *
+ * This function deactives the connection in the target's input plug control
+ * register, and frees the isochronous resources of the connection.  Before
+ * calling this function, the caller should cease transmitting packets.
+ */
+void cmp_connection_break(struct cmp_connection *c)
+{
+	int err;
+
+	mutex_lock(&c->mutex);
+
+	if (!c->connected) {
+		mutex_unlock(&c->mutex);
+		return;
+	}
+
+	err = pcr_modify(c, ipcr_break_modify, NULL, SUCCEED_ON_BUS_RESET);
+	if (err < 0)
+		cmp_error(c, "plug is still connected\n");
+
+	fw_iso_resources_free(&c->resources);
+
+	c->connected = false;
+
+	mutex_unlock(&c->mutex);
+}
+EXPORT_SYMBOL(cmp_connection_break);
+#ifndef SOUND_FIREWIRE_CMP_H_INCLUDED
+#define SOUND_FIREWIRE_CMP_H_INCLUDED
+
+#include <linux/mutex.h>
+#include <linux/types.h>
+#include "iso-resources.h"
+
+struct fw_unit;
+
+/**
+ * struct cmp_connection - manages an isochronous connection to a device
+ * @speed: the connection's actual speed
+ *
+ * This structure manages (using CMP) an isochronous stream from the local
+ * computer to a device's input plug (iPCR).
+ *
+ * There is no corresponding oPCR created on the local computer, so it is not
+ * possible to overlay connections on top of this one.
+ */
+struct cmp_connection {
+	int speed;
+	/* private: */
+	bool connected;
+	struct mutex mutex;
+	struct fw_iso_resources resources;
+	__be32 last_pcr_value;
+	unsigned int pcr_index;
+	unsigned int max_speed;
+};
+
+int cmp_connection_init(struct cmp_connection *connection,
+			struct fw_unit *unit,
+			unsigned int ipcr_index);
+void cmp_connection_destroy(struct cmp_connection *connection);
+
+int cmp_connection_establish(struct cmp_connection *connection,
+			     unsigned int max_payload);
+int cmp_connection_update(struct cmp_connection *connection);
+void cmp_connection_break(struct cmp_connection *connection);
+
+#endif
+/*
+ * Function Control Protocol (IEC 61883-1) helper functions
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#include <linux/device.h>
+#include <linux/firewire.h>
+#include <linux/firewire-constants.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/wait.h>
+#include "fcp.h"
+#include "lib.h"
+
+#define CTS_AVC 0x00
+
+#define ERROR_RETRIES	3
+#define ERROR_DELAY_MS	5
+#define FCP_TIMEOUT_MS	125
+
+static DEFINE_SPINLOCK(transactions_lock);
+static LIST_HEAD(transactions);
+
+enum fcp_state {
+	STATE_PENDING,
+	STATE_BUS_RESET,
+	STATE_COMPLETE,
+};
+
+struct fcp_transaction {
+	struct list_head list;
+	struct fw_unit *unit;
+	void *response_buffer;
+	unsigned int response_size;
+	unsigned int response_match_bytes;
+	enum fcp_state state;
+	wait_queue_head_t wait;
+};
+
+/**
+ * fcp_avc_transaction - send an AV/C command and wait for its response
+ * @unit: a unit on the target device
+ * @command: a buffer containing the command frame; must be DMA-able
+ * @command_size: the size of @command
+ * @response: a buffer for the response frame
+ * @response_size: the maximum size of @response
+ * @response_match_bytes: a bitmap specifying the bytes used to detect the
+ *                        correct response frame
+ *
+ * This function sends a FCP command frame to the target and waits for the
+ * corresponding response frame to be returned.
+ *
+ * Because it is possible for multiple FCP transactions to be active at the
+ * same time, the correct response frame is detected by the value of certain
+ * bytes.  These bytes must be set in @response before calling this function,
+ * and the corresponding bits must be set in @response_match_bytes.
+ *
+ * @command and @response can point to the same buffer.
+ *
+ * Asynchronous operation (INTERIM, NOTIFY) is not supported at the moment.
+ *
+ * Returns the actual size of the response frame, or a negative error code.
+ */
+int fcp_avc_transaction(struct fw_unit *unit,
+			const void *command, unsigned int command_size,
+			void *response, unsigned int response_size,
+			unsigned int response_match_bytes)
+{
+	struct fcp_transaction t;
+	int tcode, ret, tries = 0;
+
+	t.unit = unit;
+	t.response_buffer = response;
+	t.response_size = response_size;
+	t.response_match_bytes = response_match_bytes;
+	t.state = STATE_PENDING;
+	init_waitqueue_head(&t.wait);
+
+	spin_lock_irq(&transactions_lock);
+	list_add_tail(&t.list, &transactions);
+	spin_unlock_irq(&transactions_lock);
+
+	for (;;) {
+		tcode = command_size == 4 ? TCODE_WRITE_QUADLET_REQUEST
+					  : TCODE_WRITE_BLOCK_REQUEST;
+		ret = snd_fw_transaction(t.unit, tcode,
+					 CSR_REGISTER_BASE + CSR_FCP_COMMAND,
+					 (void *)command, command_size);
+		if (ret < 0)
+			break;
+
+		wait_event_timeout(t.wait, t.state != STATE_PENDING,
+				   msecs_to_jiffies(FCP_TIMEOUT_MS));
+
+		if (t.state == STATE_COMPLETE) {
+			ret = t.response_size;
+			break;
+		} else if (t.state == STATE_BUS_RESET) {
+			msleep(ERROR_DELAY_MS);
+		} else if (++tries >= ERROR_RETRIES) {
+			dev_err(&t.unit->device, "FCP command timed out\n");
+			ret = -EIO;
+			break;
+		}
+	}
+
+	spin_lock_irq(&transactions_lock);
+	list_del(&t.list);
+	spin_unlock_irq(&transactions_lock);
+
+	return ret;
+}
+EXPORT_SYMBOL(fcp_avc_transaction);
+
+/**
+ * fcp_bus_reset - inform the target handler about a bus reset
+ * @unit: the unit that might be used by fcp_avc_transaction()
+ *
+ * This function must be called from the driver's .update handler to inform
+ * the FCP transaction handler that a bus reset has happened.  Any pending FCP
+ * transactions are retried.
+ */
+void fcp_bus_reset(struct fw_unit *unit)
+{
+	struct fcp_transaction *t;
+
+	spin_lock_irq(&transactions_lock);
+	list_for_each_entry(t, &transactions, list) {
+		if (t->unit == unit &&
+		    t->state == STATE_PENDING) {
+			t->state = STATE_BUS_RESET;
+			wake_up(&t->wait);
+		}
+	}
+	spin_unlock_irq(&transactions_lock);
+}
+EXPORT_SYMBOL(fcp_bus_reset);
+
+/* checks whether the response matches the masked bytes in response_buffer */
+static bool is_matching_response(struct fcp_transaction *transaction,
+				 const void *response, size_t length)
+{
+	const u8 *p1, *p2;
+	unsigned int mask, i;
+
+	p1 = response;
+	p2 = transaction->response_buffer;
+	mask = transaction->response_match_bytes;
+
+	for (i = 0; ; ++i) {
+		if ((mask & 1) && p1[i] != p2[i])
+			return false;
+		mask >>= 1;
+		if (!mask)
+			return true;
+		if (--length == 0)
+			return false;
+	}
+}
+
+static void fcp_response(struct fw_card *card, struct fw_request *request,
+			 int tcode, int destination, int source,
+			 int generation, unsigned long long offset,
+			 void *data, size_t length, void *callback_data)
+{
+	struct fcp_transaction *t;
+	unsigned long flags;
+
+	if (length < 1 || (*(const u8 *)data & 0xf0) != CTS_AVC)
+		return;
+
+	spin_lock_irqsave(&transactions_lock, flags);
+	list_for_each_entry(t, &transactions, list) {
+		struct fw_device *device = fw_parent_device(t->unit);
+		if (device->card != card ||
+		    device->generation != generation)
+			continue;
+		smp_rmb(); /* node_id vs. generation */
+		if (device->node_id != source)
+			continue;
+
+		if (t->state == STATE_PENDING &&
+		    is_matching_response(t, data, length)) {
+			t->state = STATE_COMPLETE;
+			t->response_size = min((unsigned int)length,
+					       t->response_size);
+			memcpy(t->response_buffer, data, t->response_size);
+			wake_up(&t->wait);
+		}
+	}
+	spin_unlock_irqrestore(&transactions_lock, flags);
+}
+
+static struct fw_address_handler response_register_handler = {
+	.length = 0x200,
+	.address_callback = fcp_response,
+};
+
+static int __init fcp_module_init(void)
+{
+	static const struct fw_address_region response_register_region = {
+		.start = CSR_REGISTER_BASE + CSR_FCP_RESPONSE,
+		.end = CSR_REGISTER_BASE + CSR_FCP_END,
+	};
+
+	fw_core_add_address_handler(&response_register_handler,
+				    &response_register_region);
+
+	return 0;
+}
+
+static void __exit fcp_module_exit(void)
+{
+	WARN_ON(!list_empty(&transactions));
+	fw_core_remove_address_handler(&response_register_handler);
+}
+
+module_init(fcp_module_init);
+module_exit(fcp_module_exit);
+#ifndef SOUND_FIREWIRE_FCP_H_INCLUDED
+#define SOUND_FIREWIRE_FCP_H_INCLUDED
+
+struct fw_unit;
+
+int fcp_avc_transaction(struct fw_unit *unit,
+			const void *command, unsigned int command_size,
+			void *response, unsigned int response_size,
+			unsigned int response_match_bytes);
+void fcp_bus_reset(struct fw_unit *unit);
+
+#endif
+/*
+ * isochronous resources helper functions
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#include <linux/device.h>
+#include <linux/firewire.h>
+#include <linux/firewire-constants.h>
+#include <linux/jiffies.h>
+#include <linux/mutex.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include "iso-resources.h"
+
+/**
+ * fw_iso_resources_init - initializes a &struct fw_iso_resources
+ * @r: the resource manager to initialize
+ * @unit: the device unit for which the resources will be needed
+ *
+ * If the device does not support all channel numbers, change @r->channels_mask
+ * after calling this function.
+ */
+void fw_iso_resources_init(struct fw_iso_resources *r, struct fw_unit *unit)
+{
+	r->channels_mask = ~0uLL;
+	r->unit = fw_unit_get(unit);
+	mutex_init(&r->mutex);
+	r->allocated = false;
+}
+
+/**
+ * fw_iso_resources_destroy - destroy a resource manager
+ * @r: the resource manager that is no longer needed
+ */
+void fw_iso_resources_destroy(struct fw_iso_resources *r)
+{
+	WARN_ON(r->allocated);
+	mutex_destroy(&r->mutex);
+	fw_unit_put(r->unit);
+}
+
+static unsigned int packet_bandwidth(unsigned int max_payload_bytes, int speed)
+{
+	unsigned int bytes, s400_bytes;
+
+	/* iso packets have three header quadlets and quadlet-aligned payload */
+	bytes = 3 * 4 + ALIGN(max_payload_bytes, 4);
+
+	/* convert to bandwidth units (quadlets at S1600 = bytes at S400) */
+	if (speed <= SCODE_400)
+		s400_bytes = bytes * (1 << (SCODE_400 - speed));
+	else
+		s400_bytes = DIV_ROUND_UP(bytes, 1 << (speed - SCODE_400));
+
+	return s400_bytes;
+}
+
+static int current_bandwidth_overhead(struct fw_card *card)
+{
+	/*
+	 * Under the usual pessimistic assumption (cable length 4.5 m), the
+	 * isochronous overhead for N cables is 1.797 µs + N * 0.494 µs, or
+	 * 88.3 + N * 24.3 in bandwidth units.
+	 *
+	 * The calculation below tries to deduce N from the current gap count.
+	 * If the gap count has been optimized by measuring the actual packet
+	 * transmission time, this derived overhead should be near the actual
+	 * overhead as well.
+	 */
+	return card->gap_count < 63 ? card->gap_count * 97 / 10 + 89 : 512;
+}
+
+static int wait_isoch_resource_delay_after_bus_reset(struct fw_card *card)
+{
+	for (;;) {
+		s64 delay = (card->reset_jiffies + HZ) - get_jiffies_64();
+		if (delay <= 0)
+			return 0;
+		if (schedule_timeout_interruptible(delay) > 0)
+			return -ERESTARTSYS;
+	}
+}
+
+/**
+ * fw_iso_resources_allocate - allocate isochronous channel and bandwidth
+ * @r: the resource manager
+ * @max_payload_bytes: the amount of data (including CIP headers) per packet
+ * @speed: the speed (e.g., SCODE_400) at which the packets will be sent
+ *
+ * This function allocates one isochronous channel and enough bandwidth for the
+ * specified packet size.
+ *
+ * Returns the channel number that the caller must use for streaming, or
+ * a negative error code.  Due to potentionally long delays, this function is
+ * interruptible and can return -ERESTARTSYS.  On success, the caller is
+ * responsible for calling fw_iso_resources_update() on bus resets, and
+ * fw_iso_resources_free() when the resources are not longer needed.
+ */
+int fw_iso_resources_allocate(struct fw_iso_resources *r,
+			      unsigned int max_payload_bytes, int speed)
+{
+	struct fw_card *card = fw_parent_device(r->unit)->card;
+	int bandwidth, channel, err;
+
+	if (WARN_ON(r->allocated))
+		return -EBADFD;
+
+	r->bandwidth = packet_bandwidth(max_payload_bytes, speed);
+
+retry_after_bus_reset:
+	spin_lock_irq(&card->lock);
+	r->generation = card->generation;
+	r->bandwidth_overhead = current_bandwidth_overhead(card);
+	spin_unlock_irq(&card->lock);
+
+	err = wait_isoch_resource_delay_after_bus_reset(card);
+	if (err < 0)
+		return err;
+
+	mutex_lock(&r->mutex);
+
+	bandwidth = r->bandwidth + r->bandwidth_overhead;
+	fw_iso_resource_manage(card, r->generation, r->channels_mask,
+			       &channel, &bandwidth, true, r->buffer);
+	if (channel == -EAGAIN) {
+		mutex_unlock(&r->mutex);
+		goto retry_after_bus_reset;
+	}
+	if (channel >= 0) {
+		r->channel = channel;
+		r->allocated = true;
+	} else {
+		if (channel == -EBUSY)
+			dev_err(&r->unit->device,
+				"isochronous resources exhausted\n");
+		else
+			dev_err(&r->unit->device,
+				"isochronous resource allocation failed\n");
+	}
+
+	mutex_unlock(&r->mutex);
+
+	return channel;
+}
+
+/**
+ * fw_iso_resources_update - update resource allocations after a bus reset
+ * @r: the resource manager
+ *
+ * This function must be called from the driver's .update handler to reallocate
+ * any resources that were allocated before the bus reset.  It is safe to call
+ * this function if no resources are currently allocated.
+ *
+ * Returns a negative error code on failure.  If this happens, the caller must
+ * stop streaming.
+ */
+int fw_iso_resources_update(struct fw_iso_resources *r)
+{
+	struct fw_card *card = fw_parent_device(r->unit)->card;
+	int bandwidth, channel;
+
+	mutex_lock(&r->mutex);
+
+	if (!r->allocated) {
+		mutex_unlock(&r->mutex);
+		return 0;
+	}
+
+	spin_lock_irq(&card->lock);
+	r->generation = card->generation;
+	r->bandwidth_overhead = current_bandwidth_overhead(card);
+	spin_unlock_irq(&card->lock);
+
+	bandwidth = r->bandwidth + r->bandwidth_overhead;
+
+	fw_iso_resource_manage(card, r->generation, 1uLL << r->channel,
+			       &channel, &bandwidth, true, r->buffer);
+	/*
+	 * When another bus reset happens, pretend that the allocation
+	 * succeeded; we will try again for the new generation later.
+	 */
+	if (channel < 0 && channel != -EAGAIN) {
+		r->allocated = false;
+		if (channel == -EBUSY)
+			dev_err(&r->unit->device,
+				"isochronous resources exhausted\n");
+		else
+			dev_err(&r->unit->device,
+				"isochronous resource allocation failed\n");
+	}
+
+	mutex_unlock(&r->mutex);
+
+	return channel;
+}
+
+/**
+ * fw_iso_resources_free - frees allocated resources
+ * @r: the resource manager
+ *
+ * This function deallocates the channel and bandwidth, if allocated.
+ */
+void fw_iso_resources_free(struct fw_iso_resources *r)
+{
+	struct fw_card *card = fw_parent_device(r->unit)->card;
+	int bandwidth, channel;
+
+	mutex_lock(&r->mutex);
+
+	if (r->allocated) {
+		bandwidth = r->bandwidth + r->bandwidth_overhead;
+		fw_iso_resource_manage(card, r->generation, 1uLL << r->channel,
+				       &channel, &bandwidth, false, r->buffer);
+		if (channel < 0)
+			dev_err(&r->unit->device,
+				"isochronous resource deallocation failed\n");
+
+		r->allocated = false;
+	}
+
+	mutex_unlock(&r->mutex);
+}
+#ifndef SOUND_FIREWIRE_ISO_RESOURCES_H_INCLUDED
+#define SOUND_FIREWIRE_ISO_RESOURCES_H_INCLUDED
+
+#include <linux/mutex.h>
+#include <linux/types.h>
+
+struct fw_unit;
+
+/**
+ * struct fw_iso_resources - manages channel/bandwidth allocation
+ * @channels_mask: if the device does not support all channel numbers, set this
+ *                 bit mask to something else than the default (all ones)
+ *
+ * This structure manages (de)allocation of isochronous resources (channel and
+ * bandwidth) for one isochronous stream.
+ */
+struct fw_iso_resources {
+	u64 channels_mask;
+	/* private: */
+	struct fw_unit *unit;
+	struct mutex mutex;
+	unsigned int channel;
+	unsigned int bandwidth; /* in bandwidth units, without overhead */
+	unsigned int bandwidth_overhead;
+	int generation; /* in which allocation is valid */
+	bool allocated;
+	__be32 buffer[2];
+};
+
+void fw_iso_resources_init(struct fw_iso_resources *r,
+			   struct fw_unit *unit);
+void fw_iso_resources_destroy(struct fw_iso_resources *r);
+
+int fw_iso_resources_allocate(struct fw_iso_resources *r,
+			      unsigned int max_payload_bytes, int speed);
+int fw_iso_resources_update(struct fw_iso_resources *r);
+void fw_iso_resources_free(struct fw_iso_resources *r);
+
+#endif
+/*
+ * miscellaneous helper functions
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/firewire.h>
+#include <linux/module.h>
+#include "lib.h"
+
+#define ERROR_RETRY_DELAY_MS	5
+
+/**
+ * rcode_string - convert a firewire result code to a string
+ * @rcode: the result
+ */
+const char *rcode_string(unsigned int rcode)
+{
+	static const char *const names[] = {
+		[RCODE_COMPLETE]	= "complete",
+		[RCODE_CONFLICT_ERROR]	= "conflict error",
+		[RCODE_DATA_ERROR]	= "data error",
+		[RCODE_TYPE_ERROR]	= "type error",
+		[RCODE_ADDRESS_ERROR]	= "address error",
+		[RCODE_SEND_ERROR]	= "send error",
+		[RCODE_CANCELLED]	= "cancelled",
+		[RCODE_BUSY]		= "busy",
+		[RCODE_GENERATION]	= "generation",
+		[RCODE_NO_ACK]		= "no ack",
+	};
+
+	if (rcode < ARRAY_SIZE(names) && names[rcode])
+		return names[rcode];
+	else
+		return "unknown";
+}
+EXPORT_SYMBOL(rcode_string);
+
+/**
+ * snd_fw_transaction - send a request and wait for its completion
+ * @unit: the driver's unit on the target device
+ * @tcode: the transaction code
+ * @offset: the address in the target's address space
+ * @buffer: input/output data
+ * @length: length of @buffer
+ *
+ * Submits an asynchronous request to the target device, and waits for the
+ * response.  The node ID and the current generation are derived from @unit.
+ * On a bus reset or an error, the transaction is retried a few times.
+ * Returns zero on success, or a negative error code.
+ */
+int snd_fw_transaction(struct fw_unit *unit, int tcode,
+		       u64 offset, void *buffer, size_t length)
+{
+	struct fw_device *device = fw_parent_device(unit);
+	int generation, rcode, tries = 0;
+
+	for (;;) {
+		generation = device->generation;
+		smp_rmb(); /* node_id vs. generation */
+		rcode = fw_run_transaction(device->card, tcode,
+					   device->node_id, generation,
+					   device->max_speed, offset,
+					   buffer, length);
+
+		if (rcode == RCODE_COMPLETE)
+			return 0;
+
+		if (rcode_is_permanent_error(rcode) || ++tries >= 3) {
+			dev_err(&unit->device, "transaction failed: %s\n",
+				rcode_string(rcode));
+			return -EIO;
+		}
+
+		msleep(ERROR_RETRY_DELAY_MS);
+	}
+}
+EXPORT_SYMBOL(snd_fw_transaction);
+
+MODULE_DESCRIPTION("FireWire audio helper functions");
+MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
+MODULE_LICENSE("GPL v2");
+#ifndef SOUND_FIREWIRE_LIB_H_INCLUDED
+#define SOUND_FIREWIRE_LIB_H_INCLUDED
+
+#include <linux/firewire-constants.h>
+#include <linux/types.h>
+
+struct fw_unit;
+
+int snd_fw_transaction(struct fw_unit *unit, int tcode,
+		       u64 offset, void *buffer, size_t length);
+const char *rcode_string(unsigned int rcode);
+
+/* returns true if retrying the transaction would not make sense */
+static inline bool rcode_is_permanent_error(int rcode)
+{
+	return rcode == RCODE_TYPE_ERROR || rcode == RCODE_ADDRESS_ERROR;
+}
+
+#endif
+/*
+ * helpers for managing a buffer for many packets
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#include <linux/firewire.h>
+#include <linux/slab.h>
+#include "packets-buffer.h"
+
+/**
+ * iso_packets_buffer_init - allocates the memory for packets
+ * @b: the buffer structure to initialize
+ * @unit: the device at the other end of the stream
+ * @count: the number of packets
+ * @packet_size: the (maximum) size of a packet, in bytes
+ * @direction: %DMA_TO_DEVICE or %DMA_FROM_DEVICE
+ */
+int iso_packets_buffer_init(struct iso_packets_buffer *b, struct fw_unit *unit,
+			    unsigned int count, unsigned int packet_size,
+			    enum dma_data_direction direction)
+{
+	unsigned int packets_per_page, pages;
+	unsigned int i, page_index, offset_in_page;
+	void *p;
+	int err;
+
+	b->packets = kmalloc(count * sizeof(*b->packets), GFP_KERNEL);
+	if (!b->packets) {
+		err = -ENOMEM;
+		goto error;
+	}
+
+	packet_size = L1_CACHE_ALIGN(packet_size);
+	packets_per_page = PAGE_SIZE / packet_size;
+	if (WARN_ON(!packets_per_page)) {
+		err = -EINVAL;
+		goto error;
+	}
+	pages = DIV_ROUND_UP(count, packets_per_page);
+
+	err = fw_iso_buffer_init(&b->iso_buffer, fw_parent_device(unit)->card,
+				 pages, direction);
+	if (err < 0)
+		goto err_packets;
+
+	for (i = 0; i < count; ++i) {
+		page_index = i / packets_per_page;
+		p = page_address(b->iso_buffer.pages[page_index]);
+		offset_in_page = (i % packets_per_page) * packet_size;
+		b->packets[i].buffer = p + offset_in_page;
+		b->packets[i].offset = page_index * PAGE_SIZE + offset_in_page;
+	}
+
+	return 0;
+
+err_packets:
+	kfree(b->packets);
+error:
+	return err;
+}
+
+/**
+ * iso_packets_buffer_destroy - frees packet buffer resources
+ * @b: the buffer structure to free
+ * @unit: the device at the other end of the stream
+ */
+void iso_packets_buffer_destroy(struct iso_packets_buffer *b,
+				struct fw_unit *unit)
+{
+	fw_iso_buffer_destroy(&b->iso_buffer, fw_parent_device(unit)->card);
+	kfree(b->packets);
+}
+#ifndef SOUND_FIREWIRE_PACKETS_BUFFER_H_INCLUDED
+#define SOUND_FIREWIRE_PACKETS_BUFFER_H_INCLUDED
+
+#include <linux/dma-mapping.h>
+#include <linux/firewire.h>
+
+/**
+ * struct iso_packets_buffer - manages a buffer for many packets
+ * @iso_buffer: the memory containing the packets
+ * @packets: an array, with each element pointing to one packet
+ */
+struct iso_packets_buffer {
+	struct fw_iso_buffer iso_buffer;
+	struct {
+		void *buffer;
+		unsigned int offset;
+	} *packets;
+};
+
+int iso_packets_buffer_init(struct iso_packets_buffer *b, struct fw_unit *unit,
+			    unsigned int count, unsigned int packet_size,
+			    enum dma_data_direction direction);
+void iso_packets_buffer_destroy(struct iso_packets_buffer *b,
+				struct fw_unit *unit);
+
+#endif
+/*
+ * OXFW970-based speakers driver
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ * Licensed under the terms of the GNU General Public License, version 2.
+ */
+
+#include <linux/device.h>
+#include <linux/firewire.h>
+#include <linux/firewire-constants.h>
+#include <linux/module.h>
+#include <linux/mod_devicetable.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <sound/control.h>
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include "cmp.h"
+#include "fcp.h"
+#include "amdtp.h"
+#include "lib.h"
+
+#define OXFORD_FIRMWARE_ID_ADDRESS	(CSR_REGISTER_BASE + 0x50000)
+/* 0x970?vvvv or 0x971?vvvv, where vvvv = firmware version */
+
+#define OXFORD_HARDWARE_ID_ADDRESS	(CSR_REGISTER_BASE + 0x90020)
+#define OXFORD_HARDWARE_ID_OXFW970	0x39443841
+#define OXFORD_HARDWARE_ID_OXFW971	0x39373100
+
+#define VENDOR_GRIFFIN		0x001292
+#define VENDOR_LACIE		0x00d04b
+
+#define SPECIFIER_1394TA	0x00a02d
+#define VERSION_AVC		0x010001
+
+struct device_info {
+	const char *driver_name;
+	const char *short_name;
+	const char *long_name;
+	int (*pcm_constraints)(struct snd_pcm_runtime *runtime);
+	unsigned int mixer_channels;
+	u8 mute_fb_id;
+	u8 volume_fb_id;
+};
+
+struct fwspk {
+	struct snd_card *card;
+	struct fw_unit *unit;
+	const struct device_info *device_info;
+	struct snd_pcm_substream *pcm;
+	struct mutex mutex;
+	struct cmp_connection connection;
+	struct amdtp_out_stream stream;
+	bool stream_running;
+	bool mute;
+	s16 volume[6];
+	s16 volume_min;
+	s16 volume_max;
+};
+
+MODULE_DESCRIPTION("FireWire speakers driver");
+MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
+MODULE_LICENSE("GPL v2");
+
+static int firewave_rate_constraint(struct snd_pcm_hw_params *params,
+				    struct snd_pcm_hw_rule *rule)
+{
+	static unsigned int stereo_rates[] = { 48000, 96000 };
+	struct snd_interval *channels =
+			hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+	struct snd_interval *rate =
+			hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+
+	/* two channels work only at 48/96 kHz */
+	if (snd_interval_max(channels) < 6)
+		return snd_interval_list(rate, 2, stereo_rates, 0);
+	return 0;
+}
+
+static int firewave_channels_constraint(struct snd_pcm_hw_params *params,
+					struct snd_pcm_hw_rule *rule)
+{
+	static const struct snd_interval all_channels = { .min = 6, .max = 6 };
+	struct snd_interval *rate =
+			hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+	struct snd_interval *channels =
+			hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+
+	/* 32/44.1 kHz work only with all six channels */
+	if (snd_interval_max(rate) < 48000)
+		return snd_interval_refine(channels, &all_channels);
+	return 0;
+}
+
+static int firewave_constraints(struct snd_pcm_runtime *runtime)
+{
+	static unsigned int channels_list[] = { 2, 6 };
+	static struct snd_pcm_hw_constraint_list channels_list_constraint = {
+		.count = 2,
+		.list = channels_list,
+	};
+	int err;
+
+	runtime->hw.rates = SNDRV_PCM_RATE_32000 |
+			    SNDRV_PCM_RATE_44100 |
+			    SNDRV_PCM_RATE_48000 |
+			    SNDRV_PCM_RATE_96000;
+	runtime->hw.channels_max = 6;
+
+	err = snd_pcm_hw_constraint_list(runtime, 0,
+					 SNDRV_PCM_HW_PARAM_CHANNELS,
+					 &channels_list_constraint);
+	if (err < 0)
+		return err;
+	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
+				  firewave_rate_constraint, NULL,
+				  SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+	if (err < 0)
+		return err;
+	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
+				  firewave_channels_constraint, NULL,
+				  SNDRV_PCM_HW_PARAM_RATE, -1);
+	if (err < 0)
+		return err;
+
+	return 0;
+}
+
+static int lacie_speakers_constraints(struct snd_pcm_runtime *runtime)
+{
+	runtime->hw.rates = SNDRV_PCM_RATE_32000 |
+			    SNDRV_PCM_RATE_44100 |
+			    SNDRV_PCM_RATE_48000 |
+			    SNDRV_PCM_RATE_88200 |
+			    SNDRV_PCM_RATE_96000;
+
+	return 0;
+}
+
+static int fwspk_open(struct snd_pcm_substream *substream)
+{
+	static const struct snd_pcm_hardware hardware = {
+		.info = SNDRV_PCM_INFO_MMAP |
+			SNDRV_PCM_INFO_MMAP_VALID |
+			SNDRV_PCM_INFO_BATCH |
+			SNDRV_PCM_INFO_INTERLEAVED |
+			SNDRV_PCM_INFO_BLOCK_TRANSFER,
+		.formats = AMDTP_OUT_PCM_FORMAT_BITS,
+		.channels_min = 2,
+		.channels_max = 2,
+		.buffer_bytes_max = 4 * 1024 * 1024,
+		.period_bytes_min = 1,
+		.period_bytes_max = UINT_MAX,
+		.periods_min = 1,
+		.periods_max = UINT_MAX,
+	};
+	struct fwspk *fwspk = substream->private_data;
+	struct snd_pcm_runtime *runtime = substream->runtime;
+	int err;
+
+	runtime->hw = hardware;
+
+	err = fwspk->device_info->pcm_constraints(runtime);
+	if (err < 0)
+		return err;
+	err = snd_pcm_limit_hw_rates(runtime);
+	if (err < 0)
+		return err;
+
+	err = snd_pcm_hw_constraint_minmax(runtime,
+					   SNDRV_PCM_HW_PARAM_PERIOD_TIME,
+					   5000, 8192000);
+	if (err < 0)
+		return err;
+
+	err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
+	if (err < 0)
+		return err;
+
+	return 0;
+}
+
+static int fwspk_close(struct snd_pcm_substream *substream)
+{
+	return 0;
+}
+
+static void fwspk_stop_stream(struct fwspk *fwspk)
+{
+	if (fwspk->stream_running) {
+		amdtp_out_stream_stop(&fwspk->stream);
+		cmp_connection_break(&fwspk->connection);
+		fwspk->stream_running = false;
+	}
+}
+
+static int fwspk_set_rate(struct fwspk *fwspk, unsigned int sfc)
+{
+	u8 *buf;
+	int err;
+
+	buf = kmalloc(8, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	buf[0] = 0x00;		/* AV/C, CONTROL */
+	buf[1] = 0xff;		/* unit */
+	buf[2] = 0x19;		/* INPUT PLUG SIGNAL FORMAT */
+	buf[3] = 0x00;		/* plug 0 */
+	buf[4] = 0x90;		/* format: audio */
+	buf[5] = 0x00 | sfc;	/* AM824, frequency */
+	buf[6] = 0xff;		/* SYT (not used) */
+	buf[7] = 0xff;
+
+	err = fcp_avc_transaction(fwspk->unit, buf, 8, buf, 8,
+				  BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(5));
+	if (err < 0)
+		goto error;
+	if (err < 6 || buf[0] != 0x09 /* ACCEPTED */) {
+		dev_err(&fwspk->unit->device, "failed to set sample rate\n");
+		err = -EIO;
+		goto error;
+	}
+
+	err = 0;
+
+error:
+	kfree(buf);
+
+	return err;
+}
+
+static int fwspk_hw_params(struct snd_pcm_substream *substream,
+			   struct snd_pcm_hw_params *hw_params)
+{
+	struct fwspk *fwspk = substream->private_data;
+	int err;
+
+	mutex_lock(&fwspk->mutex);
+	fwspk_stop_stream(fwspk);
+	mutex_unlock(&fwspk->mutex);
+
+	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
+					       params_buffer_bytes(hw_params));
+	if (err < 0)
+		goto error;
+
+	amdtp_out_stream_set_rate(&fwspk->stream, params_rate(hw_params));
+	amdtp_out_stream_set_pcm(&fwspk->stream, params_channels(hw_params));
+
+	amdtp_out_stream_set_pcm_format(&fwspk->stream,
+					params_format(hw_params));
+
+	err = fwspk_set_rate(fwspk, fwspk->stream.sfc);
+	if (err < 0)
+		goto err_buffer;
+
+	return 0;
+
+err_buffer:
+	snd_pcm_lib_free_vmalloc_buffer(substream);
+error:
+	return err;
+}
+
+static int fwspk_hw_free(struct snd_pcm_substream *substream)
+{
+	struct fwspk *fwspk = substream->private_data;
+
+	mutex_lock(&fwspk->mutex);
+	fwspk_stop_stream(fwspk);
+	mutex_unlock(&fwspk->mutex);
+
+	return snd_pcm_lib_free_vmalloc_buffer(substream);
+}
+
+static int fwspk_prepare(struct snd_pcm_substream *substream)
+{
+	struct fwspk *fwspk = substream->private_data;
+	int err;
+
+	mutex_lock(&fwspk->mutex);
+
+	if (!fwspk->stream_running) {
+		err = cmp_connection_establish(&fwspk->connection,
+			amdtp_out_stream_get_max_payload(&fwspk->stream));
+		if (err < 0)
+			goto err_mutex;
+
+		err = amdtp_out_stream_start(&fwspk->stream,
+					fwspk->connection.resources.channel,
+					fwspk->connection.speed);
+		if (err < 0)
+			goto err_connection;
+
+		fwspk->stream_running = true;
+	}
+
+	mutex_unlock(&fwspk->mutex);
+
+	amdtp_out_stream_pcm_prepare(&fwspk->stream);
+
+	return 0;
+
+err_connection:
+	cmp_connection_break(&fwspk->connection);
+err_mutex:
+	mutex_unlock(&fwspk->mutex);
+
+	return err;
+}
+
+static int fwspk_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+	struct fwspk *fwspk = substream->private_data;
+	struct snd_pcm_substream *pcm;
+
+	switch (cmd) {
+	case SNDRV_PCM_TRIGGER_START:
+		pcm = substream;
+		break;
+	case SNDRV_PCM_TRIGGER_STOP:
+		pcm = NULL;
+		break;
+	default:
+		return -EINVAL;
+	}
+	amdtp_out_stream_pcm_trigger(&fwspk->stream, pcm);
+	return 0;
+}
+
+static snd_pcm_uframes_t fwspk_pointer(struct snd_pcm_substream *substream)
+{
+	struct fwspk *fwspk = substream->private_data;
+
+	return amdtp_out_stream_pcm_pointer(&fwspk->stream);
+}
+
+static int fwspk_create_pcm(struct fwspk *fwspk)
+{
+	static struct snd_pcm_ops ops = {
+		.open      = fwspk_open,
+		.close     = fwspk_close,
+		.ioctl     = snd_pcm_lib_ioctl,
+		.hw_params = fwspk_hw_params,
+		.hw_free   = fwspk_hw_free,
+		.prepare   = fwspk_prepare,
+		.trigger   = fwspk_trigger,
+		.pointer   = fwspk_pointer,
+		.page      = snd_pcm_lib_get_vmalloc_page,
+		.mmap      = snd_pcm_lib_mmap_vmalloc,
+	};
+	struct snd_pcm *pcm;
+	int err;
+
+	err = snd_pcm_new(fwspk->card, "OXFW970", 0, 1, 0, &pcm);
+	if (err < 0)
+		return err;
+	pcm->private_data = fwspk;
+	strcpy(pcm->name, fwspk->device_info->short_name);
+	fwspk->pcm = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
+	fwspk->pcm->ops = &ops;
+	return 0;
+}
+
+enum control_action { CTL_READ, CTL_WRITE };
+enum control_attribute {
+	CTL_MIN		= 0x02,
+	CTL_MAX		= 0x03,
+	CTL_CURRENT	= 0x10,
+};
+
+static int fwspk_mute_command(struct fwspk *fwspk, bool *value,
+			      enum control_action action)
+{
+	u8 *buf;
+	u8 response_ok;
+	int err;
+
+	buf = kmalloc(11, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	if (action == CTL_READ) {
+		buf[0] = 0x01;		/* AV/C, STATUS */
+		response_ok = 0x0c;	/*       STABLE */
+	} else {
+		buf[0] = 0x00;		/* AV/C, CONTROL */
+		response_ok = 0x09;	/*       ACCEPTED */
+	}
+	buf[1] = 0x08;			/* audio unit 0 */
+	buf[2] = 0xb8;			/* FUNCTION BLOCK */
+	buf[3] = 0x81;			/* function block type: feature */
+	buf[4] = fwspk->device_info->mute_fb_id; /* function block ID */
+	buf[5] = 0x10;			/* control attribute: current */
+	buf[6] = 0x02;			/* selector length */
+	buf[7] = 0x00;			/* audio channel number */
+	buf[8] = 0x01;			/* control selector: mute */
+	buf[9] = 0x01;			/* control data length */
+	if (action == CTL_READ)
+		buf[10] = 0xff;
+	else
+		buf[10] = *value ? 0x70 : 0x60;
+
+	err = fcp_avc_transaction(fwspk->unit, buf, 11, buf, 11, 0x3fe);
+	if (err < 0)
+		goto error;
+	if (err < 11) {
+		dev_err(&fwspk->unit->device, "short FCP response\n");
+		err = -EIO;
+		goto error;
+	}
+	if (buf[0] != response_ok) {
+		dev_err(&fwspk->unit->device, "mute command failed\n");
+		err = -EIO;
+		goto error;
+	}
+	if (action == CTL_READ)
+		*value = buf[10] == 0x70;
+
+	err = 0;
+
+error:
+	kfree(buf);
+
+	return err;
+}
+
+static int fwspk_volume_command(struct fwspk *fwspk, s16 *value,
+				unsigned int channel,
+				enum control_attribute attribute,
+				enum control_action action)
+{
+	u8 *buf;
+	u8 response_ok;
+	int err;
+
+	buf = kmalloc(12, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	if (action == CTL_READ) {
+		buf[0] = 0x01;		/* AV/C, STATUS */
+		response_ok = 0x0c;	/*       STABLE */
+	} else {
+		buf[0] = 0x00;		/* AV/C, CONTROL */
+		response_ok = 0x09;	/*       ACCEPTED */
+	}
+	buf[1] = 0x08;			/* audio unit 0 */
+	buf[2] = 0xb8;			/* FUNCTION BLOCK */
+	buf[3] = 0x81;			/* function block type: feature */
+	buf[4] = fwspk->device_info->volume_fb_id; /* function block ID */
+	buf[5] = attribute;		/* control attribute */
+	buf[6] = 0x02;			/* selector length */
+	buf[7] = channel;		/* audio channel number */
+	buf[8] = 0x02;			/* control selector: volume */
+	buf[9] = 0x02;			/* control data length */
+	if (action == CTL_READ) {
+		buf[10] = 0xff;
+		buf[11] = 0xff;
+	} else {
+		buf[10] = *value >> 8;
+		buf[11] = *value;
+	}
+
+	err = fcp_avc_transaction(fwspk->unit, buf, 12, buf, 12, 0x3fe);
+	if (err < 0)
+		goto error;
+	if (err < 12) {
+		dev_err(&fwspk->unit->device, "short FCP response\n");
+		err = -EIO;
+		goto error;
+	}
+	if (buf[0] != response_ok) {
+		dev_err(&fwspk->unit->device, "volume command failed\n");
+		err = -EIO;
+		goto error;
+	}
+	if (action == CTL_READ)
+		*value = (buf[10] << 8) | buf[11];
+
+	err = 0;
+
+error:
+	kfree(buf);
+
+	return err;
+}
+
+static int fwspk_mute_get(struct snd_kcontrol *control,
+			  struct snd_ctl_elem_value *value)
+{
+	struct fwspk *fwspk = control->private_data;
+
+	value->value.integer.value[0] = !fwspk->mute;
+
+	return 0;
+}
+
+static int fwspk_mute_put(struct snd_kcontrol *control,
+			  struct snd_ctl_elem_value *value)
+{
+	struct fwspk *fwspk = control->private_data;
+	bool mute;
+	int err;
+
+	mute = !value->value.integer.value[0];
+
+	if (mute == fwspk->mute)
+		return 0;
+
+	err = fwspk_mute_command(fwspk, &mute, CTL_WRITE);
+	if (err < 0)
+		return err;
+	fwspk->mute = mute;
+
+	return 1;
+}
+
+static int fwspk_volume_info(struct snd_kcontrol *control,
+			     struct snd_ctl_elem_info *info)
+{
+	struct fwspk *fwspk = control->private_data;
+
+	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+	info->count = fwspk->device_info->mixer_channels;
+	info->value.integer.min = fwspk->volume_min;
+	info->value.integer.max = fwspk->volume_max;
+
+	return 0;
+}
+
+static const u8 channel_map[6] = { 0, 1, 4, 5, 2, 3 };
+
+static int fwspk_volume_get(struct snd_kcontrol *control,
+			    struct snd_ctl_elem_value *value)
+{
+	struct fwspk *fwspk = control->private_data;
+	unsigned int i;
+
+	for (i = 0; i < fwspk->device_info->mixer_channels; ++i)
+		value->value.integer.value[channel_map[i]] = fwspk->volume[i];
+
+	return 0;
+}
+
+static int fwspk_volume_put(struct snd_kcontrol *control,
+			  struct snd_ctl_elem_value *value)
+{
+	struct fwspk *fwspk = control->private_data;
+	unsigned int i, changed_channels;
+	bool equal_values = true;
+	s16 volume;
+	int err;
+
+	for (i = 0; i < fwspk->device_info->mixer_channels; ++i) {
+		if (value->value.integer.value[i] < fwspk->volume_min ||
+		    value->value.integer.value[i] > fwspk->volume_max)
+			return -EINVAL;
+		if (value->value.integer.value[i] !=
+		    value->value.integer.value[0])
+			equal_values = false;
+	}
+
+	changed_channels = 0;
+	for (i = 0; i < fwspk->device_info->mixer_channels; ++i)
+		if (value->value.integer.value[channel_map[i]] !=
+							fwspk->volume[i])
+			changed_channels |= 1 << (i + 1);
+
+	if (equal_values && changed_channels != 0)
+		changed_channels = 1 << 0;
+
+	for (i = 0; i <= fwspk->device_info->mixer_channels; ++i) {
+		volume = value->value.integer.value[channel_map[i ? i - 1 : 0]];
+		if (changed_channels & (1 << i)) {
+			err = fwspk_volume_command(fwspk, &volume, i,
+						   CTL_CURRENT, CTL_WRITE);
+			if (err < 0)
+				return err;
+		}
+		if (i > 0)
+			fwspk->volume[i - 1] = volume;
+	}
+
+	return changed_channels != 0;
+}
+
+static int fwspk_create_mixer(struct fwspk *fwspk)
+{
+	static const struct snd_kcontrol_new controls[] = {
+		{
+			.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+			.name = "PCM Playback Switch",
+			.info = snd_ctl_boolean_mono_info,
+			.get = fwspk_mute_get,
+			.put = fwspk_mute_put,
+		},
+		{
+			.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+			.name = "PCM Playback Volume",
+			.info = fwspk_volume_info,
+			.get = fwspk_volume_get,
+			.put = fwspk_volume_put,
+		},
+	};
+	unsigned int i, first_ch;
+	int err;
+
+	err = fwspk_volume_command(fwspk, &fwspk->volume_min,
+				   0, CTL_MIN, CTL_READ);
+	if (err < 0)
+		return err;
+	err = fwspk_volume_command(fwspk, &fwspk->volume_max,
+				   0, CTL_MAX, CTL_READ);
+	if (err < 0)
+		return err;
+
+	err = fwspk_mute_command(fwspk, &fwspk->mute, CTL_READ);
+	if (err < 0)
+		return err;
+
+	first_ch = fwspk->device_info->mixer_channels == 1 ? 0 : 1;
+	for (i = 0; i < fwspk->device_info->mixer_channels; ++i) {
+		err = fwspk_volume_command(fwspk, &fwspk->volume[i],
+					   first_ch + i, CTL_CURRENT, CTL_READ);
+		if (err < 0)
+			return err;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(controls); ++i) {
+		err = snd_ctl_add(fwspk->card,
+				  snd_ctl_new1(&controls[i], fwspk));
+		if (err < 0)
+			return err;
+	}
+
+	return 0;
+}
+
+static u32 fwspk_read_firmware_version(struct fw_unit *unit)
+{
+	__be32 data;
+	int err;
+
+	err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST,
+				 OXFORD_FIRMWARE_ID_ADDRESS, &data, 4);
+	return err >= 0 ? be32_to_cpu(data) : 0;
+}
+
+static void fwspk_card_free(struct snd_card *card)
+{
+	struct fwspk *fwspk = card->private_data;
+	struct fw_device *dev = fw_parent_device(fwspk->unit);
+
+	amdtp_out_stream_destroy(&fwspk->stream);
+	cmp_connection_destroy(&fwspk->connection);
+	fw_unit_put(fwspk->unit);
+	fw_device_put(dev);
+	mutex_destroy(&fwspk->mutex);
+}
+
+static const struct device_info *__devinit fwspk_detect(struct fw_device *dev)
+{
+	static const struct device_info griffin_firewave = {
+		.driver_name = "FireWave",
+		.short_name  = "FireWave",
+		.long_name   = "Griffin FireWave Surround",
+		.pcm_constraints = firewave_constraints,
+		.mixer_channels = 6,
+		.mute_fb_id   = 0x01,
+		.volume_fb_id = 0x02,
+	};
+	static const struct device_info lacie_speakers = {
+		.driver_name = "FWSpeakers",
+		.short_name  = "FireWire Speakers",
+		.long_name   = "LaCie FireWire Speakers",
+		.pcm_constraints = lacie_speakers_constraints,
+		.mixer_channels = 1,
+		.mute_fb_id   = 0x01,
+		.volume_fb_id = 0x01,
+	};
+	struct fw_csr_iterator i;
+	int key, value;
+
+	fw_csr_iterator_init(&i, dev->config_rom);
+	while (fw_csr_iterator_next(&i, &key, &value))
+		if (key == CSR_VENDOR)
+			switch (value) {
+			case VENDOR_GRIFFIN:
+				return &griffin_firewave;
+			case VENDOR_LACIE:
+				return &lacie_speakers;
+			}
+
+	return NULL;
+}
+
+static int __devinit fwspk_probe(struct device *unit_dev)
+{
+	struct fw_unit *unit = fw_unit(unit_dev);
+	struct fw_device *fw_dev = fw_parent_device(unit);
+	struct snd_card *card;
+	struct fwspk *fwspk;
+	u32 firmware;
+	int err;
+
+	err = snd_card_create(-1, NULL, THIS_MODULE, sizeof(*fwspk), &card);
+	if (err < 0)
+		return err;
+	snd_card_set_dev(card, unit_dev);
+
+	fwspk = card->private_data;
+	fwspk->card = card;
+	mutex_init(&fwspk->mutex);
+	fw_device_get(fw_dev);
+	fwspk->unit = fw_unit_get(unit);
+	fwspk->device_info = fwspk_detect(fw_dev);
+	if (!fwspk->device_info) {
+		err = -ENODEV;
+		goto err_unit;
+	}
+
+	err = cmp_connection_init(&fwspk->connection, unit, 0);
+	if (err < 0)
+		goto err_unit;
+
+	err = amdtp_out_stream_init(&fwspk->stream, unit, CIP_NONBLOCKING);
+	if (err < 0)
+		goto err_connection;
+
+	card->private_free = fwspk_card_free;
+
+	strcpy(card->driver, fwspk->device_info->driver_name);
+	strcpy(card->shortname, fwspk->device_info->short_name);
+	firmware = fwspk_read_firmware_version(unit);
+	snprintf(card->longname, sizeof(card->longname),
+		 "%s (OXFW%x %04x), GUID %08x%08x at %s, S%d",
+		 fwspk->device_info->long_name,
+		 firmware >> 20, firmware & 0xffff,
+		 fw_dev->config_rom[3], fw_dev->config_rom[4],
+		 dev_name(&unit->device), 100 << fw_dev->max_speed);
+	strcpy(card->mixername, "OXFW970");
+
+	err = fwspk_create_pcm(fwspk);
+	if (err < 0)
+		goto error;
+
+	err = fwspk_create_mixer(fwspk);
+	if (err < 0)
+		goto error;
+
+	err = snd_card_register(card);
+	if (err < 0)
+		goto error;
+
+	dev_set_drvdata(unit_dev, fwspk);
+
+	return 0;
+
+err_connection:
+	cmp_connection_destroy(&fwspk->connection);
+err_unit:
+	fw_unit_put(fwspk->unit);
+	fw_device_put(fw_dev);
+	mutex_destroy(&fwspk->mutex);
+error:
+	snd_card_free(card);
+	return err;
+}
+
+static int __devexit fwspk_remove(struct device *dev)
+{
+	struct fwspk *fwspk = dev_get_drvdata(dev);
+
+	snd_card_disconnect(fwspk->card);
+
+	mutex_lock(&fwspk->mutex);
+	amdtp_out_stream_pcm_abort(&fwspk->stream);
+	fwspk_stop_stream(fwspk);
+	mutex_unlock(&fwspk->mutex);
+
+	snd_card_free_when_closed(fwspk->card);
+
+	return 0;
+}
+
+static void fwspk_bus_reset(struct fw_unit *unit)
+{
+	struct fwspk *fwspk = dev_get_drvdata(&unit->device);
+
+	fcp_bus_reset(fwspk->unit);
+
+	if (cmp_connection_update(&fwspk->connection) < 0) {
+		mutex_lock(&fwspk->mutex);
+		amdtp_out_stream_pcm_abort(&fwspk->stream);
+		fwspk_stop_stream(fwspk);
+		mutex_unlock(&fwspk->mutex);
+		return;
+	}
+
+	amdtp_out_stream_update(&fwspk->stream);
+}
+
+static const struct ieee1394_device_id fwspk_id_table[] = {
+	{
+		.match_flags  = IEEE1394_MATCH_VENDOR_ID |
+				IEEE1394_MATCH_MODEL_ID |
+				IEEE1394_MATCH_SPECIFIER_ID |
+				IEEE1394_MATCH_VERSION,
+		.vendor_id    = VENDOR_GRIFFIN,
+		.model_id     = 0x00f970,
+		.specifier_id = SPECIFIER_1394TA,
+		.version      = VERSION_AVC,
+	},
+	{
+		.match_flags  = IEEE1394_MATCH_VENDOR_ID |
+				IEEE1394_MATCH_MODEL_ID |
+				IEEE1394_MATCH_SPECIFIER_ID |
+				IEEE1394_MATCH_VERSION,
+		.vendor_id    = VENDOR_LACIE,
+		.model_id     = 0x00f970,
+		.specifier_id = SPECIFIER_1394TA,
+		.version      = VERSION_AVC,
+	},
+	{ }
+};
+MODULE_DEVICE_TABLE(ieee1394, fwspk_id_table);
+
+static struct fw_driver fwspk_driver = {
+	.driver   = {
+		.owner	= THIS_MODULE,
+		.name	= KBUILD_MODNAME,
+		.bus	= &fw_bus_type,
+		.probe	= fwspk_probe,
+		.remove	= __devexit_p(fwspk_remove),
+	},
+	.update   = fwspk_bus_reset,
+	.id_table = fwspk_id_table,
+};
+
+static int __init alsa_fwspk_init(void)
+{
+	return driver_register(&fwspk_driver.driver);
+}
+
+static void __exit alsa_fwspk_exit(void)
+{
+	driver_unregister(&fwspk_driver.driver);
+}
+
+module_init(alsa_fwspk_init);
+module_exit(alsa_fwspk_exit);
...	...	@@ -362,4 +362,5 @@
362	362	*channel = ret;
363	363	}
364	364	}
	365	+EXPORT_SYMBOL(fw_iso_resource_manage);
...	...	@@ -147,9 +147,6 @@
147	147	/* -iso */
148	148
149	149	int fw_iso_buffer_map(struct fw_iso_buffer buffer, struct vm_area_struct vma);
150		-void fw_iso_resource_manage(struct fw_card *card, int generation,
151		- u64 channels_mask, int channel, int bandwidth,
152		- bool allocate, __be32 buffer[2]);
153	150
154	151
155	152	/* -topology */
...	...	@@ -42,6 +42,10 @@
42	42	#define CSR_BROADCAST_CHANNEL 0x234
43	43	#define CSR_CONFIG_ROM 0x400
44	44	#define CSR_CONFIG_ROM_END 0x800
	45	+#define CSR_OMPR 0x900
	46	+#define CSR_OPCR(i) (0x904 + (i) * 4)
	47	+#define CSR_IMPR 0x980
	48	+#define CSR_IPCR(i) (0x984 + (i) * 4)
45	49	#define CSR_FCP_COMMAND 0xB00
46	50	#define CSR_FCP_RESPONSE 0xD00
47	51	#define CSR_FCP_END 0xF00
...	...	@@ -441,6 +445,9 @@
441	445	int cycle, int sync, int tags);
442	446	int fw_iso_context_stop(struct fw_iso_context *ctx);
443	447	void fw_iso_context_destroy(struct fw_iso_context *ctx);
	448	+void fw_iso_resource_manage(struct fw_card *card, int generation,
	449	+ u64 channels_mask, int channel, int bandwidth,
	450	+ bool allocate, __be32 buffer[2]);
444	451
445	452	#endif /* _LINUX_FIREWIRE_H */
...	...	@@ -97,6 +97,8 @@
97	97	# here assuming USB is defined before ALSA
98	98	source "sound/usb/Kconfig"
99	99
	100	+source "sound/firewire/Kconfig"
	101	+
100	102	# the following will depend on the order of config.
101	103	# here assuming PCMCIA is defined before ALSA
102	104	source "sound/pcmcia/Kconfig"
...	...	@@ -6,7 +6,7 @@
6	6	obj-$(CONFIG_SOUND_PRIME) += oss/
7	7	obj-$(CONFIG_DMASOUND) += oss/
8	8	obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ sh/ synth/ usb/ \
9		- sparc/ spi/ parisc/ pcmcia/ mips/ soc/ atmel/
	9	+ firewire/ sparc/ spi/ parisc/ pcmcia/ mips/ soc/ atmel/
10	10	obj-$(CONFIG_SND_AOA) += aoa/
11	11
12	12	# This one must be compilable even if sound is configured out
	1	+menuconfig SND_FIREWIRE
	2	+ bool "FireWire sound devices"
	3	+ depends on FIREWIRE
	4	+ default y
	5	+ help
	6	+ Support for IEEE-1394/FireWire/iLink sound devices.
	7	+
	8	+if SND_FIREWIRE && FIREWIRE
	9	+
	10	+config SND_FIREWIRE_LIB
	11	+ tristate
	12	+ depends on SND_PCM
	13	+
	14	+config SND_FIREWIRE_SPEAKERS
	15	+ tristate "FireWire speakers"
	16	+ select SND_PCM
	17	+ select SND_FIREWIRE_LIB
	18	+ help
	19	+ Say Y here to include support for the Griffin FireWave Surround
	20	+ and the LaCie FireWire Speakers.
	21	+
	22	+ To compile this driver as a module, choose M here: the module
	23	+ will be called snd-firewire-speakers.
	24	+
	25	+endif # SND_FIREWIRE
	1	+snd-firewire-lib-objs := lib.o iso-resources.o packets-buffer.o \
	2	+ fcp.o cmp.o amdtp.o
	3	+snd-firewire-speakers-objs := speakers.o
	4	+
	5	+obj-$(CONFIG_SND_FIREWIRE_LIB) += snd-firewire-lib.o
	6	+obj-$(CONFIG_SND_FIREWIRE_SPEAKERS) += snd-firewire-speakers.o
	1	+/*
	2	+ * Audio and Music Data Transmission Protocol (IEC 61883-6) streams
	3	+ * with Common Isochronous Packet (IEC 61883-1) headers
	4	+ *
	5	+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
	6	+ * Licensed under the terms of the GNU General Public License, version 2.
	7	+ */
	8	+
	9	+#include <linux/device.h>
	10	+#include <linux/err.h>
	11	+#include <linux/firewire.h>
	12	+#include <linux/module.h>
	13	+#include <linux/slab.h>
	14	+#include <sound/pcm.h>
	15	+#include "amdtp.h"
	16	+
	17	+#define TICKS_PER_CYCLE 3072
	18	+#define CYCLES_PER_SECOND 8000
	19	+#define TICKS_PER_SECOND (TICKS_PER_CYCLE * CYCLES_PER_SECOND)
	20	+
	21	+#define TRANSFER_DELAY_TICKS 0x2e00 /* 479.17 µs */
	22	+
	23	+#define TAG_CIP 1
	24	+
	25	+#define CIP_EOH (1u << 31)
	26	+#define CIP_FMT_AM (0x10 << 24)
	27	+#define AMDTP_FDF_AM824 (0 << 19)
	28	+#define AMDTP_FDF_SFC_SHIFT 16
	29	+
	30	+/* TODO: make these configurable */
	31	+#define INTERRUPT_INTERVAL 16
	32	+#define QUEUE_LENGTH 48
	33	+
	34	+/**
	35	+ * amdtp_out_stream_init - initialize an AMDTP output stream structure
	36	+ * @s: the AMDTP output stream to initialize
	37	+ * @unit: the target of the stream
	38	+ * @flags: the packet transmission method to use
	39	+ */
	40	+int amdtp_out_stream_init(struct amdtp_out_stream s, struct fw_unit unit,
	41	+ enum cip_out_flags flags)
	42	+{
	43	+ if (flags != CIP_NONBLOCKING)
	44	+ return -EINVAL;
	45	+
	46	+ s->unit = fw_unit_get(unit);
	47	+ s->flags = flags;
	48	+ s->context = ERR_PTR(-1);
	49	+ mutex_init(&s->mutex);
	50	+
	51	+ return 0;
	52	+}
	53	+EXPORT_SYMBOL(amdtp_out_stream_init);
	54	+
	55	+/**
	56	+ * amdtp_out_stream_destroy - free stream resources
	57	+ * @s: the AMDTP output stream to destroy
	58	+ */
	59	+void amdtp_out_stream_destroy(struct amdtp_out_stream *s)
	60	+{
	61	+ WARN_ON(!IS_ERR(s->context));
	62	+ mutex_destroy(&s->mutex);
	63	+ fw_unit_put(s->unit);
	64	+}
	65	+EXPORT_SYMBOL(amdtp_out_stream_destroy);
	66	+
	67	+/**
	68	+ * amdtp_out_stream_set_rate - set the sample rate
	69	+ * @s: the AMDTP output stream to configure
	70	+ * @rate: the sample rate
	71	+ *
	72	+ * The sample rate must be set before the stream is started, and must not be
	73	+ * changed while the stream is running.
	74	+ */
	75	+void amdtp_out_stream_set_rate(struct amdtp_out_stream *s, unsigned int rate)
	76	+{
	77	+ static const struct {
	78	+ unsigned int rate;
	79	+ unsigned int syt_interval;
	80	+ } rate_info[] = {
	81	+ [CIP_SFC_32000] = { 32000, 8, },
	82	+ [CIP_SFC_44100] = { 44100, 8, },
	83	+ [CIP_SFC_48000] = { 48000, 8, },
	84	+ [CIP_SFC_88200] = { 88200, 16, },
	85	+ [CIP_SFC_96000] = { 96000, 16, },
	86	+ [CIP_SFC_176400] = { 176400, 32, },
	87	+ [CIP_SFC_192000] = { 192000, 32, },
	88	+ };
	89	+ unsigned int sfc;
	90	+
	91	+ if (WARN_ON(!IS_ERR(s->context)))
	92	+ return;
	93	+
	94	+ for (sfc = 0; sfc < ARRAY_SIZE(rate_info); ++sfc)
	95	+ if (rate_info[sfc].rate == rate) {
	96	+ s->sfc = sfc;
	97	+ s->syt_interval = rate_info[sfc].syt_interval;
	98	+ return;
	99	+ }
	100	+ WARN_ON(1);
	101	+}
	102	+EXPORT_SYMBOL(amdtp_out_stream_set_rate);
	103	+
	104	+/**
	105	+ * amdtp_out_stream_get_max_payload - get the stream's packet size
	106	+ * @s: the AMDTP output stream
	107	+ *
	108	+ * This function must not be called before the stream has been configured
	109	+ * with amdtp_out_stream_set_hw_params(), amdtp_out_stream_set_pcm(), and
	110	+ * amdtp_out_stream_set_midi().
	111	+ */
	112	+unsigned int amdtp_out_stream_get_max_payload(struct amdtp_out_stream *s)
	113	+{
	114	+ static const unsigned int max_data_blocks[] = {
	115	+ [CIP_SFC_32000] = 4,
	116	+ [CIP_SFC_44100] = 6,
	117	+ [CIP_SFC_48000] = 6,
	118	+ [CIP_SFC_88200] = 12,
	119	+ [CIP_SFC_96000] = 12,
	120	+ [CIP_SFC_176400] = 23,
	121	+ [CIP_SFC_192000] = 24,
	122	+ };
	123	+
	124	+ s->data_block_quadlets = s->pcm_channels;
	125	+ s->data_block_quadlets += DIV_ROUND_UP(s->midi_ports, 8);
	126	+
	127	+ return 8 + max_data_blocks[s->sfc] * 4 * s->data_block_quadlets;
	128	+}
	129	+EXPORT_SYMBOL(amdtp_out_stream_get_max_payload);
	130	+
	131	+static void amdtp_write_s16(struct amdtp_out_stream *s,
	132	+ struct snd_pcm_substream *pcm,
	133	+ __be32 *buffer, unsigned int frames);
	134	+static void amdtp_write_s32(struct amdtp_out_stream *s,
	135	+ struct snd_pcm_substream *pcm,
	136	+ __be32 *buffer, unsigned int frames);
	137	+
	138	+/**
	139	+ * amdtp_out_stream_set_pcm_format - set the PCM format
	140	+ * @s: the AMDTP output stream to configure
	141	+ * @format: the format of the ALSA PCM device
	142	+ *
	143	+ * The sample format must be set before the stream is started, and must not be
	144	+ * changed while the stream is running.
	145	+ */
	146	+void amdtp_out_stream_set_pcm_format(struct amdtp_out_stream *s,
	147	+ snd_pcm_format_t format)
	148	+{
	149	+ if (WARN_ON(!IS_ERR(s->context)))
	150	+ return;
	151	+
	152	+ switch (format) {
	153	+ default:
	154	+ WARN_ON(1);
	155	+ /* fall through */
	156	+ case SNDRV_PCM_FORMAT_S16:
	157	+ s->transfer_samples = amdtp_write_s16;
	158	+ break;
	159	+ case SNDRV_PCM_FORMAT_S32:
	160	+ s->transfer_samples = amdtp_write_s32;
	161	+ break;
	162	+ }
	163	+}
	164	+EXPORT_SYMBOL(amdtp_out_stream_set_pcm_format);
	165	+
	166	+static unsigned int calculate_data_blocks(struct amdtp_out_stream *s)
	167	+{
	168	+ unsigned int phase, data_blocks;
	169	+
	170	+ if (!cip_sfc_is_base_44100(s->sfc)) {
	171	+ /* Sample_rate / 8000 is an integer, and precomputed. */
	172	+ data_blocks = s->data_block_state;
	173	+ } else {
	174	+ phase = s->data_block_state;
	175	+
	176	+ /*
	177	+ * This calculates the number of data blocks per packet so that
	178	+ * 1) the overall rate is correct and exactly synchronized to
	179	+ * the bus clock, and
	180	+ * 2) packets with a rounded-up number of blocks occur as early
	181	+ * as possible in the sequence (to prevent underruns of the
	182	+ * device's buffer).
	183	+ */
	184	+ if (s->sfc == CIP_SFC_44100)
	185	+ /* 6 6 5 6 5 6 5 ... */
	186	+ data_blocks = 5 + ((phase & 1) ^
	187	+ (phase == 0 \|\| phase >= 40));
	188	+ else
	189	+ /* 12 11 11 11 11 ... or 23 22 22 22 22 ... */
	190	+ data_blocks = 11 * (s->sfc >> 1) + (phase == 0);
	191	+ if (++phase >= (80 >> (s->sfc >> 1)))
	192	+ phase = 0;
	193	+ s->data_block_state = phase;
	194	+ }
	195	+
	196	+ return data_blocks;
	197	+}
	198	+
	199	+static unsigned int calculate_syt(struct amdtp_out_stream *s,
	200	+ unsigned int cycle)
	201	+{
	202	+ unsigned int syt_offset, phase, index, syt;
	203	+
	204	+ if (s->last_syt_offset < TICKS_PER_CYCLE) {
	205	+ if (!cip_sfc_is_base_44100(s->sfc))
	206	+ syt_offset = s->last_syt_offset + s->syt_offset_state;
	207	+ else {
	208	+ /*
	209	+ * The time, in ticks, of the n'th SYT_INTERVAL sample is:
	210	+ * n * SYT_INTERVAL * 24576000 / sample_rate
	211	+ * Modulo TICKS_PER_CYCLE, the difference between successive
	212	+ * elements is about 1386.23. Rounding the results of this
	213	+ * formula to the SYT precision results in a sequence of
	214	+ * differences that begins with:
	215	+ * 1386 1386 1387 1386 1386 1386 1387 1386 1386 1386 1387 ...
	216	+ * This code generates _exactly_ the same sequence.
	217	+ */
	218	+ phase = s->syt_offset_state;
	219	+ index = phase % 13;
	220	+ syt_offset = s->last_syt_offset;
	221	+ syt_offset += 1386 + ((index && !(index & 3)) \|\|
	222	+ phase == 146);
	223	+ if (++phase >= 147)
	224	+ phase = 0;
	225	+ s->syt_offset_state = phase;
	226	+ }
	227	+ } else
	228	+ syt_offset = s->last_syt_offset - TICKS_PER_CYCLE;
	229	+ s->last_syt_offset = syt_offset;
	230	+
	231	+ syt_offset += TRANSFER_DELAY_TICKS - TICKS_PER_CYCLE;
	232	+ syt = (cycle + syt_offset / TICKS_PER_CYCLE) << 12;
	233	+ syt += syt_offset % TICKS_PER_CYCLE;
	234	+
	235	+ return syt & 0xffff;
	236	+}
	237	+
	238	+static void amdtp_write_s32(struct amdtp_out_stream *s,
	239	+ struct snd_pcm_substream *pcm,
	240	+ __be32 *buffer, unsigned int frames)
	241	+{
	242	+ struct snd_pcm_runtime *runtime = pcm->runtime;
	243	+ unsigned int channels, remaining_frames, frame_step, i, c;
	244	+ const u32 *src;
	245	+
	246	+ channels = s->pcm_channels;
	247	+ src = (void *)runtime->dma_area +
	248	+ s->pcm_buffer_pointer * (runtime->frame_bits / 8);
	249	+ remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
	250	+ frame_step = s->data_block_quadlets - channels;
	251	+
	252	+ for (i = 0; i < frames; ++i) {
	253	+ for (c = 0; c < channels; ++c) {
	254	+ buffer = cpu_to_be32((src >> 8) \| 0x40000000);
	255	+ src++;
	256	+ buffer++;
	257	+ }
	258	+ buffer += frame_step;
	259	+ if (--remaining_frames == 0)
	260	+ src = (void *)runtime->dma_area;
	261	+ }
	262	+}
	263	+
	264	+static void amdtp_write_s16(struct amdtp_out_stream *s,
	265	+ struct snd_pcm_substream *pcm,
	266	+ __be32 *buffer, unsigned int frames)
	267	+{
	268	+ struct snd_pcm_runtime *runtime = pcm->runtime;
	269	+ unsigned int channels, remaining_frames, frame_step, i, c;
	270	+ const u16 *src;
	271	+
	272	+ channels = s->pcm_channels;
	273	+ src = (void *)runtime->dma_area +
	274	+ s->pcm_buffer_pointer * (runtime->frame_bits / 8);
	275	+ remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
	276	+ frame_step = s->data_block_quadlets - channels;
	277	+
	278	+ for (i = 0; i < frames; ++i) {
	279	+ for (c = 0; c < channels; ++c) {
	280	+ buffer = cpu_to_be32((src << 8) \| 0x40000000);
	281	+ src++;
	282	+ buffer++;
	283	+ }
	284	+ buffer += frame_step;
	285	+ if (--remaining_frames == 0)
	286	+ src = (void *)runtime->dma_area;
	287	+ }
	288	+}
	289	+
	290	+static void amdtp_fill_pcm_silence(struct amdtp_out_stream *s,
	291	+ __be32 *buffer, unsigned int frames)
	292	+{
	293	+ unsigned int i, c;
	294	+
	295	+ for (i = 0; i < frames; ++i) {
	296	+ for (c = 0; c < s->pcm_channels; ++c)
	297	+ buffer[c] = cpu_to_be32(0x40000000);
	298	+ buffer += s->data_block_quadlets;
	299	+ }
	300	+}
	301	+
	302	+static void amdtp_fill_midi(struct amdtp_out_stream *s,
	303	+ __be32 *buffer, unsigned int frames)
	304	+{
	305	+ unsigned int i;
	306	+
	307	+ for (i = 0; i < frames; ++i)
	308	+ buffer[s->pcm_channels + i * s->data_block_quadlets] =
	309	+ cpu_to_be32(0x80000000);
	310	+}
	311	+
	312	+static void queue_out_packet(struct amdtp_out_stream *s, unsigned int cycle)
	313	+{
	314	+ __be32 *buffer;
	315	+ unsigned int data_blocks, syt, ptr;
	316	+ struct snd_pcm_substream *pcm;
	317	+ struct fw_iso_packet packet;
	318	+ int err;
	319	+
	320	+ data_blocks = calculate_data_blocks(s);
	321	+ syt = calculate_syt(s, cycle);
	322	+
	323	+ buffer = s->buffer.packets[s->packet_counter].buffer;
	324	+ buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) \|
	325	+ (s->data_block_quadlets << 16) \|
	326	+ s->data_block_counter);
	327	+ buffer[1] = cpu_to_be32(CIP_EOH \| CIP_FMT_AM \| AMDTP_FDF_AM824 \|
	328	+ (s->sfc << AMDTP_FDF_SFC_SHIFT) \| syt);
	329	+ buffer += 2;
	330	+
	331	+ pcm = ACCESS_ONCE(s->pcm);
	332	+ if (pcm)
	333	+ s->transfer_samples(s, pcm, buffer, data_blocks);
	334	+ else
	335	+ amdtp_fill_pcm_silence(s, buffer, data_blocks);
	336	+ if (s->midi_ports)
	337	+ amdtp_fill_midi(s, buffer, data_blocks);
	338	+
	339	+ s->data_block_counter = (s->data_block_counter + data_blocks) & 0xff;
	340	+
	341	+ packet.payload_length = 8 + data_blocks * 4 * s->data_block_quadlets;
	342	+ packet.interrupt = IS_ALIGNED(s->packet_counter + 1,
	343	+ INTERRUPT_INTERVAL);
	344	+ packet.skip = 0;
	345	+ packet.tag = TAG_CIP;
	346	+ packet.sy = 0;
	347	+ packet.header_length = 0;
	348	+
	349	+ err = fw_iso_context_queue(s->context, &packet, &s->buffer.iso_buffer,
	350	+ s->buffer.packets[s->packet_counter].offset);
	351	+ if (err < 0)
	352	+ dev_err(&s->unit->device, "queueing error: %d\n", err);
	353	+
	354	+ if (++s->packet_counter >= QUEUE_LENGTH)
	355	+ s->packet_counter = 0;
	356	+
	357	+ if (pcm) {
	358	+ ptr = s->pcm_buffer_pointer + data_blocks;
	359	+ if (ptr >= pcm->runtime->buffer_size)
	360	+ ptr -= pcm->runtime->buffer_size;
	361	+ ACCESS_ONCE(s->pcm_buffer_pointer) = ptr;
	362	+
	363	+ s->pcm_period_pointer += data_blocks;
	364	+ if (s->pcm_period_pointer >= pcm->runtime->period_size) {
	365	+ s->pcm_period_pointer -= pcm->runtime->period_size;
	366	+ snd_pcm_period_elapsed(pcm);
	367	+ }
	368	+ }
	369	+}
	370	+
	371	+static void out_packet_callback(struct fw_iso_context *context, u32 cycle,
	372	+ size_t header_length, void header, void data)
	373	+{
	374	+ struct amdtp_out_stream *s = data;
	375	+ unsigned int i, packets = header_length / 4;
	376	+
	377	+ /*
	378	+ * Compute the cycle of the last queued packet.
	379	+ * (We need only the four lowest bits for the SYT, so we can ignore
	380	+ * that bits 0-11 must wrap around at 3072.)
	381	+ */
	382	+ cycle += QUEUE_LENGTH - packets;
	383	+
	384	+ for (i = 0; i < packets; ++i)
	385	+ queue_out_packet(s, ++cycle);
	386	+}
	387	+
	388	+static int queue_initial_skip_packets(struct amdtp_out_stream *s)
	389	+{
	390	+ struct fw_iso_packet skip_packet = {
	391	+ .skip = 1,
	392	+ };
	393	+ unsigned int i;
	394	+ int err;
	395	+
	396	+ for (i = 0; i < QUEUE_LENGTH; ++i) {
	397	+ skip_packet.interrupt = IS_ALIGNED(s->packet_counter + 1,
	398	+ INTERRUPT_INTERVAL);
	399	+ err = fw_iso_context_queue(s->context, &skip_packet, NULL, 0);
	400	+ if (err < 0)
	401	+ return err;
	402	+ if (++s->packet_counter >= QUEUE_LENGTH)
	403	+ s->packet_counter = 0;
	404	+ }
	405	+
	406	+ return 0;
	407	+}
	408	+
	409	+/**
	410	+ * amdtp_out_stream_start - start sending packets
	411	+ * @s: the AMDTP output stream to start
	412	+ * @channel: the isochronous channel on the bus
	413	+ * @speed: firewire speed code
	414	+ *
	415	+ * The stream cannot be started until it has been configured with
	416	+ * amdtp_out_stream_set_hw_params(), amdtp_out_stream_set_pcm(), and
	417	+ * amdtp_out_stream_set_midi(); and it must be started before any
	418	+ * PCM or MIDI device can be started.
	419	+ */
	420	+int amdtp_out_stream_start(struct amdtp_out_stream *s, int channel, int speed)
	421	+{
	422	+ static const struct {
	423	+ unsigned int data_block;
	424	+ unsigned int syt_offset;
	425	+ } initial_state[] = {
	426	+ [CIP_SFC_32000] = { 4, 3072 },
	427	+ [CIP_SFC_48000] = { 6, 1024 },
	428	+ [CIP_SFC_96000] = { 12, 1024 },
	429	+ [CIP_SFC_192000] = { 24, 1024 },
	430	+ [CIP_SFC_44100] = { 0, 67 },
	431	+ [CIP_SFC_88200] = { 0, 67 },
	432	+ [CIP_SFC_176400] = { 0, 67 },
	433	+ };
	434	+ int err;
	435	+
	436	+ mutex_lock(&s->mutex);
	437	+
	438	+ if (WARN_ON(!IS_ERR(s->context) \|\|
	439	+ (!s->pcm_channels && !s->midi_ports))) {
	440	+ err = -EBADFD;
	441	+ goto err_unlock;
	442	+ }
	443	+
	444	+ s->data_block_state = initial_state[s->sfc].data_block;
	445	+ s->syt_offset_state = initial_state[s->sfc].syt_offset;
	446	+ s->last_syt_offset = TICKS_PER_CYCLE;
	447	+
	448	+ err = iso_packets_buffer_init(&s->buffer, s->unit, QUEUE_LENGTH,
	449	+ amdtp_out_stream_get_max_payload(s),
	450	+ DMA_TO_DEVICE);
	451	+ if (err < 0)
	452	+ goto err_unlock;
	453	+
	454	+ s->context = fw_iso_context_create(fw_parent_device(s->unit)->card,
	455	+ FW_ISO_CONTEXT_TRANSMIT,
	456	+ channel, speed, 0,
	457	+ out_packet_callback, s);
	458	+ if (IS_ERR(s->context)) {
	459	+ err = PTR_ERR(s->context);
	460	+ if (err == -EBUSY)
	461	+ dev_err(&s->unit->device,
	462	+ "no free output stream on this controller\n");
	463	+ goto err_buffer;
	464	+ }
	465	+
	466	+ amdtp_out_stream_update(s);
	467	+
	468	+ s->packet_counter = 0;
	469	+ s->data_block_counter = 0;
	470	+ err = queue_initial_skip_packets(s);
	471	+ if (err < 0)
	472	+ goto err_context;
	473	+
	474	+ err = fw_iso_context_start(s->context, -1, 0, 0);
	475	+ if (err < 0)
	476	+ goto err_context;
	477	+
	478	+ mutex_unlock(&s->mutex);
	479	+
	480	+ return 0;
	481	+
	482	+err_context:
	483	+ fw_iso_context_destroy(s->context);
	484	+ s->context = ERR_PTR(-1);
	485	+err_buffer:
	486	+ iso_packets_buffer_destroy(&s->buffer, s->unit);
	487	+err_unlock:
	488	+ mutex_unlock(&s->mutex);
	489	+
	490	+ return err;
	491	+}
	492	+EXPORT_SYMBOL(amdtp_out_stream_start);
	493	+
	494	+/**
	495	+ * amdtp_out_stream_update - update the stream after a bus reset
	496	+ * @s: the AMDTP output stream
	497	+ */
	498	+void amdtp_out_stream_update(struct amdtp_out_stream *s)
	499	+{
	500	+ ACCESS_ONCE(s->source_node_id_field) =
	501	+ (fw_parent_device(s->unit)->card->node_id & 0x3f) << 24;
	502	+}
	503	+EXPORT_SYMBOL(amdtp_out_stream_update);
	504	+
	505	+/**
	506	+ * amdtp_out_stream_stop - stop sending packets
	507	+ * @s: the AMDTP output stream to stop
	508	+ *
	509	+ * All PCM and MIDI devices of the stream must be stopped before the stream
	510	+ * itself can be stopped.
	511	+ */
	512	+void amdtp_out_stream_stop(struct amdtp_out_stream *s)
	513	+{
	514	+ mutex_lock(&s->mutex);
	515	+
	516	+ if (IS_ERR(s->context)) {
	517	+ mutex_unlock(&s->mutex);
	518	+ return;
	519	+ }
	520	+
	521	+ fw_iso_context_stop(s->context);
	522	+ fw_iso_context_destroy(s->context);
	523	+ s->context = ERR_PTR(-1);
	524	+ iso_packets_buffer_destroy(&s->buffer, s->unit);
	525	+
	526	+ mutex_unlock(&s->mutex);
	527	+}
	528	+EXPORT_SYMBOL(amdtp_out_stream_stop);
	529	+
	530	+/**
	531	+ * amdtp_out_stream_pcm_abort - abort the running PCM device
	532	+ * @s: the AMDTP stream about to be stopped
	533	+ *
	534	+ * If the isochronous stream needs to be stopped asynchronously, call this
	535	+ * function first to stop the PCM device.
	536	+ */
	537	+void amdtp_out_stream_pcm_abort(struct amdtp_out_stream *s)
	538	+{
	539	+ struct snd_pcm_substream *pcm;
	540	+
	541	+ pcm = ACCESS_ONCE(s->pcm);
	542	+ if (pcm) {
	543	+ snd_pcm_stream_lock_irq(pcm);
	544	+ if (snd_pcm_running(pcm))
	545	+ snd_pcm_stop(pcm, SNDRV_PCM_STATE_XRUN);
	546	+ snd_pcm_stream_unlock_irq(pcm);
	547	+ }
	548	+}
	549	+EXPORT_SYMBOL(amdtp_out_stream_pcm_abort);
	1	+#ifndef SOUND_FIREWIRE_AMDTP_H_INCLUDED
	2	+#define SOUND_FIREWIRE_AMDTP_H_INCLUDED
	3	+
	4	+#include <linux/mutex.h>
	5	+#include <linux/spinlock.h>
	6	+#include "packets-buffer.h"
	7	+
	8	+/**
	9	+ * enum cip_out_flags - describes details of the streaming protocol
	10	+ * @CIP_NONBLOCKING: In non-blocking mode, each packet contains
	11	+ * sample_rate/8000 samples, with rounding up or down to adjust
	12	+ * for clock skew and left-over fractional samples. This should
	13	+ * be used if supported by the device.
	14	+ */
	15	+enum cip_out_flags {
	16	+ CIP_NONBLOCKING = 0,
	17	+};
	18	+
	19	+/**
	20	+ * enum cip_sfc - a stream's sample rate
	21	+ */
	22	+enum cip_sfc {
	23	+ CIP_SFC_32000 = 0,
	24	+ CIP_SFC_44100 = 1,
	25	+ CIP_SFC_48000 = 2,
	26	+ CIP_SFC_88200 = 3,
	27	+ CIP_SFC_96000 = 4,
	28	+ CIP_SFC_176400 = 5,
	29	+ CIP_SFC_192000 = 6,
	30	+};
	31	+
	32	+#define AMDTP_OUT_PCM_FORMAT_BITS (SNDRV_PCM_FMTBIT_S16 \| \
	33	+ SNDRV_PCM_FMTBIT_S32)
	34	+
	35	+struct fw_unit;
	36	+struct fw_iso_context;
	37	+struct snd_pcm_substream;
	38	+
	39	+struct amdtp_out_stream {
	40	+ struct fw_unit *unit;
	41	+ enum cip_out_flags flags;
	42	+ struct fw_iso_context *context;
	43	+ struct mutex mutex;
	44	+
	45	+ enum cip_sfc sfc;
	46	+ unsigned int data_block_quadlets;
	47	+ unsigned int pcm_channels;
	48	+ unsigned int midi_ports;
	49	+ void (transfer_samples)(struct amdtp_out_stream s,
	50	+ struct snd_pcm_substream *pcm,
	51	+ __be32 *buffer, unsigned int frames);
	52	+
	53	+ unsigned int syt_interval;
	54	+ unsigned int source_node_id_field;
	55	+ struct iso_packets_buffer buffer;
	56	+
	57	+ struct snd_pcm_substream *pcm;
	58	+
	59	+ unsigned int packet_counter;
	60	+ unsigned int data_block_counter;
	61	+
	62	+ unsigned int data_block_state;
	63	+
	64	+ unsigned int last_syt_offset;
	65	+ unsigned int syt_offset_state;
	66	+
	67	+ unsigned int pcm_buffer_pointer;
	68	+ unsigned int pcm_period_pointer;
	69	+};
	70	+
	71	+int amdtp_out_stream_init(struct amdtp_out_stream s, struct fw_unit unit,
	72	+ enum cip_out_flags flags);
	73	+void amdtp_out_stream_destroy(struct amdtp_out_stream *s);
	74	+
	75	+void amdtp_out_stream_set_rate(struct amdtp_out_stream *s, unsigned int rate);
	76	+unsigned int amdtp_out_stream_get_max_payload(struct amdtp_out_stream *s);
	77	+
	78	+int amdtp_out_stream_start(struct amdtp_out_stream *s, int channel, int speed);
	79	+void amdtp_out_stream_update(struct amdtp_out_stream *s);
	80	+void amdtp_out_stream_stop(struct amdtp_out_stream *s);
	81	+
	82	+void amdtp_out_stream_set_pcm_format(struct amdtp_out_stream *s,
	83	+ snd_pcm_format_t format);
	84	+void amdtp_out_stream_pcm_abort(struct amdtp_out_stream *s);
	85	+
	86	+/**
	87	+ * amdtp_out_stream_set_pcm - configure format of PCM samples
	88	+ * @s: the AMDTP output stream to be configured
	89	+ * @pcm_channels: the number of PCM samples in each data block, to be encoded
	90	+ * as AM824 multi-bit linear audio
	91	+ *
	92	+ * This function must not be called while the stream is running.
	93	+ */
	94	+static inline void amdtp_out_stream_set_pcm(struct amdtp_out_stream *s,
	95	+ unsigned int pcm_channels)
	96	+{
	97	+ s->pcm_channels = pcm_channels;
	98	+}
	99	+
	100	+/**
	101	+ * amdtp_out_stream_set_midi - configure format of MIDI data
	102	+ * @s: the AMDTP output stream to be configured
	103	+ * @midi_ports: the number of MIDI ports (i.e., MPX-MIDI Data Channels)
	104	+ *
	105	+ * This function must not be called while the stream is running.
	106	+ */
	107	+static inline void amdtp_out_stream_set_midi(struct amdtp_out_stream *s,
	108	+ unsigned int midi_ports)
	109	+{
	110	+ s->midi_ports = midi_ports;
	111	+}
	112	+
	113	+/**
	114	+ * amdtp_out_stream_pcm_prepare - prepare PCM device for running
	115	+ * @s: the AMDTP output stream
	116	+ *
	117	+ * This function should be called from the PCM device's .prepare callback.
	118	+ */
	119	+static inline void amdtp_out_stream_pcm_prepare(struct amdtp_out_stream *s)
	120	+{
	121	+ s->pcm_buffer_pointer = 0;
	122	+ s->pcm_period_pointer = 0;
	123	+}
	124	+
	125	+/**
	126	+ * amdtp_out_stream_pcm_trigger - start/stop playback from a PCM device
	127	+ * @s: the AMDTP output stream
	128	+ * @pcm: the PCM device to be started, or %NULL to stop the current device
	129	+ *
	130	+ * Call this function on a running isochronous stream to enable the actual
	131	+ * transmission of PCM data. This function should be called from the PCM
	132	+ * device's .trigger callback.
	133	+ */
	134	+static inline void amdtp_out_stream_pcm_trigger(struct amdtp_out_stream *s,
	135	+ struct snd_pcm_substream *pcm)
	136	+{
	137	+ ACCESS_ONCE(s->pcm) = pcm;
	138	+}
	139	+
	140	+/**
	141	+ * amdtp_out_stream_pcm_pointer - get the PCM buffer position
	142	+ * @s: the AMDTP output stream that transports the PCM data
	143	+ *
	144	+ * Returns the current buffer position, in frames.
	145	+ */
	146	+static inline unsigned long
	147	+amdtp_out_stream_pcm_pointer(struct amdtp_out_stream *s)
	148	+{
	149	+ return ACCESS_ONCE(s->pcm_buffer_pointer);
	150	+}
	151	+
	152	+static inline bool cip_sfc_is_base_44100(enum cip_sfc sfc)
	153	+{
	154	+ return sfc & 1;
	155	+}
	156	+
	157	+#endif
	1	+/*
	2	+ * Connection Management Procedures (IEC 61883-1) helper functions
	3	+ *
	4	+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
	5	+ * Licensed under the terms of the GNU General Public License, version 2.
	6	+ */
	7	+
	8	+#include <linux/device.h>
	9	+#include <linux/firewire.h>
	10	+#include <linux/firewire-constants.h>
	11	+#include <linux/module.h>
	12	+#include <linux/sched.h>
	13	+#include "lib.h"
	14	+#include "iso-resources.h"
	15	+#include "cmp.h"
	16	+
	17	+#define IMPR_SPEED_MASK 0xc0000000
	18	+#define IMPR_SPEED_SHIFT 30
	19	+#define IMPR_XSPEED_MASK 0x00000060
	20	+#define IMPR_XSPEED_SHIFT 5
	21	+#define IMPR_PLUGS_MASK 0x0000001f
	22	+
	23	+#define IPCR_ONLINE 0x80000000
	24	+#define IPCR_BCAST_CONN 0x40000000
	25	+#define IPCR_P2P_CONN_MASK 0x3f000000
	26	+#define IPCR_P2P_CONN_SHIFT 24
	27	+#define IPCR_CHANNEL_MASK 0x003f0000
	28	+#define IPCR_CHANNEL_SHIFT 16
	29	+
	30	+enum bus_reset_handling {
	31	+ ABORT_ON_BUS_RESET,
	32	+ SUCCEED_ON_BUS_RESET,
	33	+};
	34	+
	35	+static __attribute__((format(printf, 2, 3)))
	36	+void cmp_error(struct cmp_connection c, const char fmt, ...)
	37	+{
	38	+ va_list va;
	39	+
	40	+ va_start(va, fmt);
	41	+ dev_err(&c->resources.unit->device, "%cPCR%u: %pV",
	42	+ 'i', c->pcr_index, &(struct va_format){ fmt, &va });
	43	+ va_end(va);
	44	+}
	45	+
	46	+static int pcr_modify(struct cmp_connection *c,
	47	+ __be32 (modify)(struct cmp_connection c, __be32 old),
	48	+ int (check)(struct cmp_connection c, __be32 pcr),
	49	+ enum bus_reset_handling bus_reset_handling)
	50	+{
	51	+ struct fw_device *device = fw_parent_device(c->resources.unit);
	52	+ __be32 *buffer = c->resources.buffer;
	53	+ int generation = c->resources.generation;
	54	+ int rcode, errors = 0;
	55	+ __be32 old_arg;
	56	+ int err;
	57	+
	58	+ buffer[0] = c->last_pcr_value;
	59	+ for (;;) {
	60	+ old_arg = buffer[0];
	61	+ buffer[1] = modify(c, buffer[0]);
	62	+
	63	+ rcode = fw_run_transaction(
	64	+ device->card, TCODE_LOCK_COMPARE_SWAP,
	65	+ device->node_id, generation, device->max_speed,
	66	+ CSR_REGISTER_BASE + CSR_IPCR(c->pcr_index),
	67	+ buffer, 8);
	68	+
	69	+ if (rcode == RCODE_COMPLETE) {
	70	+ if (buffer[0] == old_arg) /* success? */
	71	+ break;
	72	+
	73	+ if (check) {
	74	+ err = check(c, buffer[0]);
	75	+ if (err < 0)
	76	+ return err;
	77	+ }
	78	+ } else if (rcode == RCODE_GENERATION)
	79	+ goto bus_reset;
	80	+ else if (rcode_is_permanent_error(rcode) \|\| ++errors >= 3)
	81	+ goto io_error;
	82	+ }
	83	+ c->last_pcr_value = buffer[1];
	84	+
	85	+ return 0;
	86	+
	87	+io_error:
	88	+ cmp_error(c, "transaction failed: %s\n", rcode_string(rcode));
	89	+ return -EIO;
	90	+
	91	+bus_reset:
	92	+ return bus_reset_handling == ABORT_ON_BUS_RESET ? -EAGAIN : 0;
	93	+}
	94	+
	95	+
	96	+/**
	97	+ * cmp_connection_init - initializes a connection manager
	98	+ * @c: the connection manager to initialize
	99	+ * @unit: a unit of the target device
	100	+ * @ipcr_index: the index of the iPCR on the target device
	101	+ */
	102	+int cmp_connection_init(struct cmp_connection *c,
	103	+ struct fw_unit *unit,
	104	+ unsigned int ipcr_index)
	105	+{
	106	+ __be32 impr_be;
	107	+ u32 impr;
	108	+ int err;
	109	+
	110	+ err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST,
	111	+ CSR_REGISTER_BASE + CSR_IMPR,
	112	+ &impr_be, 4);
	113	+ if (err < 0)
	114	+ return err;
	115	+ impr = be32_to_cpu(impr_be);
	116	+
	117	+ if (ipcr_index >= (impr & IMPR_PLUGS_MASK))
	118	+ return -EINVAL;
	119	+
	120	+ c->connected = false;
	121	+ mutex_init(&c->mutex);
	122	+ fw_iso_resources_init(&c->resources, unit);
	123	+ c->last_pcr_value = cpu_to_be32(0x80000000);
	124	+ c->pcr_index = ipcr_index;
	125	+ c->max_speed = (impr & IMPR_SPEED_MASK) >> IMPR_SPEED_SHIFT;
	126	+ if (c->max_speed == SCODE_BETA)
	127	+ c->max_speed += (impr & IMPR_XSPEED_MASK) >> IMPR_XSPEED_SHIFT;
	128	+
	129	+ return 0;
	130	+}
	131	+EXPORT_SYMBOL(cmp_connection_init);
	132	+
	133	+/**
	134	+ * cmp_connection_destroy - free connection manager resources
	135	+ * @c: the connection manager
	136	+ */
	137	+void cmp_connection_destroy(struct cmp_connection *c)
	138	+{
	139	+ WARN_ON(c->connected);
	140	+ mutex_destroy(&c->mutex);
	141	+ fw_iso_resources_destroy(&c->resources);
	142	+}
	143	+EXPORT_SYMBOL(cmp_connection_destroy);
	144	+
	145	+
	146	+static __be32 ipcr_set_modify(struct cmp_connection *c, __be32 ipcr)
	147	+{
	148	+ ipcr &= ~cpu_to_be32(IPCR_BCAST_CONN \|
	149	+ IPCR_P2P_CONN_MASK \|
	150	+ IPCR_CHANNEL_MASK);
	151	+ ipcr \|= cpu_to_be32(1 << IPCR_P2P_CONN_SHIFT);
	152	+ ipcr \|= cpu_to_be32(c->resources.channel << IPCR_CHANNEL_SHIFT);
	153	+
	154	+ return ipcr;
	155	+}
	156	+
	157	+static int ipcr_set_check(struct cmp_connection *c, __be32 ipcr)
	158	+{
	159	+ if (ipcr & cpu_to_be32(IPCR_BCAST_CONN \|
	160	+ IPCR_P2P_CONN_MASK)) {
	161	+ cmp_error(c, "plug is already in use\n");
	162	+ return -EBUSY;
	163	+ }
	164	+ if (!(ipcr & cpu_to_be32(IPCR_ONLINE))) {
	165	+ cmp_error(c, "plug is not on-line\n");
	166	+ return -ECONNREFUSED;
	167	+ }
	168	+
	169	+ return 0;
	170	+}
	171	+
	172	+/**
	173	+ * cmp_connection_establish - establish a connection to the target
	174	+ * @c: the connection manager
	175	+ * @max_payload_bytes: the amount of data (including CIP headers) per packet
	176	+ *
	177	+ * This function establishes a point-to-point connection from the local
	178	+ * computer to the target by allocating isochronous resources (channel and
	179	+ * bandwidth) and setting the target's input plug control register. When this
	180	+ * function succeeds, the caller is responsible for starting transmitting
	181	+ * packets.
	182	+ */
	183	+int cmp_connection_establish(struct cmp_connection *c,
	184	+ unsigned int max_payload_bytes)
	185	+{
	186	+ int err;
	187	+
	188	+ if (WARN_ON(c->connected))
	189	+ return -EISCONN;
	190	+
	191	+ c->speed = min(c->max_speed,
	192	+ fw_parent_device(c->resources.unit)->max_speed);
	193	+
	194	+ mutex_lock(&c->mutex);
	195	+
	196	+retry_after_bus_reset:
	197	+ err = fw_iso_resources_allocate(&c->resources,
	198	+ max_payload_bytes, c->speed);
	199	+ if (err < 0)
	200	+ goto err_mutex;
	201	+
	202	+ err = pcr_modify(c, ipcr_set_modify, ipcr_set_check,
	203	+ ABORT_ON_BUS_RESET);
	204	+ if (err == -EAGAIN) {
	205	+ fw_iso_resources_free(&c->resources);
	206	+ goto retry_after_bus_reset;
	207	+ }
	208	+ if (err < 0)
	209	+ goto err_resources;
	210	+
	211	+ c->connected = true;
	212	+
	213	+ mutex_unlock(&c->mutex);
	214	+
	215	+ return 0;
	216	+
	217	+err_resources:
	218	+ fw_iso_resources_free(&c->resources);
	219	+err_mutex:
	220	+ mutex_unlock(&c->mutex);
	221	+
	222	+ return err;
	223	+}
	224	+EXPORT_SYMBOL(cmp_connection_establish);
	225	+
	226	+/**
	227	+ * cmp_connection_update - update the connection after a bus reset
	228	+ * @c: the connection manager
	229	+ *
	230	+ * This function must be called from the driver's .update handler to reestablish
	231	+ * any connection that might have been active.
	232	+ *
	233	+ * Returns zero on success, or a negative error code. On an error, the
	234	+ * connection is broken and the caller must stop transmitting iso packets.
	235	+ */
	236	+int cmp_connection_update(struct cmp_connection *c)
	237	+{
	238	+ int err;
	239	+
	240	+ mutex_lock(&c->mutex);
	241	+
	242	+ if (!c->connected) {
	243	+ mutex_unlock(&c->mutex);
	244	+ return 0;
	245	+ }
	246	+
	247	+ err = fw_iso_resources_update(&c->resources);
	248	+ if (err < 0)
	249	+ goto err_unconnect;
	250	+
	251	+ err = pcr_modify(c, ipcr_set_modify, ipcr_set_check,
	252	+ SUCCEED_ON_BUS_RESET);
	253	+ if (err < 0)
	254	+ goto err_resources;
	255	+
	256	+ mutex_unlock(&c->mutex);
	257	+
	258	+ return 0;
	259	+
	260	+err_resources:
	261	+ fw_iso_resources_free(&c->resources);
	262	+err_unconnect:
	263	+ c->connected = false;
	264	+ mutex_unlock(&c->mutex);
	265	+
	266	+ return err;
	267	+}
	268	+EXPORT_SYMBOL(cmp_connection_update);
	269	+
	270	+
	271	+static __be32 ipcr_break_modify(struct cmp_connection *c, __be32 ipcr)
	272	+{
	273	+ return ipcr & ~cpu_to_be32(IPCR_BCAST_CONN \| IPCR_P2P_CONN_MASK);
	274	+}
	275	+
	276	+/**
	277	+ * cmp_connection_break - break the connection to the target
	278	+ * @c: the connection manager
	279	+ *
	280	+ * This function deactives the connection in the target's input plug control
	281	+ * register, and frees the isochronous resources of the connection. Before
	282	+ * calling this function, the caller should cease transmitting packets.
	283	+ */
	284	+void cmp_connection_break(struct cmp_connection *c)
	285	+{
	286	+ int err;
	287	+
	288	+ mutex_lock(&c->mutex);
	289	+
	290	+ if (!c->connected) {
	291	+ mutex_unlock(&c->mutex);
	292	+ return;
	293	+ }
	294	+
	295	+ err = pcr_modify(c, ipcr_break_modify, NULL, SUCCEED_ON_BUS_RESET);
	296	+ if (err < 0)
	297	+ cmp_error(c, "plug is still connected\n");
	298	+
	299	+ fw_iso_resources_free(&c->resources);
	300	+
	301	+ c->connected = false;
	302	+
	303	+ mutex_unlock(&c->mutex);
	304	+}
	305	+EXPORT_SYMBOL(cmp_connection_break);