1116 lines · c
1/*2 * Created: Fri Jan 19 10:48:35 2001 by faith@acm.org3 *4 * Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California.5 * All Rights Reserved.6 *7 * Author Rickard E. (Rik) Faith <faith@valinux.com>8 *9 * Permission is hereby granted, free of charge, to any person obtaining a10 * copy of this software and associated documentation files (the "Software"),11 * to deal in the Software without restriction, including without limitation12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,13 * and/or sell copies of the Software, and to permit persons to whom the14 * Software is furnished to do so, subject to the following conditions:15 *16 * The above copyright notice and this permission notice (including the next17 * paragraph) shall be included in all copies or substantial portions of the18 * Software.19 *20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL23 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR24 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,25 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER26 * DEALINGS IN THE SOFTWARE.27 */28 29#include <linux/debugfs.h>30#include <linux/fs.h>31#include <linux/module.h>32#include <linux/moduleparam.h>33#include <linux/mount.h>34#include <linux/pseudo_fs.h>35#include <linux/slab.h>36#include <linux/srcu.h>37#include <linux/xarray.h>38 39#include <drm/drm_accel.h>40#include <drm/drm_cache.h>41#include <drm/drm_client.h>42#include <drm/drm_color_mgmt.h>43#include <drm/drm_drv.h>44#include <drm/drm_file.h>45#include <drm/drm_managed.h>46#include <drm/drm_mode_object.h>47#include <drm/drm_panic.h>48#include <drm/drm_print.h>49#include <drm/drm_privacy_screen_machine.h>50 51#include "drm_crtc_internal.h"52#include "drm_internal.h"53 54MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl");55MODULE_DESCRIPTION("DRM shared core routines");56MODULE_LICENSE("GPL and additional rights");57 58DEFINE_XARRAY_ALLOC(drm_minors_xa);59 60/*61 * If the drm core fails to init for whatever reason,62 * we should prevent any drivers from registering with it.63 * It's best to check this at drm_dev_init(), as some drivers64 * prefer to embed struct drm_device into their own device65 * structure and call drm_dev_init() themselves.66 */67static bool drm_core_init_complete;68 69static struct dentry *drm_debugfs_root;70 71DEFINE_STATIC_SRCU(drm_unplug_srcu);72 73/*74 * DRM Minors75 * A DRM device can provide several char-dev interfaces on the DRM-Major. Each76 * of them is represented by a drm_minor object. Depending on the capabilities77 * of the device-driver, different interfaces are registered.78 *79 * Minors can be accessed via dev->$minor_name. This pointer is either80 * NULL or a valid drm_minor pointer and stays valid as long as the device is81 * valid. This means, DRM minors have the same life-time as the underlying82 * device. However, this doesn't mean that the minor is active. Minors are83 * registered and unregistered dynamically according to device-state.84 */85 86static struct xarray *drm_minor_get_xa(enum drm_minor_type type)87{88 if (type == DRM_MINOR_PRIMARY || type == DRM_MINOR_RENDER)89 return &drm_minors_xa;90#if IS_ENABLED(CONFIG_DRM_ACCEL)91 else if (type == DRM_MINOR_ACCEL)92 return &accel_minors_xa;93#endif94 else95 return ERR_PTR(-EOPNOTSUPP);96}97 98static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,99 enum drm_minor_type type)100{101 switch (type) {102 case DRM_MINOR_PRIMARY:103 return &dev->primary;104 case DRM_MINOR_RENDER:105 return &dev->render;106 case DRM_MINOR_ACCEL:107 return &dev->accel;108 default:109 BUG();110 }111}112 113static void drm_minor_alloc_release(struct drm_device *dev, void *data)114{115 struct drm_minor *minor = data;116 117 WARN_ON(dev != minor->dev);118 119 put_device(minor->kdev);120 121 xa_erase(drm_minor_get_xa(minor->type), minor->index);122}123 124/*125 * DRM used to support 64 devices, for backwards compatibility we need to maintain the126 * minor allocation scheme where minors 0-63 are primary nodes, 64-127 are control nodes,127 * and 128-191 are render nodes.128 * After reaching the limit, we're allocating minors dynamically - first-come, first-serve.129 * Accel nodes are using a distinct major, so the minors are allocated in continuous 0-MAX130 * range.131 */132#define DRM_MINOR_LIMIT(t) ({ \133 typeof(t) _t = (t); \134 _t == DRM_MINOR_ACCEL ? XA_LIMIT(0, ACCEL_MAX_MINORS) : XA_LIMIT(64 * _t, 64 * _t + 63); \135})136#define DRM_EXTENDED_MINOR_LIMIT XA_LIMIT(192, (1 << MINORBITS) - 1)137 138static int drm_minor_alloc(struct drm_device *dev, enum drm_minor_type type)139{140 struct drm_minor *minor;141 int r;142 143 minor = drmm_kzalloc(dev, sizeof(*minor), GFP_KERNEL);144 if (!minor)145 return -ENOMEM;146 147 minor->type = type;148 minor->dev = dev;149 150 r = xa_alloc(drm_minor_get_xa(type), &minor->index,151 NULL, DRM_MINOR_LIMIT(type), GFP_KERNEL);152 if (r == -EBUSY && (type == DRM_MINOR_PRIMARY || type == DRM_MINOR_RENDER))153 r = xa_alloc(&drm_minors_xa, &minor->index,154 NULL, DRM_EXTENDED_MINOR_LIMIT, GFP_KERNEL);155 if (r < 0)156 return r;157 158 r = drmm_add_action_or_reset(dev, drm_minor_alloc_release, minor);159 if (r)160 return r;161 162 minor->kdev = drm_sysfs_minor_alloc(minor);163 if (IS_ERR(minor->kdev))164 return PTR_ERR(minor->kdev);165 166 *drm_minor_get_slot(dev, type) = minor;167 return 0;168}169 170static int drm_minor_register(struct drm_device *dev, enum drm_minor_type type)171{172 struct drm_minor *minor;173 void *entry;174 int ret;175 176 DRM_DEBUG("\n");177 178 minor = *drm_minor_get_slot(dev, type);179 if (!minor)180 return 0;181 182 if (minor->type != DRM_MINOR_ACCEL) {183 ret = drm_debugfs_register(minor, minor->index,184 drm_debugfs_root);185 if (ret) {186 DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");187 goto err_debugfs;188 }189 }190 191 ret = device_add(minor->kdev);192 if (ret)193 goto err_debugfs;194 195 /* replace NULL with @minor so lookups will succeed from now on */196 entry = xa_store(drm_minor_get_xa(type), minor->index, minor, GFP_KERNEL);197 if (xa_is_err(entry)) {198 ret = xa_err(entry);199 goto err_debugfs;200 }201 WARN_ON(entry);202 203 DRM_DEBUG("new minor registered %d\n", minor->index);204 return 0;205 206err_debugfs:207 drm_debugfs_unregister(minor);208 return ret;209}210 211static void drm_minor_unregister(struct drm_device *dev, enum drm_minor_type type)212{213 struct drm_minor *minor;214 215 minor = *drm_minor_get_slot(dev, type);216 if (!minor || !device_is_registered(minor->kdev))217 return;218 219 /* replace @minor with NULL so lookups will fail from now on */220 xa_store(drm_minor_get_xa(type), minor->index, NULL, GFP_KERNEL);221 222 device_del(minor->kdev);223 dev_set_drvdata(minor->kdev, NULL); /* safety belt */224 drm_debugfs_unregister(minor);225}226 227/*228 * Looks up the given minor-ID and returns the respective DRM-minor object. The229 * refence-count of the underlying device is increased so you must release this230 * object with drm_minor_release().231 *232 * As long as you hold this minor, it is guaranteed that the object and the233 * minor->dev pointer will stay valid! However, the device may get unplugged and234 * unregistered while you hold the minor.235 */236struct drm_minor *drm_minor_acquire(struct xarray *minor_xa, unsigned int minor_id)237{238 struct drm_minor *minor;239 240 xa_lock(minor_xa);241 minor = xa_load(minor_xa, minor_id);242 if (minor)243 drm_dev_get(minor->dev);244 xa_unlock(minor_xa);245 246 if (!minor) {247 return ERR_PTR(-ENODEV);248 } else if (drm_dev_is_unplugged(minor->dev)) {249 drm_dev_put(minor->dev);250 return ERR_PTR(-ENODEV);251 }252 253 return minor;254}255 256void drm_minor_release(struct drm_minor *minor)257{258 drm_dev_put(minor->dev);259}260 261/**262 * DOC: driver instance overview263 *264 * A device instance for a drm driver is represented by &struct drm_device. This265 * is allocated and initialized with devm_drm_dev_alloc(), usually from266 * bus-specific ->probe() callbacks implemented by the driver. The driver then267 * needs to initialize all the various subsystems for the drm device like memory268 * management, vblank handling, modesetting support and initial output269 * configuration plus obviously initialize all the corresponding hardware bits.270 * Finally when everything is up and running and ready for userspace the device271 * instance can be published using drm_dev_register().272 *273 * There is also deprecated support for initializing device instances using274 * bus-specific helpers and the &drm_driver.load callback. But due to275 * backwards-compatibility needs the device instance have to be published too276 * early, which requires unpretty global locking to make safe and is therefore277 * only support for existing drivers not yet converted to the new scheme.278 *279 * When cleaning up a device instance everything needs to be done in reverse:280 * First unpublish the device instance with drm_dev_unregister(). Then clean up281 * any other resources allocated at device initialization and drop the driver's282 * reference to &drm_device using drm_dev_put().283 *284 * Note that any allocation or resource which is visible to userspace must be285 * released only when the final drm_dev_put() is called, and not when the286 * driver is unbound from the underlying physical struct &device. Best to use287 * &drm_device managed resources with drmm_add_action(), drmm_kmalloc() and288 * related functions.289 *290 * devres managed resources like devm_kmalloc() can only be used for resources291 * directly related to the underlying hardware device, and only used in code292 * paths fully protected by drm_dev_enter() and drm_dev_exit().293 *294 * Display driver example295 * ~~~~~~~~~~~~~~~~~~~~~~296 *297 * The following example shows a typical structure of a DRM display driver.298 * The example focus on the probe() function and the other functions that is299 * almost always present and serves as a demonstration of devm_drm_dev_alloc().300 *301 * .. code-block:: c302 *303 * struct driver_device {304 * struct drm_device drm;305 * void *userspace_facing;306 * struct clk *pclk;307 * };308 *309 * static const struct drm_driver driver_drm_driver = {310 * [...]311 * };312 *313 * static int driver_probe(struct platform_device *pdev)314 * {315 * struct driver_device *priv;316 * struct drm_device *drm;317 * int ret;318 *319 * priv = devm_drm_dev_alloc(&pdev->dev, &driver_drm_driver,320 * struct driver_device, drm);321 * if (IS_ERR(priv))322 * return PTR_ERR(priv);323 * drm = &priv->drm;324 *325 * ret = drmm_mode_config_init(drm);326 * if (ret)327 * return ret;328 *329 * priv->userspace_facing = drmm_kzalloc(..., GFP_KERNEL);330 * if (!priv->userspace_facing)331 * return -ENOMEM;332 *333 * priv->pclk = devm_clk_get(dev, "PCLK");334 * if (IS_ERR(priv->pclk))335 * return PTR_ERR(priv->pclk);336 *337 * // Further setup, display pipeline etc338 *339 * platform_set_drvdata(pdev, drm);340 *341 * drm_mode_config_reset(drm);342 *343 * ret = drm_dev_register(drm);344 * if (ret)345 * return ret;346 *347 * drm_fbdev_{...}_setup(drm, 32);348 *349 * return 0;350 * }351 *352 * // This function is called before the devm_ resources are released353 * static int driver_remove(struct platform_device *pdev)354 * {355 * struct drm_device *drm = platform_get_drvdata(pdev);356 *357 * drm_dev_unregister(drm);358 * drm_atomic_helper_shutdown(drm)359 *360 * return 0;361 * }362 *363 * // This function is called on kernel restart and shutdown364 * static void driver_shutdown(struct platform_device *pdev)365 * {366 * drm_atomic_helper_shutdown(platform_get_drvdata(pdev));367 * }368 *369 * static int __maybe_unused driver_pm_suspend(struct device *dev)370 * {371 * return drm_mode_config_helper_suspend(dev_get_drvdata(dev));372 * }373 *374 * static int __maybe_unused driver_pm_resume(struct device *dev)375 * {376 * drm_mode_config_helper_resume(dev_get_drvdata(dev));377 *378 * return 0;379 * }380 *381 * static const struct dev_pm_ops driver_pm_ops = {382 * SET_SYSTEM_SLEEP_PM_OPS(driver_pm_suspend, driver_pm_resume)383 * };384 *385 * static struct platform_driver driver_driver = {386 * .driver = {387 * [...]388 * .pm = &driver_pm_ops,389 * },390 * .probe = driver_probe,391 * .remove = driver_remove,392 * .shutdown = driver_shutdown,393 * };394 * module_platform_driver(driver_driver);395 *396 * Drivers that want to support device unplugging (USB, DT overlay unload) should397 * use drm_dev_unplug() instead of drm_dev_unregister(). The driver must protect398 * regions that is accessing device resources to prevent use after they're399 * released. This is done using drm_dev_enter() and drm_dev_exit(). There is one400 * shortcoming however, drm_dev_unplug() marks the drm_device as unplugged before401 * drm_atomic_helper_shutdown() is called. This means that if the disable code402 * paths are protected, they will not run on regular driver module unload,403 * possibly leaving the hardware enabled.404 */405 406/**407 * drm_put_dev - Unregister and release a DRM device408 * @dev: DRM device409 *410 * Called at module unload time or when a PCI device is unplugged.411 *412 * Cleans up all DRM device, calling drm_lastclose().413 *414 * Note: Use of this function is deprecated. It will eventually go away415 * completely. Please use drm_dev_unregister() and drm_dev_put() explicitly416 * instead to make sure that the device isn't userspace accessible any more417 * while teardown is in progress, ensuring that userspace can't access an418 * inconsistent state.419 */420void drm_put_dev(struct drm_device *dev)421{422 DRM_DEBUG("\n");423 424 if (!dev) {425 DRM_ERROR("cleanup called no dev\n");426 return;427 }428 429 drm_dev_unregister(dev);430 drm_dev_put(dev);431}432EXPORT_SYMBOL(drm_put_dev);433 434/**435 * drm_dev_enter - Enter device critical section436 * @dev: DRM device437 * @idx: Pointer to index that will be passed to the matching drm_dev_exit()438 *439 * This function marks and protects the beginning of a section that should not440 * be entered after the device has been unplugged. The section end is marked441 * with drm_dev_exit(). Calls to this function can be nested.442 *443 * Returns:444 * True if it is OK to enter the section, false otherwise.445 */446bool drm_dev_enter(struct drm_device *dev, int *idx)447{448 *idx = srcu_read_lock(&drm_unplug_srcu);449 450 if (dev->unplugged) {451 srcu_read_unlock(&drm_unplug_srcu, *idx);452 return false;453 }454 455 return true;456}457EXPORT_SYMBOL(drm_dev_enter);458 459/**460 * drm_dev_exit - Exit device critical section461 * @idx: index returned from drm_dev_enter()462 *463 * This function marks the end of a section that should not be entered after464 * the device has been unplugged.465 */466void drm_dev_exit(int idx)467{468 srcu_read_unlock(&drm_unplug_srcu, idx);469}470EXPORT_SYMBOL(drm_dev_exit);471 472/**473 * drm_dev_unplug - unplug a DRM device474 * @dev: DRM device475 *476 * This unplugs a hotpluggable DRM device, which makes it inaccessible to477 * userspace operations. Entry-points can use drm_dev_enter() and478 * drm_dev_exit() to protect device resources in a race free manner. This479 * essentially unregisters the device like drm_dev_unregister(), but can be480 * called while there are still open users of @dev.481 */482void drm_dev_unplug(struct drm_device *dev)483{484 /*485 * After synchronizing any critical read section is guaranteed to see486 * the new value of ->unplugged, and any critical section which might487 * still have seen the old value of ->unplugged is guaranteed to have488 * finished.489 */490 dev->unplugged = true;491 synchronize_srcu(&drm_unplug_srcu);492 493 drm_dev_unregister(dev);494 495 /* Clear all CPU mappings pointing to this device */496 unmap_mapping_range(dev->anon_inode->i_mapping, 0, 0, 1);497}498EXPORT_SYMBOL(drm_dev_unplug);499 500/*501 * DRM internal mount502 * We want to be able to allocate our own "struct address_space" to control503 * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow504 * stand-alone address_space objects, so we need an underlying inode. As there505 * is no way to allocate an independent inode easily, we need a fake internal506 * VFS mount-point.507 *508 * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free()509 * frees it again. You are allowed to use iget() and iput() to get references to510 * the inode. But each drm_fs_inode_new() call must be paired with exactly one511 * drm_fs_inode_free() call (which does not have to be the last iput()).512 * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it513 * between multiple inode-users. You could, technically, call514 * iget() + drm_fs_inode_free() directly after alloc and sometime later do an515 * iput(), but this way you'd end up with a new vfsmount for each inode.516 */517 518static int drm_fs_cnt;519static struct vfsmount *drm_fs_mnt;520 521static int drm_fs_init_fs_context(struct fs_context *fc)522{523 return init_pseudo(fc, 0x010203ff) ? 0 : -ENOMEM;524}525 526static struct file_system_type drm_fs_type = {527 .name = "drm",528 .owner = THIS_MODULE,529 .init_fs_context = drm_fs_init_fs_context,530 .kill_sb = kill_anon_super,531};532 533static struct inode *drm_fs_inode_new(void)534{535 struct inode *inode;536 int r;537 538 r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt);539 if (r < 0) {540 DRM_ERROR("Cannot mount pseudo fs: %d\n", r);541 return ERR_PTR(r);542 }543 544 inode = alloc_anon_inode(drm_fs_mnt->mnt_sb);545 if (IS_ERR(inode))546 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);547 548 return inode;549}550 551static void drm_fs_inode_free(struct inode *inode)552{553 if (inode) {554 iput(inode);555 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);556 }557}558 559/**560 * DOC: component helper usage recommendations561 *562 * DRM drivers that drive hardware where a logical device consists of a pile of563 * independent hardware blocks are recommended to use the :ref:`component helper564 * library<component>`. For consistency and better options for code reuse the565 * following guidelines apply:566 *567 * - The entire device initialization procedure should be run from the568 * &component_master_ops.master_bind callback, starting with569 * devm_drm_dev_alloc(), then binding all components with570 * component_bind_all() and finishing with drm_dev_register().571 *572 * - The opaque pointer passed to all components through component_bind_all()573 * should point at &struct drm_device of the device instance, not some driver574 * specific private structure.575 *576 * - The component helper fills the niche where further standardization of577 * interfaces is not practical. When there already is, or will be, a578 * standardized interface like &drm_bridge or &drm_panel, providing its own579 * functions to find such components at driver load time, like580 * drm_of_find_panel_or_bridge(), then the component helper should not be581 * used.582 */583 584static void drm_dev_init_release(struct drm_device *dev, void *res)585{586 drm_fs_inode_free(dev->anon_inode);587 588 put_device(dev->dev);589 /* Prevent use-after-free in drm_managed_release when debugging is590 * enabled. Slightly awkward, but can't really be helped. */591 dev->dev = NULL;592 mutex_destroy(&dev->master_mutex);593 mutex_destroy(&dev->clientlist_mutex);594 mutex_destroy(&dev->filelist_mutex);595 mutex_destroy(&dev->struct_mutex);596}597 598static int drm_dev_init(struct drm_device *dev,599 const struct drm_driver *driver,600 struct device *parent)601{602 struct inode *inode;603 int ret;604 605 if (!drm_core_init_complete) {606 DRM_ERROR("DRM core is not initialized\n");607 return -ENODEV;608 }609 610 if (WARN_ON(!parent))611 return -EINVAL;612 613 kref_init(&dev->ref);614 dev->dev = get_device(parent);615 dev->driver = driver;616 617 INIT_LIST_HEAD(&dev->managed.resources);618 spin_lock_init(&dev->managed.lock);619 620 /* no per-device feature limits by default */621 dev->driver_features = ~0u;622 623 if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL) &&624 (drm_core_check_feature(dev, DRIVER_RENDER) ||625 drm_core_check_feature(dev, DRIVER_MODESET))) {626 DRM_ERROR("DRM driver can't be both a compute acceleration and graphics driver\n");627 return -EINVAL;628 }629 630 INIT_LIST_HEAD(&dev->filelist);631 INIT_LIST_HEAD(&dev->filelist_internal);632 INIT_LIST_HEAD(&dev->clientlist);633 INIT_LIST_HEAD(&dev->vblank_event_list);634 635 spin_lock_init(&dev->event_lock);636 mutex_init(&dev->struct_mutex);637 mutex_init(&dev->filelist_mutex);638 mutex_init(&dev->clientlist_mutex);639 mutex_init(&dev->master_mutex);640 raw_spin_lock_init(&dev->mode_config.panic_lock);641 642 ret = drmm_add_action_or_reset(dev, drm_dev_init_release, NULL);643 if (ret)644 return ret;645 646 inode = drm_fs_inode_new();647 if (IS_ERR(inode)) {648 ret = PTR_ERR(inode);649 DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret);650 goto err;651 }652 653 dev->anon_inode = inode;654 655 if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL)) {656 ret = drm_minor_alloc(dev, DRM_MINOR_ACCEL);657 if (ret)658 goto err;659 } else {660 if (drm_core_check_feature(dev, DRIVER_RENDER)) {661 ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);662 if (ret)663 goto err;664 }665 666 ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);667 if (ret)668 goto err;669 }670 671 if (drm_core_check_feature(dev, DRIVER_GEM)) {672 ret = drm_gem_init(dev);673 if (ret) {674 DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");675 goto err;676 }677 }678 679 dev->unique = drmm_kstrdup(dev, dev_name(parent), GFP_KERNEL);680 if (!dev->unique) {681 ret = -ENOMEM;682 goto err;683 }684 685 if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL))686 accel_debugfs_init(dev);687 else688 drm_debugfs_dev_init(dev, drm_debugfs_root);689 690 return 0;691 692err:693 drm_managed_release(dev);694 695 return ret;696}697 698static void devm_drm_dev_init_release(void *data)699{700 drm_dev_put(data);701}702 703static int devm_drm_dev_init(struct device *parent,704 struct drm_device *dev,705 const struct drm_driver *driver)706{707 int ret;708 709 ret = drm_dev_init(dev, driver, parent);710 if (ret)711 return ret;712 713 return devm_add_action_or_reset(parent,714 devm_drm_dev_init_release, dev);715}716 717void *__devm_drm_dev_alloc(struct device *parent,718 const struct drm_driver *driver,719 size_t size, size_t offset)720{721 void *container;722 struct drm_device *drm;723 int ret;724 725 container = kzalloc(size, GFP_KERNEL);726 if (!container)727 return ERR_PTR(-ENOMEM);728 729 drm = container + offset;730 ret = devm_drm_dev_init(parent, drm, driver);731 if (ret) {732 kfree(container);733 return ERR_PTR(ret);734 }735 drmm_add_final_kfree(drm, container);736 737 return container;738}739EXPORT_SYMBOL(__devm_drm_dev_alloc);740 741/**742 * drm_dev_alloc - Allocate new DRM device743 * @driver: DRM driver to allocate device for744 * @parent: Parent device object745 *746 * This is the deprecated version of devm_drm_dev_alloc(), which does not support747 * subclassing through embedding the struct &drm_device in a driver private748 * structure, and which does not support automatic cleanup through devres.749 *750 * RETURNS:751 * Pointer to new DRM device, or ERR_PTR on failure.752 */753struct drm_device *drm_dev_alloc(const struct drm_driver *driver,754 struct device *parent)755{756 struct drm_device *dev;757 int ret;758 759 dev = kzalloc(sizeof(*dev), GFP_KERNEL);760 if (!dev)761 return ERR_PTR(-ENOMEM);762 763 ret = drm_dev_init(dev, driver, parent);764 if (ret) {765 kfree(dev);766 return ERR_PTR(ret);767 }768 769 drmm_add_final_kfree(dev, dev);770 771 return dev;772}773EXPORT_SYMBOL(drm_dev_alloc);774 775static void drm_dev_release(struct kref *ref)776{777 struct drm_device *dev = container_of(ref, struct drm_device, ref);778 779 /* Just in case register/unregister was never called */780 drm_debugfs_dev_fini(dev);781 782 if (dev->driver->release)783 dev->driver->release(dev);784 785 drm_managed_release(dev);786 787 kfree(dev->managed.final_kfree);788}789 790/**791 * drm_dev_get - Take reference of a DRM device792 * @dev: device to take reference of or NULL793 *794 * This increases the ref-count of @dev by one. You *must* already own a795 * reference when calling this. Use drm_dev_put() to drop this reference796 * again.797 *798 * This function never fails. However, this function does not provide *any*799 * guarantee whether the device is alive or running. It only provides a800 * reference to the object and the memory associated with it.801 */802void drm_dev_get(struct drm_device *dev)803{804 if (dev)805 kref_get(&dev->ref);806}807EXPORT_SYMBOL(drm_dev_get);808 809/**810 * drm_dev_put - Drop reference of a DRM device811 * @dev: device to drop reference of or NULL812 *813 * This decreases the ref-count of @dev by one. The device is destroyed if the814 * ref-count drops to zero.815 */816void drm_dev_put(struct drm_device *dev)817{818 if (dev)819 kref_put(&dev->ref, drm_dev_release);820}821EXPORT_SYMBOL(drm_dev_put);822 823static int create_compat_control_link(struct drm_device *dev)824{825 struct drm_minor *minor;826 char *name;827 int ret;828 829 if (!drm_core_check_feature(dev, DRIVER_MODESET))830 return 0;831 832 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);833 if (!minor)834 return 0;835 836 /*837 * Some existing userspace out there uses the existing of the controlD*838 * sysfs files to figure out whether it's a modeset driver. It only does839 * readdir, hence a symlink is sufficient (and the least confusing840 * option). Otherwise controlD* is entirely unused.841 *842 * Old controlD chardev have been allocated in the range843 * 64-127.844 */845 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);846 if (!name)847 return -ENOMEM;848 849 ret = sysfs_create_link(minor->kdev->kobj.parent,850 &minor->kdev->kobj,851 name);852 853 kfree(name);854 855 return ret;856}857 858static void remove_compat_control_link(struct drm_device *dev)859{860 struct drm_minor *minor;861 char *name;862 863 if (!drm_core_check_feature(dev, DRIVER_MODESET))864 return;865 866 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);867 if (!minor)868 return;869 870 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);871 if (!name)872 return;873 874 sysfs_remove_link(minor->kdev->kobj.parent, name);875 876 kfree(name);877}878 879/**880 * drm_dev_register - Register DRM device881 * @dev: Device to register882 * @flags: Flags passed to the driver's .load() function883 *884 * Register the DRM device @dev with the system, advertise device to user-space885 * and start normal device operation. @dev must be initialized via drm_dev_init()886 * previously.887 *888 * Never call this twice on any device!889 *890 * NOTE: To ensure backward compatibility with existing drivers method this891 * function calls the &drm_driver.load method after registering the device892 * nodes, creating race conditions. Usage of the &drm_driver.load methods is893 * therefore deprecated, drivers must perform all initialization before calling894 * drm_dev_register().895 *896 * RETURNS:897 * 0 on success, negative error code on failure.898 */899int drm_dev_register(struct drm_device *dev, unsigned long flags)900{901 const struct drm_driver *driver = dev->driver;902 int ret;903 904 if (!driver->load)905 drm_mode_config_validate(dev);906 907 WARN_ON(!dev->managed.final_kfree);908 909 if (drm_dev_needs_global_mutex(dev))910 mutex_lock(&drm_global_mutex);911 912 if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL))913 accel_debugfs_register(dev);914 else915 drm_debugfs_dev_register(dev);916 917 ret = drm_minor_register(dev, DRM_MINOR_RENDER);918 if (ret)919 goto err_minors;920 921 ret = drm_minor_register(dev, DRM_MINOR_PRIMARY);922 if (ret)923 goto err_minors;924 925 ret = drm_minor_register(dev, DRM_MINOR_ACCEL);926 if (ret)927 goto err_minors;928 929 ret = create_compat_control_link(dev);930 if (ret)931 goto err_minors;932 933 dev->registered = true;934 935 if (driver->load) {936 ret = driver->load(dev, flags);937 if (ret)938 goto err_minors;939 }940 941 if (drm_core_check_feature(dev, DRIVER_MODESET)) {942 ret = drm_modeset_register_all(dev);943 if (ret)944 goto err_unload;945 }946 drm_panic_register(dev);947 948 DRM_INFO("Initialized %s %d.%d.%d for %s on minor %d\n",949 driver->name, driver->major, driver->minor,950 driver->patchlevel,951 dev->dev ? dev_name(dev->dev) : "virtual device",952 dev->primary ? dev->primary->index : dev->accel->index);953 954 goto out_unlock;955 956err_unload:957 if (dev->driver->unload)958 dev->driver->unload(dev);959err_minors:960 remove_compat_control_link(dev);961 drm_minor_unregister(dev, DRM_MINOR_ACCEL);962 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);963 drm_minor_unregister(dev, DRM_MINOR_RENDER);964out_unlock:965 if (drm_dev_needs_global_mutex(dev))966 mutex_unlock(&drm_global_mutex);967 return ret;968}969EXPORT_SYMBOL(drm_dev_register);970 971/**972 * drm_dev_unregister - Unregister DRM device973 * @dev: Device to unregister974 *975 * Unregister the DRM device from the system. This does the reverse of976 * drm_dev_register() but does not deallocate the device. The caller must call977 * drm_dev_put() to drop their final reference, unless it is managed with devres978 * (as devices allocated with devm_drm_dev_alloc() are), in which case there is979 * already an unwind action registered.980 *981 * A special form of unregistering for hotpluggable devices is drm_dev_unplug(),982 * which can be called while there are still open users of @dev.983 *984 * This should be called first in the device teardown code to make sure985 * userspace can't access the device instance any more.986 */987void drm_dev_unregister(struct drm_device *dev)988{989 dev->registered = false;990 991 drm_panic_unregister(dev);992 993 drm_client_dev_unregister(dev);994 995 if (drm_core_check_feature(dev, DRIVER_MODESET))996 drm_modeset_unregister_all(dev);997 998 if (dev->driver->unload)999 dev->driver->unload(dev);1000 1001 remove_compat_control_link(dev);1002 drm_minor_unregister(dev, DRM_MINOR_ACCEL);1003 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);1004 drm_minor_unregister(dev, DRM_MINOR_RENDER);1005 drm_debugfs_dev_fini(dev);1006}1007EXPORT_SYMBOL(drm_dev_unregister);1008 1009/*1010 * DRM Core1011 * The DRM core module initializes all global DRM objects and makes them1012 * available to drivers. Once setup, drivers can probe their respective1013 * devices.1014 * Currently, core management includes:1015 * - The "DRM-Global" key/value database1016 * - Global ID management for connectors1017 * - DRM major number allocation1018 * - DRM minor management1019 * - DRM sysfs class1020 * - DRM debugfs root1021 *1022 * Furthermore, the DRM core provides dynamic char-dev lookups. For each1023 * interface registered on a DRM device, you can request minor numbers from DRM1024 * core. DRM core takes care of major-number management and char-dev1025 * registration. A stub ->open() callback forwards any open() requests to the1026 * registered minor.1027 */1028 1029static int drm_stub_open(struct inode *inode, struct file *filp)1030{1031 const struct file_operations *new_fops;1032 struct drm_minor *minor;1033 int err;1034 1035 DRM_DEBUG("\n");1036 1037 minor = drm_minor_acquire(&drm_minors_xa, iminor(inode));1038 if (IS_ERR(minor))1039 return PTR_ERR(minor);1040 1041 new_fops = fops_get(minor->dev->driver->fops);1042 if (!new_fops) {1043 err = -ENODEV;1044 goto out;1045 }1046 1047 replace_fops(filp, new_fops);1048 if (filp->f_op->open)1049 err = filp->f_op->open(inode, filp);1050 else1051 err = 0;1052 1053out:1054 drm_minor_release(minor);1055 1056 return err;1057}1058 1059static const struct file_operations drm_stub_fops = {1060 .owner = THIS_MODULE,1061 .open = drm_stub_open,1062 .llseek = noop_llseek,1063};1064 1065static void drm_core_exit(void)1066{1067 drm_privacy_screen_lookup_exit();1068 drm_panic_exit();1069 accel_core_exit();1070 unregister_chrdev(DRM_MAJOR, "drm");1071 debugfs_remove(drm_debugfs_root);1072 drm_sysfs_destroy();1073 WARN_ON(!xa_empty(&drm_minors_xa));1074 drm_connector_ida_destroy();1075}1076 1077static int __init drm_core_init(void)1078{1079 int ret;1080 1081 drm_connector_ida_init();1082 drm_memcpy_init_early();1083 1084 ret = drm_sysfs_init();1085 if (ret < 0) {1086 DRM_ERROR("Cannot create DRM class: %d\n", ret);1087 goto error;1088 }1089 1090 drm_debugfs_root = debugfs_create_dir("dri", NULL);1091 1092 ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops);1093 if (ret < 0)1094 goto error;1095 1096 ret = accel_core_init();1097 if (ret < 0)1098 goto error;1099 1100 drm_panic_init();1101 1102 drm_privacy_screen_lookup_init();1103 1104 drm_core_init_complete = true;1105 1106 DRM_DEBUG("Initialized\n");1107 return 0;1108 1109error:1110 drm_core_exit();1111 return ret;1112}1113 1114module_init(drm_core_init);1115module_exit(drm_core_exit);1116