1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * amdtp-motu.c - a part of driver for MOTU FireWire series
4 *
5 * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
6 */
7
8#include <linux/slab.h>
9#include <sound/pcm.h>
10#include "motu.h"
11
12#define CREATE_TRACE_POINTS
13#include "amdtp-motu-trace.h"
14
15#define CIP_FMT_MOTU		0x02
16#define CIP_FMT_MOTU_TX_V3	0x22
17#define MOTU_FDF_AM824		0x22
18
19/*
20 * Nominally 3125 bytes/second, but the MIDI port's clock might be
21 * 1% too slow, and the bus clock 100 ppm too fast.
22 */
23#define MIDI_BYTES_PER_SECOND	3093
24
25struct amdtp_motu {
26	/* For timestamp processing.  */
27	unsigned int quotient_ticks_per_event;
28	unsigned int remainder_ticks_per_event;
29	unsigned int next_ticks;
30	unsigned int next_accumulated;
31	unsigned int next_cycles;
32	unsigned int next_seconds;
33
34	unsigned int pcm_chunks;
35	unsigned int pcm_byte_offset;
36
37	struct snd_rawmidi_substream *midi;
38	unsigned int midi_ports;
39	unsigned int midi_flag_offset;
40	unsigned int midi_byte_offset;
41
42	int midi_db_count;
43	unsigned int midi_db_interval;
44};
45
46int amdtp_motu_set_parameters(struct amdtp_stream *s, unsigned int rate,
47			      unsigned int midi_ports,
48			      struct snd_motu_packet_format *formats)
49{
50	static const struct {
51		unsigned int quotient_ticks_per_event;
52		unsigned int remainder_ticks_per_event;
53	} params[] = {
54		[CIP_SFC_44100]  = { 557, 123 },
55		[CIP_SFC_48000]  = { 512,   0 },
56		[CIP_SFC_88200]  = { 278, 282 },
57		[CIP_SFC_96000]  = { 256,   0 },
58		[CIP_SFC_176400] = { 139, 141 },
59		[CIP_SFC_192000] = { 128,   0 },
60	};
61	struct amdtp_motu *p = s->protocol;
62	unsigned int pcm_chunks, data_chunks, data_block_quadlets;
63	unsigned int delay;
64	unsigned int mode;
65	int i, err;
66
67	if (amdtp_stream_running(s))
68		return -EBUSY;
69
70	for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {
71		if (snd_motu_clock_rates[i] == rate) {
72			mode = i >> 1;
73			break;
74		}
75	}
76	if (i == ARRAY_SIZE(snd_motu_clock_rates))
77		return -EINVAL;
78
79	// Each data block includes SPH in its head. Data chunks follow with
80	// 3 byte alignment. Padding follows with zero to conform to quadlet
81	// alignment.
82	pcm_chunks = formats->pcm_chunks[mode];
83	data_chunks = formats->msg_chunks + pcm_chunks;
84	data_block_quadlets = 1 + DIV_ROUND_UP(data_chunks * 3, 4);
85
86	err = amdtp_stream_set_parameters(s, rate, data_block_quadlets);
87	if (err < 0)
88		return err;
89
90	p->pcm_chunks = pcm_chunks;
91	p->pcm_byte_offset = formats->pcm_byte_offset;
92
93	p->midi_ports = midi_ports;
94	p->midi_flag_offset = formats->midi_flag_offset;
95	p->midi_byte_offset = formats->midi_byte_offset;
96
97	p->midi_db_count = 0;
98	p->midi_db_interval = rate / MIDI_BYTES_PER_SECOND;
99
100	/* IEEE 1394 bus requires. */
101	delay = 0x2e00;
102
103	/* For no-data or empty packets to adjust PCM sampling frequency. */
104	delay += 8000 * 3072 * s->syt_interval / rate;
105
106	p->next_seconds = 0;
107	p->next_cycles = delay / 3072;
108	p->quotient_ticks_per_event = params[s->sfc].quotient_ticks_per_event;
109	p->remainder_ticks_per_event = params[s->sfc].remainder_ticks_per_event;
110	p->next_ticks = delay % 3072;
111	p->next_accumulated = 0;
112
113	return 0;
114}
115
116static void read_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
117			 __be32 *buffer, unsigned int data_blocks,
118			 unsigned int pcm_frames)
119{
120	struct amdtp_motu *p = s->protocol;
121	unsigned int channels = p->pcm_chunks;
122	struct snd_pcm_runtime *runtime = pcm->runtime;
123	unsigned int pcm_buffer_pointer;
124	int remaining_frames;
125	u8 *byte;
126	u32 *dst;
127	int i, c;
128
129	pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
130	pcm_buffer_pointer %= runtime->buffer_size;
131
132	dst = (void *)runtime->dma_area +
133				frames_to_bytes(runtime, pcm_buffer_pointer);
134	remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
135
136	for (i = 0; i < data_blocks; ++i) {
137		byte = (u8 *)buffer + p->pcm_byte_offset;
138
139		for (c = 0; c < channels; ++c) {
140			*dst = (byte[0] << 24) |
141			       (byte[1] << 16) |
142			       (byte[2] << 8);
143			byte += 3;
144			dst++;
145		}
146		buffer += s->data_block_quadlets;
147		if (--remaining_frames == 0)
148			dst = (void *)runtime->dma_area;
149	}
150}
151
152static void write_pcm_s32(struct amdtp_stream *s, struct snd_pcm_substream *pcm,
153			  __be32 *buffer, unsigned int data_blocks,
154			  unsigned int pcm_frames)
155{
156	struct amdtp_motu *p = s->protocol;
157	unsigned int channels = p->pcm_chunks;
158	struct snd_pcm_runtime *runtime = pcm->runtime;
159	unsigned int pcm_buffer_pointer;
160	int remaining_frames;
161	u8 *byte;
162	const u32 *src;
163	int i, c;
164
165	pcm_buffer_pointer = s->pcm_buffer_pointer + pcm_frames;
166	pcm_buffer_pointer %= runtime->buffer_size;
167
168	src = (void *)runtime->dma_area +
169				frames_to_bytes(runtime, pcm_buffer_pointer);
170	remaining_frames = runtime->buffer_size - pcm_buffer_pointer;
171
172	for (i = 0; i < data_blocks; ++i) {
173		byte = (u8 *)buffer + p->pcm_byte_offset;
174
175		for (c = 0; c < channels; ++c) {
176			byte[0] = (*src >> 24) & 0xff;
177			byte[1] = (*src >> 16) & 0xff;
178			byte[2] = (*src >>  8) & 0xff;
179			byte += 3;
180			src++;
181		}
182
183		buffer += s->data_block_quadlets;
184		if (--remaining_frames == 0)
185			src = (void *)runtime->dma_area;
186	}
187}
188
189static void write_pcm_silence(struct amdtp_stream *s, __be32 *buffer,
190			      unsigned int data_blocks)
191{
192	struct amdtp_motu *p = s->protocol;
193	unsigned int channels, i, c;
194	u8 *byte;
195
196	channels = p->pcm_chunks;
197
198	for (i = 0; i < data_blocks; ++i) {
199		byte = (u8 *)buffer + p->pcm_byte_offset;
200
201		for (c = 0; c < channels; ++c) {
202			byte[0] = 0;
203			byte[1] = 0;
204			byte[2] = 0;
205			byte += 3;
206		}
207
208		buffer += s->data_block_quadlets;
209	}
210}
211
212int amdtp_motu_add_pcm_hw_constraints(struct amdtp_stream *s,
213				      struct snd_pcm_runtime *runtime)
214{
215	int err;
216
217	/* TODO: how to set an constraint for exactly 24bit PCM sample? */
218	err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
219	if (err < 0)
220		return err;
221
222	return amdtp_stream_add_pcm_hw_constraints(s, runtime);
223}
224
225void amdtp_motu_midi_trigger(struct amdtp_stream *s, unsigned int port,
226			     struct snd_rawmidi_substream *midi)
227{
228	struct amdtp_motu *p = s->protocol;
229
230	if (port < p->midi_ports)
231		WRITE_ONCE(p->midi, midi);
232}
233
234static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
235				unsigned int data_blocks)
236{
237	struct amdtp_motu *p = s->protocol;
238	struct snd_rawmidi_substream *midi = READ_ONCE(p->midi);
239	u8 *b;
240	int i;
241
242	for (i = 0; i < data_blocks; i++) {
243		b = (u8 *)buffer;
244
245		if (midi && p->midi_db_count == 0 &&
246		    snd_rawmidi_transmit(midi, b + p->midi_byte_offset, 1) == 1) {
247			b[p->midi_flag_offset] = 0x01;
248		} else {
249			b[p->midi_byte_offset] = 0x00;
250			b[p->midi_flag_offset] = 0x00;
251		}
252
253		buffer += s->data_block_quadlets;
254
255		if (--p->midi_db_count < 0)
256			p->midi_db_count = p->midi_db_interval;
257	}
258}
259
260static void read_midi_messages(struct amdtp_stream *s, __be32 *buffer,
261			       unsigned int data_blocks)
262{
263	struct amdtp_motu *p = s->protocol;
264	struct snd_rawmidi_substream *midi;
265	u8 *b;
266	int i;
267
268	for (i = 0; i < data_blocks; i++) {
269		b = (u8 *)buffer;
270		midi = READ_ONCE(p->midi);
271
272		if (midi && (b[p->midi_flag_offset] & 0x01))
273			snd_rawmidi_receive(midi, b + p->midi_byte_offset, 1);
274
275		buffer += s->data_block_quadlets;
276	}
277}
278
279/* For tracepoints. */
280static void __maybe_unused copy_sph(u32 *frames, __be32 *buffer,
281				    unsigned int data_blocks,
282				    unsigned int data_block_quadlets)
283{
284	unsigned int i;
285
286	for (i = 0; i < data_blocks; ++i) {
287		*frames = be32_to_cpu(*buffer);
288		buffer += data_block_quadlets;
289		frames++;
290	}
291}
292
293/* For tracepoints. */
294static void __maybe_unused copy_message(u64 *frames, __be32 *buffer,
295					unsigned int data_blocks,
296					unsigned int data_block_quadlets)
297{
298	unsigned int i;
299
300	/* This is just for v2/v3 protocol. */
301	for (i = 0; i < data_blocks; ++i) {
302		*frames = (be32_to_cpu(buffer[1]) << 16) |
303			  (be32_to_cpu(buffer[2]) >> 16);
304		buffer += data_block_quadlets;
305		frames++;
306	}
307}
308
309static void probe_tracepoints_events(struct amdtp_stream *s,
310				     const struct pkt_desc *descs,
311				     unsigned int packets)
312{
313	int i;
314
315	for (i = 0; i < packets; ++i) {
316		const struct pkt_desc *desc = descs + i;
317		__be32 *buf = desc->ctx_payload;
318		unsigned int data_blocks = desc->data_blocks;
319
320		trace_data_block_sph(s, data_blocks, buf);
321		trace_data_block_message(s, data_blocks, buf);
322	}
323}
324
325static unsigned int process_ir_ctx_payloads(struct amdtp_stream *s,
326					    const struct pkt_desc *descs,
327					    unsigned int packets,
328					    struct snd_pcm_substream *pcm)
329{
330	struct amdtp_motu *p = s->protocol;
331	unsigned int pcm_frames = 0;
332	int i;
333
334	// For data block processing.
335	for (i = 0; i < packets; ++i) {
336		const struct pkt_desc *desc = descs + i;
337		__be32 *buf = desc->ctx_payload;
338		unsigned int data_blocks = desc->data_blocks;
339
340		if (pcm) {
341			read_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
342			pcm_frames += data_blocks;
343		}
344
345		if (p->midi_ports)
346			read_midi_messages(s, buf, data_blocks);
347	}
348
349	// For tracepoints.
350	if (trace_data_block_sph_enabled() ||
351	    trace_data_block_message_enabled())
352		probe_tracepoints_events(s, descs, packets);
353
354	return pcm_frames;
355}
356
357static inline void compute_next_elapse_from_start(struct amdtp_motu *p)
358{
359	p->next_accumulated += p->remainder_ticks_per_event;
360	if (p->next_accumulated >= 441) {
361		p->next_accumulated -= 441;
362		p->next_ticks++;
363	}
364
365	p->next_ticks += p->quotient_ticks_per_event;
366	if (p->next_ticks >= 3072) {
367		p->next_ticks -= 3072;
368		p->next_cycles++;
369	}
370
371	if (p->next_cycles >= 8000) {
372		p->next_cycles -= 8000;
373		p->next_seconds++;
374	}
375
376	if (p->next_seconds >= 128)
377		p->next_seconds -= 128;
378}
379
380static void write_sph(struct amdtp_stream *s, __be32 *buffer,
381		      unsigned int data_blocks)
382{
383	struct amdtp_motu *p = s->protocol;
384	unsigned int next_cycles;
385	unsigned int i;
386	u32 sph;
387
388	for (i = 0; i < data_blocks; i++) {
389		next_cycles = (s->start_cycle + p->next_cycles) % 8000;
390		sph = ((next_cycles << 12) | p->next_ticks) & 0x01ffffff;
391		*buffer = cpu_to_be32(sph);
392
393		compute_next_elapse_from_start(p);
394
395		buffer += s->data_block_quadlets;
396	}
397}
398
399static unsigned int process_it_ctx_payloads(struct amdtp_stream *s,
400					    const struct pkt_desc *descs,
401					    unsigned int packets,
402					    struct snd_pcm_substream *pcm)
403{
404	struct amdtp_motu *p = s->protocol;
405	unsigned int pcm_frames = 0;
406	int i;
407
408	// For data block processing.
409	for (i = 0; i < packets; ++i) {
410		const struct pkt_desc *desc = descs + i;
411		__be32 *buf = desc->ctx_payload;
412		unsigned int data_blocks = desc->data_blocks;
413
414		if (pcm) {
415			write_pcm_s32(s, pcm, buf, data_blocks, pcm_frames);
416			pcm_frames += data_blocks;
417		} else {
418			write_pcm_silence(s, buf, data_blocks);
419		}
420
421		if (p->midi_ports)
422			write_midi_messages(s, buf, data_blocks);
423
424		// TODO: how to interact control messages between userspace?
425
426		write_sph(s, buf, data_blocks);
427	}
428
429	// For tracepoints.
430	if (trace_data_block_sph_enabled() ||
431	    trace_data_block_message_enabled())
432		probe_tracepoints_events(s, descs, packets);
433
434	return pcm_frames;
435}
436
437int amdtp_motu_init(struct amdtp_stream *s, struct fw_unit *unit,
438		    enum amdtp_stream_direction dir,
439		    const struct snd_motu_spec *spec)
440{
441	amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
442	int fmt = CIP_FMT_MOTU;
443	int flags = CIP_BLOCKING;
444	int err;
445
446	if (dir == AMDTP_IN_STREAM) {
447		process_ctx_payloads = process_ir_ctx_payloads;
448
449		/*
450		 * Units of version 3 transmits packets with invalid CIP header
451		 * against IEC 61883-1.
452		 */
453		if (spec->protocol_version == SND_MOTU_PROTOCOL_V3) {
454			flags |= CIP_WRONG_DBS |
455				 CIP_SKIP_DBC_ZERO_CHECK |
456				 CIP_HEADER_WITHOUT_EOH;
457			fmt = CIP_FMT_MOTU_TX_V3;
458		}
459
460		if (spec == &snd_motu_spec_8pre ||
461		    spec == &snd_motu_spec_ultralite) {
462			// 8pre has some quirks.
463			flags |= CIP_WRONG_DBS |
464				 CIP_SKIP_DBC_ZERO_CHECK;
465		}
466	} else {
467		process_ctx_payloads = process_it_ctx_payloads;
468		flags |= CIP_DBC_IS_END_EVENT;
469	}
470
471	err = amdtp_stream_init(s, unit, dir, flags, fmt, process_ctx_payloads,
472				sizeof(struct amdtp_motu));
473	if (err < 0)
474		return err;
475
476	s->sph = 1;
477
478	if (dir == AMDTP_OUT_STREAM) {
479		// Use fixed value for FDF field.
480		s->ctx_data.rx.fdf = MOTU_FDF_AM824;
481		// Not used.
482		s->ctx_data.rx.syt_override = 0xffff;
483	}
484
485	return 0;
486}
487