Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mpu401.c
Go to the documentation of this file.
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");
Generated on Thu Jan 10 2013 15:04:13 for Linux Kernel by   doxygen 1.8.2