Merge tag 'clk-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux

Pull clk fixes from Stephen Boyd:
 "A small set of fixes for problems found by smatch in new drivers that
  we added this rc and a handful of driver fixes that came in during the
  merge window"

* tag 'clk-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux:
  drivers: clk: st: Incorrect register offset used for lock_status
  clk: mediatek: mt8173: Fix enabling of critical clocks
  drivers: clk: st: Fix mux bit-setting for Cortex A9 clocks
  drivers: clk: st: Add CLK_GET_RATE_NOCACHE flag to clocks
  drivers: clk: st: Fix flexgen lock init
  drivers: clk: st: Fix FSYN channel values
  drivers: clk: st: Remove unused code
  clk: qcom: Use parent rate when set rate to pixel RCG clock
  clk: at91: do not leak resources
  clk: stm32: Fix out-by-one error path in the index lookup
  clk: iproc: fix bit manipulation arithmetic
  clk: iproc: fix memory leak from clock name

15 files changed, 74 insertions, 50 deletions

diff --git a/drivers/clk/at91/clk-h32mx.c b/drivers/clk/at91/clk-h32mx.c
index 152dcb3f7b5f..61566bcefa53 100644
--- a/drivers/clk/at91/clk-h32mx.c
+++ b/drivers/clk/at91/clk-h32mx.c
@@ -116,8 +116,10 @@ void __init of_sama5d4_clk_h32mx_setup(struct device_node *np,
         h32mxclk->pmc = pmc;
 
         clk = clk_register(NULL, &h32mxclk->hw);
-        if (!clk)
+        if (!clk) {
+                kfree(h32mxclk);
                 return;
+        }
 
         of_clk_add_provider(np, of_clk_src_simple_get, clk);
 }
diff --git a/drivers/clk/at91/clk-main.c b/drivers/clk/at91/clk-main.c
index c2400456a044..27dfa965cfed 100644
--- a/drivers/clk/at91/clk-main.c
+++ b/drivers/clk/at91/clk-main.c
@@ -171,8 +171,10 @@ at91_clk_register_main_osc(struct at91_pmc *pmc,
         irq_set_status_flags(osc->irq, IRQ_NOAUTOEN);
         ret = request_irq(osc->irq, clk_main_osc_irq_handler,
                           IRQF_TRIGGER_HIGH, name, osc);
-        if (ret)
+        if (ret) {
+                kfree(osc);
                 return ERR_PTR(ret);
+        }
 
         if (bypass)
                 pmc_write(pmc, AT91_CKGR_MOR,
diff --git a/drivers/clk/at91/clk-master.c b/drivers/clk/at91/clk-master.c
index f98eafe9b12d..5b3ded5205a2 100644
--- a/drivers/clk/at91/clk-master.c
+++ b/drivers/clk/at91/clk-master.c
@@ -165,12 +165,16 @@ at91_clk_register_master(struct at91_pmc *pmc, unsigned int irq,
         irq_set_status_flags(master->irq, IRQ_NOAUTOEN);
         ret = request_irq(master->irq, clk_master_irq_handler,
                           IRQF_TRIGGER_HIGH, "clk-master", master);
-        if (ret)
+        if (ret) {
+                kfree(master);
                 return ERR_PTR(ret);
+        }
 
         clk = clk_register(NULL, &master->hw);
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
+                free_irq(master->irq, master);
                 kfree(master);
+        }
 
         return clk;
 }
diff --git a/drivers/clk/at91/clk-pll.c b/drivers/clk/at91/clk-pll.c
index cbbe40377ad6..18b60f4895a6 100644
--- a/drivers/clk/at91/clk-pll.c
+++ b/drivers/clk/at91/clk-pll.c
@@ -346,12 +346,16 @@ at91_clk_register_pll(struct at91_pmc *pmc, unsigned int irq, const char *name,
         irq_set_status_flags(pll->irq, IRQ_NOAUTOEN);
         ret = request_irq(pll->irq, clk_pll_irq_handler, IRQF_TRIGGER_HIGH,
                           id ? "clk-pllb" : "clk-plla", pll);
-        if (ret)
+        if (ret) {
+                kfree(pll);
                 return ERR_PTR(ret);
+        }
 
         clk = clk_register(NULL, &pll->hw);
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
+                free_irq(pll->irq, pll);
                 kfree(pll);
+        }
 
         return clk;
 }
diff --git a/drivers/clk/at91/clk-system.c b/drivers/clk/at91/clk-system.c
index a76d03fd577b..58008b3e8bc1 100644
--- a/drivers/clk/at91/clk-system.c
+++ b/drivers/clk/at91/clk-system.c
@@ -130,13 +130,17 @@ at91_clk_register_system(struct at91_pmc *pmc, const char *name,
                 irq_set_status_flags(sys->irq, IRQ_NOAUTOEN);
                 ret = request_irq(sys->irq, clk_system_irq_handler,
                                 IRQF_TRIGGER_HIGH, name, sys);
-                if (ret)
+                if (ret) {
+                        kfree(sys);
                         return ERR_PTR(ret);
+                }
         }
 
         clk = clk_register(NULL, &sys->hw);
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
+                free_irq(sys->irq, sys);
                 kfree(sys);
+        }
 
         return clk;
 }
diff --git a/drivers/clk/at91/clk-utmi.c b/drivers/clk/at91/clk-utmi.c
index ae3263bc1476..30dd697b1668 100644
--- a/drivers/clk/at91/clk-utmi.c
+++ b/drivers/clk/at91/clk-utmi.c
@@ -118,12 +118,16 @@ at91_clk_register_utmi(struct at91_pmc *pmc, unsigned int irq,
         irq_set_status_flags(utmi->irq, IRQ_NOAUTOEN);
         ret = request_irq(utmi->irq, clk_utmi_irq_handler,
                           IRQF_TRIGGER_HIGH, "clk-utmi", utmi);
-        if (ret)
+        if (ret) {
+                kfree(utmi);
                 return ERR_PTR(ret);
+        }
 
         clk = clk_register(NULL, &utmi->hw);
-        if (IS_ERR(clk))
+        if (IS_ERR(clk)) {
+                free_irq(utmi->irq, utmi);
                 kfree(utmi);
+        }
 
         return clk;
 }
diff --git a/drivers/clk/bcm/clk-iproc-asiu.c b/drivers/clk/bcm/clk-iproc-asiu.c
index e19c09cd9645..f630e1bbdcfe 100644
--- a/drivers/clk/bcm/clk-iproc-asiu.c
+++ b/drivers/clk/bcm/clk-iproc-asiu.c
@@ -222,10 +222,6 @@ void __init iproc_asiu_setup(struct device_node *node,
                 struct iproc_asiu_clk *asiu_clk;
                 const char *clk_name;
 
-                clk_name = kzalloc(IPROC_CLK_NAME_LEN, GFP_KERNEL);
-                if (WARN_ON(!clk_name))
-                        goto err_clk_register;
-
                 ret = of_property_read_string_index(node, "clock-output-names",
                                                     i, &clk_name);
                 if (WARN_ON(ret))
@@ -259,7 +255,7 @@ void __init iproc_asiu_setup(struct device_node *node,
 
 err_clk_register:
         for (i = 0; i < num_clks; i++)
-                kfree(asiu->clks[i].name);
+                clk_unregister(asiu->clk_data.clks[i]);
         iounmap(asiu->gate_base);
 
 err_iomap_gate:
diff --git a/drivers/clk/bcm/clk-iproc-pll.c b/drivers/clk/bcm/clk-iproc-pll.c
index 46fb84bc2674..2dda4e8295a9 100644
--- a/drivers/clk/bcm/clk-iproc-pll.c
+++ b/drivers/clk/bcm/clk-iproc-pll.c
@@ -366,7 +366,7 @@ static unsigned long iproc_pll_recalc_rate(struct clk_hw *hw,
         val = readl(pll->pll_base + ctrl->ndiv_int.offset);
         ndiv_int = (val >> ctrl->ndiv_int.shift) &
                 bit_mask(ctrl->ndiv_int.width);
-        ndiv = ndiv_int << ctrl->ndiv_int.shift;
+        ndiv = (u64)ndiv_int << ctrl->ndiv_int.shift;
 
         if (ctrl->flags & IPROC_CLK_PLL_HAS_NDIV_FRAC) {
                 val = readl(pll->pll_base + ctrl->ndiv_frac.offset);
@@ -374,7 +374,8 @@ static unsigned long iproc_pll_recalc_rate(struct clk_hw *hw,
                         bit_mask(ctrl->ndiv_frac.width);
 
                 if (ndiv_frac != 0)
-                        ndiv = (ndiv_int << ctrl->ndiv_int.shift) | ndiv_frac;
+                        ndiv = ((u64)ndiv_int << ctrl->ndiv_int.shift) |
+                                ndiv_frac;
         }
 
         val = readl(pll->pll_base + ctrl->pdiv.offset);
@@ -655,10 +656,6 @@ void __init iproc_pll_clk_setup(struct device_node *node,
                 memset(&init, 0, sizeof(init));
                 parent_name = node->name;
 
-                clk_name = kzalloc(IPROC_CLK_NAME_LEN, GFP_KERNEL);
-                if (WARN_ON(!clk_name))
-                        goto err_clk_register;
-
                 ret = of_property_read_string_index(node, "clock-output-names",
                                                     i, &clk_name);
                 if (WARN_ON(ret))
@@ -690,10 +687,8 @@ void __init iproc_pll_clk_setup(struct device_node *node,
         return;
 
 err_clk_register:
-        for (i = 0; i < num_clks; i++) {
-                kfree(pll->clks[i].name);
+        for (i = 0; i < num_clks; i++)
                 clk_unregister(pll->clk_data.clks[i]);
-        }
 
 err_pll_register:
         if (pll->asiu_base)
diff --git a/drivers/clk/clk-stm32f4.c b/drivers/clk/clk-stm32f4.c
index b9b12a742970..3f6f7ad39490 100644
--- a/drivers/clk/clk-stm32f4.c
+++ b/drivers/clk/clk-stm32f4.c
@@ -268,7 +268,7 @@ static int stm32f4_rcc_lookup_clk_idx(u8 primary, u8 secondary)
         memcpy(table, stm32f42xx_gate_map, sizeof(table));
 
         /* only bits set in table can be used as indices */
-        if (WARN_ON(secondary > 8 * sizeof(table) ||
+        if (WARN_ON(secondary >= BITS_PER_BYTE * sizeof(table) ||
                     0 == (table[BIT_ULL_WORD(secondary)] &
                           BIT_ULL_MASK(secondary))))
                 return -EINVAL;
diff --git a/drivers/clk/mediatek/clk-mt8173.c b/drivers/clk/mediatek/clk-mt8173.c
index 4b9e04cdf7e8..8b6523d15fb8 100644
--- a/drivers/clk/mediatek/clk-mt8173.c
+++ b/drivers/clk/mediatek/clk-mt8173.c
@@ -700,6 +700,22 @@ static const struct mtk_composite peri_clks[] __initconst = {
         MUX(CLK_PERI_UART3_SEL, "uart3_ck_sel", uart_ck_sel_parents, 0x40c, 3, 1),
 };
 
+static struct clk_onecell_data *mt8173_top_clk_data __initdata;
+static struct clk_onecell_data *mt8173_pll_clk_data __initdata;
+
+static void __init mtk_clk_enable_critical(void)
+{
+        if (!mt8173_top_clk_data || !mt8173_pll_clk_data)
+                return;
+
+        clk_prepare_enable(mt8173_pll_clk_data->clks[CLK_APMIXED_ARMCA15PLL]);
+        clk_prepare_enable(mt8173_pll_clk_data->clks[CLK_APMIXED_ARMCA7PLL]);
+        clk_prepare_enable(mt8173_top_clk_data->clks[CLK_TOP_MEM_SEL]);
+        clk_prepare_enable(mt8173_top_clk_data->clks[CLK_TOP_DDRPHYCFG_SEL]);
+        clk_prepare_enable(mt8173_top_clk_data->clks[CLK_TOP_CCI400_SEL]);
+        clk_prepare_enable(mt8173_top_clk_data->clks[CLK_TOP_RTC_SEL]);
+}
+
 static void __init mtk_topckgen_init(struct device_node *node)
 {
         struct clk_onecell_data *clk_data;
@@ -712,19 +728,19 @@ static void __init mtk_topckgen_init(struct device_node *node)
                 return;
         }
 
-        clk_data = mtk_alloc_clk_data(CLK_TOP_NR_CLK);
+        mt8173_top_clk_data = clk_data = mtk_alloc_clk_data(CLK_TOP_NR_CLK);
 
         mtk_clk_register_factors(root_clk_alias, ARRAY_SIZE(root_clk_alias), clk_data);
         mtk_clk_register_factors(top_divs, ARRAY_SIZE(top_divs), clk_data);
         mtk_clk_register_composites(top_muxes, ARRAY_SIZE(top_muxes), base,
                         &mt8173_clk_lock, clk_data);
 
-        clk_prepare_enable(clk_data->clks[CLK_TOP_CCI400_SEL]);
-
         r = of_clk_add_provider(node, of_clk_src_onecell_get, clk_data);
         if (r)
                 pr_err("%s(): could not register clock provider: %d\n",
                         __func__, r);
+
+        mtk_clk_enable_critical();
 }
 CLK_OF_DECLARE(mtk_topckgen, "mediatek,mt8173-topckgen", mtk_topckgen_init);
 
@@ -818,13 +834,13 @@ static void __init mtk_apmixedsys_init(struct device_node *node)
 {
         struct clk_onecell_data *clk_data;
 
-        clk_data = mtk_alloc_clk_data(CLK_APMIXED_NR_CLK);
+        mt8173_pll_clk_data = clk_data = mtk_alloc_clk_data(CLK_APMIXED_NR_CLK);
         if (!clk_data)
                 return;
 
         mtk_clk_register_plls(node, plls, ARRAY_SIZE(plls), clk_data);
 
-        clk_prepare_enable(clk_data->clks[CLK_APMIXED_ARMCA15PLL]);
+        mtk_clk_enable_critical();
 }
 CLK_OF_DECLARE(mtk_apmixedsys, "mediatek,mt8173-apmixedsys",
                 mtk_apmixedsys_init);
diff --git a/drivers/clk/qcom/clk-rcg2.c b/drivers/clk/qcom/clk-rcg2.c
index b95d17fbb8d7..92936f0912d2 100644
--- a/drivers/clk/qcom/clk-rcg2.c
+++ b/drivers/clk/qcom/clk-rcg2.c
@@ -530,19 +530,16 @@ static int clk_pixel_set_rate(struct clk_hw *hw, unsigned long rate,
         struct clk_rcg2 *rcg = to_clk_rcg2(hw);
         struct freq_tbl f = *rcg->freq_tbl;
         const struct frac_entry *frac = frac_table_pixel;
-        unsigned long request, src_rate;
+        unsigned long request;
         int delta = 100000;
         u32 mask = BIT(rcg->hid_width) - 1;
         u32 hid_div;
-        int index = qcom_find_src_index(hw, rcg->parent_map, f.src);
-        struct clk *parent = clk_get_parent_by_index(hw->clk, index);
 
         for (; frac->num; frac++) {
                 request = (rate * frac->den) / frac->num;
 
-                src_rate = __clk_round_rate(parent, request);
-                if ((src_rate < (request - delta)) ||
-                        (src_rate > (request + delta)))
+                if ((parent_rate < (request - delta)) ||
+                        (parent_rate > (request + delta)))
                         continue;
 
                 regmap_read(rcg->clkr.regmap, rcg->cmd_rcgr + CFG_REG,
diff --git a/drivers/clk/st/clk-flexgen.c b/drivers/clk/st/clk-flexgen.c
index 657ca14ba709..8dd8cce27361 100644
--- a/drivers/clk/st/clk-flexgen.c
+++ b/drivers/clk/st/clk-flexgen.c
@@ -190,7 +190,7 @@ static struct clk *clk_register_flexgen(const char *name,
 
         init.name = name;
         init.ops = &flexgen_ops;
-        init.flags = CLK_IS_BASIC | flexgen_flags;
+        init.flags = CLK_IS_BASIC | CLK_GET_RATE_NOCACHE | flexgen_flags;
         init.parent_names = parent_names;
         init.num_parents = num_parents;
 
@@ -303,6 +303,8 @@ static void __init st_of_flexgen_setup(struct device_node *np)
         if (!rlock)
                 goto err;
 
+        spin_lock_init(rlock);
+
         for (i = 0; i < clk_data->clk_num; i++) {
                 struct clk *clk;
                 const char *clk_name;
diff --git a/drivers/clk/st/clkgen-fsyn.c b/drivers/clk/st/clkgen-fsyn.c
index e94197f04b0b..d9eb2e1d8471 100644
--- a/drivers/clk/st/clkgen-fsyn.c
+++ b/drivers/clk/st/clkgen-fsyn.c
@@ -340,7 +340,7 @@ static const struct clkgen_quadfs_data st_fs660c32_C_407 = {
                     CLKGEN_FIELD(0x30c, 0xf, 20),
                     CLKGEN_FIELD(0x310, 0xf, 20) },
         .lockstatus_present = true,
-        .lock_status = CLKGEN_FIELD(0x2A0, 0x1, 24),
+        .lock_status = CLKGEN_FIELD(0x2f0, 0x1, 24),
         .powerup_polarity = 1,
         .standby_polarity = 1,
         .pll_ops        = &st_quadfs_pll_c32_ops,
@@ -489,7 +489,7 @@ static int quadfs_pll_is_enabled(struct clk_hw *hw)
         struct st_clk_quadfs_pll *pll = to_quadfs_pll(hw);
         u32 npda = CLKGEN_READ(pll, npda);
 
-        return !!npda;
+        return pll->data->powerup_polarity ? !npda : !!npda;
 }
 
 static int clk_fs660c32_vco_get_rate(unsigned long input, struct stm_fs *fs,
@@ -635,7 +635,7 @@ static struct clk * __init st_clk_register_quadfs_pll(
 
         init.name = name;
         init.ops = quadfs->pll_ops;
-        init.flags = CLK_IS_BASIC;
+        init.flags = CLK_IS_BASIC | CLK_GET_RATE_NOCACHE;
         init.parent_names = &parent_name;
         init.num_parents = 1;
 
@@ -774,7 +774,7 @@ static void quadfs_fsynth_disable(struct clk_hw *hw)
         if (fs->lock)
                 spin_lock_irqsave(fs->lock, flags);
 
-        CLKGEN_WRITE(fs, nsb[fs->chan], !fs->data->standby_polarity);
+        CLKGEN_WRITE(fs, nsb[fs->chan], fs->data->standby_polarity);
 
         if (fs->lock)
                 spin_unlock_irqrestore(fs->lock, flags);
@@ -1082,10 +1082,6 @@ static const struct of_device_id quadfs_of_match[] = {
                 .compatible = "st,stih407-quadfs660-D",
                 .data = &st_fs660c32_D_407
         },
-        {
-                .compatible = "st,stih407-quadfs660-D",
-                .data = (void *)&st_fs660c32_D_407
-        },
         {}
 };
 
diff --git a/drivers/clk/st/clkgen-mux.c b/drivers/clk/st/clkgen-mux.c
index 4fbe6e099587..717c4a91a17b 100644
--- a/drivers/clk/st/clkgen-mux.c
+++ b/drivers/clk/st/clkgen-mux.c
@@ -237,7 +237,7 @@ static struct clk *clk_register_genamux(const char *name,
 
         init.name = name;
         init.ops = &clkgena_divmux_ops;
-        init.flags = CLK_IS_BASIC;
+        init.flags = CLK_IS_BASIC | CLK_GET_RATE_NOCACHE;
         init.parent_names = parent_names;
         init.num_parents = num_parents;
 
@@ -513,7 +513,8 @@ static void __init st_of_clkgena_prediv_setup(struct device_node *np)
                                           0, &clk_name))
                 return;
 
-        clk = clk_register_divider_table(NULL, clk_name, parent_name, 0,
+        clk = clk_register_divider_table(NULL, clk_name, parent_name,
+                                         CLK_GET_RATE_NOCACHE,
                                          reg + data->offset, data->shift, 1,
                                          0, data->table, NULL);
         if (IS_ERR(clk))
@@ -582,7 +583,7 @@ static struct clkgen_mux_data stih416_a9_mux_data = {
 };
 static struct clkgen_mux_data stih407_a9_mux_data = {
         .offset = 0x1a4,
-        .shift = 1,
+        .shift = 0,
         .width = 2,
 };
 
@@ -786,7 +787,8 @@ static void __init st_of_clkgen_vcc_setup(struct device_node *np)
                                              &mux->hw, &clk_mux_ops,
                                              &div->hw, &clk_divider_ops,
                                              &gate->hw, &clk_gate_ops,
-                                             data->clk_flags);
+                                             data->clk_flags |
+                                             CLK_GET_RATE_NOCACHE);
                 if (IS_ERR(clk)) {
                         kfree(gate);
                         kfree(div);
diff --git a/drivers/clk/st/clkgen-pll.c b/drivers/clk/st/clkgen-pll.c
index 106532207213..72d1c27eaffa 100644
--- a/drivers/clk/st/clkgen-pll.c
+++ b/drivers/clk/st/clkgen-pll.c
@@ -406,7 +406,7 @@ static struct clk * __init clkgen_pll_register(const char *parent_name,
         init.name = clk_name;
         init.ops = pll_data->ops;
 
-        init.flags = CLK_IS_BASIC;
+        init.flags = CLK_IS_BASIC | CLK_GET_RATE_NOCACHE;
         init.parent_names = &parent_name;
         init.num_parents  = 1;