[deliverable/linux.git] / drivers / gpu / drm / exynos / exynos_drm_gem.c

/* exynos_drm_gem.c
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 * Author: Inki Dae <inki.dae@samsung.com>
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

#include <drm/drmP.h>
#include <drm/drm_vma_manager.h>

#include <linux/shmem_fs.h>
#include <drm/exynos_drm.h>

#include "exynos_drm_drv.h"
#include "exynos_drm_gem.h"
#include "exynos_drm_buf.h"
#include "exynos_drm_iommu.h"

static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
					struct drm_file *file_priv,
					unsigned int *handle)
{
	int ret;

	/*
	 * allocate a id of idr table where the obj is registered
	 * and handle has the id what user can see.
	 */
	ret = drm_gem_handle_create(file_priv, obj, handle);
	if (ret)
		return ret;

	DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);

	/* drop reference from allocate - handle holds it now. */
	drm_gem_object_unreference_unlocked(obj);

	return 0;
}

void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
{
	struct drm_gem_object *obj;
	struct exynos_drm_gem_buf *buf;

	obj = &exynos_gem_obj->base;
	buf = exynos_gem_obj->buffer;

	DRM_DEBUG_KMS("handle count = %d\n", obj->handle_count);

	/*
	 * do not release memory region from exporter.
	 *
	 * the region will be released by exporter
	 * once dmabuf's refcount becomes 0.
	 */
	if (obj->import_attach)
		goto out;

	exynos_drm_free_buf(obj->dev, exynos_gem_obj->flags, buf);

out:
	exynos_drm_fini_buf(obj->dev, buf);
	exynos_gem_obj->buffer = NULL;

	drm_gem_free_mmap_offset(obj);

	/* release file pointer to gem object. */
	drm_gem_object_release(obj);

	kfree(exynos_gem_obj);
	exynos_gem_obj = NULL;
}

unsigned long exynos_drm_gem_get_size(struct drm_device *dev,
						unsigned int gem_handle,
						struct drm_file *file_priv)
{
	struct exynos_drm_gem_obj *exynos_gem_obj;
	struct drm_gem_object *obj;

	obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
	if (!obj) {
		DRM_ERROR("failed to lookup gem object.\n");
		return 0;
	}

	exynos_gem_obj = to_exynos_gem_obj(obj);

	drm_gem_object_unreference_unlocked(obj);

	return exynos_gem_obj->buffer->size;
}


struct exynos_drm_gem_obj *exynos_drm_gem_init(struct drm_device *dev,
						      unsigned long size)
{
	struct exynos_drm_gem_obj *exynos_gem_obj;
	struct drm_gem_object *obj;
	int ret;

	exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
	if (!exynos_gem_obj)
		return ERR_PTR(-ENOMEM);

	exynos_gem_obj->size = size;
	obj = &exynos_gem_obj->base;

	ret = drm_gem_object_init(dev, obj, size);
	if (ret < 0) {
		DRM_ERROR("failed to initialize gem object\n");
		kfree(exynos_gem_obj);
		return ERR_PTR(ret);
	}

	DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);

	return exynos_gem_obj;
}

struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_device *dev,
						unsigned int flags,
						unsigned long size)
{
	struct exynos_drm_gem_obj *exynos_gem_obj;
	struct exynos_drm_gem_buf *buf;
	int ret;

	if (flags & ~(EXYNOS_BO_MASK)) {
		DRM_ERROR("invalid flags.\n");
		return ERR_PTR(-EINVAL);
	}

	if (!size) {
		DRM_ERROR("invalid size.\n");
		return ERR_PTR(-EINVAL);
	}

	size = roundup(size, PAGE_SIZE);

	buf = exynos_drm_init_buf(dev, size);
	if (!buf)
		return ERR_PTR(-ENOMEM);

	exynos_gem_obj = exynos_drm_gem_init(dev, size);
	if (IS_ERR(exynos_gem_obj)) {
		ret = PTR_ERR(exynos_gem_obj);
		goto err_fini_buf;
	}

	exynos_gem_obj->buffer = buf;

	/* set memory type and cache attribute from user side. */
	exynos_gem_obj->flags = flags;

	ret = exynos_drm_alloc_buf(dev, buf, flags);
	if (ret < 0)
		goto err_gem_fini;

	return exynos_gem_obj;

err_gem_fini:
	drm_gem_object_release(&exynos_gem_obj->base);
	kfree(exynos_gem_obj);
err_fini_buf:
	exynos_drm_fini_buf(dev, buf);
	return ERR_PTR(ret);
}

int exynos_drm_gem_create_ioctl(struct drm_device *dev, void *data,
				struct drm_file *file_priv)
{
	struct drm_exynos_gem_create *args = data;
	struct exynos_drm_gem_obj *exynos_gem_obj;
	int ret;

	exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
	if (IS_ERR(exynos_gem_obj))
		return PTR_ERR(exynos_gem_obj);

	ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
			&args->handle);
	if (ret) {
		exynos_drm_gem_destroy(exynos_gem_obj);
		return ret;
	}

	return 0;
}

dma_addr_t *exynos_drm_gem_get_dma_addr(struct drm_device *dev,
					unsigned int gem_handle,
					struct drm_file *filp)
{
	struct exynos_drm_gem_obj *exynos_gem_obj;
	struct drm_gem_object *obj;

	obj = drm_gem_object_lookup(dev, filp, gem_handle);
	if (!obj) {
		DRM_ERROR("failed to lookup gem object.\n");
		return ERR_PTR(-EINVAL);
	}

	exynos_gem_obj = to_exynos_gem_obj(obj);

	return &exynos_gem_obj->buffer->dma_addr;
}

void exynos_drm_gem_put_dma_addr(struct drm_device *dev,
					unsigned int gem_handle,
					struct drm_file *filp)
{
	struct drm_gem_object *obj;

	obj = drm_gem_object_lookup(dev, filp, gem_handle);
	if (!obj) {
		DRM_ERROR("failed to lookup gem object.\n");
		return;
	}

	drm_gem_object_unreference_unlocked(obj);

	/*
	 * decrease obj->refcount one more time because we has already
	 * increased it at exynos_drm_gem_get_dma_addr().
	 */
	drm_gem_object_unreference_unlocked(obj);
}

int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem_obj *exynos_gem_obj,
				      struct vm_area_struct *vma)
{
	struct drm_device *drm_dev = exynos_gem_obj->base.dev;
	struct exynos_drm_gem_buf *buffer;
	unsigned long vm_size;
	int ret;

	vma->vm_flags &= ~VM_PFNMAP;
	vma->vm_pgoff = 0;

	vm_size = vma->vm_end - vma->vm_start;

	/*
	 * a buffer contains information to physically continuous memory
	 * allocated by user request or at framebuffer creation.
	 */
	buffer = exynos_gem_obj->buffer;

	/* check if user-requested size is valid. */
	if (vm_size > buffer->size)
		return -EINVAL;

	ret = dma_mmap_attrs(drm_dev->dev, vma, buffer->pages,
				buffer->dma_addr, buffer->size,
				&buffer->dma_attrs);
	if (ret < 0) {
		DRM_ERROR("failed to mmap.\n");
		return ret;
	}

	return 0;
}

int exynos_drm_gem_get_ioctl(struct drm_device *dev, void *data,
				      struct drm_file *file_priv)
{	struct exynos_drm_gem_obj *exynos_gem_obj;
	struct drm_exynos_gem_info *args = data;
	struct drm_gem_object *obj;

	mutex_lock(&dev->struct_mutex);

	obj = drm_gem_object_lookup(dev, file_priv, args->handle);
	if (!obj) {
		DRM_ERROR("failed to lookup gem object.\n");
		mutex_unlock(&dev->struct_mutex);
		return -EINVAL;
	}

	exynos_gem_obj = to_exynos_gem_obj(obj);

	args->flags = exynos_gem_obj->flags;
	args->size = exynos_gem_obj->size;

	drm_gem_object_unreference(obj);
	mutex_unlock(&dev->struct_mutex);

	return 0;
}

struct vm_area_struct *exynos_gem_get_vma(struct vm_area_struct *vma)
{
	struct vm_area_struct *vma_copy;

	vma_copy = kmalloc(sizeof(*vma_copy), GFP_KERNEL);
	if (!vma_copy)
		return NULL;

	if (vma->vm_ops && vma->vm_ops->open)
		vma->vm_ops->open(vma);

	if (vma->vm_file)
		get_file(vma->vm_file);

	memcpy(vma_copy, vma, sizeof(*vma));

	vma_copy->vm_mm = NULL;
	vma_copy->vm_next = NULL;
	vma_copy->vm_prev = NULL;

	return vma_copy;
}

void exynos_gem_put_vma(struct vm_area_struct *vma)
{
	if (!vma)
		return;

	if (vma->vm_ops && vma->vm_ops->close)
		vma->vm_ops->close(vma);

	if (vma->vm_file)
		fput(vma->vm_file);

	kfree(vma);
}

int exynos_gem_get_pages_from_userptr(unsigned long start,
						unsigned int npages,
						struct page **pages,
						struct vm_area_struct *vma)
{
	int get_npages;

	/* the memory region mmaped with VM_PFNMAP. */
	if (vma_is_io(vma)) {
		unsigned int i;

		for (i = 0; i < npages; ++i, start += PAGE_SIZE) {
			unsigned long pfn;
			int ret = follow_pfn(vma, start, &pfn);
			if (ret)
				return ret;

			pages[i] = pfn_to_page(pfn);
		}

		if (i != npages) {
			DRM_ERROR("failed to get user_pages.\n");
			return -EINVAL;
		}

		return 0;
	}

	get_npages = get_user_pages(current, current->mm, start,
					npages, 1, 1, pages, NULL);
	get_npages = max(get_npages, 0);
	if (get_npages != npages) {
		DRM_ERROR("failed to get user_pages.\n");
		while (get_npages)
			put_page(pages[--get_npages]);
		return -EFAULT;
	}

	return 0;
}

void exynos_gem_put_pages_to_userptr(struct page **pages,
					unsigned int npages,
					struct vm_area_struct *vma)
{
	if (!vma_is_io(vma)) {
		unsigned int i;

		for (i = 0; i < npages; i++) {
			set_page_dirty_lock(pages[i]);

			/*
			 * undo the reference we took when populating
			 * the table.
			 */
			put_page(pages[i]);
		}
	}
}

int exynos_gem_map_sgt_with_dma(struct drm_device *drm_dev,
				struct sg_table *sgt,
				enum dma_data_direction dir)
{
	int nents;

	mutex_lock(&drm_dev->struct_mutex);

	nents = dma_map_sg(drm_dev->dev, sgt->sgl, sgt->nents, dir);
	if (!nents) {
		DRM_ERROR("failed to map sgl with dma.\n");
		mutex_unlock(&drm_dev->struct_mutex);
		return nents;
	}

	mutex_unlock(&drm_dev->struct_mutex);
	return 0;
}

void exynos_gem_unmap_sgt_from_dma(struct drm_device *drm_dev,
				struct sg_table *sgt,
				enum dma_data_direction dir)
{
	dma_unmap_sg(drm_dev->dev, sgt->sgl, sgt->nents, dir);
}

void exynos_drm_gem_free_object(struct drm_gem_object *obj)
{
	struct exynos_drm_gem_obj *exynos_gem_obj;
	struct exynos_drm_gem_buf *buf;

	exynos_gem_obj = to_exynos_gem_obj(obj);
	buf = exynos_gem_obj->buffer;

	exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
}

int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
			       struct drm_device *dev,
			       struct drm_mode_create_dumb *args)
{
	struct exynos_drm_gem_obj *exynos_gem_obj;
	int ret;

	/*
	 * allocate memory to be used for framebuffer.
	 * - this callback would be called by user application
	 *	with DRM_IOCTL_MODE_CREATE_DUMB command.
	 */

	args->pitch = args->width * ((args->bpp + 7) / 8);
	args->size = args->pitch * args->height;

	if (is_drm_iommu_supported(dev)) {
		exynos_gem_obj = exynos_drm_gem_create(dev,
			EXYNOS_BO_NONCONTIG | EXYNOS_BO_WC,
			args->size);
	} else {
		exynos_gem_obj = exynos_drm_gem_create(dev,
			EXYNOS_BO_CONTIG | EXYNOS_BO_WC,
			args->size);
	}

	if (IS_ERR(exynos_gem_obj)) {
		dev_warn(dev->dev, "FB allocation failed.\n");
		return PTR_ERR(exynos_gem_obj);
	}

	ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
			&args->handle);
	if (ret) {
		exynos_drm_gem_destroy(exynos_gem_obj);
		return ret;
	}

	return 0;
}

int exynos_drm_gem_dumb_map_offset(struct drm_file *file_priv,
				   struct drm_device *dev, uint32_t handle,
				   uint64_t *offset)
{
	struct drm_gem_object *obj;
	int ret = 0;

	mutex_lock(&dev->struct_mutex);

	/*
	 * get offset of memory allocated for drm framebuffer.
	 * - this callback would be called by user application
	 *	with DRM_IOCTL_MODE_MAP_DUMB command.
	 */

	obj = drm_gem_object_lookup(dev, file_priv, handle);
	if (!obj) {
		DRM_ERROR("failed to lookup gem object.\n");
		ret = -EINVAL;
		goto unlock;
	}

	ret = drm_gem_create_mmap_offset(obj);
	if (ret)
		goto out;

	*offset = drm_vma_node_offset_addr(&obj->vma_node);
	DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);

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

int exynos_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	struct drm_gem_object *obj = vma->vm_private_data;
	struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
	struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
	unsigned long pfn;
	pgoff_t page_offset;
	int ret;

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

	if (page_offset >= (buf->size >> PAGE_SHIFT)) {
		DRM_ERROR("invalid page offset\n");
		ret = -EINVAL;
		goto out;
	}

	pfn = page_to_pfn(buf->pages[page_offset]);
	ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn);

out:
	switch (ret) {
	case 0:
	case -ERESTARTSYS:
	case -EINTR:
		return VM_FAULT_NOPAGE;
	case -ENOMEM:
		return VM_FAULT_OOM;
	default:
		return VM_FAULT_SIGBUS;
	}
}

int exynos_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
{
	struct exynos_drm_gem_obj *exynos_gem_obj;
	struct drm_gem_object *obj;
	int ret;

	/* set vm_area_struct. */
	ret = drm_gem_mmap(filp, vma);
	if (ret < 0) {
		DRM_ERROR("failed to mmap.\n");
		return ret;
	}

	obj = vma->vm_private_data;
	exynos_gem_obj = to_exynos_gem_obj(obj);

	DRM_DEBUG_KMS("flags = 0x%x\n", exynos_gem_obj->flags);

	/* non-cachable as default. */
	if (exynos_gem_obj->flags & EXYNOS_BO_CACHABLE)
		vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
	else if (exynos_gem_obj->flags & EXYNOS_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));

	ret = exynos_drm_gem_mmap_buffer(exynos_gem_obj, vma);
	if (ret)
		goto err_close_vm;

	return ret;

err_close_vm:
	drm_gem_vm_close(vma);
	drm_gem_free_mmap_offset(obj);

	return ret;
}
Commit	Line	Data
1c248b7d ID	1	/* exynos_drm_gem.c
	2	*
	3	* Copyright (c) 2011 Samsung Electronics Co., Ltd.
	4	* Author: Inki Dae <inki.dae@samsung.com>
	5	*
d81aecb5 ID	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2 of the License, or (at your
	9	* option) any later version.
1c248b7d ID	10	*/
1c248b7d ID	11
760285e7	12	#include <drm/drmP.h>
0de23977	13	#include <drm/drm_vma_manager.h>
1c248b7d	14
2b35892e	15	#include <linux/shmem_fs.h>
1c248b7d ID	16	#include <drm/exynos_drm.h>
	17
	18	#include "exynos_drm_drv.h"
	19	#include "exynos_drm_gem.h"
	20	#include "exynos_drm_buf.h"
3fec4532	21	#include "exynos_drm_iommu.h"
1c248b7d	22
2364839a JS	23	static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
	24	struct drm_file *file_priv,
	25	unsigned int *handle)
1c248b7d	26	{
1c248b7d ID	27	int ret;
1c248b7d ID	28
1c248b7d ID	29	/*
	30	* allocate a id of idr table where the obj is registered
	31	* and handle has the id what user can see.
	32	*/
	33	ret = drm_gem_handle_create(file_priv, obj, handle);
	34	if (ret)
2364839a	35	return ret;
1c248b7d ID	36
	37	DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);
	38
	39	/* drop reference from allocate - handle holds it now. */
	40	drm_gem_object_unreference_unlocked(obj);
	41
2364839a JS	42	return 0;
	43	}
	44
	45	void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
	46	{
	47	struct drm_gem_object *obj;
c01d73fa	48	struct exynos_drm_gem_buf *buf;
2364839a	49
2364839a	50	obj = &exynos_gem_obj->base;
c01d73fa	51	buf = exynos_gem_obj->buffer;
2364839a	52
a8e11d1c	53	DRM_DEBUG_KMS("handle count = %d\n", obj->handle_count);
1c248b7d	54
c374e731 ID	55	/*
	56	* do not release memory region from exporter.
	57	*
	58	* the region will be released by exporter
	59	* once dmabuf's refcount becomes 0.
	60	*/
	61	if (obj->import_attach)
	62	goto out;
	63
0519f9a1	64	exynos_drm_free_buf(obj->dev, exynos_gem_obj->flags, buf);
2b35892e	65
c374e731	66	out:
c01d73fa	67	exynos_drm_fini_buf(obj->dev, buf);
2b35892e	68	exynos_gem_obj->buffer = NULL;
2364839a	69
0de23977	70	drm_gem_free_mmap_offset(obj);
2364839a JS	71
2364839a JS	72	/* release file pointer to gem object. */
1c248b7d ID	73	drm_gem_object_release(obj);
1c248b7d ID	74
1c248b7d	75	kfree(exynos_gem_obj);
2b35892e	76	exynos_gem_obj = NULL;
2364839a JS	77	}
2364839a JS	78
a4f19aaa ID	79	unsigned long exynos_drm_gem_get_size(struct drm_device *dev,
	80	unsigned int gem_handle,
	81	struct drm_file *file_priv)
	82	{
	83	struct exynos_drm_gem_obj *exynos_gem_obj;
	84	struct drm_gem_object *obj;
	85
	86	obj = drm_gem_object_lookup(dev, file_priv, gem_handle);
	87	if (!obj) {
	88	DRM_ERROR("failed to lookup gem object.\n");
	89	return 0;
	90	}
	91
	92	exynos_gem_obj = to_exynos_gem_obj(obj);
	93
	94	drm_gem_object_unreference_unlocked(obj);
	95
	96	return exynos_gem_obj->buffer->size;
	97	}
	98
	99
b2df26c1	100	struct exynos_drm_gem_obj exynos_drm_gem_init(struct drm_device dev,
2364839a JS	101	unsigned long size)
	102	{
	103	struct exynos_drm_gem_obj *exynos_gem_obj;
	104	struct drm_gem_object *obj;
	105	int ret;
	106
	107	exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
38bb5253	108	if (!exynos_gem_obj)
5f3f4266	109	return ERR_PTR(-ENOMEM);
2364839a	110
2b35892e	111	exynos_gem_obj->size = size;
2364839a JS	112	obj = &exynos_gem_obj->base;
	113
	114	ret = drm_gem_object_init(dev, obj, size);
	115	if (ret < 0) {
	116	DRM_ERROR("failed to initialize gem object\n");
	117	kfree(exynos_gem_obj);
5f3f4266	118	return ERR_PTR(ret);
2364839a JS	119	}
	120
	121	DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
	122
	123	return exynos_gem_obj;
1c248b7d ID	124	}
1c248b7d ID	125
f088d5a9	126	struct exynos_drm_gem_obj exynos_drm_gem_create(struct drm_device dev,
2b35892e ID	127	unsigned int flags,
2b35892e ID	128	unsigned long size)
f088d5a9	129	{
2364839a	130	struct exynos_drm_gem_obj *exynos_gem_obj;
2b35892e ID	131	struct exynos_drm_gem_buf *buf;
2b35892e ID	132	int ret;
f088d5a9	133
c4130bcd JS	134	if (flags & ~(EXYNOS_BO_MASK)) {
	135	DRM_ERROR("invalid flags.\n");
	136	return ERR_PTR(-EINVAL);
	137	}
	138
dcf9af82 ID	139	if (!size) {
	140	DRM_ERROR("invalid size.\n");
	141	return ERR_PTR(-EINVAL);
	142	}
	143
eb57da88	144	size = roundup(size, PAGE_SIZE);
f088d5a9	145
2b35892e ID	146	buf = exynos_drm_init_buf(dev, size);
2b35892e ID	147	if (!buf)
ee5e770e	148	return ERR_PTR(-ENOMEM);
f088d5a9	149
2364839a	150	exynos_gem_obj = exynos_drm_gem_init(dev, size);
5f3f4266 JS	151	if (IS_ERR(exynos_gem_obj)) {
5f3f4266 JS	152	ret = PTR_ERR(exynos_gem_obj);
dcf9af82	153	goto err_fini_buf;
f088d5a9 ID	154	}
f088d5a9 ID	155
2b35892e ID	156	exynos_gem_obj->buffer = buf;
	157
	158	/* set memory type and cache attribute from user side. */
	159	exynos_gem_obj->flags = flags;
	160
0519f9a1	161	ret = exynos_drm_alloc_buf(dev, buf, flags);
c58c1599 YC	162	if (ret < 0)
c58c1599 YC	163	goto err_gem_fini;
f088d5a9 ID	164
f088d5a9 ID	165	return exynos_gem_obj;
dcf9af82	166
c58c1599 YC	167	err_gem_fini:
	168	drm_gem_object_release(&exynos_gem_obj->base);
	169	kfree(exynos_gem_obj);
dcf9af82	170	err_fini_buf:
2b35892e ID	171	exynos_drm_fini_buf(dev, buf);
2b35892e ID	172	return ERR_PTR(ret);
f088d5a9 ID	173	}
f088d5a9 ID	174
1c248b7d	175	int exynos_drm_gem_create_ioctl(struct drm_device dev, void data,
ee5e770e	176	struct drm_file *file_priv)
1c248b7d ID	177	{
1c248b7d ID	178	struct drm_exynos_gem_create *args = data;
ee5e770e	179	struct exynos_drm_gem_obj *exynos_gem_obj;
2364839a	180	int ret;
1c248b7d	181
2b35892e	182	exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
1c248b7d ID	183	if (IS_ERR(exynos_gem_obj))
	184	return PTR_ERR(exynos_gem_obj);
	185
2364839a JS	186	ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
	187	&args->handle);
	188	if (ret) {
	189	exynos_drm_gem_destroy(exynos_gem_obj);
	190	return ret;
	191	}
	192
1c248b7d ID	193	return 0;
	194	}
	195
d87342c1	196	dma_addr_t exynos_drm_gem_get_dma_addr(struct drm_device dev,
f0b1bda7	197	unsigned int gem_handle,
d87342c1	198	struct drm_file *filp)
f0b1bda7 ID	199	{
	200	struct exynos_drm_gem_obj *exynos_gem_obj;
	201	struct drm_gem_object *obj;
	202
d87342c1	203	obj = drm_gem_object_lookup(dev, filp, gem_handle);
f0b1bda7 ID	204	if (!obj) {
	205	DRM_ERROR("failed to lookup gem object.\n");
	206	return ERR_PTR(-EINVAL);
	207	}
	208
	209	exynos_gem_obj = to_exynos_gem_obj(obj);
	210
f0b1bda7 ID	211	return &exynos_gem_obj->buffer->dma_addr;
	212	}
	213
	214	void exynos_drm_gem_put_dma_addr(struct drm_device *dev,
	215	unsigned int gem_handle,
d87342c1	216	struct drm_file *filp)
f0b1bda7	217	{
f0b1bda7 ID	218	struct drm_gem_object *obj;
f0b1bda7 ID	219
d87342c1	220	obj = drm_gem_object_lookup(dev, filp, gem_handle);
f0b1bda7 ID	221	if (!obj) {
	222	DRM_ERROR("failed to lookup gem object.\n");
	223	return;
	224	}
	225
f0b1bda7 ID	226	drm_gem_object_unreference_unlocked(obj);
	227
	228	/*
	229	* decrease obj->refcount one more time because we has already
	230	* increased it at exynos_drm_gem_get_dma_addr().
	231	*/
	232	drm_gem_object_unreference_unlocked(obj);
	233	}
	234
832316c7	235	int exynos_drm_gem_mmap_buffer(struct exynos_drm_gem_obj *exynos_gem_obj,
ee5e770e	236	struct vm_area_struct *vma)
1c248b7d	237	{
832316c7	238	struct drm_device *drm_dev = exynos_gem_obj->base.dev;
2c871127	239	struct exynos_drm_gem_buf *buffer;
0519f9a1	240	unsigned long vm_size;
5b07c660	241	int ret;
1c248b7d	242
832316c7 ID	243	vma->vm_flags &= ~VM_PFNMAP;
832316c7 ID	244	vma->vm_pgoff = 0;
1c248b7d	245
0519f9a1	246	vm_size = vma->vm_end - vma->vm_start;
2b35892e	247
1c248b7d	248	/*
2c871127	249	* a buffer contains information to physically continuous memory
1c248b7d ID	250	* allocated by user request or at framebuffer creation.
1c248b7d ID	251	*/
2c871127	252	buffer = exynos_gem_obj->buffer;
1c248b7d ID	253
1c248b7d ID	254	/* check if user-requested size is valid. */
2c871127	255	if (vm_size > buffer->size)
1c248b7d ID	256	return -EINVAL;
1c248b7d ID	257
4744ad24	258	ret = dma_mmap_attrs(drm_dev->dev, vma, buffer->pages,
0519f9a1 ID	259	buffer->dma_addr, buffer->size,
0519f9a1 ID	260	&buffer->dma_attrs);
5b07c660 ID	261	if (ret < 0) {
	262	DRM_ERROR("failed to mmap.\n");
	263	return ret;
	264	}
	265
1c248b7d ID	266	return 0;
	267	}
	268
40cd7e0c ID	269	int exynos_drm_gem_get_ioctl(struct drm_device dev, void data,
	270	struct drm_file *file_priv)
	271	{ struct exynos_drm_gem_obj *exynos_gem_obj;
	272	struct drm_exynos_gem_info *args = data;
	273	struct drm_gem_object *obj;
	274
	275	mutex_lock(&dev->struct_mutex);
	276
	277	obj = drm_gem_object_lookup(dev, file_priv, args->handle);
	278	if (!obj) {
	279	DRM_ERROR("failed to lookup gem object.\n");
	280	mutex_unlock(&dev->struct_mutex);
	281	return -EINVAL;
	282	}
	283
	284	exynos_gem_obj = to_exynos_gem_obj(obj);
	285
	286	args->flags = exynos_gem_obj->flags;
	287	args->size = exynos_gem_obj->size;
	288
	289	drm_gem_object_unreference(obj);
	290	mutex_unlock(&dev->struct_mutex);
	291
	292	return 0;
	293	}
	294
2a3098ff ID	295	struct vm_area_struct exynos_gem_get_vma(struct vm_area_struct vma)
	296	{
	297	struct vm_area_struct *vma_copy;
	298
	299	vma_copy = kmalloc(sizeof(*vma_copy), GFP_KERNEL);
	300	if (!vma_copy)
	301	return NULL;
	302
	303	if (vma->vm_ops && vma->vm_ops->open)
	304	vma->vm_ops->open(vma);
	305
	306	if (vma->vm_file)
	307	get_file(vma->vm_file);
	308
	309	memcpy(vma_copy, vma, sizeof(*vma));
	310
	311	vma_copy->vm_mm = NULL;
	312	vma_copy->vm_next = NULL;
	313	vma_copy->vm_prev = NULL;
	314
	315	return vma_copy;
	316	}
	317
	318	void exynos_gem_put_vma(struct vm_area_struct *vma)
	319	{
	320	if (!vma)
	321	return;
	322
	323	if (vma->vm_ops && vma->vm_ops->close)
	324	vma->vm_ops->close(vma);
	325
	326	if (vma->vm_file)
	327	fput(vma->vm_file);
	328
	329	kfree(vma);
	330	}
	331
	332	int exynos_gem_get_pages_from_userptr(unsigned long start,
	333	unsigned int npages,
	334	struct page **pages,
	335	struct vm_area_struct *vma)
	336	{
	337	int get_npages;
	338
	339	/* the memory region mmaped with VM_PFNMAP. */
	340	if (vma_is_io(vma)) {
	341	unsigned int i;
	342
	343	for (i = 0; i < npages; ++i, start += PAGE_SIZE) {
	344	unsigned long pfn;
	345	int ret = follow_pfn(vma, start, &pfn);
	346	if (ret)
	347	return ret;
	348
	349	pages[i] = pfn_to_page(pfn);
	350	}
	351
	352	if (i != npages) {
	353	DRM_ERROR("failed to get user_pages.\n");
	354	return -EINVAL;
	355	}
	356
	357	return 0;
	358	}
359
360	get_npages = get_user_pages(current, current->mm, start,
361	npages, 1, 1, pages, NULL);
362	get_npages = max(get_npages, 0);
363	if (get_npages != npages) {
364	DRM_ERROR("failed to get user_pages.\n");
365	while (get_npages)
366	put_page(pages[--get_npages]);
367	return -EFAULT;
368	}
369
370	return 0;
371	}
372
373	void exynos_gem_put_pages_to_userptr(struct page **pages,
374	unsigned int npages,
375	struct vm_area_struct *vma)
376	{
377	if (!vma_is_io(vma)) {
378	unsigned int i;
379
380	for (i = 0; i < npages; i++) {
381	set_page_dirty_lock(pages[i]);
382
383	/*
384	* undo the reference we took when populating
385	* the table.
386	*/
387	put_page(pages[i]);
388	}
389	}
390	}
391
392	int exynos_gem_map_sgt_with_dma(struct drm_device *drm_dev,
393	struct sg_table *sgt,
394	enum dma_data_direction dir)
395	{
396	int nents;
397
398	mutex_lock(&drm_dev->struct_mutex);
399
400	nents = dma_map_sg(drm_dev->dev, sgt->sgl, sgt->nents, dir);
401	if (!nents) {
402	DRM_ERROR("failed to map sgl with dma.\n");
403	mutex_unlock(&drm_dev->struct_mutex);
404	return nents;
405	}
406
407	mutex_unlock(&drm_dev->struct_mutex);
408	return 0;
409	}
410
411	void exynos_gem_unmap_sgt_from_dma(struct drm_device *drm_dev,
412	struct sg_table *sgt,
413	enum dma_data_direction dir)
414	{
415	dma_unmap_sg(drm_dev->dev, sgt->sgl, sgt->nents, dir);
416	}
417
ee5e770e	418	void exynos_drm_gem_free_object(struct drm_gem_object *obj)
1c248b7d	419	{
b2df26c1 ID	420	struct exynos_drm_gem_obj *exynos_gem_obj;
	421	struct exynos_drm_gem_buf *buf;
	422
b2df26c1 ID	423	exynos_gem_obj = to_exynos_gem_obj(obj);
	424	buf = exynos_gem_obj->buffer;
	425
2364839a	426	exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
1c248b7d ID	427	}
	428
	429	int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
ee5e770e JS	430	struct drm_device *dev,
ee5e770e JS	431	struct drm_mode_create_dumb *args)
1c248b7d ID	432	{
1c248b7d ID	433	struct exynos_drm_gem_obj *exynos_gem_obj;
2364839a	434	int ret;
1c248b7d	435
1c248b7d	436	/*
c6b78bc8	437	* allocate memory to be used for framebuffer.
1c248b7d ID	438	* - this callback would be called by user application
	439	* with DRM_IOCTL_MODE_CREATE_DUMB command.
	440	*/
	441
3fd6b694	442	args->pitch = args->width * ((args->bpp + 7) / 8);
7da5907c	443	args->size = args->pitch * args->height;
1c248b7d	444
122beea8 RS	445	if (is_drm_iommu_supported(dev)) {
	446	exynos_gem_obj = exynos_drm_gem_create(dev,
	447	EXYNOS_BO_NONCONTIG \| EXYNOS_BO_WC,
	448	args->size);
	449	} else {
3fec4532	450	exynos_gem_obj = exynos_drm_gem_create(dev,
122beea8 RS	451	EXYNOS_BO_CONTIG \| EXYNOS_BO_WC,
122beea8 RS	452	args->size);
3fec4532 VS	453	}
3fec4532 VS	454
122beea8 RS	455	if (IS_ERR(exynos_gem_obj)) {
122beea8 RS	456	dev_warn(dev->dev, "FB allocation failed.\n");
1c248b7d	457	return PTR_ERR(exynos_gem_obj);
122beea8	458	}
1c248b7d	459
2364839a JS	460	ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
	461	&args->handle);
	462	if (ret) {
	463	exynos_drm_gem_destroy(exynos_gem_obj);
	464	return ret;
	465	}
	466
1c248b7d ID	467	return 0;
	468	}
	469
	470	int exynos_drm_gem_dumb_map_offset(struct drm_file *file_priv,
ee5e770e JS	471	struct drm_device *dev, uint32_t handle,
ee5e770e JS	472	uint64_t *offset)
1c248b7d	473	{
1c248b7d	474	struct drm_gem_object *obj;
2d91cf17	475	int ret = 0;
1c248b7d	476
1c248b7d ID	477	mutex_lock(&dev->struct_mutex);
	478
	479	/*
	480	* get offset of memory allocated for drm framebuffer.
	481	* - this callback would be called by user application
	482	* with DRM_IOCTL_MODE_MAP_DUMB command.
	483	*/
	484
	485	obj = drm_gem_object_lookup(dev, file_priv, handle);
	486	if (!obj) {
	487	DRM_ERROR("failed to lookup gem object.\n");
2d91cf17 JS	488	ret = -EINVAL;
2d91cf17 JS	489	goto unlock;
1c248b7d ID	490	}
1c248b7d ID	491
0de23977 DH	492	ret = drm_gem_create_mmap_offset(obj);
	493	if (ret)
	494	goto out;
1c248b7d	495
0de23977	496	*offset = drm_vma_node_offset_addr(&obj->vma_node);
1c248b7d ID	497	DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
1c248b7d ID	498
2d91cf17 JS	499	out:
	500	drm_gem_object_unreference(obj);
	501	unlock:
1c248b7d	502	mutex_unlock(&dev->struct_mutex);
2d91cf17	503	return ret;
1c248b7d ID	504	}
	505
	506	int exynos_drm_gem_fault(struct vm_area_struct vma, struct vm_fault vmf)
	507	{
	508	struct drm_gem_object *obj = vma->vm_private_data;
0e9a2ee3 JS	509	struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
	510	struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
	511	unsigned long pfn;
1c248b7d ID	512	pgoff_t page_offset;
	513	int ret;
	514
	515	page_offset = ((unsigned long)vmf->virtual_address -
	516	vma->vm_start) >> PAGE_SHIFT;
	517
0e9a2ee3 JS	518	if (page_offset >= (buf->size >> PAGE_SHIFT)) {
	519	DRM_ERROR("invalid page offset\n");
	520	ret = -EINVAL;
	521	goto out;
	522	}
1c248b7d	523
0e9a2ee3 JS	524	pfn = page_to_pfn(buf->pages[page_offset]);
	525	ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn);
	526
	527	out:
23597e26 JS	528	switch (ret) {
	529	case 0:
	530	case -ERESTARTSYS:
	531	case -EINTR:
	532	return VM_FAULT_NOPAGE;
	533	case -ENOMEM:
	534	return VM_FAULT_OOM;
	535	default:
	536	return VM_FAULT_SIGBUS;
	537	}
1c248b7d ID	538	}
	539
	540	int exynos_drm_gem_mmap(struct file filp, struct vm_area_struct vma)
	541	{
c01d73fa ID	542	struct exynos_drm_gem_obj *exynos_gem_obj;
c01d73fa ID	543	struct drm_gem_object *obj;
1c248b7d ID	544	int ret;
1c248b7d ID	545
1c248b7d ID	546	/* set vm_area_struct. */
	547	ret = drm_gem_mmap(filp, vma);
	548	if (ret < 0) {
	549	DRM_ERROR("failed to mmap.\n");
	550	return ret;
	551	}
	552
c01d73fa ID	553	obj = vma->vm_private_data;
	554	exynos_gem_obj = to_exynos_gem_obj(obj);
	555
211b8878 JS	556	DRM_DEBUG_KMS("flags = 0x%x\n", exynos_gem_obj->flags);
	557
	558	/* non-cachable as default. */
	559	if (exynos_gem_obj->flags & EXYNOS_BO_CACHABLE)
	560	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
	561	else if (exynos_gem_obj->flags & EXYNOS_BO_WC)
	562	vma->vm_page_prot =
	563	pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
	564	else
	565	vma->vm_page_prot =
	566	pgprot_noncached(vm_get_page_prot(vma->vm_flags));
c01d73fa	567
832316c7 ID	568	ret = exynos_drm_gem_mmap_buffer(exynos_gem_obj, vma);
	569	if (ret)
	570	goto err_close_vm;
	571
	572	return ret;
	573
	574	err_close_vm:
	575	drm_gem_vm_close(vma);
	576	drm_gem_free_mmap_offset(obj);
	577
1c248b7d ID	578	return ret;
1c248b7d ID	579	}