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

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