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