1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) by Paul Barton-Davis 1998-1999
4  */
5 
6 /* The low level driver for the WaveFront ICS2115 MIDI interface(s)
7  *
8  * Note that there is also an MPU-401 emulation (actually, a UART-401
9  * emulation) on the CS4232 on the Tropez and Tropez Plus. This code
10  * has nothing to do with that interface at all.
11  *
12  * The interface is essentially just a UART-401, but is has the
13  * interesting property of supporting what Turtle Beach called
14  * "Virtual MIDI" mode. In this mode, there are effectively *two*
15  * MIDI buses accessible via the interface, one that is routed
16  * solely to/from the external WaveFront synthesizer and the other
17  * corresponding to the pin/socket connector used to link external
18  * MIDI devices to the board.
19  *
20  * This driver fully supports this mode, allowing two distinct MIDI
21  * busses to be used completely independently, giving 32 channels of
22  * MIDI routing, 16 to the WaveFront synth and 16 to the external MIDI
23  * bus. The devices are named /dev/snd/midiCnD0 and /dev/snd/midiCnD1,
24  * where `n' is the card number. Note that the device numbers may be
25  * something other than 0 and 1 if the CS4232 UART/MPU-401 interface
26  * is enabled.
27  *
28  * Switching between the two is accomplished externally by the driver
29  * using the two otherwise unused MIDI bytes. See the code for more details.
30  *
31  * NOTE: VIRTUAL MIDI MODE IS ON BY DEFAULT (see lowlevel/isa/wavefront.c)
32  *
33  * The main reason to turn off Virtual MIDI mode is when you want to
34  * tightly couple the WaveFront synth with an external MIDI
35  * device. You won't be able to distinguish the source of any MIDI
36  * data except via SysEx ID, but thats probably OK, since for the most
37  * part, the WaveFront won't be sending any MIDI data at all.
38  *
39  * The main reason to turn on Virtual MIDI Mode is to provide two
40  * completely independent 16-channel MIDI buses, one to the
41  * WaveFront and one to any external MIDI devices. Given the 32
42  * voice nature of the WaveFront, its pretty easy to find a use
43  * for all 16 channels driving just that synth.
44  *
45  */
46 
47 #include <linux/io.h>
48 #include <linux/init.h>
49 #include <linux/time.h>
50 #include <linux/wait.h>
51 #include <sound/core.h>
52 #include <sound/snd_wavefront.h>
53 
54 static inline int
55 wf_mpu_status (snd_wavefront_midi_t *midi)
56 
57 {
58 	return inb (midi->mpu_status_port);
59 }
60 
61 static inline int
62 input_avail (snd_wavefront_midi_t *midi)
63 
64 {
65 	return !(wf_mpu_status(midi) & INPUT_AVAIL);
66 }
67 
68 static inline int
69 output_ready (snd_wavefront_midi_t *midi)
70 
71 {
72 	return !(wf_mpu_status(midi) & OUTPUT_READY);
73 }
74 
75 static inline int
76 read_data (snd_wavefront_midi_t *midi)
77 
78 {
79 	return inb (midi->mpu_data_port);
80 }
81 
82 static inline void
83 write_data (snd_wavefront_midi_t *midi, unsigned char byte)
84 
85 {
86 	outb (byte, midi->mpu_data_port);
87 }
88 
89 static snd_wavefront_midi_t *
90 get_wavefront_midi (struct snd_rawmidi_substream *substream)
91 
92 {
93 	struct snd_card *card;
94 	snd_wavefront_card_t *acard;
95 
96 	if (substream == NULL || substream->rmidi == NULL)
97 	        return NULL;
98 
99 	card = substream->rmidi->card;
100 
101 	if (card == NULL)
102 	        return NULL;
103 
104 	if (card->private_data == NULL)
105  	        return NULL;
106 
107 	acard = card->private_data;
108 
109 	return &acard->wavefront.midi;
110 }
111 
112 static void snd_wavefront_midi_output_write(snd_wavefront_card_t *card)
113 {
114 	snd_wavefront_midi_t *midi = &card->wavefront.midi;
115 	snd_wavefront_mpu_id  mpu;
116 	unsigned long flags;
117 	unsigned char midi_byte;
118 	int max = 256, mask = 1;
119 	int timeout;
120 
121 	/* Its not OK to try to change the status of "virtuality" of
122 	   the MIDI interface while we're outputting stuff.  See
123 	   snd_wavefront_midi_{enable,disable}_virtual () for the
124 	   other half of this.
125 
126 	   The first loop attempts to flush any data from the
127 	   current output device, and then the second
128 	   emits the switch byte (if necessary), and starts
129 	   outputting data for the output device currently in use.
130 	*/
131 
132 	if (midi->substream_output[midi->output_mpu] == NULL) {
133 		goto __second;
134 	}
135 
136 	while (max > 0) {
137 
138 		/* XXX fix me - no hard timing loops allowed! */
139 
140 		for (timeout = 30000; timeout > 0; timeout--) {
141 			if (output_ready (midi))
142 				break;
143 		}
144 
145 		spin_lock_irqsave (&midi->virtual, flags);
146 		if ((midi->mode[midi->output_mpu] & MPU401_MODE_OUTPUT) == 0) {
147 			spin_unlock_irqrestore (&midi->virtual, flags);
148 			goto __second;
149 		}
150 		if (output_ready (midi)) {
151 			if (snd_rawmidi_transmit(midi->substream_output[midi->output_mpu], &midi_byte, 1) == 1) {
152 				if (!midi->isvirtual ||
153 					(midi_byte != WF_INTERNAL_SWITCH &&
154 					 midi_byte != WF_EXTERNAL_SWITCH))
155 					write_data(midi, midi_byte);
156 				max--;
157 			} else {
158 				if (midi->istimer) {
159 					if (--midi->istimer <= 0)
160 						del_timer(&midi->timer);
161 				}
162 				midi->mode[midi->output_mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
163 				spin_unlock_irqrestore (&midi->virtual, flags);
164 				goto __second;
165 			}
166 		} else {
167 			spin_unlock_irqrestore (&midi->virtual, flags);
168 			return;
169 		}
170 		spin_unlock_irqrestore (&midi->virtual, flags);
171 	}
172 
173       __second:
174 
175 	if (midi->substream_output[!midi->output_mpu] == NULL) {
176 		return;
177 	}
178 
179 	while (max > 0) {
180 
181 		/* XXX fix me - no hard timing loops allowed! */
182 
183 		for (timeout = 30000; timeout > 0; timeout--) {
184 			if (output_ready (midi))
185 				break;
186 		}
187 
188 		spin_lock_irqsave (&midi->virtual, flags);
189 		if (!midi->isvirtual)
190 			mask = 0;
191 		mpu = midi->output_mpu ^ mask;
192 		mask = 0;	/* don't invert the value from now */
193 		if ((midi->mode[mpu] & MPU401_MODE_OUTPUT) == 0) {
194 			spin_unlock_irqrestore (&midi->virtual, flags);
195 			return;
196 		}
197 		if (snd_rawmidi_transmit_empty(midi->substream_output[mpu]))
198 			goto __timer;
199 		if (output_ready (midi)) {
200 			if (mpu != midi->output_mpu) {
201 				write_data(midi, mpu == internal_mpu ?
202 							WF_INTERNAL_SWITCH :
203 							WF_EXTERNAL_SWITCH);
204 				midi->output_mpu = mpu;
205 			} else if (snd_rawmidi_transmit(midi->substream_output[mpu], &midi_byte, 1) == 1) {
206 				if (!midi->isvirtual ||
207 					(midi_byte != WF_INTERNAL_SWITCH &&
208 					 midi_byte != WF_EXTERNAL_SWITCH))
209 					write_data(midi, midi_byte);
210 				max--;
211 			} else {
212 			      __timer:
213 				if (midi->istimer) {
214 					if (--midi->istimer <= 0)
215 						del_timer(&midi->timer);
216 				}
217 				midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
218 				spin_unlock_irqrestore (&midi->virtual, flags);
219 				return;
220 			}
221 		} else {
222 			spin_unlock_irqrestore (&midi->virtual, flags);
223 			return;
224 		}
225 		spin_unlock_irqrestore (&midi->virtual, flags);
226 	}
227 }
228 
229 static int snd_wavefront_midi_input_open(struct snd_rawmidi_substream *substream)
230 {
231 	unsigned long flags;
232 	snd_wavefront_midi_t *midi;
233 	snd_wavefront_mpu_id mpu;
234 
235 	if (snd_BUG_ON(!substream || !substream->rmidi))
236 		return -ENXIO;
237 	if (snd_BUG_ON(!substream->rmidi->private_data))
238 		return -ENXIO;
239 
240 	mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
241 
242 	if ((midi = get_wavefront_midi (substream)) == NULL)
243 	        return -EIO;
244 
245 	spin_lock_irqsave (&midi->open, flags);
246 	midi->mode[mpu] |= MPU401_MODE_INPUT;
247 	midi->substream_input[mpu] = substream;
248 	spin_unlock_irqrestore (&midi->open, flags);
249 
250 	return 0;
251 }
252 
253 static int snd_wavefront_midi_output_open(struct snd_rawmidi_substream *substream)
254 {
255 	unsigned long flags;
256 	snd_wavefront_midi_t *midi;
257 	snd_wavefront_mpu_id mpu;
258 
259 	if (snd_BUG_ON(!substream || !substream->rmidi))
260 		return -ENXIO;
261 	if (snd_BUG_ON(!substream->rmidi->private_data))
262 		return -ENXIO;
263 
264 	mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
265 
266 	if ((midi = get_wavefront_midi (substream)) == NULL)
267 	        return -EIO;
268 
269 	spin_lock_irqsave (&midi->open, flags);
270 	midi->mode[mpu] |= MPU401_MODE_OUTPUT;
271 	midi->substream_output[mpu] = substream;
272 	spin_unlock_irqrestore (&midi->open, flags);
273 
274 	return 0;
275 }
276 
277 static int snd_wavefront_midi_input_close(struct snd_rawmidi_substream *substream)
278 {
279 	unsigned long flags;
280 	snd_wavefront_midi_t *midi;
281 	snd_wavefront_mpu_id mpu;
282 
283 	if (snd_BUG_ON(!substream || !substream->rmidi))
284 		return -ENXIO;
285 	if (snd_BUG_ON(!substream->rmidi->private_data))
286 		return -ENXIO;
287 
288 	mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
289 
290 	if ((midi = get_wavefront_midi (substream)) == NULL)
291 	        return -EIO;
292 
293 	spin_lock_irqsave (&midi->open, flags);
294 	midi->mode[mpu] &= ~MPU401_MODE_INPUT;
295 	spin_unlock_irqrestore (&midi->open, flags);
296 
297 	return 0;
298 }
299 
300 static int snd_wavefront_midi_output_close(struct snd_rawmidi_substream *substream)
301 {
302 	unsigned long flags;
303 	snd_wavefront_midi_t *midi;
304 	snd_wavefront_mpu_id mpu;
305 
306 	if (snd_BUG_ON(!substream || !substream->rmidi))
307 		return -ENXIO;
308 	if (snd_BUG_ON(!substream->rmidi->private_data))
309 		return -ENXIO;
310 
311 	mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
312 
313 	if ((midi = get_wavefront_midi (substream)) == NULL)
314 	        return -EIO;
315 
316 	spin_lock_irqsave (&midi->open, flags);
317 	midi->mode[mpu] &= ~MPU401_MODE_OUTPUT;
318 	spin_unlock_irqrestore (&midi->open, flags);
319 	return 0;
320 }
321 
322 static void snd_wavefront_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
323 {
324 	unsigned long flags;
325 	snd_wavefront_midi_t *midi;
326 	snd_wavefront_mpu_id mpu;
327 
328 	if (substream == NULL || substream->rmidi == NULL)
329 	        return;
330 
331 	if (substream->rmidi->private_data == NULL)
332 	        return;
333 
334 	mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
335 
336 	if ((midi = get_wavefront_midi (substream)) == NULL) {
337 		return;
338 	}
339 
340 	spin_lock_irqsave (&midi->virtual, flags);
341 	if (up) {
342 		midi->mode[mpu] |= MPU401_MODE_INPUT_TRIGGER;
343 	} else {
344 		midi->mode[mpu] &= ~MPU401_MODE_INPUT_TRIGGER;
345 	}
346 	spin_unlock_irqrestore (&midi->virtual, flags);
347 }
348 
349 static void snd_wavefront_midi_output_timer(struct timer_list *t)
350 {
351 	snd_wavefront_midi_t *midi = from_timer(midi, t, timer);
352 	snd_wavefront_card_t *card = midi->timer_card;
353 	unsigned long flags;
354 
355 	spin_lock_irqsave (&midi->virtual, flags);
356 	mod_timer(&midi->timer, 1 + jiffies);
357 	spin_unlock_irqrestore (&midi->virtual, flags);
358 	snd_wavefront_midi_output_write(card);
359 }
360 
361 static void snd_wavefront_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
362 {
363 	unsigned long flags;
364 	snd_wavefront_midi_t *midi;
365 	snd_wavefront_mpu_id mpu;
366 
367 	if (substream == NULL || substream->rmidi == NULL)
368 	        return;
369 
370 	if (substream->rmidi->private_data == NULL)
371 	        return;
372 
373 	mpu = *((snd_wavefront_mpu_id *) substream->rmidi->private_data);
374 
375 	if ((midi = get_wavefront_midi (substream)) == NULL) {
376 		return;
377 	}
378 
379 	spin_lock_irqsave (&midi->virtual, flags);
380 	if (up) {
381 		if ((midi->mode[mpu] & MPU401_MODE_OUTPUT_TRIGGER) == 0) {
382 			if (!midi->istimer) {
383 				timer_setup(&midi->timer,
384 					    snd_wavefront_midi_output_timer,
385 					    0);
386 				mod_timer(&midi->timer, 1 + jiffies);
387 			}
388 			midi->istimer++;
389 			midi->mode[mpu] |= MPU401_MODE_OUTPUT_TRIGGER;
390 		}
391 	} else {
392 		midi->mode[mpu] &= ~MPU401_MODE_OUTPUT_TRIGGER;
393 	}
394 	spin_unlock_irqrestore (&midi->virtual, flags);
395 
396 	if (up)
397 		snd_wavefront_midi_output_write((snd_wavefront_card_t *)substream->rmidi->card->private_data);
398 }
399 
400 void
401 snd_wavefront_midi_interrupt (snd_wavefront_card_t *card)
402 
403 {
404 	unsigned long flags;
405 	snd_wavefront_midi_t *midi;
406 	static struct snd_rawmidi_substream *substream = NULL;
407 	static int mpu = external_mpu;
408 	int max = 128;
409 	unsigned char byte;
410 
411 	midi = &card->wavefront.midi;
412 
413 	if (!input_avail (midi)) { /* not for us */
414 		snd_wavefront_midi_output_write(card);
415 		return;
416 	}
417 
418 	spin_lock_irqsave (&midi->virtual, flags);
419 	while (--max) {
420 
421 		if (input_avail (midi)) {
422 			byte = read_data (midi);
423 
424 			if (midi->isvirtual) {
425 				if (byte == WF_EXTERNAL_SWITCH) {
426 					substream = midi->substream_input[external_mpu];
427 					mpu = external_mpu;
428 				} else if (byte == WF_INTERNAL_SWITCH) {
429 					substream = midi->substream_output[internal_mpu];
430 					mpu = internal_mpu;
431 				} /* else just leave it as it is */
432 			} else {
433 				substream = midi->substream_input[internal_mpu];
434 				mpu = internal_mpu;
435 			}
436 
437 			if (substream == NULL) {
438 				continue;
439 			}
440 
441 			if (midi->mode[mpu] & MPU401_MODE_INPUT_TRIGGER) {
442 				snd_rawmidi_receive(substream, &byte, 1);
443 			}
444 		} else {
445 			break;
446 		}
447 	}
448 	spin_unlock_irqrestore (&midi->virtual, flags);
449 
450 	snd_wavefront_midi_output_write(card);
451 }
452 
453 void
454 snd_wavefront_midi_enable_virtual (snd_wavefront_card_t *card)
455 
456 {
457 	unsigned long flags;
458 
459 	spin_lock_irqsave (&card->wavefront.midi.virtual, flags);
460 	card->wavefront.midi.isvirtual = 1;
461 	card->wavefront.midi.output_mpu = internal_mpu;
462 	card->wavefront.midi.input_mpu = internal_mpu;
463 	spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags);
464 }
465 
466 void
467 snd_wavefront_midi_disable_virtual (snd_wavefront_card_t *card)
468 
469 {
470 	unsigned long flags;
471 
472 	spin_lock_irqsave (&card->wavefront.midi.virtual, flags);
473 	// snd_wavefront_midi_input_close (card->ics2115_external_rmidi);
474 	// snd_wavefront_midi_output_close (card->ics2115_external_rmidi);
475 	card->wavefront.midi.isvirtual = 0;
476 	spin_unlock_irqrestore (&card->wavefront.midi.virtual, flags);
477 }
478 
479 int
480 snd_wavefront_midi_start (snd_wavefront_card_t *card)
481 
482 {
483 	int ok, i;
484 	unsigned char rbuf[4], wbuf[4];
485 	snd_wavefront_t *dev;
486 	snd_wavefront_midi_t *midi;
487 
488 	dev = &card->wavefront;
489 	midi = &dev->midi;
490 
491 	/* The ICS2115 MPU-401 interface doesn't do anything
492 	   until its set into UART mode.
493 	*/
494 
495 	/* XXX fix me - no hard timing loops allowed! */
496 
497 	for (i = 0; i < 30000 && !output_ready (midi); i++);
498 
499 	if (!output_ready (midi)) {
500 		snd_printk ("MIDI interface not ready for command\n");
501 		return -1;
502 	}
503 
504 	/* Any interrupts received from now on
505 	   are owned by the MIDI side of things.
506 	*/
507 
508 	dev->interrupts_are_midi = 1;
509 
510 	outb (UART_MODE_ON, midi->mpu_command_port);
511 
512 	for (ok = 0, i = 50000; i > 0 && !ok; i--) {
513 		if (input_avail (midi)) {
514 			if (read_data (midi) == MPU_ACK) {
515 				ok = 1;
516 				break;
517 			}
518 		}
519 	}
520 
521 	if (!ok) {
522 		snd_printk ("cannot set UART mode for MIDI interface");
523 		dev->interrupts_are_midi = 0;
524 		return -1;
525 	}
526 
527 	/* Route external MIDI to WaveFront synth (by default) */
528 
529 	if (snd_wavefront_cmd (dev, WFC_MISYNTH_ON, rbuf, wbuf)) {
530 		snd_printk ("can't enable MIDI-IN-2-synth routing.\n");
531 		/* XXX error ? */
532 	}
533 
534 	/* Turn on Virtual MIDI, but first *always* turn it off,
535 	   since otherwise consecutive reloads of the driver will
536 	   never cause the hardware to generate the initial "internal" or
537 	   "external" source bytes in the MIDI data stream. This
538 	   is pretty important, since the internal hardware generally will
539 	   be used to generate none or very little MIDI output, and
540 	   thus the only source of MIDI data is actually external. Without
541 	   the switch bytes, the driver will think it all comes from
542 	   the internal interface. Duh.
543 	*/
544 
545 	if (snd_wavefront_cmd (dev, WFC_VMIDI_OFF, rbuf, wbuf)) {
546 		snd_printk ("virtual MIDI mode not disabled\n");
547 		return 0; /* We're OK, but missing the external MIDI dev */
548 	}
549 
550 	snd_wavefront_midi_enable_virtual (card);
551 
552 	if (snd_wavefront_cmd (dev, WFC_VMIDI_ON, rbuf, wbuf)) {
553 		snd_printk ("cannot enable virtual MIDI mode.\n");
554 		snd_wavefront_midi_disable_virtual (card);
555 	}
556 	return 0;
557 }
558 
559 const struct snd_rawmidi_ops snd_wavefront_midi_output =
560 {
561 	.open =		snd_wavefront_midi_output_open,
562 	.close =	snd_wavefront_midi_output_close,
563 	.trigger =	snd_wavefront_midi_output_trigger,
564 };
565 
566 const struct snd_rawmidi_ops snd_wavefront_midi_input =
567 {
568 	.open =		snd_wavefront_midi_input_open,
569 	.close =	snd_wavefront_midi_input_close,
570 	.trigger =	snd_wavefront_midi_input_trigger,
571 };
572 
573