manage.c 15 KB

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