[mirror_ubuntu-hirsute-kernel.git] / drivers / gpu / drm / vgem / vgem_drv.c

/*
 * Copyright 2011 Red Hat, Inc.
 * Copyright © 2014 The Chromium OS Authors
 *
 * 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
 * on the rights to use, copy, modify, merge, publish, distribute, sub
 * license, and/or sell copies of the Software, and to permit persons to whom
 * them 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 MERCHANTIBILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS 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.
 *
 * Authors:
 *	Adam Jackson <ajax@redhat.com>
 *	Ben Widawsky <ben@bwidawsk.net>
 */

/**
 * This is vgem, a (non-hardware-backed) GEM service.  This is used by Mesa's
 * software renderer and the X server for efficient buffer sharing.
 */

#include <linux/dma-buf.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/shmem_fs.h>
#include <linux/vmalloc.h>

#include <drm/drm_drv.h>
#include <drm/drm_file.h>
#include <drm/drm_ioctl.h>
#include <drm/drm_prime.h>

#include "vgem_drv.h"

#define DRIVER_NAME	"vgem"
#define DRIVER_DESC	"Virtual GEM provider"
#define DRIVER_DATE	"20120112"
#define DRIVER_MAJOR	1
#define DRIVER_MINOR	0

static struct vgem_device {
	struct drm_device drm;
	struct platform_device *platform;
} *vgem_device;

static void vgem_gem_free_object(struct drm_gem_object *obj)
{
	struct drm_vgem_gem_object *vgem_obj = to_vgem_bo(obj);

	kvfree(vgem_obj->pages);
	mutex_destroy(&vgem_obj->pages_lock);

	if (obj->import_attach)
		drm_prime_gem_destroy(obj, vgem_obj->table);

	drm_gem_object_release(obj);
	kfree(vgem_obj);
}

static vm_fault_t vgem_gem_fault(struct vm_fault *vmf)
{
	struct vm_area_struct *vma = vmf->vma;
	struct drm_vgem_gem_object *obj = vma->vm_private_data;
	/* We don't use vmf->pgoff since that has the fake offset */
	unsigned long vaddr = vmf->address;
	vm_fault_t ret = VM_FAULT_SIGBUS;
	loff_t num_pages;
	pgoff_t page_offset;
	page_offset = (vaddr - vma->vm_start) >> PAGE_SHIFT;

	num_pages = DIV_ROUND_UP(obj->base.size, PAGE_SIZE);

	if (page_offset >= num_pages)
		return VM_FAULT_SIGBUS;

	mutex_lock(&obj->pages_lock);
	if (obj->pages) {
		get_page(obj->pages[page_offset]);
		vmf->page = obj->pages[page_offset];
		ret = 0;
	}
	mutex_unlock(&obj->pages_lock);
	if (ret) {
		struct page *page;

		page = shmem_read_mapping_page(
					file_inode(obj->base.filp)->i_mapping,
					page_offset);
		if (!IS_ERR(page)) {
			vmf->page = page;
			ret = 0;
		} else switch (PTR_ERR(page)) {
			case -ENOSPC:
			case -ENOMEM:
				ret = VM_FAULT_OOM;
				break;
			case -EBUSY:
				ret = VM_FAULT_RETRY;
				break;
			case -EFAULT:
			case -EINVAL:
				ret = VM_FAULT_SIGBUS;
				break;
			default:
				WARN_ON(PTR_ERR(page));
				ret = VM_FAULT_SIGBUS;
				break;
		}

	}
	return ret;
}

static const struct vm_operations_struct vgem_gem_vm_ops = {
	.fault = vgem_gem_fault,
	.open = drm_gem_vm_open,
	.close = drm_gem_vm_close,
};

static int vgem_open(struct drm_device *dev, struct drm_file *file)
{
	struct vgem_file *vfile;
	int ret;

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

	file->driver_priv = vfile;

	ret = vgem_fence_open(vfile);
	if (ret) {
		kfree(vfile);
		return ret;
	}

	return 0;
}

static void vgem_postclose(struct drm_device *dev, struct drm_file *file)
{
	struct vgem_file *vfile = file->driver_priv;

	vgem_fence_close(vfile);
	kfree(vfile);
}

static struct drm_vgem_gem_object *__vgem_gem_create(struct drm_device *dev,
						unsigned long size)
{
	struct drm_vgem_gem_object *obj;
	int ret;

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

	ret = drm_gem_object_init(dev, &obj->base, roundup(size, PAGE_SIZE));
	if (ret) {
		kfree(obj);
		return ERR_PTR(ret);
	}

	mutex_init(&obj->pages_lock);

	return obj;
}

static void __vgem_gem_destroy(struct drm_vgem_gem_object *obj)
{
	drm_gem_object_release(&obj->base);
	kfree(obj);
}

static struct drm_gem_object *vgem_gem_create(struct drm_device *dev,
					      struct drm_file *file,
					      unsigned int *handle,
					      unsigned long size)
{
	struct drm_vgem_gem_object *obj;
	int ret;

	obj = __vgem_gem_create(dev, size);
	if (IS_ERR(obj))
		return ERR_CAST(obj);

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

	return &obj->base;
}

static int vgem_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
				struct drm_mode_create_dumb *args)
{
	struct drm_gem_object *gem_object;
	u64 pitch, size;

	pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
	size = args->height * pitch;
	if (size == 0)
		return -EINVAL;

	gem_object = vgem_gem_create(dev, file, &args->handle, size);
	if (IS_ERR(gem_object))
		return PTR_ERR(gem_object);

	args->size = gem_object->size;
	args->pitch = pitch;

	drm_gem_object_put_unlocked(gem_object);

	DRM_DEBUG("Created object of size %llu\n", args->size);

	return 0;
}

static int vgem_gem_dumb_map(struct drm_file *file, struct drm_device *dev,
			     uint32_t handle, uint64_t *offset)
{
	struct drm_gem_object *obj;
	int ret;

	obj = drm_gem_object_lookup(file, handle);
	if (!obj)
		return -ENOENT;

	if (!obj->filp) {
		ret = -EINVAL;
		goto unref;
	}

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

	*offset = drm_vma_node_offset_addr(&obj->vma_node);
unref:
	drm_gem_object_put_unlocked(obj);

	return ret;
}

static struct drm_ioctl_desc vgem_ioctls[] = {
	DRM_IOCTL_DEF_DRV(VGEM_FENCE_ATTACH, vgem_fence_attach_ioctl, DRM_RENDER_ALLOW),
	DRM_IOCTL_DEF_DRV(VGEM_FENCE_SIGNAL, vgem_fence_signal_ioctl, DRM_RENDER_ALLOW),
};

static int vgem_mmap(struct file *filp, struct vm_area_struct *vma)
{
	unsigned long flags = vma->vm_flags;
	int ret;

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

	/* Keep the WC mmaping set by drm_gem_mmap() but our pages
	 * are ordinary and not special.
	 */
	vma->vm_flags = flags | VM_DONTEXPAND | VM_DONTDUMP;
	return 0;
}

static const struct file_operations vgem_driver_fops = {
	.owner		= THIS_MODULE,
	.open		= drm_open,
	.mmap		= vgem_mmap,
	.poll		= drm_poll,
	.read		= drm_read,
	.unlocked_ioctl = drm_ioctl,
	.compat_ioctl	= drm_compat_ioctl,
	.release	= drm_release,
};

static struct page **vgem_pin_pages(struct drm_vgem_gem_object *bo)
{
	mutex_lock(&bo->pages_lock);
	if (bo->pages_pin_count++ == 0) {
		struct page **pages;

		pages = drm_gem_get_pages(&bo->base);
		if (IS_ERR(pages)) {
			bo->pages_pin_count--;
			mutex_unlock(&bo->pages_lock);
			return pages;
		}

		bo->pages = pages;
	}
	mutex_unlock(&bo->pages_lock);

	return bo->pages;
}

static void vgem_unpin_pages(struct drm_vgem_gem_object *bo)
{
	mutex_lock(&bo->pages_lock);
	if (--bo->pages_pin_count == 0) {
		drm_gem_put_pages(&bo->base, bo->pages, true, true);
		bo->pages = NULL;
	}
	mutex_unlock(&bo->pages_lock);
}

static int vgem_prime_pin(struct drm_gem_object *obj)
{
	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);
	long n_pages = obj->size >> PAGE_SHIFT;
	struct page **pages;

	pages = vgem_pin_pages(bo);
	if (IS_ERR(pages))
		return PTR_ERR(pages);

	/* Flush the object from the CPU cache so that importers can rely
	 * on coherent indirect access via the exported dma-address.
	 */
	drm_clflush_pages(pages, n_pages);

	return 0;
}

static void vgem_prime_unpin(struct drm_gem_object *obj)
{
	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);

	vgem_unpin_pages(bo);
}

static struct sg_table *vgem_prime_get_sg_table(struct drm_gem_object *obj)
{
	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);

	return drm_prime_pages_to_sg(bo->pages, bo->base.size >> PAGE_SHIFT);
}

static struct drm_gem_object* vgem_prime_import(struct drm_device *dev,
						struct dma_buf *dma_buf)
{
	struct vgem_device *vgem = container_of(dev, typeof(*vgem), drm);

	return drm_gem_prime_import_dev(dev, dma_buf, &vgem->platform->dev);
}

static struct drm_gem_object *vgem_prime_import_sg_table(struct drm_device *dev,
			struct dma_buf_attachment *attach, struct sg_table *sg)
{
	struct drm_vgem_gem_object *obj;
	int npages;

	obj = __vgem_gem_create(dev, attach->dmabuf->size);
	if (IS_ERR(obj))
		return ERR_CAST(obj);

	npages = PAGE_ALIGN(attach->dmabuf->size) / PAGE_SIZE;

	obj->table = sg;
	obj->pages = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
	if (!obj->pages) {
		__vgem_gem_destroy(obj);
		return ERR_PTR(-ENOMEM);
	}

	obj->pages_pin_count++; /* perma-pinned */
	drm_prime_sg_to_page_addr_arrays(obj->table, obj->pages, NULL,
					npages);
	return &obj->base;
}

static void *vgem_prime_vmap(struct drm_gem_object *obj)
{
	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);
	long n_pages = obj->size >> PAGE_SHIFT;
	struct page **pages;

	pages = vgem_pin_pages(bo);
	if (IS_ERR(pages))
		return NULL;

	return vmap(pages, n_pages, 0, pgprot_writecombine(PAGE_KERNEL));
}

static void vgem_prime_vunmap(struct drm_gem_object *obj, void *vaddr)
{
	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);

	vunmap(vaddr);
	vgem_unpin_pages(bo);
}

static int vgem_prime_mmap(struct drm_gem_object *obj,
			   struct vm_area_struct *vma)
{
	int ret;

	if (obj->size < vma->vm_end - vma->vm_start)
		return -EINVAL;

	if (!obj->filp)
		return -ENODEV;

	ret = call_mmap(obj->filp, vma);
	if (ret)
		return ret;

	fput(vma->vm_file);
	vma->vm_file = get_file(obj->filp);
	vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
	vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));

	return 0;
}

static void vgem_release(struct drm_device *dev)
{
	struct vgem_device *vgem = container_of(dev, typeof(*vgem), drm);

	platform_device_unregister(vgem->platform);
	drm_dev_fini(&vgem->drm);

	kfree(vgem);
}

static struct drm_driver vgem_driver = {
	.driver_features		= DRIVER_GEM | DRIVER_RENDER,
	.release			= vgem_release,
	.open				= vgem_open,
	.postclose			= vgem_postclose,
	.gem_free_object_unlocked	= vgem_gem_free_object,
	.gem_vm_ops			= &vgem_gem_vm_ops,
	.ioctls				= vgem_ioctls,
	.num_ioctls 			= ARRAY_SIZE(vgem_ioctls),
	.fops				= &vgem_driver_fops,

	.dumb_create			= vgem_gem_dumb_create,
	.dumb_map_offset		= vgem_gem_dumb_map,

	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
	.gem_prime_pin = vgem_prime_pin,
	.gem_prime_unpin = vgem_prime_unpin,
	.gem_prime_import = vgem_prime_import,
	.gem_prime_import_sg_table = vgem_prime_import_sg_table,
	.gem_prime_get_sg_table = vgem_prime_get_sg_table,
	.gem_prime_vmap = vgem_prime_vmap,
	.gem_prime_vunmap = vgem_prime_vunmap,
	.gem_prime_mmap = vgem_prime_mmap,

	.name	= DRIVER_NAME,
	.desc	= DRIVER_DESC,
	.date	= DRIVER_DATE,
	.major	= DRIVER_MAJOR,
	.minor	= DRIVER_MINOR,
};

static int __init vgem_init(void)
{
	int ret;

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

	vgem_device->platform =
		platform_device_register_simple("vgem", -1, NULL, 0);
	if (IS_ERR(vgem_device->platform)) {
		ret = PTR_ERR(vgem_device->platform);
		goto out_free;
	}

	dma_coerce_mask_and_coherent(&vgem_device->platform->dev,
				     DMA_BIT_MASK(64));
	ret = drm_dev_init(&vgem_device->drm, &vgem_driver,
			   &vgem_device->platform->dev);
	if (ret)
		goto out_unregister;

	/* Final step: expose the device/driver to userspace */
	ret  = drm_dev_register(&vgem_device->drm, 0);
	if (ret)
		goto out_fini;

	return 0;

out_fini:
	drm_dev_fini(&vgem_device->drm);
out_unregister:
	platform_device_unregister(vgem_device->platform);
out_free:
	kfree(vgem_device);
	return ret;
}

static void __exit vgem_exit(void)
{
	drm_dev_unregister(&vgem_device->drm);
	drm_dev_put(&vgem_device->drm);
}

module_init(vgem_init);
module_exit(vgem_exit);

MODULE_AUTHOR("Red Hat, Inc.");
MODULE_AUTHOR("Intel Corporation");
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL and additional rights");
Commit	Line	Data
502e95c6 ZR	1	/*
	2	* Copyright 2011 Red Hat, Inc.
	3	* Copyright © 2014 The Chromium OS Authors
	4	*
	5	* Permission is hereby granted, free of charge, to any person obtaining a
	6	* copy of this software and associated documentation files (the "Software")
	7	* to deal in the software without restriction, including without limitation
	8	* on the rights to use, copy, modify, merge, publish, distribute, sub
	9	* license, and/or sell copies of the Software, and to permit persons to whom
	10	* them Software is furnished to do so, subject to the following conditions:
	11	*
	12	* The above copyright notice and this permission notice (including the next
	13	* paragraph) shall be included in all copies or substantial portions of the
	14	* Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTIBILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER
	20	* IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF OR IN
	21	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	22	*
	23	* Authors:
	24	* Adam Jackson <ajax@redhat.com>
	25	* Ben Widawsky <ben@bwidawsk.net>
	26	*/
	27
	28	/**
	29	* This is vgem, a (non-hardware-backed) GEM service. This is used by Mesa's
	30	* software renderer and the X server for efficient buffer sharing.
	31	*/
	32
7b42a2f4	33	#include <linux/dma-buf.h>
502e95c6	34	#include <linux/module.h>
7b42a2f4	35	#include <linux/platform_device.h>
502e95c6	36	#include <linux/shmem_fs.h>
7b42a2f4 SR	37	#include <linux/vmalloc.h>
	38
	39	#include <drm/drm_drv.h>
	40	#include <drm/drm_file.h>
	41	#include <drm/drm_ioctl.h>
	42	#include <drm/drm_prime.h>
	43
502e95c6 ZR	44	#include "vgem_drv.h"
	45
	46	#define DRIVER_NAME "vgem"
	47	#define DRIVER_DESC "Virtual GEM provider"
	48	#define DRIVER_DATE "20120112"
	49	#define DRIVER_MAJOR 1
	50	#define DRIVER_MINOR 0
	51
315f0242 CW	52	static struct vgem_device {
	53	struct drm_device drm;
	54	struct platform_device *platform;
	55	} *vgem_device;
e2aff448	56
502e95c6 ZR	57	static void vgem_gem_free_object(struct drm_gem_object *obj)
	58	{
	59	struct drm_vgem_gem_object *vgem_obj = to_vgem_bo(obj);
	60
2098105e	61	kvfree(vgem_obj->pages);
71bb23c7	62	mutex_destroy(&vgem_obj->pages_lock);
af33a919 LA	63
	64	if (obj->import_attach)
	65	drm_prime_gem_destroy(obj, vgem_obj->table);
	66
502e95c6	67	drm_gem_object_release(obj);
502e95c6 ZR	68	kfree(vgem_obj);
	69	}
	70
1d1a4f6d	71	static vm_fault_t vgem_gem_fault(struct vm_fault *vmf)
502e95c6	72	{
11bac800	73	struct vm_area_struct *vma = vmf->vma;
502e95c6	74	struct drm_vgem_gem_object *obj = vma->vm_private_data;
502e95c6	75	/* We don't use vmf->pgoff since that has the fake offset */
1a29d85e	76	unsigned long vaddr = vmf->address;
1d1a4f6d	77	vm_fault_t ret = VM_FAULT_SIGBUS;
af33a919 LA	78	loff_t num_pages;
	79	pgoff_t page_offset;
	80	page_offset = (vaddr - vma->vm_start) >> PAGE_SHIFT;
	81
	82	num_pages = DIV_ROUND_UP(obj->base.size, PAGE_SIZE);
	83
de10eba0	84	if (page_offset >= num_pages)
af33a919 LA	85	return VM_FAULT_SIGBUS;
af33a919 LA	86
71bb23c7	87	mutex_lock(&obj->pages_lock);
af33a919 LA	88	if (obj->pages) {
	89	get_page(obj->pages[page_offset]);
	90	vmf->page = obj->pages[page_offset];
	91	ret = 0;
71bb23c7 CW	92	}
	93	mutex_unlock(&obj->pages_lock);
	94	if (ret) {
af33a919 LA	95	struct page *page;
	96
	97	page = shmem_read_mapping_page(
	98	file_inode(obj->base.filp)->i_mapping,
	99	page_offset);
	100	if (!IS_ERR(page)) {
	101	vmf->page = page;
	102	ret = 0;
	103	} else switch (PTR_ERR(page)) {
	104	case -ENOSPC:
	105	case -ENOMEM:
	106	ret = VM_FAULT_OOM;
	107	break;
	108	case -EBUSY:
	109	ret = VM_FAULT_RETRY;
	110	break;
	111	case -EFAULT:
	112	case -EINVAL:
	113	ret = VM_FAULT_SIGBUS;
	114	break;
	115	default:
	116	WARN_ON(PTR_ERR(page));
	117	ret = VM_FAULT_SIGBUS;
	118	break;
	119	}
	120
502e95c6	121	}
af33a919	122	return ret;
502e95c6 ZR	123	}
502e95c6 ZR	124
7cbea8dc	125	static const struct vm_operations_struct vgem_gem_vm_ops = {
502e95c6 ZR	126	.fault = vgem_gem_fault,
	127	.open = drm_gem_vm_open,
	128	.close = drm_gem_vm_close,
	129	};
	130
40777984 CW	131	static int vgem_open(struct drm_device dev, struct drm_file file)
	132	{
	133	struct vgem_file *vfile;
	134	int ret;
	135
	136	vfile = kzalloc(sizeof(*vfile), GFP_KERNEL);
	137	if (!vfile)
	138	return -ENOMEM;
	139
	140	file->driver_priv = vfile;
	141
	142	ret = vgem_fence_open(vfile);
	143	if (ret) {
	144	kfree(vfile);
	145	return ret;
	146	}
	147
	148	return 0;
	149	}
	150
098899fe	151	static void vgem_postclose(struct drm_device dev, struct drm_file file)
40777984 CW	152	{
	153	struct vgem_file *vfile = file->driver_priv;
	154
	155	vgem_fence_close(vfile);
	156	kfree(vfile);
	157	}
	158
af33a919 LA	159	static struct drm_vgem_gem_object __vgem_gem_create(struct drm_device dev,
af33a919 LA	160	unsigned long size)
502e95c6 ZR	161	{
502e95c6 ZR	162	struct drm_vgem_gem_object *obj;
5ba6c9ff	163	int ret;
502e95c6 ZR	164
	165	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
	166	if (!obj)
	167	return ERR_PTR(-ENOMEM);
	168
5ba6c9ff	169	ret = drm_gem_object_init(dev, &obj->base, roundup(size, PAGE_SIZE));
af33a919 LA	170	if (ret) {
	171	kfree(obj);
	172	return ERR_PTR(ret);
	173	}
	174
71bb23c7 CW	175	mutex_init(&obj->pages_lock);
71bb23c7 CW	176
af33a919 LA	177	return obj;
	178	}
	179
	180	static void __vgem_gem_destroy(struct drm_vgem_gem_object *obj)
	181	{
	182	drm_gem_object_release(&obj->base);
	183	kfree(obj);
	184	}
	185
	186	static struct drm_gem_object vgem_gem_create(struct drm_device dev,
	187	struct drm_file *file,
	188	unsigned int *handle,
	189	unsigned long size)
	190	{
	191	struct drm_vgem_gem_object *obj;
	192	int ret;
	193
	194	obj = __vgem_gem_create(dev, size);
	195	if (IS_ERR(obj))
	196	return ERR_CAST(obj);
502e95c6	197
5ba6c9ff	198	ret = drm_gem_handle_create(file, &obj->base, handle);
4b848f20 DV	199	if (ret) {
4b848f20 DV	200	drm_gem_object_put_unlocked(&obj->base);
21d2b122	201	return ERR_PTR(ret);
4b848f20	202	}
502e95c6	203
5ba6c9ff	204	return &obj->base;
502e95c6 ZR	205	}
	206
	207	static int vgem_gem_dumb_create(struct drm_file file, struct drm_device dev,
	208	struct drm_mode_create_dumb *args)
	209	{
	210	struct drm_gem_object *gem_object;
5ba6c9ff	211	u64 pitch, size;
502e95c6	212
5ba6c9ff	213	pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
502e95c6 ZR	214	size = args->height * pitch;
	215	if (size == 0)
	216	return -EINVAL;
	217
	218	gem_object = vgem_gem_create(dev, file, &args->handle, size);
5ba6c9ff	219	if (IS_ERR(gem_object))
502e95c6	220	return PTR_ERR(gem_object);
502e95c6 ZR	221
	222	args->size = gem_object->size;
	223	args->pitch = pitch;
	224
4b848f20 DV	225	drm_gem_object_put_unlocked(gem_object);
	226
	227	DRM_DEBUG("Created object of size %llu\n", args->size);
502e95c6 ZR	228
	229	return 0;
	230	}
	231
5ba6c9ff CW	232	static int vgem_gem_dumb_map(struct drm_file file, struct drm_device dev,
5ba6c9ff CW	233	uint32_t handle, uint64_t *offset)
502e95c6	234	{
502e95c6	235	struct drm_gem_object *obj;
5ba6c9ff	236	int ret;
502e95c6	237
a8ad0bd8	238	obj = drm_gem_object_lookup(file, handle);
0797ac61 DV	239	if (!obj)
0797ac61 DV	240	return -ENOENT;
502e95c6	241
5ba6c9ff CW	242	if (!obj->filp) {
	243	ret = -EINVAL;
	244	goto unref;
	245	}
	246
e34274fd DV	247	ret = drm_gem_create_mmap_offset(obj);
	248	if (ret)
	249	goto unref;
502e95c6	250
502e95c6	251	*offset = drm_vma_node_offset_addr(&obj->vma_node);
502e95c6	252	unref:
c54fd47a	253	drm_gem_object_put_unlocked(obj);
0797ac61	254
502e95c6 ZR	255	return ret;
	256	}
	257
502e95c6	258	static struct drm_ioctl_desc vgem_ioctls[] = {
0a0b65d8 EV	259	DRM_IOCTL_DEF_DRV(VGEM_FENCE_ATTACH, vgem_fence_attach_ioctl, DRM_RENDER_ALLOW),
0a0b65d8 EV	260	DRM_IOCTL_DEF_DRV(VGEM_FENCE_SIGNAL, vgem_fence_signal_ioctl, DRM_RENDER_ALLOW),
502e95c6 ZR	261	};
502e95c6 ZR	262
5ba6c9ff CW	263	static int vgem_mmap(struct file filp, struct vm_area_struct vma)
	264	{
	265	unsigned long flags = vma->vm_flags;
	266	int ret;
	267
	268	ret = drm_gem_mmap(filp, vma);
	269	if (ret)
	270	return ret;
	271
	272	/* Keep the WC mmaping set by drm_gem_mmap() but our pages
	273	* are ordinary and not special.
	274	*/
	275	vma->vm_flags = flags \| VM_DONTEXPAND \| VM_DONTDUMP;
	276	return 0;
	277	}
	278
502e95c6 ZR	279	static const struct file_operations vgem_driver_fops = {
	280	.owner = THIS_MODULE,
	281	.open = drm_open,
5ba6c9ff	282	.mmap = vgem_mmap,
502e95c6 ZR	283	.poll = drm_poll,
	284	.read = drm_read,
	285	.unlocked_ioctl = drm_ioctl,
ad364f44	286	.compat_ioctl = drm_compat_ioctl,
502e95c6 ZR	287	.release = drm_release,
	288	};
	289
71bb23c7 CW	290	static struct page *vgem_pin_pages(struct drm_vgem_gem_object bo)
	291	{
	292	mutex_lock(&bo->pages_lock);
	293	if (bo->pages_pin_count++ == 0) {
	294	struct page **pages;
	295
	296	pages = drm_gem_get_pages(&bo->base);
	297	if (IS_ERR(pages)) {
	298	bo->pages_pin_count--;
	299	mutex_unlock(&bo->pages_lock);
	300	return pages;
	301	}
	302
	303	bo->pages = pages;
	304	}
	305	mutex_unlock(&bo->pages_lock);
	306
	307	return bo->pages;
	308	}
	309
	310	static void vgem_unpin_pages(struct drm_vgem_gem_object *bo)
	311	{
	312	mutex_lock(&bo->pages_lock);
	313	if (--bo->pages_pin_count == 0) {
	314	drm_gem_put_pages(&bo->base, bo->pages, true, true);
	315	bo->pages = NULL;
	316	}
	317	mutex_unlock(&bo->pages_lock);
	318	}
	319
e6f15b76 CW	320	static int vgem_prime_pin(struct drm_gem_object *obj)
e6f15b76 CW	321	{
71bb23c7	322	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);
e6f15b76 CW	323	long n_pages = obj->size >> PAGE_SHIFT;
	324	struct page **pages;
	325
71bb23c7	326	pages = vgem_pin_pages(bo);
e6f15b76 CW	327	if (IS_ERR(pages))
	328	return PTR_ERR(pages);
	329
71bb23c7 CW	330	/* Flush the object from the CPU cache so that importers can rely
	331	* on coherent indirect access via the exported dma-address.
	332	*/
e6f15b76	333	drm_clflush_pages(pages, n_pages);
e6f15b76 CW	334
	335	return 0;
	336	}
	337
71bb23c7	338	static void vgem_prime_unpin(struct drm_gem_object *obj)
e6f15b76	339	{
71bb23c7	340	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);
e6f15b76	341
71bb23c7 CW	342	vgem_unpin_pages(bo);
71bb23c7 CW	343	}
e6f15b76	344
71bb23c7 CW	345	static struct sg_table vgem_prime_get_sg_table(struct drm_gem_object obj)
	346	{
	347	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);
e6f15b76	348
71bb23c7	349	return drm_prime_pages_to_sg(bo->pages, bo->base.size >> PAGE_SHIFT);
e6f15b76 CW	350	}
e6f15b76 CW	351
af33a919 LA	352	static struct drm_gem_object* vgem_prime_import(struct drm_device *dev,
	353	struct dma_buf *dma_buf)
	354	{
315f0242 CW	355	struct vgem_device vgem = container_of(dev, typeof(vgem), drm);
	356
	357	return drm_gem_prime_import_dev(dev, dma_buf, &vgem->platform->dev);
af33a919 LA	358	}
	359
	360	static struct drm_gem_object vgem_prime_import_sg_table(struct drm_device dev,
	361	struct dma_buf_attachment attach, struct sg_table sg)
	362	{
	363	struct drm_vgem_gem_object *obj;
	364	int npages;
	365
	366	obj = __vgem_gem_create(dev, attach->dmabuf->size);
	367	if (IS_ERR(obj))
	368	return ERR_CAST(obj);
	369
	370	npages = PAGE_ALIGN(attach->dmabuf->size) / PAGE_SIZE;
	371
	372	obj->table = sg;
2098105e	373	obj->pages = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
af33a919 LA	374	if (!obj->pages) {
	375	__vgem_gem_destroy(obj);
	376	return ERR_PTR(-ENOMEM);
	377	}
71bb23c7 CW	378
71bb23c7 CW	379	obj->pages_pin_count++; /* perma-pinned */
af33a919 LA	380	drm_prime_sg_to_page_addr_arrays(obj->table, obj->pages, NULL,
	381	npages);
	382	return &obj->base;
	383	}
	384
e6f15b76 CW	385	static void vgem_prime_vmap(struct drm_gem_object obj)
e6f15b76 CW	386	{
71bb23c7	387	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);
e6f15b76 CW	388	long n_pages = obj->size >> PAGE_SHIFT;
e6f15b76 CW	389	struct page **pages;
e6f15b76	390
71bb23c7	391	pages = vgem_pin_pages(bo);
e6f15b76 CW	392	if (IS_ERR(pages))
	393	return NULL;
	394
71bb23c7	395	return vmap(pages, n_pages, 0, pgprot_writecombine(PAGE_KERNEL));
e6f15b76 CW	396	}
	397
	398	static void vgem_prime_vunmap(struct drm_gem_object obj, void vaddr)
	399	{
71bb23c7 CW	400	struct drm_vgem_gem_object *bo = to_vgem_bo(obj);
71bb23c7 CW	401
e6f15b76	402	vunmap(vaddr);
71bb23c7	403	vgem_unpin_pages(bo);
e6f15b76 CW	404	}
	405
	406	static int vgem_prime_mmap(struct drm_gem_object *obj,
	407	struct vm_area_struct *vma)
	408	{
	409	int ret;
	410
	411	if (obj->size < vma->vm_end - vma->vm_start)
	412	return -EINVAL;
	413
	414	if (!obj->filp)
	415	return -ENODEV;
	416
f74ac015	417	ret = call_mmap(obj->filp, vma);
e6f15b76 CW	418	if (ret)
	419	return ret;
	420
	421	fput(vma->vm_file);
	422	vma->vm_file = get_file(obj->filp);
	423	vma->vm_flags \|= VM_DONTEXPAND \| VM_DONTDUMP;
	424	vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
	425
	426	return 0;
	427	}
	428
315f0242 CW	429	static void vgem_release(struct drm_device *dev)
	430	{
	431	struct vgem_device vgem = container_of(dev, typeof(vgem), drm);
	432
	433	platform_device_unregister(vgem->platform);
	434	drm_dev_fini(&vgem->drm);
	435
	436	kfree(vgem);
	437	}
	438
502e95c6	439	static struct drm_driver vgem_driver = {
0424fdaf	440	.driver_features = DRIVER_GEM \| DRIVER_RENDER,
315f0242	441	.release = vgem_release,
40777984	442	.open = vgem_open,
098899fe	443	.postclose = vgem_postclose,
1bd816f1	444	.gem_free_object_unlocked = vgem_gem_free_object,
502e95c6 ZR	445	.gem_vm_ops = &vgem_gem_vm_ops,
502e95c6 ZR	446	.ioctls = vgem_ioctls,
40777984	447	.num_ioctls = ARRAY_SIZE(vgem_ioctls),
502e95c6	448	.fops = &vgem_driver_fops,
e6f15b76	449
502e95c6 ZR	450	.dumb_create = vgem_gem_dumb_create,
502e95c6 ZR	451	.dumb_map_offset = vgem_gem_dumb_map,
e6f15b76 CW	452
e6f15b76 CW	453	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
af33a919	454	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
e6f15b76	455	.gem_prime_pin = vgem_prime_pin,
71bb23c7	456	.gem_prime_unpin = vgem_prime_unpin,
af33a919	457	.gem_prime_import = vgem_prime_import,
af33a919	458	.gem_prime_import_sg_table = vgem_prime_import_sg_table,
e6f15b76 CW	459	.gem_prime_get_sg_table = vgem_prime_get_sg_table,
	460	.gem_prime_vmap = vgem_prime_vmap,
	461	.gem_prime_vunmap = vgem_prime_vunmap,
	462	.gem_prime_mmap = vgem_prime_mmap,
	463
502e95c6 ZR	464	.name = DRIVER_NAME,
	465	.desc = DRIVER_DESC,
	466	.date = DRIVER_DATE,
	467	.major = DRIVER_MAJOR,
	468	.minor = DRIVER_MINOR,
	469	};
	470
502e95c6 ZR	471	static int __init vgem_init(void)
	472	{
	473	int ret;
	474
315f0242 CW	475	vgem_device = kzalloc(sizeof(*vgem_device), GFP_KERNEL);
	476	if (!vgem_device)
	477	return -ENOMEM;
e2aff448	478
315f0242 CW	479	vgem_device->platform =
315f0242 CW	480	platform_device_register_simple("vgem", -1, NULL, 0);
e8fa49b5 WY	481	if (IS_ERR(vgem_device->platform)) {
e8fa49b5 WY	482	ret = PTR_ERR(vgem_device->platform);
d5c04dff	483	goto out_free;
502e95c6 ZR	484	}
502e95c6 ZR	485
315f0242 CW	486	dma_coerce_mask_and_coherent(&vgem_device->platform->dev,
315f0242 CW	487	DMA_BIT_MASK(64));
d5c04dff DS	488	ret = drm_dev_init(&vgem_device->drm, &vgem_driver,
	489	&vgem_device->platform->dev);
	490	if (ret)
	491	goto out_unregister;
e2aff448	492
315f0242 CW	493	/* Final step: expose the device/driver to userspace */
315f0242 CW	494	ret = drm_dev_register(&vgem_device->drm, 0);
502e95c6	495	if (ret)
d5c04dff	496	goto out_fini;
502e95c6 ZR	497
	498	return 0;
	499
315f0242 CW	500	out_fini:
315f0242 CW	501	drm_dev_fini(&vgem_device->drm);
d5c04dff DS	502	out_unregister:
d5c04dff DS	503	platform_device_unregister(vgem_device->platform);
315f0242 CW	504	out_free:
315f0242 CW	505	kfree(vgem_device);
502e95c6 ZR	506	return ret;
	507	}
	508
	509	static void __exit vgem_exit(void)
	510	{
315f0242	511	drm_dev_unregister(&vgem_device->drm);
75ff9f3c	512	drm_dev_put(&vgem_device->drm);
502e95c6 ZR	513	}
	514
	515	module_init(vgem_init);
	516	module_exit(vgem_exit);
	517
	518	MODULE_AUTHOR("Red Hat, Inc.");
40777984	519	MODULE_AUTHOR("Intel Corporation");
502e95c6 ZR	520	MODULE_DESCRIPTION(DRIVER_DESC);
502e95c6 ZR	521	MODULE_LICENSE("GPL and additional rights");