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> 3521d70354SDave Airlie #include <drm/drmP.h> 3621d70354SDave Airlie #include <drm/drm_core.h> 3721d70354SDave Airlie #include "drm_legacy.h" 3821d70354SDave Airlie 3921d70354SDave Airlie unsigned int drm_debug = 0; /* 1 to enable debug output */ 4021d70354SDave Airlie EXPORT_SYMBOL(drm_debug); 4121d70354SDave Airlie 42*4ed0ce3dSVille Syrjälä int drm_vblank_offdelay = 5000; /* Default to 5000 msecs. */ 4321d70354SDave Airlie 4421d70354SDave Airlie unsigned int drm_timestamp_precision = 20; /* Default to 20 usecs. */ 4521d70354SDave Airlie 4621d70354SDave Airlie /* 4721d70354SDave Airlie * Default to use monotonic timestamps for wait-for-vblank and page-flip 4821d70354SDave Airlie * complete events. 4921d70354SDave Airlie */ 5021d70354SDave Airlie unsigned int drm_timestamp_monotonic = 1; 5121d70354SDave Airlie 5221d70354SDave Airlie MODULE_AUTHOR(CORE_AUTHOR); 5321d70354SDave Airlie MODULE_DESCRIPTION(CORE_DESC); 5421d70354SDave Airlie MODULE_LICENSE("GPL and additional rights"); 5521d70354SDave Airlie MODULE_PARM_DESC(debug, "Enable debug output"); 56*4ed0ce3dSVille Syrjälä MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs] (0: never disable, <0: disable immediately)"); 5721d70354SDave Airlie MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]"); 5821d70354SDave Airlie MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps"); 5921d70354SDave Airlie 6021d70354SDave Airlie module_param_named(debug, drm_debug, int, 0600); 6121d70354SDave Airlie module_param_named(vblankoffdelay, drm_vblank_offdelay, int, 0600); 6221d70354SDave Airlie module_param_named(timestamp_precision_usec, drm_timestamp_precision, int, 0600); 6321d70354SDave Airlie module_param_named(timestamp_monotonic, drm_timestamp_monotonic, int, 0600); 6421d70354SDave Airlie 6521d70354SDave Airlie static DEFINE_SPINLOCK(drm_minor_lock); 6621d70354SDave Airlie static struct idr drm_minors_idr; 6721d70354SDave Airlie 6821d70354SDave Airlie struct class *drm_class; 6921d70354SDave Airlie static struct dentry *drm_debugfs_root; 7021d70354SDave Airlie 7121d70354SDave Airlie int drm_err(const char *func, const char *format, ...) 7221d70354SDave Airlie { 7321d70354SDave Airlie struct va_format vaf; 7421d70354SDave Airlie va_list args; 7521d70354SDave Airlie int r; 7621d70354SDave Airlie 7721d70354SDave Airlie va_start(args, format); 7821d70354SDave Airlie 7921d70354SDave Airlie vaf.fmt = format; 8021d70354SDave Airlie vaf.va = &args; 8121d70354SDave Airlie 8221d70354SDave Airlie r = printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* %pV", func, &vaf); 8321d70354SDave Airlie 8421d70354SDave Airlie va_end(args); 8521d70354SDave Airlie 8621d70354SDave Airlie return r; 8721d70354SDave Airlie } 8821d70354SDave Airlie EXPORT_SYMBOL(drm_err); 8921d70354SDave Airlie 9021d70354SDave Airlie void drm_ut_debug_printk(const char *function_name, const char *format, ...) 9121d70354SDave Airlie { 9221d70354SDave Airlie struct va_format vaf; 9321d70354SDave Airlie va_list args; 9421d70354SDave Airlie 9521d70354SDave Airlie va_start(args, format); 9621d70354SDave Airlie vaf.fmt = format; 9721d70354SDave Airlie vaf.va = &args; 9821d70354SDave Airlie 9921d70354SDave Airlie printk(KERN_DEBUG "[" DRM_NAME ":%s] %pV", function_name, &vaf); 10021d70354SDave Airlie 10121d70354SDave Airlie va_end(args); 10221d70354SDave Airlie } 10321d70354SDave Airlie EXPORT_SYMBOL(drm_ut_debug_printk); 10421d70354SDave Airlie 10521d70354SDave Airlie struct drm_master *drm_master_create(struct drm_minor *minor) 10621d70354SDave Airlie { 10721d70354SDave Airlie struct drm_master *master; 10821d70354SDave Airlie 10921d70354SDave Airlie master = kzalloc(sizeof(*master), GFP_KERNEL); 11021d70354SDave Airlie if (!master) 11121d70354SDave Airlie return NULL; 11221d70354SDave Airlie 11321d70354SDave Airlie kref_init(&master->refcount); 11421d70354SDave Airlie spin_lock_init(&master->lock.spinlock); 11521d70354SDave Airlie init_waitqueue_head(&master->lock.lock_queue); 11621d70354SDave Airlie if (drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER)) { 11721d70354SDave Airlie kfree(master); 11821d70354SDave Airlie return NULL; 11921d70354SDave Airlie } 12021d70354SDave Airlie INIT_LIST_HEAD(&master->magicfree); 12121d70354SDave Airlie master->minor = minor; 12221d70354SDave Airlie 12321d70354SDave Airlie return master; 12421d70354SDave Airlie } 12521d70354SDave Airlie 12621d70354SDave Airlie struct drm_master *drm_master_get(struct drm_master *master) 12721d70354SDave Airlie { 12821d70354SDave Airlie kref_get(&master->refcount); 12921d70354SDave Airlie return master; 13021d70354SDave Airlie } 13121d70354SDave Airlie EXPORT_SYMBOL(drm_master_get); 13221d70354SDave Airlie 13321d70354SDave Airlie static void drm_master_destroy(struct kref *kref) 13421d70354SDave Airlie { 13521d70354SDave Airlie struct drm_master *master = container_of(kref, struct drm_master, refcount); 13621d70354SDave Airlie struct drm_magic_entry *pt, *next; 13721d70354SDave Airlie struct drm_device *dev = master->minor->dev; 13821d70354SDave Airlie struct drm_map_list *r_list, *list_temp; 13921d70354SDave Airlie 14021d70354SDave Airlie mutex_lock(&dev->struct_mutex); 14121d70354SDave Airlie if (dev->driver->master_destroy) 14221d70354SDave Airlie dev->driver->master_destroy(dev, master); 14321d70354SDave Airlie 14421d70354SDave Airlie list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) { 14521d70354SDave Airlie if (r_list->master == master) { 14621d70354SDave Airlie drm_rmmap_locked(dev, r_list->map); 14721d70354SDave Airlie r_list = NULL; 14821d70354SDave Airlie } 14921d70354SDave Airlie } 15021d70354SDave Airlie 15121d70354SDave Airlie if (master->unique) { 15221d70354SDave Airlie kfree(master->unique); 15321d70354SDave Airlie master->unique = NULL; 15421d70354SDave Airlie master->unique_len = 0; 15521d70354SDave Airlie } 15621d70354SDave Airlie 15721d70354SDave Airlie list_for_each_entry_safe(pt, next, &master->magicfree, head) { 15821d70354SDave Airlie list_del(&pt->head); 15921d70354SDave Airlie drm_ht_remove_item(&master->magiclist, &pt->hash_item); 16021d70354SDave Airlie kfree(pt); 16121d70354SDave Airlie } 16221d70354SDave Airlie 16321d70354SDave Airlie drm_ht_remove(&master->magiclist); 16421d70354SDave Airlie 16521d70354SDave Airlie mutex_unlock(&dev->struct_mutex); 16621d70354SDave Airlie kfree(master); 16721d70354SDave Airlie } 16821d70354SDave Airlie 16921d70354SDave Airlie void drm_master_put(struct drm_master **master) 17021d70354SDave Airlie { 17121d70354SDave Airlie kref_put(&(*master)->refcount, drm_master_destroy); 17221d70354SDave Airlie *master = NULL; 17321d70354SDave Airlie } 17421d70354SDave Airlie EXPORT_SYMBOL(drm_master_put); 17521d70354SDave Airlie 17621d70354SDave Airlie int drm_setmaster_ioctl(struct drm_device *dev, void *data, 17721d70354SDave Airlie struct drm_file *file_priv) 17821d70354SDave Airlie { 17921d70354SDave Airlie int ret = 0; 18021d70354SDave Airlie 18121d70354SDave Airlie mutex_lock(&dev->master_mutex); 18221d70354SDave Airlie if (drm_is_master(file_priv)) 18321d70354SDave Airlie goto out_unlock; 18421d70354SDave Airlie 18521d70354SDave Airlie if (file_priv->minor->master) { 18621d70354SDave Airlie ret = -EINVAL; 18721d70354SDave Airlie goto out_unlock; 18821d70354SDave Airlie } 18921d70354SDave Airlie 19021d70354SDave Airlie if (!file_priv->master) { 19121d70354SDave Airlie ret = -EINVAL; 19221d70354SDave Airlie goto out_unlock; 19321d70354SDave Airlie } 19421d70354SDave Airlie 19521d70354SDave Airlie file_priv->minor->master = drm_master_get(file_priv->master); 19621d70354SDave Airlie if (dev->driver->master_set) { 19721d70354SDave Airlie ret = dev->driver->master_set(dev, file_priv, false); 19821d70354SDave Airlie if (unlikely(ret != 0)) 19921d70354SDave Airlie drm_master_put(&file_priv->minor->master); 20021d70354SDave Airlie } 20121d70354SDave Airlie 20221d70354SDave Airlie out_unlock: 20321d70354SDave Airlie mutex_unlock(&dev->master_mutex); 20421d70354SDave Airlie return ret; 20521d70354SDave Airlie } 20621d70354SDave Airlie 20721d70354SDave Airlie int drm_dropmaster_ioctl(struct drm_device *dev, void *data, 20821d70354SDave Airlie struct drm_file *file_priv) 20921d70354SDave Airlie { 21021d70354SDave Airlie int ret = -EINVAL; 21121d70354SDave Airlie 21221d70354SDave Airlie mutex_lock(&dev->master_mutex); 21321d70354SDave Airlie if (!drm_is_master(file_priv)) 21421d70354SDave Airlie goto out_unlock; 21521d70354SDave Airlie 21621d70354SDave Airlie if (!file_priv->minor->master) 21721d70354SDave Airlie goto out_unlock; 21821d70354SDave Airlie 21921d70354SDave Airlie ret = 0; 22021d70354SDave Airlie if (dev->driver->master_drop) 22121d70354SDave Airlie dev->driver->master_drop(dev, file_priv, false); 22221d70354SDave Airlie drm_master_put(&file_priv->minor->master); 22321d70354SDave Airlie 22421d70354SDave Airlie out_unlock: 22521d70354SDave Airlie mutex_unlock(&dev->master_mutex); 22621d70354SDave Airlie return ret; 22721d70354SDave Airlie } 22821d70354SDave Airlie 22921d70354SDave Airlie /* 23021d70354SDave Airlie * DRM Minors 23121d70354SDave Airlie * A DRM device can provide several char-dev interfaces on the DRM-Major. Each 23221d70354SDave Airlie * of them is represented by a drm_minor object. Depending on the capabilities 23321d70354SDave Airlie * of the device-driver, different interfaces are registered. 23421d70354SDave Airlie * 23521d70354SDave Airlie * Minors can be accessed via dev->$minor_name. This pointer is either 23621d70354SDave Airlie * NULL or a valid drm_minor pointer and stays valid as long as the device is 23721d70354SDave Airlie * valid. This means, DRM minors have the same life-time as the underlying 23821d70354SDave Airlie * device. However, this doesn't mean that the minor is active. Minors are 23921d70354SDave Airlie * registered and unregistered dynamically according to device-state. 24021d70354SDave Airlie */ 24121d70354SDave Airlie 24221d70354SDave Airlie static struct drm_minor **drm_minor_get_slot(struct drm_device *dev, 24321d70354SDave Airlie unsigned int type) 24421d70354SDave Airlie { 24521d70354SDave Airlie switch (type) { 24621d70354SDave Airlie case DRM_MINOR_LEGACY: 24721d70354SDave Airlie return &dev->primary; 24821d70354SDave Airlie case DRM_MINOR_RENDER: 24921d70354SDave Airlie return &dev->render; 25021d70354SDave Airlie case DRM_MINOR_CONTROL: 25121d70354SDave Airlie return &dev->control; 25221d70354SDave Airlie default: 25321d70354SDave Airlie return NULL; 25421d70354SDave Airlie } 25521d70354SDave Airlie } 25621d70354SDave Airlie 25721d70354SDave Airlie static int drm_minor_alloc(struct drm_device *dev, unsigned int type) 25821d70354SDave Airlie { 25921d70354SDave Airlie struct drm_minor *minor; 26021d70354SDave Airlie unsigned long flags; 26121d70354SDave Airlie int r; 26221d70354SDave Airlie 26321d70354SDave Airlie minor = kzalloc(sizeof(*minor), GFP_KERNEL); 26421d70354SDave Airlie if (!minor) 26521d70354SDave Airlie return -ENOMEM; 26621d70354SDave Airlie 26721d70354SDave Airlie minor->type = type; 26821d70354SDave Airlie minor->dev = dev; 26921d70354SDave Airlie 27021d70354SDave Airlie idr_preload(GFP_KERNEL); 27121d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 27221d70354SDave Airlie r = idr_alloc(&drm_minors_idr, 27321d70354SDave Airlie NULL, 27421d70354SDave Airlie 64 * type, 27521d70354SDave Airlie 64 * (type + 1), 27621d70354SDave Airlie GFP_NOWAIT); 27721d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 27821d70354SDave Airlie idr_preload_end(); 27921d70354SDave Airlie 28021d70354SDave Airlie if (r < 0) 28121d70354SDave Airlie goto err_free; 28221d70354SDave Airlie 28321d70354SDave Airlie minor->index = r; 28421d70354SDave Airlie 28521d70354SDave Airlie minor->kdev = drm_sysfs_minor_alloc(minor); 28621d70354SDave Airlie if (IS_ERR(minor->kdev)) { 28721d70354SDave Airlie r = PTR_ERR(minor->kdev); 28821d70354SDave Airlie goto err_index; 28921d70354SDave Airlie } 29021d70354SDave Airlie 29121d70354SDave Airlie *drm_minor_get_slot(dev, type) = minor; 29221d70354SDave Airlie return 0; 29321d70354SDave Airlie 29421d70354SDave Airlie err_index: 29521d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 29621d70354SDave Airlie idr_remove(&drm_minors_idr, minor->index); 29721d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 29821d70354SDave Airlie err_free: 29921d70354SDave Airlie kfree(minor); 30021d70354SDave Airlie return r; 30121d70354SDave Airlie } 30221d70354SDave Airlie 30321d70354SDave Airlie static void drm_minor_free(struct drm_device *dev, unsigned int type) 30421d70354SDave Airlie { 30521d70354SDave Airlie struct drm_minor **slot, *minor; 30621d70354SDave Airlie unsigned long flags; 30721d70354SDave Airlie 30821d70354SDave Airlie slot = drm_minor_get_slot(dev, type); 30921d70354SDave Airlie minor = *slot; 31021d70354SDave Airlie if (!minor) 31121d70354SDave Airlie return; 31221d70354SDave Airlie 31321d70354SDave Airlie drm_mode_group_destroy(&minor->mode_group); 31421d70354SDave Airlie put_device(minor->kdev); 31521d70354SDave Airlie 31621d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 31721d70354SDave Airlie idr_remove(&drm_minors_idr, minor->index); 31821d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 31921d70354SDave Airlie 32021d70354SDave Airlie kfree(minor); 32121d70354SDave Airlie *slot = NULL; 32221d70354SDave Airlie } 32321d70354SDave Airlie 32421d70354SDave Airlie static int drm_minor_register(struct drm_device *dev, unsigned int type) 32521d70354SDave Airlie { 32621d70354SDave Airlie struct drm_minor *minor; 32721d70354SDave Airlie unsigned long flags; 32821d70354SDave Airlie int ret; 32921d70354SDave Airlie 33021d70354SDave Airlie DRM_DEBUG("\n"); 33121d70354SDave Airlie 33221d70354SDave Airlie minor = *drm_minor_get_slot(dev, type); 33321d70354SDave Airlie if (!minor) 33421d70354SDave Airlie return 0; 33521d70354SDave Airlie 33621d70354SDave Airlie ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root); 33721d70354SDave Airlie if (ret) { 33821d70354SDave Airlie DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n"); 33921d70354SDave Airlie return ret; 34021d70354SDave Airlie } 34121d70354SDave Airlie 34221d70354SDave Airlie ret = device_add(minor->kdev); 34321d70354SDave Airlie if (ret) 34421d70354SDave Airlie goto err_debugfs; 34521d70354SDave Airlie 34621d70354SDave Airlie /* replace NULL with @minor so lookups will succeed from now on */ 34721d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 34821d70354SDave Airlie idr_replace(&drm_minors_idr, minor, minor->index); 34921d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 35021d70354SDave Airlie 35121d70354SDave Airlie DRM_DEBUG("new minor registered %d\n", minor->index); 35221d70354SDave Airlie return 0; 35321d70354SDave Airlie 35421d70354SDave Airlie err_debugfs: 35521d70354SDave Airlie drm_debugfs_cleanup(minor); 35621d70354SDave Airlie return ret; 35721d70354SDave Airlie } 35821d70354SDave Airlie 35921d70354SDave Airlie static void drm_minor_unregister(struct drm_device *dev, unsigned int type) 36021d70354SDave Airlie { 36121d70354SDave Airlie struct drm_minor *minor; 36221d70354SDave Airlie unsigned long flags; 36321d70354SDave Airlie 36421d70354SDave Airlie minor = *drm_minor_get_slot(dev, type); 36521d70354SDave Airlie if (!minor || !device_is_registered(minor->kdev)) 36621d70354SDave Airlie return; 36721d70354SDave Airlie 36821d70354SDave Airlie /* replace @minor with NULL so lookups will fail from now on */ 36921d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 37021d70354SDave Airlie idr_replace(&drm_minors_idr, NULL, minor->index); 37121d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 37221d70354SDave Airlie 37321d70354SDave Airlie device_del(minor->kdev); 37421d70354SDave Airlie dev_set_drvdata(minor->kdev, NULL); /* safety belt */ 37521d70354SDave Airlie drm_debugfs_cleanup(minor); 37621d70354SDave Airlie } 37721d70354SDave Airlie 37821d70354SDave Airlie /** 37921d70354SDave Airlie * drm_minor_acquire - Acquire a DRM minor 38021d70354SDave Airlie * @minor_id: Minor ID of the DRM-minor 38121d70354SDave Airlie * 38221d70354SDave Airlie * Looks up the given minor-ID and returns the respective DRM-minor object. The 38321d70354SDave Airlie * refence-count of the underlying device is increased so you must release this 38421d70354SDave Airlie * object with drm_minor_release(). 38521d70354SDave Airlie * 38621d70354SDave Airlie * As long as you hold this minor, it is guaranteed that the object and the 38721d70354SDave Airlie * minor->dev pointer will stay valid! However, the device may get unplugged and 38821d70354SDave Airlie * unregistered while you hold the minor. 38921d70354SDave Airlie * 39021d70354SDave Airlie * Returns: 39121d70354SDave Airlie * Pointer to minor-object with increased device-refcount, or PTR_ERR on 39221d70354SDave Airlie * failure. 39321d70354SDave Airlie */ 39421d70354SDave Airlie struct drm_minor *drm_minor_acquire(unsigned int minor_id) 39521d70354SDave Airlie { 39621d70354SDave Airlie struct drm_minor *minor; 39721d70354SDave Airlie unsigned long flags; 39821d70354SDave Airlie 39921d70354SDave Airlie spin_lock_irqsave(&drm_minor_lock, flags); 40021d70354SDave Airlie minor = idr_find(&drm_minors_idr, minor_id); 40121d70354SDave Airlie if (minor) 40221d70354SDave Airlie drm_dev_ref(minor->dev); 40321d70354SDave Airlie spin_unlock_irqrestore(&drm_minor_lock, flags); 40421d70354SDave Airlie 40521d70354SDave Airlie if (!minor) { 40621d70354SDave Airlie return ERR_PTR(-ENODEV); 40721d70354SDave Airlie } else if (drm_device_is_unplugged(minor->dev)) { 40821d70354SDave Airlie drm_dev_unref(minor->dev); 40921d70354SDave Airlie return ERR_PTR(-ENODEV); 41021d70354SDave Airlie } 41121d70354SDave Airlie 41221d70354SDave Airlie return minor; 41321d70354SDave Airlie } 41421d70354SDave Airlie 41521d70354SDave Airlie /** 41621d70354SDave Airlie * drm_minor_release - Release DRM minor 41721d70354SDave Airlie * @minor: Pointer to DRM minor object 41821d70354SDave Airlie * 41921d70354SDave Airlie * Release a minor that was previously acquired via drm_minor_acquire(). 42021d70354SDave Airlie */ 42121d70354SDave Airlie void drm_minor_release(struct drm_minor *minor) 42221d70354SDave Airlie { 42321d70354SDave Airlie drm_dev_unref(minor->dev); 42421d70354SDave Airlie } 42521d70354SDave Airlie 42621d70354SDave Airlie /** 42721d70354SDave Airlie * drm_put_dev - Unregister and release a DRM device 42821d70354SDave Airlie * @dev: DRM device 42921d70354SDave Airlie * 43021d70354SDave Airlie * Called at module unload time or when a PCI device is unplugged. 43121d70354SDave Airlie * 43221d70354SDave Airlie * Use of this function is discouraged. It will eventually go away completely. 43321d70354SDave Airlie * Please use drm_dev_unregister() and drm_dev_unref() explicitly instead. 43421d70354SDave Airlie * 43521d70354SDave Airlie * Cleans up all DRM device, calling drm_lastclose(). 43621d70354SDave Airlie */ 43721d70354SDave Airlie void drm_put_dev(struct drm_device *dev) 43821d70354SDave Airlie { 43921d70354SDave Airlie DRM_DEBUG("\n"); 44021d70354SDave Airlie 44121d70354SDave Airlie if (!dev) { 44221d70354SDave Airlie DRM_ERROR("cleanup called no dev\n"); 44321d70354SDave Airlie return; 44421d70354SDave Airlie } 44521d70354SDave Airlie 44621d70354SDave Airlie drm_dev_unregister(dev); 44721d70354SDave Airlie drm_dev_unref(dev); 44821d70354SDave Airlie } 44921d70354SDave Airlie EXPORT_SYMBOL(drm_put_dev); 45021d70354SDave Airlie 45121d70354SDave Airlie void drm_unplug_dev(struct drm_device *dev) 45221d70354SDave Airlie { 45321d70354SDave Airlie /* for a USB device */ 45421d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_LEGACY); 45521d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 45621d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_CONTROL); 45721d70354SDave Airlie 45821d70354SDave Airlie mutex_lock(&drm_global_mutex); 45921d70354SDave Airlie 46021d70354SDave Airlie drm_device_set_unplugged(dev); 46121d70354SDave Airlie 46221d70354SDave Airlie if (dev->open_count == 0) { 46321d70354SDave Airlie drm_put_dev(dev); 46421d70354SDave Airlie } 46521d70354SDave Airlie mutex_unlock(&drm_global_mutex); 46621d70354SDave Airlie } 46721d70354SDave Airlie EXPORT_SYMBOL(drm_unplug_dev); 46821d70354SDave Airlie 46921d70354SDave Airlie /* 47021d70354SDave Airlie * DRM internal mount 47121d70354SDave Airlie * We want to be able to allocate our own "struct address_space" to control 47221d70354SDave Airlie * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow 47321d70354SDave Airlie * stand-alone address_space objects, so we need an underlying inode. As there 47421d70354SDave Airlie * is no way to allocate an independent inode easily, we need a fake internal 47521d70354SDave Airlie * VFS mount-point. 47621d70354SDave Airlie * 47721d70354SDave Airlie * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free() 47821d70354SDave Airlie * frees it again. You are allowed to use iget() and iput() to get references to 47921d70354SDave Airlie * the inode. But each drm_fs_inode_new() call must be paired with exactly one 48021d70354SDave Airlie * drm_fs_inode_free() call (which does not have to be the last iput()). 48121d70354SDave Airlie * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it 48221d70354SDave Airlie * between multiple inode-users. You could, technically, call 48321d70354SDave Airlie * iget() + drm_fs_inode_free() directly after alloc and sometime later do an 48421d70354SDave Airlie * iput(), but this way you'd end up with a new vfsmount for each inode. 48521d70354SDave Airlie */ 48621d70354SDave Airlie 48721d70354SDave Airlie static int drm_fs_cnt; 48821d70354SDave Airlie static struct vfsmount *drm_fs_mnt; 48921d70354SDave Airlie 49021d70354SDave Airlie static const struct dentry_operations drm_fs_dops = { 49121d70354SDave Airlie .d_dname = simple_dname, 49221d70354SDave Airlie }; 49321d70354SDave Airlie 49421d70354SDave Airlie static const struct super_operations drm_fs_sops = { 49521d70354SDave Airlie .statfs = simple_statfs, 49621d70354SDave Airlie }; 49721d70354SDave Airlie 49821d70354SDave Airlie static struct dentry *drm_fs_mount(struct file_system_type *fs_type, int flags, 49921d70354SDave Airlie const char *dev_name, void *data) 50021d70354SDave Airlie { 50121d70354SDave Airlie return mount_pseudo(fs_type, 50221d70354SDave Airlie "drm:", 50321d70354SDave Airlie &drm_fs_sops, 50421d70354SDave Airlie &drm_fs_dops, 50521d70354SDave Airlie 0x010203ff); 50621d70354SDave Airlie } 50721d70354SDave Airlie 50821d70354SDave Airlie static struct file_system_type drm_fs_type = { 50921d70354SDave Airlie .name = "drm", 51021d70354SDave Airlie .owner = THIS_MODULE, 51121d70354SDave Airlie .mount = drm_fs_mount, 51221d70354SDave Airlie .kill_sb = kill_anon_super, 51321d70354SDave Airlie }; 51421d70354SDave Airlie 51521d70354SDave Airlie static struct inode *drm_fs_inode_new(void) 51621d70354SDave Airlie { 51721d70354SDave Airlie struct inode *inode; 51821d70354SDave Airlie int r; 51921d70354SDave Airlie 52021d70354SDave Airlie r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt); 52121d70354SDave Airlie if (r < 0) { 52221d70354SDave Airlie DRM_ERROR("Cannot mount pseudo fs: %d\n", r); 52321d70354SDave Airlie return ERR_PTR(r); 52421d70354SDave Airlie } 52521d70354SDave Airlie 52621d70354SDave Airlie inode = alloc_anon_inode(drm_fs_mnt->mnt_sb); 52721d70354SDave Airlie if (IS_ERR(inode)) 52821d70354SDave Airlie simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 52921d70354SDave Airlie 53021d70354SDave Airlie return inode; 53121d70354SDave Airlie } 53221d70354SDave Airlie 53321d70354SDave Airlie static void drm_fs_inode_free(struct inode *inode) 53421d70354SDave Airlie { 53521d70354SDave Airlie if (inode) { 53621d70354SDave Airlie iput(inode); 53721d70354SDave Airlie simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 53821d70354SDave Airlie } 53921d70354SDave Airlie } 54021d70354SDave Airlie 54121d70354SDave Airlie /** 54221d70354SDave Airlie * drm_dev_alloc - Allocate new DRM device 54321d70354SDave Airlie * @driver: DRM driver to allocate device for 54421d70354SDave Airlie * @parent: Parent device object 54521d70354SDave Airlie * 54621d70354SDave Airlie * Allocate and initialize a new DRM device. No device registration is done. 54721d70354SDave Airlie * Call drm_dev_register() to advertice the device to user space and register it 54821d70354SDave Airlie * with other core subsystems. 54921d70354SDave Airlie * 55021d70354SDave Airlie * The initial ref-count of the object is 1. Use drm_dev_ref() and 55121d70354SDave Airlie * drm_dev_unref() to take and drop further ref-counts. 55221d70354SDave Airlie * 55321d70354SDave Airlie * RETURNS: 55421d70354SDave Airlie * Pointer to new DRM device, or NULL if out of memory. 55521d70354SDave Airlie */ 55621d70354SDave Airlie struct drm_device *drm_dev_alloc(struct drm_driver *driver, 55721d70354SDave Airlie struct device *parent) 55821d70354SDave Airlie { 55921d70354SDave Airlie struct drm_device *dev; 56021d70354SDave Airlie int ret; 56121d70354SDave Airlie 56221d70354SDave Airlie dev = kzalloc(sizeof(*dev), GFP_KERNEL); 56321d70354SDave Airlie if (!dev) 56421d70354SDave Airlie return NULL; 56521d70354SDave Airlie 56621d70354SDave Airlie kref_init(&dev->ref); 56721d70354SDave Airlie dev->dev = parent; 56821d70354SDave Airlie dev->driver = driver; 56921d70354SDave Airlie 57021d70354SDave Airlie INIT_LIST_HEAD(&dev->filelist); 57121d70354SDave Airlie INIT_LIST_HEAD(&dev->ctxlist); 57221d70354SDave Airlie INIT_LIST_HEAD(&dev->vmalist); 57321d70354SDave Airlie INIT_LIST_HEAD(&dev->maplist); 57421d70354SDave Airlie INIT_LIST_HEAD(&dev->vblank_event_list); 57521d70354SDave Airlie 57621d70354SDave Airlie spin_lock_init(&dev->buf_lock); 57721d70354SDave Airlie spin_lock_init(&dev->event_lock); 57821d70354SDave Airlie mutex_init(&dev->struct_mutex); 57921d70354SDave Airlie mutex_init(&dev->ctxlist_mutex); 58021d70354SDave Airlie mutex_init(&dev->master_mutex); 58121d70354SDave Airlie 58221d70354SDave Airlie dev->anon_inode = drm_fs_inode_new(); 58321d70354SDave Airlie if (IS_ERR(dev->anon_inode)) { 58421d70354SDave Airlie ret = PTR_ERR(dev->anon_inode); 58521d70354SDave Airlie DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret); 58621d70354SDave Airlie goto err_free; 58721d70354SDave Airlie } 58821d70354SDave Airlie 58921d70354SDave Airlie if (drm_core_check_feature(dev, DRIVER_MODESET)) { 59021d70354SDave Airlie ret = drm_minor_alloc(dev, DRM_MINOR_CONTROL); 59121d70354SDave Airlie if (ret) 59221d70354SDave Airlie goto err_minors; 59321d70354SDave Airlie } 59421d70354SDave Airlie 59521d70354SDave Airlie if (drm_core_check_feature(dev, DRIVER_RENDER)) { 59621d70354SDave Airlie ret = drm_minor_alloc(dev, DRM_MINOR_RENDER); 59721d70354SDave Airlie if (ret) 59821d70354SDave Airlie goto err_minors; 59921d70354SDave Airlie } 60021d70354SDave Airlie 60121d70354SDave Airlie ret = drm_minor_alloc(dev, DRM_MINOR_LEGACY); 60221d70354SDave Airlie if (ret) 60321d70354SDave Airlie goto err_minors; 60421d70354SDave Airlie 60521d70354SDave Airlie if (drm_ht_create(&dev->map_hash, 12)) 60621d70354SDave Airlie goto err_minors; 60721d70354SDave Airlie 60821d70354SDave Airlie ret = drm_legacy_ctxbitmap_init(dev); 60921d70354SDave Airlie if (ret) { 61021d70354SDave Airlie DRM_ERROR("Cannot allocate memory for context bitmap.\n"); 61121d70354SDave Airlie goto err_ht; 61221d70354SDave Airlie } 61321d70354SDave Airlie 61421d70354SDave Airlie if (driver->driver_features & DRIVER_GEM) { 61521d70354SDave Airlie ret = drm_gem_init(dev); 61621d70354SDave Airlie if (ret) { 61721d70354SDave Airlie DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n"); 61821d70354SDave Airlie goto err_ctxbitmap; 61921d70354SDave Airlie } 62021d70354SDave Airlie } 62121d70354SDave Airlie 62221d70354SDave Airlie return dev; 62321d70354SDave Airlie 62421d70354SDave Airlie err_ctxbitmap: 62521d70354SDave Airlie drm_legacy_ctxbitmap_cleanup(dev); 62621d70354SDave Airlie err_ht: 62721d70354SDave Airlie drm_ht_remove(&dev->map_hash); 62821d70354SDave Airlie err_minors: 62921d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_LEGACY); 63021d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_RENDER); 63121d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_CONTROL); 63221d70354SDave Airlie drm_fs_inode_free(dev->anon_inode); 63321d70354SDave Airlie err_free: 63421d70354SDave Airlie mutex_destroy(&dev->master_mutex); 63521d70354SDave Airlie kfree(dev); 63621d70354SDave Airlie return NULL; 63721d70354SDave Airlie } 63821d70354SDave Airlie EXPORT_SYMBOL(drm_dev_alloc); 63921d70354SDave Airlie 64021d70354SDave Airlie static void drm_dev_release(struct kref *ref) 64121d70354SDave Airlie { 64221d70354SDave Airlie struct drm_device *dev = container_of(ref, struct drm_device, ref); 64321d70354SDave Airlie 64421d70354SDave Airlie if (dev->driver->driver_features & DRIVER_GEM) 64521d70354SDave Airlie drm_gem_destroy(dev); 64621d70354SDave Airlie 64721d70354SDave Airlie drm_legacy_ctxbitmap_cleanup(dev); 64821d70354SDave Airlie drm_ht_remove(&dev->map_hash); 64921d70354SDave Airlie drm_fs_inode_free(dev->anon_inode); 65021d70354SDave Airlie 65121d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_LEGACY); 65221d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_RENDER); 65321d70354SDave Airlie drm_minor_free(dev, DRM_MINOR_CONTROL); 65421d70354SDave Airlie 65521d70354SDave Airlie mutex_destroy(&dev->master_mutex); 65621d70354SDave Airlie kfree(dev->unique); 65721d70354SDave Airlie kfree(dev); 65821d70354SDave Airlie } 65921d70354SDave Airlie 66021d70354SDave Airlie /** 66121d70354SDave Airlie * drm_dev_ref - Take reference of a DRM device 66221d70354SDave Airlie * @dev: device to take reference of or NULL 66321d70354SDave Airlie * 66421d70354SDave Airlie * This increases the ref-count of @dev by one. You *must* already own a 66521d70354SDave Airlie * reference when calling this. Use drm_dev_unref() to drop this reference 66621d70354SDave Airlie * again. 66721d70354SDave Airlie * 66821d70354SDave Airlie * This function never fails. However, this function does not provide *any* 66921d70354SDave Airlie * guarantee whether the device is alive or running. It only provides a 67021d70354SDave Airlie * reference to the object and the memory associated with it. 67121d70354SDave Airlie */ 67221d70354SDave Airlie void drm_dev_ref(struct drm_device *dev) 67321d70354SDave Airlie { 67421d70354SDave Airlie if (dev) 67521d70354SDave Airlie kref_get(&dev->ref); 67621d70354SDave Airlie } 67721d70354SDave Airlie EXPORT_SYMBOL(drm_dev_ref); 67821d70354SDave Airlie 67921d70354SDave Airlie /** 68021d70354SDave Airlie * drm_dev_unref - Drop reference of a DRM device 68121d70354SDave Airlie * @dev: device to drop reference of or NULL 68221d70354SDave Airlie * 68321d70354SDave Airlie * This decreases the ref-count of @dev by one. The device is destroyed if the 68421d70354SDave Airlie * ref-count drops to zero. 68521d70354SDave Airlie */ 68621d70354SDave Airlie void drm_dev_unref(struct drm_device *dev) 68721d70354SDave Airlie { 68821d70354SDave Airlie if (dev) 68921d70354SDave Airlie kref_put(&dev->ref, drm_dev_release); 69021d70354SDave Airlie } 69121d70354SDave Airlie EXPORT_SYMBOL(drm_dev_unref); 69221d70354SDave Airlie 69321d70354SDave Airlie /** 69421d70354SDave Airlie * drm_dev_register - Register DRM device 69521d70354SDave Airlie * @dev: Device to register 69621d70354SDave Airlie * @flags: Flags passed to the driver's .load() function 69721d70354SDave Airlie * 69821d70354SDave Airlie * Register the DRM device @dev with the system, advertise device to user-space 69921d70354SDave Airlie * and start normal device operation. @dev must be allocated via drm_dev_alloc() 70021d70354SDave Airlie * previously. 70121d70354SDave Airlie * 70221d70354SDave Airlie * Never call this twice on any device! 70321d70354SDave Airlie * 70421d70354SDave Airlie * RETURNS: 70521d70354SDave Airlie * 0 on success, negative error code on failure. 70621d70354SDave Airlie */ 70721d70354SDave Airlie int drm_dev_register(struct drm_device *dev, unsigned long flags) 70821d70354SDave Airlie { 70921d70354SDave Airlie int ret; 71021d70354SDave Airlie 71121d70354SDave Airlie mutex_lock(&drm_global_mutex); 71221d70354SDave Airlie 71321d70354SDave Airlie ret = drm_minor_register(dev, DRM_MINOR_CONTROL); 71421d70354SDave Airlie if (ret) 71521d70354SDave Airlie goto err_minors; 71621d70354SDave Airlie 71721d70354SDave Airlie ret = drm_minor_register(dev, DRM_MINOR_RENDER); 71821d70354SDave Airlie if (ret) 71921d70354SDave Airlie goto err_minors; 72021d70354SDave Airlie 72121d70354SDave Airlie ret = drm_minor_register(dev, DRM_MINOR_LEGACY); 72221d70354SDave Airlie if (ret) 72321d70354SDave Airlie goto err_minors; 72421d70354SDave Airlie 72521d70354SDave Airlie if (dev->driver->load) { 72621d70354SDave Airlie ret = dev->driver->load(dev, flags); 72721d70354SDave Airlie if (ret) 72821d70354SDave Airlie goto err_minors; 72921d70354SDave Airlie } 73021d70354SDave Airlie 73121d70354SDave Airlie /* setup grouping for legacy outputs */ 73221d70354SDave Airlie if (drm_core_check_feature(dev, DRIVER_MODESET)) { 73321d70354SDave Airlie ret = drm_mode_group_init_legacy_group(dev, 73421d70354SDave Airlie &dev->primary->mode_group); 73521d70354SDave Airlie if (ret) 73621d70354SDave Airlie goto err_unload; 73721d70354SDave Airlie } 73821d70354SDave Airlie 73921d70354SDave Airlie ret = 0; 74021d70354SDave Airlie goto out_unlock; 74121d70354SDave Airlie 74221d70354SDave Airlie err_unload: 74321d70354SDave Airlie if (dev->driver->unload) 74421d70354SDave Airlie dev->driver->unload(dev); 74521d70354SDave Airlie err_minors: 74621d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_LEGACY); 74721d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 74821d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_CONTROL); 74921d70354SDave Airlie out_unlock: 75021d70354SDave Airlie mutex_unlock(&drm_global_mutex); 75121d70354SDave Airlie return ret; 75221d70354SDave Airlie } 75321d70354SDave Airlie EXPORT_SYMBOL(drm_dev_register); 75421d70354SDave Airlie 75521d70354SDave Airlie /** 75621d70354SDave Airlie * drm_dev_unregister - Unregister DRM device 75721d70354SDave Airlie * @dev: Device to unregister 75821d70354SDave Airlie * 75921d70354SDave Airlie * Unregister the DRM device from the system. This does the reverse of 76021d70354SDave Airlie * drm_dev_register() but does not deallocate the device. The caller must call 76121d70354SDave Airlie * drm_dev_unref() to drop their final reference. 76221d70354SDave Airlie */ 76321d70354SDave Airlie void drm_dev_unregister(struct drm_device *dev) 76421d70354SDave Airlie { 76521d70354SDave Airlie struct drm_map_list *r_list, *list_temp; 76621d70354SDave Airlie 76721d70354SDave Airlie drm_lastclose(dev); 76821d70354SDave Airlie 76921d70354SDave Airlie if (dev->driver->unload) 77021d70354SDave Airlie dev->driver->unload(dev); 77121d70354SDave Airlie 77221d70354SDave Airlie if (dev->agp) 77321d70354SDave Airlie drm_pci_agp_destroy(dev); 77421d70354SDave Airlie 77521d70354SDave Airlie drm_vblank_cleanup(dev); 77621d70354SDave Airlie 77721d70354SDave Airlie list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) 77821d70354SDave Airlie drm_rmmap(dev, r_list->map); 77921d70354SDave Airlie 78021d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_LEGACY); 78121d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_RENDER); 78221d70354SDave Airlie drm_minor_unregister(dev, DRM_MINOR_CONTROL); 78321d70354SDave Airlie } 78421d70354SDave Airlie EXPORT_SYMBOL(drm_dev_unregister); 78521d70354SDave Airlie 78621d70354SDave Airlie /** 78721d70354SDave Airlie * drm_dev_set_unique - Set the unique name of a DRM device 78821d70354SDave Airlie * @dev: device of which to set the unique name 78921d70354SDave Airlie * @fmt: format string for unique name 79021d70354SDave Airlie * 79121d70354SDave Airlie * Sets the unique name of a DRM device using the specified format string and 79221d70354SDave Airlie * a variable list of arguments. Drivers can use this at driver probe time if 79321d70354SDave Airlie * the unique name of the devices they drive is static. 79421d70354SDave Airlie * 79521d70354SDave Airlie * Return: 0 on success or a negative error code on failure. 79621d70354SDave Airlie */ 79721d70354SDave Airlie int drm_dev_set_unique(struct drm_device *dev, const char *fmt, ...) 79821d70354SDave Airlie { 79921d70354SDave Airlie va_list ap; 80021d70354SDave Airlie 80121d70354SDave Airlie kfree(dev->unique); 80221d70354SDave Airlie 80321d70354SDave Airlie va_start(ap, fmt); 80421d70354SDave Airlie dev->unique = kvasprintf(GFP_KERNEL, fmt, ap); 80521d70354SDave Airlie va_end(ap); 80621d70354SDave Airlie 80721d70354SDave Airlie return dev->unique ? 0 : -ENOMEM; 80821d70354SDave Airlie } 80921d70354SDave Airlie EXPORT_SYMBOL(drm_dev_set_unique); 81021d70354SDave Airlie 81121d70354SDave Airlie /* 81221d70354SDave Airlie * DRM Core 81321d70354SDave Airlie * The DRM core module initializes all global DRM objects and makes them 81421d70354SDave Airlie * available to drivers. Once setup, drivers can probe their respective 81521d70354SDave Airlie * devices. 81621d70354SDave Airlie * Currently, core management includes: 81721d70354SDave Airlie * - The "DRM-Global" key/value database 81821d70354SDave Airlie * - Global ID management for connectors 81921d70354SDave Airlie * - DRM major number allocation 82021d70354SDave Airlie * - DRM minor management 82121d70354SDave Airlie * - DRM sysfs class 82221d70354SDave Airlie * - DRM debugfs root 82321d70354SDave Airlie * 82421d70354SDave Airlie * Furthermore, the DRM core provides dynamic char-dev lookups. For each 82521d70354SDave Airlie * interface registered on a DRM device, you can request minor numbers from DRM 82621d70354SDave Airlie * core. DRM core takes care of major-number management and char-dev 82721d70354SDave Airlie * registration. A stub ->open() callback forwards any open() requests to the 82821d70354SDave Airlie * registered minor. 82921d70354SDave Airlie */ 83021d70354SDave Airlie 83121d70354SDave Airlie static int drm_stub_open(struct inode *inode, struct file *filp) 83221d70354SDave Airlie { 83321d70354SDave Airlie const struct file_operations *new_fops; 83421d70354SDave Airlie struct drm_minor *minor; 83521d70354SDave Airlie int err; 83621d70354SDave Airlie 83721d70354SDave Airlie DRM_DEBUG("\n"); 83821d70354SDave Airlie 83921d70354SDave Airlie mutex_lock(&drm_global_mutex); 84021d70354SDave Airlie minor = drm_minor_acquire(iminor(inode)); 84121d70354SDave Airlie if (IS_ERR(minor)) { 84221d70354SDave Airlie err = PTR_ERR(minor); 84321d70354SDave Airlie goto out_unlock; 84421d70354SDave Airlie } 84521d70354SDave Airlie 84621d70354SDave Airlie new_fops = fops_get(minor->dev->driver->fops); 84721d70354SDave Airlie if (!new_fops) { 84821d70354SDave Airlie err = -ENODEV; 84921d70354SDave Airlie goto out_release; 85021d70354SDave Airlie } 85121d70354SDave Airlie 85221d70354SDave Airlie replace_fops(filp, new_fops); 85321d70354SDave Airlie if (filp->f_op->open) 85421d70354SDave Airlie err = filp->f_op->open(inode, filp); 85521d70354SDave Airlie else 85621d70354SDave Airlie err = 0; 85721d70354SDave Airlie 85821d70354SDave Airlie out_release: 85921d70354SDave Airlie drm_minor_release(minor); 86021d70354SDave Airlie out_unlock: 86121d70354SDave Airlie mutex_unlock(&drm_global_mutex); 86221d70354SDave Airlie return err; 86321d70354SDave Airlie } 86421d70354SDave Airlie 86521d70354SDave Airlie static const struct file_operations drm_stub_fops = { 86621d70354SDave Airlie .owner = THIS_MODULE, 86721d70354SDave Airlie .open = drm_stub_open, 86821d70354SDave Airlie .llseek = noop_llseek, 86921d70354SDave Airlie }; 87021d70354SDave Airlie 87121d70354SDave Airlie static int __init drm_core_init(void) 87221d70354SDave Airlie { 87321d70354SDave Airlie int ret = -ENOMEM; 87421d70354SDave Airlie 87521d70354SDave Airlie drm_global_init(); 87621d70354SDave Airlie drm_connector_ida_init(); 87721d70354SDave Airlie idr_init(&drm_minors_idr); 87821d70354SDave Airlie 87921d70354SDave Airlie if (register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops)) 88021d70354SDave Airlie goto err_p1; 88121d70354SDave Airlie 88221d70354SDave Airlie drm_class = drm_sysfs_create(THIS_MODULE, "drm"); 88321d70354SDave Airlie if (IS_ERR(drm_class)) { 88421d70354SDave Airlie printk(KERN_ERR "DRM: Error creating drm class.\n"); 88521d70354SDave Airlie ret = PTR_ERR(drm_class); 88621d70354SDave Airlie goto err_p2; 88721d70354SDave Airlie } 88821d70354SDave Airlie 88921d70354SDave Airlie drm_debugfs_root = debugfs_create_dir("dri", NULL); 89021d70354SDave Airlie if (!drm_debugfs_root) { 89121d70354SDave Airlie DRM_ERROR("Cannot create /sys/kernel/debug/dri\n"); 89221d70354SDave Airlie ret = -1; 89321d70354SDave Airlie goto err_p3; 89421d70354SDave Airlie } 89521d70354SDave Airlie 89621d70354SDave Airlie DRM_INFO("Initialized %s %d.%d.%d %s\n", 89721d70354SDave Airlie CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE); 89821d70354SDave Airlie return 0; 89921d70354SDave Airlie err_p3: 90021d70354SDave Airlie drm_sysfs_destroy(); 90121d70354SDave Airlie err_p2: 90221d70354SDave Airlie unregister_chrdev(DRM_MAJOR, "drm"); 90321d70354SDave Airlie 90421d70354SDave Airlie idr_destroy(&drm_minors_idr); 90521d70354SDave Airlie err_p1: 90621d70354SDave Airlie return ret; 90721d70354SDave Airlie } 90821d70354SDave Airlie 90921d70354SDave Airlie static void __exit drm_core_exit(void) 91021d70354SDave Airlie { 91121d70354SDave Airlie debugfs_remove(drm_debugfs_root); 91221d70354SDave Airlie drm_sysfs_destroy(); 91321d70354SDave Airlie 91421d70354SDave Airlie unregister_chrdev(DRM_MAJOR, "drm"); 91521d70354SDave Airlie 91621d70354SDave Airlie drm_connector_ida_destroy(); 91721d70354SDave Airlie idr_destroy(&drm_minors_idr); 91821d70354SDave Airlie } 91921d70354SDave Airlie 92021d70354SDave Airlie module_init(drm_core_init); 92121d70354SDave Airlie module_exit(drm_core_exit); 922