Remove dependency on dmac_flush/inv/clean_range

The driver cache ops routine uses `dmac_{flush,inv,clean}_range`
functions which are no longer exported since k4.3. In its place
cache operations are performed on individual pages by doing
page table walk for the supplied addresses. The functions are
placed in the platform specific files in the driver.

Signed-off-by: Gowtham Tammana <g-tammana@ti.com>

2 files changed, 269 insertions, 10 deletions

diff --git a/src/hal/os/linux/kernel/gc_hal_kernel_os.c b/src/hal/os/linux/kernel/gc_hal_kernel_os.c
index 354a272..546a188 100755
--- a/src/hal/os/linux/kernel/gc_hal_kernel_os.c
+++ b/src/hal/os/linux/kernel/gc_hal_kernel_os.c
@@ -5511,13 +5511,11 @@ gckOS_CacheClean(
         return gcvSTATUS_OK;
     }
 
-    /* @tga dmac_map_area is not exported starting from k4.3
-     * using arm_dma_ops ops. Ideally place this in platform
-     * specific function above.
+    /* the below is not valid for >k4.3, handling this in platform
+     * cache op
      */
-    arm_dma_ops.sync_single_for_device(gcvNULL,
-            (dma_addr_t)Physical, Bytes, DMA_TO_DEVICE);
 #if 0
+
 #if !gcdCACHE_FUNCTION_UNIMPLEMENTED
 #ifdef CONFIG_ARM
 
@@ -5553,6 +5551,7 @@ gckOS_CacheClean(
               DMA_TO_DEVICE);
 #endif
 #endif
+
 #endif
 
     /* Success. */
@@ -5623,13 +5622,11 @@ gckOS_CacheInvalidate(
         return gcvSTATUS_OK;
     }
 
-    /* @tga `dmac_map_area` function/macro is no longer exported starting
-     * from k4.3. Using dma mappings API ops instead, ideally these need
-     * to go inside platform specific ops above. TODO
+    /* the below is not valid for >k4.3, handling this in platform
+     * cache op
      */
-    arm_dma_ops.sync_single_for_cpu(gcvNULL,
-            (dma_addr_t)Physical, Bytes, DMA_FROM_DEVICE);
 #if 0
+
 #if !gcdCACHE_FUNCTION_UNIMPLEMENTED
 #ifdef CONFIG_ARM
 
@@ -5661,6 +5658,7 @@ gckOS_CacheInvalidate(
               DMA_FROM_DEVICE);
 #endif
 #endif
+
 #endif
 
     /* Success. */
@@ -5731,6 +5729,11 @@ gckOS_CacheFlush(
         return gcvSTATUS_OK;
     }
 
+    /* the below is not valid for >k4.3, handling this in platform
+     * cache op
+     */
+#if 0
+
 #if !gcdCACHE_FUNCTION_UNIMPLEMENTED
 #ifdef CONFIG_ARM
     /* Inner cache. */
@@ -5758,6 +5761,8 @@ gckOS_CacheFlush(
 #endif
 #endif
 
+#endif
+
     /* Success. */
     gcmkFOOTER_NO();
     return gcvSTATUS_OK;
diff --git a/src/hal/os/linux/kernel/platform/ti/gc_hal_kernel_platform_j6.c b/src/hal/os/linux/kernel/platform/ti/gc_hal_kernel_platform_j6.c
index e760bb6..87727fe 100755
--- a/src/hal/os/linux/kernel/platform/ti/gc_hal_kernel_platform_j6.c
+++ b/src/hal/os/linux/kernel/platform/ti/gc_hal_kernel_platform_j6.c
@@ -61,6 +61,10 @@
 #include <linux/io.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <asm/cacheflush.h>
+#include <linux/slab.h>
+#include <linux/pagemap.h>
+#include <linux/highmem.h>
 
 /*
  * GC320 platform data struct, using the definition as in
@@ -235,6 +239,255 @@ _AdjustParam(
     return gcvSTATUS_TRUE;
 }
 
+static gceSTATUS
+cache_op_on_page(struct page *page, enum dma_data_direction dir)
+{
+    if (!PageHighMem(page) && page_to_phys(page)) {
+        dma_sync_single_for_device(gcvNULL,
+                page_to_phys(page),
+                PAGE_SIZE,
+                dir);
+    } else {
+        flush_dcache_page(page);
+    }
+
+    return gcvSTATUS_OK;
+}
+
+static gceSTATUS
+cache_op_on_mdl(PLINUX_MDL mdl, enum dma_data_direction dir)
+{
+    gceSTATUS status = gcvSTATUS_OK;
+    uint32_t i = 0;
+    uint32_t numPages = mdl->numPages;
+
+    for (i = 0; i < numPages; i++) {
+        struct page *page;
+
+        if (mdl->contiguous) {
+            page = nth_page(mdl->u.contiguousPages, i);
+        } else {
+            page = mdl->u.nonContiguousPages[i];
+        }
+
+        status = cache_op_on_page(page, dir);
+    }
+    return status;
+}
+
+static gceSTATUS
+logical_to_page(gctUINTPTR_T logical, struct page **page)
+{
+    gceSTATUS status = gcvSTATUS_OK;
+    pgd_t *pgd;
+    pmd_t *pmd;
+    pud_t *pud;
+    pte_t *pte;
+    spinlock_t *ptl;
+
+    pgd = pgd_offset(current->mm, logical);
+    if (pgd_none(*pgd) || pgd_bad(*pgd)) {
+        gckOS_DebugTrace(gcvLEVEL_ERROR, "Invalid pgd entry\n");
+        gcmkONERROR(gcvSTATUS_INVALID_ADDRESS);
+    }
+
+    pud = pud_offset(pgd, logical);
+    if (pud_none(*pud) || pud_bad(*pud)) {
+        gckOS_DebugTrace(gcvLEVEL_ERROR, "Invalid pud entry\n");
+        gcmkONERROR(gcvSTATUS_INVALID_ADDRESS);
+    }
+
+    pmd = pmd_offset(pud, logical);
+    if (pmd_none(*pmd) || pmd_bad(*pmd)) {
+        gckOS_DebugTrace(gcvLEVEL_ERROR, "Invalid pmd entry\n");
+        gcmkONERROR(gcvSTATUS_INVALID_ADDRESS);
+    }
+
+    pte = pte_offset_map_lock(current->mm, pmd, logical, &ptl);
+    if (pte_none(*pte) || !pte_present(*pte) || !pte_write(*pte)) {
+            status = gcvSTATUS_INVALID_ADDRESS;
+            goto UnLock;
+    }
+    *page = pte_page(*pte);
+
+UnLock:
+    pte_unmap_unlock(pte, ptl);
+OnError:
+    return status;
+}
+
+static gceSTATUS
+cache_op_on_logical(gctPOINTER logical, gctSIZE_T bytes,
+        enum dma_data_direction dir)
+{
+    gceSTATUS status = gcvSTATUS_OK;
+    gctUINTPTR_T startAddr, endAddr;
+    gctUINTPTR_T startAddrAligned, endAddrAligned;
+    gctSIZE_T pageCount;
+    struct page **pages;
+    int numPagesMapped;
+    int i;
+
+    startAddr = (gctUINTPTR_T)logical;
+    endAddr = startAddr + bytes;
+
+    startAddrAligned = startAddr & PAGE_MASK;
+    endAddrAligned = PAGE_ALIGN(endAddr);
+    pageCount = (endAddrAligned - startAddrAligned) >> PAGE_SHIFT;
+
+    pages = kmalloc(pageCount * sizeof(struct page *), GFP_KERNEL);
+    if (!pages) {
+        status = gcvSTATUS_OUT_OF_MEMORY;
+        goto OnError;
+    }
+    memset(pages, 0, sizeof(struct page *) * pageCount);
+
+    /* lock down user memory */
+    down_read(&current->mm->mmap_sem);
+
+    numPagesMapped = get_user_pages(current, current->mm,
+            startAddr, pageCount, 1, 0, pages, gcvNULL);
+
+    if (numPagesMapped == pageCount) {
+        for (i = 0; i < pageCount; i++) {
+            status = cache_op_on_page(pages[i], dir);
+        }
+    } else {
+        struct vm_area_struct *vma;
+
+        /* get_user_pages didnt work, release the pages if any and look for
+         * the pages in the appropriate memory region of the process. Region
+         * might correspond to memory mapped I/O.
+         */
+        gckOS_DebugTrace(gcvLEVEL_INFO,
+                "get_user_pages failed (%d/%d pages), trying to acquire from CPU page table\n",
+                numPagesMapped, pageCount);
+        if (numPagesMapped > 0) {
+            for (i = 0; i < numPagesMapped; i++) {
+                if (pages[i] == gcvNULL)
+                    break;
+
+                page_cache_release(pages[i]);
+                pages[i] = gcvNULL;
+            }
+            numPagesMapped = 0;
+        }
+
+        vma = find_vma(current->mm, startAddr);
+        if (!vma) {
+            gckOS_DebugTrace(gcvLEVEL_ERROR,
+                    "%s: find_vma returned error for start address 0x%lx\n",
+                    startAddr);
+            status = gcvSTATUS_INVALID_ADDRESS;
+            goto OnExit;
+        }
+
+        /* find_vma locates a region with an end point past a given virtual
+         * address, check if the address is within in the region
+         */
+        if (startAddr < vma->vm_start) {
+            gckOS_DebugTrace(gcvLEVEL_ERROR,
+                    "start address 0x%lx is outside the returned vma region\n",
+                    startAddr);
+            goto OnExit;
+        }
+        if (endAddr > vma->vm_end) {
+            gckOS_DebugTrace(gcvLEVEL_ERROR,
+                    "end address 0x%lx is outside the returned vma region\n",
+                    endAddr);
+            goto OnExit;
+        }
+        if (!(vma->vm_flags & VM_IO) || !(vma->vm_flags & VM_PFNMAP)) {
+            gckOS_DebugTrace(gcvLEVEL_ERROR,
+                    "Memory region does not represent IO || PFNMAP region (VMA flags 0x%lx)\n",
+                    vma->vm_flags);
+            goto OnExit;
+        }
+        if ((vma->vm_flags & (VM_READ | VM_WRITE)) != (VM_READ | VM_WRITE)) {
+            gckOS_DebugTrace(gcvLEVEL_ERROR,
+                    "No read/write access to memory region (VMA flags 0x%lx\n",
+                    vma->vm_flags);
+            goto OnExit;
+        }
+
+        for (i = 0; i < pageCount; i++) {
+            gctUINTPTR_T logical = startAddr;
+
+            status = logical_to_page(logical, &pages[i]);
+            if (status)
+                goto OnExit;
+            status = cache_op_on_page(pages[i], dir);
+            if (status)
+                goto OnExit;
+
+            logical += PAGE_SIZE;
+        }
+    }
+
+OnExit:
+    up_read(&current->mm->mmap_sem);
+
+    kfree(pages);
+
+OnError:
+    return status;
+}
+
+/*
+ * cache ops: The driver is using the old `dmac_{flush,clean,inv}_range` API
+ * for doing cache ops. This API is no longer available since k4.3 and needed
+ * to be updated. Performing cache ops on individual pages here in the platform
+ * op. This could have resided in the driver as well as no platform specific
+ * changes are in here.
+ */
+static gceSTATUS
+platform_cache(
+        IN gckPLATFORM Platform,
+        IN gctUINT32 ProcessID,
+        IN gctPHYS_ADDR Handle,
+        IN gctUINT32 Physical,
+        IN gctPOINTER Logical,
+        IN gctSIZE_T Bytes,
+        IN gceCACHEOPERATION Operation
+        )
+{
+    gceSTATUS status = gcvSTATUS_OK;
+    enum dma_data_direction dir;
+
+    switch (Operation) {
+    case gcvCACHE_FLUSH:
+        dir = DMA_BIDIRECTIONAL;
+        break;
+    case gcvCACHE_CLEAN:
+        dir = DMA_TO_DEVICE;
+        break;
+    case gcvCACHE_INVALIDATE:
+        dir = DMA_FROM_DEVICE;
+        break;
+    default:
+        return gcvSTATUS_INVALID_ARGUMENT;
+    }
+
+    /* have access to phys addr, use dma api */
+    if (Physical != gcvINVALID_ADDRESS) {
+        dma_sync_single_for_device(gcvNULL,
+                (dma_addr_t)Physical,
+                Bytes,
+                dir);
+    } else if (Handle != gcvNULL) {
+        /* only have access to unified driver `PLINUX_MDL` struct,
+         * query page list from this struct and perform cache ops
+         * on each page.
+         */
+        PLINUX_MDL mdl = (PLINUX_MDL)Handle;
+        status = cache_op_on_mdl(mdl, dir);
+    } else {
+        status = cache_op_on_logical(Logical, Bytes, dir);
+    }
+
+    return status;
+}
+
 gcsPLATFORM_OPERATIONS platformOperations =
 {
     .adjustParam   = _AdjustParam,
@@ -242,6 +495,7 @@ gcsPLATFORM_OPERATIONS platformOperations =
     .needAddDevice = _NeedAddDevice,
     .getPower      = _GetPower,
     .putPower      = _PutPower,
+    .cache         = platform_cache,
 };
 
 void