1/* 2 * sound/oss/midi_synth.c 3 * 4 * High level midi sequencer manager for dumb MIDI interfaces. 5 */ 6/* 7 * Copyright (C) by Hannu Savolainen 1993-1997 8 * 9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL) 10 * Version 2 (June 1991). See the "COPYING" file distributed with this software 11 * for more info. 12 */ 13/* 14 * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed) 15 * Andrew Veliath : fixed running status in MIDI input state machine 16 */ 17#define USE_SEQ_MACROS 18#define USE_SIMPLE_MACROS 19 20#include "sound_config.h" 21 22#define _MIDI_SYNTH_C_ 23 24#include "midi_synth.h" 25 26static int midi2synth[MAX_MIDI_DEV]; 27static int sysex_state[MAX_MIDI_DEV] = 28{0}; 29static unsigned char prev_out_status[MAX_MIDI_DEV]; 30 31#define STORE(cmd) \ 32{ \ 33 int len; \ 34 unsigned char obuf[8]; \ 35 cmd; \ 36 seq_input_event(obuf, len); \ 37} 38 39#define _seqbuf obuf 40#define _seqbufptr 0 41#define _SEQ_ADVBUF(x) len=x 42 43void 44do_midi_msg(int synthno, unsigned char *msg, int mlen) 45{ 46 switch (msg[0] & 0xf0) 47 { 48 case 0x90: 49 if (msg[2] != 0) 50 { 51 STORE(SEQ_START_NOTE(synthno, msg[0] & 0x0f, msg[1], msg[2])); 52 break; 53 } 54 msg[2] = 64; 55 56 case 0x80: 57 STORE(SEQ_STOP_NOTE(synthno, msg[0] & 0x0f, msg[1], msg[2])); 58 break; 59 60 case 0xA0: 61 STORE(SEQ_KEY_PRESSURE(synthno, msg[0] & 0x0f, msg[1], msg[2])); 62 break; 63 64 case 0xB0: 65 STORE(SEQ_CONTROL(synthno, msg[0] & 0x0f, 66 msg[1], msg[2])); 67 break; 68 69 case 0xC0: 70 STORE(SEQ_SET_PATCH(synthno, msg[0] & 0x0f, msg[1])); 71 break; 72 73 case 0xD0: 74 STORE(SEQ_CHN_PRESSURE(synthno, msg[0] & 0x0f, msg[1])); 75 break; 76 77 case 0xE0: 78 STORE(SEQ_BENDER(synthno, msg[0] & 0x0f, 79 (msg[1] & 0x7f) | ((msg[2] & 0x7f) << 7))); 80 break; 81 82 default: 83 /* printk( "MPU: Unknown midi channel message %02x\n", msg[0]); */ 84 ; 85 } 86} 87EXPORT_SYMBOL(do_midi_msg); 88 89static void 90midi_outc(int midi_dev, int data) 91{ 92 int timeout; 93 94 for (timeout = 0; timeout < 3200; timeout++) 95 if (midi_devs[midi_dev]->outputc(midi_dev, (unsigned char) (data & 0xff))) 96 { 97 if (data & 0x80) /* 98 * Status byte 99 */ 100 prev_out_status[midi_dev] = 101 (unsigned char) (data & 0xff); /* 102 * Store for running status 103 */ 104 return; /* 105 * Mission complete 106 */ 107 } 108 /* 109 * Sorry! No space on buffers. 110 */ 111 printk("Midi send timed out\n"); 112} 113 114static int 115prefix_cmd(int midi_dev, unsigned char status) 116{ 117 if ((char *) midi_devs[midi_dev]->prefix_cmd == NULL) 118 return 1; 119 120 return midi_devs[midi_dev]->prefix_cmd(midi_dev, status); 121} 122 123static void 124midi_synth_input(int orig_dev, unsigned char data) 125{ 126 int dev; 127 struct midi_input_info *inc; 128 129 static unsigned char len_tab[] = /* # of data bytes following a status 130 */ 131 { 132 2, /* 8x */ 133 2, /* 9x */ 134 2, /* Ax */ 135 2, /* Bx */ 136 1, /* Cx */ 137 1, /* Dx */ 138 2, /* Ex */ 139 0 /* Fx */ 140 }; 141 142 if (orig_dev < 0 || orig_dev > num_midis || midi_devs[orig_dev] == NULL) 143 return; 144 145 if (data == 0xfe) /* Ignore active sensing */ 146 return; 147 148 dev = midi2synth[orig_dev]; 149 inc = &midi_devs[orig_dev]->in_info; 150 151 switch (inc->m_state) 152 { 153 case MST_INIT: 154 if (data & 0x80) /* MIDI status byte */ 155 { 156 if ((data & 0xf0) == 0xf0) /* Common message */ 157 { 158 switch (data) 159 { 160 case 0xf0: /* Sysex */ 161 inc->m_state = MST_SYSEX; 162 break; /* Sysex */ 163 164 case 0xf1: /* MTC quarter frame */ 165 case 0xf3: /* Song select */ 166 inc->m_state = MST_DATA; 167 inc->m_ptr = 1; 168 inc->m_left = 1; 169 inc->m_buf[0] = data; 170 break; 171 172 case 0xf2: /* Song position pointer */ 173 inc->m_state = MST_DATA; 174 inc->m_ptr = 1; 175 inc->m_left = 2; 176 inc->m_buf[0] = data; 177 break; 178 179 default: 180 inc->m_buf[0] = data; 181 inc->m_ptr = 1; 182 do_midi_msg(dev, inc->m_buf, inc->m_ptr); 183 inc->m_ptr = 0; 184 inc->m_left = 0; 185 } 186 } else 187 { 188 inc->m_state = MST_DATA; 189 inc->m_ptr = 1; 190 inc->m_left = len_tab[(data >> 4) - 8]; 191 inc->m_buf[0] = inc->m_prev_status = data; 192 } 193 } else if (inc->m_prev_status & 0x80) { 194 /* Data byte (use running status) */ 195 inc->m_ptr = 2; 196 inc->m_buf[1] = data; 197 inc->m_buf[0] = inc->m_prev_status; 198 inc->m_left = len_tab[(inc->m_buf[0] >> 4) - 8] - 1; 199 if (inc->m_left > 0) 200 inc->m_state = MST_DATA; /* Not done yet */ 201 else { 202 inc->m_state = MST_INIT; 203 do_midi_msg(dev, inc->m_buf, inc->m_ptr); 204 inc->m_ptr = 0; 205 } 206 } 207 break; /* MST_INIT */ 208 209 case MST_DATA: 210 inc->m_buf[inc->m_ptr++] = data; 211 if (--inc->m_left <= 0) 212 { 213 inc->m_state = MST_INIT; 214 do_midi_msg(dev, inc->m_buf, inc->m_ptr); 215 inc->m_ptr = 0; 216 } 217 break; /* MST_DATA */ 218 219 case MST_SYSEX: 220 if (data == 0xf7) /* Sysex end */ 221 { 222 inc->m_state = MST_INIT; 223 inc->m_left = 0; 224 inc->m_ptr = 0; 225 } 226 break; /* MST_SYSEX */ 227 228 default: 229 printk("MIDI%d: Unexpected state %d (%02x)\n", orig_dev, inc->m_state, (int) data); 230 inc->m_state = MST_INIT; 231 } 232} 233 234static void 235leave_sysex(int dev) 236{ 237 int orig_dev = synth_devs[dev]->midi_dev; 238 int timeout = 0; 239 240 if (!sysex_state[dev]) 241 return; 242 243 sysex_state[dev] = 0; 244 245 while (!midi_devs[orig_dev]->outputc(orig_dev, 0xf7) && 246 timeout < 1000) 247 timeout++; 248 249 sysex_state[dev] = 0; 250} 251 252static void 253midi_synth_output(int dev) 254{ 255 /* 256 * Currently NOP 257 */ 258} 259 260int midi_synth_ioctl(int dev, unsigned int cmd, void __user *arg) 261{ 262 /* 263 * int orig_dev = synth_devs[dev]->midi_dev; 264 */ 265 266 switch (cmd) { 267 268 case SNDCTL_SYNTH_INFO: 269 if (__copy_to_user(arg, synth_devs[dev]->info, sizeof(struct synth_info))) 270 return -EFAULT; 271 return 0; 272 273 case SNDCTL_SYNTH_MEMAVL: 274 return 0x7fffffff; 275 276 default: 277 return -EINVAL; 278 } 279} 280EXPORT_SYMBOL(midi_synth_ioctl); 281 282int 283midi_synth_kill_note(int dev, int channel, int note, int velocity) 284{ 285 int orig_dev = synth_devs[dev]->midi_dev; 286 int msg, chn; 287 288 if (note < 0 || note > 127) 289 return 0; 290 if (channel < 0 || channel > 15) 291 return 0; 292 if (velocity < 0) 293 velocity = 0; 294 if (velocity > 127) 295 velocity = 127; 296 297 leave_sysex(dev); 298 299 msg = prev_out_status[orig_dev] & 0xf0; 300 chn = prev_out_status[orig_dev] & 0x0f; 301 302 if (chn == channel && ((msg == 0x90 && velocity == 64) || msg == 0x80)) 303 { /* 304 * Use running status 305 */ 306 if (!prefix_cmd(orig_dev, note)) 307 return 0; 308 309 midi_outc(orig_dev, note); 310 311 if (msg == 0x90) /* 312 * Running status = Note on 313 */ 314 midi_outc(orig_dev, 0); /* 315 * Note on with velocity 0 == note 316 * off 317 */ 318 else 319 midi_outc(orig_dev, velocity); 320 } else 321 { 322 if (velocity == 64) 323 { 324 if (!prefix_cmd(orig_dev, 0x90 | (channel & 0x0f))) 325 return 0; 326 midi_outc(orig_dev, 0x90 | (channel & 0x0f)); /* 327 * Note on 328 */ 329 midi_outc(orig_dev, note); 330 midi_outc(orig_dev, 0); /* 331 * Zero G 332 */ 333 } else 334 { 335 if (!prefix_cmd(orig_dev, 0x80 | (channel & 0x0f))) 336 return 0; 337 midi_outc(orig_dev, 0x80 | (channel & 0x0f)); /* 338 * Note off 339 */ 340 midi_outc(orig_dev, note); 341 midi_outc(orig_dev, velocity); 342 } 343 } 344 345 return 0; 346} 347EXPORT_SYMBOL(midi_synth_kill_note); 348 349int 350midi_synth_set_instr(int dev, int channel, int instr_no) 351{ 352 int orig_dev = synth_devs[dev]->midi_dev; 353 354 if (instr_no < 0 || instr_no > 127) 355 instr_no = 0; 356 if (channel < 0 || channel > 15) 357 return 0; 358 359 leave_sysex(dev); 360 361 if (!prefix_cmd(orig_dev, 0xc0 | (channel & 0x0f))) 362 return 0; 363 midi_outc(orig_dev, 0xc0 | (channel & 0x0f)); /* 364 * Program change 365 */ 366 midi_outc(orig_dev, instr_no); 367 368 return 0; 369} 370EXPORT_SYMBOL(midi_synth_set_instr); 371 372int 373midi_synth_start_note(int dev, int channel, int note, int velocity) 374{ 375 int orig_dev = synth_devs[dev]->midi_dev; 376 int msg, chn; 377 378 if (note < 0 || note > 127) 379 return 0; 380 if (channel < 0 || channel > 15) 381 return 0; 382 if (velocity < 0) 383 velocity = 0; 384 if (velocity > 127) 385 velocity = 127; 386 387 leave_sysex(dev); 388 389 msg = prev_out_status[orig_dev] & 0xf0; 390 chn = prev_out_status[orig_dev] & 0x0f; 391 392 if (chn == channel && msg == 0x90) 393 { /* 394 * Use running status 395 */ 396 if (!prefix_cmd(orig_dev, note)) 397 return 0; 398 midi_outc(orig_dev, note); 399 midi_outc(orig_dev, velocity); 400 } else 401 { 402 if (!prefix_cmd(orig_dev, 0x90 | (channel & 0x0f))) 403 return 0; 404 midi_outc(orig_dev, 0x90 | (channel & 0x0f)); /* 405 * Note on 406 */ 407 midi_outc(orig_dev, note); 408 midi_outc(orig_dev, velocity); 409 } 410 return 0; 411} 412EXPORT_SYMBOL(midi_synth_start_note); 413 414void 415midi_synth_reset(int dev) 416{ 417 418 leave_sysex(dev); 419} 420EXPORT_SYMBOL(midi_synth_reset); 421 422int 423midi_synth_open(int dev, int mode) 424{ 425 int orig_dev = synth_devs[dev]->midi_dev; 426 int err; 427 struct midi_input_info *inc; 428 429 if (orig_dev < 0 || orig_dev >= num_midis || midi_devs[orig_dev] == NULL) 430 return -ENXIO; 431 432 midi2synth[orig_dev] = dev; 433 sysex_state[dev] = 0; 434 prev_out_status[orig_dev] = 0; 435 436 if ((err = midi_devs[orig_dev]->open(orig_dev, mode, 437 midi_synth_input, midi_synth_output)) < 0) 438 return err; 439 inc = &midi_devs[orig_dev]->in_info; 440 441 /* save_flags(flags); 442 cli(); 443 don't know against what irqhandler to protect*/ 444 inc->m_busy = 0; 445 inc->m_state = MST_INIT; 446 inc->m_ptr = 0; 447 inc->m_left = 0; 448 inc->m_prev_status = 0x00; 449 /* restore_flags(flags); */ 450 451 return 1; 452} 453EXPORT_SYMBOL(midi_synth_open); 454 455void 456midi_synth_close(int dev) 457{ 458 int orig_dev = synth_devs[dev]->midi_dev; 459 460 leave_sysex(dev); 461 462 /* 463 * Shut up the synths by sending just single active sensing message. 464 */ 465 midi_devs[orig_dev]->outputc(orig_dev, 0xfe); 466 467 midi_devs[orig_dev]->close(orig_dev); 468} 469EXPORT_SYMBOL(midi_synth_close); 470 471void 472midi_synth_hw_control(int dev, unsigned char *event) 473{ 474} 475EXPORT_SYMBOL(midi_synth_hw_control); 476 477int 478midi_synth_load_patch(int dev, int format, const char __user *addr, 479 int count, int pmgr_flag) 480{ 481 int orig_dev = synth_devs[dev]->midi_dev; 482 483 struct sysex_info sysex; 484 int i; 485 unsigned long left, src_offs, eox_seen = 0; 486 int first_byte = 1; 487 int hdr_size = (unsigned long) &sysex.data[0] - (unsigned long) &sysex; 488 489 leave_sysex(dev); 490 491 if (!prefix_cmd(orig_dev, 0xf0)) 492 return 0; 493 494 /* Invalid patch format */ 495 if (format != SYSEX_PATCH) 496 return -EINVAL; 497 498 /* Patch header too short */ 499 if (count < hdr_size) 500 return -EINVAL; 501 502 count -= hdr_size; 503 504 /* 505 * Copy the header from user space 506 */ 507 508 if (copy_from_user(&sysex, addr, hdr_size)) 509 return -EFAULT; 510 511 /* Sysex record too short */ 512 if ((unsigned)count < (unsigned)sysex.len) 513 sysex.len = count; 514 515 left = sysex.len; 516 src_offs = 0; 517 518 for (i = 0; i < left && !signal_pending(current); i++) 519 { 520 unsigned char data; 521 522 if (get_user(data, 523 (unsigned char __user *)(addr + hdr_size + i))) 524 return -EFAULT; 525 526 eox_seen = (i > 0 && data & 0x80); /* End of sysex */ 527 528 if (eox_seen && data != 0xf7) 529 data = 0xf7; 530 531 if (i == 0) 532 { 533 if (data != 0xf0) 534 { 535 printk(KERN_WARNING "midi_synth: Sysex start missing\n"); 536 return -EINVAL; 537 } 538 } 539 while (!midi_devs[orig_dev]->outputc(orig_dev, (unsigned char) (data & 0xff)) && 540 !signal_pending(current)) 541 schedule(); 542 543 if (!first_byte && data & 0x80) 544 return 0; 545 first_byte = 0; 546 } 547 548 if (!eox_seen) 549 midi_outc(orig_dev, 0xf7); 550 return 0; 551} 552EXPORT_SYMBOL(midi_synth_load_patch); 553 554void midi_synth_panning(int dev, int channel, int pressure) 555{ 556} 557EXPORT_SYMBOL(midi_synth_panning); 558 559void midi_synth_aftertouch(int dev, int channel, int pressure) 560{ 561 int orig_dev = synth_devs[dev]->midi_dev; 562 int msg, chn; 563 564 if (pressure < 0 || pressure > 127) 565 return; 566 if (channel < 0 || channel > 15) 567 return; 568 569 leave_sysex(dev); 570 571 msg = prev_out_status[orig_dev] & 0xf0; 572 chn = prev_out_status[orig_dev] & 0x0f; 573 574 if (msg != 0xd0 || chn != channel) /* 575 * Test for running status 576 */ 577 { 578 if (!prefix_cmd(orig_dev, 0xd0 | (channel & 0x0f))) 579 return; 580 midi_outc(orig_dev, 0xd0 | (channel & 0x0f)); /* 581 * Channel pressure 582 */ 583 } else if (!prefix_cmd(orig_dev, pressure)) 584 return; 585 586 midi_outc(orig_dev, pressure); 587} 588EXPORT_SYMBOL(midi_synth_aftertouch); 589 590void 591midi_synth_controller(int dev, int channel, int ctrl_num, int value) 592{ 593 int orig_dev = synth_devs[dev]->midi_dev; 594 int chn, msg; 595 596 if (ctrl_num < 0 || ctrl_num > 127) 597 return; 598 if (channel < 0 || channel > 15) 599 return; 600 601 leave_sysex(dev); 602 603 msg = prev_out_status[orig_dev] & 0xf0; 604 chn = prev_out_status[orig_dev] & 0x0f; 605 606 if (msg != 0xb0 || chn != channel) 607 { 608 if (!prefix_cmd(orig_dev, 0xb0 | (channel & 0x0f))) 609 return; 610 midi_outc(orig_dev, 0xb0 | (channel & 0x0f)); 611 } else if (!prefix_cmd(orig_dev, ctrl_num)) 612 return; 613 614 midi_outc(orig_dev, ctrl_num); 615 midi_outc(orig_dev, value & 0x7f); 616} 617EXPORT_SYMBOL(midi_synth_controller); 618 619void 620midi_synth_bender(int dev, int channel, int value) 621{ 622 int orig_dev = synth_devs[dev]->midi_dev; 623 int msg, prev_chn; 624 625 if (channel < 0 || channel > 15) 626 return; 627 628 if (value < 0 || value > 16383) 629 return; 630 631 leave_sysex(dev); 632 633 msg = prev_out_status[orig_dev] & 0xf0; 634 prev_chn = prev_out_status[orig_dev] & 0x0f; 635 636 if (msg != 0xd0 || prev_chn != channel) /* 637 * Test for running status 638 */ 639 { 640 if (!prefix_cmd(orig_dev, 0xe0 | (channel & 0x0f))) 641 return; 642 midi_outc(orig_dev, 0xe0 | (channel & 0x0f)); 643 } else if (!prefix_cmd(orig_dev, value & 0x7f)) 644 return; 645 646 midi_outc(orig_dev, value & 0x7f); 647 midi_outc(orig_dev, (value >> 7) & 0x7f); 648} 649EXPORT_SYMBOL(midi_synth_bender); 650 651void 652midi_synth_setup_voice(int dev, int voice, int channel) 653{ 654} 655EXPORT_SYMBOL(midi_synth_setup_voice); 656 657int 658midi_synth_send_sysex(int dev, unsigned char *bytes, int len) 659{ 660 int orig_dev = synth_devs[dev]->midi_dev; 661 int i; 662 663 for (i = 0; i < len; i++) 664 { 665 switch (bytes[i]) 666 { 667 case 0xf0: /* Start sysex */ 668 if (!prefix_cmd(orig_dev, 0xf0)) 669 return 0; 670 sysex_state[dev] = 1; 671 break; 672 673 case 0xf7: /* End sysex */ 674 if (!sysex_state[dev]) /* Orphan sysex end */ 675 return 0; 676 sysex_state[dev] = 0; 677 break; 678 679 default: 680 if (!sysex_state[dev]) 681 return 0; 682 683 if (bytes[i] & 0x80) /* Error. Another message before sysex end */ 684 { 685 bytes[i] = 0xf7; /* Sysex end */ 686 sysex_state[dev] = 0; 687 } 688 } 689 690 if (!midi_devs[orig_dev]->outputc(orig_dev, bytes[i])) 691 { 692/* 693 * Hardware level buffer is full. Abort the sysex message. 694 */ 695 696 int timeout = 0; 697 698 bytes[i] = 0xf7; 699 sysex_state[dev] = 0; 700 701 while (!midi_devs[orig_dev]->outputc(orig_dev, bytes[i]) && 702 timeout < 1000) 703 timeout++; 704 } 705 if (!sysex_state[dev]) 706 return 0; 707 } 708 709 return 0; 710} 711EXPORT_SYMBOL(midi_synth_send_sysex); 712 713