clk: samsung: use kzalloc_flex
Subsystems (3)
cover clk: samsung: use kzalloc_flex
Switch three structs to flexible array members to combine allocations.
Rosen Penev (3):
clk: samsung: use kzalloc_flex
clk: samsung: cpu: use kzalloc_flex
clk: samsung: pll: use kzalloc_flex
drivers/clk/samsung/clk-cpu.c | 30 +++++++------------ drivers/clk/samsung/clk-pll.c | 56 ++++++++++++++++------------------- drivers/clk/samsung/clk.c | 28 ++++-------------- drivers/clk/samsung/clk.h | 2 +- 4 files changed, 44 insertions(+), 72 deletions(-)
--
2.53.0
PATCH 1/3 clk: samsung: use kzalloc_flex
Simplify allocation by using kzalloc_flex with a flexible array member to combine allocations.
Add __counted_by for extra runtime analysis. Move the counting variable assignment right after allocation as required ny __counted_by.
--- drivers/clk/samsung/clk.c | 28 ++++++---------------------- drivers/clk/samsung/clk.h | 2 +- 2 files changed, 7 insertions(+), 23 deletions(-)
drivers/clk/samsung/clk.c +6 -22
@@ -48,23 +48,6 @@ void samsung_clk_restore(void __iomem *base, } } -struct samsung_clk_reg_dump *samsung_clk_alloc_reg_dump ( -const unsigned long *rdump, -unsigned long nr_rdump) -{ -struct samsung_clk_reg_dump *rd; -unsigned int i; - - rd =kzalloc_objs (*rd, nr_rdump); -if (!rd) -return NULL ; - -for (i =0 ; i < nr_rdump; ++i) - rd[i].offset = rdump[i]; - -return rd; -} -/** * samsung_clk_init() - Create and initialize a clock provider object * @dev: CMU device to enable runtime PM, or NULL if RPM is not needed
@@ -430,21 +413,22 @@ void samsung_clk_extended_sleep_init(void __iomem *reg_base, unsigned long nr_rsuspend) {struct samsung_clock_reg_cache *reg_cache; +int i; - reg_cache = kzalloc_obj(struct samsung_clock_reg_cache); + reg_cache =kzalloc_flex (*reg_cache, rdump, nr_rdump);if (!reg_cache)panic ("could not allocate register reg_cache.\n" ); - reg_cache->rdump =samsung_clk_alloc_reg_dump (rdump, nr_rdump); -if (!reg_cache->rdump) -panic ("could not allocate register dump storage.\n" ); + reg_cache->rd_num = nr_rdump; + +for (i =0 ; i < nr_rdump; ++i) + reg_cache->rdump[i].offset = rdump[i];if (list_empty (&clock_reg_cache_list))register_syscore (&samsung_clk_syscore); reg_cache->reg_base = reg_base; reg_cache->sysreg = sysreg; - reg_cache->rd_num = nr_rdump; reg_cache->rsuspend = rsuspend; reg_cache->rsuspend_num = nr_rsuspend;list_add_tail (®_cache->node, &clock_reg_cache_list);
drivers/clk/samsung/clk.h +1 -1
@@ -324,10 +324,10 @@ struct samsung_clock_reg_cache {struct list_head node;void __iomem *reg_base;struct regmap *sysreg; -struct samsung_clk_reg_dump *rdump;unsigned int rd_num;const struct samsung_clk_reg_dump *rsuspend;unsigned int rsuspend_num; + struct samsung_clk_reg_dump rdump[] __counted_by(rd_num); };/**
Signature · 1 line
2.53.0
Quoted 6 lines · Rosen Penev
Simplify allocation by using
kzalloc_flexwith a flexible array member to combine allocations.Add
__counted_byfor extra runtime analysis. Move the counting variableassignment right after allocation as required ny
__counted_by.
As commented in another thread, this is not true.
(The same applies to changelog text in patch 3/3)
-Gustavo
PATCH 2/3 clk: samsung: cpu: use kzalloc_flex
In reply to Rosen PenevUse a flexible array member to combine allocations.
As kmemdup_array is really kcalloc + memcpy and kzalloc_flex kzalloc + kcalloc, kzalloc and kcalloc combine leaving the memcpy.
--- drivers/clk/samsung/clk-cpu.c | 30 +++++++++++------------------- 1 file changed, 11 insertions(+), 19 deletions(-)
drivers/clk/samsung/clk-cpu.c +11 -19
@@ -101,11 +101,11 @@ struct exynos_cpuclk {const struct clk_hw *alt_parent;void __iomem *base;spinlock_t *lock; -const struct exynos_cpuclk_cfg_data *cfg;const unsigned long num_cfgs;struct notifier_block clk_nb;unsigned long flags;const struct exynos_cpuclk_chip *chip; +struct exynos_cpuclk_cfg_data cfg[]; };/* ---- Common code --------------------------------------------------------- */
@@ -660,10 +660,6 @@ static int __init exynos_register_cpu_clock(struct samsung_clk_provider *ctx,return -EINVAL ; } - cpuclk =kzalloc_obj (*cpuclk); -if (!cpuclk) -return -ENOMEM ; - parent_name =clk_hw_get_name (parent); init.name = clk_data->name;
@@ -672,6 +668,15 @@ static int __init exynos_register_cpu_clock(struct samsung_clk_provider *ctx, init.num_parents =1 ; init.ops = &exynos_cpuclk_clk_ops; +/* Find count of configuration rates in cfg */ +for (num_cfgs =0 ; clk_data->cfg[num_cfgs].prate !=0 ; ) + num_cfgs++; + + cpuclk =kzalloc_flex (*cpuclk, cfg, num_cfgs); +if (!cpuclk) +return -ENOMEM ; + +memcpy (cpuclk->cfg, clk_data->cfg, num_cfgs *sizeof (*cpuclk->cfg)); cpuclk->alt_parent = alt_parent; cpuclk->hw.init = &init; cpuclk->base = ctx->reg_base + clk_data->offset;
@@ -687,29 +692,16 @@ static int __init exynos_register_cpu_clock(struct samsung_clk_provider *ctx, goto free_cpuclk; } -/* Find count of configuration rates in cfg */ -for (num_cfgs =0 ; clk_data->cfg[num_cfgs].prate !=0 ; ) - num_cfgs++; - - cpuclk->cfg =kmemdup_array (clk_data->cfg, num_cfgs,sizeof (*cpuclk->cfg), -GFP_KERNEL ); -if (!cpuclk->cfg) { - ret = -ENOMEM ; - goto unregister_clk_nb; - } - ret =clk_hw_register (NULL , &cpuclk->hw);if (ret) {pr_err ("%s: could not register cpuclk %s\n" , __func__, clk_data->name); - goto free_cpuclk_data; + goto unregister_clk_nb; }samsung_clk_add_lookup (ctx, &cpuclk->hw, clk_data->id);return 0 ; -free_cpuclk_data: -kfree (cpuclk->cfg); unregister_clk_nb:clk_notifier_unregister (parent->clk, &cpuclk->clk_nb); free_cpuclk:
Signature · 1 line
2.53.0
PATCH 3/3 clk: samsung: pll: use kzalloc_flex
In reply to Rosen PenevSimplify allocation by using a flexible array member to combine allocations and remove a kfree.
Use __counted_by for extra runtime analysis. Assign after allocation as required by __counted_by.
Since rate_table is now a flexible array member, NULL checks don't work. So use the counting variable to check allocation.
--- drivers/clk/samsung/clk-pll.c | 56 ++++++++++++++++------------------- 1 file changed, 26 insertions(+), 30 deletions(-)
drivers/clk/samsung/clk-pll.c +26 -30
@@ -28,7 +28,7 @@ struct samsung_clk_pll {unsigned short lock_offs;enum samsung_pll_type type;unsigned int rate_count; -const struct samsung_pll_rate_table *rate_table; + struct samsung_pll_rate_table rate_table[] __counted_by(rate_count); };#define to_clk_pll (_hw) container_of(_hw, struct samsung_clk_pll, hw)
@@ -1593,35 +1593,32 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx, {struct samsung_clk_pll *pll;struct clk_init_data init; -int ret, len; +unsigned int len =0 ; +int ret; - pll =kzalloc_obj (*pll); +if (pll_clk->rate_table) { +/* find count of rates in rate_table */ +while (pll_clk->rate_table[len].rate !=0 ) + len++; + } + + pll =kzalloc_flex (*pll, rate_table, len);if (!pll) {pr_err ("%s: could not allocate pll clk %s\n" , __func__, pll_clk->name);return ; } + pll->rate_count = len; +if (len) +memcpy (pll->rate_table, pll_clk->rate_table, + len *sizeof (*pll->rate_table)); + init.name = pll_clk->name; init.flags = pll_clk->flags; init.parent_names = &pll_clk->parent_name; init.num_parents =1 ; -if (pll_clk->rate_table) { -/* find count of rates in rate_table */ -for (len =0 ; pll_clk->rate_table[len].rate !=0 ; ) - len++; - - pll->rate_count = len; - pll->rate_table =kmemdup_array (pll_clk->rate_table, - pll->rate_count, -sizeof (*pll->rate_table), -GFP_KERNEL ); -WARN (!pll->rate_table, -"%s: could not allocate rate table for %s\n" , - __func__, pll_clk->name); - } -switch (pll_clk->type) {case pll_2126: init.ops = &samsung_pll2126_clk_ops;
@@ -1640,7 +1637,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_a9fracm: pll->enable_offs =PLL35XX_ENABLE_SHIFT ; pll->lock_offs =PLL35XX_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll35xx_clk_min_ops;else init.ops = &samsung_pll35xx_clk_ops;
@@ -1659,7 +1656,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_0732x: pll->enable_offs =PLL0822X_ENABLE_SHIFT ; pll->lock_offs =PLL0822X_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll0822x_clk_min_ops;else init.ops = &samsung_pll0822x_clk_ops;
@@ -1669,7 +1666,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,break ;case pll_4502:case pll_4508: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll45xx_clk_min_ops;else init.ops = &samsung_pll45xx_clk_ops;
@@ -1679,7 +1676,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_2650: pll->enable_offs =PLL36XX_ENABLE_SHIFT ; pll->lock_offs =PLL36XX_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll36xx_clk_min_ops;else init.ops = &samsung_pll36xx_clk_ops;
@@ -1687,7 +1684,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_0831x: pll->enable_offs =PLL0831X_ENABLE_SHIFT ; pll->lock_offs =PLL0831X_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll0831x_clk_min_ops;else init.ops = &samsung_pll0831x_clk_ops;
@@ -1703,7 +1700,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_4650:case pll_4650c:case pll_1460x: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll46xx_clk_min_ops;else init.ops = &samsung_pll46xx_clk_ops;
@@ -1712,19 +1709,19 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx, init.ops = &samsung_pll2550x_clk_ops;break ;case pll_2550xx: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll2550xx_clk_min_ops;else init.ops = &samsung_pll2550xx_clk_ops;break ;case pll_2650x: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll2650x_clk_min_ops;else init.ops = &samsung_pll2650x_clk_ops;break ;case pll_2650xx: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll2650xx_clk_min_ops;else init.ops = &samsung_pll2650xx_clk_ops;
@@ -1734,7 +1731,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx, init.ops = &samsung_pll531x_clk_ops;break ;case pll_1031x: -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_pll1031x_clk_min_ops;else init.ops = &samsung_pll1031x_clk_ops;
@@ -1742,7 +1739,7 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,case pll_a9fraco: pll->enable_offs =PLLA9FRACO_ENABLE_SHIFT ; pll->lock_offs =PLLA9FRACO_LOCK_STAT_SHIFT ; -if (!pll->rate_table) +if (!pll->rate_count) init.ops = &samsung_a9fraco_clk_min_ops;else init.ops = &samsung_a9fraco_clk_ops;
@@ -1761,7 +1758,6 @@ static void __init _samsung_clk_register_pll(struct samsung_clk_provider *ctx,if (ret) {pr_err ("%s: failed to register pll clock %s : %d\n" , __func__, pll_clk->name, ret); -kfree (pll->rate_table);kfree (pll);return ; }
Signature · 1 line
2.53.0