staging: ion: tidy up a bit

For aesthetics and readability, rename goto labels, remove
useless code lines, and clarify function return type.

Signed-off-by: Heesub Shin <heesub.shin@samsung.com>
Reviewed-by: Mitchel Humpherys <mitchelh@codeaurora.org>
Tested-by: John Stultz <john.stultz@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/staging/android/ion/ion_page_pool.c b/drivers/staging/android/ion/ion_page_pool.c
index ecb5fc3..ead4054 100644 (file)
--- a/drivers/staging/android/ion/ion_page_pool.c
+++ b/drivers/staging/android/ion/ion_page_pool.c
@@ -89,7 +89,7 @@ static struct page *ion_page_pool_remove(struct ion_page_pool *pool, bool high)
        return page;
 }
 
-void *ion_page_pool_alloc(struct ion_page_pool *pool)
+struct page *ion_page_pool_alloc(struct ion_page_pool *pool)
 {
        struct page *page = NULL;
 

diff --git a/drivers/staging/android/ion/ion_priv.h b/drivers/staging/android/ion/ion_priv.h
index c2dc942..c8f0175 100644 (file)
--- a/drivers/staging/android/ion/ion_priv.h
+++ b/drivers/staging/android/ion/ion_priv.h
@@ -378,7 +378,7 @@ struct ion_page_pool {
 
 struct ion_page_pool *ion_page_pool_create(gfp_t gfp_mask, unsigned int order);
 void ion_page_pool_destroy(struct ion_page_pool *);
-void *ion_page_pool_alloc(struct ion_page_pool *);
+struct page *ion_page_pool_alloc(struct ion_page_pool *);
 void ion_page_pool_free(struct ion_page_pool *, struct page *);
 
 /** ion_page_pool_shrink - shrinks the size of the memory cached in the pool

diff --git a/drivers/staging/android/ion/ion_system_heap.c b/drivers/staging/android/ion/ion_system_heap.c
index a144995..ae3c9ed 100644 (file)
--- a/drivers/staging/android/ion/ion_system_heap.c
+++ b/drivers/staging/android/ion/ion_system_heap.c
@@ -42,7 +42,7 @@ static int order_to_index(unsigned int order)
        return -1;
 }
 
-static unsigned int order_to_size(int order)
+static inline unsigned int order_to_size(int order)
 {
        return PAGE_SIZE << order;
 }
@@ -79,8 +79,6 @@ static struct page *alloc_buffer_page(struct ion_system_heap *heap,
                ion_pages_sync_for_device(NULL, page, PAGE_SIZE << order,
                                                DMA_BIDIRECTIONAL);
        }
-       if (!page)
-               return NULL;
 
        return page;
 }
@@ -126,7 +124,6 @@ static struct page_info *alloc_largest_available(struct ion_system_heap *heap,
 
                info->page = page;
                info->order = orders[i];
-               INIT_LIST_HEAD(&info->list);
                return info;
        }
        kfree(info);
@@ -144,7 +141,6 @@ static int ion_system_heap_allocate(struct ion_heap *heap,
                                                        heap);
        struct sg_table *table;
        struct scatterlist *sg;
-       int ret;
        struct list_head pages;
        struct page_info *info, *tmp_info;
        int i = 0;
@@ -162,24 +158,23 @@ static int ion_system_heap_allocate(struct ion_heap *heap,
                info = alloc_largest_available(sys_heap, buffer, size_remaining,
                                                max_order);
                if (!info)
-                       goto err;
+                       goto free_pages;
                list_add_tail(&info->list, &pages);
-               size_remaining -= (1 << info->order) * PAGE_SIZE;
+               size_remaining -= PAGE_SIZE << info->order;
                max_order = info->order;
                i++;
        }
        table = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
        if (!table)
-               goto err;
+               goto free_pages;
 
-       ret = sg_alloc_table(table, i, GFP_KERNEL);
-       if (ret)
-               goto err1;
+       if (sg_alloc_table(table, i, GFP_KERNEL))
+               goto free_table;
 
        sg = table->sgl;
        list_for_each_entry_safe(info, tmp_info, &pages, list) {
                struct page *page = info->page;
-               sg_set_page(sg, page, (1 << info->order) * PAGE_SIZE, 0);
+               sg_set_page(sg, page, PAGE_SIZE << info->order, 0);
                sg = sg_next(sg);
                list_del(&info->list);
                kfree(info);
@@ -187,9 +182,10 @@ static int ion_system_heap_allocate(struct ion_heap *heap,
 
        buffer->priv_virt = table;
        return 0;
-err1:
+
+free_table:
        kfree(table);
-err:
+free_pages:
        list_for_each_entry_safe(info, tmp_info, &pages, list) {
                free_buffer_page(sys_heap, buffer, info->page, info->order);
                kfree(info);
@@ -199,14 +195,12 @@ err:
 
 static void ion_system_heap_free(struct ion_buffer *buffer)
 {
-       struct ion_heap *heap = buffer->heap;
-       struct ion_system_heap *sys_heap = container_of(heap,
+       struct ion_system_heap *sys_heap = container_of(buffer->heap,
                                                        struct ion_system_heap,
                                                        heap);
        struct sg_table *table = buffer->sg_table;
        bool cached = ion_buffer_cached(buffer);
        struct scatterlist *sg;
-       LIST_HEAD(pages);
        int i;
 
        /* uncached pages come from the page pools, zero them before returning
@@ -276,10 +270,10 @@ static int ion_system_heap_debug_show(struct ion_heap *heap, struct seq_file *s,
 
                seq_printf(s, "%d order %u highmem pages in pool = %lu total\n",
                           pool->high_count, pool->order,
-                          (1 << pool->order) * PAGE_SIZE * pool->high_count);
+                          (PAGE_SIZE << pool->order) * pool->high_count);
                seq_printf(s, "%d order %u lowmem pages in pool = %lu total\n",
                           pool->low_count, pool->order,
-                          (1 << pool->order) * PAGE_SIZE * pool->low_count);
+                          (PAGE_SIZE << pool->order) * pool->low_count);
        }
        return 0;
 }
@@ -298,7 +292,7 @@ struct ion_heap *ion_system_heap_create(struct ion_platform_heap *unused)
        heap->pools = kzalloc(sizeof(struct ion_page_pool *) * num_orders,
                              GFP_KERNEL);
        if (!heap->pools)
-               goto err_alloc_pools;
+               goto free_heap;
        for (i = 0; i < num_orders; i++) {
                struct ion_page_pool *pool;
                gfp_t gfp_flags = low_order_gfp_flags;
@@ -307,18 +301,18 @@ struct ion_heap *ion_system_heap_create(struct ion_platform_heap *unused)
                        gfp_flags = high_order_gfp_flags;
                pool = ion_page_pool_create(gfp_flags, orders[i]);
                if (!pool)
-                       goto err_create_pool;
+                       goto destroy_pools;
                heap->pools[i] = pool;
        }
 
        heap->heap.debug_show = ion_system_heap_debug_show;
        return &heap->heap;
-err_create_pool:
-       for (i = 0; i < num_orders; i++)
-               if (heap->pools[i])
-                       ion_page_pool_destroy(heap->pools[i]);
+
+destroy_pools:
+       while (i--)
+               ion_page_pool_destroy(heap->pools[i]);
        kfree(heap->pools);
-err_alloc_pools:
+free_heap:
        kfree(heap);
        return ERR_PTR(-ENOMEM);
 }
@@ -364,12 +358,12 @@ static int ion_system_contig_heap_allocate(struct ion_heap *heap,
        table = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
        if (!table) {
                ret = -ENOMEM;
-               goto out;
+               goto free_pages;
        }
 
        ret = sg_alloc_table(table, 1, GFP_KERNEL);
        if (ret)
-               goto out;
+               goto free_table;
 
        sg_set_page(table->sgl, page, len, 0);
 
@@ -379,10 +373,12 @@ static int ion_system_contig_heap_allocate(struct ion_heap *heap,
 
        return 0;
 
-out:
+free_table:
+       kfree(table);
+free_pages:
        for (i = 0; i < len >> PAGE_SHIFT; i++)
                __free_page(page + i);
-       kfree(table);
+
        return ret;
 }
 
@@ -448,4 +444,3 @@ void ion_system_contig_heap_destroy(struct ion_heap *heap)
 {
        kfree(heap);
 }
-