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 clk_bulk_prepare(int num_clks, struct clk_bulk_data *clks) 243{ 244 might_sleep(); 245 return 0; 246} 247#endif 248 249/** 250 * clk_unprepare - undo preparation of a clock source 251 * @clk: clock source 252 * 253 * This undoes a previously prepared clock. The caller must balance 254 * the number of prepare and unprepare calls. 255 * 256 * Must not be called from within atomic context. 257 */ 258#ifdef CONFIG_HAVE_CLK_PREPARE 259void clk_unprepare(struct clk *clk); 260void clk_bulk_unprepare(int num_clks, const struct clk_bulk_data *clks); 261#else 262static inline void clk_unprepare(struct clk *clk) 263{ 264 might_sleep(); 265} 266static inline void clk_bulk_unprepare(int num_clks, struct clk_bulk_data *clks) 267{ 268 might_sleep(); 269} 270#endif 271 272#ifdef CONFIG_HAVE_CLK 273/** 274 * clk_get - lookup and obtain a reference to a clock producer. 275 * @dev: device for clock "consumer" 276 * @id: clock consumer ID 277 * 278 * Returns a struct clk corresponding to the clock producer, or 279 * valid IS_ERR() condition containing errno. The implementation 280 * uses @dev and @id to determine the clock consumer, and thereby 281 * the clock producer. (IOW, @id may be identical strings, but 282 * clk_get may return different clock producers depending on @dev.) 283 * 284 * Drivers must assume that the clock source is not enabled. 285 * 286 * clk_get should not be called from within interrupt context. 287 */ 288struct clk *clk_get(struct device *dev, const char *id); 289 290/** 291 * clk_bulk_get - lookup and obtain a number of references to clock producer. 292 * @dev: device for clock "consumer" 293 * @num_clks: the number of clk_bulk_data 294 * @clks: the clk_bulk_data table of consumer 295 * 296 * This helper function allows drivers to get several clk consumers in one 297 * operation. If any of the clk cannot be acquired then any clks 298 * that were obtained will be freed before returning to the caller. 299 * 300 * Returns 0 if all clocks specified in clk_bulk_data table are obtained 301 * successfully, or valid IS_ERR() condition containing errno. 302 * The implementation uses @dev and @clk_bulk_data.id to determine the 303 * clock consumer, and thereby the clock producer. 304 * The clock returned is stored in each @clk_bulk_data.clk field. 305 * 306 * Drivers must assume that the clock source is not enabled. 307 * 308 * clk_bulk_get should not be called from within interrupt context. 309 */ 310int __must_check clk_bulk_get(struct device *dev, int num_clks, 311 struct clk_bulk_data *clks); 312/** 313 * clk_bulk_get_all - lookup and obtain all available references to clock 314 * producer. 315 * @dev: device for clock "consumer" 316 * @clks: pointer to the clk_bulk_data table of consumer 317 * 318 * This helper function allows drivers to get all clk consumers in one 319 * operation. If any of the clk cannot be acquired then any clks 320 * that were obtained will be freed before returning to the caller. 321 * 322 * Returns a positive value for the number of clocks obtained while the 323 * clock references are stored in the clk_bulk_data table in @clks field. 324 * Returns 0 if there're none and a negative value if something failed. 325 * 326 * Drivers must assume that the clock source is not enabled. 327 * 328 * clk_bulk_get should not be called from within interrupt context. 329 */ 330int __must_check clk_bulk_get_all(struct device *dev, 331 struct clk_bulk_data **clks); 332 333/** 334 * clk_bulk_get_optional - lookup and obtain a number of references to clock producer 335 * @dev: device for clock "consumer" 336 * @num_clks: the number of clk_bulk_data 337 * @clks: the clk_bulk_data table of consumer 338 * 339 * Behaves the same as clk_bulk_get() except where there is no clock producer. 340 * In this case, instead of returning -ENOENT, the function returns 0 and 341 * NULL for a clk for which a clock producer could not be determined. 342 */ 343int __must_check clk_bulk_get_optional(struct device *dev, int num_clks, 344 struct clk_bulk_data *clks); 345/** 346 * devm_clk_bulk_get - managed get multiple clk consumers 347 * @dev: device for clock "consumer" 348 * @num_clks: the number of clk_bulk_data 349 * @clks: the clk_bulk_data table of consumer 350 * 351 * Return 0 on success, an errno on failure. 352 * 353 * This helper function allows drivers to get several clk 354 * consumers in one operation with management, the clks will 355 * automatically be freed when the device is unbound. 356 */ 357int __must_check devm_clk_bulk_get(struct device *dev, int num_clks, 358 struct clk_bulk_data *clks); 359/** 360 * devm_clk_bulk_get_optional - managed get multiple optional consumer clocks 361 * @dev: device for clock "consumer" 362 * @num_clks: the number of clk_bulk_data 363 * @clks: pointer to the clk_bulk_data table of consumer 364 * 365 * Behaves the same as devm_clk_bulk_get() except where there is no clock 366 * producer. In this case, instead of returning -ENOENT, the function returns 367 * NULL for given clk. It is assumed all clocks in clk_bulk_data are optional. 368 * 369 * Returns 0 if all clocks specified in clk_bulk_data table are obtained 370 * successfully or for any clk there was no clk provider available, otherwise 371 * returns valid IS_ERR() condition containing errno. 372 * The implementation uses @dev and @clk_bulk_data.id to determine the 373 * clock consumer, and thereby the clock producer. 374 * The clock returned is stored in each @clk_bulk_data.clk field. 375 * 376 * Drivers must assume that the clock source is not enabled. 377 * 378 * clk_bulk_get should not be called from within interrupt context. 379 */ 380int __must_check devm_clk_bulk_get_optional(struct device *dev, int num_clks, 381 struct clk_bulk_data *clks); 382/** 383 * devm_clk_bulk_get_all - managed get multiple clk consumers 384 * @dev: device for clock "consumer" 385 * @clks: pointer to the clk_bulk_data table of consumer 386 * 387 * Returns a positive value for the number of clocks obtained while the 388 * clock references are stored in the clk_bulk_data table in @clks field. 389 * Returns 0 if there're none and a negative value if something failed. 390 * 391 * This helper function allows drivers to get several clk 392 * consumers in one operation with management, the clks will 393 * automatically be freed when the device is unbound. 394 */ 395 396int __must_check devm_clk_bulk_get_all(struct device *dev, 397 struct clk_bulk_data **clks); 398 399/** 400 * devm_clk_get - lookup and obtain a managed reference to a clock producer. 401 * @dev: device for clock "consumer" 402 * @id: clock consumer ID 403 * 404 * Returns a struct clk corresponding to the clock producer, or 405 * valid IS_ERR() condition containing errno. The implementation 406 * uses @dev and @id to determine the clock consumer, and thereby 407 * the clock producer. (IOW, @id may be identical strings, but 408 * clk_get may return different clock producers depending on @dev.) 409 * 410 * Drivers must assume that the clock source is not enabled. 411 * 412 * devm_clk_get should not be called from within interrupt context. 413 * 414 * The clock will automatically be freed when the device is unbound 415 * from the bus. 416 */ 417struct clk *devm_clk_get(struct device *dev, const char *id); 418 419/** 420 * devm_clk_get_optional - lookup and obtain a managed reference to an optional 421 * clock producer. 422 * @dev: device for clock "consumer" 423 * @id: clock consumer ID 424 * 425 * Behaves the same as devm_clk_get() except where there is no clock producer. 426 * In this case, instead of returning -ENOENT, the function returns NULL. 427 */ 428struct clk *devm_clk_get_optional(struct device *dev, const char *id); 429 430/** 431 * devm_get_clk_from_child - lookup and obtain a managed reference to a 432 * clock producer from child node. 433 * @dev: device for clock "consumer" 434 * @np: pointer to clock consumer node 435 * @con_id: clock consumer ID 436 * 437 * This function parses the clocks, and uses them to look up the 438 * struct clk from the registered list of clock providers by using 439 * @np and @con_id 440 * 441 * The clock will automatically be freed when the device is unbound 442 * from the bus. 443 */ 444struct clk *devm_get_clk_from_child(struct device *dev, 445 struct device_node *np, const char *con_id); 446/** 447 * clk_rate_exclusive_get - get exclusivity over the rate control of a 448 * producer 449 * @clk: clock source 450 * 451 * This function allows drivers to get exclusive control over the rate of a 452 * provider. It prevents any other consumer to execute, even indirectly, 453 * opereation which could alter the rate of the provider or cause glitches 454 * 455 * If exlusivity is claimed more than once on clock, even by the same driver, 456 * the rate effectively gets locked as exclusivity can't be preempted. 457 * 458 * Must not be called from within atomic context. 459 * 460 * Returns success (0) or negative errno. 461 */ 462int clk_rate_exclusive_get(struct clk *clk); 463 464/** 465 * clk_rate_exclusive_put - release exclusivity over the rate control of a 466 * producer 467 * @clk: clock source 468 * 469 * This function allows drivers to release the exclusivity it previously got 470 * from clk_rate_exclusive_get() 471 * 472 * The caller must balance the number of clk_rate_exclusive_get() and 473 * clk_rate_exclusive_put() calls. 474 * 475 * Must not be called from within atomic context. 476 */ 477void clk_rate_exclusive_put(struct clk *clk); 478 479/** 480 * clk_enable - inform the system when the clock source should be running. 481 * @clk: clock source 482 * 483 * If the clock can not be enabled/disabled, this should return success. 484 * 485 * May be called from atomic contexts. 486 * 487 * Returns success (0) or negative errno. 488 */ 489int clk_enable(struct clk *clk); 490 491/** 492 * clk_bulk_enable - inform the system when the set of clks should be running. 493 * @num_clks: the number of clk_bulk_data 494 * @clks: the clk_bulk_data table of consumer 495 * 496 * May be called from atomic contexts. 497 * 498 * Returns success (0) or negative errno. 499 */ 500int __must_check clk_bulk_enable(int num_clks, 501 const struct clk_bulk_data *clks); 502 503/** 504 * clk_disable - inform the system when the clock source is no longer required. 505 * @clk: clock source 506 * 507 * Inform the system that a clock source is no longer required by 508 * a driver and may be shut down. 509 * 510 * May be called from atomic contexts. 511 * 512 * Implementation detail: if the clock source is shared between 513 * multiple drivers, clk_enable() calls must be balanced by the 514 * same number of clk_disable() calls for the clock source to be 515 * disabled. 516 */ 517void clk_disable(struct clk *clk); 518 519/** 520 * clk_bulk_disable - inform the system when the set of clks is no 521 * longer required. 522 * @num_clks: the number of clk_bulk_data 523 * @clks: the clk_bulk_data table of consumer 524 * 525 * Inform the system that a set of clks is no longer required by 526 * a driver and may be shut down. 527 * 528 * May be called from atomic contexts. 529 * 530 * Implementation detail: if the set of clks is shared between 531 * multiple drivers, clk_bulk_enable() calls must be balanced by the 532 * same number of clk_bulk_disable() calls for the clock source to be 533 * disabled. 534 */ 535void clk_bulk_disable(int num_clks, const struct clk_bulk_data *clks); 536 537/** 538 * clk_get_rate - obtain the current clock rate (in Hz) for a clock source. 539 * This is only valid once the clock source has been enabled. 540 * @clk: clock source 541 */ 542unsigned long clk_get_rate(struct clk *clk); 543 544/** 545 * clk_put - "free" the clock source 546 * @clk: clock source 547 * 548 * Note: drivers must ensure that all clk_enable calls made on this 549 * clock source are balanced by clk_disable calls prior to calling 550 * this function. 551 * 552 * clk_put should not be called from within interrupt context. 553 */ 554void clk_put(struct clk *clk); 555 556/** 557 * clk_bulk_put - "free" the clock source 558 * @num_clks: the number of clk_bulk_data 559 * @clks: the clk_bulk_data table of consumer 560 * 561 * Note: drivers must ensure that all clk_bulk_enable calls made on this 562 * clock source are balanced by clk_bulk_disable calls prior to calling 563 * this function. 564 * 565 * clk_bulk_put should not be called from within interrupt context. 566 */ 567void clk_bulk_put(int num_clks, struct clk_bulk_data *clks); 568 569/** 570 * clk_bulk_put_all - "free" all the clock source 571 * @num_clks: the number of clk_bulk_data 572 * @clks: the clk_bulk_data table of consumer 573 * 574 * Note: drivers must ensure that all clk_bulk_enable calls made on this 575 * clock source are balanced by clk_bulk_disable calls prior to calling 576 * this function. 577 * 578 * clk_bulk_put_all should not be called from within interrupt context. 579 */ 580void clk_bulk_put_all(int num_clks, struct clk_bulk_data *clks); 581 582/** 583 * devm_clk_put - "free" a managed clock source 584 * @dev: device used to acquire the clock 585 * @clk: clock source acquired with devm_clk_get() 586 * 587 * Note: drivers must ensure that all clk_enable calls made on this 588 * clock source are balanced by clk_disable calls prior to calling 589 * this function. 590 * 591 * clk_put should not be called from within interrupt context. 592 */ 593void devm_clk_put(struct device *dev, struct clk *clk); 594 595/* 596 * The remaining APIs are optional for machine class support. 597 */ 598 599 600/** 601 * clk_round_rate - adjust a rate to the exact rate a clock can provide 602 * @clk: clock source 603 * @rate: desired clock rate in Hz 604 * 605 * This answers the question "if I were to pass @rate to clk_set_rate(), 606 * what clock rate would I end up with?" without changing the hardware 607 * in any way. In other words: 608 * 609 * rate = clk_round_rate(clk, r); 610 * 611 * and: 612 * 613 * clk_set_rate(clk, r); 614 * rate = clk_get_rate(clk); 615 * 616 * are equivalent except the former does not modify the clock hardware 617 * in any way. 618 * 619 * Returns rounded clock rate in Hz, or negative errno. 620 */ 621long clk_round_rate(struct clk *clk, unsigned long rate); 622 623/** 624 * clk_set_rate - set the clock rate for a clock source 625 * @clk: clock source 626 * @rate: desired clock rate in Hz 627 * 628 * Returns success (0) or negative errno. 629 */ 630int clk_set_rate(struct clk *clk, unsigned long rate); 631 632/** 633 * clk_set_rate_exclusive- set the clock rate and claim exclusivity over 634 * clock source 635 * @clk: clock source 636 * @rate: desired clock rate in Hz 637 * 638 * This helper function allows drivers to atomically set the rate of a producer 639 * and claim exclusivity over the rate control of the producer. 640 * 641 * It is essentially a combination of clk_set_rate() and 642 * clk_rate_exclusite_get(). Caller must balance this call with a call to 643 * clk_rate_exclusive_put() 644 * 645 * Returns success (0) or negative errno. 646 */ 647int clk_set_rate_exclusive(struct clk *clk, unsigned long rate); 648 649/** 650 * clk_has_parent - check if a clock is a possible parent for another 651 * @clk: clock source 652 * @parent: parent clock source 653 * 654 * This function can be used in drivers that need to check that a clock can be 655 * the parent of another without actually changing the parent. 656 * 657 * Returns true if @parent is a possible parent for @clk, false otherwise. 658 */ 659bool clk_has_parent(struct clk *clk, struct clk *parent); 660 661/** 662 * clk_set_rate_range - set a rate range for a clock source 663 * @clk: clock source 664 * @min: desired minimum clock rate in Hz, inclusive 665 * @max: desired maximum clock rate in Hz, inclusive 666 * 667 * Returns success (0) or negative errno. 668 */ 669int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max); 670 671/** 672 * clk_set_min_rate - set a minimum clock rate for a clock source 673 * @clk: clock source 674 * @rate: desired minimum clock rate in Hz, inclusive 675 * 676 * Returns success (0) or negative errno. 677 */ 678int clk_set_min_rate(struct clk *clk, unsigned long rate); 679 680/** 681 * clk_set_max_rate - set a maximum clock rate for a clock source 682 * @clk: clock source 683 * @rate: desired maximum clock rate in Hz, inclusive 684 * 685 * Returns success (0) or negative errno. 686 */ 687int clk_set_max_rate(struct clk *clk, unsigned long rate); 688 689/** 690 * clk_set_parent - set the parent clock source for this clock 691 * @clk: clock source 692 * @parent: parent clock source 693 * 694 * Returns success (0) or negative errno. 695 */ 696int clk_set_parent(struct clk *clk, struct clk *parent); 697 698/** 699 * clk_get_parent - get the parent clock source for this clock 700 * @clk: clock source 701 * 702 * Returns struct clk corresponding to parent clock source, or 703 * valid IS_ERR() condition containing errno. 704 */ 705struct clk *clk_get_parent(struct clk *clk); 706 707/** 708 * clk_get_sys - get a clock based upon the device name 709 * @dev_id: device name 710 * @con_id: connection ID 711 * 712 * Returns a struct clk corresponding to the clock producer, or 713 * valid IS_ERR() condition containing errno. The implementation 714 * uses @dev_id and @con_id to determine the clock consumer, and 715 * thereby the clock producer. In contrast to clk_get() this function 716 * takes the device name instead of the device itself for identification. 717 * 718 * Drivers must assume that the clock source is not enabled. 719 * 720 * clk_get_sys should not be called from within interrupt context. 721 */ 722struct clk *clk_get_sys(const char *dev_id, const char *con_id); 723 724/** 725 * clk_save_context - save clock context for poweroff 726 * 727 * Saves the context of the clock register for powerstates in which the 728 * contents of the registers will be lost. Occurs deep within the suspend 729 * code so locking is not necessary. 730 */ 731int clk_save_context(void); 732 733/** 734 * clk_restore_context - restore clock context after poweroff 735 * 736 * This occurs with all clocks enabled. Occurs deep within the resume code 737 * so locking is not necessary. 738 */ 739void clk_restore_context(void); 740 741#else /* !CONFIG_HAVE_CLK */ 742 743static inline struct clk *clk_get(struct device *dev, const char *id) 744{ 745 return NULL; 746} 747 748static inline int __must_check clk_bulk_get(struct device *dev, int num_clks, 749 struct clk_bulk_data *clks) 750{ 751 return 0; 752} 753 754static inline int __must_check clk_bulk_get_optional(struct device *dev, 755 int num_clks, struct clk_bulk_data *clks) 756{ 757 return 0; 758} 759 760static inline int __must_check clk_bulk_get_all(struct device *dev, 761 struct clk_bulk_data **clks) 762{ 763 return 0; 764} 765 766static inline struct clk *devm_clk_get(struct device *dev, const char *id) 767{ 768 return NULL; 769} 770 771static inline struct clk *devm_clk_get_optional(struct device *dev, 772 const char *id) 773{ 774 return NULL; 775} 776 777static inline int __must_check devm_clk_bulk_get(struct device *dev, int num_clks, 778 struct clk_bulk_data *clks) 779{ 780 return 0; 781} 782 783static inline int __must_check devm_clk_bulk_get_optional(struct device *dev, 784 int num_clks, struct clk_bulk_data *clks) 785{ 786 return 0; 787} 788 789static inline int __must_check devm_clk_bulk_get_all(struct device *dev, 790 struct clk_bulk_data **clks) 791{ 792 793 return 0; 794} 795 796static inline struct clk *devm_get_clk_from_child(struct device *dev, 797 struct device_node *np, const char *con_id) 798{ 799 return NULL; 800} 801 802static inline void clk_put(struct clk *clk) {} 803 804static inline void clk_bulk_put(int num_clks, struct clk_bulk_data *clks) {} 805 806static inline void clk_bulk_put_all(int num_clks, struct clk_bulk_data *clks) {} 807 808static inline void devm_clk_put(struct device *dev, struct clk *clk) {} 809 810 811static inline int clk_rate_exclusive_get(struct clk *clk) 812{ 813 return 0; 814} 815 816static inline void clk_rate_exclusive_put(struct clk *clk) {} 817 818static inline int clk_enable(struct clk *clk) 819{ 820 return 0; 821} 822 823static inline int __must_check clk_bulk_enable(int num_clks, struct clk_bulk_data *clks) 824{ 825 return 0; 826} 827 828static inline void clk_disable(struct clk *clk) {} 829 830 831static inline void clk_bulk_disable(int num_clks, 832 struct clk_bulk_data *clks) {} 833 834static inline unsigned long clk_get_rate(struct clk *clk) 835{ 836 return 0; 837} 838 839static inline int clk_set_rate(struct clk *clk, unsigned long rate) 840{ 841 return 0; 842} 843 844static inline int clk_set_rate_exclusive(struct clk *clk, unsigned long rate) 845{ 846 return 0; 847} 848 849static inline long clk_round_rate(struct clk *clk, unsigned long rate) 850{ 851 return 0; 852} 853 854static inline bool clk_has_parent(struct clk *clk, struct clk *parent) 855{ 856 return true; 857} 858 859static inline int clk_set_rate_range(struct clk *clk, unsigned long min, 860 unsigned long max) 861{ 862 return 0; 863} 864 865static inline int clk_set_min_rate(struct clk *clk, unsigned long rate) 866{ 867 return 0; 868} 869 870static inline int clk_set_max_rate(struct clk *clk, unsigned long rate) 871{ 872 return 0; 873} 874 875static inline int clk_set_parent(struct clk *clk, struct clk *parent) 876{ 877 return 0; 878} 879 880static inline struct clk *clk_get_parent(struct clk *clk) 881{ 882 return NULL; 883} 884 885static inline struct clk *clk_get_sys(const char *dev_id, const char *con_id) 886{ 887 return NULL; 888} 889 890static inline int clk_save_context(void) 891{ 892 return 0; 893} 894 895static inline void clk_restore_context(void) {} 896 897#endif 898 899/* clk_prepare_enable helps cases using clk_enable in non-atomic context. */ 900static inline int clk_prepare_enable(struct clk *clk) 901{ 902 int ret; 903 904 ret = clk_prepare(clk); 905 if (ret) 906 return ret; 907 ret = clk_enable(clk); 908 if (ret) 909 clk_unprepare(clk); 910 911 return ret; 912} 913 914/* clk_disable_unprepare helps cases using clk_disable in non-atomic context. */ 915static inline void clk_disable_unprepare(struct clk *clk) 916{ 917 clk_disable(clk); 918 clk_unprepare(clk); 919} 920 921static inline int __must_check clk_bulk_prepare_enable(int num_clks, 922 struct clk_bulk_data *clks) 923{ 924 int ret; 925 926 ret = clk_bulk_prepare(num_clks, clks); 927 if (ret) 928 return ret; 929 ret = clk_bulk_enable(num_clks, clks); 930 if (ret) 931 clk_bulk_unprepare(num_clks, clks); 932 933 return ret; 934} 935 936static inline void clk_bulk_disable_unprepare(int num_clks, 937 struct clk_bulk_data *clks) 938{ 939 clk_bulk_disable(num_clks, clks); 940 clk_bulk_unprepare(num_clks, clks); 941} 942 943/** 944 * clk_get_optional - lookup and obtain a reference to an optional clock 945 * producer. 946 * @dev: device for clock "consumer" 947 * @id: clock consumer ID 948 * 949 * Behaves the same as clk_get() except where there is no clock producer. In 950 * this case, instead of returning -ENOENT, the function returns NULL. 951 */ 952static inline struct clk *clk_get_optional(struct device *dev, const char *id) 953{ 954 struct clk *clk = clk_get(dev, id); 955 956 if (clk == ERR_PTR(-ENOENT)) 957 return NULL; 958 959 return clk; 960} 961 962#if defined(CONFIG_OF) && defined(CONFIG_COMMON_CLK) 963struct clk *of_clk_get(struct device_node *np, int index); 964struct clk *of_clk_get_by_name(struct device_node *np, const char *name); 965struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec); 966#else 967static inline struct clk *of_clk_get(struct device_node *np, int index) 968{ 969 return ERR_PTR(-ENOENT); 970} 971static inline struct clk *of_clk_get_by_name(struct device_node *np, 972 const char *name) 973{ 974 return ERR_PTR(-ENOENT); 975} 976static inline struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec) 977{ 978 return ERR_PTR(-ENOENT); 979} 980#endif 981 982#endif 983