mirror of
https://github.com/torvalds/linux.git
synced 2024-12-05 02:23:16 +00:00
02bb57aeb0
When the {orig,midi}_dev equals num_midis, that's one too large already. Signed-off-by: Roel Kluin <roel.kluin@gmail.com> Signed-off-by: Takashi Iwai <tiwai@suse.de>
1806 lines
38 KiB
C
1806 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/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");
|