LXR linux/sound/oss/midi

   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