1 // SPDX-License-Identifier: GPL-2.0 OR MIT
2 
3 /*
4  *  Xen para-virtual DRM device
5  *
6  * Copyright (C) 2016-2018 EPAM Systems Inc.
7  *
8  * Author: Oleksandr Andrushchenko <oleksandr_andrushchenko@epam.com>
9  */
10 
11 #include <linux/dma-buf.h>
12 #include <linux/scatterlist.h>
13 #include <linux/shmem_fs.h>
14 
15 #include <drm/drm_fb_helper.h>
16 #include <drm/drm_gem.h>
17 #include <drm/drm_prime.h>
18 #include <drm/drm_probe_helper.h>
19 
20 #include <xen/balloon.h>
21 
22 #include "xen_drm_front.h"
23 #include "xen_drm_front_gem.h"
24 
25 struct xen_gem_object {
26 	struct drm_gem_object base;
27 
28 	size_t num_pages;
29 	struct page **pages;
30 
31 	/* set for buffers allocated by the backend */
32 	bool be_alloc;
33 
34 	/* this is for imported PRIME buffer */
35 	struct sg_table *sgt_imported;
36 };
37 
38 static inline struct xen_gem_object *
39 to_xen_gem_obj(struct drm_gem_object *gem_obj)
40 {
41 	return container_of(gem_obj, struct xen_gem_object, base);
42 }
43 
44 static int gem_alloc_pages_array(struct xen_gem_object *xen_obj,
45 				 size_t buf_size)
46 {
47 	xen_obj->num_pages = DIV_ROUND_UP(buf_size, PAGE_SIZE);
48 	xen_obj->pages = kvmalloc_array(xen_obj->num_pages,
49 					sizeof(struct page *), GFP_KERNEL);
50 	return !xen_obj->pages ? -ENOMEM : 0;
51 }
52 
53 static void gem_free_pages_array(struct xen_gem_object *xen_obj)
54 {
55 	kvfree(xen_obj->pages);
56 	xen_obj->pages = NULL;
57 }
58 
59 static struct xen_gem_object *gem_create_obj(struct drm_device *dev,
60 					     size_t size)
61 {
62 	struct xen_gem_object *xen_obj;
63 	int ret;
64 
65 	xen_obj = kzalloc(sizeof(*xen_obj), GFP_KERNEL);
66 	if (!xen_obj)
67 		return ERR_PTR(-ENOMEM);
68 
69 	ret = drm_gem_object_init(dev, &xen_obj->base, size);
70 	if (ret < 0) {
71 		kfree(xen_obj);
72 		return ERR_PTR(ret);
73 	}
74 
75 	return xen_obj;
76 }
77 
78 static struct xen_gem_object *gem_create(struct drm_device *dev, size_t size)
79 {
80 	struct xen_drm_front_drm_info *drm_info = dev->dev_private;
81 	struct xen_gem_object *xen_obj;
82 	int ret;
83 
84 	size = round_up(size, PAGE_SIZE);
85 	xen_obj = gem_create_obj(dev, size);
86 	if (IS_ERR(xen_obj))
87 		return xen_obj;
88 
89 	if (drm_info->front_info->cfg.be_alloc) {
90 		/*
91 		 * backend will allocate space for this buffer, so
92 		 * only allocate array of pointers to pages
93 		 */
94 		ret = gem_alloc_pages_array(xen_obj, size);
95 		if (ret < 0)
96 			goto fail;
97 
98 		/*
99 		 * allocate ballooned pages which will be used to map
100 		 * grant references provided by the backend
101 		 */
102 		ret = alloc_xenballooned_pages(xen_obj->num_pages,
103 					       xen_obj->pages);
104 		if (ret < 0) {
105 			DRM_ERROR("Cannot allocate %zu ballooned pages: %d\n",
106 				  xen_obj->num_pages, ret);
107 			gem_free_pages_array(xen_obj);
108 			goto fail;
109 		}
110 
111 		xen_obj->be_alloc = true;
112 		return xen_obj;
113 	}
114 	/*
115 	 * need to allocate backing pages now, so we can share those
116 	 * with the backend
117 	 */
118 	xen_obj->num_pages = DIV_ROUND_UP(size, PAGE_SIZE);
119 	xen_obj->pages = drm_gem_get_pages(&xen_obj->base);
120 	if (IS_ERR(xen_obj->pages)) {
121 		ret = PTR_ERR(xen_obj->pages);
122 		xen_obj->pages = NULL;
123 		goto fail;
124 	}
125 
126 	return xen_obj;
127 
128 fail:
129 	DRM_ERROR("Failed to allocate buffer with size %zu\n", size);
130 	return ERR_PTR(ret);
131 }
132 
133 struct drm_gem_object *xen_drm_front_gem_create(struct drm_device *dev,
134 						size_t size)
135 {
136 	struct xen_gem_object *xen_obj;
137 
138 	xen_obj = gem_create(dev, size);
139 	if (IS_ERR(xen_obj))
140 		return ERR_CAST(xen_obj);
141 
142 	return &xen_obj->base;
143 }
144 
145 void xen_drm_front_gem_free_object_unlocked(struct drm_gem_object *gem_obj)
146 {
147 	struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj);
148 
149 	if (xen_obj->base.import_attach) {
150 		drm_prime_gem_destroy(&xen_obj->base, xen_obj->sgt_imported);
151 		gem_free_pages_array(xen_obj);
152 	} else {
153 		if (xen_obj->pages) {
154 			if (xen_obj->be_alloc) {
155 				free_xenballooned_pages(xen_obj->num_pages,
156 							xen_obj->pages);
157 				gem_free_pages_array(xen_obj);
158 			} else {
159 				drm_gem_put_pages(&xen_obj->base,
160 						  xen_obj->pages, true, false);
161 			}
162 		}
163 	}
164 	drm_gem_object_release(gem_obj);
165 	kfree(xen_obj);
166 }
167 
168 struct page **xen_drm_front_gem_get_pages(struct drm_gem_object *gem_obj)
169 {
170 	struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj);
171 
172 	return xen_obj->pages;
173 }
174 
175 struct sg_table *xen_drm_front_gem_get_sg_table(struct drm_gem_object *gem_obj)
176 {
177 	struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj);
178 
179 	if (!xen_obj->pages)
180 		return ERR_PTR(-ENOMEM);
181 
182 	return drm_prime_pages_to_sg(xen_obj->pages, xen_obj->num_pages);
183 }
184 
185 struct drm_gem_object *
186 xen_drm_front_gem_import_sg_table(struct drm_device *dev,
187 				  struct dma_buf_attachment *attach,
188 				  struct sg_table *sgt)
189 {
190 	struct xen_drm_front_drm_info *drm_info = dev->dev_private;
191 	struct xen_gem_object *xen_obj;
192 	size_t size;
193 	int ret;
194 
195 	size = attach->dmabuf->size;
196 	xen_obj = gem_create_obj(dev, size);
197 	if (IS_ERR(xen_obj))
198 		return ERR_CAST(xen_obj);
199 
200 	ret = gem_alloc_pages_array(xen_obj, size);
201 	if (ret < 0)
202 		return ERR_PTR(ret);
203 
204 	xen_obj->sgt_imported = sgt;
205 
206 	ret = drm_prime_sg_to_page_addr_arrays(sgt, xen_obj->pages,
207 					       NULL, xen_obj->num_pages);
208 	if (ret < 0)
209 		return ERR_PTR(ret);
210 
211 	ret = xen_drm_front_dbuf_create(drm_info->front_info,
212 					xen_drm_front_dbuf_to_cookie(&xen_obj->base),
213 					0, 0, 0, size, sgt->sgl->offset,
214 					xen_obj->pages);
215 	if (ret < 0)
216 		return ERR_PTR(ret);
217 
218 	DRM_DEBUG("Imported buffer of size %zu with nents %u\n",
219 		  size, sgt->nents);
220 
221 	return &xen_obj->base;
222 }
223 
224 static int gem_mmap_obj(struct xen_gem_object *xen_obj,
225 			struct vm_area_struct *vma)
226 {
227 	int ret;
228 
229 	/*
230 	 * clear the VM_PFNMAP flag that was set by drm_gem_mmap(), and set the
231 	 * vm_pgoff (used as a fake buffer offset by DRM) to 0 as we want to map
232 	 * the whole buffer.
233 	 */
234 	vma->vm_flags &= ~VM_PFNMAP;
235 	vma->vm_flags |= VM_MIXEDMAP;
236 	vma->vm_pgoff = 0;
237 	/*
238 	 * According to Xen on ARM ABI (xen/include/public/arch-arm.h):
239 	 * all memory which is shared with other entities in the system
240 	 * (including the hypervisor and other guests) must reside in memory
241 	 * which is mapped as Normal Inner Write-Back Outer Write-Back
242 	 * Inner-Shareable.
243 	 */
244 	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
245 
246 	/*
247 	 * vm_operations_struct.fault handler will be called if CPU access
248 	 * to VM is here. For GPUs this isn't the case, because CPU
249 	 * doesn't touch the memory. Insert pages now, so both CPU and GPU are
250 	 * happy.
251 	 * FIXME: as we insert all the pages now then no .fault handler must
252 	 * be called, so don't provide one
253 	 */
254 	ret = vm_map_pages(vma, xen_obj->pages, xen_obj->num_pages);
255 	if (ret < 0)
256 		DRM_ERROR("Failed to map pages into vma: %d\n", ret);
257 
258 	return ret;
259 }
260 
261 int xen_drm_front_gem_mmap(struct file *filp, struct vm_area_struct *vma)
262 {
263 	struct xen_gem_object *xen_obj;
264 	struct drm_gem_object *gem_obj;
265 	int ret;
266 
267 	ret = drm_gem_mmap(filp, vma);
268 	if (ret < 0)
269 		return ret;
270 
271 	gem_obj = vma->vm_private_data;
272 	xen_obj = to_xen_gem_obj(gem_obj);
273 	return gem_mmap_obj(xen_obj, vma);
274 }
275 
276 void *xen_drm_front_gem_prime_vmap(struct drm_gem_object *gem_obj)
277 {
278 	struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj);
279 
280 	if (!xen_obj->pages)
281 		return NULL;
282 
283 	/* Please see comment in gem_mmap_obj on mapping and attributes. */
284 	return vmap(xen_obj->pages, xen_obj->num_pages,
285 		    VM_MAP, PAGE_KERNEL);
286 }
287 
288 void xen_drm_front_gem_prime_vunmap(struct drm_gem_object *gem_obj,
289 				    void *vaddr)
290 {
291 	vunmap(vaddr);
292 }
293 
294 int xen_drm_front_gem_prime_mmap(struct drm_gem_object *gem_obj,
295 				 struct vm_area_struct *vma)
296 {
297 	struct xen_gem_object *xen_obj;
298 	int ret;
299 
300 	ret = drm_gem_mmap_obj(gem_obj, gem_obj->size, vma);
301 	if (ret < 0)
302 		return ret;
303 
304 	xen_obj = to_xen_gem_obj(gem_obj);
305 	return gem_mmap_obj(xen_obj, vma);
306 }
307