[mirror_ubuntu-jammy-kernel.git] / drivers / gpu / drm / tegra / gem.c

/*
 * NVIDIA Tegra DRM GEM helper functions
 *
 * Copyright (C) 2012 Sascha Hauer, Pengutronix
 * Copyright (C) 2013 NVIDIA CORPORATION, All rights reserved.
 *
 * Based on the GEM/CMA helpers
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/dma-buf.h>
#include <drm/tegra_drm.h>

#include "drm.h"
#include "gem.h"

static inline struct tegra_bo *host1x_to_tegra_bo(struct host1x_bo *bo)
{
	return container_of(bo, struct tegra_bo, base);
}

static void tegra_bo_put(struct host1x_bo *bo)
{
	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
	struct drm_device *drm = obj->gem.dev;

	mutex_lock(&drm->struct_mutex);
	drm_gem_object_unreference(&obj->gem);
	mutex_unlock(&drm->struct_mutex);
}

static dma_addr_t tegra_bo_pin(struct host1x_bo *bo, struct sg_table **sgt)
{
	struct tegra_bo *obj = host1x_to_tegra_bo(bo);

	return obj->paddr;
}

static void tegra_bo_unpin(struct host1x_bo *bo, struct sg_table *sgt)
{
}

static void *tegra_bo_mmap(struct host1x_bo *bo)
{
	struct tegra_bo *obj = host1x_to_tegra_bo(bo);

	return obj->vaddr;
}

static void tegra_bo_munmap(struct host1x_bo *bo, void *addr)
{
}

static void *tegra_bo_kmap(struct host1x_bo *bo, unsigned int page)
{
	struct tegra_bo *obj = host1x_to_tegra_bo(bo);

	return obj->vaddr + page * PAGE_SIZE;
}

static void tegra_bo_kunmap(struct host1x_bo *bo, unsigned int page,
			    void *addr)
{
}

static struct host1x_bo *tegra_bo_get(struct host1x_bo *bo)
{
	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
	struct drm_device *drm = obj->gem.dev;

	mutex_lock(&drm->struct_mutex);
	drm_gem_object_reference(&obj->gem);
	mutex_unlock(&drm->struct_mutex);

	return bo;
}

static const struct host1x_bo_ops tegra_bo_ops = {
	.get = tegra_bo_get,
	.put = tegra_bo_put,
	.pin = tegra_bo_pin,
	.unpin = tegra_bo_unpin,
	.mmap = tegra_bo_mmap,
	.munmap = tegra_bo_munmap,
	.kmap = tegra_bo_kmap,
	.kunmap = tegra_bo_kunmap,
};

static void tegra_bo_destroy(struct drm_device *drm, struct tegra_bo *bo)
{
	dma_free_writecombine(drm->dev, bo->gem.size, bo->vaddr, bo->paddr);
}

struct tegra_bo *tegra_bo_create(struct drm_device *drm, unsigned int size,
				 unsigned long flags)
{
	struct tegra_bo *bo;
	int err;

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

	host1x_bo_init(&bo->base, &tegra_bo_ops);
	size = round_up(size, PAGE_SIZE);

	bo->vaddr = dma_alloc_writecombine(drm->dev, size, &bo->paddr,
					   GFP_KERNEL | __GFP_NOWARN);
	if (!bo->vaddr) {
		dev_err(drm->dev, "failed to allocate buffer with size %u\n",
			size);
		err = -ENOMEM;
		goto err_dma;
	}

	err = drm_gem_object_init(drm, &bo->gem, size);
	if (err)
		goto err_init;

	err = drm_gem_create_mmap_offset(&bo->gem);
	if (err)
		goto err_mmap;

	if (flags & DRM_TEGRA_GEM_CREATE_TILED)
		bo->tiling.mode = TEGRA_BO_TILING_MODE_TILED;

	if (flags & DRM_TEGRA_GEM_CREATE_BOTTOM_UP)
		bo->flags |= TEGRA_BO_BOTTOM_UP;

	return bo;

err_mmap:
	drm_gem_object_release(&bo->gem);
err_init:
	tegra_bo_destroy(drm, bo);
err_dma:
	kfree(bo);

	return ERR_PTR(err);
}

struct tegra_bo *tegra_bo_create_with_handle(struct drm_file *file,
					     struct drm_device *drm,
					     unsigned int size,
					     unsigned long flags,
					     unsigned int *handle)
{
	struct tegra_bo *bo;
	int ret;

	bo = tegra_bo_create(drm, size, flags);
	if (IS_ERR(bo))
		return bo;

	ret = drm_gem_handle_create(file, &bo->gem, handle);
	if (ret)
		goto err;

	drm_gem_object_unreference_unlocked(&bo->gem);

	return bo;

err:
	tegra_bo_free_object(&bo->gem);
	return ERR_PTR(ret);
}

static struct tegra_bo *tegra_bo_import(struct drm_device *drm,
					struct dma_buf *buf)
{
	struct dma_buf_attachment *attach;
	struct tegra_bo *bo;
	ssize_t size;
	int err;

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

	host1x_bo_init(&bo->base, &tegra_bo_ops);
	size = round_up(buf->size, PAGE_SIZE);

	err = drm_gem_object_init(drm, &bo->gem, size);
	if (err < 0)
		goto free;

	err = drm_gem_create_mmap_offset(&bo->gem);
	if (err < 0)
		goto release;

	attach = dma_buf_attach(buf, drm->dev);
	if (IS_ERR(attach)) {
		err = PTR_ERR(attach);
		goto free_mmap;
	}

	get_dma_buf(buf);

	bo->sgt = dma_buf_map_attachment(attach, DMA_TO_DEVICE);
	if (!bo->sgt) {
		err = -ENOMEM;
		goto detach;
	}

	if (IS_ERR(bo->sgt)) {
		err = PTR_ERR(bo->sgt);
		goto detach;
	}

	if (bo->sgt->nents > 1) {
		err = -EINVAL;
		goto detach;
	}

	bo->paddr = sg_dma_address(bo->sgt->sgl);
	bo->gem.import_attach = attach;

	return bo;

detach:
	if (!IS_ERR_OR_NULL(bo->sgt))
		dma_buf_unmap_attachment(attach, bo->sgt, DMA_TO_DEVICE);

	dma_buf_detach(buf, attach);
	dma_buf_put(buf);
free_mmap:
	drm_gem_free_mmap_offset(&bo->gem);
release:
	drm_gem_object_release(&bo->gem);
free:
	kfree(bo);

	return ERR_PTR(err);
}

void tegra_bo_free_object(struct drm_gem_object *gem)
{
	struct tegra_bo *bo = to_tegra_bo(gem);

	if (gem->import_attach) {
		dma_buf_unmap_attachment(gem->import_attach, bo->sgt,
					 DMA_TO_DEVICE);
		drm_prime_gem_destroy(gem, NULL);
	} else {
		tegra_bo_destroy(gem->dev, bo);
	}

	drm_gem_free_mmap_offset(gem);
	drm_gem_object_release(gem);

	kfree(bo);
}

int tegra_bo_dumb_create(struct drm_file *file, struct drm_device *drm,
			 struct drm_mode_create_dumb *args)
{
	int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
	struct tegra_drm *tegra = drm->dev_private;
	struct tegra_bo *bo;

	min_pitch = round_up(min_pitch, tegra->pitch_align);
	if (args->pitch < min_pitch)
		args->pitch = min_pitch;

	if (args->size < args->pitch * args->height)
		args->size = args->pitch * args->height;

	bo = tegra_bo_create_with_handle(file, drm, args->size, 0,
					 &args->handle);
	if (IS_ERR(bo))
		return PTR_ERR(bo);

	return 0;
}

int tegra_bo_dumb_map_offset(struct drm_file *file, struct drm_device *drm,
			     uint32_t handle, uint64_t *offset)
{
	struct drm_gem_object *gem;
	struct tegra_bo *bo;

	mutex_lock(&drm->struct_mutex);

	gem = drm_gem_object_lookup(drm, file, handle);
	if (!gem) {
		dev_err(drm->dev, "failed to lookup GEM object\n");
		mutex_unlock(&drm->struct_mutex);
		return -EINVAL;
	}

	bo = to_tegra_bo(gem);

	*offset = drm_vma_node_offset_addr(&bo->gem.vma_node);

	drm_gem_object_unreference(gem);

	mutex_unlock(&drm->struct_mutex);

	return 0;
}

const struct vm_operations_struct tegra_bo_vm_ops = {
	.open = drm_gem_vm_open,
	.close = drm_gem_vm_close,
};

int tegra_drm_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct drm_gem_object *gem;
	struct tegra_bo *bo;
	int ret;

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

	gem = vma->vm_private_data;
	bo = to_tegra_bo(gem);

	ret = remap_pfn_range(vma, vma->vm_start, bo->paddr >> PAGE_SHIFT,
			      vma->vm_end - vma->vm_start, vma->vm_page_prot);
	if (ret)
		drm_gem_vm_close(vma);

	return ret;
}

static struct sg_table *
tegra_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
			    enum dma_data_direction dir)
{
	struct drm_gem_object *gem = attach->dmabuf->priv;
	struct tegra_bo *bo = to_tegra_bo(gem);
	struct sg_table *sgt;

	sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
	if (!sgt)
		return NULL;

	if (sg_alloc_table(sgt, 1, GFP_KERNEL)) {
		kfree(sgt);
		return NULL;
	}

	sg_dma_address(sgt->sgl) = bo->paddr;
	sg_dma_len(sgt->sgl) = gem->size;

	return sgt;
}

static void tegra_gem_prime_unmap_dma_buf(struct dma_buf_attachment *attach,
					  struct sg_table *sgt,
					  enum dma_data_direction dir)
{
	sg_free_table(sgt);
	kfree(sgt);
}

static void tegra_gem_prime_release(struct dma_buf *buf)
{
	drm_gem_dmabuf_release(buf);
}

static void *tegra_gem_prime_kmap_atomic(struct dma_buf *buf,
					 unsigned long page)
{
	return NULL;
}

static void tegra_gem_prime_kunmap_atomic(struct dma_buf *buf,
					  unsigned long page,
					  void *addr)
{
}

static void *tegra_gem_prime_kmap(struct dma_buf *buf, unsigned long page)
{
	return NULL;
}

static void tegra_gem_prime_kunmap(struct dma_buf *buf, unsigned long page,
				   void *addr)
{
}

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

static void *tegra_gem_prime_vmap(struct dma_buf *buf)
{
	struct drm_gem_object *gem = buf->priv;
	struct tegra_bo *bo = to_tegra_bo(gem);

	return bo->vaddr;
}

static void tegra_gem_prime_vunmap(struct dma_buf *buf, void *vaddr)
{
}

static const struct dma_buf_ops tegra_gem_prime_dmabuf_ops = {
	.map_dma_buf = tegra_gem_prime_map_dma_buf,
	.unmap_dma_buf = tegra_gem_prime_unmap_dma_buf,
	.release = tegra_gem_prime_release,
	.kmap_atomic = tegra_gem_prime_kmap_atomic,
	.kunmap_atomic = tegra_gem_prime_kunmap_atomic,
	.kmap = tegra_gem_prime_kmap,
	.kunmap = tegra_gem_prime_kunmap,
	.mmap = tegra_gem_prime_mmap,
	.vmap = tegra_gem_prime_vmap,
	.vunmap = tegra_gem_prime_vunmap,
};

struct dma_buf *tegra_gem_prime_export(struct drm_device *drm,
				       struct drm_gem_object *gem,
				       int flags)
{
	return dma_buf_export(gem, &tegra_gem_prime_dmabuf_ops, gem->size,
			      flags, NULL);
}

struct drm_gem_object *tegra_gem_prime_import(struct drm_device *drm,
					      struct dma_buf *buf)
{
	struct tegra_bo *bo;

	if (buf->ops == &tegra_gem_prime_dmabuf_ops) {
		struct drm_gem_object *gem = buf->priv;

		if (gem->dev == drm) {
			drm_gem_object_reference(gem);
			return gem;
		}
	}

	bo = tegra_bo_import(drm, buf);
	if (IS_ERR(bo))
		return ERR_CAST(bo);

	return &bo->gem;
}
Commit	Line	Data
de2ba664 AM	1	/*
	2	* NVIDIA Tegra DRM GEM helper functions
	3	*
	4	* Copyright (C) 2012 Sascha Hauer, Pengutronix
	5	* Copyright (C) 2013 NVIDIA CORPORATION, All rights reserved.
	6	*
	7	* Based on the GEM/CMA helpers
	8	*
	9	* Copyright (c) 2011 Samsung Electronics Co., Ltd.
	10	*
9a2ac2dc TR	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License version 2 as
	13	* published by the Free Software Foundation.
de2ba664 AM	14	*/
de2ba664 AM	15
3800391d	16	#include <linux/dma-buf.h>
773af77f TR	17	#include <drm/tegra_drm.h>
773af77f TR	18
d1f3e1e0	19	#include "drm.h"
de2ba664 AM	20	#include "gem.h"
de2ba664 AM	21
3be82743	22	static inline struct tegra_bo host1x_to_tegra_bo(struct host1x_bo bo)
de2ba664 AM	23	{
	24	return container_of(bo, struct tegra_bo, base);
	25	}
	26
	27	static void tegra_bo_put(struct host1x_bo *bo)
	28	{
3be82743	29	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	30	struct drm_device *drm = obj->gem.dev;
	31
	32	mutex_lock(&drm->struct_mutex);
	33	drm_gem_object_unreference(&obj->gem);
	34	mutex_unlock(&drm->struct_mutex);
	35	}
	36
	37	static dma_addr_t tegra_bo_pin(struct host1x_bo bo, struct sg_table *sgt)
	38	{
3be82743	39	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	40
	41	return obj->paddr;
	42	}
	43
	44	static void tegra_bo_unpin(struct host1x_bo bo, struct sg_table sgt)
	45	{
	46	}
	47
	48	static void tegra_bo_mmap(struct host1x_bo bo)
	49	{
3be82743	50	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	51
	52	return obj->vaddr;
	53	}
	54
	55	static void tegra_bo_munmap(struct host1x_bo bo, void addr)
	56	{
	57	}
	58
	59	static void tegra_bo_kmap(struct host1x_bo bo, unsigned int page)
	60	{
3be82743	61	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	62
	63	return obj->vaddr + page * PAGE_SIZE;
	64	}
	65
	66	static void tegra_bo_kunmap(struct host1x_bo *bo, unsigned int page,
	67	void *addr)
	68	{
	69	}
	70
	71	static struct host1x_bo tegra_bo_get(struct host1x_bo bo)
	72	{
3be82743	73	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	74	struct drm_device *drm = obj->gem.dev;
	75
	76	mutex_lock(&drm->struct_mutex);
	77	drm_gem_object_reference(&obj->gem);
	78	mutex_unlock(&drm->struct_mutex);
	79
	80	return bo;
	81	}
	82
425c0fdc	83	static const struct host1x_bo_ops tegra_bo_ops = {
de2ba664 AM	84	.get = tegra_bo_get,
	85	.put = tegra_bo_put,
	86	.pin = tegra_bo_pin,
	87	.unpin = tegra_bo_unpin,
	88	.mmap = tegra_bo_mmap,
	89	.munmap = tegra_bo_munmap,
	90	.kmap = tegra_bo_kmap,
	91	.kunmap = tegra_bo_kunmap,
	92	};
	93
	94	static void tegra_bo_destroy(struct drm_device drm, struct tegra_bo bo)
	95	{
	96	dma_free_writecombine(drm->dev, bo->gem.size, bo->vaddr, bo->paddr);
	97	}
	98
773af77f TR	99	struct tegra_bo tegra_bo_create(struct drm_device drm, unsigned int size,
773af77f TR	100	unsigned long flags)
de2ba664 AM	101	{
	102	struct tegra_bo *bo;
	103	int err;
	104
	105	bo = kzalloc(sizeof(*bo), GFP_KERNEL);
	106	if (!bo)
	107	return ERR_PTR(-ENOMEM);
	108
	109	host1x_bo_init(&bo->base, &tegra_bo_ops);
	110	size = round_up(size, PAGE_SIZE);
	111
	112	bo->vaddr = dma_alloc_writecombine(drm->dev, size, &bo->paddr,
	113	GFP_KERNEL \| __GFP_NOWARN);
	114	if (!bo->vaddr) {
	115	dev_err(drm->dev, "failed to allocate buffer with size %u\n",
	116	size);
	117	err = -ENOMEM;
	118	goto err_dma;
	119	}
	120
	121	err = drm_gem_object_init(drm, &bo->gem, size);
	122	if (err)
	123	goto err_init;
	124
	125	err = drm_gem_create_mmap_offset(&bo->gem);
	126	if (err)
	127	goto err_mmap;
	128
773af77f	129	if (flags & DRM_TEGRA_GEM_CREATE_TILED)
c134f019	130	bo->tiling.mode = TEGRA_BO_TILING_MODE_TILED;
773af77f	131
db7fbdfd TR	132	if (flags & DRM_TEGRA_GEM_CREATE_BOTTOM_UP)
	133	bo->flags \|= TEGRA_BO_BOTTOM_UP;
	134
de2ba664 AM	135	return bo;
	136
	137	err_mmap:
	138	drm_gem_object_release(&bo->gem);
	139	err_init:
	140	tegra_bo_destroy(drm, bo);
	141	err_dma:
	142	kfree(bo);
	143
	144	return ERR_PTR(err);
de2ba664 AM	145	}
	146
	147	struct tegra_bo tegra_bo_create_with_handle(struct drm_file file,
3be82743 TR	148	struct drm_device *drm,
3be82743 TR	149	unsigned int size,
773af77f	150	unsigned long flags,
3be82743	151	unsigned int *handle)
de2ba664 AM	152	{
	153	struct tegra_bo *bo;
	154	int ret;
	155
773af77f	156	bo = tegra_bo_create(drm, size, flags);
de2ba664 AM	157	if (IS_ERR(bo))
	158	return bo;
	159
	160	ret = drm_gem_handle_create(file, &bo->gem, handle);
	161	if (ret)
	162	goto err;
	163
	164	drm_gem_object_unreference_unlocked(&bo->gem);
	165
	166	return bo;
	167
	168	err:
	169	tegra_bo_free_object(&bo->gem);
	170	return ERR_PTR(ret);
	171	}
	172
540457cc TR	173	static struct tegra_bo tegra_bo_import(struct drm_device drm,
540457cc TR	174	struct dma_buf *buf)
3800391d TR	175	{
	176	struct dma_buf_attachment *attach;
	177	struct tegra_bo *bo;
	178	ssize_t size;
	179	int err;
	180
	181	bo = kzalloc(sizeof(*bo), GFP_KERNEL);
	182	if (!bo)
	183	return ERR_PTR(-ENOMEM);
	184
	185	host1x_bo_init(&bo->base, &tegra_bo_ops);
	186	size = round_up(buf->size, PAGE_SIZE);
	187
	188	err = drm_gem_object_init(drm, &bo->gem, size);
	189	if (err < 0)
	190	goto free;
	191
	192	err = drm_gem_create_mmap_offset(&bo->gem);
	193	if (err < 0)
	194	goto release;
	195
	196	attach = dma_buf_attach(buf, drm->dev);
	197	if (IS_ERR(attach)) {
	198	err = PTR_ERR(attach);
	199	goto free_mmap;
	200	}
	201
	202	get_dma_buf(buf);
	203
	204	bo->sgt = dma_buf_map_attachment(attach, DMA_TO_DEVICE);
	205	if (!bo->sgt) {
	206	err = -ENOMEM;
	207	goto detach;
	208	}
	209
	210	if (IS_ERR(bo->sgt)) {
	211	err = PTR_ERR(bo->sgt);
	212	goto detach;
	213	}
	214
	215	if (bo->sgt->nents > 1) {
	216	err = -EINVAL;
	217	goto detach;
	218	}
	219
	220	bo->paddr = sg_dma_address(bo->sgt->sgl);
	221	bo->gem.import_attach = attach;
	222
	223	return bo;
	224
	225	detach:
	226	if (!IS_ERR_OR_NULL(bo->sgt))
	227	dma_buf_unmap_attachment(attach, bo->sgt, DMA_TO_DEVICE);
	228
	229	dma_buf_detach(buf, attach);
	230	dma_buf_put(buf);
	231	free_mmap:
	232	drm_gem_free_mmap_offset(&bo->gem);
	233	release:
	234	drm_gem_object_release(&bo->gem);
	235	free:
	236	kfree(bo);
	237
	238	return ERR_PTR(err);
239	}
240
de2ba664 AM	241	void tegra_bo_free_object(struct drm_gem_object *gem)
	242	{
	243	struct tegra_bo *bo = to_tegra_bo(gem);
	244
3800391d TR	245	if (gem->import_attach) {
	246	dma_buf_unmap_attachment(gem->import_attach, bo->sgt,
	247	DMA_TO_DEVICE);
	248	drm_prime_gem_destroy(gem, NULL);
	249	} else {
	250	tegra_bo_destroy(gem->dev, bo);
	251	}
	252
0de23977	253	drm_gem_free_mmap_offset(gem);
de2ba664	254	drm_gem_object_release(gem);
de2ba664 AM	255
	256	kfree(bo);
	257	}
	258
	259	int tegra_bo_dumb_create(struct drm_file file, struct drm_device drm,
	260	struct drm_mode_create_dumb *args)
	261	{
	262	int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
d1f3e1e0	263	struct tegra_drm *tegra = drm->dev_private;
de2ba664 AM	264	struct tegra_bo *bo;
de2ba664 AM	265
d1f3e1e0	266	min_pitch = round_up(min_pitch, tegra->pitch_align);
de2ba664 AM	267	if (args->pitch < min_pitch)
	268	args->pitch = min_pitch;
	269
	270	if (args->size < args->pitch * args->height)
	271	args->size = args->pitch * args->height;
	272
773af77f	273	bo = tegra_bo_create_with_handle(file, drm, args->size, 0,
3be82743	274	&args->handle);
de2ba664 AM	275	if (IS_ERR(bo))
	276	return PTR_ERR(bo);
	277
	278	return 0;
	279	}
	280
	281	int tegra_bo_dumb_map_offset(struct drm_file file, struct drm_device drm,
	282	uint32_t handle, uint64_t *offset)
	283	{
	284	struct drm_gem_object *gem;
	285	struct tegra_bo *bo;
	286
	287	mutex_lock(&drm->struct_mutex);
	288
	289	gem = drm_gem_object_lookup(drm, file, handle);
	290	if (!gem) {
	291	dev_err(drm->dev, "failed to lookup GEM object\n");
	292	mutex_unlock(&drm->struct_mutex);
	293	return -EINVAL;
	294	}
	295
	296	bo = to_tegra_bo(gem);
	297
2bc7b0ca	298	*offset = drm_vma_node_offset_addr(&bo->gem.vma_node);
de2ba664 AM	299
	300	drm_gem_object_unreference(gem);
	301
	302	mutex_unlock(&drm->struct_mutex);
	303
	304	return 0;
	305	}
	306
	307	const struct vm_operations_struct tegra_bo_vm_ops = {
	308	.open = drm_gem_vm_open,
	309	.close = drm_gem_vm_close,
	310	};
	311
	312	int tegra_drm_mmap(struct file file, struct vm_area_struct vma)
	313	{
	314	struct drm_gem_object *gem;
	315	struct tegra_bo *bo;
	316	int ret;
	317
	318	ret = drm_gem_mmap(file, vma);
	319	if (ret)
	320	return ret;
	321
	322	gem = vma->vm_private_data;
	323	bo = to_tegra_bo(gem);
	324
	325	ret = remap_pfn_range(vma, vma->vm_start, bo->paddr >> PAGE_SHIFT,
	326	vma->vm_end - vma->vm_start, vma->vm_page_prot);
	327	if (ret)
	328	drm_gem_vm_close(vma);
	329
	330	return ret;
	331	}
3800391d TR	332
	333	static struct sg_table *
	334	tegra_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
	335	enum dma_data_direction dir)
	336	{
	337	struct drm_gem_object *gem = attach->dmabuf->priv;
	338	struct tegra_bo *bo = to_tegra_bo(gem);
	339	struct sg_table *sgt;
	340
	341	sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
	342	if (!sgt)
	343	return NULL;
	344
	345	if (sg_alloc_table(sgt, 1, GFP_KERNEL)) {
	346	kfree(sgt);
	347	return NULL;
	348	}
	349
	350	sg_dma_address(sgt->sgl) = bo->paddr;
	351	sg_dma_len(sgt->sgl) = gem->size;
	352
	353	return sgt;
	354	}
	355
	356	static void tegra_gem_prime_unmap_dma_buf(struct dma_buf_attachment *attach,
	357	struct sg_table *sgt,
	358	enum dma_data_direction dir)
	359	{
	360	sg_free_table(sgt);
	361	kfree(sgt);
	362	}
	363
	364	static void tegra_gem_prime_release(struct dma_buf *buf)
	365	{
	366	drm_gem_dmabuf_release(buf);
	367	}
	368
	369	static void tegra_gem_prime_kmap_atomic(struct dma_buf buf,
	370	unsigned long page)
	371	{
	372	return NULL;
	373	}
	374
	375	static void tegra_gem_prime_kunmap_atomic(struct dma_buf *buf,
	376	unsigned long page,
	377	void *addr)
	378	{
	379	}
	380
	381	static void tegra_gem_prime_kmap(struct dma_buf buf, unsigned long page)
	382	{
	383	return NULL;
	384	}
	385
	386	static void tegra_gem_prime_kunmap(struct dma_buf *buf, unsigned long page,
	387	void *addr)
	388	{
	389	}
	390
	391	static int tegra_gem_prime_mmap(struct dma_buf buf, struct vm_area_struct vma)
	392	{
	393	return -EINVAL;
	394	}
	395
d40326f4 TR	396	static void tegra_gem_prime_vmap(struct dma_buf buf)
	397	{
	398	struct drm_gem_object *gem = buf->priv;
	399	struct tegra_bo *bo = to_tegra_bo(gem);
	400
	401	return bo->vaddr;
	402	}
	403
	404	static void tegra_gem_prime_vunmap(struct dma_buf buf, void vaddr)
	405	{
	406	}
	407
3800391d TR	408	static const struct dma_buf_ops tegra_gem_prime_dmabuf_ops = {
	409	.map_dma_buf = tegra_gem_prime_map_dma_buf,
	410	.unmap_dma_buf = tegra_gem_prime_unmap_dma_buf,
	411	.release = tegra_gem_prime_release,
	412	.kmap_atomic = tegra_gem_prime_kmap_atomic,
	413	.kunmap_atomic = tegra_gem_prime_kunmap_atomic,
	414	.kmap = tegra_gem_prime_kmap,
	415	.kunmap = tegra_gem_prime_kunmap,
	416	.mmap = tegra_gem_prime_mmap,
d40326f4 TR	417	.vmap = tegra_gem_prime_vmap,
d40326f4 TR	418	.vunmap = tegra_gem_prime_vunmap,
3800391d TR	419	};
	420
	421	struct dma_buf tegra_gem_prime_export(struct drm_device drm,
	422	struct drm_gem_object *gem,
	423	int flags)
	424	{
	425	return dma_buf_export(gem, &tegra_gem_prime_dmabuf_ops, gem->size,
3aac4502	426	flags, NULL);
3800391d TR	427	}
	428
	429	struct drm_gem_object tegra_gem_prime_import(struct drm_device drm,
	430	struct dma_buf *buf)
	431	{
	432	struct tegra_bo *bo;
	433
	434	if (buf->ops == &tegra_gem_prime_dmabuf_ops) {
	435	struct drm_gem_object *gem = buf->priv;
	436
	437	if (gem->dev == drm) {
	438	drm_gem_object_reference(gem);
	439	return gem;
	440	}
	441	}
	442
	443	bo = tegra_bo_import(drm, buf);
	444	if (IS_ERR(bo))
	445	return ERR_CAST(bo);
	446
	447	return &bo->gem;
	448	}