1 // SPDX-License-Identifier: GPL-2.0-only
3 * amdtp-motu.c - a part of driver for MOTU FireWire series
5 * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
8 #include <linux/slab.h>
12 #define CREATE_TRACE_POINTS
13 #include "amdtp-motu-trace.h"
15 #define CIP_FMT_MOTU 0x02
16 #define CIP_FMT_MOTU_TX_V3 0x22
17 #define MOTU_FDF_AM824 0x22
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 IEEE1394_SEC_MODULUS 128
25 #define TRANSFER_DELAY_TICKS 0x2e00 /* 479.17 microseconds */
27 #define CIP_SPH_CYCLE_SHIFT 12
28 #define CIP_SPH_CYCLE_MASK 0x01fff000
29 #define CIP_SPH_OFFSET_MASK 0x00000fff
32 * Nominally 3125 bytes/second, but the MIDI port's clock might be
33 * 1% too slow, and the bus clock 100 ppm too fast.
35 #define MIDI_BYTES_PER_SECOND 3093
38 /* For timestamp processing. */
39 unsigned int quotient_ticks_per_event;
40 unsigned int remainder_ticks_per_event;
41 unsigned int next_ticks;
42 unsigned int next_accumulated;
43 unsigned int next_cycles;
44 unsigned int next_seconds;
46 unsigned int pcm_chunks;
47 unsigned int pcm_byte_offset;
49 struct snd_rawmidi_substream *midi;
50 unsigned int midi_ports;
51 unsigned int midi_flag_offset;
52 unsigned int midi_byte_offset;
55 unsigned int midi_db_interval;
57 struct amdtp_motu_cache *cache;
60 int amdtp_motu_set_parameters(struct amdtp_stream *s, unsigned int rate,
61 unsigned int midi_ports,
62 struct snd_motu_packet_format *formats)
65 unsigned int quotient_ticks_per_event;
66 unsigned int remainder_ticks_per_event;
68 [CIP_SFC_44100] = { 557, 123 },
69 [CIP_SFC_48000] = { 512, 0 },
70 [CIP_SFC_88200] = { 278, 282 },
71 [CIP_SFC_96000] = { 256, 0 },
72 [CIP_SFC_176400] = { 139, 141 },
73 [CIP_SFC_192000] = { 128, 0 },
75 struct amdtp_motu *p = s->protocol;
76 unsigned int pcm_chunks, data_chunks, data_block_quadlets;
81 if (amdtp_stream_running(s))
84 for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {
85 if (snd_motu_clock_rates[i] == rate) {
90 if (i == ARRAY_SIZE(snd_motu_clock_rates))
93 // Each data block includes SPH in its head. Data chunks follow with
94 // 3 byte alignment. Padding follows with zero to conform to quadlet
96 pcm_chunks = formats->pcm_chunks[mode];
97 data_chunks = formats->msg_chunks + pcm_chunks;
98 data_block_quadlets = 1 + DIV_ROUND_UP(data_chunks * 3, 4);
100 err = amdtp_stream_set_parameters(s, rate, data_block_quadlets);
104 p->pcm_chunks = pcm_chunks;
105 p->pcm_byte_offset = formats->pcm_byte_offset;
107 p->midi_ports = midi_ports;
108 p->midi_flag_offset = formats->midi_flag_offset;
109 p->midi_byte_offset = formats->midi_byte_offset;
111 p->midi_db_count = 0;
112 p->midi_db_interval = rate / MIDI_BYTES_PER_SECOND;
114 delay = TRANSFER_DELAY_TICKS;
116 // For no-data or empty packets to adjust PCM sampling frequency.
117 delay += TICKS_PER_SECOND * s->syt_interval / rate;
120 p->next_cycles = delay / TICKS_PER_CYCLE;
121 p->quotient_ticks_per_event = params[s->sfc].quotient_ticks_per_event;
122 p->remainder_ticks_per_event = params[s->sfc].remainder_ticks_per_event;
123 p->next_ticks = delay % TICKS_PER_CYCLE;
124 p->next_accumulated = 0;
129 static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
130 __be32 *buffer, unsigned int data_blocks,
131 unsigned int pcm_frames)
133 struct amdtp_motu *p = s->protocol;
134 unsigned int channels = p->pcm_chunks;
135 struct snd_pcm_runtime *runtime = pcm->runtime;
136 unsigned int pcm_buffer_pointer;
137 int remaining_frames;
142 pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
143 pcm_buffer_pointer %= runtime->buffer_size;
145 dst = (void *)runtime->dma_area +
146 frames_to_bytes(runtime, pcm_buffer_pointer);
147 remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
149 for (i = 0; i < data_blocks; ++i) {
150 byte = (u8 *)buffer + p->pcm_byte_offset;
152 for (c = 0; c < channels; ++c) {
153 *dst = (byte[0] << 24) |
159 buffer += s->data_block_quadlets;
160 if (--remaining_frames == 0)
161 dst = (void *)runtime->dma_area;
165 static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
166 __be32 *buffer, unsigned int data_blocks,
167 unsigned int pcm_frames)
169 struct amdtp_motu *p = s->protocol;
170 unsigned int channels = p->pcm_chunks;
171 struct snd_pcm_runtime *runtime = pcm->runtime;
172 unsigned int pcm_buffer_pointer;
173 int remaining_frames;
178 pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
179 pcm_buffer_pointer %= runtime->buffer_size;
181 src = (void *)runtime->dma_area +
182 frames_to_bytes(runtime, pcm_buffer_pointer);
183 remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
185 for (i = 0; i < data_blocks; ++i) {
186 byte = (u8 *)buffer + p->pcm_byte_offset;
188 for (c = 0; c < channels; ++c) {
189 byte[0] = (*src >> 24) & 0xff;
190 byte[1] = (*src >> 16) & 0xff;
191 byte[2] = (*src >> 8) & 0xff;
196 buffer += s->data_block_quadlets;
197 if (--remaining_frames == 0)
198 src = (void *)runtime->dma_area;
202 static void write_pcm_silence(struct amdtp_stream *s, __be32 *buffer,
203 unsigned int data_blocks)
205 struct amdtp_motu *p = s->protocol;
206 unsigned int channels, i, c;
209 channels = p->pcm_chunks;
211 for (i = 0; i < data_blocks; ++i) {
212 byte = (u8 *)buffer + p->pcm_byte_offset;
214 for (c = 0; c < channels; ++c) {
221 buffer += s->data_block_quadlets;
225 int amdtp_motu_add_pcm_hw_constraints(struct amdtp_stream *s,
226 struct snd_pcm_runtime *runtime)
230 /* TODO: how to set an constraint for exactly 24bit PCM sample? */
231 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
235 return amdtp_stream_add_pcm_hw_constraints(s, runtime);
238 void amdtp_motu_midi_trigger(struct amdtp_stream *s, unsigned int port,
239 struct snd_rawmidi_substream *midi)
241 struct amdtp_motu *p = s->protocol;
243 if (port < p->midi_ports)
244 WRITE_ONCE(p->midi, midi);
247 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
248 unsigned int data_blocks)
250 struct amdtp_motu *p = s->protocol;
251 struct snd_rawmidi_substream *midi = READ_ONCE(p->midi);
255 for (i = 0; i < data_blocks; i++) {
258 if (midi && p->midi_db_count == 0 &&
259 snd_rawmidi_transmit(midi, b + p->midi_byte_offset, 1) == 1) {
260 b[p->midi_flag_offset] = 0x01;
262 b[p->midi_byte_offset] = 0x00;
263 b[p->midi_flag_offset] = 0x00;
266 buffer += s->data_block_quadlets;
268 if (--p->midi_db_count < 0)
269 p->midi_db_count = p->midi_db_interval;
273 static void read_midi_messages(struct amdtp_stream *s, __be32 *buffer,
274 unsigned int data_blocks)
276 struct amdtp_motu *p = s->protocol;
277 struct snd_rawmidi_substream *midi;
281 for (i = 0; i < data_blocks; i++) {
283 midi = READ_ONCE(p->midi);
285 if (midi && (b[p->midi_flag_offset] & 0x01))
286 snd_rawmidi_receive(midi, b + p->midi_byte_offset, 1);
288 buffer += s->data_block_quadlets;
292 /* For tracepoints. */
293 static void __maybe_unused copy_sph(u32 *frames, __be32 *buffer,
294 unsigned int data_blocks,
295 unsigned int data_block_quadlets)
299 for (i = 0; i < data_blocks; ++i) {
300 *frames = be32_to_cpu(*buffer);
301 buffer += data_block_quadlets;
306 /* For tracepoints. */
307 static void __maybe_unused copy_message(u64 *frames, __be32 *buffer,
308 unsigned int data_blocks,
309 unsigned int data_block_quadlets)
313 /* This is just for v2/v3 protocol. */
314 for (i = 0; i < data_blocks; ++i) {
315 *frames = (be32_to_cpu(buffer[1]) << 16) |
316 (be32_to_cpu(buffer[2]) >> 16);
317 buffer += data_block_quadlets;
322 static void probe_tracepoints_events(struct amdtp_stream *s,
323 const struct pkt_desc *descs,
324 unsigned int packets)
328 for (i = 0; i < packets; ++i) {
329 const struct pkt_desc *desc = descs + i;
330 __be32 *buf = desc->ctx_payload;
331 unsigned int data_blocks = desc->data_blocks;
333 trace_data_block_sph(s, data_blocks, buf);
334 trace_data_block_message(s, data_blocks, buf);
338 static void cache_event_offsets(struct amdtp_motu_cache *cache, const __be32 *buf,
339 unsigned int data_blocks, unsigned int data_block_quadlets)
341 unsigned int *event_offsets = cache->event_offsets;
342 const unsigned int cache_size = cache->size;
343 unsigned int cache_tail = cache->tail;
344 unsigned int base_tick = cache->tx_cycle_count * TICKS_PER_CYCLE;
347 for (i = 0; i < data_blocks; ++i) {
348 u32 sph = be32_to_cpu(*buf);
351 tick = ((sph & CIP_SPH_CYCLE_MASK) >> CIP_SPH_CYCLE_SHIFT) * TICKS_PER_CYCLE +
352 (sph & CIP_SPH_OFFSET_MASK);
354 if (tick < base_tick)
355 tick += TICKS_PER_SECOND;
356 event_offsets[cache_tail] = tick - base_tick;
358 cache_tail = (cache_tail + 1) % cache_size;
359 buf += data_block_quadlets;
362 cache->tail = cache_tail;
363 cache->tx_cycle_count = (cache->tx_cycle_count + 1) % CYCLES_PER_SECOND;
366 static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
367 const struct pkt_desc *descs,
368 unsigned int packets,
369 struct snd_pcm_substream *pcm)
371 struct amdtp_motu *p = s->protocol;
372 unsigned int pcm_frames = 0;
375 if (p->cache->tx_cycle_count == UINT_MAX)
376 p->cache->tx_cycle_count = (s->domain->processing_cycle.tx_start % CYCLES_PER_SECOND);
378 // For data block processing.
379 for (i = 0; i < packets; ++i) {
380 const struct pkt_desc *desc = descs + i;
381 __be32 *buf = desc->ctx_payload;
382 unsigned int data_blocks = desc->data_blocks;
384 cache_event_offsets(p->cache, buf, data_blocks, s->data_block_quadlets);
387 read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
388 pcm_frames += data_blocks;
392 read_midi_messages(s, buf, data_blocks);
396 if (trace_data_block_sph_enabled() ||
397 trace_data_block_message_enabled())
398 probe_tracepoints_events(s, descs, packets);
403 static inline void compute_next_elapse_from_start(struct amdtp_motu *p)
405 p->next_accumulated += p->remainder_ticks_per_event;
406 if (p->next_accumulated >= 441) {
407 p->next_accumulated -= 441;
411 p->next_ticks += p->quotient_ticks_per_event;
412 if (p->next_ticks >= TICKS_PER_CYCLE) {
413 p->next_ticks -= TICKS_PER_CYCLE;
417 if (p->next_cycles >= CYCLES_PER_SECOND) {
418 p->next_cycles -= CYCLES_PER_SECOND;
422 if (p->next_seconds >= IEEE1394_SEC_MODULUS)
423 p->next_seconds -= IEEE1394_SEC_MODULUS;
426 static void write_sph(struct amdtp_stream *s, __be32 *buffer, unsigned int data_blocks,
427 const unsigned int rx_start_cycle)
429 struct amdtp_motu *p = s->protocol;
430 unsigned int next_cycles;
434 for (i = 0; i < data_blocks; i++) {
435 next_cycles = (rx_start_cycle + p->next_cycles) % CYCLES_PER_SECOND;
436 sph = ((next_cycles << CIP_SPH_CYCLE_SHIFT) | p->next_ticks) &
437 (CIP_SPH_CYCLE_MASK | CIP_SPH_OFFSET_MASK);
438 *buffer = cpu_to_be32(sph);
440 compute_next_elapse_from_start(p);
442 buffer += s->data_block_quadlets;
446 static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
447 const struct pkt_desc *descs,
448 unsigned int packets,
449 struct snd_pcm_substream *pcm)
451 const unsigned int rx_start_cycle = s->domain->processing_cycle.rx_start;
452 struct amdtp_motu *p = s->protocol;
453 unsigned int pcm_frames = 0;
456 // For data block processing.
457 for (i = 0; i < packets; ++i) {
458 const struct pkt_desc *desc = descs + i;
459 __be32 *buf = desc->ctx_payload;
460 unsigned int data_blocks = desc->data_blocks;
463 write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
464 pcm_frames += data_blocks;
466 write_pcm_silence(s, buf, data_blocks);
470 write_midi_messages(s, buf, data_blocks);
472 // TODO: how to interact control messages between userspace?
474 write_sph(s, buf, data_blocks, rx_start_cycle);
478 if (trace_data_block_sph_enabled() ||
479 trace_data_block_message_enabled())
480 probe_tracepoints_events(s, descs, packets);
485 int amdtp_motu_init(struct amdtp_stream *s, struct fw_unit *unit,
486 enum amdtp_stream_direction dir,
487 const struct snd_motu_spec *spec, struct amdtp_motu_cache *cache)
489 amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
490 int fmt = CIP_FMT_MOTU;
491 unsigned int flags = CIP_BLOCKING | CIP_UNAWARE_SYT;
492 struct amdtp_motu *p;
495 if (dir == AMDTP_IN_STREAM) {
496 process_ctx_payloads = process_ir_ctx_payloads;
499 * Units of version 3 transmits packets with invalid CIP header
500 * against IEC 61883-1.
502 if (spec->protocol_version == SND_MOTU_PROTOCOL_V3) {
503 flags |= CIP_WRONG_DBS |
504 CIP_SKIP_DBC_ZERO_CHECK |
505 CIP_HEADER_WITHOUT_EOH;
506 fmt = CIP_FMT_MOTU_TX_V3;
509 if (spec == &snd_motu_spec_8pre ||
510 spec == &snd_motu_spec_ultralite) {
511 // 8pre has some quirks.
512 flags |= CIP_WRONG_DBS |
513 CIP_SKIP_DBC_ZERO_CHECK;
516 process_ctx_payloads = process_it_ctx_payloads;
517 flags |= CIP_DBC_IS_END_EVENT;
520 err = amdtp_stream_init(s, unit, dir, flags, fmt, process_ctx_payloads,
521 sizeof(struct amdtp_motu));
527 if (dir == AMDTP_OUT_STREAM) {
528 // Use fixed value for FDF field.
529 s->ctx_data.rx.fdf = MOTU_FDF_AM824;