URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [isa/] [wavefront/] [wavefront_midi.c] - Blame information for rev 3

Details | Compare with Previous | View Log


/*
 * Copyright (C) by Paul Barton-Davis 1998-1999
 *
 * This file is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 * Version 2 (June 1991). See the "COPYING" file distributed with this
 * software for more info.
 */
 
/* The low level driver for the WaveFront ICS2115 MIDI interface(s)
 *
 * Note that there is also an MPU-401 emulation (actually, a UART-401
 * emulation) on the CS4232 on the Tropez and Tropez Plus. This code
 * has nothing to do with that interface at all.
 *
 * The interface is essentially just a UART-401, but is has the
 * interesting property of supporting what Turtle Beach called
 * "Virtual MIDI" mode. In this mode, there are effectively *two*
 * MIDI buses accessible via the interface, one that is routed
 * solely to/from the external WaveFront synthesizer and the other
 * corresponding to the pin/socket connector used to link external
 * MIDI devices to the board.
 *
 * This driver fully supports this mode, allowing two distinct MIDI
 * busses to be used completely independently, giving 32 channels of
 * MIDI routing, 16 to the WaveFront synth and 16 to the external MIDI
 * bus. The devices are named /dev/snd/midiCnD0 and /dev/snd/midiCnD1,
 * where `n' is the card number. Note that the device numbers may be
 * something other than 0 and 1 if the CS4232 UART/MPU-401 interface
 * is enabled.
 *
 * Switching between the two is accomplished externally by the driver
 * using the two otherwise unused MIDI bytes. See the code for more details.
 *
 * NOTE: VIRTUAL MIDI MODE IS ON BY DEFAULT (see lowlevel/isa/wavefront.c)
 *
 * The main reason to turn off Virtual MIDI mode is when you want to
 * tightly couple the WaveFront synth with an external MIDI
 * device. You won't be able to distinguish the source of any MIDI
 * data except via SysEx ID, but thats probably OK, since for the most
 * part, the WaveFront won't be sending any MIDI data at all.
 *
 * The main reason to turn on Virtual MIDI Mode is to provide two
 * completely independent 16-channel MIDI buses, one to the
 * WaveFront and one to any external MIDI devices. Given the 32
 * voice nature of the WaveFront, its pretty easy to find a use
 * for all 16 channels driving just that synth.
 *
 */
 
#include <sound/driver.h>
#include <asm/io.h>
#include <linux/init.h>
#include <linux/time.h>
#include <linux/wait.h>
#include <sound/core.h>
#include <sound/snd_wavefront.h>
 
static inline int
wf_mpu_status (snd_wavefront_midi_t *midi)
 
{
        return inb (midi->mpu_status_port);
}
 
static inline int
input_avail (snd_wavefront_midi_t *midi)
 
{
        return !(wf_mpu_status(midi) & INPUT_AVAIL);
}
 
static inline int
output_ready (snd_wavefront_midi_t *midi)
 
{
        return !(wf_mpu_status(midi) & OUTPUT_READY);
}
 
static inline int
read_data (snd_wavefront_midi_t *midi)
 
{
        return inb (midi->mpu_data_port);
}
 
static inline void
write_data (snd_wavefront_midi_t *midi, unsigned char byte)
 
{
        outb (byte, midi->mpu_data_port);
}
 
static snd_wavefront_midi_t *
get_wavefront_midi (struct snd_rawmidi_substream *substream)
 
{
        struct snd_card *card;
        snd_wavefront_card_t *acard;
 
        if (substream == NULL || substream->rmidi == NULL)
                return NULL;
 
        card = substream->rmidi->card;
 
        if (card == NULL)
                return NULL;
 
        if (card->private_data == NULL)
                return NULL;
 
        acard = card->private_data;
 
        return &acard->wavefront.midi;
}
 
static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card)
{
        snd_wavefront_midi_t *midi = &card->wavefront.midi;
        snd_wavefront_mpu_id  mpu;
        unsigned long flags;
        unsigned char midi_byte;
        int max = 256, mask = 1;
        int timeout;
 
        /* Its not OK to try to change the status of "virtuality" of
           the MIDI interface while we're outputting stuff.  See
           snd_wavefront_midi_{enable,disable}_virtual () for the
           other half of this.
 
           The first loop attempts to flush any data from the
           current output device, and then the second
           emits the switch byte (if necessary), and starts
           outputting data for the output device currently in use.
        */
 
        if (midi->substream_output[midi->output_mpu] == NULL) {
                goto __second;
        }
 
        while (max > 0) {
 
                /* XXX fix me - no hard timing loops allowed! */
 
                for (timeout = 30000; timeout > 0; timeout--) {
                        if (output_ready (midi))
                                break;
                }
 
                spin_lock_irqsave (&midi->virtual, flags);
                if ((midi->mode[midi->output_mpu] & MPU401_MODE_OUTPUT) == 0) {
                        spin_unlock_irqrestore (&midi->virtual, flags);
                        goto __second;
                }
                if (output_ready (midi)) {
                        if (snd_rawmidi_transmit(midi->substream_output[midi->output_mpu], &midi_byte, 1) == 1) {
                                if (!midi->isvirtual ||
                                        (midi_byte != WF_INTERNAL_SWITCH &&
                                         midi_byte != WF_EXTERNAL_SWITCH))
                                        write_data(midi, midi_byte);
                                max--;
                        } else {
                                if (midi->istimer) {
                                        if (--midi->istimer <= 0)
                                                del_timer(&midi->timer);
                                }
                                midi->mode[midi->output_mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
                                spin_unlock_irqrestore (&midi->virtual, flags);
                                goto __second;
                        }
                } else {
                        spin_unlock_irqrestore (&midi->virtual, flags);
                        return;
                }
                spin_unlock_irqrestore (&midi->virtual, flags);
        }
 
      __second:
 
        if (midi->substream_output[!midi->output_mpu] == NULL) {
                return;
        }
 
        while (max > 0) {
 
                /* XXX fix me - no hard timing loops allowed! */
 
                for (timeout = 30000; timeout > 0; timeout--) {
                        if (output_ready (midi))
                                break;
                }
 
                spin_lock_irqsave (&midi->virtual, flags);
                if (!midi->isvirtual)
                        mask = 0;
                mpu = midi->output_mpu ^ mask;
                mask = 0;        /* don't invert the value from now */
                if ((midi->mode[mpu] & MPU401_MODE_OUTPUT) == 0) {
                        spin_unlock_irqrestore (&midi->virtual, flags);
                        return;
                }
                if (snd_rawmidi_transmit_empty(midi->substream_output[mpu]))
                        goto __timer;
                if (output_ready (midi)) {
                        if (mpu != midi->output_mpu) {
                                write_data(midi, mpu == internal_mpu ?
                                                        WF_INTERNAL_SWITCH :
                                                        WF_EXTERNAL_SWITCH);
                                midi->output_mpu = mpu;
                        } else if (snd_rawmidi_transmit(midi->substream_output[mpu], &midi_byte, 1) == 1) {
                                if (!midi->isvirtual ||
                                        (midi_byte != WF_INTERNAL_SWITCH &&
                                         midi_byte != WF_EXTERNAL_SWITCH))
                                        write_data(midi, midi_byte);
                                max--;
                        } else {
                              __timer:
                                if (midi->istimer) {
                                        if (--midi->istimer <= 0)
                                                del_timer(&midi->timer);
                                }
                                midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
                                spin_unlock_irqrestore (&midi->virtual, flags);
                                return;
                        }
                } else {
                        spin_unlock_irqrestore (&midi->virtual, flags);
                        return;
                }
                spin_unlock_irqrestore (&midi->virtual, flags);
        }
}
 
static int snd_wavefront_midi_input_open(struct snd_rawmidi_substream *substream)
{
        unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
        snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO);
        snd_assert(substream->rmidi->private_data != NULL, return -EIO);
 
        mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
 
        if ((midi = get_wavefront_midi (substream)) == NULL)
                return -EIO;
 
        spin_lock_irqsave (&midi->open, flags);
        midi->mode[mpu] |= MPU401_MODE_INPUT;
        midi->substream_input[mpu] = substream;
        spin_unlock_irqrestore (&midi->open, flags);
 
        return 0;
}
 
static int snd_wavefront_midi_output_open(struct snd_rawmidi_substream *substream)
{
        unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
        snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO);
        snd_assert(substream->rmidi->private_data != NULL, return -EIO);
 
        mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
 
        if ((midi = get_wavefront_midi (substream)) == NULL)
                return -EIO;
 
        spin_lock_irqsave (&midi->open, flags);
        midi->mode[mpu] |= MPU401_MODE_OUTPUT;
        midi->substream_output[mpu] = substream;
        spin_unlock_irqrestore (&midi->open, flags);
 
        return 0;
}
 
static int snd_wavefront_midi_input_close(struct snd_rawmidi_substream *substream)
{
        unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
        snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO);
        snd_assert(substream->rmidi->private_data != NULL, return -EIO);
 
        mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
 
        if ((midi = get_wavefront_midi (substream)) == NULL)
                return -EIO;
 
        spin_lock_irqsave (&midi->open, flags);
        midi->mode[mpu] &= ~MPU401_MODE_INPUT;
        spin_unlock_irqrestore (&midi->open, flags);
 
        return 0;
}
 
static int snd_wavefront_midi_output_close(struct snd_rawmidi_substream *substream)
{
        unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
        snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO);
        snd_assert(substream->rmidi->private_data != NULL, return -EIO);
 
        mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
 
        if ((midi = get_wavefront_midi (substream)) == NULL)
                return -EIO;
 
        spin_lock_irqsave (&midi->open, flags);
        midi->mode[mpu] &= ~MPU401_MODE_OUTPUT;
        spin_unlock_irqrestore (&midi->open, flags);
        return 0;
}
 
static void snd_wavefront_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
{
        unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
        if (substream == NULL || substream->rmidi == NULL)
                return;
 
        if (substream->rmidi->private_data == NULL)
                return;
 
        mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
 
        if ((midi = get_wavefront_midi (substream)) == NULL) {
                return;
        }
 
        spin_lock_irqsave (&midi->virtual, flags);
        if (up) {
                midi->mode[mpu] |= MPU401_MODE_INPUT_TRIGGER;
        } else {
                midi->mode[mpu] &= ~MPU401_MODE_INPUT_TRIGGER;
        }
        spin_unlock_irqrestore (&midi->virtual, flags);
}
 
static void snd_wavefront_midi_output_timer(unsigned long data)
{
        snd_wavefront_card_t *card = (snd_wavefront_card_t *)data;
        snd_wavefront_midi_t *midi = &card->wavefront.midi;
        unsigned long flags;
 
        spin_lock_irqsave (&midi->virtual, flags);
        midi->timer.expires = 1 + jiffies;
        add_timer(&midi->timer);
        spin_unlock_irqrestore (&midi->virtual, flags);
        snd_wavefront_midi_output_write(card);
}
 
static void snd_wavefront_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
{
        unsigned long flags;
        snd_wavefront_midi_t *midi;
        snd_wavefront_mpu_id mpu;
 
        if (substream == NULL || substream->rmidi == NULL)
                return;
 
        if (substream->rmidi->private_data == NULL)
                return;
 
        mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
 
        if ((midi = get_wavefront_midi (substream)) == NULL) {
                return;
        }
 
        spin_lock_irqsave (&midi->virtual, flags);
        if (up) {
                if ((midi->mode[mpu] & MPU401_MODE_OUTPUT_TRIGGER) == 0) {
                        if (!midi->istimer) {
                                init_timer(&midi->timer);
                                midi->timer.function = snd_wavefront_midi_output_timer;
                                midi->timer.data = (unsigned long) substream->rmidi->card->private_data;
                                midi->timer.expires = 1 + jiffies;
                                add_timer(&midi->timer);
                        }
                        midi->istimer++;
                        midi->mode[mpu] |= MPU401_MODE_OUTPUT_TRIGGER;
                }
        } else {
                midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
        }
        spin_unlock_irqrestore (&midi->virtual, flags);
 
        if (up)
                snd_wavefront_midi_output_write((snd_wavefront_card_t *)substream->rmidi->card->private_data);
}
 
void
snd_wavefront_midi_interrupt (snd_wavefront_card_t *card)
 
{
        unsigned long flags;
        snd_wavefront_midi_t *midi;
        static struct snd_rawmidi_substream *substream = NULL;
        static int mpu = external_mpu;
        int max = 128;
        unsigned char byte;
 
        midi = &card->wavefront.midi;
 
        if (!input_avail (midi)) { /* not for us */
                snd_wavefront_midi_output_write(card);
                return;
        }
 
        spin_lock_irqsave (&midi->virtual, flags);
        while (--max) {
 
                if (input_avail (midi)) {
                        byte = read_data (midi);
 
                        if (midi->isvirtual) {
                                if (byte == WF_EXTERNAL_SWITCH) {
                                        substream = midi->substream_input[external_mpu];
                                        mpu = external_mpu;
                                } else if (byte == WF_INTERNAL_SWITCH) {
                                        substream = midi->substream_output[internal_mpu];
                                        mpu = internal_mpu;
                                } /* else just leave it as it is */
                        } else {
                                substream = midi->substream_input[internal_mpu];
                                mpu = internal_mpu;
                        }
 
                        if (substream == NULL) {
                                continue;
                        }
 
                        if (midi->mode[mpu] & MPU401_MODE_INPUT_TRIGGER) {
                                snd_rawmidi_receive(substream, &byte, 1);
                        }
                } else {
                        break;
                }
        }
        spin_unlock_irqrestore (&midi->virtual, flags);
 
        snd_wavefront_midi_output_write(card);
}
 
void
snd_wavefront_midi_enable_virtual (snd_wavefront_card_t *card)
 
{
        unsigned long flags;
 
        spin_lock_irqsave (&card->wavefront.midi.virtual, flags);
        card->wavefront.midi.isvirtual = 1;
        card->wavefront.midi.output_mpu = internal_mpu;
        card->wavefront.midi.input_mpu = internal_mpu;
        spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags);
}
 
void
snd_wavefront_midi_disable_virtual (snd_wavefront_card_t *card)
 
{
        unsigned long flags;
 
        spin_lock_irqsave (&card->wavefront.midi.virtual, flags);
        // snd_wavefront_midi_input_close (card->ics2115_external_rmidi);
        // snd_wavefront_midi_output_close (card->ics2115_external_rmidi);
        card->wavefront.midi.isvirtual = 0;
        spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags);
}
 
int __devinit
snd_wavefront_midi_start (snd_wavefront_card_t *card)
 
{
        int ok, i;
        unsigned char rbuf[4], wbuf[4];
        snd_wavefront_t *dev;
        snd_wavefront_midi_t *midi;
 
        dev = &card->wavefront;
        midi = &dev->midi;
 
        /* The ICS2115 MPU-401 interface doesn't do anything
           until its set into UART mode.
        */
 
        /* XXX fix me - no hard timing loops allowed! */
 
        for (i = 0; i < 30000 && !output_ready (midi); i++);
 
        if (!output_ready (midi)) {
                snd_printk ("MIDI interface not ready for command\n");
                return -1;
        }
 
        /* Any interrupts received from now on
           are owned by the MIDI side of things.
        */
 
        dev->interrupts_are_midi = 1;
 
        outb (UART_MODE_ON, midi->mpu_command_port);
 
        for (ok = 0, i = 50000; i > 0 && !ok; i--) {
                if (input_avail (midi)) {
                        if (read_data (midi) == MPU_ACK) {
                                ok = 1;
                                break;
                        }
                }
        }
 
        if (!ok) {
                snd_printk ("cannot set UART mode for MIDI interface");
                dev->interrupts_are_midi = 0;
                return -1;
        }
 
        /* Route external MIDI to WaveFront synth (by default) */
 
        if (snd_wavefront_cmd (dev, WFC_MISYNTH_ON, rbuf, wbuf)) {
                snd_printk ("can't enable MIDI-IN-2-synth routing.\n");
                /* XXX error ? */
        }
 
        /* Turn on Virtual MIDI, but first *always* turn it off,
           since otherwise consectutive reloads of the driver will
           never cause the hardware to generate the initial "internal" or
           "external" source bytes in the MIDI data stream. This
           is pretty important, since the internal hardware generally will
           be used to generate none or very little MIDI output, and
           thus the only source of MIDI data is actually external. Without
           the switch bytes, the driver will think it all comes from
           the internal interface. Duh.
        */
 
        if (snd_wavefront_cmd (dev, WFC_VMIDI_OFF, rbuf, wbuf)) {
                snd_printk ("virtual MIDI mode not disabled\n");
                return 0; /* We're OK, but missing the external MIDI dev */
        }
 
        snd_wavefront_midi_enable_virtual (card);
 
        if (snd_wavefront_cmd (dev, WFC_VMIDI_ON, rbuf, wbuf)) {
                snd_printk ("cannot enable virtual MIDI mode.\n");
                snd_wavefront_midi_disable_virtual (card);
        }
        return 0;
}
 
struct snd_rawmidi_ops snd_wavefront_midi_output =
{
        .open =         snd_wavefront_midi_output_open,
        .close =        snd_wavefront_midi_output_close,
        .trigger =      snd_wavefront_midi_output_trigger,
};
 
struct snd_rawmidi_ops snd_wavefront_midi_input =
{
        .open =         snd_wavefront_midi_input_open,
        .close =        snd_wavefront_midi_input_close,
        .trigger =      snd_wavefront_midi_input_trigger,
};
 

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [isa/] [wavefront/] [wavefront_midi.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* Copyright (C) by Paul Barton-Davis 1998-1999`
3			`*`
4			`* This file is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)`
5			`* Version 2 (June 1991). See the "COPYING" file distributed with this`
6			`* software for more info.`
7			`*/`
8
9			`/* The low level driver for the WaveFront ICS2115 MIDI interface(s)`
10			`*`
11			`* Note that there is also an MPU-401 emulation (actually, a UART-401`
12			`* emulation) on the CS4232 on the Tropez and Tropez Plus. This code`
13			`* has nothing to do with that interface at all.`
14			`*`
15			`* The interface is essentially just a UART-401, but is has the`
16			`* interesting property of supporting what Turtle Beach called`
17			`* "Virtual MIDI" mode. In this mode, there are effectively two`
18			`* MIDI buses accessible via the interface, one that is routed`
19			`* solely to/from the external WaveFront synthesizer and the other`
20			`* corresponding to the pin/socket connector used to link external`
21			`* MIDI devices to the board.`
22			`*`
23			`* This driver fully supports this mode, allowing two distinct MIDI`
24			`* busses to be used completely independently, giving 32 channels of`
25			`* MIDI routing, 16 to the WaveFront synth and 16 to the external MIDI`
26			`* bus. The devices are named /dev/snd/midiCnD0 and /dev/snd/midiCnD1,`
27			* where `n' is the card number. Note that the device numbers may be
28			`* something other than 0 and 1 if the CS4232 UART/MPU-401 interface`
29			`* is enabled.`
30			`*`
31			`* Switching between the two is accomplished externally by the driver`
32			`* using the two otherwise unused MIDI bytes. See the code for more details.`
33			`*`
34			`* NOTE: VIRTUAL MIDI MODE IS ON BY DEFAULT (see lowlevel/isa/wavefront.c)`
35			`*`
36			`* The main reason to turn off Virtual MIDI mode is when you want to`
37			`* tightly couple the WaveFront synth with an external MIDI`
38			`* device. You won't be able to distinguish the source of any MIDI`
39			`* data except via SysEx ID, but thats probably OK, since for the most`
40			`* part, the WaveFront won't be sending any MIDI data at all.`
41			`*`
42			`* The main reason to turn on Virtual MIDI Mode is to provide two`
43			`* completely independent 16-channel MIDI buses, one to the`
44			`* WaveFront and one to any external MIDI devices. Given the 32`
45			`* voice nature of the WaveFront, its pretty easy to find a use`
46			`* for all 16 channels driving just that synth.`
47			`*`
48			`*/`
49
50			`#include <sound/driver.h>`
51			`#include <asm/io.h>`
52			`#include <linux/init.h>`
53			`#include <linux/time.h>`
54			`#include <linux/wait.h>`
55			`#include <sound/core.h>`
56			`#include <sound/snd_wavefront.h>`
57
58			`static inline int`
59			`wf_mpu_status (snd_wavefront_midi_t *midi)`
60
61			`{`
62			`return inb (midi->mpu_status_port);`
63			`}`
64
65			`static inline int`
66			`input_avail (snd_wavefront_midi_t *midi)`
67
68			`{`
69			`return !(wf_mpu_status(midi) & INPUT_AVAIL);`
70			`}`
71
72			`static inline int`
73			`output_ready (snd_wavefront_midi_t *midi)`
74
75			`{`
76			`return !(wf_mpu_status(midi) & OUTPUT_READY);`
77			`}`
78
79			`static inline int`
80			`read_data (snd_wavefront_midi_t *midi)`
81
82			`{`
83			`return inb (midi->mpu_data_port);`
84			`}`
85
86			`static inline void`
87			`write_data (snd_wavefront_midi_t *midi, unsigned char byte)`
88
89			`{`
90			`outb (byte, midi->mpu_data_port);`
91			`}`
92
93			`static snd_wavefront_midi_t *`
94			`get_wavefront_midi (struct snd_rawmidi_substream *substream)`
95
96			`{`
97			`struct snd_card *card;`
98			`snd_wavefront_card_t *acard;`
99
100			`if (substream == NULL \|\| substream->rmidi == NULL)`
101			`return NULL;`
102
103			`card = substream->rmidi->card;`
104
105			`if (card == NULL)`
106			`return NULL;`
107
108			`if (card->private_data == NULL)`
109			`return NULL;`
110
111			`acard = card->private_data;`
112
113			`return &acard->wavefront.midi;`
114			`}`
115
116			`static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card)`
117			`{`
118			`snd_wavefront_midi_t *midi = &card->wavefront.midi;`
119			`snd_wavefront_mpu_id mpu;`
120			`unsigned long flags;`
121			`unsigned char midi_byte;`
122			`int max = 256, mask = 1;`
123			`int timeout;`
124
125			`/* Its not OK to try to change the status of "virtuality" of`
126			`the MIDI interface while we're outputting stuff. See`
127			`snd_wavefront_midi_{enable,disable}_virtual () for the`
128			`other half of this.`
129
130			`The first loop attempts to flush any data from the`
131			`current output device, and then the second`
132			`emits the switch byte (if necessary), and starts`
133			`outputting data for the output device currently in use.`
134			`*/`
135
136			`if (midi->substream_output[midi->output_mpu] == NULL) {`
137			`goto __second;`
138			`}`
139
140			`while (max > 0) {`
141
142			`/* XXX fix me - no hard timing loops allowed! */`
143
144			`for (timeout = 30000; timeout > 0; timeout--) {`
145			`if (output_ready (midi))`
146			`break;`
147			`}`
148
149			`spin_lock_irqsave (&midi->virtual, flags);`
150			`if ((midi->mode[midi->output_mpu] & MPU401_MODE_OUTPUT) == 0) {`
151			`spin_unlock_irqrestore (&midi->virtual, flags);`
152			`goto __second;`
153			`}`
154			`if (output_ready (midi)) {`
155			`if (snd_rawmidi_transmit(midi->substream_output[midi->output_mpu], &midi_byte, 1) == 1) {`
156			`if (!midi->isvirtual \|\|`
157			`(midi_byte != WF_INTERNAL_SWITCH &&`
158			`midi_byte != WF_EXTERNAL_SWITCH))`
159			`write_data(midi, midi_byte);`
160			`max--;`
161			`} else {`
162			`if (midi->istimer) {`
163			`if (--midi->istimer <= 0)`
164			`del_timer(&midi->timer);`
165			`}`
166			`midi->mode[midi->output_mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;`
167			`spin_unlock_irqrestore (&midi->virtual, flags);`
168			`goto __second;`
169			`}`
170			`} else {`
171			`spin_unlock_irqrestore (&midi->virtual, flags);`
172			`return;`
173			`}`
174			`spin_unlock_irqrestore (&midi->virtual, flags);`
175			`}`
176
177			`__second:`
178
179			`if (midi->substream_output[!midi->output_mpu] == NULL) {`
180			`return;`
181			`}`
182
183			`while (max > 0) {`
184
185			`/* XXX fix me - no hard timing loops allowed! */`
186
187			`for (timeout = 30000; timeout > 0; timeout--) {`
188			`if (output_ready (midi))`
189			`break;`
190			`}`
191
192			`spin_lock_irqsave (&midi->virtual, flags);`
193			`if (!midi->isvirtual)`
194			`mask = 0;`
195			`mpu = midi->output_mpu ^ mask;`
196			`mask = 0; /* don't invert the value from now */`
197			`if ((midi->mode[mpu] & MPU401_MODE_OUTPUT) == 0) {`
198			`spin_unlock_irqrestore (&midi->virtual, flags);`
199			`return;`
200			`}`
201			`if (snd_rawmidi_transmit_empty(midi->substream_output[mpu]))`
202			`goto __timer;`
203			`if (output_ready (midi)) {`
204			`if (mpu != midi->output_mpu) {`
205			`write_data(midi, mpu == internal_mpu ?`
206			`WF_INTERNAL_SWITCH :`
207			`WF_EXTERNAL_SWITCH);`
208			`midi->output_mpu = mpu;`
209			`} else if (snd_rawmidi_transmit(midi->substream_output[mpu], &midi_byte, 1) == 1) {`
210			`if (!midi->isvirtual \|\|`
211			`(midi_byte != WF_INTERNAL_SWITCH &&`
212			`midi_byte != WF_EXTERNAL_SWITCH))`
213			`write_data(midi, midi_byte);`
214			`max--;`
215			`} else {`
216			`__timer:`
217			`if (midi->istimer) {`
218			`if (--midi->istimer <= 0)`
219			`del_timer(&midi->timer);`
220			`}`
221			`midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;`
222			`spin_unlock_irqrestore (&midi->virtual, flags);`
223			`return;`
224			`}`
225			`} else {`
226			`spin_unlock_irqrestore (&midi->virtual, flags);`
227			`return;`
228			`}`
229			`spin_unlock_irqrestore (&midi->virtual, flags);`
230			`}`
231			`}`
232
233			`static int snd_wavefront_midi_input_open(struct snd_rawmidi_substream *substream)`
234			`{`
235			`unsigned long flags;`
236			`snd_wavefront_midi_t *midi;`
237			`snd_wavefront_mpu_id mpu;`
238
239			`snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO);`
240			`snd_assert(substream->rmidi->private_data != NULL, return -EIO);`
241
242			`mpu = ((snd_wavefront_mpu_id ) substream->rmidi->private_data);`
243
244			`if ((midi = get_wavefront_midi (substream)) == NULL)`
245			`return -EIO;`
246
247			`spin_lock_irqsave (&midi->open, flags);`
248			`midi->mode[mpu] \|= MPU401_MODE_INPUT;`
249			`midi->substream_input[mpu] = substream;`
250			`spin_unlock_irqrestore (&midi->open, flags);`
251
252			`return 0;`
253			`}`
254
255			`static int snd_wavefront_midi_output_open(struct snd_rawmidi_substream *substream)`
256			`{`
257			`unsigned long flags;`
258			`snd_wavefront_midi_t *midi;`
259			`snd_wavefront_mpu_id mpu;`
260
261			`snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO);`
262			`snd_assert(substream->rmidi->private_data != NULL, return -EIO);`
263
264			`mpu = ((snd_wavefront_mpu_id ) substream->rmidi->private_data);`
265
266			`if ((midi = get_wavefront_midi (substream)) == NULL)`
267			`return -EIO;`
268
269			`spin_lock_irqsave (&midi->open, flags);`
270			`midi->mode[mpu] \|= MPU401_MODE_OUTPUT;`
271			`midi->substream_output[mpu] = substream;`
272			`spin_unlock_irqrestore (&midi->open, flags);`
273
274			`return 0;`
275			`}`
276
277			`static int snd_wavefront_midi_input_close(struct snd_rawmidi_substream *substream)`
278			`{`
279			`unsigned long flags;`
280			`snd_wavefront_midi_t *midi;`
281			`snd_wavefront_mpu_id mpu;`
282
283			`snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO);`
284			`snd_assert(substream->rmidi->private_data != NULL, return -EIO);`
285
286			`mpu = ((snd_wavefront_mpu_id ) substream->rmidi->private_data);`
287
288			`if ((midi = get_wavefront_midi (substream)) == NULL)`
289			`return -EIO;`
290
291			`spin_lock_irqsave (&midi->open, flags);`
292			`midi->mode[mpu] &= ~MPU401_MODE_INPUT;`
293			`spin_unlock_irqrestore (&midi->open, flags);`
294
295			`return 0;`
296			`}`
297
298			`static int snd_wavefront_midi_output_close(struct snd_rawmidi_substream *substream)`
299			`{`
300			`unsigned long flags;`
301			`snd_wavefront_midi_t *midi;`
302			`snd_wavefront_mpu_id mpu;`
303
304			`snd_assert(substream != NULL && substream->rmidi != NULL, return -EIO);`
305			`snd_assert(substream->rmidi->private_data != NULL, return -EIO);`
306
307			`mpu = ((snd_wavefront_mpu_id ) substream->rmidi->private_data);`
308
309			`if ((midi = get_wavefront_midi (substream)) == NULL)`
310			`return -EIO;`
311
312			`spin_lock_irqsave (&midi->open, flags);`
313			`midi->mode[mpu] &= ~MPU401_MODE_OUTPUT;`
314			`spin_unlock_irqrestore (&midi->open, flags);`
315			`return 0;`
316			`}`
317
318			`static void snd_wavefront_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)`
319			`{`
320			`unsigned long flags;`
321			`snd_wavefront_midi_t *midi;`
322			`snd_wavefront_mpu_id mpu;`
323
324			`if (substream == NULL \|\| substream->rmidi == NULL)`
325			`return;`
326
327			`if (substream->rmidi->private_data == NULL)`
328			`return;`
329
330			`mpu = ((snd_wavefront_mpu_id ) substream->rmidi->private_data);`
331
332			`if ((midi = get_wavefront_midi (substream)) == NULL) {`
333			`return;`
334			`}`
335
336			`spin_lock_irqsave (&midi->virtual, flags);`
337			`if (up) {`
338			`midi->mode[mpu] \|= MPU401_MODE_INPUT_TRIGGER;`
339			`} else {`
340			`midi->mode[mpu] &= ~MPU401_MODE_INPUT_TRIGGER;`
341			`}`
342			`spin_unlock_irqrestore (&midi->virtual, flags);`
343			`}`
344
345			`static void snd_wavefront_midi_output_timer(unsigned long data)`
346			`{`
347			`snd_wavefront_card_t card = (snd_wavefront_card_t )data;`
348			`snd_wavefront_midi_t *midi = &card->wavefront.midi;`
349			`unsigned long flags;`
350
351			`spin_lock_irqsave (&midi->virtual, flags);`
352			`midi->timer.expires = 1 + jiffies;`
353			`add_timer(&midi->timer);`
354			`spin_unlock_irqrestore (&midi->virtual, flags);`
355			`snd_wavefront_midi_output_write(card);`
356			`}`
357
358			`static void snd_wavefront_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)`
359			`{`
360			`unsigned long flags;`
361			`snd_wavefront_midi_t *midi;`
362			`snd_wavefront_mpu_id mpu;`
363
364			`if (substream == NULL \|\| substream->rmidi == NULL)`
365			`return;`
366
367			`if (substream->rmidi->private_data == NULL)`
368			`return;`
369
370			`mpu = ((snd_wavefront_mpu_id ) substream->rmidi->private_data);`
371
372			`if ((midi = get_wavefront_midi (substream)) == NULL) {`
373			`return;`
374			`}`
375
376			`spin_lock_irqsave (&midi->virtual, flags);`
377			`if (up) {`
378			`if ((midi->mode[mpu] & MPU401_MODE_OUTPUT_TRIGGER) == 0) {`
379			`if (!midi->istimer) {`
380			`init_timer(&midi->timer);`
381			`midi->timer.function = snd_wavefront_midi_output_timer;`
382			`midi->timer.data = (unsigned long) substream->rmidi->card->private_data;`
383			`midi->timer.expires = 1 + jiffies;`
384			`add_timer(&midi->timer);`
385			`}`
386			`midi->istimer++;`
387			`midi->mode[mpu] \|= MPU401_MODE_OUTPUT_TRIGGER;`
388			`}`
389			`} else {`
390			`midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;`
391			`}`
392			`spin_unlock_irqrestore (&midi->virtual, flags);`
393
394			`if (up)`
395			`snd_wavefront_midi_output_write((snd_wavefront_card_t *)substream->rmidi->card->private_data);`
396			`}`
397
398			`void`
399			`snd_wavefront_midi_interrupt (snd_wavefront_card_t *card)`
400
401			`{`
402			`unsigned long flags;`
403			`snd_wavefront_midi_t *midi;`
404			`static struct snd_rawmidi_substream *substream = NULL;`
405			`static int mpu = external_mpu;`
406			`int max = 128;`
407			`unsigned char byte;`
408
409			`midi = &card->wavefront.midi;`
410
411			`if (!input_avail (midi)) { /* not for us */`
412			`snd_wavefront_midi_output_write(card);`
413			`return;`
414			`}`
415
416			`spin_lock_irqsave (&midi->virtual, flags);`
417			`while (--max) {`
418
419			`if (input_avail (midi)) {`
420			`byte = read_data (midi);`
421
422			`if (midi->isvirtual) {`
423			`if (byte == WF_EXTERNAL_SWITCH) {`
424			`substream = midi->substream_input[external_mpu];`
425			`mpu = external_mpu;`
426			`} else if (byte == WF_INTERNAL_SWITCH) {`
427			`substream = midi->substream_output[internal_mpu];`
428			`mpu = internal_mpu;`
429			`} /* else just leave it as it is */`
430			`} else {`
431			`substream = midi->substream_input[internal_mpu];`
432			`mpu = internal_mpu;`
433			`}`
434
435			`if (substream == NULL) {`
436			`continue;`
437			`}`
438
439			`if (midi->mode[mpu] & MPU401_MODE_INPUT_TRIGGER) {`
440			`snd_rawmidi_receive(substream, &byte, 1);`
441			`}`
442			`} else {`
443			`break;`
444			`}`
445			`}`
446			`spin_unlock_irqrestore (&midi->virtual, flags);`
447
448			`snd_wavefront_midi_output_write(card);`
449			`}`
450
451			`void`
452			`snd_wavefront_midi_enable_virtual (snd_wavefront_card_t *card)`
453
454			`{`
455			`unsigned long flags;`
456
457			`spin_lock_irqsave (&card->wavefront.midi.virtual, flags);`
458			`card->wavefront.midi.isvirtual = 1;`
459			`card->wavefront.midi.output_mpu = internal_mpu;`
460			`card->wavefront.midi.input_mpu = internal_mpu;`
461			`spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags);`
462			`}`
463
464			`void`
465			`snd_wavefront_midi_disable_virtual (snd_wavefront_card_t *card)`
466
467			`{`
468			`unsigned long flags;`
469
470			`spin_lock_irqsave (&card->wavefront.midi.virtual, flags);`
471			`// snd_wavefront_midi_input_close (card->ics2115_external_rmidi);`
472			`// snd_wavefront_midi_output_close (card->ics2115_external_rmidi);`
473			`card->wavefront.midi.isvirtual = 0;`
474			`spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags);`
475			`}`
476
477			`int __devinit`
478			`snd_wavefront_midi_start (snd_wavefront_card_t *card)`
479
480			`{`
481			`int ok, i;`
482			`unsigned char rbuf[4], wbuf[4];`
483			`snd_wavefront_t *dev;`
484			`snd_wavefront_midi_t *midi;`
485
486			`dev = &card->wavefront;`
487			`midi = &dev->midi;`
488
489			`/* The ICS2115 MPU-401 interface doesn't do anything`
490			`until its set into UART mode.`
491			`*/`
492
493			`/* XXX fix me - no hard timing loops allowed! */`
494
495			`for (i = 0; i < 30000 && !output_ready (midi); i++);`
496
497			`if (!output_ready (midi)) {`
498			`snd_printk ("MIDI interface not ready for command\n");`
499			`return -1;`
500			`}`
501
502			`/* Any interrupts received from now on`
503			`are owned by the MIDI side of things.`
504			`*/`
505
506			`dev->interrupts_are_midi = 1;`
507
508			`outb (UART_MODE_ON, midi->mpu_command_port);`
509
510			`for (ok = 0, i = 50000; i > 0 && !ok; i--) {`
511			`if (input_avail (midi)) {`
512			`if (read_data (midi) == MPU_ACK) {`
513			`ok = 1;`
514			`break;`
515			`}`
516			`}`
517			`}`
518
519			`if (!ok) {`
520			`snd_printk ("cannot set UART mode for MIDI interface");`
521			`dev->interrupts_are_midi = 0;`
522			`return -1;`
523			`}`
524
525			`/* Route external MIDI to WaveFront synth (by default) */`
526
527			`if (snd_wavefront_cmd (dev, WFC_MISYNTH_ON, rbuf, wbuf)) {`
528			`snd_printk ("can't enable MIDI-IN-2-synth routing.\n");`
529			`/* XXX error ? */`
530			`}`
531
532			`/* Turn on Virtual MIDI, but first always turn it off,`
533			`since otherwise consectutive reloads of the driver will`
534			`never cause the hardware to generate the initial "internal" or`
535			`"external" source bytes in the MIDI data stream. This`
536			`is pretty important, since the internal hardware generally will`
537			`be used to generate none or very little MIDI output, and`
538			`thus the only source of MIDI data is actually external. Without`
539			`the switch bytes, the driver will think it all comes from`
540			`the internal interface. Duh.`
541			`*/`
542
543			`if (snd_wavefront_cmd (dev, WFC_VMIDI_OFF, rbuf, wbuf)) {`
544			`snd_printk ("virtual MIDI mode not disabled\n");`
545			`return 0; /* We're OK, but missing the external MIDI dev */`
546			`}`
547
548			`snd_wavefront_midi_enable_virtual (card);`
549
550			`if (snd_wavefront_cmd (dev, WFC_VMIDI_ON, rbuf, wbuf)) {`
551			`snd_printk ("cannot enable virtual MIDI mode.\n");`
552			`snd_wavefront_midi_disable_virtual (card);`
553			`}`
554			`return 0;`
555			`}`
556
557			`struct snd_rawmidi_ops snd_wavefront_midi_output =`
558			`{`
559			`.open = snd_wavefront_midi_output_open,`
560			`.close = snd_wavefront_midi_output_close,`
561			`.trigger = snd_wavefront_midi_output_trigger,`
562			`};`
563
564			`struct snd_rawmidi_ops snd_wavefront_midi_input =`
565			`{`
566			`.open = snd_wavefront_midi_input_open,`
567			`.close = snd_wavefront_midi_input_close,`
568			`.trigger = snd_wavefront_midi_input_trigger,`
569			`};`
570