[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>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#include <drm/drmP.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"

static unsigned int convert_to_vm_err_msg(int msg)
{
	unsigned int out_msg;

	switch (msg) {
	case 0:
	case -ERESTARTSYS:
	case -EINTR:
		out_msg = VM_FAULT_NOPAGE;
		break;

	case -ENOMEM:
		out_msg = VM_FAULT_OOM;
		break;

	default:
		out_msg = VM_FAULT_SIGBUS;
		break;
	}

	return out_msg;
}

static int check_gem_flags(unsigned int flags)
{
	if (flags & ~(EXYNOS_BO_MASK)) {
		DRM_ERROR("invalid flags.\n");
		return -EINVAL;
	}

	return 0;
}

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

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

static unsigned long roundup_gem_size(unsigned long size, unsigned int flags)
{
	/* TODO */

	return roundup(size, PAGE_SIZE);
}

static int exynos_drm_gem_map_buf(struct drm_gem_object *obj,
					struct vm_area_struct *vma,
					unsigned long f_vaddr,
					pgoff_t page_offset)
{
	struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
	struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
	struct scatterlist *sgl;
	unsigned long pfn;
	int i;

	if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
		if (!buf->sgt)
			return -EINTR;

		sgl = buf->sgt->sgl;
		for_each_sg(buf->sgt->sgl, sgl, buf->sgt->nents, i) {
			if (!sgl) {
				DRM_ERROR("invalid SG table\n");
				return -EINTR;
			}
			if (page_offset < (sgl->length >> PAGE_SHIFT))
				break;
			page_offset -=	(sgl->length >> PAGE_SHIFT);
		}

		if (i >= buf->sgt->nents) {
			DRM_ERROR("invalid page offset\n");
			return -EINVAL;
		}

		pfn = __phys_to_pfn(sg_phys(sgl)) + page_offset;
	} else {
		if (!buf->pages)
			return -EINTR;

		pfn = page_to_pfn(buf->pages[0]) + page_offset;
	}

	return vm_insert_mixed(vma, f_vaddr, pfn);
}

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;

	DRM_DEBUG_KMS("%s\n", __FILE__);

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

	DRM_DEBUG_KMS("handle count = %d\n", atomic_read(&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;

	if (obj->map_list.map)
		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;
}

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) {
		DRM_ERROR("failed to allocate exynos gem object\n");
		return NULL;
	}

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

	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 (!size) {
		DRM_ERROR("invalid size.\n");
		return ERR_PTR(-EINVAL);
	}

	size = roundup_gem_size(size, flags);
	DRM_DEBUG_KMS("%s\n", __FILE__);

	ret = check_gem_flags(flags);
	if (ret)
		return ERR_PTR(ret);

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

	exynos_gem_obj = exynos_drm_gem_init(dev, size);
	if (!exynos_gem_obj) {
		ret = -ENOMEM;
		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) {
		drm_gem_object_release(&exynos_gem_obj->base);
		goto err_fini_buf;
	}

	return 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;

	DRM_DEBUG_KMS("%s\n", __FILE__);

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

	exynos_gem_obj = to_exynos_gem_obj(obj);

	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_map_offset_ioctl(struct drm_device *dev, void *data,
				    struct drm_file *file_priv)
{
	struct drm_exynos_gem_map_off *args = data;

	DRM_DEBUG_KMS("%s\n", __FILE__);

	DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
			args->handle, (unsigned long)args->offset);

	if (!(dev->driver->driver_features & DRIVER_GEM)) {
		DRM_ERROR("does not support GEM.\n");
		return -ENODEV;
	}

	return exynos_drm_gem_dumb_map_offset(file_priv, dev, args->handle,
			&args->offset);
}

static int exynos_drm_gem_mmap_buffer(struct file *filp,
				      struct vm_area_struct *vma)
{
	struct drm_gem_object *obj = filp->private_data;
	struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
	struct exynos_drm_gem_buf *buffer;
	unsigned long vm_size;

	DRM_DEBUG_KMS("%s\n", __FILE__);

	vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;

	update_vm_cache_attr(exynos_gem_obj, vma);

	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;

	return dma_mmap_attrs(obj->dev->dev, vma, buffer->kvaddr,
				buffer->dma_addr, buffer->size,
				&buffer->dma_attrs);
}

static const struct file_operations exynos_drm_gem_fops = {
	.mmap = exynos_drm_gem_mmap_buffer,
};

int exynos_drm_gem_mmap_ioctl(struct drm_device *dev, void *data,
			      struct drm_file *file_priv)
{
	struct drm_exynos_gem_mmap *args = data;
	struct drm_gem_object *obj;
	unsigned int addr;

	DRM_DEBUG_KMS("%s\n", __FILE__);

	if (!(dev->driver->driver_features & DRIVER_GEM)) {
		DRM_ERROR("does not support GEM.\n");
		return -ENODEV;
	}

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

	obj->filp->f_op = &exynos_drm_gem_fops;
	obj->filp->private_data = obj;

	addr = vm_mmap(obj->filp, 0, args->size,
			PROT_READ | PROT_WRITE, MAP_SHARED, 0);

	drm_gem_object_unreference_unlocked(obj);

	if (IS_ERR((void *)addr))
		return PTR_ERR((void *)addr);

	args->mapped = addr;

	DRM_DEBUG_KMS("mapped = 0x%lx\n", (unsigned long)args->mapped);

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

int exynos_drm_gem_init_object(struct drm_gem_object *obj)
{
	DRM_DEBUG_KMS("%s\n", __FILE__);

	return 0;
}

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;

	DRM_DEBUG_KMS("%s\n", __FILE__);

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

	if (obj->import_attach)
		drm_prime_gem_destroy(obj, buf->sgt);

	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;

	DRM_DEBUG_KMS("%s\n", __FILE__);

	/*
	 * alocate 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;

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

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;

	DRM_DEBUG_KMS("%s\n", __FILE__);

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

	if (!obj->map_list.map) {
		ret = drm_gem_create_mmap_offset(obj);
		if (ret)
			goto out;
	}

	*offset = (u64)obj->map_list.hash.key << PAGE_SHIFT;
	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_dumb_destroy(struct drm_file *file_priv,
				struct drm_device *dev,
				unsigned int handle)
{
	int ret;

	DRM_DEBUG_KMS("%s\n", __FILE__);

	/*
	 * obj->refcount and obj->handle_count are decreased and
	 * if both them are 0 then exynos_drm_gem_free_object()
	 * would be called by callback to release resources.
	 */
	ret = drm_gem_handle_delete(file_priv, handle);
	if (ret < 0) {
		DRM_ERROR("failed to delete drm_gem_handle.\n");
		return ret;
	}

	return 0;
}

int exynos_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	struct drm_gem_object *obj = vma->vm_private_data;
	struct drm_device *dev = obj->dev;
	unsigned long f_vaddr;
	pgoff_t page_offset;
	int ret;

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

	mutex_lock(&dev->struct_mutex);

	ret = exynos_drm_gem_map_buf(obj, vma, f_vaddr, page_offset);
	if (ret < 0)
		DRM_ERROR("failed to map a buffer with user.\n");

	mutex_unlock(&dev->struct_mutex);

	return convert_to_vm_err_msg(ret);
}

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;

	DRM_DEBUG_KMS("%s\n", __FILE__);

	/* 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);

	ret = check_gem_flags(exynos_gem_obj->flags);
	if (ret) {
		drm_gem_vm_close(vma);
		drm_gem_free_mmap_offset(obj);
		return ret;
	}

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

	update_vm_cache_attr(exynos_gem_obj, vma);

	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	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a
	7	* copy of this software and associated documentation files (the "Software"),
	8	* to deal in the Software without restriction, including without limitation
	9	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	10	* and/or sell copies of the Software, and to permit persons to whom the
	11	* Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice (including the next
	14	* paragraph) shall be included in all copies or substantial portions of the
	15	* Software.
	16	*
	17	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	18	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	19	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	20	* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	21	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	22	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	23	* OTHER DEALINGS IN THE SOFTWARE.
	24	*/
	25
760285e7	26	#include <drm/drmP.h>
1c248b7d	27
2b35892e	28	#include <linux/shmem_fs.h>
1c248b7d ID	29	#include <drm/exynos_drm.h>
	30
	31	#include "exynos_drm_drv.h"
	32	#include "exynos_drm_gem.h"
	33	#include "exynos_drm_buf.h"
	34
	35	static unsigned int convert_to_vm_err_msg(int msg)
	36	{
	37	unsigned int out_msg;
	38
	39	switch (msg) {
	40	case 0:
	41	case -ERESTARTSYS:
	42	case -EINTR:
	43	out_msg = VM_FAULT_NOPAGE;
	44	break;
	45
	46	case -ENOMEM:
	47	out_msg = VM_FAULT_OOM;
	48	break;
	49
	50	default:
	51	out_msg = VM_FAULT_SIGBUS;
	52	break;
	53	}
	54
	55	return out_msg;
	56	}
	57
dcf9af82	58	static int check_gem_flags(unsigned int flags)
2b35892e	59	{
dcf9af82 ID	60	if (flags & ~(EXYNOS_BO_MASK)) {
	61	DRM_ERROR("invalid flags.\n");
	62	return -EINVAL;
	63	}
	64
	65	return 0;
	66	}
	67
c01d73fa ID	68	static void update_vm_cache_attr(struct exynos_drm_gem_obj *obj,
	69	struct vm_area_struct *vma)
	70	{
	71	DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);
	72
	73	/* non-cachable as default. */
	74	if (obj->flags & EXYNOS_BO_CACHABLE)
	75	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
	76	else if (obj->flags & EXYNOS_BO_WC)
	77	vma->vm_page_prot =
	78	pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
	79	else
	80	vma->vm_page_prot =
	81	pgprot_noncached(vm_get_page_prot(vma->vm_flags));
	82	}
	83
dcf9af82 ID	84	static unsigned long roundup_gem_size(unsigned long size, unsigned int flags)
dcf9af82 ID	85	{
0519f9a1	86	/* TODO */
2b35892e	87
0519f9a1	88	return roundup(size, PAGE_SIZE);
2b35892e ID	89	}
2b35892e ID	90
0519f9a1	91	static int exynos_drm_gem_map_buf(struct drm_gem_object *obj,
2b35892e ID	92	struct vm_area_struct *vma,
	93	unsigned long f_vaddr,
	94	pgoff_t page_offset)
	95	{
	96	struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
	97	struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
4ddc404b	98	struct scatterlist *sgl;
2b35892e	99	unsigned long pfn;
4ddc404b	100	int i;
2b35892e ID	101
2b35892e ID	102	if (exynos_gem_obj->flags & EXYNOS_BO_NONCONTIG) {
4ddc404b RS	103	if (!buf->sgt)
	104	return -EINTR;
	105
	106	sgl = buf->sgt->sgl;
	107	for_each_sg(buf->sgt->sgl, sgl, buf->sgt->nents, i) {
	108	if (!sgl) {
	109	DRM_ERROR("invalid SG table\n");
	110	return -EINTR;
	111	}
	112	if (page_offset < (sgl->length >> PAGE_SHIFT))
	113	break;
	114	page_offset -= (sgl->length >> PAGE_SHIFT);
	115	}
	116
	117	if (i >= buf->sgt->nents) {
	118	DRM_ERROR("invalid page offset\n");
	119	return -EINVAL;
	120	}
	121
	122	pfn = __phys_to_pfn(sg_phys(sgl)) + page_offset;
	123	} else {
2b35892e ID	124	if (!buf->pages)
	125	return -EINTR;
	126
4ddc404b RS	127	pfn = page_to_pfn(buf->pages[0]) + page_offset;
4ddc404b RS	128	}
2b35892e ID	129
	130	return vm_insert_mixed(vma, f_vaddr, pfn);
	131	}
	132
2364839a JS	133	static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
	134	struct drm_file *file_priv,
	135	unsigned int *handle)
1c248b7d	136	{
1c248b7d ID	137	int ret;
1c248b7d ID	138
1c248b7d ID	139	/*
	140	* allocate a id of idr table where the obj is registered
	141	* and handle has the id what user can see.
	142	*/
	143	ret = drm_gem_handle_create(file_priv, obj, handle);
	144	if (ret)
2364839a	145	return ret;
1c248b7d ID	146
	147	DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);
	148
	149	/* drop reference from allocate - handle holds it now. */
	150	drm_gem_object_unreference_unlocked(obj);
	151
2364839a JS	152	return 0;
	153	}
	154
	155	void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
	156	{
	157	struct drm_gem_object *obj;
c01d73fa	158	struct exynos_drm_gem_buf *buf;
2364839a JS	159
	160	DRM_DEBUG_KMS("%s\n", __FILE__);
	161
2364839a	162	obj = &exynos_gem_obj->base;
c01d73fa	163	buf = exynos_gem_obj->buffer;
2364839a JS	164
2364839a JS	165	DRM_DEBUG_KMS("handle count = %d\n", atomic_read(&obj->handle_count));
1c248b7d	166
c374e731 ID	167	/*
	168	* do not release memory region from exporter.
	169	*
	170	* the region will be released by exporter
	171	* once dmabuf's refcount becomes 0.
	172	*/
	173	if (obj->import_attach)
	174	goto out;
	175
0519f9a1	176	exynos_drm_free_buf(obj->dev, exynos_gem_obj->flags, buf);
2b35892e	177
c374e731	178	out:
c01d73fa	179	exynos_drm_fini_buf(obj->dev, buf);
2b35892e	180	exynos_gem_obj->buffer = NULL;
2364839a JS	181
	182	if (obj->map_list.map)
	183	drm_gem_free_mmap_offset(obj);
	184
	185	/* release file pointer to gem object. */
1c248b7d ID	186	drm_gem_object_release(obj);
1c248b7d ID	187
1c248b7d	188	kfree(exynos_gem_obj);
2b35892e	189	exynos_gem_obj = NULL;
2364839a JS	190	}
2364839a JS	191
b2df26c1	192	struct exynos_drm_gem_obj exynos_drm_gem_init(struct drm_device dev,
2364839a JS	193	unsigned long size)
	194	{
	195	struct exynos_drm_gem_obj *exynos_gem_obj;
	196	struct drm_gem_object *obj;
	197	int ret;
	198
	199	exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
	200	if (!exynos_gem_obj) {
	201	DRM_ERROR("failed to allocate exynos gem object\n");
	202	return NULL;
	203	}
	204
2b35892e	205	exynos_gem_obj->size = size;
2364839a JS	206	obj = &exynos_gem_obj->base;
	207
	208	ret = drm_gem_object_init(dev, obj, size);
	209	if (ret < 0) {
	210	DRM_ERROR("failed to initialize gem object\n");
	211	kfree(exynos_gem_obj);
	212	return NULL;
	213	}
	214
	215	DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
	216
	217	return exynos_gem_obj;
1c248b7d ID	218	}
1c248b7d ID	219
f088d5a9	220	struct exynos_drm_gem_obj exynos_drm_gem_create(struct drm_device dev,
2b35892e ID	221	unsigned int flags,
2b35892e ID	222	unsigned long size)
f088d5a9	223	{
2364839a	224	struct exynos_drm_gem_obj *exynos_gem_obj;
2b35892e ID	225	struct exynos_drm_gem_buf *buf;
2b35892e ID	226	int ret;
f088d5a9	227
dcf9af82 ID	228	if (!size) {
	229	DRM_ERROR("invalid size.\n");
	230	return ERR_PTR(-EINVAL);
	231	}
	232
	233	size = roundup_gem_size(size, flags);
	234	DRM_DEBUG_KMS("%s\n", __FILE__);
f088d5a9	235
dcf9af82 ID	236	ret = check_gem_flags(flags);
	237	if (ret)
	238	return ERR_PTR(ret);
2b35892e ID	239
	240	buf = exynos_drm_init_buf(dev, size);
	241	if (!buf)
ee5e770e	242	return ERR_PTR(-ENOMEM);
f088d5a9	243
2364839a JS	244	exynos_gem_obj = exynos_drm_gem_init(dev, size);
2364839a JS	245	if (!exynos_gem_obj) {
2b35892e	246	ret = -ENOMEM;
dcf9af82	247	goto err_fini_buf;
f088d5a9 ID	248	}
f088d5a9 ID	249
2b35892e ID	250	exynos_gem_obj->buffer = buf;
	251
	252	/* set memory type and cache attribute from user side. */
	253	exynos_gem_obj->flags = flags;
	254
0519f9a1 ID	255	ret = exynos_drm_alloc_buf(dev, buf, flags);
	256	if (ret < 0) {
	257	drm_gem_object_release(&exynos_gem_obj->base);
	258	goto err_fini_buf;
2b35892e	259	}
f088d5a9 ID	260
f088d5a9 ID	261	return exynos_gem_obj;
dcf9af82 ID	262
dcf9af82 ID	263	err_fini_buf:
2b35892e ID	264	exynos_drm_fini_buf(dev, buf);
2b35892e ID	265	return ERR_PTR(ret);
f088d5a9 ID	266	}
f088d5a9 ID	267
1c248b7d	268	int exynos_drm_gem_create_ioctl(struct drm_device dev, void data,
ee5e770e	269	struct drm_file *file_priv)
1c248b7d ID	270	{
1c248b7d ID	271	struct drm_exynos_gem_create *args = data;
ee5e770e	272	struct exynos_drm_gem_obj *exynos_gem_obj;
2364839a	273	int ret;
1c248b7d	274
f088d5a9	275	DRM_DEBUG_KMS("%s\n", __FILE__);
1c248b7d	276
2b35892e	277	exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
1c248b7d ID	278	if (IS_ERR(exynos_gem_obj))
	279	return PTR_ERR(exynos_gem_obj);
	280
2364839a JS	281	ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
	282	&args->handle);
	283	if (ret) {
	284	exynos_drm_gem_destroy(exynos_gem_obj);
	285	return ret;
	286	}
	287
1c248b7d ID	288	return 0;
	289	}
	290
d87342c1	291	dma_addr_t exynos_drm_gem_get_dma_addr(struct drm_device dev,
f0b1bda7	292	unsigned int gem_handle,
d87342c1	293	struct drm_file *filp)
f0b1bda7 ID	294	{
	295	struct exynos_drm_gem_obj *exynos_gem_obj;
	296	struct drm_gem_object *obj;
	297
d87342c1	298	obj = drm_gem_object_lookup(dev, filp, gem_handle);
f0b1bda7 ID	299	if (!obj) {
	300	DRM_ERROR("failed to lookup gem object.\n");
	301	return ERR_PTR(-EINVAL);
	302	}
	303
	304	exynos_gem_obj = to_exynos_gem_obj(obj);
	305
f0b1bda7 ID	306	return &exynos_gem_obj->buffer->dma_addr;
	307	}
	308
	309	void exynos_drm_gem_put_dma_addr(struct drm_device *dev,
	310	unsigned int gem_handle,
d87342c1	311	struct drm_file *filp)
f0b1bda7 ID	312	{
	313	struct exynos_drm_gem_obj *exynos_gem_obj;
	314	struct drm_gem_object *obj;
	315
d87342c1	316	obj = drm_gem_object_lookup(dev, filp, gem_handle);
f0b1bda7 ID	317	if (!obj) {
	318	DRM_ERROR("failed to lookup gem object.\n");
	319	return;
	320	}
	321
	322	exynos_gem_obj = to_exynos_gem_obj(obj);
	323
f0b1bda7 ID	324	drm_gem_object_unreference_unlocked(obj);
	325
	326	/*
	327	* decrease obj->refcount one more time because we has already
	328	* increased it at exynos_drm_gem_get_dma_addr().
	329	*/
	330	drm_gem_object_unreference_unlocked(obj);
	331	}
	332
1c248b7d	333	int exynos_drm_gem_map_offset_ioctl(struct drm_device dev, void data,
ee5e770e	334	struct drm_file *file_priv)
1c248b7d ID	335	{
	336	struct drm_exynos_gem_map_off *args = data;
	337
	338	DRM_DEBUG_KMS("%s\n", __FILE__);
	339
	340	DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
	341	args->handle, (unsigned long)args->offset);
	342
	343	if (!(dev->driver->driver_features & DRIVER_GEM)) {
	344	DRM_ERROR("does not support GEM.\n");
	345	return -ENODEV;
	346	}
	347
	348	return exynos_drm_gem_dumb_map_offset(file_priv, dev, args->handle,
	349	&args->offset);
	350	}
	351
	352	static int exynos_drm_gem_mmap_buffer(struct file *filp,
ee5e770e	353	struct vm_area_struct *vma)
1c248b7d ID	354	{
	355	struct drm_gem_object *obj = filp->private_data;
	356	struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
2c871127	357	struct exynos_drm_gem_buf *buffer;
0519f9a1	358	unsigned long vm_size;
1c248b7d ID	359
	360	DRM_DEBUG_KMS("%s\n", __FILE__);
	361
314e51b9	362	vma->vm_flags \|= VM_IO \| VM_DONTEXPAND \| VM_DONTDUMP;
1c248b7d	363
c01d73fa	364	update_vm_cache_attr(exynos_gem_obj, vma);
1c248b7d	365
0519f9a1	366	vm_size = vma->vm_end - vma->vm_start;
2b35892e	367
1c248b7d	368	/*
2c871127	369	* a buffer contains information to physically continuous memory
1c248b7d ID	370	* allocated by user request or at framebuffer creation.
1c248b7d ID	371	*/
2c871127	372	buffer = exynos_gem_obj->buffer;
1c248b7d ID	373
1c248b7d ID	374	/* check if user-requested size is valid. */
2c871127	375	if (vm_size > buffer->size)
1c248b7d ID	376	return -EINVAL;
1c248b7d ID	377
0519f9a1 ID	378	return dma_mmap_attrs(obj->dev->dev, vma, buffer->kvaddr,
	379	buffer->dma_addr, buffer->size,
	380	&buffer->dma_attrs);
1c248b7d ID	381	}
	382
	383	static const struct file_operations exynos_drm_gem_fops = {
	384	.mmap = exynos_drm_gem_mmap_buffer,
	385	};
	386
	387	int exynos_drm_gem_mmap_ioctl(struct drm_device dev, void data,
ee5e770e	388	struct drm_file *file_priv)
1c248b7d ID	389	{
	390	struct drm_exynos_gem_mmap *args = data;
	391	struct drm_gem_object *obj;
	392	unsigned int addr;
	393
	394	DRM_DEBUG_KMS("%s\n", __FILE__);
	395
	396	if (!(dev->driver->driver_features & DRIVER_GEM)) {
	397	DRM_ERROR("does not support GEM.\n");
	398	return -ENODEV;
	399	}
	400
	401	obj = drm_gem_object_lookup(dev, file_priv, args->handle);
	402	if (!obj) {
	403	DRM_ERROR("failed to lookup gem object.\n");
	404	return -EINVAL;
	405	}
	406
	407	obj->filp->f_op = &exynos_drm_gem_fops;
	408	obj->filp->private_data = obj;
	409
6be5ceb0	410	addr = vm_mmap(obj->filp, 0, args->size,
1c248b7d	411	PROT_READ \| PROT_WRITE, MAP_SHARED, 0);
1c248b7d ID	412
	413	drm_gem_object_unreference_unlocked(obj);
	414
	415	if (IS_ERR((void *)addr))
	416	return PTR_ERR((void *)addr);
	417
	418	args->mapped = addr;
	419
	420	DRM_DEBUG_KMS("mapped = 0x%lx\n", (unsigned long)args->mapped);
	421
	422	return 0;
	423	}
	424
40cd7e0c ID	425	int exynos_drm_gem_get_ioctl(struct drm_device dev, void data,
	426	struct drm_file *file_priv)
	427	{ struct exynos_drm_gem_obj *exynos_gem_obj;
	428	struct drm_exynos_gem_info *args = data;
	429	struct drm_gem_object *obj;
	430
	431	mutex_lock(&dev->struct_mutex);
	432
	433	obj = drm_gem_object_lookup(dev, file_priv, args->handle);
	434	if (!obj) {
	435	DRM_ERROR("failed to lookup gem object.\n");
	436	mutex_unlock(&dev->struct_mutex);
	437	return -EINVAL;
	438	}
	439
	440	exynos_gem_obj = to_exynos_gem_obj(obj);
	441
	442	args->flags = exynos_gem_obj->flags;
	443	args->size = exynos_gem_obj->size;
	444
	445	drm_gem_object_unreference(obj);
	446	mutex_unlock(&dev->struct_mutex);
	447
	448	return 0;
	449	}
	450
1c248b7d ID	451	int exynos_drm_gem_init_object(struct drm_gem_object *obj)
	452	{
	453	DRM_DEBUG_KMS("%s\n", __FILE__);
	454
	455	return 0;
	456	}
	457
ee5e770e	458	void exynos_drm_gem_free_object(struct drm_gem_object *obj)
1c248b7d	459	{
b2df26c1 ID	460	struct exynos_drm_gem_obj *exynos_gem_obj;
	461	struct exynos_drm_gem_buf *buf;
	462
1c248b7d ID	463	DRM_DEBUG_KMS("%s\n", __FILE__);
1c248b7d ID	464
b2df26c1 ID	465	exynos_gem_obj = to_exynos_gem_obj(obj);
	466	buf = exynos_gem_obj->buffer;
	467
	468	if (obj->import_attach)
	469	drm_prime_gem_destroy(obj, buf->sgt);
	470
2364839a	471	exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
1c248b7d ID	472	}
	473
	474	int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
ee5e770e JS	475	struct drm_device *dev,
ee5e770e JS	476	struct drm_mode_create_dumb *args)
1c248b7d ID	477	{
1c248b7d ID	478	struct exynos_drm_gem_obj *exynos_gem_obj;
2364839a	479	int ret;
1c248b7d ID	480
	481	DRM_DEBUG_KMS("%s\n", __FILE__);
	482
	483	/*
	484	* alocate memory to be used for framebuffer.
	485	* - this callback would be called by user application
	486	* with DRM_IOCTL_MODE_CREATE_DUMB command.
	487	*/
	488
3fd6b694	489	args->pitch = args->width * ((args->bpp + 7) / 8);
7da5907c	490	args->size = args->pitch * args->height;
1c248b7d	491
2b35892e	492	exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
1c248b7d ID	493	if (IS_ERR(exynos_gem_obj))
	494	return PTR_ERR(exynos_gem_obj);
	495
2364839a JS	496	ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
	497	&args->handle);
	498	if (ret) {
	499	exynos_drm_gem_destroy(exynos_gem_obj);
	500	return ret;
	501	}
	502
1c248b7d ID	503	return 0;
	504	}
	505
	506	int exynos_drm_gem_dumb_map_offset(struct drm_file *file_priv,
ee5e770e JS	507	struct drm_device *dev, uint32_t handle,
ee5e770e JS	508	uint64_t *offset)
1c248b7d	509	{
1c248b7d	510	struct drm_gem_object *obj;
2d91cf17	511	int ret = 0;
1c248b7d ID	512
	513	DRM_DEBUG_KMS("%s\n", __FILE__);
	514
	515	mutex_lock(&dev->struct_mutex);
	516
	517	/*
	518	* get offset of memory allocated for drm framebuffer.
	519	* - this callback would be called by user application
	520	* with DRM_IOCTL_MODE_MAP_DUMB command.
	521	*/
	522
	523	obj = drm_gem_object_lookup(dev, file_priv, handle);
	524	if (!obj) {
	525	DRM_ERROR("failed to lookup gem object.\n");
2d91cf17 JS	526	ret = -EINVAL;
2d91cf17 JS	527	goto unlock;
1c248b7d ID	528	}
1c248b7d ID	529
6037bafa LP	530	if (!obj->map_list.map) {
6037bafa LP	531	ret = drm_gem_create_mmap_offset(obj);
2d91cf17 JS	532	if (ret)
	533	goto out;
	534	}
1c248b7d	535
6037bafa	536	*offset = (u64)obj->map_list.hash.key << PAGE_SHIFT;
1c248b7d ID	537	DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
1c248b7d ID	538
2d91cf17 JS	539	out:
	540	drm_gem_object_unreference(obj);
	541	unlock:
1c248b7d	542	mutex_unlock(&dev->struct_mutex);
2d91cf17	543	return ret;
1c248b7d ID	544	}
1c248b7d ID	545
ee5e770e JS	546	int exynos_drm_gem_dumb_destroy(struct drm_file *file_priv,
	547	struct drm_device *dev,
	548	unsigned int handle)
	549	{
	550	int ret;
	551
	552	DRM_DEBUG_KMS("%s\n", __FILE__);
	553
	554	/*
	555	* obj->refcount and obj->handle_count are decreased and
	556	* if both them are 0 then exynos_drm_gem_free_object()
	557	* would be called by callback to release resources.
	558	*/
	559	ret = drm_gem_handle_delete(file_priv, handle);
	560	if (ret < 0) {
	561	DRM_ERROR("failed to delete drm_gem_handle.\n");
	562	return ret;
	563	}
	564
	565	return 0;
	566	}
	567
1c248b7d ID	568	int exynos_drm_gem_fault(struct vm_area_struct vma, struct vm_fault vmf)
	569	{
	570	struct drm_gem_object *obj = vma->vm_private_data;
1c248b7d	571	struct drm_device *dev = obj->dev;
2b35892e	572	unsigned long f_vaddr;
1c248b7d ID	573	pgoff_t page_offset;
	574	int ret;
	575
	576	page_offset = ((unsigned long)vmf->virtual_address -
	577	vma->vm_start) >> PAGE_SHIFT;
2b35892e	578	f_vaddr = (unsigned long)vmf->virtual_address;
1c248b7d ID	579
	580	mutex_lock(&dev->struct_mutex);
	581
0519f9a1	582	ret = exynos_drm_gem_map_buf(obj, vma, f_vaddr, page_offset);
2b35892e	583	if (ret < 0)
0519f9a1	584	DRM_ERROR("failed to map a buffer with user.\n");
1c248b7d ID	585
	586	mutex_unlock(&dev->struct_mutex);
	587
	588	return convert_to_vm_err_msg(ret);
	589	}
	590
	591	int exynos_drm_gem_mmap(struct file filp, struct vm_area_struct vma)
	592	{
c01d73fa ID	593	struct exynos_drm_gem_obj *exynos_gem_obj;
c01d73fa ID	594	struct drm_gem_object *obj;
1c248b7d ID	595	int ret;
	596
	597	DRM_DEBUG_KMS("%s\n", __FILE__);
	598
	599	/* set vm_area_struct. */
	600	ret = drm_gem_mmap(filp, vma);
	601	if (ret < 0) {
	602	DRM_ERROR("failed to mmap.\n");
	603	return ret;
	604	}
	605
c01d73fa ID	606	obj = vma->vm_private_data;
	607	exynos_gem_obj = to_exynos_gem_obj(obj);
	608
	609	ret = check_gem_flags(exynos_gem_obj->flags);
	610	if (ret) {
	611	drm_gem_vm_close(vma);
	612	drm_gem_free_mmap_offset(obj);
	613	return ret;
	614	}
	615
1c248b7d ID	616	vma->vm_flags &= ~VM_PFNMAP;
	617	vma->vm_flags \|= VM_MIXEDMAP;
	618
c01d73fa ID	619	update_vm_cache_attr(exynos_gem_obj, vma);
c01d73fa ID	620
1c248b7d ID	621	return ret;
1c248b7d ID	622	}