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
29
30
31
32
33#include "vmwgfx_drv.h"
34#include "vmwgfx_resource_priv.h"
35#include <ttm/ttm_placement.h>
36#include "vmwgfx_so.h"
37
38
39
40
41
42
43
44
45
46
47
48
49struct vmw_cotable {
50 struct vmw_resource res;
51 struct vmw_resource *ctx;
52 size_t size_read_back;
53 int seen_entries;
54 u32 type;
55 bool scrubbed;
56 struct list_head resource_list;
57};
58
59
60
61
62
63
64
65
66struct vmw_cotable_info {
67 u32 min_initial_entries;
68 u32 size;
69 void (*unbind_func)(struct vmw_private *, struct list_head *,
70 bool);
71};
72
73static const struct vmw_cotable_info co_info[] = {
74 {1, sizeof(SVGACOTableDXRTViewEntry), &vmw_view_cotable_list_destroy},
75 {1, sizeof(SVGACOTableDXDSViewEntry), &vmw_view_cotable_list_destroy},
76 {1, sizeof(SVGACOTableDXSRViewEntry), &vmw_view_cotable_list_destroy},
77 {1, sizeof(SVGACOTableDXElementLayoutEntry), NULL},
78 {1, sizeof(SVGACOTableDXBlendStateEntry), NULL},
79 {1, sizeof(SVGACOTableDXDepthStencilEntry), NULL},
80 {1, sizeof(SVGACOTableDXRasterizerStateEntry), NULL},
81 {1, sizeof(SVGACOTableDXSamplerEntry), NULL},
82 {1, sizeof(SVGACOTableDXStreamOutputEntry), NULL},
83 {1, sizeof(SVGACOTableDXQueryEntry), NULL},
84 {1, sizeof(SVGACOTableDXShaderEntry), &vmw_dx_shader_cotable_list_scrub}
85};
86
87
88
89
90
91
92const SVGACOTableType vmw_cotable_scrub_order[] = {
93 SVGA_COTABLE_RTVIEW,
94 SVGA_COTABLE_DSVIEW,
95 SVGA_COTABLE_SRVIEW,
96 SVGA_COTABLE_DXSHADER,
97 SVGA_COTABLE_ELEMENTLAYOUT,
98 SVGA_COTABLE_BLENDSTATE,
99 SVGA_COTABLE_DEPTHSTENCIL,
100 SVGA_COTABLE_RASTERIZERSTATE,
101 SVGA_COTABLE_SAMPLER,
102 SVGA_COTABLE_STREAMOUTPUT,
103 SVGA_COTABLE_DXQUERY,
104};
105
106static int vmw_cotable_bind(struct vmw_resource *res,
107 struct ttm_validate_buffer *val_buf);
108static int vmw_cotable_unbind(struct vmw_resource *res,
109 bool readback,
110 struct ttm_validate_buffer *val_buf);
111static int vmw_cotable_create(struct vmw_resource *res);
112static int vmw_cotable_destroy(struct vmw_resource *res);
113
114static const struct vmw_res_func vmw_cotable_func = {
115 .res_type = vmw_res_cotable,
116 .needs_backup = true,
117 .may_evict = true,
118 .type_name = "context guest backed object tables",
119 .backup_placement = &vmw_mob_placement,
120 .create = vmw_cotable_create,
121 .destroy = vmw_cotable_destroy,
122 .bind = vmw_cotable_bind,
123 .unbind = vmw_cotable_unbind,
124};
125
126
127
128
129
130
131
132static struct vmw_cotable *vmw_cotable(struct vmw_resource *res)
133{
134 return container_of(res, struct vmw_cotable, res);
135}
136
137
138
139
140
141
142
143
144
145static int vmw_cotable_destroy(struct vmw_resource *res)
146{
147 res->id = -1;
148 return 0;
149}
150
151
152
153
154
155
156
157
158
159
160static int vmw_cotable_unscrub(struct vmw_resource *res)
161{
162 struct vmw_cotable *vcotbl = vmw_cotable(res);
163 struct vmw_private *dev_priv = res->dev_priv;
164 struct ttm_buffer_object *bo = &res->backup->base;
165 struct {
166 SVGA3dCmdHeader header;
167 SVGA3dCmdDXSetCOTable body;
168 } *cmd;
169
170 WARN_ON_ONCE(bo->mem.mem_type != VMW_PL_MOB);
171 lockdep_assert_held(&bo->resv->lock.base);
172
173 cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), SVGA3D_INVALID_ID);
174 if (!cmd) {
175 DRM_ERROR("Failed reserving FIFO space for cotable "
176 "binding.\n");
177 return -ENOMEM;
178 }
179
180 WARN_ON(vcotbl->ctx->id == SVGA3D_INVALID_ID);
181 WARN_ON(bo->mem.mem_type != VMW_PL_MOB);
182 cmd->header.id = SVGA_3D_CMD_DX_SET_COTABLE;
183 cmd->header.size = sizeof(cmd->body);
184 cmd->body.cid = vcotbl->ctx->id;
185 cmd->body.type = vcotbl->type;
186 cmd->body.mobid = bo->mem.start;
187 cmd->body.validSizeInBytes = vcotbl->size_read_back;
188
189 vmw_fifo_commit_flush(dev_priv, sizeof(*cmd));
190 vcotbl->scrubbed = false;
191
192 return 0;
193}
194
195
196
197
198
199
200
201
202
203
204
205static int vmw_cotable_bind(struct vmw_resource *res,
206 struct ttm_validate_buffer *val_buf)
207{
208
209
210
211
212
213
214
215 val_buf->bo = &res->backup->base;
216
217 return vmw_cotable_unscrub(res);
218}
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238int vmw_cotable_scrub(struct vmw_resource *res, bool readback)
239{
240 struct vmw_cotable *vcotbl = vmw_cotable(res);
241 struct vmw_private *dev_priv = res->dev_priv;
242 size_t submit_size;
243
244 struct {
245 SVGA3dCmdHeader header;
246 SVGA3dCmdDXReadbackCOTable body;
247 } *cmd0;
248 struct {
249 SVGA3dCmdHeader header;
250 SVGA3dCmdDXSetCOTable body;
251 } *cmd1;
252
253 if (vcotbl->scrubbed)
254 return 0;
255
256 if (co_info[vcotbl->type].unbind_func)
257 co_info[vcotbl->type].unbind_func(dev_priv,
258 &vcotbl->resource_list,
259 readback);
260 submit_size = sizeof(*cmd1);
261 if (readback)
262 submit_size += sizeof(*cmd0);
263
264 cmd1 = vmw_fifo_reserve_dx(dev_priv, submit_size, SVGA3D_INVALID_ID);
265 if (!cmd1) {
266 DRM_ERROR("Failed reserving FIFO space for cotable "
267 "unbinding.\n");
268 return -ENOMEM;
269 }
270
271 vcotbl->size_read_back = 0;
272 if (readback) {
273 cmd0 = (void *) cmd1;
274 cmd0->header.id = SVGA_3D_CMD_DX_READBACK_COTABLE;
275 cmd0->header.size = sizeof(cmd0->body);
276 cmd0->body.cid = vcotbl->ctx->id;
277 cmd0->body.type = vcotbl->type;
278 cmd1 = (void *) &cmd0[1];
279 vcotbl->size_read_back = res->backup_size;
280 }
281 cmd1->header.id = SVGA_3D_CMD_DX_SET_COTABLE;
282 cmd1->header.size = sizeof(cmd1->body);
283 cmd1->body.cid = vcotbl->ctx->id;
284 cmd1->body.type = vcotbl->type;
285 cmd1->body.mobid = SVGA3D_INVALID_ID;
286 cmd1->body.validSizeInBytes = 0;
287 vmw_fifo_commit_flush(dev_priv, submit_size);
288 vcotbl->scrubbed = true;
289
290
291 res->id = -1;
292
293 return 0;
294}
295
296
297
298
299
300
301
302
303
304
305
306static int vmw_cotable_unbind(struct vmw_resource *res,
307 bool readback,
308 struct ttm_validate_buffer *val_buf)
309{
310 struct vmw_cotable *vcotbl = vmw_cotable(res);
311 struct vmw_private *dev_priv = res->dev_priv;
312 struct ttm_buffer_object *bo = val_buf->bo;
313 struct vmw_fence_obj *fence;
314
315 if (list_empty(&res->mob_head))
316 return 0;
317
318 WARN_ON_ONCE(bo->mem.mem_type != VMW_PL_MOB);
319 lockdep_assert_held(&bo->resv->lock.base);
320
321 mutex_lock(&dev_priv->binding_mutex);
322 if (!vcotbl->scrubbed)
323 vmw_dx_context_scrub_cotables(vcotbl->ctx, readback);
324 mutex_unlock(&dev_priv->binding_mutex);
325 (void) vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
326 vmw_fence_single_bo(bo, fence);
327 if (likely(fence != NULL))
328 vmw_fence_obj_unreference(&fence);
329
330 return 0;
331}
332
333
334
335
336
337
338
339
340
341static int vmw_cotable_readback(struct vmw_resource *res)
342{
343 struct vmw_cotable *vcotbl = vmw_cotable(res);
344 struct vmw_private *dev_priv = res->dev_priv;
345
346 struct {
347 SVGA3dCmdHeader header;
348 SVGA3dCmdDXReadbackCOTable body;
349 } *cmd;
350 struct vmw_fence_obj *fence;
351
352 if (!vcotbl->scrubbed) {
353 cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd),
354 SVGA3D_INVALID_ID);
355 if (!cmd) {
356 DRM_ERROR("Failed reserving FIFO space for cotable "
357 "readback.\n");
358 return -ENOMEM;
359 }
360 cmd->header.id = SVGA_3D_CMD_DX_READBACK_COTABLE;
361 cmd->header.size = sizeof(cmd->body);
362 cmd->body.cid = vcotbl->ctx->id;
363 cmd->body.type = vcotbl->type;
364 vcotbl->size_read_back = res->backup_size;
365 vmw_fifo_commit(dev_priv, sizeof(*cmd));
366 }
367
368 (void) vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
369 vmw_fence_single_bo(&res->backup->base, fence);
370 vmw_fence_obj_unreference(&fence);
371
372 return 0;
373}
374
375
376
377
378
379
380
381
382
383
384
385
386
387static int vmw_cotable_resize(struct vmw_resource *res, size_t new_size)
388{
389 struct vmw_private *dev_priv = res->dev_priv;
390 struct vmw_cotable *vcotbl = vmw_cotable(res);
391 struct vmw_dma_buffer *buf, *old_buf = res->backup;
392 struct ttm_buffer_object *bo, *old_bo = &res->backup->base;
393 size_t old_size = res->backup_size;
394 size_t old_size_read_back = vcotbl->size_read_back;
395 size_t cur_size_read_back;
396 struct ttm_bo_kmap_obj old_map, new_map;
397 int ret;
398 size_t i;
399
400 ret = vmw_cotable_readback(res);
401 if (ret)
402 return ret;
403
404 cur_size_read_back = vcotbl->size_read_back;
405 vcotbl->size_read_back = old_size_read_back;
406
407
408
409
410
411
412 buf = kzalloc(sizeof(*buf), GFP_KERNEL);
413 if (!buf)
414 return -ENOMEM;
415
416 ret = vmw_dmabuf_init(dev_priv, buf, new_size, &vmw_mob_ne_placement,
417 true, vmw_dmabuf_bo_free);
418 if (ret) {
419 DRM_ERROR("Failed initializing new cotable MOB.\n");
420 return ret;
421 }
422
423 bo = &buf->base;
424 WARN_ON_ONCE(ttm_bo_reserve(bo, false, true, false, NULL));
425
426 ret = ttm_bo_wait(old_bo, false, false, false);
427 if (unlikely(ret != 0)) {
428 DRM_ERROR("Failed waiting for cotable unbind.\n");
429 goto out_wait;
430 }
431
432
433
434
435
436 for (i = 0; i < old_bo->num_pages; ++i) {
437 bool dummy;
438
439 ret = ttm_bo_kmap(old_bo, i, 1, &old_map);
440 if (unlikely(ret != 0)) {
441 DRM_ERROR("Failed mapping old COTable on resize.\n");
442 goto out_wait;
443 }
444 ret = ttm_bo_kmap(bo, i, 1, &new_map);
445 if (unlikely(ret != 0)) {
446 DRM_ERROR("Failed mapping new COTable on resize.\n");
447 goto out_map_new;
448 }
449 memcpy(ttm_kmap_obj_virtual(&new_map, &dummy),
450 ttm_kmap_obj_virtual(&old_map, &dummy),
451 PAGE_SIZE);
452 ttm_bo_kunmap(&new_map);
453 ttm_bo_kunmap(&old_map);
454 }
455
456
457 ret = ttm_bo_validate(bo, &vmw_mob_placement, false, false);
458 if (unlikely(ret != 0)) {
459 DRM_ERROR("Failed validating new COTable backup buffer.\n");
460 goto out_wait;
461 }
462
463 res->backup = buf;
464 res->backup_size = new_size;
465 vcotbl->size_read_back = cur_size_read_back;
466
467
468
469
470
471 ret = vmw_cotable_unscrub(res);
472 if (ret) {
473 DRM_ERROR("Failed switching COTable backup buffer.\n");
474 res->backup = old_buf;
475 res->backup_size = old_size;
476 vcotbl->size_read_back = old_size_read_back;
477 goto out_wait;
478 }
479
480
481 list_del(&res->mob_head);
482 list_add_tail(&res->mob_head, &buf->res_list);
483 vmw_dmabuf_unreference(&old_buf);
484 res->id = vcotbl->type;
485
486 return 0;
487
488out_map_new:
489 ttm_bo_kunmap(&old_map);
490out_wait:
491 ttm_bo_unreserve(bo);
492 vmw_dmabuf_unreference(&buf);
493
494 return ret;
495}
496
497
498
499
500
501
502
503
504
505
506
507
508
509static int vmw_cotable_create(struct vmw_resource *res)
510{
511 struct vmw_cotable *vcotbl = vmw_cotable(res);
512 size_t new_size = res->backup_size;
513 size_t needed_size;
514 int ret;
515
516
517 needed_size = (vcotbl->seen_entries + 1) * co_info[vcotbl->type].size;
518 while (needed_size > new_size)
519 new_size *= 2;
520
521 if (likely(new_size <= res->backup_size)) {
522 if (vcotbl->scrubbed && !list_empty(&res->mob_head)) {
523 ret = vmw_cotable_unscrub(res);
524 if (ret)
525 return ret;
526 }
527 res->id = vcotbl->type;
528 return 0;
529 }
530
531 return vmw_cotable_resize(res, new_size);
532}
533
534
535
536
537
538
539
540
541static void vmw_hw_cotable_destroy(struct vmw_resource *res)
542{
543 (void) vmw_cotable_destroy(res);
544}
545
546static size_t cotable_acc_size;
547
548
549
550
551
552
553static void vmw_cotable_free(struct vmw_resource *res)
554{
555 struct vmw_private *dev_priv = res->dev_priv;
556
557 kfree(res);
558 ttm_mem_global_free(vmw_mem_glob(dev_priv), cotable_acc_size);
559}
560
561
562
563
564
565
566
567
568
569struct vmw_resource *vmw_cotable_alloc(struct vmw_private *dev_priv,
570 struct vmw_resource *ctx,
571 u32 type)
572{
573 struct vmw_cotable *vcotbl;
574 int ret;
575 u32 num_entries;
576
577 if (unlikely(cotable_acc_size == 0))
578 cotable_acc_size = ttm_round_pot(sizeof(struct vmw_cotable));
579
580 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
581 cotable_acc_size, false, true);
582 if (unlikely(ret))
583 return ERR_PTR(ret);
584
585 vcotbl = kzalloc(sizeof(*vcotbl), GFP_KERNEL);
586 if (unlikely(vcotbl == NULL)) {
587 ret = -ENOMEM;
588 goto out_no_alloc;
589 }
590
591 ret = vmw_resource_init(dev_priv, &vcotbl->res, true,
592 vmw_cotable_free, &vmw_cotable_func);
593 if (unlikely(ret != 0))
594 goto out_no_init;
595
596 INIT_LIST_HEAD(&vcotbl->resource_list);
597 vcotbl->res.id = type;
598 vcotbl->res.backup_size = PAGE_SIZE;
599 num_entries = PAGE_SIZE / co_info[type].size;
600 if (num_entries < co_info[type].min_initial_entries) {
601 vcotbl->res.backup_size = co_info[type].min_initial_entries *
602 co_info[type].size;
603 vcotbl->res.backup_size =
604 (vcotbl->res.backup_size + PAGE_SIZE - 1) & PAGE_MASK;
605 }
606
607 vcotbl->scrubbed = true;
608 vcotbl->seen_entries = -1;
609 vcotbl->type = type;
610 vcotbl->ctx = ctx;
611
612 vmw_resource_activate(&vcotbl->res, vmw_hw_cotable_destroy);
613
614 return &vcotbl->res;
615
616out_no_init:
617 kfree(vcotbl);
618out_no_alloc:
619 ttm_mem_global_free(vmw_mem_glob(dev_priv), cotable_acc_size);
620 return ERR_PTR(ret);
621}
622
623
624
625
626
627
628
629int vmw_cotable_notify(struct vmw_resource *res, int id)
630{
631 struct vmw_cotable *vcotbl = vmw_cotable(res);
632
633 if (id < 0 || id >= SVGA_COTABLE_MAX_IDS) {
634 DRM_ERROR("Illegal COTable id. Type is %u. Id is %d\n",
635 (unsigned) vcotbl->type, id);
636 return -EINVAL;
637 }
638
639 if (vcotbl->seen_entries < id) {
640
641 res->id = -1;
642 vcotbl->seen_entries = id;
643 }
644
645 return 0;
646}
647
648
649
650
651
652
653
654
655void vmw_cotable_add_resource(struct vmw_resource *res, struct list_head *head)
656{
657 struct vmw_cotable *vcotbl =
658 container_of(res, struct vmw_cotable, res);
659
660 list_add_tail(head, &vcotbl->resource_list);
661}
662