drivers/clk/clk-mux.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2019 DENX Software Engineering
   4  * Lukasz Majewski, DENX Software Engineering, lukma@denx.de
   5  *
   6  * Copyright (C) 2011 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>
   7  * Copyright (C) 2011 Richard Zhao, Linaro <richard.zhao@linaro.org>
   8  * Copyright (C) 2011-2012 Mike Turquette, Linaro Ltd <mturquette@linaro.org>
   9  *
  10  * Simple multiplexer clock implementation
  11  */
  12
  13 /*
  14  * U-Boot CCF porting node:
  15  *
  16  * The Linux kernel - as of tag: 5.0-rc3 is using also the imx_clk_fixup_mux()
  17  * version of CCF mux. It is used on e.g. imx6q to provide fixes (like
  18  * imx_cscmr1_fixup) for broken HW.
  19  *
  20  * At least for IMX6Q (but NOT IMX6QP) it is important when we set the parent
  21  * clock.
  22  */
  23
  24 #include <common.h>
  25 #include <asm/io.h>
  26 #include <malloc.h>
  27 #include <clk-uclass.h>
  28 #include <dm/device.h>
  29 #include <dm/devres.h>
  30 #include <linux/bitops.h>
  31 #include <linux/clk-provider.h>
  32 #include <clk.h>
  33 #include "clk.h"
  34 #include <linux/err.h>
  35
  36 #define UBOOT_DM_CLK_CCF_MUX "ccf_clk_mux"
  37
  38 int clk_mux_val_to_index(struct clk *clk, u32 *table, unsigned int flags,
  39                          unsigned int val)
  40 {
  41         struct clk_mux *mux = to_clk_mux(clk);
  42         int num_parents = mux->num_parents;
  43
  44         if (table) {
  45                 int i;
  46
  47                 for (i = 0; i < num_parents; i++)
  48                         if (table[i] == val)
  49                                 return i;
  50                 return -EINVAL;
  51         }
  52
  53         if (val && (flags & CLK_MUX_INDEX_BIT))
  54                 val = ffs(val) - 1;
  55
  56         if (val && (flags & CLK_MUX_INDEX_ONE))
  57                 val--;
  58
  59         if (val >= num_parents)
  60                 return -EINVAL;
  61
  62         return val;
  63 }
  64
  65 unsigned int clk_mux_index_to_val(u32 *table, unsigned int flags, u8 index)
  66 {
  67         unsigned int val = index;
  68
  69         if (table) {
  70                 val = table[index];
  71         } else {
  72                 if (flags & CLK_MUX_INDEX_BIT)
  73                         val = 1 << index;
  74
  75                 if (flags & CLK_MUX_INDEX_ONE)
  76                         val++;
  77         }
  78
  79         return val;
  80 }
  81
  82 u8 clk_mux_get_parent(struct clk *clk)
  83 {
  84         struct clk_mux *mux = to_clk_mux(clk);
  85         u32 val;
  86
  87 #if CONFIG_IS_ENABLED(SANDBOX_CLK_CCF)
  88         val = mux->io_mux_val;
  89 #else
  90         val = readl(mux->reg);
  91 #endif
  92         val >>= mux->shift;
  93         val &= mux->mask;
  94
  95         return clk_mux_val_to_index(clk, mux->table, mux->flags, val);
  96 }
  97
  98 static int clk_fetch_parent_index(struct clk *clk,
  99                                   struct clk *parent)
 100 {
 101         struct clk_mux *mux = to_clk_mux(clk);
 102
 103         int i;
 104
 105         if (!parent)
 106                 return -EINVAL;
 107
 108         for (i = 0; i < mux->num_parents; i++) {
 109                 if (!strcmp(parent->dev->name, mux->parent_names[i]))
 110                         return i;
 111         }
 112
 113         return -EINVAL;
 114 }
 115
 116 static int clk_mux_set_parent(struct clk *clk, struct clk *parent)
 117 {
 118         struct clk_mux *mux = to_clk_mux(clk);
 119         int index;
 120         u32 val;
 121         u32 reg;
 122
 123         index = clk_fetch_parent_index(clk, parent);
 124         if (index < 0) {
 125                 printf("Could not fetch index\n");
 126                 return index;
 127         }
 128
 129         val = clk_mux_index_to_val(mux->table, mux->flags, index);
 130
 131         if (mux->flags & CLK_MUX_HIWORD_MASK) {
 132                 reg = mux->mask << (mux->shift + 16);
 133         } else {
 134                 reg = readl(mux->reg);
 135                 reg &= ~(mux->mask << mux->shift);
 136         }
 137         val = val << mux->shift;
 138         reg |= val;
 139         writel(reg, mux->reg);
 140
 141         return 0;
 142 }
 143
 144 const struct clk_ops clk_mux_ops = {
 145         .get_rate = clk_generic_get_rate,
 146         .set_parent = clk_mux_set_parent,
 147 };
 148
 149 struct clk *clk_hw_register_mux_table(struct device *dev, const char *name,
 150                 const char * const *parent_names, u8 num_parents,
 151                 unsigned long flags,
 152                 void __iomem *reg, u8 shift, u32 mask,
 153                 u8 clk_mux_flags, u32 *table)
 154 {
 155         struct clk_mux *mux;
 156         struct clk *clk;
 157         u8 width = 0;
 158         int ret;
 159
 160         if (clk_mux_flags & CLK_MUX_HIWORD_MASK) {
 161                 width = fls(mask) - ffs(mask) + 1;
 162                 if (width + shift > 16) {
 163                         pr_err("mux value exceeds LOWORD field\n");
 164                         return ERR_PTR(-EINVAL);
 165                 }
 166         }
 167
 168         /* allocate the mux */
 169         mux = kzalloc(sizeof(*mux), GFP_KERNEL);
 170         if (!mux)
 171                 return ERR_PTR(-ENOMEM);
 172
 173         /* U-boot specific assignments */
 174         mux->parent_names = parent_names;
 175         mux->num_parents = num_parents;
 176
 177         /* struct clk_mux assignments */
 178         mux->reg = reg;
 179         mux->shift = shift;
 180         mux->mask = mask;
 181         mux->flags = clk_mux_flags;
 182         mux->table = table;
 183 #if CONFIG_IS_ENABLED(SANDBOX_CLK_CCF)
 184         mux->io_mux_val = *(u32 *)reg;
 185 #endif
 186
 187         clk = &mux->clk;
 188
 189         /*
 190          * Read the current mux setup - so we assign correct parent.
 191          *
 192          * Changing parent would require changing internals of udevice struct
 193          * for the corresponding clock (to do that define .set_parent() method.
 194          */
 195         ret = clk_register(clk, UBOOT_DM_CLK_CCF_MUX, name,
 196                            parent_names[clk_mux_get_parent(clk)]);
 197         if (ret) {
 198                 kfree(mux);
 199                 return ERR_PTR(ret);
 200         }
 201
 202         return clk;
 203 }
 204
 205 struct clk *clk_register_mux_table(struct device *dev, const char *name,
 206                 const char * const *parent_names, u8 num_parents,
 207                 unsigned long flags,
 208                 void __iomem *reg, u8 shift, u32 mask,
 209                 u8 clk_mux_flags, u32 *table)
 210 {
 211         struct clk *clk;
 212
 213         clk = clk_hw_register_mux_table(dev, name, parent_names, num_parents,
 214                                        flags, reg, shift, mask, clk_mux_flags,
 215                                        table);
 216         if (IS_ERR(clk))
 217                 return ERR_CAST(clk);
 218         return clk;
 219 }
 220
 221 struct clk *clk_register_mux(struct device *dev, const char *name,
 222                 const char * const *parent_names, u8 num_parents,
 223                 unsigned long flags,
 224                 void __iomem *reg, u8 shift, u8 width,
 225                 u8 clk_mux_flags)
 226 {
 227         u32 mask = BIT(width) - 1;
 228
 229         return clk_register_mux_table(dev, name, parent_names, num_parents,
 230                                       flags, reg, shift, mask, clk_mux_flags,
 231                                       NULL);
 232 }
 233
 234 U_BOOT_DRIVER(ccf_clk_mux) = {
 235         .name   = UBOOT_DM_CLK_CCF_MUX,
 236         .id     = UCLASS_CLK,
 237         .ops    = &clk_mux_ops,
 238         .flags = DM_FLAG_PRE_RELOC,
 239 };