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                 } else {
 312                         ret = -EBUSY;
 313                         goto out_unlock;
 314                 }
 315                 if ((action->flags & IRQF_DISABLED) ^ (irqflags & IRQF_DISABLED)) {
 316                         printk(KERN_ERR "Attempt to mix fast and slow interrupts on IRQ%d denied\n",
 317                                irq);
 318                         ret = -EBUSY;
 319                         goto out_unlock;
 320                 }
 321                 action = NULL;          /* Or else! */
 322         }
 323
 324         /* If this is flagged as statically allocated then we use our
 325          * private struct which is never freed.
 326          */
 327         if (irqflags & SA_STATIC_ALLOC) {
 328                 if (static_irq_count < MAX_STATIC_ALLOC)
 329                         action = &static_irqaction[static_irq_count++];
 330                 else
 331                         printk(KERN_ERR "Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
 332                                irq, devname);
 333         }
 334
 335         if (action == NULL)
 336                 action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
 337
 338         if (!action) {
 339                 ret = -ENOMEM;
 340                 goto out_unlock;
 341         }
 342
 343         action->handler = handler;
 344         action->flags = irqflags;
 345         action->name = devname;
 346         action->next = NULL;
 347         action->dev_id = dev_id;
 348
 349         if (tmp)
 350                 tmp->next = action;
 351         else
 352                 *actionp = action;
 353
 354         __enable_irq(irq);
 355
 356         ret = 0;
 357 out_unlock:
 358         spin_unlock_irqrestore(&irq_action_lock, flags);
 359 out:
 360         return ret;
 361 }
 362
 363 static void sun4d_disable_irq(unsigned int irq)
 364 {
 365         int tid = sbus_tid[(irq >> 5) - 1];
 366         unsigned long flags;
 367
 368         if (irq < NR_IRQS)
 369                 return;
 370
 371         spin_lock_irqsave(&sun4d_imsk_lock, flags);
 372         cc_set_imsk_other(tid, cc_get_imsk_other(tid) | (1 << sbus_to_pil[(irq >> 2) & 7]));
 373         spin_unlock_irqrestore(&sun4d_imsk_lock, flags);
 374 }
 375
 376 static void sun4d_enable_irq(unsigned int irq)
 377 {
 378         int tid = sbus_tid[(irq >> 5) - 1];
 379         unsigned long flags;
 380
 381         if (irq < NR_IRQS)
 382                 return;
 383
 384         spin_lock_irqsave(&sun4d_imsk_lock, flags);
 385         cc_set_imsk_other(tid, cc_get_imsk_other(tid) & ~(1 << sbus_to_pil[(irq >> 2) & 7]));
 386         spin_unlock_irqrestore(&sun4d_imsk_lock, flags);
 387 }
 388
 389 #ifdef CONFIG_SMP
 390 static void sun4d_set_cpu_int(int cpu, int level)
 391 {
 392         sun4d_send_ipi(cpu, level);
 393 }
 394
 395 static void sun4d_clear_ipi(int cpu, int level)
 396 {
 397 }
 398
 399 static void sun4d_set_udt(int cpu)
 400 {
 401 }
 402
 403 /* Setup IRQ distribution scheme. */
 404 void __init sun4d_distribute_irqs(void)
 405 {
 406         struct device_node *dp;
 407
 408         int cpuid = cpu_logical_map(1);
 409
 410         if (cpuid == -1)
 411                 cpuid = cpu_logical_map(0);
 412         for_each_node_by_name(dp, "sbi") {
 413                 int devid = of_getintprop_default(dp, "device-id", 0);
 414                 int board = of_getintprop_default(dp, "board#", 0);
 415                 sbus_tid[board] = cpuid;
 416                 set_sbi_tid(devid, cpuid << 3);
 417         }
 418         printk(KERN_ERR "All sbus IRQs directed to CPU%d\n", cpuid);
 419 }
 420 #endif
 421
 422 static void sun4d_clear_clock_irq(void)
 423 {
 424         sbus_readl(&sun4d_timers->l10_timer_limit);
 425 }
 426
 427 static void sun4d_load_profile_irq(int cpu, unsigned int limit)
 428 {
 429         bw_set_prof_limit(cpu, limit);
 430 }
 431
 432 static void __init sun4d_load_profile_irqs(void)
 433 {
 434         int cpu = 0, mid;
 435
 436         while (!cpu_find_by_instance(cpu, NULL, &mid)) {
 437                 sun4d_load_profile_irq(mid >> 3, 0);
 438                 cpu++;
 439         }
 440 }
 441
 442 static void __init sun4d_fixup_trap_table(void)
 443 {
 444 #ifdef CONFIG_SMP
 445         unsigned long flags;
 446         struct tt_entry *trap_table = &sparc_ttable[SP_TRAP_IRQ1 + (14 - 1)];
 447
 448         /* Adjust so that we jump directly to smp4d_ticker */
 449         lvl14_save[2] += smp4d_ticker - real_irq_entry;
 450
 451         /* For SMP we use the level 14 ticker, however the bootup code
 452          * has copied the firmware's level 14 vector into the boot cpu's
 453          * trap table, we must fix this now or we get squashed.
 454          */
 455         local_irq_save(flags);
 456         patchme_maybe_smp_msg[0] = 0x01000000; /* NOP out the branch */
 457         trap_table->inst_one = lvl14_save[0];
 458         trap_table->inst_two = lvl14_save[1];
 459         trap_table->inst_three = lvl14_save[2];
 460         trap_table->inst_four = lvl14_save[3];
 461         local_flush_cache_all();
 462         local_irq_restore(flags);
 463 #endif
 464 }
 465
 466 static void __init sun4d_init_timers(irq_handler_t counter_fn)
 467 {
 468         struct device_node *dp;
 469         struct resource res;
 470         const u32 *reg;
 471         int err;
 472
 473         dp = of_find_node_by_name(NULL, "cpu-unit");
 474         if (!dp) {
 475                 prom_printf("sun4d_init_timers: Unable to find cpu-unit\n");
 476                 prom_halt();
 477         }
 478
 479         /* Which cpu-unit we use is arbitrary, we can view the bootbus timer
 480          * registers via any cpu's mapping.  The first 'reg' property is the
 481          * bootbus.
 482          */
 483         reg = of_get_property(dp, "reg", NULL);
 484         of_node_put(dp);
 485         if (!reg) {
 486                 prom_printf("sun4d_init_timers: No reg property\n");
 487                 prom_halt();
 488         }
 489
 490         res.start = reg[1];
 491         res.end = reg[2] - 1;
 492         res.flags = reg[0] & 0xff;
 493         sun4d_timers = of_ioremap(&res, BW_TIMER_LIMIT,
 494                                   sizeof(struct sun4d_timer_regs), "user timer");
 495         if (!sun4d_timers) {
 496                 prom_printf("sun4d_init_timers: Can't map timer regs\n");
 497                 prom_halt();
 498         }
 499
 500         sbus_writel((((1000000/HZ) + 1) << 10), &sun4d_timers->l10_timer_limit);
 501
 502         master_l10_counter = &sun4d_timers->l10_cur_count;
 503
 504         err = request_irq(TIMER_IRQ, counter_fn,
 505                           (IRQF_DISABLED | SA_STATIC_ALLOC),
 506                           "timer", NULL);
 507         if (err) {
 508                 prom_printf("sun4d_init_timers: request_irq() failed with %d\n",
 509                              err);
 510                 prom_halt();
 511         }
 512         sun4d_load_profile_irqs();
 513         sun4d_fixup_trap_table();
 514 }
 515
 516 void __init sun4d_init_sbi_irq(void)
 517 {
 518         struct device_node *dp;
 519         int target_cpu = 0;
 520
 521 #ifdef CONFIG_SMP
 522         target_cpu = boot_cpu_id;
 523 #endif
 524
 525         nsbi = 0;
 526         for_each_node_by_name(dp, "sbi")
 527                 nsbi++;
 528         sbus_actions = kzalloc(nsbi * 8 * 4 * sizeof(struct sbus_action), GFP_ATOMIC);
 529         if (!sbus_actions) {
 530                 prom_printf("SUN4D: Cannot allocate sbus_actions, halting.\n");
 531                 prom_halt();
 532         }
 533         for_each_node_by_name(dp, "sbi") {
 534                 int devid = of_getintprop_default(dp, "device-id", 0);
 535                 int board = of_getintprop_default(dp, "board#", 0);
 536                 unsigned int mask;
 537
 538                 set_sbi_tid(devid, target_cpu << 3);
 539                 sbus_tid[board] = target_cpu;
 540
 541                 /* Get rid of pending irqs from PROM */
 542                 mask = acquire_sbi(devid, 0xffffffff);
 543                 if (mask) {
 544                         printk(KERN_ERR "Clearing pending IRQs %08x on SBI %d\n",
 545                                mask, board);
 546                         release_sbi(devid, mask);
 547                 }
 548         }
 549 }
 550
 551 void __init sun4d_init_IRQ(void)
 552 {
 553         local_irq_disable();
 554
 555         BTFIXUPSET_CALL(enable_irq, sun4d_enable_irq, BTFIXUPCALL_NORM);
 556         BTFIXUPSET_CALL(disable_irq, sun4d_disable_irq, BTFIXUPCALL_NORM);
 557         BTFIXUPSET_CALL(clear_clock_irq, sun4d_clear_clock_irq, BTFIXUPCALL_NORM);
 558         BTFIXUPSET_CALL(load_profile_irq, sun4d_load_profile_irq, BTFIXUPCALL_NORM);
 559         sparc_init_timers = sun4d_init_timers;
 560 #ifdef CONFIG_SMP
 561         BTFIXUPSET_CALL(set_cpu_int, sun4d_set_cpu_int, BTFIXUPCALL_NORM);
 562         BTFIXUPSET_CALL(clear_cpu_int, sun4d_clear_ipi, BTFIXUPCALL_NOP);
 563         BTFIXUPSET_CALL(set_irq_udt, sun4d_set_udt, BTFIXUPCALL_NOP);
 564 #endif
 565         /* Cannot enable interrupts until OBP ticker is disabled. */
 566 }