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/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/slab.h> 35 #include <linux/srcu.h> 36 37 #include <drm/drm_drv.h> 38 #include <drm/drmP.h> 39 40 #include "drm_crtc_internal.h" 41 #include "drm_legacy.h" 42 #include "drm_internal.h" 43 #include "drm_crtc_internal.h" 44 45 /* 46 * drm_debug: Enable debug output. 47 * Bitmask of DRM_UT_x. See include/drm/drmP.h for details. 48 */ 49 unsigned int drm_debug = 0; 50 EXPORT_SYMBOL(drm_debug); 51 52 MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl"); 53 MODULE_DESCRIPTION("DRM shared core routines"); 54 MODULE_LICENSE("GPL and additional rights"); 55 MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug category.\n" 56 "\t\tBit 0 (0x01) will enable CORE messages (drm core code)\n" 57 "\t\tBit 1 (0x02) will enable DRIVER messages (drm controller code)\n" 58 "\t\tBit 2 (0x04) will enable KMS messages (modesetting code)\n" 59 "\t\tBit 3 (0x08) will enable PRIME messages (prime code)\n" 60 "\t\tBit 4 (0x10) will enable ATOMIC messages (atomic code)\n" 61 "\t\tBit 5 (0x20) will enable VBL messages (vblank code)\n" 62 "\t\tBit 7 (0x80) will enable LEASE messages (leasing code)"); 63 module_param_named(debug, drm_debug, int, 0600); 64 65 static DEFINE_SPINLOCK(drm_minor_lock); 66 static struct idr drm_minors_idr; 67 68 /* 69 * If the drm core fails to init for whatever reason, 70 * we should prevent any drivers from registering with it. 71 * It's best to check this at drm_dev_init(), as some drivers 72 * prefer to embed struct drm_device into their own device 73 * structure and call drm_dev_init() themselves. 74 */ 75 static bool drm_core_init_complete = false; 76 77 static struct dentry *drm_debugfs_root; 78 79 DEFINE_STATIC_SRCU(drm_unplug_srcu); 80 81 /* 82 * DRM Minors 83 * A DRM device can provide several char-dev interfaces on the DRM-Major. Each 84 * of them is represented by a drm_minor object. Depending on the capabilities 85 * of the device-driver, different interfaces are registered. 86 * 87 * Minors can be accessed via dev->$minor_name. This pointer is either 88 * NULL or a valid drm_minor pointer and stays valid as long as the device is 89 * valid. This means, DRM minors have the same life-time as the underlying 90 * device. However, this doesn't mean that the minor is active. Minors are 91 * registered and unregistered dynamically according to device-state. 92 */ 93 94 static struct drm_minor **drm_minor_get_slot(struct drm_device *dev, 95 unsigned int type) 96 { 97 switch (type) { 98 case DRM_MINOR_PRIMARY: 99 return &dev->primary; 100 case DRM_MINOR_RENDER: 101 return &dev->render; 102 default: 103 BUG(); 104 } 105 } 106 107 static int drm_minor_alloc(struct drm_device *dev, unsigned int type) 108 { 109 struct drm_minor *minor; 110 unsigned long flags; 111 int r; 112 113 minor = kzalloc(sizeof(*minor), GFP_KERNEL); 114 if (!minor) 115 return -ENOMEM; 116 117 minor->type = type; 118 minor->dev = dev; 119 120 idr_preload(GFP_KERNEL); 121 spin_lock_irqsave(&drm_minor_lock, flags); 122 r = idr_alloc(&drm_minors_idr, 123 NULL, 124 64 * type, 125 64 * (type + 1), 126 GFP_NOWAIT); 127 spin_unlock_irqrestore(&drm_minor_lock, flags); 128 idr_preload_end(); 129 130 if (r < 0) 131 goto err_free; 132 133 minor->index = r; 134 135 minor->kdev = drm_sysfs_minor_alloc(minor); 136 if (IS_ERR(minor->kdev)) { 137 r = PTR_ERR(minor->kdev); 138 goto err_index; 139 } 140 141 *drm_minor_get_slot(dev, type) = minor; 142 return 0; 143 144 err_index: 145 spin_lock_irqsave(&drm_minor_lock, flags); 146 idr_remove(&drm_minors_idr, minor->index); 147 spin_unlock_irqrestore(&drm_minor_lock, flags); 148 err_free: 149 kfree(minor); 150 return r; 151 } 152 153 static void drm_minor_free(struct drm_device *dev, unsigned int type) 154 { 155 struct drm_minor **slot, *minor; 156 unsigned long flags; 157 158 slot = drm_minor_get_slot(dev, type); 159 minor = *slot; 160 if (!minor) 161 return; 162 163 put_device(minor->kdev); 164 165 spin_lock_irqsave(&drm_minor_lock, flags); 166 idr_remove(&drm_minors_idr, minor->index); 167 spin_unlock_irqrestore(&drm_minor_lock, flags); 168 169 kfree(minor); 170 *slot = NULL; 171 } 172 173 static int drm_minor_register(struct drm_device *dev, unsigned int type) 174 { 175 struct drm_minor *minor; 176 unsigned long flags; 177 int ret; 178 179 DRM_DEBUG("\n"); 180 181 minor = *drm_minor_get_slot(dev, type); 182 if (!minor) 183 return 0; 184 185 ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root); 186 if (ret) { 187 DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n"); 188 goto err_debugfs; 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 spin_lock_irqsave(&drm_minor_lock, flags); 197 idr_replace(&drm_minors_idr, minor, minor->index); 198 spin_unlock_irqrestore(&drm_minor_lock, flags); 199 200 DRM_DEBUG("new minor registered %d\n", minor->index); 201 return 0; 202 203 err_debugfs: 204 drm_debugfs_cleanup(minor); 205 return ret; 206 } 207 208 static void drm_minor_unregister(struct drm_device *dev, unsigned int type) 209 { 210 struct drm_minor *minor; 211 unsigned long flags; 212 213 minor = *drm_minor_get_slot(dev, type); 214 if (!minor || !device_is_registered(minor->kdev)) 215 return; 216 217 /* replace @minor with NULL so lookups will fail from now on */ 218 spin_lock_irqsave(&drm_minor_lock, flags); 219 idr_replace(&drm_minors_idr, NULL, minor->index); 220 spin_unlock_irqrestore(&drm_minor_lock, flags); 221 222 device_del(minor->kdev); 223 dev_set_drvdata(minor->kdev, NULL); /* safety belt */ 224 drm_debugfs_cleanup(minor); 225 } 226 227 /* 228 * Looks up the given minor-ID and returns the respective DRM-minor object. The 229 * refence-count of the underlying device is increased so you must release this 230 * object with drm_minor_release(). 231 * 232 * As long as you hold this minor, it is guaranteed that the object and the 233 * minor->dev pointer will stay valid! However, the device may get unplugged and 234 * unregistered while you hold the minor. 235 */ 236 struct drm_minor *drm_minor_acquire(unsigned int minor_id) 237 { 238 struct drm_minor *minor; 239 unsigned long flags; 240 241 spin_lock_irqsave(&drm_minor_lock, flags); 242 minor = idr_find(&drm_minors_idr, minor_id); 243 if (minor) 244 drm_dev_get(minor->dev); 245 spin_unlock_irqrestore(&drm_minor_lock, flags); 246 247 if (!minor) { 248 return ERR_PTR(-ENODEV); 249 } else if (drm_dev_is_unplugged(minor->dev)) { 250 drm_dev_put(minor->dev); 251 return ERR_PTR(-ENODEV); 252 } 253 254 return minor; 255 } 256 257 void drm_minor_release(struct drm_minor *minor) 258 { 259 drm_dev_put(minor->dev); 260 } 261 262 /** 263 * DOC: driver instance overview 264 * 265 * A device instance for a drm driver is represented by &struct drm_device. This 266 * is allocated with drm_dev_alloc(), usually from bus-specific ->probe() 267 * callbacks implemented by the driver. The driver then needs to initialize all 268 * the various subsystems for the drm device like memory management, vblank 269 * handling, modesetting support and intial output configuration plus obviously 270 * initialize all the corresponding hardware bits. An important part of this is 271 * also calling drm_dev_set_unique() to set the userspace-visible unique name of 272 * this device instance. Finally when everything is up and running and ready for 273 * userspace the device instance can be published using drm_dev_register(). 274 * 275 * There is also deprecated support for initalizing device instances using 276 * bus-specific helpers and the &drm_driver.load callback. But due to 277 * backwards-compatibility needs the device instance have to be published too 278 * early, which requires unpretty global locking to make safe and is therefore 279 * only support for existing drivers not yet converted to the new scheme. 280 * 281 * When cleaning up a device instance everything needs to be done in reverse: 282 * First unpublish the device instance with drm_dev_unregister(). Then clean up 283 * any other resources allocated at device initialization and drop the driver's 284 * reference to &drm_device using drm_dev_put(). 285 * 286 * Note that the lifetime rules for &drm_device instance has still a lot of 287 * historical baggage. Hence use the reference counting provided by 288 * drm_dev_get() and drm_dev_put() only carefully. 289 * 290 * It is recommended that drivers embed &struct drm_device into their own device 291 * structure, which is supported through drm_dev_init(). 292 */ 293 294 /** 295 * drm_put_dev - Unregister and release a DRM device 296 * @dev: DRM device 297 * 298 * Called at module unload time or when a PCI device is unplugged. 299 * 300 * Cleans up all DRM device, calling drm_lastclose(). 301 * 302 * Note: Use of this function is deprecated. It will eventually go away 303 * completely. Please use drm_dev_unregister() and drm_dev_put() explicitly 304 * instead to make sure that the device isn't userspace accessible any more 305 * while teardown is in progress, ensuring that userspace can't access an 306 * inconsistent state. 307 */ 308 void drm_put_dev(struct drm_device *dev) 309 { 310 DRM_DEBUG("\n"); 311 312 if (!dev) { 313 DRM_ERROR("cleanup called no dev\n"); 314 return; 315 } 316 317 drm_dev_unregister(dev); 318 drm_dev_put(dev); 319 } 320 EXPORT_SYMBOL(drm_put_dev); 321 322 /** 323 * drm_dev_enter - Enter device critical section 324 * @dev: DRM device 325 * @idx: Pointer to index that will be passed to the matching drm_dev_exit() 326 * 327 * This function marks and protects the beginning of a section that should not 328 * be entered after the device has been unplugged. The section end is marked 329 * with drm_dev_exit(). Calls to this function can be nested. 330 * 331 * Returns: 332 * True if it is OK to enter the section, false otherwise. 333 */ 334 bool drm_dev_enter(struct drm_device *dev, int *idx) 335 { 336 *idx = srcu_read_lock(&drm_unplug_srcu); 337 338 if (dev->unplugged) { 339 srcu_read_unlock(&drm_unplug_srcu, *idx); 340 return false; 341 } 342 343 return true; 344 } 345 EXPORT_SYMBOL(drm_dev_enter); 346 347 /** 348 * drm_dev_exit - Exit device critical section 349 * @idx: index returned from drm_dev_enter() 350 * 351 * This function marks the end of a section that should not be entered after 352 * the device has been unplugged. 353 */ 354 void drm_dev_exit(int idx) 355 { 356 srcu_read_unlock(&drm_unplug_srcu, idx); 357 } 358 EXPORT_SYMBOL(drm_dev_exit); 359 360 /** 361 * drm_dev_unplug - unplug a DRM device 362 * @dev: DRM device 363 * 364 * This unplugs a hotpluggable DRM device, which makes it inaccessible to 365 * userspace operations. Entry-points can use drm_dev_enter() and 366 * drm_dev_exit() to protect device resources in a race free manner. This 367 * essentially unregisters the device like drm_dev_unregister(), but can be 368 * called while there are still open users of @dev. 369 */ 370 void drm_dev_unplug(struct drm_device *dev) 371 { 372 drm_dev_unregister(dev); 373 374 mutex_lock(&drm_global_mutex); 375 if (dev->open_count == 0) 376 drm_dev_put(dev); 377 mutex_unlock(&drm_global_mutex); 378 379 /* 380 * After synchronizing any critical read section is guaranteed to see 381 * the new value of ->unplugged, and any critical section which might 382 * still have seen the old value of ->unplugged is guaranteed to have 383 * finished. 384 */ 385 dev->unplugged = true; 386 synchronize_srcu(&drm_unplug_srcu); 387 } 388 EXPORT_SYMBOL(drm_dev_unplug); 389 390 /* 391 * DRM internal mount 392 * We want to be able to allocate our own "struct address_space" to control 393 * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow 394 * stand-alone address_space objects, so we need an underlying inode. As there 395 * is no way to allocate an independent inode easily, we need a fake internal 396 * VFS mount-point. 397 * 398 * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free() 399 * frees it again. You are allowed to use iget() and iput() to get references to 400 * the inode. But each drm_fs_inode_new() call must be paired with exactly one 401 * drm_fs_inode_free() call (which does not have to be the last iput()). 402 * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it 403 * between multiple inode-users. You could, technically, call 404 * iget() + drm_fs_inode_free() directly after alloc and sometime later do an 405 * iput(), but this way you'd end up with a new vfsmount for each inode. 406 */ 407 408 static int drm_fs_cnt; 409 static struct vfsmount *drm_fs_mnt; 410 411 static const struct dentry_operations drm_fs_dops = { 412 .d_dname = simple_dname, 413 }; 414 415 static const struct super_operations drm_fs_sops = { 416 .statfs = simple_statfs, 417 }; 418 419 static struct dentry *drm_fs_mount(struct file_system_type *fs_type, int flags, 420 const char *dev_name, void *data) 421 { 422 return mount_pseudo(fs_type, 423 "drm:", 424 &drm_fs_sops, 425 &drm_fs_dops, 426 0x010203ff); 427 } 428 429 static struct file_system_type drm_fs_type = { 430 .name = "drm", 431 .owner = THIS_MODULE, 432 .mount = drm_fs_mount, 433 .kill_sb = kill_anon_super, 434 }; 435 436 static struct inode *drm_fs_inode_new(void) 437 { 438 struct inode *inode; 439 int r; 440 441 r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt); 442 if (r < 0) { 443 DRM_ERROR("Cannot mount pseudo fs: %d\n", r); 444 return ERR_PTR(r); 445 } 446 447 inode = alloc_anon_inode(drm_fs_mnt->mnt_sb); 448 if (IS_ERR(inode)) 449 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 450 451 return inode; 452 } 453 454 static void drm_fs_inode_free(struct inode *inode) 455 { 456 if (inode) { 457 iput(inode); 458 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt); 459 } 460 } 461 462 /** 463 * drm_dev_init - Initialise new DRM device 464 * @dev: DRM device 465 * @driver: DRM driver 466 * @parent: Parent device object 467 * 468 * Initialize a new DRM device. No device registration is done. 469 * Call drm_dev_register() to advertice the device to user space and register it 470 * with other core subsystems. This should be done last in the device 471 * initialization sequence to make sure userspace can't access an inconsistent 472 * state. 473 * 474 * The initial ref-count of the object is 1. Use drm_dev_get() and 475 * drm_dev_put() to take and drop further ref-counts. 476 * 477 * Note that for purely virtual devices @parent can be NULL. 478 * 479 * Drivers that do not want to allocate their own device struct 480 * embedding &struct drm_device can call drm_dev_alloc() instead. For drivers 481 * that do embed &struct drm_device it must be placed first in the overall 482 * structure, and the overall structure must be allocated using kmalloc(): The 483 * drm core's release function unconditionally calls kfree() on the @dev pointer 484 * when the final reference is released. To override this behaviour, and so 485 * allow embedding of the drm_device inside the driver's device struct at an 486 * arbitrary offset, you must supply a &drm_driver.release callback and control 487 * the finalization explicitly. 488 * 489 * RETURNS: 490 * 0 on success, or error code on failure. 491 */ 492 int drm_dev_init(struct drm_device *dev, 493 struct drm_driver *driver, 494 struct device *parent) 495 { 496 int ret; 497 498 if (!drm_core_init_complete) { 499 DRM_ERROR("DRM core is not initialized\n"); 500 return -ENODEV; 501 } 502 503 kref_init(&dev->ref); 504 dev->dev = parent; 505 dev->driver = driver; 506 507 INIT_LIST_HEAD(&dev->filelist); 508 INIT_LIST_HEAD(&dev->ctxlist); 509 INIT_LIST_HEAD(&dev->vmalist); 510 INIT_LIST_HEAD(&dev->maplist); 511 INIT_LIST_HEAD(&dev->vblank_event_list); 512 513 spin_lock_init(&dev->buf_lock); 514 spin_lock_init(&dev->event_lock); 515 mutex_init(&dev->struct_mutex); 516 mutex_init(&dev->filelist_mutex); 517 mutex_init(&dev->ctxlist_mutex); 518 mutex_init(&dev->master_mutex); 519 520 dev->anon_inode = drm_fs_inode_new(); 521 if (IS_ERR(dev->anon_inode)) { 522 ret = PTR_ERR(dev->anon_inode); 523 DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret); 524 goto err_free; 525 } 526 527 if (drm_core_check_feature(dev, DRIVER_RENDER)) { 528 ret = drm_minor_alloc(dev, DRM_MINOR_RENDER); 529 if (ret) 530 goto err_minors; 531 } 532 533 ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY); 534 if (ret) 535 goto err_minors; 536 537 ret = drm_ht_create(&dev->map_hash, 12); 538 if (ret) 539 goto err_minors; 540 541 drm_legacy_ctxbitmap_init(dev); 542 543 if (drm_core_check_feature(dev, DRIVER_GEM)) { 544 ret = drm_gem_init(dev); 545 if (ret) { 546 DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n"); 547 goto err_ctxbitmap; 548 } 549 } 550 551 /* Use the parent device name as DRM device unique identifier, but fall 552 * back to the driver name for virtual devices like vgem. */ 553 ret = drm_dev_set_unique(dev, parent ? dev_name(parent) : driver->name); 554 if (ret) 555 goto err_setunique; 556 557 return 0; 558 559 err_setunique: 560 if (drm_core_check_feature(dev, DRIVER_GEM)) 561 drm_gem_destroy(dev); 562 err_ctxbitmap: 563 drm_legacy_ctxbitmap_cleanup(dev); 564 drm_ht_remove(&dev->map_hash); 565 err_minors: 566 drm_minor_free(dev, DRM_MINOR_PRIMARY); 567 drm_minor_free(dev, DRM_MINOR_RENDER); 568 drm_fs_inode_free(dev->anon_inode); 569 err_free: 570 mutex_destroy(&dev->master_mutex); 571 mutex_destroy(&dev->ctxlist_mutex); 572 mutex_destroy(&dev->filelist_mutex); 573 mutex_destroy(&dev->struct_mutex); 574 return ret; 575 } 576 EXPORT_SYMBOL(drm_dev_init); 577 578 /** 579 * drm_dev_fini - Finalize a dead DRM device 580 * @dev: DRM device 581 * 582 * Finalize a dead DRM device. This is the converse to drm_dev_init() and 583 * frees up all data allocated by it. All driver private data should be 584 * finalized first. Note that this function does not free the @dev, that is 585 * left to the caller. 586 * 587 * The ref-count of @dev must be zero, and drm_dev_fini() should only be called 588 * from a &drm_driver.release callback. 589 */ 590 void drm_dev_fini(struct drm_device *dev) 591 { 592 drm_vblank_cleanup(dev); 593 594 if (drm_core_check_feature(dev, DRIVER_GEM)) 595 drm_gem_destroy(dev); 596 597 drm_legacy_ctxbitmap_cleanup(dev); 598 drm_ht_remove(&dev->map_hash); 599 drm_fs_inode_free(dev->anon_inode); 600 601 drm_minor_free(dev, DRM_MINOR_PRIMARY); 602 drm_minor_free(dev, DRM_MINOR_RENDER); 603 604 mutex_destroy(&dev->master_mutex); 605 mutex_destroy(&dev->ctxlist_mutex); 606 mutex_destroy(&dev->filelist_mutex); 607 mutex_destroy(&dev->struct_mutex); 608 kfree(dev->unique); 609 } 610 EXPORT_SYMBOL(drm_dev_fini); 611 612 /** 613 * drm_dev_alloc - Allocate new DRM device 614 * @driver: DRM driver to allocate device for 615 * @parent: Parent device object 616 * 617 * Allocate and initialize a new DRM device. No device registration is done. 618 * Call drm_dev_register() to advertice the device to user space and register it 619 * with other core subsystems. This should be done last in the device 620 * initialization sequence to make sure userspace can't access an inconsistent 621 * state. 622 * 623 * The initial ref-count of the object is 1. Use drm_dev_get() and 624 * drm_dev_put() to take and drop further ref-counts. 625 * 626 * Note that for purely virtual devices @parent can be NULL. 627 * 628 * Drivers that wish to subclass or embed &struct drm_device into their 629 * own struct should look at using drm_dev_init() instead. 630 * 631 * RETURNS: 632 * Pointer to new DRM device, or ERR_PTR on failure. 633 */ 634 struct drm_device *drm_dev_alloc(struct drm_driver *driver, 635 struct device *parent) 636 { 637 struct drm_device *dev; 638 int ret; 639 640 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 641 if (!dev) 642 return ERR_PTR(-ENOMEM); 643 644 ret = drm_dev_init(dev, driver, parent); 645 if (ret) { 646 kfree(dev); 647 return ERR_PTR(ret); 648 } 649 650 return dev; 651 } 652 EXPORT_SYMBOL(drm_dev_alloc); 653 654 static void drm_dev_release(struct kref *ref) 655 { 656 struct drm_device *dev = container_of(ref, struct drm_device, ref); 657 658 if (dev->driver->release) { 659 dev->driver->release(dev); 660 } else { 661 drm_dev_fini(dev); 662 kfree(dev); 663 } 664 } 665 666 /** 667 * drm_dev_get - Take reference of a DRM device 668 * @dev: device to take reference of or NULL 669 * 670 * This increases the ref-count of @dev by one. You *must* already own a 671 * reference when calling this. Use drm_dev_put() to drop this reference 672 * again. 673 * 674 * This function never fails. However, this function does not provide *any* 675 * guarantee whether the device is alive or running. It only provides a 676 * reference to the object and the memory associated with it. 677 */ 678 void drm_dev_get(struct drm_device *dev) 679 { 680 if (dev) 681 kref_get(&dev->ref); 682 } 683 EXPORT_SYMBOL(drm_dev_get); 684 685 /** 686 * drm_dev_put - Drop reference of a DRM device 687 * @dev: device to drop reference of or NULL 688 * 689 * This decreases the ref-count of @dev by one. The device is destroyed if the 690 * ref-count drops to zero. 691 */ 692 void drm_dev_put(struct drm_device *dev) 693 { 694 if (dev) 695 kref_put(&dev->ref, drm_dev_release); 696 } 697 EXPORT_SYMBOL(drm_dev_put); 698 699 /** 700 * drm_dev_unref - Drop reference of a DRM device 701 * @dev: device to drop reference of or NULL 702 * 703 * This is a compatibility alias for drm_dev_put() and should not be used by new 704 * code. 705 */ 706 void drm_dev_unref(struct drm_device *dev) 707 { 708 drm_dev_put(dev); 709 } 710 EXPORT_SYMBOL(drm_dev_unref); 711 712 static int create_compat_control_link(struct drm_device *dev) 713 { 714 struct drm_minor *minor; 715 char *name; 716 int ret; 717 718 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 719 return 0; 720 721 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 722 if (!minor) 723 return 0; 724 725 /* 726 * Some existing userspace out there uses the existing of the controlD* 727 * sysfs files to figure out whether it's a modeset driver. It only does 728 * readdir, hence a symlink is sufficient (and the least confusing 729 * option). Otherwise controlD* is entirely unused. 730 * 731 * Old controlD chardev have been allocated in the range 732 * 64-127. 733 */ 734 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 735 if (!name) 736 return -ENOMEM; 737 738 ret = sysfs_create_link(minor->kdev->kobj.parent, 739 &minor->kdev->kobj, 740 name); 741 742 kfree(name); 743 744 return ret; 745 } 746 747 static void remove_compat_control_link(struct drm_device *dev) 748 { 749 struct drm_minor *minor; 750 char *name; 751 752 if (!drm_core_check_feature(dev, DRIVER_MODESET)) 753 return; 754 755 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY); 756 if (!minor) 757 return; 758 759 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64); 760 if (!name) 761 return; 762 763 sysfs_remove_link(minor->kdev->kobj.parent, name); 764 765 kfree(name); 766 } 767 768 /** 769 * drm_dev_register - Register DRM device 770 * @dev: Device to register 771 * @flags: Flags passed to the driver's .load() function 772 * 773 * Register the DRM device @dev with the system, advertise device to user-space 774 * and start normal device operation. @dev must be allocated via drm_dev_alloc() 775 * previously. 776 * 777 * Never call this twice on any device! 778 * 779 * NOTE: To ensure backward compatibility with existing drivers method this 780 * function calls the &drm_driver.load method after registering the device 781 * nodes, creating race conditions. Usage of the &drm_driver.load methods is 782 * therefore deprecated, drivers must perform all initialization before calling 783 * drm_dev_register(). 784 * 785 * RETURNS: 786 * 0 on success, negative error code on failure. 787 */ 788 int drm_dev_register(struct drm_device *dev, unsigned long flags) 789 { 790 struct drm_driver *driver = dev->driver; 791 int ret; 792 793 mutex_lock(&drm_global_mutex); 794 795 ret = drm_minor_register(dev, DRM_MINOR_RENDER); 796 if (ret) 797 goto err_minors; 798 799 ret = drm_minor_register(dev, DRM_MINOR_PRIMARY); 800 if (ret) 801 goto err_minors; 802 803 ret = create_compat_control_link(dev); 804 if (ret) 805 goto err_minors; 806 807 dev->registered = true; 808 809 if (dev->driver->load) { 810 ret = dev->driver->load(dev, flags); 811 if (ret) 812 goto err_minors; 813 } 814 815 if (drm_core_check_feature(dev, DRIVER_MODESET)) 816 drm_modeset_register_all(dev); 817 818 ret = 0; 819 820 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", 821 driver->name, driver->major, driver->minor, 822 driver->patchlevel, driver->date, 823 dev->dev ? dev_name(dev->dev) : "virtual device", 824 dev->primary->index); 825 826 goto out_unlock; 827 828 err_minors: 829 remove_compat_control_link(dev); 830 drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 831 drm_minor_unregister(dev, DRM_MINOR_RENDER); 832 out_unlock: 833 mutex_unlock(&drm_global_mutex); 834 return ret; 835 } 836 EXPORT_SYMBOL(drm_dev_register); 837 838 /** 839 * drm_dev_unregister - Unregister DRM device 840 * @dev: Device to unregister 841 * 842 * Unregister the DRM device from the system. This does the reverse of 843 * drm_dev_register() but does not deallocate the device. The caller must call 844 * drm_dev_put() to drop their final reference. 845 * 846 * A special form of unregistering for hotpluggable devices is drm_dev_unplug(), 847 * which can be called while there are still open users of @dev. 848 * 849 * This should be called first in the device teardown code to make sure 850 * userspace can't access the device instance any more. 851 */ 852 void drm_dev_unregister(struct drm_device *dev) 853 { 854 struct drm_map_list *r_list, *list_temp; 855 856 if (drm_core_check_feature(dev, DRIVER_LEGACY)) 857 drm_lastclose(dev); 858 859 dev->registered = false; 860 861 if (drm_core_check_feature(dev, DRIVER_MODESET)) 862 drm_modeset_unregister_all(dev); 863 864 if (dev->driver->unload) 865 dev->driver->unload(dev); 866 867 if (dev->agp) 868 drm_pci_agp_destroy(dev); 869 870 list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) 871 drm_legacy_rmmap(dev, r_list->map); 872 873 remove_compat_control_link(dev); 874 drm_minor_unregister(dev, DRM_MINOR_PRIMARY); 875 drm_minor_unregister(dev, DRM_MINOR_RENDER); 876 } 877 EXPORT_SYMBOL(drm_dev_unregister); 878 879 /** 880 * drm_dev_set_unique - Set the unique name of a DRM device 881 * @dev: device of which to set the unique name 882 * @name: unique name 883 * 884 * Sets the unique name of a DRM device using the specified string. Drivers 885 * can use this at driver probe time if the unique name of the devices they 886 * drive is static. 887 * 888 * Return: 0 on success or a negative error code on failure. 889 */ 890 int drm_dev_set_unique(struct drm_device *dev, const char *name) 891 { 892 kfree(dev->unique); 893 dev->unique = kstrdup(name, GFP_KERNEL); 894 895 return dev->unique ? 0 : -ENOMEM; 896 } 897 EXPORT_SYMBOL(drm_dev_set_unique); 898 899 /* 900 * DRM Core 901 * The DRM core module initializes all global DRM objects and makes them 902 * available to drivers. Once setup, drivers can probe their respective 903 * devices. 904 * Currently, core management includes: 905 * - The "DRM-Global" key/value database 906 * - Global ID management for connectors 907 * - DRM major number allocation 908 * - DRM minor management 909 * - DRM sysfs class 910 * - DRM debugfs root 911 * 912 * Furthermore, the DRM core provides dynamic char-dev lookups. For each 913 * interface registered on a DRM device, you can request minor numbers from DRM 914 * core. DRM core takes care of major-number management and char-dev 915 * registration. A stub ->open() callback forwards any open() requests to the 916 * registered minor. 917 */ 918 919 static int drm_stub_open(struct inode *inode, struct file *filp) 920 { 921 const struct file_operations *new_fops; 922 struct drm_minor *minor; 923 int err; 924 925 DRM_DEBUG("\n"); 926 927 mutex_lock(&drm_global_mutex); 928 minor = drm_minor_acquire(iminor(inode)); 929 if (IS_ERR(minor)) { 930 err = PTR_ERR(minor); 931 goto out_unlock; 932 } 933 934 new_fops = fops_get(minor->dev->driver->fops); 935 if (!new_fops) { 936 err = -ENODEV; 937 goto out_release; 938 } 939 940 replace_fops(filp, new_fops); 941 if (filp->f_op->open) 942 err = filp->f_op->open(inode, filp); 943 else 944 err = 0; 945 946 out_release: 947 drm_minor_release(minor); 948 out_unlock: 949 mutex_unlock(&drm_global_mutex); 950 return err; 951 } 952 953 static const struct file_operations drm_stub_fops = { 954 .owner = THIS_MODULE, 955 .open = drm_stub_open, 956 .llseek = noop_llseek, 957 }; 958 959 static void drm_core_exit(void) 960 { 961 unregister_chrdev(DRM_MAJOR, "drm"); 962 debugfs_remove(drm_debugfs_root); 963 drm_sysfs_destroy(); 964 idr_destroy(&drm_minors_idr); 965 drm_connector_ida_destroy(); 966 drm_global_release(); 967 } 968 969 static int __init drm_core_init(void) 970 { 971 int ret; 972 973 drm_global_init(); 974 drm_connector_ida_init(); 975 idr_init(&drm_minors_idr); 976 977 ret = drm_sysfs_init(); 978 if (ret < 0) { 979 DRM_ERROR("Cannot create DRM class: %d\n", ret); 980 goto error; 981 } 982 983 drm_debugfs_root = debugfs_create_dir("dri", NULL); 984 if (!drm_debugfs_root) { 985 ret = -ENOMEM; 986 DRM_ERROR("Cannot create debugfs-root: %d\n", ret); 987 goto error; 988 } 989 990 ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops); 991 if (ret < 0) 992 goto error; 993 994 drm_core_init_complete = true; 995 996 DRM_DEBUG("Initialized\n"); 997 return 0; 998 999 error: 1000 drm_core_exit(); 1001 return ret; 1002 } 1003 1004 module_init(drm_core_init); 1005 module_exit(drm_core_exit); 1006