1 /* 2 * Copyright (C) 2010-2011 Canonical Ltd <jeremy.kerr@canonical.com> 3 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 * 9 * Standard functionality for the common clock API. See Documentation/clk.txt 10 */ 11 12 #include <linux/clk-private.h> 13 #include <linux/module.h> 14 #include <linux/mutex.h> 15 #include <linux/spinlock.h> 16 #include <linux/err.h> 17 #include <linux/list.h> 18 #include <linux/slab.h> 19 #include <linux/of.h> 20 #include <linux/device.h> 21 #include <linux/init.h> 22 #include <linux/sched.h> 23 24 static DEFINE_SPINLOCK(enable_lock); 25 static DEFINE_MUTEX(prepare_lock); 26 27 static struct task_struct *prepare_owner; 28 static struct task_struct *enable_owner; 29 30 static int prepare_refcnt; 31 static int enable_refcnt; 32 33 static HLIST_HEAD(clk_root_list); 34 static HLIST_HEAD(clk_orphan_list); 35 static LIST_HEAD(clk_notifier_list); 36 37 /*** locking ***/ 38 static void clk_prepare_lock(void) 39 { 40 if (!mutex_trylock(&prepare_lock)) { 41 if (prepare_owner == current) { 42 prepare_refcnt++; 43 return; 44 } 45 mutex_lock(&prepare_lock); 46 } 47 WARN_ON_ONCE(prepare_owner != NULL); 48 WARN_ON_ONCE(prepare_refcnt != 0); 49 prepare_owner = current; 50 prepare_refcnt = 1; 51 } 52 53 static void clk_prepare_unlock(void) 54 { 55 WARN_ON_ONCE(prepare_owner != current); 56 WARN_ON_ONCE(prepare_refcnt == 0); 57 58 if (--prepare_refcnt) 59 return; 60 prepare_owner = NULL; 61 mutex_unlock(&prepare_lock); 62 } 63 64 static unsigned long clk_enable_lock(void) 65 { 66 unsigned long flags; 67 68 if (!spin_trylock_irqsave(&enable_lock, flags)) { 69 if (enable_owner == current) { 70 enable_refcnt++; 71 return flags; 72 } 73 spin_lock_irqsave(&enable_lock, flags); 74 } 75 WARN_ON_ONCE(enable_owner != NULL); 76 WARN_ON_ONCE(enable_refcnt != 0); 77 enable_owner = current; 78 enable_refcnt = 1; 79 return flags; 80 } 81 82 static void clk_enable_unlock(unsigned long flags) 83 { 84 WARN_ON_ONCE(enable_owner != current); 85 WARN_ON_ONCE(enable_refcnt == 0); 86 87 if (--enable_refcnt) 88 return; 89 enable_owner = NULL; 90 spin_unlock_irqrestore(&enable_lock, flags); 91 } 92 93 /*** debugfs support ***/ 94 95 #ifdef CONFIG_COMMON_CLK_DEBUG 96 #include <linux/debugfs.h> 97 98 static struct dentry *rootdir; 99 static struct dentry *orphandir; 100 static int inited = 0; 101 102 static void clk_summary_show_one(struct seq_file *s, struct clk *c, int level) 103 { 104 if (!c) 105 return; 106 107 seq_printf(s, "%*s%-*s %-11d %-12d %-10lu", 108 level * 3 + 1, "", 109 30 - level * 3, c->name, 110 c->enable_count, c->prepare_count, clk_get_rate(c)); 111 seq_printf(s, "\n"); 112 } 113 114 static void clk_summary_show_subtree(struct seq_file *s, struct clk *c, 115 int level) 116 { 117 struct clk *child; 118 119 if (!c) 120 return; 121 122 clk_summary_show_one(s, c, level); 123 124 hlist_for_each_entry(child, &c->children, child_node) 125 clk_summary_show_subtree(s, child, level + 1); 126 } 127 128 static int clk_summary_show(struct seq_file *s, void *data) 129 { 130 struct clk *c; 131 132 seq_printf(s, " clock enable_cnt prepare_cnt rate\n"); 133 seq_printf(s, "---------------------------------------------------------------------\n"); 134 135 clk_prepare_lock(); 136 137 hlist_for_each_entry(c, &clk_root_list, child_node) 138 clk_summary_show_subtree(s, c, 0); 139 140 hlist_for_each_entry(c, &clk_orphan_list, child_node) 141 clk_summary_show_subtree(s, c, 0); 142 143 clk_prepare_unlock(); 144 145 return 0; 146 } 147 148 149 static int clk_summary_open(struct inode *inode, struct file *file) 150 { 151 return single_open(file, clk_summary_show, inode->i_private); 152 } 153 154 static const struct file_operations clk_summary_fops = { 155 .open = clk_summary_open, 156 .read = seq_read, 157 .llseek = seq_lseek, 158 .release = single_release, 159 }; 160 161 static void clk_dump_one(struct seq_file *s, struct clk *c, int level) 162 { 163 if (!c) 164 return; 165 166 seq_printf(s, "\"%s\": { ", c->name); 167 seq_printf(s, "\"enable_count\": %d,", c->enable_count); 168 seq_printf(s, "\"prepare_count\": %d,", c->prepare_count); 169 seq_printf(s, "\"rate\": %lu", clk_get_rate(c)); 170 } 171 172 static void clk_dump_subtree(struct seq_file *s, struct clk *c, int level) 173 { 174 struct clk *child; 175 176 if (!c) 177 return; 178 179 clk_dump_one(s, c, level); 180 181 hlist_for_each_entry(child, &c->children, child_node) { 182 seq_printf(s, ","); 183 clk_dump_subtree(s, child, level + 1); 184 } 185 186 seq_printf(s, "}"); 187 } 188 189 static int clk_dump(struct seq_file *s, void *data) 190 { 191 struct clk *c; 192 bool first_node = true; 193 194 seq_printf(s, "{"); 195 196 clk_prepare_lock(); 197 198 hlist_for_each_entry(c, &clk_root_list, child_node) { 199 if (!first_node) 200 seq_printf(s, ","); 201 first_node = false; 202 clk_dump_subtree(s, c, 0); 203 } 204 205 hlist_for_each_entry(c, &clk_orphan_list, child_node) { 206 seq_printf(s, ","); 207 clk_dump_subtree(s, c, 0); 208 } 209 210 clk_prepare_unlock(); 211 212 seq_printf(s, "}"); 213 return 0; 214 } 215 216 217 static int clk_dump_open(struct inode *inode, struct file *file) 218 { 219 return single_open(file, clk_dump, inode->i_private); 220 } 221 222 static const struct file_operations clk_dump_fops = { 223 .open = clk_dump_open, 224 .read = seq_read, 225 .llseek = seq_lseek, 226 .release = single_release, 227 }; 228 229 /* caller must hold prepare_lock */ 230 static int clk_debug_create_one(struct clk *clk, struct dentry *pdentry) 231 { 232 struct dentry *d; 233 int ret = -ENOMEM; 234 235 if (!clk || !pdentry) { 236 ret = -EINVAL; 237 goto out; 238 } 239 240 d = debugfs_create_dir(clk->name, pdentry); 241 if (!d) 242 goto out; 243 244 clk->dentry = d; 245 246 d = debugfs_create_u32("clk_rate", S_IRUGO, clk->dentry, 247 (u32 *)&clk->rate); 248 if (!d) 249 goto err_out; 250 251 d = debugfs_create_x32("clk_flags", S_IRUGO, clk->dentry, 252 (u32 *)&clk->flags); 253 if (!d) 254 goto err_out; 255 256 d = debugfs_create_u32("clk_prepare_count", S_IRUGO, clk->dentry, 257 (u32 *)&clk->prepare_count); 258 if (!d) 259 goto err_out; 260 261 d = debugfs_create_u32("clk_enable_count", S_IRUGO, clk->dentry, 262 (u32 *)&clk->enable_count); 263 if (!d) 264 goto err_out; 265 266 d = debugfs_create_u32("clk_notifier_count", S_IRUGO, clk->dentry, 267 (u32 *)&clk->notifier_count); 268 if (!d) 269 goto err_out; 270 271 ret = 0; 272 goto out; 273 274 err_out: 275 debugfs_remove(clk->dentry); 276 out: 277 return ret; 278 } 279 280 /* caller must hold prepare_lock */ 281 static int clk_debug_create_subtree(struct clk *clk, struct dentry *pdentry) 282 { 283 struct clk *child; 284 int ret = -EINVAL;; 285 286 if (!clk || !pdentry) 287 goto out; 288 289 ret = clk_debug_create_one(clk, pdentry); 290 291 if (ret) 292 goto out; 293 294 hlist_for_each_entry(child, &clk->children, child_node) 295 clk_debug_create_subtree(child, clk->dentry); 296 297 ret = 0; 298 out: 299 return ret; 300 } 301 302 /** 303 * clk_debug_register - add a clk node to the debugfs clk tree 304 * @clk: the clk being added to the debugfs clk tree 305 * 306 * Dynamically adds a clk to the debugfs clk tree if debugfs has been 307 * initialized. Otherwise it bails out early since the debugfs clk tree 308 * will be created lazily by clk_debug_init as part of a late_initcall. 309 * 310 * Caller must hold prepare_lock. Only clk_init calls this function (so 311 * far) so this is taken care. 312 */ 313 static int clk_debug_register(struct clk *clk) 314 { 315 struct clk *parent; 316 struct dentry *pdentry; 317 int ret = 0; 318 319 if (!inited) 320 goto out; 321 322 parent = clk->parent; 323 324 /* 325 * Check to see if a clk is a root clk. Also check that it is 326 * safe to add this clk to debugfs 327 */ 328 if (!parent) 329 if (clk->flags & CLK_IS_ROOT) 330 pdentry = rootdir; 331 else 332 pdentry = orphandir; 333 else 334 if (parent->dentry) 335 pdentry = parent->dentry; 336 else 337 goto out; 338 339 ret = clk_debug_create_subtree(clk, pdentry); 340 341 out: 342 return ret; 343 } 344 345 /** 346 * clk_debug_reparent - reparent clk node in the debugfs clk tree 347 * @clk: the clk being reparented 348 * @new_parent: the new clk parent, may be NULL 349 * 350 * Rename clk entry in the debugfs clk tree if debugfs has been 351 * initialized. Otherwise it bails out early since the debugfs clk tree 352 * will be created lazily by clk_debug_init as part of a late_initcall. 353 * 354 * Caller must hold prepare_lock. 355 */ 356 static void clk_debug_reparent(struct clk *clk, struct clk *new_parent) 357 { 358 struct dentry *d; 359 struct dentry *new_parent_d; 360 361 if (!inited) 362 return; 363 364 if (new_parent) 365 new_parent_d = new_parent->dentry; 366 else 367 new_parent_d = orphandir; 368 369 d = debugfs_rename(clk->dentry->d_parent, clk->dentry, 370 new_parent_d, clk->name); 371 if (d) 372 clk->dentry = d; 373 else 374 pr_debug("%s: failed to rename debugfs entry for %s\n", 375 __func__, clk->name); 376 } 377 378 /** 379 * clk_debug_init - lazily create the debugfs clk tree visualization 380 * 381 * clks are often initialized very early during boot before memory can 382 * be dynamically allocated and well before debugfs is setup. 383 * clk_debug_init walks the clk tree hierarchy while holding 384 * prepare_lock and creates the topology as part of a late_initcall, 385 * thus insuring that clks initialized very early will still be 386 * represented in the debugfs clk tree. This function should only be 387 * called once at boot-time, and all other clks added dynamically will 388 * be done so with clk_debug_register. 389 */ 390 static int __init clk_debug_init(void) 391 { 392 struct clk *clk; 393 struct dentry *d; 394 395 rootdir = debugfs_create_dir("clk", NULL); 396 397 if (!rootdir) 398 return -ENOMEM; 399 400 d = debugfs_create_file("clk_summary", S_IRUGO, rootdir, NULL, 401 &clk_summary_fops); 402 if (!d) 403 return -ENOMEM; 404 405 d = debugfs_create_file("clk_dump", S_IRUGO, rootdir, NULL, 406 &clk_dump_fops); 407 if (!d) 408 return -ENOMEM; 409 410 orphandir = debugfs_create_dir("orphans", rootdir); 411 412 if (!orphandir) 413 return -ENOMEM; 414 415 clk_prepare_lock(); 416 417 hlist_for_each_entry(clk, &clk_root_list, child_node) 418 clk_debug_create_subtree(clk, rootdir); 419 420 hlist_for_each_entry(clk, &clk_orphan_list, child_node) 421 clk_debug_create_subtree(clk, orphandir); 422 423 inited = 1; 424 425 clk_prepare_unlock(); 426 427 return 0; 428 } 429 late_initcall(clk_debug_init); 430 #else 431 static inline int clk_debug_register(struct clk *clk) { return 0; } 432 static inline void clk_debug_reparent(struct clk *clk, struct clk *new_parent) 433 { 434 } 435 #endif 436 437 /* caller must hold prepare_lock */ 438 static void clk_unprepare_unused_subtree(struct clk *clk) 439 { 440 struct clk *child; 441 442 if (!clk) 443 return; 444 445 hlist_for_each_entry(child, &clk->children, child_node) 446 clk_unprepare_unused_subtree(child); 447 448 if (clk->prepare_count) 449 return; 450 451 if (clk->flags & CLK_IGNORE_UNUSED) 452 return; 453 454 if (__clk_is_prepared(clk)) { 455 if (clk->ops->unprepare_unused) 456 clk->ops->unprepare_unused(clk->hw); 457 else if (clk->ops->unprepare) 458 clk->ops->unprepare(clk->hw); 459 } 460 } 461 EXPORT_SYMBOL_GPL(__clk_get_flags); 462 463 /* caller must hold prepare_lock */ 464 static void clk_disable_unused_subtree(struct clk *clk) 465 { 466 struct clk *child; 467 unsigned long flags; 468 469 if (!clk) 470 goto out; 471 472 hlist_for_each_entry(child, &clk->children, child_node) 473 clk_disable_unused_subtree(child); 474 475 flags = clk_enable_lock(); 476 477 if (clk->enable_count) 478 goto unlock_out; 479 480 if (clk->flags & CLK_IGNORE_UNUSED) 481 goto unlock_out; 482 483 /* 484 * some gate clocks have special needs during the disable-unused 485 * sequence. call .disable_unused if available, otherwise fall 486 * back to .disable 487 */ 488 if (__clk_is_enabled(clk)) { 489 if (clk->ops->disable_unused) 490 clk->ops->disable_unused(clk->hw); 491 else if (clk->ops->disable) 492 clk->ops->disable(clk->hw); 493 } 494 495 unlock_out: 496 clk_enable_unlock(flags); 497 498 out: 499 return; 500 } 501 502 static bool clk_ignore_unused; 503 static int __init clk_ignore_unused_setup(char *__unused) 504 { 505 clk_ignore_unused = true; 506 return 1; 507 } 508 __setup("clk_ignore_unused", clk_ignore_unused_setup); 509 510 static int clk_disable_unused(void) 511 { 512 struct clk *clk; 513 514 if (clk_ignore_unused) { 515 pr_warn("clk: Not disabling unused clocks\n"); 516 return 0; 517 } 518 519 clk_prepare_lock(); 520 521 hlist_for_each_entry(clk, &clk_root_list, child_node) 522 clk_disable_unused_subtree(clk); 523 524 hlist_for_each_entry(clk, &clk_orphan_list, child_node) 525 clk_disable_unused_subtree(clk); 526 527 hlist_for_each_entry(clk, &clk_root_list, child_node) 528 clk_unprepare_unused_subtree(clk); 529 530 hlist_for_each_entry(clk, &clk_orphan_list, child_node) 531 clk_unprepare_unused_subtree(clk); 532 533 clk_prepare_unlock(); 534 535 return 0; 536 } 537 late_initcall_sync(clk_disable_unused); 538 539 /*** helper functions ***/ 540 541 const char *__clk_get_name(struct clk *clk) 542 { 543 return !clk ? NULL : clk->name; 544 } 545 EXPORT_SYMBOL_GPL(__clk_get_name); 546 547 struct clk_hw *__clk_get_hw(struct clk *clk) 548 { 549 return !clk ? NULL : clk->hw; 550 } 551 552 u8 __clk_get_num_parents(struct clk *clk) 553 { 554 return !clk ? 0 : clk->num_parents; 555 } 556 557 struct clk *__clk_get_parent(struct clk *clk) 558 { 559 return !clk ? NULL : clk->parent; 560 } 561 562 unsigned int __clk_get_enable_count(struct clk *clk) 563 { 564 return !clk ? 0 : clk->enable_count; 565 } 566 567 unsigned int __clk_get_prepare_count(struct clk *clk) 568 { 569 return !clk ? 0 : clk->prepare_count; 570 } 571 572 unsigned long __clk_get_rate(struct clk *clk) 573 { 574 unsigned long ret; 575 576 if (!clk) { 577 ret = 0; 578 goto out; 579 } 580 581 ret = clk->rate; 582 583 if (clk->flags & CLK_IS_ROOT) 584 goto out; 585 586 if (!clk->parent) 587 ret = 0; 588 589 out: 590 return ret; 591 } 592 593 unsigned long __clk_get_flags(struct clk *clk) 594 { 595 return !clk ? 0 : clk->flags; 596 } 597 598 bool __clk_is_prepared(struct clk *clk) 599 { 600 int ret; 601 602 if (!clk) 603 return false; 604 605 /* 606 * .is_prepared is optional for clocks that can prepare 607 * fall back to software usage counter if it is missing 608 */ 609 if (!clk->ops->is_prepared) { 610 ret = clk->prepare_count ? 1 : 0; 611 goto out; 612 } 613 614 ret = clk->ops->is_prepared(clk->hw); 615 out: 616 return !!ret; 617 } 618 619 bool __clk_is_enabled(struct clk *clk) 620 { 621 int ret; 622 623 if (!clk) 624 return false; 625 626 /* 627 * .is_enabled is only mandatory for clocks that gate 628 * fall back to software usage counter if .is_enabled is missing 629 */ 630 if (!clk->ops->is_enabled) { 631 ret = clk->enable_count ? 1 : 0; 632 goto out; 633 } 634 635 ret = clk->ops->is_enabled(clk->hw); 636 out: 637 return !!ret; 638 } 639 640 static struct clk *__clk_lookup_subtree(const char *name, struct clk *clk) 641 { 642 struct clk *child; 643 struct clk *ret; 644 645 if (!strcmp(clk->name, name)) 646 return clk; 647 648 hlist_for_each_entry(child, &clk->children, child_node) { 649 ret = __clk_lookup_subtree(name, child); 650 if (ret) 651 return ret; 652 } 653 654 return NULL; 655 } 656 657 struct clk *__clk_lookup(const char *name) 658 { 659 struct clk *root_clk; 660 struct clk *ret; 661 662 if (!name) 663 return NULL; 664 665 /* search the 'proper' clk tree first */ 666 hlist_for_each_entry(root_clk, &clk_root_list, child_node) { 667 ret = __clk_lookup_subtree(name, root_clk); 668 if (ret) 669 return ret; 670 } 671 672 /* if not found, then search the orphan tree */ 673 hlist_for_each_entry(root_clk, &clk_orphan_list, child_node) { 674 ret = __clk_lookup_subtree(name, root_clk); 675 if (ret) 676 return ret; 677 } 678 679 return NULL; 680 } 681 682 /*** clk api ***/ 683 684 void __clk_unprepare(struct clk *clk) 685 { 686 if (!clk) 687 return; 688 689 if (WARN_ON(clk->prepare_count == 0)) 690 return; 691 692 if (--clk->prepare_count > 0) 693 return; 694 695 WARN_ON(clk->enable_count > 0); 696 697 if (clk->ops->unprepare) 698 clk->ops->unprepare(clk->hw); 699 700 __clk_unprepare(clk->parent); 701 } 702 703 /** 704 * clk_unprepare - undo preparation of a clock source 705 * @clk: the clk being unprepare 706 * 707 * clk_unprepare may sleep, which differentiates it from clk_disable. In a 708 * simple case, clk_unprepare can be used instead of clk_disable to gate a clk 709 * if the operation may sleep. One example is a clk which is accessed over 710 * I2c. In the complex case a clk gate operation may require a fast and a slow 711 * part. It is this reason that clk_unprepare and clk_disable are not mutually 712 * exclusive. In fact clk_disable must be called before clk_unprepare. 713 */ 714 void clk_unprepare(struct clk *clk) 715 { 716 clk_prepare_lock(); 717 __clk_unprepare(clk); 718 clk_prepare_unlock(); 719 } 720 EXPORT_SYMBOL_GPL(clk_unprepare); 721 722 int __clk_prepare(struct clk *clk) 723 { 724 int ret = 0; 725 726 if (!clk) 727 return 0; 728 729 if (clk->prepare_count == 0) { 730 ret = __clk_prepare(clk->parent); 731 if (ret) 732 return ret; 733 734 if (clk->ops->prepare) { 735 ret = clk->ops->prepare(clk->hw); 736 if (ret) { 737 __clk_unprepare(clk->parent); 738 return ret; 739 } 740 } 741 } 742 743 clk->prepare_count++; 744 745 return 0; 746 } 747 748 /** 749 * clk_prepare - prepare a clock source 750 * @clk: the clk being prepared 751 * 752 * clk_prepare may sleep, which differentiates it from clk_enable. In a simple 753 * case, clk_prepare can be used instead of clk_enable to ungate a clk if the 754 * operation may sleep. One example is a clk which is accessed over I2c. In 755 * the complex case a clk ungate operation may require a fast and a slow part. 756 * It is this reason that clk_prepare and clk_enable are not mutually 757 * exclusive. In fact clk_prepare must be called before clk_enable. 758 * Returns 0 on success, -EERROR otherwise. 759 */ 760 int clk_prepare(struct clk *clk) 761 { 762 int ret; 763 764 clk_prepare_lock(); 765 ret = __clk_prepare(clk); 766 clk_prepare_unlock(); 767 768 return ret; 769 } 770 EXPORT_SYMBOL_GPL(clk_prepare); 771 772 static void __clk_disable(struct clk *clk) 773 { 774 if (!clk) 775 return; 776 777 if (WARN_ON(IS_ERR(clk))) 778 return; 779 780 if (WARN_ON(clk->enable_count == 0)) 781 return; 782 783 if (--clk->enable_count > 0) 784 return; 785 786 if (clk->ops->disable) 787 clk->ops->disable(clk->hw); 788 789 __clk_disable(clk->parent); 790 } 791 792 /** 793 * clk_disable - gate a clock 794 * @clk: the clk being gated 795 * 796 * clk_disable must not sleep, which differentiates it from clk_unprepare. In 797 * a simple case, clk_disable can be used instead of clk_unprepare to gate a 798 * clk if the operation is fast and will never sleep. One example is a 799 * SoC-internal clk which is controlled via simple register writes. In the 800 * complex case a clk gate operation may require a fast and a slow part. It is 801 * this reason that clk_unprepare and clk_disable are not mutually exclusive. 802 * In fact clk_disable must be called before clk_unprepare. 803 */ 804 void clk_disable(struct clk *clk) 805 { 806 unsigned long flags; 807 808 flags = clk_enable_lock(); 809 __clk_disable(clk); 810 clk_enable_unlock(flags); 811 } 812 EXPORT_SYMBOL_GPL(clk_disable); 813 814 static int __clk_enable(struct clk *clk) 815 { 816 int ret = 0; 817 818 if (!clk) 819 return 0; 820 821 if (WARN_ON(clk->prepare_count == 0)) 822 return -ESHUTDOWN; 823 824 if (clk->enable_count == 0) { 825 ret = __clk_enable(clk->parent); 826 827 if (ret) 828 return ret; 829 830 if (clk->ops->enable) { 831 ret = clk->ops->enable(clk->hw); 832 if (ret) { 833 __clk_disable(clk->parent); 834 return ret; 835 } 836 } 837 } 838 839 clk->enable_count++; 840 return 0; 841 } 842 843 /** 844 * clk_enable - ungate a clock 845 * @clk: the clk being ungated 846 * 847 * clk_enable must not sleep, which differentiates it from clk_prepare. In a 848 * simple case, clk_enable can be used instead of clk_prepare to ungate a clk 849 * if the operation will never sleep. One example is a SoC-internal clk which 850 * is controlled via simple register writes. In the complex case a clk ungate 851 * operation may require a fast and a slow part. It is this reason that 852 * clk_enable and clk_prepare are not mutually exclusive. In fact clk_prepare 853 * must be called before clk_enable. Returns 0 on success, -EERROR 854 * otherwise. 855 */ 856 int clk_enable(struct clk *clk) 857 { 858 unsigned long flags; 859 int ret; 860 861 flags = clk_enable_lock(); 862 ret = __clk_enable(clk); 863 clk_enable_unlock(flags); 864 865 return ret; 866 } 867 EXPORT_SYMBOL_GPL(clk_enable); 868 869 /** 870 * __clk_round_rate - round the given rate for a clk 871 * @clk: round the rate of this clock 872 * 873 * Caller must hold prepare_lock. Useful for clk_ops such as .set_rate 874 */ 875 unsigned long __clk_round_rate(struct clk *clk, unsigned long rate) 876 { 877 unsigned long parent_rate = 0; 878 879 if (!clk) 880 return 0; 881 882 if (!clk->ops->round_rate) { 883 if (clk->flags & CLK_SET_RATE_PARENT) 884 return __clk_round_rate(clk->parent, rate); 885 else 886 return clk->rate; 887 } 888 889 if (clk->parent) 890 parent_rate = clk->parent->rate; 891 892 return clk->ops->round_rate(clk->hw, rate, &parent_rate); 893 } 894 895 /** 896 * clk_round_rate - round the given rate for a clk 897 * @clk: the clk for which we are rounding a rate 898 * @rate: the rate which is to be rounded 899 * 900 * Takes in a rate as input and rounds it to a rate that the clk can actually 901 * use which is then returned. If clk doesn't support round_rate operation 902 * then the parent rate is returned. 903 */ 904 long clk_round_rate(struct clk *clk, unsigned long rate) 905 { 906 unsigned long ret; 907 908 clk_prepare_lock(); 909 ret = __clk_round_rate(clk, rate); 910 clk_prepare_unlock(); 911 912 return ret; 913 } 914 EXPORT_SYMBOL_GPL(clk_round_rate); 915 916 /** 917 * __clk_notify - call clk notifier chain 918 * @clk: struct clk * that is changing rate 919 * @msg: clk notifier type (see include/linux/clk.h) 920 * @old_rate: old clk rate 921 * @new_rate: new clk rate 922 * 923 * Triggers a notifier call chain on the clk rate-change notification 924 * for 'clk'. Passes a pointer to the struct clk and the previous 925 * and current rates to the notifier callback. Intended to be called by 926 * internal clock code only. Returns NOTIFY_DONE from the last driver 927 * called if all went well, or NOTIFY_STOP or NOTIFY_BAD immediately if 928 * a driver returns that. 929 */ 930 static int __clk_notify(struct clk *clk, unsigned long msg, 931 unsigned long old_rate, unsigned long new_rate) 932 { 933 struct clk_notifier *cn; 934 struct clk_notifier_data cnd; 935 int ret = NOTIFY_DONE; 936 937 cnd.clk = clk; 938 cnd.old_rate = old_rate; 939 cnd.new_rate = new_rate; 940 941 list_for_each_entry(cn, &clk_notifier_list, node) { 942 if (cn->clk == clk) { 943 ret = srcu_notifier_call_chain(&cn->notifier_head, msg, 944 &cnd); 945 break; 946 } 947 } 948 949 return ret; 950 } 951 952 /** 953 * __clk_recalc_rates 954 * @clk: first clk in the subtree 955 * @msg: notification type (see include/linux/clk.h) 956 * 957 * Walks the subtree of clks starting with clk and recalculates rates as it 958 * goes. Note that if a clk does not implement the .recalc_rate callback then 959 * it is assumed that the clock will take on the rate of it's parent. 960 * 961 * clk_recalc_rates also propagates the POST_RATE_CHANGE notification, 962 * if necessary. 963 * 964 * Caller must hold prepare_lock. 965 */ 966 static void __clk_recalc_rates(struct clk *clk, unsigned long msg) 967 { 968 unsigned long old_rate; 969 unsigned long parent_rate = 0; 970 struct clk *child; 971 972 old_rate = clk->rate; 973 974 if (clk->parent) 975 parent_rate = clk->parent->rate; 976 977 if (clk->ops->recalc_rate) 978 clk->rate = clk->ops->recalc_rate(clk->hw, parent_rate); 979 else 980 clk->rate = parent_rate; 981 982 /* 983 * ignore NOTIFY_STOP and NOTIFY_BAD return values for POST_RATE_CHANGE 984 * & ABORT_RATE_CHANGE notifiers 985 */ 986 if (clk->notifier_count && msg) 987 __clk_notify(clk, msg, old_rate, clk->rate); 988 989 hlist_for_each_entry(child, &clk->children, child_node) 990 __clk_recalc_rates(child, msg); 991 } 992 993 /** 994 * clk_get_rate - return the rate of clk 995 * @clk: the clk whose rate is being returned 996 * 997 * Simply returns the cached rate of the clk, unless CLK_GET_RATE_NOCACHE flag 998 * is set, which means a recalc_rate will be issued. 999 * If clk is NULL then returns 0. 1000 */ 1001 unsigned long clk_get_rate(struct clk *clk) 1002 { 1003 unsigned long rate; 1004 1005 clk_prepare_lock(); 1006 1007 if (clk && (clk->flags & CLK_GET_RATE_NOCACHE)) 1008 __clk_recalc_rates(clk, 0); 1009 1010 rate = __clk_get_rate(clk); 1011 clk_prepare_unlock(); 1012 1013 return rate; 1014 } 1015 EXPORT_SYMBOL_GPL(clk_get_rate); 1016 1017 /** 1018 * __clk_speculate_rates 1019 * @clk: first clk in the subtree 1020 * @parent_rate: the "future" rate of clk's parent 1021 * 1022 * Walks the subtree of clks starting with clk, speculating rates as it 1023 * goes and firing off PRE_RATE_CHANGE notifications as necessary. 1024 * 1025 * Unlike clk_recalc_rates, clk_speculate_rates exists only for sending 1026 * pre-rate change notifications and returns early if no clks in the 1027 * subtree have subscribed to the notifications. Note that if a clk does not 1028 * implement the .recalc_rate callback then it is assumed that the clock will 1029 * take on the rate of it's parent. 1030 * 1031 * Caller must hold prepare_lock. 1032 */ 1033 static int __clk_speculate_rates(struct clk *clk, unsigned long parent_rate) 1034 { 1035 struct clk *child; 1036 unsigned long new_rate; 1037 int ret = NOTIFY_DONE; 1038 1039 if (clk->ops->recalc_rate) 1040 new_rate = clk->ops->recalc_rate(clk->hw, parent_rate); 1041 else 1042 new_rate = parent_rate; 1043 1044 /* abort rate change if a driver returns NOTIFY_BAD or NOTIFY_STOP */ 1045 if (clk->notifier_count) 1046 ret = __clk_notify(clk, PRE_RATE_CHANGE, clk->rate, new_rate); 1047 1048 if (ret & NOTIFY_STOP_MASK) 1049 goto out; 1050 1051 hlist_for_each_entry(child, &clk->children, child_node) { 1052 ret = __clk_speculate_rates(child, new_rate); 1053 if (ret & NOTIFY_STOP_MASK) 1054 break; 1055 } 1056 1057 out: 1058 return ret; 1059 } 1060 1061 static void clk_calc_subtree(struct clk *clk, unsigned long new_rate) 1062 { 1063 struct clk *child; 1064 1065 clk->new_rate = new_rate; 1066 1067 hlist_for_each_entry(child, &clk->children, child_node) { 1068 if (child->ops->recalc_rate) 1069 child->new_rate = child->ops->recalc_rate(child->hw, new_rate); 1070 else 1071 child->new_rate = new_rate; 1072 clk_calc_subtree(child, child->new_rate); 1073 } 1074 } 1075 1076 /* 1077 * calculate the new rates returning the topmost clock that has to be 1078 * changed. 1079 */ 1080 static struct clk *clk_calc_new_rates(struct clk *clk, unsigned long rate) 1081 { 1082 struct clk *top = clk; 1083 unsigned long best_parent_rate = 0; 1084 unsigned long new_rate; 1085 1086 /* sanity */ 1087 if (IS_ERR_OR_NULL(clk)) 1088 return NULL; 1089 1090 /* save parent rate, if it exists */ 1091 if (clk->parent) 1092 best_parent_rate = clk->parent->rate; 1093 1094 /* never propagate up to the parent */ 1095 if (!(clk->flags & CLK_SET_RATE_PARENT)) { 1096 if (!clk->ops->round_rate) { 1097 clk->new_rate = clk->rate; 1098 return NULL; 1099 } 1100 new_rate = clk->ops->round_rate(clk->hw, rate, &best_parent_rate); 1101 goto out; 1102 } 1103 1104 /* need clk->parent from here on out */ 1105 if (!clk->parent) { 1106 pr_debug("%s: %s has NULL parent\n", __func__, clk->name); 1107 return NULL; 1108 } 1109 1110 if (!clk->ops->round_rate) { 1111 top = clk_calc_new_rates(clk->parent, rate); 1112 new_rate = clk->parent->new_rate; 1113 1114 goto out; 1115 } 1116 1117 new_rate = clk->ops->round_rate(clk->hw, rate, &best_parent_rate); 1118 1119 if (best_parent_rate != clk->parent->rate) { 1120 top = clk_calc_new_rates(clk->parent, best_parent_rate); 1121 1122 goto out; 1123 } 1124 1125 out: 1126 clk_calc_subtree(clk, new_rate); 1127 1128 return top; 1129 } 1130 1131 /* 1132 * Notify about rate changes in a subtree. Always walk down the whole tree 1133 * so that in case of an error we can walk down the whole tree again and 1134 * abort the change. 1135 */ 1136 static struct clk *clk_propagate_rate_change(struct clk *clk, unsigned long event) 1137 { 1138 struct clk *child, *fail_clk = NULL; 1139 int ret = NOTIFY_DONE; 1140 1141 if (clk->rate == clk->new_rate) 1142 return NULL; 1143 1144 if (clk->notifier_count) { 1145 ret = __clk_notify(clk, event, clk->rate, clk->new_rate); 1146 if (ret & NOTIFY_STOP_MASK) 1147 fail_clk = clk; 1148 } 1149 1150 hlist_for_each_entry(child, &clk->children, child_node) { 1151 clk = clk_propagate_rate_change(child, event); 1152 if (clk) 1153 fail_clk = clk; 1154 } 1155 1156 return fail_clk; 1157 } 1158 1159 /* 1160 * walk down a subtree and set the new rates notifying the rate 1161 * change on the way 1162 */ 1163 static void clk_change_rate(struct clk *clk) 1164 { 1165 struct clk *child; 1166 unsigned long old_rate; 1167 unsigned long best_parent_rate = 0; 1168 1169 old_rate = clk->rate; 1170 1171 if (clk->parent) 1172 best_parent_rate = clk->parent->rate; 1173 1174 if (clk->ops->set_rate) 1175 clk->ops->set_rate(clk->hw, clk->new_rate, best_parent_rate); 1176 1177 if (clk->ops->recalc_rate) 1178 clk->rate = clk->ops->recalc_rate(clk->hw, best_parent_rate); 1179 else 1180 clk->rate = best_parent_rate; 1181 1182 if (clk->notifier_count && old_rate != clk->rate) 1183 __clk_notify(clk, POST_RATE_CHANGE, old_rate, clk->rate); 1184 1185 hlist_for_each_entry(child, &clk->children, child_node) 1186 clk_change_rate(child); 1187 } 1188 1189 /** 1190 * clk_set_rate - specify a new rate for clk 1191 * @clk: the clk whose rate is being changed 1192 * @rate: the new rate for clk 1193 * 1194 * In the simplest case clk_set_rate will only adjust the rate of clk. 1195 * 1196 * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to 1197 * propagate up to clk's parent; whether or not this happens depends on the 1198 * outcome of clk's .round_rate implementation. If *parent_rate is unchanged 1199 * after calling .round_rate then upstream parent propagation is ignored. If 1200 * *parent_rate comes back with a new rate for clk's parent then we propagate 1201 * up to clk's parent and set it's rate. Upward propagation will continue 1202 * until either a clk does not support the CLK_SET_RATE_PARENT flag or 1203 * .round_rate stops requesting changes to clk's parent_rate. 1204 * 1205 * Rate changes are accomplished via tree traversal that also recalculates the 1206 * rates for the clocks and fires off POST_RATE_CHANGE notifiers. 1207 * 1208 * Returns 0 on success, -EERROR otherwise. 1209 */ 1210 int clk_set_rate(struct clk *clk, unsigned long rate) 1211 { 1212 struct clk *top, *fail_clk; 1213 int ret = 0; 1214 1215 /* prevent racing with updates to the clock topology */ 1216 clk_prepare_lock(); 1217 1218 /* bail early if nothing to do */ 1219 if (rate == clk_get_rate(clk)) 1220 goto out; 1221 1222 if ((clk->flags & CLK_SET_RATE_GATE) && clk->prepare_count) { 1223 ret = -EBUSY; 1224 goto out; 1225 } 1226 1227 /* calculate new rates and get the topmost changed clock */ 1228 top = clk_calc_new_rates(clk, rate); 1229 if (!top) { 1230 ret = -EINVAL; 1231 goto out; 1232 } 1233 1234 /* notify that we are about to change rates */ 1235 fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE); 1236 if (fail_clk) { 1237 pr_warn("%s: failed to set %s rate\n", __func__, 1238 fail_clk->name); 1239 clk_propagate_rate_change(top, ABORT_RATE_CHANGE); 1240 ret = -EBUSY; 1241 goto out; 1242 } 1243 1244 /* change the rates */ 1245 clk_change_rate(top); 1246 1247 out: 1248 clk_prepare_unlock(); 1249 1250 return ret; 1251 } 1252 EXPORT_SYMBOL_GPL(clk_set_rate); 1253 1254 /** 1255 * clk_get_parent - return the parent of a clk 1256 * @clk: the clk whose parent gets returned 1257 * 1258 * Simply returns clk->parent. Returns NULL if clk is NULL. 1259 */ 1260 struct clk *clk_get_parent(struct clk *clk) 1261 { 1262 struct clk *parent; 1263 1264 clk_prepare_lock(); 1265 parent = __clk_get_parent(clk); 1266 clk_prepare_unlock(); 1267 1268 return parent; 1269 } 1270 EXPORT_SYMBOL_GPL(clk_get_parent); 1271 1272 /* 1273 * .get_parent is mandatory for clocks with multiple possible parents. It is 1274 * optional for single-parent clocks. Always call .get_parent if it is 1275 * available and WARN if it is missing for multi-parent clocks. 1276 * 1277 * For single-parent clocks without .get_parent, first check to see if the 1278 * .parents array exists, and if so use it to avoid an expensive tree 1279 * traversal. If .parents does not exist then walk the tree with __clk_lookup. 1280 */ 1281 static struct clk *__clk_init_parent(struct clk *clk) 1282 { 1283 struct clk *ret = NULL; 1284 u8 index; 1285 1286 /* handle the trivial cases */ 1287 1288 if (!clk->num_parents) 1289 goto out; 1290 1291 if (clk->num_parents == 1) { 1292 if (IS_ERR_OR_NULL(clk->parent)) 1293 ret = clk->parent = __clk_lookup(clk->parent_names[0]); 1294 ret = clk->parent; 1295 goto out; 1296 } 1297 1298 if (!clk->ops->get_parent) { 1299 WARN(!clk->ops->get_parent, 1300 "%s: multi-parent clocks must implement .get_parent\n", 1301 __func__); 1302 goto out; 1303 }; 1304 1305 /* 1306 * Do our best to cache parent clocks in clk->parents. This prevents 1307 * unnecessary and expensive calls to __clk_lookup. We don't set 1308 * clk->parent here; that is done by the calling function 1309 */ 1310 1311 index = clk->ops->get_parent(clk->hw); 1312 1313 if (!clk->parents) 1314 clk->parents = 1315 kzalloc((sizeof(struct clk*) * clk->num_parents), 1316 GFP_KERNEL); 1317 1318 if (!clk->parents) 1319 ret = __clk_lookup(clk->parent_names[index]); 1320 else if (!clk->parents[index]) 1321 ret = clk->parents[index] = 1322 __clk_lookup(clk->parent_names[index]); 1323 else 1324 ret = clk->parents[index]; 1325 1326 out: 1327 return ret; 1328 } 1329 1330 static void clk_reparent(struct clk *clk, struct clk *new_parent) 1331 { 1332 hlist_del(&clk->child_node); 1333 1334 if (new_parent) 1335 hlist_add_head(&clk->child_node, &new_parent->children); 1336 else 1337 hlist_add_head(&clk->child_node, &clk_orphan_list); 1338 1339 clk->parent = new_parent; 1340 } 1341 1342 void __clk_reparent(struct clk *clk, struct clk *new_parent) 1343 { 1344 clk_reparent(clk, new_parent); 1345 clk_debug_reparent(clk, new_parent); 1346 __clk_recalc_rates(clk, POST_RATE_CHANGE); 1347 } 1348 1349 static u8 clk_fetch_parent_index(struct clk *clk, struct clk *parent) 1350 { 1351 u8 i; 1352 1353 if (!clk->parents) 1354 clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents), 1355 GFP_KERNEL); 1356 1357 /* 1358 * find index of new parent clock using cached parent ptrs, 1359 * or if not yet cached, use string name comparison and cache 1360 * them now to avoid future calls to __clk_lookup. 1361 */ 1362 for (i = 0; i < clk->num_parents; i++) { 1363 if (clk->parents && clk->parents[i] == parent) 1364 break; 1365 else if (!strcmp(clk->parent_names[i], parent->name)) { 1366 if (clk->parents) 1367 clk->parents[i] = __clk_lookup(parent->name); 1368 break; 1369 } 1370 } 1371 1372 return i; 1373 } 1374 1375 static int __clk_set_parent(struct clk *clk, struct clk *parent, u8 p_index) 1376 { 1377 unsigned long flags; 1378 int ret = 0; 1379 struct clk *old_parent = clk->parent; 1380 1381 /* 1382 * Migrate prepare state between parents and prevent race with 1383 * clk_enable(). 1384 * 1385 * If the clock is not prepared, then a race with 1386 * clk_enable/disable() is impossible since we already have the 1387 * prepare lock (future calls to clk_enable() need to be preceded by 1388 * a clk_prepare()). 1389 * 1390 * If the clock is prepared, migrate the prepared state to the new 1391 * parent and also protect against a race with clk_enable() by 1392 * forcing the clock and the new parent on. This ensures that all 1393 * future calls to clk_enable() are practically NOPs with respect to 1394 * hardware and software states. 1395 * 1396 * See also: Comment for clk_set_parent() below. 1397 */ 1398 if (clk->prepare_count) { 1399 __clk_prepare(parent); 1400 clk_enable(parent); 1401 clk_enable(clk); 1402 } 1403 1404 /* update the clk tree topology */ 1405 flags = clk_enable_lock(); 1406 clk_reparent(clk, parent); 1407 clk_enable_unlock(flags); 1408 1409 /* change clock input source */ 1410 if (parent && clk->ops->set_parent) 1411 ret = clk->ops->set_parent(clk->hw, p_index); 1412 1413 if (ret) { 1414 flags = clk_enable_lock(); 1415 clk_reparent(clk, old_parent); 1416 clk_enable_unlock(flags); 1417 1418 if (clk->prepare_count) { 1419 clk_disable(clk); 1420 clk_disable(parent); 1421 __clk_unprepare(parent); 1422 } 1423 return ret; 1424 } 1425 1426 /* 1427 * Finish the migration of prepare state and undo the changes done 1428 * for preventing a race with clk_enable(). 1429 */ 1430 if (clk->prepare_count) { 1431 clk_disable(clk); 1432 clk_disable(old_parent); 1433 __clk_unprepare(old_parent); 1434 } 1435 1436 /* update debugfs with new clk tree topology */ 1437 clk_debug_reparent(clk, parent); 1438 return 0; 1439 } 1440 1441 /** 1442 * clk_set_parent - switch the parent of a mux clk 1443 * @clk: the mux clk whose input we are switching 1444 * @parent: the new input to clk 1445 * 1446 * Re-parent clk to use parent as its new input source. If clk is in 1447 * prepared state, the clk will get enabled for the duration of this call. If 1448 * that's not acceptable for a specific clk (Eg: the consumer can't handle 1449 * that, the reparenting is glitchy in hardware, etc), use the 1450 * CLK_SET_PARENT_GATE flag to allow reparenting only when clk is unprepared. 1451 * 1452 * After successfully changing clk's parent clk_set_parent will update the 1453 * clk topology, sysfs topology and propagate rate recalculation via 1454 * __clk_recalc_rates. 1455 * 1456 * Returns 0 on success, -EERROR otherwise. 1457 */ 1458 int clk_set_parent(struct clk *clk, struct clk *parent) 1459 { 1460 int ret = 0; 1461 u8 p_index = 0; 1462 unsigned long p_rate = 0; 1463 1464 if (!clk || !clk->ops) 1465 return -EINVAL; 1466 1467 /* verify ops for for multi-parent clks */ 1468 if ((clk->num_parents > 1) && (!clk->ops->set_parent)) 1469 return -ENOSYS; 1470 1471 /* prevent racing with updates to the clock topology */ 1472 clk_prepare_lock(); 1473 1474 if (clk->parent == parent) 1475 goto out; 1476 1477 /* check that we are allowed to re-parent if the clock is in use */ 1478 if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) { 1479 ret = -EBUSY; 1480 goto out; 1481 } 1482 1483 /* try finding the new parent index */ 1484 if (parent) { 1485 p_index = clk_fetch_parent_index(clk, parent); 1486 p_rate = parent->rate; 1487 if (p_index == clk->num_parents) { 1488 pr_debug("%s: clk %s can not be parent of clk %s\n", 1489 __func__, parent->name, clk->name); 1490 ret = -EINVAL; 1491 goto out; 1492 } 1493 } 1494 1495 /* propagate PRE_RATE_CHANGE notifications */ 1496 ret = __clk_speculate_rates(clk, p_rate); 1497 1498 /* abort if a driver objects */ 1499 if (ret & NOTIFY_STOP_MASK) 1500 goto out; 1501 1502 /* do the re-parent */ 1503 ret = __clk_set_parent(clk, parent, p_index); 1504 1505 /* propagate rate recalculation accordingly */ 1506 if (ret) 1507 __clk_recalc_rates(clk, ABORT_RATE_CHANGE); 1508 else 1509 __clk_recalc_rates(clk, POST_RATE_CHANGE); 1510 1511 out: 1512 clk_prepare_unlock(); 1513 1514 return ret; 1515 } 1516 EXPORT_SYMBOL_GPL(clk_set_parent); 1517 1518 /** 1519 * __clk_init - initialize the data structures in a struct clk 1520 * @dev: device initializing this clk, placeholder for now 1521 * @clk: clk being initialized 1522 * 1523 * Initializes the lists in struct clk, queries the hardware for the 1524 * parent and rate and sets them both. 1525 */ 1526 int __clk_init(struct device *dev, struct clk *clk) 1527 { 1528 int i, ret = 0; 1529 struct clk *orphan; 1530 struct hlist_node *tmp2; 1531 1532 if (!clk) 1533 return -EINVAL; 1534 1535 clk_prepare_lock(); 1536 1537 /* check to see if a clock with this name is already registered */ 1538 if (__clk_lookup(clk->name)) { 1539 pr_debug("%s: clk %s already initialized\n", 1540 __func__, clk->name); 1541 ret = -EEXIST; 1542 goto out; 1543 } 1544 1545 /* check that clk_ops are sane. See Documentation/clk.txt */ 1546 if (clk->ops->set_rate && 1547 !(clk->ops->round_rate && clk->ops->recalc_rate)) { 1548 pr_warning("%s: %s must implement .round_rate & .recalc_rate\n", 1549 __func__, clk->name); 1550 ret = -EINVAL; 1551 goto out; 1552 } 1553 1554 if (clk->ops->set_parent && !clk->ops->get_parent) { 1555 pr_warning("%s: %s must implement .get_parent & .set_parent\n", 1556 __func__, clk->name); 1557 ret = -EINVAL; 1558 goto out; 1559 } 1560 1561 /* throw a WARN if any entries in parent_names are NULL */ 1562 for (i = 0; i < clk->num_parents; i++) 1563 WARN(!clk->parent_names[i], 1564 "%s: invalid NULL in %s's .parent_names\n", 1565 __func__, clk->name); 1566 1567 /* 1568 * Allocate an array of struct clk *'s to avoid unnecessary string 1569 * look-ups of clk's possible parents. This can fail for clocks passed 1570 * in to clk_init during early boot; thus any access to clk->parents[] 1571 * must always check for a NULL pointer and try to populate it if 1572 * necessary. 1573 * 1574 * If clk->parents is not NULL we skip this entire block. This allows 1575 * for clock drivers to statically initialize clk->parents. 1576 */ 1577 if (clk->num_parents > 1 && !clk->parents) { 1578 clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents), 1579 GFP_KERNEL); 1580 /* 1581 * __clk_lookup returns NULL for parents that have not been 1582 * clk_init'd; thus any access to clk->parents[] must check 1583 * for a NULL pointer. We can always perform lazy lookups for 1584 * missing parents later on. 1585 */ 1586 if (clk->parents) 1587 for (i = 0; i < clk->num_parents; i++) 1588 clk->parents[i] = 1589 __clk_lookup(clk->parent_names[i]); 1590 } 1591 1592 clk->parent = __clk_init_parent(clk); 1593 1594 /* 1595 * Populate clk->parent if parent has already been __clk_init'd. If 1596 * parent has not yet been __clk_init'd then place clk in the orphan 1597 * list. If clk has set the CLK_IS_ROOT flag then place it in the root 1598 * clk list. 1599 * 1600 * Every time a new clk is clk_init'd then we walk the list of orphan 1601 * clocks and re-parent any that are children of the clock currently 1602 * being clk_init'd. 1603 */ 1604 if (clk->parent) 1605 hlist_add_head(&clk->child_node, 1606 &clk->parent->children); 1607 else if (clk->flags & CLK_IS_ROOT) 1608 hlist_add_head(&clk->child_node, &clk_root_list); 1609 else 1610 hlist_add_head(&clk->child_node, &clk_orphan_list); 1611 1612 /* 1613 * Set clk's rate. The preferred method is to use .recalc_rate. For 1614 * simple clocks and lazy developers the default fallback is to use the 1615 * parent's rate. If a clock doesn't have a parent (or is orphaned) 1616 * then rate is set to zero. 1617 */ 1618 if (clk->ops->recalc_rate) 1619 clk->rate = clk->ops->recalc_rate(clk->hw, 1620 __clk_get_rate(clk->parent)); 1621 else if (clk->parent) 1622 clk->rate = clk->parent->rate; 1623 else 1624 clk->rate = 0; 1625 1626 /* 1627 * walk the list of orphan clocks and reparent any that are children of 1628 * this clock 1629 */ 1630 hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) { 1631 if (orphan->ops->get_parent) { 1632 i = orphan->ops->get_parent(orphan->hw); 1633 if (!strcmp(clk->name, orphan->parent_names[i])) 1634 __clk_reparent(orphan, clk); 1635 continue; 1636 } 1637 1638 for (i = 0; i < orphan->num_parents; i++) 1639 if (!strcmp(clk->name, orphan->parent_names[i])) { 1640 __clk_reparent(orphan, clk); 1641 break; 1642 } 1643 } 1644 1645 /* 1646 * optional platform-specific magic 1647 * 1648 * The .init callback is not used by any of the basic clock types, but 1649 * exists for weird hardware that must perform initialization magic. 1650 * Please consider other ways of solving initialization problems before 1651 * using this callback, as it's use is discouraged. 1652 */ 1653 if (clk->ops->init) 1654 clk->ops->init(clk->hw); 1655 1656 clk_debug_register(clk); 1657 1658 out: 1659 clk_prepare_unlock(); 1660 1661 return ret; 1662 } 1663 1664 /** 1665 * __clk_register - register a clock and return a cookie. 1666 * 1667 * Same as clk_register, except that the .clk field inside hw shall point to a 1668 * preallocated (generally statically allocated) struct clk. None of the fields 1669 * of the struct clk need to be initialized. 1670 * 1671 * The data pointed to by .init and .clk field shall NOT be marked as init 1672 * data. 1673 * 1674 * __clk_register is only exposed via clk-private.h and is intended for use with 1675 * very large numbers of clocks that need to be statically initialized. It is 1676 * a layering violation to include clk-private.h from any code which implements 1677 * a clock's .ops; as such any statically initialized clock data MUST be in a 1678 * separate C file from the logic that implements it's operations. Returns 0 1679 * on success, otherwise an error code. 1680 */ 1681 struct clk *__clk_register(struct device *dev, struct clk_hw *hw) 1682 { 1683 int ret; 1684 struct clk *clk; 1685 1686 clk = hw->clk; 1687 clk->name = hw->init->name; 1688 clk->ops = hw->init->ops; 1689 clk->hw = hw; 1690 clk->flags = hw->init->flags; 1691 clk->parent_names = hw->init->parent_names; 1692 clk->num_parents = hw->init->num_parents; 1693 1694 ret = __clk_init(dev, clk); 1695 if (ret) 1696 return ERR_PTR(ret); 1697 1698 return clk; 1699 } 1700 EXPORT_SYMBOL_GPL(__clk_register); 1701 1702 static int _clk_register(struct device *dev, struct clk_hw *hw, struct clk *clk) 1703 { 1704 int i, ret; 1705 1706 clk->name = kstrdup(hw->init->name, GFP_KERNEL); 1707 if (!clk->name) { 1708 pr_err("%s: could not allocate clk->name\n", __func__); 1709 ret = -ENOMEM; 1710 goto fail_name; 1711 } 1712 clk->ops = hw->init->ops; 1713 clk->hw = hw; 1714 clk->flags = hw->init->flags; 1715 clk->num_parents = hw->init->num_parents; 1716 hw->clk = clk; 1717 1718 /* allocate local copy in case parent_names is __initdata */ 1719 clk->parent_names = kzalloc((sizeof(char*) * clk->num_parents), 1720 GFP_KERNEL); 1721 1722 if (!clk->parent_names) { 1723 pr_err("%s: could not allocate clk->parent_names\n", __func__); 1724 ret = -ENOMEM; 1725 goto fail_parent_names; 1726 } 1727 1728 1729 /* copy each string name in case parent_names is __initdata */ 1730 for (i = 0; i < clk->num_parents; i++) { 1731 clk->parent_names[i] = kstrdup(hw->init->parent_names[i], 1732 GFP_KERNEL); 1733 if (!clk->parent_names[i]) { 1734 pr_err("%s: could not copy parent_names\n", __func__); 1735 ret = -ENOMEM; 1736 goto fail_parent_names_copy; 1737 } 1738 } 1739 1740 ret = __clk_init(dev, clk); 1741 if (!ret) 1742 return 0; 1743 1744 fail_parent_names_copy: 1745 while (--i >= 0) 1746 kfree(clk->parent_names[i]); 1747 kfree(clk->parent_names); 1748 fail_parent_names: 1749 kfree(clk->name); 1750 fail_name: 1751 return ret; 1752 } 1753 1754 /** 1755 * clk_register - allocate a new clock, register it and return an opaque cookie 1756 * @dev: device that is registering this clock 1757 * @hw: link to hardware-specific clock data 1758 * 1759 * clk_register is the primary interface for populating the clock tree with new 1760 * clock nodes. It returns a pointer to the newly allocated struct clk which 1761 * cannot be dereferenced by driver code but may be used in conjuction with the 1762 * rest of the clock API. In the event of an error clk_register will return an 1763 * error code; drivers must test for an error code after calling clk_register. 1764 */ 1765 struct clk *clk_register(struct device *dev, struct clk_hw *hw) 1766 { 1767 int ret; 1768 struct clk *clk; 1769 1770 clk = kzalloc(sizeof(*clk), GFP_KERNEL); 1771 if (!clk) { 1772 pr_err("%s: could not allocate clk\n", __func__); 1773 ret = -ENOMEM; 1774 goto fail_out; 1775 } 1776 1777 ret = _clk_register(dev, hw, clk); 1778 if (!ret) 1779 return clk; 1780 1781 kfree(clk); 1782 fail_out: 1783 return ERR_PTR(ret); 1784 } 1785 EXPORT_SYMBOL_GPL(clk_register); 1786 1787 /** 1788 * clk_unregister - unregister a currently registered clock 1789 * @clk: clock to unregister 1790 * 1791 * Currently unimplemented. 1792 */ 1793 void clk_unregister(struct clk *clk) {} 1794 EXPORT_SYMBOL_GPL(clk_unregister); 1795 1796 static void devm_clk_release(struct device *dev, void *res) 1797 { 1798 clk_unregister(res); 1799 } 1800 1801 /** 1802 * devm_clk_register - resource managed clk_register() 1803 * @dev: device that is registering this clock 1804 * @hw: link to hardware-specific clock data 1805 * 1806 * Managed clk_register(). Clocks returned from this function are 1807 * automatically clk_unregister()ed on driver detach. See clk_register() for 1808 * more information. 1809 */ 1810 struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw) 1811 { 1812 struct clk *clk; 1813 int ret; 1814 1815 clk = devres_alloc(devm_clk_release, sizeof(*clk), GFP_KERNEL); 1816 if (!clk) 1817 return ERR_PTR(-ENOMEM); 1818 1819 ret = _clk_register(dev, hw, clk); 1820 if (!ret) { 1821 devres_add(dev, clk); 1822 } else { 1823 devres_free(clk); 1824 clk = ERR_PTR(ret); 1825 } 1826 1827 return clk; 1828 } 1829 EXPORT_SYMBOL_GPL(devm_clk_register); 1830 1831 static int devm_clk_match(struct device *dev, void *res, void *data) 1832 { 1833 struct clk *c = res; 1834 if (WARN_ON(!c)) 1835 return 0; 1836 return c == data; 1837 } 1838 1839 /** 1840 * devm_clk_unregister - resource managed clk_unregister() 1841 * @clk: clock to unregister 1842 * 1843 * Deallocate a clock allocated with devm_clk_register(). Normally 1844 * this function will not need to be called and the resource management 1845 * code will ensure that the resource is freed. 1846 */ 1847 void devm_clk_unregister(struct device *dev, struct clk *clk) 1848 { 1849 WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk)); 1850 } 1851 EXPORT_SYMBOL_GPL(devm_clk_unregister); 1852 1853 /*** clk rate change notifiers ***/ 1854 1855 /** 1856 * clk_notifier_register - add a clk rate change notifier 1857 * @clk: struct clk * to watch 1858 * @nb: struct notifier_block * with callback info 1859 * 1860 * Request notification when clk's rate changes. This uses an SRCU 1861 * notifier because we want it to block and notifier unregistrations are 1862 * uncommon. The callbacks associated with the notifier must not 1863 * re-enter into the clk framework by calling any top-level clk APIs; 1864 * this will cause a nested prepare_lock mutex. 1865 * 1866 * Pre-change notifier callbacks will be passed the current, pre-change 1867 * rate of the clk via struct clk_notifier_data.old_rate. The new, 1868 * post-change rate of the clk is passed via struct 1869 * clk_notifier_data.new_rate. 1870 * 1871 * Post-change notifiers will pass the now-current, post-change rate of 1872 * the clk in both struct clk_notifier_data.old_rate and struct 1873 * clk_notifier_data.new_rate. 1874 * 1875 * Abort-change notifiers are effectively the opposite of pre-change 1876 * notifiers: the original pre-change clk rate is passed in via struct 1877 * clk_notifier_data.new_rate and the failed post-change rate is passed 1878 * in via struct clk_notifier_data.old_rate. 1879 * 1880 * clk_notifier_register() must be called from non-atomic context. 1881 * Returns -EINVAL if called with null arguments, -ENOMEM upon 1882 * allocation failure; otherwise, passes along the return value of 1883 * srcu_notifier_chain_register(). 1884 */ 1885 int clk_notifier_register(struct clk *clk, struct notifier_block *nb) 1886 { 1887 struct clk_notifier *cn; 1888 int ret = -ENOMEM; 1889 1890 if (!clk || !nb) 1891 return -EINVAL; 1892 1893 clk_prepare_lock(); 1894 1895 /* search the list of notifiers for this clk */ 1896 list_for_each_entry(cn, &clk_notifier_list, node) 1897 if (cn->clk == clk) 1898 break; 1899 1900 /* if clk wasn't in the notifier list, allocate new clk_notifier */ 1901 if (cn->clk != clk) { 1902 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL); 1903 if (!cn) 1904 goto out; 1905 1906 cn->clk = clk; 1907 srcu_init_notifier_head(&cn->notifier_head); 1908 1909 list_add(&cn->node, &clk_notifier_list); 1910 } 1911 1912 ret = srcu_notifier_chain_register(&cn->notifier_head, nb); 1913 1914 clk->notifier_count++; 1915 1916 out: 1917 clk_prepare_unlock(); 1918 1919 return ret; 1920 } 1921 EXPORT_SYMBOL_GPL(clk_notifier_register); 1922 1923 /** 1924 * clk_notifier_unregister - remove a clk rate change notifier 1925 * @clk: struct clk * 1926 * @nb: struct notifier_block * with callback info 1927 * 1928 * Request no further notification for changes to 'clk' and frees memory 1929 * allocated in clk_notifier_register. 1930 * 1931 * Returns -EINVAL if called with null arguments; otherwise, passes 1932 * along the return value of srcu_notifier_chain_unregister(). 1933 */ 1934 int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb) 1935 { 1936 struct clk_notifier *cn = NULL; 1937 int ret = -EINVAL; 1938 1939 if (!clk || !nb) 1940 return -EINVAL; 1941 1942 clk_prepare_lock(); 1943 1944 list_for_each_entry(cn, &clk_notifier_list, node) 1945 if (cn->clk == clk) 1946 break; 1947 1948 if (cn->clk == clk) { 1949 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb); 1950 1951 clk->notifier_count--; 1952 1953 /* XXX the notifier code should handle this better */ 1954 if (!cn->notifier_head.head) { 1955 srcu_cleanup_notifier_head(&cn->notifier_head); 1956 list_del(&cn->node); 1957 kfree(cn); 1958 } 1959 1960 } else { 1961 ret = -ENOENT; 1962 } 1963 1964 clk_prepare_unlock(); 1965 1966 return ret; 1967 } 1968 EXPORT_SYMBOL_GPL(clk_notifier_unregister); 1969 1970 #ifdef CONFIG_OF 1971 /** 1972 * struct of_clk_provider - Clock provider registration structure 1973 * @link: Entry in global list of clock providers 1974 * @node: Pointer to device tree node of clock provider 1975 * @get: Get clock callback. Returns NULL or a struct clk for the 1976 * given clock specifier 1977 * @data: context pointer to be passed into @get callback 1978 */ 1979 struct of_clk_provider { 1980 struct list_head link; 1981 1982 struct device_node *node; 1983 struct clk *(*get)(struct of_phandle_args *clkspec, void *data); 1984 void *data; 1985 }; 1986 1987 extern struct of_device_id __clk_of_table[]; 1988 1989 static const struct of_device_id __clk_of_table_sentinel 1990 __used __section(__clk_of_table_end); 1991 1992 static LIST_HEAD(of_clk_providers); 1993 static DEFINE_MUTEX(of_clk_lock); 1994 1995 struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec, 1996 void *data) 1997 { 1998 return data; 1999 } 2000 EXPORT_SYMBOL_GPL(of_clk_src_simple_get); 2001 2002 struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data) 2003 { 2004 struct clk_onecell_data *clk_data = data; 2005 unsigned int idx = clkspec->args[0]; 2006 2007 if (idx >= clk_data->clk_num) { 2008 pr_err("%s: invalid clock index %d\n", __func__, idx); 2009 return ERR_PTR(-EINVAL); 2010 } 2011 2012 return clk_data->clks[idx]; 2013 } 2014 EXPORT_SYMBOL_GPL(of_clk_src_onecell_get); 2015 2016 /** 2017 * of_clk_add_provider() - Register a clock provider for a node 2018 * @np: Device node pointer associated with clock provider 2019 * @clk_src_get: callback for decoding clock 2020 * @data: context pointer for @clk_src_get callback. 2021 */ 2022 int of_clk_add_provider(struct device_node *np, 2023 struct clk *(*clk_src_get)(struct of_phandle_args *clkspec, 2024 void *data), 2025 void *data) 2026 { 2027 struct of_clk_provider *cp; 2028 2029 cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL); 2030 if (!cp) 2031 return -ENOMEM; 2032 2033 cp->node = of_node_get(np); 2034 cp->data = data; 2035 cp->get = clk_src_get; 2036 2037 mutex_lock(&of_clk_lock); 2038 list_add(&cp->link, &of_clk_providers); 2039 mutex_unlock(&of_clk_lock); 2040 pr_debug("Added clock from %s\n", np->full_name); 2041 2042 return 0; 2043 } 2044 EXPORT_SYMBOL_GPL(of_clk_add_provider); 2045 2046 /** 2047 * of_clk_del_provider() - Remove a previously registered clock provider 2048 * @np: Device node pointer associated with clock provider 2049 */ 2050 void of_clk_del_provider(struct device_node *np) 2051 { 2052 struct of_clk_provider *cp; 2053 2054 mutex_lock(&of_clk_lock); 2055 list_for_each_entry(cp, &of_clk_providers, link) { 2056 if (cp->node == np) { 2057 list_del(&cp->link); 2058 of_node_put(cp->node); 2059 kfree(cp); 2060 break; 2061 } 2062 } 2063 mutex_unlock(&of_clk_lock); 2064 } 2065 EXPORT_SYMBOL_GPL(of_clk_del_provider); 2066 2067 struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec) 2068 { 2069 struct of_clk_provider *provider; 2070 struct clk *clk = ERR_PTR(-ENOENT); 2071 2072 /* Check if we have such a provider in our array */ 2073 mutex_lock(&of_clk_lock); 2074 list_for_each_entry(provider, &of_clk_providers, link) { 2075 if (provider->node == clkspec->np) 2076 clk = provider->get(clkspec, provider->data); 2077 if (!IS_ERR(clk)) 2078 break; 2079 } 2080 mutex_unlock(&of_clk_lock); 2081 2082 return clk; 2083 } 2084 2085 const char *of_clk_get_parent_name(struct device_node *np, int index) 2086 { 2087 struct of_phandle_args clkspec; 2088 const char *clk_name; 2089 int rc; 2090 2091 if (index < 0) 2092 return NULL; 2093 2094 rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index, 2095 &clkspec); 2096 if (rc) 2097 return NULL; 2098 2099 if (of_property_read_string_index(clkspec.np, "clock-output-names", 2100 clkspec.args_count ? clkspec.args[0] : 0, 2101 &clk_name) < 0) 2102 clk_name = clkspec.np->name; 2103 2104 of_node_put(clkspec.np); 2105 return clk_name; 2106 } 2107 EXPORT_SYMBOL_GPL(of_clk_get_parent_name); 2108 2109 /** 2110 * of_clk_init() - Scan and init clock providers from the DT 2111 * @matches: array of compatible values and init functions for providers. 2112 * 2113 * This function scans the device tree for matching clock providers and 2114 * calls their initialization functions 2115 */ 2116 void __init of_clk_init(const struct of_device_id *matches) 2117 { 2118 struct device_node *np; 2119 2120 if (!matches) 2121 matches = __clk_of_table; 2122 2123 for_each_matching_node(np, matches) { 2124 const struct of_device_id *match = of_match_node(matches, np); 2125 of_clk_init_cb_t clk_init_cb = match->data; 2126 clk_init_cb(np); 2127 } 2128 } 2129 #endif 2130