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 CALLBACK_TIMEOUT 500
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
snd_dg00x_stream_get_local_rate(struct snd_dg00x * dg00x,unsigned int * rate)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 ®, 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
snd_dg00x_stream_set_local_rate(struct snd_dg00x * dg00x,unsigned int rate)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 ®, sizeof(reg), 0);
67 }
68
snd_dg00x_stream_get_clock(struct snd_dg00x * dg00x,enum snd_dg00x_clock * clock)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 ®, 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
snd_dg00x_stream_check_external_clock(struct snd_dg00x * dg00x,bool * detect)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 ®, sizeof(reg), 0);
96 if (err >= 0)
97 *detect = be32_to_cpu(reg) > 0;
98
99 return err;
100 }
101
snd_dg00x_stream_get_external_rate(struct snd_dg00x * dg00x,unsigned int * rate)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 ®, 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
finish_session(struct snd_dg00x * dg00x)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
begin_session(struct snd_dg00x * dg00x)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
keep_resources(struct snd_dg00x * dg00x,struct amdtp_stream * stream,unsigned int rate)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
init_stream(struct snd_dg00x * dg00x,struct amdtp_stream * s)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
destroy_stream(struct snd_dg00x * dg00x,struct amdtp_stream * s)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
snd_dg00x_stream_init_duplex(struct snd_dg00x * dg00x)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 */
snd_dg00x_stream_destroy_duplex(struct snd_dg00x * dg00x)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
snd_dg00x_stream_reserve_duplex(struct snd_dg00x * dg00x,unsigned int rate)288 int snd_dg00x_stream_reserve_duplex(struct snd_dg00x *dg00x, unsigned int rate)
289 {
290 unsigned int curr_rate;
291 int err;
292
293 err = snd_dg00x_stream_get_local_rate(dg00x, &curr_rate);
294 if (err < 0)
295 return err;
296 if (rate == 0)
297 rate = curr_rate;
298
299 if (dg00x->substreams_counter == 0 || curr_rate != rate) {
300 amdtp_domain_stop(&dg00x->domain);
301
302 finish_session(dg00x);
303
304 fw_iso_resources_free(&dg00x->tx_resources);
305 fw_iso_resources_free(&dg00x->rx_resources);
306
307 err = snd_dg00x_stream_set_local_rate(dg00x, rate);
308 if (err < 0)
309 return err;
310
311 err = keep_resources(dg00x, &dg00x->rx_stream, rate);
312 if (err < 0)
313 return err;
314
315 err = keep_resources(dg00x, &dg00x->tx_stream, rate);
316 if (err < 0) {
317 fw_iso_resources_free(&dg00x->rx_resources);
318 return err;
319 }
320 }
321
322 return 0;
323 }
324
snd_dg00x_stream_start_duplex(struct snd_dg00x * dg00x)325 int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x)
326 {
327 unsigned int generation = dg00x->rx_resources.generation;
328 int err = 0;
329
330 if (dg00x->substreams_counter == 0)
331 return 0;
332
333 if (amdtp_streaming_error(&dg00x->tx_stream) ||
334 amdtp_streaming_error(&dg00x->rx_stream)) {
335 amdtp_domain_stop(&dg00x->domain);
336 finish_session(dg00x);
337 }
338
339 if (generation != fw_parent_device(dg00x->unit)->card->generation) {
340 err = fw_iso_resources_update(&dg00x->tx_resources);
341 if (err < 0)
342 goto error;
343
344 err = fw_iso_resources_update(&dg00x->rx_resources);
345 if (err < 0)
346 goto error;
347 }
348
349 /*
350 * No packets are transmitted without receiving packets, reagardless of
351 * which source of clock is used.
352 */
353 if (!amdtp_stream_running(&dg00x->rx_stream)) {
354 int spd = fw_parent_device(dg00x->unit)->max_speed;
355
356 err = begin_session(dg00x);
357 if (err < 0)
358 goto error;
359
360 err = amdtp_domain_add_stream(&dg00x->domain, &dg00x->rx_stream,
361 dg00x->rx_resources.channel, spd);
362 if (err < 0)
363 goto error;
364
365 err = amdtp_domain_add_stream(&dg00x->domain, &dg00x->tx_stream,
366 dg00x->tx_resources.channel, spd);
367 if (err < 0)
368 goto error;
369
370 err = amdtp_domain_start(&dg00x->domain);
371 if (err < 0)
372 goto error;
373
374 if (!amdtp_stream_wait_callback(&dg00x->rx_stream,
375 CALLBACK_TIMEOUT) ||
376 !amdtp_stream_wait_callback(&dg00x->tx_stream,
377 CALLBACK_TIMEOUT)) {
378 err = -ETIMEDOUT;
379 goto error;
380 }
381 }
382
383 return 0;
384 error:
385 amdtp_domain_stop(&dg00x->domain);
386 finish_session(dg00x);
387
388 return err;
389 }
390
snd_dg00x_stream_stop_duplex(struct snd_dg00x * dg00x)391 void snd_dg00x_stream_stop_duplex(struct snd_dg00x *dg00x)
392 {
393 if (dg00x->substreams_counter == 0) {
394 amdtp_domain_stop(&dg00x->domain);
395 finish_session(dg00x);
396
397 fw_iso_resources_free(&dg00x->tx_resources);
398 fw_iso_resources_free(&dg00x->rx_resources);
399 }
400 }
401
snd_dg00x_stream_update_duplex(struct snd_dg00x * dg00x)402 void snd_dg00x_stream_update_duplex(struct snd_dg00x *dg00x)
403 {
404 fw_iso_resources_update(&dg00x->tx_resources);
405 fw_iso_resources_update(&dg00x->rx_resources);
406
407 amdtp_stream_update(&dg00x->tx_stream);
408 amdtp_stream_update(&dg00x->rx_stream);
409 }
410
snd_dg00x_stream_lock_changed(struct snd_dg00x * dg00x)411 void snd_dg00x_stream_lock_changed(struct snd_dg00x *dg00x)
412 {
413 dg00x->dev_lock_changed = true;
414 wake_up(&dg00x->hwdep_wait);
415 }
416
snd_dg00x_stream_lock_try(struct snd_dg00x * dg00x)417 int snd_dg00x_stream_lock_try(struct snd_dg00x *dg00x)
418 {
419 int err;
420
421 spin_lock_irq(&dg00x->lock);
422
423 /* user land lock this */
424 if (dg00x->dev_lock_count < 0) {
425 err = -EBUSY;
426 goto end;
427 }
428
429 /* this is the first time */
430 if (dg00x->dev_lock_count++ == 0)
431 snd_dg00x_stream_lock_changed(dg00x);
432 err = 0;
433 end:
434 spin_unlock_irq(&dg00x->lock);
435 return err;
436 }
437
snd_dg00x_stream_lock_release(struct snd_dg00x * dg00x)438 void snd_dg00x_stream_lock_release(struct snd_dg00x *dg00x)
439 {
440 spin_lock_irq(&dg00x->lock);
441
442 if (WARN_ON(dg00x->dev_lock_count <= 0))
443 goto end;
444 if (--dg00x->dev_lock_count == 0)
445 snd_dg00x_stream_lock_changed(dg00x);
446 end:
447 spin_unlock_irq(&dg00x->lock);
448 }
449