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