[deliverable/linux.git] / drivers / gpu / drm / i915 / i915_gem_dmabuf.c

/*
 * Copyright 2012 Red Hat Inc
 *
 * 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
 * THE AUTHORS OR COPYRIGHT HOLDERS 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:
 *	Dave Airlie <airlied@redhat.com>
 */
#include <drm/drmP.h>
#include "i915_drv.h"
#include <linux/dma-buf.h>

static struct sg_table *i915_gem_map_dma_buf(struct dma_buf_attachment *attachment,
					     enum dma_data_direction dir)
{
	struct drm_i915_gem_object *obj = attachment->dmabuf->priv;
	struct sg_table *st;
	struct scatterlist *src, *dst;
	int ret, i;

	ret = i915_mutex_lock_interruptible(obj->base.dev);
	if (ret)
		return ERR_PTR(ret);

	ret = i915_gem_object_get_pages(obj);
	if (ret) {
		st = ERR_PTR(ret);
		goto out;
	}

	/* Copy sg so that we make an independent mapping */
	st = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
	if (st == NULL) {
		st = ERR_PTR(-ENOMEM);
		goto out;
	}

	ret = sg_alloc_table(st, obj->pages->nents, GFP_KERNEL);
	if (ret) {
		kfree(st);
		st = ERR_PTR(ret);
		goto out;
	}

	src = obj->pages->sgl;
	dst = st->sgl;
	for (i = 0; i < obj->pages->nents; i++) {
		sg_set_page(dst, sg_page(src), src->length, 0);
		dst = sg_next(dst);
		src = sg_next(src);
	}

	if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir)) {
		sg_free_table(st);
		kfree(st);
		st = ERR_PTR(-ENOMEM);
		goto out;
	}

	i915_gem_object_pin_pages(obj);

out:
	mutex_unlock(&obj->base.dev->struct_mutex);
	return st;
}

static void i915_gem_unmap_dma_buf(struct dma_buf_attachment *attachment,
				   struct sg_table *sg,
				   enum dma_data_direction dir)
{
	dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
	sg_free_table(sg);
	kfree(sg);
}

static void i915_gem_dmabuf_release(struct dma_buf *dma_buf)
{
	struct drm_i915_gem_object *obj = dma_buf->priv;

	if (obj->base.export_dma_buf == dma_buf) {
		/* drop the reference on the export fd holds */
		obj->base.export_dma_buf = NULL;
		drm_gem_object_unreference_unlocked(&obj->base);
	}
}

static void *i915_gem_dmabuf_vmap(struct dma_buf *dma_buf)
{
	struct drm_i915_gem_object *obj = dma_buf->priv;
	struct drm_device *dev = obj->base.dev;
	struct sg_page_iter sg_iter;
	struct page **pages;
	int ret, i;

	ret = i915_mutex_lock_interruptible(dev);
	if (ret)
		return ERR_PTR(ret);

	if (obj->dma_buf_vmapping) {
		obj->vmapping_count++;
		goto out_unlock;
	}

	ret = i915_gem_object_get_pages(obj);
	if (ret)
		goto error;

	ret = -ENOMEM;

	pages = drm_malloc_ab(obj->base.size >> PAGE_SHIFT, sizeof(*pages));
	if (pages == NULL)
		goto error;

	i = 0;
	for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0)
		pages[i++] = sg_page_iter_page(&sg_iter);

	obj->dma_buf_vmapping = vmap(pages, i, 0, PAGE_KERNEL);
	drm_free_large(pages);

	if (!obj->dma_buf_vmapping)
		goto error;

	obj->vmapping_count = 1;
	i915_gem_object_pin_pages(obj);
out_unlock:
	mutex_unlock(&dev->struct_mutex);
	return obj->dma_buf_vmapping;

error:
	mutex_unlock(&dev->struct_mutex);
	return ERR_PTR(ret);
}

static void i915_gem_dmabuf_vunmap(struct dma_buf *dma_buf, void *vaddr)
{
	struct drm_i915_gem_object *obj = dma_buf->priv;
	struct drm_device *dev = obj->base.dev;
	int ret;

	ret = i915_mutex_lock_interruptible(dev);
	if (ret)
		return;

	if (--obj->vmapping_count == 0) {
		vunmap(obj->dma_buf_vmapping);
		obj->dma_buf_vmapping = NULL;

		i915_gem_object_unpin_pages(obj);
	}
	mutex_unlock(&dev->struct_mutex);
}

static void *i915_gem_dmabuf_kmap_atomic(struct dma_buf *dma_buf, unsigned long page_num)
{
	return NULL;
}

static void i915_gem_dmabuf_kunmap_atomic(struct dma_buf *dma_buf, unsigned long page_num, void *addr)
{

}
static void *i915_gem_dmabuf_kmap(struct dma_buf *dma_buf, unsigned long page_num)
{
	return NULL;
}

static void i915_gem_dmabuf_kunmap(struct dma_buf *dma_buf, unsigned long page_num, void *addr)
{

}

static int i915_gem_dmabuf_mmap(struct dma_buf *dma_buf, struct vm_area_struct *vma)
{
	return -EINVAL;
}

static int i915_gem_begin_cpu_access(struct dma_buf *dma_buf, size_t start, size_t length, enum dma_data_direction direction)
{
	struct drm_i915_gem_object *obj = dma_buf->priv;
	struct drm_device *dev = obj->base.dev;
	int ret;
	bool write = (direction == DMA_BIDIRECTIONAL || direction == DMA_TO_DEVICE);

	ret = i915_mutex_lock_interruptible(dev);
	if (ret)
		return ret;

	ret = i915_gem_object_set_to_cpu_domain(obj, write);
	mutex_unlock(&dev->struct_mutex);
	return ret;
}

static const struct dma_buf_ops i915_dmabuf_ops =  {
	.map_dma_buf = i915_gem_map_dma_buf,
	.unmap_dma_buf = i915_gem_unmap_dma_buf,
	.release = i915_gem_dmabuf_release,
	.kmap = i915_gem_dmabuf_kmap,
	.kmap_atomic = i915_gem_dmabuf_kmap_atomic,
	.kunmap = i915_gem_dmabuf_kunmap,
	.kunmap_atomic = i915_gem_dmabuf_kunmap_atomic,
	.mmap = i915_gem_dmabuf_mmap,
	.vmap = i915_gem_dmabuf_vmap,
	.vunmap = i915_gem_dmabuf_vunmap,
	.begin_cpu_access = i915_gem_begin_cpu_access,
};

struct dma_buf *i915_gem_prime_export(struct drm_device *dev,
				      struct drm_gem_object *gem_obj, int flags)
{
	struct drm_i915_gem_object *obj = to_intel_bo(gem_obj);

	return dma_buf_export(obj, &i915_dmabuf_ops, obj->base.size, flags);
}

static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj)
{
	struct sg_table *sg;

	sg = dma_buf_map_attachment(obj->base.import_attach, DMA_BIDIRECTIONAL);
	if (IS_ERR(sg))
		return PTR_ERR(sg);

	obj->pages = sg;
	obj->has_dma_mapping = true;
	return 0;
}

static void i915_gem_object_put_pages_dmabuf(struct drm_i915_gem_object *obj)
{
	dma_buf_unmap_attachment(obj->base.import_attach,
				 obj->pages, DMA_BIDIRECTIONAL);
	obj->has_dma_mapping = false;
}

static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = {
	.get_pages = i915_gem_object_get_pages_dmabuf,
	.put_pages = i915_gem_object_put_pages_dmabuf,
};

struct drm_gem_object *i915_gem_prime_import(struct drm_device *dev,
					     struct dma_buf *dma_buf)
{
	struct dma_buf_attachment *attach;
	struct drm_i915_gem_object *obj;
	int ret;

	/* is this one of own objects? */
	if (dma_buf->ops == &i915_dmabuf_ops) {
		obj = dma_buf->priv;
		/* is it from our device? */
		if (obj->base.dev == dev) {
			/*
			 * Importing dmabuf exported from out own gem increases
			 * refcount on gem itself instead of f_count of dmabuf.
			 */
			drm_gem_object_reference(&obj->base);
			return &obj->base;
		}
	}

	/* need to attach */
	attach = dma_buf_attach(dma_buf, dev->dev);
	if (IS_ERR(attach))
		return ERR_CAST(attach);

	get_dma_buf(dma_buf);

	obj = i915_gem_object_alloc(dev);
	if (obj == NULL) {
		ret = -ENOMEM;
		goto fail_detach;
	}

	ret = drm_gem_private_object_init(dev, &obj->base, dma_buf->size);
	if (ret) {
		i915_gem_object_free(obj);
		goto fail_detach;
	}

	i915_gem_object_init(obj, &i915_gem_object_dmabuf_ops);
	obj->base.import_attach = attach;

	return &obj->base;

fail_detach:
	dma_buf_detach(dma_buf, attach);
	dma_buf_put(dma_buf);

	return ERR_PTR(ret);
}
Commit	Line	Data
1286ff73 DV	1	/*
	2	* Copyright 2012 Red Hat Inc
	3	*
	4	* Permission is hereby granted, free of charge, to any person obtaining a
	5	* copy of this software and associated documentation files (the "Software"),
	6	* to deal in the Software without restriction, including without limitation
	7	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	8	* and/or sell copies of the Software, and to permit persons to whom the
	9	* Software is furnished to do so, subject to the following conditions:
	10	*
	11	* The above copyright notice and this permission notice (including the next
	12	* paragraph) shall be included in all copies or substantial portions of the
	13	* Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	18	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	20	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	21	* DEALINGS IN THE SOFTWARE.
	22	*
	23	* Authors:
	24	* Dave Airlie <airlied@redhat.com>
	25	*/
760285e7	26	#include <drm/drmP.h>
1286ff73 DV	27	#include "i915_drv.h"
	28	#include <linux/dma-buf.h>
	29
6a101cb2	30	static struct sg_table i915_gem_map_dma_buf(struct dma_buf_attachment attachment,
9da3da66	31	enum dma_data_direction dir)
1286ff73 DV	32	{
1286ff73 DV	33	struct drm_i915_gem_object *obj = attachment->dmabuf->priv;
9da3da66 CW	34	struct sg_table *st;
	35	struct scatterlist src, dst;
	36	int ret, i;
1286ff73	37
9da3da66	38	ret = i915_mutex_lock_interruptible(obj->base.dev);
1286ff73 DV	39	if (ret)
	40	return ERR_PTR(ret);
	41
37e680a1	42	ret = i915_gem_object_get_pages(obj);
6c085a72	43	if (ret) {
9da3da66 CW	44	st = ERR_PTR(ret);
	45	goto out;
	46	}
	47
	48	/* Copy sg so that we make an independent mapping */
	49	st = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
	50	if (st == NULL) {
	51	st = ERR_PTR(-ENOMEM);
	52	goto out;
1286ff73 DV	53	}
1286ff73 DV	54
9da3da66 CW	55	ret = sg_alloc_table(st, obj->pages->nents, GFP_KERNEL);
	56	if (ret) {
	57	kfree(st);
	58	st = ERR_PTR(ret);
	59	goto out;
	60	}
	61
	62	src = obj->pages->sgl;
	63	dst = st->sgl;
	64	for (i = 0; i < obj->pages->nents; i++) {
67d5a50c	65	sg_set_page(dst, sg_page(src), src->length, 0);
9da3da66 CW	66	dst = sg_next(dst);
	67	src = sg_next(src);
	68	}
	69
	70	if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir)) {
	71	sg_free_table(st);
	72	kfree(st);
	73	st = ERR_PTR(-ENOMEM);
6c085a72	74	goto out;
1286ff73 DV	75	}
1286ff73 DV	76
a5570178 CW	77	i915_gem_object_pin_pages(obj);
a5570178 CW	78
1286ff73	79	out:
9da3da66 CW	80	mutex_unlock(&obj->base.dev->struct_mutex);
9da3da66 CW	81	return st;
1286ff73 DV	82	}
1286ff73 DV	83
6a101cb2	84	static void i915_gem_unmap_dma_buf(struct dma_buf_attachment *attachment,
2f745ad3 CW	85	struct sg_table *sg,
2f745ad3 CW	86	enum dma_data_direction dir)
1286ff73 DV	87	{
	88	dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
	89	sg_free_table(sg);
	90	kfree(sg);
	91	}
	92
6a101cb2	93	static void i915_gem_dmabuf_release(struct dma_buf *dma_buf)
1286ff73 DV	94	{
	95	struct drm_i915_gem_object *obj = dma_buf->priv;
	96
	97	if (obj->base.export_dma_buf == dma_buf) {
	98	/* drop the reference on the export fd holds */
	99	obj->base.export_dma_buf = NULL;
	100	drm_gem_object_unreference_unlocked(&obj->base);
	101	}
	102	}
	103
9a70cc2a DA	104	static void i915_gem_dmabuf_vmap(struct dma_buf dma_buf)
	105	{
	106	struct drm_i915_gem_object *obj = dma_buf->priv;
	107	struct drm_device *dev = obj->base.dev;
67d5a50c	108	struct sg_page_iter sg_iter;
9da3da66 CW	109	struct page **pages;
9da3da66 CW	110	int ret, i;
9a70cc2a DA	111
	112	ret = i915_mutex_lock_interruptible(dev);
	113	if (ret)
	114	return ERR_PTR(ret);
	115
	116	if (obj->dma_buf_vmapping) {
	117	obj->vmapping_count++;
	118	goto out_unlock;
	119	}
	120
37e680a1	121	ret = i915_gem_object_get_pages(obj);
9da3da66 CW	122	if (ret)
9da3da66 CW	123	goto error;
9a70cc2a	124
9da3da66 CW	125	ret = -ENOMEM;
9da3da66 CW	126
67d5a50c	127	pages = drm_malloc_ab(obj->base.size >> PAGE_SHIFT, sizeof(*pages));
9da3da66 CW	128	if (pages == NULL)
	129	goto error;
	130
67d5a50c	131	i = 0;
b11b88ef	132	for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0)
2db76d7c	133	pages[i++] = sg_page_iter_page(&sg_iter);
9da3da66	134
67d5a50c	135	obj->dma_buf_vmapping = vmap(pages, i, 0, PAGE_KERNEL);
9da3da66 CW	136	drm_free_large(pages);
	137
	138	if (!obj->dma_buf_vmapping)
	139	goto error;
9a70cc2a DA	140
9a70cc2a DA	141	obj->vmapping_count = 1;
a5570178	142	i915_gem_object_pin_pages(obj);
9a70cc2a DA	143	out_unlock:
	144	mutex_unlock(&dev->struct_mutex);
	145	return obj->dma_buf_vmapping;
9da3da66 CW	146
	147	error:
	148	mutex_unlock(&dev->struct_mutex);
	149	return ERR_PTR(ret);
9a70cc2a DA	150	}
	151
	152	static void i915_gem_dmabuf_vunmap(struct dma_buf dma_buf, void vaddr)
	153	{
	154	struct drm_i915_gem_object *obj = dma_buf->priv;
	155	struct drm_device *dev = obj->base.dev;
	156	int ret;
	157
	158	ret = i915_mutex_lock_interruptible(dev);
	159	if (ret)
	160	return;
	161
a5570178	162	if (--obj->vmapping_count == 0) {
9a70cc2a DA	163	vunmap(obj->dma_buf_vmapping);
9a70cc2a DA	164	obj->dma_buf_vmapping = NULL;
a5570178 CW	165
a5570178 CW	166	i915_gem_object_unpin_pages(obj);
9a70cc2a DA	167	}
	168	mutex_unlock(&dev->struct_mutex);
	169	}
	170
1286ff73 DV	171	static void i915_gem_dmabuf_kmap_atomic(struct dma_buf dma_buf, unsigned long page_num)
	172	{
	173	return NULL;
	174	}
	175
	176	static void i915_gem_dmabuf_kunmap_atomic(struct dma_buf dma_buf, unsigned long page_num, void addr)
	177	{
	178
	179	}
	180	static void i915_gem_dmabuf_kmap(struct dma_buf dma_buf, unsigned long page_num)
	181	{
	182	return NULL;
	183	}
	184
	185	static void i915_gem_dmabuf_kunmap(struct dma_buf dma_buf, unsigned long page_num, void addr)
	186	{
	187
	188	}
	189
2dad9d4d DA	190	static int i915_gem_dmabuf_mmap(struct dma_buf dma_buf, struct vm_area_struct vma)
	191	{
	192	return -EINVAL;
	193	}
	194
ec6f1bb9 DA	195	static int i915_gem_begin_cpu_access(struct dma_buf *dma_buf, size_t start, size_t length, enum dma_data_direction direction)
	196	{
	197	struct drm_i915_gem_object *obj = dma_buf->priv;
	198	struct drm_device *dev = obj->base.dev;
	199	int ret;
	200	bool write = (direction == DMA_BIDIRECTIONAL \|\| direction == DMA_TO_DEVICE);
	201
	202	ret = i915_mutex_lock_interruptible(dev);
	203	if (ret)
	204	return ret;
	205
	206	ret = i915_gem_object_set_to_cpu_domain(obj, write);
	207	mutex_unlock(&dev->struct_mutex);
	208	return ret;
	209	}
	210
6a101cb2	211	static const struct dma_buf_ops i915_dmabuf_ops = {
1286ff73 DV	212	.map_dma_buf = i915_gem_map_dma_buf,
	213	.unmap_dma_buf = i915_gem_unmap_dma_buf,
	214	.release = i915_gem_dmabuf_release,
	215	.kmap = i915_gem_dmabuf_kmap,
	216	.kmap_atomic = i915_gem_dmabuf_kmap_atomic,
	217	.kunmap = i915_gem_dmabuf_kunmap,
	218	.kunmap_atomic = i915_gem_dmabuf_kunmap_atomic,
2dad9d4d	219	.mmap = i915_gem_dmabuf_mmap,
9a70cc2a DA	220	.vmap = i915_gem_dmabuf_vmap,
9a70cc2a DA	221	.vunmap = i915_gem_dmabuf_vunmap,
ec6f1bb9	222	.begin_cpu_access = i915_gem_begin_cpu_access,
1286ff73 DV	223	};
	224
	225	struct dma_buf i915_gem_prime_export(struct drm_device dev,
9da3da66	226	struct drm_gem_object *gem_obj, int flags)
1286ff73 DV	227	{
	228	struct drm_i915_gem_object *obj = to_intel_bo(gem_obj);
	229
5b42427f	230	return dma_buf_export(obj, &i915_dmabuf_ops, obj->base.size, flags);
1286ff73 DV	231	}
1286ff73 DV	232
2f745ad3 CW	233	static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj)
	234	{
	235	struct sg_table *sg;
	236
	237	sg = dma_buf_map_attachment(obj->base.import_attach, DMA_BIDIRECTIONAL);
	238	if (IS_ERR(sg))
	239	return PTR_ERR(sg);
	240
	241	obj->pages = sg;
	242	obj->has_dma_mapping = true;
	243	return 0;
1286ff73 DV	244	}
1286ff73 DV	245
2f745ad3 CW	246	static void i915_gem_object_put_pages_dmabuf(struct drm_i915_gem_object *obj)
	247	{
	248	dma_buf_unmap_attachment(obj->base.import_attach,
	249	obj->pages, DMA_BIDIRECTIONAL);
	250	obj->has_dma_mapping = false;
	251	}
	252
	253	static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = {
	254	.get_pages = i915_gem_object_get_pages_dmabuf,
	255	.put_pages = i915_gem_object_put_pages_dmabuf,
	256	};
	257
1286ff73	258	struct drm_gem_object i915_gem_prime_import(struct drm_device dev,
9da3da66	259	struct dma_buf *dma_buf)
1286ff73 DV	260	{
1286ff73 DV	261	struct dma_buf_attachment *attach;
1286ff73	262	struct drm_i915_gem_object *obj;
1286ff73 DV	263	int ret;
	264
	265	/* is this one of own objects? */
	266	if (dma_buf->ops == &i915_dmabuf_ops) {
	267	obj = dma_buf->priv;
	268	/* is it from our device? */
	269	if (obj->base.dev == dev) {
be8a42ae SWK	270	/*
	271	* Importing dmabuf exported from out own gem increases
	272	* refcount on gem itself instead of f_count of dmabuf.
	273	*/
1286ff73 DV	274	drm_gem_object_reference(&obj->base);
	275	return &obj->base;
	276	}
	277	}
	278
	279	/* need to attach */
	280	attach = dma_buf_attach(dma_buf, dev->dev);
	281	if (IS_ERR(attach))
	282	return ERR_CAST(attach);
	283
011c2282 ID	284	get_dma_buf(dma_buf);
011c2282 ID	285
42dcedd4	286	obj = i915_gem_object_alloc(dev);
1286ff73 DV	287	if (obj == NULL) {
1286ff73 DV	288	ret = -ENOMEM;
2f745ad3	289	goto fail_detach;
1286ff73 DV	290	}
1286ff73 DV	291
9da3da66	292	ret = drm_gem_private_object_init(dev, &obj->base, dma_buf->size);
1286ff73	293	if (ret) {
42dcedd4	294	i915_gem_object_free(obj);
2f745ad3	295	goto fail_detach;
1286ff73 DV	296	}
1286ff73 DV	297
2f745ad3	298	i915_gem_object_init(obj, &i915_gem_object_dmabuf_ops);
1286ff73 DV	299	obj->base.import_attach = attach;
	300
	301	return &obj->base;
	302
1286ff73 DV	303	fail_detach:
1286ff73 DV	304	dma_buf_detach(dma_buf, attach);
011c2282 ID	305	dma_buf_put(dma_buf);
011c2282 ID	306
1286ff73 DV	307	return ERR_PTR(ret);
1286ff73 DV	308	}