sb_midi.c

Go to the documentation of this file.

/*
 * sound/oss/sb_midi.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 <linux/slab.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] = 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 = 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();
}