[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 (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;
288	if (curr_rate != rate \|\|
289	amdtp_streaming_error(&dg00x->tx_stream) \|\|
290	amdtp_streaming_error(&dg00x->rx_stream)) {
291	finish_session(dg00x);
292
293	amdtp_stream_stop(&dg00x->tx_stream);
294	amdtp_stream_stop(&dg00x->rx_stream);
295	release_resources(dg00x);
296	}
297
298	/*
299	* No packets are transmitted without receiving packets, reagardless of
300	* which source of clock is used.
301	*/
302	if (!amdtp_stream_running(&dg00x->rx_stream)) {
303	err = snd_dg00x_stream_set_local_rate(dg00x, rate);
304	if (err < 0)
305	goto error;
306
307	err = keep_resources(dg00x, rate);
308	if (err < 0)
309	goto error;
310
311	err = begin_session(dg00x);
312	if (err < 0)
313	goto error;
314
315	err = amdtp_stream_start(&dg00x->rx_stream,
316	dg00x->rx_resources.channel,
317	fw_parent_device(dg00x->unit)->max_speed);
318	if (err < 0)
319	goto error;
320
321	if (!amdtp_stream_wait_callback(&dg00x->rx_stream,
322	CALLBACK_TIMEOUT)) {
323	err = -ETIMEDOUT;
324	goto error;
325	}
326	}
327
328	/*
329	* The value of SYT field in transmitted packets is always 0x0000. Thus,
330	* duplex streams with timestamp synchronization cannot be built.
331	*/
332	if (!amdtp_stream_running(&dg00x->tx_stream)) {
333	err = amdtp_stream_start(&dg00x->tx_stream,
334	dg00x->tx_resources.channel,
335	fw_parent_device(dg00x->unit)->max_speed);
336	if (err < 0)
337	goto error;
338
339	if (!amdtp_stream_wait_callback(&dg00x->tx_stream,
340	CALLBACK_TIMEOUT)) {
341	err = -ETIMEDOUT;
342	goto error;
343	}
344	}
345	end:
346	return err;
347	error:
348	finish_session(dg00x);
349
350	amdtp_stream_stop(&dg00x->tx_stream);
351	amdtp_stream_stop(&dg00x->rx_stream);
352	release_resources(dg00x);
353
354	return err;
355	}
356
357	void snd_dg00x_stream_stop_duplex(struct snd_dg00x *dg00x)
358	{
359	if (dg00x->substreams_counter > 0)
360	return;
361
362	amdtp_stream_stop(&dg00x->tx_stream);
363	amdtp_stream_stop(&dg00x->rx_stream);
364	finish_session(dg00x);
365	release_resources(dg00x);
366
367	/*
368	* Just after finishing the session, the device may lost transmitting
369	* functionality for a short time.
370	*/
371	msleep(50);
372	}
373
374	void snd_dg00x_stream_update_duplex(struct snd_dg00x *dg00x)
375	{
376	fw_iso_resources_update(&dg00x->tx_resources);
377	fw_iso_resources_update(&dg00x->rx_resources);
378
379	amdtp_stream_update(&dg00x->tx_stream);
380	amdtp_stream_update(&dg00x->rx_stream);
381	}
660dd3d5 TS	382
	383	void snd_dg00x_stream_lock_changed(struct snd_dg00x *dg00x)
	384	{
	385	dg00x->dev_lock_changed = true;
	386	wake_up(&dg00x->hwdep_wait);
	387	}
	388
	389	int snd_dg00x_stream_lock_try(struct snd_dg00x *dg00x)
	390	{
	391	int err;
	392
	393	spin_lock_irq(&dg00x->lock);
	394
	395	/* user land lock this */
	396	if (dg00x->dev_lock_count < 0) {
	397	err = -EBUSY;
	398	goto end;
	399	}
	400
	401	/* this is the first time */
	402	if (dg00x->dev_lock_count++ == 0)
	403	snd_dg00x_stream_lock_changed(dg00x);
	404	err = 0;
	405	end:
	406	spin_unlock_irq(&dg00x->lock);
	407	return err;
	408	}
	409
	410	void snd_dg00x_stream_lock_release(struct snd_dg00x *dg00x)
	411	{
	412	spin_lock_irq(&dg00x->lock);
	413
	414	if (WARN_ON(dg00x->dev_lock_count <= 0))
	415	goto end;
	416	if (--dg00x->dev_lock_count == 0)
	417	snd_dg00x_stream_lock_changed(dg00x);
	418	end:
	419	spin_unlock_irq(&dg00x->lock);
	420	}