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