sound/oss/sb_midi.c

   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
  31 static 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
  71 static 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
  87 static 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
 105 static int sb_midi_start_read(int dev)
 106 {
 107         return 0;
 108 }
 109
 110 static 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
 122 static int sb_midi_ioctl(int dev, unsigned cmd, void __user *arg)
 123 {
 124         return -EINVAL;
 125 }
 126
 127 void 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
 148 static 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
 162 void 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 }