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
 25struct 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
 38static inline struct xen_gem_object *
 39to_xen_gem_obj(struct drm_gem_object *gem_obj)
 40{
 41	return container_of(gem_obj, struct xen_gem_object, base);
 42}
 43
 44static 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
 53static void gem_free_pages_array(struct xen_gem_object *xen_obj)
 54{
 55	kvfree(xen_obj->pages);
 56	xen_obj->pages = NULL;
 57}
 58
 59static 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
 78static 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_OR_NULL(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_OR_NULL(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
128fail:
129	DRM_ERROR("Failed to allocate buffer with size %zu\n", size);
130	return ERR_PTR(ret);
131}
132
133struct 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_OR_NULL(xen_obj))
140		return ERR_CAST(xen_obj);
141
142	return &xen_obj->base;
143}
144
145void 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
168struct 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
175struct 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
185struct drm_gem_object *
186xen_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_OR_NULL(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, xen_obj->pages);
214	if (ret < 0)
215		return ERR_PTR(ret);
216
217	DRM_DEBUG("Imported buffer of size %zu with nents %u\n",
218		  size, sgt->nents);
219
220	return &xen_obj->base;
221}
222
223static int gem_mmap_obj(struct xen_gem_object *xen_obj,
224			struct vm_area_struct *vma)
225{
226	int ret;
227
228	/*
229	 * clear the VM_PFNMAP flag that was set by drm_gem_mmap(), and set the
230	 * vm_pgoff (used as a fake buffer offset by DRM) to 0 as we want to map
231	 * the whole buffer.
232	 */
233	vma->vm_flags &= ~VM_PFNMAP;
234	vma->vm_flags |= VM_MIXEDMAP;
235	vma->vm_pgoff = 0;
236	/*
237	 * According to Xen on ARM ABI (xen/include/public/arch-arm.h):
238	 * all memory which is shared with other entities in the system
239	 * (including the hypervisor and other guests) must reside in memory
240	 * which is mapped as Normal Inner Write-Back Outer Write-Back
241	 * Inner-Shareable.
242	 */
243	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
244
245	/*
246	 * vm_operations_struct.fault handler will be called if CPU access
247	 * to VM is here. For GPUs this isn't the case, because CPU
248	 * doesn't touch the memory. Insert pages now, so both CPU and GPU are
249	 * happy.
250	 * FIXME: as we insert all the pages now then no .fault handler must
251	 * be called, so don't provide one
252	 */
253	ret = vm_map_pages(vma, xen_obj->pages, xen_obj->num_pages);
254	if (ret < 0)
255		DRM_ERROR("Failed to map pages into vma: %d\n", ret);
256
257	return ret;
258}
259
260int xen_drm_front_gem_mmap(struct file *filp, struct vm_area_struct *vma)
261{
262	struct xen_gem_object *xen_obj;
263	struct drm_gem_object *gem_obj;
264	int ret;
265
266	ret = drm_gem_mmap(filp, vma);
267	if (ret < 0)
268		return ret;
269
270	gem_obj = vma->vm_private_data;
271	xen_obj = to_xen_gem_obj(gem_obj);
272	return gem_mmap_obj(xen_obj, vma);
273}
274
275void *xen_drm_front_gem_prime_vmap(struct drm_gem_object *gem_obj)
276{
277	struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj);
278
279	if (!xen_obj->pages)
280		return NULL;
281
282	/* Please see comment in gem_mmap_obj on mapping and attributes. */
283	return vmap(xen_obj->pages, xen_obj->num_pages,
284		    VM_MAP, PAGE_KERNEL);
285}
286
287void xen_drm_front_gem_prime_vunmap(struct drm_gem_object *gem_obj,
288				    void *vaddr)
289{
290	vunmap(vaddr);
291}
292
293int xen_drm_front_gem_prime_mmap(struct drm_gem_object *gem_obj,
294				 struct vm_area_struct *vma)
295{
296	struct xen_gem_object *xen_obj;
297	int ret;
298
299	ret = drm_gem_mmap_obj(gem_obj, gem_obj->size, vma);
300	if (ret < 0)
301		return ret;
302
303	xen_obj = to_xen_gem_obj(gem_obj);
304	return gem_mmap_obj(xen_obj, vma);
305}