1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * tascam-transaction.c - a part of driver for TASCAM FireWire series
4 *
5 * Copyright (c) 2015 Takashi Sakamoto
6 */
7
8 #include "tascam.h"
9
10 /*
11 * When return minus value, given argument is not MIDI status.
12 * When return 0, given argument is a beginning of system exclusive.
13 * When return the others, given argument is MIDI data.
14 */
15 static inline int calculate_message_bytes(u8 status)
16 {
17 switch (status) {
18 case 0xf6: /* Tune request. */
19 case 0xf8: /* Timing clock. */
20 case 0xfa: /* Start. */
21 case 0xfb: /* Continue. */
22 case 0xfc: /* Stop. */
23 case 0xfe: /* Active sensing. */
24 case 0xff: /* System reset. */
25 return 1;
26 case 0xf1: /* MIDI time code quarter frame. */
27 case 0xf3: /* Song select. */
28 return 2;
29 case 0xf2: /* Song position pointer. */
30 return 3;
31 case 0xf0: /* Exclusive. */
32 return 0;
33 case 0xf7: /* End of exclusive. */
34 break;
35 case 0xf4: /* Undefined. */
36 case 0xf5: /* Undefined. */
37 case 0xf9: /* Undefined. */
38 case 0xfd: /* Undefined. */
39 break;
40 default:
41 switch (status & 0xf0) {
42 case 0x80: /* Note on. */
43 case 0x90: /* Note off. */
44 case 0xa0: /* Polyphonic key pressure. */
45 case 0xb0: /* Control change and Mode change. */
46 case 0xe0: /* Pitch bend change. */
47 return 3;
48 case 0xc0: /* Program change. */
49 case 0xd0: /* Channel pressure. */
50 return 2;
51 default:
52 break;
53 }
54 break;
55 }
56
57 return -EINVAL;
58 }
59
60 static int fill_message(struct snd_fw_async_midi_port *port,
61 struct snd_rawmidi_substream *substream)
62 {
63 int i, len, consume;
64 u8 *label, *msg;
65 u8 status;
66
67 /* The first byte is used for label, the rest for MIDI bytes. */
68 label = port->buf;
69 msg = port->buf + 1;
70
71 consume = snd_rawmidi_transmit_peek(substream, msg, 3);
72 if (consume == 0)
73 return 0;
74
75 /* On exclusive message. */
76 if (port->on_sysex) {
77 /* Seek the end of exclusives. */
78 for (i = 0; i < consume; ++i) {
79 if (msg[i] == 0xf7) {
80 port->on_sysex = false;
81 break;
82 }
83 }
84
85 /* At the end of exclusive message, use label 0x07. */
86 if (!port->on_sysex) {
87 consume = i + 1;
88 *label = (substream->number << 4) | 0x07;
89 /* During exclusive message, use label 0x04. */
90 } else if (consume == 3) {
91 *label = (substream->number << 4) | 0x04;
92 /* We need to fill whole 3 bytes. Go to next change. */
93 } else {
94 return 0;
95 }
96
97 len = consume;
98 } else {
99 /* The beginning of exclusives. */
100 if (msg[0] == 0xf0) {
101 /* Transfer it in next chance in another condition. */
102 port->on_sysex = true;
103 return 0;
104 } else {
105 /* On running-status. */
106 if ((msg[0] & 0x80) != 0x80)
107 status = port->running_status;
108 else
109 status = msg[0];
110
111 /* Calculate consume bytes. */
112 len = calculate_message_bytes(status);
113 if (len <= 0)
114 return 0;
115
116 /* On running-status. */
117 if ((msg[0] & 0x80) != 0x80) {
118 /* Enough MIDI bytes were not retrieved. */
119 if (consume < len - 1)
120 return 0;
121 consume = len - 1;
122
123 msg[2] = msg[1];
124 msg[1] = msg[0];
125 msg[0] = port->running_status;
126 } else {
127 /* Enough MIDI bytes were not retrieved. */
128 if (consume < len)
129 return 0;
130 consume = len;
131
132 port->running_status = msg[0];
133 }
134 }
135
136 *label = (substream->number << 4) | (msg[0] >> 4);
137 }
138
139 if (len > 0 && len < 3)
140 memset(msg + len, 0, 3 - len);
141
142 return consume;
143 }
144
145 static void async_midi_port_callback(struct fw_card *card, int rcode,
146 void *data, size_t length,
147 void *callback_data)
148 {
149 struct snd_fw_async_midi_port *port = callback_data;
150 struct snd_rawmidi_substream *substream = READ_ONCE(port->substream);
151
152 /* This port is closed. */
153 if (substream == NULL)
154 return;
155
156 if (rcode == RCODE_COMPLETE)
157 snd_rawmidi_transmit_ack(substream, port->consume_bytes);
158 else if (!rcode_is_permanent_error(rcode))
159 /* To start next transaction immediately for recovery. */
160 port->next_ktime = 0;
161 else
162 /* Don't continue processing. */
163 port->error = true;
164
165 port->idling = true;
166
167 if (!snd_rawmidi_transmit_empty(substream))
168 schedule_work(&port->work);
169 }
170
171 static void midi_port_work(struct work_struct *work)
172 {
173 struct snd_fw_async_midi_port *port =
174 container_of(work, struct snd_fw_async_midi_port, work);
175 struct snd_rawmidi_substream *substream = READ_ONCE(port->substream);
176 int generation;
177
178 /* Under transacting or error state. */
179 if (!port->idling || port->error)
180 return;
181
182 /* Nothing to do. */
183 if (substream == NULL || snd_rawmidi_transmit_empty(substream))
184 return;
185
186 /* Do it in next chance. */
187 if (ktime_after(port->next_ktime, ktime_get())) {
188 schedule_work(&port->work);
189 return;
190 }
191
192 /*
193 * Fill the buffer. The callee must use snd_rawmidi_transmit_peek().
194 * Later, snd_rawmidi_transmit_ack() is called.
195 */
196 memset(port->buf, 0, 4);
197 port->consume_bytes = fill_message(port, substream);
198 if (port->consume_bytes <= 0) {
199 /* Do it in next chance, immediately. */
200 if (port->consume_bytes == 0) {
201 port->next_ktime = 0;
202 schedule_work(&port->work);
203 } else {
204 /* Fatal error. */
205 port->error = true;
206 }
207 return;
208 }
209
210 /* Set interval to next transaction. */
211 port->next_ktime = ktime_add_ns(ktime_get(),
212 port->consume_bytes * 8 * (NSEC_PER_SEC / 31250));
213
214 /* Start this transaction. */
215 port->idling = false;
216
217 /*
218 * In Linux FireWire core, when generation is updated with memory
219 * barrier, node id has already been updated. In this module, After
220 * this smp_rmb(), load/store instructions to memory are completed.
221 * Thus, both of generation and node id are available with recent
222 * values. This is a light-serialization solution to handle bus reset
223 * events on IEEE 1394 bus.
224 */
225 generation = port->parent->generation;
226 smp_rmb();
227
228 fw_send_request(port->parent->card, &port->transaction,
229 TCODE_WRITE_QUADLET_REQUEST,
230 port->parent->node_id, generation,
231 port->parent->max_speed,
232 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_RX_QUAD,
233 port->buf, 4, async_midi_port_callback,
234 port);
235 }
236
237 void snd_fw_async_midi_port_init(struct snd_fw_async_midi_port *port)
238 {
239 port->idling = true;
240 port->error = false;
241 port->running_status = 0;
242 port->on_sysex = false;
243 }
244
245 static void handle_midi_tx(struct fw_card *card, struct fw_request *request,
246 int tcode, int destination, int source,
247 int generation, unsigned long long offset,
248 void *data, size_t length, void *callback_data)
249 {
250 struct snd_tscm *tscm = callback_data;
251 u32 *buf = (u32 *)data;
252 unsigned int messages;
253 unsigned int i;
254 unsigned int port;
255 struct snd_rawmidi_substream *substream;
256 u8 *b;
257 int bytes;
258
259 if (offset != tscm->async_handler.offset)
260 goto end;
261
262 messages = length / 8;
263 for (i = 0; i < messages; i++) {
264 b = (u8 *)(buf + i * 2);
265
266 port = b[0] >> 4;
267 /* TODO: support virtual MIDI ports. */
268 if (port >= tscm->spec->midi_capture_ports)
269 goto end;
270
271 /* Assume the message length. */
272 bytes = calculate_message_bytes(b[1]);
273 /* On MIDI data or exclusives. */
274 if (bytes <= 0) {
275 /* Seek the end of exclusives. */
276 for (bytes = 1; bytes < 4; bytes++) {
277 if (b[bytes] == 0xf7)
278 break;
279 }
280 if (bytes == 4)
281 bytes = 3;
282 }
283
284 substream = READ_ONCE(tscm->tx_midi_substreams[port]);
285 if (substream != NULL)
286 snd_rawmidi_receive(substream, b + 1, bytes);
287 }
288 end:
289 fw_send_response(card, request, RCODE_COMPLETE);
290 }
291
292 int snd_tscm_transaction_register(struct snd_tscm *tscm)
293 {
294 static const struct fw_address_region resp_register_region = {
295 .start = 0xffffe0000000ull,
296 .end = 0xffffe000ffffull,
297 };
298 unsigned int i;
299 int err;
300
301 /*
302 * Usually, two quadlets are transferred by one transaction. The first
303 * quadlet has MIDI messages, the rest includes timestamp.
304 * Sometimes, 8 set of the data is transferred by a block transaction.
305 */
306 tscm->async_handler.length = 8 * 8;
307 tscm->async_handler.address_callback = handle_midi_tx;
308 tscm->async_handler.callback_data = tscm;
309
310 err = fw_core_add_address_handler(&tscm->async_handler,
311 &resp_register_region);
312 if (err < 0)
313 return err;
314
315 err = snd_tscm_transaction_reregister(tscm);
316 if (err < 0)
317 goto error;
318
319 for (i = 0; i < TSCM_MIDI_OUT_PORT_MAX; i++) {
320 tscm->out_ports[i].parent = fw_parent_device(tscm->unit);
321 tscm->out_ports[i].next_ktime = 0;
322 INIT_WORK(&tscm->out_ports[i].work, midi_port_work);
323 }
324
325 return err;
326 error:
327 fw_core_remove_address_handler(&tscm->async_handler);
328 tscm->async_handler.callback_data = NULL;
329 return err;
330 }
331
332 /* At bus reset, these registers are cleared. */
333 int snd_tscm_transaction_reregister(struct snd_tscm *tscm)
334 {
335 struct fw_device *device = fw_parent_device(tscm->unit);
336 __be32 reg;
337 int err;
338
339 /* Register messaging address. Block transaction is not allowed. */
340 reg = cpu_to_be32((device->card->node_id << 16) |
341 (tscm->async_handler.offset >> 32));
342 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
343 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_HI,
344 ®, sizeof(reg), 0);
345 if (err < 0)
346 return err;
347
348 reg = cpu_to_be32(tscm->async_handler.offset);
349 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
350 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_LO,
351 ®, sizeof(reg), 0);
352 if (err < 0)
353 return err;
354
355 /* Turn on messaging. */
356 reg = cpu_to_be32(0x00000001);
357 err = snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
358 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ON,
359 ®, sizeof(reg), 0);
360 if (err < 0)
361 return err;
362
363 /* Turn on FireWire LED. */
364 reg = cpu_to_be32(0x0001008e);
365 return snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
366 TSCM_ADDR_BASE + TSCM_OFFSET_LED_POWER,
367 ®, sizeof(reg), 0);
368 }
369
370 void snd_tscm_transaction_unregister(struct snd_tscm *tscm)
371 {
372 __be32 reg;
373
374 if (tscm->async_handler.callback_data == NULL)
375 return;
376
377 /* Turn off FireWire LED. */
378 reg = cpu_to_be32(0x0000008e);
379 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
380 TSCM_ADDR_BASE + TSCM_OFFSET_LED_POWER,
381 ®, sizeof(reg), 0);
382
383 /* Turn off messaging. */
384 reg = cpu_to_be32(0x00000000);
385 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
386 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ON,
387 ®, sizeof(reg), 0);
388
389 /* Unregister the address. */
390 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
391 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_HI,
392 ®, sizeof(reg), 0);
393 snd_fw_transaction(tscm->unit, TCODE_WRITE_QUADLET_REQUEST,
394 TSCM_ADDR_BASE + TSCM_OFFSET_MIDI_TX_ADDR_LO,
395 ®, sizeof(reg), 0);
396
397 fw_core_remove_address_handler(&tscm->async_handler);
398 tscm->async_handler.callback_data = NULL;
399 }
400
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.