1 /* 2 * linux/kernel/irq/manage.c 3 * 4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar 5 * Copyright (C) 2005-2006 Thomas Gleixner 6 * 7 * This file contains driver APIs to the irq subsystem. 8 */ 9 10 #define pr_fmt(fmt) "genirq: " fmt 11 12 #include <linux/irq.h> 13 #include <linux/kthread.h> 14 #include <linux/module.h> 15 #include <linux/random.h> 16 #include <linux/interrupt.h> 17 #include <linux/slab.h> 18 #include <linux/sched.h> 19 #include <linux/task_work.h> 20 21 #include "internals.h" 22 23 #ifdef CONFIG_IRQ_FORCED_THREADING 24 __read_mostly bool force_irqthreads; 25 26 static int __init setup_forced_irqthreads(char *arg) 27 { 28 force_irqthreads = true; 29 return 0; 30 } 31 early_param("threadirqs", setup_forced_irqthreads); 32 #endif 33 34 /** 35 * synchronize_irq - wait for pending IRQ handlers (on other CPUs) 36 * @irq: interrupt number to wait for 37 * 38 * This function waits for any pending IRQ handlers for this interrupt 39 * to complete before returning. If you use this function while 40 * holding a resource the IRQ handler may need you will deadlock. 41 * 42 * This function may be called - with care - from IRQ context. 43 */ 44 void synchronize_irq(unsigned int irq) 45 { 46 struct irq_desc *desc = irq_to_desc(irq); 47 bool inprogress; 48 49 if (!desc) 50 return; 51 52 do { 53 unsigned long flags; 54 55 /* 56 * Wait until we're out of the critical section. This might 57 * give the wrong answer due to the lack of memory barriers. 58 */ 59 while (irqd_irq_inprogress(&desc->irq_data)) 60 cpu_relax(); 61 62 /* Ok, that indicated we're done: double-check carefully. */ 63 raw_spin_lock_irqsave(&desc->lock, flags); 64 inprogress = irqd_irq_inprogress(&desc->irq_data); 65 raw_spin_unlock_irqrestore(&desc->lock, flags); 66 67 /* Oops, that failed? */ 68 } while (inprogress); 69 70 /* 71 * We made sure that no hardirq handler is running. Now verify 72 * that no threaded handlers are active. 73 */ 74 wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active)); 75 } 76 EXPORT_SYMBOL(synchronize_irq); 77 78 #ifdef CONFIG_SMP 79 cpumask_var_t irq_default_affinity; 80 81 /** 82 * irq_can_set_affinity - Check if the affinity of a given irq can be set 83 * @irq: Interrupt to check 84 * 85 */ 86 int irq_can_set_affinity(unsigned int irq) 87 { 88 struct irq_desc *desc = irq_to_desc(irq); 89 90 if (!desc || !irqd_can_balance(&desc->irq_data) || 91 !desc->irq_data.chip || !desc->irq_data.chip->irq_set_affinity) 92 return 0; 93 94 return 1; 95 } 96 97 /** 98 * irq_set_thread_affinity - Notify irq threads to adjust affinity 99 * @desc: irq descriptor which has affitnity changed 100 * 101 * We just set IRQTF_AFFINITY and delegate the affinity setting 102 * to the interrupt thread itself. We can not call 103 * set_cpus_allowed_ptr() here as we hold desc->lock and this 104 * code can be called from hard interrupt context. 105 */ 106 void irq_set_thread_affinity(struct irq_desc *desc) 107 { 108 struct irqaction *action = desc->action; 109 110 while (action) { 111 if (action->thread) 112 set_bit(IRQTF_AFFINITY, &action->thread_flags); 113 action = action->next; 114 } 115 } 116 117 #ifdef CONFIG_GENERIC_PENDING_IRQ 118 static inline bool irq_can_move_pcntxt(struct irq_data *data) 119 { 120 return irqd_can_move_in_process_context(data); 121 } 122 static inline bool irq_move_pending(struct irq_data *data) 123 { 124 return irqd_is_setaffinity_pending(data); 125 } 126 static inline void 127 irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) 128 { 129 cpumask_copy(desc->pending_mask, mask); 130 } 131 static inline void 132 irq_get_pending(struct cpumask *mask, struct irq_desc *desc) 133 { 134 cpumask_copy(mask, desc->pending_mask); 135 } 136 #else 137 static inline bool irq_can_move_pcntxt(struct irq_data *data) { return true; } 138 static inline bool irq_move_pending(struct irq_data *data) { return false; } 139 static inline void 140 irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) { } 141 static inline void 142 irq_get_pending(struct cpumask *mask, struct irq_desc *desc) { } 143 #endif 144 145 int irq_do_set_affinity(struct irq_data *data, const struct cpumask *mask, 146 bool force) 147 { 148 struct irq_desc *desc = irq_data_to_desc(data); 149 struct irq_chip *chip = irq_data_get_irq_chip(data); 150 int ret; 151 152 ret = chip->irq_set_affinity(data, mask, false); 153 switch (ret) { 154 case IRQ_SET_MASK_OK: 155 cpumask_copy(data->affinity, mask); 156 case IRQ_SET_MASK_OK_NOCOPY: 157 irq_set_thread_affinity(desc); 158 ret = 0; 159 } 160 161 return ret; 162 } 163 164 int __irq_set_affinity_locked(struct irq_data *data, const struct cpumask *mask) 165 { 166 struct irq_chip *chip = irq_data_get_irq_chip(data); 167 struct irq_desc *desc = irq_data_to_desc(data); 168 int ret = 0; 169 170 if (!chip || !chip->irq_set_affinity) 171 return -EINVAL; 172 173 if (irq_can_move_pcntxt(data)) { 174 ret = irq_do_set_affinity(data, mask, false); 175 } else { 176 irqd_set_move_pending(data); 177 irq_copy_pending(desc, mask); 178 } 179 180 if (desc->affinity_notify) { 181 kref_get(&desc->affinity_notify->kref); 182 schedule_work(&desc->affinity_notify->work); 183 } 184 irqd_set(data, IRQD_AFFINITY_SET); 185 186 return ret; 187 } 188 189 /** 190 * irq_set_affinity - Set the irq affinity of a given irq 191 * @irq: Interrupt to set affinity 192 * @mask: cpumask 193 * 194 */ 195 int irq_set_affinity(unsigned int irq, const struct cpumask *mask) 196 { 197 struct irq_desc *desc = irq_to_desc(irq); 198 unsigned long flags; 199 int ret; 200 201 if (!desc) 202 return -EINVAL; 203 204 raw_spin_lock_irqsave(&desc->lock, flags); 205 ret = __irq_set_affinity_locked(irq_desc_get_irq_data(desc), mask); 206 raw_spin_unlock_irqrestore(&desc->lock, flags); 207 return ret; 208 } 209 210 int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m) 211 { 212 unsigned long flags; 213 struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL); 214 215 if (!desc) 216 return -EINVAL; 217 desc->affinity_hint = m; 218 irq_put_desc_unlock(desc, flags); 219 return 0; 220 } 221 EXPORT_SYMBOL_GPL(irq_set_affinity_hint); 222 223 static void irq_affinity_notify(struct work_struct *work) 224 { 225 struct irq_affinity_notify *notify = 226 container_of(work, struct irq_affinity_notify, work); 227 struct irq_desc *desc = irq_to_desc(notify->irq); 228 cpumask_var_t cpumask; 229 unsigned long flags; 230 231 if (!desc || !alloc_cpumask_var(&cpumask, GFP_KERNEL)) 232 goto out; 233 234 raw_spin_lock_irqsave(&desc->lock, flags); 235 if (irq_move_pending(&desc->irq_data)) 236 irq_get_pending(cpumask, desc); 237 else 238 cpumask_copy(cpumask, desc->irq_data.affinity); 239 raw_spin_unlock_irqrestore(&desc->lock, flags); 240 241 notify->notify(notify, cpumask); 242 243 free_cpumask_var(cpumask); 244 out: 245 kref_put(¬ify->kref, notify->release); 246 } 247 248 /** 249 * irq_set_affinity_notifier - control notification of IRQ affinity changes 250 * @irq: Interrupt for which to enable/disable notification 251 * @notify: Context for notification, or %NULL to disable 252 * notification. Function pointers must be initialised; 253 * the other fields will be initialised by this function. 254 * 255 * Must be called in process context. Notification may only be enabled 256 * after the IRQ is allocated and must be disabled before the IRQ is 257 * freed using free_irq(). 258 */ 259 int 260 irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify) 261 { 262 struct irq_desc *desc = irq_to_desc(irq); 263 struct irq_affinity_notify *old_notify; 264 unsigned long flags; 265 266 /* The release function is promised process context */ 267 might_sleep(); 268 269 if (!desc) 270 return -EINVAL; 271 272 /* Complete initialisation of *notify */ 273 if (notify) { 274 notify->irq = irq; 275 kref_init(¬ify->kref); 276 INIT_WORK(¬ify->work, irq_affinity_notify); 277 } 278 279 raw_spin_lock_irqsave(&desc->lock, flags); 280 old_notify = desc->affinity_notify; 281 desc->affinity_notify = notify; 282 raw_spin_unlock_irqrestore(&desc->lock, flags); 283 284 if (old_notify) 285 kref_put(&old_notify->kref, old_notify->release); 286 287 return 0; 288 } 289 EXPORT_SYMBOL_GPL(irq_set_affinity_notifier); 290 291 #ifndef CONFIG_AUTO_IRQ_AFFINITY 292 /* 293 * Generic version of the affinity autoselector. 294 */ 295 static int 296 setup_affinity(unsigned int irq, struct irq_desc *desc, struct cpumask *mask) 297 { 298 struct cpumask *set = irq_default_affinity; 299 int node = desc->irq_data.node; 300 301 /* Excludes PER_CPU and NO_BALANCE interrupts */ 302 if (!irq_can_set_affinity(irq)) 303 return 0; 304 305 /* 306 * Preserve an userspace affinity setup, but make sure that 307 * one of the targets is online. 308 */ 309 if (irqd_has_set(&desc->irq_data, IRQD_AFFINITY_SET)) { 310 if (cpumask_intersects(desc->irq_data.affinity, 311 cpu_online_mask)) 312 set = desc->irq_data.affinity; 313 else 314 irqd_clear(&desc->irq_data, IRQD_AFFINITY_SET); 315 } 316 317 cpumask_and(mask, cpu_online_mask, set); 318 if (node != NUMA_NO_NODE) { 319 const struct cpumask *nodemask = cpumask_of_node(node); 320 321 /* make sure at least one of the cpus in nodemask is online */ 322 if (cpumask_intersects(mask, nodemask)) 323 cpumask_and(mask, mask, nodemask); 324 } 325 irq_do_set_affinity(&desc->irq_data, mask, false); 326 return 0; 327 } 328 #else 329 static inline int 330 setup_affinity(unsigned int irq, struct irq_desc *d, struct cpumask *mask) 331 { 332 return irq_select_affinity(irq); 333 } 334 #endif 335 336 /* 337 * Called when affinity is set via /proc/irq 338 */ 339 int irq_select_affinity_usr(unsigned int irq, struct cpumask *mask) 340 { 341 struct irq_desc *desc = irq_to_desc(irq); 342 unsigned long flags; 343 int ret; 344 345 raw_spin_lock_irqsave(&desc->lock, flags); 346 ret = setup_affinity(irq, desc, mask); 347 raw_spin_unlock_irqrestore(&desc->lock, flags); 348 return ret; 349 } 350 351 #else 352 static inline int 353 setup_affinity(unsigned int irq, struct irq_desc *desc, struct cpumask *mask) 354 { 355 return 0; 356 } 357 #endif 358 359 void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend) 360 { 361 if (suspend) { 362 if (!desc->action || (desc->action->flags & IRQF_NO_SUSPEND)) 363 return; 364 desc->istate |= IRQS_SUSPENDED; 365 } 366 367 if (!desc->depth++) 368 irq_disable(desc); 369 } 370 371 static int __disable_irq_nosync(unsigned int irq) 372 { 373 unsigned long flags; 374 struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL); 375 376 if (!desc) 377 return -EINVAL; 378 __disable_irq(desc, irq, false); 379 irq_put_desc_busunlock(desc, flags); 380 return 0; 381 } 382 383 /** 384 * disable_irq_nosync - disable an irq without waiting 385 * @irq: Interrupt to disable 386 * 387 * Disable the selected interrupt line. Disables and Enables are 388 * nested. 389 * Unlike disable_irq(), this function does not ensure existing 390 * instances of the IRQ handler have completed before returning. 391 * 392 * This function may be called from IRQ context. 393 */ 394 void disable_irq_nosync(unsigned int irq) 395 { 396 __disable_irq_nosync(irq); 397 } 398 EXPORT_SYMBOL(disable_irq_nosync); 399 400 /** 401 * disable_irq - disable an irq and wait for completion 402 * @irq: Interrupt to disable 403 * 404 * Disable the selected interrupt line. Enables and Disables are 405 * nested. 406 * This function waits for any pending IRQ handlers for this interrupt 407 * to complete before returning. If you use this function while 408 * holding a resource the IRQ handler may need you will deadlock. 409 * 410 * This function may be called - with care - from IRQ context. 411 */ 412 void disable_irq(unsigned int irq) 413 { 414 if (!__disable_irq_nosync(irq)) 415 synchronize_irq(irq); 416 } 417 EXPORT_SYMBOL(disable_irq); 418 419 void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume) 420 { 421 if (resume) { 422 if (!(desc->istate & IRQS_SUSPENDED)) { 423 if (!desc->action) 424 return; 425 if (!(desc->action->flags & IRQF_FORCE_RESUME)) 426 return; 427 /* Pretend that it got disabled ! */ 428 desc->depth++; 429 } 430 desc->istate &= ~IRQS_SUSPENDED; 431 } 432 433 switch (desc->depth) { 434 case 0: 435 err_out: 436 WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq); 437 break; 438 case 1: { 439 if (desc->istate & IRQS_SUSPENDED) 440 goto err_out; 441 /* Prevent probing on this irq: */ 442 irq_settings_set_noprobe(desc); 443 irq_enable(desc); 444 check_irq_resend(desc, irq); 445 /* fall-through */ 446 } 447 default: 448 desc->depth--; 449 } 450 } 451 452 /** 453 * enable_irq - enable handling of an irq 454 * @irq: Interrupt to enable 455 * 456 * Undoes the effect of one call to disable_irq(). If this 457 * matches the last disable, processing of interrupts on this 458 * IRQ line is re-enabled. 459 * 460 * This function may be called from IRQ context only when 461 * desc->irq_data.chip->bus_lock and desc->chip->bus_sync_unlock are NULL ! 462 */ 463 void enable_irq(unsigned int irq) 464 { 465 unsigned long flags; 466 struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL); 467 468 if (!desc) 469 return; 470 if (WARN(!desc->irq_data.chip, 471 KERN_ERR "enable_irq before setup/request_irq: irq %u\n", irq)) 472 goto out; 473 474 __enable_irq(desc, irq, false); 475 out: 476 irq_put_desc_busunlock(desc, flags); 477 } 478 EXPORT_SYMBOL(enable_irq); 479 480 static int set_irq_wake_real(unsigned int irq, unsigned int on) 481 { 482 struct irq_desc *desc = irq_to_desc(irq); 483 int ret = -ENXIO; 484 485 if (irq_desc_get_chip(desc)->flags & IRQCHIP_SKIP_SET_WAKE) 486 return 0; 487 488 if (desc->irq_data.chip->irq_set_wake) 489 ret = desc->irq_data.chip->irq_set_wake(&desc->irq_data, on); 490 491 return ret; 492 } 493 494 /** 495 * irq_set_irq_wake - control irq power management wakeup 496 * @irq: interrupt to control 497 * @on: enable/disable power management wakeup 498 * 499 * Enable/disable power management wakeup mode, which is 500 * disabled by default. Enables and disables must match, 501 * just as they match for non-wakeup mode support. 502 * 503 * Wakeup mode lets this IRQ wake the system from sleep 504 * states like "suspend to RAM". 505 */ 506 int irq_set_irq_wake(unsigned int irq, unsigned int on) 507 { 508 unsigned long flags; 509 struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL); 510 int ret = 0; 511 512 if (!desc) 513 return -EINVAL; 514 515 /* wakeup-capable irqs can be shared between drivers that 516 * don't need to have the same sleep mode behaviors. 517 */ 518 if (on) { 519 if (desc->wake_depth++ == 0) { 520 ret = set_irq_wake_real(irq, on); 521 if (ret) 522 desc->wake_depth = 0; 523 else 524 irqd_set(&desc->irq_data, IRQD_WAKEUP_STATE); 525 } 526 } else { 527 if (desc->wake_depth == 0) { 528 WARN(1, "Unbalanced IRQ %d wake disable\n", irq); 529 } else if (--desc->wake_depth == 0) { 530 ret = set_irq_wake_real(irq, on); 531 if (ret) 532 desc->wake_depth = 1; 533 else 534 irqd_clear(&desc->irq_data, IRQD_WAKEUP_STATE); 535 } 536 } 537 irq_put_desc_busunlock(desc, flags); 538 return ret; 539 } 540 EXPORT_SYMBOL(irq_set_irq_wake); 541 542 /* 543 * Internal function that tells the architecture code whether a 544 * particular irq has been exclusively allocated or is available 545 * for driver use. 546 */ 547 int can_request_irq(unsigned int irq, unsigned long irqflags) 548 { 549 unsigned long flags; 550 struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0); 551 int canrequest = 0; 552 553 if (!desc) 554 return 0; 555 556 if (irq_settings_can_request(desc)) { 557 if (desc->action) 558 if (irqflags & desc->action->flags & IRQF_SHARED) 559 canrequest =1; 560 } 561 irq_put_desc_unlock(desc, flags); 562 return canrequest; 563 } 564 565 int __irq_set_trigger(struct irq_desc *desc, unsigned int irq, 566 unsigned long flags) 567 { 568 struct irq_chip *chip = desc->irq_data.chip; 569 int ret, unmask = 0; 570 571 if (!chip || !chip->irq_set_type) { 572 /* 573 * IRQF_TRIGGER_* but the PIC does not support multiple 574 * flow-types? 575 */ 576 pr_debug("No set_type function for IRQ %d (%s)\n", irq, 577 chip ? (chip->name ? : "unknown") : "unknown"); 578 return 0; 579 } 580 581 flags &= IRQ_TYPE_SENSE_MASK; 582 583 if (chip->flags & IRQCHIP_SET_TYPE_MASKED) { 584 if (!irqd_irq_masked(&desc->irq_data)) 585 mask_irq(desc); 586 if (!irqd_irq_disabled(&desc->irq_data)) 587 unmask = 1; 588 } 589 590 /* caller masked out all except trigger mode flags */ 591 ret = chip->irq_set_type(&desc->irq_data, flags); 592 593 switch (ret) { 594 case IRQ_SET_MASK_OK: 595 irqd_clear(&desc->irq_data, IRQD_TRIGGER_MASK); 596 irqd_set(&desc->irq_data, flags); 597 598 case IRQ_SET_MASK_OK_NOCOPY: 599 flags = irqd_get_trigger_type(&desc->irq_data); 600 irq_settings_set_trigger_mask(desc, flags); 601 irqd_clear(&desc->irq_data, IRQD_LEVEL); 602 irq_settings_clr_level(desc); 603 if (flags & IRQ_TYPE_LEVEL_MASK) { 604 irq_settings_set_level(desc); 605 irqd_set(&desc->irq_data, IRQD_LEVEL); 606 } 607 608 ret = 0; 609 break; 610 default: 611 pr_err("Setting trigger mode %lu for irq %u failed (%pF)\n", 612 flags, irq, chip->irq_set_type); 613 } 614 if (unmask) 615 unmask_irq(desc); 616 return ret; 617 } 618 619 #ifdef CONFIG_HARDIRQS_SW_RESEND 620 int irq_set_parent(int irq, int parent_irq) 621 { 622 unsigned long flags; 623 struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0); 624 625 if (!desc) 626 return -EINVAL; 627 628 desc->parent_irq = parent_irq; 629 630 irq_put_desc_unlock(desc, flags); 631 return 0; 632 } 633 #endif 634 635 /* 636 * Default primary interrupt handler for threaded interrupts. Is 637 * assigned as primary handler when request_threaded_irq is called 638 * with handler == NULL. Useful for oneshot interrupts. 639 */ 640 static irqreturn_t irq_default_primary_handler(int irq, void *dev_id) 641 { 642 return IRQ_WAKE_THREAD; 643 } 644 645 /* 646 * Primary handler for nested threaded interrupts. Should never be 647 * called. 648 */ 649 static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id) 650 { 651 WARN(1, "Primary handler called for nested irq %d\n", irq); 652 return IRQ_NONE; 653 } 654 655 static int irq_wait_for_interrupt(struct irqaction *action) 656 { 657 set_current_state(TASK_INTERRUPTIBLE); 658 659 while (!kthread_should_stop()) { 660 661 if (test_and_clear_bit(IRQTF_RUNTHREAD, 662 &action->thread_flags)) { 663 __set_current_state(TASK_RUNNING); 664 return 0; 665 } 666 schedule(); 667 set_current_state(TASK_INTERRUPTIBLE); 668 } 669 __set_current_state(TASK_RUNNING); 670 return -1; 671 } 672 673 /* 674 * Oneshot interrupts keep the irq line masked until the threaded 675 * handler finished. unmask if the interrupt has not been disabled and 676 * is marked MASKED. 677 */ 678 static void irq_finalize_oneshot(struct irq_desc *desc, 679 struct irqaction *action) 680 { 681 if (!(desc->istate & IRQS_ONESHOT)) 682 return; 683 again: 684 chip_bus_lock(desc); 685 raw_spin_lock_irq(&desc->lock); 686 687 /* 688 * Implausible though it may be we need to protect us against 689 * the following scenario: 690 * 691 * The thread is faster done than the hard interrupt handler 692 * on the other CPU. If we unmask the irq line then the 693 * interrupt can come in again and masks the line, leaves due 694 * to IRQS_INPROGRESS and the irq line is masked forever. 695 * 696 * This also serializes the state of shared oneshot handlers 697 * versus "desc->threads_onehsot |= action->thread_mask;" in 698 * irq_wake_thread(). See the comment there which explains the 699 * serialization. 700 */ 701 if (unlikely(irqd_irq_inprogress(&desc->irq_data))) { 702 raw_spin_unlock_irq(&desc->lock); 703 chip_bus_sync_unlock(desc); 704 cpu_relax(); 705 goto again; 706 } 707 708 /* 709 * Now check again, whether the thread should run. Otherwise 710 * we would clear the threads_oneshot bit of this thread which 711 * was just set. 712 */ 713 if (test_bit(IRQTF_RUNTHREAD, &action->thread_flags)) 714 goto out_unlock; 715 716 desc->threads_oneshot &= ~action->thread_mask; 717 718 if (!desc->threads_oneshot && !irqd_irq_disabled(&desc->irq_data) && 719 irqd_irq_masked(&desc->irq_data)) 720 unmask_irq(desc); 721 722 out_unlock: 723 raw_spin_unlock_irq(&desc->lock); 724 chip_bus_sync_unlock(desc); 725 } 726 727 #ifdef CONFIG_SMP 728 /* 729 * Check whether we need to chasnge the affinity of the interrupt thread. 730 */ 731 static void 732 irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) 733 { 734 cpumask_var_t mask; 735 bool valid = true; 736 737 if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags)) 738 return; 739 740 /* 741 * In case we are out of memory we set IRQTF_AFFINITY again and 742 * try again next time 743 */ 744 if (!alloc_cpumask_var(&mask, GFP_KERNEL)) { 745 set_bit(IRQTF_AFFINITY, &action->thread_flags); 746 return; 747 } 748 749 raw_spin_lock_irq(&desc->lock); 750 /* 751 * This code is triggered unconditionally. Check the affinity 752 * mask pointer. For CPU_MASK_OFFSTACK=n this is optimized out. 753 */ 754 if (desc->irq_data.affinity) 755 cpumask_copy(mask, desc->irq_data.affinity); 756 else 757 valid = false; 758 raw_spin_unlock_irq(&desc->lock); 759 760 if (valid) 761 set_cpus_allowed_ptr(current, mask); 762 free_cpumask_var(mask); 763 } 764 #else 765 static inline void 766 irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) { } 767 #endif 768 769 /* 770 * Interrupts which are not explicitely requested as threaded 771 * interrupts rely on the implicit bh/preempt disable of the hard irq 772 * context. So we need to disable bh here to avoid deadlocks and other 773 * side effects. 774 */ 775 static irqreturn_t 776 irq_forced_thread_fn(struct irq_desc *desc, struct irqaction *action) 777 { 778 irqreturn_t ret; 779 780 local_bh_disable(); 781 ret = action->thread_fn(action->irq, action->dev_id); 782 irq_finalize_oneshot(desc, action); 783 local_bh_enable(); 784 return ret; 785 } 786 787 /* 788 * Interrupts explicitely requested as threaded interupts want to be 789 * preemtible - many of them need to sleep and wait for slow busses to 790 * complete. 791 */ 792 static irqreturn_t irq_thread_fn(struct irq_desc *desc, 793 struct irqaction *action) 794 { 795 irqreturn_t ret; 796 797 ret = action->thread_fn(action->irq, action->dev_id); 798 irq_finalize_oneshot(desc, action); 799 return ret; 800 } 801 802 static void wake_threads_waitq(struct irq_desc *desc) 803 { 804 if (atomic_dec_and_test(&desc->threads_active) && 805 waitqueue_active(&desc->wait_for_threads)) 806 wake_up(&desc->wait_for_threads); 807 } 808 809 static void irq_thread_dtor(struct callback_head *unused) 810 { 811 struct task_struct *tsk = current; 812 struct irq_desc *desc; 813 struct irqaction *action; 814 815 if (WARN_ON_ONCE(!(current->flags & PF_EXITING))) 816 return; 817 818 action = kthread_data(tsk); 819 820 pr_err("exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n", 821 tsk->comm, tsk->pid, action->irq); 822 823 824 desc = irq_to_desc(action->irq); 825 /* 826 * If IRQTF_RUNTHREAD is set, we need to decrement 827 * desc->threads_active and wake possible waiters. 828 */ 829 if (test_and_clear_bit(IRQTF_RUNTHREAD, &action->thread_flags)) 830 wake_threads_waitq(desc); 831 832 /* Prevent a stale desc->threads_oneshot */ 833 irq_finalize_oneshot(desc, action); 834 } 835 836 /* 837 * Interrupt handler thread 838 */ 839 static int irq_thread(void *data) 840 { 841 struct callback_head on_exit_work; 842 static const struct sched_param param = { 843 .sched_priority = MAX_USER_RT_PRIO/2, 844 }; 845 struct irqaction *action = data; 846 struct irq_desc *desc = irq_to_desc(action->irq); 847 irqreturn_t (*handler_fn)(struct irq_desc *desc, 848 struct irqaction *action); 849 850 if (force_irqthreads && test_bit(IRQTF_FORCED_THREAD, 851 &action->thread_flags)) 852 handler_fn = irq_forced_thread_fn; 853 else 854 handler_fn = irq_thread_fn; 855 856 sched_setscheduler(current, SCHED_FIFO, ¶m); 857 858 init_task_work(&on_exit_work, irq_thread_dtor); 859 task_work_add(current, &on_exit_work, false); 860 861 irq_thread_check_affinity(desc, action); 862 863 while (!irq_wait_for_interrupt(action)) { 864 irqreturn_t action_ret; 865 866 irq_thread_check_affinity(desc, action); 867 868 action_ret = handler_fn(desc, action); 869 if (!noirqdebug) 870 note_interrupt(action->irq, desc, action_ret); 871 872 wake_threads_waitq(desc); 873 } 874 875 /* 876 * This is the regular exit path. __free_irq() is stopping the 877 * thread via kthread_stop() after calling 878 * synchronize_irq(). So neither IRQTF_RUNTHREAD nor the 879 * oneshot mask bit can be set. We cannot verify that as we 880 * cannot touch the oneshot mask at this point anymore as 881 * __setup_irq() might have given out currents thread_mask 882 * again. 883 */ 884 task_work_cancel(current, irq_thread_dtor); 885 return 0; 886 } 887 888 static void irq_setup_forced_threading(struct irqaction *new) 889 { 890 if (!force_irqthreads) 891 return; 892 if (new->flags & (IRQF_NO_THREAD | IRQF_PERCPU | IRQF_ONESHOT)) 893 return; 894 895 new->flags |= IRQF_ONESHOT; 896 897 if (!new->thread_fn) { 898 set_bit(IRQTF_FORCED_THREAD, &new->thread_flags); 899 new->thread_fn = new->handler; 900 new->handler = irq_default_primary_handler; 901 } 902 } 903 904 /* 905 * Internal function to register an irqaction - typically used to 906 * allocate special interrupts that are part of the architecture. 907 */ 908 static int 909 __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new) 910 { 911 struct irqaction *old, **old_ptr; 912 unsigned long flags, thread_mask = 0; 913 int ret, nested, shared = 0; 914 cpumask_var_t mask; 915 916 if (!desc) 917 return -EINVAL; 918 919 if (desc->irq_data.chip == &no_irq_chip) 920 return -ENOSYS; 921 if (!try_module_get(desc->owner)) 922 return -ENODEV; 923 924 /* 925 * Check whether the interrupt nests into another interrupt 926 * thread. 927 */ 928 nested = irq_settings_is_nested_thread(desc); 929 if (nested) { 930 if (!new->thread_fn) { 931 ret = -EINVAL; 932 goto out_mput; 933 } 934 /* 935 * Replace the primary handler which was provided from 936 * the driver for non nested interrupt handling by the 937 * dummy function which warns when called. 938 */ 939 new->handler = irq_nested_primary_handler; 940 } else { 941 if (irq_settings_can_thread(desc)) 942 irq_setup_forced_threading(new); 943 } 944 945 /* 946 * Create a handler thread when a thread function is supplied 947 * and the interrupt does not nest into another interrupt 948 * thread. 949 */ 950 if (new->thread_fn && !nested) { 951 struct task_struct *t; 952 953 t = kthread_create(irq_thread, new, "irq/%d-%s", irq, 954 new->name); 955 if (IS_ERR(t)) { 956 ret = PTR_ERR(t); 957 goto out_mput; 958 } 959 /* 960 * We keep the reference to the task struct even if 961 * the thread dies to avoid that the interrupt code 962 * references an already freed task_struct. 963 */ 964 get_task_struct(t); 965 new->thread = t; 966 /* 967 * Tell the thread to set its affinity. This is 968 * important for shared interrupt handlers as we do 969 * not invoke setup_affinity() for the secondary 970 * handlers as everything is already set up. Even for 971 * interrupts marked with IRQF_NO_BALANCE this is 972 * correct as we want the thread to move to the cpu(s) 973 * on which the requesting code placed the interrupt. 974 */ 975 set_bit(IRQTF_AFFINITY, &new->thread_flags); 976 } 977 978 if (!alloc_cpumask_var(&mask, GFP_KERNEL)) { 979 ret = -ENOMEM; 980 goto out_thread; 981 } 982 983 /* 984 * Drivers are often written to work w/o knowledge about the 985 * underlying irq chip implementation, so a request for a 986 * threaded irq without a primary hard irq context handler 987 * requires the ONESHOT flag to be set. Some irq chips like 988 * MSI based interrupts are per se one shot safe. Check the 989 * chip flags, so we can avoid the unmask dance at the end of 990 * the threaded handler for those. 991 */ 992 if (desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE) 993 new->flags &= ~IRQF_ONESHOT; 994 995 /* 996 * The following block of code has to be executed atomically 997 */ 998 raw_spin_lock_irqsave(&desc->lock, flags); 999 old_ptr = &desc->action; 1000 old = *old_ptr; 1001 if (old) { 1002 /* 1003 * Can't share interrupts unless both agree to and are 1004 * the same type (level, edge, polarity). So both flag 1005 * fields must have IRQF_SHARED set and the bits which 1006 * set the trigger type must match. Also all must 1007 * agree on ONESHOT. 1008 */ 1009 if (!((old->flags & new->flags) & IRQF_SHARED) || 1010 ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK) || 1011 ((old->flags ^ new->flags) & IRQF_ONESHOT)) 1012 goto mismatch; 1013 1014 /* All handlers must agree on per-cpuness */ 1015 if ((old->flags & IRQF_PERCPU) != 1016 (new->flags & IRQF_PERCPU)) 1017 goto mismatch; 1018 1019 /* add new interrupt at end of irq queue */ 1020 do { 1021 /* 1022 * Or all existing action->thread_mask bits, 1023 * so we can find the next zero bit for this 1024 * new action. 1025 */ 1026 thread_mask |= old->thread_mask; 1027 old_ptr = &old->next; 1028 old = *old_ptr; 1029 } while (old); 1030 shared = 1; 1031 } 1032 1033 /* 1034 * Setup the thread mask for this irqaction for ONESHOT. For 1035 * !ONESHOT irqs the thread mask is 0 so we can avoid a 1036 * conditional in irq_wake_thread(). 1037 */ 1038 if (new->flags & IRQF_ONESHOT) { 1039 /* 1040 * Unlikely to have 32 resp 64 irqs sharing one line, 1041 * but who knows. 1042 */ 1043 if (thread_mask == ~0UL) { 1044 ret = -EBUSY; 1045 goto out_mask; 1046 } 1047 /* 1048 * The thread_mask for the action is or'ed to 1049 * desc->thread_active to indicate that the 1050 * IRQF_ONESHOT thread handler has been woken, but not 1051 * yet finished. The bit is cleared when a thread 1052 * completes. When all threads of a shared interrupt 1053 * line have completed desc->threads_active becomes 1054 * zero and the interrupt line is unmasked. See 1055 * handle.c:irq_wake_thread() for further information. 1056 * 1057 * If no thread is woken by primary (hard irq context) 1058 * interrupt handlers, then desc->threads_active is 1059 * also checked for zero to unmask the irq line in the 1060 * affected hard irq flow handlers 1061 * (handle_[fasteoi|level]_irq). 1062 * 1063 * The new action gets the first zero bit of 1064 * thread_mask assigned. See the loop above which or's 1065 * all existing action->thread_mask bits. 1066 */ 1067 new->thread_mask = 1 << ffz(thread_mask); 1068 1069 } else if (new->handler == irq_default_primary_handler && 1070 !(desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)) { 1071 /* 1072 * The interrupt was requested with handler = NULL, so 1073 * we use the default primary handler for it. But it 1074 * does not have the oneshot flag set. In combination 1075 * with level interrupts this is deadly, because the 1076 * default primary handler just wakes the thread, then 1077 * the irq lines is reenabled, but the device still 1078 * has the level irq asserted. Rinse and repeat.... 1079 * 1080 * While this works for edge type interrupts, we play 1081 * it safe and reject unconditionally because we can't 1082 * say for sure which type this interrupt really 1083 * has. The type flags are unreliable as the 1084 * underlying chip implementation can override them. 1085 */ 1086 pr_err("Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n", 1087 irq); 1088 ret = -EINVAL; 1089 goto out_mask; 1090 } 1091 1092 if (!shared) { 1093 init_waitqueue_head(&desc->wait_for_threads); 1094 1095 /* Setup the type (level, edge polarity) if configured: */ 1096 if (new->flags & IRQF_TRIGGER_MASK) { 1097 ret = __irq_set_trigger(desc, irq, 1098 new->flags & IRQF_TRIGGER_MASK); 1099 1100 if (ret) 1101 goto out_mask; 1102 } 1103 1104 desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \ 1105 IRQS_ONESHOT | IRQS_WAITING); 1106 irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS); 1107 1108 if (new->flags & IRQF_PERCPU) { 1109 irqd_set(&desc->irq_data, IRQD_PER_CPU); 1110 irq_settings_set_per_cpu(desc); 1111 } 1112 1113 if (new->flags & IRQF_ONESHOT) 1114 desc->istate |= IRQS_ONESHOT; 1115 1116 if (irq_settings_can_autoenable(desc)) 1117 irq_startup(desc, true); 1118 else 1119 /* Undo nested disables: */ 1120 desc->depth = 1; 1121 1122 /* Exclude IRQ from balancing if requested */ 1123 if (new->flags & IRQF_NOBALANCING) { 1124 irq_settings_set_no_balancing(desc); 1125 irqd_set(&desc->irq_data, IRQD_NO_BALANCING); 1126 } 1127 1128 /* Set default affinity mask once everything is setup */ 1129 setup_affinity(irq, desc, mask); 1130 1131 } else if (new->flags & IRQF_TRIGGER_MASK) { 1132 unsigned int nmsk = new->flags & IRQF_TRIGGER_MASK; 1133 unsigned int omsk = irq_settings_get_trigger_mask(desc); 1134 1135 if (nmsk != omsk) 1136 /* hope the handler works with current trigger mode */ 1137 pr_warning("irq %d uses trigger mode %u; requested %u\n", 1138 irq, nmsk, omsk); 1139 } 1140 1141 new->irq = irq; 1142 *old_ptr = new; 1143 1144 /* Reset broken irq detection when installing new handler */ 1145 desc->irq_count = 0; 1146 desc->irqs_unhandled = 0; 1147 1148 /* 1149 * Check whether we disabled the irq via the spurious handler 1150 * before. Reenable it and give it another chance. 1151 */ 1152 if (shared && (desc->istate & IRQS_SPURIOUS_DISABLED)) { 1153 desc->istate &= ~IRQS_SPURIOUS_DISABLED; 1154 __enable_irq(desc, irq, false); 1155 } 1156 1157 raw_spin_unlock_irqrestore(&desc->lock, flags); 1158 1159 /* 1160 * Strictly no need to wake it up, but hung_task complains 1161 * when no hard interrupt wakes the thread up. 1162 */ 1163 if (new->thread) 1164 wake_up_process(new->thread); 1165 1166 register_irq_proc(irq, desc); 1167 new->dir = NULL; 1168 register_handler_proc(irq, new); 1169 free_cpumask_var(mask); 1170 1171 return 0; 1172 1173 mismatch: 1174 if (!(new->flags & IRQF_PROBE_SHARED)) { 1175 pr_err("Flags mismatch irq %d. %08x (%s) vs. %08x (%s)\n", 1176 irq, new->flags, new->name, old->flags, old->name); 1177 #ifdef CONFIG_DEBUG_SHIRQ 1178 dump_stack(); 1179 #endif 1180 } 1181 ret = -EBUSY; 1182 1183 out_mask: 1184 raw_spin_unlock_irqrestore(&desc->lock, flags); 1185 free_cpumask_var(mask); 1186 1187 out_thread: 1188 if (new->thread) { 1189 struct task_struct *t = new->thread; 1190 1191 new->thread = NULL; 1192 kthread_stop(t); 1193 put_task_struct(t); 1194 } 1195 out_mput: 1196 module_put(desc->owner); 1197 return ret; 1198 } 1199 1200 /** 1201 * setup_irq - setup an interrupt 1202 * @irq: Interrupt line to setup 1203 * @act: irqaction for the interrupt 1204 * 1205 * Used to statically setup interrupts in the early boot process. 1206 */ 1207 int setup_irq(unsigned int irq, struct irqaction *act) 1208 { 1209 int retval; 1210 struct irq_desc *desc = irq_to_desc(irq); 1211 1212 if (WARN_ON(irq_settings_is_per_cpu_devid(desc))) 1213 return -EINVAL; 1214 chip_bus_lock(desc); 1215 retval = __setup_irq(irq, desc, act); 1216 chip_bus_sync_unlock(desc); 1217 1218 return retval; 1219 } 1220 EXPORT_SYMBOL_GPL(setup_irq); 1221 1222 /* 1223 * Internal function to unregister an irqaction - used to free 1224 * regular and special interrupts that are part of the architecture. 1225 */ 1226 static struct irqaction *__free_irq(unsigned int irq, void *dev_id) 1227 { 1228 struct irq_desc *desc = irq_to_desc(irq); 1229 struct irqaction *action, **action_ptr; 1230 unsigned long flags; 1231 1232 WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq); 1233 1234 if (!desc) 1235 return NULL; 1236 1237 raw_spin_lock_irqsave(&desc->lock, flags); 1238 1239 /* 1240 * There can be multiple actions per IRQ descriptor, find the right 1241 * one based on the dev_id: 1242 */ 1243 action_ptr = &desc->action; 1244 for (;;) { 1245 action = *action_ptr; 1246 1247 if (!action) { 1248 WARN(1, "Trying to free already-free IRQ %d\n", irq); 1249 raw_spin_unlock_irqrestore(&desc->lock, flags); 1250 1251 return NULL; 1252 } 1253 1254 if (action->dev_id == dev_id) 1255 break; 1256 action_ptr = &action->next; 1257 } 1258 1259 /* Found it - now remove it from the list of entries: */ 1260 *action_ptr = action->next; 1261 1262 /* If this was the last handler, shut down the IRQ line: */ 1263 if (!desc->action) 1264 irq_shutdown(desc); 1265 1266 #ifdef CONFIG_SMP 1267 /* make sure affinity_hint is cleaned up */ 1268 if (WARN_ON_ONCE(desc->affinity_hint)) 1269 desc->affinity_hint = NULL; 1270 #endif 1271 1272 raw_spin_unlock_irqrestore(&desc->lock, flags); 1273 1274 unregister_handler_proc(irq, action); 1275 1276 /* Make sure it's not being used on another CPU: */ 1277 synchronize_irq(irq); 1278 1279 #ifdef CONFIG_DEBUG_SHIRQ 1280 /* 1281 * It's a shared IRQ -- the driver ought to be prepared for an IRQ 1282 * event to happen even now it's being freed, so let's make sure that 1283 * is so by doing an extra call to the handler .... 1284 * 1285 * ( We do this after actually deregistering it, to make sure that a 1286 * 'real' IRQ doesn't run in * parallel with our fake. ) 1287 */ 1288 if (action->flags & IRQF_SHARED) { 1289 local_irq_save(flags); 1290 action->handler(irq, dev_id); 1291 local_irq_restore(flags); 1292 } 1293 #endif 1294 1295 if (action->thread) { 1296 kthread_stop(action->thread); 1297 put_task_struct(action->thread); 1298 } 1299 1300 module_put(desc->owner); 1301 return action; 1302 } 1303 1304 /** 1305 * remove_irq - free an interrupt 1306 * @irq: Interrupt line to free 1307 * @act: irqaction for the interrupt 1308 * 1309 * Used to remove interrupts statically setup by the early boot process. 1310 */ 1311 void remove_irq(unsigned int irq, struct irqaction *act) 1312 { 1313 struct irq_desc *desc = irq_to_desc(irq); 1314 1315 if (desc && !WARN_ON(irq_settings_is_per_cpu_devid(desc))) 1316 __free_irq(irq, act->dev_id); 1317 } 1318 EXPORT_SYMBOL_GPL(remove_irq); 1319 1320 /** 1321 * free_irq - free an interrupt allocated with request_irq 1322 * @irq: Interrupt line to free 1323 * @dev_id: Device identity to free 1324 * 1325 * Remove an interrupt handler. The handler is removed and if the 1326 * interrupt line is no longer in use by any driver it is disabled. 1327 * On a shared IRQ the caller must ensure the interrupt is disabled 1328 * on the card it drives before calling this function. The function 1329 * does not return until any executing interrupts for this IRQ 1330 * have completed. 1331 * 1332 * This function must not be called from interrupt context. 1333 */ 1334 void free_irq(unsigned int irq, void *dev_id) 1335 { 1336 struct irq_desc *desc = irq_to_desc(irq); 1337 1338 if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc))) 1339 return; 1340 1341 #ifdef CONFIG_SMP 1342 if (WARN_ON(desc->affinity_notify)) 1343 desc->affinity_notify = NULL; 1344 #endif 1345 1346 chip_bus_lock(desc); 1347 kfree(__free_irq(irq, dev_id)); 1348 chip_bus_sync_unlock(desc); 1349 } 1350 EXPORT_SYMBOL(free_irq); 1351 1352 /** 1353 * request_threaded_irq - allocate an interrupt line 1354 * @irq: Interrupt line to allocate 1355 * @handler: Function to be called when the IRQ occurs. 1356 * Primary handler for threaded interrupts 1357 * If NULL and thread_fn != NULL the default 1358 * primary handler is installed 1359 * @thread_fn: Function called from the irq handler thread 1360 * If NULL, no irq thread is created 1361 * @irqflags: Interrupt type flags 1362 * @devname: An ascii name for the claiming device 1363 * @dev_id: A cookie passed back to the handler function 1364 * 1365 * This call allocates interrupt resources and enables the 1366 * interrupt line and IRQ handling. From the point this 1367 * call is made your handler function may be invoked. Since 1368 * your handler function must clear any interrupt the board 1369 * raises, you must take care both to initialise your hardware 1370 * and to set up the interrupt handler in the right order. 1371 * 1372 * If you want to set up a threaded irq handler for your device 1373 * then you need to supply @handler and @thread_fn. @handler is 1374 * still called in hard interrupt context and has to check 1375 * whether the interrupt originates from the device. If yes it 1376 * needs to disable the interrupt on the device and return 1377 * IRQ_WAKE_THREAD which will wake up the handler thread and run 1378 * @thread_fn. This split handler design is necessary to support 1379 * shared interrupts. 1380 * 1381 * Dev_id must be globally unique. Normally the address of the 1382 * device data structure is used as the cookie. Since the handler 1383 * receives this value it makes sense to use it. 1384 * 1385 * If your interrupt is shared you must pass a non NULL dev_id 1386 * as this is required when freeing the interrupt. 1387 * 1388 * Flags: 1389 * 1390 * IRQF_SHARED Interrupt is shared 1391 * IRQF_TRIGGER_* Specify active edge(s) or level 1392 * 1393 */ 1394 int request_threaded_irq(unsigned int irq, irq_handler_t handler, 1395 irq_handler_t thread_fn, unsigned long irqflags, 1396 const char *devname, void *dev_id) 1397 { 1398 struct irqaction *action; 1399 struct irq_desc *desc; 1400 int retval; 1401 1402 /* 1403 * Sanity-check: shared interrupts must pass in a real dev-ID, 1404 * otherwise we'll have trouble later trying to figure out 1405 * which interrupt is which (messes up the interrupt freeing 1406 * logic etc). 1407 */ 1408 if ((irqflags & IRQF_SHARED) && !dev_id) 1409 return -EINVAL; 1410 1411 desc = irq_to_desc(irq); 1412 if (!desc) 1413 return -EINVAL; 1414 1415 if (!irq_settings_can_request(desc) || 1416 WARN_ON(irq_settings_is_per_cpu_devid(desc))) 1417 return -EINVAL; 1418 1419 if (!handler) { 1420 if (!thread_fn) 1421 return -EINVAL; 1422 handler = irq_default_primary_handler; 1423 } 1424 1425 action = kzalloc(sizeof(struct irqaction), GFP_KERNEL); 1426 if (!action) 1427 return -ENOMEM; 1428 1429 action->handler = handler; 1430 action->thread_fn = thread_fn; 1431 action->flags = irqflags; 1432 action->name = devname; 1433 action->dev_id = dev_id; 1434 1435 chip_bus_lock(desc); 1436 retval = __setup_irq(irq, desc, action); 1437 chip_bus_sync_unlock(desc); 1438 1439 if (retval) 1440 kfree(action); 1441 1442 #ifdef CONFIG_DEBUG_SHIRQ_FIXME 1443 if (!retval && (irqflags & IRQF_SHARED)) { 1444 /* 1445 * It's a shared IRQ -- the driver ought to be prepared for it 1446 * to happen immediately, so let's make sure.... 1447 * We disable the irq to make sure that a 'real' IRQ doesn't 1448 * run in parallel with our fake. 1449 */ 1450 unsigned long flags; 1451 1452 disable_irq(irq); 1453 local_irq_save(flags); 1454 1455 handler(irq, dev_id); 1456 1457 local_irq_restore(flags); 1458 enable_irq(irq); 1459 } 1460 #endif 1461 return retval; 1462 } 1463 EXPORT_SYMBOL(request_threaded_irq); 1464 1465 /** 1466 * request_any_context_irq - allocate an interrupt line 1467 * @irq: Interrupt line to allocate 1468 * @handler: Function to be called when the IRQ occurs. 1469 * Threaded handler for threaded interrupts. 1470 * @flags: Interrupt type flags 1471 * @name: An ascii name for the claiming device 1472 * @dev_id: A cookie passed back to the handler function 1473 * 1474 * This call allocates interrupt resources and enables the 1475 * interrupt line and IRQ handling. It selects either a 1476 * hardirq or threaded handling method depending on the 1477 * context. 1478 * 1479 * On failure, it returns a negative value. On success, 1480 * it returns either IRQC_IS_HARDIRQ or IRQC_IS_NESTED. 1481 */ 1482 int request_any_context_irq(unsigned int irq, irq_handler_t handler, 1483 unsigned long flags, const char *name, void *dev_id) 1484 { 1485 struct irq_desc *desc = irq_to_desc(irq); 1486 int ret; 1487 1488 if (!desc) 1489 return -EINVAL; 1490 1491 if (irq_settings_is_nested_thread(desc)) { 1492 ret = request_threaded_irq(irq, NULL, handler, 1493 flags, name, dev_id); 1494 return !ret ? IRQC_IS_NESTED : ret; 1495 } 1496 1497 ret = request_irq(irq, handler, flags, name, dev_id); 1498 return !ret ? IRQC_IS_HARDIRQ : ret; 1499 } 1500 EXPORT_SYMBOL_GPL(request_any_context_irq); 1501 1502 void enable_percpu_irq(unsigned int irq, unsigned int type) 1503 { 1504 unsigned int cpu = smp_processor_id(); 1505 unsigned long flags; 1506 struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); 1507 1508 if (!desc) 1509 return; 1510 1511 type &= IRQ_TYPE_SENSE_MASK; 1512 if (type != IRQ_TYPE_NONE) { 1513 int ret; 1514 1515 ret = __irq_set_trigger(desc, irq, type); 1516 1517 if (ret) { 1518 WARN(1, "failed to set type for IRQ%d\n", irq); 1519 goto out; 1520 } 1521 } 1522 1523 irq_percpu_enable(desc, cpu); 1524 out: 1525 irq_put_desc_unlock(desc, flags); 1526 } 1527 1528 void disable_percpu_irq(unsigned int irq) 1529 { 1530 unsigned int cpu = smp_processor_id(); 1531 unsigned long flags; 1532 struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); 1533 1534 if (!desc) 1535 return; 1536 1537 irq_percpu_disable(desc, cpu); 1538 irq_put_desc_unlock(desc, flags); 1539 } 1540 1541 /* 1542 * Internal function to unregister a percpu irqaction. 1543 */ 1544 static struct irqaction *__free_percpu_irq(unsigned int irq, void __percpu *dev_id) 1545 { 1546 struct irq_desc *desc = irq_to_desc(irq); 1547 struct irqaction *action; 1548 unsigned long flags; 1549 1550 WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq); 1551 1552 if (!desc) 1553 return NULL; 1554 1555 raw_spin_lock_irqsave(&desc->lock, flags); 1556 1557 action = desc->action; 1558 if (!action || action->percpu_dev_id != dev_id) { 1559 WARN(1, "Trying to free already-free IRQ %d\n", irq); 1560 goto bad; 1561 } 1562 1563 if (!cpumask_empty(desc->percpu_enabled)) { 1564 WARN(1, "percpu IRQ %d still enabled on CPU%d!\n", 1565 irq, cpumask_first(desc->percpu_enabled)); 1566 goto bad; 1567 } 1568 1569 /* Found it - now remove it from the list of entries: */ 1570 desc->action = NULL; 1571 1572 raw_spin_unlock_irqrestore(&desc->lock, flags); 1573 1574 unregister_handler_proc(irq, action); 1575 1576 module_put(desc->owner); 1577 return action; 1578 1579 bad: 1580 raw_spin_unlock_irqrestore(&desc->lock, flags); 1581 return NULL; 1582 } 1583 1584 /** 1585 * remove_percpu_irq - free a per-cpu interrupt 1586 * @irq: Interrupt line to free 1587 * @act: irqaction for the interrupt 1588 * 1589 * Used to remove interrupts statically setup by the early boot process. 1590 */ 1591 void remove_percpu_irq(unsigned int irq, struct irqaction *act) 1592 { 1593 struct irq_desc *desc = irq_to_desc(irq); 1594 1595 if (desc && irq_settings_is_per_cpu_devid(desc)) 1596 __free_percpu_irq(irq, act->percpu_dev_id); 1597 } 1598 1599 /** 1600 * free_percpu_irq - free an interrupt allocated with request_percpu_irq 1601 * @irq: Interrupt line to free 1602 * @dev_id: Device identity to free 1603 * 1604 * Remove a percpu interrupt handler. The handler is removed, but 1605 * the interrupt line is not disabled. This must be done on each 1606 * CPU before calling this function. The function does not return 1607 * until any executing interrupts for this IRQ have completed. 1608 * 1609 * This function must not be called from interrupt context. 1610 */ 1611 void free_percpu_irq(unsigned int irq, void __percpu *dev_id) 1612 { 1613 struct irq_desc *desc = irq_to_desc(irq); 1614 1615 if (!desc || !irq_settings_is_per_cpu_devid(desc)) 1616 return; 1617 1618 chip_bus_lock(desc); 1619 kfree(__free_percpu_irq(irq, dev_id)); 1620 chip_bus_sync_unlock(desc); 1621 } 1622 1623 /** 1624 * setup_percpu_irq - setup a per-cpu interrupt 1625 * @irq: Interrupt line to setup 1626 * @act: irqaction for the interrupt 1627 * 1628 * Used to statically setup per-cpu interrupts in the early boot process. 1629 */ 1630 int setup_percpu_irq(unsigned int irq, struct irqaction *act) 1631 { 1632 struct irq_desc *desc = irq_to_desc(irq); 1633 int retval; 1634 1635 if (!desc || !irq_settings_is_per_cpu_devid(desc)) 1636 return -EINVAL; 1637 chip_bus_lock(desc); 1638 retval = __setup_irq(irq, desc, act); 1639 chip_bus_sync_unlock(desc); 1640 1641 return retval; 1642 } 1643 1644 /** 1645 * request_percpu_irq - allocate a percpu interrupt line 1646 * @irq: Interrupt line to allocate 1647 * @handler: Function to be called when the IRQ occurs. 1648 * @devname: An ascii name for the claiming device 1649 * @dev_id: A percpu cookie passed back to the handler function 1650 * 1651 * This call allocates interrupt resources, but doesn't 1652 * automatically enable the interrupt. It has to be done on each 1653 * CPU using enable_percpu_irq(). 1654 * 1655 * Dev_id must be globally unique. It is a per-cpu variable, and 1656 * the handler gets called with the interrupted CPU's instance of 1657 * that variable. 1658 */ 1659 int request_percpu_irq(unsigned int irq, irq_handler_t handler, 1660 const char *devname, void __percpu *dev_id) 1661 { 1662 struct irqaction *action; 1663 struct irq_desc *desc; 1664 int retval; 1665 1666 if (!dev_id) 1667 return -EINVAL; 1668 1669 desc = irq_to_desc(irq); 1670 if (!desc || !irq_settings_can_request(desc) || 1671 !irq_settings_is_per_cpu_devid(desc)) 1672 return -EINVAL; 1673 1674 action = kzalloc(sizeof(struct irqaction), GFP_KERNEL); 1675 if (!action) 1676 return -ENOMEM; 1677 1678 action->handler = handler; 1679 action->flags = IRQF_PERCPU | IRQF_NO_SUSPEND; 1680 action->name = devname; 1681 action->percpu_dev_id = dev_id; 1682 1683 chip_bus_lock(desc); 1684 retval = __setup_irq(irq, desc, action); 1685 chip_bus_sync_unlock(desc); 1686 1687 if (retval) 1688 kfree(action); 1689 1690 return retval; 1691 } 1692