1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 * Routines for control of MPU-401 in UART mode
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.
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.
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>
27 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
28 MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode");
29 MODULE_LICENSE("GPL");
31 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu);
32 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu);
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))
43 /* Build in lowlevel io */
44 static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data,
50 static unsigned char mpu401_read_port(struct snd_mpu401 *mpu,
56 static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data,
59 writeb(data, (void __iomem *)addr);
62 static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu,
65 return readb((void __iomem *)addr);
69 static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
72 for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
73 mpu->read(mpu, MPU401D(mpu));
74 #ifdef CONFIG_SND_DEBUG
76 snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n",
77 mpu->read(mpu, MPU401C(mpu)));
81 static void uart_interrupt_tx(struct snd_mpu401 *mpu)
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);
93 static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
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);
102 snd_mpu401_uart_clear_rx(mpu);
103 spin_unlock_irqrestore(&mpu->input_lock, flags);
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);
112 * snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler
113 * @irq: the irq number
114 * @dev_id: mpu401 instance
116 * Processes the interrupt for MPU401-UART i/o.
118 * Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
120 irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id)
122 struct snd_mpu401 *mpu = dev_id;
126 _snd_mpu401_uart_interrupt(mpu);
130 EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
133 * snd_mpu401_uart_interrupt_tx - generic MPU401-UART transmit irq handler
134 * @irq: the irq number
135 * @dev_id: mpu401 instance
137 * Processes the interrupt for MPU401-UART output.
139 * Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
141 irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id)
143 struct snd_mpu401 *mpu = dev_id;
147 uart_interrupt_tx(mpu);
151 EXPORT_SYMBOL(snd_mpu401_uart_interrupt_tx);
155 * reprogram the timer and call the interrupt job
157 static void snd_mpu401_uart_timer(struct timer_list *t)
159 struct snd_mpu401 *mpu = from_timer(mpu, t, timer);
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);
167 _snd_mpu401_uart_interrupt(mpu);
171 * initialize the timer callback if not programmed yet
173 static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
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);
182 mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER :
183 MPU401_MODE_OUTPUT_TIMER;
184 spin_unlock_irqrestore (&mpu->timer_lock, flags);
188 * remove the timer callback if still active
190 static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
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);
201 spin_unlock_irqrestore (&mpu->timer_lock, flags);
205 * send a UART command
206 * return zero if successful, non-zero for some errors
209 static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
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);*/
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--)
225 #ifdef CONFIG_SND_DEBUG
227 snd_printk(KERN_ERR "cmd: tx timeout (status = 0x%x)\n",
228 mpu->read(mpu, MPU401C(mpu)));
231 mpu->write(mpu, cmd, MPU401C(mpu));
232 if (ack && !(mpu->info_flags & MPU401_INFO_NO_ACK)) {
235 while (!ok && timeout-- > 0) {
236 if (snd_mpu401_input_avail(mpu)) {
237 if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
241 if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
245 spin_unlock_irqrestore(&mpu->input_lock, flags);
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)));
256 static int snd_mpu401_do_reset(struct snd_mpu401 *mpu)
258 if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
260 if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0))
266 * input/output open/close - protected by open_mutex in rawmidi.c
268 static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
270 struct snd_mpu401 *mpu;
273 mpu = substream->rmidi->private_data;
274 if (mpu->open_input) {
275 err = mpu->open_input(mpu);
279 if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
280 if (snd_mpu401_do_reset(mpu) < 0)
283 mpu->substream_input = substream;
284 set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
288 if (mpu->open_input && mpu->close_input)
289 mpu->close_input(mpu);
293 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
295 struct snd_mpu401 *mpu;
298 mpu = substream->rmidi->private_data;
299 if (mpu->open_output) {
300 err = mpu->open_output(mpu);
304 if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
305 if (snd_mpu401_do_reset(mpu) < 0)
308 mpu->substream_output = substream;
309 set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
313 if (mpu->open_output && mpu->close_output)
314 mpu->close_output(mpu);
318 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
320 struct snd_mpu401 *mpu;
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);
335 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
337 struct snd_mpu401 *mpu;
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);
353 * trigger input callback
356 snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
359 struct snd_mpu401 *mpu;
362 mpu = substream->rmidi->private_data;
364 if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER,
366 /* first time - flush FIFO */
368 mpu->read(mpu, MPU401D(mpu));
369 if (mpu->info_flags & MPU401_INFO_USE_TIMER)
370 snd_mpu401_uart_add_timer(mpu, 1);
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);
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);
386 * transfer input pending data
387 * call with input_lock spinlock held
389 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
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);
406 * AudioDrive ES1688 - 12 bytes
407 * S3 SonicVibes - 8 bytes
408 * SoundBlaster AWE 64 - 2 bytes (ugly hardware)
412 * write output pending bytes
413 * call with output_lock spinlock held
415 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
421 if (snd_rawmidi_transmit_peek(mpu->substream_output,
424 * Try twice because there is hardware that insists on
425 * setting the output busy bit after each write.
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);
433 snd_mpu401_uart_remove_timer (mpu, 0);
434 break; /* no other data - leave the tx loop */
440 * output trigger callback
443 snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
446 struct snd_mpu401 *mpu;
448 mpu = substream->rmidi->private_data;
450 set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
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().
456 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
457 snd_mpu401_uart_add_timer(mpu, 0);
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);
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);
474 static const struct snd_rawmidi_ops snd_mpu401_uart_output =
476 .open = snd_mpu401_uart_output_open,
477 .close = snd_mpu401_uart_output_close,
478 .trigger = snd_mpu401_uart_output_trigger,
481 static const struct snd_rawmidi_ops snd_mpu401_uart_input =
483 .open = snd_mpu401_uart_input_open,
484 .close = snd_mpu401_uart_input_close,
485 .trigger = snd_mpu401_uart_input_trigger,
488 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
490 struct snd_mpu401 *mpu = rmidi->private_data;
492 free_irq(mpu->irq, (void *) mpu);
493 release_and_free_resource(mpu->res);
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
507 * Creates a new MPU-401 instance.
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).
513 * Return: Zero if successful, or a negative error code.
515 int snd_mpu401_uart_new(struct snd_card *card, int device,
516 unsigned short hardware,
518 unsigned int info_flags,
520 struct snd_rawmidi ** rrawmidi)
522 struct snd_mpu401 *mpu;
523 struct snd_rawmidi *rmidi;
524 int in_enable, out_enable;
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);
537 mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
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;
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");
553 snd_printk(KERN_ERR "mpu401_uart: "
554 "unable to grab port 0x%lx size %d\n",
560 if (info_flags & MPU401_INFO_MMIO) {
561 mpu->write = mpu401_write_mmio;
562 mpu->read = mpu401_read_mmio;
564 mpu->write = mpu401_write_port;
565 mpu->read = mpu401_read_port;
568 if (hardware == MPU401_HW_PC98II)
569 mpu->cport = port + 2;
571 mpu->cport = port + 1;
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);
581 if (irq < 0 && !(info_flags & MPU401_INFO_IRQ_HOOK))
582 info_flags |= MPU401_INFO_USE_TIMER;
583 mpu->info_flags = info_flags;
585 if (card->shortname[0])
586 snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI",
589 sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device);
591 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
592 &snd_mpu401_uart_output);
593 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
596 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
597 &snd_mpu401_uart_input);
598 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
600 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
607 snd_device_free(card, rmidi);
611 EXPORT_SYMBOL(snd_mpu401_uart_new);