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