1/* 2 * linux/include/linux/clk.h 3 * 4 * Copyright (C) 2004 ARM Limited. 5 * Written by Deep Blue Solutions Limited. 6 * Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12#ifndef __LINUX_CLK_H 13#define __LINUX_CLK_H 14 15#include <linux/err.h> 16#include <linux/kernel.h> 17#include <linux/notifier.h> 18 19struct device; 20struct clk; 21struct device_node; 22struct of_phandle_args; 23 24/** 25 * DOC: clk notifier callback types 26 * 27 * PRE_RATE_CHANGE - called immediately before the clk rate is changed, 28 * to indicate that the rate change will proceed. Drivers must 29 * immediately terminate any operations that will be affected by the 30 * rate change. Callbacks may either return NOTIFY_DONE, NOTIFY_OK, 31 * NOTIFY_STOP or NOTIFY_BAD. 32 * 33 * ABORT_RATE_CHANGE: called if the rate change failed for some reason 34 * after PRE_RATE_CHANGE. In this case, all registered notifiers on 35 * the clk will be called with ABORT_RATE_CHANGE. Callbacks must 36 * always return NOTIFY_DONE or NOTIFY_OK. 37 * 38 * POST_RATE_CHANGE - called after the clk rate change has successfully 39 * completed. Callbacks must always return NOTIFY_DONE or NOTIFY_OK. 40 * 41 */ 42#define PRE_RATE_CHANGE BIT(0) 43#define POST_RATE_CHANGE BIT(1) 44#define ABORT_RATE_CHANGE BIT(2) 45 46/** 47 * struct clk_notifier - associate a clk with a notifier 48 * @clk: struct clk * to associate the notifier with 49 * @notifier_head: a blocking_notifier_head for this clk 50 * @node: linked list pointers 51 * 52 * A list of struct clk_notifier is maintained by the notifier code. 53 * An entry is created whenever code registers the first notifier on a 54 * particular @clk. Future notifiers on that @clk are added to the 55 * @notifier_head. 56 */ 57struct clk_notifier { 58 struct clk *clk; 59 struct srcu_notifier_head notifier_head; 60 struct list_head node; 61}; 62 63/** 64 * struct clk_notifier_data - rate data to pass to the notifier callback 65 * @clk: struct clk * being changed 66 * @old_rate: previous rate of this clk 67 * @new_rate: new rate of this clk 68 * 69 * For a pre-notifier, old_rate is the clk's rate before this rate 70 * change, and new_rate is what the rate will be in the future. For a 71 * post-notifier, old_rate and new_rate are both set to the clk's 72 * current rate (this was done to optimize the implementation). 73 */ 74struct clk_notifier_data { 75 struct clk *clk; 76 unsigned long old_rate; 77 unsigned long new_rate; 78}; 79 80/** 81 * struct clk_bulk_data - Data used for bulk clk operations. 82 * 83 * @id: clock consumer ID 84 * @clk: struct clk * to store the associated clock 85 * 86 * The CLK APIs provide a series of clk_bulk_() API calls as 87 * a convenience to consumers which require multiple clks. This 88 * structure is used to manage data for these calls. 89 */ 90struct clk_bulk_data { 91 const char *id; 92 struct clk *clk; 93}; 94 95#ifdef CONFIG_COMMON_CLK 96 97/** 98 * clk_notifier_register: register a clock rate-change notifier callback 99 * @clk: clock whose rate we are interested in 100 * @nb: notifier block with callback function pointer 101 * 102 * ProTip: debugging across notifier chains can be frustrating. Make sure that 103 * your notifier callback function prints a nice big warning in case of 104 * failure. 105 */ 106int clk_notifier_register(struct clk *clk, struct notifier_block *nb); 107 108/** 109 * clk_notifier_unregister: unregister a clock rate-change notifier callback 110 * @clk: clock whose rate we are no longer interested in 111 * @nb: notifier block which will be unregistered 112 */ 113int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb); 114 115/** 116 * clk_get_accuracy - obtain the clock accuracy in ppb (parts per billion) 117 * for a clock source. 118 * @clk: clock source 119 * 120 * This gets the clock source accuracy expressed in ppb. 121 * A perfect clock returns 0. 122 */ 123long clk_get_accuracy(struct clk *clk); 124 125/** 126 * clk_set_phase - adjust the phase shift of a clock signal 127 * @clk: clock signal source 128 * @degrees: number of degrees the signal is shifted 129 * 130 * Shifts the phase of a clock signal by the specified degrees. Returns 0 on 131 * success, -EERROR otherwise. 132 */ 133int clk_set_phase(struct clk *clk, int degrees); 134 135/** 136 * clk_get_phase - return the phase shift of a clock signal 137 * @clk: clock signal source 138 * 139 * Returns the phase shift of a clock node in degrees, otherwise returns 140 * -EERROR. 141 */ 142int clk_get_phase(struct clk *clk); 143 144/** 145 * clk_set_duty_cycle - adjust the duty cycle ratio of a clock signal 146 * @clk: clock signal source 147 * @num: numerator of the duty cycle ratio to be applied 148 * @den: denominator of the duty cycle ratio to be applied 149 * 150 * Adjust the duty cycle of a clock signal by the specified ratio. Returns 0 on 151 * success, -EERROR otherwise. 152 */ 153int clk_set_duty_cycle(struct clk *clk, unsigned int num, unsigned int den); 154 155/** 156 * clk_get_duty_cycle - return the duty cycle ratio of a clock signal 157 * @clk: clock signal source 158 * @scale: scaling factor to be applied to represent the ratio as an integer 159 * 160 * Returns the duty cycle ratio multiplied by the scale provided, otherwise 161 * returns -EERROR. 162 */ 163int clk_get_scaled_duty_cycle(struct clk *clk, unsigned int scale); 164 165/** 166 * clk_is_match - check if two clk's point to the same hardware clock 167 * @p: clk compared against q 168 * @q: clk compared against p 169 * 170 * Returns true if the two struct clk pointers both point to the same hardware 171 * clock node. Put differently, returns true if @p and @q 172 * share the same &struct clk_core object. 173 * 174 * Returns false otherwise. Note that two NULL clks are treated as matching. 175 */ 176bool clk_is_match(const struct clk *p, const struct clk *q); 177 178#else 179 180static inline int clk_notifier_register(struct clk *clk, 181 struct notifier_block *nb) 182{ 183 return -ENOTSUPP; 184} 185 186static inline int clk_notifier_unregister(struct clk *clk, 187 struct notifier_block *nb) 188{ 189 return -ENOTSUPP; 190} 191 192static inline long clk_get_accuracy(struct clk *clk) 193{ 194 return -ENOTSUPP; 195} 196 197static inline long clk_set_phase(struct clk *clk, int phase) 198{ 199 return -ENOTSUPP; 200} 201 202static inline long clk_get_phase(struct clk *clk) 203{ 204 return -ENOTSUPP; 205} 206 207static inline int clk_set_duty_cycle(struct clk *clk, unsigned int num, 208 unsigned int den) 209{ 210 return -ENOTSUPP; 211} 212 213static inline unsigned int clk_get_scaled_duty_cycle(struct clk *clk, 214 unsigned int scale) 215{ 216 return 0; 217} 218 219static inline bool clk_is_match(const struct clk *p, const struct clk *q) 220{ 221 return p == q; 222} 223 224#endif 225 226/** 227 * clk_prepare - prepare a clock source 228 * @clk: clock source 229 * 230 * This prepares the clock source for use. 231 * 232 * Must not be called from within atomic context. 233 */ 234#ifdef CONFIG_HAVE_CLK_PREPARE 235int clk_prepare(struct clk *clk); 236int __must_check clk_bulk_prepare(int num_clks, 237 const struct clk_bulk_data *clks); 238#else 239static inline int clk_prepare(struct clk *clk) 240{ 241 might_sleep(); 242 return 0; 243} 244 245static inline int __must_check clk_bulk_prepare(int num_clks, struct clk_bulk_data *clks) 246{ 247 might_sleep(); 248 return 0; 249} 250#endif 251 252/** 253 * clk_unprepare - undo preparation of a clock source 254 * @clk: clock source 255 * 256 * This undoes a previously prepared clock. The caller must balance 257 * the number of prepare and unprepare calls. 258 * 259 * Must not be called from within atomic context. 260 */ 261#ifdef CONFIG_HAVE_CLK_PREPARE 262void clk_unprepare(struct clk *clk); 263void clk_bulk_unprepare(int num_clks, const struct clk_bulk_data *clks); 264#else 265static inline void clk_unprepare(struct clk *clk) 266{ 267 might_sleep(); 268} 269static inline void clk_bulk_unprepare(int num_clks, struct clk_bulk_data *clks) 270{ 271 might_sleep(); 272} 273#endif 274 275#ifdef CONFIG_HAVE_CLK 276/** 277 * clk_get - lookup and obtain a reference to a clock producer. 278 * @dev: device for clock "consumer" 279 * @id: clock consumer ID 280 * 281 * Returns a struct clk corresponding to the clock producer, or 282 * valid IS_ERR() condition containing errno. The implementation 283 * uses @dev and @id to determine the clock consumer, and thereby 284 * the clock producer. (IOW, @id may be identical strings, but 285 * clk_get may return different clock producers depending on @dev.) 286 * 287 * Drivers must assume that the clock source is not enabled. 288 * 289 * clk_get should not be called from within interrupt context. 290 */ 291struct clk *clk_get(struct device *dev, const char *id); 292 293/** 294 * clk_bulk_get - lookup and obtain a number of references to clock producer. 295 * @dev: device for clock "consumer" 296 * @num_clks: the number of clk_bulk_data 297 * @clks: the clk_bulk_data table of consumer 298 * 299 * This helper function allows drivers to get several clk consumers in one 300 * operation. If any of the clk cannot be acquired then any clks 301 * that were obtained will be freed before returning to the caller. 302 * 303 * Returns 0 if all clocks specified in clk_bulk_data table are obtained 304 * successfully, or valid IS_ERR() condition containing errno. 305 * The implementation uses @dev and @clk_bulk_data.id to determine the 306 * clock consumer, and thereby the clock producer. 307 * The clock returned is stored in each @clk_bulk_data.clk field. 308 * 309 * Drivers must assume that the clock source is not enabled. 310 * 311 * clk_bulk_get should not be called from within interrupt context. 312 */ 313int __must_check clk_bulk_get(struct device *dev, int num_clks, 314 struct clk_bulk_data *clks); 315 316/** 317 * devm_clk_bulk_get - managed get multiple clk consumers 318 * @dev: device for clock "consumer" 319 * @num_clks: the number of clk_bulk_data 320 * @clks: the clk_bulk_data table of consumer 321 * 322 * Return 0 on success, an errno on failure. 323 * 324 * This helper function allows drivers to get several clk 325 * consumers in one operation with management, the clks will 326 * automatically be freed when the device is unbound. 327 */ 328int __must_check devm_clk_bulk_get(struct device *dev, int num_clks, 329 struct clk_bulk_data *clks); 330 331/** 332 * devm_clk_get - lookup and obtain a managed reference to a clock producer. 333 * @dev: device for clock "consumer" 334 * @id: clock consumer ID 335 * 336 * Returns a struct clk corresponding to the clock producer, or 337 * valid IS_ERR() condition containing errno. The implementation 338 * uses @dev and @id to determine the clock consumer, and thereby 339 * the clock producer. (IOW, @id may be identical strings, but 340 * clk_get may return different clock producers depending on @dev.) 341 * 342 * Drivers must assume that the clock source is not enabled. 343 * 344 * devm_clk_get should not be called from within interrupt context. 345 * 346 * The clock will automatically be freed when the device is unbound 347 * from the bus. 348 */ 349struct clk *devm_clk_get(struct device *dev, const char *id); 350 351/** 352 * devm_get_clk_from_child - lookup and obtain a managed reference to a 353 * clock producer from child node. 354 * @dev: device for clock "consumer" 355 * @np: pointer to clock consumer node 356 * @con_id: clock consumer ID 357 * 358 * This function parses the clocks, and uses them to look up the 359 * struct clk from the registered list of clock providers by using 360 * @np and @con_id 361 * 362 * The clock will automatically be freed when the device is unbound 363 * from the bus. 364 */ 365struct clk *devm_get_clk_from_child(struct device *dev, 366 struct device_node *np, const char *con_id); 367/** 368 * clk_rate_exclusive_get - get exclusivity over the rate control of a 369 * producer 370 * @clk: clock source 371 * 372 * This function allows drivers to get exclusive control over the rate of a 373 * provider. It prevents any other consumer to execute, even indirectly, 374 * opereation which could alter the rate of the provider or cause glitches 375 * 376 * If exlusivity is claimed more than once on clock, even by the same driver, 377 * the rate effectively gets locked as exclusivity can't be preempted. 378 * 379 * Must not be called from within atomic context. 380 * 381 * Returns success (0) or negative errno. 382 */ 383int clk_rate_exclusive_get(struct clk *clk); 384 385/** 386 * clk_rate_exclusive_put - release exclusivity over the rate control of a 387 * producer 388 * @clk: clock source 389 * 390 * This function allows drivers to release the exclusivity it previously got 391 * from clk_rate_exclusive_get() 392 * 393 * The caller must balance the number of clk_rate_exclusive_get() and 394 * clk_rate_exclusive_put() calls. 395 * 396 * Must not be called from within atomic context. 397 */ 398void clk_rate_exclusive_put(struct clk *clk); 399 400/** 401 * clk_enable - inform the system when the clock source should be running. 402 * @clk: clock source 403 * 404 * If the clock can not be enabled/disabled, this should return success. 405 * 406 * May be called from atomic contexts. 407 * 408 * Returns success (0) or negative errno. 409 */ 410int clk_enable(struct clk *clk); 411 412/** 413 * clk_bulk_enable - inform the system when the set of clks should be running. 414 * @num_clks: the number of clk_bulk_data 415 * @clks: the clk_bulk_data table of consumer 416 * 417 * May be called from atomic contexts. 418 * 419 * Returns success (0) or negative errno. 420 */ 421int __must_check clk_bulk_enable(int num_clks, 422 const struct clk_bulk_data *clks); 423 424/** 425 * clk_disable - inform the system when the clock source is no longer required. 426 * @clk: clock source 427 * 428 * Inform the system that a clock source is no longer required by 429 * a driver and may be shut down. 430 * 431 * May be called from atomic contexts. 432 * 433 * Implementation detail: if the clock source is shared between 434 * multiple drivers, clk_enable() calls must be balanced by the 435 * same number of clk_disable() calls for the clock source to be 436 * disabled. 437 */ 438void clk_disable(struct clk *clk); 439 440/** 441 * clk_bulk_disable - inform the system when the set of clks is no 442 * longer required. 443 * @num_clks: the number of clk_bulk_data 444 * @clks: the clk_bulk_data table of consumer 445 * 446 * Inform the system that a set of clks is no longer required by 447 * a driver and may be shut down. 448 * 449 * May be called from atomic contexts. 450 * 451 * Implementation detail: if the set of clks is shared between 452 * multiple drivers, clk_bulk_enable() calls must be balanced by the 453 * same number of clk_bulk_disable() calls for the clock source to be 454 * disabled. 455 */ 456void clk_bulk_disable(int num_clks, const struct clk_bulk_data *clks); 457 458/** 459 * clk_get_rate - obtain the current clock rate (in Hz) for a clock source. 460 * This is only valid once the clock source has been enabled. 461 * @clk: clock source 462 */ 463unsigned long clk_get_rate(struct clk *clk); 464 465/** 466 * clk_put - "free" the clock source 467 * @clk: clock source 468 * 469 * Note: drivers must ensure that all clk_enable calls made on this 470 * clock source are balanced by clk_disable calls prior to calling 471 * this function. 472 * 473 * clk_put should not be called from within interrupt context. 474 */ 475void clk_put(struct clk *clk); 476 477/** 478 * clk_bulk_put - "free" the clock source 479 * @num_clks: the number of clk_bulk_data 480 * @clks: the clk_bulk_data table of consumer 481 * 482 * Note: drivers must ensure that all clk_bulk_enable calls made on this 483 * clock source are balanced by clk_bulk_disable calls prior to calling 484 * this function. 485 * 486 * clk_bulk_put should not be called from within interrupt context. 487 */ 488void clk_bulk_put(int num_clks, struct clk_bulk_data *clks); 489 490/** 491 * devm_clk_put - "free" a managed clock source 492 * @dev: device used to acquire the clock 493 * @clk: clock source acquired with devm_clk_get() 494 * 495 * Note: drivers must ensure that all clk_enable calls made on this 496 * clock source are balanced by clk_disable calls prior to calling 497 * this function. 498 * 499 * clk_put should not be called from within interrupt context. 500 */ 501void devm_clk_put(struct device *dev, struct clk *clk); 502 503/* 504 * The remaining APIs are optional for machine class support. 505 */ 506 507 508/** 509 * clk_round_rate - adjust a rate to the exact rate a clock can provide 510 * @clk: clock source 511 * @rate: desired clock rate in Hz 512 * 513 * This answers the question "if I were to pass @rate to clk_set_rate(), 514 * what clock rate would I end up with?" without changing the hardware 515 * in any way. In other words: 516 * 517 * rate = clk_round_rate(clk, r); 518 * 519 * and: 520 * 521 * clk_set_rate(clk, r); 522 * rate = clk_get_rate(clk); 523 * 524 * are equivalent except the former does not modify the clock hardware 525 * in any way. 526 * 527 * Returns rounded clock rate in Hz, or negative errno. 528 */ 529long clk_round_rate(struct clk *clk, unsigned long rate); 530 531/** 532 * clk_set_rate - set the clock rate for a clock source 533 * @clk: clock source 534 * @rate: desired clock rate in Hz 535 * 536 * Returns success (0) or negative errno. 537 */ 538int clk_set_rate(struct clk *clk, unsigned long rate); 539 540/** 541 * clk_set_rate_exclusive- set the clock rate and claim exclusivity over 542 * clock source 543 * @clk: clock source 544 * @rate: desired clock rate in Hz 545 * 546 * This helper function allows drivers to atomically set the rate of a producer 547 * and claim exclusivity over the rate control of the producer. 548 * 549 * It is essentially a combination of clk_set_rate() and 550 * clk_rate_exclusite_get(). Caller must balance this call with a call to 551 * clk_rate_exclusive_put() 552 * 553 * Returns success (0) or negative errno. 554 */ 555int clk_set_rate_exclusive(struct clk *clk, unsigned long rate); 556 557/** 558 * clk_has_parent - check if a clock is a possible parent for another 559 * @clk: clock source 560 * @parent: parent clock source 561 * 562 * This function can be used in drivers that need to check that a clock can be 563 * the parent of another without actually changing the parent. 564 * 565 * Returns true if @parent is a possible parent for @clk, false otherwise. 566 */ 567bool clk_has_parent(struct clk *clk, struct clk *parent); 568 569/** 570 * clk_set_rate_range - set a rate range for a clock source 571 * @clk: clock source 572 * @min: desired minimum clock rate in Hz, inclusive 573 * @max: desired maximum clock rate in Hz, inclusive 574 * 575 * Returns success (0) or negative errno. 576 */ 577int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max); 578 579/** 580 * clk_set_min_rate - set a minimum clock rate for a clock source 581 * @clk: clock source 582 * @rate: desired minimum clock rate in Hz, inclusive 583 * 584 * Returns success (0) or negative errno. 585 */ 586int clk_set_min_rate(struct clk *clk, unsigned long rate); 587 588/** 589 * clk_set_max_rate - set a maximum clock rate for a clock source 590 * @clk: clock source 591 * @rate: desired maximum clock rate in Hz, inclusive 592 * 593 * Returns success (0) or negative errno. 594 */ 595int clk_set_max_rate(struct clk *clk, unsigned long rate); 596 597/** 598 * clk_set_parent - set the parent clock source for this clock 599 * @clk: clock source 600 * @parent: parent clock source 601 * 602 * Returns success (0) or negative errno. 603 */ 604int clk_set_parent(struct clk *clk, struct clk *parent); 605 606/** 607 * clk_get_parent - get the parent clock source for this clock 608 * @clk: clock source 609 * 610 * Returns struct clk corresponding to parent clock source, or 611 * valid IS_ERR() condition containing errno. 612 */ 613struct clk *clk_get_parent(struct clk *clk); 614 615/** 616 * clk_get_sys - get a clock based upon the device name 617 * @dev_id: device name 618 * @con_id: connection ID 619 * 620 * Returns a struct clk corresponding to the clock producer, or 621 * valid IS_ERR() condition containing errno. The implementation 622 * uses @dev_id and @con_id to determine the clock consumer, and 623 * thereby the clock producer. In contrast to clk_get() this function 624 * takes the device name instead of the device itself for identification. 625 * 626 * Drivers must assume that the clock source is not enabled. 627 * 628 * clk_get_sys should not be called from within interrupt context. 629 */ 630struct clk *clk_get_sys(const char *dev_id, const char *con_id); 631 632#else /* !CONFIG_HAVE_CLK */ 633 634static inline struct clk *clk_get(struct device *dev, const char *id) 635{ 636 return NULL; 637} 638 639static inline int __must_check clk_bulk_get(struct device *dev, int num_clks, 640 struct clk_bulk_data *clks) 641{ 642 return 0; 643} 644 645static inline struct clk *devm_clk_get(struct device *dev, const char *id) 646{ 647 return NULL; 648} 649 650static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks, 651 struct clk_bulk_data *clks) 652{ 653 return 0; 654} 655 656static inline struct clk *devm_get_clk_from_child(struct device *dev, 657 struct device_node *np, const char *con_id) 658{ 659 return NULL; 660} 661 662static inline void clk_put(struct clk *clk) {} 663 664static inline void clk_bulk_put(int num_clks, struct clk_bulk_data *clks) {} 665 666static inline void devm_clk_put(struct device *dev, struct clk *clk) {} 667 668 669static inline int clk_rate_exclusive_get(struct clk *clk) 670{ 671 return 0; 672} 673 674static inline void clk_rate_exclusive_put(struct clk *clk) {} 675 676static inline int clk_enable(struct clk *clk) 677{ 678 return 0; 679} 680 681static inline int __must_check clk_bulk_enable(int num_clks, struct clk_bulk_data *clks) 682{ 683 return 0; 684} 685 686static inline void clk_disable(struct clk *clk) {} 687 688 689static inline void clk_bulk_disable(int num_clks, 690 struct clk_bulk_data *clks) {} 691 692static inline unsigned long clk_get_rate(struct clk *clk) 693{ 694 return 0; 695} 696 697static inline int clk_set_rate(struct clk *clk, unsigned long rate) 698{ 699 return 0; 700} 701 702static inline int clk_set_rate_exclusive(struct clk *clk, unsigned long rate) 703{ 704 return 0; 705} 706 707static inline long clk_round_rate(struct clk *clk, unsigned long rate) 708{ 709 return 0; 710} 711 712static inline bool clk_has_parent(struct clk *clk, struct clk *parent) 713{ 714 return true; 715} 716 717static inline int clk_set_parent(struct clk *clk, struct clk *parent) 718{ 719 return 0; 720} 721 722static inline struct clk *clk_get_parent(struct clk *clk) 723{ 724 return NULL; 725} 726 727static inline struct clk *clk_get_sys(const char *dev_id, const char *con_id) 728{ 729 return NULL; 730} 731#endif 732 733/* clk_prepare_enable helps cases using clk_enable in non-atomic context. */ 734static inline int clk_prepare_enable(struct clk *clk) 735{ 736 int ret; 737 738 ret = clk_prepare(clk); 739 if (ret) 740 return ret; 741 ret = clk_enable(clk); 742 if (ret) 743 clk_unprepare(clk); 744 745 return ret; 746} 747 748/* clk_disable_unprepare helps cases using clk_disable in non-atomic context. */ 749static inline void clk_disable_unprepare(struct clk *clk) 750{ 751 clk_disable(clk); 752 clk_unprepare(clk); 753} 754 755static inline int __must_check clk_bulk_prepare_enable(int num_clks, 756 struct clk_bulk_data *clks) 757{ 758 int ret; 759 760 ret = clk_bulk_prepare(num_clks, clks); 761 if (ret) 762 return ret; 763 ret = clk_bulk_enable(num_clks, clks); 764 if (ret) 765 clk_bulk_unprepare(num_clks, clks); 766 767 return ret; 768} 769 770static inline void clk_bulk_disable_unprepare(int num_clks, 771 struct clk_bulk_data *clks) 772{ 773 clk_bulk_disable(num_clks, clks); 774 clk_bulk_unprepare(num_clks, clks); 775} 776 777#if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) 778struct clk *of_clk_get(struct device_node *np, int index); 779struct clk *of_clk_get_by_name(struct device_node *np, const char *name); 780struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec); 781#else 782static inline struct clk *of_clk_get(struct device_node *np, int index) 783{ 784 return ERR_PTR(-ENOENT); 785} 786static inline struct clk *of_clk_get_by_name(struct device_node *np, 787 const char *name) 788{ 789 return ERR_PTR(-ENOENT); 790} 791static inline struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec) 792{ 793 return ERR_PTR(-ENOENT); 794} 795#endif 796 797#endif 798