2 * amdtp-motu.c - a part of driver for MOTU FireWire series
4 * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
6 * Licensed under the terms of the GNU General Public License, version 2.
9 #include <linux/slab.h>
10 #include <sound/pcm.h>
13 #define CREATE_TRACE_POINTS
14 #include "amdtp-motu-trace.h"
16 #define CIP_FMT_MOTU 0x02
17 #define CIP_FMT_MOTU_TX_V3 0x22
18 #define MOTU_FDF_AM824 0x22
21 * Nominally 3125 bytes/second, but the MIDI port's clock might be
22 * 1% too slow, and the bus clock 100 ppm too fast.
24 #define MIDI_BYTES_PER_SECOND 3093
27 /* For timestamp processing. */
28 unsigned int quotient_ticks_per_event;
29 unsigned int remainder_ticks_per_event;
30 unsigned int next_ticks;
31 unsigned int next_accumulated;
32 unsigned int next_cycles;
33 unsigned int next_seconds;
35 unsigned int pcm_chunks;
36 unsigned int pcm_byte_offset;
38 struct snd_rawmidi_substream *midi;
39 unsigned int midi_ports;
40 unsigned int midi_flag_offset;
41 unsigned int midi_byte_offset;
44 unsigned int midi_db_interval;
47 int amdtp_motu_set_parameters(struct amdtp_stream *s, unsigned int rate,
48 unsigned int midi_ports,
49 struct snd_motu_packet_format *formats)
52 unsigned int quotient_ticks_per_event;
53 unsigned int remainder_ticks_per_event;
55 [CIP_SFC_44100] = { 557, 123 },
56 [CIP_SFC_48000] = { 512, 0 },
57 [CIP_SFC_88200] = { 278, 282 },
58 [CIP_SFC_96000] = { 256, 0 },
59 [CIP_SFC_176400] = { 139, 141 },
60 [CIP_SFC_192000] = { 128, 0 },
62 struct amdtp_motu *p = s->protocol;
63 unsigned int pcm_chunks, data_chunks, data_block_quadlets;
68 if (amdtp_stream_running(s))
71 for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {
72 if (snd_motu_clock_rates[i] == rate) {
77 if (i == ARRAY_SIZE(snd_motu_clock_rates))
80 pcm_chunks = formats->fixed_part_pcm_chunks[mode] +
81 formats->differed_part_pcm_chunks[mode];
82 data_chunks = formats->msg_chunks + pcm_chunks;
85 * Each data block includes SPH in its head. Data chunks follow with
86 * 3 byte alignment. Padding follows with zero to conform to quadlet
89 data_block_quadlets = 1 + DIV_ROUND_UP(data_chunks * 3, 4);
91 err = amdtp_stream_set_parameters(s, rate, data_block_quadlets);
95 p->pcm_chunks = pcm_chunks;
96 p->pcm_byte_offset = formats->pcm_byte_offset;
98 p->midi_ports = midi_ports;
99 p->midi_flag_offset = formats->midi_flag_offset;
100 p->midi_byte_offset = formats->midi_byte_offset;
102 p->midi_db_count = 0;
103 p->midi_db_interval = rate / MIDI_BYTES_PER_SECOND;
105 /* IEEE 1394 bus requires. */
108 /* For no-data or empty packets to adjust PCM sampling frequency. */
109 delay += 8000 * 3072 * s->syt_interval / rate;
112 p->next_cycles = delay / 3072;
113 p->quotient_ticks_per_event = params[s->sfc].quotient_ticks_per_event;
114 p->remainder_ticks_per_event = params[s->sfc].remainder_ticks_per_event;
115 p->next_ticks = delay % 3072;
116 p->next_accumulated = 0;
121 static void read_pcm_s32(struct amdtp_stream *s,
122 struct snd_pcm_runtime *runtime,
123 __be32 *buffer, unsigned int data_blocks)
125 struct amdtp_motu *p = s->protocol;
126 unsigned int channels, remaining_frames, i, c;
130 channels = p->pcm_chunks;
131 dst = (void *)runtime->dma_area +
132 frames_to_bytes(runtime, s->pcm_buffer_pointer);
133 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
135 for (i = 0; i < data_blocks; ++i) {
136 byte = (u8 *)buffer + p->pcm_byte_offset;
138 for (c = 0; c < channels; ++c) {
139 *dst = (byte[0] << 24) |
145 buffer += s->data_block_quadlets;
146 if (--remaining_frames == 0)
147 dst = (void *)runtime->dma_area;
151 static void write_pcm_s32(struct amdtp_stream *s,
152 struct snd_pcm_runtime *runtime,
153 __be32 *buffer, unsigned int data_blocks)
155 struct amdtp_motu *p = s->protocol;
156 unsigned int channels, remaining_frames, i, c;
160 channels = p->pcm_chunks;
161 src = (void *)runtime->dma_area +
162 frames_to_bytes(runtime, s->pcm_buffer_pointer);
163 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
165 for (i = 0; i < data_blocks; ++i) {
166 byte = (u8 *)buffer + p->pcm_byte_offset;
168 for (c = 0; c < channels; ++c) {
169 byte[0] = (*src >> 24) & 0xff;
170 byte[1] = (*src >> 16) & 0xff;
171 byte[2] = (*src >> 8) & 0xff;
176 buffer += s->data_block_quadlets;
177 if (--remaining_frames == 0)
178 src = (void *)runtime->dma_area;
182 static void write_pcm_silence(struct amdtp_stream *s, __be32 *buffer,
183 unsigned int data_blocks)
185 struct amdtp_motu *p = s->protocol;
186 unsigned int channels, i, c;
189 channels = p->pcm_chunks;
191 for (i = 0; i < data_blocks; ++i) {
192 byte = (u8 *)buffer + p->pcm_byte_offset;
194 for (c = 0; c < channels; ++c) {
201 buffer += s->data_block_quadlets;
205 int amdtp_motu_add_pcm_hw_constraints(struct amdtp_stream *s,
206 struct snd_pcm_runtime *runtime)
210 /* TODO: how to set an constraint for exactly 24bit PCM sample? */
211 err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
215 return amdtp_stream_add_pcm_hw_constraints(s, runtime);
218 void amdtp_motu_midi_trigger(struct amdtp_stream *s, unsigned int port,
219 struct snd_rawmidi_substream *midi)
221 struct amdtp_motu *p = s->protocol;
223 if (port < p->midi_ports)
224 WRITE_ONCE(p->midi, midi);
227 static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
228 unsigned int data_blocks)
230 struct amdtp_motu *p = s->protocol;
231 struct snd_rawmidi_substream *midi = READ_ONCE(p->midi);
235 for (i = 0; i < data_blocks; i++) {
238 if (midi && p->midi_db_count == 0 &&
239 snd_rawmidi_transmit(midi, b + p->midi_byte_offset, 1) == 1) {
240 b[p->midi_flag_offset] = 0x01;
242 b[p->midi_byte_offset] = 0x00;
243 b[p->midi_flag_offset] = 0x00;
246 buffer += s->data_block_quadlets;
248 if (--p->midi_db_count < 0)
249 p->midi_db_count = p->midi_db_interval;
253 static void read_midi_messages(struct amdtp_stream *s, __be32 *buffer,
254 unsigned int data_blocks)
256 struct amdtp_motu *p = s->protocol;
257 struct snd_rawmidi_substream *midi;
261 for (i = 0; i < data_blocks; i++) {
263 midi = READ_ONCE(p->midi);
265 if (midi && (b[p->midi_flag_offset] & 0x01))
266 snd_rawmidi_receive(midi, b + p->midi_byte_offset, 1);
268 buffer += s->data_block_quadlets;
272 /* For tracepoints. */
273 static void __maybe_unused copy_sph(u32 *frames, __be32 *buffer,
274 unsigned int data_blocks,
275 unsigned int data_block_quadlets)
279 for (i = 0; i < data_blocks; ++i) {
280 *frames = be32_to_cpu(*buffer);
281 buffer += data_block_quadlets;
286 /* For tracepoints. */
287 static void __maybe_unused copy_message(u64 *frames, __be32 *buffer,
288 unsigned int data_blocks,
289 unsigned int data_block_quadlets)
293 /* This is just for v2/v3 protocol. */
294 for (i = 0; i < data_blocks; ++i) {
295 *frames = (be32_to_cpu(buffer[1]) << 16) |
296 (be32_to_cpu(buffer[2]) >> 16);
297 buffer += data_block_quadlets;
302 static unsigned int process_tx_data_blocks(struct amdtp_stream *s,
303 __be32 *buffer, unsigned int data_blocks,
306 struct amdtp_motu *p = s->protocol;
307 struct snd_pcm_substream *pcm;
309 trace_in_data_block_sph(s, data_blocks, buffer);
310 trace_in_data_block_message(s, data_blocks, buffer);
313 read_midi_messages(s, buffer, data_blocks);
315 pcm = READ_ONCE(s->pcm);
316 if (data_blocks > 0 && pcm)
317 read_pcm_s32(s, pcm->runtime, buffer, data_blocks);
322 static inline void compute_next_elapse_from_start(struct amdtp_motu *p)
324 p->next_accumulated += p->remainder_ticks_per_event;
325 if (p->next_accumulated >= 441) {
326 p->next_accumulated -= 441;
330 p->next_ticks += p->quotient_ticks_per_event;
331 if (p->next_ticks >= 3072) {
332 p->next_ticks -= 3072;
336 if (p->next_cycles >= 8000) {
337 p->next_cycles -= 8000;
341 if (p->next_seconds >= 128)
342 p->next_seconds -= 128;
345 static void write_sph(struct amdtp_stream *s, __be32 *buffer,
346 unsigned int data_blocks)
348 struct amdtp_motu *p = s->protocol;
349 unsigned int next_cycles;
353 for (i = 0; i < data_blocks; i++) {
354 next_cycles = (s->start_cycle + p->next_cycles) % 8000;
355 sph = ((next_cycles << 12) | p->next_ticks) & 0x01ffffff;
356 *buffer = cpu_to_be32(sph);
358 compute_next_elapse_from_start(p);
360 buffer += s->data_block_quadlets;
364 static unsigned int process_rx_data_blocks(struct amdtp_stream *s,
365 __be32 *buffer, unsigned int data_blocks,
368 struct amdtp_motu *p = (struct amdtp_motu *)s->protocol;
369 struct snd_pcm_substream *pcm;
374 /* TODO: how to interact control messages between userspace? */
377 write_midi_messages(s, buffer, data_blocks);
379 pcm = READ_ONCE(s->pcm);
381 write_pcm_s32(s, pcm->runtime, buffer, data_blocks);
383 write_pcm_silence(s, buffer, data_blocks);
385 write_sph(s, buffer, data_blocks);
387 trace_out_data_block_sph(s, data_blocks, buffer);
388 trace_out_data_block_message(s, data_blocks, buffer);
393 int amdtp_motu_init(struct amdtp_stream *s, struct fw_unit *unit,
394 enum amdtp_stream_direction dir,
395 const struct snd_motu_protocol *const protocol)
397 amdtp_stream_process_data_blocks_t process_data_blocks;
398 int fmt = CIP_FMT_MOTU;
399 int flags = CIP_BLOCKING;
402 if (dir == AMDTP_IN_STREAM) {
403 process_data_blocks = process_tx_data_blocks;
406 * Units of version 3 transmits packets with invalid CIP header
407 * against IEC 61883-1.
409 if (protocol == &snd_motu_protocol_v3) {
410 flags |= CIP_WRONG_DBS |
411 CIP_SKIP_DBC_ZERO_CHECK |
412 CIP_HEADER_WITHOUT_EOH;
413 fmt = CIP_FMT_MOTU_TX_V3;
416 process_data_blocks = process_rx_data_blocks;
417 flags |= CIP_DBC_IS_END_EVENT;
420 err = amdtp_stream_init(s, unit, dir, flags, fmt, process_data_blocks,
421 sizeof(struct amdtp_motu));
426 s->fdf = MOTU_FDF_AM824;