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