1 #ifndef _LINUX_IRQ_H 2 #define _LINUX_IRQ_H 3 4 /* 5 * Please do not include this file in generic code. There is currently 6 * no requirement for any architecture to implement anything held 7 * within this file. 8 * 9 * Thanks. --rmk 10 */ 11 12 #include <linux/smp.h> 13 14 #ifndef CONFIG_S390 15 16 #include <linux/linkage.h> 17 #include <linux/cache.h> 18 #include <linux/spinlock.h> 19 #include <linux/cpumask.h> 20 #include <linux/gfp.h> 21 #include <linux/irqreturn.h> 22 #include <linux/irqnr.h> 23 #include <linux/errno.h> 24 #include <linux/topology.h> 25 #include <linux/wait.h> 26 27 #include <asm/irq.h> 28 #include <asm/ptrace.h> 29 #include <asm/irq_regs.h> 30 31 struct irq_desc; 32 struct irq_data; 33 typedef void (*irq_flow_handler_t)(unsigned int irq, 34 struct irq_desc *desc); 35 typedef void (*irq_preflow_handler_t)(struct irq_data *data); 36 37 /* 38 * IRQ line status. 39 * 40 * Bits 0-7 are the same as the IRQF_* bits in linux/interrupt.h 41 * 42 * IRQ_TYPE_NONE - default, unspecified type 43 * IRQ_TYPE_EDGE_RISING - rising edge triggered 44 * IRQ_TYPE_EDGE_FALLING - falling edge triggered 45 * IRQ_TYPE_EDGE_BOTH - rising and falling edge triggered 46 * IRQ_TYPE_LEVEL_HIGH - high level triggered 47 * IRQ_TYPE_LEVEL_LOW - low level triggered 48 * IRQ_TYPE_LEVEL_MASK - Mask to filter out the level bits 49 * IRQ_TYPE_SENSE_MASK - Mask for all the above bits 50 * IRQ_TYPE_PROBE - Special flag for probing in progress 51 * 52 * Bits which can be modified via irq_set/clear/modify_status_flags() 53 * IRQ_LEVEL - Interrupt is level type. Will be also 54 * updated in the code when the above trigger 55 * bits are modified via set_irq_type() 56 * IRQ_PER_CPU - Mark an interrupt PER_CPU. Will protect 57 * it from affinity setting 58 * IRQ_NOPROBE - Interrupt cannot be probed by autoprobing 59 * IRQ_NOREQUEST - Interrupt cannot be requested via 60 * request_irq() 61 * IRQ_NOAUTOEN - Interrupt is not automatically enabled in 62 * request/setup_irq() 63 * IRQ_NO_BALANCING - Interrupt cannot be balanced (affinity set) 64 * IRQ_MOVE_PCNTXT - Interrupt can be migrated from process context 65 * IRQ_NESTED_TRHEAD - Interrupt nests into another thread 66 * 67 * Deprecated bits. They are kept updated as long as 68 * CONFIG_GENERIC_HARDIRQS_NO_COMPAT is not set. Will go away soon. These bits 69 * are internal state of the core code and if you really need to acces 70 * them then talk to the genirq maintainer instead of hacking 71 * something weird. 72 * 73 */ 74 enum { 75 IRQ_TYPE_NONE = 0x00000000, 76 IRQ_TYPE_EDGE_RISING = 0x00000001, 77 IRQ_TYPE_EDGE_FALLING = 0x00000002, 78 IRQ_TYPE_EDGE_BOTH = (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING), 79 IRQ_TYPE_LEVEL_HIGH = 0x00000004, 80 IRQ_TYPE_LEVEL_LOW = 0x00000008, 81 IRQ_TYPE_LEVEL_MASK = (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH), 82 IRQ_TYPE_SENSE_MASK = 0x0000000f, 83 84 IRQ_TYPE_PROBE = 0x00000010, 85 86 IRQ_LEVEL = (1 << 8), 87 IRQ_PER_CPU = (1 << 9), 88 IRQ_NOPROBE = (1 << 10), 89 IRQ_NOREQUEST = (1 << 11), 90 IRQ_NOAUTOEN = (1 << 12), 91 IRQ_NO_BALANCING = (1 << 13), 92 IRQ_MOVE_PCNTXT = (1 << 14), 93 IRQ_NESTED_THREAD = (1 << 15), 94 95 #ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT 96 IRQ_INPROGRESS = (1 << 16), 97 IRQ_REPLAY = (1 << 17), 98 IRQ_WAITING = (1 << 18), 99 IRQ_DISABLED = (1 << 19), 100 IRQ_PENDING = (1 << 20), 101 IRQ_MASKED = (1 << 21), 102 IRQ_MOVE_PENDING = (1 << 22), 103 IRQ_AFFINITY_SET = (1 << 23), 104 IRQ_WAKEUP = (1 << 24), 105 #endif 106 }; 107 108 #define IRQF_MODIFY_MASK \ 109 (IRQ_TYPE_SENSE_MASK | IRQ_NOPROBE | IRQ_NOREQUEST | \ 110 IRQ_NOAUTOEN | IRQ_MOVE_PCNTXT | IRQ_LEVEL | IRQ_NO_BALANCING | \ 111 IRQ_PER_CPU | IRQ_NESTED_THREAD) 112 113 #define IRQ_NO_BALANCING_MASK (IRQ_PER_CPU | IRQ_NO_BALANCING) 114 115 static inline __deprecated bool CHECK_IRQ_PER_CPU(unsigned int status) 116 { 117 return status & IRQ_PER_CPU; 118 } 119 120 /* 121 * Return value for chip->irq_set_affinity() 122 * 123 * IRQ_SET_MASK_OK - OK, core updates irq_data.affinity 124 * IRQ_SET_MASK_NOCPY - OK, chip did update irq_data.affinity 125 */ 126 enum { 127 IRQ_SET_MASK_OK = 0, 128 IRQ_SET_MASK_OK_NOCOPY, 129 }; 130 131 struct msi_desc; 132 133 /** 134 * struct irq_data - per irq and irq chip data passed down to chip functions 135 * @irq: interrupt number 136 * @node: node index useful for balancing 137 * @state_use_accessor: status information for irq chip functions. 138 * Use accessor functions to deal with it 139 * @chip: low level interrupt hardware access 140 * @handler_data: per-IRQ data for the irq_chip methods 141 * @chip_data: platform-specific per-chip private data for the chip 142 * methods, to allow shared chip implementations 143 * @msi_desc: MSI descriptor 144 * @affinity: IRQ affinity on SMP 145 * 146 * The fields here need to overlay the ones in irq_desc until we 147 * cleaned up the direct references and switched everything over to 148 * irq_data. 149 */ 150 struct irq_data { 151 unsigned int irq; 152 unsigned int node; 153 unsigned int state_use_accessors; 154 struct irq_chip *chip; 155 void *handler_data; 156 void *chip_data; 157 struct msi_desc *msi_desc; 158 #ifdef CONFIG_SMP 159 cpumask_var_t affinity; 160 #endif 161 }; 162 163 /* 164 * Bit masks for irq_data.state 165 * 166 * IRQD_TRIGGER_MASK - Mask for the trigger type bits 167 * IRQD_SETAFFINITY_PENDING - Affinity setting is pending 168 * IRQD_NO_BALANCING - Balancing disabled for this IRQ 169 * IRQD_PER_CPU - Interrupt is per cpu 170 * IRQD_AFFINITY_SET - Interrupt affinity was set 171 * IRQD_LEVEL - Interrupt is level triggered 172 * IRQD_WAKEUP_STATE - Interrupt is configured for wakeup 173 * from suspend 174 * IRDQ_MOVE_PCNTXT - Interrupt can be moved in process 175 * context 176 */ 177 enum { 178 IRQD_TRIGGER_MASK = 0xf, 179 IRQD_SETAFFINITY_PENDING = (1 << 8), 180 IRQD_NO_BALANCING = (1 << 10), 181 IRQD_PER_CPU = (1 << 11), 182 IRQD_AFFINITY_SET = (1 << 12), 183 IRQD_LEVEL = (1 << 13), 184 IRQD_WAKEUP_STATE = (1 << 14), 185 IRQD_MOVE_PCNTXT = (1 << 15), 186 }; 187 188 static inline bool irqd_is_setaffinity_pending(struct irq_data *d) 189 { 190 return d->state_use_accessors & IRQD_SETAFFINITY_PENDING; 191 } 192 193 static inline bool irqd_is_per_cpu(struct irq_data *d) 194 { 195 return d->state_use_accessors & IRQD_PER_CPU; 196 } 197 198 static inline bool irqd_can_balance(struct irq_data *d) 199 { 200 return !(d->state_use_accessors & (IRQD_PER_CPU | IRQD_NO_BALANCING)); 201 } 202 203 static inline bool irqd_affinity_was_set(struct irq_data *d) 204 { 205 return d->state_use_accessors & IRQD_AFFINITY_SET; 206 } 207 208 static inline u32 irqd_get_trigger_type(struct irq_data *d) 209 { 210 return d->state_use_accessors & IRQD_TRIGGER_MASK; 211 } 212 213 /* 214 * Must only be called inside irq_chip.irq_set_type() functions. 215 */ 216 static inline void irqd_set_trigger_type(struct irq_data *d, u32 type) 217 { 218 d->state_use_accessors &= ~IRQD_TRIGGER_MASK; 219 d->state_use_accessors |= type & IRQD_TRIGGER_MASK; 220 } 221 222 static inline bool irqd_is_level_type(struct irq_data *d) 223 { 224 return d->state_use_accessors & IRQD_LEVEL; 225 } 226 227 static inline bool irqd_is_wakeup_set(struct irq_data *d) 228 { 229 return d->state_use_accessors & IRQD_WAKEUP_STATE; 230 } 231 232 static inline bool irqd_can_move_in_process_context(struct irq_data *d) 233 { 234 return d->state_use_accessors & IRQD_MOVE_PCNTXT; 235 } 236 237 /** 238 * struct irq_chip - hardware interrupt chip descriptor 239 * 240 * @name: name for /proc/interrupts 241 * @startup: deprecated, replaced by irq_startup 242 * @shutdown: deprecated, replaced by irq_shutdown 243 * @enable: deprecated, replaced by irq_enable 244 * @disable: deprecated, replaced by irq_disable 245 * @ack: deprecated, replaced by irq_ack 246 * @mask: deprecated, replaced by irq_mask 247 * @mask_ack: deprecated, replaced by irq_mask_ack 248 * @unmask: deprecated, replaced by irq_unmask 249 * @eoi: deprecated, replaced by irq_eoi 250 * @end: deprecated, will go away with __do_IRQ() 251 * @set_affinity: deprecated, replaced by irq_set_affinity 252 * @retrigger: deprecated, replaced by irq_retrigger 253 * @set_type: deprecated, replaced by irq_set_type 254 * @set_wake: deprecated, replaced by irq_wake 255 * @bus_lock: deprecated, replaced by irq_bus_lock 256 * @bus_sync_unlock: deprecated, replaced by irq_bus_sync_unlock 257 * 258 * @irq_startup: start up the interrupt (defaults to ->enable if NULL) 259 * @irq_shutdown: shut down the interrupt (defaults to ->disable if NULL) 260 * @irq_enable: enable the interrupt (defaults to chip->unmask if NULL) 261 * @irq_disable: disable the interrupt 262 * @irq_ack: start of a new interrupt 263 * @irq_mask: mask an interrupt source 264 * @irq_mask_ack: ack and mask an interrupt source 265 * @irq_unmask: unmask an interrupt source 266 * @irq_eoi: end of interrupt 267 * @irq_set_affinity: set the CPU affinity on SMP machines 268 * @irq_retrigger: resend an IRQ to the CPU 269 * @irq_set_type: set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ 270 * @irq_set_wake: enable/disable power-management wake-on of an IRQ 271 * @irq_bus_lock: function to lock access to slow bus (i2c) chips 272 * @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips 273 * @flags: chip specific flags 274 * 275 * @release: release function solely used by UML 276 */ 277 struct irq_chip { 278 const char *name; 279 #ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED 280 unsigned int (*startup)(unsigned int irq); 281 void (*shutdown)(unsigned int irq); 282 void (*enable)(unsigned int irq); 283 void (*disable)(unsigned int irq); 284 285 void (*ack)(unsigned int irq); 286 void (*mask)(unsigned int irq); 287 void (*mask_ack)(unsigned int irq); 288 void (*unmask)(unsigned int irq); 289 void (*eoi)(unsigned int irq); 290 291 void (*end)(unsigned int irq); 292 int (*set_affinity)(unsigned int irq, 293 const struct cpumask *dest); 294 int (*retrigger)(unsigned int irq); 295 int (*set_type)(unsigned int irq, unsigned int flow_type); 296 int (*set_wake)(unsigned int irq, unsigned int on); 297 298 void (*bus_lock)(unsigned int irq); 299 void (*bus_sync_unlock)(unsigned int irq); 300 #endif 301 unsigned int (*irq_startup)(struct irq_data *data); 302 void (*irq_shutdown)(struct irq_data *data); 303 void (*irq_enable)(struct irq_data *data); 304 void (*irq_disable)(struct irq_data *data); 305 306 void (*irq_ack)(struct irq_data *data); 307 void (*irq_mask)(struct irq_data *data); 308 void (*irq_mask_ack)(struct irq_data *data); 309 void (*irq_unmask)(struct irq_data *data); 310 void (*irq_eoi)(struct irq_data *data); 311 312 int (*irq_set_affinity)(struct irq_data *data, const struct cpumask *dest, bool force); 313 int (*irq_retrigger)(struct irq_data *data); 314 int (*irq_set_type)(struct irq_data *data, unsigned int flow_type); 315 int (*irq_set_wake)(struct irq_data *data, unsigned int on); 316 317 void (*irq_bus_lock)(struct irq_data *data); 318 void (*irq_bus_sync_unlock)(struct irq_data *data); 319 320 unsigned long flags; 321 322 /* Currently used only by UML, might disappear one day.*/ 323 #ifdef CONFIG_IRQ_RELEASE_METHOD 324 void (*release)(unsigned int irq, void *dev_id); 325 #endif 326 }; 327 328 /* 329 * irq_chip specific flags 330 * 331 * IRQCHIP_SET_TYPE_MASKED: Mask before calling chip.irq_set_type() 332 * IRQCHIP_EOI_IF_HANDLED: Only issue irq_eoi() when irq was handled 333 * IRQCHIP_MASK_ON_SUSPEND: Mask non wake irqs in the suspend path 334 */ 335 enum { 336 IRQCHIP_SET_TYPE_MASKED = (1 << 0), 337 IRQCHIP_EOI_IF_HANDLED = (1 << 1), 338 IRQCHIP_MASK_ON_SUSPEND = (1 << 2), 339 }; 340 341 /* This include will go away once we isolated irq_desc usage to core code */ 342 #include <linux/irqdesc.h> 343 344 /* 345 * Pick up the arch-dependent methods: 346 */ 347 #include <asm/hw_irq.h> 348 349 #ifndef NR_IRQS_LEGACY 350 # define NR_IRQS_LEGACY 0 351 #endif 352 353 #ifndef ARCH_IRQ_INIT_FLAGS 354 # define ARCH_IRQ_INIT_FLAGS 0 355 #endif 356 357 #define IRQ_DEFAULT_INIT_FLAGS ARCH_IRQ_INIT_FLAGS 358 359 struct irqaction; 360 extern int setup_irq(unsigned int irq, struct irqaction *new); 361 extern void remove_irq(unsigned int irq, struct irqaction *act); 362 363 #ifdef CONFIG_GENERIC_HARDIRQS 364 365 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ) 366 void move_native_irq(int irq); 367 void move_masked_irq(int irq); 368 void irq_move_irq(struct irq_data *data); 369 void irq_move_masked_irq(struct irq_data *data); 370 #else 371 static inline void move_native_irq(int irq) { } 372 static inline void move_masked_irq(int irq) { } 373 static inline void irq_move_irq(struct irq_data *data) { } 374 static inline void irq_move_masked_irq(struct irq_data *data) { } 375 #endif 376 377 extern int no_irq_affinity; 378 379 /* Handle irq action chains: */ 380 extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action); 381 382 /* 383 * Built-in IRQ handlers for various IRQ types, 384 * callable via desc->handle_irq() 385 */ 386 extern void handle_level_irq(unsigned int irq, struct irq_desc *desc); 387 extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc); 388 extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc); 389 extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc); 390 extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc); 391 extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc); 392 extern void handle_nested_irq(unsigned int irq); 393 394 /* Handling of unhandled and spurious interrupts: */ 395 extern void note_interrupt(unsigned int irq, struct irq_desc *desc, 396 irqreturn_t action_ret); 397 398 399 /* Enable/disable irq debugging output: */ 400 extern int noirqdebug_setup(char *str); 401 402 /* Checks whether the interrupt can be requested by request_irq(): */ 403 extern int can_request_irq(unsigned int irq, unsigned long irqflags); 404 405 /* Dummy irq-chip implementations: */ 406 extern struct irq_chip no_irq_chip; 407 extern struct irq_chip dummy_irq_chip; 408 409 extern void 410 irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip, 411 irq_flow_handler_t handle, const char *name); 412 413 static inline void irq_set_chip_and_handler(unsigned int irq, struct irq_chip *chip, 414 irq_flow_handler_t handle) 415 { 416 irq_set_chip_and_handler_name(irq, chip, handle, NULL); 417 } 418 419 extern void 420 __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained, 421 const char *name); 422 423 static inline void 424 irq_set_handler(unsigned int irq, irq_flow_handler_t handle) 425 { 426 __irq_set_handler(irq, handle, 0, NULL); 427 } 428 429 /* 430 * Set a highlevel chained flow handler for a given IRQ. 431 * (a chained handler is automatically enabled and set to 432 * IRQ_NOREQUEST and IRQ_NOPROBE) 433 */ 434 static inline void 435 irq_set_chained_handler(unsigned int irq, irq_flow_handler_t handle) 436 { 437 __irq_set_handler(irq, handle, 1, NULL); 438 } 439 440 void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set); 441 442 static inline void irq_set_status_flags(unsigned int irq, unsigned long set) 443 { 444 irq_modify_status(irq, 0, set); 445 } 446 447 static inline void irq_clear_status_flags(unsigned int irq, unsigned long clr) 448 { 449 irq_modify_status(irq, clr, 0); 450 } 451 452 static inline void irq_set_noprobe(unsigned int irq) 453 { 454 irq_modify_status(irq, 0, IRQ_NOPROBE); 455 } 456 457 static inline void irq_set_probe(unsigned int irq) 458 { 459 irq_modify_status(irq, IRQ_NOPROBE, 0); 460 } 461 462 static inline void irq_set_nested_thread(unsigned int irq, bool nest) 463 { 464 if (nest) 465 irq_set_status_flags(irq, IRQ_NESTED_THREAD); 466 else 467 irq_clear_status_flags(irq, IRQ_NESTED_THREAD); 468 } 469 470 /* Handle dynamic irq creation and destruction */ 471 extern unsigned int create_irq_nr(unsigned int irq_want, int node); 472 extern int create_irq(void); 473 extern void destroy_irq(unsigned int irq); 474 475 /* 476 * Dynamic irq helper functions. Obsolete. Use irq_alloc_desc* and 477 * irq_free_desc instead. 478 */ 479 extern void dynamic_irq_cleanup(unsigned int irq); 480 static inline void dynamic_irq_init(unsigned int irq) 481 { 482 dynamic_irq_cleanup(irq); 483 } 484 485 /* Set/get chip/data for an IRQ: */ 486 extern int irq_set_chip(unsigned int irq, struct irq_chip *chip); 487 extern int irq_set_handler_data(unsigned int irq, void *data); 488 extern int irq_set_chip_data(unsigned int irq, void *data); 489 extern int irq_set_irq_type(unsigned int irq, unsigned int type); 490 extern int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry); 491 extern struct irq_data *irq_get_irq_data(unsigned int irq); 492 493 static inline struct irq_chip *irq_get_chip(unsigned int irq) 494 { 495 struct irq_data *d = irq_get_irq_data(irq); 496 return d ? d->chip : NULL; 497 } 498 499 static inline struct irq_chip *irq_data_get_irq_chip(struct irq_data *d) 500 { 501 return d->chip; 502 } 503 504 static inline void *irq_get_chip_data(unsigned int irq) 505 { 506 struct irq_data *d = irq_get_irq_data(irq); 507 return d ? d->chip_data : NULL; 508 } 509 510 static inline void *irq_data_get_irq_chip_data(struct irq_data *d) 511 { 512 return d->chip_data; 513 } 514 515 static inline void *irq_get_handler_data(unsigned int irq) 516 { 517 struct irq_data *d = irq_get_irq_data(irq); 518 return d ? d->handler_data : NULL; 519 } 520 521 static inline void *irq_data_get_irq_handler_data(struct irq_data *d) 522 { 523 return d->handler_data; 524 } 525 526 static inline struct msi_desc *irq_get_msi_desc(unsigned int irq) 527 { 528 struct irq_data *d = irq_get_irq_data(irq); 529 return d ? d->msi_desc : NULL; 530 } 531 532 static inline struct msi_desc *irq_data_get_msi(struct irq_data *d) 533 { 534 return d->msi_desc; 535 } 536 537 #ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT 538 /* Please do not use: Use the replacement functions instead */ 539 static inline int set_irq_chip(unsigned int irq, struct irq_chip *chip) 540 { 541 return irq_set_chip(irq, chip); 542 } 543 static inline int set_irq_data(unsigned int irq, void *data) 544 { 545 return irq_set_handler_data(irq, data); 546 } 547 static inline int set_irq_chip_data(unsigned int irq, void *data) 548 { 549 return irq_set_chip_data(irq, data); 550 } 551 static inline int set_irq_type(unsigned int irq, unsigned int type) 552 { 553 return irq_set_irq_type(irq, type); 554 } 555 static inline int set_irq_msi(unsigned int irq, struct msi_desc *entry) 556 { 557 return irq_set_msi_desc(irq, entry); 558 } 559 static inline struct irq_chip *get_irq_chip(unsigned int irq) 560 { 561 return irq_get_chip(irq); 562 } 563 static inline void *get_irq_chip_data(unsigned int irq) 564 { 565 return irq_get_chip_data(irq); 566 } 567 static inline void *get_irq_data(unsigned int irq) 568 { 569 return irq_get_handler_data(irq); 570 } 571 static inline void *irq_data_get_irq_data(struct irq_data *d) 572 { 573 return irq_data_get_irq_handler_data(d); 574 } 575 static inline struct msi_desc *get_irq_msi(unsigned int irq) 576 { 577 return irq_get_msi_desc(irq); 578 } 579 static inline void set_irq_noprobe(unsigned int irq) 580 { 581 irq_set_noprobe(irq); 582 } 583 static inline void set_irq_probe(unsigned int irq) 584 { 585 irq_set_probe(irq); 586 } 587 static inline void set_irq_nested_thread(unsigned int irq, int nest) 588 { 589 irq_set_nested_thread(irq, nest); 590 } 591 static inline void 592 set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip, 593 irq_flow_handler_t handle, const char *name) 594 { 595 irq_set_chip_and_handler_name(irq, chip, handle, name); 596 } 597 static inline void 598 set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip, 599 irq_flow_handler_t handle) 600 { 601 irq_set_chip_and_handler(irq, chip, handle); 602 } 603 static inline void 604 __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained, 605 const char *name) 606 { 607 __irq_set_handler(irq, handle, is_chained, name); 608 } 609 static inline void set_irq_handler(unsigned int irq, irq_flow_handler_t handle) 610 { 611 irq_set_handler(irq, handle); 612 } 613 static inline void 614 set_irq_chained_handler(unsigned int irq, irq_flow_handler_t handle) 615 { 616 irq_set_chained_handler(irq, handle); 617 } 618 #endif 619 620 int irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node); 621 void irq_free_descs(unsigned int irq, unsigned int cnt); 622 int irq_reserve_irqs(unsigned int from, unsigned int cnt); 623 624 static inline int irq_alloc_desc(int node) 625 { 626 return irq_alloc_descs(-1, 0, 1, node); 627 } 628 629 static inline int irq_alloc_desc_at(unsigned int at, int node) 630 { 631 return irq_alloc_descs(at, at, 1, node); 632 } 633 634 static inline int irq_alloc_desc_from(unsigned int from, int node) 635 { 636 return irq_alloc_descs(-1, from, 1, node); 637 } 638 639 static inline void irq_free_desc(unsigned int irq) 640 { 641 irq_free_descs(irq, 1); 642 } 643 644 static inline int irq_reserve_irq(unsigned int irq) 645 { 646 return irq_reserve_irqs(irq, 1); 647 } 648 649 #endif /* CONFIG_GENERIC_HARDIRQS */ 650 651 #endif /* !CONFIG_S390 */ 652 653 #endif /* _LINUX_IRQ_H */ 654