[deliverable/linux.git] / sound / drivers / mpu401 / mpu401_uart.c

/*
 *  Copyright (c) by Jaroslav Kysela <perex@perex.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. Without interrupt,
 *  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 <asm/io.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <sound/core.h>
#include <sound/mpu401.h>

MODULE_AUTHOR("Jaroslav Kysela <perex@perex.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)) & MPU401_RX_EMPTY))
#define snd_mpu401_output_ready(mpu) \
	(!(mpu->read(mpu, MPU401C(mpu)) & MPU401_TX_FULL))

/* 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(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n",
			   mpu->read(mpu, MPU401C(mpu)));
#endif
}

static void uart_interrupt_tx(struct snd_mpu401 *mpu)
{
	unsigned long flags;

	if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
	    test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
		spin_lock_irqsave(&mpu->output_lock, flags);
		snd_mpu401_uart_output_write(mpu);
		spin_unlock_irqrestore(&mpu->output_lock, flags);
	}
}

static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
{
	unsigned long flags;

	if (mpu->info_flags & MPU401_INFO_INPUT) {
		spin_lock_irqsave(&mpu->input_lock, flags);
		if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
			snd_mpu401_uart_input_read(mpu);
		else
			snd_mpu401_uart_clear_rx(mpu);
		spin_unlock_irqrestore(&mpu->input_lock, flags);
	}
	if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
		/* ok. for better Tx performance try do some output
		   when input is done */
		uart_interrupt_tx(mpu);
}

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

EXPORT_SYMBOL(snd_mpu401_uart_interrupt);

/**
 * snd_mpu401_uart_interrupt_tx - generic MPU401-UART transmit irq handler
 * @irq: the irq number
 * @dev_id: mpu401 instance
 *
 * Processes the interrupt for MPU401-UART output.
 *
 * Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
 */
irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id)
{
	struct snd_mpu401 *mpu = dev_id;
	
	if (mpu == NULL)
		return IRQ_NONE;
	uart_interrupt_tx(mpu);
	return IRQ_HANDLED;
}

EXPORT_SYMBOL(snd_mpu401_uart_interrupt_tx);

/*
 * 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);
}

/*
 * send a UART command
 * return zero if successful, non-zero for some errors
 */

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(KERN_ERR "cmd: tx timeout (status = 0x%x)\n",
				   mpu->read(mpu, MPU401C(mpu)));
#endif
	}
	mpu->write(mpu, cmd, MPU401C(mpu));
	if (ack && !(mpu->info_flags & MPU401_INFO_NO_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(KERN_ERR "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;
}

static int snd_mpu401_do_reset(struct snd_mpu401 *mpu)
{
	if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
		return -EIO;
	if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0))
		return -EIO;
	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_do_reset(mpu) < 0)
			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_do_reset(mpu) < 0)
			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->info_flags & MPU401_INFO_USE_TIMER)
				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->info_flags & MPU401_INFO_USE_TIMER)
			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))
			break; /* input not available */
		byte = mpu->read(mpu, MPU401D(mpu));
		if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
			snd_rawmidi_receive(mpu->substream_input, &byte, 1);
	}
}

/*
 *  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;

	do {
		if (snd_rawmidi_transmit_peek(mpu->substream_output,
					      &byte, 1) == 1) {
			/*
			 * Try twice because there is hardware that insists on
			 * setting the output busy bit after each write.
			 */
			if (!snd_mpu401_output_ready(mpu) &&
			    !snd_mpu401_output_ready(mpu))
				break;	/* Tx FIFO full - try again later */
			mpu->write(mpu, byte, MPU401D(mpu));
			snd_rawmidi_transmit_ack(mpu->substream_output, 1);
		} 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().
		 */
		if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
			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 {
		if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
			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 >= 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
 * @info_flags: bitflags MPU401_INFO_XXX
 * @irq: the ISA irq number, -1 if not to be allocated
 * @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).
 *
 * Return: 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,
			unsigned int info_flags,
			int irq,
			struct snd_rawmidi ** rrawmidi)
{
	struct snd_mpu401 *mpu;
	struct snd_rawmidi *rmidi;
	int in_enable, out_enable;
	int err;

	if (rrawmidi)
		*rrawmidi = NULL;
	if (! (info_flags & (MPU401_INFO_INPUT | MPU401_INFO_OUTPUT)))
		info_flags |= MPU401_INFO_INPUT | MPU401_INFO_OUTPUT;
	in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0;
	out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0;
	if ((err = snd_rawmidi_new(card, "MPU-401U", device,
				   out_enable, in_enable, &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;
	mpu->irq = -1;
	if (! (info_flags & MPU401_INFO_INTEGRATED)) {
		int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
		mpu->res = request_region(port, res_size, "MPU401 UART");
		if (mpu->res == 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;
		}
	}
	if (info_flags & MPU401_INFO_MMIO) {
		mpu->write = mpu401_write_mmio;
		mpu->read = mpu401_read_mmio;
	} else {
		mpu->write = mpu401_write_port;
		mpu->read = mpu401_read_port;
	}
	mpu->port = port;
	if (hardware == MPU401_HW_PC98II)
		mpu->cport = port + 2;
	else
		mpu->cport = port + 1;
	if (irq >= 0) {
		if (request_irq(irq, snd_mpu401_uart_interrupt, 0,
				"MPU401 UART", (void *) mpu)) {
			snd_printk(KERN_ERR "mpu401_uart: "
				   "unable to grab IRQ %d\n", irq);
			snd_device_free(card, rmidi);
			return -EBUSY;
		}
	}
	if (irq < 0 && !(info_flags & MPU401_INFO_IRQ_HOOK))
		info_flags |= MPU401_INFO_USE_TIMER;
	mpu->info_flags = info_flags;
	mpu->irq = irq;
	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);
	if (out_enable) {
		snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
				    &snd_mpu401_uart_output);
		rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
	}
	if (in_enable) {
		snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
				    &snd_mpu401_uart_input);
		rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
		if (out_enable)
			rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
	}
	mpu->rmidi = rmidi;
	if (rrawmidi)
		*rrawmidi = rmidi;
	return 0;
}

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	1	/*
c1017a4c	2	* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
1da177e4 LT	3	* Routines for control of MPU-401 in UART mode
	4	*
	5	* MPU-401 supports UART mode which is not capable generate transmit
dba8b469	6	* interrupts thus output is done via polling. Without interrupt,
1da177e4 LT	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
1da177e4 LT	31	#include <asm/io.h>
	32	#include <linux/delay.h>
	33	#include <linux/init.h>
	34	#include <linux/slab.h>
	35	#include <linux/ioport.h>
da155d5b	36	#include <linux/module.h>
1da177e4 LT	37	#include <linux/interrupt.h>
	38	#include <linux/errno.h>
	39	#include <sound/core.h>
	40	#include <sound/mpu401.h>
	41
c1017a4c	42	MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
1da177e4 LT	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
b415ed45 TI	53	#define snd_mpu401_input_avail(mpu) \
	54	(!(mpu->read(mpu, MPU401C(mpu)) & MPU401_RX_EMPTY))
	55	#define snd_mpu401_output_ready(mpu) \
	56	(!(mpu->read(mpu, MPU401C(mpu)) & MPU401_TX_FULL))
1da177e4 LT	57
1da177e4 LT	58	/* Build in lowlevel io */
2851d963 TI	59	static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data,
2851d963 TI	60	unsigned long addr)
1da177e4 LT	61	{
	62	outb(data, addr);
	63	}
	64
2851d963 TI	65	static unsigned char mpu401_read_port(struct snd_mpu401 *mpu,
2851d963 TI	66	unsigned long addr)
1da177e4 LT	67	{
	68	return inb(addr);
	69	}
	70
2851d963 TI	71	static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data,
2851d963 TI	72	unsigned long addr)
1da177e4 LT	73	{
	74	writeb(data, (void __iomem *)addr);
	75	}
	76
2851d963 TI	77	static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu,
2851d963 TI	78	unsigned long addr)
1da177e4 LT	79	{
	80	return readb((void __iomem *)addr);
	81	}
	82	/* */
	83
e1fad17b	84	static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
1da177e4 LT	85	{
	86	int timeout = 100000;
	87	for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
	88	mpu->read(mpu, MPU401D(mpu));
	89	#ifdef CONFIG_SND_DEBUG
	90	if (timeout <= 0)
2851d963 TI	91	snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n",
2851d963 TI	92	mpu->read(mpu, MPU401C(mpu)));
1da177e4 LT	93	#endif
	94	}
	95
302e4c2f	96	static void uart_interrupt_tx(struct snd_mpu401 *mpu)
1da177e4	97	{
60fac85f CL	98	unsigned long flags;
60fac85f CL	99
1da177e4 LT	100	if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
1da177e4 LT	101	test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
60fac85f	102	spin_lock_irqsave(&mpu->output_lock, flags);
1da177e4	103	snd_mpu401_uart_output_write(mpu);
60fac85f	104	spin_unlock_irqrestore(&mpu->output_lock, flags);
1da177e4 LT	105	}
	106	}
	107
302e4c2f TI	108	static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
302e4c2f TI	109	{
60fac85f CL	110	unsigned long flags;
60fac85f CL	111
302e4c2f	112	if (mpu->info_flags & MPU401_INFO_INPUT) {
60fac85f	113	spin_lock_irqsave(&mpu->input_lock, flags);
302e4c2f TI	114	if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
	115	snd_mpu401_uart_input_read(mpu);
	116	else
	117	snd_mpu401_uart_clear_rx(mpu);
60fac85f	118	spin_unlock_irqrestore(&mpu->input_lock, flags);
302e4c2f TI	119	}
	120	if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
	121	/* ok. for better Tx performance try do some output
	122	when input is done */
	123	uart_interrupt_tx(mpu);
	124	}
	125
1da177e4 LT	126	/**
	127	* snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler
	128	* @irq: the irq number
	129	* @dev_id: mpu401 instance
1da177e4 LT	130	*
1da177e4 LT	131	* Processes the interrupt for MPU401-UART i/o.
eb7c06e8 YB	132	*
eb7c06e8 YB	133	* Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
1da177e4	134	*/
7d12e780	135	irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id)
1da177e4	136	{
e1fad17b	137	struct snd_mpu401 *mpu = dev_id;
1da177e4 LT	138
	139	if (mpu == NULL)
	140	return IRQ_NONE;
	141	_snd_mpu401_uart_interrupt(mpu);
	142	return IRQ_HANDLED;
	143	}
	144
2851d963 TI	145	EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
2851d963 TI	146
302e4c2f TI	147	/**
	148	* snd_mpu401_uart_interrupt_tx - generic MPU401-UART transmit irq handler
	149	* @irq: the irq number
	150	* @dev_id: mpu401 instance
302e4c2f TI	151	*
302e4c2f TI	152	* Processes the interrupt for MPU401-UART output.
eb7c06e8 YB	153	*
eb7c06e8 YB	154	* Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
302e4c2f	155	*/
7d12e780	156	irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id)
302e4c2f TI	157	{
	158	struct snd_mpu401 *mpu = dev_id;
	159
	160	if (mpu == NULL)
	161	return IRQ_NONE;
	162	uart_interrupt_tx(mpu);
	163	return IRQ_HANDLED;
	164	}
	165
	166	EXPORT_SYMBOL(snd_mpu401_uart_interrupt_tx);
	167
1da177e4 LT	168	/*
	169	* timer callback
	170	* reprogram the timer and call the interrupt job
	171	*/
	172	static void snd_mpu401_uart_timer(unsigned long data)
	173	{
e1fad17b	174	struct snd_mpu401 mpu = (struct snd_mpu401 )data;
b32425ac	175	unsigned long flags;
1da177e4	176
b32425ac	177	spin_lock_irqsave(&mpu->timer_lock, flags);
1da177e4 LT	178	/mpu->mode \|= MPU401_MODE_TIMER;/
	179	mpu->timer.expires = 1 + jiffies;
	180	add_timer(&mpu->timer);
b32425ac	181	spin_unlock_irqrestore(&mpu->timer_lock, flags);
1da177e4 LT	182	if (mpu->rmidi)
	183	_snd_mpu401_uart_interrupt(mpu);
	184	}
	185
	186	/*
	187	* initialize the timer callback if not programmed yet
	188	*/
e1fad17b	189	static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
1da177e4 LT	190	{
	191	unsigned long flags;
	192
	193	spin_lock_irqsave (&mpu->timer_lock, flags);
	194	if (mpu->timer_invoked == 0) {
	195	init_timer(&mpu->timer);
	196	mpu->timer.data = (unsigned long)mpu;
	197	mpu->timer.function = snd_mpu401_uart_timer;
	198	mpu->timer.expires = 1 + jiffies;
	199	add_timer(&mpu->timer);
	200	}
2851d963 TI	201	mpu->timer_invoked \|= input ? MPU401_MODE_INPUT_TIMER :
2851d963 TI	202	MPU401_MODE_OUTPUT_TIMER;
1da177e4 LT	203	spin_unlock_irqrestore (&mpu->timer_lock, flags);
	204	}
	205
	206	/*
	207	* remove the timer callback if still active
	208	*/
e1fad17b	209	static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
1da177e4 LT	210	{
	211	unsigned long flags;
	212
	213	spin_lock_irqsave (&mpu->timer_lock, flags);
	214	if (mpu->timer_invoked) {
2851d963 TI	215	mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER :
2851d963 TI	216	~MPU401_MODE_OUTPUT_TIMER;
1da177e4 LT	217	if (! mpu->timer_invoked)
	218	del_timer(&mpu->timer);
	219	}
	220	spin_unlock_irqrestore (&mpu->timer_lock, flags);
	221	}
	222
	223	/*
2851d963 TI	224	* send a UART command
2851d963 TI	225	* return zero if successful, non-zero for some errors
1da177e4 LT	226	*/
1da177e4 LT	227
962f831f	228	static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
2851d963	229	int ack)
1da177e4 LT	230	{
	231	unsigned long flags;
	232	int timeout, ok;
	233
	234	spin_lock_irqsave(&mpu->input_lock, flags);
	235	if (mpu->hardware != MPU401_HW_TRID4DWAVE) {
	236	mpu->write(mpu, 0x00, MPU401D(mpu));
	237	/snd_mpu401_uart_clear_rx(mpu);/
	238	}
	239	/* ok. standard MPU-401 initialization */
	240	if (mpu->hardware != MPU401_HW_SB) {
2851d963 TI	241	for (timeout = 1000; timeout > 0 &&
2851d963 TI	242	!snd_mpu401_output_ready(mpu); timeout--)
1da177e4 LT	243	udelay(10);
	244	#ifdef CONFIG_SND_DEBUG
	245	if (!timeout)
2851d963 TI	246	snd_printk(KERN_ERR "cmd: tx timeout (status = 0x%x)\n",
2851d963 TI	247	mpu->read(mpu, MPU401C(mpu)));
1da177e4 LT	248	#endif
	249	}
	250	mpu->write(mpu, cmd, MPU401C(mpu));
df7e3fdf	251	if (ack && !(mpu->info_flags & MPU401_INFO_NO_ACK)) {
1da177e4 LT	252	ok = 0;
	253	timeout = 10000;
	254	while (!ok && timeout-- > 0) {
	255	if (snd_mpu401_input_avail(mpu)) {
	256	if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
	257	ok = 1;
	258	}
	259	}
	260	if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
	261	ok = 1;
2851d963	262	} else
1da177e4	263	ok = 1;
1da177e4	264	spin_unlock_irqrestore(&mpu->input_lock, flags);
962f831f	265	if (!ok) {
2851d963 TI	266	snd_printk(KERN_ERR "cmd: 0x%x failed at 0x%lx "
	267	"(status = 0x%x, data = 0x%x)\n", cmd, mpu->port,
	268	mpu->read(mpu, MPU401C(mpu)),
	269	mpu->read(mpu, MPU401D(mpu)));
962f831f JM	270	return 1;
	271	}
	272	return 0;
1da177e4 LT	273	}
1da177e4 LT	274
8f7ba051 TI	275	static int snd_mpu401_do_reset(struct snd_mpu401 *mpu)
	276	{
	277	if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
	278	return -EIO;
c1099fcb	279	if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0))
8f7ba051 TI	280	return -EIO;
	281	return 0;
	282	}
	283
1da177e4 LT	284	/*
	285	* input/output open/close - protected by open_mutex in rawmidi.c
	286	*/
e1fad17b	287	static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
1da177e4	288	{
e1fad17b	289	struct snd_mpu401 *mpu;
1da177e4 LT	290	int err;
	291
	292	mpu = substream->rmidi->private_data;
	293	if (mpu->open_input && (err = mpu->open_input(mpu)) < 0)
	294	return err;
	295	if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
8f7ba051	296	if (snd_mpu401_do_reset(mpu) < 0)
962f831f	297	goto error_out;
1da177e4 LT	298	}
	299	mpu->substream_input = substream;
	300	set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
	301	return 0;
962f831f JM	302
	303	error_out:
	304	if (mpu->open_input && mpu->close_input)
	305	mpu->close_input(mpu);
	306	return -EIO;
1da177e4 LT	307	}
1da177e4 LT	308
e1fad17b	309	static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
1da177e4	310	{
e1fad17b	311	struct snd_mpu401 *mpu;
1da177e4 LT	312	int err;
	313
	314	mpu = substream->rmidi->private_data;
	315	if (mpu->open_output && (err = mpu->open_output(mpu)) < 0)
	316	return err;
	317	if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
8f7ba051	318	if (snd_mpu401_do_reset(mpu) < 0)
962f831f	319	goto error_out;
1da177e4 LT	320	}
	321	mpu->substream_output = substream;
	322	set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
	323	return 0;
962f831f JM	324
	325	error_out:
	326	if (mpu->open_output && mpu->close_output)
	327	mpu->close_output(mpu);
	328	return -EIO;
1da177e4 LT	329	}
1da177e4 LT	330
e1fad17b	331	static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
1da177e4	332	{
e1fad17b	333	struct snd_mpu401 *mpu;
962f831f	334	int err = 0;
1da177e4 LT	335
	336	mpu = substream->rmidi->private_data;
	337	clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
	338	mpu->substream_input = NULL;
	339	if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode))
962f831f	340	err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
1da177e4 LT	341	if (mpu->close_input)
1da177e4 LT	342	mpu->close_input(mpu);
962f831f JM	343	if (err)
962f831f JM	344	return -EIO;
1da177e4 LT	345	return 0;
	346	}
	347
e1fad17b	348	static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
1da177e4	349	{
e1fad17b	350	struct snd_mpu401 *mpu;
962f831f	351	int err = 0;
1da177e4 LT	352
	353	mpu = substream->rmidi->private_data;
	354	clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
	355	mpu->substream_output = NULL;
	356	if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
962f831f	357	err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
1da177e4 LT	358	if (mpu->close_output)
1da177e4 LT	359	mpu->close_output(mpu);
962f831f JM	360	if (err)
962f831f JM	361	return -EIO;
1da177e4 LT	362	return 0;
	363	}
	364
	365	/*
	366	* trigger input callback
	367	*/
2851d963 TI	368	static void
2851d963 TI	369	snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
1da177e4 LT	370	{
1da177e4 LT	371	unsigned long flags;
e1fad17b	372	struct snd_mpu401 *mpu;
1da177e4 LT	373	int max = 64;
	374
	375	mpu = substream->rmidi->private_data;
	376	if (up) {
2851d963 TI	377	if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER,
2851d963 TI	378	&mpu->mode)) {
1da177e4 LT	379	/* first time - flush FIFO */
	380	while (max-- > 0)
	381	mpu->read(mpu, MPU401D(mpu));
dba8b469	382	if (mpu->info_flags & MPU401_INFO_USE_TIMER)
1da177e4 LT	383	snd_mpu401_uart_add_timer(mpu, 1);
	384	}
	385
	386	/* read data in advance */
	387	spin_lock_irqsave(&mpu->input_lock, flags);
	388	snd_mpu401_uart_input_read(mpu);
	389	spin_unlock_irqrestore(&mpu->input_lock, flags);
	390	} else {
dba8b469	391	if (mpu->info_flags & MPU401_INFO_USE_TIMER)
1da177e4 LT	392	snd_mpu401_uart_remove_timer(mpu, 1);
	393	clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
	394	}
962f831f	395
1da177e4 LT	396	}
	397
	398	/*
	399	* transfer input pending data
	400	* call with input_lock spinlock held
	401	*/
e1fad17b	402	static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
1da177e4 LT	403	{
	404	int max = 128;
	405	unsigned char byte;
	406
	407	while (max-- > 0) {
2851d963	408	if (! snd_mpu401_input_avail(mpu))
1da177e4	409	break; /* input not available */
2851d963 TI	410	byte = mpu->read(mpu, MPU401D(mpu));
	411	if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
	412	snd_rawmidi_receive(mpu->substream_input, &byte, 1);
1da177e4 LT	413	}
	414	}
	415
	416	/*
	417	* Tx FIFO sizes:
	418	* CS4237B - 16 bytes
	419	* AudioDrive ES1688 - 12 bytes
	420	* S3 SonicVibes - 8 bytes
	421	* SoundBlaster AWE 64 - 2 bytes (ugly hardware)
	422	*/
	423
	424	/*
	425	* write output pending bytes
	426	* call with output_lock spinlock held
	427	*/
e1fad17b	428	static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
1da177e4 LT	429	{
1da177e4 LT	430	unsigned char byte;
ea6b5828	431	int max = 256;
1da177e4 LT	432
1da177e4 LT	433	do {
2851d963 TI	434	if (snd_rawmidi_transmit_peek(mpu->substream_output,
2851d963 TI	435	&byte, 1) == 1) {
ea6b5828 CL	436	/*
	437	* Try twice because there is hardware that insists on
	438	* setting the output busy bit after each write.
	439	*/
	440	if (!snd_mpu401_output_ready(mpu) &&
	441	!snd_mpu401_output_ready(mpu))
1da177e4	442	break; /* Tx FIFO full - try again later */
2851d963 TI	443	mpu->write(mpu, byte, MPU401D(mpu));
2851d963 TI	444	snd_rawmidi_transmit_ack(mpu->substream_output, 1);
1da177e4 LT	445	} else {
	446	snd_mpu401_uart_remove_timer (mpu, 0);
	447	break; /* no other data - leave the tx loop */
	448	}
	449	} while (--max > 0);
	450	}
	451
	452	/*
	453	* output trigger callback
	454	*/
2851d963 TI	455	static void
2851d963 TI	456	snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
1da177e4 LT	457	{
1da177e4 LT	458	unsigned long flags;
e1fad17b	459	struct snd_mpu401 *mpu;
1da177e4 LT	460
	461	mpu = substream->rmidi->private_data;
	462	if (up) {
	463	set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
	464
	465	/* try to add the timer at each output trigger,
	466	* since the output timer might have been removed in
	467	* snd_mpu401_uart_output_write().
	468	*/
302e4c2f TI	469	if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
302e4c2f TI	470	snd_mpu401_uart_add_timer(mpu, 0);
1da177e4 LT	471
	472	/* output pending data */
	473	spin_lock_irqsave(&mpu->output_lock, flags);
	474	snd_mpu401_uart_output_write(mpu);
	475	spin_unlock_irqrestore(&mpu->output_lock, flags);
	476	} else {
302e4c2f TI	477	if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
302e4c2f TI	478	snd_mpu401_uart_remove_timer(mpu, 0);
1da177e4 LT	479	clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
	480	}
	481	}
	482
	483	/*
	484
	485	*/
	486
e1fad17b	487	static struct snd_rawmidi_ops snd_mpu401_uart_output =
1da177e4 LT	488	{
	489	.open = snd_mpu401_uart_output_open,
	490	.close = snd_mpu401_uart_output_close,
	491	.trigger = snd_mpu401_uart_output_trigger,
	492	};
	493
e1fad17b	494	static struct snd_rawmidi_ops snd_mpu401_uart_input =
1da177e4 LT	495	{
	496	.open = snd_mpu401_uart_input_open,
	497	.close = snd_mpu401_uart_input_close,
	498	.trigger = snd_mpu401_uart_input_trigger,
	499	};
	500
e1fad17b	501	static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
1da177e4	502	{
e1fad17b	503	struct snd_mpu401 *mpu = rmidi->private_data;
dba8b469	504	if (mpu->irq >= 0)
1da177e4	505	free_irq(mpu->irq, (void *) mpu);
b1d5776d	506	release_and_free_resource(mpu->res);
1da177e4 LT	507	kfree(mpu);
	508	}
	509
	510	/**
	511	* snd_mpu401_uart_new - create an MPU401-UART instance
	512	* @card: the card instance
	513	* @device: the device index, zero-based
	514	* @hardware: the hardware type, MPU401_HW_XXXX
	515	* @port: the base address of MPU401 port
302e4c2f	516	* @info_flags: bitflags MPU401_INFO_XXX
dba8b469	517	* @irq: the ISA irq number, -1 if not to be allocated
1da177e4 LT	518	* @rrawmidi: the pointer to store the new rawmidi instance
	519	*
	520	* Creates a new MPU-401 instance.
	521	*
	522	* Note that the rawmidi instance is returned on the rrawmidi argument,
	523	* not the mpu401 instance itself. To access to the mpu401 instance,
e1fad17b	524	* cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
1da177e4	525	*
eb7c06e8	526	* Return: Zero if successful, or a negative error code.
1da177e4	527	*/
e1fad17b	528	int snd_mpu401_uart_new(struct snd_card *card, int device,
1da177e4	529	unsigned short hardware,
302e4c2f TI	530	unsigned long port,
302e4c2f TI	531	unsigned int info_flags,
dba8b469	532	int irq,
e1fad17b	533	struct snd_rawmidi ** rrawmidi)
1da177e4	534	{
e1fad17b TI	535	struct snd_mpu401 *mpu;
e1fad17b TI	536	struct snd_rawmidi *rmidi;
302e4c2f	537	int in_enable, out_enable;
1da177e4 LT	538	int err;
	539
	540	if (rrawmidi)
	541	*rrawmidi = NULL;
302e4c2f TI	542	if (! (info_flags & (MPU401_INFO_INPUT \| MPU401_INFO_OUTPUT)))
	543	info_flags \|= MPU401_INFO_INPUT \| MPU401_INFO_OUTPUT;
	544	in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0;
	545	out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0;
	546	if ((err = snd_rawmidi_new(card, "MPU-401U", device,
	547	out_enable, in_enable, &rmidi)) < 0)
1da177e4	548	return err;
561b220a	549	mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
1da177e4	550	if (mpu == NULL) {
73e77ba0	551	snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n");
1da177e4 LT	552	snd_device_free(card, rmidi);
	553	return -ENOMEM;
	554	}
	555	rmidi->private_data = mpu;
	556	rmidi->private_free = snd_mpu401_uart_free;
	557	spin_lock_init(&mpu->input_lock);
	558	spin_lock_init(&mpu->output_lock);
	559	spin_lock_init(&mpu->timer_lock);
	560	mpu->hardware = hardware;
bc733d49	561	mpu->irq = -1;
302e4c2f	562	if (! (info_flags & MPU401_INFO_INTEGRATED)) {
1da177e4	563	int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
2851d963 TI	564	mpu->res = request_region(port, res_size, "MPU401 UART");
	565	if (mpu->res == NULL) {
	566	snd_printk(KERN_ERR "mpu401_uart: "
	567	"unable to grab port 0x%lx size %d\n",
	568	port, res_size);
1da177e4 LT	569	snd_device_free(card, rmidi);
	570	return -EBUSY;
	571	}
	572	}
302e4c2f	573	if (info_flags & MPU401_INFO_MMIO) {
1da177e4 LT	574	mpu->write = mpu401_write_mmio;
1da177e4 LT	575	mpu->read = mpu401_read_mmio;
302e4c2f	576	} else {
1da177e4 LT	577	mpu->write = mpu401_write_port;
1da177e4 LT	578	mpu->read = mpu401_read_port;
1da177e4 LT	579	}
	580	mpu->port = port;
	581	if (hardware == MPU401_HW_PC98II)
	582	mpu->cport = port + 2;
	583	else
	584	mpu->cport = port + 1;
dba8b469	585	if (irq >= 0) {
88e24c3a	586	if (request_irq(irq, snd_mpu401_uart_interrupt, 0,
2851d963 TI	587	"MPU401 UART", (void *) mpu)) {
	588	snd_printk(KERN_ERR "mpu401_uart: "
	589	"unable to grab IRQ %d\n", irq);
1da177e4 LT	590	snd_device_free(card, rmidi);
	591	return -EBUSY;
	592	}
	593	}
dba8b469 CL	594	if (irq < 0 && !(info_flags & MPU401_INFO_IRQ_HOOK))
dba8b469 CL	595	info_flags \|= MPU401_INFO_USE_TIMER;
302e4c2f	596	mpu->info_flags = info_flags;
1da177e4	597	mpu->irq = irq;
1da177e4	598	if (card->shortname[0])
2851d963 TI	599	snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI",
2851d963 TI	600	card->shortname);
1da177e4	601	else
2851d963	602	sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device);
302e4c2f TI	603	if (out_enable) {
	604	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
	605	&snd_mpu401_uart_output);
	606	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_OUTPUT;
	607	}
	608	if (in_enable) {
	609	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
	610	&snd_mpu401_uart_input);
	611	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_INPUT;
	612	if (out_enable)
	613	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_DUPLEX;
	614	}
1da177e4 LT	615	mpu->rmidi = rmidi;
	616	if (rrawmidi)
	617	*rrawmidi = rmidi;
	618	return 0;
	619	}
	620
1da177e4 LT	621	EXPORT_SYMBOL(snd_mpu401_uart_new);
	622
	623	/*
	624	* INIT part
	625	*/
	626
	627	static int __init alsa_mpu401_uart_init(void)
	628	{
	629	return 0;
	630	}
	631
	632	static void __exit alsa_mpu401_uart_exit(void)
	633	{
	634	}
	635
	636	module_init(alsa_mpu401_uart_init)
	637	module_exit(alsa_mpu401_uart_exit)