drivers/clk/samsung/clk.c

   1 /*
   2  * Copyright (c) 2013 Samsung Electronics Co., Ltd.
   3  * Copyright (c) 2013 Linaro Ltd.
   4  * Author: Thomas Abraham <thomas.ab@samsung.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This file includes utility functions to register clocks to common
  11  * clock framework for Samsung platforms.
  12 */
  13
  14 #include <linux/syscore_ops.h>
  15 #include "clk.h"
  16
  17 static DEFINE_SPINLOCK(lock);
  18 static struct clk **clk_table;
  19 static void __iomem *reg_base;
  20 #ifdef CONFIG_OF
  21 static struct clk_onecell_data clk_data;
  22 #endif
  23
  24 #ifdef CONFIG_PM_SLEEP
  25 void samsung_clk_save(void __iomem *base,
  26                                     struct samsung_clk_reg_dump *rd,
  27                                     unsigned int num_regs)
  28 {
  29         for (; num_regs > 0; --num_regs, ++rd)
  30                 rd->value = readl(base + rd->offset);
  31 }
  32
  33 void samsung_clk_restore(void __iomem *base,
  34                                       const struct samsung_clk_reg_dump *rd,
  35                                       unsigned int num_regs)
  36 {
  37         for (; num_regs > 0; --num_regs, ++rd)
  38                 writel(rd->value, base + rd->offset);
  39 }
  40
  41 struct samsung_clk_reg_dump *samsung_clk_alloc_reg_dump(
  42                                                 const unsigned long *rdump,
  43                                                 unsigned long nr_rdump)
  44 {
  45         struct samsung_clk_reg_dump *rd;
  46         unsigned int i;
  47
  48         rd = kcalloc(nr_rdump, sizeof(*rd), GFP_KERNEL);
  49         if (!rd)
  50                 return NULL;
  51
  52         for (i = 0; i < nr_rdump; ++i)
  53                 rd[i].offset = rdump[i];
  54
  55         return rd;
  56 }
  57
  58 static struct samsung_clk_reg_dump *reg_dump;
  59 static unsigned long nr_reg_dump;
  60
  61 static int samsung_clk_suspend(void)
  62 {
  63         struct samsung_clk_reg_dump *rd = reg_dump;
  64         unsigned long i;
  65
  66         for (i = 0; i < nr_reg_dump; i++, rd++)
  67                 rd->value = __raw_readl(reg_base + rd->offset);
  68
  69         return 0;
  70 }
  71
  72 static void samsung_clk_resume(void)
  73 {
  74         struct samsung_clk_reg_dump *rd = reg_dump;
  75         unsigned long i;
  76
  77         for (i = 0; i < nr_reg_dump; i++, rd++)
  78                 __raw_writel(rd->value, reg_base + rd->offset);
  79 }
  80
  81 static struct syscore_ops samsung_clk_syscore_ops = {
  82         .suspend        = samsung_clk_suspend,
  83         .resume         = samsung_clk_resume,
  84 };
  85 #endif /* CONFIG_PM_SLEEP */
  86
  87 /* setup the essentials required to support clock lookup using ccf */
  88 void __init samsung_clk_init(struct device_node *np, void __iomem *base,
  89                 unsigned long nr_clks, unsigned long *rdump,
  90                 unsigned long nr_rdump, unsigned long *soc_rdump,
  91                 unsigned long nr_soc_rdump)
  92 {
  93         reg_base = base;
  94
  95 #ifdef CONFIG_PM_SLEEP
  96         if (rdump && nr_rdump) {
  97                 unsigned int idx;
  98                 reg_dump = kzalloc(sizeof(struct samsung_clk_reg_dump)
  99                                 * (nr_rdump + nr_soc_rdump), GFP_KERNEL);
 100                 if (!reg_dump) {
 101                         pr_err("%s: memory alloc for register dump failed\n",
 102                                         __func__);
 103                         return;
 104                 }
 105
 106                 for (idx = 0; idx < nr_rdump; idx++)
 107                         reg_dump[idx].offset = rdump[idx];
 108                 for (idx = 0; idx < nr_soc_rdump; idx++)
 109                         reg_dump[nr_rdump + idx].offset = soc_rdump[idx];
 110                 nr_reg_dump = nr_rdump + nr_soc_rdump;
 111                 register_syscore_ops(&samsung_clk_syscore_ops);
 112         }
 113 #endif
 114
 115         clk_table = kzalloc(sizeof(struct clk *) * nr_clks, GFP_KERNEL);
 116         if (!clk_table)
 117                 panic("could not allocate clock lookup table\n");
 118
 119         if (!np)
 120                 return;
 121
 122 #ifdef CONFIG_OF
 123         clk_data.clks = clk_table;
 124         clk_data.clk_num = nr_clks;
 125         of_clk_add_provider(np, of_clk_src_onecell_get, &clk_data);
 126 #endif
 127 }
 128
 129 /* add a clock instance to the clock lookup table used for dt based lookup */
 130 void samsung_clk_add_lookup(struct clk *clk, unsigned int id)
 131 {
 132         if (clk_table && id)
 133                 clk_table[id] = clk;
 134 }
 135
 136 /* register a list of aliases */
 137 void __init samsung_clk_register_alias(struct samsung_clock_alias *list,
 138                                         unsigned int nr_clk)
 139 {
 140         struct clk *clk;
 141         unsigned int idx, ret;
 142
 143         if (!clk_table) {
 144                 pr_err("%s: clock table missing\n", __func__);
 145                 return;
 146         }
 147
 148         for (idx = 0; idx < nr_clk; idx++, list++) {
 149                 if (!list->id) {
 150                         pr_err("%s: clock id missing for index %d\n", __func__,
 151                                 idx);
 152                         continue;
 153                 }
 154
 155                 clk = clk_table[list->id];
 156                 if (!clk) {
 157                         pr_err("%s: failed to find clock %d\n", __func__,
 158                                 list->id);
 159                         continue;
 160                 }
 161
 162                 ret = clk_register_clkdev(clk, list->alias, list->dev_name);
 163                 if (ret)
 164                         pr_err("%s: failed to register lookup %s\n",
 165                                         __func__, list->alias);
 166         }
 167 }
 168
 169 /* register a list of fixed clocks */
 170 void __init samsung_clk_register_fixed_rate(
 171                 struct samsung_fixed_rate_clock *list, unsigned int nr_clk)
 172 {
 173         struct clk *clk;
 174         unsigned int idx, ret;
 175
 176         for (idx = 0; idx < nr_clk; idx++, list++) {
 177                 clk = clk_register_fixed_rate(NULL, list->name,
 178                         list->parent_name, list->flags, list->fixed_rate);
 179                 if (IS_ERR(clk)) {
 180                         pr_err("%s: failed to register clock %s\n", __func__,
 181                                 list->name);
 182                         continue;
 183                 }
 184
 185                 samsung_clk_add_lookup(clk, list->id);
 186
 187                 /*
 188                  * Unconditionally add a clock lookup for the fixed rate clocks.
 189                  * There are not many of these on any of Samsung platforms.
 190                  */
 191                 ret = clk_register_clkdev(clk, list->name, NULL);
 192                 if (ret)
 193                         pr_err("%s: failed to register clock lookup for %s",
 194                                 __func__, list->name);
 195         }
 196 }
 197
 198 /* register a list of fixed factor clocks */
 199 void __init samsung_clk_register_fixed_factor(
 200                 struct samsung_fixed_factor_clock *list, unsigned int nr_clk)
 201 {
 202         struct clk *clk;
 203         unsigned int idx;
 204
 205         for (idx = 0; idx < nr_clk; idx++, list++) {
 206                 clk = clk_register_fixed_factor(NULL, list->name,
 207                         list->parent_name, list->flags, list->mult, list->div);
 208                 if (IS_ERR(clk)) {
 209                         pr_err("%s: failed to register clock %s\n", __func__,
 210                                 list->name);
 211                         continue;
 212                 }
 213
 214                 samsung_clk_add_lookup(clk, list->id);
 215         }
 216 }
 217
 218 /* register a list of mux clocks */
 219 void __init samsung_clk_register_mux(struct samsung_mux_clock *list,
 220                                         unsigned int nr_clk)
 221 {
 222         struct clk *clk;
 223         unsigned int idx, ret;
 224
 225         for (idx = 0; idx < nr_clk; idx++, list++) {
 226                 clk = clk_register_mux(NULL, list->name, list->parent_names,
 227                         list->num_parents, list->flags, reg_base + list->offset,
 228                         list->shift, list->width, list->mux_flags, &lock);
 229                 if (IS_ERR(clk)) {
 230                         pr_err("%s: failed to register clock %s\n", __func__,
 231                                 list->name);
 232                         continue;
 233                 }
 234
 235                 samsung_clk_add_lookup(clk, list->id);
 236
 237                 /* register a clock lookup only if a clock alias is specified */
 238                 if (list->alias) {
 239                         ret = clk_register_clkdev(clk, list->alias,
 240                                                 list->dev_name);
 241                         if (ret)
 242                                 pr_err("%s: failed to register lookup %s\n",
 243                                                 __func__, list->alias);
 244                 }
 245         }
 246 }
 247
 248 /* register a list of div clocks */
 249 void __init samsung_clk_register_div(struct samsung_div_clock *list,
 250                                         unsigned int nr_clk)
 251 {
 252         struct clk *clk;
 253         unsigned int idx, ret;
 254
 255         for (idx = 0; idx < nr_clk; idx++, list++) {
 256                 if (list->table)
 257                         clk = clk_register_divider_table(NULL, list->name,
 258                                         list->parent_name, list->flags,
 259                                         reg_base + list->offset, list->shift,
 260                                         list->width, list->div_flags,
 261                                         list->table, &lock);
 262                 else
 263                         clk = clk_register_divider(NULL, list->name,
 264                                         list->parent_name, list->flags,
 265                                         reg_base + list->offset, list->shift,
 266                                         list->width, list->div_flags, &lock);
 267                 if (IS_ERR(clk)) {
 268                         pr_err("%s: failed to register clock %s\n", __func__,
 269                                 list->name);
 270                         continue;
 271                 }
 272
 273                 samsung_clk_add_lookup(clk, list->id);
 274
 275                 /* register a clock lookup only if a clock alias is specified */
 276                 if (list->alias) {
 277                         ret = clk_register_clkdev(clk, list->alias,
 278                                                 list->dev_name);
 279                         if (ret)
 280                                 pr_err("%s: failed to register lookup %s\n",
 281                                                 __func__, list->alias);
 282                 }
 283         }
 284 }
 285
 286 /* register a list of gate clocks */
 287 void __init samsung_clk_register_gate(struct samsung_gate_clock *list,
 288                                                 unsigned int nr_clk)
 289 {
 290         struct clk *clk;
 291         unsigned int idx, ret;
 292
 293         for (idx = 0; idx < nr_clk; idx++, list++) {
 294                 clk = clk_register_gate(NULL, list->name, list->parent_name,
 295                                 list->flags, reg_base + list->offset,
 296                                 list->bit_idx, list->gate_flags, &lock);
 297                 if (IS_ERR(clk)) {
 298                         pr_err("%s: failed to register clock %s\n", __func__,
 299                                 list->name);
 300                         continue;
 301                 }
 302
 303                 /* register a clock lookup only if a clock alias is specified */
 304                 if (list->alias) {
 305                         ret = clk_register_clkdev(clk, list->alias,
 306                                                         list->dev_name);
 307                         if (ret)
 308                                 pr_err("%s: failed to register lookup %s\n",
 309                                         __func__, list->alias);
 310                 }
 311
 312                 samsung_clk_add_lookup(clk, list->id);
 313         }
 314 }
 315
 316 /*
 317  * obtain the clock speed of all external fixed clock sources from device
 318  * tree and register it
 319  */
 320 #ifdef CONFIG_OF
 321 void __init samsung_clk_of_register_fixed_ext(
 322                         struct samsung_fixed_rate_clock *fixed_rate_clk,
 323                         unsigned int nr_fixed_rate_clk,
 324                         struct of_device_id *clk_matches)
 325 {
 326         const struct of_device_id *match;
 327         struct device_node *np;
 328         u32 freq;
 329
 330         for_each_matching_node_and_match(np, clk_matches, &match) {
 331                 if (of_property_read_u32(np, "clock-frequency", &freq))
 332                         continue;
 333                 fixed_rate_clk[(u32)match->data].fixed_rate = freq;
 334         }
 335         samsung_clk_register_fixed_rate(fixed_rate_clk, nr_fixed_rate_clk);
 336 }
 337 #endif
 338
 339 /* utility function to get the rate of a specified clock */
 340 unsigned long _get_rate(const char *clk_name)
 341 {
 342         struct clk *clk;
 343
 344         clk = __clk_lookup(clk_name);
 345         if (!clk) {
 346                 pr_err("%s: could not find clock %s\n", __func__, clk_name);
 347                 return 0;
 348         }
 349
 350         return clk_get_rate(clk);
 351 }