drivers/sound/mpu401.c

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

DEFINITIONS
