1 // SPDX-License-Identifier: GPL-2.0 OR MIT 2 /************************************************************************** 3 * 4 * Copyright 2012-2023 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_bo.h" 29 #include "vmwgfx_drv.h" 30 31 #include <linux/highmem.h> 32 33 #ifdef CONFIG_64BIT 34 #define VMW_PPN_SIZE 8 35 #define VMW_MOBFMT_PTDEPTH_0 SVGA3D_MOBFMT_PT64_0 36 #define VMW_MOBFMT_PTDEPTH_1 SVGA3D_MOBFMT_PT64_1 37 #define VMW_MOBFMT_PTDEPTH_2 SVGA3D_MOBFMT_PT64_2 38 #else 39 #define VMW_PPN_SIZE 4 40 #define VMW_MOBFMT_PTDEPTH_0 SVGA3D_MOBFMT_PT_0 41 #define VMW_MOBFMT_PTDEPTH_1 SVGA3D_MOBFMT_PT_1 42 #define VMW_MOBFMT_PTDEPTH_2 SVGA3D_MOBFMT_PT_2 43 #endif 44 45 /* 46 * struct vmw_mob - Structure containing page table and metadata for a 47 * Guest Memory OBject. 48 * 49 * @num_pages Number of pages that make up the page table. 50 * @pt_level The indirection level of the page table. 0-2. 51 * @pt_root_page DMA address of the level 0 page of the page table. 52 */ 53 struct vmw_mob { 54 struct vmw_bo *pt_bo; 55 unsigned long num_pages; 56 unsigned pt_level; 57 dma_addr_t pt_root_page; 58 uint32_t id; 59 }; 60 61 /* 62 * struct vmw_otable - Guest Memory OBject table metadata 63 * 64 * @size: Size of the table (page-aligned). 65 * @page_table: Pointer to a struct vmw_mob holding the page table. 66 */ 67 static const struct vmw_otable pre_dx_tables[] = { 68 {VMWGFX_NUM_MOB * sizeof(SVGAOTableMobEntry), NULL, true}, 69 {VMWGFX_NUM_GB_SURFACE * sizeof(SVGAOTableSurfaceEntry), NULL, true}, 70 {VMWGFX_NUM_GB_CONTEXT * sizeof(SVGAOTableContextEntry), NULL, true}, 71 {VMWGFX_NUM_GB_SHADER * sizeof(SVGAOTableShaderEntry), NULL, true}, 72 {VMWGFX_NUM_GB_SCREEN_TARGET * sizeof(SVGAOTableScreenTargetEntry), 73 NULL, true} 74 }; 75 76 static const struct vmw_otable dx_tables[] = { 77 {VMWGFX_NUM_MOB * sizeof(SVGAOTableMobEntry), NULL, true}, 78 {VMWGFX_NUM_GB_SURFACE * sizeof(SVGAOTableSurfaceEntry), NULL, true}, 79 {VMWGFX_NUM_GB_CONTEXT * sizeof(SVGAOTableContextEntry), NULL, true}, 80 {VMWGFX_NUM_GB_SHADER * sizeof(SVGAOTableShaderEntry), NULL, true}, 81 {VMWGFX_NUM_GB_SCREEN_TARGET * sizeof(SVGAOTableScreenTargetEntry), 82 NULL, true}, 83 {VMWGFX_NUM_DXCONTEXT * sizeof(SVGAOTableDXContextEntry), NULL, true}, 84 }; 85 86 static int vmw_mob_pt_populate(struct vmw_private *dev_priv, 87 struct vmw_mob *mob); 88 static void vmw_mob_pt_setup(struct vmw_mob *mob, 89 struct vmw_piter data_iter, 90 unsigned long num_data_pages); 91 92 93 static inline void vmw_bo_unpin_unlocked(struct ttm_buffer_object *bo) 94 { 95 int ret = ttm_bo_reserve(bo, false, true, NULL); 96 BUG_ON(ret != 0); 97 ttm_bo_unpin(bo); 98 ttm_bo_unreserve(bo); 99 } 100 101 102 /* 103 * vmw_setup_otable_base - Issue an object table base setup command to 104 * the device 105 * 106 * @dev_priv: Pointer to a device private structure 107 * @type: Type of object table base 108 * @offset Start of table offset into dev_priv::otable_bo 109 * @otable Pointer to otable metadata; 110 * 111 * This function returns -ENOMEM if it fails to reserve fifo space, 112 * and may block waiting for fifo space. 113 */ 114 static int vmw_setup_otable_base(struct vmw_private *dev_priv, 115 SVGAOTableType type, 116 struct ttm_buffer_object *otable_bo, 117 unsigned long offset, 118 struct vmw_otable *otable) 119 { 120 struct { 121 SVGA3dCmdHeader header; 122 SVGA3dCmdSetOTableBase64 body; 123 } *cmd; 124 struct vmw_mob *mob; 125 const struct vmw_sg_table *vsgt; 126 struct vmw_piter iter; 127 int ret; 128 129 BUG_ON(otable->page_table != NULL); 130 131 vsgt = vmw_bo_sg_table(otable_bo); 132 vmw_piter_start(&iter, vsgt, offset >> PAGE_SHIFT); 133 WARN_ON(!vmw_piter_next(&iter)); 134 135 mob = vmw_mob_create(otable->size >> PAGE_SHIFT); 136 if (unlikely(mob == NULL)) { 137 DRM_ERROR("Failed creating OTable page table.\n"); 138 return -ENOMEM; 139 } 140 141 if (otable->size <= PAGE_SIZE) { 142 mob->pt_level = VMW_MOBFMT_PTDEPTH_0; 143 mob->pt_root_page = vmw_piter_dma_addr(&iter); 144 } else { 145 ret = vmw_mob_pt_populate(dev_priv, mob); 146 if (unlikely(ret != 0)) 147 goto out_no_populate; 148 149 vmw_mob_pt_setup(mob, iter, otable->size >> PAGE_SHIFT); 150 mob->pt_level += VMW_MOBFMT_PTDEPTH_1 - SVGA3D_MOBFMT_PT_1; 151 } 152 153 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd)); 154 if (unlikely(cmd == NULL)) { 155 ret = -ENOMEM; 156 goto out_no_fifo; 157 } 158 159 memset(cmd, 0, sizeof(*cmd)); 160 cmd->header.id = SVGA_3D_CMD_SET_OTABLE_BASE64; 161 cmd->header.size = sizeof(cmd->body); 162 cmd->body.type = type; 163 cmd->body.baseAddress = mob->pt_root_page >> PAGE_SHIFT; 164 cmd->body.sizeInBytes = otable->size; 165 cmd->body.validSizeInBytes = 0; 166 cmd->body.ptDepth = mob->pt_level; 167 168 /* 169 * The device doesn't support this, But the otable size is 170 * determined at compile-time, so this BUG shouldn't trigger 171 * randomly. 172 */ 173 BUG_ON(mob->pt_level == VMW_MOBFMT_PTDEPTH_2); 174 175 vmw_cmd_commit(dev_priv, sizeof(*cmd)); 176 otable->page_table = mob; 177 178 return 0; 179 180 out_no_fifo: 181 out_no_populate: 182 vmw_mob_destroy(mob); 183 return ret; 184 } 185 186 /* 187 * vmw_takedown_otable_base - Issue an object table base takedown command 188 * to the device 189 * 190 * @dev_priv: Pointer to a device private structure 191 * @type: Type of object table base 192 * 193 */ 194 static void vmw_takedown_otable_base(struct vmw_private *dev_priv, 195 SVGAOTableType type, 196 struct vmw_otable *otable) 197 { 198 struct { 199 SVGA3dCmdHeader header; 200 SVGA3dCmdSetOTableBase body; 201 } *cmd; 202 struct ttm_buffer_object *bo; 203 204 if (otable->page_table == NULL) 205 return; 206 207 bo = &otable->page_table->pt_bo->tbo; 208 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd)); 209 if (unlikely(cmd == NULL)) 210 return; 211 212 memset(cmd, 0, sizeof(*cmd)); 213 cmd->header.id = SVGA_3D_CMD_SET_OTABLE_BASE; 214 cmd->header.size = sizeof(cmd->body); 215 cmd->body.type = type; 216 cmd->body.baseAddress = 0; 217 cmd->body.sizeInBytes = 0; 218 cmd->body.validSizeInBytes = 0; 219 cmd->body.ptDepth = SVGA3D_MOBFMT_INVALID; 220 vmw_cmd_commit(dev_priv, sizeof(*cmd)); 221 222 if (bo) { 223 int ret; 224 225 ret = ttm_bo_reserve(bo, false, true, NULL); 226 BUG_ON(ret != 0); 227 228 vmw_bo_fence_single(bo, NULL); 229 ttm_bo_unreserve(bo); 230 } 231 232 vmw_mob_destroy(otable->page_table); 233 otable->page_table = NULL; 234 } 235 236 237 static int vmw_otable_batch_setup(struct vmw_private *dev_priv, 238 struct vmw_otable_batch *batch) 239 { 240 unsigned long offset; 241 unsigned long bo_size; 242 struct vmw_otable *otables = batch->otables; 243 SVGAOTableType i; 244 int ret; 245 246 bo_size = 0; 247 for (i = 0; i < batch->num_otables; ++i) { 248 if (!otables[i].enabled) 249 continue; 250 251 otables[i].size = PFN_ALIGN(otables[i].size); 252 bo_size += otables[i].size; 253 } 254 255 ret = vmw_bo_create_and_populate(dev_priv, bo_size, 256 VMW_BO_DOMAIN_WAITABLE_SYS, 257 &batch->otable_bo); 258 if (unlikely(ret != 0)) 259 return ret; 260 261 offset = 0; 262 for (i = 0; i < batch->num_otables; ++i) { 263 if (!batch->otables[i].enabled) 264 continue; 265 266 ret = vmw_setup_otable_base(dev_priv, i, 267 &batch->otable_bo->tbo, 268 offset, 269 &otables[i]); 270 if (unlikely(ret != 0)) 271 goto out_no_setup; 272 offset += otables[i].size; 273 } 274 275 return 0; 276 277 out_no_setup: 278 for (i = 0; i < batch->num_otables; ++i) { 279 if (batch->otables[i].enabled) 280 vmw_takedown_otable_base(dev_priv, i, 281 &batch->otables[i]); 282 } 283 284 vmw_bo_unpin_unlocked(&batch->otable_bo->tbo); 285 ttm_bo_put(&batch->otable_bo->tbo); 286 batch->otable_bo = NULL; 287 return ret; 288 } 289 290 /* 291 * vmw_otables_setup - Set up guest backed memory object tables 292 * 293 * @dev_priv: Pointer to a device private structure 294 * 295 * Takes care of the device guest backed surface 296 * initialization, by setting up the guest backed memory object tables. 297 * Returns 0 on success and various error codes on failure. A successful return 298 * means the object tables can be taken down using the vmw_otables_takedown 299 * function. 300 */ 301 int vmw_otables_setup(struct vmw_private *dev_priv) 302 { 303 struct vmw_otable **otables = &dev_priv->otable_batch.otables; 304 int ret; 305 306 if (has_sm4_context(dev_priv)) { 307 *otables = kmemdup(dx_tables, sizeof(dx_tables), GFP_KERNEL); 308 if (!(*otables)) 309 return -ENOMEM; 310 311 dev_priv->otable_batch.num_otables = ARRAY_SIZE(dx_tables); 312 } else { 313 *otables = kmemdup(pre_dx_tables, sizeof(pre_dx_tables), 314 GFP_KERNEL); 315 if (!(*otables)) 316 return -ENOMEM; 317 318 dev_priv->otable_batch.num_otables = ARRAY_SIZE(pre_dx_tables); 319 } 320 321 ret = vmw_otable_batch_setup(dev_priv, &dev_priv->otable_batch); 322 if (unlikely(ret != 0)) 323 goto out_setup; 324 325 return 0; 326 327 out_setup: 328 kfree(*otables); 329 return ret; 330 } 331 332 static void vmw_otable_batch_takedown(struct vmw_private *dev_priv, 333 struct vmw_otable_batch *batch) 334 { 335 SVGAOTableType i; 336 struct ttm_buffer_object *bo = &batch->otable_bo->tbo; 337 int ret; 338 339 for (i = 0; i < batch->num_otables; ++i) 340 if (batch->otables[i].enabled) 341 vmw_takedown_otable_base(dev_priv, i, 342 &batch->otables[i]); 343 344 ret = ttm_bo_reserve(bo, false, true, NULL); 345 BUG_ON(ret != 0); 346 347 vmw_bo_fence_single(bo, NULL); 348 ttm_bo_unpin(bo); 349 ttm_bo_unreserve(bo); 350 351 vmw_bo_unreference(&batch->otable_bo); 352 } 353 354 /* 355 * vmw_otables_takedown - Take down guest backed memory object tables 356 * 357 * @dev_priv: Pointer to a device private structure 358 * 359 * Take down the Guest Memory Object tables. 360 */ 361 void vmw_otables_takedown(struct vmw_private *dev_priv) 362 { 363 vmw_otable_batch_takedown(dev_priv, &dev_priv->otable_batch); 364 kfree(dev_priv->otable_batch.otables); 365 } 366 367 /* 368 * vmw_mob_calculate_pt_pages - Calculate the number of page table pages 369 * needed for a guest backed memory object. 370 * 371 * @data_pages: Number of data pages in the memory object buffer. 372 */ 373 static unsigned long vmw_mob_calculate_pt_pages(unsigned long data_pages) 374 { 375 unsigned long data_size = data_pages * PAGE_SIZE; 376 unsigned long tot_size = 0; 377 378 while (likely(data_size > PAGE_SIZE)) { 379 data_size = DIV_ROUND_UP(data_size, PAGE_SIZE); 380 data_size *= VMW_PPN_SIZE; 381 tot_size += PFN_ALIGN(data_size); 382 } 383 384 return tot_size >> PAGE_SHIFT; 385 } 386 387 /* 388 * vmw_mob_create - Create a mob, but don't populate it. 389 * 390 * @data_pages: Number of data pages of the underlying buffer object. 391 */ 392 struct vmw_mob *vmw_mob_create(unsigned long data_pages) 393 { 394 struct vmw_mob *mob = kzalloc(sizeof(*mob), GFP_KERNEL); 395 396 if (unlikely(!mob)) 397 return NULL; 398 399 mob->num_pages = vmw_mob_calculate_pt_pages(data_pages); 400 401 return mob; 402 } 403 404 /* 405 * vmw_mob_pt_populate - Populate the mob pagetable 406 * 407 * @mob: Pointer to the mob the pagetable of which we want to 408 * populate. 409 * 410 * This function allocates memory to be used for the pagetable. 411 * Returns ENOMEM if memory resources aren't sufficient and may 412 * cause TTM buffer objects to be swapped out. 413 */ 414 static int vmw_mob_pt_populate(struct vmw_private *dev_priv, 415 struct vmw_mob *mob) 416 { 417 BUG_ON(mob->pt_bo != NULL); 418 419 return vmw_bo_create_and_populate(dev_priv, mob->num_pages * PAGE_SIZE, 420 VMW_BO_DOMAIN_WAITABLE_SYS, 421 &mob->pt_bo); 422 } 423 424 /** 425 * vmw_mob_assign_ppn - Assign a value to a page table entry 426 * 427 * @addr: Pointer to pointer to page table entry. 428 * @val: The page table entry 429 * 430 * Assigns a value to a page table entry pointed to by *@addr and increments 431 * *@addr according to the page table entry size. 432 */ 433 #if (VMW_PPN_SIZE == 8) 434 static void vmw_mob_assign_ppn(u32 **addr, dma_addr_t val) 435 { 436 *((u64 *) *addr) = val >> PAGE_SHIFT; 437 *addr += 2; 438 } 439 #else 440 static void vmw_mob_assign_ppn(u32 **addr, dma_addr_t val) 441 { 442 *(*addr)++ = val >> PAGE_SHIFT; 443 } 444 #endif 445 446 /* 447 * vmw_mob_build_pt - Build a pagetable 448 * 449 * @data_addr: Array of DMA addresses to the underlying buffer 450 * object's data pages. 451 * @num_data_pages: Number of buffer object data pages. 452 * @pt_pages: Array of page pointers to the page table pages. 453 * 454 * Returns the number of page table pages actually used. 455 * Uses atomic kmaps of highmem pages to avoid TLB thrashing. 456 */ 457 static unsigned long vmw_mob_build_pt(struct vmw_piter *data_iter, 458 unsigned long num_data_pages, 459 struct vmw_piter *pt_iter) 460 { 461 unsigned long pt_size = num_data_pages * VMW_PPN_SIZE; 462 unsigned long num_pt_pages = DIV_ROUND_UP(pt_size, PAGE_SIZE); 463 unsigned long pt_page; 464 u32 *addr, *save_addr; 465 unsigned long i; 466 struct page *page; 467 468 for (pt_page = 0; pt_page < num_pt_pages; ++pt_page) { 469 page = vmw_piter_page(pt_iter); 470 471 save_addr = addr = kmap_atomic(page); 472 473 for (i = 0; i < PAGE_SIZE / VMW_PPN_SIZE; ++i) { 474 vmw_mob_assign_ppn(&addr, 475 vmw_piter_dma_addr(data_iter)); 476 if (unlikely(--num_data_pages == 0)) 477 break; 478 WARN_ON(!vmw_piter_next(data_iter)); 479 } 480 kunmap_atomic(save_addr); 481 vmw_piter_next(pt_iter); 482 } 483 484 return num_pt_pages; 485 } 486 487 /* 488 * vmw_mob_build_pt - Set up a multilevel mob pagetable 489 * 490 * @mob: Pointer to a mob whose page table needs setting up. 491 * @data_addr Array of DMA addresses to the buffer object's data 492 * pages. 493 * @num_data_pages: Number of buffer object data pages. 494 * 495 * Uses tail recursion to set up a multilevel mob page table. 496 */ 497 static void vmw_mob_pt_setup(struct vmw_mob *mob, 498 struct vmw_piter data_iter, 499 unsigned long num_data_pages) 500 { 501 unsigned long num_pt_pages = 0; 502 struct ttm_buffer_object *bo = &mob->pt_bo->tbo; 503 struct vmw_piter save_pt_iter = {0}; 504 struct vmw_piter pt_iter; 505 const struct vmw_sg_table *vsgt; 506 int ret; 507 508 BUG_ON(num_data_pages == 0); 509 510 ret = ttm_bo_reserve(bo, false, true, NULL); 511 BUG_ON(ret != 0); 512 513 vsgt = vmw_bo_sg_table(bo); 514 vmw_piter_start(&pt_iter, vsgt, 0); 515 BUG_ON(!vmw_piter_next(&pt_iter)); 516 mob->pt_level = 0; 517 while (likely(num_data_pages > 1)) { 518 ++mob->pt_level; 519 BUG_ON(mob->pt_level > 2); 520 save_pt_iter = pt_iter; 521 num_pt_pages = vmw_mob_build_pt(&data_iter, num_data_pages, 522 &pt_iter); 523 data_iter = save_pt_iter; 524 num_data_pages = num_pt_pages; 525 } 526 527 mob->pt_root_page = vmw_piter_dma_addr(&save_pt_iter); 528 ttm_bo_unreserve(bo); 529 } 530 531 /* 532 * vmw_mob_destroy - Destroy a mob, unpopulating first if necessary. 533 * 534 * @mob: Pointer to a mob to destroy. 535 */ 536 void vmw_mob_destroy(struct vmw_mob *mob) 537 { 538 if (mob->pt_bo) { 539 vmw_bo_unpin_unlocked(&mob->pt_bo->tbo); 540 vmw_bo_unreference(&mob->pt_bo); 541 } 542 kfree(mob); 543 } 544 545 /* 546 * vmw_mob_unbind - Hide a mob from the device. 547 * 548 * @dev_priv: Pointer to a device private. 549 * @mob_id: Device id of the mob to unbind. 550 */ 551 void vmw_mob_unbind(struct vmw_private *dev_priv, 552 struct vmw_mob *mob) 553 { 554 struct { 555 SVGA3dCmdHeader header; 556 SVGA3dCmdDestroyGBMob body; 557 } *cmd; 558 int ret; 559 struct ttm_buffer_object *bo = &mob->pt_bo->tbo; 560 561 if (bo) { 562 ret = ttm_bo_reserve(bo, false, true, NULL); 563 /* 564 * Noone else should be using this buffer. 565 */ 566 BUG_ON(ret != 0); 567 } 568 569 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd)); 570 if (cmd) { 571 cmd->header.id = SVGA_3D_CMD_DESTROY_GB_MOB; 572 cmd->header.size = sizeof(cmd->body); 573 cmd->body.mobid = mob->id; 574 vmw_cmd_commit(dev_priv, sizeof(*cmd)); 575 } 576 577 if (bo) { 578 vmw_bo_fence_single(bo, NULL); 579 ttm_bo_unreserve(bo); 580 } 581 vmw_fifo_resource_dec(dev_priv); 582 } 583 584 /* 585 * vmw_mob_bind - Make a mob visible to the device after first 586 * populating it if necessary. 587 * 588 * @dev_priv: Pointer to a device private. 589 * @mob: Pointer to the mob we're making visible. 590 * @data_addr: Array of DMA addresses to the data pages of the underlying 591 * buffer object. 592 * @num_data_pages: Number of data pages of the underlying buffer 593 * object. 594 * @mob_id: Device id of the mob to bind 595 * 596 * This function is intended to be interfaced with the ttm_tt backend 597 * code. 598 */ 599 int vmw_mob_bind(struct vmw_private *dev_priv, 600 struct vmw_mob *mob, 601 const struct vmw_sg_table *vsgt, 602 unsigned long num_data_pages, 603 int32_t mob_id) 604 { 605 int ret; 606 bool pt_set_up = false; 607 struct vmw_piter data_iter; 608 struct { 609 SVGA3dCmdHeader header; 610 SVGA3dCmdDefineGBMob64 body; 611 } *cmd; 612 613 mob->id = mob_id; 614 vmw_piter_start(&data_iter, vsgt, 0); 615 if (unlikely(!vmw_piter_next(&data_iter))) 616 return 0; 617 618 if (likely(num_data_pages == 1)) { 619 mob->pt_level = VMW_MOBFMT_PTDEPTH_0; 620 mob->pt_root_page = vmw_piter_dma_addr(&data_iter); 621 } else if (unlikely(mob->pt_bo == NULL)) { 622 ret = vmw_mob_pt_populate(dev_priv, mob); 623 if (unlikely(ret != 0)) 624 return ret; 625 626 vmw_mob_pt_setup(mob, data_iter, num_data_pages); 627 pt_set_up = true; 628 mob->pt_level += VMW_MOBFMT_PTDEPTH_1 - SVGA3D_MOBFMT_PT_1; 629 } 630 631 vmw_fifo_resource_inc(dev_priv); 632 633 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd)); 634 if (unlikely(cmd == NULL)) 635 goto out_no_cmd_space; 636 637 cmd->header.id = SVGA_3D_CMD_DEFINE_GB_MOB64; 638 cmd->header.size = sizeof(cmd->body); 639 cmd->body.mobid = mob_id; 640 cmd->body.ptDepth = mob->pt_level; 641 cmd->body.base = mob->pt_root_page >> PAGE_SHIFT; 642 cmd->body.sizeInBytes = num_data_pages * PAGE_SIZE; 643 644 vmw_cmd_commit(dev_priv, sizeof(*cmd)); 645 646 return 0; 647 648 out_no_cmd_space: 649 vmw_fifo_resource_dec(dev_priv); 650 if (pt_set_up) { 651 vmw_bo_unpin_unlocked(&mob->pt_bo->tbo); 652 vmw_bo_unreference(&mob->pt_bo); 653 } 654 655 return -ENOMEM; 656 } 657