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