Commit 8f042aa7 authored by Linus Torvalds's avatar Linus Torvalds

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/geert/linux-m68k: (29 commits)
  m68k/mac: Remove mac_irq_{en,dis}able() wrappers
  m68k/irq: Remove obsolete support for user vector interrupt fixups
  m68k/irq: Remove obsolete m68k irq framework
  m68k/q40: Convert Q40/Q60 to genirq
  m68k/sun3: Convert Sun3/3x to genirq
  m68k/sun3: Use the kstat_irqs_cpu() wrapper
  m68k/apollo: Convert Apollo to genirq
  m68k/vme: Convert VME to genirq
  m68k/hp300: Convert HP9000/300 and HP9000/400 to genirq
  m68k/mac: Optimize interrupts using chain handlers
  m68k/mac: Convert Mac to genirq
  m68k/amiga: Optimize interrupts using chain handlers
  m68k/amiga: Convert Amiga to genirq
  m68k/amiga: Refactor amiints.c
  m68k/atari: Remove code and comments about different irq types
  m68k/atari: Convert Atari to genirq
  m68k/irq: Add genirq support
  m68k/irq: Remove obsolete IRQ_FLG_* users
  m68k/irq: Rename {,__}m68k_handle_int()
  m68k/irq: Add m68k_setup_irq_controller()
  ...
parents e6f1227e 2690e214
...@@ -4,8 +4,8 @@ config M68K ...@@ -4,8 +4,8 @@ config M68K
select HAVE_IDE select HAVE_IDE
select HAVE_AOUT if MMU select HAVE_AOUT if MMU
select GENERIC_ATOMIC64 if MMU select GENERIC_ATOMIC64 if MMU
select HAVE_GENERIC_HARDIRQS if !MMU select HAVE_GENERIC_HARDIRQS
select GENERIC_IRQ_SHOW if !MMU select GENERIC_IRQ_SHOW
select ARCH_HAVE_NMI_SAFE_CMPXCHG if RMW_INSNS select ARCH_HAVE_NMI_SAFE_CMPXCHG if RMW_INSNS
config RWSEM_GENERIC_SPINLOCK config RWSEM_GENERIC_SPINLOCK
......
...@@ -2,6 +2,15 @@ if MMU ...@@ -2,6 +2,15 @@ if MMU
comment "Bus Support" comment "Bus Support"
config DIO
bool "DIO bus support"
depends on HP300
default y
help
Say Y here to enable support for the "DIO" expansion bus used in
HP300 machines. If you are using such a system you almost certainly
want this.
config NUBUS config NUBUS
bool bool
depends on MAC depends on MAC
......
...@@ -24,6 +24,37 @@ config PROC_HARDWARE ...@@ -24,6 +24,37 @@ config PROC_HARDWARE
including the model, CPU, MMU, clock speed, BogoMIPS rating, including the model, CPU, MMU, clock speed, BogoMIPS rating,
and memory size. and memory size.
config NATFEAT
bool "ARAnyM emulator support"
depends on ATARI
help
This option enables support for ARAnyM native features, such as
access to a disk image as /dev/hda.
config NFBLOCK
tristate "NatFeat block device support"
depends on BLOCK && NATFEAT
help
Say Y to include support for the ARAnyM NatFeat block device
which allows direct access to the hard drives without using
the hardware emulation.
config NFCON
tristate "NatFeat console driver"
depends on NATFEAT
help
Say Y to include support for the ARAnyM NatFeat console driver
which allows the console output to be redirected to the stderr
output of ARAnyM.
config NFETH
tristate "NatFeat Ethernet support"
depends on ETHERNET && NATFEAT
help
Say Y to include support for the ARAnyM NatFeat network device
which will emulate a regular ethernet device while presenting an
ethertap device to the host system.
endmenu endmenu
menu "Character devices" menu "Character devices"
......
/* /*
* linux/arch/m68k/amiga/amiints.c -- Amiga Linux interrupt handling code * Amiga Linux interrupt handling code
* *
* This file is subject to the terms and conditions of the GNU General Public * This file is subject to the terms and conditions of the GNU General Public
* License. See the file COPYING in the main directory of this archive * License. See the file COPYING in the main directory of this archive
* for more details. * for more details.
*
* 11/07/96: rewritten interrupt handling, irq lists are exists now only for
* this sources where it makes sense (VERTB/PORTS/EXTER) and you must
* be careful that dev_id for this sources is unique since this the
* only possibility to distinguish between different handlers for
* free_irq. irq lists also have different irq flags:
* - IRQ_FLG_FAST: handler is inserted at top of list (after other
* fast handlers)
* - IRQ_FLG_SLOW: handler is inserted at bottom of list and before
* they're executed irq level is set to the previous
* one, but handlers don't need to be reentrant, if
* reentrance occurred, slow handlers will be just
* called again.
* The whole interrupt handling for CIAs is moved to cia.c
* /Roman Zippel
*
* 07/08/99: rewamp of the interrupt handling - we now have two types of
* interrupts, normal and fast handlers, fast handlers being
* marked with IRQF_DISABLED and runs with all other interrupts
* disabled. Normal interrupts disable their own source but
* run with all other interrupt sources enabled.
* PORTS and EXTER interrupts are always shared even if the
* drivers do not explicitly mark this when calling
* request_irq which they really should do.
* This is similar to the way interrupts are handled on all
* other architectures and makes a ton of sense besides
* having the advantage of making it easier to share
* drivers.
* /Jes
*/ */
#include <linux/init.h> #include <linux/init.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/irq.h>
#include <asm/irq.h> #include <asm/irq.h>
#include <asm/traps.h> #include <asm/traps.h>
...@@ -45,56 +17,6 @@ ...@@ -45,56 +17,6 @@
#include <asm/amigaints.h> #include <asm/amigaints.h>
#include <asm/amipcmcia.h> #include <asm/amipcmcia.h>
static void amiga_enable_irq(unsigned int irq);
static void amiga_disable_irq(unsigned int irq);
static irqreturn_t ami_int1(int irq, void *dev_id);
static irqreturn_t ami_int3(int irq, void *dev_id);
static irqreturn_t ami_int4(int irq, void *dev_id);
static irqreturn_t ami_int5(int irq, void *dev_id);
static struct irq_controller amiga_irq_controller = {
.name = "amiga",
.lock = __SPIN_LOCK_UNLOCKED(amiga_irq_controller.lock),
.enable = amiga_enable_irq,
.disable = amiga_disable_irq,
};
/*
* void amiga_init_IRQ(void)
*
* Parameters: None
*
* Returns: Nothing
*
* This function should be called during kernel startup to initialize
* the amiga IRQ handling routines.
*/
void __init amiga_init_IRQ(void)
{
if (request_irq(IRQ_AUTO_1, ami_int1, 0, "int1", NULL))
pr_err("Couldn't register int%d\n", 1);
if (request_irq(IRQ_AUTO_3, ami_int3, 0, "int3", NULL))
pr_err("Couldn't register int%d\n", 3);
if (request_irq(IRQ_AUTO_4, ami_int4, 0, "int4", NULL))
pr_err("Couldn't register int%d\n", 4);
if (request_irq(IRQ_AUTO_5, ami_int5, 0, "int5", NULL))
pr_err("Couldn't register int%d\n", 5);
m68k_setup_irq_controller(&amiga_irq_controller, IRQ_USER, AMI_STD_IRQS);
/* turn off PCMCIA interrupts */
if (AMIGAHW_PRESENT(PCMCIA))
gayle.inten = GAYLE_IRQ_IDE;
/* turn off all interrupts and enable the master interrupt bit */
amiga_custom.intena = 0x7fff;
amiga_custom.intreq = 0x7fff;
amiga_custom.intena = IF_SETCLR | IF_INTEN;
cia_init_IRQ(&ciaa_base);
cia_init_IRQ(&ciab_base);
}
/* /*
* Enable/disable a particular machine specific interrupt source. * Enable/disable a particular machine specific interrupt source.
...@@ -103,112 +25,150 @@ void __init amiga_init_IRQ(void) ...@@ -103,112 +25,150 @@ void __init amiga_init_IRQ(void)
* internal data, that may not be changed by the interrupt at the same time. * internal data, that may not be changed by the interrupt at the same time.
*/ */
static void amiga_enable_irq(unsigned int irq) static void amiga_irq_enable(struct irq_data *data)
{ {
amiga_custom.intena = IF_SETCLR | (1 << (irq - IRQ_USER)); amiga_custom.intena = IF_SETCLR | (1 << (data->irq - IRQ_USER));
} }
static void amiga_disable_irq(unsigned int irq) static void amiga_irq_disable(struct irq_data *data)
{ {
amiga_custom.intena = 1 << (irq - IRQ_USER); amiga_custom.intena = 1 << (data->irq - IRQ_USER);
} }
static struct irq_chip amiga_irq_chip = {
.name = "amiga",
.irq_enable = amiga_irq_enable,
.irq_disable = amiga_irq_disable,
};
/* /*
* The builtin Amiga hardware interrupt handlers. * The builtin Amiga hardware interrupt handlers.
*/ */
static irqreturn_t ami_int1(int irq, void *dev_id) static void ami_int1(unsigned int irq, struct irq_desc *desc)
{ {
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar; unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
/* if serial transmit buffer empty, interrupt */ /* if serial transmit buffer empty, interrupt */
if (ints & IF_TBE) { if (ints & IF_TBE) {
amiga_custom.intreq = IF_TBE; amiga_custom.intreq = IF_TBE;
m68k_handle_int(IRQ_AMIGA_TBE); generic_handle_irq(IRQ_AMIGA_TBE);
} }
/* if floppy disk transfer complete, interrupt */ /* if floppy disk transfer complete, interrupt */
if (ints & IF_DSKBLK) { if (ints & IF_DSKBLK) {
amiga_custom.intreq = IF_DSKBLK; amiga_custom.intreq = IF_DSKBLK;
m68k_handle_int(IRQ_AMIGA_DSKBLK); generic_handle_irq(IRQ_AMIGA_DSKBLK);
} }
/* if software interrupt set, interrupt */ /* if software interrupt set, interrupt */
if (ints & IF_SOFT) { if (ints & IF_SOFT) {
amiga_custom.intreq = IF_SOFT; amiga_custom.intreq = IF_SOFT;
m68k_handle_int(IRQ_AMIGA_SOFT); generic_handle_irq(IRQ_AMIGA_SOFT);
} }
return IRQ_HANDLED;
} }
static irqreturn_t ami_int3(int irq, void *dev_id) static void ami_int3(unsigned int irq, struct irq_desc *desc)
{ {
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar; unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
/* if a blitter interrupt */ /* if a blitter interrupt */
if (ints & IF_BLIT) { if (ints & IF_BLIT) {
amiga_custom.intreq = IF_BLIT; amiga_custom.intreq = IF_BLIT;
m68k_handle_int(IRQ_AMIGA_BLIT); generic_handle_irq(IRQ_AMIGA_BLIT);
} }
/* if a copper interrupt */ /* if a copper interrupt */
if (ints & IF_COPER) { if (ints & IF_COPER) {
amiga_custom.intreq = IF_COPER; amiga_custom.intreq = IF_COPER;
m68k_handle_int(IRQ_AMIGA_COPPER); generic_handle_irq(IRQ_AMIGA_COPPER);
} }
/* if a vertical blank interrupt */ /* if a vertical blank interrupt */
if (ints & IF_VERTB) { if (ints & IF_VERTB) {
amiga_custom.intreq = IF_VERTB; amiga_custom.intreq = IF_VERTB;
m68k_handle_int(IRQ_AMIGA_VERTB); generic_handle_irq(IRQ_AMIGA_VERTB);
} }
return IRQ_HANDLED;
} }
static irqreturn_t ami_int4(int irq, void *dev_id) static void ami_int4(unsigned int irq, struct irq_desc *desc)
{ {
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar; unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
/* if audio 0 interrupt */ /* if audio 0 interrupt */
if (ints & IF_AUD0) { if (ints & IF_AUD0) {
amiga_custom.intreq = IF_AUD0; amiga_custom.intreq = IF_AUD0;
m68k_handle_int(IRQ_AMIGA_AUD0); generic_handle_irq(IRQ_AMIGA_AUD0);
} }
/* if audio 1 interrupt */ /* if audio 1 interrupt */
if (ints & IF_AUD1) { if (ints & IF_AUD1) {
amiga_custom.intreq = IF_AUD1; amiga_custom.intreq = IF_AUD1;
m68k_handle_int(IRQ_AMIGA_AUD1); generic_handle_irq(IRQ_AMIGA_AUD1);
} }
/* if audio 2 interrupt */ /* if audio 2 interrupt */
if (ints & IF_AUD2) { if (ints & IF_AUD2) {
amiga_custom.intreq = IF_AUD2; amiga_custom.intreq = IF_AUD2;
m68k_handle_int(IRQ_AMIGA_AUD2); generic_handle_irq(IRQ_AMIGA_AUD2);
} }
/* if audio 3 interrupt */ /* if audio 3 interrupt */
if (ints & IF_AUD3) { if (ints & IF_AUD3) {
amiga_custom.intreq = IF_AUD3; amiga_custom.intreq = IF_AUD3;
m68k_handle_int(IRQ_AMIGA_AUD3); generic_handle_irq(IRQ_AMIGA_AUD3);
} }
return IRQ_HANDLED;
} }
static irqreturn_t ami_int5(int irq, void *dev_id) static void ami_int5(unsigned int irq, struct irq_desc *desc)
{ {
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar; unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
/* if serial receive buffer full interrupt */ /* if serial receive buffer full interrupt */
if (ints & IF_RBF) { if (ints & IF_RBF) {
/* acknowledge of IF_RBF must be done by the serial interrupt */ /* acknowledge of IF_RBF must be done by the serial interrupt */
m68k_handle_int(IRQ_AMIGA_RBF); generic_handle_irq(IRQ_AMIGA_RBF);
} }
/* if a disk sync interrupt */ /* if a disk sync interrupt */
if (ints & IF_DSKSYN) { if (ints & IF_DSKSYN) {
amiga_custom.intreq = IF_DSKSYN; amiga_custom.intreq = IF_DSKSYN;
m68k_handle_int(IRQ_AMIGA_DSKSYN); generic_handle_irq(IRQ_AMIGA_DSKSYN);
} }
return IRQ_HANDLED; }
/*
* void amiga_init_IRQ(void)
*
* Parameters: None
*
* Returns: Nothing
*
* This function should be called during kernel startup to initialize
* the amiga IRQ handling routines.
*/
void __init amiga_init_IRQ(void)
{
m68k_setup_irq_controller(&amiga_irq_chip, handle_simple_irq, IRQ_USER,
AMI_STD_IRQS);
irq_set_chained_handler(IRQ_AUTO_1, ami_int1);
irq_set_chained_handler(IRQ_AUTO_3, ami_int3);
irq_set_chained_handler(IRQ_AUTO_4, ami_int4);
irq_set_chained_handler(IRQ_AUTO_5, ami_int5);
/* turn off PCMCIA interrupts */
if (AMIGAHW_PRESENT(PCMCIA))
gayle.inten = GAYLE_IRQ_IDE;
/* turn off all interrupts and enable the master interrupt bit */
amiga_custom.intena = 0x7fff;
amiga_custom.intreq = 0x7fff;
amiga_custom.intena = IF_SETCLR | IF_INTEN;
cia_init_IRQ(&ciaa_base);
cia_init_IRQ(&ciab_base);
} }
...@@ -93,13 +93,14 @@ static irqreturn_t cia_handler(int irq, void *dev_id) ...@@ -93,13 +93,14 @@ static irqreturn_t cia_handler(int irq, void *dev_id)
amiga_custom.intreq = base->int_mask; amiga_custom.intreq = base->int_mask;
for (; ints; mach_irq++, ints >>= 1) { for (; ints; mach_irq++, ints >>= 1) {
if (ints & 1) if (ints & 1)
m68k_handle_int(mach_irq); generic_handle_irq(mach_irq);
} }
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static void cia_enable_irq(unsigned int irq) static void cia_irq_enable(struct irq_data *data)
{ {
unsigned int irq = data->irq;
unsigned char mask; unsigned char mask;
if (irq >= IRQ_AMIGA_CIAB) { if (irq >= IRQ_AMIGA_CIAB) {
...@@ -113,19 +114,20 @@ static void cia_enable_irq(unsigned int irq) ...@@ -113,19 +114,20 @@ static void cia_enable_irq(unsigned int irq)
} }
} }
static void cia_disable_irq(unsigned int irq) static void cia_irq_disable(struct irq_data *data)
{ {
unsigned int irq = data->irq;
if (irq >= IRQ_AMIGA_CIAB) if (irq >= IRQ_AMIGA_CIAB)
cia_able_irq(&ciab_base, 1 << (irq - IRQ_AMIGA_CIAB)); cia_able_irq(&ciab_base, 1 << (irq - IRQ_AMIGA_CIAB));
else else
cia_able_irq(&ciaa_base, 1 << (irq - IRQ_AMIGA_CIAA)); cia_able_irq(&ciaa_base, 1 << (irq - IRQ_AMIGA_CIAA));
} }
static struct irq_controller cia_irq_controller = { static struct irq_chip cia_irq_chip = {
.name = "cia", .name = "cia",
.lock = __SPIN_LOCK_UNLOCKED(cia_irq_controller.lock), .irq_enable = cia_irq_enable,
.enable = cia_enable_irq, .irq_disable = cia_irq_disable,
.disable = cia_disable_irq,
}; };
/* /*
...@@ -134,9 +136,9 @@ static struct irq_controller cia_irq_controller = { ...@@ -134,9 +136,9 @@ static struct irq_controller cia_irq_controller = {
* into this chain. * into this chain.
*/ */
static void auto_enable_irq(unsigned int irq) static void auto_irq_enable(struct irq_data *data)
{ {
switch (irq) { switch (data->irq) {
case IRQ_AUTO_2: case IRQ_AUTO_2:
amiga_custom.intena = IF_SETCLR | IF_PORTS; amiga_custom.intena = IF_SETCLR | IF_PORTS;
break; break;
...@@ -146,9 +148,9 @@ static void auto_enable_irq(unsigned int irq) ...@@ -146,9 +148,9 @@ static void auto_enable_irq(unsigned int irq)
} }
} }
static void auto_disable_irq(unsigned int irq) static void auto_irq_disable(struct irq_data *data)
{ {
switch (irq) { switch (data->irq) {
case IRQ_AUTO_2: case IRQ_AUTO_2:
amiga_custom.intena = IF_PORTS; amiga_custom.intena = IF_PORTS;
break; break;
...@@ -158,24 +160,25 @@ static void auto_disable_irq(unsigned int irq) ...@@ -158,24 +160,25 @@ static void auto_disable_irq(unsigned int irq)
} }
} }
static struct irq_controller auto_irq_controller = { static struct irq_chip auto_irq_chip = {
.name = "auto", .name = "auto",
.lock = __SPIN_LOCK_UNLOCKED(auto_irq_controller.lock), .irq_enable = auto_irq_enable,
.enable = auto_enable_irq, .irq_disable = auto_irq_disable,
.disable = auto_disable_irq,
}; };
void __init cia_init_IRQ(struct ciabase *base) void __init cia_init_IRQ(struct ciabase *base)
{ {
m68k_setup_irq_controller(&cia_irq_controller, base->cia_irq, CIA_IRQS); m68k_setup_irq_controller(&cia_irq_chip, handle_simple_irq,
base->cia_irq, CIA_IRQS);
/* clear any pending interrupt and turn off all interrupts */ /* clear any pending interrupt and turn off all interrupts */
cia_set_irq(base, CIA_ICR_ALL); cia_set_irq(base, CIA_ICR_ALL);
cia_able_irq(base, CIA_ICR_ALL); cia_able_irq(base, CIA_ICR_ALL);
/* override auto int and install CIA handler */ /* override auto int and install CIA handler */
m68k_setup_irq_controller(&auto_irq_controller, base->handler_irq, 1); m68k_setup_irq_controller(&auto_irq_chip, handle_simple_irq,
m68k_irq_startup(base->handler_irq); base->handler_irq, 1);
m68k_irq_startup_irq(base->handler_irq);
if (request_irq(base->handler_irq, cia_handler, IRQF_SHARED, if (request_irq(base->handler_irq, cia_handler, IRQF_SHARED,
base->name, base)) base->name, base))
pr_err("Couldn't register %s interrupt\n", base->name); pr_err("Couldn't register %s interrupt\n", base->name);
......
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/traps.h> #include <asm/traps.h>
#include <asm/apollohw.h> #include <asm/apollohw.h>
void dn_process_int(unsigned int irq, struct pt_regs *fp) unsigned int apollo_irq_startup(struct irq_data *data)
{ {
__m68k_handle_int(irq, fp); unsigned int irq = data->irq;
*(volatile unsigned char *)(pica)=0x20;
*(volatile unsigned char *)(picb)=0x20;
}
int apollo_irq_startup(unsigned int irq)
{
if (irq < 8) if (irq < 8)
*(volatile unsigned char *)(pica+1) &= ~(1 << irq); *(volatile unsigned char *)(pica+1) &= ~(1 << irq);
else else
...@@ -21,24 +15,33 @@ int apollo_irq_startup(unsigned int irq) ...@@ -21,24 +15,33 @@ int apollo_irq_startup(unsigned int irq)
return 0; return 0;
} }
void apollo_irq_shutdown(unsigned int irq) void apollo_irq_shutdown(struct irq_data *data)
{ {
unsigned int irq = data->irq;
if (irq < 8) if (irq < 8)
*(volatile unsigned char *)(pica+1) |= (1 << irq); *(volatile unsigned char *)(pica+1) |= (1 << irq);
else else
*(volatile unsigned char *)(picb+1) |= (1 << (irq - 8)); *(volatile unsigned char *)(picb+1) |= (1 << (irq - 8));
} }
static struct irq_controller apollo_irq_controller = { void apollo_irq_eoi(struct irq_data *data)
{
*(volatile unsigned char *)(pica) = 0x20;
*(volatile unsigned char *)(picb) = 0x20;
}
static struct irq_chip apollo_irq_chip = {
.name = "apollo", .name = "apollo",
.lock = __SPIN_LOCK_UNLOCKED(apollo_irq_controller.lock), .irq_startup = apollo_irq_startup,
.startup = apollo_irq_startup, .irq_shutdown = apollo_irq_shutdown,
.shutdown = apollo_irq_shutdown, .irq_eoi = apollo_irq_eoi,
}; };
void __init dn_init_IRQ(void) void __init dn_init_IRQ(void)
{ {
m68k_setup_user_interrupt(VEC_USER + 96, 16, dn_process_int); m68k_setup_user_interrupt(VEC_USER + 96, 16);
m68k_setup_irq_controller(&apollo_irq_controller, IRQ_APOLLO, 16); m68k_setup_irq_controller(&apollo_irq_chip, handle_fasteoi_irq,
IRQ_APOLLO, 16);
} }
This diff is collapsed.
...@@ -86,7 +86,7 @@ static void bvme6000_get_model(char *model) ...@@ -86,7 +86,7 @@ static void bvme6000_get_model(char *model)
*/ */
static void __init bvme6000_init_IRQ(void) static void __init bvme6000_init_IRQ(void)
{ {
m68k_setup_user_interrupt(VEC_USER, 192, NULL); m68k_setup_user_interrupt(VEC_USER, 192);
} }
void __init config_bvme6000(void) void __init config_bvme6000(void)
......
...@@ -70,7 +70,7 @@ void __init hp300_sched_init(irq_handler_t vector) ...@@ -70,7 +70,7 @@ void __init hp300_sched_init(irq_handler_t vector)
asm volatile(" movpw %0,%1@(5)" : : "d" (INTVAL), "a" (CLOCKBASE)); asm volatile(" movpw %0,%1@(5)" : : "d" (INTVAL), "a" (CLOCKBASE));
if (request_irq(IRQ_AUTO_6, hp300_tick, IRQ_FLG_STD, "timer tick", vector)) if (request_irq(IRQ_AUTO_6, hp300_tick, 0, "timer tick", vector))
pr_err("Couldn't register timer interrupt\n"); pr_err("Couldn't register timer interrupt\n");
out_8(CLOCKBASE + CLKCR2, 0x1); /* select CR1 */ out_8(CLOCKBASE + CLKCR2, 0x1); /* select CR1 */
......
...@@ -18,6 +18,11 @@ ...@@ -18,6 +18,11 @@
#ifdef CONFIG_MMU #ifdef CONFIG_MMU
static inline void ack_bad_irq(unsigned int irq)
{
pr_crit("unexpected IRQ trap at vector %02x\n", irq);
}
/* entry.S is sensitive to the offsets of these fields */ /* entry.S is sensitive to the offsets of these fields */
typedef struct { typedef struct {
unsigned int __softirq_pending; unsigned int __softirq_pending;
......
...@@ -27,11 +27,6 @@ ...@@ -27,11 +27,6 @@
#ifdef CONFIG_MMU #ifdef CONFIG_MMU
#include <linux/linkage.h>
#include <linux/hardirq.h>
#include <linux/irqreturn.h>
#include <linux/spinlock_types.h>
/* /*
* Interrupt source definitions * Interrupt source definitions
* General interrupt sources are the level 1-7. * General interrupt sources are the level 1-7.
...@@ -54,10 +49,6 @@ ...@@ -54,10 +49,6 @@
#define IRQ_USER 8 #define IRQ_USER 8
extern unsigned int irq_canonicalize(unsigned int irq);
struct pt_regs;
/* /*
* various flags for request_irq() - the Amiga now uses the standard * various flags for request_irq() - the Amiga now uses the standard
* mechanism like all other architectures - IRQF_DISABLED and * mechanism like all other architectures - IRQF_DISABLED and
...@@ -71,57 +62,27 @@ struct pt_regs; ...@@ -71,57 +62,27 @@ struct pt_regs;
#define IRQ_FLG_STD (0x8000) /* internally used */ #define IRQ_FLG_STD (0x8000) /* internally used */
#endif #endif
/* struct irq_data;
* This structure is used to chain together the ISRs for a particular struct irq_chip;
* interrupt source (if it supports chaining). struct irq_desc;
*/ extern unsigned int m68k_irq_startup(struct irq_data *data);
typedef struct irq_node { extern unsigned int m68k_irq_startup_irq(unsigned int irq);
irqreturn_t (*handler)(int, void *); extern void m68k_irq_shutdown(struct irq_data *data);
void *dev_id; extern void m68k_setup_auto_interrupt(void (*handler)(unsigned int,
struct irq_node *next; struct pt_regs *));
unsigned long flags; extern void m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt);
const char *devname; extern void m68k_setup_irq_controller(struct irq_chip *,
} irq_node_t; void (*handle)(unsigned int irq,
struct irq_desc *desc),
/* unsigned int irq, unsigned int cnt);
* This structure has only 4 elements for speed reasons
*/
struct irq_handler {
int (*handler)(int, void *);
unsigned long flags;
void *dev_id;
const char *devname;
};
struct irq_controller {
const char *name;
spinlock_t lock;
int (*startup)(unsigned int irq);
void (*shutdown)(unsigned int irq);
void (*enable)(unsigned int irq);
void (*disable)(unsigned int irq);
};
extern int m68k_irq_startup(unsigned int);
extern void m68k_irq_shutdown(unsigned int);
/*
* This function returns a new irq_node_t
*/
extern irq_node_t *new_irq_node(void);
extern void m68k_setup_auto_interrupt(void (*handler)(unsigned int, struct pt_regs *)); extern unsigned int irq_canonicalize(unsigned int irq);
extern void m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt,
void (*handler)(unsigned int, struct pt_regs *));
extern void m68k_setup_irq_controller(struct irq_controller *, unsigned int, unsigned int);
asmlinkage void m68k_handle_int(unsigned int);
asmlinkage void __m68k_handle_int(unsigned int, struct pt_regs *);
#else #else
#define irq_canonicalize(irq) (irq) #define irq_canonicalize(irq) (irq)
#endif /* CONFIG_MMU */ #endif /* CONFIG_MMU */
asmlinkage void do_IRQ(int irq, struct pt_regs *regs); asmlinkage void do_IRQ(int irq, struct pt_regs *regs);
extern atomic_t irq_err_count;
#endif /* _M68K_IRQ_H_ */ #endif /* _M68K_IRQ_H_ */
...@@ -12,6 +12,8 @@ extern void mac_reset(void); ...@@ -12,6 +12,8 @@ extern void mac_reset(void);
extern void mac_poweroff(void); extern void mac_poweroff(void);
extern void mac_init_IRQ(void); extern void mac_init_IRQ(void);
extern int mac_irq_pending(unsigned int); extern int mac_irq_pending(unsigned int);
extern void mac_irq_enable(struct irq_data *data);
extern void mac_irq_disable(struct irq_data *data);
/* /*
* Floppy driver magic hook - probably shouldn't be here * Floppy driver magic hook - probably shouldn't be here
......
...@@ -24,6 +24,3 @@ ...@@ -24,6 +24,3 @@
#define Q40_IRQ10_MASK (1<<5) #define Q40_IRQ10_MASK (1<<5)
#define Q40_IRQ14_MASK (1<<6) #define Q40_IRQ14_MASK (1<<6)
#define Q40_IRQ15_MASK (1<<7) #define Q40_IRQ15_MASK (1<<7)
extern unsigned long q40_probe_irq_on (void);
extern int q40_probe_irq_off (unsigned long irqs);
...@@ -6,16 +6,15 @@ extra-$(CONFIG_MMU) := head.o ...@@ -6,16 +6,15 @@ extra-$(CONFIG_MMU) := head.o
extra-$(CONFIG_SUN3) := sun3-head.o extra-$(CONFIG_SUN3) := sun3-head.o
extra-y += vmlinux.lds extra-y += vmlinux.lds
obj-y := entry.o m68k_ksyms.o module.o process.o ptrace.o setup.o signal.o \ obj-y := entry.o irq.o m68k_ksyms.o module.o process.o ptrace.o setup.o \
sys_m68k.o syscalltable.o time.o traps.o signal.o sys_m68k.o syscalltable.o time.o traps.o
obj-$(CONFIG_MMU) += ints.o devres.o vectors.o obj-$(CONFIG_MMU) += ints.o vectors.o
devres-$(CONFIG_MMU) = ../../../kernel/irq/devres.o
ifndef CONFIG_MMU_SUN3 ifndef CONFIG_MMU_SUN3
obj-y += dma.o obj-y += dma.o
endif endif
ifndef CONFIG_MMU ifndef CONFIG_MMU
obj-y += init_task.o irq.o obj-y += init_task.o
endif endif
...@@ -48,7 +48,7 @@ ...@@ -48,7 +48,7 @@
.globl sys_fork, sys_clone, sys_vfork .globl sys_fork, sys_clone, sys_vfork
.globl ret_from_interrupt, bad_interrupt .globl ret_from_interrupt, bad_interrupt
.globl auto_irqhandler_fixup .globl auto_irqhandler_fixup
.globl user_irqvec_fixup, user_irqhandler_fixup .globl user_irqvec_fixup
.text .text
ENTRY(buserr) ENTRY(buserr)
...@@ -207,7 +207,7 @@ ENTRY(auto_inthandler) ...@@ -207,7 +207,7 @@ ENTRY(auto_inthandler)
movel %sp,%sp@- movel %sp,%sp@-
movel %d0,%sp@- | put vector # on stack movel %d0,%sp@- | put vector # on stack
auto_irqhandler_fixup = . + 2 auto_irqhandler_fixup = . + 2
jsr __m68k_handle_int | process the IRQ jsr do_IRQ | process the IRQ
addql #8,%sp | pop parameters off stack addql #8,%sp | pop parameters off stack
ret_from_interrupt: ret_from_interrupt:
...@@ -240,8 +240,7 @@ user_irqvec_fixup = . + 2 ...@@ -240,8 +240,7 @@ user_irqvec_fixup = . + 2
movel %sp,%sp@- movel %sp,%sp@-
movel %d0,%sp@- | put vector # on stack movel %d0,%sp@- | put vector # on stack
user_irqhandler_fixup = . + 2 jsr do_IRQ | process the IRQ
jsr __m68k_handle_int | process the IRQ
addql #8,%sp | pop parameters off stack addql #8,%sp | pop parameters off stack
subqb #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1) subqb #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
......
This diff is collapsed.
...@@ -11,6 +11,7 @@ ...@@ -11,6 +11,7 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/irq.h>
#include <asm/traps.h> #include <asm/traps.h>
#include <asm/bootinfo.h> #include <asm/bootinfo.h>
...@@ -20,9 +21,6 @@ ...@@ -20,9 +21,6 @@
/* #define DEBUG_IRQS */ /* #define DEBUG_IRQS */
extern void mac_enable_irq(unsigned int);
extern void mac_disable_irq(unsigned int);
int baboon_present; int baboon_present;
static volatile struct baboon *baboon; static volatile struct baboon *baboon;
static unsigned char baboon_disabled; static unsigned char baboon_disabled;
...@@ -53,7 +51,7 @@ void __init baboon_init(void) ...@@ -53,7 +51,7 @@ void __init baboon_init(void)
* Baboon interrupt handler. This works a lot like a VIA. * Baboon interrupt handler. This works a lot like a VIA.
*/ */
static irqreturn_t baboon_irq(int irq, void *dev_id) static void baboon_irq(unsigned int irq, struct irq_desc *desc)
{ {
int irq_bit, irq_num; int irq_bit, irq_num;
unsigned char events; unsigned char events;
...@@ -64,15 +62,16 @@ static irqreturn_t baboon_irq(int irq, void *dev_id) ...@@ -64,15 +62,16 @@ static irqreturn_t baboon_irq(int irq, void *dev_id)
(uint) baboon->mb_status); (uint) baboon->mb_status);
#endif #endif
if (!(events = baboon->mb_ifr & 0x07)) events = baboon->mb_ifr & 0x07;
return IRQ_NONE; if (!events)
return;
irq_num = IRQ_BABOON_0; irq_num = IRQ_BABOON_0;
irq_bit = 1; irq_bit = 1;
do { do {
if (events & irq_bit) { if (events & irq_bit) {
baboon->mb_ifr &= ~irq_bit; baboon->mb_ifr &= ~irq_bit;
m68k_handle_int(irq_num); generic_handle_irq(irq_num);
} }
irq_bit <<= 1; irq_bit <<= 1;
irq_num++; irq_num++;
...@@ -82,7 +81,6 @@ static irqreturn_t baboon_irq(int irq, void *dev_id) ...@@ -82,7 +81,6 @@ static irqreturn_t baboon_irq(int irq, void *dev_id)
/* for now we need to smash all interrupts */ /* for now we need to smash all interrupts */
baboon->mb_ifr &= ~events; baboon->mb_ifr &= ~events;
#endif #endif
return IRQ_HANDLED;
} }
/* /*
...@@ -92,8 +90,7 @@ static irqreturn_t baboon_irq(int irq, void *dev_id) ...@@ -92,8 +90,7 @@ static irqreturn_t baboon_irq(int irq, void *dev_id)
void __init baboon_register_interrupts(void) void __init baboon_register_interrupts(void)
{ {
baboon_disabled = 0; baboon_disabled = 0;
if (request_irq(IRQ_NUBUS_C, baboon_irq, 0, "baboon", (void *)baboon)) irq_set_chained_handler(IRQ_NUBUS_C, baboon_irq);
pr_err("Couldn't register baboon interrupt\n");
} }
/* /*
...@@ -111,7 +108,7 @@ void baboon_irq_enable(int irq) ...@@ -111,7 +108,7 @@ void baboon_irq_enable(int irq)
baboon_disabled &= ~(1 << irq_idx); baboon_disabled &= ~(1 << irq_idx);
if (!baboon_disabled) if (!baboon_disabled)
mac_enable_irq(IRQ_NUBUS_C); mac_irq_enable(irq_get_irq_data(IRQ_NUBUS_C));
} }
void baboon_irq_disable(int irq) void baboon_irq_disable(int irq)
...@@ -124,7 +121,7 @@ void baboon_irq_disable(int irq) ...@@ -124,7 +121,7 @@ void baboon_irq_disable(int irq)
baboon_disabled |= 1 << irq_idx; baboon_disabled |= 1 << irq_idx;
if (baboon_disabled) if (baboon_disabled)
mac_disable_irq(IRQ_NUBUS_C); mac_irq_disable(irq_get_irq_data(IRQ_NUBUS_C));
} }
void baboon_irq_clear(int irq) void baboon_irq_clear(int irq)
......
...@@ -305,15 +305,13 @@ void __init iop_register_interrupts(void) ...@@ -305,15 +305,13 @@ void __init iop_register_interrupts(void)
{ {
if (iop_ism_present) { if (iop_ism_present) {
if (oss_present) { if (oss_present) {
if (request_irq(OSS_IRQLEV_IOPISM, iop_ism_irq, if (request_irq(OSS_IRQLEV_IOPISM, iop_ism_irq, 0,
IRQ_FLG_LOCK, "ISM IOP", "ISM IOP", (void *)IOP_NUM_ISM))
(void *) IOP_NUM_ISM))
pr_err("Couldn't register ISM IOP interrupt\n"); pr_err("Couldn't register ISM IOP interrupt\n");
oss_irq_enable(IRQ_MAC_ADB); oss_irq_enable(IRQ_MAC_ADB);
} else { } else {
if (request_irq(IRQ_VIA2_0, iop_ism_irq, if (request_irq(IRQ_VIA2_0, iop_ism_irq, 0, "ISM IOP",
IRQ_FLG_LOCK|IRQ_FLG_FAST, "ISM IOP", (void *)IOP_NUM_ISM))
(void *) IOP_NUM_ISM))
pr_err("Couldn't register ISM IOP interrupt\n"); pr_err("Couldn't register ISM IOP interrupt\n");
} }
if (!iop_alive(iop_base[IOP_NUM_ISM])) { if (!iop_alive(iop_base[IOP_NUM_ISM])) {
......
...@@ -190,14 +190,10 @@ irqreturn_t mac_debug_handler(int, void *); ...@@ -190,14 +190,10 @@ irqreturn_t mac_debug_handler(int, void *);
/* #define DEBUG_MACINTS */ /* #define DEBUG_MACINTS */
void mac_enable_irq(unsigned int irq); static struct irq_chip mac_irq_chip = {
void mac_disable_irq(unsigned int irq);
static struct irq_controller mac_irq_controller = {
.name = "mac", .name = "mac",
.lock = __SPIN_LOCK_UNLOCKED(mac_irq_controller.lock), .irq_enable = mac_irq_enable,
.enable = mac_enable_irq, .irq_disable = mac_irq_disable,
.disable = mac_disable_irq,
}; };
void __init mac_init_IRQ(void) void __init mac_init_IRQ(void)
...@@ -205,7 +201,7 @@ void __init mac_init_IRQ(void) ...@@ -205,7 +201,7 @@ void __init mac_init_IRQ(void)
#ifdef DEBUG_MACINTS #ifdef DEBUG_MACINTS
printk("mac_init_IRQ(): Setting things up...\n"); printk("mac_init_IRQ(): Setting things up...\n");
#endif #endif
m68k_setup_irq_controller(&mac_irq_controller, IRQ_USER, m68k_setup_irq_controller(&mac_irq_chip, handle_simple_irq, IRQ_USER,
NUM_MAC_SOURCES - IRQ_USER); NUM_MAC_SOURCES - IRQ_USER);
/* Make sure the SONIC interrupt is cleared or things get ugly */ /* Make sure the SONIC interrupt is cleared or things get ugly */
#ifdef SHUTUP_SONIC #ifdef SHUTUP_SONIC
...@@ -241,16 +237,17 @@ void __init mac_init_IRQ(void) ...@@ -241,16 +237,17 @@ void __init mac_init_IRQ(void)
} }
/* /*
* mac_enable_irq - enable an interrupt source * mac_irq_enable - enable an interrupt source
* mac_disable_irq - disable an interrupt source * mac_irq_disable - disable an interrupt source
* mac_clear_irq - clears a pending interrupt * mac_clear_irq - clears a pending interrupt
* mac_pending_irq - Returns the pending status of an IRQ (nonzero = pending) * mac_irq_pending - returns the pending status of an IRQ (nonzero = pending)
* *
* These routines are just dispatchers to the VIA/OSS/PSC routines. * These routines are just dispatchers to the VIA/OSS/PSC routines.
*/ */
void mac_enable_irq(unsigned int irq) void mac_irq_enable(struct irq_data *data)
{ {
int irq = data->irq;
int irq_src = IRQ_SRC(irq); int irq_src = IRQ_SRC(irq);
switch(irq_src) { switch(irq_src) {
...@@ -283,8 +280,9 @@ void mac_enable_irq(unsigned int irq) ...@@ -283,8 +280,9 @@ void mac_enable_irq(unsigned int irq)
} }
} }
void mac_disable_irq(unsigned int irq) void mac_irq_disable(struct irq_data *data)
{ {
int irq = data->irq;
int irq_src = IRQ_SRC(irq); int irq_src = IRQ_SRC(irq);
switch(irq_src) { switch(irq_src) {
......
...@@ -19,6 +19,7 @@ ...@@ -19,6 +19,7 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/irq.h>
#include <asm/bootinfo.h> #include <asm/bootinfo.h>
#include <asm/macintosh.h> #include <asm/macintosh.h>
...@@ -29,10 +30,7 @@ ...@@ -29,10 +30,7 @@
int oss_present; int oss_present;
volatile struct mac_oss *oss; volatile struct mac_oss *oss;
static irqreturn_t oss_irq(int, void *); extern void via1_irq(unsigned int irq, struct irq_desc *desc);
static irqreturn_t oss_nubus_irq(int, void *);
extern irqreturn_t via1_irq(int, void *);
/* /*
* Initialize the OSS * Initialize the OSS
...@@ -59,26 +57,6 @@ void __init oss_init(void) ...@@ -59,26 +57,6 @@ void __init oss_init(void)
oss->irq_level[OSS_VIA1] = OSS_IRQLEV_VIA1; oss->irq_level[OSS_VIA1] = OSS_IRQLEV_VIA1;
} }
/*
* Register the OSS and NuBus interrupt dispatchers.
*/
void __init oss_register_interrupts(void)
{
if (request_irq(OSS_IRQLEV_SCSI, oss_irq, IRQ_FLG_LOCK,
"scsi", (void *) oss))
pr_err("Couldn't register %s interrupt\n", "scsi");
if (request_irq(OSS_IRQLEV_NUBUS, oss_nubus_irq, IRQ_FLG_LOCK,
"nubus", (void *) oss))
pr_err("Couldn't register %s interrupt\n", "nubus");
if (request_irq(OSS_IRQLEV_SOUND, oss_irq, IRQ_FLG_LOCK,
"sound", (void *) oss))
pr_err("Couldn't register %s interrupt\n", "sound");
if (request_irq(OSS_IRQLEV_VIA1, via1_irq, IRQ_FLG_LOCK,
"via1", (void *) via1))
pr_err("Couldn't register %s interrupt\n", "via1");
}
/* /*
* Initialize OSS for Nubus access * Initialize OSS for Nubus access
*/ */
...@@ -92,17 +70,17 @@ void __init oss_nubus_init(void) ...@@ -92,17 +70,17 @@ void __init oss_nubus_init(void)
* and SCSI; everything else is routed to its own autovector IRQ. * and SCSI; everything else is routed to its own autovector IRQ.
*/ */
static irqreturn_t oss_irq(int irq, void *dev_id) static void oss_irq(unsigned int irq, struct irq_desc *desc)
{ {
int events; int events;
events = oss->irq_pending & (OSS_IP_SOUND|OSS_IP_SCSI); events = oss->irq_pending & (OSS_IP_SOUND|OSS_IP_SCSI);
if (!events) if (!events)
return IRQ_NONE; return;
#ifdef DEBUG_IRQS #ifdef DEBUG_IRQS
if ((console_loglevel == 10) && !(events & OSS_IP_SCSI)) { if ((console_loglevel == 10) && !(events & OSS_IP_SCSI)) {
printk("oss_irq: irq %d events = 0x%04X\n", irq, printk("oss_irq: irq %u events = 0x%04X\n", irq,
(int) oss->irq_pending); (int) oss->irq_pending);
} }
#endif #endif
...@@ -113,11 +91,10 @@ static irqreturn_t oss_irq(int irq, void *dev_id) ...@@ -113,11 +91,10 @@ static irqreturn_t oss_irq(int irq, void *dev_id)
/* FIXME: call sound handler */ /* FIXME: call sound handler */
} else if (events & OSS_IP_SCSI) { } else if (events & OSS_IP_SCSI) {
oss->irq_pending &= ~OSS_IP_SCSI; oss->irq_pending &= ~OSS_IP_SCSI;
m68k_handle_int(IRQ_MAC_SCSI); generic_handle_irq(IRQ_MAC_SCSI);
} else { } else {
/* FIXME: error check here? */ /* FIXME: error check here? */
} }
return IRQ_HANDLED;
} }
/* /*
...@@ -126,13 +103,13 @@ static irqreturn_t oss_irq(int irq, void *dev_id) ...@@ -126,13 +103,13 @@ static irqreturn_t oss_irq(int irq, void *dev_id)
* Unlike the VIA/RBV this is on its own autovector interrupt level. * Unlike the VIA/RBV this is on its own autovector interrupt level.
*/ */
static irqreturn_t oss_nubus_irq(int irq, void *dev_id) static void oss_nubus_irq(unsigned int irq, struct irq_desc *desc)
{ {
int events, irq_bit, i; int events, irq_bit, i;
events = oss->irq_pending & OSS_IP_NUBUS; events = oss->irq_pending & OSS_IP_NUBUS;
if (!events) if (!events)
return IRQ_NONE; return;
#ifdef DEBUG_NUBUS_INT #ifdef DEBUG_NUBUS_INT
if (console_loglevel > 7) { if (console_loglevel > 7) {
...@@ -148,10 +125,21 @@ static irqreturn_t oss_nubus_irq(int irq, void *dev_id) ...@@ -148,10 +125,21 @@ static irqreturn_t oss_nubus_irq(int irq, void *dev_id)
irq_bit >>= 1; irq_bit >>= 1;
if (events & irq_bit) { if (events & irq_bit) {
oss->irq_pending &= ~irq_bit; oss->irq_pending &= ~irq_bit;
m68k_handle_int(NUBUS_SOURCE_BASE + i); generic_handle_irq(NUBUS_SOURCE_BASE + i);
} }
} while(events & (irq_bit - 1)); } while(events & (irq_bit - 1));
return IRQ_HANDLED; }
/*
* Register the OSS and NuBus interrupt dispatchers.
*/
void __init oss_register_interrupts(void)
{
irq_set_chained_handler(OSS_IRQLEV_SCSI, oss_irq);
irq_set_chained_handler(OSS_IRQLEV_NUBUS, oss_nubus_irq);
irq_set_chained_handler(OSS_IRQLEV_SOUND, oss_irq);
irq_set_chained_handler(OSS_IRQLEV_VIA1, via1_irq);
} }
/* /*
......
...@@ -18,6 +18,7 @@ ...@@ -18,6 +18,7 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/irq.h>
#include <asm/traps.h> #include <asm/traps.h>
#include <asm/bootinfo.h> #include <asm/bootinfo.h>
...@@ -30,8 +31,6 @@ ...@@ -30,8 +31,6 @@
int psc_present; int psc_present;
volatile __u8 *psc; volatile __u8 *psc;
irqreturn_t psc_irq(int, void *);
/* /*
* Debugging dump, used in various places to see what's going on. * Debugging dump, used in various places to see what's going on.
*/ */
...@@ -111,53 +110,53 @@ void __init psc_init(void) ...@@ -111,53 +110,53 @@ void __init psc_init(void)
} }
} }
/*
* Register the PSC interrupt dispatchers for autovector interrupts 3-6.
*/
void __init psc_register_interrupts(void)
{
if (request_irq(IRQ_AUTO_3, psc_irq, 0, "psc3", (void *) 0x30))
pr_err("Couldn't register psc%d interrupt\n", 3);
if (request_irq(IRQ_AUTO_4, psc_irq, 0, "psc4", (void *) 0x40))
pr_err("Couldn't register psc%d interrupt\n", 4);
if (request_irq(IRQ_AUTO_5, psc_irq, 0, "psc5", (void *) 0x50))
pr_err("Couldn't register psc%d interrupt\n", 5);
if (request_irq(IRQ_AUTO_6, psc_irq, 0, "psc6", (void *) 0x60))
pr_err("Couldn't register psc%d interrupt\n", 6);
}
/* /*
* PSC interrupt handler. It's a lot like the VIA interrupt handler. * PSC interrupt handler. It's a lot like the VIA interrupt handler.
*/ */
irqreturn_t psc_irq(int irq, void *dev_id) static void psc_irq(unsigned int irq, struct irq_desc *desc)
{ {
int pIFR = pIFRbase + ((int) dev_id); unsigned int offset = (unsigned int)irq_desc_get_handler_data(desc);
int pIER = pIERbase + ((int) dev_id); int pIFR = pIFRbase + offset;
int pIER = pIERbase + offset;
int irq_num; int irq_num;
unsigned char irq_bit, events; unsigned char irq_bit, events;
#ifdef DEBUG_IRQS #ifdef DEBUG_IRQS
printk("psc_irq: irq %d pIFR = 0x%02X pIER = 0x%02X\n", printk("psc_irq: irq %u pIFR = 0x%02X pIER = 0x%02X\n",
irq, (int) psc_read_byte(pIFR), (int) psc_read_byte(pIER)); irq, (int) psc_read_byte(pIFR), (int) psc_read_byte(pIER));
#endif #endif
events = psc_read_byte(pIFR) & psc_read_byte(pIER) & 0xF; events = psc_read_byte(pIFR) & psc_read_byte(pIER) & 0xF;
if (!events) if (!events)
return IRQ_NONE; return;
irq_num = irq << 3; irq_num = irq << 3;
irq_bit = 1; irq_bit = 1;
do { do {
if (events & irq_bit) { if (events & irq_bit) {
psc_write_byte(pIFR, irq_bit); psc_write_byte(pIFR, irq_bit);
m68k_handle_int(irq_num); generic_handle_irq(irq_num);
} }
irq_num++; irq_num++;
irq_bit <<= 1; irq_bit <<= 1;
} while (events >= irq_bit); } while (events >= irq_bit);
return IRQ_HANDLED; }
/*
* Register the PSC interrupt dispatchers for autovector interrupts 3-6.
*/
void __init psc_register_interrupts(void)
{
irq_set_chained_handler(IRQ_AUTO_3, psc_irq);
irq_set_handler_data(IRQ_AUTO_3, (void *)0x30);
irq_set_chained_handler(IRQ_AUTO_4, psc_irq);
irq_set_handler_data(IRQ_AUTO_4, (void *)0x40);
irq_set_chained_handler(IRQ_AUTO_5, psc_irq);
irq_set_handler_data(IRQ_AUTO_5, (void *)0x50);
irq_set_chained_handler(IRQ_AUTO_6, psc_irq);
irq_set_handler_data(IRQ_AUTO_6, (void *)0x60);
} }
void psc_irq_enable(int irq) { void psc_irq_enable(int irq) {
......
...@@ -28,6 +28,7 @@ ...@@ -28,6 +28,7 @@
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/irq.h>
#include <asm/bootinfo.h> #include <asm/bootinfo.h>
#include <asm/macintosh.h> #include <asm/macintosh.h>
...@@ -77,9 +78,6 @@ static int gIER,gIFR,gBufA,gBufB; ...@@ -77,9 +78,6 @@ static int gIER,gIFR,gBufA,gBufB;
static u8 nubus_disabled; static u8 nubus_disabled;
void via_debug_dump(void); void via_debug_dump(void);
irqreturn_t via1_irq(int, void *);
irqreturn_t via2_irq(int, void *);
irqreturn_t via_nubus_irq(int, void *);
void via_irq_enable(int irq); void via_irq_enable(int irq);
void via_irq_disable(int irq); void via_irq_disable(int irq);
void via_irq_clear(int irq); void via_irq_clear(int irq);
...@@ -281,39 +279,10 @@ void __init via_init_clock(irq_handler_t func) ...@@ -281,39 +279,10 @@ void __init via_init_clock(irq_handler_t func)
via1[vT1CL] = MAC_CLOCK_LOW; via1[vT1CL] = MAC_CLOCK_LOW;
via1[vT1CH] = MAC_CLOCK_HIGH; via1[vT1CH] = MAC_CLOCK_HIGH;
if (request_irq(IRQ_MAC_TIMER_1, func, IRQ_FLG_LOCK, "timer", func)) if (request_irq(IRQ_MAC_TIMER_1, func, 0, "timer", func))
pr_err("Couldn't register %s interrupt\n", "timer"); pr_err("Couldn't register %s interrupt\n", "timer");
} }
/*
* Register the interrupt dispatchers for VIA or RBV machines only.
*/
void __init via_register_interrupts(void)
{
if (via_alt_mapping) {
if (request_irq(IRQ_AUTO_1, via1_irq,
IRQ_FLG_LOCK|IRQ_FLG_FAST, "software",
(void *) via1))
pr_err("Couldn't register %s interrupt\n", "software");
if (request_irq(IRQ_AUTO_6, via1_irq,
IRQ_FLG_LOCK|IRQ_FLG_FAST, "via1",
(void *) via1))
pr_err("Couldn't register %s interrupt\n", "via1");
} else {
if (request_irq(IRQ_AUTO_1, via1_irq,
IRQ_FLG_LOCK|IRQ_FLG_FAST, "via1",
(void *) via1))
pr_err("Couldn't register %s interrupt\n", "via1");
}
if (request_irq(IRQ_AUTO_2, via2_irq, IRQ_FLG_LOCK|IRQ_FLG_FAST,
"via2", (void *) via2))
pr_err("Couldn't register %s interrupt\n", "via2");
if (request_irq(IRQ_MAC_NUBUS, via_nubus_irq,
IRQ_FLG_LOCK|IRQ_FLG_FAST, "nubus", (void *) via2))
pr_err("Couldn't register %s interrupt\n", "nubus");
}
/* /*
* Debugging dump, used in various places to see what's going on. * Debugging dump, used in various places to see what's going on.
*/ */
...@@ -446,48 +415,46 @@ void __init via_nubus_init(void) ...@@ -446,48 +415,46 @@ void __init via_nubus_init(void)
* via6522.c :-), disable/pending masks added. * via6522.c :-), disable/pending masks added.
*/ */
irqreturn_t via1_irq(int irq, void *dev_id) void via1_irq(unsigned int irq, struct irq_desc *desc)
{ {
int irq_num; int irq_num;
unsigned char irq_bit, events; unsigned char irq_bit, events;
events = via1[vIFR] & via1[vIER] & 0x7F; events = via1[vIFR] & via1[vIER] & 0x7F;
if (!events) if (!events)
return IRQ_NONE; return;
irq_num = VIA1_SOURCE_BASE; irq_num = VIA1_SOURCE_BASE;
irq_bit = 1; irq_bit = 1;
do { do {
if (events & irq_bit) { if (events & irq_bit) {
via1[vIFR] = irq_bit; via1[vIFR] = irq_bit;
m68k_handle_int(irq_num); generic_handle_irq(irq_num);
} }
++irq_num; ++irq_num;
irq_bit <<= 1; irq_bit <<= 1;
} while (events >= irq_bit); } while (events >= irq_bit);
return IRQ_HANDLED;
} }
irqreturn_t via2_irq(int irq, void *dev_id) static void via2_irq(unsigned int irq, struct irq_desc *desc)
{ {
int irq_num; int irq_num;
unsigned char irq_bit, events; unsigned char irq_bit, events;
events = via2[gIFR] & via2[gIER] & 0x7F; events = via2[gIFR] & via2[gIER] & 0x7F;
if (!events) if (!events)
return IRQ_NONE; return;
irq_num = VIA2_SOURCE_BASE; irq_num = VIA2_SOURCE_BASE;
irq_bit = 1; irq_bit = 1;
do { do {
if (events & irq_bit) { if (events & irq_bit) {
via2[gIFR] = irq_bit | rbv_clear; via2[gIFR] = irq_bit | rbv_clear;
m68k_handle_int(irq_num); generic_handle_irq(irq_num);
} }
++irq_num; ++irq_num;
irq_bit <<= 1; irq_bit <<= 1;
} while (events >= irq_bit); } while (events >= irq_bit);
return IRQ_HANDLED;
} }
/* /*
...@@ -495,7 +462,7 @@ irqreturn_t via2_irq(int irq, void *dev_id) ...@@ -495,7 +462,7 @@ irqreturn_t via2_irq(int irq, void *dev_id)
* VIA2 dispatcher as a fast interrupt handler. * VIA2 dispatcher as a fast interrupt handler.
*/ */
irqreturn_t via_nubus_irq(int irq, void *dev_id) void via_nubus_irq(unsigned int irq, struct irq_desc *desc)
{ {
int slot_irq; int slot_irq;
unsigned char slot_bit, events; unsigned char slot_bit, events;
...@@ -506,7 +473,7 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id) ...@@ -506,7 +473,7 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id)
else else
events &= ~via2[vDirA]; events &= ~via2[vDirA];
if (!events) if (!events)
return IRQ_NONE; return;
do { do {
slot_irq = IRQ_NUBUS_F; slot_irq = IRQ_NUBUS_F;
...@@ -514,7 +481,7 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id) ...@@ -514,7 +481,7 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id)
do { do {
if (events & slot_bit) { if (events & slot_bit) {
events &= ~slot_bit; events &= ~slot_bit;
m68k_handle_int(slot_irq); generic_handle_irq(slot_irq);
} }
--slot_irq; --slot_irq;
slot_bit >>= 1; slot_bit >>= 1;
...@@ -528,7 +495,24 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id) ...@@ -528,7 +495,24 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id)
else else
events &= ~via2[vDirA]; events &= ~via2[vDirA];
} while (events); } while (events);
return IRQ_HANDLED; }
/*
* Register the interrupt dispatchers for VIA or RBV machines only.
*/
void __init via_register_interrupts(void)
{
if (via_alt_mapping) {
/* software interrupt */
irq_set_chained_handler(IRQ_AUTO_1, via1_irq);
/* via1 interrupt */
irq_set_chained_handler(IRQ_AUTO_6, via1_irq);
} else {
irq_set_chained_handler(IRQ_AUTO_1, via1_irq);
}
irq_set_chained_handler(IRQ_AUTO_2, via2_irq);
irq_set_chained_handler(IRQ_MAC_NUBUS, via_nubus_irq);
} }
void via_irq_enable(int irq) { void via_irq_enable(int irq) {
......
...@@ -81,7 +81,7 @@ static void mvme147_get_model(char *model) ...@@ -81,7 +81,7 @@ static void mvme147_get_model(char *model)
void __init mvme147_init_IRQ(void) void __init mvme147_init_IRQ(void)
{ {
m68k_setup_user_interrupt(VEC_USER, 192, NULL); m68k_setup_user_interrupt(VEC_USER, 192);
} }
void __init config_mvme147(void) void __init config_mvme147(void)
...@@ -114,8 +114,7 @@ static irqreturn_t mvme147_timer_int (int irq, void *dev_id) ...@@ -114,8 +114,7 @@ static irqreturn_t mvme147_timer_int (int irq, void *dev_id)
void mvme147_sched_init (irq_handler_t timer_routine) void mvme147_sched_init (irq_handler_t timer_routine)
{ {
tick_handler = timer_routine; tick_handler = timer_routine;
if (request_irq(PCC_IRQ_TIMER1, mvme147_timer_int, IRQ_FLG_REPLACE, if (request_irq(PCC_IRQ_TIMER1, mvme147_timer_int, 0, "timer 1", NULL))
"timer 1", NULL))
pr_err("Couldn't register timer interrupt\n"); pr_err("Couldn't register timer interrupt\n");
/* Init the clock with a value */ /* Init the clock with a value */
......
...@@ -117,7 +117,7 @@ static void mvme16x_get_hardware_list(struct seq_file *m) ...@@ -117,7 +117,7 @@ static void mvme16x_get_hardware_list(struct seq_file *m)
static void __init mvme16x_init_IRQ (void) static void __init mvme16x_init_IRQ (void)
{ {
m68k_setup_user_interrupt(VEC_USER, 192, NULL); m68k_setup_user_interrupt(VEC_USER, 192);
} }
#define pcc2chip ((volatile u_char *)0xfff42000) #define pcc2chip ((volatile u_char *)0xfff42000)
......
...@@ -15,10 +15,10 @@ ...@@ -15,10 +15,10 @@
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/errno.h> #include <linux/errno.h>
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/irq.h>
#include <asm/ptrace.h> #include <asm/ptrace.h>
#include <asm/system.h> #include <asm/system.h>
#include <asm/irq.h>
#include <asm/traps.h> #include <asm/traps.h>
#include <asm/q40_master.h> #include <asm/q40_master.h>
...@@ -35,35 +35,36 @@ ...@@ -35,35 +35,36 @@
*/ */
static void q40_irq_handler(unsigned int, struct pt_regs *fp); static void q40_irq_handler(unsigned int, struct pt_regs *fp);
static void q40_enable_irq(unsigned int); static void q40_irq_enable(struct irq_data *data);
static void q40_disable_irq(unsigned int); static void q40_irq_disable(struct irq_data *data);
unsigned short q40_ablecount[35]; unsigned short q40_ablecount[35];
unsigned short q40_state[35]; unsigned short q40_state[35];
static int q40_irq_startup(unsigned int irq) static unsigned int q40_irq_startup(struct irq_data *data)
{ {
unsigned int irq = data->irq;
/* test for ISA ints not implemented by HW */ /* test for ISA ints not implemented by HW */
switch (irq) { switch (irq) {
case 1: case 2: case 8: case 9: case 1: case 2: case 8: case 9:
case 11: case 12: case 13: case 11: case 12: case 13:
printk("%s: ISA IRQ %d not implemented by HW\n", __func__, irq); printk("%s: ISA IRQ %d not implemented by HW\n", __func__, irq);
return -ENXIO; /* FIXME return -ENXIO; */
} }
return 0; return 0;
} }
static void q40_irq_shutdown(unsigned int irq) static void q40_irq_shutdown(struct irq_data *data)
{ {
} }
static struct irq_controller q40_irq_controller = { static struct irq_chip q40_irq_chip = {
.name = "q40", .name = "q40",
.lock = __SPIN_LOCK_UNLOCKED(q40_irq_controller.lock), .irq_startup = q40_irq_startup,
.startup = q40_irq_startup, .irq_shutdown = q40_irq_shutdown,
.shutdown = q40_irq_shutdown, .irq_enable = q40_irq_enable,
.enable = q40_enable_irq, .irq_disable = q40_irq_disable,
.disable = q40_disable_irq,
}; };
/* /*
...@@ -81,13 +82,14 @@ static int disabled; ...@@ -81,13 +82,14 @@ static int disabled;
void __init q40_init_IRQ(void) void __init q40_init_IRQ(void)
{ {
m68k_setup_irq_controller(&q40_irq_controller, 1, Q40_IRQ_MAX); m68k_setup_irq_controller(&q40_irq_chip, handle_simple_irq, 1,
Q40_IRQ_MAX);
/* setup handler for ISA ints */ /* setup handler for ISA ints */
m68k_setup_auto_interrupt(q40_irq_handler); m68k_setup_auto_interrupt(q40_irq_handler);
m68k_irq_startup(IRQ_AUTO_2); m68k_irq_startup_irq(IRQ_AUTO_2);
m68k_irq_startup(IRQ_AUTO_4); m68k_irq_startup_irq(IRQ_AUTO_4);
/* now enable some ints.. */ /* now enable some ints.. */
master_outb(1, EXT_ENABLE_REG); /* ISA IRQ 5-15 */ master_outb(1, EXT_ENABLE_REG); /* ISA IRQ 5-15 */
...@@ -218,11 +220,11 @@ static void q40_irq_handler(unsigned int irq, struct pt_regs *fp) ...@@ -218,11 +220,11 @@ static void q40_irq_handler(unsigned int irq, struct pt_regs *fp)
switch (irq) { switch (irq) {
case 4: case 4:
case 6: case 6:
__m68k_handle_int(Q40_IRQ_SAMPLE, fp); do_IRQ(Q40_IRQ_SAMPLE, fp);
return; return;
} }
if (mir & Q40_IRQ_FRAME_MASK) { if (mir & Q40_IRQ_FRAME_MASK) {
__m68k_handle_int(Q40_IRQ_FRAME, fp); do_IRQ(Q40_IRQ_FRAME, fp);
master_outb(-1, FRAME_CLEAR_REG); master_outb(-1, FRAME_CLEAR_REG);
} }
if ((mir & Q40_IRQ_SER_MASK) || (mir & Q40_IRQ_EXT_MASK)) { if ((mir & Q40_IRQ_SER_MASK) || (mir & Q40_IRQ_EXT_MASK)) {
...@@ -257,7 +259,7 @@ static void q40_irq_handler(unsigned int irq, struct pt_regs *fp) ...@@ -257,7 +259,7 @@ static void q40_irq_handler(unsigned int irq, struct pt_regs *fp)
goto iirq; goto iirq;
} }
q40_state[irq] |= IRQ_INPROGRESS; q40_state[irq] |= IRQ_INPROGRESS;
__m68k_handle_int(irq, fp); do_IRQ(irq, fp);
q40_state[irq] &= ~IRQ_INPROGRESS; q40_state[irq] &= ~IRQ_INPROGRESS;
/* naively enable everything, if that fails than */ /* naively enable everything, if that fails than */
...@@ -288,25 +290,29 @@ static void q40_irq_handler(unsigned int irq, struct pt_regs *fp) ...@@ -288,25 +290,29 @@ static void q40_irq_handler(unsigned int irq, struct pt_regs *fp)
mir = master_inb(IIRQ_REG); mir = master_inb(IIRQ_REG);
/* should test whether keyboard irq is really enabled, doing it in defhand */ /* should test whether keyboard irq is really enabled, doing it in defhand */
if (mir & Q40_IRQ_KEYB_MASK) if (mir & Q40_IRQ_KEYB_MASK)
__m68k_handle_int(Q40_IRQ_KEYBOARD, fp); do_IRQ(Q40_IRQ_KEYBOARD, fp);
return; return;
} }
void q40_enable_irq(unsigned int irq) void q40_irq_enable(struct irq_data *data)
{ {
unsigned int irq = data->irq;
if (irq >= 5 && irq <= 15) { if (irq >= 5 && irq <= 15) {
mext_disabled--; mext_disabled--;
if (mext_disabled > 0) if (mext_disabled > 0)
printk("q40_enable_irq : nested disable/enable\n"); printk("q40_irq_enable : nested disable/enable\n");
if (mext_disabled == 0) if (mext_disabled == 0)
master_outb(1, EXT_ENABLE_REG); master_outb(1, EXT_ENABLE_REG);
} }
} }
void q40_disable_irq(unsigned int irq) void q40_irq_disable(struct irq_data *data)
{ {
unsigned int irq = data->irq;
/* disable ISA iqs : only do something if the driver has been /* disable ISA iqs : only do something if the driver has been
* verified to be Q40 "compatible" - right now IDE, NE2K * verified to be Q40 "compatible" - right now IDE, NE2K
* Any driver should not attempt to sleep across disable_irq !! * Any driver should not attempt to sleep across disable_irq !!
...@@ -319,13 +325,3 @@ void q40_disable_irq(unsigned int irq) ...@@ -319,13 +325,3 @@ void q40_disable_irq(unsigned int irq)
printk("disable_irq nesting count %d\n",mext_disabled); printk("disable_irq nesting count %d\n",mext_disabled);
} }
} }
unsigned long q40_probe_irq_on(void)
{
printk("irq probing not working - reconfigure the driver to avoid this\n");
return -1;
}
int q40_probe_irq_off(unsigned long irqs)
{
return -1;
}
...@@ -51,25 +51,29 @@ void sun3_disable_irq(unsigned int irq) ...@@ -51,25 +51,29 @@ void sun3_disable_irq(unsigned int irq)
static irqreturn_t sun3_int7(int irq, void *dev_id) static irqreturn_t sun3_int7(int irq, void *dev_id)
{ {
*sun3_intreg |= (1 << irq); unsigned int cnt;
if (!(kstat_cpu(0).irqs[irq] % 2000))
sun3_leds(led_pattern[(kstat_cpu(0).irqs[irq] % 16000) / 2000]); cnt = kstat_irqs_cpu(irq, 0);
if (!(cnt % 2000))
sun3_leds(led_pattern[cnt % 16000 / 2000]);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static irqreturn_t sun3_int5(int irq, void *dev_id) static irqreturn_t sun3_int5(int irq, void *dev_id)
{ {
unsigned int cnt;
#ifdef CONFIG_SUN3 #ifdef CONFIG_SUN3
intersil_clear(); intersil_clear();
#endif #endif
*sun3_intreg |= (1 << irq);
#ifdef CONFIG_SUN3 #ifdef CONFIG_SUN3
intersil_clear(); intersil_clear();
#endif #endif
xtime_update(1); xtime_update(1);
update_process_times(user_mode(get_irq_regs())); update_process_times(user_mode(get_irq_regs()));
if (!(kstat_cpu(0).irqs[irq] % 20)) cnt = kstat_irqs_cpu(irq, 0);
sun3_leds(led_pattern[(kstat_cpu(0).irqs[irq] % 160) / 20]); if (!(cnt % 20))
sun3_leds(led_pattern[cnt % 160 / 20]);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
...@@ -79,29 +83,33 @@ static irqreturn_t sun3_vec255(int irq, void *dev_id) ...@@ -79,29 +83,33 @@ static irqreturn_t sun3_vec255(int irq, void *dev_id)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static void sun3_inthandle(unsigned int irq, struct pt_regs *fp) static void sun3_irq_enable(struct irq_data *data)
{ {
*sun3_intreg &= ~(1 << irq); sun3_enable_irq(data->irq);
};
__m68k_handle_int(irq, fp); static void sun3_irq_disable(struct irq_data *data)
} {
sun3_disable_irq(data->irq);
};
static struct irq_controller sun3_irq_controller = { static struct irq_chip sun3_irq_chip = {
.name = "sun3", .name = "sun3",
.lock = __SPIN_LOCK_UNLOCKED(sun3_irq_controller.lock), .irq_startup = m68k_irq_startup,
.startup = m68k_irq_startup, .irq_shutdown = m68k_irq_shutdown,
.shutdown = m68k_irq_shutdown, .irq_enable = sun3_irq_enable,
.enable = sun3_enable_irq, .irq_disable = sun3_irq_disable,
.disable = sun3_disable_irq, .irq_mask = sun3_irq_disable,
.irq_unmask = sun3_irq_enable,
}; };
void __init sun3_init_IRQ(void) void __init sun3_init_IRQ(void)
{ {
*sun3_intreg = 1; *sun3_intreg = 1;
m68k_setup_auto_interrupt(sun3_inthandle); m68k_setup_irq_controller(&sun3_irq_chip, handle_level_irq, IRQ_AUTO_1,
m68k_setup_irq_controller(&sun3_irq_controller, IRQ_AUTO_1, 7); 7);
m68k_setup_user_interrupt(VEC_USER, 128, NULL); m68k_setup_user_interrupt(VEC_USER, 128);
if (request_irq(IRQ_AUTO_5, sun3_int5, 0, "int5", NULL)) if (request_irq(IRQ_AUTO_5, sun3_int5, 0, "int5", NULL))
pr_err("Couldn't register %s interrupt\n", "int5"); pr_err("Couldn't register %s interrupt\n", "int5");
......
...@@ -43,7 +43,6 @@ ...@@ -43,7 +43,6 @@
/* For SCSI -> ATAPI command conversion */ /* For SCSI -> ATAPI command conversion */
#include <scsi/scsi.h> #include <scsi/scsi.h>
#include <linux/irq.h>
#include <linux/io.h> #include <linux/io.h>
#include <asm/byteorder.h> #include <asm/byteorder.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
......
...@@ -35,7 +35,6 @@ ...@@ -35,7 +35,6 @@
#include <scsi/scsi_ioctl.h> #include <scsi/scsi_ioctl.h>
#include <asm/byteorder.h> #include <asm/byteorder.h>
#include <linux/irq.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
#include <linux/io.h> #include <linux/io.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
......
...@@ -41,7 +41,6 @@ ...@@ -41,7 +41,6 @@
#include <scsi/scsi.h> #include <scsi/scsi.h>
#include <asm/byteorder.h> #include <asm/byteorder.h>
#include <linux/irq.h>
#include <linux/uaccess.h> #include <linux/uaccess.h>
#include <linux/io.h> #include <linux/io.h>
#include <asm/unaligned.h> #include <asm/unaligned.h>
......
...@@ -159,7 +159,7 @@ int macii_init(void) ...@@ -159,7 +159,7 @@ int macii_init(void)
err = macii_init_via(); err = macii_init_via();
if (err) goto out; if (err) goto out;
err = request_irq(IRQ_MAC_ADB, macii_interrupt, IRQ_FLG_LOCK, "ADB", err = request_irq(IRQ_MAC_ADB, macii_interrupt, 0, "ADB",
macii_interrupt); macii_interrupt);
if (err) goto out; if (err) goto out;
......
...@@ -122,8 +122,8 @@ maciisi_init(void) ...@@ -122,8 +122,8 @@ maciisi_init(void)
return err; return err;
} }
if (request_irq(IRQ_MAC_ADB, maciisi_interrupt, IRQ_FLG_LOCK | IRQ_FLG_FAST, if (request_irq(IRQ_MAC_ADB, maciisi_interrupt, 0, "ADB",
"ADB", maciisi_interrupt)) { maciisi_interrupt)) {
printk(KERN_ERR "maciisi_init: can't get irq %d\n", IRQ_MAC_ADB); printk(KERN_ERR "maciisi_init: can't get irq %d\n", IRQ_MAC_ADB);
return -EAGAIN; return -EAGAIN;
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment