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