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