Merge branch 'stable/xen-pcifront-0.8.2' of git://git.kernel.org/pub/scm/linux/kernel/git/konrad/xen

  and branch 'for-linus' of git://xenbits.xen.org/people/sstabellini/linux-pvhvm

* 'for-linus' of git://xenbits.xen.org/people/sstabellini/linux-pvhvm:
  xen: register xen pci notifier
  xen: initialize cpu masks for pv guests in xen_smp_init
  xen: add a missing #include to arch/x86/pci/xen.c
  xen: mask the MTRR feature from the cpuid
  xen: make hvc_xen console work for dom0.
  xen: add the direct mapping area for ISA bus access
  xen: Initialize xenbus for dom0.
  xen: use vcpu_ops to setup cpu masks
  xen: map a dummy page for local apic and ioapic in xen_set_fixmap
  xen: remap MSIs into pirqs when running as initial domain
  xen: remap GSIs as pirqs when running as initial domain
  xen: introduce XEN_DOM0 as a silent option
  xen: map MSIs into pirqs
  xen: support GSI -> pirq remapping in PV on HVM guests
  xen: add xen hvm acpi_register_gsi variant
  acpi: use indirect call to register gsi in different modes
  xen: implement xen_hvm_register_pirq
  xen: get the maximum number of pirqs from xen
  xen: support pirq != irq

* 'stable/xen-pcifront-0.8.2' of git://git.kernel.org/pub/scm/linux/kernel/git/konrad/xen: (27 commits)
  X86/PCI: Remove the dependency on isapnp_disable.
  xen: Update Makefile with CONFIG_BLOCK dependency for biomerge.c
  MAINTAINERS: Add myself to the Xen Hypervisor Interface and remove Chris Wright.
  x86: xen: Sanitse irq handling (part two)
  swiotlb-xen: On x86-32 builts, select SWIOTLB instead of depending on it.
  MAINTAINERS: Add myself for Xen PCI and Xen SWIOTLB maintainer.
  xen/pci: Request ACS when Xen-SWIOTLB is activated.
  xen-pcifront: Xen PCI frontend driver.
  xenbus: prevent warnings on unhandled enumeration values
  xenbus: Xen paravirtualised PCI hotplug support.
  xen/x86/PCI: Add support for the Xen PCI subsystem
  x86: Introduce x86_msi_ops
  msi: Introduce default_[teardown|setup]_msi_irqs with fallback.
  x86/PCI: Export pci_walk_bus function.
  x86/PCI: make sure _PAGE_IOMAP it set on pci mappings
  x86/PCI: Clean up pci_cache_line_size
  xen: fix shared irq device passthrough
  xen: Provide a variant of xen_poll_irq with timeout.
  xen: Find an unbound irq number in reverse order (high to low).
  xen: statically initialize cpu_evtchn_mask_p
  ...

Fix up trivial conflicts in drivers/pci/Makefile

7 files changed, 652 insertions, 23 deletions

diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
index 60d71e9abe9f..6e6180ccd726 100644
--- a/drivers/xen/Kconfig
+++ b/drivers/xen/Kconfig
@@ -74,6 +74,7 @@ config XEN_PLATFORM_PCI
 
 config SWIOTLB_XEN
         def_bool y
-        depends on SWIOTLB
+        depends on PCI
+        select SWIOTLB
 
 endmenu
diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
index fcaf838f54be..eb8a78d77d9d 100644
--- a/drivers/xen/Makefile
+++ b/drivers/xen/Makefile
@@ -4,6 +4,7 @@ obj-y	+= xenbus/
 nostackp := $(call cc-option, -fno-stack-protector)
 CFLAGS_features.o                       := $(nostackp)
 
+obj-$(CONFIG_BLOCK)             += biomerge.o
 obj-$(CONFIG_HOTPLUG_CPU)       += cpu_hotplug.o
 obj-$(CONFIG_XEN_XENCOMM)       += xencomm.o
 obj-$(CONFIG_XEN_BALLOON)       += balloon.o
@@ -12,3 +13,4 @@ obj-$(CONFIG_XENFS)		+= xenfs/
 obj-$(CONFIG_XEN_SYS_HYPERVISOR)        += sys-hypervisor.o
 obj-$(CONFIG_XEN_PLATFORM_PCI)  += platform-pci.o
 obj-$(CONFIG_SWIOTLB_XEN)       += swiotlb-xen.o
+obj-$(CONFIG_XEN_DOM0)          += pci.o
diff --git a/drivers/xen/biomerge.c b/drivers/xen/biomerge.c
new file mode 100644
index 000000000000..ba6eda4b5143
--- /dev/null
+++ b/drivers/xen/biomerge.c
@@ -0,0 +1,13 @@
+#include <linux/bio.h>
+#include <linux/io.h>
+#include <xen/page.h>
+
+bool xen_biovec_phys_mergeable(const struct bio_vec *vec1,
+                               const struct bio_vec *vec2)
+{
+        unsigned long mfn1 = pfn_to_mfn(page_to_pfn(vec1->bv_page));
+        unsigned long mfn2 = pfn_to_mfn(page_to_pfn(vec2->bv_page));
+
+        return __BIOVEC_PHYS_MERGEABLE(vec1, vec2) &&
+                ((mfn1 == mfn2) || ((mfn1+1) == mfn2));
+}
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 347f17edad77..97612f548a8e 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -16,7 +16,7 @@
  *    (typically dom0).
  * 2. VIRQs, typically used for timers.  These are per-cpu events.
  * 3. IPIs.
- * 4. Hardware interrupts. Not supported at present.
+ * 4. PIRQs - Hardware interrupts.
  *
  * Jeremy Fitzhardinge <jeremy@xensource.com>, XenSource Inc, 2007
  */
@@ -28,12 +28,16 @@
 #include <linux/string.h>
 #include <linux/bootmem.h>
 #include <linux/slab.h>
+#include <linux/irqnr.h>
+#include <linux/pci.h>
 
 #include <asm/desc.h>
 #include <asm/ptrace.h>
 #include <asm/irq.h>
 #include <asm/idle.h>
+#include <asm/io_apic.h>
 #include <asm/sync_bitops.h>
+#include <asm/xen/pci.h>
 #include <asm/xen/hypercall.h>
 #include <asm/xen/hypervisor.h>
 
@@ -73,7 +77,8 @@ enum xen_irq_type {
  * event channel - irq->event channel mapping
  * cpu - cpu this event channel is bound to
  * index - type-specific information:
- *    PIRQ - vector, with MSB being "needs EIO"
+ *    PIRQ - vector, with MSB being "needs EIO", or physical IRQ of the HVM
+ *           guest, or GSI (real passthrough IRQ) of the device.
  *    VIRQ - virq number
  *    IPI - IPI vector
  *    EVTCHN -
@@ -88,21 +93,30 @@ struct irq_info
                 unsigned short virq;
                 enum ipi_vector ipi;
                 struct {
+                        unsigned short pirq;
                         unsigned short gsi;
-                        unsigned short vector;
+                        unsigned char vector;
+                        unsigned char flags;
                 } pirq;
         } u;
 };
+#define PIRQ_NEEDS_EOI  (1 << 0)
+#define PIRQ_SHAREABLE  (1 << 1)
 
-static struct irq_info irq_info[NR_IRQS];
+static struct irq_info *irq_info;
+static int *pirq_to_irq;
+static int nr_pirqs;
 
-static int evtchn_to_irq[NR_EVENT_CHANNELS] = {
-        [0 ... NR_EVENT_CHANNELS-1] = -1
-};
+static int *evtchn_to_irq;
 struct cpu_evtchn_s {
         unsigned long bits[NR_EVENT_CHANNELS/BITS_PER_LONG];
 };
-static struct cpu_evtchn_s *cpu_evtchn_mask_p;
+
+static __initdata struct cpu_evtchn_s init_evtchn_mask = {
+        .bits[0 ... (NR_EVENT_CHANNELS/BITS_PER_LONG)-1] = ~0ul,
+};
+static struct cpu_evtchn_s *cpu_evtchn_mask_p = &init_evtchn_mask;
+
 static inline unsigned long *cpu_evtchn_mask(int cpu)
 {
         return cpu_evtchn_mask_p[cpu].bits;
@@ -113,6 +127,7 @@ static inline unsigned long *cpu_evtchn_mask(int cpu)
 
 static struct irq_chip xen_dynamic_chip;
 static struct irq_chip xen_percpu_chip;
+static struct irq_chip xen_pirq_chip;
 
 /* Constructor for packed IRQ information. */
 static struct irq_info mk_unbound_info(void)
@@ -138,11 +153,12 @@ static struct irq_info mk_virq_info(unsigned short evtchn, unsigned short virq)
                         .cpu = 0, .u.virq = virq };
 }
 
-static struct irq_info mk_pirq_info(unsigned short evtchn,
+static struct irq_info mk_pirq_info(unsigned short evtchn, unsigned short pirq,
                                     unsigned short gsi, unsigned short vector)
 {
         return (struct irq_info) { .type = IRQT_PIRQ, .evtchn = evtchn,
-                        .cpu = 0, .u.pirq = { .gsi = gsi, .vector = vector } };
+                        .cpu = 0,
+                        .u.pirq = { .pirq = pirq, .gsi = gsi, .vector = vector } };
 }
 
 /*
@@ -184,6 +200,16 @@ static unsigned virq_from_irq(unsigned irq)
         return info->u.virq;
 }
 
+static unsigned pirq_from_irq(unsigned irq)
+{
+        struct irq_info *info = info_for_irq(irq);
+
+        BUG_ON(info == NULL);
+        BUG_ON(info->type != IRQT_PIRQ);
+
+        return info->u.pirq.pirq;
+}
+
 static unsigned gsi_from_irq(unsigned irq)
 {
         struct irq_info *info = info_for_irq(irq);
@@ -225,6 +251,15 @@ static unsigned int cpu_from_evtchn(unsigned int evtchn)
         return ret;
 }
 
+static bool pirq_needs_eoi(unsigned irq)
+{
+        struct irq_info *info = info_for_irq(irq);
+
+        BUG_ON(info->type != IRQT_PIRQ);
+
+        return info->u.pirq.flags & PIRQ_NEEDS_EOI;
+}
+
 static inline unsigned long active_evtchns(unsigned int cpu,
                                            struct shared_info *sh,
                                            unsigned int idx)
@@ -336,12 +371,40 @@ static void unmask_evtchn(int port)
         put_cpu();
 }
 
+static int get_nr_hw_irqs(void)
+{
+        int ret = 1;
+
+#ifdef CONFIG_X86_IO_APIC
+        ret = get_nr_irqs_gsi();
+#endif
+
+        return ret;
+}
+
+/* callers of this function should make sure that PHYSDEVOP_get_nr_pirqs
+ * succeeded otherwise nr_pirqs won't hold the right value */
+static int find_unbound_pirq(void)
+{
+        int i;
+        for (i = nr_pirqs-1; i >= 0; i--) {
+                if (pirq_to_irq[i] < 0)
+                        return i;
+        }
+        return -1;
+}
+
 static int find_unbound_irq(void)
 {
         struct irq_data *data;
         int irq, res;
+        int start = get_nr_hw_irqs();
 
-        for (irq = 0; irq < nr_irqs; irq++) {
+        if (start == nr_irqs)
+                goto no_irqs;
+
+        /* nr_irqs is a magic value. Must not use it.*/
+        for (irq = nr_irqs-1; irq > start; irq--) {
                 data = irq_get_irq_data(irq);
                 /* only 0->15 have init'd desc; handle irq > 16 */
                 if (!data)
@@ -354,8 +417,8 @@ static int find_unbound_irq(void)
                         return irq;
         }
 
-        if (irq == nr_irqs)
-                panic("No available IRQ to bind to: increase nr_irqs!\n");
+        if (irq == start)
+                goto no_irqs;
 
         res = irq_alloc_desc_at(irq, 0);
 
@@ -363,6 +426,357 @@ static int find_unbound_irq(void)
                 return -1;
 
         return irq;
+
+no_irqs:
+        panic("No available IRQ to bind to: increase nr_irqs!\n");
+}
+
+static bool identity_mapped_irq(unsigned irq)
+{
+        /* identity map all the hardware irqs */
+        return irq < get_nr_hw_irqs();
+}
+
+static void pirq_unmask_notify(int irq)
+{
+        struct physdev_eoi eoi = { .irq = pirq_from_irq(irq) };
+
+        if (unlikely(pirq_needs_eoi(irq))) {
+                int rc = HYPERVISOR_physdev_op(PHYSDEVOP_eoi, &eoi);
+                WARN_ON(rc);
+        }
+}
+
+static void pirq_query_unmask(int irq)
+{
+        struct physdev_irq_status_query irq_status;
+        struct irq_info *info = info_for_irq(irq);
+
+        BUG_ON(info->type != IRQT_PIRQ);
+
+        irq_status.irq = pirq_from_irq(irq);
+        if (HYPERVISOR_physdev_op(PHYSDEVOP_irq_status_query, &irq_status))
+                irq_status.flags = 0;
+
+        info->u.pirq.flags &= ~PIRQ_NEEDS_EOI;
+        if (irq_status.flags & XENIRQSTAT_needs_eoi)
+                info->u.pirq.flags |= PIRQ_NEEDS_EOI;
+}
+
+static bool probing_irq(int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+
+        return desc && desc->action == NULL;
+}
+
+static unsigned int startup_pirq(unsigned int irq)
+{
+        struct evtchn_bind_pirq bind_pirq;
+        struct irq_info *info = info_for_irq(irq);
+        int evtchn = evtchn_from_irq(irq);
+        int rc;
+
+        BUG_ON(info->type != IRQT_PIRQ);
+
+        if (VALID_EVTCHN(evtchn))
+                goto out;
+
+        bind_pirq.pirq = pirq_from_irq(irq);
+        /* NB. We are happy to share unless we are probing. */
+        bind_pirq.flags = info->u.pirq.flags & PIRQ_SHAREABLE ?
+                                        BIND_PIRQ__WILL_SHARE : 0;
+        rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_pirq, &bind_pirq);
+        if (rc != 0) {
+                if (!probing_irq(irq))
+                        printk(KERN_INFO "Failed to obtain physical IRQ %d\n",
+                               irq);
+                return 0;
+        }
+        evtchn = bind_pirq.port;
+
+        pirq_query_unmask(irq);
+
+        evtchn_to_irq[evtchn] = irq;
+        bind_evtchn_to_cpu(evtchn, 0);
+        info->evtchn = evtchn;
+
+out:
+        unmask_evtchn(evtchn);
+        pirq_unmask_notify(irq);
+
+        return 0;
+}
+
+static void shutdown_pirq(unsigned int irq)
+{
+        struct evtchn_close close;
+        struct irq_info *info = info_for_irq(irq);
+        int evtchn = evtchn_from_irq(irq);
+
+        BUG_ON(info->type != IRQT_PIRQ);
+
+        if (!VALID_EVTCHN(evtchn))
+                return;
+
+        mask_evtchn(evtchn);
+
+        close.port = evtchn;
+        if (HYPERVISOR_event_channel_op(EVTCHNOP_close, &close) != 0)
+                BUG();
+
+        bind_evtchn_to_cpu(evtchn, 0);
+        evtchn_to_irq[evtchn] = -1;
+        info->evtchn = 0;
+}
+
+static void enable_pirq(unsigned int irq)
+{
+        startup_pirq(irq);
+}
+
+static void disable_pirq(unsigned int irq)
+{
+}
+
+static void ack_pirq(unsigned int irq)
+{
+        int evtchn = evtchn_from_irq(irq);
+
+        move_native_irq(irq);
+
+        if (VALID_EVTCHN(evtchn)) {
+                mask_evtchn(evtchn);
+                clear_evtchn(evtchn);
+        }
+}
+
+static void end_pirq(unsigned int irq)
+{
+        int evtchn = evtchn_from_irq(irq);
+        struct irq_desc *desc = irq_to_desc(irq);
+
+        if (WARN_ON(!desc))
+                return;
+
+        if ((desc->status & (IRQ_DISABLED|IRQ_PENDING)) ==
+            (IRQ_DISABLED|IRQ_PENDING)) {
+                shutdown_pirq(irq);
+        } else if (VALID_EVTCHN(evtchn)) {
+                unmask_evtchn(evtchn);
+                pirq_unmask_notify(irq);
+        }
+}
+
+static int find_irq_by_gsi(unsigned gsi)
+{
+        int irq;
+
+        for (irq = 0; irq < nr_irqs; irq++) {
+                struct irq_info *info = info_for_irq(irq);
+
+                if (info == NULL || info->type != IRQT_PIRQ)
+                        continue;
+
+                if (gsi_from_irq(irq) == gsi)
+                        return irq;
+        }
+
+        return -1;
+}
+
+int xen_allocate_pirq(unsigned gsi, int shareable, char *name)
+{
+        return xen_map_pirq_gsi(gsi, gsi, shareable, name);
+}
+
+/* xen_map_pirq_gsi might allocate irqs from the top down, as a
+ * consequence don't assume that the irq number returned has a low value
+ * or can be used as a pirq number unless you know otherwise.
+ *
+ * One notable exception is when xen_map_pirq_gsi is called passing an
+ * hardware gsi as argument, in that case the irq number returned
+ * matches the gsi number passed as second argument.
+ *
+ * Note: We don't assign an event channel until the irq actually started
+ * up.  Return an existing irq if we've already got one for the gsi.
+ */
+int xen_map_pirq_gsi(unsigned pirq, unsigned gsi, int shareable, char *name)
+{
+        int irq = 0;
+        struct physdev_irq irq_op;
+
+        spin_lock(&irq_mapping_update_lock);
+
+        if ((pirq > nr_pirqs) || (gsi > nr_irqs)) {
+                printk(KERN_WARNING "xen_map_pirq_gsi: %s %s is incorrect!\n",
+                        pirq > nr_pirqs ? "nr_pirqs" :"",
+                        gsi > nr_irqs ? "nr_irqs" : "");
+                goto out;
+        }
+
+        irq = find_irq_by_gsi(gsi);
+        if (irq != -1) {
+                printk(KERN_INFO "xen_map_pirq_gsi: returning irq %d for gsi %u\n",
+                       irq, gsi);
+                goto out;       /* XXX need refcount? */
+        }
+
+        /* If we are a PV guest, we don't have GSIs (no ACPI passed). Therefore
+         * we are using the !xen_initial_domain() to drop in the function.*/
+        if (identity_mapped_irq(gsi) || (!xen_initial_domain() &&
+                                xen_pv_domain())) {
+                irq = gsi;
+                irq_alloc_desc_at(irq, 0);
+        } else
+                irq = find_unbound_irq();
+
+        set_irq_chip_and_handler_name(irq, &xen_pirq_chip,
+                                      handle_level_irq, name);
+
+        irq_op.irq = irq;
+        irq_op.vector = 0;
+
+        /* Only the privileged domain can do this. For non-priv, the pcifront
+         * driver provides a PCI bus that does the call to do exactly
+         * this in the priv domain. */
+        if (xen_initial_domain() &&
+            HYPERVISOR_physdev_op(PHYSDEVOP_alloc_irq_vector, &irq_op)) {
+                irq_free_desc(irq);
+                irq = -ENOSPC;
+                goto out;
+        }
+
+        irq_info[irq] = mk_pirq_info(0, pirq, gsi, irq_op.vector);
+        irq_info[irq].u.pirq.flags |= shareable ? PIRQ_SHAREABLE : 0;
+        pirq_to_irq[pirq] = irq;
+
+out:
+        spin_unlock(&irq_mapping_update_lock);
+
+        return irq;
+}
+
+#ifdef CONFIG_PCI_MSI
+#include <linux/msi.h>
+#include "../pci/msi.h"
+
+void xen_allocate_pirq_msi(char *name, int *irq, int *pirq)
+{
+        spin_lock(&irq_mapping_update_lock);
+
+        *irq = find_unbound_irq();
+        if (*irq == -1)
+                goto out;
+
+        *pirq = find_unbound_pirq();
+        if (*pirq == -1)
+                goto out;
+
+        set_irq_chip_and_handler_name(*irq, &xen_pirq_chip,
+                                      handle_level_irq, name);
+
+        irq_info[*irq] = mk_pirq_info(0, *pirq, 0, 0);
+        pirq_to_irq[*pirq] = *irq;
+
+out:
+        spin_unlock(&irq_mapping_update_lock);
+}
+
+int xen_create_msi_irq(struct pci_dev *dev, struct msi_desc *msidesc, int type)
+{
+        int irq = -1;
+        struct physdev_map_pirq map_irq;
+        int rc;
+        int pos;
+        u32 table_offset, bir;
+
+        memset(&map_irq, 0, sizeof(map_irq));
+        map_irq.domid = DOMID_SELF;
+        map_irq.type = MAP_PIRQ_TYPE_MSI;
+        map_irq.index = -1;
+        map_irq.pirq = -1;
+        map_irq.bus = dev->bus->number;
+        map_irq.devfn = dev->devfn;
+
+        if (type == PCI_CAP_ID_MSIX) {
+                pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
+
+                pci_read_config_dword(dev, msix_table_offset_reg(pos),
+                                        &table_offset);
+                bir = (u8)(table_offset & PCI_MSIX_FLAGS_BIRMASK);
+
+                map_irq.table_base = pci_resource_start(dev, bir);
+                map_irq.entry_nr = msidesc->msi_attrib.entry_nr;
+        }
+
+        spin_lock(&irq_mapping_update_lock);
+
+        irq = find_unbound_irq();
+
+        if (irq == -1)
+                goto out;
+
+        rc = HYPERVISOR_physdev_op(PHYSDEVOP_map_pirq, &map_irq);
+        if (rc) {
+                printk(KERN_WARNING "xen map irq failed %d\n", rc);
+
+                irq_free_desc(irq);
+
+                irq = -1;
+                goto out;
+        }
+        irq_info[irq] = mk_pirq_info(0, map_irq.pirq, 0, map_irq.index);
+
+        set_irq_chip_and_handler_name(irq, &xen_pirq_chip,
+                        handle_level_irq,
+                        (type == PCI_CAP_ID_MSIX) ? "msi-x":"msi");
+
+out:
+        spin_unlock(&irq_mapping_update_lock);
+        return irq;
+}
+#endif
+
+int xen_destroy_irq(int irq)
+{
+        struct irq_desc *desc;
+        struct physdev_unmap_pirq unmap_irq;
+        struct irq_info *info = info_for_irq(irq);
+        int rc = -ENOENT;
+
+        spin_lock(&irq_mapping_update_lock);
+
+        desc = irq_to_desc(irq);
+        if (!desc)
+                goto out;
+
+        if (xen_initial_domain()) {
+                unmap_irq.pirq = info->u.pirq.gsi;
+                unmap_irq.domid = DOMID_SELF;
+                rc = HYPERVISOR_physdev_op(PHYSDEVOP_unmap_pirq, &unmap_irq);
+                if (rc) {
+                        printk(KERN_WARNING "unmap irq failed %d\n", rc);
+                        goto out;
+                }
+        }
+        irq_info[irq] = mk_unbound_info();
+
+        irq_free_desc(irq);
+
+out:
+        spin_unlock(&irq_mapping_update_lock);
+        return rc;
+}
+
+int xen_vector_from_irq(unsigned irq)
+{
+        return vector_from_irq(irq);
+}
+
+int xen_gsi_from_irq(unsigned irq)
+{
+        return gsi_from_irq(irq);
 }
 
 int bind_evtchn_to_irq(unsigned int evtchn)
@@ -425,7 +839,7 @@ static int bind_ipi_to_irq(unsigned int ipi, unsigned int cpu)
 }
 
 
-static int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
+int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
 {
         struct evtchn_bind_virq bind_virq;
         int evtchn, irq;
@@ -928,7 +1342,7 @@ void xen_clear_irq_pending(int irq)
         if (VALID_EVTCHN(evtchn))
                 clear_evtchn(evtchn);
 }
-
+EXPORT_SYMBOL(xen_clear_irq_pending);
 void xen_set_irq_pending(int irq)
 {
         int evtchn = evtchn_from_irq(irq);
@@ -948,9 +1362,9 @@ bool xen_test_irq_pending(int irq)
         return ret;
 }
 
-/* Poll waiting for an irq to become pending.  In the usual case, the
-   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 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)
 {
         evtchn_port_t evtchn = evtchn_from_irq(irq);
 
@@ -958,13 +1372,20 @@ void xen_poll_irq(int irq)
                 struct sched_poll poll;
 
                 poll.nr_ports = 1;
-                poll.timeout = 0;
+                poll.timeout = timeout;
                 set_xen_guest_handle(poll.ports, &evtchn);
 
                 if (HYPERVISOR_sched_op(SCHEDOP_poll, &poll) != 0)
                         BUG();
         }
 }
+EXPORT_SYMBOL(xen_poll_irq_timeout);
+/* Poll waiting for an irq to become pending.  In the usual case, the
+ * irq will be disabled so it won't deliver an interrupt. */
+void xen_poll_irq(int irq)
+{
+        xen_poll_irq_timeout(irq, 0 /* no timeout */);
+}
 
 void xen_irq_resume(void)
 {
@@ -1001,6 +1422,26 @@ static struct irq_chip xen_dynamic_chip __read_mostly = {
         .retrigger      = retrigger_dynirq,
 };
 
+static struct irq_chip xen_pirq_chip __read_mostly = {
+        .name           = "xen-pirq",
+
+        .startup        = startup_pirq,
+        .shutdown       = shutdown_pirq,
+
+        .enable         = enable_pirq,
+        .unmask         = enable_pirq,
+
+        .disable        = disable_pirq,
+        .mask           = disable_pirq,
+
+        .ack            = ack_pirq,
+        .end            = end_pirq,
+
+        .set_affinity   = set_affinity_irq,
+
+        .retrigger      = retrigger_dynirq,
+};
+
 static struct irq_chip xen_percpu_chip __read_mostly = {
         .name           = "xen-percpu",
 
@@ -1051,11 +1492,32 @@ void xen_callback_vector(void) {}
 
 void __init xen_init_IRQ(void)
 {
-        int i;
+        int i, rc;
+        struct physdev_nr_pirqs op_nr_pirqs;
 
         cpu_evtchn_mask_p = kcalloc(nr_cpu_ids, sizeof(struct cpu_evtchn_s),
                                     GFP_KERNEL);
-        BUG_ON(cpu_evtchn_mask_p == NULL);
+        irq_info = kcalloc(nr_irqs, sizeof(*irq_info), GFP_KERNEL);
+
+        rc = HYPERVISOR_physdev_op(PHYSDEVOP_get_nr_pirqs, &op_nr_pirqs);
+        if (rc < 0) {
+                nr_pirqs = nr_irqs;
+                if (rc != -ENOSYS)
+                        printk(KERN_WARNING "PHYSDEVOP_get_nr_pirqs returned rc=%d\n", rc);
+        } else {
+                if (xen_pv_domain() && !xen_initial_domain())
+                        nr_pirqs = max((int)op_nr_pirqs.nr_pirqs, nr_irqs);
+                else
+                        nr_pirqs = op_nr_pirqs.nr_pirqs;
+        }
+        pirq_to_irq = kcalloc(nr_pirqs, sizeof(*pirq_to_irq), GFP_KERNEL);
+        for (i = 0; i < nr_pirqs; i++)
+                pirq_to_irq[i] = -1;
+
+        evtchn_to_irq = kcalloc(NR_EVENT_CHANNELS, sizeof(*evtchn_to_irq),
+                                    GFP_KERNEL);
+        for (i = 0; i < NR_EVENT_CHANNELS; i++)
+                evtchn_to_irq[i] = -1;
 
         init_evtchn_cpu_bindings();
 
@@ -1066,7 +1528,12 @@ void __init xen_init_IRQ(void)
         if (xen_hvm_domain()) {
                 xen_callback_vector();
                 native_init_IRQ();
+                /* pci_xen_hvm_init must be called after native_init_IRQ so that
+                 * __acpi_register_gsi can point at the right function */
+                pci_xen_hvm_init();
         } else {
                 irq_ctx_init(smp_processor_id());
+                if (xen_initial_domain())
+                        xen_setup_pirqs();
         }
 }
diff --git a/drivers/xen/pci.c b/drivers/xen/pci.c
new file mode 100644
index 000000000000..cef4bafc07dc
--- /dev/null
+++ b/drivers/xen/pci.c
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2009, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * Author: Weidong Han <weidong.han@intel.com>
+ */
+
+#include <linux/pci.h>
+#include <xen/xen.h>
+#include <xen/interface/physdev.h>
+#include <xen/interface/xen.h>
+
+#include <asm/xen/hypervisor.h>
+#include <asm/xen/hypercall.h>
+#include "../pci/pci.h"
+
+static int xen_add_device(struct device *dev)
+{
+        int r;
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+
+#ifdef CONFIG_PCI_IOV
+        if (pci_dev->is_virtfn) {
+                struct physdev_manage_pci_ext manage_pci_ext = {
+                        .bus            = pci_dev->bus->number,
+                        .devfn          = pci_dev->devfn,
+                        .is_virtfn      = 1,
+                        .physfn.bus     = pci_dev->physfn->bus->number,
+                        .physfn.devfn   = pci_dev->physfn->devfn,
+                };
+
+                r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_add_ext,
+                        &manage_pci_ext);
+        } else
+#endif
+        if (pci_ari_enabled(pci_dev->bus) && PCI_SLOT(pci_dev->devfn)) {
+                struct physdev_manage_pci_ext manage_pci_ext = {
+                        .bus            = pci_dev->bus->number,
+                        .devfn          = pci_dev->devfn,
+                        .is_extfn       = 1,
+                };
+
+                r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_add_ext,
+                        &manage_pci_ext);
+        } else {
+                struct physdev_manage_pci manage_pci = {
+                        .bus    = pci_dev->bus->number,
+                        .devfn  = pci_dev->devfn,
+                };
+
+                r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_add,
+                        &manage_pci);
+        }
+
+        return r;
+}
+
+static int xen_remove_device(struct device *dev)
+{
+        int r;
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+        struct physdev_manage_pci manage_pci;
+
+        manage_pci.bus = pci_dev->bus->number;
+        manage_pci.devfn = pci_dev->devfn;
+
+        r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_remove,
+                &manage_pci);
+
+        return r;
+}
+
+static int xen_pci_notifier(struct notifier_block *nb,
+                            unsigned long action, void *data)
+{
+        struct device *dev = data;
+        int r = 0;
+
+        switch (action) {
+        case BUS_NOTIFY_ADD_DEVICE:
+                r = xen_add_device(dev);
+                break;
+        case BUS_NOTIFY_DEL_DEVICE:
+                r = xen_remove_device(dev);
+                break;
+        default:
+                break;
+        }
+
+        return r;
+}
+
+struct notifier_block device_nb = {
+        .notifier_call = xen_pci_notifier,
+};
+
+static int __init register_xen_pci_notifier(void)
+{
+        if (!xen_initial_domain())
+                return 0;
+
+        return bus_register_notifier(&pci_bus_type, &device_nb);
+}
+
+arch_initcall(register_xen_pci_notifier);
diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c
index 7e49527189b6..cdacf923e073 100644
--- a/drivers/xen/xenbus/xenbus_client.c
+++ b/drivers/xen/xenbus/xenbus_client.c
@@ -50,6 +50,8 @@ const char *xenbus_strstate(enum xenbus_state state)
                 [ XenbusStateConnected    ] = "Connected",
                 [ XenbusStateClosing      ] = "Closing",
                 [ XenbusStateClosed       ] = "Closed",
+                [XenbusStateReconfiguring] = "Reconfiguring",
+                [XenbusStateReconfigured] = "Reconfigured",
         };
         return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
 }
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index 132939f36020..deb9c4ba3a93 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -803,6 +803,7 @@ device_initcall(xenbus_probe_initcall);
 static int __init xenbus_init(void)
 {
         int err = 0;
+        unsigned long page = 0;
 
         DPRINTK("");
 
@@ -823,7 +824,31 @@ static int __init xenbus_init(void)
          * Domain0 doesn't have a store_evtchn or store_mfn yet.
          */
         if (xen_initial_domain()) {
-                /* dom0 not yet supported */
+                struct evtchn_alloc_unbound alloc_unbound;
+
+                /* Allocate Xenstore page */
+                page = get_zeroed_page(GFP_KERNEL);
+                if (!page)
+                        goto out_error;
+
+                xen_store_mfn = xen_start_info->store_mfn =
+                        pfn_to_mfn(virt_to_phys((void *)page) >>
+                                   PAGE_SHIFT);
+
+                /* Next allocate a local port which xenstored can bind to */
+                alloc_unbound.dom        = DOMID_SELF;
+                alloc_unbound.remote_dom = 0;
+
+                err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
+                                                  &alloc_unbound);
+                if (err == -ENOSYS)
+                        goto out_error;
+
+                BUG_ON(err);
+                xen_store_evtchn = xen_start_info->store_evtchn =
+                        alloc_unbound.port;
+
+                xen_store_interface = mfn_to_virt(xen_store_mfn);
         } else {
                 if (xen_hvm_domain()) {
                         uint64_t v = 0;
@@ -869,6 +894,8 @@ static int __init xenbus_init(void)
         bus_unregister(&xenbus_frontend.bus);
 
   out_error:
+        if (page != 0)
+                free_page(page);
         return err;
 }