1 files changed, 282 insertions, 83 deletions
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 676e00dfb21a..ae1e422f18e3 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -1,5 +1,5 @@
-#ifndef __irq_h
+#ifndef _LINUX_IRQ_H
-#define __irq_h
+#define _LINUX_IRQ_H
 /*
 * Please do not include this file in generic code.  There is currently
@@ -11,7 +11,7 @@
 #include <linux/smp.h>
-#if !defined(CONFIG_S390)
+#ifndef CONFIG_S390
 #include <linux/linkage.h>
 #include <linux/cache.h>
@@ -24,84 +24,168 @@
 /*
 * IRQ line status.
+ *
+ * Bits 0-16 are reserved for the IRQF_* bits in linux/interrupt.h
+ *
+ * IRQ types
 */
-#define IRQ_INPROGRESS  1       /* IRQ handler active - do not enter! */
+#define IRQ_TYPE_NONE           0x00000000      /* Default, unspecified type */
-#define IRQ_DISABLED    2       /* IRQ disabled - do not enter! */
+#define IRQ_TYPE_EDGE_RISING    0x00000001      /* Edge rising type */
-#define IRQ_PENDING     4       /* IRQ pending - replay on enable */
+#define IRQ_TYPE_EDGE_FALLING   0x00000002      /* Edge falling type */
-#define IRQ_REPLAY      8       /* IRQ has been replayed but not acked yet */
+#define IRQ_TYPE_EDGE_BOTH (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)
-#define IRQ_AUTODETECT  16      /* IRQ is being autodetected */
+#define IRQ_TYPE_LEVEL_HIGH     0x00000004      /* Level high type */
-#define IRQ_WAITING     32      /* IRQ not yet seen - for autodetection */
+#define IRQ_TYPE_LEVEL_LOW      0x00000008      /* Level low type */
-#define IRQ_LEVEL       64      /* IRQ level triggered */
+#define IRQ_TYPE_SENSE_MASK     0x0000000f      /* Mask of the above */
-#define IRQ_MASKED      128     /* IRQ masked - shouldn't be seen again */
+#define IRQ_TYPE_PROBE          0x00000010      /* Probing in progress */
-#if defined(ARCH_HAS_IRQ_PER_CPU)
-# define IRQ_PER_CPU    256     /* IRQ is per CPU */
+/* Internal flags */
+#define IRQ_INPROGRESS          0x00010000      /* IRQ handler active - do not enter! */
+#define IRQ_DISABLED            0x00020000      /* IRQ disabled - do not enter! */
+#define IRQ_PENDING             0x00040000      /* IRQ pending - replay on enable */
+#define IRQ_REPLAY              0x00080000      /* IRQ has been replayed but not acked yet */
+#define IRQ_AUTODETECT          0x00100000      /* IRQ is being autodetected */
+#define IRQ_WAITING             0x00200000      /* IRQ not yet seen - for autodetection */
+#define IRQ_LEVEL               0x00400000      /* IRQ level triggered */
+#define IRQ_MASKED              0x00800000      /* IRQ masked - shouldn't be seen again */
+#ifdef CONFIG_IRQ_PER_CPU
+# define IRQ_PER_CPU            0x01000000      /* IRQ is per CPU */
 # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
 #else
 # define CHECK_IRQ_PER_CPU(var) 0
 #endif
-/*
+#define IRQ_NOPROBE             0x02000000      /* IRQ is not valid for probing */
- * Interrupt controller descriptor. This is all we need
+#define IRQ_NOREQUEST           0x04000000      /* IRQ cannot be requested */
- * to describe about the low-level hardware. 
+#define IRQ_NOAUTOEN            0x08000000      /* IRQ will not be enabled on request irq */
+#define IRQ_DELAYED_DISABLE     0x10000000      /* IRQ disable (masking) happens delayed. */
+struct proc_dir_entry;
+/**
+ * struct irq_chip - hardware interrupt chip descriptor
+ *
+ * @name:               name for /proc/interrupts
+ * @startup:            start up the interrupt (defaults to ->enable if NULL)
+ * @shutdown:           shut down the interrupt (defaults to ->disable if NULL)
+ * @enable:             enable the interrupt (defaults to chip->unmask if NULL)
+ * @disable:            disable the interrupt (defaults to chip->mask if NULL)
+ * @ack:                start of a new interrupt
+ * @mask:               mask an interrupt source
+ * @mask_ack:           ack and mask an interrupt source
+ * @unmask:             unmask an interrupt source
+ * @eoi:                end of interrupt - chip level
+ * @end:                end of interrupt - flow level
+ * @set_affinity:       set the CPU affinity on SMP machines
+ * @retrigger:          resend an IRQ to the CPU
+ * @set_type:           set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
+ * @set_wake:           enable/disable power-management wake-on of an IRQ
+ *
+ * @release:            release function solely used by UML
+ * @typename:           obsoleted by name, kept as migration helper
 */
-struct hw_interrupt_type {
+struct irq_chip {
-        const char * typename;
+        const char      *name;
-        unsigned int (*startup)(unsigned int irq);
+        unsigned int    (*startup)(unsigned int irq);
-        void (*shutdown)(unsigned int irq);
+        void            (*shutdown)(unsigned int irq);
-        void (*enable)(unsigned int irq);
+        void            (*enable)(unsigned int irq);
-        void (*disable)(unsigned int irq);
+        void            (*disable)(unsigned int irq);
-        void (*ack)(unsigned int irq);
-        void (*end)(unsigned int irq);
+        void            (*ack)(unsigned int irq);
-        void (*set_affinity)(unsigned int irq, cpumask_t dest);
+        void            (*mask)(unsigned int irq);
+        void            (*mask_ack)(unsigned int irq);
+        void            (*unmask)(unsigned int irq);
+        void            (*eoi)(unsigned int irq);
+        void            (*end)(unsigned int irq);
+        void            (*set_affinity)(unsigned int irq, cpumask_t dest);
+        int             (*retrigger)(unsigned int irq);
+        int             (*set_type)(unsigned int irq, unsigned int flow_type);
+        int             (*set_wake)(unsigned int irq, unsigned int on);
        /* Currently used only by UML, might disappear one day.*/
 #ifdef CONFIG_IRQ_RELEASE_METHOD
-        void (*release)(unsigned int irq, void *dev_id);
+        void            (*release)(unsigned int irq, void *dev_id);
 #endif
+        /*
+         * For compatibility, ->typename is copied into ->name.
+         * Will disappear.
+         */
+        const char      *typename;
 };
-typedef struct hw_interrupt_type  hw_irq_controller;
+/**
+ * struct irq_desc - interrupt descriptor
-/*
+ *
- * This is the "IRQ descriptor", which contains various information
+ * @handle_irq:         highlevel irq-events handler [if NULL, __do_IRQ()]
- * about the irq, including what kind of hardware handling it has,
+ * @chip:               low level interrupt hardware access
- * whether it is disabled etc etc.
+ * @handler_data:       per-IRQ data for the irq_chip methods
+ * @chip_data:          platform-specific per-chip private data for the chip
+ *                      methods, to allow shared chip implementations
+ * @action:             the irq action chain
+ * @status:             status information
+ * @depth:              disable-depth, for nested irq_disable() calls
+ * @irq_count:          stats field to detect stalled irqs
+ * @irqs_unhandled:     stats field for spurious unhandled interrupts
+ * @lock:               locking for SMP
+ * @affinity:           IRQ affinity on SMP
+ * @cpu:                cpu index useful for balancing
+ * @pending_mask:       pending rebalanced interrupts
+ * @move_irq:           need to re-target IRQ destination
+ * @dir:                /proc/irq/ procfs entry
+ * @affinity_entry:     /proc/irq/smp_affinity procfs entry on SMP
 *
 * Pad this out to 32 bytes for cache and indexing reasons.
 */
-typedef struct irq_desc {
+struct irq_desc {
-        hw_irq_controller *handler;
+        void fastcall           (*handle_irq)(unsigned int irq,
-        void *handler_data;
+                                              struct irq_desc *desc,
-        struct irqaction *action;       /* IRQ action list */
+                                              struct pt_regs *regs);
-        unsigned int status;            /* IRQ status */
+        struct irq_chip         *chip;
-        unsigned int depth;             /* nested irq disables */
+        void                    *handler_data;
-        unsigned int irq_count;         /* For detecting broken interrupts */
+        void                    *chip_data;
-        unsigned int irqs_unhandled;
+        struct irqaction        *action;        /* IRQ action list */
-        spinlock_t lock;
+        unsigned int            status;         /* IRQ status */
-#if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE)
-        unsigned int move_irq;          /* Flag need to re-target intr dest*/
+        unsigned int            depth;          /* nested irq disables */
+        unsigned int            irq_count;      /* For detecting broken IRQs */
+        unsigned int            irqs_unhandled;
+        spinlock_t              lock;
+#ifdef CONFIG_SMP
+        cpumask_t               affinity;
+        unsigned int            cpu;
+#endif
+#if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE)
+        cpumask_t               pending_mask;
+        unsigned int            move_irq;       /* need to re-target IRQ dest */
+#endif
+#ifdef CONFIG_PROC_FS
+        struct proc_dir_entry *dir;
 #endif
-} ____cacheline_aligned irq_desc_t;
+} ____cacheline_aligned;
-extern irq_desc_t irq_desc [NR_IRQS];
+extern struct irq_desc irq_desc[NR_IRQS];
-/* Return a pointer to the irq descriptor for IRQ.  */
+/*
-static inline irq_desc_t *
+ * Migration helpers for obsolete names, they will go away:
-irq_descp (int irq)
+ */
-{
+#define hw_interrupt_type       irq_chip
-        return irq_desc + irq;
+typedef struct irq_chip         hw_irq_controller;
-}
+#define no_irq_type             no_irq_chip
+typedef struct irq_desc         irq_desc_t;
-#include <asm/hw_irq.h> /* the arch dependent stuff */
+/*
+ * Pick up the arch-dependent methods:
+ */
+#include <asm/hw_irq.h>
-extern int setup_irq(unsigned int irq, struct irqaction * new);
+extern int setup_irq(unsigned int irq, struct irqaction *new);
 #ifdef CONFIG_GENERIC_HARDIRQS
-extern cpumask_t irq_affinity[NR_IRQS];
 #ifdef CONFIG_SMP
 static inline void set_native_irq_info(int irq, cpumask_t mask)
 {
-        irq_affinity[irq] = mask;
+        irq_desc[irq].affinity = mask;
 }
 #else
 static inline void set_native_irq_info(int irq, cpumask_t mask)
@@ -111,8 +195,7 @@ static inline void set_native_irq_info(int irq, cpumask_t mask)
 #ifdef CONFIG_SMP
-#if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE)
+#if defined(CONFIG_GENERIC_PENDING_IRQ) || defined(CONFIG_IRQBALANCE)
-extern cpumask_t pending_irq_cpumask[NR_IRQS];
 void set_pending_irq(unsigned int irq, cpumask_t mask);
 void move_native_irq(int irq);
@@ -133,7 +216,7 @@ static inline void set_irq_info(int irq, cpumask_t mask)
 {
 }
-#else // CONFIG_PCI_MSI
+#else /* CONFIG_PCI_MSI */
 static inline void move_irq(int irq)
 {
@@ -144,26 +227,36 @@ static inline void set_irq_info(int irq, cpumask_t mask)
 {
        set_native_irq_info(irq, mask);
 }
-#endif // CONFIG_PCI_MSI
-#else   // CONFIG_GENERIC_PENDING_IRQ || CONFIG_IRQBALANCE
+#endif /* CONFIG_PCI_MSI */
+#else /* CONFIG_GENERIC_PENDING_IRQ || CONFIG_IRQBALANCE */
+static inline void move_irq(int irq)
+{
+}
+static inline void move_native_irq(int irq)
+{
+}
+static inline void set_pending_irq(unsigned int irq, cpumask_t mask)
+{
+}
-#define move_irq(x)
-#define move_native_irq(x)
-#define set_pending_irq(x,y)
 static inline void set_irq_info(int irq, cpumask_t mask)
 {
        set_native_irq_info(irq, mask);
 }
-#endif // CONFIG_GENERIC_PENDING_IRQ
+#endif /* CONFIG_GENERIC_PENDING_IRQ */
-#else // CONFIG_SMP
+#else /* CONFIG_SMP */
 #define move_irq(x)
 #define move_native_irq(x)
-#endif // CONFIG_SMP
+#endif /* CONFIG_SMP */
 #ifdef CONFIG_IRQBALANCE
 extern void set_balance_irq_affinity(unsigned int irq, cpumask_t mask);
@@ -173,32 +266,138 @@ static inline void set_balance_irq_affinity(unsigned int irq, cpumask_t mask)
 }
 #endif
+#ifdef CONFIG_AUTO_IRQ_AFFINITY
+extern int select_smp_affinity(unsigned int irq);
+#else
+static inline int select_smp_affinity(unsigned int irq)
+{
+        return 1;
+}
+#endif
 extern int no_irq_affinity;
-extern int noirqdebug_setup(char *str);
-extern fastcall irqreturn_t handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
+/* Handle irq action chains: */
-                                        struct irqaction *action);
+extern int handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
+                            struct irqaction *action);
+/*
+ * Built-in IRQ handlers for various IRQ types,
+ * callable via desc->chip->handle_irq()
+ */
+extern void fastcall
+handle_level_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs);
+extern void fastcall
+handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc,
+                         struct pt_regs *regs);
+extern void fastcall
+handle_edge_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs);
+extern void fastcall
+handle_simple_irq(unsigned int irq, struct irq_desc *desc,
+                  struct pt_regs *regs);
+extern void fastcall
+handle_percpu_irq(unsigned int irq, struct irq_desc *desc,
+                  struct pt_regs *regs);
+extern void fastcall
+handle_bad_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs);
+/*
+ * Get a descriptive string for the highlevel handler, for
+ * /proc/interrupts output:
+ */
+extern const char *
+handle_irq_name(void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                        struct pt_regs *));
+/*
+ * Monolithic do_IRQ implementation.
+ * (is an explicit fastcall, because i386 4KSTACKS calls it from assembly)
+ */
 extern fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs);
-extern void note_interrupt(unsigned int irq, irq_desc_t *desc,
-                                        int action_ret, struct pt_regs *regs);
-extern int can_request_irq(unsigned int irq, unsigned long irqflags);
+/*
+ * Architectures call this to let the generic IRQ layer
+ * handle an interrupt. If the descriptor is attached to an
+ * irqchip-style controller then we call the ->handle_irq() handler,
+ * and it calls __do_IRQ() if it's attached to an irqtype-style controller.
+ */
+static inline void generic_handle_irq(unsigned int irq, struct pt_regs *regs)
+{
+        struct irq_desc *desc = irq_desc + irq;
+        if (likely(desc->handle_irq))
+                desc->handle_irq(irq, desc, regs);
+        else
+                __do_IRQ(irq, regs);
+}
+/* Handling of unhandled and spurious interrupts: */
+extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
+                           int action_ret, struct pt_regs *regs);
+/* Resending of interrupts :*/
+void check_irq_resend(struct irq_desc *desc, unsigned int irq);
+/* Initialize /proc/irq/ */
 extern void init_irq_proc(void);
-#ifdef CONFIG_AUTO_IRQ_AFFINITY
+/* Enable/disable irq debugging output: */
-extern int select_smp_affinity(unsigned int irq);
+extern int noirqdebug_setup(char *str);
-#else
-static inline int
+/* Checks whether the interrupt can be requested by request_irq(): */
-select_smp_affinity(unsigned int irq)
+extern int can_request_irq(unsigned int irq, unsigned long irqflags);
+/* Dummy irq-chip implementation: */
+extern struct irq_chip no_irq_chip;
+extern void
+set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
+                         void fastcall (*handle)(unsigned int,
+                                                 struct irq_desc *,
+                                                 struct pt_regs *));
+extern void
+__set_irq_handler(unsigned int irq,
+                  void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                          struct pt_regs *),
+                  int is_chained);
+/*
+ * Set a highlevel flow handler for a given IRQ:
+ */
+static inline void
+set_irq_handler(unsigned int irq,
+                void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                        struct pt_regs *))
 {
-        return 1;
+        __set_irq_handler(irq, handle, 0);
 }
-#endif
-#endif
+/*
+ * Set a highlevel chained flow handler for a given IRQ.
+ * (a chained handler is automatically enabled and set to
+ *  IRQ_NOREQUEST and IRQ_NOPROBE)
+ */
+static inline void
+set_irq_chained_handler(unsigned int irq,
+                        void fastcall (*handle)(unsigned int, struct irq_desc *,
+                                                struct pt_regs *))
+{
+        __set_irq_handler(irq, handle, 1);
+}
-extern hw_irq_controller no_irq_type;  /* needed in every arch ? */
+/* Set/get chip/data for an IRQ: */
-#endif
+extern int set_irq_chip(unsigned int irq, struct irq_chip *chip);
+extern int set_irq_data(unsigned int irq, void *data);
+extern int set_irq_chip_data(unsigned int irq, void *data);
+extern int set_irq_type(unsigned int irq, unsigned int type);
+#define get_irq_chip(irq)       (irq_desc[irq].chip)
+#define get_irq_chip_data(irq)  (irq_desc[irq].chip_data)
+#define get_irq_data(irq)       (irq_desc[irq].handler_data)
+#endif /* CONFIG_GENERIC_HARDIRQS */
+#endif /* !CONFIG_S390 */
-#endif /* __irq_h */
+#endif /* _LINUX_IRQ_H */

diff --git a/include/linux/irq.h b/include/linux/irq.h index 676e00dfb21a..ae1e422f18e3 100644 --- a/include/linux/irq.h +++ b/include/linux/irq.h
@@ -1,5 +1,5 @@
1	#ifndef __irq_h	1	#ifndef _LINUX_IRQ_H
2	#define __irq_h	2	#define _LINUX_IRQ_H
3		3
4	/*	4	/*
5	* Please do not include this file in generic code. There is currently	5	* Please do not include this file in generic code. There is currently
@@ -11,7 +11,7 @@
11		11
12	#include <linux/smp.h>	12	#include <linux/smp.h>
13		13
14	#if !defined(CONFIG_S390)	14	#ifndef CONFIG_S390
15		15
16	#include <linux/linkage.h>	16	#include <linux/linkage.h>
17	#include <linux/cache.h>	17	#include <linux/cache.h>
@@ -24,84 +24,168 @@
24		24
25	/*	25	/*
26	* IRQ line status.	26	* IRQ line status.
		27	*
		28	* Bits 0-16 are reserved for the IRQF_* bits in linux/interrupt.h
		29	*
		30	* IRQ types
27	*/	31	*/
28	#define IRQ_INPROGRESS 1 /* IRQ handler active - do not enter! */	32	#define IRQ_TYPE_NONE 0x00000000 /* Default, unspecified type */
29	#define IRQ_DISABLED 2 /* IRQ disabled - do not enter! */	33	#define IRQ_TYPE_EDGE_RISING 0x00000001 /* Edge rising type */
30	#define IRQ_PENDING 4 /* IRQ pending - replay on enable */	34	#define IRQ_TYPE_EDGE_FALLING 0x00000002 /* Edge falling type */
31	#define IRQ_REPLAY 8 /* IRQ has been replayed but not acked yet */	35	#define IRQ_TYPE_EDGE_BOTH (IRQ_TYPE_EDGE_FALLING \| IRQ_TYPE_EDGE_RISING)
32	#define IRQ_AUTODETECT 16 /* IRQ is being autodetected */	36	#define IRQ_TYPE_LEVEL_HIGH 0x00000004 /* Level high type */
33	#define IRQ_WAITING 32 /* IRQ not yet seen - for autodetection */	37	#define IRQ_TYPE_LEVEL_LOW 0x00000008 /* Level low type */
34	#define IRQ_LEVEL 64 /* IRQ level triggered */	38	#define IRQ_TYPE_SENSE_MASK 0x0000000f /* Mask of the above */
35	#define IRQ_MASKED 128 /* IRQ masked - shouldn't be seen again */	39	#define IRQ_TYPE_PROBE 0x00000010 /* Probing in progress */
36	#if defined(ARCH_HAS_IRQ_PER_CPU)	40
37	# define IRQ_PER_CPU 256 /* IRQ is per CPU */	41	/* Internal flags */
		42	#define IRQ_INPROGRESS 0x00010000 /* IRQ handler active - do not enter! */
		43	#define IRQ_DISABLED 0x00020000 /* IRQ disabled - do not enter! */
		44	#define IRQ_PENDING 0x00040000 /* IRQ pending - replay on enable */
		45	#define IRQ_REPLAY 0x00080000 /* IRQ has been replayed but not acked yet */
		46	#define IRQ_AUTODETECT 0x00100000 /* IRQ is being autodetected */
		47	#define IRQ_WAITING 0x00200000 /* IRQ not yet seen - for autodetection */
		48	#define IRQ_LEVEL 0x00400000 /* IRQ level triggered */
		49	#define IRQ_MASKED 0x00800000 /* IRQ masked - shouldn't be seen again */
		50	#ifdef CONFIG_IRQ_PER_CPU
		51	# define IRQ_PER_CPU 0x01000000 /* IRQ is per CPU */
38	# define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)	52	# define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
39	#else	53	#else
40	# define CHECK_IRQ_PER_CPU(var) 0	54	# define CHECK_IRQ_PER_CPU(var) 0
41	#endif	55	#endif
42		56
43	/*	57	#define IRQ_NOPROBE 0x02000000 /* IRQ is not valid for probing */
44	* Interrupt controller descriptor. This is all we need	58	#define IRQ_NOREQUEST 0x04000000 /* IRQ cannot be requested */
45	* to describe about the low-level hardware.	59	#define IRQ_NOAUTOEN 0x08000000 /* IRQ will not be enabled on request irq */
		60	#define IRQ_DELAYED_DISABLE 0x10000000 /* IRQ disable (masking) happens delayed. */
		61
		62	struct proc_dir_entry;
		63
		64	/**
		65	* struct irq_chip - hardware interrupt chip descriptor
		66	*
		67	* @name: name for /proc/interrupts
		68	* @startup: start up the interrupt (defaults to ->enable if NULL)
		69	* @shutdown: shut down the interrupt (defaults to ->disable if NULL)
		70	* @enable: enable the interrupt (defaults to chip->unmask if NULL)
		71	* @disable: disable the interrupt (defaults to chip->mask if NULL)
		72	* @ack: start of a new interrupt
		73	* @mask: mask an interrupt source
		74	* @mask_ack: ack and mask an interrupt source
		75	* @unmask: unmask an interrupt source
		76	* @eoi: end of interrupt - chip level
		77	* @end: end of interrupt - flow level
		78	* @set_affinity: set the CPU affinity on SMP machines
		79	* @retrigger: resend an IRQ to the CPU
		80	* @set_type: set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
		81	* @set_wake: enable/disable power-management wake-on of an IRQ
		82	*
		83	* @release: release function solely used by UML
		84	* @typename: obsoleted by name, kept as migration helper
46	*/	85	*/
47	struct hw_interrupt_type {	86	struct irq_chip {
48	const char * typename;	87	const char *name;
49	unsigned int (*startup)(unsigned int irq);	88	unsigned int (*startup)(unsigned int irq);
50	void (*shutdown)(unsigned int irq);	89	void (*shutdown)(unsigned int irq);
51	void (*enable)(unsigned int irq);	90	void (*enable)(unsigned int irq);
52	void (*disable)(unsigned int irq);	91	void (*disable)(unsigned int irq);
53	void (*ack)(unsigned int irq);	92
54	void (*end)(unsigned int irq);	93	void (*ack)(unsigned int irq);
55	void (*set_affinity)(unsigned int irq, cpumask_t dest);	94	void (*mask)(unsigned int irq);
		95	void (*mask_ack)(unsigned int irq);
		96	void (*unmask)(unsigned int irq);
		97	void (*eoi)(unsigned int irq);
		98
		99	void (*end)(unsigned int irq);
		100	void (*set_affinity)(unsigned int irq, cpumask_t dest);
		101	int (*retrigger)(unsigned int irq);
		102	int (*set_type)(unsigned int irq, unsigned int flow_type);
		103	int (*set_wake)(unsigned int irq, unsigned int on);
		104
56	/* Currently used only by UML, might disappear one day.*/	105	/* Currently used only by UML, might disappear one day.*/
57	#ifdef CONFIG_IRQ_RELEASE_METHOD	106	#ifdef CONFIG_IRQ_RELEASE_METHOD
58	void (release)(unsigned int irq, void dev_id);	107	void (release)(unsigned int irq, void dev_id);
59	#endif	108	#endif
		109	/*
		110	* For compatibility, ->typename is copied into ->name.
		111	* Will disappear.
		112	*/
		113	const char *typename;
60	};	114	};
61		115
62	typedef struct hw_interrupt_type hw_irq_controller;	116	/**
63		117	* struct irq_desc - interrupt descriptor
64	/*	118	*
65	* This is the "IRQ descriptor", which contains various information	119	* @handle_irq: highlevel irq-events handler [if NULL, __do_IRQ()]
66	* about the irq, including what kind of hardware handling it has,	120	* @chip: low level interrupt hardware access
67	* whether it is disabled etc etc.	121	* @handler_data: per-IRQ data for the irq_chip methods
		122	* @chip_data: platform-specific per-chip private data for the chip
		123	* methods, to allow shared chip implementations
		124	* @action: the irq action chain
		125	* @status: status information
		126	* @depth: disable-depth, for nested irq_disable() calls
		127	* @irq_count: stats field to detect stalled irqs
		128	* @irqs_unhandled: stats field for spurious unhandled interrupts
		129	* @lock: locking for SMP
		130	* @affinity: IRQ affinity on SMP
		131	* @cpu: cpu index useful for balancing
		132	* @pending_mask: pending rebalanced interrupts
		133	* @move_irq: need to re-target IRQ destination
		134	* @dir: /proc/irq/ procfs entry
		135	* @affinity_entry: /proc/irq/smp_affinity procfs entry on SMP
68	*	136	*
69	* Pad this out to 32 bytes for cache and indexing reasons.	137	* Pad this out to 32 bytes for cache and indexing reasons.
70	*/	138	*/
71	typedef struct irq_desc {	139	struct irq_desc {
72	hw_irq_controller *handler;	140	void fastcall (*handle_irq)(unsigned int irq,
73	void *handler_data;	141	struct irq_desc *desc,
74	struct irqaction action; / IRQ action list */	142	struct pt_regs *regs);
75	unsigned int status; /* IRQ status */	143	struct irq_chip *chip;
76	unsigned int depth; /* nested irq disables */	144	void *handler_data;
77	unsigned int irq_count; /* For detecting broken interrupts */	145	void *chip_data;
78	unsigned int irqs_unhandled;	146	struct irqaction action; / IRQ action list */
79	spinlock_t lock;	147	unsigned int status; /* IRQ status */
80	#if defined (CONFIG_GENERIC_PENDING_IRQ) \|\| defined (CONFIG_IRQBALANCE)	148
81	unsigned int move_irq; /* Flag need to re-target intr dest*/	149	unsigned int depth; /* nested irq disables */
		150	unsigned int irq_count; /* For detecting broken IRQs */
		151	unsigned int irqs_unhandled;
		152	spinlock_t lock;
		153	#ifdef CONFIG_SMP
		154	cpumask_t affinity;
		155	unsigned int cpu;
		156	#endif
		157	#if defined(CONFIG_GENERIC_PENDING_IRQ) \|\| defined(CONFIG_IRQBALANCE)
		158	cpumask_t pending_mask;
		159	unsigned int move_irq; /* need to re-target IRQ dest */
		160	#endif
		161	#ifdef CONFIG_PROC_FS
		162	struct proc_dir_entry *dir;
82	#endif	163	#endif
83	} ____cacheline_aligned irq_desc_t;	164	} ____cacheline_aligned;
84		165
85	extern irq_desc_t irq_desc [NR_IRQS];	166	extern struct irq_desc irq_desc[NR_IRQS];
86		167
87	/* Return a pointer to the irq descriptor for IRQ. */	168	/*
88	static inline irq_desc_t *	169	* Migration helpers for obsolete names, they will go away:
89	irq_descp (int irq)	170	*/
90	{	171	#define hw_interrupt_type irq_chip
91	return irq_desc + irq;	172	typedef struct irq_chip hw_irq_controller;
92	}	173	#define no_irq_type no_irq_chip
		174	typedef struct irq_desc irq_desc_t;
93		175
94	#include <asm/hw_irq.h> /* the arch dependent stuff */	176	/*
		177	* Pick up the arch-dependent methods:
		178	*/
		179	#include <asm/hw_irq.h>
95		180
96	extern int setup_irq(unsigned int irq, struct irqaction * new);	181	extern int setup_irq(unsigned int irq, struct irqaction *new);
97		182
98	#ifdef CONFIG_GENERIC_HARDIRQS	183	#ifdef CONFIG_GENERIC_HARDIRQS
99	extern cpumask_t irq_affinity[NR_IRQS];
100		184
101	#ifdef CONFIG_SMP	185	#ifdef CONFIG_SMP
102	static inline void set_native_irq_info(int irq, cpumask_t mask)	186	static inline void set_native_irq_info(int irq, cpumask_t mask)
103	{	187	{
104	irq_affinity[irq] = mask;	188	irq_desc[irq].affinity = mask;
105	}	189	}
106	#else	190	#else
107	static inline void set_native_irq_info(int irq, cpumask_t mask)	191	static inline void set_native_irq_info(int irq, cpumask_t mask)
@@ -111,8 +195,7 @@ static inline void set_native_irq_info(int irq, cpumask_t mask)
111		195
112	#ifdef CONFIG_SMP	196	#ifdef CONFIG_SMP
113		197
114	#if defined (CONFIG_GENERIC_PENDING_IRQ) \|\| defined (CONFIG_IRQBALANCE)	198	#if defined(CONFIG_GENERIC_PENDING_IRQ) \|\| defined(CONFIG_IRQBALANCE)
115	extern cpumask_t pending_irq_cpumask[NR_IRQS];
116		199
117	void set_pending_irq(unsigned int irq, cpumask_t mask);	200	void set_pending_irq(unsigned int irq, cpumask_t mask);
118	void move_native_irq(int irq);	201	void move_native_irq(int irq);
@@ -133,7 +216,7 @@ static inline void set_irq_info(int irq, cpumask_t mask)
133	{	216	{
134	}	217	}
135		218
136	#else // CONFIG_PCI_MSI	219	#else /* CONFIG_PCI_MSI */
137		220
138	static inline void move_irq(int irq)	221	static inline void move_irq(int irq)
139	{	222	{
@@ -144,26 +227,36 @@ static inline void set_irq_info(int irq, cpumask_t mask)
144	{	227	{
145	set_native_irq_info(irq, mask);	228	set_native_irq_info(irq, mask);
146	}	229	}
147	#endif // CONFIG_PCI_MSI
148		230
149	#else // CONFIG_GENERIC_PENDING_IRQ \|\| CONFIG_IRQBALANCE	231	#endif /* CONFIG_PCI_MSI */
		232
		233	#else /* CONFIG_GENERIC_PENDING_IRQ \|\| CONFIG_IRQBALANCE */
		234
		235	static inline void move_irq(int irq)
		236	{
		237	}
		238
		239	static inline void move_native_irq(int irq)
		240	{
		241	}
		242
		243	static inline void set_pending_irq(unsigned int irq, cpumask_t mask)
		244	{
		245	}
150		246
151	#define move_irq(x)
152	#define move_native_irq(x)
153	#define set_pending_irq(x,y)
154	static inline void set_irq_info(int irq, cpumask_t mask)	247	static inline void set_irq_info(int irq, cpumask_t mask)
155	{	248	{
156	set_native_irq_info(irq, mask);	249	set_native_irq_info(irq, mask);
157	}	250	}
158		251
159	#endif // CONFIG_GENERIC_PENDING_IRQ	252	#endif /* CONFIG_GENERIC_PENDING_IRQ */
160		253
161	#else // CONFIG_SMP	254	#else /* CONFIG_SMP */
162		255
163	#define move_irq(x)	256	#define move_irq(x)
164	#define move_native_irq(x)	257	#define move_native_irq(x)
165		258
166	#endif // CONFIG_SMP	259	#endif /* CONFIG_SMP */
167		260
168	#ifdef CONFIG_IRQBALANCE	261	#ifdef CONFIG_IRQBALANCE
169	extern void set_balance_irq_affinity(unsigned int irq, cpumask_t mask);	262	extern void set_balance_irq_affinity(unsigned int irq, cpumask_t mask);
@@ -173,32 +266,138 @@ static inline void set_balance_irq_affinity(unsigned int irq, cpumask_t mask)
173	}	266	}
174	#endif	267	#endif
175		268
		269	#ifdef CONFIG_AUTO_IRQ_AFFINITY
		270	extern int select_smp_affinity(unsigned int irq);
		271	#else
		272	static inline int select_smp_affinity(unsigned int irq)
		273	{
		274	return 1;
		275	}
		276	#endif
		277
176	extern int no_irq_affinity;	278	extern int no_irq_affinity;
177	extern int noirqdebug_setup(char *str);
178		279
179	extern fastcall irqreturn_t handle_IRQ_event(unsigned int irq, struct pt_regs *regs,	280	/* Handle irq action chains: */
180	struct irqaction *action);	281	extern int handle_IRQ_event(unsigned int irq, struct pt_regs *regs,
		282	struct irqaction *action);
		283
		284	/*
		285	* Built-in IRQ handlers for various IRQ types,
		286	* callable via desc->chip->handle_irq()
		287	*/
		288	extern void fastcall
		289	handle_level_irq(unsigned int irq, struct irq_desc desc, struct pt_regs regs);
		290	extern void fastcall
		291	handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc,
		292	struct pt_regs *regs);
		293	extern void fastcall
		294	handle_edge_irq(unsigned int irq, struct irq_desc desc, struct pt_regs regs);
		295	extern void fastcall
		296	handle_simple_irq(unsigned int irq, struct irq_desc *desc,
		297	struct pt_regs *regs);
		298	extern void fastcall
		299	handle_percpu_irq(unsigned int irq, struct irq_desc *desc,
		300	struct pt_regs *regs);
		301	extern void fastcall
		302	handle_bad_irq(unsigned int irq, struct irq_desc desc, struct pt_regs regs);
		303
		304	/*
		305	* Get a descriptive string for the highlevel handler, for
		306	* /proc/interrupts output:
		307	*/
		308	extern const char *
		309	handle_irq_name(void fastcall (handle)(unsigned int, struct irq_desc ,
		310	struct pt_regs *));
		311
		312	/*
		313	* Monolithic do_IRQ implementation.
		314	* (is an explicit fastcall, because i386 4KSTACKS calls it from assembly)
		315	*/
181	extern fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs);	316	extern fastcall unsigned int __do_IRQ(unsigned int irq, struct pt_regs *regs);
182	extern void note_interrupt(unsigned int irq, irq_desc_t *desc,
183	int action_ret, struct pt_regs *regs);
184	extern int can_request_irq(unsigned int irq, unsigned long irqflags);
185		317
		318	/*
		319	* Architectures call this to let the generic IRQ layer
		320	* handle an interrupt. If the descriptor is attached to an
		321	* irqchip-style controller then we call the ->handle_irq() handler,
		322	* and it calls __do_IRQ() if it's attached to an irqtype-style controller.
		323	*/
		324	static inline void generic_handle_irq(unsigned int irq, struct pt_regs *regs)
		325	{
		326	struct irq_desc *desc = irq_desc + irq;
		327
		328	if (likely(desc->handle_irq))
		329	desc->handle_irq(irq, desc, regs);
		330	else
		331	__do_IRQ(irq, regs);
		332	}
		333
		334	/* Handling of unhandled and spurious interrupts: */
		335	extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
		336	int action_ret, struct pt_regs *regs);
		337
		338	/* Resending of interrupts :*/
		339	void check_irq_resend(struct irq_desc *desc, unsigned int irq);
		340
		341	/* Initialize /proc/irq/ */
186	extern void init_irq_proc(void);	342	extern void init_irq_proc(void);
187		343
188	#ifdef CONFIG_AUTO_IRQ_AFFINITY	344	/* Enable/disable irq debugging output: */
189	extern int select_smp_affinity(unsigned int irq);	345	extern int noirqdebug_setup(char *str);
190	#else	346
191	static inline int	347	/* Checks whether the interrupt can be requested by request_irq(): */
192	select_smp_affinity(unsigned int irq)	348	extern int can_request_irq(unsigned int irq, unsigned long irqflags);
		349
		350	/* Dummy irq-chip implementation: */
		351	extern struct irq_chip no_irq_chip;
		352
		353	extern void
		354	set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip,
		355	void fastcall (*handle)(unsigned int,
		356	struct irq_desc *,
		357	struct pt_regs *));
		358	extern void
		359	__set_irq_handler(unsigned int irq,
		360	void fastcall (handle)(unsigned int, struct irq_desc ,
		361	struct pt_regs *),
		362	int is_chained);
		363
		364	/*
		365	* Set a highlevel flow handler for a given IRQ:
		366	*/
		367	static inline void
		368	set_irq_handler(unsigned int irq,
		369	void fastcall (handle)(unsigned int, struct irq_desc ,
		370	struct pt_regs *))
193	{	371	{
194	return 1;	372	__set_irq_handler(irq, handle, 0);
195	}	373	}
196	#endif
197		374
198	#endif	375	/*
		376	* Set a highlevel chained flow handler for a given IRQ.
		377	* (a chained handler is automatically enabled and set to
		378	* IRQ_NOREQUEST and IRQ_NOPROBE)
		379	*/
		380	static inline void
		381	set_irq_chained_handler(unsigned int irq,
		382	void fastcall (handle)(unsigned int, struct irq_desc ,
		383	struct pt_regs *))
		384	{
		385	__set_irq_handler(irq, handle, 1);
		386	}
199		387
200	extern hw_irq_controller no_irq_type; /* needed in every arch ? */	388	/* Set/get chip/data for an IRQ: */
201		389
202	#endif	390	extern int set_irq_chip(unsigned int irq, struct irq_chip *chip);
		391	extern int set_irq_data(unsigned int irq, void *data);
		392	extern int set_irq_chip_data(unsigned int irq, void *data);
		393	extern int set_irq_type(unsigned int irq, unsigned int type);
		394
		395	#define get_irq_chip(irq) (irq_desc[irq].chip)
		396	#define get_irq_chip_data(irq) (irq_desc[irq].chip_data)
		397	#define get_irq_data(irq) (irq_desc[irq].handler_data)
		398
		399	#endif /* CONFIG_GENERIC_HARDIRQS */
		400
		401	#endif /* !CONFIG_S390 */
203		402
204	#endif /* __irq_h */	403	#endif /* _LINUX_IRQ_H */