drivers/gpu/drm/vmwgfx/vmwgfx_binding.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /**************************************************************************
   3  *
   4  * Copyright 2015 VMware, Inc., Palo Alto, CA., USA
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27 /*
  28  * This file implements the vmwgfx context binding manager,
  29  * The sole reason for having to use this code is that vmware guest
  30  * backed contexts can be swapped out to their backing mobs by the device
  31  * at any time, also swapped in at any time. At swapin time, the device
  32  * validates the context bindings to make sure they point to valid resources.
  33  * It's this outside-of-drawcall validation (that can happen at any time),
  34  * that makes this code necessary.
  35  *
  36  * We therefore need to kill any context bindings pointing to a resource
  37  * when the resource is swapped out. Furthermore, if the vmwgfx driver has
  38  * swapped out the context we can't swap it in again to kill bindings because
  39  * of backing mob reservation lockdep violations, so as part of
  40  * context swapout, also kill all bindings of a context, so that they are
  41  * already killed if a resource to which a binding points
  42  * needs to be swapped out.
  43  *
  44  * Note that a resource can be pointed to by bindings from multiple contexts,
  45  * Therefore we can't easily protect this data by a per context mutex
  46  * (unless we use deadlock-safe WW mutexes). So we use a global binding_mutex
  47  * to protect all binding manager data.
  48  *
  49  * Finally, any association between a context and a global resource
  50  * (surface, shader or even DX query) is conceptually a context binding that
  51  * needs to be tracked by this code.
  52  */
  53
  54 #include "vmwgfx_drv.h"
  55 #include "vmwgfx_binding.h"
  56 #include "device_include/svga3d_reg.h"
  57
  58 #define VMW_BINDING_RT_BIT     0
  59 #define VMW_BINDING_PS_BIT     1
  60 #define VMW_BINDING_SO_T_BIT   2
  61 #define VMW_BINDING_VB_BIT     3
  62 #define VMW_BINDING_UAV_BIT    4
  63 #define VMW_BINDING_CS_UAV_BIT 5
  64 #define VMW_BINDING_NUM_BITS   6
  65
  66 #define VMW_BINDING_PS_SR_BIT  0
  67
  68 /**
  69  * struct vmw_ctx_binding_state - per context binding state
  70  *
  71  * @dev_priv: Pointer to device private structure.
  72  * @list: linked list of individual active bindings.
  73  * @render_targets: Render target bindings.
  74  * @texture_units: Texture units bindings.
  75  * @ds_view: Depth-stencil view binding.
  76  * @so_targets: StreamOutput target bindings.
  77  * @vertex_buffers: Vertex buffer bindings.
  78  * @index_buffer: Index buffer binding.
  79  * @per_shader: Per shader-type bindings.
  80  * @ua_views: UAV bindings.
  81  * @so_state: StreamOutput bindings.
  82  * @dirty: Bitmap tracking per binding-type changes that have not yet
  83  * been emitted to the device.
  84  * @dirty_vb: Bitmap tracking individual vertex buffer binding changes that
  85  * have not yet been emitted to the device.
  86  * @bind_cmd_buffer: Scratch space used to construct binding commands.
  87  * @bind_cmd_count: Number of binding command data entries in @bind_cmd_buffer
  88  * @bind_first_slot: Used together with @bind_cmd_buffer to indicate the
  89  * device binding slot of the first command data entry in @bind_cmd_buffer.
  90  *
  91  * Note that this structure also provides storage space for the individual
  92  * struct vmw_ctx_binding objects, so that no dynamic allocation is needed
  93  * for individual bindings.
  94  *
  95  */
  96 struct vmw_ctx_binding_state {
  97         struct vmw_private *dev_priv;
  98         struct list_head list;
  99         struct vmw_ctx_bindinfo_view render_targets[SVGA3D_RT_MAX];
 100         struct vmw_ctx_bindinfo_tex texture_units[SVGA3D_NUM_TEXTURE_UNITS];
 101         struct vmw_ctx_bindinfo_view ds_view;
 102         struct vmw_ctx_bindinfo_so_target so_targets[SVGA3D_DX_MAX_SOTARGETS];
 103         struct vmw_ctx_bindinfo_vb vertex_buffers[SVGA3D_DX_MAX_VERTEXBUFFERS];
 104         struct vmw_ctx_bindinfo_ib index_buffer;
 105         struct vmw_dx_shader_bindings per_shader[SVGA3D_NUM_SHADERTYPE];
 106         struct vmw_ctx_bindinfo_uav ua_views[VMW_MAX_UAV_BIND_TYPE];
 107         struct vmw_ctx_bindinfo_so so_state;
 108
 109         unsigned long dirty;
 110         DECLARE_BITMAP(dirty_vb, SVGA3D_DX_MAX_VERTEXBUFFERS);
 111
 112         u32 bind_cmd_buffer[VMW_MAX_VIEW_BINDINGS];
 113         u32 bind_cmd_count;
 114         u32 bind_first_slot;
 115 };
 116
 117 static int vmw_binding_scrub_shader(struct vmw_ctx_bindinfo *bi, bool rebind);
 118 static int vmw_binding_scrub_render_target(struct vmw_ctx_bindinfo *bi,
 119                                            bool rebind);
 120 static int vmw_binding_scrub_texture(struct vmw_ctx_bindinfo *bi, bool rebind);
 121 static int vmw_binding_scrub_cb(struct vmw_ctx_bindinfo *bi, bool rebind);
 122 static int vmw_binding_scrub_dx_rt(struct vmw_ctx_bindinfo *bi, bool rebind);
 123 static int vmw_binding_scrub_sr(struct vmw_ctx_bindinfo *bi, bool rebind);
 124 static int vmw_binding_scrub_so_target(struct vmw_ctx_bindinfo *bi, bool rebind);
 125 static int vmw_binding_emit_dirty(struct vmw_ctx_binding_state *cbs);
 126 static int vmw_binding_scrub_dx_shader(struct vmw_ctx_bindinfo *bi,
 127                                        bool rebind);
 128 static int vmw_binding_scrub_ib(struct vmw_ctx_bindinfo *bi, bool rebind);
 129 static int vmw_binding_scrub_vb(struct vmw_ctx_bindinfo *bi, bool rebind);
 130 static int vmw_binding_scrub_uav(struct vmw_ctx_bindinfo *bi, bool rebind);
 131 static int vmw_binding_scrub_cs_uav(struct vmw_ctx_bindinfo *bi, bool rebind);
 132 static int vmw_binding_scrub_so(struct vmw_ctx_bindinfo *bi, bool rebind);
 133
 134 static void vmw_binding_build_asserts(void) __attribute__ ((unused));
 135
 136 typedef int (*vmw_scrub_func)(struct vmw_ctx_bindinfo *, bool);
 137
 138 /**
 139  * struct vmw_binding_info - Per binding type information for the binding
 140  * manager
 141  *
 142  * @size: The size of the struct binding derived from a struct vmw_ctx_bindinfo.
 143  * @offsets: array[shader_slot] of offsets to the array[slot]
 144  * of struct bindings for the binding type.
 145  * @scrub_func: Pointer to the scrub function for this binding type.
 146  *
 147  * Holds static information to help optimize the binding manager and avoid
 148  * an excessive amount of switch statements.
 149  */
 150 struct vmw_binding_info {
 151         size_t size;
 152         const size_t *offsets;
 153         vmw_scrub_func scrub_func;
 154 };
 155
 156 /*
 157  * A number of static variables that help determine the scrub func and the
 158  * location of the struct vmw_ctx_bindinfo slots for each binding type.
 159  */
 160 static const size_t vmw_binding_shader_offsets[] = {
 161         offsetof(struct vmw_ctx_binding_state, per_shader[0].shader),
 162         offsetof(struct vmw_ctx_binding_state, per_shader[1].shader),
 163         offsetof(struct vmw_ctx_binding_state, per_shader[2].shader),
 164         offsetof(struct vmw_ctx_binding_state, per_shader[3].shader),
 165         offsetof(struct vmw_ctx_binding_state, per_shader[4].shader),
 166         offsetof(struct vmw_ctx_binding_state, per_shader[5].shader),
 167 };
 168 static const size_t vmw_binding_rt_offsets[] = {
 169         offsetof(struct vmw_ctx_binding_state, render_targets),
 170 };
 171 static const size_t vmw_binding_tex_offsets[] = {
 172         offsetof(struct vmw_ctx_binding_state, texture_units),
 173 };
 174 static const size_t vmw_binding_cb_offsets[] = {
 175         offsetof(struct vmw_ctx_binding_state, per_shader[0].const_buffers),
 176         offsetof(struct vmw_ctx_binding_state, per_shader[1].const_buffers),
 177         offsetof(struct vmw_ctx_binding_state, per_shader[2].const_buffers),
 178         offsetof(struct vmw_ctx_binding_state, per_shader[3].const_buffers),
 179         offsetof(struct vmw_ctx_binding_state, per_shader[4].const_buffers),
 180         offsetof(struct vmw_ctx_binding_state, per_shader[5].const_buffers),
 181 };
 182 static const size_t vmw_binding_dx_ds_offsets[] = {
 183         offsetof(struct vmw_ctx_binding_state, ds_view),
 184 };
 185 static const size_t vmw_binding_sr_offsets[] = {
 186         offsetof(struct vmw_ctx_binding_state, per_shader[0].shader_res),
 187         offsetof(struct vmw_ctx_binding_state, per_shader[1].shader_res),
 188         offsetof(struct vmw_ctx_binding_state, per_shader[2].shader_res),
 189         offsetof(struct vmw_ctx_binding_state, per_shader[3].shader_res),
 190         offsetof(struct vmw_ctx_binding_state, per_shader[4].shader_res),
 191         offsetof(struct vmw_ctx_binding_state, per_shader[5].shader_res),
 192 };
 193 static const size_t vmw_binding_so_target_offsets[] = {
 194         offsetof(struct vmw_ctx_binding_state, so_targets),
 195 };
 196 static const size_t vmw_binding_vb_offsets[] = {
 197         offsetof(struct vmw_ctx_binding_state, vertex_buffers),
 198 };
 199 static const size_t vmw_binding_ib_offsets[] = {
 200         offsetof(struct vmw_ctx_binding_state, index_buffer),
 201 };
 202 static const size_t vmw_binding_uav_offsets[] = {
 203         offsetof(struct vmw_ctx_binding_state, ua_views[0].views),
 204 };
 205 static const size_t vmw_binding_cs_uav_offsets[] = {
 206         offsetof(struct vmw_ctx_binding_state, ua_views[1].views),
 207 };
 208 static const size_t vmw_binding_so_offsets[] = {
 209         offsetof(struct vmw_ctx_binding_state, so_state),
 210 };
 211
 212 static const struct vmw_binding_info vmw_binding_infos[] = {
 213         [vmw_ctx_binding_shader] = {
 214                 .size = sizeof(struct vmw_ctx_bindinfo_shader),
 215                 .offsets = vmw_binding_shader_offsets,
 216                 .scrub_func = vmw_binding_scrub_shader},
 217         [vmw_ctx_binding_rt] = {
 218                 .size = sizeof(struct vmw_ctx_bindinfo_view),
 219                 .offsets = vmw_binding_rt_offsets,
 220                 .scrub_func = vmw_binding_scrub_render_target},
 221         [vmw_ctx_binding_tex] = {
 222                 .size = sizeof(struct vmw_ctx_bindinfo_tex),
 223                 .offsets = vmw_binding_tex_offsets,
 224                 .scrub_func = vmw_binding_scrub_texture},
 225         [vmw_ctx_binding_cb] = {
 226                 .size = sizeof(struct vmw_ctx_bindinfo_cb),
 227                 .offsets = vmw_binding_cb_offsets,
 228                 .scrub_func = vmw_binding_scrub_cb},
 229         [vmw_ctx_binding_dx_shader] = {
 230                 .size = sizeof(struct vmw_ctx_bindinfo_shader),
 231                 .offsets = vmw_binding_shader_offsets,
 232                 .scrub_func = vmw_binding_scrub_dx_shader},
 233         [vmw_ctx_binding_dx_rt] = {
 234                 .size = sizeof(struct vmw_ctx_bindinfo_view),
 235                 .offsets = vmw_binding_rt_offsets,
 236                 .scrub_func = vmw_binding_scrub_dx_rt},
 237         [vmw_ctx_binding_sr] = {
 238                 .size = sizeof(struct vmw_ctx_bindinfo_view),
 239                 .offsets = vmw_binding_sr_offsets,
 240                 .scrub_func = vmw_binding_scrub_sr},
 241         [vmw_ctx_binding_ds] = {
 242                 .size = sizeof(struct vmw_ctx_bindinfo_view),
 243                 .offsets = vmw_binding_dx_ds_offsets,
 244                 .scrub_func = vmw_binding_scrub_dx_rt},
 245         [vmw_ctx_binding_so_target] = {
 246                 .size = sizeof(struct vmw_ctx_bindinfo_so_target),
 247                 .offsets = vmw_binding_so_target_offsets,
 248                 .scrub_func = vmw_binding_scrub_so_target},
 249         [vmw_ctx_binding_vb] = {
 250                 .size = sizeof(struct vmw_ctx_bindinfo_vb),
 251                 .offsets = vmw_binding_vb_offsets,
 252                 .scrub_func = vmw_binding_scrub_vb},
 253         [vmw_ctx_binding_ib] = {
 254                 .size = sizeof(struct vmw_ctx_bindinfo_ib),
 255                 .offsets = vmw_binding_ib_offsets,
 256                 .scrub_func = vmw_binding_scrub_ib},
 257         [vmw_ctx_binding_uav] = {
 258                 .size = sizeof(struct vmw_ctx_bindinfo_view),
 259                 .offsets = vmw_binding_uav_offsets,
 260                 .scrub_func = vmw_binding_scrub_uav},
 261         [vmw_ctx_binding_cs_uav] = {
 262                 .size = sizeof(struct vmw_ctx_bindinfo_view),
 263                 .offsets = vmw_binding_cs_uav_offsets,
 264                 .scrub_func = vmw_binding_scrub_cs_uav},
 265         [vmw_ctx_binding_so] = {
 266                 .size = sizeof(struct vmw_ctx_bindinfo_so),
 267                 .offsets = vmw_binding_so_offsets,
 268                 .scrub_func = vmw_binding_scrub_so},
 269 };
 270
 271 /**
 272  * vmw_cbs_context - Return a pointer to the context resource of a
 273  * context binding state tracker.
 274  *
 275  * @cbs: The context binding state tracker.
 276  *
 277  * Provided there are any active bindings, this function will return an
 278  * unreferenced pointer to the context resource that owns the context
 279  * binding state tracker. If there are no active bindings, this function
 280  * will return NULL. Note that the caller must somehow ensure that a reference
 281  * is held on the context resource prior to calling this function.
 282  */
 283 static const struct vmw_resource *
 284 vmw_cbs_context(const struct vmw_ctx_binding_state *cbs)
 285 {
 286         if (list_empty(&cbs->list))
 287                 return NULL;
 288
 289         return list_first_entry(&cbs->list, struct vmw_ctx_bindinfo,
 290                                 ctx_list)->ctx;
 291 }
 292
 293 /**
 294  * vmw_binding_loc - determine the struct vmw_ctx_bindinfo slot location.
 295  *
 296  * @cbs: Pointer to a struct vmw_ctx_binding state which holds the slot.
 297  * @bt: The binding type.
 298  * @shader_slot: The shader slot of the binding. If none, then set to 0.
 299  * @slot: The slot of the binding.
 300  */
 301 static struct vmw_ctx_bindinfo *
 302 vmw_binding_loc(struct vmw_ctx_binding_state *cbs,
 303                 enum vmw_ctx_binding_type bt, u32 shader_slot, u32 slot)
 304 {
 305         const struct vmw_binding_info *b = &vmw_binding_infos[bt];
 306         size_t offset = b->offsets[shader_slot] + b->size*slot;
 307
 308         return (struct vmw_ctx_bindinfo *)((u8 *) cbs + offset);
 309 }
 310
 311 /**
 312  * vmw_binding_drop: Stop tracking a context binding
 313  *
 314  * @bi: Pointer to binding tracker storage.
 315  *
 316  * Stops tracking a context binding, and re-initializes its storage.
 317  * Typically used when the context binding is replaced with a binding to
 318  * another (or the same, for that matter) resource.
 319  */
 320 static void vmw_binding_drop(struct vmw_ctx_bindinfo *bi)
 321 {
 322         list_del(&bi->ctx_list);
 323         if (!list_empty(&bi->res_list))
 324                 list_del(&bi->res_list);
 325         bi->ctx = NULL;
 326 }
 327
 328 /**
 329  * vmw_binding_add: Start tracking a context binding
 330  *
 331  * @cbs: Pointer to the context binding state tracker.
 332  * @bi: Information about the binding to track.
 333  * @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  */
 339 void 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  */
 367 void 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  */
 383 void 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  */
 397 static 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  */
 427 void 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  */
 445 void 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  */
 469 void 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  */
 487 void 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  */
 519 void 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  */
 542 int 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  */
 571 static 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  */
 602 static 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  */
 638 static 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  */
 673 static 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  */
 702 static 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  */
 748 static 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  */
 781 static 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  */
 815 static 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  */
 858 static 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  */
 905 static 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  */
 937 static 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  */
 973 static 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  */
1008 static 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  */
1049 static 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
1084 static 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
1114 static 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  */
1154 static 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  */
1201 static 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  */
1223 static 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  */
1240 static 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  */
1257 static 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  */
1276 static 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
1307 static 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
1315 static 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  */
1328 static 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  */
1357 struct vmw_ctx_binding_state *
1358 vmw_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  */
1378 void 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  */
1392 struct 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  */
1405 void 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  */
1425 u32 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  */
1445 static 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 }