1 /* 2 * Copyright (C) 2009 Daniel Hellstrom (daniel@gaisler.com) Aeroflex Gaisler AB 3 * Copyright (C) 2009 Konrad Eisele (konrad@gaisler.com) Aeroflex Gaisler AB 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/errno.h> 9 #include <linux/mutex.h> 10 #include <linux/of.h> 11 #include <linux/of_platform.h> 12 #include <linux/interrupt.h> 13 #include <linux/of_device.h> 14 15 #include <asm/oplib.h> 16 #include <asm/timer.h> 17 #include <asm/prom.h> 18 #include <asm/leon.h> 19 #include <asm/leon_amba.h> 20 #include <asm/traps.h> 21 #include <asm/cacheflush.h> 22 #include <asm/smp.h> 23 #include <asm/setup.h> 24 25 #include "prom.h" 26 #include "irq.h" 27 28 struct leon3_irqctrl_regs_map *leon3_irqctrl_regs; /* interrupt controller base address */ 29 struct leon3_gptimer_regs_map *leon3_gptimer_regs; /* timer controller base address */ 30 31 int leondebug_irq_disable; 32 int leon_debug_irqout; 33 static int dummy_master_l10_counter; 34 unsigned long amba_system_id; 35 static DEFINE_SPINLOCK(leon_irq_lock); 36 37 unsigned long leon3_gptimer_irq; /* interrupt controller irq number */ 38 unsigned long leon3_gptimer_idx; /* Timer Index (0..6) within Timer Core */ 39 int leon3_ticker_irq; /* Timer ticker IRQ */ 40 unsigned int sparc_leon_eirq; 41 #define LEON_IMASK(cpu) (&leon3_irqctrl_regs->mask[cpu]) 42 #define LEON_IACK (&leon3_irqctrl_regs->iclear) 43 #define LEON_DO_ACK_HW 1 44 45 /* Return the last ACKed IRQ by the Extended IRQ controller. It has already 46 * been (automatically) ACKed when the CPU takes the trap. 47 */ 48 static inline unsigned int leon_eirq_get(int cpu) 49 { 50 return LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->intid[cpu]) & 0x1f; 51 } 52 53 /* Handle one or multiple IRQs from the extended interrupt controller */ 54 static void leon_handle_ext_irq(unsigned int irq, struct irq_desc *desc) 55 { 56 unsigned int eirq; 57 int cpu = sparc_leon3_cpuid(); 58 59 eirq = leon_eirq_get(cpu); 60 if ((eirq & 0x10) && irq_map[eirq]->irq) /* bit4 tells if IRQ happened */ 61 generic_handle_irq(irq_map[eirq]->irq); 62 } 63 64 /* The extended IRQ controller has been found, this function registers it */ 65 void leon_eirq_setup(unsigned int eirq) 66 { 67 unsigned long mask, oldmask; 68 unsigned int veirq; 69 70 if (eirq < 1 || eirq > 0xf) { 71 printk(KERN_ERR "LEON EXT IRQ NUMBER BAD: %d\n", eirq); 72 return; 73 } 74 75 veirq = leon_build_device_irq(eirq, leon_handle_ext_irq, "extirq", 0); 76 77 /* 78 * Unmask the Extended IRQ, the IRQs routed through the Ext-IRQ 79 * controller have a mask-bit of their own, so this is safe. 80 */ 81 irq_link(veirq); 82 mask = 1 << eirq; 83 oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(boot_cpu_id)); 84 LEON3_BYPASS_STORE_PA(LEON_IMASK(boot_cpu_id), (oldmask | mask)); 85 sparc_leon_eirq = eirq; 86 } 87 88 static inline unsigned long get_irqmask(unsigned int irq) 89 { 90 unsigned long mask; 91 92 if (!irq || ((irq > 0xf) && !sparc_leon_eirq) 93 || ((irq > 0x1f) && sparc_leon_eirq)) { 94 printk(KERN_ERR 95 "leon_get_irqmask: false irq number: %d\n", irq); 96 mask = 0; 97 } else { 98 mask = LEON_HARD_INT(irq); 99 } 100 return mask; 101 } 102 103 #ifdef CONFIG_SMP 104 static int irq_choose_cpu(const struct cpumask *affinity) 105 { 106 cpumask_t mask; 107 108 cpus_and(mask, cpu_online_map, *affinity); 109 if (cpus_equal(mask, cpu_online_map) || cpus_empty(mask)) 110 return boot_cpu_id; 111 else 112 return first_cpu(mask); 113 } 114 #else 115 #define irq_choose_cpu(affinity) boot_cpu_id 116 #endif 117 118 static int leon_set_affinity(struct irq_data *data, const struct cpumask *dest, 119 bool force) 120 { 121 unsigned long mask, oldmask, flags; 122 int oldcpu, newcpu; 123 124 mask = (unsigned long)data->chip_data; 125 oldcpu = irq_choose_cpu(data->affinity); 126 newcpu = irq_choose_cpu(dest); 127 128 if (oldcpu == newcpu) 129 goto out; 130 131 /* unmask on old CPU first before enabling on the selected CPU */ 132 spin_lock_irqsave(&leon_irq_lock, flags); 133 oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(oldcpu)); 134 LEON3_BYPASS_STORE_PA(LEON_IMASK(oldcpu), (oldmask & ~mask)); 135 oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(newcpu)); 136 LEON3_BYPASS_STORE_PA(LEON_IMASK(newcpu), (oldmask | mask)); 137 spin_unlock_irqrestore(&leon_irq_lock, flags); 138 out: 139 return IRQ_SET_MASK_OK; 140 } 141 142 static void leon_unmask_irq(struct irq_data *data) 143 { 144 unsigned long mask, oldmask, flags; 145 int cpu; 146 147 mask = (unsigned long)data->chip_data; 148 cpu = irq_choose_cpu(data->affinity); 149 spin_lock_irqsave(&leon_irq_lock, flags); 150 oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu)); 151 LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu), (oldmask | mask)); 152 spin_unlock_irqrestore(&leon_irq_lock, flags); 153 } 154 155 static void leon_mask_irq(struct irq_data *data) 156 { 157 unsigned long mask, oldmask, flags; 158 int cpu; 159 160 mask = (unsigned long)data->chip_data; 161 cpu = irq_choose_cpu(data->affinity); 162 spin_lock_irqsave(&leon_irq_lock, flags); 163 oldmask = LEON3_BYPASS_LOAD_PA(LEON_IMASK(cpu)); 164 LEON3_BYPASS_STORE_PA(LEON_IMASK(cpu), (oldmask & ~mask)); 165 spin_unlock_irqrestore(&leon_irq_lock, flags); 166 } 167 168 static unsigned int leon_startup_irq(struct irq_data *data) 169 { 170 irq_link(data->irq); 171 leon_unmask_irq(data); 172 return 0; 173 } 174 175 static void leon_shutdown_irq(struct irq_data *data) 176 { 177 leon_mask_irq(data); 178 irq_unlink(data->irq); 179 } 180 181 /* Used by external level sensitive IRQ handlers on the LEON: ACK IRQ ctrl */ 182 static void leon_eoi_irq(struct irq_data *data) 183 { 184 unsigned long mask = (unsigned long)data->chip_data; 185 186 if (mask & LEON_DO_ACK_HW) 187 LEON3_BYPASS_STORE_PA(LEON_IACK, mask & ~LEON_DO_ACK_HW); 188 } 189 190 static struct irq_chip leon_irq = { 191 .name = "leon", 192 .irq_startup = leon_startup_irq, 193 .irq_shutdown = leon_shutdown_irq, 194 .irq_mask = leon_mask_irq, 195 .irq_unmask = leon_unmask_irq, 196 .irq_eoi = leon_eoi_irq, 197 .irq_set_affinity = leon_set_affinity, 198 }; 199 200 /* 201 * Build a LEON IRQ for the edge triggered LEON IRQ controller: 202 * Edge (normal) IRQ - handle_simple_irq, ack=DONT-CARE, never ack 203 * Level IRQ (PCI|Level-GPIO) - handle_fasteoi_irq, ack=1, ack after ISR 204 * Per-CPU Edge - handle_percpu_irq, ack=0 205 */ 206 unsigned int leon_build_device_irq(unsigned int real_irq, 207 irq_flow_handler_t flow_handler, 208 const char *name, int do_ack) 209 { 210 unsigned int irq; 211 unsigned long mask; 212 213 irq = 0; 214 mask = get_irqmask(real_irq); 215 if (mask == 0) 216 goto out; 217 218 irq = irq_alloc(real_irq, real_irq); 219 if (irq == 0) 220 goto out; 221 222 if (do_ack) 223 mask |= LEON_DO_ACK_HW; 224 225 irq_set_chip_and_handler_name(irq, &leon_irq, 226 flow_handler, name); 227 irq_set_chip_data(irq, (void *)mask); 228 229 out: 230 return irq; 231 } 232 233 static unsigned int _leon_build_device_irq(struct platform_device *op, 234 unsigned int real_irq) 235 { 236 return leon_build_device_irq(real_irq, handle_simple_irq, "edge", 0); 237 } 238 239 void leon_update_virq_handling(unsigned int virq, 240 irq_flow_handler_t flow_handler, 241 const char *name, int do_ack) 242 { 243 unsigned long mask = (unsigned long)irq_get_chip_data(virq); 244 245 mask &= ~LEON_DO_ACK_HW; 246 if (do_ack) 247 mask |= LEON_DO_ACK_HW; 248 249 irq_set_chip_and_handler_name(virq, &leon_irq, 250 flow_handler, name); 251 irq_set_chip_data(virq, (void *)mask); 252 } 253 254 void __init leon_init_timers(irq_handler_t counter_fn) 255 { 256 int irq, eirq; 257 struct device_node *rootnp, *np, *nnp; 258 struct property *pp; 259 int len; 260 int icsel; 261 int ampopts; 262 int err; 263 264 leondebug_irq_disable = 0; 265 leon_debug_irqout = 0; 266 master_l10_counter = (unsigned int *)&dummy_master_l10_counter; 267 dummy_master_l10_counter = 0; 268 269 rootnp = of_find_node_by_path("/ambapp0"); 270 if (!rootnp) 271 goto bad; 272 273 /* Find System ID: GRLIB build ID and optional CHIP ID */ 274 pp = of_find_property(rootnp, "systemid", &len); 275 if (pp) 276 amba_system_id = *(unsigned long *)pp->value; 277 278 /* Find IRQMP IRQ Controller Registers base adr otherwise bail out */ 279 np = of_find_node_by_name(rootnp, "GAISLER_IRQMP"); 280 if (!np) { 281 np = of_find_node_by_name(rootnp, "01_00d"); 282 if (!np) 283 goto bad; 284 } 285 pp = of_find_property(np, "reg", &len); 286 if (!pp) 287 goto bad; 288 leon3_irqctrl_regs = *(struct leon3_irqctrl_regs_map **)pp->value; 289 290 /* Find GPTIMER Timer Registers base address otherwise bail out. */ 291 nnp = rootnp; 292 do { 293 np = of_find_node_by_name(nnp, "GAISLER_GPTIMER"); 294 if (!np) { 295 np = of_find_node_by_name(nnp, "01_011"); 296 if (!np) 297 goto bad; 298 } 299 300 ampopts = 0; 301 pp = of_find_property(np, "ampopts", &len); 302 if (pp) { 303 ampopts = *(int *)pp->value; 304 if (ampopts == 0) { 305 /* Skip this instance, resource already 306 * allocated by other OS */ 307 nnp = np; 308 continue; 309 } 310 } 311 312 /* Select Timer-Instance on Timer Core. Default is zero */ 313 leon3_gptimer_idx = ampopts & 0x7; 314 315 pp = of_find_property(np, "reg", &len); 316 if (pp) 317 leon3_gptimer_regs = *(struct leon3_gptimer_regs_map **) 318 pp->value; 319 pp = of_find_property(np, "interrupts", &len); 320 if (pp) 321 leon3_gptimer_irq = *(unsigned int *)pp->value; 322 } while (0); 323 324 if (!(leon3_gptimer_regs && leon3_irqctrl_regs && leon3_gptimer_irq)) 325 goto bad; 326 327 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].val, 0); 328 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].rld, 329 (((1000000 / HZ) - 1))); 330 LEON3_BYPASS_STORE_PA( 331 &leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl, 0); 332 333 #ifdef CONFIG_SMP 334 leon3_ticker_irq = leon3_gptimer_irq + 1 + leon3_gptimer_idx; 335 336 if (!(LEON3_BYPASS_LOAD_PA(&leon3_gptimer_regs->config) & 337 (1<<LEON3_GPTIMER_SEPIRQ))) { 338 printk(KERN_ERR "timer not configured with separate irqs\n"); 339 BUG(); 340 } 341 342 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].val, 343 0); 344 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].rld, 345 (((1000000/HZ) - 1))); 346 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl, 347 0); 348 #endif 349 350 /* 351 * The IRQ controller may (if implemented) consist of multiple 352 * IRQ controllers, each mapped on a 4Kb boundary. 353 * Each CPU may be routed to different IRQCTRLs, however 354 * we assume that all CPUs (in SMP system) is routed to the 355 * same IRQ Controller, and for non-SMP only one IRQCTRL is 356 * accessed anyway. 357 * In AMP systems, Linux must run on CPU0 for the time being. 358 */ 359 icsel = LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->icsel[boot_cpu_id/8]); 360 icsel = (icsel >> ((7 - (boot_cpu_id&0x7)) * 4)) & 0xf; 361 leon3_irqctrl_regs += icsel; 362 363 /* Mask all IRQs on boot-cpu IRQ controller */ 364 LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->mask[boot_cpu_id], 0); 365 366 /* Probe extended IRQ controller */ 367 eirq = (LEON3_BYPASS_LOAD_PA(&leon3_irqctrl_regs->mpstatus) 368 >> 16) & 0xf; 369 if (eirq != 0) 370 leon_eirq_setup(eirq); 371 372 irq = _leon_build_device_irq(NULL, leon3_gptimer_irq+leon3_gptimer_idx); 373 err = request_irq(irq, counter_fn, IRQF_TIMER, "timer", NULL); 374 if (err) { 375 printk(KERN_ERR "unable to attach timer IRQ%d\n", irq); 376 prom_halt(); 377 } 378 379 #ifdef CONFIG_SMP 380 { 381 unsigned long flags; 382 383 /* 384 * In SMP, sun4m adds a IPI handler to IRQ trap handler that 385 * LEON never must take, sun4d and LEON overwrites the branch 386 * with a NOP. 387 */ 388 local_irq_save(flags); 389 patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */ 390 local_flush_cache_all(); 391 local_irq_restore(flags); 392 } 393 #endif 394 395 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx].ctrl, 396 LEON3_GPTIMER_EN | 397 LEON3_GPTIMER_RL | 398 LEON3_GPTIMER_LD | 399 LEON3_GPTIMER_IRQEN); 400 401 #ifdef CONFIG_SMP 402 /* Install per-cpu IRQ handler for broadcasted ticker */ 403 irq = leon_build_device_irq(leon3_ticker_irq, handle_percpu_irq, 404 "per-cpu", 0); 405 err = request_irq(irq, leon_percpu_timer_interrupt, 406 IRQF_PERCPU | IRQF_TIMER, "ticker", 407 NULL); 408 if (err) { 409 printk(KERN_ERR "unable to attach ticker IRQ%d\n", irq); 410 prom_halt(); 411 } 412 413 LEON3_BYPASS_STORE_PA(&leon3_gptimer_regs->e[leon3_gptimer_idx+1].ctrl, 414 LEON3_GPTIMER_EN | 415 LEON3_GPTIMER_RL | 416 LEON3_GPTIMER_LD | 417 LEON3_GPTIMER_IRQEN); 418 #endif 419 return; 420 bad: 421 printk(KERN_ERR "No Timer/irqctrl found\n"); 422 BUG(); 423 return; 424 } 425 426 void leon_clear_clock_irq(void) 427 { 428 } 429 430 void leon_load_profile_irq(int cpu, unsigned int limit) 431 { 432 BUG(); 433 } 434 435 void __init leon_trans_init(struct device_node *dp) 436 { 437 if (strcmp(dp->type, "cpu") == 0 && strcmp(dp->name, "<NULL>") == 0) { 438 struct property *p; 439 p = of_find_property(dp, "mid", (void *)0); 440 if (p) { 441 int mid; 442 dp->name = prom_early_alloc(5 + 1); 443 memcpy(&mid, p->value, p->length); 444 sprintf((char *)dp->name, "cpu%.2d", mid); 445 } 446 } 447 } 448 449 void __initdata (*prom_amba_init)(struct device_node *dp, struct device_node ***nextp) = 0; 450 451 void __init leon_node_init(struct device_node *dp, struct device_node ***nextp) 452 { 453 if (prom_amba_init && 454 strcmp(dp->type, "ambapp") == 0 && 455 strcmp(dp->name, "ambapp0") == 0) { 456 prom_amba_init(dp, nextp); 457 } 458 } 459 460 #ifdef CONFIG_SMP 461 462 void leon_set_cpu_int(int cpu, int level) 463 { 464 unsigned long mask; 465 mask = get_irqmask(level); 466 LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask); 467 } 468 469 static void leon_clear_ipi(int cpu, int level) 470 { 471 unsigned long mask; 472 mask = get_irqmask(level); 473 LEON3_BYPASS_STORE_PA(&leon3_irqctrl_regs->force[cpu], mask<<16); 474 } 475 476 static void leon_set_udt(int cpu) 477 { 478 } 479 480 void leon_clear_profile_irq(int cpu) 481 { 482 } 483 484 void leon_enable_irq_cpu(unsigned int irq_nr, unsigned int cpu) 485 { 486 unsigned long mask, flags, *addr; 487 mask = get_irqmask(irq_nr); 488 spin_lock_irqsave(&leon_irq_lock, flags); 489 addr = (unsigned long *)LEON_IMASK(cpu); 490 LEON3_BYPASS_STORE_PA(addr, (LEON3_BYPASS_LOAD_PA(addr) | mask)); 491 spin_unlock_irqrestore(&leon_irq_lock, flags); 492 } 493 494 #endif 495 496 void __init leon_init_IRQ(void) 497 { 498 sparc_irq_config.init_timers = leon_init_timers; 499 sparc_irq_config.build_device_irq = _leon_build_device_irq; 500 501 BTFIXUPSET_CALL(clear_clock_irq, leon_clear_clock_irq, 502 BTFIXUPCALL_NORM); 503 BTFIXUPSET_CALL(load_profile_irq, leon_load_profile_irq, 504 BTFIXUPCALL_NOP); 505 506 #ifdef CONFIG_SMP 507 BTFIXUPSET_CALL(set_cpu_int, leon_set_cpu_int, BTFIXUPCALL_NORM); 508 BTFIXUPSET_CALL(clear_cpu_int, leon_clear_ipi, BTFIXUPCALL_NORM); 509 BTFIXUPSET_CALL(set_irq_udt, leon_set_udt, BTFIXUPCALL_NORM); 510 #endif 511 512 } 513 514 void __init leon_init(void) 515 { 516 of_pdt_build_more = &leon_node_init; 517 } 518