Commit d890d739 authored by Geert Uytterhoeven's avatar Geert Uytterhoeven

m68k/irq: Remove obsolete m68k irq framework

Signed-off-by: default avatarGeert Uytterhoeven <geert@linux-m68k.org>
parent a03010ed
......@@ -4,8 +4,8 @@ config M68K
select HAVE_IDE
select HAVE_AOUT if MMU
select GENERIC_ATOMIC64 if MMU
select HAVE_GENERIC_HARDIRQS if !MMU
select GENERIC_IRQ_SHOW if !MMU
select HAVE_GENERIC_HARDIRQS
select GENERIC_IRQ_SHOW
select ARCH_HAVE_NMI_SAFE_CMPXCHG if RMW_INSNS
config RWSEM_GENERIC_SPINLOCK
......@@ -84,12 +84,6 @@ config MMU_SUN3
bool
depends on MMU && !MMU_MOTOROLA
config USE_GENERIC_HARDIRQS
bool "Use genirq"
depends on MMU
select HAVE_GENERIC_HARDIRQS
select GENERIC_IRQ_SHOW
menu "Platform setup"
source arch/m68k/Kconfig.cpu
......
......@@ -9,9 +9,7 @@
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#ifdef CONFIG_GENERIC_HARDIRQS
#include <linux/irq.h>
#endif
#include <asm/irq.h>
#include <asm/traps.h>
......@@ -48,7 +46,6 @@ static struct irq_chip amiga_irq_chip = {
* The builtin Amiga hardware interrupt handlers.
*/
#ifdef CONFIG_GENERIC_HARDIRQS
static void ami_int1(unsigned int irq, struct irq_desc *desc)
{
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
......@@ -140,103 +137,6 @@ static void ami_int5(unsigned int irq, struct irq_desc *desc)
generic_handle_irq(IRQ_AMIGA_DSKSYN);
}
}
#else /* !CONFIG_GENERIC_HARDIRQS */
static irqreturn_t ami_int1(int irq, void *dev_id)
{
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
/* if serial transmit buffer empty, interrupt */
if (ints & IF_TBE) {
amiga_custom.intreq = IF_TBE;
generic_handle_irq(IRQ_AMIGA_TBE);
}
/* if floppy disk transfer complete, interrupt */
if (ints & IF_DSKBLK) {
amiga_custom.intreq = IF_DSKBLK;
generic_handle_irq(IRQ_AMIGA_DSKBLK);
}
/* if software interrupt set, interrupt */
if (ints & IF_SOFT) {
amiga_custom.intreq = IF_SOFT;
generic_handle_irq(IRQ_AMIGA_SOFT);
}
return IRQ_HANDLED;
}
static irqreturn_t ami_int3(int irq, void *dev_id)
{
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
/* if a blitter interrupt */
if (ints & IF_BLIT) {
amiga_custom.intreq = IF_BLIT;
generic_handle_irq(IRQ_AMIGA_BLIT);
}
/* if a copper interrupt */
if (ints & IF_COPER) {
amiga_custom.intreq = IF_COPER;
generic_handle_irq(IRQ_AMIGA_COPPER);
}
/* if a vertical blank interrupt */
if (ints & IF_VERTB) {
amiga_custom.intreq = IF_VERTB;
generic_handle_irq(IRQ_AMIGA_VERTB);
}
return IRQ_HANDLED;
}
static irqreturn_t ami_int4(int irq, void *dev_id)
{
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
/* if audio 0 interrupt */
if (ints & IF_AUD0) {
amiga_custom.intreq = IF_AUD0;
generic_handle_irq(IRQ_AMIGA_AUD0);
}
/* if audio 1 interrupt */
if (ints & IF_AUD1) {
amiga_custom.intreq = IF_AUD1;
generic_handle_irq(IRQ_AMIGA_AUD1);
}
/* if audio 2 interrupt */
if (ints & IF_AUD2) {
amiga_custom.intreq = IF_AUD2;
generic_handle_irq(IRQ_AMIGA_AUD2);
}
/* if audio 3 interrupt */
if (ints & IF_AUD3) {
amiga_custom.intreq = IF_AUD3;
generic_handle_irq(IRQ_AMIGA_AUD3);
}
return IRQ_HANDLED;
}
static irqreturn_t ami_int5(int irq, void *dev_id)
{
unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
/* if serial receive buffer full interrupt */
if (ints & IF_RBF) {
/* acknowledge of IF_RBF must be done by the serial interrupt */
generic_handle_irq(IRQ_AMIGA_RBF);
}
/* if a disk sync interrupt */
if (ints & IF_DSKSYN) {
amiga_custom.intreq = IF_DSKSYN;
generic_handle_irq(IRQ_AMIGA_DSKSYN);
}
return IRQ_HANDLED;
}
#endif /* !CONFIG_GENERIC_HARDIRQS */
/*
......@@ -252,7 +152,6 @@ static irqreturn_t ami_int5(int irq, void *dev_id)
void __init amiga_init_IRQ(void)
{
#ifdef CONFIG_GENERIC_HARDIRQS
m68k_setup_irq_controller(&amiga_irq_chip, handle_simple_irq, IRQ_USER,
AMI_STD_IRQS);
......@@ -260,19 +159,6 @@ void __init amiga_init_IRQ(void)
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);
#else /* !CONFIG_GENERIC_HARDIRQS */
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_chip, handle_simple_irq, IRQ_USER,
AMI_STD_IRQS);
#endif /* !CONFIG_GENERIC_HARDIRQS */
/* turn off PCMCIA interrupts */
if (AMIGAHW_PRESENT(PCMCIA))
......
#include <linux/interrupt.h>
#ifdef CONFIG_GENERIC_HARDIRQS
#include <linux/irq.h>
#else
#include <asm/irq.h>
#endif
#include <asm/traps.h>
#include <asm/apollohw.h>
#ifndef CONFIG_GENERIC_HARDIRQS
void dn_process_int(unsigned int irq, struct pt_regs *fp)
{
do_IRQ(irq, fp);
*(volatile unsigned char *)(pica)=0x20;
*(volatile unsigned char *)(picb)=0x20;
}
#endif
unsigned int apollo_irq_startup(struct irq_data *data)
{
unsigned int irq = data->irq;
......@@ -39,31 +25,23 @@ void apollo_irq_shutdown(struct irq_data *data)
*(volatile unsigned char *)(picb+1) |= (1 << (irq - 8));
}
#ifdef CONFIG_GENERIC_HARDIRQS
void apollo_irq_eoi(struct irq_data *data)
{
*(volatile unsigned char *)(pica) = 0x20;
*(volatile unsigned char *)(picb) = 0x20;
}
#endif
static struct irq_chip apollo_irq_chip = {
.name = "apollo",
.irq_startup = apollo_irq_startup,
.irq_shutdown = apollo_irq_shutdown,
#ifdef CONFIG_GENERIC_HARDIRQS
.irq_eoi = apollo_irq_eoi,
#endif
};
void __init dn_init_IRQ(void)
{
#ifdef CONFIG_GENERIC_HARDIRQS
m68k_setup_user_interrupt(VEC_USER + 96, 16, NULL);
#else
m68k_setup_user_interrupt(VEC_USER + 96, 16, dn_process_int);
#endif
m68k_setup_irq_controller(&apollo_irq_chip, handle_fasteoi_irq,
IRQ_APOLLO, 16);
}
......@@ -62,67 +62,6 @@
#define IRQ_FLG_STD (0x8000) /* internally used */
#endif
#ifndef CONFIG_GENERIC_HARDIRQS
#include <linux/linkage.h>
#include <linux/hardirq.h>
#include <linux/irqreturn.h>
#include <linux/spinlock_types.h>
struct pt_regs;
/*
* This structure is used to chain together the ISRs for a particular
* interrupt source (if it supports chaining).
*/
struct irq_data {
unsigned int irq;
irqreturn_t (*handler)(int, void *);
void *dev_id;
struct irq_data *next;
unsigned long flags;
const char *devname;
};
/*
* 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_chip {
const char *name;
unsigned int (*irq_startup)(struct irq_data *data);
void (*irq_shutdown)(struct irq_data *data);
void (*irq_enable)(struct irq_data *data);
void (*irq_disable)(struct irq_data *data);
};
extern unsigned int m68k_irq_startup(struct irq_data *data);
extern unsigned int m68k_irq_startup_irq(unsigned int irq);
extern void m68k_irq_shutdown(struct irq_data *data);
/*
* This function returns a new struct irq_data
*/
extern struct irq_data *new_irq_node(void);
extern void m68k_setup_auto_interrupt(void (*handler)(unsigned int, struct pt_regs *));
extern void m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt,
void (*handler)(unsigned int, struct pt_regs *));
extern void m68k_setup_irq_chip(struct irq_chip *, unsigned int, unsigned int);
#define m68k_setup_irq_controller(chip, dummy, irq, cnt) \
m68k_setup_irq_chip((chip), (irq), (cnt))
extern void generic_handle_irq(unsigned int);
asmlinkage void do_IRQ(int irq, struct pt_regs *regs);
#else /* CONFIG_GENERIC_HARDIRQS */
struct irq_data;
struct irq_chip;
struct irq_desc;
......@@ -139,8 +78,6 @@ extern void m68k_setup_irq_controller(struct irq_chip *,
struct irq_desc *desc),
unsigned int irq, unsigned int cnt);
#endif /* CONFIG_GENERIC_HARDIRQS */
extern unsigned int irq_canonicalize(unsigned int irq);
#else
......
......@@ -24,8 +24,3 @@
#define Q40_IRQ10_MASK (1<<5)
#define Q40_IRQ14_MASK (1<<6)
#define Q40_IRQ15_MASK (1<<7)
#ifndef CONFIG_GENERIC_HARDIRQS
extern unsigned long q40_probe_irq_on (void);
extern int q40_probe_irq_off (unsigned long irqs);
#endif
......@@ -6,11 +6,10 @@ extra-$(CONFIG_MMU) := head.o
extra-$(CONFIG_SUN3) := sun3-head.o
extra-y += vmlinux.lds
obj-y := entry.o m68k_ksyms.o module.o process.o ptrace.o setup.o signal.o \
sys_m68k.o syscalltable.o time.o traps.o
obj-y := entry.o irq.o m68k_ksyms.o module.o process.o ptrace.o setup.o \
signal.o sys_m68k.o syscalltable.o time.o traps.o
obj-$(CONFIG_MMU) += ints.o vectors.o
devres-$(CONFIG_MMU) = ../../../kernel/irq/devres.o
ifndef CONFIG_MMU_SUN3
obj-y += dma.o
......@@ -18,9 +17,4 @@ endif
ifndef CONFIG_MMU
obj-y += init_task.o
endif
ifdef CONFIG_GENERIC_HARDIRQS
obj-y += irq.o
else
obj-y += devres.o
endif
......@@ -31,20 +31,6 @@ extern u32 auto_irqhandler_fixup[];
extern u32 user_irqhandler_fixup[];
extern u16 user_irqvec_fixup[];
#ifndef CONFIG_GENERIC_HARDIRQS
/* table for system interrupt handlers */
static struct irq_data *irq_list[NR_IRQS];
static struct irq_chip *irq_chip[NR_IRQS];
static int irq_depth[NR_IRQS];
static inline int irq_set_chip(unsigned int irq, struct irq_chip *chip)
{
irq_chip[irq] = chip;
return 0;
}
#define irq_set_chip_and_handler(irq, chip, dummy) irq_set_chip(irq, chip)
#endif /* !CONFIG_GENERIC_HARDIRQS */
static int m68k_first_user_vec;
static struct irq_chip auto_irq_chip = {
......@@ -59,11 +45,6 @@ static struct irq_chip user_irq_chip = {
.irq_shutdown = m68k_irq_shutdown,
};
#ifndef CONFIG_GENERIC_HARDIRQS
#define NUM_IRQ_NODES 100
static struct irq_data nodes[NUM_IRQ_NODES];
#endif /* !CONFIG_GENERIC_HARDIRQS */
/*
* void init_IRQ(void)
*
......@@ -133,8 +114,6 @@ void __init m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt,
flush_icache();
}
#ifdef CONFIG_GENERIC_HARDIRQS
/**
* m68k_setup_irq_controller
* @chip: irq chip which controls specified irq
......@@ -160,198 +139,6 @@ void m68k_setup_irq_controller(struct irq_chip *chip,
}
}
#else /* !CONFIG_GENERIC_HARDIRQS */
/**
* m68k_setup_irq_chip
* @contr: irq controller which controls specified irq
* @irq: first irq to be managed by the controller
*
* Change the controller for the specified range of irq, which will be used to
* manage these irq. auto/user irq already have a default controller, which can
* be changed as well, but the controller probably should use m68k_irq_startup/
* m68k_irq_shutdown.
*/
void m68k_setup_irq_chip(struct irq_chip *contr, unsigned int irq,
unsigned int cnt)
{
int i;
for (i = 0; i < cnt; i++)
irq_set_chip(irq + i, contr);
}
struct irq_data *new_irq_node(void)
{
struct irq_data *node;
short i;
for (node = nodes, i = NUM_IRQ_NODES-1; i >= 0; node++, i--) {
if (!node->handler) {
memset(node, 0, sizeof(*node));
return node;
}
}
printk ("new_irq_node: out of nodes\n");
return NULL;
}
static int m68k_setup_irq(unsigned int irq, struct irq_data *node)
{
struct irq_chip *contr;
struct irq_data **prev;
unsigned long flags;
if (irq >= NR_IRQS || !(contr = irq_chip[irq])) {
printk("%s: Incorrect IRQ %d from %s\n",
__func__, irq, node->devname);
return -ENXIO;
}
local_irq_save(flags);
prev = irq_list + irq;
if (*prev) {
/* Can't share interrupts unless both agree to */
if (!((*prev)->flags & node->flags & IRQF_SHARED)) {
local_irq_restore(flags);
return -EBUSY;
}
while (*prev)
prev = &(*prev)->next;
}
if (!irq_list[irq]) {
if (contr->irq_startup)
contr->irq_startup(node);
else
contr->irq_enable(node);
}
node->next = NULL;
*prev = node;
local_irq_restore(flags);
return 0;
}
int request_irq(unsigned int irq,
irq_handler_t handler,
unsigned long flags, const char *devname, void *dev_id)
{
struct irq_data *node;
int res;
node = new_irq_node();
if (!node)
return -ENOMEM;
node->irq = irq;
node->handler = handler;
node->flags = flags;
node->dev_id = dev_id;
node->devname = devname;
res = m68k_setup_irq(irq, node);
if (res)
node->handler = NULL;
return res;
}
EXPORT_SYMBOL(request_irq);
void free_irq(unsigned int irq, void *dev_id)
{
struct irq_chip *contr;
struct irq_data **p, *node;
unsigned long flags;
if (irq >= NR_IRQS || !(contr = irq_chip[irq])) {
printk("%s: Incorrect IRQ %d\n", __func__, irq);
return;
}
local_irq_save(flags);
p = irq_list + irq;
while ((node = *p)) {
if (node->dev_id == dev_id)
break;
p = &node->next;
}
if (node) {
*p = node->next;
node->handler = NULL;
} else
printk("%s: Removing probably wrong IRQ %d\n",
__func__, irq);
if (!irq_list[irq]) {
if (contr->irq_shutdown)
contr->irq_shutdown(node);
else
contr->irq_disable(node);
}
local_irq_restore(flags);
}
EXPORT_SYMBOL(free_irq);
void enable_irq(unsigned int irq)
{
struct irq_chip *contr;
unsigned long flags;
if (irq >= NR_IRQS || !(contr = irq_chip[irq])) {
printk("%s: Incorrect IRQ %d\n",
__func__, irq);
return;
}
local_irq_save(flags);
if (irq_depth[irq]) {
if (!--irq_depth[irq]) {
if (contr->irq_enable)
contr->irq_enable(irq_list[irq]);
}
} else
WARN_ON(1);
local_irq_restore(flags);
}
EXPORT_SYMBOL(enable_irq);
void disable_irq(unsigned int irq)
{
struct irq_chip *contr;
unsigned long flags;
if (irq >= NR_IRQS || !(contr = irq_chip[irq])) {
printk("%s: Incorrect IRQ %d\n",
__func__, irq);
return;
}
local_irq_save(flags);
if (!irq_depth[irq]++) {
if (contr->irq_disable)
contr->irq_disable(irq_list[irq]);
}
local_irq_restore(flags);
}
EXPORT_SYMBOL(disable_irq);
void disable_irq_nosync(unsigned int irq) __attribute__((alias("disable_irq")));
EXPORT_SYMBOL(disable_irq_nosync);
#endif /* !CONFIG_GENERIC_HARDIRQS */
unsigned int m68k_irq_startup_irq(unsigned int irq)
{
if (irq <= IRQ_AUTO_7)
......@@ -377,36 +164,6 @@ void m68k_irq_shutdown(struct irq_data *data)
}
#ifndef CONFIG_GENERIC_HARDIRQS
/*
* Do we need these probe functions on the m68k?
*
* ... may be useful with ISA devices
*/
unsigned long probe_irq_on (void)
{
#ifdef CONFIG_Q40
if (MACH_IS_Q40)
return q40_probe_irq_on();
#endif
return 0;
}
EXPORT_SYMBOL(probe_irq_on);
int probe_irq_off (unsigned long irqs)
{
#ifdef CONFIG_Q40
if (MACH_IS_Q40)
return q40_probe_irq_off(irqs);
#endif
return 0;
}
EXPORT_SYMBOL(probe_irq_off);
#endif /* CONFIG_GENERIC_HARDIRQS */
unsigned int irq_canonicalize(unsigned int irq)
{
#ifdef CONFIG_Q40
......@@ -418,63 +175,9 @@ unsigned int irq_canonicalize(unsigned int irq)
EXPORT_SYMBOL(irq_canonicalize);
#ifndef CONFIG_GENERIC_HARDIRQS
void generic_handle_irq(unsigned int irq)
{
struct irq_data *node;
kstat_cpu(0).irqs[irq]++;
node = irq_list[irq];
do {
node->handler(irq, node->dev_id);
node = node->next;
} while (node);
}