2 * Audio and Music Data Transmission Protocol (IEC 61883-6) streams
3 * with Common Isochronous Packet (IEC 61883-1) headers
5 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
6 * Licensed under the terms of the GNU General Public License, version 2.
9 #include <linux/device.h>
10 #include <linux/err.h>
11 #include <linux/firewire.h>
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/sched.h>
15 #include <sound/pcm.h>
16 #include <sound/rawmidi.h>
19 #define TICKS_PER_CYCLE 3072
20 #define CYCLES_PER_SECOND 8000
21 #define TICKS_PER_SECOND (TICKS_PER_CYCLE * CYCLES_PER_SECOND)
23 #define TRANSFER_DELAY_TICKS 0x2e00 /* 479.17 µs */
25 /* isochronous header parameters */
26 #define ISO_DATA_LENGTH_SHIFT 16
29 /* common isochronous packet header parameters */
30 #define CIP_EOH (1u << 31)
31 #define CIP_EOH_MASK 0x80000000
32 #define CIP_FMT_AM (0x10 << 24)
33 #define CIP_FMT_MASK 0x3f000000
34 #define CIP_SYT_MASK 0x0000ffff
35 #define CIP_SYT_NO_INFO 0xffff
36 #define CIP_FDF_MASK 0x00ff0000
37 #define CIP_FDF_SFC_SHIFT 16
40 * Audio and Music transfer protocol specific parameters
41 * only "Clock-based rate control mode" is supported
43 #define AMDTP_FDF_AM824 (0 << (CIP_FDF_SFC_SHIFT + 3))
44 #define AMDTP_FDF_NO_DATA 0xff
45 #define AMDTP_DBS_MASK 0x00ff0000
46 #define AMDTP_DBS_SHIFT 16
47 #define AMDTP_DBC_MASK 0x000000ff
49 /* TODO: make these configurable */
50 #define INTERRUPT_INTERVAL 16
51 #define QUEUE_LENGTH 48
53 #define IN_PACKET_HEADER_SIZE 4
54 #define OUT_PACKET_HEADER_SIZE 0
56 static void pcm_period_tasklet(unsigned long data
);
59 * amdtp_stream_init - initialize an AMDTP stream structure
60 * @s: the AMDTP stream to initialize
61 * @unit: the target of the stream
62 * @dir: the direction of stream
63 * @flags: the packet transmission method to use
65 int amdtp_stream_init(struct amdtp_stream
*s
, struct fw_unit
*unit
,
66 enum amdtp_stream_direction dir
, enum cip_flags flags
)
68 s
->unit
= fw_unit_get(unit
);
71 s
->context
= ERR_PTR(-1);
72 mutex_init(&s
->mutex
);
73 tasklet_init(&s
->period_tasklet
, pcm_period_tasklet
, (unsigned long)s
);
76 init_waitqueue_head(&s
->callback_wait
);
77 s
->callbacked
= false;
82 EXPORT_SYMBOL(amdtp_stream_init
);
85 * amdtp_stream_destroy - free stream resources
86 * @s: the AMDTP stream to destroy
88 void amdtp_stream_destroy(struct amdtp_stream
*s
)
90 WARN_ON(amdtp_stream_running(s
));
91 mutex_destroy(&s
->mutex
);
94 EXPORT_SYMBOL(amdtp_stream_destroy
);
96 const unsigned int amdtp_syt_intervals
[CIP_SFC_COUNT
] = {
100 [CIP_SFC_88200
] = 16,
101 [CIP_SFC_96000
] = 16,
102 [CIP_SFC_176400
] = 32,
103 [CIP_SFC_192000
] = 32,
105 EXPORT_SYMBOL(amdtp_syt_intervals
);
108 * amdtp_stream_set_parameters - set stream parameters
109 * @s: the AMDTP stream to configure
110 * @rate: the sample rate
111 * @pcm_channels: the number of PCM samples in each data block, to be encoded
112 * as AM824 multi-bit linear audio
113 * @midi_ports: the number of MIDI ports (i.e., MPX-MIDI Data Channels)
115 * The parameters must be set before the stream is started, and must not be
116 * changed while the stream is running.
118 void amdtp_stream_set_parameters(struct amdtp_stream
*s
,
120 unsigned int pcm_channels
,
121 unsigned int midi_ports
)
123 static const unsigned int rates
[] = {
124 [CIP_SFC_32000
] = 32000,
125 [CIP_SFC_44100
] = 44100,
126 [CIP_SFC_48000
] = 48000,
127 [CIP_SFC_88200
] = 88200,
128 [CIP_SFC_96000
] = 96000,
129 [CIP_SFC_176400
] = 176400,
130 [CIP_SFC_192000
] = 192000,
132 unsigned int i
, sfc
, midi_channels
;
134 midi_channels
= DIV_ROUND_UP(midi_ports
, 8);
136 if (WARN_ON(amdtp_stream_running(s
)) |
137 WARN_ON(pcm_channels
> AMDTP_MAX_CHANNELS_FOR_PCM
) |
138 WARN_ON(midi_channels
> AMDTP_MAX_CHANNELS_FOR_MIDI
))
141 for (sfc
= 0; sfc
< CIP_SFC_COUNT
; ++sfc
)
142 if (rates
[sfc
] == rate
)
148 s
->pcm_channels
= pcm_channels
;
150 s
->data_block_quadlets
= s
->pcm_channels
+ midi_channels
;
151 s
->midi_ports
= midi_ports
;
153 s
->syt_interval
= amdtp_syt_intervals
[sfc
];
155 /* default buffering in the device */
156 s
->transfer_delay
= TRANSFER_DELAY_TICKS
- TICKS_PER_CYCLE
;
157 if (s
->flags
& CIP_BLOCKING
)
158 /* additional buffering needed to adjust for no-data packets */
159 s
->transfer_delay
+= TICKS_PER_SECOND
* s
->syt_interval
/ rate
;
161 /* init the position map for PCM and MIDI channels */
162 for (i
= 0; i
< pcm_channels
; i
++)
163 s
->pcm_positions
[i
] = i
;
164 s
->midi_position
= s
->pcm_channels
;
166 EXPORT_SYMBOL(amdtp_stream_set_parameters
);
169 * amdtp_stream_get_max_payload - get the stream's packet size
170 * @s: the AMDTP stream
172 * This function must not be called before the stream has been configured
173 * with amdtp_stream_set_parameters().
175 unsigned int amdtp_stream_get_max_payload(struct amdtp_stream
*s
)
177 return 8 + s
->syt_interval
* s
->data_block_quadlets
* 4;
179 EXPORT_SYMBOL(amdtp_stream_get_max_payload
);
181 static void amdtp_write_s16(struct amdtp_stream
*s
,
182 struct snd_pcm_substream
*pcm
,
183 __be32
*buffer
, unsigned int frames
);
184 static void amdtp_write_s32(struct amdtp_stream
*s
,
185 struct snd_pcm_substream
*pcm
,
186 __be32
*buffer
, unsigned int frames
);
187 static void amdtp_read_s32(struct amdtp_stream
*s
,
188 struct snd_pcm_substream
*pcm
,
189 __be32
*buffer
, unsigned int frames
);
192 * amdtp_stream_set_pcm_format - set the PCM format
193 * @s: the AMDTP stream to configure
194 * @format: the format of the ALSA PCM device
196 * The sample format must be set after the other paramters (rate/PCM channels/
197 * MIDI) and before the stream is started, and must not be changed while the
200 void amdtp_stream_set_pcm_format(struct amdtp_stream
*s
,
201 snd_pcm_format_t format
)
203 if (WARN_ON(amdtp_stream_pcm_running(s
)))
210 case SNDRV_PCM_FORMAT_S16
:
211 if (s
->direction
== AMDTP_OUT_STREAM
) {
212 s
->transfer_samples
= amdtp_write_s16
;
217 case SNDRV_PCM_FORMAT_S32
:
218 if (s
->direction
== AMDTP_OUT_STREAM
)
219 s
->transfer_samples
= amdtp_write_s32
;
221 s
->transfer_samples
= amdtp_read_s32
;
225 EXPORT_SYMBOL(amdtp_stream_set_pcm_format
);
228 * amdtp_stream_pcm_prepare - prepare PCM device for running
229 * @s: the AMDTP stream
231 * This function should be called from the PCM device's .prepare callback.
233 void amdtp_stream_pcm_prepare(struct amdtp_stream
*s
)
235 tasklet_kill(&s
->period_tasklet
);
236 s
->pcm_buffer_pointer
= 0;
237 s
->pcm_period_pointer
= 0;
238 s
->pointer_flush
= true;
240 EXPORT_SYMBOL(amdtp_stream_pcm_prepare
);
242 static unsigned int calculate_data_blocks(struct amdtp_stream
*s
)
244 unsigned int phase
, data_blocks
;
246 if (s
->flags
& CIP_BLOCKING
)
247 data_blocks
= s
->syt_interval
;
248 else if (!cip_sfc_is_base_44100(s
->sfc
)) {
249 /* Sample_rate / 8000 is an integer, and precomputed. */
250 data_blocks
= s
->data_block_state
;
252 phase
= s
->data_block_state
;
255 * This calculates the number of data blocks per packet so that
256 * 1) the overall rate is correct and exactly synchronized to
258 * 2) packets with a rounded-up number of blocks occur as early
259 * as possible in the sequence (to prevent underruns of the
262 if (s
->sfc
== CIP_SFC_44100
)
263 /* 6 6 5 6 5 6 5 ... */
264 data_blocks
= 5 + ((phase
& 1) ^
265 (phase
== 0 || phase
>= 40));
267 /* 12 11 11 11 11 ... or 23 22 22 22 22 ... */
268 data_blocks
= 11 * (s
->sfc
>> 1) + (phase
== 0);
269 if (++phase
>= (80 >> (s
->sfc
>> 1)))
271 s
->data_block_state
= phase
;
277 static unsigned int calculate_syt(struct amdtp_stream
*s
,
280 unsigned int syt_offset
, phase
, index
, syt
;
282 if (s
->last_syt_offset
< TICKS_PER_CYCLE
) {
283 if (!cip_sfc_is_base_44100(s
->sfc
))
284 syt_offset
= s
->last_syt_offset
+ s
->syt_offset_state
;
287 * The time, in ticks, of the n'th SYT_INTERVAL sample is:
288 * n * SYT_INTERVAL * 24576000 / sample_rate
289 * Modulo TICKS_PER_CYCLE, the difference between successive
290 * elements is about 1386.23. Rounding the results of this
291 * formula to the SYT precision results in a sequence of
292 * differences that begins with:
293 * 1386 1386 1387 1386 1386 1386 1387 1386 1386 1386 1387 ...
294 * This code generates _exactly_ the same sequence.
296 phase
= s
->syt_offset_state
;
298 syt_offset
= s
->last_syt_offset
;
299 syt_offset
+= 1386 + ((index
&& !(index
& 3)) ||
303 s
->syt_offset_state
= phase
;
306 syt_offset
= s
->last_syt_offset
- TICKS_PER_CYCLE
;
307 s
->last_syt_offset
= syt_offset
;
309 if (syt_offset
< TICKS_PER_CYCLE
) {
310 syt_offset
+= s
->transfer_delay
;
311 syt
= (cycle
+ syt_offset
/ TICKS_PER_CYCLE
) << 12;
312 syt
+= syt_offset
% TICKS_PER_CYCLE
;
314 return syt
& CIP_SYT_MASK
;
316 return CIP_SYT_NO_INFO
;
320 static void amdtp_write_s32(struct amdtp_stream
*s
,
321 struct snd_pcm_substream
*pcm
,
322 __be32
*buffer
, unsigned int frames
)
324 struct snd_pcm_runtime
*runtime
= pcm
->runtime
;
325 unsigned int channels
, remaining_frames
, i
, c
;
328 channels
= s
->pcm_channels
;
329 src
= (void *)runtime
->dma_area
+
330 frames_to_bytes(runtime
, s
->pcm_buffer_pointer
);
331 remaining_frames
= runtime
->buffer_size
- s
->pcm_buffer_pointer
;
333 for (i
= 0; i
< frames
; ++i
) {
334 for (c
= 0; c
< channels
; ++c
) {
335 buffer
[s
->pcm_positions
[c
]] =
336 cpu_to_be32((*src
>> 8) | 0x40000000);
339 buffer
+= s
->data_block_quadlets
;
340 if (--remaining_frames
== 0)
341 src
= (void *)runtime
->dma_area
;
345 static void amdtp_write_s16(struct amdtp_stream
*s
,
346 struct snd_pcm_substream
*pcm
,
347 __be32
*buffer
, unsigned int frames
)
349 struct snd_pcm_runtime
*runtime
= pcm
->runtime
;
350 unsigned int channels
, remaining_frames
, i
, c
;
353 channels
= s
->pcm_channels
;
354 src
= (void *)runtime
->dma_area
+
355 frames_to_bytes(runtime
, s
->pcm_buffer_pointer
);
356 remaining_frames
= runtime
->buffer_size
- s
->pcm_buffer_pointer
;
358 for (i
= 0; i
< frames
; ++i
) {
359 for (c
= 0; c
< channels
; ++c
) {
360 buffer
[s
->pcm_positions
[c
]] =
361 cpu_to_be32((*src
<< 8) | 0x40000000);
364 buffer
+= s
->data_block_quadlets
;
365 if (--remaining_frames
== 0)
366 src
= (void *)runtime
->dma_area
;
370 static void amdtp_read_s32(struct amdtp_stream
*s
,
371 struct snd_pcm_substream
*pcm
,
372 __be32
*buffer
, unsigned int frames
)
374 struct snd_pcm_runtime
*runtime
= pcm
->runtime
;
375 unsigned int channels
, remaining_frames
, i
, c
;
378 channels
= s
->pcm_channels
;
379 dst
= (void *)runtime
->dma_area
+
380 frames_to_bytes(runtime
, s
->pcm_buffer_pointer
);
381 remaining_frames
= runtime
->buffer_size
- s
->pcm_buffer_pointer
;
383 for (i
= 0; i
< frames
; ++i
) {
384 for (c
= 0; c
< channels
; ++c
) {
385 *dst
= be32_to_cpu(buffer
[s
->pcm_positions
[c
]]) << 8;
388 buffer
+= s
->data_block_quadlets
;
389 if (--remaining_frames
== 0)
390 dst
= (void *)runtime
->dma_area
;
394 static void amdtp_fill_pcm_silence(struct amdtp_stream
*s
,
395 __be32
*buffer
, unsigned int frames
)
399 for (i
= 0; i
< frames
; ++i
) {
400 for (c
= 0; c
< s
->pcm_channels
; ++c
)
401 buffer
[s
->pcm_positions
[c
]] = cpu_to_be32(0x40000000);
402 buffer
+= s
->data_block_quadlets
;
406 static void amdtp_fill_midi(struct amdtp_stream
*s
,
407 __be32
*buffer
, unsigned int frames
)
409 unsigned int f
, port
;
412 for (f
= 0; f
< frames
; f
++) {
413 buffer
[s
->midi_position
] = 0;
414 b
= (u8
*)&buffer
[s
->midi_position
];
416 port
= (s
->data_block_counter
+ f
) % 8;
417 if ((s
->midi
[port
] == NULL
) ||
418 (snd_rawmidi_transmit(s
->midi
[port
], b
+ 1, 1) <= 0))
423 buffer
+= s
->data_block_quadlets
;
427 static void amdtp_pull_midi(struct amdtp_stream
*s
,
428 __be32
*buffer
, unsigned int frames
)
430 unsigned int f
, port
;
434 for (f
= 0; f
< frames
; f
++) {
435 port
= (s
->data_block_counter
+ f
) % 8;
436 b
= (u8
*)&buffer
[s
->midi_position
];
439 if ((1 <= len
) && (len
<= 3) && (s
->midi
[port
]))
440 snd_rawmidi_receive(s
->midi
[port
], b
+ 1, len
);
442 buffer
+= s
->data_block_quadlets
;
446 static void update_pcm_pointers(struct amdtp_stream
*s
,
447 struct snd_pcm_substream
*pcm
,
451 ptr
= s
->pcm_buffer_pointer
+ frames
;
452 if (ptr
>= pcm
->runtime
->buffer_size
)
453 ptr
-= pcm
->runtime
->buffer_size
;
454 ACCESS_ONCE(s
->pcm_buffer_pointer
) = ptr
;
456 s
->pcm_period_pointer
+= frames
;
457 if (s
->pcm_period_pointer
>= pcm
->runtime
->period_size
) {
458 s
->pcm_period_pointer
-= pcm
->runtime
->period_size
;
459 s
->pointer_flush
= false;
460 tasklet_hi_schedule(&s
->period_tasklet
);
464 static void pcm_period_tasklet(unsigned long data
)
466 struct amdtp_stream
*s
= (void *)data
;
467 struct snd_pcm_substream
*pcm
= ACCESS_ONCE(s
->pcm
);
470 snd_pcm_period_elapsed(pcm
);
473 static int queue_packet(struct amdtp_stream
*s
,
474 unsigned int header_length
,
475 unsigned int payload_length
, bool skip
)
477 struct fw_iso_packet p
= {0};
480 if (IS_ERR(s
->context
))
483 p
.interrupt
= IS_ALIGNED(s
->packet_index
+ 1, INTERRUPT_INTERVAL
);
485 p
.header_length
= header_length
;
486 p
.payload_length
= (!skip
) ? payload_length
: 0;
488 err
= fw_iso_context_queue(s
->context
, &p
, &s
->buffer
.iso_buffer
,
489 s
->buffer
.packets
[s
->packet_index
].offset
);
491 dev_err(&s
->unit
->device
, "queueing error: %d\n", err
);
495 if (++s
->packet_index
>= QUEUE_LENGTH
)
501 static inline int queue_out_packet(struct amdtp_stream
*s
,
502 unsigned int payload_length
, bool skip
)
504 return queue_packet(s
, OUT_PACKET_HEADER_SIZE
,
505 payload_length
, skip
);
508 static inline int queue_in_packet(struct amdtp_stream
*s
)
510 return queue_packet(s
, IN_PACKET_HEADER_SIZE
,
511 amdtp_stream_get_max_payload(s
), false);
514 static void handle_out_packet(struct amdtp_stream
*s
, unsigned int syt
)
517 unsigned int data_blocks
, payload_length
;
518 struct snd_pcm_substream
*pcm
;
520 if (s
->packet_index
< 0)
523 /* this module generate empty packet for 'no data' */
524 if (!(s
->flags
& CIP_BLOCKING
) || (syt
!= CIP_SYT_NO_INFO
))
525 data_blocks
= calculate_data_blocks(s
);
529 buffer
= s
->buffer
.packets
[s
->packet_index
].buffer
;
530 buffer
[0] = cpu_to_be32(ACCESS_ONCE(s
->source_node_id_field
) |
531 (s
->data_block_quadlets
<< AMDTP_DBS_SHIFT
) |
532 s
->data_block_counter
);
533 buffer
[1] = cpu_to_be32(CIP_EOH
| CIP_FMT_AM
| AMDTP_FDF_AM824
|
534 (s
->sfc
<< CIP_FDF_SFC_SHIFT
) | syt
);
537 pcm
= ACCESS_ONCE(s
->pcm
);
539 s
->transfer_samples(s
, pcm
, buffer
, data_blocks
);
541 amdtp_fill_pcm_silence(s
, buffer
, data_blocks
);
543 amdtp_fill_midi(s
, buffer
, data_blocks
);
545 s
->data_block_counter
= (s
->data_block_counter
+ data_blocks
) & 0xff;
547 payload_length
= 8 + data_blocks
* 4 * s
->data_block_quadlets
;
548 if (queue_out_packet(s
, payload_length
, false) < 0) {
549 s
->packet_index
= -1;
550 amdtp_stream_pcm_abort(s
);
555 update_pcm_pointers(s
, pcm
, data_blocks
);
558 static void handle_in_packet(struct amdtp_stream
*s
,
559 unsigned int payload_quadlets
,
563 unsigned int data_blocks
, data_block_quadlets
, data_block_counter
;
564 struct snd_pcm_substream
*pcm
= NULL
;
566 cip_header
[0] = be32_to_cpu(buffer
[0]);
567 cip_header
[1] = be32_to_cpu(buffer
[1]);
570 * This module supports 'Two-quadlet CIP header with SYT field'.
571 * For convenience, also check FMT field is AM824 or not.
573 if (((cip_header
[0] & CIP_EOH_MASK
) == CIP_EOH
) ||
574 ((cip_header
[1] & CIP_EOH_MASK
) != CIP_EOH
) ||
575 ((cip_header
[1] & CIP_FMT_MASK
) != CIP_FMT_AM
)) {
576 dev_info_ratelimited(&s
->unit
->device
,
577 "Invalid CIP header for AMDTP: %08X:%08X\n",
578 cip_header
[0], cip_header
[1]);
582 /* Calculate data blocks */
583 if (payload_quadlets
< 3 ||
584 ((cip_header
[1] & CIP_FDF_MASK
) ==
585 (AMDTP_FDF_NO_DATA
<< CIP_FDF_SFC_SHIFT
))) {
588 data_block_quadlets
=
589 (cip_header
[0] & AMDTP_DBS_MASK
) >> AMDTP_DBS_SHIFT
;
590 /* avoid division by zero */
591 if (data_block_quadlets
== 0) {
592 dev_info_ratelimited(&s
->unit
->device
,
593 "Detect invalid value in dbs field: %08X\n",
598 data_blocks
= (payload_quadlets
- 2) / data_block_quadlets
;
601 /* Check data block counter continuity */
602 data_block_counter
= cip_header
[0] & AMDTP_DBC_MASK
;
603 if (data_block_counter
!= s
->data_block_counter
) {
604 dev_info(&s
->unit
->device
,
605 "Detect discontinuity of CIP: %02X %02X\n",
606 s
->data_block_counter
, data_block_counter
);
610 if (data_blocks
> 0) {
613 pcm
= ACCESS_ONCE(s
->pcm
);
615 s
->transfer_samples(s
, pcm
, buffer
, data_blocks
);
618 amdtp_pull_midi(s
, buffer
, data_blocks
);
621 s
->data_block_counter
= (data_block_counter
+ data_blocks
) & 0xff;
623 if (queue_in_packet(s
) < 0)
627 update_pcm_pointers(s
, pcm
, data_blocks
);
631 s
->packet_index
= -1;
632 amdtp_stream_pcm_abort(s
);
635 static void out_stream_callback(struct fw_iso_context
*context
, u32 cycle
,
636 size_t header_length
, void *header
,
639 struct amdtp_stream
*s
= private_data
;
640 unsigned int i
, syt
, packets
= header_length
/ 4;
643 * Compute the cycle of the last queued packet.
644 * (We need only the four lowest bits for the SYT, so we can ignore
645 * that bits 0-11 must wrap around at 3072.)
647 cycle
+= QUEUE_LENGTH
- packets
;
649 for (i
= 0; i
< packets
; ++i
) {
650 syt
= calculate_syt(s
, ++cycle
);
651 handle_out_packet(s
, syt
);
653 fw_iso_context_queue_flush(s
->context
);
656 static void in_stream_callback(struct fw_iso_context
*context
, u32 cycle
,
657 size_t header_length
, void *header
,
660 struct amdtp_stream
*s
= private_data
;
661 unsigned int p
, syt
, packets
, payload_quadlets
;
662 __be32
*buffer
, *headers
= header
;
664 /* The number of packets in buffer */
665 packets
= header_length
/ IN_PACKET_HEADER_SIZE
;
667 for (p
= 0; p
< packets
; p
++) {
668 if (s
->packet_index
< 0)
671 buffer
= s
->buffer
.packets
[s
->packet_index
].buffer
;
673 /* Process sync slave stream */
674 if (s
->sync_slave
&& s
->sync_slave
->callbacked
) {
675 syt
= be32_to_cpu(buffer
[1]) & CIP_SYT_MASK
;
676 handle_out_packet(s
->sync_slave
, syt
);
679 /* The number of quadlets in this packet */
681 (be32_to_cpu(headers
[p
]) >> ISO_DATA_LENGTH_SHIFT
) / 4;
682 handle_in_packet(s
, payload_quadlets
, buffer
);
685 /* Queueing error or detecting discontinuity */
686 if (s
->packet_index
< 0) {
687 /* Abort sync slave. */
689 s
->sync_slave
->packet_index
= -1;
690 amdtp_stream_pcm_abort(s
->sync_slave
);
695 /* when sync to device, flush the packets for slave stream */
696 if (s
->sync_slave
&& s
->sync_slave
->callbacked
)
697 fw_iso_context_queue_flush(s
->sync_slave
->context
);
699 fw_iso_context_queue_flush(s
->context
);
702 /* processing is done by master callback */
703 static void slave_stream_callback(struct fw_iso_context
*context
, u32 cycle
,
704 size_t header_length
, void *header
,
710 /* this is executed one time */
711 static void amdtp_stream_first_callback(struct fw_iso_context
*context
,
712 u32 cycle
, size_t header_length
,
713 void *header
, void *private_data
)
715 struct amdtp_stream
*s
= private_data
;
718 * For in-stream, first packet has come.
719 * For out-stream, prepared to transmit first packet
721 s
->callbacked
= true;
722 wake_up(&s
->callback_wait
);
724 if (s
->direction
== AMDTP_IN_STREAM
)
725 context
->callback
.sc
= in_stream_callback
;
726 else if ((s
->flags
& CIP_BLOCKING
) && (s
->flags
& CIP_SYNC_TO_DEVICE
))
727 context
->callback
.sc
= slave_stream_callback
;
729 context
->callback
.sc
= out_stream_callback
;
731 context
->callback
.sc(context
, cycle
, header_length
, header
, s
);
735 * amdtp_stream_start - start transferring packets
736 * @s: the AMDTP stream to start
737 * @channel: the isochronous channel on the bus
738 * @speed: firewire speed code
740 * The stream cannot be started until it has been configured with
741 * amdtp_stream_set_parameters() and it must be started before any PCM or MIDI
742 * device can be started.
744 int amdtp_stream_start(struct amdtp_stream
*s
, int channel
, int speed
)
746 static const struct {
747 unsigned int data_block
;
748 unsigned int syt_offset
;
749 } initial_state
[] = {
750 [CIP_SFC_32000
] = { 4, 3072 },
751 [CIP_SFC_48000
] = { 6, 1024 },
752 [CIP_SFC_96000
] = { 12, 1024 },
753 [CIP_SFC_192000
] = { 24, 1024 },
754 [CIP_SFC_44100
] = { 0, 67 },
755 [CIP_SFC_88200
] = { 0, 67 },
756 [CIP_SFC_176400
] = { 0, 67 },
758 unsigned int header_size
;
759 enum dma_data_direction dir
;
762 mutex_lock(&s
->mutex
);
764 if (WARN_ON(amdtp_stream_running(s
) ||
765 (s
->data_block_quadlets
< 1))) {
770 s
->data_block_counter
= 0;
771 s
->data_block_state
= initial_state
[s
->sfc
].data_block
;
772 s
->syt_offset_state
= initial_state
[s
->sfc
].syt_offset
;
773 s
->last_syt_offset
= TICKS_PER_CYCLE
;
775 /* initialize packet buffer */
776 if (s
->direction
== AMDTP_IN_STREAM
) {
777 dir
= DMA_FROM_DEVICE
;
778 type
= FW_ISO_CONTEXT_RECEIVE
;
779 header_size
= IN_PACKET_HEADER_SIZE
;
782 type
= FW_ISO_CONTEXT_TRANSMIT
;
783 header_size
= OUT_PACKET_HEADER_SIZE
;
785 err
= iso_packets_buffer_init(&s
->buffer
, s
->unit
, QUEUE_LENGTH
,
786 amdtp_stream_get_max_payload(s
), dir
);
790 s
->context
= fw_iso_context_create(fw_parent_device(s
->unit
)->card
,
791 type
, channel
, speed
, header_size
,
792 amdtp_stream_first_callback
, s
);
793 if (IS_ERR(s
->context
)) {
794 err
= PTR_ERR(s
->context
);
796 dev_err(&s
->unit
->device
,
797 "no free stream on this controller\n");
801 amdtp_stream_update(s
);
805 if (s
->direction
== AMDTP_IN_STREAM
)
806 err
= queue_in_packet(s
);
808 err
= queue_out_packet(s
, 0, true);
811 } while (s
->packet_index
> 0);
813 /* NOTE: TAG1 matches CIP. This just affects in stream. */
814 s
->callbacked
= false;
815 err
= fw_iso_context_start(s
->context
, -1, 0,
816 FW_ISO_CONTEXT_MATCH_TAG1
);
820 mutex_unlock(&s
->mutex
);
825 fw_iso_context_destroy(s
->context
);
826 s
->context
= ERR_PTR(-1);
828 iso_packets_buffer_destroy(&s
->buffer
, s
->unit
);
830 mutex_unlock(&s
->mutex
);
834 EXPORT_SYMBOL(amdtp_stream_start
);
837 * amdtp_stream_pcm_pointer - get the PCM buffer position
838 * @s: the AMDTP stream that transports the PCM data
840 * Returns the current buffer position, in frames.
842 unsigned long amdtp_stream_pcm_pointer(struct amdtp_stream
*s
)
844 /* this optimization is allowed to be racy */
845 if (s
->pointer_flush
)
846 fw_iso_context_flush_completions(s
->context
);
848 s
->pointer_flush
= true;
850 return ACCESS_ONCE(s
->pcm_buffer_pointer
);
852 EXPORT_SYMBOL(amdtp_stream_pcm_pointer
);
855 * amdtp_stream_update - update the stream after a bus reset
856 * @s: the AMDTP stream
858 void amdtp_stream_update(struct amdtp_stream
*s
)
860 ACCESS_ONCE(s
->source_node_id_field
) =
861 (fw_parent_device(s
->unit
)->card
->node_id
& 0x3f) << 24;
863 EXPORT_SYMBOL(amdtp_stream_update
);
866 * amdtp_stream_stop - stop sending packets
867 * @s: the AMDTP stream to stop
869 * All PCM and MIDI devices of the stream must be stopped before the stream
870 * itself can be stopped.
872 void amdtp_stream_stop(struct amdtp_stream
*s
)
874 mutex_lock(&s
->mutex
);
876 if (!amdtp_stream_running(s
)) {
877 mutex_unlock(&s
->mutex
);
881 tasklet_kill(&s
->period_tasklet
);
882 fw_iso_context_stop(s
->context
);
883 fw_iso_context_destroy(s
->context
);
884 s
->context
= ERR_PTR(-1);
885 iso_packets_buffer_destroy(&s
->buffer
, s
->unit
);
887 s
->callbacked
= false;
889 mutex_unlock(&s
->mutex
);
891 EXPORT_SYMBOL(amdtp_stream_stop
);
894 * amdtp_stream_pcm_abort - abort the running PCM device
895 * @s: the AMDTP stream about to be stopped
897 * If the isochronous stream needs to be stopped asynchronously, call this
898 * function first to stop the PCM device.
900 void amdtp_stream_pcm_abort(struct amdtp_stream
*s
)
902 struct snd_pcm_substream
*pcm
;
904 pcm
= ACCESS_ONCE(s
->pcm
);
906 snd_pcm_stream_lock_irq(pcm
);
907 if (snd_pcm_running(pcm
))
908 snd_pcm_stop(pcm
, SNDRV_PCM_STATE_XRUN
);
909 snd_pcm_stream_unlock_irq(pcm
);
912 EXPORT_SYMBOL(amdtp_stream_pcm_abort
);