arch/arm/plat-omap/clock.c

   1 /*
   2  *  linux/arch/arm/plat-omap/clock.c
   3  *
   4  *  Copyright (C) 2004 - 2008 Nokia corporation
   5  *  Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
   6  *
   7  *  Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13 #include <linux/kernel.h>
  14 #include <linux/init.h>
  15 #include <linux/module.h>
  16 #include <linux/list.h>
  17 #include <linux/errno.h>
  18 #include <linux/err.h>
  19 #include <linux/string.h>
  20 #include <linux/clk.h>
  21 #include <linux/mutex.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/cpufreq.h>
  24 #include <linux/debugfs.h>
  25 #include <linux/io.h>
  26
  27 #include <mach/clock.h>
  28
  29 static LIST_HEAD(clocks);
  30 static DEFINE_MUTEX(clocks_mutex);
  31 static DEFINE_SPINLOCK(clockfw_lock);
  32
  33 static struct clk_functions *arch_clock;
  34
  35 /*-------------------------------------------------------------------------
  36  * Standard clock functions defined in include/linux/clk.h
  37  *-------------------------------------------------------------------------*/
  38
  39 int clk_enable(struct clk *clk)
  40 {
  41         unsigned long flags;
  42         int ret = 0;
  43
  44         if (clk == NULL || IS_ERR(clk))
  45                 return -EINVAL;
  46
  47         spin_lock_irqsave(&clockfw_lock, flags);
  48         if (arch_clock->clk_enable)
  49                 ret = arch_clock->clk_enable(clk);
  50         spin_unlock_irqrestore(&clockfw_lock, flags);
  51
  52         return ret;
  53 }
  54 EXPORT_SYMBOL(clk_enable);
  55
  56 void clk_disable(struct clk *clk)
  57 {
  58         unsigned long flags;
  59
  60         if (clk == NULL || IS_ERR(clk))
  61                 return;
  62
  63         spin_lock_irqsave(&clockfw_lock, flags);
  64         if (clk->usecount == 0) {
  65                 printk(KERN_ERR "Trying disable clock %s with 0 usecount\n",
  66                        clk->name);
  67                 WARN_ON(1);
  68                 goto out;
  69         }
  70
  71         if (arch_clock->clk_disable)
  72                 arch_clock->clk_disable(clk);
  73
  74 out:
  75         spin_unlock_irqrestore(&clockfw_lock, flags);
  76 }
  77 EXPORT_SYMBOL(clk_disable);
  78
  79 unsigned long clk_get_rate(struct clk *clk)
  80 {
  81         unsigned long flags;
  82         unsigned long ret = 0;
  83
  84         if (clk == NULL || IS_ERR(clk))
  85                 return 0;
  86
  87         spin_lock_irqsave(&clockfw_lock, flags);
  88         ret = clk->rate;
  89         spin_unlock_irqrestore(&clockfw_lock, flags);
  90
  91         return ret;
  92 }
  93 EXPORT_SYMBOL(clk_get_rate);
  94
  95 /*-------------------------------------------------------------------------
  96  * Optional clock functions defined in include/linux/clk.h
  97  *-------------------------------------------------------------------------*/
  98
  99 long clk_round_rate(struct clk *clk, unsigned long rate)
 100 {
 101         unsigned long flags;
 102         long ret = 0;
 103
 104         if (clk == NULL || IS_ERR(clk))
 105                 return ret;
 106
 107         spin_lock_irqsave(&clockfw_lock, flags);
 108         if (arch_clock->clk_round_rate)
 109                 ret = arch_clock->clk_round_rate(clk, rate);
 110         spin_unlock_irqrestore(&clockfw_lock, flags);
 111
 112         return ret;
 113 }
 114 EXPORT_SYMBOL(clk_round_rate);
 115
 116 int clk_set_rate(struct clk *clk, unsigned long rate)
 117 {
 118         unsigned long flags;
 119         int ret = -EINVAL;
 120
 121         if (clk == NULL || IS_ERR(clk))
 122                 return ret;
 123
 124         spin_lock_irqsave(&clockfw_lock, flags);
 125         if (arch_clock->clk_set_rate)
 126                 ret = arch_clock->clk_set_rate(clk, rate);
 127         if (ret == 0) {
 128                 if (clk->recalc)
 129                         clk->rate = clk->recalc(clk);
 130                 propagate_rate(clk);
 131         }
 132         spin_unlock_irqrestore(&clockfw_lock, flags);
 133
 134         return ret;
 135 }
 136 EXPORT_SYMBOL(clk_set_rate);
 137
 138 int clk_set_parent(struct clk *clk, struct clk *parent)
 139 {
 140         unsigned long flags;
 141         int ret = -EINVAL;
 142
 143         if (clk == NULL || IS_ERR(clk) || parent == NULL || IS_ERR(parent))
 144                 return ret;
 145
 146         spin_lock_irqsave(&clockfw_lock, flags);
 147         if (clk->usecount == 0) {
 148                 if (arch_clock->clk_set_parent)
 149                         ret = arch_clock->clk_set_parent(clk, parent);
 150                 if (ret == 0) {
 151                         if (clk->recalc)
 152                                 clk->rate = clk->recalc(clk);
 153                         propagate_rate(clk);
 154                 }
 155         } else
 156                 ret = -EBUSY;
 157         spin_unlock_irqrestore(&clockfw_lock, flags);
 158
 159         return ret;
 160 }
 161 EXPORT_SYMBOL(clk_set_parent);
 162
 163 struct clk *clk_get_parent(struct clk *clk)
 164 {
 165         return clk->parent;
 166 }
 167 EXPORT_SYMBOL(clk_get_parent);
 168
 169 /*-------------------------------------------------------------------------
 170  * OMAP specific clock functions shared between omap1 and omap2
 171  *-------------------------------------------------------------------------*/
 172
 173 unsigned int __initdata mpurate;
 174
 175 /*
 176  * By default we use the rate set by the bootloader.
 177  * You can override this with mpurate= cmdline option.
 178  */
 179 static int __init omap_clk_setup(char *str)
 180 {
 181         get_option(&str, &mpurate);
 182
 183         if (!mpurate)
 184                 return 1;
 185
 186         if (mpurate < 1000)
 187                 mpurate *= 1000000;
 188
 189         return 1;
 190 }
 191 __setup("mpurate=", omap_clk_setup);
 192
 193 /* Used for clocks that always have same value as the parent clock */
 194 unsigned long followparent_recalc(struct clk *clk)
 195 {
 196         return clk->parent->rate;
 197 }
 198
 199 void clk_reparent(struct clk *child, struct clk *parent)
 200 {
 201         list_del_init(&child->sibling);
 202         if (parent)
 203                 list_add(&child->sibling, &parent->children);
 204         child->parent = parent;
 205
 206         /* now do the debugfs renaming to reattach the child
 207            to the proper parent */
 208 }
 209
 210 /* Propagate rate to children */
 211 void propagate_rate(struct clk * tclk)
 212 {
 213         struct clk *clkp;
 214
 215         list_for_each_entry(clkp, &tclk->children, sibling) {
 216                 if (clkp->recalc)
 217                         clkp->rate = clkp->recalc(clkp);
 218                 propagate_rate(clkp);
 219         }
 220 }
 221
 222 static LIST_HEAD(root_clks);
 223
 224 /**
 225  * recalculate_root_clocks - recalculate and propagate all root clocks
 226  *
 227  * Recalculates all root clocks (clocks with no parent), which if the
 228  * clock's .recalc is set correctly, should also propagate their rates.
 229  * Called at init.
 230  */
 231 void recalculate_root_clocks(void)
 232 {
 233         struct clk *clkp;
 234
 235         list_for_each_entry(clkp, &root_clks, sibling) {
 236                 if (clkp->recalc)
 237                         clkp->rate = clkp->recalc(clkp);
 238                 propagate_rate(clkp);
 239         }
 240 }
 241
 242 void clk_init_one(struct clk *clk)
 243 {
 244         INIT_LIST_HEAD(&clk->children);
 245 }
 246
 247 int clk_register(struct clk *clk)
 248 {
 249         if (clk == NULL || IS_ERR(clk))
 250                 return -EINVAL;
 251
 252         /*
 253          * trap out already registered clocks
 254          */
 255         if (clk->node.next || clk->node.prev)
 256                 return 0;
 257
 258         mutex_lock(&clocks_mutex);
 259         if (clk->parent)
 260                 list_add(&clk->sibling, &clk->parent->children);
 261         else
 262                 list_add(&clk->sibling, &root_clks);
 263
 264         list_add(&clk->node, &clocks);
 265         if (clk->init)
 266                 clk->init(clk);
 267         mutex_unlock(&clocks_mutex);
 268
 269         return 0;
 270 }
 271 EXPORT_SYMBOL(clk_register);
 272
 273 void clk_unregister(struct clk *clk)
 274 {
 275         if (clk == NULL || IS_ERR(clk))
 276                 return;
 277
 278         mutex_lock(&clocks_mutex);
 279         list_del(&clk->sibling);
 280         list_del(&clk->node);
 281         mutex_unlock(&clocks_mutex);
 282 }
 283 EXPORT_SYMBOL(clk_unregister);
 284
 285 void clk_enable_init_clocks(void)
 286 {
 287         struct clk *clkp;
 288
 289         list_for_each_entry(clkp, &clocks, node) {
 290                 if (clkp->flags & ENABLE_ON_INIT)
 291                         clk_enable(clkp);
 292         }
 293 }
 294 EXPORT_SYMBOL(clk_enable_init_clocks);
 295
 296 /*
 297  * Low level helpers
 298  */
 299 static int clkll_enable_null(struct clk *clk)
 300 {
 301         return 0;
 302 }
 303
 304 static void clkll_disable_null(struct clk *clk)
 305 {
 306 }
 307
 308 const struct clkops clkops_null = {
 309         .enable         = clkll_enable_null,
 310         .disable        = clkll_disable_null,
 311 };
 312
 313 #ifdef CONFIG_CPU_FREQ
 314 void clk_init_cpufreq_table(struct cpufreq_frequency_table **table)
 315 {
 316         unsigned long flags;
 317
 318         spin_lock_irqsave(&clockfw_lock, flags);
 319         if (arch_clock->clk_init_cpufreq_table)
 320                 arch_clock->clk_init_cpufreq_table(table);
 321         spin_unlock_irqrestore(&clockfw_lock, flags);
 322 }
 323 EXPORT_SYMBOL(clk_init_cpufreq_table);
 324 #endif
 325
 326 /*-------------------------------------------------------------------------*/
 327
 328 #ifdef CONFIG_OMAP_RESET_CLOCKS
 329 /*
 330  * Disable any unused clocks left on by the bootloader
 331  */
 332 static int __init clk_disable_unused(void)
 333 {
 334         struct clk *ck;
 335         unsigned long flags;
 336
 337         list_for_each_entry(ck, &clocks, node) {
 338                 if (ck->ops == &clkops_null)
 339                         continue;
 340
 341                 if (ck->usecount > 0 || ck->enable_reg == 0)
 342                         continue;
 343
 344                 spin_lock_irqsave(&clockfw_lock, flags);
 345                 if (arch_clock->clk_disable_unused)
 346                         arch_clock->clk_disable_unused(ck);
 347                 spin_unlock_irqrestore(&clockfw_lock, flags);
 348         }
 349
 350         return 0;
 351 }
 352 late_initcall(clk_disable_unused);
 353 #endif
 354
 355 int __init clk_init(struct clk_functions * custom_clocks)
 356 {
 357         if (!custom_clocks) {
 358                 printk(KERN_ERR "No custom clock functions registered\n");
 359                 BUG();
 360         }
 361
 362         arch_clock = custom_clocks;
 363
 364         return 0;
 365 }
 366
 367 #if defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS)
 368 /*
 369  *      debugfs support to trace clock tree hierarchy and attributes
 370  */
 371 static struct dentry *clk_debugfs_root;
 372
 373 static int clk_debugfs_register_one(struct clk *c)
 374 {
 375         int err;
 376         struct dentry *d, *child;
 377         struct clk *pa = c->parent;
 378         char s[255];
 379         char *p = s;
 380
 381         p += sprintf(p, "%s", c->name);
 382         if (c->id != 0)
 383                 sprintf(p, ":%d", c->id);
 384         d = debugfs_create_dir(s, pa ? pa->dent : clk_debugfs_root);
 385         if (!d)
 386                 return -ENOMEM;
 387         c->dent = d;
 388
 389         d = debugfs_create_u8("usecount", S_IRUGO, c->dent, (u8 *)&c->usecount);
 390         if (!d) {
 391                 err = -ENOMEM;
 392                 goto err_out;
 393         }
 394         d = debugfs_create_u32("rate", S_IRUGO, c->dent, (u32 *)&c->rate);
 395         if (!d) {
 396                 err = -ENOMEM;
 397                 goto err_out;
 398         }
 399         d = debugfs_create_x32("flags", S_IRUGO, c->dent, (u32 *)&c->flags);
 400         if (!d) {
 401                 err = -ENOMEM;
 402                 goto err_out;
 403         }
 404         return 0;
 405
 406 err_out:
 407         d = c->dent;
 408         list_for_each_entry(child, &d->d_subdirs, d_u.d_child)
 409                 debugfs_remove(child);
 410         debugfs_remove(c->dent);
 411         return err;
 412 }
 413
 414 static int clk_debugfs_register(struct clk *c)
 415 {
 416         int err;
 417         struct clk *pa = c->parent;
 418
 419         if (pa && !pa->dent) {
 420                 err = clk_debugfs_register(pa);
 421                 if (err)
 422                         return err;
 423         }
 424
 425         if (!c->dent) {
 426                 err = clk_debugfs_register_one(c);
 427                 if (err)
 428                         return err;
 429         }
 430         return 0;
 431 }
 432
 433 static int __init clk_debugfs_init(void)
 434 {
 435         struct clk *c;
 436         struct dentry *d;
 437         int err;
 438
 439         d = debugfs_create_dir("clock", NULL);
 440         if (!d)
 441                 return -ENOMEM;
 442         clk_debugfs_root = d;
 443
 444         list_for_each_entry(c, &clocks, node) {
 445                 err = clk_debugfs_register(c);
 446                 if (err)
 447                         goto err_out;
 448         }
 449         return 0;
 450 err_out:
 451         debugfs_remove(clk_debugfs_root); /* REVISIT: Cleanup correctly */
 452         return err;
 453 }
 454 late_initcall(clk_debugfs_init);
 455
 456 #endif /* defined(CONFIG_PM_DEBUG) && defined(CONFIG_DEBUG_FS) */