1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* interrupt.h */ 3 #ifndef _LINUX_INTERRUPT_H 4 #define _LINUX_INTERRUPT_H 5 6 #include <linux/kernel.h> 7 #include <linux/bitops.h> 8 #include <linux/cpumask.h> 9 #include <linux/irqreturn.h> 10 #include <linux/irqnr.h> 11 #include <linux/hardirq.h> 12 #include <linux/irqflags.h> 13 #include <linux/hrtimer.h> 14 #include <linux/kref.h> 15 #include <linux/workqueue.h> 16 17 #include <linux/atomic.h> 18 #include <asm/ptrace.h> 19 #include <asm/irq.h> 20 #include <asm/sections.h> 21 22 /* 23 * These correspond to the IORESOURCE_IRQ_* defines in 24 * linux/ioport.h to select the interrupt line behaviour. When 25 * requesting an interrupt without specifying a IRQF_TRIGGER, the 26 * setting should be assumed to be "as already configured", which 27 * may be as per machine or firmware initialisation. 28 */ 29 #define IRQF_TRIGGER_NONE 0x00000000 30 #define IRQF_TRIGGER_RISING 0x00000001 31 #define IRQF_TRIGGER_FALLING 0x00000002 32 #define IRQF_TRIGGER_HIGH 0x00000004 33 #define IRQF_TRIGGER_LOW 0x00000008 34 #define IRQF_TRIGGER_MASK (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \ 35 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING) 36 #define IRQF_TRIGGER_PROBE 0x00000010 37 38 /* 39 * These flags used only by the kernel as part of the 40 * irq handling routines. 41 * 42 * IRQF_SHARED - allow sharing the irq among several devices 43 * IRQF_PROBE_SHARED - set by callers when they expect sharing mismatches to occur 44 * IRQF_TIMER - Flag to mark this interrupt as timer interrupt 45 * IRQF_PERCPU - Interrupt is per cpu 46 * IRQF_NOBALANCING - Flag to exclude this interrupt from irq balancing 47 * IRQF_IRQPOLL - Interrupt is used for polling (only the interrupt that is 48 * registered first in a shared interrupt is considered for 49 * performance reasons) 50 * IRQF_ONESHOT - Interrupt is not reenabled after the hardirq handler finished. 51 * Used by threaded interrupts which need to keep the 52 * irq line disabled until the threaded handler has been run. 53 * IRQF_NO_SUSPEND - Do not disable this IRQ during suspend. Does not guarantee 54 * that this interrupt will wake the system from a suspended 55 * state. See Documentation/power/suspend-and-interrupts.rst 56 * IRQF_FORCE_RESUME - Force enable it on resume even if IRQF_NO_SUSPEND is set 57 * IRQF_NO_THREAD - Interrupt cannot be threaded 58 * IRQF_EARLY_RESUME - Resume IRQ early during syscore instead of at device 59 * resume time. 60 * IRQF_COND_SUSPEND - If the IRQ is shared with a NO_SUSPEND user, execute this 61 * interrupt handler after suspending interrupts. For system 62 * wakeup devices users need to implement wakeup detection in 63 * their interrupt handlers. 64 */ 65 #define IRQF_SHARED 0x00000080 66 #define IRQF_PROBE_SHARED 0x00000100 67 #define __IRQF_TIMER 0x00000200 68 #define IRQF_PERCPU 0x00000400 69 #define IRQF_NOBALANCING 0x00000800 70 #define IRQF_IRQPOLL 0x00001000 71 #define IRQF_ONESHOT 0x00002000 72 #define IRQF_NO_SUSPEND 0x00004000 73 #define IRQF_FORCE_RESUME 0x00008000 74 #define IRQF_NO_THREAD 0x00010000 75 #define IRQF_EARLY_RESUME 0x00020000 76 #define IRQF_COND_SUSPEND 0x00040000 77 78 #define IRQF_TIMER (__IRQF_TIMER | IRQF_NO_SUSPEND | IRQF_NO_THREAD) 79 80 /* 81 * These values can be returned by request_any_context_irq() and 82 * describe the context the interrupt will be run in. 83 * 84 * IRQC_IS_HARDIRQ - interrupt runs in hardirq context 85 * IRQC_IS_NESTED - interrupt runs in a nested threaded context 86 */ 87 enum { 88 IRQC_IS_HARDIRQ = 0, 89 IRQC_IS_NESTED, 90 }; 91 92 typedef irqreturn_t (*irq_handler_t)(int, void *); 93 94 /** 95 * struct irqaction - per interrupt action descriptor 96 * @handler: interrupt handler function 97 * @name: name of the device 98 * @dev_id: cookie to identify the device 99 * @percpu_dev_id: cookie to identify the device 100 * @next: pointer to the next irqaction for shared interrupts 101 * @irq: interrupt number 102 * @flags: flags (see IRQF_* above) 103 * @thread_fn: interrupt handler function for threaded interrupts 104 * @thread: thread pointer for threaded interrupts 105 * @secondary: pointer to secondary irqaction (force threading) 106 * @thread_flags: flags related to @thread 107 * @thread_mask: bitmask for keeping track of @thread activity 108 * @dir: pointer to the proc/irq/NN/name entry 109 */ 110 struct irqaction { 111 irq_handler_t handler; 112 void *dev_id; 113 void __percpu *percpu_dev_id; 114 struct irqaction *next; 115 irq_handler_t thread_fn; 116 struct task_struct *thread; 117 struct irqaction *secondary; 118 unsigned int irq; 119 unsigned int flags; 120 unsigned long thread_flags; 121 unsigned long thread_mask; 122 const char *name; 123 struct proc_dir_entry *dir; 124 } ____cacheline_internodealigned_in_smp; 125 126 extern irqreturn_t no_action(int cpl, void *dev_id); 127 128 /* 129 * If a (PCI) device interrupt is not connected we set dev->irq to 130 * IRQ_NOTCONNECTED. This causes request_irq() to fail with -ENOTCONN, so we 131 * can distingiush that case from other error returns. 132 * 133 * 0x80000000 is guaranteed to be outside the available range of interrupts 134 * and easy to distinguish from other possible incorrect values. 135 */ 136 #define IRQ_NOTCONNECTED (1U << 31) 137 138 extern int __must_check 139 request_threaded_irq(unsigned int irq, irq_handler_t handler, 140 irq_handler_t thread_fn, 141 unsigned long flags, const char *name, void *dev); 142 143 /** 144 * request_irq - Add a handler for an interrupt line 145 * @irq: The interrupt line to allocate 146 * @handler: Function to be called when the IRQ occurs. 147 * Primary handler for threaded interrupts 148 * If NULL, the default primary handler is installed 149 * @flags: Handling flags 150 * @name: Name of the device generating this interrupt 151 * @dev: A cookie passed to the handler function 152 * 153 * This call allocates an interrupt and establishes a handler; see 154 * the documentation for request_threaded_irq() for details. 155 */ 156 static inline int __must_check 157 request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, 158 const char *name, void *dev) 159 { 160 return request_threaded_irq(irq, handler, NULL, flags, name, dev); 161 } 162 163 extern int __must_check 164 request_any_context_irq(unsigned int irq, irq_handler_t handler, 165 unsigned long flags, const char *name, void *dev_id); 166 167 extern int __must_check 168 __request_percpu_irq(unsigned int irq, irq_handler_t handler, 169 unsigned long flags, const char *devname, 170 void __percpu *percpu_dev_id); 171 172 extern int __must_check 173 request_nmi(unsigned int irq, irq_handler_t handler, unsigned long flags, 174 const char *name, void *dev); 175 176 static inline int __must_check 177 request_percpu_irq(unsigned int irq, irq_handler_t handler, 178 const char *devname, void __percpu *percpu_dev_id) 179 { 180 return __request_percpu_irq(irq, handler, 0, 181 devname, percpu_dev_id); 182 } 183 184 extern int __must_check 185 request_percpu_nmi(unsigned int irq, irq_handler_t handler, 186 const char *devname, void __percpu *dev); 187 188 extern const void *free_irq(unsigned int, void *); 189 extern void free_percpu_irq(unsigned int, void __percpu *); 190 191 extern const void *free_nmi(unsigned int irq, void *dev_id); 192 extern void free_percpu_nmi(unsigned int irq, void __percpu *percpu_dev_id); 193 194 struct device; 195 196 extern int __must_check 197 devm_request_threaded_irq(struct device *dev, unsigned int irq, 198 irq_handler_t handler, irq_handler_t thread_fn, 199 unsigned long irqflags, const char *devname, 200 void *dev_id); 201 202 static inline int __must_check 203 devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler, 204 unsigned long irqflags, const char *devname, void *dev_id) 205 { 206 return devm_request_threaded_irq(dev, irq, handler, NULL, irqflags, 207 devname, dev_id); 208 } 209 210 extern int __must_check 211 devm_request_any_context_irq(struct device *dev, unsigned int irq, 212 irq_handler_t handler, unsigned long irqflags, 213 const char *devname, void *dev_id); 214 215 extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id); 216 217 /* 218 * On lockdep we dont want to enable hardirqs in hardirq 219 * context. Use local_irq_enable_in_hardirq() to annotate 220 * kernel code that has to do this nevertheless (pretty much 221 * the only valid case is for old/broken hardware that is 222 * insanely slow). 223 * 224 * NOTE: in theory this might break fragile code that relies 225 * on hardirq delivery - in practice we dont seem to have such 226 * places left. So the only effect should be slightly increased 227 * irqs-off latencies. 228 */ 229 #ifdef CONFIG_LOCKDEP 230 # define local_irq_enable_in_hardirq() do { } while (0) 231 #else 232 # define local_irq_enable_in_hardirq() local_irq_enable() 233 #endif 234 235 bool irq_has_action(unsigned int irq); 236 extern void disable_irq_nosync(unsigned int irq); 237 extern bool disable_hardirq(unsigned int irq); 238 extern void disable_irq(unsigned int irq); 239 extern void disable_percpu_irq(unsigned int irq); 240 extern void enable_irq(unsigned int irq); 241 extern void enable_percpu_irq(unsigned int irq, unsigned int type); 242 extern bool irq_percpu_is_enabled(unsigned int irq); 243 extern void irq_wake_thread(unsigned int irq, void *dev_id); 244 245 extern void disable_nmi_nosync(unsigned int irq); 246 extern void disable_percpu_nmi(unsigned int irq); 247 extern void enable_nmi(unsigned int irq); 248 extern void enable_percpu_nmi(unsigned int irq, unsigned int type); 249 extern int prepare_percpu_nmi(unsigned int irq); 250 extern void teardown_percpu_nmi(unsigned int irq); 251 252 extern int irq_inject_interrupt(unsigned int irq); 253 254 /* The following three functions are for the core kernel use only. */ 255 extern void suspend_device_irqs(void); 256 extern void resume_device_irqs(void); 257 extern void rearm_wake_irq(unsigned int irq); 258 259 /** 260 * struct irq_affinity_notify - context for notification of IRQ affinity changes 261 * @irq: Interrupt to which notification applies 262 * @kref: Reference count, for internal use 263 * @work: Work item, for internal use 264 * @notify: Function to be called on change. This will be 265 * called in process context. 266 * @release: Function to be called on release. This will be 267 * called in process context. Once registered, the 268 * structure must only be freed when this function is 269 * called or later. 270 */ 271 struct irq_affinity_notify { 272 unsigned int irq; 273 struct kref kref; 274 struct work_struct work; 275 void (*notify)(struct irq_affinity_notify *, const cpumask_t *mask); 276 void (*release)(struct kref *ref); 277 }; 278 279 #define IRQ_AFFINITY_MAX_SETS 4 280 281 /** 282 * struct irq_affinity - Description for automatic irq affinity assignements 283 * @pre_vectors: Don't apply affinity to @pre_vectors at beginning of 284 * the MSI(-X) vector space 285 * @post_vectors: Don't apply affinity to @post_vectors at end of 286 * the MSI(-X) vector space 287 * @nr_sets: The number of interrupt sets for which affinity 288 * spreading is required 289 * @set_size: Array holding the size of each interrupt set 290 * @calc_sets: Callback for calculating the number and size 291 * of interrupt sets 292 * @priv: Private data for usage by @calc_sets, usually a 293 * pointer to driver/device specific data. 294 */ 295 struct irq_affinity { 296 unsigned int pre_vectors; 297 unsigned int post_vectors; 298 unsigned int nr_sets; 299 unsigned int set_size[IRQ_AFFINITY_MAX_SETS]; 300 void (*calc_sets)(struct irq_affinity *, unsigned int nvecs); 301 void *priv; 302 }; 303 304 /** 305 * struct irq_affinity_desc - Interrupt affinity descriptor 306 * @mask: cpumask to hold the affinity assignment 307 * @is_managed: 1 if the interrupt is managed internally 308 */ 309 struct irq_affinity_desc { 310 struct cpumask mask; 311 unsigned int is_managed : 1; 312 }; 313 314 #if defined(CONFIG_SMP) 315 316 extern cpumask_var_t irq_default_affinity; 317 318 /* Internal implementation. Use the helpers below */ 319 extern int __irq_set_affinity(unsigned int irq, const struct cpumask *cpumask, 320 bool force); 321 322 /** 323 * irq_set_affinity - Set the irq affinity of a given irq 324 * @irq: Interrupt to set affinity 325 * @cpumask: cpumask 326 * 327 * Fails if cpumask does not contain an online CPU 328 */ 329 static inline int 330 irq_set_affinity(unsigned int irq, const struct cpumask *cpumask) 331 { 332 return __irq_set_affinity(irq, cpumask, false); 333 } 334 335 /** 336 * irq_force_affinity - Force the irq affinity of a given irq 337 * @irq: Interrupt to set affinity 338 * @cpumask: cpumask 339 * 340 * Same as irq_set_affinity, but without checking the mask against 341 * online cpus. 342 * 343 * Solely for low level cpu hotplug code, where we need to make per 344 * cpu interrupts affine before the cpu becomes online. 345 */ 346 static inline int 347 irq_force_affinity(unsigned int irq, const struct cpumask *cpumask) 348 { 349 return __irq_set_affinity(irq, cpumask, true); 350 } 351 352 extern int irq_can_set_affinity(unsigned int irq); 353 extern int irq_select_affinity(unsigned int irq); 354 355 extern int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m); 356 extern int irq_update_affinity_desc(unsigned int irq, 357 struct irq_affinity_desc *affinity); 358 359 extern int 360 irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify); 361 362 struct irq_affinity_desc * 363 irq_create_affinity_masks(unsigned int nvec, struct irq_affinity *affd); 364 365 unsigned int irq_calc_affinity_vectors(unsigned int minvec, unsigned int maxvec, 366 const struct irq_affinity *affd); 367 368 #else /* CONFIG_SMP */ 369 370 static inline int irq_set_affinity(unsigned int irq, const struct cpumask *m) 371 { 372 return -EINVAL; 373 } 374 375 static inline int irq_force_affinity(unsigned int irq, const struct cpumask *cpumask) 376 { 377 return 0; 378 } 379 380 static inline int irq_can_set_affinity(unsigned int irq) 381 { 382 return 0; 383 } 384 385 static inline int irq_select_affinity(unsigned int irq) { return 0; } 386 387 static inline int irq_set_affinity_hint(unsigned int irq, 388 const struct cpumask *m) 389 { 390 return -EINVAL; 391 } 392 393 static inline int irq_update_affinity_desc(unsigned int irq, 394 struct irq_affinity_desc *affinity) 395 { 396 return -EINVAL; 397 } 398 399 static inline int 400 irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify) 401 { 402 return 0; 403 } 404 405 static inline struct irq_affinity_desc * 406 irq_create_affinity_masks(unsigned int nvec, struct irq_affinity *affd) 407 { 408 return NULL; 409 } 410 411 static inline unsigned int 412 irq_calc_affinity_vectors(unsigned int minvec, unsigned int maxvec, 413 const struct irq_affinity *affd) 414 { 415 return maxvec; 416 } 417 418 #endif /* CONFIG_SMP */ 419 420 /* 421 * Special lockdep variants of irq disabling/enabling. 422 * These should be used for locking constructs that 423 * know that a particular irq context which is disabled, 424 * and which is the only irq-context user of a lock, 425 * that it's safe to take the lock in the irq-disabled 426 * section without disabling hardirqs. 427 * 428 * On !CONFIG_LOCKDEP they are equivalent to the normal 429 * irq disable/enable methods. 430 */ 431 static inline void disable_irq_nosync_lockdep(unsigned int irq) 432 { 433 disable_irq_nosync(irq); 434 #ifdef CONFIG_LOCKDEP 435 local_irq_disable(); 436 #endif 437 } 438 439 static inline void disable_irq_nosync_lockdep_irqsave(unsigned int irq, unsigned long *flags) 440 { 441 disable_irq_nosync(irq); 442 #ifdef CONFIG_LOCKDEP 443 local_irq_save(*flags); 444 #endif 445 } 446 447 static inline void disable_irq_lockdep(unsigned int irq) 448 { 449 disable_irq(irq); 450 #ifdef CONFIG_LOCKDEP 451 local_irq_disable(); 452 #endif 453 } 454 455 static inline void enable_irq_lockdep(unsigned int irq) 456 { 457 #ifdef CONFIG_LOCKDEP 458 local_irq_enable(); 459 #endif 460 enable_irq(irq); 461 } 462 463 static inline void enable_irq_lockdep_irqrestore(unsigned int irq, unsigned long *flags) 464 { 465 #ifdef CONFIG_LOCKDEP 466 local_irq_restore(*flags); 467 #endif 468 enable_irq(irq); 469 } 470 471 /* IRQ wakeup (PM) control: */ 472 extern int irq_set_irq_wake(unsigned int irq, unsigned int on); 473 474 static inline int enable_irq_wake(unsigned int irq) 475 { 476 return irq_set_irq_wake(irq, 1); 477 } 478 479 static inline int disable_irq_wake(unsigned int irq) 480 { 481 return irq_set_irq_wake(irq, 0); 482 } 483 484 /* 485 * irq_get_irqchip_state/irq_set_irqchip_state specific flags 486 */ 487 enum irqchip_irq_state { 488 IRQCHIP_STATE_PENDING, /* Is interrupt pending? */ 489 IRQCHIP_STATE_ACTIVE, /* Is interrupt in progress? */ 490 IRQCHIP_STATE_MASKED, /* Is interrupt masked? */ 491 IRQCHIP_STATE_LINE_LEVEL, /* Is IRQ line high? */ 492 }; 493 494 extern int irq_get_irqchip_state(unsigned int irq, enum irqchip_irq_state which, 495 bool *state); 496 extern int irq_set_irqchip_state(unsigned int irq, enum irqchip_irq_state which, 497 bool state); 498 499 #ifdef CONFIG_IRQ_FORCED_THREADING 500 # ifdef CONFIG_PREEMPT_RT 501 # define force_irqthreads (true) 502 # else 503 extern bool force_irqthreads; 504 # endif 505 #else 506 #define force_irqthreads (0) 507 #endif 508 509 #ifndef local_softirq_pending 510 511 #ifndef local_softirq_pending_ref 512 #define local_softirq_pending_ref irq_stat.__softirq_pending 513 #endif 514 515 #define local_softirq_pending() (__this_cpu_read(local_softirq_pending_ref)) 516 #define set_softirq_pending(x) (__this_cpu_write(local_softirq_pending_ref, (x))) 517 #define or_softirq_pending(x) (__this_cpu_or(local_softirq_pending_ref, (x))) 518 519 #endif /* local_softirq_pending */ 520 521 /* Some architectures might implement lazy enabling/disabling of 522 * interrupts. In some cases, such as stop_machine, we might want 523 * to ensure that after a local_irq_disable(), interrupts have 524 * really been disabled in hardware. Such architectures need to 525 * implement the following hook. 526 */ 527 #ifndef hard_irq_disable 528 #define hard_irq_disable() do { } while(0) 529 #endif 530 531 /* PLEASE, avoid to allocate new softirqs, if you need not _really_ high 532 frequency threaded job scheduling. For almost all the purposes 533 tasklets are more than enough. F.e. all serial device BHs et 534 al. should be converted to tasklets, not to softirqs. 535 */ 536 537 enum 538 { 539 HI_SOFTIRQ=0, 540 TIMER_SOFTIRQ, 541 NET_TX_SOFTIRQ, 542 NET_RX_SOFTIRQ, 543 BLOCK_SOFTIRQ, 544 IRQ_POLL_SOFTIRQ, 545 TASKLET_SOFTIRQ, 546 SCHED_SOFTIRQ, 547 HRTIMER_SOFTIRQ, 548 RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */ 549 550 NR_SOFTIRQS 551 }; 552 553 #define SOFTIRQ_STOP_IDLE_MASK (~(1 << RCU_SOFTIRQ)) 554 555 /* map softirq index to softirq name. update 'softirq_to_name' in 556 * kernel/softirq.c when adding a new softirq. 557 */ 558 extern const char * const softirq_to_name[NR_SOFTIRQS]; 559 560 /* softirq mask and active fields moved to irq_cpustat_t in 561 * asm/hardirq.h to get better cache usage. KAO 562 */ 563 564 struct softirq_action 565 { 566 void (*action)(struct softirq_action *); 567 }; 568 569 asmlinkage void do_softirq(void); 570 asmlinkage void __do_softirq(void); 571 572 extern void open_softirq(int nr, void (*action)(struct softirq_action *)); 573 extern void softirq_init(void); 574 extern void __raise_softirq_irqoff(unsigned int nr); 575 576 extern void raise_softirq_irqoff(unsigned int nr); 577 extern void raise_softirq(unsigned int nr); 578 579 DECLARE_PER_CPU(struct task_struct *, ksoftirqd); 580 581 static inline struct task_struct *this_cpu_ksoftirqd(void) 582 { 583 return this_cpu_read(ksoftirqd); 584 } 585 586 /* Tasklets --- multithreaded analogue of BHs. 587 588 This API is deprecated. Please consider using threaded IRQs instead: 589 https://lore.kernel.org/lkml/20200716081538.2sivhkj4hcyrusem@linutronix.de 590 591 Main feature differing them of generic softirqs: tasklet 592 is running only on one CPU simultaneously. 593 594 Main feature differing them of BHs: different tasklets 595 may be run simultaneously on different CPUs. 596 597 Properties: 598 * If tasklet_schedule() is called, then tasklet is guaranteed 599 to be executed on some cpu at least once after this. 600 * If the tasklet is already scheduled, but its execution is still not 601 started, it will be executed only once. 602 * If this tasklet is already running on another CPU (or schedule is called 603 from tasklet itself), it is rescheduled for later. 604 * Tasklet is strictly serialized wrt itself, but not 605 wrt another tasklets. If client needs some intertask synchronization, 606 he makes it with spinlocks. 607 */ 608 609 struct tasklet_struct 610 { 611 struct tasklet_struct *next; 612 unsigned long state; 613 atomic_t count; 614 bool use_callback; 615 union { 616 void (*func)(unsigned long data); 617 void (*callback)(struct tasklet_struct *t); 618 }; 619 unsigned long data; 620 }; 621 622 #define DECLARE_TASKLET(name, _callback) \ 623 struct tasklet_struct name = { \ 624 .count = ATOMIC_INIT(0), \ 625 .callback = _callback, \ 626 .use_callback = true, \ 627 } 628 629 #define DECLARE_TASKLET_DISABLED(name, _callback) \ 630 struct tasklet_struct name = { \ 631 .count = ATOMIC_INIT(1), \ 632 .callback = _callback, \ 633 .use_callback = true, \ 634 } 635 636 #define from_tasklet(var, callback_tasklet, tasklet_fieldname) \ 637 container_of(callback_tasklet, typeof(*var), tasklet_fieldname) 638 639 #define DECLARE_TASKLET_OLD(name, _func) \ 640 struct tasklet_struct name = { \ 641 .count = ATOMIC_INIT(0), \ 642 .func = _func, \ 643 } 644 645 #define DECLARE_TASKLET_DISABLED_OLD(name, _func) \ 646 struct tasklet_struct name = { \ 647 .count = ATOMIC_INIT(1), \ 648 .func = _func, \ 649 } 650 651 enum 652 { 653 TASKLET_STATE_SCHED, /* Tasklet is scheduled for execution */ 654 TASKLET_STATE_RUN /* Tasklet is running (SMP only) */ 655 }; 656 657 #ifdef CONFIG_SMP 658 static inline int tasklet_trylock(struct tasklet_struct *t) 659 { 660 return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state); 661 } 662 663 static inline void tasklet_unlock(struct tasklet_struct *t) 664 { 665 smp_mb__before_atomic(); 666 clear_bit(TASKLET_STATE_RUN, &(t)->state); 667 } 668 669 static inline void tasklet_unlock_wait(struct tasklet_struct *t) 670 { 671 while (test_bit(TASKLET_STATE_RUN, &(t)->state)) { barrier(); } 672 } 673 #else 674 #define tasklet_trylock(t) 1 675 #define tasklet_unlock_wait(t) do { } while (0) 676 #define tasklet_unlock(t) do { } while (0) 677 #endif 678 679 extern void __tasklet_schedule(struct tasklet_struct *t); 680 681 static inline void tasklet_schedule(struct tasklet_struct *t) 682 { 683 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) 684 __tasklet_schedule(t); 685 } 686 687 extern void __tasklet_hi_schedule(struct tasklet_struct *t); 688 689 static inline void tasklet_hi_schedule(struct tasklet_struct *t) 690 { 691 if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) 692 __tasklet_hi_schedule(t); 693 } 694 695 static inline void tasklet_disable_nosync(struct tasklet_struct *t) 696 { 697 atomic_inc(&t->count); 698 smp_mb__after_atomic(); 699 } 700 701 static inline void tasklet_disable(struct tasklet_struct *t) 702 { 703 tasklet_disable_nosync(t); 704 tasklet_unlock_wait(t); 705 smp_mb(); 706 } 707 708 static inline void tasklet_enable(struct tasklet_struct *t) 709 { 710 smp_mb__before_atomic(); 711 atomic_dec(&t->count); 712 } 713 714 extern void tasklet_kill(struct tasklet_struct *t); 715 extern void tasklet_kill_immediate(struct tasklet_struct *t, unsigned int cpu); 716 extern void tasklet_init(struct tasklet_struct *t, 717 void (*func)(unsigned long), unsigned long data); 718 extern void tasklet_setup(struct tasklet_struct *t, 719 void (*callback)(struct tasklet_struct *)); 720 721 /* 722 * Autoprobing for irqs: 723 * 724 * probe_irq_on() and probe_irq_off() provide robust primitives 725 * for accurate IRQ probing during kernel initialization. They are 726 * reasonably simple to use, are not "fooled" by spurious interrupts, 727 * and, unlike other attempts at IRQ probing, they do not get hung on 728 * stuck interrupts (such as unused PS2 mouse interfaces on ASUS boards). 729 * 730 * For reasonably foolproof probing, use them as follows: 731 * 732 * 1. clear and/or mask the device's internal interrupt. 733 * 2. sti(); 734 * 3. irqs = probe_irq_on(); // "take over" all unassigned idle IRQs 735 * 4. enable the device and cause it to trigger an interrupt. 736 * 5. wait for the device to interrupt, using non-intrusive polling or a delay. 737 * 6. irq = probe_irq_off(irqs); // get IRQ number, 0=none, negative=multiple 738 * 7. service the device to clear its pending interrupt. 739 * 8. loop again if paranoia is required. 740 * 741 * probe_irq_on() returns a mask of allocated irq's. 742 * 743 * probe_irq_off() takes the mask as a parameter, 744 * and returns the irq number which occurred, 745 * or zero if none occurred, or a negative irq number 746 * if more than one irq occurred. 747 */ 748 749 #if !defined(CONFIG_GENERIC_IRQ_PROBE) 750 static inline unsigned long probe_irq_on(void) 751 { 752 return 0; 753 } 754 static inline int probe_irq_off(unsigned long val) 755 { 756 return 0; 757 } 758 static inline unsigned int probe_irq_mask(unsigned long val) 759 { 760 return 0; 761 } 762 #else 763 extern unsigned long probe_irq_on(void); /* returns 0 on failure */ 764 extern int probe_irq_off(unsigned long); /* returns 0 or negative on failure */ 765 extern unsigned int probe_irq_mask(unsigned long); /* returns mask of ISA interrupts */ 766 #endif 767 768 #ifdef CONFIG_PROC_FS 769 /* Initialize /proc/irq/ */ 770 extern void init_irq_proc(void); 771 #else 772 static inline void init_irq_proc(void) 773 { 774 } 775 #endif 776 777 #ifdef CONFIG_IRQ_TIMINGS 778 void irq_timings_enable(void); 779 void irq_timings_disable(void); 780 u64 irq_timings_next_event(u64 now); 781 #endif 782 783 struct seq_file; 784 int show_interrupts(struct seq_file *p, void *v); 785 int arch_show_interrupts(struct seq_file *p, int prec); 786 787 extern int early_irq_init(void); 788 extern int arch_probe_nr_irqs(void); 789 extern int arch_early_irq_init(void); 790 791 /* 792 * We want to know which function is an entrypoint of a hardirq or a softirq. 793 */ 794 #ifndef __irq_entry 795 # define __irq_entry __section(".irqentry.text") 796 #endif 797 798 #define __softirq_entry __section(".softirqentry.text") 799 800 #endif 801