arch/i386/kernel/irq.c

   1 /*
   2  *      linux/arch/i386/kernel/irq.c
   3  *
   4  *      Copyright (C) 1992, 1998 Linus Torvalds, Ingo Molnar
   5  *
   6  * This file contains the code used by various IRQ handling routines:
   7  * asking for different IRQ's should be done through these routines
   8  * instead of just grabbing them. Thus setups with different IRQ numbers
   9  * shouldn't result in any weird surprises, and installing new handlers
  10  * should be easier.
  11  */
  12
  13 /*
  14  * (mostly architecture independent, will move to kernel/irq.c in 2.5.)
  15  *
  16  * IRQs are in fact implemented a bit like signal handlers for the kernel.
  17  * Naturally it's not a 1:1 relation, but there are similarities.
  18  */
  19
  20 #include <linux/config.h>
  21 #include <linux/ptrace.h>
  22 #include <linux/errno.h>
  23 #include <linux/signal.h>
  24 #include <linux/sched.h>
  25 #include <linux/ioport.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/timex.h>
  28 #include <linux/slab.h>
  29 #include <linux/random.h>
  30 #include <linux/smp_lock.h>
  31 #include <linux/init.h>
  32 #include <linux/kernel_stat.h>
  33 #include <linux/irq.h>
  34 #include <linux/proc_fs.h>
  35
  36 #include <asm/atomic.h>
  37 #include <asm/io.h>
  38 #include <asm/smp.h>
  39 #include <asm/system.h>
  40 #include <asm/bitops.h>
  41 #include <asm/uaccess.h>
  42 #include <asm/pgalloc.h>
  43 #include <asm/delay.h>
  44 #include <asm/desc.h>
  45 #include <asm/irq.h>
  46
  47
  48
  49 /*
  50  * Linux has a controller-independent x86 interrupt architecture.
  51  * every controller has a 'controller-template', that is used
  52  * by the main code to do the right thing. Each driver-visible
  53  * interrupt source is transparently wired to the apropriate
  54  * controller. Thus drivers need not be aware of the
  55  * interrupt-controller.
  56  *
  57  * Various interrupt controllers we handle: 8259 PIC, SMP IO-APIC,
  58  * PIIX4's internal 8259 PIC and SGI's Visual Workstation Cobalt (IO-)APIC.
  59  * (IO-APICs assumed to be messaging to Pentium local-APICs)
  60  *
  61  * the code is designed to be easily extended with new/different
  62  * interrupt controllers, without having to do assembly magic.
  63  */
  64
  65 /*
  66  * Controller mappings for all interrupt sources:
  67  */
  68 irq_desc_t irq_desc[NR_IRQS] __cacheline_aligned =
  69         { [0 ... NR_IRQS-1] = { 0, &no_irq_type, NULL, 0, SPIN_LOCK_UNLOCKED}};
  70
  71 static void register_irq_proc (unsigned int irq);
  72
  73 /*
  74  * Special irq handlers.
  75  */
  76
  77 void no_action(int cpl, void *dev_id, struct pt_regs *regs) { }
  78
  79 /*
  80  * Generic no controller code
  81  */
  82
  83 static void enable_none(unsigned int irq) { }
  84 static unsigned int startup_none(unsigned int irq) { return 0; }
  85 static void disable_none(unsigned int irq) { }
  86 static void ack_none(unsigned int irq)
  87 {
  88 /*
  89  * 'what should we do if we get a hw irq event on an illegal vector'.
  90  * each architecture has to answer this themselves, it doesnt deserve
  91  * a generic callback i think.
  92  */
  93 #if CONFIG_X86
  94         printk("unexpected IRQ trap at vector %02x\n", irq);
  95 #ifdef CONFIG_X86_LOCAL_APIC
  96         /*
  97          * Currently unexpected vectors happen only on SMP and APIC.
  98          * We _must_ ack these because every local APIC has only N
  99          * irq slots per priority level, and a 'hanging, unacked' IRQ
 100          * holds up an irq slot - in excessive cases (when multiple
 101          * unexpected vectors occur) that might lock up the APIC
 102          * completely.
 103          */
 104         ack_APIC_irq();
 105 #endif
 106 #endif
 107 }
 108
 109 /* startup is the same as "enable", shutdown is same as "disable" */
 110 #define shutdown_none   disable_none
 111 #define end_none        enable_none
 112
 113 struct hw_interrupt_type no_irq_type = {
 114         "none",
 115         startup_none,
 116         shutdown_none,
 117         enable_none,
 118         disable_none,
 119         ack_none,
 120         end_none
 121 };
 122
 123 atomic_t irq_err_count;
 124 #ifdef CONFIG_X86_IO_APIC
 125 #ifdef APIC_MISMATCH_DEBUG
 126 atomic_t irq_mis_count;
 127 #endif
 128 #endif
 129
 130 /*
 131  * Generic, controller-independent functions:
 132  */
 133
 134 int get_irq_list(char *buf)
 135 {
 136         int i, j;
 137         struct irqaction * action;
 138         char *p = buf;
 139
 140         p += sprintf(p, "           ");
 141         for (j=0; j<smp_num_cpus; j++)
 142                 p += sprintf(p, "CPU%d       ",j);
 143         *p++ = '\n';
 144
 145         for (i = 0 ; i < NR_IRQS ; i++) {
 146                 action = irq_desc[i].action;
 147                 if (!action)
 148                         continue;
 149                 p += sprintf(p, "%3d: ",i);
 150 #ifndef CONFIG_SMP
 151                 p += sprintf(p, "%10u ", kstat_irqs(i));
 152 #else
 153                 for (j = 0; j < smp_num_cpus; j++)
 154                         p += sprintf(p, "%10u ",
 155                                 kstat.irqs[cpu_logical_map(j)][i]);
 156 #endif
 157                 p += sprintf(p, " %14s", irq_desc[i].handler->typename);
 158                 p += sprintf(p, "  %s", action->name);
 159
 160                 for (action=action->next; action; action = action->next)
 161                         p += sprintf(p, ", %s", action->name);
 162                 *p++ = '\n';
 163         }
 164         p += sprintf(p, "NMI: ");
 165         for (j = 0; j < smp_num_cpus; j++)
 166                 p += sprintf(p, "%10u ",
 167                         nmi_count(cpu_logical_map(j)));
 168         p += sprintf(p, "\n");
 169 #if CONFIG_X86_LOCAL_APIC
 170         p += sprintf(p, "LOC: ");
 171         for (j = 0; j < smp_num_cpus; j++)
 172                 p += sprintf(p, "%10u ",
 173                         apic_timer_irqs[cpu_logical_map(j)]);
 174         p += sprintf(p, "\n");
 175 #endif
 176         p += sprintf(p, "ERR: %10u\n", atomic_read(&irq_err_count));
 177 #ifdef CONFIG_X86_IO_APIC
 178 #ifdef APIC_MISMATCH_DEBUG
 179         p += sprintf(p, "MIS: %10u\n", atomic_read(&irq_mis_count));
 180 #endif
 181 #endif
 182         return p - buf;
 183 }
 184
 185
 186 /*
 187  * Global interrupt locks for SMP. Allow interrupts to come in on any
 188  * CPU, yet make cli/sti act globally to protect critical regions..
 189  */
 190
 191 #ifdef CONFIG_SMP
 192 unsigned char global_irq_holder = NO_PROC_ID;
 193 unsigned volatile long global_irq_lock; /* pendantic: long for set_bit --RR */
 194
 195 extern void show_stack(unsigned long* esp);
 196
 197 static void show(char * str)
 198 {
 199         int i;
 200         int cpu = smp_processor_id();
 201
 202         printk("\n%s, CPU %d:\n", str, cpu);
 203         printk("irq:  %d [",irqs_running());
 204         for(i=0;i < smp_num_cpus;i++)
 205                 printk(" %d",local_irq_count(i));
 206         printk(" ]\nbh:   %d [",spin_is_locked(&global_bh_lock) ? 1 : 0);
 207         for(i=0;i < smp_num_cpus;i++)
 208                 printk(" %d",local_bh_count(i));
 209
 210         printk(" ]\nStack dumps:");
 211         for(i = 0; i < smp_num_cpus; i++) {
 212                 unsigned long esp;
 213                 if (i == cpu)
 214                         continue;
 215                 printk("\nCPU %d:",i);
 216                 esp = init_tss[i].esp0;
 217                 if (!esp) {
 218                         /* tss->esp0 is set to NULL in cpu_init(),
 219                          * it's initialized when the cpu returns to user
 220                          * space. -- manfreds
 221                          */
 222                         printk(" <unknown> ");
 223                         continue;
 224                 }
 225                 esp &= ~(THREAD_SIZE-1);
 226                 esp += sizeof(struct task_struct);
 227                 show_stack((void*)esp);
 228         }
 229         printk("\nCPU %d:",cpu);
 230         show_stack(NULL);
 231         printk("\n");
 232 }
 233
 234 #define MAXCOUNT 100000000
 235
 236 /*
 237  * I had a lockup scenario where a tight loop doing
 238  * spin_unlock()/spin_lock() on CPU#1 was racing with
 239  * spin_lock() on CPU#0. CPU#0 should have noticed spin_unlock(), but
 240  * apparently the spin_unlock() information did not make it
 241  * through to CPU#0 ... nasty, is this by design, do we have to limit
 242  * 'memory update oscillation frequency' artificially like here?
 243  *
 244  * Such 'high frequency update' races can be avoided by careful design, but
 245  * some of our major constructs like spinlocks use similar techniques,
 246  * it would be nice to clarify this issue. Set this define to 0 if you
 247  * want to check whether your system freezes.  I suspect the delay done
 248  * by SYNC_OTHER_CORES() is in correlation with 'snooping latency', but
 249  * i thought that such things are guaranteed by design, since we use
 250  * the 'LOCK' prefix.
 251  */
 252 #define SUSPECTED_CPU_OR_CHIPSET_BUG_WORKAROUND 0
 253
 254 #if SUSPECTED_CPU_OR_CHIPSET_BUG_WORKAROUND
 255 # define SYNC_OTHER_CORES(x) udelay(x+1)
 256 #else
 257 /*
 258  * We have to allow irqs to arrive between __sti and __cli
 259  */
 260 # define SYNC_OTHER_CORES(x) __asm__ __volatile__ ("nop")
 261 #endif
 262
 263 static inline void wait_on_irq(int cpu)
 264 {
 265         int count = MAXCOUNT;
 266
 267         for (;;) {
 268
 269                 /*
 270                  * Wait until all interrupts are gone. Wait
 271                  * for bottom half handlers unless we're
 272                  * already executing in one..
 273                  */
 274                 if (!irqs_running())
 275                         if (local_bh_count(cpu) || !spin_is_locked(&global_bh_lock))
 276                                 break;
 277
 278                 /* Duh, we have to loop. Release the lock to avoid deadlocks */
 279                 clear_bit(0,&global_irq_lock);
 280
 281                 for (;;) {
 282                         if (!--count) {
 283                                 show("wait_on_irq");
 284                                 count = ~0;
 285                         }
 286                         __sti();
 287                         SYNC_OTHER_CORES(cpu);
 288                         __cli();
 289                         if (irqs_running())
 290                                 continue;
 291                         if (global_irq_lock)
 292                                 continue;
 293                         if (!local_bh_count(cpu) && spin_is_locked(&global_bh_lock))
 294                                 continue;
 295                         if (!test_and_set_bit(0,&global_irq_lock))
 296                                 break;
 297                 }
 298         }
 299 }
 300
 301 /*
 302  * This is called when we want to synchronize with
 303  * interrupts. We may for example tell a device to
 304  * stop sending interrupts: but to make sure there
 305  * are no interrupts that are executing on another
 306  * CPU we need to call this function.
 307  */
 308 void synchronize_irq(void)
 309 {
 310         if (irqs_running()) {
 311                 /* Stupid approach */
 312                 cli();
 313                 sti();
 314         }
 315 }
 316
 317 static inline void get_irqlock(int cpu)
 318 {
 319         if (test_and_set_bit(0,&global_irq_lock)) {
 320                 /* do we already hold the lock? */
 321                 if ((unsigned char) cpu == global_irq_holder)
 322                         return;
 323                 /* Uhhuh.. Somebody else got it. Wait.. */
 324                 do {
 325                         do {
 326                                 rep_nop();
 327                         } while (test_bit(0,&global_irq_lock));
 328                 } while (test_and_set_bit(0,&global_irq_lock));
 329         }
 330         /*
 331          * We also to make sure that nobody else is running
 332          * in an interrupt context.
 333          */
 334         wait_on_irq(cpu);
 335
 336         /*
 337          * Ok, finally..
 338          */
 339         global_irq_holder = cpu;
 340 }
 341
 342 #define EFLAGS_IF_SHIFT 9
 343
 344 /*
 345  * A global "cli()" while in an interrupt context
 346  * turns into just a local cli(). Interrupts
 347  * should use spinlocks for the (very unlikely)
 348  * case that they ever want to protect against
 349  * each other.
 350  *
 351  * If we already have local interrupts disabled,
 352  * this will not turn a local disable into a
 353  * global one (problems with spinlocks: this makes
 354  * save_flags+cli+sti usable inside a spinlock).
 355  */
 356 void __global_cli(void)
 357 {
 358         unsigned int flags;
 359
 360         __save_flags(flags);
 361         if (flags & (1 << EFLAGS_IF_SHIFT)) {
 362                 int cpu = smp_processor_id();
 363                 __cli();
 364                 if (!local_irq_count(cpu))
 365                         get_irqlock(cpu);
 366         }
 367 }
 368
 369 void __global_sti(void)
 370 {
 371         int cpu = smp_processor_id();
 372
 373         if (!local_irq_count(cpu))
 374                 release_irqlock(cpu);
 375         __sti();
 376 }
 377
 378 /*
 379  * SMP flags value to restore to:
 380  * 0 - global cli
 381  * 1 - global sti
 382  * 2 - local cli
 383  * 3 - local sti
 384  */
 385 unsigned long __global_save_flags(void)
 386 {
 387         int retval;
 388         int local_enabled;
 389         unsigned long flags;
 390         int cpu = smp_processor_id();
 391
 392         __save_flags(flags);
 393         local_enabled = (flags >> EFLAGS_IF_SHIFT) & 1;
 394         /* default to local */
 395         retval = 2 + local_enabled;
 396
 397         /* check for global flags if we're not in an interrupt */
 398         if (!local_irq_count(cpu)) {
 399                 if (local_enabled)
 400                         retval = 1;
 401                 if (global_irq_holder == cpu)
 402                         retval = 0;
 403         }
 404         return retval;
 405 }
 406
 407 void __global_restore_flags(unsigned long flags)
 408 {
 409         switch (flags) {
 410         case 0:
 411                 __global_cli();
 412                 break;
 413         case 1:
 414                 __global_sti();
 415                 break;
 416         case 2:
 417                 __cli();
 418                 break;
 419         case 3:
 420                 __sti();
 421                 break;
 422         default:
 423                 printk("global_restore_flags: %08lx (%08lx)\n",
 424                         flags, (&flags)[-1]);
 425         }
 426 }
 427
 428 #endif
 429
 430 /*
 431  * This should really return information about whether
 432  * we should do bottom half handling etc. Right now we
 433  * end up _always_ checking the bottom half, which is a
 434  * waste of time and is not what some drivers would
 435  * prefer.
 436  */
 437 int handle_IRQ_event(unsigned int irq, struct pt_regs * regs, struct irqaction * action)
 438 {
 439         int status;
 440         int cpu = smp_processor_id();
 441
 442         irq_enter(cpu, irq);
 443
 444         status = 1;     /* Force the "do bottom halves" bit */
 445
 446         if (!(action->flags & SA_INTERRUPT))
 447                 __sti();
 448
 449         do {
 450                 status |= action->flags;
 451                 action->handler(irq, action->dev_id, regs);
 452                 action = action->next;
 453         } while (action);
 454         if (status & SA_SAMPLE_RANDOM)
 455                 add_interrupt_randomness(irq);
 456         __cli();
 457
 458         irq_exit(cpu, irq);
 459
 460         return status;
 461 }
 462
 463 /*
 464  * Generic enable/disable code: this just calls
 465  * down into the PIC-specific version for the actual
 466  * hardware disable after having gotten the irq
 467  * controller lock.
 468  */
 469
 470 /**
 471  *      disable_irq_nosync - disable an irq without waiting
 472  *      @irq: Interrupt to disable
 473  *
 474  *      Disable the selected interrupt line.  Disables and Enables are
 475  *      nested.
 476  *      Unlike disable_irq(), this function does not ensure existing
 477  *      instances of the IRQ handler have completed before returning.
 478  *
 479  *      This function may be called from IRQ context.
 480  */
 481
 482 inline void disable_irq_nosync(unsigned int irq)
 483 {
 484         irq_desc_t *desc = irq_desc + irq;
 485         unsigned long flags;
 486
 487         spin_lock_irqsave(&desc->lock, flags);
 488         if (!desc->depth++) {
 489                 desc->status |= IRQ_DISABLED;
 490                 desc->handler->disable(irq);
 491         }
 492         spin_unlock_irqrestore(&desc->lock, flags);
 493 }
 494
 495 /**
 496  *      disable_irq - disable an irq and wait for completion
 497  *      @irq: Interrupt to disable
 498  *
 499  *      Disable the selected interrupt line.  Enables and Disables are
 500  *      nested.
 501  *      This function waits for any pending IRQ handlers for this interrupt
 502  *      to complete before returning. If you use this function while
 503  *      holding a resource the IRQ handler may need you will deadlock.
 504  *
 505  *      This function may be called - with care - from IRQ context.
 506  */
 507
 508 void disable_irq(unsigned int irq)
 509 {
 510         disable_irq_nosync(irq);
 511
 512         if (!local_irq_count(smp_processor_id())) {
 513                 do {
 514                         barrier();
 515                         cpu_relax();
 516                 } while (irq_desc[irq].status & IRQ_INPROGRESS);
 517         }
 518 }
 519
 520 /**
 521  *      enable_irq - enable handling of an irq
 522  *      @irq: Interrupt to enable
 523  *
 524  *      Undoes the effect of one call to disable_irq().  If this
 525  *      matches the last disable, processing of interrupts on this
 526  *      IRQ line is re-enabled.
 527  *
 528  *      This function may be called from IRQ context.
 529  */
 530
 531 void enable_irq(unsigned int irq)
 532 {
 533         irq_desc_t *desc = irq_desc + irq;
 534         unsigned long flags;
 535
 536         spin_lock_irqsave(&desc->lock, flags);
 537         switch (desc->depth) {
 538         case 1: {
 539                 unsigned int status = desc->status & ~IRQ_DISABLED;
 540                 desc->status = status;
 541                 if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
 542                         desc->status = status | IRQ_REPLAY;
 543                         hw_resend_irq(desc->handler,irq);
 544                 }
 545                 desc->handler->enable(irq);
 546                 /* fall-through */
 547         }
 548         default:
 549                 desc->depth--;
 550                 break;
 551         case 0:
 552                 printk("enable_irq(%u) unbalanced from %p\n", irq,
 553                        __builtin_return_address(0));
 554         }
 555         spin_unlock_irqrestore(&desc->lock, flags);
 556 }
 557
 558 /*
 559  * do_IRQ handles all normal device IRQ's (the special
 560  * SMP cross-CPU interrupts have their own specific
 561  * handlers).
 562  */
 563 asmlinkage unsigned int do_IRQ(struct pt_regs regs)
 564 {
 565         /*
 566          * We ack quickly, we don't want the irq controller
 567          * thinking we're snobs just because some other CPU has
 568          * disabled global interrupts (we have already done the
 569          * INT_ACK cycles, it's too late to try to pretend to the
 570          * controller that we aren't taking the interrupt).
 571          *
 572          * 0 return value means that this irq is already being
 573          * handled by some other CPU. (or is disabled)
 574          */
 575         int irq = regs.orig_eax & 0xff; /* high bits used in ret_from_ code  */
 576         int cpu = smp_processor_id();
 577         irq_desc_t *desc = irq_desc + irq;
 578         struct irqaction * action;
 579         unsigned int status;
 580 #ifdef CONFIG_DEBUG_STACKOVERFLOW
 581         long esp;
 582
 583         /* Debugging check for stack overflow: is there less than 1KB free? */
 584         __asm__ __volatile__("andl %%esp,%0" : "=r" (esp) : "0" (8191));
 585         if (unlikely(esp < (sizeof(struct task_struct) + 1024))) {
 586                 extern void show_stack(unsigned long *);
 587
 588                 printk("do_IRQ: stack overflow: %ld\n",
 589                         esp - sizeof(struct task_struct));
 590                 __asm__ __volatile__("movl %%esp,%0" : "=r" (esp));
 591                 show_stack((void *)esp);
 592         }
 593 #endif
 594
 595         kstat.irqs[cpu][irq]++;
 596         spin_lock(&desc->lock);
 597         desc->handler->ack(irq);
 598         /*
 599            REPLAY is when Linux resends an IRQ that was dropped earlier
 600            WAITING is used by probe to mark irqs that are being tested
 601            */
 602         status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
 603         status |= IRQ_PENDING; /* we _want_ to handle it */
 604
 605         /*
 606          * If the IRQ is disabled for whatever reason, we cannot
 607          * use the action we have.
 608          */
 609         action = NULL;
 610         if (!(status & (IRQ_DISABLED | IRQ_INPROGRESS))) {
 611                 action = desc->action;
 612                 status &= ~IRQ_PENDING; /* we commit to handling */
 613                 status |= IRQ_INPROGRESS; /* we are handling it */
 614         }
 615         desc->status = status;
 616
 617         /*
 618          * If there is no IRQ handler or it was disabled, exit early.
 619            Since we set PENDING, if another processor is handling
 620            a different instance of this same irq, the other processor
 621            will take care of it.
 622          */
 623         if (!action)
 624                 goto out;
 625
 626         /*
 627          * Edge triggered interrupts need to remember
 628          * pending events.
 629          * This applies to any hw interrupts that allow a second
 630          * instance of the same irq to arrive while we are in do_IRQ
 631          * or in the handler. But the code here only handles the _second_
 632          * instance of the irq, not the third or fourth. So it is mostly
 633          * useful for irq hardware that does not mask cleanly in an
 634          * SMP environment.
 635          */
 636         for (;;) {
 637                 spin_unlock(&desc->lock);
 638                 handle_IRQ_event(irq, &regs, action);
 639                 spin_lock(&desc->lock);
 640
 641                 if (!(desc->status & IRQ_PENDING))
 642                         break;
 643                 desc->status &= ~IRQ_PENDING;
 644         }
 645         desc->status &= ~IRQ_INPROGRESS;
 646 out:
 647         /*
 648          * The ->end() handler has to deal with interrupts which got
 649          * disabled while the handler was running.
 650          */
 651         desc->handler->end(irq);
 652         spin_unlock(&desc->lock);
 653
 654         if (softirq_pending(cpu))
 655                 do_softirq();
 656         return 1;
 657 }
 658
 659 /**
 660  *      request_irq - allocate an interrupt line
 661  *      @irq: Interrupt line to allocate
 662  *      @handler: Function to be called when the IRQ occurs
 663  *      @irqflags: Interrupt type flags
 664  *      @devname: An ascii name for the claiming device
 665  *      @dev_id: A cookie passed back to the handler function
 666  *
 667  *      This call allocates interrupt resources and enables the
 668  *      interrupt line and IRQ handling. From the point this
 669  *      call is made your handler function may be invoked. Since
 670  *      your handler function must clear any interrupt the board
 671  *      raises, you must take care both to initialise your hardware
 672  *      and to set up the interrupt handler in the right order.
 673  *
 674  *      Dev_id must be globally unique. Normally the address of the
 675  *      device data structure is used as the cookie. Since the handler
 676  *      receives this value it makes sense to use it.
 677  *
 678  *      If your interrupt is shared you must pass a non NULL dev_id
 679  *      as this is required when freeing the interrupt.
 680  *
 681  *      Flags:
 682  *
 683  *      SA_SHIRQ                Interrupt is shared
 684  *
 685  *      SA_INTERRUPT            Disable local interrupts while processing
 686  *
 687  *      SA_SAMPLE_RANDOM        The interrupt can be used for entropy
 688  *
 689  */
 690
 691 int request_irq(unsigned int irq,
 692                 void (*handler)(int, void *, struct pt_regs *),
 693                 unsigned long irqflags,
 694                 const char * devname,
 695                 void *dev_id)
 696 {
 697         int retval;
 698         struct irqaction * action;
 699
 700 #if 1
 701         /*
 702          * Sanity-check: shared interrupts should REALLY pass in
 703          * a real dev-ID, otherwise we'll have trouble later trying
 704          * to figure out which interrupt is which (messes up the
 705          * interrupt freeing logic etc).
 706          */
 707         if (irqflags & SA_SHIRQ) {
 708                 if (!dev_id)
 709                         printk("Bad boy: %s (at 0x%x) called us without a dev_id!\n", devname, (&irq)[-1]);
 710         }
 711 #endif
 712
 713         if (irq >= NR_IRQS)
 714                 return -EINVAL;
 715         if (!handler)
 716                 return -EINVAL;
 717
 718         action = (struct irqaction *)
 719                         kmalloc(sizeof(struct irqaction), GFP_KERNEL);
 720         if (!action)
 721                 return -ENOMEM;
 722
 723         action->handler = handler;
 724         action->flags = irqflags;
 725         action->mask = 0;
 726         action->name = devname;
 727         action->next = NULL;
 728         action->dev_id = dev_id;
 729
 730         retval = setup_irq(irq, action);
 731         if (retval)
 732                 kfree(action);
 733         return retval;
 734 }
 735
 736 /**
 737  *      free_irq - free an interrupt
 738  *      @irq: Interrupt line to free
 739  *      @dev_id: Device identity to free
 740  *
 741  *      Remove an interrupt handler. The handler is removed and if the
 742  *      interrupt line is no longer in use by any driver it is disabled.
 743  *      On a shared IRQ the caller must ensure the interrupt is disabled
 744  *      on the card it drives before calling this function. The function
 745  *      does not return until any executing interrupts for this IRQ
 746  *      have completed.
 747  *
 748  *      This function may be called from interrupt context.
 749  *
 750  *      Bugs: Attempting to free an irq in a handler for the same irq hangs
 751  *            the machine.
 752  */
 753
 754 void free_irq(unsigned int irq, void *dev_id)
 755 {
 756         irq_desc_t *desc;
 757         struct irqaction **p;
 758         unsigned long flags;
 759
 760         if (irq >= NR_IRQS)
 761                 return;
 762
 763         desc = irq_desc + irq;
 764         spin_lock_irqsave(&desc->lock,flags);
 765         p = &desc->action;
 766         for (;;) {
 767                 struct irqaction * action = *p;
 768                 if (action) {
 769                         struct irqaction **pp = p;
 770                         p = &action->next;
 771                         if (action->dev_id != dev_id)
 772                                 continue;
 773
 774                         /* Found it - now remove it from the list of entries */
 775                         *pp = action->next;
 776                         if (!desc->action) {
 777                                 desc->status |= IRQ_DISABLED;
 778                                 desc->handler->shutdown(irq);
 779                         }
 780                         spin_unlock_irqrestore(&desc->lock,flags);
 781
 782 #ifdef CONFIG_SMP
 783                         /* Wait to make sure it's not being used on another CPU */
 784                         while (desc->status & IRQ_INPROGRESS) {
 785                                 barrier();
 786                                 cpu_relax();
 787                         }
 788 #endif
 789                         kfree(action);
 790                         return;
 791                 }
 792                 printk("Trying to free free IRQ%d\n",irq);
 793                 spin_unlock_irqrestore(&desc->lock,flags);
 794                 return;
 795         }
 796 }
 797
 798 /*
 799  * IRQ autodetection code..
 800  *
 801  * This depends on the fact that any interrupt that
 802  * comes in on to an unassigned handler will get stuck
 803  * with "IRQ_WAITING" cleared and the interrupt
 804  * disabled.
 805  */
 806
 807 static DECLARE_MUTEX(probe_sem);
 808
 809 /**
 810  *      probe_irq_on    - begin an interrupt autodetect
 811  *
 812  *      Commence probing for an interrupt. The interrupts are scanned
 813  *      and a mask of potential interrupt lines is returned.
 814  *
 815  */
 816
 817 unsigned long probe_irq_on(void)
 818 {
 819         unsigned int i;
 820         irq_desc_t *desc;
 821         unsigned long val;
 822         unsigned long delay;
 823
 824         down(&probe_sem);
 825         /*
 826          * something may have generated an irq long ago and we want to
 827          * flush such a longstanding irq before considering it as spurious.
 828          */
 829         for (i = NR_IRQS-1; i > 0; i--)  {
 830                 desc = irq_desc + i;
 831
 832                 spin_lock_irq(&desc->lock);
 833                 if (!irq_desc[i].action)
 834                         irq_desc[i].handler->startup(i);
 835                 spin_unlock_irq(&desc->lock);
 836         }
 837
 838         /* Wait for longstanding interrupts to trigger. */
 839         for (delay = jiffies + HZ/50; time_after(delay, jiffies); )
 840                 /* about 20ms delay */ synchronize_irq();
 841
 842         /*
 843          * enable any unassigned irqs
 844          * (we must startup again here because if a longstanding irq
 845          * happened in the previous stage, it may have masked itself)
 846          */
 847         for (i = NR_IRQS-1; i > 0; i--) {
 848                 desc = irq_desc + i;
 849
 850                 spin_lock_irq(&desc->lock);
 851                 if (!desc->action) {
 852                         desc->status |= IRQ_AUTODETECT | IRQ_WAITING;
 853                         if (desc->handler->startup(i))
 854                                 desc->status |= IRQ_PENDING;
 855                 }
 856                 spin_unlock_irq(&desc->lock);
 857         }
 858
 859         /*
 860          * Wait for spurious interrupts to trigger
 861          */
 862         for (delay = jiffies + HZ/10; time_after(delay, jiffies); )
 863                 /* about 100ms delay */ synchronize_irq();
 864
 865         /*
 866          * Now filter out any obviously spurious interrupts
 867          */
 868         val = 0;
 869         for (i = 0; i < NR_IRQS; i++) {
 870                 irq_desc_t *desc = irq_desc + i;
 871                 unsigned int status;
 872
 873                 spin_lock_irq(&desc->lock);
 874                 status = desc->status;
 875
 876                 if (status & IRQ_AUTODETECT) {
 877                         /* It triggered already - consider it spurious. */
 878                         if (!(status & IRQ_WAITING)) {
 879                                 desc->status = status & ~IRQ_AUTODETECT;
 880                                 desc->handler->shutdown(i);
 881                         } else
 882                                 if (i < 32)
 883                                         val |= 1 << i;
 884                 }
 885                 spin_unlock_irq(&desc->lock);
 886         }
 887
 888         return val;
 889 }
 890
 891 /*
 892  * Return a mask of triggered interrupts (this
 893  * can handle only legacy ISA interrupts).
 894  */
 895
 896 /**
 897  *      probe_irq_mask - scan a bitmap of interrupt lines
 898  *      @val:   mask of interrupts to consider
 899  *
 900  *      Scan the ISA bus interrupt lines and return a bitmap of
 901  *      active interrupts. The interrupt probe logic state is then
 902  *      returned to its previous value.
 903  *
 904  *      Note: we need to scan all the irq's even though we will
 905  *      only return ISA irq numbers - just so that we reset them
 906  *      all to a known state.
 907  */
 908 unsigned int probe_irq_mask(unsigned long val)
 909 {
 910         int i;
 911         unsigned int mask;
 912
 913         mask = 0;
 914         for (i = 0; i < NR_IRQS; i++) {
 915                 irq_desc_t *desc = irq_desc + i;
 916                 unsigned int status;
 917
 918                 spin_lock_irq(&desc->lock);
 919                 status = desc->status;
 920
 921                 if (status & IRQ_AUTODETECT) {
 922                         if (i < 16 && !(status & IRQ_WAITING))
 923                                 mask |= 1 << i;
 924
 925                         desc->status = status & ~IRQ_AUTODETECT;
 926                         desc->handler->shutdown(i);
 927                 }
 928                 spin_unlock_irq(&desc->lock);
 929         }
 930         up(&probe_sem);
 931
 932         return mask & val;
 933 }
 934
 935 /*
 936  * Return the one interrupt that triggered (this can
 937  * handle any interrupt source).
 938  */
 939
 940 /**
 941  *      probe_irq_off   - end an interrupt autodetect
 942  *      @val: mask of potential interrupts (unused)
 943  *
 944  *      Scans the unused interrupt lines and returns the line which
 945  *      appears to have triggered the interrupt. If no interrupt was
 946  *      found then zero is returned. If more than one interrupt is
 947  *      found then minus the first candidate is returned to indicate
 948  *      their is doubt.
 949  *
 950  *      The interrupt probe logic state is returned to its previous
 951  *      value.
 952  *
 953  *      BUGS: When used in a module (which arguably shouldnt happen)
 954  *      nothing prevents two IRQ probe callers from overlapping. The
 955  *      results of this are non-optimal.
 956  */
 957
 958 int probe_irq_off(unsigned long val)
 959 {
 960         int i, irq_found, nr_irqs;
 961
 962         nr_irqs = 0;
 963         irq_found = 0;
 964         for (i = 0; i < NR_IRQS; i++) {
 965                 irq_desc_t *desc = irq_desc + i;
 966                 unsigned int status;
 967
 968                 spin_lock_irq(&desc->lock);
 969                 status = desc->status;
 970
 971                 if (status & IRQ_AUTODETECT) {
 972                         if (!(status & IRQ_WAITING)) {
 973                                 if (!nr_irqs)
 974                                         irq_found = i;
 975                                 nr_irqs++;
 976                         }
 977                         desc->status = status & ~IRQ_AUTODETECT;
 978                         desc->handler->shutdown(i);
 979                 }
 980                 spin_unlock_irq(&desc->lock);
 981         }
 982         up(&probe_sem);
 983
 984         if (nr_irqs > 1)
 985                 irq_found = -irq_found;
 986         return irq_found;
 987 }
 988
 989 /* this was setup_x86_irq but it seems pretty generic */
 990 int setup_irq(unsigned int irq, struct irqaction * new)
 991 {
 992         int shared = 0;
 993         unsigned long flags;
 994         struct irqaction *old, **p;
 995         irq_desc_t *desc = irq_desc + irq;
 996
 997         /*
 998          * Some drivers like serial.c use request_irq() heavily,
 999          * so we have to be careful not to interfere with a
1000          * running system.
1001          */
1002         if (new->flags & SA_SAMPLE_RANDOM) {
1003                 /*
1004                  * This function might sleep, we want to call it first,
1005                  * outside of the atomic block.
1006                  * Yes, this might clear the entropy pool if the wrong
1007                  * driver is attempted to be loaded, without actually
1008                  * installing a new handler, but is this really a problem,
1009                  * only the sysadmin is able to do this.
1010                  */
1011                 rand_initialize_irq(irq);
1012         }
1013
1014         /*
1015          * The following block of code has to be executed atomically
1016          */
1017         spin_lock_irqsave(&desc->lock,flags);
1018         p = &desc->action;
1019         if ((old = *p) != NULL) {
1020                 /* Can't share interrupts unless both agree to */
1021                 if (!(old->flags & new->flags & SA_SHIRQ)) {
1022                         spin_unlock_irqrestore(&desc->lock,flags);
1023                         return -EBUSY;
1024                 }
1025
1026                 /* add new interrupt at end of irq queue */
1027                 do {
1028                         p = &old->next;
1029                         old = *p;
1030                 } while (old);
1031                 shared = 1;
1032         }
1033
1034         *p = new;
1035
1036         if (!shared) {
1037                 desc->depth = 0;
1038                 desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING);
1039                 desc->handler->startup(irq);
1040         }
1041         spin_unlock_irqrestore(&desc->lock,flags);
1042
1043         register_irq_proc(irq);
1044         return 0;
1045 }
1046
1047 static struct proc_dir_entry * root_irq_dir;
1048 static struct proc_dir_entry * irq_dir [NR_IRQS];
1049
1050 #define HEX_DIGITS 8
1051
1052 static unsigned int parse_hex_value (const char *buffer,
1053                 unsigned long count, unsigned long *ret)
1054 {
1055         unsigned char hexnum [HEX_DIGITS];
1056         unsigned long value;
1057         int i;
1058
1059         if (!count)
1060                 return -EINVAL;
1061         if (count > HEX_DIGITS)
1062                 count = HEX_DIGITS;
1063         if (copy_from_user(hexnum, buffer, count))
1064                 return -EFAULT;
1065
1066         /*
1067          * Parse the first 8 characters as a hex string, any non-hex char
1068          * is end-of-string. '00e1', 'e1', '00E1', 'E1' are all the same.
1069          */
1070         value = 0;
1071
1072         for (i = 0; i < count; i++) {
1073                 unsigned int c = hexnum[i];
1074
1075                 switch (c) {
1076                         case '0' ... '9': c -= '0'; break;
1077                         case 'a' ... 'f': c -= 'a'-10; break;
1078                         case 'A' ... 'F': c -= 'A'-10; break;
1079                 default:
1080                         goto out;
1081                 }
1082                 value = (value << 4) | c;
1083         }
1084 out:
1085         *ret = value;
1086         return 0;
1087 }
1088
1089 #if CONFIG_SMP
1090
1091 static struct proc_dir_entry * smp_affinity_entry [NR_IRQS];
1092
1093 static unsigned long irq_affinity [NR_IRQS] = { [0 ... NR_IRQS-1] = ~0UL };
1094 static int irq_affinity_read_proc (char *page, char **start, off_t off,
1095                         int count, int *eof, void *data)
1096 {
1097         if (count < HEX_DIGITS+1)
1098                 return -EINVAL;
1099         return sprintf (page, "%08lx\n", irq_affinity[(long)data]);
1100 }
1101
1102 static int irq_affinity_write_proc (struct file *file, const char *buffer,
1103                                         unsigned long count, void *data)
1104 {
1105         int irq = (long) data, full_count = count, err;
1106         unsigned long new_value;
1107
1108         if (!irq_desc[irq].handler->set_affinity)
1109                 return -EIO;
1110
1111         err = parse_hex_value(buffer, count, &new_value);
1112
1113         /*
1114          * Do not allow disabling IRQs completely - it's a too easy
1115          * way to make the system unusable accidentally :-) At least
1116          * one online CPU still has to be targeted.
1117          */
1118         if (!(new_value & cpu_online_map))
1119                 return -EINVAL;
1120
1121         irq_affinity[irq] = new_value;
1122         irq_desc[irq].handler->set_affinity(irq, new_value);
1123
1124         return full_count;
1125 }
1126
1127 #endif
1128
1129 static int prof_cpu_mask_read_proc (char *page, char **start, off_t off,
1130                         int count, int *eof, void *data)
1131 {
1132         unsigned long *mask = (unsigned long *) data;
1133         if (count < HEX_DIGITS+1)
1134                 return -EINVAL;
1135         return sprintf (page, "%08lx\n", *mask);
1136 }
1137
1138 static int prof_cpu_mask_write_proc (struct file *file, const char *buffer,
1139                                         unsigned long count, void *data)
1140 {
1141         unsigned long *mask = (unsigned long *) data, full_count = count, err;
1142         unsigned long new_value;
1143
1144         err = parse_hex_value(buffer, count, &new_value);
1145         if (err)
1146                 return err;
1147
1148         *mask = new_value;
1149         return full_count;
1150 }
1151
1152 #define MAX_NAMELEN 10
1153
1154 static void register_irq_proc (unsigned int irq)
1155 {
1156         char name [MAX_NAMELEN];
1157
1158         if (!root_irq_dir || (irq_desc[irq].handler == &no_irq_type) ||
1159                         irq_dir[irq])
1160                 return;
1161
1162         memset(name, 0, MAX_NAMELEN);
1163         sprintf(name, "%d", irq);
1164
1165         /* create /proc/irq/1234 */
1166         irq_dir[irq] = proc_mkdir(name, root_irq_dir);
1167
1168 #if CONFIG_SMP
1169         {
1170                 struct proc_dir_entry *entry;
1171
1172                 /* create /proc/irq/1234/smp_affinity */
1173                 entry = create_proc_entry("smp_affinity", 0600, irq_dir[irq]);
1174
1175                 if (entry) {
1176                         entry->nlink = 1;
1177                         entry->data = (void *)(long)irq;
1178                         entry->read_proc = irq_affinity_read_proc;
1179                         entry->write_proc = irq_affinity_write_proc;
1180                 }
1181
1182                 smp_affinity_entry[irq] = entry;
1183         }
1184 #endif
1185 }
1186
1187 unsigned long prof_cpu_mask = -1;
1188
1189 void init_irq_proc (void)
1190 {
1191         struct proc_dir_entry *entry;
1192         int i;
1193
1194         /* create /proc/irq */
1195         root_irq_dir = proc_mkdir("irq", 0);
1196
1197         /* create /proc/irq/prof_cpu_mask */
1198         entry = create_proc_entry("prof_cpu_mask", 0600, root_irq_dir);
1199
1200         if (!entry)
1201             return;
1202
1203         entry->nlink = 1;
1204         entry->data = (void *)&prof_cpu_mask;
1205         entry->read_proc = prof_cpu_mask_read_proc;
1206         entry->write_proc = prof_cpu_mask_write_proc;
1207
1208         /*
1209          * Create entries for all existing IRQs.
1210          */
1211         for (i = 0; i < NR_IRQS; i++)
1212                 register_irq_proc(i);
1213 }
1214