1// SPDX-License-Identifier: GPL-2.0-only
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>
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
28static int keep_resources(struct snd_motu *motu, unsigned int rate,
29			  struct amdtp_stream *stream)
30{
31	struct fw_iso_resources *resources;
32	struct snd_motu_packet_format *packet_format;
33	unsigned int midi_ports = 0;
34	int err;
35
36	if (stream == &motu->rx_stream) {
37		resources = &motu->rx_resources;
38		packet_format = &motu->rx_packet_formats;
39
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;
46
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	}
51
52	err = amdtp_motu_set_parameters(stream, rate, midi_ports,
53					packet_format);
54	if (err < 0)
55		return err;
56
57	return fw_iso_resources_allocate(resources,
58				amdtp_stream_get_max_payload(stream),
59				fw_parent_device(motu->unit)->max_speed);
60}
61
62static int begin_session(struct snd_motu *motu)
63{
64	__be32 reg;
65	u32 data;
66	int err;
67
68	// Configure the unit to start isochronous communication.
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
85static void finish_session(struct snd_motu *motu)
86{
87	__be32 reg;
88	u32 data;
89	int err;
90
91	err = snd_motu_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));
107}
108
109int snd_motu_stream_cache_packet_formats(struct snd_motu *motu)
110{
111	int err;
112
113	err = snd_motu_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
136int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate,
137				   unsigned int frames_per_period,
138				   unsigned int frames_per_buffer)
139{
140	unsigned int curr_rate;
141	int err;
142
143	err = snd_motu_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) {
150		amdtp_domain_stop(&motu->domain);
151		finish_session(motu);
152
153		fw_iso_resources_free(&motu->tx_resources);
154		fw_iso_resources_free(&motu->rx_resources);
155
156		err = snd_motu_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		}
176
177		err = amdtp_domain_set_events_per_period(&motu->domain,
178					frames_per_period, frames_per_buffer);
179		if (err < 0) {
180			fw_iso_resources_free(&motu->tx_resources);
181			fw_iso_resources_free(&motu->rx_resources);
182			return err;
183		}
184	}
185
186	return 0;
187}
188
189static 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->spec->tx_fixed_pcm_chunks[0] == motu->tx_packet_formats.pcm_chunks[0])
205		data |= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
206	if (motu->spec->rx_fixed_pcm_chunks[0] == motu->rx_packet_formats.pcm_chunks[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
215int snd_motu_stream_start_duplex(struct snd_motu *motu)
216{
217	unsigned int generation = motu->rx_resources.generation;
218	int err = 0;
219
220	if (motu->substreams_counter == 0)
221		return 0;
222
223	if (amdtp_streaming_error(&motu->rx_stream) ||
224	    amdtp_streaming_error(&motu->tx_stream)) {
225		amdtp_domain_stop(&motu->domain);
226		finish_session(motu);
227	}
228
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
239	if (!amdtp_stream_running(&motu->rx_stream)) {
240		int spd = fw_parent_device(motu->unit)->max_speed;
241
242		err = ensure_packet_formats(motu);
243		if (err < 0)
244			return err;
245
246		err = begin_session(motu);
247		if (err < 0) {
248			dev_err(&motu->unit->device,
249				"fail to start isochronous comm: %d\n", err);
250			goto stop_streams;
251		}
252
253		err = amdtp_domain_add_stream(&motu->domain, &motu->tx_stream,
254					      motu->tx_resources.channel, spd);
255		if (err < 0)
256			goto stop_streams;
257
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
263		err = amdtp_domain_start(&motu->domain, 0);
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;
272			goto stop_streams;
273		}
274
275		err = snd_motu_protocol_switch_fetching_mode(motu, true);
276		if (err < 0) {
277			dev_err(&motu->unit->device,
278				"fail to enable frame fetching: %d\n", err);
279			goto stop_streams;
280		}
281	}
282
283	return 0;
284
285stop_streams:
286	amdtp_domain_stop(&motu->domain);
287	finish_session(motu);
288	return err;
289}
290
291void snd_motu_stream_stop_duplex(struct snd_motu *motu)
292{
293	if (motu->substreams_counter == 0) {
294		amdtp_domain_stop(&motu->domain);
295		finish_session(motu);
296
297		fw_iso_resources_free(&motu->tx_resources);
298		fw_iso_resources_free(&motu->rx_resources);
299	}
300}
301
302static int init_stream(struct snd_motu *motu, struct amdtp_stream *s)
303{
304	struct fw_iso_resources *resources;
305	enum amdtp_stream_direction dir;
306	int err;
307
308	if (s == &motu->tx_stream) {
309		resources = &motu->tx_resources;
310		dir = AMDTP_IN_STREAM;
311	} else {
312		resources = &motu->rx_resources;
313		dir = AMDTP_OUT_STREAM;
314	}
315
316	err = fw_iso_resources_init(resources, motu->unit);
317	if (err < 0)
318		return err;
319
320	err = amdtp_motu_init(s, motu->unit, dir, motu->spec);
321	if (err < 0)
322		fw_iso_resources_destroy(resources);
323
324	return err;
325}
326
327static void destroy_stream(struct snd_motu *motu, struct amdtp_stream *s)
328{
329	amdtp_stream_destroy(s);
330
331	if (s == &motu->tx_stream)
332		fw_iso_resources_destroy(&motu->tx_resources);
333	else
334		fw_iso_resources_destroy(&motu->rx_resources);
335}
336
337int snd_motu_stream_init_duplex(struct snd_motu *motu)
338{
339	int err;
340
341	err = init_stream(motu, &motu->tx_stream);
342	if (err < 0)
343		return err;
344
345	err = init_stream(motu, &motu->rx_stream);
346	if (err < 0) {
347		destroy_stream(motu, &motu->tx_stream);
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	}
356
357	return err;
358}
359
360// This function should be called before starting streams or after stopping
361// streams.
362void snd_motu_stream_destroy_duplex(struct snd_motu *motu)
363{
364	amdtp_domain_destroy(&motu->domain);
365
366	destroy_stream(motu, &motu->rx_stream);
367	destroy_stream(motu, &motu->tx_stream);
368
369	motu->substreams_counter = 0;
370}
371
372static void motu_lock_changed(struct snd_motu *motu)
373{
374	motu->dev_lock_changed = true;
375	wake_up(&motu->hwdep_wait);
376}
377
378int 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;
392out:
393	spin_unlock_irq(&motu->lock);
394	return err;
395}
396
397void 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);
406out:
407	spin_unlock_irq(&motu->lock);
408}
409