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