[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Xen-devel] Experimental results for VGA passthrough



Certainly. I tried this on Xen 3.4.1 rc1 pre, changeset 19645. Most of
these stuff are from Jean and his team. Hopefully more people can update
their results.

- Beng Heng

Jun Koi wrote:
> Hi Beng,
> 
> Would you please send the patch you applied on top of Xen to the list?
> I think many people are interested in that.
> 
> Thanks,
> Jun
> 
> 
> 

diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/drivers/xen/pciback/controller.c 
b/linux-2.6.18-xen.hg/drivers/xen/pciback/controller.c
--- a/linux-2.6.18-xen.hg/drivers/xen/pciback/controller.c      2009-06-07 
20:48:21.000000000 -0400
+++ b/linux-2.6.18-xen.hg/drivers/xen/pciback/controller.c      2009-06-07 
19:04:11.000000000 -0400
@@ -208,7 +208,7 @@ void pciback_release_pci_dev(struct pcib
        }
 
        spin_unlock_irqrestore(&dev_data->lock, flags);
-       pcistub_put_pci_dev(found_dev);
+       pcistub_put_pci_dev(found_dev, 0);
 }
 
 int pciback_init_devices(struct pciback_device *pdev)
@@ -396,7 +396,7 @@ void pciback_release_devices(struct pcib
                list_for_each_entry_safe(dev_entry, d,
                                         &cntrl_entry->dev_list, list) {
                        list_del(&dev_entry->list);
-                       pcistub_put_pci_dev(dev_entry->dev);
+                       pcistub_put_pci_dev(dev_entry->dev, 0);
                        kfree(dev_entry);
                }
                list_del(&cntrl_entry->list);
diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/drivers/xen/pciback/passthrough.c 
b/linux-2.6.18-xen.hg/drivers/xen/pciback/passthrough.c
--- a/linux-2.6.18-xen.hg/drivers/xen/pciback/passthrough.c     2009-06-07 
20:48:21.000000000 -0400
+++ b/linux-2.6.18-xen.hg/drivers/xen/pciback/passthrough.c     2009-06-07 
19:04:11.000000000 -0400
@@ -88,7 +88,7 @@ void pciback_release_pci_dev(struct pcib
        spin_unlock_irqrestore(&dev_data->lock, flags);
 
        if (found_dev)
-               pcistub_put_pci_dev(found_dev);
+               pcistub_put_pci_dev(found_dev, 1);
 }
 
 int pciback_init_devices(struct pciback_device *pdev)
@@ -157,7 +157,7 @@ void pciback_release_devices(struct pcib
 
        list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
                list_del(&dev_entry->list);
-               pcistub_put_pci_dev(dev_entry->dev);
+               pcistub_put_pci_dev(dev_entry->dev, 1);
                kfree(dev_entry);
        }
 
diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/drivers/xen/pciback/pciback.h 
b/linux-2.6.18-xen.hg/drivers/xen/pciback/pciback.h
--- a/linux-2.6.18-xen.hg/drivers/xen/pciback/pciback.h 2009-06-07 
20:48:21.000000000 -0400
+++ b/linux-2.6.18-xen.hg/drivers/xen/pciback/pciback.h 2009-06-07 
19:04:11.000000000 -0400
@@ -25,6 +25,14 @@ struct pci_dev_entry {
 #define _PCIB_op_pending       (1)
 #define PCIB_op_pending                (1<<(_PCIB_op_pending))
 
+#define PCIBACK_TYPE_UNKNOWN       0
+#define PCIBACK_TYPE_PCIe_ENDPOINT 1
+#define PCIBACK_TYPE_PCIe_BRIDGE   2
+#define PCIBACK_TYPE_PCI_BRIDGE    3
+#define PCIBACK_TYPE_PCI           4
+
+#define DEV_CLASS_PCI_PCI_BRIDGE 0x0604
+
 struct pciback_device {
        void *pci_dev_data;
        spinlock_t dev_lock;
@@ -48,6 +56,13 @@ struct pciback_dev_data {
        struct list_head config_fields;
        int permissive;
        int warned_on_write;
+       u32 dev_type;
+       int no_flr;
+       int exp_flr_offset;
+       int af_flr_offset;
+       int use_sbr;
+       int use_d3r;
+       u8 *cfg_space; /* saved config space for device */
 };
 
 /* Get/Put PCI Devices that are hidden from the PCI Backend Domain */
@@ -56,11 +71,25 @@ struct pci_dev *pcistub_get_pci_dev_by_s
                                            int slot, int func);
 struct pci_dev *pcistub_get_pci_dev(struct pciback_device *pdev,
                                    struct pci_dev *dev);
-void pcistub_put_pci_dev(struct pci_dev *dev);
+void pcistub_put_pci_dev(struct pci_dev *dev, int do_flr);
+
+/* Reference/unreference PCI Devices and stubs without changing the state */
+struct pci_dev *pcistub_ref_pci_dev(struct pci_dev *dev);
+void pcistub_unref_pci_dev(struct pci_dev *dev);
+
+/* Store/reload config space for devices */
+void pciback_store_config_space(struct pci_dev *dev);
+void pciback_reload_config_space(struct pci_dev *dev);
 
 /* Ensure a device is turned off or reset */
 void pciback_reset_device(struct pci_dev *pdev);
 
+/* Do a function level reset (or approximage functionality) for device */
+void pciback_flr_device(struct pci_dev *dev);
+
+/* Helper to classify the device type */
+void pciback_classify_device(struct pci_dev *dev);
+
 /* Access a virtual configuration space for a PCI device */
 int pciback_config_init(void);
 int pciback_config_init_dev(struct pci_dev *dev);
@@ -102,6 +131,10 @@ void pciback_release_devices(struct pcib
 irqreturn_t pciback_handle_event(int irq, void *dev_id, struct pt_regs *regs);
 void pciback_do_op(void *data);
 
+/* Parse and load device specific module parameters */
+int pciback_parse_device_params(const char *device_args, int type,
+                                       int (*add_func) (int domain, int bus, 
int slot, int func, int type));
+
 int pciback_xenbus_register(void);
 void pciback_xenbus_unregister(void);
 
diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/drivers/xen/pciback/pciback_ops.c 
b/linux-2.6.18-xen.hg/drivers/xen/pciback/pciback_ops.c
--- a/linux-2.6.18-xen.hg/drivers/xen/pciback/pciback_ops.c     2009-06-07 
20:48:21.000000000 -0400
+++ b/linux-2.6.18-xen.hg/drivers/xen/pciback/pciback_ops.c     2009-06-07 
19:04:11.000000000 -0400
@@ -5,20 +5,189 @@
  */
 #include <linux/module.h>
 #include <linux/wait.h>
+#include <linux/delay.h> /* For mdelay function */
 #include <asm/bitops.h>
 #include <xen/evtchn.h>
 #include "pciback.h"
 
+#define PCIBACK_VENDOR_INTEL     0x8086
+#define PCIBACK_CLASS_ID_USB     0x0c03
+#define PCIBACK_CLASS_ID_VGA     0x0300
+#define PCIBACK_USB_FLRCTRL      0x4
+
+#define PCIBACK_IGFX_CAP09_OFFSET    0xa4
+#define PCIBACK_IGFX_CAP13_OFFSET    0xa4
+
+#define PCIBACK_IGFX_MEDIARST        0x0d
+#define PCIBACK_IGFX_MEDIARST_OFFSET 0xc0
+
 int verbose_request = 0;
 module_param(verbose_request, int, 0644);
 
+struct pcistub_sbr_entry {
+       struct list_head dev_list;
+       struct pci_dev *dev;
+};
+
+struct pcistub_sbr_list {
+       struct list_head dev_list;
+       struct pci_dev *bridge;
+       struct pci_dev *dev;
+       int find_all;
+       int err;
+};
+
+/* Used to store the config state so it can be restored after
+ * resets.
+ */
+void pciback_store_config_space(struct pci_dev *dev)
+{
+       struct pciback_dev_data *dev_data = pci_get_drvdata(dev);
+       u32 *ptr = (u32*)dev_data->cfg_space;
+       int i, count = dev->cfg_size/sizeof(u32);
+       
+       for (i = 0; i < count; i += sizeof(u32), ptr++)
+               pci_read_config_dword(dev, i, ptr);
+}
+
+/* Used to reload the config state after resets.
+ */
+void pciback_reload_config_space(struct pci_dev *dev)
+{
+       struct pciback_dev_data *dev_data = pci_get_drvdata(dev);
+       u32 *ptr = (u32*)dev_data->cfg_space;
+       int i, val, count = dev->cfg_size/sizeof(u32);
+
+       for (i = 0; i < count; i += sizeof(u32), ptr++) {
+               pci_read_config_dword(dev, i, &val);
+               if (val != *ptr)
+                       pci_write_config_dword(dev, i, *ptr);
+       }
+}
+
+static void pciback_walk_bus_cb(struct pci_dev *dev, void *userdata)
+{
+       struct pcistub_sbr_list *list = (struct pcistub_sbr_list*)userdata;
+       struct pcistub_sbr_entry *entry;
+       struct pci_dev *dev_tmp;
+       
+       if (list->err != 0)
+               return;
+
+       /* For PCIe endpoints we are only looking for co-assigned functions */
+       if (!list->find_all &&
+               (dev->bus->number != list->dev->bus->number ||
+                PCI_SLOT(dev->devfn) != PCI_SLOT(list->dev->devfn)))
+               return;
+
+       dev_tmp = pcistub_ref_pci_dev(dev);
+       if (dev_tmp == NULL) {
+               /* not controlled by pciback, fail */
+               list->err = ENXIO;
+               return;
+       }
+
+       entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
+       if (entry == NULL) {
+               pcistub_unref_pci_dev(dev_tmp);
+               list->err = ENOMEM;
+               return;
+       }
+
+       entry->dev = dev_tmp;
+       list_add_tail(&entry->dev_list, &list->dev_list);
+}
+
+static void pciback_cleanup_sbr_list(struct pcistub_sbr_list *list)
+{
+       struct pcistub_sbr_entry *entry;
+
+       list_for_each_entry(entry, &list->dev_list, dev_list) {
+               pcistub_unref_pci_dev(entry->dev);
+               kfree(entry);
+       }
+}
+
+/* Routine to find all devices and bridges that need to be reset
+ * during a secondary bus reset. For PCIe this is simply all the
+ * functions on the particular device. For PCI this is all devices
+ * and bridges below the topmost PCI/PCI-X bridge. Note for PCI, 
+ * there is at least one something->PCI/PCI-X bridge to find since
+ * the device is not on the host bus 0 and is on a PCI bus.
+ */
+static int pciback_get_sbr_list(struct pci_dev *dev, 
+       struct pcistub_sbr_list *list, int pcie_endpoint)
+{
+       struct pci_dev *bridge = dev->bus->self;
+       struct pci_dev *last = NULL;
+       int exp_pos;
+       u16 exp_caps = 0;
+
+       list->err = 0;
+       list->dev = dev;
+       INIT_LIST_HEAD(&list->dev_list);
+
+       if (!pcie_endpoint) {
+               while (bridge) {
+                       /* Looking for the uppermost PCI/PCI-X bridge. If it is 
not PCIe then 
+                        * this is a PCI/PCI-X bridge. If it is PCIe then 
except the PCIe to 
+                        * PCI/PCI-X type 7, the rest of the bridge types are 
PCIe so the last 
+                        * bridge encountered was the topmost PCI/PCI-X bridge.
+                        */
+                       exp_pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
+                       if (exp_pos != 0) {
+                               pci_read_config_word(bridge, exp_pos + 
PCI_EXP_FLAGS, &exp_caps);
+                               if (((exp_caps & PCI_EXP_FLAGS_TYPE) >> 4) != 
PCI_EXP_TYPE_PCI_BRIDGE)
+                                       break; /* don't want it in the list if 
it is a PCIe bridge */
+                       }
+                       last = bridge;
+                       bridge = last->bus->self;
+               }
+               list->bridge = last;
+               list->find_all = 1; /* find all devices/bridges below the 
topmost */
+       }
+       else {
+               if (bridge) {
+                       /* For PCIe, SBR logic is limited to PCIe endpoints 
behind a root/switch
+                        * port.
+                        */
+                       exp_pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
+                       if (likely(exp_pos != 0)) {
+                               pci_read_config_word(bridge, exp_pos + 
PCI_EXP_FLAGS, &exp_caps);
+                               exp_caps = ((exp_caps & PCI_EXP_FLAGS_TYPE) >> 
4);
+                               if (exp_caps == PCI_EXP_TYPE_ROOT_PORT ||
+                                       exp_caps == PCI_EXP_TYPE_UPSTREAM ||
+                                       exp_caps == PCI_EXP_TYPE_DOWNSTREAM)
+                                       last = bridge;
+                       }
+               }
+               list->bridge = last;
+               list->find_all = 0; /* find just functions on this slot */
+       }
+
+       /* Sanity check, there may not be any appropriate bridge to reset */
+       if (!list->bridge) {
+               dev_dbg(&dev->dev, "No appropriate bridge to reset\n");
+               return ENXIO;
+       }
+
+       pci_walk_bus(list->bridge->subordinate, pciback_walk_bus_cb, list);
+
+       if (list->err) {
+               pciback_cleanup_sbr_list(list);
+               return list->err;
+       }
+
+       return 0;
+}
+
 /* Ensure a device is "turned off" and ready to be exported.
  * (Also see pciback_config_reset to ensure virtual configuration space is
  * ready to be re-exported)
  */
 void pciback_reset_device(struct pci_dev *dev)
 {
-       u16 cmd;
+       u16 cmd = 0;
 
        /* Disable devices (but not bridges) */
        if (dev->hdr_type == PCI_HEADER_TYPE_NORMAL) {
@@ -38,6 +207,425 @@ void pciback_reset_device(struct pci_dev
                }
        }
 }
+
+/* Do a PCIe type function level reset for a single function on this
+ * device.
+ */
+static void pciback_do_pcie_flr(struct pci_dev *dev, int exp_pos)
+{
+       u16 status = 0;
+       
+       dev_dbg(&dev->dev, "doing PCIe FLR\n"); 
+
+       pci_block_user_cfg_access(dev);
+
+       /* Wait for Transaction Pending bit clean */
+       msleep(100);
+       pci_read_config_word(dev, exp_pos + PCI_EXP_DEVSTA, &status);
+       if (status & PCI_EXP_DEVSTA_TRPND) {
+               dev_dbg(&dev->dev, "Busy after 100ms while trying to reset; 
sleeping for 1 second\n");
+               ssleep(1);
+               pci_read_config_word(dev, exp_pos + PCI_EXP_DEVSTA, &status);
+               if (status & PCI_EXP_DEVSTA_TRPND)
+                       dev_warn(&dev->dev, "Still busy after 1s; proceeding 
with reset anyway\n");
+       }
+
+       pci_write_config_word(dev, exp_pos + PCI_EXP_DEVCTL, 
PCI_EXP_DEVCTL_BCR_FLR);
+       mdelay(200);
+
+       pciback_reload_config_space(dev);
+
+       pci_unblock_user_cfg_access(dev);
+}
+
+/* Do a PCI type function level reset for a single function on this
+ * device. This uses the Advanced Features Capability extensions to
+ * the PCI spec.
+ */
+static void pciback_do_pci_flr(struct pci_dev *dev, int af_pos, int clear_cmd)
+{
+       u8 status = 0;
+
+       dev_dbg(&dev->dev, "doing PCI FLR\n");
+
+       pci_block_user_cfg_access(dev);
+
+       /* Clear the command register to prevent new transactions */
+       if (clear_cmd)
+               pci_write_config_word(dev, PCI_COMMAND, 0);
+
+       /* Wait for Transaction Pending bit clean */
+       msleep(100);
+       pci_read_config_byte(dev, af_pos + PCI_AF_STA, &status);
+       if (status & PCI_AF_STA_TP) {
+               dev_dbg(&dev->dev, "Busy after 100ms while trying to reset; 
sleeping for 1 second\n");
+               ssleep(1);
+               pci_read_config_byte(dev, af_pos + PCI_AF_STA, &status);
+               if (status & PCI_AF_STA_TP)
+                       dev_warn(&dev->dev, "Still busy after 1s; proceeding 
with reset anyway\n");
+       }
+
+       pci_write_config_byte(dev, af_pos + PCI_AF_CTRL, PCI_AF_CTRL_FLR);
+       mdelay(200);
+
+       pciback_reload_config_space(dev);
+
+       pci_unblock_user_cfg_access(dev);
+}
+
+/* Vendor specific resets. These can be set in the vendor specific
+ * capabilities structures. Currently only the Intel USB and iGFX
+ * reset is supported.
+ */
+static int pciback_do_vendor_specific_reset(struct pci_dev *dev)
+{
+       struct pci_dev *gmch;
+       int vendor_pos, i;
+       u32 reg32 = 0;
+       u16 device_id, cmd;     
+       u8 reg8 = 0;
+
+       dev_dbg(&dev->dev, "doing vendor specific resets\n");   
+
+       if (dev->vendor != PCIBACK_VENDOR_INTEL)
+               return -ENXIO;
+
+       if ((dev->class >> 8) == PCIBACK_CLASS_ID_VGA) {
+               if (dev->bus->number != 0 || dev->devfn != PCI_DEVFN(2,0))
+                       return -ENXIO;
+
+               /* Locate the GMCH (north bridge) and test for specific Intel 
devices */
+               gmch = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
+               if (!gmch)
+                       return -ENXIO;
+
+               device_id = gmch->device;
+               pci_dev_put(gmch);
+
+               if (device_id != PCI_DEVICE_ID_INTEL_GMCHGM45)
+                       return -ENXIO;
+
+               /* Correct device and platform, assume vendor specific offset */
+               pci_read_config_dword(dev, PCIBACK_IGFX_CAP09_OFFSET, &reg32);
+               if ((reg32 & 0x000000FF) != PCI_CAP_ID_VNDR ||
+                       ((reg32 >> 16) & 0x000000FF) != 0x06 ||
+                       ((reg32 >> 24) & 0x000000F0) != 0x20)
+                       return -ENXIO;
+
+               vendor_pos = PCIBACK_IGFX_CAP09_OFFSET;
+       } else if ((dev->class >> 8) == PCIBACK_CLASS_ID_USB) {
+               vendor_pos = pci_find_capability(dev, PCI_CAP_ID_VNDR);
+               if (vendor_pos == 0)
+                       return -ENXIO;
+       }
+       else
+               return -ENXIO;  
+
+       if ((dev->class >> 8) == PCIBACK_CLASS_ID_VGA) {
+               pci_write_config_byte(dev, PCIBACK_IGFX_MEDIARST_OFFSET, 
PCIBACK_IGFX_MEDIARST);
+               for (i = 0; i <= 10; i++) {
+                       msleep(100);
+                       pci_read_config_byte(dev, PCIBACK_IGFX_MEDIARST_OFFSET, 
&reg8);
+                       if ((reg8 & 0x01) == 0)
+                               break;
+                       if (i == 10) {
+                               dev_warn(&dev->dev, "media not reset after 1s; 
skipping FLR\n");
+                               goto out;
+                       }
+               }
+        
+               /* This specific reset will hang if the command register does 
not have
+                * memory space access enabled */
+               pci_read_config_word(dev, PCI_COMMAND, &cmd);
+               pci_write_config_word(dev, PCI_COMMAND, (cmd | 
PCI_COMMAND_MEMORY));
+               /* The rest is the same as a PCI AF FLR - use the same routine 
*/
+               pciback_do_pci_flr(dev, vendor_pos, 0);
+               pci_write_config_word(dev, PCI_COMMAND, cmd);
+       } else {
+               pci_block_user_cfg_access(dev);
+
+               pci_write_config_byte(dev, vendor_pos + PCIBACK_USB_FLRCTRL, 1);
+               mdelay(200);
+
+               pciback_reload_config_space(dev);
+
+               pci_unblock_user_cfg_access(dev);
+       }
+
+out:
+       return 0;
+}
+
+/* Use a D0-D3-D0 device state transition to reset the device. This
+ * is a good enough reset for some devices (like NICs).
+ */
+static int pciback_do_dstate_transition_reset(struct pci_dev *dev)
+{
+       int pm_pos;
+       u32 pm_ctl = 0;
+
+       pm_pos = pci_find_capability(dev, PCI_CAP_ID_PM);
+       if (pm_pos == 0)
+               return -ENXIO;
+
+       dev_dbg(&dev->dev, "doing Dstate transition reset\n");  
+
+       /* No_Soft_Reset - When set 1, this bit indicates that devices
+        * transitioning from D3hot to D0 because of PowerState commands 
+        * do not perform an internal reset.
+        */
+       pci_read_config_dword(dev, pm_pos + PCI_PM_CTRL, &pm_ctl);
+       if (pm_ctl & PCI_PM_CTRL_NO_SOFT_RESET)
+               return -ENXIO;
+       
+       pci_block_user_cfg_access(dev);
+
+       pm_ctl &= ~PCI_PM_CTRL_STATE_MASK;
+       pm_ctl |= PCI_PM_CTRL_D3HOT;
+       pci_write_config_word(dev, pm_pos + PCI_PM_CTRL, pm_ctl);
+       mdelay(10);
+
+       pm_ctl &= ~PCI_PM_CTRL_STATE_MASK;
+       pm_ctl |= PCI_PM_CTRL_D0;
+       pci_write_config_word(dev, pm_pos + PCI_PM_CTRL, pm_ctl);
+       mdelay(10);
+
+       pciback_reload_config_space(dev);
+
+       pci_unblock_user_cfg_access(dev);
+       
+       return 0;
+}
+
+/* Do a secondary bus reset on a bridge. This is only done if all
+ * co-assignment rules are satisfied and if it was explicitly 
+ * requested via pciback parameters.
+ */
+static int pciback_do_secondary_bus_reset(struct pci_dev *dev, u32 dev_type)
+{
+       struct pcistub_sbr_list sbr_list;
+       struct pcistub_sbr_entry *entry;
+       u16 pci_bctl = 0;
+       int err = 0;
+
+       /* Call helper to get the device list needed for the device type. */
+       err = pciback_get_sbr_list(dev, &sbr_list,
+                       (dev_type == PCIBACK_TYPE_PCIe_ENDPOINT ? 1 : 0));
+       if (err) {
+               dev_warn(&dev->dev, 
+                       "secondary bus reset failed for device - all functions 
need to be co-assigned - err: %d\n", err);
+               return err;
+       }
+
+       pci_block_user_cfg_access(dev);
+
+       /* Reset the secondary bus and restore the PCI space for all the devfn 
found above.
+        */
+       pci_read_config_word(sbr_list.bridge, PCI_BRIDGE_CONTROL, &pci_bctl);
+       pci_write_config_word(sbr_list.bridge, PCI_BRIDGE_CONTROL, pci_bctl | 
PCI_BRIDGE_CTL_BUS_RESET);
+       msleep(200);
+       pci_write_config_word(sbr_list.bridge, PCI_BRIDGE_CONTROL, pci_bctl);
+       msleep(200);
+       
+       list_for_each_entry(entry, &sbr_list.dev_list, dev_list) {
+               pciback_reload_config_space(entry->dev);
+       }
+       
+       pci_unblock_user_cfg_access(dev);
+
+       pciback_cleanup_sbr_list(&sbr_list);
+
+       return 0;
+}
+
+/* This function is used to do a function level reset on a singe 
+ * device/function. FLRs must be done on devices before they are 
+ * unassigned from one domain and passed through to another. The 
+ * preferred method is to do an actual FLR on the device but the 
+ * functionality may not be present or exposed. In the later case
+ * we attempt to locate the capability even though it is not 
+ * chained into the capabilities list.
+ *
+ * In some cases, there is no way to perform the actual FLR so we 
+ * fall back to some alternate methods (which are not as effective
+ * or useful).
+ */
+void pciback_flr_device(struct pci_dev *dev)
+{
+       struct pciback_dev_data *dev_data = pci_get_drvdata(dev);
+       int err = 0;
+
+       if (dev_data->no_flr) {
+               dev_dbg(&dev->dev, "FLR disabled for device\n");
+               return;
+       }
+       dev_dbg(&dev->dev, "FLR invoked for device\n");
+
+       do {
+               /* First, always try to do an FLR */
+               if (dev_data->dev_type == PCIBACK_TYPE_PCIe_ENDPOINT &&
+                       dev_data->exp_flr_offset != 0) {
+                       pciback_do_pcie_flr(dev, dev_data->exp_flr_offset);
+                       break;
+               }
+               if (dev_data->dev_type == PCIBACK_TYPE_PCI &&
+                       dev_data->af_flr_offset != 0) {
+                       pciback_do_pci_flr(dev, dev_data->af_flr_offset, 1);
+                       break;
+               }
+               
+               /* Next for integrated devices on the host bus 0, try some 
other methods */
+               if (dev->bus->number == 0) {
+                       err = pciback_do_vendor_specific_reset(dev);
+                       if (err && dev_data->use_d3r)
+                               err = pciback_do_dstate_transition_reset(dev);
+                       if (err)
+                               dev_warn(&dev->dev, "FLR functionality not 
supported; "
+                                               "attempts to use vendor FLR or 
D-states unsuccessful\n");
+                       break;
+               }
+
+               /* Else attempt a secondary bus reset if all conditions are met 
*/
+               if (dev_data->use_sbr) {
+                       err = pciback_do_secondary_bus_reset(dev, 
dev_data->dev_type);
+                       if (err)
+                               dev_warn(&dev->dev, "FLR functionality not 
supported; "
+                                               "attempts to use secondary bus 
reset unsuccessful;\n");
+                       break;
+               }
+
+               err = -ENODEV;          
+       } while (0);
+
+       if (err)
+               dev_warn(&dev->dev, "FLR not performed for device\n");
+}
+
+/* Helper used to location the FLR capabilities for a PCIe device.
+ * When the capability cannot be found in the chain but is present,
+ * special logic is used to attempt to locate functionality.
+ *
+ * returns: the offset to the capability, zero if not found.
+ */
+static int pciback_find_pcie_flr_caps(struct pci_dev *dev)
+{
+       int exp_pos;
+       u32 cap = 0;
+
+       /* First look for the PCIe FLR capabilities using the capabilities list 
*/
+       exp_pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
+       if (exp_pos) {
+               pci_read_config_dword(dev, exp_pos + PCI_EXP_DEVCAP, &cap);
+               if (cap & PCI_EXP_DEVCAP_FLR) {
+                       return exp_pos;
+               }
+       }
+
+       return 0;
+}
+
+/* Helper used to location the AF FLR capabilities for a PCI device.
+ * When the capability cannot be found in the chain but is present,
+ * special logic is used to attempt to locate functionality.
+ *
+ * returns: the offset to the capability, zero if not found.
+ */
+static int pciback_find_pci_flr_caps(struct pci_dev *dev)
+{
+       struct pci_dev *gmch;
+       int af_pos;
+       u16 device_id;
+       u8 cap = 0, reg8 = 0;
+
+       /* First look for the PCI AF capabilities for FLR using the 
capabilities list. This
+        * is only used on the devices on the root/host bus (integrated 
devices). 
+        */
+       if (dev->bus->number != 0)
+               return 0;
+
+       af_pos = pci_find_capability(dev, PCI_CAP_ID_AF);
+       if (af_pos) {
+               pci_read_config_byte(dev, af_pos + PCI_AF_DEVCAP, &cap);
+               if (cap & PCI_AF_CAP_FLR) {
+                       return af_pos;
+               }
+       }
+
+       /* Next look for the unchained AF capabilities for FLR using specific 
+        * logic. Currently only the graphics device on the Intel Q45 etc 
+        * systems has special logic for locating the hidden FLR caps.
+     */
+       do {
+               if (dev->bus->number != 0 || dev->devfn != PCI_DEVFN(2,0) ||
+                       dev->vendor != PCIBACK_VENDOR_INTEL || (dev->class >> 
8) != PCIBACK_CLASS_ID_VGA)
+                       break;
+
+               /* Locate the GMCH (north bridge) and test for specific Intel 
devices */
+               gmch = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
+               if (!gmch)
+                       break;
+
+               device_id = gmch->device;
+               pci_dev_put(gmch);
+
+               if (device_id != PCI_DEVICE_ID_INTEL_GMCHQ45 &&
+                       device_id != PCI_DEVICE_ID_INTEL_GMCHG45 &&
+                       device_id != PCI_DEVICE_ID_INTEL_GMCHG41)
+                       break;
+               
+               /* Correct device and platform, assume AF offset */
+               af_pos = PCIBACK_IGFX_CAP13_OFFSET;
+               pci_read_config_byte(dev, af_pos + PCI_AF_LENFLD, &reg8);
+               if (reg8 == PCI_AF_LENGTH) {
+                       pci_read_config_byte(dev, af_pos + PCI_AF_DEVCAP, &cap);
+                       if (cap & PCI_AF_CAP_FLR) {
+                               return af_pos;
+                       }
+               }
+       } while (0);
+
+       /* Else not found */
+       return 0;
+}
+
+/* Classify the device, specifically determine if it is PCIe/PCI 
+ * and whether it is a PCIe endpoint, bridge, or other PCI device. 
+ */
+void pciback_classify_device(struct pci_dev *dev)
+{
+       struct pciback_dev_data *dev_data;
+       int exp_pos;
+       u16 exp_caps = 0;
+
+       dev_data = pci_get_drvdata(dev);
+       dev_data->dev_type = PCIBACK_TYPE_UNKNOWN;
+
+       exp_pos = pci_find_capability(dev, PCI_CAP_ID_EXP);
+       
+       if ((dev->class >> 8) != DEV_CLASS_PCI_PCI_BRIDGE) {
+               if (exp_pos != 0) {
+                       dev_data->dev_type = PCIBACK_TYPE_PCIe_ENDPOINT;
+                       dev_data->exp_flr_offset = 
pciback_find_pcie_flr_caps(dev);
+               } else {
+                       dev_data->dev_type = PCIBACK_TYPE_PCI;
+                       dev_data->af_flr_offset = 
pciback_find_pci_flr_caps(dev);
+               }
+               goto classify_done;
+       }
+       
+       if (exp_pos == 0) {
+               dev_data->dev_type = PCIBACK_TYPE_PCI_BRIDGE;
+               goto classify_done;
+       }
+
+       pci_read_config_word(dev, exp_pos + PCI_EXP_FLAGS, &exp_caps);
+       dev_data->dev_type = (((exp_caps & PCI_EXP_FLAGS_TYPE) >> 4) == 
PCI_EXP_TYPE_PCI_BRIDGE) ? PCIBACK_TYPE_PCI_BRIDGE : PCIBACK_TYPE_PCIe_BRIDGE;
+
+classify_done:
+
+       return;
+}
+
 extern wait_queue_head_t aer_wait_queue;
 extern struct workqueue_struct *pciback_wq;
 /*
@@ -132,3 +720,51 @@ irqreturn_t pciback_handle_event(int irq
 
        return IRQ_HANDLED;
 }
+
+/* Helper routine used to parse command line parameters passed to the 
+ * pciback module from the boot loader. These params all have the form
+ * of a list of one or more devices, e.g.:
+ * (XXXX:XX:XX.X)(XXXX:XX:XX.X)
+ * Which is: (domain/segment:bus:dev.func)
+ */
+int pciback_parse_device_params(const char *device_args, int type, 
+                       int (*add_func) (int domain, int bus, int slot, int 
func, int type))
+{
+       int pos = 0;
+       int err = 0;
+       int domain, bus, slot, func;
+       int parsed;
+
+       if (device_args && *device_args) {
+               do {
+                       parsed = 0;
+
+                       err = sscanf(device_args + pos,
+                                    " (%x:%x:%x.%x) %n",
+                                    &domain, &bus, &slot, &func, &parsed);
+                       if (err != 4) {
+                               domain = 0;
+                               err = sscanf(device_args + pos,
+                                            " (%x:%x.%x) %n",
+                                            &bus, &slot, &func, &parsed);
+                               if (err != 3)
+                                       goto parse_error;
+                       }
+
+                       err = add_func(domain, bus, slot, func, type);
+                       if (err)
+                               goto out;
+
+                       /* if parsed<=0, we've reached the end of the string */
+                       pos += parsed;
+               } while (parsed > 0 && device_args[pos]);
+       }
+
+out:
+       return err;
+
+parse_error:
+       printk(KERN_ERR "pciback: Error parsing device parameters \"%s\" at 
\"%s\"\n",
+              device_args, device_args + pos);
+       return -EINVAL;
+}
diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/drivers/xen/pciback/pci_stub.c 
b/linux-2.6.18-xen.hg/drivers/xen/pciback/pci_stub.c
--- a/linux-2.6.18-xen.hg/drivers/xen/pciback/pci_stub.c        2009-06-07 
20:48:21.000000000 -0400
+++ b/linux-2.6.18-xen.hg/drivers/xen/pciback/pci_stub.c        2009-06-07 
19:04:11.000000000 -0400
@@ -24,10 +24,28 @@ wait_queue_head_t aer_wait_queue;
 * We want to avoid in middle of AER ops, pciback devices is being removed
 */
 static DECLARE_RWSEM(pcistub_sem);
-module_param_named(hide, pci_devs_to_hide, charp, 0444);
+module_param_named(hide, pci_devs_to_hide, charp, S_IRUGO);
+
+static char *pci_devs_use_sbr = NULL;
+module_param_named(sbr, pci_devs_use_sbr, charp, S_IRUGO);
+
+static char *pci_devs_use_d3r = NULL;
+module_param_named(d3r, pci_devs_use_d3r, charp, S_IRUGO);
+
+static char *pci_devs_no_flr = NULL;
+module_param_named(noflr, pci_devs_no_flr, charp, S_IRUGO);
+
+/* Device id list holding different device type listings
+ * for hiding devices and reset logic.
+ */
+#define PCIBACK_ID_TYPE_HIDE  1
+#define PCIBACK_ID_TYPE_SBR   2
+#define PCIBACK_ID_TYPE_D3R   3
+#define PCIBACK_ID_TYPE_NOFLR 4
 
 struct pcistub_device_id {
        struct list_head slot_list;
+       int type;
        int domain;
        unsigned char bus;
        unsigned int devfn;
@@ -56,6 +74,8 @@ static LIST_HEAD(pcistub_devices);
 static int initialize_devices = 0;
 static LIST_HEAD(seized_devices);
 
+static int disable_all_flr = 0;
+
 static struct pcistub_device *pcistub_device_alloc(struct pci_dev *dev)
 {
        struct pcistub_device *psdev;
@@ -78,6 +98,23 @@ static struct pcistub_device *pcistub_de
        return psdev;
 }
 
+static struct pciback_dev_data *pcistub_dev_data_alloc(struct pci_dev *dev)
+{
+       struct pciback_dev_data *dev_data;
+
+       dev_dbg(&dev->dev, "pcistub_dev_data_alloc\n");
+
+       dev_data = kzalloc(sizeof(*dev_data) + dev->cfg_size, GFP_ATOMIC);
+       if (!dev_data)
+               return NULL;
+               
+       pci_set_drvdata(dev, dev_data);
+
+       dev_data->cfg_space = (u8*)(dev_data) + sizeof(*dev_data);
+
+       return dev_data;
+}
+
 /* Don't call this directly as it's called by pcistub_device_put */
 static void pcistub_device_release(struct kref *kref)
 {
@@ -200,7 +237,7 @@ struct pci_dev *pcistub_get_pci_dev(stru
        return found_dev;
 }
 
-void pcistub_put_pci_dev(struct pci_dev *dev)
+void pcistub_put_pci_dev(struct pci_dev *dev, int do_flr)
 {
        struct pcistub_device *psdev, *found_psdev = NULL;
        unsigned long flags;
@@ -220,6 +257,13 @@ void pcistub_put_pci_dev(struct pci_dev 
        * pcistub and pciback when AER is in processing
        */
        down_write(&pcistub_sem);
+
+       /* For pass-through devices, do an FLR (or approximate) for the device
+        * before it is put back and ready for the next domain
+        */
+       if (!disable_all_flr && do_flr)
+               pciback_flr_device(dev);
+
        /* Cleanup our device
         * (so it's ready for the next domain)
         */
@@ -235,6 +279,43 @@ void pcistub_put_pci_dev(struct pci_dev 
        up_write(&pcistub_sem);
 }
 
+struct pci_dev *pcistub_ref_pci_dev(struct pci_dev *dev)
+{
+       struct pcistub_device *psdev;
+       struct pci_dev *found_dev = NULL;
+       unsigned long flags;
+
+       spin_lock_irqsave(&pcistub_devices_lock, flags);
+
+       list_for_each_entry(psdev, &pcistub_devices, dev_list) {
+               if (psdev->dev == dev) {
+                       pcistub_device_get(psdev); /* just a ref count */
+                       found_dev = psdev->dev;
+                       break;
+               }
+       }
+
+       spin_unlock_irqrestore(&pcistub_devices_lock, flags);
+       return found_dev;
+}
+
+void pcistub_unref_pci_dev(struct pci_dev *dev)
+{
+       struct pcistub_device *psdev;
+       unsigned long flags;
+
+       spin_lock_irqsave(&pcistub_devices_lock, flags);
+
+       list_for_each_entry(psdev, &pcistub_devices, dev_list) {
+               if (psdev->dev == dev) {
+                       pcistub_device_get(psdev); /* just an unref count */
+                       break;
+               }
+       }
+
+       spin_unlock_irqrestore(&pcistub_devices_lock, flags);
+}
+
 static int __devinit pcistub_match_one(struct pci_dev *dev,
                                       struct pcistub_device_id *pdev_id)
 {
@@ -255,7 +336,7 @@ static int __devinit pcistub_match_one(s
        return 0;
 }
 
-static int __devinit pcistub_match(struct pci_dev *dev)
+static int __devinit pcistub_match(struct pci_dev *dev, int type)
 {
        struct pcistub_device_id *pdev_id;
        unsigned long flags;
@@ -263,6 +344,8 @@ static int __devinit pcistub_match(struc
 
        spin_lock_irqsave(&device_ids_lock, flags);
        list_for_each_entry(pdev_id, &pcistub_device_ids, slot_list) {
+               if (pdev_id->type != type)
+                       continue;
                if (pcistub_match_one(dev, pdev_id)) {
                        found = 1;
                        break;
@@ -285,12 +368,11 @@ static int __devinit pcistub_init_device
         * would need to be called somewhere to free the memory allocated
         * here and then to call kfree(pci_get_drvdata(psdev->dev)).
         */
-       dev_data = kzalloc(sizeof(*dev_data), GFP_ATOMIC);
+       dev_data = pcistub_dev_data_alloc(dev);
        if (!dev_data) {
                err = -ENOMEM;
                goto out;
        }
-       pci_set_drvdata(dev, dev_data);
 
        dev_dbg(&dev->dev, "initializing config\n");
 
@@ -317,6 +399,22 @@ static int __devinit pcistub_init_device
        dev_dbg(&dev->dev, "reset device\n");
        pciback_reset_device(dev);
 
+       /* Classify the device so we know if it is PCI/PCIe and if it is
+        * a bridge - this information is used for FLR logic. Also store 
+        * values if SBR/D3R reset logic was requested.
+        */
+       pciback_classify_device(dev);
+       dev_data->no_flr = pcistub_match(dev, PCIBACK_ID_TYPE_NOFLR);
+       if (!dev_data->no_flr) {
+               dev_data->use_sbr = pcistub_match(dev, PCIBACK_ID_TYPE_SBR);
+               dev_data->use_d3r = pcistub_match(dev, PCIBACK_ID_TYPE_D3R);
+       }
+
+       /* Store the config space here where the device is off and ready to be 
+        * exported before any FLRs or other resets are done
+        */
+       pciback_store_config_space(dev);
+
        return 0;
 
       config_release:
@@ -414,7 +512,7 @@ static int __devinit pcistub_probe(struc
 
        dev_dbg(&dev->dev, "probing...\n");
 
-       if (pcistub_match(dev)) {
+       if (pcistub_match(dev, PCIBACK_ID_TYPE_HIDE)) {
 
                if (dev->hdr_type != PCI_HEADER_TYPE_NORMAL
                    && dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
@@ -851,7 +949,7 @@ static inline int str_to_quirk(const cha
        return -EINVAL;
 }
 
-static int pcistub_device_id_add(int domain, int bus, int slot, int func)
+static int pcistub_device_id_add(int domain, int bus, int slot, int func, int 
type)
 {
        struct pcistub_device_id *pci_dev_id;
        unsigned long flags;
@@ -860,12 +958,13 @@ static int pcistub_device_id_add(int dom
        if (!pci_dev_id)
                return -ENOMEM;
 
+       pci_dev_id->type = type;
        pci_dev_id->domain = domain;
        pci_dev_id->bus = bus;
        pci_dev_id->devfn = PCI_DEVFN(slot, func);
 
-       pr_debug("pciback: wants to seize %04x:%02x:%02x.%01x\n",
-                domain, bus, slot, func);
+       pr_debug("pciback: adding device ID type: %d for %04x:%02x:%02x.%01x\n",
+                type, domain, bus, slot, func);
 
        spin_lock_irqsave(&device_ids_lock, flags);
        list_add_tail(&pci_dev_id->slot_list, &pcistub_device_ids);
@@ -874,7 +973,7 @@ static int pcistub_device_id_add(int dom
        return 0;
 }
 
-static int pcistub_device_id_remove(int domain, int bus, int slot, int func)
+static int pcistub_device_id_remove(int domain, int bus, int slot, int func, 
int type)
 {
        struct pcistub_device_id *pci_dev_id, *t;
        int devfn = PCI_DEVFN(slot, func);
@@ -884,7 +983,7 @@ static int pcistub_device_id_remove(int 
        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
+               if (pci_dev_id->type == type && pci_dev_id->domain == domain
                    && pci_dev_id->bus == bus && pci_dev_id->devfn == devfn) {
                        /* Don't break; here because it's possible the same
                         * slot could be in the list more than once
@@ -939,6 +1038,32 @@ static int pcistub_reg_add(int domain, i
        return err;
 }
 
+static int pcistub_device_do_flr(int domain, int bus, int slot, int func)
+{
+       int err = 0;
+       struct pcistub_device *psdev;
+       struct pci_dev *dev;
+
+       psdev = pcistub_device_find(domain, bus, slot, func);
+       if (!psdev || !psdev->dev) {
+               err = -ENODEV;
+               goto out;
+       }
+       dev = psdev->dev;
+
+       /* Do an FLR (or approximate) for the device on demand and 
+        * reload config
+        */
+       if (!disable_all_flr) {
+               pciback_flr_device(dev);
+       }
+       else
+               dev_dbg(&dev->dev, "FLR disabled for all devices\n");
+
+out:
+       return err;
+}
+
 static ssize_t pcistub_slot_add(struct device_driver *drv, const char *buf,
                                size_t count)
 {
@@ -949,7 +1074,7 @@ static ssize_t pcistub_slot_add(struct d
        if (err)
                goto out;
 
-       err = pcistub_device_id_add(domain, bus, slot, func);
+       err = pcistub_device_id_add(domain, bus, slot, func, 
PCIBACK_ID_TYPE_HIDE);
 
       out:
        if (!err)
@@ -969,7 +1094,7 @@ static ssize_t pcistub_slot_remove(struc
        if (err)
                goto out;
 
-       err = pcistub_device_id_remove(domain, bus, slot, func);
+       err = pcistub_device_id_remove(domain, bus, slot, func, 
PCIBACK_ID_TYPE_HIDE);
 
       out:
        if (!err)
@@ -987,6 +1112,10 @@ static ssize_t pcistub_slot_show(struct 
 
        spin_lock_irqsave(&device_ids_lock, flags);
        list_for_each_entry(pci_dev_id, &pcistub_device_ids, slot_list) {
+               /* only want devices set for hide, not reset entries */
+               if (pci_dev_id->type != PCIBACK_ID_TYPE_HIDE)
+                       continue;
+
                if (count >= PAGE_SIZE)
                        break;
 
@@ -1068,7 +1197,7 @@ static ssize_t pcistub_quirk_show(struct
 
 DRIVER_ATTR(quirks, S_IRUSR | S_IWUSR, pcistub_quirk_show, pcistub_quirk_add);
 
-static ssize_t permissive_add(struct device_driver *drv, const char *buf,
+static ssize_t pcistub_permissive_add(struct device_driver *drv, const char 
*buf,
                              size_t count)
 {
        int domain, bus, slot, func;
@@ -1109,7 +1238,7 @@ static ssize_t permissive_add(struct dev
        return err;
 }
 
-static ssize_t permissive_show(struct device_driver *drv, char *buf)
+static ssize_t pcistub_permissive_show(struct device_driver *drv, char *buf)
 {
        struct pcistub_device *psdev;
        struct pciback_dev_data *dev_data;
@@ -1132,7 +1261,68 @@ static ssize_t permissive_show(struct de
        return count;
 }
 
-DRIVER_ATTR(permissive, S_IRUSR | S_IWUSR, permissive_show, permissive_add);
+DRIVER_ATTR(permissive, S_IRUSR | S_IWUSR, pcistub_permissive_show, 
pcistub_permissive_add);
+
+static ssize_t pcistub_do_flr(struct device_driver *drv, const char *buf,
+                                  size_t count)
+{
+       int domain, bus, slot, func;
+       int err;
+
+       err = str_to_slot(buf, &domain, &bus, &slot, &func);
+       if (err)
+               goto out;
+
+       err = pcistub_device_do_flr(domain, bus, slot, func);
+
+out:
+       if (!err)
+               err = count;
+       return err;
+}
+
+DRIVER_ATTR(do_flr, S_IWUSR, NULL, pcistub_do_flr);
+
+static ssize_t pcistub_resets(struct device_driver *drv, const char *buf,
+                                  size_t count)
+{
+       int domain, bus, slot, func;
+       int type, err = 0;
+
+       /* string begins with reset type specifier sbr=|dr3=|noflr= */
+       if (!strncmp(buf, "sbr=", 4)) {
+               type = PCIBACK_ID_TYPE_SBR;
+               buf += 4;
+       } else if (!strncmp(buf, "d3r=", 4)) {
+               type = PCIBACK_ID_TYPE_D3R;
+               buf += 4;
+       } else if (!strncmp(buf, "noflr=", 6)) {
+               type = PCIBACK_ID_TYPE_NOFLR;
+               buf += 6;
+       } else {
+               err = -EINVAL;
+               goto out;
+       }
+
+       /* check special wildcard noflr */
+       if (type == PCIBACK_ID_TYPE_NOFLR && !strncmp(buf, "(*)", 3)) {
+               disable_all_flr = 1;
+               goto out;
+       }
+
+       err = str_to_slot(buf, &domain, &bus, &slot, &func);
+       if (err)
+               goto out;
+
+       err = pcistub_device_id_add(domain, bus, slot, func, type);
+
+out:
+       if (!err)
+               err = count;
+       return err;
+}
+
+DRIVER_ATTR(resets, S_IWUSR, NULL, pcistub_resets);
 
 #ifdef CONFIG_PCI_MSI
 
@@ -1158,6 +1348,8 @@ static void pcistub_exit(void)
        driver_remove_file(&pciback_pci_driver.driver, &driver_attr_slots);
        driver_remove_file(&pciback_pci_driver.driver, &driver_attr_quirks);
        driver_remove_file(&pciback_pci_driver.driver, &driver_attr_permissive);
+       driver_remove_file(&pciback_pci_driver.driver, &driver_attr_do_flr);
+       driver_remove_file(&pciback_pci_driver.driver, &driver_attr_resets);
 
        pci_unregister_driver(&pciback_pci_driver);
        WARN_ON(unregister_msi_get_owner(pciback_get_owner));
@@ -1165,35 +1357,27 @@ static void pcistub_exit(void)
 
 static int __init pcistub_init(void)
 {
-       int pos = 0;
        int err = 0;
-       int domain, bus, slot, func;
-       int parsed;
 
-       if (pci_devs_to_hide && *pci_devs_to_hide) {
-               do {
-                       parsed = 0;
-
-                       err = sscanf(pci_devs_to_hide + pos,
-                                    " (%x:%x:%x.%x) %n",
-                                    &domain, &bus, &slot, &func, &parsed);
-                       if (err != 4) {
-                               domain = 0;
-                               err = sscanf(pci_devs_to_hide + pos,
-                                            " (%x:%x.%x) %n",
-                                            &bus, &slot, &func, &parsed);
-                               if (err != 3)
-                                       goto parse_error;
-                       }
+       /* Parse device lists for hide, sbr, and d3r */
+       err = pciback_parse_device_params(pci_devs_to_hide, 
PCIBACK_ID_TYPE_HIDE, pcistub_device_id_add);
+       if (err)
+               goto out;
 
-                       err = pcistub_device_id_add(domain, bus, slot, func);
-                       if (err)
-                               goto out;
+       err = pciback_parse_device_params(pci_devs_use_sbr, 
PCIBACK_ID_TYPE_SBR, pcistub_device_id_add);
+       if (err)
+               goto out;
 
-                       /* if parsed<=0, we've reached the end of the string */
-                       pos += parsed;
-               } while (parsed > 0 && pci_devs_to_hide[pos]);
-       }
+       err = pciback_parse_device_params(pci_devs_use_d3r, 
PCIBACK_ID_TYPE_D3R, pcistub_device_id_add);
+       if (err)
+               goto out;
+
+       if (pci_devs_no_flr && *pci_devs_no_flr && !strncmp(pci_devs_no_flr, 
"(*)", 3))
+               disable_all_flr = 1; /* check special wildcard noflr */
+       else
+               err = pciback_parse_device_params(pci_devs_no_flr, 
PCIBACK_ID_TYPE_NOFLR, pcistub_device_id_add);
+       if (err)
+               goto out;
 
        /* If we're the first PCI Device Driver to register, we're the
         * first one to get offered PCI devices as they become
@@ -1217,6 +1401,12 @@ static int __init pcistub_init(void)
        if (!err)
                err = driver_create_file(&pciback_pci_driver.driver,
                                         &driver_attr_permissive);
+       if (!err)
+               err = driver_create_file(&pciback_pci_driver.driver,
+                                        &driver_attr_do_flr);
+       if (!err)
+               err = driver_create_file(&pciback_pci_driver.driver,
+                                        &driver_attr_resets);
 
        if (!err)
                err = register_msi_get_owner(pciback_get_owner);
@@ -1225,11 +1415,6 @@ static int __init pcistub_init(void)
 
       out:
        return err;
-
-      parse_error:
-       printk(KERN_ERR "pciback: Error parsing pci_devs_to_hide at \"%s\"\n",
-              pci_devs_to_hide + pos);
-       return -EINVAL;
 }
 
 #ifndef MODULE
diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/drivers/xen/pciback/slot.c 
b/linux-2.6.18-xen.hg/drivers/xen/pciback/slot.c
--- a/linux-2.6.18-xen.hg/drivers/xen/pciback/slot.c    2009-06-07 
20:48:21.000000000 -0400
+++ b/linux-2.6.18-xen.hg/drivers/xen/pciback/slot.c    2009-06-07 
19:04:11.000000000 -0400
@@ -109,7 +109,7 @@ void pciback_release_pci_dev(struct pcib
        spin_unlock_irqrestore(&slot_dev->lock, flags);
 
        if (found_dev)
-               pcistub_put_pci_dev(found_dev);
+               pcistub_put_pci_dev(found_dev, 0);
 }
 
 int pciback_init_devices(struct pciback_device *pdev)
@@ -149,7 +149,7 @@ void pciback_release_devices(struct pcib
                for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
                        dev = slot_dev->slots[bus][slot];
                        if (dev != NULL)
-                               pcistub_put_pci_dev(dev);
+                               pcistub_put_pci_dev(dev, 0);
                }
 
        kfree(slot_dev);
diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/drivers/xen/pciback/vpci.c 
b/linux-2.6.18-xen.hg/drivers/xen/pciback/vpci.c
--- a/linux-2.6.18-xen.hg/drivers/xen/pciback/vpci.c    2009-06-07 
20:48:21.000000000 -0400
+++ b/linux-2.6.18-xen.hg/drivers/xen/pciback/vpci.c    2009-06-07 
19:04:11.000000000 -0400
@@ -162,7 +162,7 @@ void pciback_release_pci_dev(struct pcib
        spin_unlock_irqrestore(&vpci_dev->lock, flags);
 
        if (found_dev)
-               pcistub_put_pci_dev(found_dev);
+               pcistub_put_pci_dev(found_dev, 0);
 }
 
 int pciback_init_devices(struct pciback_device *pdev)
@@ -202,7 +202,7 @@ void pciback_release_devices(struct pcib
                list_for_each_entry_safe(e, tmp, &vpci_dev->dev_list[slot],
                                         list) {
                        list_del(&e->list);
-                       pcistub_put_pci_dev(e->dev);
+                       pcistub_put_pci_dev(e->dev, 0);
                        kfree(e);
                }
        }
diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/include/linux/pci_ids.h 
b/linux-2.6.18-xen.hg/include/linux/pci_ids.h
--- a/linux-2.6.18-xen.hg/include/linux/pci_ids.h       2009-06-07 
20:48:23.000000000 -0400
+++ b/linux-2.6.18-xen.hg/include/linux/pci_ids.h       2009-06-07 
19:04:11.000000000 -0400
@@ -2259,6 +2259,14 @@
 #define PCI_DEVICE_ID_INTEL_IXP2800    0x9004
 #define PCI_DEVICE_ID_INTEL_S21152BB   0xb152
 
+#define PCI_DEVICE_ID_INTEL_GMCHQ45 0x2e10
+#define PCI_DEVICE_ID_INTEL_GMCHG45 0x2e20
+#define PCI_DEVICE_ID_INTEL_MCHP45  0x2e20
+#define PCI_DEVICE_ID_INTEL_GMCHG41 0x2e30
+#define PCI_DEVICE_ID_INTEL_GMCHGM45 0x2a40
+
+#define PCI_DEVICE_ID_INTEL_GMCHG41 0x2e30
+
 #define PCI_VENDOR_ID_SCALEMP          0x8686
 #define PCI_DEVICE_ID_SCALEMP_VSMP_CTL 0x1010
 
diff -rupN --ignore-blank-lines-X diffignore 
a/linux-2.6.18-xen.hg/include/linux/pci_regs.h 
b/linux-2.6.18-xen.hg/include/linux/pci_regs.h
--- a/linux-2.6.18-xen.hg/include/linux/pci_regs.h      2009-06-07 
20:48:23.000000000 -0400
+++ b/linux-2.6.18-xen.hg/include/linux/pci_regs.h      2009-06-07 
19:04:11.000000000 -0400
@@ -201,6 +201,7 @@
 #define  PCI_CAP_ID_SHPC       0x0C    /* PCI Standard Hot-Plug Controller */
 #define  PCI_CAP_ID_EXP        0x10    /* PCI Express */
 #define  PCI_CAP_ID_MSIX       0x11    /* MSI-X */
+#define  PCI_CAP_ID_AF      0x13    /* Advanced Features Capability */
 #define PCI_CAP_LIST_NEXT      1       /* Next capability in the list */
 #define PCI_CAP_FLAGS          2       /* Capability defined flags (16 bits) */
 #define PCI_CAP_SIZEOF         4
@@ -229,6 +230,11 @@
 #define  PCI_PM_CTRL_DATA_SEL_MASK     0x1e00  /* Data select (??) */
 #define  PCI_PM_CTRL_DATA_SCALE_MASK   0x6000  /* Data scale (??) */
 #define  PCI_PM_CTRL_PME_STATUS        0x8000  /* PME pin status */
+#define  PCI_PM_CTRL_DATA_DSTATE_MASK 0x3      /* D0 - D3 */
+#define  PCI_PM_CTRL_D0 0x0
+#define  PCI_PM_CTRL_D1 0x1
+#define  PCI_PM_CTRL_D2 0x2
+#define  PCI_PM_CTRL_D3HOT 0x3
 #define PCI_PM_PPB_EXTENSIONS  6       /* PPB support extensions (??) */
 #define  PCI_PM_PPB_B2_B3      0x40    /* Stop clock when in D3hot (??) */
 #define  PCI_PM_BPCC_ENABLE    0x80    /* Bus power/clock control enable (??) 
*/
@@ -346,6 +352,7 @@
 #define  PCI_EXP_DEVCAP_PWR_IND        0x4000  /* Power Indicator Present */
 #define  PCI_EXP_DEVCAP_PWR_VAL        0x3fc0000 /* Slot Power Limit Value */
 #define  PCI_EXP_DEVCAP_PWR_SCL        0xc000000 /* Slot Power Limit Scale */
+#define  PCI_EXP_DEVCAP_FLR     0x10000000 /* Function Level Reset */
 #define PCI_EXP_DEVCTL         8       /* Device Control */
 #define  PCI_EXP_DEVCTL_CERE   0x0001  /* Correctable Error Reporting En. */
 #define  PCI_EXP_DEVCTL_NFERE  0x0002  /* Non-Fatal Error Reporting Enable */
@@ -358,6 +365,7 @@
 #define  PCI_EXP_DEVCTL_AUX_PME        0x0400  /* Auxiliary Power PM Enable */
 #define  PCI_EXP_DEVCTL_NOSNOOP_EN 0x0800  /* Enable No Snoop */
 #define  PCI_EXP_DEVCTL_READRQ 0x7000  /* Max_Read_Request_Size */
+#define  PCI_EXP_DEVCTL_BCR_FLR 0x8000  /* Bridge Configuration Retry / FLR */
 #define PCI_EXP_DEVSTA         10      /* Device Status */
 #define  PCI_EXP_DEVSTA_CED    0x01    /* Correctable Error Detected */
 #define  PCI_EXP_DEVSTA_NFED   0x02    /* Non-Fatal Error Detected */
@@ -482,6 +490,17 @@
 #define  PCI_ARI_CTRL_ACS      0x0002  /* ACS Function Groups Enable */
 #define  PCI_ARI_CTRL_FG(x)    (((x) >> 4) & 7) /* Function Group */
 
+/* Advanced Features Capability */
+#define PCI_AF_LENFLD    0x02 /* Device length offset */
+#define  PCI_AF_LENGTH   0x06
+#define PCI_AF_DEVCAP    0x03 /* Device capabilities offset */
+#define  PCI_AF_CAP_TP   0x01
+#define  PCI_AF_CAP_FLR  0x02
+#define PCI_AF_CTRL      0x04 /* Device CTRL offset */
+#define  PCI_AF_CTRL_FLR 0x01
+#define PCI_AF_STA       0x05 /* Device STATUS offset */
+#define  PCI_AF_STA_TP   0x01
+ 
 /* Single Root I/O Virtualization */
 #define PCI_SRIOV_CAP          0x04    /* SR-IOV Capabilities */
 #define  PCI_SRIOV_CAP_VFM     0x01    /* VF Migration Capable */
diff -rupN --ignore-blank-lines-X diffignore 
a/tools/firmware/hvmloader/hvmloader.c b/tools/firmware/hvmloader/hvmloader.c
--- a/tools/firmware/hvmloader/hvmloader.c      2009-06-07 20:44:47.000000000 
-0400
+++ b/tools/firmware/hvmloader/hvmloader.c      2009-06-07 19:04:11.000000000 
-0400
@@ -673,6 +673,7 @@ int main(void)
         break;
     default:
         printf("No emulated VGA adaptor ...\n");
+        vgabios_sz = round_option_rom((*(uint8_t 
*)(VGABIOS_PHYSICAL_ADDRESS+2)) * 512);
         break;
     }
 
diff -rupN --ignore-blank-lines-X diffignore a/tools/ioemu-remote/console.h 
b/tools/ioemu-remote/console.h
--- a/tools/ioemu-remote/console.h      2009-06-07 21:14:47.000000000 -0400
+++ b/tools/ioemu-remote/console.h      2009-06-07 19:04:11.000000000 -0400
@@ -290,6 +290,9 @@ void vga_hw_update(void);
 void vga_hw_invalidate(void);
 void vga_hw_screen_dump(const char *filename);
 
+void unset_vga_acc(void);
+void set_vga_acc(void);
+
 int is_graphic_console(void);
 int is_fixedsize_console(void);
 CharDriverState *text_console_init(const char *p);
@@ -341,4 +344,9 @@ const char *readline_get_history(unsigne
 void readline_start(const char *prompt, int is_password,
                     ReadLineFunc *readline_func, void *opaque);
 
+/* intel.c */
+int intel_enter(void);
+int intel_leave(void);
+void intel_display_init(DisplayState *ds);
+
 #endif
diff -rupN --ignore-blank-lines-X diffignore 
a/tools/ioemu-remote/hw/pass-through.c b/tools/ioemu-remote/hw/pass-through.c
--- a/tools/ioemu-remote/hw/pass-through.c      2009-06-07 21:14:48.000000000 
-0400
+++ b/tools/ioemu-remote/hw/pass-through.c      2009-06-07 19:04:11.000000000 
-0400
@@ -90,6 +90,8 @@
 #include "qemu-xen.h"
 #include <unistd.h>
 
+extern int vga_passthrough;
+
 struct php_dev {
     struct pt_dev *pt_dev;
     uint8_t valid;
@@ -1573,10 +1575,11 @@ static int pt_dev_is_virtfn(struct pci_d
 
 static int pt_register_regions(struct pt_dev *assigned_device)
 {
-    int i = 0;
+    int i = 0, ret = 0;
     uint32_t bar_data = 0;
     struct pci_dev *pci_dev = assigned_device->pci_dev;
     PCIDevice *d = &assigned_device->dev;
+    uint16_t class, vendor_id;
 
     /* Register PIO/MMIO BARs */
     for ( i = 0; i < PCI_BAR_ENTRIES; i++ )
@@ -1632,6 +1635,25 @@ static int pt_register_regions(struct pt
             (uint32_t)(pci_dev->rom_size), (uint32_t)(pci_dev->rom_base_addr));
     }
 
+    /* Map legacy ioport and iomem, for specific devices */
+    vendor_id = pci_read_word(pci_dev, 0x00);
+    class = pci_read_word(pci_dev, 0x0a);
+
+    PT_LOG("Real device vendor_id=0x%x class=0x%x\n", vendor_id, class);
+    if ( vga_passthrough && class == 0x0300 )
+    {
+        PT_LOG("add an intel graphic card\n");
+
+        ret = xc_domain_ioport_mapping(xc_handle, domid, 0x3B0, 0x3B0, 0xb, 
DPCI_ADD_MAPPING);
+        ret = xc_domain_ioport_mapping(xc_handle, domid, 0x3C0, 0x3C0, 32, 
DPCI_ADD_MAPPING);
+        ret |= xc_domain_memory_mapping(xc_handle, domid, 0xa0, 0xa0, 32, 
DPCI_ADD_MAPPING);
+        if ( ret != 0 )
+        {
+            PT_LOG("legacy mapping failed!\n");
+            return ret;
+        }
+    }
+
     return 0;
 }
 
@@ -1640,6 +1662,7 @@ static void pt_unregister_regions(struct
     int i, type, ret;
     uint32_t e_size;
     PCIDevice *d = (PCIDevice*)assigned_device;
+    uint16_t class, vendor_id;
 
     for ( i = 0; i < PCI_NUM_REGIONS; i++ )
     {
@@ -1681,6 +1704,24 @@ static void pt_unregister_regions(struct
 
     }
 
+    /* unmap legacy ioport and iomem, for specific devices */
+    vendor_id = pci_read_word(assigned_device->pci_dev, 0x00);
+    class = pci_read_word(assigned_device->pci_dev, 0x0a);
+    
+    PT_LOG("Real device vendor_id=0x%x class=0x%x\n", vendor_id, class);
+    if ( vga_passthrough && class == 0x0300 )
+    {
+        PT_LOG("remove an intel graphic card\n");
+
+        ret = xc_domain_ioport_mapping(xc_handle, domid, 0x3B0, 0x3B0, 0xb, 
DPCI_REMOVE_MAPPING);
+        ret = xc_domain_ioport_mapping(xc_handle, domid, 0x3C0, 0x3C0, 32, 
DPCI_REMOVE_MAPPING);
+        ret |= xc_domain_memory_mapping(xc_handle, domid, 0xa0, 0xa0, 32, 
DPCI_REMOVE_MAPPING);
+        if ( ret != 0 )
+        {
+            PT_LOG("legacy unmapping failed !\n");
+        }
+    }
+
 }
 
 static uint8_t find_cap_offset(struct pci_dev *pci_dev, uint8_t cap)
@@ -3759,7 +3800,7 @@ static struct pt_dev * register_real_dev
     struct pci_config_cf8 machine_bdf;
     char *key, *val;
     int msi_translate, power_mgmt;
-
+    
     PT_LOG("Assigning real physical device %02x:%02x.%x ...\n",
         r_bus, r_dev, r_func);
 
@@ -3931,7 +3972,7 @@ static struct pt_dev * register_real_dev
     }
 
 out:
-    PT_LOG("Real physical device %02x:%02x.%x registered successfuly!\n"
+    PT_LOG("Real physical device %02x:%02x.%x registered successfully!\n"
            "IRQ type = %s\n", r_bus, r_dev, r_func,
            assigned_device->msi_trans_en? "MSI-INTx":"INTx");
 
@@ -4113,3 +4154,47 @@ err:
     return status;
 }
 
+u8 pt_pci_host_read_byte(int bus, int dev, int fn, u32 addr)
+{
+    struct pci_dev *pci_dev;
+    u8             val;
+
+    pci_dev = pci_get_dev(dpci_infos.pci_access, 0, bus, dev, fn);
+    if (!pci_dev)
+        return 0;
+
+    val = pci_read_byte(pci_dev, addr);
+    pci_free_dev(pci_dev);
+
+    return val;
+}
+
+u16 pt_pci_host_read_word(int bus, int dev, int fn, u32 addr)
+{
+    struct pci_dev *pci_dev;
+    u16             val;
+
+    pci_dev = pci_get_dev(dpci_infos.pci_access, 0, bus, dev, fn);
+    if (!pci_dev)
+        return 0;
+
+    val = pci_read_word(pci_dev, addr);
+    pci_free_dev(pci_dev);
+
+    return val;
+}
+
+u32 pt_pci_host_read_long(int bus, int dev, int fn, u32 addr)
+{
+    struct pci_dev *pci_dev;
+    u32             val;
+
+    pci_dev = pci_get_dev(dpci_infos.pci_access, 0, bus, dev, fn);
+    if (!pci_dev)
+        return 0;
+
+    val = pci_read_long(pci_dev, addr);
+    pci_free_dev(pci_dev);
+
+    return val;
+}
diff -rupN --ignore-blank-lines-X diffignore a/tools/ioemu-remote/hw/pc.c 
b/tools/ioemu-remote/hw/pc.c
--- a/tools/ioemu-remote/hw/pc.c        2009-06-07 21:14:47.000000000 -0400
+++ b/tools/ioemu-remote/hw/pc.c        2009-06-07 19:04:11.000000000 -0400
@@ -65,6 +65,8 @@ void tpm_tis_init(SetIRQFunc *set_irq, v
 extern uint8_t *acpi_tables;
 extern size_t acpi_tables_len;
 
+extern int vga_passthrough;
+
 static fdctrl_t *floppy_controller;
 static RTCState *rtc_state;
 static PITState *pit;
@@ -984,6 +986,7 @@ vga_bios_error:
 
     register_ioport_write(0xf0, 1, 1, ioportF0_write, NULL);
 
+    if (!vga_passthrough) {
     if (cirrus_vga_enabled) {
         if (pci_enabled) {
             pci_cirrus_vga_init(pci_bus,
@@ -1010,6 +1013,7 @@ vga_bios_error:
                          vga_ram_addr, vga_ram_size);
         }
     }
+    }
 
 #ifdef CONFIG_PASSTHROUGH
     /* Pass-through Initialization
diff -rupN --ignore-blank-lines-X diffignore a/tools/ioemu-remote/hw/pci.c 
b/tools/ioemu-remote/hw/pci.c
--- a/tools/ioemu-remote/hw/pci.c       2009-06-07 21:14:47.000000000 -0400
+++ b/tools/ioemu-remote/hw/pci.c       2009-06-07 19:04:11.000000000 -0400
@@ -28,11 +28,14 @@
 #include "virtio-net.h"
 #include "sysemu.h"
 
+#include "pass-through.h"
 #include "exec-all.h"
 #include "qemu-xen.h"
 
 //#define DEBUG_PCI
 
+extern int vga_passthrough;
+
 struct PCIBus {
     int bus_num;
     int devfn_min;
@@ -611,7 +614,24 @@ uint32_t pci_data_read(void *opaque, uin
         goto the_end;
     }
     config_addr = addr & 0xff;
-    val = pci_dev->config_read(pci_dev, config_addr, len);
+    if (vga_passthrough && pci_dev->devfn == 0x00) //Host Bridge
+    {
+        val = pci_dev->config_read(pci_dev, config_addr, len);
+
+        if (config_addr == 0x52) // GMCH
+            val = pt_pci_host_read_word(0, 0, 0, 0x52);
+        if (config_addr == 0x02) // Device ID
+        {
+            if (len == 2)
+                val = pt_pci_host_read_word(0, 0, 0, 0x00);
+            else if (len == 4)
+                val = pt_pci_host_read_long(0, 0, 0, 0x00);
+        }
+    } else if (vga_passthrough && pci_dev->devfn == 0x10 && // intel graphic 
card
+               config_addr == 0xfc) // OpRegion address
+        val = 0; // force to fall back to SMI mode
+    else
+        val = pci_dev->config_read(pci_dev, config_addr, len);
 #if defined(DEBUG_PCI)
     printf("pci_config_read: %s: addr=%02x val=%08x len=%d\n",
            pci_dev->name, config_addr, val, len);
diff -rupN --ignore-blank-lines-X diffignore a/tools/ioemu-remote/hw/vga.c 
b/tools/ioemu-remote/hw/vga.c
--- a/tools/ioemu-remote/hw/vga.c       2009-06-07 21:14:47.000000000 -0400
+++ b/tools/ioemu-remote/hw/vga.c       2009-06-07 19:04:11.000000000 -0400
@@ -34,9 +34,9 @@
 
 #include "qemu-timer.h"
 
-//#define DEBUG_VGA
-//#define DEBUG_VGA_MEM
-//#define DEBUG_VGA_REG
+#define DEBUG_VGA
+#define DEBUG_VGA_MEM
+#define DEBUG_VGA_REG
 
 //#define DEBUG_BOCHS_VBE
 
@@ -161,6 +161,18 @@ static uint8_t expand4to8[16];
 static void vga_bios_init(VGAState *s);
 static void vga_screen_dump(void *opaque, const char *filename);
 
+static VGAState *xen_vga_state;
+
+void set_vga_acc(void)
+{
+    set_vram_mapping(xen_vga_state, xen_vga_state->lfb_addr, 
xen_vga_state->lfb_end);
+}
+
+void unset_vga_acc(void)
+{
+    unset_vram_mapping(xen_vga_state);
+}
+
 static void vga_dumb_update_retrace_info(VGAState *s)
 {
     (void) s;
@@ -2473,8 +2485,6 @@ static void vga_bios_init(VGAState *s)
 }
 
 
-static VGAState *xen_vga_state;
-
 /* Allocate video memory in the GPFN space */
 void xen_vga_populate_vram(uint64_t vram_addr, uint32_t vga_ram_size)
 {
diff -rupN --ignore-blank-lines-X diffignore a/tools/ioemu-remote/intel.c 
b/tools/ioemu-remote/intel.c
--- a/tools/ioemu-remote/intel.c        1969-12-31 19:00:00.000000000 -0500
+++ b/tools/ioemu-remote/intel.c        2009-06-07 19:04:11.000000000 -0400
@@ -0,0 +1,494 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <signal.h>
+#include <pci/pci.h>
+
+#include "qemu-common.h"
+#include "console.h"
+#include "sysemu.h"
+
+#define INTEL_DEBUG(format, args...)                                    \
+    fprintf (stderr, "intel.c:%d:%s " format , __LINE__, __func__, ## args)
+
+#define TileW           128
+#define TileH           8
+
+#define REG_DR_DSPASURF                0x7019C
+#define REG_DR_DSPACNTR                0x70180
+#define REG_DR_DSPASTRIDE      0x70188
+#define REG_DR_PIPEACONF       0x70008
+
+#define REG_DR_DSPBSURF                0x7119C
+#define REG_DR_DSPBCNTR                0x71180
+#define REG_DR_DSPBSTRIDE      0x71188
+#define REG_DR_PIPEBCONF       0x71008
+
+#define REG_DE_PIPEASRC                0x6001c
+
+extern int                      vga_passthrough;
+uint32_t                        guest_framebuffer;
+
+static int                      display = 0;
+
+static int                      mmio_fd = -1;
+static int                      mem_fd = -1;
+static uint8_t                  *intel_mem = NULL;
+static uint8_t                  *intel_mmio = NULL;
+static int                      intel_force_full_update = 0;
+static int                      intel_have_focus;
+static int                      IntelPitch = 16;
+static int                      IntelX = 1280;
+static int                      IntelY = 1024;
+static DisplayState             *lds = NULL;
+static uint8_t                  *old_data = NULL;
+static uint32_t                 intel_fb_base, intel_mmio_base;
+static uint32_t                 map_s, map_d, map_size;
+static int                      refresh;
+
+static void set_data_mappings(void);
+static void unset_data_mappings(int mapping);
+static void set_data_pointer(void);
+static void intel_resize(DisplayState *ds);
+
+static inline unsigned int intel_get_reg(unsigned int reg)
+{
+    return *(unsigned int*)(intel_mmio + reg);
+}
+
+static inline int is_linear(void)
+{
+    unsigned int *dspacntr = (unsigned int *)(intel_mmio + REG_DR_DSPACNTR);
+    if (((*dspacntr) & (1 << 10)) == 0)
+        return 1;
+    else
+        return 0;
+}
+
+static inline unsigned int intel_get_pitch(void)
+{
+    unsigned int *dspastride = (unsigned int *)(intel_mmio + 
REG_DR_DSPASTRIDE);
+    return *dspastride;
+}
+
+static inline unsigned int intel_get_offset(DisplaySurface *ds, int x, int y)
+{
+    return (y * ds->width + x) * 4;
+}
+
+static void intel_update_linear(DisplaySurface *ds, int x, int y, int w, int h)
+{
+    int i, bpp = ds->pf.depth / 8;
+    unsigned char *s, *d;
+    s = ds->data;
+    d = (unsigned char *)(intel_mem + intel_get_reg(REG_DR_DSPASURF));
+    s += (ds->linesize * y) + bpp * x;
+    d += (ds->linesize * y) + bpp * x;
+    for (i = 0; i < h; i++) {
+        memcpy(d, s, w * bpp);
+        s += ds->linesize;
+        d += ds->linesize;
+    }
+}
+
+static void intel_force_linear(int linesize)
+{
+    unsigned int *dspacntr = (unsigned int *)(intel_mmio + REG_DR_DSPACNTR);
+    unsigned int *pipeaconf = (unsigned int *)(intel_mmio + REG_DR_PIPEACONF);
+    unsigned int *dspasurf = (unsigned int *)(intel_mmio + REG_DR_DSPASURF);
+    unsigned int *dspastride = (unsigned int *)(intel_mmio + 
REG_DR_DSPASTRIDE);
+
+    unsigned int *dspbcntr = (unsigned int *)(intel_mmio + REG_DR_DSPBCNTR);
+    unsigned int *pipebconf = (unsigned int *)(intel_mmio + REG_DR_PIPEBCONF);
+    unsigned int *dspbsurf = (unsigned int *)(intel_mmio + REG_DR_DSPBSURF);
+    unsigned int *dspbstride = (unsigned int *)(intel_mmio + 
REG_DR_DSPBSTRIDE);
+
+    unsigned int surfa = 0, surfb = 0, pipea = 0, pipeb = 0;
+    char pipebenabled = !!(*pipebconf & (1 << 30));
+
+
+    INTEL_DEBUG("DSPASURF CTRL: 0x%x\n", intel_get_reg(REG_DR_DSPACNTR));
+
+    /* Disable surface */
+    pipea = *pipeaconf & (0x3 << 18);
+    *pipeaconf &= ~(0x3 << 18);
+    *dspacntr |= (1 << 31);
+    /* Address of the surface to map to */
+    surfa = *dspasurf;
+    *dspasurf = 0x00000000;
+    *dspacntr &= ~(1 << 31);
+    *dspasurf = 0x00000000;
+    *pipeaconf |= pipea;
+
+    if (pipebenabled) {
+        INTEL_DEBUG("PIPEBCONF enabled.\n");
+
+        /* Disable surface */
+        pipeb = *pipebconf & (0x3 << 18);
+        *pipebconf &= ~(0x3 << 18);
+        *dspbcntr |= (1 << 31);
+        /* Address of the surface to map to */
+        surfb = *dspbsurf;
+        *dspbsurf = 0x00000000;
+        *dspbcntr &= ~(1 << 31);
+        *dspbsurf = 0x00000000;
+        *pipebconf |= pipeb;
+    }
+
+    usleep(20000);
+
+    *pipeaconf &= ~(0x3 << 18);
+    /* Enable surface linear mode */
+    *dspacntr &= ~(1 << 10);
+    if (linesize) *dspastride = linesize;
+    *dspasurf = surfa;
+    *dspacntr |= (1 << 31);
+    *pipeaconf |= pipea;
+
+    if (pipebenabled) {
+        *pipebconf &= ~(0x3 << 18);
+        /* Enable surface linear mode */
+        *dspbcntr &= ~(1 << 10);
+        if (linesize) *dspbstride = linesize;
+        *dspbsurf = surfb;
+        *dspbcntr |= (1 << 31);
+        *pipebconf |= pipeb;
+    }
+
+    usleep(20000);
+}
+
+static void intel_update(DisplayState *ds, int x, int y, int w, int h)
+{
+    if (intel_have_focus && !old_data && !map_size)
+        intel_update_linear(ds->surface, x, y, w, h);
+}
+
+static void set_fb_mapping(void)
+{
+    DisplaySurface *surf = lds->surface;
+    int rc;
+    unsigned long nr_pfn;
+
+    unset_vga_acc();
+    fprintf(stderr, "set_fb_mapping: %x %x\n", (intel_fb_base + 
intel_get_reg(REG_DR_DSPASURF)), guest_framebuffer);
+    nr_pfn = (surf->linesize * surf->height) >> TARGET_PAGE_BITS;
+
+    rc = xc_domain_memory_mapping(xc_handle,
+            domid,
+            (guest_framebuffer >> TARGET_PAGE_BITS),
+            ((intel_fb_base + intel_get_reg(REG_DR_DSPASURF)) >> 
TARGET_PAGE_BITS),
+            nr_pfn,
+            DPCI_ADD_MAPPING);
+    if (rc) {
+        fprintf(stderr, "xc_domain_memory_mapping failed %d\n", rc);
+        return;
+    }
+    map_s = ((intel_fb_base + intel_get_reg(REG_DR_DSPASURF)) >> 
TARGET_PAGE_BITS);
+    map_d = (guest_framebuffer >> TARGET_PAGE_BITS);
+    map_size = nr_pfn;
+}
+
+static void unset_fb_mapping(void)
+{
+    int rc;
+
+    fprintf(stderr, "unset_fb_mapping: %x %x\n", map_d, map_s);
+
+    rc = xc_domain_memory_mapping(xc_handle,
+            domid,
+            map_d,
+            map_s,
+            map_size,
+            DPCI_REMOVE_MAPPING);
+    if (rc) {
+        fprintf(stderr, "xc_domain_memory_mapping failed %d\n", rc);
+        return;
+    }
+
+    set_vga_acc();
+    map_s = 0;
+    map_d = 0;
+    map_size = 0;
+}
+
+static void intel_setdata(DisplayState *ds)
+{
+    if (map_size)
+        unset_fb_mapping();
+    set_fb_mapping();
+}
+
+static void intel_resize_shared(DisplayState *ds, int w, int h, int depth, int 
linesize, void *pixels)
+{
+    DisplaySurface *surf = ds->surface;
+
+    if (!intel_have_focus) {
+        surf->width = w;
+        surf->height = h;
+        intel_resize(ds);
+        return;
+    }
+    if (depth == 32 && w == IntelX && h == IntelY)
+        surf->flags = QEMU_ALLOCATED_FLAG;
+    else
+        surf->flags &= ~QEMU_ALLOCATED_FLAG;
+    if (surf->flags & QEMU_ALLOCATED_FLAG) {
+        surf->width = w;
+        surf->height = h;
+        surf->pf.depth = 32;
+        surf->linesize = linesize;
+        /* adjust linesize */
+        intel_force_linear(linesize);
+        set_data_mappings();
+        if (refresh) {
+            memcpy(surf->data, pixels, surf->linesize * surf->height);
+            refresh = 0;
+        }
+        surf->data = pixels;
+        intel_setdata(ds);
+    } else {
+        surf->width = w;
+        surf->height = h;
+        intel_resize(ds);
+    }
+}
+
+static void intel_resize(DisplayState *ds)
+{
+    DisplaySurface *surf = ds->surface;
+    int old_linesize = surf->linesize;
+
+    if (surf->pf.depth == 32 && surf->width == IntelX && surf->height == 
IntelY)
+      surf->flags = QEMU_ALLOCATED_FLAG;
+    else
+      surf->flags &= ~QEMU_ALLOCATED_FLAG;
+
+    if (is_buffer_shared(surf))
+    {
+      INTEL_DEBUG("intel_resize_shared: enable shared buffer, linesize %d\n",
+                  surf->linesize);
+      intel_force_linear(surf->linesize);
+      set_data_mappings();
+      if (refresh)
+      {
+        // Pixels doesn't exist anymore ??
+        //memcpy(surf->data, pixels, surf->linesize * surf->height);
+        refresh = 0;
+      }
+      intel_setdata(ds);
+      return;
+    }
+    
+    INTEL_DEBUG("intel_resize: no shared buffer, linesize=%d\n", 
surf->linesize);
+    surf->linesize = intel_get_pitch();
+    if (map_size) {
+        unset_fb_mapping();
+        unset_data_mappings(1);
+    }
+    if (intel_have_focus && !is_linear()) {
+        intel_force_linear(0);
+    }
+    surf->flags &= ~QEMU_ALLOCATED_FLAG;
+    if (intel_have_focus && !old_data &&
+        surf->width * surf->height <= IntelX * IntelY)
+        set_data_mappings();
+    else if (intel_have_focus && old_data &&
+             surf->width * surf->height > IntelX * IntelY)
+        unset_data_mappings(0);
+    if (!old_data) {
+        qemu_free(surf->data);
+        surf->data = qemu_mallocz(surf->height * surf->linesize);
+    } else {
+        INTEL_DEBUG("intel_resize: set_data_pointer\n");
+        set_data_pointer();
+    }
+    if (intel_have_focus)
+        memset((unsigned char *)(intel_mem + intel_get_reg(REG_DR_DSPASURF)), 
0x0, IntelX * IntelY);
+    if (refresh) {
+        if (old_data) {
+            unsigned char *s, *d;
+            int i;
+            s = old_data;
+            d = surf->data;
+            for (i = 0; i < surf->height; i++) {
+                memcpy(d, s, surf->width * 4);
+                s += old_linesize;
+                d += surf->linesize;
+            }
+        }
+        refresh = 0;
+    }
+}
+
+static void intel_refresh(DisplayState *ds)
+{
+    vga_hw_update();
+}
+
+static void intel_init_mapping(void)
+{
+    struct pci_access   *pci_bus;
+    struct pci_dev      *pci_dev;
+
+    mmio_fd = open("/dev/mem", O_RDWR);
+    if (mmio_fd == -1)
+    {
+        perror("open");
+        exit(1);
+    }
+    mem_fd = open("/dev/mem", O_RDWR);
+    if (mem_fd == -1)
+    {
+        perror("open");
+        exit(1);
+    }
+
+    pci_bus = pci_alloc();
+    pci_init(pci_bus);
+    pci_dev = pci_get_dev(pci_bus, 0, 0, 2, 0);
+    pci_fill_info(pci_dev, PCI_FILL_BASES);
+    intel_fb_base = pci_dev->base_addr[2] & 0xfffff000;
+    intel_mmio_base = pci_dev->base_addr[0] & 0xfffff000;
+    pci_free_dev(pci_dev);
+    pci_cleanup(pci_bus);
+
+    INTEL_DEBUG("Map intel main mem 0x%x\n", intel_fb_base);
+    intel_mem = mmap(NULL, 0x10000000, PROT_READ | PROT_WRITE, MAP_SHARED,
+                     mem_fd, intel_fb_base);
+    if (intel_mem == MAP_FAILED)
+    {
+        perror("mmap");
+        exit(1);
+    }
+
+    INTEL_DEBUG("Map intel mmio 0x%x\n", intel_mmio_base);
+    intel_mmio = mmap(NULL, 4 * 1024 * 1024, PROT_READ | PROT_WRITE, 
MAP_SHARED,
+                      mmio_fd, intel_mmio_base);
+    if (intel_mem == MAP_FAILED)
+    {
+        perror("mmap");
+        exit(1);
+    }
+}
+
+static void set_data_pointer(void)
+{
+    DisplaySurface *surf = lds->surface;
+
+    surf->data = (unsigned char *)(intel_mem + intel_get_reg(REG_DR_DSPASURF));
+    surf->data = surf->data +
+                surf->linesize * ((IntelY - surf->height) / 2) +
+                4 * ((IntelX - surf->width) / 2);
+}
+
+static void set_data_mappings(void)
+{
+    INTEL_DEBUG("set_data_mappings\n");
+    if (!old_data)
+        old_data = lds->surface->data;
+    set_data_pointer();
+}
+
+static void unset_data_mappings(int mapping)
+{
+    DisplaySurface *surf = lds->surface;
+    if (!old_data)
+        return;
+    if (mapping) {
+        uint8_t * buffer_pointer = surf->data;
+        surf->data = old_data;
+        old_data = NULL;
+        surf->data = realloc(surf->data, surf->linesize * surf->height);
+        memcpy(surf->data,
+                (unsigned char *)(intel_mem + intel_get_reg(REG_DR_DSPASURF)),
+                surf->linesize * surf->height);
+        memcpy(buffer_pointer,
+                surf->data,
+                surf->linesize * surf->height);
+    } else {
+        uint8_t * buffer_pointer = surf->data;
+        surf->data = old_data;
+        old_data = NULL;
+        surf->data = realloc(surf->data, surf->linesize * surf->height);
+        memcpy(surf->data,
+                buffer_pointer,
+                surf->linesize * surf->height);
+    }
+    INTEL_DEBUG("unset_data_mappings %d: success\n", mapping);
+}
+
+static int intel_getfocus(void)
+{
+    return intel_have_focus;
+}
+
+static void intel_focus(int focus)
+{
+    if (intel_have_focus == focus)
+        return;
+
+    INTEL_DEBUG("intel_focus %d\n", focus);
+    intel_have_focus = focus;
+    if (focus) {
+        if (!is_linear()) {
+           IntelPitch = intel_get_reg(REG_DR_DSPASTRIDE);
+           IntelX = ((intel_get_reg(REG_DE_PIPEASRC) >> 16) & 0xfff) + 1;
+           IntelY = (intel_get_reg(REG_DE_PIPEASRC) & 0xfff) + 1;
+           INTEL_DEBUG("Resolution is %dx%d\n", IntelX, IntelY);
+        }
+        refresh = 1;
+        lds->listeners->dpy_resize = intel_resize;
+        lds->listeners->dpy_setdata = intel_setdata;
+        vga_hw_invalidate();
+    } else {
+        if (map_size) {
+            unset_fb_mapping();
+            unset_data_mappings(1);
+        } else if (old_data) {
+            unset_data_mappings(0);
+        }
+        lds->listeners->dpy_resize = NULL;
+        lds->listeners->dpy_setdata = NULL;
+        lds->surface->flags &= ~QEMU_ALLOCATED_FLAG;
+    }
+}
+
+int intel_enter(void)
+{
+    intel_focus(1);
+    return 1;
+}
+
+int intel_leave(void)
+{
+    intel_focus(0);
+    return 1;
+}
+
+void intel_display_init(DisplayState *ds)
+{
+    DisplaySurface *surf = ds->surface;
+
+    INTEL_DEBUG("\n");
+
+    intel_init_mapping();
+
+    INTEL_DEBUG("Frambuffer is at 0x%x\n", intel_get_reg(REG_DR_DSPASURF));
+
+    surf->flags = 0;
+    surf->width = 640;
+    surf->height = 480;
+    surf->pf.depth = 32;
+    intel_resize(ds);
+    lds = ds;
+
+    ds->listeners->dpy_update = intel_update;
+    ds->listeners->dpy_resize = intel_resize;
+    ds->listeners->dpy_refresh = intel_refresh;
+}
\ No newline at end of file
diff -rupN --ignore-blank-lines-X diffignore a/tools/ioemu-remote/vl.c 
b/tools/ioemu-remote/vl.c
--- a/tools/ioemu-remote/vl.c   2009-06-07 21:14:47.000000000 -0400
+++ b/tools/ioemu-remote/vl.c   2009-06-07 19:29:12.000000000 -0400
@@ -233,6 +233,9 @@ CharDriverState *virtcon_hds[MAX_VIRTIO_
 #ifdef TARGET_I386
 int win2k_install_hack = 0;
 int rtc_td_hack = 0;
+int vga_passthrough = 0;
+const char *dom0_input = NULL;
+int intel = 0;
 #endif
 int usb_enabled = 0;
 int smp_cpus = 1;
@@ -4039,6 +4042,9 @@ static void help(int exitcode)
            "-disable-opengl disable OpenGL rendering, using SDL"
 #endif
 #endif
+           "-vga_passthrough enable graphics card passthrough\n"
+           "-dom0-input     enable dom0 controlling qemu\n"
+           "-intel          use intel gfx\n"
            "-portrait       rotate graphical output 90 deg left (only PXA 
LCD)\n"
            "-vga [std|cirrus|vmware|none]\n"
            "                select video card type\n"
@@ -4275,6 +4281,9 @@ enum {
     QEMU_OPTION_domainname,
     QEMU_OPTION_acpi,
     QEMU_OPTION_vcpus,
+    QEMU_OPTION_vga_passthrough,
+    QEMU_OPTION_dom0_input,
+    QEMU_OPTION_intel,
 
     /* Debug/Expert options: */
     QEMU_OPTION_serial,
@@ -4448,6 +4457,9 @@ static const QEMUOption qemu_options[] =
     { "pciemulation", HAS_ARG, QEMU_OPTION_pci_emulation },
     { "vncunused", 0, QEMU_OPTION_vncunused },
     { "vcpus", HAS_ARG, QEMU_OPTION_vcpus },
+    { "vga_passthrough", 0, QEMU_OPTION_vga_passthrough },
+    { "dom0-input", HAS_ARG, QEMU_OPTION_dom0_input },
+    { "intel", 0, QEMU_OPTION_intel },
 #if defined(CONFIG_XEN) && !defined(CONFIG_DM)
     { "xen-domid", HAS_ARG, QEMU_OPTION_xen_domid },
     { "xen-create", 0, QEMU_OPTION_xen_create },
@@ -5281,6 +5293,15 @@ int main(int argc, char **argv, char **e
             case QEMU_OPTION_disable_opengl:
                 opengl_enabled = 0;
                 break;
+            case QEMU_OPTION_vga_passthrough:
+                vga_passthrough = 1;
+                break;
+            case QEMU_OPTION_dom0_input:
+                dom0_input = optarg;
+                break;
+            case QEMU_OPTION_intel:
+                intel = 1;
+                break;
             case QEMU_OPTION_direct_pci:
                direct_pci = optarg;
                 break;
@@ -5876,6 +5897,14 @@ int main(int argc, char **argv, char **e
             fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
             exit(1);
         }
+
+#ifdef CONFIG_DM 
+        if(vga_passthrough)
+            fprintf(stderr, "Replace if initializing dom0_driver\n" );
+#else        
+        dumb_display_init(ds);
+#endif
+
     } else { 
 #if defined(CONFIG_CURSES)
             if (curses) {
diff -rupN --ignore-blank-lines-X diffignore a/tools/ioemu-remote/xen-hooks.mak 
b/tools/ioemu-remote/xen-hooks.mak
--- a/tools/ioemu-remote/xen-hooks.mak  2009-06-07 21:14:47.000000000 -0400
+++ b/tools/ioemu-remote/xen-hooks.mak  2009-06-07 19:04:12.000000000 -0400
@@ -35,6 +35,7 @@ OBJS += exec-dm.o
 OBJS += pci_emulation.o
 OBJS += helper2.o
 OBJS += battery_mgmt.o
+OBJS += intel.o
 
 ifdef CONFIG_STUBDOM
 CPPFLAGS += $(TARGET_CPPFLAGS) -DNEED_CPU_H \
diff -rupN --ignore-blank-lines-X diffignore a/tools/libxc/xc_hvm_build.c 
b/tools/libxc/xc_hvm_build.c
--- a/tools/libxc/xc_hvm_build.c        2009-06-07 20:44:47.000000000 -0400
+++ b/tools/libxc/xc_hvm_build.c        2009-06-07 19:04:12.000000000 -0400
@@ -1,7 +1,3 @@
-/******************************************************************************
- * xc_hvm_build.c
- */
-
 #include <stddef.h>
 #include <inttypes.h>
 #include <stdlib.h>
@@ -66,6 +62,82 @@ static void build_hvm_info(void *hvm_inf
     hvm_info->checksum = -sum;
 }
 
+static int init_vgabios(int            xc_handle,
+                        uint32_t       dom,
+                        unsigned char *buffer,
+                        uint32_t       bios_size)
+{
+    char                *va_bios = NULL;
+    uint32_t            va_size = 0;
+
+    va_size = bios_size + bios_size % XC_PAGE_SIZE;
+    va_bios = xc_map_foreign_range(xc_handle, dom, va_size,
+                                   PROT_READ | PROT_WRITE, 0xC0);
+    if (!va_bios)
+    {
+        IPRINTF("Unable to map vga bios!\n");
+        return -1;
+    }
+
+    if ( buffer != NULL)
+        memcpy(va_bios, buffer, bios_size);
+    else
+        memset(va_bios, 0, bios_size);
+
+    munmap(va_bios, va_size);
+    return 0;
+}
+
+static int  setup_vga_pt(int            xc_handle,
+                         uint32_t       dom)
+{
+    int                 rc = 0;
+    unsigned char       *bios = NULL;
+    int                 bios_size = 0;
+    char                *c = NULL;
+    char                checksum = 0;
+
+    IPRINTF("Setting up vga passthrough.\n");
+
+    /* Allocated 64K for the vga bios */
+    if (!(bios = malloc(64 * 1024))) {
+        IPRINTF("Error allocating memory for vga bios.\n");
+        return -1;
+    }
+
+#ifdef __linux__
+    bios_size = xc_get_vgabios(bios, 64 * 1024);
+#else
+    bios_size = 0;
+#endif /* __linux__ */
+
+    if (bios_size == 0)
+    {
+        IPRINTF("vga bios size is 0!\n");
+        rc = -1;
+        goto error;
+    }
+       
+    /* Adjust the bios checksum */
+    for ( c = (char*)bios; c < ((char*)bios + bios_size); c++ )
+        checksum += *c;
+    if (checksum)
+        bios[bios_size - 1] -= checksum;
+    init_vgabios(xc_handle, dom, bios, bios_size);    
+
+error:
+    free(bios);
+
+    if( rc == -1 ) {
+        IPRINTF("Error setting up vga passthrough.\n");
+    }
+    else {
+        IPRINTF("Success setting up vga passthrough.\n");
+    }
+
+    return rc;
+}
+
 static int loadelfimage(
     struct elf_binary *elf, int xch, uint32_t dom, unsigned long *parray)
 {
@@ -381,7 +453,8 @@ int xc_hvm_build_target_mem(int xc_handl
                            uint32_t domid,
                            int memsize,
                            int target,
-                           const char *image_name)
+                           const char *image_name,
+                           int vga_pt_enabled)
 {
     char *image;
     int  sts;
@@ -392,6 +465,12 @@ int xc_hvm_build_target_mem(int xc_handl
         return -1;
 
     sts = xc_hvm_build_internal(xc_handle, domid, memsize, target, image, 
image_size);
+    if ( vga_pt_enabled ) {
+        sts |= setup_vga_pt(xc_handle, domid);
+    } else {
+        sts |= init_vgabios(xc_handle, domid, NULL, 0x800);
+    }
+
 
     free(image);
 
diff -rupN --ignore-blank-lines-X diffignore a/tools/libxc/xc_linux.c 
b/tools/libxc/xc_linux.c
--- a/tools/libxc/xc_linux.c    2009-06-07 20:44:47.000000000 -0400
+++ b/tools/libxc/xc_linux.c    2009-06-07 19:04:12.000000000 -0400
@@ -562,6 +562,57 @@ int xc_gnttab_set_max_grants(int xcg_han
     return 0;
 }
 
+int xc_get_vgabios(unsigned char        *buf,
+                   int                  len)
+{
+    int         mem;
+    uint32_t    start, size = 0;
+    uint16_t    magic = 0;
+
+    start = 0xC0000;
+    if (len < size)
+        return 0;
+    if ((mem = open("/dev/mem", O_RDONLY)) < 0)
+        return 0;
+   
+    /*
+    ** Check if it a real bios extension.
+    ** The magic number is 0xAA55.
+    */
+    if (start != lseek(mem, start, SEEK_SET))
+        goto out;
+    if (read(mem, &magic, 2) != 2)
+        goto out;
+    if (magic != 0xAA55)
+        goto out;
+
+    /* Find the size of the rom extension */
+    if (start != lseek(mem, start, SEEK_SET))
+        goto out;
+    if (lseek(mem, 2, SEEK_CUR) != (start + 2))
+        goto out;
+    if (read(mem, &size, 1) != 1)
+        goto out;
+    /* This size is in 512K */
+    size *= 512;
+
+    /*
+    ** Set the file to the begining of the rombios,
+    ** to start the copy.
+    */
+    if (start != lseek(mem, start, SEEK_SET))
+    {
+        size = 0;
+        goto out;
+    }
+    if (size != read(mem, buf, size))
+        size = 0;
+
+out:
+    close(mem);
+    return size;
+}
+
 /*
  * Local variables:
  * mode: C
diff -rupN --ignore-blank-lines-X diffignore a/tools/libxc/xenctrl.h 
b/tools/libxc/xenctrl.h
--- a/tools/libxc/xenctrl.h     2009-06-07 20:44:47.000000000 -0400
+++ b/tools/libxc/xenctrl.h     2009-06-07 19:04:12.000000000 -0400
@@ -145,6 +145,10 @@ int xc_waitdomain(
     int *status,
     int options);
 
+int xc_get_vgabios(
+    unsigned char       *bios,
+    int                 len);
+
 #endif /* __linux__ */
 
 /*
diff -rupN --ignore-blank-lines-X diffignore a/tools/libxc/xenguest.h 
b/tools/libxc/xenguest.h
--- a/tools/libxc/xenguest.h    2009-06-07 20:44:47.000000000 -0400
+++ b/tools/libxc/xenguest.h    2009-06-07 19:04:12.000000000 -0400
@@ -134,7 +134,8 @@ int xc_hvm_build_target_mem(int xc_handl
                             uint32_t domid,
                             int memsize,
                             int target,
-                            const char *image_name);
+                            const char *image_name,
+                            int vga_pt_enabled);
 
 int xc_hvm_build_mem(int xc_handle,
                      uint32_t domid,
diff -rupN --ignore-blank-lines-X diffignore 
a/tools/python/xen/lowlevel/xc/xc.c b/tools/python/xen/lowlevel/xc/xc.c
--- a/tools/python/xen/lowlevel/xc/xc.c 2009-06-07 20:44:47.000000000 -0400
+++ b/tools/python/xen/lowlevel/xc/xc.c 2009-06-07 19:04:12.000000000 -0400
@@ -890,21 +890,21 @@ static PyObject *pyxc_hvm_build(XcObject
     int i;
 #endif
     char *image;
-    int memsize, target=-1, vcpus = 1, acpi = 0, apic = 1;
+    int memsize, target=-1, vcpus = 1, acpi = 0, apic = 1, vga_pt = 0;
 
     static char *kwd_list[] = { "domid",
                                 "memsize", "image", "target", "vcpus", "acpi",
-                                "apic", NULL };
-    if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iis|iiii", kwd_list,
+                                "apic", "vga_pt", NULL };
+    if ( !PyArg_ParseTupleAndKeywords(args, kwds, "iis|iiiii", kwd_list,
                                       &dom, &memsize, &image, &target, &vcpus,
-                                      &acpi, &apic) )
+                                      &acpi, &apic, &vga_pt) )
         return NULL;
 
     if ( target == -1 )
         target = memsize;
 
     if ( xc_hvm_build_target_mem(self->xc_handle, dom, memsize,
-                                 target, image) != 0 )
+                                 target, image, vga_pt) != 0 )
         return pyxc_error_to_exception();
 
 #if !defined(__ia64__)
diff -rupN --ignore-blank-lines-X diffignore a/tools/python/xen/xend/image.py 
b/tools/python/xen/xend/image.py
--- a/tools/python/xen/xend/image.py    2009-06-07 20:44:47.000000000 -0400
+++ b/tools/python/xen/xend/image.py    2009-06-07 19:04:12.000000000 -0400
@@ -279,6 +279,9 @@ class ImageHandler:
         vnc_config = {}
         has_vnc = int(vmConfig['platform'].get('vnc', 0)) != 0
         has_sdl = int(vmConfig['platform'].get('sdl', 0)) != 0
+        has_vga_passthrough = int(vmConfig['platform'].get('vga_passthrough', 
0)) != 0
+        has_intel = int(vmConfig['platform'].get('intel', 0)) != 0
+
         opengl = 1
         keymap = vmConfig['platform'].get("keymap")
         for dev_uuid in vmConfig['console_refs']:
@@ -302,7 +305,7 @@ class ImageHandler:
             ret.append("-k")
             ret.append(keymap)
 
-        if has_vnc:
+        if has_vnc and not has_vga_passthrough:
             if not vnc_config:
                 for key in ('vncunused', 'vnclisten', 'vncdisplay',
                             'vncpasswd'):
@@ -353,6 +356,15 @@ class ImageHandler:
 
         if int(vmConfig['platform'].get('monitor', 0)) != 0:
             ret = ret + ['-monitor', 'vc']
+
+        if has_vga_passthrough:
+            ret.append('-vga_passthrough')
+            dom0_input = str(vmConfig['platform'].get('dom0_input'))
+            ret = ret + ['-dom0-input', dom0_input]
+
+        if has_intel:
+            ret.append('-intel')
+
         return ret
 
     def getDeviceModelArgs(self, restore = False):
@@ -754,7 +766,9 @@ class HVMImageHandler(ImageHandler):
         self.apic = int(vmConfig['platform'].get('apic', 0))
         self.acpi = int(vmConfig['platform'].get('acpi', 0))
         self.guest_os_type = vmConfig['platform'].get('guest_os_type')
-
+        self.vga_pt = int(vmConfig['platform'].get('vga_passthrough', 0))
+        self.dom0_input = str(vmConfig['platform'].get('dom0_input'))
+        self.intel = int(vmConfig['platform'].get('intel', 0))
 
     # Return a list of cmd line args to the device models based on the
     # xm config file
@@ -869,6 +883,7 @@ class HVMImageHandler(ImageHandler):
         log.debug("vcpus          = %d", self.vm.getVCpuCount())
         log.debug("acpi           = %d", self.acpi)
         log.debug("apic           = %d", self.apic)
+        log.debug("vga_pt         = %d", self.vga_pt)
 
         rc = xc.hvm_build(domid          = self.vm.getDomid(),
                           image          = self.loader,
@@ -876,7 +891,8 @@ class HVMImageHandler(ImageHandler):
                           target         = mem_mb,
                           vcpus          = self.vm.getVCpuCount(),
                           acpi           = self.acpi,
-                          apic           = self.apic)
+                          apic           = self.apic,
+                          vga_pt         = self.vga_pt)
         rc['notes'] = { 'SUSPEND_CANCEL': 1 }
 
         rc['store_mfn'] = xc.hvm_get_param(self.vm.getDomid(),
diff -rupN --ignore-blank-lines-X diffignore 
a/tools/python/xen/xend/XendConfig.py b/tools/python/xen/xend/XendConfig.py
--- a/tools/python/xen/xend/XendConfig.py       2009-06-07 20:44:47.000000000 
-0400
+++ b/tools/python/xen/xend/XendConfig.py       2009-06-07 19:04:12.000000000 
-0400
@@ -171,6 +171,9 @@ XENAPI_PLATFORM_CFG_TYPES = {
     'pci_msitranslate': int,
     'pci_power_mgmt': int,
     'xen_platform_pci': int,
+    'vga_passthrough': int,
+    'dom0_input': str,
+    'intel': int,
 }
 
 # Xen API console 'other_config' keys.
diff -rupN --ignore-blank-lines-X diffignore a/tools/python/xen/xm/create.py 
b/tools/python/xen/xm/create.py
--- a/tools/python/xen/xm/create.py     2009-06-07 20:44:47.000000000 -0400
+++ b/tools/python/xen/xm/create.py     2009-06-07 19:04:12.000000000 -0400
@@ -618,6 +618,18 @@ gopts.var('xen_platform_pci', val='0|1',
            fn=set_int, default=1,
            use="Is xen_platform_pci used?")
 
+gopts.var('vga_passthrough', val='0|1',
+           fn=set_int, default=None,
+           use="Enable the passthrough for the graphic card.")
+
+gopts.var('dom0_input', val='DOM0_INPUT',
+           fn=set_value, default=None,
+           use="Input arguments for dom0 driver")
+
+gopts.var('intel', val='INTEL',
+           fn=set_int, default=None,
+           use="Use Intel GFX.")
+
 def err(msg):
     """Print an error to stderr and exit.
     """
@@ -932,7 +944,8 @@ def configure_hvm(config_image, vals):
              'acpi', 'apic', 'usb', 'usbdevice', 'keymap', 'pci', 'hpet',
              'guest_os_type', 'hap', 'opengl', 'cpuid', 'cpuid_check',
              'viridian', 'xen_extended_power_mgmt', 'pci_msitranslate',
-             'vpt_align', 'pci_power_mgmt', 'xen_platform_pci' ]
+             'vpt_align', 'pci_power_mgmt', 'xen_platform_pci',
+             'vga_passthrough', 'dom0_input', 'intel' ]
 
     for a in args:
         if a in vals.__dict__ and vals.__dict__[a] is not None:
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-devel

 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.