ret in dma_direct_alloc() and dma_direct_alloc_pages() holds the returned
CPU mapping, not a generic return value. Rename it to cpu_addr and update
the remaining uses to match.

This makes the allocation paths easier to follow and keeps the local naming
consistent with what the variable actually represents.

Tested-by: Michael Kelley <[email protected]>
Tested-by: Mostafa Saleh <[email protected]>
Reviewed-by: Petr Tesarik <[email protected]>
Signed-off-by: Aneesh Kumar K.V (Arm) <[email protected]>
---
 kernel/dma/direct.c | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/kernel/dma/direct.c b/kernel/dma/direct.c
index 23138519cf22..9575d68571bf 100644
--- a/kernel/dma/direct.c
+++ b/kernel/dma/direct.c
@@ -204,7 +204,7 @@ void *dma_direct_alloc(struct device *dev, size_t size,
        bool mark_mem_decrypt = false;
        bool allow_highmem = true;
        struct page *page;
-       void *ret;
+       void *cpu_addr;
 
        if (force_dma_unencrypted(dev))
                attrs |= __DMA_ATTR_ALLOC_CC_SHARED;
@@ -261,9 +261,10 @@ void *dma_direct_alloc(struct device *dev, size_t size,
         */
        if ((remap || (attrs & __DMA_ATTR_ALLOC_CC_SHARED)) &&
            dma_direct_use_pool(dev, gfp)) {
-               page = dma_direct_alloc_from_pool(dev, size, dma_handle,
-                                                 &ret, gfp, attrs);
-               return page ? ret : NULL;
+               page = dma_direct_alloc_from_pool(dev, size,
+                                       dma_handle, &cpu_addr,
+                                       gfp, attrs);
+               return page ? cpu_addr : NULL;
        }
 
        if (is_swiotlb_for_alloc(dev)) {
@@ -310,34 +311,33 @@ void *dma_direct_alloc(struct device *dev, size_t size,
                arch_dma_prep_coherent(page, size);
 
                /* create a coherent mapping */
-               ret = dma_common_contiguous_remap(page, size, prot,
-                               __builtin_return_address(0));
-               if (!ret)
+               cpu_addr = dma_common_contiguous_remap(page, size, prot,
+                                       __builtin_return_address(0));
+               if (!cpu_addr)
                        goto out_encrypt_pages;
        } else {
-               ret = page_address(page);
+               cpu_addr = page_address(page);
        }
 
-       memset(ret, 0, size);
+       memset(cpu_addr, 0, size);
 
        if (set_uncached) {
                void *uncached_cpu_addr;
 
                arch_dma_prep_coherent(page, size);
-               uncached_cpu_addr = arch_dma_set_uncached(ret, size);
+               uncached_cpu_addr = arch_dma_set_uncached(cpu_addr, size);
                if (IS_ERR(uncached_cpu_addr))
                        goto out_free_remap_pages;
-               ret = uncached_cpu_addr;
+               cpu_addr = uncached_cpu_addr;
        }
 
        *dma_handle = phys_to_dma_direct(dev, page_to_phys(page),
                                         !!(attrs & 
__DMA_ATTR_ALLOC_CC_SHARED));
-       return ret;
-
+       return cpu_addr;
 
 out_free_remap_pages:
        if (remap)
-               dma_common_free_remap(ret, size);
+               dma_common_free_remap(cpu_addr, size);
 
 out_encrypt_pages:
        if (mark_mem_decrypt &&
@@ -429,21 +429,21 @@ struct page *dma_direct_alloc_pages(struct device *dev, 
size_t size,
 {
        unsigned long attrs = 0;
        struct page *page;
-       void *ret;
+       void *cpu_addr;
 
        if (force_dma_unencrypted(dev))
                attrs |= __DMA_ATTR_ALLOC_CC_SHARED;
 
        if ((attrs & __DMA_ATTR_ALLOC_CC_SHARED) && dma_direct_use_pool(dev, 
gfp))
                return dma_direct_alloc_from_pool(dev, size, dma_handle,
-                                                 &ret, gfp, attrs);
+                                                 &cpu_addr, gfp, attrs);
 
        if (is_swiotlb_for_alloc(dev)) {
                page = dma_direct_alloc_swiotlb(dev, size, attrs);
                if (!page)
                        return NULL;
 
-               ret = page_address(page);
+               cpu_addr = page_address(page);
                goto setup_page;
        }
 
@@ -451,12 +451,12 @@ struct page *dma_direct_alloc_pages(struct device *dev, 
size_t size,
        if (!page)
                return NULL;
 
-       ret = page_address(page);
+       cpu_addr = page_address(page);
        if ((attrs & __DMA_ATTR_ALLOC_CC_SHARED) &&
-           dma_set_decrypted(dev, ret, size))
+           dma_set_decrypted(dev, cpu_addr, size))
                goto out_leak_pages;
 setup_page:
-       memset(ret, 0, size);
+       memset(cpu_addr, 0, size);
        *dma_handle = phys_to_dma_direct(dev, page_to_phys(page),
                                         !!(attrs & 
__DMA_ATTR_ALLOC_CC_SHARED));
        return page;
-- 
2.43.0


Reply via email to