include/linux/pm_opp.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Generic OPP Interface
   4  *
   5  * Copyright (C) 2009-2010 Texas Instruments Incorporated.
   6  *      Nishanth Menon
   7  *      Romit Dasgupta
   8  *      Kevin Hilman
   9  */
  10
  11 #ifndef __LINUX_OPP_H__
  12 #define __LINUX_OPP_H__
  13
  14 #include <linux/energy_model.h>
  15 #include <linux/err.h>
  16 #include <linux/notifier.h>
  17
  18 struct clk;
  19 struct cpufreq_frequency_table;
  20 struct regulator;
  21 struct dev_pm_opp;
  22 struct device;
  23 struct opp_table;
  24
  25 enum dev_pm_opp_event {
  26         OPP_EVENT_ADD, OPP_EVENT_REMOVE, OPP_EVENT_ENABLE, OPP_EVENT_DISABLE,
  27         OPP_EVENT_ADJUST_VOLTAGE,
  28 };
  29
  30 /**
  31  * struct dev_pm_opp_supply - Power supply voltage/current values
  32  * @u_volt:     Target voltage in microvolts corresponding to this OPP
  33  * @u_volt_min: Minimum voltage in microvolts corresponding to this OPP
  34  * @u_volt_max: Maximum voltage in microvolts corresponding to this OPP
  35  * @u_amp:      Maximum current drawn by the device in microamperes
  36  * @u_watt:     Power used by the device in microwatts
  37  *
  38  * This structure stores the voltage/current/power values for a single power
  39  * supply.
  40  */
  41 struct dev_pm_opp_supply {
  42         unsigned long u_volt;
  43         unsigned long u_volt_min;
  44         unsigned long u_volt_max;
  45         unsigned long u_amp;
  46         unsigned long u_watt;
  47 };
  48
  49 typedef int (*config_regulators_t)(struct device *dev,
  50                         struct dev_pm_opp *old_opp, struct dev_pm_opp *new_opp,
  51                         struct regulator **regulators, unsigned int count);
  52
  53 typedef int (*config_clks_t)(struct device *dev, struct opp_table *opp_table,
  54                         struct dev_pm_opp *opp, void *data, bool scaling_down);
  55
  56 /**
  57  * struct dev_pm_opp_config - Device OPP configuration values
  58  * @clk_names: Clk names, NULL terminated array.
  59  * @config_clks: Custom set clk helper.
  60  * @prop_name: Name to postfix to properties.
  61  * @config_regulators: Custom set regulator helper.
  62  * @supported_hw: Array of hierarchy of versions to match.
  63  * @supported_hw_count: Number of elements in the array.
  64  * @regulator_names: Array of pointers to the names of the regulator, NULL terminated.
  65  * @genpd_names: Null terminated array of pointers containing names of genpd to
  66  *              attach. Mutually exclusive with required_devs.
  67  * @virt_devs: Pointer to return the array of genpd virtual devices. Mutually
  68  *              exclusive with required_devs.
  69  * @required_devs: Required OPP devices. Mutually exclusive with genpd_names/virt_devs.
  70  *
  71  * This structure contains platform specific OPP configurations for the device.
  72  */
  73 struct dev_pm_opp_config {
  74         /* NULL terminated */
  75         const char * const *clk_names;
  76         config_clks_t config_clks;
  77         const char *prop_name;
  78         config_regulators_t config_regulators;
  79         const unsigned int *supported_hw;
  80         unsigned int supported_hw_count;
  81         const char * const *regulator_names;
  82         const char * const *genpd_names;
  83         struct device ***virt_devs;
  84         struct device **required_devs;
  85 };
  86
  87 #define OPP_LEVEL_UNSET                 U32_MAX
  88
  89 /**
  90  * struct dev_pm_opp_data - The data to use to initialize an OPP.
  91  * @turbo: Flag to indicate whether the OPP is to be marked turbo or not.
  92  * @level: The performance level for the OPP. Set level to OPP_LEVEL_UNSET if
  93  * level field isn't used.
  94  * @freq: The clock rate in Hz for the OPP.
  95  * @u_volt: The voltage in uV for the OPP.
  96  */
  97 struct dev_pm_opp_data {
  98         bool turbo;
  99         unsigned int level;
 100         unsigned long freq;
 101         unsigned long u_volt;
 102 };
 103
 104 #if defined(CONFIG_PM_OPP)
 105
 106 struct opp_table *dev_pm_opp_get_opp_table(struct device *dev);
 107 void dev_pm_opp_put_opp_table(struct opp_table *opp_table);
 108
 109 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp);
 110
 111 int dev_pm_opp_get_supplies(struct dev_pm_opp *opp, struct dev_pm_opp_supply *supplies);
 112
 113 unsigned long dev_pm_opp_get_power(struct dev_pm_opp *opp);
 114
 115 unsigned long dev_pm_opp_get_freq_indexed(struct dev_pm_opp *opp, u32 index);
 116
 117 unsigned int dev_pm_opp_get_level(struct dev_pm_opp *opp);
 118
 119 unsigned int dev_pm_opp_get_required_pstate(struct dev_pm_opp *opp,
 120                                             unsigned int index);
 121
 122 bool dev_pm_opp_is_turbo(struct dev_pm_opp *opp);
 123
 124 int dev_pm_opp_get_opp_count(struct device *dev);
 125 unsigned long dev_pm_opp_get_max_clock_latency(struct device *dev);
 126 unsigned long dev_pm_opp_get_max_volt_latency(struct device *dev);
 127 unsigned long dev_pm_opp_get_max_transition_latency(struct device *dev);
 128 unsigned long dev_pm_opp_get_suspend_opp_freq(struct device *dev);
 129
 130 struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
 131                                               unsigned long freq,
 132                                               bool available);
 133
 134 struct dev_pm_opp *
 135 dev_pm_opp_find_freq_exact_indexed(struct device *dev, unsigned long freq,
 136                                    u32 index, bool available);
 137
 138 struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
 139                                               unsigned long *freq);
 140
 141 struct dev_pm_opp *dev_pm_opp_find_freq_floor_indexed(struct device *dev,
 142                                                       unsigned long *freq, u32 index);
 143
 144 struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
 145                                              unsigned long *freq);
 146
 147 struct dev_pm_opp *dev_pm_opp_find_freq_ceil_indexed(struct device *dev,
 148                                                      unsigned long *freq, u32 index);
 149
 150 struct dev_pm_opp *dev_pm_opp_find_level_exact(struct device *dev,
 151                                                unsigned int level);
 152
 153 struct dev_pm_opp *dev_pm_opp_find_level_ceil(struct device *dev,
 154                                               unsigned int *level);
 155
 156 struct dev_pm_opp *dev_pm_opp_find_level_floor(struct device *dev,
 157                                                unsigned int *level);
 158
 159 struct dev_pm_opp *dev_pm_opp_find_bw_ceil(struct device *dev,
 160                                            unsigned int *bw, int index);
 161
 162 struct dev_pm_opp *dev_pm_opp_find_bw_floor(struct device *dev,
 163                                            unsigned int *bw, int index);
 164
 165 void dev_pm_opp_put(struct dev_pm_opp *opp);
 166
 167 int dev_pm_opp_add_dynamic(struct device *dev, struct dev_pm_opp_data *opp);
 168
 169 void dev_pm_opp_remove(struct device *dev, unsigned long freq);
 170 void dev_pm_opp_remove_all_dynamic(struct device *dev);
 171
 172 int dev_pm_opp_adjust_voltage(struct device *dev, unsigned long freq,
 173                               unsigned long u_volt, unsigned long u_volt_min,
 174                               unsigned long u_volt_max);
 175
 176 int dev_pm_opp_enable(struct device *dev, unsigned long freq);
 177
 178 int dev_pm_opp_disable(struct device *dev, unsigned long freq);
 179
 180 int dev_pm_opp_register_notifier(struct device *dev, struct notifier_block *nb);
 181 int dev_pm_opp_unregister_notifier(struct device *dev, struct notifier_block *nb);
 182
 183 int dev_pm_opp_set_config(struct device *dev, struct dev_pm_opp_config *config);
 184 int devm_pm_opp_set_config(struct device *dev, struct dev_pm_opp_config *config);
 185 void dev_pm_opp_clear_config(int token);
 186 int dev_pm_opp_config_clks_simple(struct device *dev,
 187                 struct opp_table *opp_table, struct dev_pm_opp *opp, void *data,
 188                 bool scaling_down);
 189
 190 struct dev_pm_opp *dev_pm_opp_xlate_required_opp(struct opp_table *src_table, struct opp_table *dst_table, struct dev_pm_opp *src_opp);
 191 int dev_pm_opp_xlate_performance_state(struct opp_table *src_table, struct opp_table *dst_table, unsigned int pstate);
 192 int dev_pm_opp_set_rate(struct device *dev, unsigned long target_freq);
 193 int dev_pm_opp_set_opp(struct device *dev, struct dev_pm_opp *opp);
 194 int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, const struct cpumask *cpumask);
 195 int dev_pm_opp_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask);
 196 void dev_pm_opp_remove_table(struct device *dev);
 197 void dev_pm_opp_cpumask_remove_table(const struct cpumask *cpumask);
 198 int dev_pm_opp_sync_regulators(struct device *dev);
 199 #else
 200 static inline struct opp_table *dev_pm_opp_get_opp_table(struct device *dev)
 201 {
 202         return ERR_PTR(-EOPNOTSUPP);
 203 }
 204
 205 static inline struct opp_table *dev_pm_opp_get_opp_table_indexed(struct device *dev, int index)
 206 {
 207         return ERR_PTR(-EOPNOTSUPP);
 208 }
 209
 210 static inline void dev_pm_opp_put_opp_table(struct opp_table *opp_table) {}
 211
 212 static inline unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
 213 {
 214         return 0;
 215 }
 216
 217 static inline int dev_pm_opp_get_supplies(struct dev_pm_opp *opp, struct dev_pm_opp_supply *supplies)
 218 {
 219         return -EOPNOTSUPP;
 220 }
 221
 222 static inline unsigned long dev_pm_opp_get_power(struct dev_pm_opp *opp)
 223 {
 224         return 0;
 225 }
 226
 227 static inline unsigned long dev_pm_opp_get_freq_indexed(struct dev_pm_opp *opp, u32 index)
 228 {
 229         return 0;
 230 }
 231
 232 static inline unsigned int dev_pm_opp_get_level(struct dev_pm_opp *opp)
 233 {
 234         return 0;
 235 }
 236
 237 static inline
 238 unsigned int dev_pm_opp_get_required_pstate(struct dev_pm_opp *opp,
 239                                             unsigned int index)
 240 {
 241         return 0;
 242 }
 243
 244 static inline bool dev_pm_opp_is_turbo(struct dev_pm_opp *opp)
 245 {
 246         return false;
 247 }
 248
 249 static inline int dev_pm_opp_get_opp_count(struct device *dev)
 250 {
 251         return 0;
 252 }
 253
 254 static inline unsigned long dev_pm_opp_get_max_clock_latency(struct device *dev)
 255 {
 256         return 0;
 257 }
 258
 259 static inline unsigned long dev_pm_opp_get_max_volt_latency(struct device *dev)
 260 {
 261         return 0;
 262 }
 263
 264 static inline unsigned long dev_pm_opp_get_max_transition_latency(struct device *dev)
 265 {
 266         return 0;
 267 }
 268
 269 static inline unsigned long dev_pm_opp_get_suspend_opp_freq(struct device *dev)
 270 {
 271         return 0;
 272 }
 273
 274 static inline struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
 275                                         unsigned long freq, bool available)
 276 {
 277         return ERR_PTR(-EOPNOTSUPP);
 278 }
 279
 280 static inline struct dev_pm_opp *
 281 dev_pm_opp_find_freq_exact_indexed(struct device *dev, unsigned long freq,
 282                                    u32 index, bool available)
 283 {
 284         return ERR_PTR(-EOPNOTSUPP);
 285 }
 286
 287 static inline struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
 288                                         unsigned long *freq)
 289 {
 290         return ERR_PTR(-EOPNOTSUPP);
 291 }
 292
 293 static inline struct dev_pm_opp *
 294 dev_pm_opp_find_freq_floor_indexed(struct device *dev, unsigned long *freq, u32 index)
 295 {
 296         return ERR_PTR(-EOPNOTSUPP);
 297 }
 298
 299 static inline struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
 300                                         unsigned long *freq)
 301 {
 302         return ERR_PTR(-EOPNOTSUPP);
 303 }
 304
 305 static inline struct dev_pm_opp *
 306 dev_pm_opp_find_freq_ceil_indexed(struct device *dev, unsigned long *freq, u32 index)
 307 {
 308         return ERR_PTR(-EOPNOTSUPP);
 309 }
 310
 311 static inline struct dev_pm_opp *dev_pm_opp_find_level_exact(struct device *dev,
 312                                         unsigned int level)
 313 {
 314         return ERR_PTR(-EOPNOTSUPP);
 315 }
 316
 317 static inline struct dev_pm_opp *dev_pm_opp_find_level_ceil(struct device *dev,
 318                                         unsigned int *level)
 319 {
 320         return ERR_PTR(-EOPNOTSUPP);
 321 }
 322
 323 static inline struct dev_pm_opp *dev_pm_opp_find_level_floor(struct device *dev,
 324                                                              unsigned int *level)
 325 {
 326         return ERR_PTR(-EOPNOTSUPP);
 327 }
 328
 329 static inline struct dev_pm_opp *dev_pm_opp_find_bw_ceil(struct device *dev,
 330                                         unsigned int *bw, int index)
 331 {
 332         return ERR_PTR(-EOPNOTSUPP);
 333 }
 334
 335 static inline struct dev_pm_opp *dev_pm_opp_find_bw_floor(struct device *dev,
 336                                         unsigned int *bw, int index)
 337 {
 338         return ERR_PTR(-EOPNOTSUPP);
 339 }
 340
 341 static inline void dev_pm_opp_put(struct dev_pm_opp *opp) {}
 342
 343 static inline int
 344 dev_pm_opp_add_dynamic(struct device *dev, struct dev_pm_opp_data *opp)
 345 {
 346         return -EOPNOTSUPP;
 347 }
 348
 349 static inline void dev_pm_opp_remove(struct device *dev, unsigned long freq)
 350 {
 351 }
 352
 353 static inline void dev_pm_opp_remove_all_dynamic(struct device *dev)
 354 {
 355 }
 356
 357 static inline int
 358 dev_pm_opp_adjust_voltage(struct device *dev, unsigned long freq,
 359                           unsigned long u_volt, unsigned long u_volt_min,
 360                           unsigned long u_volt_max)
 361 {
 362         return 0;
 363 }
 364
 365 static inline int dev_pm_opp_enable(struct device *dev, unsigned long freq)
 366 {
 367         return 0;
 368 }
 369
 370 static inline int dev_pm_opp_disable(struct device *dev, unsigned long freq)
 371 {
 372         return 0;
 373 }
 374
 375 static inline int dev_pm_opp_register_notifier(struct device *dev, struct notifier_block *nb)
 376 {
 377         return -EOPNOTSUPP;
 378 }
 379
 380 static inline int dev_pm_opp_unregister_notifier(struct device *dev, struct notifier_block *nb)
 381 {
 382         return -EOPNOTSUPP;
 383 }
 384
 385 static inline int dev_pm_opp_set_config(struct device *dev, struct dev_pm_opp_config *config)
 386 {
 387         return -EOPNOTSUPP;
 388 }
 389
 390 static inline int devm_pm_opp_set_config(struct device *dev, struct dev_pm_opp_config *config)
 391 {
 392         return -EOPNOTSUPP;
 393 }
 394
 395 static inline void dev_pm_opp_clear_config(int token) {}
 396
 397 static inline int dev_pm_opp_config_clks_simple(struct device *dev,
 398                 struct opp_table *opp_table, struct dev_pm_opp *opp, void *data,
 399                 bool scaling_down)
 400 {
 401         return -EOPNOTSUPP;
 402 }
 403
 404 static inline struct dev_pm_opp *dev_pm_opp_xlate_required_opp(struct opp_table *src_table,
 405                                 struct opp_table *dst_table, struct dev_pm_opp *src_opp)
 406 {
 407         return ERR_PTR(-EOPNOTSUPP);
 408 }
 409
 410 static inline int dev_pm_opp_xlate_performance_state(struct opp_table *src_table, struct opp_table *dst_table, unsigned int pstate)
 411 {
 412         return -EOPNOTSUPP;
 413 }
 414
 415 static inline int dev_pm_opp_set_rate(struct device *dev, unsigned long target_freq)
 416 {
 417         return -EOPNOTSUPP;
 418 }
 419
 420 static inline int dev_pm_opp_set_opp(struct device *dev, struct dev_pm_opp *opp)
 421 {
 422         return -EOPNOTSUPP;
 423 }
 424
 425 static inline int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, const struct cpumask *cpumask)
 426 {
 427         return -EOPNOTSUPP;
 428 }
 429
 430 static inline int dev_pm_opp_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask)
 431 {
 432         return -EINVAL;
 433 }
 434
 435 static inline void dev_pm_opp_remove_table(struct device *dev)
 436 {
 437 }
 438
 439 static inline void dev_pm_opp_cpumask_remove_table(const struct cpumask *cpumask)
 440 {
 441 }
 442
 443 static inline int dev_pm_opp_sync_regulators(struct device *dev)
 444 {
 445         return -EOPNOTSUPP;
 446 }
 447
 448 #endif          /* CONFIG_PM_OPP */
 449
 450 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
 451 int dev_pm_opp_init_cpufreq_table(struct device *dev, struct cpufreq_frequency_table **table);
 452 void dev_pm_opp_free_cpufreq_table(struct device *dev, struct cpufreq_frequency_table **table);
 453 #else
 454 static inline int dev_pm_opp_init_cpufreq_table(struct device *dev, struct cpufreq_frequency_table **table)
 455 {
 456         return -EINVAL;
 457 }
 458
 459 static inline void dev_pm_opp_free_cpufreq_table(struct device *dev, struct cpufreq_frequency_table **table)
 460 {
 461 }
 462 #endif
 463
 464
 465 #if defined(CONFIG_PM_OPP) && defined(CONFIG_OF)
 466 int dev_pm_opp_of_add_table(struct device *dev);
 467 int dev_pm_opp_of_add_table_indexed(struct device *dev, int index);
 468 int devm_pm_opp_of_add_table_indexed(struct device *dev, int index);
 469 void dev_pm_opp_of_remove_table(struct device *dev);
 470 int devm_pm_opp_of_add_table(struct device *dev);
 471 int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask);
 472 void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask);
 473 int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask);
 474 struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev);
 475 struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp);
 476 int of_get_required_opp_performance_state(struct device_node *np, int index);
 477 bool dev_pm_opp_of_has_required_opp(struct device *dev);
 478 int dev_pm_opp_of_find_icc_paths(struct device *dev, struct opp_table *opp_table);
 479 int dev_pm_opp_of_register_em(struct device *dev, struct cpumask *cpus);
 480 int dev_pm_opp_calc_power(struct device *dev, unsigned long *uW,
 481                           unsigned long *kHz);
 482 static inline void dev_pm_opp_of_unregister_em(struct device *dev)
 483 {
 484         em_dev_unregister_perf_domain(dev);
 485 }
 486 #else
 487 static inline int dev_pm_opp_of_add_table(struct device *dev)
 488 {
 489         return -EOPNOTSUPP;
 490 }
 491
 492 static inline int dev_pm_opp_of_add_table_indexed(struct device *dev, int index)
 493 {
 494         return -EOPNOTSUPP;
 495 }
 496
 497 static inline int devm_pm_opp_of_add_table_indexed(struct device *dev, int index)
 498 {
 499         return -EOPNOTSUPP;
 500 }
 501
 502 static inline void dev_pm_opp_of_remove_table(struct device *dev)
 503 {
 504 }
 505
 506 static inline int devm_pm_opp_of_add_table(struct device *dev)
 507 {
 508         return -EOPNOTSUPP;
 509 }
 510
 511 static inline int dev_pm_opp_of_cpumask_add_table(const struct cpumask *cpumask)
 512 {
 513         return -EOPNOTSUPP;
 514 }
 515
 516 static inline void dev_pm_opp_of_cpumask_remove_table(const struct cpumask *cpumask)
 517 {
 518 }
 519
 520 static inline int dev_pm_opp_of_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask)
 521 {
 522         return -EOPNOTSUPP;
 523 }
 524
 525 static inline struct device_node *dev_pm_opp_of_get_opp_desc_node(struct device *dev)
 526 {
 527         return NULL;
 528 }
 529
 530 static inline struct device_node *dev_pm_opp_get_of_node(struct dev_pm_opp *opp)
 531 {
 532         return NULL;
 533 }
 534
 535 static inline int dev_pm_opp_of_register_em(struct device *dev,
 536                                             struct cpumask *cpus)
 537 {
 538         return -EOPNOTSUPP;
 539 }
 540
 541 static inline void dev_pm_opp_of_unregister_em(struct device *dev)
 542 {
 543 }
 544
 545 static inline int dev_pm_opp_calc_power(struct device *dev, unsigned long *uW,
 546                                         unsigned long *kHz)
 547 {
 548         return -EOPNOTSUPP;
 549 }
 550
 551 static inline int of_get_required_opp_performance_state(struct device_node *np, int index)
 552 {
 553         return -EOPNOTSUPP;
 554 }
 555
 556 static inline bool dev_pm_opp_of_has_required_opp(struct device *dev)
 557 {
 558         return false;
 559 }
 560
 561 static inline int dev_pm_opp_of_find_icc_paths(struct device *dev, struct opp_table *opp_table)
 562 {
 563         return -EOPNOTSUPP;
 564 }
 565 #endif
 566
 567 /* OPP Configuration helpers */
 568
 569 static inline int dev_pm_opp_add(struct device *dev, unsigned long freq,
 570                                  unsigned long u_volt)
 571 {
 572         struct dev_pm_opp_data data = {
 573                 .freq = freq,
 574                 .u_volt = u_volt,
 575         };
 576
 577         return dev_pm_opp_add_dynamic(dev, &data);
 578 }
 579
 580 /* Regulators helpers */
 581 static inline int dev_pm_opp_set_regulators(struct device *dev,
 582                                             const char * const names[])
 583 {
 584         struct dev_pm_opp_config config = {
 585                 .regulator_names = names,
 586         };
 587
 588         return dev_pm_opp_set_config(dev, &config);
 589 }
 590
 591 static inline void dev_pm_opp_put_regulators(int token)
 592 {
 593         dev_pm_opp_clear_config(token);
 594 }
 595
 596 static inline int devm_pm_opp_set_regulators(struct device *dev,
 597                                              const char * const names[])
 598 {
 599         struct dev_pm_opp_config config = {
 600                 .regulator_names = names,
 601         };
 602
 603         return devm_pm_opp_set_config(dev, &config);
 604 }
 605
 606 /* Supported-hw helpers */
 607 static inline int dev_pm_opp_set_supported_hw(struct device *dev,
 608                                               const u32 *versions,
 609                                               unsigned int count)
 610 {
 611         struct dev_pm_opp_config config = {
 612                 .supported_hw = versions,
 613                 .supported_hw_count = count,
 614         };
 615
 616         return dev_pm_opp_set_config(dev, &config);
 617 }
 618
 619 static inline void dev_pm_opp_put_supported_hw(int token)
 620 {
 621         dev_pm_opp_clear_config(token);
 622 }
 623
 624 static inline int devm_pm_opp_set_supported_hw(struct device *dev,
 625                                                const u32 *versions,
 626                                                unsigned int count)
 627 {
 628         struct dev_pm_opp_config config = {
 629                 .supported_hw = versions,
 630                 .supported_hw_count = count,
 631         };
 632
 633         return devm_pm_opp_set_config(dev, &config);
 634 }
 635
 636 /* clkname helpers */
 637 static inline int dev_pm_opp_set_clkname(struct device *dev, const char *name)
 638 {
 639         const char *names[] = { name, NULL };
 640         struct dev_pm_opp_config config = {
 641                 .clk_names = names,
 642         };
 643
 644         return dev_pm_opp_set_config(dev, &config);
 645 }
 646
 647 static inline void dev_pm_opp_put_clkname(int token)
 648 {
 649         dev_pm_opp_clear_config(token);
 650 }
 651
 652 static inline int devm_pm_opp_set_clkname(struct device *dev, const char *name)
 653 {
 654         const char *names[] = { name, NULL };
 655         struct dev_pm_opp_config config = {
 656                 .clk_names = names,
 657         };
 658
 659         return devm_pm_opp_set_config(dev, &config);
 660 }
 661
 662 /* config-regulators helpers */
 663 static inline int dev_pm_opp_set_config_regulators(struct device *dev,
 664                                                    config_regulators_t helper)
 665 {
 666         struct dev_pm_opp_config config = {
 667                 .config_regulators = helper,
 668         };
 669
 670         return dev_pm_opp_set_config(dev, &config);
 671 }
 672
 673 static inline void dev_pm_opp_put_config_regulators(int token)
 674 {
 675         dev_pm_opp_clear_config(token);
 676 }
 677
 678 /* genpd helpers */
 679 static inline int dev_pm_opp_attach_genpd(struct device *dev,
 680                                           const char * const *names,
 681                                           struct device ***virt_devs)
 682 {
 683         struct dev_pm_opp_config config = {
 684                 .genpd_names = names,
 685                 .virt_devs = virt_devs,
 686         };
 687
 688         return dev_pm_opp_set_config(dev, &config);
 689 }
 690
 691 static inline void dev_pm_opp_detach_genpd(int token)
 692 {
 693         dev_pm_opp_clear_config(token);
 694 }
 695
 696 static inline int devm_pm_opp_attach_genpd(struct device *dev,
 697                                            const char * const *names,
 698                                            struct device ***virt_devs)
 699 {
 700         struct dev_pm_opp_config config = {
 701                 .genpd_names = names,
 702                 .virt_devs = virt_devs,
 703         };
 704
 705         return devm_pm_opp_set_config(dev, &config);
 706 }
 707
 708 /* prop-name helpers */
 709 static inline int dev_pm_opp_set_prop_name(struct device *dev, const char *name)
 710 {
 711         struct dev_pm_opp_config config = {
 712                 .prop_name = name,
 713         };
 714
 715         return dev_pm_opp_set_config(dev, &config);
 716 }
 717
 718 static inline void dev_pm_opp_put_prop_name(int token)
 719 {
 720         dev_pm_opp_clear_config(token);
 721 }
 722
 723 static inline unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
 724 {
 725         return dev_pm_opp_get_freq_indexed(opp, 0);
 726 }
 727
 728 #endif          /* __LINUX_OPP_H__ */