1 // SPDX-License-Identifier: GPL-2.0
2 // ff-protocol-latter - a part of driver for RME Fireface series
4 // Copyright (c) 2019 Takashi Sakamoto
6 // Licensed under the terms of the GNU General Public License, version 2.
8 #include <linux/delay.h>
12 #define LATTER_STF 0xffff00000004
13 #define LATTER_ISOC_CHANNELS 0xffff00000008
14 #define LATTER_ISOC_START 0xffff0000000c
15 #define LATTER_FETCH_MODE 0xffff00000010
16 #define LATTER_SYNC_STATUS 0x0000801c0000
18 static int parse_clock_bits(u32 data, unsigned int *rate,
19 enum snd_ff_clock_src *src)
24 } *rate_entry, rate_entries[] = {
25 { 32000, 0x00000000, },
26 { 44100, 0x01000000, },
27 { 48000, 0x02000000, },
28 { 64000, 0x04000000, },
29 { 88200, 0x05000000, },
30 { 96000, 0x06000000, },
31 { 128000, 0x08000000, },
32 { 176400, 0x09000000, },
33 { 192000, 0x0a000000, },
36 enum snd_ff_clock_src src;
38 } *clk_entry, clk_entries[] = {
39 { SND_FF_CLOCK_SRC_SPDIF, 0x00000200, },
40 { SND_FF_CLOCK_SRC_ADAT1, 0x00000400, },
41 { SND_FF_CLOCK_SRC_WORD, 0x00000600, },
42 { SND_FF_CLOCK_SRC_INTERNAL, 0x00000e00, },
46 for (i = 0; i < ARRAY_SIZE(rate_entries); ++i) {
47 rate_entry = rate_entries + i;
48 if ((data & 0x0f000000) == rate_entry->flag) {
49 *rate = rate_entry->rate;
53 if (i == ARRAY_SIZE(rate_entries))
56 for (i = 0; i < ARRAY_SIZE(clk_entries); ++i) {
57 clk_entry = clk_entries + i;
58 if ((data & 0x000e00) == clk_entry->flag) {
59 *src = clk_entry->src;
63 if (i == ARRAY_SIZE(clk_entries))
69 static int latter_get_clock(struct snd_ff *ff, unsigned int *rate,
70 enum snd_ff_clock_src *src)
76 err = snd_fw_transaction(ff->unit, TCODE_READ_QUADLET_REQUEST,
77 LATTER_SYNC_STATUS, ®, sizeof(reg), 0);
80 data = le32_to_cpu(reg);
82 return parse_clock_bits(data, rate, src);
85 static int latter_switch_fetching_mode(struct snd_ff *ff, bool enable)
94 reg = cpu_to_le32(data);
96 return snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
97 LATTER_FETCH_MODE, ®, sizeof(reg), 0);
100 static int keep_resources(struct snd_ff *ff, unsigned int rate)
102 enum snd_ff_stream_mode mode;
106 // Check whether the given value is supported or not.
107 for (i = 0; i < CIP_SFC_COUNT; i++) {
108 if (amdtp_rate_table[i] == rate)
111 if (i >= CIP_SFC_COUNT)
114 err = snd_ff_stream_get_multiplier_mode(i, &mode);
118 /* Keep resources for in-stream. */
119 ff->tx_resources.channels_mask = 0x00000000000000ffuLL;
120 err = fw_iso_resources_allocate(&ff->tx_resources,
121 amdtp_stream_get_max_payload(&ff->tx_stream),
122 fw_parent_device(ff->unit)->max_speed);
126 /* Keep resources for out-stream. */
127 ff->rx_resources.channels_mask = 0x00000000000000ffuLL;
128 err = fw_iso_resources_allocate(&ff->rx_resources,
129 amdtp_stream_get_max_payload(&ff->rx_stream),
130 fw_parent_device(ff->unit)->max_speed);
132 fw_iso_resources_free(&ff->tx_resources);
137 static int latter_begin_session(struct snd_ff *ff, unsigned int rate)
139 static const struct {
143 } *entry, rate_table[] = {
144 { 32000, 0x00, 0x92, },
145 { 44100, 0x02, 0x92, },
146 { 48000, 0x04, 0x92, },
147 { 64000, 0x08, 0x8e, },
148 { 88200, 0x0a, 0x8e, },
149 { 96000, 0x0c, 0x8e, },
150 { 128000, 0x10, 0x8c, },
151 { 176400, 0x12, 0x8c, },
152 { 192000, 0x14, 0x8c, },
160 for (i = 0; i < ARRAY_SIZE(rate_table); ++i) {
161 entry = rate_table + i;
162 if (entry->stf == rate)
165 if (i == ARRAY_SIZE(rate_table))
168 reg = cpu_to_le32(entry->code);
169 err = snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
170 LATTER_STF, ®, sizeof(reg), 0);
174 // Confirm to shift transmission clock.
176 while (count++ < 10) {
177 unsigned int curr_rate;
178 enum snd_ff_clock_src src;
180 err = latter_get_clock(ff, &curr_rate, &src);
184 if (curr_rate == rate)
190 err = keep_resources(ff, rate);
194 data = (ff->tx_resources.channel << 8) | ff->rx_resources.channel;
195 reg = cpu_to_le32(data);
196 err = snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
197 LATTER_ISOC_CHANNELS, ®, sizeof(reg), 0);
201 // Always use the maximum number of data channels in data block of
203 reg = cpu_to_le32(entry->flag);
204 return snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
205 LATTER_ISOC_START, ®, sizeof(reg), 0);
208 static void latter_finish_session(struct snd_ff *ff)
212 reg = cpu_to_le32(0x00000000);
213 snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
214 LATTER_ISOC_START, ®, sizeof(reg), 0);
217 static void latter_dump_status(struct snd_ff *ff, struct snd_info_buffer *buffer)
219 static const struct {
223 } *clk_entry, clk_entries[] = {
224 { "S/PDIF", 0x00000001, 0x00000010, },
225 { "ADAT", 0x00000002, 0x00000020, },
226 { "WDClk", 0x00000004, 0x00000040, },
231 enum snd_ff_clock_src src;
236 err = snd_fw_transaction(ff->unit, TCODE_READ_QUADLET_REQUEST,
237 LATTER_SYNC_STATUS, ®, sizeof(reg), 0);
240 data = le32_to_cpu(reg);
242 snd_iprintf(buffer, "External source detection:\n");
244 for (i = 0; i < ARRAY_SIZE(clk_entries); ++i) {
245 clk_entry = clk_entries + i;
246 snd_iprintf(buffer, "%s: ", clk_entry->label);
247 if (data & clk_entry->locked_mask) {
248 if (data & clk_entry->synced_mask)
249 snd_iprintf(buffer, "sync\n");
251 snd_iprintf(buffer, "lock\n");
253 snd_iprintf(buffer, "none\n");
257 err = parse_clock_bits(data, &rate, &src);
260 label = snd_ff_proc_get_clk_label(src);
264 snd_iprintf(buffer, "Referred clock: %s %d\n", label, rate);
267 // NOTE: transactions are transferred within 0x00-0x7f in allocated range of
268 // address. This seems to be for check of discontinuity in receiver side.
270 // Like Fireface 400, drivers can select one of 4 options for lower 4 bytes of
271 // destination address by bit flags in quadlet register (little endian) at
272 // 0x'ffff'0000'0014:
274 // bit flags: offset of destination address
275 // - 0x00002000: 0x'....'....'0000'0000
276 // - 0x00004000: 0x'....'....'0000'0080
277 // - 0x00008000: 0x'....'....'0000'0100
278 // - 0x00010000: 0x'....'....'0000'0180
280 // Drivers can suppress the device to transfer asynchronous transactions by
281 // clear these bit flags.
283 // Actually, the register is write-only and includes the other settings such as
284 // input attenuation. This driver allocates for the first option
285 // (0x'....'....'0000'0000) and expects userspace application to configure the
287 static void latter_handle_midi_msg(struct snd_ff *ff, unsigned int offset,
288 __le32 *buf, size_t length)
290 u32 data = le32_to_cpu(*buf);
291 unsigned int index = (data & 0x000000f0) >> 4;
293 struct snd_rawmidi_substream *substream;
296 if (index >= ff->spec->midi_in_ports)
299 switch (data & 0x0000000f) {
312 len = data & 0x00000003;
318 byte[0] = (data & 0x0000ff00) >> 8;
319 byte[1] = (data & 0x00ff0000) >> 16;
320 byte[2] = (data & 0xff000000) >> 24;
322 substream = READ_ONCE(ff->tx_midi_substreams[index]);
324 snd_rawmidi_receive(substream, byte, len);
328 * When return minus value, given argument is not MIDI status.
329 * When return 0, given argument is a beginning of system exclusive.
330 * When return the others, given argument is MIDI data.
332 static inline int calculate_message_bytes(u8 status)
335 case 0xf6: /* Tune request. */
336 case 0xf8: /* Timing clock. */
337 case 0xfa: /* Start. */
338 case 0xfb: /* Continue. */
339 case 0xfc: /* Stop. */
340 case 0xfe: /* Active sensing. */
341 case 0xff: /* System reset. */
343 case 0xf1: /* MIDI time code quarter frame. */
344 case 0xf3: /* Song select. */
346 case 0xf2: /* Song position pointer. */
348 case 0xf0: /* Exclusive. */
350 case 0xf7: /* End of exclusive. */
352 case 0xf4: /* Undefined. */
353 case 0xf5: /* Undefined. */
354 case 0xf9: /* Undefined. */
355 case 0xfd: /* Undefined. */
358 switch (status & 0xf0) {
359 case 0x80: /* Note on. */
360 case 0x90: /* Note off. */
361 case 0xa0: /* Polyphonic key pressure. */
362 case 0xb0: /* Control change and Mode change. */
363 case 0xe0: /* Pitch bend change. */
365 case 0xc0: /* Program change. */
366 case 0xd0: /* Channel pressure. */
377 static int latter_fill_midi_msg(struct snd_ff *ff,
378 struct snd_rawmidi_substream *substream,
382 u8 *buf = (u8 *)&data;
386 consumed = snd_rawmidi_transmit_peek(substream, buf + 1, 3);
390 if (!ff->on_sysex[port]) {
391 if (buf[1] != 0xf0) {
392 if (consumed < calculate_message_bytes(buf[1]))
395 // The beginning of exclusives.
396 ff->on_sysex[port] = true;
401 if (buf[1] != 0xf7) {
402 if (buf[2] == 0xf7 || buf[3] == 0xf7) {
403 // Transfer end code at next time.
409 // The end of exclusives.
410 ff->on_sysex[port] = false;
416 ff->msg_buf[port][0] = cpu_to_le32(data);
417 ff->rx_bytes[port] = consumed;
422 const struct snd_ff_protocol snd_ff_protocol_latter = {
423 .handle_midi_msg = latter_handle_midi_msg,
424 .fill_midi_msg = latter_fill_midi_msg,
425 .get_clock = latter_get_clock,
426 .switch_fetching_mode = latter_switch_fetching_mode,
427 .begin_session = latter_begin_session,
428 .finish_session = latter_finish_session,
429 .dump_status = latter_dump_status,