1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4  *  Routines for control of MPU-401 in UART mode
5  *
6  *  MPU-401 supports UART mode which is not capable generate transmit
7  *  interrupts thus output is done via polling. Without interrupt,
8  *  input is done also via polling. Do not expect good performance.
9  *
10  *   13-03-2003:
11  *      Added support for different kind of hardware I/O. Build in choices
12  *      are port and mmio. For other kind of I/O, set mpu->read and
13  *      mpu->write to your own I/O functions.
14  */
15 
16 #include <linux/io.h>
17 #include <linux/delay.h>
18 #include <linux/init.h>
19 #include <linux/slab.h>
20 #include <linux/ioport.h>
21 #include <linux/module.h>
22 #include <linux/interrupt.h>
23 #include <linux/errno.h>
24 #include <sound/core.h>
25 #include <sound/mpu401.h>
26 
27 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
28 MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode");
29 MODULE_LICENSE("GPL");
30 
31 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu);
32 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu);
33 
34 /*
35 
36  */
37 
38 #define snd_mpu401_input_avail(mpu) \
39 	(!(mpu->read(mpu, MPU401C(mpu)) & MPU401_RX_EMPTY))
40 #define snd_mpu401_output_ready(mpu) \
41 	(!(mpu->read(mpu, MPU401C(mpu)) & MPU401_TX_FULL))
42 
43 /* Build in lowlevel io */
44 static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data,
45 			      unsigned long addr)
46 {
47 	outb(data, addr);
48 }
49 
50 static unsigned char mpu401_read_port(struct snd_mpu401 *mpu,
51 				      unsigned long addr)
52 {
53 	return inb(addr);
54 }
55 
56 static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data,
57 			      unsigned long addr)
58 {
59 	writeb(data, (void __iomem *)addr);
60 }
61 
62 static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu,
63 				      unsigned long addr)
64 {
65 	return readb((void __iomem *)addr);
66 }
67 /*  */
68 
69 static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
70 {
71 	int timeout = 100000;
72 	for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
73 		mpu->read(mpu, MPU401D(mpu));
74 #ifdef CONFIG_SND_DEBUG
75 	if (timeout <= 0)
76 		snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n",
77 			   mpu->read(mpu, MPU401C(mpu)));
78 #endif
79 }
80 
81 static void uart_interrupt_tx(struct snd_mpu401 *mpu)
82 {
83 	unsigned long flags;
84 
85 	if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
86 	    test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
87 		spin_lock_irqsave(&mpu->output_lock, flags);
88 		snd_mpu401_uart_output_write(mpu);
89 		spin_unlock_irqrestore(&mpu->output_lock, flags);
90 	}
91 }
92 
93 static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
94 {
95 	unsigned long flags;
96 
97 	if (mpu->info_flags & MPU401_INFO_INPUT) {
98 		spin_lock_irqsave(&mpu->input_lock, flags);
99 		if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
100 			snd_mpu401_uart_input_read(mpu);
101 		else
102 			snd_mpu401_uart_clear_rx(mpu);
103 		spin_unlock_irqrestore(&mpu->input_lock, flags);
104 	}
105 	if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
106 		/* ok. for better Tx performance try do some output
107 		   when input is done */
108 		uart_interrupt_tx(mpu);
109 }
110 
111 /**
112  * snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler
113  * @irq: the irq number
114  * @dev_id: mpu401 instance
115  *
116  * Processes the interrupt for MPU401-UART i/o.
117  *
118  * Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
119  */
120 irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id)
121 {
122 	struct snd_mpu401 *mpu = dev_id;
123 
124 	if (!mpu)
125 		return IRQ_NONE;
126 	_snd_mpu401_uart_interrupt(mpu);
127 	return IRQ_HANDLED;
128 }
129 
130 EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
131 
132 /**
133  * snd_mpu401_uart_interrupt_tx - generic MPU401-UART transmit irq handler
134  * @irq: the irq number
135  * @dev_id: mpu401 instance
136  *
137  * Processes the interrupt for MPU401-UART output.
138  *
139  * Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
140  */
141 irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id)
142 {
143 	struct snd_mpu401 *mpu = dev_id;
144 
145 	if (!mpu)
146 		return IRQ_NONE;
147 	uart_interrupt_tx(mpu);
148 	return IRQ_HANDLED;
149 }
150 
151 EXPORT_SYMBOL(snd_mpu401_uart_interrupt_tx);
152 
153 /*
154  * timer callback
155  * reprogram the timer and call the interrupt job
156  */
157 static void snd_mpu401_uart_timer(struct timer_list *t)
158 {
159 	struct snd_mpu401 *mpu = from_timer(mpu, t, timer);
160 	unsigned long flags;
161 
162 	spin_lock_irqsave(&mpu->timer_lock, flags);
163 	/*mpu->mode |= MPU401_MODE_TIMER;*/
164 	mod_timer(&mpu->timer,  1 + jiffies);
165 	spin_unlock_irqrestore(&mpu->timer_lock, flags);
166 	if (mpu->rmidi)
167 		_snd_mpu401_uart_interrupt(mpu);
168 }
169 
170 /*
171  * initialize the timer callback if not programmed yet
172  */
173 static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
174 {
175 	unsigned long flags;
176 
177 	spin_lock_irqsave (&mpu->timer_lock, flags);
178 	if (mpu->timer_invoked == 0) {
179 		timer_setup(&mpu->timer, snd_mpu401_uart_timer, 0);
180 		mod_timer(&mpu->timer, 1 + jiffies);
181 	}
182 	mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER :
183 		MPU401_MODE_OUTPUT_TIMER;
184 	spin_unlock_irqrestore (&mpu->timer_lock, flags);
185 }
186 
187 /*
188  * remove the timer callback if still active
189  */
190 static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
191 {
192 	unsigned long flags;
193 
194 	spin_lock_irqsave (&mpu->timer_lock, flags);
195 	if (mpu->timer_invoked) {
196 		mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER :
197 			~MPU401_MODE_OUTPUT_TIMER;
198 		if (! mpu->timer_invoked)
199 			del_timer(&mpu->timer);
200 	}
201 	spin_unlock_irqrestore (&mpu->timer_lock, flags);
202 }
203 
204 /*
205  * send a UART command
206  * return zero if successful, non-zero for some errors
207  */
208 
209 static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
210 			       int ack)
211 {
212 	unsigned long flags;
213 	int timeout, ok;
214 
215 	spin_lock_irqsave(&mpu->input_lock, flags);
216 	if (mpu->hardware != MPU401_HW_TRID4DWAVE) {
217 		mpu->write(mpu, 0x00, MPU401D(mpu));
218 		/*snd_mpu401_uart_clear_rx(mpu);*/
219 	}
220 	/* ok. standard MPU-401 initialization */
221 	if (mpu->hardware != MPU401_HW_SB) {
222 		for (timeout = 1000; timeout > 0 &&
223 			     !snd_mpu401_output_ready(mpu); timeout--)
224 			udelay(10);
225 #ifdef CONFIG_SND_DEBUG
226 		if (!timeout)
227 			snd_printk(KERN_ERR "cmd: tx timeout (status = 0x%x)\n",
228 				   mpu->read(mpu, MPU401C(mpu)));
229 #endif
230 	}
231 	mpu->write(mpu, cmd, MPU401C(mpu));
232 	if (ack && !(mpu->info_flags & MPU401_INFO_NO_ACK)) {
233 		ok = 0;
234 		timeout = 10000;
235 		while (!ok && timeout-- > 0) {
236 			if (snd_mpu401_input_avail(mpu)) {
237 				if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
238 					ok = 1;
239 			}
240 		}
241 		if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
242 			ok = 1;
243 	} else
244 		ok = 1;
245 	spin_unlock_irqrestore(&mpu->input_lock, flags);
246 	if (!ok) {
247 		snd_printk(KERN_ERR "cmd: 0x%x failed at 0x%lx "
248 			   "(status = 0x%x, data = 0x%x)\n", cmd, mpu->port,
249 			   mpu->read(mpu, MPU401C(mpu)),
250 			   mpu->read(mpu, MPU401D(mpu)));
251 		return 1;
252 	}
253 	return 0;
254 }
255 
256 static int snd_mpu401_do_reset(struct snd_mpu401 *mpu)
257 {
258 	if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
259 		return -EIO;
260 	if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0))
261 		return -EIO;
262 	return 0;
263 }
264 
265 /*
266  * input/output open/close - protected by open_mutex in rawmidi.c
267  */
268 static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
269 {
270 	struct snd_mpu401 *mpu;
271 	int err;
272 
273 	mpu = substream->rmidi->private_data;
274 	if (mpu->open_input) {
275 		err = mpu->open_input(mpu);
276 		if (err < 0)
277 			return err;
278 	}
279 	if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
280 		if (snd_mpu401_do_reset(mpu) < 0)
281 			goto error_out;
282 	}
283 	mpu->substream_input = substream;
284 	set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
285 	return 0;
286 
287 error_out:
288 	if (mpu->open_input && mpu->close_input)
289 		mpu->close_input(mpu);
290 	return -EIO;
291 }
292 
293 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
294 {
295 	struct snd_mpu401 *mpu;
296 	int err;
297 
298 	mpu = substream->rmidi->private_data;
299 	if (mpu->open_output) {
300 		err = mpu->open_output(mpu);
301 		if (err < 0)
302 			return err;
303 	}
304 	if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
305 		if (snd_mpu401_do_reset(mpu) < 0)
306 			goto error_out;
307 	}
308 	mpu->substream_output = substream;
309 	set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
310 	return 0;
311 
312 error_out:
313 	if (mpu->open_output && mpu->close_output)
314 		mpu->close_output(mpu);
315 	return -EIO;
316 }
317 
318 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
319 {
320 	struct snd_mpu401 *mpu;
321 	int err = 0;
322 
323 	mpu = substream->rmidi->private_data;
324 	clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
325 	mpu->substream_input = NULL;
326 	if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode))
327 		err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
328 	if (mpu->close_input)
329 		mpu->close_input(mpu);
330 	if (err)
331 		return -EIO;
332 	return 0;
333 }
334 
335 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
336 {
337 	struct snd_mpu401 *mpu;
338 	int err = 0;
339 
340 	mpu = substream->rmidi->private_data;
341 	clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
342 	mpu->substream_output = NULL;
343 	if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
344 		err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
345 	if (mpu->close_output)
346 		mpu->close_output(mpu);
347 	if (err)
348 		return -EIO;
349 	return 0;
350 }
351 
352 /*
353  * trigger input callback
354  */
355 static void
356 snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
357 {
358 	unsigned long flags;
359 	struct snd_mpu401 *mpu;
360 	int max = 64;
361 
362 	mpu = substream->rmidi->private_data;
363 	if (up) {
364 		if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER,
365 				       &mpu->mode)) {
366 			/* first time - flush FIFO */
367 			while (max-- > 0)
368 				mpu->read(mpu, MPU401D(mpu));
369 			if (mpu->info_flags & MPU401_INFO_USE_TIMER)
370 				snd_mpu401_uart_add_timer(mpu, 1);
371 		}
372 
373 		/* read data in advance */
374 		spin_lock_irqsave(&mpu->input_lock, flags);
375 		snd_mpu401_uart_input_read(mpu);
376 		spin_unlock_irqrestore(&mpu->input_lock, flags);
377 	} else {
378 		if (mpu->info_flags & MPU401_INFO_USE_TIMER)
379 			snd_mpu401_uart_remove_timer(mpu, 1);
380 		clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
381 	}
382 
383 }
384 
385 /*
386  * transfer input pending data
387  * call with input_lock spinlock held
388  */
389 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
390 {
391 	int max = 128;
392 	unsigned char byte;
393 
394 	while (max-- > 0) {
395 		if (! snd_mpu401_input_avail(mpu))
396 			break; /* input not available */
397 		byte = mpu->read(mpu, MPU401D(mpu));
398 		if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
399 			snd_rawmidi_receive(mpu->substream_input, &byte, 1);
400 	}
401 }
402 
403 /*
404  *  Tx FIFO sizes:
405  *    CS4237B			- 16 bytes
406  *    AudioDrive ES1688         - 12 bytes
407  *    S3 SonicVibes             -  8 bytes
408  *    SoundBlaster AWE 64       -  2 bytes (ugly hardware)
409  */
410 
411 /*
412  * write output pending bytes
413  * call with output_lock spinlock held
414  */
415 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
416 {
417 	unsigned char byte;
418 	int max = 256;
419 
420 	do {
421 		if (snd_rawmidi_transmit_peek(mpu->substream_output,
422 					      &byte, 1) == 1) {
423 			/*
424 			 * Try twice because there is hardware that insists on
425 			 * setting the output busy bit after each write.
426 			 */
427 			if (!snd_mpu401_output_ready(mpu) &&
428 			    !snd_mpu401_output_ready(mpu))
429 				break;	/* Tx FIFO full - try again later */
430 			mpu->write(mpu, byte, MPU401D(mpu));
431 			snd_rawmidi_transmit_ack(mpu->substream_output, 1);
432 		} else {
433 			snd_mpu401_uart_remove_timer (mpu, 0);
434 			break;	/* no other data - leave the tx loop */
435 		}
436 	} while (--max > 0);
437 }
438 
439 /*
440  * output trigger callback
441  */
442 static void
443 snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
444 {
445 	unsigned long flags;
446 	struct snd_mpu401 *mpu;
447 
448 	mpu = substream->rmidi->private_data;
449 	if (up) {
450 		set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
451 
452 		/* try to add the timer at each output trigger,
453 		 * since the output timer might have been removed in
454 		 * snd_mpu401_uart_output_write().
455 		 */
456 		if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
457 			snd_mpu401_uart_add_timer(mpu, 0);
458 
459 		/* output pending data */
460 		spin_lock_irqsave(&mpu->output_lock, flags);
461 		snd_mpu401_uart_output_write(mpu);
462 		spin_unlock_irqrestore(&mpu->output_lock, flags);
463 	} else {
464 		if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
465 			snd_mpu401_uart_remove_timer(mpu, 0);
466 		clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
467 	}
468 }
469 
470 /*
471 
472  */
473 
474 static const struct snd_rawmidi_ops snd_mpu401_uart_output =
475 {
476 	.open =		snd_mpu401_uart_output_open,
477 	.close =	snd_mpu401_uart_output_close,
478 	.trigger =	snd_mpu401_uart_output_trigger,
479 };
480 
481 static const struct snd_rawmidi_ops snd_mpu401_uart_input =
482 {
483 	.open =		snd_mpu401_uart_input_open,
484 	.close =	snd_mpu401_uart_input_close,
485 	.trigger =	snd_mpu401_uart_input_trigger,
486 };
487 
488 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
489 {
490 	struct snd_mpu401 *mpu = rmidi->private_data;
491 	if (mpu->irq >= 0)
492 		free_irq(mpu->irq, (void *) mpu);
493 	release_and_free_resource(mpu->res);
494 	kfree(mpu);
495 }
496 
497 /**
498  * snd_mpu401_uart_new - create an MPU401-UART instance
499  * @card: the card instance
500  * @device: the device index, zero-based
501  * @hardware: the hardware type, MPU401_HW_XXXX
502  * @port: the base address of MPU401 port
503  * @info_flags: bitflags MPU401_INFO_XXX
504  * @irq: the ISA irq number, -1 if not to be allocated
505  * @rrawmidi: the pointer to store the new rawmidi instance
506  *
507  * Creates a new MPU-401 instance.
508  *
509  * Note that the rawmidi instance is returned on the rrawmidi argument,
510  * not the mpu401 instance itself.  To access to the mpu401 instance,
511  * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
512  *
513  * Return: Zero if successful, or a negative error code.
514  */
515 int snd_mpu401_uart_new(struct snd_card *card, int device,
516 			unsigned short hardware,
517 			unsigned long port,
518 			unsigned int info_flags,
519 			int irq,
520 			struct snd_rawmidi ** rrawmidi)
521 {
522 	struct snd_mpu401 *mpu;
523 	struct snd_rawmidi *rmidi;
524 	int in_enable, out_enable;
525 	int err;
526 
527 	if (rrawmidi)
528 		*rrawmidi = NULL;
529 	if (! (info_flags & (MPU401_INFO_INPUT | MPU401_INFO_OUTPUT)))
530 		info_flags |= MPU401_INFO_INPUT | MPU401_INFO_OUTPUT;
531 	in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0;
532 	out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0;
533 	err = snd_rawmidi_new(card, "MPU-401U", device,
534 			      out_enable, in_enable, &rmidi);
535 	if (err < 0)
536 		return err;
537 	mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
538 	if (!mpu) {
539 		err = -ENOMEM;
540 		goto free_device;
541 	}
542 	rmidi->private_data = mpu;
543 	rmidi->private_free = snd_mpu401_uart_free;
544 	spin_lock_init(&mpu->input_lock);
545 	spin_lock_init(&mpu->output_lock);
546 	spin_lock_init(&mpu->timer_lock);
547 	mpu->hardware = hardware;
548 	mpu->irq = -1;
549 	if (! (info_flags & MPU401_INFO_INTEGRATED)) {
550 		int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
551 		mpu->res = request_region(port, res_size, "MPU401 UART");
552 		if (!mpu->res) {
553 			snd_printk(KERN_ERR "mpu401_uart: "
554 				   "unable to grab port 0x%lx size %d\n",
555 				   port, res_size);
556 			err = -EBUSY;
557 			goto free_device;
558 		}
559 	}
560 	if (info_flags & MPU401_INFO_MMIO) {
561 		mpu->write = mpu401_write_mmio;
562 		mpu->read = mpu401_read_mmio;
563 	} else {
564 		mpu->write = mpu401_write_port;
565 		mpu->read = mpu401_read_port;
566 	}
567 	mpu->port = port;
568 	if (hardware == MPU401_HW_PC98II)
569 		mpu->cport = port + 2;
570 	else
571 		mpu->cport = port + 1;
572 	if (irq >= 0) {
573 		if (request_irq(irq, snd_mpu401_uart_interrupt, 0,
574 				"MPU401 UART", (void *) mpu)) {
575 			snd_printk(KERN_ERR "mpu401_uart: "
576 				   "unable to grab IRQ %d\n", irq);
577 			err = -EBUSY;
578 			goto free_device;
579 		}
580 	}
581 	if (irq < 0 && !(info_flags & MPU401_INFO_IRQ_HOOK))
582 		info_flags |= MPU401_INFO_USE_TIMER;
583 	mpu->info_flags = info_flags;
584 	mpu->irq = irq;
585 	if (card->shortname[0])
586 		snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI",
587 			 card->shortname);
588 	else
589 		sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device);
590 	if (out_enable) {
591 		snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
592 				    &snd_mpu401_uart_output);
593 		rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
594 	}
595 	if (in_enable) {
596 		snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
597 				    &snd_mpu401_uart_input);
598 		rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
599 		if (out_enable)
600 			rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
601 	}
602 	mpu->rmidi = rmidi;
603 	if (rrawmidi)
604 		*rrawmidi = rmidi;
605 	return 0;
606 free_device:
607 	snd_device_free(card, rmidi);
608 	return err;
609 }
610 
611 EXPORT_SYMBOL(snd_mpu401_uart_new);
612