1/*
2 * Copyright 2014 Canonical
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * Authors: Andreas Pokorny
23 */
24
25#include <drm/drm_prime.h>
26#include <linux/virtio_dma_buf.h>
27
28#include "virtgpu_drv.h"
29
30MODULE_IMPORT_NS("DMA_BUF");
31
32static int virtgpu_virtio_get_uuid(struct dma_buf *buf,
33 uuid_t *uuid)
34{
35 struct drm_gem_object *obj = buf->priv;
36 struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);
37 struct virtio_gpu_device *vgdev = obj->dev->dev_private;
38
39 wait_event(vgdev->resp_wq, bo->uuid_state != STATE_INITIALIZING);
40 if (bo->uuid_state != STATE_OK)
41 return -ENODEV;
42
43 uuid_copy(dst: uuid, src: &bo->uuid);
44
45 return 0;
46}
47
48static struct sg_table *
49virtgpu_gem_map_dma_buf(struct dma_buf_attachment *attach,
50 enum dma_data_direction dir)
51{
52 struct drm_gem_object *obj = attach->dmabuf->priv;
53 struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);
54
55 if (virtio_gpu_is_vram(bo))
56 return virtio_gpu_vram_map_dma_buf(bo, dev: attach->dev, dir);
57
58 return drm_gem_map_dma_buf(attach, dir);
59}
60
61static void virtgpu_gem_unmap_dma_buf(struct dma_buf_attachment *attach,
62 struct sg_table *sgt,
63 enum dma_data_direction dir)
64{
65 struct drm_gem_object *obj = attach->dmabuf->priv;
66 struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);
67
68 if (virtio_gpu_is_vram(bo)) {
69 virtio_gpu_vram_unmap_dma_buf(dev: attach->dev, sgt, dir);
70 return;
71 }
72
73 drm_gem_unmap_dma_buf(attach, sgt, dir);
74}
75
76static const struct virtio_dma_buf_ops virtgpu_dmabuf_ops = {
77 .ops = {
78 .attach = virtio_dma_buf_attach,
79 .detach = drm_gem_map_detach,
80 .map_dma_buf = virtgpu_gem_map_dma_buf,
81 .unmap_dma_buf = virtgpu_gem_unmap_dma_buf,
82 .release = drm_gem_dmabuf_release,
83 .mmap = drm_gem_dmabuf_mmap,
84 .vmap = drm_gem_dmabuf_vmap,
85 .vunmap = drm_gem_dmabuf_vunmap,
86 },
87 .device_attach = drm_gem_map_attach,
88 .get_uuid = virtgpu_virtio_get_uuid,
89};
90
91int virtio_gpu_resource_assign_uuid(struct virtio_gpu_device *vgdev,
92 struct virtio_gpu_object *bo)
93{
94 struct virtio_gpu_object_array *objs;
95
96 objs = virtio_gpu_array_alloc(nents: 1);
97 if (!objs)
98 return -ENOMEM;
99
100 virtio_gpu_array_add_obj(objs, obj: &bo->base.base);
101
102 return virtio_gpu_cmd_resource_assign_uuid(vgdev, objs);
103}
104
105struct dma_buf *virtgpu_gem_prime_export(struct drm_gem_object *obj,
106 int flags)
107{
108 struct dma_buf *buf;
109 struct drm_device *dev = obj->dev;
110 struct virtio_gpu_device *vgdev = dev->dev_private;
111 struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);
112 int ret = 0;
113 bool blob = bo->host3d_blob || bo->guest_blob;
114 DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
115
116 if (!blob) {
117 if (vgdev->has_resource_assign_uuid) {
118 ret = virtio_gpu_resource_assign_uuid(vgdev, bo);
119 if (ret)
120 return ERR_PTR(error: ret);
121
122 virtio_gpu_notify(vgdev);
123 } else {
124 bo->uuid_state = STATE_ERR;
125 }
126 } else if (!(bo->blob_flags & VIRTGPU_BLOB_FLAG_USE_CROSS_DEVICE)) {
127 bo->uuid_state = STATE_ERR;
128 }
129
130 exp_info.ops = &virtgpu_dmabuf_ops.ops;
131 exp_info.size = obj->size;
132 exp_info.flags = flags;
133 exp_info.priv = obj;
134 exp_info.resv = obj->resv;
135
136 buf = virtio_dma_buf_export(exp_info: &exp_info);
137 if (IS_ERR(ptr: buf))
138 return buf;
139
140 drm_dev_get(dev);
141 drm_gem_object_get(obj);
142
143 return buf;
144}
145
146int virtgpu_dma_buf_import_sgt(struct virtio_gpu_mem_entry **ents,
147 unsigned int *nents,
148 struct virtio_gpu_object *bo,
149 struct dma_buf_attachment *attach)
150{
151 struct scatterlist *sl;
152 struct sg_table *sgt;
153 long i, ret;
154
155 dma_resv_assert_held(attach->dmabuf->resv);
156
157 ret = dma_resv_wait_timeout(obj: attach->dmabuf->resv,
158 usage: DMA_RESV_USAGE_KERNEL,
159 intr: false, MAX_SCHEDULE_TIMEOUT);
160 if (ret <= 0)
161 return ret < 0 ? ret : -ETIMEDOUT;
162
163 sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
164 if (IS_ERR(ptr: sgt))
165 return PTR_ERR(ptr: sgt);
166
167 *ents = kvmalloc_array(sgt->nents,
168 sizeof(struct virtio_gpu_mem_entry),
169 GFP_KERNEL);
170 if (!(*ents)) {
171 dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
172 return -ENOMEM;
173 }
174
175 *nents = sgt->nents;
176 for_each_sgtable_dma_sg(sgt, sl, i) {
177 (*ents)[i].addr = cpu_to_le64(sg_dma_address(sl));
178 (*ents)[i].length = cpu_to_le32(sg_dma_len(sl));
179 (*ents)[i].padding = 0;
180 }
181
182 bo->sgt = sgt;
183 return 0;
184}
185
186static void virtgpu_dma_buf_unmap(struct virtio_gpu_object *bo)
187{
188 struct dma_buf_attachment *attach = bo->base.base.import_attach;
189
190 dma_resv_assert_held(attach->dmabuf->resv);
191
192 if (bo->created) {
193 virtio_gpu_detach_object_fenced(bo);
194
195 if (bo->sgt)
196 dma_buf_unmap_attachment(attach, bo->sgt,
197 DMA_BIDIRECTIONAL);
198
199 bo->sgt = NULL;
200 }
201}
202
203static void virtgpu_dma_buf_free_obj(struct drm_gem_object *obj)
204{
205 struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);
206 struct virtio_gpu_device *vgdev = obj->dev->dev_private;
207 struct dma_buf_attachment *attach = obj->import_attach;
208
209 if (drm_gem_is_imported(obj)) {
210 struct dma_buf *dmabuf = attach->dmabuf;
211
212 dma_resv_lock(obj: dmabuf->resv, NULL);
213 virtgpu_dma_buf_unmap(bo);
214 dma_resv_unlock(obj: dmabuf->resv);
215
216 dma_buf_detach(dmabuf, attach);
217 dma_buf_put(dmabuf);
218 }
219
220 if (bo->created) {
221 virtio_gpu_cmd_unref_resource(vgdev, bo);
222 virtio_gpu_notify(vgdev);
223 return;
224 }
225 virtio_gpu_cleanup_object(bo);
226}
227
228static int virtgpu_dma_buf_init_obj(struct drm_device *dev,
229 struct virtio_gpu_object *bo,
230 struct dma_buf_attachment *attach)
231{
232 struct virtio_gpu_device *vgdev = dev->dev_private;
233 struct virtio_gpu_object_params params = { 0 };
234 struct dma_resv *resv = attach->dmabuf->resv;
235 struct virtio_gpu_mem_entry *ents = NULL;
236 unsigned int nents;
237 int ret;
238
239 ret = virtio_gpu_resource_id_get(vgdev, resid: &bo->hw_res_handle);
240 if (ret) {
241 virtgpu_dma_buf_free_obj(obj: &bo->base.base);
242 return ret;
243 }
244
245 dma_resv_lock(obj: resv, NULL);
246
247 ret = dma_buf_pin(attach);
248 if (ret)
249 goto err_pin;
250
251 ret = virtgpu_dma_buf_import_sgt(ents: &ents, nents: &nents, bo, attach);
252 if (ret)
253 goto err_import;
254
255 params.blob = true;
256 params.blob_mem = VIRTGPU_BLOB_MEM_GUEST;
257 params.blob_flags = VIRTGPU_BLOB_FLAG_USE_SHAREABLE;
258 params.size = attach->dmabuf->size;
259
260 virtio_gpu_cmd_resource_create_blob(vgdev, bo, params: &params,
261 ents, nents);
262 bo->guest_blob = true;
263
264 dma_buf_unpin(attach);
265 dma_resv_unlock(obj: resv);
266
267 return 0;
268
269err_import:
270 dma_buf_unpin(attach);
271err_pin:
272 dma_resv_unlock(obj: resv);
273 virtgpu_dma_buf_free_obj(obj: &bo->base.base);
274 return ret;
275}
276
277static const struct drm_gem_object_funcs virtgpu_gem_dma_buf_funcs = {
278 .free = virtgpu_dma_buf_free_obj,
279};
280
281static void virtgpu_dma_buf_move_notify(struct dma_buf_attachment *attach)
282{
283 struct drm_gem_object *obj = attach->importer_priv;
284 struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);
285
286 virtgpu_dma_buf_unmap(bo);
287}
288
289static const struct dma_buf_attach_ops virtgpu_dma_buf_attach_ops = {
290 .allow_peer2peer = true,
291 .move_notify = virtgpu_dma_buf_move_notify
292};
293
294struct drm_gem_object *virtgpu_gem_prime_import(struct drm_device *dev,
295 struct dma_buf *buf)
296{
297 struct virtio_gpu_device *vgdev = dev->dev_private;
298 struct dma_buf_attachment *attach;
299 struct virtio_gpu_object *bo;
300 struct drm_gem_object *obj;
301 int ret;
302
303 if (buf->ops == &virtgpu_dmabuf_ops.ops) {
304 obj = buf->priv;
305 if (obj->dev == dev) {
306 /*
307 * Importing dmabuf exported from our own gem increases
308 * refcount on gem itself instead of f_count of dmabuf.
309 */
310 drm_gem_object_get(obj);
311 return obj;
312 }
313 }
314
315 if (!vgdev->has_resource_blob || vgdev->has_virgl_3d)
316 return drm_gem_prime_import(dev, dma_buf: buf);
317
318 bo = kzalloc(sizeof(*bo), GFP_KERNEL);
319 if (!bo)
320 return ERR_PTR(error: -ENOMEM);
321
322 obj = &bo->base.base;
323 obj->resv = buf->resv;
324 obj->funcs = &virtgpu_gem_dma_buf_funcs;
325 drm_gem_private_object_init(dev, obj, size: buf->size);
326
327 attach = dma_buf_dynamic_attach(dmabuf: buf, dev: dev->dev,
328 importer_ops: &virtgpu_dma_buf_attach_ops, importer_priv: obj);
329 if (IS_ERR(ptr: attach)) {
330 kfree(objp: bo);
331 return ERR_CAST(ptr: attach);
332 }
333
334 obj->import_attach = attach;
335 get_dma_buf(dmabuf: buf);
336
337 ret = virtgpu_dma_buf_init_obj(dev, bo, attach);
338 if (ret < 0)
339 return ERR_PTR(error: ret);
340
341 return obj;
342}
343
344struct drm_gem_object *virtgpu_gem_prime_import_sg_table(
345 struct drm_device *dev, struct dma_buf_attachment *attach,
346 struct sg_table *table)
347{
348 return ERR_PTR(error: -ENODEV);
349}
350

source code of linux/drivers/gpu/drm/virtio/virtgpu_prime.c