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