[funini.com] -> [kei@sodan] -> Kernel Reading

root/sound/oss/sequencer.c

/* [<][>][^][v][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_poll
  29. sequencer_timer
  30. note_to_freq
  31. compute_finetune
  32. sequencer_init
  33. sequencer_unload

/*
 * sound/oss/sequencer.c
 *
 * The sequencer personality manager.
 */
/*
 * Copyright (C) by Hannu Savolainen 1993-1997
 *
 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 * Version 2 (June 1991). See the "COPYING" file distributed with this software
 * for more info.
 */
/*
 * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
 * Alan Cox        : reformatted and fixed a pair of null pointer bugs
 */
#include <linux/kmod.h>
#include <linux/spinlock.h>
#include "sound_config.h"

#include "midi_ctrl.h"

static int      sequencer_ok;
static struct sound_timer_operations *tmr;
static int      tmr_no = -1;    /* Currently selected timer */
static int      pending_timer = -1;     /* For timer change operation */
extern unsigned long seq_time;

static int      obsolete_api_used;
static DEFINE_SPINLOCK(lock);

/*
 * Local counts for number of synth and MIDI devices. These are initialized
 * by the sequencer_open.
 */
static int      max_mididev;
static int      max_synthdev;

/*
 * The seq_mode gives the operating mode of the sequencer:
 *      1 = level1 (the default)
 *      2 = level2 (extended capabilities)
 */

#define SEQ_1   1
#define SEQ_2   2
static int      seq_mode = SEQ_1;

static DECLARE_WAIT_QUEUE_HEAD(seq_sleeper);
static DECLARE_WAIT_QUEUE_HEAD(midi_sleeper);

static int      midi_opened[MAX_MIDI_DEV];

static int      midi_written[MAX_MIDI_DEV];

static unsigned long prev_input_time;
static int      prev_event_time;

#include "tuning.h"

#define EV_SZ   8
#define IEV_SZ  8

static unsigned char *queue;
static unsigned char *iqueue;

static volatile int qhead, qtail, qlen;
static volatile int iqhead, iqtail, iqlen;
static volatile int seq_playing;
static volatile int sequencer_busy;
static int      output_threshold;
static long     pre_event_timeout;
static unsigned synth_open_mask;

static int      seq_queue(unsigned char *note, char nonblock);
static void     seq_startplay(void);
static int      seq_sync(void);
static void     seq_reset(void);

#if MAX_SYNTH_DEV > 15
#error Too many synthesizer devices enabled.
#endif

int sequencer_read(int dev, struct file *file, char __user *buf, int count)
{
        int c = count, p = 0;
        int ev_len;
        unsigned long flags;

        dev = dev >> 4;

        ev_len = seq_mode == SEQ_1 ? 4 : 8;

        spin_lock_irqsave(&lock,flags);

        if (!iqlen)
        {
                spin_unlock_irqrestore(&lock,flags);
                if (file->f_flags & O_NONBLOCK) {
                        return -EAGAIN;
                }

                interruptible_sleep_on_timeout(&midi_sleeper,
                                               pre_event_timeout);
                spin_lock_irqsave(&lock,flags);
                if (!iqlen)
                {
                        spin_unlock_irqrestore(&lock,flags);
                        return 0;
                }
        }
        while (iqlen && c >= ev_len)
        {
                char *fixit = (char *) &iqueue[iqhead * IEV_SZ];
                spin_unlock_irqrestore(&lock,flags);
                if (copy_to_user(&(buf)[p], fixit, ev_len))
                        return count - c;
                p += ev_len;
                c -= ev_len;

                spin_lock_irqsave(&lock,flags);
                iqhead = (iqhead + 1) % SEQ_MAX_QUEUE;
                iqlen--;
        }
        spin_unlock_irqrestore(&lock,flags);
        return count - c;
}

static void sequencer_midi_output(int dev)
{
        /*
         * Currently NOP
         */
}

void seq_copy_to_input(unsigned char *event_rec, int len)
{
        unsigned long flags;

        /*
         * Verify that the len is valid for the current mode.
         */

        if (len != 4 && len != 8)
                return;
        if ((seq_mode == SEQ_1) != (len == 4))
                return;

        if (iqlen >= (SEQ_MAX_QUEUE - 1))
                return;         /* Overflow */

        spin_lock_irqsave(&lock,flags);
        memcpy(&iqueue[iqtail * IEV_SZ], event_rec, len);
        iqlen++;
        iqtail = (iqtail + 1) % SEQ_MAX_QUEUE;
        wake_up(&midi_sleeper);
        spin_unlock_irqrestore(&lock,flags);
}
EXPORT_SYMBOL(seq_copy_to_input);

static void sequencer_midi_input(int dev, unsigned char data)
{
        unsigned int tstamp;
        unsigned char event_rec[4];

        if (data == 0xfe)       /* Ignore active sensing */
                return;

        tstamp = jiffies - seq_time;

        if (tstamp != prev_input_time)
        {
                tstamp = (tstamp << 8) | SEQ_WAIT;
                seq_copy_to_input((unsigned char *) &tstamp, 4);
                prev_input_time = tstamp;
        }
        event_rec[0] = SEQ_MIDIPUTC;
        event_rec[1] = data;
        event_rec[2] = dev;
        event_rec[3] = 0;

        seq_copy_to_input(event_rec, 4);
}

void seq_input_event(unsigned char *event_rec, int len)
{
        unsigned long this_time;

        if (seq_mode == SEQ_2)
                this_time = tmr->get_time(tmr_no);
        else
                this_time = jiffies - seq_time;

        if (this_time != prev_input_time)
        {
                unsigned char   tmp_event[8];

                tmp_event[0] = EV_TIMING;
                tmp_event[1] = TMR_WAIT_ABS;
                tmp_event[2] = 0;
                tmp_event[3] = 0;
                *(unsigned int *) &tmp_event[4] = this_time;

                seq_copy_to_input(tmp_event, 8);
                prev_input_time = this_time;
        }
        seq_copy_to_input(event_rec, len);
}
EXPORT_SYMBOL(seq_input_event);

int sequencer_write(int dev, struct file *file, const char __user *buf, int count)
{
        unsigned char event_rec[EV_SZ], ev_code;
        int p = 0, c, ev_size;
        int err;
        int mode = translate_mode(file);

        dev = dev >> 4;

        DEB(printk("sequencer_write(dev=%d, count=%d)\n", dev, count));

        if (mode == OPEN_READ)
                return -EIO;

        c = count;

        while (c >= 4)
        {
                if (copy_from_user((char *) event_rec, &(buf)[p], 4))
                        goto out;
                ev_code = event_rec[0];

                if (ev_code == SEQ_FULLSIZE)
                {
                        int err, fmt;

                        dev = *(unsigned short *) &event_rec[2];
                        if (dev < 0 || dev >= max_synthdev || synth_devs[dev] == NULL)
                                return -ENXIO;

                        if (!(synth_open_mask & (1 << dev)))
                                return -ENXIO;

                        fmt = (*(short *) &event_rec[0]) & 0xffff;
                        err = synth_devs[dev]->load_patch(dev, fmt, buf, p + 4, c, 0);
                        if (err < 0)
                                return err;

                        return err;
                }
                if (ev_code >= 128)
                {
                        if (seq_mode == SEQ_2 && ev_code == SEQ_EXTENDED)
                        {
                                printk(KERN_WARNING "Sequencer: Invalid level 2 event %x\n", ev_code);
                                return -EINVAL;
                        }
                        ev_size = 8;

                        if (c < ev_size)
                        {
                                if (!seq_playing)
                                        seq_startplay();
                                return count - c;
                        }
                        if (copy_from_user((char *)&event_rec[4],
                                           &(buf)[p + 4], 4))
                                goto out;

                }
                else
                {
                        if (seq_mode == SEQ_2)
                        {
                                printk(KERN_WARNING "Sequencer: 4 byte event in level 2 mode\n");
                                return -EINVAL;
                        }
                        ev_size = 4;

                        if (event_rec[0] != SEQ_MIDIPUTC)
                                obsolete_api_used = 1;
                }

                if (event_rec[0] == SEQ_MIDIPUTC)
                {
                        if (!midi_opened[event_rec[2]])
                        {
                                int mode;
                                int dev = event_rec[2];

                                if (dev >= max_mididev || midi_devs[dev]==NULL)
                                {
                                        /*printk("Sequencer Error: Nonexistent MIDI device %d\n", dev);*/
                                        return -ENXIO;
                                }
                                mode = translate_mode(file);

                                if ((err = midi_devs[dev]->open(dev, mode,
                                                                sequencer_midi_input, sequencer_midi_output)) < 0)
                                {
                                        seq_reset();
                                        printk(KERN_WARNING "Sequencer Error: Unable to open Midi #%d\n", dev);
                                        return err;
                                }
                                midi_opened[dev] = 1;
                        }
                }
                if (!seq_queue(event_rec, (file->f_flags & (O_NONBLOCK) ? 1 : 0)))
                {
                        int processed = count - c;

                        if (!seq_playing)
                                seq_startplay();

                        if (!processed && (file->f_flags & O_NONBLOCK))
                                return -EAGAIN;
                        else
                                return processed;
                }
                p += ev_size;
                c -= ev_size;
        }

        if (!seq_playing)
                seq_startplay();
out:
        return count;
}

static int seq_queue(unsigned char *note, char nonblock)
{

        /*
         * Test if there is space in the queue
         */

        if (qlen >= SEQ_MAX_QUEUE)
                if (!seq_playing)
                        seq_startplay();        /*
                                                 * Give chance to drain the queue
                                                 */

        if (!nonblock && qlen >= SEQ_MAX_QUEUE && !waitqueue_active(&seq_sleeper)) {
                /*
                 * Sleep until there is enough space on the queue
                 */
                interruptible_sleep_on(&seq_sleeper);
        }
        if (qlen >= SEQ_MAX_QUEUE)
        {
                return 0;       /*
                                 * To be sure
                                 */
        }
        memcpy(&queue[qtail * EV_SZ], note, EV_SZ);

        qtail = (qtail + 1) % SEQ_MAX_QUEUE;
        qlen++;

        return 1;
}

static int extended_event(unsigned char *q)
{
        int dev = q[2];

        if (dev < 0 || dev >= max_synthdev)
                return -ENXIO;

        if (!(synth_open_mask & (1 << dev)))
                return -ENXIO;

        switch (q[1])
        {
                case SEQ_NOTEOFF:
                        synth_devs[dev]->kill_note(dev, q[3], q[4], q[5]);
                        break;

                case SEQ_NOTEON:
                        if (q[4] > 127 && q[4] != 255)
                                return 0;

                        if (q[5] == 0)
                        {
                                synth_devs[dev]->kill_note(dev, q[3], q[4], q[5]);
                                break;
                        }
                        synth_devs[dev]->start_note(dev, q[3], q[4], q[5]);
                        break;

                case SEQ_PGMCHANGE:
                        synth_devs[dev]->set_instr(dev, q[3], q[4]);
                        break;

                case SEQ_AFTERTOUCH:
                        synth_devs[dev]->aftertouch(dev, q[3], q[4]);
                        break;

                case SEQ_BALANCE:
                        synth_devs[dev]->panning(dev, q[3], (char) q[4]);
                        break;

                case SEQ_CONTROLLER:
                        synth_devs[dev]->controller(dev, q[3], q[4], (short) (q[5] | (q[6] << 8)));
                        break;

                case SEQ_VOLMODE:
                        if (synth_devs[dev]->volume_method != NULL)
                                synth_devs[dev]->volume_method(dev, q[3]);
                        break;

                default:
                        return -EINVAL;
        }
        return 0;
}

static int find_voice(int dev, int chn, int note)
{
        unsigned short key;
        int i;

        key = (chn << 8) | (note + 1);
        for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
                if (synth_devs[dev]->alloc.map[i] == key)
                        return i;
        return -1;
}

static int alloc_voice(int dev, int chn, int note)
{
        unsigned short  key;
        int voice;

        key = (chn << 8) | (note + 1);

        voice = synth_devs[dev]->alloc_voice(dev, chn, note,
                                             &synth_devs[dev]->alloc);
        synth_devs[dev]->alloc.map[voice] = key;
        synth_devs[dev]->alloc.alloc_times[voice] =
                        synth_devs[dev]->alloc.timestamp++;
        return voice;
}

static void seq_chn_voice_event(unsigned char *event_rec)
{
#define dev event_rec[1]
#define cmd event_rec[2]
#define chn event_rec[3]
#define note event_rec[4]
#define parm event_rec[5]

        int voice = -1;

        if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
                return;
        if (!(synth_open_mask & (1 << dev)))
                return;
        if (!synth_devs[dev])
                return;

        if (seq_mode == SEQ_2)
        {
                if (synth_devs[dev]->alloc_voice)
                        voice = find_voice(dev, chn, note);

                if (cmd == MIDI_NOTEON && parm == 0)
                {
                        cmd = MIDI_NOTEOFF;
                        parm = 64;
                }
        }

        switch (cmd)
        {
                case MIDI_NOTEON:
                        if (note > 127 && note != 255)  /* Not a seq2 feature */
                                return;

                        if (voice == -1 && seq_mode == SEQ_2 && synth_devs[dev]->alloc_voice)
                        {
                                /* Internal synthesizer (FM, GUS, etc) */
                                voice = alloc_voice(dev, chn, note);
                        }
                        if (voice == -1)
                                voice = chn;

                        if (seq_mode == SEQ_2 && (int) dev < num_synths)
                        {
                                /*
                                 * The MIDI channel 10 is a percussive channel. Use the note
                                 * number to select the proper patch (128 to 255) to play.
                                 */

                                if (chn == 9)
                                {
                                        synth_devs[dev]->set_instr(dev, voice, 128 + note);
                                        synth_devs[dev]->chn_info[chn].pgm_num = 128 + note;
                                }
                                synth_devs[dev]->setup_voice(dev, voice, chn);
                        }
                        synth_devs[dev]->start_note(dev, voice, note, parm);
                        break;

                case MIDI_NOTEOFF:
                        if (voice == -1)
                                voice = chn;
                        synth_devs[dev]->kill_note(dev, voice, note, parm);
                        break;

                case MIDI_KEY_PRESSURE:
                        if (voice == -1)
                                voice = chn;
                        synth_devs[dev]->aftertouch(dev, voice, parm);
                        break;

                default:;
        }
#undef dev
#undef cmd
#undef chn
#undef note
#undef parm
}


static void seq_chn_common_event(unsigned char *event_rec)
{
        unsigned char dev = event_rec[1];
        unsigned char cmd = event_rec[2];
        unsigned char chn = event_rec[3];
        unsigned char p1 = event_rec[4];

        /* unsigned char p2 = event_rec[5]; */
        unsigned short w14 = *(short *) &event_rec[6];

        if ((int) dev > max_synthdev || synth_devs[dev] == NULL)
                return;
        if (!(synth_open_mask & (1 << dev)))
                return;
        if (!synth_devs[dev])
                return;

        switch (cmd)
        {
                case MIDI_PGM_CHANGE:
                        if (seq_mode == SEQ_2)
                        {
                                synth_devs[dev]->chn_info[chn].pgm_num = p1;
                                if ((int) dev >= num_synths)
                                        synth_devs[dev]->set_instr(dev, chn, p1);
                        }
                        else
                                synth_devs[dev]->set_instr(dev, chn, p1);

                        break;

                case MIDI_CTL_CHANGE:
                        if (seq_mode == SEQ_2)
                        {
                                if (chn > 15 || p1 > 127)
                                        break;

                                synth_devs[dev]->chn_info[chn].controllers[p1] = w14 & 0x7f;

                                if (p1 < 32)    /* Setting MSB should clear LSB to 0 */
                                        synth_devs[dev]->chn_info[chn].controllers[p1 + 32] = 0;

                                if ((int) dev < num_synths)
                                {
                                        int val = w14 & 0x7f;
                                        int i, key;

                                        if (p1 < 64)    /* Combine MSB and LSB */
                                        {
                                                val = ((synth_devs[dev]->
                                                        chn_info[chn].controllers[p1 & ~32] & 0x7f) << 7)
                                                        | (synth_devs[dev]->
                                                        chn_info[chn].controllers[p1 | 32] & 0x7f);
                                                p1 &= ~32;
                                        }
                                        /* Handle all playing notes on this channel */

                                        key = ((int) chn << 8);

                                        for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
                                                if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
                                                        synth_devs[dev]->controller(dev, i, p1, val);
                                }
                                else
                                        synth_devs[dev]->controller(dev, chn, p1, w14);
                        }
                        else    /* Mode 1 */
                                synth_devs[dev]->controller(dev, chn, p1, w14);
                        break;

                case MIDI_PITCH_BEND:
                        if (seq_mode == SEQ_2)
                        {
                                synth_devs[dev]->chn_info[chn].bender_value = w14;

                                if ((int) dev < num_synths)
                                {
                                        /* Handle all playing notes on this channel */
                                        int i, key;

                                        key = (chn << 8);

                                        for (i = 0; i < synth_devs[dev]->alloc.max_voice; i++)
                                                if ((synth_devs[dev]->alloc.map[i] & 0xff00) == key)
                                                        synth_devs[dev]->bender(dev, i, w14);
                                }
                                else
                                        synth_devs[dev]->bender(dev, chn, w14);
                        }
                        else    /* MODE 1 */
                                synth_devs[dev]->bender(dev, chn, w14);
                        break;

                default:;
        }
}

static int seq_timing_event(unsigned char *event_rec)
{
        unsigned char cmd = event_rec[1];
        unsigned int parm = *(int *) &event_rec[4];

        if (seq_mode == SEQ_2)
        {
                int ret;

                if ((ret = tmr->event(tmr_no, event_rec)) == TIMER_ARMED)
                        if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
                                wake_up(&seq_sleeper);
                return ret;
        }
        switch (cmd)
        {
                case TMR_WAIT_REL:
                        parm += prev_event_time;

                        /*
                         * NOTE!  No break here. Execution of TMR_WAIT_REL continues in the
                         * next case (TMR_WAIT_ABS)
                         */

                case TMR_WAIT_ABS:
                        if (parm > 0)
                        {
                                long time;

                                time = parm;
                                prev_event_time = time;

                                seq_playing = 1;
                                request_sound_timer(time);

                                if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
                                        wake_up(&seq_sleeper);
                                return TIMER_ARMED;
                        }
                        break;

                case TMR_START:
                        seq_time = jiffies;
                        prev_input_time = 0;
                        prev_event_time = 0;
                        break;

                case TMR_STOP:
                        break;

                case TMR_CONTINUE:
                        break;

                case TMR_TEMPO:
                        break;

                case TMR_ECHO:
                        if (seq_mode == SEQ_2)
                                seq_copy_to_input(event_rec, 8);
                        else
                        {
                                parm = (parm << 8 | SEQ_ECHO);
                                seq_copy_to_input((unsigned char *) &parm, 4);
                        }
                        break;

                default:;
        }

        return TIMER_NOT_ARMED;
}

static void seq_local_event(unsigned char *event_rec)
{
        unsigned char   cmd = event_rec[1];
        unsigned int    parm = *((unsigned int *) &event_rec[4]);

        switch (cmd)
        {
                case LOCL_STARTAUDIO:
                        DMAbuf_start_devices(parm);
                        break;

                default:;
        }
}

static void seq_sysex_message(unsigned char *event_rec)
{
        unsigned int dev = event_rec[1];
        int i, l = 0;
        unsigned char  *buf = &event_rec[2];

        if (dev > max_synthdev)
                return;
        if (!(synth_open_mask & (1 << dev)))
                return;
        if (!synth_devs[dev])
                return;

        l = 0;
        for (i = 0; i < 6 && buf[i] != 0xff; i++)
                l = i + 1;

        if (!synth_devs[dev]->send_sysex)
                return;
        if (l > 0)
                synth_devs[dev]->send_sysex(dev, buf, l);
}

static int play_event(unsigned char *q)
{
        /*
         * NOTE! This routine returns
         *   0 = normal event played.
         *   1 = Timer armed. Suspend playback until timer callback.
         *   2 = MIDI output buffer full. Restore queue and suspend until timer
         */
        unsigned int *delay;

        switch (q[0])
        {
                case SEQ_NOTEOFF:
                        if (synth_open_mask & (1 << 0))
                                if (synth_devs[0])
                                        synth_devs[0]->kill_note(0, q[1], 255, q[3]);
                        break;

                case SEQ_NOTEON:
                        if (q[4] < 128 || q[4] == 255)
                                if (synth_open_mask & (1 << 0))
                                        if (synth_devs[0])
                                                synth_devs[0]->start_note(0, q[1], q[2], q[3]);
                        break;

                case SEQ_WAIT:
                        delay = (unsigned int *) q;     /*
                                                         * Bytes 1 to 3 are containing the *
                                                         * delay in 'ticks'
                                                         */
                        *delay = (*delay >> 8) & 0xffffff;

                        if (*delay > 0)
                        {
                                long time;

                                seq_playing = 1;
                                time = *delay;
                                prev_event_time = time;

                                request_sound_timer(time);

                                if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
                                        wake_up(&seq_sleeper);
                                /*
                                 * The timer is now active and will reinvoke this function
                                 * after the timer expires. Return to the caller now.
                                 */
                                return 1;
                        }
                        break;

                case SEQ_PGMCHANGE:
                        if (synth_open_mask & (1 << 0))
                                if (synth_devs[0])
                                        synth_devs[0]->set_instr(0, q[1], q[2]);
                        break;

                case SEQ_SYNCTIMER:     /*
                                         * Reset timer
                                         */
                        seq_time = jiffies;
                        prev_input_time = 0;
                        prev_event_time = 0;
                        break;

                case SEQ_MIDIPUTC:      /*
                                         * Put a midi character
                                         */
                        if (midi_opened[q[2]])
                        {
                                int dev;

                                dev = q[2];

                                if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
                                        break;

                                if (!midi_devs[dev]->outputc(dev, q[1]))
                                {
                                        /*
                                         * Output FIFO is full. Wait one timer cycle and try again.
                                         */

                                        seq_playing = 1;
                                        request_sound_timer(-1);
                                        return 2;
                                }
                                else
                                        midi_written[dev] = 1;
                        }
                        break;

                case SEQ_ECHO:
                        seq_copy_to_input(q, 4);        /*
                                                         * Echo back to the process
                                                         */
                        break;

                case SEQ_PRIVATE:
                        if ((int) q[1] < max_synthdev)
                                synth_devs[q[1]]->hw_control(q[1], q);
                        break;

                case SEQ_EXTENDED:
                        extended_event(q);
                        break;

                case EV_CHN_VOICE:
                        seq_chn_voice_event(q);
                        break;

                case EV_CHN_COMMON:
                        seq_chn_common_event(q);
                        break;

                case EV_TIMING:
                        if (seq_timing_event(q) == TIMER_ARMED)
                        {
                                return 1;
                        }
                        break;

                case EV_SEQ_LOCAL:
                        seq_local_event(q);
                        break;

                case EV_SYSEX:
                        seq_sysex_message(q);
                        break;

                default:;
        }
        return 0;
}

/* called also as timer in irq context */
static void seq_startplay(void)
{
        int this_one, action;
        unsigned long flags;

        while (qlen > 0)
        {

                spin_lock_irqsave(&lock,flags);
                qhead = ((this_one = qhead) + 1) % SEQ_MAX_QUEUE;
                qlen--;
                spin_unlock_irqrestore(&lock,flags);

                seq_playing = 1;

                if ((action = play_event(&queue[this_one * EV_SZ])))
                {               /* Suspend playback. Next timer routine invokes this routine again */
                        if (action == 2)
                        {
                                qlen++;
                                qhead = this_one;
                        }
                        return;
                }
        }

        seq_playing = 0;

        if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
                wake_up(&seq_sleeper);
}

static void reset_controllers(int dev, unsigned char *controller, int update_dev)
{
        int i;
        for (i = 0; i < 128; i++)
                controller[i] = ctrl_def_values[i];
}

static void setup_mode2(void)
{
        int dev;

        max_synthdev = num_synths;

        for (dev = 0; dev < num_midis; dev++)
        {
                if (midi_devs[dev] && midi_devs[dev]->converter != NULL)
                {
                        synth_devs[max_synthdev++] = midi_devs[dev]->converter;
                }
        }

        for (dev = 0; dev < max_synthdev; dev++)
        {
                int chn;

                synth_devs[dev]->sysex_ptr = 0;
                synth_devs[dev]->emulation = 0;

                for (chn = 0; chn < 16; chn++)
                {
                        synth_devs[dev]->chn_info[chn].pgm_num = 0;
                        reset_controllers(dev,
                                synth_devs[dev]->chn_info[chn].controllers,0);
                        synth_devs[dev]->chn_info[chn].bender_value = (1 << 7); /* Neutral */
                        synth_devs[dev]->chn_info[chn].bender_range = 200;
                }
        }
        max_mididev = 0;
        seq_mode = SEQ_2;
}

int sequencer_open(int dev, struct file *file)
{
        int retval, mode, i;
        int level, tmp;

        if (!sequencer_ok)
                sequencer_init();

        level = ((dev & 0x0f) == SND_DEV_SEQ2) ? 2 : 1;

        dev = dev >> 4;
        mode = translate_mode(file);

        DEB(printk("sequencer_open(dev=%d)\n", dev));

        if (!sequencer_ok)
        {
/*              printk("Sound card: sequencer not initialized\n");*/
                return -ENXIO;
        }
        if (dev)                /* Patch manager device (obsolete) */
                return -ENXIO;

        if(synth_devs[dev] == NULL)
                request_module("synth0");

        if (mode == OPEN_READ)
        {
                if (!num_midis)
                {
                        /*printk("Sequencer: No MIDI devices. Input not possible\n");*/
                        sequencer_busy = 0;
                        return -ENXIO;
                }
        }
        if (sequencer_busy)
        {
                return -EBUSY;
        }
        sequencer_busy = 1;
        obsolete_api_used = 0;

        max_mididev = num_midis;
        max_synthdev = num_synths;
        pre_event_timeout = MAX_SCHEDULE_TIMEOUT;
        seq_mode = SEQ_1;

        if (pending_timer != -1)
        {
                tmr_no = pending_timer;
                pending_timer = -1;
        }
        if (tmr_no == -1)       /* Not selected yet */
        {
                int i, best;

                best = -1;
                for (i = 0; i < num_sound_timers; i++)
                        if (sound_timer_devs[i] && sound_timer_devs[i]->priority > best)
                        {
                                tmr_no = i;
                                best = sound_timer_devs[i]->priority;
                        }
                if (tmr_no == -1)       /* Should not be */
                        tmr_no = 0;
        }
        tmr = sound_timer_devs[tmr_no];

        if (level == 2)
        {
                if (tmr == NULL)
                {
                        /*printk("sequencer: No timer for level 2\n");*/
                        sequencer_busy = 0;
                        return -ENXIO;
                }
                setup_mode2();
        }
        if (!max_synthdev && !max_mididev)
        {
                sequencer_busy=0;
                return -ENXIO;
        }

        synth_open_mask = 0;

        for (i = 0; i < max_mididev; i++)
        {
                midi_opened[i] = 0;
                midi_written[i] = 0;
        }

        for (i = 0; i < max_synthdev; i++)
        {
                if (synth_devs[i]==NULL)
                        continue;

                if (!try_module_get(synth_devs[i]->owner))
                        continue;

                if ((tmp = synth_devs[i]->open(i, mode)) < 0)
                {
                        printk(KERN_WARNING "Sequencer: Warning! Cannot open synth device #%d (%d)\n", i, tmp);
                        if (synth_devs[i]->midi_dev)
                                printk(KERN_WARNING "(Maps to MIDI dev #%d)\n", synth_devs[i]->midi_dev);
                }
                else
                {
                        synth_open_mask |= (1 << i);
                        if (synth_devs[i]->midi_dev)
                                midi_opened[synth_devs[i]->midi_dev] = 1;
                }
        }

        seq_time = jiffies;

        prev_input_time = 0;
        prev_event_time = 0;

        if (seq_mode == SEQ_1 && (mode == OPEN_READ || mode == OPEN_READWRITE))
        {
                /*
                 * Initialize midi input devices
                 */

                for (i = 0; i < max_mididev; i++)
                        if (!midi_opened[i] && midi_devs[i])
                        {
                                if (!try_module_get(midi_devs[i]->owner))
                                        continue;
        
                                if ((retval = midi_devs[i]->open(i, mode,
                                        sequencer_midi_input, sequencer_midi_output)) >= 0)
                                {
                                        midi_opened[i] = 1;
                                }
                        }
        }

        if (seq_mode == SEQ_2) {
                if (try_module_get(tmr->owner))
                        tmr->open(tmr_no, seq_mode);
        }

        init_waitqueue_head(&seq_sleeper);
        init_waitqueue_head(&midi_sleeper);
        output_threshold = SEQ_MAX_QUEUE / 2;

        return 0;
}

static void seq_drain_midi_queues(void)
{
        int i, n;

        /*
         * Give the Midi drivers time to drain their output queues
         */

        n = 1;

        while (!signal_pending(current) && n)
        {
                n = 0;

                for (i = 0; i < max_mididev; i++)
                        if (midi_opened[i] && midi_written[i])
                                if (midi_devs[i]->buffer_status != NULL)
                                        if (midi_devs[i]->buffer_status(i))
                                                n++;

                /*
                 * Let's have a delay
                 */

                if (n)
                        interruptible_sleep_on_timeout(&seq_sleeper,
                                                       HZ/10);
        }
}

void sequencer_release(int dev, struct file *file)
{
        int i;
        int mode = translate_mode(file);

        dev = dev >> 4;

        DEB(printk("sequencer_release(dev=%d)\n", dev));

        /*
         * Wait until the queue is empty (if we don't have nonblock)
         */

        if (mode != OPEN_READ && !(file->f_flags & O_NONBLOCK))
        {
                while (!signal_pending(current) && qlen > 0)
                {
                        seq_sync();
                        interruptible_sleep_on_timeout(&seq_sleeper,
                                                       3*HZ);
                        /* Extra delay */
                }
        }

        if (mode != OPEN_READ)
                seq_drain_midi_queues();        /*
                                                 * Ensure the output queues are empty
                                                 */
        seq_reset();
        if (mode != OPEN_READ)
                seq_drain_midi_queues();        /*
                                                 * Flush the all notes off messages
                                                 */

        for (i = 0; i < max_synthdev; i++)
        {
                if (synth_open_mask & (1 << i)) /*
                                                 * Actually opened
                                                 */
                        if (synth_devs[i])
                        {
                                synth_devs[i]->close(i);

                                module_put(synth_devs[i]->owner);

                                if (synth_devs[i]->midi_dev)
                                        midi_opened[synth_devs[i]->midi_dev] = 0;
                        }
        }

        for (i = 0; i < max_mididev; i++)
        {
                if (midi_opened[i]) {
                        midi_devs[i]->close(i);
                        module_put(midi_devs[i]->owner);
                }
        }

        if (seq_mode == SEQ_2) {
                tmr->close(tmr_no);
                module_put(tmr->owner);
        }

        if (obsolete_api_used)
                printk(KERN_WARNING "/dev/music: Obsolete (4 byte) API was used by %s\n", current->comm);
        sequencer_busy = 0;
}

static int seq_sync(void)
{
        if (qlen && !seq_playing && !signal_pending(current))
                seq_startplay();

        if (qlen > 0)
                interruptible_sleep_on_timeout(&seq_sleeper, HZ);
        return qlen;
}

static void midi_outc(int dev, unsigned char data)
{
        /*
         * NOTE! Calls sleep(). Don't call this from interrupt.
         */

        int n;
        unsigned long flags;

        /*
         * This routine sends one byte to the Midi channel.
         * If the output FIFO is full, it waits until there
         * is space in the queue
         */

        n = 3 * HZ;             /* Timeout */

        spin_lock_irqsave(&lock,flags);
        while (n && !midi_devs[dev]->outputc(dev, data)) {
                interruptible_sleep_on_timeout(&seq_sleeper, HZ/25);
                n--;
        }
        spin_unlock_irqrestore(&lock,flags);
}

static void seq_reset(void)
{
        /*
         * NOTE! Calls sleep(). Don't call this from interrupt.
         */

        int i;
        int chn;
        unsigned long flags;

        sound_stop_timer();

        seq_time = jiffies;
        prev_input_time = 0;
        prev_event_time = 0;

        qlen = qhead = qtail = 0;
        iqlen = iqhead = iqtail = 0;

        for (i = 0; i < max_synthdev; i++)
                if (synth_open_mask & (1 << i))
                        if (synth_devs[i])
                                synth_devs[i]->reset(i);

        if (seq_mode == SEQ_2)
        {
                for (chn = 0; chn < 16; chn++)
                        for (i = 0; i < max_synthdev; i++)
                                if (synth_open_mask & (1 << i))
                                        if (synth_devs[i])
                                        {
                                                synth_devs[i]->controller(i, chn, 123, 0);      /* All notes off */
                                                synth_devs[i]->controller(i, chn, 121, 0);      /* Reset all ctl */
                                                synth_devs[i]->bender(i, chn, 1 << 13); /* Bender off */
                                        }
        }
        else    /* seq_mode == SEQ_1 */
        {
                for (i = 0; i < max_mididev; i++)
                        if (midi_written[i])    /*
                                                 * Midi used. Some notes may still be playing
                                                 */
                        {
                                /*
                                 *      Sending just a ACTIVE SENSING message should be enough to stop all
                                 *      playing notes. Since there are devices not recognizing the
                                 *      active sensing, we have to send some all notes off messages also.
                                 */
                                midi_outc(i, 0xfe);

                                for (chn = 0; chn < 16; chn++)
                                {
                                        midi_outc(i, (unsigned char) (0xb0 + (chn & 0x0f)));            /* control change */
                                        midi_outc(i, 0x7b);     /* All notes off */
                                        midi_outc(i, 0);        /* Dummy parameter */
                                }

                                midi_devs[i]->close(i);

                                midi_written[i] = 0;
                                midi_opened[i] = 0;
                        }
        }

        seq_playing = 0;

        spin_lock_irqsave(&lock,flags);

        if (waitqueue_active(&seq_sleeper)) {
                /*      printk( "Sequencer Warning: Unexpected sleeping process - Waking up\n"); */
                wake_up(&seq_sleeper);
        }
        spin_unlock_irqrestore(&lock,flags);
}

static void seq_panic(void)
{
        /*
         * This routine is called by the application in case the user
         * wants to reset the system to the default state.
         */

        seq_reset();

        /*
         * Since some of the devices don't recognize the active sensing and
         * all notes off messages, we have to shut all notes manually.
         *
         *      TO BE IMPLEMENTED LATER
         */

        /*
         * Also return the controllers to their default states
         */
}

int sequencer_ioctl(int dev, struct file *file, unsigned int cmd, void __user *arg)
{
        int midi_dev, orig_dev, val, err;
        int mode = translate_mode(file);
        struct synth_info inf;
        struct seq_event_rec event_rec;
        unsigned long flags;
        int __user *p = arg;

        orig_dev = dev = dev >> 4;

        switch (cmd)
        {
                case SNDCTL_TMR_TIMEBASE:
                case SNDCTL_TMR_TEMPO:
                case SNDCTL_TMR_START:
                case SNDCTL_TMR_STOP:
                case SNDCTL_TMR_CONTINUE:
                case SNDCTL_TMR_METRONOME:
                case SNDCTL_TMR_SOURCE:
                        if (seq_mode != SEQ_2)
                                return -EINVAL;
                        return tmr->ioctl(tmr_no, cmd, arg);

                case SNDCTL_TMR_SELECT:
                        if (seq_mode != SEQ_2)
                                return -EINVAL;
                        if (get_user(pending_timer, p))
                                return -EFAULT;
                        if (pending_timer < 0 || pending_timer >= num_sound_timers || sound_timer_devs[pending_timer] == NULL)
                        {
                                pending_timer = -1;
                                return -EINVAL;
                        }
                        val = pending_timer;
                        break;

                case SNDCTL_SEQ_PANIC:
                        seq_panic();
                        return -EINVAL;

                case SNDCTL_SEQ_SYNC:
                        if (mode == OPEN_READ)
                                return 0;
                        while (qlen > 0 && !signal_pending(current))
                                seq_sync();
                        return qlen ? -EINTR : 0;

                case SNDCTL_SEQ_RESET:
                        seq_reset();
                        return 0;

                case SNDCTL_SEQ_TESTMIDI:
                        if (__get_user(midi_dev, p))
                                return -EFAULT;
                        if (midi_dev < 0 || midi_dev >= max_mididev || !midi_devs[midi_dev])
                                return -ENXIO;

                        if (!midi_opened[midi_dev] &&
                                (err = midi_devs[midi_dev]->open(midi_dev, mode, sequencer_midi_input,
                                                     sequencer_midi_output)) < 0)
                                return err;
                        midi_opened[midi_dev] = 1;
                        return 0;

                case SNDCTL_SEQ_GETINCOUNT:
                        if (mode == OPEN_WRITE)
                                return 0;
                        val = iqlen;
                        break;

                case SNDCTL_SEQ_GETOUTCOUNT:
                        if (mode == OPEN_READ)
                                return 0;
                        val = SEQ_MAX_QUEUE - qlen;
                        break;

                case SNDCTL_SEQ_GETTIME:
                        if (seq_mode == SEQ_2)
                                return tmr->ioctl(tmr_no, cmd, arg);
                        val = jiffies - seq_time;
                        break;

                case SNDCTL_SEQ_CTRLRATE:
                        /*
                         * If *arg == 0, just return the current rate
                         */
                        if (seq_mode == SEQ_2)
                                return tmr->ioctl(tmr_no, cmd, arg);

                        if (get_user(val, p))
                                return -EFAULT;
                        if (val != 0)
                                return -EINVAL;
                        val = HZ;
                        break;

                case SNDCTL_SEQ_RESETSAMPLES:
                case SNDCTL_SYNTH_REMOVESAMPLE:
                case SNDCTL_SYNTH_CONTROL:
                        if (get_user(dev, p))
                                return -EFAULT;
                        if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
                                return -ENXIO;
                        if (!(synth_open_mask & (1 << dev)) && !orig_dev)
                                return -EBUSY;
                        return synth_devs[dev]->ioctl(dev, cmd, arg);

                case SNDCTL_SEQ_NRSYNTHS:
                        val = max_synthdev;
                        break;

                case SNDCTL_SEQ_NRMIDIS:
                        val = max_mididev;
                        break;

                case SNDCTL_SYNTH_MEMAVL:
                        if (get_user(dev, p))
                                return -EFAULT;
                        if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
                                return -ENXIO;
                        if (!(synth_open_mask & (1 << dev)) && !orig_dev)
                                return -EBUSY;
                        val = synth_devs[dev]->ioctl(dev, cmd, arg);
                        break;

                case SNDCTL_FM_4OP_ENABLE:
                        if (get_user(dev, p))
                                return -EFAULT;
                        if (dev < 0 || dev >= num_synths || synth_devs[dev] == NULL)
                                return -ENXIO;
                        if (!(synth_open_mask & (1 << dev)))
                                return -ENXIO;
                        synth_devs[dev]->ioctl(dev, cmd, arg);
                        return 0;

                case SNDCTL_SYNTH_INFO:
                        if (get_user(dev, &((struct synth_info __user *)arg)->device))
                                return -EFAULT;
                        if (dev < 0 || dev >= max_synthdev)
                                return -ENXIO;
                        if (!(synth_open_mask & (1 << dev)) && !orig_dev)
                                return -EBUSY;
                        return synth_devs[dev]->ioctl(dev, cmd, arg);

                /* Like SYNTH_INFO but returns ID in the name field */
                case SNDCTL_SYNTH_ID:
                        if (get_user(dev, &((struct synth_info __user *)arg)->device))
                                return -EFAULT;
                        if (dev < 0 || dev >= max_synthdev)
                                return -ENXIO;
                        if (!(synth_open_mask & (1 << dev)) && !orig_dev)
                                return -EBUSY;
                        memcpy(&inf, synth_devs[dev]->info, sizeof(inf));
                        strlcpy(inf.name, synth_devs[dev]->id, sizeof(inf.name));
                        inf.device = dev;
                        return copy_to_user(arg, &inf, sizeof(inf))?-EFAULT:0;

                case SNDCTL_SEQ_OUTOFBAND:
                        if (copy_from_user(&event_rec, arg, sizeof(event_rec)))
                                return -EFAULT;
                        spin_lock_irqsave(&lock,flags);
                        play_event(event_rec.arr);
                        spin_unlock_irqrestore(&lock,flags);
                        return 0;

                case SNDCTL_MIDI_INFO:
                        if (get_user(dev, &((struct midi_info __user *)arg)->device))
                                return -EFAULT;
                        if (dev < 0 || dev >= max_mididev || !midi_devs[dev])
                                return -ENXIO;
                        midi_devs[dev]->info.device = dev;
                        return copy_to_user(arg, &midi_devs[dev]->info, sizeof(struct midi_info))?-EFAULT:0;

                case SNDCTL_SEQ_THRESHOLD:
                        if (get_user(val, p))
                                return -EFAULT;
                        if (val < 1)
                                val = 1;
                        if (val >= SEQ_MAX_QUEUE)
                                val = SEQ_MAX_QUEUE - 1;
                        output_threshold = val;
                        return 0;

                case SNDCTL_MIDI_PRETIME:
                        if (get_user(val, p))
                                return -EFAULT;
                        if (val < 0)
                                val = 0;
                        val = (HZ * val) / 10;
                        pre_event_timeout = val;
                        break;

                default:
                        if (mode == OPEN_READ)
                                return -EIO;
                        if (!synth_devs[0])
                                return -ENXIO;
                        if (!(synth_open_mask & (1 << 0)))
                                return -ENXIO;
                        if (!synth_devs[0]->ioctl)
                                return -EINVAL;
                        return synth_devs[0]->ioctl(0, cmd, arg);
        }
        return put_user(val, p);
}

/* No kernel lock - we're using the global irq lock here */
unsigned int sequencer_poll(int dev, struct file *file, poll_table * wait)
{
        unsigned long flags;
        unsigned int mask = 0;

        dev = dev >> 4;

        spin_lock_irqsave(&lock,flags);
        /* input */
        poll_wait(file, &midi_sleeper, wait);
        if (iqlen)
                mask |= POLLIN | POLLRDNORM;

        /* output */
        poll_wait(file, &seq_sleeper, wait);
        if ((SEQ_MAX_QUEUE - qlen) >= output_threshold)
                mask |= POLLOUT | POLLWRNORM;
        spin_unlock_irqrestore(&lock,flags);
        return mask;
}


void sequencer_timer(unsigned long dummy)
{
        seq_startplay();
}
EXPORT_SYMBOL(sequencer_timer);

int note_to_freq(int note_num)
{

        /*
         * This routine converts a midi note to a frequency (multiplied by 1000)
         */

        int note, octave, note_freq;
        static int notes[] =
        {
                261632, 277189, 293671, 311132, 329632, 349232,
                369998, 391998, 415306, 440000, 466162, 493880
        };

#define BASE_OCTAVE     5

        octave = note_num / 12;
        note = note_num % 12;

        note_freq = notes[note];

        if (octave < BASE_OCTAVE)
                note_freq >>= (BASE_OCTAVE - octave);
        else if (octave > BASE_OCTAVE)
                note_freq <<= (octave - BASE_OCTAVE);

        /*
         * note_freq >>= 1;
         */

        return note_freq;
}
EXPORT_SYMBOL(note_to_freq);

unsigned long compute_finetune(unsigned long base_freq, int bend, int range,
                 int vibrato_cents)
{
        unsigned long amount;
        int negative, semitones, cents, multiplier = 1;

        if (!bend)
                return base_freq;
        if (!range)
                return base_freq;

        if (!base_freq)
                return base_freq;

        if (range >= 8192)
                range = 8192;

        bend = bend * range / 8192;     /* Convert to cents */
        bend += vibrato_cents;

        if (!bend)
                return base_freq;

        negative = bend < 0 ? 1 : 0;

        if (bend < 0)
                bend *= -1;
        if (bend > range)
                bend = range;

        /*
           if (bend > 2399)
           bend = 2399;
         */
        while (bend > 2399)
        {
                multiplier *= 4;
                bend -= 2400;
        }

        semitones = bend / 100;
        if (semitones > 99)
                semitones = 99;
        cents = bend % 100;

        amount = (int) (semitone_tuning[semitones] * multiplier * cent_tuning[cents]) / 10000;

        if (negative)
                return (base_freq * 10000) / amount;    /* Bend down */
        else
                return (base_freq * amount) / 10000;    /* Bend up */
}
EXPORT_SYMBOL(compute_finetune);

void sequencer_init(void)
{
        if (sequencer_ok)
                return;
        queue = (unsigned char *)vmalloc(SEQ_MAX_QUEUE * EV_SZ);
        if (queue == NULL)
        {
                printk(KERN_ERR "sequencer: Can't allocate memory for sequencer output queue\n");
                return;
        }
        iqueue = (unsigned char *)vmalloc(SEQ_MAX_QUEUE * IEV_SZ);
        if (iqueue == NULL)
        {
                printk(KERN_ERR "sequencer: Can't allocate memory for sequencer input queue\n");
                vfree(queue);
                return;
        }
        sequencer_ok = 1;
}
EXPORT_SYMBOL(sequencer_init);

void sequencer_unload(void)
{
        vfree(queue);
        vfree(iqueue);
        queue = iqueue = NULL;
}

/* [<][>][^][v][top][bottom][index][help] */

[funini.com] -> [kei@sodan] -> Kernel Reading