1 /* 2 * SS1000/SC2000 interrupt handling. 3 * 4 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 5 * Heavily based on arch/sparc/kernel/irq.c. 6 */ 7 8 #include <linux/kernel_stat.h> 9 #include <linux/seq_file.h> 10 11 #include <asm/timer.h> 12 #include <asm/traps.h> 13 #include <asm/irq.h> 14 #include <asm/io.h> 15 #include <asm/sbi.h> 16 #include <asm/cacheflush.h> 17 18 #include "kernel.h" 19 #include "irq.h" 20 21 /* Sun4d interrupts fall roughly into two categories. SBUS and 22 * cpu local. CPU local interrupts cover the timer interrupts 23 * and whatnot, and we encode those as normal PILs between 24 * 0 and 15. 25 * 26 * SBUS interrupts are encoded integers including the board number 27 * (plus one), the SBUS level, and the SBUS slot number. Sun4D 28 * IRQ dispatch is done by: 29 * 30 * 1) Reading the BW local interrupt table in order to get the bus 31 * interrupt mask. 32 * 33 * This table is indexed by SBUS interrupt level which can be 34 * derived from the PIL we got interrupted on. 35 * 36 * 2) For each bus showing interrupt pending from #1, read the 37 * SBI interrupt state register. This will indicate which slots 38 * have interrupts pending for that SBUS interrupt level. 39 */ 40 41 struct sun4d_timer_regs { 42 u32 l10_timer_limit; 43 u32 l10_cur_countx; 44 u32 l10_limit_noclear; 45 u32 ctrl; 46 u32 l10_cur_count; 47 }; 48 49 static struct sun4d_timer_regs __iomem *sun4d_timers; 50 51 #define TIMER_IRQ 10 52 53 #define MAX_STATIC_ALLOC 4 54 static unsigned char sbus_tid[32]; 55 56 static struct irqaction *irq_action[NR_IRQS]; 57 58 static struct sbus_action { 59 struct irqaction *action; 60 /* For SMP this needs to be extended */ 61 } *sbus_actions; 62 63 static int pil_to_sbus[] = { 64 0, 65 0, 66 1, 67 2, 68 0, 69 3, 70 0, 71 4, 72 0, 73 5, 74 0, 75 6, 76 0, 77 7, 78 0, 79 0, 80 }; 81 82 static int sbus_to_pil[] = { 83 0, 84 2, 85 3, 86 5, 87 7, 88 9, 89 11, 90 13, 91 }; 92 93 static int nsbi; 94 95 /* Exported for sun4d_smp.c */ 96 DEFINE_SPINLOCK(sun4d_imsk_lock); 97 98 int show_sun4d_interrupts(struct seq_file *p, void *v) 99 { 100 int i = *(loff_t *) v, j = 0, k = 0, sbusl; 101 struct irqaction *action; 102 unsigned long flags; 103 #ifdef CONFIG_SMP 104 int x; 105 #endif 106 107 spin_lock_irqsave(&irq_action_lock, flags); 108 if (i < NR_IRQS) { 109 sbusl = pil_to_sbus[i]; 110 if (!sbusl) { 111 action = *(i + irq_action); 112 if (!action) 113 goto out_unlock; 114 } else { 115 for (j = 0; j < nsbi; j++) { 116 for (k = 0; k < 4; k++) 117 action = sbus_actions[(j << 5) + (sbusl << 2) + k].action; 118 if (action) 119 goto found_it; 120 } 121 goto out_unlock; 122 } 123 found_it: seq_printf(p, "%3d: ", i); 124 #ifndef CONFIG_SMP 125 seq_printf(p, "%10u ", kstat_irqs(i)); 126 #else 127 for_each_online_cpu(x) 128 seq_printf(p, "%10u ", 129 kstat_cpu(cpu_logical_map(x)).irqs[i]); 130 #endif 131 seq_printf(p, "%c %s", 132 (action->flags & IRQF_DISABLED) ? '+' : ' ', 133 action->name); 134 action = action->next; 135 for (;;) { 136 for (; action; action = action->next) { 137 seq_printf(p, ",%s %s", 138 (action->flags & IRQF_DISABLED) ? " +" : "", 139 action->name); 140 } 141 if (!sbusl) 142 break; 143 k++; 144 if (k < 4) { 145 action = sbus_actions[(j << 5) + (sbusl << 2) + k].action; 146 } else { 147 j++; 148 if (j == nsbi) 149 break; 150 k = 0; 151 action = sbus_actions[(j << 5) + (sbusl << 2)].action; 152 } 153 } 154 seq_putc(p, '\n'); 155 } 156 out_unlock: 157 spin_unlock_irqrestore(&irq_action_lock, flags); 158 return 0; 159 } 160 161 void sun4d_free_irq(unsigned int irq, void *dev_id) 162 { 163 struct irqaction *action, **actionp; 164 struct irqaction *tmp = NULL; 165 unsigned long flags; 166 167 spin_lock_irqsave(&irq_action_lock, flags); 168 if (irq < 15) 169 actionp = irq + irq_action; 170 else 171 actionp = &(sbus_actions[irq - (1 << 5)].action); 172 action = *actionp; 173 if (!action) { 174 printk(KERN_ERR "Trying to free free IRQ%d\n", irq); 175 goto out_unlock; 176 } 177 if (dev_id) { 178 for (; action; action = action->next) { 179 if (action->dev_id == dev_id) 180 break; 181 tmp = action; 182 } 183 if (!action) { 184 printk(KERN_ERR "Trying to free free shared IRQ%d\n", 185 irq); 186 goto out_unlock; 187 } 188 } else if (action->flags & IRQF_SHARED) { 189 printk(KERN_ERR "Trying to free shared IRQ%d with NULL device ID\n", 190 irq); 191 goto out_unlock; 192 } 193 if (action->flags & SA_STATIC_ALLOC) { 194 /* 195 * This interrupt is marked as specially allocated 196 * so it is a bad idea to free it. 197 */ 198 printk(KERN_ERR "Attempt to free statically allocated IRQ%d (%s)\n", 199 irq, action->name); 200 goto out_unlock; 201 } 202 203 if (tmp) 204 tmp->next = action->next; 205 else 206 *actionp = action->next; 207 208 spin_unlock_irqrestore(&irq_action_lock, flags); 209 210 synchronize_irq(irq); 211 212 spin_lock_irqsave(&irq_action_lock, flags); 213 214 kfree(action); 215 216 if (!(*actionp)) 217 __disable_irq(irq); 218 219 out_unlock: 220 spin_unlock_irqrestore(&irq_action_lock, flags); 221 } 222 223 void sun4d_handler_irq(int pil, struct pt_regs *regs) 224 { 225 struct pt_regs *old_regs; 226 struct irqaction *action; 227 int cpu = smp_processor_id(); 228 /* SBUS IRQ level (1 - 7) */ 229 int sbusl = pil_to_sbus[pil]; 230 231 /* FIXME: Is this necessary?? */ 232 cc_get_ipen(); 233 234 cc_set_iclr(1 << pil); 235 236 old_regs = set_irq_regs(regs); 237 irq_enter(); 238 kstat_cpu(cpu).irqs[pil]++; 239 if (!sbusl) { 240 action = *(pil + irq_action); 241 if (!action) 242 unexpected_irq(pil, NULL, regs); 243 do { 244 action->handler(pil, action->dev_id); 245 action = action->next; 246 } while (action); 247 } else { 248 int bus_mask = bw_get_intr_mask(sbusl) & 0x3ffff; 249 int sbino; 250 struct sbus_action *actionp; 251 unsigned mask, slot; 252 int sbil = (sbusl << 2); 253 254 bw_clear_intr_mask(sbusl, bus_mask); 255 256 /* Loop for each pending SBI */ 257 for (sbino = 0; bus_mask; sbino++, bus_mask >>= 1) 258 if (bus_mask & 1) { 259 mask = acquire_sbi(SBI2DEVID(sbino), 0xf << sbil); 260 mask &= (0xf << sbil); 261 actionp = sbus_actions + (sbino << 5) + (sbil); 262 /* Loop for each pending SBI slot */ 263 for (slot = (1 << sbil); mask; slot <<= 1, actionp++) 264 if (mask & slot) { 265 mask &= ~slot; 266 action = actionp->action; 267 268 if (!action) 269 unexpected_irq(pil, NULL, regs); 270 do { 271 action->handler(pil, action->dev_id); 272 action = action->next; 273 } while (action); 274 release_sbi(SBI2DEVID(sbino), slot); 275 } 276 } 277 } 278 irq_exit(); 279 set_irq_regs(old_regs); 280 } 281 282 int sun4d_request_irq(unsigned int irq, 283 irq_handler_t handler, 284 unsigned long irqflags, const char *devname, void *dev_id) 285 { 286 struct irqaction *action, *tmp = NULL, **actionp; 287 unsigned long flags; 288 int ret; 289 290 if (irq > 14 && irq < (1 << 5)) { 291 ret = -EINVAL; 292 goto out; 293 } 294 295 if (!handler) { 296 ret = -EINVAL; 297 goto out; 298 } 299 300 spin_lock_irqsave(&irq_action_lock, flags); 301 302 if (irq >= (1 << 5)) 303 actionp = &(sbus_actions[irq - (1 << 5)].action); 304 else 305 actionp = irq + irq_action; 306 action = *actionp; 307 308 if (action) { 309 if ((action->flags & IRQF_SHARED) && (irqflags & IRQF_SHARED)) { 310 for (tmp = action; tmp->next; tmp = tmp->next) 311 /* find last entry - tmp used below */; 312 } else { 313 ret = -EBUSY; 314 goto out_unlock; 315 } 316 if ((action->flags & IRQF_DISABLED) ^ (irqflags & IRQF_DISABLED)) { 317 printk(KERN_ERR "Attempt to mix fast and slow interrupts on IRQ%d denied\n", 318 irq); 319 ret = -EBUSY; 320 goto out_unlock; 321 } 322 action = NULL; /* Or else! */ 323 } 324 325 /* If this is flagged as statically allocated then we use our 326 * private struct which is never freed. 327 */ 328 if (irqflags & SA_STATIC_ALLOC) { 329 if (static_irq_count < MAX_STATIC_ALLOC) 330 action = &static_irqaction[static_irq_count++]; 331 else 332 printk(KERN_ERR "Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", 333 irq, devname); 334 } 335 336 if (action == NULL) 337 action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC); 338 339 if (!action) { 340 ret = -ENOMEM; 341 goto out_unlock; 342 } 343 344 action->handler = handler; 345 action->flags = irqflags; 346 action->name = devname; 347 action->next = NULL; 348 action->dev_id = dev_id; 349 350 if (tmp) 351 tmp->next = action; 352 else 353 *actionp = action; 354 355 __enable_irq(irq); 356 357 ret = 0; 358 out_unlock: 359 spin_unlock_irqrestore(&irq_action_lock, flags); 360 out: 361 return ret; 362 } 363 364 static void sun4d_disable_irq(unsigned int irq) 365 { 366 int tid = sbus_tid[(irq >> 5) - 1]; 367 unsigned long flags; 368 369 if (irq < NR_IRQS) 370 return; 371 372 spin_lock_irqsave(&sun4d_imsk_lock, flags); 373 cc_set_imsk_other(tid, cc_get_imsk_other(tid) | (1 << sbus_to_pil[(irq >> 2) & 7])); 374 spin_unlock_irqrestore(&sun4d_imsk_lock, flags); 375 } 376 377 static void sun4d_enable_irq(unsigned int irq) 378 { 379 int tid = sbus_tid[(irq >> 5) - 1]; 380 unsigned long flags; 381 382 if (irq < NR_IRQS) 383 return; 384 385 spin_lock_irqsave(&sun4d_imsk_lock, flags); 386 cc_set_imsk_other(tid, cc_get_imsk_other(tid) & ~(1 << sbus_to_pil[(irq >> 2) & 7])); 387 spin_unlock_irqrestore(&sun4d_imsk_lock, flags); 388 } 389 390 #ifdef CONFIG_SMP 391 static void sun4d_set_cpu_int(int cpu, int level) 392 { 393 sun4d_send_ipi(cpu, level); 394 } 395 396 static void sun4d_clear_ipi(int cpu, int level) 397 { 398 } 399 400 static void sun4d_set_udt(int cpu) 401 { 402 } 403 404 /* Setup IRQ distribution scheme. */ 405 void __init sun4d_distribute_irqs(void) 406 { 407 struct device_node *dp; 408 409 int cpuid = cpu_logical_map(1); 410 411 if (cpuid == -1) 412 cpuid = cpu_logical_map(0); 413 for_each_node_by_name(dp, "sbi") { 414 int devid = of_getintprop_default(dp, "device-id", 0); 415 int board = of_getintprop_default(dp, "board#", 0); 416 sbus_tid[board] = cpuid; 417 set_sbi_tid(devid, cpuid << 3); 418 } 419 printk(KERN_ERR "All sbus IRQs directed to CPU%d\n", cpuid); 420 } 421 #endif 422 423 static void sun4d_clear_clock_irq(void) 424 { 425 sbus_readl(&sun4d_timers->l10_timer_limit); 426 } 427 428 static void sun4d_load_profile_irq(int cpu, unsigned int limit) 429 { 430 bw_set_prof_limit(cpu, limit); 431 } 432 433 static void __init sun4d_load_profile_irqs(void) 434 { 435 int cpu = 0, mid; 436 437 while (!cpu_find_by_instance(cpu, NULL, &mid)) { 438 sun4d_load_profile_irq(mid >> 3, 0); 439 cpu++; 440 } 441 } 442 443 unsigned int sun4d_build_device_irq(struct platform_device *op, 444 unsigned int real_irq) 445 { 446 static int pil_to_sbus[] = { 447 0, 0, 1, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 0, 448 }; 449 struct device_node *dp = op->dev.of_node; 450 struct device_node *io_unit, *sbi = dp->parent; 451 const struct linux_prom_registers *regs; 452 int board, slot; 453 int sbusl; 454 455 while (sbi) { 456 if (!strcmp(sbi->name, "sbi")) 457 break; 458 459 sbi = sbi->parent; 460 } 461 if (!sbi) 462 goto err_out; 463 464 regs = of_get_property(dp, "reg", NULL); 465 if (!regs) 466 goto err_out; 467 468 slot = regs->which_io; 469 470 /* 471 * If SBI's parent is not io-unit or the io-unit lacks 472 * a "board#" property, something is very wrong. 473 */ 474 if (!sbi->parent || strcmp(sbi->parent->name, "io-unit")) { 475 printk("%s: Error, parent is not io-unit.\n", sbi->full_name); 476 goto err_out; 477 } 478 io_unit = sbi->parent; 479 board = of_getintprop_default(io_unit, "board#", -1); 480 if (board == -1) { 481 printk("%s: Error, lacks board# property.\n", io_unit->full_name); 482 goto err_out; 483 } 484 485 sbusl = pil_to_sbus[real_irq]; 486 if (sbusl) 487 return (((board + 1) << 5) + (sbusl << 2) + slot); 488 489 err_out: 490 return real_irq; 491 } 492 493 static void __init sun4d_fixup_trap_table(void) 494 { 495 #ifdef CONFIG_SMP 496 unsigned long flags; 497 struct tt_entry *trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (14 - 1)]; 498 499 /* Adjust so that we jump directly to smp4d_ticker */ 500 lvl14_save[2] += smp4d_ticker - real_irq_entry; 501 502 /* For SMP we use the level 14 ticker, however the bootup code 503 * has copied the firmware's level 14 vector into the boot cpu's 504 * trap table, we must fix this now or we get squashed. 505 */ 506 local_irq_save(flags); 507 patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */ 508 trap_table->inst_one = lvl14_save[0]; 509 trap_table->inst_two = lvl14_save[1]; 510 trap_table->inst_three = lvl14_save[2]; 511 trap_table->inst_four = lvl14_save[3]; 512 local_flush_cache_all(); 513 local_irq_restore(flags); 514 #endif 515 } 516 517 static void __init sun4d_init_timers(irq_handler_t counter_fn) 518 { 519 struct device_node *dp; 520 struct resource res; 521 const u32 *reg; 522 int err; 523 524 dp = of_find_node_by_name(NULL, "cpu-unit"); 525 if (!dp) { 526 prom_printf("sun4d_init_timers: Unable to find cpu-unit\n"); 527 prom_halt(); 528 } 529 530 /* Which cpu-unit we use is arbitrary, we can view the bootbus timer 531 * registers via any cpu's mapping. The first 'reg' property is the 532 * bootbus. 533 */ 534 reg = of_get_property(dp, "reg", NULL); 535 of_node_put(dp); 536 if (!reg) { 537 prom_printf("sun4d_init_timers: No reg property\n"); 538 prom_halt(); 539 } 540 541 res.start = reg[1]; 542 res.end = reg[2] - 1; 543 res.flags = reg[0] & 0xff; 544 sun4d_timers = of_ioremap(&res, BW_TIMER_LIMIT, 545 sizeof(struct sun4d_timer_regs), "user timer"); 546 if (!sun4d_timers) { 547 prom_printf("sun4d_init_timers: Can't map timer regs\n"); 548 prom_halt(); 549 } 550 551 sbus_writel((((1000000/HZ) + 1) << 10), &sun4d_timers->l10_timer_limit); 552 553 master_l10_counter = &sun4d_timers->l10_cur_count; 554 555 err = request_irq(TIMER_IRQ, counter_fn, 556 (IRQF_DISABLED | SA_STATIC_ALLOC), 557 "timer", NULL); 558 if (err) { 559 prom_printf("sun4d_init_timers: request_irq() failed with %d\n", 560 err); 561 prom_halt(); 562 } 563 sun4d_load_profile_irqs(); 564 sun4d_fixup_trap_table(); 565 } 566 567 void __init sun4d_init_sbi_irq(void) 568 { 569 struct device_node *dp; 570 int target_cpu = 0; 571 572 #ifdef CONFIG_SMP 573 target_cpu = boot_cpu_id; 574 #endif 575 576 nsbi = 0; 577 for_each_node_by_name(dp, "sbi") 578 nsbi++; 579 sbus_actions = kzalloc(nsbi * 8 * 4 * sizeof(struct sbus_action), GFP_ATOMIC); 580 if (!sbus_actions) { 581 prom_printf("SUN4D: Cannot allocate sbus_actions, halting.\n"); 582 prom_halt(); 583 } 584 for_each_node_by_name(dp, "sbi") { 585 int devid = of_getintprop_default(dp, "device-id", 0); 586 int board = of_getintprop_default(dp, "board#", 0); 587 unsigned int mask; 588 589 set_sbi_tid(devid, target_cpu << 3); 590 sbus_tid[board] = target_cpu; 591 592 /* Get rid of pending irqs from PROM */ 593 mask = acquire_sbi(devid, 0xffffffff); 594 if (mask) { 595 printk(KERN_ERR "Clearing pending IRQs %08x on SBI %d\n", 596 mask, board); 597 release_sbi(devid, mask); 598 } 599 } 600 } 601 602 void __init sun4d_init_IRQ(void) 603 { 604 local_irq_disable(); 605 606 BTFIXUPSET_CALL(enable_irq, sun4d_enable_irq, BTFIXUPCALL_NORM); 607 BTFIXUPSET_CALL(disable_irq, sun4d_disable_irq, BTFIXUPCALL_NORM); 608 BTFIXUPSET_CALL(clear_clock_irq, sun4d_clear_clock_irq, BTFIXUPCALL_NORM); 609 BTFIXUPSET_CALL(load_profile_irq, sun4d_load_profile_irq, BTFIXUPCALL_NORM); 610 611 sparc_irq_config.init_timers = sun4d_init_timers; 612 sparc_irq_config.build_device_irq = sun4d_build_device_irq; 613 614 #ifdef CONFIG_SMP 615 BTFIXUPSET_CALL(set_cpu_int, sun4d_set_cpu_int, BTFIXUPCALL_NORM); 616 BTFIXUPSET_CALL(clear_cpu_int, sun4d_clear_ipi, BTFIXUPCALL_NOP); 617 BTFIXUPSET_CALL(set_irq_udt, sun4d_set_udt, BTFIXUPCALL_NOP); 618 #endif 619 /* Cannot enable interrupts until OBP ticker is disabled. */ 620 } 621