arch/sparc/kernel/irq.c

   1 /*  $Id: irq.c,v 1.114 2001/12/11 04:55:51 davem Exp $
   2  *  arch/sparc/kernel/irq.c:  Interrupt request handling routines. On the
   3  *                            Sparc the IRQ's are basically 'cast in stone'
   4  *                            and you are supposed to probe the prom's device
   5  *                            node trees to find out who's got which IRQ.
   6  *
   7  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   8  *  Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
   9  *  Copyright (C) 1995,2002 Pete A. Zaitcev (zaitcev@yahoo.com)
  10  *  Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
  11  *  Copyright (C) 1998-2000 Anton Blanchard (anton@samba.org)
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/sched.h>
  16 #include <linux/ptrace.h>
  17 #include <linux/errno.h>
  18 #include <linux/linkage.h>
  19 #include <linux/kernel_stat.h>
  20 #include <linux/signal.h>
  21 #include <linux/sched.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/slab.h>
  24 #include <linux/random.h>
  25 #include <linux/init.h>
  26 #include <linux/smp.h>
  27 #include <linux/smp_lock.h>
  28 #include <linux/delay.h>
  29 #include <linux/threads.h>
  30 #include <linux/spinlock.h>
  31 #include <linux/seq_file.h>
  32
  33 #include <asm/ptrace.h>
  34 #include <asm/processor.h>
  35 #include <asm/system.h>
  36 #include <asm/psr.h>
  37 #include <asm/smp.h>
  38 #include <asm/vaddrs.h>
  39 #include <asm/timer.h>
  40 #include <asm/openprom.h>
  41 #include <asm/oplib.h>
  42 #include <asm/traps.h>
  43 #include <asm/irq.h>
  44 #include <asm/io.h>
  45 #include <asm/pgalloc.h>
  46 #include <asm/pgtable.h>
  47 #include <asm/pcic.h>
  48 #include <asm/cacheflush.h>
  49
  50 #ifdef CONFIG_SMP
  51 #define SMP_NOP2 "nop; nop;\n\t"
  52 #define SMP_NOP3 "nop; nop; nop;\n\t"
  53 #else
  54 #define SMP_NOP2
  55 #define SMP_NOP3
  56 #endif /* SMP */
  57 unsigned long __local_irq_save(void)
  58 {
  59         unsigned long retval;
  60         unsigned long tmp;
  61
  62         __asm__ __volatile__(
  63                 "rd     %%psr, %0\n\t"
  64                 SMP_NOP3        /* Sun4m + Cypress + SMP bug */
  65                 "or     %0, %2, %1\n\t"
  66                 "wr     %1, 0, %%psr\n\t"
  67                 "nop; nop; nop\n"
  68                 : "=&r" (retval), "=r" (tmp)
  69                 : "i" (PSR_PIL)
  70                 : "memory");
  71
  72         return retval;
  73 }
  74
  75 void local_irq_enable(void)
  76 {
  77         unsigned long tmp;
  78
  79         __asm__ __volatile__(
  80                 "rd     %%psr, %0\n\t"
  81                 SMP_NOP3        /* Sun4m + Cypress + SMP bug */
  82                 "andn   %0, %1, %0\n\t"
  83                 "wr     %0, 0, %%psr\n\t"
  84                 "nop; nop; nop\n"
  85                 : "=&r" (tmp)
  86                 : "i" (PSR_PIL)
  87                 : "memory");
  88 }
  89
  90 void local_irq_restore(unsigned long old_psr)
  91 {
  92         unsigned long tmp;
  93
  94         __asm__ __volatile__(
  95                 "rd     %%psr, %0\n\t"
  96                 "and    %2, %1, %2\n\t"
  97                 SMP_NOP2        /* Sun4m + Cypress + SMP bug */
  98                 "andn   %0, %1, %0\n\t"
  99                 "wr     %0, %2, %%psr\n\t"
 100                 "nop; nop; nop\n"
 101                 : "=&r" (tmp)
 102                 : "i" (PSR_PIL), "r" (old_psr)
 103                 : "memory");
 104 }
 105
 106 EXPORT_SYMBOL(__local_irq_save);
 107 EXPORT_SYMBOL(local_irq_enable);
 108 EXPORT_SYMBOL(local_irq_restore);
 109
 110 /*
 111  * Dave Redman (djhr@tadpole.co.uk)
 112  *
 113  * IRQ numbers.. These are no longer restricted to 15..
 114  *
 115  * this is done to enable SBUS cards and onboard IO to be masked
 116  * correctly. using the interrupt level isn't good enough.
 117  *
 118  * For example:
 119  *   A device interrupting at sbus level6 and the Floppy both come in
 120  *   at IRQ11, but enabling and disabling them requires writing to
 121  *   different bits in the SLAVIO/SEC.
 122  *
 123  * As a result of these changes sun4m machines could now support
 124  * directed CPU interrupts using the existing enable/disable irq code
 125  * with tweaks.
 126  *
 127  */
 128
 129 static void irq_panic(void)
 130 {
 131     extern char *cputypval;
 132     prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval);
 133     prom_halt();
 134 }
 135
 136 void (*sparc_init_timers)(irqreturn_t (*)(int, void *,struct pt_regs *)) =
 137     (void (*)(irqreturn_t (*)(int, void *,struct pt_regs *))) irq_panic;
 138
 139 /*
 140  * Dave Redman (djhr@tadpole.co.uk)
 141  *
 142  * There used to be extern calls and hard coded values here.. very sucky!
 143  * instead, because some of the devices attach very early, I do something
 144  * equally sucky but at least we'll never try to free statically allocated
 145  * space or call kmalloc before kmalloc_init :(.
 146  *
 147  * In fact it's the timer10 that attaches first.. then timer14
 148  * then kmalloc_init is called.. then the tty interrupts attach.
 149  * hmmm....
 150  *
 151  */
 152 #define MAX_STATIC_ALLOC        4
 153 struct irqaction static_irqaction[MAX_STATIC_ALLOC];
 154 int static_irq_count;
 155
 156 struct {
 157         struct irqaction *action;
 158         int flags;
 159 } sparc_irq[NR_IRQS];
 160 #define SPARC_IRQ_INPROGRESS 1
 161
 162 /* Used to protect the IRQ action lists */
 163 DEFINE_SPINLOCK(irq_action_lock);
 164
 165 int show_interrupts(struct seq_file *p, void *v)
 166 {
 167         int i = *(loff_t *) v;
 168         struct irqaction * action;
 169         unsigned long flags;
 170 #ifdef CONFIG_SMP
 171         int j;
 172 #endif
 173
 174         if (sparc_cpu_model == sun4d) {
 175                 extern int show_sun4d_interrupts(struct seq_file *, void *);
 176
 177                 return show_sun4d_interrupts(p, v);
 178         }
 179         spin_lock_irqsave(&irq_action_lock, flags);
 180         if (i < NR_IRQS) {
 181                 action = sparc_irq[i].action;
 182                 if (!action)
 183                         goto out_unlock;
 184                 seq_printf(p, "%3d: ", i);
 185 #ifndef CONFIG_SMP
 186                 seq_printf(p, "%10u ", kstat_irqs(i));
 187 #else
 188                 for_each_online_cpu(j) {
 189                         seq_printf(p, "%10u ",
 190                                     kstat_cpu(j).irqs[i]);
 191                 }
 192 #endif
 193                 seq_printf(p, " %c %s",
 194                         (action->flags & IRQF_DISABLED) ? '+' : ' ',
 195                         action->name);
 196                 for (action=action->next; action; action = action->next) {
 197                         seq_printf(p, ",%s %s",
 198                                 (action->flags & IRQF_DISABLED) ? " +" : "",
 199                                 action->name);
 200                 }
 201                 seq_putc(p, '\n');
 202         }
 203 out_unlock:
 204         spin_unlock_irqrestore(&irq_action_lock, flags);
 205         return 0;
 206 }
 207
 208 void free_irq(unsigned int irq, void *dev_id)
 209 {
 210         struct irqaction * action;
 211         struct irqaction **actionp;
 212         unsigned long flags;
 213         unsigned int cpu_irq;
 214
 215         if (sparc_cpu_model == sun4d) {
 216                 extern void sun4d_free_irq(unsigned int, void *);
 217
 218                 sun4d_free_irq(irq, dev_id);
 219                 return;
 220         }
 221         cpu_irq = irq & (NR_IRQS - 1);
 222         if (cpu_irq > 14) {  /* 14 irq levels on the sparc */
 223                 printk("Trying to free bogus IRQ %d\n", irq);
 224                 return;
 225         }
 226
 227         spin_lock_irqsave(&irq_action_lock, flags);
 228
 229         actionp = &sparc_irq[cpu_irq].action;
 230         action = *actionp;
 231
 232         if (!action->handler) {
 233                 printk("Trying to free free IRQ%d\n",irq);
 234                 goto out_unlock;
 235         }
 236         if (dev_id) {
 237                 for (; action; action = action->next) {
 238                         if (action->dev_id == dev_id)
 239                                 break;
 240                         actionp = &action->next;
 241                 }
 242                 if (!action) {
 243                         printk("Trying to free free shared IRQ%d\n",irq);
 244                         goto out_unlock;
 245                 }
 246         } else if (action->flags & IRQF_SHARED) {
 247                 printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
 248                 goto out_unlock;
 249         }
 250         if (action->flags & SA_STATIC_ALLOC)
 251         {
 252                 /* This interrupt is marked as specially allocated
 253                  * so it is a bad idea to free it.
 254                  */
 255                 printk("Attempt to free statically allocated IRQ%d (%s)\n",
 256                        irq, action->name);
 257                 goto out_unlock;
 258         }
 259
 260         *actionp = action->next;
 261
 262         spin_unlock_irqrestore(&irq_action_lock, flags);
 263
 264         synchronize_irq(irq);
 265
 266         spin_lock_irqsave(&irq_action_lock, flags);
 267
 268         kfree(action);
 269
 270         if (!sparc_irq[cpu_irq].action)
 271                 disable_irq(irq);
 272
 273 out_unlock:
 274         spin_unlock_irqrestore(&irq_action_lock, flags);
 275 }
 276
 277 EXPORT_SYMBOL(free_irq);
 278
 279 /*
 280  * This is called when we want to synchronize with
 281  * interrupts. We may for example tell a device to
 282  * stop sending interrupts: but to make sure there
 283  * are no interrupts that are executing on another
 284  * CPU we need to call this function.
 285  */
 286 #ifdef CONFIG_SMP
 287 void synchronize_irq(unsigned int irq)
 288 {
 289         unsigned int cpu_irq;
 290
 291         cpu_irq = irq & (NR_IRQS - 1);
 292         while (sparc_irq[cpu_irq].flags & SPARC_IRQ_INPROGRESS)
 293                 cpu_relax();
 294 }
 295 #endif /* SMP */
 296
 297 void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
 298 {
 299         int i;
 300         struct irqaction * action;
 301         unsigned int cpu_irq;
 302
 303         cpu_irq = irq & (NR_IRQS - 1);
 304         action = sparc_irq[cpu_irq].action;
 305
 306         printk("IO device interrupt, irq = %d\n", irq);
 307         printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc,
 308                     regs->npc, regs->u_regs[14]);
 309         if (action) {
 310                 printk("Expecting: ");
 311                 for (i = 0; i < 16; i++)
 312                         if (action->handler)
 313                                 printk("[%s:%d:0x%x] ", action->name,
 314                                        (int) i, (unsigned int) action->handler);
 315         }
 316         printk("AIEEE\n");
 317         panic("bogus interrupt received");
 318 }
 319
 320 void handler_irq(int irq, struct pt_regs * regs)
 321 {
 322         struct irqaction * action;
 323         int cpu = smp_processor_id();
 324 #ifdef CONFIG_SMP
 325         extern void smp4m_irq_rotate(int cpu);
 326 #endif
 327
 328         irq_enter();
 329         disable_pil_irq(irq);
 330 #ifdef CONFIG_SMP
 331         /* Only rotate on lower priority IRQ's (scsi, ethernet, etc.). */
 332         if((sparc_cpu_model==sun4m) && (irq < 10))
 333                 smp4m_irq_rotate(cpu);
 334 #endif
 335         action = sparc_irq[irq].action;
 336         sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS;
 337         kstat_cpu(cpu).irqs[irq]++;
 338         do {
 339                 if (!action || !action->handler)
 340                         unexpected_irq(irq, NULL, regs);
 341                 action->handler(irq, action->dev_id, regs);
 342                 action = action->next;
 343         } while (action);
 344         sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
 345         enable_pil_irq(irq);
 346         irq_exit();
 347 }
 348
 349 #ifdef CONFIG_BLK_DEV_FD
 350 extern void floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 351
 352 void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
 353 {
 354         int cpu = smp_processor_id();
 355
 356         disable_pil_irq(irq);
 357         irq_enter();
 358         kstat_cpu(cpu).irqs[irq]++;
 359         floppy_interrupt(irq, dev_id, regs);
 360         irq_exit();
 361         enable_pil_irq(irq);
 362         // XXX Eek, it's totally changed with preempt_count() and such
 363         // if (softirq_pending(cpu))
 364         //      do_softirq();
 365 }
 366 #endif
 367
 368 /* Fast IRQ's on the Sparc can only have one routine attached to them,
 369  * thus no sharing possible.
 370  */
 371 int request_fast_irq(unsigned int irq,
 372                      irqreturn_t (*handler)(int, void *, struct pt_regs *),
 373                      unsigned long irqflags, const char *devname)
 374 {
 375         struct irqaction *action;
 376         unsigned long flags;
 377         unsigned int cpu_irq;
 378         int ret;
 379 #ifdef CONFIG_SMP
 380         struct tt_entry *trap_table;
 381         extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
 382 #endif
 383
 384         cpu_irq = irq & (NR_IRQS - 1);
 385         if(cpu_irq > 14) {
 386                 ret = -EINVAL;
 387                 goto out;
 388         }
 389         if(!handler) {
 390                 ret = -EINVAL;
 391                 goto out;
 392         }
 393
 394         spin_lock_irqsave(&irq_action_lock, flags);
 395
 396         action = sparc_irq[cpu_irq].action;
 397         if(action) {
 398                 if(action->flags & IRQF_SHARED)
 399                         panic("Trying to register fast irq when already shared.\n");
 400                 if(irqflags & IRQF_SHARED)
 401                         panic("Trying to register fast irq as shared.\n");
 402
 403                 /* Anyway, someone already owns it so cannot be made fast. */
 404                 printk("request_fast_irq: Trying to register yet already owned.\n");
 405                 ret = -EBUSY;
 406                 goto out_unlock;
 407         }
 408
 409         /* If this is flagged as statically allocated then we use our
 410          * private struct which is never freed.
 411          */
 412         if (irqflags & SA_STATIC_ALLOC) {
 413             if (static_irq_count < MAX_STATIC_ALLOC)
 414                 action = &static_irqaction[static_irq_count++];
 415             else
 416                 printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
 417                        irq, devname);
 418         }
 419
 420         if (action == NULL)
 421             action = (struct irqaction *)kmalloc(sizeof(struct irqaction),
 422                                                  GFP_ATOMIC);
 423
 424         if (!action) {
 425                 ret = -ENOMEM;
 426                 goto out_unlock;
 427         }
 428
 429         /* Dork with trap table if we get this far. */
 430 #define INSTANTIATE(table) \
 431         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
 432         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
 433                 SPARC_BRANCH((unsigned long) handler, \
 434                              (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
 435         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
 436         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;
 437
 438         INSTANTIATE(sparc_ttable)
 439 #ifdef CONFIG_SMP
 440         trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
 441         trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
 442         trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
 443 #endif
 444 #undef INSTANTIATE
 445         /*
 446          * XXX Correct thing whould be to flush only I- and D-cache lines
 447          * which contain the handler in question. But as of time of the
 448          * writing we have no CPU-neutral interface to fine-grained flushes.
 449          */
 450         flush_cache_all();
 451
 452         action->handler = handler;
 453         action->flags = irqflags;
 454         cpus_clear(action->mask);
 455         action->name = devname;
 456         action->dev_id = NULL;
 457         action->next = NULL;
 458
 459         sparc_irq[cpu_irq].action = action;
 460
 461         enable_irq(irq);
 462
 463         ret = 0;
 464 out_unlock:
 465         spin_unlock_irqrestore(&irq_action_lock, flags);
 466 out:
 467         return ret;
 468 }
 469
 470 int request_irq(unsigned int irq,
 471                 irqreturn_t (*handler)(int, void *, struct pt_regs *),
 472                 unsigned long irqflags, const char * devname, void *dev_id)
 473 {
 474         struct irqaction * action, **actionp;
 475         unsigned long flags;
 476         unsigned int cpu_irq;
 477         int ret;
 478
 479         if (sparc_cpu_model == sun4d) {
 480                 extern int sun4d_request_irq(unsigned int,
 481                                              irqreturn_t (*)(int, void *, struct pt_regs *),
 482                                              unsigned long, const char *, void *);
 483                 return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
 484         }
 485         cpu_irq = irq & (NR_IRQS - 1);
 486         if(cpu_irq > 14) {
 487                 ret = -EINVAL;
 488                 goto out;
 489         }
 490         if (!handler) {
 491                 ret = -EINVAL;
 492                 goto out;
 493         }
 494
 495         spin_lock_irqsave(&irq_action_lock, flags);
 496
 497         actionp = &sparc_irq[cpu_irq].action;
 498         action = *actionp;
 499         if (action) {
 500                 if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) {
 501                         ret = -EBUSY;
 502                         goto out_unlock;
 503                 }
 504                 if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) {
 505                         printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
 506                         ret = -EBUSY;
 507                         goto out_unlock;
 508                 }
 509                 for ( ; action; action = *actionp)
 510                         actionp = &action->next;
 511         }
 512
 513         /* If this is flagged as statically allocated then we use our
 514          * private struct which is never freed.
 515          */
 516         if (irqflags & SA_STATIC_ALLOC) {
 517                 if (static_irq_count < MAX_STATIC_ALLOC)
 518                         action = &static_irqaction[static_irq_count++];
 519                 else
 520                         printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
 521         }
 522
 523         if (action == NULL)
 524                 action = (struct irqaction *)kmalloc(sizeof(struct irqaction),
 525                                                      GFP_ATOMIC);
 526
 527         if (!action) {
 528                 ret = -ENOMEM;
 529                 goto out_unlock;
 530         }
 531
 532         action->handler = handler;
 533         action->flags = irqflags;
 534         cpus_clear(action->mask);
 535         action->name = devname;
 536         action->next = NULL;
 537         action->dev_id = dev_id;
 538
 539         *actionp = action;
 540
 541         enable_irq(irq);
 542
 543         ret = 0;
 544 out_unlock:
 545         spin_unlock_irqrestore(&irq_action_lock, flags);
 546 out:
 547         return ret;
 548 }
 549
 550 EXPORT_SYMBOL(request_irq);
 551
 552 /* We really don't need these at all on the Sparc.  We only have
 553  * stubs here because they are exported to modules.
 554  */
 555 unsigned long probe_irq_on(void)
 556 {
 557         return 0;
 558 }
 559
 560 EXPORT_SYMBOL(probe_irq_on);
 561
 562 int probe_irq_off(unsigned long mask)
 563 {
 564         return 0;
 565 }
 566
 567 EXPORT_SYMBOL(probe_irq_off);
 568
 569 /* djhr
 570  * This could probably be made indirect too and assigned in the CPU
 571  * bits of the code. That would be much nicer I think and would also
 572  * fit in with the idea of being able to tune your kernel for your machine
 573  * by removing unrequired machine and device support.
 574  *
 575  */
 576
 577 void __init init_IRQ(void)
 578 {
 579         extern void sun4c_init_IRQ( void );
 580         extern void sun4m_init_IRQ( void );
 581         extern void sun4d_init_IRQ( void );
 582
 583         switch(sparc_cpu_model) {
 584         case sun4c:
 585         case sun4:
 586                 sun4c_init_IRQ();
 587                 break;
 588
 589         case sun4m:
 590 #ifdef CONFIG_PCI
 591                 pcic_probe();
 592                 if (pcic_present()) {
 593                         sun4m_pci_init_IRQ();
 594                         break;
 595                 }
 596 #endif
 597                 sun4m_init_IRQ();
 598                 break;
 599
 600         case sun4d:
 601                 sun4d_init_IRQ();
 602                 break;
 603
 604         default:
 605                 prom_printf("Cannot initialize IRQ's on this Sun machine...");
 606                 break;
 607         }
 608         btfixup();
 609 }
 610
 611 void init_irq_proc(void)
 612 {
 613         /* For now, nothing... */
 614 }