1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
4 | * Routines for control of EMU10K1 MPU-401 in UART mode |
5 | */ |
6 | |
7 | #include <linux/time.h> |
8 | #include <linux/init.h> |
9 | #include <sound/core.h> |
10 | #include <sound/emu10k1.h> |
11 | |
12 | #define EMU10K1_MIDI_MODE_INPUT (1<<0) |
13 | #define EMU10K1_MIDI_MODE_OUTPUT (1<<1) |
14 | |
15 | static inline unsigned char mpu401_read(struct snd_emu10k1 *emu, |
16 | struct snd_emu10k1_midi *mpu, int idx) |
17 | { |
18 | if (emu->audigy) |
19 | return (unsigned char)snd_emu10k1_ptr_read(emu, reg: mpu->port + idx, chn: 0); |
20 | else |
21 | return inb(port: emu->port + mpu->port + idx); |
22 | } |
23 | |
24 | static inline void mpu401_write(struct snd_emu10k1 *emu, |
25 | struct snd_emu10k1_midi *mpu, int data, int idx) |
26 | { |
27 | if (emu->audigy) |
28 | snd_emu10k1_ptr_write(emu, reg: mpu->port + idx, chn: 0, data); |
29 | else |
30 | outb(value: data, port: emu->port + mpu->port + idx); |
31 | } |
32 | |
33 | #define mpu401_write_data(emu, mpu, data) mpu401_write(emu, mpu, data, 0) |
34 | #define mpu401_write_cmd(emu, mpu, data) mpu401_write(emu, mpu, data, 1) |
35 | #define mpu401_read_data(emu, mpu) mpu401_read(emu, mpu, 0) |
36 | #define mpu401_read_stat(emu, mpu) mpu401_read(emu, mpu, 1) |
37 | |
38 | #define mpu401_input_avail(emu,mpu) (!(mpu401_read_stat(emu,mpu) & 0x80)) |
39 | #define mpu401_output_ready(emu,mpu) (!(mpu401_read_stat(emu,mpu) & 0x40)) |
40 | |
41 | #define MPU401_RESET 0xff |
42 | #define MPU401_ENTER_UART 0x3f |
43 | #define MPU401_ACK 0xfe |
44 | |
45 | static void mpu401_clear_rx(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mpu) |
46 | { |
47 | int timeout = 100000; |
48 | for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--) |
49 | mpu401_read_data(emu, mpu); |
50 | #ifdef CONFIG_SND_DEBUG |
51 | if (timeout <= 0) |
52 | dev_err(emu->card->dev, |
53 | "cmd: clear rx timeout (status = 0x%x)\n" , |
54 | mpu401_read_stat(emu, mpu)); |
55 | #endif |
56 | } |
57 | |
58 | /* |
59 | |
60 | */ |
61 | |
62 | static void do_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, unsigned int status) |
63 | { |
64 | unsigned char byte; |
65 | |
66 | if (midi->rmidi == NULL) { |
67 | snd_emu10k1_intr_disable(emu, intrenb: midi->tx_enable | midi->rx_enable); |
68 | return; |
69 | } |
70 | |
71 | spin_lock(lock: &midi->input_lock); |
72 | if ((status & midi->ipr_rx) && mpu401_input_avail(emu, midi)) { |
73 | if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) { |
74 | mpu401_clear_rx(emu, mpu: midi); |
75 | } else { |
76 | byte = mpu401_read_data(emu, midi); |
77 | if (midi->substream_input) |
78 | snd_rawmidi_receive(substream: midi->substream_input, buffer: &byte, count: 1); |
79 | } |
80 | } |
81 | spin_unlock(lock: &midi->input_lock); |
82 | |
83 | spin_lock(lock: &midi->output_lock); |
84 | if ((status & midi->ipr_tx) && mpu401_output_ready(emu, midi)) { |
85 | if (midi->substream_output && |
86 | snd_rawmidi_transmit(substream: midi->substream_output, buffer: &byte, count: 1) == 1) { |
87 | mpu401_write_data(emu, midi, byte); |
88 | } else { |
89 | snd_emu10k1_intr_disable(emu, intrenb: midi->tx_enable); |
90 | } |
91 | } |
92 | spin_unlock(lock: &midi->output_lock); |
93 | } |
94 | |
95 | static void snd_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, unsigned int status) |
96 | { |
97 | do_emu10k1_midi_interrupt(emu, midi: &emu->midi, status); |
98 | } |
99 | |
100 | static void snd_emu10k1_midi_interrupt2(struct snd_emu10k1 *emu, unsigned int status) |
101 | { |
102 | do_emu10k1_midi_interrupt(emu, midi: &emu->midi2, status); |
103 | } |
104 | |
105 | static int snd_emu10k1_midi_cmd(struct snd_emu10k1 * emu, struct snd_emu10k1_midi *midi, unsigned char cmd, int ack) |
106 | { |
107 | int timeout, ok; |
108 | |
109 | spin_lock_irq(lock: &midi->input_lock); |
110 | mpu401_write_data(emu, midi, 0x00); |
111 | /* mpu401_clear_rx(emu, midi); */ |
112 | |
113 | mpu401_write_cmd(emu, midi, cmd); |
114 | if (ack) { |
115 | ok = 0; |
116 | timeout = 10000; |
117 | while (!ok && timeout-- > 0) { |
118 | if (mpu401_input_avail(emu, midi)) { |
119 | if (mpu401_read_data(emu, midi) == MPU401_ACK) |
120 | ok = 1; |
121 | } |
122 | } |
123 | if (!ok && mpu401_read_data(emu, midi) == MPU401_ACK) |
124 | ok = 1; |
125 | } else { |
126 | ok = 1; |
127 | } |
128 | spin_unlock_irq(lock: &midi->input_lock); |
129 | if (!ok) { |
130 | dev_err(emu->card->dev, |
131 | "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n" , |
132 | cmd, emu->port, |
133 | mpu401_read_stat(emu, midi), |
134 | mpu401_read_data(emu, midi)); |
135 | return 1; |
136 | } |
137 | return 0; |
138 | } |
139 | |
140 | static int snd_emu10k1_midi_input_open(struct snd_rawmidi_substream *substream) |
141 | { |
142 | struct snd_emu10k1 *emu; |
143 | struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; |
144 | |
145 | emu = midi->emu; |
146 | if (snd_BUG_ON(!emu)) |
147 | return -ENXIO; |
148 | spin_lock_irq(lock: &midi->open_lock); |
149 | midi->midi_mode |= EMU10K1_MIDI_MODE_INPUT; |
150 | midi->substream_input = substream; |
151 | if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) { |
152 | spin_unlock_irq(lock: &midi->open_lock); |
153 | if (snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, ack: 1)) |
154 | goto error_out; |
155 | if (snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, ack: 1)) |
156 | goto error_out; |
157 | } else { |
158 | spin_unlock_irq(lock: &midi->open_lock); |
159 | } |
160 | return 0; |
161 | |
162 | error_out: |
163 | return -EIO; |
164 | } |
165 | |
166 | static int snd_emu10k1_midi_output_open(struct snd_rawmidi_substream *substream) |
167 | { |
168 | struct snd_emu10k1 *emu; |
169 | struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; |
170 | |
171 | emu = midi->emu; |
172 | if (snd_BUG_ON(!emu)) |
173 | return -ENXIO; |
174 | spin_lock_irq(lock: &midi->open_lock); |
175 | midi->midi_mode |= EMU10K1_MIDI_MODE_OUTPUT; |
176 | midi->substream_output = substream; |
177 | if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) { |
178 | spin_unlock_irq(lock: &midi->open_lock); |
179 | if (snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, ack: 1)) |
180 | goto error_out; |
181 | if (snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, ack: 1)) |
182 | goto error_out; |
183 | } else { |
184 | spin_unlock_irq(lock: &midi->open_lock); |
185 | } |
186 | return 0; |
187 | |
188 | error_out: |
189 | return -EIO; |
190 | } |
191 | |
192 | static int snd_emu10k1_midi_input_close(struct snd_rawmidi_substream *substream) |
193 | { |
194 | struct snd_emu10k1 *emu; |
195 | struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; |
196 | int err = 0; |
197 | |
198 | emu = midi->emu; |
199 | if (snd_BUG_ON(!emu)) |
200 | return -ENXIO; |
201 | spin_lock_irq(lock: &midi->open_lock); |
202 | snd_emu10k1_intr_disable(emu, intrenb: midi->rx_enable); |
203 | midi->midi_mode &= ~EMU10K1_MIDI_MODE_INPUT; |
204 | midi->substream_input = NULL; |
205 | if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) { |
206 | spin_unlock_irq(lock: &midi->open_lock); |
207 | err = snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, ack: 0); |
208 | } else { |
209 | spin_unlock_irq(lock: &midi->open_lock); |
210 | } |
211 | return err; |
212 | } |
213 | |
214 | static int snd_emu10k1_midi_output_close(struct snd_rawmidi_substream *substream) |
215 | { |
216 | struct snd_emu10k1 *emu; |
217 | struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; |
218 | int err = 0; |
219 | |
220 | emu = midi->emu; |
221 | if (snd_BUG_ON(!emu)) |
222 | return -ENXIO; |
223 | spin_lock_irq(lock: &midi->open_lock); |
224 | snd_emu10k1_intr_disable(emu, intrenb: midi->tx_enable); |
225 | midi->midi_mode &= ~EMU10K1_MIDI_MODE_OUTPUT; |
226 | midi->substream_output = NULL; |
227 | if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) { |
228 | spin_unlock_irq(lock: &midi->open_lock); |
229 | err = snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, ack: 0); |
230 | } else { |
231 | spin_unlock_irq(lock: &midi->open_lock); |
232 | } |
233 | return err; |
234 | } |
235 | |
236 | static void snd_emu10k1_midi_input_trigger(struct snd_rawmidi_substream *substream, int up) |
237 | { |
238 | struct snd_emu10k1 *emu; |
239 | struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; |
240 | emu = midi->emu; |
241 | if (snd_BUG_ON(!emu)) |
242 | return; |
243 | |
244 | if (up) |
245 | snd_emu10k1_intr_enable(emu, intrenb: midi->rx_enable); |
246 | else |
247 | snd_emu10k1_intr_disable(emu, intrenb: midi->rx_enable); |
248 | } |
249 | |
250 | static void snd_emu10k1_midi_output_trigger(struct snd_rawmidi_substream *substream, int up) |
251 | { |
252 | struct snd_emu10k1 *emu; |
253 | struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data; |
254 | |
255 | emu = midi->emu; |
256 | if (snd_BUG_ON(!emu)) |
257 | return; |
258 | |
259 | if (up) { |
260 | int max = 4; |
261 | unsigned char byte; |
262 | |
263 | /* try to send some amount of bytes here before interrupts */ |
264 | spin_lock_irq(lock: &midi->output_lock); |
265 | while (max > 0) { |
266 | if (mpu401_output_ready(emu, midi)) { |
267 | if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT) || |
268 | snd_rawmidi_transmit(substream, buffer: &byte, count: 1) != 1) { |
269 | /* no more data */ |
270 | spin_unlock_irq(lock: &midi->output_lock); |
271 | return; |
272 | } |
273 | mpu401_write_data(emu, midi, byte); |
274 | max--; |
275 | } else { |
276 | break; |
277 | } |
278 | } |
279 | spin_unlock_irq(lock: &midi->output_lock); |
280 | snd_emu10k1_intr_enable(emu, intrenb: midi->tx_enable); |
281 | } else { |
282 | snd_emu10k1_intr_disable(emu, intrenb: midi->tx_enable); |
283 | } |
284 | } |
285 | |
286 | /* |
287 | |
288 | */ |
289 | |
290 | static const struct snd_rawmidi_ops snd_emu10k1_midi_output = |
291 | { |
292 | .open = snd_emu10k1_midi_output_open, |
293 | .close = snd_emu10k1_midi_output_close, |
294 | .trigger = snd_emu10k1_midi_output_trigger, |
295 | }; |
296 | |
297 | static const struct snd_rawmidi_ops snd_emu10k1_midi_input = |
298 | { |
299 | .open = snd_emu10k1_midi_input_open, |
300 | .close = snd_emu10k1_midi_input_close, |
301 | .trigger = snd_emu10k1_midi_input_trigger, |
302 | }; |
303 | |
304 | static void snd_emu10k1_midi_free(struct snd_rawmidi *rmidi) |
305 | { |
306 | struct snd_emu10k1_midi *midi = rmidi->private_data; |
307 | midi->interrupt = NULL; |
308 | midi->rmidi = NULL; |
309 | } |
310 | |
311 | static int emu10k1_midi_init(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, int device, char *name) |
312 | { |
313 | struct snd_rawmidi *rmidi; |
314 | int err; |
315 | |
316 | err = snd_rawmidi_new(card: emu->card, id: name, device, output_count: 1, input_count: 1, rmidi: &rmidi); |
317 | if (err < 0) |
318 | return err; |
319 | midi->emu = emu; |
320 | spin_lock_init(&midi->open_lock); |
321 | spin_lock_init(&midi->input_lock); |
322 | spin_lock_init(&midi->output_lock); |
323 | strcpy(p: rmidi->name, q: name); |
324 | snd_rawmidi_set_ops(rmidi, stream: SNDRV_RAWMIDI_STREAM_OUTPUT, ops: &snd_emu10k1_midi_output); |
325 | snd_rawmidi_set_ops(rmidi, stream: SNDRV_RAWMIDI_STREAM_INPUT, ops: &snd_emu10k1_midi_input); |
326 | rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | |
327 | SNDRV_RAWMIDI_INFO_INPUT | |
328 | SNDRV_RAWMIDI_INFO_DUPLEX; |
329 | rmidi->private_data = midi; |
330 | rmidi->private_free = snd_emu10k1_midi_free; |
331 | midi->rmidi = rmidi; |
332 | return 0; |
333 | } |
334 | |
335 | int snd_emu10k1_midi(struct snd_emu10k1 *emu) |
336 | { |
337 | struct snd_emu10k1_midi *midi = &emu->midi; |
338 | int err; |
339 | |
340 | err = emu10k1_midi_init(emu, midi, device: 0, name: "EMU10K1 MPU-401 (UART)" ); |
341 | if (err < 0) |
342 | return err; |
343 | |
344 | midi->tx_enable = INTE_MIDITXENABLE; |
345 | midi->rx_enable = INTE_MIDIRXENABLE; |
346 | midi->port = MUDATA; |
347 | midi->ipr_tx = IPR_MIDITRANSBUFEMPTY; |
348 | midi->ipr_rx = IPR_MIDIRECVBUFEMPTY; |
349 | midi->interrupt = snd_emu10k1_midi_interrupt; |
350 | return 0; |
351 | } |
352 | |
353 | int snd_emu10k1_audigy_midi(struct snd_emu10k1 *emu) |
354 | { |
355 | struct snd_emu10k1_midi *midi; |
356 | int err; |
357 | |
358 | midi = &emu->midi; |
359 | err = emu10k1_midi_init(emu, midi, device: 0, name: "Audigy MPU-401 (UART)" ); |
360 | if (err < 0) |
361 | return err; |
362 | |
363 | midi->tx_enable = INTE_MIDITXENABLE; |
364 | midi->rx_enable = INTE_MIDIRXENABLE; |
365 | midi->port = A_MUDATA1; |
366 | midi->ipr_tx = IPR_MIDITRANSBUFEMPTY; |
367 | midi->ipr_rx = IPR_MIDIRECVBUFEMPTY; |
368 | midi->interrupt = snd_emu10k1_midi_interrupt; |
369 | |
370 | midi = &emu->midi2; |
371 | err = emu10k1_midi_init(emu, midi, device: 1, name: "Audigy MPU-401 #2" ); |
372 | if (err < 0) |
373 | return err; |
374 | |
375 | midi->tx_enable = INTE_A_MIDITXENABLE2; |
376 | midi->rx_enable = INTE_A_MIDIRXENABLE2; |
377 | midi->port = A_MUDATA2; |
378 | midi->ipr_tx = IPR_A_MIDITRANSBUFEMPTY2; |
379 | midi->ipr_rx = IPR_A_MIDIRECVBUFEMPTY2; |
380 | midi->interrupt = snd_emu10k1_midi_interrupt2; |
381 | return 0; |
382 | } |
383 | |