121d70354SDave Airlie /* 221d70354SDave Airlie * Created: Fri Jan 19 10:48:35 2001 by faith@acm.org 321d70354SDave Airlie * 421d70354SDave Airlie * Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California. 521d70354SDave Airlie * All Rights Reserved. 621d70354SDave Airlie * 721d70354SDave Airlie * Author Rickard E. (Rik) Faith <faith@valinux.com> 821d70354SDave Airlie * 921d70354SDave Airlie * Permission is hereby granted, free of charge, to any person obtaining a 1021d70354SDave Airlie * copy of this software and associated documentation files (the "Software"), 1121d70354SDave Airlie * to deal in the Software without restriction, including without limitation 1221d70354SDave Airlie * the rights to use, copy, modify, merge, publish, distribute, sublicense, 1321d70354SDave Airlie * and/or sell copies of the Software, and to permit persons to whom the 1421d70354SDave Airlie * Software is furnished to do so, subject to the following conditions: 1521d70354SDave Airlie * 1621d70354SDave Airlie * The above copyright notice and this permission notice (including the next 1721d70354SDave Airlie * paragraph) shall be included in all copies or substantial portions of the 1821d70354SDave Airlie * Software. 1921d70354SDave Airlie * 2021d70354SDave Airlie * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 2121d70354SDave Airlie * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 2221d70354SDave Airlie * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 2321d70354SDave Airlie * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 2421d70354SDave Airlie * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 2521d70354SDave Airlie * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 2621d70354SDave Airlie * DEALINGS IN THE SOFTWARE. 2721d70354SDave Airlie */ 2821d70354SDave Airlie 2921d70354SDave Airlie #include <linux/debugfs.h> 3021d70354SDave Airlie #include <linux/fs.h> 3121d70354SDave Airlie #include <linux/module.h> 3221d70354SDave Airlie #include <linux/moduleparam.h> 3321d70354SDave Airlie #include <linux/mount.h> 344a457910SDavid Howells #include <linux/pseudo_fs.h> 3521d70354SDave Airlie #include <linux/slab.h> 36bee330f3SNoralf Trønnes #include <linux/srcu.h> 3785e634bcSDaniel Vetter 38c76f0f7cSNoralf Trønnes #include <drm/drm_client.h> 390500c04eSSam Ravnborg #include <drm/drm_color_mgmt.h> 4085e634bcSDaniel Vetter #include <drm/drm_drv.h> 410500c04eSSam Ravnborg #include <drm/drm_file.h> 420500c04eSSam Ravnborg #include <drm/drm_mode_object.h> 430500c04eSSam Ravnborg #include <drm/drm_print.h> 4485e634bcSDaniel Vetter 4579190ea2SBenjamin Gaignard #include "drm_crtc_internal.h" 4667d0ec4eSDaniel Vetter #include "drm_internal.h" 470500c04eSSam Ravnborg #include "drm_legacy.h" 4821d70354SDave Airlie 496dc3e22eSEzequiel Garcia /* 506dc3e22eSEzequiel Garcia * drm_debug: Enable debug output. 510500c04eSSam Ravnborg * Bitmask of DRM_UT_x. See include/drm/drm_print.h for details. 526dc3e22eSEzequiel Garcia */ 536dc3e22eSEzequiel Garcia unsigned int drm_debug = 0; 5421d70354SDave Airlie EXPORT_SYMBOL(drm_debug); 5521d70354SDave Airlie 5682d5e73fSDavid Herrmann MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl"); 5782d5e73fSDavid Herrmann MODULE_DESCRIPTION("DRM shared core routines"); 5821d70354SDave Airlie MODULE_LICENSE("GPL and additional rights"); 596dc3e22eSEzequiel Garcia MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug category.\n" 606dc3e22eSEzequiel Garcia "\t\tBit 0 (0x01) will enable CORE messages (drm core code)\n" 616dc3e22eSEzequiel Garcia "\t\tBit 1 (0x02) will enable DRIVER messages (drm controller code)\n" 626dc3e22eSEzequiel Garcia "\t\tBit 2 (0x04) will enable KMS messages (modesetting code)\n" 636dc3e22eSEzequiel Garcia "\t\tBit 3 (0x08) will enable PRIME messages (prime code)\n" 646dc3e22eSEzequiel Garcia "\t\tBit 4 (0x10) will enable ATOMIC messages (atomic code)\n" 65e7646f84SKeith Packard "\t\tBit 5 (0x20) will enable VBL messages (vblank code)\n" 66a18b2192SLyude Paul "\t\tBit 7 (0x80) will enable LEASE messages (leasing code)\n" 67a18b2192SLyude Paul "\t\tBit 8 (0x100) will enable DP messages (displayport code)"); 6821d70354SDave Airlie module_param_named(debug, drm_debug, int, 0600); 6921d70354SDave Airlie 7021d70354SDave Airlie static DEFINE_SPINLOCK(drm_minor_lock); 7121d70354SDave Airlie static struct idr drm_minors_idr; 7221d70354SDave Airlie 73371c2279SAlexandru Moise /* 74371c2279SAlexandru Moise * If the drm core fails to init for whatever reason, 75371c2279SAlexandru Moise * we should prevent any drivers from registering with it. 76371c2279SAlexandru Moise * It's best to check this at drm_dev_init(), as some drivers 77371c2279SAlexandru Moise * prefer to embed struct drm_device into their own device 78371c2279SAlexandru Moise * structure and call drm_dev_init() themselves. 79371c2279SAlexandru Moise */ 80371c2279SAlexandru Moise static bool drm_core_init_complete = false; 81371c2279SAlexandru Moise 8221d70354SDave Airlie static struct dentry *drm_debugfs_root; 8321d70354SDave Airlie 84bee330f3SNoralf Trønnes DEFINE_STATIC_SRCU(drm_unplug_srcu); 85bee330f3SNoralf Trønnes 8621d70354SDave Airlie /* 8721d70354SDave Airlie * DRM Minors 8821d70354SDave Airlie * A DRM device can provide several char-dev interfaces on the DRM-Major. Each 8921d70354SDave Airlie * of them is represented by a drm_minor object. Depending on the capabilities 9021d70354SDave Airlie * of the device-driver, different interfaces are registered. 9121d70354SDave Airlie * 9221d70354SDave Airlie * Minors can be accessed via dev->$minor_name. This pointer is either 9321d70354SDave Airlie * NULL or a valid drm_minor pointer and stays valid as long as the device is 9421d70354SDave Airlie * valid. This means, DRM minors have the same life-time as the underlying 9521d70354SDave Airlie * device. However, this doesn't mean that the minor is active. Minors are 9621d70354SDave Airlie * registered and unregistered dynamically according to device-state. 9721d70354SDave Airlie */ 9821d70354SDave Airlie 9921d70354SDave Airlie static struct drm_minor **drm_minor_get_slot(struct drm_device *dev, 10021d70354SDave Airlie unsigned int type) 10121d70354SDave Airlie { 10221d70354SDave Airlie switch (type) { 103a3ccc461SDavid Herrmann case DRM_MINOR_PRIMARY: 10421d70354SDave Airlie return &dev->primary; 10521d70354SDave Airlie case DRM_MINOR_RENDER: 10621d70354SDave Airlie return &dev->render; 10721d70354SDave Airlie default: 1083bd07ccdSJoe Moriarty BUG(); 10921d70354SDave Airlie } 11021d70354SDave Airlie } 11121d70354SDave Airlie 11221d70354SDave Airlie static int drm_minor_alloc(struct drm_device *dev, unsigned int type) 11321d70354SDave Airlie { 11421d70354SDave Airlie struct drm_minor *minor; 11521d70354SDave Airlie unsigned long flags; 11621d70354SDave Airlie int r; 11721d70354SDave Airlie 11821d70354SDave Airlie minor = kzalloc(sizeof(*minor), GFP_KERNEL); 11921d70354SDave Airlie if (!minor) 12021d70354SDave Airlie return -ENOMEM; 12121d70354SDave Airlie 12221d70354SDave Airlie minor->type = type; 12321d70354SDave Airlie minor->dev = dev; 12421d70354SDave Airlie 12521d70354SDave Airlie idr_preload(GFP_KERNEL); 12621d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 12721d70354SDave Airlie r = idr_alloc(&drm_minors_idr, 12821d70354SDave Airlie NULL, 12921d70354SDave Airlie 64 * type, 13021d70354SDave Airlie 64 * (type + 1), 13121d70354SDave Airlie GFP_NOWAIT); 13221d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 13321d70354SDave Airlie idr_preload_end(); 13421d70354SDave Airlie 13521d70354SDave Airlie if (r < 0) 13621d70354SDave Airlie goto err_free; 13721d70354SDave Airlie 13821d70354SDave Airlie minor->index = r; 13921d70354SDave Airlie 14021d70354SDave Airlie minor->kdev = drm_sysfs_minor_alloc(minor); 14121d70354SDave Airlie if (IS_ERR(minor->kdev)) { 14221d70354SDave Airlie r = PTR_ERR(minor->kdev); 14321d70354SDave Airlie goto err_index; 14421d70354SDave Airlie } 14521d70354SDave Airlie 14621d70354SDave Airlie *drm_minor_get_slot(dev, type) = minor; 14721d70354SDave Airlie return 0; 14821d70354SDave Airlie 14921d70354SDave Airlie err_index: 15021d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 15121d70354SDave Airlie idr_remove(&drm_minors_idr, minor->index); 15221d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 15321d70354SDave Airlie err_free: 15421d70354SDave Airlie kfree(minor); 15521d70354SDave Airlie return r; 15621d70354SDave Airlie } 15721d70354SDave Airlie 15821d70354SDave Airlie static void drm_minor_free(struct drm_device *dev, unsigned int type) 15921d70354SDave Airlie { 16021d70354SDave Airlie struct drm_minor **slot, *minor; 16121d70354SDave Airlie unsigned long flags; 16221d70354SDave Airlie 16321d70354SDave Airlie slot = drm_minor_get_slot(dev, type); 16421d70354SDave Airlie minor = *slot; 16521d70354SDave Airlie if (!minor) 16621d70354SDave Airlie return; 16721d70354SDave Airlie 16821d70354SDave Airlie put_device(minor->kdev); 16921d70354SDave Airlie 17021d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 17121d70354SDave Airlie idr_remove(&drm_minors_idr, minor->index); 17221d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 17321d70354SDave Airlie 17421d70354SDave Airlie kfree(minor); 17521d70354SDave Airlie *slot = NULL; 17621d70354SDave Airlie } 17721d70354SDave Airlie 17821d70354SDave Airlie static int drm_minor_register(struct drm_device *dev, unsigned int type) 17921d70354SDave Airlie { 18021d70354SDave Airlie struct drm_minor *minor; 18121d70354SDave Airlie unsigned long flags; 18221d70354SDave Airlie int ret; 18321d70354SDave Airlie 18421d70354SDave Airlie DRM_DEBUG("\n"); 18521d70354SDave Airlie 18621d70354SDave Airlie minor = *drm_minor_get_slot(dev, type); 18721d70354SDave Airlie if (!minor) 18821d70354SDave Airlie return 0; 18921d70354SDave Airlie 19021d70354SDave Airlie ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root); 19121d70354SDave Airlie if (ret) { 19221d70354SDave Airlie DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n"); 193a67834f8SNoralf Trønnes goto err_debugfs; 19421d70354SDave Airlie } 19521d70354SDave Airlie 19621d70354SDave Airlie ret = device_add(minor->kdev); 19721d70354SDave Airlie if (ret) 19821d70354SDave Airlie goto err_debugfs; 19921d70354SDave Airlie 20021d70354SDave Airlie /* replace NULL with @minor so lookups will succeed from now on */ 20121d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 20221d70354SDave Airlie idr_replace(&drm_minors_idr, minor, minor->index); 20321d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 20421d70354SDave Airlie 20521d70354SDave Airlie DRM_DEBUG("new minor registered %d\n", minor->index); 20621d70354SDave Airlie return 0; 20721d70354SDave Airlie 20821d70354SDave Airlie err_debugfs: 20921d70354SDave Airlie drm_debugfs_cleanup(minor); 21021d70354SDave Airlie return ret; 21121d70354SDave Airlie } 21221d70354SDave Airlie 21321d70354SDave Airlie static void drm_minor_unregister(struct drm_device *dev, unsigned int type) 21421d70354SDave Airlie { 21521d70354SDave Airlie struct drm_minor *minor; 21621d70354SDave Airlie unsigned long flags; 21721d70354SDave Airlie 21821d70354SDave Airlie minor = *drm_minor_get_slot(dev, type); 21921d70354SDave Airlie if (!minor || !device_is_registered(minor->kdev)) 22021d70354SDave Airlie return; 22121d70354SDave Airlie 22221d70354SDave Airlie /* replace @minor with NULL so lookups will fail from now on */ 22321d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 22421d70354SDave Airlie idr_replace(&drm_minors_idr, NULL, minor->index); 22521d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 22621d70354SDave Airlie 22721d70354SDave Airlie device_del(minor->kdev); 22821d70354SDave Airlie dev_set_drvdata(minor->kdev, NULL); /* safety belt */ 22921d70354SDave Airlie drm_debugfs_cleanup(minor); 23021d70354SDave Airlie } 23121d70354SDave Airlie 23285e634bcSDaniel Vetter /* 23321d70354SDave Airlie * Looks up the given minor-ID and returns the respective DRM-minor object. The 23421d70354SDave Airlie * refence-count of the underlying device is increased so you must release this 23521d70354SDave Airlie * object with drm_minor_release(). 23621d70354SDave Airlie * 23721d70354SDave Airlie * As long as you hold this minor, it is guaranteed that the object and the 23821d70354SDave Airlie * minor->dev pointer will stay valid! However, the device may get unplugged and 23921d70354SDave Airlie * unregistered while you hold the minor. 24021d70354SDave Airlie */ 24121d70354SDave Airlie struct drm_minor *drm_minor_acquire(unsigned int minor_id) 24221d70354SDave Airlie { 24321d70354SDave Airlie struct drm_minor *minor; 24421d70354SDave Airlie unsigned long flags; 24521d70354SDave Airlie 24621d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 24721d70354SDave Airlie minor = idr_find(&drm_minors_idr, minor_id); 24821d70354SDave Airlie if (minor) 2499a96f550SAishwarya Pant drm_dev_get(minor->dev); 25021d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 25121d70354SDave Airlie 25221d70354SDave Airlie if (!minor) { 25321d70354SDave Airlie return ERR_PTR(-ENODEV); 254c07dcd61SDaniel Vetter } else if (drm_dev_is_unplugged(minor->dev)) { 2559a96f550SAishwarya Pant drm_dev_put(minor->dev); 25621d70354SDave Airlie return ERR_PTR(-ENODEV); 25721d70354SDave Airlie } 25821d70354SDave Airlie 25921d70354SDave Airlie return minor; 26021d70354SDave Airlie } 26121d70354SDave Airlie 26221d70354SDave Airlie void drm_minor_release(struct drm_minor *minor) 26321d70354SDave Airlie { 2649a96f550SAishwarya Pant drm_dev_put(minor->dev); 26521d70354SDave Airlie } 26621d70354SDave Airlie 26721d70354SDave Airlie /** 2686e3f797cSDaniel Vetter * DOC: driver instance overview 2696e3f797cSDaniel Vetter * 270ea0dd85aSDaniel Vetter * A device instance for a drm driver is represented by &struct drm_device. This 27133e70110SDaniel Vetter * is initialized with drm_dev_init(), usually from bus-specific ->probe() 2726e3f797cSDaniel Vetter * callbacks implemented by the driver. The driver then needs to initialize all 2736e3f797cSDaniel Vetter * the various subsystems for the drm device like memory management, vblank 2746e3f797cSDaniel Vetter * handling, modesetting support and intial output configuration plus obviously 27533e70110SDaniel Vetter * initialize all the corresponding hardware bits. Finally when everything is up 27633e70110SDaniel Vetter * and running and ready for userspace the device instance can be published 27733e70110SDaniel Vetter * using drm_dev_register(). 2786e3f797cSDaniel Vetter * 2796e3f797cSDaniel Vetter * There is also deprecated support for initalizing device instances using 280ef40cbf9SDaniel Vetter * bus-specific helpers and the &drm_driver.load callback. But due to 2816e3f797cSDaniel Vetter * backwards-compatibility needs the device instance have to be published too 2826e3f797cSDaniel Vetter * early, which requires unpretty global locking to make safe and is therefore 2836e3f797cSDaniel Vetter * only support for existing drivers not yet converted to the new scheme. 2846e3f797cSDaniel Vetter * 2856e3f797cSDaniel Vetter * When cleaning up a device instance everything needs to be done in reverse: 2866e3f797cSDaniel Vetter * First unpublish the device instance with drm_dev_unregister(). Then clean up 2876e3f797cSDaniel Vetter * any other resources allocated at device initialization and drop the driver's 2889a96f550SAishwarya Pant * reference to &drm_device using drm_dev_put(). 2896e3f797cSDaniel Vetter * 2906e3f797cSDaniel Vetter * Note that the lifetime rules for &drm_device instance has still a lot of 2916e3f797cSDaniel Vetter * historical baggage. Hence use the reference counting provided by 2929a96f550SAishwarya Pant * drm_dev_get() and drm_dev_put() only carefully. 293de99f060SNoralf Trønnes * 294de99f060SNoralf Trønnes * Display driver example 295de99f060SNoralf Trønnes * ~~~~~~~~~~~~~~~~~~~~~~ 296de99f060SNoralf Trønnes * 297de99f060SNoralf Trønnes * The following example shows a typical structure of a DRM display driver. 298de99f060SNoralf Trønnes * The example focus on the probe() function and the other functions that is 299de99f060SNoralf Trønnes * almost always present and serves as a demonstration of devm_drm_dev_init() 300de99f060SNoralf Trønnes * usage with its accompanying drm_driver->release callback. 301de99f060SNoralf Trønnes * 302de99f060SNoralf Trønnes * .. code-block:: c 303de99f060SNoralf Trønnes * 304de99f060SNoralf Trønnes * struct driver_device { 305de99f060SNoralf Trønnes * struct drm_device drm; 306de99f060SNoralf Trønnes * void *userspace_facing; 307de99f060SNoralf Trønnes * struct clk *pclk; 308de99f060SNoralf Trønnes * }; 309de99f060SNoralf Trønnes * 310de99f060SNoralf Trønnes * static void driver_drm_release(struct drm_device *drm) 311de99f060SNoralf Trønnes * { 312de99f060SNoralf Trønnes * struct driver_device *priv = container_of(...); 313de99f060SNoralf Trønnes * 314de99f060SNoralf Trønnes * drm_mode_config_cleanup(drm); 315de99f060SNoralf Trønnes * drm_dev_fini(drm); 316de99f060SNoralf Trønnes * kfree(priv->userspace_facing); 317de99f060SNoralf Trønnes * kfree(priv); 318de99f060SNoralf Trønnes * } 319de99f060SNoralf Trønnes * 320de99f060SNoralf Trønnes * static struct drm_driver driver_drm_driver = { 321de99f060SNoralf Trønnes * [...] 322de99f060SNoralf Trønnes * .release = driver_drm_release, 323de99f060SNoralf Trønnes * }; 324de99f060SNoralf Trønnes * 325de99f060SNoralf Trønnes * static int driver_probe(struct platform_device *pdev) 326de99f060SNoralf Trønnes * { 327de99f060SNoralf Trønnes * struct driver_device *priv; 328de99f060SNoralf Trønnes * struct drm_device *drm; 329de99f060SNoralf Trønnes * int ret; 330de99f060SNoralf Trønnes * 33156d8d641SJonathan Neuschäfer * // devm_kzalloc() can't be used here because the drm_device ' 33256d8d641SJonathan Neuschäfer * // lifetime can exceed the device lifetime if driver unbind 33356d8d641SJonathan Neuschäfer * // happens when userspace still has open file descriptors. 334de99f060SNoralf Trønnes * priv = kzalloc(sizeof(*priv), GFP_KERNEL); 335de99f060SNoralf Trønnes * if (!priv) 336de99f060SNoralf Trønnes * return -ENOMEM; 337de99f060SNoralf Trønnes * 338de99f060SNoralf Trønnes * drm = &priv->drm; 339de99f060SNoralf Trønnes * 340de99f060SNoralf Trønnes * ret = devm_drm_dev_init(&pdev->dev, drm, &driver_drm_driver); 341de99f060SNoralf Trønnes * if (ret) { 342de99f060SNoralf Trønnes * kfree(drm); 343de99f060SNoralf Trønnes * return ret; 344de99f060SNoralf Trønnes * } 345de99f060SNoralf Trønnes * 346de99f060SNoralf Trønnes * drm_mode_config_init(drm); 347de99f060SNoralf Trønnes * 348de99f060SNoralf Trønnes * priv->userspace_facing = kzalloc(..., GFP_KERNEL); 349de99f060SNoralf Trønnes * if (!priv->userspace_facing) 350de99f060SNoralf Trønnes * return -ENOMEM; 351de99f060SNoralf Trønnes * 352de99f060SNoralf Trønnes * priv->pclk = devm_clk_get(dev, "PCLK"); 353de99f060SNoralf Trønnes * if (IS_ERR(priv->pclk)) 354de99f060SNoralf Trønnes * return PTR_ERR(priv->pclk); 355de99f060SNoralf Trønnes * 35656d8d641SJonathan Neuschäfer * // Further setup, display pipeline etc 357de99f060SNoralf Trønnes * 358de99f060SNoralf Trønnes * platform_set_drvdata(pdev, drm); 359de99f060SNoralf Trønnes * 360de99f060SNoralf Trønnes * drm_mode_config_reset(drm); 361de99f060SNoralf Trønnes * 362de99f060SNoralf Trønnes * ret = drm_dev_register(drm); 363de99f060SNoralf Trønnes * if (ret) 364de99f060SNoralf Trønnes * return ret; 365de99f060SNoralf Trønnes * 366de99f060SNoralf Trønnes * drm_fbdev_generic_setup(drm, 32); 367de99f060SNoralf Trønnes * 368de99f060SNoralf Trønnes * return 0; 369de99f060SNoralf Trønnes * } 370de99f060SNoralf Trønnes * 37156d8d641SJonathan Neuschäfer * // This function is called before the devm_ resources are released 372de99f060SNoralf Trønnes * static int driver_remove(struct platform_device *pdev) 373de99f060SNoralf Trønnes * { 374de99f060SNoralf Trønnes * struct drm_device *drm = platform_get_drvdata(pdev); 375de99f060SNoralf Trønnes * 376de99f060SNoralf Trønnes * drm_dev_unregister(drm); 377de99f060SNoralf Trønnes * drm_atomic_helper_shutdown(drm) 378de99f060SNoralf Trønnes * 379de99f060SNoralf Trønnes * return 0; 380de99f060SNoralf Trønnes * } 381de99f060SNoralf Trønnes * 38256d8d641SJonathan Neuschäfer * // This function is called on kernel restart and shutdown 383de99f060SNoralf Trønnes * static void driver_shutdown(struct platform_device *pdev) 384de99f060SNoralf Trønnes * { 385de99f060SNoralf Trønnes * drm_atomic_helper_shutdown(platform_get_drvdata(pdev)); 386de99f060SNoralf Trønnes * } 387de99f060SNoralf Trønnes * 388de99f060SNoralf Trønnes * static int __maybe_unused driver_pm_suspend(struct device *dev) 389de99f060SNoralf Trønnes * { 390de99f060SNoralf Trønnes * return drm_mode_config_helper_suspend(dev_get_drvdata(dev)); 391de99f060SNoralf Trønnes * } 392de99f060SNoralf Trønnes * 393de99f060SNoralf Trønnes * static int __maybe_unused driver_pm_resume(struct device *dev) 394de99f060SNoralf Trønnes * { 395de99f060SNoralf Trønnes * drm_mode_config_helper_resume(dev_get_drvdata(dev)); 396de99f060SNoralf Trønnes * 397de99f060SNoralf Trønnes * return 0; 398de99f060SNoralf Trønnes * } 399de99f060SNoralf Trønnes * 400de99f060SNoralf Trønnes * static const struct dev_pm_ops driver_pm_ops = { 401de99f060SNoralf Trønnes * SET_SYSTEM_SLEEP_PM_OPS(driver_pm_suspend, driver_pm_resume) 402de99f060SNoralf Trønnes * }; 403de99f060SNoralf Trønnes * 404de99f060SNoralf Trønnes * static struct platform_driver driver_driver = { 405de99f060SNoralf Trønnes * .driver = { 406de99f060SNoralf Trønnes * [...] 407de99f060SNoralf Trønnes * .pm = &driver_pm_ops, 408de99f060SNoralf Trønnes * }, 409de99f060SNoralf Trønnes * .probe = driver_probe, 410de99f060SNoralf Trønnes * .remove = driver_remove, 411de99f060SNoralf Trønnes * .shutdown = driver_shutdown, 412de99f060SNoralf Trønnes * }; 413de99f060SNoralf Trønnes * module_platform_driver(driver_driver); 414de99f060SNoralf Trønnes * 415de99f060SNoralf Trønnes * Drivers that want to support device unplugging (USB, DT overlay unload) should 416de99f060SNoralf Trønnes * use drm_dev_unplug() instead of drm_dev_unregister(). The driver must protect 417de99f060SNoralf Trønnes * regions that is accessing device resources to prevent use after they're 418de99f060SNoralf Trønnes * released. This is done using drm_dev_enter() and drm_dev_exit(). There is one 419de99f060SNoralf Trønnes * shortcoming however, drm_dev_unplug() marks the drm_device as unplugged before 420de99f060SNoralf Trønnes * drm_atomic_helper_shutdown() is called. This means that if the disable code 421de99f060SNoralf Trønnes * paths are protected, they will not run on regular driver module unload, 422de99f060SNoralf Trønnes * possibily leaving the hardware enabled. 4236e3f797cSDaniel Vetter */ 4246e3f797cSDaniel Vetter 4256e3f797cSDaniel Vetter /** 42621d70354SDave Airlie * drm_put_dev - Unregister and release a DRM device 42721d70354SDave Airlie * @dev: DRM device 42821d70354SDave Airlie * 42921d70354SDave Airlie * Called at module unload time or when a PCI device is unplugged. 43021d70354SDave Airlie * 43121d70354SDave Airlie * Cleans up all DRM device, calling drm_lastclose(). 4326e3f797cSDaniel Vetter * 4336e3f797cSDaniel Vetter * Note: Use of this function is deprecated. It will eventually go away 4349a96f550SAishwarya Pant * completely. Please use drm_dev_unregister() and drm_dev_put() explicitly 4356e3f797cSDaniel Vetter * instead to make sure that the device isn't userspace accessible any more 4366e3f797cSDaniel Vetter * while teardown is in progress, ensuring that userspace can't access an 4376e3f797cSDaniel Vetter * inconsistent state. 43821d70354SDave Airlie */ 43921d70354SDave Airlie void drm_put_dev(struct drm_device *dev) 44021d70354SDave Airlie { 44121d70354SDave Airlie DRM_DEBUG("\n"); 44221d70354SDave Airlie 44321d70354SDave Airlie if (!dev) { 44421d70354SDave Airlie DRM_ERROR("cleanup called no dev\n"); 44521d70354SDave Airlie return; 44621d70354SDave Airlie } 44721d70354SDave Airlie 44821d70354SDave Airlie drm_dev_unregister(dev); 4499a96f550SAishwarya Pant drm_dev_put(dev); 45021d70354SDave Airlie } 45121d70354SDave Airlie EXPORT_SYMBOL(drm_put_dev); 45221d70354SDave Airlie 453bee330f3SNoralf Trønnes /** 454bee330f3SNoralf Trønnes * drm_dev_enter - Enter device critical section 455bee330f3SNoralf Trønnes * @dev: DRM device 456bee330f3SNoralf Trønnes * @idx: Pointer to index that will be passed to the matching drm_dev_exit() 457bee330f3SNoralf Trønnes * 458bee330f3SNoralf Trønnes * This function marks and protects the beginning of a section that should not 459bee330f3SNoralf Trønnes * be entered after the device has been unplugged. The section end is marked 460bee330f3SNoralf Trønnes * with drm_dev_exit(). Calls to this function can be nested. 461bee330f3SNoralf Trønnes * 462bee330f3SNoralf Trønnes * Returns: 463bee330f3SNoralf Trønnes * True if it is OK to enter the section, false otherwise. 464bee330f3SNoralf Trønnes */ 465bee330f3SNoralf Trønnes bool drm_dev_enter(struct drm_device *dev, int *idx) 466c07dcd61SDaniel Vetter { 467bee330f3SNoralf Trønnes *idx = srcu_read_lock(&drm_unplug_srcu); 468bee330f3SNoralf Trønnes 469bee330f3SNoralf Trønnes if (dev->unplugged) { 470bee330f3SNoralf Trønnes srcu_read_unlock(&drm_unplug_srcu, *idx); 471bee330f3SNoralf Trønnes return false; 472c07dcd61SDaniel Vetter } 473c07dcd61SDaniel Vetter 474bee330f3SNoralf Trønnes return true; 475bee330f3SNoralf Trønnes } 476bee330f3SNoralf Trønnes EXPORT_SYMBOL(drm_dev_enter); 477bee330f3SNoralf Trønnes 478bee330f3SNoralf Trønnes /** 479bee330f3SNoralf Trønnes * drm_dev_exit - Exit device critical section 480bee330f3SNoralf Trønnes * @idx: index returned from drm_dev_enter() 481bee330f3SNoralf Trønnes * 482bee330f3SNoralf Trønnes * This function marks the end of a section that should not be entered after 483bee330f3SNoralf Trønnes * the device has been unplugged. 484bee330f3SNoralf Trønnes */ 485bee330f3SNoralf Trønnes void drm_dev_exit(int idx) 486bee330f3SNoralf Trønnes { 487bee330f3SNoralf Trønnes srcu_read_unlock(&drm_unplug_srcu, idx); 488bee330f3SNoralf Trønnes } 489bee330f3SNoralf Trønnes EXPORT_SYMBOL(drm_dev_exit); 490bee330f3SNoralf Trønnes 491c07dcd61SDaniel Vetter /** 492c07dcd61SDaniel Vetter * drm_dev_unplug - unplug a DRM device 493c07dcd61SDaniel Vetter * @dev: DRM device 494c07dcd61SDaniel Vetter * 495c07dcd61SDaniel Vetter * This unplugs a hotpluggable DRM device, which makes it inaccessible to 496bee330f3SNoralf Trønnes * userspace operations. Entry-points can use drm_dev_enter() and 497bee330f3SNoralf Trønnes * drm_dev_exit() to protect device resources in a race free manner. This 498c07dcd61SDaniel Vetter * essentially unregisters the device like drm_dev_unregister(), but can be 499c07dcd61SDaniel Vetter * called while there are still open users of @dev. 500c07dcd61SDaniel Vetter */ 501c07dcd61SDaniel Vetter void drm_dev_unplug(struct drm_device *dev) 50221d70354SDave Airlie { 503bee330f3SNoralf Trønnes /* 504bee330f3SNoralf Trønnes * After synchronizing any critical read section is guaranteed to see 505bee330f3SNoralf Trønnes * the new value of ->unplugged, and any critical section which might 506bee330f3SNoralf Trønnes * still have seen the old value of ->unplugged is guaranteed to have 507bee330f3SNoralf Trønnes * finished. 508bee330f3SNoralf Trønnes */ 509bee330f3SNoralf Trønnes dev->unplugged = true; 510bee330f3SNoralf Trønnes synchronize_srcu(&drm_unplug_srcu); 511069035c5SOleksandr Andrushchenko 512069035c5SOleksandr Andrushchenko drm_dev_unregister(dev); 51321d70354SDave Airlie } 514c07dcd61SDaniel Vetter EXPORT_SYMBOL(drm_dev_unplug); 51521d70354SDave Airlie 51621d70354SDave Airlie /* 51721d70354SDave Airlie * DRM internal mount 51821d70354SDave Airlie * We want to be able to allocate our own "struct address_space" to control 51921d70354SDave Airlie * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow 52021d70354SDave Airlie * stand-alone address_space objects, so we need an underlying inode. As there 52121d70354SDave Airlie * is no way to allocate an independent inode easily, we need a fake internal 52221d70354SDave Airlie * VFS mount-point. 52321d70354SDave Airlie * 52421d70354SDave Airlie * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free() 52521d70354SDave Airlie * frees it again. You are allowed to use iget() and iput() to get references to 52621d70354SDave Airlie * the inode. But each drm_fs_inode_new() call must be paired with exactly one 52721d70354SDave Airlie * drm_fs_inode_free() call (which does not have to be the last iput()). 52821d70354SDave Airlie * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it 52921d70354SDave Airlie * between multiple inode-users. You could, technically, call 53021d70354SDave Airlie * iget() + drm_fs_inode_free() directly after alloc and sometime later do an 53121d70354SDave Airlie * iput(), but this way you'd end up with a new vfsmount for each inode. 53221d70354SDave Airlie */ 53321d70354SDave Airlie 53421d70354SDave Airlie static int drm_fs_cnt; 53521d70354SDave Airlie static struct vfsmount *drm_fs_mnt; 53621d70354SDave Airlie 5374a457910SDavid Howells static int drm_fs_init_fs_context(struct fs_context *fc) 53821d70354SDave Airlie { 5394a457910SDavid Howells return init_pseudo(fc, 0x010203ff) ? 0 : -ENOMEM; 54021d70354SDave Airlie } 54121d70354SDave Airlie 54221d70354SDave Airlie static struct file_system_type drm_fs_type = { 54321d70354SDave Airlie .name = "drm", 54421d70354SDave Airlie .owner = THIS_MODULE, 5454a457910SDavid Howells .init_fs_context = drm_fs_init_fs_context, 54621d70354SDave Airlie .kill_sb = kill_anon_super, 54721d70354SDave Airlie }; 54821d70354SDave Airlie 54921d70354SDave Airlie static struct inode *drm_fs_inode_new(void) 55021d70354SDave Airlie { 55121d70354SDave Airlie struct inode *inode; 55221d70354SDave Airlie int r; 55321d70354SDave Airlie 55421d70354SDave Airlie r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt); 55521d70354SDave Airlie if (r < 0) { 55621d70354SDave Airlie DRM_ERROR("Cannot mount pseudo fs: %d\n", r); 55721d70354SDave Airlie return ERR_PTR(r); 55821d70354SDave Airlie } 55921d70354SDave Airlie 56021d70354SDave Airlie inode = alloc_anon_inode(drm_fs_mnt->mnt_sb); 56121d70354SDave Airlie if (IS_ERR(inode)) 56221d70354SDave Airlie simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 56321d70354SDave Airlie 56421d70354SDave Airlie return inode; 56521d70354SDave Airlie } 56621d70354SDave Airlie 56721d70354SDave Airlie static void drm_fs_inode_free(struct inode *inode) 56821d70354SDave Airlie { 56921d70354SDave Airlie if (inode) { 57021d70354SDave Airlie iput(inode); 57121d70354SDave Airlie simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 57221d70354SDave Airlie } 57321d70354SDave Airlie } 57421d70354SDave Airlie 57521d70354SDave Airlie /** 57686ab67dfSDaniel Vetter * DOC: component helper usage recommendations 57786ab67dfSDaniel Vetter * 57886ab67dfSDaniel Vetter * DRM drivers that drive hardware where a logical device consists of a pile of 57986ab67dfSDaniel Vetter * independent hardware blocks are recommended to use the :ref:`component helper 58086ab67dfSDaniel Vetter * library<component>`. For consistency and better options for code reuse the 58186ab67dfSDaniel Vetter * following guidelines apply: 58286ab67dfSDaniel Vetter * 58386ab67dfSDaniel Vetter * - The entire device initialization procedure should be run from the 58486ab67dfSDaniel Vetter * &component_master_ops.master_bind callback, starting with drm_dev_init(), 58586ab67dfSDaniel Vetter * then binding all components with component_bind_all() and finishing with 58686ab67dfSDaniel Vetter * drm_dev_register(). 58786ab67dfSDaniel Vetter * 58886ab67dfSDaniel Vetter * - The opaque pointer passed to all components through component_bind_all() 58986ab67dfSDaniel Vetter * should point at &struct drm_device of the device instance, not some driver 59086ab67dfSDaniel Vetter * specific private structure. 59186ab67dfSDaniel Vetter * 59286ab67dfSDaniel Vetter * - The component helper fills the niche where further standardization of 59386ab67dfSDaniel Vetter * interfaces is not practical. When there already is, or will be, a 59486ab67dfSDaniel Vetter * standardized interface like &drm_bridge or &drm_panel, providing its own 59586ab67dfSDaniel Vetter * functions to find such components at driver load time, like 59686ab67dfSDaniel Vetter * drm_of_find_panel_or_bridge(), then the component helper should not be 59786ab67dfSDaniel Vetter * used. 59886ab67dfSDaniel Vetter */ 59986ab67dfSDaniel Vetter 60086ab67dfSDaniel Vetter /** 601b209aca3SChris Wilson * drm_dev_init - Initialise new DRM device 602b209aca3SChris Wilson * @dev: DRM device 603b209aca3SChris Wilson * @driver: DRM driver 60421d70354SDave Airlie * @parent: Parent device object 60521d70354SDave Airlie * 606b209aca3SChris Wilson * Initialize a new DRM device. No device registration is done. 60721d70354SDave Airlie * Call drm_dev_register() to advertice the device to user space and register it 6086e3f797cSDaniel Vetter * with other core subsystems. This should be done last in the device 6096e3f797cSDaniel Vetter * initialization sequence to make sure userspace can't access an inconsistent 6106e3f797cSDaniel Vetter * state. 61121d70354SDave Airlie * 6129a96f550SAishwarya Pant * The initial ref-count of the object is 1. Use drm_dev_get() and 6139a96f550SAishwarya Pant * drm_dev_put() to take and drop further ref-counts. 61421d70354SDave Airlie * 61533e70110SDaniel Vetter * It is recommended that drivers embed &struct drm_device into their own device 61633e70110SDaniel Vetter * structure. 61733e70110SDaniel Vetter * 618b209aca3SChris Wilson * Drivers that do not want to allocate their own device struct 619ea0dd85aSDaniel Vetter * embedding &struct drm_device can call drm_dev_alloc() instead. For drivers 620ea0dd85aSDaniel Vetter * that do embed &struct drm_device it must be placed first in the overall 621d82faafdSDaniel Vetter * structure, and the overall structure must be allocated using kmalloc(): The 622d82faafdSDaniel Vetter * drm core's release function unconditionally calls kfree() on the @dev pointer 623f30c9257SChris Wilson * when the final reference is released. To override this behaviour, and so 624f30c9257SChris Wilson * allow embedding of the drm_device inside the driver's device struct at an 625f30c9257SChris Wilson * arbitrary offset, you must supply a &drm_driver.release callback and control 626f30c9257SChris Wilson * the finalization explicitly. 627b209aca3SChris Wilson * 62821d70354SDave Airlie * RETURNS: 629b209aca3SChris Wilson * 0 on success, or error code on failure. 63021d70354SDave Airlie */ 631b209aca3SChris Wilson int drm_dev_init(struct drm_device *dev, 632b209aca3SChris Wilson struct drm_driver *driver, 63321d70354SDave Airlie struct device *parent) 63421d70354SDave Airlie { 63521d70354SDave Airlie int ret; 63621d70354SDave Airlie 637371c2279SAlexandru Moise if (!drm_core_init_complete) { 638371c2279SAlexandru Moise DRM_ERROR("DRM core is not initialized\n"); 639371c2279SAlexandru Moise return -ENODEV; 640371c2279SAlexandru Moise } 641371c2279SAlexandru Moise 642f08877e7SEmil Velikov BUG_ON(!parent); 643f08877e7SEmil Velikov 64421d70354SDave Airlie kref_init(&dev->ref); 64556be6503SNoralf Trønnes dev->dev = get_device(parent); 64621d70354SDave Airlie dev->driver = driver; 64721d70354SDave Airlie 64818ace11fSVille Syrjälä /* no per-device feature limits by default */ 64918ace11fSVille Syrjälä dev->driver_features = ~0u; 65018ace11fSVille Syrjälä 6518437dd73SDave Airlie drm_legacy_init_members(dev); 65221d70354SDave Airlie INIT_LIST_HEAD(&dev->filelist); 653c76f0f7cSNoralf Trønnes INIT_LIST_HEAD(&dev->filelist_internal); 654c76f0f7cSNoralf Trønnes INIT_LIST_HEAD(&dev->clientlist); 65521d70354SDave Airlie INIT_LIST_HEAD(&dev->vblank_event_list); 65621d70354SDave Airlie 65721d70354SDave Airlie spin_lock_init(&dev->event_lock); 65821d70354SDave Airlie mutex_init(&dev->struct_mutex); 6591d2ac403SDaniel Vetter mutex_init(&dev->filelist_mutex); 660c76f0f7cSNoralf Trønnes mutex_init(&dev->clientlist_mutex); 66121d70354SDave Airlie mutex_init(&dev->master_mutex); 66221d70354SDave Airlie 66321d70354SDave Airlie dev->anon_inode = drm_fs_inode_new(); 66421d70354SDave Airlie if (IS_ERR(dev->anon_inode)) { 66521d70354SDave Airlie ret = PTR_ERR(dev->anon_inode); 66621d70354SDave Airlie DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret); 66721d70354SDave Airlie goto err_free; 66821d70354SDave Airlie } 66921d70354SDave Airlie 67021d70354SDave Airlie if (drm_core_check_feature(dev, DRIVER_RENDER)) { 67121d70354SDave Airlie ret = drm_minor_alloc(dev, DRM_MINOR_RENDER); 67221d70354SDave Airlie if (ret) 67321d70354SDave Airlie goto err_minors; 67421d70354SDave Airlie } 67521d70354SDave Airlie 676a3ccc461SDavid Herrmann ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY); 67721d70354SDave Airlie if (ret) 67821d70354SDave Airlie goto err_minors; 67921d70354SDave Airlie 680fabb0e2aSDave Airlie ret = drm_legacy_create_map_hash(dev); 681b209aca3SChris Wilson if (ret) 68221d70354SDave Airlie goto err_minors; 68321d70354SDave Airlie 684ba6976c1SDaniel Vetter drm_legacy_ctxbitmap_init(dev); 68521d70354SDave Airlie 6861bcecfacSAndrzej Hajda if (drm_core_check_feature(dev, DRIVER_GEM)) { 68721d70354SDave Airlie ret = drm_gem_init(dev); 68821d70354SDave Airlie if (ret) { 68921d70354SDave Airlie DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n"); 69021d70354SDave Airlie goto err_ctxbitmap; 69121d70354SDave Airlie } 69221d70354SDave Airlie } 69321d70354SDave Airlie 694f08877e7SEmil Velikov ret = drm_dev_set_unique(dev, dev_name(parent)); 695e112e593SNicolas Iooss if (ret) 696e112e593SNicolas Iooss goto err_setunique; 697e112e593SNicolas Iooss 698b209aca3SChris Wilson return 0; 69921d70354SDave Airlie 700e112e593SNicolas Iooss err_setunique: 701e112e593SNicolas Iooss if (drm_core_check_feature(dev, DRIVER_GEM)) 702e112e593SNicolas Iooss drm_gem_destroy(dev); 70321d70354SDave Airlie err_ctxbitmap: 70421d70354SDave Airlie drm_legacy_ctxbitmap_cleanup(dev); 705fabb0e2aSDave Airlie drm_legacy_remove_map_hash(dev); 70621d70354SDave Airlie err_minors: 707a3ccc461SDavid Herrmann drm_minor_free(dev, DRM_MINOR_PRIMARY); 70821d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_RENDER); 70921d70354SDave Airlie drm_fs_inode_free(dev->anon_inode); 71021d70354SDave Airlie err_free: 71156be6503SNoralf Trønnes put_device(dev->dev); 71221d70354SDave Airlie mutex_destroy(&dev->master_mutex); 713c76f0f7cSNoralf Trønnes mutex_destroy(&dev->clientlist_mutex); 714f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->filelist_mutex); 715f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->struct_mutex); 7168437dd73SDave Airlie drm_legacy_destroy_members(dev); 717b209aca3SChris Wilson return ret; 718b209aca3SChris Wilson } 719b209aca3SChris Wilson EXPORT_SYMBOL(drm_dev_init); 720b209aca3SChris Wilson 7219b1f1b6bSNoralf Trønnes static void devm_drm_dev_init_release(void *data) 7229b1f1b6bSNoralf Trønnes { 7239b1f1b6bSNoralf Trønnes drm_dev_put(data); 7249b1f1b6bSNoralf Trønnes } 7259b1f1b6bSNoralf Trønnes 7269b1f1b6bSNoralf Trønnes /** 7279b1f1b6bSNoralf Trønnes * devm_drm_dev_init - Resource managed drm_dev_init() 7289b1f1b6bSNoralf Trønnes * @parent: Parent device object 7299b1f1b6bSNoralf Trønnes * @dev: DRM device 7309b1f1b6bSNoralf Trønnes * @driver: DRM driver 7319b1f1b6bSNoralf Trønnes * 7329b1f1b6bSNoralf Trønnes * Managed drm_dev_init(). The DRM device initialized with this function is 7339b1f1b6bSNoralf Trønnes * automatically put on driver detach using drm_dev_put(). You must supply a 7349b1f1b6bSNoralf Trønnes * &drm_driver.release callback to control the finalization explicitly. 7359b1f1b6bSNoralf Trønnes * 7369b1f1b6bSNoralf Trønnes * RETURNS: 7379b1f1b6bSNoralf Trønnes * 0 on success, or error code on failure. 7389b1f1b6bSNoralf Trønnes */ 7399b1f1b6bSNoralf Trønnes int devm_drm_dev_init(struct device *parent, 7409b1f1b6bSNoralf Trønnes struct drm_device *dev, 7419b1f1b6bSNoralf Trønnes struct drm_driver *driver) 7429b1f1b6bSNoralf Trønnes { 7439b1f1b6bSNoralf Trønnes int ret; 7449b1f1b6bSNoralf Trønnes 7459b1f1b6bSNoralf Trønnes if (WARN_ON(!parent || !driver->release)) 7469b1f1b6bSNoralf Trønnes return -EINVAL; 7479b1f1b6bSNoralf Trønnes 7489b1f1b6bSNoralf Trønnes ret = drm_dev_init(dev, driver, parent); 7499b1f1b6bSNoralf Trønnes if (ret) 7509b1f1b6bSNoralf Trønnes return ret; 7519b1f1b6bSNoralf Trønnes 7529b1f1b6bSNoralf Trønnes ret = devm_add_action(parent, devm_drm_dev_init_release, dev); 7539b1f1b6bSNoralf Trønnes if (ret) 7549b1f1b6bSNoralf Trønnes devm_drm_dev_init_release(dev); 7559b1f1b6bSNoralf Trønnes 7569b1f1b6bSNoralf Trønnes return ret; 7579b1f1b6bSNoralf Trønnes } 7589b1f1b6bSNoralf Trønnes EXPORT_SYMBOL(devm_drm_dev_init); 7599b1f1b6bSNoralf Trønnes 760b209aca3SChris Wilson /** 761f30c9257SChris Wilson * drm_dev_fini - Finalize a dead DRM device 762f30c9257SChris Wilson * @dev: DRM device 763f30c9257SChris Wilson * 764f30c9257SChris Wilson * Finalize a dead DRM device. This is the converse to drm_dev_init() and 765f30c9257SChris Wilson * frees up all data allocated by it. All driver private data should be 766f30c9257SChris Wilson * finalized first. Note that this function does not free the @dev, that is 767f30c9257SChris Wilson * left to the caller. 768f30c9257SChris Wilson * 769f30c9257SChris Wilson * The ref-count of @dev must be zero, and drm_dev_fini() should only be called 770f30c9257SChris Wilson * from a &drm_driver.release callback. 771f30c9257SChris Wilson */ 772f30c9257SChris Wilson void drm_dev_fini(struct drm_device *dev) 773f30c9257SChris Wilson { 774f30c9257SChris Wilson drm_vblank_cleanup(dev); 775f30c9257SChris Wilson 776f30c9257SChris Wilson if (drm_core_check_feature(dev, DRIVER_GEM)) 777f30c9257SChris Wilson drm_gem_destroy(dev); 778f30c9257SChris Wilson 779f30c9257SChris Wilson drm_legacy_ctxbitmap_cleanup(dev); 780fabb0e2aSDave Airlie drm_legacy_remove_map_hash(dev); 781f30c9257SChris Wilson drm_fs_inode_free(dev->anon_inode); 782f30c9257SChris Wilson 783f30c9257SChris Wilson drm_minor_free(dev, DRM_MINOR_PRIMARY); 784f30c9257SChris Wilson drm_minor_free(dev, DRM_MINOR_RENDER); 785f30c9257SChris Wilson 78656be6503SNoralf Trønnes put_device(dev->dev); 78756be6503SNoralf Trønnes 788f30c9257SChris Wilson mutex_destroy(&dev->master_mutex); 789c76f0f7cSNoralf Trønnes mutex_destroy(&dev->clientlist_mutex); 790f30c9257SChris Wilson mutex_destroy(&dev->filelist_mutex); 791f30c9257SChris Wilson mutex_destroy(&dev->struct_mutex); 7928437dd73SDave Airlie drm_legacy_destroy_members(dev); 793f30c9257SChris Wilson kfree(dev->unique); 794f30c9257SChris Wilson } 795f30c9257SChris Wilson EXPORT_SYMBOL(drm_dev_fini); 796f30c9257SChris Wilson 797f30c9257SChris Wilson /** 798b209aca3SChris Wilson * drm_dev_alloc - Allocate new DRM device 799b209aca3SChris Wilson * @driver: DRM driver to allocate device for 800b209aca3SChris Wilson * @parent: Parent device object 801b209aca3SChris Wilson * 802b209aca3SChris Wilson * Allocate and initialize a new DRM device. No device registration is done. 803b209aca3SChris Wilson * Call drm_dev_register() to advertice the device to user space and register it 804b209aca3SChris Wilson * with other core subsystems. This should be done last in the device 805b209aca3SChris Wilson * initialization sequence to make sure userspace can't access an inconsistent 806b209aca3SChris Wilson * state. 807b209aca3SChris Wilson * 8089a96f550SAishwarya Pant * The initial ref-count of the object is 1. Use drm_dev_get() and 8099a96f550SAishwarya Pant * drm_dev_put() to take and drop further ref-counts. 810b209aca3SChris Wilson * 811b209aca3SChris Wilson * Note that for purely virtual devices @parent can be NULL. 812b209aca3SChris Wilson * 813ea0dd85aSDaniel Vetter * Drivers that wish to subclass or embed &struct drm_device into their 814b209aca3SChris Wilson * own struct should look at using drm_dev_init() instead. 815b209aca3SChris Wilson * 816b209aca3SChris Wilson * RETURNS: 8170f288605STom Gundersen * Pointer to new DRM device, or ERR_PTR on failure. 818b209aca3SChris Wilson */ 819b209aca3SChris Wilson struct drm_device *drm_dev_alloc(struct drm_driver *driver, 820b209aca3SChris Wilson struct device *parent) 821b209aca3SChris Wilson { 822b209aca3SChris Wilson struct drm_device *dev; 823b209aca3SChris Wilson int ret; 824b209aca3SChris Wilson 825b209aca3SChris Wilson dev = kzalloc(sizeof(*dev), GFP_KERNEL); 826b209aca3SChris Wilson if (!dev) 8270f288605STom Gundersen return ERR_PTR(-ENOMEM); 828b209aca3SChris Wilson 829b209aca3SChris Wilson ret = drm_dev_init(dev, driver, parent); 830b209aca3SChris Wilson if (ret) { 83121d70354SDave Airlie kfree(dev); 8320f288605STom Gundersen return ERR_PTR(ret); 83321d70354SDave Airlie } 834b209aca3SChris Wilson 835b209aca3SChris Wilson return dev; 836b209aca3SChris Wilson } 83721d70354SDave Airlie EXPORT_SYMBOL(drm_dev_alloc); 83821d70354SDave Airlie 83921d70354SDave Airlie static void drm_dev_release(struct kref *ref) 84021d70354SDave Airlie { 84121d70354SDave Airlie struct drm_device *dev = container_of(ref, struct drm_device, ref); 84221d70354SDave Airlie 843f30c9257SChris Wilson if (dev->driver->release) { 844f30c9257SChris Wilson dev->driver->release(dev); 845f30c9257SChris Wilson } else { 846f30c9257SChris Wilson drm_dev_fini(dev); 84721d70354SDave Airlie kfree(dev); 84821d70354SDave Airlie } 849f30c9257SChris Wilson } 85021d70354SDave Airlie 85121d70354SDave Airlie /** 8529a96f550SAishwarya Pant * drm_dev_get - Take reference of a DRM device 85321d70354SDave Airlie * @dev: device to take reference of or NULL 85421d70354SDave Airlie * 85521d70354SDave Airlie * This increases the ref-count of @dev by one. You *must* already own a 8569a96f550SAishwarya Pant * reference when calling this. Use drm_dev_put() to drop this reference 85721d70354SDave Airlie * again. 85821d70354SDave Airlie * 85921d70354SDave Airlie * This function never fails. However, this function does not provide *any* 86021d70354SDave Airlie * guarantee whether the device is alive or running. It only provides a 86121d70354SDave Airlie * reference to the object and the memory associated with it. 86221d70354SDave Airlie */ 8639a96f550SAishwarya Pant void drm_dev_get(struct drm_device *dev) 86421d70354SDave Airlie { 86521d70354SDave Airlie if (dev) 86621d70354SDave Airlie kref_get(&dev->ref); 86721d70354SDave Airlie } 8689a96f550SAishwarya Pant EXPORT_SYMBOL(drm_dev_get); 86921d70354SDave Airlie 87021d70354SDave Airlie /** 8719a96f550SAishwarya Pant * drm_dev_put - Drop reference of a DRM device 87221d70354SDave Airlie * @dev: device to drop reference of or NULL 87321d70354SDave Airlie * 87421d70354SDave Airlie * This decreases the ref-count of @dev by one. The device is destroyed if the 87521d70354SDave Airlie * ref-count drops to zero. 87621d70354SDave Airlie */ 8779a96f550SAishwarya Pant void drm_dev_put(struct drm_device *dev) 87821d70354SDave Airlie { 87921d70354SDave Airlie if (dev) 88021d70354SDave Airlie kref_put(&dev->ref, drm_dev_release); 88121d70354SDave Airlie } 8829a96f550SAishwarya Pant EXPORT_SYMBOL(drm_dev_put); 8839a96f550SAishwarya Pant 8846449b088SDaniel Vetter static int create_compat_control_link(struct drm_device *dev) 8856449b088SDaniel Vetter { 8866449b088SDaniel Vetter struct drm_minor *minor; 8876449b088SDaniel Vetter char *name; 8886449b088SDaniel Vetter int ret; 8896449b088SDaniel Vetter 8906449b088SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 8916449b088SDaniel Vetter return 0; 8926449b088SDaniel Vetter 8936449b088SDaniel Vetter minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 8946449b088SDaniel Vetter if (!minor) 8956449b088SDaniel Vetter return 0; 8966449b088SDaniel Vetter 8976449b088SDaniel Vetter /* 8986449b088SDaniel Vetter * Some existing userspace out there uses the existing of the controlD* 8996449b088SDaniel Vetter * sysfs files to figure out whether it's a modeset driver. It only does 9006449b088SDaniel Vetter * readdir, hence a symlink is sufficient (and the least confusing 9016449b088SDaniel Vetter * option). Otherwise controlD* is entirely unused. 9026449b088SDaniel Vetter * 9036449b088SDaniel Vetter * Old controlD chardev have been allocated in the range 9046449b088SDaniel Vetter * 64-127. 9056449b088SDaniel Vetter */ 9066449b088SDaniel Vetter name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 9076449b088SDaniel Vetter if (!name) 9086449b088SDaniel Vetter return -ENOMEM; 9096449b088SDaniel Vetter 9106449b088SDaniel Vetter ret = sysfs_create_link(minor->kdev->kobj.parent, 9116449b088SDaniel Vetter &minor->kdev->kobj, 9126449b088SDaniel Vetter name); 9136449b088SDaniel Vetter 9146449b088SDaniel Vetter kfree(name); 9156449b088SDaniel Vetter 9166449b088SDaniel Vetter return ret; 9176449b088SDaniel Vetter } 9186449b088SDaniel Vetter 9196449b088SDaniel Vetter static void remove_compat_control_link(struct drm_device *dev) 9206449b088SDaniel Vetter { 9216449b088SDaniel Vetter struct drm_minor *minor; 9226449b088SDaniel Vetter char *name; 9236449b088SDaniel Vetter 9246449b088SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 9256449b088SDaniel Vetter return; 9266449b088SDaniel Vetter 9276449b088SDaniel Vetter minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 9286449b088SDaniel Vetter if (!minor) 9296449b088SDaniel Vetter return; 9306449b088SDaniel Vetter 9317f6df440SHaneen Mohammed name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 9326449b088SDaniel Vetter if (!name) 9336449b088SDaniel Vetter return; 9346449b088SDaniel Vetter 9356449b088SDaniel Vetter sysfs_remove_link(minor->kdev->kobj.parent, name); 9366449b088SDaniel Vetter 9376449b088SDaniel Vetter kfree(name); 9386449b088SDaniel Vetter } 9396449b088SDaniel Vetter 94021d70354SDave Airlie /** 94121d70354SDave Airlie * drm_dev_register - Register DRM device 94221d70354SDave Airlie * @dev: Device to register 94321d70354SDave Airlie * @flags: Flags passed to the driver's .load() function 94421d70354SDave Airlie * 94521d70354SDave Airlie * Register the DRM device @dev with the system, advertise device to user-space 94633e70110SDaniel Vetter * and start normal device operation. @dev must be initialized via drm_dev_init() 947e28cd4d0SChris Wilson * previously. 94821d70354SDave Airlie * 94921d70354SDave Airlie * Never call this twice on any device! 95021d70354SDave Airlie * 9516e3f797cSDaniel Vetter * NOTE: To ensure backward compatibility with existing drivers method this 952ef40cbf9SDaniel Vetter * function calls the &drm_driver.load method after registering the device 953ef40cbf9SDaniel Vetter * nodes, creating race conditions. Usage of the &drm_driver.load methods is 954ef40cbf9SDaniel Vetter * therefore deprecated, drivers must perform all initialization before calling 9556e3f797cSDaniel Vetter * drm_dev_register(). 9566e3f797cSDaniel Vetter * 95721d70354SDave Airlie * RETURNS: 95821d70354SDave Airlie * 0 on success, negative error code on failure. 95921d70354SDave Airlie */ 96021d70354SDave Airlie int drm_dev_register(struct drm_device *dev, unsigned long flags) 96121d70354SDave Airlie { 96275f6dfe3SGabriel Krisman Bertazi struct drm_driver *driver = dev->driver; 96321d70354SDave Airlie int ret; 96421d70354SDave Airlie 96521d70354SDave Airlie mutex_lock(&drm_global_mutex); 96621d70354SDave Airlie 96721d70354SDave Airlie ret = drm_minor_register(dev, DRM_MINOR_RENDER); 96821d70354SDave Airlie if (ret) 96921d70354SDave Airlie goto err_minors; 97021d70354SDave Airlie 971a3ccc461SDavid Herrmann ret = drm_minor_register(dev, DRM_MINOR_PRIMARY); 97221d70354SDave Airlie if (ret) 97321d70354SDave Airlie goto err_minors; 97421d70354SDave Airlie 9756449b088SDaniel Vetter ret = create_compat_control_link(dev); 9766449b088SDaniel Vetter if (ret) 9776449b088SDaniel Vetter goto err_minors; 9786449b088SDaniel Vetter 979e0f32f78SDaniel Vetter dev->registered = true; 980e0f32f78SDaniel Vetter 98121d70354SDave Airlie if (dev->driver->load) { 98221d70354SDave Airlie ret = dev->driver->load(dev, flags); 98321d70354SDave Airlie if (ret) 98421d70354SDave Airlie goto err_minors; 98521d70354SDave Airlie } 98621d70354SDave Airlie 987bee7fb15SChris Wilson if (drm_core_check_feature(dev, DRIVER_MODESET)) 98879190ea2SBenjamin Gaignard drm_modeset_register_all(dev); 989e28cd4d0SChris Wilson 99021d70354SDave Airlie ret = 0; 99175f6dfe3SGabriel Krisman Bertazi 99275f6dfe3SGabriel Krisman Bertazi DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", 99375f6dfe3SGabriel Krisman Bertazi driver->name, driver->major, driver->minor, 9946098909cSChris Wilson driver->patchlevel, driver->date, 9956098909cSChris Wilson dev->dev ? dev_name(dev->dev) : "virtual device", 99675f6dfe3SGabriel Krisman Bertazi dev->primary->index); 99775f6dfe3SGabriel Krisman Bertazi 99821d70354SDave Airlie goto out_unlock; 99921d70354SDave Airlie 100021d70354SDave Airlie err_minors: 10016449b088SDaniel Vetter remove_compat_control_link(dev); 1002a3ccc461SDavid Herrmann drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 100321d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 100421d70354SDave Airlie out_unlock: 100521d70354SDave Airlie mutex_unlock(&drm_global_mutex); 100621d70354SDave Airlie return ret; 100721d70354SDave Airlie } 100821d70354SDave Airlie EXPORT_SYMBOL(drm_dev_register); 100921d70354SDave Airlie 101021d70354SDave Airlie /** 101121d70354SDave Airlie * drm_dev_unregister - Unregister DRM device 101221d70354SDave Airlie * @dev: Device to unregister 101321d70354SDave Airlie * 101421d70354SDave Airlie * Unregister the DRM device from the system. This does the reverse of 101521d70354SDave Airlie * drm_dev_register() but does not deallocate the device. The caller must call 10169a96f550SAishwarya Pant * drm_dev_put() to drop their final reference. 10176e3f797cSDaniel Vetter * 1018c07dcd61SDaniel Vetter * A special form of unregistering for hotpluggable devices is drm_dev_unplug(), 1019c07dcd61SDaniel Vetter * which can be called while there are still open users of @dev. 1020c07dcd61SDaniel Vetter * 10216e3f797cSDaniel Vetter * This should be called first in the device teardown code to make sure 10226e3f797cSDaniel Vetter * userspace can't access the device instance any more. 102321d70354SDave Airlie */ 102421d70354SDave Airlie void drm_dev_unregister(struct drm_device *dev) 102521d70354SDave Airlie { 10262e45eeacSDaniel Vetter if (drm_core_check_feature(dev, DRIVER_LEGACY)) 102721d70354SDave Airlie drm_lastclose(dev); 102821d70354SDave Airlie 1029e6e7b48bSDaniel Vetter dev->registered = false; 1030e6e7b48bSDaniel Vetter 1031c76f0f7cSNoralf Trønnes drm_client_dev_unregister(dev); 1032c76f0f7cSNoralf Trønnes 1033bee7fb15SChris Wilson if (drm_core_check_feature(dev, DRIVER_MODESET)) 103479190ea2SBenjamin Gaignard drm_modeset_unregister_all(dev); 1035e28cd4d0SChris Wilson 103621d70354SDave Airlie if (dev->driver->unload) 103721d70354SDave Airlie dev->driver->unload(dev); 103821d70354SDave Airlie 103921d70354SDave Airlie if (dev->agp) 104021d70354SDave Airlie drm_pci_agp_destroy(dev); 104121d70354SDave Airlie 104235a28021SDave Airlie drm_legacy_rmmaps(dev); 104321d70354SDave Airlie 10446449b088SDaniel Vetter remove_compat_control_link(dev); 1045a3ccc461SDavid Herrmann drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 104621d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 104721d70354SDave Airlie } 104821d70354SDave Airlie EXPORT_SYMBOL(drm_dev_unregister); 104921d70354SDave Airlie 1050a6b5fac5SGerd Hoffmann /** 1051a6b5fac5SGerd Hoffmann * drm_dev_set_unique - Set the unique name of a DRM device 1052a6b5fac5SGerd Hoffmann * @dev: device of which to set the unique name 1053a6b5fac5SGerd Hoffmann * @name: unique name 1054a6b5fac5SGerd Hoffmann * 105533e70110SDaniel Vetter * Sets the unique name of a DRM device using the specified string. This is 105633e70110SDaniel Vetter * already done by drm_dev_init(), drivers should only override the default 105733e70110SDaniel Vetter * unique name for backwards compatibility reasons. 1058a6b5fac5SGerd Hoffmann * 1059a6b5fac5SGerd Hoffmann * Return: 0 on success or a negative error code on failure. 1060a6b5fac5SGerd Hoffmann */ 1061a6b5fac5SGerd Hoffmann int drm_dev_set_unique(struct drm_device *dev, const char *name) 1062a6b5fac5SGerd Hoffmann { 1063a6b5fac5SGerd Hoffmann kfree(dev->unique); 1064a6b5fac5SGerd Hoffmann dev->unique = kstrdup(name, GFP_KERNEL); 1065a6b5fac5SGerd Hoffmann 1066a6b5fac5SGerd Hoffmann return dev->unique ? 0 : -ENOMEM; 1067a6b5fac5SGerd Hoffmann } 1068a6b5fac5SGerd Hoffmann EXPORT_SYMBOL(drm_dev_set_unique); 1069a6b5fac5SGerd Hoffmann 107021d70354SDave Airlie /* 107121d70354SDave Airlie * DRM Core 107221d70354SDave Airlie * The DRM core module initializes all global DRM objects and makes them 107321d70354SDave Airlie * available to drivers. Once setup, drivers can probe their respective 107421d70354SDave Airlie * devices. 107521d70354SDave Airlie * Currently, core management includes: 107621d70354SDave Airlie * - The "DRM-Global" key/value database 107721d70354SDave Airlie * - Global ID management for connectors 107821d70354SDave Airlie * - DRM major number allocation 107921d70354SDave Airlie * - DRM minor management 108021d70354SDave Airlie * - DRM sysfs class 108121d70354SDave Airlie * - DRM debugfs root 108221d70354SDave Airlie * 108321d70354SDave Airlie * Furthermore, the DRM core provides dynamic char-dev lookups. For each 108421d70354SDave Airlie * interface registered on a DRM device, you can request minor numbers from DRM 108521d70354SDave Airlie * core. DRM core takes care of major-number management and char-dev 108621d70354SDave Airlie * registration. A stub ->open() callback forwards any open() requests to the 108721d70354SDave Airlie * registered minor. 108821d70354SDave Airlie */ 108921d70354SDave Airlie 109021d70354SDave Airlie static int drm_stub_open(struct inode *inode, struct file *filp) 109121d70354SDave Airlie { 109221d70354SDave Airlie const struct file_operations *new_fops; 109321d70354SDave Airlie struct drm_minor *minor; 109421d70354SDave Airlie int err; 109521d70354SDave Airlie 109621d70354SDave Airlie DRM_DEBUG("\n"); 109721d70354SDave Airlie 109821d70354SDave Airlie mutex_lock(&drm_global_mutex); 109921d70354SDave Airlie minor = drm_minor_acquire(iminor(inode)); 110021d70354SDave Airlie if (IS_ERR(minor)) { 110121d70354SDave Airlie err = PTR_ERR(minor); 110221d70354SDave Airlie goto out_unlock; 110321d70354SDave Airlie } 110421d70354SDave Airlie 110521d70354SDave Airlie new_fops = fops_get(minor->dev->driver->fops); 110621d70354SDave Airlie if (!new_fops) { 110721d70354SDave Airlie err = -ENODEV; 110821d70354SDave Airlie goto out_release; 110921d70354SDave Airlie } 111021d70354SDave Airlie 111121d70354SDave Airlie replace_fops(filp, new_fops); 111221d70354SDave Airlie if (filp->f_op->open) 111321d70354SDave Airlie err = filp->f_op->open(inode, filp); 111421d70354SDave Airlie else 111521d70354SDave Airlie err = 0; 111621d70354SDave Airlie 111721d70354SDave Airlie out_release: 111821d70354SDave Airlie drm_minor_release(minor); 111921d70354SDave Airlie out_unlock: 112021d70354SDave Airlie mutex_unlock(&drm_global_mutex); 112121d70354SDave Airlie return err; 112221d70354SDave Airlie } 112321d70354SDave Airlie 112421d70354SDave Airlie static const struct file_operations drm_stub_fops = { 112521d70354SDave Airlie .owner = THIS_MODULE, 112621d70354SDave Airlie .open = drm_stub_open, 112721d70354SDave Airlie .llseek = noop_llseek, 112821d70354SDave Airlie }; 112921d70354SDave Airlie 11302cc107dcSDavid Herrmann static void drm_core_exit(void) 11312cc107dcSDavid Herrmann { 11322cc107dcSDavid Herrmann unregister_chrdev(DRM_MAJOR, "drm"); 11332cc107dcSDavid Herrmann debugfs_remove(drm_debugfs_root); 11342cc107dcSDavid Herrmann drm_sysfs_destroy(); 11352cc107dcSDavid Herrmann idr_destroy(&drm_minors_idr); 11362cc107dcSDavid Herrmann drm_connector_ida_destroy(); 11372cc107dcSDavid Herrmann } 11382cc107dcSDavid Herrmann 113921d70354SDave Airlie static int __init drm_core_init(void) 114021d70354SDave Airlie { 11412cc107dcSDavid Herrmann int ret; 114221d70354SDave Airlie 114321d70354SDave Airlie drm_connector_ida_init(); 114421d70354SDave Airlie idr_init(&drm_minors_idr); 114521d70354SDave Airlie 1146fcc90213SDavid Herrmann ret = drm_sysfs_init(); 1147fcc90213SDavid Herrmann if (ret < 0) { 11482cc107dcSDavid Herrmann DRM_ERROR("Cannot create DRM class: %d\n", ret); 11492cc107dcSDavid Herrmann goto error; 115021d70354SDave Airlie } 115121d70354SDave Airlie 115221d70354SDave Airlie drm_debugfs_root = debugfs_create_dir("dri", NULL); 115321d70354SDave Airlie 11542cc107dcSDavid Herrmann ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops); 11552cc107dcSDavid Herrmann if (ret < 0) 11562cc107dcSDavid Herrmann goto error; 11572cc107dcSDavid Herrmann 1158371c2279SAlexandru Moise drm_core_init_complete = true; 1159371c2279SAlexandru Moise 1160e82dfa00SChris Wilson DRM_DEBUG("Initialized\n"); 116121d70354SDave Airlie return 0; 116221d70354SDave Airlie 11632cc107dcSDavid Herrmann error: 11642cc107dcSDavid Herrmann drm_core_exit(); 116521d70354SDave Airlie return ret; 116621d70354SDave Airlie } 116721d70354SDave Airlie 116821d70354SDave Airlie module_init(drm_core_init); 116921d70354SDave Airlie module_exit(drm_core_exit); 1170