#include <dt-bindings/clock/axg-clkc.h>
 
-static DEFINE_SPINLOCK(meson_clk_lock);
-
 static struct clk_regmap axg_fixed_pll_dco = {
        .data = &(struct meson_clk_pll_data){
                .en = {
                        .shift   = 0,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .flags = CLK_MESON_MPLL_ROUND_CLOSEST,
        },
        .hw.init = &(struct clk_init_data){
                        .shift   = 1,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .flags = CLK_MESON_MPLL_ROUND_CLOSEST,
        },
        .hw.init = &(struct clk_init_data){
                        .shift   = 2,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .flags = CLK_MESON_MPLL_ROUND_CLOSEST,
        },
        .hw.init = &(struct clk_init_data){
                        .shift   = 3,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .flags = CLK_MESON_MPLL_ROUND_CLOSEST,
        },
        .hw.init = &(struct clk_init_data){
 
        struct clk_regmap *clk = to_clk_regmap(hw);
        struct meson_clk_mpll_data *mpll = meson_clk_mpll_data(clk);
        unsigned int sdm, n2;
-       unsigned long flags = 0;
 
        params_from_rate(rate, parent_rate, &sdm, &n2, mpll->flags);
 
-       if (mpll->lock)
-               spin_lock_irqsave(mpll->lock, flags);
-       else
-               __acquire(mpll->lock);
-
        /* Set the fractional part */
        meson_parm_write(clk->map, &mpll->sdm, sdm);
 
        /* Set the integer divider part */
        meson_parm_write(clk->map, &mpll->n2, n2);
 
-       if (mpll->lock)
-               spin_unlock_irqrestore(mpll->lock, flags);
-       else
-               __release(mpll->lock);
-
        return 0;
 }
 
 
        struct parm misc;
        const struct reg_sequence *init_regs;
        unsigned int init_count;
-       spinlock_t *lock;
        u8 flags;
 };
 
 
 
 #include <dt-bindings/clock/g12a-clkc.h>
 
-static DEFINE_SPINLOCK(meson_clk_lock);
-
 static struct clk_regmap g12a_fixed_pll_dco = {
        .data = &(struct meson_clk_pll_data){
                .en = {
                        .shift   = 29,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .init_regs = g12a_mpll0_init_regs,
                .init_count = ARRAY_SIZE(g12a_mpll0_init_regs),
        },
                        .shift   = 29,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .init_regs = g12a_mpll1_init_regs,
                .init_count = ARRAY_SIZE(g12a_mpll1_init_regs),
        },
                        .shift   = 29,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .init_regs = g12a_mpll2_init_regs,
                .init_count = ARRAY_SIZE(g12a_mpll2_init_regs),
        },
                        .shift   = 29,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .init_regs = g12a_mpll3_init_regs,
                .init_count = ARRAY_SIZE(g12a_mpll3_init_regs),
        },
 
 
 #include <dt-bindings/clock/gxbb-clkc.h>
 
-static DEFINE_SPINLOCK(meson_clk_lock);
-
 static const struct pll_params_table gxbb_gp0_pll_params_table[] = {
        PLL_PARAMS(32, 1),
        PLL_PARAMS(33, 1),
                        .shift   = 16,
                        .width   = 9,
                },
-               .lock = &meson_clk_lock,
        },
        .hw.init = &(struct clk_init_data){
                .name = "mpll0_div",
                        .shift   = 16,
                        .width   = 9,
                },
-               .lock = &meson_clk_lock,
        },
        .hw.init = &(struct clk_init_data){
                .name = "mpll0_div",
                        .shift   = 16,
                        .width   = 9,
                },
-               .lock = &meson_clk_lock,
        },
        .hw.init = &(struct clk_init_data){
                .name = "mpll1_div",
                        .shift   = 16,
                        .width   = 9,
                },
-               .lock = &meson_clk_lock,
        },
        .hw.init = &(struct clk_init_data){
                .name = "mpll2_div",
 
                        .shift   = 25,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
        },
        .hw.init = &(struct clk_init_data){
                .name = "mpll0_div",
                        .shift   = 16,
                        .width   = 9,
                },
-               .lock = &meson_clk_lock,
        },
        .hw.init = &(struct clk_init_data){
                .name = "mpll1_div",
                        .shift   = 16,
                        .width   = 9,
                },
-               .lock = &meson_clk_lock,
        },
        .hw.init = &(struct clk_init_data){
                .name = "mpll2_div",
 
 #include "meson-clkc-utils.h"
 #include <dt-bindings/clock/amlogic,s4-pll-clkc.h>
 
-static DEFINE_SPINLOCK(meson_clk_lock);
-
 /*
  * These clock are a fixed value (fixed_pll is 2GHz) that is initialized by ROMcode.
  * The chip was changed fixed pll for security reasons. Fixed PLL registers are not writable
                        .shift   = 29,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .init_regs = s4_mpll0_init_regs,
                .init_count = ARRAY_SIZE(s4_mpll0_init_regs),
        },
                        .shift   = 29,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .init_regs = s4_mpll1_init_regs,
                .init_count = ARRAY_SIZE(s4_mpll1_init_regs),
        },
                        .shift   = 29,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .init_regs = s4_mpll2_init_regs,
                .init_count = ARRAY_SIZE(s4_mpll2_init_regs),
        },
                        .shift   = 29,
                        .width   = 1,
                },
-               .lock = &meson_clk_lock,
                .init_regs = s4_mpll3_init_regs,
                .init_count = ARRAY_SIZE(s4_mpll3_init_regs),
        },