chip.c 19 KB

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