manage.c 42 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658
  1. /*
  2. * linux/kernel/irq/manage.c
  3. *
  4. * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
  5. * Copyright (C) 2005-2006 Thomas Gleixner
  6. *
  7. * This file contains driver APIs to the irq subsystem.
  8. */
  9. #include <linux/irq.h>
  10. #include <linux/kthread.h>
  11. #include <linux/module.h>
  12. #include <linux/random.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/slab.h>
  15. #include <linux/sched.h>
  16. #include "internals.h"
  17. #ifdef CONFIG_IRQ_FORCED_THREADING
  18. __read_mostly bool force_irqthreads;
  19. static int __init setup_forced_irqthreads(char *arg)
  20. {
  21. force_irqthreads = true;
  22. return 0;
  23. }
  24. early_param("threadirqs", setup_forced_irqthreads);
  25. #endif
  26. /**
  27. * synchronize_irq - wait for pending IRQ handlers (on other CPUs)
  28. * @irq: interrupt number to wait for
  29. *
  30. * This function waits for any pending IRQ handlers for this interrupt
  31. * to complete before returning. If you use this function while
  32. * holding a resource the IRQ handler may need you will deadlock.
  33. *
  34. * This function may be called - with care - from IRQ context.
  35. */
  36. void synchronize_irq(unsigned int irq)
  37. {
  38. struct irq_desc *desc = irq_to_desc(irq);
  39. bool inprogress;
  40. if (!desc)
  41. return;
  42. do {
  43. unsigned long flags;
  44. /*
  45. * Wait until we're out of the critical section. This might
  46. * give the wrong answer due to the lack of memory barriers.
  47. */
  48. while (irqd_irq_inprogress(&desc->irq_data))
  49. cpu_relax();
  50. /* Ok, that indicated we're done: double-check carefully. */
  51. raw_spin_lock_irqsave(&desc->lock, flags);
  52. inprogress = irqd_irq_inprogress(&desc->irq_data);
  53. raw_spin_unlock_irqrestore(&desc->lock, flags);
  54. /* Oops, that failed? */
  55. } while (inprogress);
  56. /*
  57. * We made sure that no hardirq handler is running. Now verify
  58. * that no threaded handlers are active.
  59. */
  60. wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active));
  61. }
  62. EXPORT_SYMBOL(synchronize_irq);
  63. #ifdef CONFIG_SMP
  64. cpumask_var_t irq_default_affinity;
  65. /**
  66. * irq_can_set_affinity - Check if the affinity of a given irq can be set
  67. * @irq: Interrupt to check
  68. *
  69. */
  70. int irq_can_set_affinity(unsigned int irq)
  71. {
  72. struct irq_desc *desc = irq_to_desc(irq);
  73. if (!desc || !irqd_can_balance(&desc->irq_data) ||
  74. !desc->irq_data.chip || !desc->irq_data.chip->irq_set_affinity)
  75. return 0;
  76. return 1;
  77. }
  78. /**
  79. * irq_set_thread_affinity - Notify irq threads to adjust affinity
  80. * @desc: irq descriptor which has affitnity changed
  81. *
  82. * We just set IRQTF_AFFINITY and delegate the affinity setting
  83. * to the interrupt thread itself. We can not call
  84. * set_cpus_allowed_ptr() here as we hold desc->lock and this
  85. * code can be called from hard interrupt context.
  86. */
  87. void irq_set_thread_affinity(struct irq_desc *desc)
  88. {
  89. struct irqaction *action = desc->action;
  90. while (action) {
  91. if (action->thread)
  92. set_bit(IRQTF_AFFINITY, &action->thread_flags);
  93. action = action->next;
  94. }
  95. }
  96. #ifdef CONFIG_GENERIC_PENDING_IRQ
  97. static inline bool irq_can_move_pcntxt(struct irq_data *data)
  98. {
  99. return irqd_can_move_in_process_context(data);
  100. }
  101. static inline bool irq_move_pending(struct irq_data *data)
  102. {
  103. return irqd_is_setaffinity_pending(data);
  104. }
  105. static inline void
  106. irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
  107. {
  108. cpumask_copy(desc->pending_mask, mask);
  109. }
  110. static inline void
  111. irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
  112. {
  113. cpumask_copy(mask, desc->pending_mask);
  114. }
  115. #else
  116. static inline bool irq_can_move_pcntxt(struct irq_data *data) { return true; }
  117. static inline bool irq_move_pending(struct irq_data *data) { return false; }
  118. static inline void
  119. irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) { }
  120. static inline void
  121. irq_get_pending(struct cpumask *mask, struct irq_desc *desc) { }
  122. #endif
  123. int irq_do_set_affinity(struct irq_data *data, const struct cpumask *mask,
  124. bool force)
  125. {
  126. struct irq_desc *desc = irq_data_to_desc(data);
  127. struct irq_chip *chip = irq_data_get_irq_chip(data);
  128. int ret;
  129. ret = chip->irq_set_affinity(data, mask, false);
  130. switch (ret) {
  131. case IRQ_SET_MASK_OK:
  132. cpumask_copy(data->affinity, mask);
  133. case IRQ_SET_MASK_OK_NOCOPY:
  134. irq_set_thread_affinity(desc);
  135. ret = 0;
  136. }
  137. return ret;
  138. }
  139. int __irq_set_affinity_locked(struct irq_data *data, const struct cpumask *mask)
  140. {
  141. struct irq_chip *chip = irq_data_get_irq_chip(data);
  142. struct irq_desc *desc = irq_data_to_desc(data);
  143. int ret = 0;
  144. if (!chip || !chip->irq_set_affinity)
  145. return -EINVAL;
  146. if (irq_can_move_pcntxt(data)) {
  147. ret = irq_do_set_affinity(data, mask, false);
  148. } else {
  149. irqd_set_move_pending(data);
  150. irq_copy_pending(desc, mask);
  151. }
  152. if (desc->affinity_notify) {
  153. kref_get(&desc->affinity_notify->kref);
  154. schedule_work(&desc->affinity_notify->work);
  155. }
  156. irqd_set(data, IRQD_AFFINITY_SET);
  157. return ret;
  158. }
  159. /**
  160. * irq_set_affinity - Set the irq affinity of a given irq
  161. * @irq: Interrupt to set affinity
  162. * @mask: cpumask
  163. *
  164. */
  165. int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
  166. {
  167. struct irq_desc *desc = irq_to_desc(irq);
  168. unsigned long flags;
  169. int ret;
  170. if (!desc)
  171. return -EINVAL;
  172. raw_spin_lock_irqsave(&desc->lock, flags);
  173. ret = __irq_set_affinity_locked(irq_desc_get_irq_data(desc), mask);
  174. raw_spin_unlock_irqrestore(&desc->lock, flags);
  175. return ret;
  176. }
  177. int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m)
  178. {
  179. unsigned long flags;
  180. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
  181. if (!desc)
  182. return -EINVAL;
  183. desc->affinity_hint = m;
  184. irq_put_desc_unlock(desc, flags);
  185. return 0;
  186. }
  187. EXPORT_SYMBOL_GPL(irq_set_affinity_hint);
  188. static void irq_affinity_notify(struct work_struct *work)
  189. {
  190. struct irq_affinity_notify *notify =
  191. container_of(work, struct irq_affinity_notify, work);
  192. struct irq_desc *desc = irq_to_desc(notify->irq);
  193. cpumask_var_t cpumask;
  194. unsigned long flags;
  195. if (!desc || !alloc_cpumask_var(&cpumask, GFP_KERNEL))
  196. goto out;
  197. raw_spin_lock_irqsave(&desc->lock, flags);
  198. if (irq_move_pending(&desc->irq_data))
  199. irq_get_pending(cpumask, desc);
  200. else
  201. cpumask_copy(cpumask, desc->irq_data.affinity);
  202. raw_spin_unlock_irqrestore(&desc->lock, flags);
  203. notify->notify(notify, cpumask);
  204. free_cpumask_var(cpumask);
  205. out:
  206. kref_put(&notify->kref, notify->release);
  207. }
  208. /**
  209. * irq_set_affinity_notifier - control notification of IRQ affinity changes
  210. * @irq: Interrupt for which to enable/disable notification
  211. * @notify: Context for notification, or %NULL to disable
  212. * notification. Function pointers must be initialised;
  213. * the other fields will be initialised by this function.
  214. *
  215. * Must be called in process context. Notification may only be enabled
  216. * after the IRQ is allocated and must be disabled before the IRQ is
  217. * freed using free_irq().
  218. */
  219. int
  220. irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify)
  221. {
  222. struct irq_desc *desc = irq_to_desc(irq);
  223. struct irq_affinity_notify *old_notify;
  224. unsigned long flags;
  225. /* The release function is promised process context */
  226. might_sleep();
  227. if (!desc)
  228. return -EINVAL;
  229. /* Complete initialisation of *notify */
  230. if (notify) {
  231. notify->irq = irq;
  232. kref_init(&notify->kref);
  233. INIT_WORK(&notify->work, irq_affinity_notify);
  234. }
  235. raw_spin_lock_irqsave(&desc->lock, flags);
  236. old_notify = desc->affinity_notify;
  237. desc->affinity_notify = notify;
  238. raw_spin_unlock_irqrestore(&desc->lock, flags);
  239. if (old_notify)
  240. kref_put(&old_notify->kref, old_notify->release);
  241. return 0;
  242. }
  243. EXPORT_SYMBOL_GPL(irq_set_affinity_notifier);
  244. #ifndef CONFIG_AUTO_IRQ_AFFINITY
  245. /*
  246. * Generic version of the affinity autoselector.
  247. */
  248. static int
  249. setup_affinity(unsigned int irq, struct irq_desc *desc, struct cpumask *mask)
  250. {
  251. struct cpumask *set = irq_default_affinity;
  252. int node = desc->irq_data.node;
  253. /* Excludes PER_CPU and NO_BALANCE interrupts */
  254. if (!irq_can_set_affinity(irq))
  255. return 0;
  256. /*
  257. * Preserve an userspace affinity setup, but make sure that
  258. * one of the targets is online.
  259. */
  260. if (irqd_has_set(&desc->irq_data, IRQD_AFFINITY_SET)) {
  261. if (cpumask_intersects(desc->irq_data.affinity,
  262. cpu_online_mask))
  263. set = desc->irq_data.affinity;
  264. else
  265. irqd_clear(&desc->irq_data, IRQD_AFFINITY_SET);
  266. }
  267. cpumask_and(mask, cpu_online_mask, set);
  268. if (node != NUMA_NO_NODE) {
  269. const struct cpumask *nodemask = cpumask_of_node(node);
  270. /* make sure at least one of the cpus in nodemask is online */
  271. if (cpumask_intersects(mask, nodemask))
  272. cpumask_and(mask, mask, nodemask);
  273. }
  274. irq_do_set_affinity(&desc->irq_data, mask, false);
  275. return 0;
  276. }
  277. #else
  278. static inline int
  279. setup_affinity(unsigned int irq, struct irq_desc *d, struct cpumask *mask)
  280. {
  281. return irq_select_affinity(irq);
  282. }
  283. #endif
  284. /*
  285. * Called when affinity is set via /proc/irq
  286. */
  287. int irq_select_affinity_usr(unsigned int irq, struct cpumask *mask)
  288. {
  289. struct irq_desc *desc = irq_to_desc(irq);
  290. unsigned long flags;
  291. int ret;
  292. raw_spin_lock_irqsave(&desc->lock, flags);
  293. ret = setup_affinity(irq, desc, mask);
  294. raw_spin_unlock_irqrestore(&desc->lock, flags);
  295. return ret;
  296. }
  297. #else
  298. static inline int
  299. setup_affinity(unsigned int irq, struct irq_desc *desc, struct cpumask *mask)
  300. {
  301. return 0;
  302. }
  303. #endif
  304. void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)
  305. {
  306. if (suspend) {
  307. if (!desc->action || (desc->action->flags & IRQF_NO_SUSPEND))
  308. return;
  309. desc->istate |= IRQS_SUSPENDED;
  310. }
  311. if (!desc->depth++)
  312. irq_disable(desc);
  313. }
  314. static int __disable_irq_nosync(unsigned int irq)
  315. {
  316. unsigned long flags;
  317. struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
  318. if (!desc)
  319. return -EINVAL;
  320. __disable_irq(desc, irq, false);
  321. irq_put_desc_busunlock(desc, flags);
  322. return 0;
  323. }
  324. /**
  325. * disable_irq_nosync - disable an irq without waiting
  326. * @irq: Interrupt to disable
  327. *
  328. * Disable the selected interrupt line. Disables and Enables are
  329. * nested.
  330. * Unlike disable_irq(), this function does not ensure existing
  331. * instances of the IRQ handler have completed before returning.
  332. *
  333. * This function may be called from IRQ context.
  334. */
  335. void disable_irq_nosync(unsigned int irq)
  336. {
  337. __disable_irq_nosync(irq);
  338. }
  339. EXPORT_SYMBOL(disable_irq_nosync);
  340. /**
  341. * disable_irq - disable an irq and wait for completion
  342. * @irq: Interrupt to disable
  343. *
  344. * Disable the selected interrupt line. Enables and Disables are
  345. * nested.
  346. * This function waits for any pending IRQ handlers for this interrupt
  347. * to complete before returning. If you use this function while
  348. * holding a resource the IRQ handler may need you will deadlock.
  349. *
  350. * This function may be called - with care - from IRQ context.
  351. */
  352. void disable_irq(unsigned int irq)
  353. {
  354. if (!__disable_irq_nosync(irq))
  355. synchronize_irq(irq);
  356. }
  357. EXPORT_SYMBOL(disable_irq);
  358. void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
  359. {
  360. if (resume) {
  361. if (!(desc->istate & IRQS_SUSPENDED)) {
  362. if (!desc->action)
  363. return;
  364. if (!(desc->action->flags & IRQF_FORCE_RESUME))
  365. return;
  366. /* Pretend that it got disabled ! */
  367. desc->depth++;
  368. }
  369. desc->istate &= ~IRQS_SUSPENDED;
  370. }
  371. switch (desc->depth) {
  372. case 0:
  373. err_out:
  374. WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
  375. break;
  376. case 1: {
  377. if (desc->istate & IRQS_SUSPENDED)
  378. goto err_out;
  379. /* Prevent probing on this irq: */
  380. irq_settings_set_noprobe(desc);
  381. irq_enable(desc);
  382. check_irq_resend(desc, irq);
  383. /* fall-through */
  384. }
  385. default:
  386. desc->depth--;
  387. }
  388. }
  389. /**
  390. * enable_irq - enable handling of an irq
  391. * @irq: Interrupt to enable
  392. *
  393. * Undoes the effect of one call to disable_irq(). If this
  394. * matches the last disable, processing of interrupts on this
  395. * IRQ line is re-enabled.
  396. *
  397. * This function may be called from IRQ context only when
  398. * desc->irq_data.chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
  399. */
  400. void enable_irq(unsigned int irq)
  401. {
  402. unsigned long flags;
  403. struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
  404. if (!desc)
  405. return;
  406. if (WARN(!desc->irq_data.chip,
  407. KERN_ERR "enable_irq before setup/request_irq: irq %u\n", irq))
  408. goto out;
  409. __enable_irq(desc, irq, false);
  410. out:
  411. irq_put_desc_busunlock(desc, flags);
  412. }
  413. EXPORT_SYMBOL(enable_irq);
  414. static int set_irq_wake_real(unsigned int irq, unsigned int on)
  415. {
  416. struct irq_desc *desc = irq_to_desc(irq);
  417. int ret = -ENXIO;
  418. if (irq_desc_get_chip(desc)->flags & IRQCHIP_SKIP_SET_WAKE)
  419. return 0;
  420. if (desc->irq_data.chip->irq_set_wake)
  421. ret = desc->irq_data.chip->irq_set_wake(&desc->irq_data, on);
  422. return ret;
  423. }
  424. /**
  425. * irq_set_irq_wake - control irq power management wakeup
  426. * @irq: interrupt to control
  427. * @on: enable/disable power management wakeup
  428. *
  429. * Enable/disable power management wakeup mode, which is
  430. * disabled by default. Enables and disables must match,
  431. * just as they match for non-wakeup mode support.
  432. *
  433. * Wakeup mode lets this IRQ wake the system from sleep
  434. * states like "suspend to RAM".
  435. */
  436. int irq_set_irq_wake(unsigned int irq, unsigned int on)
  437. {
  438. unsigned long flags;
  439. struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
  440. int ret = 0;
  441. if (!desc)
  442. return -EINVAL;
  443. /* wakeup-capable irqs can be shared between drivers that
  444. * don't need to have the same sleep mode behaviors.
  445. */
  446. if (on) {
  447. if (desc->wake_depth++ == 0) {
  448. ret = set_irq_wake_real(irq, on);
  449. if (ret)
  450. desc->wake_depth = 0;
  451. else
  452. irqd_set(&desc->irq_data, IRQD_WAKEUP_STATE);
  453. }
  454. } else {
  455. if (desc->wake_depth == 0) {
  456. WARN(1, "Unbalanced IRQ %d wake disable\n", irq);
  457. } else if (--desc->wake_depth == 0) {
  458. ret = set_irq_wake_real(irq, on);
  459. if (ret)
  460. desc->wake_depth = 1;
  461. else
  462. irqd_clear(&desc->irq_data, IRQD_WAKEUP_STATE);
  463. }
  464. }
  465. irq_put_desc_busunlock(desc, flags);
  466. return ret;
  467. }
  468. EXPORT_SYMBOL(irq_set_irq_wake);
  469. /*
  470. * Internal function that tells the architecture code whether a
  471. * particular irq has been exclusively allocated or is available
  472. * for driver use.
  473. */
  474. int can_request_irq(unsigned int irq, unsigned long irqflags)
  475. {
  476. unsigned long flags;
  477. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
  478. int canrequest = 0;
  479. if (!desc)
  480. return 0;
  481. if (irq_settings_can_request(desc)) {
  482. if (desc->action)
  483. if (irqflags & desc->action->flags & IRQF_SHARED)
  484. canrequest =1;
  485. }
  486. irq_put_desc_unlock(desc, flags);
  487. return canrequest;
  488. }
  489. int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
  490. unsigned long flags)
  491. {
  492. struct irq_chip *chip = desc->irq_data.chip;
  493. int ret, unmask = 0;
  494. if (!chip || !chip->irq_set_type) {
  495. /*
  496. * IRQF_TRIGGER_* but the PIC does not support multiple
  497. * flow-types?
  498. */
  499. pr_debug("genirq: No set_type function for IRQ %d (%s)\n", irq,
  500. chip ? (chip->name ? : "unknown") : "unknown");
  501. return 0;
  502. }
  503. flags &= IRQ_TYPE_SENSE_MASK;
  504. if (chip->flags & IRQCHIP_SET_TYPE_MASKED) {
  505. if (!irqd_irq_masked(&desc->irq_data))
  506. mask_irq(desc);
  507. if (!irqd_irq_disabled(&desc->irq_data))
  508. unmask = 1;
  509. }
  510. /* caller masked out all except trigger mode flags */
  511. ret = chip->irq_set_type(&desc->irq_data, flags);
  512. switch (ret) {
  513. case IRQ_SET_MASK_OK:
  514. irqd_clear(&desc->irq_data, IRQD_TRIGGER_MASK);
  515. irqd_set(&desc->irq_data, flags);
  516. case IRQ_SET_MASK_OK_NOCOPY:
  517. flags = irqd_get_trigger_type(&desc->irq_data);
  518. irq_settings_set_trigger_mask(desc, flags);
  519. irqd_clear(&desc->irq_data, IRQD_LEVEL);
  520. irq_settings_clr_level(desc);
  521. if (flags & IRQ_TYPE_LEVEL_MASK) {
  522. irq_settings_set_level(desc);
  523. irqd_set(&desc->irq_data, IRQD_LEVEL);
  524. }
  525. ret = 0;
  526. break;
  527. default:
  528. pr_err("genirq: Setting trigger mode %lu for irq %u failed (%pF)\n",
  529. flags, irq, chip->irq_set_type);
  530. }
  531. if (unmask)
  532. unmask_irq(desc);
  533. return ret;
  534. }
  535. /*
  536. * Default primary interrupt handler for threaded interrupts. Is
  537. * assigned as primary handler when request_threaded_irq is called
  538. * with handler == NULL. Useful for oneshot interrupts.
  539. */
  540. static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
  541. {
  542. return IRQ_WAKE_THREAD;
  543. }
  544. /*
  545. * Primary handler for nested threaded interrupts. Should never be
  546. * called.
  547. */
  548. static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
  549. {
  550. WARN(1, "Primary handler called for nested irq %d\n", irq);
  551. return IRQ_NONE;
  552. }
  553. static int irq_wait_for_interrupt(struct irqaction *action)
  554. {
  555. set_current_state(TASK_INTERRUPTIBLE);
  556. while (!kthread_should_stop()) {
  557. if (test_and_clear_bit(IRQTF_RUNTHREAD,
  558. &action->thread_flags)) {
  559. __set_current_state(TASK_RUNNING);
  560. return 0;
  561. }
  562. schedule();
  563. set_current_state(TASK_INTERRUPTIBLE);
  564. }
  565. __set_current_state(TASK_RUNNING);
  566. return -1;
  567. }
  568. /*
  569. * Oneshot interrupts keep the irq line masked until the threaded
  570. * handler finished. unmask if the interrupt has not been disabled and
  571. * is marked MASKED.
  572. */
  573. static void irq_finalize_oneshot(struct irq_desc *desc,
  574. struct irqaction *action)
  575. {
  576. if (!(desc->istate & IRQS_ONESHOT))
  577. return;
  578. again:
  579. chip_bus_lock(desc);
  580. raw_spin_lock_irq(&desc->lock);
  581. /*
  582. * Implausible though it may be we need to protect us against
  583. * the following scenario:
  584. *
  585. * The thread is faster done than the hard interrupt handler
  586. * on the other CPU. If we unmask the irq line then the
  587. * interrupt can come in again and masks the line, leaves due
  588. * to IRQS_INPROGRESS and the irq line is masked forever.
  589. *
  590. * This also serializes the state of shared oneshot handlers
  591. * versus "desc->threads_onehsot |= action->thread_mask;" in
  592. * irq_wake_thread(). See the comment there which explains the
  593. * serialization.
  594. */
  595. if (unlikely(irqd_irq_inprogress(&desc->irq_data))) {
  596. raw_spin_unlock_irq(&desc->lock);
  597. chip_bus_sync_unlock(desc);
  598. cpu_relax();
  599. goto again;
  600. }
  601. /*
  602. * Now check again, whether the thread should run. Otherwise
  603. * we would clear the threads_oneshot bit of this thread which
  604. * was just set.
  605. */
  606. if (test_bit(IRQTF_RUNTHREAD, &action->thread_flags))
  607. goto out_unlock;
  608. desc->threads_oneshot &= ~action->thread_mask;
  609. if (!desc->threads_oneshot && !irqd_irq_disabled(&desc->irq_data) &&
  610. irqd_irq_masked(&desc->irq_data))
  611. unmask_irq(desc);
  612. out_unlock:
  613. raw_spin_unlock_irq(&desc->lock);
  614. chip_bus_sync_unlock(desc);
  615. }
  616. #ifdef CONFIG_SMP
  617. /*
  618. * Check whether we need to chasnge the affinity of the interrupt thread.
  619. */
  620. static void
  621. irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
  622. {
  623. cpumask_var_t mask;
  624. if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags))
  625. return;
  626. /*
  627. * In case we are out of memory we set IRQTF_AFFINITY again and
  628. * try again next time
  629. */
  630. if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
  631. set_bit(IRQTF_AFFINITY, &action->thread_flags);
  632. return;
  633. }
  634. raw_spin_lock_irq(&desc->lock);
  635. cpumask_copy(mask, desc->irq_data.affinity);
  636. raw_spin_unlock_irq(&desc->lock);
  637. set_cpus_allowed_ptr(current, mask);
  638. free_cpumask_var(mask);
  639. }
  640. #else
  641. static inline void
  642. irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) { }
  643. #endif
  644. /*
  645. * Interrupts which are not explicitely requested as threaded
  646. * interrupts rely on the implicit bh/preempt disable of the hard irq
  647. * context. So we need to disable bh here to avoid deadlocks and other
  648. * side effects.
  649. */
  650. static irqreturn_t
  651. irq_forced_thread_fn(struct irq_desc *desc, struct irqaction *action)
  652. {
  653. irqreturn_t ret;
  654. local_bh_disable();
  655. ret = action->thread_fn(action->irq, action->dev_id);
  656. irq_finalize_oneshot(desc, action);
  657. local_bh_enable();
  658. return ret;
  659. }
  660. /*
  661. * Interrupts explicitely requested as threaded interupts want to be
  662. * preemtible - many of them need to sleep and wait for slow busses to
  663. * complete.
  664. */
  665. static irqreturn_t irq_thread_fn(struct irq_desc *desc,
  666. struct irqaction *action)
  667. {
  668. irqreturn_t ret;
  669. ret = action->thread_fn(action->irq, action->dev_id);
  670. irq_finalize_oneshot(desc, action);
  671. return ret;
  672. }
  673. static void wake_threads_waitq(struct irq_desc *desc)
  674. {
  675. if (atomic_dec_and_test(&desc->threads_active) &&
  676. waitqueue_active(&desc->wait_for_threads))
  677. wake_up(&desc->wait_for_threads);
  678. }
  679. /*
  680. * Interrupt handler thread
  681. */
  682. static int irq_thread(void *data)
  683. {
  684. static const struct sched_param param = {
  685. .sched_priority = MAX_USER_RT_PRIO/2,
  686. };
  687. struct irqaction *action = data;
  688. struct irq_desc *desc = irq_to_desc(action->irq);
  689. irqreturn_t (*handler_fn)(struct irq_desc *desc,
  690. struct irqaction *action);
  691. if (force_irqthreads && test_bit(IRQTF_FORCED_THREAD,
  692. &action->thread_flags))
  693. handler_fn = irq_forced_thread_fn;
  694. else
  695. handler_fn = irq_thread_fn;
  696. sched_setscheduler(current, SCHED_FIFO, &param);
  697. current->irq_thread = 1;
  698. while (!irq_wait_for_interrupt(action)) {
  699. irqreturn_t action_ret;
  700. irq_thread_check_affinity(desc, action);
  701. action_ret = handler_fn(desc, action);
  702. if (!noirqdebug)
  703. note_interrupt(action->irq, desc, action_ret);
  704. wake_threads_waitq(desc);
  705. }
  706. /*
  707. * This is the regular exit path. __free_irq() is stopping the
  708. * thread via kthread_stop() after calling
  709. * synchronize_irq(). So neither IRQTF_RUNTHREAD nor the
  710. * oneshot mask bit can be set. We cannot verify that as we
  711. * cannot touch the oneshot mask at this point anymore as
  712. * __setup_irq() might have given out currents thread_mask
  713. * again.
  714. *
  715. * Clear irq_thread. Otherwise exit_irq_thread() would make
  716. * fuzz about an active irq thread going into nirvana.
  717. */
  718. current->irq_thread = 0;
  719. return 0;
  720. }
  721. /*
  722. * Called from do_exit()
  723. */
  724. void exit_irq_thread(void)
  725. {
  726. struct task_struct *tsk = current;
  727. struct irq_desc *desc;
  728. struct irqaction *action;
  729. if (!tsk->irq_thread)
  730. return;
  731. action = kthread_data(tsk);
  732. pr_err("genirq: exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n",
  733. tsk->comm ? tsk->comm : "", tsk->pid, action->irq);
  734. desc = irq_to_desc(action->irq);
  735. /*
  736. * If IRQTF_RUNTHREAD is set, we need to decrement
  737. * desc->threads_active and wake possible waiters.
  738. */
  739. if (test_and_clear_bit(IRQTF_RUNTHREAD, &action->thread_flags))
  740. wake_threads_waitq(desc);
  741. /* Prevent a stale desc->threads_oneshot */
  742. irq_finalize_oneshot(desc, action);
  743. }
  744. static void irq_setup_forced_threading(struct irqaction *new)
  745. {
  746. if (!force_irqthreads)
  747. return;
  748. if (new->flags & (IRQF_NO_THREAD | IRQF_PERCPU | IRQF_ONESHOT))
  749. return;
  750. new->flags |= IRQF_ONESHOT;
  751. if (!new->thread_fn) {
  752. set_bit(IRQTF_FORCED_THREAD, &new->thread_flags);
  753. new->thread_fn = new->handler;
  754. new->handler = irq_default_primary_handler;
  755. }
  756. }
  757. /*
  758. * Internal function to register an irqaction - typically used to
  759. * allocate special interrupts that are part of the architecture.
  760. */
  761. static int
  762. __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
  763. {
  764. struct irqaction *old, **old_ptr;
  765. unsigned long flags, thread_mask = 0;
  766. int ret, nested, shared = 0;
  767. cpumask_var_t mask;
  768. if (!desc)
  769. return -EINVAL;
  770. if (desc->irq_data.chip == &no_irq_chip)
  771. return -ENOSYS;
  772. if (!try_module_get(desc->owner))
  773. return -ENODEV;
  774. /*
  775. * Some drivers like serial.c use request_irq() heavily,
  776. * so we have to be careful not to interfere with a
  777. * running system.
  778. */
  779. if (new->flags & IRQF_SAMPLE_RANDOM) {
  780. /*
  781. * This function might sleep, we want to call it first,
  782. * outside of the atomic block.
  783. * Yes, this might clear the entropy pool if the wrong
  784. * driver is attempted to be loaded, without actually
  785. * installing a new handler, but is this really a problem,
  786. * only the sysadmin is able to do this.
  787. */
  788. rand_initialize_irq(irq);
  789. }
  790. /*
  791. * Check whether the interrupt nests into another interrupt
  792. * thread.
  793. */
  794. nested = irq_settings_is_nested_thread(desc);
  795. if (nested) {
  796. if (!new->thread_fn) {
  797. ret = -EINVAL;
  798. goto out_mput;
  799. }
  800. /*
  801. * Replace the primary handler which was provided from
  802. * the driver for non nested interrupt handling by the
  803. * dummy function which warns when called.
  804. */
  805. new->handler = irq_nested_primary_handler;
  806. } else {
  807. if (irq_settings_can_thread(desc))
  808. irq_setup_forced_threading(new);
  809. }
  810. /*
  811. * Create a handler thread when a thread function is supplied
  812. * and the interrupt does not nest into another interrupt
  813. * thread.
  814. */
  815. if (new->thread_fn && !nested) {
  816. struct task_struct *t;
  817. t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
  818. new->name);
  819. if (IS_ERR(t)) {
  820. ret = PTR_ERR(t);
  821. goto out_mput;
  822. }
  823. /*
  824. * We keep the reference to the task struct even if
  825. * the thread dies to avoid that the interrupt code
  826. * references an already freed task_struct.
  827. */
  828. get_task_struct(t);
  829. new->thread = t;
  830. }
  831. if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
  832. ret = -ENOMEM;
  833. goto out_thread;
  834. }
  835. /*
  836. * The following block of code has to be executed atomically
  837. */
  838. raw_spin_lock_irqsave(&desc->lock, flags);
  839. old_ptr = &desc->action;
  840. old = *old_ptr;
  841. if (old) {
  842. /*
  843. * Can't share interrupts unless both agree to and are
  844. * the same type (level, edge, polarity). So both flag
  845. * fields must have IRQF_SHARED set and the bits which
  846. * set the trigger type must match. Also all must
  847. * agree on ONESHOT.
  848. */
  849. if (!((old->flags & new->flags) & IRQF_SHARED) ||
  850. ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK) ||
  851. ((old->flags ^ new->flags) & IRQF_ONESHOT))
  852. goto mismatch;
  853. /* All handlers must agree on per-cpuness */
  854. if ((old->flags & IRQF_PERCPU) !=
  855. (new->flags & IRQF_PERCPU))
  856. goto mismatch;
  857. /* add new interrupt at end of irq queue */
  858. do {
  859. /*
  860. * Or all existing action->thread_mask bits,
  861. * so we can find the next zero bit for this
  862. * new action.
  863. */
  864. thread_mask |= old->thread_mask;
  865. old_ptr = &old->next;
  866. old = *old_ptr;
  867. } while (old);
  868. shared = 1;
  869. }
  870. /*
  871. * Setup the thread mask for this irqaction for ONESHOT. For
  872. * !ONESHOT irqs the thread mask is 0 so we can avoid a
  873. * conditional in irq_wake_thread().
  874. */
  875. if (new->flags & IRQF_ONESHOT) {
  876. /*
  877. * Unlikely to have 32 resp 64 irqs sharing one line,
  878. * but who knows.
  879. */
  880. if (thread_mask == ~0UL) {
  881. ret = -EBUSY;
  882. goto out_mask;
  883. }
  884. /*
  885. * The thread_mask for the action is or'ed to
  886. * desc->thread_active to indicate that the
  887. * IRQF_ONESHOT thread handler has been woken, but not
  888. * yet finished. The bit is cleared when a thread
  889. * completes. When all threads of a shared interrupt
  890. * line have completed desc->threads_active becomes
  891. * zero and the interrupt line is unmasked. See
  892. * handle.c:irq_wake_thread() for further information.
  893. *
  894. * If no thread is woken by primary (hard irq context)
  895. * interrupt handlers, then desc->threads_active is
  896. * also checked for zero to unmask the irq line in the
  897. * affected hard irq flow handlers
  898. * (handle_[fasteoi|level]_irq).
  899. *
  900. * The new action gets the first zero bit of
  901. * thread_mask assigned. See the loop above which or's
  902. * all existing action->thread_mask bits.
  903. */
  904. new->thread_mask = 1 << ffz(thread_mask);
  905. } else if (new->handler == irq_default_primary_handler) {
  906. /*
  907. * The interrupt was requested with handler = NULL, so
  908. * we use the default primary handler for it. But it
  909. * does not have the oneshot flag set. In combination
  910. * with level interrupts this is deadly, because the
  911. * default primary handler just wakes the thread, then
  912. * the irq lines is reenabled, but the device still
  913. * has the level irq asserted. Rinse and repeat....
  914. *
  915. * While this works for edge type interrupts, we play
  916. * it safe and reject unconditionally because we can't
  917. * say for sure which type this interrupt really
  918. * has. The type flags are unreliable as the
  919. * underlying chip implementation can override them.
  920. */
  921. pr_err("genirq: Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n",
  922. irq);
  923. ret = -EINVAL;
  924. goto out_mask;
  925. }
  926. if (!shared) {
  927. init_waitqueue_head(&desc->wait_for_threads);
  928. /* Setup the type (level, edge polarity) if configured: */
  929. if (new->flags & IRQF_TRIGGER_MASK) {
  930. ret = __irq_set_trigger(desc, irq,
  931. new->flags & IRQF_TRIGGER_MASK);
  932. if (ret)
  933. goto out_mask;
  934. }
  935. desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
  936. IRQS_ONESHOT | IRQS_WAITING);
  937. irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
  938. if (new->flags & IRQF_PERCPU) {
  939. irqd_set(&desc->irq_data, IRQD_PER_CPU);
  940. irq_settings_set_per_cpu(desc);
  941. }
  942. if (new->flags & IRQF_ONESHOT)
  943. desc->istate |= IRQS_ONESHOT;
  944. if (irq_settings_can_autoenable(desc))
  945. irq_startup(desc, true);
  946. else
  947. /* Undo nested disables: */
  948. desc->depth = 1;
  949. /* Exclude IRQ from balancing if requested */
  950. if (new->flags & IRQF_NOBALANCING) {
  951. irq_settings_set_no_balancing(desc);
  952. irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
  953. }
  954. /* Set default affinity mask once everything is setup */
  955. setup_affinity(irq, desc, mask);
  956. } else if (new->flags & IRQF_TRIGGER_MASK) {
  957. unsigned int nmsk = new->flags & IRQF_TRIGGER_MASK;
  958. unsigned int omsk = irq_settings_get_trigger_mask(desc);
  959. if (nmsk != omsk)
  960. /* hope the handler works with current trigger mode */
  961. pr_warning("genirq: irq %d uses trigger mode %u; requested %u\n",
  962. irq, nmsk, omsk);
  963. }
  964. new->irq = irq;
  965. *old_ptr = new;
  966. /* Reset broken irq detection when installing new handler */
  967. desc->irq_count = 0;
  968. desc->irqs_unhandled = 0;
  969. /*
  970. * Check whether we disabled the irq via the spurious handler
  971. * before. Reenable it and give it another chance.
  972. */
  973. if (shared && (desc->istate & IRQS_SPURIOUS_DISABLED)) {
  974. desc->istate &= ~IRQS_SPURIOUS_DISABLED;
  975. __enable_irq(desc, irq, false);
  976. }
  977. raw_spin_unlock_irqrestore(&desc->lock, flags);
  978. /*
  979. * Strictly no need to wake it up, but hung_task complains
  980. * when no hard interrupt wakes the thread up.
  981. */
  982. if (new->thread)
  983. wake_up_process(new->thread);
  984. register_irq_proc(irq, desc);
  985. new->dir = NULL;
  986. register_handler_proc(irq, new);
  987. free_cpumask_var(mask);
  988. return 0;
  989. mismatch:
  990. if (!(new->flags & IRQF_PROBE_SHARED)) {
  991. pr_err("genirq: Flags mismatch irq %d. %08x (%s) vs. %08x (%s)\n",
  992. irq, new->flags, new->name, old->flags, old->name);
  993. #ifdef CONFIG_DEBUG_SHIRQ
  994. dump_stack();
  995. #endif
  996. }
  997. ret = -EBUSY;
  998. out_mask:
  999. raw_spin_unlock_irqrestore(&desc->lock, flags);
  1000. free_cpumask_var(mask);
  1001. out_thread:
  1002. if (new->thread) {
  1003. struct task_struct *t = new->thread;
  1004. new->thread = NULL;
  1005. kthread_stop(t);
  1006. put_task_struct(t);
  1007. }
  1008. out_mput:
  1009. module_put(desc->owner);
  1010. return ret;
  1011. }
  1012. /**
  1013. * setup_irq - setup an interrupt
  1014. * @irq: Interrupt line to setup
  1015. * @act: irqaction for the interrupt
  1016. *
  1017. * Used to statically setup interrupts in the early boot process.
  1018. */
  1019. int setup_irq(unsigned int irq, struct irqaction *act)
  1020. {
  1021. int retval;
  1022. struct irq_desc *desc = irq_to_desc(irq);
  1023. if (WARN_ON(irq_settings_is_per_cpu_devid(desc)))
  1024. return -EINVAL;
  1025. chip_bus_lock(desc);
  1026. retval = __setup_irq(irq, desc, act);
  1027. chip_bus_sync_unlock(desc);
  1028. return retval;
  1029. }
  1030. EXPORT_SYMBOL_GPL(setup_irq);
  1031. /*
  1032. * Internal function to unregister an irqaction - used to free
  1033. * regular and special interrupts that are part of the architecture.
  1034. */
  1035. static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
  1036. {
  1037. struct irq_desc *desc = irq_to_desc(irq);
  1038. struct irqaction *action, **action_ptr;
  1039. unsigned long flags;
  1040. WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
  1041. if (!desc)
  1042. return NULL;
  1043. raw_spin_lock_irqsave(&desc->lock, flags);
  1044. /*
  1045. * There can be multiple actions per IRQ descriptor, find the right
  1046. * one based on the dev_id:
  1047. */
  1048. action_ptr = &desc->action;
  1049. for (;;) {
  1050. action = *action_ptr;
  1051. if (!action) {
  1052. WARN(1, "Trying to free already-free IRQ %d\n", irq);
  1053. raw_spin_unlock_irqrestore(&desc->lock, flags);
  1054. return NULL;
  1055. }
  1056. if (action->dev_id == dev_id)
  1057. break;
  1058. action_ptr = &action->next;
  1059. }
  1060. /* Found it - now remove it from the list of entries: */
  1061. *action_ptr = action->next;
  1062. /* If this was the last handler, shut down the IRQ line: */
  1063. if (!desc->action)
  1064. irq_shutdown(desc);
  1065. #ifdef CONFIG_SMP
  1066. /* make sure affinity_hint is cleaned up */
  1067. if (WARN_ON_ONCE(desc->affinity_hint))
  1068. desc->affinity_hint = NULL;
  1069. #endif
  1070. raw_spin_unlock_irqrestore(&desc->lock, flags);
  1071. unregister_handler_proc(irq, action);
  1072. /* Make sure it's not being used on another CPU: */
  1073. synchronize_irq(irq);
  1074. #ifdef CONFIG_DEBUG_SHIRQ
  1075. /*
  1076. * It's a shared IRQ -- the driver ought to be prepared for an IRQ
  1077. * event to happen even now it's being freed, so let's make sure that
  1078. * is so by doing an extra call to the handler ....
  1079. *
  1080. * ( We do this after actually deregistering it, to make sure that a
  1081. * 'real' IRQ doesn't run in * parallel with our fake. )
  1082. */
  1083. if (action->flags & IRQF_SHARED) {
  1084. local_irq_save(flags);
  1085. action->handler(irq, dev_id);
  1086. local_irq_restore(flags);
  1087. }
  1088. #endif
  1089. if (action->thread) {
  1090. kthread_stop(action->thread);
  1091. put_task_struct(action->thread);
  1092. }
  1093. module_put(desc->owner);
  1094. return action;
  1095. }
  1096. /**
  1097. * remove_irq - free an interrupt
  1098. * @irq: Interrupt line to free
  1099. * @act: irqaction for the interrupt
  1100. *
  1101. * Used to remove interrupts statically setup by the early boot process.
  1102. */
  1103. void remove_irq(unsigned int irq, struct irqaction *act)
  1104. {
  1105. struct irq_desc *desc = irq_to_desc(irq);
  1106. if (desc && !WARN_ON(irq_settings_is_per_cpu_devid(desc)))
  1107. __free_irq(irq, act->dev_id);
  1108. }
  1109. EXPORT_SYMBOL_GPL(remove_irq);
  1110. /**
  1111. * free_irq - free an interrupt allocated with request_irq
  1112. * @irq: Interrupt line to free
  1113. * @dev_id: Device identity to free
  1114. *
  1115. * Remove an interrupt handler. The handler is removed and if the
  1116. * interrupt line is no longer in use by any driver it is disabled.
  1117. * On a shared IRQ the caller must ensure the interrupt is disabled
  1118. * on the card it drives before calling this function. The function
  1119. * does not return until any executing interrupts for this IRQ
  1120. * have completed.
  1121. *
  1122. * This function must not be called from interrupt context.
  1123. */
  1124. void free_irq(unsigned int irq, void *dev_id)
  1125. {
  1126. struct irq_desc *desc = irq_to_desc(irq);
  1127. if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
  1128. return;
  1129. #ifdef CONFIG_SMP
  1130. if (WARN_ON(desc->affinity_notify))
  1131. desc->affinity_notify = NULL;
  1132. #endif
  1133. chip_bus_lock(desc);
  1134. kfree(__free_irq(irq, dev_id));
  1135. chip_bus_sync_unlock(desc);
  1136. }
  1137. EXPORT_SYMBOL(free_irq);
  1138. /**
  1139. * request_threaded_irq - allocate an interrupt line
  1140. * @irq: Interrupt line to allocate
  1141. * @handler: Function to be called when the IRQ occurs.
  1142. * Primary handler for threaded interrupts
  1143. * If NULL and thread_fn != NULL the default
  1144. * primary handler is installed
  1145. * @thread_fn: Function called from the irq handler thread
  1146. * If NULL, no irq thread is created
  1147. * @irqflags: Interrupt type flags
  1148. * @devname: An ascii name for the claiming device
  1149. * @dev_id: A cookie passed back to the handler function
  1150. *
  1151. * This call allocates interrupt resources and enables the
  1152. * interrupt line and IRQ handling. From the point this
  1153. * call is made your handler function may be invoked. Since
  1154. * your handler function must clear any interrupt the board
  1155. * raises, you must take care both to initialise your hardware
  1156. * and to set up the interrupt handler in the right order.
  1157. *
  1158. * If you want to set up a threaded irq handler for your device
  1159. * then you need to supply @handler and @thread_fn. @handler is
  1160. * still called in hard interrupt context and has to check
  1161. * whether the interrupt originates from the device. If yes it
  1162. * needs to disable the interrupt on the device and return
  1163. * IRQ_WAKE_THREAD which will wake up the handler thread and run
  1164. * @thread_fn. This split handler design is necessary to support
  1165. * shared interrupts.
  1166. *
  1167. * Dev_id must be globally unique. Normally the address of the
  1168. * device data structure is used as the cookie. Since the handler
  1169. * receives this value it makes sense to use it.
  1170. *
  1171. * If your interrupt is shared you must pass a non NULL dev_id
  1172. * as this is required when freeing the interrupt.
  1173. *
  1174. * Flags:
  1175. *
  1176. * IRQF_SHARED Interrupt is shared
  1177. * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy
  1178. * IRQF_TRIGGER_* Specify active edge(s) or level
  1179. *
  1180. */
  1181. int request_threaded_irq(unsigned int irq, irq_handler_t handler,
  1182. irq_handler_t thread_fn, unsigned long irqflags,
  1183. const char *devname, void *dev_id)
  1184. {
  1185. struct irqaction *action;
  1186. struct irq_desc *desc;
  1187. int retval;
  1188. /*
  1189. * Sanity-check: shared interrupts must pass in a real dev-ID,
  1190. * otherwise we'll have trouble later trying to figure out
  1191. * which interrupt is which (messes up the interrupt freeing
  1192. * logic etc).
  1193. */
  1194. if ((irqflags & IRQF_SHARED) && !dev_id)
  1195. return -EINVAL;
  1196. desc = irq_to_desc(irq);
  1197. if (!desc)
  1198. return -EINVAL;
  1199. if (!irq_settings_can_request(desc) ||
  1200. WARN_ON(irq_settings_is_per_cpu_devid(desc)))
  1201. return -EINVAL;
  1202. if (!handler) {
  1203. if (!thread_fn)
  1204. return -EINVAL;
  1205. handler = irq_default_primary_handler;
  1206. }
  1207. action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
  1208. if (!action)
  1209. return -ENOMEM;
  1210. action->handler = handler;
  1211. action->thread_fn = thread_fn;
  1212. action->flags = irqflags;
  1213. action->name = devname;
  1214. action->dev_id = dev_id;
  1215. chip_bus_lock(desc);
  1216. retval = __setup_irq(irq, desc, action);
  1217. chip_bus_sync_unlock(desc);
  1218. if (retval)
  1219. kfree(action);
  1220. #ifdef CONFIG_DEBUG_SHIRQ_FIXME
  1221. if (!retval && (irqflags & IRQF_SHARED)) {
  1222. /*
  1223. * It's a shared IRQ -- the driver ought to be prepared for it
  1224. * to happen immediately, so let's make sure....
  1225. * We disable the irq to make sure that a 'real' IRQ doesn't
  1226. * run in parallel with our fake.
  1227. */
  1228. unsigned long flags;
  1229. disable_irq(irq);
  1230. local_irq_save(flags);
  1231. handler(irq, dev_id);
  1232. local_irq_restore(flags);
  1233. enable_irq(irq);
  1234. }
  1235. #endif
  1236. return retval;
  1237. }
  1238. EXPORT_SYMBOL(request_threaded_irq);
  1239. /**
  1240. * request_any_context_irq - allocate an interrupt line
  1241. * @irq: Interrupt line to allocate
  1242. * @handler: Function to be called when the IRQ occurs.
  1243. * Threaded handler for threaded interrupts.
  1244. * @flags: Interrupt type flags
  1245. * @name: An ascii name for the claiming device
  1246. * @dev_id: A cookie passed back to the handler function
  1247. *
  1248. * This call allocates interrupt resources and enables the
  1249. * interrupt line and IRQ handling. It selects either a
  1250. * hardirq or threaded handling method depending on the
  1251. * context.
  1252. *
  1253. * On failure, it returns a negative value. On success,
  1254. * it returns either IRQC_IS_HARDIRQ or IRQC_IS_NESTED.
  1255. */
  1256. int request_any_context_irq(unsigned int irq, irq_handler_t handler,
  1257. unsigned long flags, const char *name, void *dev_id)
  1258. {
  1259. struct irq_desc *desc = irq_to_desc(irq);
  1260. int ret;
  1261. if (!desc)
  1262. return -EINVAL;
  1263. if (irq_settings_is_nested_thread(desc)) {
  1264. ret = request_threaded_irq(irq, NULL, handler,
  1265. flags, name, dev_id);
  1266. return !ret ? IRQC_IS_NESTED : ret;
  1267. }
  1268. ret = request_irq(irq, handler, flags, name, dev_id);
  1269. return !ret ? IRQC_IS_HARDIRQ : ret;
  1270. }
  1271. EXPORT_SYMBOL_GPL(request_any_context_irq);
  1272. void enable_percpu_irq(unsigned int irq, unsigned int type)
  1273. {
  1274. unsigned int cpu = smp_processor_id();
  1275. unsigned long flags;
  1276. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
  1277. if (!desc)
  1278. return;
  1279. type &= IRQ_TYPE_SENSE_MASK;
  1280. if (type != IRQ_TYPE_NONE) {
  1281. int ret;
  1282. ret = __irq_set_trigger(desc, irq, type);
  1283. if (ret) {
  1284. WARN(1, "failed to set type for IRQ%d\n", irq);
  1285. goto out;
  1286. }
  1287. }
  1288. irq_percpu_enable(desc, cpu);
  1289. out:
  1290. irq_put_desc_unlock(desc, flags);
  1291. }
  1292. void disable_percpu_irq(unsigned int irq)
  1293. {
  1294. unsigned int cpu = smp_processor_id();
  1295. unsigned long flags;
  1296. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
  1297. if (!desc)
  1298. return;
  1299. irq_percpu_disable(desc, cpu);
  1300. irq_put_desc_unlock(desc, flags);
  1301. }
  1302. /*
  1303. * Internal function to unregister a percpu irqaction.
  1304. */
  1305. static struct irqaction *__free_percpu_irq(unsigned int irq, void __percpu *dev_id)
  1306. {
  1307. struct irq_desc *desc = irq_to_desc(irq);
  1308. struct irqaction *action;
  1309. unsigned long flags;
  1310. WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
  1311. if (!desc)
  1312. return NULL;
  1313. raw_spin_lock_irqsave(&desc->lock, flags);
  1314. action = desc->action;
  1315. if (!action || action->percpu_dev_id != dev_id) {
  1316. WARN(1, "Trying to free already-free IRQ %d\n", irq);
  1317. goto bad;
  1318. }
  1319. if (!cpumask_empty(desc->percpu_enabled)) {
  1320. WARN(1, "percpu IRQ %d still enabled on CPU%d!\n",
  1321. irq, cpumask_first(desc->percpu_enabled));
  1322. goto bad;
  1323. }
  1324. /* Found it - now remove it from the list of entries: */
  1325. desc->action = NULL;
  1326. raw_spin_unlock_irqrestore(&desc->lock, flags);
  1327. unregister_handler_proc(irq, action);
  1328. module_put(desc->owner);
  1329. return action;
  1330. bad:
  1331. raw_spin_unlock_irqrestore(&desc->lock, flags);
  1332. return NULL;
  1333. }
  1334. /**
  1335. * remove_percpu_irq - free a per-cpu interrupt
  1336. * @irq: Interrupt line to free
  1337. * @act: irqaction for the interrupt
  1338. *
  1339. * Used to remove interrupts statically setup by the early boot process.
  1340. */
  1341. void remove_percpu_irq(unsigned int irq, struct irqaction *act)
  1342. {
  1343. struct irq_desc *desc = irq_to_desc(irq);
  1344. if (desc && irq_settings_is_per_cpu_devid(desc))
  1345. __free_percpu_irq(irq, act->percpu_dev_id);
  1346. }
  1347. /**
  1348. * free_percpu_irq - free an interrupt allocated with request_percpu_irq
  1349. * @irq: Interrupt line to free
  1350. * @dev_id: Device identity to free
  1351. *
  1352. * Remove a percpu interrupt handler. The handler is removed, but
  1353. * the interrupt line is not disabled. This must be done on each
  1354. * CPU before calling this function. The function does not return
  1355. * until any executing interrupts for this IRQ have completed.
  1356. *
  1357. * This function must not be called from interrupt context.
  1358. */
  1359. void free_percpu_irq(unsigned int irq, void __percpu *dev_id)
  1360. {
  1361. struct irq_desc *desc = irq_to_desc(irq);
  1362. if (!desc || !irq_settings_is_per_cpu_devid(desc))
  1363. return;
  1364. chip_bus_lock(desc);
  1365. kfree(__free_percpu_irq(irq, dev_id));
  1366. chip_bus_sync_unlock(desc);
  1367. }
  1368. /**
  1369. * setup_percpu_irq - setup a per-cpu interrupt
  1370. * @irq: Interrupt line to setup
  1371. * @act: irqaction for the interrupt
  1372. *
  1373. * Used to statically setup per-cpu interrupts in the early boot process.
  1374. */
  1375. int setup_percpu_irq(unsigned int irq, struct irqaction *act)
  1376. {
  1377. struct irq_desc *desc = irq_to_desc(irq);
  1378. int retval;
  1379. if (!desc || !irq_settings_is_per_cpu_devid(desc))
  1380. return -EINVAL;
  1381. chip_bus_lock(desc);
  1382. retval = __setup_irq(irq, desc, act);
  1383. chip_bus_sync_unlock(desc);
  1384. return retval;
  1385. }
  1386. /**
  1387. * request_percpu_irq - allocate a percpu interrupt line
  1388. * @irq: Interrupt line to allocate
  1389. * @handler: Function to be called when the IRQ occurs.
  1390. * @devname: An ascii name for the claiming device
  1391. * @dev_id: A percpu cookie passed back to the handler function
  1392. *
  1393. * This call allocates interrupt resources, but doesn't
  1394. * automatically enable the interrupt. It has to be done on each
  1395. * CPU using enable_percpu_irq().
  1396. *
  1397. * Dev_id must be globally unique. It is a per-cpu variable, and
  1398. * the handler gets called with the interrupted CPU's instance of
  1399. * that variable.
  1400. */
  1401. int request_percpu_irq(unsigned int irq, irq_handler_t handler,
  1402. const char *devname, void __percpu *dev_id)
  1403. {
  1404. struct irqaction *action;
  1405. struct irq_desc *desc;
  1406. int retval;
  1407. if (!dev_id)
  1408. return -EINVAL;
  1409. desc = irq_to_desc(irq);
  1410. if (!desc || !irq_settings_can_request(desc) ||
  1411. !irq_settings_is_per_cpu_devid(desc))
  1412. return -EINVAL;
  1413. action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
  1414. if (!action)
  1415. return -ENOMEM;
  1416. action->handler = handler;
  1417. action->flags = IRQF_PERCPU | IRQF_NO_SUSPEND;
  1418. action->name = devname;
  1419. action->percpu_dev_id = dev_id;
  1420. chip_bus_lock(desc);
  1421. retval = __setup_irq(irq, desc, action);
  1422. chip_bus_sync_unlock(desc);
  1423. if (retval)
  1424. kfree(action);
  1425. return retval;
  1426. }