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);
  30
  31         if (!desc)
  32                 return -EINVAL;
  33
  34         if (!chip)
  35                 chip = &no_irq_chip;
  36
  37         irq_chip_set_defaults(chip);
  38         desc->irq_data.chip = chip;
  39         irq_put_desc_unlock(desc, flags);
  40         return 0;
  41 }
  42 EXPORT_SYMBOL(irq_set_chip);
  43
  44 /**
  45  *      irq_set_type - set the irq trigger type for an irq
  46  *      @irq:   irq number
  47  *      @type:  IRQ_TYPE_{LEVEL,EDGE}_* value - see include/linux/irq.h
  48  */
  49 int irq_set_irq_type(unsigned int irq, unsigned int type)
  50 {
  51         unsigned long flags;
  52         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags);
  53         int ret = 0;
  54
  55         if (!desc)
  56                 return -EINVAL;
  57
  58         type &= IRQ_TYPE_SENSE_MASK;
  59         if (type != IRQ_TYPE_NONE)
  60                 ret = __irq_set_trigger(desc, irq, type);
  61         irq_put_desc_busunlock(desc, flags);
  62         return ret;
  63 }
  64 EXPORT_SYMBOL(irq_set_irq_type);
  65
  66 /**
  67  *      irq_set_handler_data - set irq handler data for an irq
  68  *      @irq:   Interrupt number
  69  *      @data:  Pointer to interrupt specific data
  70  *
  71  *      Set the hardware irq controller data for an irq
  72  */
  73 int irq_set_handler_data(unsigned int irq, void *data)
  74 {
  75         unsigned long flags;
  76         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
  77
  78         if (!desc)
  79                 return -EINVAL;
  80         desc->irq_data.handler_data = data;
  81         irq_put_desc_unlock(desc, flags);
  82         return 0;
  83 }
  84 EXPORT_SYMBOL(irq_set_handler_data);
  85
  86 /**
  87  *      irq_set_msi_desc - set MSI descriptor data for an irq
  88  *      @irq:   Interrupt number
  89  *      @entry: Pointer to MSI descriptor data
  90  *
  91  *      Set the MSI descriptor entry for an irq
  92  */
  93 int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry)
  94 {
  95         unsigned long flags;
  96         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
  97
  98         if (!desc)
  99                 return -EINVAL;
 100         desc->irq_data.msi_desc = entry;
 101         if (entry)
 102                 entry->irq = irq;
 103         irq_put_desc_unlock(desc, flags);
 104         return 0;
 105 }
 106
 107 /**
 108  *      irq_set_chip_data - set irq chip data for an irq
 109  *      @irq:   Interrupt number
 110  *      @data:  Pointer to chip specific data
 111  *
 112  *      Set the hardware irq chip data for an irq
 113  */
 114 int irq_set_chip_data(unsigned int irq, void *data)
 115 {
 116         unsigned long flags;
 117         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
 118
 119         if (!desc)
 120                 return -EINVAL;
 121         desc->irq_data.chip_data = data;
 122         irq_put_desc_unlock(desc, flags);
 123         return 0;
 124 }
 125 EXPORT_SYMBOL(irq_set_chip_data);
 126
 127 struct irq_data *irq_get_irq_data(unsigned int irq)
 128 {
 129         struct irq_desc *desc = irq_to_desc(irq);
 130
 131         return desc ? &desc->irq_data : NULL;
 132 }
 133 EXPORT_SYMBOL_GPL(irq_get_irq_data);
 134
 135 static void irq_state_clr_disabled(struct irq_desc *desc)
 136 {
 137         desc->istate &= ~IRQS_DISABLED;
 138         irq_compat_clr_disabled(desc);
 139 }
 140
 141 static void irq_state_set_disabled(struct irq_desc *desc)
 142 {
 143         desc->istate |= IRQS_DISABLED;
 144         irq_compat_set_disabled(desc);
 145 }
 146
 147 static void irq_state_clr_masked(struct irq_desc *desc)
 148 {
 149         desc->istate &= ~IRQS_MASKED;
 150         irq_compat_clr_masked(desc);
 151 }
 152
 153 static void irq_state_set_masked(struct irq_desc *desc)
 154 {
 155         desc->istate |= IRQS_MASKED;
 156         irq_compat_set_masked(desc);
 157 }
 158
 159 int irq_startup(struct irq_desc *desc)
 160 {
 161         irq_state_clr_disabled(desc);
 162         desc->depth = 0;
 163
 164         if (desc->irq_data.chip->irq_startup) {
 165                 int ret = desc->irq_data.chip->irq_startup(&desc->irq_data);
 166                 irq_state_clr_masked(desc);
 167                 return ret;
 168         }
 169
 170         irq_enable(desc);
 171         return 0;
 172 }
 173
 174 void irq_shutdown(struct irq_desc *desc)
 175 {
 176         irq_state_set_disabled(desc);
 177         desc->depth = 1;
 178         if (desc->irq_data.chip->irq_shutdown)
 179                 desc->irq_data.chip->irq_shutdown(&desc->irq_data);
 180         if (desc->irq_data.chip->irq_disable)
 181                 desc->irq_data.chip->irq_disable(&desc->irq_data);
 182         else
 183                 desc->irq_data.chip->irq_mask(&desc->irq_data);
 184         irq_state_set_masked(desc);
 185 }
 186
 187 void irq_enable(struct irq_desc *desc)
 188 {
 189         irq_state_clr_disabled(desc);
 190         if (desc->irq_data.chip->irq_enable)
 191                 desc->irq_data.chip->irq_enable(&desc->irq_data);
 192         else
 193                 desc->irq_data.chip->irq_unmask(&desc->irq_data);
 194         irq_state_clr_masked(desc);
 195 }
 196
 197 void irq_disable(struct irq_desc *desc)
 198 {
 199         irq_state_set_disabled(desc);
 200         if (desc->irq_data.chip->irq_disable) {
 201                 desc->irq_data.chip->irq_disable(&desc->irq_data);
 202                 irq_state_set_masked(desc);
 203         }
 204 }
 205
 206 #ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
 207 /* Temporary migration helpers */
 208 static void compat_irq_mask(struct irq_data *data)
 209 {
 210         data->chip->mask(data->irq);
 211 }
 212
 213 static void compat_irq_unmask(struct irq_data *data)
 214 {
 215         data->chip->unmask(data->irq);
 216 }
 217
 218 static void compat_irq_ack(struct irq_data *data)
 219 {
 220         data->chip->ack(data->irq);
 221 }
 222
 223 static void compat_irq_mask_ack(struct irq_data *data)
 224 {
 225         data->chip->mask_ack(data->irq);
 226 }
 227
 228 static void compat_irq_eoi(struct irq_data *data)
 229 {
 230         data->chip->eoi(data->irq);
 231 }
 232
 233 static void compat_irq_enable(struct irq_data *data)
 234 {
 235         data->chip->enable(data->irq);
 236 }
 237
 238 static void compat_irq_disable(struct irq_data *data)
 239 {
 240         data->chip->disable(data->irq);
 241 }
 242
 243 static void compat_irq_shutdown(struct irq_data *data)
 244 {
 245         data->chip->shutdown(data->irq);
 246 }
 247
 248 static unsigned int compat_irq_startup(struct irq_data *data)
 249 {
 250         return data->chip->startup(data->irq);
 251 }
 252
 253 static int compat_irq_set_affinity(struct irq_data *data,
 254                                    const struct cpumask *dest, bool force)
 255 {
 256         return data->chip->set_affinity(data->irq, dest);
 257 }
 258
 259 static int compat_irq_set_type(struct irq_data *data, unsigned int type)
 260 {
 261         return data->chip->set_type(data->irq, type);
 262 }
 263
 264 static int compat_irq_set_wake(struct irq_data *data, unsigned int on)
 265 {
 266         return data->chip->set_wake(data->irq, on);
 267 }
 268
 269 static int compat_irq_retrigger(struct irq_data *data)
 270 {
 271         return data->chip->retrigger(data->irq);
 272 }
 273
 274 static void compat_bus_lock(struct irq_data *data)
 275 {
 276         data->chip->bus_lock(data->irq);
 277 }
 278
 279 static void compat_bus_sync_unlock(struct irq_data *data)
 280 {
 281         data->chip->bus_sync_unlock(data->irq);
 282 }
 283 #endif
 284
 285 /*
 286  * Fixup enable/disable function pointers
 287  */
 288 void irq_chip_set_defaults(struct irq_chip *chip)
 289 {
 290 #ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
 291         if (chip->enable)
 292                 chip->irq_enable = compat_irq_enable;
 293         if (chip->disable)
 294                 chip->irq_disable = compat_irq_disable;
 295         if (chip->shutdown)
 296                 chip->irq_shutdown = compat_irq_shutdown;
 297         if (chip->startup)
 298                 chip->irq_startup = compat_irq_startup;
 299         if (!chip->end)
 300                 chip->end = dummy_irq_chip.end;
 301         if (chip->bus_lock)
 302                 chip->irq_bus_lock = compat_bus_lock;
 303         if (chip->bus_sync_unlock)
 304                 chip->irq_bus_sync_unlock = compat_bus_sync_unlock;
 305         if (chip->mask)
 306                 chip->irq_mask = compat_irq_mask;
 307         if (chip->unmask)
 308                 chip->irq_unmask = compat_irq_unmask;
 309         if (chip->ack)
 310                 chip->irq_ack = compat_irq_ack;
 311         if (chip->mask_ack)
 312                 chip->irq_mask_ack = compat_irq_mask_ack;
 313         if (chip->eoi)
 314                 chip->irq_eoi = compat_irq_eoi;
 315         if (chip->set_affinity)
 316                 chip->irq_set_affinity = compat_irq_set_affinity;
 317         if (chip->set_type)
 318                 chip->irq_set_type = compat_irq_set_type;
 319         if (chip->set_wake)
 320                 chip->irq_set_wake = compat_irq_set_wake;
 321         if (chip->retrigger)
 322                 chip->irq_retrigger = compat_irq_retrigger;
 323 #endif
 324 }
 325
 326 static inline void mask_ack_irq(struct irq_desc *desc)
 327 {
 328         if (desc->irq_data.chip->irq_mask_ack)
 329                 desc->irq_data.chip->irq_mask_ack(&desc->irq_data);
 330         else {
 331                 desc->irq_data.chip->irq_mask(&desc->irq_data);
 332                 if (desc->irq_data.chip->irq_ack)
 333                         desc->irq_data.chip->irq_ack(&desc->irq_data);
 334         }
 335         irq_state_set_masked(desc);
 336 }
 337
 338 void mask_irq(struct irq_desc *desc)
 339 {
 340         if (desc->irq_data.chip->irq_mask) {
 341                 desc->irq_data.chip->irq_mask(&desc->irq_data);
 342                 irq_state_set_masked(desc);
 343         }
 344 }
 345
 346 void unmask_irq(struct irq_desc *desc)
 347 {
 348         if (desc->irq_data.chip->irq_unmask) {
 349                 desc->irq_data.chip->irq_unmask(&desc->irq_data);
 350                 irq_state_clr_masked(desc);
 351         }
 352 }
 353
 354 /*
 355  *      handle_nested_irq - Handle a nested irq from a irq thread
 356  *      @irq:   the interrupt number
 357  *
 358  *      Handle interrupts which are nested into a threaded interrupt
 359  *      handler. The handler function is called inside the calling
 360  *      threads context.
 361  */
 362 void handle_nested_irq(unsigned int irq)
 363 {
 364         struct irq_desc *desc = irq_to_desc(irq);
 365         struct irqaction *action;
 366         irqreturn_t action_ret;
 367
 368         might_sleep();
 369
 370         raw_spin_lock_irq(&desc->lock);
 371
 372         kstat_incr_irqs_this_cpu(irq, desc);
 373
 374         action = desc->action;
 375         if (unlikely(!action || (desc->istate & IRQS_DISABLED)))
 376                 goto out_unlock;
 377
 378         irq_compat_set_progress(desc);
 379         desc->istate |= IRQS_INPROGRESS;
 380         raw_spin_unlock_irq(&desc->lock);
 381
 382         action_ret = action->thread_fn(action->irq, action->dev_id);
 383         if (!noirqdebug)
 384                 note_interrupt(irq, desc, action_ret);
 385
 386         raw_spin_lock_irq(&desc->lock);
 387         desc->istate &= ~IRQS_INPROGRESS;
 388         irq_compat_clr_progress(desc);
 389
 390 out_unlock:
 391         raw_spin_unlock_irq(&desc->lock);
 392 }
 393 EXPORT_SYMBOL_GPL(handle_nested_irq);
 394
 395 static bool irq_check_poll(struct irq_desc *desc)
 396 {
 397         if (!(desc->istate & IRQS_POLL_INPROGRESS))
 398                 return false;
 399         return irq_wait_for_poll(desc);
 400 }
 401
 402 /**
 403  *      handle_simple_irq - Simple and software-decoded IRQs.
 404  *      @irq:   the interrupt number
 405  *      @desc:  the interrupt description structure for this irq
 406  *
 407  *      Simple interrupts are either sent from a demultiplexing interrupt
 408  *      handler or come from hardware, where no interrupt hardware control
 409  *      is necessary.
 410  *
 411  *      Note: The caller is expected to handle the ack, clear, mask and
 412  *      unmask issues if necessary.
 413  */
 414 void
 415 handle_simple_irq(unsigned int irq, struct irq_desc *desc)
 416 {
 417         raw_spin_lock(&desc->lock);
 418
 419         if (unlikely(desc->istate & IRQS_INPROGRESS))
 420                 if (!irq_check_poll(desc))
 421                         goto out_unlock;
 422
 423         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 424         kstat_incr_irqs_this_cpu(irq, desc);
 425
 426         if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED)))
 427                 goto out_unlock;
 428
 429         handle_irq_event(desc);
 430
 431 out_unlock:
 432         raw_spin_unlock(&desc->lock);
 433 }
 434
 435 /**
 436  *      handle_level_irq - Level type irq handler
 437  *      @irq:   the interrupt number
 438  *      @desc:  the interrupt description structure for this irq
 439  *
 440  *      Level type interrupts are active as long as the hardware line has
 441  *      the active level. This may require to mask the interrupt and unmask
 442  *      it after the associated handler has acknowledged the device, so the
 443  *      interrupt line is back to inactive.
 444  */
 445 void
 446 handle_level_irq(unsigned int irq, struct irq_desc *desc)
 447 {
 448         raw_spin_lock(&desc->lock);
 449         mask_ack_irq(desc);
 450
 451         if (unlikely(desc->istate & IRQS_INPROGRESS))
 452                 if (!irq_check_poll(desc))
 453                         goto out_unlock;
 454
 455         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 456         kstat_incr_irqs_this_cpu(irq, desc);
 457
 458         /*
 459          * If its disabled or no action available
 460          * keep it masked and get out of here
 461          */
 462         if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED)))
 463                 goto out_unlock;
 464
 465         handle_irq_event(desc);
 466
 467         if (!(desc->istate & (IRQS_DISABLED | IRQS_ONESHOT)))
 468                 unmask_irq(desc);
 469 out_unlock:
 470         raw_spin_unlock(&desc->lock);
 471 }
 472 EXPORT_SYMBOL_GPL(handle_level_irq);
 473
 474 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI
 475 static inline void preflow_handler(struct irq_desc *desc)
 476 {
 477         if (desc->preflow_handler)
 478                 desc->preflow_handler(&desc->irq_data);
 479 }
 480 #else
 481 static inline void preflow_handler(struct irq_desc *desc) { }
 482 #endif
 483
 484 /**
 485  *      handle_fasteoi_irq - irq handler for transparent controllers
 486  *      @irq:   the interrupt number
 487  *      @desc:  the interrupt description structure for this irq
 488  *
 489  *      Only a single callback will be issued to the chip: an ->eoi()
 490  *      call when the interrupt has been serviced. This enables support
 491  *      for modern forms of interrupt handlers, which handle the flow
 492  *      details in hardware, transparently.
 493  */
 494 void
 495 handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
 496 {
 497         raw_spin_lock(&desc->lock);
 498
 499         if (unlikely(desc->istate & IRQS_INPROGRESS))
 500                 if (!irq_check_poll(desc))
 501                         goto out;
 502
 503         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 504         kstat_incr_irqs_this_cpu(irq, desc);
 505
 506         /*
 507          * If its disabled or no action available
 508          * then mask it and get out of here:
 509          */
 510         if (unlikely(!desc->action || (desc->istate & IRQS_DISABLED))) {
 511                 irq_compat_set_pending(desc);
 512                 desc->istate |= IRQS_PENDING;
 513                 mask_irq(desc);
 514                 goto out;
 515         }
 516
 517         if (desc->istate & IRQS_ONESHOT)
 518                 mask_irq(desc);
 519
 520         preflow_handler(desc);
 521         handle_irq_event(desc);
 522
 523 out_eoi:
 524         desc->irq_data.chip->irq_eoi(&desc->irq_data);
 525 out_unlock:
 526         raw_spin_unlock(&desc->lock);
 527         return;
 528 out:
 529         if (!(desc->irq_data.chip->flags & IRQCHIP_EOI_IF_HANDLED))
 530                 goto out_eoi;
 531         goto out_unlock;
 532 }
 533
 534 /**
 535  *      handle_edge_irq - edge type IRQ handler
 536  *      @irq:   the interrupt number
 537  *      @desc:  the interrupt description structure for this irq
 538  *
 539  *      Interrupt occures on the falling and/or rising edge of a hardware
 540  *      signal. The occurence is latched into the irq controller hardware
 541  *      and must be acked in order to be reenabled. After the ack another
 542  *      interrupt can happen on the same source even before the first one
 543  *      is handled by the associated event handler. If this happens it
 544  *      might be necessary to disable (mask) the interrupt depending on the
 545  *      controller hardware. This requires to reenable the interrupt inside
 546  *      of the loop which handles the interrupts which have arrived while
 547  *      the handler was running. If all pending interrupts are handled, the
 548  *      loop is left.
 549  */
 550 void
 551 handle_edge_irq(unsigned int irq, struct irq_desc *desc)
 552 {
 553         raw_spin_lock(&desc->lock);
 554
 555         desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
 556         /*
 557          * If we're currently running this IRQ, or its disabled,
 558          * we shouldn't process the IRQ. Mark it pending, handle
 559          * the necessary masking and go out
 560          */
 561         if (unlikely((desc->istate & (IRQS_DISABLED | IRQS_INPROGRESS) ||
 562                       !desc->action))) {
 563                 if (!irq_check_poll(desc)) {
 564                         irq_compat_set_pending(desc);
 565                         desc->istate |= IRQS_PENDING;
 566                         mask_ack_irq(desc);
 567                         goto out_unlock;
 568                 }
 569         }
 570         kstat_incr_irqs_this_cpu(irq, desc);
 571
 572         /* Start handling the irq */
 573         desc->irq_data.chip->irq_ack(&desc->irq_data);
 574
 575         do {
 576                 if (unlikely(!desc->action)) {
 577                         mask_irq(desc);
 578                         goto out_unlock;
 579                 }
 580
 581                 /*
 582                  * When another irq arrived while we were handling
 583                  * one, we could have masked the irq.
 584                  * Renable it, if it was not disabled in meantime.
 585                  */
 586                 if (unlikely(desc->istate & IRQS_PENDING)) {
 587                         if (!(desc->istate & IRQS_DISABLED) &&
 588                             (desc->istate & IRQS_MASKED))
 589                                 unmask_irq(desc);
 590                 }
 591
 592                 handle_irq_event(desc);
 593
 594         } while ((desc->istate & IRQS_PENDING) &&
 595                  !(desc->istate & IRQS_DISABLED));
 596
 597 out_unlock:
 598         raw_spin_unlock(&desc->lock);
 599 }
 600
 601 /**
 602  *      handle_percpu_irq - Per CPU local irq handler
 603  *      @irq:   the interrupt number
 604  *      @desc:  the interrupt description structure for this irq
 605  *
 606  *      Per CPU interrupts on SMP machines without locking requirements
 607  */
 608 void
 609 handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
 610 {
 611         struct irq_chip *chip = irq_desc_get_chip(desc);
 612
 613         kstat_incr_irqs_this_cpu(irq, desc);
 614
 615         if (chip->irq_ack)
 616                 chip->irq_ack(&desc->irq_data);
 617
 618         handle_irq_event_percpu(desc, desc->action);
 619
 620         if (chip->irq_eoi)
 621                 chip->irq_eoi(&desc->irq_data);
 622 }
 623
 624 void
 625 __irq_set_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
 626                   const char *name)
 627 {
 628         unsigned long flags;
 629         struct irq_desc *desc = irq_get_desc_buslock(irq, &flags);
 630
 631         if (!desc)
 632                 return;
 633
 634         if (!handle) {
 635                 handle = handle_bad_irq;
 636         } else {
 637                 if (WARN_ON(desc->irq_data.chip == &no_irq_chip))
 638                         goto out;
 639         }
 640
 641         /* Uninstall? */
 642         if (handle == handle_bad_irq) {
 643                 if (desc->irq_data.chip != &no_irq_chip)
 644                         mask_ack_irq(desc);
 645                 irq_compat_set_disabled(desc);
 646                 desc->istate |= IRQS_DISABLED;
 647                 desc->depth = 1;
 648         }
 649         desc->handle_irq = handle;
 650         desc->name = name;
 651
 652         if (handle != handle_bad_irq && is_chained) {
 653                 irq_settings_set_noprobe(desc);
 654                 irq_settings_set_norequest(desc);
 655                 irq_startup(desc);
 656         }
 657 out:
 658         irq_put_desc_busunlock(desc, flags);
 659 }
 660 EXPORT_SYMBOL_GPL(__irq_set_handler);
 661
 662 void
 663 irq_set_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
 664                               irq_flow_handler_t handle, const char *name)
 665 {
 666         irq_set_chip(irq, chip);
 667         __irq_set_handler(irq, handle, 0, name);
 668 }
 669
 670 void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set)
 671 {
 672         unsigned long flags;
 673         struct irq_desc *desc = irq_get_desc_lock(irq, &flags);
 674
 675         if (!desc)
 676                 return;
 677         irq_settings_clr_and_set(desc, clr, set);
 678
 679         irqd_clear(&desc->irq_data, IRQD_NO_BALANCING | IRQD_PER_CPU |
 680                    IRQD_TRIGGER_MASK | IRQD_LEVEL | IRQD_MOVE_PCNTXT);
 681         if (irq_settings_has_no_balance_set(desc))
 682                 irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
 683         if (irq_settings_is_per_cpu(desc))
 684                 irqd_set(&desc->irq_data, IRQD_PER_CPU);
 685         if (irq_settings_can_move_pcntxt(desc))
 686                 irqd_set(&desc->irq_data, IRQD_MOVE_PCNTXT);
 687
 688         irqd_set(&desc->irq_data, irq_settings_get_trigger_mask(desc));
 689
 690         irq_put_desc_unlock(desc, flags);
 691 }