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> 3585e634bcSDaniel Vetter 3685e634bcSDaniel Vetter #include <drm/drm_drv.h> 3721d70354SDave Airlie #include <drm/drmP.h> 3885e634bcSDaniel Vetter 3979190ea2SBenjamin Gaignard #include "drm_crtc_internal.h" 4021d70354SDave Airlie #include "drm_legacy.h" 4167d0ec4eSDaniel Vetter #include "drm_internal.h" 4281065548SDaniel Vetter #include "drm_crtc_internal.h" 4321d70354SDave Airlie 446dc3e22eSEzequiel Garcia /* 456dc3e22eSEzequiel Garcia * drm_debug: Enable debug output. 466dc3e22eSEzequiel Garcia * Bitmask of DRM_UT_x. See include/drm/drmP.h for details. 476dc3e22eSEzequiel Garcia */ 486dc3e22eSEzequiel Garcia unsigned int drm_debug = 0; 4921d70354SDave Airlie EXPORT_SYMBOL(drm_debug); 5021d70354SDave Airlie 5182d5e73fSDavid Herrmann MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl"); 5282d5e73fSDavid Herrmann MODULE_DESCRIPTION("DRM shared core routines"); 5321d70354SDave Airlie MODULE_LICENSE("GPL and additional rights"); 546dc3e22eSEzequiel Garcia MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug category.\n" 556dc3e22eSEzequiel Garcia "\t\tBit 0 (0x01) will enable CORE messages (drm core code)\n" 566dc3e22eSEzequiel Garcia "\t\tBit 1 (0x02) will enable DRIVER messages (drm controller code)\n" 576dc3e22eSEzequiel Garcia "\t\tBit 2 (0x04) will enable KMS messages (modesetting code)\n" 586dc3e22eSEzequiel Garcia "\t\tBit 3 (0x08) will enable PRIME messages (prime code)\n" 596dc3e22eSEzequiel Garcia "\t\tBit 4 (0x10) will enable ATOMIC messages (atomic code)\n" 606dc3e22eSEzequiel Garcia "\t\tBit 5 (0x20) will enable VBL messages (vblank code)"); 6121d70354SDave Airlie module_param_named(debug, drm_debug, int, 0600); 6221d70354SDave Airlie 6321d70354SDave Airlie static DEFINE_SPINLOCK(drm_minor_lock); 6421d70354SDave Airlie static struct idr drm_minors_idr; 6521d70354SDave Airlie 6621d70354SDave Airlie static struct dentry *drm_debugfs_root; 6721d70354SDave Airlie 68c4e68a58SSean Paul #define DRM_PRINTK_FMT "[" DRM_NAME ":%s]%s %pV" 69c4e68a58SSean Paul 70c4e68a58SSean Paul void drm_dev_printk(const struct device *dev, const char *level, 71c4e68a58SSean Paul unsigned int category, const char *function_name, 72c4e68a58SSean Paul const char *prefix, const char *format, ...) 7321d70354SDave Airlie { 7421d70354SDave Airlie struct va_format vaf; 7521d70354SDave Airlie va_list args; 7621d70354SDave Airlie 77c4e68a58SSean Paul if (category != DRM_UT_NONE && !(drm_debug & category)) 78c4e68a58SSean Paul return; 7921d70354SDave Airlie 8021d70354SDave Airlie va_start(args, format); 8121d70354SDave Airlie vaf.fmt = format; 8221d70354SDave Airlie vaf.va = &args; 8321d70354SDave Airlie 84b4ba97e7SChris Wilson if (dev) 85c4e68a58SSean Paul dev_printk(level, dev, DRM_PRINTK_FMT, function_name, prefix, 86c4e68a58SSean Paul &vaf); 87b4ba97e7SChris Wilson else 88b4ba97e7SChris Wilson printk("%s" DRM_PRINTK_FMT, level, function_name, prefix, &vaf); 8921d70354SDave Airlie 9021d70354SDave Airlie va_end(args); 9121d70354SDave Airlie } 92c4e68a58SSean Paul EXPORT_SYMBOL(drm_dev_printk); 93c4e68a58SSean Paul 94c4e68a58SSean Paul void drm_printk(const char *level, unsigned int category, 95c4e68a58SSean Paul const char *format, ...) 96c4e68a58SSean Paul { 97c4e68a58SSean Paul struct va_format vaf; 98c4e68a58SSean Paul va_list args; 99c4e68a58SSean Paul 100c4e68a58SSean Paul if (category != DRM_UT_NONE && !(drm_debug & category)) 101c4e68a58SSean Paul return; 102c4e68a58SSean Paul 103c4e68a58SSean Paul va_start(args, format); 104c4e68a58SSean Paul vaf.fmt = format; 105c4e68a58SSean Paul vaf.va = &args; 106c4e68a58SSean Paul 1076bd488dbSJoe Perches printk("%s" "[" DRM_NAME ":%ps]%s %pV", 1086bd488dbSJoe Perches level, __builtin_return_address(0), 1096bd488dbSJoe Perches strcmp(level, KERN_ERR) == 0 ? " *ERROR*" : "", &vaf); 110c4e68a58SSean Paul 111c4e68a58SSean Paul va_end(args); 112c4e68a58SSean Paul } 113c4e68a58SSean Paul EXPORT_SYMBOL(drm_printk); 11421d70354SDave Airlie 11521d70354SDave Airlie /* 11621d70354SDave Airlie * DRM Minors 11721d70354SDave Airlie * A DRM device can provide several char-dev interfaces on the DRM-Major. Each 11821d70354SDave Airlie * of them is represented by a drm_minor object. Depending on the capabilities 11921d70354SDave Airlie * of the device-driver, different interfaces are registered. 12021d70354SDave Airlie * 12121d70354SDave Airlie * Minors can be accessed via dev->$minor_name. This pointer is either 12221d70354SDave Airlie * NULL or a valid drm_minor pointer and stays valid as long as the device is 12321d70354SDave Airlie * valid. This means, DRM minors have the same life-time as the underlying 12421d70354SDave Airlie * device. However, this doesn't mean that the minor is active. Minors are 12521d70354SDave Airlie * registered and unregistered dynamically according to device-state. 12621d70354SDave Airlie */ 12721d70354SDave Airlie 12821d70354SDave Airlie static struct drm_minor **drm_minor_get_slot(struct drm_device *dev, 12921d70354SDave Airlie unsigned int type) 13021d70354SDave Airlie { 13121d70354SDave Airlie switch (type) { 132a3ccc461SDavid Herrmann case DRM_MINOR_PRIMARY: 13321d70354SDave Airlie return &dev->primary; 13421d70354SDave Airlie case DRM_MINOR_RENDER: 13521d70354SDave Airlie return &dev->render; 13621d70354SDave Airlie case DRM_MINOR_CONTROL: 13721d70354SDave Airlie return &dev->control; 13821d70354SDave Airlie default: 13921d70354SDave Airlie return NULL; 14021d70354SDave Airlie } 14121d70354SDave Airlie } 14221d70354SDave Airlie 14321d70354SDave Airlie static int drm_minor_alloc(struct drm_device *dev, unsigned int type) 14421d70354SDave Airlie { 14521d70354SDave Airlie struct drm_minor *minor; 14621d70354SDave Airlie unsigned long flags; 14721d70354SDave Airlie int r; 14821d70354SDave Airlie 14921d70354SDave Airlie minor = kzalloc(sizeof(*minor), GFP_KERNEL); 15021d70354SDave Airlie if (!minor) 15121d70354SDave Airlie return -ENOMEM; 15221d70354SDave Airlie 15321d70354SDave Airlie minor->type = type; 15421d70354SDave Airlie minor->dev = dev; 15521d70354SDave Airlie 15621d70354SDave Airlie idr_preload(GFP_KERNEL); 15721d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 15821d70354SDave Airlie r = idr_alloc(&drm_minors_idr, 15921d70354SDave Airlie NULL, 16021d70354SDave Airlie 64 * type, 16121d70354SDave Airlie 64 * (type + 1), 16221d70354SDave Airlie GFP_NOWAIT); 16321d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 16421d70354SDave Airlie idr_preload_end(); 16521d70354SDave Airlie 16621d70354SDave Airlie if (r < 0) 16721d70354SDave Airlie goto err_free; 16821d70354SDave Airlie 16921d70354SDave Airlie minor->index = r; 17021d70354SDave Airlie 17121d70354SDave Airlie minor->kdev = drm_sysfs_minor_alloc(minor); 17221d70354SDave Airlie if (IS_ERR(minor->kdev)) { 17321d70354SDave Airlie r = PTR_ERR(minor->kdev); 17421d70354SDave Airlie goto err_index; 17521d70354SDave Airlie } 17621d70354SDave Airlie 17721d70354SDave Airlie *drm_minor_get_slot(dev, type) = minor; 17821d70354SDave Airlie return 0; 17921d70354SDave Airlie 18021d70354SDave Airlie err_index: 18121d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 18221d70354SDave Airlie idr_remove(&drm_minors_idr, minor->index); 18321d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 18421d70354SDave Airlie err_free: 18521d70354SDave Airlie kfree(minor); 18621d70354SDave Airlie return r; 18721d70354SDave Airlie } 18821d70354SDave Airlie 18921d70354SDave Airlie static void drm_minor_free(struct drm_device *dev, unsigned int type) 19021d70354SDave Airlie { 19121d70354SDave Airlie struct drm_minor **slot, *minor; 19221d70354SDave Airlie unsigned long flags; 19321d70354SDave Airlie 19421d70354SDave Airlie slot = drm_minor_get_slot(dev, type); 19521d70354SDave Airlie minor = *slot; 19621d70354SDave Airlie if (!minor) 19721d70354SDave Airlie return; 19821d70354SDave Airlie 19921d70354SDave Airlie put_device(minor->kdev); 20021d70354SDave Airlie 20121d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 20221d70354SDave Airlie idr_remove(&drm_minors_idr, minor->index); 20321d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 20421d70354SDave Airlie 20521d70354SDave Airlie kfree(minor); 20621d70354SDave Airlie *slot = NULL; 20721d70354SDave Airlie } 20821d70354SDave Airlie 20921d70354SDave Airlie static int drm_minor_register(struct drm_device *dev, unsigned int type) 21021d70354SDave Airlie { 21121d70354SDave Airlie struct drm_minor *minor; 21221d70354SDave Airlie unsigned long flags; 21321d70354SDave Airlie int ret; 21421d70354SDave Airlie 21521d70354SDave Airlie DRM_DEBUG("\n"); 21621d70354SDave Airlie 21721d70354SDave Airlie minor = *drm_minor_get_slot(dev, type); 21821d70354SDave Airlie if (!minor) 21921d70354SDave Airlie return 0; 22021d70354SDave Airlie 22121d70354SDave Airlie ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root); 22221d70354SDave Airlie if (ret) { 22321d70354SDave Airlie DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n"); 224a67834f8SNoralf Trønnes goto err_debugfs; 22521d70354SDave Airlie } 22621d70354SDave Airlie 22721d70354SDave Airlie ret = device_add(minor->kdev); 22821d70354SDave Airlie if (ret) 22921d70354SDave Airlie goto err_debugfs; 23021d70354SDave Airlie 23121d70354SDave Airlie /* replace NULL with @minor so lookups will succeed from now on */ 23221d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 23321d70354SDave Airlie idr_replace(&drm_minors_idr, minor, minor->index); 23421d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 23521d70354SDave Airlie 23621d70354SDave Airlie DRM_DEBUG("new minor registered %d\n", minor->index); 23721d70354SDave Airlie return 0; 23821d70354SDave Airlie 23921d70354SDave Airlie err_debugfs: 24021d70354SDave Airlie drm_debugfs_cleanup(minor); 24121d70354SDave Airlie return ret; 24221d70354SDave Airlie } 24321d70354SDave Airlie 24421d70354SDave Airlie static void drm_minor_unregister(struct drm_device *dev, unsigned int type) 24521d70354SDave Airlie { 24621d70354SDave Airlie struct drm_minor *minor; 24721d70354SDave Airlie unsigned long flags; 24821d70354SDave Airlie 24921d70354SDave Airlie minor = *drm_minor_get_slot(dev, type); 25021d70354SDave Airlie if (!minor || !device_is_registered(minor->kdev)) 25121d70354SDave Airlie return; 25221d70354SDave Airlie 25321d70354SDave Airlie /* replace @minor with NULL so lookups will fail from now on */ 25421d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 25521d70354SDave Airlie idr_replace(&drm_minors_idr, NULL, minor->index); 25621d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 25721d70354SDave Airlie 25821d70354SDave Airlie device_del(minor->kdev); 25921d70354SDave Airlie dev_set_drvdata(minor->kdev, NULL); /* safety belt */ 26021d70354SDave Airlie drm_debugfs_cleanup(minor); 26121d70354SDave Airlie } 26221d70354SDave Airlie 26385e634bcSDaniel Vetter /* 26421d70354SDave Airlie * Looks up the given minor-ID and returns the respective DRM-minor object. The 26521d70354SDave Airlie * refence-count of the underlying device is increased so you must release this 26621d70354SDave Airlie * object with drm_minor_release(). 26721d70354SDave Airlie * 26821d70354SDave Airlie * As long as you hold this minor, it is guaranteed that the object and the 26921d70354SDave Airlie * minor->dev pointer will stay valid! However, the device may get unplugged and 27021d70354SDave Airlie * unregistered while you hold the minor. 27121d70354SDave Airlie */ 27221d70354SDave Airlie struct drm_minor *drm_minor_acquire(unsigned int minor_id) 27321d70354SDave Airlie { 27421d70354SDave Airlie struct drm_minor *minor; 27521d70354SDave Airlie unsigned long flags; 27621d70354SDave Airlie 27721d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 27821d70354SDave Airlie minor = idr_find(&drm_minors_idr, minor_id); 27921d70354SDave Airlie if (minor) 28021d70354SDave Airlie drm_dev_ref(minor->dev); 28121d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 28221d70354SDave Airlie 28321d70354SDave Airlie if (!minor) { 28421d70354SDave Airlie return ERR_PTR(-ENODEV); 28521d70354SDave Airlie } else if (drm_device_is_unplugged(minor->dev)) { 28621d70354SDave Airlie drm_dev_unref(minor->dev); 28721d70354SDave Airlie return ERR_PTR(-ENODEV); 28821d70354SDave Airlie } 28921d70354SDave Airlie 29021d70354SDave Airlie return minor; 29121d70354SDave Airlie } 29221d70354SDave Airlie 29321d70354SDave Airlie void drm_minor_release(struct drm_minor *minor) 29421d70354SDave Airlie { 29521d70354SDave Airlie drm_dev_unref(minor->dev); 29621d70354SDave Airlie } 29721d70354SDave Airlie 29821d70354SDave Airlie /** 2996e3f797cSDaniel Vetter * DOC: driver instance overview 3006e3f797cSDaniel Vetter * 301ea0dd85aSDaniel Vetter * A device instance for a drm driver is represented by &struct drm_device. This 3026e3f797cSDaniel Vetter * is allocated with drm_dev_alloc(), usually from bus-specific ->probe() 3036e3f797cSDaniel Vetter * callbacks implemented by the driver. The driver then needs to initialize all 3046e3f797cSDaniel Vetter * the various subsystems for the drm device like memory management, vblank 3056e3f797cSDaniel Vetter * handling, modesetting support and intial output configuration plus obviously 306a6b5fac5SGerd Hoffmann * initialize all the corresponding hardware bits. An important part of this is 307a6b5fac5SGerd Hoffmann * also calling drm_dev_set_unique() to set the userspace-visible unique name of 308a6b5fac5SGerd Hoffmann * this device instance. Finally when everything is up and running and ready for 309a6b5fac5SGerd Hoffmann * userspace the device instance can be published using drm_dev_register(). 3106e3f797cSDaniel Vetter * 3116e3f797cSDaniel Vetter * There is also deprecated support for initalizing device instances using 312ef40cbf9SDaniel Vetter * bus-specific helpers and the &drm_driver.load callback. But due to 3136e3f797cSDaniel Vetter * backwards-compatibility needs the device instance have to be published too 3146e3f797cSDaniel Vetter * early, which requires unpretty global locking to make safe and is therefore 3156e3f797cSDaniel Vetter * only support for existing drivers not yet converted to the new scheme. 3166e3f797cSDaniel Vetter * 3176e3f797cSDaniel Vetter * When cleaning up a device instance everything needs to be done in reverse: 3186e3f797cSDaniel Vetter * First unpublish the device instance with drm_dev_unregister(). Then clean up 3196e3f797cSDaniel Vetter * any other resources allocated at device initialization and drop the driver's 3206e3f797cSDaniel Vetter * reference to &drm_device using drm_dev_unref(). 3216e3f797cSDaniel Vetter * 3226e3f797cSDaniel Vetter * Note that the lifetime rules for &drm_device instance has still a lot of 3236e3f797cSDaniel Vetter * historical baggage. Hence use the reference counting provided by 3246e3f797cSDaniel Vetter * drm_dev_ref() and drm_dev_unref() only carefully. 3256e3f797cSDaniel Vetter * 326ea0dd85aSDaniel Vetter * It is recommended that drivers embed &struct drm_device into their own device 327d82faafdSDaniel Vetter * structure, which is supported through drm_dev_init(). 3286e3f797cSDaniel Vetter */ 3296e3f797cSDaniel Vetter 3306e3f797cSDaniel Vetter /** 33121d70354SDave Airlie * drm_put_dev - Unregister and release a DRM device 33221d70354SDave Airlie * @dev: DRM device 33321d70354SDave Airlie * 33421d70354SDave Airlie * Called at module unload time or when a PCI device is unplugged. 33521d70354SDave Airlie * 33621d70354SDave Airlie * Cleans up all DRM device, calling drm_lastclose(). 3376e3f797cSDaniel Vetter * 3386e3f797cSDaniel Vetter * Note: Use of this function is deprecated. It will eventually go away 3396e3f797cSDaniel Vetter * completely. Please use drm_dev_unregister() and drm_dev_unref() explicitly 3406e3f797cSDaniel Vetter * instead to make sure that the device isn't userspace accessible any more 3416e3f797cSDaniel Vetter * while teardown is in progress, ensuring that userspace can't access an 3426e3f797cSDaniel Vetter * inconsistent state. 34321d70354SDave Airlie */ 34421d70354SDave Airlie void drm_put_dev(struct drm_device *dev) 34521d70354SDave Airlie { 34621d70354SDave Airlie DRM_DEBUG("\n"); 34721d70354SDave Airlie 34821d70354SDave Airlie if (!dev) { 34921d70354SDave Airlie DRM_ERROR("cleanup called no dev\n"); 35021d70354SDave Airlie return; 35121d70354SDave Airlie } 35221d70354SDave Airlie 35321d70354SDave Airlie drm_dev_unregister(dev); 35421d70354SDave Airlie drm_dev_unref(dev); 35521d70354SDave Airlie } 35621d70354SDave Airlie EXPORT_SYMBOL(drm_put_dev); 35721d70354SDave Airlie 35821d70354SDave Airlie void drm_unplug_dev(struct drm_device *dev) 35921d70354SDave Airlie { 36021d70354SDave Airlie /* for a USB device */ 361a39be606SChris Wilson drm_dev_unregister(dev); 36221d70354SDave Airlie 36321d70354SDave Airlie mutex_lock(&drm_global_mutex); 36421d70354SDave Airlie 36521d70354SDave Airlie drm_device_set_unplugged(dev); 36621d70354SDave Airlie 36721d70354SDave Airlie if (dev->open_count == 0) { 36821d70354SDave Airlie drm_put_dev(dev); 36921d70354SDave Airlie } 37021d70354SDave Airlie mutex_unlock(&drm_global_mutex); 37121d70354SDave Airlie } 37221d70354SDave Airlie EXPORT_SYMBOL(drm_unplug_dev); 37321d70354SDave Airlie 37421d70354SDave Airlie /* 37521d70354SDave Airlie * DRM internal mount 37621d70354SDave Airlie * We want to be able to allocate our own "struct address_space" to control 37721d70354SDave Airlie * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow 37821d70354SDave Airlie * stand-alone address_space objects, so we need an underlying inode. As there 37921d70354SDave Airlie * is no way to allocate an independent inode easily, we need a fake internal 38021d70354SDave Airlie * VFS mount-point. 38121d70354SDave Airlie * 38221d70354SDave Airlie * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free() 38321d70354SDave Airlie * frees it again. You are allowed to use iget() and iput() to get references to 38421d70354SDave Airlie * the inode. But each drm_fs_inode_new() call must be paired with exactly one 38521d70354SDave Airlie * drm_fs_inode_free() call (which does not have to be the last iput()). 38621d70354SDave Airlie * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it 38721d70354SDave Airlie * between multiple inode-users. You could, technically, call 38821d70354SDave Airlie * iget() + drm_fs_inode_free() directly after alloc and sometime later do an 38921d70354SDave Airlie * iput(), but this way you'd end up with a new vfsmount for each inode. 39021d70354SDave Airlie */ 39121d70354SDave Airlie 39221d70354SDave Airlie static int drm_fs_cnt; 39321d70354SDave Airlie static struct vfsmount *drm_fs_mnt; 39421d70354SDave Airlie 39521d70354SDave Airlie static const struct dentry_operations drm_fs_dops = { 39621d70354SDave Airlie .d_dname = simple_dname, 39721d70354SDave Airlie }; 39821d70354SDave Airlie 39921d70354SDave Airlie static const struct super_operations drm_fs_sops = { 40021d70354SDave Airlie .statfs = simple_statfs, 40121d70354SDave Airlie }; 40221d70354SDave Airlie 40321d70354SDave Airlie static struct dentry *drm_fs_mount(struct file_system_type *fs_type, int flags, 40421d70354SDave Airlie const char *dev_name, void *data) 40521d70354SDave Airlie { 40621d70354SDave Airlie return mount_pseudo(fs_type, 40721d70354SDave Airlie "drm:", 40821d70354SDave Airlie &drm_fs_sops, 40921d70354SDave Airlie &drm_fs_dops, 41021d70354SDave Airlie 0x010203ff); 41121d70354SDave Airlie } 41221d70354SDave Airlie 41321d70354SDave Airlie static struct file_system_type drm_fs_type = { 41421d70354SDave Airlie .name = "drm", 41521d70354SDave Airlie .owner = THIS_MODULE, 41621d70354SDave Airlie .mount = drm_fs_mount, 41721d70354SDave Airlie .kill_sb = kill_anon_super, 41821d70354SDave Airlie }; 41921d70354SDave Airlie 42021d70354SDave Airlie static struct inode *drm_fs_inode_new(void) 42121d70354SDave Airlie { 42221d70354SDave Airlie struct inode *inode; 42321d70354SDave Airlie int r; 42421d70354SDave Airlie 42521d70354SDave Airlie r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt); 42621d70354SDave Airlie if (r < 0) { 42721d70354SDave Airlie DRM_ERROR("Cannot mount pseudo fs: %d\n", r); 42821d70354SDave Airlie return ERR_PTR(r); 42921d70354SDave Airlie } 43021d70354SDave Airlie 43121d70354SDave Airlie inode = alloc_anon_inode(drm_fs_mnt->mnt_sb); 43221d70354SDave Airlie if (IS_ERR(inode)) 43321d70354SDave Airlie simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 43421d70354SDave Airlie 43521d70354SDave Airlie return inode; 43621d70354SDave Airlie } 43721d70354SDave Airlie 43821d70354SDave Airlie static void drm_fs_inode_free(struct inode *inode) 43921d70354SDave Airlie { 44021d70354SDave Airlie if (inode) { 44121d70354SDave Airlie iput(inode); 44221d70354SDave Airlie simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 44321d70354SDave Airlie } 44421d70354SDave Airlie } 44521d70354SDave Airlie 44621d70354SDave Airlie /** 447b209aca3SChris Wilson * drm_dev_init - Initialise new DRM device 448b209aca3SChris Wilson * @dev: DRM device 449b209aca3SChris Wilson * @driver: DRM driver 45021d70354SDave Airlie * @parent: Parent device object 45121d70354SDave Airlie * 452b209aca3SChris Wilson * Initialize a new DRM device. No device registration is done. 45321d70354SDave Airlie * Call drm_dev_register() to advertice the device to user space and register it 4546e3f797cSDaniel Vetter * with other core subsystems. This should be done last in the device 4556e3f797cSDaniel Vetter * initialization sequence to make sure userspace can't access an inconsistent 4566e3f797cSDaniel Vetter * state. 45721d70354SDave Airlie * 45821d70354SDave Airlie * The initial ref-count of the object is 1. Use drm_dev_ref() and 45921d70354SDave Airlie * drm_dev_unref() to take and drop further ref-counts. 46021d70354SDave Airlie * 461b0ff4b93SDaniel Vetter * Note that for purely virtual devices @parent can be NULL. 462b0ff4b93SDaniel Vetter * 463b209aca3SChris Wilson * Drivers that do not want to allocate their own device struct 464ea0dd85aSDaniel Vetter * embedding &struct drm_device can call drm_dev_alloc() instead. For drivers 465ea0dd85aSDaniel Vetter * that do embed &struct drm_device it must be placed first in the overall 466d82faafdSDaniel Vetter * structure, and the overall structure must be allocated using kmalloc(): The 467d82faafdSDaniel Vetter * drm core's release function unconditionally calls kfree() on the @dev pointer 468d82faafdSDaniel Vetter * when the final reference is released. 469b209aca3SChris Wilson * 47021d70354SDave Airlie * RETURNS: 471b209aca3SChris Wilson * 0 on success, or error code on failure. 47221d70354SDave Airlie */ 473b209aca3SChris Wilson int drm_dev_init(struct drm_device *dev, 474b209aca3SChris Wilson struct drm_driver *driver, 47521d70354SDave Airlie struct device *parent) 47621d70354SDave Airlie { 47721d70354SDave Airlie int ret; 47821d70354SDave Airlie 47921d70354SDave Airlie kref_init(&dev->ref); 48021d70354SDave Airlie dev->dev = parent; 48121d70354SDave Airlie dev->driver = driver; 48221d70354SDave Airlie 48321d70354SDave Airlie INIT_LIST_HEAD(&dev->filelist); 48421d70354SDave Airlie INIT_LIST_HEAD(&dev->ctxlist); 48521d70354SDave Airlie INIT_LIST_HEAD(&dev->vmalist); 48621d70354SDave Airlie INIT_LIST_HEAD(&dev->maplist); 48721d70354SDave Airlie INIT_LIST_HEAD(&dev->vblank_event_list); 48821d70354SDave Airlie 48921d70354SDave Airlie spin_lock_init(&dev->buf_lock); 49021d70354SDave Airlie spin_lock_init(&dev->event_lock); 49121d70354SDave Airlie mutex_init(&dev->struct_mutex); 4921d2ac403SDaniel Vetter mutex_init(&dev->filelist_mutex); 49321d70354SDave Airlie mutex_init(&dev->ctxlist_mutex); 49421d70354SDave Airlie mutex_init(&dev->master_mutex); 49521d70354SDave Airlie 49621d70354SDave Airlie dev->anon_inode = drm_fs_inode_new(); 49721d70354SDave Airlie if (IS_ERR(dev->anon_inode)) { 49821d70354SDave Airlie ret = PTR_ERR(dev->anon_inode); 49921d70354SDave Airlie DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret); 50021d70354SDave Airlie goto err_free; 50121d70354SDave Airlie } 50221d70354SDave Airlie 50321d70354SDave Airlie if (drm_core_check_feature(dev, DRIVER_RENDER)) { 50421d70354SDave Airlie ret = drm_minor_alloc(dev, DRM_MINOR_RENDER); 50521d70354SDave Airlie if (ret) 50621d70354SDave Airlie goto err_minors; 50721d70354SDave Airlie } 50821d70354SDave Airlie 509a3ccc461SDavid Herrmann ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY); 51021d70354SDave Airlie if (ret) 51121d70354SDave Airlie goto err_minors; 51221d70354SDave Airlie 513b209aca3SChris Wilson ret = drm_ht_create(&dev->map_hash, 12); 514b209aca3SChris Wilson if (ret) 51521d70354SDave Airlie goto err_minors; 51621d70354SDave Airlie 517ba6976c1SDaniel Vetter drm_legacy_ctxbitmap_init(dev); 51821d70354SDave Airlie 5191bcecfacSAndrzej Hajda if (drm_core_check_feature(dev, DRIVER_GEM)) { 52021d70354SDave Airlie ret = drm_gem_init(dev); 52121d70354SDave Airlie if (ret) { 52221d70354SDave Airlie DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n"); 52321d70354SDave Airlie goto err_ctxbitmap; 52421d70354SDave Airlie } 52521d70354SDave Airlie } 52621d70354SDave Airlie 5275079c464SDaniel Vetter /* Use the parent device name as DRM device unique identifier, but fall 5285079c464SDaniel Vetter * back to the driver name for virtual devices like vgem. */ 5295079c464SDaniel Vetter ret = drm_dev_set_unique(dev, parent ? dev_name(parent) : driver->name); 530e112e593SNicolas Iooss if (ret) 531e112e593SNicolas Iooss goto err_setunique; 532e112e593SNicolas Iooss 533b209aca3SChris Wilson return 0; 53421d70354SDave Airlie 535e112e593SNicolas Iooss err_setunique: 536e112e593SNicolas Iooss if (drm_core_check_feature(dev, DRIVER_GEM)) 537e112e593SNicolas Iooss drm_gem_destroy(dev); 53821d70354SDave Airlie err_ctxbitmap: 53921d70354SDave Airlie drm_legacy_ctxbitmap_cleanup(dev); 54021d70354SDave Airlie drm_ht_remove(&dev->map_hash); 54121d70354SDave Airlie err_minors: 542a3ccc461SDavid Herrmann drm_minor_free(dev, DRM_MINOR_PRIMARY); 54321d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_RENDER); 54421d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_CONTROL); 54521d70354SDave Airlie drm_fs_inode_free(dev->anon_inode); 54621d70354SDave Airlie err_free: 54721d70354SDave Airlie mutex_destroy(&dev->master_mutex); 548f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->ctxlist_mutex); 549f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->filelist_mutex); 550f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->struct_mutex); 551b209aca3SChris Wilson return ret; 552b209aca3SChris Wilson } 553b209aca3SChris Wilson EXPORT_SYMBOL(drm_dev_init); 554b209aca3SChris Wilson 555b209aca3SChris Wilson /** 556b209aca3SChris Wilson * drm_dev_alloc - Allocate new DRM device 557b209aca3SChris Wilson * @driver: DRM driver to allocate device for 558b209aca3SChris Wilson * @parent: Parent device object 559b209aca3SChris Wilson * 560b209aca3SChris Wilson * Allocate and initialize a new DRM device. No device registration is done. 561b209aca3SChris Wilson * Call drm_dev_register() to advertice the device to user space and register it 562b209aca3SChris Wilson * with other core subsystems. This should be done last in the device 563b209aca3SChris Wilson * initialization sequence to make sure userspace can't access an inconsistent 564b209aca3SChris Wilson * state. 565b209aca3SChris Wilson * 566b209aca3SChris Wilson * The initial ref-count of the object is 1. Use drm_dev_ref() and 567b209aca3SChris Wilson * drm_dev_unref() to take and drop further ref-counts. 568b209aca3SChris Wilson * 569b209aca3SChris Wilson * Note that for purely virtual devices @parent can be NULL. 570b209aca3SChris Wilson * 571ea0dd85aSDaniel Vetter * Drivers that wish to subclass or embed &struct drm_device into their 572b209aca3SChris Wilson * own struct should look at using drm_dev_init() instead. 573b209aca3SChris Wilson * 574b209aca3SChris Wilson * RETURNS: 5750f288605STom Gundersen * Pointer to new DRM device, or ERR_PTR on failure. 576b209aca3SChris Wilson */ 577b209aca3SChris Wilson struct drm_device *drm_dev_alloc(struct drm_driver *driver, 578b209aca3SChris Wilson struct device *parent) 579b209aca3SChris Wilson { 580b209aca3SChris Wilson struct drm_device *dev; 581b209aca3SChris Wilson int ret; 582b209aca3SChris Wilson 583b209aca3SChris Wilson dev = kzalloc(sizeof(*dev), GFP_KERNEL); 584b209aca3SChris Wilson if (!dev) 5850f288605STom Gundersen return ERR_PTR(-ENOMEM); 586b209aca3SChris Wilson 587b209aca3SChris Wilson ret = drm_dev_init(dev, driver, parent); 588b209aca3SChris Wilson if (ret) { 58921d70354SDave Airlie kfree(dev); 5900f288605STom Gundersen return ERR_PTR(ret); 59121d70354SDave Airlie } 592b209aca3SChris Wilson 593b209aca3SChris Wilson return dev; 594b209aca3SChris Wilson } 59521d70354SDave Airlie EXPORT_SYMBOL(drm_dev_alloc); 59621d70354SDave Airlie 59721d70354SDave Airlie static void drm_dev_release(struct kref *ref) 59821d70354SDave Airlie { 59921d70354SDave Airlie struct drm_device *dev = container_of(ref, struct drm_device, ref); 60021d70354SDave Airlie 6011bcecfacSAndrzej Hajda if (drm_core_check_feature(dev, DRIVER_GEM)) 60221d70354SDave Airlie drm_gem_destroy(dev); 60321d70354SDave Airlie 60421d70354SDave Airlie drm_legacy_ctxbitmap_cleanup(dev); 60521d70354SDave Airlie drm_ht_remove(&dev->map_hash); 60621d70354SDave Airlie drm_fs_inode_free(dev->anon_inode); 60721d70354SDave Airlie 608a3ccc461SDavid Herrmann drm_minor_free(dev, DRM_MINOR_PRIMARY); 60921d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_RENDER); 61021d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_CONTROL); 61121d70354SDave Airlie 61221d70354SDave Airlie mutex_destroy(&dev->master_mutex); 613f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->ctxlist_mutex); 614f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->filelist_mutex); 615f92e1ee5SJoonas Lahtinen mutex_destroy(&dev->struct_mutex); 61621d70354SDave Airlie kfree(dev->unique); 61721d70354SDave Airlie kfree(dev); 61821d70354SDave Airlie } 61921d70354SDave Airlie 62021d70354SDave Airlie /** 62121d70354SDave Airlie * drm_dev_ref - Take reference of a DRM device 62221d70354SDave Airlie * @dev: device to take reference of or NULL 62321d70354SDave Airlie * 62421d70354SDave Airlie * This increases the ref-count of @dev by one. You *must* already own a 62521d70354SDave Airlie * reference when calling this. Use drm_dev_unref() to drop this reference 62621d70354SDave Airlie * again. 62721d70354SDave Airlie * 62821d70354SDave Airlie * This function never fails. However, this function does not provide *any* 62921d70354SDave Airlie * guarantee whether the device is alive or running. It only provides a 63021d70354SDave Airlie * reference to the object and the memory associated with it. 63121d70354SDave Airlie */ 63221d70354SDave Airlie void drm_dev_ref(struct drm_device *dev) 63321d70354SDave Airlie { 63421d70354SDave Airlie if (dev) 63521d70354SDave Airlie kref_get(&dev->ref); 63621d70354SDave Airlie } 63721d70354SDave Airlie EXPORT_SYMBOL(drm_dev_ref); 63821d70354SDave Airlie 63921d70354SDave Airlie /** 64021d70354SDave Airlie * drm_dev_unref - Drop reference of a DRM device 64121d70354SDave Airlie * @dev: device to drop reference of or NULL 64221d70354SDave Airlie * 64321d70354SDave Airlie * This decreases the ref-count of @dev by one. The device is destroyed if the 64421d70354SDave Airlie * ref-count drops to zero. 64521d70354SDave Airlie */ 64621d70354SDave Airlie void drm_dev_unref(struct drm_device *dev) 64721d70354SDave Airlie { 64821d70354SDave Airlie if (dev) 64921d70354SDave Airlie kref_put(&dev->ref, drm_dev_release); 65021d70354SDave Airlie } 65121d70354SDave Airlie EXPORT_SYMBOL(drm_dev_unref); 65221d70354SDave Airlie 6536449b088SDaniel Vetter static int create_compat_control_link(struct drm_device *dev) 6546449b088SDaniel Vetter { 6556449b088SDaniel Vetter struct drm_minor *minor; 6566449b088SDaniel Vetter char *name; 6576449b088SDaniel Vetter int ret; 6586449b088SDaniel Vetter 6596449b088SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 6606449b088SDaniel Vetter return 0; 6616449b088SDaniel Vetter 6626449b088SDaniel Vetter minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 6636449b088SDaniel Vetter if (!minor) 6646449b088SDaniel Vetter return 0; 6656449b088SDaniel Vetter 6666449b088SDaniel Vetter /* 6676449b088SDaniel Vetter * Some existing userspace out there uses the existing of the controlD* 6686449b088SDaniel Vetter * sysfs files to figure out whether it's a modeset driver. It only does 6696449b088SDaniel Vetter * readdir, hence a symlink is sufficient (and the least confusing 6706449b088SDaniel Vetter * option). Otherwise controlD* is entirely unused. 6716449b088SDaniel Vetter * 6726449b088SDaniel Vetter * Old controlD chardev have been allocated in the range 6736449b088SDaniel Vetter * 64-127. 6746449b088SDaniel Vetter */ 6756449b088SDaniel Vetter name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 6766449b088SDaniel Vetter if (!name) 6776449b088SDaniel Vetter return -ENOMEM; 6786449b088SDaniel Vetter 6796449b088SDaniel Vetter ret = sysfs_create_link(minor->kdev->kobj.parent, 6806449b088SDaniel Vetter &minor->kdev->kobj, 6816449b088SDaniel Vetter name); 6826449b088SDaniel Vetter 6836449b088SDaniel Vetter kfree(name); 6846449b088SDaniel Vetter 6856449b088SDaniel Vetter return ret; 6866449b088SDaniel Vetter } 6876449b088SDaniel Vetter 6886449b088SDaniel Vetter static void remove_compat_control_link(struct drm_device *dev) 6896449b088SDaniel Vetter { 6906449b088SDaniel Vetter struct drm_minor *minor; 6916449b088SDaniel Vetter char *name; 6926449b088SDaniel Vetter 6936449b088SDaniel Vetter if (!drm_core_check_feature(dev, DRIVER_MODESET)) 6946449b088SDaniel Vetter return; 6956449b088SDaniel Vetter 6966449b088SDaniel Vetter minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 6976449b088SDaniel Vetter if (!minor) 6986449b088SDaniel Vetter return; 6996449b088SDaniel Vetter 7006449b088SDaniel Vetter name = kasprintf(GFP_KERNEL, "controlD%d", minor->index); 7016449b088SDaniel Vetter if (!name) 7026449b088SDaniel Vetter return; 7036449b088SDaniel Vetter 7046449b088SDaniel Vetter sysfs_remove_link(minor->kdev->kobj.parent, name); 7056449b088SDaniel Vetter 7066449b088SDaniel Vetter kfree(name); 7076449b088SDaniel Vetter } 7086449b088SDaniel Vetter 70921d70354SDave Airlie /** 71021d70354SDave Airlie * drm_dev_register - Register DRM device 71121d70354SDave Airlie * @dev: Device to register 71221d70354SDave Airlie * @flags: Flags passed to the driver's .load() function 71321d70354SDave Airlie * 71421d70354SDave Airlie * Register the DRM device @dev with the system, advertise device to user-space 71521d70354SDave Airlie * and start normal device operation. @dev must be allocated via drm_dev_alloc() 716e28cd4d0SChris Wilson * previously. 71721d70354SDave Airlie * 71821d70354SDave Airlie * Never call this twice on any device! 71921d70354SDave Airlie * 7206e3f797cSDaniel Vetter * NOTE: To ensure backward compatibility with existing drivers method this 721ef40cbf9SDaniel Vetter * function calls the &drm_driver.load method after registering the device 722ef40cbf9SDaniel Vetter * nodes, creating race conditions. Usage of the &drm_driver.load methods is 723ef40cbf9SDaniel Vetter * therefore deprecated, drivers must perform all initialization before calling 7246e3f797cSDaniel Vetter * drm_dev_register(). 7256e3f797cSDaniel Vetter * 72621d70354SDave Airlie * RETURNS: 72721d70354SDave Airlie * 0 on success, negative error code on failure. 72821d70354SDave Airlie */ 72921d70354SDave Airlie int drm_dev_register(struct drm_device *dev, unsigned long flags) 73021d70354SDave Airlie { 73175f6dfe3SGabriel Krisman Bertazi struct drm_driver *driver = dev->driver; 73221d70354SDave Airlie int ret; 73321d70354SDave Airlie 73421d70354SDave Airlie mutex_lock(&drm_global_mutex); 73521d70354SDave Airlie 73621d70354SDave Airlie ret = drm_minor_register(dev, DRM_MINOR_CONTROL); 73721d70354SDave Airlie if (ret) 73821d70354SDave Airlie goto err_minors; 73921d70354SDave Airlie 74021d70354SDave Airlie ret = drm_minor_register(dev, DRM_MINOR_RENDER); 74121d70354SDave Airlie if (ret) 74221d70354SDave Airlie goto err_minors; 74321d70354SDave Airlie 744a3ccc461SDavid Herrmann ret = drm_minor_register(dev, DRM_MINOR_PRIMARY); 74521d70354SDave Airlie if (ret) 74621d70354SDave Airlie goto err_minors; 74721d70354SDave Airlie 7486449b088SDaniel Vetter ret = create_compat_control_link(dev); 7496449b088SDaniel Vetter if (ret) 7506449b088SDaniel Vetter goto err_minors; 7516449b088SDaniel Vetter 75221d70354SDave Airlie if (dev->driver->load) { 75321d70354SDave Airlie ret = dev->driver->load(dev, flags); 75421d70354SDave Airlie if (ret) 75521d70354SDave Airlie goto err_minors; 75621d70354SDave Airlie } 75721d70354SDave Airlie 758bee7fb15SChris Wilson if (drm_core_check_feature(dev, DRIVER_MODESET)) 75979190ea2SBenjamin Gaignard drm_modeset_register_all(dev); 760e28cd4d0SChris Wilson 76121d70354SDave Airlie ret = 0; 76275f6dfe3SGabriel Krisman Bertazi 76375f6dfe3SGabriel Krisman Bertazi DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", 76475f6dfe3SGabriel Krisman Bertazi driver->name, driver->major, driver->minor, 7656098909cSChris Wilson driver->patchlevel, driver->date, 7666098909cSChris Wilson dev->dev ? dev_name(dev->dev) : "virtual device", 76775f6dfe3SGabriel Krisman Bertazi dev->primary->index); 76875f6dfe3SGabriel Krisman Bertazi 76921d70354SDave Airlie goto out_unlock; 77021d70354SDave Airlie 77121d70354SDave Airlie err_minors: 7726449b088SDaniel Vetter remove_compat_control_link(dev); 773a3ccc461SDavid Herrmann drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 77421d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 77521d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_CONTROL); 77621d70354SDave Airlie out_unlock: 77721d70354SDave Airlie mutex_unlock(&drm_global_mutex); 77821d70354SDave Airlie return ret; 77921d70354SDave Airlie } 78021d70354SDave Airlie EXPORT_SYMBOL(drm_dev_register); 78121d70354SDave Airlie 78221d70354SDave Airlie /** 78321d70354SDave Airlie * drm_dev_unregister - Unregister DRM device 78421d70354SDave Airlie * @dev: Device to unregister 78521d70354SDave Airlie * 78621d70354SDave Airlie * Unregister the DRM device from the system. This does the reverse of 78721d70354SDave Airlie * drm_dev_register() but does not deallocate the device. The caller must call 78821d70354SDave Airlie * drm_dev_unref() to drop their final reference. 7896e3f797cSDaniel Vetter * 7906e3f797cSDaniel Vetter * This should be called first in the device teardown code to make sure 7916e3f797cSDaniel Vetter * userspace can't access the device instance any more. 79221d70354SDave Airlie */ 79321d70354SDave Airlie void drm_dev_unregister(struct drm_device *dev) 79421d70354SDave Airlie { 79521d70354SDave Airlie struct drm_map_list *r_list, *list_temp; 79621d70354SDave Airlie 79721d70354SDave Airlie drm_lastclose(dev); 79821d70354SDave Airlie 799bee7fb15SChris Wilson if (drm_core_check_feature(dev, DRIVER_MODESET)) 80079190ea2SBenjamin Gaignard drm_modeset_unregister_all(dev); 801e28cd4d0SChris Wilson 80221d70354SDave Airlie if (dev->driver->unload) 80321d70354SDave Airlie dev->driver->unload(dev); 80421d70354SDave Airlie 80521d70354SDave Airlie if (dev->agp) 80621d70354SDave Airlie drm_pci_agp_destroy(dev); 80721d70354SDave Airlie 80821d70354SDave Airlie drm_vblank_cleanup(dev); 80921d70354SDave Airlie 81021d70354SDave Airlie list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) 8119fc5cde7SDavid Herrmann drm_legacy_rmmap(dev, r_list->map); 81221d70354SDave Airlie 8136449b088SDaniel Vetter remove_compat_control_link(dev); 814a3ccc461SDavid Herrmann drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 81521d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 81621d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_CONTROL); 81721d70354SDave Airlie } 81821d70354SDave Airlie EXPORT_SYMBOL(drm_dev_unregister); 81921d70354SDave Airlie 820a6b5fac5SGerd Hoffmann /** 821a6b5fac5SGerd Hoffmann * drm_dev_set_unique - Set the unique name of a DRM device 822a6b5fac5SGerd Hoffmann * @dev: device of which to set the unique name 823a6b5fac5SGerd Hoffmann * @name: unique name 824a6b5fac5SGerd Hoffmann * 825a6b5fac5SGerd Hoffmann * Sets the unique name of a DRM device using the specified string. Drivers 826a6b5fac5SGerd Hoffmann * can use this at driver probe time if the unique name of the devices they 827a6b5fac5SGerd Hoffmann * drive is static. 828a6b5fac5SGerd Hoffmann * 829a6b5fac5SGerd Hoffmann * Return: 0 on success or a negative error code on failure. 830a6b5fac5SGerd Hoffmann */ 831a6b5fac5SGerd Hoffmann int drm_dev_set_unique(struct drm_device *dev, const char *name) 832a6b5fac5SGerd Hoffmann { 833a6b5fac5SGerd Hoffmann kfree(dev->unique); 834a6b5fac5SGerd Hoffmann dev->unique = kstrdup(name, GFP_KERNEL); 835a6b5fac5SGerd Hoffmann 836a6b5fac5SGerd Hoffmann return dev->unique ? 0 : -ENOMEM; 837a6b5fac5SGerd Hoffmann } 838a6b5fac5SGerd Hoffmann EXPORT_SYMBOL(drm_dev_set_unique); 839a6b5fac5SGerd Hoffmann 84021d70354SDave Airlie /* 84121d70354SDave Airlie * DRM Core 84221d70354SDave Airlie * The DRM core module initializes all global DRM objects and makes them 84321d70354SDave Airlie * available to drivers. Once setup, drivers can probe their respective 84421d70354SDave Airlie * devices. 84521d70354SDave Airlie * Currently, core management includes: 84621d70354SDave Airlie * - The "DRM-Global" key/value database 84721d70354SDave Airlie * - Global ID management for connectors 84821d70354SDave Airlie * - DRM major number allocation 84921d70354SDave Airlie * - DRM minor management 85021d70354SDave Airlie * - DRM sysfs class 85121d70354SDave Airlie * - DRM debugfs root 85221d70354SDave Airlie * 85321d70354SDave Airlie * Furthermore, the DRM core provides dynamic char-dev lookups. For each 85421d70354SDave Airlie * interface registered on a DRM device, you can request minor numbers from DRM 85521d70354SDave Airlie * core. DRM core takes care of major-number management and char-dev 85621d70354SDave Airlie * registration. A stub ->open() callback forwards any open() requests to the 85721d70354SDave Airlie * registered minor. 85821d70354SDave Airlie */ 85921d70354SDave Airlie 86021d70354SDave Airlie static int drm_stub_open(struct inode *inode, struct file *filp) 86121d70354SDave Airlie { 86221d70354SDave Airlie const struct file_operations *new_fops; 86321d70354SDave Airlie struct drm_minor *minor; 86421d70354SDave Airlie int err; 86521d70354SDave Airlie 86621d70354SDave Airlie DRM_DEBUG("\n"); 86721d70354SDave Airlie 86821d70354SDave Airlie mutex_lock(&drm_global_mutex); 86921d70354SDave Airlie minor = drm_minor_acquire(iminor(inode)); 87021d70354SDave Airlie if (IS_ERR(minor)) { 87121d70354SDave Airlie err = PTR_ERR(minor); 87221d70354SDave Airlie goto out_unlock; 87321d70354SDave Airlie } 87421d70354SDave Airlie 87521d70354SDave Airlie new_fops = fops_get(minor->dev->driver->fops); 87621d70354SDave Airlie if (!new_fops) { 87721d70354SDave Airlie err = -ENODEV; 87821d70354SDave Airlie goto out_release; 87921d70354SDave Airlie } 88021d70354SDave Airlie 88121d70354SDave Airlie replace_fops(filp, new_fops); 88221d70354SDave Airlie if (filp->f_op->open) 88321d70354SDave Airlie err = filp->f_op->open(inode, filp); 88421d70354SDave Airlie else 88521d70354SDave Airlie err = 0; 88621d70354SDave Airlie 88721d70354SDave Airlie out_release: 88821d70354SDave Airlie drm_minor_release(minor); 88921d70354SDave Airlie out_unlock: 89021d70354SDave Airlie mutex_unlock(&drm_global_mutex); 89121d70354SDave Airlie return err; 89221d70354SDave Airlie } 89321d70354SDave Airlie 89421d70354SDave Airlie static const struct file_operations drm_stub_fops = { 89521d70354SDave Airlie .owner = THIS_MODULE, 89621d70354SDave Airlie .open = drm_stub_open, 89721d70354SDave Airlie .llseek = noop_llseek, 89821d70354SDave Airlie }; 89921d70354SDave Airlie 9002cc107dcSDavid Herrmann static void drm_core_exit(void) 9012cc107dcSDavid Herrmann { 9022cc107dcSDavid Herrmann unregister_chrdev(DRM_MAJOR, "drm"); 9032cc107dcSDavid Herrmann debugfs_remove(drm_debugfs_root); 9042cc107dcSDavid Herrmann drm_sysfs_destroy(); 9052cc107dcSDavid Herrmann idr_destroy(&drm_minors_idr); 9062cc107dcSDavid Herrmann drm_connector_ida_destroy(); 9072cc107dcSDavid Herrmann drm_global_release(); 9082cc107dcSDavid Herrmann } 9092cc107dcSDavid Herrmann 91021d70354SDave Airlie static int __init drm_core_init(void) 91121d70354SDave Airlie { 9122cc107dcSDavid Herrmann int ret; 91321d70354SDave Airlie 91421d70354SDave Airlie drm_global_init(); 91521d70354SDave Airlie drm_connector_ida_init(); 91621d70354SDave Airlie idr_init(&drm_minors_idr); 91721d70354SDave Airlie 918fcc90213SDavid Herrmann ret = drm_sysfs_init(); 919fcc90213SDavid Herrmann if (ret < 0) { 9202cc107dcSDavid Herrmann DRM_ERROR("Cannot create DRM class: %d\n", ret); 9212cc107dcSDavid Herrmann goto error; 92221d70354SDave Airlie } 92321d70354SDave Airlie 92421d70354SDave Airlie drm_debugfs_root = debugfs_create_dir("dri", NULL); 92521d70354SDave Airlie if (!drm_debugfs_root) { 9262cc107dcSDavid Herrmann ret = -ENOMEM; 9272cc107dcSDavid Herrmann DRM_ERROR("Cannot create debugfs-root: %d\n", ret); 9282cc107dcSDavid Herrmann goto error; 92921d70354SDave Airlie } 93021d70354SDave Airlie 9312cc107dcSDavid Herrmann ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops); 9322cc107dcSDavid Herrmann if (ret < 0) 9332cc107dcSDavid Herrmann goto error; 9342cc107dcSDavid Herrmann 935e82dfa00SChris Wilson DRM_DEBUG("Initialized\n"); 93621d70354SDave Airlie return 0; 93721d70354SDave Airlie 9382cc107dcSDavid Herrmann error: 9392cc107dcSDavid Herrmann drm_core_exit(); 94021d70354SDave Airlie return ret; 94121d70354SDave Airlie } 94221d70354SDave Airlie 94321d70354SDave Airlie module_init(drm_core_init); 94421d70354SDave Airlie module_exit(drm_core_exit); 945