1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) by Paul Barton-Davis 1998-1999 4 */ 5 6 /* The low level driver for the WaveFront ICS2115 MIDI interface(s) 7 * 8 * Note that there is also an MPU-401 emulation (actually, a UART-401 9 * emulation) on the CS4232 on the Tropez and Tropez Plus. This code 10 * has nothing to do with that interface at all. 11 * 12 * The interface is essentially just a UART-401, but is has the 13 * interesting property of supporting what Turtle Beach called 14 * "Virtual MIDI" mode. In this mode, there are effectively *two* 15 * MIDI buses accessible via the interface, one that is routed 16 * solely to/from the external WaveFront synthesizer and the other 17 * corresponding to the pin/socket connector used to link external 18 * MIDI devices to the board. 19 * 20 * This driver fully supports this mode, allowing two distinct MIDI 21 * busses to be used completely independently, giving 32 channels of 22 * MIDI routing, 16 to the WaveFront synth and 16 to the external MIDI 23 * bus. The devices are named /dev/snd/midiCnD0 and /dev/snd/midiCnD1, 24 * where `n' is the card number. Note that the device numbers may be 25 * something other than 0 and 1 if the CS4232 UART/MPU-401 interface 26 * is enabled. 27 * 28 * Switching between the two is accomplished externally by the driver 29 * using the two otherwise unused MIDI bytes. See the code for more details. 30 * 31 * NOTE: VIRTUAL MIDI MODE IS ON BY DEFAULT (see lowlevel/isa/wavefront.c) 32 * 33 * The main reason to turn off Virtual MIDI mode is when you want to 34 * tightly couple the WaveFront synth with an external MIDI 35 * device. You won't be able to distinguish the source of any MIDI 36 * data except via SysEx ID, but thats probably OK, since for the most 37 * part, the WaveFront won't be sending any MIDI data at all. 38 * 39 * The main reason to turn on Virtual MIDI Mode is to provide two 40 * completely independent 16-channel MIDI buses, one to the 41 * WaveFront and one to any external MIDI devices. Given the 32 42 * voice nature of the WaveFront, its pretty easy to find a use 43 * for all 16 channels driving just that synth. 44 * 45 */ 46 47 #include <linux/io.h> 48 #include <linux/init.h> 49 #include <linux/time.h> 50 #include <linux/wait.h> 51 #include <sound/core.h> 52 #include <sound/snd_wavefront.h> 53 54 static inline int 55 wf_mpu_status (snd_wavefront_midi_t *midi) 56 57 { 58 return inb (midi->mpu_status_port); 59 } 60 61 static inline int 62 input_avail (snd_wavefront_midi_t *midi) 63 64 { 65 return !(wf_mpu_status(midi) & INPUT_AVAIL); 66 } 67 68 static inline int 69 output_ready (snd_wavefront_midi_t *midi) 70 71 { 72 return !(wf_mpu_status(midi) & OUTPUT_READY); 73 } 74 75 static inline int 76 read_data (snd_wavefront_midi_t *midi) 77 78 { 79 return inb (midi->mpu_data_port); 80 } 81 82 static inline void 83 write_data (snd_wavefront_midi_t *midi, unsigned char byte) 84 85 { 86 outb (byte, midi->mpu_data_port); 87 } 88 89 static snd_wavefront_midi_t * 90 get_wavefront_midi (struct snd_rawmidi_substream *substream) 91 92 { 93 struct snd_card *card; 94 snd_wavefront_card_t *acard; 95 96 if (substream == NULL || substream->rmidi == NULL) 97 return NULL; 98 99 card = substream->rmidi->card; 100 101 if (card == NULL) 102 return NULL; 103 104 if (card->private_data == NULL) 105 return NULL; 106 107 acard = card->private_data; 108 109 return &acard->wavefront.midi; 110 } 111 112 static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card) 113 { 114 snd_wavefront_midi_t *midi = &card->wavefront.midi; 115 snd_wavefront_mpu_id mpu; 116 unsigned long flags; 117 unsigned char midi_byte; 118 int max = 256, mask = 1; 119 int timeout; 120 121 /* Its not OK to try to change the status of "virtuality" of 122 the MIDI interface while we're outputting stuff. See 123 snd_wavefront_midi_{enable,disable}_virtual () for the 124 other half of this. 125 126 The first loop attempts to flush any data from the 127 current output device, and then the second 128 emits the switch byte (if necessary), and starts 129 outputting data for the output device currently in use. 130 */ 131 132 if (midi->substream_output[midi->output_mpu] == NULL) { 133 goto __second; 134 } 135 136 while (max > 0) { 137 138 /* XXX fix me - no hard timing loops allowed! */ 139 140 for (timeout = 30000; timeout > 0; timeout--) { 141 if (output_ready (midi)) 142 break; 143 } 144 145 spin_lock_irqsave (&midi->virtual, flags); 146 if ((midi->mode[midi->output_mpu] & MPU401_MODE_OUTPUT) == 0) { 147 spin_unlock_irqrestore (&midi->virtual, flags); 148 goto __second; 149 } 150 if (output_ready (midi)) { 151 if (snd_rawmidi_transmit(midi->substream_output[midi->output_mpu], &midi_byte, 1) == 1) { 152 if (!midi->isvirtual || 153 (midi_byte != WF_INTERNAL_SWITCH && 154 midi_byte != WF_EXTERNAL_SWITCH)) 155 write_data(midi, midi_byte); 156 max--; 157 } else { 158 if (midi->istimer) { 159 if (--midi->istimer <= 0) 160 del_timer(&midi->timer); 161 } 162 midi->mode[midi->output_mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER; 163 spin_unlock_irqrestore (&midi->virtual, flags); 164 goto __second; 165 } 166 } else { 167 spin_unlock_irqrestore (&midi->virtual, flags); 168 return; 169 } 170 spin_unlock_irqrestore (&midi->virtual, flags); 171 } 172 173 __second: 174 175 if (midi->substream_output[!midi->output_mpu] == NULL) { 176 return; 177 } 178 179 while (max > 0) { 180 181 /* XXX fix me - no hard timing loops allowed! */ 182 183 for (timeout = 30000; timeout > 0; timeout--) { 184 if (output_ready (midi)) 185 break; 186 } 187 188 spin_lock_irqsave (&midi->virtual, flags); 189 if (!midi->isvirtual) 190 mask = 0; 191 mpu = midi->output_mpu ^ mask; 192 mask = 0; /* don't invert the value from now */ 193 if ((midi->mode[mpu] & MPU401_MODE_OUTPUT) == 0) { 194 spin_unlock_irqrestore (&midi->virtual, flags); 195 return; 196 } 197 if (snd_rawmidi_transmit_empty(midi->substream_output[mpu])) 198 goto __timer; 199 if (output_ready (midi)) { 200 if (mpu != midi->output_mpu) { 201 write_data(midi, mpu == internal_mpu ? 202 WF_INTERNAL_SWITCH : 203 WF_EXTERNAL_SWITCH); 204 midi->output_mpu = mpu; 205 } else if (snd_rawmidi_transmit(midi->substream_output[mpu], &midi_byte, 1) == 1) { 206 if (!midi->isvirtual || 207 (midi_byte != WF_INTERNAL_SWITCH && 208 midi_byte != WF_EXTERNAL_SWITCH)) 209 write_data(midi, midi_byte); 210 max--; 211 } else { 212 __timer: 213 if (midi->istimer) { 214 if (--midi->istimer <= 0) 215 del_timer(&midi->timer); 216 } 217 midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER; 218 spin_unlock_irqrestore (&midi->virtual, flags); 219 return; 220 } 221 } else { 222 spin_unlock_irqrestore (&midi->virtual, flags); 223 return; 224 } 225 spin_unlock_irqrestore (&midi->virtual, flags); 226 } 227 } 228 229 static int snd_wavefront_midi_input_open(struct snd_rawmidi_substream *substream) 230 { 231 unsigned long flags; 232 snd_wavefront_midi_t *midi; 233 snd_wavefront_mpu_id mpu; 234 235 if (snd_BUG_ON(!substream || !substream->rmidi)) 236 return -ENXIO; 237 if (snd_BUG_ON(!substream->rmidi->private_data)) 238 return -ENXIO; 239 240 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 241 242 if ((midi = get_wavefront_midi (substream)) == NULL) 243 return -EIO; 244 245 spin_lock_irqsave (&midi->open, flags); 246 midi->mode[mpu] |= MPU401_MODE_INPUT; 247 midi->substream_input[mpu] = substream; 248 spin_unlock_irqrestore (&midi->open, flags); 249 250 return 0; 251 } 252 253 static int snd_wavefront_midi_output_open(struct snd_rawmidi_substream *substream) 254 { 255 unsigned long flags; 256 snd_wavefront_midi_t *midi; 257 snd_wavefront_mpu_id mpu; 258 259 if (snd_BUG_ON(!substream || !substream->rmidi)) 260 return -ENXIO; 261 if (snd_BUG_ON(!substream->rmidi->private_data)) 262 return -ENXIO; 263 264 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 265 266 if ((midi = get_wavefront_midi (substream)) == NULL) 267 return -EIO; 268 269 spin_lock_irqsave (&midi->open, flags); 270 midi->mode[mpu] |= MPU401_MODE_OUTPUT; 271 midi->substream_output[mpu] = substream; 272 spin_unlock_irqrestore (&midi->open, flags); 273 274 return 0; 275 } 276 277 static int snd_wavefront_midi_input_close(struct snd_rawmidi_substream *substream) 278 { 279 unsigned long flags; 280 snd_wavefront_midi_t *midi; 281 snd_wavefront_mpu_id mpu; 282 283 if (snd_BUG_ON(!substream || !substream->rmidi)) 284 return -ENXIO; 285 if (snd_BUG_ON(!substream->rmidi->private_data)) 286 return -ENXIO; 287 288 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 289 290 if ((midi = get_wavefront_midi (substream)) == NULL) 291 return -EIO; 292 293 spin_lock_irqsave (&midi->open, flags); 294 midi->mode[mpu] &= ~MPU401_MODE_INPUT; 295 spin_unlock_irqrestore (&midi->open, flags); 296 297 return 0; 298 } 299 300 static int snd_wavefront_midi_output_close(struct snd_rawmidi_substream *substream) 301 { 302 unsigned long flags; 303 snd_wavefront_midi_t *midi; 304 snd_wavefront_mpu_id mpu; 305 306 if (snd_BUG_ON(!substream || !substream->rmidi)) 307 return -ENXIO; 308 if (snd_BUG_ON(!substream->rmidi->private_data)) 309 return -ENXIO; 310 311 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 312 313 if ((midi = get_wavefront_midi (substream)) == NULL) 314 return -EIO; 315 316 spin_lock_irqsave (&midi->open, flags); 317 midi->mode[mpu] &= ~MPU401_MODE_OUTPUT; 318 spin_unlock_irqrestore (&midi->open, flags); 319 return 0; 320 } 321 322 static void snd_wavefront_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) 323 { 324 unsigned long flags; 325 snd_wavefront_midi_t *midi; 326 snd_wavefront_mpu_id mpu; 327 328 if (substream == NULL || substream->rmidi == NULL) 329 return; 330 331 if (substream->rmidi->private_data == NULL) 332 return; 333 334 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 335 336 if ((midi = get_wavefront_midi (substream)) == NULL) { 337 return; 338 } 339 340 spin_lock_irqsave (&midi->virtual, flags); 341 if (up) { 342 midi->mode[mpu] |= MPU401_MODE_INPUT_TRIGGER; 343 } else { 344 midi->mode[mpu] &= ~MPU401_MODE_INPUT_TRIGGER; 345 } 346 spin_unlock_irqrestore (&midi->virtual, flags); 347 } 348 349 static void snd_wavefront_midi_output_timer(struct timer_list *t) 350 { 351 snd_wavefront_midi_t *midi = from_timer(midi, t, timer); 352 snd_wavefront_card_t *card = midi->timer_card; 353 unsigned long flags; 354 355 spin_lock_irqsave (&midi->virtual, flags); 356 mod_timer(&midi->timer, 1 + jiffies); 357 spin_unlock_irqrestore (&midi->virtual, flags); 358 snd_wavefront_midi_output_write(card); 359 } 360 361 static void snd_wavefront_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) 362 { 363 unsigned long flags; 364 snd_wavefront_midi_t *midi; 365 snd_wavefront_mpu_id mpu; 366 367 if (substream == NULL || substream->rmidi == NULL) 368 return; 369 370 if (substream->rmidi->private_data == NULL) 371 return; 372 373 mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data); 374 375 if ((midi = get_wavefront_midi (substream)) == NULL) { 376 return; 377 } 378 379 spin_lock_irqsave (&midi->virtual, flags); 380 if (up) { 381 if ((midi->mode[mpu] & MPU401_MODE_OUTPUT_TRIGGER) == 0) { 382 if (!midi->istimer) { 383 timer_setup(&midi->timer, 384 snd_wavefront_midi_output_timer, 385 0); 386 mod_timer(&midi->timer, 1 + jiffies); 387 } 388 midi->istimer++; 389 midi->mode[mpu] |= MPU401_MODE_OUTPUT_TRIGGER; 390 } 391 } else { 392 midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER; 393 } 394 spin_unlock_irqrestore (&midi->virtual, flags); 395 396 if (up) 397 snd_wavefront_midi_output_write((snd_wavefront_card_t *)substream->rmidi->card->private_data); 398 } 399 400 void 401 snd_wavefront_midi_interrupt (snd_wavefront_card_t *card) 402 403 { 404 unsigned long flags; 405 snd_wavefront_midi_t *midi; 406 static struct snd_rawmidi_substream *substream = NULL; 407 static int mpu = external_mpu; 408 int max = 128; 409 unsigned char byte; 410 411 midi = &card->wavefront.midi; 412 413 if (!input_avail (midi)) { /* not for us */ 414 snd_wavefront_midi_output_write(card); 415 return; 416 } 417 418 spin_lock_irqsave (&midi->virtual, flags); 419 while (--max) { 420 421 if (input_avail (midi)) { 422 byte = read_data (midi); 423 424 if (midi->isvirtual) { 425 if (byte == WF_EXTERNAL_SWITCH) { 426 substream = midi->substream_input[external_mpu]; 427 mpu = external_mpu; 428 } else if (byte == WF_INTERNAL_SWITCH) { 429 substream = midi->substream_output[internal_mpu]; 430 mpu = internal_mpu; 431 } /* else just leave it as it is */ 432 } else { 433 substream = midi->substream_input[internal_mpu]; 434 mpu = internal_mpu; 435 } 436 437 if (substream == NULL) { 438 continue; 439 } 440 441 if (midi->mode[mpu] & MPU401_MODE_INPUT_TRIGGER) { 442 snd_rawmidi_receive(substream, &byte, 1); 443 } 444 } else { 445 break; 446 } 447 } 448 spin_unlock_irqrestore (&midi->virtual, flags); 449 450 snd_wavefront_midi_output_write(card); 451 } 452 453 void 454 snd_wavefront_midi_enable_virtual (snd_wavefront_card_t *card) 455 456 { 457 unsigned long flags; 458 459 spin_lock_irqsave (&card->wavefront.midi.virtual, flags); 460 card->wavefront.midi.isvirtual = 1; 461 card->wavefront.midi.output_mpu = internal_mpu; 462 card->wavefront.midi.input_mpu = internal_mpu; 463 spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags); 464 } 465 466 void 467 snd_wavefront_midi_disable_virtual (snd_wavefront_card_t *card) 468 469 { 470 unsigned long flags; 471 472 spin_lock_irqsave (&card->wavefront.midi.virtual, flags); 473 // snd_wavefront_midi_input_close (card->ics2115_external_rmidi); 474 // snd_wavefront_midi_output_close (card->ics2115_external_rmidi); 475 card->wavefront.midi.isvirtual = 0; 476 spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags); 477 } 478 479 int 480 snd_wavefront_midi_start (snd_wavefront_card_t *card) 481 482 { 483 int ok, i; 484 unsigned char rbuf[4], wbuf[4]; 485 snd_wavefront_t *dev; 486 snd_wavefront_midi_t *midi; 487 488 dev = &card->wavefront; 489 midi = &dev->midi; 490 491 /* The ICS2115 MPU-401 interface doesn't do anything 492 until its set into UART mode. 493 */ 494 495 /* XXX fix me - no hard timing loops allowed! */ 496 497 for (i = 0; i < 30000 && !output_ready (midi); i++); 498 499 if (!output_ready (midi)) { 500 snd_printk ("MIDI interface not ready for command\n"); 501 return -1; 502 } 503 504 /* Any interrupts received from now on 505 are owned by the MIDI side of things. 506 */ 507 508 dev->interrupts_are_midi = 1; 509 510 outb (UART_MODE_ON, midi->mpu_command_port); 511 512 for (ok = 0, i = 50000; i > 0 && !ok; i--) { 513 if (input_avail (midi)) { 514 if (read_data (midi) == MPU_ACK) { 515 ok = 1; 516 break; 517 } 518 } 519 } 520 521 if (!ok) { 522 snd_printk ("cannot set UART mode for MIDI interface"); 523 dev->interrupts_are_midi = 0; 524 return -1; 525 } 526 527 /* Route external MIDI to WaveFront synth (by default) */ 528 529 if (snd_wavefront_cmd (dev, WFC_MISYNTH_ON, rbuf, wbuf)) { 530 snd_printk ("can't enable MIDI-IN-2-synth routing.\n"); 531 /* XXX error ? */ 532 } 533 534 /* Turn on Virtual MIDI, but first *always* turn it off, 535 since otherwise consecutive reloads of the driver will 536 never cause the hardware to generate the initial "internal" or 537 "external" source bytes in the MIDI data stream. This 538 is pretty important, since the internal hardware generally will 539 be used to generate none or very little MIDI output, and 540 thus the only source of MIDI data is actually external. Without 541 the switch bytes, the driver will think it all comes from 542 the internal interface. Duh. 543 */ 544 545 if (snd_wavefront_cmd (dev, WFC_VMIDI_OFF, rbuf, wbuf)) { 546 snd_printk ("virtual MIDI mode not disabled\n"); 547 return 0; /* We're OK, but missing the external MIDI dev */ 548 } 549 550 snd_wavefront_midi_enable_virtual (card); 551 552 if (snd_wavefront_cmd (dev, WFC_VMIDI_ON, rbuf, wbuf)) { 553 snd_printk ("cannot enable virtual MIDI mode.\n"); 554 snd_wavefront_midi_disable_virtual (card); 555 } 556 return 0; 557 } 558 559 const struct snd_rawmidi_ops snd_wavefront_midi_output = 560 { 561 .open = snd_wavefront_midi_output_open, 562 .close = snd_wavefront_midi_output_close, 563 .trigger = snd_wavefront_midi_output_trigger, 564 }; 565 566 const struct snd_rawmidi_ops snd_wavefront_midi_input = 567 { 568 .open = snd_wavefront_midi_input_open, 569 .close = snd_wavefront_midi_input_close, 570 .trigger = snd_wavefront_midi_input_trigger, 571 }; 572 573