16 files changed, 349 insertions, 87 deletions

diff --git a/arch/x86/include/asm/xen/swiotlb-xen.h b/arch/x86/include/asm/xen/swiotlb-xen.h
index 1be1ab7d6a41..ee52fcac6f72 100644
--- a/arch/x86/include/asm/xen/swiotlb-xen.h
+++ b/arch/x86/include/asm/xen/swiotlb-xen.h
@@ -5,10 +5,12 @@
 extern int xen_swiotlb;
 extern int __init pci_xen_swiotlb_detect(void);
 extern void __init pci_xen_swiotlb_init(void);
+extern int pci_xen_swiotlb_init_late(void);
 #else
 #define xen_swiotlb (0)
 static inline int __init pci_xen_swiotlb_detect(void) { return 0; }
 static inline void __init pci_xen_swiotlb_init(void) { }
+static inline int pci_xen_swiotlb_init_late(void) { return -ENXIO; }
 #endif
 
 #endif /* _ASM_X86_SWIOTLB_XEN_H */
diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index 689a4c9da866..70f140447a28 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -1441,11 +1441,19 @@ asmlinkage void __init xen_start_kernel(void)
                 const struct dom0_vga_console_info *info =
                         (void *)((char *)xen_start_info +
                                  xen_start_info->console.dom0.info_off);
+                struct xen_platform_op op = {
+                        .cmd = XENPF_firmware_info,
+                        .interface_version = XENPF_INTERFACE_VERSION,
+                        .u.firmware_info.type = XEN_FW_KBD_SHIFT_FLAGS,
+                };
 
                 xen_init_vga(info, xen_start_info->console.dom0.info_size);
                 xen_start_info->console.domU.mfn = 0;
                 xen_start_info->console.domU.evtchn = 0;
 
+                if (HYPERVISOR_dom0_op(&op) == 0)
+                        boot_params.kbd_status = op.u.firmware_info.u.kbd_shift_flags;
+
                 xen_init_apic();
 
                 /* Make sure ACS will be enabled */
diff --git a/arch/x86/xen/pci-swiotlb-xen.c b/arch/x86/xen/pci-swiotlb-xen.c
index 1ab45941502d..969570491c39 100644
--- a/arch/x86/xen/pci-swiotlb-xen.c
+++ b/arch/x86/xen/pci-swiotlb-xen.c
@@ -8,7 +8,14 @@
 #include <xen/xen.h>
 #include <asm/iommu_table.h>
 
+
 #include <asm/xen/swiotlb-xen.h>
+#ifdef CONFIG_X86_64
+#include <asm/iommu.h>
+#include <asm/dma.h>
+#endif
+#include <linux/export.h>
+
 int xen_swiotlb __read_mostly;
 
 static struct dma_map_ops xen_swiotlb_dma_ops = {
@@ -35,33 +42,63 @@ static struct dma_map_ops xen_swiotlb_dma_ops = {
 int __init pci_xen_swiotlb_detect(void)
 {
 
+        if (!xen_pv_domain())
+                return 0;
+
         /* If running as PV guest, either iommu=soft, or swiotlb=force will
          * activate this IOMMU. If running as PV privileged, activate it
          * irregardless.
          */
-        if ((xen_initial_domain() || swiotlb || swiotlb_force) &&
-            (xen_pv_domain()))
+        if ((xen_initial_domain() || swiotlb || swiotlb_force))
                 xen_swiotlb = 1;
 
         /* If we are running under Xen, we MUST disable the native SWIOTLB.
          * Don't worry about swiotlb_force flag activating the native, as
          * the 'swiotlb' flag is the only one turning it on. */
-        if (xen_pv_domain())
-                swiotlb = 0;
+        swiotlb = 0;
 
+#ifdef CONFIG_X86_64
+        /* pci_swiotlb_detect_4gb turns on native SWIOTLB if no_iommu == 0
+         * (so no iommu=X command line over-writes).
+         * Considering that PV guests do not want the *native SWIOTLB* but
+         * only Xen SWIOTLB it is not useful to us so set no_iommu=1 here.
+         */
+        if (max_pfn > MAX_DMA32_PFN)
+                no_iommu = 1;
+#endif
         return xen_swiotlb;
 }
 
 void __init pci_xen_swiotlb_init(void)
 {
         if (xen_swiotlb) {
-                xen_swiotlb_init(1);
+                xen_swiotlb_init(1, true /* early */);
                 dma_ops = &xen_swiotlb_dma_ops;
 
                 /* Make sure ACS will be enabled */
                 pci_request_acs();
         }
 }
+
+int pci_xen_swiotlb_init_late(void)
+{
+        int rc;
+
+        if (xen_swiotlb)
+                return 0;
+
+        rc = xen_swiotlb_init(1, false /* late */);
+        if (rc)
+                return rc;
+
+        dma_ops = &xen_swiotlb_dma_ops;
+        /* Make sure ACS will be enabled */
+        pci_request_acs();
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pci_xen_swiotlb_init_late);
+
 IOMMU_INIT_FINISH(pci_xen_swiotlb_detect,
                   NULL,
                   pci_xen_swiotlb_init,
diff --git a/arch/x86/xen/vga.c b/arch/x86/xen/vga.c
index 1cd7f4d11e29..6722e3733f02 100644
--- a/arch/x86/xen/vga.c
+++ b/arch/x86/xen/vga.c
@@ -35,6 +35,7 @@ void __init xen_init_vga(const struct dom0_vga_console_info *info, size_t size)
                         info->u.text_mode_3.font_height;
                 break;
 
+        case XEN_VGATYPE_EFI_LFB:
         case XEN_VGATYPE_VESA_LFB:
                 if (size < offsetof(struct dom0_vga_console_info,
                                     u.vesa_lfb.gbl_caps))
@@ -54,6 +55,12 @@ void __init xen_init_vga(const struct dom0_vga_console_info *info, size_t size)
                 screen_info->blue_pos = info->u.vesa_lfb.blue_pos;
                 screen_info->rsvd_size = info->u.vesa_lfb.rsvd_size;
                 screen_info->rsvd_pos = info->u.vesa_lfb.rsvd_pos;
+
+                if (info->video_type == XEN_VGATYPE_EFI_LFB) {
+                        screen_info->orig_video_isVGA = VIDEO_TYPE_EFI;
+                        break;
+                }
+
                 if (size >= offsetof(struct dom0_vga_console_info,
                                      u.vesa_lfb.gbl_caps)
                     + sizeof(info->u.vesa_lfb.gbl_caps))
diff --git a/drivers/net/xen-netback/netback.c b/drivers/net/xen-netback/netback.c
index 1c0a30240d97..4ebfcf3d8a3b 100644
--- a/drivers/net/xen-netback/netback.c
+++ b/drivers/net/xen-netback/netback.c
@@ -636,9 +636,7 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
                 return;
 
         BUG_ON(npo.copy_prod > ARRAY_SIZE(netbk->grant_copy_op));
-        ret = HYPERVISOR_grant_table_op(GNTTABOP_copy, &netbk->grant_copy_op,
-                                        npo.copy_prod);
-        BUG_ON(ret != 0);
+        gnttab_batch_copy(netbk->grant_copy_op, npo.copy_prod);
 
         while ((skb = __skb_dequeue(&rxq)) != NULL) {
                 sco = (struct skb_cb_overlay *)skb->cb;
@@ -1461,18 +1459,15 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk)
 static void xen_netbk_tx_action(struct xen_netbk *netbk)
 {
         unsigned nr_gops;
-        int ret;
 
         nr_gops = xen_netbk_tx_build_gops(netbk);
 
         if (nr_gops == 0)
                 return;
-        ret = HYPERVISOR_grant_table_op(GNTTABOP_copy,
-                                        netbk->tx_copy_ops, nr_gops);
-        BUG_ON(ret);
 
-        xen_netbk_tx_submit(netbk);
+        gnttab_batch_copy(netbk->tx_copy_ops, nr_gops);
 
+        xen_netbk_tx_submit(netbk);
 }
 
 static void xen_netbk_idx_release(struct xen_netbk *netbk, u16 pending_idx)
diff --git a/drivers/pci/xen-pcifront.c b/drivers/pci/xen-pcifront.c
index a4d901def8f2..7d6773535b67 100644
--- a/drivers/pci/xen-pcifront.c
+++ b/drivers/pci/xen-pcifront.c
@@ -21,6 +21,7 @@
 #include <linux/bitops.h>
 #include <linux/time.h>
 
+#include <asm/xen/swiotlb-xen.h>
 #define INVALID_GRANT_REF (0)
 #define INVALID_EVTCHN    (-1)
 
@@ -668,7 +669,7 @@ static irqreturn_t pcifront_handler_aer(int irq, void *dev)
         schedule_pcifront_aer_op(pdev);
         return IRQ_HANDLED;
 }
-static int pcifront_connect(struct pcifront_device *pdev)
+static int pcifront_connect_and_init_dma(struct pcifront_device *pdev)
 {
         int err = 0;
 
@@ -681,9 +682,13 @@ static int pcifront_connect(struct pcifront_device *pdev)
                 dev_err(&pdev->xdev->dev, "PCI frontend already installed!\n");
                 err = -EEXIST;
         }
-
         spin_unlock(&pcifront_dev_lock);
 
+        if (!err && !swiotlb_nr_tbl()) {
+                err = pci_xen_swiotlb_init_late();
+                if (err)
+                        dev_err(&pdev->xdev->dev, "Could not setup SWIOTLB!\n");
+        }
         return err;
 }
 
@@ -842,10 +847,10 @@ static int __devinit pcifront_try_connect(struct pcifront_device *pdev)
             XenbusStateInitialised)
                 goto out;
 
-        err = pcifront_connect(pdev);
+        err = pcifront_connect_and_init_dma(pdev);
         if (err) {
                 xenbus_dev_fatal(pdev->xdev, err,
-                                 "Error connecting PCI Frontend");
+                                 "Error setting up PCI Frontend");
                 goto out;
         }
 
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
index eea81cf8a2a5..3a567b15600b 100644
--- a/drivers/xen/grant-table.c
+++ b/drivers/xen/grant-table.c
@@ -38,6 +38,7 @@
 #include <linux/vmalloc.h>
 #include <linux/uaccess.h>
 #include <linux/io.h>
+#include <linux/delay.h>
 #include <linux/hardirq.h>
 
 #include <xen/xen.h>
@@ -823,6 +824,52 @@ unsigned int gnttab_max_grant_frames(void)
 }
 EXPORT_SYMBOL_GPL(gnttab_max_grant_frames);
 
+/* Handling of paged out grant targets (GNTST_eagain) */
+#define MAX_DELAY 256
+static inline void
+gnttab_retry_eagain_gop(unsigned int cmd, void *gop, int16_t *status,
+                                                const char *func)
+{
+        unsigned delay = 1;
+
+        do {
+                BUG_ON(HYPERVISOR_grant_table_op(cmd, gop, 1));
+                if (*status == GNTST_eagain)
+                        msleep(delay++);
+        } while ((*status == GNTST_eagain) && (delay < MAX_DELAY));
+
+        if (delay >= MAX_DELAY) {
+                printk(KERN_ERR "%s: %s eagain grant\n", func, current->comm);
+                *status = GNTST_bad_page;
+        }
+}
+
+void gnttab_batch_map(struct gnttab_map_grant_ref *batch, unsigned count)
+{
+        struct gnttab_map_grant_ref *op;
+
+        if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, batch, count))
+                BUG();
+        for (op = batch; op < batch + count; op++)
+                if (op->status == GNTST_eagain)
+                        gnttab_retry_eagain_gop(GNTTABOP_map_grant_ref, op,
+                                                &op->status, __func__);
+}
+EXPORT_SYMBOL_GPL(gnttab_batch_map);
+
+void gnttab_batch_copy(struct gnttab_copy *batch, unsigned count)
+{
+        struct gnttab_copy *op;
+
+        if (HYPERVISOR_grant_table_op(GNTTABOP_copy, batch, count))
+                BUG();
+        for (op = batch; op < batch + count; op++)
+                if (op->status == GNTST_eagain)
+                        gnttab_retry_eagain_gop(GNTTABOP_copy, op,
+                                                &op->status, __func__);
+}
+EXPORT_SYMBOL_GPL(gnttab_batch_copy);
+
 int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
                     struct gnttab_map_grant_ref *kmap_ops,
                     struct page **pages, unsigned int count)
@@ -836,6 +883,12 @@ int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
         if (ret)
                 return ret;
 
+        /* Retry eagain maps */
+        for (i = 0; i < count; i++)
+                if (map_ops[i].status == GNTST_eagain)
+                        gnttab_retry_eagain_gop(GNTTABOP_map_grant_ref, map_ops + i,
+                                                &map_ops[i].status, __func__);
+
         if (xen_feature(XENFEAT_auto_translated_physmap))
                 return ret;
 
diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c
index 2e74dba6a04d..58db6df866ef 100644
--- a/drivers/xen/swiotlb-xen.c
+++ b/drivers/xen/swiotlb-xen.c
@@ -144,31 +144,72 @@ xen_swiotlb_fixup(void *buf, size_t size, unsigned long nslabs)
         } while (i < nslabs);
         return 0;
 }
+static unsigned long xen_set_nslabs(unsigned long nr_tbl)
+{
+        if (!nr_tbl) {
+                xen_io_tlb_nslabs = (64 * 1024 * 1024 >> IO_TLB_SHIFT);
+                xen_io_tlb_nslabs = ALIGN(xen_io_tlb_nslabs, IO_TLB_SEGSIZE);
+        } else
+                xen_io_tlb_nslabs = nr_tbl;
+
+        return xen_io_tlb_nslabs << IO_TLB_SHIFT;
+}
+
+enum xen_swiotlb_err {
+        XEN_SWIOTLB_UNKNOWN = 0,
+        XEN_SWIOTLB_ENOMEM,
+        XEN_SWIOTLB_EFIXUP
+};
 
-void __init xen_swiotlb_init(int verbose)
+static const char *xen_swiotlb_error(enum xen_swiotlb_err err)
 {
-        unsigned long bytes;
+        switch (err) {
+        case XEN_SWIOTLB_ENOMEM:
+                return "Cannot allocate Xen-SWIOTLB buffer\n";
+        case XEN_SWIOTLB_EFIXUP:
+                return "Failed to get contiguous memory for DMA from Xen!\n"\
+                    "You either: don't have the permissions, do not have"\
+                    " enough free memory under 4GB, or the hypervisor memory"\
+                    " is too fragmented!";
+        default:
+                break;
+        }
+        return "";
+}
+int __ref xen_swiotlb_init(int verbose, bool early)
+{
+        unsigned long bytes, order;
         int rc = -ENOMEM;
-        unsigned long nr_tbl;
-        char *m = NULL;
+        enum xen_swiotlb_err m_ret = XEN_SWIOTLB_UNKNOWN;
         unsigned int repeat = 3;
 
-        nr_tbl = swiotlb_nr_tbl();
-        if (nr_tbl)
-                xen_io_tlb_nslabs = nr_tbl;
-        else {
-                xen_io_tlb_nslabs = (64 * 1024 * 1024 >> IO_TLB_SHIFT);
-                xen_io_tlb_nslabs = ALIGN(xen_io_tlb_nslabs, IO_TLB_SEGSIZE);
-        }
+        xen_io_tlb_nslabs = swiotlb_nr_tbl();
 retry:
-        bytes = xen_io_tlb_nslabs << IO_TLB_SHIFT;
-
+        bytes = xen_set_nslabs(xen_io_tlb_nslabs);
+        order = get_order(xen_io_tlb_nslabs << IO_TLB_SHIFT);
         /*
          * Get IO TLB memory from any location.
          */
-        xen_io_tlb_start = alloc_bootmem_pages(PAGE_ALIGN(bytes));
+        if (early)
+                xen_io_tlb_start = alloc_bootmem_pages(PAGE_ALIGN(bytes));
+        else {
+#define SLABS_PER_PAGE (1 << (PAGE_SHIFT - IO_TLB_SHIFT))
+#define IO_TLB_MIN_SLABS ((1<<20) >> IO_TLB_SHIFT)
+                while ((SLABS_PER_PAGE << order) > IO_TLB_MIN_SLABS) {
+                        xen_io_tlb_start = (void *)__get_free_pages(__GFP_NOWARN, order);
+                        if (xen_io_tlb_start)
+                                break;
+                        order--;
+                }
+                if (order != get_order(bytes)) {
+                        pr_warn("Warning: only able to allocate %ld MB "
+                                "for software IO TLB\n", (PAGE_SIZE << order) >> 20);
+                        xen_io_tlb_nslabs = SLABS_PER_PAGE << order;
+                        bytes = xen_io_tlb_nslabs << IO_TLB_SHIFT;
+                }
+        }
         if (!xen_io_tlb_start) {
-                m = "Cannot allocate Xen-SWIOTLB buffer!\n";
+                m_ret = XEN_SWIOTLB_ENOMEM;
                 goto error;
         }
         xen_io_tlb_end = xen_io_tlb_start + bytes;
@@ -179,17 +220,22 @@ retry:
                                bytes,
                                xen_io_tlb_nslabs);
         if (rc) {
-                free_bootmem(__pa(xen_io_tlb_start), PAGE_ALIGN(bytes));
-                m = "Failed to get contiguous memory for DMA from Xen!\n"\
-                    "You either: don't have the permissions, do not have"\
-                    " enough free memory under 4GB, or the hypervisor memory"\
-                    "is too fragmented!";
+                if (early)
+                        free_bootmem(__pa(xen_io_tlb_start), PAGE_ALIGN(bytes));
+                else {
+                        free_pages((unsigned long)xen_io_tlb_start, order);
+                        xen_io_tlb_start = NULL;
+                }
+                m_ret = XEN_SWIOTLB_EFIXUP;
                 goto error;
         }
         start_dma_addr = xen_virt_to_bus(xen_io_tlb_start);
-        swiotlb_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs, verbose);
-
-        return;
+        if (early) {
+                swiotlb_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs, verbose);
+                rc = 0;
+        } else
+                rc = swiotlb_late_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs);
+        return rc;
 error:
         if (repeat--) {
                 xen_io_tlb_nslabs = max(1024UL, /* Min is 2MB */
@@ -198,10 +244,13 @@ error:
                       (xen_io_tlb_nslabs << IO_TLB_SHIFT) >> 20);
                 goto retry;
         }
-        xen_raw_printk("%s (rc:%d)", m, rc);
-        panic("%s (rc:%d)", m, rc);
+        pr_err("%s (rc:%d)", xen_swiotlb_error(m_ret), rc);
+        if (early)
+                panic("%s (rc:%d)", xen_swiotlb_error(m_ret), rc);
+        else
+                free_pages((unsigned long)xen_io_tlb_start, order);
+        return rc;
 }
-
 void *
 xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
                            dma_addr_t *dma_handle, gfp_t flags,
diff --git a/drivers/xen/xen-pciback/pci_stub.c b/drivers/xen/xen-pciback/pci_stub.c
index 03342728bf23..e5a0c13e2ad4 100644
--- a/drivers/xen/xen-pciback/pci_stub.c
+++ b/drivers/xen/xen-pciback/pci_stub.c
@@ -362,6 +362,7 @@ static int __devinit pcistub_init_device(struct pci_dev *dev)
         else {
                 dev_dbg(&dev->dev, "reseting (FLR, D3, etc) the device\n");
                 __pci_reset_function_locked(dev);
+                pci_restore_state(dev);
         }
         /* Now disable the device (this also ensures some private device
          * data is setup before we export)
@@ -681,14 +682,14 @@ static pci_ers_result_t xen_pcibk_slot_reset(struct pci_dev *dev)
                 dev_err(&dev->dev, DRV_NAME " device is not connected or owned"
                         " by HVM, kill it\n");
                 kill_domain_by_device(psdev);
-                goto release;
+                goto end;
         }
 
         if (!test_bit(_XEN_PCIB_AERHANDLER,
                 (unsigned long *)&psdev->pdev->sh_info->flags)) {
                 dev_err(&dev->dev,
                         "guest with no AER driver should have been killed\n");
-                goto release;
+                goto end;
         }
         result = common_process(psdev, 1, XEN_PCI_OP_aer_slotreset, result);
 
@@ -698,9 +699,9 @@ static pci_ers_result_t xen_pcibk_slot_reset(struct pci_dev *dev)
                         "No AER slot_reset service or disconnected!\n");
                 kill_domain_by_device(psdev);
         }
-release:
-        pcistub_device_put(psdev);
 end:
+        if (psdev)
+                pcistub_device_put(psdev);
         up_write(&pcistub_sem);
         return result;
 
@@ -739,14 +740,14 @@ static pci_ers_result_t xen_pcibk_mmio_enabled(struct pci_dev *dev)
                 dev_err(&dev->dev, DRV_NAME " device is not connected or owned"
                         " by HVM, kill it\n");
                 kill_domain_by_device(psdev);
-                goto release;
+                goto end;
         }
 
         if (!test_bit(_XEN_PCIB_AERHANDLER,
                 (unsigned long *)&psdev->pdev->sh_info->flags)) {
                 dev_err(&dev->dev,
                         "guest with no AER driver should have been killed\n");
-                goto release;
+                goto end;
         }
         result = common_process(psdev, 1, XEN_PCI_OP_aer_mmio, result);
 
@@ -756,9 +757,9 @@ static pci_ers_result_t xen_pcibk_mmio_enabled(struct pci_dev *dev)
                         "No AER mmio_enabled service or disconnected!\n");
                 kill_domain_by_device(psdev);
         }
-release:
-        pcistub_device_put(psdev);
 end:
+        if (psdev)
+                pcistub_device_put(psdev);
         up_write(&pcistub_sem);
         return result;
 }
@@ -797,7 +798,7 @@ static pci_ers_result_t xen_pcibk_error_detected(struct pci_dev *dev,
                 dev_err(&dev->dev, DRV_NAME " device is not connected or owned"
                         " by HVM, kill it\n");
                 kill_domain_by_device(psdev);
-                goto release;
+                goto end;
         }
 
         /*Guest owns the device yet no aer handler regiested, kill guest*/
@@ -805,7 +806,7 @@ static pci_ers_result_t xen_pcibk_error_detected(struct pci_dev *dev,
                 (unsigned long *)&psdev->pdev->sh_info->flags)) {
                 dev_dbg(&dev->dev, "guest may have no aer driver, kill it\n");
                 kill_domain_by_device(psdev);
-                goto release;
+                goto end;
         }
         result = common_process(psdev, error, XEN_PCI_OP_aer_detected, result);
 
@@ -815,9 +816,9 @@ static pci_ers_result_t xen_pcibk_error_detected(struct pci_dev *dev,
                         "No AER error_detected service or disconnected!\n");
                 kill_domain_by_device(psdev);
         }
-release:
-        pcistub_device_put(psdev);
 end:
+        if (psdev)
+                pcistub_device_put(psdev);
         up_write(&pcistub_sem);
         return result;
 }
@@ -851,7 +852,7 @@ static void xen_pcibk_error_resume(struct pci_dev *dev)
                 dev_err(&dev->dev, DRV_NAME " device is not connected or owned"
                         " by HVM, kill it\n");
                 kill_domain_by_device(psdev);
-                goto release;
+                goto end;
         }
 
         if (!test_bit(_XEN_PCIB_AERHANDLER,
@@ -859,13 +860,13 @@ static void xen_pcibk_error_resume(struct pci_dev *dev)
                 dev_err(&dev->dev,
                         "guest with no AER driver should have been killed\n");
                 kill_domain_by_device(psdev);
-                goto release;
+                goto end;
         }
         common_process(psdev, 1, XEN_PCI_OP_aer_resume,
                        PCI_ERS_RESULT_RECOVERED);
-release:
-        pcistub_device_put(psdev);
 end:
+        if (psdev)
+                pcistub_device_put(psdev);
         up_write(&pcistub_sem);
         return;
 }
@@ -897,17 +898,41 @@ static inline int str_to_slot(const char *buf, int *domain, int *bus,
                               int *slot, int *func)
 {
         int err;
+        char wc = '*';
 
         err = sscanf(buf, " %x:%x:%x.%x", domain, bus, slot, func);
-        if (err == 4)
+        switch (err) {
+        case 3:
+                *func = -1;
+                err = sscanf(buf, " %x:%x:%x.%c", domain, bus, slot, &wc);
+                break;
+        case 2:
+                *slot = *func = -1;
+                err = sscanf(buf, " %x:%x:*.%c", domain, bus, &wc);
+                if (err >= 2)
+                        ++err;
+                break;
+        }
+        if (err == 4 && wc == '*')
                 return 0;
         else if (err < 0)
                 return -EINVAL;
 
         /* try again without domain */
         *domain = 0;
+        wc = '*';
         err = sscanf(buf, " %x:%x.%x", bus, slot, func);
-        if (err == 3)
+        switch (err) {
+        case 2:
+                *func = -1;
+                err = sscanf(buf, " %x:%x.%c", bus, slot, &wc);
+                break;
+        case 1:
+                *slot = *func = -1;
+                err = sscanf(buf, " %x:*.%c", bus, &wc) + 1;
+                break;
+        }
+        if (err == 3 && wc == '*')
                 return 0;
 
         return -EINVAL;
@@ -930,6 +955,19 @@ static int pcistub_device_id_add(int domain, int bus, int slot, int func)
 {
         struct pcistub_device_id *pci_dev_id;
         unsigned long flags;
+        int rc = 0;
+
+        if (slot < 0) {
+                for (slot = 0; !rc && slot < 32; ++slot)
+                        rc = pcistub_device_id_add(domain, bus, slot, func);
+                return rc;
+        }
+
+        if (func < 0) {
+                for (func = 0; !rc && func < 8; ++func)
+                        rc = pcistub_device_id_add(domain, bus, slot, func);
+                return rc;
+        }
 
         pci_dev_id = kmalloc(sizeof(*pci_dev_id), GFP_KERNEL);
         if (!pci_dev_id)
@@ -952,15 +990,15 @@ static int pcistub_device_id_add(int domain, int bus, int slot, int func)
 static int pcistub_device_id_remove(int domain, int bus, int slot, int func)
 {
         struct pcistub_device_id *pci_dev_id, *t;
-        int devfn = PCI_DEVFN(slot, func);
         int err = -ENOENT;
         unsigned long flags;
 
         spin_lock_irqsave(&device_ids_lock, flags);
         list_for_each_entry_safe(pci_dev_id, t, &pcistub_device_ids,
                                  slot_list) {
-                if (pci_dev_id->domain == domain
-                    && pci_dev_id->bus == bus && pci_dev_id->devfn == devfn) {
+                if (pci_dev_id->domain == domain && pci_dev_id->bus == bus
+                    && (slot < 0 || PCI_SLOT(pci_dev_id->devfn) == slot)
+                    && (func < 0 || PCI_FUNC(pci_dev_id->devfn) == func)) {
                         /* Don't break; here because it's possible the same
                          * slot could be in the list more than once
                          */
@@ -987,7 +1025,7 @@ static int pcistub_reg_add(int domain, int bus, int slot, int func, int reg,
         struct config_field *field;
 
         psdev = pcistub_device_find(domain, bus, slot, func);
-        if (!psdev || !psdev->dev) {
+        if (!psdev) {
                 err = -ENODEV;
                 goto out;
         }
@@ -1011,6 +1049,8 @@ static int pcistub_reg_add(int domain, int bus, int slot, int func, int reg,
         if (err)
                 kfree(field);
 out:
+        if (psdev)
+                pcistub_device_put(psdev);
         return err;
 }
 
@@ -1115,10 +1155,9 @@ static ssize_t pcistub_irq_handler_switch(struct device_driver *drv,
 
         err = str_to_slot(buf, &domain, &bus, &slot, &func);
         if (err)
-                goto out;
+                return err;
 
         psdev = pcistub_device_find(domain, bus, slot, func);
-
         if (!psdev)
                 goto out;
 
@@ -1134,6 +1173,8 @@ static ssize_t pcistub_irq_handler_switch(struct device_driver *drv,
         if (dev_data->isr_on)
                 dev_data->ack_intr = 1;
 out:
+        if (psdev)
+                pcistub_device_put(psdev);
         if (!err)
                 err = count;
         return err;
@@ -1216,15 +1257,16 @@ static ssize_t permissive_add(struct device_driver *drv, const char *buf,
         err = str_to_slot(buf, &domain, &bus, &slot, &func);
         if (err)
                 goto out;
+        if (slot < 0 || func < 0) {
+                err = -EINVAL;
+                goto out;
+        }
         psdev = pcistub_device_find(domain, bus, slot, func);
         if (!psdev) {
                 err = -ENODEV;
                 goto out;
         }
-        if (!psdev->dev) {
-                err = -ENODEV;
-                goto release;
-        }
+
         dev_data = pci_get_drvdata(psdev->dev);
         /* the driver data for a device should never be null at this point */
         if (!dev_data) {
@@ -1297,17 +1339,51 @@ static int __init pcistub_init(void)
 
         if (pci_devs_to_hide && *pci_devs_to_hide) {
                 do {
+                        char wc = '*';
+
                         parsed = 0;
 
                         err = sscanf(pci_devs_to_hide + pos,
                                      " (%x:%x:%x.%x) %n",
                                      &domain, &bus, &slot, &func, &parsed);
-                        if (err != 4) {
+                        switch (err) {
+                        case 3:
+                                func = -1;
+                                err = sscanf(pci_devs_to_hide + pos,
+                                             " (%x:%x:%x.%c) %n",
+                                             &domain, &bus, &slot, &wc,
+                                             &parsed);
+                                break;
+                        case 2:
+                                slot = func = -1;
+                                err = sscanf(pci_devs_to_hide + pos,
+                                             " (%x:%x:*.%c) %n",
+                                             &domain, &bus, &wc, &parsed) + 1;
+                                break;
+                        }
+
+                        if (err != 4 || wc != '*') {
                                 domain = 0;
+                                wc = '*';
                                 err = sscanf(pci_devs_to_hide + pos,
                                              " (%x:%x.%x) %n",
                                              &bus, &slot, &func, &parsed);
-                                if (err != 3)
+                                switch (err) {
+                                case 2:
+                                        func = -1;
+                                        err = sscanf(pci_devs_to_hide + pos,
+                                                     " (%x:%x.%c) %n",
+                                                     &bus, &slot, &wc,
+                                                     &parsed);
+                                        break;
+                                case 1:
+                                        slot = func = -1;
+                                        err = sscanf(pci_devs_to_hide + pos,
+                                                     " (%x:*.%c) %n",
+                                                     &bus, &wc, &parsed) + 1;
+                                        break;
+                                }
+                                if (err != 3 || wc != '*')
                                         goto parse_error;
                         }
 
diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c
index b3e146edb51d..bcf3ba4a6ec1 100644
--- a/drivers/xen/xenbus/xenbus_client.c
+++ b/drivers/xen/xenbus/xenbus_client.c
@@ -490,8 +490,7 @@ static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,
 
         op.host_addr = arbitrary_virt_to_machine(pte).maddr;
 
-        if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
-                BUG();
+        gnttab_batch_map(&op, 1);
 
         if (op.status != GNTST_okay) {
                 free_vm_area(area);
@@ -572,8 +571,7 @@ int xenbus_map_ring(struct xenbus_device *dev, int gnt_ref,
         gnttab_set_map_op(&op, (unsigned long)vaddr, GNTMAP_host_map, gnt_ref,
                           dev->otherend_id);
 
-        if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
-                BUG();
+        gnttab_batch_map(&op, 1);
 
         if (op.status != GNTST_okay) {
                 xenbus_dev_fatal(dev, op.status,
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index e872526fdc5f..8d08b3ed406d 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -25,6 +25,7 @@ extern int swiotlb_force;
 extern void swiotlb_init(int verbose);
 extern void swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose);
 extern unsigned long swiotlb_nr_tbl(void);
+extern int swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs);
 
 /*
  * Enumeration for sync targets
diff --git a/include/xen/grant_table.h b/include/xen/grant_table.h
index 11e27c3af3cb..ba0d77529a29 100644
--- a/include/xen/grant_table.h
+++ b/include/xen/grant_table.h
@@ -189,4 +189,16 @@ int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
 int gnttab_unmap_refs(struct gnttab_unmap_grant_ref *unmap_ops,
                       struct page **pages, unsigned int count, bool clear_pte);
 
+/* Perform a batch of grant map/copy operations. Retry every batch slot
+ * for which the hypervisor returns GNTST_eagain. This is typically due
+ * to paged out target frames.
+ *
+ * Will retry for 1, 2, ... 255 ms, i.e. 256 times during 32 seconds.
+ *
+ * Return value in each iand every status field of the batch guaranteed
+ * to not be GNTST_eagain.
+ */
+void gnttab_batch_map(struct gnttab_map_grant_ref *batch, unsigned count);
+void gnttab_batch_copy(struct gnttab_copy *batch, unsigned count);
+
 #endif /* __ASM_GNTTAB_H__ */
diff --git a/include/xen/interface/platform.h b/include/xen/interface/platform.h
index a3275a850e54..54ad6f9e4725 100644
--- a/include/xen/interface/platform.h
+++ b/include/xen/interface/platform.h
@@ -112,6 +112,7 @@ DEFINE_GUEST_HANDLE_STRUCT(xenpf_platform_quirk_t);
 #define XEN_FW_DISK_INFO          1 /* from int 13 AH=08/41/48 */
 #define XEN_FW_DISK_MBR_SIGNATURE 2 /* from MBR offset 0x1b8 */
 #define XEN_FW_VBEDDC_INFO        3 /* from int 10 AX=4f15 */
+#define XEN_FW_KBD_SHIFT_FLAGS    5 /* Int16, Fn02: Get keyboard shift flags. */
 struct xenpf_firmware_info {
         /* IN variables. */
         uint32_t type;
@@ -142,6 +143,8 @@ struct xenpf_firmware_info {
                         /* must refer to 128-byte buffer */
                         GUEST_HANDLE(uchar) edid;
                 } vbeddc_info; /* XEN_FW_VBEDDC_INFO */
+
+                uint8_t kbd_shift_flags; /* XEN_FW_KBD_SHIFT_FLAGS */
         } u;
 };
 DEFINE_GUEST_HANDLE_STRUCT(xenpf_firmware_info_t);
diff --git a/include/xen/interface/xen.h b/include/xen/interface/xen.h
index 1e0df6b7d3b3..886a5d80a18f 100644
--- a/include/xen/interface/xen.h
+++ b/include/xen/interface/xen.h
@@ -454,6 +454,7 @@ struct dom0_vga_console_info {
         uint8_t video_type;
 #define XEN_VGATYPE_TEXT_MODE_3 0x03
 #define XEN_VGATYPE_VESA_LFB    0x23
+#define XEN_VGATYPE_EFI_LFB     0x70
 
         union {
                 struct {
diff --git a/include/xen/swiotlb-xen.h b/include/xen/swiotlb-xen.h
index c050b6b9de38..de8bcc641c49 100644
--- a/include/xen/swiotlb-xen.h
+++ b/include/xen/swiotlb-xen.h
@@ -3,7 +3,7 @@
 
 #include <linux/swiotlb.h>
 
-extern void xen_swiotlb_init(int verbose);
+extern int xen_swiotlb_init(int verbose, bool early);
 
 extern void
 *xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index 45bc1f83a5ad..f114bf6a8e13 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -170,7 +170,7 @@ void __init swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose)
  * Statically reserve bounce buffer space and initialize bounce buffer data
  * structures for the software IO TLB used to implement the DMA API.
  */
-void __init
+static void __init
 swiotlb_init_with_default_size(size_t default_size, int verbose)
 {
         unsigned long bytes;
@@ -206,8 +206,9 @@ swiotlb_init(int verbose)
 int
 swiotlb_late_init_with_default_size(size_t default_size)
 {
-        unsigned long i, bytes, req_nslabs = io_tlb_nslabs;
+        unsigned long bytes, req_nslabs = io_tlb_nslabs;
         unsigned int order;
+        int rc = 0;
 
         if (!io_tlb_nslabs) {
                 io_tlb_nslabs = (default_size >> IO_TLB_SHIFT);
@@ -229,16 +230,32 @@ swiotlb_late_init_with_default_size(size_t default_size)
                 order--;
         }
 
-        if (!io_tlb_start)
-                goto cleanup1;
-
+        if (!io_tlb_start) {
+                io_tlb_nslabs = req_nslabs;
+                return -ENOMEM;
+        }
         if (order != get_order(bytes)) {
                 printk(KERN_WARNING "Warning: only able to allocate %ld MB "
                        "for software IO TLB\n", (PAGE_SIZE << order) >> 20);
                 io_tlb_nslabs = SLABS_PER_PAGE << order;
-                bytes = io_tlb_nslabs << IO_TLB_SHIFT;
         }
+        rc = swiotlb_late_init_with_tbl(io_tlb_start, io_tlb_nslabs);
+        if (rc)
+                free_pages((unsigned long)io_tlb_start, order);
+        return rc;
+}
+
+int
+swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs)
+{
+        unsigned long i, bytes;
+
+        bytes = nslabs << IO_TLB_SHIFT;
+
+        io_tlb_nslabs = nslabs;
+        io_tlb_start = tlb;
         io_tlb_end = io_tlb_start + bytes;
+
         memset(io_tlb_start, 0, bytes);
 
         /*
@@ -288,10 +305,8 @@ cleanup3:
         io_tlb_list = NULL;
 cleanup2:
         io_tlb_end = NULL;
-        free_pages((unsigned long)io_tlb_start, order);
         io_tlb_start = NULL;
-cleanup1:
-        io_tlb_nslabs = req_nslabs;
+        io_tlb_nslabs = 0;
         return -ENOMEM;
 }