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