drivers/clk/microchip/clk-mpfs-ccc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Author: Conor Dooley <conor.dooley@microchip.com>
   4  *
   5  * Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries
   6  */
   7 #include "asm-generic/errno-base.h"
   8 #include <linux/clk-provider.h>
   9 #include <linux/io.h>
  10 #include <linux/module.h>
  11 #include <linux/platform_device.h>
  12 #include <dt-bindings/clock/microchip,mpfs-clock.h>
  13
  14 /* address offset of control registers */
  15 #define MPFS_CCC_PLL_CR                 0x04u
  16 #define MPFS_CCC_REF_CR                 0x08u
  17 #define MPFS_CCC_SSCG_2_CR              0x2Cu
  18 #define MPFS_CCC_POSTDIV01_CR           0x10u
  19 #define MPFS_CCC_POSTDIV23_CR           0x14u
  20
  21 #define MPFS_CCC_FBDIV_SHIFT            0x00u
  22 #define MPFS_CCC_FBDIV_WIDTH            0x0Cu
  23 #define MPFS_CCC_POSTDIV0_SHIFT         0x08u
  24 #define MPFS_CCC_POSTDIV1_SHIFT         0x18u
  25 #define MPFS_CCC_POSTDIV2_SHIFT         MPFS_CCC_POSTDIV0_SHIFT
  26 #define MPFS_CCC_POSTDIV3_SHIFT         MPFS_CCC_POSTDIV1_SHIFT
  27 #define MPFS_CCC_POSTDIV_WIDTH          0x06u
  28 #define MPFS_CCC_REFCLK_SEL             BIT(6)
  29 #define MPFS_CCC_REFDIV_SHIFT           0x08u
  30 #define MPFS_CCC_REFDIV_WIDTH           0x06u
  31
  32 #define MPFS_CCC_FIXED_DIV              4
  33 #define MPFS_CCC_OUTPUTS_PER_PLL        4
  34 #define MPFS_CCC_REFS_PER_PLL           2
  35
  36 struct mpfs_ccc_data {
  37         void __iomem **pll_base;
  38         struct device *dev;
  39         struct clk_hw_onecell_data hw_data;
  40 };
  41
  42 struct mpfs_ccc_pll_hw_clock {
  43         void __iomem *base;
  44         const char *name;
  45         const struct clk_parent_data *parents;
  46         unsigned int id;
  47         u32 reg_offset;
  48         u32 shift;
  49         u32 width;
  50         u32 flags;
  51         struct clk_hw hw;
  52         struct clk_init_data init;
  53 };
  54
  55 #define to_mpfs_ccc_clk(_hw) container_of(_hw, struct mpfs_ccc_pll_hw_clock, hw)
  56
  57 /*
  58  * mpfs_ccc_lock prevents anything else from writing to a fabric ccc
  59  * while a software locked register is being written.
  60  */
  61 static DEFINE_SPINLOCK(mpfs_ccc_lock);
  62
  63 static const struct clk_parent_data mpfs_ccc_pll0_refs[] = {
  64         { .fw_name = "pll0_ref0" },
  65         { .fw_name = "pll0_ref1" },
  66 };
  67
  68 static const struct clk_parent_data mpfs_ccc_pll1_refs[] = {
  69         { .fw_name = "pll1_ref0" },
  70         { .fw_name = "pll1_ref1" },
  71 };
  72
  73 static unsigned long mpfs_ccc_pll_recalc_rate(struct clk_hw *hw, unsigned long prate)
  74 {
  75         struct mpfs_ccc_pll_hw_clock *ccc_hw = to_mpfs_ccc_clk(hw);
  76         void __iomem *mult_addr = ccc_hw->base + ccc_hw->reg_offset;
  77         void __iomem *ref_div_addr = ccc_hw->base + MPFS_CCC_REF_CR;
  78         u32 mult, ref_div;
  79
  80         mult = readl_relaxed(mult_addr) >> MPFS_CCC_FBDIV_SHIFT;
  81         mult &= clk_div_mask(MPFS_CCC_FBDIV_WIDTH);
  82         ref_div = readl_relaxed(ref_div_addr) >> MPFS_CCC_REFDIV_SHIFT;
  83         ref_div &= clk_div_mask(MPFS_CCC_REFDIV_WIDTH);
  84
  85         return prate * mult / (ref_div * MPFS_CCC_FIXED_DIV);
  86 }
  87
  88 static u8 mpfs_ccc_pll_get_parent(struct clk_hw *hw)
  89 {
  90         struct mpfs_ccc_pll_hw_clock *ccc_hw = to_mpfs_ccc_clk(hw);
  91         void __iomem *pll_cr_addr = ccc_hw->base + MPFS_CCC_PLL_CR;
  92
  93         return !!(readl_relaxed(pll_cr_addr) & MPFS_CCC_REFCLK_SEL);
  94 }
  95
  96 static const struct clk_ops mpfs_ccc_pll_ops = {
  97         .recalc_rate = mpfs_ccc_pll_recalc_rate,
  98         .get_parent = mpfs_ccc_pll_get_parent,
  99 };
 100
 101 #define CLK_CCC_PLL(_id, _parents, _shift, _width, _flags, _offset) {   \
 102         .id = _id,                                                      \
 103         .shift = _shift,                                                \
 104         .width = _width,                                                \
 105         .reg_offset = _offset,                                          \
 106         .flags = _flags,                                                \
 107         .parents = _parents,                                            \
 108 }
 109
 110 static struct mpfs_ccc_pll_hw_clock mpfs_ccc_pll_clks[] = {
 111         CLK_CCC_PLL(CLK_CCC_PLL0, mpfs_ccc_pll0_refs, MPFS_CCC_FBDIV_SHIFT,
 112                     MPFS_CCC_FBDIV_WIDTH, 0, MPFS_CCC_SSCG_2_CR),
 113         CLK_CCC_PLL(CLK_CCC_PLL1, mpfs_ccc_pll1_refs, MPFS_CCC_FBDIV_SHIFT,
 114                     MPFS_CCC_FBDIV_WIDTH, 0, MPFS_CCC_SSCG_2_CR),
 115 };
 116
 117 struct mpfs_ccc_out_hw_clock {
 118         struct clk_divider divider;
 119         struct clk_init_data init;
 120         unsigned int id;
 121         u32 reg_offset;
 122 };
 123
 124 #define CLK_CCC_OUT(_id, _shift, _width, _flags, _offset) {     \
 125         .id = _id,                                              \
 126         .divider.shift = _shift,                                \
 127         .divider.width = _width,                                \
 128         .reg_offset = _offset,                                  \
 129         .divider.flags = _flags,                                \
 130         .divider.lock = &mpfs_ccc_lock,                         \
 131 }
 132
 133 static struct mpfs_ccc_out_hw_clock mpfs_ccc_pll0out_clks[] = {
 134         CLK_CCC_OUT(CLK_CCC_PLL0_OUT0, MPFS_CCC_POSTDIV0_SHIFT, MPFS_CCC_POSTDIV_WIDTH,
 135                     CLK_DIVIDER_ONE_BASED, MPFS_CCC_POSTDIV01_CR),
 136         CLK_CCC_OUT(CLK_CCC_PLL0_OUT1, MPFS_CCC_POSTDIV1_SHIFT, MPFS_CCC_POSTDIV_WIDTH,
 137                     CLK_DIVIDER_ONE_BASED, MPFS_CCC_POSTDIV01_CR),
 138         CLK_CCC_OUT(CLK_CCC_PLL0_OUT2, MPFS_CCC_POSTDIV2_SHIFT, MPFS_CCC_POSTDIV_WIDTH,
 139                     CLK_DIVIDER_ONE_BASED, MPFS_CCC_POSTDIV23_CR),
 140         CLK_CCC_OUT(CLK_CCC_PLL0_OUT3, MPFS_CCC_POSTDIV3_SHIFT, MPFS_CCC_POSTDIV_WIDTH,
 141                     CLK_DIVIDER_ONE_BASED, MPFS_CCC_POSTDIV23_CR),
 142 };
 143
 144 static struct mpfs_ccc_out_hw_clock mpfs_ccc_pll1out_clks[] = {
 145         CLK_CCC_OUT(CLK_CCC_PLL1_OUT0, MPFS_CCC_POSTDIV0_SHIFT, MPFS_CCC_POSTDIV_WIDTH,
 146                     CLK_DIVIDER_ONE_BASED, MPFS_CCC_POSTDIV01_CR),
 147         CLK_CCC_OUT(CLK_CCC_PLL1_OUT1, MPFS_CCC_POSTDIV1_SHIFT, MPFS_CCC_POSTDIV_WIDTH,
 148                     CLK_DIVIDER_ONE_BASED, MPFS_CCC_POSTDIV01_CR),
 149         CLK_CCC_OUT(CLK_CCC_PLL1_OUT2, MPFS_CCC_POSTDIV2_SHIFT, MPFS_CCC_POSTDIV_WIDTH,
 150                     CLK_DIVIDER_ONE_BASED, MPFS_CCC_POSTDIV23_CR),
 151         CLK_CCC_OUT(CLK_CCC_PLL1_OUT3, MPFS_CCC_POSTDIV3_SHIFT, MPFS_CCC_POSTDIV_WIDTH,
 152                     CLK_DIVIDER_ONE_BASED, MPFS_CCC_POSTDIV23_CR),
 153 };
 154
 155 static struct mpfs_ccc_out_hw_clock *mpfs_ccc_pllout_clks[] = {
 156         mpfs_ccc_pll0out_clks, mpfs_ccc_pll1out_clks
 157 };
 158
 159 static int mpfs_ccc_register_outputs(struct device *dev, struct mpfs_ccc_out_hw_clock *out_hws,
 160                                      unsigned int num_clks, struct mpfs_ccc_data *data,
 161                                      struct mpfs_ccc_pll_hw_clock *parent)
 162 {
 163         int ret;
 164
 165         for (unsigned int i = 0; i < num_clks; i++) {
 166                 struct mpfs_ccc_out_hw_clock *out_hw = &out_hws[i];
 167                 char *name = devm_kzalloc(dev, 23, GFP_KERNEL);
 168
 169                 snprintf(name, 23, "%s_out%u", parent->name, i);
 170                 out_hw->divider.hw.init = CLK_HW_INIT_HW(name, &parent->hw, &clk_divider_ops, 0);
 171                 out_hw->divider.reg = data->pll_base[i / MPFS_CCC_OUTPUTS_PER_PLL] +
 172                         out_hw->reg_offset;
 173
 174                 ret = devm_clk_hw_register(dev, &out_hw->divider.hw);
 175                 if (ret)
 176                         return dev_err_probe(dev, ret, "failed to register clock id: %d\n",
 177                                              out_hw->id);
 178
 179                 data->hw_data.hws[out_hw->id] = &out_hw->divider.hw;
 180         }
 181
 182         return 0;
 183 }
 184
 185 #define CLK_HW_INIT_PARENTS_DATA_FIXED_SIZE(_name, _parents, _ops, _flags)      \
 186         (&(struct clk_init_data) {                                              \
 187                 .flags          = _flags,                                       \
 188                 .name           = _name,                                        \
 189                 .parent_data    = _parents,                                     \
 190                 .num_parents    = MPFS_CCC_REFS_PER_PLL,                        \
 191                 .ops            = _ops,                                         \
 192         })
 193
 194 static int mpfs_ccc_register_plls(struct device *dev, struct mpfs_ccc_pll_hw_clock *pll_hws,
 195                                   unsigned int num_clks, struct mpfs_ccc_data *data)
 196 {
 197         int ret;
 198
 199         for (unsigned int i = 0; i < num_clks; i++) {
 200                 struct mpfs_ccc_pll_hw_clock *pll_hw = &pll_hws[i];
 201                 char *name = devm_kzalloc(dev, 18, GFP_KERNEL);
 202
 203                 pll_hw->base = data->pll_base[i];
 204                 snprintf(name, 18, "ccc%s_pll%u", strchrnul(dev->of_node->full_name, '@'), i);
 205                 pll_hw->name = (const char *)name;
 206                 pll_hw->hw.init = CLK_HW_INIT_PARENTS_DATA_FIXED_SIZE(pll_hw->name,
 207                                                                       pll_hw->parents,
 208                                                                       &mpfs_ccc_pll_ops, 0);
 209
 210                 ret = devm_clk_hw_register(dev, &pll_hw->hw);
 211                 if (ret)
 212                         return dev_err_probe(dev, ret, "failed to register ccc id: %d\n",
 213                                              pll_hw->id);
 214
 215                 data->hw_data.hws[pll_hw->id] = &pll_hw->hw;
 216
 217                 ret = mpfs_ccc_register_outputs(dev, mpfs_ccc_pllout_clks[i],
 218                                                 MPFS_CCC_OUTPUTS_PER_PLL, data, pll_hw);
 219                 if (ret)
 220                         return ret;
 221         }
 222
 223         return 0;
 224 }
 225
 226 static int mpfs_ccc_probe(struct platform_device *pdev)
 227 {
 228         struct mpfs_ccc_data *clk_data;
 229         void __iomem *pll_base[ARRAY_SIZE(mpfs_ccc_pll_clks)];
 230         unsigned int num_clks;
 231         int ret;
 232
 233         num_clks = ARRAY_SIZE(mpfs_ccc_pll_clks) + ARRAY_SIZE(mpfs_ccc_pll0out_clks) +
 234                    ARRAY_SIZE(mpfs_ccc_pll1out_clks);
 235
 236         clk_data = devm_kzalloc(&pdev->dev, struct_size(clk_data, hw_data.hws, num_clks),
 237                                 GFP_KERNEL);
 238         if (!clk_data)
 239                 return -ENOMEM;
 240
 241         pll_base[0] = devm_platform_ioremap_resource(pdev, 0);
 242         if (IS_ERR(pll_base[0]))
 243                 return PTR_ERR(pll_base[0]);
 244
 245         pll_base[1] = devm_platform_ioremap_resource(pdev, 1);
 246         if (IS_ERR(pll_base[1]))
 247                 return PTR_ERR(pll_base[1]);
 248
 249         clk_data->pll_base = pll_base;
 250         clk_data->hw_data.num = num_clks;
 251         clk_data->dev = &pdev->dev;
 252
 253         ret = mpfs_ccc_register_plls(clk_data->dev, mpfs_ccc_pll_clks,
 254                                      ARRAY_SIZE(mpfs_ccc_pll_clks), clk_data);
 255         if (ret)
 256                 return ret;
 257
 258         return devm_of_clk_add_hw_provider(clk_data->dev, of_clk_hw_onecell_get,
 259                                            &clk_data->hw_data);
 260 }
 261
 262 static const struct of_device_id mpfs_ccc_of_match_table[] = {
 263         { .compatible = "microchip,mpfs-ccc", },
 264         {}
 265 };
 266 MODULE_DEVICE_TABLE(of, mpfs_ccc_of_match_table);
 267
 268 static struct platform_driver mpfs_ccc_driver = {
 269         .probe = mpfs_ccc_probe,
 270         .driver = {
 271                 .name = "microchip-mpfs-ccc",
 272                 .of_match_table = mpfs_ccc_of_match_table,
 273         },
 274 };
 275
 276 static int __init clk_ccc_init(void)
 277 {
 278         return platform_driver_register(&mpfs_ccc_driver);
 279 }
 280 core_initcall(clk_ccc_init);
 281
 282 static void __exit clk_ccc_exit(void)
 283 {
 284         platform_driver_unregister(&mpfs_ccc_driver);
 285 }
 286 module_exit(clk_ccc_exit);
 287
 288 MODULE_DESCRIPTION("Microchip PolarFire SoC Clock Conditioning Circuitry Driver");
 289 MODULE_AUTHOR("Conor Dooley <conor.dooley@microchip.com>");
 290 MODULE_LICENSE("GPL");