arch/m68knommu/platform/68360/ints.c

   1 /*
   2  * linux/arch/$(ARCH)/platform/$(PLATFORM)/ints.c
   3  *
   4  * This file is subject to the terms and conditions of the GNU General Public
   5  * License.  See the file COPYING in the main directory of this archive
   6  * for more details.
   7  *
   8  * Copyright (c) 2000  Michael Leslie <mleslie@lineo.com>
   9  * Copyright (c) 1996 Roman Zippel
  10  * Copyright (c) 1999 D. Jeff Dionne <jeff@uclinux.org>
  11  */
  12
  13 #include <linux/config.h>
  14 #include <linux/module.h>
  15 #include <linux/types.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sched.h>
  18 #include <linux/kernel_stat.h>
  19 #include <linux/errno.h>
  20
  21 #include <asm/system.h>
  22 #include <asm/irq.h>
  23 #include <asm/traps.h>
  24 #include <asm/io.h>
  25 #include <asm/machdep.h>
  26 #include <asm/setup.h>
  27 #include <asm/m68360.h>
  28
  29 /* from quicc/commproc.c: */
  30 extern QUICC *pquicc;
  31 extern void cpm_interrupt_init(void);
  32
  33 #define INTERNAL_IRQS (96)
  34
  35 /* assembler routines */
  36 asmlinkage void system_call(void);
  37 asmlinkage void buserr(void);
  38 asmlinkage void trap(void);
  39 asmlinkage irqreturn_t bad_interrupt(void);
  40 asmlinkage irqreturn_t inthandler(void);
  41
  42 extern void *_ramvec[];
  43
  44 /* The number of spurious interrupts */
  45 volatile unsigned int num_spurious;
  46 unsigned int local_irq_count[NR_CPUS];
  47
  48 /* irq node variables for the 32 (potential) on chip sources */
  49 static irq_node_t int_irq_list[INTERNAL_IRQS];
  50
  51 static short int_irq_ablecount[INTERNAL_IRQS];
  52
  53 /*
  54  * This function should be called during kernel startup to initialize
  55  * IRQ handling routines.
  56  */
  57
  58 void init_IRQ(void)
  59 {
  60         int i;
  61         int vba = (CPM_VECTOR_BASE<<4);
  62
  63         /* set up the vectors */
  64         _ramvec[2] = buserr;
  65         _ramvec[3] = trap;
  66         _ramvec[4] = trap;
  67         _ramvec[5] = trap;
  68         _ramvec[6] = trap;
  69         _ramvec[7] = trap;
  70         _ramvec[8] = trap;
  71         _ramvec[9] = trap;
  72         _ramvec[10] = trap;
  73         _ramvec[11] = trap;
  74         _ramvec[12] = trap;
  75         _ramvec[13] = trap;
  76         _ramvec[14] = trap;
  77         _ramvec[15] = trap;
  78
  79         _ramvec[32] = system_call;
  80         _ramvec[33] = trap;
  81
  82
  83         cpm_interrupt_init();
  84
  85         /* set up CICR for vector base address and irq level */
  86         /* irl = 4, hp = 1f - see MC68360UM p 7-377 */
  87         pquicc->intr_cicr = 0x00e49f00 | vba;
  88
  89         /* CPM interrupt vectors: (p 7-376) */
  90         _ramvec[vba+CPMVEC_ERROR]       = bad_interrupt; /* Error */
  91         _ramvec[vba+CPMVEC_PIO_PC11]    = inthandler;   /* pio - pc11 */
  92         _ramvec[vba+CPMVEC_PIO_PC10]    = inthandler;   /* pio - pc10 */
  93         _ramvec[vba+CPMVEC_SMC2]        = inthandler;   /* smc2/pip */
  94         _ramvec[vba+CPMVEC_SMC1]        = inthandler;   /* smc1 */
  95         _ramvec[vba+CPMVEC_SPI]         = inthandler;   /* spi */
  96         _ramvec[vba+CPMVEC_PIO_PC9]     = inthandler;   /* pio - pc9 */
  97         _ramvec[vba+CPMVEC_TIMER4]      = inthandler;   /* timer 4 */
  98         _ramvec[vba+CPMVEC_RESERVED1]   = inthandler;   /* reserved */
  99         _ramvec[vba+CPMVEC_PIO_PC8]     = inthandler;   /* pio - pc8 */
 100         _ramvec[vba+CPMVEC_PIO_PC7]     = inthandler;  /* pio - pc7 */
 101         _ramvec[vba+CPMVEC_PIO_PC6]     = inthandler;  /* pio - pc6 */
 102         _ramvec[vba+CPMVEC_TIMER3]      = inthandler;  /* timer 3 */
 103         _ramvec[vba+CPMVEC_RISCTIMER]   = inthandler;  /* reserved */
 104         _ramvec[vba+CPMVEC_PIO_PC5]     = inthandler;  /* pio - pc5 */
 105         _ramvec[vba+CPMVEC_PIO_PC4]     = inthandler;  /* pio - pc4 */
 106         _ramvec[vba+CPMVEC_RESERVED2]   = inthandler;  /* reserved */
 107         _ramvec[vba+CPMVEC_RISCTIMER]   = inthandler;  /* timer table */
 108         _ramvec[vba+CPMVEC_TIMER2]      = inthandler;  /* timer 2 */
 109         _ramvec[vba+CPMVEC_RESERVED3]   = inthandler;  /* reserved */
 110         _ramvec[vba+CPMVEC_IDMA2]       = inthandler;  /* idma 2 */
 111         _ramvec[vba+CPMVEC_IDMA1]       = inthandler;  /* idma 1 */
 112         _ramvec[vba+CPMVEC_SDMA_CB_ERR] = inthandler;  /* sdma channel bus error */
 113         _ramvec[vba+CPMVEC_PIO_PC3]     = inthandler;  /* pio - pc3 */
 114         _ramvec[vba+CPMVEC_PIO_PC2]     = inthandler;  /* pio - pc2 */
 115         /* _ramvec[vba+CPMVEC_TIMER1]      = cpm_isr_timer1; */  /* timer 1 */
 116         _ramvec[vba+CPMVEC_TIMER1]      = inthandler;  /* timer 1 */
 117         _ramvec[vba+CPMVEC_PIO_PC1]     = inthandler;  /* pio - pc1 */
 118         _ramvec[vba+CPMVEC_SCC4]        = inthandler;  /* scc 4 */
 119         _ramvec[vba+CPMVEC_SCC3]        = inthandler;  /* scc 3 */
 120         _ramvec[vba+CPMVEC_SCC2]        = inthandler;  /* scc 2 */
 121         _ramvec[vba+CPMVEC_SCC1]        = inthandler;  /* scc 1 */
 122         _ramvec[vba+CPMVEC_PIO_PC0]     = inthandler;  /* pio - pc0 */
 123
 124
 125         /* turn off all CPM interrupts */
 126         pquicc->intr_cimr = 0x00000000;
 127
 128         /* initialize handlers */
 129         for (i = 0; i < INTERNAL_IRQS; i++) {
 130                 int_irq_list[i].handler = NULL;
 131                 int_irq_list[i].flags   = IRQ_FLG_STD;
 132                 int_irq_list[i].dev_id  = NULL;
 133                 int_irq_list[i].devname = NULL;
 134         }
 135 }
 136
 137 #if 0
 138 void M68360_insert_irq(irq_node_t **list, irq_node_t *node)
 139 {
 140         unsigned long flags;
 141         irq_node_t *cur;
 142
 143         if (!node->dev_id)
 144                 printk(KERN_INFO "%s: Warning: dev_id of %s is zero\n",
 145                        __FUNCTION__, node->devname);
 146
 147         local_irq_save(flags);
 148
 149         cur = *list;
 150
 151         while (cur) {
 152                 list = &cur->next;
 153                 cur = cur->next;
 154         }
 155
 156         node->next = cur;
 157         *list = node;
 158
 159         local_irq_restore(flags);
 160 }
 161
 162 void M68360_delete_irq(irq_node_t **list, void *dev_id)
 163 {
 164         unsigned long flags;
 165         irq_node_t *node;
 166
 167         local_irq_save(flags);
 168
 169         for (node = *list; node; list = &node->next, node = *list) {
 170                 if (node->dev_id == dev_id) {
 171                         *list = node->next;
 172                         /* Mark it as free. */
 173                         node->handler = NULL;
 174                         local_irq_restore(flags);
 175                         return;
 176                 }
 177         }
 178         local_irq_restore(flags);
 179         printk (KERN_INFO "%s: tried to remove invalid irq\n", __FUNCTION__);
 180 }
 181 #endif
 182
 183 int request_irq(
 184         unsigned int irq,
 185         irqreturn_t (*handler)(int, void *, struct pt_regs *),
 186         unsigned long flags,
 187         const char *devname,
 188         void *dev_id)
 189 {
 190         int mask = (1<<irq);
 191
 192         irq += (CPM_VECTOR_BASE<<4);
 193
 194         if (irq >= INTERNAL_IRQS) {
 195                 printk (KERN_ERR "%s: Unknown IRQ %d from %s\n", __FUNCTION__, irq, devname);
 196                 return -ENXIO;
 197         }
 198
 199         if (!(int_irq_list[irq].flags & IRQ_FLG_STD)) {
 200                 if (int_irq_list[irq].flags & IRQ_FLG_LOCK) {
 201                         printk(KERN_ERR "%s: IRQ %d from %s is not replaceable\n",
 202                                __FUNCTION__, irq, int_irq_list[irq].devname);
 203                         return -EBUSY;
 204                 }
 205                 if (flags & IRQ_FLG_REPLACE) {
 206                         printk(KERN_ERR "%s: %s can't replace IRQ %d from %s\n",
 207                                __FUNCTION__, devname, irq, int_irq_list[irq].devname);
 208                         return -EBUSY;
 209                 }
 210         }
 211         int_irq_list[irq].handler = handler;
 212         int_irq_list[irq].flags   = flags;
 213         int_irq_list[irq].dev_id  = dev_id;
 214         int_irq_list[irq].devname = devname;
 215
 216         /* enable in the CIMR */
 217         if (!int_irq_ablecount[irq])
 218                 pquicc->intr_cimr |= mask;
 219         /*      *(volatile unsigned long *)0xfffff304 &= ~(1<<irq); */
 220
 221         return 0;
 222 }
 223
 224 EXPORT_SYMBOL(request_irq);
 225
 226 void free_irq(unsigned int irq, void *dev_id)
 227 {
 228         if (irq >= INTERNAL_IRQS) {
 229                 printk (KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
 230                 return;
 231         }
 232
 233         if (int_irq_list[irq].dev_id != dev_id)
 234                 printk(KERN_INFO "%s: removing probably wrong IRQ %d from %s\n",
 235                        __FUNCTION__, irq, int_irq_list[irq].devname);
 236         int_irq_list[irq].handler = NULL;
 237         int_irq_list[irq].flags   = IRQ_FLG_STD;
 238         int_irq_list[irq].dev_id  = NULL;
 239         int_irq_list[irq].devname = NULL;
 240
 241         *(volatile unsigned long *)0xfffff304 |= 1<<irq;
 242 }
 243
 244 EXPORT_SYMBOL(free_irq);
 245
 246 #if 0
 247 /*
 248  * Enable/disable a particular machine specific interrupt source.
 249  * Note that this may affect other interrupts in case of a shared interrupt.
 250  * This function should only be called for a _very_ short time to change some
 251  * internal data, that may not be changed by the interrupt at the same time.
 252  * int_(enable|disable)_irq calls may also be nested.
 253  */
 254 void M68360_enable_irq(unsigned int irq)
 255 {
 256         if (irq >= INTERNAL_IRQS) {
 257                 printk(KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
 258                 return;
 259         }
 260
 261         if (--int_irq_ablecount[irq])
 262                 return;
 263
 264         /* enable the interrupt */
 265         *(volatile unsigned long *)0xfffff304 &= ~(1<<irq);
 266 }
 267
 268 void M68360_disable_irq(unsigned int irq)
 269 {
 270         if (irq >= INTERNAL_IRQS) {
 271                 printk(KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
 272                 return;
 273         }
 274
 275         if (int_irq_ablecount[irq]++)
 276                 return;
 277
 278         /* disable the interrupt */
 279         *(volatile unsigned long *)0xfffff304 |= 1<<irq;
 280 }
 281 #endif
 282
 283 int show_interrupts(struct seq_file *p, void *v)
 284 {
 285         int i = *(loff_t *) v;
 286
 287         if (i < NR_IRQS) {
 288                 if (int_irq_list[i].devname) {
 289                         seq_printf(p, "%3d: %10u ", i, kstat_cpu(0).irqs[i]);
 290                         if (int_irq_list[i].flags & IRQ_FLG_LOCK)
 291                                 seq_printf(p, "L ");
 292                         else
 293                                 seq_printf(p, "  ");
 294                         seq_printf(p, "%s\n", int_irq_list[i].devname);
 295                 }
 296         }
 297         if (i == NR_IRQS)
 298                 seq_printf(p, "   : %10u   spurious\n", num_spurious);
 299
 300         return 0;
 301 }
 302
 303 /* The 68k family did not have a good way to determine the source
 304  * of interrupts until later in the family.  The EC000 core does
 305  * not provide the vector number on the stack, we vector everything
 306  * into one vector and look in the blasted mask register...
 307  * This code is designed to be fast, almost constant time, not clean!
 308  */
 309 void process_int(int vec, struct pt_regs *fp)
 310 {
 311         int irq;
 312         int mask;
 313
 314         /* unsigned long pend = *(volatile unsigned long *)0xfffff30c; */
 315
 316         /* irq = vec + (CPM_VECTOR_BASE<<4); */
 317         irq = vec;
 318
 319         /* unsigned long pend = *(volatile unsigned long *)pquicc->intr_cipr; */
 320
 321         /* Bugger all that weirdness. For the moment, I seem to know where I came from;
 322          * vec is passed from a specific ISR, so I'll use it. */
 323
 324         if (int_irq_list[irq].handler) {
 325                 int_irq_list[irq].handler(irq , int_irq_list[irq].dev_id, fp);
 326                 kstat_cpu(0).irqs[irq]++;
 327                 pquicc->intr_cisr = (1 << vec); /* indicate that irq has been serviced */
 328         } else {
 329                 printk(KERN_ERR "unregistered interrupt %d!\nTurning it off in the CIMR...\n", irq);
 330                 /* *(volatile unsigned long *)0xfffff304 |= mask; */
 331                 pquicc->intr_cimr &= ~(1 << vec);
 332                 num_spurious += 1;
 333         }
 334         return(IRQ_HANDLED);
 335 }