1 // SPDX-License-Identifier: GPL-2.0 OR MIT 2 /************************************************************************** 3 * 4 * Copyright © 2018-2019 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 <drm/ttm/ttm_placement.h> 30 31 #include "vmwgfx_drv.h" 32 #include "vmwgfx_resource_priv.h" 33 #include "vmwgfx_binding.h" 34 35 /** 36 * struct vmw_dx_streamoutput - Streamoutput resource metadata. 37 * @res: Base resource struct. 38 * @ctx: Non-refcounted context to which @res belong. 39 * @cotable: Refcounted cotable holding this Streamoutput. 40 * @cotable_head: List head for cotable-so_res list. 41 * @id: User-space provided identifier. 42 * @size: User-space provided mob size. 43 * @committed: Whether streamoutput is actually created or pending creation. 44 */ 45 struct vmw_dx_streamoutput { 46 struct vmw_resource res; 47 struct vmw_resource *ctx; 48 struct vmw_resource *cotable; 49 struct list_head cotable_head; 50 u32 id; 51 u32 size; 52 bool committed; 53 }; 54 55 static int vmw_dx_streamoutput_create(struct vmw_resource *res); 56 static int vmw_dx_streamoutput_bind(struct vmw_resource *res, 57 struct ttm_validate_buffer *val_buf); 58 static int vmw_dx_streamoutput_unbind(struct vmw_resource *res, bool readback, 59 struct ttm_validate_buffer *val_buf); 60 static void vmw_dx_streamoutput_commit_notify(struct vmw_resource *res, 61 enum vmw_cmdbuf_res_state state); 62 63 static size_t vmw_streamoutput_size; 64 65 static const struct vmw_res_func vmw_dx_streamoutput_func = { 66 .res_type = vmw_res_streamoutput, 67 .needs_backup = true, 68 .may_evict = false, 69 .type_name = "DX streamoutput", 70 .backup_placement = &vmw_mob_placement, 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_FIFO_RESERVE_DX(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->backup->base.mem.start; 110 cmd->body.offsetInBytes = res->backup_offset; 111 cmd->body.sizeInBytes = so->size; 112 vmw_fifo_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->mem.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_FIFO_RESERVE_DX(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_fifo_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->backup->base.mem.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_private *dev_priv = res->dev_priv; 258 struct vmw_dx_streamoutput *so = vmw_res_to_dx_streamoutput(res); 259 260 vmw_resource_unreference(&so->cotable); 261 kfree(so); 262 ttm_mem_global_free(vmw_mem_glob(dev_priv), vmw_streamoutput_size); 263 } 264 265 static void vmw_dx_streamoutput_hw_destroy(struct vmw_resource *res) 266 { 267 /* Destroyed by user-space cmd buf or as part of context takedown. */ 268 res->id = -1; 269 } 270 271 /** 272 * vmw_dx_streamoutput_add - Add a streamoutput as a cmd buf managed resource. 273 * @man: Command buffer managed resource manager for current context. 274 * @ctx: Pointer to context resource. 275 * @user_key: The identifier for this streamoutput. 276 * @list: The list of staged command buffer managed resources. 277 * 278 * Return: 0 on success, negative error code on failure. 279 */ 280 int vmw_dx_streamoutput_add(struct vmw_cmdbuf_res_manager *man, 281 struct vmw_resource *ctx, u32 user_key, 282 struct list_head *list) 283 { 284 struct vmw_dx_streamoutput *so; 285 struct vmw_resource *res; 286 struct vmw_private *dev_priv = ctx->dev_priv; 287 struct ttm_operation_ctx ttm_opt_ctx = { 288 .interruptible = true, 289 .no_wait_gpu = false 290 }; 291 int ret; 292 293 if (!vmw_streamoutput_size) 294 vmw_streamoutput_size = ttm_round_pot(sizeof(*so)); 295 296 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), 297 vmw_streamoutput_size, &ttm_opt_ctx); 298 if (ret) { 299 if (ret != -ERESTARTSYS) 300 DRM_ERROR("Out of graphics memory for streamout.\n"); 301 return ret; 302 } 303 304 so = kmalloc(sizeof(*so), GFP_KERNEL); 305 if (!so) { 306 ttm_mem_global_free(vmw_mem_glob(dev_priv), 307 vmw_streamoutput_size); 308 return -ENOMEM; 309 } 310 311 res = &so->res; 312 so->ctx = ctx; 313 so->cotable = vmw_resource_reference 314 (vmw_context_cotable(ctx, SVGA_COTABLE_STREAMOUTPUT)); 315 so->id = user_key; 316 so->committed = false; 317 INIT_LIST_HEAD(&so->cotable_head); 318 ret = vmw_resource_init(dev_priv, res, true, 319 vmw_dx_streamoutput_res_free, 320 &vmw_dx_streamoutput_func); 321 if (ret) 322 goto out_resource_init; 323 324 ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_streamoutput, user_key, 325 res, list); 326 if (ret) 327 goto out_resource_init; 328 329 res->id = so->id; 330 res->hw_destroy = vmw_dx_streamoutput_hw_destroy; 331 332 out_resource_init: 333 vmw_resource_unreference(&res); 334 335 return ret; 336 } 337 338 /** 339 * vmw_dx_streamoutput_set_size - Sets streamoutput mob size in res struct. 340 * @res: The streamoutput res for which need to set size. 341 * @size: The size provided by user-space to set. 342 */ 343 void vmw_dx_streamoutput_set_size(struct vmw_resource *res, u32 size) 344 { 345 struct vmw_dx_streamoutput *so = vmw_res_to_dx_streamoutput(res); 346 347 so->size = size; 348 } 349 350 /** 351 * vmw_dx_streamoutput_remove - Stage streamoutput for removal. 352 * @man: Command buffer managed resource manager for current context. 353 * @user_key: The identifier for this streamoutput. 354 * @list: The list of staged command buffer managed resources. 355 * 356 * Return: 0 on success, negative error code on failure. 357 */ 358 int vmw_dx_streamoutput_remove(struct vmw_cmdbuf_res_manager *man, 359 u32 user_key, 360 struct list_head *list) 361 { 362 struct vmw_resource *r; 363 364 return vmw_cmdbuf_res_remove(man, vmw_cmdbuf_res_streamoutput, 365 (u32)user_key, list, &r); 366 } 367 368 /** 369 * vmw_dx_streamoutput_cotable_list_scrub - cotable unbind_func callback. 370 * @dev_priv: Device private. 371 * @list: The list of cotable resources. 372 * @readback: Whether the call was part of a readback unbind. 373 */ 374 void vmw_dx_streamoutput_cotable_list_scrub(struct vmw_private *dev_priv, 375 struct list_head *list, 376 bool readback) 377 { 378 struct vmw_dx_streamoutput *entry, *next; 379 380 lockdep_assert_held_once(&dev_priv->binding_mutex); 381 382 list_for_each_entry_safe(entry, next, list, cotable_head) { 383 WARN_ON(vmw_dx_streamoutput_scrub(&entry->res)); 384 if (!readback) 385 entry->committed =false; 386 } 387 } 388