1 /**************************************************************************
2  *
3  * Copyright © 2009-2015 VMware, Inc., Palo Alto, CA., USA
4  * All Rights Reserved.
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 #include <drm/ttm/ttm_placement.h>
29 
30 #include "vmwgfx_drv.h"
31 #include "vmwgfx_resource_priv.h"
32 #include "vmwgfx_binding.h"
33 
34 struct vmw_user_context {
35 	struct ttm_base_object base;
36 	struct vmw_resource res;
37 	struct vmw_ctx_binding_state *cbs;
38 	struct vmw_cmdbuf_res_manager *man;
39 	struct vmw_resource *cotables[SVGA_COTABLE_DX10_MAX];
40 	spinlock_t cotable_lock;
41 	struct vmw_dma_buffer *dx_query_mob;
42 };
43 
44 static void vmw_user_context_free(struct vmw_resource *res);
45 static struct vmw_resource *
46 vmw_user_context_base_to_res(struct ttm_base_object *base);
47 
48 static int vmw_gb_context_create(struct vmw_resource *res);
49 static int vmw_gb_context_bind(struct vmw_resource *res,
50 			       struct ttm_validate_buffer *val_buf);
51 static int vmw_gb_context_unbind(struct vmw_resource *res,
52 				 bool readback,
53 				 struct ttm_validate_buffer *val_buf);
54 static int vmw_gb_context_destroy(struct vmw_resource *res);
55 static int vmw_dx_context_create(struct vmw_resource *res);
56 static int vmw_dx_context_bind(struct vmw_resource *res,
57 			       struct ttm_validate_buffer *val_buf);
58 static int vmw_dx_context_unbind(struct vmw_resource *res,
59 				 bool readback,
60 				 struct ttm_validate_buffer *val_buf);
61 static int vmw_dx_context_destroy(struct vmw_resource *res);
62 
63 static uint64_t vmw_user_context_size;
64 
65 static const struct vmw_user_resource_conv user_context_conv = {
66 	.object_type = VMW_RES_CONTEXT,
67 	.base_obj_to_res = vmw_user_context_base_to_res,
68 	.res_free = vmw_user_context_free
69 };
70 
71 const struct vmw_user_resource_conv *user_context_converter =
72 	&user_context_conv;
73 
74 
75 static const struct vmw_res_func vmw_legacy_context_func = {
76 	.res_type = vmw_res_context,
77 	.needs_backup = false,
78 	.may_evict = false,
79 	.type_name = "legacy contexts",
80 	.backup_placement = NULL,
81 	.create = NULL,
82 	.destroy = NULL,
83 	.bind = NULL,
84 	.unbind = NULL
85 };
86 
87 static const struct vmw_res_func vmw_gb_context_func = {
88 	.res_type = vmw_res_context,
89 	.needs_backup = true,
90 	.may_evict = true,
91 	.type_name = "guest backed contexts",
92 	.backup_placement = &vmw_mob_placement,
93 	.create = vmw_gb_context_create,
94 	.destroy = vmw_gb_context_destroy,
95 	.bind = vmw_gb_context_bind,
96 	.unbind = vmw_gb_context_unbind
97 };
98 
99 static const struct vmw_res_func vmw_dx_context_func = {
100 	.res_type = vmw_res_dx_context,
101 	.needs_backup = true,
102 	.may_evict = true,
103 	.type_name = "dx contexts",
104 	.backup_placement = &vmw_mob_placement,
105 	.create = vmw_dx_context_create,
106 	.destroy = vmw_dx_context_destroy,
107 	.bind = vmw_dx_context_bind,
108 	.unbind = vmw_dx_context_unbind
109 };
110 
111 /**
112  * Context management:
113  */
114 
115 static void vmw_context_cotables_unref(struct vmw_user_context *uctx)
116 {
117 	struct vmw_resource *res;
118 	int i;
119 
120 	for (i = 0; i < SVGA_COTABLE_DX10_MAX; ++i) {
121 		spin_lock(&uctx->cotable_lock);
122 		res = uctx->cotables[i];
123 		uctx->cotables[i] = NULL;
124 		spin_unlock(&uctx->cotable_lock);
125 
126 		if (res)
127 			vmw_resource_unreference(&res);
128 	}
129 }
130 
131 static void vmw_hw_context_destroy(struct vmw_resource *res)
132 {
133 	struct vmw_user_context *uctx =
134 		container_of(res, struct vmw_user_context, res);
135 	struct vmw_private *dev_priv = res->dev_priv;
136 	struct {
137 		SVGA3dCmdHeader header;
138 		SVGA3dCmdDestroyContext body;
139 	} *cmd;
140 
141 
142 	if (res->func->destroy == vmw_gb_context_destroy ||
143 	    res->func->destroy == vmw_dx_context_destroy) {
144 		mutex_lock(&dev_priv->cmdbuf_mutex);
145 		vmw_cmdbuf_res_man_destroy(uctx->man);
146 		mutex_lock(&dev_priv->binding_mutex);
147 		vmw_binding_state_kill(uctx->cbs);
148 		(void) res->func->destroy(res);
149 		mutex_unlock(&dev_priv->binding_mutex);
150 		if (dev_priv->pinned_bo != NULL &&
151 		    !dev_priv->query_cid_valid)
152 			__vmw_execbuf_release_pinned_bo(dev_priv, NULL);
153 		mutex_unlock(&dev_priv->cmdbuf_mutex);
154 		vmw_context_cotables_unref(uctx);
155 		return;
156 	}
157 
158 	vmw_execbuf_release_pinned_bo(dev_priv);
159 	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
160 	if (unlikely(cmd == NULL)) {
161 		DRM_ERROR("Failed reserving FIFO space for surface "
162 			  "destruction.\n");
163 		return;
164 	}
165 
166 	cmd->header.id = SVGA_3D_CMD_CONTEXT_DESTROY;
167 	cmd->header.size = sizeof(cmd->body);
168 	cmd->body.cid = res->id;
169 
170 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
171 	vmw_fifo_resource_dec(dev_priv);
172 }
173 
174 static int vmw_gb_context_init(struct vmw_private *dev_priv,
175 			       bool dx,
176 			       struct vmw_resource *res,
177 			       void (*res_free)(struct vmw_resource *res))
178 {
179 	int ret, i;
180 	struct vmw_user_context *uctx =
181 		container_of(res, struct vmw_user_context, res);
182 
183 	res->backup_size = (dx ? sizeof(SVGADXContextMobFormat) :
184 			    SVGA3D_CONTEXT_DATA_SIZE);
185 	ret = vmw_resource_init(dev_priv, res, true,
186 				res_free,
187 				dx ? &vmw_dx_context_func :
188 				&vmw_gb_context_func);
189 	if (unlikely(ret != 0))
190 		goto out_err;
191 
192 	if (dev_priv->has_mob) {
193 		uctx->man = vmw_cmdbuf_res_man_create(dev_priv);
194 		if (IS_ERR(uctx->man)) {
195 			ret = PTR_ERR(uctx->man);
196 			uctx->man = NULL;
197 			goto out_err;
198 		}
199 	}
200 
201 	uctx->cbs = vmw_binding_state_alloc(dev_priv);
202 	if (IS_ERR(uctx->cbs)) {
203 		ret = PTR_ERR(uctx->cbs);
204 		goto out_err;
205 	}
206 
207 	spin_lock_init(&uctx->cotable_lock);
208 
209 	if (dx) {
210 		for (i = 0; i < SVGA_COTABLE_DX10_MAX; ++i) {
211 			uctx->cotables[i] = vmw_cotable_alloc(dev_priv,
212 							      &uctx->res, i);
213 			if (unlikely(IS_ERR(uctx->cotables[i]))) {
214 				ret = PTR_ERR(uctx->cotables[i]);
215 				goto out_cotables;
216 			}
217 		}
218 	}
219 
220 
221 
222 	vmw_resource_activate(res, vmw_hw_context_destroy);
223 	return 0;
224 
225 out_cotables:
226 	vmw_context_cotables_unref(uctx);
227 out_err:
228 	if (res_free)
229 		res_free(res);
230 	else
231 		kfree(res);
232 	return ret;
233 }
234 
235 static int vmw_context_init(struct vmw_private *dev_priv,
236 			    struct vmw_resource *res,
237 			    void (*res_free)(struct vmw_resource *res),
238 			    bool dx)
239 {
240 	int ret;
241 
242 	struct {
243 		SVGA3dCmdHeader header;
244 		SVGA3dCmdDefineContext body;
245 	} *cmd;
246 
247 	if (dev_priv->has_mob)
248 		return vmw_gb_context_init(dev_priv, dx, res, res_free);
249 
250 	ret = vmw_resource_init(dev_priv, res, false,
251 				res_free, &vmw_legacy_context_func);
252 
253 	if (unlikely(ret != 0)) {
254 		DRM_ERROR("Failed to allocate a resource id.\n");
255 		goto out_early;
256 	}
257 
258 	if (unlikely(res->id >= SVGA3D_MAX_CONTEXT_IDS)) {
259 		DRM_ERROR("Out of hw context ids.\n");
260 		vmw_resource_unreference(&res);
261 		return -ENOMEM;
262 	}
263 
264 	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
265 	if (unlikely(cmd == NULL)) {
266 		DRM_ERROR("Fifo reserve failed.\n");
267 		vmw_resource_unreference(&res);
268 		return -ENOMEM;
269 	}
270 
271 	cmd->header.id = SVGA_3D_CMD_CONTEXT_DEFINE;
272 	cmd->header.size = sizeof(cmd->body);
273 	cmd->body.cid = res->id;
274 
275 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
276 	vmw_fifo_resource_inc(dev_priv);
277 	vmw_resource_activate(res, vmw_hw_context_destroy);
278 	return 0;
279 
280 out_early:
281 	if (res_free == NULL)
282 		kfree(res);
283 	else
284 		res_free(res);
285 	return ret;
286 }
287 
288 
289 /*
290  * GB context.
291  */
292 
293 static int vmw_gb_context_create(struct vmw_resource *res)
294 {
295 	struct vmw_private *dev_priv = res->dev_priv;
296 	int ret;
297 	struct {
298 		SVGA3dCmdHeader header;
299 		SVGA3dCmdDefineGBContext body;
300 	} *cmd;
301 
302 	if (likely(res->id != -1))
303 		return 0;
304 
305 	ret = vmw_resource_alloc_id(res);
306 	if (unlikely(ret != 0)) {
307 		DRM_ERROR("Failed to allocate a context id.\n");
308 		goto out_no_id;
309 	}
310 
311 	if (unlikely(res->id >= VMWGFX_NUM_GB_CONTEXT)) {
312 		ret = -EBUSY;
313 		goto out_no_fifo;
314 	}
315 
316 	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
317 	if (unlikely(cmd == NULL)) {
318 		DRM_ERROR("Failed reserving FIFO space for context "
319 			  "creation.\n");
320 		ret = -ENOMEM;
321 		goto out_no_fifo;
322 	}
323 
324 	cmd->header.id = SVGA_3D_CMD_DEFINE_GB_CONTEXT;
325 	cmd->header.size = sizeof(cmd->body);
326 	cmd->body.cid = res->id;
327 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
328 	vmw_fifo_resource_inc(dev_priv);
329 
330 	return 0;
331 
332 out_no_fifo:
333 	vmw_resource_release_id(res);
334 out_no_id:
335 	return ret;
336 }
337 
338 static int vmw_gb_context_bind(struct vmw_resource *res,
339 			       struct ttm_validate_buffer *val_buf)
340 {
341 	struct vmw_private *dev_priv = res->dev_priv;
342 	struct {
343 		SVGA3dCmdHeader header;
344 		SVGA3dCmdBindGBContext body;
345 	} *cmd;
346 	struct ttm_buffer_object *bo = val_buf->bo;
347 
348 	BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
349 
350 	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
351 	if (unlikely(cmd == NULL)) {
352 		DRM_ERROR("Failed reserving FIFO space for context "
353 			  "binding.\n");
354 		return -ENOMEM;
355 	}
356 	cmd->header.id = SVGA_3D_CMD_BIND_GB_CONTEXT;
357 	cmd->header.size = sizeof(cmd->body);
358 	cmd->body.cid = res->id;
359 	cmd->body.mobid = bo->mem.start;
360 	cmd->body.validContents = res->backup_dirty;
361 	res->backup_dirty = false;
362 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
363 
364 	return 0;
365 }
366 
367 static int vmw_gb_context_unbind(struct vmw_resource *res,
368 				 bool readback,
369 				 struct ttm_validate_buffer *val_buf)
370 {
371 	struct vmw_private *dev_priv = res->dev_priv;
372 	struct ttm_buffer_object *bo = val_buf->bo;
373 	struct vmw_fence_obj *fence;
374 	struct vmw_user_context *uctx =
375 		container_of(res, struct vmw_user_context, res);
376 
377 	struct {
378 		SVGA3dCmdHeader header;
379 		SVGA3dCmdReadbackGBContext body;
380 	} *cmd1;
381 	struct {
382 		SVGA3dCmdHeader header;
383 		SVGA3dCmdBindGBContext body;
384 	} *cmd2;
385 	uint32_t submit_size;
386 	uint8_t *cmd;
387 
388 
389 	BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
390 
391 	mutex_lock(&dev_priv->binding_mutex);
392 	vmw_binding_state_scrub(uctx->cbs);
393 
394 	submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0);
395 
396 	cmd = vmw_fifo_reserve(dev_priv, submit_size);
397 	if (unlikely(cmd == NULL)) {
398 		DRM_ERROR("Failed reserving FIFO space for context "
399 			  "unbinding.\n");
400 		mutex_unlock(&dev_priv->binding_mutex);
401 		return -ENOMEM;
402 	}
403 
404 	cmd2 = (void *) cmd;
405 	if (readback) {
406 		cmd1 = (void *) cmd;
407 		cmd1->header.id = SVGA_3D_CMD_READBACK_GB_CONTEXT;
408 		cmd1->header.size = sizeof(cmd1->body);
409 		cmd1->body.cid = res->id;
410 		cmd2 = (void *) (&cmd1[1]);
411 	}
412 	cmd2->header.id = SVGA_3D_CMD_BIND_GB_CONTEXT;
413 	cmd2->header.size = sizeof(cmd2->body);
414 	cmd2->body.cid = res->id;
415 	cmd2->body.mobid = SVGA3D_INVALID_ID;
416 
417 	vmw_fifo_commit(dev_priv, submit_size);
418 	mutex_unlock(&dev_priv->binding_mutex);
419 
420 	/*
421 	 * Create a fence object and fence the backup buffer.
422 	 */
423 
424 	(void) vmw_execbuf_fence_commands(NULL, dev_priv,
425 					  &fence, NULL);
426 
427 	vmw_fence_single_bo(bo, fence);
428 
429 	if (likely(fence != NULL))
430 		vmw_fence_obj_unreference(&fence);
431 
432 	return 0;
433 }
434 
435 static int vmw_gb_context_destroy(struct vmw_resource *res)
436 {
437 	struct vmw_private *dev_priv = res->dev_priv;
438 	struct {
439 		SVGA3dCmdHeader header;
440 		SVGA3dCmdDestroyGBContext body;
441 	} *cmd;
442 
443 	if (likely(res->id == -1))
444 		return 0;
445 
446 	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
447 	if (unlikely(cmd == NULL)) {
448 		DRM_ERROR("Failed reserving FIFO space for context "
449 			  "destruction.\n");
450 		return -ENOMEM;
451 	}
452 
453 	cmd->header.id = SVGA_3D_CMD_DESTROY_GB_CONTEXT;
454 	cmd->header.size = sizeof(cmd->body);
455 	cmd->body.cid = res->id;
456 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
457 	if (dev_priv->query_cid == res->id)
458 		dev_priv->query_cid_valid = false;
459 	vmw_resource_release_id(res);
460 	vmw_fifo_resource_dec(dev_priv);
461 
462 	return 0;
463 }
464 
465 /*
466  * DX context.
467  */
468 
469 static int vmw_dx_context_create(struct vmw_resource *res)
470 {
471 	struct vmw_private *dev_priv = res->dev_priv;
472 	int ret;
473 	struct {
474 		SVGA3dCmdHeader header;
475 		SVGA3dCmdDXDefineContext body;
476 	} *cmd;
477 
478 	if (likely(res->id != -1))
479 		return 0;
480 
481 	ret = vmw_resource_alloc_id(res);
482 	if (unlikely(ret != 0)) {
483 		DRM_ERROR("Failed to allocate a context id.\n");
484 		goto out_no_id;
485 	}
486 
487 	if (unlikely(res->id >= VMWGFX_NUM_DXCONTEXT)) {
488 		ret = -EBUSY;
489 		goto out_no_fifo;
490 	}
491 
492 	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
493 	if (unlikely(cmd == NULL)) {
494 		DRM_ERROR("Failed reserving FIFO space for context "
495 			  "creation.\n");
496 		ret = -ENOMEM;
497 		goto out_no_fifo;
498 	}
499 
500 	cmd->header.id = SVGA_3D_CMD_DX_DEFINE_CONTEXT;
501 	cmd->header.size = sizeof(cmd->body);
502 	cmd->body.cid = res->id;
503 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
504 	vmw_fifo_resource_inc(dev_priv);
505 
506 	return 0;
507 
508 out_no_fifo:
509 	vmw_resource_release_id(res);
510 out_no_id:
511 	return ret;
512 }
513 
514 static int vmw_dx_context_bind(struct vmw_resource *res,
515 			       struct ttm_validate_buffer *val_buf)
516 {
517 	struct vmw_private *dev_priv = res->dev_priv;
518 	struct {
519 		SVGA3dCmdHeader header;
520 		SVGA3dCmdDXBindContext body;
521 	} *cmd;
522 	struct ttm_buffer_object *bo = val_buf->bo;
523 
524 	BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
525 
526 	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
527 	if (unlikely(cmd == NULL)) {
528 		DRM_ERROR("Failed reserving FIFO space for context "
529 			  "binding.\n");
530 		return -ENOMEM;
531 	}
532 
533 	cmd->header.id = SVGA_3D_CMD_DX_BIND_CONTEXT;
534 	cmd->header.size = sizeof(cmd->body);
535 	cmd->body.cid = res->id;
536 	cmd->body.mobid = bo->mem.start;
537 	cmd->body.validContents = res->backup_dirty;
538 	res->backup_dirty = false;
539 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
540 
541 
542 	return 0;
543 }
544 
545 /**
546  * vmw_dx_context_scrub_cotables - Scrub all bindings and
547  * cotables from a context
548  *
549  * @ctx: Pointer to the context resource
550  * @readback: Whether to save the otable contents on scrubbing.
551  *
552  * COtables must be unbound before their context, but unbinding requires
553  * the backup buffer being reserved, whereas scrubbing does not.
554  * This function scrubs all cotables of a context, potentially reading back
555  * the contents into their backup buffers. However, scrubbing cotables
556  * also makes the device context invalid, so scrub all bindings first so
557  * that doesn't have to be done later with an invalid context.
558  */
559 void vmw_dx_context_scrub_cotables(struct vmw_resource *ctx,
560 				   bool readback)
561 {
562 	struct vmw_user_context *uctx =
563 		container_of(ctx, struct vmw_user_context, res);
564 	int i;
565 
566 	vmw_binding_state_scrub(uctx->cbs);
567 	for (i = 0; i < SVGA_COTABLE_DX10_MAX; ++i) {
568 		struct vmw_resource *res;
569 
570 		/* Avoid racing with ongoing cotable destruction. */
571 		spin_lock(&uctx->cotable_lock);
572 		res = uctx->cotables[vmw_cotable_scrub_order[i]];
573 		if (res)
574 			res = vmw_resource_reference_unless_doomed(res);
575 		spin_unlock(&uctx->cotable_lock);
576 		if (!res)
577 			continue;
578 
579 		WARN_ON(vmw_cotable_scrub(res, readback));
580 		vmw_resource_unreference(&res);
581 	}
582 }
583 
584 static int vmw_dx_context_unbind(struct vmw_resource *res,
585 				 bool readback,
586 				 struct ttm_validate_buffer *val_buf)
587 {
588 	struct vmw_private *dev_priv = res->dev_priv;
589 	struct ttm_buffer_object *bo = val_buf->bo;
590 	struct vmw_fence_obj *fence;
591 	struct vmw_user_context *uctx =
592 		container_of(res, struct vmw_user_context, res);
593 
594 	struct {
595 		SVGA3dCmdHeader header;
596 		SVGA3dCmdDXReadbackContext body;
597 	} *cmd1;
598 	struct {
599 		SVGA3dCmdHeader header;
600 		SVGA3dCmdDXBindContext body;
601 	} *cmd2;
602 	uint32_t submit_size;
603 	uint8_t *cmd;
604 
605 
606 	BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
607 
608 	mutex_lock(&dev_priv->binding_mutex);
609 	vmw_dx_context_scrub_cotables(res, readback);
610 
611 	if (uctx->dx_query_mob && uctx->dx_query_mob->dx_query_ctx &&
612 	    readback) {
613 		WARN_ON(uctx->dx_query_mob->dx_query_ctx != res);
614 		if (vmw_query_readback_all(uctx->dx_query_mob))
615 			DRM_ERROR("Failed to read back query states\n");
616 	}
617 
618 	submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0);
619 
620 	cmd = vmw_fifo_reserve(dev_priv, submit_size);
621 	if (unlikely(cmd == NULL)) {
622 		DRM_ERROR("Failed reserving FIFO space for context "
623 			  "unbinding.\n");
624 		mutex_unlock(&dev_priv->binding_mutex);
625 		return -ENOMEM;
626 	}
627 
628 	cmd2 = (void *) cmd;
629 	if (readback) {
630 		cmd1 = (void *) cmd;
631 		cmd1->header.id = SVGA_3D_CMD_DX_READBACK_CONTEXT;
632 		cmd1->header.size = sizeof(cmd1->body);
633 		cmd1->body.cid = res->id;
634 		cmd2 = (void *) (&cmd1[1]);
635 	}
636 	cmd2->header.id = SVGA_3D_CMD_DX_BIND_CONTEXT;
637 	cmd2->header.size = sizeof(cmd2->body);
638 	cmd2->body.cid = res->id;
639 	cmd2->body.mobid = SVGA3D_INVALID_ID;
640 
641 	vmw_fifo_commit(dev_priv, submit_size);
642 	mutex_unlock(&dev_priv->binding_mutex);
643 
644 	/*
645 	 * Create a fence object and fence the backup buffer.
646 	 */
647 
648 	(void) vmw_execbuf_fence_commands(NULL, dev_priv,
649 					  &fence, NULL);
650 
651 	vmw_fence_single_bo(bo, fence);
652 
653 	if (likely(fence != NULL))
654 		vmw_fence_obj_unreference(&fence);
655 
656 	return 0;
657 }
658 
659 static int vmw_dx_context_destroy(struct vmw_resource *res)
660 {
661 	struct vmw_private *dev_priv = res->dev_priv;
662 	struct {
663 		SVGA3dCmdHeader header;
664 		SVGA3dCmdDXDestroyContext body;
665 	} *cmd;
666 
667 	if (likely(res->id == -1))
668 		return 0;
669 
670 	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
671 	if (unlikely(cmd == NULL)) {
672 		DRM_ERROR("Failed reserving FIFO space for context "
673 			  "destruction.\n");
674 		return -ENOMEM;
675 	}
676 
677 	cmd->header.id = SVGA_3D_CMD_DX_DESTROY_CONTEXT;
678 	cmd->header.size = sizeof(cmd->body);
679 	cmd->body.cid = res->id;
680 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
681 	if (dev_priv->query_cid == res->id)
682 		dev_priv->query_cid_valid = false;
683 	vmw_resource_release_id(res);
684 	vmw_fifo_resource_dec(dev_priv);
685 
686 	return 0;
687 }
688 
689 /**
690  * User-space context management:
691  */
692 
693 static struct vmw_resource *
694 vmw_user_context_base_to_res(struct ttm_base_object *base)
695 {
696 	return &(container_of(base, struct vmw_user_context, base)->res);
697 }
698 
699 static void vmw_user_context_free(struct vmw_resource *res)
700 {
701 	struct vmw_user_context *ctx =
702 	    container_of(res, struct vmw_user_context, res);
703 	struct vmw_private *dev_priv = res->dev_priv;
704 
705 	if (ctx->cbs)
706 		vmw_binding_state_free(ctx->cbs);
707 
708 	(void) vmw_context_bind_dx_query(res, NULL);
709 
710 	ttm_base_object_kfree(ctx, base);
711 	ttm_mem_global_free(vmw_mem_glob(dev_priv),
712 			    vmw_user_context_size);
713 }
714 
715 /**
716  * This function is called when user space has no more references on the
717  * base object. It releases the base-object's reference on the resource object.
718  */
719 
720 static void vmw_user_context_base_release(struct ttm_base_object **p_base)
721 {
722 	struct ttm_base_object *base = *p_base;
723 	struct vmw_user_context *ctx =
724 	    container_of(base, struct vmw_user_context, base);
725 	struct vmw_resource *res = &ctx->res;
726 
727 	*p_base = NULL;
728 	vmw_resource_unreference(&res);
729 }
730 
731 int vmw_context_destroy_ioctl(struct drm_device *dev, void *data,
732 			      struct drm_file *file_priv)
733 {
734 	struct drm_vmw_context_arg *arg = (struct drm_vmw_context_arg *)data;
735 	struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
736 
737 	return ttm_ref_object_base_unref(tfile, arg->cid, TTM_REF_USAGE);
738 }
739 
740 static int vmw_context_define(struct drm_device *dev, void *data,
741 			      struct drm_file *file_priv, bool dx)
742 {
743 	struct vmw_private *dev_priv = vmw_priv(dev);
744 	struct vmw_user_context *ctx;
745 	struct vmw_resource *res;
746 	struct vmw_resource *tmp;
747 	struct drm_vmw_context_arg *arg = (struct drm_vmw_context_arg *)data;
748 	struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
749 	struct ttm_operation_ctx ttm_opt_ctx = {
750 		.interruptible = true,
751 		.no_wait_gpu = false
752 	};
753 	int ret;
754 
755 	if (!dev_priv->has_dx && dx) {
756 		DRM_ERROR("DX contexts not supported by device.\n");
757 		return -EINVAL;
758 	}
759 
760 	/*
761 	 * Approximate idr memory usage with 128 bytes. It will be limited
762 	 * by maximum number_of contexts anyway.
763 	 */
764 
765 	if (unlikely(vmw_user_context_size == 0))
766 		vmw_user_context_size = ttm_round_pot(sizeof(*ctx)) + 128 +
767 		  ((dev_priv->has_mob) ? vmw_cmdbuf_res_man_size() : 0);
768 
769 	ret = ttm_read_lock(&dev_priv->reservation_sem, true);
770 	if (unlikely(ret != 0))
771 		return ret;
772 
773 	ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
774 				   vmw_user_context_size,
775 				   &ttm_opt_ctx);
776 	if (unlikely(ret != 0)) {
777 		if (ret != -ERESTARTSYS)
778 			DRM_ERROR("Out of graphics memory for context"
779 				  " creation.\n");
780 		goto out_unlock;
781 	}
782 
783 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
784 	if (unlikely(!ctx)) {
785 		ttm_mem_global_free(vmw_mem_glob(dev_priv),
786 				    vmw_user_context_size);
787 		ret = -ENOMEM;
788 		goto out_unlock;
789 	}
790 
791 	res = &ctx->res;
792 	ctx->base.shareable = false;
793 	ctx->base.tfile = NULL;
794 
795 	/*
796 	 * From here on, the destructor takes over resource freeing.
797 	 */
798 
799 	ret = vmw_context_init(dev_priv, res, vmw_user_context_free, dx);
800 	if (unlikely(ret != 0))
801 		goto out_unlock;
802 
803 	tmp = vmw_resource_reference(&ctx->res);
804 	ret = ttm_base_object_init(tfile, &ctx->base, false, VMW_RES_CONTEXT,
805 				   &vmw_user_context_base_release, NULL);
806 
807 	if (unlikely(ret != 0)) {
808 		vmw_resource_unreference(&tmp);
809 		goto out_err;
810 	}
811 
812 	arg->cid = ctx->base.hash.key;
813 out_err:
814 	vmw_resource_unreference(&res);
815 out_unlock:
816 	ttm_read_unlock(&dev_priv->reservation_sem);
817 	return ret;
818 }
819 
820 int vmw_context_define_ioctl(struct drm_device *dev, void *data,
821 			     struct drm_file *file_priv)
822 {
823 	return vmw_context_define(dev, data, file_priv, false);
824 }
825 
826 int vmw_extended_context_define_ioctl(struct drm_device *dev, void *data,
827 				      struct drm_file *file_priv)
828 {
829 	union drm_vmw_extended_context_arg *arg = (typeof(arg)) data;
830 	struct drm_vmw_context_arg *rep = &arg->rep;
831 
832 	switch (arg->req) {
833 	case drm_vmw_context_legacy:
834 		return vmw_context_define(dev, rep, file_priv, false);
835 	case drm_vmw_context_dx:
836 		return vmw_context_define(dev, rep, file_priv, true);
837 	default:
838 		break;
839 	}
840 	return -EINVAL;
841 }
842 
843 /**
844  * vmw_context_binding_list - Return a list of context bindings
845  *
846  * @ctx: The context resource
847  *
848  * Returns the current list of bindings of the given context. Note that
849  * this list becomes stale as soon as the dev_priv::binding_mutex is unlocked.
850  */
851 struct list_head *vmw_context_binding_list(struct vmw_resource *ctx)
852 {
853 	struct vmw_user_context *uctx =
854 		container_of(ctx, struct vmw_user_context, res);
855 
856 	return vmw_binding_state_list(uctx->cbs);
857 }
858 
859 struct vmw_cmdbuf_res_manager *vmw_context_res_man(struct vmw_resource *ctx)
860 {
861 	return container_of(ctx, struct vmw_user_context, res)->man;
862 }
863 
864 struct vmw_resource *vmw_context_cotable(struct vmw_resource *ctx,
865 					 SVGACOTableType cotable_type)
866 {
867 	if (cotable_type >= SVGA_COTABLE_DX10_MAX)
868 		return ERR_PTR(-EINVAL);
869 
870 	return vmw_resource_reference
871 		(container_of(ctx, struct vmw_user_context, res)->
872 		 cotables[cotable_type]);
873 }
874 
875 /**
876  * vmw_context_binding_state -
877  * Return a pointer to a context binding state structure
878  *
879  * @ctx: The context resource
880  *
881  * Returns the current state of bindings of the given context. Note that
882  * this state becomes stale as soon as the dev_priv::binding_mutex is unlocked.
883  */
884 struct vmw_ctx_binding_state *
885 vmw_context_binding_state(struct vmw_resource *ctx)
886 {
887 	return container_of(ctx, struct vmw_user_context, res)->cbs;
888 }
889 
890 /**
891  * vmw_context_bind_dx_query -
892  * Sets query MOB for the context.  If @mob is NULL, then this function will
893  * remove the association between the MOB and the context.  This function
894  * assumes the binding_mutex is held.
895  *
896  * @ctx_res: The context resource
897  * @mob: a reference to the query MOB
898  *
899  * Returns -EINVAL if a MOB has already been set and does not match the one
900  * specified in the parameter.  0 otherwise.
901  */
902 int vmw_context_bind_dx_query(struct vmw_resource *ctx_res,
903 			      struct vmw_dma_buffer *mob)
904 {
905 	struct vmw_user_context *uctx =
906 		container_of(ctx_res, struct vmw_user_context, res);
907 
908 	if (mob == NULL) {
909 		if (uctx->dx_query_mob) {
910 			uctx->dx_query_mob->dx_query_ctx = NULL;
911 			vmw_dmabuf_unreference(&uctx->dx_query_mob);
912 			uctx->dx_query_mob = NULL;
913 		}
914 
915 		return 0;
916 	}
917 
918 	/* Can only have one MOB per context for queries */
919 	if (uctx->dx_query_mob && uctx->dx_query_mob != mob)
920 		return -EINVAL;
921 
922 	mob->dx_query_ctx  = ctx_res;
923 
924 	if (!uctx->dx_query_mob)
925 		uctx->dx_query_mob = vmw_dmabuf_reference(mob);
926 
927 	return 0;
928 }
929 
930 /**
931  * vmw_context_get_dx_query_mob - Returns non-counted reference to DX query mob
932  *
933  * @ctx_res: The context resource
934  */
935 struct vmw_dma_buffer *
936 vmw_context_get_dx_query_mob(struct vmw_resource *ctx_res)
937 {
938 	struct vmw_user_context *uctx =
939 		container_of(ctx_res, struct vmw_user_context, res);
940 
941 	return uctx->dx_query_mob;
942 }
943