drivers/clk/ti/clk.c

   1 /*
   2  * TI clock support
   3  *
   4  * Copyright (C) 2013 Texas Instruments, Inc.
   5  *
   6  * Tero Kristo <t-kristo@ti.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  * This program is distributed "as is" WITHOUT ANY WARRANTY of any
  13  * kind, whether express or implied; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #include <linux/clk-provider.h>
  19 #include <linux/clkdev.h>
  20 #include <linux/clk/ti.h>
  21 #include <linux/of.h>
  22 #include <linux/of_address.h>
  23 #include <linux/list.h>
  24 #include <linux/regmap.h>
  25 #include <linux/bootmem.h>
  26
  27 #include "clock.h"
  28
  29 #undef pr_fmt
  30 #define pr_fmt(fmt) "%s: " fmt, __func__
  31
  32 struct ti_clk_ll_ops *ti_clk_ll_ops;
  33 static struct device_node *clocks_node_ptr[CLK_MAX_MEMMAPS];
  34
  35 struct ti_clk_features ti_clk_features;
  36
  37 struct clk_iomap {
  38         struct regmap *regmap;
  39         void __iomem *mem;
  40 };
  41
  42 static struct clk_iomap *clk_memmaps[CLK_MAX_MEMMAPS];
  43
  44 static void clk_memmap_writel(u32 val, void __iomem *reg)
  45 {
  46         struct clk_omap_reg *r = (struct clk_omap_reg *)&reg;
  47         struct clk_iomap *io = clk_memmaps[r->index];
  48
  49         if (io->regmap)
  50                 regmap_write(io->regmap, r->offset, val);
  51         else
  52                 writel_relaxed(val, io->mem + r->offset);
  53 }
  54
  55 static u32 clk_memmap_readl(void __iomem *reg)
  56 {
  57         u32 val;
  58         struct clk_omap_reg *r = (struct clk_omap_reg *)&reg;
  59         struct clk_iomap *io = clk_memmaps[r->index];
  60
  61         if (io->regmap)
  62                 regmap_read(io->regmap, r->offset, &val);
  63         else
  64                 val = readl_relaxed(io->mem + r->offset);
  65
  66         return val;
  67 }
  68
  69 /**
  70  * ti_clk_setup_ll_ops - setup low level clock operations
  71  * @ops: low level clock ops descriptor
  72  *
  73  * Sets up low level clock operations for TI clock driver. This is used
  74  * to provide various callbacks for the clock driver towards platform
  75  * specific code. Returns 0 on success, -EBUSY if ll_ops have been
  76  * registered already.
  77  */
  78 int ti_clk_setup_ll_ops(struct ti_clk_ll_ops *ops)
  79 {
  80         if (ti_clk_ll_ops) {
  81                 pr_err("Attempt to register ll_ops multiple times.\n");
  82                 return -EBUSY;
  83         }
  84
  85         ti_clk_ll_ops = ops;
  86         ops->clk_readl = clk_memmap_readl;
  87         ops->clk_writel = clk_memmap_writel;
  88
  89         return 0;
  90 }
  91
  92 /**
  93  * ti_dt_clocks_register - register DT alias clocks during boot
  94  * @oclks: list of clocks to register
  95  *
  96  * Register alias or non-standard DT clock entries during boot. By
  97  * default, DT clocks are found based on their node name. If any
  98  * additional con-id / dev-id -> clock mapping is required, use this
  99  * function to list these.
 100  */
 101 void __init ti_dt_clocks_register(struct ti_dt_clk oclks[])
 102 {
 103         struct ti_dt_clk *c;
 104         struct device_node *node;
 105         struct clk *clk;
 106         struct of_phandle_args clkspec;
 107
 108         for (c = oclks; c->node_name != NULL; c++) {
 109                 node = of_find_node_by_name(NULL, c->node_name);
 110                 clkspec.np = node;
 111                 clk = of_clk_get_from_provider(&clkspec);
 112
 113                 if (!IS_ERR(clk)) {
 114                         c->lk.clk = clk;
 115                         clkdev_add(&c->lk);
 116                 } else {
 117                         pr_warn("failed to lookup clock node %s\n",
 118                                 c->node_name);
 119                 }
 120         }
 121 }
 122
 123 struct clk_init_item {
 124         struct device_node *node;
 125         struct clk_hw *hw;
 126         ti_of_clk_init_cb_t func;
 127         struct list_head link;
 128 };
 129
 130 static LIST_HEAD(retry_list);
 131
 132 /**
 133  * ti_clk_retry_init - retries a failed clock init at later phase
 134  * @node: device not for the clock
 135  * @hw: partially initialized clk_hw struct for the clock
 136  * @func: init function to be called for the clock
 137  *
 138  * Adds a failed clock init to the retry list. The retry list is parsed
 139  * once all the other clocks have been initialized.
 140  */
 141 int __init ti_clk_retry_init(struct device_node *node, struct clk_hw *hw,
 142                               ti_of_clk_init_cb_t func)
 143 {
 144         struct clk_init_item *retry;
 145
 146         pr_debug("%s: adding to retry list...\n", node->name);
 147         retry = kzalloc(sizeof(*retry), GFP_KERNEL);
 148         if (!retry)
 149                 return -ENOMEM;
 150
 151         retry->node = node;
 152         retry->func = func;
 153         retry->hw = hw;
 154         list_add(&retry->link, &retry_list);
 155
 156         return 0;
 157 }
 158
 159 /**
 160  * ti_clk_get_reg_addr - get register address for a clock register
 161  * @node: device node for the clock
 162  * @index: register index from the clock node
 163  *
 164  * Builds clock register address from device tree information. This
 165  * is a struct of type clk_omap_reg. Returns a pointer to the register
 166  * address, or a pointer error value in failure.
 167  */
 168 void __iomem *ti_clk_get_reg_addr(struct device_node *node, int index)
 169 {
 170         struct clk_omap_reg *reg;
 171         u32 val;
 172         u32 tmp;
 173         int i;
 174
 175         reg = (struct clk_omap_reg *)&tmp;
 176
 177         for (i = 0; i < CLK_MAX_MEMMAPS; i++) {
 178                 if (clocks_node_ptr[i] == node->parent)
 179                         break;
 180         }
 181
 182         if (i == CLK_MAX_MEMMAPS) {
 183                 pr_err("clk-provider not found for %s!\n", node->name);
 184                 return IOMEM_ERR_PTR(-ENOENT);
 185         }
 186
 187         reg->index = i;
 188
 189         if (of_property_read_u32_index(node, "reg", index, &val)) {
 190                 pr_err("%s must have reg[%d]!\n", node->name, index);
 191                 return IOMEM_ERR_PTR(-EINVAL);
 192         }
 193
 194         reg->offset = val;
 195
 196         return (void __iomem *)tmp;
 197 }
 198
 199 /**
 200  * omap2_clk_provider_init - init master clock provider
 201  * @parent: master node
 202  * @index: internal index for clk_reg_ops
 203  * @syscon: syscon regmap pointer for accessing clock registers
 204  * @mem: iomem pointer for the clock provider memory area, only used if
 205  *       syscon is not provided
 206  *
 207  * Initializes a master clock IP block. This basically sets up the
 208  * mapping from clocks node to the memory map index. All the clocks
 209  * are then initialized through the common of_clk_init call, and the
 210  * clocks will access their memory maps based on the node layout.
 211  * Returns 0 in success.
 212  */
 213 int __init omap2_clk_provider_init(struct device_node *parent, int index,
 214                                    struct regmap *syscon, void __iomem *mem)
 215 {
 216         struct device_node *clocks;
 217         struct clk_iomap *io;
 218
 219         /* get clocks for this parent */
 220         clocks = of_get_child_by_name(parent, "clocks");
 221         if (!clocks) {
 222                 pr_err("%s missing 'clocks' child node.\n", parent->name);
 223                 return -EINVAL;
 224         }
 225
 226         /* add clocks node info */
 227         clocks_node_ptr[index] = clocks;
 228
 229         io = kzalloc(sizeof(*io), GFP_KERNEL);
 230
 231         io->regmap = syscon;
 232         io->mem = mem;
 233
 234         clk_memmaps[index] = io;
 235
 236         return 0;
 237 }
 238
 239 /**
 240  * omap2_clk_legacy_provider_init - initialize a legacy clock provider
 241  * @index: index for the clock provider
 242  * @mem: iomem pointer for the clock provider memory area
 243  *
 244  * Initializes a legacy clock provider memory mapping.
 245  */
 246 void __init omap2_clk_legacy_provider_init(int index, void __iomem *mem)
 247 {
 248         struct clk_iomap *io;
 249
 250         io = memblock_virt_alloc(sizeof(*io), 0);
 251
 252         io->mem = mem;
 253
 254         clk_memmaps[index] = io;
 255 }
 256
 257 /**
 258  * ti_dt_clk_init_retry_clks - init clocks from the retry list
 259  *
 260  * Initializes any clocks that have failed to initialize before,
 261  * reasons being missing parent node(s) during earlier init. This
 262  * typically happens only for DPLLs which need to have both of their
 263  * parent clocks ready during init.
 264  */
 265 void ti_dt_clk_init_retry_clks(void)
 266 {
 267         struct clk_init_item *retry;
 268         struct clk_init_item *tmp;
 269         int retries = 5;
 270
 271         while (!list_empty(&retry_list) && retries) {
 272                 list_for_each_entry_safe(retry, tmp, &retry_list, link) {
 273                         pr_debug("retry-init: %s\n", retry->node->name);
 274                         retry->func(retry->hw, retry->node);
 275                         list_del(&retry->link);
 276                         kfree(retry);
 277                 }
 278                 retries--;
 279         }
 280 }
 281
 282 #if defined(CONFIG_ARCH_OMAP3) && defined(CONFIG_ATAGS)
 283 void __init ti_clk_patch_legacy_clks(struct ti_clk **patch)
 284 {
 285         while (*patch) {
 286                 memcpy((*patch)->patch, *patch, sizeof(**patch));
 287                 patch++;
 288         }
 289 }
 290
 291 struct clk __init *ti_clk_register_clk(struct ti_clk *setup)
 292 {
 293         struct clk *clk;
 294         struct ti_clk_fixed *fixed;
 295         struct ti_clk_fixed_factor *fixed_factor;
 296         struct clk_hw *clk_hw;
 297
 298         if (setup->clk)
 299                 return setup->clk;
 300
 301         switch (setup->type) {
 302         case TI_CLK_FIXED:
 303                 fixed = setup->data;
 304
 305                 clk = clk_register_fixed_rate(NULL, setup->name, NULL,
 306                                               CLK_IS_ROOT, fixed->frequency);
 307                 break;
 308         case TI_CLK_MUX:
 309                 clk = ti_clk_register_mux(setup);
 310                 break;
 311         case TI_CLK_DIVIDER:
 312                 clk = ti_clk_register_divider(setup);
 313                 break;
 314         case TI_CLK_COMPOSITE:
 315                 clk = ti_clk_register_composite(setup);
 316                 break;
 317         case TI_CLK_FIXED_FACTOR:
 318                 fixed_factor = setup->data;
 319
 320                 clk = clk_register_fixed_factor(NULL, setup->name,
 321                                                 fixed_factor->parent,
 322                                                 0, fixed_factor->mult,
 323                                                 fixed_factor->div);
 324                 break;
 325         case TI_CLK_GATE:
 326                 clk = ti_clk_register_gate(setup);
 327                 break;
 328         case TI_CLK_DPLL:
 329                 clk = ti_clk_register_dpll(setup);
 330                 break;
 331         default:
 332                 pr_err("bad type for %s!\n", setup->name);
 333                 clk = ERR_PTR(-EINVAL);
 334         }
 335
 336         if (!IS_ERR(clk)) {
 337                 setup->clk = clk;
 338                 if (setup->clkdm_name) {
 339                         if (__clk_get_flags(clk) & CLK_IS_BASIC) {
 340                                 pr_warn("can't setup clkdm for basic clk %s\n",
 341                                         setup->name);
 342                         } else {
 343                                 clk_hw = __clk_get_hw(clk);
 344                                 to_clk_hw_omap(clk_hw)->clkdm_name =
 345                                         setup->clkdm_name;
 346                                 omap2_init_clk_clkdm(clk_hw);
 347                         }
 348                 }
 349         }
 350
 351         return clk;
 352 }
 353
 354 int __init ti_clk_register_legacy_clks(struct ti_clk_alias *clks)
 355 {
 356         struct clk *clk;
 357         bool retry;
 358         struct ti_clk_alias *retry_clk;
 359         struct ti_clk_alias *tmp;
 360
 361         while (clks->clk) {
 362                 clk = ti_clk_register_clk(clks->clk);
 363                 if (IS_ERR(clk)) {
 364                         if (PTR_ERR(clk) == -EAGAIN) {
 365                                 list_add(&clks->link, &retry_list);
 366                         } else {
 367                                 pr_err("register for %s failed: %ld\n",
 368                                        clks->clk->name, PTR_ERR(clk));
 369                                 return PTR_ERR(clk);
 370                         }
 371                 } else {
 372                         clks->lk.clk = clk;
 373                         clkdev_add(&clks->lk);
 374                 }
 375                 clks++;
 376         }
 377
 378         retry = true;
 379
 380         while (!list_empty(&retry_list) && retry) {
 381                 retry = false;
 382                 list_for_each_entry_safe(retry_clk, tmp, &retry_list, link) {
 383                         pr_debug("retry-init: %s\n", retry_clk->clk->name);
 384                         clk = ti_clk_register_clk(retry_clk->clk);
 385                         if (IS_ERR(clk)) {
 386                                 if (PTR_ERR(clk) == -EAGAIN) {
 387                                         continue;
 388                                 } else {
 389                                         pr_err("register for %s failed: %ld\n",
 390                                                retry_clk->clk->name,
 391                                                PTR_ERR(clk));
 392                                         return PTR_ERR(clk);
 393                                 }
 394                         } else {
 395                                 retry = true;
 396                                 retry_clk->lk.clk = clk;
 397                                 clkdev_add(&retry_clk->lk);
 398                                 list_del(&retry_clk->link);
 399                         }
 400                 }
 401         }
 402
 403         return 0;
 404 }
 405 #endif
 406
 407 /**
 408  * ti_clk_setup_features - setup clock features flags
 409  * @features: features definition to use
 410  *
 411  * Initializes the clock driver features flags based on platform
 412  * provided data. No return value.
 413  */
 414 void __init ti_clk_setup_features(struct ti_clk_features *features)
 415 {
 416         memcpy(&ti_clk_features, features, sizeof(*features));
 417 }
 418
 419 /**
 420  * ti_clk_get_features - get clock driver features flags
 421  *
 422  * Get TI clock driver features description. Returns a pointer
 423  * to the current feature setup.
 424  */
 425 const struct ti_clk_features *ti_clk_get_features(void)
 426 {
 427         return &ti_clk_features;
 428 }
 429
 430 /**
 431  * omap2_clk_enable_init_clocks - prepare & enable a list of clocks
 432  * @clk_names: ptr to an array of strings of clock names to enable
 433  * @num_clocks: number of clock names in @clk_names
 434  *
 435  * Prepare and enable a list of clocks, named by @clk_names.  No
 436  * return value. XXX Deprecated; only needed until these clocks are
 437  * properly claimed and enabled by the drivers or core code that uses
 438  * them.  XXX What code disables & calls clk_put on these clocks?
 439  */
 440 void omap2_clk_enable_init_clocks(const char **clk_names, u8 num_clocks)
 441 {
 442         struct clk *init_clk;
 443         int i;
 444
 445         for (i = 0; i < num_clocks; i++) {
 446                 init_clk = clk_get(NULL, clk_names[i]);
 447                 if (WARN(IS_ERR(init_clk), "could not find init clock %s\n",
 448                          clk_names[i]))
 449                         continue;
 450                 clk_prepare_enable(init_clk);
 451         }
 452 }