mirror of
https://github.com/torvalds/linux.git
synced 2024-11-16 17:12:06 +00:00
7d12e780e0
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)
458 lines
9.3 KiB
C
458 lines
9.3 KiB
C
/*
|
|
* sound/oss/pas2_card.c
|
|
*
|
|
* Detection routine for the Pro Audio Spectrum cards.
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/module.h>
|
|
#include <linux/spinlock.h>
|
|
#include "sound_config.h"
|
|
|
|
#include "pas2.h"
|
|
#include "sb.h"
|
|
|
|
static unsigned char dma_bits[] = {
|
|
4, 1, 2, 3, 0, 5, 6, 7
|
|
};
|
|
|
|
static unsigned char irq_bits[] = {
|
|
0, 0, 1, 2, 3, 4, 5, 6, 0, 1, 7, 8, 9, 0, 10, 11
|
|
};
|
|
|
|
static unsigned char sb_irq_bits[] = {
|
|
0x00, 0x00, 0x08, 0x10, 0x00, 0x18, 0x00, 0x20,
|
|
0x00, 0x08, 0x28, 0x30, 0x38, 0, 0
|
|
};
|
|
|
|
static unsigned char sb_dma_bits[] = {
|
|
0x00, 0x40, 0x80, 0xC0, 0, 0, 0, 0
|
|
};
|
|
|
|
/*
|
|
* The Address Translation code is used to convert I/O register addresses to
|
|
* be relative to the given base -register
|
|
*/
|
|
|
|
int pas_translate_code = 0;
|
|
static int pas_intr_mask;
|
|
static int pas_irq;
|
|
static int pas_sb_base;
|
|
DEFINE_SPINLOCK(pas_lock);
|
|
#ifndef CONFIG_PAS_JOYSTICK
|
|
static int joystick;
|
|
#else
|
|
static int joystick = 1;
|
|
#endif
|
|
#ifdef SYMPHONY_PAS
|
|
static int symphony = 1;
|
|
#else
|
|
static int symphony;
|
|
#endif
|
|
#ifdef BROKEN_BUS_CLOCK
|
|
static int broken_bus_clock = 1;
|
|
#else
|
|
static int broken_bus_clock;
|
|
#endif
|
|
|
|
static struct address_info cfg;
|
|
static struct address_info cfg2;
|
|
|
|
char pas_model = 0;
|
|
static char *pas_model_names[] = {
|
|
"",
|
|
"Pro AudioSpectrum+",
|
|
"CDPC",
|
|
"Pro AudioSpectrum 16",
|
|
"Pro AudioSpectrum 16D"
|
|
};
|
|
|
|
/*
|
|
* pas_read() and pas_write() are equivalents of inb and outb
|
|
* These routines perform the I/O address translation required
|
|
* to support other than the default base address
|
|
*/
|
|
|
|
extern void mix_write(unsigned char data, int ioaddr);
|
|
|
|
unsigned char pas_read(int ioaddr)
|
|
{
|
|
return inb(ioaddr + pas_translate_code);
|
|
}
|
|
|
|
void pas_write(unsigned char data, int ioaddr)
|
|
{
|
|
outb((data), ioaddr + pas_translate_code);
|
|
}
|
|
|
|
/******************* Begin of the Interrupt Handler ********************/
|
|
|
|
static irqreturn_t pasintr(int irq, void *dev_id)
|
|
{
|
|
int status;
|
|
|
|
status = pas_read(0x0B89);
|
|
pas_write(status, 0x0B89); /* Clear interrupt */
|
|
|
|
if (status & 0x08)
|
|
{
|
|
pas_pcm_interrupt(status, 1);
|
|
status &= ~0x08;
|
|
}
|
|
if (status & 0x10)
|
|
{
|
|
pas_midi_interrupt();
|
|
status &= ~0x10;
|
|
}
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
int pas_set_intr(int mask)
|
|
{
|
|
if (!mask)
|
|
return 0;
|
|
|
|
pas_intr_mask |= mask;
|
|
|
|
pas_write(pas_intr_mask, 0x0B8B);
|
|
return 0;
|
|
}
|
|
|
|
int pas_remove_intr(int mask)
|
|
{
|
|
if (!mask)
|
|
return 0;
|
|
|
|
pas_intr_mask &= ~mask;
|
|
pas_write(pas_intr_mask, 0x0B8B);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/******************* End of the Interrupt handler **********************/
|
|
|
|
/******************* Begin of the Initialization Code ******************/
|
|
|
|
static int __init config_pas_hw(struct address_info *hw_config)
|
|
{
|
|
char ok = 1;
|
|
unsigned int_ptrs; /* scsi/sound interrupt pointers */
|
|
|
|
pas_irq = hw_config->irq;
|
|
|
|
pas_write(0x00, 0x0B8B);
|
|
pas_write(0x36, 0x138B);
|
|
pas_write(0x36, 0x1388);
|
|
pas_write(0, 0x1388);
|
|
pas_write(0x74, 0x138B);
|
|
pas_write(0x74, 0x1389);
|
|
pas_write(0, 0x1389);
|
|
|
|
pas_write(0x80 | 0x40 | 0x20 | 1, 0x0B8A);
|
|
pas_write(0x80 | 0x20 | 0x10 | 0x08 | 0x01, 0xF8A);
|
|
pas_write(0x01 | 0x02 | 0x04 | 0x10 /*
|
|
* |
|
|
* 0x80
|
|
*/ , 0xB88);
|
|
|
|
pas_write(0x80
|
|
| joystick?0x40:0
|
|
,0xF388);
|
|
|
|
if (pas_irq < 0 || pas_irq > 15)
|
|
{
|
|
printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq);
|
|
hw_config->irq=-1;
|
|
ok = 0;
|
|
}
|
|
else
|
|
{
|
|
int_ptrs = pas_read(0xF38A);
|
|
int_ptrs = (int_ptrs & 0xf0) | irq_bits[pas_irq];
|
|
pas_write(int_ptrs, 0xF38A);
|
|
if (!irq_bits[pas_irq])
|
|
{
|
|
printk(KERN_ERR "PAS16: Invalid IRQ %d", pas_irq);
|
|
hw_config->irq=-1;
|
|
ok = 0;
|
|
}
|
|
else
|
|
{
|
|
if (request_irq(pas_irq, pasintr, 0, "PAS16",hw_config) < 0) {
|
|
printk(KERN_ERR "PAS16: Cannot allocate IRQ %d\n",pas_irq);
|
|
hw_config->irq=-1;
|
|
ok = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hw_config->dma < 0 || hw_config->dma > 7)
|
|
{
|
|
printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma);
|
|
hw_config->dma=-1;
|
|
ok = 0;
|
|
}
|
|
else
|
|
{
|
|
pas_write(dma_bits[hw_config->dma], 0xF389);
|
|
if (!dma_bits[hw_config->dma])
|
|
{
|
|
printk(KERN_ERR "PAS16: Invalid DMA selection %d", hw_config->dma);
|
|
hw_config->dma=-1;
|
|
ok = 0;
|
|
}
|
|
else
|
|
{
|
|
if (sound_alloc_dma(hw_config->dma, "PAS16"))
|
|
{
|
|
printk(KERN_ERR "pas2_card.c: Can't allocate DMA channel\n");
|
|
hw_config->dma=-1;
|
|
ok = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This fixes the timing problems of the PAS due to the Symphony chipset
|
|
* as per Media Vision. Only define this if your PAS doesn't work correctly.
|
|
*/
|
|
|
|
if(symphony)
|
|
{
|
|
outb((0x05), 0xa8);
|
|
outb((0x60), 0xa9);
|
|
}
|
|
|
|
if(broken_bus_clock)
|
|
pas_write(0x01 | 0x10 | 0x20 | 0x04, 0x8388);
|
|
else
|
|
/*
|
|
* pas_write(0x01, 0x8388);
|
|
*/
|
|
pas_write(0x01 | 0x10 | 0x20, 0x8388);
|
|
|
|
pas_write(0x18, 0x838A); /* ??? */
|
|
pas_write(0x20 | 0x01, 0x0B8A); /* Mute off, filter = 17.897 kHz */
|
|
pas_write(8, 0xBF8A);
|
|
|
|
mix_write(0x80 | 5, 0x078B);
|
|
mix_write(5, 0x078B);
|
|
|
|
{
|
|
struct address_info *sb_config;
|
|
|
|
sb_config = &cfg2;
|
|
if (sb_config->io_base)
|
|
{
|
|
unsigned char irq_dma;
|
|
|
|
/*
|
|
* Turn on Sound Blaster compatibility
|
|
* bit 1 = SB emulation
|
|
* bit 0 = MPU401 emulation (CDPC only :-( )
|
|
*/
|
|
|
|
pas_write(0x02, 0xF788);
|
|
|
|
/*
|
|
* "Emulation address"
|
|
*/
|
|
|
|
pas_write((sb_config->io_base >> 4) & 0x0f, 0xF789);
|
|
pas_sb_base = sb_config->io_base;
|
|
|
|
if (!sb_dma_bits[sb_config->dma])
|
|
printk(KERN_ERR "PAS16 Warning: Invalid SB DMA %d\n\n", sb_config->dma);
|
|
|
|
if (!sb_irq_bits[sb_config->irq])
|
|
printk(KERN_ERR "PAS16 Warning: Invalid SB IRQ %d\n\n", sb_config->irq);
|
|
|
|
irq_dma = sb_dma_bits[sb_config->dma] |
|
|
sb_irq_bits[sb_config->irq];
|
|
|
|
pas_write(irq_dma, 0xFB8A);
|
|
}
|
|
else
|
|
pas_write(0x00, 0xF788);
|
|
}
|
|
|
|
if (!ok)
|
|
printk(KERN_WARNING "PAS16: Driver not enabled\n");
|
|
|
|
return ok;
|
|
}
|
|
|
|
static int __init detect_pas_hw(struct address_info *hw_config)
|
|
{
|
|
unsigned char board_id, foo;
|
|
|
|
/*
|
|
* WARNING: Setting an option like W:1 or so that disables warm boot reset
|
|
* of the card will screw up this detect code something fierce. Adding code
|
|
* to handle this means possibly interfering with other cards on the bus if
|
|
* you have something on base port 0x388. SO be forewarned.
|
|
*/
|
|
|
|
outb((0xBC), 0x9A01); /* Activate first board */
|
|
outb((hw_config->io_base >> 2), 0x9A01); /* Set base address */
|
|
pas_translate_code = hw_config->io_base - 0x388;
|
|
pas_write(1, 0xBF88); /* Select one wait states */
|
|
|
|
board_id = pas_read(0x0B8B);
|
|
|
|
if (board_id == 0xff)
|
|
return 0;
|
|
|
|
/*
|
|
* We probably have a PAS-series board, now check for a PAS16-series board
|
|
* by trying to change the board revision bits. PAS16-series hardware won't
|
|
* let you do this - the bits are read-only.
|
|
*/
|
|
|
|
foo = board_id ^ 0xe0;
|
|
|
|
pas_write(foo, 0x0B8B);
|
|
foo = pas_read(0x0B8B);
|
|
pas_write(board_id, 0x0B8B);
|
|
|
|
if (board_id != foo)
|
|
return 0;
|
|
|
|
pas_model = pas_read(0xFF88);
|
|
|
|
return pas_model;
|
|
}
|
|
|
|
static void __init attach_pas_card(struct address_info *hw_config)
|
|
{
|
|
pas_irq = hw_config->irq;
|
|
|
|
if (detect_pas_hw(hw_config))
|
|
{
|
|
|
|
if ((pas_model = pas_read(0xFF88)))
|
|
{
|
|
char temp[100];
|
|
|
|
sprintf(temp,
|
|
"%s rev %d", pas_model_names[(int) pas_model],
|
|
pas_read(0x2789));
|
|
conf_printf(temp, hw_config);
|
|
}
|
|
if (config_pas_hw(hw_config))
|
|
{
|
|
pas_pcm_init(hw_config);
|
|
pas_midi_init();
|
|
pas_init_mixer();
|
|
}
|
|
}
|
|
}
|
|
|
|
static inline int __init probe_pas(struct address_info *hw_config)
|
|
{
|
|
return detect_pas_hw(hw_config);
|
|
}
|
|
|
|
static void __exit unload_pas(struct address_info *hw_config)
|
|
{
|
|
extern int pas_audiodev;
|
|
extern int pas2_mididev;
|
|
|
|
if (hw_config->dma>0)
|
|
sound_free_dma(hw_config->dma);
|
|
if (hw_config->irq>0)
|
|
free_irq(hw_config->irq, hw_config);
|
|
|
|
if(pas_audiodev!=-1)
|
|
sound_unload_mixerdev(audio_devs[pas_audiodev]->mixer_dev);
|
|
if(pas2_mididev!=-1)
|
|
sound_unload_mididev(pas2_mididev);
|
|
if(pas_audiodev!=-1)
|
|
sound_unload_audiodev(pas_audiodev);
|
|
}
|
|
|
|
static int __initdata io = -1;
|
|
static int __initdata irq = -1;
|
|
static int __initdata dma = -1;
|
|
static int __initdata dma16 = -1; /* Set this for modules that need it */
|
|
|
|
static int __initdata sb_io = 0;
|
|
static int __initdata sb_irq = -1;
|
|
static int __initdata sb_dma = -1;
|
|
static int __initdata sb_dma16 = -1;
|
|
|
|
module_param(io, int, 0);
|
|
module_param(irq, int, 0);
|
|
module_param(dma, int, 0);
|
|
module_param(dma16, int, 0);
|
|
|
|
module_param(sb_io, int, 0);
|
|
module_param(sb_irq, int, 0);
|
|
module_param(sb_dma, int, 0);
|
|
module_param(sb_dma16, int, 0);
|
|
|
|
module_param(joystick, bool, 0);
|
|
module_param(symphony, bool, 0);
|
|
module_param(broken_bus_clock, bool, 0);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
static int __init init_pas2(void)
|
|
{
|
|
printk(KERN_INFO "Pro Audio Spectrum driver Copyright (C) by Hannu Savolainen 1993-1996\n");
|
|
|
|
cfg.io_base = io;
|
|
cfg.irq = irq;
|
|
cfg.dma = dma;
|
|
cfg.dma2 = dma16;
|
|
|
|
cfg2.io_base = sb_io;
|
|
cfg2.irq = sb_irq;
|
|
cfg2.dma = sb_dma;
|
|
cfg2.dma2 = sb_dma16;
|
|
|
|
if (cfg.io_base == -1 || cfg.dma == -1 || cfg.irq == -1) {
|
|
printk(KERN_INFO "I/O, IRQ, DMA and type are mandatory\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!probe_pas(&cfg))
|
|
return -ENODEV;
|
|
attach_pas_card(&cfg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __exit cleanup_pas2(void)
|
|
{
|
|
unload_pas(&cfg);
|
|
}
|
|
|
|
module_init(init_pas2);
|
|
module_exit(cleanup_pas2);
|
|
|
|
#ifndef MODULE
|
|
static int __init setup_pas2(char *str)
|
|
{
|
|
/* io, irq, dma, dma2, sb_io, sb_irq, sb_dma, sb_dma2 */
|
|
int ints[9];
|
|
|
|
str = get_options(str, ARRAY_SIZE(ints), ints);
|
|
|
|
io = ints[1];
|
|
irq = ints[2];
|
|
dma = ints[3];
|
|
dma16 = ints[4];
|
|
|
|
sb_io = ints[5];
|
|
sb_irq = ints[6];
|
|
sb_dma = ints[7];
|
|
sb_dma16 = ints[8];
|
|
|
|
return 1;
|
|
}
|
|
|
|
__setup("pas2=", setup_pas2);
|
|
#endif
|