1 // SPDX-License-Identifier: GPL-2.0-only
3 * dice_stream.c - a part of driver for DICE based devices
5 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
6 * Copyright (c) 2014 Takashi Sakamoto <o-takashi@sakamocchi.jp>
11 #define CALLBACK_TIMEOUT 200
12 #define NOTIFICATION_TIMEOUT_MS (2 * MSEC_PER_SEC)
19 const unsigned int snd_dice_rates[SND_DICE_RATES_COUNT] = {
32 int snd_dice_stream_get_rate_mode(struct snd_dice *dice, unsigned int rate,
33 enum snd_dice_rate_mode *mode)
35 /* Corresponding to each entry in snd_dice_rates. */
36 static const enum snd_dice_rate_mode modes[] = {
37 [0] = SND_DICE_RATE_MODE_LOW,
38 [1] = SND_DICE_RATE_MODE_LOW,
39 [2] = SND_DICE_RATE_MODE_LOW,
40 [3] = SND_DICE_RATE_MODE_MIDDLE,
41 [4] = SND_DICE_RATE_MODE_MIDDLE,
42 [5] = SND_DICE_RATE_MODE_HIGH,
43 [6] = SND_DICE_RATE_MODE_HIGH,
47 for (i = 0; i < ARRAY_SIZE(snd_dice_rates); i++) {
48 if (!(dice->clock_caps & BIT(i)))
50 if (snd_dice_rates[i] != rate)
61 * This operation has an effect to synchronize GLOBAL_STATUS/GLOBAL_SAMPLE_RATE
62 * to GLOBAL_STATUS. Especially, just after powering on, these are different.
64 static int ensure_phase_lock(struct snd_dice *dice, unsigned int rate)
71 err = snd_dice_transaction_read_global(dice, GLOBAL_CLOCK_SELECT,
76 data = be32_to_cpu(reg);
78 data &= ~CLOCK_RATE_MASK;
79 for (i = 0; i < ARRAY_SIZE(snd_dice_rates); ++i) {
80 if (snd_dice_rates[i] == rate)
83 if (i == ARRAY_SIZE(snd_dice_rates))
85 data |= i << CLOCK_RATE_SHIFT;
87 if (completion_done(&dice->clock_accepted))
88 reinit_completion(&dice->clock_accepted);
90 reg = cpu_to_be32(data);
91 err = snd_dice_transaction_write_global(dice, GLOBAL_CLOCK_SELECT,
96 if (wait_for_completion_timeout(&dice->clock_accepted,
97 msecs_to_jiffies(NOTIFICATION_TIMEOUT_MS)) == 0) {
99 * Old versions of Dice firmware transfer no notification when
100 * the same clock status as current one is set. In this case,
101 * just check current clock status.
103 err = snd_dice_transaction_read_global(dice, GLOBAL_STATUS,
104 &nominal, sizeof(nominal));
107 if (!(be32_to_cpu(nominal) & STATUS_SOURCE_LOCKED))
114 static int get_register_params(struct snd_dice *dice,
115 struct reg_params *tx_params,
116 struct reg_params *rx_params)
121 err = snd_dice_transaction_read_tx(dice, TX_NUMBER, reg, sizeof(reg));
125 min_t(unsigned int, be32_to_cpu(reg[0]), MAX_STREAMS);
126 tx_params->size = be32_to_cpu(reg[1]) * 4;
128 err = snd_dice_transaction_read_rx(dice, RX_NUMBER, reg, sizeof(reg));
132 min_t(unsigned int, be32_to_cpu(reg[0]), MAX_STREAMS);
133 rx_params->size = be32_to_cpu(reg[1]) * 4;
138 static void release_resources(struct snd_dice *dice)
142 for (i = 0; i < MAX_STREAMS; ++i) {
143 fw_iso_resources_free(&dice->tx_resources[i]);
144 fw_iso_resources_free(&dice->rx_resources[i]);
148 static void stop_streams(struct snd_dice *dice, enum amdtp_stream_direction dir,
149 struct reg_params *params)
154 for (i = 0; i < params->count; i++) {
155 reg = cpu_to_be32((u32)-1);
156 if (dir == AMDTP_IN_STREAM) {
157 snd_dice_transaction_write_tx(dice,
158 params->size * i + TX_ISOCHRONOUS,
161 snd_dice_transaction_write_rx(dice,
162 params->size * i + RX_ISOCHRONOUS,
168 static int keep_resources(struct snd_dice *dice, struct amdtp_stream *stream,
169 struct fw_iso_resources *resources, unsigned int rate,
170 unsigned int pcm_chs, unsigned int midi_ports)
172 bool double_pcm_frames;
176 // At 176.4/192.0 kHz, Dice has a quirk to transfer two PCM frames in
177 // one data block of AMDTP packet. Thus sampling transfer frequency is
178 // a half of PCM sampling frequency, i.e. PCM frames at 192.0 kHz are
179 // transferred on AMDTP packets at 96 kHz. Two successive samples of a
180 // channel are stored consecutively in the packet. This quirk is called
182 // For this quirk, blocking mode is required and PCM buffer size should
183 // be aligned to SYT_INTERVAL.
184 double_pcm_frames = rate > 96000;
185 if (double_pcm_frames) {
190 err = amdtp_am824_set_parameters(stream, rate, pcm_chs, midi_ports,
195 if (double_pcm_frames) {
198 for (i = 0; i < pcm_chs; i++) {
199 amdtp_am824_set_pcm_position(stream, i, i * 2);
200 amdtp_am824_set_pcm_position(stream, i + pcm_chs,
205 return fw_iso_resources_allocate(resources,
206 amdtp_stream_get_max_payload(stream),
207 fw_parent_device(dice->unit)->max_speed);
210 static int keep_dual_resources(struct snd_dice *dice, unsigned int rate,
211 enum amdtp_stream_direction dir,
212 struct reg_params *params)
214 enum snd_dice_rate_mode mode;
218 err = snd_dice_stream_get_rate_mode(dice, rate, &mode);
222 for (i = 0; i < params->count; ++i) {
224 struct amdtp_stream *stream;
225 struct fw_iso_resources *resources;
226 unsigned int pcm_cache;
227 unsigned int midi_cache;
228 unsigned int pcm_chs;
229 unsigned int midi_ports;
231 if (dir == AMDTP_IN_STREAM) {
232 stream = &dice->tx_stream[i];
233 resources = &dice->tx_resources[i];
235 pcm_cache = dice->tx_pcm_chs[i][mode];
236 midi_cache = dice->tx_midi_ports[i];
237 err = snd_dice_transaction_read_tx(dice,
238 params->size * i + TX_NUMBER_AUDIO,
241 stream = &dice->rx_stream[i];
242 resources = &dice->rx_resources[i];
244 pcm_cache = dice->rx_pcm_chs[i][mode];
245 midi_cache = dice->rx_midi_ports[i];
246 err = snd_dice_transaction_read_rx(dice,
247 params->size * i + RX_NUMBER_AUDIO,
252 pcm_chs = be32_to_cpu(reg[0]);
253 midi_ports = be32_to_cpu(reg[1]);
255 // These are important for developer of this driver.
256 if (pcm_chs != pcm_cache || midi_ports != midi_cache) {
257 dev_info(&dice->unit->device,
258 "cache mismatch: pcm: %u:%u, midi: %u:%u\n",
259 pcm_chs, pcm_cache, midi_ports, midi_cache);
263 err = keep_resources(dice, stream, resources, rate, pcm_chs,
272 static void finish_session(struct snd_dice *dice, struct reg_params *tx_params,
273 struct reg_params *rx_params)
275 stop_streams(dice, AMDTP_IN_STREAM, tx_params);
276 stop_streams(dice, AMDTP_OUT_STREAM, rx_params);
278 snd_dice_transaction_clear_enable(dice);
281 int snd_dice_stream_reserve_duplex(struct snd_dice *dice, unsigned int rate,
282 unsigned int events_per_period,
283 unsigned int events_per_buffer)
285 unsigned int curr_rate;
288 // Check sampling transmission frequency.
289 err = snd_dice_transaction_get_rate(dice, &curr_rate);
295 if (dice->substreams_counter == 0 || curr_rate != rate) {
296 struct reg_params tx_params, rx_params;
298 amdtp_domain_stop(&dice->domain);
300 err = get_register_params(dice, &tx_params, &rx_params);
303 finish_session(dice, &tx_params, &rx_params);
305 release_resources(dice);
307 // Just after owning the unit (GLOBAL_OWNER), the unit can
308 // return invalid stream formats. Selecting clock parameters
309 // have an effect for the unit to refine it.
310 err = ensure_phase_lock(dice, rate);
314 // After changing sampling transfer frequency, the value of
315 // register can be changed.
316 err = get_register_params(dice, &tx_params, &rx_params);
320 err = keep_dual_resources(dice, rate, AMDTP_IN_STREAM,
325 err = keep_dual_resources(dice, rate, AMDTP_OUT_STREAM,
330 err = amdtp_domain_set_events_per_period(&dice->domain,
331 events_per_period, events_per_buffer);
338 release_resources(dice);
342 static int start_streams(struct snd_dice *dice, enum amdtp_stream_direction dir,
343 unsigned int rate, struct reg_params *params)
345 unsigned int max_speed = fw_parent_device(dice->unit)->max_speed;
349 for (i = 0; i < params->count; i++) {
350 struct amdtp_stream *stream;
351 struct fw_iso_resources *resources;
354 if (dir == AMDTP_IN_STREAM) {
355 stream = dice->tx_stream + i;
356 resources = dice->tx_resources + i;
358 stream = dice->rx_stream + i;
359 resources = dice->rx_resources + i;
362 reg = cpu_to_be32(resources->channel);
363 if (dir == AMDTP_IN_STREAM) {
364 err = snd_dice_transaction_write_tx(dice,
365 params->size * i + TX_ISOCHRONOUS,
368 err = snd_dice_transaction_write_rx(dice,
369 params->size * i + RX_ISOCHRONOUS,
375 if (dir == AMDTP_IN_STREAM) {
376 reg = cpu_to_be32(max_speed);
377 err = snd_dice_transaction_write_tx(dice,
378 params->size * i + TX_SPEED,
384 err = amdtp_domain_add_stream(&dice->domain, stream,
385 resources->channel, max_speed);
394 * MEMO: After this function, there're two states of streams:
395 * - None streams are running.
396 * - All streams are running.
398 int snd_dice_stream_start_duplex(struct snd_dice *dice)
400 unsigned int generation = dice->rx_resources[0].generation;
401 struct reg_params tx_params, rx_params;
404 enum snd_dice_rate_mode mode;
407 if (dice->substreams_counter == 0)
410 err = get_register_params(dice, &tx_params, &rx_params);
414 // Check error of packet streaming.
415 for (i = 0; i < MAX_STREAMS; ++i) {
416 if (amdtp_streaming_error(&dice->tx_stream[i]) ||
417 amdtp_streaming_error(&dice->rx_stream[i])) {
418 amdtp_domain_stop(&dice->domain);
419 finish_session(dice, &tx_params, &rx_params);
424 if (generation != fw_parent_device(dice->unit)->card->generation) {
425 for (i = 0; i < MAX_STREAMS; ++i) {
426 if (i < tx_params.count)
427 fw_iso_resources_update(dice->tx_resources + i);
428 if (i < rx_params.count)
429 fw_iso_resources_update(dice->rx_resources + i);
433 // Check required streams are running or not.
434 err = snd_dice_transaction_get_rate(dice, &rate);
437 err = snd_dice_stream_get_rate_mode(dice, rate, &mode);
440 for (i = 0; i < MAX_STREAMS; ++i) {
441 if (dice->tx_pcm_chs[i][mode] > 0 &&
442 !amdtp_stream_running(&dice->tx_stream[i]))
444 if (dice->rx_pcm_chs[i][mode] > 0 &&
445 !amdtp_stream_running(&dice->rx_stream[i]))
448 if (i < MAX_STREAMS) {
449 // Start both streams.
450 err = start_streams(dice, AMDTP_IN_STREAM, rate, &tx_params);
454 err = start_streams(dice, AMDTP_OUT_STREAM, rate, &rx_params);
458 err = snd_dice_transaction_set_enable(dice);
460 dev_err(&dice->unit->device,
461 "fail to enable interface\n");
465 err = amdtp_domain_start(&dice->domain, 0);
469 for (i = 0; i < MAX_STREAMS; i++) {
470 if ((i < tx_params.count &&
471 !amdtp_stream_wait_callback(&dice->tx_stream[i],
472 CALLBACK_TIMEOUT)) ||
473 (i < rx_params.count &&
474 !amdtp_stream_wait_callback(&dice->rx_stream[i],
475 CALLBACK_TIMEOUT))) {
484 amdtp_domain_stop(&dice->domain);
485 finish_session(dice, &tx_params, &rx_params);
490 * MEMO: After this function, there're two states of streams:
491 * - None streams are running.
492 * - All streams are running.
494 void snd_dice_stream_stop_duplex(struct snd_dice *dice)
496 struct reg_params tx_params, rx_params;
498 if (dice->substreams_counter == 0) {
499 if (get_register_params(dice, &tx_params, &rx_params) >= 0) {
500 amdtp_domain_stop(&dice->domain);
501 finish_session(dice, &tx_params, &rx_params);
504 release_resources(dice);
508 static int init_stream(struct snd_dice *dice, enum amdtp_stream_direction dir,
511 struct amdtp_stream *stream;
512 struct fw_iso_resources *resources;
515 if (dir == AMDTP_IN_STREAM) {
516 stream = &dice->tx_stream[index];
517 resources = &dice->tx_resources[index];
519 stream = &dice->rx_stream[index];
520 resources = &dice->rx_resources[index];
523 err = fw_iso_resources_init(resources, dice->unit);
526 resources->channels_mask = 0x00000000ffffffffuLL;
528 err = amdtp_am824_init(stream, dice->unit, dir, CIP_BLOCKING);
530 amdtp_stream_destroy(stream);
531 fw_iso_resources_destroy(resources);
538 * This function should be called before starting streams or after stopping
541 static void destroy_stream(struct snd_dice *dice,
542 enum amdtp_stream_direction dir,
545 struct amdtp_stream *stream;
546 struct fw_iso_resources *resources;
548 if (dir == AMDTP_IN_STREAM) {
549 stream = &dice->tx_stream[index];
550 resources = &dice->tx_resources[index];
552 stream = &dice->rx_stream[index];
553 resources = &dice->rx_resources[index];
556 amdtp_stream_destroy(stream);
557 fw_iso_resources_destroy(resources);
560 int snd_dice_stream_init_duplex(struct snd_dice *dice)
564 for (i = 0; i < MAX_STREAMS; i++) {
565 err = init_stream(dice, AMDTP_IN_STREAM, i);
568 destroy_stream(dice, AMDTP_IN_STREAM, i);
573 for (i = 0; i < MAX_STREAMS; i++) {
574 err = init_stream(dice, AMDTP_OUT_STREAM, i);
577 destroy_stream(dice, AMDTP_OUT_STREAM, i);
578 for (i = 0; i < MAX_STREAMS; i++)
579 destroy_stream(dice, AMDTP_IN_STREAM, i);
584 err = amdtp_domain_init(&dice->domain);
586 for (i = 0; i < MAX_STREAMS; ++i) {
587 destroy_stream(dice, AMDTP_OUT_STREAM, i);
588 destroy_stream(dice, AMDTP_IN_STREAM, i);
595 void snd_dice_stream_destroy_duplex(struct snd_dice *dice)
599 for (i = 0; i < MAX_STREAMS; i++) {
600 destroy_stream(dice, AMDTP_IN_STREAM, i);
601 destroy_stream(dice, AMDTP_OUT_STREAM, i);
604 amdtp_domain_destroy(&dice->domain);
607 void snd_dice_stream_update_duplex(struct snd_dice *dice)
609 struct reg_params tx_params, rx_params;
612 * On a bus reset, the DICE firmware disables streaming and then goes
613 * off contemplating its own navel for hundreds of milliseconds before
614 * it can react to any of our attempts to reenable streaming. This
615 * means that we lose synchronization anyway, so we force our streams
616 * to stop so that the application can restart them in an orderly
619 dice->global_enabled = false;
621 if (get_register_params(dice, &tx_params, &rx_params) == 0) {
622 amdtp_domain_stop(&dice->domain);
624 stop_streams(dice, AMDTP_IN_STREAM, &tx_params);
625 stop_streams(dice, AMDTP_OUT_STREAM, &rx_params);
629 int snd_dice_stream_detect_current_formats(struct snd_dice *dice)
632 enum snd_dice_rate_mode mode;
634 struct reg_params tx_params, rx_params;
638 /* If extended protocol is available, detect detail spec. */
639 err = snd_dice_detect_extension_formats(dice);
644 * Available stream format is restricted at current mode of sampling
647 err = snd_dice_transaction_get_rate(dice, &rate);
651 err = snd_dice_stream_get_rate_mode(dice, rate, &mode);
656 * Just after owning the unit (GLOBAL_OWNER), the unit can return
657 * invalid stream formats. Selecting clock parameters have an effect
658 * for the unit to refine it.
660 err = ensure_phase_lock(dice, rate);
664 err = get_register_params(dice, &tx_params, &rx_params);
668 for (i = 0; i < tx_params.count; ++i) {
669 err = snd_dice_transaction_read_tx(dice,
670 tx_params.size * i + TX_NUMBER_AUDIO,
674 dice->tx_pcm_chs[i][mode] = be32_to_cpu(reg[0]);
675 dice->tx_midi_ports[i] = max_t(unsigned int,
676 be32_to_cpu(reg[1]), dice->tx_midi_ports[i]);
678 for (i = 0; i < rx_params.count; ++i) {
679 err = snd_dice_transaction_read_rx(dice,
680 rx_params.size * i + RX_NUMBER_AUDIO,
684 dice->rx_pcm_chs[i][mode] = be32_to_cpu(reg[0]);
685 dice->rx_midi_ports[i] = max_t(unsigned int,
686 be32_to_cpu(reg[1]), dice->rx_midi_ports[i]);
692 static void dice_lock_changed(struct snd_dice *dice)
694 dice->dev_lock_changed = true;
695 wake_up(&dice->hwdep_wait);
698 int snd_dice_stream_lock_try(struct snd_dice *dice)
702 spin_lock_irq(&dice->lock);
704 if (dice->dev_lock_count < 0) {
709 if (dice->dev_lock_count++ == 0)
710 dice_lock_changed(dice);
713 spin_unlock_irq(&dice->lock);
717 void snd_dice_stream_lock_release(struct snd_dice *dice)
719 spin_lock_irq(&dice->lock);
721 if (WARN_ON(dice->dev_lock_count <= 0))
724 if (--dice->dev_lock_count == 0)
725 dice_lock_changed(dice);
727 spin_unlock_irq(&dice->lock);