[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)
{
	struct drm_i915_gem_object *obj = attachment->dmabuf->priv;

	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_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	87	{
eb91626a DV	88	struct drm_i915_gem_object *obj = attachment->dmabuf->priv;
	89
	90	mutex_lock(&obj->base.dev->struct_mutex);
	91
1286ff73 DV	92	dma_unmap_sg(attachment->dev, sg->sgl, sg->nents, dir);
	93	sg_free_table(sg);
	94	kfree(sg);
eb91626a DV	95
	96	i915_gem_object_unpin_pages(obj);
	97
	98	mutex_unlock(&obj->base.dev->struct_mutex);
1286ff73 DV	99	}
1286ff73 DV	100
6a101cb2	101	static void i915_gem_dmabuf_release(struct dma_buf *dma_buf)
1286ff73 DV	102	{
	103	struct drm_i915_gem_object *obj = dma_buf->priv;
	104
	105	if (obj->base.export_dma_buf == dma_buf) {
	106	/* drop the reference on the export fd holds */
	107	obj->base.export_dma_buf = NULL;
	108	drm_gem_object_unreference_unlocked(&obj->base);
	109	}
	110	}
	111
9a70cc2a DA	112	static void i915_gem_dmabuf_vmap(struct dma_buf dma_buf)
	113	{
	114	struct drm_i915_gem_object *obj = dma_buf->priv;
	115	struct drm_device *dev = obj->base.dev;
67d5a50c	116	struct sg_page_iter sg_iter;
9da3da66 CW	117	struct page **pages;
9da3da66 CW	118	int ret, i;
9a70cc2a DA	119
	120	ret = i915_mutex_lock_interruptible(dev);
	121	if (ret)
	122	return ERR_PTR(ret);
	123
	124	if (obj->dma_buf_vmapping) {
	125	obj->vmapping_count++;
	126	goto out_unlock;
	127	}
	128
37e680a1	129	ret = i915_gem_object_get_pages(obj);
9da3da66 CW	130	if (ret)
9da3da66 CW	131	goto error;
9a70cc2a	132
9da3da66 CW	133	ret = -ENOMEM;
9da3da66 CW	134
67d5a50c	135	pages = drm_malloc_ab(obj->base.size >> PAGE_SHIFT, sizeof(*pages));
9da3da66 CW	136	if (pages == NULL)
	137	goto error;
	138
67d5a50c	139	i = 0;
b11b88ef	140	for_each_sg_page(obj->pages->sgl, &sg_iter, obj->pages->nents, 0)
2db76d7c	141	pages[i++] = sg_page_iter_page(&sg_iter);
9da3da66	142
67d5a50c	143	obj->dma_buf_vmapping = vmap(pages, i, 0, PAGE_KERNEL);
9da3da66 CW	144	drm_free_large(pages);
	145
	146	if (!obj->dma_buf_vmapping)
	147	goto error;
9a70cc2a DA	148
9a70cc2a DA	149	obj->vmapping_count = 1;
a5570178	150	i915_gem_object_pin_pages(obj);
9a70cc2a DA	151	out_unlock:
	152	mutex_unlock(&dev->struct_mutex);
	153	return obj->dma_buf_vmapping;
9da3da66 CW	154
	155	error:
	156	mutex_unlock(&dev->struct_mutex);
	157	return ERR_PTR(ret);
9a70cc2a DA	158	}
	159
	160	static void i915_gem_dmabuf_vunmap(struct dma_buf dma_buf, void vaddr)
	161	{
	162	struct drm_i915_gem_object *obj = dma_buf->priv;
	163	struct drm_device *dev = obj->base.dev;
	164	int ret;
	165
	166	ret = i915_mutex_lock_interruptible(dev);
	167	if (ret)
	168	return;
	169
a5570178	170	if (--obj->vmapping_count == 0) {
9a70cc2a DA	171	vunmap(obj->dma_buf_vmapping);
9a70cc2a DA	172	obj->dma_buf_vmapping = NULL;
a5570178 CW	173
a5570178 CW	174	i915_gem_object_unpin_pages(obj);
9a70cc2a DA	175	}
	176	mutex_unlock(&dev->struct_mutex);
	177	}
	178
1286ff73 DV	179	static void i915_gem_dmabuf_kmap_atomic(struct dma_buf dma_buf, unsigned long page_num)
	180	{
	181	return NULL;
	182	}
	183
	184	static void i915_gem_dmabuf_kunmap_atomic(struct dma_buf dma_buf, unsigned long page_num, void addr)
	185	{
	186
	187	}
	188	static void i915_gem_dmabuf_kmap(struct dma_buf dma_buf, unsigned long page_num)
	189	{
	190	return NULL;
	191	}
	192
	193	static void i915_gem_dmabuf_kunmap(struct dma_buf dma_buf, unsigned long page_num, void addr)
	194	{
	195
	196	}
	197
2dad9d4d DA	198	static int i915_gem_dmabuf_mmap(struct dma_buf dma_buf, struct vm_area_struct vma)
	199	{
	200	return -EINVAL;
	201	}
	202
ec6f1bb9 DA	203	static int i915_gem_begin_cpu_access(struct dma_buf *dma_buf, size_t start, size_t length, enum dma_data_direction direction)
	204	{
	205	struct drm_i915_gem_object *obj = dma_buf->priv;
	206	struct drm_device *dev = obj->base.dev;
	207	int ret;
	208	bool write = (direction == DMA_BIDIRECTIONAL \|\| direction == DMA_TO_DEVICE);
	209
	210	ret = i915_mutex_lock_interruptible(dev);
	211	if (ret)
	212	return ret;
	213
	214	ret = i915_gem_object_set_to_cpu_domain(obj, write);
	215	mutex_unlock(&dev->struct_mutex);
	216	return ret;
	217	}
	218
6a101cb2	219	static const struct dma_buf_ops i915_dmabuf_ops = {
1286ff73 DV	220	.map_dma_buf = i915_gem_map_dma_buf,
	221	.unmap_dma_buf = i915_gem_unmap_dma_buf,
	222	.release = i915_gem_dmabuf_release,
	223	.kmap = i915_gem_dmabuf_kmap,
	224	.kmap_atomic = i915_gem_dmabuf_kmap_atomic,
	225	.kunmap = i915_gem_dmabuf_kunmap,
	226	.kunmap_atomic = i915_gem_dmabuf_kunmap_atomic,
2dad9d4d	227	.mmap = i915_gem_dmabuf_mmap,
9a70cc2a DA	228	.vmap = i915_gem_dmabuf_vmap,
9a70cc2a DA	229	.vunmap = i915_gem_dmabuf_vunmap,
ec6f1bb9	230	.begin_cpu_access = i915_gem_begin_cpu_access,
1286ff73 DV	231	};
	232
	233	struct dma_buf i915_gem_prime_export(struct drm_device dev,
9da3da66	234	struct drm_gem_object *gem_obj, int flags)
1286ff73 DV	235	{
	236	struct drm_i915_gem_object *obj = to_intel_bo(gem_obj);
	237
5b42427f	238	return dma_buf_export(obj, &i915_dmabuf_ops, obj->base.size, flags);
1286ff73 DV	239	}
1286ff73 DV	240
2f745ad3 CW	241	static int i915_gem_object_get_pages_dmabuf(struct drm_i915_gem_object *obj)
	242	{
	243	struct sg_table *sg;
	244
	245	sg = dma_buf_map_attachment(obj->base.import_attach, DMA_BIDIRECTIONAL);
	246	if (IS_ERR(sg))
	247	return PTR_ERR(sg);
	248
	249	obj->pages = sg;
	250	obj->has_dma_mapping = true;
	251	return 0;
1286ff73 DV	252	}
1286ff73 DV	253
2f745ad3 CW	254	static void i915_gem_object_put_pages_dmabuf(struct drm_i915_gem_object *obj)
	255	{
	256	dma_buf_unmap_attachment(obj->base.import_attach,
	257	obj->pages, DMA_BIDIRECTIONAL);
	258	obj->has_dma_mapping = false;
	259	}
	260
	261	static const struct drm_i915_gem_object_ops i915_gem_object_dmabuf_ops = {
	262	.get_pages = i915_gem_object_get_pages_dmabuf,
	263	.put_pages = i915_gem_object_put_pages_dmabuf,
	264	};
	265
1286ff73	266	struct drm_gem_object i915_gem_prime_import(struct drm_device dev,
9da3da66	267	struct dma_buf *dma_buf)
1286ff73 DV	268	{
1286ff73 DV	269	struct dma_buf_attachment *attach;
1286ff73	270	struct drm_i915_gem_object *obj;
1286ff73 DV	271	int ret;
	272
	273	/* is this one of own objects? */
	274	if (dma_buf->ops == &i915_dmabuf_ops) {
	275	obj = dma_buf->priv;
	276	/* is it from our device? */
	277	if (obj->base.dev == dev) {
be8a42ae SWK	278	/*
	279	* Importing dmabuf exported from out own gem increases
	280	* refcount on gem itself instead of f_count of dmabuf.
	281	*/
1286ff73 DV	282	drm_gem_object_reference(&obj->base);
	283	return &obj->base;
	284	}
	285	}
	286
	287	/* need to attach */
	288	attach = dma_buf_attach(dma_buf, dev->dev);
	289	if (IS_ERR(attach))
	290	return ERR_CAST(attach);
	291
011c2282 ID	292	get_dma_buf(dma_buf);
011c2282 ID	293
42dcedd4	294	obj = i915_gem_object_alloc(dev);
1286ff73 DV	295	if (obj == NULL) {
1286ff73 DV	296	ret = -ENOMEM;
2f745ad3	297	goto fail_detach;
1286ff73 DV	298	}
1286ff73 DV	299
9da3da66	300	ret = drm_gem_private_object_init(dev, &obj->base, dma_buf->size);
1286ff73	301	if (ret) {
42dcedd4	302	i915_gem_object_free(obj);
2f745ad3	303	goto fail_detach;
1286ff73 DV	304	}
1286ff73 DV	305
2f745ad3	306	i915_gem_object_init(obj, &i915_gem_object_dmabuf_ops);
1286ff73 DV	307	obj->base.import_attach = attach;
	308
	309	return &obj->base;
	310
1286ff73 DV	311	fail_detach:
1286ff73 DV	312	dma_buf_detach(dma_buf, attach);
011c2282 ID	313	dma_buf_put(dma_buf);
011c2282 ID	314
1286ff73 DV	315	return ERR_PTR(ret);
1286ff73 DV	316	}