root/drivers/sound/sequencer.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. sequencer_read
  2. sequencer_midi_output
  3. seq_copy_to_input
  4. sequencer_midi_input
  5. seq_input_event
  6. sequencer_write
  7. seq_queue
  8. extended_event
  9. find_voice
  10. alloc_voice
  11. seq_chn_voice_event
  12. seq_chn_common_event
  13. seq_timing_event
  14. seq_local_event
  15. seq_sysex_message
  16. play_event
  17. seq_startplay
  18. reset_controllers
  19. setup_mode2
  20. sequencer_open
  21. seq_drain_midi_queues
  22. sequencer_release
  23. seq_sync
  24. midi_outc
  25. seq_reset
  26. seq_panic
  27. sequencer_ioctl
  28. sequencer_select
  29. sequencer_timer
  30. note_to_freq
  31. compute_finetune
  32. sequencer_init

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

/* [previous][next][first][last][top][bottom][index][help] */