During graphics driver initialization its useful to be able to mux only the DDC to the inactive client in order to read the EDID. Add a switch_ddc callback to allow capable handlers to provide this functionality, and add vga_switcheroo_switch_ddc() to allow DRM to mux only the DDC.

Signed-off-by: Seth Forshee seth.forshee@canonical.com --- drivers/gpu/vga/vga_switcheroo.c | 39 +++++++++++++++++++++++++++++++++++++- include/linux/vga_switcheroo.h | 4 ++++ 2 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/drivers/gpu/vga/vga_switcheroo.c b/drivers/gpu/vga/vga_switcheroo.c index e25cf31..ea6bcc2 100644 --- a/drivers/gpu/vga/vga_switcheroo.c +++ b/drivers/gpu/vga/vga_switcheroo.c @@ -252,6 +252,29 @@ void vga_switcheroo_client_fb_set(struct pci_dev *pdev, } EXPORT_SYMBOL(vga_switcheroo_client_fb_set);

+int vga_switcheroo_switch_ddc(struct pci_dev *pdev) +{ + int ret = 0; + int id; + + mutex_lock(&vgasr_mutex); + + if (!vgasr_priv.handler) { + ret = -ENODEV; + goto out; + } + + if (vgasr_priv.handler->switch_ddc) { + id = vgasr_priv.handler->get_client_id(pdev); + ret = vgasr_priv.handler->switch_ddc(id); + } + +out: + mutex_unlock(&vgasr_mutex); + return ret; +} +EXPORT_SYMBOL(vga_switcheroo_switch_ddc); + static int vga_switcheroo_show(struct seq_file *m, void *v) { struct vga_switcheroo_client *client; @@ -342,9 +365,15 @@ static int vga_switchto_stage2(struct vga_switcheroo_client *new_client) fb_notifier_call_chain(FB_EVENT_REMAP_ALL_CONSOLE, &event); }

+ if (vgasr_priv.handler->switch_ddc) { + ret = vgasr_priv.handler->switch_ddc(new_client->id); + if (ret) + return ret; + } + ret = vgasr_priv.handler->switchto(new_client->id); if (ret) - return ret; + goto restore_ddc;

if (new_client->ops->reprobe) new_client->ops->reprobe(new_client->pdev); @@ -356,6 +385,14 @@ static int vga_switchto_stage2(struct vga_switcheroo_client *new_client)

new_client->active = true; return 0; + +restore_ddc: + if (vgasr_priv.handler->switch_ddc) { + int id = (new_client->id == VGA_SWITCHEROO_IGD) ? + VGA_SWITCHEROO_DIS : VGA_SWITCHEROO_IGD; + ret = vgasr_priv.handler->switch_ddc(id); + } + return ret; }

static bool check_can_switch(void) diff --git a/include/linux/vga_switcheroo.h b/include/linux/vga_switcheroo.h index ddb419c..b0d0839 100644 --- a/include/linux/vga_switcheroo.h +++ b/include/linux/vga_switcheroo.h @@ -29,6 +29,7 @@ enum vga_switcheroo_client_id { };

struct vga_switcheroo_handler { + int (*switch_ddc)(enum vga_switcheroo_client_id id); int (*switchto)(enum vga_switcheroo_client_id id); int (*power_state)(enum vga_switcheroo_client_id id, enum vga_switcheroo_state state); @@ -53,6 +54,8 @@ int vga_switcheroo_register_audio_client(struct pci_dev *pdev, void vga_switcheroo_client_fb_set(struct pci_dev *dev, struct fb_info *info);

+int vga_switcheroo_switch_ddc(struct pci_dev *pdev); + int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler); void vga_switcheroo_unregister_handler(void);

@@ -66,6 +69,7 @@ static inline void vga_switcheroo_unregister_client(struct pci_dev *dev) {} static inline int vga_switcheroo_register_client(struct pci_dev *dev, const struct vga_switcheroo_client_ops *ops) { return 0; } static inline void vga_switcheroo_client_fb_set(struct pci_dev *dev, struct fb_info *info) {} +static inline void vga_switcheroo_switch_ddc(struct pci_dev *pdev) { return NULL; } static inline int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler) { return 0; } static inline int vga_switcheroo_register_audio_client(struct pci_dev *pdev, const struct vga_switcheroo_client_ops *ops,

DRM needs to be notified of client and handler registration in order to defer initialization of the secondary GPU until the EDID can be read from the LVDS panel. To support this add a notifier call chain to vga_switcheroo for subscribing to switcheroo events. Events are generated for registration and unregistration of handlers and clients.

Signed-off-by: Seth Forshee seth.forshee@canonical.com --- drivers/gpu/vga/vga_switcheroo.c | 34 ++++++++++++++++++++++++++++++++++ include/linux/vga_switcheroo.h | 14 ++++++++++++++ 2 files changed, 48 insertions(+)

diff --git a/drivers/gpu/vga/vga_switcheroo.c b/drivers/gpu/vga/vga_switcheroo.c index e53f67d..d5cd274 100644 --- a/drivers/gpu/vga/vga_switcheroo.c +++ b/drivers/gpu/vga/vga_switcheroo.c @@ -24,6 +24,7 @@ #include <linux/fs.h> #include <linux/debugfs.h> #include <linux/fb.h> +#include <linux/notifier.h>

#include <linux/pci.h> #include <linux/vga_switcheroo.h> @@ -70,6 +71,28 @@ static struct vgasr_priv vgasr_priv = { .clients = LIST_HEAD_INIT(vgasr_priv.clients), };

+static BLOCKING_NOTIFIER_HEAD(vga_switcheroo_notifier_list); + +int vga_switcheroo_register_notifier(struct notifier_block *nb) +{ + return blocking_notifier_chain_register(&vga_switcheroo_notifier_list, + nb); +} +EXPORT_SYMBOL(vga_switcheroo_register_notifier); + +int vga_switcheroo_unregister_notifier(struct notifier_block *nb) +{ + return blocking_notifier_chain_unregister(&vga_switcheroo_notifier_list, + nb); +} +EXPORT_SYMBOL(vga_switcheroo_unregister_notifier); + +static int vga_switcheroo_notifier_call_chain(enum vga_switcheroo_event event) +{ + return blocking_notifier_call_chain(&vga_switcheroo_notifier_list, + event, NULL); +} + static bool vga_switcheroo_ready(void) { /* we're ready if we get two clients + handler */ @@ -113,10 +136,18 @@ int vga_switcheroo_register_handler(struct vga_switcheroo_handler *handler) vga_switcheroo_enable(); } mutex_unlock(&vgasr_mutex); + + vga_switcheroo_notifier_call_chain(VGA_SWITCHEROO_HANDLER_REGISTERED); return 0; } EXPORT_SYMBOL(vga_switcheroo_register_handler);

+bool vga_switcheroo_handler_registered(void) +{ + return !!vgasr_priv.handler; +} +EXPORT_SYMBOL(vga_switcheroo_handler_registered); + void vga_switcheroo_unregister_handler(void) { mutex_lock(&vgasr_mutex); @@ -127,6 +158,7 @@ void vga_switcheroo_unregister_handler(void) vgasr_priv.active = false; } mutex_unlock(&vgasr_mutex); + vga_switcheroo_notifier_call_chain(VGA_SWITCHEROO_HANDLER_UNREGISTERED); } EXPORT_SYMBOL(vga_switcheroo_unregister_handler);

@@ -156,6 +188,7 @@ static int register_client(struct pci_dev *pdev, vga_switcheroo_enable(); } mutex_unlock(&vgasr_mutex); + vga_switcheroo_notifier_call_chain(VGA_SWITCHEROO_CLIENT_REGISTERED); return 0; }

@@ -250,6 +283,7 @@ void vga_switcheroo_unregister_client(struct pci_dev *pdev) vgasr_priv.active = false; } mutex_unlock(&vgasr_mutex); + vga_switcheroo_notifier_call_chain(VGA_SWITCHEROO_CLIENT_UNREGISTERED); } EXPORT_SYMBOL(vga_switcheroo_unregister_client);

diff --git a/include/linux/vga_switcheroo.h b/include/linux/vga_switcheroo.h index e361858..c3d7c6f 100644 --- a/include/linux/vga_switcheroo.h +++ b/include/linux/vga_switcheroo.h @@ -11,6 +11,7 @@ #define _LINUX_VGA_SWITCHEROO_H_

#include <linux/fb.h> +#include <linux/notifier.h>

struct pci_dev;

@@ -28,6 +29,13 @@ enum vga_switcheroo_client_id { VGA_SWITCHEROO_MAX_CLIENTS, };

+enum vga_switcheroo_event { + VGA_SWITCHEROO_CLIENT_REGISTERED, + VGA_SWITCHEROO_CLIENT_UNREGISTERED, + VGA_SWITCHEROO_HANDLER_REGISTERED, + VGA_SWITCHEROO_HANDLER_UNREGISTERED, +}; + struct vga_switcheroo_handler { int (*switch_ddc)(enum vga_switcheroo_client_id id); int (*switchto)(enum vga_switcheroo_client_id id); @@ -44,6 +52,9 @@ struct vga_switcheroo_client_ops { };

#if defined(CONFIG_VGA_SWITCHEROO) +int vga_switcheroo_register_notifier(struct notifier_block *nb); +int vga_switcheroo_unregister_notifier(struct notifier_block *nb); +bool vga_switcheroo_handler_registered(void); void vga_switcheroo_unregister_client(struct pci_dev *dev); int vga_switcheroo_register_client(struct pci_dev *dev, const struct vga_switcheroo_client_ops *ops); @@ -66,6 +77,9 @@ int vga_switcheroo_get_client_state(struct pci_dev *dev);

#else

+static inline int vga_switcheroo_register_notifier(struct notifier_block *nb) { return 0; } +static inline int vga_switcheroo_unregister_notifier(struct notifier_block *nb) { return 0; } +static inline bool vga_switcheroo_handler_registered(void) { return false; } static inline void vga_switcheroo_unregister_client(struct pci_dev *dev) {} static inline int vga_switcheroo_register_client(struct pci_dev *dev, const struct vga_switcheroo_client_ops *ops) { return 0; }

Some dual graphics machines support muxing the DDC separately from the display, so make use of this functionality when reading the EDID on the inactive GPU. Also serialize drm_get_edid() with a mutex to avoid races on the DDC mux state.

Signed-off-by: Seth Forshee seth.forshee@canonical.com --- drivers/gpu/drm/drm_edid.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)

diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c index b7ee230..b389269 100644 --- a/drivers/gpu/drm/drm_edid.c +++ b/drivers/gpu/drm/drm_edid.c @@ -31,6 +31,7 @@ #include <linux/slab.h> #include <linux/i2c.h> #include <linux/module.h> +#include <linux/vga_switcheroo.h> #include "drmP.h" #include "drm_edid.h" #include "drm_edid_modes.h" @@ -82,6 +83,8 @@ struct detailed_mode_closure { #define LEVEL_GTF2 2 #define LEVEL_CVT 3

+static DEFINE_MUTEX(drm_edid_mutex); + static struct edid_quirk { char vendor[4]; int product_id; @@ -398,12 +401,26 @@ struct edid *drm_get_edid(struct drm_connector *connector, struct i2c_adapter *adapter) { struct edid *edid = NULL; + struct pci_dev *pdev = connector->dev->pdev; + struct pci_dev *active_pdev = NULL; + + mutex_lock(&drm_edid_mutex); + + if (pdev) { + active_pdev = vga_switcheroo_get_active_client(); + if (active_pdev != pdev) + vga_switcheroo_switch_ddc(pdev); + }

if (drm_probe_ddc(adapter)) edid = (struct edid *)drm_do_get_edid(connector, adapter);

+ if (active_pdev && active_pdev != pdev) + vga_switcheroo_switch_ddc(active_pdev); + connector->display_info.raw_edid = (char *)edid;

+ mutex_unlock(&drm_edid_mutex); return edid;

}

Many Apple laptops with hybrid graphics require switching the i2c mux to the integrated GPU when that device is being initialized in order to get correct mode information for the LVDS panel. This requires that switcheroo is ready at the time the device is initialized, which is not guaranteed.

To support this, delay calling the driver load() callback until the vga_switcheroo handler and active client have been registered. This is restricted to Apple notebooks via DMI data to avoid causing problems on machines without switcheroo support.

Signed-off-by: Seth Forshee seth.forshee@canonical.com --- drivers/gpu/drm/drm_drv.c | 3 + drivers/gpu/drm/drm_pci.c | 164 ++++++++++++++++++++++++++++++++++++++++----- include/drm/drmP.h | 2 + 3 files changed, 153 insertions(+), 16 deletions(-)

diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c index 9238de4..124fd8a 100644 --- a/drivers/gpu/drm/drm_drv.c +++ b/drivers/gpu/drm/drm_drv.c @@ -276,6 +276,8 @@ static int __init drm_core_init(void) goto err_p3; }

+ drm_pci_module_init(); + DRM_INFO("Initialized %s %d.%d.%d %s\n", CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE); return 0; @@ -291,6 +293,7 @@ err_p1:

static void __exit drm_core_exit(void) { + drm_pci_module_exit(); remove_proc_entry("dri", NULL); debugfs_remove(drm_debugfs_root); drm_sysfs_destroy(); diff --git a/drivers/gpu/drm/drm_pci.c b/drivers/gpu/drm/drm_pci.c index 55eb824..a5c9068 100644 --- a/drivers/gpu/drm/drm_pci.c +++ b/drivers/gpu/drm/drm_pci.c @@ -40,6 +40,10 @@ #include <linux/slab.h> #include <linux/dma-mapping.h> #include <linux/export.h> +#include <linux/dmi.h> +#include <linux/notifier.h> +#include <linux/vgaarb.h> +#include <linux/vga_switcheroo.h> #include "drmP.h"

/**********************************************************************/ @@ -297,19 +301,8 @@ static struct drm_bus drm_pci_bus = { .agp_init = drm_pci_agp_init, };

-/** - * Register. - * - * \param pdev - PCI device structure - * \param ent entry from the PCI ID table with device type flags - * \return zero on success or a negative number on failure. - * - * Attempt to gets inter module "drm" information. If we are first - * then register the character device and inter module information. - * Try and register, if we fail to register, backout previous work. - */ -int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, - struct drm_driver *driver) +int __drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, + struct drm_driver *driver) { struct drm_device *dev; int ret; @@ -334,8 +327,6 @@ int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, dev->hose = pdev->sysdata; #endif

- mutex_lock(&drm_global_mutex); - if ((ret = drm_fill_in_dev(dev, ent, driver))) { printk(KERN_ERR "DRM: Fill_in_dev failed.\n"); goto err_g2; @@ -371,7 +362,6 @@ int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, driver->name, driver->major, driver->minor, driver->patchlevel, driver->date, pci_name(pdev), dev->primary->index);

- mutex_unlock(&drm_global_mutex); return 0;

err_g4: @@ -386,10 +376,140 @@ err_g1: mutex_unlock(&drm_global_mutex); return ret; } + +/* + * List of machines that require delaying initialization of the secondary + * GPU until vga_switcheroo is ready. + */ +static struct dmi_system_id deferred_init_dmi_table[] = { + { + .ident = "Apple Laptop", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), + DMI_MATCH(DMI_CHASSIS_TYPE, "10"), /* Notebook */ + }, + }, +}; + +struct deferred_init_data { + struct list_head list; + struct pci_dev *pdev; + const struct pci_device_id *ent; + struct drm_driver *driver; +}; + +static LIST_HEAD(deferred_init_list); + +static bool drm_pci_switcheroo_ready(void) +{ + if (!vga_switcheroo_handler_registered()) + return false; + if (!vga_switcheroo_get_active_client()) + return false; + return true; +} + +static void drm_deferred_init_work_fn(struct work_struct *work) +{ + struct deferred_init_data *di_data, *temp; + + mutex_lock(&drm_global_mutex); + + if (!drm_pci_switcheroo_ready()) { + mutex_unlock(&drm_global_mutex); + return; + } + + list_for_each_entry_safe(di_data, temp, &deferred_init_list, list) { + if (__drm_get_pci_dev(di_data->pdev, di_data->ent, + di_data->driver)) + DRM_ERROR("pci device initialization failed\n"); + list_del(&di_data->list); + kfree(di_data); + } + mutex_unlock(&drm_global_mutex); +} +static DECLARE_WORK(deferred_init_work, drm_deferred_init_work_fn); + +static int drm_switcheroo_notifier_fn(struct notifier_block *nb, + unsigned long val, void *unused) +{ + if (val == VGA_SWITCHEROO_CLIENT_REGISTERED || + val == VGA_SWITCHEROO_HANDLER_REGISTERED) + queue_work(system_nrt_wq, &deferred_init_work); + return NOTIFY_OK; +} + +static struct notifier_block drm_switcheroo_notifier = { + .notifier_call = drm_switcheroo_notifier_fn, +}; + +static bool drm_pci_needs_deferred_init(struct pci_dev *pdev) +{ + if (!dmi_check_system(deferred_init_dmi_table)) + return false; + if (vga_default_device() == pdev) + return false; + return !drm_pci_switcheroo_ready(); +} + +/** + * Register. + * + * \param pdev - PCI device structure + * \param ent entry from the PCI ID table with device type flags + * \return zero on success or a negative number on failure. + * + * Attempt to gets inter module "drm" information. If we are first + * then register the character device and inter module information. + * Try and register, if we fail to register, backout previous work. + */ +int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, + struct drm_driver *driver) +{ + int ret = 0; + + mutex_lock(&drm_global_mutex); + + /* + * On some machines secondary graphics devices shouldn't be + * initialized until the handler and primary graphics device + * have been registered with vga_switcheroo. + */ + if (drm_pci_needs_deferred_init(pdev)) { + struct deferred_init_data *di_data = + kmalloc(sizeof(*di_data), GFP_KERNEL); + if (!di_data) { + ret = -ENOMEM; + } else { + di_data->pdev = pdev; + di_data->ent = ent; + di_data->driver = driver; + list_add_tail(&di_data->list, &deferred_init_list); + } + } else { + ret = __drm_get_pci_dev(pdev, ent, driver); + } + + mutex_unlock(&drm_global_mutex); + return ret; +} EXPORT_SYMBOL(drm_get_pci_dev);

void drm_put_pci_dev(struct drm_device *dev) { + struct deferred_init_data *di_data; + + mutex_lock(&drm_global_mutex); + list_for_each_entry(di_data, &deferred_init_list, list) { + if (di_data->pdev == dev->pdev) { + list_del(&di_data->list); + kfree(di_data); + break; + } + } + mutex_unlock(&drm_global_mutex); + drm_put_dev(dev); } EXPORT_SYMBOL(drm_put_pci_dev); @@ -520,3 +640,15 @@ int drm_pcie_get_speed_cap_mask(struct drm_device *dev, u32 *mask) return 0; } EXPORT_SYMBOL(drm_pcie_get_speed_cap_mask); + +int drm_pci_module_init(void) +{ + return vga_switcheroo_register_notifier(&drm_switcheroo_notifier); +} +EXPORT_SYMBOL(drm_pci_module_init); + +void drm_pci_module_exit(void) +{ + vga_switcheroo_unregister_notifier(&drm_switcheroo_notifier); +} +EXPORT_SYMBOL(drm_pci_module_exit); diff --git a/include/drm/drmP.h b/include/drm/drmP.h index eb99e96..0e9401f 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h @@ -1749,6 +1749,8 @@ extern int drm_get_pci_dev(struct pci_dev *pdev, const struct pci_device_id *ent, struct drm_driver *driver); extern void drm_put_pci_dev(struct drm_device *dev); +extern int drm_pci_module_init(void); +extern void drm_pci_module_exit(void);

#define DRM_PCIE_SPEED_25 1 #define DRM_PCIE_SPEED_50 2