Logo Search packages:      
Sourcecode: linux version File versions  Download package

mpu401.c

/*
 * sound/oss/mpu401.c
 *
 * The low level driver for Roland MPU-401 compatible Midi cards.
 */
/*
 * Copyright (C) by Hannu Savolainen 1993-1997
 *
 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 * Version 2 (June 1991). See the "COPYING" file distributed with this software
 * for more info.
 *
 *
 * Thomas Sailer  ioctl code reworked (vmalloc/vfree removed)
 * Alan Cox       modularisation, use normal request_irq, use dev_id
 * Bartlomiej Zolnierkiewicz  removed some __init to allow using many drivers
 * Chris Rankin         Update the module-usage counter for the coprocessor
 * Zwane Mwaikambo      Changed attach/unload resource freeing
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/spinlock.h>
#define USE_SEQ_MACROS
#define USE_SIMPLE_MACROS

#include "sound_config.h"

#include "coproc.h"
#include "mpu401.h"

static int      timer_mode = TMR_INTERNAL, timer_caps = TMR_INTERNAL;

struct mpu_config
{
      int             base;   /*
                         * I/O base
                         */
      int             irq;
      int             opened; /*
                         * Open mode
                         */
      int             devno;
      int             synthno;
      int             uart_mode;
      int             initialized;
      int             mode;
#define MODE_MIDI 1
#define MODE_SYNTH      2
      unsigned char   version, revision;
      unsigned int    capabilities;
#define MPU_CAP_INTLG   0x10000000
#define MPU_CAP_SYNC    0x00000010
#define MPU_CAP_FSK     0x00000020
#define MPU_CAP_CLS     0x00000040
#define MPU_CAP_SMPTE   0x00000080
#define MPU_CAP_2PORT   0x00000001
      int             timer_flag;

#define MBUF_MAX  10
#define BUFTEST(dc) if (dc->m_ptr >= MBUF_MAX || dc->m_ptr < 0) \
      {printk( "MPU: Invalid buffer pointer %d/%d, s=%d\n",  dc->m_ptr,  dc->m_left,  dc->m_state);dc->m_ptr--;}
        int             m_busy;
        unsigned char   m_buf[MBUF_MAX];
        int             m_ptr;
        int             m_state;
        int             m_left;
        unsigned char   last_status;
        void            (*inputintr) (int dev, unsigned char data);
        int             shared_irq;
        int            *osp;
        spinlock_t      lock;
  };

#define     DATAPORT(base)   (base)
#define     COMDPORT(base)   (base+1)
#define     STATPORT(base)   (base+1)


static void mpu401_close(int dev);

static inline int mpu401_status(struct mpu_config *devc)
{
      return inb(STATPORT(devc->base));
}

#define input_avail(devc)           (!(mpu401_status(devc)&INPUT_AVAIL))
#define output_ready(devc)          (!(mpu401_status(devc)&OUTPUT_READY))

static inline void write_command(struct mpu_config *devc, unsigned char cmd)
{
      outb(cmd, COMDPORT(devc->base));
}

static inline int read_data(struct mpu_config *devc)
{
      return inb(DATAPORT(devc->base));
}

static inline void write_data(struct mpu_config *devc, unsigned char byte)
{
      outb(byte, DATAPORT(devc->base));
}

#define     OUTPUT_READY      0x40
#define     INPUT_AVAIL 0x80
#define     MPU_ACK           0xFE
#define     MPU_RESET   0xFF
#define     UART_MODE_ON      0x3F

static struct mpu_config dev_conf[MAX_MIDI_DEV];

static int n_mpu_devs;

static int reset_mpu401(struct mpu_config *devc);
static void set_uart_mode(int dev, struct mpu_config *devc, int arg);

static int mpu_timer_init(int midi_dev);
static void mpu_timer_interrupt(void);
static void timer_ext_event(struct mpu_config *devc, int event, int parm);

static struct synth_info mpu_synth_info_proto = {
      "MPU-401 MIDI interface", 
      0, 
      SYNTH_TYPE_MIDI, 
      MIDI_TYPE_MPU401, 
      0, 128, 
      0, 128, 
      SYNTH_CAP_INPUT
};

static struct synth_info mpu_synth_info[MAX_MIDI_DEV];

/*
 * States for the input scanner
 */

#define ST_INIT               0     /* Ready for timing byte or msg */
#define ST_TIMED        1     /* Leading timing byte rcvd */
#define ST_DATABYTE           2     /* Waiting for (nr_left) data bytes */

#define ST_SYSMSG       100   /* System message (sysx etc). */
#define ST_SYSEX        101   /* System exclusive msg */
#define ST_MTC                102   /* Midi Time Code (MTC) qframe msg */
#define ST_SONGSEL            103   /* Song select */
#define ST_SONGPOS            104   /* Song position pointer */

static unsigned char len_tab[] =    /* # of data bytes following a status
                               */
{
      2,                /* 8x */
      2,                /* 9x */
      2,                /* Ax */
      2,                /* Bx */
      1,                /* Cx */
      1,                /* Dx */
      2,                /* Ex */
      0                 /* Fx */
};

#define STORE(cmd) \
{ \
      int len; \
      unsigned char obuf[8]; \
      cmd; \
      seq_input_event(obuf, len); \
}

#define _seqbuf obuf
#define _seqbufptr 0
#define _SEQ_ADVBUF(x) len=x

static int mpu_input_scanner(struct mpu_config *devc, unsigned char midic)
{

      switch (devc->m_state)
      {
            case ST_INIT:
                  switch (midic)
                  {
                        case 0xf8:
                        /* Timer overflow */
                              break;

                        case 0xfc:
                              printk("<all end>");
                              break;

                        case 0xfd:
                              if (devc->timer_flag)
                                    mpu_timer_interrupt();
                              break;

                        case 0xfe:
                              return MPU_ACK;

                        case 0xf0:
                        case 0xf1:
                        case 0xf2:
                        case 0xf3:
                        case 0xf4:
                        case 0xf5:
                        case 0xf6:
                        case 0xf7:
                              printk("<Trk data rq #%d>", midic & 0x0f);
                              break;

                        case 0xf9:
                              printk("<conductor rq>");
                              break;

                        case 0xff:
                              devc->m_state = ST_SYSMSG;
                              break;

                        default:
                              if (midic <= 0xef)
                              {
                                    /* printk( "mpu time: %d ",  midic); */
                                    devc->m_state = ST_TIMED;
                              }
                              else
                                    printk("<MPU: Unknown event %02x> ", midic);
                  }
                  break;

            case ST_TIMED:
                  {
                        int msg = ((int) (midic & 0xf0) >> 4);

                        devc->m_state = ST_DATABYTE;

                        if (msg < 8)      /* Data byte */
                        {
                              /* printk( "midi msg (running status) "); */
                              msg = ((int) (devc->last_status & 0xf0) >> 4);
                              msg -= 8;
                              devc->m_left = len_tab[msg] - 1;

                              devc->m_ptr = 2;
                              devc->m_buf[0] = devc->last_status;
                              devc->m_buf[1] = midic;

                              if (devc->m_left <= 0)
                              {
                                    devc->m_state = ST_INIT;
                                    do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
                                    devc->m_ptr = 0;
                              }
                        }
                        else if (msg == 0xf)    /* MPU MARK */
                        {
                              devc->m_state = ST_INIT;

                              switch (midic)
                              {
                                    case 0xf8:
                                          /* printk( "NOP "); */
                                          break;

                                    case 0xf9:
                                          /* printk( "meas end "); */
                                          break;

                                    case 0xfc:
                                          /* printk( "data end "); */
                                          break;

                                    default:
                                          printk("Unknown MPU mark %02x\n", midic);
                              }
                        }
                        else
                        {
                              devc->last_status = midic;
                              /* printk( "midi msg "); */
                              msg -= 8;
                              devc->m_left = len_tab[msg];

                              devc->m_ptr = 1;
                              devc->m_buf[0] = midic;

                              if (devc->m_left <= 0)
                              {
                                    devc->m_state = ST_INIT;
                                    do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
                                    devc->m_ptr = 0;
                              }
                        }
                  }
                  break;

            case ST_SYSMSG:
                  switch (midic)
                  {
                        case 0xf0:
                              printk("<SYX>");
                              devc->m_state = ST_SYSEX;
                              break;

                        case 0xf1:
                              devc->m_state = ST_MTC;
                              break;

                        case 0xf2:
                              devc->m_state = ST_SONGPOS;
                              devc->m_ptr = 0;
                              break;

                        case 0xf3:
                              devc->m_state = ST_SONGSEL;
                              break;

                        case 0xf6:
                              /* printk( "tune_request\n"); */
                              devc->m_state = ST_INIT;

                              /*
                               *    Real time messages
                               */
                        case 0xf8:
                              /* midi clock */
                              devc->m_state = ST_INIT;
                              timer_ext_event(devc, TMR_CLOCK, 0);
                              break;

                        case 0xfA:
                              devc->m_state = ST_INIT;
                              timer_ext_event(devc, TMR_START, 0);
                              break;

                        case 0xFB:
                              devc->m_state = ST_INIT;
                              timer_ext_event(devc, TMR_CONTINUE, 0);
                              break;

                        case 0xFC:
                              devc->m_state = ST_INIT;
                              timer_ext_event(devc, TMR_STOP, 0);
                              break;

                        case 0xFE:
                              /* active sensing */
                              devc->m_state = ST_INIT;
                              break;

                        case 0xff:
                              /* printk( "midi hard reset"); */
                              devc->m_state = ST_INIT;
                              break;

                        default:
                              printk("unknown MIDI sysmsg %0x\n", midic);
                              devc->m_state = ST_INIT;
                  }
                  break;

            case ST_MTC:
                  devc->m_state = ST_INIT;
                  printk("MTC frame %x02\n", midic);
                  break;

            case ST_SYSEX:
                  if (midic == 0xf7)
                  {
                        printk("<EOX>");
                        devc->m_state = ST_INIT;
                  }
                  else
                        printk("%02x ", midic);
                  break;

            case ST_SONGPOS:
                  BUFTEST(devc);
                  devc->m_buf[devc->m_ptr++] = midic;
                  if (devc->m_ptr == 2)
                  {
                        devc->m_state = ST_INIT;
                        devc->m_ptr = 0;
                        timer_ext_event(devc, TMR_SPP,
                              ((devc->m_buf[1] & 0x7f) << 7) |
                              (devc->m_buf[0] & 0x7f));
                  }
                  break;

            case ST_DATABYTE:
                  BUFTEST(devc);
                  devc->m_buf[devc->m_ptr++] = midic;
                  if ((--devc->m_left) <= 0)
                  {
                        devc->m_state = ST_INIT;
                        do_midi_msg(devc->synthno, devc->m_buf, devc->m_ptr);
                        devc->m_ptr = 0;
                  }
                  break;

            default:
                  printk("Bad state %d ", devc->m_state);
                  devc->m_state = ST_INIT;
      }
      return 1;
}

static void mpu401_input_loop(struct mpu_config *devc)
{
      unsigned long flags;
      int busy;
      int n;

      spin_lock_irqsave(&devc->lock,flags);
      busy = devc->m_busy;
      devc->m_busy = 1;
      spin_unlock_irqrestore(&devc->lock,flags);

      if (busy)         /* Already inside the scanner */
            return;

      n = 50;

      while (input_avail(devc) && n-- > 0)
      {
            unsigned char c = read_data(devc);

            if (devc->mode == MODE_SYNTH)
            {
                  mpu_input_scanner(devc, c);
            }
            else if (devc->opened & OPEN_READ && devc->inputintr != NULL)
                  devc->inputintr(devc->devno, c);
      }
      devc->m_busy = 0;
}

static irqreturn_t mpuintr(int irq, void *dev_id)
{
      struct mpu_config *devc;
      int dev = (int)(unsigned long) dev_id;
      int handled = 0;

      devc = &dev_conf[dev];

      if (input_avail(devc))
      {
            handled = 1;
            if (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH))
                  mpu401_input_loop(devc);
            else
            {
                  /* Dummy read (just to acknowledge the interrupt) */
                  read_data(devc);
            }
      }
      return IRQ_RETVAL(handled);
}

static int mpu401_open(int dev, int mode,
          void            (*input) (int dev, unsigned char data),
          void            (*output) (int dev)
)
{
      int err;
      struct mpu_config *devc;
      struct coproc_operations *coprocessor;

      if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
            return -ENXIO;

      devc = &dev_conf[dev];

      if (devc->opened)
              return -EBUSY;
      /*
       *  Verify that the device is really running.
       *  Some devices (such as Ensoniq SoundScape don't
       *  work before the on board processor (OBP) is initialized
       *  by downloading its microcode.
       */

      if (!devc->initialized)
      {
            if (mpu401_status(devc) == 0xff)    /* Bus float */
            {
                  printk(KERN_ERR "mpu401: Device not initialized properly\n");
                  return -EIO;
            }
            reset_mpu401(devc);
      }

      if ( (coprocessor = midi_devs[dev]->coproc) != NULL )
      {
            if (!try_module_get(coprocessor->owner)) {
                  mpu401_close(dev);
                  return -ENODEV;
            }

            if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
            {
                  printk(KERN_WARNING "MPU-401: Can't access coprocessor device\n");
                  mpu401_close(dev);
                  return err;
            }
      }
      
      set_uart_mode(dev, devc, 1);
      devc->mode = MODE_MIDI;
      devc->synthno = 0;

      mpu401_input_loop(devc);

      devc->inputintr = input;
      devc->opened = mode;

      return 0;
}

static void mpu401_close(int dev)
{
      struct mpu_config *devc;
      struct coproc_operations *coprocessor;

      devc = &dev_conf[dev];
      if (devc->uart_mode)
            reset_mpu401(devc);     /*
                               * This disables the UART mode
                               */
      devc->mode = 0;
      devc->inputintr = NULL;

      coprocessor = midi_devs[dev]->coproc;
      if (coprocessor) {
            coprocessor->close(coprocessor->devc, COPR_MIDI);
            module_put(coprocessor->owner);
      }
      devc->opened = 0;
}

static int mpu401_out(int dev, unsigned char midi_byte)
{
      int timeout;
      unsigned long flags;

      struct mpu_config *devc;

      devc = &dev_conf[dev];

      /*
       * Sometimes it takes about 30000 loops before the output becomes ready
       * (After reset). Normally it takes just about 10 loops.
       */

      for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--);

      spin_lock_irqsave(&devc->lock,flags);
      if (!output_ready(devc))
      {
            printk(KERN_WARNING "mpu401: Send data timeout\n");
            spin_unlock_irqrestore(&devc->lock,flags);
            return 0;
      }
      write_data(devc, midi_byte);
      spin_unlock_irqrestore(&devc->lock,flags);
      return 1;
}

static int mpu401_command(int dev, mpu_command_rec * cmd)
{
      int i, timeout, ok;
      int ret = 0;
      unsigned long   flags;
      struct mpu_config *devc;

      devc = &dev_conf[dev];

      if (devc->uart_mode)    /*
                         * Not possible in UART mode
                         */
      {
            printk(KERN_WARNING "mpu401: commands not possible in the UART mode\n");
            return -EINVAL;
      }
      /*
       * Test for input since pending input seems to block the output.
       */
      if (input_avail(devc))
            mpu401_input_loop(devc);

      /*
       * Sometimes it takes about 50000 loops before the output becomes ready
       * (After reset). Normally it takes just about 10 loops.
       */

      timeout = 50000;
retry:
      if (timeout-- <= 0)
      {
            printk(KERN_WARNING "mpu401: Command (0x%x) timeout\n", (int) cmd->cmd);
            return -EIO;
      }
      spin_lock_irqsave(&devc->lock,flags);

      if (!output_ready(devc))
      {
            spin_unlock_irqrestore(&devc->lock,flags);
            goto retry;
      }
      write_command(devc, cmd->cmd);

      ok = 0;
      for (timeout = 50000; timeout > 0 && !ok; timeout--)
      {
            if (input_avail(devc))
            {
                  if (devc->opened && devc->mode == MODE_SYNTH)
                  {
                        if (mpu_input_scanner(devc, read_data(devc)) == MPU_ACK)
                              ok = 1;
                  }
                  else
                  {
                        /* Device is not currently open. Use simpler method */
                        if (read_data(devc) == MPU_ACK)
                              ok = 1;
                  }
            }
      }
      if (!ok)
      {
            spin_unlock_irqrestore(&devc->lock,flags);
            return -EIO;
      }
      if (cmd->nr_args)
      {
            for (i = 0; i < cmd->nr_args; i++)
            {
                  for (timeout = 3000; timeout > 0 && !output_ready(devc); timeout--);

                  if (!mpu401_out(dev, cmd->data[i]))
                  {
                        spin_unlock_irqrestore(&devc->lock,flags);
                        printk(KERN_WARNING "mpu401: Command (0x%x), parm send failed.\n", (int) cmd->cmd);
                        return -EIO;
                  }
            }
      }
      ret = 0;
      cmd->data[0] = 0;

      if (cmd->nr_returns)
      {
            for (i = 0; i < cmd->nr_returns; i++)
            {
                  ok = 0;
                  for (timeout = 5000; timeout > 0 && !ok; timeout--)
                        if (input_avail(devc))
                        {
                              cmd->data[i] = read_data(devc);
                              ok = 1;
                        }
                  if (!ok)
                  {
                        spin_unlock_irqrestore(&devc->lock,flags);
                        return -EIO;
                  }
            }
      }
      spin_unlock_irqrestore(&devc->lock,flags);
      return ret;
}

static int mpu_cmd(int dev, int cmd, int data)
{
      int ret;

      static mpu_command_rec rec;

      rec.cmd = cmd & 0xff;
      rec.nr_args = ((cmd & 0xf0) == 0xE0);
      rec.nr_returns = ((cmd & 0xf0) == 0xA0);
      rec.data[0] = data & 0xff;

      if ((ret = mpu401_command(dev, &rec)) < 0)
            return ret;
      return (unsigned char) rec.data[0];
}

static int mpu401_prefix_cmd(int dev, unsigned char status)
{
      struct mpu_config *devc = &dev_conf[dev];

      if (devc->uart_mode)
            return 1;

      if (status < 0xf0)
      {
            if (mpu_cmd(dev, 0xD0, 0) < 0)
                  return 0;
            return 1;
      }
      switch (status)
      {
            case 0xF0:
                  if (mpu_cmd(dev, 0xDF, 0) < 0)
                        return 0;
                  return 1;

            default:
                  return 0;
      }
}

static int mpu401_start_read(int dev)
{
      return 0;
}

static int mpu401_end_read(int dev)
{
      return 0;
}

static int mpu401_ioctl(int dev, unsigned cmd, void __user *arg)
{
      struct mpu_config *devc;
      mpu_command_rec rec;
      int val, ret;

      devc = &dev_conf[dev];
      switch (cmd) 
      {
            case SNDCTL_MIDI_MPUMODE:
                  if (!(devc->capabilities & MPU_CAP_INTLG)) { /* No intelligent mode */
                        printk(KERN_WARNING "mpu401: Intelligent mode not supported by the HW\n");
                        return -EINVAL;
                  }
                  if (get_user(val, (int __user *)arg))
                        return -EFAULT;
                  set_uart_mode(dev, devc, !val);
                  return 0;

            case SNDCTL_MIDI_MPUCMD:
                  if (copy_from_user(&rec, arg, sizeof(rec)))
                        return -EFAULT;
                  if ((ret = mpu401_command(dev, &rec)) < 0)
                        return ret;
                  if (copy_to_user(arg, &rec, sizeof(rec)))
                        return -EFAULT;
                  return 0;

            default:
                  return -EINVAL;
      }
}

static void mpu401_kick(int dev)
{
}

static int mpu401_buffer_status(int dev)
{
      return 0;         /*
                         * No data in buffers
                         */
}

static int mpu_synth_ioctl(int dev, unsigned int cmd, void __user *arg)
{
      int midi_dev;
      struct mpu_config *devc;

      midi_dev = synth_devs[dev]->midi_dev;

      if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
            return -ENXIO;

      devc = &dev_conf[midi_dev];

      switch (cmd)
      {

            case SNDCTL_SYNTH_INFO:
                  if (copy_to_user(arg, &mpu_synth_info[midi_dev],
                              sizeof(struct synth_info)))
                        return -EFAULT;
                  return 0;

            case SNDCTL_SYNTH_MEMAVL:
                  return 0x7fffffff;

            default:
                  return -EINVAL;
      }
}

static int mpu_synth_open(int dev, int mode)
{
      int midi_dev, err;
      struct mpu_config *devc;
      struct coproc_operations *coprocessor;

      midi_dev = synth_devs[dev]->midi_dev;

      if (midi_dev < 0 || midi_dev > num_midis || midi_devs[midi_dev] == NULL)
            return -ENXIO;

      devc = &dev_conf[midi_dev];

      /*
       *  Verify that the device is really running.
       *  Some devices (such as Ensoniq SoundScape don't
       *  work before the on board processor (OBP) is initialized
       *  by downloading its microcode.
       */

      if (!devc->initialized)
      {
            if (mpu401_status(devc) == 0xff)    /* Bus float */
            {
                  printk(KERN_ERR "mpu401: Device not initialized properly\n");
                  return -EIO;
            }
            reset_mpu401(devc);
      }
      if (devc->opened)
            return -EBUSY;
      devc->mode = MODE_SYNTH;
      devc->synthno = dev;

      devc->inputintr = NULL;

      coprocessor = midi_devs[midi_dev]->coproc;
      if (coprocessor) {
            if (!try_module_get(coprocessor->owner))
                  return -ENODEV;

            if ((err = coprocessor->open(coprocessor->devc, COPR_MIDI)) < 0)
            {
                  printk(KERN_WARNING "mpu401: Can't access coprocessor device\n");
                  return err;
            }
      }
      devc->opened = mode;
      reset_mpu401(devc);

      if (mode & OPEN_READ)
      {
            mpu_cmd(midi_dev, 0x8B, 0);   /* Enable data in stop mode */
            mpu_cmd(midi_dev, 0x34, 0);   /* Return timing bytes in stop mode */
            mpu_cmd(midi_dev, 0x87, 0);   /* Enable pitch & controller */
      }
      return 0;
}

static void mpu_synth_close(int dev)
{ 
      int midi_dev;
      struct mpu_config *devc;
      struct coproc_operations *coprocessor;

      midi_dev = synth_devs[dev]->midi_dev;

      devc = &dev_conf[midi_dev];
      mpu_cmd(midi_dev, 0x15, 0);   /* Stop recording, playback and MIDI */
      mpu_cmd(midi_dev, 0x8a, 0);   /* Disable data in stopped mode */

      devc->inputintr = NULL;

      coprocessor = midi_devs[midi_dev]->coproc;
      if (coprocessor) {
            coprocessor->close(coprocessor->devc, COPR_MIDI);
            module_put(coprocessor->owner);
      }
      devc->opened = 0;
      devc->mode = 0;
}

#define MIDI_SYNTH_NAME "MPU-401 UART Midi"
#define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
#include "midi_synth.h"

static struct synth_operations mpu401_synth_proto =
{
      .owner            = THIS_MODULE,
      .id         = "MPU401",
      .info       = NULL,
      .midi_dev   = 0,
      .synth_type = SYNTH_TYPE_MIDI,
      .synth_subtype    = 0,
      .open       = mpu_synth_open,
      .close            = mpu_synth_close,
      .ioctl            = mpu_synth_ioctl,
      .kill_note  = midi_synth_kill_note,
      .start_note = midi_synth_start_note,
      .set_instr  = midi_synth_set_instr,
      .reset            = midi_synth_reset,
      .hw_control = midi_synth_hw_control,
      .load_patch = midi_synth_load_patch,
      .aftertouch = midi_synth_aftertouch,
      .controller = midi_synth_controller,
      .panning    = midi_synth_panning,
      .bender           = midi_synth_bender,
      .setup_voice      = midi_synth_setup_voice,
      .send_sysex = midi_synth_send_sysex
};

static struct synth_operations *mpu401_synth_operations[MAX_MIDI_DEV];

static struct midi_operations mpu401_midi_proto =
{
      .owner            = THIS_MODULE,
      .info       = {"MPU-401 Midi", 0, MIDI_CAP_MPU401, SNDCARD_MPU401},
      .in_info    = {0},
      .open       = mpu401_open,
      .close            = mpu401_close,
      .ioctl            = mpu401_ioctl,
      .outputc    = mpu401_out,
      .start_read = mpu401_start_read,
      .end_read   = mpu401_end_read,
      .kick       = mpu401_kick,
      .buffer_status    = mpu401_buffer_status,
      .prefix_cmd = mpu401_prefix_cmd
};

static struct midi_operations mpu401_midi_operations[MAX_MIDI_DEV];

static void mpu401_chk_version(int n, struct mpu_config *devc)
{
      int tmp;
      unsigned long flags;

      devc->version = devc->revision = 0;

      spin_lock_irqsave(&devc->lock,flags);
      if ((tmp = mpu_cmd(n, 0xAC, 0)) < 0)
      {
            spin_unlock_irqrestore(&devc->lock,flags);
            return;
      }
      if ((tmp & 0xf0) > 0x20)      /* Why it's larger than 2.x ??? */
      {
            spin_unlock_irqrestore(&devc->lock,flags);
            return;
      }
      devc->version = tmp;

      if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0)
      {
            devc->version = 0;
            spin_unlock_irqrestore(&devc->lock,flags);
            return;
      }
      devc->revision = tmp;
      spin_unlock_irqrestore(&devc->lock,flags);
}

int attach_mpu401(struct address_info *hw_config, struct module *owner)
{
      unsigned long flags;
      char revision_char;

      int m, ret;
      struct mpu_config *devc;

      hw_config->slots[1] = -1;
      m = sound_alloc_mididev();
      if (m == -1)
      {
            printk(KERN_WARNING "MPU-401: Too many midi devices detected\n");
            ret = -ENOMEM;
            goto out_err;
      }
      devc = &dev_conf[m];
      devc->base = hw_config->io_base;
      devc->osp = hw_config->osp;
      devc->irq = hw_config->irq;
      devc->opened = 0;
      devc->uart_mode = 0;
      devc->initialized = 0;
      devc->version = 0;
      devc->revision = 0;
      devc->capabilities = 0;
      devc->timer_flag = 0;
      devc->m_busy = 0;
      devc->m_state = ST_INIT;
      devc->shared_irq = hw_config->always_detect;
      devc->irq = hw_config->irq;
      spin_lock_init(&devc->lock);

      if (devc->irq < 0)
      {
            devc->irq *= -1;
            devc->shared_irq = 1;
      }

      if (!hw_config->always_detect)
      {
            /* Verify the hardware again */
            if (!reset_mpu401(devc))
            {
                  printk(KERN_WARNING "mpu401: Device didn't respond\n");
                  ret = -ENODEV;
                  goto out_mididev;
            }
            if (!devc->shared_irq)
            {
                  if (request_irq(devc->irq, mpuintr, 0, "mpu401",
                              hw_config) < 0)
                  {
                        printk(KERN_WARNING "mpu401: Failed to allocate IRQ%d\n", devc->irq);
                        ret = -ENOMEM;
                        goto out_mididev;
                  }
            }
            spin_lock_irqsave(&devc->lock,flags);
            mpu401_chk_version(m, devc);
            if (devc->version == 0)
                  mpu401_chk_version(m, devc);
                  spin_unlock_irqrestore(&devc->lock,flags);
      }

      if (devc->version != 0)
            if (mpu_cmd(m, 0xC5, 0) >= 0) /* Set timebase OK */
                  if (mpu_cmd(m, 0xE0, 120) >= 0)           /* Set tempo OK */
                        devc->capabilities |= MPU_CAP_INTLG;      /* Supports intelligent mode */


      mpu401_synth_operations[m] = kmalloc(sizeof(struct synth_operations), GFP_KERNEL);

      if (mpu401_synth_operations[m] == NULL)
      {
            printk(KERN_ERR "mpu401: Can't allocate memory\n");
            ret = -ENOMEM;
            goto out_irq;
      }
      if (!(devc->capabilities & MPU_CAP_INTLG))      /* No intelligent mode */
      {
            memcpy((char *) mpu401_synth_operations[m],
                  (char *) &std_midi_synth,
                   sizeof(struct synth_operations));
      }
      else
      {
            memcpy((char *) mpu401_synth_operations[m],
                  (char *) &mpu401_synth_proto,
                   sizeof(struct synth_operations));
      }
      if (owner)
            mpu401_synth_operations[m]->owner = owner;

      memcpy((char *) &mpu401_midi_operations[m],
             (char *) &mpu401_midi_proto,
             sizeof(struct midi_operations));

      mpu401_midi_operations[m].converter = mpu401_synth_operations[m];

      memcpy((char *) &mpu_synth_info[m],
             (char *) &mpu_synth_info_proto,
             sizeof(struct synth_info));

      n_mpu_devs++;

      if (devc->version == 0x20 && devc->revision >= 0x07)  /* MusicQuest interface */
      {
            int ports = (devc->revision & 0x08) ? 32 : 16;

            devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_SMPTE |
                        MPU_CAP_CLS | MPU_CAP_2PORT;

            revision_char = (devc->revision == 0x7f) ? 'M' : ' ';
            sprintf(mpu_synth_info[m].name, "MQX-%d%c MIDI Interface #%d",
                        ports,
                        revision_char,
                        n_mpu_devs);
      }
      else
      {
            revision_char = devc->revision ? devc->revision + '@' : ' ';
            if ((int) devc->revision > ('Z' - '@'))
                  revision_char = '+';

            devc->capabilities |= MPU_CAP_SYNC | MPU_CAP_FSK;

            if (hw_config->name)
                  sprintf(mpu_synth_info[m].name, "%s (MPU401)", hw_config->name);
            else
                  sprintf(mpu_synth_info[m].name,
                        "MPU-401 %d.%d%c Midi interface #%d",
                        (int) (devc->version & 0xf0) >> 4,
                        devc->version & 0x0f,
                        revision_char,
                        n_mpu_devs);
      }

      strcpy(mpu401_midi_operations[m].info.name,
             mpu_synth_info[m].name);

      conf_printf(mpu_synth_info[m].name, hw_config);

      mpu401_synth_operations[m]->midi_dev = devc->devno = m;
      mpu401_synth_operations[devc->devno]->info = &mpu_synth_info[devc->devno];

      if (devc->capabilities & MPU_CAP_INTLG)         /* Intelligent mode */
            hw_config->slots[2] = mpu_timer_init(m);

      midi_devs[m] = &mpu401_midi_operations[devc->devno];
      
      if (owner)
            midi_devs[m]->owner = owner;

      hw_config->slots[1] = m;
      sequencer_init();
      
      return 0;

out_irq:
      free_irq(devc->irq, hw_config);
out_mididev:
      sound_unload_mididev(m);
out_err:
      release_region(hw_config->io_base, 2);
      return ret;
}

static int reset_mpu401(struct mpu_config *devc)
{
      unsigned long flags;
      int ok, timeout, n;
      int timeout_limit;

      /*
       * Send the RESET command. Try again if no success at the first time.
       * (If the device is in the UART mode, it will not ack the reset cmd).
       */

      ok = 0;

      timeout_limit = devc->initialized ? 30000 : 100000;
      devc->initialized = 1;

      for (n = 0; n < 2 && !ok; n++)
      {
            for (timeout = timeout_limit; timeout > 0 && !ok; timeout--)
                    ok = output_ready(devc);

            write_command(devc, MPU_RESET);     /*
                                             * Send MPU-401 RESET Command
                                           */

            /*
             * Wait at least 25 msec. This method is not accurate so let's make the
             * loop bit longer. Cannot sleep since this is called during boot.
             */

            for (timeout = timeout_limit * 2; timeout > 0 && !ok; timeout--)
            {
                  spin_lock_irqsave(&devc->lock,flags);
                  if (input_avail(devc))
                        if (read_data(devc) == MPU_ACK)
                              ok = 1;
                  spin_unlock_irqrestore(&devc->lock,flags);
            }

      }

      devc->m_state = ST_INIT;
      devc->m_ptr = 0;
      devc->m_left = 0;
      devc->last_status = 0;
      devc->uart_mode = 0;

      return ok;
}

static void set_uart_mode(int dev, struct mpu_config *devc, int arg)
{
      if (!arg && (devc->capabilities & MPU_CAP_INTLG))
            return;
      if ((devc->uart_mode == 0) == (arg == 0))
            return;           /* Already set */
      reset_mpu401(devc);     /* This exits the uart mode */

      if (arg)
      {
            if (mpu_cmd(dev, UART_MODE_ON, 0) < 0)
            {
                  printk(KERN_ERR "mpu401: Can't enter UART mode\n");
                  devc->uart_mode = 0;
                  return;
            }
      }
      devc->uart_mode = arg;

}

int probe_mpu401(struct address_info *hw_config, struct resource *ports)
{
      int ok = 0;
      struct mpu_config tmp_devc;

      tmp_devc.base = hw_config->io_base;
      tmp_devc.irq = hw_config->irq;
      tmp_devc.initialized = 0;
      tmp_devc.opened = 0;
      tmp_devc.osp = hw_config->osp;

      if (hw_config->always_detect)
            return 1;

      if (inb(hw_config->io_base + 1) == 0xff)
      {
            DDB(printk("MPU401: Port %x looks dead.\n", hw_config->io_base));
            return 0;   /* Just bus float? */
      }
      ok = reset_mpu401(&tmp_devc);

      if (!ok)
      {
            DDB(printk("MPU401: Reset failed on port %x\n", hw_config->io_base));
      }
      return ok;
}

void unload_mpu401(struct address_info *hw_config)
{
      void *p;
      int n=hw_config->slots[1];
            
      if (n != -1) {
            release_region(hw_config->io_base, 2);
            if (hw_config->always_detect == 0 && hw_config->irq > 0)
                  free_irq(hw_config->irq, hw_config);
            p=mpu401_synth_operations[n];
            sound_unload_mididev(n);
            sound_unload_timerdev(hw_config->slots[2]);
            kfree(p);
      }
}

/*****************************************************
 *      Timer stuff
 ****************************************************/

static volatile int timer_initialized = 0, timer_open = 0, tmr_running = 0;
static volatile int curr_tempo, curr_timebase, hw_timebase;
static int      max_timebase = 8;   /* 8*24=192 ppqn */
static volatile unsigned long next_event_time;
static volatile unsigned long curr_ticks, curr_clocks;
static unsigned long prev_event_time;
static int      metronome_mode;

static unsigned long clocks2ticks(unsigned long clocks)
{
      /*
       * The MPU-401 supports just a limited set of possible timebase values.
       * Since the applications require more choices, the driver has to
       * program the HW to do its best and to convert between the HW and
       * actual timebases.
       */
      return ((clocks * curr_timebase) + (hw_timebase / 2)) / hw_timebase;
}

static void set_timebase(int midi_dev, int val)
{
      int hw_val;

      if (val < 48)
            val = 48;
      if (val > 1000)
            val = 1000;

      hw_val = val;
      hw_val = (hw_val + 12) / 24;
      if (hw_val > max_timebase)
            hw_val = max_timebase;

      if (mpu_cmd(midi_dev, 0xC0 | (hw_val & 0x0f), 0) < 0)
      {
            printk(KERN_WARNING "mpu401: Can't set HW timebase to %d\n", hw_val * 24);
            return;
      }
      hw_timebase = hw_val * 24;
      curr_timebase = val;

}

static void tmr_reset(struct mpu_config *devc)
{
      unsigned long flags;

      spin_lock_irqsave(&devc->lock,flags);
      next_event_time = (unsigned long) -1;
      prev_event_time = 0;
      curr_ticks = curr_clocks = 0;
      spin_unlock_irqrestore(&devc->lock,flags);
}

static void set_timer_mode(int midi_dev)
{
      if (timer_mode & TMR_MODE_CLS)
            mpu_cmd(midi_dev, 0x3c, 0);   /* Use CLS sync */
      else if (timer_mode & TMR_MODE_SMPTE)
            mpu_cmd(midi_dev, 0x3d, 0);   /* Use SMPTE sync */

      if (timer_mode & TMR_INTERNAL)
      {
              mpu_cmd(midi_dev, 0x80, 0); /* Use MIDI sync */
      }
      else
      {
            if (timer_mode & (TMR_MODE_MIDI | TMR_MODE_CLS))
            {
                  mpu_cmd(midi_dev, 0x82, 0);         /* Use MIDI sync */
                  mpu_cmd(midi_dev, 0x91, 0);         /* Enable ext MIDI ctrl */
            }
            else if (timer_mode & TMR_MODE_FSK)
                  mpu_cmd(midi_dev, 0x81, 0);   /* Use FSK sync */
      }
}

static void stop_metronome(int midi_dev)
{
      mpu_cmd(midi_dev, 0x84, 0);   /* Disable metronome */
}

static void setup_metronome(int midi_dev)
{
      int numerator, denominator;
      int clks_per_click, num_32nds_per_beat;
      int beats_per_measure;

      numerator = ((unsigned) metronome_mode >> 24) & 0xff;
      denominator = ((unsigned) metronome_mode >> 16) & 0xff;
      clks_per_click = ((unsigned) metronome_mode >> 8) & 0xff;
      num_32nds_per_beat = (unsigned) metronome_mode & 0xff;
      beats_per_measure = (numerator * 4) >> denominator;

      if (!metronome_mode)
            mpu_cmd(midi_dev, 0x84, 0);   /* Disable metronome */
      else
      {
            mpu_cmd(midi_dev, 0xE4, clks_per_click);
            mpu_cmd(midi_dev, 0xE6, beats_per_measure);
            mpu_cmd(midi_dev, 0x83, 0);   /* Enable metronome without accents */
      }
}

static int mpu_start_timer(int midi_dev)
{
      struct mpu_config *devc= &dev_conf[midi_dev];

      tmr_reset(devc);
      set_timer_mode(midi_dev);

      if (tmr_running)
            return TIMER_NOT_ARMED;       /* Already running */

      if (timer_mode & TMR_INTERNAL)
      {
            mpu_cmd(midi_dev, 0x02, 0);   /* Send MIDI start */
            tmr_running = 1;
            return TIMER_NOT_ARMED;
      }
      else
      {
            mpu_cmd(midi_dev, 0x35, 0);   /* Enable mode messages to PC */
            mpu_cmd(midi_dev, 0x38, 0);   /* Enable sys common messages to PC */
            mpu_cmd(midi_dev, 0x39, 0);   /* Enable real time messages to PC */
            mpu_cmd(midi_dev, 0x97, 0);   /* Enable system exclusive messages to PC */
      }
      return TIMER_ARMED;
}

static int mpu_timer_open(int dev, int mode)
{
      int midi_dev = sound_timer_devs[dev]->devlink;
      struct mpu_config *devc= &dev_conf[midi_dev];

      if (timer_open)
            return -EBUSY;

      tmr_reset(devc);
      curr_tempo = 50;
      mpu_cmd(midi_dev, 0xE0, 50);
      curr_timebase = hw_timebase = 120;
      set_timebase(midi_dev, 120);
      timer_open = 1;
      metronome_mode = 0;
      set_timer_mode(midi_dev);

      mpu_cmd(midi_dev, 0xe7, 0x04);      /* Send all clocks to host */
      mpu_cmd(midi_dev, 0x95, 0);   /* Enable clock to host */

      return 0;
}

static void mpu_timer_close(int dev)
{
      int midi_dev = sound_timer_devs[dev]->devlink;

      timer_open = tmr_running = 0;
      mpu_cmd(midi_dev, 0x15, 0);   /* Stop all */
      mpu_cmd(midi_dev, 0x94, 0);   /* Disable clock to host */
      mpu_cmd(midi_dev, 0x8c, 0);   /* Disable measure end messages to host */
      stop_metronome(midi_dev);
}

static int mpu_timer_event(int dev, unsigned char *event)
{
      unsigned char command = event[1];
      unsigned long parm = *(unsigned int *) &event[4];
      int midi_dev = sound_timer_devs[dev]->devlink;

      switch (command)
      {
            case TMR_WAIT_REL:
                  parm += prev_event_time;
            case TMR_WAIT_ABS:
                  if (parm > 0)
                  {
                        long time;

                        if (parm <= curr_ticks) /* It's the time */
                              return TIMER_NOT_ARMED;
                        time = parm;
                        next_event_time = prev_event_time = time;

                        return TIMER_ARMED;
                  }
                  break;

            case TMR_START:
                  if (tmr_running)
                        break;
                  return mpu_start_timer(midi_dev);

            case TMR_STOP:
                  mpu_cmd(midi_dev, 0x01, 0);   /* Send MIDI stop */
                  stop_metronome(midi_dev);
                  tmr_running = 0;
                  break;

            case TMR_CONTINUE:
                  if (tmr_running)
                        break;
                  mpu_cmd(midi_dev, 0x03, 0);   /* Send MIDI continue */
                  setup_metronome(midi_dev);
                  tmr_running = 1;
                  break;

            case TMR_TEMPO:
                  if (parm)
                  {
                        if (parm < 8)
                              parm = 8;
                        if (parm > 250)
                              parm = 250;
                        if (mpu_cmd(midi_dev, 0xE0, parm) < 0)
                              printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) parm);
                        curr_tempo = parm;
                  }
                  break;

            case TMR_ECHO:
                  seq_copy_to_input(event, 8);
                  break;

            case TMR_TIMESIG:
                  if (metronome_mode)     /* Metronome enabled */
                  {
                        metronome_mode = parm;
                        setup_metronome(midi_dev);
                  }
                  break;

            default:;
      }
      return TIMER_NOT_ARMED;
}

static unsigned long mpu_timer_get_time(int dev)
{
      if (!timer_open)
            return 0;

      return curr_ticks;
}

static int mpu_timer_ioctl(int dev, unsigned int command, void __user *arg)
{
      int midi_dev = sound_timer_devs[dev]->devlink;
      int __user *p = (int __user *)arg;

      switch (command)
      {
            case SNDCTL_TMR_SOURCE:
                  {
                        int parm;

                        if (get_user(parm, p))
                              return -EFAULT;
                        parm &= timer_caps;

                        if (parm != 0)
                        {
                              timer_mode = parm;
      
                              if (timer_mode & TMR_MODE_CLS)
                                    mpu_cmd(midi_dev, 0x3c, 0);         /* Use CLS sync */
                              else if (timer_mode & TMR_MODE_SMPTE)
                                    mpu_cmd(midi_dev, 0x3d, 0);         /* Use SMPTE sync */
                        }
                        if (put_user(timer_mode, p))
                              return -EFAULT;
                        return timer_mode;
                  }
                  break;

            case SNDCTL_TMR_START:
                  mpu_start_timer(midi_dev);
                  return 0;

            case SNDCTL_TMR_STOP:
                  tmr_running = 0;
                  mpu_cmd(midi_dev, 0x01, 0);   /* Send MIDI stop */
                  stop_metronome(midi_dev);
                  return 0;

            case SNDCTL_TMR_CONTINUE:
                  if (tmr_running)
                        return 0;
                  tmr_running = 1;
                  mpu_cmd(midi_dev, 0x03, 0);   /* Send MIDI continue */
                  return 0;

            case SNDCTL_TMR_TIMEBASE:
                  {
                        int val;
                        if (get_user(val, p))
                              return -EFAULT;
                        if (val)
                              set_timebase(midi_dev, val);
                        if (put_user(curr_timebase, p))
                              return -EFAULT;
                        return curr_timebase;
                  }
                  break;

            case SNDCTL_TMR_TEMPO:
                  {
                        int val;
                        int ret;

                        if (get_user(val, p))
                              return -EFAULT;

                        if (val)
                        {
                              if (val < 8)
                                    val = 8;
                              if (val > 250)
                                    val = 250;
                              if ((ret = mpu_cmd(midi_dev, 0xE0, val)) < 0)
                              {
                                    printk(KERN_WARNING "mpu401: Can't set tempo to %d\n", (int) val);
                                    return ret;
                              }
                              curr_tempo = val;
                        }
                        if (put_user(curr_tempo, p))
                              return -EFAULT;
                        return curr_tempo;
                  }
                  break;

            case SNDCTL_SEQ_CTRLRATE:
                  {
                        int val;
                        if (get_user(val, p))
                              return -EFAULT;

                        if (val != 0)           /* Can't change */
                              return -EINVAL;
                        val = ((curr_tempo * curr_timebase) + 30)/60;
                        if (put_user(val, p))
                              return -EFAULT;
                        return val;
                  }
                  break;

            case SNDCTL_SEQ_GETTIME:
                  if (put_user(curr_ticks, p))
                        return -EFAULT;
                  return curr_ticks;

            case SNDCTL_TMR_METRONOME:
                  if (get_user(metronome_mode, p))
                        return -EFAULT;
                  setup_metronome(midi_dev);
                  return 0;

            default:;
      }
      return -EINVAL;
}

static void mpu_timer_arm(int dev, long time)
{
      if (time < 0)
            time = curr_ticks + 1;
      else if (time <= curr_ticks)  /* It's the time */
            return;
      next_event_time = prev_event_time = time;
      return;
}

static struct sound_timer_operations mpu_timer =
{
      .owner            = THIS_MODULE,
      .info       = {"MPU-401 Timer", 0},
      .priority   = 10, /* Priority */
      .devlink    = 0,  /* Local device link */
      .open       = mpu_timer_open,
      .close            = mpu_timer_close,
      .event            = mpu_timer_event,
      .get_time   = mpu_timer_get_time,
      .ioctl            = mpu_timer_ioctl,
      .arm_timer  = mpu_timer_arm
};

static void mpu_timer_interrupt(void)
{
      if (!timer_open)
            return;

      if (!tmr_running)
            return;

      curr_clocks++;
      curr_ticks = clocks2ticks(curr_clocks);

      if (curr_ticks >= next_event_time)
      {
            next_event_time = (unsigned long) -1;
            sequencer_timer(0);
      }
}

static void timer_ext_event(struct mpu_config *devc, int event, int parm)
{
      int midi_dev = devc->devno;

      if (!devc->timer_flag)
            return;

      switch (event)
      {
            case TMR_CLOCK:
                  printk("<MIDI clk>");
                  break;

            case TMR_START:
                  printk("Ext MIDI start\n");
                  if (!tmr_running)
                  {
                        if (timer_mode & TMR_EXTERNAL)
                        {
                              tmr_running = 1;
                              setup_metronome(midi_dev);
                              next_event_time = 0;
                              STORE(SEQ_START_TIMER());
                        }
                  }
                  break;

            case TMR_STOP:
                  printk("Ext MIDI stop\n");
                  if (timer_mode & TMR_EXTERNAL)
                  {
                        tmr_running = 0;
                        stop_metronome(midi_dev);
                        STORE(SEQ_STOP_TIMER());
                  }
                  break;

            case TMR_CONTINUE:
                  printk("Ext MIDI continue\n");
                  if (timer_mode & TMR_EXTERNAL)
                  {
                        tmr_running = 1;
                        setup_metronome(midi_dev);
                        STORE(SEQ_CONTINUE_TIMER());
                  }
                  break;

            case TMR_SPP:
                  printk("Songpos: %d\n", parm);
                  if (timer_mode & TMR_EXTERNAL)
                  {
                        STORE(SEQ_SONGPOS(parm));
                  }
                  break;
      }
}

static int mpu_timer_init(int midi_dev)
{
      struct mpu_config *devc;
      int n;

      devc = &dev_conf[midi_dev];

      if (timer_initialized)
            return -1;  /* There is already a similar timer */

      timer_initialized = 1;

      mpu_timer.devlink = midi_dev;
      dev_conf[midi_dev].timer_flag = 1;

      n = sound_alloc_timerdev();
      if (n == -1)
            n = 0;
      sound_timer_devs[n] = &mpu_timer;

      if (devc->version < 0x20)     /* Original MPU-401 */
            timer_caps = TMR_INTERNAL | TMR_EXTERNAL | TMR_MODE_FSK | TMR_MODE_MIDI;
      else
      {
            /*
             * The version number 2.0 is used (at least) by the
             * MusicQuest cards and the Roland Super-MPU.
             *
             * MusicQuest has given a special meaning to the bits of the
             * revision number. The Super-MPU returns 0.
             */

            if (devc->revision)
                  timer_caps |= TMR_EXTERNAL | TMR_MODE_MIDI;

            if (devc->revision & 0x02)
                  timer_caps |= TMR_MODE_CLS;


            if (devc->revision & 0x40)
                  max_timebase = 10;      /* Has the 216 and 240 ppqn modes */
      }

      timer_mode = (TMR_INTERNAL | TMR_MODE_MIDI) & timer_caps;
      return n;

}

EXPORT_SYMBOL(probe_mpu401);
EXPORT_SYMBOL(attach_mpu401);
EXPORT_SYMBOL(unload_mpu401);

static struct address_info cfg;

static int io = -1;
static int irq = -1;

module_param(irq, int, 0);
module_param(io, int, 0);

static int __init init_mpu401(void)
{
      int ret;
      /* Can be loaded either for module use or to provide functions
         to others */
      if (io != -1 && irq != -1) {
            struct resource *ports;
              cfg.irq = irq;
            cfg.io_base = io;
            ports = request_region(io, 2, "mpu401");
            if (!ports)
                  return -EBUSY;
            if (probe_mpu401(&cfg, ports) == 0) {
                  release_region(io, 2);
                  return -ENODEV;
            }
            if ((ret = attach_mpu401(&cfg, THIS_MODULE)))
                  return ret;
      }
      
      return 0;
}

static void __exit cleanup_mpu401(void)
{
      if (io != -1 && irq != -1) {
            /* Check for use by, for example, sscape driver */
            unload_mpu401(&cfg);
      }
}

module_init(init_mpu401);
module_exit(cleanup_mpu401);

#ifndef MODULE
static int __init setup_mpu401(char *str)
{
        /* io, irq */
      int ints[3];
      
      str = get_options(str, ARRAY_SIZE(ints), ints);
      
      io = ints[1];
      irq = ints[2];

      return 1;
}

__setup("mpu401=", setup_mpu401);
#endif
MODULE_LICENSE("GPL");

Generated by  Doxygen 1.6.0   Back to index