GNU Linux-libre 4.14.262-gnu1
[releases.git] / drivers / gpu / drm / vmwgfx / vmwgfx_mob.c
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))
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))
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))
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 }