1 /* $NetBSD: virtgpu_fence.c,v 1.3 2021/12/18 23:45:45 riastradh Exp $ */
2
3 /*
4 * Copyright (C) 2015 Red Hat, Inc.
5 * All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining
8 * a 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, sublicense, 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
17 * portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
22 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
23 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
24 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
25 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 */
27
28 #include <sys/cdefs.h>
29 __KERNEL_RCSID(0, "$NetBSD: virtgpu_fence.c,v 1.3 2021/12/18 23:45:45 riastradh Exp $");
30
31 #include <trace/events/dma_fence.h>
32
33 #include "virtgpu_drv.h"
34
35 #define to_virtio_fence(x) \
36 container_of(x, struct virtio_gpu_fence, f)
37
virtio_get_driver_name(struct dma_fence * f)38 static const char *virtio_get_driver_name(struct dma_fence *f)
39 {
40 return "virtio_gpu";
41 }
42
virtio_get_timeline_name(struct dma_fence * f)43 static const char *virtio_get_timeline_name(struct dma_fence *f)
44 {
45 return "controlq";
46 }
47
virtio_fence_signaled(struct dma_fence * f)48 static bool virtio_fence_signaled(struct dma_fence *f)
49 {
50 struct virtio_gpu_fence *fence = to_virtio_fence(f);
51
52 if (WARN_ON_ONCE(fence->f.seqno == 0))
53 /* leaked fence outside driver before completing
54 * initialization with virtio_gpu_fence_emit */
55 return false;
56 if (atomic64_read(&fence->drv->last_seq) >= fence->f.seqno)
57 return true;
58 return false;
59 }
60
virtio_fence_value_str(struct dma_fence * f,char * str,int size)61 static void virtio_fence_value_str(struct dma_fence *f, char *str, int size)
62 {
63 snprintf(str, size, "%llu", f->seqno);
64 }
65
virtio_timeline_value_str(struct dma_fence * f,char * str,int size)66 static void virtio_timeline_value_str(struct dma_fence *f, char *str, int size)
67 {
68 struct virtio_gpu_fence *fence = to_virtio_fence(f);
69
70 snprintf(str, size, "%llu", (u64)atomic64_read(&fence->drv->last_seq));
71 }
72
73 static const struct dma_fence_ops virtio_fence_ops = {
74 .get_driver_name = virtio_get_driver_name,
75 .get_timeline_name = virtio_get_timeline_name,
76 .signaled = virtio_fence_signaled,
77 .fence_value_str = virtio_fence_value_str,
78 .timeline_value_str = virtio_timeline_value_str,
79 };
80
virtio_gpu_fence_alloc(struct virtio_gpu_device * vgdev)81 struct virtio_gpu_fence *virtio_gpu_fence_alloc(struct virtio_gpu_device *vgdev)
82 {
83 struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv;
84 struct virtio_gpu_fence *fence = kzalloc(sizeof(struct virtio_gpu_fence),
85 GFP_KERNEL);
86 if (!fence)
87 return fence;
88
89 fence->drv = drv;
90
91 /* This only partially initializes the fence because the seqno is
92 * unknown yet. The fence must not be used outside of the driver
93 * until virtio_gpu_fence_emit is called.
94 */
95 dma_fence_init(&fence->f, &virtio_fence_ops, &drv->lock, drv->context, 0);
96
97 return fence;
98 }
99
virtio_gpu_fence_emit(struct virtio_gpu_device * vgdev,struct virtio_gpu_ctrl_hdr * cmd_hdr,struct virtio_gpu_fence * fence)100 void virtio_gpu_fence_emit(struct virtio_gpu_device *vgdev,
101 struct virtio_gpu_ctrl_hdr *cmd_hdr,
102 struct virtio_gpu_fence *fence)
103 {
104 struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv;
105 unsigned long irq_flags;
106
107 spin_lock_irqsave(&drv->lock, irq_flags);
108 fence->f.seqno = ++drv->sync_seq;
109 dma_fence_get(&fence->f);
110 list_add_tail(&fence->node, &drv->fences);
111 spin_unlock_irqrestore(&drv->lock, irq_flags);
112
113 trace_dma_fence_emit(&fence->f);
114
115 cmd_hdr->flags |= cpu_to_le32(VIRTIO_GPU_FLAG_FENCE);
116 cmd_hdr->fence_id = cpu_to_le64(fence->f.seqno);
117 }
118
virtio_gpu_fence_event_process(struct virtio_gpu_device * vgdev,u64 last_seq)119 void virtio_gpu_fence_event_process(struct virtio_gpu_device *vgdev,
120 u64 last_seq)
121 {
122 struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv;
123 struct virtio_gpu_fence *fence, *tmp;
124 unsigned long irq_flags;
125
126 spin_lock_irqsave(&drv->lock, irq_flags);
127 atomic64_set(&vgdev->fence_drv.last_seq, last_seq);
128 list_for_each_entry_safe(fence, tmp, &drv->fences, node) {
129 if (last_seq < fence->f.seqno)
130 continue;
131 dma_fence_signal_locked(&fence->f);
132 list_del(&fence->node);
133 dma_fence_put(&fence->f);
134 }
135 spin_unlock_irqrestore(&drv->lock, irq_flags);
136 }
137