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