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 */ 68irq_desc_t irq_desc[NR_IRQS] __cacheline_aligned = 69 { [0 ... NR_IRQS-1] = { 0, &no_irq_type, NULL, 0, SPIN_LOCK_UNLOCKED}}; 70 71static void register_irq_proc (unsigned int irq); 72 73/* 74 * Special irq handlers. 75 */ 76 77void no_action(int cpl, void *dev_id, struct pt_regs *regs) { } 78 79/* 80 * Generic no controller code 81 */ 82 83static void enable_none(unsigned int irq) { } 84static unsigned int startup_none(unsigned int irq) { return 0; } 85static void disable_none(unsigned int irq) { } 86static 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 113struct 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 123atomic_t irq_err_count; 124#ifdef CONFIG_X86_IO_APIC 125#ifdef APIC_MISMATCH_DEBUG 126atomic_t irq_mis_count; 127#endif 128#endif 129 130/* 131 * Generic, controller-independent functions: 132 */ 133 134int 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 192unsigned char global_irq_holder = NO_PROC_ID; 193unsigned volatile long global_irq_lock; /* pendantic: long for set_bit --RR */ 194 195extern void show_stack(unsigned long* esp); 196 197static 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 263static 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 */ 308void synchronize_irq(void) 309{ 310 if (irqs_running()) { 311 /* Stupid approach */ 312 cli(); 313 sti(); 314 } 315} 316 317static 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 */ 356void __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 369void __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 */ 385unsigned 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 407void __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 */ 437int 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 482inline 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 508void 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 531void 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 */ 563asmlinkage 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, ®s, 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; 646out: 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 691int 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 /* 701 * Sanity-check: shared interrupts should REALLY pass in 702 * a real dev-ID, otherwise we'll have trouble later trying 703 * to figure out which interrupt is which (messes up the 704 * interrupt freeing logic etc). 705 */ 706 if (irqflags & SA_SHIRQ) { 707 if (!dev_id) 708 printk("Bad boy: %s (at 0x%x) called us without a dev_id!\n", devname, (&irq)[-1]); 709 } 710 711 if (irq >= NR_IRQS) 712 return -EINVAL; 713 if (!handler) 714 return -EINVAL; 715 716 action = (struct irqaction *) 717 kmalloc(sizeof(struct irqaction), GFP_KERNEL); 718 if (!action) 719 return -ENOMEM; 720 721 action->handler = handler; 722 action->flags = irqflags; 723 action->mask = 0; 724 action->name = devname; 725 action->next = NULL; 726 action->dev_id = dev_id; 727 728 retval = setup_irq(irq, action); 729 if (retval) 730 kfree(action); 731 return retval; 732} 733 734/** 735 * free_irq - free an interrupt 736 * @irq: Interrupt line to free 737 * @dev_id: Device identity to free 738 * 739 * Remove an interrupt handler. The handler is removed and if the 740 * interrupt line is no longer in use by any driver it is disabled. 741 * On a shared IRQ the caller must ensure the interrupt is disabled 742 * on the card it drives before calling this function. The function 743 * does not return until any executing interrupts for this IRQ 744 * have completed. 745 * 746 * This function may be called from interrupt context. 747 * 748 * Bugs: Attempting to free an irq in a handler for the same irq hangs 749 * the machine. 750 */ 751 752void free_irq(unsigned int irq, void *dev_id) 753{ 754 irq_desc_t *desc; 755 struct irqaction **p; 756 unsigned long flags; 757 758 if (irq >= NR_IRQS) 759 return; 760 761 desc = irq_desc + irq; 762 spin_lock_irqsave(&desc->lock,flags); 763 p = &desc->action; 764 for (;;) { 765 struct irqaction * action = *p; 766 if (action) { 767 struct irqaction **pp = p; 768 p = &action->next; 769 if (action->dev_id != dev_id) 770 continue; 771 772 /* Found it - now remove it from the list of entries */ 773 *pp = action->next; 774 if (!desc->action) { 775 desc->status |= IRQ_DISABLED; 776 desc->handler->shutdown(irq); 777 } 778 spin_unlock_irqrestore(&desc->lock,flags); 779 780#ifdef CONFIG_SMP 781 /* Wait to make sure it's not being used on another CPU */ 782 while (desc->status & IRQ_INPROGRESS) { 783 barrier(); 784 cpu_relax(); 785 } 786#endif 787 kfree(action); 788 return; 789 } 790 printk("Trying to free free IRQ%d\n",irq); 791 spin_unlock_irqrestore(&desc->lock,flags); 792 return; 793 } 794} 795 796/* 797 * IRQ autodetection code.. 798 * 799 * This depends on the fact that any interrupt that 800 * comes in on to an unassigned handler will get stuck 801 * with "IRQ_WAITING" cleared and the interrupt 802 * disabled. 803 */ 804 805static DECLARE_MUTEX(probe_sem); 806 807/** 808 * probe_irq_on - begin an interrupt autodetect 809 * 810 * Commence probing for an interrupt. The interrupts are scanned 811 * and a mask of potential interrupt lines is returned. 812 * 813 */ 814 815unsigned long probe_irq_on(void) 816{ 817 unsigned int i; 818 irq_desc_t *desc; 819 unsigned long val; 820 unsigned long delay; 821 822 down(&probe_sem); 823 /* 824 * something may have generated an irq long ago and we want to 825 * flush such a longstanding irq before considering it as spurious. 826 */ 827 for (i = NR_IRQS-1; i > 0; i--) { 828 desc = irq_desc + i; 829 830 spin_lock_irq(&desc->lock); 831 if (!irq_desc[i].action) 832 irq_desc[i].handler->startup(i); 833 spin_unlock_irq(&desc->lock); 834 } 835 836 /* Wait for longstanding interrupts to trigger. */ 837 for (delay = jiffies + HZ/50; time_after(delay, jiffies); ) 838 /* about 20ms delay */ synchronize_irq(); 839 840 /* 841 * enable any unassigned irqs 842 * (we must startup again here because if a longstanding irq 843 * happened in the previous stage, it may have masked itself) 844 */ 845 for (i = NR_IRQS-1; i > 0; i--) { 846 desc = irq_desc + i; 847 848 spin_lock_irq(&desc->lock); 849 if (!desc->action) { 850 desc->status |= IRQ_AUTODETECT | IRQ_WAITING; 851 if (desc->handler->startup(i)) 852 desc->status |= IRQ_PENDING; 853 } 854 spin_unlock_irq(&desc->lock); 855 } 856 857 /* 858 * Wait for spurious interrupts to trigger 859 */ 860 for (delay = jiffies + HZ/10; time_after(delay, jiffies); ) 861 /* about 100ms delay */ synchronize_irq(); 862 863 /* 864 * Now filter out any obviously spurious interrupts 865 */ 866 val = 0; 867 for (i = 0; i < NR_IRQS; i++) { 868 irq_desc_t *desc = irq_desc + i; 869 unsigned int status; 870 871 spin_lock_irq(&desc->lock); 872 status = desc->status; 873 874 if (status & IRQ_AUTODETECT) { 875 /* It triggered already - consider it spurious. */ 876 if (!(status & IRQ_WAITING)) { 877 desc->status = status & ~IRQ_AUTODETECT; 878 desc->handler->shutdown(i); 879 } else 880 if (i < 32) 881 val |= 1 << i; 882 } 883 spin_unlock_irq(&desc->lock); 884 } 885 886 return val; 887} 888 889/* 890 * Return a mask of triggered interrupts (this 891 * can handle only legacy ISA interrupts). 892 */ 893 894/** 895 * probe_irq_mask - scan a bitmap of interrupt lines 896 * @val: mask of interrupts to consider 897 * 898 * Scan the ISA bus interrupt lines and return a bitmap of 899 * active interrupts. The interrupt probe logic state is then 900 * returned to its previous value. 901 * 902 * Note: we need to scan all the irq's even though we will 903 * only return ISA irq numbers - just so that we reset them 904 * all to a known state. 905 */ 906unsigned int probe_irq_mask(unsigned long val) 907{ 908 int i; 909 unsigned int mask; 910 911 mask = 0; 912 for (i = 0; i < NR_IRQS; i++) { 913 irq_desc_t *desc = irq_desc + i; 914 unsigned int status; 915 916 spin_lock_irq(&desc->lock); 917 status = desc->status; 918 919 if (status & IRQ_AUTODETECT) { 920 if (i < 16 && !(status & IRQ_WAITING)) 921 mask |= 1 << i; 922 923 desc->status = status & ~IRQ_AUTODETECT; 924 desc->handler->shutdown(i); 925 } 926 spin_unlock_irq(&desc->lock); 927 } 928 up(&probe_sem); 929 930 return mask & val; 931} 932 933/* 934 * Return the one interrupt that triggered (this can 935 * handle any interrupt source). 936 */ 937 938/** 939 * probe_irq_off - end an interrupt autodetect 940 * @val: mask of potential interrupts (unused) 941 * 942 * Scans the unused interrupt lines and returns the line which 943 * appears to have triggered the interrupt. If no interrupt was 944 * found then zero is returned. If more than one interrupt is 945 * found then minus the first candidate is returned to indicate 946 * their is doubt. 947 * 948 * The interrupt probe logic state is returned to its previous 949 * value. 950 * 951 * BUGS: When used in a module (which arguably shouldnt happen) 952 * nothing prevents two IRQ probe callers from overlapping. The 953 * results of this are non-optimal. 954 */ 955 956int probe_irq_off(unsigned long val) 957{ 958 int i, irq_found, nr_irqs; 959 960 nr_irqs = 0; 961 irq_found = 0; 962 for (i = 0; i < NR_IRQS; i++) { 963 irq_desc_t *desc = irq_desc + i; 964 unsigned int status; 965 966 spin_lock_irq(&desc->lock); 967 status = desc->status; 968 969 if (status & IRQ_AUTODETECT) { 970 if (!(status & IRQ_WAITING)) { 971 if (!nr_irqs) 972 irq_found = i; 973 nr_irqs++; 974 } 975 desc->status = status & ~IRQ_AUTODETECT; 976 desc->handler->shutdown(i); 977 } 978 spin_unlock_irq(&desc->lock); 979 } 980 up(&probe_sem); 981 982 if (nr_irqs > 1) 983 irq_found = -irq_found; 984 return irq_found; 985} 986 987/* this was setup_x86_irq but it seems pretty generic */ 988int setup_irq(unsigned int irq, struct irqaction * new) 989{ 990 int shared = 0; 991 unsigned long flags; 992 struct irqaction *old, **p; 993 irq_desc_t *desc = irq_desc + irq; 994 995 /* 996 * Some drivers like serial.c use request_irq() heavily, 997 * so we have to be careful not to interfere with a 998 * running system. 999 */ 1000 if (new->flags & SA_SAMPLE_RANDOM) { 1001 /* 1002 * This function might sleep, we want to call it first, 1003 * outside of the atomic block. 1004 * Yes, this might clear the entropy pool if the wrong 1005 * driver is attempted to be loaded, without actually 1006 * installing a new handler, but is this really a problem, 1007 * only the sysadmin is able to do this. 1008 */ 1009 rand_initialize_irq(irq); 1010 } 1011 1012 /* 1013 * The following block of code has to be executed atomically 1014 */ 1015 spin_lock_irqsave(&desc->lock,flags); 1016 p = &desc->action; 1017 if ((old = *p) != NULL) { 1018 /* Can't share interrupts unless both agree to */ 1019 if (!(old->flags & new->flags & SA_SHIRQ)) { 1020 spin_unlock_irqrestore(&desc->lock,flags); 1021 return -EBUSY; 1022 } 1023 1024 /* add new interrupt at end of irq queue */ 1025 do { 1026 p = &old->next; 1027 old = *p; 1028 } while (old); 1029 shared = 1; 1030 } 1031 1032 *p = new; 1033 1034 if (!shared) { 1035 desc->depth = 0; 1036 desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | IRQ_WAITING); 1037 desc->handler->startup(irq); 1038 } 1039 spin_unlock_irqrestore(&desc->lock,flags); 1040 1041 register_irq_proc(irq); 1042 return 0; 1043} 1044 1045static struct proc_dir_entry * root_irq_dir; 1046static struct proc_dir_entry * irq_dir [NR_IRQS]; 1047 1048#define HEX_DIGITS 8 1049 1050static unsigned int parse_hex_value (const char *buffer, 1051 unsigned long count, unsigned long *ret) 1052{ 1053 unsigned char hexnum [HEX_DIGITS]; 1054 unsigned long value; 1055 int i; 1056 1057 if (!count) 1058 return -EINVAL; 1059 if (count > HEX_DIGITS) 1060 count = HEX_DIGITS; 1061 if (copy_from_user(hexnum, buffer, count)) 1062 return -EFAULT; 1063 1064 /* 1065 * Parse the first 8 characters as a hex string, any non-hex char 1066 * is end-of-string. '00e1', 'e1', '00E1', 'E1' are all the same. 1067 */ 1068 value = 0; 1069 1070 for (i = 0; i < count; i++) { 1071 unsigned int c = hexnum[i]; 1072 1073 switch (c) { 1074 case '0' ... '9': c -= '0'; break; 1075 case 'a' ... 'f': c -= 'a'-10; break; 1076 case 'A' ... 'F': c -= 'A'-10; break; 1077 default: 1078 goto out; 1079 } 1080 value = (value << 4) | c; 1081 } 1082out: 1083 *ret = value; 1084 return 0; 1085} 1086 1087#if CONFIG_SMP 1088 1089static struct proc_dir_entry * smp_affinity_entry [NR_IRQS]; 1090 1091static unsigned long irq_affinity [NR_IRQS] = { [0 ... NR_IRQS-1] = ~0UL }; 1092static int irq_affinity_read_proc (char *page, char **start, off_t off, 1093 int count, int *eof, void *data) 1094{ 1095 if (count < HEX_DIGITS+1) 1096 return -EINVAL; 1097 return sprintf (page, "%08lx\n", irq_affinity[(long)data]); 1098} 1099 1100static int irq_affinity_write_proc (struct file *file, const char *buffer, 1101 unsigned long count, void *data) 1102{ 1103 int irq = (long) data, full_count = count, err; 1104 unsigned long new_value; 1105 1106 if (!irq_desc[irq].handler->set_affinity) 1107 return -EIO; 1108 1109 err = parse_hex_value(buffer, count, &new_value); 1110 1111 /* 1112 * Do not allow disabling IRQs completely - it's a too easy 1113 * way to make the system unusable accidentally :-) At least 1114 * one online CPU still has to be targeted. 1115 */ 1116 if (!(new_value & cpu_online_map)) 1117 return -EINVAL; 1118 1119 irq_affinity[irq] = new_value; 1120 irq_desc[irq].handler->set_affinity(irq, new_value); 1121 1122 return full_count; 1123} 1124 1125#endif 1126 1127#define MAX_NAMELEN 10 1128 1129static void register_irq_proc (unsigned int irq) 1130{ 1131 char name [MAX_NAMELEN]; 1132 1133 if (!root_irq_dir || (irq_desc[irq].handler == &no_irq_type) || 1134 irq_dir[irq]) 1135 return; 1136 1137 memset(name, 0, MAX_NAMELEN); 1138 sprintf(name, "%d", irq); 1139 1140 /* create /proc/irq/1234 */ 1141 irq_dir[irq] = proc_mkdir(name, root_irq_dir); 1142 1143#if CONFIG_SMP 1144 { 1145 struct proc_dir_entry *entry; 1146 1147 /* create /proc/irq/1234/smp_affinity */ 1148 entry = create_proc_entry("smp_affinity", 0600, irq_dir[irq]); 1149 1150 if (entry) { 1151 entry->nlink = 1; 1152 entry->data = (void *)(long)irq; 1153 entry->read_proc = irq_affinity_read_proc; 1154 entry->write_proc = irq_affinity_write_proc; 1155 } 1156 1157 smp_affinity_entry[irq] = entry; 1158 } 1159#endif 1160} 1161 1162void init_irq_proc (void) 1163{ 1164 int i; 1165 1166 /* create /proc/irq */ 1167 root_irq_dir = proc_mkdir("irq", 0); 1168 1169 /* 1170 * Create entries for all existing IRQs. 1171 */ 1172 for (i = 0; i < NR_IRQS; i++) 1173 register_irq_proc(i); 1174} 1175 1176