pas2_midi.c

Go to the documentation of this file.

/*
 * sound/oss/pas2_midi.c
 *
 * The low level driver for the PAS Midi Interface.
 */
/*
 * 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.
 *
 * Bartlomiej Zolnierkiewicz    : Added __init to pas_init_mixer()
 */

#include <linux/init.h>
#include <linux/spinlock.h>
#include "sound_config.h"

#include "pas2.h"

extern spinlock_t pas_lock;

static int      midi_busy, input_opened;
static int      my_dev;

int pas2_mididev=-1;

static unsigned char tmp_queue[256];
static volatile int qlen;
static volatile unsigned char qhead, qtail;

static void     (*midi_input_intr) (int dev, unsigned char data);

static int pas_midi_open(int dev, int mode,
          void            (*input) (int dev, unsigned char data),
          void            (*output) (int dev)
)
{
    int             err;
    unsigned long   flags;
    unsigned char   ctrl;


    if (midi_busy)
        return -EBUSY;

    /*
     * Reset input and output FIFO pointers
     */
    pas_write(0x20 | 0x40,
          0x178b);

    spin_lock_irqsave(&pas_lock, flags);

    if ((err = pas_set_intr(0x10)) < 0)
    {
        spin_unlock_irqrestore(&pas_lock, flags);
        return err;
    }
    /*
     * Enable input available and output FIFO empty interrupts
     */

    ctrl = 0;
    input_opened = 0;
    midi_input_intr = input;

    if (mode == OPEN_READ || mode == OPEN_READWRITE)
    {
        ctrl |= 0x04;   /* Enable input */
        input_opened = 1;
    }
    if (mode == OPEN_WRITE || mode == OPEN_READWRITE)
    {
        ctrl |= 0x08 | 0x10;    /* Enable output */
    }
    pas_write(ctrl, 0x178b);

    /*
     * Acknowledge any pending interrupts
     */

    pas_write(0xff, 0x1B88);

    spin_unlock_irqrestore(&pas_lock, flags);

    midi_busy = 1;
    qlen = qhead = qtail = 0;
    return 0;
}

static void pas_midi_close(int dev)
{

    /*
     * Reset FIFO pointers, disable intrs
     */
    pas_write(0x20 | 0x40, 0x178b);

    pas_remove_intr(0x10);
    midi_busy = 0;
}

static int dump_to_midi(unsigned char midi_byte)
{
    int fifo_space, x;

    fifo_space = ((x = pas_read(0x1B89)) >> 4) & 0x0f;

    /*
     * The MIDI FIFO space register and it's documentation is nonunderstandable.
     * There seem to be no way to differentiate between buffer full and buffer
     * empty situations. For this reason we don't never write the buffer
     * completely full. In this way we can assume that 0 (or is it 15)
     * means that the buffer is empty.
     */

    if (fifo_space < 2 && fifo_space != 0)  /* Full (almost) */
        return 0;   /* Ask upper layers to retry after some time */

    pas_write(midi_byte, 0x178A);

    return 1;
}

static int pas_midi_out(int dev, unsigned char midi_byte)
{

    unsigned long flags;

    /*
     * Drain the local queue first
     */

    spin_lock_irqsave(&pas_lock, flags);

    while (qlen && dump_to_midi(tmp_queue[qhead]))
    {
        qlen--;
        qhead++;
    }

    spin_unlock_irqrestore(&pas_lock, flags);

    /*
     *  Output the byte if the local queue is empty.
     */

    if (!qlen)
        if (dump_to_midi(midi_byte))
            return 1;

    /*
     *  Put to the local queue
     */

    if (qlen >= 256)
        return 0;   /* Local queue full */

    spin_lock_irqsave(&pas_lock, flags);

    tmp_queue[qtail] = midi_byte;
    qlen++;
    qtail++;

    spin_unlock_irqrestore(&pas_lock, flags);

    return 1;
}

static int pas_midi_start_read(int dev)
{
    return 0;
}

static int pas_midi_end_read(int dev)
{
    return 0;
}

static void pas_midi_kick(int dev)
{
}

static int pas_buffer_status(int dev)
{
    return qlen;
}

#define MIDI_SYNTH_NAME "Pro Audio Spectrum Midi"
#define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
#include "midi_synth.h"

static struct midi_operations pas_midi_operations =
{
    .owner      = THIS_MODULE,
    .info       = {"Pro Audio Spectrum", 0, 0, SNDCARD_PAS},
    .converter  = &std_midi_synth,
    .in_info    = {0},
    .open       = pas_midi_open,
    .close      = pas_midi_close,
    .outputc    = pas_midi_out,
    .start_read = pas_midi_start_read,
    .end_read   = pas_midi_end_read,
    .kick       = pas_midi_kick,
    .buffer_status  = pas_buffer_status,
};

void __init pas_midi_init(void)
{
    int dev = sound_alloc_mididev();

    if (dev == -1)
    {
        printk(KERN_WARNING "pas_midi_init: Too many midi devices detected\n");
        return;
    }
    std_midi_synth.midi_dev = my_dev = dev;
    midi_devs[dev] = &pas_midi_operations;
    pas2_mididev = dev;
    sequencer_init();
}

void pas_midi_interrupt(void)
{
    unsigned char   stat;
    int             i, incount;

    stat = pas_read(0x1B88);

    if (stat & 0x04)    /* Input data available */
    {
        incount = pas_read(0x1B89) & 0x0f;  /* Input FIFO size */
        if (!incount)
            incount = 16;

        for (i = 0; i < incount; i++)
            if (input_opened)
            {
                midi_input_intr(my_dev, pas_read(0x178A));
            } else
                pas_read(0x178A);   /* Flush */
    }
    if (stat & (0x08 | 0x10))
    {
        spin_lock(&pas_lock);/* called in irq context */

        while (qlen && dump_to_midi(tmp_queue[qhead]))
        {
            qlen--;
            qhead++;
        }

        spin_unlock(&pas_lock);
    }
    if (stat & 0x40)
    {
        printk(KERN_WARNING "MIDI output overrun %x,%x\n", pas_read(0x1B89), stat);
    }
    pas_write(stat, 0x1B88);    /* Acknowledge interrupts */
}