1 // SPDX-License-Identifier: GPL-2.0-only
3 * digi00x-stream.c - a part of driver for Digidesign Digi 002/003 family
5 * Copyright (c) 2014-2015 Takashi Sakamoto
10 #define CALLBACK_TIMEOUT 500
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,
19 /* Multi Bit Linear Audio data channels for each sampling transfer frequency. */
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),
26 [SND_DG00X_RATE_88200] = (8 + 2),
27 [SND_DG00X_RATE_96000] = (8 + 2),
30 int snd_dg00x_stream_get_local_rate(struct snd_dg00x *dg00x, unsigned int *rate)
36 err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
37 DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
38 ®, sizeof(reg), 0);
42 data = be32_to_cpu(reg) & 0x0f;
43 if (data < ARRAY_SIZE(snd_dg00x_stream_rates))
44 *rate = snd_dg00x_stream_rates[data];
51 int snd_dg00x_stream_set_local_rate(struct snd_dg00x *dg00x, unsigned int rate)
56 for (i = 0; i < ARRAY_SIZE(snd_dg00x_stream_rates); i++) {
57 if (rate == snd_dg00x_stream_rates[i])
60 if (i == ARRAY_SIZE(snd_dg00x_stream_rates))
64 return snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
65 DG00X_ADDR_BASE + DG00X_OFFSET_LOCAL_RATE,
66 ®, sizeof(reg), 0);
69 int snd_dg00x_stream_get_clock(struct snd_dg00x *dg00x,
70 enum snd_dg00x_clock *clock)
75 err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
76 DG00X_ADDR_BASE + DG00X_OFFSET_CLOCK_SOURCE,
77 ®, sizeof(reg), 0);
81 *clock = be32_to_cpu(reg) & 0x0f;
82 if (*clock >= SND_DG00X_CLOCK_COUNT)
88 int snd_dg00x_stream_check_external_clock(struct snd_dg00x *dg00x, bool *detect)
93 err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
94 DG00X_ADDR_BASE + DG00X_OFFSET_DETECT_EXTERNAL,
95 ®, sizeof(reg), 0);
97 *detect = be32_to_cpu(reg) > 0;
102 int snd_dg00x_stream_get_external_rate(struct snd_dg00x *dg00x,
109 err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
110 DG00X_ADDR_BASE + DG00X_OFFSET_EXTERNAL_RATE,
111 ®, sizeof(reg), 0);
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. */
125 static void finish_session(struct snd_dg00x *dg00x)
129 amdtp_stream_stop(&dg00x->tx_stream);
130 amdtp_stream_stop(&dg00x->rx_stream);
132 data = cpu_to_be32(0x00000003);
133 snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
134 DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_SET,
135 &data, sizeof(data), 0);
137 // Unregister isochronous channels for both direction.
139 snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
140 DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
141 &data, sizeof(data), 0);
143 // Just after finishing the session, the device may lost transmitting
144 // functionality for a short time.
148 static int begin_session(struct snd_dg00x *dg00x)
154 // Register isochronous channels for both direction.
155 data = cpu_to_be32((dg00x->tx_resources.channel << 16) |
156 dg00x->rx_resources.channel);
157 err = snd_fw_transaction(dg00x->unit, TCODE_WRITE_QUADLET_REQUEST,
158 DG00X_ADDR_BASE + DG00X_OFFSET_ISOC_CHANNELS,
159 &data, sizeof(data), 0);
163 err = snd_fw_transaction(dg00x->unit, TCODE_READ_QUADLET_REQUEST,
164 DG00X_ADDR_BASE + DG00X_OFFSET_STREAMING_STATE,
165 &data, sizeof(data), 0);
168 curr = be32_to_cpu(data);
175 data = cpu_to_be32(curr);
176 err = snd_fw_transaction(dg00x->unit,
177 TCODE_WRITE_QUADLET_REQUEST,
179 DG00X_OFFSET_STREAMING_SET,
180 &data, sizeof(data), 0);
191 static int keep_resources(struct snd_dg00x *dg00x, struct amdtp_stream *stream,
194 struct fw_iso_resources *resources;
198 // Check sampling rate.
199 for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
200 if (snd_dg00x_stream_rates[i] == rate)
203 if (i == SND_DG00X_RATE_COUNT)
206 if (stream == &dg00x->tx_stream)
207 resources = &dg00x->tx_resources;
209 resources = &dg00x->rx_resources;
211 err = amdtp_dot_set_parameters(stream, rate,
212 snd_dg00x_stream_pcm_channels[i]);
216 return fw_iso_resources_allocate(resources,
217 amdtp_stream_get_max_payload(stream),
218 fw_parent_device(dg00x->unit)->max_speed);
221 int snd_dg00x_stream_init_duplex(struct snd_dg00x *dg00x)
225 /* For out-stream. */
226 err = fw_iso_resources_init(&dg00x->rx_resources, dg00x->unit);
229 err = amdtp_dot_init(&dg00x->rx_stream, dg00x->unit, AMDTP_OUT_STREAM);
234 err = fw_iso_resources_init(&dg00x->tx_resources, dg00x->unit);
237 err = amdtp_dot_init(&dg00x->tx_stream, dg00x->unit, AMDTP_IN_STREAM);
243 snd_dg00x_stream_destroy_duplex(dg00x);
248 * This function should be called before starting streams or after stopping
251 void snd_dg00x_stream_destroy_duplex(struct snd_dg00x *dg00x)
253 amdtp_stream_destroy(&dg00x->rx_stream);
254 fw_iso_resources_destroy(&dg00x->rx_resources);
256 amdtp_stream_destroy(&dg00x->tx_stream);
257 fw_iso_resources_destroy(&dg00x->tx_resources);
260 int snd_dg00x_stream_reserve_duplex(struct snd_dg00x *dg00x, unsigned int rate)
262 unsigned int curr_rate;
265 err = snd_dg00x_stream_get_local_rate(dg00x, &curr_rate);
271 if (dg00x->substreams_counter == 0 || curr_rate != rate) {
272 finish_session(dg00x);
274 fw_iso_resources_free(&dg00x->tx_resources);
275 fw_iso_resources_free(&dg00x->rx_resources);
277 err = snd_dg00x_stream_set_local_rate(dg00x, rate);
281 err = keep_resources(dg00x, &dg00x->rx_stream, rate);
285 err = keep_resources(dg00x, &dg00x->tx_stream, rate);
287 fw_iso_resources_free(&dg00x->rx_resources);
295 int snd_dg00x_stream_start_duplex(struct snd_dg00x *dg00x)
297 unsigned int generation = dg00x->rx_resources.generation;
300 if (dg00x->substreams_counter == 0)
303 if (amdtp_streaming_error(&dg00x->tx_stream) ||
304 amdtp_streaming_error(&dg00x->rx_stream))
305 finish_session(dg00x);
307 if (generation != fw_parent_device(dg00x->unit)->card->generation) {
308 err = fw_iso_resources_update(&dg00x->tx_resources);
312 err = fw_iso_resources_update(&dg00x->rx_resources);
318 * No packets are transmitted without receiving packets, reagardless of
319 * which source of clock is used.
321 if (!amdtp_stream_running(&dg00x->rx_stream)) {
322 err = begin_session(dg00x);
326 err = amdtp_stream_start(&dg00x->rx_stream,
327 dg00x->rx_resources.channel,
328 fw_parent_device(dg00x->unit)->max_speed);
332 if (!amdtp_stream_wait_callback(&dg00x->rx_stream,
340 * The value of SYT field in transmitted packets is always 0x0000. Thus,
341 * duplex streams with timestamp synchronization cannot be built.
343 if (!amdtp_stream_running(&dg00x->tx_stream)) {
344 err = amdtp_stream_start(&dg00x->tx_stream,
345 dg00x->tx_resources.channel,
346 fw_parent_device(dg00x->unit)->max_speed);
350 if (!amdtp_stream_wait_callback(&dg00x->tx_stream,
359 finish_session(dg00x);
364 void snd_dg00x_stream_stop_duplex(struct snd_dg00x *dg00x)
366 if (dg00x->substreams_counter == 0) {
367 finish_session(dg00x);
369 fw_iso_resources_free(&dg00x->tx_resources);
370 fw_iso_resources_free(&dg00x->rx_resources);
374 void snd_dg00x_stream_update_duplex(struct snd_dg00x *dg00x)
376 fw_iso_resources_update(&dg00x->tx_resources);
377 fw_iso_resources_update(&dg00x->rx_resources);
379 amdtp_stream_update(&dg00x->tx_stream);
380 amdtp_stream_update(&dg00x->rx_stream);
383 void snd_dg00x_stream_lock_changed(struct snd_dg00x *dg00x)
385 dg00x->dev_lock_changed = true;
386 wake_up(&dg00x->hwdep_wait);
389 int snd_dg00x_stream_lock_try(struct snd_dg00x *dg00x)
393 spin_lock_irq(&dg00x->lock);
395 /* user land lock this */
396 if (dg00x->dev_lock_count < 0) {
401 /* this is the first time */
402 if (dg00x->dev_lock_count++ == 0)
403 snd_dg00x_stream_lock_changed(dg00x);
406 spin_unlock_irq(&dg00x->lock);
410 void snd_dg00x_stream_lock_release(struct snd_dg00x *dg00x)
412 spin_lock_irq(&dg00x->lock);
414 if (WARN_ON(dg00x->dev_lock_count <= 0))
416 if (--dg00x->dev_lock_count == 0)
417 snd_dg00x_stream_lock_changed(dg00x);
419 spin_unlock_irq(&dg00x->lock);