?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Pull one more egcs 1.1.2 workaround.
[linux-2.6/linux-mips.git] / sound / oss / mpu401.c
blob38ae0aaf95ca0d66f4223b851a82107603914306
1 /*
2 * sound/mpu401.c
3 *
4 * The low level driver for Roland MPU-401 compatible Midi cards.
5 */
6 /*
7 * Copyright (C) by Hannu Savolainen 1993-1997
8 *
9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
11 * for more info.
12 *
13 *
14 * Thomas Sailer ioctl code reworked (vmalloc/vfree removed)
15 * Alan Cox modularisation, use normal request_irq, use dev_id
16 * Bartlomiej Zolnierkiewicz removed some __init to allow using many drivers
17 * Chris Rankin Update the module-usage counter for the coprocessor
18 */
19
20 #include <linux/module.h>
21 #include <linux/init.h>
22 #include <linux/spinlock.h>
23 #define USE_SEQ_MACROS
24 #define USE_SIMPLE_MACROS
25
26 #include "sound_config.h"
27
28 #include "coproc.h"
29 #include "mpu401.h"
30
31 static int timer_mode = TMR_INTERNAL, timer_caps = TMR_INTERNAL;
32
33 struct mpu_config
34 {
35 int base; /*
36 * I/O base
37 */
38 int irq;
39 int opened; /*
40 * Open mode
41 */
42 int devno;
43 int synthno;
44 int uart_mode;
45 int initialized;
46 int mode;
47 #define MODE_MIDI 1
48 #define MODE_SYNTH 2
49 unsigned char version, revision;
50 unsigned int capabilities;
51 #define MPU_CAP_INTLG 0x10000000
52 #define MPU_CAP_SYNC 0x00000010
53 #define MPU_CAP_FSK 0x00000020
54 #define MPU_CAP_CLS 0x00000040
55 #define MPU_CAP_SMPTE 0x00000080
56 #define MPU_CAP_2PORT 0x00000001
57 int timer_flag;
58
59 #define MBUF_MAX 10
60 #define BUFTEST(dc) if (dc->m_ptr >= MBUF_MAX || dc->m_ptr < 0) \
61 {printk( "MPU: Invalid buffer pointer %d/%d, s=%d\n", dc->m_ptr, dc->m_left, dc->m_state);dc->m_ptr--;}
62 int m_busy;
63 unsigned char m_buf[MBUF_MAX];
64 int m_ptr;
65 int m_state;
66 int m_left;
67 unsigned char last_status;
68 void (*inputintr) (int dev, unsigned char data);
69 int shared_irq;
70 int *osp;
71 spinlock_t lock;
72 };
73
74 #define DATAPORT(base) (base)
75 #define COMDPORT(base) (base+1)
76 #define STATPORT(base) (base+1)
77
78
79 static void mpu401_close(int dev);
80
81 static int mpu401_status(struct mpu_config *devc)
82 {
83 return inb(STATPORT(devc->base));
84 }
85
86 #define input_avail(devc) (!(mpu401_status(devc)&INPUT_AVAIL))
87 #define output_ready(devc) (!(mpu401_status(devc)&OUTPUT_READY))
88
89 static void write_command(struct mpu_config *devc, unsigned char cmd)
90 {
91 outb(cmd, COMDPORT(devc->base));
92 }
93
94 static int read_data(struct mpu_config *devc)
95 {
96 return inb(DATAPORT(devc->base));
97 }
98
99 static void write_data(struct mpu_config *devc, unsigned char byte)
100 {
101 outb(byte, DATAPORT(devc->base));
102 }
103
104 #define OUTPUT_READY 0x40
105 #define INPUT_AVAIL 0x80
106 #define MPU_ACK 0xFE
107 #define MPU_RESET 0xFF
108 #define UART_MODE_ON 0x3F
109
110 static struct mpu_config dev_conf[MAX_MIDI_DEV] =
111 {
112 {0}
113 };
114
115 static int n_mpu_devs = 0;
116
117 static int reset_mpu401(struct mpu_config *devc);
118 static void set_uart_mode(int dev, struct mpu_config *devc, int arg);
119
120 static int mpu_timer_init(int midi_dev);
121 static void mpu_timer_interrupt(void);
122 static void timer_ext_event(struct mpu_config *devc, int event, int parm);
123
124 static struct synth_info mpu_synth_info_proto = {
125 "MPU-401 MIDI interface",
126 0,
127 SYNTH_TYPE_MIDI,
128 MIDI_TYPE_MPU401,
129 0, 128,
130 0, 128,
131 SYNTH_CAP_INPUT
132 };
133
134 static struct synth_info mpu_synth_info[MAX_MIDI_DEV];
135
136 /*
137 * States for the input scanner
138 */
139
140 #define ST_INIT 0 /* Ready for timing byte or msg */
141 #define ST_TIMED 1 /* Leading timing byte rcvd */
142 #define ST_DATABYTE 2 /* Waiting for (nr_left) data bytes */
143
144 #define ST_SYSMSG 100 /* System message (sysx etc). */
145 #define ST_SYSEX 101 /* System exclusive msg */
146 #define ST_MTC 102 /* Midi Time Code (MTC) qframe msg */
147 #define ST_SONGSEL 103 /* Song select */
148 #define ST_SONGPOS 104 /* Song position pointer */
149
150 static unsigned char len_tab[] = /* # of data bytes following a status
151 */
152 {
153 2, /* 8x */
154 2, /* 9x */
155 2, /* Ax */
156 2, /* Bx */
157 1, /* Cx */
158 1, /* Dx */
159 2, /* Ex */
160 0 /* Fx */
161 };
162
163 #define STORE(cmd) \
164 { \
165 int len; \
166 unsigned char obuf[8]; \
167 cmd; \
168 seq_input_event(obuf, len); \
169 }
170
171 #define _seqbuf obuf
172 #define _seqbufptr 0
173 #define _SEQ_ADVBUF(x) len=x
174
175 static int mpu_input_scanner(struct mpu_config *devc, unsigned char midic)
176 {
177
178 switch (devc->m_state)
179 {
180 case ST_INIT:
181 switch (midic)
182 {
183 case 0xf8:
184 /* Timer overflow */
185 break;
186
187 case 0xfc:
188 printk("<all end>");
189 break;
190
191 case 0xfd:
192 if (devc->timer_flag)
193 mpu_timer_interrupt();
194 break;
195
196 case 0xfe:
197 return MPU_ACK;
198
199 case 0xf0:
200 case 0xf1:
201 case 0xf2:
202 case 0xf3:
203 case 0xf4:
204 case 0xf5:
205 case 0xf6:
206 case 0xf7:
207 printk("<Trk data rq #%d>", midic & 0x0f);
208 break;
209
210 case 0xf9:
211 printk("<conductor rq>");
212 break;
213
214 case 0xff:
215 devc->m_state = ST_SYSMSG;
216 break;
217
218 default:
219 if (midic <= 0xef)
220 {
221 /* printk( "mpu time: %d ", midic); */
222 devc->m_state = ST_TIMED;
223 }
224 else
225 printk("<MPU: Unknown event %02x> ", midic);
226 }
227 break;
228
229 case ST_TIMED:
230 {
231 int msg = ((int) (midic & 0xf0) >> 4);
232
233 devc->m_state = ST_DATABYTE;
234
235 if (msg < 8) /* Data byte */
236 {
237 /* printk( "midi msg (running status) "); */
238 msg = ((int) (devc->last_status & 0xf0) >> 4);
239 msg -= 8;
240 devc->m_left = len_tab[msg] - 1;
241
242 devc->m_ptr = 2;
243 devc->m_buf[0] = devc->last_status;
244 devc->m_buf[1] = midic;
245
246 if (devc->m_left <= 0)
247 {
248 devc->m_state = ST_INIT;
249 do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
250 devc->m_ptr = 0;
251 }
252 }
253 else if (msg == 0xf) /* MPU MARK */
254 {
255 devc->m_state = ST_INIT;
256
257 switch (midic)
258 {
259 case 0xf8:
260 /* printk( "NOP "); */
261 break;
262
263 case 0xf9:
264 /* printk( "meas end "); */
265 break;
266
267 case 0xfc:
268 /* printk( "data end "); */
269 break;
270
271 default:
272 printk("Unknown MPU mark %02x\n", midic);
273 }
274 }
275 else
276 {
277 devc->last_status = midic;
278 /* printk( "midi msg "); */
279 msg -= 8;
280 devc->m_left = len_tab[msg];
281
282 devc->m_ptr = 1;
283 devc->m_buf[0] = midic;
284
285 if (devc->m_left <= 0)
286 {
287 devc->m_state = ST_INIT;
288 do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
289 devc->m_ptr = 0;
290 }
291 }
292 }
293 break;
294
295 case ST_SYSMSG:
296 switch (midic)
297 {
298 case 0xf0:
299 printk("<SYX>");
300 devc->m_state = ST_SYSEX;
301 break;
302
303 case 0xf1:
304 devc->m_state = ST_MTC;
305 break;
306
307 case 0xf2:
308 devc->m_state = ST_SONGPOS;
309 devc->m_ptr = 0;
310 break;
311
312 case 0xf3:
313 devc->m_state = ST_SONGSEL;
314 break;
315
316 case 0xf6:
317 /* printk( "tune_request\n"); */
318 devc->m_state = ST_INIT;
319
320 /*
321 * Real time messages
322 */
323 case 0xf8:
324 /* midi clock */
325 devc->m_state = ST_INIT;
326 timer_ext_event(devc, TMR_CLOCK, 0);
327 break;
328
329 case 0xfA:
330 devc->m_state = ST_INIT;
331 timer_ext_event(devc, TMR_START, 0);
332 break;
333
334 case 0xFB:
335 devc->m_state = ST_INIT;
336 timer_ext_event(devc, TMR_CONTINUE, 0);
337 break;
338
339 case 0xFC:
340 devc->m_state = ST_INIT;
341 timer_ext_event(devc, TMR_STOP, 0);
342 break;
343
344 case 0xFE:
345 /* active sensing */
346 devc->m_state = ST_INIT;
347 break;
348
349 case 0xff:
350 /* printk( "midi hard reset"); */
351 devc->m_state = ST_INIT;
352 break;
353
354 default:
355 printk("unknown MIDI sysmsg %0x\n", midic);
356 devc->m_state = ST_INIT;
357 }
358 break;
359
360 case ST_MTC:
361 devc->m_state = ST_INIT;
362 printk("MTC frame %x02\n", midic);
363 break;
364
365 case ST_SYSEX:
366 if (midic == 0xf7)
367 {
368 printk("<EOX>");
369 devc->m_state = ST_INIT;
370 }
371 else
372 printk("%02x ", midic);
373 break;
374
375 case ST_SONGPOS:
376 BUFTEST(devc);
377 devc->m_buf[devc->m_ptr++] = midic;
378 if (devc->m_ptr == 2)
379 {
380 devc->m_state = ST_INIT;
381 devc->m_ptr = 0;
382 timer_ext_event(devc, TMR_SPP,
383 ((devc->m_buf[1] & 0x7f) << 7) |
384 (devc->m_buf[0] & 0x7f));
385 }
386 break;
387
388 case ST_DATABYTE:
389 BUFTEST(devc);
390 devc->m_buf[devc->m_ptr++] = midic;
391 if ((--devc->m_left) <= 0)
392 {
393 devc->m_state = ST_INIT;
394 do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
395 devc->m_ptr = 0;
396 }
397 break;
398
399 default:
400 printk("Bad state %d ", devc->m_state);
401 devc->m_state = ST_INIT;
402 }
403 return 1;
404 }
405
406 static void mpu401_input_loop(struct mpu_config *devc)
407 {
408 unsigned long flags;
409 int busy;
410 int n;
411
412 spin_lock_irqsave(&devc->lock,flags);
413 busy = devc->m_busy;
414 devc->m_busy = 1;
415 spin_unlock_irqrestore(&devc->lock,flags);
416
417 if (busy) /* Already inside the scanner */
418 return;
419
420 n = 50;
421
422 while (input_avail(devc) && n-- > 0)
423 {
424 unsigned char c = read_data(devc);
425
426 if (devc->mode == MODE_SYNTH)
427 {
428 mpu_input_scanner(devc, c);
429 }
430 else if (devc->opened & OPEN_READ && devc->inputintr != NULL)
431 devc->inputintr(devc->devno, c);
432 }
433 devc->m_busy = 0;
434 }
435
436 int intchk_mpu401(void *dev_id)
437 {
438 struct mpu_config *devc;
439 int dev = (int) dev_id;
440
441 devc = &dev_conf[dev];
442 return input_avail(devc);
443 }
444
445 void mpuintr(int irq, void *dev_id, struct pt_regs *dummy)
446 {
447 struct mpu_config *devc;
448 int dev = (int) dev_id;
449
450 devc = &dev_conf[dev];
451
452 if (input_avail(devc))
453 {
454 if (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH))
455 mpu401_input_loop(devc);
456 else
457 {
458 /* Dummy read (just to acknowledge the interrupt) */
459 read_data(devc);
460 }
461 }
462 }
463
464 static int mpu401_open(int dev, int mode,
465 void (*input) (int dev, unsigned char data),
466 void (*output) (int dev)
467 )
468 {
469 int err;
470 struct mpu_config *devc;
471 struct coproc_operations *coprocessor;
472
473 if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
474 return -ENXIO;
475
476 devc = &dev_conf[dev];
477
478 if (devc->opened)
479 return -EBUSY;
480 /*
481 * Verify that the device is really running.
482 * Some devices (such as Ensoniq SoundScape don't
483 * work before the on board processor (OBP) is initialized
484 * by downloading its microcode.
485 */
486
487 if (!devc->initialized)
488 {
489 if (mpu401_status(devc) == 0xff) /* Bus float */
490 {
491 printk(KERN_ERR "mpu401: Device not initialized properly\n");
492 return -EIO;
493 }
494 reset_mpu401(devc);
495 }
496
497 if ( (coprocessor = midi_devs[dev]->coproc) != NULL )
498 {
499 if (coprocessor->owner)
500 __MOD_INC_USE_COUNT(coprocessor->owner);
501
502 if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
503 {
504 printk(KERN_WARNING "MPU-401: Can't access coprocessor device\n");
505 mpu401_close(dev);
506 return err;
507 }
508 }
509
510 set_uart_mode(dev, devc, 1);
511 devc->mode = MODE_MIDI;
512 devc->synthno = 0;
513
514 mpu401_input_loop(devc);
515
516 devc->inputintr = input;
517 devc->opened = mode;
518
519 return 0;
520 }
521
522 static void mpu401_close(int dev)
523 {
524 struct mpu_config *devc;
525 struct coproc_operations *coprocessor;
526
527 devc = &dev_conf[dev];
528 if (devc->uart_mode)
529 reset_mpu401(devc); /*
530 * This disables the UART mode
531 */
532 devc->mode = 0;
533 devc->inputintr = NULL;
534
535 coprocessor = midi_devs[dev]->coproc;
536 if (coprocessor) {
537 coprocessor->close(coprocessor->devc, COPR_MIDI);
538
539 if (coprocessor->owner)
540 __MOD_DEC_USE_COUNT(coprocessor->owner);
541 }
542 devc->opened = 0;
543 }
544
545 static int mpu401_out(int dev, unsigned char midi_byte)
546 {
547 int timeout;
548 unsigned long flags;
549
550 struct mpu_config *devc;
551
552 devc = &dev_conf[dev];
553
554 /*
555 * Sometimes it takes about 30000 loops before the output becomes ready
556 * (After reset). Normally it takes just about 10 loops.
557 */
558
559 for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--);
560
561 spin_lock_irqsave(&devc->lock,flags);
562 if (!output_ready(devc))
563 {
564 printk(KERN_WARNING "mpu401: Send data timeout\n");
565 spin_unlock_irqrestore(&devc->lock,flags);
566 return 0;
567 }
568 write_data(devc, midi_byte);
569 spin_unlock_irqrestore(&devc->lock,flags);
570 return 1;
571 }
572
573 static int mpu401_command(int dev, mpu_command_rec * cmd)
574 {
575 int i, timeout, ok;
576 int ret = 0;
577 unsigned long flags;
578 struct mpu_config *devc;
579
580 devc = &dev_conf[dev];
581
582 if (devc->uart_mode) /*
583 * Not possible in UART mode
584 */
585 {
586 printk(KERN_WARNING "mpu401: commands not possible in the UART mode\n");
587 return -EINVAL;
588 }
589 /*
590 * Test for input since pending input seems to block the output.
591 */
592 if (input_avail(devc))
593 mpu401_input_loop(devc);
594
595 /*
596 * Sometimes it takes about 50000 loops before the output becomes ready
597 * (After reset). Normally it takes just about 10 loops.
598 */
599
600 timeout = 50000;
601 retry:
602 if (timeout-- <= 0)
603 {
604 printk(KERN_WARNING "mpu401: Command (0x%x) timeout\n", (int) cmd->cmd);
605 return -EIO;
606 }
607 spin_lock_irqsave(&devc->lock,flags);
608
609 if (!output_ready(devc))
610 {
611 spin_unlock_irqrestore(&devc->lock,flags);
612 goto retry;
613 }
614 write_command(devc, cmd->cmd);
615
616 ok = 0;
617 for (timeout = 50000; timeout > 0 && !ok; timeout--)
618 {
619 if (input_avail(devc))
620 {
621 if (devc->opened && devc->mode == MODE_SYNTH)
622 {
623 if (mpu_input_scanner(devc, read_data(devc)) == MPU_ACK)
624 ok = 1;
625 }
626 else
627 {
628 /* Device is not currently open. Use simpler method */
629 if (read_data(devc) == MPU_ACK)
630 ok = 1;
631 }
632 }
633 }
634 if (!ok)
635 {
636 spin_unlock_irqrestore(&devc->lock,flags);
637 return -EIO;
638 }
639 if (cmd->nr_args)
640 {
641 for (i = 0; i < cmd->nr_args; i++)
642 {
643 for (timeout = 3000; timeout > 0 && !output_ready(devc); timeout--);
644
645 if (!mpu401_out(dev, cmd->data[i]))
646 {
647 spin_unlock_irqrestore(&devc->lock,flags);
648 printk(KERN_WARNING "mpu401: Command (0x%x), parm send failed.\n", (int) cmd->cmd);
649 return -EIO;
650 }
651 }
652 }
653 ret = 0;
654 cmd->data[0] = 0;
655
656 if (cmd->nr_returns)
657 {
658 for (i = 0; i < cmd->nr_returns; i++)
659 {
660 ok = 0;
661 for (timeout = 5000; timeout > 0 && !ok; timeout--)
662 if (input_avail(devc))
663 {
664 cmd->data[i] = read_data(devc);
665 ok = 1;
666 }
667 if (!ok)
668 {
669 spin_unlock_irqrestore(&devc->lock,flags);
670 return -EIO;
671 }
672 }
673 }
674 spin_unlock_irqrestore(&devc->lock,flags);
675 return ret;
676 }
677
678 static int mpu_cmd(int dev, int cmd, int data)
679 {
680 int ret;
681
682 static mpu_command_rec rec;
683
684 rec.cmd = cmd & 0xff;
685 rec.nr_args = ((cmd & 0xf0) == 0xE0);
686 rec.nr_returns = ((cmd & 0xf0) == 0xA0);
687 rec.data[0] = data & 0xff;
688
689 if ((ret = mpu401_command(dev, &rec)) < 0)
690 return ret;
691 return (unsigned char) rec.data[0];
692 }
693
694 static int mpu401_prefix_cmd(int dev, unsigned char status)
695 {
696 struct mpu_config *devc = &dev_conf[dev];
697
698 if (devc->uart_mode)
699 return 1;
700
701 if (status < 0xf0)
702 {
703 if (mpu_cmd(dev, 0xD0, 0) < 0)
704 return 0;
705 return 1;
706 }
707 switch (status)
708 {
709 case 0xF0:
710 if (mpu_cmd(dev, 0xDF, 0) < 0)
711 return 0;
712 return 1;
713
714 default:
715 return 0;
716 }
717 }
718
719 static int mpu401_start_read(int dev)
720 {
721 return 0;
722 }
723
724 static int mpu401_end_read(int dev)
725 {
726 return 0;
727 }
728
729 static int mpu401_ioctl(int dev, unsigned cmd, caddr_t arg)
730 {
731 struct mpu_config *devc;
732 mpu_command_rec rec;
733 int val, ret;
734
735 devc = &dev_conf[dev];
736 switch (cmd)
737 {
738 case SNDCTL_MIDI_MPUMODE:
739 if (!(devc->capabilities & MPU_CAP_INTLG)) { /* No intelligent mode */
740 printk(KERN_WARNING "mpu401: Intelligent mode not supported by the HW\n");
741 return -EINVAL;
742 }
743 if (get_user(val, (int *)arg))
744 return -EFAULT;
745 set_uart_mode(dev, devc, !val);
746 return 0;
747
748 case SNDCTL_MIDI_MPUCMD:
749 if (copy_from_user(&rec, arg, sizeof(rec)))
750 return -EFAULT;
751 if ((ret = mpu401_command(dev, &rec)) < 0)
752 return ret;
753 if (copy_to_user(arg, &rec, sizeof(rec)))
754 return -EFAULT;
755 return 0;
756
757 default:
758 return -EINVAL;
759 }
760 }
761
762 static void mpu401_kick(int dev)
763 {
764 }
765
766 static int mpu401_buffer_status(int dev)
767 {
768 return 0; /*
769 * No data in buffers
770 */
771 }
772
773 static int mpu_synth_ioctl(int dev,
774 unsigned int cmd, caddr_t arg)
775 {
776 int midi_dev;
777 struct mpu_config *devc;
778
779 midi_dev = synth_devs[dev]->midi_dev;
780
781 if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
782 return -ENXIO;
783
784 devc = &dev_conf[midi_dev];
785
786 switch (cmd)
787 {
788
789 case SNDCTL_SYNTH_INFO:
790 memcpy((&((char *) arg)[0]), (char *) &mpu_synth_info[midi_dev], sizeof(struct synth_info));
791 return 0;
792
793 case SNDCTL_SYNTH_MEMAVL:
794 return 0x7fffffff;
795
796 default:
797 return -EINVAL;
798 }
799 }
800
801 static int mpu_synth_open(int dev, int mode)
802 {
803 int midi_dev, err;
804 struct mpu_config *devc;
805 struct coproc_operations *coprocessor;
806
807 midi_dev = synth_devs[dev]->midi_dev;
808
809 if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
810 return -ENXIO;
811
812 devc = &dev_conf[midi_dev];
813
814 /*
815 * Verify that the device is really running.
816 * Some devices (such as Ensoniq SoundScape don't
817 * work before the on board processor (OBP) is initialized
818 * by downloading its microcode.
819 */
820
821 if (!devc->initialized)
822 {
823 if (mpu401_status(devc) == 0xff) /* Bus float */
824 {
825 printk(KERN_ERR "mpu401: Device not initialized properly\n");
826 return -EIO;
827 }
828 reset_mpu401(devc);
829 }
830 if (devc->opened)
831 return -EBUSY;
832 devc->mode = MODE_SYNTH;
833 devc->synthno = dev;
834
835 devc->inputintr = NULL;
836
837 coprocessor = midi_devs[midi_dev]->coproc;
838 if (coprocessor) {
839 if (coprocessor->owner)
840 __MOD_INC_USE_COUNT(coprocessor->owner);
841
842 if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
843 {
844 printk(KERN_WARNING "mpu401: Can't access coprocessor device\n");
845 return err;
846 }
847 }
848 devc->opened = mode;
849 reset_mpu401(devc);
850
851 if (mode & OPEN_READ)
852 {
853 mpu_cmd(midi_dev, 0x8B, 0); /* Enable data in stop mode */
854 mpu_cmd(midi_dev, 0x34, 0); /* Return timing bytes in stop mode */
855 mpu_cmd(midi_dev, 0x87, 0); /* Enable pitch & controller */
856 }
857 return 0;
858 }
859
860 static void mpu_synth_close(int dev)
861 {
862 int midi_dev;
863 struct mpu_config *devc;
864 struct coproc_operations *coprocessor;
865
866 midi_dev = synth_devs[dev]->midi_dev;
867
868 devc = &dev_conf[midi_dev];
869 mpu_cmd(midi_dev, 0x15, 0); /* Stop recording, playback and MIDI */
870 mpu_cmd(midi_dev, 0x8a, 0); /* Disable data in stopped mode */
871
872 devc->inputintr = NULL;
873
874 coprocessor = midi_devs[midi_dev]->coproc;
875 if (coprocessor) {
876 coprocessor->close(coprocessor->devc, COPR_MIDI);
877
878 if (coprocessor->owner)
879 __MOD_DEC_USE_COUNT(coprocessor->owner);
880 }
881 devc->opened = 0;
882 devc->mode = 0;
883 }
884
885 #define MIDI_SYNTH_NAME "MPU-401 UART Midi"
886 #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
887 #include "midi_synth.h"
888
889 static struct synth_operations mpu401_synth_proto =
890 {
891 owner: THIS_MODULE,
892 id: "MPU401",
893 info: NULL,
894 midi_dev: 0,
895 synth_type: SYNTH_TYPE_MIDI,
896 synth_subtype: 0,
897 open: mpu_synth_open,
898 close: mpu_synth_close,
899 ioctl: mpu_synth_ioctl,
900 kill_note: midi_synth_kill_note,
901 start_note: midi_synth_start_note,
902 set_instr: midi_synth_set_instr,
903 reset: midi_synth_reset,
904 hw_control: midi_synth_hw_control,
905 load_patch: midi_synth_load_patch,
906 aftertouch: midi_synth_aftertouch,
907 controller: midi_synth_controller,
908 panning: midi_synth_panning,
909 bender: midi_synth_bender,
910 setup_voice: midi_synth_setup_voice,
911 send_sysex: midi_synth_send_sysex
912 };
913
914 static struct synth_operations *mpu401_synth_operations[MAX_MIDI_DEV];
915
916 static struct midi_operations mpu401_midi_proto =
917 {
918 owner: THIS_MODULE,
919 info: {"MPU-401 Midi", 0, MIDI_CAP_MPU401, SNDCARD_MPU401},
920 in_info: {0},
921 open: mpu401_open,
922 close: mpu401_close,
923 ioctl: mpu401_ioctl,
924 outputc: mpu401_out,
925 start_read: mpu401_start_read,
926 end_read: mpu401_end_read,
927 kick: mpu401_kick,
928 buffer_status: mpu401_buffer_status,
929 prefix_cmd: mpu401_prefix_cmd
930 };
931
932 static struct midi_operations mpu401_midi_operations[MAX_MIDI_DEV];
933
934 static void mpu401_chk_version(int n, struct mpu_config *devc)
935 {
936 int tmp;
937 unsigned long flags;
938
939 devc->version = devc->revision = 0;
940
941 spin_lock_irqsave(&devc->lock,flags);
942 if ((tmp = mpu_cmd(n, 0xAC, 0)) < 0)
943 {
944 spin_unlock_irqrestore(&devc->lock,flags);
945 return;
946 }
947 if ((tmp & 0xf0) > 0x20) /* Why it's larger than 2.x ??? */
948 {
949 spin_unlock_irqrestore(&devc->lock,flags);
950 return;
951 }
952 devc->version = tmp;
953
954 if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0)
955 {
956 devc->version = 0;
957 spin_unlock_irqrestore(&devc->lock,flags);
958 return;
959 }
960 devc->revision = tmp;
961 spin_unlock_irqrestore(&devc->lock,flags);
962 }
963
964 void attach_mpu401(struct address_info *hw_config, struct module *owner)
965 {
966 unsigned long flags;
967 char revision_char;
968
969 int m;
970 struct mpu_config *devc;
971
972 hw_config->slots[1] = -1;
973 m = sound_alloc_mididev();
974 if (m == -1)
975 {
976 printk(KERN_WARNING "MPU-401: Too many midi devices detected\n");
977 return;
978 }
979 devc = &dev_conf[m];
980 devc->base = hw_config->io_base;
981 devc->osp = hw_config->osp;
982 devc->irq = hw_config->irq;
983 devc->opened = 0;
984 devc->uart_mode = 0;
985 devc->initialized = 0;
986 devc->version = 0;
987 devc->revision = 0;
988 devc->capabilities = 0;
989 devc->timer_flag = 0;
990 devc->m_busy = 0;
991 devc->m_state = ST_INIT;
992 devc->shared_irq = hw_config->always_detect;
993 devc->irq = hw_config->irq;
994 spin_lock_init(&devc->lock);
995
996 if (devc->irq < 0)
997 {
998 devc->irq *= -1;
999 devc->shared_irq = 1;
1000 }
1001
1002 if (!hw_config->always_detect)
1003 {
1004 /* Verify the hardware again */
1005 if (!reset_mpu401(devc))
1006 {
1007 printk(KERN_WARNING "mpu401: Device didn't respond\n");
1008 sound_unload_mididev(m);
1009 return;
1010 }
1011 if (!devc->shared_irq)
1012 {
1013 if (request_irq(devc->irq, mpuintr, 0, "mpu401", (void *)m) < 0)
1014 {
1015 printk(KERN_WARNING "mpu401: Failed to allocate IRQ%d\n", devc->irq);
1016 sound_unload_mididev(m);
1017 return;
1018 }
1019 }
1020 spin_lock_irqsave(&devc->lock,flags);
1021 mpu401_chk_version(m, devc);
1022 if (devc->version == 0)
1023 mpu401_chk_version(m, devc);
1024 spin_unlock_irqrestore(&devc->lock,flags);
1025 }
1026 request_region(hw_config->io_base, 2, "mpu401");
1027
1028 if (devc->version != 0)
1029 if (mpu_cmd(m, 0xC5, 0) >= 0) /* Set timebase OK */
1030 if (mpu_cmd(m, 0xE0, 120) >= 0) /* Set tempo OK */
1031 devc->capabilities |= MPU_CAP_INTLG; /* Supports intelligent mode */
1032
1033
1034 mpu401_synth_operations[m] = (struct synth_operations *)kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
1035
1036 if (mpu401_synth_operations[m] == NULL)
1037 {
1038 sound_unload_mididev(m);
1039 printk(KERN_ERR "mpu401: Can't allocate memory\n");
1040 return;
1041 }
1042 if (!(devc->capabilities & MPU_CAP_INTLG)) /* No intelligent mode */
1043 {
1044 memcpy((char *) mpu401_synth_operations[m],
1045 (char *) &std_midi_synth,
1046 sizeof(struct synth_operations));
1047 }
1048 else
1049 {
1050 memcpy((char *) mpu401_synth_operations[m],
1051 (char *) &mpu401_synth_proto,
1052 sizeof(struct synth_operations));
1053 }
1054 if (owner)
1055 mpu401_synth_operations[m]->owner = owner;
1056
1057 memcpy((char *) &mpu401_midi_operations[m],
1058 (char *) &mpu401_midi_proto,
1059 sizeof(struct midi_operations));
1060
1061 mpu401_midi_operations[m].converter = mpu401_synth_operations[m];
1062
1063 memcpy((char *) &mpu_synth_info[m],
1064 (char *) &mpu_synth_info_proto,
1065 sizeof(struct synth_info));
1066
1067 n_mpu_devs++;
1068
1069 if (devc->version == 0x20 && devc->revision >= 0x07) /* MusicQuest interface */
1070 {
1071 int ports = (devc->revision & 0x08) ? 32 : 16;
1072
1073 devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_SMPTE |
1074 MPU_CAP_CLS | MPU_CAP_2PORT;
1075
1076 revision_char = (devc->revision == 0x7f) ? 'M' : ' ';
1077 sprintf(mpu_synth_info[m].name, "MQX-%d%c MIDI Interface #%d",
1078 ports,
1079 revision_char,
1080 n_mpu_devs);
1081 }
1082 else
1083 {
1084 revision_char = devc->revision ? devc->revision + '@' : ' ';
1085 if ((int) devc->revision > ('Z' - '@'))
1086 revision_char = '+';
1087
1088 devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_FSK;
1089
1090 if (hw_config->name)
1091 sprintf(mpu_synth_info[m].name, "%s (MPU401)", hw_config->name);
1092 else
1093 sprintf(mpu_synth_info[m].name,
1094 "MPU-401 %d.%d%c Midi interface #%d",
1095 (int) (devc->version & 0xf0) >> 4,
1096 devc->version & 0x0f,
1097 revision_char,
1098 n_mpu_devs);
1099 }
1100
1101 strcpy(mpu401_midi_operations[m].info.name,
1102 mpu_synth_info[m].name);
1103
1104 conf_printf(mpu_synth_info[m].name, hw_config);
1105
1106 mpu401_synth_operations[m]->midi_dev = devc->devno = m;
1107 mpu401_synth_operations[devc->devno]->info = &mpu_synth_info[devc->devno];
1108
1109 if (devc->capabilities & MPU_CAP_INTLG) /* Intelligent mode */
1110 hw_config->slots[2] = mpu_timer_init(m);
1111
1112 midi_devs[m] = &mpu401_midi_operations[devc->devno];
1113
1114 if (owner)
1115 midi_devs[m]->owner = owner;
1116
1117 hw_config->slots[1] = m;
1118 sequencer_init();
1119 }
1120
1121 static int reset_mpu401(struct mpu_config *devc)
1122 {
1123 unsigned long flags;
1124 int ok, timeout, n;
1125 int timeout_limit;
1126
1127 /*
1128 * Send the RESET command. Try again if no success at the first time.
1129 * (If the device is in the UART mode, it will not ack the reset cmd).
1130 */
1131
1132 ok = 0;
1133
1134 timeout_limit = devc->initialized ? 30000 : 100000;
1135 devc->initialized = 1;
1136
1137 for (n = 0; n < 2 && !ok; n++)
1138 {
1139 for (timeout = timeout_limit; timeout > 0 && !ok; timeout--)
1140 ok = output_ready(devc);
1141
1142 write_command(devc, MPU_RESET); /*
1143 * Send MPU-401 RESET Command
1144 */
1145
1146 /*
1147 * Wait at least 25 msec. This method is not accurate so let's make the
1148 * loop bit longer. Cannot sleep since this is called during boot.
1149 */
1150
1151 for (timeout = timeout_limit * 2; timeout > 0 && !ok; timeout--)
1152 {
1153 spin_lock_irqsave(&devc->lock,flags);
1154 if (input_avail(devc))
1155 if (read_data(devc) == MPU_ACK)
1156 ok = 1;
1157 spin_unlock_irqrestore(&devc->lock,flags);
1158 }
1159
1160 }
1161
1162 devc->m_state = ST_INIT;
1163 devc->m_ptr = 0;
1164 devc->m_left = 0;
1165 devc->last_status = 0;
1166 devc->uart_mode = 0;
1167
1168 return ok;
1169 }
1170
1171 static void set_uart_mode(int dev, struct mpu_config *devc, int arg)
1172 {
1173 if (!arg && (devc->capabilities & MPU_CAP_INTLG))
1174 return;
1175 if ((devc->uart_mode == 0) == (arg == 0))
1176 return; /* Already set */
1177 reset_mpu401(devc); /* This exits the uart mode */
1178
1179 if (arg)
1180 {
1181 if (mpu_cmd(dev, UART_MODE_ON, 0) < 0)
1182 {
1183 printk(KERN_ERR "mpu401: Can't enter UART mode\n");
1184 devc->uart_mode = 0;
1185 return;
1186 }
1187 }
1188 devc->uart_mode = arg;
1189
1190 }
1191
1192 int probe_mpu401(struct address_info *hw_config)
1193 {
1194 int ok = 0;
1195 struct mpu_config tmp_devc;
1196
1197 if (check_region(hw_config->io_base, 2))
1198 {
1199 printk(KERN_ERR "mpu401: I/O port %x already in use\n\n", hw_config->io_base);
1200 return 0;
1201 }
1202 tmp_devc.base = hw_config->io_base;
1203 tmp_devc.irq = hw_config->irq;
1204 tmp_devc.initialized = 0;
1205 tmp_devc.opened = 0;
1206 tmp_devc.osp = hw_config->osp;
1207
1208 if (hw_config->always_detect)
1209 return 1;
1210
1211 if (inb(hw_config->io_base + 1) == 0xff)
1212 {
1213 DDB(printk("MPU401: Port %x looks dead.\n", hw_config->io_base));
1214 return 0; /* Just bus float? */
1215 }
1216 ok = reset_mpu401(&tmp_devc);
1217
1218 if (!ok)
1219 {
1220 DDB(printk("MPU401: Reset failed on port %x\n", hw_config->io_base));
1221 }
1222 return ok;
1223 }
1224
1225 void unload_mpu401(struct address_info *hw_config)
1226 {
1227 void *p;
1228 int n=hw_config->slots[1];
1229
1230 release_region(hw_config->io_base, 2);
1231 if (hw_config->always_detect == 0 && hw_config->irq > 0)
1232 free_irq(hw_config->irq, (void *)n);
1233 p=mpu401_synth_operations[n];
1234 sound_unload_mididev(n);
1235 sound_unload_timerdev(hw_config->slots[2]);
1236 if(p)
1237 kfree(p);
1238 }
1239
1240 /*****************************************************
1241 * Timer stuff
1242 ****************************************************/
1243
1244 static volatile int timer_initialized = 0, timer_open = 0, tmr_running = 0;
1245 static volatile int curr_tempo, curr_timebase, hw_timebase;
1246 static int max_timebase = 8; /* 8*24=192 ppqn */
1247 static volatile unsigned long next_event_time;
1248 static volatile unsigned long curr_ticks, curr_clocks;
1249 static unsigned long prev_event_time;
1250 static int metronome_mode;
1251
1252 static unsigned long clocks2ticks(unsigned long clocks)
1253 {
1254 /*
1255 * The MPU-401 supports just a limited set of possible timebase values.
1256 * Since the applications require more choices, the driver has to
1257 * program the HW to do its best and to convert between the HW and
1258 * actual timebases.
1259 */
1260 return ((clocks * curr_timebase) + (hw_timebase / 2)) / hw_timebase;
1261 }
1262
1263 static void set_timebase(int midi_dev, int val)
1264 {
1265 int hw_val;
1266
1267 if (val < 48)
1268 val = 48;
1269 if (val > 1000)
1270 val = 1000;
1271
1272 hw_val = val;
1273 hw_val = (hw_val + 12) / 24;
1274 if (hw_val > max_timebase)
1275 hw_val = max_timebase;
1276
1277 if (mpu_cmd(midi_dev, 0xC0 | (hw_val & 0x0f), 0) < 0)
1278 {
1279 printk(KERN_WARNING "mpu401: Can't set HW timebase to %d\n", hw_val * 24);
1280 return;
1281 }
1282 hw_timebase = hw_val * 24;
1283 curr_timebase = val;
1284
1285 }
1286
1287 static void tmr_reset(struct mpu_config *devc)
1288 {
1289 unsigned long flags;
1290
1291 spin_lock_irqsave(&devc->lock,flags);
1292 next_event_time = (unsigned long) -1;
1293 prev_event_time = 0;
1294 curr_ticks = curr_clocks = 0;
1295 spin_unlock_irqrestore(&devc->lock,flags);
1296 }
1297
1298 static void set_timer_mode(int midi_dev)
1299 {
1300 if (timer_mode & TMR_MODE_CLS)
1301 mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */
1302 else if (timer_mode & TMR_MODE_SMPTE)
1303 mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */
1304
1305 if (timer_mode & TMR_INTERNAL)
1306 {
1307 mpu_cmd(midi_dev, 0x80, 0); /* Use MIDI sync */
1308 }
1309 else
1310 {
1311 if (timer_mode & (TMR_MODE_MIDI | TMR_MODE_CLS))
1312 {
1313 mpu_cmd(midi_dev, 0x82, 0); /* Use MIDI sync */
1314 mpu_cmd(midi_dev, 0x91, 0); /* Enable ext MIDI ctrl */
1315 }
1316 else if (timer_mode & TMR_MODE_FSK)
1317 mpu_cmd(midi_dev, 0x81, 0); /* Use FSK sync */
1318 }
1319 }
1320
1321 static void stop_metronome(int midi_dev)
1322 {
1323 mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */
1324 }
1325
1326 static void setup_metronome(int midi_dev)
1327 {
1328 int numerator, denominator;
1329 int clks_per_click, num_32nds_per_beat;
1330 int beats_per_measure;
1331
1332 numerator = ((unsigned) metronome_mode >> 24) & 0xff;
1333 denominator = ((unsigned) metronome_mode >> 16) & 0xff;
1334 clks_per_click = ((unsigned) metronome_mode >> 8) & 0xff;
1335 num_32nds_per_beat = (unsigned) metronome_mode & 0xff;
1336 beats_per_measure = (numerator * 4) >> denominator;
1337
1338 if (!metronome_mode)
1339 mpu_cmd(midi_dev, 0x84, 0); /* Disable metronome */
1340 else
1341 {
1342 mpu_cmd(midi_dev, 0xE4, clks_per_click);
1343 mpu_cmd(midi_dev, 0xE6, beats_per_measure);
1344 mpu_cmd(midi_dev, 0x83, 0); /* Enable metronome without accents */
1345 }
1346 }
1347
1348 static int mpu_start_timer(int midi_dev)
1349 {
1350 struct mpu_config *devc= &dev_conf[midi_dev];
1351
1352 tmr_reset(devc);
1353 set_timer_mode(midi_dev);
1354
1355 if (tmr_running)
1356 return TIMER_NOT_ARMED; /* Already running */
1357
1358 if (timer_mode & TMR_INTERNAL)
1359 {
1360 mpu_cmd(midi_dev, 0x02, 0); /* Send MIDI start */
1361 tmr_running = 1;
1362 return TIMER_NOT_ARMED;
1363 }
1364 else
1365 {
1366 mpu_cmd(midi_dev, 0x35, 0); /* Enable mode messages to PC */
1367 mpu_cmd(midi_dev, 0x38, 0); /* Enable sys common messages to PC */
1368 mpu_cmd(midi_dev, 0x39, 0); /* Enable real time messages to PC */
1369 mpu_cmd(midi_dev, 0x97, 0); /* Enable system exclusive messages to PC */
1370 }
1371 return TIMER_ARMED;
1372 }
1373
1374 static int mpu_timer_open(int dev, int mode)
1375 {
1376 int midi_dev = sound_timer_devs[dev]->devlink;
1377 struct mpu_config *devc= &dev_conf[midi_dev];
1378
1379 if (timer_open)
1380 return -EBUSY;
1381
1382 tmr_reset(devc);
1383 curr_tempo = 50;
1384 mpu_cmd(midi_dev, 0xE0, 50);
1385 curr_timebase = hw_timebase = 120;
1386 set_timebase(midi_dev, 120);
1387 timer_open = 1;
1388 metronome_mode = 0;
1389 set_timer_mode(midi_dev);
1390
1391 mpu_cmd(midi_dev, 0xe7, 0x04); /* Send all clocks to host */
1392 mpu_cmd(midi_dev, 0x95, 0); /* Enable clock to host */
1393
1394 return 0;
1395 }
1396
1397 static void mpu_timer_close(int dev)
1398 {
1399 int midi_dev = sound_timer_devs[dev]->devlink;
1400
1401 timer_open = tmr_running = 0;
1402 mpu_cmd(midi_dev, 0x15, 0); /* Stop all */
1403 mpu_cmd(midi_dev, 0x94, 0); /* Disable clock to host */
1404 mpu_cmd(midi_dev, 0x8c, 0); /* Disable measure end messages to host */
1405 stop_metronome(midi_dev);
1406 }
1407
1408 static int mpu_timer_event(int dev, unsigned char *event)
1409 {
1410 unsigned char command = event[1];
1411 unsigned long parm = *(unsigned int *) &event[4];
1412 int midi_dev = sound_timer_devs[dev]->devlink;
1413
1414 switch (command)
1415 {
1416 case TMR_WAIT_REL:
1417 parm += prev_event_time;
1418 case TMR_WAIT_ABS:
1419 if (parm > 0)
1420 {
1421 long time;
1422
1423 if (parm <= curr_ticks) /* It's the time */
1424 return TIMER_NOT_ARMED;
1425 time = parm;
1426 next_event_time = prev_event_time = time;
1427
1428 return TIMER_ARMED;
1429 }
1430 break;
1431
1432 case TMR_START:
1433 if (tmr_running)
1434 break;
1435 return mpu_start_timer(midi_dev);
1436
1437 case TMR_STOP:
1438 mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */
1439 stop_metronome(midi_dev);
1440 tmr_running = 0;
1441 break;
1442
1443 case TMR_CONTINUE:
1444 if (tmr_running)
1445 break;
1446 mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */
1447 setup_metronome(midi_dev);
1448 tmr_running = 1;
1449 break;
1450
1451 case TMR_TEMPO:
1452 if (parm)
1453 {
1454 if (parm < 8)
1455 parm = 8;
1456 if (parm > 250)
1457 parm = 250;
1458 if (mpu_cmd(midi_dev, 0xE0, parm) < 0)
1459 printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) parm);
1460 curr_tempo = parm;
1461 }
1462 break;
1463
1464 case TMR_ECHO:
1465 seq_copy_to_input(event, 8);
1466 break;
1467
1468 case TMR_TIMESIG:
1469 if (metronome_mode) /* Metronome enabled */
1470 {
1471 metronome_mode = parm;
1472 setup_metronome(midi_dev);
1473 }
1474 break;
1475
1476 default:;
1477 }
1478 return TIMER_NOT_ARMED;
1479 }
1480
1481 static unsigned long mpu_timer_get_time(int dev)
1482 {
1483 if (!timer_open)
1484 return 0;
1485
1486 return curr_ticks;
1487 }
1488
1489 static int mpu_timer_ioctl(int dev, unsigned int command, caddr_t arg)
1490 {
1491 int midi_dev = sound_timer_devs[dev]->devlink;
1492
1493 switch (command)
1494 {
1495 case SNDCTL_TMR_SOURCE:
1496 {
1497 int parm;
1498
1499 parm = *(int *) arg;
1500 parm &= timer_caps;
1501
1502 if (parm != 0)
1503 {
1504 timer_mode = parm;
1505
1506 if (timer_mode & TMR_MODE_CLS)
1507 mpu_cmd(midi_dev, 0x3c, 0); /* Use CLS sync */
1508 else if (timer_mode & TMR_MODE_SMPTE)
1509 mpu_cmd(midi_dev, 0x3d, 0); /* Use SMPTE sync */
1510 }
1511 return (*(int *) arg = timer_mode);
1512 }
1513 break;
1514
1515 case SNDCTL_TMR_START:
1516 mpu_start_timer(midi_dev);
1517 return 0;
1518
1519 case SNDCTL_TMR_STOP:
1520 tmr_running = 0;
1521 mpu_cmd(midi_dev, 0x01, 0); /* Send MIDI stop */
1522 stop_metronome(midi_dev);
1523 return 0;
1524
1525 case SNDCTL_TMR_CONTINUE:
1526 if (tmr_running)
1527 return 0;
1528 tmr_running = 1;
1529 mpu_cmd(midi_dev, 0x03, 0); /* Send MIDI continue */
1530 return 0;
1531
1532 case SNDCTL_TMR_TIMEBASE:
1533 {
1534 int val;
1535
1536 val = *(int *) arg;
1537 if (val)
1538 set_timebase(midi_dev, val);
1539 return (*(int *) arg = curr_timebase);
1540 }
1541 break;
1542
1543 case SNDCTL_TMR_TEMPO:
1544 {
1545 int val;
1546 int ret;
1547
1548 val = *(int *) arg;
1549
1550 if (val)
1551 {
1552 if (val < 8)
1553 val = 8;
1554 if (val > 250)
1555 val = 250;
1556 if ((ret = mpu_cmd(midi_dev, 0xE0, val)) < 0)
1557 {
1558 printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) val);
1559 return ret;
1560 }
1561 curr_tempo = val;
1562 }
1563 return (*(int *) arg = curr_tempo);
1564 }
1565 break;
1566
1567 case SNDCTL_SEQ_CTRLRATE:
1568 {
1569 int val;
1570
1571 val = *(int *) arg;
1572 if (val != 0) /* Can't change */
1573 return -EINVAL;
1574 return (*(int *) arg = ((curr_tempo * curr_timebase) + 30) / 60);
1575 }
1576 break;
1577
1578 case SNDCTL_SEQ_GETTIME:
1579 return (*(int *) arg = curr_ticks);
1580
1581 case SNDCTL_TMR_METRONOME:
1582 metronome_mode = *(int *) arg;
1583 setup_metronome(midi_dev);
1584 return 0;
1585
1586 default:;
1587 }
1588 return -EINVAL;
1589 }
1590
1591 static void mpu_timer_arm(int dev, long time)
1592 {
1593 if (time < 0)
1594 time = curr_ticks + 1;
1595 else if (time <= curr_ticks) /* It's the time */
1596 return;
1597 next_event_time = prev_event_time = time;
1598 return;
1599 }
1600
1601 static struct sound_timer_operations mpu_timer =
1602 {
1603 owner: THIS_MODULE,
1604 info: {"MPU-401 Timer", 0},
1605 priority: 10, /* Priority */
1606 devlink: 0, /* Local device link */
1607 open: mpu_timer_open,
1608 close: mpu_timer_close,
1609 event: mpu_timer_event,
1610 get_time: mpu_timer_get_time,
1611 ioctl: mpu_timer_ioctl,
1612 arm_timer: mpu_timer_arm
1613 };
1614
1615 static void mpu_timer_interrupt(void)
1616 {
1617 if (!timer_open)
1618 return;
1619
1620 if (!tmr_running)
1621 return;
1622
1623 curr_clocks++;
1624 curr_ticks = clocks2ticks(curr_clocks);
1625
1626 if (curr_ticks >= next_event_time)
1627 {
1628 next_event_time = (unsigned long) -1;
1629 sequencer_timer(0);
1630 }
1631 }
1632
1633 static void timer_ext_event(struct mpu_config *devc, int event, int parm)
1634 {
1635 int midi_dev = devc->devno;
1636
1637 if (!devc->timer_flag)
1638 return;
1639
1640 switch (event)
1641 {
1642 case TMR_CLOCK:
1643 printk("<MIDI clk>");
1644 break;
1645
1646 case TMR_START:
1647 printk("Ext MIDI start\n");
1648 if (!tmr_running)
1649 {
1650 if (timer_mode & TMR_EXTERNAL)
1651 {
1652 tmr_running = 1;
1653 setup_metronome(midi_dev);
1654 next_event_time = 0;
1655 STORE(SEQ_START_TIMER());
1656 }
1657 }
1658 break;
1659
1660 case TMR_STOP:
1661 printk("Ext MIDI stop\n");
1662 if (timer_mode & TMR_EXTERNAL)
1663 {
1664 tmr_running = 0;
1665 stop_metronome(midi_dev);
1666 STORE(SEQ_STOP_TIMER());
1667 }
1668 break;
1669
1670 case TMR_CONTINUE:
1671 printk("Ext MIDI continue\n");
1672 if (timer_mode & TMR_EXTERNAL)
1673 {
1674 tmr_running = 1;
1675 setup_metronome(midi_dev);
1676 STORE(SEQ_CONTINUE_TIMER());
1677 }
1678 break;
1679
1680 case TMR_SPP:
1681 printk("Songpos: %d\n", parm);
1682 if (timer_mode & TMR_EXTERNAL)
1683 {
1684 STORE(SEQ_SONGPOS(parm));
1685 }
1686 break;
1687 }
1688 }
1689
1690 static int mpu_timer_init(int midi_dev)
1691 {
1692 struct mpu_config *devc;
1693 int n;
1694
1695 devc = &dev_conf[midi_dev];
1696
1697 if (timer_initialized)
1698 return -1; /* There is already a similar timer */
1699
1700 timer_initialized = 1;
1701
1702 mpu_timer.devlink = midi_dev;
1703 dev_conf[midi_dev].timer_flag = 1;
1704
1705 n = sound_alloc_timerdev();
1706 if (n == -1)
1707 n = 0;
1708 sound_timer_devs[n] = &mpu_timer;
1709
1710 if (devc->version < 0x20) /* Original MPU-401 */
1711 timer_caps = TMR_INTERNAL | TMR_EXTERNAL | TMR_MODE_FSK | TMR_MODE_MIDI;
1712 else
1713 {
1714 /*
1715 * The version number 2.0 is used (at least) by the
1716 * MusicQuest cards and the Roland Super-MPU.
1717 *
1718 * MusicQuest has given a special meaning to the bits of the
1719 * revision number. The Super-MPU returns 0.
1720 */
1721
1722 if (devc->revision)
1723 timer_caps |= TMR_EXTERNAL | TMR_MODE_MIDI;
1724
1725 if (devc->revision & 0x02)
1726 timer_caps |= TMR_MODE_CLS;
1727
1728
1729 if (devc->revision & 0x40)
1730 max_timebase = 10; /* Has the 216 and 240 ppqn modes */
1731 }
1732
1733 timer_mode = (TMR_INTERNAL | TMR_MODE_MIDI) & timer_caps;
1734 return n;
1735
1736 }
1737
1738 EXPORT_SYMBOL(probe_mpu401);
1739 EXPORT_SYMBOL(attach_mpu401);
1740 EXPORT_SYMBOL(unload_mpu401);
1741 EXPORT_SYMBOL(intchk_mpu401);
1742 EXPORT_SYMBOL(mpuintr);
1743
1744 static struct address_info cfg;
1745
1746 static int __initdata io = -1;
1747 static int __initdata irq = -1;
1748
1749 MODULE_PARM(irq, "i");
1750 MODULE_PARM(io, "i");
1751
1752 int __init init_mpu401(void)
1753 {
1754 /* Can be loaded either for module use or to provide functions
1755 to others */
1756 if (io != -1 && irq != -1) {
1757 cfg.irq = irq;
1758 cfg.io_base = io;
1759 if (probe_mpu401(&cfg) == 0)
1760 return -ENODEV;
1761 attach_mpu401(&cfg, THIS_MODULE);
1762 }
1763
1764 return 0;
1765 }
1766
1767 void __exit cleanup_mpu401(void)
1768 {
1769 if (io != -1 && irq != -1) {
1770 /* Check for use by, for example, sscape driver */
1771 unload_mpu401(&cfg);
1772 }
1773 }
1774
1775 module_init(init_mpu401);
1776 module_exit(cleanup_mpu401);
1777
1778 #ifndef MODULE
1779 static int __init setup_mpu401(char *str)
1780 {
1781 /* io, irq */
1782 int ints[3];
1783
1784 str = get_options(str, ARRAY_SIZE(ints), ints);
1785
1786 io = ints[1];
1787 irq = ints[2];
1788
1789 return 1;
1790 }
1791
1792 __setup("mpu401=", setup_mpu401);
1793 #endif
1794 MODULE_LICENSE("GPL");
Mirror of the linux-mips.org kernel tree