2019-05-27 14:55:05 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2007-10-15 15:50:19 +08:00
|
|
|
* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
|
2005-04-17 06:20:36 +08:00
|
|
|
* Routines for control of MPU-401 in UART mode
|
|
|
|
|
*
|
|
|
|
|
* MPU-401 supports UART mode which is not capable generate transmit
|
ALSA: mpu401: clean up interrupt specification
The semantics of snd_mpu401_uart_new()'s interrupt parameters are
somewhat counterintuitive: To prevent the function from allocating its
own interrupt, either the irq number must be invalid, or the irq_flags
parameter must be zero. At the same time, the irq parameter being
invalid specifies that the mpu401 code has to work without an interrupt
allocated by the caller. This implies that, if there is an interrupt
and it is allocated by the caller, the irq parameter must be set to
a valid-looking number which then isn't actually used.
With the removal of IRQF_DISABLED, zero becomes a valid irq_flags value,
which forces us to handle the parameters differently.
This patch introduces a new flag MPU401_INFO_IRQ_HOOK for when the
device interrupt is handled by the caller, and makes the allocation of
the interrupt to depend only on the irq parameter. As suggested by
Takashi, the irq_flags parameter was dropped because, when used, it had
the constant value IRQF_DISABLED.
Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-09-13 17:24:41 +08:00
|
|
|
* interrupts thus output is done via polling. Without interrupt,
|
2005-04-17 06:20:36 +08:00
|
|
|
* input is done also via polling. Do not expect good performance.
|
|
|
|
|
*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
|
|
|
|
|
2015-01-28 23:49:33 +08:00
|
|
|
#include <linux/io.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/delay.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/slab.h>
|
|
|
|
|
#include <linux/ioport.h>
|
2011-07-16 00:38:28 +08:00
|
|
|
#include <linux/module.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
|
#include <sound/core.h>
|
|
|
|
|
#include <sound/mpu401.h>
|
|
|
|
|
|
2007-10-15 15:50:19 +08:00
|
|
|
MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
|
2005-04-17 06:20:36 +08:00
|
|
|
MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode");
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
2005-11-17 21:12:45 +08:00
|
|
|
static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu);
|
|
|
|
|
static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
2008-04-23 23:47:28 +08:00
|
|
|
#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))
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* Build in lowlevel io */
|
2006-05-18 20:48:26 +08:00
|
|
|
static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data,
|
|
|
|
|
unsigned long addr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
outb(data, addr);
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-18 20:48:26 +08:00
|
|
|
static unsigned char mpu401_read_port(struct snd_mpu401 *mpu,
|
|
|
|
|
unsigned long addr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
return inb(addr);
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-18 20:48:26 +08:00
|
|
|
static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data,
|
|
|
|
|
unsigned long addr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
writeb(data, (void __iomem *)addr);
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-18 20:48:26 +08:00
|
|
|
static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu,
|
|
|
|
|
unsigned long addr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
return readb((void __iomem *)addr);
|
|
|
|
|
}
|
|
|
|
|
/* */
|
|
|
|
|
|
2005-11-17 21:12:45 +08:00
|
|
|
static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
int timeout = 100000;
|
|
|
|
|
for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
|
|
|
|
|
mpu->read(mpu, MPU401D(mpu));
|
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
|
if (timeout <= 0)
|
2006-05-18 20:48:26 +08:00
|
|
|
snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n",
|
|
|
|
|
mpu->read(mpu, MPU401C(mpu)));
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-23 19:24:30 +08:00
|
|
|
static void uart_interrupt_tx(struct snd_mpu401 *mpu)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-11-12 15:47:57 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
|
|
|
|
|
test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
|
2007-11-12 15:47:57 +08:00
|
|
|
spin_lock_irqsave(&mpu->output_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
snd_mpu401_uart_output_write(mpu);
|
2007-11-12 15:47:57 +08:00
|
|
|
spin_unlock_irqrestore(&mpu->output_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-23 19:24:30 +08:00
|
|
|
static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
|
|
|
|
|
{
|
2007-11-12 15:47:57 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
2006-05-23 19:24:30 +08:00
|
|
|
if (mpu->info_flags & MPU401_INFO_INPUT) {
|
2007-11-12 15:47:57 +08:00
|
|
|
spin_lock_irqsave(&mpu->input_lock, flags);
|
2006-05-23 19:24:30 +08:00
|
|
|
if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
|
|
|
|
|
snd_mpu401_uart_input_read(mpu);
|
|
|
|
|
else
|
|
|
|
|
snd_mpu401_uart_clear_rx(mpu);
|
2007-11-12 15:47:57 +08:00
|
|
|
spin_unlock_irqrestore(&mpu->input_lock, flags);
|
2006-05-23 19:24:30 +08:00
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
|
* 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.
|
2013-03-12 05:05:14 +08:00
|
|
|
*
|
|
|
|
|
* Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu = dev_id;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-08-13 02:50:16 +08:00
|
|
|
if (!mpu)
|
2005-04-17 06:20:36 +08:00
|
|
|
return IRQ_NONE;
|
|
|
|
|
_snd_mpu401_uart_interrupt(mpu);
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-18 20:48:26 +08:00
|
|
|
EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
|
|
|
|
|
|
2006-05-23 19:24:30 +08:00
|
|
|
/**
|
|
|
|
|
* 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.
|
2013-03-12 05:05:14 +08:00
|
|
|
*
|
|
|
|
|
* Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
|
2006-05-23 19:24:30 +08:00
|
|
|
*/
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 21:55:46 +08:00
|
|
|
irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id)
|
2006-05-23 19:24:30 +08:00
|
|
|
{
|
|
|
|
|
struct snd_mpu401 *mpu = dev_id;
|
|
|
|
|
|
2017-08-13 02:50:16 +08:00
|
|
|
if (!mpu)
|
2006-05-23 19:24:30 +08:00
|
|
|
return IRQ_NONE;
|
|
|
|
|
uart_interrupt_tx(mpu);
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(snd_mpu401_uart_interrupt_tx);
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* timer callback
|
|
|
|
|
* reprogram the timer and call the interrupt job
|
|
|
|
|
*/
|
2017-10-24 23:34:29 +08:00
|
|
|
static void snd_mpu401_uart_timer(struct timer_list *t)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2017-10-24 23:34:29 +08:00
|
|
|
struct snd_mpu401 *mpu = from_timer(mpu, t, timer);
|
2005-11-19 01:52:14 +08:00
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-11-19 01:52:14 +08:00
|
|
|
spin_lock_irqsave(&mpu->timer_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
/*mpu->mode |= MPU401_MODE_TIMER;*/
|
2015-01-19 18:28:13 +08:00
|
|
|
mod_timer(&mpu->timer, 1 + jiffies);
|
2005-11-19 01:52:14 +08:00
|
|
|
spin_unlock_irqrestore(&mpu->timer_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (mpu->rmidi)
|
|
|
|
|
_snd_mpu401_uart_interrupt(mpu);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* initialize the timer callback if not programmed yet
|
|
|
|
|
*/
|
2005-11-17 21:12:45 +08:00
|
|
|
static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave (&mpu->timer_lock, flags);
|
|
|
|
|
if (mpu->timer_invoked == 0) {
|
2017-10-24 23:34:29 +08:00
|
|
|
timer_setup(&mpu->timer, snd_mpu401_uart_timer, 0);
|
2015-01-19 18:28:13 +08:00
|
|
|
mod_timer(&mpu->timer, 1 + jiffies);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-05-18 20:48:26 +08:00
|
|
|
mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER :
|
|
|
|
|
MPU401_MODE_OUTPUT_TIMER;
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_unlock_irqrestore (&mpu->timer_lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* remove the timer callback if still active
|
|
|
|
|
*/
|
2005-11-17 21:12:45 +08:00
|
|
|
static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
|
|
spin_lock_irqsave (&mpu->timer_lock, flags);
|
|
|
|
|
if (mpu->timer_invoked) {
|
2006-05-18 20:48:26 +08:00
|
|
|
mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER :
|
|
|
|
|
~MPU401_MODE_OUTPUT_TIMER;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (! mpu->timer_invoked)
|
|
|
|
|
del_timer(&mpu->timer);
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irqrestore (&mpu->timer_lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
2006-05-18 20:48:26 +08:00
|
|
|
* send a UART command
|
|
|
|
|
* return zero if successful, non-zero for some errors
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
|
2006-04-20 17:43:20 +08:00
|
|
|
static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
|
2006-05-18 20:48:26 +08:00
|
|
|
int ack)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
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) {
|
2006-05-18 20:48:26 +08:00
|
|
|
for (timeout = 1000; timeout > 0 &&
|
|
|
|
|
!snd_mpu401_output_ready(mpu); timeout--)
|
2005-04-17 06:20:36 +08:00
|
|
|
udelay(10);
|
|
|
|
|
#ifdef CONFIG_SND_DEBUG
|
|
|
|
|
if (!timeout)
|
2006-05-18 20:48:26 +08:00
|
|
|
snd_printk(KERN_ERR "cmd: tx timeout (status = 0x%x)\n",
|
|
|
|
|
mpu->read(mpu, MPU401C(mpu)));
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
mpu->write(mpu, cmd, MPU401C(mpu));
|
2008-04-25 15:13:45 +08:00
|
|
|
if (ack && !(mpu->info_flags & MPU401_INFO_NO_ACK)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
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;
|
2006-05-18 20:48:26 +08:00
|
|
|
} else
|
2005-04-17 06:20:36 +08:00
|
|
|
ok = 1;
|
|
|
|
|
spin_unlock_irqrestore(&mpu->input_lock, flags);
|
2006-04-20 17:43:20 +08:00
|
|
|
if (!ok) {
|
2006-05-18 20:48:26 +08:00
|
|
|
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)));
|
2006-04-20 17:43:20 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2007-02-22 23:07:21 +08:00
|
|
|
static int snd_mpu401_do_reset(struct snd_mpu401 *mpu)
|
|
|
|
|
{
|
|
|
|
|
if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
|
|
|
|
|
return -EIO;
|
2007-10-11 20:42:23 +08:00
|
|
|
if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0))
|
2007-02-22 23:07:21 +08:00
|
|
|
return -EIO;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* input/output open/close - protected by open_mutex in rawmidi.c
|
|
|
|
|
*/
|
2005-11-17 21:12:45 +08:00
|
|
|
static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu;
|
2005-04-17 06:20:36 +08:00
|
|
|
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)) {
|
2007-02-22 23:07:21 +08:00
|
|
|
if (snd_mpu401_do_reset(mpu) < 0)
|
2006-04-20 17:43:20 +08:00
|
|
|
goto error_out;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
mpu->substream_input = substream;
|
|
|
|
|
set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
|
|
|
|
|
return 0;
|
2006-04-20 17:43:20 +08:00
|
|
|
|
|
|
|
|
error_out:
|
|
|
|
|
if (mpu->open_input && mpu->close_input)
|
|
|
|
|
mpu->close_input(mpu);
|
|
|
|
|
return -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-11-17 21:12:45 +08:00
|
|
|
static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu;
|
2005-04-17 06:20:36 +08:00
|
|
|
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)) {
|
2007-02-22 23:07:21 +08:00
|
|
|
if (snd_mpu401_do_reset(mpu) < 0)
|
2006-04-20 17:43:20 +08:00
|
|
|
goto error_out;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
mpu->substream_output = substream;
|
|
|
|
|
set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
|
|
|
|
|
return 0;
|
2006-04-20 17:43:20 +08:00
|
|
|
|
|
|
|
|
error_out:
|
|
|
|
|
if (mpu->open_output && mpu->close_output)
|
|
|
|
|
mpu->close_output(mpu);
|
|
|
|
|
return -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-11-17 21:12:45 +08:00
|
|
|
static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu;
|
2006-04-20 17:43:20 +08:00
|
|
|
int err = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
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))
|
2006-04-20 17:43:20 +08:00
|
|
|
err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (mpu->close_input)
|
|
|
|
|
mpu->close_input(mpu);
|
2006-04-20 17:43:20 +08:00
|
|
|
if (err)
|
|
|
|
|
return -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2005-11-17 21:12:45 +08:00
|
|
|
static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu;
|
2006-04-20 17:43:20 +08:00
|
|
|
int err = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
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))
|
2006-04-20 17:43:20 +08:00
|
|
|
err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (mpu->close_output)
|
|
|
|
|
mpu->close_output(mpu);
|
2006-04-20 17:43:20 +08:00
|
|
|
if (err)
|
|
|
|
|
return -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* trigger input callback
|
|
|
|
|
*/
|
2006-05-18 20:48:26 +08:00
|
|
|
static void
|
|
|
|
|
snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
unsigned long flags;
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu;
|
2005-04-17 06:20:36 +08:00
|
|
|
int max = 64;
|
|
|
|
|
|
|
|
|
|
mpu = substream->rmidi->private_data;
|
|
|
|
|
if (up) {
|
2006-05-18 20:48:26 +08:00
|
|
|
if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER,
|
|
|
|
|
&mpu->mode)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* first time - flush FIFO */
|
|
|
|
|
while (max-- > 0)
|
|
|
|
|
mpu->read(mpu, MPU401D(mpu));
|
ALSA: mpu401: clean up interrupt specification
The semantics of snd_mpu401_uart_new()'s interrupt parameters are
somewhat counterintuitive: To prevent the function from allocating its
own interrupt, either the irq number must be invalid, or the irq_flags
parameter must be zero. At the same time, the irq parameter being
invalid specifies that the mpu401 code has to work without an interrupt
allocated by the caller. This implies that, if there is an interrupt
and it is allocated by the caller, the irq parameter must be set to
a valid-looking number which then isn't actually used.
With the removal of IRQF_DISABLED, zero becomes a valid irq_flags value,
which forces us to handle the parameters differently.
This patch introduces a new flag MPU401_INFO_IRQ_HOOK for when the
device interrupt is handled by the caller, and makes the allocation of
the interrupt to depend only on the irq parameter. As suggested by
Takashi, the irq_flags parameter was dropped because, when used, it had
the constant value IRQF_DISABLED.
Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-09-13 17:24:41 +08:00
|
|
|
if (mpu->info_flags & MPU401_INFO_USE_TIMER)
|
2005-04-17 06:20:36 +08:00
|
|
|
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 {
|
ALSA: mpu401: clean up interrupt specification
The semantics of snd_mpu401_uart_new()'s interrupt parameters are
somewhat counterintuitive: To prevent the function from allocating its
own interrupt, either the irq number must be invalid, or the irq_flags
parameter must be zero. At the same time, the irq parameter being
invalid specifies that the mpu401 code has to work without an interrupt
allocated by the caller. This implies that, if there is an interrupt
and it is allocated by the caller, the irq parameter must be set to
a valid-looking number which then isn't actually used.
With the removal of IRQF_DISABLED, zero becomes a valid irq_flags value,
which forces us to handle the parameters differently.
This patch introduces a new flag MPU401_INFO_IRQ_HOOK for when the
device interrupt is handled by the caller, and makes the allocation of
the interrupt to depend only on the irq parameter. As suggested by
Takashi, the irq_flags parameter was dropped because, when used, it had
the constant value IRQF_DISABLED.
Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-09-13 17:24:41 +08:00
|
|
|
if (mpu->info_flags & MPU401_INFO_USE_TIMER)
|
2005-04-17 06:20:36 +08:00
|
|
|
snd_mpu401_uart_remove_timer(mpu, 1);
|
|
|
|
|
clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
|
|
|
|
|
}
|
2006-04-20 17:43:20 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* transfer input pending data
|
|
|
|
|
* call with input_lock spinlock held
|
|
|
|
|
*/
|
2005-11-17 21:12:45 +08:00
|
|
|
static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
int max = 128;
|
|
|
|
|
unsigned char byte;
|
|
|
|
|
|
|
|
|
|
while (max-- > 0) {
|
2006-05-18 20:48:26 +08:00
|
|
|
if (! snd_mpu401_input_avail(mpu))
|
2005-04-17 06:20:36 +08:00
|
|
|
break; /* input not available */
|
2006-05-18 20:48:26 +08:00
|
|
|
byte = mpu->read(mpu, MPU401D(mpu));
|
|
|
|
|
if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
|
|
|
|
|
snd_rawmidi_receive(mpu->substream_input, &byte, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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
|
|
|
|
|
*/
|
2005-11-17 21:12:45 +08:00
|
|
|
static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
unsigned char byte;
|
2008-02-25 17:59:52 +08:00
|
|
|
int max = 256;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
do {
|
2006-05-18 20:48:26 +08:00
|
|
|
if (snd_rawmidi_transmit_peek(mpu->substream_output,
|
|
|
|
|
&byte, 1) == 1) {
|
2008-02-25 17:59:52 +08:00
|
|
|
/*
|
|
|
|
|
* 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))
|
2005-04-17 06:20:36 +08:00
|
|
|
break; /* Tx FIFO full - try again later */
|
2006-05-18 20:48:26 +08:00
|
|
|
mpu->write(mpu, byte, MPU401D(mpu));
|
|
|
|
|
snd_rawmidi_transmit_ack(mpu->substream_output, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
|
snd_mpu401_uart_remove_timer (mpu, 0);
|
|
|
|
|
break; /* no other data - leave the tx loop */
|
|
|
|
|
}
|
|
|
|
|
} while (--max > 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* output trigger callback
|
|
|
|
|
*/
|
2006-05-18 20:48:26 +08:00
|
|
|
static void
|
|
|
|
|
snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
unsigned long flags;
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
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().
|
|
|
|
|
*/
|
2006-05-23 19:24:30 +08:00
|
|
|
if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
|
|
|
|
|
snd_mpu401_uart_add_timer(mpu, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* output pending data */
|
|
|
|
|
spin_lock_irqsave(&mpu->output_lock, flags);
|
|
|
|
|
snd_mpu401_uart_output_write(mpu);
|
|
|
|
|
spin_unlock_irqrestore(&mpu->output_lock, flags);
|
|
|
|
|
} else {
|
2006-05-23 19:24:30 +08:00
|
|
|
if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
|
|
|
|
|
snd_mpu401_uart_remove_timer(mpu, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
2017-01-06 00:28:39 +08:00
|
|
|
static const struct snd_rawmidi_ops snd_mpu401_uart_output =
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
.open = snd_mpu401_uart_output_open,
|
|
|
|
|
.close = snd_mpu401_uart_output_close,
|
|
|
|
|
.trigger = snd_mpu401_uart_output_trigger,
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-06 00:28:39 +08:00
|
|
|
static const struct snd_rawmidi_ops snd_mpu401_uart_input =
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
.open = snd_mpu401_uart_input_open,
|
|
|
|
|
.close = snd_mpu401_uart_input_close,
|
|
|
|
|
.trigger = snd_mpu401_uart_input_trigger,
|
|
|
|
|
};
|
|
|
|
|
|
2005-11-17 21:12:45 +08:00
|
|
|
static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu = rmidi->private_data;
|
ALSA: mpu401: clean up interrupt specification
The semantics of snd_mpu401_uart_new()'s interrupt parameters are
somewhat counterintuitive: To prevent the function from allocating its
own interrupt, either the irq number must be invalid, or the irq_flags
parameter must be zero. At the same time, the irq parameter being
invalid specifies that the mpu401 code has to work without an interrupt
allocated by the caller. This implies that, if there is an interrupt
and it is allocated by the caller, the irq parameter must be set to
a valid-looking number which then isn't actually used.
With the removal of IRQF_DISABLED, zero becomes a valid irq_flags value,
which forces us to handle the parameters differently.
This patch introduces a new flag MPU401_INFO_IRQ_HOOK for when the
device interrupt is handled by the caller, and makes the allocation of
the interrupt to depend only on the irq parameter. As suggested by
Takashi, the irq_flags parameter was dropped because, when used, it had
the constant value IRQF_DISABLED.
Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-09-13 17:24:41 +08:00
|
|
|
if (mpu->irq >= 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
free_irq(mpu->irq, (void *) mpu);
|
2005-10-10 17:56:31 +08:00
|
|
|
release_and_free_resource(mpu->res);
|
2005-04-17 06:20:36 +08:00
|
|
|
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
|
2006-05-23 19:24:30 +08:00
|
|
|
* @info_flags: bitflags MPU401_INFO_XXX
|
ALSA: mpu401: clean up interrupt specification
The semantics of snd_mpu401_uart_new()'s interrupt parameters are
somewhat counterintuitive: To prevent the function from allocating its
own interrupt, either the irq number must be invalid, or the irq_flags
parameter must be zero. At the same time, the irq parameter being
invalid specifies that the mpu401 code has to work without an interrupt
allocated by the caller. This implies that, if there is an interrupt
and it is allocated by the caller, the irq parameter must be set to
a valid-looking number which then isn't actually used.
With the removal of IRQF_DISABLED, zero becomes a valid irq_flags value,
which forces us to handle the parameters differently.
This patch introduces a new flag MPU401_INFO_IRQ_HOOK for when the
device interrupt is handled by the caller, and makes the allocation of
the interrupt to depend only on the irq parameter. As suggested by
Takashi, the irq_flags parameter was dropped because, when used, it had
the constant value IRQF_DISABLED.
Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-09-13 17:24:41 +08:00
|
|
|
* @irq: the ISA irq number, -1 if not to be allocated
|
2005-04-17 06:20:36 +08:00
|
|
|
* @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,
|
2005-11-17 21:12:45 +08:00
|
|
|
* cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2013-03-12 05:05:14 +08:00
|
|
|
* Return: Zero if successful, or a negative error code.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2005-11-17 21:12:45 +08:00
|
|
|
int snd_mpu401_uart_new(struct snd_card *card, int device,
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned short hardware,
|
2006-05-23 19:24:30 +08:00
|
|
|
unsigned long port,
|
|
|
|
|
unsigned int info_flags,
|
ALSA: mpu401: clean up interrupt specification
The semantics of snd_mpu401_uart_new()'s interrupt parameters are
somewhat counterintuitive: To prevent the function from allocating its
own interrupt, either the irq number must be invalid, or the irq_flags
parameter must be zero. At the same time, the irq parameter being
invalid specifies that the mpu401 code has to work without an interrupt
allocated by the caller. This implies that, if there is an interrupt
and it is allocated by the caller, the irq parameter must be set to
a valid-looking number which then isn't actually used.
With the removal of IRQF_DISABLED, zero becomes a valid irq_flags value,
which forces us to handle the parameters differently.
This patch introduces a new flag MPU401_INFO_IRQ_HOOK for when the
device interrupt is handled by the caller, and makes the allocation of
the interrupt to depend only on the irq parameter. As suggested by
Takashi, the irq_flags parameter was dropped because, when used, it had
the constant value IRQF_DISABLED.
Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-09-13 17:24:41 +08:00
|
|
|
int irq,
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_rawmidi ** rrawmidi)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-11-17 21:12:45 +08:00
|
|
|
struct snd_mpu401 *mpu;
|
|
|
|
|
struct snd_rawmidi *rmidi;
|
2006-05-23 19:24:30 +08:00
|
|
|
int in_enable, out_enable;
|
2005-04-17 06:20:36 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (rrawmidi)
|
|
|
|
|
*rrawmidi = NULL;
|
2006-05-23 19:24:30 +08:00
|
|
|
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)
|
2005-04-17 06:20:36 +08:00
|
|
|
return err;
|
[ALSA] Replace with kzalloc() - others
Documentation,SA11xx UDA1341 driver,Generic drivers,MPU401 UART,OPL3
OPL4,Digigram VX core,I2C cs8427,I2C lib core,I2C tea6330t,L3 drivers
AK4114 receiver,AK4117 receiver,PDAudioCF driver,PPC PMAC driver
SPARC AMD7930 driver,SPARC cs4231 driver,Synth,Common EMU synth
USB generic driver,USB USX2Y
Replace kcalloc(1,..) with kzalloc().
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2005-09-09 20:22:34 +08:00
|
|
|
mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
|
2017-08-13 02:50:16 +08:00
|
|
|
if (!mpu) {
|
2017-08-13 02:40:17 +08:00
|
|
|
err = -ENOMEM;
|
|
|
|
|
goto free_device;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
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;
|
2012-07-23 17:35:55 +08:00
|
|
|
mpu->irq = -1;
|
2006-05-23 19:24:30 +08:00
|
|
|
if (! (info_flags & MPU401_INFO_INTEGRATED)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
|
2006-05-18 20:48:26 +08:00
|
|
|
mpu->res = request_region(port, res_size, "MPU401 UART");
|
2017-08-13 02:50:16 +08:00
|
|
|
if (!mpu->res) {
|
2006-05-18 20:48:26 +08:00
|
|
|
snd_printk(KERN_ERR "mpu401_uart: "
|
|
|
|
|
"unable to grab port 0x%lx size %d\n",
|
|
|
|
|
port, res_size);
|
2017-08-13 02:40:17 +08:00
|
|
|
err = -EBUSY;
|
|
|
|
|
goto free_device;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
2006-05-23 19:24:30 +08:00
|
|
|
if (info_flags & MPU401_INFO_MMIO) {
|
2005-04-17 06:20:36 +08:00
|
|
|
mpu->write = mpu401_write_mmio;
|
|
|
|
|
mpu->read = mpu401_read_mmio;
|
2006-05-23 19:24:30 +08:00
|
|
|
} else {
|
2005-04-17 06:20:36 +08:00
|
|
|
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;
|
ALSA: mpu401: clean up interrupt specification
The semantics of snd_mpu401_uart_new()'s interrupt parameters are
somewhat counterintuitive: To prevent the function from allocating its
own interrupt, either the irq number must be invalid, or the irq_flags
parameter must be zero. At the same time, the irq parameter being
invalid specifies that the mpu401 code has to work without an interrupt
allocated by the caller. This implies that, if there is an interrupt
and it is allocated by the caller, the irq parameter must be set to
a valid-looking number which then isn't actually used.
With the removal of IRQF_DISABLED, zero becomes a valid irq_flags value,
which forces us to handle the parameters differently.
This patch introduces a new flag MPU401_INFO_IRQ_HOOK for when the
device interrupt is handled by the caller, and makes the allocation of
the interrupt to depend only on the irq parameter. As suggested by
Takashi, the irq_flags parameter was dropped because, when used, it had
the constant value IRQF_DISABLED.
Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-09-13 17:24:41 +08:00
|
|
|
if (irq >= 0) {
|
2011-09-22 16:59:20 +08:00
|
|
|
if (request_irq(irq, snd_mpu401_uart_interrupt, 0,
|
2006-05-18 20:48:26 +08:00
|
|
|
"MPU401 UART", (void *) mpu)) {
|
|
|
|
|
snd_printk(KERN_ERR "mpu401_uart: "
|
|
|
|
|
"unable to grab IRQ %d\n", irq);
|
2017-08-13 02:40:17 +08:00
|
|
|
err = -EBUSY;
|
|
|
|
|
goto free_device;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
ALSA: mpu401: clean up interrupt specification
The semantics of snd_mpu401_uart_new()'s interrupt parameters are
somewhat counterintuitive: To prevent the function from allocating its
own interrupt, either the irq number must be invalid, or the irq_flags
parameter must be zero. At the same time, the irq parameter being
invalid specifies that the mpu401 code has to work without an interrupt
allocated by the caller. This implies that, if there is an interrupt
and it is allocated by the caller, the irq parameter must be set to
a valid-looking number which then isn't actually used.
With the removal of IRQF_DISABLED, zero becomes a valid irq_flags value,
which forces us to handle the parameters differently.
This patch introduces a new flag MPU401_INFO_IRQ_HOOK for when the
device interrupt is handled by the caller, and makes the allocation of
the interrupt to depend only on the irq parameter. As suggested by
Takashi, the irq_flags parameter was dropped because, when used, it had
the constant value IRQF_DISABLED.
Signed-off-by: Clemens Ladisch <clemens@ladisch.de>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
2011-09-13 17:24:41 +08:00
|
|
|
if (irq < 0 && !(info_flags & MPU401_INFO_IRQ_HOOK))
|
|
|
|
|
info_flags |= MPU401_INFO_USE_TIMER;
|
2006-05-23 19:24:30 +08:00
|
|
|
mpu->info_flags = info_flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
mpu->irq = irq;
|
|
|
|
|
if (card->shortname[0])
|
2006-05-18 20:48:26 +08:00
|
|
|
snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI",
|
|
|
|
|
card->shortname);
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2006-05-18 20:48:26 +08:00
|
|
|
sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device);
|
2006-05-23 19:24:30 +08:00
|
|
|
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;
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
mpu->rmidi = rmidi;
|
|
|
|
|
if (rrawmidi)
|
|
|
|
|
*rrawmidi = rmidi;
|
|
|
|
|
return 0;
|
2017-08-13 02:40:17 +08:00
|
|
|
free_device:
|
|
|
|
|
snd_device_free(card, rmidi);
|
|
|
|
|
return err;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(snd_mpu401_uart_new);
|