From patchwork Mon Aug 20 15:31:04 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Seth Forshee X-Patchwork-Id: 1353631 Return-Path: X-Original-To: patchwork-dri-devel@patchwork.kernel.org Delivered-To: patchwork-process-083081@patchwork2.kernel.org Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by patchwork2.kernel.org (Postfix) with ESMTP id 82605DFB34 for ; Tue, 21 Aug 2012 09:53:23 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 59CC29F031 for ; Tue, 21 Aug 2012 02:53:23 -0700 (PDT) X-Original-To: dri-devel@lists.freedesktop.org Delivered-To: dri-devel@lists.freedesktop.org Received: from youngberry.canonical.com (youngberry.canonical.com [91.189.89.112]) by gabe.freedesktop.org (Postfix) with ESMTP id 5AC1D9EFE5 for ; Mon, 20 Aug 2012 08:31:26 -0700 (PDT) Received: from 64-126-113-183.dyn.everestkc.net ([64.126.113.183] helo=canonical.com) by youngberry.canonical.com with esmtpsa (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1T3Twq-0000CI-OP; Mon, 20 Aug 2012 15:31:25 +0000 From: Seth Forshee To: Dave Airlie , Daniel Vetter , Matthew Garrett , David Airlie Subject: [RFC PATCH 7/7] drm/pci: Defer initialization of secondary graphics devices until switcheroo is ready Date: Mon, 20 Aug 2012 10:31:04 -0500 Message-Id: <1345476664-22066-8-git-send-email-seth.forshee@canonical.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1345476664-22066-1-git-send-email-seth.forshee@canonical.com> References: <20120806045150.GA23652@thinkpad-t410> <1345476664-22066-1-git-send-email-seth.forshee@canonical.com> X-Mailman-Approved-At: Mon, 20 Aug 2012 23:13:53 -0700 Cc: Andreas Heider , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: dri-devel-bounces+patchwork-dri-devel=patchwork.kernel.org@lists.freedesktop.org Errors-To: dri-devel-bounces+patchwork-dri-devel=patchwork.kernel.org@lists.freedesktop.org Deferring initiailzation of the secondary GPU until switcheroo is ready will allow successfully reading the EDID in systems which support muxing the DDC seperately from the display. Signed-off-by: Seth Forshee --- drivers/gpu/drm/drm_drv.c | 3 + drivers/gpu/drm/drm_pci.c | 141 +++++++++++++++++++++++++++++++++++++++------ include/drm/drmP.h | 2 + 3 files changed, 129 insertions(+), 17 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 4896c96..9da0cd2 100644 --- a/drivers/gpu/drm/drm_pci.c +++ b/drivers/gpu/drm/drm_pci.c @@ -40,6 +40,9 @@ #include #include #include +#include +#include +#include #include "drmP.h" /**********************************************************************/ @@ -297,19 +300,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 +326,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 +361,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 +375,116 @@ err_g1: mutex_unlock(&drm_global_mutex); return ret; } + +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 void drm_deferred_init_work_fn(struct work_struct *work) +{ + struct deferred_init_data *di_data, *temp; + + mutex_lock(&drm_global_mutex); + + if (!vga_switcheroo_handler_registered() || + !vga_switcheroo_get_active_client()) { + 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, +}; + +/** + * 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); + + /* + * For secondary graphics devices shouldn't be initialized + * until the handler and primary graphics device have been + * registered with vga_switcheroo. + * + * FIXME: Is vga_default_device() reliable enough for this + * purpose? + * + * FIXME: If vga_switcheroo is disabled secondary devices + * never gets initialized. Is this okay? Maybe it is, since + * we can't switch to the secondary GPU anyway. + */ + if (vga_default_device() == pdev || + (vga_switcheroo_handler_registered() && + vga_switcheroo_get_active_client())) { + ret = __drm_get_pci_dev(pdev, ent, driver); + } else { + 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); + } + } + + 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); @@ -466,7 +561,7 @@ void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver) pci_unregister_driver(pdriver); } else { list_for_each_entry_safe(dev, tmp, &driver->device_list, driver_item) - drm_put_dev(dev); + drm_put_pci_dev(dev); } DRM_INFO("Module unloaded\n"); } @@ -520,3 +615,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