linux/sound/oss/mpu401.c
Tejun Heo 5a0e3ad6af include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files.  percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.

percpu.h -> slab.h dependency is about to be removed.  Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability.  As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.

  http://userweb.kernel.org/~tj/misc/slabh-sweep.py

The script does the followings.

* Scan files for gfp and slab usages and update includes such that
  only the necessary includes are there.  ie. if only gfp is used,
  gfp.h, if slab is used, slab.h.

* When the script inserts a new include, it looks at the include
  blocks and try to put the new include such that its order conforms
  to its surrounding.  It's put in the include block which contains
  core kernel includes, in the same order that the rest are ordered -
  alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
  doesn't seem to be any matching order.

* If the script can't find a place to put a new include (mostly
  because the file doesn't have fitting include block), it prints out
  an error message indicating which .h file needs to be added to the
  file.

The conversion was done in the following steps.

1. The initial automatic conversion of all .c files updated slightly
   over 4000 files, deleting around 700 includes and adding ~480 gfp.h
   and ~3000 slab.h inclusions.  The script emitted errors for ~400
   files.

2. Each error was manually checked.  Some didn't need the inclusion,
   some needed manual addition while adding it to implementation .h or
   embedding .c file was more appropriate for others.  This step added
   inclusions to around 150 files.

3. The script was run again and the output was compared to the edits
   from  to make sure no file was left behind.

4. Several build tests were done and a couple of problems were fixed.
   e.g. lib/decompress_*.c used malloc/free() wrappers around slab
   APIs requiring slab.h to be added manually.

5. The script was run on all .h files but without automatically
   editing them as sprinkling gfp.h and slab.h inclusions around .h
   files could easily lead to inclusion dependency hell.  Most gfp.h
   inclusion directives were ignored as stuff from gfp.h was usually
   wildly available and often used in preprocessor macros.  Each
   slab.h inclusion directive was examined and added manually as
   necessary.

6. percpu.h was updated not to include slab.h.

7. Build test were done on the following configurations and failures
   were fixed.  CONFIG_GCOV_KERNEL was turned off for all tests (as my
   distributed build env didn't work with gcov compiles) and a few
   more options had to be turned off depending on archs to make things
   build (like ipr on powerpc/64 which failed due to missing writeq).

   * x86 and x86_64 UP and SMP allmodconfig and a custom test config.
   * powerpc and powerpc64 SMP allmodconfig
   * sparc and sparc64 SMP allmodconfig
   * ia64 SMP allmodconfig
   * s390 SMP allmodconfig
   * alpha SMP allmodconfig
   * um on x86_64 SMP allmodconfig

8. percpu.h modifications were reverted so that it could be applied as
   a separate patch and serve as bisection point.

Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.

Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-30 22:02:32 +09:00

1807 lines
38 KiB
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/slab.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;
devc->version = devc->revision = 0;
tmp = mpu_cmd(n, 0xAC, 0);
if (tmp < 0)
return;
if ((tmp & 0xf0) > 0x20) /* Why it's larger than 2.x ??? */
return;
devc->version = tmp;
if ((tmp = mpu_cmd(n, 0xAD, 0)) < 0) {
devc->version = 0;
return;
}
devc->revision = tmp;
}
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 #%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");