1 // SPDX-License-Identifier: GPL-2.0-only
3 * tascam-stream.c - a part of driver for TASCAM FireWire series
5 * Copyright (c) 2015 Takashi Sakamoto
8 #include <linux/delay.h>
11 #define CLOCK_STATUS_MASK 0xffff0000
12 #define CLOCK_CONFIG_MASK 0x0000ffff
14 #define CALLBACK_TIMEOUT 500
16 static int get_clock(struct snd_tscm *tscm, u32 *data)
23 err = snd_fw_transaction(tscm->unit, TCODE_READ_QUADLET_REQUEST,
24 TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
25 ®, sizeof(reg), 0);
29 *data = be32_to_cpu(reg);
30 if (*data & CLOCK_STATUS_MASK)
33 // In intermediate state after changing clock status.
37 // Still in the intermediate state.
44 static int set_clock(struct snd_tscm *tscm, unsigned int rate,
45 enum snd_tscm_clock clock)
51 err = get_clock(tscm, &data);
54 data &= CLOCK_CONFIG_MASK;
59 if ((rate % 44100) == 0) {
62 if (rate / 44100 == 2)
64 } else if ((rate % 48000) == 0) {
67 if (rate / 48000 == 2)
74 if (clock != INT_MAX) {
79 reg = cpu_to_be32(data);
81 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
82 TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
83 ®, sizeof(reg), 0);
87 if (data & 0x00008000)
88 reg = cpu_to_be32(0x0000001a);
90 reg = cpu_to_be32(0x0000000d);
92 return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
93 TSCM_ADDR_BASE + TSCM_OFFSET_MULTIPLEX_MODE,
94 ®, sizeof(reg), 0);
97 int snd_tscm_stream_get_rate(struct snd_tscm *tscm, unsigned int *rate)
102 err = get_clock(tscm, &data);
106 data = (data & 0xff000000) >> 24;
108 /* Check base rate. */
109 if ((data & 0x0f) == 0x01)
111 else if ((data & 0x0f) == 0x02)
116 /* Check multiplier. */
117 if ((data & 0xf0) == 0x80)
119 else if ((data & 0xf0) != 0x00)
125 int snd_tscm_stream_get_clock(struct snd_tscm *tscm, enum snd_tscm_clock *clock)
130 err = get_clock(tscm, &data);
134 *clock = ((data & 0x00ff0000) >> 16) - 1;
135 if (*clock < 0 || *clock > SND_TSCM_CLOCK_ADAT)
141 static int enable_data_channels(struct snd_tscm *tscm)
149 for (i = 0; i < tscm->spec->pcm_capture_analog_channels; ++i)
151 if (tscm->spec->has_adat)
153 if (tscm->spec->has_spdif)
156 reg = cpu_to_be32(data);
157 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
158 TSCM_ADDR_BASE + TSCM_OFFSET_TX_PCM_CHANNELS,
159 ®, sizeof(reg), 0);
164 for (i = 0; i < tscm->spec->pcm_playback_analog_channels; ++i)
166 if (tscm->spec->has_adat)
168 if (tscm->spec->has_spdif)
171 reg = cpu_to_be32(data);
172 return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
173 TSCM_ADDR_BASE + TSCM_OFFSET_RX_PCM_CHANNELS,
174 ®, sizeof(reg), 0);
177 static int set_stream_formats(struct snd_tscm *tscm, unsigned int rate)
182 // Set an option for unknown purpose.
183 reg = cpu_to_be32(0x00200000);
184 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
185 TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
186 ®, sizeof(reg), 0);
190 return enable_data_channels(tscm);
193 static void finish_session(struct snd_tscm *tscm)
197 amdtp_stream_stop(&tscm->rx_stream);
198 amdtp_stream_stop(&tscm->tx_stream);
201 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
202 TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
203 ®, sizeof(reg), 0);
206 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
207 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
208 ®, sizeof(reg), 0);
210 // Unregister channels.
211 reg = cpu_to_be32(0x00000000);
212 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
213 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
214 ®, sizeof(reg), 0);
215 reg = cpu_to_be32(0x00000000);
216 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
217 TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
218 ®, sizeof(reg), 0);
219 reg = cpu_to_be32(0x00000000);
220 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
221 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
222 ®, sizeof(reg), 0);
225 static int begin_session(struct snd_tscm *tscm)
230 // Register the isochronous channel for transmitting stream.
231 reg = cpu_to_be32(tscm->tx_resources.channel);
232 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
233 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
234 ®, sizeof(reg), 0);
239 reg = cpu_to_be32(0x00000002);
240 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
241 TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
242 ®, sizeof(reg), 0);
246 // Register the isochronous channel for receiving stream.
247 reg = cpu_to_be32(tscm->rx_resources.channel);
248 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
249 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
250 ®, sizeof(reg), 0);
254 reg = cpu_to_be32(0x00000001);
255 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
256 TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
257 ®, sizeof(reg), 0);
261 reg = cpu_to_be32(0x00000001);
262 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
263 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
264 ®, sizeof(reg), 0);
268 // Set an option for unknown purpose.
269 reg = cpu_to_be32(0x00002000);
270 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
271 TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
272 ®, sizeof(reg), 0);
276 // Start multiplexing PCM samples on packets.
277 reg = cpu_to_be32(0x00000001);
278 return snd_fw_transaction(tscm->unit,
279 TCODE_WRITE_QUADLET_REQUEST,
280 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_ON,
281 ®, sizeof(reg), 0);
284 static int keep_resources(struct snd_tscm *tscm, unsigned int rate,
285 struct amdtp_stream *stream)
287 struct fw_iso_resources *resources;
290 if (stream == &tscm->tx_stream)
291 resources = &tscm->tx_resources;
293 resources = &tscm->rx_resources;
295 err = amdtp_tscm_set_parameters(stream, rate);
299 return fw_iso_resources_allocate(resources,
300 amdtp_stream_get_max_payload(stream),
301 fw_parent_device(tscm->unit)->max_speed);
304 int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
306 unsigned int pcm_channels;
309 /* For out-stream. */
310 err = fw_iso_resources_init(&tscm->rx_resources, tscm->unit);
313 pcm_channels = tscm->spec->pcm_playback_analog_channels;
314 if (tscm->spec->has_adat)
316 if (tscm->spec->has_spdif)
318 err = amdtp_tscm_init(&tscm->rx_stream, tscm->unit, AMDTP_OUT_STREAM,
324 err = fw_iso_resources_init(&tscm->tx_resources, tscm->unit);
327 pcm_channels = tscm->spec->pcm_capture_analog_channels;
328 if (tscm->spec->has_adat)
330 if (tscm->spec->has_spdif)
332 err = amdtp_tscm_init(&tscm->tx_stream, tscm->unit, AMDTP_IN_STREAM,
335 amdtp_stream_destroy(&tscm->rx_stream);
340 // At bus reset, streaming is stopped and some registers are clear.
341 void snd_tscm_stream_update_duplex(struct snd_tscm *tscm)
343 amdtp_stream_pcm_abort(&tscm->tx_stream);
344 amdtp_stream_stop(&tscm->tx_stream);
346 amdtp_stream_pcm_abort(&tscm->rx_stream);
347 amdtp_stream_stop(&tscm->rx_stream);
351 * This function should be called before starting streams or after stopping
354 void snd_tscm_stream_destroy_duplex(struct snd_tscm *tscm)
356 amdtp_stream_destroy(&tscm->rx_stream);
357 amdtp_stream_destroy(&tscm->tx_stream);
359 fw_iso_resources_destroy(&tscm->rx_resources);
360 fw_iso_resources_destroy(&tscm->tx_resources);
363 int snd_tscm_stream_reserve_duplex(struct snd_tscm *tscm, unsigned int rate)
365 unsigned int curr_rate;
368 err = snd_tscm_stream_get_rate(tscm, &curr_rate);
372 if (tscm->substreams_counter == 0 || rate != curr_rate) {
373 finish_session(tscm);
375 fw_iso_resources_free(&tscm->tx_resources);
376 fw_iso_resources_free(&tscm->rx_resources);
378 err = set_clock(tscm, rate, INT_MAX);
382 err = keep_resources(tscm, rate, &tscm->tx_stream);
386 err = keep_resources(tscm, rate, &tscm->rx_stream);
388 fw_iso_resources_free(&tscm->tx_resources);
396 int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
398 unsigned int generation = tscm->rx_resources.generation;
401 if (tscm->substreams_counter == 0)
404 if (amdtp_streaming_error(&tscm->rx_stream) ||
405 amdtp_streaming_error(&tscm->tx_stream))
406 finish_session(tscm);
408 if (generation != fw_parent_device(tscm->unit)->card->generation) {
409 err = fw_iso_resources_update(&tscm->tx_resources);
413 err = fw_iso_resources_update(&tscm->rx_resources);
418 if (!amdtp_stream_running(&tscm->rx_stream)) {
419 err = set_stream_formats(tscm, rate);
423 err = begin_session(tscm);
427 err = amdtp_stream_start(&tscm->rx_stream,
428 tscm->rx_resources.channel,
429 fw_parent_device(tscm->unit)->max_speed);
433 if (!amdtp_stream_wait_callback(&tscm->rx_stream,
440 if (!amdtp_stream_running(&tscm->tx_stream)) {
441 err = amdtp_stream_start(&tscm->tx_stream,
442 tscm->tx_resources.channel,
443 fw_parent_device(tscm->unit)->max_speed);
447 if (!amdtp_stream_wait_callback(&tscm->tx_stream,
456 finish_session(tscm);
461 void snd_tscm_stream_stop_duplex(struct snd_tscm *tscm)
463 if (tscm->substreams_counter == 0) {
464 finish_session(tscm);
466 fw_iso_resources_free(&tscm->tx_resources);
467 fw_iso_resources_free(&tscm->rx_resources);
471 void snd_tscm_stream_lock_changed(struct snd_tscm *tscm)
473 tscm->dev_lock_changed = true;
474 wake_up(&tscm->hwdep_wait);
477 int snd_tscm_stream_lock_try(struct snd_tscm *tscm)
481 spin_lock_irq(&tscm->lock);
483 /* user land lock this */
484 if (tscm->dev_lock_count < 0) {
489 /* this is the first time */
490 if (tscm->dev_lock_count++ == 0)
491 snd_tscm_stream_lock_changed(tscm);
494 spin_unlock_irq(&tscm->lock);
498 void snd_tscm_stream_lock_release(struct snd_tscm *tscm)
500 spin_lock_irq(&tscm->lock);
502 if (WARN_ON(tscm->dev_lock_count <= 0))
504 if (--tscm->dev_lock_count == 0)
505 snd_tscm_stream_lock_changed(tscm);
507 spin_unlock_irq(&tscm->lock);