[mirror_ubuntu-hirsute-kernel.git] / drivers / gpu / drm / udl / udl_gem.c

/*
 * Copyright (C) 2012 Red Hat
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License v2. See the file COPYING in the main directory of this archive for
 * more details.
 */

#include <drm/drmP.h>
#include "udl_drv.h"
#include <linux/shmem_fs.h>
#include <linux/dma-buf.h>

struct udl_gem_object *udl_gem_alloc_object(struct drm_device *dev,
					    size_t size)
{
	struct udl_gem_object *obj;

	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
	if (obj == NULL)
		return NULL;

	if (drm_gem_object_init(dev, &obj->base, size) != 0) {
		kfree(obj);
		return NULL;
	}

	return obj;
}

static int
udl_gem_create(struct drm_file *file,
	       struct drm_device *dev,
	       uint64_t size,
	       uint32_t *handle_p)
{
	struct udl_gem_object *obj;
	int ret;
	u32 handle;

	size = roundup(size, PAGE_SIZE);

	obj = udl_gem_alloc_object(dev, size);
	if (obj == NULL)
		return -ENOMEM;

	ret = drm_gem_handle_create(file, &obj->base, &handle);
	if (ret) {
		drm_gem_object_release(&obj->base);
		kfree(obj);
		return ret;
	}

	drm_gem_object_unreference(&obj->base);
	*handle_p = handle;
	return 0;
}

int udl_dumb_create(struct drm_file *file,
		    struct drm_device *dev,
		    struct drm_mode_create_dumb *args)
{
	args->pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
	args->size = args->pitch * args->height;
	return udl_gem_create(file, dev,
			      args->size, &args->handle);
}

int udl_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
{
	int ret;

	ret = drm_gem_mmap(filp, vma);
	if (ret)
		return ret;

	vma->vm_flags &= ~VM_PFNMAP;
	vma->vm_flags |= VM_MIXEDMAP;

	return ret;
}

int udl_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	struct udl_gem_object *obj = to_udl_bo(vma->vm_private_data);
	struct page *page;
	unsigned int page_offset;
	int ret = 0;

	page_offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >>
		PAGE_SHIFT;

	if (!obj->pages)
		return VM_FAULT_SIGBUS;

	page = obj->pages[page_offset];
	ret = vm_insert_page(vma, (unsigned long)vmf->virtual_address, page);
	switch (ret) {
	case -EAGAIN:
	case 0:
	case -ERESTARTSYS:
		return VM_FAULT_NOPAGE;
	case -ENOMEM:
		return VM_FAULT_OOM;
	default:
		return VM_FAULT_SIGBUS;
	}
}

static int udl_gem_get_pages(struct udl_gem_object *obj, gfp_t gfpmask)
{
	struct page **pages;

	if (obj->pages)
		return 0;

	pages = drm_gem_get_pages(&obj->base, gfpmask);
	if (IS_ERR(pages))
		return PTR_ERR(pages);

	obj->pages = pages;

	return 0;
}

static void udl_gem_put_pages(struct udl_gem_object *obj)
{
	if (obj->base.import_attach) {
		drm_free_large(obj->pages);
		obj->pages = NULL;
		return;
	}

	drm_gem_put_pages(&obj->base, obj->pages, false, false);
	obj->pages = NULL;
}

int udl_gem_vmap(struct udl_gem_object *obj)
{
	int page_count = obj->base.size / PAGE_SIZE;
	int ret;

	if (obj->base.import_attach) {
		obj->vmapping = dma_buf_vmap(obj->base.import_attach->dmabuf);
		if (!obj->vmapping)
			return -ENOMEM;
		return 0;
	}
		
	ret = udl_gem_get_pages(obj, GFP_KERNEL);
	if (ret)
		return ret;

	obj->vmapping = vmap(obj->pages, page_count, 0, PAGE_KERNEL);
	if (!obj->vmapping)
		return -ENOMEM;
	return 0;
}

void udl_gem_vunmap(struct udl_gem_object *obj)
{
	if (obj->base.import_attach) {
		dma_buf_vunmap(obj->base.import_attach->dmabuf, obj->vmapping);
		return;
	}

	if (obj->vmapping)
		vunmap(obj->vmapping);

	udl_gem_put_pages(obj);
}

void udl_gem_free_object(struct drm_gem_object *gem_obj)
{
	struct udl_gem_object *obj = to_udl_bo(gem_obj);

	if (obj->vmapping)
		udl_gem_vunmap(obj);

	if (gem_obj->import_attach) {
		drm_prime_gem_destroy(gem_obj, obj->sg);
		put_device(gem_obj->dev->dev);
	}

	if (obj->pages)
		udl_gem_put_pages(obj);

	drm_gem_free_mmap_offset(gem_obj);
}

/* the dumb interface doesn't work with the GEM straight MMAP
   interface, it expects to do MMAP on the drm fd, like normal */
int udl_gem_mmap(struct drm_file *file, struct drm_device *dev,
		 uint32_t handle, uint64_t *offset)
{
	struct udl_gem_object *gobj;
	struct drm_gem_object *obj;
	int ret = 0;

	mutex_lock(&dev->struct_mutex);
	obj = drm_gem_object_lookup(dev, file, handle);
	if (obj == NULL) {
		ret = -ENOENT;
		goto unlock;
	}
	gobj = to_udl_bo(obj);

	ret = udl_gem_get_pages(gobj, GFP_KERNEL);
	if (ret)
		goto out;
	ret = drm_gem_create_mmap_offset(obj);
	if (ret)
		goto out;

	*offset = drm_vma_node_offset_addr(&gobj->base.vma_node);

out:
	drm_gem_object_unreference(&gobj->base);
unlock:
	mutex_unlock(&dev->struct_mutex);
	return ret;
}

static int udl_prime_create(struct drm_device *dev,
			    size_t size,
			    struct sg_table *sg,
			    struct udl_gem_object **obj_p)
{
	struct udl_gem_object *obj;
	int npages;

	npages = size / PAGE_SIZE;

	*obj_p = NULL;
	obj = udl_gem_alloc_object(dev, npages * PAGE_SIZE);
	if (!obj)
		return -ENOMEM;

	obj->sg = sg;
	obj->pages = drm_malloc_ab(npages, sizeof(struct page *));
	if (obj->pages == NULL) {
		DRM_ERROR("obj pages is NULL %d\n", npages);
		return -ENOMEM;
	}

	drm_prime_sg_to_page_addr_arrays(sg, obj->pages, NULL, npages);

	*obj_p = obj;
	return 0;
}

struct drm_gem_object *udl_gem_prime_import(struct drm_device *dev,
				struct dma_buf *dma_buf)
{
	struct dma_buf_attachment *attach;
	struct sg_table *sg;
	struct udl_gem_object *uobj;
	int ret;

	/* need to attach */
	get_device(dev->dev);
	attach = dma_buf_attach(dma_buf, dev->dev);
	if (IS_ERR(attach)) {
		put_device(dev->dev);
		return ERR_CAST(attach);
	}

	get_dma_buf(dma_buf);

	sg = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
	if (IS_ERR(sg)) {
		ret = PTR_ERR(sg);
		goto fail_detach;
	}

	ret = udl_prime_create(dev, dma_buf->size, sg, &uobj);
	if (ret) {
		goto fail_unmap;
	}

	uobj->base.import_attach = attach;

	return &uobj->base;

fail_unmap:
	dma_buf_unmap_attachment(attach, sg, DMA_BIDIRECTIONAL);
fail_detach:
	dma_buf_detach(dma_buf, attach);
	dma_buf_put(dma_buf);
	put_device(dev->dev);
	return ERR_PTR(ret);
}
Commit	Line	Data
5320918b DA	1	/*
	2	* Copyright (C) 2012 Red Hat
	3	*
	4	* This file is subject to the terms and conditions of the GNU General Public
	5	* License v2. See the file COPYING in the main directory of this archive for
	6	* more details.
	7	*/
	8
760285e7	9	#include <drm/drmP.h>
5320918b DA	10	#include "udl_drv.h"
5320918b DA	11	#include <linux/shmem_fs.h>
96503f59	12	#include <linux/dma-buf.h>
5320918b DA	13
	14	struct udl_gem_object udl_gem_alloc_object(struct drm_device dev,
	15	size_t size)
	16	{
	17	struct udl_gem_object *obj;
	18
	19	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
	20	if (obj == NULL)
	21	return NULL;
	22
	23	if (drm_gem_object_init(dev, &obj->base, size) != 0) {
	24	kfree(obj);
	25	return NULL;
	26	}
	27
	28	return obj;
	29	}
	30
	31	static int
	32	udl_gem_create(struct drm_file *file,
	33	struct drm_device *dev,
	34	uint64_t size,
	35	uint32_t *handle_p)
	36	{
	37	struct udl_gem_object *obj;
	38	int ret;
	39	u32 handle;
	40
	41	size = roundup(size, PAGE_SIZE);
	42
	43	obj = udl_gem_alloc_object(dev, size);
	44	if (obj == NULL)
	45	return -ENOMEM;
	46
	47	ret = drm_gem_handle_create(file, &obj->base, &handle);
	48	if (ret) {
	49	drm_gem_object_release(&obj->base);
	50	kfree(obj);
	51	return ret;
	52	}
	53
	54	drm_gem_object_unreference(&obj->base);
	55	*handle_p = handle;
	56	return 0;
	57	}
	58
	59	int udl_dumb_create(struct drm_file *file,
	60	struct drm_device *dev,
	61	struct drm_mode_create_dumb *args)
	62	{
2b932d8e	63	args->pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
5320918b DA	64	args->size = args->pitch * args->height;
	65	return udl_gem_create(file, dev,
	66	args->size, &args->handle);
	67	}
	68
fa9e8550 KK	69	int udl_drm_gem_mmap(struct file filp, struct vm_area_struct vma)
	70	{
	71	int ret;
	72
	73	ret = drm_gem_mmap(filp, vma);
	74	if (ret)
	75	return ret;
	76
	77	vma->vm_flags &= ~VM_PFNMAP;
	78	vma->vm_flags \|= VM_MIXEDMAP;
	79
	80	return ret;
	81	}
	82
5320918b DA	83	int udl_gem_fault(struct vm_area_struct vma, struct vm_fault vmf)
	84	{
	85	struct udl_gem_object *obj = to_udl_bo(vma->vm_private_data);
	86	struct page *page;
	87	unsigned int page_offset;
	88	int ret = 0;
	89
	90	page_offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >>
	91	PAGE_SHIFT;
	92
	93	if (!obj->pages)
	94	return VM_FAULT_SIGBUS;
	95
	96	page = obj->pages[page_offset];
	97	ret = vm_insert_page(vma, (unsigned long)vmf->virtual_address, page);
	98	switch (ret) {
	99	case -EAGAIN:
5320918b DA	100	case 0:
	101	case -ERESTARTSYS:
	102	return VM_FAULT_NOPAGE;
	103	case -ENOMEM:
	104	return VM_FAULT_OOM;
	105	default:
	106	return VM_FAULT_SIGBUS;
	107	}
	108	}
	109
5320918b DA	110	static int udl_gem_get_pages(struct udl_gem_object *obj, gfp_t gfpmask)
5320918b DA	111	{
5dc9e1e8	112	struct page **pages;
5320918b DA	113
	114	if (obj->pages)
	115	return 0;
	116
5dc9e1e8 RC	117	pages = drm_gem_get_pages(&obj->base, gfpmask);
	118	if (IS_ERR(pages))
	119	return PTR_ERR(pages);
5320918b	120
5dc9e1e8	121	obj->pages = pages;
5320918b DA	122
5320918b DA	123	return 0;
5320918b DA	124	}
	125
	126	static void udl_gem_put_pages(struct udl_gem_object *obj)
	127	{
1d507b3a RC	128	if (obj->base.import_attach) {
	129	drm_free_large(obj->pages);
	130	obj->pages = NULL;
	131	return;
	132	}
	133
5dc9e1e8	134	drm_gem_put_pages(&obj->base, obj->pages, false, false);
5320918b DA	135	obj->pages = NULL;
	136	}
	137
	138	int udl_gem_vmap(struct udl_gem_object *obj)
	139	{
	140	int page_count = obj->base.size / PAGE_SIZE;
	141	int ret;
	142
e8aa1d1e	143	if (obj->base.import_attach) {
e8aa1d1e DA	144	obj->vmapping = dma_buf_vmap(obj->base.import_attach->dmabuf);
	145	if (!obj->vmapping)
	146	return -ENOMEM;
	147	return 0;
	148	}
	149
5320918b DA	150	ret = udl_gem_get_pages(obj, GFP_KERNEL);
	151	if (ret)
	152	return ret;
	153
	154	obj->vmapping = vmap(obj->pages, page_count, 0, PAGE_KERNEL);
	155	if (!obj->vmapping)
	156	return -ENOMEM;
	157	return 0;
	158	}
	159
	160	void udl_gem_vunmap(struct udl_gem_object *obj)
	161	{
e8aa1d1e DA	162	if (obj->base.import_attach) {
e8aa1d1e DA	163	dma_buf_vunmap(obj->base.import_attach->dmabuf, obj->vmapping);
e8aa1d1e DA	164	return;
	165	}
	166
5320918b DA	167	if (obj->vmapping)
	168	vunmap(obj->vmapping);
	169
	170	udl_gem_put_pages(obj);
	171	}
	172
	173	void udl_gem_free_object(struct drm_gem_object *gem_obj)
	174	{
	175	struct udl_gem_object *obj = to_udl_bo(gem_obj);
	176
	177	if (obj->vmapping)
	178	udl_gem_vunmap(obj);
	179
347cf10a	180	if (gem_obj->import_attach) {
e8aa1d1e	181	drm_prime_gem_destroy(gem_obj, obj->sg);
347cf10a DA	182	put_device(gem_obj->dev->dev);
347cf10a DA	183	}
e8aa1d1e	184
5320918b DA	185	if (obj->pages)
	186	udl_gem_put_pages(obj);
	187
0de23977	188	drm_gem_free_mmap_offset(gem_obj);
5320918b DA	189	}
	190
	191	/* the dumb interface doesn't work with the GEM straight MMAP
	192	interface, it expects to do MMAP on the drm fd, like normal */
	193	int udl_gem_mmap(struct drm_file file, struct drm_device dev,
	194	uint32_t handle, uint64_t *offset)
	195	{
	196	struct udl_gem_object *gobj;
	197	struct drm_gem_object *obj;
	198	int ret = 0;
	199
	200	mutex_lock(&dev->struct_mutex);
	201	obj = drm_gem_object_lookup(dev, file, handle);
	202	if (obj == NULL) {
	203	ret = -ENOENT;
	204	goto unlock;
	205	}
	206	gobj = to_udl_bo(obj);
	207
	208	ret = udl_gem_get_pages(gobj, GFP_KERNEL);
	209	if (ret)
ace281e8	210	goto out;
0de23977 DH	211	ret = drm_gem_create_mmap_offset(obj);
	212	if (ret)
	213	goto out;
5320918b	214
0de23977	215	*offset = drm_vma_node_offset_addr(&gobj->base.vma_node);
5320918b DA	216
	217	out:
	218	drm_gem_object_unreference(&gobj->base);
	219	unlock:
	220	mutex_unlock(&dev->struct_mutex);
	221	return ret;
	222	}
96503f59 DA	223
	224	static int udl_prime_create(struct drm_device *dev,
	225	size_t size,
	226	struct sg_table *sg,
	227	struct udl_gem_object **obj_p)
	228	{
	229	struct udl_gem_object *obj;
	230	int npages;
96503f59 DA	231
	232	npages = size / PAGE_SIZE;
	233
	234	*obj_p = NULL;
	235	obj = udl_gem_alloc_object(dev, npages * PAGE_SIZE);
	236	if (!obj)
	237	return -ENOMEM;
	238
	239	obj->sg = sg;
	240	obj->pages = drm_malloc_ab(npages, sizeof(struct page *));
	241	if (obj->pages == NULL) {
	242	DRM_ERROR("obj pages is NULL %d\n", npages);
	243	return -ENOMEM;
	244	}
	245
	246	drm_prime_sg_to_page_addr_arrays(sg, obj->pages, NULL, npages);
	247
	248	*obj_p = obj;
	249	return 0;
	250	}
	251
	252	struct drm_gem_object udl_gem_prime_import(struct drm_device dev,
	253	struct dma_buf *dma_buf)
	254	{
	255	struct dma_buf_attachment *attach;
	256	struct sg_table *sg;
	257	struct udl_gem_object *uobj;
	258	int ret;
	259
	260	/* need to attach */
347cf10a	261	get_device(dev->dev);
96503f59	262	attach = dma_buf_attach(dma_buf, dev->dev);
347cf10a DA	263	if (IS_ERR(attach)) {
347cf10a DA	264	put_device(dev->dev);
959f7247	265	return ERR_CAST(attach);
347cf10a	266	}
96503f59	267
011c2282 ID	268	get_dma_buf(dma_buf);
011c2282 ID	269
96503f59 DA	270	sg = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
	271	if (IS_ERR(sg)) {
	272	ret = PTR_ERR(sg);
	273	goto fail_detach;
	274	}
	275
	276	ret = udl_prime_create(dev, dma_buf->size, sg, &uobj);
	277	if (ret) {
	278	goto fail_unmap;
	279	}
	280
	281	uobj->base.import_attach = attach;
	282
	283	return &uobj->base;
	284
	285	fail_unmap:
	286	dma_buf_unmap_attachment(attach, sg, DMA_BIDIRECTIONAL);
	287	fail_detach:
	288	dma_buf_detach(dma_buf, attach);
011c2282	289	dma_buf_put(dma_buf);
347cf10a	290	put_device(dev->dev);
96503f59 DA	291	return ERR_PTR(ret);
96503f59 DA	292	}