kernel/irq/chip.c

   1 /*
   2  * linux/kernel/irq/chip.c
   3  *
   4  * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
   5  * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
   6  *
   7  * This file contains the core interrupt handling code, for irq-chip
   8  * based architectures.
   9  *
  10  * Detailed information is available in Documentation/DocBook/genericirq
  11  */
  12
  13 #include <linux/irq.h>
  14 #include <linux/msi.h>
  15 #include <linux/module.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/kernel_stat.h>
  18
  19 #include "internals.h"
  20
  21 /**
  22  *      irq_set_chip - set the irq chip for an irq
  23  *      @irq:   irq number
  24  *      @chip:  pointer to irq chip description structure
  25  */
  26 int irq_set_chip(unsigned int irq, struct irq_chip *chip)
  27 {
  28         unsigned long flags;
  29         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
  30
  31         if (!desc)
  32                 return -EINVAL;
  33
  34         if (!chip)
  35                 chip = &no_irq_chip;
  36
  37         desc->irq_data.chip = chip;
  38         irq_put_desc_unlock(desc, flags);
  39         /*
  40          * For !CONFIG_SPARSE_IRQ make the irq show up in
  41          * allocated_irqs. For the CONFIG_SPARSE_IRQ case, it is
  42          * already marked, and this call is harmless.
  43          */
  44         irq_reserve_irq(irq);
  45         return 0;
  46 }
  47 EXPORT_SYMBOL(irq_set_chip);
  48
  49 /**
  50  *      irq_set_type - set the irq trigger type for an irq
  51  *      @irq:   irq number
  52  *      @type:  IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
  53  */
  54 int irq_set_irq_type(unsigned int irq, unsigned int type)
  55 {
  56         unsigned long flags;
  57         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
  58         int ret = 0;
  59
  60         if (!desc)
  61                 return -EINVAL;
  62
  63         type &= IRQ_TYPE_SENSE_MASK;
  64         if (type != IRQ_TYPE_NONE)
  65                 ret = __irq_set_trigger(desc, irq, type);
  66         irq_put_desc_busunlock(desc, flags);
  67         return ret;
  68 }
  69 EXPORT_SYMBOL(irq_set_irq_type);
  70
  71 /**
  72  *      irq_set_handler_data - set irq handler data for an irq
  73  *      @irq:   Interrupt number
  74  *      @data:  Pointer to interrupt specific data
  75  *
  76  *      Set the hardware irq controller data for an irq
  77  */
  78 int irq_set_handler_data(unsigned int irq, void *data)
  79 {
  80         unsigned long flags;
  81         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
  82
  83         if (!desc)
  84                 return -EINVAL;
  85         desc->irq_data.handler_data = data;
  86         irq_put_desc_unlock(desc, flags);
  87         return 0;
  88 }
  89 EXPORT_SYMBOL(irq_set_handler_data);
  90
  91 /**
  92  *      irq_set_msi_desc - set MSI descriptor data for an irq
  93  *      @irq:   Interrupt number
  94  *      @entry: Pointer to MSI descriptor data
  95  *
  96  *      Set the MSI descriptor entry for an irq
  97  */
  98 int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry)
  99 {
 100         unsigned long flags;
 101         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
 102
 103         if (!desc)
 104                 return -EINVAL;
 105         desc->irq_data.msi_desc = entry;
 106         if (entry)
 107                 entry->irq = irq;
 108         irq_put_desc_unlock(desc, flags);
 109         return 0;
 110 }
 111
 112 /**
 113  *      irq_set_chip_data - set irq chip data for an irq
 114  *      @irq:   Interrupt number
 115  *      @data:  Pointer to chip specific data
 116  *
 117  *      Set the hardware irq chip data for an irq
 118  */
 119 int irq_set_chip_data(unsigned int irq, void *data)
 120 {
 121         unsigned long flags;
 122         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
 123
 124         if (!desc)
 125                 return -EINVAL;
 126         desc->irq_data.chip_data = data;
 127         irq_put_desc_unlock(desc, flags);
 128         return 0;
 129 }
 130 EXPORT_SYMBOL(irq_set_chip_data);
 131
 132 struct irq_data *irq_get_irq_data(unsigned int irq)
 133 {
 134         struct irq_desc *desc = irq_to_desc(irq);
 135
 136         return desc ? &desc->irq_data : NULL;
 137 }
 138 EXPORT_SYMBOL_GPL(irq_get_irq_data);
 139
 140 static void irq_state_clr_disabled(struct irq_desc *desc)
 141 {
 142         irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
 143 }
 144
 145 static void irq_state_set_disabled(struct irq_desc *desc)
 146 {
 147         irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
 148 }
 149
 150 static void irq_state_clr_masked(struct irq_desc *desc)
 151 {
 152         irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
 153 }
 154
 155 static void irq_state_set_masked(struct irq_desc *desc)
 156 {
 157         irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
 158 }
 159
 160 int irq_startup(struct irq_desc *desc)
 161 {
 162         irq_state_clr_disabled(desc);
 163         desc->depth = 0;
 164
 165         if (desc->irq_data.chip->irq_startup) {
 166                 int ret = desc->irq_data.chip->irq_startup(&desc->irq_data);
 167                 irq_state_clr_masked(desc);
 168                 return ret;
 169         }
 170
 171         irq_enable(desc);
 172         return 0;
 173 }
 174
 175 void irq_shutdown(struct irq_desc *desc)
 176 {
 177         irq_state_set_disabled(desc);
 178         desc->depth = 1;
 179         if (desc->irq_data.chip->irq_shutdown)
 180                 desc->irq_data.chip->irq_shutdown(&desc->irq_data);
 181         else if (desc->irq_data.chip->irq_disable)
 182                 desc->irq_data.chip->irq_disable(&desc->irq_data);
 183         else
 184                 desc->irq_data.chip->irq_mask(&desc->irq_data);
 185         irq_state_set_masked(desc);
 186 }
 187
 188 void irq_enable(struct irq_desc *desc)
 189 {
 190         irq_state_clr_disabled(desc);
 191         if (desc->irq_data.chip->irq_enable)
 192                 desc->irq_data.chip->irq_enable(&desc->irq_data);
 193         else
 194                 desc->irq_data.chip->irq_unmask(&desc->irq_data);
 195         irq_state_clr_masked(desc);
 196 }
 197
 198 void irq_disable(struct irq_desc *desc)
 199 {
 200         irq_state_set_disabled(desc);
 201         if (desc->irq_data.chip->irq_disable) {
 202                 desc->irq_data.chip->irq_disable(&desc->irq_data);
 203                 irq_state_set_masked(desc);
 204         }
 205 }
 206
 207 void irq_percpu_enable(struct irq_desc *desc, unsigned int cpu)
 208 {
 209         if (desc->irq_data.chip->irq_enable)
 210                 desc->irq_data.chip->irq_enable(&desc->irq_data);
 211         else
 212                 desc->irq_data.chip->irq_unmask(&desc->irq_data);
 213         cpumask_set_cpu(cpu, desc->percpu_enabled);
 214 }
 215
 216 void irq_percpu_disable(struct irq_desc *desc, unsigned int cpu)
 217 {
 218         if (desc->irq_data.chip->irq_disable)
 219                 desc->irq_data.chip->irq_disable(&desc->irq_data);
 220         else
 221                 desc->irq_data.chip->irq_mask(&desc->irq_data);
 222         cpumask_clear_cpu(cpu, desc->percpu_enabled);
 223 }
 224
 225 static inline void mask_ack_irq(struct irq_desc *desc)
 226 {
 227         if (desc->irq_data.chip->irq_mask_ack)
 228                 desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
 229         else {
 230                 desc->irq_data.chip->irq_mask(&desc->irq_data);
 231                 if (desc->irq_data.chip->irq_ack)
 232                         desc->irq_data.chip->irq_ack(&desc->irq_data);
 233         }
 234         irq_state_set_masked(desc);
 235 }
 236
 237 void mask_irq(struct irq_desc *desc)
 238 {
 239         if (desc->irq_data.chip->irq_mask) {
 240                 desc->irq_data.chip->irq_mask(&desc->irq_data);
 241                 irq_state_set_masked(desc);
 242         }
 243 }
 244
 245 void unmask_irq(struct irq_desc *desc)
 246 {
 247         if (desc->irq_data.chip->irq_unmask) {
 248                 desc->irq_data.chip->irq_unmask(&desc->irq_data);
 249                 irq_state_clr_masked(desc);
 250         }
 251 }
 252
 253 /*
 254  *      handle_nested_irq - Handle a nested irq from a irq thread
 255  *      @irq:   the interrupt number
 256  *
 257  *      Handle interrupts which are nested into a threaded interrupt
 258  *      handler. The handler function is called inside the calling
 259  *      threads context.
 260  */
 261 void handle_nested_irq(unsigned int irq)
 262 {
 263         struct irq_desc *desc = irq_to_desc(irq);
 264         struct irqaction *action;
 265         irqreturn_t action_ret;
 266
 267         might_sleep();
 268
 269         raw_spin_lock_irq(&desc->lock);
 270
 271         kstat_incr_irqs_this_cpu(irq, desc);
 272
 273         action = desc->action;
 274         if (unlikely(!action || irqd_irq_disabled(&desc->irq_data)))
 275                 goto out_unlock;
 276
 277         irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
 278         raw_spin_unlock_irq(&desc->lock);
 279
 280         action_ret = action->thread_fn(action->irq, action->dev_id);
 281         if (!noirqdebug)
 282                 note_interrupt(irq, desc, action_ret);
 283
 284         raw_spin_lock_irq(&desc->lock);
 285         irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
 286
 287 out_unlock:
 288         raw_spin_unlock_irq(&desc->lock);
 289 }
 290 EXPORT_SYMBOL_GPL(handle_nested_irq);
 291
 292 static bool irq_check_poll(struct irq_desc *desc)
 293 {
 294         if (!(desc->istate & IRQS_POLL_INPROGRESS))
 295                 return false;
 296         return irq_wait_for_poll(desc);
 297 }
 298
 299 /**
 300  *      handle_simple_irq - Simple and software-decoded IRQs.
 301  *      @irq:   the interrupt number
 302  *      @desc:  the interrupt description structure for this irq
 303  *
 304  *      Simple interrupts are either sent from a demultiplexing interrupt
 305  *      handler or come from hardware, where no interrupt hardware control
 306  *      is necessary.
 307  *
 308  *      Note: The caller is expected to handle the ack, clear, mask and
 309  *      unmask issues if necessary.
 310  */
 311 void
 312 handle_simple_irq(unsigned int irq, struct irq_desc *desc)
 313 {
 314         raw_spin_lock(&desc->lock);
 315
 316         if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
 317                 if (!irq_check_poll(desc))
 318                         goto out_unlock;
 319
 320         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 321         kstat_incr_irqs_this_cpu(irq, desc);
 322
 323         if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))
 324                 goto out_unlock;
 325
 326         handle_irq_event(desc);
 327
 328 out_unlock:
 329         raw_spin_unlock(&desc->lock);
 330 }
 331 EXPORT_SYMBOL_GPL(handle_simple_irq);
 332
 333 /*
 334  * Called unconditionally from handle_level_irq() and only for oneshot
 335  * interrupts from handle_fasteoi_irq()
 336  */
 337 static void cond_unmask_irq(struct irq_desc *desc)
 338 {
 339         /*
 340          * We need to unmask in the following cases:
 341          * - Standard level irq (IRQF_ONESHOT is not set)
 342          * - Oneshot irq which did not wake the thread (caused by a
 343          *   spurious interrupt or a primary handler handling it
 344          *   completely).
 345          */
 346         if (!irqd_irq_disabled(&desc->irq_data) &&
 347             irqd_irq_masked(&desc->irq_data) && !desc->threads_oneshot)
 348                 unmask_irq(desc);
 349 }
 350
 351 /**
 352  *      handle_level_irq - Level type irq handler
 353  *      @irq:   the interrupt number
 354  *      @desc:  the interrupt description structure for this irq
 355  *
 356  *      Level type interrupts are active as long as the hardware line has
 357  *      the active level. This may require to mask the interrupt and unmask
 358  *      it after the associated handler has acknowledged the device, so the
 359  *      interrupt line is back to inactive.
 360  */
 361 void
 362 handle_level_irq(unsigned int irq, struct irq_desc *desc)
 363 {
 364         raw_spin_lock(&desc->lock);
 365         mask_ack_irq(desc);
 366
 367         if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
 368                 if (!irq_check_poll(desc))
 369                         goto out_unlock;
 370
 371         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 372         kstat_incr_irqs_this_cpu(irq, desc);
 373
 374         /*
 375          * If its disabled or no action available
 376          * keep it masked and get out of here
 377          */
 378         if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data)))
 379                 goto out_unlock;
 380
 381         handle_irq_event(desc);
 382
 383         cond_unmask_irq(desc);
 384
 385 out_unlock:
 386         raw_spin_unlock(&desc->lock);
 387 }
 388 EXPORT_SYMBOL_GPL(handle_level_irq);
 389
 390 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI
 391 static inline void preflow_handler(struct irq_desc *desc)
 392 {
 393         if (desc->preflow_handler)
 394                 desc->preflow_handler(&desc->irq_data);
 395 }
 396 #else
 397 static inline void preflow_handler(struct irq_desc *desc) { }
 398 #endif
 399
 400 /**
 401  *      handle_fasteoi_irq - irq handler for transparent controllers
 402  *      @irq:   the interrupt number
 403  *      @desc:  the interrupt description structure for this irq
 404  *
 405  *      Only a single callback will be issued to the chip: an ->eoi()
 406  *      call when the interrupt has been serviced. This enables support
 407  *      for modern forms of interrupt handlers, which handle the flow
 408  *      details in hardware, transparently.
 409  */
 410 void
 411 handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
 412 {
 413         raw_spin_lock(&desc->lock);
 414
 415         if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
 416                 if (!irq_check_poll(desc))
 417                         goto out;
 418
 419         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 420         kstat_incr_irqs_this_cpu(irq, desc);
 421
 422         /*
 423          * If its disabled or no action available
 424          * then mask it and get out of here:
 425          */
 426         if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
 427                 desc->istate |= IRQS_PENDING;
 428                 mask_irq(desc);
 429                 goto out;
 430         }
 431
 432         if (desc->istate & IRQS_ONESHOT)
 433                 mask_irq(desc);
 434
 435         preflow_handler(desc);
 436         handle_irq_event(desc);
 437
 438         if (desc->istate & IRQS_ONESHOT)
 439                 cond_unmask_irq(desc);
 440
 441 out_eoi:
 442         desc->irq_data.chip->irq_eoi(&desc->irq_data);
 443 out_unlock:
 444         raw_spin_unlock(&desc->lock);
 445         return;
 446 out:
 447         if (!(desc->irq_data.chip->flags & IRQCHIP_EOI_IF_HANDLED))
 448                 goto out_eoi;
 449         goto out_unlock;
 450 }
 451
 452 /**
 453  *      handle_edge_irq - edge type IRQ handler
 454  *      @irq:   the interrupt number
 455  *      @desc:  the interrupt description structure for this irq
 456  *
 457  *      Interrupt occures on the falling and/or rising edge of a hardware
 458  *      signal. The occurrence is latched into the irq controller hardware
 459  *      and must be acked in order to be reenabled. After the ack another
 460  *      interrupt can happen on the same source even before the first one
 461  *      is handled by the associated event handler. If this happens it
 462  *      might be necessary to disable (mask) the interrupt depending on the
 463  *      controller hardware. This requires to reenable the interrupt inside
 464  *      of the loop which handles the interrupts which have arrived while
 465  *      the handler was running. If all pending interrupts are handled, the
 466  *      loop is left.
 467  */
 468 void
 469 handle_edge_irq(unsigned int irq, struct irq_desc *desc)
 470 {
 471         raw_spin_lock(&desc->lock);
 472
 473         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 474         /*
 475          * If we're currently running this IRQ, or its disabled,
 476          * we shouldn't process the IRQ. Mark it pending, handle
 477          * the necessary masking and go out
 478          */
 479         if (unlikely(irqd_irq_disabled(&desc->irq_data) ||
 480                      irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {
 481                 if (!irq_check_poll(desc)) {
 482                         desc->istate |= IRQS_PENDING;
 483                         mask_ack_irq(desc);
 484                         goto out_unlock;
 485                 }
 486         }
 487         kstat_incr_irqs_this_cpu(irq, desc);
 488
 489         /* Start handling the irq */
 490         desc->irq_data.chip->irq_ack(&desc->irq_data);
 491
 492         do {
 493                 if (unlikely(!desc->action)) {
 494                         mask_irq(desc);
 495                         goto out_unlock;
 496                 }
 497
 498                 /*
 499                  * When another irq arrived while we were handling
 500                  * one, we could have masked the irq.
 501                  * Renable it, if it was not disabled in meantime.
 502                  */
 503                 if (unlikely(desc->istate & IRQS_PENDING)) {
 504                         if (!irqd_irq_disabled(&desc->irq_data) &&
 505                             irqd_irq_masked(&desc->irq_data))
 506                                 unmask_irq(desc);
 507                 }
 508
 509                 handle_irq_event(desc);
 510
 511         } while ((desc->istate & IRQS_PENDING) &&
 512                  !irqd_irq_disabled(&desc->irq_data));
 513
 514 out_unlock:
 515         raw_spin_unlock(&desc->lock);
 516 }
 517
 518 #ifdef CONFIG_IRQ_EDGE_EOI_HANDLER
 519 /**
 520  *      handle_edge_eoi_irq - edge eoi type IRQ handler
 521  *      @irq:   the interrupt number
 522  *      @desc:  the interrupt description structure for this irq
 523  *
 524  * Similar as the above handle_edge_irq, but using eoi and w/o the
 525  * mask/unmask logic.
 526  */
 527 void handle_edge_eoi_irq(unsigned int irq, struct irq_desc *desc)
 528 {
 529         struct irq_chip *chip = irq_desc_get_chip(desc);
 530
 531         raw_spin_lock(&desc->lock);
 532
 533         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 534         /*
 535          * If we're currently running this IRQ, or its disabled,
 536          * we shouldn't process the IRQ. Mark it pending, handle
 537          * the necessary masking and go out
 538          */
 539         if (unlikely(irqd_irq_disabled(&desc->irq_data) ||
 540                      irqd_irq_inprogress(&desc->irq_data) || !desc->action)) {
 541                 if (!irq_check_poll(desc)) {
 542                         desc->istate |= IRQS_PENDING;
 543                         goto out_eoi;
 544                 }
 545         }
 546         kstat_incr_irqs_this_cpu(irq, desc);
 547
 548         do {
 549                 if (unlikely(!desc->action))
 550                         goto out_eoi;
 551
 552                 handle_irq_event(desc);
 553
 554         } while ((desc->istate & IRQS_PENDING) &&
 555                  !irqd_irq_disabled(&desc->irq_data));
 556
 557 out_eoi:
 558         chip->irq_eoi(&desc->irq_data);
 559         raw_spin_unlock(&desc->lock);
 560 }
 561 #endif
 562
 563 /**
 564  *      handle_percpu_irq - Per CPU local irq handler
 565  *      @irq:   the interrupt number
 566  *      @desc:  the interrupt description structure for this irq
 567  *
 568  *      Per CPU interrupts on SMP machines without locking requirements
 569  */
 570 void
 571 handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
 572 {
 573         struct irq_chip *chip = irq_desc_get_chip(desc);
 574
 575         kstat_incr_irqs_this_cpu(irq, desc);
 576
 577         if (chip->irq_ack)
 578                 chip->irq_ack(&desc->irq_data);
 579
 580         handle_irq_event_percpu(desc, desc->action);
 581
 582         if (chip->irq_eoi)
 583                 chip->irq_eoi(&desc->irq_data);
 584 }
 585
 586 /**
 587  * handle_percpu_devid_irq - Per CPU local irq handler with per cpu dev ids
 588  * @irq:        the interrupt number
 589  * @desc:       the interrupt description structure for this irq
 590  *
 591  * Per CPU interrupts on SMP machines without locking requirements. Same as
 592  * handle_percpu_irq() above but with the following extras:
 593  *
 594  * action->percpu_dev_id is a pointer to percpu variables which
 595  * contain the real device id for the cpu on which this handler is
 596  * called
 597  */
 598 void handle_percpu_devid_irq(unsigned int irq, struct irq_desc *desc)
 599 {
 600         struct irq_chip *chip = irq_desc_get_chip(desc);
 601         struct irqaction *action = desc->action;
 602         void *dev_id = __this_cpu_ptr(action->percpu_dev_id);
 603         irqreturn_t res;
 604
 605         kstat_incr_irqs_this_cpu(irq, desc);
 606
 607         if (chip->irq_ack)
 608                 chip->irq_ack(&desc->irq_data);
 609
 610         trace_irq_handler_entry(irq, action);
 611         res = action->handler(irq, dev_id);
 612         trace_irq_handler_exit(irq, action, res);
 613
 614         if (chip->irq_eoi)
 615                 chip->irq_eoi(&desc->irq_data);
 616 }
 617
 618 void
 619 __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
 620                   const char *name)
 621 {
 622         unsigned long flags;
 623         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, 0);
 624
 625         if (!desc)
 626                 return;
 627
 628         if (!handle) {
 629                 handle = handle_bad_irq;
 630         } else {
 631                 if (WARN_ON(desc->irq_data.chip == &no_irq_chip))
 632                         goto out;
 633         }
 634
 635         /* Uninstall? */
 636         if (handle == handle_bad_irq) {
 637                 if (desc->irq_data.chip != &no_irq_chip)
 638                         mask_ack_irq(desc);
 639                 irq_state_set_disabled(desc);
 640                 desc->depth = 1;
 641         }
 642         desc->handle_irq = handle;
 643         desc->name = name;
 644
 645         if (handle != handle_bad_irq && is_chained) {
 646                 irq_settings_set_noprobe(desc);
 647                 irq_settings_set_norequest(desc);
 648                 irq_settings_set_nothread(desc);
 649                 irq_startup(desc);
 650         }
 651 out:
 652         irq_put_desc_busunlock(desc, flags);
 653 }
 654 EXPORT_SYMBOL_GPL(__irq_set_handler);
 655
 656 void
 657 irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
 658                               irq_flow_handler_t handle, const char *name)
 659 {
 660         irq_set_chip(irq, chip);
 661         __irq_set_handler(irq, handle, 0, name);
 662 }
 663
 664 void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
 665 {
 666         unsigned long flags;
 667         struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
 668
 669         if (!desc)
 670                 return;
 671         irq_settings_clr_and_set(desc, clr, set);
 672
 673         irqd_clear(&desc->irq_data, IRQD_NO_BALANCING | IRQD_PER_CPU |
 674                    IRQD_TRIGGER_MASK | IRQD_LEVEL | IRQD_MOVE_PCNTXT);
 675         if (irq_settings_has_no_balance_set(desc))
 676                 irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
 677         if (irq_settings_is_per_cpu(desc))
 678                 irqd_set(&desc->irq_data, IRQD_PER_CPU);
 679         if (irq_settings_can_move_pcntxt(desc))
 680                 irqd_set(&desc->irq_data, IRQD_MOVE_PCNTXT);
 681         if (irq_settings_is_level(desc))
 682                 irqd_set(&desc->irq_data, IRQD_LEVEL);
 683
 684         irqd_set(&desc->irq_data, irq_settings_get_trigger_mask(desc));
 685
 686         irq_put_desc_unlock(desc, flags);
 687 }
 688 EXPORT_SYMBOL_GPL(irq_modify_status);
 689
 690 /**
 691  *      irq_cpu_online - Invoke all irq_cpu_online functions.
 692  *
 693  *      Iterate through all irqs and invoke the chip.irq_cpu_online()
 694  *      for each.
 695  */
 696 void irq_cpu_online(void)
 697 {
 698         struct irq_desc *desc;
 699         struct irq_chip *chip;
 700         unsigned long flags;
 701         unsigned int irq;
 702
 703         for_each_active_irq(irq) {
 704                 desc = irq_to_desc(irq);
 705                 if (!desc)
 706                         continue;
 707
 708                 raw_spin_lock_irqsave(&desc->lock, flags);
 709
 710                 chip = irq_data_get_irq_chip(&desc->irq_data);
 711                 if (chip && chip->irq_cpu_online &&
 712                     (!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
 713                      !irqd_irq_disabled(&desc->irq_data)))
 714                         chip->irq_cpu_online(&desc->irq_data);
 715
 716                 raw_spin_unlock_irqrestore(&desc->lock, flags);
 717         }
 718 }
 719
 720 /**
 721  *      irq_cpu_offline - Invoke all irq_cpu_offline functions.
 722  *
 723  *      Iterate through all irqs and invoke the chip.irq_cpu_offline()
 724  *      for each.
 725  */
 726 void irq_cpu_offline(void)
 727 {
 728         struct irq_desc *desc;
 729         struct irq_chip *chip;
 730         unsigned long flags;
 731         unsigned int irq;
 732
 733         for_each_active_irq(irq) {
 734                 desc = irq_to_desc(irq);
 735                 if (!desc)
 736                         continue;
 737
 738                 raw_spin_lock_irqsave(&desc->lock, flags);
 739
 740                 chip = irq_data_get_irq_chip(&desc->irq_data);
 741                 if (chip && chip->irq_cpu_offline &&
 742                     (!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) ||
 743                      !irqd_irq_disabled(&desc->irq_data)))
 744                         chip->irq_cpu_offline(&desc->irq_data);
 745
 746                 raw_spin_unlock_irqrestore(&desc->lock, flags);
 747         }
 748 }