[linux-2.6-block.git] / sound / firewire / motu / motu-stream.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * motu-stream.c - a part of driver for MOTU FireWire series
 *
 * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
 */

#include "motu.h"

#define	CALLBACK_TIMEOUT	200

#define ISOC_COMM_CONTROL_OFFSET		0x0b00
#define  ISOC_COMM_CONTROL_MASK			0xffff0000
#define  CHANGE_RX_ISOC_COMM_STATE		0x80000000
#define  RX_ISOC_COMM_IS_ACTIVATED		0x40000000
#define  RX_ISOC_COMM_CHANNEL_MASK		0x3f000000
#define  RX_ISOC_COMM_CHANNEL_SHIFT		24
#define  CHANGE_TX_ISOC_COMM_STATE		0x00800000
#define  TX_ISOC_COMM_IS_ACTIVATED		0x00400000
#define  TX_ISOC_COMM_CHANNEL_MASK		0x003f0000
#define  TX_ISOC_COMM_CHANNEL_SHIFT		16

#define PACKET_FORMAT_OFFSET			0x0b10
#define  TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS	0x00000080
#define  RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS	0x00000040
#define  TX_PACKET_TRANSMISSION_SPEED_MASK	0x0000000f

static int keep_resources(struct snd_motu *motu, unsigned int rate,
			  struct amdtp_stream *stream)
{
	struct fw_iso_resources *resources;
	struct snd_motu_packet_format *packet_format;
	unsigned int midi_ports = 0;
	int err;

	if (stream == &motu->rx_stream) {
		resources = &motu->rx_resources;
		packet_format = &motu->rx_packet_formats;

		if ((motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) ||
		    (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q))
			midi_ports = 1;
	} else {
		resources = &motu->tx_resources;
		packet_format = &motu->tx_packet_formats;

		if ((motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) ||
		    (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q))
			midi_ports = 1;
	}

	err = amdtp_motu_set_parameters(stream, rate, midi_ports,
					packet_format);
	if (err < 0)
		return err;

	return fw_iso_resources_allocate(resources,
				amdtp_stream_get_max_payload(stream),
				fw_parent_device(motu->unit)->max_speed);
}

static int begin_session(struct snd_motu *motu)
{
	__be32 reg;
	u32 data;
	int err;

	// Configure the unit to start isochronous communication.
	err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
					sizeof(reg));
	if (err < 0)
		return err;
	data = be32_to_cpu(reg) & ~ISOC_COMM_CONTROL_MASK;

	data |= CHANGE_RX_ISOC_COMM_STATE | RX_ISOC_COMM_IS_ACTIVATED |
		(motu->rx_resources.channel << RX_ISOC_COMM_CHANNEL_SHIFT) |
		CHANGE_TX_ISOC_COMM_STATE | TX_ISOC_COMM_IS_ACTIVATED |
		(motu->tx_resources.channel << TX_ISOC_COMM_CHANNEL_SHIFT);

	reg = cpu_to_be32(data);
	return snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
					  sizeof(reg));
}

static void finish_session(struct snd_motu *motu)
{
	__be32 reg;
	u32 data;
	int err;

	err = motu->spec->protocol->switch_fetching_mode(motu, false);
	if (err < 0)
		return;

	err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
					sizeof(reg));
	if (err < 0)
		return;
	data = be32_to_cpu(reg);

	data &= ~(RX_ISOC_COMM_IS_ACTIVATED | TX_ISOC_COMM_IS_ACTIVATED);
	data |= CHANGE_RX_ISOC_COMM_STATE | CHANGE_TX_ISOC_COMM_STATE;

	reg = cpu_to_be32(data);
	snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
				   sizeof(reg));
}

int snd_motu_stream_cache_packet_formats(struct snd_motu *motu)
{
	int err;

	err = motu->spec->protocol->cache_packet_formats(motu);
	if (err < 0)
		return err;

	if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) {
		motu->tx_packet_formats.midi_flag_offset = 4;
		motu->tx_packet_formats.midi_byte_offset = 6;
	} else if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q) {
		motu->tx_packet_formats.midi_flag_offset = 8;
		motu->tx_packet_formats.midi_byte_offset = 7;
	}

	if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) {
		motu->rx_packet_formats.midi_flag_offset = 4;
		motu->rx_packet_formats.midi_byte_offset = 6;
	} else if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) {
		motu->rx_packet_formats.midi_flag_offset = 8;
		motu->rx_packet_formats.midi_byte_offset = 7;
	}

	return 0;
}

int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate,
				   unsigned int frames_per_period,
				   unsigned int frames_per_buffer)
{
	unsigned int curr_rate;
	int err;

	err = motu->spec->protocol->get_clock_rate(motu, &curr_rate);
	if (err < 0)
		return err;
	if (rate == 0)
		rate = curr_rate;

	if (motu->substreams_counter == 0 || curr_rate != rate) {
		amdtp_domain_stop(&motu->domain);
		finish_session(motu);

		fw_iso_resources_free(&motu->tx_resources);
		fw_iso_resources_free(&motu->rx_resources);

		err = motu->spec->protocol->set_clock_rate(motu, rate);
		if (err < 0) {
			dev_err(&motu->unit->device,
				"fail to set sampling rate: %d\n", err);
			return err;
		}

		err = snd_motu_stream_cache_packet_formats(motu);
		if (err < 0)
			return err;

		err = keep_resources(motu, rate, &motu->tx_stream);
		if (err < 0)
			return err;

		err = keep_resources(motu, rate, &motu->rx_stream);
		if (err < 0) {
			fw_iso_resources_free(&motu->tx_resources);
			return err;
		}

		err = amdtp_domain_set_events_per_period(&motu->domain,
					frames_per_period, frames_per_buffer);
		if (err < 0) {
			fw_iso_resources_free(&motu->tx_resources);
			fw_iso_resources_free(&motu->rx_resources);
			return err;
		}
	}

	return 0;
}

static int ensure_packet_formats(struct snd_motu *motu)
{
	__be32 reg;
	u32 data;
	int err;

	err = snd_motu_transaction_read(motu, PACKET_FORMAT_OFFSET, &reg,
					sizeof(reg));
	if (err < 0)
		return err;
	data = be32_to_cpu(reg);

	data &= ~(TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS |
		  RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS|
		  TX_PACKET_TRANSMISSION_SPEED_MASK);
	if (motu->tx_packet_formats.differed_part_pcm_chunks[0] == 0)
		data |= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
	if (motu->rx_packet_formats.differed_part_pcm_chunks[0] == 0)
		data |= RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
	data |= fw_parent_device(motu->unit)->max_speed;

	reg = cpu_to_be32(data);
	return snd_motu_transaction_write(motu, PACKET_FORMAT_OFFSET, &reg,
					  sizeof(reg));
}

int snd_motu_stream_start_duplex(struct snd_motu *motu)
{
	unsigned int generation = motu->rx_resources.generation;
	int err = 0;

	if (motu->substreams_counter == 0)
		return 0;

	if (amdtp_streaming_error(&motu->rx_stream) ||
	    amdtp_streaming_error(&motu->tx_stream)) {
		amdtp_domain_stop(&motu->domain);
		finish_session(motu);
	}

	if (generation != fw_parent_device(motu->unit)->card->generation) {
		err = fw_iso_resources_update(&motu->rx_resources);
		if (err < 0)
			return err;

		err = fw_iso_resources_update(&motu->tx_resources);
		if (err < 0)
			return err;
	}

	if (!amdtp_stream_running(&motu->rx_stream)) {
		int spd = fw_parent_device(motu->unit)->max_speed;

		err = ensure_packet_formats(motu);
		if (err < 0)
			return err;

		err = begin_session(motu);
		if (err < 0) {
			dev_err(&motu->unit->device,
				"fail to start isochronous comm: %d\n", err);
			goto stop_streams;
		}

		err = amdtp_domain_add_stream(&motu->domain, &motu->tx_stream,
					      motu->tx_resources.channel, spd);
		if (err < 0)
			goto stop_streams;

		err = amdtp_domain_add_stream(&motu->domain, &motu->rx_stream,
					      motu->rx_resources.channel, spd);
		if (err < 0)
			goto stop_streams;

		err = amdtp_domain_start(&motu->domain, 0);
		if (err < 0)
			goto stop_streams;

		if (!amdtp_stream_wait_callback(&motu->tx_stream,
						CALLBACK_TIMEOUT) ||
		    !amdtp_stream_wait_callback(&motu->rx_stream,
						CALLBACK_TIMEOUT)) {
			err = -ETIMEDOUT;
			goto stop_streams;
		}

		err = motu->spec->protocol->switch_fetching_mode(motu, true);
		if (err < 0) {
			dev_err(&motu->unit->device,
				"fail to enable frame fetching: %d\n", err);
			goto stop_streams;
		}
	}

	return 0;

stop_streams:
	amdtp_domain_stop(&motu->domain);
	finish_session(motu);
	return err;
}

void snd_motu_stream_stop_duplex(struct snd_motu *motu)
{
	if (motu->substreams_counter == 0) {
		amdtp_domain_stop(&motu->domain);
		finish_session(motu);

		fw_iso_resources_free(&motu->tx_resources);
		fw_iso_resources_free(&motu->rx_resources);
	}
}

static int init_stream(struct snd_motu *motu, struct amdtp_stream *s)
{
	struct fw_iso_resources *resources;
	enum amdtp_stream_direction dir;
	int err;

	if (s == &motu->tx_stream) {
		resources = &motu->tx_resources;
		dir = AMDTP_IN_STREAM;
	} else {
		resources = &motu->rx_resources;
		dir = AMDTP_OUT_STREAM;
	}

	err = fw_iso_resources_init(resources, motu->unit);
	if (err < 0)
		return err;

	err = amdtp_motu_init(s, motu->unit, dir, motu->spec->protocol);
	if (err < 0)
		fw_iso_resources_destroy(resources);

	return err;
}

static void destroy_stream(struct snd_motu *motu, struct amdtp_stream *s)
{
	amdtp_stream_destroy(s);

	if (s == &motu->tx_stream)
		fw_iso_resources_destroy(&motu->tx_resources);
	else
		fw_iso_resources_destroy(&motu->rx_resources);
}

int snd_motu_stream_init_duplex(struct snd_motu *motu)
{
	int err;

	err = init_stream(motu, &motu->tx_stream);
	if (err < 0)
		return err;

	err = init_stream(motu, &motu->rx_stream);
	if (err < 0) {
		destroy_stream(motu, &motu->tx_stream);
		return err;
	}

	err = amdtp_domain_init(&motu->domain);
	if (err < 0) {
		destroy_stream(motu, &motu->tx_stream);
		destroy_stream(motu, &motu->rx_stream);
	}

	return err;
}

// This function should be called before starting streams or after stopping
// streams.
void snd_motu_stream_destroy_duplex(struct snd_motu *motu)
{
	amdtp_domain_destroy(&motu->domain);

	destroy_stream(motu, &motu->rx_stream);
	destroy_stream(motu, &motu->tx_stream);

	motu->substreams_counter = 0;
}

static void motu_lock_changed(struct snd_motu *motu)
{
	motu->dev_lock_changed = true;
	wake_up(&motu->hwdep_wait);
}

int snd_motu_stream_lock_try(struct snd_motu *motu)
{
	int err;

	spin_lock_irq(&motu->lock);

	if (motu->dev_lock_count < 0) {
		err = -EBUSY;
		goto out;
	}

	if (motu->dev_lock_count++ == 0)
		motu_lock_changed(motu);
	err = 0;
out:
	spin_unlock_irq(&motu->lock);
	return err;
}

void snd_motu_stream_lock_release(struct snd_motu *motu)
{
	spin_lock_irq(&motu->lock);

	if (WARN_ON(motu->dev_lock_count <= 0))
		goto out;

	if (--motu->dev_lock_count == 0)
		motu_lock_changed(motu);
out:
	spin_unlock_irq(&motu->lock);
}
Commit	Line	Data
da607e19	1	// SPDX-License-Identifier: GPL-2.0-only
9b2bb4f2 TS	2	/*
	3	* motu-stream.c - a part of driver for MOTU FireWire series
	4	*
	5	* Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
9b2bb4f2 TS	6	*/
	7
	8	#include "motu.h"
	9
	10	#define CALLBACK_TIMEOUT 200
	11
	12	#define ISOC_COMM_CONTROL_OFFSET 0x0b00
	13	#define ISOC_COMM_CONTROL_MASK 0xffff0000
	14	#define CHANGE_RX_ISOC_COMM_STATE 0x80000000
	15	#define RX_ISOC_COMM_IS_ACTIVATED 0x40000000
	16	#define RX_ISOC_COMM_CHANNEL_MASK 0x3f000000
	17	#define RX_ISOC_COMM_CHANNEL_SHIFT 24
	18	#define CHANGE_TX_ISOC_COMM_STATE 0x00800000
	19	#define TX_ISOC_COMM_IS_ACTIVATED 0x00400000
	20	#define TX_ISOC_COMM_CHANNEL_MASK 0x003f0000
	21	#define TX_ISOC_COMM_CHANNEL_SHIFT 16
	22
	23	#define PACKET_FORMAT_OFFSET 0x0b10
	24	#define TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS 0x00000080
	25	#define RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS 0x00000040
	26	#define TX_PACKET_TRANSMISSION_SPEED_MASK 0x0000000f
	27
8350132e TS	28	static int keep_resources(struct snd_motu *motu, unsigned int rate,
8350132e TS	29	struct amdtp_stream *stream)
9b2bb4f2	30	{
8350132e TS	31	struct fw_iso_resources *resources;
8350132e TS	32	struct snd_motu_packet_format *packet_format;
9e796e7d	33	unsigned int midi_ports = 0;
9b2bb4f2 TS	34	int err;
9b2bb4f2 TS	35
8350132e TS	36	if (stream == &motu->rx_stream) {
	37	resources = &motu->rx_resources;
	38	packet_format = &motu->rx_packet_formats;
9e796e7d	39
8350132e TS	40	if ((motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) \|\|
	41	(motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q))
	42	midi_ports = 1;
	43	} else {
	44	resources = &motu->tx_resources;
	45	packet_format = &motu->tx_packet_formats;
9b2bb4f2	46
8350132e TS	47	if ((motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) \|\|
	48	(motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q))
	49	midi_ports = 1;
	50	}
8b460c76	51
8350132e TS	52	err = amdtp_motu_set_parameters(stream, rate, midi_ports,
8350132e TS	53	packet_format);
9b2bb4f2 TS	54	if (err < 0)
	55	return err;
	56
8350132e TS	57	return fw_iso_resources_allocate(resources,
8350132e TS	58	amdtp_stream_get_max_payload(stream),
9b2bb4f2	59	fw_parent_device(motu->unit)->max_speed);
8350132e TS	60	}
8350132e TS	61
8edc56ec	62	static int begin_session(struct snd_motu *motu)
8350132e TS	63	{
	64	__be32 reg;
	65	u32 data;
	66	int err;
	67
8350132e	68	// Configure the unit to start isochronous communication.
9b2bb4f2 TS	69	err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
	70	sizeof(reg));
	71	if (err < 0)
	72	return err;
	73	data = be32_to_cpu(reg) & ~ISOC_COMM_CONTROL_MASK;
	74
	75	data \|= CHANGE_RX_ISOC_COMM_STATE \| RX_ISOC_COMM_IS_ACTIVATED \|
	76	(motu->rx_resources.channel << RX_ISOC_COMM_CHANNEL_SHIFT) \|
	77	CHANGE_TX_ISOC_COMM_STATE \| TX_ISOC_COMM_IS_ACTIVATED \|
	78	(motu->tx_resources.channel << TX_ISOC_COMM_CHANNEL_SHIFT);
	79
	80	reg = cpu_to_be32(data);
	81	return snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
	82	sizeof(reg));
	83	}
	84
b66ab142	85	static void finish_session(struct snd_motu *motu)
9b2bb4f2 TS	86	{
	87	__be32 reg;
	88	u32 data;
	89	int err;
	90
	91	err = motu->spec->protocol->switch_fetching_mode(motu, false);
	92	if (err < 0)
	93	return;
	94
	95	err = snd_motu_transaction_read(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
	96	sizeof(reg));
	97	if (err < 0)
	98	return;
	99	data = be32_to_cpu(reg);
	100
	101	data &= ~(RX_ISOC_COMM_IS_ACTIVATED \| TX_ISOC_COMM_IS_ACTIVATED);
	102	data \|= CHANGE_RX_ISOC_COMM_STATE \| CHANGE_TX_ISOC_COMM_STATE;
	103
	104	reg = cpu_to_be32(data);
	105	snd_motu_transaction_write(motu, ISOC_COMM_CONTROL_OFFSET, &reg,
	106	sizeof(reg));
9b2bb4f2 TS	107	}
9b2bb4f2 TS	108
8b460c76 TS	109	int snd_motu_stream_cache_packet_formats(struct snd_motu *motu)
	110	{
	111	int err;
	112
	113	err = motu->spec->protocol->cache_packet_formats(motu);
	114	if (err < 0)
	115	return err;
	116
	117	if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_2ND_Q) {
	118	motu->tx_packet_formats.midi_flag_offset = 4;
	119	motu->tx_packet_formats.midi_byte_offset = 6;
	120	} else if (motu->spec->flags & SND_MOTU_SPEC_TX_MIDI_3RD_Q) {
	121	motu->tx_packet_formats.midi_flag_offset = 8;
	122	motu->tx_packet_formats.midi_byte_offset = 7;
	123	}
	124
	125	if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_2ND_Q) {
	126	motu->rx_packet_formats.midi_flag_offset = 4;
	127	motu->rx_packet_formats.midi_byte_offset = 6;
	128	} else if (motu->spec->flags & SND_MOTU_SPEC_RX_MIDI_3RD_Q) {
	129	motu->rx_packet_formats.midi_flag_offset = 8;
	130	motu->rx_packet_formats.midi_byte_offset = 7;
	131	}
	132
	133	return 0;
	134	}
	135
0d39cd0e	136	int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate,
0f5482e7 TS	137	unsigned int frames_per_period,
0f5482e7 TS	138	unsigned int frames_per_buffer)
8edc56ec TS	139	{
	140	unsigned int curr_rate;
	141	int err;
	142
	143	err = motu->spec->protocol->get_clock_rate(motu, &curr_rate);
	144	if (err < 0)
	145	return err;
	146	if (rate == 0)
	147	rate = curr_rate;
	148
	149	if (motu->substreams_counter == 0 \|\| curr_rate != rate) {
ccc6c1b0	150	amdtp_domain_stop(&motu->domain);
8edc56ec TS	151	finish_session(motu);
	152
	153	fw_iso_resources_free(&motu->tx_resources);
	154	fw_iso_resources_free(&motu->rx_resources);
	155
	156	err = motu->spec->protocol->set_clock_rate(motu, rate);
	157	if (err < 0) {
	158	dev_err(&motu->unit->device,
	159	"fail to set sampling rate: %d\n", err);
	160	return err;
	161	}
	162
	163	err = snd_motu_stream_cache_packet_formats(motu);
	164	if (err < 0)
	165	return err;
	166
	167	err = keep_resources(motu, rate, &motu->tx_stream);
	168	if (err < 0)
	169	return err;
	170
	171	err = keep_resources(motu, rate, &motu->rx_stream);
	172	if (err < 0) {
	173	fw_iso_resources_free(&motu->tx_resources);
	174	return err;
	175	}
0d39cd0e TS	176
0d39cd0e TS	177	err = amdtp_domain_set_events_per_period(&motu->domain,
0f5482e7	178	frames_per_period, frames_per_buffer);
0d39cd0e TS	179	if (err < 0) {
	180	fw_iso_resources_free(&motu->tx_resources);
	181	fw_iso_resources_free(&motu->rx_resources);
	182	return err;
	183	}
8edc56ec TS	184	}
	185
	186	return 0;
	187	}
	188
9b2bb4f2 TS	189	static int ensure_packet_formats(struct snd_motu *motu)
	190	{
	191	__be32 reg;
	192	u32 data;
	193	int err;
	194
	195	err = snd_motu_transaction_read(motu, PACKET_FORMAT_OFFSET, &reg,
	196	sizeof(reg));
	197	if (err < 0)
	198	return err;
	199	data = be32_to_cpu(reg);
	200
	201	data &= ~(TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS \|
	202	RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS\|
	203	TX_PACKET_TRANSMISSION_SPEED_MASK);
	204	if (motu->tx_packet_formats.differed_part_pcm_chunks[0] == 0)
	205	data \|= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
	206	if (motu->rx_packet_formats.differed_part_pcm_chunks[0] == 0)
	207	data \|= RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
	208	data \|= fw_parent_device(motu->unit)->max_speed;
	209
	210	reg = cpu_to_be32(data);
	211	return snd_motu_transaction_write(motu, PACKET_FORMAT_OFFSET, &reg,
	212	sizeof(reg));
	213	}
	214
8edc56ec	215	int snd_motu_stream_start_duplex(struct snd_motu *motu)
9b2bb4f2	216	{
2d103420	217	unsigned int generation = motu->rx_resources.generation;
9b2bb4f2 TS	218	int err = 0;
9b2bb4f2 TS	219
18f26034	220	if (motu->substreams_counter == 0)
9b2bb4f2 TS	221	return 0;
9b2bb4f2 TS	222
8edc56ec	223	if (amdtp_streaming_error(&motu->rx_stream) \|\|
ccc6c1b0 TS	224	amdtp_streaming_error(&motu->tx_stream)) {
ccc6c1b0 TS	225	amdtp_domain_stop(&motu->domain);
b66ab142	226	finish_session(motu);
ccc6c1b0	227	}
9b2bb4f2	228
2d103420 TS	229	if (generation != fw_parent_device(motu->unit)->card->generation) {
	230	err = fw_iso_resources_update(&motu->rx_resources);
	231	if (err < 0)
	232	return err;
	233
	234	err = fw_iso_resources_update(&motu->tx_resources);
	235	if (err < 0)
	236	return err;
	237	}
	238
9b2bb4f2	239	if (!amdtp_stream_running(&motu->rx_stream)) {
ccc6c1b0 TS	240	int spd = fw_parent_device(motu->unit)->max_speed;
ccc6c1b0 TS	241
9b2bb4f2 TS	242	err = ensure_packet_formats(motu);
	243	if (err < 0)
	244	return err;
	245
8edc56ec	246	err = begin_session(motu);
9b2bb4f2 TS	247	if (err < 0) {
	248	dev_err(&motu->unit->device,
	249	"fail to start isochronous comm: %d\n", err);
f16e666b	250	goto stop_streams;
9b2bb4f2 TS	251	}
9b2bb4f2 TS	252
ccc6c1b0 TS	253	err = amdtp_domain_add_stream(&motu->domain, &motu->tx_stream,
	254	motu->tx_resources.channel, spd);
	255	if (err < 0)
f16e666b	256	goto stop_streams;
9b2bb4f2	257
ccc6c1b0 TS	258	err = amdtp_domain_add_stream(&motu->domain, &motu->rx_stream,
	259	motu->rx_resources.channel, spd);
	260	if (err < 0)
	261	goto stop_streams;
	262
acfedcbe	263	err = amdtp_domain_start(&motu->domain, 0);
ccc6c1b0 TS	264	if (err < 0)
	265	goto stop_streams;
	266
	267	if (!amdtp_stream_wait_callback(&motu->tx_stream,
	268	CALLBACK_TIMEOUT) \|\|
	269	!amdtp_stream_wait_callback(&motu->rx_stream,
	270	CALLBACK_TIMEOUT)) {
	271	err = -ETIMEDOUT;
f16e666b	272	goto stop_streams;
9b2bb4f2	273	}
9b2bb4f2	274
ccc6c1b0	275	err = motu->spec->protocol->switch_fetching_mode(motu, true);
9b2bb4f2 TS	276	if (err < 0) {
9b2bb4f2 TS	277	dev_err(&motu->unit->device,
ccc6c1b0	278	"fail to enable frame fetching: %d\n", err);
f16e666b	279	goto stop_streams;
9b2bb4f2 TS	280	}
	281	}
	282
	283	return 0;
f16e666b ME	284
f16e666b ME	285	stop_streams:
ccc6c1b0	286	amdtp_domain_stop(&motu->domain);
b66ab142	287	finish_session(motu);
f16e666b	288	return err;
9b2bb4f2 TS	289	}
	290
	291	void snd_motu_stream_stop_duplex(struct snd_motu *motu)
	292	{
eccd895c	293	if (motu->substreams_counter == 0) {
ccc6c1b0	294	amdtp_domain_stop(&motu->domain);
ec694fba	295	finish_session(motu);
eccd895c TS	296
	297	fw_iso_resources_free(&motu->tx_resources);
	298	fw_iso_resources_free(&motu->rx_resources);
	299	}
9b2bb4f2 TS	300	}
9b2bb4f2 TS	301
39e522a5	302	static int init_stream(struct snd_motu motu, struct amdtp_stream s)
9b2bb4f2	303	{
9b2bb4f2	304	struct fw_iso_resources *resources;
39e522a5 TS	305	enum amdtp_stream_direction dir;
39e522a5 TS	306	int err;
9b2bb4f2	307
39e522a5	308	if (s == &motu->tx_stream) {
9b2bb4f2	309	resources = &motu->tx_resources;
39e522a5	310	dir = AMDTP_IN_STREAM;
9b2bb4f2	311	} else {
9b2bb4f2	312	resources = &motu->rx_resources;
39e522a5	313	dir = AMDTP_OUT_STREAM;
9b2bb4f2 TS	314	}
	315
	316	err = fw_iso_resources_init(resources, motu->unit);
	317	if (err < 0)
	318	return err;
	319
39e522a5 TS	320	err = amdtp_motu_init(s, motu->unit, dir, motu->spec->protocol);
39e522a5 TS	321	if (err < 0)
9b2bb4f2	322	fw_iso_resources_destroy(resources);
9b2bb4f2 TS	323
	324	return err;
	325	}
	326
39e522a5	327	static void destroy_stream(struct snd_motu motu, struct amdtp_stream s)
9b2bb4f2	328	{
39e522a5	329	amdtp_stream_destroy(s);
9b2bb4f2	330
39e522a5 TS	331	if (s == &motu->tx_stream)
	332	fw_iso_resources_destroy(&motu->tx_resources);
	333	else
	334	fw_iso_resources_destroy(&motu->rx_resources);
9b2bb4f2 TS	335	}
	336
	337	int snd_motu_stream_init_duplex(struct snd_motu *motu)
	338	{
	339	int err;
	340
39e522a5	341	err = init_stream(motu, &motu->tx_stream);
9b2bb4f2 TS	342	if (err < 0)
	343	return err;
	344
39e522a5	345	err = init_stream(motu, &motu->rx_stream);
ccc6c1b0	346	if (err < 0) {
39e522a5	347	destroy_stream(motu, &motu->tx_stream);
ccc6c1b0 TS	348	return err;
	349	}
	350
	351	err = amdtp_domain_init(&motu->domain);
	352	if (err < 0) {
	353	destroy_stream(motu, &motu->tx_stream);
	354	destroy_stream(motu, &motu->rx_stream);
	355	}
9b2bb4f2 TS	356
	357	return err;
	358	}
	359
ccc6c1b0 TS	360	// This function should be called before starting streams or after stopping
ccc6c1b0 TS	361	// streams.
9b2bb4f2 TS	362	void snd_motu_stream_destroy_duplex(struct snd_motu *motu)
9b2bb4f2 TS	363	{
ccc6c1b0 TS	364	amdtp_domain_destroy(&motu->domain);
ccc6c1b0 TS	365
39e522a5 TS	366	destroy_stream(motu, &motu->rx_stream);
39e522a5 TS	367	destroy_stream(motu, &motu->tx_stream);
9b2bb4f2	368
18f26034	369	motu->substreams_counter = 0;
9b2bb4f2	370	}
71c37977 TS	371
	372	static void motu_lock_changed(struct snd_motu *motu)
	373	{
	374	motu->dev_lock_changed = true;
	375	wake_up(&motu->hwdep_wait);
	376	}
	377
	378	int snd_motu_stream_lock_try(struct snd_motu *motu)
	379	{
	380	int err;
	381
	382	spin_lock_irq(&motu->lock);
	383
	384	if (motu->dev_lock_count < 0) {
	385	err = -EBUSY;
	386	goto out;
	387	}
	388
	389	if (motu->dev_lock_count++ == 0)
	390	motu_lock_changed(motu);
	391	err = 0;
	392	out:
	393	spin_unlock_irq(&motu->lock);
	394	return err;
	395	}
	396
	397	void snd_motu_stream_lock_release(struct snd_motu *motu)
	398	{
	399	spin_lock_irq(&motu->lock);
	400
	401	if (WARN_ON(motu->dev_lock_count <= 0))
	402	goto out;
	403
	404	if (--motu->dev_lock_count == 0)
	405	motu_lock_changed(motu);
	406	out:
	407	spin_unlock_irq(&motu->lock);
	408	}