1 /*
2  * Copyright (C) 2015 Red Hat, Inc.
3  * All Rights Reserved.
4  *
5  * Authors:
6  *    Dave Airlie <airlied@redhat.com>
7  *    Gerd Hoffmann <kraxel@redhat.com>
8  *
9  * Permission is hereby granted, free of charge, to any person obtaining a
10  * copy of this software and associated documentation files (the "Software"),
11  * to deal in the Software without restriction, including without limitation
12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13  * and/or sell copies of the Software, and to permit persons to whom the
14  * Software is furnished to do so, subject to the following conditions:
15  *
16  * The above copyright notice and this permission notice (including the next
17  * paragraph) shall be included in all copies or substantial portions of the
18  * Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
23  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
26  * OTHER DEALINGS IN THE SOFTWARE.
27  */
28 
29 #include <linux/dma-mapping.h>
30 #include <linux/virtio.h>
31 #include <linux/virtio_config.h>
32 #include <linux/virtio_ring.h>
33 
34 #include <drm/drm_edid.h>
35 
36 #include "virtgpu_drv.h"
37 #include "virtgpu_trace.h"
38 
39 #define MAX_INLINE_CMD_SIZE   96
40 #define MAX_INLINE_RESP_SIZE  24
41 #define VBUFFER_SIZE          (sizeof(struct virtio_gpu_vbuffer) \
42 			       + MAX_INLINE_CMD_SIZE		 \
43 			       + MAX_INLINE_RESP_SIZE)
44 
45 static void convert_to_hw_box(struct virtio_gpu_box *dst,
46 			      const struct drm_virtgpu_3d_box *src)
47 {
48 	dst->x = cpu_to_le32(src->x);
49 	dst->y = cpu_to_le32(src->y);
50 	dst->z = cpu_to_le32(src->z);
51 	dst->w = cpu_to_le32(src->w);
52 	dst->h = cpu_to_le32(src->h);
53 	dst->d = cpu_to_le32(src->d);
54 }
55 
56 void virtio_gpu_ctrl_ack(struct virtqueue *vq)
57 {
58 	struct drm_device *dev = vq->vdev->priv;
59 	struct virtio_gpu_device *vgdev = dev->dev_private;
60 
61 	schedule_work(&vgdev->ctrlq.dequeue_work);
62 }
63 
64 void virtio_gpu_cursor_ack(struct virtqueue *vq)
65 {
66 	struct drm_device *dev = vq->vdev->priv;
67 	struct virtio_gpu_device *vgdev = dev->dev_private;
68 
69 	schedule_work(&vgdev->cursorq.dequeue_work);
70 }
71 
72 int virtio_gpu_alloc_vbufs(struct virtio_gpu_device *vgdev)
73 {
74 	vgdev->vbufs = kmem_cache_create("virtio-gpu-vbufs",
75 					 VBUFFER_SIZE,
76 					 __alignof__(struct virtio_gpu_vbuffer),
77 					 0, NULL);
78 	if (!vgdev->vbufs)
79 		return -ENOMEM;
80 	return 0;
81 }
82 
83 void virtio_gpu_free_vbufs(struct virtio_gpu_device *vgdev)
84 {
85 	kmem_cache_destroy(vgdev->vbufs);
86 	vgdev->vbufs = NULL;
87 }
88 
89 static struct virtio_gpu_vbuffer*
90 virtio_gpu_get_vbuf(struct virtio_gpu_device *vgdev,
91 		    int size, int resp_size, void *resp_buf,
92 		    virtio_gpu_resp_cb resp_cb)
93 {
94 	struct virtio_gpu_vbuffer *vbuf;
95 
96 	vbuf = kmem_cache_zalloc(vgdev->vbufs, GFP_KERNEL | __GFP_NOFAIL);
97 
98 	BUG_ON(size > MAX_INLINE_CMD_SIZE ||
99 	       size < sizeof(struct virtio_gpu_ctrl_hdr));
100 	vbuf->buf = (void *)vbuf + sizeof(*vbuf);
101 	vbuf->size = size;
102 
103 	vbuf->resp_cb = resp_cb;
104 	vbuf->resp_size = resp_size;
105 	if (resp_size <= MAX_INLINE_RESP_SIZE)
106 		vbuf->resp_buf = (void *)vbuf->buf + size;
107 	else
108 		vbuf->resp_buf = resp_buf;
109 	BUG_ON(!vbuf->resp_buf);
110 	return vbuf;
111 }
112 
113 static struct virtio_gpu_ctrl_hdr *
114 virtio_gpu_vbuf_ctrl_hdr(struct virtio_gpu_vbuffer *vbuf)
115 {
116 	/* this assumes a vbuf contains a command that starts with a
117 	 * virtio_gpu_ctrl_hdr, which is true for both ctrl and cursor
118 	 * virtqueues.
119 	 */
120 	return (struct virtio_gpu_ctrl_hdr *)vbuf->buf;
121 }
122 
123 static struct virtio_gpu_update_cursor*
124 virtio_gpu_alloc_cursor(struct virtio_gpu_device *vgdev,
125 			struct virtio_gpu_vbuffer **vbuffer_p)
126 {
127 	struct virtio_gpu_vbuffer *vbuf;
128 
129 	vbuf = virtio_gpu_get_vbuf
130 		(vgdev, sizeof(struct virtio_gpu_update_cursor),
131 		 0, NULL, NULL);
132 	if (IS_ERR(vbuf)) {
133 		*vbuffer_p = NULL;
134 		return ERR_CAST(vbuf);
135 	}
136 	*vbuffer_p = vbuf;
137 	return (struct virtio_gpu_update_cursor *)vbuf->buf;
138 }
139 
140 static void *virtio_gpu_alloc_cmd_resp(struct virtio_gpu_device *vgdev,
141 				       virtio_gpu_resp_cb cb,
142 				       struct virtio_gpu_vbuffer **vbuffer_p,
143 				       int cmd_size, int resp_size,
144 				       void *resp_buf)
145 {
146 	struct virtio_gpu_vbuffer *vbuf;
147 
148 	vbuf = virtio_gpu_get_vbuf(vgdev, cmd_size,
149 				   resp_size, resp_buf, cb);
150 	*vbuffer_p = vbuf;
151 	return (struct virtio_gpu_command *)vbuf->buf;
152 }
153 
154 static void *virtio_gpu_alloc_cmd(struct virtio_gpu_device *vgdev,
155 				  struct virtio_gpu_vbuffer **vbuffer_p,
156 				  int size)
157 {
158 	return virtio_gpu_alloc_cmd_resp(vgdev, NULL, vbuffer_p, size,
159 					 sizeof(struct virtio_gpu_ctrl_hdr),
160 					 NULL);
161 }
162 
163 static void *virtio_gpu_alloc_cmd_cb(struct virtio_gpu_device *vgdev,
164 				     struct virtio_gpu_vbuffer **vbuffer_p,
165 				     int size,
166 				     virtio_gpu_resp_cb cb)
167 {
168 	return virtio_gpu_alloc_cmd_resp(vgdev, cb, vbuffer_p, size,
169 					 sizeof(struct virtio_gpu_ctrl_hdr),
170 					 NULL);
171 }
172 
173 static void free_vbuf(struct virtio_gpu_device *vgdev,
174 		      struct virtio_gpu_vbuffer *vbuf)
175 {
176 	if (vbuf->resp_size > MAX_INLINE_RESP_SIZE)
177 		kfree(vbuf->resp_buf);
178 	kvfree(vbuf->data_buf);
179 	kmem_cache_free(vgdev->vbufs, vbuf);
180 }
181 
182 static void reclaim_vbufs(struct virtqueue *vq, struct list_head *reclaim_list)
183 {
184 	struct virtio_gpu_vbuffer *vbuf;
185 	unsigned int len;
186 	int freed = 0;
187 
188 	while ((vbuf = virtqueue_get_buf(vq, &len))) {
189 		list_add_tail(&vbuf->list, reclaim_list);
190 		freed++;
191 	}
192 	if (freed == 0)
193 		DRM_DEBUG("Huh? zero vbufs reclaimed");
194 }
195 
196 void virtio_gpu_dequeue_ctrl_func(struct work_struct *work)
197 {
198 	struct virtio_gpu_device *vgdev =
199 		container_of(work, struct virtio_gpu_device,
200 			     ctrlq.dequeue_work);
201 	struct list_head reclaim_list;
202 	struct virtio_gpu_vbuffer *entry, *tmp;
203 	struct virtio_gpu_ctrl_hdr *resp;
204 	u64 fence_id;
205 
206 	INIT_LIST_HEAD(&reclaim_list);
207 	spin_lock(&vgdev->ctrlq.qlock);
208 	do {
209 		virtqueue_disable_cb(vgdev->ctrlq.vq);
210 		reclaim_vbufs(vgdev->ctrlq.vq, &reclaim_list);
211 
212 	} while (!virtqueue_enable_cb(vgdev->ctrlq.vq));
213 	spin_unlock(&vgdev->ctrlq.qlock);
214 
215 	list_for_each_entry(entry, &reclaim_list, list) {
216 		resp = (struct virtio_gpu_ctrl_hdr *)entry->resp_buf;
217 
218 		trace_virtio_gpu_cmd_response(vgdev->ctrlq.vq, resp);
219 
220 		if (resp->type != cpu_to_le32(VIRTIO_GPU_RESP_OK_NODATA)) {
221 			if (le32_to_cpu(resp->type) >= VIRTIO_GPU_RESP_ERR_UNSPEC) {
222 				struct virtio_gpu_ctrl_hdr *cmd;
223 				cmd = virtio_gpu_vbuf_ctrl_hdr(entry);
224 				DRM_ERROR_RATELIMITED("response 0x%x (command 0x%x)\n",
225 						      le32_to_cpu(resp->type),
226 						      le32_to_cpu(cmd->type));
227 			} else
228 				DRM_DEBUG("response 0x%x\n", le32_to_cpu(resp->type));
229 		}
230 		if (resp->flags & cpu_to_le32(VIRTIO_GPU_FLAG_FENCE)) {
231 			fence_id = le64_to_cpu(resp->fence_id);
232 			virtio_gpu_fence_event_process(vgdev, fence_id);
233 		}
234 		if (entry->resp_cb)
235 			entry->resp_cb(vgdev, entry);
236 	}
237 	wake_up(&vgdev->ctrlq.ack_queue);
238 
239 	list_for_each_entry_safe(entry, tmp, &reclaim_list, list) {
240 		if (entry->objs)
241 			virtio_gpu_array_put_free_delayed(vgdev, entry->objs);
242 		list_del(&entry->list);
243 		free_vbuf(vgdev, entry);
244 	}
245 }
246 
247 void virtio_gpu_dequeue_cursor_func(struct work_struct *work)
248 {
249 	struct virtio_gpu_device *vgdev =
250 		container_of(work, struct virtio_gpu_device,
251 			     cursorq.dequeue_work);
252 	struct list_head reclaim_list;
253 	struct virtio_gpu_vbuffer *entry, *tmp;
254 
255 	INIT_LIST_HEAD(&reclaim_list);
256 	spin_lock(&vgdev->cursorq.qlock);
257 	do {
258 		virtqueue_disable_cb(vgdev->cursorq.vq);
259 		reclaim_vbufs(vgdev->cursorq.vq, &reclaim_list);
260 	} while (!virtqueue_enable_cb(vgdev->cursorq.vq));
261 	spin_unlock(&vgdev->cursorq.qlock);
262 
263 	list_for_each_entry_safe(entry, tmp, &reclaim_list, list) {
264 		list_del(&entry->list);
265 		free_vbuf(vgdev, entry);
266 	}
267 	wake_up(&vgdev->cursorq.ack_queue);
268 }
269 
270 /* Create sg_table from a vmalloc'd buffer. */
271 static struct sg_table *vmalloc_to_sgt(char *data, uint32_t size, int *sg_ents)
272 {
273 	int ret, s, i;
274 	struct sg_table *sgt;
275 	struct scatterlist *sg;
276 	struct page *pg;
277 
278 	if (WARN_ON(!PAGE_ALIGNED(data)))
279 		return NULL;
280 
281 	sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
282 	if (!sgt)
283 		return NULL;
284 
285 	*sg_ents = DIV_ROUND_UP(size, PAGE_SIZE);
286 	ret = sg_alloc_table(sgt, *sg_ents, GFP_KERNEL);
287 	if (ret) {
288 		kfree(sgt);
289 		return NULL;
290 	}
291 
292 	for_each_sgtable_sg(sgt, sg, i) {
293 		pg = vmalloc_to_page(data);
294 		if (!pg) {
295 			sg_free_table(sgt);
296 			kfree(sgt);
297 			return NULL;
298 		}
299 
300 		s = min_t(int, PAGE_SIZE, size);
301 		sg_set_page(sg, pg, s, 0);
302 
303 		size -= s;
304 		data += s;
305 	}
306 
307 	return sgt;
308 }
309 
310 static int virtio_gpu_queue_ctrl_sgs(struct virtio_gpu_device *vgdev,
311 				     struct virtio_gpu_vbuffer *vbuf,
312 				     struct virtio_gpu_fence *fence,
313 				     int elemcnt,
314 				     struct scatterlist **sgs,
315 				     int outcnt,
316 				     int incnt)
317 {
318 	struct virtqueue *vq = vgdev->ctrlq.vq;
319 	int ret, idx;
320 
321 	if (!drm_dev_enter(vgdev->ddev, &idx)) {
322 		if (fence && vbuf->objs)
323 			virtio_gpu_array_unlock_resv(vbuf->objs);
324 		free_vbuf(vgdev, vbuf);
325 		return -1;
326 	}
327 
328 	if (vgdev->has_indirect)
329 		elemcnt = 1;
330 
331 again:
332 	spin_lock(&vgdev->ctrlq.qlock);
333 
334 	if (vq->num_free < elemcnt) {
335 		spin_unlock(&vgdev->ctrlq.qlock);
336 		virtio_gpu_notify(vgdev);
337 		wait_event(vgdev->ctrlq.ack_queue, vq->num_free >= elemcnt);
338 		goto again;
339 	}
340 
341 	/* now that the position of the vbuf in the virtqueue is known, we can
342 	 * finally set the fence id
343 	 */
344 	if (fence) {
345 		virtio_gpu_fence_emit(vgdev, virtio_gpu_vbuf_ctrl_hdr(vbuf),
346 				      fence);
347 		if (vbuf->objs) {
348 			virtio_gpu_array_add_fence(vbuf->objs, &fence->f);
349 			virtio_gpu_array_unlock_resv(vbuf->objs);
350 		}
351 	}
352 
353 	ret = virtqueue_add_sgs(vq, sgs, outcnt, incnt, vbuf, GFP_ATOMIC);
354 	WARN_ON(ret);
355 
356 	trace_virtio_gpu_cmd_queue(vq, virtio_gpu_vbuf_ctrl_hdr(vbuf));
357 
358 	atomic_inc(&vgdev->pending_commands);
359 
360 	spin_unlock(&vgdev->ctrlq.qlock);
361 
362 	drm_dev_exit(idx);
363 	return 0;
364 }
365 
366 static int virtio_gpu_queue_fenced_ctrl_buffer(struct virtio_gpu_device *vgdev,
367 					       struct virtio_gpu_vbuffer *vbuf,
368 					       struct virtio_gpu_fence *fence)
369 {
370 	struct scatterlist *sgs[3], vcmd, vout, vresp;
371 	struct sg_table *sgt = NULL;
372 	int elemcnt = 0, outcnt = 0, incnt = 0, ret;
373 
374 	/* set up vcmd */
375 	sg_init_one(&vcmd, vbuf->buf, vbuf->size);
376 	elemcnt++;
377 	sgs[outcnt] = &vcmd;
378 	outcnt++;
379 
380 	/* set up vout */
381 	if (vbuf->data_size) {
382 		if (is_vmalloc_addr(vbuf->data_buf)) {
383 			int sg_ents;
384 			sgt = vmalloc_to_sgt(vbuf->data_buf, vbuf->data_size,
385 					     &sg_ents);
386 			if (!sgt) {
387 				if (fence && vbuf->objs)
388 					virtio_gpu_array_unlock_resv(vbuf->objs);
389 				return -1;
390 			}
391 
392 			elemcnt += sg_ents;
393 			sgs[outcnt] = sgt->sgl;
394 		} else {
395 			sg_init_one(&vout, vbuf->data_buf, vbuf->data_size);
396 			elemcnt++;
397 			sgs[outcnt] = &vout;
398 		}
399 		outcnt++;
400 	}
401 
402 	/* set up vresp */
403 	if (vbuf->resp_size) {
404 		sg_init_one(&vresp, vbuf->resp_buf, vbuf->resp_size);
405 		elemcnt++;
406 		sgs[outcnt + incnt] = &vresp;
407 		incnt++;
408 	}
409 
410 	ret = virtio_gpu_queue_ctrl_sgs(vgdev, vbuf, fence, elemcnt, sgs, outcnt,
411 					incnt);
412 
413 	if (sgt) {
414 		sg_free_table(sgt);
415 		kfree(sgt);
416 	}
417 	return ret;
418 }
419 
420 void virtio_gpu_notify(struct virtio_gpu_device *vgdev)
421 {
422 	bool notify;
423 
424 	if (!atomic_read(&vgdev->pending_commands))
425 		return;
426 
427 	spin_lock(&vgdev->ctrlq.qlock);
428 	atomic_set(&vgdev->pending_commands, 0);
429 	notify = virtqueue_kick_prepare(vgdev->ctrlq.vq);
430 	spin_unlock(&vgdev->ctrlq.qlock);
431 
432 	if (notify)
433 		virtqueue_notify(vgdev->ctrlq.vq);
434 }
435 
436 static int virtio_gpu_queue_ctrl_buffer(struct virtio_gpu_device *vgdev,
437 					struct virtio_gpu_vbuffer *vbuf)
438 {
439 	return virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, NULL);
440 }
441 
442 static void virtio_gpu_queue_cursor(struct virtio_gpu_device *vgdev,
443 				    struct virtio_gpu_vbuffer *vbuf)
444 {
445 	struct virtqueue *vq = vgdev->cursorq.vq;
446 	struct scatterlist *sgs[1], ccmd;
447 	int idx, ret, outcnt;
448 	bool notify;
449 
450 	if (!drm_dev_enter(vgdev->ddev, &idx)) {
451 		free_vbuf(vgdev, vbuf);
452 		return;
453 	}
454 
455 	sg_init_one(&ccmd, vbuf->buf, vbuf->size);
456 	sgs[0] = &ccmd;
457 	outcnt = 1;
458 
459 	spin_lock(&vgdev->cursorq.qlock);
460 retry:
461 	ret = virtqueue_add_sgs(vq, sgs, outcnt, 0, vbuf, GFP_ATOMIC);
462 	if (ret == -ENOSPC) {
463 		spin_unlock(&vgdev->cursorq.qlock);
464 		wait_event(vgdev->cursorq.ack_queue, vq->num_free >= outcnt);
465 		spin_lock(&vgdev->cursorq.qlock);
466 		goto retry;
467 	} else {
468 		trace_virtio_gpu_cmd_queue(vq,
469 			virtio_gpu_vbuf_ctrl_hdr(vbuf));
470 
471 		notify = virtqueue_kick_prepare(vq);
472 	}
473 
474 	spin_unlock(&vgdev->cursorq.qlock);
475 
476 	if (notify)
477 		virtqueue_notify(vq);
478 
479 	drm_dev_exit(idx);
480 }
481 
482 /* just create gem objects for userspace and long lived objects,
483  * just use dma_alloced pages for the queue objects?
484  */
485 
486 /* create a basic resource */
487 void virtio_gpu_cmd_create_resource(struct virtio_gpu_device *vgdev,
488 				    struct virtio_gpu_object *bo,
489 				    struct virtio_gpu_object_params *params,
490 				    struct virtio_gpu_object_array *objs,
491 				    struct virtio_gpu_fence *fence)
492 {
493 	struct virtio_gpu_resource_create_2d *cmd_p;
494 	struct virtio_gpu_vbuffer *vbuf;
495 
496 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
497 	memset(cmd_p, 0, sizeof(*cmd_p));
498 	vbuf->objs = objs;
499 
500 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_CREATE_2D);
501 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
502 	cmd_p->format = cpu_to_le32(params->format);
503 	cmd_p->width = cpu_to_le32(params->width);
504 	cmd_p->height = cpu_to_le32(params->height);
505 
506 	virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
507 	bo->created = true;
508 }
509 
510 static void virtio_gpu_cmd_unref_cb(struct virtio_gpu_device *vgdev,
511 				    struct virtio_gpu_vbuffer *vbuf)
512 {
513 	struct virtio_gpu_object *bo;
514 
515 	bo = vbuf->resp_cb_data;
516 	vbuf->resp_cb_data = NULL;
517 
518 	virtio_gpu_cleanup_object(bo);
519 }
520 
521 void virtio_gpu_cmd_unref_resource(struct virtio_gpu_device *vgdev,
522 				   struct virtio_gpu_object *bo)
523 {
524 	struct virtio_gpu_resource_unref *cmd_p;
525 	struct virtio_gpu_vbuffer *vbuf;
526 	int ret;
527 
528 	cmd_p = virtio_gpu_alloc_cmd_cb(vgdev, &vbuf, sizeof(*cmd_p),
529 					virtio_gpu_cmd_unref_cb);
530 	memset(cmd_p, 0, sizeof(*cmd_p));
531 
532 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_UNREF);
533 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
534 
535 	vbuf->resp_cb_data = bo;
536 	ret = virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
537 	if (ret < 0)
538 		virtio_gpu_cleanup_object(bo);
539 }
540 
541 void virtio_gpu_cmd_set_scanout(struct virtio_gpu_device *vgdev,
542 				uint32_t scanout_id, uint32_t resource_id,
543 				uint32_t width, uint32_t height,
544 				uint32_t x, uint32_t y)
545 {
546 	struct virtio_gpu_set_scanout *cmd_p;
547 	struct virtio_gpu_vbuffer *vbuf;
548 
549 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
550 	memset(cmd_p, 0, sizeof(*cmd_p));
551 
552 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_SET_SCANOUT);
553 	cmd_p->resource_id = cpu_to_le32(resource_id);
554 	cmd_p->scanout_id = cpu_to_le32(scanout_id);
555 	cmd_p->r.width = cpu_to_le32(width);
556 	cmd_p->r.height = cpu_to_le32(height);
557 	cmd_p->r.x = cpu_to_le32(x);
558 	cmd_p->r.y = cpu_to_le32(y);
559 
560 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
561 }
562 
563 void virtio_gpu_cmd_resource_flush(struct virtio_gpu_device *vgdev,
564 				   uint32_t resource_id,
565 				   uint32_t x, uint32_t y,
566 				   uint32_t width, uint32_t height,
567 				   struct virtio_gpu_object_array *objs,
568 				   struct virtio_gpu_fence *fence)
569 {
570 	struct virtio_gpu_resource_flush *cmd_p;
571 	struct virtio_gpu_vbuffer *vbuf;
572 
573 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
574 	memset(cmd_p, 0, sizeof(*cmd_p));
575 	vbuf->objs = objs;
576 
577 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_FLUSH);
578 	cmd_p->resource_id = cpu_to_le32(resource_id);
579 	cmd_p->r.width = cpu_to_le32(width);
580 	cmd_p->r.height = cpu_to_le32(height);
581 	cmd_p->r.x = cpu_to_le32(x);
582 	cmd_p->r.y = cpu_to_le32(y);
583 
584 	virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
585 }
586 
587 void virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev,
588 					uint64_t offset,
589 					uint32_t width, uint32_t height,
590 					uint32_t x, uint32_t y,
591 					struct virtio_gpu_object_array *objs,
592 					struct virtio_gpu_fence *fence)
593 {
594 	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(objs->objs[0]);
595 	struct virtio_gpu_transfer_to_host_2d *cmd_p;
596 	struct virtio_gpu_vbuffer *vbuf;
597 	bool use_dma_api = !virtio_has_dma_quirk(vgdev->vdev);
598 	struct virtio_gpu_object_shmem *shmem = to_virtio_gpu_shmem(bo);
599 
600 	if (use_dma_api)
601 		dma_sync_sgtable_for_device(vgdev->vdev->dev.parent,
602 					    shmem->pages, DMA_TO_DEVICE);
603 
604 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
605 	memset(cmd_p, 0, sizeof(*cmd_p));
606 	vbuf->objs = objs;
607 
608 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D);
609 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
610 	cmd_p->offset = cpu_to_le64(offset);
611 	cmd_p->r.width = cpu_to_le32(width);
612 	cmd_p->r.height = cpu_to_le32(height);
613 	cmd_p->r.x = cpu_to_le32(x);
614 	cmd_p->r.y = cpu_to_le32(y);
615 
616 	virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
617 }
618 
619 static void
620 virtio_gpu_cmd_resource_attach_backing(struct virtio_gpu_device *vgdev,
621 				       uint32_t resource_id,
622 				       struct virtio_gpu_mem_entry *ents,
623 				       uint32_t nents,
624 				       struct virtio_gpu_fence *fence)
625 {
626 	struct virtio_gpu_resource_attach_backing *cmd_p;
627 	struct virtio_gpu_vbuffer *vbuf;
628 
629 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
630 	memset(cmd_p, 0, sizeof(*cmd_p));
631 
632 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING);
633 	cmd_p->resource_id = cpu_to_le32(resource_id);
634 	cmd_p->nr_entries = cpu_to_le32(nents);
635 
636 	vbuf->data_buf = ents;
637 	vbuf->data_size = sizeof(*ents) * nents;
638 
639 	virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
640 }
641 
642 static void virtio_gpu_cmd_get_display_info_cb(struct virtio_gpu_device *vgdev,
643 					       struct virtio_gpu_vbuffer *vbuf)
644 {
645 	struct virtio_gpu_resp_display_info *resp =
646 		(struct virtio_gpu_resp_display_info *)vbuf->resp_buf;
647 	int i;
648 
649 	spin_lock(&vgdev->display_info_lock);
650 	for (i = 0; i < vgdev->num_scanouts; i++) {
651 		vgdev->outputs[i].info = resp->pmodes[i];
652 		if (resp->pmodes[i].enabled) {
653 			DRM_DEBUG("output %d: %dx%d+%d+%d", i,
654 				  le32_to_cpu(resp->pmodes[i].r.width),
655 				  le32_to_cpu(resp->pmodes[i].r.height),
656 				  le32_to_cpu(resp->pmodes[i].r.x),
657 				  le32_to_cpu(resp->pmodes[i].r.y));
658 		} else {
659 			DRM_DEBUG("output %d: disabled", i);
660 		}
661 	}
662 
663 	vgdev->display_info_pending = false;
664 	spin_unlock(&vgdev->display_info_lock);
665 	wake_up(&vgdev->resp_wq);
666 
667 	if (!drm_helper_hpd_irq_event(vgdev->ddev))
668 		drm_kms_helper_hotplug_event(vgdev->ddev);
669 }
670 
671 static void virtio_gpu_cmd_get_capset_info_cb(struct virtio_gpu_device *vgdev,
672 					      struct virtio_gpu_vbuffer *vbuf)
673 {
674 	struct virtio_gpu_get_capset_info *cmd =
675 		(struct virtio_gpu_get_capset_info *)vbuf->buf;
676 	struct virtio_gpu_resp_capset_info *resp =
677 		(struct virtio_gpu_resp_capset_info *)vbuf->resp_buf;
678 	int i = le32_to_cpu(cmd->capset_index);
679 
680 	spin_lock(&vgdev->display_info_lock);
681 	if (vgdev->capsets) {
682 		vgdev->capsets[i].id = le32_to_cpu(resp->capset_id);
683 		vgdev->capsets[i].max_version = le32_to_cpu(resp->capset_max_version);
684 		vgdev->capsets[i].max_size = le32_to_cpu(resp->capset_max_size);
685 	} else {
686 		DRM_ERROR("invalid capset memory.");
687 	}
688 	spin_unlock(&vgdev->display_info_lock);
689 	wake_up(&vgdev->resp_wq);
690 }
691 
692 static void virtio_gpu_cmd_capset_cb(struct virtio_gpu_device *vgdev,
693 				     struct virtio_gpu_vbuffer *vbuf)
694 {
695 	struct virtio_gpu_get_capset *cmd =
696 		(struct virtio_gpu_get_capset *)vbuf->buf;
697 	struct virtio_gpu_resp_capset *resp =
698 		(struct virtio_gpu_resp_capset *)vbuf->resp_buf;
699 	struct virtio_gpu_drv_cap_cache *cache_ent;
700 
701 	spin_lock(&vgdev->display_info_lock);
702 	list_for_each_entry(cache_ent, &vgdev->cap_cache, head) {
703 		if (cache_ent->version == le32_to_cpu(cmd->capset_version) &&
704 		    cache_ent->id == le32_to_cpu(cmd->capset_id)) {
705 			memcpy(cache_ent->caps_cache, resp->capset_data,
706 			       cache_ent->size);
707 			/* Copy must occur before is_valid is signalled. */
708 			smp_wmb();
709 			atomic_set(&cache_ent->is_valid, 1);
710 			break;
711 		}
712 	}
713 	spin_unlock(&vgdev->display_info_lock);
714 	wake_up_all(&vgdev->resp_wq);
715 }
716 
717 static int virtio_get_edid_block(void *data, u8 *buf,
718 				 unsigned int block, size_t len)
719 {
720 	struct virtio_gpu_resp_edid *resp = data;
721 	size_t start = block * EDID_LENGTH;
722 
723 	if (start + len > le32_to_cpu(resp->size))
724 		return -1;
725 	memcpy(buf, resp->edid + start, len);
726 	return 0;
727 }
728 
729 static void virtio_gpu_cmd_get_edid_cb(struct virtio_gpu_device *vgdev,
730 				       struct virtio_gpu_vbuffer *vbuf)
731 {
732 	struct virtio_gpu_cmd_get_edid *cmd =
733 		(struct virtio_gpu_cmd_get_edid *)vbuf->buf;
734 	struct virtio_gpu_resp_edid *resp =
735 		(struct virtio_gpu_resp_edid *)vbuf->resp_buf;
736 	uint32_t scanout = le32_to_cpu(cmd->scanout);
737 	struct virtio_gpu_output *output;
738 	struct edid *new_edid, *old_edid;
739 
740 	if (scanout >= vgdev->num_scanouts)
741 		return;
742 	output = vgdev->outputs + scanout;
743 
744 	new_edid = drm_do_get_edid(&output->conn, virtio_get_edid_block, resp);
745 	drm_connector_update_edid_property(&output->conn, new_edid);
746 
747 	spin_lock(&vgdev->display_info_lock);
748 	old_edid = output->edid;
749 	output->edid = new_edid;
750 	spin_unlock(&vgdev->display_info_lock);
751 
752 	kfree(old_edid);
753 	wake_up(&vgdev->resp_wq);
754 }
755 
756 int virtio_gpu_cmd_get_display_info(struct virtio_gpu_device *vgdev)
757 {
758 	struct virtio_gpu_ctrl_hdr *cmd_p;
759 	struct virtio_gpu_vbuffer *vbuf;
760 	void *resp_buf;
761 
762 	resp_buf = kzalloc(sizeof(struct virtio_gpu_resp_display_info),
763 			   GFP_KERNEL);
764 	if (!resp_buf)
765 		return -ENOMEM;
766 
767 	cmd_p = virtio_gpu_alloc_cmd_resp
768 		(vgdev, &virtio_gpu_cmd_get_display_info_cb, &vbuf,
769 		 sizeof(*cmd_p), sizeof(struct virtio_gpu_resp_display_info),
770 		 resp_buf);
771 	memset(cmd_p, 0, sizeof(*cmd_p));
772 
773 	vgdev->display_info_pending = true;
774 	cmd_p->type = cpu_to_le32(VIRTIO_GPU_CMD_GET_DISPLAY_INFO);
775 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
776 	return 0;
777 }
778 
779 int virtio_gpu_cmd_get_capset_info(struct virtio_gpu_device *vgdev, int idx)
780 {
781 	struct virtio_gpu_get_capset_info *cmd_p;
782 	struct virtio_gpu_vbuffer *vbuf;
783 	void *resp_buf;
784 
785 	resp_buf = kzalloc(sizeof(struct virtio_gpu_resp_capset_info),
786 			   GFP_KERNEL);
787 	if (!resp_buf)
788 		return -ENOMEM;
789 
790 	cmd_p = virtio_gpu_alloc_cmd_resp
791 		(vgdev, &virtio_gpu_cmd_get_capset_info_cb, &vbuf,
792 		 sizeof(*cmd_p), sizeof(struct virtio_gpu_resp_capset_info),
793 		 resp_buf);
794 	memset(cmd_p, 0, sizeof(*cmd_p));
795 
796 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_GET_CAPSET_INFO);
797 	cmd_p->capset_index = cpu_to_le32(idx);
798 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
799 	return 0;
800 }
801 
802 int virtio_gpu_cmd_get_capset(struct virtio_gpu_device *vgdev,
803 			      int idx, int version,
804 			      struct virtio_gpu_drv_cap_cache **cache_p)
805 {
806 	struct virtio_gpu_get_capset *cmd_p;
807 	struct virtio_gpu_vbuffer *vbuf;
808 	int max_size;
809 	struct virtio_gpu_drv_cap_cache *cache_ent;
810 	struct virtio_gpu_drv_cap_cache *search_ent;
811 	void *resp_buf;
812 
813 	*cache_p = NULL;
814 
815 	if (idx >= vgdev->num_capsets)
816 		return -EINVAL;
817 
818 	if (version > vgdev->capsets[idx].max_version)
819 		return -EINVAL;
820 
821 	cache_ent = kzalloc(sizeof(*cache_ent), GFP_KERNEL);
822 	if (!cache_ent)
823 		return -ENOMEM;
824 
825 	max_size = vgdev->capsets[idx].max_size;
826 	cache_ent->caps_cache = kmalloc(max_size, GFP_KERNEL);
827 	if (!cache_ent->caps_cache) {
828 		kfree(cache_ent);
829 		return -ENOMEM;
830 	}
831 
832 	resp_buf = kzalloc(sizeof(struct virtio_gpu_resp_capset) + max_size,
833 			   GFP_KERNEL);
834 	if (!resp_buf) {
835 		kfree(cache_ent->caps_cache);
836 		kfree(cache_ent);
837 		return -ENOMEM;
838 	}
839 
840 	cache_ent->version = version;
841 	cache_ent->id = vgdev->capsets[idx].id;
842 	atomic_set(&cache_ent->is_valid, 0);
843 	cache_ent->size = max_size;
844 	spin_lock(&vgdev->display_info_lock);
845 	/* Search while under lock in case it was added by another task. */
846 	list_for_each_entry(search_ent, &vgdev->cap_cache, head) {
847 		if (search_ent->id == vgdev->capsets[idx].id &&
848 		    search_ent->version == version) {
849 			*cache_p = search_ent;
850 			break;
851 		}
852 	}
853 	if (!*cache_p)
854 		list_add_tail(&cache_ent->head, &vgdev->cap_cache);
855 	spin_unlock(&vgdev->display_info_lock);
856 
857 	if (*cache_p) {
858 		/* Entry was found, so free everything that was just created. */
859 		kfree(resp_buf);
860 		kfree(cache_ent->caps_cache);
861 		kfree(cache_ent);
862 		return 0;
863 	}
864 
865 	cmd_p = virtio_gpu_alloc_cmd_resp
866 		(vgdev, &virtio_gpu_cmd_capset_cb, &vbuf, sizeof(*cmd_p),
867 		 sizeof(struct virtio_gpu_resp_capset) + max_size,
868 		 resp_buf);
869 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_GET_CAPSET);
870 	cmd_p->capset_id = cpu_to_le32(vgdev->capsets[idx].id);
871 	cmd_p->capset_version = cpu_to_le32(version);
872 	*cache_p = cache_ent;
873 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
874 
875 	return 0;
876 }
877 
878 int virtio_gpu_cmd_get_edids(struct virtio_gpu_device *vgdev)
879 {
880 	struct virtio_gpu_cmd_get_edid *cmd_p;
881 	struct virtio_gpu_vbuffer *vbuf;
882 	void *resp_buf;
883 	int scanout;
884 
885 	if (WARN_ON(!vgdev->has_edid))
886 		return -EINVAL;
887 
888 	for (scanout = 0; scanout < vgdev->num_scanouts; scanout++) {
889 		resp_buf = kzalloc(sizeof(struct virtio_gpu_resp_edid),
890 				   GFP_KERNEL);
891 		if (!resp_buf)
892 			return -ENOMEM;
893 
894 		cmd_p = virtio_gpu_alloc_cmd_resp
895 			(vgdev, &virtio_gpu_cmd_get_edid_cb, &vbuf,
896 			 sizeof(*cmd_p), sizeof(struct virtio_gpu_resp_edid),
897 			 resp_buf);
898 		cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_GET_EDID);
899 		cmd_p->scanout = cpu_to_le32(scanout);
900 		virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
901 	}
902 
903 	return 0;
904 }
905 
906 void virtio_gpu_cmd_context_create(struct virtio_gpu_device *vgdev, uint32_t id,
907 				   uint32_t context_init, uint32_t nlen,
908 				   const char *name)
909 {
910 	struct virtio_gpu_ctx_create *cmd_p;
911 	struct virtio_gpu_vbuffer *vbuf;
912 
913 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
914 	memset(cmd_p, 0, sizeof(*cmd_p));
915 
916 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_CTX_CREATE);
917 	cmd_p->hdr.ctx_id = cpu_to_le32(id);
918 	cmd_p->nlen = cpu_to_le32(nlen);
919 	cmd_p->context_init = cpu_to_le32(context_init);
920 	strncpy(cmd_p->debug_name, name, sizeof(cmd_p->debug_name) - 1);
921 	cmd_p->debug_name[sizeof(cmd_p->debug_name) - 1] = 0;
922 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
923 }
924 
925 void virtio_gpu_cmd_context_destroy(struct virtio_gpu_device *vgdev,
926 				    uint32_t id)
927 {
928 	struct virtio_gpu_ctx_destroy *cmd_p;
929 	struct virtio_gpu_vbuffer *vbuf;
930 
931 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
932 	memset(cmd_p, 0, sizeof(*cmd_p));
933 
934 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_CTX_DESTROY);
935 	cmd_p->hdr.ctx_id = cpu_to_le32(id);
936 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
937 }
938 
939 void virtio_gpu_cmd_context_attach_resource(struct virtio_gpu_device *vgdev,
940 					    uint32_t ctx_id,
941 					    struct virtio_gpu_object_array *objs)
942 {
943 	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(objs->objs[0]);
944 	struct virtio_gpu_ctx_resource *cmd_p;
945 	struct virtio_gpu_vbuffer *vbuf;
946 
947 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
948 	memset(cmd_p, 0, sizeof(*cmd_p));
949 	vbuf->objs = objs;
950 
951 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE);
952 	cmd_p->hdr.ctx_id = cpu_to_le32(ctx_id);
953 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
954 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
955 }
956 
957 void virtio_gpu_cmd_context_detach_resource(struct virtio_gpu_device *vgdev,
958 					    uint32_t ctx_id,
959 					    struct virtio_gpu_object_array *objs)
960 {
961 	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(objs->objs[0]);
962 	struct virtio_gpu_ctx_resource *cmd_p;
963 	struct virtio_gpu_vbuffer *vbuf;
964 
965 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
966 	memset(cmd_p, 0, sizeof(*cmd_p));
967 	vbuf->objs = objs;
968 
969 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE);
970 	cmd_p->hdr.ctx_id = cpu_to_le32(ctx_id);
971 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
972 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
973 }
974 
975 void
976 virtio_gpu_cmd_resource_create_3d(struct virtio_gpu_device *vgdev,
977 				  struct virtio_gpu_object *bo,
978 				  struct virtio_gpu_object_params *params,
979 				  struct virtio_gpu_object_array *objs,
980 				  struct virtio_gpu_fence *fence)
981 {
982 	struct virtio_gpu_resource_create_3d *cmd_p;
983 	struct virtio_gpu_vbuffer *vbuf;
984 
985 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
986 	memset(cmd_p, 0, sizeof(*cmd_p));
987 	vbuf->objs = objs;
988 
989 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_CREATE_3D);
990 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
991 	cmd_p->format = cpu_to_le32(params->format);
992 	cmd_p->width = cpu_to_le32(params->width);
993 	cmd_p->height = cpu_to_le32(params->height);
994 
995 	cmd_p->target = cpu_to_le32(params->target);
996 	cmd_p->bind = cpu_to_le32(params->bind);
997 	cmd_p->depth = cpu_to_le32(params->depth);
998 	cmd_p->array_size = cpu_to_le32(params->array_size);
999 	cmd_p->last_level = cpu_to_le32(params->last_level);
1000 	cmd_p->nr_samples = cpu_to_le32(params->nr_samples);
1001 	cmd_p->flags = cpu_to_le32(params->flags);
1002 
1003 	virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
1004 
1005 	bo->created = true;
1006 }
1007 
1008 void virtio_gpu_cmd_transfer_to_host_3d(struct virtio_gpu_device *vgdev,
1009 					uint32_t ctx_id,
1010 					uint64_t offset, uint32_t level,
1011 					uint32_t stride,
1012 					uint32_t layer_stride,
1013 					struct drm_virtgpu_3d_box *box,
1014 					struct virtio_gpu_object_array *objs,
1015 					struct virtio_gpu_fence *fence)
1016 {
1017 	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(objs->objs[0]);
1018 	struct virtio_gpu_transfer_host_3d *cmd_p;
1019 	struct virtio_gpu_vbuffer *vbuf;
1020 	bool use_dma_api = !virtio_has_dma_quirk(vgdev->vdev);
1021 
1022 	if (virtio_gpu_is_shmem(bo) && use_dma_api) {
1023 		struct virtio_gpu_object_shmem *shmem = to_virtio_gpu_shmem(bo);
1024 		dma_sync_sgtable_for_device(vgdev->vdev->dev.parent,
1025 					    shmem->pages, DMA_TO_DEVICE);
1026 	}
1027 
1028 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
1029 	memset(cmd_p, 0, sizeof(*cmd_p));
1030 
1031 	vbuf->objs = objs;
1032 
1033 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D);
1034 	cmd_p->hdr.ctx_id = cpu_to_le32(ctx_id);
1035 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
1036 	convert_to_hw_box(&cmd_p->box, box);
1037 	cmd_p->offset = cpu_to_le64(offset);
1038 	cmd_p->level = cpu_to_le32(level);
1039 	cmd_p->stride = cpu_to_le32(stride);
1040 	cmd_p->layer_stride = cpu_to_le32(layer_stride);
1041 
1042 	virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
1043 }
1044 
1045 void virtio_gpu_cmd_transfer_from_host_3d(struct virtio_gpu_device *vgdev,
1046 					  uint32_t ctx_id,
1047 					  uint64_t offset, uint32_t level,
1048 					  uint32_t stride,
1049 					  uint32_t layer_stride,
1050 					  struct drm_virtgpu_3d_box *box,
1051 					  struct virtio_gpu_object_array *objs,
1052 					  struct virtio_gpu_fence *fence)
1053 {
1054 	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(objs->objs[0]);
1055 	struct virtio_gpu_transfer_host_3d *cmd_p;
1056 	struct virtio_gpu_vbuffer *vbuf;
1057 
1058 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
1059 	memset(cmd_p, 0, sizeof(*cmd_p));
1060 
1061 	vbuf->objs = objs;
1062 
1063 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D);
1064 	cmd_p->hdr.ctx_id = cpu_to_le32(ctx_id);
1065 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
1066 	convert_to_hw_box(&cmd_p->box, box);
1067 	cmd_p->offset = cpu_to_le64(offset);
1068 	cmd_p->level = cpu_to_le32(level);
1069 	cmd_p->stride = cpu_to_le32(stride);
1070 	cmd_p->layer_stride = cpu_to_le32(layer_stride);
1071 
1072 	virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
1073 }
1074 
1075 void virtio_gpu_cmd_submit(struct virtio_gpu_device *vgdev,
1076 			   void *data, uint32_t data_size,
1077 			   uint32_t ctx_id,
1078 			   struct virtio_gpu_object_array *objs,
1079 			   struct virtio_gpu_fence *fence)
1080 {
1081 	struct virtio_gpu_cmd_submit *cmd_p;
1082 	struct virtio_gpu_vbuffer *vbuf;
1083 
1084 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
1085 	memset(cmd_p, 0, sizeof(*cmd_p));
1086 
1087 	vbuf->data_buf = data;
1088 	vbuf->data_size = data_size;
1089 	vbuf->objs = objs;
1090 
1091 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_SUBMIT_3D);
1092 	cmd_p->hdr.ctx_id = cpu_to_le32(ctx_id);
1093 	cmd_p->size = cpu_to_le32(data_size);
1094 
1095 	virtio_gpu_queue_fenced_ctrl_buffer(vgdev, vbuf, fence);
1096 }
1097 
1098 void virtio_gpu_object_attach(struct virtio_gpu_device *vgdev,
1099 			      struct virtio_gpu_object *obj,
1100 			      struct virtio_gpu_mem_entry *ents,
1101 			      unsigned int nents)
1102 {
1103 	virtio_gpu_cmd_resource_attach_backing(vgdev, obj->hw_res_handle,
1104 					       ents, nents, NULL);
1105 }
1106 
1107 void virtio_gpu_cursor_ping(struct virtio_gpu_device *vgdev,
1108 			    struct virtio_gpu_output *output)
1109 {
1110 	struct virtio_gpu_vbuffer *vbuf;
1111 	struct virtio_gpu_update_cursor *cur_p;
1112 
1113 	output->cursor.pos.scanout_id = cpu_to_le32(output->index);
1114 	cur_p = virtio_gpu_alloc_cursor(vgdev, &vbuf);
1115 	memcpy(cur_p, &output->cursor, sizeof(output->cursor));
1116 	virtio_gpu_queue_cursor(vgdev, vbuf);
1117 }
1118 
1119 static void virtio_gpu_cmd_resource_uuid_cb(struct virtio_gpu_device *vgdev,
1120 					    struct virtio_gpu_vbuffer *vbuf)
1121 {
1122 	struct virtio_gpu_object *obj =
1123 		gem_to_virtio_gpu_obj(vbuf->objs->objs[0]);
1124 	struct virtio_gpu_resp_resource_uuid *resp =
1125 		(struct virtio_gpu_resp_resource_uuid *)vbuf->resp_buf;
1126 	uint32_t resp_type = le32_to_cpu(resp->hdr.type);
1127 
1128 	spin_lock(&vgdev->resource_export_lock);
1129 	WARN_ON(obj->uuid_state != STATE_INITIALIZING);
1130 
1131 	if (resp_type == VIRTIO_GPU_RESP_OK_RESOURCE_UUID &&
1132 	    obj->uuid_state == STATE_INITIALIZING) {
1133 		import_uuid(&obj->uuid, resp->uuid);
1134 		obj->uuid_state = STATE_OK;
1135 	} else {
1136 		obj->uuid_state = STATE_ERR;
1137 	}
1138 	spin_unlock(&vgdev->resource_export_lock);
1139 
1140 	wake_up_all(&vgdev->resp_wq);
1141 }
1142 
1143 int
1144 virtio_gpu_cmd_resource_assign_uuid(struct virtio_gpu_device *vgdev,
1145 				    struct virtio_gpu_object_array *objs)
1146 {
1147 	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(objs->objs[0]);
1148 	struct virtio_gpu_resource_assign_uuid *cmd_p;
1149 	struct virtio_gpu_vbuffer *vbuf;
1150 	struct virtio_gpu_resp_resource_uuid *resp_buf;
1151 
1152 	resp_buf = kzalloc(sizeof(*resp_buf), GFP_KERNEL);
1153 	if (!resp_buf) {
1154 		spin_lock(&vgdev->resource_export_lock);
1155 		bo->uuid_state = STATE_ERR;
1156 		spin_unlock(&vgdev->resource_export_lock);
1157 		virtio_gpu_array_put_free(objs);
1158 		return -ENOMEM;
1159 	}
1160 
1161 	cmd_p = virtio_gpu_alloc_cmd_resp
1162 		(vgdev, virtio_gpu_cmd_resource_uuid_cb, &vbuf, sizeof(*cmd_p),
1163 		 sizeof(struct virtio_gpu_resp_resource_uuid), resp_buf);
1164 	memset(cmd_p, 0, sizeof(*cmd_p));
1165 
1166 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID);
1167 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
1168 
1169 	vbuf->objs = objs;
1170 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
1171 	return 0;
1172 }
1173 
1174 static void virtio_gpu_cmd_resource_map_cb(struct virtio_gpu_device *vgdev,
1175 					   struct virtio_gpu_vbuffer *vbuf)
1176 {
1177 	struct virtio_gpu_object *bo =
1178 		gem_to_virtio_gpu_obj(vbuf->objs->objs[0]);
1179 	struct virtio_gpu_resp_map_info *resp =
1180 		(struct virtio_gpu_resp_map_info *)vbuf->resp_buf;
1181 	struct virtio_gpu_object_vram *vram = to_virtio_gpu_vram(bo);
1182 	uint32_t resp_type = le32_to_cpu(resp->hdr.type);
1183 
1184 	spin_lock(&vgdev->host_visible_lock);
1185 
1186 	if (resp_type == VIRTIO_GPU_RESP_OK_MAP_INFO) {
1187 		vram->map_info = resp->map_info;
1188 		vram->map_state = STATE_OK;
1189 	} else {
1190 		vram->map_state = STATE_ERR;
1191 	}
1192 
1193 	spin_unlock(&vgdev->host_visible_lock);
1194 	wake_up_all(&vgdev->resp_wq);
1195 }
1196 
1197 int virtio_gpu_cmd_map(struct virtio_gpu_device *vgdev,
1198 		       struct virtio_gpu_object_array *objs, uint64_t offset)
1199 {
1200 	struct virtio_gpu_resource_map_blob *cmd_p;
1201 	struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(objs->objs[0]);
1202 	struct virtio_gpu_vbuffer *vbuf;
1203 	struct virtio_gpu_resp_map_info *resp_buf;
1204 
1205 	resp_buf = kzalloc(sizeof(*resp_buf), GFP_KERNEL);
1206 	if (!resp_buf)
1207 		return -ENOMEM;
1208 
1209 	cmd_p = virtio_gpu_alloc_cmd_resp
1210 		(vgdev, virtio_gpu_cmd_resource_map_cb, &vbuf, sizeof(*cmd_p),
1211 		 sizeof(struct virtio_gpu_resp_map_info), resp_buf);
1212 	memset(cmd_p, 0, sizeof(*cmd_p));
1213 
1214 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_MAP_BLOB);
1215 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
1216 	cmd_p->offset = cpu_to_le64(offset);
1217 	vbuf->objs = objs;
1218 
1219 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
1220 	return 0;
1221 }
1222 
1223 void virtio_gpu_cmd_unmap(struct virtio_gpu_device *vgdev,
1224 			  struct virtio_gpu_object *bo)
1225 {
1226 	struct virtio_gpu_resource_unmap_blob *cmd_p;
1227 	struct virtio_gpu_vbuffer *vbuf;
1228 
1229 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
1230 	memset(cmd_p, 0, sizeof(*cmd_p));
1231 
1232 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_UNMAP_BLOB);
1233 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
1234 
1235 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
1236 }
1237 
1238 void
1239 virtio_gpu_cmd_resource_create_blob(struct virtio_gpu_device *vgdev,
1240 				    struct virtio_gpu_object *bo,
1241 				    struct virtio_gpu_object_params *params,
1242 				    struct virtio_gpu_mem_entry *ents,
1243 				    uint32_t nents)
1244 {
1245 	struct virtio_gpu_resource_create_blob *cmd_p;
1246 	struct virtio_gpu_vbuffer *vbuf;
1247 
1248 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
1249 	memset(cmd_p, 0, sizeof(*cmd_p));
1250 
1251 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB);
1252 	cmd_p->hdr.ctx_id = cpu_to_le32(params->ctx_id);
1253 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
1254 	cmd_p->blob_mem = cpu_to_le32(params->blob_mem);
1255 	cmd_p->blob_flags = cpu_to_le32(params->blob_flags);
1256 	cmd_p->blob_id = cpu_to_le64(params->blob_id);
1257 	cmd_p->size = cpu_to_le64(params->size);
1258 	cmd_p->nr_entries = cpu_to_le32(nents);
1259 
1260 	vbuf->data_buf = ents;
1261 	vbuf->data_size = sizeof(*ents) * nents;
1262 
1263 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
1264 	bo->created = true;
1265 }
1266 
1267 void virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_device *vgdev,
1268 				     uint32_t scanout_id,
1269 				     struct virtio_gpu_object *bo,
1270 				     struct drm_framebuffer *fb,
1271 				     uint32_t width, uint32_t height,
1272 				     uint32_t x, uint32_t y)
1273 {
1274 	uint32_t i;
1275 	struct virtio_gpu_set_scanout_blob *cmd_p;
1276 	struct virtio_gpu_vbuffer *vbuf;
1277 	uint32_t format = virtio_gpu_translate_format(fb->format->format);
1278 
1279 	cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p));
1280 	memset(cmd_p, 0, sizeof(*cmd_p));
1281 
1282 	cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_SET_SCANOUT_BLOB);
1283 	cmd_p->resource_id = cpu_to_le32(bo->hw_res_handle);
1284 	cmd_p->scanout_id = cpu_to_le32(scanout_id);
1285 
1286 	cmd_p->format = cpu_to_le32(format);
1287 	cmd_p->width  = cpu_to_le32(fb->width);
1288 	cmd_p->height = cpu_to_le32(fb->height);
1289 
1290 	for (i = 0; i < 4; i++) {
1291 		cmd_p->strides[i] = cpu_to_le32(fb->pitches[i]);
1292 		cmd_p->offsets[i] = cpu_to_le32(fb->offsets[i]);
1293 	}
1294 
1295 	cmd_p->r.width = cpu_to_le32(width);
1296 	cmd_p->r.height = cpu_to_le32(height);
1297 	cmd_p->r.x = cpu_to_le32(x);
1298 	cmd_p->r.y = cpu_to_le32(y);
1299 
1300 	virtio_gpu_queue_ctrl_buffer(vgdev, vbuf);
1301 }
1302