Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0 OR MIT
2/**************************************************************************
3 *
4 * Copyright 2015 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 * This file implements the vmwgfx context binding manager,
29 * The sole reason for having to use this code is that vmware guest
30 * backed contexts can be swapped out to their backing mobs by the device
31 * at any time, also swapped in at any time. At swapin time, the device
32 * validates the context bindings to make sure they point to valid resources.
33 * It's this outside-of-drawcall validation (that can happen at any time),
34 * that makes this code necessary.
35 *
36 * We therefore need to kill any context bindings pointing to a resource
37 * when the resource is swapped out. Furthermore, if the vmwgfx driver has
38 * swapped out the context we can't swap it in again to kill bindings because
39 * of backing mob reservation lockdep violations, so as part of
40 * context swapout, also kill all bindings of a context, so that they are
41 * already killed if a resource to which a binding points
42 * needs to be swapped out.
43 *
44 * Note that a resource can be pointed to by bindings from multiple contexts,
45 * Therefore we can't easily protect this data by a per context mutex
46 * (unless we use deadlock-safe WW mutexes). So we use a global binding_mutex
47 * to protect all binding manager data.
48 *
49 * Finally, any association between a context and a global resource
50 * (surface, shader or even DX query) is conceptually a context binding that
51 * needs to be tracked by this code.
52 */
53
54#include "vmwgfx_drv.h"
55#include "vmwgfx_binding.h"
56#include "device_include/svga3d_reg.h"
57
58#define VMW_BINDING_RT_BIT 0
59#define VMW_BINDING_PS_BIT 1
60#define VMW_BINDING_SO_T_BIT 2
61#define VMW_BINDING_VB_BIT 3
62#define VMW_BINDING_UAV_BIT 4
63#define VMW_BINDING_CS_UAV_BIT 5
64#define VMW_BINDING_NUM_BITS 6
65
66#define VMW_BINDING_PS_SR_BIT 0
67
68/**
69 * struct vmw_ctx_binding_state - per context binding state
70 *
71 * @dev_priv: Pointer to device private structure.
72 * @list: linked list of individual active bindings.
73 * @render_targets: Render target bindings.
74 * @texture_units: Texture units bindings.
75 * @ds_view: Depth-stencil view binding.
76 * @so_targets: StreamOutput target bindings.
77 * @vertex_buffers: Vertex buffer bindings.
78 * @index_buffer: Index buffer binding.
79 * @per_shader: Per shader-type bindings.
80 * @ua_views: UAV bindings.
81 * @so_state: StreamOutput bindings.
82 * @dirty: Bitmap tracking per binding-type changes that have not yet
83 * been emitted to the device.
84 * @dirty_vb: Bitmap tracking individual vertex buffer binding changes that
85 * have not yet been emitted to the device.
86 * @bind_cmd_buffer: Scratch space used to construct binding commands.
87 * @bind_cmd_count: Number of binding command data entries in @bind_cmd_buffer
88 * @bind_first_slot: Used together with @bind_cmd_buffer to indicate the
89 * device binding slot of the first command data entry in @bind_cmd_buffer.
90 *
91 * Note that this structure also provides storage space for the individual
92 * struct vmw_ctx_binding objects, so that no dynamic allocation is needed
93 * for individual bindings.
94 *
95 */
96struct vmw_ctx_binding_state {
97 struct vmw_private *dev_priv;
98 struct list_head list;
99 struct vmw_ctx_bindinfo_view render_targets[SVGA3D_RT_MAX];
100 struct vmw_ctx_bindinfo_tex texture_units[SVGA3D_NUM_TEXTURE_UNITS];
101 struct vmw_ctx_bindinfo_view ds_view;
102 struct vmw_ctx_bindinfo_so_target so_targets[SVGA3D_DX_MAX_SOTARGETS];
103 struct vmw_ctx_bindinfo_vb vertex_buffers[SVGA3D_DX_MAX_VERTEXBUFFERS];
104 struct vmw_ctx_bindinfo_ib index_buffer;
105 struct vmw_dx_shader_bindings per_shader[SVGA3D_NUM_SHADERTYPE];
106 struct vmw_ctx_bindinfo_uav ua_views[VMW_MAX_UAV_BIND_TYPE];
107 struct vmw_ctx_bindinfo_so so_state;
108
109 unsigned long dirty;
110 DECLARE_BITMAP(dirty_vb, SVGA3D_DX_MAX_VERTEXBUFFERS);
111
112 u32 bind_cmd_buffer[VMW_MAX_VIEW_BINDINGS];
113 u32 bind_cmd_count;
114 u32 bind_first_slot;
115};
116
117static int vmw_binding_scrub_shader(struct vmw_ctx_bindinfo *bi, bool rebind);
118static int vmw_binding_scrub_render_target(struct vmw_ctx_bindinfo *bi,
119 bool rebind);
120static int vmw_binding_scrub_texture(struct vmw_ctx_bindinfo *bi, bool rebind);
121static int vmw_binding_scrub_cb(struct vmw_ctx_bindinfo *bi, bool rebind);
122static int vmw_binding_scrub_dx_rt(struct vmw_ctx_bindinfo *bi, bool rebind);
123static int vmw_binding_scrub_sr(struct vmw_ctx_bindinfo *bi, bool rebind);
124static int vmw_binding_scrub_so_target(struct vmw_ctx_bindinfo *bi, bool rebind);
125static int vmw_binding_emit_dirty(struct vmw_ctx_binding_state *cbs);
126static int vmw_binding_scrub_dx_shader(struct vmw_ctx_bindinfo *bi,
127 bool rebind);
128static int vmw_binding_scrub_ib(struct vmw_ctx_bindinfo *bi, bool rebind);
129static int vmw_binding_scrub_vb(struct vmw_ctx_bindinfo *bi, bool rebind);
130static int vmw_binding_scrub_uav(struct vmw_ctx_bindinfo *bi, bool rebind);
131static int vmw_binding_scrub_cs_uav(struct vmw_ctx_bindinfo *bi, bool rebind);
132static int vmw_binding_scrub_so(struct vmw_ctx_bindinfo *bi, bool rebind);
133
134static void vmw_binding_build_asserts(void) __attribute__ ((unused));
135
136typedef int (*vmw_scrub_func)(struct vmw_ctx_bindinfo *, bool);
137
138/**
139 * struct vmw_binding_info - Per binding type information for the binding
140 * manager
141 *
142 * @size: The size of the struct binding derived from a struct vmw_ctx_bindinfo.
143 * @offsets: array[shader_slot] of offsets to the array[slot]
144 * of struct bindings for the binding type.
145 * @scrub_func: Pointer to the scrub function for this binding type.
146 *
147 * Holds static information to help optimize the binding manager and avoid
148 * an excessive amount of switch statements.
149 */
150struct vmw_binding_info {
151 size_t size;
152 const size_t *offsets;
153 vmw_scrub_func scrub_func;
154};
155
156/*
157 * A number of static variables that help determine the scrub func and the
158 * location of the struct vmw_ctx_bindinfo slots for each binding type.
159 */
160static const size_t vmw_binding_shader_offsets[] = {
161 offsetof(struct vmw_ctx_binding_state, per_shader[0].shader),
162 offsetof(struct vmw_ctx_binding_state, per_shader[1].shader),
163 offsetof(struct vmw_ctx_binding_state, per_shader[2].shader),
164 offsetof(struct vmw_ctx_binding_state, per_shader[3].shader),
165 offsetof(struct vmw_ctx_binding_state, per_shader[4].shader),
166 offsetof(struct vmw_ctx_binding_state, per_shader[5].shader),
167};
168static const size_t vmw_binding_rt_offsets[] = {
169 offsetof(struct vmw_ctx_binding_state, render_targets),
170};
171static const size_t vmw_binding_tex_offsets[] = {
172 offsetof(struct vmw_ctx_binding_state, texture_units),
173};
174static const size_t vmw_binding_cb_offsets[] = {
175 offsetof(struct vmw_ctx_binding_state, per_shader[0].const_buffers),
176 offsetof(struct vmw_ctx_binding_state, per_shader[1].const_buffers),
177 offsetof(struct vmw_ctx_binding_state, per_shader[2].const_buffers),
178 offsetof(struct vmw_ctx_binding_state, per_shader[3].const_buffers),
179 offsetof(struct vmw_ctx_binding_state, per_shader[4].const_buffers),
180 offsetof(struct vmw_ctx_binding_state, per_shader[5].const_buffers),
181};
182static const size_t vmw_binding_dx_ds_offsets[] = {
183 offsetof(struct vmw_ctx_binding_state, ds_view),
184};
185static const size_t vmw_binding_sr_offsets[] = {
186 offsetof(struct vmw_ctx_binding_state, per_shader[0].shader_res),
187 offsetof(struct vmw_ctx_binding_state, per_shader[1].shader_res),
188 offsetof(struct vmw_ctx_binding_state, per_shader[2].shader_res),
189 offsetof(struct vmw_ctx_binding_state, per_shader[3].shader_res),
190 offsetof(struct vmw_ctx_binding_state, per_shader[4].shader_res),
191 offsetof(struct vmw_ctx_binding_state, per_shader[5].shader_res),
192};
193static const size_t vmw_binding_so_target_offsets[] = {
194 offsetof(struct vmw_ctx_binding_state, so_targets),
195};
196static const size_t vmw_binding_vb_offsets[] = {
197 offsetof(struct vmw_ctx_binding_state, vertex_buffers),
198};
199static const size_t vmw_binding_ib_offsets[] = {
200 offsetof(struct vmw_ctx_binding_state, index_buffer),
201};
202static const size_t vmw_binding_uav_offsets[] = {
203 offsetof(struct vmw_ctx_binding_state, ua_views[0].views),
204};
205static const size_t vmw_binding_cs_uav_offsets[] = {
206 offsetof(struct vmw_ctx_binding_state, ua_views[1].views),
207};
208static const size_t vmw_binding_so_offsets[] = {
209 offsetof(struct vmw_ctx_binding_state, so_state),
210};
211
212static const struct vmw_binding_info vmw_binding_infos[] = {
213 [vmw_ctx_binding_shader] = {
214 .size = sizeof(struct vmw_ctx_bindinfo_shader),
215 .offsets = vmw_binding_shader_offsets,
216 .scrub_func = vmw_binding_scrub_shader},
217 [vmw_ctx_binding_rt] = {
218 .size = sizeof(struct vmw_ctx_bindinfo_view),
219 .offsets = vmw_binding_rt_offsets,
220 .scrub_func = vmw_binding_scrub_render_target},
221 [vmw_ctx_binding_tex] = {
222 .size = sizeof(struct vmw_ctx_bindinfo_tex),
223 .offsets = vmw_binding_tex_offsets,
224 .scrub_func = vmw_binding_scrub_texture},
225 [vmw_ctx_binding_cb] = {
226 .size = sizeof(struct vmw_ctx_bindinfo_cb),
227 .offsets = vmw_binding_cb_offsets,
228 .scrub_func = vmw_binding_scrub_cb},
229 [vmw_ctx_binding_dx_shader] = {
230 .size = sizeof(struct vmw_ctx_bindinfo_shader),
231 .offsets = vmw_binding_shader_offsets,
232 .scrub_func = vmw_binding_scrub_dx_shader},
233 [vmw_ctx_binding_dx_rt] = {
234 .size = sizeof(struct vmw_ctx_bindinfo_view),
235 .offsets = vmw_binding_rt_offsets,
236 .scrub_func = vmw_binding_scrub_dx_rt},
237 [vmw_ctx_binding_sr] = {
238 .size = sizeof(struct vmw_ctx_bindinfo_view),
239 .offsets = vmw_binding_sr_offsets,
240 .scrub_func = vmw_binding_scrub_sr},
241 [vmw_ctx_binding_ds] = {
242 .size = sizeof(struct vmw_ctx_bindinfo_view),
243 .offsets = vmw_binding_dx_ds_offsets,
244 .scrub_func = vmw_binding_scrub_dx_rt},
245 [vmw_ctx_binding_so_target] = {
246 .size = sizeof(struct vmw_ctx_bindinfo_so_target),
247 .offsets = vmw_binding_so_target_offsets,
248 .scrub_func = vmw_binding_scrub_so_target},
249 [vmw_ctx_binding_vb] = {
250 .size = sizeof(struct vmw_ctx_bindinfo_vb),
251 .offsets = vmw_binding_vb_offsets,
252 .scrub_func = vmw_binding_scrub_vb},
253 [vmw_ctx_binding_ib] = {
254 .size = sizeof(struct vmw_ctx_bindinfo_ib),
255 .offsets = vmw_binding_ib_offsets,
256 .scrub_func = vmw_binding_scrub_ib},
257 [vmw_ctx_binding_uav] = {
258 .size = sizeof(struct vmw_ctx_bindinfo_view),
259 .offsets = vmw_binding_uav_offsets,
260 .scrub_func = vmw_binding_scrub_uav},
261 [vmw_ctx_binding_cs_uav] = {
262 .size = sizeof(struct vmw_ctx_bindinfo_view),
263 .offsets = vmw_binding_cs_uav_offsets,
264 .scrub_func = vmw_binding_scrub_cs_uav},
265 [vmw_ctx_binding_so] = {
266 .size = sizeof(struct vmw_ctx_bindinfo_so),
267 .offsets = vmw_binding_so_offsets,
268 .scrub_func = vmw_binding_scrub_so},
269};
270
271/**
272 * vmw_cbs_context - Return a pointer to the context resource of a
273 * context binding state tracker.
274 *
275 * @cbs: The context binding state tracker.
276 *
277 * Provided there are any active bindings, this function will return an
278 * unreferenced pointer to the context resource that owns the context
279 * binding state tracker. If there are no active bindings, this function
280 * will return NULL. Note that the caller must somehow ensure that a reference
281 * is held on the context resource prior to calling this function.
282 */
283static const struct vmw_resource *
284vmw_cbs_context(const struct vmw_ctx_binding_state *cbs)
285{
286 if (list_empty(&cbs->list))
287 return NULL;
288
289 return list_first_entry(&cbs->list, struct vmw_ctx_bindinfo,
290 ctx_list)->ctx;
291}
292
293/**
294 * vmw_binding_loc - determine the struct vmw_ctx_bindinfo slot location.
295 *
296 * @cbs: Pointer to a struct vmw_ctx_binding state which holds the slot.
297 * @bt: The binding type.
298 * @shader_slot: The shader slot of the binding. If none, then set to 0.
299 * @slot: The slot of the binding.
300 */
301static struct vmw_ctx_bindinfo *
302vmw_binding_loc(struct vmw_ctx_binding_state *cbs,
303 enum vmw_ctx_binding_type bt, u32 shader_slot, u32 slot)
304{
305 const struct vmw_binding_info *b = &vmw_binding_infos[bt];
306 size_t offset = b->offsets[shader_slot] + b->size*slot;
307
308 return (struct vmw_ctx_bindinfo *)((u8 *) cbs + offset);
309}
310
311/**
312 * vmw_binding_drop: Stop tracking a context binding
313 *
314 * @bi: Pointer to binding tracker storage.
315 *
316 * Stops tracking a context binding, and re-initializes its storage.
317 * Typically used when the context binding is replaced with a binding to
318 * another (or the same, for that matter) resource.
319 */
320static void vmw_binding_drop(struct vmw_ctx_bindinfo *bi)
321{
322 list_del(&bi->ctx_list);
323 if (!list_empty(&bi->res_list))
324 list_del(&bi->res_list);
325 bi->ctx = NULL;
326}
327
328/**
329 * vmw_binding_add: Start tracking a context binding
330 *
331 * @cbs: Pointer to the context binding state tracker.
332 * @bi: Information about the binding to track.
333 * @shader_slot: The shader slot of the binding.
334 * @slot: The slot of the binding.
335 *
336 * Starts tracking the binding in the context binding
337 * state structure @cbs.
338 */
339void vmw_binding_add(struct vmw_ctx_binding_state *cbs,
340 const struct vmw_ctx_bindinfo *bi,
341 u32 shader_slot, u32 slot)
342{
343 struct vmw_ctx_bindinfo *loc =
344 vmw_binding_loc(cbs, bi->bt, shader_slot, slot);
345 const struct vmw_binding_info *b = &vmw_binding_infos[bi->bt];
346
347 if (loc->ctx != NULL)
348 vmw_binding_drop(loc);
349
350 memcpy(loc, bi, b->size);
351 loc->scrubbed = false;
352 list_add(&loc->ctx_list, &cbs->list);
353 INIT_LIST_HEAD(&loc->res_list);
354}
355
356/**
357 * vmw_binding_cb_offset_update: Update the offset of a cb binding
358 *
359 * @cbs: Pointer to the context binding state tracker.
360 * @shader_slot: The shader slot of the binding.
361 * @slot: The slot of the binding.
362 * @offsetInBytes: The new offset of the binding.
363 *
364 * Updates the offset of an existing cb binding in the context binding
365 * state structure @cbs.
366 */
367void vmw_binding_cb_offset_update(struct vmw_ctx_binding_state *cbs,
368 u32 shader_slot, u32 slot, u32 offsetInBytes)
369{
370 struct vmw_ctx_bindinfo *loc =
371 vmw_binding_loc(cbs, vmw_ctx_binding_cb, shader_slot, slot);
372 struct vmw_ctx_bindinfo_cb *loc_cb =
373 (struct vmw_ctx_bindinfo_cb *)((u8 *) loc);
374 loc_cb->offset = offsetInBytes;
375}
376
377/**
378 * vmw_binding_add_uav_index - Add UAV index for tracking.
379 * @cbs: Pointer to the context binding state tracker.
380 * @slot: UAV type to which bind this index.
381 * @index: The splice index to track.
382 */
383void vmw_binding_add_uav_index(struct vmw_ctx_binding_state *cbs, uint32 slot,
384 uint32 index)
385{
386 cbs->ua_views[slot].index = index;
387}
388
389/**
390 * vmw_binding_transfer: Transfer a context binding tracking entry.
391 *
392 * @cbs: Pointer to the persistent context binding state tracker.
393 * @from: Staged binding info built during execbuf
394 * @bi: Information about the binding to track.
395 *
396 */
397static void vmw_binding_transfer(struct vmw_ctx_binding_state *cbs,
398 const struct vmw_ctx_binding_state *from,
399 const struct vmw_ctx_bindinfo *bi)
400{
401 size_t offset = (unsigned long)bi - (unsigned long)from;
402 struct vmw_ctx_bindinfo *loc = (struct vmw_ctx_bindinfo *)
403 ((unsigned long) cbs + offset);
404
405 if (loc->ctx != NULL) {
406 WARN_ON(bi->scrubbed);
407
408 vmw_binding_drop(loc);
409 }
410
411 if (bi->res != NULL) {
412 memcpy(loc, bi, vmw_binding_infos[bi->bt].size);
413 list_add_tail(&loc->ctx_list, &cbs->list);
414 list_add_tail(&loc->res_list, &loc->res->binding_head);
415 }
416}
417
418/**
419 * vmw_binding_state_kill - Kill all bindings associated with a
420 * struct vmw_ctx_binding state structure, and re-initialize the structure.
421 *
422 * @cbs: Pointer to the context binding state tracker.
423 *
424 * Emits commands to scrub all bindings associated with the
425 * context binding state tracker. Then re-initializes the whole structure.
426 */
427void vmw_binding_state_kill(struct vmw_ctx_binding_state *cbs)
428{
429 struct vmw_ctx_bindinfo *entry, *next;
430
431 vmw_binding_state_scrub(cbs);
432 list_for_each_entry_safe(entry, next, &cbs->list, ctx_list)
433 vmw_binding_drop(entry);
434}
435
436/**
437 * vmw_binding_state_scrub - Scrub all bindings associated with a
438 * struct vmw_ctx_binding state structure.
439 *
440 * @cbs: Pointer to the context binding state tracker.
441 *
442 * Emits commands to scrub all bindings associated with the
443 * context binding state tracker.
444 */
445void vmw_binding_state_scrub(struct vmw_ctx_binding_state *cbs)
446{
447 struct vmw_ctx_bindinfo *entry;
448
449 list_for_each_entry(entry, &cbs->list, ctx_list) {
450 if (!entry->scrubbed) {
451 (void) vmw_binding_infos[entry->bt].scrub_func
452 (entry, false);
453 entry->scrubbed = true;
454 }
455 }
456
457 (void) vmw_binding_emit_dirty(cbs);
458}
459
460/**
461 * vmw_binding_res_list_kill - Kill all bindings on a
462 * resource binding list
463 *
464 * @head: list head of resource binding list
465 *
466 * Kills all bindings associated with a specific resource. Typically
467 * called before the resource is destroyed.
468 */
469void vmw_binding_res_list_kill(struct list_head *head)
470{
471 struct vmw_ctx_bindinfo *entry, *next;
472
473 vmw_binding_res_list_scrub(head);
474 list_for_each_entry_safe(entry, next, head, res_list)
475 vmw_binding_drop(entry);
476}
477
478/**
479 * vmw_binding_res_list_scrub - Scrub all bindings on a
480 * resource binding list
481 *
482 * @head: list head of resource binding list
483 *
484 * Scrub all bindings associated with a specific resource. Typically
485 * called before the resource is evicted.
486 */
487void vmw_binding_res_list_scrub(struct list_head *head)
488{
489 struct vmw_ctx_bindinfo *entry;
490
491 list_for_each_entry(entry, head, res_list) {
492 if (!entry->scrubbed) {
493 (void) vmw_binding_infos[entry->bt].scrub_func
494 (entry, false);
495 entry->scrubbed = true;
496 }
497 }
498
499 list_for_each_entry(entry, head, res_list) {
500 struct vmw_ctx_binding_state *cbs =
501 vmw_context_binding_state(entry->ctx);
502
503 (void) vmw_binding_emit_dirty(cbs);
504 }
505}
506
507
508/**
509 * vmw_binding_state_commit - Commit staged binding info
510 *
511 * @to: Staged binding info area to copy into to.
512 * @from: Staged binding info built during execbuf.
513 *
514 * Transfers binding info from a temporary structure
515 * (typically used by execbuf) to the persistent
516 * structure in the context. This can be done once commands have been
517 * submitted to hardware
518 */
519void vmw_binding_state_commit(struct vmw_ctx_binding_state *to,
520 struct vmw_ctx_binding_state *from)
521{
522 struct vmw_ctx_bindinfo *entry, *next;
523
524 list_for_each_entry_safe(entry, next, &from->list, ctx_list) {
525 vmw_binding_transfer(to, from, entry);
526 vmw_binding_drop(entry);
527 }
528
529 /* Also transfer uav splice indices */
530 to->ua_views[0].index = from->ua_views[0].index;
531 to->ua_views[1].index = from->ua_views[1].index;
532}
533
534/**
535 * vmw_binding_rebind_all - Rebind all scrubbed bindings of a context
536 *
537 * @cbs: Pointer to the context binding state tracker.
538 *
539 * Walks through the context binding list and rebinds all scrubbed
540 * resources.
541 */
542int vmw_binding_rebind_all(struct vmw_ctx_binding_state *cbs)
543{
544 struct vmw_ctx_bindinfo *entry;
545 int ret;
546
547 list_for_each_entry(entry, &cbs->list, ctx_list) {
548 if (likely(!entry->scrubbed))
549 continue;
550
551 if ((entry->res == NULL || entry->res->id ==
552 SVGA3D_INVALID_ID))
553 continue;
554
555 ret = vmw_binding_infos[entry->bt].scrub_func(entry, true);
556 if (unlikely(ret != 0))
557 return ret;
558
559 entry->scrubbed = false;
560 }
561
562 return vmw_binding_emit_dirty(cbs);
563}
564
565/**
566 * vmw_binding_scrub_shader - scrub a shader binding from a context.
567 *
568 * @bi: single binding information.
569 * @rebind: Whether to issue a bind instead of scrub command.
570 */
571static int vmw_binding_scrub_shader(struct vmw_ctx_bindinfo *bi, bool rebind)
572{
573 struct vmw_ctx_bindinfo_shader *binding =
574 container_of(bi, typeof(*binding), bi);
575 struct vmw_private *dev_priv = bi->ctx->dev_priv;
576 struct {
577 SVGA3dCmdHeader header;
578 SVGA3dCmdSetShader body;
579 } *cmd;
580
581 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
582 if (unlikely(cmd == NULL))
583 return -ENOMEM;
584
585 cmd->header.id = SVGA_3D_CMD_SET_SHADER;
586 cmd->header.size = sizeof(cmd->body);
587 cmd->body.cid = bi->ctx->id;
588 cmd->body.type = binding->shader_slot + SVGA3D_SHADERTYPE_MIN;
589 cmd->body.shid = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
590 vmw_cmd_commit(dev_priv, sizeof(*cmd));
591
592 return 0;
593}
594
595/**
596 * vmw_binding_scrub_render_target - scrub a render target binding
597 * from a context.
598 *
599 * @bi: single binding information.
600 * @rebind: Whether to issue a bind instead of scrub command.
601 */
602static int vmw_binding_scrub_render_target(struct vmw_ctx_bindinfo *bi,
603 bool rebind)
604{
605 struct vmw_ctx_bindinfo_view *binding =
606 container_of(bi, typeof(*binding), bi);
607 struct vmw_private *dev_priv = bi->ctx->dev_priv;
608 struct {
609 SVGA3dCmdHeader header;
610 SVGA3dCmdSetRenderTarget body;
611 } *cmd;
612
613 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
614 if (unlikely(cmd == NULL))
615 return -ENOMEM;
616
617 cmd->header.id = SVGA_3D_CMD_SETRENDERTARGET;
618 cmd->header.size = sizeof(cmd->body);
619 cmd->body.cid = bi->ctx->id;
620 cmd->body.type = binding->slot;
621 cmd->body.target.sid = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
622 cmd->body.target.face = 0;
623 cmd->body.target.mipmap = 0;
624 vmw_cmd_commit(dev_priv, sizeof(*cmd));
625
626 return 0;
627}
628
629/**
630 * vmw_binding_scrub_texture - scrub a texture binding from a context.
631 *
632 * @bi: single binding information.
633 * @rebind: Whether to issue a bind instead of scrub command.
634 *
635 * TODO: Possibly complement this function with a function that takes
636 * a list of texture bindings and combines them to a single command.
637 */
638static int vmw_binding_scrub_texture(struct vmw_ctx_bindinfo *bi,
639 bool rebind)
640{
641 struct vmw_ctx_bindinfo_tex *binding =
642 container_of(bi, typeof(*binding), bi);
643 struct vmw_private *dev_priv = bi->ctx->dev_priv;
644 struct {
645 SVGA3dCmdHeader header;
646 struct {
647 SVGA3dCmdSetTextureState c;
648 SVGA3dTextureState s1;
649 } body;
650 } *cmd;
651
652 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
653 if (unlikely(cmd == NULL))
654 return -ENOMEM;
655
656 cmd->header.id = SVGA_3D_CMD_SETTEXTURESTATE;
657 cmd->header.size = sizeof(cmd->body);
658 cmd->body.c.cid = bi->ctx->id;
659 cmd->body.s1.stage = binding->texture_stage;
660 cmd->body.s1.name = SVGA3D_TS_BIND_TEXTURE;
661 cmd->body.s1.value = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
662 vmw_cmd_commit(dev_priv, sizeof(*cmd));
663
664 return 0;
665}
666
667/**
668 * vmw_binding_scrub_dx_shader - scrub a dx shader binding from a context.
669 *
670 * @bi: single binding information.
671 * @rebind: Whether to issue a bind instead of scrub command.
672 */
673static int vmw_binding_scrub_dx_shader(struct vmw_ctx_bindinfo *bi, bool rebind)
674{
675 struct vmw_ctx_bindinfo_shader *binding =
676 container_of(bi, typeof(*binding), bi);
677 struct vmw_private *dev_priv = bi->ctx->dev_priv;
678 struct {
679 SVGA3dCmdHeader header;
680 SVGA3dCmdDXSetShader body;
681 } *cmd;
682
683 cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), bi->ctx->id);
684 if (unlikely(cmd == NULL))
685 return -ENOMEM;
686
687 cmd->header.id = SVGA_3D_CMD_DX_SET_SHADER;
688 cmd->header.size = sizeof(cmd->body);
689 cmd->body.type = binding->shader_slot + SVGA3D_SHADERTYPE_MIN;
690 cmd->body.shaderId = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
691 vmw_cmd_commit(dev_priv, sizeof(*cmd));
692
693 return 0;
694}
695
696/**
697 * vmw_binding_scrub_cb - scrub a constant buffer binding from a context.
698 *
699 * @bi: single binding information.
700 * @rebind: Whether to issue a bind instead of scrub command.
701 */
702static int vmw_binding_scrub_cb(struct vmw_ctx_bindinfo *bi, bool rebind)
703{
704 struct vmw_ctx_bindinfo_cb *binding =
705 container_of(bi, typeof(*binding), bi);
706 struct vmw_private *dev_priv = bi->ctx->dev_priv;
707 struct {
708 SVGA3dCmdHeader header;
709 SVGA3dCmdDXSetSingleConstantBuffer body;
710 } *cmd;
711
712 cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), bi->ctx->id);
713 if (unlikely(cmd == NULL))
714 return -ENOMEM;
715
716 cmd->header.id = SVGA_3D_CMD_DX_SET_SINGLE_CONSTANT_BUFFER;
717 cmd->header.size = sizeof(cmd->body);
718 cmd->body.slot = binding->slot;
719 cmd->body.type = binding->shader_slot + SVGA3D_SHADERTYPE_MIN;
720 if (rebind) {
721 cmd->body.offsetInBytes = binding->offset;
722 cmd->body.sizeInBytes = binding->size;
723 cmd->body.sid = bi->res->id;
724 } else {
725 cmd->body.offsetInBytes = 0;
726 cmd->body.sizeInBytes = 0;
727 cmd->body.sid = SVGA3D_INVALID_ID;
728 }
729 vmw_cmd_commit(dev_priv, sizeof(*cmd));
730
731 return 0;
732}
733
734/**
735 * vmw_collect_view_ids - Build view id data for a view binding command
736 * without checking which bindings actually need to be emitted
737 *
738 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
739 * @biv: Pointer to where the binding info array is stored in @cbs
740 * @max_num: Maximum number of entries in the @bi array.
741 *
742 * Scans the @bi array for bindings and builds a buffer of view id data.
743 * Stops at the first non-existing binding in the @bi array.
744 * On output, @cbs->bind_cmd_count contains the number of bindings to be
745 * emitted, @cbs->bind_first_slot is set to zero, and @cbs->bind_cmd_buffer
746 * contains the command data.
747 */
748static void vmw_collect_view_ids(struct vmw_ctx_binding_state *cbs,
749 const struct vmw_ctx_bindinfo_view *biv,
750 u32 max_num)
751{
752 unsigned long i;
753
754 cbs->bind_cmd_count = 0;
755 cbs->bind_first_slot = 0;
756
757 for (i = 0; i < max_num; ++i, ++biv) {
758 if (!biv->bi.ctx)
759 break;
760
761 cbs->bind_cmd_buffer[cbs->bind_cmd_count++] =
762 ((biv->bi.scrubbed) ?
763 SVGA3D_INVALID_ID : biv->bi.res->id);
764 }
765}
766
767/**
768 * vmw_collect_dirty_view_ids - Build view id data for a view binding command
769 *
770 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
771 * @bi: Pointer to where the binding info array is stored in @cbs
772 * @dirty: Bitmap indicating which bindings need to be emitted.
773 * @max_num: Maximum number of entries in the @bi array.
774 *
775 * Scans the @bi array for bindings that need to be emitted and
776 * builds a buffer of view id data.
777 * On output, @cbs->bind_cmd_count contains the number of bindings to be
778 * emitted, @cbs->bind_first_slot indicates the index of the first emitted
779 * binding, and @cbs->bind_cmd_buffer contains the command data.
780 */
781static void vmw_collect_dirty_view_ids(struct vmw_ctx_binding_state *cbs,
782 const struct vmw_ctx_bindinfo *bi,
783 unsigned long *dirty,
784 u32 max_num)
785{
786 const struct vmw_ctx_bindinfo_view *biv =
787 container_of(bi, struct vmw_ctx_bindinfo_view, bi);
788 unsigned long i, next_bit;
789
790 cbs->bind_cmd_count = 0;
791 i = find_first_bit(dirty, max_num);
792 next_bit = i;
793 cbs->bind_first_slot = i;
794
795 biv += i;
796 for (; i < max_num; ++i, ++biv) {
797 cbs->bind_cmd_buffer[cbs->bind_cmd_count++] =
798 ((!biv->bi.ctx || biv->bi.scrubbed) ?
799 SVGA3D_INVALID_ID : biv->bi.res->id);
800
801 if (next_bit == i) {
802 next_bit = find_next_bit(dirty, max_num, i + 1);
803 if (next_bit >= max_num)
804 break;
805 }
806 }
807}
808
809/**
810 * vmw_emit_set_sr - Issue delayed DX shader resource binding commands
811 *
812 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
813 * @shader_slot: The shader slot of the binding.
814 */
815static int vmw_emit_set_sr(struct vmw_ctx_binding_state *cbs,
816 int shader_slot)
817{
818 const struct vmw_ctx_bindinfo *loc =
819 &cbs->per_shader[shader_slot].shader_res[0].bi;
820 struct {
821 SVGA3dCmdHeader header;
822 SVGA3dCmdDXSetShaderResources body;
823 } *cmd;
824 size_t cmd_size, view_id_size;
825 const struct vmw_resource *ctx = vmw_cbs_context(cbs);
826
827 vmw_collect_dirty_view_ids(cbs, loc,
828 cbs->per_shader[shader_slot].dirty_sr,
829 SVGA3D_DX_MAX_SRVIEWS);
830 if (cbs->bind_cmd_count == 0)
831 return 0;
832
833 view_id_size = cbs->bind_cmd_count*sizeof(uint32);
834 cmd_size = sizeof(*cmd) + view_id_size;
835 cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
836 if (unlikely(cmd == NULL))
837 return -ENOMEM;
838
839 cmd->header.id = SVGA_3D_CMD_DX_SET_SHADER_RESOURCES;
840 cmd->header.size = sizeof(cmd->body) + view_id_size;
841 cmd->body.type = shader_slot + SVGA3D_SHADERTYPE_MIN;
842 cmd->body.startView = cbs->bind_first_slot;
843
844 memcpy(&cmd[1], cbs->bind_cmd_buffer, view_id_size);
845
846 vmw_cmd_commit(ctx->dev_priv, cmd_size);
847 bitmap_clear(cbs->per_shader[shader_slot].dirty_sr,
848 cbs->bind_first_slot, cbs->bind_cmd_count);
849
850 return 0;
851}
852
853/**
854 * vmw_emit_set_rt - Issue delayed DX rendertarget binding commands
855 *
856 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
857 */
858static int vmw_emit_set_rt(struct vmw_ctx_binding_state *cbs)
859{
860 const struct vmw_ctx_bindinfo_view *loc = &cbs->render_targets[0];
861 struct {
862 SVGA3dCmdHeader header;
863 SVGA3dCmdDXSetRenderTargets body;
864 } *cmd;
865 size_t cmd_size, view_id_size;
866 const struct vmw_resource *ctx = vmw_cbs_context(cbs);
867
868 vmw_collect_view_ids(cbs, loc, SVGA3D_DX_MAX_RENDER_TARGETS);
869 view_id_size = cbs->bind_cmd_count*sizeof(uint32);
870 cmd_size = sizeof(*cmd) + view_id_size;
871 cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
872 if (unlikely(cmd == NULL))
873 return -ENOMEM;
874
875 cmd->header.id = SVGA_3D_CMD_DX_SET_RENDERTARGETS;
876 cmd->header.size = sizeof(cmd->body) + view_id_size;
877
878 if (cbs->ds_view.bi.ctx && !cbs->ds_view.bi.scrubbed)
879 cmd->body.depthStencilViewId = cbs->ds_view.bi.res->id;
880 else
881 cmd->body.depthStencilViewId = SVGA3D_INVALID_ID;
882
883 memcpy(&cmd[1], cbs->bind_cmd_buffer, view_id_size);
884
885 vmw_cmd_commit(ctx->dev_priv, cmd_size);
886
887 return 0;
888
889}
890
891/**
892 * vmw_collect_so_targets - Build SVGA3dSoTarget data for a binding command
893 * without checking which bindings actually need to be emitted
894 *
895 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
896 * @biso: Pointer to where the binding info array is stored in @cbs
897 * @max_num: Maximum number of entries in the @bi array.
898 *
899 * Scans the @bi array for bindings and builds a buffer of SVGA3dSoTarget data.
900 * Stops at the first non-existing binding in the @bi array.
901 * On output, @cbs->bind_cmd_count contains the number of bindings to be
902 * emitted, @cbs->bind_first_slot is set to zero, and @cbs->bind_cmd_buffer
903 * contains the command data.
904 */
905static void vmw_collect_so_targets(struct vmw_ctx_binding_state *cbs,
906 const struct vmw_ctx_bindinfo_so_target *biso,
907 u32 max_num)
908{
909 unsigned long i;
910 SVGA3dSoTarget *so_buffer = (SVGA3dSoTarget *) cbs->bind_cmd_buffer;
911
912 cbs->bind_cmd_count = 0;
913 cbs->bind_first_slot = 0;
914
915 for (i = 0; i < max_num; ++i, ++biso, ++so_buffer,
916 ++cbs->bind_cmd_count) {
917 if (!biso->bi.ctx)
918 break;
919
920 if (!biso->bi.scrubbed) {
921 so_buffer->sid = biso->bi.res->id;
922 so_buffer->offset = biso->offset;
923 so_buffer->sizeInBytes = biso->size;
924 } else {
925 so_buffer->sid = SVGA3D_INVALID_ID;
926 so_buffer->offset = 0;
927 so_buffer->sizeInBytes = 0;
928 }
929 }
930}
931
932/**
933 * vmw_emit_set_so_target - Issue delayed streamout binding commands
934 *
935 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
936 */
937static int vmw_emit_set_so_target(struct vmw_ctx_binding_state *cbs)
938{
939 const struct vmw_ctx_bindinfo_so_target *loc = &cbs->so_targets[0];
940 struct {
941 SVGA3dCmdHeader header;
942 SVGA3dCmdDXSetSOTargets body;
943 } *cmd;
944 size_t cmd_size, so_target_size;
945 const struct vmw_resource *ctx = vmw_cbs_context(cbs);
946
947 vmw_collect_so_targets(cbs, loc, SVGA3D_DX_MAX_SOTARGETS);
948 if (cbs->bind_cmd_count == 0)
949 return 0;
950
951 so_target_size = cbs->bind_cmd_count*sizeof(SVGA3dSoTarget);
952 cmd_size = sizeof(*cmd) + so_target_size;
953 cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
954 if (unlikely(cmd == NULL))
955 return -ENOMEM;
956
957 cmd->header.id = SVGA_3D_CMD_DX_SET_SOTARGETS;
958 cmd->header.size = sizeof(cmd->body) + so_target_size;
959 memcpy(&cmd[1], cbs->bind_cmd_buffer, so_target_size);
960
961 vmw_cmd_commit(ctx->dev_priv, cmd_size);
962
963 return 0;
964
965}
966
967/**
968 * vmw_binding_emit_dirty_ps - Issue delayed per shader binding commands
969 *
970 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
971 *
972 */
973static int vmw_binding_emit_dirty_ps(struct vmw_ctx_binding_state *cbs)
974{
975 struct vmw_dx_shader_bindings *sb = &cbs->per_shader[0];
976 u32 i;
977 int ret;
978
979 for (i = 0; i < SVGA3D_NUM_SHADERTYPE_DX10; ++i, ++sb) {
980 if (!test_bit(VMW_BINDING_PS_SR_BIT, &sb->dirty))
981 continue;
982
983 ret = vmw_emit_set_sr(cbs, i);
984 if (ret)
985 break;
986
987 __clear_bit(VMW_BINDING_PS_SR_BIT, &sb->dirty);
988 }
989
990 return 0;
991}
992
993/**
994 * vmw_collect_dirty_vbs - Build SVGA3dVertexBuffer data for a
995 * SVGA3dCmdDXSetVertexBuffers command
996 *
997 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
998 * @bi: Pointer to where the binding info array is stored in @cbs
999 * @dirty: Bitmap indicating which bindings need to be emitted.
1000 * @max_num: Maximum number of entries in the @bi array.
1001 *
1002 * Scans the @bi array for bindings that need to be emitted and
1003 * builds a buffer of SVGA3dVertexBuffer data.
1004 * On output, @cbs->bind_cmd_count contains the number of bindings to be
1005 * emitted, @cbs->bind_first_slot indicates the index of the first emitted
1006 * binding, and @cbs->bind_cmd_buffer contains the command data.
1007 */
1008static void vmw_collect_dirty_vbs(struct vmw_ctx_binding_state *cbs,
1009 const struct vmw_ctx_bindinfo *bi,
1010 unsigned long *dirty,
1011 u32 max_num)
1012{
1013 const struct vmw_ctx_bindinfo_vb *biv =
1014 container_of(bi, struct vmw_ctx_bindinfo_vb, bi);
1015 unsigned long i, next_bit;
1016 SVGA3dVertexBuffer *vbs = (SVGA3dVertexBuffer *) &cbs->bind_cmd_buffer;
1017
1018 cbs->bind_cmd_count = 0;
1019 i = find_first_bit(dirty, max_num);
1020 next_bit = i;
1021 cbs->bind_first_slot = i;
1022
1023 biv += i;
1024 for (; i < max_num; ++i, ++biv, ++vbs) {
1025 if (!biv->bi.ctx || biv->bi.scrubbed) {
1026 vbs->sid = SVGA3D_INVALID_ID;
1027 vbs->stride = 0;
1028 vbs->offset = 0;
1029 } else {
1030 vbs->sid = biv->bi.res->id;
1031 vbs->stride = biv->stride;
1032 vbs->offset = biv->offset;
1033 }
1034 cbs->bind_cmd_count++;
1035 if (next_bit == i) {
1036 next_bit = find_next_bit(dirty, max_num, i + 1);
1037 if (next_bit >= max_num)
1038 break;
1039 }
1040 }
1041}
1042
1043/**
1044 * vmw_emit_set_vb - Issue delayed vertex buffer binding commands
1045 *
1046 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
1047 *
1048 */
1049static int vmw_emit_set_vb(struct vmw_ctx_binding_state *cbs)
1050{
1051 const struct vmw_ctx_bindinfo *loc =
1052 &cbs->vertex_buffers[0].bi;
1053 struct {
1054 SVGA3dCmdHeader header;
1055 SVGA3dCmdDXSetVertexBuffers body;
1056 } *cmd;
1057 size_t cmd_size, set_vb_size;
1058 const struct vmw_resource *ctx = vmw_cbs_context(cbs);
1059
1060 vmw_collect_dirty_vbs(cbs, loc, cbs->dirty_vb,
1061 SVGA3D_DX_MAX_VERTEXBUFFERS);
1062 if (cbs->bind_cmd_count == 0)
1063 return 0;
1064
1065 set_vb_size = cbs->bind_cmd_count*sizeof(SVGA3dVertexBuffer);
1066 cmd_size = sizeof(*cmd) + set_vb_size;
1067 cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
1068 if (unlikely(cmd == NULL))
1069 return -ENOMEM;
1070
1071 cmd->header.id = SVGA_3D_CMD_DX_SET_VERTEX_BUFFERS;
1072 cmd->header.size = sizeof(cmd->body) + set_vb_size;
1073 cmd->body.startBuffer = cbs->bind_first_slot;
1074
1075 memcpy(&cmd[1], cbs->bind_cmd_buffer, set_vb_size);
1076
1077 vmw_cmd_commit(ctx->dev_priv, cmd_size);
1078 bitmap_clear(cbs->dirty_vb,
1079 cbs->bind_first_slot, cbs->bind_cmd_count);
1080
1081 return 0;
1082}
1083
1084static int vmw_emit_set_uav(struct vmw_ctx_binding_state *cbs)
1085{
1086 const struct vmw_ctx_bindinfo_view *loc = &cbs->ua_views[0].views[0];
1087 struct {
1088 SVGA3dCmdHeader header;
1089 SVGA3dCmdDXSetUAViews body;
1090 } *cmd;
1091 size_t cmd_size, view_id_size;
1092 const struct vmw_resource *ctx = vmw_cbs_context(cbs);
1093
1094 vmw_collect_view_ids(cbs, loc, vmw_max_num_uavs(cbs->dev_priv));
1095 view_id_size = cbs->bind_cmd_count*sizeof(uint32);
1096 cmd_size = sizeof(*cmd) + view_id_size;
1097 cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
1098 if (!cmd)
1099 return -ENOMEM;
1100
1101 cmd->header.id = SVGA_3D_CMD_DX_SET_UA_VIEWS;
1102 cmd->header.size = sizeof(cmd->body) + view_id_size;
1103
1104 /* Splice index is specified user-space */
1105 cmd->body.uavSpliceIndex = cbs->ua_views[0].index;
1106
1107 memcpy(&cmd[1], cbs->bind_cmd_buffer, view_id_size);
1108
1109 vmw_cmd_commit(ctx->dev_priv, cmd_size);
1110
1111 return 0;
1112}
1113
1114static int vmw_emit_set_cs_uav(struct vmw_ctx_binding_state *cbs)
1115{
1116 const struct vmw_ctx_bindinfo_view *loc = &cbs->ua_views[1].views[0];
1117 struct {
1118 SVGA3dCmdHeader header;
1119 SVGA3dCmdDXSetCSUAViews body;
1120 } *cmd;
1121 size_t cmd_size, view_id_size;
1122 const struct vmw_resource *ctx = vmw_cbs_context(cbs);
1123
1124 vmw_collect_view_ids(cbs, loc, vmw_max_num_uavs(cbs->dev_priv));
1125 view_id_size = cbs->bind_cmd_count*sizeof(uint32);
1126 cmd_size = sizeof(*cmd) + view_id_size;
1127 cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
1128 if (!cmd)
1129 return -ENOMEM;
1130
1131 cmd->header.id = SVGA_3D_CMD_DX_SET_CS_UA_VIEWS;
1132 cmd->header.size = sizeof(cmd->body) + view_id_size;
1133
1134 /* Start index is specified user-space */
1135 cmd->body.startIndex = cbs->ua_views[1].index;
1136
1137 memcpy(&cmd[1], cbs->bind_cmd_buffer, view_id_size);
1138
1139 vmw_cmd_commit(ctx->dev_priv, cmd_size);
1140
1141 return 0;
1142}
1143
1144/**
1145 * vmw_binding_emit_dirty - Issue delayed binding commands
1146 *
1147 * @cbs: Pointer to the context's struct vmw_ctx_binding_state
1148 *
1149 * This function issues the delayed binding commands that arise from
1150 * previous scrub / unscrub calls. These binding commands are typically
1151 * commands that batch a number of bindings and therefore it makes sense
1152 * to delay them.
1153 */
1154static int vmw_binding_emit_dirty(struct vmw_ctx_binding_state *cbs)
1155{
1156 int ret = 0;
1157 unsigned long hit = 0;
1158
1159 while ((hit = find_next_bit(&cbs->dirty, VMW_BINDING_NUM_BITS, hit))
1160 < VMW_BINDING_NUM_BITS) {
1161
1162 switch (hit) {
1163 case VMW_BINDING_RT_BIT:
1164 ret = vmw_emit_set_rt(cbs);
1165 break;
1166 case VMW_BINDING_PS_BIT:
1167 ret = vmw_binding_emit_dirty_ps(cbs);
1168 break;
1169 case VMW_BINDING_SO_T_BIT:
1170 ret = vmw_emit_set_so_target(cbs);
1171 break;
1172 case VMW_BINDING_VB_BIT:
1173 ret = vmw_emit_set_vb(cbs);
1174 break;
1175 case VMW_BINDING_UAV_BIT:
1176 ret = vmw_emit_set_uav(cbs);
1177 break;
1178 case VMW_BINDING_CS_UAV_BIT:
1179 ret = vmw_emit_set_cs_uav(cbs);
1180 break;
1181 default:
1182 BUG();
1183 }
1184 if (ret)
1185 return ret;
1186
1187 __clear_bit(hit, &cbs->dirty);
1188 hit++;
1189 }
1190
1191 return 0;
1192}
1193
1194/**
1195 * vmw_binding_scrub_sr - Schedule a dx shaderresource binding
1196 * scrub from a context
1197 *
1198 * @bi: single binding information.
1199 * @rebind: Whether to issue a bind instead of scrub command.
1200 */
1201static int vmw_binding_scrub_sr(struct vmw_ctx_bindinfo *bi, bool rebind)
1202{
1203 struct vmw_ctx_bindinfo_view *biv =
1204 container_of(bi, struct vmw_ctx_bindinfo_view, bi);
1205 struct vmw_ctx_binding_state *cbs =
1206 vmw_context_binding_state(bi->ctx);
1207
1208 __set_bit(biv->slot, cbs->per_shader[biv->shader_slot].dirty_sr);
1209 __set_bit(VMW_BINDING_PS_SR_BIT,
1210 &cbs->per_shader[biv->shader_slot].dirty);
1211 __set_bit(VMW_BINDING_PS_BIT, &cbs->dirty);
1212
1213 return 0;
1214}
1215
1216/**
1217 * vmw_binding_scrub_dx_rt - Schedule a dx rendertarget binding
1218 * scrub from a context
1219 *
1220 * @bi: single binding information.
1221 * @rebind: Whether to issue a bind instead of scrub command.
1222 */
1223static int vmw_binding_scrub_dx_rt(struct vmw_ctx_bindinfo *bi, bool rebind)
1224{
1225 struct vmw_ctx_binding_state *cbs =
1226 vmw_context_binding_state(bi->ctx);
1227
1228 __set_bit(VMW_BINDING_RT_BIT, &cbs->dirty);
1229
1230 return 0;
1231}
1232
1233/**
1234 * vmw_binding_scrub_so_target - Schedule a dx streamoutput buffer binding
1235 * scrub from a context
1236 *
1237 * @bi: single binding information.
1238 * @rebind: Whether to issue a bind instead of scrub command.
1239 */
1240static int vmw_binding_scrub_so_target(struct vmw_ctx_bindinfo *bi, bool rebind)
1241{
1242 struct vmw_ctx_binding_state *cbs =
1243 vmw_context_binding_state(bi->ctx);
1244
1245 __set_bit(VMW_BINDING_SO_T_BIT, &cbs->dirty);
1246
1247 return 0;
1248}
1249
1250/**
1251 * vmw_binding_scrub_vb - Schedule a dx vertex buffer binding
1252 * scrub from a context
1253 *
1254 * @bi: single binding information.
1255 * @rebind: Whether to issue a bind instead of scrub command.
1256 */
1257static int vmw_binding_scrub_vb(struct vmw_ctx_bindinfo *bi, bool rebind)
1258{
1259 struct vmw_ctx_bindinfo_vb *bivb =
1260 container_of(bi, struct vmw_ctx_bindinfo_vb, bi);
1261 struct vmw_ctx_binding_state *cbs =
1262 vmw_context_binding_state(bi->ctx);
1263
1264 __set_bit(bivb->slot, cbs->dirty_vb);
1265 __set_bit(VMW_BINDING_VB_BIT, &cbs->dirty);
1266
1267 return 0;
1268}
1269
1270/**
1271 * vmw_binding_scrub_ib - scrub a dx index buffer binding from a context
1272 *
1273 * @bi: single binding information.
1274 * @rebind: Whether to issue a bind instead of scrub command.
1275 */
1276static int vmw_binding_scrub_ib(struct vmw_ctx_bindinfo *bi, bool rebind)
1277{
1278 struct vmw_ctx_bindinfo_ib *binding =
1279 container_of(bi, typeof(*binding), bi);
1280 struct vmw_private *dev_priv = bi->ctx->dev_priv;
1281 struct {
1282 SVGA3dCmdHeader header;
1283 SVGA3dCmdDXSetIndexBuffer body;
1284 } *cmd;
1285
1286 cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), bi->ctx->id);
1287 if (unlikely(cmd == NULL))
1288 return -ENOMEM;
1289
1290 cmd->header.id = SVGA_3D_CMD_DX_SET_INDEX_BUFFER;
1291 cmd->header.size = sizeof(cmd->body);
1292 if (rebind) {
1293 cmd->body.sid = bi->res->id;
1294 cmd->body.format = binding->format;
1295 cmd->body.offset = binding->offset;
1296 } else {
1297 cmd->body.sid = SVGA3D_INVALID_ID;
1298 cmd->body.format = 0;
1299 cmd->body.offset = 0;
1300 }
1301
1302 vmw_cmd_commit(dev_priv, sizeof(*cmd));
1303
1304 return 0;
1305}
1306
1307static int vmw_binding_scrub_uav(struct vmw_ctx_bindinfo *bi, bool rebind)
1308{
1309 struct vmw_ctx_binding_state *cbs = vmw_context_binding_state(bi->ctx);
1310
1311 __set_bit(VMW_BINDING_UAV_BIT, &cbs->dirty);
1312 return 0;
1313}
1314
1315static int vmw_binding_scrub_cs_uav(struct vmw_ctx_bindinfo *bi, bool rebind)
1316{
1317 struct vmw_ctx_binding_state *cbs = vmw_context_binding_state(bi->ctx);
1318
1319 __set_bit(VMW_BINDING_CS_UAV_BIT, &cbs->dirty);
1320 return 0;
1321}
1322
1323/**
1324 * vmw_binding_scrub_so - Scrub a streamoutput binding from context.
1325 * @bi: Single binding information.
1326 * @rebind: Whether to issue a bind instead of scrub command.
1327 */
1328static int vmw_binding_scrub_so(struct vmw_ctx_bindinfo *bi, bool rebind)
1329{
1330 struct vmw_ctx_bindinfo_so *binding =
1331 container_of(bi, typeof(*binding), bi);
1332 struct vmw_private *dev_priv = bi->ctx->dev_priv;
1333 struct {
1334 SVGA3dCmdHeader header;
1335 SVGA3dCmdDXSetStreamOutput body;
1336 } *cmd;
1337
1338 cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), bi->ctx->id);
1339 if (!cmd)
1340 return -ENOMEM;
1341
1342 cmd->header.id = SVGA_3D_CMD_DX_SET_STREAMOUTPUT;
1343 cmd->header.size = sizeof(cmd->body);
1344 cmd->body.soid = rebind ? bi->res->id : SVGA3D_INVALID_ID;
1345 vmw_cmd_commit(dev_priv, sizeof(*cmd));
1346
1347 return 0;
1348}
1349
1350/**
1351 * vmw_binding_state_alloc - Allocate a struct vmw_ctx_binding_state.
1352 *
1353 * @dev_priv: Pointer to a device private structure.
1354 *
1355 * Returns a pointer to a newly allocated struct or an error pointer on error.
1356 */
1357struct vmw_ctx_binding_state *
1358vmw_binding_state_alloc(struct vmw_private *dev_priv)
1359{
1360 struct vmw_ctx_binding_state *cbs;
1361
1362 cbs = vzalloc(sizeof(*cbs));
1363 if (!cbs) {
1364 return ERR_PTR(-ENOMEM);
1365 }
1366
1367 cbs->dev_priv = dev_priv;
1368 INIT_LIST_HEAD(&cbs->list);
1369
1370 return cbs;
1371}
1372
1373/**
1374 * vmw_binding_state_free - Free a struct vmw_ctx_binding_state.
1375 *
1376 * @cbs: Pointer to the struct vmw_ctx_binding_state to be freed.
1377 */
1378void vmw_binding_state_free(struct vmw_ctx_binding_state *cbs)
1379{
1380 vfree(cbs);
1381}
1382
1383/**
1384 * vmw_binding_state_list - Get the binding list of a
1385 * struct vmw_ctx_binding_state
1386 *
1387 * @cbs: Pointer to the struct vmw_ctx_binding_state
1388 *
1389 * Returns the binding list which can be used to traverse through the bindings
1390 * and access the resource information of all bindings.
1391 */
1392struct list_head *vmw_binding_state_list(struct vmw_ctx_binding_state *cbs)
1393{
1394 return &cbs->list;
1395}
1396
1397/**
1398 * vmw_binding_state_reset - clear a struct vmw_ctx_binding_state
1399 *
1400 * @cbs: Pointer to the struct vmw_ctx_binding_state to be cleared
1401 *
1402 * Drops all bindings registered in @cbs. No device binding actions are
1403 * performed.
1404 */
1405void vmw_binding_state_reset(struct vmw_ctx_binding_state *cbs)
1406{
1407 struct vmw_ctx_bindinfo *entry, *next;
1408
1409 list_for_each_entry_safe(entry, next, &cbs->list, ctx_list)
1410 vmw_binding_drop(entry);
1411}
1412
1413/**
1414 * vmw_binding_dirtying - Return whether a binding type is dirtying its resource
1415 * @binding_type: The binding type
1416 *
1417 * Each time a resource is put on the validation list as the result of a
1418 * context binding referencing it, we need to determine whether that resource
1419 * will be dirtied (written to by the GPU) as a result of the corresponding
1420 * GPU operation. Currently rendertarget-, depth-stencil-, stream-output-target
1421 * and unordered access view bindings are capable of dirtying its resource.
1422 *
1423 * Return: Whether the binding type dirties the resource its binding points to.
1424 */
1425u32 vmw_binding_dirtying(enum vmw_ctx_binding_type binding_type)
1426{
1427 static u32 is_binding_dirtying[vmw_ctx_binding_max] = {
1428 [vmw_ctx_binding_rt] = VMW_RES_DIRTY_SET,
1429 [vmw_ctx_binding_dx_rt] = VMW_RES_DIRTY_SET,
1430 [vmw_ctx_binding_ds] = VMW_RES_DIRTY_SET,
1431 [vmw_ctx_binding_so_target] = VMW_RES_DIRTY_SET,
1432 [vmw_ctx_binding_uav] = VMW_RES_DIRTY_SET,
1433 [vmw_ctx_binding_cs_uav] = VMW_RES_DIRTY_SET,
1434 };
1435
1436 /* Review this function as new bindings are added. */
1437 BUILD_BUG_ON(vmw_ctx_binding_max != 14);
1438 return is_binding_dirtying[binding_type];
1439}
1440
1441/*
1442 * This function is unused at run-time, and only used to hold various build
1443 * asserts important for code optimization assumptions.
1444 */
1445static void vmw_binding_build_asserts(void)
1446{
1447 BUILD_BUG_ON(SVGA3D_NUM_SHADERTYPE_DX10 != 3);
1448 BUILD_BUG_ON(SVGA3D_DX_MAX_RENDER_TARGETS > SVGA3D_RT_MAX);
1449 BUILD_BUG_ON(sizeof(uint32) != sizeof(u32));
1450
1451 /*
1452 * struct vmw_ctx_binding_state::bind_cmd_buffer is used for various
1453 * view id arrays.
1454 */
1455 BUILD_BUG_ON(VMW_MAX_VIEW_BINDINGS < SVGA3D_RT_MAX);
1456 BUILD_BUG_ON(VMW_MAX_VIEW_BINDINGS < SVGA3D_DX_MAX_SRVIEWS);
1457 BUILD_BUG_ON(VMW_MAX_VIEW_BINDINGS < SVGA3D_DX_MAX_CONSTBUFFERS);
1458
1459 /*
1460 * struct vmw_ctx_binding_state::bind_cmd_buffer is used for
1461 * u32 view ids, SVGA3dSoTargets and SVGA3dVertexBuffers
1462 */
1463 BUILD_BUG_ON(SVGA3D_DX_MAX_SOTARGETS*sizeof(SVGA3dSoTarget) >
1464 VMW_MAX_VIEW_BINDINGS*sizeof(u32));
1465 BUILD_BUG_ON(SVGA3D_DX_MAX_VERTEXBUFFERS*sizeof(SVGA3dVertexBuffer) >
1466 VMW_MAX_VIEW_BINDINGS*sizeof(u32));
1467}