]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * sound/v_midi.c | |
3 | * | |
4 | * The low level driver for the Sound Blaster DS chips. | |
5 | * | |
6 | * | |
7 | * Copyright (C) by Hannu Savolainen 1993-1996 | |
8 | * | |
9 | * USS/Lite 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 | * Changes | |
15 | * Alan Cox Modularisation, changed memory allocations | |
16 | * Christoph Hellwig Adapted to module_init/module_exit | |
17 | * | |
18 | * Status | |
19 | * Untested | |
20 | */ | |
21 | ||
22 | #include <linux/init.h> | |
23 | #include <linux/module.h> | |
24 | #include <linux/spinlock.h> | |
25 | #include "sound_config.h" | |
26 | ||
27 | #include "v_midi.h" | |
28 | ||
29 | static vmidi_devc *v_devc[2] = { NULL, NULL}; | |
30 | static int midi1,midi2; | |
31 | static void *midi_mem = NULL; | |
32 | ||
33 | /* | |
34 | * The DSP channel can be used either for input or output. Variable | |
35 | * 'sb_irq_mode' will be set when the program calls read or write first time | |
36 | * after open. Current version doesn't support mode changes without closing | |
37 | * and reopening the device. Support for this feature may be implemented in a | |
38 | * future version of this driver. | |
39 | */ | |
40 | ||
41 | ||
42 | void (*midi_input_intr) (int dev, unsigned char data); | |
43 | ||
44 | static int v_midi_open (int dev, int mode, | |
45 | void (*input) (int dev, unsigned char data), | |
46 | void (*output) (int dev) | |
47 | ) | |
48 | { | |
49 | vmidi_devc *devc = midi_devs[dev]->devc; | |
50 | unsigned long flags; | |
51 | ||
52 | if (devc == NULL) | |
53 | return -(ENXIO); | |
54 | ||
55 | spin_lock_irqsave(&devc->lock,flags); | |
56 | if (devc->opened) | |
57 | { | |
58 | spin_unlock_irqrestore(&devc->lock,flags); | |
59 | return -(EBUSY); | |
60 | } | |
61 | devc->opened = 1; | |
62 | spin_unlock_irqrestore(&devc->lock,flags); | |
63 | ||
64 | devc->intr_active = 1; | |
65 | ||
66 | if (mode & OPEN_READ) | |
67 | { | |
68 | devc->input_opened = 1; | |
69 | devc->midi_input_intr = input; | |
70 | } | |
71 | ||
72 | return 0; | |
73 | } | |
74 | ||
75 | static void v_midi_close (int dev) | |
76 | { | |
77 | vmidi_devc *devc = midi_devs[dev]->devc; | |
78 | unsigned long flags; | |
79 | ||
80 | if (devc == NULL) | |
81 | return; | |
82 | ||
83 | spin_lock_irqsave(&devc->lock,flags); | |
84 | devc->intr_active = 0; | |
85 | devc->input_opened = 0; | |
86 | devc->opened = 0; | |
87 | spin_unlock_irqrestore(&devc->lock,flags); | |
88 | } | |
89 | ||
90 | static int v_midi_out (int dev, unsigned char midi_byte) | |
91 | { | |
92 | vmidi_devc *devc = midi_devs[dev]->devc; | |
93 | vmidi_devc *pdevc; | |
94 | ||
95 | if (devc == NULL) | |
96 | return -ENXIO; | |
97 | ||
98 | pdevc = midi_devs[devc->pair_mididev]->devc; | |
99 | if (pdevc->input_opened > 0){ | |
100 | if (MIDIbuf_avail(pdevc->my_mididev) > 500) | |
101 | return 0; | |
102 | pdevc->midi_input_intr (pdevc->my_mididev, midi_byte); | |
103 | } | |
104 | return 1; | |
105 | } | |
106 | ||
107 | static inline int v_midi_start_read (int dev) | |
108 | { | |
109 | return 0; | |
110 | } | |
111 | ||
112 | static int v_midi_end_read (int dev) | |
113 | { | |
114 | vmidi_devc *devc = midi_devs[dev]->devc; | |
115 | if (devc == NULL) | |
116 | return -ENXIO; | |
117 | ||
118 | devc->intr_active = 0; | |
119 | return 0; | |
120 | } | |
121 | ||
122 | /* why -EPERM and not -EINVAL?? */ | |
123 | ||
124 | static inline int v_midi_ioctl (int dev, unsigned cmd, void __user *arg) | |
125 | { | |
126 | return -EPERM; | |
127 | } | |
128 | ||
129 | ||
130 | #define MIDI_SYNTH_NAME "Loopback MIDI" | |
131 | #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT | |
132 | ||
133 | #include "midi_synth.h" | |
134 | ||
135 | static struct midi_operations v_midi_operations = | |
136 | { | |
137 | .owner = THIS_MODULE, | |
138 | .info = {"Loopback MIDI Port 1", 0, 0, SNDCARD_VMIDI}, | |
139 | .converter = &std_midi_synth, | |
140 | .in_info = {0}, | |
141 | .open = v_midi_open, | |
142 | .close = v_midi_close, | |
143 | .ioctl = v_midi_ioctl, | |
144 | .outputc = v_midi_out, | |
145 | .start_read = v_midi_start_read, | |
146 | .end_read = v_midi_end_read, | |
147 | }; | |
148 | ||
149 | static struct midi_operations v_midi_operations2 = | |
150 | { | |
151 | .owner = THIS_MODULE, | |
152 | .info = {"Loopback MIDI Port 2", 0, 0, SNDCARD_VMIDI}, | |
153 | .converter = &std_midi_synth, | |
154 | .in_info = {0}, | |
155 | .open = v_midi_open, | |
156 | .close = v_midi_close, | |
157 | .ioctl = v_midi_ioctl, | |
158 | .outputc = v_midi_out, | |
159 | .start_read = v_midi_start_read, | |
160 | .end_read = v_midi_end_read, | |
161 | }; | |
162 | ||
163 | /* | |
164 | * We kmalloc just one of these - it makes life simpler and the code | |
165 | * cleaner and the memory handling far more efficient | |
166 | */ | |
167 | ||
168 | struct vmidi_memory | |
169 | { | |
170 | /* Must be first */ | |
171 | struct midi_operations m_ops[2]; | |
172 | struct synth_operations s_ops[2]; | |
173 | struct vmidi_devc v_ops[2]; | |
174 | }; | |
175 | ||
176 | static void __init attach_v_midi (struct address_info *hw_config) | |
177 | { | |
178 | struct vmidi_memory *m; | |
179 | /* printk("Attaching v_midi device.....\n"); */ | |
180 | ||
181 | midi1 = sound_alloc_mididev(); | |
182 | if (midi1 == -1) | |
183 | { | |
184 | printk(KERN_ERR "v_midi: Too many midi devices detected\n"); | |
185 | return; | |
186 | } | |
187 | ||
188 | m=(struct vmidi_memory *)kmalloc(sizeof(struct vmidi_memory), GFP_KERNEL); | |
189 | if (m == NULL) | |
190 | { | |
191 | printk(KERN_WARNING "Loopback MIDI: Failed to allocate memory\n"); | |
192 | sound_unload_mididev(midi1); | |
193 | return; | |
194 | } | |
195 | ||
196 | midi_mem = m; | |
197 | ||
198 | midi_devs[midi1] = &m->m_ops[0]; | |
199 | ||
200 | ||
201 | midi2 = sound_alloc_mididev(); | |
202 | if (midi2 == -1) | |
203 | { | |
204 | printk (KERN_ERR "v_midi: Too many midi devices detected\n"); | |
205 | kfree(m); | |
206 | sound_unload_mididev(midi1); | |
207 | return; | |
208 | } | |
209 | ||
210 | midi_devs[midi2] = &m->m_ops[1]; | |
211 | ||
212 | /* printk("VMIDI1: %d VMIDI2: %d\n",midi1,midi2); */ | |
213 | ||
214 | /* for MIDI-1 */ | |
215 | v_devc[0] = &m->v_ops[0]; | |
216 | memcpy ((char *) midi_devs[midi1], (char *) &v_midi_operations, | |
217 | sizeof (struct midi_operations)); | |
218 | ||
219 | v_devc[0]->my_mididev = midi1; | |
220 | v_devc[0]->pair_mididev = midi2; | |
221 | v_devc[0]->opened = v_devc[0]->input_opened = 0; | |
222 | v_devc[0]->intr_active = 0; | |
223 | v_devc[0]->midi_input_intr = NULL; | |
224 | spin_lock_init(&v_devc[0]->lock); | |
225 | ||
226 | midi_devs[midi1]->devc = v_devc[0]; | |
227 | ||
228 | midi_devs[midi1]->converter = &m->s_ops[0]; | |
229 | std_midi_synth.midi_dev = midi1; | |
230 | memcpy ((char *) midi_devs[midi1]->converter, (char *) &std_midi_synth, | |
231 | sizeof (struct synth_operations)); | |
232 | midi_devs[midi1]->converter->id = "V_MIDI 1"; | |
233 | ||
234 | /* for MIDI-2 */ | |
235 | v_devc[1] = &m->v_ops[1]; | |
236 | ||
237 | memcpy ((char *) midi_devs[midi2], (char *) &v_midi_operations2, | |
238 | sizeof (struct midi_operations)); | |
239 | ||
240 | v_devc[1]->my_mididev = midi2; | |
241 | v_devc[1]->pair_mididev = midi1; | |
242 | v_devc[1]->opened = v_devc[1]->input_opened = 0; | |
243 | v_devc[1]->intr_active = 0; | |
244 | v_devc[1]->midi_input_intr = NULL; | |
245 | spin_lock_init(&v_devc[1]->lock); | |
246 | ||
247 | midi_devs[midi2]->devc = v_devc[1]; | |
248 | midi_devs[midi2]->converter = &m->s_ops[1]; | |
249 | ||
250 | std_midi_synth.midi_dev = midi2; | |
251 | memcpy ((char *) midi_devs[midi2]->converter, (char *) &std_midi_synth, | |
252 | sizeof (struct synth_operations)); | |
253 | midi_devs[midi2]->converter->id = "V_MIDI 2"; | |
254 | ||
255 | sequencer_init(); | |
256 | /* printk("Attached v_midi device\n"); */ | |
257 | } | |
258 | ||
259 | static inline int __init probe_v_midi(struct address_info *hw_config) | |
260 | { | |
261 | return(1); /* always OK */ | |
262 | } | |
263 | ||
264 | ||
265 | static void __exit unload_v_midi(struct address_info *hw_config) | |
266 | { | |
267 | sound_unload_mididev(midi1); | |
268 | sound_unload_mididev(midi2); | |
269 | kfree(midi_mem); | |
270 | } | |
271 | ||
272 | static struct address_info cfg; /* dummy */ | |
273 | ||
274 | static int __init init_vmidi(void) | |
275 | { | |
276 | printk("MIDI Loopback device driver\n"); | |
277 | if (!probe_v_midi(&cfg)) | |
278 | return -ENODEV; | |
279 | attach_v_midi(&cfg); | |
280 | ||
281 | return 0; | |
282 | } | |
283 | ||
284 | static void __exit cleanup_vmidi(void) | |
285 | { | |
286 | unload_v_midi(&cfg); | |
287 | } | |
288 | ||
289 | module_init(init_vmidi); | |
290 | module_exit(cleanup_vmidi); | |
291 | MODULE_LICENSE("GPL"); |