arch/sh/kernel/cpu/clock.c

   1 /*
   2  * arch/sh/kernel/cpu/clock.c - SuperH clock framework
   3  *
   4  *  Copyright (C) 2005 - 2009  Paul Mundt
   5  *
   6  * This clock framework is derived from the OMAP version by:
   7  *
   8  *      Copyright (C) 2004 - 2008 Nokia Corporation
   9  *      Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
  10  *
  11  *  Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
  12  *
  13  *  With clkdev bits:
  14  *
  15  *      Copyright (C) 2008 Russell King.
  16  *
  17  * This file is subject to the terms and conditions of the GNU General Public
  18  * License.  See the file "COPYING" in the main directory of this archive
  19  * for more details.
  20  */
  21 #include <linux/kernel.h>
  22 #include <linux/init.h>
  23 #include <linux/module.h>
  24 #include <linux/mutex.h>
  25 #include <linux/list.h>
  26 #include <linux/kobject.h>
  27 #include <linux/sysdev.h>
  28 #include <linux/seq_file.h>
  29 #include <linux/err.h>
  30 #include <linux/platform_device.h>
  31 #include <linux/debugfs.h>
  32 #include <linux/cpufreq.h>
  33 #include <asm/clock.h>
  34 #include <asm/machvec.h>
  35
  36 static LIST_HEAD(clock_list);
  37 static DEFINE_SPINLOCK(clock_lock);
  38 static DEFINE_MUTEX(clock_list_sem);
  39
  40 void clk_rate_table_build(struct clk *clk,
  41                           struct cpufreq_frequency_table *freq_table,
  42                           int nr_freqs,
  43                           struct clk_div_mult_table *src_table,
  44                           unsigned long *bitmap)
  45 {
  46         unsigned long mult, div;
  47         unsigned long freq;
  48         int i;
  49
  50         for (i = 0; i < nr_freqs; i++) {
  51                 div = 1;
  52                 mult = 1;
  53
  54                 if (src_table->divisors && i < src_table->nr_divisors)
  55                         div = src_table->divisors[i];
  56
  57                 if (src_table->multipliers && i < src_table->nr_multipliers)
  58                         mult = src_table->multipliers[i];
  59
  60                 if (!div || !mult || (bitmap && !test_bit(i, bitmap)))
  61                         freq = CPUFREQ_ENTRY_INVALID;
  62                 else
  63                         freq = clk->parent->rate * mult / div;
  64
  65                 freq_table[i].index = i;
  66                 freq_table[i].frequency = freq;
  67         }
  68
  69         /* Termination entry */
  70         freq_table[i].index = i;
  71         freq_table[i].frequency = CPUFREQ_TABLE_END;
  72 }
  73
  74 long clk_rate_table_round(struct clk *clk,
  75                           struct cpufreq_frequency_table *freq_table,
  76                           unsigned long rate)
  77 {
  78         unsigned long rate_error, rate_error_prev = ~0UL;
  79         unsigned long rate_best_fit = rate;
  80         unsigned long highest, lowest;
  81         int i;
  82
  83         highest = lowest = 0;
  84
  85         for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
  86                 unsigned long freq = freq_table[i].frequency;
  87
  88                 if (freq == CPUFREQ_ENTRY_INVALID)
  89                         continue;
  90
  91                 if (freq > highest)
  92                         highest = freq;
  93                 if (freq < lowest)
  94                         lowest = freq;
  95
  96                 rate_error = abs(freq - rate);
  97                 if (rate_error < rate_error_prev) {
  98                         rate_best_fit = freq;
  99                         rate_error_prev = rate_error;
 100                 }
 101
 102                 if (rate_error == 0)
 103                         break;
 104         }
 105
 106         if (rate >= highest)
 107                 rate_best_fit = highest;
 108         if (rate <= lowest)
 109                 rate_best_fit = lowest;
 110
 111         return rate_best_fit;
 112 }
 113
 114 int clk_rate_table_find(struct clk *clk,
 115                         struct cpufreq_frequency_table *freq_table,
 116                         unsigned long rate)
 117 {
 118         int i;
 119
 120         for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
 121                 unsigned long freq = freq_table[i].frequency;
 122
 123                 if (freq == CPUFREQ_ENTRY_INVALID)
 124                         continue;
 125
 126                 if (freq == rate)
 127                         return i;
 128         }
 129
 130         return -ENOENT;
 131 }
 132
 133 /* Used for clocks that always have same value as the parent clock */
 134 unsigned long followparent_recalc(struct clk *clk)
 135 {
 136         return clk->parent ? clk->parent->rate : 0;
 137 }
 138
 139 int clk_reparent(struct clk *child, struct clk *parent)
 140 {
 141         list_del_init(&child->sibling);
 142         if (parent)
 143                 list_add(&child->sibling, &parent->children);
 144         child->parent = parent;
 145
 146         /* now do the debugfs renaming to reattach the child
 147            to the proper parent */
 148
 149         return 0;
 150 }
 151
 152 /* Propagate rate to children */
 153 void propagate_rate(struct clk *tclk)
 154 {
 155         struct clk *clkp;
 156
 157         list_for_each_entry(clkp, &tclk->children, sibling) {
 158                 if (clkp->ops && clkp->ops->recalc)
 159                         clkp->rate = clkp->ops->recalc(clkp);
 160
 161                 propagate_rate(clkp);
 162         }
 163 }
 164
 165 static void __clk_disable(struct clk *clk)
 166 {
 167         if (clk->usecount == 0) {
 168                 printk(KERN_ERR "Trying disable clock %s with 0 usecount\n",
 169                        clk->name);
 170                 WARN_ON(1);
 171                 return;
 172         }
 173
 174         if (!(--clk->usecount)) {
 175                 if (likely(clk->ops && clk->ops->disable))
 176                         clk->ops->disable(clk);
 177                 if (likely(clk->parent))
 178                         __clk_disable(clk->parent);
 179         }
 180 }
 181
 182 void clk_disable(struct clk *clk)
 183 {
 184         unsigned long flags;
 185
 186         if (!clk)
 187                 return;
 188
 189         spin_lock_irqsave(&clock_lock, flags);
 190         __clk_disable(clk);
 191         spin_unlock_irqrestore(&clock_lock, flags);
 192 }
 193 EXPORT_SYMBOL_GPL(clk_disable);
 194
 195 static int __clk_enable(struct clk *clk)
 196 {
 197         int ret = 0;
 198
 199         if (clk->usecount++ == 0) {
 200                 if (clk->parent) {
 201                         ret = __clk_enable(clk->parent);
 202                         if (unlikely(ret))
 203                                 goto err;
 204                 }
 205
 206                 if (clk->ops && clk->ops->enable) {
 207                         ret = clk->ops->enable(clk);
 208                         if (ret) {
 209                                 if (clk->parent)
 210                                         __clk_disable(clk->parent);
 211                                 goto err;
 212                         }
 213                 }
 214         }
 215
 216         return ret;
 217 err:
 218         clk->usecount--;
 219         return ret;
 220 }
 221
 222 int clk_enable(struct clk *clk)
 223 {
 224         unsigned long flags;
 225         int ret;
 226
 227         if (!clk)
 228                 return -EINVAL;
 229
 230         spin_lock_irqsave(&clock_lock, flags);
 231         ret = __clk_enable(clk);
 232         spin_unlock_irqrestore(&clock_lock, flags);
 233
 234         return ret;
 235 }
 236 EXPORT_SYMBOL_GPL(clk_enable);
 237
 238 static LIST_HEAD(root_clks);
 239
 240 /**
 241  * recalculate_root_clocks - recalculate and propagate all root clocks
 242  *
 243  * Recalculates all root clocks (clocks with no parent), which if the
 244  * clock's .recalc is set correctly, should also propagate their rates.
 245  * Called at init.
 246  */
 247 void recalculate_root_clocks(void)
 248 {
 249         struct clk *clkp;
 250
 251         list_for_each_entry(clkp, &root_clks, sibling) {
 252                 if (clkp->ops && clkp->ops->recalc)
 253                         clkp->rate = clkp->ops->recalc(clkp);
 254                 propagate_rate(clkp);
 255         }
 256 }
 257
 258 int clk_register(struct clk *clk)
 259 {
 260         if (clk == NULL || IS_ERR(clk))
 261                 return -EINVAL;
 262
 263         /*
 264          * trap out already registered clocks
 265          */
 266         if (clk->node.next || clk->node.prev)
 267                 return 0;
 268
 269         mutex_lock(&clock_list_sem);
 270
 271         INIT_LIST_HEAD(&clk->children);
 272         clk->usecount = 0;
 273
 274         if (clk->parent)
 275                 list_add(&clk->sibling, &clk->parent->children);
 276         else
 277                 list_add(&clk->sibling, &root_clks);
 278
 279         list_add(&clk->node, &clock_list);
 280         if (clk->ops && clk->ops->init)
 281                 clk->ops->init(clk);
 282         mutex_unlock(&clock_list_sem);
 283
 284         return 0;
 285 }
 286 EXPORT_SYMBOL_GPL(clk_register);
 287
 288 void clk_unregister(struct clk *clk)
 289 {
 290         mutex_lock(&clock_list_sem);
 291         list_del(&clk->sibling);
 292         list_del(&clk->node);
 293         mutex_unlock(&clock_list_sem);
 294 }
 295 EXPORT_SYMBOL_GPL(clk_unregister);
 296
 297 static void clk_enable_init_clocks(void)
 298 {
 299         struct clk *clkp;
 300
 301         list_for_each_entry(clkp, &clock_list, node)
 302                 if (clkp->flags & CLK_ENABLE_ON_INIT)
 303                         clk_enable(clkp);
 304 }
 305
 306 unsigned long clk_get_rate(struct clk *clk)
 307 {
 308         return clk->rate;
 309 }
 310 EXPORT_SYMBOL_GPL(clk_get_rate);
 311
 312 int clk_set_rate(struct clk *clk, unsigned long rate)
 313 {
 314         return clk_set_rate_ex(clk, rate, 0);
 315 }
 316 EXPORT_SYMBOL_GPL(clk_set_rate);
 317
 318 int clk_set_rate_ex(struct clk *clk, unsigned long rate, int algo_id)
 319 {
 320         int ret = -EOPNOTSUPP;
 321         unsigned long flags;
 322
 323         spin_lock_irqsave(&clock_lock, flags);
 324
 325         if (likely(clk->ops && clk->ops->set_rate)) {
 326                 ret = clk->ops->set_rate(clk, rate, algo_id);
 327                 if (ret != 0)
 328                         goto out_unlock;
 329         } else {
 330                 clk->rate = rate;
 331                 ret = 0;
 332         }
 333
 334         if (clk->ops && clk->ops->recalc)
 335                 clk->rate = clk->ops->recalc(clk);
 336
 337         propagate_rate(clk);
 338
 339 out_unlock:
 340         spin_unlock_irqrestore(&clock_lock, flags);
 341
 342         return ret;
 343 }
 344 EXPORT_SYMBOL_GPL(clk_set_rate_ex);
 345
 346 int clk_set_parent(struct clk *clk, struct clk *parent)
 347 {
 348         unsigned long flags;
 349         int ret = -EINVAL;
 350
 351         if (!parent || !clk)
 352                 return ret;
 353         if (clk->parent == parent)
 354                 return 0;
 355
 356         spin_lock_irqsave(&clock_lock, flags);
 357         if (clk->usecount == 0) {
 358                 if (clk->ops->set_parent)
 359                         ret = clk->ops->set_parent(clk, parent);
 360                 else
 361                         ret = clk_reparent(clk, parent);
 362
 363                 if (ret == 0) {
 364                         pr_debug("clock: set parent of %s to %s (new rate %ld)\n",
 365                                  clk->name, clk->parent->name, clk->rate);
 366                         if (clk->ops->recalc)
 367                                 clk->rate = clk->ops->recalc(clk);
 368                         propagate_rate(clk);
 369                 }
 370         } else
 371                 ret = -EBUSY;
 372         spin_unlock_irqrestore(&clock_lock, flags);
 373
 374         return ret;
 375 }
 376 EXPORT_SYMBOL_GPL(clk_set_parent);
 377
 378 struct clk *clk_get_parent(struct clk *clk)
 379 {
 380         return clk->parent;
 381 }
 382 EXPORT_SYMBOL_GPL(clk_get_parent);
 383
 384 long clk_round_rate(struct clk *clk, unsigned long rate)
 385 {
 386         if (likely(clk->ops && clk->ops->round_rate)) {
 387                 unsigned long flags, rounded;
 388
 389                 spin_lock_irqsave(&clock_lock, flags);
 390                 rounded = clk->ops->round_rate(clk, rate);
 391                 spin_unlock_irqrestore(&clock_lock, flags);
 392
 393                 return rounded;
 394         }
 395
 396         return clk_get_rate(clk);
 397 }
 398 EXPORT_SYMBOL_GPL(clk_round_rate);
 399
 400 /*
 401  * Find the correct struct clk for the device and connection ID.
 402  * We do slightly fuzzy matching here:
 403  *  An entry with a NULL ID is assumed to be a wildcard.
 404  *  If an entry has a device ID, it must match
 405  *  If an entry has a connection ID, it must match
 406  * Then we take the most specific entry - with the following
 407  * order of precidence: dev+con > dev only > con only.
 408  */
 409 static struct clk *clk_find(const char *dev_id, const char *con_id)
 410 {
 411         struct clk_lookup *p;
 412         struct clk *clk = NULL;
 413         int match, best = 0;
 414
 415         list_for_each_entry(p, &clock_list, node) {
 416                 match = 0;
 417                 if (p->dev_id) {
 418                         if (!dev_id || strcmp(p->dev_id, dev_id))
 419                                 continue;
 420                         match += 2;
 421                 }
 422                 if (p->con_id) {
 423                         if (!con_id || strcmp(p->con_id, con_id))
 424                                 continue;
 425                         match += 1;
 426                 }
 427                 if (match == 0)
 428                         continue;
 429
 430                 if (match > best) {
 431                         clk = p->clk;
 432                         best = match;
 433                 }
 434         }
 435         return clk;
 436 }
 437
 438 struct clk *clk_get_sys(const char *dev_id, const char *con_id)
 439 {
 440         struct clk *clk;
 441
 442         mutex_lock(&clock_list_sem);
 443         clk = clk_find(dev_id, con_id);
 444         mutex_unlock(&clock_list_sem);
 445
 446         return clk ? clk : ERR_PTR(-ENOENT);
 447 }
 448 EXPORT_SYMBOL_GPL(clk_get_sys);
 449
 450 /*
 451  * Returns a clock. Note that we first try to use device id on the bus
 452  * and clock name. If this fails, we try to use clock name only.
 453  */
 454 struct clk *clk_get(struct device *dev, const char *id)
 455 {
 456         const char *dev_id = dev ? dev_name(dev) : NULL;
 457         struct clk *p, *clk = ERR_PTR(-ENOENT);
 458         int idno;
 459
 460         clk = clk_get_sys(dev_id, id);
 461         if (clk && !IS_ERR(clk))
 462                 return clk;
 463
 464         if (dev == NULL || dev->bus != &platform_bus_type)
 465                 idno = -1;
 466         else
 467                 idno = to_platform_device(dev)->id;
 468
 469         mutex_lock(&clock_list_sem);
 470         list_for_each_entry(p, &clock_list, node) {
 471                 if (p->id == idno &&
 472                     strcmp(id, p->name) == 0 && try_module_get(p->owner)) {
 473                         clk = p;
 474                         goto found;
 475                 }
 476         }
 477
 478         list_for_each_entry(p, &clock_list, node) {
 479                 if (strcmp(id, p->name) == 0 && try_module_get(p->owner)) {
 480                         clk = p;
 481                         break;
 482                 }
 483         }
 484
 485 found:
 486         mutex_unlock(&clock_list_sem);
 487
 488         return clk;
 489 }
 490 EXPORT_SYMBOL_GPL(clk_get);
 491
 492 void clk_put(struct clk *clk)
 493 {
 494         if (clk && !IS_ERR(clk))
 495                 module_put(clk->owner);
 496 }
 497 EXPORT_SYMBOL_GPL(clk_put);
 498
 499 #ifdef CONFIG_PM
 500 static int clks_sysdev_suspend(struct sys_device *dev, pm_message_t state)
 501 {
 502         static pm_message_t prev_state;
 503         struct clk *clkp;
 504
 505         switch (state.event) {
 506         case PM_EVENT_ON:
 507                 /* Resumeing from hibernation */
 508                 if (prev_state.event != PM_EVENT_FREEZE)
 509                         break;
 510
 511                 list_for_each_entry(clkp, &clock_list, node) {
 512                         if (likely(clkp->ops)) {
 513                                 unsigned long rate = clkp->rate;
 514
 515                                 if (likely(clkp->ops->set_parent))
 516                                         clkp->ops->set_parent(clkp,
 517                                                 clkp->parent);
 518                                 if (likely(clkp->ops->set_rate))
 519                                         clkp->ops->set_rate(clkp,
 520                                                 rate, NO_CHANGE);
 521                                 else if (likely(clkp->ops->recalc))
 522                                         clkp->rate = clkp->ops->recalc(clkp);
 523                         }
 524                 }
 525                 break;
 526         case PM_EVENT_FREEZE:
 527                 break;
 528         case PM_EVENT_SUSPEND:
 529                 break;
 530         }
 531
 532         prev_state = state;
 533         return 0;
 534 }
 535
 536 static int clks_sysdev_resume(struct sys_device *dev)
 537 {
 538         return clks_sysdev_suspend(dev, PMSG_ON);
 539 }
 540
 541 static struct sysdev_class clks_sysdev_class = {
 542         .name = "clks",
 543 };
 544
 545 static struct sysdev_driver clks_sysdev_driver = {
 546         .suspend = clks_sysdev_suspend,
 547         .resume = clks_sysdev_resume,
 548 };
 549
 550 static struct sys_device clks_sysdev_dev = {
 551         .cls = &clks_sysdev_class,
 552 };
 553
 554 static int __init clk_sysdev_init(void)
 555 {
 556         sysdev_class_register(&clks_sysdev_class);
 557         sysdev_driver_register(&clks_sysdev_class, &clks_sysdev_driver);
 558         sysdev_register(&clks_sysdev_dev);
 559
 560         return 0;
 561 }
 562 subsys_initcall(clk_sysdev_init);
 563 #endif
 564
 565 int __init clk_init(void)
 566 {
 567         int ret;
 568
 569         ret = arch_clk_init();
 570         if (unlikely(ret)) {
 571                 pr_err("%s: CPU clock registration failed.\n", __func__);
 572                 return ret;
 573         }
 574
 575         if (sh_mv.mv_clk_init) {
 576                 ret = sh_mv.mv_clk_init();
 577                 if (unlikely(ret)) {
 578                         pr_err("%s: machvec clock initialization failed.\n",
 579                                __func__);
 580                         return ret;
 581                 }
 582         }
 583
 584         /* Kick the child clocks.. */
 585         recalculate_root_clocks();
 586
 587         /* Enable the necessary init clocks */
 588         clk_enable_init_clocks();
 589
 590         return ret;
 591 }
 592
 593 /*
 594  *      debugfs support to trace clock tree hierarchy and attributes
 595  */
 596 static struct dentry *clk_debugfs_root;
 597
 598 static int clk_debugfs_register_one(struct clk *c)
 599 {
 600         int err;
 601         struct dentry *d, *child, *child_tmp;
 602         struct clk *pa = c->parent;
 603         char s[255];
 604         char *p = s;
 605
 606         p += sprintf(p, "%s", c->name);
 607         if (c->id >= 0)
 608                 sprintf(p, ":%d", c->id);
 609         d = debugfs_create_dir(s, pa ? pa->dentry : clk_debugfs_root);
 610         if (!d)
 611                 return -ENOMEM;
 612         c->dentry = d;
 613
 614         d = debugfs_create_u8("usecount", S_IRUGO, c->dentry, (u8 *)&c->usecount);
 615         if (!d) {
 616                 err = -ENOMEM;
 617                 goto err_out;
 618         }
 619         d = debugfs_create_u32("rate", S_IRUGO, c->dentry, (u32 *)&c->rate);
 620         if (!d) {
 621                 err = -ENOMEM;
 622                 goto err_out;
 623         }
 624         d = debugfs_create_x32("flags", S_IRUGO, c->dentry, (u32 *)&c->flags);
 625         if (!d) {
 626                 err = -ENOMEM;
 627                 goto err_out;
 628         }
 629         return 0;
 630
 631 err_out:
 632         d = c->dentry;
 633         list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child)
 634                 debugfs_remove(child);
 635         debugfs_remove(c->dentry);
 636         return err;
 637 }
 638
 639 static int clk_debugfs_register(struct clk *c)
 640 {
 641         int err;
 642         struct clk *pa = c->parent;
 643
 644         if (pa && !pa->dentry) {
 645                 err = clk_debugfs_register(pa);
 646                 if (err)
 647                         return err;
 648         }
 649
 650         if (!c->dentry) {
 651                 err = clk_debugfs_register_one(c);
 652                 if (err)
 653                         return err;
 654         }
 655         return 0;
 656 }
 657
 658 static int __init clk_debugfs_init(void)
 659 {
 660         struct clk *c;
 661         struct dentry *d;
 662         int err;
 663
 664         d = debugfs_create_dir("clock", NULL);
 665         if (!d)
 666                 return -ENOMEM;
 667         clk_debugfs_root = d;
 668
 669         list_for_each_entry(c, &clock_list, node) {
 670                 err = clk_debugfs_register(c);
 671                 if (err)
 672                         goto err_out;
 673         }
 674         return 0;
 675 err_out:
 676         debugfs_remove(clk_debugfs_root); /* REVISIT: Cleanup correctly */
 677         return err;
 678 }
 679 late_initcall(clk_debugfs_init);