1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/io.h>
30#include <linux/time.h>
31#include <sound/core.h>
32#include <sound/sb.h>
33
34
35irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb *chip)
36{
37 struct snd_rawmidi *rmidi;
38 int max = 64;
39 char byte;
40
41 if (!chip)
42 return IRQ_NONE;
43
44 rmidi = chip->rmidi;
45 if (!rmidi) {
46 inb(SBP(chip, DATA_AVAIL));
47 return IRQ_NONE;
48 }
49
50 spin_lock(&chip->midi_input_lock);
51 while (max-- > 0) {
52 if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
53 byte = inb(SBP(chip, READ));
54 if (chip->open & SB_OPEN_MIDI_INPUT_TRIGGER) {
55 snd_rawmidi_receive(chip->midi_substream_input, &byte, 1);
56 }
57 }
58 }
59 spin_unlock(&chip->midi_input_lock);
60 return IRQ_HANDLED;
61}
62
63static int snd_sb8dsp_midi_input_open(struct snd_rawmidi_substream *substream)
64{
65 unsigned long flags;
66 struct snd_sb *chip;
67 unsigned int valid_open_flags;
68
69 chip = substream->rmidi->private_data;
70 valid_open_flags = chip->hardware >= SB_HW_20
71 ? SB_OPEN_MIDI_OUTPUT | SB_OPEN_MIDI_OUTPUT_TRIGGER : 0;
72 spin_lock_irqsave(&chip->open_lock, flags);
73 if (chip->open & ~valid_open_flags) {
74 spin_unlock_irqrestore(&chip->open_lock, flags);
75 return -EAGAIN;
76 }
77 chip->open |= SB_OPEN_MIDI_INPUT;
78 chip->midi_substream_input = substream;
79 if (!(chip->open & SB_OPEN_MIDI_OUTPUT)) {
80 spin_unlock_irqrestore(&chip->open_lock, flags);
81 snd_sbdsp_reset(chip);
82 if (chip->hardware >= SB_HW_20)
83 snd_sbdsp_command(chip, SB_DSP_MIDI_UART_IRQ);
84 } else {
85 spin_unlock_irqrestore(&chip->open_lock, flags);
86 }
87 return 0;
88}
89
90static int snd_sb8dsp_midi_output_open(struct snd_rawmidi_substream *substream)
91{
92 unsigned long flags;
93 struct snd_sb *chip;
94 unsigned int valid_open_flags;
95
96 chip = substream->rmidi->private_data;
97 valid_open_flags = chip->hardware >= SB_HW_20
98 ? SB_OPEN_MIDI_INPUT | SB_OPEN_MIDI_INPUT_TRIGGER : 0;
99 spin_lock_irqsave(&chip->open_lock, flags);
100 if (chip->open & ~valid_open_flags) {
101 spin_unlock_irqrestore(&chip->open_lock, flags);
102 return -EAGAIN;
103 }
104 chip->open |= SB_OPEN_MIDI_OUTPUT;
105 chip->midi_substream_output = substream;
106 if (!(chip->open & SB_OPEN_MIDI_INPUT)) {
107 spin_unlock_irqrestore(&chip->open_lock, flags);
108 snd_sbdsp_reset(chip);
109 if (chip->hardware >= SB_HW_20)
110 snd_sbdsp_command(chip, SB_DSP_MIDI_UART_IRQ);
111 } else {
112 spin_unlock_irqrestore(&chip->open_lock, flags);
113 }
114 return 0;
115}
116
117static int snd_sb8dsp_midi_input_close(struct snd_rawmidi_substream *substream)
118{
119 unsigned long flags;
120 struct snd_sb *chip;
121
122 chip = substream->rmidi->private_data;
123 spin_lock_irqsave(&chip->open_lock, flags);
124 chip->open &= ~(SB_OPEN_MIDI_INPUT | SB_OPEN_MIDI_INPUT_TRIGGER);
125 chip->midi_substream_input = NULL;
126 if (!(chip->open & SB_OPEN_MIDI_OUTPUT)) {
127 spin_unlock_irqrestore(&chip->open_lock, flags);
128 snd_sbdsp_reset(chip);
129 } else {
130 spin_unlock_irqrestore(&chip->open_lock, flags);
131 }
132 return 0;
133}
134
135static int snd_sb8dsp_midi_output_close(struct snd_rawmidi_substream *substream)
136{
137 unsigned long flags;
138 struct snd_sb *chip;
139
140 chip = substream->rmidi->private_data;
141 del_timer_sync(&chip->midi_timer);
142 spin_lock_irqsave(&chip->open_lock, flags);
143 chip->open &= ~(SB_OPEN_MIDI_OUTPUT | SB_OPEN_MIDI_OUTPUT_TRIGGER);
144 chip->midi_substream_output = NULL;
145 if (!(chip->open & SB_OPEN_MIDI_INPUT)) {
146 spin_unlock_irqrestore(&chip->open_lock, flags);
147 snd_sbdsp_reset(chip);
148 } else {
149 spin_unlock_irqrestore(&chip->open_lock, flags);
150 }
151 return 0;
152}
153
154static void snd_sb8dsp_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
155{
156 unsigned long flags;
157 struct snd_sb *chip;
158
159 chip = substream->rmidi->private_data;
160 spin_lock_irqsave(&chip->open_lock, flags);
161 if (up) {
162 if (!(chip->open & SB_OPEN_MIDI_INPUT_TRIGGER)) {
163 if (chip->hardware < SB_HW_20)
164 snd_sbdsp_command(chip, SB_DSP_MIDI_INPUT_IRQ);
165 chip->open |= SB_OPEN_MIDI_INPUT_TRIGGER;
166 }
167 } else {
168 if (chip->open & SB_OPEN_MIDI_INPUT_TRIGGER) {
169 if (chip->hardware < SB_HW_20)
170 snd_sbdsp_command(chip, SB_DSP_MIDI_INPUT_IRQ);
171 chip->open &= ~SB_OPEN_MIDI_INPUT_TRIGGER;
172 }
173 }
174 spin_unlock_irqrestore(&chip->open_lock, flags);
175}
176
177static void snd_sb8dsp_midi_output_write(struct snd_rawmidi_substream *substream)
178{
179 unsigned long flags;
180 struct snd_sb *chip;
181 char byte;
182 int max = 32;
183
184
185 chip = substream->rmidi->private_data;
186 while (max-- > 0) {
187 spin_lock_irqsave(&chip->open_lock, flags);
188 if (snd_rawmidi_transmit_peek(substream, &byte, 1) != 1) {
189 chip->open &= ~SB_OPEN_MIDI_OUTPUT_TRIGGER;
190 del_timer(&chip->midi_timer);
191 spin_unlock_irqrestore(&chip->open_lock, flags);
192 break;
193 }
194 if (chip->hardware >= SB_HW_20) {
195 int timeout = 8;
196 while ((inb(SBP(chip, STATUS)) & 0x80) != 0 && --timeout > 0)
197 ;
198 if (timeout == 0) {
199
200 spin_unlock_irqrestore(&chip->open_lock, flags);
201 break;
202 }
203 outb(byte, SBP(chip, WRITE));
204 } else {
205 snd_sbdsp_command(chip, SB_DSP_MIDI_OUTPUT);
206 snd_sbdsp_command(chip, byte);
207 }
208 snd_rawmidi_transmit_ack(substream, 1);
209 spin_unlock_irqrestore(&chip->open_lock, flags);
210 }
211}
212
213static void snd_sb8dsp_midi_output_timer(struct timer_list *t)
214{
215 struct snd_sb *chip = from_timer(chip, t, midi_timer);
216 struct snd_rawmidi_substream *substream = chip->midi_substream_output;
217 unsigned long flags;
218
219 spin_lock_irqsave(&chip->open_lock, flags);
220 mod_timer(&chip->midi_timer, 1 + jiffies);
221 spin_unlock_irqrestore(&chip->open_lock, flags);
222 snd_sb8dsp_midi_output_write(substream);
223}
224
225static void snd_sb8dsp_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
226{
227 unsigned long flags;
228 struct snd_sb *chip;
229
230 chip = substream->rmidi->private_data;
231 spin_lock_irqsave(&chip->open_lock, flags);
232 if (up) {
233 if (!(chip->open & SB_OPEN_MIDI_OUTPUT_TRIGGER)) {
234 mod_timer(&chip->midi_timer, 1 + jiffies);
235 chip->open |= SB_OPEN_MIDI_OUTPUT_TRIGGER;
236 }
237 } else {
238 if (chip->open & SB_OPEN_MIDI_OUTPUT_TRIGGER) {
239 chip->open &= ~SB_OPEN_MIDI_OUTPUT_TRIGGER;
240 }
241 }
242 spin_unlock_irqrestore(&chip->open_lock, flags);
243
244 if (up)
245 snd_sb8dsp_midi_output_write(substream);
246}
247
248static const struct snd_rawmidi_ops snd_sb8dsp_midi_output =
249{
250 .open = snd_sb8dsp_midi_output_open,
251 .close = snd_sb8dsp_midi_output_close,
252 .trigger = snd_sb8dsp_midi_output_trigger,
253};
254
255static const struct snd_rawmidi_ops snd_sb8dsp_midi_input =
256{
257 .open = snd_sb8dsp_midi_input_open,
258 .close = snd_sb8dsp_midi_input_close,
259 .trigger = snd_sb8dsp_midi_input_trigger,
260};
261
262int snd_sb8dsp_midi(struct snd_sb *chip, int device)
263{
264 struct snd_rawmidi *rmidi;
265 int err;
266
267 if ((err = snd_rawmidi_new(chip->card, "SB8 MIDI", device, 1, 1, &rmidi)) < 0)
268 return err;
269 strcpy(rmidi->name, "SB8 MIDI");
270 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_sb8dsp_midi_output);
271 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_sb8dsp_midi_input);
272 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT;
273 if (chip->hardware >= SB_HW_20)
274 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
275 rmidi->private_data = chip;
276 timer_setup(&chip->midi_timer, snd_sb8dsp_midi_output_timer, 0);
277 chip->rmidi = rmidi;
278 return 0;
279}
280