[linux-2.6-block.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 drm_i915_gem_object *dma_buf_to_obj(struct dma_buf *buf)
{
	return to_intel_bo(buf->priv);
}

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 = dma_buf_to_obj(attachment->dmabuf);
	struct sg_table *st;
	struct scatterlist *src, *dst;
	int ret, i;

	ret = i915_mutex_lock_interruptible(obj->base.dev);
	if (ret)
		goto err;

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

	i915_gem_object_pin_pages(obj);

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

	ret = sg_alloc_table(st, obj->pages->nents, GFP_KERNEL);
	if (ret)
		goto err_free;

	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)) {
		ret =-ENOMEM;
		goto err_free_sg;
	}

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

err_free_sg:
	sg_free_table(st);
err_free:
	kfree(st);
err_unpin:
	i915_gem_object_unpin_pages(obj);
err_unlock:
	mutex_unlock(&obj->base.dev->struct_mutex);
err:
	return ERR_PTR(ret);
}

static void i915_gem_unmap_dma_buf(struct dma_buf_attachment *attachment,
				   struct sg_table *sg,
				   enum dma_data_direction dir)
{
	struct drm_i915_gem_object *obj = dma_buf_to_obj(attachment->dmabuf);

	mutex_lock(&obj->base.dev->struct_mutex);

	dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
	sg_free_table(sg);
	kfree(sg);

	i915_gem_object_unpin_pages(obj);

	mutex_unlock(&obj->base.dev->struct_mutex);
}

static void *i915_gem_dmabuf_vmap(struct dma_buf *dma_buf)
{
	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
	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 err;

	i915_gem_object_pin_pages(obj);

	ret = -ENOMEM;

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

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

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

err_unpin:
	i915_gem_object_unpin_pages(obj);
err:
	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_to_obj(dma_buf);
	struct drm_device *dev = obj->base.dev;

	mutex_lock(&dev->struct_mutex);
	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)
{
	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
	int ret;

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

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

	ret = obj->base.filp->f_op->mmap(obj->base.filp, vma);
	if (ret)
		return ret;

	fput(vma->vm_file);
	vma->vm_file = get_file(obj->base.filp);

	return 0;
}

static int i915_gem_begin_cpu_access(struct dma_buf *dma_buf, enum dma_data_direction direction)
{
	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
	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 int i915_gem_end_cpu_access(struct dma_buf *dma_buf, enum dma_data_direction direction)
{
	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
	struct drm_device *dev = obj->base.dev;
	int ret;

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

	ret = i915_gem_object_set_to_gtt_domain(obj, false);
	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 = drm_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,
	.end_cpu_access = i915_gem_end_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);
	DEFINE_DMA_BUF_EXPORT_INFO(exp_info);

	exp_info.ops = &i915_dmabuf_ops;
	exp_info.size = gem_obj->size;
	exp_info.flags = flags;
	exp_info.priv = gem_obj;


	if (obj->ops->dmabuf_export) {
		int ret = obj->ops->dmabuf_export(obj);
		if (ret)
			return ERR_PTR(ret);
	}

	return dma_buf_export(&exp_info);
}

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

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_to_obj(dma_buf);
		/* 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;
	}

	drm_gem_private_object_init(dev, &obj->base, dma_buf->size);
	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
608806a5 DV	30	static struct drm_i915_gem_object dma_buf_to_obj(struct dma_buf buf)
	31	{
	32	return to_intel_bo(buf->priv);
	33	}
	34
6a101cb2	35	static struct sg_table i915_gem_map_dma_buf(struct dma_buf_attachment attachment,
9da3da66	36	enum dma_data_direction dir)
1286ff73	37	{
608806a5	38	struct drm_i915_gem_object *obj = dma_buf_to_obj(attachment->dmabuf);
9da3da66 CW	39	struct sg_table *st;
	40	struct scatterlist src, dst;
	41	int ret, i;
1286ff73	42
9da3da66	43	ret = i915_mutex_lock_interruptible(obj->base.dev);
1286ff73	44	if (ret)
5cfacded	45	goto err;
1286ff73	46
37e680a1	47	ret = i915_gem_object_get_pages(obj);
5cfacded CW	48	if (ret)
	49	goto err_unlock;
	50
	51	i915_gem_object_pin_pages(obj);
9da3da66 CW	52
	53	/* Copy sg so that we make an independent mapping */
	54	st = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
	55	if (st == NULL) {
5cfacded CW	56	ret = -ENOMEM;
5cfacded CW	57	goto err_unpin;
1286ff73 DV	58	}
1286ff73 DV	59
9da3da66	60	ret = sg_alloc_table(st, obj->pages->nents, GFP_KERNEL);
5cfacded CW	61	if (ret)
5cfacded CW	62	goto err_free;
9da3da66 CW	63
	64	src = obj->pages->sgl;
	65	dst = st->sgl;
	66	for (i = 0; i < obj->pages->nents; i++) {
67d5a50c	67	sg_set_page(dst, sg_page(src), src->length, 0);
9da3da66 CW	68	dst = sg_next(dst);
	69	src = sg_next(src);
	70	}
	71
	72	if (!dma_map_sg(attachment->dev, st->sgl, st->nents, dir)) {
5cfacded CW	73	ret =-ENOMEM;
5cfacded CW	74	goto err_free_sg;
1286ff73 DV	75	}
1286ff73 DV	76
9da3da66 CW	77	mutex_unlock(&obj->base.dev->struct_mutex);
9da3da66 CW	78	return st;
5cfacded CW	79
	80	err_free_sg:
	81	sg_free_table(st);
	82	err_free:
	83	kfree(st);
	84	err_unpin:
	85	i915_gem_object_unpin_pages(obj);
	86	err_unlock:
	87	mutex_unlock(&obj->base.dev->struct_mutex);
	88	err:
	89	return ERR_PTR(ret);
1286ff73 DV	90	}
1286ff73 DV	91
6a101cb2	92	static void i915_gem_unmap_dma_buf(struct dma_buf_attachment *attachment,
2f745ad3 CW	93	struct sg_table *sg,
2f745ad3 CW	94	enum dma_data_direction dir)
1286ff73	95	{
608806a5	96	struct drm_i915_gem_object *obj = dma_buf_to_obj(attachment->dmabuf);
f214266c DV	97
	98	mutex_lock(&obj->base.dev->struct_mutex);
	99
1286ff73 DV	100	dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
	101	sg_free_table(sg);
	102	kfree(sg);
f214266c DV	103
	104	i915_gem_object_unpin_pages(obj);
	105
	106	mutex_unlock(&obj->base.dev->struct_mutex);
1286ff73 DV	107	}
1286ff73 DV	108
9a70cc2a DA	109	static void i915_gem_dmabuf_vmap(struct dma_buf dma_buf)
9a70cc2a DA	110	{
608806a5	111	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
9a70cc2a	112	struct drm_device *dev = obj->base.dev;
67d5a50c	113	struct sg_page_iter sg_iter;
9da3da66 CW	114	struct page **pages;
9da3da66 CW	115	int ret, i;
9a70cc2a DA	116
	117	ret = i915_mutex_lock_interruptible(dev);
	118	if (ret)
	119	return ERR_PTR(ret);
	120
	121	if (obj->dma_buf_vmapping) {
	122	obj->vmapping_count++;
	123	goto out_unlock;
	124	}
	125
37e680a1	126	ret = i915_gem_object_get_pages(obj);
9da3da66	127	if (ret)
993fc6eb CW	128	goto err;
	129
	130	i915_gem_object_pin_pages(obj);
9a70cc2a	131
9da3da66 CW	132	ret = -ENOMEM;
9da3da66 CW	133
67d5a50c	134	pages = drm_malloc_ab(obj->base.size >> PAGE_SHIFT, sizeof(*pages));
9da3da66	135	if (pages == NULL)
993fc6eb	136	goto err_unpin;
9da3da66	137
67d5a50c	138	i = 0;
b11b88ef	139	for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0)
2db76d7c	140	pages[i++] = sg_page_iter_page(&sg_iter);
9da3da66	141
67d5a50c	142	obj->dma_buf_vmapping = vmap(pages, i, 0, PAGE_KERNEL);
9da3da66 CW	143	drm_free_large(pages);
	144
	145	if (!obj->dma_buf_vmapping)
993fc6eb	146	goto err_unpin;
9a70cc2a DA	147
	148	obj->vmapping_count = 1;
	149	out_unlock:
	150	mutex_unlock(&dev->struct_mutex);
	151	return obj->dma_buf_vmapping;
9da3da66	152
993fc6eb CW	153	err_unpin:
	154	i915_gem_object_unpin_pages(obj);
	155	err:
9da3da66 CW	156	mutex_unlock(&dev->struct_mutex);
9da3da66 CW	157	return ERR_PTR(ret);
9a70cc2a DA	158	}
	159
	160	static void i915_gem_dmabuf_vunmap(struct dma_buf dma_buf, void vaddr)
	161	{
608806a5	162	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
9a70cc2a	163	struct drm_device *dev = obj->base.dev;
9a70cc2a	164
ce7ec768	165	mutex_lock(&dev->struct_mutex);
a5570178	166	if (--obj->vmapping_count == 0) {
9a70cc2a DA	167	vunmap(obj->dma_buf_vmapping);
9a70cc2a DA	168	obj->dma_buf_vmapping = NULL;
a5570178 CW	169
a5570178 CW	170	i915_gem_object_unpin_pages(obj);
9a70cc2a DA	171	}
	172	mutex_unlock(&dev->struct_mutex);
	173	}
	174
1286ff73 DV	175	static void i915_gem_dmabuf_kmap_atomic(struct dma_buf dma_buf, unsigned long page_num)
	176	{
	177	return NULL;
	178	}
	179
	180	static void i915_gem_dmabuf_kunmap_atomic(struct dma_buf dma_buf, unsigned long page_num, void addr)
	181	{
	182
	183	}
	184	static void i915_gem_dmabuf_kmap(struct dma_buf dma_buf, unsigned long page_num)
	185	{
	186	return NULL;
	187	}
	188
	189	static void i915_gem_dmabuf_kunmap(struct dma_buf dma_buf, unsigned long page_num, void addr)
	190	{
	191
	192	}
	193
2dad9d4d DA	194	static int i915_gem_dmabuf_mmap(struct dma_buf dma_buf, struct vm_area_struct vma)
2dad9d4d DA	195	{
2dbf0d90 TV	196	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
	197	int ret;
	198
	199	if (obj->base.size < vma->vm_end - vma->vm_start)
	200	return -EINVAL;
	201
	202	if (!obj->base.filp)
	203	return -ENODEV;
	204
	205	ret = obj->base.filp->f_op->mmap(obj->base.filp, vma);
	206	if (ret)
	207	return ret;
	208
	209	fput(vma->vm_file);
	210	vma->vm_file = get_file(obj->base.filp);
	211
	212	return 0;
2dad9d4d DA	213	}
2dad9d4d DA	214
831e9da7	215	static int i915_gem_begin_cpu_access(struct dma_buf *dma_buf, enum dma_data_direction direction)
ec6f1bb9	216	{
608806a5	217	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
ec6f1bb9 DA	218	struct drm_device *dev = obj->base.dev;
	219	int ret;
	220	bool write = (direction == DMA_BIDIRECTIONAL \|\| direction == DMA_TO_DEVICE);
	221
	222	ret = i915_mutex_lock_interruptible(dev);
	223	if (ret)
	224	return ret;
	225
	226	ret = i915_gem_object_set_to_cpu_domain(obj, write);
	227	mutex_unlock(&dev->struct_mutex);
	228	return ret;
	229	}
	230
18b862dc	231	static int i915_gem_end_cpu_access(struct dma_buf *dma_buf, enum dma_data_direction direction)
346400c8 TV	232	{
	233	struct drm_i915_gem_object *obj = dma_buf_to_obj(dma_buf);
	234	struct drm_device *dev = obj->base.dev;
346400c8 TV	235	int ret;
346400c8 TV	236
18b862dc CW	237	ret = i915_mutex_lock_interruptible(dev);
	238	if (ret)
	239	return ret;
346400c8 TV	240
346400c8 TV	241	ret = i915_gem_object_set_to_gtt_domain(obj, false);
346400c8 TV	242	mutex_unlock(&dev->struct_mutex);
346400c8 TV	243
18b862dc	244	return ret;
346400c8 TV	245	}
346400c8 TV	246
6a101cb2	247	static const struct dma_buf_ops i915_dmabuf_ops = {
1286ff73 DV	248	.map_dma_buf = i915_gem_map_dma_buf,
1286ff73 DV	249	.unmap_dma_buf = i915_gem_unmap_dma_buf,
c1d6798d	250	.release = drm_gem_dmabuf_release,
1286ff73 DV	251	.kmap = i915_gem_dmabuf_kmap,
	252	.kmap_atomic = i915_gem_dmabuf_kmap_atomic,
	253	.kunmap = i915_gem_dmabuf_kunmap,
	254	.kunmap_atomic = i915_gem_dmabuf_kunmap_atomic,
2dad9d4d	255	.mmap = i915_gem_dmabuf_mmap,
9a70cc2a DA	256	.vmap = i915_gem_dmabuf_vmap,
9a70cc2a DA	257	.vunmap = i915_gem_dmabuf_vunmap,
ec6f1bb9	258	.begin_cpu_access = i915_gem_begin_cpu_access,
346400c8	259	.end_cpu_access = i915_gem_end_cpu_access,
1286ff73 DV	260	};
	261
	262	struct dma_buf i915_gem_prime_export(struct drm_device dev,
9da3da66	263	struct drm_gem_object *gem_obj, int flags)
1286ff73	264	{
5cc9ed4b	265	struct drm_i915_gem_object *obj = to_intel_bo(gem_obj);
d8fbe341 SS	266	DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
	267
	268	exp_info.ops = &i915_dmabuf_ops;
	269	exp_info.size = gem_obj->size;
	270	exp_info.flags = flags;
	271	exp_info.priv = gem_obj;
	272
5cc9ed4b CW	273
	274	if (obj->ops->dmabuf_export) {
	275	int ret = obj->ops->dmabuf_export(obj);
	276	if (ret)
	277	return ERR_PTR(ret);
	278	}
	279
d8fbe341	280	return dma_buf_export(&exp_info);
1286ff73 DV	281	}
1286ff73 DV	282
2f745ad3 CW	283	static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj)
	284	{
	285	struct sg_table *sg;
	286
	287	sg = dma_buf_map_attachment(obj->base.import_attach, DMA_BIDIRECTIONAL);
	288	if (IS_ERR(sg))
	289	return PTR_ERR(sg);
	290
	291	obj->pages = sg;
2f745ad3	292	return 0;
1286ff73 DV	293	}
1286ff73 DV	294
2f745ad3 CW	295	static void i915_gem_object_put_pages_dmabuf(struct drm_i915_gem_object *obj)
	296	{
	297	dma_buf_unmap_attachment(obj->base.import_attach,
	298	obj->pages, DMA_BIDIRECTIONAL);
2f745ad3 CW	299	}
	300
	301	static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = {
	302	.get_pages = i915_gem_object_get_pages_dmabuf,
	303	.put_pages = i915_gem_object_put_pages_dmabuf,
	304	};
	305
1286ff73	306	struct drm_gem_object i915_gem_prime_import(struct drm_device dev,
9da3da66	307	struct dma_buf *dma_buf)
1286ff73 DV	308	{
1286ff73 DV	309	struct dma_buf_attachment *attach;
1286ff73	310	struct drm_i915_gem_object *obj;
1286ff73 DV	311	int ret;
	312
	313	/* is this one of own objects? */
	314	if (dma_buf->ops == &i915_dmabuf_ops) {
608806a5	315	obj = dma_buf_to_obj(dma_buf);
1286ff73 DV	316	/* is it from our device? */
1286ff73 DV	317	if (obj->base.dev == dev) {
be8a42ae SWK	318	/*
	319	* Importing dmabuf exported from out own gem increases
	320	* refcount on gem itself instead of f_count of dmabuf.
	321	*/
1286ff73 DV	322	drm_gem_object_reference(&obj->base);
	323	return &obj->base;
	324	}
	325	}
	326
	327	/* need to attach */
	328	attach = dma_buf_attach(dma_buf, dev->dev);
	329	if (IS_ERR(attach))
	330	return ERR_CAST(attach);
	331
011c2282 ID	332	get_dma_buf(dma_buf);
011c2282 ID	333
42dcedd4	334	obj = i915_gem_object_alloc(dev);
1286ff73 DV	335	if (obj == NULL) {
1286ff73 DV	336	ret = -ENOMEM;
2f745ad3	337	goto fail_detach;
1286ff73 DV	338	}
1286ff73 DV	339
89c8233f	340	drm_gem_private_object_init(dev, &obj->base, dma_buf->size);
2f745ad3	341	i915_gem_object_init(obj, &i915_gem_object_dmabuf_ops);
1286ff73 DV	342	obj->base.import_attach = attach;
	343
	344	return &obj->base;
	345
1286ff73 DV	346	fail_detach:
1286ff73 DV	347	dma_buf_detach(dma_buf, attach);
011c2282 ID	348	dma_buf_put(dma_buf);
011c2282 ID	349
1286ff73 DV	350	return ERR_PTR(ret);
1286ff73 DV	351	}