[linux-2.6-block.git] / drivers / gpu / drm / mediatek / mtk_drm_gem.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2015 MediaTek Inc.
 */

#include <linux/dma-buf.h>

#include <drm/drm.h>
#include <drm/drm_device.h>
#include <drm/drm_gem.h>
#include <drm/drm_gem_cma_helper.h>
#include <drm/drm_prime.h>

#include "mtk_drm_drv.h"
#include "mtk_drm_gem.h"

static const struct drm_gem_object_funcs mtk_drm_gem_object_funcs = {
	.free = mtk_drm_gem_free_object,
	.get_sg_table = mtk_gem_prime_get_sg_table,
	.vmap = mtk_drm_gem_prime_vmap,
	.vunmap = mtk_drm_gem_prime_vunmap,
	.vm_ops = &drm_gem_cma_vm_ops,
};

static struct mtk_drm_gem_obj *mtk_drm_gem_init(struct drm_device *dev,
						unsigned long size)
{
	struct mtk_drm_gem_obj *mtk_gem_obj;
	int ret;

	size = round_up(size, PAGE_SIZE);

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

	mtk_gem_obj->base.funcs = &mtk_drm_gem_object_funcs;

	ret = drm_gem_object_init(dev, &mtk_gem_obj->base, size);
	if (ret < 0) {
		DRM_ERROR("failed to initialize gem object\n");
		kfree(mtk_gem_obj);
		return ERR_PTR(ret);
	}

	return mtk_gem_obj;
}

struct mtk_drm_gem_obj *mtk_drm_gem_create(struct drm_device *dev,
					   size_t size, bool alloc_kmap)
{
	struct mtk_drm_private *priv = dev->dev_private;
	struct mtk_drm_gem_obj *mtk_gem;
	struct drm_gem_object *obj;
	int ret;

	mtk_gem = mtk_drm_gem_init(dev, size);
	if (IS_ERR(mtk_gem))
		return ERR_CAST(mtk_gem);

	obj = &mtk_gem->base;

	mtk_gem->dma_attrs = DMA_ATTR_WRITE_COMBINE;

	if (!alloc_kmap)
		mtk_gem->dma_attrs |= DMA_ATTR_NO_KERNEL_MAPPING;

	mtk_gem->cookie = dma_alloc_attrs(priv->dma_dev, obj->size,
					  &mtk_gem->dma_addr, GFP_KERNEL,
					  mtk_gem->dma_attrs);
	if (!mtk_gem->cookie) {
		DRM_ERROR("failed to allocate %zx byte dma buffer", obj->size);
		ret = -ENOMEM;
		goto err_gem_free;
	}

	if (alloc_kmap)
		mtk_gem->kvaddr = mtk_gem->cookie;

	DRM_DEBUG_DRIVER("cookie = %p dma_addr = %pad size = %zu\n",
			 mtk_gem->cookie, &mtk_gem->dma_addr,
			 size);

	return mtk_gem;

err_gem_free:
	drm_gem_object_release(obj);
	kfree(mtk_gem);
	return ERR_PTR(ret);
}

void mtk_drm_gem_free_object(struct drm_gem_object *obj)
{
	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
	struct mtk_drm_private *priv = obj->dev->dev_private;

	if (mtk_gem->sg)
		drm_prime_gem_destroy(obj, mtk_gem->sg);
	else
		dma_free_attrs(priv->dma_dev, obj->size, mtk_gem->cookie,
			       mtk_gem->dma_addr, mtk_gem->dma_attrs);

	/* release file pointer to gem object. */
	drm_gem_object_release(obj);

	kfree(mtk_gem);
}

int mtk_drm_gem_dumb_create(struct drm_file *file_priv, struct drm_device *dev,
			    struct drm_mode_create_dumb *args)
{
	struct mtk_drm_gem_obj *mtk_gem;
	int ret;

	args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
	args->size = args->pitch * args->height;

	mtk_gem = mtk_drm_gem_create(dev, args->size, false);
	if (IS_ERR(mtk_gem))
		return PTR_ERR(mtk_gem);

	/*
	 * allocate a id of idr table where the obj is registered
	 * and handle has the id what user can see.
	 */
	ret = drm_gem_handle_create(file_priv, &mtk_gem->base, &args->handle);
	if (ret)
		goto err_handle_create;

	/* drop reference from allocate - handle holds it now. */
	drm_gem_object_put(&mtk_gem->base);

	return 0;

err_handle_create:
	mtk_drm_gem_free_object(&mtk_gem->base);
	return ret;
}

static int mtk_drm_gem_object_mmap(struct drm_gem_object *obj,
				   struct vm_area_struct *vma)

{
	int ret;
	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
	struct mtk_drm_private *priv = obj->dev->dev_private;

	/*
	 * dma_alloc_attrs() allocated a struct page table for mtk_gem, so clear
	 * VM_PFNMAP flag that was set by drm_gem_mmap_obj()/drm_gem_mmap().
	 */
	vma->vm_flags &= ~VM_PFNMAP;

	ret = dma_mmap_attrs(priv->dma_dev, vma, mtk_gem->cookie,
			     mtk_gem->dma_addr, obj->size, mtk_gem->dma_attrs);
	if (ret)
		drm_gem_vm_close(vma);

	return ret;
}

int mtk_drm_gem_mmap_buf(struct drm_gem_object *obj, struct vm_area_struct *vma)
{
	int ret;

	ret = drm_gem_mmap_obj(obj, obj->size, vma);
	if (ret)
		return ret;

	return mtk_drm_gem_object_mmap(obj, vma);
}

int mtk_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
{
	struct drm_gem_object *obj;
	int ret;

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

	obj = vma->vm_private_data;

	/*
	 * Set vm_pgoff (used as a fake buffer offset by DRM) to 0 and map the
	 * whole buffer from the start.
	 */
	vma->vm_pgoff = 0;

	return mtk_drm_gem_object_mmap(obj, vma);
}

/*
 * Allocate a sg_table for this GEM object.
 * Note: Both the table's contents, and the sg_table itself must be freed by
 *       the caller.
 * Returns a pointer to the newly allocated sg_table, or an ERR_PTR() error.
 */
struct sg_table *mtk_gem_prime_get_sg_table(struct drm_gem_object *obj)
{
	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
	struct mtk_drm_private *priv = obj->dev->dev_private;
	struct sg_table *sgt;
	int ret;

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

	ret = dma_get_sgtable_attrs(priv->dma_dev, sgt, mtk_gem->cookie,
				    mtk_gem->dma_addr, obj->size,
				    mtk_gem->dma_attrs);
	if (ret) {
		DRM_ERROR("failed to allocate sgt, %d\n", ret);
		kfree(sgt);
		return ERR_PTR(ret);
	}

	return sgt;
}

struct drm_gem_object *mtk_gem_prime_import_sg_table(struct drm_device *dev,
			struct dma_buf_attachment *attach, struct sg_table *sg)
{
	struct mtk_drm_gem_obj *mtk_gem;

	/* check if the entries in the sg_table are contiguous */
	if (drm_prime_get_contiguous_size(sg) < attach->dmabuf->size) {
		DRM_ERROR("sg_table is not contiguous");
		return ERR_PTR(-EINVAL);
	}

	mtk_gem = mtk_drm_gem_init(dev, attach->dmabuf->size);
	if (IS_ERR(mtk_gem))
		return ERR_CAST(mtk_gem);

	mtk_gem->dma_addr = sg_dma_address(sg->sgl);
	mtk_gem->sg = sg;

	return &mtk_gem->base;
}

int mtk_drm_gem_prime_vmap(struct drm_gem_object *obj, struct dma_buf_map *map)
{
	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
	struct sg_table *sgt = NULL;
	unsigned int npages;

	if (mtk_gem->kvaddr)
		goto out;

	sgt = mtk_gem_prime_get_sg_table(obj);
	if (IS_ERR(sgt))
		return PTR_ERR(sgt);

	npages = obj->size >> PAGE_SHIFT;
	mtk_gem->pages = kcalloc(npages, sizeof(*mtk_gem->pages), GFP_KERNEL);
	if (!mtk_gem->pages) {
		kfree(sgt);
		return -ENOMEM;
	}

	drm_prime_sg_to_page_addr_arrays(sgt, mtk_gem->pages, NULL, npages);

	mtk_gem->kvaddr = vmap(mtk_gem->pages, npages, VM_MAP,
			       pgprot_writecombine(PAGE_KERNEL));

out:
	kfree(sgt);
	dma_buf_map_set_vaddr(map, mtk_gem->kvaddr);

	return 0;
}

void mtk_drm_gem_prime_vunmap(struct drm_gem_object *obj, struct dma_buf_map *map)
{
	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
	void *vaddr = map->vaddr;

	if (!mtk_gem->pages)
		return;

	vunmap(vaddr);
	mtk_gem->kvaddr = 0;
	kfree(mtk_gem->pages);
}
Commit	Line	Data
1802d0be	1	// SPDX-License-Identifier: GPL-2.0-only
119f5173 CH	2	/*
119f5173 CH	3	* Copyright (c) 2015 MediaTek Inc.
119f5173 CH	4	*/
119f5173 CH	5
119f5173 CH	6	#include <linux/dma-buf.h>
119f5173 CH	7
1eef08cb	8	#include <drm/drm.h>
9aef5867 SR	9	#include <drm/drm_device.h>
9aef5867 SR	10	#include <drm/drm_gem.h>
84274de6	11	#include <drm/drm_gem_cma_helper.h>
9aef5867 SR	12	#include <drm/drm_prime.h>
9aef5867 SR	13
119f5173 CH	14	#include "mtk_drm_drv.h"
	15	#include "mtk_drm_gem.h"
	16
84274de6 TZ	17	static const struct drm_gem_object_funcs mtk_drm_gem_object_funcs = {
	18	.free = mtk_drm_gem_free_object,
	19	.get_sg_table = mtk_gem_prime_get_sg_table,
	20	.vmap = mtk_drm_gem_prime_vmap,
	21	.vunmap = mtk_drm_gem_prime_vunmap,
	22	.vm_ops = &drm_gem_cma_vm_ops,
	23	};
	24
119f5173 CH	25	static struct mtk_drm_gem_obj mtk_drm_gem_init(struct drm_device dev,
	26	unsigned long size)
	27	{
	28	struct mtk_drm_gem_obj *mtk_gem_obj;
	29	int ret;
	30
	31	size = round_up(size, PAGE_SIZE);
	32
	33	mtk_gem_obj = kzalloc(sizeof(*mtk_gem_obj), GFP_KERNEL);
	34	if (!mtk_gem_obj)
	35	return ERR_PTR(-ENOMEM);
	36
84274de6 TZ	37	mtk_gem_obj->base.funcs = &mtk_drm_gem_object_funcs;
84274de6 TZ	38
119f5173 CH	39	ret = drm_gem_object_init(dev, &mtk_gem_obj->base, size);
	40	if (ret < 0) {
	41	DRM_ERROR("failed to initialize gem object\n");
	42	kfree(mtk_gem_obj);
	43	return ERR_PTR(ret);
	44	}
	45
	46	return mtk_gem_obj;
	47	}
	48
	49	struct mtk_drm_gem_obj mtk_drm_gem_create(struct drm_device dev,
	50	size_t size, bool alloc_kmap)
	51	{
	52	struct mtk_drm_private *priv = dev->dev_private;
	53	struct mtk_drm_gem_obj *mtk_gem;
	54	struct drm_gem_object *obj;
	55	int ret;
	56
	57	mtk_gem = mtk_drm_gem_init(dev, size);
	58	if (IS_ERR(mtk_gem))
	59	return ERR_CAST(mtk_gem);
	60
	61	obj = &mtk_gem->base;
	62
00085f1e	63	mtk_gem->dma_attrs = DMA_ATTR_WRITE_COMBINE;
119f5173 CH	64
119f5173 CH	65	if (!alloc_kmap)
00085f1e	66	mtk_gem->dma_attrs \|= DMA_ATTR_NO_KERNEL_MAPPING;
119f5173 CH	67
	68	mtk_gem->cookie = dma_alloc_attrs(priv->dma_dev, obj->size,
	69	&mtk_gem->dma_addr, GFP_KERNEL,
00085f1e	70	mtk_gem->dma_attrs);
119f5173 CH	71	if (!mtk_gem->cookie) {
	72	DRM_ERROR("failed to allocate %zx byte dma buffer", obj->size);
	73	ret = -ENOMEM;
	74	goto err_gem_free;
	75	}
	76
	77	if (alloc_kmap)
	78	mtk_gem->kvaddr = mtk_gem->cookie;
	79
	80	DRM_DEBUG_DRIVER("cookie = %p dma_addr = %pad size = %zu\n",
	81	mtk_gem->cookie, &mtk_gem->dma_addr,
	82	size);
	83
	84	return mtk_gem;
	85
	86	err_gem_free:
	87	drm_gem_object_release(obj);
	88	kfree(mtk_gem);
	89	return ERR_PTR(ret);
	90	}
	91
	92	void mtk_drm_gem_free_object(struct drm_gem_object *obj)
	93	{
	94	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
	95	struct mtk_drm_private *priv = obj->dev->dev_private;
	96
	97	if (mtk_gem->sg)
	98	drm_prime_gem_destroy(obj, mtk_gem->sg);
	99	else
	100	dma_free_attrs(priv->dma_dev, obj->size, mtk_gem->cookie,
00085f1e	101	mtk_gem->dma_addr, mtk_gem->dma_attrs);
119f5173 CH	102
	103	/* release file pointer to gem object. */
	104	drm_gem_object_release(obj);
	105
	106	kfree(mtk_gem);
	107	}
	108
	109	int mtk_drm_gem_dumb_create(struct drm_file file_priv, struct drm_device dev,
	110	struct drm_mode_create_dumb *args)
	111	{
	112	struct mtk_drm_gem_obj *mtk_gem;
	113	int ret;
	114
	115	args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
	116	args->size = args->pitch * args->height;
	117
	118	mtk_gem = mtk_drm_gem_create(dev, args->size, false);
	119	if (IS_ERR(mtk_gem))
	120	return PTR_ERR(mtk_gem);
	121
	122	/*
	123	* allocate a id of idr table where the obj is registered
	124	* and handle has the id what user can see.
	125	*/
	126	ret = drm_gem_handle_create(file_priv, &mtk_gem->base, &args->handle);
	127	if (ret)
	128	goto err_handle_create;
	129
	130	/* drop reference from allocate - handle holds it now. */
556372df	131	drm_gem_object_put(&mtk_gem->base);
119f5173 CH	132
	133	return 0;
	134
	135	err_handle_create:
	136	mtk_drm_gem_free_object(&mtk_gem->base);
	137	return ret;
	138	}
	139
119f5173 CH	140	static int mtk_drm_gem_object_mmap(struct drm_gem_object *obj,
	141	struct vm_area_struct *vma)
	142
	143	{
	144	int ret;
	145	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
	146	struct mtk_drm_private *priv = obj->dev->dev_private;
	147
	148	/*
	149	* dma_alloc_attrs() allocated a struct page table for mtk_gem, so clear
	150	* VM_PFNMAP flag that was set by drm_gem_mmap_obj()/drm_gem_mmap().
	151	*/
	152	vma->vm_flags &= ~VM_PFNMAP;
119f5173 CH	153
119f5173 CH	154	ret = dma_mmap_attrs(priv->dma_dev, vma, mtk_gem->cookie,
00085f1e	155	mtk_gem->dma_addr, obj->size, mtk_gem->dma_attrs);
119f5173 CH	156	if (ret)
	157	drm_gem_vm_close(vma);
	158
	159	return ret;
	160	}
	161
	162	int mtk_drm_gem_mmap_buf(struct drm_gem_object obj, struct vm_area_struct vma)
	163	{
	164	int ret;
	165
	166	ret = drm_gem_mmap_obj(obj, obj->size, vma);
	167	if (ret)
	168	return ret;
	169
	170	return mtk_drm_gem_object_mmap(obj, vma);
	171	}
	172
	173	int mtk_drm_gem_mmap(struct file filp, struct vm_area_struct vma)
	174	{
	175	struct drm_gem_object *obj;
	176	int ret;
	177
	178	ret = drm_gem_mmap(filp, vma);
	179	if (ret)
	180	return ret;
	181
	182	obj = vma->vm_private_data;
	183
46a3b9fc YN	184	/*
	185	* Set vm_pgoff (used as a fake buffer offset by DRM) to 0 and map the
	186	* whole buffer from the start.
	187	*/
	188	vma->vm_pgoff = 0;
	189
119f5173 CH	190	return mtk_drm_gem_object_mmap(obj, vma);
	191	}
	192
	193	/*
	194	* Allocate a sg_table for this GEM object.
	195	* Note: Both the table's contents, and the sg_table itself must be freed by
	196	* the caller.
	197	* Returns a pointer to the newly allocated sg_table, or an ERR_PTR() error.
	198	*/
	199	struct sg_table mtk_gem_prime_get_sg_table(struct drm_gem_object obj)
	200	{
	201	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
	202	struct mtk_drm_private *priv = obj->dev->dev_private;
	203	struct sg_table *sgt;
	204	int ret;
	205
	206	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
	207	if (!sgt)
	208	return ERR_PTR(-ENOMEM);
	209
	210	ret = dma_get_sgtable_attrs(priv->dma_dev, sgt, mtk_gem->cookie,
	211	mtk_gem->dma_addr, obj->size,
00085f1e	212	mtk_gem->dma_attrs);
119f5173 CH	213	if (ret) {
	214	DRM_ERROR("failed to allocate sgt, %d\n", ret);
	215	kfree(sgt);
	216	return ERR_PTR(ret);
	217	}
	218
	219	return sgt;
	220	}
	221
	222	struct drm_gem_object mtk_gem_prime_import_sg_table(struct drm_device dev,
	223	struct dma_buf_attachment attach, struct sg_table sg)
	224	{
	225	struct mtk_drm_gem_obj *mtk_gem;
119f5173	226
960db7fc MS	227	/* check if the entries in the sg_table are contiguous */
	228	if (drm_prime_get_contiguous_size(sg) < attach->dmabuf->size) {
	229	DRM_ERROR("sg_table is not contiguous");
	230	return ERR_PTR(-EINVAL);
	231	}
119f5173	232
960db7fc	233	mtk_gem = mtk_drm_gem_init(dev, attach->dmabuf->size);
119f5173	234	if (IS_ERR(mtk_gem))
1e109115	235	return ERR_CAST(mtk_gem);
119f5173	236
119f5173 CH	237	mtk_gem->dma_addr = sg_dma_address(sg->sgl);
	238	mtk_gem->sg = sg;
	239
	240	return &mtk_gem->base;
119f5173	241	}
3df64d7b	242
7e542ff8	243	int mtk_drm_gem_prime_vmap(struct drm_gem_object obj, struct dma_buf_map map)
3df64d7b CH	244	{
3df64d7b CH	245	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
7e542ff8	246	struct sg_table *sgt = NULL;
3df64d7b	247	unsigned int npages;
3df64d7b CH	248
3df64d7b CH	249	if (mtk_gem->kvaddr)
7e542ff8	250	goto out;
3df64d7b CH	251
	252	sgt = mtk_gem_prime_get_sg_table(obj);
	253	if (IS_ERR(sgt))
7e542ff8	254	return PTR_ERR(sgt);
3df64d7b CH	255
	256	npages = obj->size >> PAGE_SHIFT;
	257	mtk_gem->pages = kcalloc(npages, sizeof(*mtk_gem->pages), GFP_KERNEL);
7e542ff8 TZ	258	if (!mtk_gem->pages) {
	259	kfree(sgt);
	260	return -ENOMEM;
	261	}
3df64d7b	262
90dcf444 MS	263	drm_prime_sg_to_page_addr_arrays(sgt, mtk_gem->pages, NULL, npages);
90dcf444 MS	264
3df64d7b CH	265	mtk_gem->kvaddr = vmap(mtk_gem->pages, npages, VM_MAP,
	266	pgprot_writecombine(PAGE_KERNEL));
	267
	268	out:
2ec35bd2	269	kfree(sgt);
7e542ff8	270	dma_buf_map_set_vaddr(map, mtk_gem->kvaddr);
3df64d7b	271
7e542ff8	272	return 0;
3df64d7b CH	273	}
3df64d7b CH	274
7e542ff8	275	void mtk_drm_gem_prime_vunmap(struct drm_gem_object obj, struct dma_buf_map map)
3df64d7b CH	276	{
3df64d7b CH	277	struct mtk_drm_gem_obj *mtk_gem = to_mtk_gem_obj(obj);
7e542ff8	278	void *vaddr = map->vaddr;
3df64d7b CH	279
	280	if (!mtk_gem->pages)
	281	return;
	282
	283	vunmap(vaddr);
	284	mtk_gem->kvaddr = 0;
2ec35bd2	285	kfree(mtk_gem->pages);
3df64d7b	286	}