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 CALLBACK_TIMEOUT 500
13 static int get_clock(struct snd_tscm *tscm, u32 *data)
18 err = snd_fw_transaction(tscm->unit, TCODE_READ_QUADLET_REQUEST,
19 TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
20 ®, sizeof(reg), 0);
22 *data = be32_to_cpu(reg);
27 static int set_clock(struct snd_tscm *tscm, unsigned int rate,
28 enum snd_tscm_clock clock)
34 err = get_clock(tscm, &data);
42 if ((rate % 44100) == 0) {
45 if (rate / 44100 == 2)
47 } else if ((rate % 48000) == 0) {
50 if (rate / 48000 == 2)
57 if (clock != INT_MAX) {
62 reg = cpu_to_be32(data);
64 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
65 TSCM_ADDR_BASE + TSCM_OFFSET_CLOCK_STATUS,
66 ®, sizeof(reg), 0);
70 if (data & 0x00008000)
71 reg = cpu_to_be32(0x0000001a);
73 reg = cpu_to_be32(0x0000000d);
75 return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
76 TSCM_ADDR_BASE + TSCM_OFFSET_MULTIPLEX_MODE,
77 ®, sizeof(reg), 0);
80 int snd_tscm_stream_get_rate(struct snd_tscm *tscm, unsigned int *rate)
83 unsigned int trials = 0;
86 while (data == 0x0 || trials++ < 5) {
87 err = get_clock(tscm, &data);
91 data = (data & 0xff000000) >> 24;
94 /* Check base rate. */
95 if ((data & 0x0f) == 0x01)
97 else if ((data & 0x0f) == 0x02)
102 /* Check multiplier. */
103 if ((data & 0xf0) == 0x80)
105 else if ((data & 0xf0) != 0x00)
111 int snd_tscm_stream_get_clock(struct snd_tscm *tscm, enum snd_tscm_clock *clock)
116 err = get_clock(tscm, &data);
120 *clock = ((data & 0x00ff0000) >> 16) - 1;
121 if (*clock < 0 || *clock > SND_TSCM_CLOCK_ADAT)
127 static int enable_data_channels(struct snd_tscm *tscm)
135 for (i = 0; i < tscm->spec->pcm_capture_analog_channels; ++i)
137 if (tscm->spec->has_adat)
139 if (tscm->spec->has_spdif)
142 reg = cpu_to_be32(data);
143 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
144 TSCM_ADDR_BASE + TSCM_OFFSET_TX_PCM_CHANNELS,
145 ®, sizeof(reg), 0);
150 for (i = 0; i < tscm->spec->pcm_playback_analog_channels; ++i)
152 if (tscm->spec->has_adat)
154 if (tscm->spec->has_spdif)
157 reg = cpu_to_be32(data);
158 return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
159 TSCM_ADDR_BASE + TSCM_OFFSET_RX_PCM_CHANNELS,
160 ®, sizeof(reg), 0);
163 static int set_stream_formats(struct snd_tscm *tscm, unsigned int rate)
168 /* Set an option for unknown purpose. */
169 reg = cpu_to_be32(0x00200000);
170 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
171 TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
172 ®, sizeof(reg), 0);
176 err = enable_data_channels(tscm);
180 return set_clock(tscm, rate, INT_MAX);
183 static void finish_session(struct snd_tscm *tscm)
188 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
189 TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
190 ®, sizeof(reg), 0);
193 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
194 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
195 ®, sizeof(reg), 0);
199 static int begin_session(struct snd_tscm *tscm)
204 reg = cpu_to_be32(0x00000001);
205 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
206 TSCM_ADDR_BASE + TSCM_OFFSET_START_STREAMING,
207 ®, sizeof(reg), 0);
211 reg = cpu_to_be32(0x00000001);
212 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
213 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_ON,
214 ®, sizeof(reg), 0);
218 /* Set an option for unknown purpose. */
219 reg = cpu_to_be32(0x00002000);
220 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
221 TSCM_ADDR_BASE + TSCM_OFFSET_SET_OPTION,
222 ®, sizeof(reg), 0);
226 /* Start multiplexing PCM samples on packets. */
227 reg = cpu_to_be32(0x00000001);
228 return snd_fw_transaction(tscm->unit,
229 TCODE_WRITE_QUADLET_REQUEST,
230 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_ON,
231 ®, sizeof(reg), 0);
234 static void release_resources(struct snd_tscm *tscm)
238 /* Unregister channels. */
239 reg = cpu_to_be32(0x00000000);
240 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
241 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
242 ®, sizeof(reg), 0);
243 reg = cpu_to_be32(0x00000000);
244 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
245 TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
246 ®, sizeof(reg), 0);
247 reg = cpu_to_be32(0x00000000);
248 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
249 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
250 ®, sizeof(reg), 0);
252 /* Release isochronous resources. */
253 fw_iso_resources_free(&tscm->tx_resources);
254 fw_iso_resources_free(&tscm->rx_resources);
257 static int keep_resources(struct snd_tscm *tscm, unsigned int rate)
262 /* Keep resources for in-stream. */
263 err = amdtp_tscm_set_parameters(&tscm->tx_stream, rate);
266 err = fw_iso_resources_allocate(&tscm->tx_resources,
267 amdtp_stream_get_max_payload(&tscm->tx_stream),
268 fw_parent_device(tscm->unit)->max_speed);
272 /* Keep resources for out-stream. */
273 err = amdtp_tscm_set_parameters(&tscm->rx_stream, rate);
276 err = fw_iso_resources_allocate(&tscm->rx_resources,
277 amdtp_stream_get_max_payload(&tscm->rx_stream),
278 fw_parent_device(tscm->unit)->max_speed);
282 /* Register the isochronous channel for transmitting stream. */
283 reg = cpu_to_be32(tscm->tx_resources.channel);
284 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
285 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_TX_CH,
286 ®, sizeof(reg), 0);
291 reg = cpu_to_be32(0x00000002);
292 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
293 TSCM_ADDR_BASE + TSCM_OFFSET_UNKNOWN,
294 ®, sizeof(reg), 0);
298 /* Register the isochronous channel for receiving stream. */
299 reg = cpu_to_be32(tscm->rx_resources.channel);
300 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
301 TSCM_ADDR_BASE + TSCM_OFFSET_ISOC_RX_CH,
302 ®, sizeof(reg), 0);
308 release_resources(tscm);
312 int snd_tscm_stream_init_duplex(struct snd_tscm *tscm)
314 unsigned int pcm_channels;
317 /* For out-stream. */
318 err = fw_iso_resources_init(&tscm->rx_resources, tscm->unit);
321 pcm_channels = tscm->spec->pcm_playback_analog_channels;
322 if (tscm->spec->has_adat)
324 if (tscm->spec->has_spdif)
326 err = amdtp_tscm_init(&tscm->rx_stream, tscm->unit, AMDTP_OUT_STREAM,
332 err = fw_iso_resources_init(&tscm->tx_resources, tscm->unit);
335 pcm_channels = tscm->spec->pcm_capture_analog_channels;
336 if (tscm->spec->has_adat)
338 if (tscm->spec->has_spdif)
340 err = amdtp_tscm_init(&tscm->tx_stream, tscm->unit, AMDTP_IN_STREAM,
343 amdtp_stream_destroy(&tscm->rx_stream);
348 /* At bus reset, streaming is stopped and some registers are clear. */
349 void snd_tscm_stream_update_duplex(struct snd_tscm *tscm)
351 amdtp_stream_pcm_abort(&tscm->tx_stream);
352 amdtp_stream_stop(&tscm->tx_stream);
354 amdtp_stream_pcm_abort(&tscm->rx_stream);
355 amdtp_stream_stop(&tscm->rx_stream);
359 * This function should be called before starting streams or after stopping
362 void snd_tscm_stream_destroy_duplex(struct snd_tscm *tscm)
364 amdtp_stream_destroy(&tscm->rx_stream);
365 amdtp_stream_destroy(&tscm->tx_stream);
367 fw_iso_resources_destroy(&tscm->rx_resources);
368 fw_iso_resources_destroy(&tscm->tx_resources);
371 int snd_tscm_stream_start_duplex(struct snd_tscm *tscm, unsigned int rate)
373 unsigned int curr_rate;
376 if (tscm->substreams_counter == 0)
379 err = snd_tscm_stream_get_rate(tscm, &curr_rate);
382 if (curr_rate != rate ||
383 amdtp_streaming_error(&tscm->rx_stream) ||
384 amdtp_streaming_error(&tscm->tx_stream)) {
385 finish_session(tscm);
387 amdtp_stream_stop(&tscm->rx_stream);
388 amdtp_stream_stop(&tscm->tx_stream);
390 release_resources(tscm);
393 if (!amdtp_stream_running(&tscm->rx_stream)) {
394 err = keep_resources(tscm, rate);
398 err = set_stream_formats(tscm, rate);
402 err = begin_session(tscm);
406 err = amdtp_stream_start(&tscm->rx_stream,
407 tscm->rx_resources.channel,
408 fw_parent_device(tscm->unit)->max_speed);
412 if (!amdtp_stream_wait_callback(&tscm->rx_stream,
419 if (!amdtp_stream_running(&tscm->tx_stream)) {
420 err = amdtp_stream_start(&tscm->tx_stream,
421 tscm->tx_resources.channel,
422 fw_parent_device(tscm->unit)->max_speed);
426 if (!amdtp_stream_wait_callback(&tscm->tx_stream,
435 amdtp_stream_stop(&tscm->rx_stream);
436 amdtp_stream_stop(&tscm->tx_stream);
438 finish_session(tscm);
439 release_resources(tscm);
444 void snd_tscm_stream_stop_duplex(struct snd_tscm *tscm)
446 if (tscm->substreams_counter > 0)
449 amdtp_stream_stop(&tscm->tx_stream);
450 amdtp_stream_stop(&tscm->rx_stream);
452 finish_session(tscm);
453 release_resources(tscm);
456 void snd_tscm_stream_lock_changed(struct snd_tscm *tscm)
458 tscm->dev_lock_changed = true;
459 wake_up(&tscm->hwdep_wait);
462 int snd_tscm_stream_lock_try(struct snd_tscm *tscm)
466 spin_lock_irq(&tscm->lock);
468 /* user land lock this */
469 if (tscm->dev_lock_count < 0) {
474 /* this is the first time */
475 if (tscm->dev_lock_count++ == 0)
476 snd_tscm_stream_lock_changed(tscm);
479 spin_unlock_irq(&tscm->lock);
483 void snd_tscm_stream_lock_release(struct snd_tscm *tscm)
485 spin_lock_irq(&tscm->lock);
487 if (WARN_ON(tscm->dev_lock_count <= 0))
489 if (--tscm->dev_lock_count == 0)
490 snd_tscm_stream_lock_changed(tscm);
492 spin_unlock_irq(&tscm->lock);