[deliverable/linux.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 <linux/iommu.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,
};

/*
 * A generic iommu_map_sg() function is being reviewed and will hopefully be
 * merged soon. At that point this function can be dropped in favour of the
 * one provided by the IOMMU API.
 */
static ssize_t __iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
			      struct scatterlist *sg, unsigned int nents,
			      int prot)
{
	struct scatterlist *s;
	size_t offset = 0;
	unsigned int i;
	int err;

	for_each_sg(sg, s, nents, i) {
		phys_addr_t phys = page_to_phys(sg_page(s));
		size_t length = s->offset + s->length;

		err = iommu_map(domain, iova + offset, phys, length, prot);
		if (err < 0) {
			iommu_unmap(domain, iova, offset);
			return err;
		}

		offset += length;
	}

	return offset;
}

static int tegra_bo_iommu_map(struct tegra_drm *tegra, struct tegra_bo *bo)
{
	int prot = IOMMU_READ | IOMMU_WRITE;
	ssize_t err;

	if (bo->mm)
		return -EBUSY;

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

	err = drm_mm_insert_node_generic(&tegra->mm, bo->mm, bo->gem.size,
					 PAGE_SIZE, 0, 0, 0);
	if (err < 0) {
		dev_err(tegra->drm->dev, "out of I/O virtual memory: %zd\n",
			err);
		goto free;
	}

	bo->paddr = bo->mm->start;

	err = __iommu_map_sg(tegra->domain, bo->paddr, bo->sgt->sgl,
			     bo->sgt->nents, prot);
	if (err < 0) {
		dev_err(tegra->drm->dev, "failed to map buffer: %zd\n", err);
		goto remove;
	}

	bo->size = err;

	return 0;

remove:
	drm_mm_remove_node(bo->mm);
free:
	kfree(bo->mm);
	return err;
}

static int tegra_bo_iommu_unmap(struct tegra_drm *tegra, struct tegra_bo *bo)
{
	if (!bo->mm)
		return 0;

	iommu_unmap(tegra->domain, bo->paddr, bo->size);
	drm_mm_remove_node(bo->mm);
	kfree(bo->mm);

	return 0;
}

static struct tegra_bo *tegra_bo_alloc_object(struct drm_device *drm,
					      size_t size)
{
	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);

	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;

	return bo;

release:
	drm_gem_object_release(&bo->gem);
free:
	kfree(bo);
	return ERR_PTR(err);
}

static void tegra_bo_free(struct drm_device *drm, struct tegra_bo *bo)
{
	if (bo->pages) {
		drm_gem_put_pages(&bo->gem, bo->pages, true, true);
		sg_free_table(bo->sgt);
		kfree(bo->sgt);
	} else {
		dma_free_writecombine(drm->dev, bo->gem.size, bo->vaddr,
				      bo->paddr);
	}
}

static int tegra_bo_get_pages(struct drm_device *drm, struct tegra_bo *bo,
			      size_t size)
{
	bo->pages = drm_gem_get_pages(&bo->gem);
	if (IS_ERR(bo->pages))
		return PTR_ERR(bo->pages);

	bo->num_pages = size >> PAGE_SHIFT;

	bo->sgt = drm_prime_pages_to_sg(bo->pages, bo->num_pages);
	if (IS_ERR(bo->sgt)) {
		drm_gem_put_pages(&bo->gem, bo->pages, false, false);
		return PTR_ERR(bo->sgt);
	}

	return 0;
}

static int tegra_bo_alloc(struct drm_device *drm, struct tegra_bo *bo,
			  size_t size)
{
	struct tegra_drm *tegra = drm->dev_private;
	int err;

	if (tegra->domain) {
		err = tegra_bo_get_pages(drm, bo, size);
		if (err < 0)
			return err;

		err = tegra_bo_iommu_map(tegra, bo);
		if (err < 0) {
			tegra_bo_free(drm, bo);
			return err;
		}
	} else {
		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 of size %zu\n",
				size);
			return -ENOMEM;
		}
	}

	return 0;
}

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

	bo = tegra_bo_alloc_object(drm, size);
	if (IS_ERR(bo))
		return bo;

	err = tegra_bo_alloc(drm, bo, size);
	if (err < 0)
		goto release;

	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;

release:
	drm_gem_object_release(&bo->gem);
	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 err;

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

	err = drm_gem_handle_create(file, &bo->gem, handle);
	if (err) {
		tegra_bo_free_object(&bo->gem);
		return ERR_PTR(err);
	}

	drm_gem_object_unreference_unlocked(&bo->gem);

	return bo;
}

static struct tegra_bo *tegra_bo_import(struct drm_device *drm,
					struct dma_buf *buf)
{
	struct tegra_drm *tegra = drm->dev_private;
	struct dma_buf_attachment *attach;
	struct tegra_bo *bo;
	int err;

	bo = tegra_bo_alloc_object(drm, buf->size);
	if (IS_ERR(bo))
		return bo;

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

	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 (tegra->domain) {
		err = tegra_bo_iommu_map(tegra, bo);
		if (err < 0)
			goto detach;
	} else {
		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:
	drm_gem_object_release(&bo->gem);
	kfree(bo);
	return ERR_PTR(err);
}

void tegra_bo_free_object(struct drm_gem_object *gem)
{
	struct tegra_drm *tegra = gem->dev->dev_private;
	struct tegra_bo *bo = to_tegra_bo(gem);

	if (tegra->domain)
		tegra_bo_iommu_unmap(tegra, bo);

	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_free(gem->dev, bo);
	}

	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)
{
	unsigned int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
	struct tegra_drm *tegra = drm->dev_private;
	struct tegra_bo *bo;

	args->pitch = round_up(min_pitch, tegra->pitch_align);
	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;
}

static int tegra_bo_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	struct drm_gem_object *gem = vma->vm_private_data;
	struct tegra_bo *bo = to_tegra_bo(gem);
	struct page *page;
	pgoff_t offset;
	int err;

	if (!bo->pages)
		return VM_FAULT_SIGBUS;

	offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >> PAGE_SHIFT;
	page = bo->pages[offset];

	err = vm_insert_page(vma, (unsigned long)vmf->virtual_address, page);
	switch (err) {
	case -EAGAIN:
	case 0:
	case -ERESTARTSYS:
	case -EINTR:
	case -EBUSY:
		return VM_FAULT_NOPAGE;

	case -ENOMEM:
		return VM_FAULT_OOM;
	}

	return VM_FAULT_SIGBUS;
}

const struct vm_operations_struct tegra_bo_vm_ops = {
	.fault = tegra_bo_fault,
	.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);

	if (!bo->pages) {
		unsigned long vm_pgoff = vma->vm_pgoff;

		vma->vm_flags &= ~VM_PFNMAP;
		vma->vm_pgoff = 0;

		ret = dma_mmap_writecombine(gem->dev->dev, vma, bo->vaddr,
					    bo->paddr, gem->size);
		if (ret) {
			drm_gem_vm_close(vma);
			return ret;
		}

		vma->vm_pgoff = vm_pgoff;
	} else {
		pgprot_t prot = vm_get_page_prot(vma->vm_flags);

		vma->vm_flags |= VM_MIXEDMAP;
		vma->vm_flags &= ~VM_PFNMAP;

		vma->vm_page_prot = pgprot_writecombine(prot);
	}

	return 0;
}

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 (bo->pages) {
		struct scatterlist *sg;
		unsigned int i;

		if (sg_alloc_table(sgt, bo->num_pages, GFP_KERNEL))
			goto free;

		for_each_sg(sgt->sgl, sg, bo->num_pages, i)
			sg_set_page(sg, bo->pages[i], PAGE_SIZE, 0);

		if (dma_map_sg(attach->dev, sgt->sgl, sgt->nents, dir) == 0)
			goto free;
	} else {
		if (sg_alloc_table(sgt, 1, GFP_KERNEL))
			goto free;

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

	return sgt;

free:
	sg_free_table(sgt);
	kfree(sgt);
	return NULL;
}

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

	if (bo->pages)
		dma_unmap_sg(attach->dev, sgt->sgl, sgt->nents, 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>
df06b759	17	#include <linux/iommu.h>
773af77f TR	18	#include <drm/tegra_drm.h>
773af77f TR	19
d1f3e1e0	20	#include "drm.h"
de2ba664 AM	21	#include "gem.h"
de2ba664 AM	22
3be82743	23	static inline struct tegra_bo host1x_to_tegra_bo(struct host1x_bo bo)
de2ba664 AM	24	{
	25	return container_of(bo, struct tegra_bo, base);
	26	}
	27
	28	static void tegra_bo_put(struct host1x_bo *bo)
	29	{
3be82743	30	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	31	struct drm_device *drm = obj->gem.dev;
	32
	33	mutex_lock(&drm->struct_mutex);
	34	drm_gem_object_unreference(&obj->gem);
	35	mutex_unlock(&drm->struct_mutex);
	36	}
	37
	38	static dma_addr_t tegra_bo_pin(struct host1x_bo bo, struct sg_table *sgt)
	39	{
3be82743	40	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	41
	42	return obj->paddr;
	43	}
	44
	45	static void tegra_bo_unpin(struct host1x_bo bo, struct sg_table sgt)
	46	{
	47	}
	48
	49	static void tegra_bo_mmap(struct host1x_bo bo)
	50	{
3be82743	51	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	52
	53	return obj->vaddr;
	54	}
	55
	56	static void tegra_bo_munmap(struct host1x_bo bo, void addr)
	57	{
	58	}
	59
	60	static void tegra_bo_kmap(struct host1x_bo bo, unsigned int page)
	61	{
3be82743	62	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	63
	64	return obj->vaddr + page * PAGE_SIZE;
	65	}
	66
	67	static void tegra_bo_kunmap(struct host1x_bo *bo, unsigned int page,
	68	void *addr)
	69	{
	70	}
	71
	72	static struct host1x_bo tegra_bo_get(struct host1x_bo bo)
	73	{
3be82743	74	struct tegra_bo *obj = host1x_to_tegra_bo(bo);
de2ba664 AM	75	struct drm_device *drm = obj->gem.dev;
	76
	77	mutex_lock(&drm->struct_mutex);
	78	drm_gem_object_reference(&obj->gem);
	79	mutex_unlock(&drm->struct_mutex);
	80
	81	return bo;
	82	}
	83
425c0fdc	84	static const struct host1x_bo_ops tegra_bo_ops = {
de2ba664 AM	85	.get = tegra_bo_get,
	86	.put = tegra_bo_put,
	87	.pin = tegra_bo_pin,
	88	.unpin = tegra_bo_unpin,
	89	.mmap = tegra_bo_mmap,
	90	.munmap = tegra_bo_munmap,
	91	.kmap = tegra_bo_kmap,
	92	.kunmap = tegra_bo_kunmap,
	93	};
	94
df06b759 TR	95	/*
	96	* A generic iommu_map_sg() function is being reviewed and will hopefully be
	97	* merged soon. At that point this function can be dropped in favour of the
	98	* one provided by the IOMMU API.
	99	*/
	100	static ssize_t __iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
	101	struct scatterlist *sg, unsigned int nents,
	102	int prot)
	103	{
	104	struct scatterlist *s;
	105	size_t offset = 0;
	106	unsigned int i;
	107	int err;
	108
	109	for_each_sg(sg, s, nents, i) {
	110	phys_addr_t phys = page_to_phys(sg_page(s));
	111	size_t length = s->offset + s->length;
	112
	113	err = iommu_map(domain, iova + offset, phys, length, prot);
	114	if (err < 0) {
	115	iommu_unmap(domain, iova, offset);
	116	return err;
	117	}
	118
	119	offset += length;
	120	}
	121
	122	return offset;
	123	}
	124
	125	static int tegra_bo_iommu_map(struct tegra_drm tegra, struct tegra_bo bo)
	126	{
	127	int prot = IOMMU_READ \| IOMMU_WRITE;
	128	ssize_t err;
	129
	130	if (bo->mm)
	131	return -EBUSY;
	132
	133	bo->mm = kzalloc(sizeof(*bo->mm), GFP_KERNEL);
	134	if (!bo->mm)
	135	return -ENOMEM;
	136
	137	err = drm_mm_insert_node_generic(&tegra->mm, bo->mm, bo->gem.size,
	138	PAGE_SIZE, 0, 0, 0);
	139	if (err < 0) {
	140	dev_err(tegra->drm->dev, "out of I/O virtual memory: %zd\n",
	141	err);
	142	goto free;
	143	}
	144
	145	bo->paddr = bo->mm->start;
	146
	147	err = __iommu_map_sg(tegra->domain, bo->paddr, bo->sgt->sgl,
	148	bo->sgt->nents, prot);
	149	if (err < 0) {
	150	dev_err(tegra->drm->dev, "failed to map buffer: %zd\n", err);
	151	goto remove;
	152	}
	153
	154	bo->size = err;
	155
	156	return 0;
	157
	158	remove:
159	drm_mm_remove_node(bo->mm);
160	free:
161	kfree(bo->mm);
162	return err;
163	}
164
165	static int tegra_bo_iommu_unmap(struct tegra_drm tegra, struct tegra_bo bo)
166	{
167	if (!bo->mm)
168	return 0;
169
170	iommu_unmap(tegra->domain, bo->paddr, bo->size);
171	drm_mm_remove_node(bo->mm);
172	kfree(bo->mm);
173
174	return 0;
175	}
176
c28d4a31 TR	177	static struct tegra_bo tegra_bo_alloc_object(struct drm_device drm,
	178	size_t size)
	179	{
	180	struct tegra_bo *bo;
	181	int err;
	182
	183	bo = kzalloc(sizeof(*bo), GFP_KERNEL);
	184	if (!bo)
	185	return ERR_PTR(-ENOMEM);
	186
	187	host1x_bo_init(&bo->base, &tegra_bo_ops);
	188	size = round_up(size, PAGE_SIZE);
	189
	190	err = drm_gem_object_init(drm, &bo->gem, size);
	191	if (err < 0)
	192	goto free;
	193
	194	err = drm_gem_create_mmap_offset(&bo->gem);
	195	if (err < 0)
	196	goto release;
	197
	198	return bo;
	199
	200	release:
	201	drm_gem_object_release(&bo->gem);
	202	free:
	203	kfree(bo);
	204	return ERR_PTR(err);
	205	}
	206
df06b759	207	static void tegra_bo_free(struct drm_device drm, struct tegra_bo bo)
de2ba664	208	{
df06b759 TR	209	if (bo->pages) {
	210	drm_gem_put_pages(&bo->gem, bo->pages, true, true);
	211	sg_free_table(bo->sgt);
	212	kfree(bo->sgt);
	213	} else {
	214	dma_free_writecombine(drm->dev, bo->gem.size, bo->vaddr,
	215	bo->paddr);
	216	}
	217	}
	218
	219	static int tegra_bo_get_pages(struct drm_device drm, struct tegra_bo bo,
	220	size_t size)
	221	{
	222	bo->pages = drm_gem_get_pages(&bo->gem);
	223	if (IS_ERR(bo->pages))
	224	return PTR_ERR(bo->pages);
	225
	226	bo->num_pages = size >> PAGE_SHIFT;
	227
	228	bo->sgt = drm_prime_pages_to_sg(bo->pages, bo->num_pages);
	229	if (IS_ERR(bo->sgt)) {
	230	drm_gem_put_pages(&bo->gem, bo->pages, false, false);
	231	return PTR_ERR(bo->sgt);
	232	}
	233
	234	return 0;
	235	}
	236
	237	static int tegra_bo_alloc(struct drm_device drm, struct tegra_bo bo,
	238	size_t size)
	239	{
	240	struct tegra_drm *tegra = drm->dev_private;
	241	int err;
	242
	243	if (tegra->domain) {
	244	err = tegra_bo_get_pages(drm, bo, size);
	245	if (err < 0)
	246	return err;
	247
	248	err = tegra_bo_iommu_map(tegra, bo);
	249	if (err < 0) {
	250	tegra_bo_free(drm, bo);
	251	return err;
	252	}
	253	} else {
	254	bo->vaddr = dma_alloc_writecombine(drm->dev, size, &bo->paddr,
	255	GFP_KERNEL \| __GFP_NOWARN);
	256	if (!bo->vaddr) {
	257	dev_err(drm->dev,
	258	"failed to allocate buffer of size %zu\n",
	259	size);
	260	return -ENOMEM;
	261	}
	262	}
	263
	264	return 0;
de2ba664 AM	265	}
de2ba664 AM	266
773af77f TR	267	struct tegra_bo tegra_bo_create(struct drm_device drm, unsigned int size,
773af77f TR	268	unsigned long flags)
de2ba664 AM	269	{
	270	struct tegra_bo *bo;
	271	int err;
	272
c28d4a31 TR	273	bo = tegra_bo_alloc_object(drm, size);
	274	if (IS_ERR(bo))
	275	return bo;
de2ba664	276
df06b759 TR	277	err = tegra_bo_alloc(drm, bo, size);
	278	if (err < 0)
	279	goto release;
de2ba664	280
773af77f	281	if (flags & DRM_TEGRA_GEM_CREATE_TILED)
c134f019	282	bo->tiling.mode = TEGRA_BO_TILING_MODE_TILED;
773af77f	283
db7fbdfd TR	284	if (flags & DRM_TEGRA_GEM_CREATE_BOTTOM_UP)
	285	bo->flags \|= TEGRA_BO_BOTTOM_UP;
	286
de2ba664 AM	287	return bo;
de2ba664 AM	288
df06b759 TR	289	release:
df06b759 TR	290	drm_gem_object_release(&bo->gem);
de2ba664	291	kfree(bo);
de2ba664	292	return ERR_PTR(err);
de2ba664 AM	293	}
	294
	295	struct tegra_bo tegra_bo_create_with_handle(struct drm_file file,
3be82743 TR	296	struct drm_device *drm,
3be82743 TR	297	unsigned int size,
773af77f	298	unsigned long flags,
3be82743	299	unsigned int *handle)
de2ba664 AM	300	{
de2ba664 AM	301	struct tegra_bo *bo;
a8b48df5	302	int err;
de2ba664	303
773af77f	304	bo = tegra_bo_create(drm, size, flags);
de2ba664 AM	305	if (IS_ERR(bo))
	306	return bo;
	307
a8b48df5 TR	308	err = drm_gem_handle_create(file, &bo->gem, handle);
	309	if (err) {
	310	tegra_bo_free_object(&bo->gem);
	311	return ERR_PTR(err);
	312	}
de2ba664 AM	313
	314	drm_gem_object_unreference_unlocked(&bo->gem);
	315
	316	return bo;
de2ba664 AM	317	}
de2ba664 AM	318
540457cc TR	319	static struct tegra_bo tegra_bo_import(struct drm_device drm,
540457cc TR	320	struct dma_buf *buf)
3800391d	321	{
df06b759	322	struct tegra_drm *tegra = drm->dev_private;
3800391d TR	323	struct dma_buf_attachment *attach;
3800391d TR	324	struct tegra_bo *bo;
3800391d TR	325	int err;
3800391d TR	326
c28d4a31 TR	327	bo = tegra_bo_alloc_object(drm, buf->size);
	328	if (IS_ERR(bo))
	329	return bo;
3800391d TR	330
	331	attach = dma_buf_attach(buf, drm->dev);
	332	if (IS_ERR(attach)) {
	333	err = PTR_ERR(attach);
c28d4a31	334	goto free;
3800391d TR	335	}
	336
	337	get_dma_buf(buf);
	338
	339	bo->sgt = dma_buf_map_attachment(attach, DMA_TO_DEVICE);
	340	if (!bo->sgt) {
	341	err = -ENOMEM;
	342	goto detach;
	343	}
	344
	345	if (IS_ERR(bo->sgt)) {
	346	err = PTR_ERR(bo->sgt);
	347	goto detach;
	348	}
	349
df06b759 TR	350	if (tegra->domain) {
	351	err = tegra_bo_iommu_map(tegra, bo);
	352	if (err < 0)
	353	goto detach;
	354	} else {
	355	if (bo->sgt->nents > 1) {
	356	err = -EINVAL;
	357	goto detach;
	358	}
	359
	360	bo->paddr = sg_dma_address(bo->sgt->sgl);
3800391d TR	361	}
3800391d TR	362
3800391d TR	363	bo->gem.import_attach = attach;
	364
	365	return bo;
	366
	367	detach:
	368	if (!IS_ERR_OR_NULL(bo->sgt))
	369	dma_buf_unmap_attachment(attach, bo->sgt, DMA_TO_DEVICE);
	370
	371	dma_buf_detach(buf, attach);
	372	dma_buf_put(buf);
3800391d	373	free:
c28d4a31	374	drm_gem_object_release(&bo->gem);
3800391d	375	kfree(bo);
3800391d TR	376	return ERR_PTR(err);
	377	}
	378
de2ba664 AM	379	void tegra_bo_free_object(struct drm_gem_object *gem)
de2ba664 AM	380	{
df06b759	381	struct tegra_drm *tegra = gem->dev->dev_private;
de2ba664 AM	382	struct tegra_bo *bo = to_tegra_bo(gem);
de2ba664 AM	383
df06b759 TR	384	if (tegra->domain)
	385	tegra_bo_iommu_unmap(tegra, bo);
	386
3800391d TR	387	if (gem->import_attach) {
	388	dma_buf_unmap_attachment(gem->import_attach, bo->sgt,
	389	DMA_TO_DEVICE);
	390	drm_prime_gem_destroy(gem, NULL);
	391	} else {
df06b759	392	tegra_bo_free(gem->dev, bo);
3800391d TR	393	}
3800391d TR	394
de2ba664	395	drm_gem_object_release(gem);
de2ba664 AM	396	kfree(bo);
	397	}
	398
	399	int tegra_bo_dumb_create(struct drm_file file, struct drm_device drm,
	400	struct drm_mode_create_dumb *args)
	401	{
dc6057ec	402	unsigned int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
d1f3e1e0	403	struct tegra_drm *tegra = drm->dev_private;
de2ba664 AM	404	struct tegra_bo *bo;
de2ba664 AM	405
dc6057ec TR	406	args->pitch = round_up(min_pitch, tegra->pitch_align);
dc6057ec TR	407	args->size = args->pitch * args->height;
de2ba664	408
773af77f	409	bo = tegra_bo_create_with_handle(file, drm, args->size, 0,
3be82743	410	&args->handle);
de2ba664 AM	411	if (IS_ERR(bo))
	412	return PTR_ERR(bo);
	413
	414	return 0;
	415	}
	416
	417	int tegra_bo_dumb_map_offset(struct drm_file file, struct drm_device drm,
	418	uint32_t handle, uint64_t *offset)
	419	{
	420	struct drm_gem_object *gem;
	421	struct tegra_bo *bo;
	422
	423	mutex_lock(&drm->struct_mutex);
	424
	425	gem = drm_gem_object_lookup(drm, file, handle);
	426	if (!gem) {
	427	dev_err(drm->dev, "failed to lookup GEM object\n");
	428	mutex_unlock(&drm->struct_mutex);
	429	return -EINVAL;
	430	}
	431
	432	bo = to_tegra_bo(gem);
	433
2bc7b0ca	434	*offset = drm_vma_node_offset_addr(&bo->gem.vma_node);
de2ba664 AM	435
	436	drm_gem_object_unreference(gem);
	437
	438	mutex_unlock(&drm->struct_mutex);
	439
	440	return 0;
	441	}
	442
df06b759 TR	443	static int tegra_bo_fault(struct vm_area_struct vma, struct vm_fault vmf)
	444	{
	445	struct drm_gem_object *gem = vma->vm_private_data;
	446	struct tegra_bo *bo = to_tegra_bo(gem);
	447	struct page *page;
	448	pgoff_t offset;
	449	int err;
	450
	451	if (!bo->pages)
	452	return VM_FAULT_SIGBUS;
	453
	454	offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >> PAGE_SHIFT;
	455	page = bo->pages[offset];
	456
	457	err = vm_insert_page(vma, (unsigned long)vmf->virtual_address, page);
	458	switch (err) {
	459	case -EAGAIN:
	460	case 0:
	461	case -ERESTARTSYS:
	462	case -EINTR:
	463	case -EBUSY:
	464	return VM_FAULT_NOPAGE;
	465
	466	case -ENOMEM:
	467	return VM_FAULT_OOM;
	468	}
	469
	470	return VM_FAULT_SIGBUS;
	471	}
	472
de2ba664	473	const struct vm_operations_struct tegra_bo_vm_ops = {
df06b759	474	.fault = tegra_bo_fault,
de2ba664 AM	475	.open = drm_gem_vm_open,
	476	.close = drm_gem_vm_close,
	477	};
	478
	479	int tegra_drm_mmap(struct file file, struct vm_area_struct vma)
	480	{
	481	struct drm_gem_object *gem;
	482	struct tegra_bo *bo;
	483	int ret;
	484
	485	ret = drm_gem_mmap(file, vma);
	486	if (ret)
	487	return ret;
	488
	489	gem = vma->vm_private_data;
	490	bo = to_tegra_bo(gem);
	491
df06b759 TR	492	if (!bo->pages) {
df06b759 TR	493	unsigned long vm_pgoff = vma->vm_pgoff;
53ea7213	494
df06b759 TR	495	vma->vm_flags &= ~VM_PFNMAP;
	496	vma->vm_pgoff = 0;
	497
	498	ret = dma_mmap_writecombine(gem->dev->dev, vma, bo->vaddr,
	499	bo->paddr, gem->size);
	500	if (ret) {
	501	drm_gem_vm_close(vma);
	502	return ret;
	503	}
	504
	505	vma->vm_pgoff = vm_pgoff;
	506	} else {
	507	pgprot_t prot = vm_get_page_prot(vma->vm_flags);
53ea7213	508
df06b759 TR	509	vma->vm_flags \|= VM_MIXEDMAP;
	510	vma->vm_flags &= ~VM_PFNMAP;
	511
	512	vma->vm_page_prot = pgprot_writecombine(prot);
	513	}
de2ba664	514
53ea7213	515	return 0;
de2ba664	516	}
3800391d TR	517
	518	static struct sg_table *
	519	tegra_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
	520	enum dma_data_direction dir)
	521	{
	522	struct drm_gem_object *gem = attach->dmabuf->priv;
	523	struct tegra_bo *bo = to_tegra_bo(gem);
	524	struct sg_table *sgt;
	525
	526	sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
	527	if (!sgt)
	528	return NULL;
	529
df06b759 TR	530	if (bo->pages) {
	531	struct scatterlist *sg;
	532	unsigned int i;
	533
	534	if (sg_alloc_table(sgt, bo->num_pages, GFP_KERNEL))
	535	goto free;
3800391d	536
df06b759 TR	537	for_each_sg(sgt->sgl, sg, bo->num_pages, i)
	538	sg_set_page(sg, bo->pages[i], PAGE_SIZE, 0);
	539
	540	if (dma_map_sg(attach->dev, sgt->sgl, sgt->nents, dir) == 0)
	541	goto free;
	542	} else {
	543	if (sg_alloc_table(sgt, 1, GFP_KERNEL))
	544	goto free;
	545
	546	sg_dma_address(sgt->sgl) = bo->paddr;
	547	sg_dma_len(sgt->sgl) = gem->size;
	548	}
3800391d TR	549
3800391d TR	550	return sgt;
df06b759 TR	551
	552	free:
	553	sg_free_table(sgt);
	554	kfree(sgt);
	555	return NULL;
3800391d TR	556	}
	557
	558	static void tegra_gem_prime_unmap_dma_buf(struct dma_buf_attachment *attach,
	559	struct sg_table *sgt,
	560	enum dma_data_direction dir)
	561	{
df06b759 TR	562	struct drm_gem_object *gem = attach->dmabuf->priv;
	563	struct tegra_bo *bo = to_tegra_bo(gem);
	564
	565	if (bo->pages)
	566	dma_unmap_sg(attach->dev, sgt->sgl, sgt->nents, dir);
	567
3800391d TR	568	sg_free_table(sgt);
	569	kfree(sgt);
	570	}
	571
	572	static void tegra_gem_prime_release(struct dma_buf *buf)
	573	{
	574	drm_gem_dmabuf_release(buf);
	575	}
	576
	577	static void tegra_gem_prime_kmap_atomic(struct dma_buf buf,
	578	unsigned long page)
	579	{
	580	return NULL;
	581	}
	582
	583	static void tegra_gem_prime_kunmap_atomic(struct dma_buf *buf,
	584	unsigned long page,
	585	void *addr)
	586	{
	587	}
	588
	589	static void tegra_gem_prime_kmap(struct dma_buf buf, unsigned long page)
	590	{
	591	return NULL;
	592	}
	593
	594	static void tegra_gem_prime_kunmap(struct dma_buf *buf, unsigned long page,
	595	void *addr)
	596	{
	597	}
	598
	599	static int tegra_gem_prime_mmap(struct dma_buf buf, struct vm_area_struct vma)
	600	{
	601	return -EINVAL;
	602	}
	603
d40326f4 TR	604	static void tegra_gem_prime_vmap(struct dma_buf buf)
	605	{
	606	struct drm_gem_object *gem = buf->priv;
	607	struct tegra_bo *bo = to_tegra_bo(gem);
	608
	609	return bo->vaddr;
	610	}
	611
	612	static void tegra_gem_prime_vunmap(struct dma_buf buf, void vaddr)
	613	{
	614	}
	615
3800391d TR	616	static const struct dma_buf_ops tegra_gem_prime_dmabuf_ops = {
	617	.map_dma_buf = tegra_gem_prime_map_dma_buf,
	618	.unmap_dma_buf = tegra_gem_prime_unmap_dma_buf,
	619	.release = tegra_gem_prime_release,
	620	.kmap_atomic = tegra_gem_prime_kmap_atomic,
	621	.kunmap_atomic = tegra_gem_prime_kunmap_atomic,
	622	.kmap = tegra_gem_prime_kmap,
	623	.kunmap = tegra_gem_prime_kunmap,
	624	.mmap = tegra_gem_prime_mmap,
d40326f4 TR	625	.vmap = tegra_gem_prime_vmap,
d40326f4 TR	626	.vunmap = tegra_gem_prime_vunmap,
3800391d TR	627	};
	628
	629	struct dma_buf tegra_gem_prime_export(struct drm_device drm,
	630	struct drm_gem_object *gem,
	631	int flags)
	632	{
	633	return dma_buf_export(gem, &tegra_gem_prime_dmabuf_ops, gem->size,
3aac4502	634	flags, NULL);
3800391d TR	635	}
	636
	637	struct drm_gem_object tegra_gem_prime_import(struct drm_device drm,
	638	struct dma_buf *buf)
	639	{
	640	struct tegra_bo *bo;
	641
	642	if (buf->ops == &tegra_gem_prime_dmabuf_ops) {
	643	struct drm_gem_object *gem = buf->priv;
	644
	645	if (gem->dev == drm) {
	646	drm_gem_object_reference(gem);
	647	return gem;
	648	}
	649	}
	650
	651	bo = tegra_bo_import(drm, buf);
	652	if (IS_ERR(bo))
	653	return ERR_CAST(bo);
	654
	655	return &bo->gem;
	656	}