1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include "vmwgfx_drv.h"
29
30
31
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
50
51
52
53
54
55
56struct 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
66
67
68
69
70static 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
79static 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
89static int vmw_mob_pt_populate(struct vmw_private *dev_priv,
90 struct vmw_mob *mob);
91static void vmw_mob_pt_setup(struct vmw_mob *mob,
92 struct vmw_piter data_iter,
93 unsigned long num_data_pages);
94
95
96
97
98
99
100
101
102
103
104
105
106
107static 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
167
168
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
177out_no_fifo:
178out_no_populate:
179 vmw_mob_destroy(mob);
180 return ret;
181}
182
183
184
185
186
187
188
189
190
191static 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
237static 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
291out_unreserve:
292 ttm_bo_unreserve(batch->otable_bo);
293out_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);
301out_no_bo:
302 return ret;
303}
304
305
306
307
308
309
310
311
312
313
314
315
316int 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
342out_setup:
343 kfree(*otables);
344 return ret;
345}
346
347static 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
370
371
372
373
374
375void 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
383
384
385
386
387static 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
403
404
405
406struct 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
420
421
422
423
424
425
426
427
428
429static 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
456out_unreserve:
457 ttm_bo_unreserve(mob->pt_bo);
458 ttm_bo_unref(&mob->pt_bo);
459
460 return ret;
461}
462
463
464
465
466
467
468
469
470
471
472#if (VMW_PPN_SIZE == 8)
473static void vmw_mob_assign_ppn(u32 **addr, dma_addr_t val)
474{
475 *((u64 *) *addr) = val >> PAGE_SHIFT;
476 *addr += 2;
477}
478#else
479static void vmw_mob_assign_ppn(u32 **addr, dma_addr_t val)
480{
481 *(*addr)++ = val >> PAGE_SHIFT;
482}
483#endif
484
485
486
487
488
489
490
491
492
493
494
495
496static 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
528
529
530
531
532
533
534
535
536static 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
570
571
572
573void 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
582
583
584
585
586void 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
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
623
624
625
626
627
628
629
630
631
632
633
634
635
636int 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
691out_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