[mirror_ubuntu-zesty-kernel.git] / sound / firewire / tascam / tascam-stream.c

/*
 * tascam-stream.c - a part of driver for TASCAM FireWire series
 *
 * Copyright (c) 2015 Takashi Sakamoto
 *
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include <linux/delay.h>
#include "tascam.h"

#define CALLBACK_TIMEOUT 500

static int get_clock(struct snd_tscm *tscm, u32 *data)
{
	__be32 reg;
	int err;

	err = snd_fw_transaction(tscm->unit, TCODE_READ_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
				 &reg, sizeof(reg), 0);
	if (err >= 0)
		*data = be32_to_cpu(reg);

	return err;
}

static int set_clock(struct snd_tscm *tscm, unsigned int rate,
		     enum snd_tscm_clock clock)
{
	u32 data;
	__be32 reg;
	int err;

	err = get_clock(tscm, &data);
	if (err < 0)
		return err;
	data &= 0x0000ffff;

	if (rate > 0) {
		data &= 0x000000ff;
		/* Base rate. */
		if ((rate % 44100) == 0) {
			data |= 0x00000100;
			/* Multiplier. */
			if (rate / 44100 == 2)
				data |= 0x00008000;
		} else if ((rate % 48000) == 0) {
			data |= 0x00000200;
			/* Multiplier. */
			if (rate / 48000 == 2)
				data |= 0x00008000;
		} else {
			return -EAGAIN;
		}
	}

	if (clock != INT_MAX) {
		data &= 0x0000ff00;
		data |= clock + 1;
	}

	reg = cpu_to_be32(data);

	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	if (data & 0x00008000)
		reg = cpu_to_be32(0x0000001a);
	else
		reg = cpu_to_be32(0x0000000d);

	return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				  TSCM_ADDR_BASE + TSCM_OFFSET_MULTIPLEX_MODE,
				  &reg, sizeof(reg), 0);
}

int snd_tscm_stream_get_rate(struct snd_tscm *tscm, unsigned int *rate)
{
	u32 data = 0x0;
	unsigned int trials = 0;
	int err;

	while (data == 0x0 || trials++ < 5) {
		err = get_clock(tscm, &data);
		if (err < 0)
			return err;

		data = (data & 0xff000000) >> 24;
	}

	/* Check base rate. */
	if ((data & 0x0f) == 0x01)
		*rate = 44100;
	else if ((data & 0x0f) == 0x02)
		*rate = 48000;
	else
		return -EAGAIN;

	/* Check multiplier. */
	if ((data & 0xf0) == 0x80)
		*rate *= 2;
	else if ((data & 0xf0) != 0x00)
		return -EAGAIN;

	return err;
}

int snd_tscm_stream_get_clock(struct snd_tscm *tscm, enum snd_tscm_clock *clock)
{
	u32 data;
	int err;

	err = get_clock(tscm, &data);
	if (err < 0)
		return err;

	*clock = ((data & 0x00ff0000) >> 16) - 1;
	if (*clock < 0 || *clock > SND_TSCM_CLOCK_ADAT)
		return -EIO;

	return 0;
}

static int enable_data_channels(struct snd_tscm *tscm)
{
	__be32 reg;
	u32 data;
	unsigned int i;
	int err;

	data = 0;
	for (i = 0; i < tscm->spec->pcm_capture_analog_channels; ++i)
		data |= BIT(i);
	if (tscm->spec->has_adat)
		data |= 0x0000ff00;
	if (tscm->spec->has_spdif)
		data |= 0x00030000;

	reg = cpu_to_be32(data);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_TX_PCM_CHANNELS,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	data = 0;
	for (i = 0; i < tscm->spec->pcm_playback_analog_channels; ++i)
		data |= BIT(i);
	if (tscm->spec->has_adat)
		data |= 0x0000ff00;
	if (tscm->spec->has_spdif)
		data |= 0x00030000;

	reg = cpu_to_be32(data);
	return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				  TSCM_ADDR_BASE + TSCM_OFFSET_RX_PCM_CHANNELS,
				  &reg, sizeof(reg), 0);
}

static int set_stream_formats(struct snd_tscm *tscm, unsigned int rate)
{
	__be32 reg;
	int err;

	/* Set an option for unknown purpose. */
	reg = cpu_to_be32(0x00200000);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	err = enable_data_channels(tscm);
	if (err < 0)
		return err;

	return set_clock(tscm, rate, INT_MAX);
}

static void finish_session(struct snd_tscm *tscm)
{
	__be32 reg;

	reg = 0;
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
			   &reg, sizeof(reg), 0);

	reg = 0;
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
			   &reg, sizeof(reg), 0);

}

static int begin_session(struct snd_tscm *tscm)
{
	__be32 reg;
	int err;

	reg = cpu_to_be32(0x00000001);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	reg = cpu_to_be32(0x00000001);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	/* Set an option for unknown purpose. */
	reg = cpu_to_be32(0x00002000);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		return err;

	/* Start multiplexing PCM samples on packets. */
	reg = cpu_to_be32(0x00000001);
	return snd_fw_transaction(tscm->unit,
				  TCODE_WRITE_QUADLET_REQUEST,
				  TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_ON,
				  &reg, sizeof(reg), 0);
}

static void release_resources(struct snd_tscm *tscm)
{
	__be32 reg;

	/* Unregister channels. */
	reg = cpu_to_be32(0x00000000);
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
			   &reg, sizeof(reg), 0);
	reg = cpu_to_be32(0x00000000);
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
			   &reg, sizeof(reg), 0);
	reg = cpu_to_be32(0x00000000);
	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
			   TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
			   &reg, sizeof(reg), 0);

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

static int keep_resources(struct snd_tscm *tscm, unsigned int rate)
{
	__be32 reg;
	int err;

	/* Keep resources for in-stream. */
	err = amdtp_tscm_set_parameters(&tscm->tx_stream, rate);
	if (err < 0)
		return err;
	err = fw_iso_resources_allocate(&tscm->tx_resources,
			amdtp_stream_get_max_payload(&tscm->tx_stream),
			fw_parent_device(tscm->unit)->max_speed);
	if (err < 0)
		goto error;

	/* Keep resources for out-stream. */
	err = amdtp_tscm_set_parameters(&tscm->rx_stream, rate);
	if (err < 0)
		return err;
	err = fw_iso_resources_allocate(&tscm->rx_resources,
			amdtp_stream_get_max_payload(&tscm->rx_stream),
			fw_parent_device(tscm->unit)->max_speed);
	if (err < 0)
		return err;

	/* Register the isochronous channel for transmitting stream. */
	reg = cpu_to_be32(tscm->tx_resources.channel);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		goto error;

	/* Unknown */
	reg = cpu_to_be32(0x00000002);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		goto error;

	/* Register the isochronous channel for receiving stream. */
	reg = cpu_to_be32(tscm->rx_resources.channel);
	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
				 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
				 &reg, sizeof(reg), 0);
	if (err < 0)
		goto error;

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

int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
{
	unsigned int pcm_channels;
	int err;

	/* For out-stream. */
	err = fw_iso_resources_init(&tscm->rx_resources, tscm->unit);
	if (err < 0)
		return err;
	pcm_channels = tscm->spec->pcm_playback_analog_channels;
	if (tscm->spec->has_adat)
		pcm_channels += 8;
	if (tscm->spec->has_spdif)
		pcm_channels += 2;
	err = amdtp_tscm_init(&tscm->rx_stream, tscm->unit, AMDTP_OUT_STREAM,
			      pcm_channels);
	if (err < 0)
		return err;

	/* For in-stream. */
	err = fw_iso_resources_init(&tscm->tx_resources, tscm->unit);
	if (err < 0)
		return err;
	pcm_channels = tscm->spec->pcm_capture_analog_channels;
	if (tscm->spec->has_adat)
		pcm_channels += 8;
	if (tscm->spec->has_spdif)
		pcm_channels += 2;
	err = amdtp_tscm_init(&tscm->tx_stream, tscm->unit, AMDTP_IN_STREAM,
			      pcm_channels);
	if (err < 0)
		amdtp_stream_destroy(&tscm->rx_stream);

	return 0;
}

/* At bus reset, streaming is stopped and some registers are clear. */
void snd_tscm_stream_update_duplex(struct snd_tscm *tscm)
{
	amdtp_stream_pcm_abort(&tscm->tx_stream);
	amdtp_stream_stop(&tscm->tx_stream);

	amdtp_stream_pcm_abort(&tscm->rx_stream);
	amdtp_stream_stop(&tscm->rx_stream);
}

/*
 * This function should be called before starting streams or after stopping
 * streams.
 */
void snd_tscm_stream_destroy_duplex(struct snd_tscm *tscm)
{
	amdtp_stream_destroy(&tscm->rx_stream);
	amdtp_stream_destroy(&tscm->tx_stream);

	fw_iso_resources_destroy(&tscm->rx_resources);
	fw_iso_resources_destroy(&tscm->tx_resources);
}

int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
{
	unsigned int curr_rate;
	int err;

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

	err = snd_tscm_stream_get_rate(tscm, &curr_rate);
	if (err < 0)
		return err;
	if (curr_rate != rate ||
	    amdtp_streaming_error(&tscm->rx_stream) ||
	    amdtp_streaming_error(&tscm->tx_stream)) {
		finish_session(tscm);

		amdtp_stream_stop(&tscm->rx_stream);
		amdtp_stream_stop(&tscm->tx_stream);

		release_resources(tscm);
	}

	if (!amdtp_stream_running(&tscm->rx_stream)) {
		err = keep_resources(tscm, rate);
		if (err < 0)
			goto error;

		err = set_stream_formats(tscm, rate);
		if (err < 0)
			goto error;

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

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

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

	if (!amdtp_stream_running(&tscm->tx_stream)) {
		err = amdtp_stream_start(&tscm->tx_stream,
				tscm->tx_resources.channel,
				fw_parent_device(tscm->unit)->max_speed);
		if (err < 0)
			goto error;

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

	return 0;
error:
	amdtp_stream_stop(&tscm->rx_stream);
	amdtp_stream_stop(&tscm->tx_stream);

	finish_session(tscm);
	release_resources(tscm);

	return err;
}

void snd_tscm_stream_stop_duplex(struct snd_tscm *tscm)
{
	if (tscm->substreams_counter > 0)
		return;

	amdtp_stream_stop(&tscm->tx_stream);
	amdtp_stream_stop(&tscm->rx_stream);

	finish_session(tscm);
	release_resources(tscm);
}

void snd_tscm_stream_lock_changed(struct snd_tscm *tscm)
{
	tscm->dev_lock_changed = true;
	wake_up(&tscm->hwdep_wait);
}

int snd_tscm_stream_lock_try(struct snd_tscm *tscm)
{
	int err;

	spin_lock_irq(&tscm->lock);

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

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

void snd_tscm_stream_lock_release(struct snd_tscm *tscm)
{
	spin_lock_irq(&tscm->lock);

	if (WARN_ON(tscm->dev_lock_count <= 0))
		goto end;
	if (--tscm->dev_lock_count == 0)
		snd_tscm_stream_lock_changed(tscm);
end:
	spin_unlock_irq(&tscm->lock);
}
Commit	Line	Data
35efa5c4 TS	1	/*
	2	* tascam-stream.c - a part of driver for TASCAM FireWire series
	3	*
	4	* Copyright (c) 2015 Takashi Sakamoto
	5	*
	6	* Licensed under the terms of the GNU General Public License, version 2.
	7	*/
	8
	9	#include <linux/delay.h>
	10	#include "tascam.h"
	11
	12	#define CALLBACK_TIMEOUT 500
	13
	14	static int get_clock(struct snd_tscm tscm, u32 data)
	15	{
	16	__be32 reg;
	17	int err;
	18
	19	err = snd_fw_transaction(tscm->unit, TCODE_READ_QUADLET_REQUEST,
	20	TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
	21	&reg, sizeof(reg), 0);
	22	if (err >= 0)
	23	*data = be32_to_cpu(reg);
	24
	25	return err;
	26	}
	27
	28	static int set_clock(struct snd_tscm *tscm, unsigned int rate,
	29	enum snd_tscm_clock clock)
	30	{
	31	u32 data;
	32	__be32 reg;
	33	int err;
	34
	35	err = get_clock(tscm, &data);
	36	if (err < 0)
	37	return err;
	38	data &= 0x0000ffff;
	39
	40	if (rate > 0) {
	41	data &= 0x000000ff;
	42	/* Base rate. */
	43	if ((rate % 44100) == 0) {
	44	data \|= 0x00000100;
	45	/* Multiplier. */
	46	if (rate / 44100 == 2)
	47	data \|= 0x00008000;
	48	} else if ((rate % 48000) == 0) {
	49	data \|= 0x00000200;
	50	/* Multiplier. */
	51	if (rate / 48000 == 2)
	52	data \|= 0x00008000;
	53	} else {
	54	return -EAGAIN;
	55	}
	56	}
	57
	58	if (clock != INT_MAX) {
	59	data &= 0x0000ff00;
	60	data \|= clock + 1;
	61	}
	62
	63	reg = cpu_to_be32(data);
	64
65	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
66	TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
67	&reg, sizeof(reg), 0);
68	if (err < 0)
69	return err;
70
71	if (data & 0x00008000)
72	reg = cpu_to_be32(0x0000001a);
73	else
74	reg = cpu_to_be32(0x0000000d);
75
76	return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
77	TSCM_ADDR_BASE + TSCM_OFFSET_MULTIPLEX_MODE,
78	&reg, sizeof(reg), 0);
79	}
80
81	int snd_tscm_stream_get_rate(struct snd_tscm tscm, unsigned int rate)
82	{
83	u32 data = 0x0;
84	unsigned int trials = 0;
85	int err;
86
87	while (data == 0x0 \|\| trials++ < 5) {
88	err = get_clock(tscm, &data);
89	if (err < 0)
90	return err;
91
92	data = (data & 0xff000000) >> 24;
93	}
94
95	/* Check base rate. */
96	if ((data & 0x0f) == 0x01)
97	*rate = 44100;
98	else if ((data & 0x0f) == 0x02)
99	*rate = 48000;
100	else
101	return -EAGAIN;
102
103	/* Check multiplier. */
104	if ((data & 0xf0) == 0x80)
105	rate = 2;
106	else if ((data & 0xf0) != 0x00)
107	return -EAGAIN;
108
109	return err;
110	}
111
112	int snd_tscm_stream_get_clock(struct snd_tscm tscm, enum snd_tscm_clock clock)
113	{
114	u32 data;
115	int err;
116
117	err = get_clock(tscm, &data);
118	if (err < 0)
119	return err;
120
121	*clock = ((data & 0x00ff0000) >> 16) - 1;
122	if (clock < 0 \|\| clock > SND_TSCM_CLOCK_ADAT)
123	return -EIO;
124
125	return 0;
126	}
127
128	static int enable_data_channels(struct snd_tscm *tscm)
129	{
130	__be32 reg;
131	u32 data;
132	unsigned int i;
133	int err;
134
135	data = 0;
136	for (i = 0; i < tscm->spec->pcm_capture_analog_channels; ++i)
137	data \|= BIT(i);
138	if (tscm->spec->has_adat)
139	data \|= 0x0000ff00;
140	if (tscm->spec->has_spdif)
141	data \|= 0x00030000;
142
143	reg = cpu_to_be32(data);
144	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
145	TSCM_ADDR_BASE + TSCM_OFFSET_TX_PCM_CHANNELS,
146	&reg, sizeof(reg), 0);
147	if (err < 0)
148	return err;
149
150	data = 0;
151	for (i = 0; i < tscm->spec->pcm_playback_analog_channels; ++i)
152	data \|= BIT(i);
153	if (tscm->spec->has_adat)
154	data \|= 0x0000ff00;
155	if (tscm->spec->has_spdif)
156	data \|= 0x00030000;
157
158	reg = cpu_to_be32(data);
159	return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
160	TSCM_ADDR_BASE + TSCM_OFFSET_RX_PCM_CHANNELS,
161	&reg, sizeof(reg), 0);
162	}
163
164	static int set_stream_formats(struct snd_tscm *tscm, unsigned int rate)
165	{
166	__be32 reg;
167	int err;
168
169	/* Set an option for unknown purpose. */
170	reg = cpu_to_be32(0x00200000);
171	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
172	TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
173	&reg, sizeof(reg), 0);
174	if (err < 0)
175	return err;
176
177	err = enable_data_channels(tscm);
178	if (err < 0)
179	return err;
180
181	return set_clock(tscm, rate, INT_MAX);
182	}
183
184	static void finish_session(struct snd_tscm *tscm)
185	{
186	__be32 reg;
187
188	reg = 0;
189	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
190	TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
191	&reg, sizeof(reg), 0);
192
193	reg = 0;
194	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
195	TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
196	&reg, sizeof(reg), 0);
197
198	}
199
200	static int begin_session(struct snd_tscm *tscm)
201	{
202	__be32 reg;
203	int err;
204
205	reg = cpu_to_be32(0x00000001);
206	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
207	TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
208	&reg, sizeof(reg), 0);
209	if (err < 0)
210	return err;
211
212	reg = cpu_to_be32(0x00000001);
213	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
214	TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
215	&reg, sizeof(reg), 0);
216	if (err < 0)
217	return err;
218
219	/* Set an option for unknown purpose. */
220	reg = cpu_to_be32(0x00002000);
221	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
222	TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
223	&reg, sizeof(reg), 0);
224	if (err < 0)
225	return err;
226
227	/* Start multiplexing PCM samples on packets. */
228	reg = cpu_to_be32(0x00000001);
229	return snd_fw_transaction(tscm->unit,
230	TCODE_WRITE_QUADLET_REQUEST,
231	TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_ON,
232	&reg, sizeof(reg), 0);
233	}
234
235	static void release_resources(struct snd_tscm *tscm)
236	{
237	__be32 reg;
238
239	/* Unregister channels. */
240	reg = cpu_to_be32(0x00000000);
241	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
242	TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
243	&reg, sizeof(reg), 0);
244	reg = cpu_to_be32(0x00000000);
245	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
246	TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
247	&reg, sizeof(reg), 0);
248	reg = cpu_to_be32(0x00000000);
249	snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
250	TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
251	&reg, sizeof(reg), 0);
252
253	/* Release isochronous resources. */
254	fw_iso_resources_free(&tscm->tx_resources);
255	fw_iso_resources_free(&tscm->rx_resources);
256	}
257
258	static int keep_resources(struct snd_tscm *tscm, unsigned int rate)
259	{
260	__be32 reg;
261	int err;
262
263	/* Keep resources for in-stream. */
264	err = amdtp_tscm_set_parameters(&tscm->tx_stream, rate);
265	if (err < 0)
266	return err;
267	err = fw_iso_resources_allocate(&tscm->tx_resources,
268	amdtp_stream_get_max_payload(&tscm->tx_stream),
269	fw_parent_device(tscm->unit)->max_speed);
270	if (err < 0)
271	goto error;
272
273	/* Keep resources for out-stream. */
274	err = amdtp_tscm_set_parameters(&tscm->rx_stream, rate);
275	if (err < 0)
276	return err;
277	err = fw_iso_resources_allocate(&tscm->rx_resources,
278	amdtp_stream_get_max_payload(&tscm->rx_stream),
279	fw_parent_device(tscm->unit)->max_speed);
280	if (err < 0)
281	return err;
282
283	/* Register the isochronous channel for transmitting stream. */
284	reg = cpu_to_be32(tscm->tx_resources.channel);
285	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
286	TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
287	&reg, sizeof(reg), 0);
288	if (err < 0)
289	goto error;
290
291	/* Unknown */
292	reg = cpu_to_be32(0x00000002);
293	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
294	TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
295	&reg, sizeof(reg), 0);
296	if (err < 0)
297	goto error;
298
299	/* Register the isochronous channel for receiving stream. */
300	reg = cpu_to_be32(tscm->rx_resources.channel);
301	err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
302	TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
303	&reg, sizeof(reg), 0);
304	if (err < 0)
305	goto error;
306
307	return 0;
308	error:
309	release_resources(tscm);
310	return err;
311	}
312
313	int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
314	{
315	unsigned int pcm_channels;
316	int err;
317
318	/* For out-stream. */
319	err = fw_iso_resources_init(&tscm->rx_resources, tscm->unit);
320	if (err < 0)
321	return err;
322	pcm_channels = tscm->spec->pcm_playback_analog_channels;
323	if (tscm->spec->has_adat)
324	pcm_channels += 8;
325	if (tscm->spec->has_spdif)
326	pcm_channels += 2;
327	err = amdtp_tscm_init(&tscm->rx_stream, tscm->unit, AMDTP_OUT_STREAM,
328	pcm_channels);
329	if (err < 0)
330	return err;
331
332	/* For in-stream. */
333	err = fw_iso_resources_init(&tscm->tx_resources, tscm->unit);
334	if (err < 0)
335	return err;
336	pcm_channels = tscm->spec->pcm_capture_analog_channels;
337	if (tscm->spec->has_adat)
338	pcm_channels += 8;
339	if (tscm->spec->has_spdif)
340	pcm_channels += 2;
341	err = amdtp_tscm_init(&tscm->tx_stream, tscm->unit, AMDTP_IN_STREAM,
342	pcm_channels);
343	if (err < 0)
344	amdtp_stream_destroy(&tscm->rx_stream);
345
346	return 0;
347	}
348
349	/* At bus reset, streaming is stopped and some registers are clear. */
350	void snd_tscm_stream_update_duplex(struct snd_tscm *tscm)
351	{
352	amdtp_stream_pcm_abort(&tscm->tx_stream);
353	amdtp_stream_stop(&tscm->tx_stream);
354
355	amdtp_stream_pcm_abort(&tscm->rx_stream);
356	amdtp_stream_stop(&tscm->rx_stream);
357	}
358
359	/*
360	* This function should be called before starting streams or after stopping
361	* streams.
362	*/
363	void snd_tscm_stream_destroy_duplex(struct snd_tscm *tscm)
364	{
365	amdtp_stream_destroy(&tscm->rx_stream);
366	amdtp_stream_destroy(&tscm->tx_stream);
367
368	fw_iso_resources_destroy(&tscm->rx_resources);
369	fw_iso_resources_destroy(&tscm->tx_resources);
370	}
371
372	int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
373	{
374	unsigned int curr_rate;
375	int err;
376
377	if (tscm->substreams_counter == 0)
378	return 0;
379
380	err = snd_tscm_stream_get_rate(tscm, &curr_rate);
381	if (err < 0)
382	return err;
383	if (curr_rate != rate \|\|
28e64f51 TS	384	amdtp_streaming_error(&tscm->rx_stream) \|\|
28e64f51 TS	385	amdtp_streaming_error(&tscm->tx_stream)) {
35efa5c4 TS	386	finish_session(tscm);
35efa5c4 TS	387
35efa5c4	388	amdtp_stream_stop(&tscm->rx_stream);
28e64f51	389	amdtp_stream_stop(&tscm->tx_stream);
35efa5c4 TS	390
	391	release_resources(tscm);
	392	}
	393
28e64f51	394	if (!amdtp_stream_running(&tscm->rx_stream)) {
35efa5c4 TS	395	err = keep_resources(tscm, rate);
	396	if (err < 0)
	397	goto error;
	398
	399	err = set_stream_formats(tscm, rate);
	400	if (err < 0)
	401	goto error;
	402
	403	err = begin_session(tscm);
	404	if (err < 0)
	405	goto error;
	406
28e64f51 TS	407	err = amdtp_stream_start(&tscm->rx_stream,
28e64f51 TS	408	tscm->rx_resources.channel,
35efa5c4 TS	409	fw_parent_device(tscm->unit)->max_speed);
	410	if (err < 0)
	411	goto error;
	412
28e64f51	413	if (!amdtp_stream_wait_callback(&tscm->rx_stream,
35efa5c4 TS	414	CALLBACK_TIMEOUT)) {
	415	err = -ETIMEDOUT;
	416	goto error;
	417	}
	418	}
	419
28e64f51 TS	420	if (!amdtp_stream_running(&tscm->tx_stream)) {
	421	err = amdtp_stream_start(&tscm->tx_stream,
	422	tscm->tx_resources.channel,
35efa5c4 TS	423	fw_parent_device(tscm->unit)->max_speed);
	424	if (err < 0)
	425	goto error;
	426
28e64f51	427	if (!amdtp_stream_wait_callback(&tscm->tx_stream,
35efa5c4 TS	428	CALLBACK_TIMEOUT)) {
	429	err = -ETIMEDOUT;
	430	goto error;
	431	}
	432	}
	433
	434	return 0;
	435	error:
35efa5c4	436	amdtp_stream_stop(&tscm->rx_stream);
28e64f51	437	amdtp_stream_stop(&tscm->tx_stream);
35efa5c4 TS	438
	439	finish_session(tscm);
	440	release_resources(tscm);
	441
	442	return err;
	443	}
	444
	445	void snd_tscm_stream_stop_duplex(struct snd_tscm *tscm)
	446	{
	447	if (tscm->substreams_counter > 0)
	448	return;
	449
	450	amdtp_stream_stop(&tscm->tx_stream);
	451	amdtp_stream_stop(&tscm->rx_stream);
	452
	453	finish_session(tscm);
	454	release_resources(tscm);
	455	}
e5e0c3dd TS	456
	457	void snd_tscm_stream_lock_changed(struct snd_tscm *tscm)
	458	{
	459	tscm->dev_lock_changed = true;
	460	wake_up(&tscm->hwdep_wait);
	461	}
	462
	463	int snd_tscm_stream_lock_try(struct snd_tscm *tscm)
	464	{
	465	int err;
	466
	467	spin_lock_irq(&tscm->lock);
	468
	469	/* user land lock this */
	470	if (tscm->dev_lock_count < 0) {
	471	err = -EBUSY;
	472	goto end;
	473	}
	474
	475	/* this is the first time */
	476	if (tscm->dev_lock_count++ == 0)
	477	snd_tscm_stream_lock_changed(tscm);
	478	err = 0;
	479	end:
	480	spin_unlock_irq(&tscm->lock);
	481	return err;
	482	}
	483
	484	void snd_tscm_stream_lock_release(struct snd_tscm *tscm)
	485	{
	486	spin_lock_irq(&tscm->lock);
	487
	488	if (WARN_ON(tscm->dev_lock_count <= 0))
	489	goto end;
	490	if (--tscm->dev_lock_count == 0)
	491	snd_tscm_stream_lock_changed(tscm);
	492	end:
	493	spin_unlock_irq(&tscm->lock);
	494	}