arch/sparc/kernel/sun4d_irq.c

   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 }