3 files changed, 169 insertions, 43 deletions

diff --git a/drivers/gpu/vga/Kconfig b/drivers/gpu/vga/Kconfig
index 8d0e31a22027..96c83a9a76bb 100644
--- a/drivers/gpu/vga/Kconfig
+++ b/drivers/gpu/vga/Kconfig
@@ -1,5 +1,5 @@
 config VGA_ARB
-        bool "VGA Arbitration" if EMBEDDED
+        bool "VGA Arbitration" if EXPERT
         default y
         depends on PCI
         help
diff --git a/drivers/gpu/vga/vga_switcheroo.c b/drivers/gpu/vga/vga_switcheroo.c
index c8768f38511e..58434e804d91 100644
--- a/drivers/gpu/vga/vga_switcheroo.c
+++ b/drivers/gpu/vga/vga_switcheroo.c
@@ -33,6 +33,7 @@ struct vga_switcheroo_client {
         struct fb_info *fb_info;
         int pwr_state;
         void (*set_gpu_state)(struct pci_dev *pdev, enum vga_switcheroo_state);
+        void (*reprobe)(struct pci_dev *pdev);
         bool (*can_switch)(struct pci_dev *pdev);
         int id;
         bool active;
@@ -103,6 +104,7 @@ static void vga_switcheroo_enable(void)
 
 int vga_switcheroo_register_client(struct pci_dev *pdev,
                                    void (*set_gpu_state)(struct pci_dev *pdev, enum vga_switcheroo_state),
+                                   void (*reprobe)(struct pci_dev *pdev),
                                    bool (*can_switch)(struct pci_dev *pdev))
 {
         int index;
@@ -117,6 +119,7 @@ int vga_switcheroo_register_client(struct pci_dev *pdev,
         vgasr_priv.clients[index].pwr_state = VGA_SWITCHEROO_ON;
         vgasr_priv.clients[index].pdev = pdev;
         vgasr_priv.clients[index].set_gpu_state = set_gpu_state;
+        vgasr_priv.clients[index].reprobe = reprobe;
         vgasr_priv.clients[index].can_switch = can_switch;
         vgasr_priv.clients[index].id = -1;
         if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
@@ -174,7 +177,8 @@ static int vga_switcheroo_show(struct seq_file *m, void *v)
         int i;
         mutex_lock(&vgasr_mutex);
         for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
-                seq_printf(m, "%d:%c:%s:%s\n", i,
+                seq_printf(m, "%d:%s:%c:%s:%s\n", i,
+                           vgasr_priv.clients[i].id == VGA_SWITCHEROO_DIS ? "DIS" : "IGD",
                            vgasr_priv.clients[i].active ? '+' : ' ',
                            vgasr_priv.clients[i].pwr_state ? "Pwr" : "Off",
                            pci_name(vgasr_priv.clients[i].pdev));
@@ -190,9 +194,8 @@ static int vga_switcheroo_debugfs_open(struct inode *inode, struct file *file)
 
 static int vga_switchon(struct vga_switcheroo_client *client)
 {
-        int ret;
-
-        ret = vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_ON);
+        if (vgasr_priv.handler->power_state)
+                vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_ON);
         /* call the driver callback to turn on device */
         client->set_gpu_state(client->pdev, VGA_SWITCHEROO_ON);
         client->pwr_state = VGA_SWITCHEROO_ON;
@@ -203,20 +206,18 @@ static int vga_switchoff(struct vga_switcheroo_client *client)
 {
         /* call the driver callback to turn off device */
         client->set_gpu_state(client->pdev, VGA_SWITCHEROO_OFF);
-        vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_OFF);
+        if (vgasr_priv.handler->power_state)
+                vgasr_priv.handler->power_state(client->id, VGA_SWITCHEROO_OFF);
         client->pwr_state = VGA_SWITCHEROO_OFF;
         return 0;
 }
 
-static int vga_switchto(struct vga_switcheroo_client *new_client)
+/* stage one happens before delay */
+static int vga_switchto_stage1(struct vga_switcheroo_client *new_client)
 {
-        int ret;
         int i;
         struct vga_switcheroo_client *active = NULL;
 
-        if (new_client->active == true)
-                return 0;
-
         for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
                 if (vgasr_priv.clients[i].active == true) {
                         active = &vgasr_priv.clients[i];
@@ -226,19 +227,32 @@ static int vga_switchto(struct vga_switcheroo_client *new_client)
         if (!active)
                 return 0;
 
-        /* power up the first device */
-        ret = pci_enable_device(new_client->pdev);
-        if (ret)
-                return ret;
-
         if (new_client->pwr_state == VGA_SWITCHEROO_OFF)
                 vga_switchon(new_client);
 
         /* swap shadow resource to denote boot VGA device has changed so X starts on new device */
-        active->active = false;
-
         active->pdev->resource[PCI_ROM_RESOURCE].flags &= ~IORESOURCE_ROM_SHADOW;
         new_client->pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW;
+        return 0;
+}
+
+/* post delay */
+static int vga_switchto_stage2(struct vga_switcheroo_client *new_client)
+{
+        int ret;
+        int i;
+        struct vga_switcheroo_client *active = NULL;
+
+        for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
+                if (vgasr_priv.clients[i].active == true) {
+                        active = &vgasr_priv.clients[i];
+                        break;
+                }
+        }
+        if (!active)
+                return 0;
+
+        active->active = false;
 
         if (new_client->fb_info) {
                 struct fb_event event;
@@ -250,6 +264,9 @@ static int vga_switchto(struct vga_switcheroo_client *new_client)
         if (ret)
                 return ret;
 
+        if (new_client->reprobe)
+                new_client->reprobe(new_client->pdev);
+
         if (active->pwr_state == VGA_SWITCHEROO_ON)
                 vga_switchoff(active);
 
@@ -265,6 +282,7 @@ vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf,
         const char *pdev_name;
         int i, ret;
         bool delay = false, can_switch;
+        bool just_mux = false;
         int client_id = -1;
         struct vga_switcheroo_client *client = NULL;
 
@@ -319,6 +337,15 @@ vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf,
         if (strncmp(usercmd, "DIS", 3) == 0)
                 client_id = VGA_SWITCHEROO_DIS;
 
+        if (strncmp(usercmd, "MIGD", 4) == 0) {
+                just_mux = true;
+                client_id = VGA_SWITCHEROO_IGD;
+        }
+        if (strncmp(usercmd, "MDIS", 4) == 0) {
+                just_mux = true;
+                client_id = VGA_SWITCHEROO_DIS;
+        }
+
         if (client_id == -1)
                 goto out;
 
@@ -330,6 +357,15 @@ vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf,
         }
 
         vgasr_priv.delayed_switch_active = false;
+
+        if (just_mux) {
+                ret = vgasr_priv.handler->switchto(client_id);
+                goto out;
+        }
+
+        if (client->active == true)
+                goto out;
+
         /* okay we want a switch - test if devices are willing to switch */
         can_switch = true;
         for (i = 0; i < VGA_SWITCHEROO_MAX_CLIENTS; i++) {
@@ -345,18 +381,22 @@ vga_switcheroo_debugfs_write(struct file *filp, const char __user *ubuf,
 
         if (can_switch == true) {
                 pdev_name = pci_name(client->pdev);
-                ret = vga_switchto(client);
+                ret = vga_switchto_stage1(client);
+                if (ret)
+                        printk(KERN_ERR "vga_switcheroo: switching failed stage 1 %d\n", ret);
+
+                ret = vga_switchto_stage2(client);
                 if (ret)
-                        printk(KERN_ERR "vga_switcheroo: switching failed %d\n", ret);
+                        printk(KERN_ERR "vga_switcheroo: switching failed stage 2 %d\n", ret);
+
         } else {
                 printk(KERN_INFO "vga_switcheroo: setting delayed switch to client %d\n", client->id);
                 vgasr_priv.delayed_switch_active = true;
                 vgasr_priv.delayed_client_id = client_id;
 
-                /* we should at least power up the card to
-                   make the switch faster */
-                if (client->pwr_state == VGA_SWITCHEROO_OFF)
-                        vga_switchon(client);
+                ret = vga_switchto_stage1(client);
+                if (ret)
+                        printk(KERN_ERR "vga_switcheroo: delayed switching stage 1 failed %d\n", ret);
         }
 
 out:
@@ -438,9 +478,9 @@ int vga_switcheroo_process_delayed_switch(void)
                 goto err;
 
         pdev_name = pci_name(client->pdev);
-        ret = vga_switchto(client);
+        ret = vga_switchto_stage2(client);
         if (ret)
-                printk(KERN_ERR "vga_switcheroo: delayed switching failed %d\n", ret);
+                printk(KERN_ERR "vga_switcheroo: delayed switching failed stage 2 %d\n", ret);
 
         vgasr_priv.delayed_switch_active = false;
         err = 0;
diff --git a/drivers/gpu/vga/vgaarb.c b/drivers/gpu/vga/vgaarb.c
index f366f968155a..8a1021f2e319 100644
--- a/drivers/gpu/vga/vgaarb.c
+++ b/drivers/gpu/vga/vgaarb.c
@@ -61,7 +61,7 @@ struct vga_device {
         unsigned int mem_lock_cnt;      /* legacy MEM lock count */
         unsigned int io_norm_cnt;       /* normal IO count */
         unsigned int mem_norm_cnt;      /* normal MEM count */
-
+        bool bridge_has_one_vga;
         /* allow IRQ enable/disable hook */
         void *cookie;
         void (*irq_set_state)(void *cookie, bool enable);
@@ -151,7 +151,7 @@ static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
 static void vga_check_first_use(void)
 {
         /* we should inform all GPUs in the system that
-         * VGA arb has occured and to try and disable resources
+         * VGA arb has occurred and to try and disable resources
          * if they can */
         if (!vga_arbiter_used) {
                 vga_arbiter_used = true;
@@ -165,6 +165,8 @@ static struct vga_device *__vga_tryget(struct vga_device *vgadev,
         unsigned int wants, legacy_wants, match;
         struct vga_device *conflict;
         unsigned int pci_bits;
+        u32 flags = 0;
+
         /* Account for "normal" resources to lock. If we decode the legacy,
          * counterpart, we need to request it as well
          */
@@ -237,16 +239,23 @@ static struct vga_device *__vga_tryget(struct vga_device *vgadev,
                 /* looks like he doesn't have a lock, we can steal
                  * them from him
                  */
-                vga_irq_set_state(conflict, false);
 
+                flags = 0;
                 pci_bits = 0;
-                if (lwants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
-                        pci_bits |= PCI_COMMAND_MEMORY;
-                if (lwants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
-                        pci_bits |= PCI_COMMAND_IO;
 
-                pci_set_vga_state(conflict->pdev, false, pci_bits,
-                                  change_bridge);
+                if (!conflict->bridge_has_one_vga) {
+                        vga_irq_set_state(conflict, false);
+                        flags |= PCI_VGA_STATE_CHANGE_DECODES;
+                        if (lwants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
+                                pci_bits |= PCI_COMMAND_MEMORY;
+                        if (lwants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
+                                pci_bits |= PCI_COMMAND_IO;
+                }
+
+                if (change_bridge)
+                        flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
+
+                pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
                 conflict->owns &= ~lwants;
                 /* If he also owned non-legacy, that is no longer the case */
                 if (lwants & VGA_RSRC_LEGACY_MEM)
@@ -261,14 +270,24 @@ enable_them:
          * also have in "decodes". We can lock resources we don't decode but
          * not own them.
          */
+        flags = 0;
         pci_bits = 0;
-        if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
-                pci_bits |= PCI_COMMAND_MEMORY;
-        if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
-                pci_bits |= PCI_COMMAND_IO;
-        pci_set_vga_state(vgadev->pdev, true, pci_bits, !!(wants & VGA_RSRC_LEGACY_MASK));
 
-        vga_irq_set_state(vgadev, true);
+        if (!vgadev->bridge_has_one_vga) {
+                flags |= PCI_VGA_STATE_CHANGE_DECODES;
+                if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
+                        pci_bits |= PCI_COMMAND_MEMORY;
+                if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
+                        pci_bits |= PCI_COMMAND_IO;
+        }
+        if (!!(wants & VGA_RSRC_LEGACY_MASK))
+                flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
+
+        pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
+
+        if (!vgadev->bridge_has_one_vga) {
+                vga_irq_set_state(vgadev, true);
+        }
         vgadev->owns |= (wants & vgadev->decodes);
 lock_them:
         vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
@@ -421,6 +440,62 @@ bail:
 }
 EXPORT_SYMBOL(vga_put);
 
+/* Rules for using a bridge to control a VGA descendant decoding:
+   if a bridge has only one VGA descendant then it can be used
+   to control the VGA routing for that device.
+   It should always use the bridge closest to the device to control it.
+   If a bridge has a direct VGA descendant, but also have a sub-bridge
+   VGA descendant then we cannot use that bridge to control the direct VGA descendant.
+   So for every device we register, we need to iterate all its parent bridges
+   so we can invalidate any devices using them properly.
+*/
+static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
+{
+        struct vga_device *same_bridge_vgadev;
+        struct pci_bus *new_bus, *bus;
+        struct pci_dev *new_bridge, *bridge;
+
+        vgadev->bridge_has_one_vga = true;
+
+        if (list_empty(&vga_list))
+                return;
+
+        /* okay iterate the new devices bridge hierarachy */
+        new_bus = vgadev->pdev->bus;
+        while (new_bus) {
+                new_bridge = new_bus->self;
+
+                if (new_bridge) {
+                        /* go through list of devices already registered */
+                        list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
+                                bus = same_bridge_vgadev->pdev->bus;
+                                bridge = bus->self;
+
+                                /* see if the share a bridge with this device */
+                                if (new_bridge == bridge) {
+                                        /* if their direct parent bridge is the same
+                                           as any bridge of this device then it can't be used
+                                           for that device */
+                                        same_bridge_vgadev->bridge_has_one_vga = false;
+                                }
+
+                                /* now iterate the previous devices bridge hierarchy */
+                                /* if the new devices parent bridge is in the other devices
+                                   hierarchy then we can't use it to control this device */
+                                while (bus) {
+                                        bridge = bus->self;
+                                        if (bridge) {
+                                                if (bridge == vgadev->pdev->bus->self)
+                                                        vgadev->bridge_has_one_vga = false;
+                                        }
+                                        bus = bus->parent;
+                                }
+                        }
+                }
+                new_bus = new_bus->parent;
+        }
+}
+
 /*
  * Currently, we assume that the "initial" setup of the system is
  * not sane, that is we come up with conflicting devices and let
@@ -500,6 +575,8 @@ static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
                 vga_default = pci_dev_get(pdev);
 #endif
 
+        vga_arbiter_check_bridge_sharing(vgadev);
+
         /* Add to the list */
         list_add(&vgadev->list, &vga_list);
         vga_count++;
@@ -636,7 +713,7 @@ int vga_client_register(struct pci_dev *pdev, void *cookie,
                         void (*irq_set_state)(void *cookie, bool state),
                         unsigned int (*set_vga_decode)(void *cookie, bool decode))
 {
-        int ret = -1;
+        int ret = -ENODEV;
         struct vga_device *vgadev;
         unsigned long flags;
 
@@ -774,7 +851,7 @@ static ssize_t vga_arb_read(struct file *file, char __user * buf,
          */
         spin_lock_irqsave(&vga_lock, flags);
 
-        /* If we are targetting the default, use it */
+        /* If we are targeting the default, use it */
         pdev = priv->target;
         if (pdev == NULL || pdev == PCI_INVALID_CARD) {
                 spin_unlock_irqrestore(&vga_lock, flags);
@@ -1211,6 +1288,7 @@ static const struct file_operations vga_arb_device_fops = {
         .poll = vga_arb_fpoll,
         .open = vga_arb_open,
         .release = vga_arb_release,
+        .llseek = noop_llseek,
 };
 
 static struct miscdevice vga_arb_device = {
@@ -1221,6 +1299,7 @@ static int __init vga_arb_device_init(void)
 {
         int rc;
         struct pci_dev *pdev;
+        struct vga_device *vgadev;
 
         rc = misc_register(&vga_arb_device);
         if (rc < 0)
@@ -1237,6 +1316,13 @@ static int __init vga_arb_device_init(void)
                 vga_arbiter_add_pci_device(pdev);
 
         pr_info("vgaarb: loaded\n");
+
+        list_for_each_entry(vgadev, &vga_list, list) {
+                if (vgadev->bridge_has_one_vga)
+                        pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev));
+                else
+                        pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev->pdev));
+        }
         return rc;
 }
 subsys_initcall(vga_arb_device_init);