forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-11 223293205a7265c8b02882461ba8996650048ade 
 kernel/drivers/gpu/drm/exynos/exynos_drm_gem.c
....@@ -1,40 +1,31 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12 /* exynos_drm_gem.c
23  *
34  * Copyright (c) 2011 Samsung Electronics Co., Ltd.
45  * Author: Inki Dae <inki.dae@samsung.com>
5
- *
6
- * This program is free software; you can redistribute  it and/or modify it
7
- * under  the terms of  the GNU General  Public License as published by the
8
- * Free Software Foundation;  either version 2 of the  License, or (at your
9
- * option) any later version.
106  */
117 
12
-#include <drm/drmP.h>
13
-#include <drm/drm_vma_manager.h>
148 
15
-#include <linux/shmem_fs.h>
169 #include <linux/dma-buf.h>
1710 #include <linux/pfn_t.h>
11
+#include <linux/shmem_fs.h>
12
+
13
+#include <drm/drm_prime.h>
14
+#include <drm/drm_vma_manager.h>
1815 #include <drm/exynos_drm.h>
1916 
2017 #include "exynos_drm_drv.h"
2118 #include "exynos_drm_gem.h"
22
-#include "exynos_drm_iommu.h"
2319 
24
-static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem)
20
+static int exynos_drm_alloc_buf(struct exynos_drm_gem *exynos_gem, bool kvmap)
2521 {
2622 	struct drm_device *dev = exynos_gem->base.dev;
27
-	unsigned long attr;
28
-	unsigned int nr_pages;
29
-	struct sg_table sgt;
30
-	int ret = -ENOMEM;
23
+	unsigned long attr = 0;
3124 
3225 	if (exynos_gem->dma_addr) {
33
-		DRM_DEBUG_KMS("already allocated.\n");
26
+		DRM_DEV_DEBUG_KMS(to_dma_dev(dev), "already allocated.\n");
3427 		return 0;
3528 	}
36
-
37
-	exynos_gem->dma_attrs = 0;
3829 
3930 	/*
4031 	 * if EXYNOS_BO_CONTIG, fully physically contiguous memory
....@@ -42,7 +33,7 @@
4233 	 * as possible.
4334 	 */
4435 	if (!(exynos_gem->flags & EXYNOS_BO_NONCONTIG))
45
-		exynos_gem->dma_attrs |= DMA_ATTR_FORCE_CONTIGUOUS;
36
+		attr |= DMA_ATTR_FORCE_CONTIGUOUS;
4637 
4738 	/*
4839 	 * if EXYNOS_BO_WC or EXYNOS_BO_NONCACHABLE, writecombine mapping
....@@ -50,61 +41,27 @@
5041 	 */
5142 	if (exynos_gem->flags & EXYNOS_BO_WC ||
5243 			!(exynos_gem->flags & EXYNOS_BO_CACHABLE))
53
-		attr = DMA_ATTR_WRITE_COMBINE;
54
-	else
55
-		attr = DMA_ATTR_NON_CONSISTENT;
44
+		attr |= DMA_ATTR_WRITE_COMBINE;
5645 
57
-	exynos_gem->dma_attrs |= attr;
58
-	exynos_gem->dma_attrs |= DMA_ATTR_NO_KERNEL_MAPPING;
46
+	/* FBDev emulation requires kernel mapping */
47
+	if (!kvmap)
48
+		attr |= DMA_ATTR_NO_KERNEL_MAPPING;
5949 
60
-	nr_pages = exynos_gem->size >> PAGE_SHIFT;
61
-
62
-	exynos_gem->pages = kvmalloc_array(nr_pages, sizeof(struct page *),
63
-			GFP_KERNEL | __GFP_ZERO);
64
-	if (!exynos_gem->pages) {
65
-		DRM_ERROR("failed to allocate pages.\n");
66
-		return -ENOMEM;
67
-	}
68
-
50
+	exynos_gem->dma_attrs = attr;
6951 	exynos_gem->cookie = dma_alloc_attrs(to_dma_dev(dev), exynos_gem->size,
7052 					     &exynos_gem->dma_addr, GFP_KERNEL,
7153 					     exynos_gem->dma_attrs);
7254 	if (!exynos_gem->cookie) {
73
-		DRM_ERROR("failed to allocate buffer.\n");
74
-		goto err_free;
55
+		DRM_DEV_ERROR(to_dma_dev(dev), "failed to allocate buffer.\n");
56
+		return -ENOMEM;
7557 	}
7658 
77
-	ret = dma_get_sgtable_attrs(to_dma_dev(dev), &sgt, exynos_gem->cookie,
78
-				    exynos_gem->dma_addr, exynos_gem->size,
79
-				    exynos_gem->dma_attrs);
80
-	if (ret < 0) {
81
-		DRM_ERROR("failed to get sgtable.\n");
82
-		goto err_dma_free;
83
-	}
59
+	if (kvmap)
60
+		exynos_gem->kvaddr = exynos_gem->cookie;
8461 
85
-	if (drm_prime_sg_to_page_addr_arrays(&sgt, exynos_gem->pages, NULL,
86
-					     nr_pages)) {
87
-		DRM_ERROR("invalid sgtable.\n");
88
-		ret = -EINVAL;
89
-		goto err_sgt_free;
90
-	}
91
-
92
-	sg_free_table(&sgt);
93
-
94
-	DRM_DEBUG_KMS("dma_addr(0x%lx), size(0x%lx)\n",
62
+	DRM_DEV_DEBUG_KMS(to_dma_dev(dev), "dma_addr(0x%lx), size(0x%lx)\n",
9563 			(unsigned long)exynos_gem->dma_addr, exynos_gem->size);
96
-
9764 	return 0;
98
-
99
-err_sgt_free:
100
-	sg_free_table(&sgt);
101
-err_dma_free:
102
-	dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie,
103
-		       exynos_gem->dma_addr, exynos_gem->dma_attrs);
104
-err_free:
105
-	kvfree(exynos_gem->pages);
106
-
107
-	return ret;
10865 }
10966 
11067 static void exynos_drm_free_buf(struct exynos_drm_gem *exynos_gem)
....@@ -112,18 +69,16 @@
11269 	struct drm_device *dev = exynos_gem->base.dev;
11370 
11471 	if (!exynos_gem->dma_addr) {
115
-		DRM_DEBUG_KMS("dma_addr is invalid.\n");
72
+		DRM_DEV_DEBUG_KMS(dev->dev, "dma_addr is invalid.\n");
11673 		return;
11774 	}
11875 
119
-	DRM_DEBUG_KMS("dma_addr(0x%lx), size(0x%lx)\n",
76
+	DRM_DEV_DEBUG_KMS(dev->dev, "dma_addr(0x%lx), size(0x%lx)\n",
12077 			(unsigned long)exynos_gem->dma_addr, exynos_gem->size);
12178 
12279 	dma_free_attrs(to_dma_dev(dev), exynos_gem->size, exynos_gem->cookie,
12380 			(dma_addr_t)exynos_gem->dma_addr,
12481 			exynos_gem->dma_attrs);
125
-
126
-	kvfree(exynos_gem->pages);
12782 }
12883 
12984 static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
....@@ -140,10 +95,10 @@
14095 	if (ret)
14196 		return ret;
14297 
143
-	DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);
98
+	DRM_DEV_DEBUG_KMS(to_dma_dev(obj->dev), "gem handle = 0x%x\n", *handle);
14499 
145100 	/* drop reference from allocate - handle holds it now. */
146
-	drm_gem_object_put_unlocked(obj);
101
+	drm_gem_object_put(obj);
147102 
148103 	return 0;
149104 }
....@@ -152,7 +107,8 @@
152107 {
153108 	struct drm_gem_object *obj = &exynos_gem->base;
154109 
155
-	DRM_DEBUG_KMS("handle count = %d\n", obj->handle_count);
110
+	DRM_DEV_DEBUG_KMS(to_dma_dev(obj->dev), "handle count = %d\n",
111
+			  obj->handle_count);
156112 
157113 	/*
158114 	 * do not release memory region from exporter.
....@@ -187,7 +143,7 @@
187143 
188144 	ret = drm_gem_object_init(dev, obj, size);
189145 	if (ret < 0) {
190
-		DRM_ERROR("failed to initialize gem object\n");
146
+		DRM_DEV_ERROR(dev->dev, "failed to initialize gem object\n");
191147 		kfree(exynos_gem);
192148 		return ERR_PTR(ret);
193149 	}
....@@ -199,25 +155,27 @@
199155 		return ERR_PTR(ret);
200156 	}
201157 
202
-	DRM_DEBUG_KMS("created file object = %pK\n", obj->filp);
158
+	DRM_DEV_DEBUG_KMS(dev->dev, "created file object = %pK\n", obj->filp);
203159 
204160 	return exynos_gem;
205161 }
206162 
207163 struct exynos_drm_gem *exynos_drm_gem_create(struct drm_device *dev,
208164 					     unsigned int flags,
209
-					     unsigned long size)
165
+					     unsigned long size,
166
+					     bool kvmap)
210167 {
211168 	struct exynos_drm_gem *exynos_gem;
212169 	int ret;
213170 
214171 	if (flags & ~(EXYNOS_BO_MASK)) {
215
-		DRM_ERROR("invalid GEM buffer flags: %u\n", flags);
172
+		DRM_DEV_ERROR(dev->dev,
173
+			      "invalid GEM buffer flags: %u\n", flags);
216174 		return ERR_PTR(-EINVAL);
217175 	}
218176 
219177 	if (!size) {
220
-		DRM_ERROR("invalid GEM buffer size: %lu\n", size);
178
+		DRM_DEV_ERROR(dev->dev, "invalid GEM buffer size: %lu\n", size);
221179 		return ERR_PTR(-EINVAL);
222180 	}
223181 
....@@ -239,7 +197,7 @@
239197 	/* set memory type and cache attribute from user side. */
240198 	exynos_gem->flags = flags;
241199 
242
-	ret = exynos_drm_alloc_buf(exynos_gem);
200
+	ret = exynos_drm_alloc_buf(exynos_gem, kvmap);
243201 	if (ret < 0) {
244202 		drm_gem_object_release(&exynos_gem->base);
245203 		kfree(exynos_gem);
....@@ -256,7 +214,7 @@
256214 	struct exynos_drm_gem *exynos_gem;
257215 	int ret;
258216 
259
-	exynos_gem = exynos_drm_gem_create(dev, args->flags, args->size);
217
+	exynos_gem = exynos_drm_gem_create(dev, args->flags, args->size, false);
260218 	if (IS_ERR(exynos_gem))
261219 		return PTR_ERR(exynos_gem);
262220 
....@@ -326,7 +284,7 @@
326284 
327285 	obj = drm_gem_object_lookup(file_priv, args->handle);
328286 	if (!obj) {
329
-		DRM_ERROR("failed to lookup gem object.\n");
287
+		DRM_DEV_ERROR(dev->dev, "failed to lookup gem object.\n");
330288 		return -EINVAL;
331289 	}
332290 
....@@ -335,7 +293,7 @@
335293 	args->flags = exynos_gem->flags;
336294 	args->size = exynos_gem->size;
337295 
338
-	drm_gem_object_put_unlocked(obj);
296
+	drm_gem_object_put(obj);
339297 
340298 	return 0;
341299 }
....@@ -367,7 +325,7 @@
367325 	else
368326 		flags = EXYNOS_BO_CONTIG | EXYNOS_BO_WC;
369327 
370
-	exynos_gem = exynos_drm_gem_create(dev, flags, args->size);
328
+	exynos_gem = exynos_drm_gem_create(dev, flags, args->size, false);
371329 	if (IS_ERR(exynos_gem)) {
372330 		dev_warn(dev->dev, "FB allocation failed.\n");
373331 		return PTR_ERR(exynos_gem);
....@@ -383,33 +341,14 @@
383341 	return 0;
384342 }
385343 
386
-vm_fault_t exynos_drm_gem_fault(struct vm_fault *vmf)
387
-{
388
-	struct vm_area_struct *vma = vmf->vma;
389
-	struct drm_gem_object *obj = vma->vm_private_data;
390
-	struct exynos_drm_gem *exynos_gem = to_exynos_gem(obj);
391
-	unsigned long pfn;
392
-	pgoff_t page_offset;
393
-
394
-	page_offset = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
395
-
396
-	if (page_offset >= (exynos_gem->size >> PAGE_SHIFT)) {
397
-		DRM_ERROR("invalid page offset\n");
398
-		return VM_FAULT_SIGBUS;
399
-	}
400
-
401
-	pfn = page_to_pfn(exynos_gem->pages[page_offset]);
402
-	return vmf_insert_mixed(vma, vmf->address,
403
-			__pfn_to_pfn_t(pfn, PFN_DEV));
404
-}
405
-
406344 static int exynos_drm_gem_mmap_obj(struct drm_gem_object *obj,
407345 				   struct vm_area_struct *vma)
408346 {
409347 	struct exynos_drm_gem *exynos_gem = to_exynos_gem(obj);
410348 	int ret;
411349 
412
-	DRM_DEBUG_KMS("flags = 0x%x\n", exynos_gem->flags);
350
+	DRM_DEV_DEBUG_KMS(to_dma_dev(obj->dev), "flags = 0x%x\n",
351
+			  exynos_gem->flags);
413352 
414353 	/* non-cachable as default. */
415354 	if (exynos_gem->flags & EXYNOS_BO_CACHABLE)
....@@ -463,11 +402,24 @@
463402 struct sg_table *exynos_drm_gem_prime_get_sg_table(struct drm_gem_object *obj)
464403 {
465404 	struct exynos_drm_gem *exynos_gem = to_exynos_gem(obj);
466
-	int npages;
405
+	struct drm_device *drm_dev = obj->dev;
406
+	struct sg_table *sgt;
407
+	int ret;
467408 
468
-	npages = exynos_gem->size >> PAGE_SHIFT;
409
+	sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
410
+	if (!sgt)
411
+		return ERR_PTR(-ENOMEM);
469412 
470
-	return drm_prime_pages_to_sg(exynos_gem->pages, npages);
413
+	ret = dma_get_sgtable_attrs(to_dma_dev(drm_dev), sgt, exynos_gem->cookie,
414
+				    exynos_gem->dma_addr, exynos_gem->size,
415
+				    exynos_gem->dma_attrs);
416
+	if (ret) {
417
+		DRM_ERROR("failed to get sgtable, %d\n", ret);
418
+		kfree(sgt);
419
+		return ERR_PTR(ret);
420
+	}
421
+
422
+	return sgt;
471423 }
472424 
473425 struct drm_gem_object *
....@@ -476,52 +428,30 @@
476428 				     struct sg_table *sgt)
477429 {
478430 	struct exynos_drm_gem *exynos_gem;
479
-	int npages;
480
-	int ret;
431
+
432
+	/* check if the entries in the sg_table are contiguous */
433
+	if (drm_prime_get_contiguous_size(sgt) < attach->dmabuf->size) {
434
+		DRM_ERROR("buffer chunks must be mapped contiguously");
435
+		return ERR_PTR(-EINVAL);
436
+	}
481437 
482438 	exynos_gem = exynos_drm_gem_init(dev, attach->dmabuf->size);
483
-	if (IS_ERR(exynos_gem)) {
484
-		ret = PTR_ERR(exynos_gem);
485
-		return ERR_PTR(ret);
486
-	}
439
+	if (IS_ERR(exynos_gem))
440
+		return ERR_CAST(exynos_gem);
441
+
442
+	/*
443
+	 * Buffer has been mapped as contiguous into DMA address space,
444
+	 * but if there is IOMMU, it can be either CONTIG or NONCONTIG.
445
+	 * We assume a simplified logic below:
446
+	 */
447
+	if (is_drm_iommu_supported(dev))
448
+		exynos_gem->flags |= EXYNOS_BO_NONCONTIG;
449
+	else
450
+		exynos_gem->flags |= EXYNOS_BO_CONTIG;
487451 
488452 	exynos_gem->dma_addr = sg_dma_address(sgt->sgl);
489
-
490
-	npages = exynos_gem->size >> PAGE_SHIFT;
491
-	exynos_gem->pages = kvmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
492
-	if (!exynos_gem->pages) {
493
-		ret = -ENOMEM;
494
-		goto err;
495
-	}
496
-
497
-	ret = drm_prime_sg_to_page_addr_arrays(sgt, exynos_gem->pages, NULL,
498
-					       npages);
499
-	if (ret < 0)
500
-		goto err_free_large;
501
-
502453 	exynos_gem->sgt = sgt;
503
-
504
-	if (sgt->nents == 1) {
505
-		/* always physically continuous memory if sgt->nents is 1. */
506
-		exynos_gem->flags |= EXYNOS_BO_CONTIG;
507
-	} else {
508
-		/*
509
-		 * this case could be CONTIG or NONCONTIG type but for now
510
-		 * sets NONCONTIG.
511
-		 * TODO. we have to find a way that exporter can notify
512
-		 * the type of its own buffer to importer.
513
-		 */
514
-		exynos_gem->flags |= EXYNOS_BO_NONCONTIG;
515
-	}
516
-
517454 	return &exynos_gem->base;
518
-
519
-err_free_large:
520
-	kvfree(exynos_gem->pages);
521
-err:
522
-	drm_gem_object_release(&exynos_gem->base);
523
-	kfree(exynos_gem);
524
-	return ERR_PTR(ret);
525455 }
526456 
527457 void *exynos_drm_gem_prime_vmap(struct drm_gem_object *obj)