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> 3421d70354SDave Airlie #include <linux/slab.h> 35bee330f3SNoralf Trønnes #include <linux/srcu.h> 3685e634bcSDaniel Vetter 37c76f0f7cSNoralf Trønnes #include <drm/drm_client.h> 3885e634bcSDaniel Vetter #include <drm/drm_drv.h> 3921d70354SDave Airlie #include <drm/drmP.h> 4085e634bcSDaniel Vetter 4179190ea2SBenjamin Gaignard #include "drm_crtc_internal.h" 4221d70354SDave Airlie #include "drm_legacy.h" 4367d0ec4eSDaniel Vetter #include "drm_internal.h" 4421d70354SDave Airlie 456dc3e22eSEzequiel Garcia /* 466dc3e22eSEzequiel Garcia * drm_debug: Enable debug output. 476dc3e22eSEzequiel Garcia * Bitmask of DRM_UT_x. See include/drm/drmP.h for details. 486dc3e22eSEzequiel Garcia */ 496dc3e22eSEzequiel Garcia unsigned int drm_debug = 0; 5021d70354SDave Airlie EXPORT_SYMBOL(drm_debug); 5121d70354SDave Airlie 5282d5e73fSDavid Herrmann MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl"); 5382d5e73fSDavid Herrmann MODULE_DESCRIPTION("DRM shared core routines"); 5421d70354SDave Airlie MODULE_LICENSE("GPL and additional rights"); 556dc3e22eSEzequiel Garcia MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug category.\n" 566dc3e22eSEzequiel Garcia "\t\tBit 0 (0x01) will enable CORE messages (drm core code)\n" 576dc3e22eSEzequiel Garcia "\t\tBit 1 (0x02) will enable DRIVER messages (drm controller code)\n" 586dc3e22eSEzequiel Garcia "\t\tBit 2 (0x04) will enable KMS messages (modesetting code)\n" 596dc3e22eSEzequiel Garcia "\t\tBit 3 (0x08) will enable PRIME messages (prime code)\n" 606dc3e22eSEzequiel Garcia "\t\tBit 4 (0x10) will enable ATOMIC messages (atomic code)\n" 61e7646f84SKeith Packard "\t\tBit 5 (0x20) will enable VBL messages (vblank code)\n" 62a18b2192SLyude Paul "\t\tBit 7 (0x80) will enable LEASE messages (leasing code)\n" 63a18b2192SLyude Paul "\t\tBit 8 (0x100) will enable DP messages (displayport code)"); 6421d70354SDave Airlie module_param_named(debug, drm_debug, int, 0600); 6521d70354SDave Airlie 6621d70354SDave Airlie static DEFINE_SPINLOCK(drm_minor_lock); 6721d70354SDave Airlie static struct idr drm_minors_idr; 6821d70354SDave Airlie 69371c2279SAlexandru Moise /* 70371c2279SAlexandru Moise * If the drm core fails to init for whatever reason, 71371c2279SAlexandru Moise * we should prevent any drivers from registering with it. 72371c2279SAlexandru Moise * It's best to check this at drm_dev_init(), as some drivers 73371c2279SAlexandru Moise * prefer to embed struct drm_device into their own device 74371c2279SAlexandru Moise * structure and call drm_dev_init() themselves. 75371c2279SAlexandru Moise */ 76371c2279SAlexandru Moise static bool drm_core_init_complete = false; 77371c2279SAlexandru Moise 7821d70354SDave Airlie static struct dentry *drm_debugfs_root; 7921d70354SDave Airlie 80bee330f3SNoralf Trønnes DEFINE_STATIC_SRCU(drm_unplug_srcu); 81bee330f3SNoralf Trønnes 8221d70354SDave Airlie /* 8321d70354SDave Airlie * DRM Minors 8421d70354SDave Airlie * A DRM device can provide several char-dev interfaces on the DRM-Major. Each 8521d70354SDave Airlie * of them is represented by a drm_minor object. Depending on the capabilities 8621d70354SDave Airlie * of the device-driver, different interfaces are registered. 8721d70354SDave Airlie * 8821d70354SDave Airlie * Minors can be accessed via dev->$minor_name. This pointer is either 8921d70354SDave Airlie * NULL or a valid drm_minor pointer and stays valid as long as the device is 9021d70354SDave Airlie * valid. This means, DRM minors have the same life-time as the underlying 9121d70354SDave Airlie * device. However, this doesn't mean that the minor is active. Minors are 9221d70354SDave Airlie * registered and unregistered dynamically according to device-state. 9321d70354SDave Airlie */ 9421d70354SDave Airlie 9521d70354SDave Airlie static struct drm_minor **drm_minor_get_slot(struct drm_device *dev, 9621d70354SDave Airlie unsigned int type) 9721d70354SDave Airlie { 9821d70354SDave Airlie switch (type) { 99a3ccc461SDavid Herrmann case DRM_MINOR_PRIMARY: 10021d70354SDave Airlie return &dev->primary; 10121d70354SDave Airlie case DRM_MINOR_RENDER: 10221d70354SDave Airlie return &dev->render; 10321d70354SDave Airlie default: 1043bd07ccdSJoe Moriarty BUG(); 10521d70354SDave Airlie } 10621d70354SDave Airlie } 10721d70354SDave Airlie 10821d70354SDave Airlie static int drm_minor_alloc(struct drm_device *dev, unsigned int type) 10921d70354SDave Airlie { 11021d70354SDave Airlie struct drm_minor *minor; 11121d70354SDave Airlie unsigned long flags; 11221d70354SDave Airlie int r; 11321d70354SDave Airlie 11421d70354SDave Airlie minor = kzalloc(sizeof(*minor), GFP_KERNEL); 11521d70354SDave Airlie if (!minor) 11621d70354SDave Airlie return -ENOMEM; 11721d70354SDave Airlie 11821d70354SDave Airlie minor->type = type; 11921d70354SDave Airlie minor->dev = dev; 12021d70354SDave Airlie 12121d70354SDave Airlie idr_preload(GFP_KERNEL); 12221d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 12321d70354SDave Airlie r = idr_alloc(&drm_minors_idr, 12421d70354SDave Airlie NULL, 12521d70354SDave Airlie 64 * type, 12621d70354SDave Airlie 64 * (type + 1), 12721d70354SDave Airlie GFP_NOWAIT); 12821d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 12921d70354SDave Airlie idr_preload_end(); 13021d70354SDave Airlie 13121d70354SDave Airlie if (r < 0) 13221d70354SDave Airlie goto err_free; 13321d70354SDave Airlie 13421d70354SDave Airlie minor->index = r; 13521d70354SDave Airlie 13621d70354SDave Airlie minor->kdev = drm_sysfs_minor_alloc(minor); 13721d70354SDave Airlie if (IS_ERR(minor->kdev)) { 13821d70354SDave Airlie r = PTR_ERR(minor->kdev); 13921d70354SDave Airlie goto err_index; 14021d70354SDave Airlie } 14121d70354SDave Airlie 14221d70354SDave Airlie *drm_minor_get_slot(dev, type) = minor; 14321d70354SDave Airlie return 0; 14421d70354SDave Airlie 14521d70354SDave Airlie err_index: 14621d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 14721d70354SDave Airlie idr_remove(&drm_minors_idr, minor->index); 14821d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 14921d70354SDave Airlie err_free: 15021d70354SDave Airlie kfree(minor); 15121d70354SDave Airlie return r; 15221d70354SDave Airlie } 15321d70354SDave Airlie 15421d70354SDave Airlie static void drm_minor_free(struct drm_device *dev, unsigned int type) 15521d70354SDave Airlie { 15621d70354SDave Airlie struct drm_minor **slot, *minor; 15721d70354SDave Airlie unsigned long flags; 15821d70354SDave Airlie 15921d70354SDave Airlie slot = drm_minor_get_slot(dev, type); 16021d70354SDave Airlie minor = *slot; 16121d70354SDave Airlie if (!minor) 16221d70354SDave Airlie return; 16321d70354SDave Airlie 16421d70354SDave Airlie put_device(minor->kdev); 16521d70354SDave Airlie 16621d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 16721d70354SDave Airlie idr_remove(&drm_minors_idr, minor->index); 16821d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 16921d70354SDave Airlie 17021d70354SDave Airlie kfree(minor); 17121d70354SDave Airlie *slot = NULL; 17221d70354SDave Airlie } 17321d70354SDave Airlie 17421d70354SDave Airlie static int drm_minor_register(struct drm_device *dev, unsigned int type) 17521d70354SDave Airlie { 17621d70354SDave Airlie struct drm_minor *minor; 17721d70354SDave Airlie unsigned long flags; 17821d70354SDave Airlie int ret; 17921d70354SDave Airlie 18021d70354SDave Airlie DRM_DEBUG("\n"); 18121d70354SDave Airlie 18221d70354SDave Airlie minor = *drm_minor_get_slot(dev, type); 18321d70354SDave Airlie if (!minor) 18421d70354SDave Airlie return 0; 18521d70354SDave Airlie 18621d70354SDave Airlie ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root); 18721d70354SDave Airlie if (ret) { 18821d70354SDave Airlie DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n"); 189a67834f8SNoralf Trønnes goto err_debugfs; 19021d70354SDave Airlie } 19121d70354SDave Airlie 19221d70354SDave Airlie ret = device_add(minor->kdev); 19321d70354SDave Airlie if (ret) 19421d70354SDave Airlie goto err_debugfs; 19521d70354SDave Airlie 19621d70354SDave Airlie /* replace NULL with @minor so lookups will succeed from now on */ 19721d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 19821d70354SDave Airlie idr_replace(&drm_minors_idr, minor, minor->index); 19921d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 20021d70354SDave Airlie 20121d70354SDave Airlie DRM_DEBUG("new minor registered %d\n", minor->index); 20221d70354SDave Airlie return 0; 20321d70354SDave Airlie 20421d70354SDave Airlie err_debugfs: 20521d70354SDave Airlie drm_debugfs_cleanup(minor); 20621d70354SDave Airlie return ret; 20721d70354SDave Airlie } 20821d70354SDave Airlie 20921d70354SDave Airlie static void drm_minor_unregister(struct drm_device *dev, unsigned int type) 21021d70354SDave Airlie { 21121d70354SDave Airlie struct drm_minor *minor; 21221d70354SDave Airlie unsigned long flags; 21321d70354SDave Airlie 21421d70354SDave Airlie minor = *drm_minor_get_slot(dev, type); 21521d70354SDave Airlie if (!minor || !device_is_registered(minor->kdev)) 21621d70354SDave Airlie return; 21721d70354SDave Airlie 21821d70354SDave Airlie /* replace @minor with NULL so lookups will fail from now on */ 21921d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 22021d70354SDave Airlie idr_replace(&drm_minors_idr, NULL, minor->index); 22121d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 22221d70354SDave Airlie 22321d70354SDave Airlie device_del(minor->kdev); 22421d70354SDave Airlie dev_set_drvdata(minor->kdev, NULL); /* safety belt */ 22521d70354SDave Airlie drm_debugfs_cleanup(minor); 22621d70354SDave Airlie } 22721d70354SDave Airlie 22885e634bcSDaniel Vetter /* 22921d70354SDave Airlie * Looks up the given minor-ID and returns the respective DRM-minor object. The 23021d70354SDave Airlie * refence-count of the underlying device is increased so you must release this 23121d70354SDave Airlie * object with drm_minor_release(). 23221d70354SDave Airlie * 23321d70354SDave Airlie * As long as you hold this minor, it is guaranteed that the object and the 23421d70354SDave Airlie * minor->dev pointer will stay valid! However, the device may get unplugged and 23521d70354SDave Airlie * unregistered while you hold the minor. 23621d70354SDave Airlie */ 23721d70354SDave Airlie struct drm_minor *drm_minor_acquire(unsigned int minor_id) 23821d70354SDave Airlie { 23921d70354SDave Airlie struct drm_minor *minor; 24021d70354SDave Airlie unsigned long flags; 24121d70354SDave Airlie 24221d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 24321d70354SDave Airlie minor = idr_find(&drm_minors_idr, minor_id); 24421d70354SDave Airlie if (minor) 2459a96f550SAishwarya Pant drm_dev_get(minor->dev); 24621d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 24721d70354SDave Airlie 24821d70354SDave Airlie if (!minor) { 24921d70354SDave Airlie return ERR_PTR(-ENODEV); 250c07dcd61SDaniel Vetter } else if (drm_dev_is_unplugged(minor->dev)) { 2519a96f550SAishwarya Pant drm_dev_put(minor->dev); 25221d70354SDave Airlie return ERR_PTR(-ENODEV); 25321d70354SDave Airlie } 25421d70354SDave Airlie 25521d70354SDave Airlie return minor; 25621d70354SDave Airlie } 25721d70354SDave Airlie 25821d70354SDave Airlie void drm_minor_release(struct drm_minor *minor) 25921d70354SDave Airlie { 2609a96f550SAishwarya Pant drm_dev_put(minor->dev); 26121d70354SDave Airlie } 26221d70354SDave Airlie 26321d70354SDave Airlie /** 2646e3f797cSDaniel Vetter * DOC: driver instance overview 2656e3f797cSDaniel Vetter * 266ea0dd85aSDaniel Vetter * A device instance for a drm driver is represented by &struct drm_device. This 26733e70110SDaniel Vetter * is initialized with drm_dev_init(), usually from bus-specific ->probe() 2686e3f797cSDaniel Vetter * callbacks implemented by the driver. The driver then needs to initialize all 2696e3f797cSDaniel Vetter * the various subsystems for the drm device like memory management, vblank 2706e3f797cSDaniel Vetter * handling, modesetting support and intial output configuration plus obviously 27133e70110SDaniel Vetter * initialize all the corresponding hardware bits. Finally when everything is up 27233e70110SDaniel Vetter * and running and ready for userspace the device instance can be published 27333e70110SDaniel Vetter * using drm_dev_register(). 2746e3f797cSDaniel Vetter * 2756e3f797cSDaniel Vetter * There is also deprecated support for initalizing device instances using 276ef40cbf9SDaniel Vetter * bus-specific helpers and the &drm_driver.load callback. But due to 2776e3f797cSDaniel Vetter * backwards-compatibility needs the device instance have to be published too 2786e3f797cSDaniel Vetter * early, which requires unpretty global locking to make safe and is therefore 2796e3f797cSDaniel Vetter * only support for existing drivers not yet converted to the new scheme. 2806e3f797cSDaniel Vetter * 2816e3f797cSDaniel Vetter * When cleaning up a device instance everything needs to be done in reverse: 2826e3f797cSDaniel Vetter * First unpublish the device instance with drm_dev_unregister(). Then clean up 2836e3f797cSDaniel Vetter * any other resources allocated at device initialization and drop the driver's 2849a96f550SAishwarya Pant * reference to &drm_device using drm_dev_put(). 2856e3f797cSDaniel Vetter * 2866e3f797cSDaniel Vetter * Note that the lifetime rules for &drm_device instance has still a lot of 2876e3f797cSDaniel Vetter * historical baggage. Hence use the reference counting provided by 2889a96f550SAishwarya Pant * drm_dev_get() and drm_dev_put() only carefully. 2896e3f797cSDaniel Vetter */ 2906e3f797cSDaniel Vetter 2916e3f797cSDaniel Vetter /** 29221d70354SDave Airlie * drm_put_dev - Unregister and release a DRM device 29321d70354SDave Airlie * @dev: DRM device 29421d70354SDave Airlie * 29521d70354SDave Airlie * Called at module unload time or when a PCI device is unplugged. 29621d70354SDave Airlie * 29721d70354SDave Airlie * Cleans up all DRM device, calling drm_lastclose(). 2986e3f797cSDaniel Vetter * 2996e3f797cSDaniel Vetter * Note: Use of this function is deprecated. It will eventually go away 3009a96f550SAishwarya Pant * completely. Please use drm_dev_unregister() and drm_dev_put() explicitly 3016e3f797cSDaniel Vetter * instead to make sure that the device isn't userspace accessible any more 3026e3f797cSDaniel Vetter * while teardown is in progress, ensuring that userspace can't access an 3036e3f797cSDaniel Vetter * inconsistent state. 30421d70354SDave Airlie */ 30521d70354SDave Airlie void drm_put_dev(struct drm_device *dev) 30621d70354SDave Airlie { 30721d70354SDave Airlie DRM_DEBUG("\n"); 30821d70354SDave Airlie 30921d70354SDave Airlie if (!dev) { 31021d70354SDave Airlie DRM_ERROR("cleanup called no dev\n"); 31121d70354SDave Airlie return; 31221d70354SDave Airlie } 31321d70354SDave Airlie 31421d70354SDave Airlie drm_dev_unregister(dev); 3159a96f550SAishwarya Pant drm_dev_put(dev); 31621d70354SDave Airlie } 31721d70354SDave Airlie EXPORT_SYMBOL(drm_put_dev); 31821d70354SDave Airlie 319bee330f3SNoralf Trønnes /** 320bee330f3SNoralf Trønnes * drm_dev_enter - Enter device critical section 321bee330f3SNoralf Trønnes * @dev: DRM device 322bee330f3SNoralf Trønnes * @idx: Pointer to index that will be passed to the matching drm_dev_exit() 323bee330f3SNoralf Trønnes * 324bee330f3SNoralf Trønnes * This function marks and protects the beginning of a section that should not 325bee330f3SNoralf Trønnes * be entered after the device has been unplugged. The section end is marked 326bee330f3SNoralf Trønnes * with drm_dev_exit(). Calls to this function can be nested. 327bee330f3SNoralf Trønnes * 328bee330f3SNoralf Trønnes * Returns: 329bee330f3SNoralf Trønnes * True if it is OK to enter the section, false otherwise. 330bee330f3SNoralf Trønnes */ 331bee330f3SNoralf Trønnes bool drm_dev_enter(struct drm_device *dev, int *idx) 332c07dcd61SDaniel Vetter { 333bee330f3SNoralf Trønnes *idx = srcu_read_lock(&drm_unplug_srcu); 334bee330f3SNoralf Trønnes 335bee330f3SNoralf Trønnes if (dev->unplugged) { 336bee330f3SNoralf Trønnes srcu_read_unlock(&drm_unplug_srcu, *idx); 337bee330f3SNoralf Trønnes return false; 338c07dcd61SDaniel Vetter } 339c07dcd61SDaniel Vetter 340bee330f3SNoralf Trønnes return true; 341bee330f3SNoralf Trønnes } 342bee330f3SNoralf Trønnes EXPORT_SYMBOL(drm_dev_enter); 343bee330f3SNoralf Trønnes 344bee330f3SNoralf Trønnes /** 345bee330f3SNoralf Trønnes * drm_dev_exit - Exit device critical section 346bee330f3SNoralf Trønnes * @idx: index returned from drm_dev_enter() 347bee330f3SNoralf Trønnes * 348bee330f3SNoralf Trønnes * This function marks the end of a section that should not be entered after 349bee330f3SNoralf Trønnes * the device has been unplugged. 350bee330f3SNoralf Trønnes */ 351bee330f3SNoralf Trønnes void drm_dev_exit(int idx) 352bee330f3SNoralf Trønnes { 353bee330f3SNoralf Trønnes srcu_read_unlock(&drm_unplug_srcu, idx); 354bee330f3SNoralf Trønnes } 355bee330f3SNoralf Trønnes EXPORT_SYMBOL(drm_dev_exit); 356bee330f3SNoralf Trønnes 357c07dcd61SDaniel Vetter /** 358c07dcd61SDaniel Vetter * drm_dev_unplug - unplug a DRM device 359c07dcd61SDaniel Vetter * @dev: DRM device 360c07dcd61SDaniel Vetter * 361c07dcd61SDaniel Vetter * This unplugs a hotpluggable DRM device, which makes it inaccessible to 362bee330f3SNoralf Trønnes * userspace operations. Entry-points can use drm_dev_enter() and 363bee330f3SNoralf Trønnes * drm_dev_exit() to protect device resources in a race free manner. This 364c07dcd61SDaniel Vetter * essentially unregisters the device like drm_dev_unregister(), but can be 365c07dcd61SDaniel Vetter * called while there are still open users of @dev. 366c07dcd61SDaniel Vetter */ 367c07dcd61SDaniel Vetter void drm_dev_unplug(struct drm_device *dev) 36821d70354SDave Airlie { 369bee330f3SNoralf Trønnes /* 370bee330f3SNoralf Trønnes * After synchronizing any critical read section is guaranteed to see 371bee330f3SNoralf Trønnes * the new value of ->unplugged, and any critical section which might 372bee330f3SNoralf Trønnes * still have seen the old value of ->unplugged is guaranteed to have 373bee330f3SNoralf Trønnes * finished. 374bee330f3SNoralf Trønnes */ 375bee330f3SNoralf Trønnes dev->unplugged = true; 376bee330f3SNoralf Trønnes synchronize_srcu(&drm_unplug_srcu); 377069035c5SOleksandr Andrushchenko 378069035c5SOleksandr Andrushchenko drm_dev_unregister(dev); 379069035c5SOleksandr Andrushchenko 380069035c5SOleksandr Andrushchenko mutex_lock(&drm_global_mutex); 381069035c5SOleksandr Andrushchenko if (dev->open_count == 0) 382069035c5SOleksandr Andrushchenko drm_dev_put(dev); 383069035c5SOleksandr Andrushchenko mutex_unlock(&drm_global_mutex); 38421d70354SDave Airlie } 385c07dcd61SDaniel Vetter EXPORT_SYMBOL(drm_dev_unplug); 38621d70354SDave Airlie 38721d70354SDave Airlie /* 38821d70354SDave Airlie * DRM internal mount 38921d70354SDave Airlie * We want to be able to allocate our own "struct address_space" to control 39021d70354SDave Airlie * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow 39121d70354SDave Airlie * stand-alone address_space objects, so we need an underlying inode. As there 39221d70354SDave Airlie * is no way to allocate an independent inode easily, we need a fake internal 39321d70354SDave Airlie * VFS mount-point. 39421d70354SDave Airlie * 39521d70354SDave Airlie * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free() 39621d70354SDave Airlie * frees it again. You are allowed to use iget() and iput() to get references to 39721d70354SDave Airlie * the inode. But each drm_fs_inode_new() call must be paired with exactly one 39821d70354SDave Airlie * drm_fs_inode_free() call (which does not have to be the last iput()). 39921d70354SDave Airlie * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it 40021d70354SDave Airlie * between multiple inode-users. You could, technically, call 40121d70354SDave Airlie * iget() + drm_fs_inode_free() directly after alloc and sometime later do an 40221d70354SDave Airlie * iput(), but this way you'd end up with a new vfsmount for each inode. 40321d70354SDave Airlie */ 40421d70354SDave Airlie 40521d70354SDave Airlie static int drm_fs_cnt; 40621d70354SDave Airlie static struct vfsmount *drm_fs_mnt; 40721d70354SDave Airlie 40821d70354SDave Airlie static const struct dentry_operations drm_fs_dops = { 40921d70354SDave Airlie .d_dname = simple_dname, 41021d70354SDave Airlie }; 41121d70354SDave Airlie 41221d70354SDave Airlie static const struct super_operations drm_fs_sops = { 41321d70354SDave Airlie .statfs = simple_statfs, 41421d70354SDave Airlie }; 41521d70354SDave Airlie 41621d70354SDave Airlie static struct dentry *drm_fs_mount(struct file_system_type *fs_type, int flags, 41721d70354SDave Airlie const char *dev_name, void *data) 41821d70354SDave Airlie { 41921d70354SDave Airlie return mount_pseudo(fs_type, 42021d70354SDave Airlie "drm:", 42121d70354SDave Airlie &drm_fs_sops, 42221d70354SDave Airlie &drm_fs_dops, 42321d70354SDave Airlie 0x010203ff); 42421d70354SDave Airlie } 42521d70354SDave Airlie 42621d70354SDave Airlie static struct file_system_type drm_fs_type = { 42721d70354SDave Airlie .name = "drm", 42821d70354SDave Airlie .owner = THIS_MODULE, 42921d70354SDave Airlie .mount = drm_fs_mount, 43021d70354SDave Airlie .kill_sb = kill_anon_super, 43121d70354SDave Airlie }; 43221d70354SDave Airlie 43321d70354SDave Airlie static struct inode *drm_fs_inode_new(void) 43421d70354SDave Airlie { 43521d70354SDave Airlie struct inode *inode; 43621d70354SDave Airlie int r; 43721d70354SDave Airlie 43821d70354SDave Airlie r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt); 43921d70354SDave Airlie if (r < 0) { 44021d70354SDave Airlie DRM_ERROR("Cannot mount pseudo fs: %d\n", r); 44121d70354SDave Airlie return ERR_PTR(r); 44221d70354SDave Airlie } 44321d70354SDave Airlie 44421d70354SDave Airlie inode = alloc_anon_inode(drm_fs_mnt->mnt_sb); 44521d70354SDave Airlie if (IS_ERR(inode)) 44621d70354SDave Airlie simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 44721d70354SDave Airlie 44821d70354SDave Airlie return inode; 44921d70354SDave Airlie } 45021d70354SDave Airlie 45121d70354SDave Airlie static void drm_fs_inode_free(struct inode *inode) 45221d70354SDave Airlie { 45321d70354SDave Airlie if (inode) { 45421d70354SDave Airlie iput(inode); 45521d70354SDave Airlie simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 45621d70354SDave Airlie } 45721d70354SDave Airlie } 45821d70354SDave Airlie 45921d70354SDave Airlie /** 460b209aca3SChris Wilson * drm_dev_init - Initialise new DRM device 461b209aca3SChris Wilson * @dev: DRM device 462b209aca3SChris Wilson * @driver: DRM driver 46321d70354SDave Airlie * @parent: Parent device object 46421d70354SDave Airlie * 465b209aca3SChris Wilson * Initialize a new DRM device. No device registration is done. 46621d70354SDave Airlie * Call drm_dev_register() to advertice the device to user space and register it 4676e3f797cSDaniel Vetter * with other core subsystems. This should be done last in the device 4686e3f797cSDaniel Vetter * initialization sequence to make sure userspace can't access an inconsistent 4696e3f797cSDaniel Vetter * state. 47021d70354SDave Airlie * 4719a96f550SAishwarya Pant * The initial ref-count of the object is 1. Use drm_dev_get() and 4729a96f550SAishwarya Pant * drm_dev_put() to take and drop further ref-counts. 47321d70354SDave Airlie * 47433e70110SDaniel Vetter * It is recommended that drivers embed &struct drm_device into their own device 47533e70110SDaniel Vetter * structure. 47633e70110SDaniel Vetter * 477b209aca3SChris Wilson * Drivers that do not want to allocate their own device struct 478ea0dd85aSDaniel Vetter * embedding &struct drm_device can call drm_dev_alloc() instead. For drivers 479ea0dd85aSDaniel Vetter * that do embed &struct drm_device it must be placed first in the overall 480d82faafdSDaniel Vetter * structure, and the overall structure must be allocated using kmalloc(): The 481d82faafdSDaniel Vetter * drm core's release function unconditionally calls kfree() on the @dev pointer 482f30c9257SChris Wilson * when the final reference is released. To override this behaviour, and so 483f30c9257SChris Wilson * allow embedding of the drm_device inside the driver's device struct at an 484f30c9257SChris Wilson * arbitrary offset, you must supply a &drm_driver.release callback and control 485f30c9257SChris Wilson * the finalization explicitly. 486b209aca3SChris Wilson * 48721d70354SDave Airlie * RETURNS: 488b209aca3SChris Wilson * 0 on success, or error code on failure. 48921d70354SDave Airlie */ 490b209aca3SChris Wilson int drm_dev_init(struct drm_device *dev, 491b209aca3SChris Wilson struct drm_driver *driver, 49221d70354SDave Airlie struct device *parent) 49321d70354SDave Airlie { 49421d70354SDave Airlie int ret; 49521d70354SDave Airlie 496371c2279SAlexandru Moise if (!drm_core_init_complete) { 497371c2279SAlexandru Moise DRM_ERROR("DRM core is not initialized\n"); 498371c2279SAlexandru Moise return -ENODEV; 499371c2279SAlexandru Moise } 500371c2279SAlexandru Moise 501f08877e7SEmil Velikov BUG_ON(!parent); 502f08877e7SEmil Velikov 50321d70354SDave Airlie kref_init(&dev->ref); 50421d70354SDave Airlie dev->dev = parent; 50521d70354SDave Airlie dev->driver = driver; 50621d70354SDave Airlie 50718ace11fSVille Syrjälä /* no per-device feature limits by default */ 50818ace11fSVille Syrjälä dev->driver_features = ~0u; 50918ace11fSVille Syrjälä 51021d70354SDave Airlie INIT_LIST_HEAD(&dev->filelist); 511c76f0f7cSNoralf Trønnes INIT_LIST_HEAD(&dev->filelist_internal); 512c76f0f7cSNoralf Trønnes INIT_LIST_HEAD(&dev->clientlist); 51321d70354SDave Airlie INIT_LIST_HEAD(&dev->ctxlist); 51421d70354SDave Airlie INIT_LIST_HEAD(&dev->vmalist); 51521d70354SDave Airlie INIT_LIST_HEAD(&dev->maplist); 51621d70354SDave Airlie INIT_LIST_HEAD(&dev->vblank_event_list); 51721d70354SDave Airlie 51821d70354SDave Airlie spin_lock_init(&dev->buf_lock); 51921d70354SDave Airlie spin_lock_init(&dev->event_lock); 52021d70354SDave Airlie mutex_init(&dev->struct_mutex); 5211d2ac403SDaniel Vetter mutex_init(&dev->filelist_mutex); 522c76f0f7cSNoralf Trønnes mutex_init(&dev->clientlist_mutex); 52321d70354SDave Airlie mutex_init(&dev->ctxlist_mutex); 52421d70354SDave Airlie mutex_init(&dev->master_mutex); 52521d70354SDave Airlie 52621d70354SDave Airlie dev->anon_inode = drm_fs_inode_new(); 52721d70354SDave Airlie if (IS_ERR(dev->anon_inode)) { 52821d70354SDave Airlie ret = PTR_ERR(dev->anon_inode); 52921d70354SDave Airlie DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret); 53021d70354SDave Airlie goto err_free; 53121d70354SDave Airlie } 53221d70354SDave Airlie 53321d70354SDave Airlie if (drm_core_check_feature(dev, DRIVER_RENDER)) { 53421d70354SDave Airlie ret = drm_minor_alloc(dev, DRM_MINOR_RENDER); 53521d70354SDave Airlie if (ret) 53621d70354SDave Airlie goto err_minors; 53721d70354SDave Airlie } 53821d70354SDave Airlie 539a3ccc461SDavid Herrmann ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY); 54021d70354SDave Airlie if (ret) 54121d70354SDave Airlie goto err_minors; 54221d70354SDave Airlie 543b209aca3SChris Wilson ret = drm_ht_create(&dev->map_hash, 12); 544b209aca3SChris Wilson if (ret) 54521d70354SDave Airlie goto err_minors; 54621d70354SDave Airlie 547ba6976c1SDaniel Vetter drm_legacy_ctxbitmap_init(dev); 54821d70354SDave Airlie 5491bcecfacSAndrzej Hajda if (drm_core_check_feature(dev, DRIVER_GEM)) { 55021d70354SDave Airlie ret = drm_gem_init(dev); 55121d70354SDave Airlie if (ret) { 55221d70354SDave Airlie DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n"); 55321d70354SDave Airlie goto err_ctxbitmap; 55421d70354SDave Airlie } 55521d70354SDave Airlie } 55621d70354SDave Airlie 557f08877e7SEmil Velikov ret = drm_dev_set_unique(dev, dev_name(parent)); 558e112e593SNicolas Iooss if (ret) 559e112e593SNicolas Iooss goto err_setunique; 560e112e593SNicolas Iooss 561b209aca3SChris Wilson return 0; 56221d70354SDave Airlie 563e112e593SNicolas Iooss err_setunique: 564e112e593SNicolas Iooss if (drm_core_check_feature(dev, DRIVER_GEM)) 565e112e593SNicolas Iooss drm_gem_destroy(dev); 56621d70354SDave Airlie err_ctxbitmap: 56721d70354SDave Airlie drm_legacy_ctxbitmap_cleanup(dev); 56821d70354SDave Airlie drm_ht_remove(&dev->map_hash); 56921d70354SDave Airlie err_minors: 570a3ccc461SDavid Herrmann drm_minor_free(dev, DRM_MINOR_PRIMARY); 57121d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_RENDER); 57221d70354SDave Airlie drm_fs_inode_free(dev->anon_inode); 57321d70354SDave Airlie err_free: 57421d70354SDave Airlie mutex_destroy(&dev->master_mutex); 575f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->ctxlist_mutex); 576c76f0f7cSNoralf Trønnes mutex_destroy(&dev->clientlist_mutex); 577f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->filelist_mutex); 578f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->struct_mutex); 579b209aca3SChris Wilson return ret; 580b209aca3SChris Wilson } 581b209aca3SChris Wilson EXPORT_SYMBOL(drm_dev_init); 582b209aca3SChris Wilson 583b209aca3SChris Wilson /** 584f30c9257SChris Wilson * drm_dev_fini - Finalize a dead DRM device 585f30c9257SChris Wilson * @dev: DRM device 586f30c9257SChris Wilson * 587f30c9257SChris Wilson * Finalize a dead DRM device. This is the converse to drm_dev_init() and 588f30c9257SChris Wilson * frees up all data allocated by it. All driver private data should be 589f30c9257SChris Wilson * finalized first. Note that this function does not free the @dev, that is 590f30c9257SChris Wilson * left to the caller. 591f30c9257SChris Wilson * 592f30c9257SChris Wilson * The ref-count of @dev must be zero, and drm_dev_fini() should only be called 593f30c9257SChris Wilson * from a &drm_driver.release callback. 594f30c9257SChris Wilson */ 595f30c9257SChris Wilson void drm_dev_fini(struct drm_device *dev) 596f30c9257SChris Wilson { 597f30c9257SChris Wilson drm_vblank_cleanup(dev); 598f30c9257SChris Wilson 599f30c9257SChris Wilson if (drm_core_check_feature(dev, DRIVER_GEM)) 600f30c9257SChris Wilson drm_gem_destroy(dev); 601f30c9257SChris Wilson 602f30c9257SChris Wilson drm_legacy_ctxbitmap_cleanup(dev); 603f30c9257SChris Wilson drm_ht_remove(&dev->map_hash); 604f30c9257SChris Wilson drm_fs_inode_free(dev->anon_inode); 605f30c9257SChris Wilson 606f30c9257SChris Wilson drm_minor_free(dev, DRM_MINOR_PRIMARY); 607f30c9257SChris Wilson drm_minor_free(dev, DRM_MINOR_RENDER); 608f30c9257SChris Wilson 609f30c9257SChris Wilson mutex_destroy(&dev->master_mutex); 610f30c9257SChris Wilson mutex_destroy(&dev->ctxlist_mutex); 611c76f0f7cSNoralf Trønnes mutex_destroy(&dev->clientlist_mutex); 612f30c9257SChris Wilson mutex_destroy(&dev->filelist_mutex); 613f30c9257SChris Wilson mutex_destroy(&dev->struct_mutex); 614f30c9257SChris Wilson kfree(dev->unique); 615f30c9257SChris Wilson } 616f30c9257SChris Wilson EXPORT_SYMBOL(drm_dev_fini); 617f30c9257SChris Wilson 618f30c9257SChris Wilson /** 619b209aca3SChris Wilson * drm_dev_alloc - Allocate new DRM device 620b209aca3SChris Wilson * @driver: DRM driver to allocate device for 621b209aca3SChris Wilson * @parent: Parent device object 622b209aca3SChris Wilson * 623b209aca3SChris Wilson * Allocate and initialize a new DRM device. No device registration is done. 624b209aca3SChris Wilson * Call drm_dev_register() to advertice the device to user space and register it 625b209aca3SChris Wilson * with other core subsystems. This should be done last in the device 626b209aca3SChris Wilson * initialization sequence to make sure userspace can't access an inconsistent 627b209aca3SChris Wilson * state. 628b209aca3SChris Wilson * 6299a96f550SAishwarya Pant * The initial ref-count of the object is 1. Use drm_dev_get() and 6309a96f550SAishwarya Pant * drm_dev_put() to take and drop further ref-counts. 631b209aca3SChris Wilson * 632b209aca3SChris Wilson * Note that for purely virtual devices @parent can be NULL. 633b209aca3SChris Wilson * 634ea0dd85aSDaniel Vetter * Drivers that wish to subclass or embed &struct drm_device into their 635b209aca3SChris Wilson * own struct should look at using drm_dev_init() instead. 636b209aca3SChris Wilson * 637b209aca3SChris Wilson * RETURNS: 6380f288605STom Gundersen * Pointer to new DRM device, or ERR_PTR on failure. 639b209aca3SChris Wilson */ 640b209aca3SChris Wilson struct drm_device *drm_dev_alloc(struct drm_driver *driver, 641b209aca3SChris Wilson struct device *parent) 642b209aca3SChris Wilson { 643b209aca3SChris Wilson struct drm_device *dev; 644b209aca3SChris Wilson int ret; 645b209aca3SChris Wilson 646b209aca3SChris Wilson dev = kzalloc(sizeof(*dev), GFP_KERNEL); 647b209aca3SChris Wilson if (!dev) 6480f288605STom Gundersen return ERR_PTR(-ENOMEM); 649b209aca3SChris Wilson 650b209aca3SChris Wilson ret = drm_dev_init(dev, driver, parent); 651b209aca3SChris Wilson if (ret) { 65221d70354SDave Airlie kfree(dev); 6530f288605STom Gundersen return ERR_PTR(ret); 65421d70354SDave Airlie } 655b209aca3SChris Wilson 656b209aca3SChris Wilson return dev; 657b209aca3SChris Wilson } 65821d70354SDave Airlie EXPORT_SYMBOL(drm_dev_alloc); 65921d70354SDave Airlie 66021d70354SDave Airlie static void drm_dev_release(struct kref *ref) 66121d70354SDave Airlie { 66221d70354SDave Airlie struct drm_device *dev = container_of(ref, struct drm_device, ref); 66321d70354SDave Airlie 664f30c9257SChris Wilson if (dev->driver->release) { 665f30c9257SChris Wilson dev->driver->release(dev); 666f30c9257SChris Wilson } else { 667f30c9257SChris Wilson drm_dev_fini(dev); 66821d70354SDave Airlie kfree(dev); 66921d70354SDave Airlie } 670f30c9257SChris Wilson } 67121d70354SDave Airlie 67221d70354SDave Airlie /** 6739a96f550SAishwarya Pant * drm_dev_get - Take reference of a DRM device 67421d70354SDave Airlie * @dev: device to take reference of or NULL 67521d70354SDave Airlie * 67621d70354SDave Airlie * This increases the ref-count of @dev by one. You *must* already own a 6779a96f550SAishwarya Pant * reference when calling this. Use drm_dev_put() to drop this reference 67821d70354SDave Airlie * again. 67921d70354SDave Airlie * 68021d70354SDave Airlie * This function never fails. However, this function does not provide *any* 68121d70354SDave Airlie * guarantee whether the device is alive or running. It only provides a 68221d70354SDave Airlie * reference to the object and the memory associated with it. 68321d70354SDave Airlie */ 6849a96f550SAishwarya Pant void drm_dev_get(struct drm_device *dev) 68521d70354SDave Airlie { 68621d70354SDave Airlie if (dev) 68721d70354SDave Airlie kref_get(&dev->ref); 68821d70354SDave Airlie } 6899a96f550SAishwarya Pant EXPORT_SYMBOL(drm_dev_get); 69021d70354SDave Airlie 69121d70354SDave Airlie /** 6929a96f550SAishwarya Pant * drm_dev_put - Drop reference of a DRM device 69321d70354SDave Airlie * @dev: device to drop reference of or NULL 69421d70354SDave Airlie * 69521d70354SDave Airlie * This decreases the ref-count of @dev by one. The device is destroyed if the 69621d70354SDave Airlie * ref-count drops to zero. 69721d70354SDave Airlie */ 6989a96f550SAishwarya Pant void drm_dev_put(struct drm_device *dev) 69921d70354SDave Airlie { 70021d70354SDave Airlie if (dev) 70121d70354SDave Airlie kref_put(&dev->ref, drm_dev_release); 70221d70354SDave Airlie } 7039a96f550SAishwarya Pant EXPORT_SYMBOL(drm_dev_put); 7049a96f550SAishwarya Pant 7056449b088SDaniel Vetter static int create_compat_control_link(struct drm_device *dev) 7066449b088SDaniel Vetter { 7076449b088SDaniel Vetter struct drm_minor *minor; 7086449b088SDaniel Vetter char *name; 7096449b088SDaniel Vetter int ret; 7106449b088SDaniel Vetter 7116449b088SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 7126449b088SDaniel Vetter return 0; 7136449b088SDaniel Vetter 7146449b088SDaniel Vetter minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 7156449b088SDaniel Vetter if (!minor) 7166449b088SDaniel Vetter return 0; 7176449b088SDaniel Vetter 7186449b088SDaniel Vetter /* 7196449b088SDaniel Vetter * Some existing userspace out there uses the existing of the controlD* 7206449b088SDaniel Vetter * sysfs files to figure out whether it's a modeset driver. It only does 7216449b088SDaniel Vetter * readdir, hence a symlink is sufficient (and the least confusing 7226449b088SDaniel Vetter * option). Otherwise controlD* is entirely unused. 7236449b088SDaniel Vetter * 7246449b088SDaniel Vetter * Old controlD chardev have been allocated in the range 7256449b088SDaniel Vetter * 64-127. 7266449b088SDaniel Vetter */ 7276449b088SDaniel Vetter name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 7286449b088SDaniel Vetter if (!name) 7296449b088SDaniel Vetter return -ENOMEM; 7306449b088SDaniel Vetter 7316449b088SDaniel Vetter ret = sysfs_create_link(minor->kdev->kobj.parent, 7326449b088SDaniel Vetter &minor->kdev->kobj, 7336449b088SDaniel Vetter name); 7346449b088SDaniel Vetter 7356449b088SDaniel Vetter kfree(name); 7366449b088SDaniel Vetter 7376449b088SDaniel Vetter return ret; 7386449b088SDaniel Vetter } 7396449b088SDaniel Vetter 7406449b088SDaniel Vetter static void remove_compat_control_link(struct drm_device *dev) 7416449b088SDaniel Vetter { 7426449b088SDaniel Vetter struct drm_minor *minor; 7436449b088SDaniel Vetter char *name; 7446449b088SDaniel Vetter 7456449b088SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 7466449b088SDaniel Vetter return; 7476449b088SDaniel Vetter 7486449b088SDaniel Vetter minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 7496449b088SDaniel Vetter if (!minor) 7506449b088SDaniel Vetter return; 7516449b088SDaniel Vetter 7527f6df440SHaneen Mohammed name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 7536449b088SDaniel Vetter if (!name) 7546449b088SDaniel Vetter return; 7556449b088SDaniel Vetter 7566449b088SDaniel Vetter sysfs_remove_link(minor->kdev->kobj.parent, name); 7576449b088SDaniel Vetter 7586449b088SDaniel Vetter kfree(name); 7596449b088SDaniel Vetter } 7606449b088SDaniel Vetter 76121d70354SDave Airlie /** 76221d70354SDave Airlie * drm_dev_register - Register DRM device 76321d70354SDave Airlie * @dev: Device to register 76421d70354SDave Airlie * @flags: Flags passed to the driver's .load() function 76521d70354SDave Airlie * 76621d70354SDave Airlie * Register the DRM device @dev with the system, advertise device to user-space 76733e70110SDaniel Vetter * and start normal device operation. @dev must be initialized via drm_dev_init() 768e28cd4d0SChris Wilson * previously. 76921d70354SDave Airlie * 77021d70354SDave Airlie * Never call this twice on any device! 77121d70354SDave Airlie * 7726e3f797cSDaniel Vetter * NOTE: To ensure backward compatibility with existing drivers method this 773ef40cbf9SDaniel Vetter * function calls the &drm_driver.load method after registering the device 774ef40cbf9SDaniel Vetter * nodes, creating race conditions. Usage of the &drm_driver.load methods is 775ef40cbf9SDaniel Vetter * therefore deprecated, drivers must perform all initialization before calling 7766e3f797cSDaniel Vetter * drm_dev_register(). 7776e3f797cSDaniel Vetter * 77821d70354SDave Airlie * RETURNS: 77921d70354SDave Airlie * 0 on success, negative error code on failure. 78021d70354SDave Airlie */ 78121d70354SDave Airlie int drm_dev_register(struct drm_device *dev, unsigned long flags) 78221d70354SDave Airlie { 78375f6dfe3SGabriel Krisman Bertazi struct drm_driver *driver = dev->driver; 78421d70354SDave Airlie int ret; 78521d70354SDave Airlie 78621d70354SDave Airlie mutex_lock(&drm_global_mutex); 78721d70354SDave Airlie 78821d70354SDave Airlie ret = drm_minor_register(dev, DRM_MINOR_RENDER); 78921d70354SDave Airlie if (ret) 79021d70354SDave Airlie goto err_minors; 79121d70354SDave Airlie 792a3ccc461SDavid Herrmann ret = drm_minor_register(dev, DRM_MINOR_PRIMARY); 79321d70354SDave Airlie if (ret) 79421d70354SDave Airlie goto err_minors; 79521d70354SDave Airlie 7966449b088SDaniel Vetter ret = create_compat_control_link(dev); 7976449b088SDaniel Vetter if (ret) 7986449b088SDaniel Vetter goto err_minors; 7996449b088SDaniel Vetter 800e6e7b48bSDaniel Vetter dev->registered = true; 801e6e7b48bSDaniel Vetter 80221d70354SDave Airlie if (dev->driver->load) { 80321d70354SDave Airlie ret = dev->driver->load(dev, flags); 80421d70354SDave Airlie if (ret) 80521d70354SDave Airlie goto err_minors; 80621d70354SDave Airlie } 80721d70354SDave Airlie 808bee7fb15SChris Wilson if (drm_core_check_feature(dev, DRIVER_MODESET)) 80979190ea2SBenjamin Gaignard drm_modeset_register_all(dev); 810e28cd4d0SChris Wilson 81121d70354SDave Airlie ret = 0; 81275f6dfe3SGabriel Krisman Bertazi 81375f6dfe3SGabriel Krisman Bertazi DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", 81475f6dfe3SGabriel Krisman Bertazi driver->name, driver->major, driver->minor, 8156098909cSChris Wilson driver->patchlevel, driver->date, 8166098909cSChris Wilson dev->dev ? dev_name(dev->dev) : "virtual device", 81775f6dfe3SGabriel Krisman Bertazi dev->primary->index); 81875f6dfe3SGabriel Krisman Bertazi 81921d70354SDave Airlie goto out_unlock; 82021d70354SDave Airlie 82121d70354SDave Airlie err_minors: 8226449b088SDaniel Vetter remove_compat_control_link(dev); 823a3ccc461SDavid Herrmann drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 82421d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 82521d70354SDave Airlie out_unlock: 82621d70354SDave Airlie mutex_unlock(&drm_global_mutex); 82721d70354SDave Airlie return ret; 82821d70354SDave Airlie } 82921d70354SDave Airlie EXPORT_SYMBOL(drm_dev_register); 83021d70354SDave Airlie 83121d70354SDave Airlie /** 83221d70354SDave Airlie * drm_dev_unregister - Unregister DRM device 83321d70354SDave Airlie * @dev: Device to unregister 83421d70354SDave Airlie * 83521d70354SDave Airlie * Unregister the DRM device from the system. This does the reverse of 83621d70354SDave Airlie * drm_dev_register() but does not deallocate the device. The caller must call 8379a96f550SAishwarya Pant * drm_dev_put() to drop their final reference. 8386e3f797cSDaniel Vetter * 839c07dcd61SDaniel Vetter * A special form of unregistering for hotpluggable devices is drm_dev_unplug(), 840c07dcd61SDaniel Vetter * which can be called while there are still open users of @dev. 841c07dcd61SDaniel Vetter * 8426e3f797cSDaniel Vetter * This should be called first in the device teardown code to make sure 8436e3f797cSDaniel Vetter * userspace can't access the device instance any more. 84421d70354SDave Airlie */ 84521d70354SDave Airlie void drm_dev_unregister(struct drm_device *dev) 84621d70354SDave Airlie { 84721d70354SDave Airlie struct drm_map_list *r_list, *list_temp; 84821d70354SDave Airlie 8492e45eeacSDaniel Vetter if (drm_core_check_feature(dev, DRIVER_LEGACY)) 85021d70354SDave Airlie drm_lastclose(dev); 85121d70354SDave Airlie 852e6e7b48bSDaniel Vetter dev->registered = false; 853e6e7b48bSDaniel Vetter 854c76f0f7cSNoralf Trønnes drm_client_dev_unregister(dev); 855c76f0f7cSNoralf Trønnes 856bee7fb15SChris Wilson if (drm_core_check_feature(dev, DRIVER_MODESET)) 85779190ea2SBenjamin Gaignard drm_modeset_unregister_all(dev); 858e28cd4d0SChris Wilson 85921d70354SDave Airlie if (dev->driver->unload) 86021d70354SDave Airlie dev->driver->unload(dev); 86121d70354SDave Airlie 86221d70354SDave Airlie if (dev->agp) 86321d70354SDave Airlie drm_pci_agp_destroy(dev); 86421d70354SDave Airlie 86521d70354SDave Airlie list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) 8669fc5cde7SDavid Herrmann drm_legacy_rmmap(dev, r_list->map); 86721d70354SDave Airlie 8686449b088SDaniel Vetter remove_compat_control_link(dev); 869a3ccc461SDavid Herrmann drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 87021d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 87121d70354SDave Airlie } 87221d70354SDave Airlie EXPORT_SYMBOL(drm_dev_unregister); 87321d70354SDave Airlie 874a6b5fac5SGerd Hoffmann /** 875a6b5fac5SGerd Hoffmann * drm_dev_set_unique - Set the unique name of a DRM device 876a6b5fac5SGerd Hoffmann * @dev: device of which to set the unique name 877a6b5fac5SGerd Hoffmann * @name: unique name 878a6b5fac5SGerd Hoffmann * 87933e70110SDaniel Vetter * Sets the unique name of a DRM device using the specified string. This is 88033e70110SDaniel Vetter * already done by drm_dev_init(), drivers should only override the default 88133e70110SDaniel Vetter * unique name for backwards compatibility reasons. 882a6b5fac5SGerd Hoffmann * 883a6b5fac5SGerd Hoffmann * Return: 0 on success or a negative error code on failure. 884a6b5fac5SGerd Hoffmann */ 885a6b5fac5SGerd Hoffmann int drm_dev_set_unique(struct drm_device *dev, const char *name) 886a6b5fac5SGerd Hoffmann { 887a6b5fac5SGerd Hoffmann kfree(dev->unique); 888a6b5fac5SGerd Hoffmann dev->unique = kstrdup(name, GFP_KERNEL); 889a6b5fac5SGerd Hoffmann 890a6b5fac5SGerd Hoffmann return dev->unique ? 0 : -ENOMEM; 891a6b5fac5SGerd Hoffmann } 892a6b5fac5SGerd Hoffmann EXPORT_SYMBOL(drm_dev_set_unique); 893a6b5fac5SGerd Hoffmann 89421d70354SDave Airlie /* 89521d70354SDave Airlie * DRM Core 89621d70354SDave Airlie * The DRM core module initializes all global DRM objects and makes them 89721d70354SDave Airlie * available to drivers. Once setup, drivers can probe their respective 89821d70354SDave Airlie * devices. 89921d70354SDave Airlie * Currently, core management includes: 90021d70354SDave Airlie * - The "DRM-Global" key/value database 90121d70354SDave Airlie * - Global ID management for connectors 90221d70354SDave Airlie * - DRM major number allocation 90321d70354SDave Airlie * - DRM minor management 90421d70354SDave Airlie * - DRM sysfs class 90521d70354SDave Airlie * - DRM debugfs root 90621d70354SDave Airlie * 90721d70354SDave Airlie * Furthermore, the DRM core provides dynamic char-dev lookups. For each 90821d70354SDave Airlie * interface registered on a DRM device, you can request minor numbers from DRM 90921d70354SDave Airlie * core. DRM core takes care of major-number management and char-dev 91021d70354SDave Airlie * registration. A stub ->open() callback forwards any open() requests to the 91121d70354SDave Airlie * registered minor. 91221d70354SDave Airlie */ 91321d70354SDave Airlie 91421d70354SDave Airlie static int drm_stub_open(struct inode *inode, struct file *filp) 91521d70354SDave Airlie { 91621d70354SDave Airlie const struct file_operations *new_fops; 91721d70354SDave Airlie struct drm_minor *minor; 91821d70354SDave Airlie int err; 91921d70354SDave Airlie 92021d70354SDave Airlie DRM_DEBUG("\n"); 92121d70354SDave Airlie 92221d70354SDave Airlie mutex_lock(&drm_global_mutex); 92321d70354SDave Airlie minor = drm_minor_acquire(iminor(inode)); 92421d70354SDave Airlie if (IS_ERR(minor)) { 92521d70354SDave Airlie err = PTR_ERR(minor); 92621d70354SDave Airlie goto out_unlock; 92721d70354SDave Airlie } 92821d70354SDave Airlie 92921d70354SDave Airlie new_fops = fops_get(minor->dev->driver->fops); 93021d70354SDave Airlie if (!new_fops) { 93121d70354SDave Airlie err = -ENODEV; 93221d70354SDave Airlie goto out_release; 93321d70354SDave Airlie } 93421d70354SDave Airlie 93521d70354SDave Airlie replace_fops(filp, new_fops); 93621d70354SDave Airlie if (filp->f_op->open) 93721d70354SDave Airlie err = filp->f_op->open(inode, filp); 93821d70354SDave Airlie else 93921d70354SDave Airlie err = 0; 94021d70354SDave Airlie 94121d70354SDave Airlie out_release: 94221d70354SDave Airlie drm_minor_release(minor); 94321d70354SDave Airlie out_unlock: 94421d70354SDave Airlie mutex_unlock(&drm_global_mutex); 94521d70354SDave Airlie return err; 94621d70354SDave Airlie } 94721d70354SDave Airlie 94821d70354SDave Airlie static const struct file_operations drm_stub_fops = { 94921d70354SDave Airlie .owner = THIS_MODULE, 95021d70354SDave Airlie .open = drm_stub_open, 95121d70354SDave Airlie .llseek = noop_llseek, 95221d70354SDave Airlie }; 95321d70354SDave Airlie 9542cc107dcSDavid Herrmann static void drm_core_exit(void) 9552cc107dcSDavid Herrmann { 9562cc107dcSDavid Herrmann unregister_chrdev(DRM_MAJOR, "drm"); 9572cc107dcSDavid Herrmann debugfs_remove(drm_debugfs_root); 9582cc107dcSDavid Herrmann drm_sysfs_destroy(); 9592cc107dcSDavid Herrmann idr_destroy(&drm_minors_idr); 9602cc107dcSDavid Herrmann drm_connector_ida_destroy(); 9612cc107dcSDavid Herrmann } 9622cc107dcSDavid Herrmann 96321d70354SDave Airlie static int __init drm_core_init(void) 96421d70354SDave Airlie { 9652cc107dcSDavid Herrmann int ret; 96621d70354SDave Airlie 96721d70354SDave Airlie drm_connector_ida_init(); 96821d70354SDave Airlie idr_init(&drm_minors_idr); 96921d70354SDave Airlie 970fcc90213SDavid Herrmann ret = drm_sysfs_init(); 971fcc90213SDavid Herrmann if (ret < 0) { 9722cc107dcSDavid Herrmann DRM_ERROR("Cannot create DRM class: %d\n", ret); 9732cc107dcSDavid Herrmann goto error; 97421d70354SDave Airlie } 97521d70354SDave Airlie 97621d70354SDave Airlie drm_debugfs_root = debugfs_create_dir("dri", NULL); 97721d70354SDave Airlie if (!drm_debugfs_root) { 9782cc107dcSDavid Herrmann ret = -ENOMEM; 9792cc107dcSDavid Herrmann DRM_ERROR("Cannot create debugfs-root: %d\n", ret); 9802cc107dcSDavid Herrmann goto error; 98121d70354SDave Airlie } 98221d70354SDave Airlie 9832cc107dcSDavid Herrmann ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops); 9842cc107dcSDavid Herrmann if (ret < 0) 9852cc107dcSDavid Herrmann goto error; 9862cc107dcSDavid Herrmann 987371c2279SAlexandru Moise drm_core_init_complete = true; 988371c2279SAlexandru Moise 989e82dfa00SChris Wilson DRM_DEBUG("Initialized\n"); 99021d70354SDave Airlie return 0; 99121d70354SDave Airlie 9922cc107dcSDavid Herrmann error: 9932cc107dcSDavid Herrmann drm_core_exit(); 99421d70354SDave Airlie return ret; 99521d70354SDave Airlie } 99621d70354SDave Airlie 99721d70354SDave Airlie module_init(drm_core_init); 99821d70354SDave Airlie module_exit(drm_core_exit); 999