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
sb_midi_open(int dev,int mode,void (* input)(int dev,unsigned char data),void (* output)(int dev))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
sb_midi_close(int dev)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
sb_midi_out(int dev,unsigned char midi_byte)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
sb_midi_start_read(int dev)105 static int sb_midi_start_read(int dev)
106 {
107 return 0;
108 }
109
sb_midi_end_read(int dev)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
sb_midi_ioctl(int dev,unsigned cmd,void __user * arg)122 static int sb_midi_ioctl(int dev, unsigned cmd, void __user *arg)
123 {
124 return -EINVAL;
125 }
126
sb_midi_interrupt(sb_devc * devc)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
sb_dsp_midi_init(sb_devc * devc,struct module * owner)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 }
207