[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;
	}

	obj->flags = UDL_BO_CACHEABLE;
	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_unlocked(&obj->base);
	*handle_p = handle;
	return 0;
}

static void update_vm_cache_attr(struct udl_gem_object *obj,
				 struct vm_area_struct *vma)
{
	DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);

	/* non-cacheable as default. */
	if (obj->flags & UDL_BO_CACHEABLE) {
		vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
	} else if (obj->flags & UDL_BO_WC) {
		vma->vm_page_prot =
			pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
	} else {
		vma->vm_page_prot =
			pgprot_noncached(vm_get_page_prot(vma->vm_flags));
	}
}

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;

	update_vm_cache_attr(to_udl_bo(vma->vm_private_data), vma);

	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 = (vmf->address - vma->vm_start) >> PAGE_SHIFT;

	if (!obj->pages)
		return VM_FAULT_SIGBUS;

	page = obj->pages[page_offset];
	ret = vm_insert_page(vma, vmf->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;
	}
}

int udl_gem_get_pages(struct udl_gem_object *obj)
{
	struct page **pages;

	if (obj->pages)
		return 0;

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

	obj->pages = pages;

	return 0;
}

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);
	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;
	}

	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(file, handle);
	if (obj == NULL) {
		ret = -ENOENT;
		goto unlock;
	}
	gobj = to_udl_bo(obj);

	ret = udl_gem_get_pages(gobj);
	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;
}
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
09a58da0	28	obj->flags = UDL_BO_CACHEABLE;
5320918b DA	29	return obj;
	30	}
	31
	32	static int
	33	udl_gem_create(struct drm_file *file,
	34	struct drm_device *dev,
	35	uint64_t size,
	36	uint32_t *handle_p)
	37	{
	38	struct udl_gem_object *obj;
	39	int ret;
	40	u32 handle;
	41
	42	size = roundup(size, PAGE_SIZE);
	43
	44	obj = udl_gem_alloc_object(dev, size);
	45	if (obj == NULL)
	46	return -ENOMEM;
	47
	48	ret = drm_gem_handle_create(file, &obj->base, &handle);
	49	if (ret) {
	50	drm_gem_object_release(&obj->base);
	51	kfree(obj);
	52	return ret;
	53	}
	54
72b9ff06	55	drm_gem_object_unreference_unlocked(&obj->base);
5320918b DA	56	*handle_p = handle;
	57	return 0;
	58	}
	59
09a58da0 HS	60	static void update_vm_cache_attr(struct udl_gem_object *obj,
	61	struct vm_area_struct *vma)
	62	{
	63	DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);
	64
	65	/* non-cacheable as default. */
	66	if (obj->flags & UDL_BO_CACHEABLE) {
	67	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
	68	} else if (obj->flags & UDL_BO_WC) {
	69	vma->vm_page_prot =
	70	pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
	71	} else {
	72	vma->vm_page_prot =
	73	pgprot_noncached(vm_get_page_prot(vma->vm_flags));
	74	}
	75	}
	76
5320918b DA	77	int udl_dumb_create(struct drm_file *file,
	78	struct drm_device *dev,
	79	struct drm_mode_create_dumb *args)
	80	{
2b932d8e	81	args->pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
5320918b DA	82	args->size = args->pitch * args->height;
	83	return udl_gem_create(file, dev,
	84	args->size, &args->handle);
	85	}
	86
fa9e8550 KK	87	int udl_drm_gem_mmap(struct file filp, struct vm_area_struct vma)
	88	{
	89	int ret;
	90
	91	ret = drm_gem_mmap(filp, vma);
	92	if (ret)
	93	return ret;
	94
	95	vma->vm_flags &= ~VM_PFNMAP;
	96	vma->vm_flags \|= VM_MIXEDMAP;
	97
09a58da0 HS	98	update_vm_cache_attr(to_udl_bo(vma->vm_private_data), vma);
09a58da0 HS	99
fa9e8550 KK	100	return ret;
	101	}
	102
5320918b DA	103	int udl_gem_fault(struct vm_area_struct vma, struct vm_fault vmf)
	104	{
	105	struct udl_gem_object *obj = to_udl_bo(vma->vm_private_data);
	106	struct page *page;
	107	unsigned int page_offset;
	108	int ret = 0;
	109
1a29d85e	110	page_offset = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
5320918b DA	111
	112	if (!obj->pages)
	113	return VM_FAULT_SIGBUS;
	114
	115	page = obj->pages[page_offset];
1a29d85e	116	ret = vm_insert_page(vma, vmf->address, page);
5320918b DA	117	switch (ret) {
5320918b DA	118	case -EAGAIN:
5320918b DA	119	case 0:
	120	case -ERESTARTSYS:
	121	return VM_FAULT_NOPAGE;
	122	case -ENOMEM:
	123	return VM_FAULT_OOM;
	124	default:
	125	return VM_FAULT_SIGBUS;
	126	}
	127	}
	128
4bc158e0	129	int udl_gem_get_pages(struct udl_gem_object *obj)
5320918b	130	{
5dc9e1e8	131	struct page **pages;
5320918b DA	132
	133	if (obj->pages)
	134	return 0;
	135
0cdbe8ac	136	pages = drm_gem_get_pages(&obj->base);
5dc9e1e8 RC	137	if (IS_ERR(pages))
5dc9e1e8 RC	138	return PTR_ERR(pages);
5320918b	139
5dc9e1e8	140	obj->pages = pages;
5320918b DA	141
5320918b DA	142	return 0;
5320918b DA	143	}
5320918b DA	144
4bc158e0	145	void udl_gem_put_pages(struct udl_gem_object *obj)
5320918b	146	{
1d507b3a RC	147	if (obj->base.import_attach) {
	148	drm_free_large(obj->pages);
	149	obj->pages = NULL;
	150	return;
	151	}
	152
5dc9e1e8	153	drm_gem_put_pages(&obj->base, obj->pages, false, false);
5320918b DA	154	obj->pages = NULL;
	155	}
	156
	157	int udl_gem_vmap(struct udl_gem_object *obj)
	158	{
	159	int page_count = obj->base.size / PAGE_SIZE;
	160	int ret;
	161
e8aa1d1e	162	if (obj->base.import_attach) {
e8aa1d1e DA	163	obj->vmapping = dma_buf_vmap(obj->base.import_attach->dmabuf);
	164	if (!obj->vmapping)
	165	return -ENOMEM;
	166	return 0;
	167	}
	168
0cdbe8ac	169	ret = udl_gem_get_pages(obj);
5320918b DA	170	if (ret)
	171	return ret;
	172
	173	obj->vmapping = vmap(obj->pages, page_count, 0, PAGE_KERNEL);
	174	if (!obj->vmapping)
	175	return -ENOMEM;
	176	return 0;
	177	}
	178
	179	void udl_gem_vunmap(struct udl_gem_object *obj)
	180	{
e8aa1d1e DA	181	if (obj->base.import_attach) {
e8aa1d1e DA	182	dma_buf_vunmap(obj->base.import_attach->dmabuf, obj->vmapping);
e8aa1d1e DA	183	return;
	184	}
	185
e9196d23	186	vunmap(obj->vmapping);
5320918b DA	187
	188	udl_gem_put_pages(obj);
	189	}
	190
	191	void udl_gem_free_object(struct drm_gem_object *gem_obj)
	192	{
	193	struct udl_gem_object *obj = to_udl_bo(gem_obj);
	194
	195	if (obj->vmapping)
	196	udl_gem_vunmap(obj);
	197
347cf10a	198	if (gem_obj->import_attach) {
e8aa1d1e	199	drm_prime_gem_destroy(gem_obj, obj->sg);
347cf10a DA	200	put_device(gem_obj->dev->dev);
347cf10a DA	201	}
e8aa1d1e	202
5320918b DA	203	if (obj->pages)
	204	udl_gem_put_pages(obj);
	205
0de23977	206	drm_gem_free_mmap_offset(gem_obj);
5320918b DA	207	}
	208
	209	/* the dumb interface doesn't work with the GEM straight MMAP
	210	interface, it expects to do MMAP on the drm fd, like normal */
	211	int udl_gem_mmap(struct drm_file file, struct drm_device dev,
	212	uint32_t handle, uint64_t *offset)
	213	{
	214	struct udl_gem_object *gobj;
	215	struct drm_gem_object *obj;
	216	int ret = 0;
	217
	218	mutex_lock(&dev->struct_mutex);
a8ad0bd8	219	obj = drm_gem_object_lookup(file, handle);
5320918b DA	220	if (obj == NULL) {
	221	ret = -ENOENT;
	222	goto unlock;
	223	}
	224	gobj = to_udl_bo(obj);
	225
0cdbe8ac	226	ret = udl_gem_get_pages(gobj);
5320918b	227	if (ret)
ace281e8	228	goto out;
0de23977 DH	229	ret = drm_gem_create_mmap_offset(obj);
	230	if (ret)
	231	goto out;
5320918b	232
0de23977	233	*offset = drm_vma_node_offset_addr(&gobj->base.vma_node);
5320918b DA	234
	235	out:
	236	drm_gem_object_unreference(&gobj->base);
	237	unlock:
	238	mutex_unlock(&dev->struct_mutex);
	239	return ret;
	240	}