Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/module.h> |
| 14 | #include <linux/types.h> |
| 15 | #include <linux/kernel.h> |
| 16 | #include <linux/sched.h> |
| 17 | #include <linux/kernel_stat.h> |
| 18 | #include <linux/errno.h> |
| 19 | |
| 20 | #include <asm/system.h> |
| 21 | #include <asm/irq.h> |
Greg Ungerer | 0f7cfcc | 2006-06-28 16:09:41 +1000 | [diff] [blame] | 22 | #include <asm/irqnode.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | } |