arch/m68knommu/platform/68328/ints.c

   1 /*
   2  * linux/arch/m68knommu/platform/68328/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 1996 Roman Zippel
   9  * Copyright 1999 D. Jeff Dionne <jeff@rt-control.com>
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/types.h>
  14 #include <linux/kernel.h>
  15 #include <linux/sched.h>
  16 #include <linux/kernel_stat.h>
  17 #include <linux/errno.h>
  18
  19 #include <asm/system.h>
  20 #include <asm/irq.h>
  21 #include <asm/traps.h>
  22 #include <asm/io.h>
  23 #include <asm/machdep.h>
  24 #include <asm/setup.h>
  25
  26 #if defined(CONFIG_M68328)
  27 #include <asm/MC68328.h>
  28 #elif defined(CONFIG_M68EZ328)
  29 #include <asm/MC68EZ328.h>
  30 #elif defined(CONFIG_M68VZ328)
  31 #include <asm/MC68VZ328.h>
  32 #endif
  33
  34 /* assembler routines */
  35 asmlinkage void system_call(void);
  36 asmlinkage void buserr(void);
  37 asmlinkage void trap(void);
  38 asmlinkage void trap3(void);
  39 asmlinkage void trap4(void);
  40 asmlinkage void trap5(void);
  41 asmlinkage void trap6(void);
  42 asmlinkage void trap7(void);
  43 asmlinkage void trap8(void);
  44 asmlinkage void trap9(void);
  45 asmlinkage void trap10(void);
  46 asmlinkage void trap11(void);
  47 asmlinkage void trap12(void);
  48 asmlinkage void trap13(void);
  49 asmlinkage void trap14(void);
  50 asmlinkage void trap15(void);
  51 asmlinkage void trap33(void);
  52 asmlinkage void trap34(void);
  53 asmlinkage void trap35(void);
  54 asmlinkage void trap36(void);
  55 asmlinkage void trap37(void);
  56 asmlinkage void trap38(void);
  57 asmlinkage void trap39(void);
  58 asmlinkage void trap40(void);
  59 asmlinkage void trap41(void);
  60 asmlinkage void trap42(void);
  61 asmlinkage void trap43(void);
  62 asmlinkage void trap44(void);
  63 asmlinkage void trap45(void);
  64 asmlinkage void trap46(void);
  65 asmlinkage void trap47(void);
  66 asmlinkage irqreturn_t bad_interrupt(int, void *, struct pt_regs *);
  67 asmlinkage irqreturn_t inthandler(void);
  68 asmlinkage irqreturn_t inthandler1(void);
  69 asmlinkage irqreturn_t inthandler2(void);
  70 asmlinkage irqreturn_t inthandler3(void);
  71 asmlinkage irqreturn_t inthandler4(void);
  72 asmlinkage irqreturn_t inthandler5(void);
  73 asmlinkage irqreturn_t inthandler6(void);
  74 asmlinkage irqreturn_t inthandler7(void);
  75
  76 extern e_vector *_ramvec;
  77
  78 /* The number of spurious interrupts */
  79 volatile unsigned int num_spurious;
  80 unsigned int local_irq_count[NR_CPUS];
  81
  82 /* irq node variables for the 32 (potential) on chip sources */
  83 static irq_node_t int_irq_list[NR_IRQS];
  84
  85 #if !defined(CONFIG_DRAGEN2)
  86 asm (".global _start, __ramend/n/t"
  87      ".section .romvec/n"
  88      "e_vectors:\n\t"
  89      ".long __ramend-4, _start, buserr, trap, trap, trap, trap, trap\n\t"
  90      ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
  91      ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
  92      ".long trap, trap, trap, trap\n\t"
  93      ".long trap, trap, trap, trap\n\t"
  94         /*.long inthandler, inthandler, inthandler, inthandler
  95         .long inthandler4, inthandler, inthandler, inthandler   */
  96         /* TRAP #0-15 */
  97      ".long system_call, trap, trap, trap, trap, trap, trap, trap\n\t"
  98      ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
  99      ".long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n\t"
 100      ".text\n"
 101      "ignore: rte");
 102 #endif
 103
 104 /*
 105  * This function should be called during kernel startup to initialize
 106  * the IRQ handling routines.
 107  */
 108 void init_IRQ(void)
 109 {
 110         int i;
 111
 112         /* set up the vectors */
 113         for (i = 72; i < 256; ++i)
 114                 _ramvec[i] = (e_vector) bad_interrupt;
 115
 116         _ramvec[32] = system_call;
 117
 118         _ramvec[65] = (e_vector) inthandler1;
 119         _ramvec[66] = (e_vector) inthandler2;
 120         _ramvec[67] = (e_vector) inthandler3;
 121         _ramvec[68] = (e_vector) inthandler4;
 122         _ramvec[69] = (e_vector) inthandler5;
 123         _ramvec[70] = (e_vector) inthandler6;
 124         _ramvec[71] = (e_vector) inthandler7;
 125
 126         IVR = 0x40; /* Set DragonBall IVR (interrupt base) to 64 */
 127
 128         /* initialize handlers */
 129         for (i = 0; i < NR_IRQS; i++) {
 130                 int_irq_list[i].handler = bad_interrupt;
 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         /* turn off all interrupts */
 137         IMR = ~0;
 138 }
 139
 140 int request_irq(
 141         unsigned int irq,
 142         irqreturn_t (*handler)(int, void *, struct pt_regs *),
 143         unsigned long flags,
 144         const char *devname,
 145         void *dev_id)
 146 {
 147         if (irq >= NR_IRQS) {
 148                 printk (KERN_ERR "%s: Unknown IRQ %d from %s\n", __FUNCTION__, irq, devname);
 149                 return -ENXIO;
 150         }
 151
 152         if (!(int_irq_list[irq].flags & IRQ_FLG_STD)) {
 153                 if (int_irq_list[irq].flags & IRQ_FLG_LOCK) {
 154                         printk(KERN_ERR "%s: IRQ %d from %s is not replaceable\n",
 155                                __FUNCTION__, irq, int_irq_list[irq].devname);
 156                         return -EBUSY;
 157                 }
 158                 if (flags & IRQ_FLG_REPLACE) {
 159                         printk(KERN_ERR "%s: %s can't replace IRQ %d from %s\n",
 160                                __FUNCTION__, devname, irq, int_irq_list[irq].devname);
 161                         return -EBUSY;
 162                 }
 163         }
 164
 165         int_irq_list[irq].handler = handler;
 166         int_irq_list[irq].flags   = flags;
 167         int_irq_list[irq].dev_id  = dev_id;
 168         int_irq_list[irq].devname = devname;
 169
 170         IMR &= ~(1<<irq);
 171
 172         return 0;
 173 }
 174
 175 EXPORT_SYMBOL(request_irq);
 176
 177 void free_irq(unsigned int irq, void *dev_id)
 178 {
 179         if (irq >= NR_IRQS) {
 180                 printk (KERN_ERR "%s: Unknown IRQ %d\n", __FUNCTION__, irq);
 181                 return;
 182         }
 183
 184         if (int_irq_list[irq].dev_id != dev_id)
 185                 printk(KERN_INFO "%s: removing probably wrong IRQ %d from %s\n",
 186                        __FUNCTION__, irq, int_irq_list[irq].devname);
 187
 188         int_irq_list[irq].handler = bad_interrupt;
 189         int_irq_list[irq].flags   = IRQ_FLG_STD;
 190         int_irq_list[irq].dev_id  = NULL;
 191         int_irq_list[irq].devname = NULL;
 192
 193         IMR |= 1<<irq;
 194 }
 195
 196 EXPORT_SYMBOL(free_irq);
 197
 198 int show_interrupts(struct seq_file *p, void *v)
 199 {
 200         int i = *(loff_t *) v;
 201
 202         if (i < NR_IRQS) {
 203                 if (int_irq_list[i].devname) {
 204                         seq_printf(p, "%3d: %10u ", i, kstat_cpu(0).irqs[i]);
 205                         if (int_irq_list[i].flags & IRQ_FLG_LOCK)
 206                                 seq_printf(p, "L ");
 207                         else
 208                                 seq_printf(p, "  ");
 209                         seq_printf(p, "%s\n", int_irq_list[i].devname);
 210                 }
 211         }
 212         if (i == NR_IRQS)
 213                 seq_printf(p, "   : %10u   spurious\n", num_spurious);
 214
 215         return 0;
 216 }
 217
 218 /* The 68k family did not have a good way to determine the source
 219  * of interrupts until later in the family.  The EC000 core does
 220  * not provide the vector number on the stack, we vector everything
 221  * into one vector and look in the blasted mask register...
 222  * This code is designed to be fast, almost constant time, not clean!
 223  */
 224 void process_int(int vec, struct pt_regs *fp)
 225 {
 226         int irq;
 227         int mask;
 228
 229         unsigned long pend = ISR;
 230
 231         while (pend) {
 232                 if (pend & 0x0000ffff) {
 233                         if (pend & 0x000000ff) {
 234                                 if (pend & 0x0000000f) {
 235                                         mask = 0x00000001;
 236                                         irq = 0;
 237                                 } else {
 238                                         mask = 0x00000010;
 239                                         irq = 4;
 240                                 }
 241                         } else {
 242                                 if (pend & 0x00000f00) {
 243                                         mask = 0x00000100;
 244                                         irq = 8;
 245                                 } else {
 246                                         mask = 0x00001000;
 247                                         irq = 12;
 248                                 }
 249                         }
 250                 } else {
 251                         if (pend & 0x00ff0000) {
 252                                 if (pend & 0x000f0000) {
 253                                         mask = 0x00010000;
 254                                         irq = 16;
 255                                 } else {
 256                                         mask = 0x00100000;
 257                                         irq = 20;
 258                                 }
 259                         } else {
 260                                 if (pend & 0x0f000000) {
 261                                         mask = 0x01000000;
 262                                         irq = 24;
 263                                 } else {
 264                                         mask = 0x10000000;
 265                                         irq = 28;
 266                                 }
 267                         }
 268                 }
 269
 270                 while (! (mask & pend)) {
 271                         mask <<=1;
 272                         irq++;
 273                 }
 274
 275                 kstat_cpu(0).irqs[irq]++;
 276
 277                 if (int_irq_list[irq].handler) {
 278                         int_irq_list[irq].handler(irq, int_irq_list[irq].dev_id, fp);
 279                 } else {
 280                         printk(KERN_ERR "unregistered interrupt %d!\nTurning it off in the IMR...\n", irq);
 281                         IMR |= mask;
 282                 }
 283                 pend &= ~mask;
 284         }
 285 }