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  */
96 struct 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 
117 static int vmw_binding_scrub_shader(struct vmw_ctx_bindinfo *bi, bool rebind);
118 static int vmw_binding_scrub_render_target(struct vmw_ctx_bindinfo *bi,
119 					   bool rebind);
120 static int vmw_binding_scrub_texture(struct vmw_ctx_bindinfo *bi, bool rebind);
121 static int vmw_binding_scrub_cb(struct vmw_ctx_bindinfo *bi, bool rebind);
122 static int vmw_binding_scrub_dx_rt(struct vmw_ctx_bindinfo *bi, bool rebind);
123 static int vmw_binding_scrub_sr(struct vmw_ctx_bindinfo *bi, bool rebind);
124 static int vmw_binding_scrub_so_target(struct vmw_ctx_bindinfo *bi, bool rebind);
125 static int vmw_binding_emit_dirty(struct vmw_ctx_binding_state *cbs);
126 static int vmw_binding_scrub_dx_shader(struct vmw_ctx_bindinfo *bi,
127 				       bool rebind);
128 static int vmw_binding_scrub_ib(struct vmw_ctx_bindinfo *bi, bool rebind);
129 static int vmw_binding_scrub_vb(struct vmw_ctx_bindinfo *bi, bool rebind);
130 static int vmw_binding_scrub_uav(struct vmw_ctx_bindinfo *bi, bool rebind);
131 static int vmw_binding_scrub_cs_uav(struct vmw_ctx_bindinfo *bi, bool rebind);
132 static int vmw_binding_scrub_so(struct vmw_ctx_bindinfo *bi, bool rebind);
133 
134 static void vmw_binding_build_asserts(void) __attribute__ ((unused));
135 
136 typedef 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  */
150 struct 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  */
160 static 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 };
168 static const size_t vmw_binding_rt_offsets[] = {
169 	offsetof(struct vmw_ctx_binding_state, render_targets),
170 };
171 static const size_t vmw_binding_tex_offsets[] = {
172 	offsetof(struct vmw_ctx_binding_state, texture_units),
173 };
174 static 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 };
182 static const size_t vmw_binding_dx_ds_offsets[] = {
183 	offsetof(struct vmw_ctx_binding_state, ds_view),
184 };
185 static 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 };
193 static const size_t vmw_binding_so_target_offsets[] = {
194 	offsetof(struct vmw_ctx_binding_state, so_targets),
195 };
196 static const size_t vmw_binding_vb_offsets[] = {
197 	offsetof(struct vmw_ctx_binding_state, vertex_buffers),
198 };
199 static const size_t vmw_binding_ib_offsets[] = {
200 	offsetof(struct vmw_ctx_binding_state, index_buffer),
201 };
202 static const size_t vmw_binding_uav_offsets[] = {
203 	offsetof(struct vmw_ctx_binding_state, ua_views[0].views),
204 };
205 static const size_t vmw_binding_cs_uav_offsets[] = {
206 	offsetof(struct vmw_ctx_binding_state, ua_views[1].views),
207 };
208 static const size_t vmw_binding_so_offsets[] = {
209 	offsetof(struct vmw_ctx_binding_state, so_state),
210 };
211 
212 static 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  */
283 static const struct vmw_resource *
284 vmw_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  */
301 static struct vmw_ctx_bindinfo *
302 vmw_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  */
320 static 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  *
334  * Starts tracking the binding in the context binding
335  * state structure @cbs.
336  */
337 void vmw_binding_add(struct vmw_ctx_binding_state *cbs,
338 		    const struct vmw_ctx_bindinfo *bi,
339 		    u32 shader_slot, u32 slot)
340 {
341 	struct vmw_ctx_bindinfo *loc =
342 		vmw_binding_loc(cbs, bi->bt, shader_slot, slot);
343 	const struct vmw_binding_info *b = &vmw_binding_infos[bi->bt];
344 
345 	if (loc->ctx != NULL)
346 		vmw_binding_drop(loc);
347 
348 	memcpy(loc, bi, b->size);
349 	loc->scrubbed = false;
350 	list_add(&loc->ctx_list, &cbs->list);
351 	INIT_LIST_HEAD(&loc->res_list);
352 }
353 
354 /**
355  * vmw_binding_add_uav_index - Add UAV index for tracking.
356  * @cbs: Pointer to the context binding state tracker.
357  * @slot: UAV type to which bind this index.
358  * @index: The splice index to track.
359  */
360 void vmw_binding_add_uav_index(struct vmw_ctx_binding_state *cbs, uint32 slot,
361 			       uint32 index)
362 {
363 	cbs->ua_views[slot].index = index;
364 }
365 
366 /**
367  * vmw_binding_transfer: Transfer a context binding tracking entry.
368  *
369  * @cbs: Pointer to the persistent context binding state tracker.
370  * @bi: Information about the binding to track.
371  *
372  */
373 static void vmw_binding_transfer(struct vmw_ctx_binding_state *cbs,
374 				 const struct vmw_ctx_binding_state *from,
375 				 const struct vmw_ctx_bindinfo *bi)
376 {
377 	size_t offset = (unsigned long)bi - (unsigned long)from;
378 	struct vmw_ctx_bindinfo *loc = (struct vmw_ctx_bindinfo *)
379 		((unsigned long) cbs + offset);
380 
381 	if (loc->ctx != NULL) {
382 		WARN_ON(bi->scrubbed);
383 
384 		vmw_binding_drop(loc);
385 	}
386 
387 	if (bi->res != NULL) {
388 		memcpy(loc, bi, vmw_binding_infos[bi->bt].size);
389 		list_add_tail(&loc->ctx_list, &cbs->list);
390 		list_add_tail(&loc->res_list, &loc->res->binding_head);
391 	}
392 }
393 
394 /**
395  * vmw_binding_state_kill - Kill all bindings associated with a
396  * struct vmw_ctx_binding state structure, and re-initialize the structure.
397  *
398  * @cbs: Pointer to the context binding state tracker.
399  *
400  * Emits commands to scrub all bindings associated with the
401  * context binding state tracker. Then re-initializes the whole structure.
402  */
403 void vmw_binding_state_kill(struct vmw_ctx_binding_state *cbs)
404 {
405 	struct vmw_ctx_bindinfo *entry, *next;
406 
407 	vmw_binding_state_scrub(cbs);
408 	list_for_each_entry_safe(entry, next, &cbs->list, ctx_list)
409 		vmw_binding_drop(entry);
410 }
411 
412 /**
413  * vmw_binding_state_scrub - Scrub all bindings associated with a
414  * struct vmw_ctx_binding state structure.
415  *
416  * @cbs: Pointer to the context binding state tracker.
417  *
418  * Emits commands to scrub all bindings associated with the
419  * context binding state tracker.
420  */
421 void vmw_binding_state_scrub(struct vmw_ctx_binding_state *cbs)
422 {
423 	struct vmw_ctx_bindinfo *entry;
424 
425 	list_for_each_entry(entry, &cbs->list, ctx_list) {
426 		if (!entry->scrubbed) {
427 			(void) vmw_binding_infos[entry->bt].scrub_func
428 				(entry, false);
429 			entry->scrubbed = true;
430 		}
431 	}
432 
433 	(void) vmw_binding_emit_dirty(cbs);
434 }
435 
436 /**
437  * vmw_binding_res_list_kill - Kill all bindings on a
438  * resource binding list
439  *
440  * @head: list head of resource binding list
441  *
442  * Kills all bindings associated with a specific resource. Typically
443  * called before the resource is destroyed.
444  */
445 void vmw_binding_res_list_kill(struct list_head *head)
446 {
447 	struct vmw_ctx_bindinfo *entry, *next;
448 
449 	vmw_binding_res_list_scrub(head);
450 	list_for_each_entry_safe(entry, next, head, res_list)
451 		vmw_binding_drop(entry);
452 }
453 
454 /**
455  * vmw_binding_res_list_scrub - Scrub all bindings on a
456  * resource binding list
457  *
458  * @head: list head of resource binding list
459  *
460  * Scrub all bindings associated with a specific resource. Typically
461  * called before the resource is evicted.
462  */
463 void vmw_binding_res_list_scrub(struct list_head *head)
464 {
465 	struct vmw_ctx_bindinfo *entry;
466 
467 	list_for_each_entry(entry, head, res_list) {
468 		if (!entry->scrubbed) {
469 			(void) vmw_binding_infos[entry->bt].scrub_func
470 				(entry, false);
471 			entry->scrubbed = true;
472 		}
473 	}
474 
475 	list_for_each_entry(entry, head, res_list) {
476 		struct vmw_ctx_binding_state *cbs =
477 			vmw_context_binding_state(entry->ctx);
478 
479 		(void) vmw_binding_emit_dirty(cbs);
480 	}
481 }
482 
483 
484 /**
485  * vmw_binding_state_commit - Commit staged binding info
486  *
487  * @ctx: Pointer to context to commit the staged binding info to.
488  * @from: Staged binding info built during execbuf.
489  * @scrubbed: Transfer only scrubbed bindings.
490  *
491  * Transfers binding info from a temporary structure
492  * (typically used by execbuf) to the persistent
493  * structure in the context. This can be done once commands have been
494  * submitted to hardware
495  */
496 void vmw_binding_state_commit(struct vmw_ctx_binding_state *to,
497 			      struct vmw_ctx_binding_state *from)
498 {
499 	struct vmw_ctx_bindinfo *entry, *next;
500 
501 	list_for_each_entry_safe(entry, next, &from->list, ctx_list) {
502 		vmw_binding_transfer(to, from, entry);
503 		vmw_binding_drop(entry);
504 	}
505 
506 	/* Also transfer uav splice indices */
507 	to->ua_views[0].index = from->ua_views[0].index;
508 	to->ua_views[1].index = from->ua_views[1].index;
509 }
510 
511 /**
512  * vmw_binding_rebind_all - Rebind all scrubbed bindings of a context
513  *
514  * @ctx: The context resource
515  *
516  * Walks through the context binding list and rebinds all scrubbed
517  * resources.
518  */
519 int vmw_binding_rebind_all(struct vmw_ctx_binding_state *cbs)
520 {
521 	struct vmw_ctx_bindinfo *entry;
522 	int ret;
523 
524 	list_for_each_entry(entry, &cbs->list, ctx_list) {
525 		if (likely(!entry->scrubbed))
526 			continue;
527 
528 		if ((entry->res == NULL || entry->res->id ==
529 			    SVGA3D_INVALID_ID))
530 			continue;
531 
532 		ret = vmw_binding_infos[entry->bt].scrub_func(entry, true);
533 		if (unlikely(ret != 0))
534 			return ret;
535 
536 		entry->scrubbed = false;
537 	}
538 
539 	return vmw_binding_emit_dirty(cbs);
540 }
541 
542 /**
543  * vmw_binding_scrub_shader - scrub a shader binding from a context.
544  *
545  * @bi: single binding information.
546  * @rebind: Whether to issue a bind instead of scrub command.
547  */
548 static int vmw_binding_scrub_shader(struct vmw_ctx_bindinfo *bi, bool rebind)
549 {
550 	struct vmw_ctx_bindinfo_shader *binding =
551 		container_of(bi, typeof(*binding), bi);
552 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
553 	struct {
554 		SVGA3dCmdHeader header;
555 		SVGA3dCmdSetShader body;
556 	} *cmd;
557 
558 	cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
559 	if (unlikely(cmd == NULL))
560 		return -ENOMEM;
561 
562 	cmd->header.id = SVGA_3D_CMD_SET_SHADER;
563 	cmd->header.size = sizeof(cmd->body);
564 	cmd->body.cid = bi->ctx->id;
565 	cmd->body.type = binding->shader_slot + SVGA3D_SHADERTYPE_MIN;
566 	cmd->body.shid = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
567 	vmw_cmd_commit(dev_priv, sizeof(*cmd));
568 
569 	return 0;
570 }
571 
572 /**
573  * vmw_binding_scrub_render_target - scrub a render target binding
574  * from a context.
575  *
576  * @bi: single binding information.
577  * @rebind: Whether to issue a bind instead of scrub command.
578  */
579 static int vmw_binding_scrub_render_target(struct vmw_ctx_bindinfo *bi,
580 					   bool rebind)
581 {
582 	struct vmw_ctx_bindinfo_view *binding =
583 		container_of(bi, typeof(*binding), bi);
584 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
585 	struct {
586 		SVGA3dCmdHeader header;
587 		SVGA3dCmdSetRenderTarget body;
588 	} *cmd;
589 
590 	cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
591 	if (unlikely(cmd == NULL))
592 		return -ENOMEM;
593 
594 	cmd->header.id = SVGA_3D_CMD_SETRENDERTARGET;
595 	cmd->header.size = sizeof(cmd->body);
596 	cmd->body.cid = bi->ctx->id;
597 	cmd->body.type = binding->slot;
598 	cmd->body.target.sid = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
599 	cmd->body.target.face = 0;
600 	cmd->body.target.mipmap = 0;
601 	vmw_cmd_commit(dev_priv, sizeof(*cmd));
602 
603 	return 0;
604 }
605 
606 /**
607  * vmw_binding_scrub_texture - scrub a texture binding from a context.
608  *
609  * @bi: single binding information.
610  * @rebind: Whether to issue a bind instead of scrub command.
611  *
612  * TODO: Possibly complement this function with a function that takes
613  * a list of texture bindings and combines them to a single command.
614  */
615 static int vmw_binding_scrub_texture(struct vmw_ctx_bindinfo *bi,
616 				     bool rebind)
617 {
618 	struct vmw_ctx_bindinfo_tex *binding =
619 		container_of(bi, typeof(*binding), bi);
620 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
621 	struct {
622 		SVGA3dCmdHeader header;
623 		struct {
624 			SVGA3dCmdSetTextureState c;
625 			SVGA3dTextureState s1;
626 		} body;
627 	} *cmd;
628 
629 	cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd));
630 	if (unlikely(cmd == NULL))
631 		return -ENOMEM;
632 
633 	cmd->header.id = SVGA_3D_CMD_SETTEXTURESTATE;
634 	cmd->header.size = sizeof(cmd->body);
635 	cmd->body.c.cid = bi->ctx->id;
636 	cmd->body.s1.stage = binding->texture_stage;
637 	cmd->body.s1.name = SVGA3D_TS_BIND_TEXTURE;
638 	cmd->body.s1.value = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
639 	vmw_cmd_commit(dev_priv, sizeof(*cmd));
640 
641 	return 0;
642 }
643 
644 /**
645  * vmw_binding_scrub_dx_shader - scrub a dx shader binding from a context.
646  *
647  * @bi: single binding information.
648  * @rebind: Whether to issue a bind instead of scrub command.
649  */
650 static int vmw_binding_scrub_dx_shader(struct vmw_ctx_bindinfo *bi, bool rebind)
651 {
652 	struct vmw_ctx_bindinfo_shader *binding =
653 		container_of(bi, typeof(*binding), bi);
654 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
655 	struct {
656 		SVGA3dCmdHeader header;
657 		SVGA3dCmdDXSetShader body;
658 	} *cmd;
659 
660 	cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), bi->ctx->id);
661 	if (unlikely(cmd == NULL))
662 		return -ENOMEM;
663 
664 	cmd->header.id = SVGA_3D_CMD_DX_SET_SHADER;
665 	cmd->header.size = sizeof(cmd->body);
666 	cmd->body.type = binding->shader_slot + SVGA3D_SHADERTYPE_MIN;
667 	cmd->body.shaderId = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
668 	vmw_cmd_commit(dev_priv, sizeof(*cmd));
669 
670 	return 0;
671 }
672 
673 /**
674  * vmw_binding_scrub_cb - scrub a constant buffer binding from a context.
675  *
676  * @bi: single binding information.
677  * @rebind: Whether to issue a bind instead of scrub command.
678  */
679 static int vmw_binding_scrub_cb(struct vmw_ctx_bindinfo *bi, bool rebind)
680 {
681 	struct vmw_ctx_bindinfo_cb *binding =
682 		container_of(bi, typeof(*binding), bi);
683 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
684 	struct {
685 		SVGA3dCmdHeader header;
686 		SVGA3dCmdDXSetSingleConstantBuffer body;
687 	} *cmd;
688 
689 	cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), bi->ctx->id);
690 	if (unlikely(cmd == NULL))
691 		return -ENOMEM;
692 
693 	cmd->header.id = SVGA_3D_CMD_DX_SET_SINGLE_CONSTANT_BUFFER;
694 	cmd->header.size = sizeof(cmd->body);
695 	cmd->body.slot = binding->slot;
696 	cmd->body.type = binding->shader_slot + SVGA3D_SHADERTYPE_MIN;
697 	if (rebind) {
698 		cmd->body.offsetInBytes = binding->offset;
699 		cmd->body.sizeInBytes = binding->size;
700 		cmd->body.sid = bi->res->id;
701 	} else {
702 		cmd->body.offsetInBytes = 0;
703 		cmd->body.sizeInBytes = 0;
704 		cmd->body.sid = SVGA3D_INVALID_ID;
705 	}
706 	vmw_cmd_commit(dev_priv, sizeof(*cmd));
707 
708 	return 0;
709 }
710 
711 /**
712  * vmw_collect_view_ids - Build view id data for a view binding command
713  * without checking which bindings actually need to be emitted
714  *
715  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
716  * @bi: Pointer to where the binding info array is stored in @cbs
717  * @max_num: Maximum number of entries in the @bi array.
718  *
719  * Scans the @bi array for bindings and builds a buffer of view id data.
720  * Stops at the first non-existing binding in the @bi array.
721  * On output, @cbs->bind_cmd_count contains the number of bindings to be
722  * emitted, @cbs->bind_first_slot is set to zero, and @cbs->bind_cmd_buffer
723  * contains the command data.
724  */
725 static void vmw_collect_view_ids(struct vmw_ctx_binding_state *cbs,
726 				 const struct vmw_ctx_bindinfo *bi,
727 				 u32 max_num)
728 {
729 	const struct vmw_ctx_bindinfo_view *biv =
730 		container_of(bi, struct vmw_ctx_bindinfo_view, bi);
731 	unsigned long i;
732 
733 	cbs->bind_cmd_count = 0;
734 	cbs->bind_first_slot = 0;
735 
736 	for (i = 0; i < max_num; ++i, ++biv) {
737 		if (!biv->bi.ctx)
738 			break;
739 
740 		cbs->bind_cmd_buffer[cbs->bind_cmd_count++] =
741 			((biv->bi.scrubbed) ?
742 			 SVGA3D_INVALID_ID : biv->bi.res->id);
743 	}
744 }
745 
746 /**
747  * vmw_collect_dirty_view_ids - Build view id data for a view binding command
748  *
749  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
750  * @bi: Pointer to where the binding info array is stored in @cbs
751  * @dirty: Bitmap indicating which bindings need to be emitted.
752  * @max_num: Maximum number of entries in the @bi array.
753  *
754  * Scans the @bi array for bindings that need to be emitted and
755  * builds a buffer of view id data.
756  * On output, @cbs->bind_cmd_count contains the number of bindings to be
757  * emitted, @cbs->bind_first_slot indicates the index of the first emitted
758  * binding, and @cbs->bind_cmd_buffer contains the command data.
759  */
760 static void vmw_collect_dirty_view_ids(struct vmw_ctx_binding_state *cbs,
761 				       const struct vmw_ctx_bindinfo *bi,
762 				       unsigned long *dirty,
763 				       u32 max_num)
764 {
765 	const struct vmw_ctx_bindinfo_view *biv =
766 		container_of(bi, struct vmw_ctx_bindinfo_view, bi);
767 	unsigned long i, next_bit;
768 
769 	cbs->bind_cmd_count = 0;
770 	i = find_first_bit(dirty, max_num);
771 	next_bit = i;
772 	cbs->bind_first_slot = i;
773 
774 	biv += i;
775 	for (; i < max_num; ++i, ++biv) {
776 		cbs->bind_cmd_buffer[cbs->bind_cmd_count++] =
777 			((!biv->bi.ctx || biv->bi.scrubbed) ?
778 			 SVGA3D_INVALID_ID : biv->bi.res->id);
779 
780 		if (next_bit == i) {
781 			next_bit = find_next_bit(dirty, max_num, i + 1);
782 			if (next_bit >= max_num)
783 				break;
784 		}
785 	}
786 }
787 
788 /**
789  * vmw_binding_emit_set_sr - Issue delayed DX shader resource binding commands
790  *
791  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
792  */
793 static int vmw_emit_set_sr(struct vmw_ctx_binding_state *cbs,
794 			   int shader_slot)
795 {
796 	const struct vmw_ctx_bindinfo *loc =
797 		&cbs->per_shader[shader_slot].shader_res[0].bi;
798 	struct {
799 		SVGA3dCmdHeader header;
800 		SVGA3dCmdDXSetShaderResources body;
801 	} *cmd;
802 	size_t cmd_size, view_id_size;
803 	const struct vmw_resource *ctx = vmw_cbs_context(cbs);
804 
805 	vmw_collect_dirty_view_ids(cbs, loc,
806 				   cbs->per_shader[shader_slot].dirty_sr,
807 				   SVGA3D_DX_MAX_SRVIEWS);
808 	if (cbs->bind_cmd_count == 0)
809 		return 0;
810 
811 	view_id_size = cbs->bind_cmd_count*sizeof(uint32);
812 	cmd_size = sizeof(*cmd) + view_id_size;
813 	cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
814 	if (unlikely(cmd == NULL))
815 		return -ENOMEM;
816 
817 	cmd->header.id = SVGA_3D_CMD_DX_SET_SHADER_RESOURCES;
818 	cmd->header.size = sizeof(cmd->body) + view_id_size;
819 	cmd->body.type = shader_slot + SVGA3D_SHADERTYPE_MIN;
820 	cmd->body.startView = cbs->bind_first_slot;
821 
822 	memcpy(&cmd[1], cbs->bind_cmd_buffer, view_id_size);
823 
824 	vmw_cmd_commit(ctx->dev_priv, cmd_size);
825 	bitmap_clear(cbs->per_shader[shader_slot].dirty_sr,
826 		     cbs->bind_first_slot, cbs->bind_cmd_count);
827 
828 	return 0;
829 }
830 
831 /**
832  * vmw_binding_emit_set_rt - Issue delayed DX rendertarget binding commands
833  *
834  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
835  */
836 static int vmw_emit_set_rt(struct vmw_ctx_binding_state *cbs)
837 {
838 	const struct vmw_ctx_bindinfo *loc = &cbs->render_targets[0].bi;
839 	struct {
840 		SVGA3dCmdHeader header;
841 		SVGA3dCmdDXSetRenderTargets body;
842 	} *cmd;
843 	size_t cmd_size, view_id_size;
844 	const struct vmw_resource *ctx = vmw_cbs_context(cbs);
845 
846 	vmw_collect_view_ids(cbs, loc, SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS);
847 	view_id_size = cbs->bind_cmd_count*sizeof(uint32);
848 	cmd_size = sizeof(*cmd) + view_id_size;
849 	cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
850 	if (unlikely(cmd == NULL))
851 		return -ENOMEM;
852 
853 	cmd->header.id = SVGA_3D_CMD_DX_SET_RENDERTARGETS;
854 	cmd->header.size = sizeof(cmd->body) + view_id_size;
855 
856 	if (cbs->ds_view.bi.ctx && !cbs->ds_view.bi.scrubbed)
857 		cmd->body.depthStencilViewId = cbs->ds_view.bi.res->id;
858 	else
859 		cmd->body.depthStencilViewId = SVGA3D_INVALID_ID;
860 
861 	memcpy(&cmd[1], cbs->bind_cmd_buffer, view_id_size);
862 
863 	vmw_cmd_commit(ctx->dev_priv, cmd_size);
864 
865 	return 0;
866 
867 }
868 
869 /**
870  * vmw_collect_so_targets - Build SVGA3dSoTarget data for a binding command
871  * without checking which bindings actually need to be emitted
872  *
873  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
874  * @bi: Pointer to where the binding info array is stored in @cbs
875  * @max_num: Maximum number of entries in the @bi array.
876  *
877  * Scans the @bi array for bindings and builds a buffer of SVGA3dSoTarget data.
878  * Stops at the first non-existing binding in the @bi array.
879  * On output, @cbs->bind_cmd_count contains the number of bindings to be
880  * emitted, @cbs->bind_first_slot is set to zero, and @cbs->bind_cmd_buffer
881  * contains the command data.
882  */
883 static void vmw_collect_so_targets(struct vmw_ctx_binding_state *cbs,
884 				   const struct vmw_ctx_bindinfo *bi,
885 				   u32 max_num)
886 {
887 	const struct vmw_ctx_bindinfo_so_target *biso =
888 		container_of(bi, struct vmw_ctx_bindinfo_so_target, bi);
889 	unsigned long i;
890 	SVGA3dSoTarget *so_buffer = (SVGA3dSoTarget *) cbs->bind_cmd_buffer;
891 
892 	cbs->bind_cmd_count = 0;
893 	cbs->bind_first_slot = 0;
894 
895 	for (i = 0; i < max_num; ++i, ++biso, ++so_buffer,
896 		    ++cbs->bind_cmd_count) {
897 		if (!biso->bi.ctx)
898 			break;
899 
900 		if (!biso->bi.scrubbed) {
901 			so_buffer->sid = biso->bi.res->id;
902 			so_buffer->offset = biso->offset;
903 			so_buffer->sizeInBytes = biso->size;
904 		} else {
905 			so_buffer->sid = SVGA3D_INVALID_ID;
906 			so_buffer->offset = 0;
907 			so_buffer->sizeInBytes = 0;
908 		}
909 	}
910 }
911 
912 /**
913  * vmw_emit_set_so_target - Issue delayed streamout binding commands
914  *
915  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
916  */
917 static int vmw_emit_set_so_target(struct vmw_ctx_binding_state *cbs)
918 {
919 	const struct vmw_ctx_bindinfo *loc = &cbs->so_targets[0].bi;
920 	struct {
921 		SVGA3dCmdHeader header;
922 		SVGA3dCmdDXSetSOTargets body;
923 	} *cmd;
924 	size_t cmd_size, so_target_size;
925 	const struct vmw_resource *ctx = vmw_cbs_context(cbs);
926 
927 	vmw_collect_so_targets(cbs, loc, SVGA3D_DX_MAX_SOTARGETS);
928 	if (cbs->bind_cmd_count == 0)
929 		return 0;
930 
931 	so_target_size = cbs->bind_cmd_count*sizeof(SVGA3dSoTarget);
932 	cmd_size = sizeof(*cmd) + so_target_size;
933 	cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
934 	if (unlikely(cmd == NULL))
935 		return -ENOMEM;
936 
937 	cmd->header.id = SVGA_3D_CMD_DX_SET_SOTARGETS;
938 	cmd->header.size = sizeof(cmd->body) + so_target_size;
939 	memcpy(&cmd[1], cbs->bind_cmd_buffer, so_target_size);
940 
941 	vmw_cmd_commit(ctx->dev_priv, cmd_size);
942 
943 	return 0;
944 
945 }
946 
947 /**
948  * vmw_binding_emit_dirty_ps - Issue delayed per shader binding commands
949  *
950  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
951  *
952  */
953 static int vmw_binding_emit_dirty_ps(struct vmw_ctx_binding_state *cbs)
954 {
955 	struct vmw_dx_shader_bindings *sb = &cbs->per_shader[0];
956 	u32 i;
957 	int ret;
958 
959 	for (i = 0; i < SVGA3D_NUM_SHADERTYPE_DX10; ++i, ++sb) {
960 		if (!test_bit(VMW_BINDING_PS_SR_BIT, &sb->dirty))
961 			continue;
962 
963 		ret = vmw_emit_set_sr(cbs, i);
964 		if (ret)
965 			break;
966 
967 		__clear_bit(VMW_BINDING_PS_SR_BIT, &sb->dirty);
968 	}
969 
970 	return 0;
971 }
972 
973 /**
974  * vmw_collect_dirty_vbs - Build SVGA3dVertexBuffer data for a
975  * SVGA3dCmdDXSetVertexBuffers command
976  *
977  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
978  * @bi: Pointer to where the binding info array is stored in @cbs
979  * @dirty: Bitmap indicating which bindings need to be emitted.
980  * @max_num: Maximum number of entries in the @bi array.
981  *
982  * Scans the @bi array for bindings that need to be emitted and
983  * builds a buffer of SVGA3dVertexBuffer data.
984  * On output, @cbs->bind_cmd_count contains the number of bindings to be
985  * emitted, @cbs->bind_first_slot indicates the index of the first emitted
986  * binding, and @cbs->bind_cmd_buffer contains the command data.
987  */
988 static void vmw_collect_dirty_vbs(struct vmw_ctx_binding_state *cbs,
989 				  const struct vmw_ctx_bindinfo *bi,
990 				  unsigned long *dirty,
991 				  u32 max_num)
992 {
993 	const struct vmw_ctx_bindinfo_vb *biv =
994 		container_of(bi, struct vmw_ctx_bindinfo_vb, bi);
995 	unsigned long i, next_bit;
996 	SVGA3dVertexBuffer *vbs = (SVGA3dVertexBuffer *) &cbs->bind_cmd_buffer;
997 
998 	cbs->bind_cmd_count = 0;
999 	i = find_first_bit(dirty, max_num);
1000 	next_bit = i;
1001 	cbs->bind_first_slot = i;
1002 
1003 	biv += i;
1004 	for (; i < max_num; ++i, ++biv, ++vbs) {
1005 		if (!biv->bi.ctx || biv->bi.scrubbed) {
1006 			vbs->sid = SVGA3D_INVALID_ID;
1007 			vbs->stride = 0;
1008 			vbs->offset = 0;
1009 		} else {
1010 			vbs->sid = biv->bi.res->id;
1011 			vbs->stride = biv->stride;
1012 			vbs->offset = biv->offset;
1013 		}
1014 		cbs->bind_cmd_count++;
1015 		if (next_bit == i) {
1016 			next_bit = find_next_bit(dirty, max_num, i + 1);
1017 			if (next_bit >= max_num)
1018 				break;
1019 		}
1020 	}
1021 }
1022 
1023 /**
1024  * vmw_binding_emit_set_vb - Issue delayed vertex buffer binding commands
1025  *
1026  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
1027  *
1028  */
1029 static int vmw_emit_set_vb(struct vmw_ctx_binding_state *cbs)
1030 {
1031 	const struct vmw_ctx_bindinfo *loc =
1032 		&cbs->vertex_buffers[0].bi;
1033 	struct {
1034 		SVGA3dCmdHeader header;
1035 		SVGA3dCmdDXSetVertexBuffers body;
1036 	} *cmd;
1037 	size_t cmd_size, set_vb_size;
1038 	const struct vmw_resource *ctx = vmw_cbs_context(cbs);
1039 
1040 	vmw_collect_dirty_vbs(cbs, loc, cbs->dirty_vb,
1041 			     SVGA3D_DX_MAX_VERTEXBUFFERS);
1042 	if (cbs->bind_cmd_count == 0)
1043 		return 0;
1044 
1045 	set_vb_size = cbs->bind_cmd_count*sizeof(SVGA3dVertexBuffer);
1046 	cmd_size = sizeof(*cmd) + set_vb_size;
1047 	cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
1048 	if (unlikely(cmd == NULL))
1049 		return -ENOMEM;
1050 
1051 	cmd->header.id = SVGA_3D_CMD_DX_SET_VERTEX_BUFFERS;
1052 	cmd->header.size = sizeof(cmd->body) + set_vb_size;
1053 	cmd->body.startBuffer = cbs->bind_first_slot;
1054 
1055 	memcpy(&cmd[1], cbs->bind_cmd_buffer, set_vb_size);
1056 
1057 	vmw_cmd_commit(ctx->dev_priv, cmd_size);
1058 	bitmap_clear(cbs->dirty_vb,
1059 		     cbs->bind_first_slot, cbs->bind_cmd_count);
1060 
1061 	return 0;
1062 }
1063 
1064 static int vmw_emit_set_uav(struct vmw_ctx_binding_state *cbs)
1065 {
1066 	const struct vmw_ctx_bindinfo *loc = &cbs->ua_views[0].views[0].bi;
1067 	struct {
1068 		SVGA3dCmdHeader header;
1069 		SVGA3dCmdDXSetUAViews body;
1070 	} *cmd;
1071 	size_t cmd_size, view_id_size;
1072 	const struct vmw_resource *ctx = vmw_cbs_context(cbs);
1073 
1074 	vmw_collect_view_ids(cbs, loc, SVGA3D_MAX_UAVIEWS);
1075 	view_id_size = cbs->bind_cmd_count*sizeof(uint32);
1076 	cmd_size = sizeof(*cmd) + view_id_size;
1077 	cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
1078 	if (!cmd)
1079 		return -ENOMEM;
1080 
1081 	cmd->header.id = SVGA_3D_CMD_DX_SET_UA_VIEWS;
1082 	cmd->header.size = sizeof(cmd->body) + view_id_size;
1083 
1084 	/* Splice index is specified user-space   */
1085 	cmd->body.uavSpliceIndex = cbs->ua_views[0].index;
1086 
1087 	memcpy(&cmd[1], cbs->bind_cmd_buffer, view_id_size);
1088 
1089 	vmw_cmd_commit(ctx->dev_priv, cmd_size);
1090 
1091 	return 0;
1092 }
1093 
1094 static int vmw_emit_set_cs_uav(struct vmw_ctx_binding_state *cbs)
1095 {
1096 	const struct vmw_ctx_bindinfo *loc = &cbs->ua_views[1].views[0].bi;
1097 	struct {
1098 		SVGA3dCmdHeader header;
1099 		SVGA3dCmdDXSetCSUAViews body;
1100 	} *cmd;
1101 	size_t cmd_size, view_id_size;
1102 	const struct vmw_resource *ctx = vmw_cbs_context(cbs);
1103 
1104 	vmw_collect_view_ids(cbs, loc, SVGA3D_MAX_UAVIEWS);
1105 	view_id_size = cbs->bind_cmd_count*sizeof(uint32);
1106 	cmd_size = sizeof(*cmd) + view_id_size;
1107 	cmd = VMW_CMD_CTX_RESERVE(ctx->dev_priv, cmd_size, ctx->id);
1108 	if (!cmd)
1109 		return -ENOMEM;
1110 
1111 	cmd->header.id = SVGA_3D_CMD_DX_SET_CS_UA_VIEWS;
1112 	cmd->header.size = sizeof(cmd->body) + view_id_size;
1113 
1114 	/* Start index is specified user-space */
1115 	cmd->body.startIndex = cbs->ua_views[1].index;
1116 
1117 	memcpy(&cmd[1], cbs->bind_cmd_buffer, view_id_size);
1118 
1119 	vmw_cmd_commit(ctx->dev_priv, cmd_size);
1120 
1121 	return 0;
1122 }
1123 
1124 /**
1125  * vmw_binding_emit_dirty - Issue delayed binding commands
1126  *
1127  * @cbs: Pointer to the context's struct vmw_ctx_binding_state
1128  *
1129  * This function issues the delayed binding commands that arise from
1130  * previous scrub / unscrub calls. These binding commands are typically
1131  * commands that batch a number of bindings and therefore it makes sense
1132  * to delay them.
1133  */
1134 static int vmw_binding_emit_dirty(struct vmw_ctx_binding_state *cbs)
1135 {
1136 	int ret = 0;
1137 	unsigned long hit = 0;
1138 
1139 	while ((hit = find_next_bit(&cbs->dirty, VMW_BINDING_NUM_BITS, hit))
1140 	      < VMW_BINDING_NUM_BITS) {
1141 
1142 		switch (hit) {
1143 		case VMW_BINDING_RT_BIT:
1144 			ret = vmw_emit_set_rt(cbs);
1145 			break;
1146 		case VMW_BINDING_PS_BIT:
1147 			ret = vmw_binding_emit_dirty_ps(cbs);
1148 			break;
1149 		case VMW_BINDING_SO_T_BIT:
1150 			ret = vmw_emit_set_so_target(cbs);
1151 			break;
1152 		case VMW_BINDING_VB_BIT:
1153 			ret = vmw_emit_set_vb(cbs);
1154 			break;
1155 		case VMW_BINDING_UAV_BIT:
1156 			ret = vmw_emit_set_uav(cbs);
1157 			break;
1158 		case VMW_BINDING_CS_UAV_BIT:
1159 			ret = vmw_emit_set_cs_uav(cbs);
1160 			break;
1161 		default:
1162 			BUG();
1163 		}
1164 		if (ret)
1165 			return ret;
1166 
1167 		__clear_bit(hit, &cbs->dirty);
1168 		hit++;
1169 	}
1170 
1171 	return 0;
1172 }
1173 
1174 /**
1175  * vmw_binding_scrub_sr - Schedule a dx shaderresource binding
1176  * scrub from a context
1177  *
1178  * @bi: single binding information.
1179  * @rebind: Whether to issue a bind instead of scrub command.
1180  */
1181 static int vmw_binding_scrub_sr(struct vmw_ctx_bindinfo *bi, bool rebind)
1182 {
1183 	struct vmw_ctx_bindinfo_view *biv =
1184 		container_of(bi, struct vmw_ctx_bindinfo_view, bi);
1185 	struct vmw_ctx_binding_state *cbs =
1186 		vmw_context_binding_state(bi->ctx);
1187 
1188 	__set_bit(biv->slot, cbs->per_shader[biv->shader_slot].dirty_sr);
1189 	__set_bit(VMW_BINDING_PS_SR_BIT,
1190 		  &cbs->per_shader[biv->shader_slot].dirty);
1191 	__set_bit(VMW_BINDING_PS_BIT, &cbs->dirty);
1192 
1193 	return 0;
1194 }
1195 
1196 /**
1197  * vmw_binding_scrub_dx_rt - Schedule a dx rendertarget binding
1198  * scrub from a context
1199  *
1200  * @bi: single binding information.
1201  * @rebind: Whether to issue a bind instead of scrub command.
1202  */
1203 static int vmw_binding_scrub_dx_rt(struct vmw_ctx_bindinfo *bi, bool rebind)
1204 {
1205 	struct vmw_ctx_binding_state *cbs =
1206 		vmw_context_binding_state(bi->ctx);
1207 
1208 	__set_bit(VMW_BINDING_RT_BIT, &cbs->dirty);
1209 
1210 	return 0;
1211 }
1212 
1213 /**
1214  * vmw_binding_scrub_so_target - Schedule a dx streamoutput buffer binding
1215  * scrub from a context
1216  *
1217  * @bi: single binding information.
1218  * @rebind: Whether to issue a bind instead of scrub command.
1219  */
1220 static int vmw_binding_scrub_so_target(struct vmw_ctx_bindinfo *bi, bool rebind)
1221 {
1222 	struct vmw_ctx_binding_state *cbs =
1223 		vmw_context_binding_state(bi->ctx);
1224 
1225 	__set_bit(VMW_BINDING_SO_T_BIT, &cbs->dirty);
1226 
1227 	return 0;
1228 }
1229 
1230 /**
1231  * vmw_binding_scrub_vb - Schedule a dx vertex buffer binding
1232  * scrub from a context
1233  *
1234  * @bi: single binding information.
1235  * @rebind: Whether to issue a bind instead of scrub command.
1236  */
1237 static int vmw_binding_scrub_vb(struct vmw_ctx_bindinfo *bi, bool rebind)
1238 {
1239 	struct vmw_ctx_bindinfo_vb *bivb =
1240 		container_of(bi, struct vmw_ctx_bindinfo_vb, bi);
1241 	struct vmw_ctx_binding_state *cbs =
1242 		vmw_context_binding_state(bi->ctx);
1243 
1244 	__set_bit(bivb->slot, cbs->dirty_vb);
1245 	__set_bit(VMW_BINDING_VB_BIT, &cbs->dirty);
1246 
1247 	return 0;
1248 }
1249 
1250 /**
1251  * vmw_binding_scrub_ib - scrub a dx index buffer binding from a context
1252  *
1253  * @bi: single binding information.
1254  * @rebind: Whether to issue a bind instead of scrub command.
1255  */
1256 static int vmw_binding_scrub_ib(struct vmw_ctx_bindinfo *bi, bool rebind)
1257 {
1258 	struct vmw_ctx_bindinfo_ib *binding =
1259 		container_of(bi, typeof(*binding), bi);
1260 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
1261 	struct {
1262 		SVGA3dCmdHeader header;
1263 		SVGA3dCmdDXSetIndexBuffer body;
1264 	} *cmd;
1265 
1266 	cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), bi->ctx->id);
1267 	if (unlikely(cmd == NULL))
1268 		return -ENOMEM;
1269 
1270 	cmd->header.id = SVGA_3D_CMD_DX_SET_INDEX_BUFFER;
1271 	cmd->header.size = sizeof(cmd->body);
1272 	if (rebind) {
1273 		cmd->body.sid = bi->res->id;
1274 		cmd->body.format = binding->format;
1275 		cmd->body.offset = binding->offset;
1276 	} else {
1277 		cmd->body.sid = SVGA3D_INVALID_ID;
1278 		cmd->body.format = 0;
1279 		cmd->body.offset = 0;
1280 	}
1281 
1282 	vmw_cmd_commit(dev_priv, sizeof(*cmd));
1283 
1284 	return 0;
1285 }
1286 
1287 static int vmw_binding_scrub_uav(struct vmw_ctx_bindinfo *bi, bool rebind)
1288 {
1289 	struct vmw_ctx_binding_state *cbs = vmw_context_binding_state(bi->ctx);
1290 
1291 	__set_bit(VMW_BINDING_UAV_BIT, &cbs->dirty);
1292 	return 0;
1293 }
1294 
1295 static int vmw_binding_scrub_cs_uav(struct vmw_ctx_bindinfo *bi, bool rebind)
1296 {
1297 	struct vmw_ctx_binding_state *cbs = vmw_context_binding_state(bi->ctx);
1298 
1299 	__set_bit(VMW_BINDING_CS_UAV_BIT, &cbs->dirty);
1300 	return 0;
1301 }
1302 
1303 /**
1304  * vmw_binding_scrub_so - Scrub a streamoutput binding from context.
1305  * @bi: Single binding information.
1306  * @rebind: Whether to issue a bind instead of scrub command.
1307  */
1308 static int vmw_binding_scrub_so(struct vmw_ctx_bindinfo *bi, bool rebind)
1309 {
1310 	struct vmw_ctx_bindinfo_so *binding =
1311 		container_of(bi, typeof(*binding), bi);
1312 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
1313 	struct {
1314 		SVGA3dCmdHeader header;
1315 		SVGA3dCmdDXSetStreamOutput body;
1316 	} *cmd;
1317 
1318 	cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), bi->ctx->id);
1319 	if (!cmd)
1320 		return -ENOMEM;
1321 
1322 	cmd->header.id = SVGA_3D_CMD_DX_SET_STREAMOUTPUT;
1323 	cmd->header.size = sizeof(cmd->body);
1324 	cmd->body.soid = rebind ? bi->res->id : SVGA3D_INVALID_ID;
1325 	vmw_cmd_commit(dev_priv, sizeof(*cmd));
1326 
1327 	return 0;
1328 }
1329 
1330 /**
1331  * vmw_binding_state_alloc - Allocate a struct vmw_ctx_binding_state with
1332  * memory accounting.
1333  *
1334  * @dev_priv: Pointer to a device private structure.
1335  *
1336  * Returns a pointer to a newly allocated struct or an error pointer on error.
1337  */
1338 struct vmw_ctx_binding_state *
1339 vmw_binding_state_alloc(struct vmw_private *dev_priv)
1340 {
1341 	struct vmw_ctx_binding_state *cbs;
1342 	struct ttm_operation_ctx ctx = {
1343 		.interruptible = false,
1344 		.no_wait_gpu = false
1345 	};
1346 	int ret;
1347 
1348 	ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), sizeof(*cbs),
1349 				&ctx);
1350 	if (ret)
1351 		return ERR_PTR(ret);
1352 
1353 	cbs = vzalloc(sizeof(*cbs));
1354 	if (!cbs) {
1355 		ttm_mem_global_free(vmw_mem_glob(dev_priv), sizeof(*cbs));
1356 		return ERR_PTR(-ENOMEM);
1357 	}
1358 
1359 	cbs->dev_priv = dev_priv;
1360 	INIT_LIST_HEAD(&cbs->list);
1361 
1362 	return cbs;
1363 }
1364 
1365 /**
1366  * vmw_binding_state_free - Free a struct vmw_ctx_binding_state and its
1367  * memory accounting info.
1368  *
1369  * @cbs: Pointer to the struct vmw_ctx_binding_state to be freed.
1370  */
1371 void vmw_binding_state_free(struct vmw_ctx_binding_state *cbs)
1372 {
1373 	struct vmw_private *dev_priv = cbs->dev_priv;
1374 
1375 	vfree(cbs);
1376 	ttm_mem_global_free(vmw_mem_glob(dev_priv), sizeof(*cbs));
1377 }
1378 
1379 /**
1380  * vmw_binding_state_list - Get the binding list of a
1381  * struct vmw_ctx_binding_state
1382  *
1383  * @cbs: Pointer to the struct vmw_ctx_binding_state
1384  *
1385  * Returns the binding list which can be used to traverse through the bindings
1386  * and access the resource information of all bindings.
1387  */
1388 struct list_head *vmw_binding_state_list(struct vmw_ctx_binding_state *cbs)
1389 {
1390 	return &cbs->list;
1391 }
1392 
1393 /**
1394  * vmwgfx_binding_state_reset - clear a struct vmw_ctx_binding_state
1395  *
1396  * @cbs: Pointer to the struct vmw_ctx_binding_state to be cleared
1397  *
1398  * Drops all bindings registered in @cbs. No device binding actions are
1399  * performed.
1400  */
1401 void vmw_binding_state_reset(struct vmw_ctx_binding_state *cbs)
1402 {
1403 	struct vmw_ctx_bindinfo *entry, *next;
1404 
1405 	list_for_each_entry_safe(entry, next, &cbs->list, ctx_list)
1406 		vmw_binding_drop(entry);
1407 }
1408 
1409 /**
1410  * vmw_binding_dirtying - Return whether a binding type is dirtying its resource
1411  * @binding_type: The binding type
1412  *
1413  * Each time a resource is put on the validation list as the result of a
1414  * context binding referencing it, we need to determine whether that resource
1415  * will be dirtied (written to by the GPU) as a result of the corresponding
1416  * GPU operation. Currently rendertarget-, depth-stencil-, stream-output-target
1417  * and unordered access view bindings are capable of dirtying its resource.
1418  *
1419  * Return: Whether the binding type dirties the resource its binding points to.
1420  */
1421 u32 vmw_binding_dirtying(enum vmw_ctx_binding_type binding_type)
1422 {
1423 	static u32 is_binding_dirtying[vmw_ctx_binding_max] = {
1424 		[vmw_ctx_binding_rt] = VMW_RES_DIRTY_SET,
1425 		[vmw_ctx_binding_dx_rt] = VMW_RES_DIRTY_SET,
1426 		[vmw_ctx_binding_ds] = VMW_RES_DIRTY_SET,
1427 		[vmw_ctx_binding_so_target] = VMW_RES_DIRTY_SET,
1428 		[vmw_ctx_binding_uav] = VMW_RES_DIRTY_SET,
1429 		[vmw_ctx_binding_cs_uav] = VMW_RES_DIRTY_SET,
1430 	};
1431 
1432 	/* Review this function as new bindings are added. */
1433 	BUILD_BUG_ON(vmw_ctx_binding_max != 14);
1434 	return is_binding_dirtying[binding_type];
1435 }
1436 
1437 /*
1438  * This function is unused at run-time, and only used to hold various build
1439  * asserts important for code optimization assumptions.
1440  */
1441 static void vmw_binding_build_asserts(void)
1442 {
1443 	BUILD_BUG_ON(SVGA3D_NUM_SHADERTYPE_DX10 != 3);
1444 	BUILD_BUG_ON(SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS > SVGA3D_RT_MAX);
1445 	BUILD_BUG_ON(sizeof(uint32) != sizeof(u32));
1446 
1447 	/*
1448 	 * struct vmw_ctx_binding_state::bind_cmd_buffer is used for various
1449 	 * view id arrays.
1450 	 */
1451 	BUILD_BUG_ON(VMW_MAX_VIEW_BINDINGS < SVGA3D_RT_MAX);
1452 	BUILD_BUG_ON(VMW_MAX_VIEW_BINDINGS < SVGA3D_DX_MAX_SRVIEWS);
1453 	BUILD_BUG_ON(VMW_MAX_VIEW_BINDINGS < SVGA3D_DX_MAX_CONSTBUFFERS);
1454 
1455 	/*
1456 	 * struct vmw_ctx_binding_state::bind_cmd_buffer is used for
1457 	 * u32 view ids, SVGA3dSoTargets and SVGA3dVertexBuffers
1458 	 */
1459 	BUILD_BUG_ON(SVGA3D_DX_MAX_SOTARGETS*sizeof(SVGA3dSoTarget) >
1460 		     VMW_MAX_VIEW_BINDINGS*sizeof(u32));
1461 	BUILD_BUG_ON(SVGA3D_DX_MAX_VERTEXBUFFERS*sizeof(SVGA3dVertexBuffer) >
1462 		     VMW_MAX_VIEW_BINDINGS*sizeof(u32));
1463 }
1464