[mirror_ubuntu-eoan-kernel.git] / drivers / gpu / drm / msm / msm_gem.c

/*
 * Copyright (C) 2013 Red Hat
 * Author: Rob Clark <robdclark@gmail.com>
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/spinlock.h>
#include <linux/shmem_fs.h>

#include "msm_drv.h"
#include "msm_gem.h"
#include "msm_gpu.h"


/* called with dev->struct_mutex held */
static struct page **get_pages(struct drm_gem_object *obj)
{
	struct msm_gem_object *msm_obj = to_msm_bo(obj);

	if (!msm_obj->pages) {
		struct drm_device *dev = obj->dev;
		struct page **p = drm_gem_get_pages(obj, 0);
		int npages = obj->size >> PAGE_SHIFT;

		if (IS_ERR(p)) {
			dev_err(dev->dev, "could not get pages: %ld\n",
					PTR_ERR(p));
			return p;
		}

		msm_obj->sgt = drm_prime_pages_to_sg(p, npages);
		if (IS_ERR(msm_obj->sgt)) {
			dev_err(dev->dev, "failed to allocate sgt\n");
			return ERR_CAST(msm_obj->sgt);
		}

		msm_obj->pages = p;

		/* For non-cached buffers, ensure the new pages are clean
		 * because display controller, GPU, etc. are not coherent:
		 */
		if (msm_obj->flags & (MSM_BO_WC|MSM_BO_UNCACHED))
			dma_map_sg(dev->dev, msm_obj->sgt->sgl,
					msm_obj->sgt->nents, DMA_BIDIRECTIONAL);
	}

	return msm_obj->pages;
}

static void put_pages(struct drm_gem_object *obj)
{
	struct msm_gem_object *msm_obj = to_msm_bo(obj);

	if (msm_obj->pages) {
		/* For non-cached buffers, ensure the new pages are clean
		 * because display controller, GPU, etc. are not coherent:
		 */
		if (msm_obj->flags & (MSM_BO_WC|MSM_BO_UNCACHED))
			dma_unmap_sg(obj->dev->dev, msm_obj->sgt->sgl,
					msm_obj->sgt->nents, DMA_BIDIRECTIONAL);
		sg_free_table(msm_obj->sgt);
		kfree(msm_obj->sgt);

		drm_gem_put_pages(obj, msm_obj->pages, true, false);
		msm_obj->pages = NULL;
	}
}

int msm_gem_mmap_obj(struct drm_gem_object *obj,
		struct vm_area_struct *vma)
{
	struct msm_gem_object *msm_obj = to_msm_bo(obj);

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

	if (msm_obj->flags & MSM_BO_WC) {
		vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
	} else if (msm_obj->flags & MSM_BO_UNCACHED) {
		vma->vm_page_prot = pgprot_noncached(vm_get_page_prot(vma->vm_flags));
	} else {
		/*
		 * Shunt off cached objs to shmem file so they have their own
		 * address_space (so unmap_mapping_range does what we want,
		 * in particular in the case of mmap'd dmabufs)
		 */
		fput(vma->vm_file);
		get_file(obj->filp);
		vma->vm_pgoff = 0;
		vma->vm_file  = obj->filp;

		vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
	}

	return 0;
}

int msm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
{
	int ret;

	ret = drm_gem_mmap(filp, vma);
	if (ret) {
		DBG("mmap failed: %d", ret);
		return ret;
	}

	return msm_gem_mmap_obj(vma->vm_private_data, vma);
}

int msm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	struct drm_gem_object *obj = vma->vm_private_data;
	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	struct drm_device *dev = obj->dev;
	struct page **pages;
	unsigned long pfn;
	pgoff_t pgoff;
	int ret;

	/* Make sure we don't parallel update on a fault, nor move or remove
	 * something from beneath our feet
	 */
	ret = mutex_lock_interruptible(&dev->struct_mutex);
	if (ret)
		goto out;

	/* make sure we have pages attached now */
	pages = get_pages(obj);
	if (IS_ERR(pages)) {
		ret = PTR_ERR(pages);
		goto out_unlock;
	}

	/* We don't use vmf->pgoff since that has the fake offset: */
	pgoff = ((unsigned long)vmf->virtual_address -
			vma->vm_start) >> PAGE_SHIFT;

	pfn = page_to_pfn(msm_obj->pages[pgoff]);

	VERB("Inserting %p pfn %lx, pa %lx", vmf->virtual_address,
			pfn, pfn << PAGE_SHIFT);

	ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn);

out_unlock:
	mutex_unlock(&dev->struct_mutex);
out:
	switch (ret) {
	case -EAGAIN:
	case 0:
	case -ERESTARTSYS:
	case -EINTR:
		return VM_FAULT_NOPAGE;
	case -ENOMEM:
		return VM_FAULT_OOM;
	default:
		return VM_FAULT_SIGBUS;
	}
}

/** get mmap offset */
static uint64_t mmap_offset(struct drm_gem_object *obj)
{
	struct drm_device *dev = obj->dev;
	int ret;

	WARN_ON(!mutex_is_locked(&dev->struct_mutex));

	/* Make it mmapable */
	ret = drm_gem_create_mmap_offset(obj);

	if (ret) {
		dev_err(dev->dev, "could not allocate mmap offset\n");
		return 0;
	}

	return drm_vma_node_offset_addr(&obj->vma_node);
}

uint64_t msm_gem_mmap_offset(struct drm_gem_object *obj)
{
	uint64_t offset;
	mutex_lock(&obj->dev->struct_mutex);
	offset = mmap_offset(obj);
	mutex_unlock(&obj->dev->struct_mutex);
	return offset;
}

/* helpers for dealing w/ iommu: */
static int map_range(struct iommu_domain *domain, unsigned int iova,
		struct sg_table *sgt, unsigned int len, int prot)
{
	struct scatterlist *sg;
	unsigned int da = iova;
	unsigned int i, j;
	int ret;

	if (!domain || !sgt)
		return -EINVAL;

	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
		u32 pa = sg_phys(sg) - sg->offset;
		size_t bytes = sg->length + sg->offset;

		VERB("map[%d]: %08x %08x(%x)", i, iova, pa, bytes);

		ret = iommu_map(domain, da, pa, bytes, prot);
		if (ret)
			goto fail;

		da += bytes;
	}

	return 0;

fail:
	da = iova;

	for_each_sg(sgt->sgl, sg, i, j) {
		size_t bytes = sg->length + sg->offset;
		iommu_unmap(domain, da, bytes);
		da += bytes;
	}
	return ret;
}

static void unmap_range(struct iommu_domain *domain, unsigned int iova,
		struct sg_table *sgt, unsigned int len)
{
	struct scatterlist *sg;
	unsigned int da = iova;
	int i;

	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
		size_t bytes = sg->length + sg->offset;
		size_t unmapped;

		unmapped = iommu_unmap(domain, da, bytes);
		if (unmapped < bytes)
			break;

		VERB("unmap[%d]: %08x(%x)", i, iova, bytes);

		BUG_ON(!IS_ALIGNED(bytes, PAGE_SIZE));

		da += bytes;
	}
}

/* should be called under struct_mutex.. although it can be called
 * from atomic context without struct_mutex to acquire an extra
 * iova ref if you know one is already held.
 *
 * That means when I do eventually need to add support for unpinning
 * the refcnt counter needs to be atomic_t.
 */
int msm_gem_get_iova_locked(struct drm_gem_object *obj, int id,
		uint32_t *iova)
{
	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	int ret = 0;

	if (!msm_obj->domain[id].iova) {
		struct msm_drm_private *priv = obj->dev->dev_private;
		uint32_t offset = (uint32_t)mmap_offset(obj);
		struct page **pages;
		pages = get_pages(obj);
		if (IS_ERR(pages))
			return PTR_ERR(pages);
		// XXX ideally we would not map buffers writable when not needed...
		ret = map_range(priv->iommus[id], offset, msm_obj->sgt,
				obj->size, IOMMU_READ | IOMMU_WRITE);
		msm_obj->domain[id].iova = offset;
	}

	if (!ret)
		*iova = msm_obj->domain[id].iova;

	return ret;
}

int msm_gem_get_iova(struct drm_gem_object *obj, int id, uint32_t *iova)
{
	int ret;
	mutex_lock(&obj->dev->struct_mutex);
	ret = msm_gem_get_iova_locked(obj, id, iova);
	mutex_unlock(&obj->dev->struct_mutex);
	return ret;
}

void msm_gem_put_iova(struct drm_gem_object *obj, int id)
{
	// XXX TODO ..
	// NOTE: probably don't need a _locked() version.. we wouldn't
	// normally unmap here, but instead just mark that it could be
	// unmapped (if the iova refcnt drops to zero), but then later
	// if another _get_iova_locked() fails we can start unmapping
	// things that are no longer needed..
}

int msm_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
		struct drm_mode_create_dumb *args)
{
	args->pitch = align_pitch(args->width, args->bpp);
	args->size  = PAGE_ALIGN(args->pitch * args->height);
	return msm_gem_new_handle(dev, file, args->size,
			MSM_BO_SCANOUT | MSM_BO_WC, &args->handle);
}

int msm_gem_dumb_map_offset(struct drm_file *file, struct drm_device *dev,
		uint32_t handle, uint64_t *offset)
{
	struct drm_gem_object *obj;
	int ret = 0;

	/* GEM does all our handle to object mapping */
	obj = drm_gem_object_lookup(dev, file, handle);
	if (obj == NULL) {
		ret = -ENOENT;
		goto fail;
	}

	*offset = msm_gem_mmap_offset(obj);

	drm_gem_object_unreference_unlocked(obj);

fail:
	return ret;
}

void *msm_gem_vaddr_locked(struct drm_gem_object *obj)
{
	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	WARN_ON(!mutex_is_locked(&obj->dev->struct_mutex));
	if (!msm_obj->vaddr) {
		struct page **pages = get_pages(obj);
		if (IS_ERR(pages))
			return ERR_CAST(pages);
		msm_obj->vaddr = vmap(pages, obj->size >> PAGE_SHIFT,
				VM_MAP, pgprot_writecombine(PAGE_KERNEL));
	}
	return msm_obj->vaddr;
}

void *msm_gem_vaddr(struct drm_gem_object *obj)
{
	void *ret;
	mutex_lock(&obj->dev->struct_mutex);
	ret = msm_gem_vaddr_locked(obj);
	mutex_unlock(&obj->dev->struct_mutex);
	return ret;
}

int msm_gem_queue_inactive_work(struct drm_gem_object *obj,
		struct work_struct *work)
{
	struct drm_device *dev = obj->dev;
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	int ret = 0;

	mutex_lock(&dev->struct_mutex);
	if (!list_empty(&work->entry)) {
		ret = -EINVAL;
	} else if (is_active(msm_obj)) {
		list_add_tail(&work->entry, &msm_obj->inactive_work);
	} else {
		queue_work(priv->wq, work);
	}
	mutex_unlock(&dev->struct_mutex);

	return ret;
}

void msm_gem_move_to_active(struct drm_gem_object *obj,
		struct msm_gpu *gpu, bool write, uint32_t fence)
{
	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	msm_obj->gpu = gpu;
	if (write)
		msm_obj->write_fence = fence;
	else
		msm_obj->read_fence = fence;
	list_del_init(&msm_obj->mm_list);
	list_add_tail(&msm_obj->mm_list, &gpu->active_list);
}

void msm_gem_move_to_inactive(struct drm_gem_object *obj)
{
	struct drm_device *dev = obj->dev;
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_gem_object *msm_obj = to_msm_bo(obj);

	WARN_ON(!mutex_is_locked(&dev->struct_mutex));

	msm_obj->gpu = NULL;
	msm_obj->read_fence = 0;
	msm_obj->write_fence = 0;
	list_del_init(&msm_obj->mm_list);
	list_add_tail(&msm_obj->mm_list, &priv->inactive_list);

	while (!list_empty(&msm_obj->inactive_work)) {
		struct work_struct *work;

		work = list_first_entry(&msm_obj->inactive_work,
				struct work_struct, entry);

		list_del_init(&work->entry);
		queue_work(priv->wq, work);
	}
}

int msm_gem_cpu_prep(struct drm_gem_object *obj, uint32_t op,
		struct timespec *timeout)
{
	struct drm_device *dev = obj->dev;
	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	int ret = 0;

	if (is_active(msm_obj)) {
		uint32_t fence = 0;

		if (op & MSM_PREP_READ)
			fence = msm_obj->write_fence;
		if (op & MSM_PREP_WRITE)
			fence = max(fence, msm_obj->read_fence);
		if (op & MSM_PREP_NOSYNC)
			timeout = NULL;

		ret = msm_wait_fence_interruptable(dev, fence, timeout);
	}

	/* TODO cache maintenance */

	return ret;
}

int msm_gem_cpu_fini(struct drm_gem_object *obj)
{
	/* TODO cache maintenance */
	return 0;
}

#ifdef CONFIG_DEBUG_FS
void msm_gem_describe(struct drm_gem_object *obj, struct seq_file *m)
{
	struct drm_device *dev = obj->dev;
	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	uint64_t off = drm_vma_node_start(&obj->vma_node);

	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
	seq_printf(m, "%08x: %c(r=%u,w=%u) %2d (%2d) %08llx %p %d\n",
			msm_obj->flags, is_active(msm_obj) ? 'A' : 'I',
			msm_obj->read_fence, msm_obj->write_fence,
			obj->name, obj->refcount.refcount.counter,
			off, msm_obj->vaddr, obj->size);
}

void msm_gem_describe_objects(struct list_head *list, struct seq_file *m)
{
	struct msm_gem_object *msm_obj;
	int count = 0;
	size_t size = 0;

	list_for_each_entry(msm_obj, list, mm_list) {
		struct drm_gem_object *obj = &msm_obj->base;
		seq_printf(m, "   ");
		msm_gem_describe(obj, m);
		count++;
		size += obj->size;
	}

	seq_printf(m, "Total %d objects, %zu bytes\n", count, size);
}
#endif

void msm_gem_free_object(struct drm_gem_object *obj)
{
	struct drm_device *dev = obj->dev;
	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	int id;

	WARN_ON(!mutex_is_locked(&dev->struct_mutex));

	/* object should not be on active list: */
	WARN_ON(is_active(msm_obj));

	list_del(&msm_obj->mm_list);

	for (id = 0; id < ARRAY_SIZE(msm_obj->domain); id++) {
		if (msm_obj->domain[id].iova) {
			struct msm_drm_private *priv = obj->dev->dev_private;
			uint32_t offset = (uint32_t)mmap_offset(obj);
			unmap_range(priv->iommus[id], offset,
					msm_obj->sgt, obj->size);
		}
	}

	drm_gem_free_mmap_offset(obj);

	if (msm_obj->vaddr)
		vunmap(msm_obj->vaddr);

	put_pages(obj);

	if (msm_obj->resv == &msm_obj->_resv)
		reservation_object_fini(msm_obj->resv);

	drm_gem_object_release(obj);

	kfree(msm_obj);
}

/* convenience method to construct a GEM buffer object, and userspace handle */
int msm_gem_new_handle(struct drm_device *dev, struct drm_file *file,
		uint32_t size, uint32_t flags, uint32_t *handle)
{
	struct drm_gem_object *obj;
	int ret;

	ret = mutex_lock_interruptible(&dev->struct_mutex);
	if (ret)
		return ret;

	obj = msm_gem_new(dev, size, flags);

	mutex_unlock(&dev->struct_mutex);

	if (IS_ERR(obj))
		return PTR_ERR(obj);

	ret = drm_gem_handle_create(file, obj, handle);

	/* drop reference from allocate - handle holds it now */
	drm_gem_object_unreference_unlocked(obj);

	return ret;
}

struct drm_gem_object *msm_gem_new(struct drm_device *dev,
		uint32_t size, uint32_t flags)
{
	struct msm_drm_private *priv = dev->dev_private;
	struct msm_gem_object *msm_obj;
	struct drm_gem_object *obj = NULL;
	int ret;

	WARN_ON(!mutex_is_locked(&dev->struct_mutex));

	size = PAGE_ALIGN(size);

	switch (flags & MSM_BO_CACHE_MASK) {
	case MSM_BO_UNCACHED:
	case MSM_BO_CACHED:
	case MSM_BO_WC:
		break;
	default:
		dev_err(dev->dev, "invalid cache flag: %x\n",
				(flags & MSM_BO_CACHE_MASK));
		ret = -EINVAL;
		goto fail;
	}

	msm_obj = kzalloc(sizeof(*msm_obj), GFP_KERNEL);
	if (!msm_obj) {
		ret = -ENOMEM;
		goto fail;
	}

	obj = &msm_obj->base;

	ret = drm_gem_object_init(dev, obj, size);
	if (ret)
		goto fail;

	msm_obj->flags = flags;

	msm_obj->resv = &msm_obj->_resv;
	reservation_object_init(msm_obj->resv);

	INIT_LIST_HEAD(&msm_obj->submit_entry);
	INIT_LIST_HEAD(&msm_obj->inactive_work);
	list_add_tail(&msm_obj->mm_list, &priv->inactive_list);

	return obj;

fail:
	if (obj)
		drm_gem_object_unreference_unlocked(obj);

	return ERR_PTR(ret);
}
Commit	Line	Data
c8afe684 RC	1	/*
	2	* Copyright (C) 2013 Red Hat
	3	* Author: Rob Clark <robdclark@gmail.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program. If not, see <http://www.gnu.org/licenses/>.
	16	*/
	17
	18	#include <linux/spinlock.h>
	19	#include <linux/shmem_fs.h>
	20
	21	#include "msm_drv.h"
	22	#include "msm_gem.h"
7198e6b0	23	#include "msm_gpu.h"
c8afe684 RC	24
	25
	26	/* called with dev->struct_mutex held */
	27	static struct page *get_pages(struct drm_gem_object obj)
	28	{
	29	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	30
	31	if (!msm_obj->pages) {
	32	struct drm_device *dev = obj->dev;
	33	struct page **p = drm_gem_get_pages(obj, 0);
	34	int npages = obj->size >> PAGE_SHIFT;
	35
	36	if (IS_ERR(p)) {
	37	dev_err(dev->dev, "could not get pages: %ld\n",
	38	PTR_ERR(p));
	39	return p;
	40	}
	41
	42	msm_obj->sgt = drm_prime_pages_to_sg(p, npages);
1f70e079	43	if (IS_ERR(msm_obj->sgt)) {
c8afe684	44	dev_err(dev->dev, "failed to allocate sgt\n");
1f70e079	45	return ERR_CAST(msm_obj->sgt);
c8afe684 RC	46	}
	47
	48	msm_obj->pages = p;
	49
	50	/* For non-cached buffers, ensure the new pages are clean
	51	* because display controller, GPU, etc. are not coherent:
	52	*/
	53	if (msm_obj->flags & (MSM_BO_WC\|MSM_BO_UNCACHED))
	54	dma_map_sg(dev->dev, msm_obj->sgt->sgl,
	55	msm_obj->sgt->nents, DMA_BIDIRECTIONAL);
	56	}
	57
	58	return msm_obj->pages;
	59	}
	60
	61	static void put_pages(struct drm_gem_object *obj)
	62	{
	63	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	64
	65	if (msm_obj->pages) {
	66	/* For non-cached buffers, ensure the new pages are clean
	67	* because display controller, GPU, etc. are not coherent:
	68	*/
	69	if (msm_obj->flags & (MSM_BO_WC\|MSM_BO_UNCACHED))
	70	dma_unmap_sg(obj->dev->dev, msm_obj->sgt->sgl,
	71	msm_obj->sgt->nents, DMA_BIDIRECTIONAL);
	72	sg_free_table(msm_obj->sgt);
	73	kfree(msm_obj->sgt);
	74
	75	drm_gem_put_pages(obj, msm_obj->pages, true, false);
	76	msm_obj->pages = NULL;
	77	}
	78	}
	79
	80	int msm_gem_mmap_obj(struct drm_gem_object *obj,
	81	struct vm_area_struct *vma)
	82	{
	83	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	84
	85	vma->vm_flags &= ~VM_PFNMAP;
	86	vma->vm_flags \|= VM_MIXEDMAP;
	87
	88	if (msm_obj->flags & MSM_BO_WC) {
	89	vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
	90	} else if (msm_obj->flags & MSM_BO_UNCACHED) {
	91	vma->vm_page_prot = pgprot_noncached(vm_get_page_prot(vma->vm_flags));
	92	} else {
	93	/*
	94	* Shunt off cached objs to shmem file so they have their own
	95	* address_space (so unmap_mapping_range does what we want,
	96	* in particular in the case of mmap'd dmabufs)
	97	*/
	98	fput(vma->vm_file);
	99	get_file(obj->filp);
	100	vma->vm_pgoff = 0;
	101	vma->vm_file = obj->filp;
	102
	103	vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
	104	}
	105
	106	return 0;
	107	}
	108
	109	int msm_gem_mmap(struct file filp, struct vm_area_struct vma)
110	{
111	int ret;
112
113	ret = drm_gem_mmap(filp, vma);
114	if (ret) {
115	DBG("mmap failed: %d", ret);
116	return ret;
117	}
118
119	return msm_gem_mmap_obj(vma->vm_private_data, vma);
120	}
121
122	int msm_gem_fault(struct vm_area_struct vma, struct vm_fault vmf)
123	{
124	struct drm_gem_object *obj = vma->vm_private_data;
125	struct msm_gem_object *msm_obj = to_msm_bo(obj);
126	struct drm_device *dev = obj->dev;
127	struct page **pages;
128	unsigned long pfn;
129	pgoff_t pgoff;
130	int ret;
131
132	/* Make sure we don't parallel update on a fault, nor move or remove
133	* something from beneath our feet
134	*/
135	ret = mutex_lock_interruptible(&dev->struct_mutex);
136	if (ret)
137	goto out;
138
139	/* make sure we have pages attached now */
140	pages = get_pages(obj);
141	if (IS_ERR(pages)) {
142	ret = PTR_ERR(pages);
143	goto out_unlock;
144	}
145
146	/* We don't use vmf->pgoff since that has the fake offset: */
147	pgoff = ((unsigned long)vmf->virtual_address -
148	vma->vm_start) >> PAGE_SHIFT;
149
150	pfn = page_to_pfn(msm_obj->pages[pgoff]);
151
152	VERB("Inserting %p pfn %lx, pa %lx", vmf->virtual_address,
153	pfn, pfn << PAGE_SHIFT);
154
155	ret = vm_insert_mixed(vma, (unsigned long)vmf->virtual_address, pfn);
156
157	out_unlock:
158	mutex_unlock(&dev->struct_mutex);
159	out:
160	switch (ret) {
161	case -EAGAIN:
c8afe684 RC	162	case 0:
	163	case -ERESTARTSYS:
	164	case -EINTR:
	165	return VM_FAULT_NOPAGE;
	166	case -ENOMEM:
	167	return VM_FAULT_OOM;
	168	default:
	169	return VM_FAULT_SIGBUS;
	170	}
	171	}
	172
	173	/** get mmap offset */
	174	static uint64_t mmap_offset(struct drm_gem_object *obj)
	175	{
	176	struct drm_device *dev = obj->dev;
	177	int ret;
	178
	179	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
	180
	181	/* Make it mmapable */
	182	ret = drm_gem_create_mmap_offset(obj);
	183
	184	if (ret) {
	185	dev_err(dev->dev, "could not allocate mmap offset\n");
	186	return 0;
	187	}
	188
	189	return drm_vma_node_offset_addr(&obj->vma_node);
	190	}
	191
	192	uint64_t msm_gem_mmap_offset(struct drm_gem_object *obj)
	193	{
	194	uint64_t offset;
	195	mutex_lock(&obj->dev->struct_mutex);
	196	offset = mmap_offset(obj);
	197	mutex_unlock(&obj->dev->struct_mutex);
	198	return offset;
	199	}
	200
	201	/* helpers for dealing w/ iommu: */
	202	static int map_range(struct iommu_domain *domain, unsigned int iova,
	203	struct sg_table *sgt, unsigned int len, int prot)
	204	{
	205	struct scatterlist *sg;
	206	unsigned int da = iova;
	207	unsigned int i, j;
	208	int ret;
	209
	210	if (!domain \|\| !sgt)
	211	return -EINVAL;
	212
	213	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
	214	u32 pa = sg_phys(sg) - sg->offset;
	215	size_t bytes = sg->length + sg->offset;
	216
	217	VERB("map[%d]: %08x %08x(%x)", i, iova, pa, bytes);
	218
	219	ret = iommu_map(domain, da, pa, bytes, prot);
	220	if (ret)
	221	goto fail;
	222
	223	da += bytes;
	224	}
	225
226	return 0;
227
228	fail:
229	da = iova;
230
231	for_each_sg(sgt->sgl, sg, i, j) {
232	size_t bytes = sg->length + sg->offset;
233	iommu_unmap(domain, da, bytes);
234	da += bytes;
235	}
236	return ret;
237	}
238
239	static void unmap_range(struct iommu_domain *domain, unsigned int iova,
240	struct sg_table *sgt, unsigned int len)
241	{
242	struct scatterlist *sg;
243	unsigned int da = iova;
244	int i;
245
246	for_each_sg(sgt->sgl, sg, sgt->nents, i) {
247	size_t bytes = sg->length + sg->offset;
248	size_t unmapped;
249
250	unmapped = iommu_unmap(domain, da, bytes);
251	if (unmapped < bytes)
252	break;
253
254	VERB("unmap[%d]: %08x(%x)", i, iova, bytes);
255
256	BUG_ON(!IS_ALIGNED(bytes, PAGE_SIZE));
257
258	da += bytes;
259	}
260	}
261
262	/* should be called under struct_mutex.. although it can be called
263	* from atomic context without struct_mutex to acquire an extra
264	* iova ref if you know one is already held.
265	*
266	* That means when I do eventually need to add support for unpinning
267	* the refcnt counter needs to be atomic_t.
268	*/
269	int msm_gem_get_iova_locked(struct drm_gem_object *obj, int id,
270	uint32_t *iova)
271	{
272	struct msm_gem_object *msm_obj = to_msm_bo(obj);
273	int ret = 0;
274
275	if (!msm_obj->domain[id].iova) {
276	struct msm_drm_private *priv = obj->dev->dev_private;
277	uint32_t offset = (uint32_t)mmap_offset(obj);
278	struct page **pages;
279	pages = get_pages(obj);
280	if (IS_ERR(pages))
281	return PTR_ERR(pages);
282	// XXX ideally we would not map buffers writable when not needed...
283	ret = map_range(priv->iommus[id], offset, msm_obj->sgt,
284	obj->size, IOMMU_READ \| IOMMU_WRITE);
285	msm_obj->domain[id].iova = offset;
286	}
287
288	if (!ret)
289	*iova = msm_obj->domain[id].iova;
290
291	return ret;
292	}
293
294	int msm_gem_get_iova(struct drm_gem_object obj, int id, uint32_t iova)
295	{
296	int ret;
297	mutex_lock(&obj->dev->struct_mutex);
298	ret = msm_gem_get_iova_locked(obj, id, iova);
299	mutex_unlock(&obj->dev->struct_mutex);
300	return ret;
301	}
302
303	void msm_gem_put_iova(struct drm_gem_object *obj, int id)
304	{
305	// XXX TODO ..
306	// NOTE: probably don't need a _locked() version.. we wouldn't
307	// normally unmap here, but instead just mark that it could be
308	// unmapped (if the iova refcnt drops to zero), but then later
309	// if another _get_iova_locked() fails we can start unmapping
310	// things that are no longer needed..
311	}
312
313	int msm_gem_dumb_create(struct drm_file file, struct drm_device dev,
314	struct drm_mode_create_dumb *args)
315	{
316	args->pitch = align_pitch(args->width, args->bpp);
317	args->size = PAGE_ALIGN(args->pitch * args->height);
318	return msm_gem_new_handle(dev, file, args->size,
319	MSM_BO_SCANOUT \| MSM_BO_WC, &args->handle);
320	}
321
c8afe684 RC	322	int msm_gem_dumb_map_offset(struct drm_file file, struct drm_device dev,
	323	uint32_t handle, uint64_t *offset)
	324	{
	325	struct drm_gem_object *obj;
	326	int ret = 0;
	327
	328	/* GEM does all our handle to object mapping */
	329	obj = drm_gem_object_lookup(dev, file, handle);
	330	if (obj == NULL) {
	331	ret = -ENOENT;
	332	goto fail;
	333	}
	334
	335	*offset = msm_gem_mmap_offset(obj);
	336
	337	drm_gem_object_unreference_unlocked(obj);
	338
	339	fail:
	340	return ret;
	341	}
	342
	343	void msm_gem_vaddr_locked(struct drm_gem_object obj)
	344	{
	345	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	346	WARN_ON(!mutex_is_locked(&obj->dev->struct_mutex));
	347	if (!msm_obj->vaddr) {
	348	struct page **pages = get_pages(obj);
	349	if (IS_ERR(pages))
	350	return ERR_CAST(pages);
	351	msm_obj->vaddr = vmap(pages, obj->size >> PAGE_SHIFT,
	352	VM_MAP, pgprot_writecombine(PAGE_KERNEL));
	353	}
	354	return msm_obj->vaddr;
	355	}
	356
	357	void msm_gem_vaddr(struct drm_gem_object obj)
	358	{
	359	void *ret;
	360	mutex_lock(&obj->dev->struct_mutex);
	361	ret = msm_gem_vaddr_locked(obj);
	362	mutex_unlock(&obj->dev->struct_mutex);
	363	return ret;
	364	}
	365
	366	int msm_gem_queue_inactive_work(struct drm_gem_object *obj,
	367	struct work_struct *work)
	368	{
	369	struct drm_device *dev = obj->dev;
	370	struct msm_drm_private *priv = dev->dev_private;
7198e6b0 RC	371	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	372	int ret = 0;
	373
	374	mutex_lock(&dev->struct_mutex);
	375	if (!list_empty(&work->entry)) {
	376	ret = -EINVAL;
	377	} else if (is_active(msm_obj)) {
	378	list_add_tail(&work->entry, &msm_obj->inactive_work);
	379	} else {
	380	queue_work(priv->wq, work);
	381	}
	382	mutex_unlock(&dev->struct_mutex);
	383
	384	return ret;
	385	}
	386
	387	void msm_gem_move_to_active(struct drm_gem_object *obj,
bf6811f3	388	struct msm_gpu *gpu, bool write, uint32_t fence)
7198e6b0 RC	389	{
	390	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	391	msm_obj->gpu = gpu;
bf6811f3 RC	392	if (write)
	393	msm_obj->write_fence = fence;
	394	else
	395	msm_obj->read_fence = fence;
7198e6b0 RC	396	list_del_init(&msm_obj->mm_list);
	397	list_add_tail(&msm_obj->mm_list, &gpu->active_list);
	398	}
	399
	400	void msm_gem_move_to_inactive(struct drm_gem_object *obj)
	401	{
	402	struct drm_device *dev = obj->dev;
	403	struct msm_drm_private *priv = dev->dev_private;
	404	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	405
	406	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
	407
	408	msm_obj->gpu = NULL;
bf6811f3 RC	409	msm_obj->read_fence = 0;
bf6811f3 RC	410	msm_obj->write_fence = 0;
7198e6b0 RC	411	list_del_init(&msm_obj->mm_list);
	412	list_add_tail(&msm_obj->mm_list, &priv->inactive_list);
	413
	414	while (!list_empty(&msm_obj->inactive_work)) {
	415	struct work_struct *work;
	416
	417	work = list_first_entry(&msm_obj->inactive_work,
	418	struct work_struct, entry);
	419
	420	list_del_init(&work->entry);
	421	queue_work(priv->wq, work);
	422	}
	423	}
	424
	425	int msm_gem_cpu_prep(struct drm_gem_object *obj, uint32_t op,
	426	struct timespec *timeout)
	427	{
	428	struct drm_device *dev = obj->dev;
	429	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	430	int ret = 0;
	431
f816f272	432	if (is_active(msm_obj)) {
bf6811f3	433	uint32_t fence = 0;
f816f272	434
bf6811f3 RC	435	if (op & MSM_PREP_READ)
	436	fence = msm_obj->write_fence;
	437	if (op & MSM_PREP_WRITE)
	438	fence = max(fence, msm_obj->read_fence);
f816f272 RC	439	if (op & MSM_PREP_NOSYNC)
	440	timeout = NULL;
	441
bf6811f3 RC	442	ret = msm_wait_fence_interruptable(dev, fence, timeout);
bf6811f3 RC	443	}
7198e6b0 RC	444
7198e6b0 RC	445	/* TODO cache maintenance */
c8afe684	446
7198e6b0 RC	447	return ret;
7198e6b0 RC	448	}
c8afe684	449
7198e6b0 RC	450	int msm_gem_cpu_fini(struct drm_gem_object *obj)
	451	{
	452	/* TODO cache maintenance */
c8afe684 RC	453	return 0;
	454	}
	455
	456	#ifdef CONFIG_DEBUG_FS
	457	void msm_gem_describe(struct drm_gem_object obj, struct seq_file m)
	458	{
	459	struct drm_device *dev = obj->dev;
	460	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	461	uint64_t off = drm_vma_node_start(&obj->vma_node);
	462
	463	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
bf6811f3	464	seq_printf(m, "%08x: %c(r=%u,w=%u) %2d (%2d) %08llx %p %d\n",
7198e6b0	465	msm_obj->flags, is_active(msm_obj) ? 'A' : 'I',
bf6811f3 RC	466	msm_obj->read_fence, msm_obj->write_fence,
bf6811f3 RC	467	obj->name, obj->refcount.refcount.counter,
c8afe684 RC	468	off, msm_obj->vaddr, obj->size);
	469	}
	470
	471	void msm_gem_describe_objects(struct list_head list, struct seq_file m)
	472	{
	473	struct msm_gem_object *msm_obj;
	474	int count = 0;
	475	size_t size = 0;
	476
	477	list_for_each_entry(msm_obj, list, mm_list) {
	478	struct drm_gem_object *obj = &msm_obj->base;
	479	seq_printf(m, " ");
	480	msm_gem_describe(obj, m);
	481	count++;
	482	size += obj->size;
	483	}
	484
	485	seq_printf(m, "Total %d objects, %zu bytes\n", count, size);
	486	}
	487	#endif
	488
	489	void msm_gem_free_object(struct drm_gem_object *obj)
	490	{
	491	struct drm_device *dev = obj->dev;
	492	struct msm_gem_object *msm_obj = to_msm_bo(obj);
	493	int id;
	494
	495	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
	496
7198e6b0 RC	497	/* object should not be on active list: */
	498	WARN_ON(is_active(msm_obj));
	499
c8afe684 RC	500	list_del(&msm_obj->mm_list);
	501
	502	for (id = 0; id < ARRAY_SIZE(msm_obj->domain); id++) {
	503	if (msm_obj->domain[id].iova) {
	504	struct msm_drm_private *priv = obj->dev->dev_private;
	505	uint32_t offset = (uint32_t)mmap_offset(obj);
	506	unmap_range(priv->iommus[id], offset,
	507	msm_obj->sgt, obj->size);
	508	}
	509	}
	510
	511	drm_gem_free_mmap_offset(obj);
	512
	513	if (msm_obj->vaddr)
	514	vunmap(msm_obj->vaddr);
	515
	516	put_pages(obj);
	517
7198e6b0 RC	518	if (msm_obj->resv == &msm_obj->_resv)
	519	reservation_object_fini(msm_obj->resv);
	520
c8afe684 RC	521	drm_gem_object_release(obj);
	522
	523	kfree(msm_obj);
	524	}
	525
	526	/* convenience method to construct a GEM buffer object, and userspace handle */
	527	int msm_gem_new_handle(struct drm_device dev, struct drm_file file,
	528	uint32_t size, uint32_t flags, uint32_t *handle)
	529	{
	530	struct drm_gem_object *obj;
	531	int ret;
	532
	533	ret = mutex_lock_interruptible(&dev->struct_mutex);
	534	if (ret)
	535	return ret;
	536
	537	obj = msm_gem_new(dev, size, flags);
	538
	539	mutex_unlock(&dev->struct_mutex);
	540
	541	if (IS_ERR(obj))
	542	return PTR_ERR(obj);
	543
	544	ret = drm_gem_handle_create(file, obj, handle);
	545
	546	/* drop reference from allocate - handle holds it now */
	547	drm_gem_object_unreference_unlocked(obj);
	548
	549	return ret;
	550	}
	551
	552	struct drm_gem_object msm_gem_new(struct drm_device dev,
	553	uint32_t size, uint32_t flags)
	554	{
	555	struct msm_drm_private *priv = dev->dev_private;
	556	struct msm_gem_object *msm_obj;
	557	struct drm_gem_object *obj = NULL;
	558	int ret;
	559
	560	WARN_ON(!mutex_is_locked(&dev->struct_mutex));
	561
	562	size = PAGE_ALIGN(size);
	563
	564	switch (flags & MSM_BO_CACHE_MASK) {
	565	case MSM_BO_UNCACHED:
	566	case MSM_BO_CACHED:
	567	case MSM_BO_WC:
	568	break;
	569	default:
	570	dev_err(dev->dev, "invalid cache flag: %x\n",
	571	(flags & MSM_BO_CACHE_MASK));
	572	ret = -EINVAL;
	573	goto fail;
	574	}
	575
	576	msm_obj = kzalloc(sizeof(*msm_obj), GFP_KERNEL);
	577	if (!msm_obj) {
	578	ret = -ENOMEM;
	579	goto fail;
	580	}
	581
	582	obj = &msm_obj->base;
	583
	584	ret = drm_gem_object_init(dev, obj, size);
585	if (ret)
586	goto fail;
587
588	msm_obj->flags = flags;
589
7198e6b0 RC	590	msm_obj->resv = &msm_obj->_resv;
7198e6b0 RC	591	reservation_object_init(msm_obj->resv);
c8afe684	592
7198e6b0 RC	593	INIT_LIST_HEAD(&msm_obj->submit_entry);
7198e6b0 RC	594	INIT_LIST_HEAD(&msm_obj->inactive_work);
c8afe684 RC	595	list_add_tail(&msm_obj->mm_list, &priv->inactive_list);
	596
	597	return obj;
	598
	599	fail:
	600	if (obj)
	601	drm_gem_object_unreference_unlocked(obj);
	602
	603	return ERR_PTR(ret);
	604	}