sound/oss/midi_synth.c

   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
  26 static int      midi2synth[MAX_MIDI_DEV];
  27 static int      sysex_state[MAX_MIDI_DEV] =
  28 {0};
  29 static 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
  43 void
  44 do_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 }
  87 EXPORT_SYMBOL(do_midi_msg);
  88
  89 static void
  90 midi_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
 114 static int
 115 prefix_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
 123 static void
 124 midi_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
 234 static void
 235 leave_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
 252 static void
 253 midi_synth_output(int dev)
 254 {
 255         /*
 256          * Currently NOP
 257          */
 258 }
 259
 260 int 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 }
 280 EXPORT_SYMBOL(midi_synth_ioctl);
 281
 282 int
 283 midi_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 }
 347 EXPORT_SYMBOL(midi_synth_kill_note);
 348
 349 int
 350 midi_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 }
 370 EXPORT_SYMBOL(midi_synth_set_instr);
 371
 372 int
 373 midi_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 }
 412 EXPORT_SYMBOL(midi_synth_start_note);
 413
 414 void
 415 midi_synth_reset(int dev)
 416 {
 417
 418         leave_sysex(dev);
 419 }
 420 EXPORT_SYMBOL(midi_synth_reset);
 421
 422 int
 423 midi_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 }
 453 EXPORT_SYMBOL(midi_synth_open);
 454
 455 void
 456 midi_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 }
 469 EXPORT_SYMBOL(midi_synth_close);
 470
 471 void
 472 midi_synth_hw_control(int dev, unsigned char *event)
 473 {
 474 }
 475 EXPORT_SYMBOL(midi_synth_hw_control);
 476
 477 int
 478 midi_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 }
 552 EXPORT_SYMBOL(midi_synth_load_patch);
 553
 554 void midi_synth_panning(int dev, int channel, int pressure)
 555 {
 556 }
 557 EXPORT_SYMBOL(midi_synth_panning);
 558
 559 void 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 }
 588 EXPORT_SYMBOL(midi_synth_aftertouch);
 589
 590 void
 591 midi_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 }
 617 EXPORT_SYMBOL(midi_synth_controller);
 618
 619 void
 620 midi_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 }
 649 EXPORT_SYMBOL(midi_synth_bender);
 650
 651 void
 652 midi_synth_setup_voice(int dev, int voice, int channel)
 653 {
 654 }
 655 EXPORT_SYMBOL(midi_synth_setup_voice);
 656
 657 int
 658 midi_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 }
 711 EXPORT_SYMBOL(midi_synth_send_sysex);
 712