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

/*
 * digi00x-stream.c - a part of driver for Digidesign Digi 002/003 family
 *
 * Copyright (c) 2014-2015 Takashi Sakamoto
 *
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include "digi00x.h"

#define CALLBACK_TIMEOUT 500

const unsigned int snd_dg00x_stream_rates[SND_DG00X_RATE_COUNT] = {
	[SND_DG00X_RATE_44100] = 44100,
	[SND_DG00X_RATE_48000] = 48000,
	[SND_DG00X_RATE_88200] = 88200,
	[SND_DG00X_RATE_96000] = 96000,
};

/* Multi Bit Linear Audio data channels for each sampling transfer frequency. */
const unsigned int
snd_dg00x_stream_pcm_channels[SND_DG00X_RATE_COUNT] = {
	/* Analog/ADAT/SPDIF */
	[SND_DG00X_RATE_44100] = (8 + 8 + 2),
	[SND_DG00X_RATE_48000] = (8 + 8 + 2),
	/* Analog/SPDIF */
	[SND_DG00X_RATE_88200] = (8 + 2),
	[SND_DG00X_RATE_96000] = (8 + 2),
};

int snd_dg00x_stream_get_local_rate(struct snd_dg00x *dg00x, unsigned int *rate)
{
	u32 data;
	__be32 reg;
	int err;

	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
				 DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	data = be32_to_cpu(reg) & 0x0f;
	if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
		*rate = snd_dg00x_stream_rates[data];
	else
		err = -EIO;

	return err;
}

int snd_dg00x_stream_set_local_rate(struct snd_dg00x *dg00x, unsigned int rate)
{
	__be32 reg;
	unsigned int i;

	for (i = 0; i < ARRAY_SIZE(snd_dg00x_stream_rates); i++) {
		if (rate == snd_dg00x_stream_rates[i])
			break;
	}
	if (i == ARRAY_SIZE(snd_dg00x_stream_rates))
		return -EINVAL;

	reg = cpu_to_be32(i);
	return snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
				  DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
				  &reg, sizeof(reg), 0);
}

int snd_dg00x_stream_get_clock(struct snd_dg00x *dg00x,
			       enum snd_dg00x_clock *clock)
{
	__be32 reg;
	int err;

	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
				 DG00X_ADDR_BASE + DG00X_OFFSET_CLOCK_SOURCE,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	*clock = be32_to_cpu(reg) & 0x0f;
	if (*clock >= SND_DG00X_CLOCK_COUNT)
		err = -EIO;

	return err;
}

int snd_dg00x_stream_check_external_clock(struct snd_dg00x *dg00x, bool *detect)
{
	__be32 reg;
	int err;

	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
				 DG00X_ADDR_BASE + DG00X_OFFSET_DETECT_EXTERNAL,
				 &reg, sizeof(reg), 0);
	if (err >= 0)
		*detect = be32_to_cpu(reg) > 0;

	return err;
}

int snd_dg00x_stream_get_external_rate(struct snd_dg00x *dg00x,
				       unsigned int *rate)
{
	u32 data;
	__be32 reg;
	int err;

	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
				 DG00X_ADDR_BASE + DG00X_OFFSET_EXTERNAL_RATE,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	data = be32_to_cpu(reg) & 0x0f;
	if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
		*rate = snd_dg00x_stream_rates[data];
	/* This means desync. */
	else
		err = -EBUSY;

	return err;
}

static void finish_session(struct snd_dg00x *dg00x)
{
	__be32 data = cpu_to_be32(0x00000003);

	snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
			   DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_SET,
			   &data, sizeof(data), 0);
}

static int begin_session(struct snd_dg00x *dg00x)
{
	__be32 data;
	u32 curr;
	int err;

	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
				 DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_STATE,
				 &data, sizeof(data), 0);
	if (err < 0)
		goto error;
	curr = be32_to_cpu(data);

	if (curr == 0)
		curr = 2;

	curr--;
	while (curr > 0) {
		data = cpu_to_be32(curr);
		err = snd_fw_transaction(dg00x->unit,
					 TCODE_WRITE_QUADLET_REQUEST,
					 DG00X_ADDR_BASE +
					 DG00X_OFFSET_STREAMING_SET,
					 &data, sizeof(data), 0);
		if (err < 0)
			goto error;

		msleep(20);
		curr--;
	}

	return 0;
error:
	finish_session(dg00x);
	return err;
}

static void release_resources(struct snd_dg00x *dg00x)
{
	__be32 data = 0;

	/* Unregister isochronous channels for both direction. */
	snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
			   DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
			   &data, sizeof(data), 0);

	/* Release isochronous resources. */
	fw_iso_resources_free(&dg00x->tx_resources);
	fw_iso_resources_free(&dg00x->rx_resources);
}

static int keep_resources(struct snd_dg00x *dg00x, unsigned int rate)
{
	unsigned int i;
	__be32 data;
	int err;

	/* Check sampling rate. */
	for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
		if (snd_dg00x_stream_rates[i] == rate)
			break;
	}
	if (i == SND_DG00X_RATE_COUNT)
		return -EINVAL;

	/* Keep resources for out-stream. */
	err = amdtp_dot_set_parameters(&dg00x->rx_stream, rate,
				       snd_dg00x_stream_pcm_channels[i]);
	if (err < 0)
		return err;
	err = fw_iso_resources_allocate(&dg00x->rx_resources,
				amdtp_stream_get_max_payload(&dg00x->rx_stream),
				fw_parent_device(dg00x->unit)->max_speed);
	if (err < 0)
		return err;

	/* Keep resources for in-stream. */
	err = amdtp_dot_set_parameters(&dg00x->tx_stream, rate,
				       snd_dg00x_stream_pcm_channels[i]);
	if (err < 0)
		return err;
	err = fw_iso_resources_allocate(&dg00x->tx_resources,
				amdtp_stream_get_max_payload(&dg00x->tx_stream),
				fw_parent_device(dg00x->unit)->max_speed);
	if (err < 0)
		goto error;

	/* Register isochronous channels for both direction. */
	data = cpu_to_be32((dg00x->tx_resources.channel << 16) |
			   dg00x->rx_resources.channel);
	err = snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
				 DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
				 &data, sizeof(data), 0);
	if (err < 0)
		goto error;

	return 0;
error:
	release_resources(dg00x);
	return err;
}

int snd_dg00x_stream_init_duplex(struct snd_dg00x *dg00x)
{
	int err;

	/* For out-stream. */
	err = fw_iso_resources_init(&dg00x->rx_resources, dg00x->unit);
	if (err < 0)
		goto error;
	err = amdtp_dot_init(&dg00x->rx_stream, dg00x->unit, AMDTP_OUT_STREAM);
	if (err < 0)
		goto error;

	/* For in-stream. */
	err = fw_iso_resources_init(&dg00x->tx_resources, dg00x->unit);
	if (err < 0)
		goto error;
	err = amdtp_dot_init(&dg00x->tx_stream, dg00x->unit, AMDTP_IN_STREAM);
	if (err < 0)
		goto error;

	return 0;
error:
	snd_dg00x_stream_destroy_duplex(dg00x);
	return err;
}

/*
 * This function should be called before starting streams or after stopping
 * streams.
 */
void snd_dg00x_stream_destroy_duplex(struct snd_dg00x *dg00x)
{
	amdtp_stream_destroy(&dg00x->rx_stream);
	fw_iso_resources_destroy(&dg00x->rx_resources);

	amdtp_stream_destroy(&dg00x->tx_stream);
	fw_iso_resources_destroy(&dg00x->tx_resources);
}

int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x, unsigned int rate)
{
	unsigned int curr_rate;
	int err = 0;

	if (dg00x->substreams_counter == 0)
		goto end;

	/* Check current sampling rate. */
	err = snd_dg00x_stream_get_local_rate(dg00x, &curr_rate);
	if (err < 0)
		goto error;
	if (rate == 0)
		rate = curr_rate;
	if (curr_rate != rate ||
	    amdtp_streaming_error(&dg00x->tx_stream) ||
	    amdtp_streaming_error(&dg00x->rx_stream)) {
		finish_session(dg00x);

		amdtp_stream_stop(&dg00x->tx_stream);
		amdtp_stream_stop(&dg00x->rx_stream);
		release_resources(dg00x);
	}

	/*
	 * No packets are transmitted without receiving packets, reagardless of
	 * which source of clock is used.
	 */
	if (!amdtp_stream_running(&dg00x->rx_stream)) {
		err = snd_dg00x_stream_set_local_rate(dg00x, rate);
		if (err < 0)
			goto error;

		err = keep_resources(dg00x, rate);
		if (err < 0)
			goto error;

		err = begin_session(dg00x);
		if (err < 0)
			goto error;

		err = amdtp_stream_start(&dg00x->rx_stream,
				dg00x->rx_resources.channel,
				fw_parent_device(dg00x->unit)->max_speed);
		if (err < 0)
			goto error;

		if (!amdtp_stream_wait_callback(&dg00x->rx_stream,
					      CALLBACK_TIMEOUT)) {
			err = -ETIMEDOUT;
			goto error;
		}
	}

	/*
	 * The value of SYT field in transmitted packets is always 0x0000. Thus,
	 * duplex streams with timestamp synchronization cannot be built.
	 */
	if (!amdtp_stream_running(&dg00x->tx_stream)) {
		err = amdtp_stream_start(&dg00x->tx_stream,
				dg00x->tx_resources.channel,
				fw_parent_device(dg00x->unit)->max_speed);
		if (err < 0)
			goto error;

		if (!amdtp_stream_wait_callback(&dg00x->tx_stream,
					      CALLBACK_TIMEOUT)) {
			err = -ETIMEDOUT;
			goto error;
		}
	}
end:
	return err;
error:
	finish_session(dg00x);

	amdtp_stream_stop(&dg00x->tx_stream);
	amdtp_stream_stop(&dg00x->rx_stream);
	release_resources(dg00x);

	return err;
}

void snd_dg00x_stream_stop_duplex(struct snd_dg00x *dg00x)
{
	if (dg00x->substreams_counter > 0)
		return;

	amdtp_stream_stop(&dg00x->tx_stream);
	amdtp_stream_stop(&dg00x->rx_stream);
	finish_session(dg00x);
	release_resources(dg00x);

	/*
	 * Just after finishing the session, the device may lost transmitting
	 * functionality for a short time.
	 */
	msleep(50);
}

void snd_dg00x_stream_update_duplex(struct snd_dg00x *dg00x)
{
	fw_iso_resources_update(&dg00x->tx_resources);
	fw_iso_resources_update(&dg00x->rx_resources);

	amdtp_stream_update(&dg00x->tx_stream);
	amdtp_stream_update(&dg00x->rx_stream);
}

void snd_dg00x_stream_lock_changed(struct snd_dg00x *dg00x)
{
	dg00x->dev_lock_changed = true;
	wake_up(&dg00x->hwdep_wait);
}

int snd_dg00x_stream_lock_try(struct snd_dg00x *dg00x)
{
	int err;

	spin_lock_irq(&dg00x->lock);

	/* user land lock this */
	if (dg00x->dev_lock_count < 0) {
		err = -EBUSY;
		goto end;
	}

	/* this is the first time */
	if (dg00x->dev_lock_count++ == 0)
		snd_dg00x_stream_lock_changed(dg00x);
	err = 0;
end:
	spin_unlock_irq(&dg00x->lock);
	return err;
}

void snd_dg00x_stream_lock_release(struct snd_dg00x *dg00x)
{
	spin_lock_irq(&dg00x->lock);

	if (WARN_ON(dg00x->dev_lock_count <= 0))
		goto end;
	if (--dg00x->dev_lock_count == 0)
		snd_dg00x_stream_lock_changed(dg00x);
end:
	spin_unlock_irq(&dg00x->lock);
}
Commit	Line	Data
3a2a1797 TS	1	/*
	2	* digi00x-stream.c - a part of driver for Digidesign Digi 002/003 family
	3	*
	4	* Copyright (c) 2014-2015 Takashi Sakamoto
	5	*
	6	* Licensed under the terms of the GNU General Public License, version 2.
	7	*/
	8
	9	#include "digi00x.h"
	10
	11	#define CALLBACK_TIMEOUT 500
	12
	13	const unsigned int snd_dg00x_stream_rates[SND_DG00X_RATE_COUNT] = {
	14	[SND_DG00X_RATE_44100] = 44100,
	15	[SND_DG00X_RATE_48000] = 48000,
	16	[SND_DG00X_RATE_88200] = 88200,
	17	[SND_DG00X_RATE_96000] = 96000,
	18	};
	19
	20	/* Multi Bit Linear Audio data channels for each sampling transfer frequency. */
	21	const unsigned int
	22	snd_dg00x_stream_pcm_channels[SND_DG00X_RATE_COUNT] = {
	23	/* Analog/ADAT/SPDIF */
	24	[SND_DG00X_RATE_44100] = (8 + 8 + 2),
	25	[SND_DG00X_RATE_48000] = (8 + 8 + 2),
	26	/* Analog/SPDIF */
	27	[SND_DG00X_RATE_88200] = (8 + 2),
	28	[SND_DG00X_RATE_96000] = (8 + 2),
	29	};
	30
	31	int snd_dg00x_stream_get_local_rate(struct snd_dg00x dg00x, unsigned int rate)
	32	{
	33	u32 data;
	34	__be32 reg;
	35	int err;
	36
	37	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
	38	DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
	39	&reg, sizeof(reg), 0);
	40	if (err < 0)
	41	return err;
	42
	43	data = be32_to_cpu(reg) & 0x0f;
	44	if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
	45	*rate = snd_dg00x_stream_rates[data];
	46	else
	47	err = -EIO;
	48
	49	return err;
	50	}
	51
	52	int snd_dg00x_stream_set_local_rate(struct snd_dg00x *dg00x, unsigned int rate)
	53	{
	54	__be32 reg;
	55	unsigned int i;
	56
	57	for (i = 0; i < ARRAY_SIZE(snd_dg00x_stream_rates); i++) {
	58	if (rate == snd_dg00x_stream_rates[i])
	59	break;
	60	}
	61	if (i == ARRAY_SIZE(snd_dg00x_stream_rates))
	62	return -EINVAL;
	63
	64	reg = cpu_to_be32(i);
65	return snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
66	DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
67	&reg, sizeof(reg), 0);
68	}
69
70	int snd_dg00x_stream_get_clock(struct snd_dg00x *dg00x,
71	enum snd_dg00x_clock *clock)
72	{
73	__be32 reg;
74	int err;
75
76	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
77	DG00X_ADDR_BASE + DG00X_OFFSET_CLOCK_SOURCE,
78	&reg, sizeof(reg), 0);
79	if (err < 0)
80	return err;
81
82	*clock = be32_to_cpu(reg) & 0x0f;
83	if (*clock >= SND_DG00X_CLOCK_COUNT)
84	err = -EIO;
85
86	return err;
87	}
88
89	int snd_dg00x_stream_check_external_clock(struct snd_dg00x dg00x, bool detect)
90	{
91	__be32 reg;
92	int err;
93
94	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
95	DG00X_ADDR_BASE + DG00X_OFFSET_DETECT_EXTERNAL,
96	&reg, sizeof(reg), 0);
97	if (err >= 0)
98	*detect = be32_to_cpu(reg) > 0;
99
100	return err;
101	}
102
103	int snd_dg00x_stream_get_external_rate(struct snd_dg00x *dg00x,
104	unsigned int *rate)
105	{
106	u32 data;
107	__be32 reg;
108	int err;
109
110	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
111	DG00X_ADDR_BASE + DG00X_OFFSET_EXTERNAL_RATE,
112	&reg, sizeof(reg), 0);
113	if (err < 0)
114	return err;
115
116	data = be32_to_cpu(reg) & 0x0f;
117	if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
118	*rate = snd_dg00x_stream_rates[data];
119	/* This means desync. */
120	else
121	err = -EBUSY;
122
123	return err;
124	}
125
126	static void finish_session(struct snd_dg00x *dg00x)
127	{
128	__be32 data = cpu_to_be32(0x00000003);
129
130	snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
131	DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_SET,
132	&data, sizeof(data), 0);
133	}
134
135	static int begin_session(struct snd_dg00x *dg00x)
136	{
137	__be32 data;
138	u32 curr;
139	int err;
140
141	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
142	DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_STATE,
143	&data, sizeof(data), 0);
144	if (err < 0)
145	goto error;
146	curr = be32_to_cpu(data);
147
148	if (curr == 0)
149	curr = 2;
150
151	curr--;
152	while (curr > 0) {
153	data = cpu_to_be32(curr);
154	err = snd_fw_transaction(dg00x->unit,
155	TCODE_WRITE_QUADLET_REQUEST,
156	DG00X_ADDR_BASE +
157	DG00X_OFFSET_STREAMING_SET,
158	&data, sizeof(data), 0);
159	if (err < 0)
160	goto error;
161
162	msleep(20);
163	curr--;
164	}
165
166	return 0;
167	error:
168	finish_session(dg00x);
169	return err;
170	}
171
172	static void release_resources(struct snd_dg00x *dg00x)
173	{
174	__be32 data = 0;
175
176	/* Unregister isochronous channels for both direction. */
177	snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
178	DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
179	&data, sizeof(data), 0);
180
181	/* Release isochronous resources. */
182	fw_iso_resources_free(&dg00x->tx_resources);
183	fw_iso_resources_free(&dg00x->rx_resources);
184	}
185
186	static int keep_resources(struct snd_dg00x *dg00x, unsigned int rate)
187	{
188	unsigned int i;
189	__be32 data;
190	int err;
191
192	/* Check sampling rate. */
193	for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
194	if (snd_dg00x_stream_rates[i] == rate)
195	break;
196	}
197	if (i == SND_DG00X_RATE_COUNT)
198	return -EINVAL;
199
200	/* Keep resources for out-stream. */
201	err = amdtp_dot_set_parameters(&dg00x->rx_stream, rate,
9dc5d31c	202	snd_dg00x_stream_pcm_channels[i]);
3a2a1797 TS	203	if (err < 0)
	204	return err;
	205	err = fw_iso_resources_allocate(&dg00x->rx_resources,
	206	amdtp_stream_get_max_payload(&dg00x->rx_stream),
	207	fw_parent_device(dg00x->unit)->max_speed);
	208	if (err < 0)
	209	return err;
	210
	211	/* Keep resources for in-stream. */
	212	err = amdtp_dot_set_parameters(&dg00x->tx_stream, rate,
9dc5d31c	213	snd_dg00x_stream_pcm_channels[i]);
3a2a1797 TS	214	if (err < 0)
	215	return err;
	216	err = fw_iso_resources_allocate(&dg00x->tx_resources,
	217	amdtp_stream_get_max_payload(&dg00x->tx_stream),
	218	fw_parent_device(dg00x->unit)->max_speed);
	219	if (err < 0)
	220	goto error;
	221
	222	/* Register isochronous channels for both direction. */
	223	data = cpu_to_be32((dg00x->tx_resources.channel << 16) \|
	224	dg00x->rx_resources.channel);
	225	err = snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
	226	DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
	227	&data, sizeof(data), 0);
	228	if (err < 0)
	229	goto error;
	230
	231	return 0;
	232	error:
	233	release_resources(dg00x);
	234	return err;
	235	}
	236
	237	int snd_dg00x_stream_init_duplex(struct snd_dg00x *dg00x)
	238	{
	239	int err;
	240
	241	/* For out-stream. */
	242	err = fw_iso_resources_init(&dg00x->rx_resources, dg00x->unit);
	243	if (err < 0)
	244	goto error;
	245	err = amdtp_dot_init(&dg00x->rx_stream, dg00x->unit, AMDTP_OUT_STREAM);
	246	if (err < 0)
	247	goto error;
	248
	249	/* For in-stream. */
	250	err = fw_iso_resources_init(&dg00x->tx_resources, dg00x->unit);
	251	if (err < 0)
	252	goto error;
	253	err = amdtp_dot_init(&dg00x->tx_stream, dg00x->unit, AMDTP_IN_STREAM);
	254	if (err < 0)
	255	goto error;
	256
	257	return 0;
	258	error:
	259	snd_dg00x_stream_destroy_duplex(dg00x);
	260	return err;
	261	}
	262
	263	/*
	264	* This function should be called before starting streams or after stopping
	265	* streams.
	266	*/
	267	void snd_dg00x_stream_destroy_duplex(struct snd_dg00x *dg00x)
	268	{
	269	amdtp_stream_destroy(&dg00x->rx_stream);
	270	fw_iso_resources_destroy(&dg00x->rx_resources);
	271
	272	amdtp_stream_destroy(&dg00x->tx_stream);
	273	fw_iso_resources_destroy(&dg00x->tx_resources);
	274	}
	275
	276	int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x, unsigned int rate)
	277	{
278	unsigned int curr_rate;
279	int err = 0;
280
281	if (dg00x->substreams_counter == 0)
282	goto end;
283
284	/* Check current sampling rate. */
285	err = snd_dg00x_stream_get_local_rate(dg00x, &curr_rate);
286	if (err < 0)
287	goto error;
9fbfd38b TS	288	if (rate == 0)
9fbfd38b TS	289	rate = curr_rate;
3a2a1797 TS	290	if (curr_rate != rate \|\|
	291	amdtp_streaming_error(&dg00x->tx_stream) \|\|
	292	amdtp_streaming_error(&dg00x->rx_stream)) {
	293	finish_session(dg00x);
	294
	295	amdtp_stream_stop(&dg00x->tx_stream);
	296	amdtp_stream_stop(&dg00x->rx_stream);
	297	release_resources(dg00x);
	298	}
	299
	300	/*
	301	* No packets are transmitted without receiving packets, reagardless of
	302	* which source of clock is used.
	303	*/
	304	if (!amdtp_stream_running(&dg00x->rx_stream)) {
	305	err = snd_dg00x_stream_set_local_rate(dg00x, rate);
	306	if (err < 0)
	307	goto error;
	308
	309	err = keep_resources(dg00x, rate);
	310	if (err < 0)
	311	goto error;
	312
	313	err = begin_session(dg00x);
	314	if (err < 0)
	315	goto error;
	316
	317	err = amdtp_stream_start(&dg00x->rx_stream,
	318	dg00x->rx_resources.channel,
	319	fw_parent_device(dg00x->unit)->max_speed);
	320	if (err < 0)
	321	goto error;
	322
	323	if (!amdtp_stream_wait_callback(&dg00x->rx_stream,
	324	CALLBACK_TIMEOUT)) {
	325	err = -ETIMEDOUT;
	326	goto error;
	327	}
	328	}
	329
	330	/*
	331	* The value of SYT field in transmitted packets is always 0x0000. Thus,
	332	* duplex streams with timestamp synchronization cannot be built.
	333	*/
	334	if (!amdtp_stream_running(&dg00x->tx_stream)) {
	335	err = amdtp_stream_start(&dg00x->tx_stream,
	336	dg00x->tx_resources.channel,
	337	fw_parent_device(dg00x->unit)->max_speed);
	338	if (err < 0)
	339	goto error;
	340
	341	if (!amdtp_stream_wait_callback(&dg00x->tx_stream,
	342	CALLBACK_TIMEOUT)) {
	343	err = -ETIMEDOUT;
	344	goto error;
	345	}
	346	}
	347	end:
	348	return err;
	349	error:
	350	finish_session(dg00x);
	351
	352	amdtp_stream_stop(&dg00x->tx_stream);
	353	amdtp_stream_stop(&dg00x->rx_stream);
354	release_resources(dg00x);
355
356	return err;
357	}
358
359	void snd_dg00x_stream_stop_duplex(struct snd_dg00x *dg00x)
360	{
361	if (dg00x->substreams_counter > 0)
362	return;
363
364	amdtp_stream_stop(&dg00x->tx_stream);
365	amdtp_stream_stop(&dg00x->rx_stream);
366	finish_session(dg00x);
367	release_resources(dg00x);
368
369	/*
370	* Just after finishing the session, the device may lost transmitting
371	* functionality for a short time.
372	*/
373	msleep(50);
374	}
375
376	void snd_dg00x_stream_update_duplex(struct snd_dg00x *dg00x)
377	{
378	fw_iso_resources_update(&dg00x->tx_resources);
379	fw_iso_resources_update(&dg00x->rx_resources);
380
381	amdtp_stream_update(&dg00x->tx_stream);
382	amdtp_stream_update(&dg00x->rx_stream);
383	}
660dd3d5 TS	384
	385	void snd_dg00x_stream_lock_changed(struct snd_dg00x *dg00x)
	386	{
	387	dg00x->dev_lock_changed = true;
	388	wake_up(&dg00x->hwdep_wait);
	389	}
	390
	391	int snd_dg00x_stream_lock_try(struct snd_dg00x *dg00x)
	392	{
	393	int err;
	394
	395	spin_lock_irq(&dg00x->lock);
	396
	397	/* user land lock this */
	398	if (dg00x->dev_lock_count < 0) {
	399	err = -EBUSY;
	400	goto end;
	401	}
	402
	403	/* this is the first time */
	404	if (dg00x->dev_lock_count++ == 0)
	405	snd_dg00x_stream_lock_changed(dg00x);
	406	err = 0;
	407	end:
	408	spin_unlock_irq(&dg00x->lock);
	409	return err;
	410	}
	411
	412	void snd_dg00x_stream_lock_release(struct snd_dg00x *dg00x)
	413	{
	414	spin_lock_irq(&dg00x->lock);
	415
	416	if (WARN_ON(dg00x->dev_lock_count <= 0))
	417	goto end;
	418	if (--dg00x->dev_lock_count == 0)
	419	snd_dg00x_stream_lock_changed(dg00x);
	420	end:
	421	spin_unlock_irq(&dg00x->lock);
	422	}