[mirror_ubuntu-artful-kernel.git] / sound / drivers / mpu401 / mpu401_uart.c

/*
 *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
 *  Routines for control of MPU-401 in UART mode
 *
 *  MPU-401 supports UART mode which is not capable generate transmit
 *  interrupts thus output is done via polling. Also, if irq < 0, then
 *  input is done also via polling. Do not expect good performance.
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 *   13-03-2003:
 *      Added support for different kind of hardware I/O. Build in choices
 *      are port and mmio. For other kind of I/O, set mpu->read and
 *      mpu->write to your own I/O functions.
 *
 */

#include <sound/driver.h>
#include <asm/io.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <sound/core.h>
#include <sound/mpu401.h>

MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode");
MODULE_LICENSE("GPL");

static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu);
static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu);

/*

 */

#define snd_mpu401_input_avail(mpu)	(!(mpu->read(mpu, MPU401C(mpu)) & 0x80))
#define snd_mpu401_output_ready(mpu)	(!(mpu->read(mpu, MPU401C(mpu)) & 0x40))

#define MPU401_RESET		0xff
#define MPU401_ENTER_UART	0x3f
#define MPU401_ACK		0xfe

/* Build in lowlevel io */
static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr)
{
	outb(data, addr);
}

static unsigned char mpu401_read_port(struct snd_mpu401 *mpu, unsigned long addr)
{
	return inb(addr);
}

static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr)
{
	writeb(data, (void __iomem *)addr);
}

static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu, unsigned long addr)
{
	return readb((void __iomem *)addr);
}
/*  */

static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
{
	int timeout = 100000;
	for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
		mpu->read(mpu, MPU401D(mpu));
#ifdef CONFIG_SND_DEBUG
	if (timeout <= 0)
		snd_printk("cmd: clear rx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu)));
#endif
}

static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
{
	spin_lock(&mpu->input_lock);
	if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
		snd_mpu401_uart_input_read(mpu);
	} else {
		snd_mpu401_uart_clear_rx(mpu);
	}
	spin_unlock(&mpu->input_lock);
 	/* ok. for better Tx performance try do some output when input is done */
	if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
	    test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
		spin_lock(&mpu->output_lock);
		snd_mpu401_uart_output_write(mpu);
		spin_unlock(&mpu->output_lock);
	}
}

/**
 * snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler
 * @irq: the irq number
 * @dev_id: mpu401 instance
 * @regs: the reigster
 *
 * Processes the interrupt for MPU401-UART i/o.
 */
irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
	struct snd_mpu401 *mpu = dev_id;
	
	if (mpu == NULL)
		return IRQ_NONE;
	_snd_mpu401_uart_interrupt(mpu);
	return IRQ_HANDLED;
}

/*
 * timer callback
 * reprogram the timer and call the interrupt job
 */
static void snd_mpu401_uart_timer(unsigned long data)
{
	struct snd_mpu401 *mpu = (struct snd_mpu401 *)data;
	unsigned long flags;

	spin_lock_irqsave(&mpu->timer_lock, flags);
	/*mpu->mode |= MPU401_MODE_TIMER;*/
	mpu->timer.expires = 1 + jiffies;
	add_timer(&mpu->timer);
	spin_unlock_irqrestore(&mpu->timer_lock, flags);
	if (mpu->rmidi)
		_snd_mpu401_uart_interrupt(mpu);
}

/*
 * initialize the timer callback if not programmed yet
 */
static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
{
	unsigned long flags;

	spin_lock_irqsave (&mpu->timer_lock, flags);
	if (mpu->timer_invoked == 0) {
		init_timer(&mpu->timer);
		mpu->timer.data = (unsigned long)mpu;
		mpu->timer.function = snd_mpu401_uart_timer;
		mpu->timer.expires = 1 + jiffies;
		add_timer(&mpu->timer);
	} 
	mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER : MPU401_MODE_OUTPUT_TIMER;
	spin_unlock_irqrestore (&mpu->timer_lock, flags);
}

/*
 * remove the timer callback if still active
 */
static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
{
	unsigned long flags;

	spin_lock_irqsave (&mpu->timer_lock, flags);
	if (mpu->timer_invoked) {
		mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER : ~MPU401_MODE_OUTPUT_TIMER;
		if (! mpu->timer_invoked)
			del_timer(&mpu->timer);
	}
	spin_unlock_irqrestore (&mpu->timer_lock, flags);
}

/*

 */

static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
		int ack)
{
	unsigned long flags;
	int timeout, ok;

	spin_lock_irqsave(&mpu->input_lock, flags);
	if (mpu->hardware != MPU401_HW_TRID4DWAVE) {
		mpu->write(mpu, 0x00, MPU401D(mpu));
		/*snd_mpu401_uart_clear_rx(mpu);*/
	}
	/* ok. standard MPU-401 initialization */
	if (mpu->hardware != MPU401_HW_SB) {
		for (timeout = 1000; timeout > 0 && !snd_mpu401_output_ready(mpu); timeout--)
			udelay(10);
#ifdef CONFIG_SND_DEBUG
		if (!timeout)
			snd_printk("cmd: tx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu)));
#endif
	}
	mpu->write(mpu, cmd, MPU401C(mpu));
	if (ack) {
		ok = 0;
		timeout = 10000;
		while (!ok && timeout-- > 0) {
			if (snd_mpu401_input_avail(mpu)) {
				if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
					ok = 1;
			}
		}
		if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
			ok = 1;
	} else {
		ok = 1;
	}
	spin_unlock_irqrestore(&mpu->input_lock, flags);
	if (!ok) {
		snd_printk("cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)\n", cmd, mpu->port, mpu->read(mpu, MPU401C(mpu)), mpu->read(mpu, MPU401D(mpu)));
		return 1;
	}
	return 0;
}

/*
 * input/output open/close - protected by open_mutex in rawmidi.c
 */
static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
{
	struct snd_mpu401 *mpu;
	int err;

	mpu = substream->rmidi->private_data;
	if (mpu->open_input && (err = mpu->open_input(mpu)) < 0)
		return err;
	if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
		if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
			goto error_out;
		if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 1))
			goto error_out;
	}
	mpu->substream_input = substream;
	set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
	return 0;

error_out:
	if (mpu->open_input && mpu->close_input)
		mpu->close_input(mpu);
	return -EIO;
}

static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
{
	struct snd_mpu401 *mpu;
	int err;

	mpu = substream->rmidi->private_data;
	if (mpu->open_output && (err = mpu->open_output(mpu)) < 0)
		return err;
	if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
		if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
			goto error_out;
		if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 1))
			goto error_out;
	}
	mpu->substream_output = substream;
	set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
	return 0;

error_out:
	if (mpu->open_output && mpu->close_output)
		mpu->close_output(mpu);
	return -EIO;
}

static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
{
	struct snd_mpu401 *mpu;
	int err = 0;

	mpu = substream->rmidi->private_data;
	clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
	mpu->substream_input = NULL;
	if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode))
		err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
	if (mpu->close_input)
		mpu->close_input(mpu);
	if (err)
		return -EIO;
	return 0;
}

static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
{
	struct snd_mpu401 *mpu;
	int err = 0;

	mpu = substream->rmidi->private_data;
	clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
	mpu->substream_output = NULL;
	if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
		err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
	if (mpu->close_output)
		mpu->close_output(mpu);
	if (err)
		return -EIO;
	return 0;
}

/*
 * trigger input callback
 */
static void snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
{
	unsigned long flags;
	struct snd_mpu401 *mpu;
	int max = 64;

	mpu = substream->rmidi->private_data;
	if (up) {
		if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode)) {
			/* first time - flush FIFO */
			while (max-- > 0)
				mpu->read(mpu, MPU401D(mpu));
			if (mpu->irq < 0)
				snd_mpu401_uart_add_timer(mpu, 1);
		}
		
		/* read data in advance */
		spin_lock_irqsave(&mpu->input_lock, flags);
		snd_mpu401_uart_input_read(mpu);
		spin_unlock_irqrestore(&mpu->input_lock, flags);
	} else {
		if (mpu->irq < 0)
			snd_mpu401_uart_remove_timer(mpu, 1);
		clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
	}

}

/*
 * transfer input pending data
 * call with input_lock spinlock held
 */
static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
{
	int max = 128;
	unsigned char byte;

	while (max-- > 0) {
		if (snd_mpu401_input_avail(mpu)) {
			byte = mpu->read(mpu, MPU401D(mpu));
			if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
				snd_rawmidi_receive(mpu->substream_input, &byte, 1);
		} else {
			break; /* input not available */
		}
	}
}

/*
 *  Tx FIFO sizes:
 *    CS4237B			- 16 bytes
 *    AudioDrive ES1688         - 12 bytes
 *    S3 SonicVibes             -  8 bytes
 *    SoundBlaster AWE 64       -  2 bytes (ugly hardware)
 */

/*
 * write output pending bytes
 * call with output_lock spinlock held
 */
static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
{
	unsigned char byte;
	int max = 256, timeout;

	do {
		if (snd_rawmidi_transmit_peek(mpu->substream_output, &byte, 1) == 1) {
			for (timeout = 100; timeout > 0; timeout--) {
				if (snd_mpu401_output_ready(mpu)) {
					mpu->write(mpu, byte, MPU401D(mpu));
					snd_rawmidi_transmit_ack(mpu->substream_output, 1);
					break;
				}
			}
			if (timeout == 0)
				break;	/* Tx FIFO full - try again later */
		} else {
			snd_mpu401_uart_remove_timer (mpu, 0);
			break;	/* no other data - leave the tx loop */
		}
	} while (--max > 0);
}

/*
 * output trigger callback
 */
static void snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
{
	unsigned long flags;
	struct snd_mpu401 *mpu;

	mpu = substream->rmidi->private_data;
	if (up) {
		set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);

		/* try to add the timer at each output trigger,
		 * since the output timer might have been removed in
		 * snd_mpu401_uart_output_write().
		 */
		snd_mpu401_uart_add_timer(mpu, 0);

		/* output pending data */
		spin_lock_irqsave(&mpu->output_lock, flags);
		snd_mpu401_uart_output_write(mpu);
		spin_unlock_irqrestore(&mpu->output_lock, flags);
	} else {
		snd_mpu401_uart_remove_timer(mpu, 0);
		clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
	}
}

/*

 */

static struct snd_rawmidi_ops snd_mpu401_uart_output =
{
	.open =		snd_mpu401_uart_output_open,
	.close =	snd_mpu401_uart_output_close,
	.trigger =	snd_mpu401_uart_output_trigger,
};

static struct snd_rawmidi_ops snd_mpu401_uart_input =
{
	.open =		snd_mpu401_uart_input_open,
	.close =	snd_mpu401_uart_input_close,
	.trigger =	snd_mpu401_uart_input_trigger,
};

static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
{
	struct snd_mpu401 *mpu = rmidi->private_data;
	if (mpu->irq_flags && mpu->irq >= 0)
		free_irq(mpu->irq, (void *) mpu);
	release_and_free_resource(mpu->res);
	kfree(mpu);
}

/**
 * snd_mpu401_uart_new - create an MPU401-UART instance
 * @card: the card instance
 * @device: the device index, zero-based
 * @hardware: the hardware type, MPU401_HW_XXXX
 * @port: the base address of MPU401 port
 * @integrated: non-zero if the port was already reserved by the chip
 * @irq: the irq number, -1 if no interrupt for mpu
 * @irq_flags: the irq request flags (SA_XXX), 0 if irq was already reserved.
 * @rrawmidi: the pointer to store the new rawmidi instance
 *
 * Creates a new MPU-401 instance.
 *
 * Note that the rawmidi instance is returned on the rrawmidi argument,
 * not the mpu401 instance itself.  To access to the mpu401 instance,
 * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
 *
 * Returns zero if successful, or a negative error code.
 */
int snd_mpu401_uart_new(struct snd_card *card, int device,
			unsigned short hardware,
			unsigned long port, int integrated,
			int irq, int irq_flags,
			struct snd_rawmidi ** rrawmidi)
{
	struct snd_mpu401 *mpu;
	struct snd_rawmidi *rmidi;
	int err;

	if (rrawmidi)
		*rrawmidi = NULL;
	if ((err = snd_rawmidi_new(card, "MPU-401U", device, 1, 1, &rmidi)) < 0)
		return err;
	mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
	if (mpu == NULL) {
		snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n");
		snd_device_free(card, rmidi);
		return -ENOMEM;
	}
	rmidi->private_data = mpu;
	rmidi->private_free = snd_mpu401_uart_free;
	spin_lock_init(&mpu->input_lock);
	spin_lock_init(&mpu->output_lock);
	spin_lock_init(&mpu->timer_lock);
	mpu->hardware = hardware;
	if (!integrated) {
		int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
		if ((mpu->res = request_region(port, res_size, "MPU401 UART")) == NULL) {
			snd_printk(KERN_ERR "mpu401_uart: unable to grab port 0x%lx size %d\n", port, res_size);
			snd_device_free(card, rmidi);
			return -EBUSY;
		}
	}
	switch (hardware) {
	case MPU401_HW_AUREAL:
		mpu->write = mpu401_write_mmio;
		mpu->read = mpu401_read_mmio;
		break;
	default:
		mpu->write = mpu401_write_port;
		mpu->read = mpu401_read_port;
		break;
	}
	mpu->port = port;
	if (hardware == MPU401_HW_PC98II)
		mpu->cport = port + 2;
	else
		mpu->cport = port + 1;
	if (irq >= 0 && irq_flags) {
		if (request_irq(irq, snd_mpu401_uart_interrupt, irq_flags, "MPU401 UART", (void *) mpu)) {
			snd_printk(KERN_ERR "mpu401_uart: unable to grab IRQ %d\n", irq);
			snd_device_free(card, rmidi);
			return -EBUSY;
		}
	}
	mpu->irq = irq;
	mpu->irq_flags = irq_flags;
	if (card->shortname[0])
		snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI", card->shortname);
	else
		sprintf(rmidi->name, "MPU-401 MIDI %d-%d", card->number, device);
	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_mpu401_uart_output);
	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_mpu401_uart_input);
	rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
	                     SNDRV_RAWMIDI_INFO_INPUT |
	                     SNDRV_RAWMIDI_INFO_DUPLEX;
	mpu->rmidi = rmidi;
	if (rrawmidi)
		*rrawmidi = rmidi;
	return 0;
}

EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
EXPORT_SYMBOL(snd_mpu401_uart_new);

/*
 *  INIT part
 */

static int __init alsa_mpu401_uart_init(void)
{
	return 0;
}

static void __exit alsa_mpu401_uart_exit(void)
{
}

module_init(alsa_mpu401_uart_init)
module_exit(alsa_mpu401_uart_exit)
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (c) by Jaroslav Kysela <perex@suse.cz>
	3	* Routines for control of MPU-401 in UART mode
	4	*
	5	* MPU-401 supports UART mode which is not capable generate transmit
	6	* interrupts thus output is done via polling. Also, if irq < 0, then
	7	* input is done also via polling. Do not expect good performance.
	8	*
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	23	*
	24	* 13-03-2003:
	25	* Added support for different kind of hardware I/O. Build in choices
	26	* are port and mmio. For other kind of I/O, set mpu->read and
	27	* mpu->write to your own I/O functions.
	28	*
	29	*/
	30
	31	#include <sound/driver.h>
	32	#include <asm/io.h>
	33	#include <linux/delay.h>
	34	#include <linux/init.h>
	35	#include <linux/slab.h>
	36	#include <linux/ioport.h>
	37	#include <linux/interrupt.h>
	38	#include <linux/errno.h>
	39	#include <sound/core.h>
	40	#include <sound/mpu401.h>
	41
	42	MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
	43	MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode");
	44	MODULE_LICENSE("GPL");
	45
e1fad17b TI	46	static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu);
e1fad17b TI	47	static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu);
1da177e4 LT	48
	49	/*
	50
	51	*/
	52
	53	#define snd_mpu401_input_avail(mpu) (!(mpu->read(mpu, MPU401C(mpu)) & 0x80))
	54	#define snd_mpu401_output_ready(mpu) (!(mpu->read(mpu, MPU401C(mpu)) & 0x40))
	55
	56	#define MPU401_RESET 0xff
	57	#define MPU401_ENTER_UART 0x3f
	58	#define MPU401_ACK 0xfe
	59
	60	/* Build in lowlevel io */
e1fad17b	61	static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr)
1da177e4 LT	62	{
	63	outb(data, addr);
	64	}
	65
e1fad17b	66	static unsigned char mpu401_read_port(struct snd_mpu401 *mpu, unsigned long addr)
1da177e4 LT	67	{
	68	return inb(addr);
	69	}
	70
e1fad17b	71	static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr)
1da177e4 LT	72	{
	73	writeb(data, (void __iomem *)addr);
	74	}
	75
e1fad17b	76	static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu, unsigned long addr)
1da177e4 LT	77	{
	78	return readb((void __iomem *)addr);
	79	}
	80	/* */
	81
e1fad17b	82	static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
1da177e4 LT	83	{
	84	int timeout = 100000;
	85	for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
	86	mpu->read(mpu, MPU401D(mpu));
	87	#ifdef CONFIG_SND_DEBUG
	88	if (timeout <= 0)
	89	snd_printk("cmd: clear rx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu)));
	90	#endif
	91	}
	92
e1fad17b	93	static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
1da177e4 LT	94	{
	95	spin_lock(&mpu->input_lock);
	96	if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
	97	snd_mpu401_uart_input_read(mpu);
	98	} else {
	99	snd_mpu401_uart_clear_rx(mpu);
	100	}
	101	spin_unlock(&mpu->input_lock);
	102	/* ok. for better Tx performance try do some output when input is done */
	103	if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
	104	test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
	105	spin_lock(&mpu->output_lock);
	106	snd_mpu401_uart_output_write(mpu);
	107	spin_unlock(&mpu->output_lock);
	108	}
	109	}
	110
	111	/**
	112	* snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler
	113	* @irq: the irq number
	114	* @dev_id: mpu401 instance
	115	* @regs: the reigster
	116	*
	117	* Processes the interrupt for MPU401-UART i/o.
	118	*/
	119	irqreturn_t snd_mpu401_uart_interrupt(int irq, void dev_id, struct pt_regs regs)
	120	{
e1fad17b	121	struct snd_mpu401 *mpu = dev_id;
1da177e4 LT	122
	123	if (mpu == NULL)
	124	return IRQ_NONE;
	125	_snd_mpu401_uart_interrupt(mpu);
	126	return IRQ_HANDLED;
	127	}
	128
	129	/*
	130	* timer callback
	131	* reprogram the timer and call the interrupt job
	132	*/
	133	static void snd_mpu401_uart_timer(unsigned long data)
	134	{
e1fad17b	135	struct snd_mpu401 mpu = (struct snd_mpu401 )data;
b32425ac	136	unsigned long flags;
1da177e4	137
b32425ac	138	spin_lock_irqsave(&mpu->timer_lock, flags);
1da177e4 LT	139	/mpu->mode \|= MPU401_MODE_TIMER;/
	140	mpu->timer.expires = 1 + jiffies;
	141	add_timer(&mpu->timer);
b32425ac	142	spin_unlock_irqrestore(&mpu->timer_lock, flags);
1da177e4 LT	143	if (mpu->rmidi)
	144	_snd_mpu401_uart_interrupt(mpu);
	145	}
	146
	147	/*
	148	* initialize the timer callback if not programmed yet
	149	*/
e1fad17b	150	static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
1da177e4 LT	151	{
	152	unsigned long flags;
	153
	154	spin_lock_irqsave (&mpu->timer_lock, flags);
	155	if (mpu->timer_invoked == 0) {
	156	init_timer(&mpu->timer);
	157	mpu->timer.data = (unsigned long)mpu;
	158	mpu->timer.function = snd_mpu401_uart_timer;
	159	mpu->timer.expires = 1 + jiffies;
	160	add_timer(&mpu->timer);
	161	}
	162	mpu->timer_invoked \|= input ? MPU401_MODE_INPUT_TIMER : MPU401_MODE_OUTPUT_TIMER;
	163	spin_unlock_irqrestore (&mpu->timer_lock, flags);
	164	}
	165
	166	/*
	167	* remove the timer callback if still active
	168	*/
e1fad17b	169	static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
1da177e4 LT	170	{
	171	unsigned long flags;
	172
	173	spin_lock_irqsave (&mpu->timer_lock, flags);
	174	if (mpu->timer_invoked) {
	175	mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER : ~MPU401_MODE_OUTPUT_TIMER;
	176	if (! mpu->timer_invoked)
	177	del_timer(&mpu->timer);
	178	}
	179	spin_unlock_irqrestore (&mpu->timer_lock, flags);
	180	}
	181
	182	/*
	183
	184	*/
	185
962f831f JM	186	static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
962f831f JM	187	int ack)
1da177e4 LT	188	{
	189	unsigned long flags;
	190	int timeout, ok;
	191
	192	spin_lock_irqsave(&mpu->input_lock, flags);
	193	if (mpu->hardware != MPU401_HW_TRID4DWAVE) {
	194	mpu->write(mpu, 0x00, MPU401D(mpu));
	195	/snd_mpu401_uart_clear_rx(mpu);/
	196	}
	197	/* ok. standard MPU-401 initialization */
	198	if (mpu->hardware != MPU401_HW_SB) {
	199	for (timeout = 1000; timeout > 0 && !snd_mpu401_output_ready(mpu); timeout--)
	200	udelay(10);
	201	#ifdef CONFIG_SND_DEBUG
	202	if (!timeout)
	203	snd_printk("cmd: tx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu)));
	204	#endif
	205	}
	206	mpu->write(mpu, cmd, MPU401C(mpu));
	207	if (ack) {
	208	ok = 0;
	209	timeout = 10000;
	210	while (!ok && timeout-- > 0) {
	211	if (snd_mpu401_input_avail(mpu)) {
	212	if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
	213	ok = 1;
	214	}
	215	}
	216	if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
	217	ok = 1;
	218	} else {
	219	ok = 1;
	220	}
	221	spin_unlock_irqrestore(&mpu->input_lock, flags);
962f831f	222	if (!ok) {
1da177e4	223	snd_printk("cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)\n", cmd, mpu->port, mpu->read(mpu, MPU401C(mpu)), mpu->read(mpu, MPU401D(mpu)));
962f831f JM	224	return 1;
	225	}
	226	return 0;
1da177e4 LT	227	}
	228
	229	/*
	230	* input/output open/close - protected by open_mutex in rawmidi.c
	231	*/
e1fad17b	232	static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
1da177e4	233	{
e1fad17b	234	struct snd_mpu401 *mpu;
1da177e4 LT	235	int err;
	236
	237	mpu = substream->rmidi->private_data;
	238	if (mpu->open_input && (err = mpu->open_input(mpu)) < 0)
	239	return err;
	240	if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
962f831f JM	241	if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
	242	goto error_out;
	243	if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 1))
	244	goto error_out;
1da177e4 LT	245	}
	246	mpu->substream_input = substream;
	247	set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
	248	return 0;
962f831f JM	249
	250	error_out:
	251	if (mpu->open_input && mpu->close_input)
	252	mpu->close_input(mpu);
	253	return -EIO;
1da177e4 LT	254	}
1da177e4 LT	255
e1fad17b	256	static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
1da177e4	257	{
e1fad17b	258	struct snd_mpu401 *mpu;
1da177e4 LT	259	int err;
	260
	261	mpu = substream->rmidi->private_data;
	262	if (mpu->open_output && (err = mpu->open_output(mpu)) < 0)
	263	return err;
	264	if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
962f831f JM	265	if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
	266	goto error_out;
	267	if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 1))
	268	goto error_out;
1da177e4 LT	269	}
	270	mpu->substream_output = substream;
	271	set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
	272	return 0;
962f831f JM	273
	274	error_out:
	275	if (mpu->open_output && mpu->close_output)
	276	mpu->close_output(mpu);
	277	return -EIO;
1da177e4 LT	278	}
1da177e4 LT	279
e1fad17b	280	static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
1da177e4	281	{
e1fad17b	282	struct snd_mpu401 *mpu;
962f831f	283	int err = 0;
1da177e4 LT	284
	285	mpu = substream->rmidi->private_data;
	286	clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
	287	mpu->substream_input = NULL;
	288	if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode))
962f831f	289	err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
1da177e4 LT	290	if (mpu->close_input)
1da177e4 LT	291	mpu->close_input(mpu);
962f831f JM	292	if (err)
962f831f JM	293	return -EIO;
1da177e4 LT	294	return 0;
	295	}
	296
e1fad17b	297	static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
1da177e4	298	{
e1fad17b	299	struct snd_mpu401 *mpu;
962f831f	300	int err = 0;
1da177e4 LT	301
	302	mpu = substream->rmidi->private_data;
	303	clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
	304	mpu->substream_output = NULL;
	305	if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
962f831f	306	err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
1da177e4 LT	307	if (mpu->close_output)
1da177e4 LT	308	mpu->close_output(mpu);
962f831f JM	309	if (err)
962f831f JM	310	return -EIO;
1da177e4 LT	311	return 0;
	312	}
	313
	314	/*
	315	* trigger input callback
	316	*/
e1fad17b	317	static void snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
1da177e4 LT	318	{
1da177e4 LT	319	unsigned long flags;
e1fad17b	320	struct snd_mpu401 *mpu;
1da177e4 LT	321	int max = 64;
	322
	323	mpu = substream->rmidi->private_data;
	324	if (up) {
	325	if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode)) {
	326	/* first time - flush FIFO */
	327	while (max-- > 0)
	328	mpu->read(mpu, MPU401D(mpu));
	329	if (mpu->irq < 0)
	330	snd_mpu401_uart_add_timer(mpu, 1);
	331	}
	332
	333	/* read data in advance */
	334	spin_lock_irqsave(&mpu->input_lock, flags);
	335	snd_mpu401_uart_input_read(mpu);
	336	spin_unlock_irqrestore(&mpu->input_lock, flags);
	337	} else {
	338	if (mpu->irq < 0)
	339	snd_mpu401_uart_remove_timer(mpu, 1);
	340	clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
	341	}
962f831f	342
1da177e4 LT	343	}
	344
	345	/*
	346	* transfer input pending data
	347	* call with input_lock spinlock held
	348	*/
e1fad17b	349	static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
1da177e4 LT	350	{
	351	int max = 128;
	352	unsigned char byte;
	353
	354	while (max-- > 0) {
	355	if (snd_mpu401_input_avail(mpu)) {
	356	byte = mpu->read(mpu, MPU401D(mpu));
	357	if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
	358	snd_rawmidi_receive(mpu->substream_input, &byte, 1);
	359	} else {
	360	break; /* input not available */
	361	}
	362	}
	363	}
	364
	365	/*
	366	* Tx FIFO sizes:
	367	* CS4237B - 16 bytes
	368	* AudioDrive ES1688 - 12 bytes
	369	* S3 SonicVibes - 8 bytes
	370	* SoundBlaster AWE 64 - 2 bytes (ugly hardware)
	371	*/
	372
	373	/*
	374	* write output pending bytes
	375	* call with output_lock spinlock held
	376	*/
e1fad17b	377	static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
1da177e4 LT	378	{
	379	unsigned char byte;
	380	int max = 256, timeout;
	381
	382	do {
	383	if (snd_rawmidi_transmit_peek(mpu->substream_output, &byte, 1) == 1) {
	384	for (timeout = 100; timeout > 0; timeout--) {
	385	if (snd_mpu401_output_ready(mpu)) {
	386	mpu->write(mpu, byte, MPU401D(mpu));
	387	snd_rawmidi_transmit_ack(mpu->substream_output, 1);
	388	break;
	389	}
	390	}
	391	if (timeout == 0)
	392	break; /* Tx FIFO full - try again later */
	393	} else {
	394	snd_mpu401_uart_remove_timer (mpu, 0);
	395	break; /* no other data - leave the tx loop */
	396	}
	397	} while (--max > 0);
	398	}
	399
	400	/*
	401	* output trigger callback
	402	*/
e1fad17b	403	static void snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
1da177e4 LT	404	{
1da177e4 LT	405	unsigned long flags;
e1fad17b	406	struct snd_mpu401 *mpu;
1da177e4 LT	407
	408	mpu = substream->rmidi->private_data;
	409	if (up) {
	410	set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
	411
	412	/* try to add the timer at each output trigger,
	413	* since the output timer might have been removed in
	414	* snd_mpu401_uart_output_write().
	415	*/
	416	snd_mpu401_uart_add_timer(mpu, 0);
	417
	418	/* output pending data */
	419	spin_lock_irqsave(&mpu->output_lock, flags);
	420	snd_mpu401_uart_output_write(mpu);
	421	spin_unlock_irqrestore(&mpu->output_lock, flags);
	422	} else {
	423	snd_mpu401_uart_remove_timer(mpu, 0);
	424	clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
	425	}
	426	}
	427
	428	/*
	429
	430	*/
	431
e1fad17b	432	static struct snd_rawmidi_ops snd_mpu401_uart_output =
1da177e4 LT	433	{
	434	.open = snd_mpu401_uart_output_open,
	435	.close = snd_mpu401_uart_output_close,
	436	.trigger = snd_mpu401_uart_output_trigger,
	437	};
	438
e1fad17b	439	static struct snd_rawmidi_ops snd_mpu401_uart_input =
1da177e4 LT	440	{
	441	.open = snd_mpu401_uart_input_open,
	442	.close = snd_mpu401_uart_input_close,
	443	.trigger = snd_mpu401_uart_input_trigger,
	444	};
	445
e1fad17b	446	static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
1da177e4	447	{
e1fad17b	448	struct snd_mpu401 *mpu = rmidi->private_data;
1da177e4 LT	449	if (mpu->irq_flags && mpu->irq >= 0)
1da177e4 LT	450	free_irq(mpu->irq, (void *) mpu);
b1d5776d	451	release_and_free_resource(mpu->res);
1da177e4 LT	452	kfree(mpu);
	453	}
	454
	455	/**
	456	* snd_mpu401_uart_new - create an MPU401-UART instance
	457	* @card: the card instance
	458	* @device: the device index, zero-based
	459	* @hardware: the hardware type, MPU401_HW_XXXX
	460	* @port: the base address of MPU401 port
	461	* @integrated: non-zero if the port was already reserved by the chip
	462	* @irq: the irq number, -1 if no interrupt for mpu
	463	* @irq_flags: the irq request flags (SA_XXX), 0 if irq was already reserved.
	464	* @rrawmidi: the pointer to store the new rawmidi instance
	465	*
	466	* Creates a new MPU-401 instance.
	467	*
	468	* Note that the rawmidi instance is returned on the rrawmidi argument,
	469	* not the mpu401 instance itself. To access to the mpu401 instance,
e1fad17b	470	* cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
1da177e4 LT	471	*
	472	* Returns zero if successful, or a negative error code.
	473	*/
e1fad17b	474	int snd_mpu401_uart_new(struct snd_card *card, int device,
1da177e4 LT	475	unsigned short hardware,
	476	unsigned long port, int integrated,
	477	int irq, int irq_flags,
e1fad17b	478	struct snd_rawmidi ** rrawmidi)
1da177e4	479	{
e1fad17b TI	480	struct snd_mpu401 *mpu;
e1fad17b TI	481	struct snd_rawmidi *rmidi;
1da177e4 LT	482	int err;
	483
	484	if (rrawmidi)
	485	*rrawmidi = NULL;
	486	if ((err = snd_rawmidi_new(card, "MPU-401U", device, 1, 1, &rmidi)) < 0)
	487	return err;
561b220a	488	mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
1da177e4	489	if (mpu == NULL) {
73e77ba0	490	snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n");
1da177e4 LT	491	snd_device_free(card, rmidi);
	492	return -ENOMEM;
	493	}
	494	rmidi->private_data = mpu;
	495	rmidi->private_free = snd_mpu401_uart_free;
	496	spin_lock_init(&mpu->input_lock);
	497	spin_lock_init(&mpu->output_lock);
	498	spin_lock_init(&mpu->timer_lock);
	499	mpu->hardware = hardware;
	500	if (!integrated) {
	501	int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
	502	if ((mpu->res = request_region(port, res_size, "MPU401 UART")) == NULL) {
	503	snd_printk(KERN_ERR "mpu401_uart: unable to grab port 0x%lx size %d\n", port, res_size);
	504	snd_device_free(card, rmidi);
	505	return -EBUSY;
	506	}
	507	}
	508	switch (hardware) {
	509	case MPU401_HW_AUREAL:
	510	mpu->write = mpu401_write_mmio;
	511	mpu->read = mpu401_read_mmio;
	512	break;
	513	default:
	514	mpu->write = mpu401_write_port;
	515	mpu->read = mpu401_read_port;
	516	break;
	517	}
	518	mpu->port = port;
	519	if (hardware == MPU401_HW_PC98II)
	520	mpu->cport = port + 2;
	521	else
	522	mpu->cport = port + 1;
	523	if (irq >= 0 && irq_flags) {
	524	if (request_irq(irq, snd_mpu401_uart_interrupt, irq_flags, "MPU401 UART", (void *) mpu)) {
	525	snd_printk(KERN_ERR "mpu401_uart: unable to grab IRQ %d\n", irq);
	526	snd_device_free(card, rmidi);
	527	return -EBUSY;
	528	}
	529	}
	530	mpu->irq = irq;
	531	mpu->irq_flags = irq_flags;
	532	if (card->shortname[0])
	533	snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI", card->shortname);
	534	else
	535	sprintf(rmidi->name, "MPU-401 MIDI %d-%d", card->number, device);
	536	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_mpu401_uart_output);
	537	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_mpu401_uart_input);
	538	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_OUTPUT \|
	539	SNDRV_RAWMIDI_INFO_INPUT \|
	540	SNDRV_RAWMIDI_INFO_DUPLEX;
	541	mpu->rmidi = rmidi;
	542	if (rrawmidi)
	543	*rrawmidi = rmidi;
	544	return 0;
	545	}
	546
	547	EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
	548	EXPORT_SYMBOL(snd_mpu401_uart_new);
	549
	550	/*
	551	* INIT part
	552	*/
	553
	554	static int __init alsa_mpu401_uart_init(void)
555	{
556	return 0;
557	}
558
559	static void __exit alsa_mpu401_uart_exit(void)
560	{
561	}
562
563	module_init(alsa_mpu401_uart_init)
564	module_exit(alsa_mpu401_uart_exit)