drivers/gpu/drm/vmwgfx/vmwgfx_streamoutput.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /**************************************************************************
   3  *
   4  * Copyright © 2018-2023 VMware, Inc., Palo Alto, CA., USA
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  22  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  23  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  24  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  25  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 #include "vmwgfx_binding.h"
  30 #include "vmwgfx_bo.h"
  31 #include "vmwgfx_drv.h"
  32 #include "vmwgfx_resource_priv.h"
  33
  34 #include <drm/ttm/ttm_placement.h>
  35
  36 /**
  37  * struct vmw_dx_streamoutput - Streamoutput resource metadata.
  38  * @res: Base resource struct.
  39  * @ctx: Non-refcounted context to which @res belong.
  40  * @cotable: Refcounted cotable holding this Streamoutput.
  41  * @cotable_head: List head for cotable-so_res list.
  42  * @id: User-space provided identifier.
  43  * @size: User-space provided mob size.
  44  * @committed: Whether streamoutput is actually created or pending creation.
  45  */
  46 struct vmw_dx_streamoutput {
  47         struct vmw_resource res;
  48         struct vmw_resource *ctx;
  49         struct vmw_resource *cotable;
  50         struct list_head cotable_head;
  51         u32 id;
  52         u32 size;
  53         bool committed;
  54 };
  55
  56 static int vmw_dx_streamoutput_create(struct vmw_resource *res);
  57 static int vmw_dx_streamoutput_bind(struct vmw_resource *res,
  58                                     struct ttm_validate_buffer *val_buf);
  59 static int vmw_dx_streamoutput_unbind(struct vmw_resource *res, bool readback,
  60                                       struct ttm_validate_buffer *val_buf);
  61 static void vmw_dx_streamoutput_commit_notify(struct vmw_resource *res,
  62                                               enum vmw_cmdbuf_res_state state);
  63
  64 static const struct vmw_res_func vmw_dx_streamoutput_func = {
  65         .res_type = vmw_res_streamoutput,
  66         .needs_guest_memory = true,
  67         .may_evict = false,
  68         .type_name = "DX streamoutput",
  69         .domain = VMW_BO_DOMAIN_MOB,
  70         .busy_domain = VMW_BO_DOMAIN_MOB,
  71         .create = vmw_dx_streamoutput_create,
  72         .destroy = NULL, /* Command buffer managed resource. */
  73         .bind = vmw_dx_streamoutput_bind,
  74         .unbind = vmw_dx_streamoutput_unbind,
  75         .commit_notify = vmw_dx_streamoutput_commit_notify,
  76 };
  77
  78 static inline struct vmw_dx_streamoutput *
  79 vmw_res_to_dx_streamoutput(struct vmw_resource *res)
  80 {
  81         return container_of(res, struct vmw_dx_streamoutput, res);
  82 }
  83
  84 /**
  85  * vmw_dx_streamoutput_unscrub - Reattach the MOB to streamoutput.
  86  * @res: The streamoutput resource.
  87  *
  88  * Return: 0 on success, negative error code on failure.
  89  */
  90 static int vmw_dx_streamoutput_unscrub(struct vmw_resource *res)
  91 {
  92         struct vmw_dx_streamoutput *so = vmw_res_to_dx_streamoutput(res);
  93         struct vmw_private *dev_priv = res->dev_priv;
  94         struct {
  95                 SVGA3dCmdHeader header;
  96                 SVGA3dCmdDXBindStreamOutput body;
  97         } *cmd;
  98
  99         if (!list_empty(&so->cotable_head) || !so->committed )
 100                 return 0;
 101
 102         cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), so->ctx->id);
 103         if (!cmd)
 104                 return -ENOMEM;
 105
 106         cmd->header.id = SVGA_3D_CMD_DX_BIND_STREAMOUTPUT;
 107         cmd->header.size = sizeof(cmd->body);
 108         cmd->body.soid = so->id;
 109         cmd->body.mobid = res->guest_memory_bo->tbo.resource->start;
 110         cmd->body.offsetInBytes = res->guest_memory_offset;
 111         cmd->body.sizeInBytes = so->size;
 112         vmw_cmd_commit(dev_priv, sizeof(*cmd));
 113
 114         vmw_cotable_add_resource(so->cotable, &so->cotable_head);
 115
 116         return 0;
 117 }
 118
 119 static int vmw_dx_streamoutput_create(struct vmw_resource *res)
 120 {
 121         struct vmw_private *dev_priv = res->dev_priv;
 122         struct vmw_dx_streamoutput *so = vmw_res_to_dx_streamoutput(res);
 123         int ret = 0;
 124
 125         WARN_ON_ONCE(!so->committed);
 126
 127         if (vmw_resource_mob_attached(res)) {
 128                 mutex_lock(&dev_priv->binding_mutex);
 129                 ret = vmw_dx_streamoutput_unscrub(res);
 130                 mutex_unlock(&dev_priv->binding_mutex);
 131         }
 132
 133         res->id = so->id;
 134
 135         return ret;
 136 }
 137
 138 static int vmw_dx_streamoutput_bind(struct vmw_resource *res,
 139                                     struct ttm_validate_buffer *val_buf)
 140 {
 141         struct vmw_private *dev_priv = res->dev_priv;
 142         struct ttm_buffer_object *bo = val_buf->bo;
 143         int ret;
 144
 145         if (WARN_ON(bo->resource->mem_type != VMW_PL_MOB))
 146                 return -EINVAL;
 147
 148         mutex_lock(&dev_priv->binding_mutex);
 149         ret = vmw_dx_streamoutput_unscrub(res);
 150         mutex_unlock(&dev_priv->binding_mutex);
 151
 152         return ret;
 153 }
 154
 155 /**
 156  * vmw_dx_streamoutput_scrub - Unbind the MOB from streamoutput.
 157  * @res: The streamoutput resource.
 158  *
 159  * Return: 0 on success, negative error code on failure.
 160  */
 161 static int vmw_dx_streamoutput_scrub(struct vmw_resource *res)
 162 {
 163         struct vmw_private *dev_priv = res->dev_priv;
 164         struct vmw_dx_streamoutput *so = vmw_res_to_dx_streamoutput(res);
 165         struct {
 166                 SVGA3dCmdHeader header;
 167                 SVGA3dCmdDXBindStreamOutput body;
 168         } *cmd;
 169
 170         if (list_empty(&so->cotable_head))
 171                 return 0;
 172
 173         WARN_ON_ONCE(!so->committed);
 174
 175         cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), so->ctx->id);
 176         if (!cmd)
 177                 return -ENOMEM;
 178
 179         cmd->header.id = SVGA_3D_CMD_DX_BIND_STREAMOUTPUT;
 180         cmd->header.size = sizeof(cmd->body);
 181         cmd->body.soid = res->id;
 182         cmd->body.mobid = SVGA3D_INVALID_ID;
 183         cmd->body.offsetInBytes = 0;
 184         cmd->body.sizeInBytes = so->size;
 185         vmw_cmd_commit(dev_priv, sizeof(*cmd));
 186
 187         res->id = -1;
 188         list_del_init(&so->cotable_head);
 189
 190         return 0;
 191 }
 192
 193 static int vmw_dx_streamoutput_unbind(struct vmw_resource *res, bool readback,
 194                                       struct ttm_validate_buffer *val_buf)
 195 {
 196         struct vmw_private *dev_priv = res->dev_priv;
 197         struct vmw_fence_obj *fence;
 198         int ret;
 199
 200         if (WARN_ON(res->guest_memory_bo->tbo.resource->mem_type != VMW_PL_MOB))
 201                 return -EINVAL;
 202
 203         mutex_lock(&dev_priv->binding_mutex);
 204         ret = vmw_dx_streamoutput_scrub(res);
 205         mutex_unlock(&dev_priv->binding_mutex);
 206
 207         if (ret)
 208                 return ret;
 209
 210         (void) vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
 211         vmw_bo_fence_single(val_buf->bo, fence);
 212
 213         if (fence != NULL)
 214                 vmw_fence_obj_unreference(&fence);
 215
 216         return 0;
 217 }
 218
 219 static void vmw_dx_streamoutput_commit_notify(struct vmw_resource *res,
 220                                            enum vmw_cmdbuf_res_state state)
 221 {
 222         struct vmw_private *dev_priv = res->dev_priv;
 223         struct vmw_dx_streamoutput *so = vmw_res_to_dx_streamoutput(res);
 224
 225         if (state == VMW_CMDBUF_RES_ADD) {
 226                 mutex_lock(&dev_priv->binding_mutex);
 227                 vmw_cotable_add_resource(so->cotable, &so->cotable_head);
 228                 so->committed = true;
 229                 res->id = so->id;
 230                 mutex_unlock(&dev_priv->binding_mutex);
 231         } else {
 232                 mutex_lock(&dev_priv->binding_mutex);
 233                 list_del_init(&so->cotable_head);
 234                 so->committed = false;
 235                 res->id = -1;
 236                 mutex_unlock(&dev_priv->binding_mutex);
 237         }
 238 }
 239
 240 /**
 241  * vmw_dx_streamoutput_lookup - Do a streamoutput resource lookup by user key.
 242  * @man: Command buffer managed resource manager for current context.
 243  * @user_key: User-space identifier for lookup.
 244  *
 245  * Return: Valid refcounted vmw_resource on success, error pointer on failure.
 246  */
 247 struct vmw_resource *
 248 vmw_dx_streamoutput_lookup(struct vmw_cmdbuf_res_manager *man,
 249                            u32 user_key)
 250 {
 251         return vmw_cmdbuf_res_lookup(man, vmw_cmdbuf_res_streamoutput,
 252                                      user_key);
 253 }
 254
 255 static void vmw_dx_streamoutput_res_free(struct vmw_resource *res)
 256 {
 257         struct vmw_dx_streamoutput *so = vmw_res_to_dx_streamoutput(res);
 258
 259         vmw_resource_unreference(&so->cotable);
 260         kfree(so);
 261 }
 262
 263 static void vmw_dx_streamoutput_hw_destroy(struct vmw_resource *res)
 264 {
 265         /* Destroyed by user-space cmd buf or as part of context takedown. */
 266         res->id = -1;
 267 }
 268
 269 /**
 270  * vmw_dx_streamoutput_add - Add a streamoutput as a cmd buf managed resource.
 271  * @man: Command buffer managed resource manager for current context.
 272  * @ctx: Pointer to context resource.
 273  * @user_key: The identifier for this streamoutput.
 274  * @list: The list of staged command buffer managed resources.
 275  *
 276  * Return: 0 on success, negative error code on failure.
 277  */
 278 int vmw_dx_streamoutput_add(struct vmw_cmdbuf_res_manager *man,
 279                             struct vmw_resource *ctx, u32 user_key,
 280                             struct list_head *list)
 281 {
 282         struct vmw_dx_streamoutput *so;
 283         struct vmw_resource *res;
 284         struct vmw_private *dev_priv = ctx->dev_priv;
 285         int ret;
 286
 287         so = kmalloc(sizeof(*so), GFP_KERNEL);
 288         if (!so) {
 289                 return -ENOMEM;
 290         }
 291
 292         res = &so->res;
 293         so->ctx = ctx;
 294         so->cotable = vmw_resource_reference
 295                 (vmw_context_cotable(ctx, SVGA_COTABLE_STREAMOUTPUT));
 296         so->id = user_key;
 297         so->committed = false;
 298         INIT_LIST_HEAD(&so->cotable_head);
 299         ret = vmw_resource_init(dev_priv, res, true,
 300                                 vmw_dx_streamoutput_res_free,
 301                                 &vmw_dx_streamoutput_func);
 302         if (ret)
 303                 goto out_resource_init;
 304
 305         ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_streamoutput, user_key,
 306                                  res, list);
 307         if (ret)
 308                 goto out_resource_init;
 309
 310         res->id = so->id;
 311         res->hw_destroy = vmw_dx_streamoutput_hw_destroy;
 312
 313 out_resource_init:
 314         vmw_resource_unreference(&res);
 315
 316         return ret;
 317 }
 318
 319 /**
 320  * vmw_dx_streamoutput_set_size - Sets streamoutput mob size in res struct.
 321  * @res: The streamoutput res for which need to set size.
 322  * @size: The size provided by user-space to set.
 323  */
 324 void vmw_dx_streamoutput_set_size(struct vmw_resource *res, u32 size)
 325 {
 326         struct vmw_dx_streamoutput *so = vmw_res_to_dx_streamoutput(res);
 327
 328         so->size = size;
 329 }
 330
 331 /**
 332  * vmw_dx_streamoutput_remove - Stage streamoutput for removal.
 333  * @man: Command buffer managed resource manager for current context.
 334  * @user_key: The identifier for this streamoutput.
 335  * @list: The list of staged command buffer managed resources.
 336  *
 337  * Return: 0 on success, negative error code on failure.
 338  */
 339 int vmw_dx_streamoutput_remove(struct vmw_cmdbuf_res_manager *man,
 340                                u32 user_key,
 341                                struct list_head *list)
 342 {
 343         struct vmw_resource *r;
 344
 345         return vmw_cmdbuf_res_remove(man, vmw_cmdbuf_res_streamoutput,
 346                                      (u32)user_key, list, &r);
 347 }
 348
 349 /**
 350  * vmw_dx_streamoutput_cotable_list_scrub - cotable unbind_func callback.
 351  * @dev_priv: Device private.
 352  * @list: The list of cotable resources.
 353  * @readback: Whether the call was part of a readback unbind.
 354  */
 355 void vmw_dx_streamoutput_cotable_list_scrub(struct vmw_private *dev_priv,
 356                                             struct list_head *list,
 357                                             bool readback)
 358 {
 359         struct vmw_dx_streamoutput *entry, *next;
 360
 361         lockdep_assert_held_once(&dev_priv->binding_mutex);
 362
 363         list_for_each_entry_safe(entry, next, list, cotable_head) {
 364                 WARN_ON(vmw_dx_streamoutput_scrub(&entry->res));
 365                 if (!readback)
 366                         entry->committed =false;
 367         }
 368 }