drivers/sound/gus_midi.c

   1 /*
   2  * sound/gus2_midi.c
   3  *
   4  * The low level driver for the GUS Midi Interface.
   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 #include "sound_config.h"
  14 #include "gus_hw.h"
  15
  16 static int      midi_busy = 0, input_opened = 0;
  17 static int      my_dev;
  18 static int      output_used = 0;
  19 static volatile unsigned char gus_midi_control;
  20
  21 static void     (*midi_input_intr) (int dev, unsigned char data);
  22
  23 static unsigned char tmp_queue[256];
  24 extern int      gus_pnp_flag;
  25 static volatile int qlen;
  26 static volatile unsigned char qhead, qtail;
  27 extern int      gus_base, gus_irq, gus_dma;
  28 extern int     *gus_osp;
  29
  30 static int GUS_MIDI_STATUS(void)
  31 {
  32         return inb(u_MidiStatus);
  33 }
  34
  35 static int gus_midi_open(int dev, int mode, void (*input) (int dev, unsigned char data), void (*output) (int dev))
  36 {
  37         if (midi_busy)
  38         {
  39 /*              printk("GUS: Midi busy\n");*/
  40                 return -EBUSY;
  41         }
  42         outb((MIDI_RESET), u_MidiControl);
  43         gus_delay();
  44
  45         gus_midi_control = 0;
  46         input_opened = 0;
  47
  48         if (mode == OPEN_READ || mode == OPEN_READWRITE)
  49                 if (!gus_pnp_flag)
  50                 {
  51                         gus_midi_control |= MIDI_ENABLE_RCV;
  52                         input_opened = 1;
  53                 }
  54         outb((gus_midi_control), u_MidiControl);        /* Enable */
  55
  56         midi_busy = 1;
  57         qlen = qhead = qtail = output_used = 0;
  58         midi_input_intr = input;
  59
  60         return 0;
  61 }
  62
  63 static int dump_to_midi(unsigned char midi_byte)
  64 {
  65         unsigned long   flags;
  66         int             ok = 0;
  67
  68         output_used = 1;
  69
  70         save_flags(flags);
  71         cli();
  72
  73         if (GUS_MIDI_STATUS() & MIDI_XMIT_EMPTY)
  74         {
  75                 ok = 1;
  76                 outb((midi_byte), u_MidiData);
  77         }
  78         else
  79         {
  80                 /*
  81                  * Enable Midi xmit interrupts (again)
  82                  */
  83                 gus_midi_control |= MIDI_ENABLE_XMIT;
  84                 outb((gus_midi_control), u_MidiControl);
  85         }
  86
  87         restore_flags(flags);
  88         return ok;
  89 }
  90
  91 static void gus_midi_close(int dev)
  92 {
  93         /*
  94          * Reset FIFO pointers, disable intrs
  95          */
  96
  97         outb((MIDI_RESET), u_MidiControl);
  98         midi_busy = 0;
  99 }
 100
 101 static int gus_midi_out(int dev, unsigned char midi_byte)
 102 {
 103         unsigned long   flags;
 104
 105         /*
 106          * Drain the local queue first
 107          */
 108
 109         save_flags(flags);
 110         cli();
 111
 112         while (qlen && dump_to_midi(tmp_queue[qhead]))
 113         {
 114                 qlen--;
 115                 qhead++;
 116         }
 117         restore_flags(flags);
 118
 119         /*
 120          *      Output the byte if the local queue is empty.
 121          */
 122
 123         if (!qlen)
 124                 if (dump_to_midi(midi_byte))
 125                         return 1;       /*
 126                                          * OK
 127                                          */
 128
 129         /*
 130          *      Put to the local queue
 131          */
 132
 133         if (qlen >= 256)
 134                 return 0;       /*
 135                                  * Local queue full
 136                                  */
 137         save_flags(flags);
 138         cli();
 139
 140         tmp_queue[qtail] = midi_byte;
 141         qlen++;
 142         qtail++;
 143
 144         restore_flags(flags);
 145         return 1;
 146 }
 147
 148 static int gus_midi_start_read(int dev)
 149 {
 150         return 0;
 151 }
 152
 153 static int gus_midi_end_read(int dev)
 154 {
 155         return 0;
 156 }
 157
 158 static void gus_midi_kick(int dev)
 159 {
 160 }
 161
 162 static int gus_midi_buffer_status(int dev)
 163 {
 164         unsigned long   flags;
 165
 166         if (!output_used)
 167                 return 0;
 168
 169         save_flags(flags);
 170         cli();
 171
 172         if (qlen && dump_to_midi(tmp_queue[qhead]))
 173         {
 174                 qlen--;
 175                 qhead++;
 176         }
 177         restore_flags(flags);
 178         return (qlen > 0) | !(GUS_MIDI_STATUS() & MIDI_XMIT_EMPTY);
 179 }
 180
 181 #define MIDI_SYNTH_NAME "Gravis Ultrasound Midi"
 182 #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
 183 #include "midi_synth.h"
 184
 185 static struct midi_operations gus_midi_operations =
 186 {
 187         {
 188                 "Gravis UltraSound Midi", 0, 0, SNDCARD_GUS
 189         },
 190         &std_midi_synth,
 191         {0},
 192         gus_midi_open,
 193         gus_midi_close,
 194         NULL, /* ioctl */
 195         gus_midi_out,
 196         gus_midi_start_read,
 197         gus_midi_end_read,
 198         gus_midi_kick,
 199         NULL,                   /*
 200                                  * command
 201                                  */
 202         gus_midi_buffer_status,
 203         NULL
 204 };
 205
 206 void gus_midi_init(struct address_info *hw_config)
 207 {
 208         int dev = sound_alloc_mididev();
 209
 210         if (dev == -1)
 211         {
 212                 printk(KERN_INFO "gus_midi: Too many midi devices detected\n");
 213                 return;
 214         }
 215         outb((MIDI_RESET), u_MidiControl);
 216
 217         std_midi_synth.midi_dev = my_dev = dev;
 218         hw_config->slots[2] = dev;
 219         midi_devs[dev] = &gus_midi_operations;
 220         sequencer_init();
 221         return;
 222 }
 223
 224 void gus_midi_interrupt(int dummy)
 225 {
 226         volatile unsigned char stat, data;
 227         unsigned long flags;
 228         int timeout = 10;
 229
 230         save_flags(flags);
 231         cli();
 232
 233         while (timeout-- > 0 && (stat = GUS_MIDI_STATUS()) & (MIDI_RCV_FULL | MIDI_XMIT_EMPTY))
 234         {
 235                 if (stat & MIDI_RCV_FULL)
 236                 {
 237                         data = inb(u_MidiData);
 238                         if (input_opened)
 239                                 midi_input_intr(my_dev, data);
 240                 }
 241                 if (stat & MIDI_XMIT_EMPTY)
 242                 {
 243                         while (qlen && dump_to_midi(tmp_queue[qhead]))
 244                         {
 245                                 qlen--;
 246                                 qhead++;
 247                         }
 248                         if (!qlen)
 249                         {
 250                               /*
 251                                * Disable Midi output interrupts, since no data in the buffer
 252                                */
 253                               gus_midi_control &= ~MIDI_ENABLE_XMIT;
 254                               outb((gus_midi_control), u_MidiControl);
 255                               outb((gus_midi_control), u_MidiControl);
 256                         }
 257                 }
 258         }
 259         restore_flags(flags);
 260 }