Root/
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"); |
1807 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9