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