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.

Signed-off-by: Aneesh Kumar K.V (Arm) <[email protected]>
---
 kernel/dma/direct.c | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/kernel/dma/direct.c b/kernel/dma/direct.c
index 1e9f9ff7b9d3..902008e40ea1 100644
--- a/kernel/dma/direct.c
+++ b/kernel/dma/direct.c
@@ -212,7 +212,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;
 
        /*
         * DMA_ATTR_CC_SHARED is not a caller-visible dma_alloc_*()
@@ -326,34 +326,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_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 &&
@@ -437,7 +436,7 @@ 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_CC_SHARED;
@@ -455,7 +454,7 @@ struct page *dma_direct_alloc_pages(struct device *dev, 
size_t size,
                        swiotlb_free(dev, page, size);
                        return NULL;
                }
-               ret = page_address(page);
+               cpu_addr = page_address(page);
                goto setup_page;
        }
 
@@ -463,11 +462,11 @@ struct page *dma_direct_alloc_pages(struct device *dev, 
size_t size,
        if (!page)
                return NULL;
 
-       ret = page_address(page);
-       if ((attrs & DMA_ATTR_CC_SHARED) && dma_set_decrypted(dev, ret, size))
+       cpu_addr = page_address(page);
+       if ((attrs & DMA_ATTR_CC_SHARED) && 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_CC_SHARED));
        return page;
-- 
2.43.0


Reply via email to