gpu: nvgpu: nvgpu SGL implementation

The last major item preventing the core MM code in the nvgpu
driver from being platform agnostic is the usage of Linux
scattergather tables and scattergather lists. These data
structures are used throughout the mapping code to handle
discontiguous DMA allocations and also overloaded to represent
VIDMEM allocs.

The notion of a scatter gather table is crucial to a HW device
that can handle discontiguous DMA. The GPU has a MMU which
allows the GPU to do page gathering and present a virtually
contiguous buffer to the GPU HW. As a result it makes sense
for the GPU driver to use some sort of scatter gather concept
so maximize memory usage efficiency.

To that end this patch keeps the notion of a scatter gather
list but implements it in the nvgpu common code. It is based
heavily on the Linux SGL concept. It is a singly linked list
of blocks - each representing a chunk of memory. To map or
use a DMA allocation SW must iterate over each block in the
SGL.

This patch implements the most basic level of support for this
data structure. There are certainly easy optimizations that
could be done to speed up the current implementation. However,
this patches' goal is to simply divest the core MM code from
any last Linux'isms. Speed and efficiency come next.

Change-Id: Icf44641db22d87fa1d003debbd9f71b605258e42
Signed-off-by: Alex Waterman <alexw@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1530867
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>

2 files changed, 30 insertions, 29 deletions

diff --git a/drivers/gpu/nvgpu/vgpu/gp10b/vgpu_mm_gp10b.c b/drivers/gpu/nvgpu/vgpu/gp10b/vgpu_mm_gp10b.c
index 85c436e5..ee9b791a 100644
--- a/drivers/gpu/nvgpu/vgpu/gp10b/vgpu_mm_gp10b.c
+++ b/drivers/gpu/nvgpu/vgpu/gp10b/vgpu_mm_gp10b.c
@@ -13,7 +13,6 @@
  * more details.
  */
 
-#include <linux/dma-mapping.h>
 #include "vgpu/vgpu.h"
 #include "vgpu_mm_gp10b.h"
 #include "gk20a/mm_gk20a.h"
@@ -41,7 +40,7 @@ static inline int add_mem_desc(struct tegra_vgpu_mem_desc *mem_desc,
 
 static u64 vgpu_gp10b_locked_gmmu_map(struct vm_gk20a *vm,
                                 u64 map_offset,
-                                struct sg_table *sgt,
+                                struct nvgpu_mem_sgl *sgl,
                                 u64 buffer_offset,
                                 u64 size,
                                 int pgsz_idx,
@@ -61,10 +60,9 @@ static u64 vgpu_gp10b_locked_gmmu_map(struct vm_gk20a *vm,
         struct tegra_vgpu_as_map_ex_params *p = &msg.params.as_map_ex;
         struct tegra_vgpu_mem_desc *mem_desc;
         u32 page_size  = vm->gmmu_page_sizes[pgsz_idx];
+        u64 buffer_size = PAGE_ALIGN(size);
         u64 space_to_skip = buffer_offset;
-        u64 buffer_size = 0;
         u32 mem_desc_count = 0, i;
-        struct scatterlist *sgl;
         void *handle = NULL;
         size_t oob_size;
         u8 prot;
@@ -73,7 +71,7 @@ static u64 vgpu_gp10b_locked_gmmu_map(struct vm_gk20a *vm,
 
         /* FIXME: add support for sparse mappings */
 
-        if (WARN_ON(!sgt) || WARN_ON(!g->mm.bypass_smmu))
+        if (WARN_ON(!sgl) || WARN_ON(!g->mm.bypass_smmu))
                 return 0;
 
         if (space_to_skip & (page_size - 1))
@@ -100,33 +98,36 @@ static u64 vgpu_gp10b_locked_gmmu_map(struct vm_gk20a *vm,
                 goto fail;
         }
 
-        sgl = sgt->sgl;
-        while (space_to_skip && sgl &&
-                (space_to_skip + page_size > sgl->length)) {
-                space_to_skip -= sgl->length;
-                sgl = sg_next(sgl);
-        }
-        WARN_ON(!sgl);
+        while (sgl) {
+                u64 phys_addr;
+                u64 chunk_length;
+
+                /*
+                 * Cut out sgl ents for space_to_skip.
+                 */
+                if (space_to_skip &&
+                    space_to_skip >= nvgpu_mem_sgl_length(sgl)) {
+                        space_to_skip -= nvgpu_mem_sgl_length(sgl);
+                        sgl = nvgpu_mem_sgl_next(sgl);
+                        continue;
+                }
 
-        if (add_mem_desc(&mem_desc[mem_desc_count++],
-                        sg_phys(sgl) + space_to_skip,
-                        sgl->length - space_to_skip,
-                        &oob_size)) {
-                err = -ENOMEM;
-                goto fail;
-        }
-        buffer_size += sgl->length - space_to_skip;
+                phys_addr = nvgpu_mem_sgl_phys(sgl) + space_to_skip;
+                chunk_length = min(size,
+                                   nvgpu_mem_sgl_length(sgl) - space_to_skip);
 
-        sgl = sg_next(sgl);
-        while (sgl && buffer_size < size) {
-                if (add_mem_desc(&mem_desc[mem_desc_count++], sg_phys(sgl),
-                                sgl->length, &oob_size)) {
+                if (add_mem_desc(&mem_desc[mem_desc_count++], phys_addr,
+                                 chunk_length, &oob_size)) {
                         err = -ENOMEM;
                         goto fail;
                 }
 
-                buffer_size += sgl->length;
-                sgl = sg_next(sgl);
+                space_to_skip = 0;
+                size -= chunk_length;
+                sgl   = nvgpu_mem_sgl_next(sgl);
+
+                if (size == 0)
+                        break;
         }
 
         if (rw_flag == gk20a_mem_flag_read_only)
@@ -153,7 +154,7 @@ static u64 vgpu_gp10b_locked_gmmu_map(struct vm_gk20a *vm,
         msg.handle = vgpu_get_handle(g);
         p->handle = vm->handle;
         p->gpu_va = map_offset;
-        p->size = size;
+        p->size = buffer_size;
         p->mem_desc_count = mem_desc_count;
         p->pgsz_idx = pgsz_idx;
         p->iova = 0;
diff --git a/drivers/gpu/nvgpu/vgpu/mm_vgpu.c b/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
index ef9e00c8..5da6f158 100644
--- a/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
+++ b/drivers/gpu/nvgpu/vgpu/mm_vgpu.c
@@ -78,7 +78,7 @@ int vgpu_init_mm_support(struct gk20a *g)
 
 static u64 vgpu_locked_gmmu_map(struct vm_gk20a *vm,
                                 u64 map_offset,
-                                struct sg_table *sgt,
+                                struct nvgpu_mem_sgl *sgl,
                                 u64 buffer_offset,
                                 u64 size,
                                 int pgsz_idx,
@@ -98,7 +98,7 @@ static u64 vgpu_locked_gmmu_map(struct vm_gk20a *vm,
         struct dma_iommu_mapping *mapping = to_dma_iommu_mapping(d);
         struct tegra_vgpu_cmd_msg msg;
         struct tegra_vgpu_as_map_params *p = &msg.params.as_map;
-        u64 addr = nvgpu_mem_get_addr_sgl(g, sgt->sgl);
+        u64 addr = nvgpu_mem_sgl_gpu_addr(g, sgl, NULL);
         u8 prot;
 
         gk20a_dbg_fn("");