Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

/*

 * 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 */

}