[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 if (bo->vaddr) {
		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)
{
	struct scatterlist *s;
	struct sg_table *sgt;
	unsigned int i;

	bo->pages = drm_gem_get_pages(&bo->gem);
	if (IS_ERR(bo->pages))
		return PTR_ERR(bo->pages);

	bo->num_pages = size >> PAGE_SHIFT;

	sgt = drm_prime_pages_to_sg(bo->pages, bo->num_pages);
	if (IS_ERR(sgt))
		goto put_pages;

	/*
	 * Fake up the SG table so that dma_map_sg() can be used to flush the
	 * pages associated with it. Note that this relies on the fact that
	 * the DMA API doesn't hook into IOMMU on Tegra, therefore mapping is
	 * only cache maintenance.
	 *
	 * TODO: Replace this by drm_clflash_sg() once it can be implemented
	 * without relying on symbols that are not exported.
	 */
	for_each_sg(sgt->sgl, s, sgt->nents, i)
		sg_dma_address(s) = sg_phys(s);

	if (dma_map_sg(drm->dev, sgt->sgl, sgt->nents, DMA_TO_DEVICE) == 0) {
		sgt = ERR_PTR(-ENOMEM);
		goto release_sgt;
	}

	bo->sgt = sgt;

	return 0;

release_sgt:
	sg_free_table(sgt);
	kfree(sgt);
put_pages:
	drm_gem_put_pages(&bo->gem, bo->pages, false, false);
	return PTR_ERR(sgt);
}

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, size_t 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,
					     size_t size,
					     unsigned long flags,
					     u32 *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,
			     u32 handle, u64 *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);
7e0180e3	213	} else if (bo->vaddr) {
df06b759 TR	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	{
a04251fc TR	222	struct scatterlist *s;
	223	struct sg_table *sgt;
	224	unsigned int i;
	225
df06b759 TR	226	bo->pages = drm_gem_get_pages(&bo->gem);
	227	if (IS_ERR(bo->pages))
	228	return PTR_ERR(bo->pages);
	229
	230	bo->num_pages = size >> PAGE_SHIFT;
	231
a04251fc TR	232	sgt = drm_prime_pages_to_sg(bo->pages, bo->num_pages);
	233	if (IS_ERR(sgt))
	234	goto put_pages;
	235
	236	/*
	237	* Fake up the SG table so that dma_map_sg() can be used to flush the
	238	* pages associated with it. Note that this relies on the fact that
	239	* the DMA API doesn't hook into IOMMU on Tegra, therefore mapping is
	240	* only cache maintenance.
	241	*
	242	* TODO: Replace this by drm_clflash_sg() once it can be implemented
	243	* without relying on symbols that are not exported.
	244	*/
	245	for_each_sg(sgt->sgl, s, sgt->nents, i)
	246	sg_dma_address(s) = sg_phys(s);
	247
	248	if (dma_map_sg(drm->dev, sgt->sgl, sgt->nents, DMA_TO_DEVICE) == 0) {
	249	sgt = ERR_PTR(-ENOMEM);
	250	goto release_sgt;
df06b759 TR	251	}
df06b759 TR	252
a04251fc TR	253	bo->sgt = sgt;
a04251fc TR	254
df06b759	255	return 0;
a04251fc TR	256
	257	release_sgt:
	258	sg_free_table(sgt);
	259	kfree(sgt);
	260	put_pages:
	261	drm_gem_put_pages(&bo->gem, bo->pages, false, false);
	262	return PTR_ERR(sgt);
df06b759 TR	263	}
	264
	265	static int tegra_bo_alloc(struct drm_device drm, struct tegra_bo bo,
	266	size_t size)
	267	{
	268	struct tegra_drm *tegra = drm->dev_private;
	269	int err;
	270
	271	if (tegra->domain) {
	272	err = tegra_bo_get_pages(drm, bo, size);
	273	if (err < 0)
	274	return err;
	275
	276	err = tegra_bo_iommu_map(tegra, bo);
	277	if (err < 0) {
	278	tegra_bo_free(drm, bo);
	279	return err;
	280	}
	281	} else {
	282	bo->vaddr = dma_alloc_writecombine(drm->dev, size, &bo->paddr,
	283	GFP_KERNEL \| __GFP_NOWARN);
	284	if (!bo->vaddr) {
	285	dev_err(drm->dev,
	286	"failed to allocate buffer of size %zu\n",
	287	size);
	288	return -ENOMEM;
	289	}
	290	}
	291
	292	return 0;
de2ba664 AM	293	}
de2ba664 AM	294
71c38629	295	struct tegra_bo tegra_bo_create(struct drm_device drm, size_t size,
773af77f	296	unsigned long flags)
de2ba664 AM	297	{
	298	struct tegra_bo *bo;
	299	int err;
	300
c28d4a31 TR	301	bo = tegra_bo_alloc_object(drm, size);
	302	if (IS_ERR(bo))
	303	return bo;
de2ba664	304
df06b759 TR	305	err = tegra_bo_alloc(drm, bo, size);
	306	if (err < 0)
	307	goto release;
de2ba664	308
773af77f	309	if (flags & DRM_TEGRA_GEM_CREATE_TILED)
c134f019	310	bo->tiling.mode = TEGRA_BO_TILING_MODE_TILED;
773af77f	311
db7fbdfd TR	312	if (flags & DRM_TEGRA_GEM_CREATE_BOTTOM_UP)
	313	bo->flags \|= TEGRA_BO_BOTTOM_UP;
	314
de2ba664 AM	315	return bo;
de2ba664 AM	316
df06b759 TR	317	release:
df06b759 TR	318	drm_gem_object_release(&bo->gem);
de2ba664	319	kfree(bo);
de2ba664	320	return ERR_PTR(err);
de2ba664 AM	321	}
	322
	323	struct tegra_bo tegra_bo_create_with_handle(struct drm_file file,
3be82743	324	struct drm_device *drm,
71c38629	325	size_t size,
773af77f	326	unsigned long flags,
71c38629	327	u32 *handle)
de2ba664 AM	328	{
de2ba664 AM	329	struct tegra_bo *bo;
a8b48df5	330	int err;
de2ba664	331
773af77f	332	bo = tegra_bo_create(drm, size, flags);
de2ba664 AM	333	if (IS_ERR(bo))
	334	return bo;
	335
a8b48df5 TR	336	err = drm_gem_handle_create(file, &bo->gem, handle);
	337	if (err) {
	338	tegra_bo_free_object(&bo->gem);
	339	return ERR_PTR(err);
	340	}
de2ba664 AM	341
	342	drm_gem_object_unreference_unlocked(&bo->gem);
	343
	344	return bo;
de2ba664 AM	345	}
de2ba664 AM	346
540457cc TR	347	static struct tegra_bo tegra_bo_import(struct drm_device drm,
540457cc TR	348	struct dma_buf *buf)
3800391d	349	{
df06b759	350	struct tegra_drm *tegra = drm->dev_private;
3800391d TR	351	struct dma_buf_attachment *attach;
3800391d TR	352	struct tegra_bo *bo;
3800391d TR	353	int err;
3800391d TR	354
c28d4a31 TR	355	bo = tegra_bo_alloc_object(drm, buf->size);
	356	if (IS_ERR(bo))
	357	return bo;
3800391d TR	358
	359	attach = dma_buf_attach(buf, drm->dev);
	360	if (IS_ERR(attach)) {
	361	err = PTR_ERR(attach);
c28d4a31	362	goto free;
3800391d TR	363	}
	364
	365	get_dma_buf(buf);
	366
	367	bo->sgt = dma_buf_map_attachment(attach, DMA_TO_DEVICE);
	368	if (!bo->sgt) {
	369	err = -ENOMEM;
	370	goto detach;
	371	}
	372
	373	if (IS_ERR(bo->sgt)) {
	374	err = PTR_ERR(bo->sgt);
	375	goto detach;
	376	}
	377
df06b759 TR	378	if (tegra->domain) {
	379	err = tegra_bo_iommu_map(tegra, bo);
	380	if (err < 0)
	381	goto detach;
	382	} else {
	383	if (bo->sgt->nents > 1) {
	384	err = -EINVAL;
	385	goto detach;
	386	}
	387
	388	bo->paddr = sg_dma_address(bo->sgt->sgl);
3800391d TR	389	}
3800391d TR	390
3800391d TR	391	bo->gem.import_attach = attach;
	392
	393	return bo;
	394
	395	detach:
	396	if (!IS_ERR_OR_NULL(bo->sgt))
	397	dma_buf_unmap_attachment(attach, bo->sgt, DMA_TO_DEVICE);
	398
	399	dma_buf_detach(buf, attach);
	400	dma_buf_put(buf);
3800391d	401	free:
c28d4a31	402	drm_gem_object_release(&bo->gem);
3800391d	403	kfree(bo);
3800391d TR	404	return ERR_PTR(err);
	405	}
	406
de2ba664 AM	407	void tegra_bo_free_object(struct drm_gem_object *gem)
de2ba664 AM	408	{
df06b759	409	struct tegra_drm *tegra = gem->dev->dev_private;
de2ba664 AM	410	struct tegra_bo *bo = to_tegra_bo(gem);
de2ba664 AM	411
df06b759 TR	412	if (tegra->domain)
	413	tegra_bo_iommu_unmap(tegra, bo);
	414
3800391d TR	415	if (gem->import_attach) {
	416	dma_buf_unmap_attachment(gem->import_attach, bo->sgt,
	417	DMA_TO_DEVICE);
	418	drm_prime_gem_destroy(gem, NULL);
	419	} else {
df06b759	420	tegra_bo_free(gem->dev, bo);
3800391d TR	421	}
3800391d TR	422
de2ba664	423	drm_gem_object_release(gem);
de2ba664 AM	424	kfree(bo);
	425	}
	426
	427	int tegra_bo_dumb_create(struct drm_file file, struct drm_device drm,
	428	struct drm_mode_create_dumb *args)
	429	{
dc6057ec	430	unsigned int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
d1f3e1e0	431	struct tegra_drm *tegra = drm->dev_private;
de2ba664 AM	432	struct tegra_bo *bo;
de2ba664 AM	433
dc6057ec TR	434	args->pitch = round_up(min_pitch, tegra->pitch_align);
dc6057ec TR	435	args->size = args->pitch * args->height;
de2ba664	436
773af77f	437	bo = tegra_bo_create_with_handle(file, drm, args->size, 0,
3be82743	438	&args->handle);
de2ba664 AM	439	if (IS_ERR(bo))
	440	return PTR_ERR(bo);
	441
	442	return 0;
	443	}
	444
	445	int tegra_bo_dumb_map_offset(struct drm_file file, struct drm_device drm,
71c38629	446	u32 handle, u64 *offset)
de2ba664 AM	447	{
	448	struct drm_gem_object *gem;
	449	struct tegra_bo *bo;
	450
	451	mutex_lock(&drm->struct_mutex);
	452
	453	gem = drm_gem_object_lookup(drm, file, handle);
	454	if (!gem) {
	455	dev_err(drm->dev, "failed to lookup GEM object\n");
	456	mutex_unlock(&drm->struct_mutex);
	457	return -EINVAL;
	458	}
	459
	460	bo = to_tegra_bo(gem);
	461
2bc7b0ca	462	*offset = drm_vma_node_offset_addr(&bo->gem.vma_node);
de2ba664 AM	463
	464	drm_gem_object_unreference(gem);
	465
	466	mutex_unlock(&drm->struct_mutex);
	467
	468	return 0;
	469	}
	470
df06b759 TR	471	static int tegra_bo_fault(struct vm_area_struct vma, struct vm_fault vmf)
	472	{
	473	struct drm_gem_object *gem = vma->vm_private_data;
	474	struct tegra_bo *bo = to_tegra_bo(gem);
	475	struct page *page;
	476	pgoff_t offset;
	477	int err;
	478
	479	if (!bo->pages)
	480	return VM_FAULT_SIGBUS;
	481
	482	offset = ((unsigned long)vmf->virtual_address - vma->vm_start) >> PAGE_SHIFT;
	483	page = bo->pages[offset];
	484
	485	err = vm_insert_page(vma, (unsigned long)vmf->virtual_address, page);
	486	switch (err) {
	487	case -EAGAIN:
	488	case 0:
	489	case -ERESTARTSYS:
	490	case -EINTR:
	491	case -EBUSY:
	492	return VM_FAULT_NOPAGE;
	493
	494	case -ENOMEM:
	495	return VM_FAULT_OOM;
	496	}
	497
	498	return VM_FAULT_SIGBUS;
	499	}
	500
de2ba664	501	const struct vm_operations_struct tegra_bo_vm_ops = {
df06b759	502	.fault = tegra_bo_fault,
de2ba664 AM	503	.open = drm_gem_vm_open,
	504	.close = drm_gem_vm_close,
	505	};
	506
	507	int tegra_drm_mmap(struct file file, struct vm_area_struct vma)
	508	{
	509	struct drm_gem_object *gem;
	510	struct tegra_bo *bo;
	511	int ret;
	512
	513	ret = drm_gem_mmap(file, vma);
	514	if (ret)
	515	return ret;
	516
	517	gem = vma->vm_private_data;
	518	bo = to_tegra_bo(gem);
	519
df06b759 TR	520	if (!bo->pages) {
df06b759 TR	521	unsigned long vm_pgoff = vma->vm_pgoff;
53ea7213	522
df06b759 TR	523	vma->vm_flags &= ~VM_PFNMAP;
	524	vma->vm_pgoff = 0;
	525
	526	ret = dma_mmap_writecombine(gem->dev->dev, vma, bo->vaddr,
	527	bo->paddr, gem->size);
	528	if (ret) {
	529	drm_gem_vm_close(vma);
	530	return ret;
	531	}
	532
	533	vma->vm_pgoff = vm_pgoff;
	534	} else {
	535	pgprot_t prot = vm_get_page_prot(vma->vm_flags);
53ea7213	536
df06b759 TR	537	vma->vm_flags \|= VM_MIXEDMAP;
	538	vma->vm_flags &= ~VM_PFNMAP;
	539
	540	vma->vm_page_prot = pgprot_writecombine(prot);
	541	}
de2ba664	542
53ea7213	543	return 0;
de2ba664	544	}
3800391d TR	545
	546	static struct sg_table *
	547	tegra_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
	548	enum dma_data_direction dir)
	549	{
	550	struct drm_gem_object *gem = attach->dmabuf->priv;
	551	struct tegra_bo *bo = to_tegra_bo(gem);
	552	struct sg_table *sgt;
	553
	554	sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
	555	if (!sgt)
	556	return NULL;
	557
df06b759 TR	558	if (bo->pages) {
	559	struct scatterlist *sg;
	560	unsigned int i;
	561
	562	if (sg_alloc_table(sgt, bo->num_pages, GFP_KERNEL))
	563	goto free;
3800391d	564
df06b759 TR	565	for_each_sg(sgt->sgl, sg, bo->num_pages, i)
	566	sg_set_page(sg, bo->pages[i], PAGE_SIZE, 0);
	567
	568	if (dma_map_sg(attach->dev, sgt->sgl, sgt->nents, dir) == 0)
	569	goto free;
	570	} else {
	571	if (sg_alloc_table(sgt, 1, GFP_KERNEL))
	572	goto free;
	573
	574	sg_dma_address(sgt->sgl) = bo->paddr;
	575	sg_dma_len(sgt->sgl) = gem->size;
	576	}
3800391d TR	577
3800391d TR	578	return sgt;
df06b759 TR	579
	580	free:
	581	sg_free_table(sgt);
	582	kfree(sgt);
	583	return NULL;
3800391d TR	584	}
	585
	586	static void tegra_gem_prime_unmap_dma_buf(struct dma_buf_attachment *attach,
	587	struct sg_table *sgt,
	588	enum dma_data_direction dir)
	589	{
df06b759 TR	590	struct drm_gem_object *gem = attach->dmabuf->priv;
	591	struct tegra_bo *bo = to_tegra_bo(gem);
	592
	593	if (bo->pages)
	594	dma_unmap_sg(attach->dev, sgt->sgl, sgt->nents, dir);
	595
3800391d TR	596	sg_free_table(sgt);
	597	kfree(sgt);
	598	}
	599
	600	static void tegra_gem_prime_release(struct dma_buf *buf)
	601	{
	602	drm_gem_dmabuf_release(buf);
	603	}
	604
	605	static void tegra_gem_prime_kmap_atomic(struct dma_buf buf,
	606	unsigned long page)
	607	{
	608	return NULL;
	609	}
	610
	611	static void tegra_gem_prime_kunmap_atomic(struct dma_buf *buf,
	612	unsigned long page,
	613	void *addr)
	614	{
	615	}
	616
	617	static void tegra_gem_prime_kmap(struct dma_buf buf, unsigned long page)
	618	{
	619	return NULL;
	620	}
	621
	622	static void tegra_gem_prime_kunmap(struct dma_buf *buf, unsigned long page,
	623	void *addr)
	624	{
	625	}
	626
	627	static int tegra_gem_prime_mmap(struct dma_buf buf, struct vm_area_struct vma)
	628	{
	629	return -EINVAL;
	630	}
	631
d40326f4 TR	632	static void tegra_gem_prime_vmap(struct dma_buf buf)
	633	{
	634	struct drm_gem_object *gem = buf->priv;
	635	struct tegra_bo *bo = to_tegra_bo(gem);
	636
	637	return bo->vaddr;
	638	}
	639
	640	static void tegra_gem_prime_vunmap(struct dma_buf buf, void vaddr)
	641	{
	642	}
	643
3800391d TR	644	static const struct dma_buf_ops tegra_gem_prime_dmabuf_ops = {
	645	.map_dma_buf = tegra_gem_prime_map_dma_buf,
	646	.unmap_dma_buf = tegra_gem_prime_unmap_dma_buf,
	647	.release = tegra_gem_prime_release,
	648	.kmap_atomic = tegra_gem_prime_kmap_atomic,
	649	.kunmap_atomic = tegra_gem_prime_kunmap_atomic,
	650	.kmap = tegra_gem_prime_kmap,
	651	.kunmap = tegra_gem_prime_kunmap,
	652	.mmap = tegra_gem_prime_mmap,
d40326f4 TR	653	.vmap = tegra_gem_prime_vmap,
d40326f4 TR	654	.vunmap = tegra_gem_prime_vunmap,
3800391d TR	655	};
	656
	657	struct dma_buf tegra_gem_prime_export(struct drm_device drm,
	658	struct drm_gem_object *gem,
	659	int flags)
	660	{
	661	return dma_buf_export(gem, &tegra_gem_prime_dmabuf_ops, gem->size,
3aac4502	662	flags, NULL);
3800391d TR	663	}
	664
	665	struct drm_gem_object tegra_gem_prime_import(struct drm_device drm,
	666	struct dma_buf *buf)
	667	{
	668	struct tegra_bo *bo;
	669
	670	if (buf->ops == &tegra_gem_prime_dmabuf_ops) {
	671	struct drm_gem_object *gem = buf->priv;
	672
	673	if (gem->dev == drm) {
	674	drm_gem_object_reference(gem);
	675	return gem;
	676	}
	677	}
	678
	679	bo = tegra_bo_import(drm, buf);
	680	if (IS_ERR(bo))
	681	return ERR_CAST(bo);
	682
	683	return &bo->gem;
	684	}