1 // SPDX-License-Identifier: GPL-2.0 OR MIT 2 /************************************************************************** 3 * 4 * Copyright 2009-2015 VMware, Inc., Palo Alto, CA., USA 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 21 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, 22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE 24 * USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28 #include "vmwgfx_drv.h" 29 #include <drm/ttm/ttm_bo_driver.h> 30 #include <drm/ttm/ttm_placement.h> 31 32 static const struct ttm_place vram_placement_flags = { 33 .fpfn = 0, 34 .lpfn = 0, 35 .mem_type = TTM_PL_VRAM, 36 .flags = 0 37 }; 38 39 static const struct ttm_place sys_placement_flags = { 40 .fpfn = 0, 41 .lpfn = 0, 42 .mem_type = TTM_PL_SYSTEM, 43 .flags = 0 44 }; 45 46 static const struct ttm_place gmr_placement_flags = { 47 .fpfn = 0, 48 .lpfn = 0, 49 .mem_type = VMW_PL_GMR, 50 .flags = 0 51 }; 52 53 static const struct ttm_place mob_placement_flags = { 54 .fpfn = 0, 55 .lpfn = 0, 56 .mem_type = VMW_PL_MOB, 57 .flags = 0 58 }; 59 60 struct ttm_placement vmw_vram_placement = { 61 .num_placement = 1, 62 .placement = &vram_placement_flags, 63 .num_busy_placement = 1, 64 .busy_placement = &vram_placement_flags 65 }; 66 67 static const struct ttm_place vram_gmr_placement_flags[] = { 68 { 69 .fpfn = 0, 70 .lpfn = 0, 71 .mem_type = TTM_PL_VRAM, 72 .flags = 0 73 }, { 74 .fpfn = 0, 75 .lpfn = 0, 76 .mem_type = VMW_PL_GMR, 77 .flags = 0 78 } 79 }; 80 81 static const struct ttm_place gmr_vram_placement_flags[] = { 82 { 83 .fpfn = 0, 84 .lpfn = 0, 85 .mem_type = VMW_PL_GMR, 86 .flags = 0 87 }, { 88 .fpfn = 0, 89 .lpfn = 0, 90 .mem_type = TTM_PL_VRAM, 91 .flags = 0 92 } 93 }; 94 95 struct ttm_placement vmw_vram_gmr_placement = { 96 .num_placement = 2, 97 .placement = vram_gmr_placement_flags, 98 .num_busy_placement = 1, 99 .busy_placement = &gmr_placement_flags 100 }; 101 102 struct ttm_placement vmw_vram_sys_placement = { 103 .num_placement = 1, 104 .placement = &vram_placement_flags, 105 .num_busy_placement = 1, 106 .busy_placement = &sys_placement_flags 107 }; 108 109 struct ttm_placement vmw_sys_placement = { 110 .num_placement = 1, 111 .placement = &sys_placement_flags, 112 .num_busy_placement = 1, 113 .busy_placement = &sys_placement_flags 114 }; 115 116 static const struct ttm_place evictable_placement_flags[] = { 117 { 118 .fpfn = 0, 119 .lpfn = 0, 120 .mem_type = TTM_PL_SYSTEM, 121 .flags = 0 122 }, { 123 .fpfn = 0, 124 .lpfn = 0, 125 .mem_type = TTM_PL_VRAM, 126 .flags = 0 127 }, { 128 .fpfn = 0, 129 .lpfn = 0, 130 .mem_type = VMW_PL_GMR, 131 .flags = 0 132 }, { 133 .fpfn = 0, 134 .lpfn = 0, 135 .mem_type = VMW_PL_MOB, 136 .flags = 0 137 } 138 }; 139 140 static const struct ttm_place nonfixed_placement_flags[] = { 141 { 142 .fpfn = 0, 143 .lpfn = 0, 144 .mem_type = TTM_PL_SYSTEM, 145 .flags = 0 146 }, { 147 .fpfn = 0, 148 .lpfn = 0, 149 .mem_type = VMW_PL_GMR, 150 .flags = 0 151 }, { 152 .fpfn = 0, 153 .lpfn = 0, 154 .mem_type = VMW_PL_MOB, 155 .flags = 0 156 } 157 }; 158 159 struct ttm_placement vmw_evictable_placement = { 160 .num_placement = 4, 161 .placement = evictable_placement_flags, 162 .num_busy_placement = 1, 163 .busy_placement = &sys_placement_flags 164 }; 165 166 struct ttm_placement vmw_srf_placement = { 167 .num_placement = 1, 168 .num_busy_placement = 2, 169 .placement = &gmr_placement_flags, 170 .busy_placement = gmr_vram_placement_flags 171 }; 172 173 struct ttm_placement vmw_mob_placement = { 174 .num_placement = 1, 175 .num_busy_placement = 1, 176 .placement = &mob_placement_flags, 177 .busy_placement = &mob_placement_flags 178 }; 179 180 struct ttm_placement vmw_nonfixed_placement = { 181 .num_placement = 3, 182 .placement = nonfixed_placement_flags, 183 .num_busy_placement = 1, 184 .busy_placement = &sys_placement_flags 185 }; 186 187 struct vmw_ttm_tt { 188 struct ttm_tt dma_ttm; 189 struct vmw_private *dev_priv; 190 int gmr_id; 191 struct vmw_mob *mob; 192 int mem_type; 193 struct sg_table sgt; 194 struct vmw_sg_table vsgt; 195 uint64_t sg_alloc_size; 196 bool mapped; 197 bool bound; 198 }; 199 200 const size_t vmw_tt_size = sizeof(struct vmw_ttm_tt); 201 202 /** 203 * __vmw_piter_non_sg_next: Helper functions to advance 204 * a struct vmw_piter iterator. 205 * 206 * @viter: Pointer to the iterator. 207 * 208 * These functions return false if past the end of the list, 209 * true otherwise. Functions are selected depending on the current 210 * DMA mapping mode. 211 */ 212 static bool __vmw_piter_non_sg_next(struct vmw_piter *viter) 213 { 214 return ++(viter->i) < viter->num_pages; 215 } 216 217 static bool __vmw_piter_sg_next(struct vmw_piter *viter) 218 { 219 bool ret = __vmw_piter_non_sg_next(viter); 220 221 return __sg_page_iter_dma_next(&viter->iter) && ret; 222 } 223 224 225 static dma_addr_t __vmw_piter_dma_addr(struct vmw_piter *viter) 226 { 227 return viter->addrs[viter->i]; 228 } 229 230 static dma_addr_t __vmw_piter_sg_addr(struct vmw_piter *viter) 231 { 232 return sg_page_iter_dma_address(&viter->iter); 233 } 234 235 236 /** 237 * vmw_piter_start - Initialize a struct vmw_piter. 238 * 239 * @viter: Pointer to the iterator to initialize 240 * @vsgt: Pointer to a struct vmw_sg_table to initialize from 241 * @p_offset: Pointer offset used to update current array position 242 * 243 * Note that we're following the convention of __sg_page_iter_start, so that 244 * the iterator doesn't point to a valid page after initialization; it has 245 * to be advanced one step first. 246 */ 247 void vmw_piter_start(struct vmw_piter *viter, const struct vmw_sg_table *vsgt, 248 unsigned long p_offset) 249 { 250 viter->i = p_offset - 1; 251 viter->num_pages = vsgt->num_pages; 252 viter->pages = vsgt->pages; 253 switch (vsgt->mode) { 254 case vmw_dma_alloc_coherent: 255 viter->next = &__vmw_piter_non_sg_next; 256 viter->dma_address = &__vmw_piter_dma_addr; 257 viter->addrs = vsgt->addrs; 258 break; 259 case vmw_dma_map_populate: 260 case vmw_dma_map_bind: 261 viter->next = &__vmw_piter_sg_next; 262 viter->dma_address = &__vmw_piter_sg_addr; 263 __sg_page_iter_start(&viter->iter.base, vsgt->sgt->sgl, 264 vsgt->sgt->orig_nents, p_offset); 265 break; 266 default: 267 BUG(); 268 } 269 } 270 271 /** 272 * vmw_ttm_unmap_from_dma - unmap device addresses previsouly mapped for 273 * TTM pages 274 * 275 * @vmw_tt: Pointer to a struct vmw_ttm_backend 276 * 277 * Used to free dma mappings previously mapped by vmw_ttm_map_for_dma. 278 */ 279 static void vmw_ttm_unmap_from_dma(struct vmw_ttm_tt *vmw_tt) 280 { 281 struct device *dev = vmw_tt->dev_priv->drm.dev; 282 283 dma_unmap_sgtable(dev, &vmw_tt->sgt, DMA_BIDIRECTIONAL, 0); 284 vmw_tt->sgt.nents = vmw_tt->sgt.orig_nents; 285 } 286 287 /** 288 * vmw_ttm_map_for_dma - map TTM pages to get device addresses 289 * 290 * @vmw_tt: Pointer to a struct vmw_ttm_backend 291 * 292 * This function is used to get device addresses from the kernel DMA layer. 293 * However, it's violating the DMA API in that when this operation has been 294 * performed, it's illegal for the CPU to write to the pages without first 295 * unmapping the DMA mappings, or calling dma_sync_sg_for_cpu(). It is 296 * therefore only legal to call this function if we know that the function 297 * dma_sync_sg_for_cpu() is a NOP, and dma_sync_sg_for_device() is at most 298 * a CPU write buffer flush. 299 */ 300 static int vmw_ttm_map_for_dma(struct vmw_ttm_tt *vmw_tt) 301 { 302 struct device *dev = vmw_tt->dev_priv->drm.dev; 303 304 return dma_map_sgtable(dev, &vmw_tt->sgt, DMA_BIDIRECTIONAL, 0); 305 } 306 307 /** 308 * vmw_ttm_map_dma - Make sure TTM pages are visible to the device 309 * 310 * @vmw_tt: Pointer to a struct vmw_ttm_tt 311 * 312 * Select the correct function for and make sure the TTM pages are 313 * visible to the device. Allocate storage for the device mappings. 314 * If a mapping has already been performed, indicated by the storage 315 * pointer being non NULL, the function returns success. 316 */ 317 static int vmw_ttm_map_dma(struct vmw_ttm_tt *vmw_tt) 318 { 319 struct vmw_private *dev_priv = vmw_tt->dev_priv; 320 struct ttm_mem_global *glob = vmw_mem_glob(dev_priv); 321 struct vmw_sg_table *vsgt = &vmw_tt->vsgt; 322 struct ttm_operation_ctx ctx = { 323 .interruptible = true, 324 .no_wait_gpu = false 325 }; 326 struct vmw_piter iter; 327 dma_addr_t old; 328 int ret = 0; 329 static size_t sgl_size; 330 static size_t sgt_size; 331 332 if (vmw_tt->mapped) 333 return 0; 334 335 vsgt->mode = dev_priv->map_mode; 336 vsgt->pages = vmw_tt->dma_ttm.pages; 337 vsgt->num_pages = vmw_tt->dma_ttm.num_pages; 338 vsgt->addrs = vmw_tt->dma_ttm.dma_address; 339 vsgt->sgt = &vmw_tt->sgt; 340 341 switch (dev_priv->map_mode) { 342 case vmw_dma_map_bind: 343 case vmw_dma_map_populate: 344 if (unlikely(!sgl_size)) { 345 sgl_size = ttm_round_pot(sizeof(struct scatterlist)); 346 sgt_size = ttm_round_pot(sizeof(struct sg_table)); 347 } 348 vmw_tt->sg_alloc_size = sgt_size + sgl_size * vsgt->num_pages; 349 ret = ttm_mem_global_alloc(glob, vmw_tt->sg_alloc_size, &ctx); 350 if (unlikely(ret != 0)) 351 return ret; 352 353 ret = sg_alloc_table_from_pages_segment( 354 &vmw_tt->sgt, vsgt->pages, vsgt->num_pages, 0, 355 (unsigned long)vsgt->num_pages << PAGE_SHIFT, 356 dma_get_max_seg_size(dev_priv->drm.dev), GFP_KERNEL); 357 if (ret) 358 goto out_sg_alloc_fail; 359 360 if (vsgt->num_pages > vmw_tt->sgt.orig_nents) { 361 uint64_t over_alloc = 362 sgl_size * (vsgt->num_pages - 363 vmw_tt->sgt.orig_nents); 364 365 ttm_mem_global_free(glob, over_alloc); 366 vmw_tt->sg_alloc_size -= over_alloc; 367 } 368 369 ret = vmw_ttm_map_for_dma(vmw_tt); 370 if (unlikely(ret != 0)) 371 goto out_map_fail; 372 373 break; 374 default: 375 break; 376 } 377 378 old = ~((dma_addr_t) 0); 379 vmw_tt->vsgt.num_regions = 0; 380 for (vmw_piter_start(&iter, vsgt, 0); vmw_piter_next(&iter);) { 381 dma_addr_t cur = vmw_piter_dma_addr(&iter); 382 383 if (cur != old + PAGE_SIZE) 384 vmw_tt->vsgt.num_regions++; 385 old = cur; 386 } 387 388 vmw_tt->mapped = true; 389 return 0; 390 391 out_map_fail: 392 sg_free_table(vmw_tt->vsgt.sgt); 393 vmw_tt->vsgt.sgt = NULL; 394 out_sg_alloc_fail: 395 ttm_mem_global_free(glob, vmw_tt->sg_alloc_size); 396 return ret; 397 } 398 399 /** 400 * vmw_ttm_unmap_dma - Tear down any TTM page device mappings 401 * 402 * @vmw_tt: Pointer to a struct vmw_ttm_tt 403 * 404 * Tear down any previously set up device DMA mappings and free 405 * any storage space allocated for them. If there are no mappings set up, 406 * this function is a NOP. 407 */ 408 static void vmw_ttm_unmap_dma(struct vmw_ttm_tt *vmw_tt) 409 { 410 struct vmw_private *dev_priv = vmw_tt->dev_priv; 411 412 if (!vmw_tt->vsgt.sgt) 413 return; 414 415 switch (dev_priv->map_mode) { 416 case vmw_dma_map_bind: 417 case vmw_dma_map_populate: 418 vmw_ttm_unmap_from_dma(vmw_tt); 419 sg_free_table(vmw_tt->vsgt.sgt); 420 vmw_tt->vsgt.sgt = NULL; 421 ttm_mem_global_free(vmw_mem_glob(dev_priv), 422 vmw_tt->sg_alloc_size); 423 break; 424 default: 425 break; 426 } 427 vmw_tt->mapped = false; 428 } 429 430 /** 431 * vmw_bo_sg_table - Return a struct vmw_sg_table object for a 432 * TTM buffer object 433 * 434 * @bo: Pointer to a struct ttm_buffer_object 435 * 436 * Returns a pointer to a struct vmw_sg_table object. The object should 437 * not be freed after use. 438 * Note that for the device addresses to be valid, the buffer object must 439 * either be reserved or pinned. 440 */ 441 const struct vmw_sg_table *vmw_bo_sg_table(struct ttm_buffer_object *bo) 442 { 443 struct vmw_ttm_tt *vmw_tt = 444 container_of(bo->ttm, struct vmw_ttm_tt, dma_ttm); 445 446 return &vmw_tt->vsgt; 447 } 448 449 450 static int vmw_ttm_bind(struct ttm_device *bdev, 451 struct ttm_tt *ttm, struct ttm_resource *bo_mem) 452 { 453 struct vmw_ttm_tt *vmw_be = 454 container_of(ttm, struct vmw_ttm_tt, dma_ttm); 455 int ret = 0; 456 457 if (!bo_mem) 458 return -EINVAL; 459 460 if (vmw_be->bound) 461 return 0; 462 463 ret = vmw_ttm_map_dma(vmw_be); 464 if (unlikely(ret != 0)) 465 return ret; 466 467 vmw_be->gmr_id = bo_mem->start; 468 vmw_be->mem_type = bo_mem->mem_type; 469 470 switch (bo_mem->mem_type) { 471 case VMW_PL_GMR: 472 ret = vmw_gmr_bind(vmw_be->dev_priv, &vmw_be->vsgt, 473 ttm->num_pages, vmw_be->gmr_id); 474 break; 475 case VMW_PL_MOB: 476 if (unlikely(vmw_be->mob == NULL)) { 477 vmw_be->mob = 478 vmw_mob_create(ttm->num_pages); 479 if (unlikely(vmw_be->mob == NULL)) 480 return -ENOMEM; 481 } 482 483 ret = vmw_mob_bind(vmw_be->dev_priv, vmw_be->mob, 484 &vmw_be->vsgt, ttm->num_pages, 485 vmw_be->gmr_id); 486 break; 487 default: 488 BUG(); 489 } 490 vmw_be->bound = true; 491 return ret; 492 } 493 494 static void vmw_ttm_unbind(struct ttm_device *bdev, 495 struct ttm_tt *ttm) 496 { 497 struct vmw_ttm_tt *vmw_be = 498 container_of(ttm, struct vmw_ttm_tt, dma_ttm); 499 500 if (!vmw_be->bound) 501 return; 502 503 switch (vmw_be->mem_type) { 504 case VMW_PL_GMR: 505 vmw_gmr_unbind(vmw_be->dev_priv, vmw_be->gmr_id); 506 break; 507 case VMW_PL_MOB: 508 vmw_mob_unbind(vmw_be->dev_priv, vmw_be->mob); 509 break; 510 default: 511 BUG(); 512 } 513 514 if (vmw_be->dev_priv->map_mode == vmw_dma_map_bind) 515 vmw_ttm_unmap_dma(vmw_be); 516 vmw_be->bound = false; 517 } 518 519 520 static void vmw_ttm_destroy(struct ttm_device *bdev, struct ttm_tt *ttm) 521 { 522 struct vmw_ttm_tt *vmw_be = 523 container_of(ttm, struct vmw_ttm_tt, dma_ttm); 524 525 vmw_ttm_unbind(bdev, ttm); 526 ttm_tt_destroy_common(bdev, ttm); 527 vmw_ttm_unmap_dma(vmw_be); 528 if (vmw_be->dev_priv->map_mode == vmw_dma_alloc_coherent) 529 ttm_tt_fini(&vmw_be->dma_ttm); 530 else 531 ttm_tt_fini(ttm); 532 533 if (vmw_be->mob) 534 vmw_mob_destroy(vmw_be->mob); 535 536 kfree(vmw_be); 537 } 538 539 540 static int vmw_ttm_populate(struct ttm_device *bdev, 541 struct ttm_tt *ttm, struct ttm_operation_ctx *ctx) 542 { 543 unsigned int i; 544 int ret; 545 546 /* TODO: maybe completely drop this ? */ 547 if (ttm_tt_is_populated(ttm)) 548 return 0; 549 550 ret = ttm_pool_alloc(&bdev->pool, ttm, ctx); 551 if (ret) 552 return ret; 553 554 for (i = 0; i < ttm->num_pages; ++i) { 555 ret = ttm_mem_global_alloc_page(&ttm_mem_glob, ttm->pages[i], 556 PAGE_SIZE, ctx); 557 if (ret) 558 goto error; 559 } 560 return 0; 561 562 error: 563 while (i--) 564 ttm_mem_global_free_page(&ttm_mem_glob, ttm->pages[i], 565 PAGE_SIZE); 566 ttm_pool_free(&bdev->pool, ttm); 567 return ret; 568 } 569 570 static void vmw_ttm_unpopulate(struct ttm_device *bdev, 571 struct ttm_tt *ttm) 572 { 573 struct vmw_ttm_tt *vmw_tt = container_of(ttm, struct vmw_ttm_tt, 574 dma_ttm); 575 unsigned int i; 576 577 if (vmw_tt->mob) { 578 vmw_mob_destroy(vmw_tt->mob); 579 vmw_tt->mob = NULL; 580 } 581 582 vmw_ttm_unmap_dma(vmw_tt); 583 584 for (i = 0; i < ttm->num_pages; ++i) 585 ttm_mem_global_free_page(&ttm_mem_glob, ttm->pages[i], 586 PAGE_SIZE); 587 588 ttm_pool_free(&bdev->pool, ttm); 589 } 590 591 static struct ttm_tt *vmw_ttm_tt_create(struct ttm_buffer_object *bo, 592 uint32_t page_flags) 593 { 594 struct vmw_ttm_tt *vmw_be; 595 int ret; 596 597 vmw_be = kzalloc(sizeof(*vmw_be), GFP_KERNEL); 598 if (!vmw_be) 599 return NULL; 600 601 vmw_be->dev_priv = container_of(bo->bdev, struct vmw_private, bdev); 602 vmw_be->mob = NULL; 603 604 if (vmw_be->dev_priv->map_mode == vmw_dma_alloc_coherent) 605 ret = ttm_sg_tt_init(&vmw_be->dma_ttm, bo, page_flags, 606 ttm_cached); 607 else 608 ret = ttm_tt_init(&vmw_be->dma_ttm, bo, page_flags, 609 ttm_cached); 610 if (unlikely(ret != 0)) 611 goto out_no_init; 612 613 return &vmw_be->dma_ttm; 614 out_no_init: 615 kfree(vmw_be); 616 return NULL; 617 } 618 619 static void vmw_evict_flags(struct ttm_buffer_object *bo, 620 struct ttm_placement *placement) 621 { 622 *placement = vmw_sys_placement; 623 } 624 625 static int vmw_ttm_io_mem_reserve(struct ttm_device *bdev, struct ttm_resource *mem) 626 { 627 struct vmw_private *dev_priv = container_of(bdev, struct vmw_private, bdev); 628 629 switch (mem->mem_type) { 630 case TTM_PL_SYSTEM: 631 case VMW_PL_GMR: 632 case VMW_PL_MOB: 633 return 0; 634 case TTM_PL_VRAM: 635 mem->bus.offset = (mem->start << PAGE_SHIFT) + 636 dev_priv->vram_start; 637 mem->bus.is_iomem = true; 638 mem->bus.caching = ttm_cached; 639 break; 640 default: 641 return -EINVAL; 642 } 643 return 0; 644 } 645 646 /** 647 * vmw_move_notify - TTM move_notify_callback 648 * 649 * @bo: The TTM buffer object about to move. 650 * @old_mem: The old memory where we move from 651 * @new_mem: The struct ttm_resource indicating to what memory 652 * region the move is taking place. 653 * 654 * Calls move_notify for all subsystems needing it. 655 * (currently only resources). 656 */ 657 static void vmw_move_notify(struct ttm_buffer_object *bo, 658 struct ttm_resource *old_mem, 659 struct ttm_resource *new_mem) 660 { 661 vmw_bo_move_notify(bo, new_mem); 662 vmw_query_move_notify(bo, old_mem, new_mem); 663 } 664 665 666 /** 667 * vmw_swap_notify - TTM move_notify_callback 668 * 669 * @bo: The TTM buffer object about to be swapped out. 670 */ 671 static void vmw_swap_notify(struct ttm_buffer_object *bo) 672 { 673 vmw_bo_swap_notify(bo); 674 (void) ttm_bo_wait(bo, false, false); 675 } 676 677 static int vmw_move(struct ttm_buffer_object *bo, 678 bool evict, 679 struct ttm_operation_ctx *ctx, 680 struct ttm_resource *new_mem, 681 struct ttm_place *hop) 682 { 683 struct ttm_resource_manager *old_man = ttm_manager_type(bo->bdev, bo->resource->mem_type); 684 struct ttm_resource_manager *new_man = ttm_manager_type(bo->bdev, new_mem->mem_type); 685 int ret; 686 687 if (new_man->use_tt && new_mem->mem_type != TTM_PL_SYSTEM) { 688 ret = vmw_ttm_bind(bo->bdev, bo->ttm, new_mem); 689 if (ret) 690 return ret; 691 } 692 693 vmw_move_notify(bo, bo->resource, new_mem); 694 695 if (old_man->use_tt && new_man->use_tt) { 696 if (bo->resource->mem_type == TTM_PL_SYSTEM) { 697 ttm_bo_move_null(bo, new_mem); 698 return 0; 699 } 700 ret = ttm_bo_wait_ctx(bo, ctx); 701 if (ret) 702 goto fail; 703 704 vmw_ttm_unbind(bo->bdev, bo->ttm); 705 ttm_resource_free(bo, &bo->resource); 706 ttm_bo_assign_mem(bo, new_mem); 707 return 0; 708 } else { 709 ret = ttm_bo_move_memcpy(bo, ctx, new_mem); 710 if (ret) 711 goto fail; 712 } 713 return 0; 714 fail: 715 vmw_move_notify(bo, new_mem, bo->resource); 716 return ret; 717 } 718 719 struct ttm_device_funcs vmw_bo_driver = { 720 .ttm_tt_create = &vmw_ttm_tt_create, 721 .ttm_tt_populate = &vmw_ttm_populate, 722 .ttm_tt_unpopulate = &vmw_ttm_unpopulate, 723 .ttm_tt_destroy = &vmw_ttm_destroy, 724 .eviction_valuable = ttm_bo_eviction_valuable, 725 .evict_flags = vmw_evict_flags, 726 .move = vmw_move, 727 .swap_notify = vmw_swap_notify, 728 .io_mem_reserve = &vmw_ttm_io_mem_reserve, 729 }; 730 731 int vmw_bo_create_and_populate(struct vmw_private *dev_priv, 732 unsigned long bo_size, 733 struct ttm_buffer_object **bo_p) 734 { 735 struct ttm_operation_ctx ctx = { 736 .interruptible = false, 737 .no_wait_gpu = false 738 }; 739 struct ttm_buffer_object *bo; 740 int ret; 741 742 ret = vmw_bo_create_kernel(dev_priv, bo_size, 743 &vmw_sys_placement, 744 &bo); 745 if (unlikely(ret != 0)) 746 return ret; 747 748 ret = ttm_bo_reserve(bo, false, true, NULL); 749 BUG_ON(ret != 0); 750 ret = vmw_ttm_populate(bo->bdev, bo->ttm, &ctx); 751 if (likely(ret == 0)) { 752 struct vmw_ttm_tt *vmw_tt = 753 container_of(bo->ttm, struct vmw_ttm_tt, dma_ttm); 754 ret = vmw_ttm_map_dma(vmw_tt); 755 } 756 757 ttm_bo_unreserve(bo); 758 759 if (likely(ret == 0)) 760 *bo_p = bo; 761 return ret; 762 } 763