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         unsigned long   flags;
 571         struct mpu_config *devc;
 572
 573         devc = &dev_conf[dev];
 574
 575         if (devc->uart_mode)    /*
 576                                  * Not possible in UART mode
 577                                  */
 578         {
 579                 printk(KERN_WARNING "mpu401: commands not possible in the UART mode\n");
 580                 return -EINVAL;
 581         }
 582         /*
 583          * Test for input since pending input seems to block the output.
 584          */
 585         if (input_avail(devc))
 586                 mpu401_input_loop(devc);
 587
 588         /*
 589          * Sometimes it takes about 50000 loops before the output becomes ready
 590          * (After reset). Normally it takes just about 10 loops.
 591          */
 592
 593         timeout = 50000;
 594 retry:
 595         if (timeout-- <= 0)
 596         {
 597                 printk(KERN_WARNING "mpu401: Command (0x%x) timeout\n", (int) cmd->cmd);
 598                 return -EIO;
 599         }
 600         spin_lock_irqsave(&devc->lock,flags);
 601
 602         if (!output_ready(devc))
 603         {
 604                 spin_unlock_irqrestore(&devc->lock,flags);
 605                 goto retry;
 606         }
 607         write_command(devc, cmd->cmd);
 608
 609         ok = 0;
 610         for (timeout = 50000; timeout > 0 && !ok; timeout--)
 611         {
 612                 if (input_avail(devc))
 613                 {
 614                         if (devc->opened && devc->mode == MODE_SYNTH)
 615                         {
 616                                 if (mpu_input_scanner(devc, read_data(devc)) == MPU_ACK)
 617                                         ok = 1;
 618                         }
 619                         else
 620                         {
 621                                 /* Device is not currently open. Use simpler method */
 622                                 if (read_data(devc) == MPU_ACK)
 623                                         ok = 1;
 624                         }
 625                 }
 626         }
 627         if (!ok)
 628         {
 629                 spin_unlock_irqrestore(&devc->lock,flags);
 630                 return -EIO;
 631         }
 632         if (cmd->nr_args)
 633         {
 634                 for (i = 0; i < cmd->nr_args; i++)
 635                 {
 636                         for (timeout = 3000; timeout > 0 && !output_ready(devc); timeout--);
 637
 638                         if (!mpu401_out(dev, cmd->data[i]))
 639                         {
 640                                 spin_unlock_irqrestore(&devc->lock,flags);
 641                                 printk(KERN_WARNING "mpu401: Command (0x%x), parm send failed.\n", (int) cmd->cmd);
 642                                 return -EIO;
 643                         }
 644                 }
 645         }
 646         cmd->data[0] = 0;
 647
 648         if (cmd->nr_returns)
 649         {
 650                 for (i = 0; i < cmd->nr_returns; i++)
 651                 {
 652                         ok = 0;
 653                         for (timeout = 5000; timeout > 0 && !ok; timeout--)
 654                                 if (input_avail(devc))
 655                                 {
 656                                         cmd->data[i] = read_data(devc);
 657                                         ok = 1;
 658                                 }
 659                         if (!ok)
 660                         {
 661                                 spin_unlock_irqrestore(&devc->lock,flags);
 662                                 return -EIO;
 663                         }
 664                 }
 665         }
 666         spin_unlock_irqrestore(&devc->lock,flags);
 667         return 0;
 668 }
 669
 670 static int mpu_cmd(int dev, int cmd, int data)
 671 {
 672         int ret;
 673
 674         static mpu_command_rec rec;
 675
 676         rec.cmd = cmd & 0xff;
 677         rec.nr_args = ((cmd & 0xf0) == 0xE0);
 678         rec.nr_returns = ((cmd & 0xf0) == 0xA0);
 679         rec.data[0] = data & 0xff;
 680
 681         if ((ret = mpu401_command(dev, &rec)) < 0)
 682                 return ret;
 683         return (unsigned char) rec.data[0];
 684 }
 685
 686 static int mpu401_prefix_cmd(int dev, unsigned char status)
 687 {
 688         struct mpu_config *devc = &dev_conf[dev];
 689
 690         if (devc->uart_mode)
 691                 return 1;
 692
 693         if (status < 0xf0)
 694         {
 695                 if (mpu_cmd(dev, 0xD0, 0) < 0)
 696                         return 0;
 697                 return 1;
 698         }
 699         switch (status)
 700         {
 701                 case 0xF0:
 702                         if (mpu_cmd(dev, 0xDF, 0) < 0)
 703                                 return 0;
 704                         return 1;
 705
 706                 default:
 707                         return 0;
 708         }
 709 }
 710
 711 static int mpu401_start_read(int dev)
 712 {
 713         return 0;
 714 }
 715
 716 static int mpu401_end_read(int dev)
 717 {
 718         return 0;
 719 }
 720
 721 static int mpu401_ioctl(int dev, unsigned cmd, void __user *arg)
 722 {
 723         struct mpu_config *devc;
 724         mpu_command_rec rec;
 725         int val, ret;
 726
 727         devc = &dev_conf[dev];
 728         switch (cmd)
 729         {
 730                 case SNDCTL_MIDI_MPUMODE:
 731                         if (!(devc->capabilities & MPU_CAP_INTLG)) { /* No intelligent mode */
 732                                 printk(KERN_WARNING "mpu401: Intelligent mode not supported by the HW\n");
 733                                 return -EINVAL;
 734                         }
 735                         if (get_user(val, (int __user *)arg))
 736                                 return -EFAULT;
 737                         set_uart_mode(dev, devc, !val);
 738                         return 0;
 739
 740                 case SNDCTL_MIDI_MPUCMD:
 741                         if (copy_from_user(&rec, arg, sizeof(rec)))
 742                                 return -EFAULT;
 743                         if ((ret = mpu401_command(dev, &rec)) < 0)
 744                                 return ret;
 745                         if (copy_to_user(arg, &rec, sizeof(rec)))
 746                                 return -EFAULT;
 747                         return 0;
 748
 749                 default:
 750                         return -EINVAL;
 751         }
 752 }
 753
 754 static void mpu401_kick(int dev)
 755 {
 756 }
 757
 758 static int mpu401_buffer_status(int dev)
 759 {
 760         return 0;               /*
 761                                  * No data in buffers
 762                                  */
 763 }
 764
 765 static int mpu_synth_ioctl(int dev, unsigned int cmd, void __user *arg)
 766 {
 767         int midi_dev;
 768         struct mpu_config *devc;
 769
 770         midi_dev = synth_devs[dev]->midi_dev;
 771
 772         if (midi_dev < 0 || midi_dev >= num_midis || midi_devs[midi_dev] == NULL)
 773                 return -ENXIO;
 774
 775         devc = &dev_conf[midi_dev];
 776
 777         switch (cmd)
 778         {
 779
 780                 case SNDCTL_SYNTH_INFO:
 781                         if (copy_to_user(arg, &mpu_synth_info[midi_dev],
 782                                         sizeof(struct synth_info)))
 783                                 return -EFAULT;
 784                         return 0;
 785
 786                 case SNDCTL_SYNTH_MEMAVL:
 787                         return 0x7fffffff;
 788
 789                 default:
 790                         return -EINVAL;
 791         }
 792 }
 793
 794 static int mpu_synth_open(int dev, int mode)
 795 {
 796         int midi_dev, err;
 797         struct mpu_config *devc;
 798         struct coproc_operations *coprocessor;
 799
 800         midi_dev = synth_devs[dev]->midi_dev;
 801
 802         if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
 803                 return -ENXIO;
 804
 805         devc = &dev_conf[midi_dev];
 806
 807         /*
 808          *  Verify that the device is really running.
 809          *  Some devices (such as Ensoniq SoundScape don't
 810          *  work before the on board processor (OBP) is initialized
 811          *  by downloading its microcode.
 812          */
 813
 814         if (!devc->initialized)
 815         {
 816                 if (mpu401_status(devc) == 0xff)        /* Bus float */
 817                 {
 818                         printk(KERN_ERR "mpu401: Device not initialized properly\n");
 819                         return -EIO;
 820                 }
 821                 reset_mpu401(devc);
 822         }
 823         if (devc->opened)
 824                 return -EBUSY;
 825         devc->mode = MODE_SYNTH;
 826         devc->synthno = dev;
 827
 828         devc->inputintr = NULL;
 829
 830         coprocessor = midi_devs[midi_dev]->coproc;
 831         if (coprocessor) {
 832                 if (!try_module_get(coprocessor->owner))
 833                         return -ENODEV;
 834
 835                 if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
 836                 {
 837                         printk(KERN_WARNING "mpu401: Can't access coprocessor device\n");
 838                         return err;
 839                 }
 840         }
 841         devc->opened = mode;
 842         reset_mpu401(devc);
 843
 844         if (mode & OPEN_READ)
 845         {
 846                 mpu_cmd(midi_dev, 0x8B, 0);     /* Enable data in stop mode */
 847                 mpu_cmd(midi_dev, 0x34, 0);     /* Return timing bytes in stop mode */
 848                 mpu_cmd(midi_dev, 0x87, 0);     /* Enable pitch & controller */
 849         }
 850         return 0;
 851 }
 852
 853 static void mpu_synth_close(int dev)
 854 {
 855         int midi_dev;
 856         struct mpu_config *devc;
 857         struct coproc_operations *coprocessor;
 858
 859         midi_dev = synth_devs[dev]->midi_dev;
 860
 861         devc = &dev_conf[midi_dev];
 862         mpu_cmd(midi_dev, 0x15, 0);     /* Stop recording, playback and MIDI */
 863         mpu_cmd(midi_dev, 0x8a, 0);     /* Disable data in stopped mode */
 864
 865         devc->inputintr = NULL;
 866
 867         coprocessor = midi_devs[midi_dev]->coproc;
 868         if (coprocessor) {
 869                 coprocessor->close(coprocessor->devc, COPR_MIDI);
 870                 module_put(coprocessor->owner);
 871         }
 872         devc->opened = 0;
 873         devc->mode = 0;
 874 }
 875
 876 #define MIDI_SYNTH_NAME "MPU-401 UART Midi"
 877 #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
 878 #include "midi_synth.h"
 879
 880 static struct synth_operations mpu401_synth_proto =
 881 {
 882         .owner          = THIS_MODULE,
 883         .id             = "MPU401",
 884         .info           = NULL,
 885         .midi_dev       = 0,
 886         .synth_type     = SYNTH_TYPE_MIDI,
 887         .synth_subtype  = 0,
 888         .open           = mpu_synth_open,
 889         .close          = mpu_synth_close,
 890         .ioctl          = mpu_synth_ioctl,
 891         .kill_note      = midi_synth_kill_note,
 892         .start_note     = midi_synth_start_note,
 893         .set_instr      = midi_synth_set_instr,
 894         .reset          = midi_synth_reset,
 895         .hw_control     = midi_synth_hw_control,
 896         .load_patch     = midi_synth_load_patch,
 897         .aftertouch     = midi_synth_aftertouch,
 898         .controller     = midi_synth_controller,
 899         .panning        = midi_synth_panning,
 900         .bender         = midi_synth_bender,
 901         .setup_voice    = midi_synth_setup_voice,
 902         .send_sysex     = midi_synth_send_sysex
 903 };
 904
 905 static struct synth_operations *mpu401_synth_operations[MAX_MIDI_DEV];
 906
 907 static struct midi_operations mpu401_midi_proto =
 908 {
 909         .owner          = THIS_MODULE,
 910         .info           = {"MPU-401 Midi", 0, MIDI_CAP_MPU401, SNDCARD_MPU401},
 911         .in_info        = {0},
 912         .open           = mpu401_open,
 913         .close          = mpu401_close,
 914         .ioctl          = mpu401_ioctl,
 915         .outputc        = mpu401_out,
 916         .start_read     = mpu401_start_read,
 917         .end_read       = mpu401_end_read,
 918         .kick           = mpu401_kick,
 919         .buffer_status  = mpu401_buffer_status,
 920         .prefix_cmd     = mpu401_prefix_cmd
 921 };
 922
 923 static struct midi_operations mpu401_midi_operations[MAX_MIDI_DEV];
 924
 925 static void mpu401_chk_version(int n, struct mpu_config *devc)
 926 {
 927         int tmp;
 928
 929         devc->version = devc->revision = 0;
 930
 931         tmp = mpu_cmd(n, 0xAC, 0);
 932         if (tmp < 0)
 933                 return;
 934         if ((tmp & 0xf0) > 0x20)        /* Why it's larger than 2.x ??? */
 935                 return;
 936         devc->version = tmp;
 937
 938         if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0) {
 939                 devc->version = 0;
 940                 return;
 941         }
 942         devc->revision = tmp;
 943 }
 944
 945 int attach_mpu401(struct address_info *hw_config, struct module *owner)
 946 {
 947         unsigned long flags;
 948         char revision_char;
 949
 950         int m, ret;
 951         struct mpu_config *devc;
 952
 953         hw_config->slots[1] = -1;
 954         m = sound_alloc_mididev();
 955         if (m == -1)
 956         {
 957                 printk(KERN_WARNING "MPU-401: Too many midi devices detected\n");
 958                 ret = -ENOMEM;
 959                 goto out_err;
 960         }
 961         devc = &dev_conf[m];
 962         devc->base = hw_config->io_base;
 963         devc->osp = hw_config->osp;
 964         devc->irq = hw_config->irq;
 965         devc->opened = 0;
 966         devc->uart_mode = 0;
 967         devc->initialized = 0;
 968         devc->version = 0;
 969         devc->revision = 0;
 970         devc->capabilities = 0;
 971         devc->timer_flag = 0;
 972         devc->m_busy = 0;
 973         devc->m_state = ST_INIT;
 974         devc->shared_irq = hw_config->always_detect;
 975         devc->irq = hw_config->irq;
 976         spin_lock_init(&devc->lock);
 977
 978         if (devc->irq < 0)
 979         {
 980                 devc->irq *= -1;
 981                 devc->shared_irq = 1;
 982         }
 983
 984         if (!hw_config->always_detect)
 985         {
 986                 /* Verify the hardware again */
 987                 if (!reset_mpu401(devc))
 988                 {
 989                         printk(KERN_WARNING "mpu401: Device didn't respond\n");
 990                         ret = -ENODEV;
 991                         goto out_mididev;
 992                 }
 993                 if (!devc->shared_irq)
 994                 {
 995                         if (request_irq(devc->irq, mpuintr, 0, "mpu401",
 996                                         hw_config) < 0)
 997                         {
 998                                 printk(KERN_WARNING "mpu401: Failed to allocate IRQ%d\n", devc->irq);
 999                                 ret = -ENOMEM;
1000                                 goto out_mididev;
1001                         }
1002                 }
1003                 spin_lock_irqsave(&devc->lock,flags);
1004                 mpu401_chk_version(m, devc);
1005                 if (devc->version == 0)
1006                         mpu401_chk_version(m, devc);
1007                 spin_unlock_irqrestore(&devc->lock, flags);
1008         }
1009
1010         if (devc->version != 0)
1011                 if (mpu_cmd(m, 0xC5, 0) >= 0)   /* Set timebase OK */
1012                         if (mpu_cmd(m, 0xE0, 120) >= 0)         /* Set tempo OK */
1013                                 devc->capabilities |= MPU_CAP_INTLG;    /* Supports intelligent mode */
1014
1015
1016         mpu401_synth_operations[m] = kmalloc(sizeof(struct synth_operations), GFP_KERNEL);
1017
1018         if (mpu401_synth_operations[m] == NULL)
1019         {
1020                 printk(KERN_ERR "mpu401: Can't allocate memory\n");
1021                 ret = -ENOMEM;
1022                 goto out_irq;
1023         }
1024         if (!(devc->capabilities & MPU_CAP_INTLG))      /* No intelligent mode */
1025         {
1026                 memcpy((char *) mpu401_synth_operations[m],
1027                         (char *) &std_midi_synth,
1028                          sizeof(struct synth_operations));
1029         }
1030         else
1031         {
1032                 memcpy((char *) mpu401_synth_operations[m],
1033                         (char *) &mpu401_synth_proto,
1034                          sizeof(struct synth_operations));
1035         }
1036         if (owner)
1037                 mpu401_synth_operations[m]->owner = owner;
1038
1039         memcpy((char *) &mpu401_midi_operations[m],
1040                (char *) &mpu401_midi_proto,
1041                sizeof(struct midi_operations));
1042
1043         mpu401_midi_operations[m].converter = mpu401_synth_operations[m];
1044
1045         memcpy((char *) &mpu_synth_info[m],
1046                (char *) &mpu_synth_info_proto,
1047                sizeof(struct synth_info));
1048
1049         n_mpu_devs++;
1050
1051         if (devc->version == 0x20 && devc->revision >= 0x07)    /* MusicQuest interface */
1052         {
1053                 int ports = (devc->revision & 0x08) ? 32 : 16;
1054
1055                 devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_SMPTE |
1056                                 MPU_CAP_CLS | MPU_CAP_2PORT;
1057
1058                 revision_char = (devc->revision == 0x7f) ? 'M' : ' ';
1059                 sprintf(mpu_synth_info[m].name, "MQX-%d%c MIDI Interface #%d",
1060                                 ports,
1061                                 revision_char,
1062                                 n_mpu_devs);
1063         }
1064         else
1065         {
1066                 revision_char = devc->revision ? devc->revision + '@' : ' ';
1067                 if ((int) devc->revision > ('Z' - '@'))
1068                         revision_char = '+';
1069
1070                 devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_FSK;
1071
1072                 if (hw_config->name)
1073                         sprintf(mpu_synth_info[m].name, "%s (MPU401)", hw_config->name);
1074                 else
1075                         sprintf(mpu_synth_info[m].name,
1076                                 "MPU-401 %d.%d%c MIDI #%d",
1077                                 (int) (devc->version & 0xf0) >> 4,
1078                                 devc->version & 0x0f,
1079                                 revision_char,
1080                                 n_mpu_devs);
1081         }
1082
1083         strcpy(mpu401_midi_operations[m].info.name,
1084                mpu_synth_info[m].name);
1085
1086         conf_printf(mpu_synth_info[m].name, hw_config);
1087
1088         mpu401_synth_operations[m]->midi_dev = devc->devno = m;
1089         mpu401_synth_operations[devc->devno]->info = &mpu_synth_info[devc->devno];
1090
1091         if (devc->capabilities & MPU_CAP_INTLG)         /* Intelligent mode */
1092                 hw_config->slots[2] = mpu_timer_init(m);
1093
1094         midi_devs[m] = &mpu401_midi_operations[devc->devno];
1095
1096         if (owner)
1097                 midi_devs[m]->owner = owner;
1098
1099         hw_config->slots[1] = m;
1100         sequencer_init();
1101
1102         return 0;
1103
1104 out_irq:
1105         free_irq(devc->irq, hw_config);
1106 out_mididev:
1107         sound_unload_mididev(m);
1108 out_err:
1109         release_region(hw_config->io_base, 2);
1110         return ret;
1111 }
1112
1113 static int reset_mpu401(struct mpu_config *devc)
1114 {
1115         unsigned long flags;
1116         int ok, timeout, n;
1117         int timeout_limit;
1118
1119         /*
1120          * Send the RESET command. Try again if no success at the first time.
1121          * (If the device is in the UART mode, it will not ack the reset cmd).
1122          */
1123
1124         ok = 0;
1125
1126         timeout_limit = devc->initialized ? 30000 : 100000;
1127         devc->initialized = 1;
1128
1129         for (n = 0; n < 2 && !ok; n++)
1130         {
1131                 for (timeout = timeout_limit; timeout > 0 && !ok; timeout--)
1132                           ok = output_ready(devc);
1133
1134                 write_command(devc, MPU_RESET); /*
1135                                                            * Send MPU-401 RESET Command
1136                                                          */
1137
1138                 /*
1139                  * Wait at least 25 msec. This method is not accurate so let's make the
1140                  * loop bit longer. Cannot sleep since this is called during boot.
1141                  */
1142
1143                 for (timeout = timeout_limit * 2; timeout > 0 && !ok; timeout--)
1144                 {
1145                         spin_lock_irqsave(&devc->lock,flags);
1146                         if (input_avail(devc))
1147                                 if (read_data(devc) == MPU_ACK)
1148                                         ok = 1;
1149                         spin_unlock_irqrestore(&devc->lock,flags);
1150                 }
1151
1152         }
1153
1154         devc->m_state = ST_INIT;
1155         devc->m_ptr = 0;
1156         devc->m_left = 0;
1157         devc->last_status = 0;
1158         devc->uart_mode = 0;
1159
1160         return ok;
1161 }
1162
1163 static void set_uart_mode(int dev, struct mpu_config *devc, int arg)
1164 {
1165         if (!arg && (devc->capabilities & MPU_CAP_INTLG))
1166                 return;
1167         if ((devc->uart_mode == 0) == (arg == 0))
1168                 return;         /* Already set */
1169         reset_mpu401(devc);     /* This exits the uart mode */
1170
1171         if (arg)
1172         {
1173                 if (mpu_cmd(dev, UART_MODE_ON, 0) < 0)
1174                 {
1175                         printk(KERN_ERR "mpu401: Can't enter UART mode\n");
1176                         devc->uart_mode = 0;
1177                         return;
1178                 }
1179         }
1180         devc->uart_mode = arg;
1181
1182 }
1183
1184 int probe_mpu401(struct address_info *hw_config, struct resource *ports)
1185 {
1186         int ok = 0;
1187         struct mpu_config tmp_devc;
1188
1189         tmp_devc.base = hw_config->io_base;
1190         tmp_devc.irq = hw_config->irq;
1191         tmp_devc.initialized = 0;
1192         tmp_devc.opened = 0;
1193         tmp_devc.osp = hw_config->osp;
1194
1195         if (hw_config->always_detect)
1196                 return 1;
1197
1198         if (inb(hw_config->io_base + 1) == 0xff)
1199         {
1200                 DDB(printk("MPU401: Port %x looks dead.\n", hw_config->io_base));
1201                 return 0;       /* Just bus float? */
1202         }
1203         ok = reset_mpu401(&tmp_devc);
1204
1205         if (!ok)
1206         {
1207                 DDB(printk("MPU401: Reset failed on port %x\n", hw_config->io_base));
1208         }
1209         return ok;
1210 }
1211
1212 void unload_mpu401(struct address_info *hw_config)
1213 {
1214         void *p;
1215         int n=hw_config->slots[1];
1216
1217         if (n != -1) {
1218                 release_region(hw_config->io_base, 2);
1219                 if (hw_config->always_detect == 0 && hw_config->irq > 0)
1220                         free_irq(hw_config->irq, hw_config);
1221                 p=mpu401_synth_operations[n];
1222                 sound_unload_mididev(n);
1223                 sound_unload_timerdev(hw_config->slots[2]);
1224                 kfree(p);
1225         }
1226 }
1227
1228 /*****************************************************
1229  *      Timer stuff
1230  ****************************************************/
1231
1232 static volatile int timer_initialized = 0, timer_open = 0, tmr_running = 0;
1233 static volatile int curr_tempo, curr_timebase, hw_timebase;
1234 static int      max_timebase = 8;       /* 8*24=192 ppqn */
1235 static volatile unsigned long next_event_time;
1236 static volatile unsigned long curr_ticks, curr_clocks;
1237 static unsigned long prev_event_time;
1238 static int      metronome_mode;
1239
1240 static unsigned long clocks2ticks(unsigned long clocks)
1241 {
1242         /*
1243          * The MPU-401 supports just a limited set of possible timebase values.
1244          * Since the applications require more choices, the driver has to
1245          * program the HW to do its best and to convert between the HW and
1246          * actual timebases.
1247          */
1248         return ((clocks * curr_timebase) + (hw_timebase / 2)) / hw_timebase;
1249 }
1250
1251 static void set_timebase(int midi_dev, int val)
1252 {
1253         int hw_val;
1254
1255         if (val < 48)
1256                 val = 48;
1257         if (val > 1000)
1258                 val = 1000;
1259
1260         hw_val = val;
1261         hw_val = (hw_val + 12) / 24;
1262         if (hw_val > max_timebase)
1263                 hw_val = max_timebase;
1264
1265         if (mpu_cmd(midi_dev, 0xC0 | (hw_val & 0x0f), 0) < 0)
1266         {
1267                 printk(KERN_WARNING "mpu401: Can't set HW timebase to %d\n", hw_val * 24);
1268                 return;
1269         }
1270         hw_timebase = hw_val * 24;
1271         curr_timebase = val;
1272
1273 }
1274
1275 static void tmr_reset(struct mpu_config *devc)
1276 {
1277         unsigned long flags;
1278
1279         spin_lock_irqsave(&devc->lock,flags);
1280         next_event_time = (unsigned long) -1;
1281         prev_event_time = 0;
1282         curr_ticks = curr_clocks = 0;
1283         spin_unlock_irqrestore(&devc->lock,flags);
1284 }
1285
1286 static void set_timer_mode(int midi_dev)
1287 {
1288         if (timer_mode & TMR_MODE_CLS)
1289                 mpu_cmd(midi_dev, 0x3c, 0);     /* Use CLS sync */
1290         else if (timer_mode & TMR_MODE_SMPTE)
1291                 mpu_cmd(midi_dev, 0x3d, 0);     /* Use SMPTE sync */
1292
1293         if (timer_mode & TMR_INTERNAL)
1294         {
1295                   mpu_cmd(midi_dev, 0x80, 0);   /* Use MIDI sync */
1296         }
1297         else
1298         {
1299                 if (timer_mode & (TMR_MODE_MIDI | TMR_MODE_CLS))
1300                 {
1301                         mpu_cmd(midi_dev, 0x82, 0);             /* Use MIDI sync */
1302                         mpu_cmd(midi_dev, 0x91, 0);             /* Enable ext MIDI ctrl */
1303                 }
1304                 else if (timer_mode & TMR_MODE_FSK)
1305                         mpu_cmd(midi_dev, 0x81, 0);     /* Use FSK sync */
1306         }
1307 }
1308
1309 static void stop_metronome(int midi_dev)
1310 {
1311         mpu_cmd(midi_dev, 0x84, 0);     /* Disable metronome */
1312 }
1313
1314 static void setup_metronome(int midi_dev)
1315 {
1316         int numerator, denominator;
1317         int clks_per_click, num_32nds_per_beat;
1318         int beats_per_measure;
1319
1320         numerator = ((unsigned) metronome_mode >> 24) & 0xff;
1321         denominator = ((unsigned) metronome_mode >> 16) & 0xff;
1322         clks_per_click = ((unsigned) metronome_mode >> 8) & 0xff;
1323         num_32nds_per_beat = (unsigned) metronome_mode & 0xff;
1324         beats_per_measure = (numerator * 4) >> denominator;
1325
1326         if (!metronome_mode)
1327                 mpu_cmd(midi_dev, 0x84, 0);     /* Disable metronome */
1328         else
1329         {
1330                 mpu_cmd(midi_dev, 0xE4, clks_per_click);
1331                 mpu_cmd(midi_dev, 0xE6, beats_per_measure);
1332                 mpu_cmd(midi_dev, 0x83, 0);     /* Enable metronome without accents */
1333         }
1334 }
1335
1336 static int mpu_start_timer(int midi_dev)
1337 {
1338         struct mpu_config *devc= &dev_conf[midi_dev];
1339
1340         tmr_reset(devc);
1341         set_timer_mode(midi_dev);
1342
1343         if (tmr_running)
1344                 return TIMER_NOT_ARMED;         /* Already running */
1345
1346         if (timer_mode & TMR_INTERNAL)
1347         {
1348                 mpu_cmd(midi_dev, 0x02, 0);     /* Send MIDI start */
1349                 tmr_running = 1;
1350                 return TIMER_NOT_ARMED;
1351         }
1352         else
1353         {
1354                 mpu_cmd(midi_dev, 0x35, 0);     /* Enable mode messages to PC */
1355                 mpu_cmd(midi_dev, 0x38, 0);     /* Enable sys common messages to PC */
1356                 mpu_cmd(midi_dev, 0x39, 0);     /* Enable real time messages to PC */
1357                 mpu_cmd(midi_dev, 0x97, 0);     /* Enable system exclusive messages to PC */
1358         }
1359         return TIMER_ARMED;
1360 }
1361
1362 static int mpu_timer_open(int dev, int mode)
1363 {
1364         int midi_dev = sound_timer_devs[dev]->devlink;
1365         struct mpu_config *devc= &dev_conf[midi_dev];
1366
1367         if (timer_open)
1368                 return -EBUSY;
1369
1370         tmr_reset(devc);
1371         curr_tempo = 50;
1372         mpu_cmd(midi_dev, 0xE0, 50);
1373         curr_timebase = hw_timebase = 120;
1374         set_timebase(midi_dev, 120);
1375         timer_open = 1;
1376         metronome_mode = 0;
1377         set_timer_mode(midi_dev);
1378
1379         mpu_cmd(midi_dev, 0xe7, 0x04);  /* Send all clocks to host */
1380         mpu_cmd(midi_dev, 0x95, 0);     /* Enable clock to host */
1381
1382         return 0;
1383 }
1384
1385 static void mpu_timer_close(int dev)
1386 {
1387         int midi_dev = sound_timer_devs[dev]->devlink;
1388
1389         timer_open = tmr_running = 0;
1390         mpu_cmd(midi_dev, 0x15, 0);     /* Stop all */
1391         mpu_cmd(midi_dev, 0x94, 0);     /* Disable clock to host */
1392         mpu_cmd(midi_dev, 0x8c, 0);     /* Disable measure end messages to host */
1393         stop_metronome(midi_dev);
1394 }
1395
1396 static int mpu_timer_event(int dev, unsigned char *event)
1397 {
1398         unsigned char command = event[1];
1399         unsigned long parm = *(unsigned int *) &event[4];
1400         int midi_dev = sound_timer_devs[dev]->devlink;
1401
1402         switch (command)
1403         {
1404                 case TMR_WAIT_REL:
1405                         parm += prev_event_time;
1406                 case TMR_WAIT_ABS:
1407                         if (parm > 0)
1408                         {
1409                                 long time;
1410
1411                                 if (parm <= curr_ticks) /* It's the time */
1412                                         return TIMER_NOT_ARMED;
1413                                 time = parm;
1414                                 next_event_time = prev_event_time = time;
1415
1416                                 return TIMER_ARMED;
1417                         }
1418                         break;
1419
1420                 case TMR_START:
1421                         if (tmr_running)
1422                                 break;
1423                         return mpu_start_timer(midi_dev);
1424
1425                 case TMR_STOP:
1426                         mpu_cmd(midi_dev, 0x01, 0);     /* Send MIDI stop */
1427                         stop_metronome(midi_dev);
1428                         tmr_running = 0;
1429                         break;
1430
1431                 case TMR_CONTINUE:
1432                         if (tmr_running)
1433                                 break;
1434                         mpu_cmd(midi_dev, 0x03, 0);     /* Send MIDI continue */
1435                         setup_metronome(midi_dev);
1436                         tmr_running = 1;
1437                         break;
1438
1439                 case TMR_TEMPO:
1440                         if (parm)
1441                         {
1442                                 if (parm < 8)
1443                                         parm = 8;
1444                                 if (parm > 250)
1445                                         parm = 250;
1446                                 if (mpu_cmd(midi_dev, 0xE0, parm) < 0)
1447                                         printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) parm);
1448                                 curr_tempo = parm;
1449                         }
1450                         break;
1451
1452                 case TMR_ECHO:
1453                         seq_copy_to_input(event, 8);
1454                         break;
1455
1456                 case TMR_TIMESIG:
1457                         if (metronome_mode)     /* Metronome enabled */
1458                         {
1459                                 metronome_mode = parm;
1460                                 setup_metronome(midi_dev);
1461                         }
1462                         break;
1463
1464                 default:;
1465         }
1466         return TIMER_NOT_ARMED;
1467 }
1468
1469 static unsigned long mpu_timer_get_time(int dev)
1470 {
1471         if (!timer_open)
1472                 return 0;
1473
1474         return curr_ticks;
1475 }
1476
1477 static int mpu_timer_ioctl(int dev, unsigned int command, void __user *arg)
1478 {
1479         int midi_dev = sound_timer_devs[dev]->devlink;
1480         int __user *p = (int __user *)arg;
1481
1482         switch (command)
1483         {
1484                 case SNDCTL_TMR_SOURCE:
1485                         {
1486                                 int parm;
1487
1488                                 if (get_user(parm, p))
1489                                         return -EFAULT;
1490                                 parm &= timer_caps;
1491
1492                                 if (parm != 0)
1493                                 {
1494                                         timer_mode = parm;
1495
1496                                         if (timer_mode & TMR_MODE_CLS)
1497                                                 mpu_cmd(midi_dev, 0x3c, 0);             /* Use CLS sync */
1498                                         else if (timer_mode & TMR_MODE_SMPTE)
1499                                                 mpu_cmd(midi_dev, 0x3d, 0);             /* Use SMPTE sync */
1500                                 }
1501                                 if (put_user(timer_mode, p))
1502                                         return -EFAULT;
1503                                 return timer_mode;
1504                         }
1505                         break;
1506
1507                 case SNDCTL_TMR_START:
1508                         mpu_start_timer(midi_dev);
1509                         return 0;
1510
1511                 case SNDCTL_TMR_STOP:
1512                         tmr_running = 0;
1513                         mpu_cmd(midi_dev, 0x01, 0);     /* Send MIDI stop */
1514                         stop_metronome(midi_dev);
1515                         return 0;
1516
1517                 case SNDCTL_TMR_CONTINUE:
1518                         if (tmr_running)
1519                                 return 0;
1520                         tmr_running = 1;
1521                         mpu_cmd(midi_dev, 0x03, 0);     /* Send MIDI continue */
1522                         return 0;
1523
1524                 case SNDCTL_TMR_TIMEBASE:
1525                         {
1526                                 int val;
1527                                 if (get_user(val, p))
1528                                         return -EFAULT;
1529                                 if (val)
1530                                         set_timebase(midi_dev, val);
1531                                 if (put_user(curr_timebase, p))
1532                                         return -EFAULT;
1533                                 return curr_timebase;
1534                         }
1535                         break;
1536
1537                 case SNDCTL_TMR_TEMPO:
1538                         {
1539                                 int val;
1540                                 int ret;
1541
1542                                 if (get_user(val, p))
1543                                         return -EFAULT;
1544
1545                                 if (val)
1546                                 {
1547                                         if (val < 8)
1548                                                 val = 8;
1549                                         if (val > 250)
1550                                                 val = 250;
1551                                         if ((ret = mpu_cmd(midi_dev, 0xE0, val)) < 0)
1552                                         {
1553                                                 printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) val);
1554                                                 return ret;
1555                                         }
1556                                         curr_tempo = val;
1557                                 }
1558                                 if (put_user(curr_tempo, p))
1559                                         return -EFAULT;
1560                                 return curr_tempo;
1561                         }
1562                         break;
1563
1564                 case SNDCTL_SEQ_CTRLRATE:
1565                         {
1566                                 int val;
1567                                 if (get_user(val, p))
1568                                         return -EFAULT;
1569
1570                                 if (val != 0)           /* Can't change */
1571                                         return -EINVAL;
1572                                 val = ((curr_tempo * curr_timebase) + 30)/60;
1573                                 if (put_user(val, p))
1574                                         return -EFAULT;
1575                                 return val;
1576                         }
1577                         break;
1578
1579                 case SNDCTL_SEQ_GETTIME:
1580                         if (put_user(curr_ticks, p))
1581                                 return -EFAULT;
1582                         return curr_ticks;
1583
1584                 case SNDCTL_TMR_METRONOME:
1585                         if (get_user(metronome_mode, p))
1586                                 return -EFAULT;
1587                         setup_metronome(midi_dev);
1588                         return 0;
1589
1590                 default:;
1591         }
1592         return -EINVAL;
1593 }
1594
1595 static void mpu_timer_arm(int dev, long time)
1596 {
1597         if (time < 0)
1598                 time = curr_ticks + 1;
1599         else if (time <= curr_ticks)    /* It's the time */
1600                 return;
1601         next_event_time = prev_event_time = time;
1602         return;
1603 }
1604
1605 static struct sound_timer_operations mpu_timer =
1606 {
1607         .owner          = THIS_MODULE,
1608         .info           = {"MPU-401 Timer", 0},
1609         .priority       = 10,   /* Priority */
1610         .devlink        = 0,    /* Local device link */
1611         .open           = mpu_timer_open,
1612         .close          = mpu_timer_close,
1613         .event          = mpu_timer_event,
1614         .get_time       = mpu_timer_get_time,
1615         .ioctl          = mpu_timer_ioctl,
1616         .arm_timer      = mpu_timer_arm
1617 };
1618
1619 static void mpu_timer_interrupt(void)
1620 {
1621         if (!timer_open)
1622                 return;
1623
1624         if (!tmr_running)
1625                 return;
1626
1627         curr_clocks++;
1628         curr_ticks = clocks2ticks(curr_clocks);
1629
1630         if (curr_ticks >= next_event_time)
1631         {
1632                 next_event_time = (unsigned long) -1;
1633                 sequencer_timer(0);
1634         }
1635 }
1636
1637 static void timer_ext_event(struct mpu_config *devc, int event, int parm)
1638 {
1639         int midi_dev = devc->devno;
1640
1641         if (!devc->timer_flag)
1642                 return;
1643
1644         switch (event)
1645         {
1646                 case TMR_CLOCK:
1647                         printk("<MIDI clk>");
1648                         break;
1649
1650                 case TMR_START:
1651                         printk("Ext MIDI start\n");
1652                         if (!tmr_running)
1653                         {
1654                                 if (timer_mode & TMR_EXTERNAL)
1655                                 {
1656                                         tmr_running = 1;
1657                                         setup_metronome(midi_dev);
1658                                         next_event_time = 0;
1659                                         STORE(SEQ_START_TIMER());
1660                                 }
1661                         }
1662                         break;
1663
1664                 case TMR_STOP:
1665                         printk("Ext MIDI stop\n");
1666                         if (timer_mode & TMR_EXTERNAL)
1667                         {
1668                                 tmr_running = 0;
1669                                 stop_metronome(midi_dev);
1670                                 STORE(SEQ_STOP_TIMER());
1671                         }
1672                         break;
1673
1674                 case TMR_CONTINUE:
1675                         printk("Ext MIDI continue\n");
1676                         if (timer_mode & TMR_EXTERNAL)
1677                         {
1678                                 tmr_running = 1;
1679                                 setup_metronome(midi_dev);
1680                                 STORE(SEQ_CONTINUE_TIMER());
1681                         }
1682                         break;
1683
1684                 case TMR_SPP:
1685                         printk("Songpos: %d\n", parm);
1686                         if (timer_mode & TMR_EXTERNAL)
1687                         {
1688                                 STORE(SEQ_SONGPOS(parm));
1689                         }
1690                         break;
1691         }
1692 }
1693
1694 static int mpu_timer_init(int midi_dev)
1695 {
1696         struct mpu_config *devc;
1697         int n;
1698
1699         devc = &dev_conf[midi_dev];
1700
1701         if (timer_initialized)
1702                 return -1;      /* There is already a similar timer */
1703
1704         timer_initialized = 1;
1705
1706         mpu_timer.devlink = midi_dev;
1707         dev_conf[midi_dev].timer_flag = 1;
1708
1709         n = sound_alloc_timerdev();
1710         if (n == -1)
1711                 n = 0;
1712         sound_timer_devs[n] = &mpu_timer;
1713
1714         if (devc->version < 0x20)       /* Original MPU-401 */
1715                 timer_caps = TMR_INTERNAL | TMR_EXTERNAL | TMR_MODE_FSK | TMR_MODE_MIDI;
1716         else
1717         {
1718                 /*
1719                  * The version number 2.0 is used (at least) by the
1720                  * MusicQuest cards and the Roland Super-MPU.
1721                  *
1722                  * MusicQuest has given a special meaning to the bits of the
1723                  * revision number. The Super-MPU returns 0.
1724                  */
1725
1726                 if (devc->revision)
1727                         timer_caps |= TMR_EXTERNAL | TMR_MODE_MIDI;
1728
1729                 if (devc->revision & 0x02)
1730                         timer_caps |= TMR_MODE_CLS;
1731
1732
1733                 if (devc->revision & 0x40)
1734                         max_timebase = 10;      /* Has the 216 and 240 ppqn modes */
1735         }
1736
1737         timer_mode = (TMR_INTERNAL | TMR_MODE_MIDI) & timer_caps;
1738         return n;
1739
1740 }
1741
1742 EXPORT_SYMBOL(probe_mpu401);
1743 EXPORT_SYMBOL(attach_mpu401);
1744 EXPORT_SYMBOL(unload_mpu401);
1745
1746 static struct address_info cfg;
1747
1748 static int io = -1;
1749 static int irq = -1;
1750
1751 module_param(irq, int, 0);
1752 module_param(io, int, 0);
1753
1754 static int __init init_mpu401(void)
1755 {
1756         int ret;
1757         /* Can be loaded either for module use or to provide functions
1758            to others */
1759         if (io != -1 && irq != -1) {
1760                 struct resource *ports;
1761                 cfg.irq = irq;
1762                 cfg.io_base = io;
1763                 ports = request_region(io, 2, "mpu401");
1764                 if (!ports)
1765                         return -EBUSY;
1766                 if (probe_mpu401(&cfg, ports) == 0) {
1767                         release_region(io, 2);
1768                         return -ENODEV;
1769                 }
1770                 if ((ret = attach_mpu401(&cfg, THIS_MODULE)))
1771                         return ret;
1772         }
1773
1774         return 0;
1775 }
1776
1777 static void __exit cleanup_mpu401(void)
1778 {
1779         if (io != -1 && irq != -1) {
1780                 /* Check for use by, for example, sscape driver */
1781                 unload_mpu401(&cfg);
1782         }
1783 }
1784
1785 module_init(init_mpu401);
1786 module_exit(cleanup_mpu401);
1787
1788 #ifndef MODULE
1789 static int __init setup_mpu401(char *str)
1790 {
1791         /* io, irq */
1792         int ints[3];
1793
1794         str = get_options(str, ARRAY_SIZE(ints), ints);
1795
1796         io = ints[1];
1797         irq = ints[2];
1798
1799         return 1;
1800 }
1801
1802 __setup("mpu401=", setup_mpu401);
1803 #endif
1804 MODULE_LICENSE("GPL");