336 lines
9.3 KiB
C
336 lines
9.3 KiB
C
/*
|
|
* linux/arch/$(ARCH)/platform/$(PLATFORM)/ints.c
|
|
*
|
|
* 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
|
|
* for more details.
|
|
*
|
|
* Copyright (c) 2000 Michael Leslie <mleslie@lineo.com>
|
|
* Copyright (c) 1996 Roman Zippel
|
|
* Copyright (c) 1999 D. Jeff Dionne <jeff@uclinux.org>
|
|
*/
|
|
|
|
#include <linux/config.h>
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/kernel_stat.h>
|
|
#include <linux/errno.h>
|
|
|
|
#include <asm/system.h>
|
|
#include <asm/irq.h>
|
|
#include <asm/traps.h>
|
|
#include <asm/io.h>
|
|
#include <asm/machdep.h>
|
|
#include <asm/setup.h>
|
|
#include <asm/m68360.h>
|
|
|
|
/* from quicc/commproc.c: */
|
|
extern QUICC *pquicc;
|
|
extern void cpm_interrupt_init(void);
|
|
|
|
#define INTERNAL_IRQS (96)
|
|
|
|
/* assembler routines */
|
|
asmlinkage void system_call(void);
|
|
asmlinkage void buserr(void);
|
|
asmlinkage void trap(void);
|
|
asmlinkage irqreturn_t bad_interrupt(void);
|
|
asmlinkage irqreturn_t inthandler(void);
|
|
|
|
extern void *_ramvec[];
|
|
|
|
/* The number of spurious interrupts */
|
|
volatile unsigned int num_spurious;
|
|
unsigned int local_irq_count[NR_CPUS];
|
|
|
|
/* irq node variables for the 32 (potential) on chip sources */
|
|
static irq_node_t int_irq_list[INTERNAL_IRQS];
|
|
|
|
static short int_irq_ablecount[INTERNAL_IRQS];
|
|
|
|
/*
|
|
* This function should be called during kernel startup to initialize
|
|
* IRQ handling routines.
|
|
*/
|
|
|
|
void init_IRQ(void)
|
|
{
|
|
int i;
|
|
int vba = (CPM_VECTOR_BASE<<4);
|
|
|
|
/* set up the vectors */
|
|
_ramvec[2] = buserr;
|
|
_ramvec[3] = trap;
|
|
_ramvec[4] = trap;
|
|
_ramvec[5] = trap;
|
|
_ramvec[6] = trap;
|
|
_ramvec[7] = trap;
|
|
_ramvec[8] = trap;
|
|
_ramvec[9] = trap;
|
|
_ramvec[10] = trap;
|
|
_ramvec[11] = trap;
|
|
_ramvec[12] = trap;
|
|
_ramvec[13] = trap;
|
|
_ramvec[14] = trap;
|
|
_ramvec[15] = trap;
|
|
|
|
_ramvec[32] = system_call;
|
|
_ramvec[33] = trap;
|
|
|
|
|
|
cpm_interrupt_init();
|
|
|
|
/* set up CICR for vector base address and irq level */
|
|
/* irl = 4, hp = 1f - see MC68360UM p 7-377 */
|
|
pquicc->intr_cicr = 0x00e49f00 | vba;
|
|
|
|
/* CPM interrupt vectors: (p 7-376) */
|
|
_ramvec[vba+CPMVEC_ERROR] = bad_interrupt; /* Error */
|
|
_ramvec[vba+CPMVEC_PIO_PC11] = inthandler; /* pio - pc11 */
|
|
_ramvec[vba+CPMVEC_PIO_PC10] = inthandler; /* pio - pc10 */
|
|
_ramvec[vba+CPMVEC_SMC2] = inthandler; /* smc2/pip */
|
|
_ramvec[vba+CPMVEC_SMC1] = inthandler; /* smc1 */
|
|
_ramvec[vba+CPMVEC_SPI] = inthandler; /* spi */
|
|
_ramvec[vba+CPMVEC_PIO_PC9] = inthandler; /* pio - pc9 */
|
|
_ramvec[vba+CPMVEC_TIMER4] = inthandler; /* timer 4 */
|
|
_ramvec[vba+CPMVEC_RESERVED1] = inthandler; /* reserved */
|
|
_ramvec[vba+CPMVEC_PIO_PC8] = inthandler; /* pio - pc8 */
|
|
_ramvec[vba+CPMVEC_PIO_PC7] = inthandler; /* pio - pc7 */
|
|
_ramvec[vba+CPMVEC_PIO_PC6] = inthandler; /* pio - pc6 */
|
|
_ramvec[vba+CPMVEC_TIMER3] = inthandler; /* timer 3 */
|
|
_ramvec[vba+CPMVEC_RISCTIMER] = inthandler; /* reserved */
|
|
_ramvec[vba+CPMVEC_PIO_PC5] = inthandler; /* pio - pc5 */
|
|
_ramvec[vba+CPMVEC_PIO_PC4] = inthandler; /* pio - pc4 */
|
|
_ramvec[vba+CPMVEC_RESERVED2] = inthandler; /* reserved */
|
|
_ramvec[vba+CPMVEC_RISCTIMER] = inthandler; /* timer table */
|
|
_ramvec[vba+CPMVEC_TIMER2] = inthandler; /* timer 2 */
|
|
_ramvec[vba+CPMVEC_RESERVED3] = inthandler; /* reserved */
|
|
_ramvec[vba+CPMVEC_IDMA2] = inthandler; /* idma 2 */
|
|
_ramvec[vba+CPMVEC_IDMA1] = inthandler; /* idma 1 */
|
|
_ramvec[vba+CPMVEC_SDMA_CB_ERR] = inthandler; /* sdma channel bus error */
|
|
_ramvec[vba+CPMVEC_PIO_PC3] = inthandler; /* pio - pc3 */
|
|
_ramvec[vba+CPMVEC_PIO_PC2] = inthandler; /* pio - pc2 */
|
|
/* _ramvec[vba+CPMVEC_TIMER1] = cpm_isr_timer1; */ /* timer 1 */
|
|
_ramvec[vba+CPMVEC_TIMER1] = inthandler; /* timer 1 */
|
|
_ramvec[vba+CPMVEC_PIO_PC1] = inthandler; /* pio - pc1 */
|
|
_ramvec[vba+CPMVEC_SCC4] = inthandler; /* scc 4 */
|
|
_ramvec[vba+CPMVEC_SCC3] = inthandler; /* scc 3 */
|
|
_ramvec[vba+CPMVEC_SCC2] = inthandler; /* scc 2 */
|
|
_ramvec[vba+CPMVEC_SCC1] = inthandler; /* scc 1 */
|
|
_ramvec[vba+CPMVEC_PIO_PC0] = inthandler; /* pio - pc0 */
|
|
|
|
|
|
/* turn off all CPM interrupts */
|
|
pquicc->intr_cimr = 0x00000000;
|
|
|
|
/* initialize handlers */
|
|
for (i = 0; i < INTERNAL_IRQS; i++) {
|
|
int_irq_list[i].handler = NULL;
|
|
int_irq_list[i].flags = IRQ_FLG_STD;
|
|
int_irq_list[i].dev_id = NULL;
|
|
int_irq_list[i].devname = NULL;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
void M68360_insert_irq(irq_node_t **list, irq_node_t *node)
|
|
{
|
|
unsigned long flags;
|
|
irq_node_t *cur;
|
|
|
|
if (!node->dev_id)
|
|
printk(KERN_INFO "%s: Warning: dev_id of %s is zero\n",
|
|
__FUNCTION__, node->devname);
|
|
|
|
local_irq_save(flags);
|
|
|
|
cur = *list;
|
|
|
|
while (cur) {
|
|
list = &cur->next;
|
|
cur = cur->next;
|
|
}
|
|
|
|
node->next = cur;
|
|
*list = node;
|
|
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
void M68360_delete_irq(irq_node_t **list, void *dev_id)
|
|
{
|
|
unsigned long flags;
|
|
irq_node_t *node;
|
|
|
|
local_irq_save(flags);
|
|
|
|
for (node = *list; node; list = &node->next, node = *list) {
|
|
if (node->dev_id == dev_id) {
|
|
*list = node->next;
|
|
/* Mark it as free. */
|
|
node->handler = NULL;
|
|
local_irq_restore(flags);
|
|
return;
|
|
}
|
|
}
|
|
local_irq_restore(flags);
|
|
printk (KERN_INFO "%s: tried to remove invalid irq\n", __FUNCTION__);
|
|
}
|
|
#endif
|
|
|
|
int request_irq(
|
|
unsigned int irq,
|
|
irqreturn_t (*handler)(int, void *, struct pt_regs *),
|
|
unsigned long flags,
|
|
const char *devname,
|
|
void *dev_id)
|
|
{
|
|
int mask = (1<<irq);
|
|
|
|
irq += (CPM_VECTOR_BASE<<4);
|
|
|
|
if (irq >= INTERNAL_IRQS) {
|
|
printk (KERN_ERR "%s: Unknown IRQ %d from %s\n", __FUNCTION__, irq, devname);
|
|
return -ENXIO;
|
|
}
|
|
|
|
if (!(int_irq_list[irq].flags & IRQ_FLG_STD)) {
|
|
if (int_irq_list[irq].flags & IRQ_FLG_LOCK) {
|
|
printk(KERN_ERR "%s: IRQ %d from %s is not replaceable\n",
|
|
__FUNCTION__, irq, int_irq_list[irq].devname);
|
|
return -EBUSY;
|
|
}
|
|
if (flags & IRQ_FLG_REPLACE) {
|
|
printk(KERN_ERR "%s: %s can't replace IRQ %d from %s\n",
|
|
__FUNCTION__, devname, irq, int_irq_list[irq].devname);
|
|
return -EBUSY;
|
|
}
|
|
}
|
|
int_irq_list[irq].handler = handler;
|
|
int_irq_list[irq].flags = flags;
|
|
int_irq_list[irq].dev_id = dev_id;
|
|
int_irq_list[irq].devname = devname;
|
|
|
|
/* enable in the CIMR */
|
|
if (!int_irq_ablecount[irq])
|
|
pquicc->intr_cimr |= mask;
|
|
/* *(volatile unsigned long *)0xfffff304 &= ~(1<<irq); */
|
|
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL(request_irq);
|
|
|
|
void free_irq(unsigned int irq, void *dev_id)
|
|
{
|
|
if (irq >= INTERNAL_IRQS) {
|
|
printk (KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
|
|
return;
|
|
}
|
|
|
|
if (int_irq_list[irq].dev_id != dev_id)
|
|
printk(KERN_INFO "%s: removing probably wrong IRQ %d from %s\n",
|
|
__FUNCTION__, irq, int_irq_list[irq].devname);
|
|
int_irq_list[irq].handler = NULL;
|
|
int_irq_list[irq].flags = IRQ_FLG_STD;
|
|
int_irq_list[irq].dev_id = NULL;
|
|
int_irq_list[irq].devname = NULL;
|
|
|
|
*(volatile unsigned long *)0xfffff304 |= 1<<irq;
|
|
}
|
|
|
|
EXPORT_SYMBOL(free_irq);
|
|
|
|
#if 0
|
|
/*
|
|
* Enable/disable a particular machine specific interrupt source.
|
|
* Note that this may affect other interrupts in case of a shared interrupt.
|
|
* This function should only be called for a _very_ short time to change some
|
|
* internal data, that may not be changed by the interrupt at the same time.
|
|
* int_(enable|disable)_irq calls may also be nested.
|
|
*/
|
|
void M68360_enable_irq(unsigned int irq)
|
|
{
|
|
if (irq >= INTERNAL_IRQS) {
|
|
printk(KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
|
|
return;
|
|
}
|
|
|
|
if (--int_irq_ablecount[irq])
|
|
return;
|
|
|
|
/* enable the interrupt */
|
|
*(volatile unsigned long *)0xfffff304 &= ~(1<<irq);
|
|
}
|
|
|
|
void M68360_disable_irq(unsigned int irq)
|
|
{
|
|
if (irq >= INTERNAL_IRQS) {
|
|
printk(KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
|
|
return;
|
|
}
|
|
|
|
if (int_irq_ablecount[irq]++)
|
|
return;
|
|
|
|
/* disable the interrupt */
|
|
*(volatile unsigned long *)0xfffff304 |= 1<<irq;
|
|
}
|
|
#endif
|
|
|
|
int show_interrupts(struct seq_file *p, void *v)
|
|
{
|
|
int i = *(loff_t *) v;
|
|
|
|
if (i < NR_IRQS) {
|
|
if (int_irq_list[i].devname) {
|
|
seq_printf(p, "%3d: %10u ", i, kstat_cpu(0).irqs[i]);
|
|
if (int_irq_list[i].flags & IRQ_FLG_LOCK)
|
|
seq_printf(p, "L ");
|
|
else
|
|
seq_printf(p, " ");
|
|
seq_printf(p, "%s\n", int_irq_list[i].devname);
|
|
}
|
|
}
|
|
if (i == NR_IRQS)
|
|
seq_printf(p, " : %10u spurious\n", num_spurious);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* The 68k family did not have a good way to determine the source
|
|
* of interrupts until later in the family. The EC000 core does
|
|
* not provide the vector number on the stack, we vector everything
|
|
* into one vector and look in the blasted mask register...
|
|
* This code is designed to be fast, almost constant time, not clean!
|
|
*/
|
|
void process_int(int vec, struct pt_regs *fp)
|
|
{
|
|
int irq;
|
|
int mask;
|
|
|
|
/* unsigned long pend = *(volatile unsigned long *)0xfffff30c; */
|
|
|
|
/* irq = vec + (CPM_VECTOR_BASE<<4); */
|
|
irq = vec;
|
|
|
|
/* unsigned long pend = *(volatile unsigned long *)pquicc->intr_cipr; */
|
|
|
|
/* Bugger all that weirdness. For the moment, I seem to know where I came from;
|
|
* vec is passed from a specific ISR, so I'll use it. */
|
|
|
|
if (int_irq_list[irq].handler) {
|
|
int_irq_list[irq].handler(irq , int_irq_list[irq].dev_id, fp);
|
|
kstat_cpu(0).irqs[irq]++;
|
|
pquicc->intr_cisr = (1 << vec); /* indicate that irq has been serviced */
|
|
} else {
|
|
printk(KERN_ERR "unregistered interrupt %d!\nTurning it off in the CIMR...\n", irq);
|
|
/* *(volatile unsigned long *)0xfffff304 |= mask; */
|
|
pquicc->intr_cimr &= ~(1 << vec);
|
|
num_spurious += 1;
|
|
}
|
|
return(IRQ_HANDLED);
|
|
}
|