1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * digi00x-stream.c - a part of driver for Digidesign Digi 002/003 family
4  *
5  * Copyright (c) 2014-2015 Takashi Sakamoto
6  */
7 
8 #include "digi00x.h"
9 
10 #define READY_TIMEOUT_MS	200
11 
12 const unsigned int snd_dg00x_stream_rates[SND_DG00X_RATE_COUNT] = {
13 	[SND_DG00X_RATE_44100] = 44100,
14 	[SND_DG00X_RATE_48000] = 48000,
15 	[SND_DG00X_RATE_88200] = 88200,
16 	[SND_DG00X_RATE_96000] = 96000,
17 };
18 
19 /* Multi Bit Linear Audio data channels for each sampling transfer frequency. */
20 const unsigned int
21 snd_dg00x_stream_pcm_channels[SND_DG00X_RATE_COUNT] = {
22 	/* Analog/ADAT/SPDIF */
23 	[SND_DG00X_RATE_44100] = (8 + 8 + 2),
24 	[SND_DG00X_RATE_48000] = (8 + 8 + 2),
25 	/* Analog/SPDIF */
26 	[SND_DG00X_RATE_88200] = (8 + 2),
27 	[SND_DG00X_RATE_96000] = (8 + 2),
28 };
29 
30 int snd_dg00x_stream_get_local_rate(struct snd_dg00x *dg00x, unsigned int *rate)
31 {
32 	u32 data;
33 	__be32 reg;
34 	int err;
35 
36 	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
37 				 DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
38 				 &reg, sizeof(reg), 0);
39 	if (err < 0)
40 		return err;
41 
42 	data = be32_to_cpu(reg) & 0x0f;
43 	if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
44 		*rate = snd_dg00x_stream_rates[data];
45 	else
46 		err = -EIO;
47 
48 	return err;
49 }
50 
51 int snd_dg00x_stream_set_local_rate(struct snd_dg00x *dg00x, unsigned int rate)
52 {
53 	__be32 reg;
54 	unsigned int i;
55 
56 	for (i = 0; i < ARRAY_SIZE(snd_dg00x_stream_rates); i++) {
57 		if (rate == snd_dg00x_stream_rates[i])
58 			break;
59 	}
60 	if (i == ARRAY_SIZE(snd_dg00x_stream_rates))
61 		return -EINVAL;
62 
63 	reg = cpu_to_be32(i);
64 	return snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
65 				  DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
66 				  &reg, sizeof(reg), 0);
67 }
68 
69 int snd_dg00x_stream_get_clock(struct snd_dg00x *dg00x,
70 			       enum snd_dg00x_clock *clock)
71 {
72 	__be32 reg;
73 	int err;
74 
75 	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
76 				 DG00X_ADDR_BASE + DG00X_OFFSET_CLOCK_SOURCE,
77 				 &reg, sizeof(reg), 0);
78 	if (err < 0)
79 		return err;
80 
81 	*clock = be32_to_cpu(reg) & 0x0f;
82 	if (*clock >= SND_DG00X_CLOCK_COUNT)
83 		err = -EIO;
84 
85 	return err;
86 }
87 
88 int snd_dg00x_stream_check_external_clock(struct snd_dg00x *dg00x, bool *detect)
89 {
90 	__be32 reg;
91 	int err;
92 
93 	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
94 				 DG00X_ADDR_BASE + DG00X_OFFSET_DETECT_EXTERNAL,
95 				 &reg, sizeof(reg), 0);
96 	if (err >= 0)
97 		*detect = be32_to_cpu(reg) > 0;
98 
99 	return err;
100 }
101 
102 int snd_dg00x_stream_get_external_rate(struct snd_dg00x *dg00x,
103 				       unsigned int *rate)
104 {
105 	u32 data;
106 	__be32 reg;
107 	int err;
108 
109 	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
110 				 DG00X_ADDR_BASE + DG00X_OFFSET_EXTERNAL_RATE,
111 				 &reg, sizeof(reg), 0);
112 	if (err < 0)
113 		return err;
114 
115 	data = be32_to_cpu(reg) & 0x0f;
116 	if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
117 		*rate = snd_dg00x_stream_rates[data];
118 	/* This means desync. */
119 	else
120 		err = -EBUSY;
121 
122 	return err;
123 }
124 
125 static void finish_session(struct snd_dg00x *dg00x)
126 {
127 	__be32 data;
128 
129 	data = cpu_to_be32(0x00000003);
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 	// Unregister isochronous channels for both direction.
135 	data = 0;
136 	snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
137 			   DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
138 			   &data, sizeof(data), 0);
139 
140 	// Just after finishing the session, the device may lost transmitting
141 	// functionality for a short time.
142 	msleep(50);
143 }
144 
145 static int begin_session(struct snd_dg00x *dg00x)
146 {
147 	__be32 data;
148 	u32 curr;
149 	int err;
150 
151 	// Register isochronous channels for both direction.
152 	data = cpu_to_be32((dg00x->tx_resources.channel << 16) |
153 			   dg00x->rx_resources.channel);
154 	err = snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
155 				 DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
156 				 &data, sizeof(data), 0);
157 	if (err < 0)
158 		return err;
159 
160 	err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
161 				 DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_STATE,
162 				 &data, sizeof(data), 0);
163 	if (err < 0)
164 		return err;
165 	curr = be32_to_cpu(data);
166 
167 	if (curr == 0)
168 		curr = 2;
169 
170 	curr--;
171 	while (curr > 0) {
172 		data = cpu_to_be32(curr);
173 		err = snd_fw_transaction(dg00x->unit,
174 					 TCODE_WRITE_QUADLET_REQUEST,
175 					 DG00X_ADDR_BASE +
176 					 DG00X_OFFSET_STREAMING_SET,
177 					 &data, sizeof(data), 0);
178 		if (err < 0)
179 			break;
180 
181 		msleep(20);
182 		curr--;
183 	}
184 
185 	return err;
186 }
187 
188 static int keep_resources(struct snd_dg00x *dg00x, struct amdtp_stream *stream,
189 			  unsigned int rate)
190 {
191 	struct fw_iso_resources *resources;
192 	int i;
193 	int err;
194 
195 	// Check sampling rate.
196 	for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
197 		if (snd_dg00x_stream_rates[i] == rate)
198 			break;
199 	}
200 	if (i == SND_DG00X_RATE_COUNT)
201 		return -EINVAL;
202 
203 	if (stream == &dg00x->tx_stream)
204 		resources = &dg00x->tx_resources;
205 	else
206 		resources = &dg00x->rx_resources;
207 
208 	err = amdtp_dot_set_parameters(stream, rate,
209 				       snd_dg00x_stream_pcm_channels[i]);
210 	if (err < 0)
211 		return err;
212 
213 	return fw_iso_resources_allocate(resources,
214 				amdtp_stream_get_max_payload(stream),
215 				fw_parent_device(dg00x->unit)->max_speed);
216 }
217 
218 static int init_stream(struct snd_dg00x *dg00x, struct amdtp_stream *s)
219 {
220 	struct fw_iso_resources *resources;
221 	enum amdtp_stream_direction dir;
222 	int err;
223 
224 	if (s == &dg00x->tx_stream) {
225 		resources = &dg00x->tx_resources;
226 		dir = AMDTP_IN_STREAM;
227 	} else {
228 		resources = &dg00x->rx_resources;
229 		dir = AMDTP_OUT_STREAM;
230 	}
231 
232 	err = fw_iso_resources_init(resources, dg00x->unit);
233 	if (err < 0)
234 		return err;
235 
236 	err = amdtp_dot_init(s, dg00x->unit, dir);
237 	if (err < 0)
238 		fw_iso_resources_destroy(resources);
239 
240 	return err;
241 }
242 
243 static void destroy_stream(struct snd_dg00x *dg00x, struct amdtp_stream *s)
244 {
245 	amdtp_stream_destroy(s);
246 
247 	if (s == &dg00x->tx_stream)
248 		fw_iso_resources_destroy(&dg00x->tx_resources);
249 	else
250 		fw_iso_resources_destroy(&dg00x->rx_resources);
251 }
252 
253 int snd_dg00x_stream_init_duplex(struct snd_dg00x *dg00x)
254 {
255 	int err;
256 
257 	err = init_stream(dg00x, &dg00x->rx_stream);
258 	if (err < 0)
259 		return err;
260 
261 	err = init_stream(dg00x, &dg00x->tx_stream);
262 	if (err < 0) {
263 		destroy_stream(dg00x, &dg00x->rx_stream);
264 		return err;
265 	}
266 
267 	err = amdtp_domain_init(&dg00x->domain);
268 	if (err < 0) {
269 		destroy_stream(dg00x, &dg00x->rx_stream);
270 		destroy_stream(dg00x, &dg00x->tx_stream);
271 	}
272 
273 	return err;
274 }
275 
276 /*
277  * This function should be called before starting streams or after stopping
278  * streams.
279  */
280 void snd_dg00x_stream_destroy_duplex(struct snd_dg00x *dg00x)
281 {
282 	amdtp_domain_destroy(&dg00x->domain);
283 
284 	destroy_stream(dg00x, &dg00x->rx_stream);
285 	destroy_stream(dg00x, &dg00x->tx_stream);
286 }
287 
288 int snd_dg00x_stream_reserve_duplex(struct snd_dg00x *dg00x, unsigned int rate,
289 				    unsigned int frames_per_period,
290 				    unsigned int frames_per_buffer)
291 {
292 	unsigned int curr_rate;
293 	int err;
294 
295 	err = snd_dg00x_stream_get_local_rate(dg00x, &curr_rate);
296 	if (err < 0)
297 		return err;
298 	if (rate == 0)
299 		rate = curr_rate;
300 
301 	if (dg00x->substreams_counter == 0 || curr_rate != rate) {
302 		amdtp_domain_stop(&dg00x->domain);
303 
304 		finish_session(dg00x);
305 
306 		fw_iso_resources_free(&dg00x->tx_resources);
307 		fw_iso_resources_free(&dg00x->rx_resources);
308 
309 		err = snd_dg00x_stream_set_local_rate(dg00x, rate);
310 		if (err < 0)
311 			return err;
312 
313 		err = keep_resources(dg00x, &dg00x->rx_stream, rate);
314 		if (err < 0)
315 			return err;
316 
317 		err = keep_resources(dg00x, &dg00x->tx_stream, rate);
318 		if (err < 0) {
319 			fw_iso_resources_free(&dg00x->rx_resources);
320 			return err;
321 		}
322 
323 		err = amdtp_domain_set_events_per_period(&dg00x->domain,
324 					frames_per_period, frames_per_buffer);
325 		if (err < 0) {
326 			fw_iso_resources_free(&dg00x->rx_resources);
327 			fw_iso_resources_free(&dg00x->tx_resources);
328 			return err;
329 		}
330 	}
331 
332 	return 0;
333 }
334 
335 int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x)
336 {
337 	unsigned int generation = dg00x->rx_resources.generation;
338 	int err = 0;
339 
340 	if (dg00x->substreams_counter == 0)
341 		return 0;
342 
343 	if (amdtp_streaming_error(&dg00x->tx_stream) ||
344 	    amdtp_streaming_error(&dg00x->rx_stream)) {
345 		amdtp_domain_stop(&dg00x->domain);
346 		finish_session(dg00x);
347 	}
348 
349 	if (generation != fw_parent_device(dg00x->unit)->card->generation) {
350 		err = fw_iso_resources_update(&dg00x->tx_resources);
351 		if (err < 0)
352 			goto error;
353 
354 		err = fw_iso_resources_update(&dg00x->rx_resources);
355 		if (err < 0)
356 			goto error;
357 	}
358 
359 	/*
360 	 * No packets are transmitted without receiving packets, reagardless of
361 	 * which source of clock is used.
362 	 */
363 	if (!amdtp_stream_running(&dg00x->rx_stream)) {
364 		int spd = fw_parent_device(dg00x->unit)->max_speed;
365 
366 		err = begin_session(dg00x);
367 		if (err < 0)
368 			goto error;
369 
370 		err = amdtp_domain_add_stream(&dg00x->domain, &dg00x->rx_stream,
371 					      dg00x->rx_resources.channel, spd);
372 		if (err < 0)
373 			goto error;
374 
375 		err = amdtp_domain_add_stream(&dg00x->domain, &dg00x->tx_stream,
376 					      dg00x->tx_resources.channel, spd);
377 		if (err < 0)
378 			goto error;
379 
380 		// NOTE: The device doesn't start packet transmission till receiving any packet.
381 		// It ignores presentation time expressed by the value of syt field of CIP header
382 		// in received packets. The sequence of the number of data blocks per packet is
383 		// important for media clock recovery.
384 		err = amdtp_domain_start(&dg00x->domain, 0, true, true);
385 		if (err < 0)
386 			goto error;
387 
388 		if (!amdtp_domain_wait_ready(&dg00x->domain, READY_TIMEOUT_MS)) {
389 			err = -ETIMEDOUT;
390 			goto error;
391 		}
392 	}
393 
394 	return 0;
395 error:
396 	amdtp_domain_stop(&dg00x->domain);
397 	finish_session(dg00x);
398 
399 	return err;
400 }
401 
402 void snd_dg00x_stream_stop_duplex(struct snd_dg00x *dg00x)
403 {
404 	if (dg00x->substreams_counter == 0) {
405 		amdtp_domain_stop(&dg00x->domain);
406 		finish_session(dg00x);
407 
408 		fw_iso_resources_free(&dg00x->tx_resources);
409 		fw_iso_resources_free(&dg00x->rx_resources);
410 	}
411 }
412 
413 void snd_dg00x_stream_update_duplex(struct snd_dg00x *dg00x)
414 {
415 	fw_iso_resources_update(&dg00x->tx_resources);
416 	fw_iso_resources_update(&dg00x->rx_resources);
417 
418 	amdtp_stream_update(&dg00x->tx_stream);
419 	amdtp_stream_update(&dg00x->rx_stream);
420 }
421 
422 void snd_dg00x_stream_lock_changed(struct snd_dg00x *dg00x)
423 {
424 	dg00x->dev_lock_changed = true;
425 	wake_up(&dg00x->hwdep_wait);
426 }
427 
428 int snd_dg00x_stream_lock_try(struct snd_dg00x *dg00x)
429 {
430 	int err;
431 
432 	spin_lock_irq(&dg00x->lock);
433 
434 	/* user land lock this */
435 	if (dg00x->dev_lock_count < 0) {
436 		err = -EBUSY;
437 		goto end;
438 	}
439 
440 	/* this is the first time */
441 	if (dg00x->dev_lock_count++ == 0)
442 		snd_dg00x_stream_lock_changed(dg00x);
443 	err = 0;
444 end:
445 	spin_unlock_irq(&dg00x->lock);
446 	return err;
447 }
448 
449 void snd_dg00x_stream_lock_release(struct snd_dg00x *dg00x)
450 {
451 	spin_lock_irq(&dg00x->lock);
452 
453 	if (WARN_ON(dg00x->dev_lock_count <= 0))
454 		goto end;
455 	if (--dg00x->dev_lock_count == 0)
456 		snd_dg00x_stream_lock_changed(dg00x);
457 end:
458 	spin_unlock_irq(&dg00x->lock);
459 }
460