11 files changed, 486 insertions, 302 deletions

diff --git a/include/linux/dmar.h b/include/linux/dmar.h
index d7cecc90ed34..51651b76d40f 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -106,6 +106,7 @@ struct irte {
                 __u64 high;
         };
 };
+
 #ifdef CONFIG_INTR_REMAP
 extern int intr_remapping_enabled;
 extern int intr_remapping_supported(void);
@@ -119,11 +120,8 @@ extern int alloc_irte(struct intel_iommu *iommu, int irq, u16 count);
 extern int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index,
                         u16 sub_handle);
 extern int map_irq_to_irte_handle(int irq, u16 *sub_handle);
-extern int clear_irte_irq(int irq, struct intel_iommu *iommu, u16 index);
-extern int flush_irte(int irq);
 extern int free_irte(int irq);
 
-extern int irq_remapped(int irq);
 extern struct intel_iommu *map_dev_to_ir(struct pci_dev *dev);
 extern struct intel_iommu *map_ioapic_to_ir(int apic);
 extern struct intel_iommu *map_hpet_to_ir(u8 id);
@@ -177,7 +175,6 @@ static inline int set_msi_sid(struct irte *irte, struct pci_dev *dev)
         return 0;
 }
 
-#define irq_remapped(irq)               (0)
 #define enable_intr_remapping(mode)     (-1)
 #define disable_intr_remapping()        (0)
 #define reenable_intr_remapping(mode)   (0)
@@ -187,8 +184,9 @@ static inline int set_msi_sid(struct irte *irte, struct pci_dev *dev)
 /* Can't use the common MSI interrupt functions
  * since DMAR is not a pci device
  */
-extern void dmar_msi_unmask(unsigned int irq);
-extern void dmar_msi_mask(unsigned int irq);
+struct irq_data;
+extern void dmar_msi_unmask(struct irq_data *data);
+extern void dmar_msi_mask(struct irq_data *data);
 extern void dmar_msi_read(int irq, struct msi_msg *msg);
 extern void dmar_msi_write(int irq, struct msi_msg *msg);
 extern int dmar_set_interrupt(struct intel_iommu *iommu);
diff --git a/include/linux/htirq.h b/include/linux/htirq.h
index c96ea46737d0..70a1dbbf2093 100644
--- a/include/linux/htirq.h
+++ b/include/linux/htirq.h
@@ -9,8 +9,9 @@ struct ht_irq_msg {
 /* Helper functions.. */
 void fetch_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg);
 void write_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg);
-void mask_ht_irq(unsigned int irq);
-void unmask_ht_irq(unsigned int irq);
+struct irq_data;
+void mask_ht_irq(struct irq_data *data);
+void unmask_ht_irq(struct irq_data *data);
 
 /* The arch hook for getting things started */
 int arch_setup_ht_irq(unsigned int irq, struct pci_dev *dev);
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index a0384a4d1e6f..19988983aeac 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -641,11 +641,8 @@ static inline void init_irq_proc(void)
 struct seq_file;
 int show_interrupts(struct seq_file *p, void *v);
 
-struct irq_desc;
-
 extern int early_irq_init(void);
 extern int arch_probe_nr_irqs(void);
 extern int arch_early_irq_init(void);
-extern int arch_init_chip_data(struct irq_desc *desc, int node);
 
 #endif
diff --git a/include/linux/irq.h b/include/linux/irq.h
index c03243ad84b4..e9639115dff1 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -72,6 +72,10 @@ typedef	void (*irq_flow_handler_t)(unsigned int irq,
 #define IRQ_ONESHOT             0x08000000      /* IRQ is not unmasked after hardirq */
 #define IRQ_NESTED_THREAD       0x10000000      /* IRQ is nested into another, no own handler thread */
 
+#define IRQF_MODIFY_MASK        \
+        (IRQ_TYPE_SENSE_MASK | IRQ_NOPROBE | IRQ_NOREQUEST | \
+         IRQ_NOAUTOEN | IRQ_MOVE_PCNTXT | IRQ_LEVEL)
+
 #ifdef CONFIG_IRQ_PER_CPU
 # define CHECK_IRQ_PER_CPU(var) ((var) & IRQ_PER_CPU)
 # define IRQ_NO_BALANCING_MASK  (IRQ_PER_CPU | IRQ_NO_BALANCING)
@@ -80,36 +84,77 @@ typedef	void (*irq_flow_handler_t)(unsigned int irq,
 # define IRQ_NO_BALANCING_MASK  IRQ_NO_BALANCING
 #endif
 
-struct proc_dir_entry;
 struct msi_desc;
 
 /**
+ * struct irq_data - per irq and irq chip data passed down to chip functions
+ * @irq:                interrupt number
+ * @node:               node index useful for balancing
+ * @chip:               low level interrupt hardware access
+ * @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
+ * @msi_desc:           MSI descriptor
+ * @affinity:           IRQ affinity on SMP
+ *
+ * The fields here need to overlay the ones in irq_desc until we
+ * cleaned up the direct references and switched everything over to
+ * irq_data.
+ */
+struct irq_data {
+        unsigned int            irq;
+        unsigned int            node;
+        struct irq_chip         *chip;
+        void                    *handler_data;
+        void                    *chip_data;
+        struct msi_desc         *msi_desc;
+#ifdef CONFIG_SMP
+        cpumask_var_t           affinity;
+#endif
+};
+
+/**
  * 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
- * @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
+ * @startup:            deprecated, replaced by irq_startup
+ * @shutdown:           deprecated, replaced by irq_shutdown
+ * @enable:             deprecated, replaced by irq_enable
+ * @disable:            deprecated, replaced by irq_disable
+ * @ack:                deprecated, replaced by irq_ack
+ * @mask:               deprecated, replaced by irq_mask
+ * @mask_ack:           deprecated, replaced by irq_mask_ack
+ * @unmask:             deprecated, replaced by irq_unmask
+ * @eoi:                deprecated, replaced by irq_eoi
+ * @end:                deprecated, will go away with __do_IRQ()
+ * @set_affinity:       deprecated, replaced by irq_set_affinity
+ * @retrigger:          deprecated, replaced by irq_retrigger
+ * @set_type:           deprecated, replaced by irq_set_type
+ * @set_wake:           deprecated, replaced by irq_wake
+ * @bus_lock:           deprecated, replaced by irq_bus_lock
+ * @bus_sync_unlock:    deprecated, replaced by irq_bus_sync_unlock
  *
- * @bus_lock:           function to lock access to slow bus (i2c) chips
- * @bus_sync_unlock:    function to sync and unlock slow bus (i2c) chips
+ * @irq_startup:        start up the interrupt (defaults to ->enable if NULL)
+ * @irq_shutdown:       shut down the interrupt (defaults to ->disable if NULL)
+ * @irq_enable:         enable the interrupt (defaults to chip->unmask if NULL)
+ * @irq_disable:        disable the interrupt
+ * @irq_ack:            start of a new interrupt
+ * @irq_mask:           mask an interrupt source
+ * @irq_mask_ack:       ack and mask an interrupt source
+ * @irq_unmask:         unmask an interrupt source
+ * @irq_eoi:            end of interrupt
+ * @irq_set_affinity:   set the CPU affinity on SMP machines
+ * @irq_retrigger:      resend an IRQ to the CPU
+ * @irq_set_type:       set the flow type (IRQ_TYPE_LEVEL/etc.) of an IRQ
+ * @irq_set_wake:       enable/disable power-management wake-on of an IRQ
+ * @irq_bus_lock:       function to lock access to slow bus (i2c) chips
+ * @irq_bus_sync_unlock:function to sync and unlock slow bus (i2c) chips
  *
  * @release:            release function solely used by UML
- * @typename:           obsoleted by name, kept as migration helper
  */
 struct irq_chip {
         const char      *name;
+#ifndef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
         unsigned int    (*startup)(unsigned int irq);
         void            (*shutdown)(unsigned int irq);
         void            (*enable)(unsigned int irq);
@@ -130,154 +175,66 @@ struct irq_chip {
 
         void            (*bus_lock)(unsigned int irq);
         void            (*bus_sync_unlock)(unsigned int irq);
+#endif
+        unsigned int    (*irq_startup)(struct irq_data *data);
+        void            (*irq_shutdown)(struct irq_data *data);
+        void            (*irq_enable)(struct irq_data *data);
+        void            (*irq_disable)(struct irq_data *data);
+
+        void            (*irq_ack)(struct irq_data *data);
+        void            (*irq_mask)(struct irq_data *data);
+        void            (*irq_mask_ack)(struct irq_data *data);
+        void            (*irq_unmask)(struct irq_data *data);
+        void            (*irq_eoi)(struct irq_data *data);
+
+        int             (*irq_set_affinity)(struct irq_data *data, const struct cpumask *dest, bool force);
+        int             (*irq_retrigger)(struct irq_data *data);
+        int             (*irq_set_type)(struct irq_data *data, unsigned int flow_type);
+        int             (*irq_set_wake)(struct irq_data *data, unsigned int on);
+
+        void            (*irq_bus_lock)(struct irq_data *data);
+        void            (*irq_bus_sync_unlock)(struct irq_data *data);
 
         /* Currently used only by UML, might disappear one day.*/
 #ifdef CONFIG_IRQ_RELEASE_METHOD
         void            (*release)(unsigned int irq, void *dev_id);
 #endif
-        /*
-         * For compatibility, ->typename is copied into ->name.
-         * Will disappear.
-         */
-        const char      *typename;
 };
 
-struct timer_rand_state;
-struct irq_2_iommu;
-/**
- * struct irq_desc - interrupt descriptor
- * @irq:                interrupt number for this descriptor
- * @timer_rand_state:   pointer to timer rand state struct
- * @kstat_irqs:         irq stats per cpu
- * @irq_2_iommu:        iommu with this irq
- * @handle_irq:         highlevel irq-events handler [if NULL, __do_IRQ()]
- * @chip:               low level interrupt hardware access
- * @msi_desc:           MSI descriptor
- * @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
- * @wake_depth:         enable depth, for multiple set_irq_wake() callers
- * @irq_count:          stats field to detect stalled irqs
- * @last_unhandled:     aging timer for unhandled count
- * @irqs_unhandled:     stats field for spurious unhandled interrupts
- * @lock:               locking for SMP
- * @affinity:           IRQ affinity on SMP
- * @node:               node index useful for balancing
- * @pending_mask:       pending rebalanced interrupts
- * @threads_active:     number of irqaction threads currently running
- * @wait_for_threads:   wait queue for sync_irq to wait for threaded handlers
- * @dir:                /proc/irq/ procfs entry
- * @name:               flow handler name for /proc/interrupts output
- */
-struct irq_desc {
-        unsigned int            irq;
-        struct timer_rand_state *timer_rand_state;
-        unsigned int            *kstat_irqs;
-#ifdef CONFIG_INTR_REMAP
-        struct irq_2_iommu      *irq_2_iommu;
-#endif
-        irq_flow_handler_t      handle_irq;
-        struct irq_chip         *chip;
-        struct msi_desc         *msi_desc;
-        void                    *handler_data;
-        void                    *chip_data;
-        struct irqaction        *action;        /* IRQ action list */
-        unsigned int            status;         /* IRQ status */
-
-        unsigned int            depth;          /* nested irq disables */
-        unsigned int            wake_depth;     /* nested wake enables */
-        unsigned int            irq_count;      /* For detecting broken IRQs */
-        unsigned long           last_unhandled; /* Aging timer for unhandled count */
-        unsigned int            irqs_unhandled;
-        raw_spinlock_t          lock;
-#ifdef CONFIG_SMP
-        cpumask_var_t           affinity;
-        const struct cpumask    *affinity_hint;
-        unsigned int            node;
-#ifdef CONFIG_GENERIC_PENDING_IRQ
-        cpumask_var_t           pending_mask;
-#endif
-#endif
-        atomic_t                threads_active;
-        wait_queue_head_t       wait_for_threads;
-#ifdef CONFIG_PROC_FS
-        struct proc_dir_entry   *dir;
-#endif
-        const char              *name;
-} ____cacheline_internodealigned_in_smp;
+/* This include will go away once we isolated irq_desc usage to core code */
+#include <linux/irqdesc.h>
 
-extern void arch_init_copy_chip_data(struct irq_desc *old_desc,
-                                        struct irq_desc *desc, int node);
-extern void arch_free_chip_data(struct irq_desc *old_desc, struct irq_desc *desc);
+/*
+ * Pick up the arch-dependent methods:
+ */
+#include <asm/hw_irq.h>
 
-#ifndef CONFIG_SPARSE_IRQ
-extern struct irq_desc irq_desc[NR_IRQS];
+#ifndef NR_IRQS_LEGACY
+# define NR_IRQS_LEGACY 0
 #endif
 
-#ifdef CONFIG_NUMA_IRQ_DESC
-extern struct irq_desc *move_irq_desc(struct irq_desc *old_desc, int node);
-#else
-static inline struct irq_desc *move_irq_desc(struct irq_desc *desc, int node)
-{
-        return desc;
-}
+#ifndef ARCH_IRQ_INIT_FLAGS
+# define ARCH_IRQ_INIT_FLAGS    0
 #endif
 
-extern struct irq_desc *irq_to_desc_alloc_node(unsigned int irq, int node);
-
-/*
- * Pick up the arch-dependent methods:
- */
-#include <asm/hw_irq.h>
+#define IRQ_DEFAULT_INIT_FLAGS  (IRQ_DISABLED | ARCH_IRQ_INIT_FLAGS)
 
+struct irqaction;
 extern int setup_irq(unsigned int irq, struct irqaction *new);
 extern void remove_irq(unsigned int irq, struct irqaction *act);
 
 #ifdef CONFIG_GENERIC_HARDIRQS
 
-#ifdef CONFIG_SMP
-
-#ifdef CONFIG_GENERIC_PENDING_IRQ
-
+#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ)
 void move_native_irq(int irq);
 void move_masked_irq(int irq);
-
-#else /* CONFIG_GENERIC_PENDING_IRQ */
-
-static inline void move_irq(int irq)
-{
-}
-
-static inline void move_native_irq(int irq)
-{
-}
-
-static inline void move_masked_irq(int irq)
-{
-}
-
-#endif /* CONFIG_GENERIC_PENDING_IRQ */
-
-#else /* CONFIG_SMP */
-
-#define move_native_irq(x)
-#define move_masked_irq(x)
-
-#endif /* CONFIG_SMP */
+#else
+static inline void move_native_irq(int irq) { }
+static inline void move_masked_irq(int irq) { }
+#endif
 
 extern int no_irq_affinity;
 
-static inline int irq_balancing_disabled(unsigned int irq)
-{
-        struct irq_desc *desc;
-
-        desc = irq_to_desc(irq);
-        return desc->status & IRQ_NO_BALANCING_MASK;
-}
-
 /* Handle irq action chains: */
 extern irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action);
 
@@ -293,42 +250,10 @@ extern void handle_percpu_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_bad_irq(unsigned int irq, struct irq_desc *desc);
 extern void handle_nested_irq(unsigned int irq);
 
-/*
- * Monolithic do_IRQ implementation.
- */
-#ifndef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
-extern unsigned int __do_IRQ(unsigned int irq);
-#endif
-
-/*
- * 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_desc(unsigned int irq, struct irq_desc *desc)
-{
-#ifdef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
-        desc->handle_irq(irq, desc);
-#else
-        if (likely(desc->handle_irq))
-                desc->handle_irq(irq, desc);
-        else
-                __do_IRQ(irq);
-#endif
-}
-
-static inline void generic_handle_irq(unsigned int irq)
-{
-        generic_handle_irq_desc(irq, irq_to_desc(irq));
-}
-
 /* Handling of unhandled and spurious interrupts: */
 extern void note_interrupt(unsigned int irq, struct irq_desc *desc,
                            irqreturn_t action_ret);
 
-/* Resending of interrupts :*/
-void check_irq_resend(struct irq_desc *desc, unsigned int irq);
 
 /* Enable/disable irq debugging output: */
 extern int noirqdebug_setup(char *str);
@@ -351,16 +276,6 @@ extern void
 __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                   const char *name);
 
-/* caller has locked the irq_desc and both params are valid */
-static inline void __set_irq_handler_unlocked(int irq,
-                                              irq_flow_handler_t handler)
-{
-        struct irq_desc *desc;
-
-        desc = irq_to_desc(irq);
-        desc->handle_irq = handler;
-}
-
 /*
  * Set a highlevel flow handler for a given IRQ:
  */
@@ -384,141 +299,121 @@ set_irq_chained_handler(unsigned int irq,
 
 extern void set_irq_nested_thread(unsigned int irq, int nest);
 
-extern void set_irq_noprobe(unsigned int irq);
-extern void set_irq_probe(unsigned int irq);
+void irq_modify_status(unsigned int irq, unsigned long clr, unsigned long set);
+
+static inline void irq_set_status_flags(unsigned int irq, unsigned long set)
+{
+        irq_modify_status(irq, 0, set);
+}
+
+static inline void irq_clear_status_flags(unsigned int irq, unsigned long clr)
+{
+        irq_modify_status(irq, clr, 0);
+}
+
+static inline void set_irq_noprobe(unsigned int irq)
+{
+        irq_modify_status(irq, 0, IRQ_NOPROBE);
+}
+
+static inline void set_irq_probe(unsigned int irq)
+{
+        irq_modify_status(irq, IRQ_NOPROBE, 0);
+}
 
 /* Handle dynamic irq creation and destruction */
 extern unsigned int create_irq_nr(unsigned int irq_want, int node);
 extern int create_irq(void);
 extern void destroy_irq(unsigned int irq);
 
-/* Test to see if a driver has successfully requested an irq */
-static inline int irq_has_action(unsigned int irq)
+/*
+ * Dynamic irq helper functions. Obsolete. Use irq_alloc_desc* and
+ * irq_free_desc instead.
+ */
+extern void dynamic_irq_cleanup(unsigned int irq);
+static inline void dynamic_irq_init(unsigned int irq)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
-        return desc->action != NULL;
+        dynamic_irq_cleanup(irq);
 }
 
-/* Dynamic irq helper functions */
-extern void dynamic_irq_init(unsigned int irq);
-void dynamic_irq_init_keep_chip_data(unsigned int irq);
-extern void dynamic_irq_cleanup(unsigned int irq);
-void dynamic_irq_cleanup_keep_chip_data(unsigned int irq);
-
 /* Set/get chip/data for an IRQ: */
 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);
 extern int set_irq_msi(unsigned int irq, struct msi_desc *entry);
+extern struct irq_data *irq_get_irq_data(unsigned int irq);
 
-#define get_irq_chip(irq)       (irq_to_desc(irq)->chip)
-#define get_irq_chip_data(irq)  (irq_to_desc(irq)->chip_data)
-#define get_irq_data(irq)       (irq_to_desc(irq)->handler_data)
-#define get_irq_msi(irq)        (irq_to_desc(irq)->msi_desc)
-
-#define get_irq_desc_chip(desc)         ((desc)->chip)
-#define get_irq_desc_chip_data(desc)    ((desc)->chip_data)
-#define get_irq_desc_data(desc)         ((desc)->handler_data)
-#define get_irq_desc_msi(desc)          ((desc)->msi_desc)
-
-#endif /* CONFIG_GENERIC_HARDIRQS */
-
-#endif /* !CONFIG_S390 */
-
-#ifdef CONFIG_SMP
-/**
- * alloc_desc_masks - allocate cpumasks for irq_desc
- * @desc:       pointer to irq_desc struct
- * @node:       node which will be handling the cpumasks
- * @boot:       true if need bootmem
- *
- * Allocates affinity and pending_mask cpumask if required.
- * Returns true if successful (or not required).
- */
-static inline bool alloc_desc_masks(struct irq_desc *desc, int node,
-                                                        bool boot)
+static inline struct irq_chip *get_irq_chip(unsigned int irq)
 {
-        gfp_t gfp = GFP_ATOMIC;
-
-        if (boot)
-                gfp = GFP_NOWAIT;
-
-#ifdef CONFIG_CPUMASK_OFFSTACK
-        if (!alloc_cpumask_var_node(&desc->affinity, gfp, node))
-                return false;
+        struct irq_data *d = irq_get_irq_data(irq);
+        return d ? d->chip : NULL;
+}
 
-#ifdef CONFIG_GENERIC_PENDING_IRQ
-        if (!alloc_cpumask_var_node(&desc->pending_mask, gfp, node)) {
-                free_cpumask_var(desc->affinity);
-                return false;
-        }
-#endif
-#endif
-        return true;
+static inline struct irq_chip *irq_data_get_irq_chip(struct irq_data *d)
+{
+        return d->chip;
 }
 
-static inline void init_desc_masks(struct irq_desc *desc)
+static inline void *get_irq_chip_data(unsigned int irq)
 {
-        cpumask_setall(desc->affinity);
-#ifdef CONFIG_GENERIC_PENDING_IRQ
-        cpumask_clear(desc->pending_mask);
-#endif
+        struct irq_data *d = irq_get_irq_data(irq);
+        return d ? d->chip_data : NULL;
 }
 
-/**
- * init_copy_desc_masks - copy cpumasks for irq_desc
- * @old_desc:   pointer to old irq_desc struct
- * @new_desc:   pointer to new irq_desc struct
- *
- * Insures affinity and pending_masks are copied to new irq_desc.
- * If !CONFIG_CPUMASKS_OFFSTACK the cpumasks are embedded in the
- * irq_desc struct so the copy is redundant.
- */
+static inline void *irq_data_get_irq_chip_data(struct irq_data *d)
+{
+        return d->chip_data;
+}
 
-static inline void init_copy_desc_masks(struct irq_desc *old_desc,
-                                        struct irq_desc *new_desc)
+static inline void *get_irq_data(unsigned int irq)
 {
-#ifdef CONFIG_CPUMASK_OFFSTACK
-        cpumask_copy(new_desc->affinity, old_desc->affinity);
+        struct irq_data *d = irq_get_irq_data(irq);
+        return d ? d->handler_data : NULL;
+}
 
-#ifdef CONFIG_GENERIC_PENDING_IRQ
-        cpumask_copy(new_desc->pending_mask, old_desc->pending_mask);
-#endif
-#endif
+static inline void *irq_data_get_irq_data(struct irq_data *d)
+{
+        return d->handler_data;
 }
 
-static inline void free_desc_masks(struct irq_desc *old_desc,
-                                   struct irq_desc *new_desc)
+static inline struct msi_desc *get_irq_msi(unsigned int irq)
 {
-        free_cpumask_var(old_desc->affinity);
+        struct irq_data *d = irq_get_irq_data(irq);
+        return d ? d->msi_desc : NULL;
+}
 
-#ifdef CONFIG_GENERIC_PENDING_IRQ
-        free_cpumask_var(old_desc->pending_mask);
-#endif
+static inline struct msi_desc *irq_data_get_msi(struct irq_data *d)
+{
+        return d->msi_desc;
 }
 
-#else /* !CONFIG_SMP */
+int irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node);
+void irq_free_descs(unsigned int irq, unsigned int cnt);
+int irq_reserve_irqs(unsigned int from, unsigned int cnt);
 
-static inline bool alloc_desc_masks(struct irq_desc *desc, int node,
-                                                                bool boot)
+static inline int irq_alloc_desc(int node)
 {
-        return true;
+        return irq_alloc_descs(-1, 0, 1, node);
 }
 
-static inline void init_desc_masks(struct irq_desc *desc)
+static inline int irq_alloc_desc_at(unsigned int at, int node)
 {
+        return irq_alloc_descs(at, at, 1, node);
 }
 
-static inline void init_copy_desc_masks(struct irq_desc *old_desc,
-                                        struct irq_desc *new_desc)
+static inline int irq_alloc_desc_from(unsigned int from, int node)
 {
+        return irq_alloc_descs(-1, from, 1, node);
 }
 
-static inline void free_desc_masks(struct irq_desc *old_desc,
-                                   struct irq_desc *new_desc)
+static inline void irq_free_desc(unsigned int irq)
 {
+        irq_free_descs(irq, 1);
 }
-#endif  /* CONFIG_SMP */
+
+#endif /* CONFIG_GENERIC_HARDIRQS */
+
+#endif /* !CONFIG_S390 */
 
 #endif /* _LINUX_IRQ_H */
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
new file mode 100644
index 000000000000..979c68cc7458
--- /dev/null
+++ b/include/linux/irqdesc.h
@@ -0,0 +1,159 @@
+#ifndef _LINUX_IRQDESC_H
+#define _LINUX_IRQDESC_H
+
+/*
+ * Core internal functions to deal with irq descriptors
+ *
+ * This include will move to kernel/irq once we cleaned up the tree.
+ * For now it's included from <linux/irq.h>
+ */
+
+struct proc_dir_entry;
+struct timer_rand_state;
+/**
+ * struct irq_desc - interrupt descriptor
+ * @irq_data:           per irq and chip data passed down to chip functions
+ * @timer_rand_state:   pointer to timer rand state struct
+ * @kstat_irqs:         irq stats per cpu
+ * @handle_irq:         highlevel irq-events handler [if NULL, __do_IRQ()]
+ * @action:             the irq action chain
+ * @status:             status information
+ * @depth:              disable-depth, for nested irq_disable() calls
+ * @wake_depth:         enable depth, for multiple set_irq_wake() callers
+ * @irq_count:          stats field to detect stalled irqs
+ * @last_unhandled:     aging timer for unhandled count
+ * @irqs_unhandled:     stats field for spurious unhandled interrupts
+ * @lock:               locking for SMP
+ * @pending_mask:       pending rebalanced interrupts
+ * @threads_active:     number of irqaction threads currently running
+ * @wait_for_threads:   wait queue for sync_irq to wait for threaded handlers
+ * @dir:                /proc/irq/ procfs entry
+ * @name:               flow handler name for /proc/interrupts output
+ */
+struct irq_desc {
+
+#ifdef CONFIG_GENERIC_HARDIRQS_NO_DEPRECATED
+        struct irq_data         irq_data;
+#else
+        /*
+         * This union will go away, once we fixed the direct access to
+         * irq_desc all over the place. The direct fields are a 1:1
+         * overlay of irq_data.
+         */
+        union {
+                struct irq_data         irq_data;
+                struct {
+                        unsigned int            irq;
+                        unsigned int            node;
+                        struct irq_chip         *chip;
+                        void                    *handler_data;
+                        void                    *chip_data;
+                        struct msi_desc         *msi_desc;
+#ifdef CONFIG_SMP
+                        cpumask_var_t           affinity;
+#endif
+                };
+        };
+#endif
+
+        struct timer_rand_state *timer_rand_state;
+        unsigned int            *kstat_irqs;
+        irq_flow_handler_t      handle_irq;
+        struct irqaction        *action;        /* IRQ action list */
+        unsigned int            status;         /* IRQ status */
+
+        unsigned int            depth;          /* nested irq disables */
+        unsigned int            wake_depth;     /* nested wake enables */
+        unsigned int            irq_count;      /* For detecting broken IRQs */
+        unsigned long           last_unhandled; /* Aging timer for unhandled count */
+        unsigned int            irqs_unhandled;
+        raw_spinlock_t          lock;
+#ifdef CONFIG_SMP
+        const struct cpumask    *affinity_hint;
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+        cpumask_var_t           pending_mask;
+#endif
+#endif
+        atomic_t                threads_active;
+        wait_queue_head_t       wait_for_threads;
+#ifdef CONFIG_PROC_FS
+        struct proc_dir_entry   *dir;
+#endif
+        const char              *name;
+} ____cacheline_internodealigned_in_smp;
+
+#ifndef CONFIG_SPARSE_IRQ
+extern struct irq_desc irq_desc[NR_IRQS];
+#endif
+
+/* Will be removed once the last users in power and sh are gone */
+extern struct irq_desc *irq_to_desc_alloc_node(unsigned int irq, int node);
+static inline struct irq_desc *move_irq_desc(struct irq_desc *desc, int node)
+{
+        return desc;
+}
+
+#ifdef CONFIG_GENERIC_HARDIRQS
+
+#define get_irq_desc_chip(desc)         ((desc)->irq_data.chip)
+#define get_irq_desc_chip_data(desc)    ((desc)->irq_data.chip_data)
+#define get_irq_desc_data(desc)         ((desc)->irq_data.handler_data)
+#define get_irq_desc_msi(desc)          ((desc)->irq_data.msi_desc)
+
+/*
+ * Monolithic do_IRQ implementation.
+ */
+#ifndef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
+extern unsigned int __do_IRQ(unsigned int irq);
+#endif
+
+/*
+ * 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_desc(unsigned int irq, struct irq_desc *desc)
+{
+#ifdef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
+        desc->handle_irq(irq, desc);
+#else
+        if (likely(desc->handle_irq))
+                desc->handle_irq(irq, desc);
+        else
+                __do_IRQ(irq);
+#endif
+}
+
+static inline void generic_handle_irq(unsigned int irq)
+{
+        generic_handle_irq_desc(irq, irq_to_desc(irq));
+}
+
+/* Test to see if a driver has successfully requested an irq */
+static inline int irq_has_action(unsigned int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        return desc->action != NULL;
+}
+
+static inline int irq_balancing_disabled(unsigned int irq)
+{
+        struct irq_desc *desc;
+
+        desc = irq_to_desc(irq);
+        return desc->status & IRQ_NO_BALANCING_MASK;
+}
+
+/* caller has locked the irq_desc and both params are valid */
+static inline void __set_irq_handler_unlocked(int irq,
+                                              irq_flow_handler_t handler)
+{
+        struct irq_desc *desc;
+
+        desc = irq_to_desc(irq);
+        desc->handle_irq = handler;
+}
+#endif
+
+#endif
diff --git a/include/linux/irqnr.h b/include/linux/irqnr.h
index 7bf89bc8cbca..05aa8c23483f 100644
--- a/include/linux/irqnr.h
+++ b/include/linux/irqnr.h
@@ -25,6 +25,7 @@
 
 extern int nr_irqs;
 extern struct irq_desc *irq_to_desc(unsigned int irq);
+unsigned int irq_get_next_irq(unsigned int offset);
 
 # define for_each_irq_desc(irq, desc)                                   \
         for (irq = 0, desc = irq_to_desc(irq); irq < nr_irqs;           \
@@ -47,6 +48,10 @@ extern struct irq_desc *irq_to_desc(unsigned int irq);
 #define irq_node(irq)   0
 #endif
 
+# define for_each_active_irq(irq)                       \
+        for (irq = irq_get_next_irq(0); irq < nr_irqs;  \
+             irq = irq_get_next_irq(irq + 1))
+
 #endif /* CONFIG_GENERIC_HARDIRQS */
 
 #define for_each_irq_nr(irq)                   \
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 06aed8305bf3..17d050ce7ab8 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -424,14 +424,6 @@ do {								\
 
 #endif /* CONFIG_LOCKDEP */
 
-#ifdef CONFIG_GENERIC_HARDIRQS
-extern void early_init_irq_lock_class(void);
-#else
-static inline void early_init_irq_lock_class(void)
-{
-}
-#endif
-
 #ifdef CONFIG_TRACE_IRQFLAGS
 extern void early_boot_irqs_off(void);
 extern void early_boot_irqs_on(void);
diff --git a/include/linux/msi.h b/include/linux/msi.h
index 91b05c171854..05acced439a3 100644
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -10,12 +10,13 @@ struct msi_msg {
 };
 
 /* Helper functions */
-struct irq_desc;
-extern void mask_msi_irq(unsigned int irq);
-extern void unmask_msi_irq(unsigned int irq);
-extern void read_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg);
-extern void get_cached_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg);
-extern void write_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg);
+struct irq_data;
+struct msi_desc;
+extern void mask_msi_irq(struct irq_data *data);
+extern void unmask_msi_irq(struct irq_data *data);
+extern void __read_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
+extern void __get_cached_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
+extern void __write_msi_msg(struct msi_desc *entry, struct msi_msg *msg);
 extern void read_msi_msg(unsigned int irq, struct msi_msg *msg);
 extern void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg);
 extern void write_msi_msg(unsigned int irq, struct msi_msg *msg);
diff --git a/include/xen/events.h b/include/xen/events.h
index a15d93262e30..c1717ca5ac13 100644
--- a/include/xen/events.h
+++ b/include/xen/events.h
@@ -53,6 +53,10 @@ bool xen_test_irq_pending(int irq);
    irq will be disabled so it won't deliver an interrupt. */
 void xen_poll_irq(int irq);
 
+/* Poll waiting for an irq to become pending with a timeout.  In the usual case,
+ * the irq will be disabled so it won't deliver an interrupt. */
+void xen_poll_irq_timeout(int irq, u64 timeout);
+
 /* Determine the IRQ which is bound to an event channel */
 unsigned irq_from_evtchn(unsigned int evtchn);
 
@@ -63,4 +67,18 @@ int xen_set_callback_via(uint64_t via);
 void xen_evtchn_do_upcall(struct pt_regs *regs);
 void xen_hvm_evtchn_do_upcall(void);
 
+/* Allocate an irq for a physical interrupt, given a gsi.  "Legacy"
+ * GSIs are identity mapped; others are dynamically allocated as
+ * usual. */
+int xen_allocate_pirq(unsigned gsi, int shareable, char *name);
+
+/* De-allocates the above mentioned physical interrupt. */
+int xen_destroy_irq(int irq);
+
+/* Return vector allocated to pirq */
+int xen_vector_from_irq(unsigned pirq);
+
+/* Return gsi allocated to pirq */
+int xen_gsi_from_irq(unsigned pirq);
+
 #endif  /* _XEN_EVENTS_H */
diff --git a/include/xen/interface/io/pciif.h b/include/xen/interface/io/pciif.h
new file mode 100644
index 000000000000..d9922ae36eb5
--- /dev/null
+++ b/include/xen/interface/io/pciif.h
@@ -0,0 +1,112 @@
+/*
+ * PCI Backend/Frontend Common Data Structures & Macros
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ *   Author: Ryan Wilson <hap9@epoch.ncsc.mil>
+ */
+#ifndef __XEN_PCI_COMMON_H__
+#define __XEN_PCI_COMMON_H__
+
+/* Be sure to bump this number if you change this file */
+#define XEN_PCI_MAGIC "7"
+
+/* xen_pci_sharedinfo flags */
+#define _XEN_PCIF_active                (0)
+#define XEN_PCIF_active                 (1<<_XEN_PCIF_active)
+#define _XEN_PCIB_AERHANDLER            (1)
+#define XEN_PCIB_AERHANDLER             (1<<_XEN_PCIB_AERHANDLER)
+#define _XEN_PCIB_active                (2)
+#define XEN_PCIB_active                 (1<<_XEN_PCIB_active)
+
+/* xen_pci_op commands */
+#define XEN_PCI_OP_conf_read            (0)
+#define XEN_PCI_OP_conf_write           (1)
+#define XEN_PCI_OP_enable_msi           (2)
+#define XEN_PCI_OP_disable_msi          (3)
+#define XEN_PCI_OP_enable_msix          (4)
+#define XEN_PCI_OP_disable_msix         (5)
+#define XEN_PCI_OP_aer_detected         (6)
+#define XEN_PCI_OP_aer_resume           (7)
+#define XEN_PCI_OP_aer_mmio             (8)
+#define XEN_PCI_OP_aer_slotreset        (9)
+
+/* xen_pci_op error numbers */
+#define XEN_PCI_ERR_success             (0)
+#define XEN_PCI_ERR_dev_not_found       (-1)
+#define XEN_PCI_ERR_invalid_offset      (-2)
+#define XEN_PCI_ERR_access_denied       (-3)
+#define XEN_PCI_ERR_not_implemented     (-4)
+/* XEN_PCI_ERR_op_failed - backend failed to complete the operation */
+#define XEN_PCI_ERR_op_failed           (-5)
+
+/*
+ * it should be PAGE_SIZE-sizeof(struct xen_pci_op))/sizeof(struct msix_entry))
+ * Should not exceed 128
+ */
+#define SH_INFO_MAX_VEC                 128
+
+struct xen_msix_entry {
+        uint16_t vector;
+        uint16_t entry;
+};
+struct xen_pci_op {
+        /* IN: what action to perform: XEN_PCI_OP_* */
+        uint32_t cmd;
+
+        /* OUT: will contain an error number (if any) from errno.h */
+        int32_t err;
+
+        /* IN: which device to touch */
+        uint32_t domain; /* PCI Domain/Segment */
+        uint32_t bus;
+        uint32_t devfn;
+
+        /* IN: which configuration registers to touch */
+        int32_t offset;
+        int32_t size;
+
+        /* IN/OUT: Contains the result after a READ or the value to WRITE */
+        uint32_t value;
+        /* IN: Contains extra infor for this operation */
+        uint32_t info;
+        /*IN:  param for msi-x */
+        struct xen_msix_entry msix_entries[SH_INFO_MAX_VEC];
+};
+
+/*used for pcie aer handling*/
+struct xen_pcie_aer_op {
+        /* IN: what action to perform: XEN_PCI_OP_* */
+        uint32_t cmd;
+        /*IN/OUT: return aer_op result or carry error_detected state as input*/
+        int32_t err;
+
+        /* IN: which device to touch */
+        uint32_t domain; /* PCI Domain/Segment*/
+        uint32_t bus;
+        uint32_t devfn;
+};
+struct xen_pci_sharedinfo {
+        /* flags - XEN_PCIF_* */
+        uint32_t flags;
+        struct xen_pci_op op;
+        struct xen_pcie_aer_op aer_op;
+};
+
+#endif /* __XEN_PCI_COMMON_H__ */
diff --git a/include/xen/interface/io/xenbus.h b/include/xen/interface/io/xenbus.h
index 46508c7fa399..9fda532973a5 100644
--- a/include/xen/interface/io/xenbus.h
+++ b/include/xen/interface/io/xenbus.h
@@ -27,8 +27,14 @@ enum xenbus_state
         XenbusStateClosing      = 5,  /* The device is being closed
                                          due to an error or an unplug
                                          event. */
-        XenbusStateClosed       = 6
+        XenbusStateClosed       = 6,
 
+        /*
+        * Reconfiguring: The device is being reconfigured.
+        */
+        XenbusStateReconfiguring = 7,
+
+        XenbusStateReconfigured  = 8
 };
 
 #endif /* _XEN_PUBLIC_IO_XENBUS_H */