1 // SPDX-License-Identifier: GPL-2.0-or-later 2 3 #include <linux/dma-buf-map.h> 4 #include <linux/module.h> 5 6 #include <drm/drm_debugfs.h> 7 #include <drm/drm_device.h> 8 #include <drm/drm_drv.h> 9 #include <drm/drm_file.h> 10 #include <drm/drm_framebuffer.h> 11 #include <drm/drm_gem_atomic_helper.h> 12 #include <drm/drm_gem_ttm_helper.h> 13 #include <drm/drm_gem_vram_helper.h> 14 #include <drm/drm_managed.h> 15 #include <drm/drm_mode.h> 16 #include <drm/drm_plane.h> 17 #include <drm/drm_prime.h> 18 #include <drm/drm_simple_kms_helper.h> 19 20 #include <drm/ttm/ttm_range_manager.h> 21 22 static const struct drm_gem_object_funcs drm_gem_vram_object_funcs; 23 24 /** 25 * DOC: overview 26 * 27 * This library provides &struct drm_gem_vram_object (GEM VRAM), a GEM 28 * buffer object that is backed by video RAM (VRAM). It can be used for 29 * framebuffer devices with dedicated memory. 30 * 31 * The data structure &struct drm_vram_mm and its helpers implement a memory 32 * manager for simple framebuffer devices with dedicated video memory. GEM 33 * VRAM buffer objects are either placed in the video memory or remain evicted 34 * to system memory. 35 * 36 * With the GEM interface userspace applications create, manage and destroy 37 * graphics buffers, such as an on-screen framebuffer. GEM does not provide 38 * an implementation of these interfaces. It's up to the DRM driver to 39 * provide an implementation that suits the hardware. If the hardware device 40 * contains dedicated video memory, the DRM driver can use the VRAM helper 41 * library. Each active buffer object is stored in video RAM. Active 42 * buffer are used for drawing the current frame, typically something like 43 * the frame's scanout buffer or the cursor image. If there's no more space 44 * left in VRAM, inactive GEM objects can be moved to system memory. 45 * 46 * To initialize the VRAM helper library call drmm_vram_helper_alloc_mm(). 47 * The function allocates and initializes an instance of &struct drm_vram_mm 48 * in &struct drm_device.vram_mm . Use &DRM_GEM_VRAM_DRIVER to initialize 49 * &struct drm_driver and &DRM_VRAM_MM_FILE_OPERATIONS to initialize 50 * &struct file_operations; as illustrated below. 51 * 52 * .. code-block:: c 53 * 54 * struct file_operations fops ={ 55 * .owner = THIS_MODULE, 56 * DRM_VRAM_MM_FILE_OPERATION 57 * }; 58 * struct drm_driver drv = { 59 * .driver_feature = DRM_ ... , 60 * .fops = &fops, 61 * DRM_GEM_VRAM_DRIVER 62 * }; 63 * 64 * int init_drm_driver() 65 * { 66 * struct drm_device *dev; 67 * uint64_t vram_base; 68 * unsigned long vram_size; 69 * int ret; 70 * 71 * // setup device, vram base and size 72 * // ... 73 * 74 * ret = drmm_vram_helper_alloc_mm(dev, vram_base, vram_size); 75 * if (ret) 76 * return ret; 77 * return 0; 78 * } 79 * 80 * This creates an instance of &struct drm_vram_mm, exports DRM userspace 81 * interfaces for GEM buffer management and initializes file operations to 82 * allow for accessing created GEM buffers. With this setup, the DRM driver 83 * manages an area of video RAM with VRAM MM and provides GEM VRAM objects 84 * to userspace. 85 * 86 * You don't have to clean up the instance of VRAM MM. 87 * drmm_vram_helper_alloc_mm() is a managed interface that installs a 88 * clean-up handler to run during the DRM device's release. 89 * 90 * For drawing or scanout operations, rsp. buffer objects have to be pinned 91 * in video RAM. Call drm_gem_vram_pin() with &DRM_GEM_VRAM_PL_FLAG_VRAM or 92 * &DRM_GEM_VRAM_PL_FLAG_SYSTEM to pin a buffer object in video RAM or system 93 * memory. Call drm_gem_vram_unpin() to release the pinned object afterwards. 94 * 95 * A buffer object that is pinned in video RAM has a fixed address within that 96 * memory region. Call drm_gem_vram_offset() to retrieve this value. Typically 97 * it's used to program the hardware's scanout engine for framebuffers, set 98 * the cursor overlay's image for a mouse cursor, or use it as input to the 99 * hardware's drawing engine. 100 * 101 * To access a buffer object's memory from the DRM driver, call 102 * drm_gem_vram_vmap(). It maps the buffer into kernel address 103 * space and returns the memory address. Use drm_gem_vram_vunmap() to 104 * release the mapping. 105 */ 106 107 /* 108 * Buffer-objects helpers 109 */ 110 111 static void drm_gem_vram_cleanup(struct drm_gem_vram_object *gbo) 112 { 113 /* We got here via ttm_bo_put(), which means that the 114 * TTM buffer object in 'bo' has already been cleaned 115 * up; only release the GEM object. 116 */ 117 118 WARN_ON(gbo->vmap_use_count); 119 WARN_ON(dma_buf_map_is_set(&gbo->map)); 120 121 drm_gem_object_release(&gbo->bo.base); 122 } 123 124 static void drm_gem_vram_destroy(struct drm_gem_vram_object *gbo) 125 { 126 drm_gem_vram_cleanup(gbo); 127 kfree(gbo); 128 } 129 130 static void ttm_buffer_object_destroy(struct ttm_buffer_object *bo) 131 { 132 struct drm_gem_vram_object *gbo = drm_gem_vram_of_bo(bo); 133 134 drm_gem_vram_destroy(gbo); 135 } 136 137 static void drm_gem_vram_placement(struct drm_gem_vram_object *gbo, 138 unsigned long pl_flag) 139 { 140 u32 invariant_flags = 0; 141 unsigned int i; 142 unsigned int c = 0; 143 144 if (pl_flag & DRM_GEM_VRAM_PL_FLAG_TOPDOWN) 145 invariant_flags = TTM_PL_FLAG_TOPDOWN; 146 147 gbo->placement.placement = gbo->placements; 148 gbo->placement.busy_placement = gbo->placements; 149 150 if (pl_flag & DRM_GEM_VRAM_PL_FLAG_VRAM) { 151 gbo->placements[c].mem_type = TTM_PL_VRAM; 152 gbo->placements[c++].flags = invariant_flags; 153 } 154 155 if (pl_flag & DRM_GEM_VRAM_PL_FLAG_SYSTEM || !c) { 156 gbo->placements[c].mem_type = TTM_PL_SYSTEM; 157 gbo->placements[c++].flags = invariant_flags; 158 } 159 160 gbo->placement.num_placement = c; 161 gbo->placement.num_busy_placement = c; 162 163 for (i = 0; i < c; ++i) { 164 gbo->placements[i].fpfn = 0; 165 gbo->placements[i].lpfn = 0; 166 } 167 } 168 169 /** 170 * drm_gem_vram_create() - Creates a VRAM-backed GEM object 171 * @dev: the DRM device 172 * @size: the buffer size in bytes 173 * @pg_align: the buffer's alignment in multiples of the page size 174 * 175 * GEM objects are allocated by calling struct drm_driver.gem_create_object, 176 * if set. Otherwise kzalloc() will be used. Drivers can set their own GEM 177 * object functions in struct drm_driver.gem_create_object. If no functions 178 * are set, the new GEM object will use the default functions from GEM VRAM 179 * helpers. 180 * 181 * Returns: 182 * A new instance of &struct drm_gem_vram_object on success, or 183 * an ERR_PTR()-encoded error code otherwise. 184 */ 185 struct drm_gem_vram_object *drm_gem_vram_create(struct drm_device *dev, 186 size_t size, 187 unsigned long pg_align) 188 { 189 struct drm_gem_vram_object *gbo; 190 struct drm_gem_object *gem; 191 struct drm_vram_mm *vmm = dev->vram_mm; 192 struct ttm_device *bdev; 193 int ret; 194 195 if (WARN_ONCE(!vmm, "VRAM MM not initialized")) 196 return ERR_PTR(-EINVAL); 197 198 if (dev->driver->gem_create_object) { 199 gem = dev->driver->gem_create_object(dev, size); 200 if (!gem) 201 return ERR_PTR(-ENOMEM); 202 gbo = drm_gem_vram_of_gem(gem); 203 } else { 204 gbo = kzalloc(sizeof(*gbo), GFP_KERNEL); 205 if (!gbo) 206 return ERR_PTR(-ENOMEM); 207 gem = &gbo->bo.base; 208 } 209 210 if (!gem->funcs) 211 gem->funcs = &drm_gem_vram_object_funcs; 212 213 ret = drm_gem_object_init(dev, gem, size); 214 if (ret) { 215 kfree(gbo); 216 return ERR_PTR(ret); 217 } 218 219 bdev = &vmm->bdev; 220 221 gbo->bo.bdev = bdev; 222 drm_gem_vram_placement(gbo, DRM_GEM_VRAM_PL_FLAG_SYSTEM); 223 224 /* 225 * A failing ttm_bo_init will call ttm_buffer_object_destroy 226 * to release gbo->bo.base and kfree gbo. 227 */ 228 ret = ttm_bo_init(bdev, &gbo->bo, size, ttm_bo_type_device, 229 &gbo->placement, pg_align, false, NULL, NULL, 230 ttm_buffer_object_destroy); 231 if (ret) 232 return ERR_PTR(ret); 233 234 return gbo; 235 } 236 EXPORT_SYMBOL(drm_gem_vram_create); 237 238 /** 239 * drm_gem_vram_put() - Releases a reference to a VRAM-backed GEM object 240 * @gbo: the GEM VRAM object 241 * 242 * See ttm_bo_put() for more information. 243 */ 244 void drm_gem_vram_put(struct drm_gem_vram_object *gbo) 245 { 246 ttm_bo_put(&gbo->bo); 247 } 248 EXPORT_SYMBOL(drm_gem_vram_put); 249 250 static u64 drm_gem_vram_pg_offset(struct drm_gem_vram_object *gbo) 251 { 252 /* Keep TTM behavior for now, remove when drivers are audited */ 253 if (WARN_ON_ONCE(!gbo->bo.resource || 254 gbo->bo.resource->mem_type == TTM_PL_SYSTEM)) 255 return 0; 256 257 return gbo->bo.resource->start; 258 } 259 260 /** 261 * drm_gem_vram_offset() - \ 262 Returns a GEM VRAM object's offset in video memory 263 * @gbo: the GEM VRAM object 264 * 265 * This function returns the buffer object's offset in the device's video 266 * memory. The buffer object has to be pinned to %TTM_PL_VRAM. 267 * 268 * Returns: 269 * The buffer object's offset in video memory on success, or 270 * a negative errno code otherwise. 271 */ 272 s64 drm_gem_vram_offset(struct drm_gem_vram_object *gbo) 273 { 274 if (WARN_ON_ONCE(!gbo->bo.pin_count)) 275 return (s64)-ENODEV; 276 return drm_gem_vram_pg_offset(gbo) << PAGE_SHIFT; 277 } 278 EXPORT_SYMBOL(drm_gem_vram_offset); 279 280 static int drm_gem_vram_pin_locked(struct drm_gem_vram_object *gbo, 281 unsigned long pl_flag) 282 { 283 struct ttm_operation_ctx ctx = { false, false }; 284 int ret; 285 286 if (gbo->bo.pin_count) 287 goto out; 288 289 if (pl_flag) 290 drm_gem_vram_placement(gbo, pl_flag); 291 292 ret = ttm_bo_validate(&gbo->bo, &gbo->placement, &ctx); 293 if (ret < 0) 294 return ret; 295 296 out: 297 ttm_bo_pin(&gbo->bo); 298 299 return 0; 300 } 301 302 /** 303 * drm_gem_vram_pin() - Pins a GEM VRAM object in a region. 304 * @gbo: the GEM VRAM object 305 * @pl_flag: a bitmask of possible memory regions 306 * 307 * Pinning a buffer object ensures that it is not evicted from 308 * a memory region. A pinned buffer object has to be unpinned before 309 * it can be pinned to another region. If the pl_flag argument is 0, 310 * the buffer is pinned at its current location (video RAM or system 311 * memory). 312 * 313 * Small buffer objects, such as cursor images, can lead to memory 314 * fragmentation if they are pinned in the middle of video RAM. This 315 * is especially a problem on devices with only a small amount of 316 * video RAM. Fragmentation can prevent the primary framebuffer from 317 * fitting in, even though there's enough memory overall. The modifier 318 * DRM_GEM_VRAM_PL_FLAG_TOPDOWN marks the buffer object to be pinned 319 * at the high end of the memory region to avoid fragmentation. 320 * 321 * Returns: 322 * 0 on success, or 323 * a negative error code otherwise. 324 */ 325 int drm_gem_vram_pin(struct drm_gem_vram_object *gbo, unsigned long pl_flag) 326 { 327 int ret; 328 329 ret = ttm_bo_reserve(&gbo->bo, true, false, NULL); 330 if (ret) 331 return ret; 332 ret = drm_gem_vram_pin_locked(gbo, pl_flag); 333 ttm_bo_unreserve(&gbo->bo); 334 335 return ret; 336 } 337 EXPORT_SYMBOL(drm_gem_vram_pin); 338 339 static void drm_gem_vram_unpin_locked(struct drm_gem_vram_object *gbo) 340 { 341 ttm_bo_unpin(&gbo->bo); 342 } 343 344 /** 345 * drm_gem_vram_unpin() - Unpins a GEM VRAM object 346 * @gbo: the GEM VRAM object 347 * 348 * Returns: 349 * 0 on success, or 350 * a negative error code otherwise. 351 */ 352 int drm_gem_vram_unpin(struct drm_gem_vram_object *gbo) 353 { 354 int ret; 355 356 ret = ttm_bo_reserve(&gbo->bo, true, false, NULL); 357 if (ret) 358 return ret; 359 360 drm_gem_vram_unpin_locked(gbo); 361 ttm_bo_unreserve(&gbo->bo); 362 363 return 0; 364 } 365 EXPORT_SYMBOL(drm_gem_vram_unpin); 366 367 static int drm_gem_vram_kmap_locked(struct drm_gem_vram_object *gbo, 368 struct dma_buf_map *map) 369 { 370 int ret; 371 372 if (gbo->vmap_use_count > 0) 373 goto out; 374 375 /* 376 * VRAM helpers unmap the BO only on demand. So the previous 377 * page mapping might still be around. Only vmap if the there's 378 * no mapping present. 379 */ 380 if (dma_buf_map_is_null(&gbo->map)) { 381 ret = ttm_bo_vmap(&gbo->bo, &gbo->map); 382 if (ret) 383 return ret; 384 } 385 386 out: 387 ++gbo->vmap_use_count; 388 *map = gbo->map; 389 390 return 0; 391 } 392 393 static void drm_gem_vram_kunmap_locked(struct drm_gem_vram_object *gbo, 394 struct dma_buf_map *map) 395 { 396 struct drm_device *dev = gbo->bo.base.dev; 397 398 if (drm_WARN_ON_ONCE(dev, !gbo->vmap_use_count)) 399 return; 400 401 if (drm_WARN_ON_ONCE(dev, !dma_buf_map_is_equal(&gbo->map, map))) 402 return; /* BUG: map not mapped from this BO */ 403 404 if (--gbo->vmap_use_count > 0) 405 return; 406 407 /* 408 * Permanently mapping and unmapping buffers adds overhead from 409 * updating the page tables and creates debugging output. Therefore, 410 * we delay the actual unmap operation until the BO gets evicted 411 * from memory. See drm_gem_vram_bo_driver_move_notify(). 412 */ 413 } 414 415 /** 416 * drm_gem_vram_vmap() - Pins and maps a GEM VRAM object into kernel address 417 * space 418 * @gbo: The GEM VRAM object to map 419 * @map: Returns the kernel virtual address of the VRAM GEM object's backing 420 * store. 421 * 422 * The vmap function pins a GEM VRAM object to its current location, either 423 * system or video memory, and maps its buffer into kernel address space. 424 * As pinned object cannot be relocated, you should avoid pinning objects 425 * permanently. Call drm_gem_vram_vunmap() with the returned address to 426 * unmap and unpin the GEM VRAM object. 427 * 428 * Returns: 429 * 0 on success, or a negative error code otherwise. 430 */ 431 int drm_gem_vram_vmap(struct drm_gem_vram_object *gbo, struct dma_buf_map *map) 432 { 433 int ret; 434 435 ret = ttm_bo_reserve(&gbo->bo, true, false, NULL); 436 if (ret) 437 return ret; 438 439 ret = drm_gem_vram_pin_locked(gbo, 0); 440 if (ret) 441 goto err_ttm_bo_unreserve; 442 ret = drm_gem_vram_kmap_locked(gbo, map); 443 if (ret) 444 goto err_drm_gem_vram_unpin_locked; 445 446 ttm_bo_unreserve(&gbo->bo); 447 448 return 0; 449 450 err_drm_gem_vram_unpin_locked: 451 drm_gem_vram_unpin_locked(gbo); 452 err_ttm_bo_unreserve: 453 ttm_bo_unreserve(&gbo->bo); 454 return ret; 455 } 456 EXPORT_SYMBOL(drm_gem_vram_vmap); 457 458 /** 459 * drm_gem_vram_vunmap() - Unmaps and unpins a GEM VRAM object 460 * @gbo: The GEM VRAM object to unmap 461 * @map: Kernel virtual address where the VRAM GEM object was mapped 462 * 463 * A call to drm_gem_vram_vunmap() unmaps and unpins a GEM VRAM buffer. See 464 * the documentation for drm_gem_vram_vmap() for more information. 465 */ 466 void drm_gem_vram_vunmap(struct drm_gem_vram_object *gbo, struct dma_buf_map *map) 467 { 468 int ret; 469 470 ret = ttm_bo_reserve(&gbo->bo, false, false, NULL); 471 if (WARN_ONCE(ret, "ttm_bo_reserve_failed(): ret=%d\n", ret)) 472 return; 473 474 drm_gem_vram_kunmap_locked(gbo, map); 475 drm_gem_vram_unpin_locked(gbo); 476 477 ttm_bo_unreserve(&gbo->bo); 478 } 479 EXPORT_SYMBOL(drm_gem_vram_vunmap); 480 481 /** 482 * drm_gem_vram_fill_create_dumb() - \ 483 Helper for implementing &struct drm_driver.dumb_create 484 * @file: the DRM file 485 * @dev: the DRM device 486 * @pg_align: the buffer's alignment in multiples of the page size 487 * @pitch_align: the scanline's alignment in powers of 2 488 * @args: the arguments as provided to \ 489 &struct drm_driver.dumb_create 490 * 491 * This helper function fills &struct drm_mode_create_dumb, which is used 492 * by &struct drm_driver.dumb_create. Implementations of this interface 493 * should forwards their arguments to this helper, plus the driver-specific 494 * parameters. 495 * 496 * Returns: 497 * 0 on success, or 498 * a negative error code otherwise. 499 */ 500 int drm_gem_vram_fill_create_dumb(struct drm_file *file, 501 struct drm_device *dev, 502 unsigned long pg_align, 503 unsigned long pitch_align, 504 struct drm_mode_create_dumb *args) 505 { 506 size_t pitch, size; 507 struct drm_gem_vram_object *gbo; 508 int ret; 509 u32 handle; 510 511 pitch = args->width * DIV_ROUND_UP(args->bpp, 8); 512 if (pitch_align) { 513 if (WARN_ON_ONCE(!is_power_of_2(pitch_align))) 514 return -EINVAL; 515 pitch = ALIGN(pitch, pitch_align); 516 } 517 size = pitch * args->height; 518 519 size = roundup(size, PAGE_SIZE); 520 if (!size) 521 return -EINVAL; 522 523 gbo = drm_gem_vram_create(dev, size, pg_align); 524 if (IS_ERR(gbo)) 525 return PTR_ERR(gbo); 526 527 ret = drm_gem_handle_create(file, &gbo->bo.base, &handle); 528 if (ret) 529 goto err_drm_gem_object_put; 530 531 drm_gem_object_put(&gbo->bo.base); 532 533 args->pitch = pitch; 534 args->size = size; 535 args->handle = handle; 536 537 return 0; 538 539 err_drm_gem_object_put: 540 drm_gem_object_put(&gbo->bo.base); 541 return ret; 542 } 543 EXPORT_SYMBOL(drm_gem_vram_fill_create_dumb); 544 545 /* 546 * Helpers for struct ttm_device_funcs 547 */ 548 549 static bool drm_is_gem_vram(struct ttm_buffer_object *bo) 550 { 551 return (bo->destroy == ttm_buffer_object_destroy); 552 } 553 554 static void drm_gem_vram_bo_driver_evict_flags(struct drm_gem_vram_object *gbo, 555 struct ttm_placement *pl) 556 { 557 drm_gem_vram_placement(gbo, DRM_GEM_VRAM_PL_FLAG_SYSTEM); 558 *pl = gbo->placement; 559 } 560 561 static void drm_gem_vram_bo_driver_move_notify(struct drm_gem_vram_object *gbo) 562 { 563 struct ttm_buffer_object *bo = &gbo->bo; 564 struct drm_device *dev = bo->base.dev; 565 566 if (drm_WARN_ON_ONCE(dev, gbo->vmap_use_count)) 567 return; 568 569 ttm_bo_vunmap(bo, &gbo->map); 570 dma_buf_map_clear(&gbo->map); /* explicitly clear mapping for next vmap call */ 571 } 572 573 static int drm_gem_vram_bo_driver_move(struct drm_gem_vram_object *gbo, 574 bool evict, 575 struct ttm_operation_ctx *ctx, 576 struct ttm_resource *new_mem) 577 { 578 drm_gem_vram_bo_driver_move_notify(gbo); 579 return ttm_bo_move_memcpy(&gbo->bo, ctx, new_mem); 580 } 581 582 /* 583 * Helpers for struct drm_gem_object_funcs 584 */ 585 586 /** 587 * drm_gem_vram_object_free() - \ 588 Implements &struct drm_gem_object_funcs.free 589 * @gem: GEM object. Refers to &struct drm_gem_vram_object.gem 590 */ 591 static void drm_gem_vram_object_free(struct drm_gem_object *gem) 592 { 593 struct drm_gem_vram_object *gbo = drm_gem_vram_of_gem(gem); 594 595 drm_gem_vram_put(gbo); 596 } 597 598 /* 599 * Helpers for dump buffers 600 */ 601 602 /** 603 * drm_gem_vram_driver_dumb_create() - \ 604 Implements &struct drm_driver.dumb_create 605 * @file: the DRM file 606 * @dev: the DRM device 607 * @args: the arguments as provided to \ 608 &struct drm_driver.dumb_create 609 * 610 * This function requires the driver to use @drm_device.vram_mm for its 611 * instance of VRAM MM. 612 * 613 * Returns: 614 * 0 on success, or 615 * a negative error code otherwise. 616 */ 617 int drm_gem_vram_driver_dumb_create(struct drm_file *file, 618 struct drm_device *dev, 619 struct drm_mode_create_dumb *args) 620 { 621 if (WARN_ONCE(!dev->vram_mm, "VRAM MM not initialized")) 622 return -EINVAL; 623 624 return drm_gem_vram_fill_create_dumb(file, dev, 0, 0, args); 625 } 626 EXPORT_SYMBOL(drm_gem_vram_driver_dumb_create); 627 628 /* 629 * Helpers for struct drm_plane_helper_funcs 630 */ 631 632 /** 633 * drm_gem_vram_plane_helper_prepare_fb() - \ 634 * Implements &struct drm_plane_helper_funcs.prepare_fb 635 * @plane: a DRM plane 636 * @new_state: the plane's new state 637 * 638 * During plane updates, this function sets the plane's fence and 639 * pins the GEM VRAM objects of the plane's new framebuffer to VRAM. 640 * Call drm_gem_vram_plane_helper_cleanup_fb() to unpin them. 641 * 642 * Returns: 643 * 0 on success, or 644 * a negative errno code otherwise. 645 */ 646 int 647 drm_gem_vram_plane_helper_prepare_fb(struct drm_plane *plane, 648 struct drm_plane_state *new_state) 649 { 650 size_t i; 651 struct drm_gem_vram_object *gbo; 652 int ret; 653 654 if (!new_state->fb) 655 return 0; 656 657 for (i = 0; i < ARRAY_SIZE(new_state->fb->obj); ++i) { 658 if (!new_state->fb->obj[i]) 659 continue; 660 gbo = drm_gem_vram_of_gem(new_state->fb->obj[i]); 661 ret = drm_gem_vram_pin(gbo, DRM_GEM_VRAM_PL_FLAG_VRAM); 662 if (ret) 663 goto err_drm_gem_vram_unpin; 664 } 665 666 ret = drm_gem_plane_helper_prepare_fb(plane, new_state); 667 if (ret) 668 goto err_drm_gem_vram_unpin; 669 670 return 0; 671 672 err_drm_gem_vram_unpin: 673 while (i) { 674 --i; 675 gbo = drm_gem_vram_of_gem(new_state->fb->obj[i]); 676 drm_gem_vram_unpin(gbo); 677 } 678 return ret; 679 } 680 EXPORT_SYMBOL(drm_gem_vram_plane_helper_prepare_fb); 681 682 /** 683 * drm_gem_vram_plane_helper_cleanup_fb() - \ 684 * Implements &struct drm_plane_helper_funcs.cleanup_fb 685 * @plane: a DRM plane 686 * @old_state: the plane's old state 687 * 688 * During plane updates, this function unpins the GEM VRAM 689 * objects of the plane's old framebuffer from VRAM. Complements 690 * drm_gem_vram_plane_helper_prepare_fb(). 691 */ 692 void 693 drm_gem_vram_plane_helper_cleanup_fb(struct drm_plane *plane, 694 struct drm_plane_state *old_state) 695 { 696 size_t i; 697 struct drm_gem_vram_object *gbo; 698 699 if (!old_state->fb) 700 return; 701 702 for (i = 0; i < ARRAY_SIZE(old_state->fb->obj); ++i) { 703 if (!old_state->fb->obj[i]) 704 continue; 705 gbo = drm_gem_vram_of_gem(old_state->fb->obj[i]); 706 drm_gem_vram_unpin(gbo); 707 } 708 } 709 EXPORT_SYMBOL(drm_gem_vram_plane_helper_cleanup_fb); 710 711 /* 712 * Helpers for struct drm_simple_display_pipe_funcs 713 */ 714 715 /** 716 * drm_gem_vram_simple_display_pipe_prepare_fb() - \ 717 * Implements &struct drm_simple_display_pipe_funcs.prepare_fb 718 * @pipe: a simple display pipe 719 * @new_state: the plane's new state 720 * 721 * During plane updates, this function pins the GEM VRAM 722 * objects of the plane's new framebuffer to VRAM. Call 723 * drm_gem_vram_simple_display_pipe_cleanup_fb() to unpin them. 724 * 725 * Returns: 726 * 0 on success, or 727 * a negative errno code otherwise. 728 */ 729 int drm_gem_vram_simple_display_pipe_prepare_fb( 730 struct drm_simple_display_pipe *pipe, 731 struct drm_plane_state *new_state) 732 { 733 return drm_gem_vram_plane_helper_prepare_fb(&pipe->plane, new_state); 734 } 735 EXPORT_SYMBOL(drm_gem_vram_simple_display_pipe_prepare_fb); 736 737 /** 738 * drm_gem_vram_simple_display_pipe_cleanup_fb() - \ 739 * Implements &struct drm_simple_display_pipe_funcs.cleanup_fb 740 * @pipe: a simple display pipe 741 * @old_state: the plane's old state 742 * 743 * During plane updates, this function unpins the GEM VRAM 744 * objects of the plane's old framebuffer from VRAM. Complements 745 * drm_gem_vram_simple_display_pipe_prepare_fb(). 746 */ 747 void drm_gem_vram_simple_display_pipe_cleanup_fb( 748 struct drm_simple_display_pipe *pipe, 749 struct drm_plane_state *old_state) 750 { 751 drm_gem_vram_plane_helper_cleanup_fb(&pipe->plane, old_state); 752 } 753 EXPORT_SYMBOL(drm_gem_vram_simple_display_pipe_cleanup_fb); 754 755 /* 756 * PRIME helpers 757 */ 758 759 /** 760 * drm_gem_vram_object_pin() - \ 761 Implements &struct drm_gem_object_funcs.pin 762 * @gem: The GEM object to pin 763 * 764 * Returns: 765 * 0 on success, or 766 * a negative errno code otherwise. 767 */ 768 static int drm_gem_vram_object_pin(struct drm_gem_object *gem) 769 { 770 struct drm_gem_vram_object *gbo = drm_gem_vram_of_gem(gem); 771 772 /* Fbdev console emulation is the use case of these PRIME 773 * helpers. This may involve updating a hardware buffer from 774 * a shadow FB. We pin the buffer to it's current location 775 * (either video RAM or system memory) to prevent it from 776 * being relocated during the update operation. If you require 777 * the buffer to be pinned to VRAM, implement a callback that 778 * sets the flags accordingly. 779 */ 780 return drm_gem_vram_pin(gbo, 0); 781 } 782 783 /** 784 * drm_gem_vram_object_unpin() - \ 785 Implements &struct drm_gem_object_funcs.unpin 786 * @gem: The GEM object to unpin 787 */ 788 static void drm_gem_vram_object_unpin(struct drm_gem_object *gem) 789 { 790 struct drm_gem_vram_object *gbo = drm_gem_vram_of_gem(gem); 791 792 drm_gem_vram_unpin(gbo); 793 } 794 795 /** 796 * drm_gem_vram_object_vmap() - 797 * Implements &struct drm_gem_object_funcs.vmap 798 * @gem: The GEM object to map 799 * @map: Returns the kernel virtual address of the VRAM GEM object's backing 800 * store. 801 * 802 * Returns: 803 * 0 on success, or a negative error code otherwise. 804 */ 805 static int drm_gem_vram_object_vmap(struct drm_gem_object *gem, struct dma_buf_map *map) 806 { 807 struct drm_gem_vram_object *gbo = drm_gem_vram_of_gem(gem); 808 809 return drm_gem_vram_vmap(gbo, map); 810 } 811 812 /** 813 * drm_gem_vram_object_vunmap() - 814 * Implements &struct drm_gem_object_funcs.vunmap 815 * @gem: The GEM object to unmap 816 * @map: Kernel virtual address where the VRAM GEM object was mapped 817 */ 818 static void drm_gem_vram_object_vunmap(struct drm_gem_object *gem, struct dma_buf_map *map) 819 { 820 struct drm_gem_vram_object *gbo = drm_gem_vram_of_gem(gem); 821 822 drm_gem_vram_vunmap(gbo, map); 823 } 824 825 /* 826 * GEM object funcs 827 */ 828 829 static const struct drm_gem_object_funcs drm_gem_vram_object_funcs = { 830 .free = drm_gem_vram_object_free, 831 .pin = drm_gem_vram_object_pin, 832 .unpin = drm_gem_vram_object_unpin, 833 .vmap = drm_gem_vram_object_vmap, 834 .vunmap = drm_gem_vram_object_vunmap, 835 .mmap = drm_gem_ttm_mmap, 836 .print_info = drm_gem_ttm_print_info, 837 }; 838 839 /* 840 * VRAM memory manager 841 */ 842 843 /* 844 * TTM TT 845 */ 846 847 static void bo_driver_ttm_tt_destroy(struct ttm_device *bdev, struct ttm_tt *tt) 848 { 849 ttm_tt_fini(tt); 850 kfree(tt); 851 } 852 853 /* 854 * TTM BO device 855 */ 856 857 static struct ttm_tt *bo_driver_ttm_tt_create(struct ttm_buffer_object *bo, 858 uint32_t page_flags) 859 { 860 struct ttm_tt *tt; 861 int ret; 862 863 tt = kzalloc(sizeof(*tt), GFP_KERNEL); 864 if (!tt) 865 return NULL; 866 867 ret = ttm_tt_init(tt, bo, page_flags, ttm_cached); 868 if (ret < 0) 869 goto err_ttm_tt_init; 870 871 return tt; 872 873 err_ttm_tt_init: 874 kfree(tt); 875 return NULL; 876 } 877 878 static void bo_driver_evict_flags(struct ttm_buffer_object *bo, 879 struct ttm_placement *placement) 880 { 881 struct drm_gem_vram_object *gbo; 882 883 /* TTM may pass BOs that are not GEM VRAM BOs. */ 884 if (!drm_is_gem_vram(bo)) 885 return; 886 887 gbo = drm_gem_vram_of_bo(bo); 888 889 drm_gem_vram_bo_driver_evict_flags(gbo, placement); 890 } 891 892 static void bo_driver_delete_mem_notify(struct ttm_buffer_object *bo) 893 { 894 struct drm_gem_vram_object *gbo; 895 896 /* TTM may pass BOs that are not GEM VRAM BOs. */ 897 if (!drm_is_gem_vram(bo)) 898 return; 899 900 gbo = drm_gem_vram_of_bo(bo); 901 902 drm_gem_vram_bo_driver_move_notify(gbo); 903 } 904 905 static int bo_driver_move(struct ttm_buffer_object *bo, 906 bool evict, 907 struct ttm_operation_ctx *ctx, 908 struct ttm_resource *new_mem, 909 struct ttm_place *hop) 910 { 911 struct drm_gem_vram_object *gbo; 912 913 gbo = drm_gem_vram_of_bo(bo); 914 915 return drm_gem_vram_bo_driver_move(gbo, evict, ctx, new_mem); 916 } 917 918 static int bo_driver_io_mem_reserve(struct ttm_device *bdev, 919 struct ttm_resource *mem) 920 { 921 struct drm_vram_mm *vmm = drm_vram_mm_of_bdev(bdev); 922 923 switch (mem->mem_type) { 924 case TTM_PL_SYSTEM: /* nothing to do */ 925 break; 926 case TTM_PL_VRAM: 927 mem->bus.offset = (mem->start << PAGE_SHIFT) + vmm->vram_base; 928 mem->bus.is_iomem = true; 929 mem->bus.caching = ttm_write_combined; 930 break; 931 default: 932 return -EINVAL; 933 } 934 935 return 0; 936 } 937 938 static struct ttm_device_funcs bo_driver = { 939 .ttm_tt_create = bo_driver_ttm_tt_create, 940 .ttm_tt_destroy = bo_driver_ttm_tt_destroy, 941 .eviction_valuable = ttm_bo_eviction_valuable, 942 .evict_flags = bo_driver_evict_flags, 943 .move = bo_driver_move, 944 .delete_mem_notify = bo_driver_delete_mem_notify, 945 .io_mem_reserve = bo_driver_io_mem_reserve, 946 }; 947 948 /* 949 * struct drm_vram_mm 950 */ 951 952 static int drm_vram_mm_debugfs(struct seq_file *m, void *data) 953 { 954 struct drm_info_node *node = (struct drm_info_node *) m->private; 955 struct drm_vram_mm *vmm = node->minor->dev->vram_mm; 956 struct ttm_resource_manager *man = ttm_manager_type(&vmm->bdev, TTM_PL_VRAM); 957 struct drm_printer p = drm_seq_file_printer(m); 958 959 ttm_resource_manager_debug(man, &p); 960 return 0; 961 } 962 963 static const struct drm_info_list drm_vram_mm_debugfs_list[] = { 964 { "vram-mm", drm_vram_mm_debugfs, 0, NULL }, 965 }; 966 967 /** 968 * drm_vram_mm_debugfs_init() - Register VRAM MM debugfs file. 969 * 970 * @minor: drm minor device. 971 * 972 */ 973 void drm_vram_mm_debugfs_init(struct drm_minor *minor) 974 { 975 drm_debugfs_create_files(drm_vram_mm_debugfs_list, 976 ARRAY_SIZE(drm_vram_mm_debugfs_list), 977 minor->debugfs_root, minor); 978 } 979 EXPORT_SYMBOL(drm_vram_mm_debugfs_init); 980 981 static int drm_vram_mm_init(struct drm_vram_mm *vmm, struct drm_device *dev, 982 uint64_t vram_base, size_t vram_size) 983 { 984 int ret; 985 986 vmm->vram_base = vram_base; 987 vmm->vram_size = vram_size; 988 989 ret = ttm_device_init(&vmm->bdev, &bo_driver, dev->dev, 990 dev->anon_inode->i_mapping, 991 dev->vma_offset_manager, 992 false, true); 993 if (ret) 994 return ret; 995 996 ret = ttm_range_man_init(&vmm->bdev, TTM_PL_VRAM, 997 false, vram_size >> PAGE_SHIFT); 998 if (ret) 999 return ret; 1000 1001 return 0; 1002 } 1003 1004 static void drm_vram_mm_cleanup(struct drm_vram_mm *vmm) 1005 { 1006 ttm_range_man_fini(&vmm->bdev, TTM_PL_VRAM); 1007 ttm_device_fini(&vmm->bdev); 1008 } 1009 1010 /* 1011 * Helpers for integration with struct drm_device 1012 */ 1013 1014 static struct drm_vram_mm *drm_vram_helper_alloc_mm(struct drm_device *dev, uint64_t vram_base, 1015 size_t vram_size) 1016 { 1017 int ret; 1018 1019 if (WARN_ON(dev->vram_mm)) 1020 return dev->vram_mm; 1021 1022 dev->vram_mm = kzalloc(sizeof(*dev->vram_mm), GFP_KERNEL); 1023 if (!dev->vram_mm) 1024 return ERR_PTR(-ENOMEM); 1025 1026 ret = drm_vram_mm_init(dev->vram_mm, dev, vram_base, vram_size); 1027 if (ret) 1028 goto err_kfree; 1029 1030 return dev->vram_mm; 1031 1032 err_kfree: 1033 kfree(dev->vram_mm); 1034 dev->vram_mm = NULL; 1035 return ERR_PTR(ret); 1036 } 1037 1038 static void drm_vram_helper_release_mm(struct drm_device *dev) 1039 { 1040 if (!dev->vram_mm) 1041 return; 1042 1043 drm_vram_mm_cleanup(dev->vram_mm); 1044 kfree(dev->vram_mm); 1045 dev->vram_mm = NULL; 1046 } 1047 1048 static void drm_vram_mm_release(struct drm_device *dev, void *ptr) 1049 { 1050 drm_vram_helper_release_mm(dev); 1051 } 1052 1053 /** 1054 * drmm_vram_helper_init - Initializes a device's instance of 1055 * &struct drm_vram_mm 1056 * @dev: the DRM device 1057 * @vram_base: the base address of the video memory 1058 * @vram_size: the size of the video memory in bytes 1059 * 1060 * Creates a new instance of &struct drm_vram_mm and stores it in 1061 * struct &drm_device.vram_mm. The instance is auto-managed and cleaned 1062 * up as part of device cleanup. Calling this function multiple times 1063 * will generate an error message. 1064 * 1065 * Returns: 1066 * 0 on success, or a negative errno code otherwise. 1067 */ 1068 int drmm_vram_helper_init(struct drm_device *dev, uint64_t vram_base, 1069 size_t vram_size) 1070 { 1071 struct drm_vram_mm *vram_mm; 1072 1073 if (drm_WARN_ON_ONCE(dev, dev->vram_mm)) 1074 return 0; 1075 1076 vram_mm = drm_vram_helper_alloc_mm(dev, vram_base, vram_size); 1077 if (IS_ERR(vram_mm)) 1078 return PTR_ERR(vram_mm); 1079 return drmm_add_action_or_reset(dev, drm_vram_mm_release, NULL); 1080 } 1081 EXPORT_SYMBOL(drmm_vram_helper_init); 1082 1083 /* 1084 * Mode-config helpers 1085 */ 1086 1087 static enum drm_mode_status 1088 drm_vram_helper_mode_valid_internal(struct drm_device *dev, 1089 const struct drm_display_mode *mode, 1090 unsigned long max_bpp) 1091 { 1092 struct drm_vram_mm *vmm = dev->vram_mm; 1093 unsigned long fbsize, fbpages, max_fbpages; 1094 1095 if (WARN_ON(!dev->vram_mm)) 1096 return MODE_BAD; 1097 1098 max_fbpages = (vmm->vram_size / 2) >> PAGE_SHIFT; 1099 1100 fbsize = mode->hdisplay * mode->vdisplay * max_bpp; 1101 fbpages = DIV_ROUND_UP(fbsize, PAGE_SIZE); 1102 1103 if (fbpages > max_fbpages) 1104 return MODE_MEM; 1105 1106 return MODE_OK; 1107 } 1108 1109 /** 1110 * drm_vram_helper_mode_valid - Tests if a display mode's 1111 * framebuffer fits into the available video memory. 1112 * @dev: the DRM device 1113 * @mode: the mode to test 1114 * 1115 * This function tests if enough video memory is available for using the 1116 * specified display mode. Atomic modesetting requires importing the 1117 * designated framebuffer into video memory before evicting the active 1118 * one. Hence, any framebuffer may consume at most half of the available 1119 * VRAM. Display modes that require a larger framebuffer can not be used, 1120 * even if the CRTC does support them. Each framebuffer is assumed to 1121 * have 32-bit color depth. 1122 * 1123 * Note: 1124 * The function can only test if the display mode is supported in 1125 * general. If there are too many framebuffers pinned to video memory, 1126 * a display mode may still not be usable in practice. The color depth of 1127 * 32-bit fits all current use case. A more flexible test can be added 1128 * when necessary. 1129 * 1130 * Returns: 1131 * MODE_OK if the display mode is supported, or an error code of type 1132 * enum drm_mode_status otherwise. 1133 */ 1134 enum drm_mode_status 1135 drm_vram_helper_mode_valid(struct drm_device *dev, 1136 const struct drm_display_mode *mode) 1137 { 1138 static const unsigned long max_bpp = 4; /* DRM_FORMAT_XRGB8888 */ 1139 1140 return drm_vram_helper_mode_valid_internal(dev, mode, max_bpp); 1141 } 1142 EXPORT_SYMBOL(drm_vram_helper_mode_valid); 1143 1144 MODULE_DESCRIPTION("DRM VRAM memory-management helpers"); 1145 MODULE_LICENSE("GPL"); 1146