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 IRQs 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/delay.h>
  28 #include <linux/threads.h>
  29 #include <linux/spinlock.h>
  30 #include <linux/seq_file.h>
  31
  32 #include <asm/ptrace.h>
  33 #include <asm/processor.h>
  34 #include <asm/system.h>
  35 #include <asm/psr.h>
  36 #include <asm/smp.h>
  37 #include <asm/vaddrs.h>
  38 #include <asm/timer.h>
  39 #include <asm/openprom.h>
  40 #include <asm/oplib.h>
  41 #include <asm/traps.h>
  42 #include <asm/irq.h>
  43 #include <asm/io.h>
  44 #include <asm/pgalloc.h>
  45 #include <asm/pgtable.h>
  46 #include <asm/pcic.h>
  47 #include <asm/cacheflush.h>
  48 #include <asm/irq_regs.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)(irq_handler_t ) =
 137     (void (*)(irq_handler_t )) 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 pt_regs *old_regs;
 323         struct irqaction * action;
 324         int cpu = smp_processor_id();
 325 #ifdef CONFIG_SMP
 326         extern void smp4m_irq_rotate(int cpu);
 327 #endif
 328
 329         old_regs = set_irq_regs(regs);
 330         irq_enter();
 331         disable_pil_irq(irq);
 332 #ifdef CONFIG_SMP
 333         /* Only rotate on lower priority IRQs (scsi, ethernet, etc.). */
 334         if((sparc_cpu_model==sun4m) && (irq < 10))
 335                 smp4m_irq_rotate(cpu);
 336 #endif
 337         action = sparc_irq[irq].action;
 338         sparc_irq[irq].flags |= SPARC_IRQ_INPROGRESS;
 339         kstat_cpu(cpu).irqs[irq]++;
 340         do {
 341                 if (!action || !action->handler)
 342                         unexpected_irq(irq, NULL, regs);
 343                 action->handler(irq, action->dev_id);
 344                 action = action->next;
 345         } while (action);
 346         sparc_irq[irq].flags &= ~SPARC_IRQ_INPROGRESS;
 347         enable_pil_irq(irq);
 348         irq_exit();
 349         set_irq_regs(old_regs);
 350 }
 351
 352 #ifdef CONFIG_BLK_DEV_FD
 353 extern void floppy_interrupt(int irq, void *dev_id);
 354
 355 void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
 356 {
 357         struct pt_regs *old_regs;
 358         int cpu = smp_processor_id();
 359
 360         old_regs = set_irq_regs(regs);
 361         disable_pil_irq(irq);
 362         irq_enter();
 363         kstat_cpu(cpu).irqs[irq]++;
 364         floppy_interrupt(irq, dev_id);
 365         irq_exit();
 366         enable_pil_irq(irq);
 367         set_irq_regs(old_regs);
 368         // XXX Eek, it's totally changed with preempt_count() and such
 369         // if (softirq_pending(cpu))
 370         //      do_softirq();
 371 }
 372 #endif
 373
 374 /* Fast IRQs on the Sparc can only have one routine attached to them,
 375  * thus no sharing possible.
 376  */
 377 int request_fast_irq(unsigned int irq,
 378                      irq_handler_t handler,
 379                      unsigned long irqflags, const char *devname)
 380 {
 381         struct irqaction *action;
 382         unsigned long flags;
 383         unsigned int cpu_irq;
 384         int ret;
 385 #ifdef CONFIG_SMP
 386         struct tt_entry *trap_table;
 387         extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
 388 #endif
 389
 390         cpu_irq = irq & (NR_IRQS - 1);
 391         if(cpu_irq > 14) {
 392                 ret = -EINVAL;
 393                 goto out;
 394         }
 395         if(!handler) {
 396                 ret = -EINVAL;
 397                 goto out;
 398         }
 399
 400         spin_lock_irqsave(&irq_action_lock, flags);
 401
 402         action = sparc_irq[cpu_irq].action;
 403         if(action) {
 404                 if(action->flags & IRQF_SHARED)
 405                         panic("Trying to register fast irq when already shared.\n");
 406                 if(irqflags & IRQF_SHARED)
 407                         panic("Trying to register fast irq as shared.\n");
 408
 409                 /* Anyway, someone already owns it so cannot be made fast. */
 410                 printk("request_fast_irq: Trying to register yet already owned.\n");
 411                 ret = -EBUSY;
 412                 goto out_unlock;
 413         }
 414
 415         /* If this is flagged as statically allocated then we use our
 416          * private struct which is never freed.
 417          */
 418         if (irqflags & SA_STATIC_ALLOC) {
 419             if (static_irq_count < MAX_STATIC_ALLOC)
 420                 action = &static_irqaction[static_irq_count++];
 421             else
 422                 printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
 423                        irq, devname);
 424         }
 425
 426         if (action == NULL)
 427             action = kmalloc(sizeof(struct irqaction),
 428                                                  GFP_ATOMIC);
 429
 430         if (!action) {
 431                 ret = -ENOMEM;
 432                 goto out_unlock;
 433         }
 434
 435         /* Dork with trap table if we get this far. */
 436 #define INSTANTIATE(table) \
 437         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
 438         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
 439                 SPARC_BRANCH((unsigned long) handler, \
 440                              (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
 441         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
 442         table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;
 443
 444         INSTANTIATE(sparc_ttable)
 445 #ifdef CONFIG_SMP
 446         trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
 447         trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
 448         trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
 449 #endif
 450 #undef INSTANTIATE
 451         /*
 452          * XXX Correct thing whould be to flush only I- and D-cache lines
 453          * which contain the handler in question. But as of time of the
 454          * writing we have no CPU-neutral interface to fine-grained flushes.
 455          */
 456         flush_cache_all();
 457
 458         action->handler = handler;
 459         action->flags = irqflags;
 460         cpus_clear(action->mask);
 461         action->name = devname;
 462         action->dev_id = NULL;
 463         action->next = NULL;
 464
 465         sparc_irq[cpu_irq].action = action;
 466
 467         enable_irq(irq);
 468
 469         ret = 0;
 470 out_unlock:
 471         spin_unlock_irqrestore(&irq_action_lock, flags);
 472 out:
 473         return ret;
 474 }
 475
 476 int request_irq(unsigned int irq,
 477                 irq_handler_t handler,
 478                 unsigned long irqflags, const char * devname, void *dev_id)
 479 {
 480         struct irqaction * action, **actionp;
 481         unsigned long flags;
 482         unsigned int cpu_irq;
 483         int ret;
 484
 485         if (sparc_cpu_model == sun4d) {
 486                 extern int sun4d_request_irq(unsigned int,
 487                                              irq_handler_t ,
 488                                              unsigned long, const char *, void *);
 489                 return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
 490         }
 491         cpu_irq = irq & (NR_IRQS - 1);
 492         if(cpu_irq > 14) {
 493                 ret = -EINVAL;
 494                 goto out;
 495         }
 496         if (!handler) {
 497                 ret = -EINVAL;
 498                 goto out;
 499         }
 500
 501         spin_lock_irqsave(&irq_action_lock, flags);
 502
 503         actionp = &sparc_irq[cpu_irq].action;
 504         action = *actionp;
 505         if (action) {
 506                 if (!(action->flags & IRQF_SHARED) || !(irqflags & IRQF_SHARED)) {
 507                         ret = -EBUSY;
 508                         goto out_unlock;
 509                 }
 510                 if ((action->flags & IRQF_DISABLED) != (irqflags & IRQF_DISABLED)) {
 511                         printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
 512                         ret = -EBUSY;
 513                         goto out_unlock;
 514                 }
 515                 for ( ; action; action = *actionp)
 516                         actionp = &action->next;
 517         }
 518
 519         /* If this is flagged as statically allocated then we use our
 520          * private struct which is never freed.
 521          */
 522         if (irqflags & SA_STATIC_ALLOC) {
 523                 if (static_irq_count < MAX_STATIC_ALLOC)
 524                         action = &static_irqaction[static_irq_count++];
 525                 else
 526                         printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
 527         }
 528
 529         if (action == NULL)
 530                 action = kmalloc(sizeof(struct irqaction),
 531                                                      GFP_ATOMIC);
 532
 533         if (!action) {
 534                 ret = -ENOMEM;
 535                 goto out_unlock;
 536         }
 537
 538         action->handler = handler;
 539         action->flags = irqflags;
 540         cpus_clear(action->mask);
 541         action->name = devname;
 542         action->next = NULL;
 543         action->dev_id = dev_id;
 544
 545         *actionp = action;
 546
 547         enable_irq(irq);
 548
 549         ret = 0;
 550 out_unlock:
 551         spin_unlock_irqrestore(&irq_action_lock, flags);
 552 out:
 553         return ret;
 554 }
 555
 556 EXPORT_SYMBOL(request_irq);
 557
 558 /* We really don't need these at all on the Sparc.  We only have
 559  * stubs here because they are exported to modules.
 560  */
 561 unsigned long probe_irq_on(void)
 562 {
 563         return 0;
 564 }
 565
 566 EXPORT_SYMBOL(probe_irq_on);
 567
 568 int probe_irq_off(unsigned long mask)
 569 {
 570         return 0;
 571 }
 572
 573 EXPORT_SYMBOL(probe_irq_off);
 574
 575 /* djhr
 576  * This could probably be made indirect too and assigned in the CPU
 577  * bits of the code. That would be much nicer I think and would also
 578  * fit in with the idea of being able to tune your kernel for your machine
 579  * by removing unrequired machine and device support.
 580  *
 581  */
 582
 583 void __init init_IRQ(void)
 584 {
 585         extern void sun4c_init_IRQ( void );
 586         extern void sun4m_init_IRQ( void );
 587         extern void sun4d_init_IRQ( void );
 588
 589         switch(sparc_cpu_model) {
 590         case sun4c:
 591         case sun4:
 592                 sun4c_init_IRQ();
 593                 break;
 594
 595         case sun4m:
 596 #ifdef CONFIG_PCI
 597                 pcic_probe();
 598                 if (pcic_present()) {
 599                         sun4m_pci_init_IRQ();
 600                         break;
 601                 }
 602 #endif
 603                 sun4m_init_IRQ();
 604                 break;
 605
 606         case sun4d:
 607                 sun4d_init_IRQ();
 608                 break;
 609
 610         default:
 611                 prom_printf("Cannot initialize IRQs on this Sun machine...");
 612                 break;
 613         }
 614         btfixup();
 615 }
 616
 617 void init_irq_proc(void)
 618 {
 619         /* For now, nothing... */
 620 }