linux/sound/oss/sb_midi.c
<<
>>
Prefs
   1/*
   2 * sound/oss/sb_midi.c
   3 *
   4 * The low level driver for the Sound Blaster DS chips.
   5 *
   6 *
   7 * Copyright (C) by Hannu Savolainen 1993-1997
   8 *
   9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11 * for more info.
  12 */
  13
  14#include <linux/spinlock.h>
  15#include <linux/slab.h>
  16
  17#include "sound_config.h"
  18
  19#include "sb.h"
  20#undef SB_TEST_IRQ
  21
  22/*
  23 * The DSP channel can be used either for input or output. Variable
  24 * 'sb_irq_mode' will be set when the program calls read or write first time
  25 * after open. Current version doesn't support mode changes without closing
  26 * and reopening the device. Support for this feature may be implemented in a
  27 * future version of this driver.
  28 */
  29
  30
  31static int sb_midi_open(int dev, int mode,
  32             void            (*input) (int dev, unsigned char data),
  33             void            (*output) (int dev)
  34)
  35{
  36        sb_devc *devc = midi_devs[dev]->devc;
  37        unsigned long flags;
  38
  39        if (devc == NULL)
  40                return -ENXIO;
  41
  42        spin_lock_irqsave(&devc->lock, flags);
  43        if (devc->opened)
  44        {
  45                spin_unlock_irqrestore(&devc->lock, flags);
  46                return -EBUSY;
  47        }
  48        devc->opened = 1;
  49        spin_unlock_irqrestore(&devc->lock, flags);
  50
  51        devc->irq_mode = IMODE_MIDI;
  52        devc->midi_broken = 0;
  53
  54        sb_dsp_reset(devc);
  55
  56        if (!sb_dsp_command(devc, 0x35))        /* Start MIDI UART mode */
  57        {
  58                  devc->opened = 0;
  59                  return -EIO;
  60        }
  61        devc->intr_active = 1;
  62
  63        if (mode & OPEN_READ)
  64        {
  65                devc->input_opened = 1;
  66                devc->midi_input_intr = input;
  67        }
  68        return 0;
  69}
  70
  71static void sb_midi_close(int dev)
  72{
  73        sb_devc *devc = midi_devs[dev]->devc;
  74        unsigned long flags;
  75
  76        if (devc == NULL)
  77                return;
  78
  79        spin_lock_irqsave(&devc->lock, flags);
  80        sb_dsp_reset(devc);
  81        devc->intr_active = 0;
  82        devc->input_opened = 0;
  83        devc->opened = 0;
  84        spin_unlock_irqrestore(&devc->lock, flags);
  85}
  86
  87static int sb_midi_out(int dev, unsigned char midi_byte)
  88{
  89        sb_devc *devc = midi_devs[dev]->devc;
  90
  91        if (devc == NULL)
  92                return 1;
  93
  94        if (devc->midi_broken)
  95                return 1;
  96
  97        if (!sb_dsp_command(devc, midi_byte))
  98        {
  99                devc->midi_broken = 1;
 100                return 1;
 101        }
 102        return 1;
 103}
 104
 105static int sb_midi_start_read(int dev)
 106{
 107        return 0;
 108}
 109
 110static int sb_midi_end_read(int dev)
 111{
 112        sb_devc *devc = midi_devs[dev]->devc;
 113
 114        if (devc == NULL)
 115                return -ENXIO;
 116
 117        sb_dsp_reset(devc);
 118        devc->intr_active = 0;
 119        return 0;
 120}
 121
 122static int sb_midi_ioctl(int dev, unsigned cmd, void __user *arg)
 123{
 124        return -EINVAL;
 125}
 126
 127void sb_midi_interrupt(sb_devc * devc)
 128{
 129        unsigned long   flags;
 130        unsigned char   data;
 131
 132        if (devc == NULL)
 133                return;
 134
 135        spin_lock_irqsave(&devc->lock, flags);
 136
 137        data = inb(DSP_READ);
 138        if (devc->input_opened)
 139                devc->midi_input_intr(devc->my_mididev, data);
 140
 141        spin_unlock_irqrestore(&devc->lock, flags);
 142}
 143
 144#define MIDI_SYNTH_NAME "Sound Blaster Midi"
 145#define MIDI_SYNTH_CAPS 0
 146#include "midi_synth.h"
 147
 148static struct midi_operations sb_midi_operations =
 149{
 150        .owner          = THIS_MODULE,
 151        .info           = {"Sound Blaster", 0, 0, SNDCARD_SB},
 152        .converter      = &std_midi_synth,
 153        .in_info        = {0},
 154        .open           = sb_midi_open,
 155        .close          = sb_midi_close,
 156        .ioctl          = sb_midi_ioctl,
 157        .outputc        = sb_midi_out,
 158        .start_read     = sb_midi_start_read,
 159        .end_read       = sb_midi_end_read,
 160};
 161
 162void sb_dsp_midi_init(sb_devc * devc, struct module *owner)
 163{
 164        int dev;
 165
 166        if (devc->model < 2)    /* No MIDI support for SB 1.x */
 167                return;
 168
 169        dev = sound_alloc_mididev();
 170
 171        if (dev == -1)
 172        {
 173                printk(KERN_ERR "sb_midi: too many MIDI devices detected\n");
 174                return;
 175        }
 176        std_midi_synth.midi_dev = devc->my_mididev = dev;
 177        midi_devs[dev] = kmalloc(sizeof(struct midi_operations), GFP_KERNEL);
 178        if (midi_devs[dev] == NULL)
 179        {
 180                printk(KERN_WARNING "Sound Blaster:  failed to allocate MIDI memory.\n");
 181                sound_unload_mididev(dev);
 182                  return;
 183        }
 184        memcpy((char *) midi_devs[dev], (char *) &sb_midi_operations,
 185               sizeof(struct midi_operations));
 186
 187        if (owner)
 188                        midi_devs[dev]->owner = owner;
 189        
 190        midi_devs[dev]->devc = devc;
 191
 192
 193        midi_devs[dev]->converter = kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
 194        if (midi_devs[dev]->converter == NULL)
 195        {
 196                  printk(KERN_WARNING "Sound Blaster:  failed to allocate MIDI memory.\n");
 197                  kfree(midi_devs[dev]);
 198                  sound_unload_mididev(dev);
 199                  return;
 200        }
 201        memcpy((char *) midi_devs[dev]->converter, (char *) &std_midi_synth,
 202               sizeof(struct synth_operations));
 203
 204        midi_devs[dev]->converter->id = "SBMIDI";
 205        sequencer_init();
 206}
 207
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.