drivers/sound/sequencer.c

/* */
This source file includes following definitions.
sequencer_read
sequencer_midi_output
seq_copy_to_input
sequencer_midi_input
seq_input_event
sequencer_write
seq_queue
extended_event
find_voice
alloc_voice
seq_chn_voice_event
seq_chn_common_event
seq_timing_event
seq_local_event
seq_sysex_message
play_event
seq_startplay
reset_controllers
setup_mode2
sequencer_open
seq_drain_midi_queues
sequencer_release
seq_sync
midi_outc
seq_reset
seq_panic
sequencer_ioctl
sequencer_select
sequencer_timer
note_to_freq
compute_finetune
sequencer_init
   1 /*
   2  * sound/sequencer.c
   3  *
   4  * The sequencer personality manager.
   5  *
   6  * Copyright by Hannu Savolainen 1993
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are
  10  * met: 1. Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer. 2.
  12  * Redistributions in binary form must reproduce the above copyright notice,
  13  * this list of conditions and the following disclaimer in the documentation
  14  * and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  20  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29 
  30 #define SEQUENCER_C
  31 #include "sound_config.h"
  32 
  33 #ifdef CONFIG_SEQUENCER
  34 
  35 #include "midi_ctrl.h"
  36 
  37 static int      sequencer_ok = 0;
  38 static struct sound_timer_operations *tmr;
  39 static int      tmr_no = -1;    /* Currently selected timer */
  40 static int      pending_timer = -1;     /* For timer change operation */
  41 
  42 /*
  43  * Local counts for number of synth and MIDI devices. These are initialized
  44  * by the sequencer_open.
  45  */
  46 static int      max_mididev = 0;
  47 static int      max_synthdev = 0;
  48 
  49 /*
  50  * The seq_mode gives the operating mode of the sequencer:
  51  *      1 = level1 (the default)
  52  *      2 = level2 (extended capabilites)
  53  */
  54 
  55 #define SEQ_1   1
  56 #define SEQ_2   2
  57 static int      seq_mode = SEQ_1;
  58 
  59 static wait_handle *seq_sleeper = NULL;
  60 static volatile struct snd_wait seq_sleep_flag =
  61 {0};
  62 static wait_handle *midi_sleeper = NULL;
  63 static volatile struct snd_wait midi_sleep_flag =
  64 {0};
  65 
  66 static int      midi_opened[MAX_MIDI_DEV] =
  67 {0};
  68 static int      midi_written[MAX_MIDI_DEV] =
  69 {0};
  70 
  71 unsigned long   prev_input_time = 0;
  72 int             prev_event_time;
  73 unsigned long   seq_time = 0;
  74 
  75 #include "tuning.h"
  76 
  77 #define EV_SZ   8
  78 #define IEV_SZ  8
  79 static unsigned char *queue = NULL;
  80 static unsigned char *iqueue = NULL;
  81 
  82 static volatile int qhead = 0, qtail = 0, qlen = 0;
  83 static volatile int iqhead = 0, iqtail = 0, iqlen = 0;
  84 static volatile int seq_playing = 0;
  85 static volatile int sequencer_busy = 0;
  86 static int      output_treshold;
  87 static int      pre_event_timeout;
  88 static unsigned synth_open_mask;
  89 
  90 static int      seq_queue (unsigned char *note, char nonblock);
  91 static void     seq_startplay (void);
  92 static int      seq_sync (void);
  93 static void     seq_reset (void);
  94 static int      pmgr_present[MAX_SYNTH_DEV] =
  95 {0};
  96 
  97 #if MAX_SYNTH_DEV > 15
  98 #error Too many synthesizer devices enabled.
  99 #endif
 100 
 101 int
 102 sequencer_read (int dev, struct fileinfo *file, snd_rw_buf * buf, int count)
     /*  */
 103 {
 104   int             c = count, p = 0;
 105   int             ev_len;
 106   unsigned long   flags;
 107 
 108   dev = dev >> 4;
 109 
 110   ev_len = seq_mode == SEQ_1 ? 4 : 8;
 111 
 112   if (dev)                      /*
 113                                  * Patch manager device
 114                                  */
 115     return pmgr_read (dev - 1, file, buf, count);
 116 
 117   save_flags (flags);
 118   cli ();
 119   if (!iqlen)
 120     {
 121       if ((file->flags & (O_NONBLOCK) ?
 122            1 : 0))
 123         {
 124           restore_flags (flags);
 125           return -EAGAIN;
 126         }
 127 
 128 
 129       {
 130         unsigned long   tl;
 131 
 132         if (pre_event_timeout)
 133           current_set_timeout (tl = jiffies + (pre_event_timeout));
 134         else
 135           tl = 0xffffffff;
 136         midi_sleep_flag.mode = WK_SLEEP;
 137         module_interruptible_sleep_on (&midi_sleeper);
 138         if (!(midi_sleep_flag.mode & WK_WAKEUP))
 139           {
 140             if (jiffies >= tl)
 141               midi_sleep_flag.mode |= WK_TIMEOUT;
 142           }
 143         midi_sleep_flag.mode &= ~WK_SLEEP;
 144       };
 145 
 146       if (!iqlen)
 147         {
 148           restore_flags (flags);
 149           return 0;
 150         }
 151     }
 152 
 153   while (iqlen && c >= ev_len)
 154     {
 155 
 156       memcpy_tofs (&((buf)[p]), (char *) &iqueue[iqhead * IEV_SZ], ev_len);
 157       p += ev_len;
 158       c -= ev_len;
 159 
 160       iqhead = (iqhead + 1) % SEQ_MAX_QUEUE;
 161       iqlen--;
 162     }
 163   restore_flags (flags);
 164 
 165   return count - c;
 166 }
 167 
 168 static void
 169 sequencer_midi_output (int dev)
     /*  */
 170 {
 171   /*
 172    * Currently NOP
 173    */
 174 }
 175 
 176 void
 177 seq_copy_to_input (unsigned char *event, int len)
     /*  */
 178 {
 179   unsigned long   flags;
 180 
 181   /*
 182      * Verify that the len is valid for the current mode.
 183    */
 184 
 185   if (len != 4 && len != 8)
 186     return;
 187   if ((seq_mode == SEQ_1) != (len == 4))
 188     return;
 189 
 190   if (iqlen >= (SEQ_MAX_QUEUE - 1))
 191     return;                     /* Overflow */
 192 
 193   save_flags (flags);
 194   cli ();
 195   memcpy (&iqueue[iqtail * IEV_SZ], event, len);
 196   iqlen++;
 197   iqtail = (iqtail + 1) % SEQ_MAX_QUEUE;
 198 
 199   if ((midi_sleep_flag.mode & WK_SLEEP))
 200     {
 201       {
 202         midi_sleep_flag.mode = WK_WAKEUP;
 203         module_wake_up (&midi_sleeper);
 204       };
 205     }
 206   restore_flags (flags);
 207 }
 208 
 209 static void
 210 sequencer_midi_input (int dev, unsigned char data)
     /*  */
 211 {
 212   unsigned int    tstamp;
 213   unsigned char   event[4];
 214 
 215   if (data == 0xfe)             /* Ignore active sensing */
 216     return;
 217 
 218   tstamp = jiffies - seq_time;
 219   if (tstamp != prev_input_time)
 220     {
 221       tstamp = (tstamp << 8) | SEQ_WAIT;
 222 
 223       seq_copy_to_input ((unsigned char *) &tstamp, 4);
 224       prev_input_time = tstamp;
 225     }
 226 
 227   event[0] = SEQ_MIDIPUTC;
 228   event[1] = data;
 229   event[2] = dev;
 230   event[3] = 0;
 231 
 232   seq_copy_to_input (event, 4);
 233 }
 234 
 235 void
 236 seq_input_event (unsigned char *event, int len)
     /*  */
 237 {
 238   unsigned long   this_time;
 239 
 240   if (seq_mode == SEQ_2)
 241     this_time = tmr->get_time (tmr_no);
 242   else
 243     this_time = jiffies - seq_time;
 244 
 245   if (this_time != prev_input_time)
 246     {
 247       unsigned char   tmp_event[8];
 248 
 249       tmp_event[0] = EV_TIMING;
 250       tmp_event[1] = TMR_WAIT_ABS;
 251       tmp_event[2] = 0;
 252       tmp_event[3] = 0;
 253       *(unsigned long *) &tmp_event[4] = this_time;
 254 
 255       seq_copy_to_input (tmp_event, 8);
 256       prev_input_time = this_time;
 257     }
 258 
 259   seq_copy_to_input (event, len);
 260 }
 261 
 262 int
 263 sequencer_write (int dev, struct fileinfo *file, const snd_rw_buf * buf, int count)
     /*  */
 264 {
 265   unsigned char   event[EV_SZ], ev_code;
 266   int             p = 0, c, ev_size;
 267   int             err;
 268   int             mode = file->mode & O_ACCMODE;
 269 
 270   dev = dev >> 4;
 271 
 272   DEB (printk ("sequencer_write(dev=%d, count=%d)\n", dev, count));
 273 
 274   if (mode == OPEN_READ)
 275     return -EIO;
 276 
 277   if (dev)
 278     return pmgr_write (dev - 1, file, buf, count);
 279 
 280   c = count;
 281 
 282   while (c >= 4)
 283     {
 284       memcpy_fromfs ((char *) event, &((buf)[p]), 4);
 285       ev_code = event[0];
 286 
 287       if (ev_code == SEQ_FULLSIZE)
 288         {
 289           int             err;
 290 
 291           dev = *(unsigned short *) &event[2];
 292           if (dev < 0 || dev >= max_synthdev)
 293             return -ENXIO;
 294 
 295           if (!(synth_open_mask & (1 << dev)))
 296             return -ENXIO;
 297 
 298           err = synth_devs[dev]->load_patch (dev, *(short *) &event[0], buf, p + 4, c, 0);
 299           if (err < 0)
 300             return err;
 301 
 302           return err;
 303         }
 304 
 305       if (ev_code >= 128)
 306         {
 307           if (seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED)
 308             {
 309               printk ("Sequencer: Invalid level 2 event %x\n", ev_code);
 310               return -EINVAL;
 311             }
 312 
 313           ev_size = 8;
 314 
 315           if (c < ev_size)
 316             {
 317               if (!seq_playing)
 318                 seq_startplay ();
 319               return count - c;
 320             }
 321 
 322           memcpy_fromfs ((char *) &event[4], &((buf)[p + 4]), 4);
 323 
 324         }
 325       else
 326         {
 327           if (seq_mode == SEQ_2)
 328             {
 329               printk ("Sequencer: 4 byte event in level 2 mode\n");
 330               return -EINVAL;
 331             }
 332           ev_size = 4;
 333         }
 334 
 335       if (event[0] == SEQ_MIDIPUTC)
 336         {
 337 
 338           if (!midi_opened[event[2]])
 339             {
 340               int             mode;
 341               int             dev = event[2];
 342 
 343               if (dev >= max_mididev)
 344                 {
 345                   printk ("Sequencer Error: Nonexistent MIDI device %d\n", dev);
 346                   return -ENXIO;
 347                 }
 348 
 349               mode = file->mode & O_ACCMODE;
 350 
 351               if ((err = midi_devs[dev]->open (dev, mode,
 352                           sequencer_midi_input, sequencer_midi_output)) < 0)
 353                 {
 354                   seq_reset ();
 355                   printk ("Sequencer Error: Unable to open Midi #%d\n", dev);
 356                   return err;
 357                 }
 358 
 359               midi_opened[dev] = 1;
 360             }
 361 
 362         }
 363 
 364       if (!seq_queue (event, (file->flags & (O_NONBLOCK) ?
 365                               1 : 0)))
 366         {
 367           int             processed = count - c;
 368 
 369           if (!seq_playing)
 370             seq_startplay ();
 371 
 372           if (!processed && (file->flags & (O_NONBLOCK) ?
 373                              1 : 0))
 374             return -EAGAIN;
 375           else
 376             return processed;
 377         }
 378 
 379       p += ev_size;
 380       c -= ev_size;
 381     }
 382 
 383   if (!seq_playing)
 384     seq_startplay ();
 385 
 386   return count;                 /* This will "eat" chunks shorter than 4 bytes (if written
 387                                    * alone) Should we really do that ?
 388                                  */
 389 }
 390 
 391 static int
 392 seq_queue (unsigned char *note, char nonblock)
     /*  */
 393 {
 394 
 395   /*
 396    * Test if there is space in the queue
 397    */
 398 
 399   if (qlen >= SEQ_MAX_QUEUE)
 400     if (!seq_playing)
 401       seq_startplay ();         /*
 402                                  * Give chance to drain the queue
 403                                  */
 404 
 405   if (!nonblock && qlen >= SEQ_MAX_QUEUE && !(seq_sleep_flag.mode & WK_SLEEP))
 406     {
 407       /*
 408        * Sleep until there is enough space on the queue
 409        */
 410 
 411       seq_sleep_flag.mode = WK_SLEEP;
 412       module_interruptible_sleep_on (&seq_sleeper);
 413       seq_sleep_flag.mode &= ~WK_SLEEP;;
 414     }
 415 
 416   if (qlen >= SEQ_MAX_QUEUE)
 417     {
 418       return 0;                 /*
 419                                  * To be sure
 420                                  */
 421     }
 422   memcpy (&queue[qtail * EV_SZ], note, EV_SZ);
 423 
 424   qtail = (qtail + 1) % SEQ_MAX_QUEUE;
 425   qlen++;
 426 
 427   return 1;
 428 }
 429 
 430 static int
 431 extended_event (unsigned char *q)
     /*  */
 432 {
 433   int             dev = q[2];
 434 
 435   if (dev < 0 || dev >= max_synthdev)
 436     return -ENXIO;
 437 
 438   if (!(synth_open_mask & (1 << dev)))
 439     return -ENXIO;
 440 
 441   switch (q[1])
 442     {
 443     case SEQ_NOTEOFF:
 444       synth_devs[dev]->kill_note (dev, q[3], q[4], q[5]);
 445       break;
 446 
 447     case SEQ_NOTEON:
 448       if (q[4] > 127 && q[4] != 255)
 449         return 0;
 450 
 451       synth_devs[dev]->start_note (dev, q[3], q[4], q[5]);
 452       break;
 453 
 454     case SEQ_PGMCHANGE:
 455       synth_devs[dev]->set_instr (dev, q[3], q[4]);
 456       break;
 457 
 458     case SEQ_AFTERTOUCH:
 459       synth_devs[dev]->aftertouch (dev, q[3], q[4]);
 460       break;
 461 
 462     case SEQ_BALANCE:
 463       synth_devs[dev]->panning (dev, q[3], (char) q[4]);
 464       break;
 465 
 466     case SEQ_CONTROLLER:
 467       synth_devs[dev]->controller (dev, q[3], q[4], *(short *) &q[5]);
 468       break;
 469 
 470     case SEQ_VOLMODE:
 471       if (synth_devs[dev]->volume_method != NULL)
 472         synth_devs[dev]->volume_method (dev, q[3]);
 473       break;
 474 
 475     default:
 476       return -EINVAL;
 477     }
 478 
 479   return 0;
 480 }
 481 
 482 static int
 483 find_voice (int dev, int chn, int note)
     /*  */
 484 {
 485   unsigned short  key;
 486   int             i;
 487 
 488   key = (chn << 8) | (note + 1);
 489 
 490   for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
 491     if (synth_devs[dev]->alloc.map[i] == key)
 492       return i;
 493 
 494   return -1;
 495 }
 496 
 497 static int
 498 alloc_voice (int dev, int chn, int note)
     /*  */
 499 {
 500   unsigned short  key;
 501   int             voice;
 502 
 503   key = (chn << 8) | (note + 1);
 504 
 505   voice = synth_devs[dev]->alloc_voice (dev, chn, note,
 506                                         &synth_devs[dev]->alloc);
 507   synth_devs[dev]->alloc.map[voice] = key;
 508   synth_devs[dev]->alloc.alloc_times[voice] =
 509     synth_devs[dev]->alloc.timestamp++;
 510   return voice;
 511 }
 512 
 513 static void
 514 seq_chn_voice_event (unsigned char *event)
     /*  */
 515 {
 516   unsigned char   dev = event[1];
 517   unsigned char   cmd = event[2];
 518   unsigned char   chn = event[3];
 519   unsigned char   note = event[4];
 520   unsigned char   parm = event[5];
 521   int             voice = -1;
 522 
 523   if ((int) dev > max_synthdev)
 524     return;
 525   if (!(synth_open_mask & (1 << dev)))
 526     return;
 527   if (!synth_devs[dev])
 528     return;
 529 
 530   if (seq_mode == SEQ_2)
 531     {
 532       if (synth_devs[dev]->alloc_voice)
 533         voice = find_voice (dev, chn, note);
 534 
 535       if (cmd == MIDI_NOTEON && parm == 0)
 536         {
 537           cmd = MIDI_NOTEOFF;
 538           parm = 64;
 539         }
 540     }
 541 
 542   switch (cmd)
 543     {
 544     case MIDI_NOTEON:
 545       if (note > 127 && note != 255)    /* Not a seq2 feature */
 546         return;
 547 
 548       if (voice == -1 && seq_mode == SEQ_2 && synth_devs[dev]->alloc_voice)
 549         {                       /* Internal synthesizer (FM, GUS, etc) */
 550           voice = alloc_voice (dev, chn, note);
 551         }
 552 
 553       if (voice == -1)
 554         voice = chn;
 555 
 556       if (seq_mode == SEQ_2 && (int) dev < num_synths)
 557         {
 558           /*
 559              * The MIDI channel 10 is a percussive channel. Use the note
 560              * number to select the proper patch (128 to 255) to play.
 561            */
 562 
 563           if (chn == 9)
 564             {
 565               synth_devs[dev]->set_instr (dev, voice, 128 + note);
 566               note = 60;        /* Middle C */
 567 
 568             }
 569         }
 570 
 571       if (seq_mode == SEQ_2)
 572         {
 573           synth_devs[dev]->setup_voice (dev, voice, chn);
 574         }
 575 
 576       synth_devs[dev]->start_note (dev, voice, note, parm);
 577       break;
 578 
 579     case MIDI_NOTEOFF:
 580       if (voice == -1)
 581         voice = chn;
 582       synth_devs[dev]->kill_note (dev, voice, note, parm);
 583       break;
 584 
 585     case MIDI_KEY_PRESSURE:
 586       if (voice == -1)
 587         voice = chn;
 588       synth_devs[dev]->aftertouch (dev, voice, parm);
 589       break;
 590 
 591     default:;
 592     }
 593 }
 594 
 595 static void
 596 seq_chn_common_event (unsigned char *event)
     /*  */
 597 {
 598   unsigned char   dev = event[1];
 599   unsigned char   cmd = event[2];
 600   unsigned char   chn = event[3];
 601   unsigned char   p1 = event[4];
 602 
 603   /* unsigned char   p2 = event[5]; */
 604   unsigned short  w14 = *(short *) &event[6];
 605 
 606   if ((int) dev > max_synthdev)
 607     return;
 608   if (!(synth_open_mask & (1 << dev)))
 609     return;
 610   if (!synth_devs[dev])
 611     return;
 612 
 613   switch (cmd)
 614     {
 615     case MIDI_PGM_CHANGE:
 616       if (seq_mode == SEQ_2)
 617         {
 618           synth_devs[dev]->chn_info[chn].pgm_num = p1;
 619           if ((int) dev >= num_synths)
 620             synth_devs[dev]->set_instr (dev, chn, p1);
 621         }
 622       else
 623         synth_devs[dev]->set_instr (dev, chn, p1);
 624 
 625       break;
 626 
 627     case MIDI_CTL_CHANGE:
 628       if (seq_mode == SEQ_2)
 629         {
 630           if (chn > 15 || p1 > 127)
 631             break;
 632 
 633           synth_devs[dev]->chn_info[chn].controllers[p1] = w14 & 0x7f;
 634 
 635           if (p1 < 32)          /* Setting MSB should clear LSB to 0 */
 636             synth_devs[dev]->chn_info[chn].controllers[p1 + 32] = 0;
 637 
 638           if ((int) dev < num_synths)
 639             {
 640               int             val = w14 & 0x7f;
 641               int             i, key;
 642 
 643               if (p1 < 64)      /* Combine MSB and LSB */
 644                 {
 645                   val = ((synth_devs[dev]->
 646                           chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
 647                     | (synth_devs[dev]->
 648                        chn_info[chn].controllers[p1 | 32] & 0x7f);
 649                   p1 &= ~32;
 650                 }
 651 
 652               /* Handle all playing notes on this channel */
 653 
 654               key = ((int) chn << 8);
 655 
 656               for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
 657                 if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
 658                   synth_devs[dev]->controller (dev, i, p1, val);
 659             }
 660           else
 661             synth_devs[dev]->controller (dev, chn, p1, w14);
 662         }
 663       else                      /* Mode 1 */
 664         synth_devs[dev]->controller (dev, chn, p1, w14);
 665       break;
 666 
 667     case MIDI_PITCH_BEND:
 668       if (seq_mode == SEQ_2)
 669         {
 670           synth_devs[dev]->chn_info[chn].bender_value = w14;
 671 
 672           if ((int) dev < num_synths)
 673             {                   /* Handle all playing notes on this channel */
 674               int             i, key;
 675 
 676               key = (chn << 8);
 677 
 678               for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
 679                 if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
 680                   synth_devs[dev]->bender (dev, i, w14);
 681             }
 682           else
 683             synth_devs[dev]->bender (dev, chn, w14);
 684         }
 685       else                      /* MODE 1 */
 686         synth_devs[dev]->bender (dev, chn, w14);
 687       break;
 688 
 689     default:;
 690     }
 691 }
 692 
 693 static int
 694 seq_timing_event (unsigned char *event)
     /*  */
 695 {
 696   unsigned char   cmd = event[1];
 697   unsigned int    parm = *(int *) &event[4];
 698 
 699   if (seq_mode == SEQ_2)
 700     {
 701       int             ret;
 702 
 703       if ((ret = tmr->event (tmr_no, event)) == TIMER_ARMED)
 704         {
 705           if ((SEQ_MAX_QUEUE - qlen) >= output_treshold)
 706             {
 707               unsigned long   flags;
 708 
 709               save_flags (flags);
 710               cli ();
 711               if ((seq_sleep_flag.mode & WK_SLEEP))
 712                 {
 713                   {
 714                     seq_sleep_flag.mode = WK_WAKEUP;
 715                     module_wake_up (&seq_sleeper);
 716                   };
 717                 }
 718               restore_flags (flags);
 719             }
 720         }
 721       return ret;
 722     }
 723 
 724   switch (cmd)
 725     {
 726     case TMR_WAIT_REL:
 727       parm += prev_event_time;
 728 
 729       /*
 730          * NOTE!  No break here. Execution of TMR_WAIT_REL continues in the
 731          * next case (TMR_WAIT_ABS)
 732        */
 733 
 734     case TMR_WAIT_ABS:
 735       if (parm > 0)
 736         {
 737           long            time;
 738 
 739           seq_playing = 1;
 740           time = parm;
 741           prev_event_time = time;
 742 
 743           request_sound_timer (time);
 744 
 745           if ((SEQ_MAX_QUEUE - qlen) >= output_treshold)
 746             {
 747               unsigned long   flags;
 748 
 749               save_flags (flags);
 750               cli ();
 751               if ((seq_sleep_flag.mode & WK_SLEEP))
 752                 {
 753                   {
 754                     seq_sleep_flag.mode = WK_WAKEUP;
 755                     module_wake_up (&seq_sleeper);
 756                   };
 757                 }
 758               restore_flags (flags);
 759             }
 760 
 761           return TIMER_ARMED;
 762         }
 763       break;
 764 
 765     case TMR_START:
 766       seq_time = jiffies;
 767       prev_input_time = 0;
 768       prev_event_time = 0;
 769       break;
 770 
 771     case TMR_STOP:
 772       break;
 773 
 774     case TMR_CONTINUE:
 775       break;
 776 
 777     case TMR_TEMPO:
 778       break;
 779 
 780     case TMR_ECHO:
 781       if (seq_mode == SEQ_2)
 782         seq_copy_to_input (event, 8);
 783       else
 784         {
 785           parm = (parm << 8 | SEQ_ECHO);
 786           seq_copy_to_input ((unsigned char *) &parm, 4);
 787         }
 788       break;
 789 
 790     default:;
 791     }
 792 
 793   return TIMER_NOT_ARMED;
 794 }
 795 
 796 static void
 797 seq_local_event (unsigned char *event)
     /*  */
 798 {
 799   unsigned char   cmd = event[1];
 800   unsigned int    parm = *((unsigned int *) &event[4]);
 801 
 802   switch (cmd)
 803     {
 804     case LOCL_STARTAUDIO:
 805 #ifdef CONFIG_AUDIO
 806       DMAbuf_start_devices (parm);
 807 #endif
 808       break;
 809 
 810     default:;
 811     }
 812 }
 813 
 814 static void
 815 seq_sysex_message (unsigned char *event)
     /*  */
 816 {
 817   int             dev = event[1];
 818   int             i, l = 0;
 819   unsigned char  *buf = &event[2];
 820 
 821   if ((int) dev > max_synthdev)
 822     return;
 823   if (!(synth_open_mask & (1 << dev)))
 824     return;
 825   if (!synth_devs[dev])
 826     return;
 827   if (!synth_devs[dev]->send_sysex)
 828     return;
 829 
 830   l = 0;
 831   for (i = 0; i < 6 && buf[i] != 0xff; i++)
 832     l = i + 1;
 833 
 834   if (l > 0)
 835     synth_devs[dev]->send_sysex (dev, buf, l);
 836 }
 837 
 838 static int
 839 play_event (unsigned char *q)
     /*  */
 840 {
 841   /*
 842      * NOTE! This routine returns
 843      *   0 = normal event played.
 844      *   1 = Timer armed. Suspend playback until timer callback.
 845      *   2 = MIDI output buffer full. Restore queue and suspend until timer
 846    */
 847   unsigned long  *delay;
 848 
 849   switch (q[0])
 850     {
 851     case SEQ_NOTEOFF:
 852       if (synth_open_mask & (1 << 0))
 853         if (synth_devs[0])
 854           synth_devs[0]->kill_note (0, q[1], 255, q[3]);
 855       break;
 856 
 857     case SEQ_NOTEON:
 858       if (q[4] < 128 || q[4] == 255)
 859         if (synth_open_mask & (1 << 0))
 860           if (synth_devs[0])
 861             synth_devs[0]->start_note (0, q[1], q[2], q[3]);
 862       break;
 863 
 864     case SEQ_WAIT:
 865       delay = (unsigned long *) q;      /*
 866                                          * Bytes 1 to 3 are containing the *
 867                                          * delay in jiffies
 868                                          */
 869       *delay = (*delay >> 8) & 0xffffff;
 870 
 871       if (*delay > 0)
 872         {
 873           long            time;
 874 
 875           seq_playing = 1;
 876           time = *delay;
 877           prev_event_time = time;
 878 
 879           request_sound_timer (time);
 880 
 881           if ((SEQ_MAX_QUEUE - qlen) >= output_treshold)
 882             {
 883               unsigned long   flags;
 884 
 885               save_flags (flags);
 886               cli ();
 887               if ((seq_sleep_flag.mode & WK_SLEEP))
 888                 {
 889                   {
 890                     seq_sleep_flag.mode = WK_WAKEUP;
 891                     module_wake_up (&seq_sleeper);
 892                   };
 893                 }
 894               restore_flags (flags);
 895             }
 896           /*
 897              * The timer is now active and will reinvoke this function
 898              * after the timer expires. Return to the caller now.
 899            */
 900           return 1;
 901         }
 902       break;
 903 
 904     case SEQ_PGMCHANGE:
 905       if (synth_open_mask & (1 << 0))
 906         if (synth_devs[0])
 907           synth_devs[0]->set_instr (0, q[1], q[2]);
 908       break;
 909 
 910     case SEQ_SYNCTIMER: /*
 911                                    * Reset timer
 912                                  */
 913       seq_time = jiffies;
 914       prev_input_time = 0;
 915       prev_event_time = 0;
 916       break;
 917 
 918     case SEQ_MIDIPUTC:          /*
 919                                  * Put a midi character
 920                                  */
 921       if (midi_opened[q[2]])
 922         {
 923           int             dev;
 924 
 925           dev = q[2];
 926 
 927           if (!midi_devs[dev]->putc (dev, q[1]))
 928             {
 929               /*
 930                  * Output FIFO is full. Wait one timer cycle and try again.
 931                */
 932 
 933               seq_playing = 1;
 934               request_sound_timer (-1);
 935               return 2;
 936             }
 937           else
 938             midi_written[dev] = 1;
 939         }
 940       break;
 941 
 942     case SEQ_ECHO:
 943       seq_copy_to_input (q, 4); /*
 944                                    * Echo back to the process
 945                                  */
 946       break;
 947 
 948     case SEQ_PRIVATE:
 949       if ((int) q[1] < max_synthdev)
 950         synth_devs[q[1]]->hw_control (q[1], q);
 951       break;
 952 
 953     case SEQ_EXTENDED:
 954       extended_event (q);
 955       break;
 956 
 957     case EV_CHN_VOICE:
 958       seq_chn_voice_event (q);
 959       break;
 960 
 961     case EV_CHN_COMMON:
 962       seq_chn_common_event (q);
 963       break;
 964 
 965     case EV_TIMING:
 966       if (seq_timing_event (q) == TIMER_ARMED)
 967         {
 968           return 1;
 969         }
 970       break;
 971 
 972     case EV_SEQ_LOCAL:
 973       seq_local_event (q);
 974       break;
 975 
 976     case EV_SYSEX:
 977       seq_sysex_message (q);
 978       break;
 979 
 980     default:;
 981     }
 982 
 983   return 0;
 984 }
 985 
 986 static void
 987 seq_startplay (void)
     /*  */
 988 {
 989   unsigned long   flags;
 990   int             this_one, action;
 991 
 992   while (qlen > 0)
 993     {
 994 
 995       save_flags (flags);
 996       cli ();
 997       qhead = ((this_one = qhead) + 1) % SEQ_MAX_QUEUE;
 998       qlen--;
 999       restore_flags (flags);
1000 
1001       seq_playing = 1;
1002 
1003       if ((action = play_event (&queue[this_one * EV_SZ])))
1004         {                       /* Suspend playback. Next timer routine invokes this routine again */
1005           if (action == 2)
1006             {
1007               qlen++;
1008               qhead = this_one;
1009             }
1010           return;
1011         }
1012 
1013     }
1014 
1015   seq_playing = 0;
1016 
1017   if ((SEQ_MAX_QUEUE - qlen) >= output_treshold)
1018     {
1019       unsigned long   flags;
1020 
1021       save_flags (flags);
1022       cli ();
1023       if ((seq_sleep_flag.mode & WK_SLEEP))
1024         {
1025           {
1026             seq_sleep_flag.mode = WK_WAKEUP;
1027             module_wake_up (&seq_sleeper);
1028           };
1029         }
1030       restore_flags (flags);
1031     }
1032 }
1033 
1034 static void
1035 reset_controllers (int dev, unsigned char *controller, int update_dev)
     /*  */
1036 {
1037 
1038   int             i;
1039 
1040   for (i = 0; i < 128; i++)
1041     controller[i] = ctrl_def_values[i];
1042 }
1043 
1044 static void
1045 setup_mode2 (void)
     /*  */
1046 {
1047   int             dev;
1048 
1049   max_synthdev = num_synths;
1050 
1051   for (dev = 0; dev < num_midis; dev++)
1052     if (midi_devs[dev]->converter != NULL)
1053       {
1054         synth_devs[max_synthdev++] =
1055           midi_devs[dev]->converter;
1056       }
1057 
1058   for (dev = 0; dev < max_synthdev; dev++)
1059     {
1060       int             chn;
1061 
1062       for (chn = 0; chn < 16; chn++)
1063         {
1064           synth_devs[dev]->chn_info[chn].pgm_num = 0;
1065           reset_controllers (dev,
1066                              synth_devs[dev]->chn_info[chn].controllers,
1067                              0);
1068           synth_devs[dev]->chn_info[chn].bender_value = (1 << 7);       /* Neutral */
1069         }
1070     }
1071 
1072   max_mididev = 0;
1073   seq_mode = SEQ_2;
1074 }
1075 
1076 int
1077 sequencer_open (int dev, struct fileinfo *file)
     /*  */
1078 {
1079   int             retval, mode, i;
1080   int             level, tmp;
1081   unsigned long   flags;
1082 
1083   level = ((dev & 0x0f) == SND_DEV_SEQ2) ? 2 : 1;
1084 
1085   dev = dev >> 4;
1086   mode = file->mode & O_ACCMODE;
1087 
1088   DEB (printk ("sequencer_open(dev=%d)\n", dev));
1089 
1090   if (!sequencer_ok)
1091     {
1092       printk ("Soundcard: Sequencer not initialized\n");
1093       return -ENXIO;
1094     }
1095 
1096   if (dev)                      /* Patch manager device */
1097     {
1098       int             err;
1099 
1100       printk ("Patch manager interface is currently broken. Sorry\n");
1101       return -ENXIO;
1102 
1103       dev--;
1104 
1105       if (dev >= MAX_SYNTH_DEV)
1106         return -ENXIO;
1107       if (pmgr_present[dev])
1108         return -EBUSY;
1109       if ((err = pmgr_open (dev)) < 0)
1110         return err;
1111 
1112       pmgr_present[dev] = 1;
1113       return err;
1114     }
1115 
1116   save_flags (flags);
1117   cli ();
1118   if (sequencer_busy)
1119     {
1120       printk ("Sequencer busy\n");
1121       restore_flags (flags);
1122       return -EBUSY;
1123     }
1124   sequencer_busy = 1;
1125   restore_flags (flags);
1126 
1127   max_mididev = num_midis;
1128   max_synthdev = num_synths;
1129   pre_event_timeout = 0;
1130   seq_mode = SEQ_1;
1131 
1132   if (pending_timer != -1)
1133     {
1134       tmr_no = pending_timer;
1135       pending_timer = -1;
1136     }
1137 
1138   if (tmr_no == -1)             /* Not selected yet */
1139     {
1140       int             i, best;
1141 
1142       best = -1;
1143       for (i = 0; i < num_sound_timers; i++)
1144         if (sound_timer_devs[i]->priority > best)
1145           {
1146             tmr_no = i;
1147             best = sound_timer_devs[i]->priority;
1148           }
1149 
1150       if (tmr_no == -1)         /* Should not be */
1151         tmr_no = 0;
1152     }
1153 
1154   tmr = sound_timer_devs[tmr_no];
1155 
1156   if (level == 2)
1157     {
1158       if (tmr == NULL)
1159         {
1160           printk ("sequencer: No timer for level 2\n");
1161           sequencer_busy = 0;
1162           return -ENXIO;
1163         }
1164       setup_mode2 ();
1165     }
1166 
1167   if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
1168     if (!max_mididev)
1169       {
1170         printk ("Sequencer: No Midi devices. Input not possible\n");
1171         sequencer_busy = 0;
1172         return -ENXIO;
1173       }
1174 
1175   if (!max_synthdev && !max_mididev)
1176     return -ENXIO;
1177 
1178   synth_open_mask = 0;
1179 
1180   for (i = 0; i < max_mididev; i++)
1181     {
1182       midi_opened[i] = 0;
1183       midi_written[i] = 0;
1184     }
1185 
1186   /*
1187    * if (mode == OPEN_WRITE || mode == OPEN_READWRITE)
1188    */
1189   for (i = 0; i < max_synthdev; i++)    /*
1190                                          * Open synth devices
1191                                          */
1192     if ((tmp = synth_devs[i]->open (i, mode)) < 0)
1193       {
1194         printk ("Sequencer: Warning! Cannot open synth device #%d (%d)\n", i, tmp);
1195         if (synth_devs[i]->midi_dev)
1196           printk ("(Maps to MIDI dev #%d)\n", synth_devs[i]->midi_dev);
1197       }
1198     else
1199       {
1200         synth_open_mask |= (1 << i);
1201         if (synth_devs[i]->midi_dev)    /*
1202                                          * Is a midi interface
1203                                          */
1204           midi_opened[synth_devs[i]->midi_dev] = 1;
1205       }
1206 
1207   seq_time = jiffies;
1208   prev_input_time = 0;
1209   prev_event_time = 0;
1210 
1211   if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
1212     {                           /*
1213                                  * Initialize midi input devices
1214                                  */
1215       for (i = 0; i < max_mididev; i++)
1216         if (!midi_opened[i])
1217           {
1218             if ((retval = midi_devs[i]->open (i, mode,
1219                          sequencer_midi_input, sequencer_midi_output)) >= 0)
1220               midi_opened[i] = 1;
1221           }
1222     }
1223 
1224   if (seq_mode == SEQ_2)
1225     {
1226       tmr->open (tmr_no, seq_mode);
1227     }
1228 
1229   seq_sleep_flag.mode = WK_NONE;
1230   midi_sleep_flag.mode = WK_NONE;
1231   output_treshold = SEQ_MAX_QUEUE / 2;
1232 
1233   for (i = 0; i < num_synths; i++)
1234     if (pmgr_present[i])
1235       pmgr_inform (i, PM_E_OPENED, 0, 0, 0, 0);
1236 
1237   return 0;
1238 }
1239 
1240 void
1241 seq_drain_midi_queues (void)
     /*  */
1242 {
1243   int             i, n;
1244 
1245   /*
1246    * Give the Midi drivers time to drain their output queues
1247    */
1248 
1249   n = 1;
1250 
1251   while (!current_got_fatal_signal () && n)
1252     {
1253       n = 0;
1254 
1255       for (i = 0; i < max_mididev; i++)
1256         if (midi_opened[i] && midi_written[i])
1257           if (midi_devs[i]->buffer_status != NULL)
1258             if (midi_devs[i]->buffer_status (i))
1259               n++;
1260 
1261       /*
1262        * Let's have a delay
1263        */
1264       if (n)
1265         {
1266 
1267           {
1268             unsigned long   tl;
1269 
1270             if (HZ / 10)
1271               current_set_timeout (tl = jiffies + (HZ / 10));
1272             else
1273               tl = 0xffffffff;
1274             seq_sleep_flag.mode = WK_SLEEP;
1275             module_interruptible_sleep_on (&seq_sleeper);
1276             if (!(seq_sleep_flag.mode & WK_WAKEUP))
1277               {
1278                 if (jiffies >= tl)
1279                   seq_sleep_flag.mode |= WK_TIMEOUT;
1280               }
1281             seq_sleep_flag.mode &= ~WK_SLEEP;
1282           };
1283         }
1284     }
1285 }
1286 
1287 void
1288 sequencer_release (int dev, struct fileinfo *file)
     /*  */
1289 {
1290   int             i;
1291   int             mode = file->mode & O_ACCMODE;
1292 
1293   dev = dev >> 4;
1294 
1295   DEB (printk ("sequencer_release(dev=%d)\n", dev));
1296 
1297   if (dev)                      /*
1298                                  * Patch manager device
1299                                  */
1300     {
1301       dev--;
1302       pmgr_release (dev);
1303       pmgr_present[dev] = 0;
1304       return;
1305     }
1306 
1307   /*
1308    * * Wait until the queue is empty (if we don't have nonblock)
1309    */
1310 
1311   if (mode != OPEN_READ && !(file->flags & (O_NONBLOCK) ?
1312                              1 : 0))
1313     while (!current_got_fatal_signal () && qlen)
1314       {
1315         seq_sync ();
1316       }
1317 
1318   if (mode != OPEN_READ)
1319     seq_drain_midi_queues ();   /*
1320                                  * Ensure the output queues are empty
1321                                  */
1322   seq_reset ();
1323   if (mode != OPEN_READ)
1324     seq_drain_midi_queues ();   /*
1325                                  * Flush the all notes off messages
1326                                  */
1327 
1328   for (i = 0; i < max_synthdev; i++)
1329     if (synth_open_mask & (1 << i))     /*
1330                                          * Actually opened
1331                                          */
1332       if (synth_devs[i])
1333         {
1334           synth_devs[i]->close (i);
1335 
1336           if (synth_devs[i]->midi_dev)
1337             midi_opened[synth_devs[i]->midi_dev] = 0;
1338         }
1339 
1340   for (i = 0; i < num_synths; i++)
1341     if (pmgr_present[i])
1342       pmgr_inform (i, PM_E_CLOSED, 0, 0, 0, 0);
1343 
1344   for (i = 0; i < max_mididev; i++)
1345     if (midi_opened[i])
1346       midi_devs[i]->close (i);
1347 
1348   if (seq_mode == SEQ_2)
1349     tmr->close (tmr_no);
1350 
1351   sequencer_busy = 0;
1352 }
1353 
1354 static int
1355 seq_sync (void)
     /*  */
1356 {
1357   unsigned long   flags;
1358 
1359   if (qlen && !seq_playing && !current_got_fatal_signal ())
1360     seq_startplay ();
1361 
1362   save_flags (flags);
1363   cli ();
1364   if (qlen && !(seq_sleep_flag.mode & WK_SLEEP))
1365     {
1366 
1367       {
1368         unsigned long   tl;
1369 
1370         if (HZ)
1371           current_set_timeout (tl = jiffies + (HZ));
1372         else
1373           tl = 0xffffffff;
1374         seq_sleep_flag.mode = WK_SLEEP;
1375         module_interruptible_sleep_on (&seq_sleeper);
1376         if (!(seq_sleep_flag.mode & WK_WAKEUP))
1377           {
1378             if (jiffies >= tl)
1379               seq_sleep_flag.mode |= WK_TIMEOUT;
1380           }
1381         seq_sleep_flag.mode &= ~WK_SLEEP;
1382       };
1383     }
1384   restore_flags (flags);
1385 
1386   return qlen;
1387 }
1388 
1389 static void
1390 midi_outc (int dev, unsigned char data)
     /*  */
1391 {
1392   /*
1393    * NOTE! Calls sleep(). Don't call this from interrupt.
1394    */
1395 
1396   int             n;
1397   unsigned long   flags;
1398 
1399   /*
1400    * This routine sends one byte to the Midi channel.
1401    * If the output Fifo is full, it waits until there
1402    * is space in the queue
1403    */
1404 
1405   n = 3 * HZ;                   /* Timeout */
1406 
1407   save_flags (flags);
1408   cli ();
1409   while (n && !midi_devs[dev]->putc (dev, data))
1410     {
1411 
1412       {
1413         unsigned long   tl;
1414 
1415         if (4)
1416           current_set_timeout (tl = jiffies + (4));
1417         else
1418           tl = 0xffffffff;
1419         seq_sleep_flag.mode = WK_SLEEP;
1420         module_interruptible_sleep_on (&seq_sleeper);
1421         if (!(seq_sleep_flag.mode & WK_WAKEUP))
1422           {
1423             if (jiffies >= tl)
1424               seq_sleep_flag.mode |= WK_TIMEOUT;
1425           }
1426         seq_sleep_flag.mode &= ~WK_SLEEP;
1427       };
1428       n--;
1429     }
1430   restore_flags (flags);
1431 }
1432 
1433 static void
1434 seq_reset (void)
     /*  */
1435 {
1436   /*
1437    * NOTE! Calls sleep(). Don't call this from interrupt.
1438    */
1439 
1440   int             i;
1441   int             chn;
1442   unsigned long   flags;
1443 
1444   sound_stop_timer ();
1445   seq_time = jiffies;
1446   prev_input_time = 0;
1447   prev_event_time = 0;
1448 
1449   qlen = qhead = qtail = 0;
1450   iqlen = iqhead = iqtail = 0;
1451 
1452   for (i = 0; i < max_synthdev; i++)
1453     if (synth_open_mask & (1 << i))
1454       if (synth_devs[i])
1455         synth_devs[i]->reset (i);
1456 
1457   if (seq_mode == SEQ_2)
1458     {
1459 
1460       for (chn = 0; chn < 16; chn++)
1461         for (i = 0; i < max_synthdev; i++)
1462           if (synth_open_mask & (1 << i))
1463             if (synth_devs[i])
1464               {
1465                 synth_devs[i]->controller (i, chn, 123, 0);     /* All notes off */
1466                 synth_devs[i]->controller (i, chn, 121, 0);     /* Reset all ctl */
1467                 synth_devs[i]->bender (i, chn, 1 << 13);        /* Bender off */
1468               }
1469 
1470     }
1471   else
1472     /* seq_mode == SEQ_1 */
1473     {
1474       for (i = 0; i < max_mididev; i++)
1475         if (midi_written[i])    /*
1476                                  * Midi used. Some notes may still be playing
1477                                  */
1478           {
1479             /*
1480                *      Sending just a ACTIVE SENSING message should be enough to stop all
1481                *      playing notes. Since there are devices not recognizing the
1482                *      active sensing, we have to send some all notes off messages also.
1483              */
1484             midi_outc (i, 0xfe);
1485 
1486             for (chn = 0; chn < 16; chn++)
1487               {
1488                 midi_outc (i,
1489                            (unsigned char) (0xb0 + (chn & 0x0f)));      /* control change */
1490                 midi_outc (i, 0x7b);    /* All notes off */
1491                 midi_outc (i, 0);       /* Dummy parameter */
1492               }
1493 
1494             midi_devs[i]->close (i);
1495 
1496             midi_written[i] = 0;
1497             midi_opened[i] = 0;
1498           }
1499     }
1500 
1501   seq_playing = 0;
1502 
1503   save_flags (flags);
1504   cli ();
1505   if ((seq_sleep_flag.mode & WK_SLEEP))
1506     {
1507       /*      printk ("Sequencer Warning: Unexpected sleeping process - Waking up\n"); */
1508       {
1509         seq_sleep_flag.mode = WK_WAKEUP;
1510         module_wake_up (&seq_sleeper);
1511       };
1512     }
1513   restore_flags (flags);
1514 
1515 }
1516 
1517 static void
1518 seq_panic (void)
     /*  */
1519 {
1520   /*
1521      * This routine is called by the application in case the user
1522      * wants to reset the system to the default state.
1523    */
1524 
1525   seq_reset ();
1526 
1527   /*
1528      * Since some of the devices don't recognize the active sensing and
1529      * all notes off messages, we have to shut all notes manually.
1530      *
1531      *      TO BE IMPLEMENTED LATER
1532    */
1533 
1534   /*
1535      * Also return the controllers to their default states
1536    */
1537 }
1538 
1539 int
1540 sequencer_ioctl (int dev, struct fileinfo *file,
     /*  */
1541                  unsigned int cmd, ioctl_arg arg)
1542 {
1543   int             midi_dev, orig_dev;
1544   int             mode = file->mode & O_ACCMODE;
1545 
1546   orig_dev = dev = dev >> 4;
1547 
1548   switch (cmd)
1549     {
1550     case SNDCTL_TMR_TIMEBASE:
1551     case SNDCTL_TMR_TEMPO:
1552     case SNDCTL_TMR_START:
1553     case SNDCTL_TMR_STOP:
1554     case SNDCTL_TMR_CONTINUE:
1555     case SNDCTL_TMR_METRONOME:
1556     case SNDCTL_TMR_SOURCE:
1557       if (dev)                  /* Patch manager */
1558         return -EIO;
1559 
1560       if (seq_mode != SEQ_2)
1561         return -EINVAL;
1562       return tmr->ioctl (tmr_no, cmd, arg);
1563       break;
1564 
1565     case SNDCTL_TMR_SELECT:
1566       if (dev)                  /* Patch manager */
1567         return -EIO;
1568 
1569       if (seq_mode != SEQ_2)
1570         return -EINVAL;
1571       pending_timer = get_fs_long ((long *) arg);
1572 
1573       if (pending_timer < 0 || pending_timer >= num_sound_timers)
1574         {
1575           pending_timer = -1;
1576           return -EINVAL;
1577         }
1578 
1579       return snd_ioctl_return ((int *) arg, pending_timer);
1580       break;
1581 
1582     case SNDCTL_SEQ_PANIC:
1583       seq_panic ();
1584       break;
1585 
1586     case SNDCTL_SEQ_SYNC:
1587       if (dev)                  /*
1588                                  * Patch manager
1589                                  */
1590         return -EIO;
1591 
1592       if (mode == OPEN_READ)
1593         return 0;
1594       while (qlen && !current_got_fatal_signal ())
1595         seq_sync ();
1596       if (qlen)
1597         return -EINTR;
1598       else
1599         return 0;
1600       break;
1601 
1602     case SNDCTL_SEQ_RESET:
1603       if (dev)                  /*
1604                                  * Patch manager
1605                                  */
1606         return -EIO;
1607 
1608       seq_reset ();
1609       return 0;
1610       break;
1611 
1612     case SNDCTL_SEQ_TESTMIDI:
1613       if (dev)                  /*
1614                                  * Patch manager
1615                                  */
1616         return -EIO;
1617 
1618       midi_dev = get_fs_long ((long *) arg);
1619       if (midi_dev >= max_mididev)
1620         return -ENXIO;
1621 
1622       if (!midi_opened[midi_dev])
1623         {
1624           int             err, mode;
1625 
1626           mode = file->mode & O_ACCMODE;
1627           if ((err = midi_devs[midi_dev]->open (midi_dev, mode,
1628                                                 sequencer_midi_input,
1629                                                 sequencer_midi_output)) < 0)
1630             return err;
1631         }
1632 
1633       midi_opened[midi_dev] = 1;
1634 
1635       return 0;
1636       break;
1637 
1638     case SNDCTL_SEQ_GETINCOUNT:
1639       if (dev)                  /*
1640                                  * Patch manager
1641                                  */
1642         return -EIO;
1643 
1644       if (mode == OPEN_WRITE)
1645         return 0;
1646       return snd_ioctl_return ((int *) arg, iqlen);
1647       break;
1648 
1649     case SNDCTL_SEQ_GETOUTCOUNT:
1650 
1651       if (mode == OPEN_READ)
1652         return 0;
1653       return snd_ioctl_return ((int *) arg, SEQ_MAX_QUEUE - qlen);
1654       break;
1655 
1656     case SNDCTL_SEQ_CTRLRATE:
1657       if (dev)                  /* Patch manager */
1658         return -EIO;
1659 
1660       /*
1661        * If *arg == 0, just return the current rate
1662        */
1663       if (seq_mode == SEQ_2)
1664         return tmr->ioctl (tmr_no, cmd, arg);
1665 
1666       if (get_fs_long ((long *) arg) != 0)
1667         return -EINVAL;
1668 
1669       return snd_ioctl_return ((int *) arg, HZ);
1670       break;
1671 
1672     case SNDCTL_SEQ_RESETSAMPLES:
1673       {
1674         int             err;
1675 
1676         dev = get_fs_long ((long *) arg);
1677         if (dev < 0 || dev >= num_synths)
1678           {
1679             return -ENXIO;
1680           }
1681 
1682         if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1683           {
1684             return -EBUSY;
1685           }
1686 
1687         if (!orig_dev && pmgr_present[dev])
1688           pmgr_inform (dev, PM_E_PATCH_RESET, 0, 0, 0, 0);
1689 
1690         err = synth_devs[dev]->ioctl (dev, cmd, arg);
1691         return err;
1692       }
1693       break;
1694 
1695     case SNDCTL_SEQ_NRSYNTHS:
1696       return snd_ioctl_return ((int *) arg, max_synthdev);
1697       break;
1698 
1699     case SNDCTL_SEQ_NRMIDIS:
1700       return snd_ioctl_return ((int *) arg, max_mididev);
1701       break;
1702 
1703     case SNDCTL_SYNTH_MEMAVL:
1704       {
1705         int             dev = get_fs_long ((long *) arg);
1706 
1707         if (dev < 0 || dev >= num_synths)
1708           return -ENXIO;
1709 
1710         if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1711           return -EBUSY;
1712 
1713         return snd_ioctl_return ((int *) arg, synth_devs[dev]->ioctl (dev, cmd, arg));
1714       }
1715       break;
1716 
1717     case SNDCTL_FM_4OP_ENABLE:
1718       {
1719         int             dev = get_fs_long ((long *) arg);
1720 
1721         if (dev < 0 || dev >= num_synths)
1722           return -ENXIO;
1723 
1724         if (!(synth_open_mask & (1 << dev)))
1725           return -ENXIO;
1726 
1727         synth_devs[dev]->ioctl (dev, cmd, arg);
1728         return 0;
1729       }
1730       break;
1731 
1732     case SNDCTL_SYNTH_INFO:
1733       {
1734         struct synth_info inf;
1735         int             dev;
1736 
1737         memcpy_fromfs ((char *) &inf, &(((char *) arg)[0]), sizeof (inf));
1738         dev = inf.device;
1739 
1740         if (dev < 0 || dev >= max_synthdev)
1741           return -ENXIO;
1742 
1743         if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1744           return -EBUSY;
1745 
1746         return synth_devs[dev]->ioctl (dev, cmd, arg);
1747       }
1748       break;
1749 
1750     case SNDCTL_SEQ_OUTOFBAND:
1751       {
1752         struct seq_event_rec event;
1753         unsigned long   flags;
1754 
1755         memcpy_fromfs ((char *) &event, &(((char *) arg)[0]), sizeof (event));
1756 
1757         save_flags (flags);
1758         cli ();
1759         play_event (event.arr);
1760         restore_flags (flags);
1761 
1762         return 0;
1763       }
1764       break;
1765 
1766     case SNDCTL_MIDI_INFO:
1767       {
1768         struct midi_info inf;
1769         int             dev;
1770 
1771         memcpy_fromfs ((char *) &inf, &(((char *) arg)[0]), sizeof (inf));
1772         dev = inf.device;
1773 
1774         if (dev < 0 || dev >= max_mididev)
1775           return -ENXIO;
1776 
1777         memcpy_tofs ((&((char *) arg)[0]), (char *) &(midi_devs[dev]->info), sizeof (inf));
1778         return 0;
1779       }
1780       break;
1781 
1782     case SNDCTL_PMGR_IFACE:
1783       {
1784         struct patmgr_info *inf;
1785         int             dev, err;
1786 
1787         if ((inf = (struct patmgr_info *) kmalloc (sizeof (*inf), GFP_KERNEL)) == NULL)
1788           {
1789             printk ("patmgr: Can't allocate memory for a message\n");
1790             return -EIO;
1791           }
1792 
1793         memcpy_fromfs ((char *) inf, &(((char *) arg)[0]), sizeof (*inf));
1794         dev = inf->device;
1795 
1796         if (dev < 0 || dev >= num_synths)
1797           {
1798             kfree (inf);
1799             return -ENXIO;
1800           }
1801 
1802         if (!synth_devs[dev]->pmgr_interface)
1803           {
1804             kfree (inf);
1805             return -ENXIO;
1806           }
1807 
1808         if ((err = synth_devs[dev]->pmgr_interface (dev, inf)) == -1)
1809           {
1810             kfree (inf);
1811             return err;
1812           }
1813 
1814         memcpy_tofs ((&((char *) arg)[0]), (char *) inf, sizeof (*inf));
1815         kfree (inf);
1816         return 0;
1817       }
1818       break;
1819 
1820     case SNDCTL_PMGR_ACCESS:
1821       {
1822         struct patmgr_info *inf;
1823         int             dev, err;
1824 
1825         if ((inf = (struct patmgr_info *) kmalloc (sizeof (*inf), GFP_KERNEL)) == NULL)
1826           {
1827             printk ("patmgr: Can't allocate memory for a message\n");
1828             return -EIO;
1829           }
1830 
1831         memcpy_fromfs ((char *) inf, &(((char *) arg)[0]), sizeof (*inf));
1832         dev = inf->device;
1833 
1834         if (dev < 0 || dev >= num_synths)
1835           {
1836             kfree (inf);
1837             return -ENXIO;
1838           }
1839 
1840         if (!pmgr_present[dev])
1841           {
1842             kfree (inf);
1843             return -ESRCH;
1844           }
1845 
1846         if ((err = pmgr_access (dev, inf)) < 0)
1847           {
1848             kfree (inf);
1849             return err;
1850           }
1851 
1852         memcpy_tofs ((&((char *) arg)[0]), (char *) inf, sizeof (*inf));
1853         kfree (inf);
1854         return 0;
1855       }
1856       break;
1857 
1858     case SNDCTL_SEQ_THRESHOLD:
1859       {
1860         int             tmp = get_fs_long ((long *) arg);
1861 
1862         if (dev)                /*
1863                                  * Patch manager
1864                                  */
1865           return -EIO;
1866 
1867         if (tmp < 1)
1868           tmp = 1;
1869         if (tmp >= SEQ_MAX_QUEUE)
1870           tmp = SEQ_MAX_QUEUE - 1;
1871         output_treshold = tmp;
1872         return 0;
1873       }
1874       break;
1875 
1876     case SNDCTL_MIDI_PRETIME:
1877       {
1878         int             val = get_fs_long ((long *) arg);
1879 
1880         if (val < 0)
1881           val = 0;
1882 
1883         val = (HZ * val) / 10;
1884         pre_event_timeout = val;
1885         return snd_ioctl_return ((int *) arg, val);
1886       }
1887       break;
1888 
1889     default:
1890       if (dev)                  /*
1891                                  * Patch manager
1892                                  */
1893         return -EIO;
1894 
1895       if (mode == OPEN_READ)
1896         return -EIO;
1897 
1898       if (!synth_devs[0])
1899         return -ENXIO;
1900       if (!(synth_open_mask & (1 << 0)))
1901         return -ENXIO;
1902       return synth_devs[0]->ioctl (0, cmd, arg);
1903       break;
1904     }
1905 
1906   return -EINVAL;
1907 }
1908 
1909 int
1910 sequencer_select (int dev, struct fileinfo *file, int sel_type, select_table_handle * wait)
     /*  */
1911 {
1912   unsigned long   flags;
1913 
1914   dev = dev >> 4;
1915 
1916   switch (sel_type)
1917     {
1918     case SEL_IN:
1919       save_flags (flags);
1920       cli ();
1921       if (!iqlen)
1922         {
1923           midi_sleep_flag.mode = WK_SLEEP;
1924           module_select_wait (&midi_sleeper, wait);
1925           restore_flags (flags);
1926           return 0;
1927         }
1928       midi_sleep_flag.mode &= ~WK_SLEEP;
1929       restore_flags (flags);
1930       return 1;
1931       break;
1932 
1933     case SEL_OUT:
1934       save_flags (flags);
1935       cli ();
1936       if ((SEQ_MAX_QUEUE - qlen) < output_treshold)
1937         {
1938           seq_sleep_flag.mode = WK_SLEEP;
1939           module_select_wait (&seq_sleeper, wait);
1940           restore_flags (flags);
1941           return 0;
1942         }
1943       seq_sleep_flag.mode &= ~WK_SLEEP;
1944       restore_flags (flags);
1945       return 1;
1946       break;
1947 
1948     case SEL_EX:
1949       return 0;
1950     }
1951 
1952   return 0;
1953 }
1954 
1955 
1956 void
1957 sequencer_timer (unsigned long dummy)
     /*  */
1958 {
1959   seq_startplay ();
1960 }
1961 
1962 int
1963 note_to_freq (int note_num)
     /*  */
1964 {
1965 
1966   /*
1967    * This routine converts a midi note to a frequency (multiplied by 1000)
1968    */
1969 
1970   int             note, octave, note_freq;
1971   int             notes[] =
1972   {
1973     261632, 277189, 293671, 311132, 329632, 349232,
1974     369998, 391998, 415306, 440000, 466162, 493880
1975   };
1976 
1977 #define BASE_OCTAVE     5
1978 
1979   octave = note_num / 12;
1980   note = note_num % 12;
1981 
1982   note_freq = notes[note];
1983 
1984   if (octave < BASE_OCTAVE)
1985     note_freq >>= (BASE_OCTAVE - octave);
1986   else if (octave > BASE_OCTAVE)
1987     note_freq <<= (octave - BASE_OCTAVE);
1988 
1989   /*
1990    * note_freq >>= 1;
1991    */
1992 
1993   return note_freq;
1994 }
1995 
1996 unsigned long
1997 compute_finetune (unsigned long base_freq, int bend, int range)
     /*  */
1998 {
1999   unsigned long   amount;
2000   int             negative, semitones, cents, multiplier = 1;
2001 
2002   if (!bend)
2003     return base_freq;
2004   if (!range)
2005     return base_freq;
2006 
2007   if (!base_freq)
2008     return base_freq;
2009 
2010   if (range >= 8192)
2011     range = 8192;
2012 
2013   bend = bend * range / 8192;
2014   if (!bend)
2015     return base_freq;
2016 
2017   negative = bend < 0 ? 1 : 0;
2018 
2019   if (bend < 0)
2020     bend *= -1;
2021   if (bend > range)
2022     bend = range;
2023 
2024   /*
2025      if (bend > 2399)
2026      bend = 2399;
2027    */
2028   while (bend > 2399)
2029     {
2030       multiplier *= 4;
2031       bend -= 2400;
2032     }
2033 
2034   semitones = bend / 100;
2035   cents = bend % 100;
2036 
2037   amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents])
2038     / 10000;
2039 
2040   if (negative)
2041     return (base_freq * 10000) / amount;        /* Bend down */
2042   else
2043     return (base_freq * amount) / 10000;        /* Bend up */
2044 }
2045 
2046 
2047 long
2048 sequencer_init (long mem_start)
     /*  */
2049 {
2050 
2051   sequencer_ok = 1;
2052 
2053   queue = (unsigned char *) (sound_mem_blocks[sound_num_blocks] = kmalloc (SEQ_MAX_QUEUE * EV_SZ, GFP_KERNEL));
2054   if (sound_num_blocks < 1024)
2055     sound_num_blocks++;;
2056 
2057   iqueue = (unsigned char *) (sound_mem_blocks[sound_num_blocks] = kmalloc (SEQ_MAX_QUEUE * IEV_SZ, GFP_KERNEL));
2058   if (sound_num_blocks < 1024)
2059     sound_num_blocks++;;
2060 
2061   return mem_start;
2062 }
2063 
2064 #endif
/* */
root/drivers/sound/sequencer.c

DEFINITIONS
