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