diff options
Diffstat (limited to 'sound/oss/sb_midi.c')
| -rw-r--r-- | sound/oss/sb_midi.c | 205 |
1 files changed, 205 insertions, 0 deletions
diff --git a/sound/oss/sb_midi.c b/sound/oss/sb_midi.c new file mode 100644 index 000000000000..ed3bd0640ffd --- /dev/null +++ b/sound/oss/sb_midi.c @@ -0,0 +1,205 @@ +/* + * sound/sb_dsp.c + * + * The low level driver for the Sound Blaster DS chips. + * + * + * 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. + */ + +#include <linux/spinlock.h> + +#include "sound_config.h" + +#include "sb.h" +#undef SB_TEST_IRQ + +/* + * The DSP channel can be used either for input or output. Variable + * 'sb_irq_mode' will be set when the program calls read or write first time + * after open. Current version doesn't support mode changes without closing + * and reopening the device. Support for this feature may be implemented in a + * future version of this driver. + */ + + +static int sb_midi_open(int dev, int mode, + void (*input) (int dev, unsigned char data), + void (*output) (int dev) +) +{ + sb_devc *devc = midi_devs[dev]->devc; + unsigned long flags; + + if (devc == NULL) + return -ENXIO; + + spin_lock_irqsave(&devc->lock, flags); + if (devc->opened) + { + spin_unlock_irqrestore(&devc->lock, flags); + return -EBUSY; + } + devc->opened = 1; + spin_unlock_irqrestore(&devc->lock, flags); + + devc->irq_mode = IMODE_MIDI; + devc->midi_broken = 0; + + sb_dsp_reset(devc); + + if (!sb_dsp_command(devc, 0x35)) /* Start MIDI UART mode */ + { + devc->opened = 0; + return -EIO; + } + devc->intr_active = 1; + + if (mode & OPEN_READ) + { + devc->input_opened = 1; + devc->midi_input_intr = input; + } + return 0; +} + +static void sb_midi_close(int dev) +{ + sb_devc *devc = midi_devs[dev]->devc; + unsigned long flags; + + if (devc == NULL) + return; + + spin_lock_irqsave(&devc->lock, flags); + sb_dsp_reset(devc); + devc->intr_active = 0; + devc->input_opened = 0; + devc->opened = 0; + spin_unlock_irqrestore(&devc->lock, flags); +} + +static int sb_midi_out(int dev, unsigned char midi_byte) +{ + sb_devc *devc = midi_devs[dev]->devc; + + if (devc == NULL) + return 1; + + if (devc->midi_broken) + return 1; + + if (!sb_dsp_command(devc, midi_byte)) + { + devc->midi_broken = 1; + return 1; + } + return 1; +} + +static int sb_midi_start_read(int dev) +{ + return 0; +} + +static int sb_midi_end_read(int dev) +{ + sb_devc *devc = midi_devs[dev]->devc; + + if (devc == NULL) + return -ENXIO; + + sb_dsp_reset(devc); + devc->intr_active = 0; + return 0; +} + +static int sb_midi_ioctl(int dev, unsigned cmd, void __user *arg) +{ + return -EINVAL; +} + +void sb_midi_interrupt(sb_devc * devc) +{ + unsigned long flags; + unsigned char data; + + if (devc == NULL) + return; + + spin_lock_irqsave(&devc->lock, flags); + + data = inb(DSP_READ); + if (devc->input_opened) + devc->midi_input_intr(devc->my_mididev, data); + + spin_unlock_irqrestore(&devc->lock, flags); +} + +#define MIDI_SYNTH_NAME "Sound Blaster Midi" +#define MIDI_SYNTH_CAPS 0 +#include "midi_synth.h" + +static struct midi_operations sb_midi_operations = +{ + .owner = THIS_MODULE, + .info = {"Sound Blaster", 0, 0, SNDCARD_SB}, + .converter = &std_midi_synth, + .in_info = {0}, + .open = sb_midi_open, + .close = sb_midi_close, + .ioctl = sb_midi_ioctl, + .outputc = sb_midi_out, + .start_read = sb_midi_start_read, + .end_read = sb_midi_end_read, +}; + +void sb_dsp_midi_init(sb_devc * devc, struct module *owner) +{ + int dev; + + if (devc->model < 2) /* No MIDI support for SB 1.x */ + return; + + dev = sound_alloc_mididev(); + + if (dev == -1) + { + printk(KERN_ERR "sb_midi: too many MIDI devices detected\n"); + return; + } + std_midi_synth.midi_dev = devc->my_mididev = dev; + midi_devs[dev] = (struct midi_operations *)kmalloc(sizeof(struct midi_operations), GFP_KERNEL); + if (midi_devs[dev] == NULL) + { + printk(KERN_WARNING "Sound Blaster: failed to allocate MIDI memory.\n"); + sound_unload_mididev(dev); + return; + } + memcpy((char *) midi_devs[dev], (char *) &sb_midi_operations, + sizeof(struct midi_operations)); + + if (owner) + midi_devs[dev]->owner = owner; + + midi_devs[dev]->devc = devc; + + + midi_devs[dev]->converter = (struct synth_operations *)kmalloc(sizeof(struct synth_operations), GFP_KERNEL); + if (midi_devs[dev]->converter == NULL) + { + printk(KERN_WARNING "Sound Blaster: failed to allocate MIDI memory.\n"); + kfree(midi_devs[dev]); + sound_unload_mididev(dev); + return; + } + memcpy((char *) midi_devs[dev]->converter, (char *) &std_midi_synth, + sizeof(struct synth_operations)); + + midi_devs[dev]->converter->id = "SBMIDI"; + sequencer_init(); +} |