pci: hda: Limit sleep time when codec is off
[linux-3.10.git] / sound / oss / mpu401.c
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");