manage.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692
  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/module.h>
  11. #include <linux/random.h>
  12. #include <linux/interrupt.h>
  13. #include <linux/slab.h>
  14. #include "internals.h"
  15. #ifdef CONFIG_SMP
  16. cpumask_t irq_default_affinity = CPU_MASK_ALL;
  17. /**
  18. * synchronize_irq - wait for pending IRQ handlers (on other CPUs)
  19. * @irq: interrupt number to wait for
  20. *
  21. * This function waits for any pending IRQ handlers for this interrupt
  22. * to complete before returning. If you use this function while
  23. * holding a resource the IRQ handler may need you will deadlock.
  24. *
  25. * This function may be called - with care - from IRQ context.
  26. */
  27. void synchronize_irq(unsigned int irq)
  28. {
  29. struct irq_desc *desc = irq_to_desc(irq);
  30. unsigned int status;
  31. if (!desc)
  32. return;
  33. do {
  34. unsigned long flags;
  35. /*
  36. * Wait until we're out of the critical section. This might
  37. * give the wrong answer due to the lack of memory barriers.
  38. */
  39. while (desc->status & IRQ_INPROGRESS)
  40. cpu_relax();
  41. /* Ok, that indicated we're done: double-check carefully. */
  42. spin_lock_irqsave(&desc->lock, flags);
  43. status = desc->status;
  44. spin_unlock_irqrestore(&desc->lock, flags);
  45. /* Oops, that failed? */
  46. } while (status & IRQ_INPROGRESS);
  47. }
  48. EXPORT_SYMBOL(synchronize_irq);
  49. /**
  50. * irq_can_set_affinity - Check if the affinity of a given irq can be set
  51. * @irq: Interrupt to check
  52. *
  53. */
  54. int irq_can_set_affinity(unsigned int irq)
  55. {
  56. struct irq_desc *desc = irq_to_desc(irq);
  57. if (CHECK_IRQ_PER_CPU(desc->status) || !desc->chip ||
  58. !desc->chip->set_affinity)
  59. return 0;
  60. return 1;
  61. }
  62. /**
  63. * irq_set_affinity - Set the irq affinity of a given irq
  64. * @irq: Interrupt to set affinity
  65. * @cpumask: cpumask
  66. *
  67. */
  68. int irq_set_affinity(unsigned int irq, cpumask_t cpumask)
  69. {
  70. struct irq_desc *desc = irq_to_desc(irq);
  71. if (!desc->chip->set_affinity)
  72. return -EINVAL;
  73. set_balance_irq_affinity(irq, cpumask);
  74. #ifdef CONFIG_GENERIC_PENDING_IRQ
  75. if (desc->status & IRQ_MOVE_PCNTXT) {
  76. unsigned long flags;
  77. spin_lock_irqsave(&desc->lock, flags);
  78. desc->chip->set_affinity(irq, cpumask);
  79. spin_unlock_irqrestore(&desc->lock, flags);
  80. } else
  81. set_pending_irq(irq, cpumask);
  82. #else
  83. desc->affinity = cpumask;
  84. desc->chip->set_affinity(irq, cpumask);
  85. #endif
  86. return 0;
  87. }
  88. #ifndef CONFIG_AUTO_IRQ_AFFINITY
  89. /*
  90. * Generic version of the affinity autoselector.
  91. */
  92. int irq_select_affinity(unsigned int irq)
  93. {
  94. cpumask_t mask;
  95. struct irq_desc *desc;
  96. if (!irq_can_set_affinity(irq))
  97. return 0;
  98. cpus_and(mask, cpu_online_map, irq_default_affinity);
  99. desc = irq_to_desc(irq);
  100. desc->affinity = mask;
  101. desc->chip->set_affinity(irq, mask);
  102. set_balance_irq_affinity(irq, mask);
  103. return 0;
  104. }
  105. #endif
  106. #endif
  107. /**
  108. * disable_irq_nosync - disable an irq without waiting
  109. * @irq: Interrupt to disable
  110. *
  111. * Disable the selected interrupt line. Disables and Enables are
  112. * nested.
  113. * Unlike disable_irq(), this function does not ensure existing
  114. * instances of the IRQ handler have completed before returning.
  115. *
  116. * This function may be called from IRQ context.
  117. */
  118. void disable_irq_nosync(unsigned int irq)
  119. {
  120. struct irq_desc *desc;
  121. unsigned long flags;
  122. desc = irq_to_desc(irq);
  123. if (!desc)
  124. return;
  125. spin_lock_irqsave(&desc->lock, flags);
  126. if (!desc->depth++) {
  127. desc->status |= IRQ_DISABLED;
  128. desc->chip->disable(irq);
  129. }
  130. spin_unlock_irqrestore(&desc->lock, flags);
  131. }
  132. EXPORT_SYMBOL(disable_irq_nosync);
  133. /**
  134. * disable_irq - disable an irq and wait for completion
  135. * @irq: Interrupt to disable
  136. *
  137. * Disable the selected interrupt line. Enables and Disables are
  138. * nested.
  139. * This function waits for any pending IRQ handlers for this interrupt
  140. * to complete before returning. If you use this function while
  141. * holding a resource the IRQ handler may need you will deadlock.
  142. *
  143. * This function may be called - with care - from IRQ context.
  144. */
  145. void disable_irq(unsigned int irq)
  146. {
  147. struct irq_desc *desc;
  148. desc = irq_to_desc(irq);
  149. if (!desc)
  150. return;
  151. disable_irq_nosync(irq);
  152. if (desc->action)
  153. synchronize_irq(irq);
  154. }
  155. EXPORT_SYMBOL(disable_irq);
  156. static void __enable_irq(struct irq_desc *desc, unsigned int irq)
  157. {
  158. switch (desc->depth) {
  159. case 0:
  160. WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
  161. break;
  162. case 1: {
  163. unsigned int status = desc->status & ~IRQ_DISABLED;
  164. /* Prevent probing on this irq: */
  165. desc->status = status | IRQ_NOPROBE;
  166. check_irq_resend(desc, irq);
  167. /* fall-through */
  168. }
  169. default:
  170. desc->depth--;
  171. }
  172. }
  173. /**
  174. * enable_irq - enable handling of an irq
  175. * @irq: Interrupt to enable
  176. *
  177. * Undoes the effect of one call to disable_irq(). If this
  178. * matches the last disable, processing of interrupts on this
  179. * IRQ line is re-enabled.
  180. *
  181. * This function may be called from IRQ context.
  182. */
  183. void enable_irq(unsigned int irq)
  184. {
  185. struct irq_desc *desc;
  186. unsigned long flags;
  187. desc = irq_to_desc(irq);
  188. if (!desc)
  189. return;
  190. spin_lock_irqsave(&desc->lock, flags);
  191. __enable_irq(desc, irq);
  192. spin_unlock_irqrestore(&desc->lock, flags);
  193. }
  194. EXPORT_SYMBOL(enable_irq);
  195. static int set_irq_wake_real(unsigned int irq, unsigned int on)
  196. {
  197. struct irq_desc *desc = irq_to_desc(irq);
  198. int ret = -ENXIO;
  199. if (desc->chip->set_wake)
  200. ret = desc->chip->set_wake(irq, on);
  201. return ret;
  202. }
  203. /**
  204. * set_irq_wake - control irq power management wakeup
  205. * @irq: interrupt to control
  206. * @on: enable/disable power management wakeup
  207. *
  208. * Enable/disable power management wakeup mode, which is
  209. * disabled by default. Enables and disables must match,
  210. * just as they match for non-wakeup mode support.
  211. *
  212. * Wakeup mode lets this IRQ wake the system from sleep
  213. * states like "suspend to RAM".
  214. */
  215. int set_irq_wake(unsigned int irq, unsigned int on)
  216. {
  217. struct irq_desc *desc = irq_to_desc(irq);
  218. unsigned long flags;
  219. int ret = 0;
  220. /* wakeup-capable irqs can be shared between drivers that
  221. * don't need to have the same sleep mode behaviors.
  222. */
  223. spin_lock_irqsave(&desc->lock, flags);
  224. if (on) {
  225. if (desc->wake_depth++ == 0) {
  226. ret = set_irq_wake_real(irq, on);
  227. if (ret)
  228. desc->wake_depth = 0;
  229. else
  230. desc->status |= IRQ_WAKEUP;
  231. }
  232. } else {
  233. if (desc->wake_depth == 0) {
  234. WARN(1, "Unbalanced IRQ %d wake disable\n", irq);
  235. } else if (--desc->wake_depth == 0) {
  236. ret = set_irq_wake_real(irq, on);
  237. if (ret)
  238. desc->wake_depth = 1;
  239. else
  240. desc->status &= ~IRQ_WAKEUP;
  241. }
  242. }
  243. spin_unlock_irqrestore(&desc->lock, flags);
  244. return ret;
  245. }
  246. EXPORT_SYMBOL(set_irq_wake);
  247. /*
  248. * Internal function that tells the architecture code whether a
  249. * particular irq has been exclusively allocated or is available
  250. * for driver use.
  251. */
  252. int can_request_irq(unsigned int irq, unsigned long irqflags)
  253. {
  254. struct irq_desc *desc;
  255. struct irqaction *action;
  256. desc = irq_to_desc(irq);
  257. if (!desc)
  258. return 0;
  259. if (desc->status & IRQ_NOREQUEST)
  260. return 0;
  261. action = desc->action;
  262. if (action)
  263. if (irqflags & action->flags & IRQF_SHARED)
  264. action = NULL;
  265. return !action;
  266. }
  267. void compat_irq_chip_set_default_handler(struct irq_desc *desc)
  268. {
  269. /*
  270. * If the architecture still has not overriden
  271. * the flow handler then zap the default. This
  272. * should catch incorrect flow-type setting.
  273. */
  274. if (desc->handle_irq == &handle_bad_irq)
  275. desc->handle_irq = NULL;
  276. }
  277. int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
  278. unsigned long flags)
  279. {
  280. int ret;
  281. struct irq_chip *chip = desc->chip;
  282. if (!chip || !chip->set_type) {
  283. /*
  284. * IRQF_TRIGGER_* but the PIC does not support multiple
  285. * flow-types?
  286. */
  287. pr_warning("No set_type function for IRQ %d (%s)\n", irq,
  288. chip ? (chip->name ? : "unknown") : "unknown");
  289. return 0;
  290. }
  291. ret = chip->set_type(irq, flags & IRQF_TRIGGER_MASK);
  292. if (ret)
  293. pr_err("setting trigger mode %d for irq %u failed (%pF)\n",
  294. (int)(flags & IRQF_TRIGGER_MASK),
  295. irq, chip->set_type);
  296. else {
  297. /* note that IRQF_TRIGGER_MASK == IRQ_TYPE_SENSE_MASK */
  298. desc->status &= ~IRQ_TYPE_SENSE_MASK;
  299. desc->status |= flags & IRQ_TYPE_SENSE_MASK;
  300. }
  301. return ret;
  302. }
  303. /*
  304. * Internal function to register an irqaction - typically used to
  305. * allocate special interrupts that are part of the architecture.
  306. */
  307. int setup_irq(unsigned int irq, struct irqaction *new)
  308. {
  309. struct irq_desc *desc;
  310. struct irqaction *old, **p;
  311. const char *old_name = NULL;
  312. unsigned long flags;
  313. int shared = 0;
  314. int ret;
  315. desc = irq_to_desc(irq);
  316. if (!desc)
  317. return -EINVAL;
  318. if (desc->chip == &no_irq_chip)
  319. return -ENOSYS;
  320. /*
  321. * Some drivers like serial.c use request_irq() heavily,
  322. * so we have to be careful not to interfere with a
  323. * running system.
  324. */
  325. if (new->flags & IRQF_SAMPLE_RANDOM) {
  326. /*
  327. * This function might sleep, we want to call it first,
  328. * outside of the atomic block.
  329. * Yes, this might clear the entropy pool if the wrong
  330. * driver is attempted to be loaded, without actually
  331. * installing a new handler, but is this really a problem,
  332. * only the sysadmin is able to do this.
  333. */
  334. rand_initialize_irq(irq);
  335. }
  336. /*
  337. * The following block of code has to be executed atomically
  338. */
  339. spin_lock_irqsave(&desc->lock, flags);
  340. p = &desc->action;
  341. old = *p;
  342. if (old) {
  343. /*
  344. * Can't share interrupts unless both agree to and are
  345. * the same type (level, edge, polarity). So both flag
  346. * fields must have IRQF_SHARED set and the bits which
  347. * set the trigger type must match.
  348. */
  349. if (!((old->flags & new->flags) & IRQF_SHARED) ||
  350. ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK)) {
  351. old_name = old->name;
  352. goto mismatch;
  353. }
  354. #if defined(CONFIG_IRQ_PER_CPU)
  355. /* All handlers must agree on per-cpuness */
  356. if ((old->flags & IRQF_PERCPU) !=
  357. (new->flags & IRQF_PERCPU))
  358. goto mismatch;
  359. #endif
  360. /* add new interrupt at end of irq queue */
  361. do {
  362. p = &old->next;
  363. old = *p;
  364. } while (old);
  365. shared = 1;
  366. }
  367. if (!shared) {
  368. irq_chip_set_defaults(desc->chip);
  369. /* Setup the type (level, edge polarity) if configured: */
  370. if (new->flags & IRQF_TRIGGER_MASK) {
  371. ret = __irq_set_trigger(desc, irq, new->flags);
  372. if (ret) {
  373. spin_unlock_irqrestore(&desc->lock, flags);
  374. return ret;
  375. }
  376. } else
  377. compat_irq_chip_set_default_handler(desc);
  378. #if defined(CONFIG_IRQ_PER_CPU)
  379. if (new->flags & IRQF_PERCPU)
  380. desc->status |= IRQ_PER_CPU;
  381. #endif
  382. desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING |
  383. IRQ_INPROGRESS | IRQ_SPURIOUS_DISABLED);
  384. if (!(desc->status & IRQ_NOAUTOEN)) {
  385. desc->depth = 0;
  386. desc->status &= ~IRQ_DISABLED;
  387. desc->chip->startup(irq);
  388. } else
  389. /* Undo nested disables: */
  390. desc->depth = 1;
  391. /* Set default affinity mask once everything is setup */
  392. irq_select_affinity(irq);
  393. } else if ((new->flags & IRQF_TRIGGER_MASK)
  394. && (new->flags & IRQF_TRIGGER_MASK)
  395. != (desc->status & IRQ_TYPE_SENSE_MASK)) {
  396. /* hope the handler works with the actual trigger mode... */
  397. pr_warning("IRQ %d uses trigger mode %d; requested %d\n",
  398. irq, (int)(desc->status & IRQ_TYPE_SENSE_MASK),
  399. (int)(new->flags & IRQF_TRIGGER_MASK));
  400. }
  401. *p = new;
  402. /* Exclude IRQ from balancing */
  403. if (new->flags & IRQF_NOBALANCING)
  404. desc->status |= IRQ_NO_BALANCING;
  405. /* Reset broken irq detection when installing new handler */
  406. desc->irq_count = 0;
  407. desc->irqs_unhandled = 0;
  408. /*
  409. * Check whether we disabled the irq via the spurious handler
  410. * before. Reenable it and give it another chance.
  411. */
  412. if (shared && (desc->status & IRQ_SPURIOUS_DISABLED)) {
  413. desc->status &= ~IRQ_SPURIOUS_DISABLED;
  414. __enable_irq(desc, irq);
  415. }
  416. spin_unlock_irqrestore(&desc->lock, flags);
  417. new->irq = irq;
  418. register_irq_proc(irq, desc);
  419. new->dir = NULL;
  420. register_handler_proc(irq, new);
  421. return 0;
  422. mismatch:
  423. #ifdef CONFIG_DEBUG_SHIRQ
  424. if (!(new->flags & IRQF_PROBE_SHARED)) {
  425. printk(KERN_ERR "IRQ handler type mismatch for IRQ %d\n", irq);
  426. if (old_name)
  427. printk(KERN_ERR "current handler: %s\n", old_name);
  428. dump_stack();
  429. }
  430. #endif
  431. spin_unlock_irqrestore(&desc->lock, flags);
  432. return -EBUSY;
  433. }
  434. /**
  435. * free_irq - free an interrupt
  436. * @irq: Interrupt line to free
  437. * @dev_id: Device identity to free
  438. *
  439. * Remove an interrupt handler. The handler is removed and if the
  440. * interrupt line is no longer in use by any driver it is disabled.
  441. * On a shared IRQ the caller must ensure the interrupt is disabled
  442. * on the card it drives before calling this function. The function
  443. * does not return until any executing interrupts for this IRQ
  444. * have completed.
  445. *
  446. * This function must not be called from interrupt context.
  447. */
  448. void free_irq(unsigned int irq, void *dev_id)
  449. {
  450. struct irq_desc *desc;
  451. struct irqaction **p;
  452. unsigned long flags;
  453. WARN_ON(in_interrupt());
  454. desc = irq_to_desc(irq);
  455. if (!desc)
  456. return;
  457. spin_lock_irqsave(&desc->lock, flags);
  458. p = &desc->action;
  459. for (;;) {
  460. struct irqaction *action = *p;
  461. if (action) {
  462. struct irqaction **pp = p;
  463. p = &action->next;
  464. if (action->dev_id != dev_id)
  465. continue;
  466. /* Found it - now remove it from the list of entries */
  467. *pp = action->next;
  468. /* Currently used only by UML, might disappear one day.*/
  469. #ifdef CONFIG_IRQ_RELEASE_METHOD
  470. if (desc->chip->release)
  471. desc->chip->release(irq, dev_id);
  472. #endif
  473. if (!desc->action) {
  474. desc->status |= IRQ_DISABLED;
  475. if (desc->chip->shutdown)
  476. desc->chip->shutdown(irq);
  477. else
  478. desc->chip->disable(irq);
  479. }
  480. spin_unlock_irqrestore(&desc->lock, flags);
  481. unregister_handler_proc(irq, action);
  482. /* Make sure it's not being used on another CPU */
  483. synchronize_irq(irq);
  484. #ifdef CONFIG_DEBUG_SHIRQ
  485. /*
  486. * It's a shared IRQ -- the driver ought to be
  487. * prepared for it to happen even now it's
  488. * being freed, so let's make sure.... We do
  489. * this after actually deregistering it, to
  490. * make sure that a 'real' IRQ doesn't run in
  491. * parallel with our fake
  492. */
  493. if (action->flags & IRQF_SHARED) {
  494. local_irq_save(flags);
  495. action->handler(irq, dev_id);
  496. local_irq_restore(flags);
  497. }
  498. #endif
  499. kfree(action);
  500. return;
  501. }
  502. printk(KERN_ERR "Trying to free already-free IRQ %d\n", irq);
  503. #ifdef CONFIG_DEBUG_SHIRQ
  504. dump_stack();
  505. #endif
  506. spin_unlock_irqrestore(&desc->lock, flags);
  507. return;
  508. }
  509. }
  510. EXPORT_SYMBOL(free_irq);
  511. /**
  512. * request_irq - allocate an interrupt line
  513. * @irq: Interrupt line to allocate
  514. * @handler: Function to be called when the IRQ occurs
  515. * @irqflags: Interrupt type flags
  516. * @devname: An ascii name for the claiming device
  517. * @dev_id: A cookie passed back to the handler function
  518. *
  519. * This call allocates interrupt resources and enables the
  520. * interrupt line and IRQ handling. From the point this
  521. * call is made your handler function may be invoked. Since
  522. * your handler function must clear any interrupt the board
  523. * raises, you must take care both to initialise your hardware
  524. * and to set up the interrupt handler in the right order.
  525. *
  526. * Dev_id must be globally unique. Normally the address of the
  527. * device data structure is used as the cookie. Since the handler
  528. * receives this value it makes sense to use it.
  529. *
  530. * If your interrupt is shared you must pass a non NULL dev_id
  531. * as this is required when freeing the interrupt.
  532. *
  533. * Flags:
  534. *
  535. * IRQF_SHARED Interrupt is shared
  536. * IRQF_DISABLED Disable local interrupts while processing
  537. * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy
  538. * IRQF_TRIGGER_* Specify active edge(s) or level
  539. *
  540. */
  541. int request_irq(unsigned int irq, irq_handler_t handler,
  542. unsigned long irqflags, const char *devname, void *dev_id)
  543. {
  544. struct irqaction *action;
  545. int retval;
  546. struct irq_desc *desc;
  547. #ifdef CONFIG_LOCKDEP
  548. /*
  549. * Lockdep wants atomic interrupt handlers:
  550. */
  551. irqflags |= IRQF_DISABLED;
  552. #endif
  553. /*
  554. * Sanity-check: shared interrupts must pass in a real dev-ID,
  555. * otherwise we'll have trouble later trying to figure out
  556. * which interrupt is which (messes up the interrupt freeing
  557. * logic etc).
  558. */
  559. if ((irqflags & IRQF_SHARED) && !dev_id)
  560. return -EINVAL;
  561. desc = irq_to_desc(irq);
  562. if (!desc)
  563. return -EINVAL;
  564. if (desc->status & IRQ_NOREQUEST)
  565. return -EINVAL;
  566. if (!handler)
  567. return -EINVAL;
  568. action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
  569. if (!action)
  570. return -ENOMEM;
  571. action->handler = handler;
  572. action->flags = irqflags;
  573. cpus_clear(action->mask);
  574. action->name = devname;
  575. action->next = NULL;
  576. action->dev_id = dev_id;
  577. retval = setup_irq(irq, action);
  578. if (retval)
  579. kfree(action);
  580. #ifdef CONFIG_DEBUG_SHIRQ
  581. if (irqflags & IRQF_SHARED) {
  582. /*
  583. * It's a shared IRQ -- the driver ought to be prepared for it
  584. * to happen immediately, so let's make sure....
  585. * We disable the irq to make sure that a 'real' IRQ doesn't
  586. * run in parallel with our fake.
  587. */
  588. unsigned long flags;
  589. disable_irq(irq);
  590. local_irq_save(flags);
  591. handler(irq, dev_id);
  592. local_irq_restore(flags);
  593. enable_irq(irq);
  594. }
  595. #endif
  596. return retval;
  597. }
  598. EXPORT_SYMBOL(request_irq);