2 * ff-transaction.c - a part of driver for RME Fireface series
4 * Copyright (c) 2015-2017 Takashi Sakamoto
6 * Licensed under the terms of the GNU General Public License, version 2.
11 static void finish_transmit_midi_msg(struct snd_ff *ff, unsigned int port,
14 struct snd_rawmidi_substream *substream =
15 READ_ONCE(ff->rx_midi_substreams[port]);
17 if (rcode_is_permanent_error(rcode)) {
18 ff->rx_midi_error[port] = true;
22 if (rcode != RCODE_COMPLETE) {
23 /* Transfer the message again, immediately. */
24 ff->next_ktime[port] = 0;
25 schedule_work(&ff->rx_midi_work[port]);
29 snd_rawmidi_transmit_ack(substream, ff->rx_bytes[port]);
30 ff->rx_bytes[port] = 0;
32 if (!snd_rawmidi_transmit_empty(substream))
33 schedule_work(&ff->rx_midi_work[port]);
36 static void finish_transmit_midi0_msg(struct fw_card *card, int rcode,
37 void *data, size_t length,
41 container_of(callback_data, struct snd_ff, transactions[0]);
42 finish_transmit_midi_msg(ff, 0, rcode);
45 static void finish_transmit_midi1_msg(struct fw_card *card, int rcode,
46 void *data, size_t length,
50 container_of(callback_data, struct snd_ff, transactions[1]);
51 finish_transmit_midi_msg(ff, 1, rcode);
54 static inline void fill_midi_buf(struct snd_ff *ff, unsigned int port,
55 unsigned int index, u8 byte)
57 ff->msg_buf[port][index] = cpu_to_le32(byte);
60 static void transmit_midi_msg(struct snd_ff *ff, unsigned int port)
62 struct snd_rawmidi_substream *substream =
63 READ_ONCE(ff->rx_midi_substreams[port]);
64 u8 *buf = (u8 *)ff->msg_buf[port];
67 struct fw_device *fw_dev = fw_parent_device(ff->unit);
68 unsigned long long addr;
70 fw_transaction_callback_t callback;
72 if (substream == NULL || snd_rawmidi_transmit_empty(substream))
75 if (ff->rx_bytes[port] > 0 || ff->rx_midi_error[port])
78 /* Do it in next chance. */
79 if (ktime_after(ff->next_ktime[port], ktime_get())) {
80 schedule_work(&ff->rx_midi_work[port]);
84 len = snd_rawmidi_transmit_peek(substream, buf,
85 SND_FF_MAXIMIM_MIDI_QUADS);
89 for (i = len - 1; i >= 0; i--)
90 fill_midi_buf(ff, port, i, buf[i]);
93 addr = ff->spec->midi_rx_addrs[0];
94 callback = finish_transmit_midi0_msg;
96 addr = ff->spec->midi_rx_addrs[1];
97 callback = finish_transmit_midi1_msg;
100 /* Set interval to next transaction. */
101 ff->next_ktime[port] = ktime_add_ns(ktime_get(),
102 len * 8 * NSEC_PER_SEC / 31250);
103 ff->rx_bytes[port] = len;
106 * In Linux FireWire core, when generation is updated with memory
107 * barrier, node id has already been updated. In this module, After
108 * this smp_rmb(), load/store instructions to memory are completed.
109 * Thus, both of generation and node id are available with recent
110 * values. This is a light-serialization solution to handle bus reset
111 * events on IEEE 1394 bus.
113 generation = fw_dev->generation;
115 fw_send_request(fw_dev->card, &ff->transactions[port],
116 TCODE_WRITE_BLOCK_REQUEST,
117 fw_dev->node_id, generation, fw_dev->max_speed,
118 addr, &ff->msg_buf[port], len * 4,
119 callback, &ff->transactions[port]);
122 static void transmit_midi0_msg(struct work_struct *work)
124 struct snd_ff *ff = container_of(work, struct snd_ff, rx_midi_work[0]);
126 transmit_midi_msg(ff, 0);
129 static void transmit_midi1_msg(struct work_struct *work)
131 struct snd_ff *ff = container_of(work, struct snd_ff, rx_midi_work[1]);
133 transmit_midi_msg(ff, 1);
136 static void handle_midi_msg(struct fw_card *card, struct fw_request *request,
137 int tcode, int destination, int source,
138 int generation, unsigned long long offset,
139 void *data, size_t length, void *callback_data)
141 struct snd_ff *ff = callback_data;
144 fw_send_response(card, request, RCODE_COMPLETE);
146 offset -= ff->async_handler.offset;
147 ff->spec->protocol->handle_midi_msg(ff, (unsigned int)offset, buf,
151 static int allocate_own_address(struct snd_ff *ff, int i)
153 struct fw_address_region midi_msg_region;
156 ff->async_handler.length = ff->spec->midi_addr_range;
157 ff->async_handler.address_callback = handle_midi_msg;
158 ff->async_handler.callback_data = ff;
160 midi_msg_region.start = 0x000100000000ull * i;
161 midi_msg_region.end = midi_msg_region.start + ff->async_handler.length;
163 err = fw_core_add_address_handler(&ff->async_handler, &midi_msg_region);
165 /* Controllers are allowed to register this region. */
166 if (ff->async_handler.offset & 0x0000ffffffff) {
167 fw_core_remove_address_handler(&ff->async_handler);
176 * Controllers are allowed to register higher 4 bytes of address to receive
177 * the transactions. Different models have different registers for this purpose;
178 * e.g. 0x'0000'8010'03f4 for Fireface 400.
179 * The controllers are not allowed to register lower 4 bytes of the address.
180 * They are forced to select one of 4 options for the part of address by writing
181 * corresponding bits to 0x'0000'8010'051f.
183 * The 3rd-6th bits of this register are flags to indicate lower 4 bytes of
184 * address to which the device transferrs the transactions. In short:
185 * - 0x20: 0x'....'....'0000'0180
186 * - 0x10: 0x'....'....'0000'0100
187 * - 0x08: 0x'....'....'0000'0080
188 * - 0x04: 0x'....'....'0000'0000
190 * This driver configure 0x'....'....'0000'0000 to receive MIDI messages from
191 * units. The 3rd bit of the register should be configured, however this driver
192 * deligates this task to userspace applications due to a restriction that this
193 * register is write-only and the other bits have own effects.
195 * Unlike Fireface 800, Fireface 400 cancels transferring asynchronous
196 * transactions when the 1st and 2nd of the register stand. These two bits have
198 * - 0x02, 0x01: cancel transferring
200 * On the other hand, the bits have no effect on Fireface 800. This model
201 * cancels asynchronous transactions when the higher 4 bytes of address is
202 * overwritten with zero.
204 int snd_ff_transaction_reregister(struct snd_ff *ff)
206 struct fw_card *fw_card = fw_parent_device(ff->unit)->card;
211 * Controllers are allowed to register its node ID and upper 2 byte of
212 * local address to listen asynchronous transactions.
214 addr = (fw_card->node_id << 16) | (ff->async_handler.offset >> 32);
215 reg = cpu_to_le32(addr);
216 return snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
217 ff->spec->midi_high_addr,
218 ®, sizeof(reg), 0);
221 int snd_ff_transaction_register(struct snd_ff *ff)
226 * Allocate in Memory Space of IEC 13213, but lower 4 byte in LSB should
227 * be zero due to device specification.
229 for (i = 0; i < 0xffff; i++) {
230 err = allocate_own_address(ff, i);
231 if (err != -EBUSY && err != -EAGAIN)
237 err = snd_ff_transaction_reregister(ff);
241 INIT_WORK(&ff->rx_midi_work[0], transmit_midi0_msg);
242 INIT_WORK(&ff->rx_midi_work[1], transmit_midi1_msg);
247 void snd_ff_transaction_unregister(struct snd_ff *ff)
251 if (ff->async_handler.callback_data == NULL)
253 ff->async_handler.callback_data = NULL;
255 /* Release higher 4 bytes of address. */
256 reg = cpu_to_le32(0x00000000);
257 snd_fw_transaction(ff->unit, TCODE_WRITE_QUADLET_REQUEST,
258 ff->spec->midi_high_addr,
259 ®, sizeof(reg), 0);
261 fw_core_remove_address_handler(&ff->async_handler);