home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / irq.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  11.7 KB  |  388 lines
  1. #ifndef _LINUX_IRQ_H
  2. #define _LINUX_IRQ_H
  3.  
  4. /*
  5.  * Please do not include this file in generic code.  There is currently
  6.  * no requirement for any architecture to implement anything held
  7.  * within this file.
  8.  *
  9.  * Thanks. --rmk
  10.  */
  11.  
  12. #include <linux/smp.h>
  13.  
  14. #ifndef CONFIG_S390
  15.  
  16. #include <linux/linkage.h>
  17. #include <linux/cache.h>
  18. #include <linux/spinlock.h>
  19. #include <linux/cpumask.h>
  20. #include <linux/irqreturn.h>
  21. #include <linux/irqnr.h>
  22. #include <linux/errno.h>
  23.  
  24. #include <asm/irq.h>
  25. #include <asm/ptrace.h>
  26. #include <asm/irq_regs.h>
  27.  
  28. struct irq_desc;
  29. typedef    void (*irq_flow_handler_t)(unsigned int irq,
  30.                         struct irq_desc *desc);
  31.  
  32.  
  33. /*
  34.  * IRQ line status.
  35.  *
  36.  * Bits 0-7 are reserved for the IRQF_* bits in linux/interrupt.h
  37.  *
  38.  * IRQ types
  39.  */
  40. #define IRQ_TYPE_NONE        0x00000000    /* Default, unspecified type */
  41. #define IRQ_TYPE_EDGE_RISING    0x00000001    /* Edge rising type */
  42. #define IRQ_TYPE_EDGE_FALLING    0x00000002    /* Edge falling type */
  43. #define IRQ_TYPE_EDGE_BOTH (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)
  44. #define IRQ_TYPE_LEVEL_HIGH    0x00000004    /* Level high type */
  45. #define IRQ_TYPE_LEVEL_LOW    0x00000008    /* Level low type */
  46. #define IRQ_TYPE_SENSE_MASK    0x0000000f    /* Mask of the above */
  47. #define IRQ_TYPE_PROBE        0x00000010    /* Probing in progress */
  48.  
  49. /* Internal flags */
  50. #define IRQ_INPROGRESS        0x00000100    /* IRQ handler active - do not enter! */
  51. #define IRQ_DISABLED        0x00000200    /* IRQ disabled - do not enter! */
  52. #define IRQ_PENDING        0x00000400    /* IRQ pending - replay on enable */
  53. #define IRQ_REPLAY        0x00000800    /* IRQ has been replayed but not acked yet */
  54. #define IRQ_AUTODETECT        0x00001000    /* IRQ is being autodetected */
  55. #define IRQ_WAITING        0x00002000    /* IRQ not yet seen - for autodetection */
  56. #define IRQ_LEVEL        0x00004000    /* IRQ level triggered */
  57. #define IRQ_MASKED        0x00008000    /* IRQ masked - shouldn't be seen again */
  58. #define IRQ_PER_CPU        0x00010000    /* IRQ is per CPU */
  59. #define IRQ_NOPROBE        0x00020000    /* IRQ is not valid for probing */
  60. #define IRQ_NOREQUEST        0x00040000    /* IRQ cannot be requested */
  61. #define IRQ_NOAUTOEN        0x00080000    /* IRQ will not be enabled on request irq */
  62. #define IRQ_WAKEUP        0x00100000    /* IRQ triggers system wakeup */
  63. #define IRQ_MOVE_PENDING    0x00200000    /* need to re-target IRQ destination */
  64. #define IRQ_NO_BALANCING    0x00400000    /* IRQ is excluded from balancing */
  65. #define IRQ_SPURIOUS_DISABLED    0x00800000    /* IRQ was disabled by the spurious trap */
  66. #define IRQ_MOVE_PCNTXT        0x01000000    /* IRQ migration from process context */
  67. #define IRQ_AFFINITY_SET    0x02000000    /* IRQ affinity was set from userspace*/
  68.  
  69. #ifdef CONFIG_IRQ_PER_CPU
  70. # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
  71. # define IRQ_NO_BALANCING_MASK    (IRQ_PER_CPU | IRQ_NO_BALANCING)
  72. #else
  73. # define CHECK_IRQ_PER_CPU(var) 0
  74. # define IRQ_NO_BALANCING_MASK    IRQ_NO_BALANCING
  75. #endif
  76.  
  77. struct proc_dir_entry;
  78. struct msi_desc;
  79.  
  80. /**
  81.  * struct irq_chip - hardware interrupt chip descriptor
  82.  *
  83.  * @name:        name for /proc/interrupts
  84.  * @startup:        start up the interrupt (defaults to ->enable if NULL)
  85.  * @shutdown:        shut down the interrupt (defaults to ->disable if NULL)
  86.  * @enable:        enable the interrupt (defaults to chip->unmask if NULL)
  87.  * @disable:        disable the interrupt (defaults to chip->mask if NULL)
  88.  * @ack:        start of a new interrupt
  89.  * @mask:        mask an interrupt source
  90.  * @mask_ack:        ack and mask an interrupt source
  91.  * @unmask:        unmask an interrupt source
  92.  * @eoi:        end of interrupt - chip level
  93.  * @end:        end of interrupt - flow level
  94.  * @set_affinity:    set the CPU affinity on SMP machines
  95.  * @retrigger:        resend an IRQ to the CPU
  96.  * @set_type:        set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
  97.  * @set_wake:        enable/disable power-management wake-on of an IRQ
  98.  *
  99.  * @release:        release function solely used by UML
  100.  * @typename:        obsoleted by name, kept as migration helper
  101.  */
  102. struct irq_chip {
  103.     const char    *name;
  104.     unsigned int    (*startup)(unsigned int irq);
  105.     void        (*shutdown)(unsigned int irq);
  106.     void        (*enable)(unsigned int irq);
  107.     void        (*disable)(unsigned int irq);
  108.  
  109.     void        (*ack)(unsigned int irq);
  110.     void        (*mask)(unsigned int irq);
  111.     void        (*mask_ack)(unsigned int irq);
  112.     void        (*unmask)(unsigned int irq);
  113.     void        (*eoi)(unsigned int irq);
  114.  
  115.     void        (*end)(unsigned int irq);
  116.     void        (*set_affinity)(unsigned int irq, cpumask_t dest);
  117.     int        (*retrigger)(unsigned int irq);
  118.     int        (*set_type)(unsigned int irq, unsigned int flow_type);
  119.     int        (*set_wake)(unsigned int irq, unsigned int on);
  120.  
  121.     /* Currently used only by UML, might disappear one day.*/
  122. #ifdef CONFIG_IRQ_RELEASE_METHOD
  123.     void        (*release)(unsigned int irq, void *dev_id);
  124. #endif
  125.     /*
  126.      * For compatibility, ->typename is copied into ->name.
  127.      * Will disappear.
  128.      */
  129.     const char    *typename;
  130. };
  131.  
  132. /**
  133.  * struct irq_desc - interrupt descriptor
  134.  * @irq:        interrupt number for this descriptor
  135.  * @handle_irq:        highlevel irq-events handler [if NULL, __do_IRQ()]
  136.  * @chip:        low level interrupt hardware access
  137.  * @msi_desc:        MSI descriptor
  138.  * @handler_data:    per-IRQ data for the irq_chip methods
  139.  * @chip_data:        platform-specific per-chip private data for the chip
  140.  *            methods, to allow shared chip implementations
  141.  * @action:        the irq action chain
  142.  * @status:        status information
  143.  * @depth:        disable-depth, for nested irq_disable() calls
  144.  * @wake_depth:        enable depth, for multiple set_irq_wake() callers
  145.  * @irq_count:        stats field to detect stalled irqs
  146.  * @irqs_unhandled:    stats field for spurious unhandled interrupts
  147.  * @last_unhandled:    aging timer for unhandled count
  148.  * @lock:        locking for SMP
  149.  * @affinity:        IRQ affinity on SMP
  150.  * @cpu:        cpu index useful for balancing
  151.  * @pending_mask:    pending rebalanced interrupts
  152.  * @dir:        /proc/irq/ procfs entry
  153.  * @name:        flow handler name for /proc/interrupts output
  154.  */
  155. struct irq_desc {
  156.     unsigned int        irq;
  157.     irq_flow_handler_t    handle_irq;
  158.     struct irq_chip        *chip;
  159.     struct msi_desc        *msi_desc;
  160.     void            *handler_data;
  161.     void            *chip_data;
  162.     struct irqaction    *action;    /* IRQ action list */
  163.     unsigned int        status;        /* IRQ status */
  164.  
  165.     unsigned int        depth;        /* nested irq disables */
  166.     unsigned int        wake_depth;    /* nested wake enables */
  167.     unsigned int        irq_count;    /* For detecting broken IRQs */
  168.     unsigned int        irqs_unhandled;
  169.     unsigned long        last_unhandled;    /* Aging timer for unhandled count */
  170.     spinlock_t        lock;
  171. #ifdef CONFIG_SMP
  172.     cpumask_t        affinity;
  173.     unsigned int        cpu;
  174. #endif
  175. #ifdef CONFIG_GENERIC_PENDING_IRQ
  176.     cpumask_t        pending_mask;
  177. #endif
  178. #ifdef CONFIG_PROC_FS
  179.     struct proc_dir_entry    *dir;
  180. #endif
  181.     const char        *name;
  182. } ____cacheline_internodealigned_in_smp;
  183.  
  184.  
  185. extern struct irq_desc irq_desc[NR_IRQS];
  186.  
  187. static inline struct irq_desc *irq_to_desc(unsigned int irq)
  188. {
  189.     return (irq < nr_irqs) ? irq_desc + irq : NULL;
  190. }
  191.  
  192. /*
  193.  * Migration helpers for obsolete names, they will go away:
  194.  */
  195. #define hw_interrupt_type    irq_chip
  196. typedef struct irq_chip        hw_irq_controller;
  197. #define no_irq_type        no_irq_chip
  198. typedef struct irq_desc        irq_desc_t;
  199.  
  200. /*
  201.  * Pick up the arch-dependent methods:
  202.  */
  203. #include <asm/hw_irq.h>
  204.  
  205. extern int setup_irq(unsigned int irq, struct irqaction *new);
  206.  
  207. #ifdef CONFIG_GENERIC_HARDIRQS
  208.  
  209. #ifdef CONFIG_SMP
  210.  
  211. #ifdef CONFIG_GENERIC_PENDING_IRQ
  212.  
  213. void move_native_irq(int irq);
  214. void move_masked_irq(int irq);
  215.  
  216. #else /* CONFIG_GENERIC_PENDING_IRQ */
  217.  
  218. static inline void move_irq(int irq)
  219. {
  220. }
  221.  
  222. static inline void move_native_irq(int irq)
  223. {
  224. }
  225.  
  226. static inline void move_masked_irq(int irq)
  227. {
  228. }
  229.  
  230. #endif /* CONFIG_GENERIC_PENDING_IRQ */
  231.  
  232. #else /* CONFIG_SMP */
  233.  
  234. #define move_native_irq(x)
  235. #define move_masked_irq(x)
  236.  
  237. #endif /* CONFIG_SMP */
  238.  
  239. extern int no_irq_affinity;
  240.  
  241. static inline int irq_balancing_disabled(unsigned int irq)
  242. {
  243.     struct irq_desc *desc;
  244.  
  245.     desc = irq_to_desc(irq);
  246.     return desc->status & IRQ_NO_BALANCING_MASK;
  247. }
  248.  
  249. /* Handle irq action chains: */
  250. extern int handle_IRQ_event(unsigned int irq, struct irqaction *action);
  251.  
  252. /*
  253.  * Built-in IRQ handlers for various IRQ types,
  254.  * callable via desc->chip->handle_irq()
  255.  */
  256. extern void handle_level_irq(unsigned int irq, struct irq_desc *desc);
  257. extern void handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc);
  258. extern void handle_edge_irq(unsigned int irq, struct irq_desc *desc);
  259. extern void handle_simple_irq(unsigned int irq, struct irq_desc *desc);
  260. extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
  261. extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
  262.  
  263. /*
  264.  * Monolithic do_IRQ implementation.
  265.  */
  266. #ifndef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
  267. extern unsigned int __do_IRQ(unsigned int irq);
  268. #endif
  269.  
  270. /*
  271.  * Architectures call this to let the generic IRQ layer
  272.  * handle an interrupt. If the descriptor is attached to an
  273.  * irqchip-style controller then we call the ->handle_irq() handler,
  274.  * and it calls __do_IRQ() if it's attached to an irqtype-style controller.
  275.  */
  276. static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc)
  277. {
  278. #ifdef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
  279.     desc->handle_irq(irq, desc);
  280. #else
  281.     if (likely(desc->handle_irq))
  282.         desc->handle_irq(irq, desc);
  283.     else
  284.         __do_IRQ(irq);
  285. #endif
  286. }
  287.  
  288. static inline void generic_handle_irq(unsigned int irq)
  289. {
  290.     generic_handle_irq_desc(irq, irq_to_desc(irq));
  291. }
  292.  
  293. /* Handling of unhandled and spurious interrupts: */
  294. extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
  295.                int action_ret);
  296.  
  297. /* Resending of interrupts :*/
  298. void check_irq_resend(struct irq_desc *desc, unsigned int irq);
  299.  
  300. /* Enable/disable irq debugging output: */
  301. extern int noirqdebug_setup(char *str);
  302.  
  303. /* Checks whether the interrupt can be requested by request_irq(): */
  304. extern int can_request_irq(unsigned int irq, unsigned long irqflags);
  305.  
  306. /* Dummy irq-chip implementations: */
  307. extern struct irq_chip no_irq_chip;
  308. extern struct irq_chip dummy_irq_chip;
  309.  
  310. extern void
  311. set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
  312.              irq_flow_handler_t handle);
  313. extern void
  314. set_irq_chip_and_handler_name(unsigned int irq, struct irq_chip *chip,
  315.                   irq_flow_handler_t handle, const char *name);
  316.  
  317. extern void
  318. __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
  319.           const char *name);
  320.  
  321. /* caller has locked the irq_desc and both params are valid */
  322. static inline void __set_irq_handler_unlocked(int irq,
  323.                           irq_flow_handler_t handler)
  324. {
  325.     struct irq_desc *desc;
  326.  
  327.     desc = irq_to_desc(irq);
  328.     desc->handle_irq = handler;
  329. }
  330.  
  331. /*
  332.  * Set a highlevel flow handler for a given IRQ:
  333.  */
  334. static inline void
  335. set_irq_handler(unsigned int irq, irq_flow_handler_t handle)
  336. {
  337.     __set_irq_handler(irq, handle, 0, NULL);
  338. }
  339.  
  340. /*
  341.  * Set a highlevel chained flow handler for a given IRQ.
  342.  * (a chained handler is automatically enabled and set to
  343.  *  IRQ_NOREQUEST and IRQ_NOPROBE)
  344.  */
  345. static inline void
  346. set_irq_chained_handler(unsigned int irq,
  347.             irq_flow_handler_t handle)
  348. {
  349.     __set_irq_handler(irq, handle, 1, NULL);
  350. }
  351.  
  352. extern void set_irq_noprobe(unsigned int irq);
  353. extern void set_irq_probe(unsigned int irq);
  354.  
  355. /* Handle dynamic irq creation and destruction */
  356. extern unsigned int create_irq_nr(unsigned int irq_want);
  357. extern int create_irq(void);
  358. extern void destroy_irq(unsigned int irq);
  359.  
  360. /* Test to see if a driver has successfully requested an irq */
  361. static inline int irq_has_action(unsigned int irq)
  362. {
  363.     struct irq_desc *desc = irq_to_desc(irq);
  364.     return desc->action != NULL;
  365. }
  366.  
  367. /* Dynamic irq helper functions */
  368. extern void dynamic_irq_init(unsigned int irq);
  369. extern void dynamic_irq_cleanup(unsigned int irq);
  370.  
  371. /* Set/get chip/data for an IRQ: */
  372. extern int set_irq_chip(unsigned int irq, struct irq_chip *chip);
  373. extern int set_irq_data(unsigned int irq, void *data);
  374. extern int set_irq_chip_data(unsigned int irq, void *data);
  375. extern int set_irq_type(unsigned int irq, unsigned int type);
  376. extern int set_irq_msi(unsigned int irq, struct msi_desc *entry);
  377.  
  378. #define get_irq_chip(irq)    (irq_to_desc(irq)->chip)
  379. #define get_irq_chip_data(irq)    (irq_to_desc(irq)->chip_data)
  380. #define get_irq_data(irq)    (irq_to_desc(irq)->handler_data)
  381. #define get_irq_msi(irq)    (irq_to_desc(irq)->msi_desc)
  382.  
  383. #endif /* CONFIG_GENERIC_HARDIRQS */
  384.  
  385. #endif /* !CONFIG_S390 */
  386.  
  387. #endif /* _LINUX_IRQ_H */
  388.