[linux-2.6-block.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/module.h>
#include <linux/ramfs.h>
#include <linux/shmem_fs.h>
#include <linux/dma-buf.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

void vgem_gem_put_pages(struct drm_vgem_gem_object *obj)
{
	drm_gem_put_pages(&obj->base, obj->pages, false, false);
	obj->pages = NULL;
}

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

	drm_gem_free_mmap_offset(obj);

	if (vgem_obj->use_dma_buf && obj->dma_buf) {
		dma_buf_put(obj->dma_buf);
		obj->dma_buf = NULL;
	}

	drm_gem_object_release(obj);

	if (vgem_obj->pages)
		vgem_gem_put_pages(vgem_obj);

	vgem_obj->pages = NULL;

	kfree(vgem_obj);
}

int vgem_gem_get_pages(struct drm_vgem_gem_object *obj)
{
	struct page **pages;

	if (obj->pages || obj->use_dma_buf)
		return 0;

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

	obj->pages = pages;

	return 0;
}

static int vgem_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	struct drm_vgem_gem_object *obj = vma->vm_private_data;
	struct drm_device *dev = obj->base.dev;
	loff_t num_pages;
	pgoff_t page_offset;
	int ret;

	/* We don't use vmf->pgoff since that has the fake offset */
	page_offset = ((unsigned long)vmf->virtual_address - 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(&dev->struct_mutex);

	ret = vm_insert_page(vma, (unsigned long)vmf->virtual_address,
			     obj->pages[page_offset]);

	mutex_unlock(&dev->struct_mutex);
	switch (ret) {
	case 0:
		return VM_FAULT_NOPAGE;
	case -ENOMEM:
		return VM_FAULT_OOM;
	case -EBUSY:
		return VM_FAULT_RETRY;
	case -EFAULT:
	case -EINVAL:
		return VM_FAULT_SIGBUS;
	default:
		WARN_ON(1);
		return VM_FAULT_SIGBUS;
	}
}

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

/* ioctls */

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;
	struct drm_gem_object *gem_object;
	int err;

	size = roundup(size, PAGE_SIZE);

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

	gem_object = &obj->base;

	err = drm_gem_object_init(dev, gem_object, size);
	if (err)
		goto out;

	err = vgem_gem_get_pages(obj);
	if (err)
		goto out;

	err = drm_gem_handle_create(file, gem_object, handle);
	if (err)
		goto handle_out;

	drm_gem_object_unreference_unlocked(gem_object);

	return gem_object;

handle_out:
	drm_gem_object_release(gem_object);
out:
	kfree(obj);
	return ERR_PTR(err);
}

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;
	uint64_t size;
	uint64_t 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)) {
		DRM_DEBUG_DRIVER("object creation failed\n");
		return PTR_ERR(gem_object);
	}

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

	DRM_DEBUG_DRIVER("Created object of size %lld\n", size);

	return 0;
}

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

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

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

	BUG_ON(!obj->filp);

	obj->filp->private_data = obj;

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

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

static struct drm_ioctl_desc vgem_ioctls[] = {
};

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

static struct drm_driver vgem_driver = {
	.driver_features		= DRIVER_GEM,
	.gem_free_object		= vgem_gem_free_object,
	.gem_vm_ops			= &vgem_gem_vm_ops,
	.ioctls				= vgem_ioctls,
	.fops				= &vgem_driver_fops,
	.dumb_create			= vgem_gem_dumb_create,
	.dumb_map_offset		= vgem_gem_dumb_map,
	.name	= DRIVER_NAME,
	.desc	= DRIVER_DESC,
	.date	= DRIVER_DATE,
	.major	= DRIVER_MAJOR,
	.minor	= DRIVER_MINOR,
};

struct drm_device *vgem_device;

static int __init vgem_init(void)
{
	int ret;

	vgem_device = drm_dev_alloc(&vgem_driver, NULL);
	if (!vgem_device) {
		ret = -ENOMEM;
		goto out;
	}

	drm_dev_set_unique(vgem_device, "vgem");

	ret  = drm_dev_register(vgem_device, 0);

	if (ret)
		goto out_unref;

	return 0;

out_unref:
	drm_dev_unref(vgem_device);
out:
	return ret;
}

static void __exit vgem_exit(void)
{
	drm_dev_unregister(vgem_device);
	drm_dev_unref(vgem_device);
}

module_init(vgem_init);
module_exit(vgem_exit);

MODULE_AUTHOR("Red Hat, Inc.");
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
	33	#include <linux/module.h>
	34	#include <linux/ramfs.h>
	35	#include <linux/shmem_fs.h>
	36	#include <linux/dma-buf.h>
	37	#include "vgem_drv.h"
	38
	39	#define DRIVER_NAME "vgem"
	40	#define DRIVER_DESC "Virtual GEM provider"
	41	#define DRIVER_DATE "20120112"
	42	#define DRIVER_MAJOR 1
	43	#define DRIVER_MINOR 0
	44
	45	void vgem_gem_put_pages(struct drm_vgem_gem_object *obj)
	46	{
	47	drm_gem_put_pages(&obj->base, obj->pages, false, false);
	48	obj->pages = NULL;
	49	}
	50
	51	static void vgem_gem_free_object(struct drm_gem_object *obj)
	52	{
	53	struct drm_vgem_gem_object *vgem_obj = to_vgem_bo(obj);
	54
	55	drm_gem_free_mmap_offset(obj);
	56
	57	if (vgem_obj->use_dma_buf && obj->dma_buf) {
	58	dma_buf_put(obj->dma_buf);
	59	obj->dma_buf = NULL;
	60	}
	61
	62	drm_gem_object_release(obj);
	63
	64	if (vgem_obj->pages)
65	vgem_gem_put_pages(vgem_obj);
66
67	vgem_obj->pages = NULL;
68
69	kfree(vgem_obj);
70	}
71
72	int vgem_gem_get_pages(struct drm_vgem_gem_object *obj)
73	{
74	struct page **pages;
75
76	if (obj->pages \|\| obj->use_dma_buf)
77	return 0;
78
79	pages = drm_gem_get_pages(&obj->base);
80	if (IS_ERR(pages)) {
81	return PTR_ERR(pages);
82	}
83
84	obj->pages = pages;
85
86	return 0;
87	}
88
89	static int vgem_gem_fault(struct vm_area_struct vma, struct vm_fault vmf)
90	{
91	struct drm_vgem_gem_object *obj = vma->vm_private_data;
92	struct drm_device *dev = obj->base.dev;
93	loff_t num_pages;
94	pgoff_t page_offset;
95	int ret;
96
97	/* We don't use vmf->pgoff since that has the fake offset */
98	page_offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >>
99	PAGE_SHIFT;
100
101	num_pages = DIV_ROUND_UP(obj->base.size, PAGE_SIZE);
102
103	if (page_offset > num_pages)
104	return VM_FAULT_SIGBUS;
105
106	mutex_lock(&dev->struct_mutex);
107
108	ret = vm_insert_page(vma, (unsigned long)vmf->virtual_address,
109	obj->pages[page_offset]);
110
111	mutex_unlock(&dev->struct_mutex);
112	switch (ret) {
113	case 0:
114	return VM_FAULT_NOPAGE;
115	case -ENOMEM:
116	return VM_FAULT_OOM;
117	case -EBUSY:
118	return VM_FAULT_RETRY;
119	case -EFAULT:
120	case -EINVAL:
121	return VM_FAULT_SIGBUS;
122	default:
123	WARN_ON(1);
124	return VM_FAULT_SIGBUS;
125	}
126	}
127
7cbea8dc	128	static const struct vm_operations_struct vgem_gem_vm_ops = {
502e95c6 ZR	129	.fault = vgem_gem_fault,
	130	.open = drm_gem_vm_open,
	131	.close = drm_gem_vm_close,
	132	};
	133
	134	/* ioctls */
	135
	136	static struct drm_gem_object vgem_gem_create(struct drm_device dev,
	137	struct drm_file *file,
	138	unsigned int *handle,
	139	unsigned long size)
	140	{
	141	struct drm_vgem_gem_object *obj;
	142	struct drm_gem_object *gem_object;
	143	int err;
	144
	145	size = roundup(size, PAGE_SIZE);
	146
	147	obj = kzalloc(sizeof(*obj), GFP_KERNEL);
	148	if (!obj)
	149	return ERR_PTR(-ENOMEM);
	150
	151	gem_object = &obj->base;
	152
	153	err = drm_gem_object_init(dev, gem_object, size);
	154	if (err)
	155	goto out;
	156
7f340a26 DV	157	err = vgem_gem_get_pages(obj);
	158	if (err)
	159	goto out;
	160
502e95c6 ZR	161	err = drm_gem_handle_create(file, gem_object, handle);
	162	if (err)
	163	goto handle_out;
	164
	165	drm_gem_object_unreference_unlocked(gem_object);
	166
	167	return gem_object;
	168
	169	handle_out:
	170	drm_gem_object_release(gem_object);
	171	out:
	172	kfree(obj);
	173	return ERR_PTR(err);
	174	}
	175
	176	static int vgem_gem_dumb_create(struct drm_file file, struct drm_device dev,
	177	struct drm_mode_create_dumb *args)
	178	{
	179	struct drm_gem_object *gem_object;
	180	uint64_t size;
	181	uint64_t pitch = args->width * DIV_ROUND_UP(args->bpp, 8);
	182
	183	size = args->height * pitch;
	184	if (size == 0)
	185	return -EINVAL;
	186
	187	gem_object = vgem_gem_create(dev, file, &args->handle, size);
	188
	189	if (IS_ERR(gem_object)) {
	190	DRM_DEBUG_DRIVER("object creation failed\n");
	191	return PTR_ERR(gem_object);
	192	}
	193
	194	args->size = gem_object->size;
	195	args->pitch = pitch;
	196
	197	DRM_DEBUG_DRIVER("Created object of size %lld\n", size);
	198
	199	return 0;
	200	}
	201
	202	int vgem_gem_dumb_map(struct drm_file file, struct drm_device dev,
	203	uint32_t handle, uint64_t *offset)
	204	{
	205	int ret = 0;
	206	struct drm_gem_object *obj;
	207
	208	mutex_lock(&dev->struct_mutex);
	209	obj = drm_gem_object_lookup(dev, file, handle);
	210	if (!obj) {
	211	ret = -ENOENT;
	212	goto unlock;
	213	}
	214
e34274fd DV	215	ret = drm_gem_create_mmap_offset(obj);
	216	if (ret)
	217	goto unref;
502e95c6 ZR	218
	219	BUG_ON(!obj->filp);
	220
	221	obj->filp->private_data = obj;
	222
502e95c6 ZR	223	*offset = drm_vma_node_offset_addr(&obj->vma_node);
502e95c6 ZR	224
502e95c6 ZR	225	unref:
	226	drm_gem_object_unreference(obj);
	227	unlock:
	228	mutex_unlock(&dev->struct_mutex);
	229	return ret;
	230	}
	231
502e95c6 ZR	232	static struct drm_ioctl_desc vgem_ioctls[] = {
	233	};
	234
	235	static const struct file_operations vgem_driver_fops = {
	236	.owner = THIS_MODULE,
	237	.open = drm_open,
3d57b42c	238	.mmap = drm_gem_mmap,
502e95c6 ZR	239	.poll = drm_poll,
	240	.read = drm_read,
	241	.unlocked_ioctl = drm_ioctl,
	242	.release = drm_release,
	243	};
	244
	245	static struct drm_driver vgem_driver = {
990ed272	246	.driver_features = DRIVER_GEM,
502e95c6 ZR	247	.gem_free_object = vgem_gem_free_object,
	248	.gem_vm_ops = &vgem_gem_vm_ops,
	249	.ioctls = vgem_ioctls,
	250	.fops = &vgem_driver_fops,
	251	.dumb_create = vgem_gem_dumb_create,
	252	.dumb_map_offset = vgem_gem_dumb_map,
502e95c6 ZR	253	.name = DRIVER_NAME,
	254	.desc = DRIVER_DESC,
	255	.date = DRIVER_DATE,
	256	.major = DRIVER_MAJOR,
	257	.minor = DRIVER_MINOR,
	258	};
	259
	260	struct drm_device *vgem_device;
	261
	262	static int __init vgem_init(void)
	263	{
	264	int ret;
	265
	266	vgem_device = drm_dev_alloc(&vgem_driver, NULL);
	267	if (!vgem_device) {
	268	ret = -ENOMEM;
	269	goto out;
	270	}
	271
fa2f97dd DV	272	drm_dev_set_unique(vgem_device, "vgem");
fa2f97dd DV	273
502e95c6 ZR	274	ret = drm_dev_register(vgem_device, 0);
	275
	276	if (ret)
	277	goto out_unref;
	278
	279	return 0;
	280
	281	out_unref:
	282	drm_dev_unref(vgem_device);
	283	out:
	284	return ret;
	285	}
	286
	287	static void __exit vgem_exit(void)
	288	{
	289	drm_dev_unregister(vgem_device);
	290	drm_dev_unref(vgem_device);
	291	}
	292
	293	module_init(vgem_init);
	294	module_exit(vgem_exit);
	295
	296	MODULE_AUTHOR("Red Hat, Inc.");
	297	MODULE_DESCRIPTION(DRIVER_DESC);
	298	MODULE_LICENSE("GPL and additional rights");