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