freebsd-dev/sys/i386/isa/sound/mad16_sb_midi.c
Mark Murray 1fa24a09c7 Upgrade the sound sources to Amancio Hasty's latest-and-greatest.
This is based on Voxware 3.5, and corresponds to Amancio's `guspnp21'.

Bug reports to Amancio, please!
1997-10-31 06:30:22 +00:00

286 lines
6.6 KiB
C

/*
* sound/mad16_sb_midi.c
*
* The low level driver for MAD16 SoundBlaster-DS-chip-based MIDI.
*
* Copyright by Hannu Savolainen 1993, Aaron Ucko 1995
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer. 2.
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/
#include <i386/isa/sound/sound_config.h>
#if defined(CONFIG_MAD16) && defined(CONFIG_MIDI)
#define sbc_base mad16_sb_base
#include <i386/isa/sound/sb_card.h>
static int input_opened = 0;
static int my_dev;
static int mad16_sb_base = 0x220;
static int mad16_sb_irq = 0;
static int mad16_sb_dsp_ok = 0;
static sound_os_info *midi_osp;
int mad16_sb_midi_mode = NORMAL_MIDI;
int mad16_sb_midi_busy = 0;
int mad16_sb_duplex_midi = 0;
volatile int mad16_sb_intr_active = 0;
void (*midi_input_intr) (int dev, unsigned char data);
static void mad16_sb_midi_init(int model);
static int
mad16_sb_dsp_command(unsigned char val)
{
int i;
unsigned long limit;
limit = get_time() + hz / 10; /* The timeout is 0.1 secods */
/*
* Note! the i<500000 is an emergency exit. The
* mad16_sb_dsp_command() is sometimes called while interrupts are
* disabled. This means that the timer is disabled also. However the
* timeout situation is a abnormal condition. Normally the DSP should
* be ready to accept commands after just couple of loops.
*/
for (i = 0; i < 500000 && get_time() < limit; i++) {
if ((inb(DSP_STATUS) & 0x80) == 0) {
outb(DSP_COMMAND, val);
return 1;
}
}
printf("MAD16 (SBP mode): DSP Command(%x) Timeout.\n", val);
printf("IRQ conflict???\n");
return 0;
}
void
mad16_sbintr(int irq)
{
int status;
unsigned long flags;
unsigned char data;
status = inb(DSP_DATA_AVAIL); /* Clear interrupt */
flags = splhigh();
data = inb(DSP_READ);
if (input_opened)
midi_input_intr(my_dev, data);
splx(flags);
}
static int
mad16_sb_reset_dsp(void)
{
int loopc;
outb(DSP_RESET, 1);
DELAY(10);
outb(DSP_RESET, 0);
DELAY(30);
for (loopc = 0; loopc < 100 && !(inb(DSP_DATA_AVAIL) & 0x80); loopc++)
DELAY(10);
/* Wait for data available status */
if (inb(DSP_READ) != 0xAA)
return 0; /* Sorry */
return 1;
}
int
mad16_sb_dsp_detect(struct address_info * hw_config)
{
mad16_sb_base = hw_config->io_base;
mad16_sb_irq = hw_config->irq;
midi_osp = hw_config->osp;
if (mad16_sb_dsp_ok)
return 0; /* Already initialized */
if (!mad16_sb_reset_dsp())
return 0;
return 1; /* Detected */
}
void
mad16_sb_dsp_init(struct address_info * hw_config)
/*
* this function now just verifies the reported version and calls
* mad16_sb_midi_init -- everything else is done elsewhere
*/
{
midi_osp = hw_config->osp;
if (snd_set_irq_handler(mad16_sb_irq, mad16_sbintr, midi_osp) < 0) {
printf("MAD16 SB MIDI: IRQ not free\n");
return;
}
conf_printf("MAD16 MIDI (SB mode)", hw_config);
mad16_sb_midi_init(2);
mad16_sb_dsp_ok = 1;
return;
}
static int
mad16_sb_midi_open(int dev, int mode,
void (*input) (int dev, unsigned char data),
void (*output) (int dev)
)
{
if (!mad16_sb_dsp_ok) {
printf("MAD16_SB Error: MIDI hardware not installed\n");
return -(ENXIO);
}
if (mad16_sb_midi_busy)
return -(EBUSY);
if (mode != OPEN_WRITE && !mad16_sb_duplex_midi) {
if (num_midis == 1)
printf("MAD16 (SBP mode): Midi input not currently supported\n");
return -(EPERM);
}
mad16_sb_midi_mode = NORMAL_MIDI;
if (mode != OPEN_WRITE) {
if (mad16_sb_intr_active)
return -(EBUSY);
mad16_sb_midi_mode = UART_MIDI;
}
if (mad16_sb_midi_mode == UART_MIDI) {
mad16_sb_reset_dsp();
if (!mad16_sb_dsp_command(0x35))
return -(EIO); /* Enter the UART mode */
mad16_sb_intr_active = 1;
input_opened = 1;
midi_input_intr = input;
}
mad16_sb_midi_busy = 1;
return 0;
}
static void
mad16_sb_midi_close(int dev)
{
if (mad16_sb_midi_mode == UART_MIDI) {
mad16_sb_reset_dsp(); /* The only way to kill the UART mode */
}
mad16_sb_intr_active = 0;
mad16_sb_midi_busy = 0;
input_opened = 0;
}
static int
mad16_sb_midi_out(int dev, unsigned char midi_byte)
{
unsigned long flags;
if (mad16_sb_midi_mode == NORMAL_MIDI) {
flags = splhigh();
if (mad16_sb_dsp_command(0x38))
mad16_sb_dsp_command(midi_byte);
else
printf("MAD16_SB Error: Unable to send a MIDI byte\n");
splx(flags);
} else
mad16_sb_dsp_command(midi_byte); /* UART write */
return 1;
}
static int
mad16_sb_midi_start_read(int dev)
{
if (mad16_sb_midi_mode != UART_MIDI) {
printf("MAD16 (SBP mode): MIDI input not implemented.\n");
return -(EPERM);
}
return 0;
}
static int
mad16_sb_midi_end_read(int dev)
{
if (mad16_sb_midi_mode == UART_MIDI) {
mad16_sb_reset_dsp();
mad16_sb_intr_active = 0;
}
return 0;
}
static int
mad16_sb_midi_ioctl(int dev, unsigned cmd, ioctl_arg arg)
{
return -(EPERM);
}
#define MIDI_SYNTH_NAME "pseudo-SoundBlaster Midi"
#define MIDI_SYNTH_CAPS 0
#include <i386/isa/sound/midi_synth.h>
static struct midi_operations mad16_sb_midi_operations =
{
{"MAD16 (SBP mode)", 0, 0, SNDCARD_MAD16},
&std_midi_synth,
{0},
mad16_sb_midi_open,
mad16_sb_midi_close,
mad16_sb_midi_ioctl,
mad16_sb_midi_out,
mad16_sb_midi_start_read,
mad16_sb_midi_end_read,
NULL, /* Kick */
NULL, /* command */
NULL, /* buffer_status */
NULL
};
static void
mad16_sb_midi_init(int model)
{
if (num_midis >= MAX_MIDI_DEV) {
printf("Sound: Too many midi devices detected\n");
return;
}
std_midi_synth.midi_dev = num_midis;
my_dev = num_midis;
midi_devs[num_midis++] = &mad16_sb_midi_operations;
}
#endif