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 
28 static 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 
62 static 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 
85 static void finish_session(struct snd_motu *motu)
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));
107 }
108 
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 
136 int snd_motu_stream_reserve_duplex(struct snd_motu *motu, unsigned int rate)
137 {
138 	unsigned int curr_rate;
139 	int err;
140 
141 	err = motu->spec->protocol->get_clock_rate(motu, &curr_rate);
142 	if (err < 0)
143 		return err;
144 	if (rate == 0)
145 		rate = curr_rate;
146 
147 	if (motu->substreams_counter == 0 || curr_rate != rate) {
148 		amdtp_domain_stop(&motu->domain);
149 		finish_session(motu);
150 
151 		fw_iso_resources_free(&motu->tx_resources);
152 		fw_iso_resources_free(&motu->rx_resources);
153 
154 		err = motu->spec->protocol->set_clock_rate(motu, rate);
155 		if (err < 0) {
156 			dev_err(&motu->unit->device,
157 				"fail to set sampling rate: %d\n", err);
158 			return err;
159 		}
160 
161 		err = snd_motu_stream_cache_packet_formats(motu);
162 		if (err < 0)
163 			return err;
164 
165 		err = keep_resources(motu, rate, &motu->tx_stream);
166 		if (err < 0)
167 			return err;
168 
169 		err = keep_resources(motu, rate, &motu->rx_stream);
170 		if (err < 0) {
171 			fw_iso_resources_free(&motu->tx_resources);
172 			return err;
173 		}
174 	}
175 
176 	return 0;
177 }
178 
179 static int ensure_packet_formats(struct snd_motu *motu)
180 {
181 	__be32 reg;
182 	u32 data;
183 	int err;
184 
185 	err = snd_motu_transaction_read(motu, PACKET_FORMAT_OFFSET, &reg,
186 					sizeof(reg));
187 	if (err < 0)
188 		return err;
189 	data = be32_to_cpu(reg);
190 
191 	data &= ~(TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS |
192 		  RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS|
193 		  TX_PACKET_TRANSMISSION_SPEED_MASK);
194 	if (motu->tx_packet_formats.differed_part_pcm_chunks[0] == 0)
195 		data |= TX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
196 	if (motu->rx_packet_formats.differed_part_pcm_chunks[0] == 0)
197 		data |= RX_PACKET_EXCLUDE_DIFFERED_DATA_CHUNKS;
198 	data |= fw_parent_device(motu->unit)->max_speed;
199 
200 	reg = cpu_to_be32(data);
201 	return snd_motu_transaction_write(motu, PACKET_FORMAT_OFFSET, &reg,
202 					  sizeof(reg));
203 }
204 
205 int snd_motu_stream_start_duplex(struct snd_motu *motu)
206 {
207 	unsigned int generation = motu->rx_resources.generation;
208 	int err = 0;
209 
210 	if (motu->substreams_counter == 0)
211 		return 0;
212 
213 	if (amdtp_streaming_error(&motu->rx_stream) ||
214 	    amdtp_streaming_error(&motu->tx_stream)) {
215 		amdtp_domain_stop(&motu->domain);
216 		finish_session(motu);
217 	}
218 
219 	if (generation != fw_parent_device(motu->unit)->card->generation) {
220 		err = fw_iso_resources_update(&motu->rx_resources);
221 		if (err < 0)
222 			return err;
223 
224 		err = fw_iso_resources_update(&motu->tx_resources);
225 		if (err < 0)
226 			return err;
227 	}
228 
229 	if (!amdtp_stream_running(&motu->rx_stream)) {
230 		int spd = fw_parent_device(motu->unit)->max_speed;
231 
232 		err = ensure_packet_formats(motu);
233 		if (err < 0)
234 			return err;
235 
236 		err = begin_session(motu);
237 		if (err < 0) {
238 			dev_err(&motu->unit->device,
239 				"fail to start isochronous comm: %d\n", err);
240 			goto stop_streams;
241 		}
242 
243 		err = amdtp_domain_add_stream(&motu->domain, &motu->tx_stream,
244 					      motu->tx_resources.channel, spd);
245 		if (err < 0)
246 			goto stop_streams;
247 
248 		err = amdtp_domain_add_stream(&motu->domain, &motu->rx_stream,
249 					      motu->rx_resources.channel, spd);
250 		if (err < 0)
251 			goto stop_streams;
252 
253 		err = amdtp_domain_start(&motu->domain);
254 		if (err < 0)
255 			goto stop_streams;
256 
257 		if (!amdtp_stream_wait_callback(&motu->tx_stream,
258 						CALLBACK_TIMEOUT) ||
259 		    !amdtp_stream_wait_callback(&motu->rx_stream,
260 						CALLBACK_TIMEOUT)) {
261 			err = -ETIMEDOUT;
262 			goto stop_streams;
263 		}
264 
265 		err = motu->spec->protocol->switch_fetching_mode(motu, true);
266 		if (err < 0) {
267 			dev_err(&motu->unit->device,
268 				"fail to enable frame fetching: %d\n", err);
269 			goto stop_streams;
270 		}
271 	}
272 
273 	return 0;
274 
275 stop_streams:
276 	amdtp_domain_stop(&motu->domain);
277 	finish_session(motu);
278 	return err;
279 }
280 
281 void snd_motu_stream_stop_duplex(struct snd_motu *motu)
282 {
283 	if (motu->substreams_counter == 0) {
284 		amdtp_domain_stop(&motu->domain);
285 		finish_session(motu);
286 
287 		fw_iso_resources_free(&motu->tx_resources);
288 		fw_iso_resources_free(&motu->rx_resources);
289 	}
290 }
291 
292 static int init_stream(struct snd_motu *motu, struct amdtp_stream *s)
293 {
294 	struct fw_iso_resources *resources;
295 	enum amdtp_stream_direction dir;
296 	int err;
297 
298 	if (s == &motu->tx_stream) {
299 		resources = &motu->tx_resources;
300 		dir = AMDTP_IN_STREAM;
301 	} else {
302 		resources = &motu->rx_resources;
303 		dir = AMDTP_OUT_STREAM;
304 	}
305 
306 	err = fw_iso_resources_init(resources, motu->unit);
307 	if (err < 0)
308 		return err;
309 
310 	err = amdtp_motu_init(s, motu->unit, dir, motu->spec->protocol);
311 	if (err < 0)
312 		fw_iso_resources_destroy(resources);
313 
314 	return err;
315 }
316 
317 static void destroy_stream(struct snd_motu *motu, struct amdtp_stream *s)
318 {
319 	amdtp_stream_destroy(s);
320 
321 	if (s == &motu->tx_stream)
322 		fw_iso_resources_destroy(&motu->tx_resources);
323 	else
324 		fw_iso_resources_destroy(&motu->rx_resources);
325 }
326 
327 int snd_motu_stream_init_duplex(struct snd_motu *motu)
328 {
329 	int err;
330 
331 	err = init_stream(motu, &motu->tx_stream);
332 	if (err < 0)
333 		return err;
334 
335 	err = init_stream(motu, &motu->rx_stream);
336 	if (err < 0) {
337 		destroy_stream(motu, &motu->tx_stream);
338 		return err;
339 	}
340 
341 	err = amdtp_domain_init(&motu->domain);
342 	if (err < 0) {
343 		destroy_stream(motu, &motu->tx_stream);
344 		destroy_stream(motu, &motu->rx_stream);
345 	}
346 
347 	return err;
348 }
349 
350 // This function should be called before starting streams or after stopping
351 // streams.
352 void snd_motu_stream_destroy_duplex(struct snd_motu *motu)
353 {
354 	amdtp_domain_destroy(&motu->domain);
355 
356 	destroy_stream(motu, &motu->rx_stream);
357 	destroy_stream(motu, &motu->tx_stream);
358 
359 	motu->substreams_counter = 0;
360 }
361 
362 static void motu_lock_changed(struct snd_motu *motu)
363 {
364 	motu->dev_lock_changed = true;
365 	wake_up(&motu->hwdep_wait);
366 }
367 
368 int snd_motu_stream_lock_try(struct snd_motu *motu)
369 {
370 	int err;
371 
372 	spin_lock_irq(&motu->lock);
373 
374 	if (motu->dev_lock_count < 0) {
375 		err = -EBUSY;
376 		goto out;
377 	}
378 
379 	if (motu->dev_lock_count++ == 0)
380 		motu_lock_changed(motu);
381 	err = 0;
382 out:
383 	spin_unlock_irq(&motu->lock);
384 	return err;
385 }
386 
387 void snd_motu_stream_lock_release(struct snd_motu *motu)
388 {
389 	spin_lock_irq(&motu->lock);
390 
391 	if (WARN_ON(motu->dev_lock_count <= 0))
392 		goto out;
393 
394 	if (--motu->dev_lock_count == 0)
395 		motu_lock_changed(motu);
396 out:
397 	spin_unlock_irq(&motu->lock);
398 }
399