linux-old/drivers/sound/sequencer.c
<<
>>
Prefs
   1/*
   2 * sound/sequencer.c
   3 *
   4 * The sequencer personality manager.
   5 */
   6/*
   7 * Copyright (C) by Hannu Savolainen 1993-1997
   8 *
   9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11 * for more info.
  12 */
  13/*
  14 * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
  15 * Alan Cox        : reformatted and fixed a pair of null pointer bugs
  16 */
  17#include <linux/kmod.h>
  18
  19#define SEQUENCER_C
  20#include "sound_config.h"
  21
  22#include "midi_ctrl.h"
  23
  24static int      sequencer_ok = 0;
  25static struct sound_timer_operations *tmr;
  26static int      tmr_no = -1;    /* Currently selected timer */
  27static int      pending_timer = -1;     /* For timer change operation */
  28extern unsigned long seq_time;
  29
  30static int      obsolete_api_used = 0;
  31
  32/*
  33 * Local counts for number of synth and MIDI devices. These are initialized
  34 * by the sequencer_open.
  35 */
  36static int      max_mididev = 0;
  37static int      max_synthdev = 0;
  38
  39/*
  40 * The seq_mode gives the operating mode of the sequencer:
  41 *      1 = level1 (the default)
  42 *      2 = level2 (extended capabilities)
  43 */
  44
  45#define SEQ_1   1
  46#define SEQ_2   2
  47static int      seq_mode = SEQ_1;
  48
  49static DECLARE_WAIT_QUEUE_HEAD(seq_sleeper);
  50static DECLARE_WAIT_QUEUE_HEAD(midi_sleeper);
  51
  52static int      midi_opened[MAX_MIDI_DEV] = {
  53        0
  54};
  55
  56static int      midi_written[MAX_MIDI_DEV] = {
  57        0
  58};
  59
  60static unsigned long prev_input_time = 0;
  61static int      prev_event_time;
  62
  63#include "tuning.h"
  64
  65#define EV_SZ   8
  66#define IEV_SZ  8
  67
  68static unsigned char *queue = NULL;
  69static unsigned char *iqueue = NULL;
  70
  71static volatile int qhead = 0, qtail = 0, qlen = 0;
  72static volatile int iqhead = 0, iqtail = 0, iqlen = 0;
  73static volatile int seq_playing = 0;
  74static volatile int sequencer_busy = 0;
  75static int      output_threshold;
  76static long     pre_event_timeout;
  77static unsigned synth_open_mask;
  78
  79static int      seq_queue(unsigned char *note, char nonblock);
  80static void     seq_startplay(void);
  81static int      seq_sync(void);
  82static void     seq_reset(void);
  83
  84#if MAX_SYNTH_DEV > 15
  85#error Too many synthesizer devices enabled.
  86#endif
  87
  88int sequencer_read(int dev, struct file *file, char *buf, int count)
  89{
  90        int c = count, p = 0;
  91        int ev_len;
  92        unsigned long flags;
  93
  94        dev = dev >> 4;
  95
  96        ev_len = seq_mode == SEQ_1 ? 4 : 8;
  97
  98        save_flags(flags);
  99        cli();
 100
 101        if (!iqlen)
 102        {
 103                if (file->f_flags & O_NONBLOCK) {
 104                        restore_flags(flags);
 105                        return -EAGAIN;
 106                }
 107
 108                interruptible_sleep_on_timeout(&midi_sleeper,
 109                                               pre_event_timeout);
 110                if (!iqlen)
 111                {
 112                        restore_flags(flags);
 113                        return 0;
 114                }
 115        }
 116        while (iqlen && c >= ev_len)
 117        {
 118                char *fixit = (char *) &iqueue[iqhead * IEV_SZ];
 119                copy_to_user(&(buf)[p], fixit, ev_len);
 120                p += ev_len;
 121                c -= ev_len;
 122
 123                iqhead = (iqhead + 1) % SEQ_MAX_QUEUE;
 124                iqlen--;
 125        }
 126        restore_flags(flags);
 127        return count - c;
 128}
 129
 130static void sequencer_midi_output(int dev)
 131{
 132        /*
 133         * Currently NOP
 134         */
 135}
 136
 137void seq_copy_to_input(unsigned char *event_rec, int len)
 138{
 139        unsigned long flags;
 140
 141        /*
 142         * Verify that the len is valid for the current mode.
 143         */
 144
 145        if (len != 4 && len != 8)
 146                return;
 147        if ((seq_mode == SEQ_1) != (len == 4))
 148                return;
 149
 150        if (iqlen >= (SEQ_MAX_QUEUE - 1))
 151                return;         /* Overflow */
 152
 153        save_flags(flags);
 154        cli();
 155        memcpy(&iqueue[iqtail * IEV_SZ], event_rec, len);
 156        iqlen++;
 157        iqtail = (iqtail + 1) % SEQ_MAX_QUEUE;
 158        wake_up(&midi_sleeper);
 159        restore_flags(flags);
 160}
 161
 162static void sequencer_midi_input(int dev, unsigned char data)
 163{
 164        unsigned int tstamp;
 165        unsigned char event_rec[4];
 166
 167        if (data == 0xfe)       /* Ignore active sensing */
 168                return;
 169
 170        tstamp = jiffies - seq_time;
 171
 172        if (tstamp != prev_input_time)
 173        {
 174                tstamp = (tstamp << 8) | SEQ_WAIT;
 175                seq_copy_to_input((unsigned char *) &tstamp, 4);
 176                prev_input_time = tstamp;
 177        }
 178        event_rec[0] = SEQ_MIDIPUTC;
 179        event_rec[1] = data;
 180        event_rec[2] = dev;
 181        event_rec[3] = 0;
 182
 183        seq_copy_to_input(event_rec, 4);
 184}
 185
 186void seq_input_event(unsigned char *event_rec, int len)
 187{
 188        unsigned long this_time;
 189
 190        if (seq_mode == SEQ_2)
 191                this_time = tmr->get_time(tmr_no);
 192        else
 193                this_time = jiffies - seq_time;
 194
 195        if (this_time != prev_input_time)
 196        {
 197                unsigned char   tmp_event[8];
 198
 199                tmp_event[0] = EV_TIMING;
 200                tmp_event[1] = TMR_WAIT_ABS;
 201                tmp_event[2] = 0;
 202                tmp_event[3] = 0;
 203                *(unsigned int *) &tmp_event[4] = this_time;
 204
 205                seq_copy_to_input(tmp_event, 8);
 206                prev_input_time = this_time;
 207        }
 208        seq_copy_to_input(event_rec, len);
 209}
 210
 211int sequencer_write(int dev, struct file *file, const char *buf, int count)
 212{
 213        unsigned char event_rec[EV_SZ], ev_code;
 214        int p = 0, c, ev_size;
 215        int err;
 216        int mode = translate_mode(file);
 217
 218        dev = dev >> 4;
 219
 220        DEB(printk("sequencer_write(dev=%d, count=%d)\n", dev, count));
 221
 222        if (mode == OPEN_READ)
 223                return -EIO;
 224
 225        c = count;
 226
 227        while (c >= 4)
 228        {
 229                copy_from_user((char *) event_rec, &(buf)[p], 4);
 230                ev_code = event_rec[0];
 231
 232                if (ev_code == SEQ_FULLSIZE)
 233                {
 234                        int err, fmt;
 235
 236                        dev = *(unsigned short *) &event_rec[2];
 237                        if (dev < 0 || dev >= max_synthdev || synth_devs[dev] == NULL)
 238                                return -ENXIO;
 239
 240                        if (!(synth_open_mask & (1 << dev)))
 241                                return -ENXIO;
 242
 243                        fmt = (*(short *) &event_rec[0]) & 0xffff;
 244                        err = synth_devs[dev]->load_patch(dev, fmt, buf, p + 4, c, 0);
 245                        if (err < 0)
 246                                return err;
 247
 248                        return err;
 249                }
 250                if (ev_code >= 128)
 251                {
 252                        if (seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED)
 253                        {
 254                                printk(KERN_WARNING "Sequencer: Invalid level 2 event %x\n", ev_code);
 255                                return -EINVAL;
 256                        }
 257                        ev_size = 8;
 258
 259                        if (c < ev_size)
 260                        {
 261                                if (!seq_playing)
 262                                        seq_startplay();
 263                                return count - c;
 264                        }
 265                        copy_from_user((char *) &event_rec[4], &(buf)[p + 4], 4);
 266
 267                }
 268                else
 269                {
 270                        if (seq_mode == SEQ_2)
 271                        {
 272                                printk(KERN_WARNING "Sequencer: 4 byte event in level 2 mode\n");
 273                                return -EINVAL;
 274                        }
 275                        ev_size = 4;
 276
 277                        if (event_rec[0] != SEQ_MIDIPUTC)
 278                                obsolete_api_used = 1;
 279                }
 280
 281                if (event_rec[0] == SEQ_MIDIPUTC)
 282                {
 283                        if (!midi_opened[event_rec[2]])
 284                        {
 285                                int mode;
 286                                int dev = event_rec[2];
 287
 288                                if (dev >= max_mididev || midi_devs[dev]==NULL)
 289                                {
 290                                        /*printk("Sequencer Error: Nonexistent MIDI device %d\n", dev);*/
 291                                        return -ENXIO;
 292                                }
 293                                mode = translate_mode(file);
 294
 295                                if ((err = midi_devs[dev]->open(dev, mode,
 296                                                                sequencer_midi_input, sequencer_midi_output)) < 0)
 297                                {
 298                                        seq_reset();
 299                                        printk(KERN_WARNING "Sequencer Error: Unable to open Midi #%d\n", dev);
 300                                        return err;
 301                                }
 302                                midi_opened[dev] = 1;
 303                        }
 304                }
 305                if (!seq_queue(event_rec, (file->f_flags & (O_NONBLOCK) ? 1 : 0)))
 306                {
 307                        int processed = count - c;
 308
 309                        if (!seq_playing)
 310                                seq_startplay();
 311
 312                        if (!processed && (file->f_flags & O_NONBLOCK))
 313                                return -EAGAIN;
 314                        else
 315                                return processed;
 316                }
 317                p += ev_size;
 318                c -= ev_size;
 319        }
 320
 321        if (!seq_playing)
 322                seq_startplay();
 323
 324        return count;
 325}
 326
 327static int seq_queue(unsigned char *note, char nonblock)
 328{
 329
 330        /*
 331         * Test if there is space in the queue
 332         */
 333
 334        if (qlen >= SEQ_MAX_QUEUE)
 335                if (!seq_playing)
 336                        seq_startplay();        /*
 337                                                 * Give chance to drain the queue
 338                                                 */
 339
 340        if (!nonblock && qlen >= SEQ_MAX_QUEUE && !waitqueue_active(&seq_sleeper)) {
 341                /*
 342                 * Sleep until there is enough space on the queue
 343                 */
 344                interruptible_sleep_on(&seq_sleeper);
 345        }
 346        if (qlen >= SEQ_MAX_QUEUE)
 347        {
 348                return 0;       /*
 349                                 * To be sure
 350                                 */
 351        }
 352        memcpy(&queue[qtail * EV_SZ], note, EV_SZ);
 353
 354        qtail = (qtail + 1) % SEQ_MAX_QUEUE;
 355        qlen++;
 356
 357        return 1;
 358}
 359
 360static int extended_event(unsigned char *q)
 361{
 362        int dev = q[2];
 363
 364        if (dev < 0 || dev >= max_synthdev)
 365                return -ENXIO;
 366
 367        if (!(synth_open_mask & (1 << dev)))
 368                return -ENXIO;
 369
 370        switch (q[1])
 371        {
 372                case SEQ_NOTEOFF:
 373                        synth_devs[dev]->kill_note(dev, q[3], q[4], q[5]);
 374                        break;
 375
 376                case SEQ_NOTEON:
 377                        if (q[4] > 127 && q[4] != 255)
 378                                return 0;
 379
 380                        if (q[5] == 0)
 381                        {
 382                                synth_devs[dev]->kill_note(dev, q[3], q[4], q[5]);
 383                                break;
 384                        }
 385                        synth_devs[dev]->start_note(dev, q[3], q[4], q[5]);
 386                        break;
 387
 388                case SEQ_PGMCHANGE:
 389                        synth_devs[dev]->set_instr(dev, q[3], q[4]);
 390                        break;
 391
 392                case SEQ_AFTERTOUCH:
 393                        synth_devs[dev]->aftertouch(dev, q[3], q[4]);
 394                        break;
 395
 396                case SEQ_BALANCE:
 397                        synth_devs[dev]->panning(dev, q[3], (char) q[4]);
 398                        break;
 399
 400                case SEQ_CONTROLLER:
 401                        synth_devs[dev]->controller(dev, q[3], q[4], (short) (q[5] | (q[6] << 8)));
 402                        break;
 403
 404                case SEQ_VOLMODE:
 405                        if (synth_devs[dev]->volume_method != NULL)
 406                                synth_devs[dev]->volume_method(dev, q[3]);
 407                        break;
 408
 409                default:
 410                        return -EINVAL;
 411        }
 412        return 0;
 413}
 414
 415static int find_voice(int dev, int chn, int note)
 416{
 417        unsigned short key;
 418        int i;
 419
 420        key = (chn << 8) | (note + 1);
 421        for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
 422                if (synth_devs[dev]->alloc.map[i] == key)
 423                        return i;
 424        return -1;
 425}
 426
 427static int alloc_voice(int dev, int chn, int note)
 428{
 429        unsigned short  key;
 430        int voice;
 431
 432        key = (chn << 8) | (note + 1);
 433
 434        voice = synth_devs[dev]->alloc_voice(dev, chn, note,
 435                                             &synth_devs[dev]->alloc);
 436        synth_devs[dev]->alloc.map[voice] = key;
 437        synth_devs[dev]->alloc.alloc_times[voice] =
 438                        synth_devs[dev]->alloc.timestamp++;
 439        return voice;
 440}
 441
 442static void seq_chn_voice_event(unsigned char *event_rec)
 443{
 444#define dev event_rec[1]
 445#define cmd event_rec[2]
 446#define chn event_rec[3]
 447#define note event_rec[4]
 448#define parm event_rec[5]
 449
 450        int voice = -1;
 451
 452        if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
 453                return;
 454        if (!(synth_open_mask & (1 << dev)))
 455                return;
 456        if (!synth_devs[dev])
 457                return;
 458
 459        if (seq_mode == SEQ_2)
 460        {
 461                if (synth_devs[dev]->alloc_voice)
 462                        voice = find_voice(dev, chn, note);
 463
 464                if (cmd == MIDI_NOTEON && parm == 0)
 465                {
 466                        cmd = MIDI_NOTEOFF;
 467                        parm = 64;
 468                }
 469        }
 470
 471        switch (cmd)
 472        {
 473                case MIDI_NOTEON:
 474                        if (note > 127 && note != 255)  /* Not a seq2 feature */
 475                                return;
 476
 477                        if (voice == -1 && seq_mode == SEQ_2 && synth_devs[dev]->alloc_voice)
 478                        {
 479                                /* Internal synthesizer (FM, GUS, etc) */
 480                                voice = alloc_voice(dev, chn, note);
 481                        }
 482                        if (voice == -1)
 483                                voice = chn;
 484
 485                        if (seq_mode == SEQ_2 && (int) dev < num_synths)
 486                        {
 487                                /*
 488                                 * The MIDI channel 10 is a percussive channel. Use the note
 489                                 * number to select the proper patch (128 to 255) to play.
 490                                 */
 491
 492                                if (chn == 9)
 493                                {
 494                                        synth_devs[dev]->set_instr(dev, voice, 128 + note);
 495                                        synth_devs[dev]->chn_info[chn].pgm_num = 128 + note;
 496                                }
 497                                synth_devs[dev]->setup_voice(dev, voice, chn);
 498                        }
 499                        synth_devs[dev]->start_note(dev, voice, note, parm);
 500                        break;
 501
 502                case MIDI_NOTEOFF:
 503                        if (voice == -1)
 504                                voice = chn;
 505                        synth_devs[dev]->kill_note(dev, voice, note, parm);
 506                        break;
 507
 508                case MIDI_KEY_PRESSURE:
 509                        if (voice == -1)
 510                                voice = chn;
 511                        synth_devs[dev]->aftertouch(dev, voice, parm);
 512                        break;
 513
 514                default:;
 515        }
 516#undef dev
 517#undef cmd
 518#undef chn
 519#undef note
 520#undef parm
 521}
 522
 523
 524static void seq_chn_common_event(unsigned char *event_rec)
 525{
 526        unsigned char dev = event_rec[1];
 527        unsigned char cmd = event_rec[2];
 528        unsigned char chn = event_rec[3];
 529        unsigned char p1 = event_rec[4];
 530
 531        /* unsigned char p2 = event_rec[5]; */
 532        unsigned short w14 = *(short *) &event_rec[6];
 533
 534        if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
 535                return;
 536        if (!(synth_open_mask & (1 << dev)))
 537                return;
 538        if (!synth_devs[dev])
 539                return;
 540
 541        switch (cmd)
 542        {
 543                case MIDI_PGM_CHANGE:
 544                        if (seq_mode == SEQ_2)
 545                        {
 546                                synth_devs[dev]->chn_info[chn].pgm_num = p1;
 547                                if ((int) dev >= num_synths)
 548                                        synth_devs[dev]->set_instr(dev, chn, p1);
 549                        }
 550                        else
 551                                synth_devs[dev]->set_instr(dev, chn, p1);
 552
 553                        break;
 554
 555                case MIDI_CTL_CHANGE:
 556                        if (seq_mode == SEQ_2)
 557                        {
 558                                if (chn > 15 || p1 > 127)
 559                                        break;
 560
 561                                synth_devs[dev]->chn_info[chn].controllers[p1] = w14 & 0x7f;
 562
 563                                if (p1 < 32)    /* Setting MSB should clear LSB to 0 */
 564                                        synth_devs[dev]->chn_info[chn].controllers[p1 + 32] = 0;
 565
 566                                if ((int) dev < num_synths)
 567                                {
 568                                        int val = w14 & 0x7f;
 569                                        int i, key;
 570
 571                                        if (p1 < 64)    /* Combine MSB and LSB */
 572                                        {
 573                                                val = ((synth_devs[dev]->
 574                                                        chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
 575                                                        | (synth_devs[dev]->
 576                                                        chn_info[chn].controllers[p1 | 32] & 0x7f);
 577                                                p1 &= ~32;
 578                                        }
 579                                        /* Handle all playing notes on this channel */
 580
 581                                        key = ((int) chn << 8);
 582
 583                                        for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
 584                                                if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
 585                                                        synth_devs[dev]->controller(dev, i, p1, val);
 586                                }
 587                                else
 588                                        synth_devs[dev]->controller(dev, chn, p1, w14);
 589                        }
 590                        else    /* Mode 1 */
 591                                synth_devs[dev]->controller(dev, chn, p1, w14);
 592                        break;
 593
 594                case MIDI_PITCH_BEND:
 595                        if (seq_mode == SEQ_2)
 596                        {
 597                                synth_devs[dev]->chn_info[chn].bender_value = w14;
 598
 599                                if ((int) dev < num_synths)
 600                                {
 601                                        /* Handle all playing notes on this channel */
 602                                        int i, key;
 603
 604                                        key = (chn << 8);
 605
 606                                        for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
 607                                                if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
 608                                                        synth_devs[dev]->bender(dev, i, w14);
 609                                }
 610                                else
 611                                        synth_devs[dev]->bender(dev, chn, w14);
 612                        }
 613                        else    /* MODE 1 */
 614                                synth_devs[dev]->bender(dev, chn, w14);
 615                        break;
 616
 617                default:;
 618        }
 619}
 620
 621static int seq_timing_event(unsigned char *event_rec)
 622{
 623        unsigned char cmd = event_rec[1];
 624        unsigned int parm = *(int *) &event_rec[4];
 625
 626        if (seq_mode == SEQ_2)
 627        {
 628                int ret;
 629
 630                if ((ret = tmr->event(tmr_no, event_rec)) == TIMER_ARMED)
 631                        if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
 632                                wake_up(&seq_sleeper);
 633                return ret;
 634        }
 635        switch (cmd)
 636        {
 637                case TMR_WAIT_REL:
 638                        parm += prev_event_time;
 639
 640                        /*
 641                         * NOTE!  No break here. Execution of TMR_WAIT_REL continues in the
 642                         * next case (TMR_WAIT_ABS)
 643                         */
 644
 645                case TMR_WAIT_ABS:
 646                        if (parm > 0)
 647                        {
 648                                long time;
 649
 650                                time = parm;
 651                                prev_event_time = time;
 652
 653                                seq_playing = 1;
 654                                request_sound_timer(time);
 655
 656                                if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
 657                                        wake_up(&seq_sleeper);
 658                                return TIMER_ARMED;
 659                        }
 660                        break;
 661
 662                case TMR_START:
 663                        seq_time = jiffies;
 664                        prev_input_time = 0;
 665                        prev_event_time = 0;
 666                        break;
 667
 668                case TMR_STOP:
 669                        break;
 670
 671                case TMR_CONTINUE:
 672                        break;
 673
 674                case TMR_TEMPO:
 675                        break;
 676
 677                case TMR_ECHO:
 678                        if (seq_mode == SEQ_2)
 679                                seq_copy_to_input(event_rec, 8);
 680                        else
 681                        {
 682                                parm = (parm << 8 | SEQ_ECHO);
 683                                seq_copy_to_input((unsigned char *) &parm, 4);
 684                        }
 685                        break;
 686
 687                default:;
 688        }
 689
 690        return TIMER_NOT_ARMED;
 691}
 692
 693static void seq_local_event(unsigned char *event_rec)
 694{
 695        unsigned char   cmd = event_rec[1];
 696        unsigned int    parm = *((unsigned int *) &event_rec[4]);
 697
 698        switch (cmd)
 699        {
 700                case LOCL_STARTAUDIO:
 701                        DMAbuf_start_devices(parm);
 702                        break;
 703
 704                default:;
 705        }
 706}
 707
 708static void seq_sysex_message(unsigned char *event_rec)
 709{
 710        int dev = event_rec[1];
 711        int i, l = 0;
 712        unsigned char  *buf = &event_rec[2];
 713
 714        if ((int) dev > max_synthdev)
 715                return;
 716        if (!(synth_open_mask & (1 << dev)))
 717                return;
 718        if (!synth_devs[dev])
 719                return;
 720
 721        l = 0;
 722        for (i = 0; i < 6 && buf[i] != 0xff; i++)
 723                l = i + 1;
 724
 725        if (!synth_devs[dev]->send_sysex)
 726                return;
 727        if (l > 0)
 728                synth_devs[dev]->send_sysex(dev, buf, l);
 729}
 730
 731static int play_event(unsigned char *q)
 732{
 733        /*
 734         * NOTE! This routine returns
 735         *   0 = normal event played.
 736         *   1 = Timer armed. Suspend playback until timer callback.
 737         *   2 = MIDI output buffer full. Restore queue and suspend until timer
 738         */
 739        unsigned int *delay;
 740
 741        switch (q[0])
 742        {
 743                case SEQ_NOTEOFF:
 744                        if (synth_open_mask & (1 << 0))
 745                                if (synth_devs[0])
 746                                        synth_devs[0]->kill_note(0, q[1], 255, q[3]);
 747                        break;
 748
 749                case SEQ_NOTEON:
 750                        if (q[4] < 128 || q[4] == 255)
 751                                if (synth_open_mask & (1 << 0))
 752                                        if (synth_devs[0])
 753                                                synth_devs[0]->start_note(0, q[1], q[2], q[3]);
 754                        break;
 755
 756                case SEQ_WAIT:
 757                        delay = (unsigned int *) q;     /*
 758                                                         * Bytes 1 to 3 are containing the *
 759                                                         * delay in 'ticks'
 760                                                         */
 761                        *delay = (*delay >> 8) & 0xffffff;
 762
 763                        if (*delay > 0)
 764                        {
 765                                long time;
 766
 767                                seq_playing = 1;
 768                                time = *delay;
 769                                prev_event_time = time;
 770
 771                                request_sound_timer(time);
 772
 773                                if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
 774                                        wake_up(&seq_sleeper);
 775                                /*
 776                                 * The timer is now active and will reinvoke this function
 777                                 * after the timer expires. Return to the caller now.
 778                                 */
 779                                return 1;
 780                        }
 781                        break;
 782
 783                case SEQ_PGMCHANGE:
 784                        if (synth_open_mask & (1 << 0))
 785                                if (synth_devs[0])
 786                                        synth_devs[0]->set_instr(0, q[1], q[2]);
 787                        break;
 788
 789                case SEQ_SYNCTIMER:     /*
 790                                         * Reset timer
 791                                         */
 792                        seq_time = jiffies;
 793                        prev_input_time = 0;
 794                        prev_event_time = 0;
 795                        break;
 796
 797                case SEQ_MIDIPUTC:      /*
 798                                         * Put a midi character
 799                                         */
 800                        if (midi_opened[q[2]])
 801                        {
 802                                int dev;
 803
 804                                dev = q[2];
 805
 806                                if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
 807                                        break;
 808
 809                                if (!midi_devs[dev]->outputc(dev, q[1]))
 810                                {
 811                                        /*
 812                                         * Output FIFO is full. Wait one timer cycle and try again.
 813                                         */
 814
 815                                        seq_playing = 1;
 816                                        request_sound_timer(-1);
 817                                        return 2;
 818                                }
 819                                else
 820                                        midi_written[dev] = 1;
 821                        }
 822                        break;
 823
 824                case SEQ_ECHO:
 825                        seq_copy_to_input(q, 4);        /*
 826                                                         * Echo back to the process
 827                                                         */
 828                        break;
 829
 830                case SEQ_PRIVATE:
 831                        if ((int) q[1] < max_synthdev)
 832                                synth_devs[q[1]]->hw_control(q[1], q);
 833                        break;
 834
 835                case SEQ_EXTENDED:
 836                        extended_event(q);
 837                        break;
 838
 839                case EV_CHN_VOICE:
 840                        seq_chn_voice_event(q);
 841                        break;
 842
 843                case EV_CHN_COMMON:
 844                        seq_chn_common_event(q);
 845                        break;
 846
 847                case EV_TIMING:
 848                        if (seq_timing_event(q) == TIMER_ARMED)
 849                        {
 850                                return 1;
 851                        }
 852                        break;
 853
 854                case EV_SEQ_LOCAL:
 855                        seq_local_event(q);
 856                        break;
 857
 858                case EV_SYSEX:
 859                        seq_sysex_message(q);
 860                        break;
 861
 862                default:;
 863        }
 864        return 0;
 865}
 866
 867static void seq_startplay(void)
 868{
 869        unsigned long flags;
 870        int this_one, action;
 871
 872        while (qlen > 0)
 873        {
 874
 875                save_flags(flags);
 876                cli();
 877                qhead = ((this_one = qhead) + 1) % SEQ_MAX_QUEUE;
 878                qlen--;
 879                restore_flags(flags);
 880
 881                seq_playing = 1;
 882
 883                if ((action = play_event(&queue[this_one * EV_SZ])))
 884                {               /* Suspend playback. Next timer routine invokes this routine again */
 885                        if (action == 2)
 886                        {
 887                                qlen++;
 888                                qhead = this_one;
 889                        }
 890                        return;
 891                }
 892        }
 893
 894        seq_playing = 0;
 895
 896        if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
 897                wake_up(&seq_sleeper);
 898}
 899
 900static void reset_controllers(int dev, unsigned char *controller, int update_dev)
 901{
 902        int i;
 903        for (i = 0; i < 128; i++)
 904                controller[i] = ctrl_def_values[i];
 905}
 906
 907static void setup_mode2(void)
 908{
 909        int dev;
 910
 911        max_synthdev = num_synths;
 912
 913        for (dev = 0; dev < num_midis; dev++)
 914        {
 915                if (midi_devs[dev] && midi_devs[dev]->converter != NULL)
 916                {
 917                        synth_devs[max_synthdev++] = midi_devs[dev]->converter;
 918                }
 919        }
 920
 921        for (dev = 0; dev < max_synthdev; dev++)
 922        {
 923                int chn;
 924
 925                synth_devs[dev]->sysex_ptr = 0;
 926                synth_devs[dev]->emulation = 0;
 927
 928                for (chn = 0; chn < 16; chn++)
 929                {
 930                        synth_devs[dev]->chn_info[chn].pgm_num = 0;
 931                        reset_controllers(dev,
 932                                synth_devs[dev]->chn_info[chn].controllers,0);
 933                        synth_devs[dev]->chn_info[chn].bender_value = (1 << 7); /* Neutral */
 934                        synth_devs[dev]->chn_info[chn].bender_range = 200;
 935                }
 936        }
 937        max_mididev = 0;
 938        seq_mode = SEQ_2;
 939}
 940
 941int sequencer_open(int dev, struct file *file)
 942{
 943        int retval, mode, i;
 944        int level, tmp;
 945        unsigned long flags;
 946
 947        if (!sequencer_ok)
 948                sequencer_init();
 949
 950        level = ((dev & 0x0f) == SND_DEV_SEQ2) ? 2 : 1;
 951
 952        dev = dev >> 4;
 953        mode = translate_mode(file);
 954
 955        DEB(printk("sequencer_open(dev=%d)\n", dev));
 956
 957        if (!sequencer_ok)
 958        {
 959/*              printk("Sound card: sequencer not initialized\n");*/
 960                return -ENXIO;
 961        }
 962        if (dev)                /* Patch manager device (obsolete) */
 963                return -ENXIO;
 964
 965        if(synth_devs[dev] == NULL)
 966                request_module("synth0");
 967
 968        if (mode == OPEN_READ)
 969        {
 970                if (!num_midis)
 971                {
 972                        /*printk("Sequencer: No MIDI devices. Input not possible\n");*/
 973                        sequencer_busy = 0;
 974                        return -ENXIO;
 975                }
 976        }
 977        save_flags(flags);
 978        cli();
 979        if (sequencer_busy)
 980        {
 981                restore_flags(flags);
 982                return -EBUSY;
 983        }
 984        sequencer_busy = 1;
 985        obsolete_api_used = 0;
 986        restore_flags(flags);
 987
 988        max_mididev = num_midis;
 989        max_synthdev = num_synths;
 990        pre_event_timeout = MAX_SCHEDULE_TIMEOUT;
 991        seq_mode = SEQ_1;
 992
 993        if (pending_timer != -1)
 994        {
 995                tmr_no = pending_timer;
 996                pending_timer = -1;
 997        }
 998        if (tmr_no == -1)       /* Not selected yet */
 999        {
1000                int i, best;
1001
1002                best = -1;
1003                for (i = 0; i < num_sound_timers; i++)
1004                        if (sound_timer_devs[i] && sound_timer_devs[i]->priority > best)
1005                        {
1006                                tmr_no = i;
1007                                best = sound_timer_devs[i]->priority;
1008                        }
1009                if (tmr_no == -1)       /* Should not be */
1010                        tmr_no = 0;
1011        }
1012        tmr = sound_timer_devs[tmr_no];
1013
1014        if (level == 2)
1015        {
1016                if (tmr == NULL)
1017                {
1018                        /*printk("sequencer: No timer for level 2\n");*/
1019                        sequencer_busy = 0;
1020                        return -ENXIO;
1021                }
1022                setup_mode2();
1023        }
1024        if (!max_synthdev && !max_mididev)
1025        {
1026                sequencer_busy=0;
1027                return -ENXIO;
1028        }
1029
1030        synth_open_mask = 0;
1031
1032        for (i = 0; i < max_mididev; i++)
1033        {
1034                midi_opened[i] = 0;
1035                midi_written[i] = 0;
1036        }
1037
1038        for (i = 0; i < max_synthdev; i++)
1039        {
1040                if (synth_devs[i]==NULL)
1041                        continue;
1042
1043                if (synth_devs[i]->owner)
1044                        __MOD_INC_USE_COUNT (synth_devs[i]->owner);
1045
1046                if ((tmp = synth_devs[i]->open(i, mode)) < 0)
1047                {
1048                        printk(KERN_WARNING "Sequencer: Warning! Cannot open synth device #%d (%d)\n", i, tmp);
1049                        if (synth_devs[i]->midi_dev)
1050                                printk(KERN_WARNING "(Maps to MIDI dev #%d)\n", synth_devs[i]->midi_dev);
1051                }
1052                else
1053                {
1054                        synth_open_mask |= (1 << i);
1055                        if (synth_devs[i]->midi_dev)
1056                                midi_opened[synth_devs[i]->midi_dev] = 1;
1057                }
1058        }
1059
1060        seq_time = jiffies;
1061
1062        prev_input_time = 0;
1063        prev_event_time = 0;
1064
1065        if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
1066        {
1067                /*
1068                 * Initialize midi input devices
1069                 */
1070
1071                for (i = 0; i < max_mididev; i++)
1072                        if (!midi_opened[i] && midi_devs[i])
1073                        {
1074                                if (midi_devs[i]->owner)
1075                                        __MOD_INC_USE_COUNT (midi_devs[i]->owner);
1076        
1077                                if ((retval = midi_devs[i]->open(i, mode,
1078                                        sequencer_midi_input, sequencer_midi_output)) >= 0)
1079                                {
1080                                        midi_opened[i] = 1;
1081                                }
1082                        }
1083        }
1084
1085        if (seq_mode == SEQ_2) {
1086                if (tmr->owner)
1087                        __MOD_INC_USE_COUNT (tmr->owner);
1088                tmr->open(tmr_no, seq_mode);
1089        }
1090
1091        init_waitqueue_head(&seq_sleeper);
1092        init_waitqueue_head(&midi_sleeper);
1093        output_threshold = SEQ_MAX_QUEUE / 2;
1094
1095        return 0;
1096}
1097
1098void seq_drain_midi_queues(void)
1099{
1100        int i, n;
1101
1102        /*
1103         * Give the Midi drivers time to drain their output queues
1104         */
1105
1106        n = 1;
1107
1108        while (!signal_pending(current) && n)
1109        {
1110                n = 0;
1111
1112                for (i = 0; i < max_mididev; i++)
1113                        if (midi_opened[i] && midi_written[i])
1114                                if (midi_devs[i]->buffer_status != NULL)
1115                                        if (midi_devs[i]->buffer_status(i))
1116                                                n++;
1117
1118                /*
1119                 * Let's have a delay
1120                 */
1121
1122                if (n)
1123                        interruptible_sleep_on_timeout(&seq_sleeper,
1124                                                       HZ/10);
1125        }
1126}
1127
1128void sequencer_release(int dev, struct file *file)
1129{
1130        int i;
1131        int mode = translate_mode(file);
1132
1133        dev = dev >> 4;
1134
1135        DEB(printk("sequencer_release(dev=%d)\n", dev));
1136
1137        /*
1138         * Wait until the queue is empty (if we don't have nonblock)
1139         */
1140
1141        if (mode != OPEN_READ && !(file->f_flags & O_NONBLOCK))
1142        {
1143                while (!signal_pending(current) && qlen > 0)
1144                {
1145                        seq_sync();
1146                        interruptible_sleep_on_timeout(&seq_sleeper,
1147                                                       3*HZ);
1148                        /* Extra delay */
1149                }
1150        }
1151
1152        if (mode != OPEN_READ)
1153                seq_drain_midi_queues();        /*
1154                                                 * Ensure the output queues are empty
1155                                                 */
1156        seq_reset();
1157        if (mode != OPEN_READ)
1158                seq_drain_midi_queues();        /*
1159                                                 * Flush the all notes off messages
1160                                                 */
1161
1162        for (i = 0; i < max_synthdev; i++)
1163        {
1164                if (synth_open_mask & (1 << i)) /*
1165                                                 * Actually opened
1166                                                 */
1167                        if (synth_devs[i])
1168                        {
1169                                synth_devs[i]->close(i);
1170
1171                                if (synth_devs[i]->owner)
1172                                        __MOD_DEC_USE_COUNT (synth_devs[i]->owner);
1173
1174                                if (synth_devs[i]->midi_dev)
1175                                        midi_opened[synth_devs[i]->midi_dev] = 0;
1176                        }
1177        }
1178
1179        for (i = 0; i < max_mididev; i++)
1180        {
1181                if (midi_opened[i]) {
1182                        midi_devs[i]->close(i);
1183                        if (midi_devs[i]->owner)
1184                                __MOD_DEC_USE_COUNT (midi_devs[i]->owner);
1185                }
1186        }
1187
1188        if (seq_mode == SEQ_2) {
1189                tmr->close(tmr_no);
1190                if (tmr->owner)
1191                        __MOD_DEC_USE_COUNT (tmr->owner);
1192        }
1193
1194        if (obsolete_api_used)
1195                printk(KERN_WARNING "/dev/music: Obsolete (4 byte) API was used by %s\n", current->comm);
1196        sequencer_busy = 0;
1197}
1198
1199static int seq_sync(void)
1200{
1201        unsigned long flags;
1202
1203        if (qlen && !seq_playing && !signal_pending(current))
1204                seq_startplay();
1205
1206        save_flags(flags);
1207        cli();
1208        if (qlen > 0)
1209                interruptible_sleep_on_timeout(&seq_sleeper, HZ);
1210        restore_flags(flags);
1211        return qlen;
1212}
1213
1214static void midi_outc(int dev, unsigned char data)
1215{
1216        /*
1217         * NOTE! Calls sleep(). Don't call this from interrupt.
1218         */
1219
1220        int n;
1221        unsigned long flags;
1222
1223        /*
1224         * This routine sends one byte to the Midi channel.
1225         * If the output FIFO is full, it waits until there
1226         * is space in the queue
1227         */
1228
1229        n = 3 * HZ;             /* Timeout */
1230
1231        save_flags(flags);
1232        cli();
1233        while (n && !midi_devs[dev]->outputc(dev, data)) {
1234                interruptible_sleep_on_timeout(&seq_sleeper, HZ/25);
1235                n--;
1236        }
1237        restore_flags(flags);
1238}
1239
1240static void seq_reset(void)
1241{
1242        /*
1243         * NOTE! Calls sleep(). Don't call this from interrupt.
1244         */
1245
1246        int i;
1247        int chn;
1248        unsigned long flags;
1249
1250        sound_stop_timer();
1251
1252        seq_time = jiffies;
1253        prev_input_time = 0;
1254        prev_event_time = 0;
1255
1256        qlen = qhead = qtail = 0;
1257        iqlen = iqhead = iqtail = 0;
1258
1259        for (i = 0; i < max_synthdev; i++)
1260                if (synth_open_mask & (1 << i))
1261                        if (synth_devs[i])
1262                                synth_devs[i]->reset(i);
1263
1264        if (seq_mode == SEQ_2)
1265        {
1266                for (chn = 0; chn < 16; chn++)
1267                        for (i = 0; i < max_synthdev; i++)
1268                                if (synth_open_mask & (1 << i))
1269                                        if (synth_devs[i])
1270                                        {
1271                                                synth_devs[i]->controller(i, chn, 123, 0);      /* All notes off */
1272                                                synth_devs[i]->controller(i, chn, 121, 0);      /* Reset all ctl */
1273                                                synth_devs[i]->bender(i, chn, 1 << 13); /* Bender off */
1274                                        }
1275        }
1276        else    /* seq_mode == SEQ_1 */
1277        {
1278                for (i = 0; i < max_mididev; i++)
1279                        if (midi_written[i])    /*
1280                                                 * Midi used. Some notes may still be playing
1281                                                 */
1282                        {
1283                                /*
1284                                 *      Sending just a ACTIVE SENSING message should be enough to stop all
1285                                 *      playing notes. Since there are devices not recognizing the
1286                                 *      active sensing, we have to send some all notes off messages also.
1287                                 */
1288                                midi_outc(i, 0xfe);
1289
1290                                for (chn = 0; chn < 16; chn++)
1291                                {
1292                                        midi_outc(i, (unsigned char) (0xb0 + (chn & 0x0f)));            /* control change */
1293                                        midi_outc(i, 0x7b);     /* All notes off */
1294                                        midi_outc(i, 0);        /* Dummy parameter */
1295                                }
1296
1297                                midi_devs[i]->close(i);
1298
1299                                midi_written[i] = 0;
1300                                midi_opened[i] = 0;
1301                        }
1302        }
1303
1304        seq_playing = 0;
1305
1306        save_flags(flags);
1307        cli();
1308
1309        if (waitqueue_active(&seq_sleeper)) {
1310                /*      printk( "Sequencer Warning: Unexpected sleeping process - Waking up\n"); */
1311                wake_up(&seq_sleeper);
1312        }
1313        restore_flags(flags);
1314}
1315
1316static void seq_panic(void)
1317{
1318        /*
1319         * This routine is called by the application in case the user
1320         * wants to reset the system to the default state.
1321         */
1322
1323        seq_reset();
1324
1325        /*
1326         * Since some of the devices don't recognize the active sensing and
1327         * all notes off messages, we have to shut all notes manually.
1328         *
1329         *      TO BE IMPLEMENTED LATER
1330         */
1331
1332        /*
1333         * Also return the controllers to their default states
1334         */
1335}
1336
1337int sequencer_ioctl(int dev, struct file *file, unsigned int cmd, caddr_t arg)
1338{
1339        int midi_dev, orig_dev, val, err;
1340        int mode = translate_mode(file);
1341        struct synth_info inf;
1342        struct seq_event_rec event_rec;
1343        unsigned long flags;
1344
1345        orig_dev = dev = dev >> 4;
1346
1347        switch (cmd)
1348        {
1349                case SNDCTL_TMR_TIMEBASE:
1350                case SNDCTL_TMR_TEMPO:
1351                case SNDCTL_TMR_START:
1352                case SNDCTL_TMR_STOP:
1353                case SNDCTL_TMR_CONTINUE:
1354                case SNDCTL_TMR_METRONOME:
1355                case SNDCTL_TMR_SOURCE:
1356                        if (seq_mode != SEQ_2)
1357                                return -EINVAL;
1358                        return tmr->ioctl(tmr_no, cmd, arg);
1359
1360                case SNDCTL_TMR_SELECT:
1361                        if (seq_mode != SEQ_2)
1362                                return -EINVAL;
1363                        if (get_user(pending_timer, (int *)arg))
1364                                return -EFAULT;
1365                        if (pending_timer < 0 || pending_timer >= num_sound_timers || sound_timer_devs[pending_timer] == NULL)
1366                        {
1367                                pending_timer = -1;
1368                                return -EINVAL;
1369                        }
1370                        val = pending_timer;
1371                        break;
1372
1373                case SNDCTL_SEQ_PANIC:
1374                        seq_panic();
1375                        return -EINVAL;
1376
1377                case SNDCTL_SEQ_SYNC:
1378                        if (mode == OPEN_READ)
1379                                return 0;
1380                        while (qlen > 0 && !signal_pending(current))
1381                                seq_sync();
1382                        return qlen ? -EINTR : 0;
1383
1384                case SNDCTL_SEQ_RESET:
1385                        seq_reset();
1386                        return 0;
1387
1388                case SNDCTL_SEQ_TESTMIDI:
1389                        if (__get_user(midi_dev, (int *)arg))
1390                                return -EFAULT;
1391                        if (midi_dev < 0 || midi_dev >= max_mididev || !midi_devs[midi_dev])
1392                                return -ENXIO;
1393
1394                        if (!midi_opened[midi_dev] &&
1395                                (err = midi_devs[midi_dev]->open(midi_dev, mode, sequencer_midi_input,
1396                                                     sequencer_midi_output)) < 0)
1397                                return err;
1398                        midi_opened[midi_dev] = 1;
1399                        return 0;
1400
1401                case SNDCTL_SEQ_GETINCOUNT:
1402                        if (mode == OPEN_WRITE)
1403                                return 0;
1404                        val = iqlen;
1405                        break;
1406
1407                case SNDCTL_SEQ_GETOUTCOUNT:
1408                        if (mode == OPEN_READ)
1409                                return 0;
1410                        val = SEQ_MAX_QUEUE - qlen;
1411                        break;
1412
1413                case SNDCTL_SEQ_GETTIME:
1414                        if (seq_mode == SEQ_2)
1415                                return tmr->ioctl(tmr_no, cmd, arg);
1416                        val = jiffies - seq_time;
1417                        break;
1418
1419                case SNDCTL_SEQ_CTRLRATE:
1420                        /*
1421                         * If *arg == 0, just return the current rate
1422                         */
1423                        if (seq_mode == SEQ_2)
1424                                return tmr->ioctl(tmr_no, cmd, arg);
1425
1426                        if (get_user(val, (int *)arg))
1427                                return -EFAULT;
1428                        if (val != 0)
1429                                return -EINVAL;
1430                        val = HZ;
1431                        break;
1432
1433                case SNDCTL_SEQ_RESETSAMPLES:
1434                case SNDCTL_SYNTH_REMOVESAMPLE:
1435                case SNDCTL_SYNTH_CONTROL:
1436                        if (get_user(dev, (int *)arg))
1437                                return -EFAULT;
1438                        if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
1439                                return -ENXIO;
1440                        if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1441                                return -EBUSY;
1442                        return synth_devs[dev]->ioctl(dev, cmd, arg);
1443
1444                case SNDCTL_SEQ_NRSYNTHS:
1445                        val = max_synthdev;
1446                        break;
1447
1448                case SNDCTL_SEQ_NRMIDIS:
1449                        val = max_mididev;
1450                        break;
1451
1452                case SNDCTL_SYNTH_MEMAVL:
1453                        if (get_user(dev, (int *)arg))
1454                                return -EFAULT;
1455                        if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
1456                                return -ENXIO;
1457                        if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1458                                return -EBUSY;
1459                        val = synth_devs[dev]->ioctl(dev, cmd, arg);
1460                        break;
1461
1462                case SNDCTL_FM_4OP_ENABLE:
1463                        if (get_user(dev, (int *)arg))
1464                                return -EFAULT;
1465                        if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
1466                                return -ENXIO;
1467                        if (!(synth_open_mask & (1 << dev)))
1468                                return -ENXIO;
1469                        synth_devs[dev]->ioctl(dev, cmd, arg);
1470                        return 0;
1471
1472                case SNDCTL_SYNTH_INFO:
1473                        if (get_user(dev, (int *)(&(((struct synth_info *)arg)->device))))
1474                                return -EFAULT;
1475                        if (dev < 0 || dev >= max_synthdev)
1476                                return -ENXIO;
1477                        if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1478                                return -EBUSY;
1479                        return synth_devs[dev]->ioctl(dev, cmd, arg);
1480
1481                /* Like SYNTH_INFO but returns ID in the name field */
1482                case SNDCTL_SYNTH_ID:
1483                        if (get_user(dev, (int *)(&(((struct synth_info *)arg)->device))))
1484                                return -EFAULT;
1485                        if (dev < 0 || dev >= max_synthdev)
1486                                return -ENXIO;
1487                        if (!(synth_open_mask & (1 << dev)) && !orig_dev)
1488                                return -EBUSY;
1489                        memcpy(&inf, synth_devs[dev]->info, sizeof(inf));
1490                        strncpy(inf.name, synth_devs[dev]->id, sizeof(inf.name));
1491                        inf.device = dev;
1492                        return copy_to_user(arg, &inf, sizeof(inf))?-EFAULT:0;
1493
1494                case SNDCTL_SEQ_OUTOFBAND:
1495                        if (copy_from_user(&event_rec, arg, sizeof(event_rec)))
1496                                return -EFAULT;
1497                        save_flags(flags);
1498                        cli();
1499                        play_event(event_rec.arr);
1500                        restore_flags(flags);
1501                        return 0;
1502
1503                case SNDCTL_MIDI_INFO:
1504                        if (get_user(dev, (int *)(&(((struct midi_info *)arg)->device))))
1505                                return -EFAULT;
1506                        if (dev < 0 || dev >= max_mididev || !midi_devs[dev])
1507                                return -ENXIO;
1508                        midi_devs[dev]->info.device = dev;
1509                        return copy_to_user(arg, &midi_devs[dev]->info, sizeof(struct midi_info))?-EFAULT:0;
1510
1511                case SNDCTL_SEQ_THRESHOLD:
1512                        if (get_user(val, (int *)arg))
1513                                return -EFAULT;
1514                        if (val < 1)
1515                                val = 1;
1516                        if (val >= SEQ_MAX_QUEUE)
1517                                val = SEQ_MAX_QUEUE - 1;
1518                        output_threshold = val;
1519                        return 0;
1520
1521                case SNDCTL_MIDI_PRETIME:
1522                        if (get_user(val, (int *)arg))
1523                                return -EFAULT;
1524                        if (val < 0)
1525                                val = 0;
1526                        val = (HZ * val) / 10;
1527                        pre_event_timeout = val;
1528                        break;
1529
1530                default:
1531                        if (mode == OPEN_READ)
1532                                return -EIO;
1533                        if (!synth_devs[0])
1534                                return -ENXIO;
1535                        if (!(synth_open_mask & (1 << 0)))
1536                                return -ENXIO;
1537                        if (!synth_devs[0]->ioctl)
1538                                return -EINVAL;
1539                        return synth_devs[0]->ioctl(0, cmd, arg);
1540        }
1541        return put_user(val, (int *)arg);
1542}
1543
1544/* No kernel lock - we're using the global irq lock here */
1545unsigned int sequencer_poll(int dev, struct file *file, poll_table * wait)
1546{
1547        unsigned long flags;
1548        unsigned int mask = 0;
1549
1550        dev = dev >> 4;
1551
1552        save_flags(flags);
1553        cli();
1554        /* input */
1555        poll_wait(file, &midi_sleeper, wait);
1556        if (iqlen)
1557                mask |= POLLIN | POLLRDNORM;
1558
1559        /* output */
1560        poll_wait(file, &seq_sleeper, wait);
1561        if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
1562                mask |= POLLOUT | POLLWRNORM;
1563        restore_flags(flags);
1564        return mask;
1565}
1566
1567
1568void sequencer_timer(unsigned long dummy)
1569{
1570        seq_startplay();
1571}
1572
1573int note_to_freq(int note_num)
1574{
1575
1576        /*
1577         * This routine converts a midi note to a frequency (multiplied by 1000)
1578         */
1579
1580        int note, octave, note_freq;
1581        static int notes[] =
1582        {
1583                261632, 277189, 293671, 311132, 329632, 349232,
1584                369998, 391998, 415306, 440000, 466162, 493880
1585        };
1586
1587#define BASE_OCTAVE     5
1588
1589        octave = note_num / 12;
1590        note = note_num % 12;
1591
1592        note_freq = notes[note];
1593
1594        if (octave < BASE_OCTAVE)
1595                note_freq >>= (BASE_OCTAVE - octave);
1596        else if (octave > BASE_OCTAVE)
1597                note_freq <<= (octave - BASE_OCTAVE);
1598
1599        /*
1600         * note_freq >>= 1;
1601         */
1602
1603        return note_freq;
1604}
1605
1606unsigned long compute_finetune(unsigned long base_freq, int bend, int range,
1607                 int vibrato_cents)
1608{
1609        unsigned long amount;
1610        int negative, semitones, cents, multiplier = 1;
1611
1612        if (!bend)
1613                return base_freq;
1614        if (!range)
1615                return base_freq;
1616
1617        if (!base_freq)
1618                return base_freq;
1619
1620        if (range >= 8192)
1621                range = 8192;
1622
1623        bend = bend * range / 8192;     /* Convert to cents */
1624        bend += vibrato_cents;
1625
1626        if (!bend)
1627                return base_freq;
1628
1629        negative = bend < 0 ? 1 : 0;
1630
1631        if (bend < 0)
1632                bend *= -1;
1633        if (bend > range)
1634                bend = range;
1635
1636        /*
1637           if (bend > 2399)
1638           bend = 2399;
1639         */
1640        while (bend > 2399)
1641        {
1642                multiplier *= 4;
1643                bend -= 2400;
1644        }
1645
1646        semitones = bend / 100;
1647        if (semitones > 99)
1648                semitones = 99;
1649        cents = bend % 100;
1650
1651        amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents]) / 10000;
1652
1653        if (negative)
1654                return (base_freq * 10000) / amount;    /* Bend down */
1655        else
1656                return (base_freq * amount) / 10000;    /* Bend up */
1657}
1658
1659
1660void sequencer_init(void)
1661{
1662        /* drag in sequencer_syms.o */
1663        {
1664                extern char sequencer_syms_symbol;
1665                sequencer_syms_symbol = 0;
1666        }
1667
1668        if (sequencer_ok)
1669                return;
1670        MIDIbuf_init();
1671        queue = (unsigned char *)vmalloc(SEQ_MAX_QUEUE * EV_SZ);
1672        if (queue == NULL)
1673        {
1674                printk(KERN_ERR "sequencer: Can't allocate memory for sequencer output queue\n");
1675                return;
1676        }
1677        iqueue = (unsigned char *)vmalloc(SEQ_MAX_QUEUE * IEV_SZ);
1678        if (iqueue == NULL)
1679        {
1680                printk(KERN_ERR "sequencer: Can't allocate memory for sequencer input queue\n");
1681                vfree(queue);
1682                return;
1683        }
1684        sequencer_ok = 1;
1685}
1686
1687void sequencer_unload(void)
1688{
1689        if(queue)
1690        {
1691                vfree(queue);
1692                queue=NULL;
1693        }
1694        if(iqueue)
1695        {
1696                vfree(iqueue);
1697                iqueue=NULL;
1698        }
1699}
1700