1 /* 2 * Created: Fri Jan 19 10:48:35 2001 by faith@acm.org 3 * 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 a 10 * copy of this software and associated documentation files (the "Software"), 11 * to deal in the Software without restriction, including without limitation 12 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 13 * and/or sell copies of the Software, and to permit persons to whom the 14 * Software is furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice (including the next 17 * paragraph) shall be included in all copies or substantial portions of the 18 * Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 23 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 24 * 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 OTHER 26 * DEALINGS IN THE SOFTWARE. 27 */ 28 29 #include <linux/bitops.h> 30 #include <linux/cgroup_dmem.h> 31 #include <linux/debugfs.h> 32 #include <linux/fs.h> 33 #include <linux/module.h> 34 #include <linux/moduleparam.h> 35 #include <linux/mount.h> 36 #include <linux/pseudo_fs.h> 37 #include <linux/slab.h> 38 #include <linux/sprintf.h> 39 #include <linux/srcu.h> 40 #include <linux/xarray.h> 41 42 #include <drm/drm_accel.h> 43 #include <drm/drm_bridge.h> 44 #include <drm/drm_cache.h> 45 #include <drm/drm_client_event.h> 46 #include <drm/drm_color_mgmt.h> 47 #include <drm/drm_drv.h> 48 #include <drm/drm_file.h> 49 #include <drm/drm_managed.h> 50 #include <drm/drm_mode_object.h> 51 #include <drm/drm_panic.h> 52 #include <drm/drm_print.h> 53 #include <drm/drm_privacy_screen_machine.h> 54 55 #include "drm_crtc_internal.h" 56 #include "drm_internal.h" 57 58 MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl"); 59 MODULE_DESCRIPTION("DRM shared core routines"); 60 MODULE_LICENSE("GPL and additional rights"); 61 62 DEFINE_XARRAY_ALLOC(drm_minors_xa); 63 64 /* 65 * If the drm core fails to init for whatever reason, 66 * we should prevent any drivers from registering with it. 67 * It's best to check this at drm_dev_init(), as some drivers 68 * prefer to embed struct drm_device into their own device 69 * structure and call drm_dev_init() themselves. 70 */ 71 static bool drm_core_init_complete; 72 73 static struct dentry *drm_debugfs_root; 74 75 DEFINE_STATIC_SRCU(drm_unplug_srcu); 76 77 /* 78 * DRM Minors 79 * A DRM device can provide several char-dev interfaces on the DRM-Major. Each 80 * of them is represented by a drm_minor object. Depending on the capabilities 81 * of the device-driver, different interfaces are registered. 82 * 83 * Minors can be accessed via dev->$minor_name. This pointer is either 84 * NULL or a valid drm_minor pointer and stays valid as long as the device is 85 * valid. This means, DRM minors have the same life-time as the underlying 86 * device. However, this doesn't mean that the minor is active. Minors are 87 * registered and unregistered dynamically according to device-state. 88 */ 89 90 static struct xarray *drm_minor_get_xa(enum drm_minor_type type) 91 { 92 if (type == DRM_MINOR_PRIMARY || type == DRM_MINOR_RENDER) 93 return &drm_minors_xa; 94 #if IS_ENABLED(CONFIG_DRM_ACCEL) 95 else if (type == DRM_MINOR_ACCEL) 96 return &accel_minors_xa; 97 #endif 98 else 99 return ERR_PTR(-EOPNOTSUPP); 100 } 101 102 static struct drm_minor **drm_minor_get_slot(struct drm_device *dev, 103 enum drm_minor_type type) 104 { 105 switch (type) { 106 case DRM_MINOR_PRIMARY: 107 return &dev->primary; 108 case DRM_MINOR_RENDER: 109 return &dev->render; 110 case DRM_MINOR_ACCEL: 111 return &dev->accel; 112 default: 113 BUG(); 114 } 115 } 116 117 static void drm_minor_alloc_release(struct drm_device *dev, void *data) 118 { 119 struct drm_minor *minor = data; 120 121 WARN_ON(dev != minor->dev); 122 123 put_device(minor->kdev); 124 125 xa_erase(drm_minor_get_xa(minor->type), minor->index); 126 } 127 128 /* 129 * DRM used to support 64 devices, for backwards compatibility we need to maintain the 130 * minor allocation scheme where minors 0-63 are primary nodes, 64-127 are control nodes, 131 * and 128-191 are render nodes. 132 * After reaching the limit, we're allocating minors dynamically - first-come, first-serve. 133 * Accel nodes are using a distinct major, so the minors are allocated in continuous 0-MAX 134 * range. 135 */ 136 #define DRM_MINOR_LIMIT(t) ({ \ 137 typeof(t) _t = (t); \ 138 _t == DRM_MINOR_ACCEL ? XA_LIMIT(0, ACCEL_MAX_MINORS) : XA_LIMIT(64 * _t, 64 * _t + 63); \ 139 }) 140 #define DRM_EXTENDED_MINOR_LIMIT XA_LIMIT(192, (1 << MINORBITS) - 1) 141 142 static int drm_minor_alloc(struct drm_device *dev, enum drm_minor_type type) 143 { 144 struct drm_minor *minor; 145 int r; 146 147 minor = drmm_kzalloc(dev, sizeof(*minor), GFP_KERNEL); 148 if (!minor) 149 return -ENOMEM; 150 151 minor->type = type; 152 minor->dev = dev; 153 154 r = xa_alloc(drm_minor_get_xa(type), &minor->index, 155 NULL, DRM_MINOR_LIMIT(type), GFP_KERNEL); 156 if (r == -EBUSY && (type == DRM_MINOR_PRIMARY || type == DRM_MINOR_RENDER)) 157 r = xa_alloc(&drm_minors_xa, &minor->index, 158 NULL, DRM_EXTENDED_MINOR_LIMIT, GFP_KERNEL); 159 if (r < 0) 160 return r; 161 162 r = drmm_add_action_or_reset(dev, drm_minor_alloc_release, minor); 163 if (r) 164 return r; 165 166 minor->kdev = drm_sysfs_minor_alloc(minor); 167 if (IS_ERR(minor->kdev)) 168 return PTR_ERR(minor->kdev); 169 170 *drm_minor_get_slot(dev, type) = minor; 171 return 0; 172 } 173 174 static int drm_minor_register(struct drm_device *dev, enum drm_minor_type type) 175 { 176 struct drm_minor *minor; 177 void *entry; 178 int ret; 179 180 DRM_DEBUG("\n"); 181 182 minor = *drm_minor_get_slot(dev, type); 183 if (!minor) 184 return 0; 185 186 if (minor->type != DRM_MINOR_ACCEL) { 187 ret = drm_debugfs_register(minor, minor->index, 188 drm_debugfs_root); 189 if (ret) { 190 DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n"); 191 goto err_debugfs; 192 } 193 } 194 195 ret = device_add(minor->kdev); 196 if (ret) 197 goto err_debugfs; 198 199 /* replace NULL with @minor so lookups will succeed from now on */ 200 entry = xa_store(drm_minor_get_xa(type), minor->index, minor, GFP_KERNEL); 201 if (xa_is_err(entry)) { 202 ret = xa_err(entry); 203 goto err_debugfs; 204 } 205 WARN_ON(entry); 206 207 DRM_DEBUG("new minor registered %d\n", minor->index); 208 return 0; 209 210 err_debugfs: 211 drm_debugfs_unregister(minor); 212 return ret; 213 } 214 215 static void drm_minor_unregister(struct drm_device *dev, enum drm_minor_type type) 216 { 217 struct drm_minor *minor; 218 219 minor = *drm_minor_get_slot(dev, type); 220 if (!minor || !device_is_registered(minor->kdev)) 221 return; 222 223 /* replace @minor with NULL so lookups will fail from now on */ 224 xa_store(drm_minor_get_xa(type), minor->index, NULL, GFP_KERNEL); 225 226 device_del(minor->kdev); 227 dev_set_drvdata(minor->kdev, NULL); /* safety belt */ 228 drm_debugfs_unregister(minor); 229 } 230 231 /* 232 * Looks up the given minor-ID and returns the respective DRM-minor object. The 233 * refence-count of the underlying device is increased so you must release this 234 * object with drm_minor_release(). 235 * 236 * As long as you hold this minor, it is guaranteed that the object and the 237 * minor->dev pointer will stay valid! However, the device may get unplugged and 238 * unregistered while you hold the minor. 239 */ 240 struct drm_minor *drm_minor_acquire(struct xarray *minor_xa, unsigned int minor_id) 241 { 242 struct drm_minor *minor; 243 244 xa_lock(minor_xa); 245 minor = xa_load(minor_xa, minor_id); 246 if (minor) 247 drm_dev_get(minor->dev); 248 xa_unlock(minor_xa); 249 250 if (!minor) { 251 return ERR_PTR(-ENODEV); 252 } else if (drm_dev_is_unplugged(minor->dev)) { 253 drm_dev_put(minor->dev); 254 return ERR_PTR(-ENODEV); 255 } 256 257 return minor; 258 } 259 260 void drm_minor_release(struct drm_minor *minor) 261 { 262 drm_dev_put(minor->dev); 263 } 264 265 /** 266 * DOC: driver instance overview 267 * 268 * A device instance for a drm driver is represented by &struct drm_device. This 269 * is allocated and initialized with devm_drm_dev_alloc(), usually from 270 * bus-specific ->probe() callbacks implemented by the driver. The driver then 271 * needs to initialize all the various subsystems for the drm device like memory 272 * management, vblank handling, modesetting support and initial output 273 * configuration plus obviously initialize all the corresponding hardware bits. 274 * Finally when everything is up and running and ready for userspace the device 275 * instance can be published using drm_dev_register(). 276 * 277 * There is also deprecated support for initializing device instances using 278 * bus-specific helpers and the &drm_driver.load callback. But due to 279 * backwards-compatibility needs the device instance have to be published too 280 * early, which requires unpretty global locking to make safe and is therefore 281 * only support for existing drivers not yet converted to the new scheme. 282 * 283 * When cleaning up a device instance everything needs to be done in reverse: 284 * First unpublish the device instance with drm_dev_unregister(). Then clean up 285 * any other resources allocated at device initialization and drop the driver's 286 * reference to &drm_device using drm_dev_put(). 287 * 288 * Note that any allocation or resource which is visible to userspace must be 289 * released only when the final drm_dev_put() is called, and not when the 290 * driver is unbound from the underlying physical struct &device. Best to use 291 * &drm_device managed resources with drmm_add_action(), drmm_kmalloc() and 292 * related functions. 293 * 294 * devres managed resources like devm_kmalloc() can only be used for resources 295 * directly related to the underlying hardware device, and only used in code 296 * paths fully protected by drm_dev_enter() and drm_dev_exit(). 297 * 298 * Display driver example 299 * ~~~~~~~~~~~~~~~~~~~~~~ 300 * 301 * The following example shows a typical structure of a DRM display driver. 302 * The example focus on the probe() function and the other functions that is 303 * almost always present and serves as a demonstration of devm_drm_dev_alloc(). 304 * 305 * .. code-block:: c 306 * 307 * struct driver_device { 308 * struct drm_device drm; 309 * void *userspace_facing; 310 * struct clk *pclk; 311 * }; 312 * 313 * static const struct drm_driver driver_drm_driver = { 314 * [...] 315 * }; 316 * 317 * static int driver_probe(struct platform_device *pdev) 318 * { 319 * struct driver_device *priv; 320 * struct drm_device *drm; 321 * int ret; 322 * 323 * priv = devm_drm_dev_alloc(&pdev->dev, &driver_drm_driver, 324 * struct driver_device, drm); 325 * if (IS_ERR(priv)) 326 * return PTR_ERR(priv); 327 * drm = &priv->drm; 328 * 329 * ret = drmm_mode_config_init(drm); 330 * if (ret) 331 * return ret; 332 * 333 * priv->userspace_facing = drmm_kzalloc(..., GFP_KERNEL); 334 * if (!priv->userspace_facing) 335 * return -ENOMEM; 336 * 337 * priv->pclk = devm_clk_get(dev, "PCLK"); 338 * if (IS_ERR(priv->pclk)) 339 * return PTR_ERR(priv->pclk); 340 * 341 * // Further setup, display pipeline etc 342 * 343 * platform_set_drvdata(pdev, drm); 344 * 345 * drm_mode_config_reset(drm); 346 * 347 * ret = drm_dev_register(drm); 348 * if (ret) 349 * return ret; 350 * 351 * drm_fbdev_{...}_setup(drm, 32); 352 * 353 * return 0; 354 * } 355 * 356 * // This function is called before the devm_ resources are released 357 * static int driver_remove(struct platform_device *pdev) 358 * { 359 * struct drm_device *drm = platform_get_drvdata(pdev); 360 * 361 * drm_dev_unregister(drm); 362 * drm_atomic_helper_shutdown(drm) 363 * 364 * return 0; 365 * } 366 * 367 * // This function is called on kernel restart and shutdown 368 * static void driver_shutdown(struct platform_device *pdev) 369 * { 370 * drm_atomic_helper_shutdown(platform_get_drvdata(pdev)); 371 * } 372 * 373 * static int __maybe_unused driver_pm_suspend(struct device *dev) 374 * { 375 * return drm_mode_config_helper_suspend(dev_get_drvdata(dev)); 376 * } 377 * 378 * static int __maybe_unused driver_pm_resume(struct device *dev) 379 * { 380 * drm_mode_config_helper_resume(dev_get_drvdata(dev)); 381 * 382 * return 0; 383 * } 384 * 385 * static const struct dev_pm_ops driver_pm_ops = { 386 * SET_SYSTEM_SLEEP_PM_OPS(driver_pm_suspend, driver_pm_resume) 387 * }; 388 * 389 * static struct platform_driver driver_driver = { 390 * .driver = { 391 * [...] 392 * .pm = &driver_pm_ops, 393 * }, 394 * .probe = driver_probe, 395 * .remove = driver_remove, 396 * .shutdown = driver_shutdown, 397 * }; 398 * module_platform_driver(driver_driver); 399 * 400 * Drivers that want to support device unplugging (USB, DT overlay unload) should 401 * use drm_dev_unplug() instead of drm_dev_unregister(). The driver must protect 402 * regions that is accessing device resources to prevent use after they're 403 * released. This is done using drm_dev_enter() and drm_dev_exit(). There is one 404 * shortcoming however, drm_dev_unplug() marks the drm_device as unplugged before 405 * drm_atomic_helper_shutdown() is called. This means that if the disable code 406 * paths are protected, they will not run on regular driver module unload, 407 * possibly leaving the hardware enabled. 408 */ 409 410 /** 411 * drm_put_dev - Unregister and release a DRM device 412 * @dev: DRM device 413 * 414 * Called at module unload time or when a PCI device is unplugged. 415 * 416 * Cleans up all DRM device, calling drm_lastclose(). 417 * 418 * Note: Use of this function is deprecated. It will eventually go away 419 * completely. Please use drm_dev_unregister() and drm_dev_put() explicitly 420 * instead to make sure that the device isn't userspace accessible any more 421 * while teardown is in progress, ensuring that userspace can't access an 422 * inconsistent state. 423 */ 424 void drm_put_dev(struct drm_device *dev) 425 { 426 DRM_DEBUG("\n"); 427 428 if (!dev) { 429 DRM_ERROR("cleanup called no dev\n"); 430 return; 431 } 432 433 drm_dev_unregister(dev); 434 drm_dev_put(dev); 435 } 436 EXPORT_SYMBOL(drm_put_dev); 437 438 /** 439 * drm_dev_enter - Enter device critical section 440 * @dev: DRM device 441 * @idx: Pointer to index that will be passed to the matching drm_dev_exit() 442 * 443 * This function marks and protects the beginning of a section that should not 444 * be entered after the device has been unplugged. The section end is marked 445 * with drm_dev_exit(). Calls to this function can be nested. 446 * 447 * Returns: 448 * True if it is OK to enter the section, false otherwise. 449 */ 450 bool drm_dev_enter(struct drm_device *dev, int *idx) 451 { 452 *idx = srcu_read_lock(&drm_unplug_srcu); 453 454 if (dev->unplugged) { 455 srcu_read_unlock(&drm_unplug_srcu, *idx); 456 return false; 457 } 458 459 return true; 460 } 461 EXPORT_SYMBOL(drm_dev_enter); 462 463 /** 464 * drm_dev_exit - Exit device critical section 465 * @idx: index returned from drm_dev_enter() 466 * 467 * This function marks the end of a section that should not be entered after 468 * the device has been unplugged. 469 */ 470 void drm_dev_exit(int idx) 471 { 472 srcu_read_unlock(&drm_unplug_srcu, idx); 473 } 474 EXPORT_SYMBOL(drm_dev_exit); 475 476 /** 477 * drm_dev_unplug - unplug a DRM device 478 * @dev: DRM device 479 * 480 * This unplugs a hotpluggable DRM device, which makes it inaccessible to 481 * userspace operations. Entry-points can use drm_dev_enter() and 482 * drm_dev_exit() to protect device resources in a race free manner. This 483 * essentially unregisters the device like drm_dev_unregister(), but can be 484 * called while there are still open users of @dev. 485 */ 486 void drm_dev_unplug(struct drm_device *dev) 487 { 488 /* 489 * After synchronizing any critical read section is guaranteed to see 490 * the new value of ->unplugged, and any critical section which might 491 * still have seen the old value of ->unplugged is guaranteed to have 492 * finished. 493 */ 494 dev->unplugged = true; 495 synchronize_srcu(&drm_unplug_srcu); 496 497 drm_dev_unregister(dev); 498 499 /* Clear all CPU mappings pointing to this device */ 500 unmap_mapping_range(dev->anon_inode->i_mapping, 0, 0, 1); 501 } 502 EXPORT_SYMBOL(drm_dev_unplug); 503 504 /** 505 * drm_dev_set_dma_dev - set the DMA device for a DRM device 506 * @dev: DRM device 507 * @dma_dev: DMA device or NULL 508 * 509 * Sets the DMA device of the given DRM device. Only required if 510 * the DMA device is different from the DRM device's parent. After 511 * calling this function, the DRM device holds a reference on 512 * @dma_dev. Pass NULL to clear the DMA device. 513 */ 514 void drm_dev_set_dma_dev(struct drm_device *dev, struct device *dma_dev) 515 { 516 dma_dev = get_device(dma_dev); 517 518 put_device(dev->dma_dev); 519 dev->dma_dev = dma_dev; 520 } 521 EXPORT_SYMBOL(drm_dev_set_dma_dev); 522 523 /* 524 * Available recovery methods for wedged device. To be sent along with device 525 * wedged uevent. 526 */ 527 static const char *drm_get_wedge_recovery(unsigned int opt) 528 { 529 switch (BIT(opt)) { 530 case DRM_WEDGE_RECOVERY_NONE: 531 return "none"; 532 case DRM_WEDGE_RECOVERY_REBIND: 533 return "rebind"; 534 case DRM_WEDGE_RECOVERY_BUS_RESET: 535 return "bus-reset"; 536 default: 537 return NULL; 538 } 539 } 540 541 /** 542 * drm_dev_wedged_event - generate a device wedged uevent 543 * @dev: DRM device 544 * @method: method(s) to be used for recovery 545 * 546 * This generates a device wedged uevent for the DRM device specified by @dev. 547 * Recovery @method\(s) of choice will be sent in the uevent environment as 548 * ``WEDGED=<method1>[,..,<methodN>]`` in order of less to more side-effects. 549 * If caller is unsure about recovery or @method is unknown (0), 550 * ``WEDGED=unknown`` will be sent instead. 551 * 552 * Refer to "Device Wedging" chapter in Documentation/gpu/drm-uapi.rst for more 553 * details. 554 * 555 * Returns: 0 on success, negative error code otherwise. 556 */ 557 int drm_dev_wedged_event(struct drm_device *dev, unsigned long method) 558 { 559 const char *recovery = NULL; 560 unsigned int len, opt; 561 /* Event string length up to 28+ characters with available methods */ 562 char event_string[32]; 563 char *envp[] = { event_string, NULL }; 564 565 len = scnprintf(event_string, sizeof(event_string), "%s", "WEDGED="); 566 567 for_each_set_bit(opt, &method, BITS_PER_TYPE(method)) { 568 recovery = drm_get_wedge_recovery(opt); 569 if (drm_WARN_ONCE(dev, !recovery, "invalid recovery method %u\n", opt)) 570 break; 571 572 len += scnprintf(event_string + len, sizeof(event_string), "%s,", recovery); 573 } 574 575 if (recovery) 576 /* Get rid of trailing comma */ 577 event_string[len - 1] = '\0'; 578 else 579 /* Caller is unsure about recovery, do the best we can at this point. */ 580 snprintf(event_string, sizeof(event_string), "%s", "WEDGED=unknown"); 581 582 drm_info(dev, "device wedged, %s\n", method == DRM_WEDGE_RECOVERY_NONE ? 583 "but recovered through reset" : "needs recovery"); 584 585 return kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp); 586 } 587 EXPORT_SYMBOL(drm_dev_wedged_event); 588 589 /* 590 * DRM internal mount 591 * We want to be able to allocate our own "struct address_space" to control 592 * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow 593 * stand-alone address_space objects, so we need an underlying inode. As there 594 * is no way to allocate an independent inode easily, we need a fake internal 595 * VFS mount-point. 596 * 597 * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free() 598 * frees it again. You are allowed to use iget() and iput() to get references to 599 * the inode. But each drm_fs_inode_new() call must be paired with exactly one 600 * drm_fs_inode_free() call (which does not have to be the last iput()). 601 * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it 602 * between multiple inode-users. You could, technically, call 603 * iget() + drm_fs_inode_free() directly after alloc and sometime later do an 604 * iput(), but this way you'd end up with a new vfsmount for each inode. 605 */ 606 607 static int drm_fs_cnt; 608 static struct vfsmount *drm_fs_mnt; 609 610 static int drm_fs_init_fs_context(struct fs_context *fc) 611 { 612 return init_pseudo(fc, 0x010203ff) ? 0 : -ENOMEM; 613 } 614 615 static struct file_system_type drm_fs_type = { 616 .name = "drm", 617 .owner = THIS_MODULE, 618 .init_fs_context = drm_fs_init_fs_context, 619 .kill_sb = kill_anon_super, 620 }; 621 622 static struct inode *drm_fs_inode_new(void) 623 { 624 struct inode *inode; 625 int r; 626 627 r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt); 628 if (r < 0) { 629 DRM_ERROR("Cannot mount pseudo fs: %d\n", r); 630 return ERR_PTR(r); 631 } 632 633 inode = alloc_anon_inode(drm_fs_mnt->mnt_sb); 634 if (IS_ERR(inode)) 635 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 636 637 return inode; 638 } 639 640 static void drm_fs_inode_free(struct inode *inode) 641 { 642 if (inode) { 643 iput(inode); 644 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 645 } 646 } 647 648 /** 649 * DOC: component helper usage recommendations 650 * 651 * DRM drivers that drive hardware where a logical device consists of a pile of 652 * independent hardware blocks are recommended to use the :ref:`component helper 653 * library<component>`. For consistency and better options for code reuse the 654 * following guidelines apply: 655 * 656 * - The entire device initialization procedure should be run from the 657 * &component_master_ops.master_bind callback, starting with 658 * devm_drm_dev_alloc(), then binding all components with 659 * component_bind_all() and finishing with drm_dev_register(). 660 * 661 * - The opaque pointer passed to all components through component_bind_all() 662 * should point at &struct drm_device of the device instance, not some driver 663 * specific private structure. 664 * 665 * - The component helper fills the niche where further standardization of 666 * interfaces is not practical. When there already is, or will be, a 667 * standardized interface like &drm_bridge or &drm_panel, providing its own 668 * functions to find such components at driver load time, like 669 * drm_of_find_panel_or_bridge(), then the component helper should not be 670 * used. 671 */ 672 673 static void drm_dev_init_release(struct drm_device *dev, void *res) 674 { 675 drm_fs_inode_free(dev->anon_inode); 676 677 put_device(dev->dma_dev); 678 dev->dma_dev = NULL; 679 put_device(dev->dev); 680 /* Prevent use-after-free in drm_managed_release when debugging is 681 * enabled. Slightly awkward, but can't really be helped. */ 682 dev->dev = NULL; 683 mutex_destroy(&dev->master_mutex); 684 mutex_destroy(&dev->clientlist_mutex); 685 mutex_destroy(&dev->filelist_mutex); 686 mutex_destroy(&dev->struct_mutex); 687 } 688 689 static int drm_dev_init(struct drm_device *dev, 690 const struct drm_driver *driver, 691 struct device *parent) 692 { 693 struct inode *inode; 694 int ret; 695 696 if (!drm_core_init_complete) { 697 DRM_ERROR("DRM core is not initialized\n"); 698 return -ENODEV; 699 } 700 701 if (WARN_ON(!parent)) 702 return -EINVAL; 703 704 kref_init(&dev->ref); 705 dev->dev = get_device(parent); 706 dev->driver = driver; 707 708 INIT_LIST_HEAD(&dev->managed.resources); 709 spin_lock_init(&dev->managed.lock); 710 711 /* no per-device feature limits by default */ 712 dev->driver_features = ~0u; 713 714 if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL) && 715 (drm_core_check_feature(dev, DRIVER_RENDER) || 716 drm_core_check_feature(dev, DRIVER_MODESET))) { 717 DRM_ERROR("DRM driver can't be both a compute acceleration and graphics driver\n"); 718 return -EINVAL; 719 } 720 721 INIT_LIST_HEAD(&dev->filelist); 722 INIT_LIST_HEAD(&dev->filelist_internal); 723 INIT_LIST_HEAD(&dev->clientlist); 724 INIT_LIST_HEAD(&dev->vblank_event_list); 725 726 spin_lock_init(&dev->event_lock); 727 mutex_init(&dev->struct_mutex); 728 mutex_init(&dev->filelist_mutex); 729 mutex_init(&dev->clientlist_mutex); 730 mutex_init(&dev->master_mutex); 731 raw_spin_lock_init(&dev->mode_config.panic_lock); 732 733 ret = drmm_add_action_or_reset(dev, drm_dev_init_release, NULL); 734 if (ret) 735 return ret; 736 737 inode = drm_fs_inode_new(); 738 if (IS_ERR(inode)) { 739 ret = PTR_ERR(inode); 740 DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret); 741 goto err; 742 } 743 744 dev->anon_inode = inode; 745 746 if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL)) { 747 ret = drm_minor_alloc(dev, DRM_MINOR_ACCEL); 748 if (ret) 749 goto err; 750 } else { 751 if (drm_core_check_feature(dev, DRIVER_RENDER)) { 752 ret = drm_minor_alloc(dev, DRM_MINOR_RENDER); 753 if (ret) 754 goto err; 755 } 756 757 ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY); 758 if (ret) 759 goto err; 760 } 761 762 if (drm_core_check_feature(dev, DRIVER_GEM)) { 763 ret = drm_gem_init(dev); 764 if (ret) { 765 DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n"); 766 goto err; 767 } 768 } 769 770 dev->unique = drmm_kstrdup(dev, dev_name(parent), GFP_KERNEL); 771 if (!dev->unique) { 772 ret = -ENOMEM; 773 goto err; 774 } 775 776 if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL)) 777 accel_debugfs_init(dev); 778 else 779 drm_debugfs_dev_init(dev, drm_debugfs_root); 780 781 return 0; 782 783 err: 784 drm_managed_release(dev); 785 786 return ret; 787 } 788 789 static void devm_drm_dev_init_release(void *data) 790 { 791 drm_dev_put(data); 792 } 793 794 static int devm_drm_dev_init(struct device *parent, 795 struct drm_device *dev, 796 const struct drm_driver *driver) 797 { 798 int ret; 799 800 ret = drm_dev_init(dev, driver, parent); 801 if (ret) 802 return ret; 803 804 return devm_add_action_or_reset(parent, 805 devm_drm_dev_init_release, dev); 806 } 807 808 void *__devm_drm_dev_alloc(struct device *parent, 809 const struct drm_driver *driver, 810 size_t size, size_t offset) 811 { 812 void *container; 813 struct drm_device *drm; 814 int ret; 815 816 container = kzalloc(size, GFP_KERNEL); 817 if (!container) 818 return ERR_PTR(-ENOMEM); 819 820 drm = container + offset; 821 ret = devm_drm_dev_init(parent, drm, driver); 822 if (ret) { 823 kfree(container); 824 return ERR_PTR(ret); 825 } 826 drmm_add_final_kfree(drm, container); 827 828 return container; 829 } 830 EXPORT_SYMBOL(__devm_drm_dev_alloc); 831 832 /** 833 * __drm_dev_alloc - Allocation of a &drm_device instance 834 * @parent: Parent device object 835 * @driver: DRM driver 836 * @size: the size of the struct which contains struct drm_device 837 * @offset: the offset of the &drm_device within the container. 838 * 839 * This should *NOT* be by any drivers, but is a dedicated interface for the 840 * corresponding Rust abstraction. 841 * 842 * This is the same as devm_drm_dev_alloc(), but without the corresponding 843 * resource management through the parent device, but not the same as 844 * drm_dev_alloc(), since the latter is the deprecated version, which does not 845 * support subclassing. 846 * 847 * Returns: A pointer to new DRM device, or an ERR_PTR on failure. 848 */ 849 void *__drm_dev_alloc(struct device *parent, 850 const struct drm_driver *driver, 851 size_t size, size_t offset) 852 { 853 void *container; 854 struct drm_device *drm; 855 int ret; 856 857 container = kzalloc(size, GFP_KERNEL); 858 if (!container) 859 return ERR_PTR(-ENOMEM); 860 861 drm = container + offset; 862 ret = drm_dev_init(drm, driver, parent); 863 if (ret) { 864 kfree(container); 865 return ERR_PTR(ret); 866 } 867 drmm_add_final_kfree(drm, container); 868 869 return container; 870 } 871 EXPORT_SYMBOL(__drm_dev_alloc); 872 873 /** 874 * drm_dev_alloc - Allocate new DRM device 875 * @driver: DRM driver to allocate device for 876 * @parent: Parent device object 877 * 878 * This is the deprecated version of devm_drm_dev_alloc(), which does not support 879 * subclassing through embedding the struct &drm_device in a driver private 880 * structure, and which does not support automatic cleanup through devres. 881 * 882 * RETURNS: 883 * Pointer to new DRM device, or ERR_PTR on failure. 884 */ 885 struct drm_device *drm_dev_alloc(const struct drm_driver *driver, 886 struct device *parent) 887 { 888 return __drm_dev_alloc(parent, driver, sizeof(struct drm_device), 0); 889 } 890 EXPORT_SYMBOL(drm_dev_alloc); 891 892 static void drm_dev_release(struct kref *ref) 893 { 894 struct drm_device *dev = container_of(ref, struct drm_device, ref); 895 896 /* Just in case register/unregister was never called */ 897 drm_debugfs_dev_fini(dev); 898 899 if (dev->driver->release) 900 dev->driver->release(dev); 901 902 drm_managed_release(dev); 903 904 kfree(dev->managed.final_kfree); 905 } 906 907 /** 908 * drm_dev_get - Take reference of a DRM device 909 * @dev: device to take reference of or NULL 910 * 911 * This increases the ref-count of @dev by one. You *must* already own a 912 * reference when calling this. Use drm_dev_put() to drop this reference 913 * again. 914 * 915 * This function never fails. However, this function does not provide *any* 916 * guarantee whether the device is alive or running. It only provides a 917 * reference to the object and the memory associated with it. 918 */ 919 void drm_dev_get(struct drm_device *dev) 920 { 921 if (dev) 922 kref_get(&dev->ref); 923 } 924 EXPORT_SYMBOL(drm_dev_get); 925 926 /** 927 * drm_dev_put - Drop reference of a DRM device 928 * @dev: device to drop reference of or NULL 929 * 930 * This decreases the ref-count of @dev by one. The device is destroyed if the 931 * ref-count drops to zero. 932 */ 933 void drm_dev_put(struct drm_device *dev) 934 { 935 if (dev) 936 kref_put(&dev->ref, drm_dev_release); 937 } 938 EXPORT_SYMBOL(drm_dev_put); 939 940 static void drmm_cg_unregister_region(struct drm_device *dev, void *arg) 941 { 942 dmem_cgroup_unregister_region(arg); 943 } 944 945 /** 946 * drmm_cgroup_register_region - Register a region of a DRM device to cgroups 947 * @dev: device for region 948 * @region_name: Region name for registering 949 * @size: Size of region in bytes 950 * 951 * This decreases the ref-count of @dev by one. The device is destroyed if the 952 * ref-count drops to zero. 953 */ 954 struct dmem_cgroup_region *drmm_cgroup_register_region(struct drm_device *dev, const char *region_name, u64 size) 955 { 956 struct dmem_cgroup_region *region; 957 int ret; 958 959 region = dmem_cgroup_register_region(size, "drm/%s/%s", dev->unique, region_name); 960 if (IS_ERR_OR_NULL(region)) 961 return region; 962 963 ret = drmm_add_action_or_reset(dev, drmm_cg_unregister_region, region); 964 if (ret) 965 return ERR_PTR(ret); 966 967 return region; 968 } 969 EXPORT_SYMBOL_GPL(drmm_cgroup_register_region); 970 971 static int create_compat_control_link(struct drm_device *dev) 972 { 973 struct drm_minor *minor; 974 char *name; 975 int ret; 976 977 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 978 return 0; 979 980 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 981 if (!minor) 982 return 0; 983 984 /* 985 * Some existing userspace out there uses the existing of the controlD* 986 * sysfs files to figure out whether it's a modeset driver. It only does 987 * readdir, hence a symlink is sufficient (and the least confusing 988 * option). Otherwise controlD* is entirely unused. 989 * 990 * Old controlD chardev have been allocated in the range 991 * 64-127. 992 */ 993 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 994 if (!name) 995 return -ENOMEM; 996 997 ret = sysfs_create_link(minor->kdev->kobj.parent, 998 &minor->kdev->kobj, 999 name); 1000 1001 kfree(name); 1002 1003 return ret; 1004 } 1005 1006 static void remove_compat_control_link(struct drm_device *dev) 1007 { 1008 struct drm_minor *minor; 1009 char *name; 1010 1011 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 1012 return; 1013 1014 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 1015 if (!minor) 1016 return; 1017 1018 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 1019 if (!name) 1020 return; 1021 1022 sysfs_remove_link(minor->kdev->kobj.parent, name); 1023 1024 kfree(name); 1025 } 1026 1027 /** 1028 * drm_dev_register - Register DRM device 1029 * @dev: Device to register 1030 * @flags: Flags passed to the driver's .load() function 1031 * 1032 * Register the DRM device @dev with the system, advertise device to user-space 1033 * and start normal device operation. @dev must be initialized via drm_dev_init() 1034 * previously. 1035 * 1036 * Never call this twice on any device! 1037 * 1038 * NOTE: To ensure backward compatibility with existing drivers method this 1039 * function calls the &drm_driver.load method after registering the device 1040 * nodes, creating race conditions. Usage of the &drm_driver.load methods is 1041 * therefore deprecated, drivers must perform all initialization before calling 1042 * drm_dev_register(). 1043 * 1044 * RETURNS: 1045 * 0 on success, negative error code on failure. 1046 */ 1047 int drm_dev_register(struct drm_device *dev, unsigned long flags) 1048 { 1049 const struct drm_driver *driver = dev->driver; 1050 int ret; 1051 1052 if (!driver->load) 1053 drm_mode_config_validate(dev); 1054 1055 WARN_ON(!dev->managed.final_kfree); 1056 1057 if (drm_dev_needs_global_mutex(dev)) 1058 mutex_lock(&drm_global_mutex); 1059 1060 if (drm_core_check_feature(dev, DRIVER_COMPUTE_ACCEL)) 1061 accel_debugfs_register(dev); 1062 else 1063 drm_debugfs_dev_register(dev); 1064 1065 ret = drm_minor_register(dev, DRM_MINOR_RENDER); 1066 if (ret) 1067 goto err_minors; 1068 1069 ret = drm_minor_register(dev, DRM_MINOR_PRIMARY); 1070 if (ret) 1071 goto err_minors; 1072 1073 ret = drm_minor_register(dev, DRM_MINOR_ACCEL); 1074 if (ret) 1075 goto err_minors; 1076 1077 ret = create_compat_control_link(dev); 1078 if (ret) 1079 goto err_minors; 1080 1081 dev->registered = true; 1082 1083 if (driver->load) { 1084 ret = driver->load(dev, flags); 1085 if (ret) 1086 goto err_minors; 1087 } 1088 1089 if (drm_core_check_feature(dev, DRIVER_MODESET)) { 1090 ret = drm_modeset_register_all(dev); 1091 if (ret) 1092 goto err_unload; 1093 } 1094 drm_panic_register(dev); 1095 1096 DRM_INFO("Initialized %s %d.%d.%d for %s on minor %d\n", 1097 driver->name, driver->major, driver->minor, 1098 driver->patchlevel, 1099 dev->dev ? dev_name(dev->dev) : "virtual device", 1100 dev->primary ? dev->primary->index : dev->accel->index); 1101 1102 goto out_unlock; 1103 1104 err_unload: 1105 if (dev->driver->unload) 1106 dev->driver->unload(dev); 1107 err_minors: 1108 remove_compat_control_link(dev); 1109 drm_minor_unregister(dev, DRM_MINOR_ACCEL); 1110 drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 1111 drm_minor_unregister(dev, DRM_MINOR_RENDER); 1112 out_unlock: 1113 if (drm_dev_needs_global_mutex(dev)) 1114 mutex_unlock(&drm_global_mutex); 1115 return ret; 1116 } 1117 EXPORT_SYMBOL(drm_dev_register); 1118 1119 /** 1120 * drm_dev_unregister - Unregister DRM device 1121 * @dev: Device to unregister 1122 * 1123 * Unregister the DRM device from the system. This does the reverse of 1124 * drm_dev_register() but does not deallocate the device. The caller must call 1125 * drm_dev_put() to drop their final reference, unless it is managed with devres 1126 * (as devices allocated with devm_drm_dev_alloc() are), in which case there is 1127 * already an unwind action registered. 1128 * 1129 * A special form of unregistering for hotpluggable devices is drm_dev_unplug(), 1130 * which can be called while there are still open users of @dev. 1131 * 1132 * This should be called first in the device teardown code to make sure 1133 * userspace can't access the device instance any more. 1134 */ 1135 void drm_dev_unregister(struct drm_device *dev) 1136 { 1137 dev->registered = false; 1138 1139 drm_panic_unregister(dev); 1140 1141 drm_client_dev_unregister(dev); 1142 1143 if (drm_core_check_feature(dev, DRIVER_MODESET)) 1144 drm_modeset_unregister_all(dev); 1145 1146 if (dev->driver->unload) 1147 dev->driver->unload(dev); 1148 1149 remove_compat_control_link(dev); 1150 drm_minor_unregister(dev, DRM_MINOR_ACCEL); 1151 drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 1152 drm_minor_unregister(dev, DRM_MINOR_RENDER); 1153 drm_debugfs_dev_fini(dev); 1154 } 1155 EXPORT_SYMBOL(drm_dev_unregister); 1156 1157 /* 1158 * DRM Core 1159 * The DRM core module initializes all global DRM objects and makes them 1160 * available to drivers. Once setup, drivers can probe their respective 1161 * devices. 1162 * Currently, core management includes: 1163 * - The "DRM-Global" key/value database 1164 * - Global ID management for connectors 1165 * - DRM major number allocation 1166 * - DRM minor management 1167 * - DRM sysfs class 1168 * - DRM debugfs root 1169 * 1170 * Furthermore, the DRM core provides dynamic char-dev lookups. For each 1171 * interface registered on a DRM device, you can request minor numbers from DRM 1172 * core. DRM core takes care of major-number management and char-dev 1173 * registration. A stub ->open() callback forwards any open() requests to the 1174 * registered minor. 1175 */ 1176 1177 static int drm_stub_open(struct inode *inode, struct file *filp) 1178 { 1179 const struct file_operations *new_fops; 1180 struct drm_minor *minor; 1181 int err; 1182 1183 DRM_DEBUG("\n"); 1184 1185 minor = drm_minor_acquire(&drm_minors_xa, iminor(inode)); 1186 if (IS_ERR(minor)) 1187 return PTR_ERR(minor); 1188 1189 new_fops = fops_get(minor->dev->driver->fops); 1190 if (!new_fops) { 1191 err = -ENODEV; 1192 goto out; 1193 } 1194 1195 replace_fops(filp, new_fops); 1196 if (filp->f_op->open) 1197 err = filp->f_op->open(inode, filp); 1198 else 1199 err = 0; 1200 1201 out: 1202 drm_minor_release(minor); 1203 1204 return err; 1205 } 1206 1207 static const struct file_operations drm_stub_fops = { 1208 .owner = THIS_MODULE, 1209 .open = drm_stub_open, 1210 .llseek = noop_llseek, 1211 }; 1212 1213 static void drm_core_exit(void) 1214 { 1215 drm_privacy_screen_lookup_exit(); 1216 drm_panic_exit(); 1217 accel_core_exit(); 1218 unregister_chrdev(DRM_MAJOR, "drm"); 1219 debugfs_remove(drm_debugfs_root); 1220 drm_sysfs_destroy(); 1221 WARN_ON(!xa_empty(&drm_minors_xa)); 1222 drm_connector_ida_destroy(); 1223 } 1224 1225 static int __init drm_core_init(void) 1226 { 1227 int ret; 1228 1229 drm_connector_ida_init(); 1230 drm_memcpy_init_early(); 1231 1232 ret = drm_sysfs_init(); 1233 if (ret < 0) { 1234 DRM_ERROR("Cannot create DRM class: %d\n", ret); 1235 goto error; 1236 } 1237 1238 drm_debugfs_root = debugfs_create_dir("dri", NULL); 1239 drm_bridge_debugfs_params(drm_debugfs_root); 1240 1241 ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops); 1242 if (ret < 0) 1243 goto error; 1244 1245 ret = accel_core_init(); 1246 if (ret < 0) 1247 goto error; 1248 1249 drm_panic_init(); 1250 1251 drm_privacy_screen_lookup_init(); 1252 1253 drm_core_init_complete = true; 1254 1255 DRM_DEBUG("Initialized\n"); 1256 return 0; 1257 1258 error: 1259 drm_core_exit(); 1260 return ret; 1261 } 1262 1263 module_init(drm_core_init); 1264 module_exit(drm_core_exit); 1265