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#include <xen/xen.h>
 22
 23#include "xen_drm_front.h"
 24#include "xen_drm_front_gem.h"
 25
 26struct 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
 39static inline struct xen_gem_object *
 40to_xen_gem_obj(struct drm_gem_object *gem_obj)
 41{
 42	return container_of(gem_obj, struct xen_gem_object, base);
 43}
 44
 45static 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
 54static void gem_free_pages_array(struct xen_gem_object *xen_obj)
 55{
 56	kvfree(xen_obj->pages);
 57	xen_obj->pages = NULL;
 58}
 59
 60static 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
 79static 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(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 = xen_alloc_unpopulated_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(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
129fail:
130	DRM_ERROR("Failed to allocate buffer with size %zu\n", size);
131	return ERR_PTR(ret);
132}
133
134struct 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(xen_obj))
141		return ERR_CAST(xen_obj);
142
143	return &xen_obj->base;
144}
145
146void 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				xen_free_unpopulated_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
169struct 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
176struct 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
186struct drm_gem_object *
187xen_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(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, sgt->sgl->offset,
215					xen_obj->pages);
216	if (ret < 0)
217		return ERR_PTR(ret);
218
219	DRM_DEBUG("Imported buffer of size %zu with nents %u\n",
220		  size, sgt->nents);
221
222	return &xen_obj->base;
223}
224
225static int gem_mmap_obj(struct xen_gem_object *xen_obj,
226			struct vm_area_struct *vma)
227{
228	int ret;
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	ret = vm_map_pages(vma, xen_obj->pages, xen_obj->num_pages);
256	if (ret < 0)
257		DRM_ERROR("Failed to map pages into vma: %d\n", ret);
258
259	return ret;
260}
261
262int xen_drm_front_gem_mmap(struct file *filp, struct vm_area_struct *vma)
263{
264	struct xen_gem_object *xen_obj;
265	struct drm_gem_object *gem_obj;
266	int ret;
267
268	ret = drm_gem_mmap(filp, vma);
269	if (ret < 0)
270		return ret;
271
272	gem_obj = vma->vm_private_data;
273	xen_obj = to_xen_gem_obj(gem_obj);
274	return gem_mmap_obj(xen_obj, vma);
275}
276
277void *xen_drm_front_gem_prime_vmap(struct drm_gem_object *gem_obj)
278{
279	struct xen_gem_object *xen_obj = to_xen_gem_obj(gem_obj);
280
281	if (!xen_obj->pages)
282		return NULL;
283
284	/* Please see comment in gem_mmap_obj on mapping and attributes. */
285	return vmap(xen_obj->pages, xen_obj->num_pages,
286		    VM_MAP, PAGE_KERNEL);
287}
288
289void xen_drm_front_gem_prime_vunmap(struct drm_gem_object *gem_obj,
290				    void *vaddr)
291{
292	vunmap(vaddr);
293}
294
295int xen_drm_front_gem_prime_mmap(struct drm_gem_object *gem_obj,
296				 struct vm_area_struct *vma)
297{
298	struct xen_gem_object *xen_obj;
299	int ret;
300
301	ret = drm_gem_mmap_obj(gem_obj, gem_obj->size, vma);
302	if (ret < 0)
303		return ret;
304
305	xen_obj = to_xen_gem_obj(gem_obj);
306	return gem_mmap_obj(xen_obj, vma);
307}