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, c->rate); 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", c->rate); 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(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->rate) 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 bool migrated_enable = false; 1381 1382 /* migrate prepare */ 1383 if (clk->prepare_count) 1384 __clk_prepare(parent); 1385 1386 flags = clk_enable_lock(); 1387 1388 /* migrate enable */ 1389 if (clk->enable_count) { 1390 __clk_enable(parent); 1391 migrated_enable = true; 1392 } 1393 1394 /* update the clk tree topology */ 1395 clk_reparent(clk, parent); 1396 1397 clk_enable_unlock(flags); 1398 1399 /* change clock input source */ 1400 if (parent && clk->ops->set_parent) 1401 ret = clk->ops->set_parent(clk->hw, p_index); 1402 1403 if (ret) { 1404 /* 1405 * The error handling is tricky due to that we need to release 1406 * the spinlock while issuing the .set_parent callback. This 1407 * means the new parent might have been enabled/disabled in 1408 * between, which must be considered when doing rollback. 1409 */ 1410 flags = clk_enable_lock(); 1411 1412 clk_reparent(clk, old_parent); 1413 1414 if (migrated_enable && clk->enable_count) { 1415 __clk_disable(parent); 1416 } else if (migrated_enable && (clk->enable_count == 0)) { 1417 __clk_disable(old_parent); 1418 } else if (!migrated_enable && clk->enable_count) { 1419 __clk_disable(parent); 1420 __clk_enable(old_parent); 1421 } 1422 1423 clk_enable_unlock(flags); 1424 1425 if (clk->prepare_count) 1426 __clk_unprepare(parent); 1427 1428 return ret; 1429 } 1430 1431 /* clean up enable for old parent if migration was done */ 1432 if (migrated_enable) { 1433 flags = clk_enable_lock(); 1434 __clk_disable(old_parent); 1435 clk_enable_unlock(flags); 1436 } 1437 1438 /* clean up prepare for old parent if migration was done */ 1439 if (clk->prepare_count) 1440 __clk_unprepare(old_parent); 1441 1442 /* update debugfs with new clk tree topology */ 1443 clk_debug_reparent(clk, parent); 1444 return 0; 1445 } 1446 1447 /** 1448 * clk_set_parent - switch the parent of a mux clk 1449 * @clk: the mux clk whose input we are switching 1450 * @parent: the new input to clk 1451 * 1452 * Re-parent clk to use parent as it's new input source. If clk has the 1453 * CLK_SET_PARENT_GATE flag set then clk must be gated for this 1454 * operation to succeed. After successfully changing clk's parent 1455 * clk_set_parent will update the clk topology, sysfs topology and 1456 * propagate rate recalculation via __clk_recalc_rates. Returns 0 on 1457 * success, -EERROR otherwise. 1458 */ 1459 int clk_set_parent(struct clk *clk, struct clk *parent) 1460 { 1461 int ret = 0; 1462 u8 p_index = 0; 1463 unsigned long p_rate = 0; 1464 1465 if (!clk || !clk->ops) 1466 return -EINVAL; 1467 1468 /* verify ops for for multi-parent clks */ 1469 if ((clk->num_parents > 1) && (!clk->ops->set_parent)) 1470 return -ENOSYS; 1471 1472 /* prevent racing with updates to the clock topology */ 1473 clk_prepare_lock(); 1474 1475 if (clk->parent == parent) 1476 goto out; 1477 1478 /* check that we are allowed to re-parent if the clock is in use */ 1479 if ((clk->flags & CLK_SET_PARENT_GATE) && clk->prepare_count) { 1480 ret = -EBUSY; 1481 goto out; 1482 } 1483 1484 /* try finding the new parent index */ 1485 if (parent) { 1486 p_index = clk_fetch_parent_index(clk, parent); 1487 p_rate = parent->rate; 1488 if (p_index == clk->num_parents) { 1489 pr_debug("%s: clk %s can not be parent of clk %s\n", 1490 __func__, parent->name, clk->name); 1491 ret = -EINVAL; 1492 goto out; 1493 } 1494 } 1495 1496 /* propagate PRE_RATE_CHANGE notifications */ 1497 if (clk->notifier_count) 1498 ret = __clk_speculate_rates(clk, p_rate); 1499 1500 /* abort if a driver objects */ 1501 if (ret & NOTIFY_STOP_MASK) 1502 goto out; 1503 1504 /* do the re-parent */ 1505 ret = __clk_set_parent(clk, parent, p_index); 1506 1507 /* propagate rate recalculation accordingly */ 1508 if (ret) 1509 __clk_recalc_rates(clk, ABORT_RATE_CHANGE); 1510 else 1511 __clk_recalc_rates(clk, POST_RATE_CHANGE); 1512 1513 out: 1514 clk_prepare_unlock(); 1515 1516 return ret; 1517 } 1518 EXPORT_SYMBOL_GPL(clk_set_parent); 1519 1520 /** 1521 * __clk_init - initialize the data structures in a struct clk 1522 * @dev: device initializing this clk, placeholder for now 1523 * @clk: clk being initialized 1524 * 1525 * Initializes the lists in struct clk, queries the hardware for the 1526 * parent and rate and sets them both. 1527 */ 1528 int __clk_init(struct device *dev, struct clk *clk) 1529 { 1530 int i, ret = 0; 1531 struct clk *orphan; 1532 struct hlist_node *tmp2; 1533 1534 if (!clk) 1535 return -EINVAL; 1536 1537 clk_prepare_lock(); 1538 1539 /* check to see if a clock with this name is already registered */ 1540 if (__clk_lookup(clk->name)) { 1541 pr_debug("%s: clk %s already initialized\n", 1542 __func__, clk->name); 1543 ret = -EEXIST; 1544 goto out; 1545 } 1546 1547 /* check that clk_ops are sane. See Documentation/clk.txt */ 1548 if (clk->ops->set_rate && 1549 !(clk->ops->round_rate && clk->ops->recalc_rate)) { 1550 pr_warning("%s: %s must implement .round_rate & .recalc_rate\n", 1551 __func__, clk->name); 1552 ret = -EINVAL; 1553 goto out; 1554 } 1555 1556 if (clk->ops->set_parent && !clk->ops->get_parent) { 1557 pr_warning("%s: %s must implement .get_parent & .set_parent\n", 1558 __func__, clk->name); 1559 ret = -EINVAL; 1560 goto out; 1561 } 1562 1563 /* throw a WARN if any entries in parent_names are NULL */ 1564 for (i = 0; i < clk->num_parents; i++) 1565 WARN(!clk->parent_names[i], 1566 "%s: invalid NULL in %s's .parent_names\n", 1567 __func__, clk->name); 1568 1569 /* 1570 * Allocate an array of struct clk *'s to avoid unnecessary string 1571 * look-ups of clk's possible parents. This can fail for clocks passed 1572 * in to clk_init during early boot; thus any access to clk->parents[] 1573 * must always check for a NULL pointer and try to populate it if 1574 * necessary. 1575 * 1576 * If clk->parents is not NULL we skip this entire block. This allows 1577 * for clock drivers to statically initialize clk->parents. 1578 */ 1579 if (clk->num_parents > 1 && !clk->parents) { 1580 clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents), 1581 GFP_KERNEL); 1582 /* 1583 * __clk_lookup returns NULL for parents that have not been 1584 * clk_init'd; thus any access to clk->parents[] must check 1585 * for a NULL pointer. We can always perform lazy lookups for 1586 * missing parents later on. 1587 */ 1588 if (clk->parents) 1589 for (i = 0; i < clk->num_parents; i++) 1590 clk->parents[i] = 1591 __clk_lookup(clk->parent_names[i]); 1592 } 1593 1594 clk->parent = __clk_init_parent(clk); 1595 1596 /* 1597 * Populate clk->parent if parent has already been __clk_init'd. If 1598 * parent has not yet been __clk_init'd then place clk in the orphan 1599 * list. If clk has set the CLK_IS_ROOT flag then place it in the root 1600 * clk list. 1601 * 1602 * Every time a new clk is clk_init'd then we walk the list of orphan 1603 * clocks and re-parent any that are children of the clock currently 1604 * being clk_init'd. 1605 */ 1606 if (clk->parent) 1607 hlist_add_head(&clk->child_node, 1608 &clk->parent->children); 1609 else if (clk->flags & CLK_IS_ROOT) 1610 hlist_add_head(&clk->child_node, &clk_root_list); 1611 else 1612 hlist_add_head(&clk->child_node, &clk_orphan_list); 1613 1614 /* 1615 * Set clk's rate. The preferred method is to use .recalc_rate. For 1616 * simple clocks and lazy developers the default fallback is to use the 1617 * parent's rate. If a clock doesn't have a parent (or is orphaned) 1618 * then rate is set to zero. 1619 */ 1620 if (clk->ops->recalc_rate) 1621 clk->rate = clk->ops->recalc_rate(clk->hw, 1622 __clk_get_rate(clk->parent)); 1623 else if (clk->parent) 1624 clk->rate = clk->parent->rate; 1625 else 1626 clk->rate = 0; 1627 1628 /* 1629 * walk the list of orphan clocks and reparent any that are children of 1630 * this clock 1631 */ 1632 hlist_for_each_entry_safe(orphan, tmp2, &clk_orphan_list, child_node) { 1633 if (orphan->ops->get_parent) { 1634 i = orphan->ops->get_parent(orphan->hw); 1635 if (!strcmp(clk->name, orphan->parent_names[i])) 1636 __clk_reparent(orphan, clk); 1637 continue; 1638 } 1639 1640 for (i = 0; i < orphan->num_parents; i++) 1641 if (!strcmp(clk->name, orphan->parent_names[i])) { 1642 __clk_reparent(orphan, clk); 1643 break; 1644 } 1645 } 1646 1647 /* 1648 * optional platform-specific magic 1649 * 1650 * The .init callback is not used by any of the basic clock types, but 1651 * exists for weird hardware that must perform initialization magic. 1652 * Please consider other ways of solving initialization problems before 1653 * using this callback, as it's use is discouraged. 1654 */ 1655 if (clk->ops->init) 1656 clk->ops->init(clk->hw); 1657 1658 clk_debug_register(clk); 1659 1660 out: 1661 clk_prepare_unlock(); 1662 1663 return ret; 1664 } 1665 1666 /** 1667 * __clk_register - register a clock and return a cookie. 1668 * 1669 * Same as clk_register, except that the .clk field inside hw shall point to a 1670 * preallocated (generally statically allocated) struct clk. None of the fields 1671 * of the struct clk need to be initialized. 1672 * 1673 * The data pointed to by .init and .clk field shall NOT be marked as init 1674 * data. 1675 * 1676 * __clk_register is only exposed via clk-private.h and is intended for use with 1677 * very large numbers of clocks that need to be statically initialized. It is 1678 * a layering violation to include clk-private.h from any code which implements 1679 * a clock's .ops; as such any statically initialized clock data MUST be in a 1680 * separate C file from the logic that implements it's operations. Returns 0 1681 * on success, otherwise an error code. 1682 */ 1683 struct clk *__clk_register(struct device *dev, struct clk_hw *hw) 1684 { 1685 int ret; 1686 struct clk *clk; 1687 1688 clk = hw->clk; 1689 clk->name = hw->init->name; 1690 clk->ops = hw->init->ops; 1691 clk->hw = hw; 1692 clk->flags = hw->init->flags; 1693 clk->parent_names = hw->init->parent_names; 1694 clk->num_parents = hw->init->num_parents; 1695 1696 ret = __clk_init(dev, clk); 1697 if (ret) 1698 return ERR_PTR(ret); 1699 1700 return clk; 1701 } 1702 EXPORT_SYMBOL_GPL(__clk_register); 1703 1704 static int _clk_register(struct device *dev, struct clk_hw *hw, struct clk *clk) 1705 { 1706 int i, ret; 1707 1708 clk->name = kstrdup(hw->init->name, GFP_KERNEL); 1709 if (!clk->name) { 1710 pr_err("%s: could not allocate clk->name\n", __func__); 1711 ret = -ENOMEM; 1712 goto fail_name; 1713 } 1714 clk->ops = hw->init->ops; 1715 clk->hw = hw; 1716 clk->flags = hw->init->flags; 1717 clk->num_parents = hw->init->num_parents; 1718 hw->clk = clk; 1719 1720 /* allocate local copy in case parent_names is __initdata */ 1721 clk->parent_names = kzalloc((sizeof(char*) * clk->num_parents), 1722 GFP_KERNEL); 1723 1724 if (!clk->parent_names) { 1725 pr_err("%s: could not allocate clk->parent_names\n", __func__); 1726 ret = -ENOMEM; 1727 goto fail_parent_names; 1728 } 1729 1730 1731 /* copy each string name in case parent_names is __initdata */ 1732 for (i = 0; i < clk->num_parents; i++) { 1733 clk->parent_names[i] = kstrdup(hw->init->parent_names[i], 1734 GFP_KERNEL); 1735 if (!clk->parent_names[i]) { 1736 pr_err("%s: could not copy parent_names\n", __func__); 1737 ret = -ENOMEM; 1738 goto fail_parent_names_copy; 1739 } 1740 } 1741 1742 ret = __clk_init(dev, clk); 1743 if (!ret) 1744 return 0; 1745 1746 fail_parent_names_copy: 1747 while (--i >= 0) 1748 kfree(clk->parent_names[i]); 1749 kfree(clk->parent_names); 1750 fail_parent_names: 1751 kfree(clk->name); 1752 fail_name: 1753 return ret; 1754 } 1755 1756 /** 1757 * clk_register - allocate a new clock, register it and return an opaque cookie 1758 * @dev: device that is registering this clock 1759 * @hw: link to hardware-specific clock data 1760 * 1761 * clk_register is the primary interface for populating the clock tree with new 1762 * clock nodes. It returns a pointer to the newly allocated struct clk which 1763 * cannot be dereferenced by driver code but may be used in conjuction with the 1764 * rest of the clock API. In the event of an error clk_register will return an 1765 * error code; drivers must test for an error code after calling clk_register. 1766 */ 1767 struct clk *clk_register(struct device *dev, struct clk_hw *hw) 1768 { 1769 int ret; 1770 struct clk *clk; 1771 1772 clk = kzalloc(sizeof(*clk), GFP_KERNEL); 1773 if (!clk) { 1774 pr_err("%s: could not allocate clk\n", __func__); 1775 ret = -ENOMEM; 1776 goto fail_out; 1777 } 1778 1779 ret = _clk_register(dev, hw, clk); 1780 if (!ret) 1781 return clk; 1782 1783 kfree(clk); 1784 fail_out: 1785 return ERR_PTR(ret); 1786 } 1787 EXPORT_SYMBOL_GPL(clk_register); 1788 1789 /** 1790 * clk_unregister - unregister a currently registered clock 1791 * @clk: clock to unregister 1792 * 1793 * Currently unimplemented. 1794 */ 1795 void clk_unregister(struct clk *clk) {} 1796 EXPORT_SYMBOL_GPL(clk_unregister); 1797 1798 static void devm_clk_release(struct device *dev, void *res) 1799 { 1800 clk_unregister(res); 1801 } 1802 1803 /** 1804 * devm_clk_register - resource managed clk_register() 1805 * @dev: device that is registering this clock 1806 * @hw: link to hardware-specific clock data 1807 * 1808 * Managed clk_register(). Clocks returned from this function are 1809 * automatically clk_unregister()ed on driver detach. See clk_register() for 1810 * more information. 1811 */ 1812 struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw) 1813 { 1814 struct clk *clk; 1815 int ret; 1816 1817 clk = devres_alloc(devm_clk_release, sizeof(*clk), GFP_KERNEL); 1818 if (!clk) 1819 return ERR_PTR(-ENOMEM); 1820 1821 ret = _clk_register(dev, hw, clk); 1822 if (!ret) { 1823 devres_add(dev, clk); 1824 } else { 1825 devres_free(clk); 1826 clk = ERR_PTR(ret); 1827 } 1828 1829 return clk; 1830 } 1831 EXPORT_SYMBOL_GPL(devm_clk_register); 1832 1833 static int devm_clk_match(struct device *dev, void *res, void *data) 1834 { 1835 struct clk *c = res; 1836 if (WARN_ON(!c)) 1837 return 0; 1838 return c == data; 1839 } 1840 1841 /** 1842 * devm_clk_unregister - resource managed clk_unregister() 1843 * @clk: clock to unregister 1844 * 1845 * Deallocate a clock allocated with devm_clk_register(). Normally 1846 * this function will not need to be called and the resource management 1847 * code will ensure that the resource is freed. 1848 */ 1849 void devm_clk_unregister(struct device *dev, struct clk *clk) 1850 { 1851 WARN_ON(devres_release(dev, devm_clk_release, devm_clk_match, clk)); 1852 } 1853 EXPORT_SYMBOL_GPL(devm_clk_unregister); 1854 1855 /*** clk rate change notifiers ***/ 1856 1857 /** 1858 * clk_notifier_register - add a clk rate change notifier 1859 * @clk: struct clk * to watch 1860 * @nb: struct notifier_block * with callback info 1861 * 1862 * Request notification when clk's rate changes. This uses an SRCU 1863 * notifier because we want it to block and notifier unregistrations are 1864 * uncommon. The callbacks associated with the notifier must not 1865 * re-enter into the clk framework by calling any top-level clk APIs; 1866 * this will cause a nested prepare_lock mutex. 1867 * 1868 * Pre-change notifier callbacks will be passed the current, pre-change 1869 * rate of the clk via struct clk_notifier_data.old_rate. The new, 1870 * post-change rate of the clk is passed via struct 1871 * clk_notifier_data.new_rate. 1872 * 1873 * Post-change notifiers will pass the now-current, post-change rate of 1874 * the clk in both struct clk_notifier_data.old_rate and struct 1875 * clk_notifier_data.new_rate. 1876 * 1877 * Abort-change notifiers are effectively the opposite of pre-change 1878 * notifiers: the original pre-change clk rate is passed in via struct 1879 * clk_notifier_data.new_rate and the failed post-change rate is passed 1880 * in via struct clk_notifier_data.old_rate. 1881 * 1882 * clk_notifier_register() must be called from non-atomic context. 1883 * Returns -EINVAL if called with null arguments, -ENOMEM upon 1884 * allocation failure; otherwise, passes along the return value of 1885 * srcu_notifier_chain_register(). 1886 */ 1887 int clk_notifier_register(struct clk *clk, struct notifier_block *nb) 1888 { 1889 struct clk_notifier *cn; 1890 int ret = -ENOMEM; 1891 1892 if (!clk || !nb) 1893 return -EINVAL; 1894 1895 clk_prepare_lock(); 1896 1897 /* search the list of notifiers for this clk */ 1898 list_for_each_entry(cn, &clk_notifier_list, node) 1899 if (cn->clk == clk) 1900 break; 1901 1902 /* if clk wasn't in the notifier list, allocate new clk_notifier */ 1903 if (cn->clk != clk) { 1904 cn = kzalloc(sizeof(struct clk_notifier), GFP_KERNEL); 1905 if (!cn) 1906 goto out; 1907 1908 cn->clk = clk; 1909 srcu_init_notifier_head(&cn->notifier_head); 1910 1911 list_add(&cn->node, &clk_notifier_list); 1912 } 1913 1914 ret = srcu_notifier_chain_register(&cn->notifier_head, nb); 1915 1916 clk->notifier_count++; 1917 1918 out: 1919 clk_prepare_unlock(); 1920 1921 return ret; 1922 } 1923 EXPORT_SYMBOL_GPL(clk_notifier_register); 1924 1925 /** 1926 * clk_notifier_unregister - remove a clk rate change notifier 1927 * @clk: struct clk * 1928 * @nb: struct notifier_block * with callback info 1929 * 1930 * Request no further notification for changes to 'clk' and frees memory 1931 * allocated in clk_notifier_register. 1932 * 1933 * Returns -EINVAL if called with null arguments; otherwise, passes 1934 * along the return value of srcu_notifier_chain_unregister(). 1935 */ 1936 int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb) 1937 { 1938 struct clk_notifier *cn = NULL; 1939 int ret = -EINVAL; 1940 1941 if (!clk || !nb) 1942 return -EINVAL; 1943 1944 clk_prepare_lock(); 1945 1946 list_for_each_entry(cn, &clk_notifier_list, node) 1947 if (cn->clk == clk) 1948 break; 1949 1950 if (cn->clk == clk) { 1951 ret = srcu_notifier_chain_unregister(&cn->notifier_head, nb); 1952 1953 clk->notifier_count--; 1954 1955 /* XXX the notifier code should handle this better */ 1956 if (!cn->notifier_head.head) { 1957 srcu_cleanup_notifier_head(&cn->notifier_head); 1958 kfree(cn); 1959 } 1960 1961 } else { 1962 ret = -ENOENT; 1963 } 1964 1965 clk_prepare_unlock(); 1966 1967 return ret; 1968 } 1969 EXPORT_SYMBOL_GPL(clk_notifier_unregister); 1970 1971 #ifdef CONFIG_OF 1972 /** 1973 * struct of_clk_provider - Clock provider registration structure 1974 * @link: Entry in global list of clock providers 1975 * @node: Pointer to device tree node of clock provider 1976 * @get: Get clock callback. Returns NULL or a struct clk for the 1977 * given clock specifier 1978 * @data: context pointer to be passed into @get callback 1979 */ 1980 struct of_clk_provider { 1981 struct list_head link; 1982 1983 struct device_node *node; 1984 struct clk *(*get)(struct of_phandle_args *clkspec, void *data); 1985 void *data; 1986 }; 1987 1988 extern struct of_device_id __clk_of_table[]; 1989 1990 static const struct of_device_id __clk_of_table_sentinel 1991 __used __section(__clk_of_table_end); 1992 1993 static LIST_HEAD(of_clk_providers); 1994 static DEFINE_MUTEX(of_clk_lock); 1995 1996 struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec, 1997 void *data) 1998 { 1999 return data; 2000 } 2001 EXPORT_SYMBOL_GPL(of_clk_src_simple_get); 2002 2003 struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data) 2004 { 2005 struct clk_onecell_data *clk_data = data; 2006 unsigned int idx = clkspec->args[0]; 2007 2008 if (idx >= clk_data->clk_num) { 2009 pr_err("%s: invalid clock index %d\n", __func__, idx); 2010 return ERR_PTR(-EINVAL); 2011 } 2012 2013 return clk_data->clks[idx]; 2014 } 2015 EXPORT_SYMBOL_GPL(of_clk_src_onecell_get); 2016 2017 /** 2018 * of_clk_add_provider() - Register a clock provider for a node 2019 * @np: Device node pointer associated with clock provider 2020 * @clk_src_get: callback for decoding clock 2021 * @data: context pointer for @clk_src_get callback. 2022 */ 2023 int of_clk_add_provider(struct device_node *np, 2024 struct clk *(*clk_src_get)(struct of_phandle_args *clkspec, 2025 void *data), 2026 void *data) 2027 { 2028 struct of_clk_provider *cp; 2029 2030 cp = kzalloc(sizeof(struct of_clk_provider), GFP_KERNEL); 2031 if (!cp) 2032 return -ENOMEM; 2033 2034 cp->node = of_node_get(np); 2035 cp->data = data; 2036 cp->get = clk_src_get; 2037 2038 mutex_lock(&of_clk_lock); 2039 list_add(&cp->link, &of_clk_providers); 2040 mutex_unlock(&of_clk_lock); 2041 pr_debug("Added clock from %s\n", np->full_name); 2042 2043 return 0; 2044 } 2045 EXPORT_SYMBOL_GPL(of_clk_add_provider); 2046 2047 /** 2048 * of_clk_del_provider() - Remove a previously registered clock provider 2049 * @np: Device node pointer associated with clock provider 2050 */ 2051 void of_clk_del_provider(struct device_node *np) 2052 { 2053 struct of_clk_provider *cp; 2054 2055 mutex_lock(&of_clk_lock); 2056 list_for_each_entry(cp, &of_clk_providers, link) { 2057 if (cp->node == np) { 2058 list_del(&cp->link); 2059 of_node_put(cp->node); 2060 kfree(cp); 2061 break; 2062 } 2063 } 2064 mutex_unlock(&of_clk_lock); 2065 } 2066 EXPORT_SYMBOL_GPL(of_clk_del_provider); 2067 2068 struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec) 2069 { 2070 struct of_clk_provider *provider; 2071 struct clk *clk = ERR_PTR(-ENOENT); 2072 2073 /* Check if we have such a provider in our array */ 2074 mutex_lock(&of_clk_lock); 2075 list_for_each_entry(provider, &of_clk_providers, link) { 2076 if (provider->node == clkspec->np) 2077 clk = provider->get(clkspec, provider->data); 2078 if (!IS_ERR(clk)) 2079 break; 2080 } 2081 mutex_unlock(&of_clk_lock); 2082 2083 return clk; 2084 } 2085 2086 const char *of_clk_get_parent_name(struct device_node *np, int index) 2087 { 2088 struct of_phandle_args clkspec; 2089 const char *clk_name; 2090 int rc; 2091 2092 if (index < 0) 2093 return NULL; 2094 2095 rc = of_parse_phandle_with_args(np, "clocks", "#clock-cells", index, 2096 &clkspec); 2097 if (rc) 2098 return NULL; 2099 2100 if (of_property_read_string_index(clkspec.np, "clock-output-names", 2101 clkspec.args_count ? clkspec.args[0] : 0, 2102 &clk_name) < 0) 2103 clk_name = clkspec.np->name; 2104 2105 of_node_put(clkspec.np); 2106 return clk_name; 2107 } 2108 EXPORT_SYMBOL_GPL(of_clk_get_parent_name); 2109 2110 /** 2111 * of_clk_init() - Scan and init clock providers from the DT 2112 * @matches: array of compatible values and init functions for providers. 2113 * 2114 * This function scans the device tree for matching clock providers and 2115 * calls their initialization functions 2116 */ 2117 void __init of_clk_init(const struct of_device_id *matches) 2118 { 2119 struct device_node *np; 2120 2121 if (!matches) 2122 matches = __clk_of_table; 2123 2124 for_each_matching_node(np, matches) { 2125 const struct of_device_id *match = of_match_node(matches, np); 2126 of_clk_init_cb_t clk_init_cb = match->data; 2127 clk_init_cb(np); 2128 } 2129 } 2130 #endif 2131