drivers/base/power/opp/core.c

   1 /*
   2  * Generic OPP Interface
   3  *
   4  * Copyright (C) 2009-2010 Texas Instruments Incorporated.
   5  *      Nishanth Menon
   6  *      Romit Dasgupta
   7  *      Kevin Hilman
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/errno.h>
  17 #include <linux/err.h>
  18 #include <linux/slab.h>
  19 #include <linux/device.h>
  20 #include <linux/of.h>
  21 #include <linux/export.h>
  22
  23 #include "opp.h"
  24
  25 /*
  26  * The root of the list of all devices. All device_opp structures branch off
  27  * from here, with each device_opp containing the list of opp it supports in
  28  * various states of availability.
  29  */
  30 static LIST_HEAD(dev_opp_list);
  31 /* Lock to allow exclusive modification to the device and opp lists */
  32 DEFINE_MUTEX(dev_opp_list_lock);
  33
  34 #define opp_rcu_lockdep_assert()                                        \
  35 do {                                                                    \
  36         RCU_LOCKDEP_WARN(!rcu_read_lock_held() &&                       \
  37                                 !lockdep_is_held(&dev_opp_list_lock),   \
  38                            "Missing rcu_read_lock() or "                \
  39                            "dev_opp_list_lock protection");             \
  40 } while (0)
  41
  42 static struct device_list_opp *_find_list_dev(const struct device *dev,
  43                                               struct device_opp *dev_opp)
  44 {
  45         struct device_list_opp *list_dev;
  46
  47         list_for_each_entry(list_dev, &dev_opp->dev_list, node)
  48                 if (list_dev->dev == dev)
  49                         return list_dev;
  50
  51         return NULL;
  52 }
  53
  54 static struct device_opp *_managed_opp(const struct device_node *np)
  55 {
  56         struct device_opp *dev_opp;
  57
  58         list_for_each_entry_rcu(dev_opp, &dev_opp_list, node) {
  59                 if (dev_opp->np == np) {
  60                         /*
  61                          * Multiple devices can point to the same OPP table and
  62                          * so will have same node-pointer, np.
  63                          *
  64                          * But the OPPs will be considered as shared only if the
  65                          * OPP table contains a "opp-shared" property.
  66                          */
  67                         return dev_opp->shared_opp ? dev_opp : NULL;
  68                 }
  69         }
  70
  71         return NULL;
  72 }
  73
  74 /**
  75  * _find_device_opp() - find device_opp struct using device pointer
  76  * @dev:        device pointer used to lookup device OPPs
  77  *
  78  * Search list of device OPPs for one containing matching device. Does a RCU
  79  * reader operation to grab the pointer needed.
  80  *
  81  * Return: pointer to 'struct device_opp' if found, otherwise -ENODEV or
  82  * -EINVAL based on type of error.
  83  *
  84  * Locking: For readers, this function must be called under rcu_read_lock().
  85  * device_opp is a RCU protected pointer, which means that device_opp is valid
  86  * as long as we are under RCU lock.
  87  *
  88  * For Writers, this function must be called with dev_opp_list_lock held.
  89  */
  90 struct device_opp *_find_device_opp(struct device *dev)
  91 {
  92         struct device_opp *dev_opp;
  93
  94         opp_rcu_lockdep_assert();
  95
  96         if (IS_ERR_OR_NULL(dev)) {
  97                 pr_err("%s: Invalid parameters\n", __func__);
  98                 return ERR_PTR(-EINVAL);
  99         }
 100
 101         list_for_each_entry_rcu(dev_opp, &dev_opp_list, node)
 102                 if (_find_list_dev(dev, dev_opp))
 103                         return dev_opp;
 104
 105         return ERR_PTR(-ENODEV);
 106 }
 107
 108 /**
 109  * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an available opp
 110  * @opp:        opp for which voltage has to be returned for
 111  *
 112  * Return: voltage in micro volt corresponding to the opp, else
 113  * return 0
 114  *
 115  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 116  * protected pointer. This means that opp which could have been fetched by
 117  * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
 118  * under RCU lock. The pointer returned by the opp_find_freq family must be
 119  * used in the same section as the usage of this function with the pointer
 120  * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
 121  * pointer.
 122  */
 123 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
 124 {
 125         struct dev_pm_opp *tmp_opp;
 126         unsigned long v = 0;
 127
 128         opp_rcu_lockdep_assert();
 129
 130         tmp_opp = rcu_dereference(opp);
 131         if (IS_ERR_OR_NULL(tmp_opp) || !tmp_opp->available)
 132                 pr_err("%s: Invalid parameters\n", __func__);
 133         else
 134                 v = tmp_opp->u_volt;
 135
 136         return v;
 137 }
 138 EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);
 139
 140 /**
 141  * dev_pm_opp_get_freq() - Gets the frequency corresponding to an available opp
 142  * @opp:        opp for which frequency has to be returned for
 143  *
 144  * Return: frequency in hertz corresponding to the opp, else
 145  * return 0
 146  *
 147  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 148  * protected pointer. This means that opp which could have been fetched by
 149  * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
 150  * under RCU lock. The pointer returned by the opp_find_freq family must be
 151  * used in the same section as the usage of this function with the pointer
 152  * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
 153  * pointer.
 154  */
 155 unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
 156 {
 157         struct dev_pm_opp *tmp_opp;
 158         unsigned long f = 0;
 159
 160         opp_rcu_lockdep_assert();
 161
 162         tmp_opp = rcu_dereference(opp);
 163         if (IS_ERR_OR_NULL(tmp_opp) || !tmp_opp->available)
 164                 pr_err("%s: Invalid parameters\n", __func__);
 165         else
 166                 f = tmp_opp->rate;
 167
 168         return f;
 169 }
 170 EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq);
 171
 172 /**
 173  * dev_pm_opp_is_turbo() - Returns if opp is turbo OPP or not
 174  * @opp: opp for which turbo mode is being verified
 175  *
 176  * Turbo OPPs are not for normal use, and can be enabled (under certain
 177  * conditions) for short duration of times to finish high throughput work
 178  * quickly. Running on them for longer times may overheat the chip.
 179  *
 180  * Return: true if opp is turbo opp, else false.
 181  *
 182  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 183  * protected pointer. This means that opp which could have been fetched by
 184  * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
 185  * under RCU lock. The pointer returned by the opp_find_freq family must be
 186  * used in the same section as the usage of this function with the pointer
 187  * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
 188  * pointer.
 189  */
 190 bool dev_pm_opp_is_turbo(struct dev_pm_opp *opp)
 191 {
 192         struct dev_pm_opp *tmp_opp;
 193
 194         opp_rcu_lockdep_assert();
 195
 196         tmp_opp = rcu_dereference(opp);
 197         if (IS_ERR_OR_NULL(tmp_opp) || !tmp_opp->available) {
 198                 pr_err("%s: Invalid parameters\n", __func__);
 199                 return false;
 200         }
 201
 202         return tmp_opp->turbo;
 203 }
 204 EXPORT_SYMBOL_GPL(dev_pm_opp_is_turbo);
 205
 206 /**
 207  * dev_pm_opp_get_max_clock_latency() - Get max clock latency in nanoseconds
 208  * @dev:        device for which we do this operation
 209  *
 210  * Return: This function returns the max clock latency in nanoseconds.
 211  *
 212  * Locking: This function takes rcu_read_lock().
 213  */
 214 unsigned long dev_pm_opp_get_max_clock_latency(struct device *dev)
 215 {
 216         struct device_opp *dev_opp;
 217         unsigned long clock_latency_ns;
 218
 219         rcu_read_lock();
 220
 221         dev_opp = _find_device_opp(dev);
 222         if (IS_ERR(dev_opp))
 223                 clock_latency_ns = 0;
 224         else
 225                 clock_latency_ns = dev_opp->clock_latency_ns_max;
 226
 227         rcu_read_unlock();
 228         return clock_latency_ns;
 229 }
 230 EXPORT_SYMBOL_GPL(dev_pm_opp_get_max_clock_latency);
 231
 232 /**
 233  * dev_pm_opp_get_suspend_opp() - Get suspend opp
 234  * @dev:        device for which we do this operation
 235  *
 236  * Return: This function returns pointer to the suspend opp if it is
 237  * defined and available, otherwise it returns NULL.
 238  *
 239  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 240  * protected pointer. The reason for the same is that the opp pointer which is
 241  * returned will remain valid for use with opp_get_{voltage, freq} only while
 242  * under the locked area. The pointer returned must be used prior to unlocking
 243  * with rcu_read_unlock() to maintain the integrity of the pointer.
 244  */
 245 struct dev_pm_opp *dev_pm_opp_get_suspend_opp(struct device *dev)
 246 {
 247         struct device_opp *dev_opp;
 248
 249         opp_rcu_lockdep_assert();
 250
 251         dev_opp = _find_device_opp(dev);
 252         if (IS_ERR(dev_opp) || !dev_opp->suspend_opp ||
 253             !dev_opp->suspend_opp->available)
 254                 return NULL;
 255
 256         return dev_opp->suspend_opp;
 257 }
 258 EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp);
 259
 260 /**
 261  * dev_pm_opp_get_opp_count() - Get number of opps available in the opp list
 262  * @dev:        device for which we do this operation
 263  *
 264  * Return: This function returns the number of available opps if there are any,
 265  * else returns 0 if none or the corresponding error value.
 266  *
 267  * Locking: This function takes rcu_read_lock().
 268  */
 269 int dev_pm_opp_get_opp_count(struct device *dev)
 270 {
 271         struct device_opp *dev_opp;
 272         struct dev_pm_opp *temp_opp;
 273         int count = 0;
 274
 275         rcu_read_lock();
 276
 277         dev_opp = _find_device_opp(dev);
 278         if (IS_ERR(dev_opp)) {
 279                 count = PTR_ERR(dev_opp);
 280                 dev_err(dev, "%s: device OPP not found (%d)\n",
 281                         __func__, count);
 282                 goto out_unlock;
 283         }
 284
 285         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
 286                 if (temp_opp->available)
 287                         count++;
 288         }
 289
 290 out_unlock:
 291         rcu_read_unlock();
 292         return count;
 293 }
 294 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);
 295
 296 /**
 297  * dev_pm_opp_find_freq_exact() - search for an exact frequency
 298  * @dev:                device for which we do this operation
 299  * @freq:               frequency to search for
 300  * @available:          true/false - match for available opp
 301  *
 302  * Return: Searches for exact match in the opp list and returns pointer to the
 303  * matching opp if found, else returns ERR_PTR in case of error and should
 304  * be handled using IS_ERR. Error return values can be:
 305  * EINVAL:      for bad pointer
 306  * ERANGE:      no match found for search
 307  * ENODEV:      if device not found in list of registered devices
 308  *
 309  * Note: available is a modifier for the search. if available=true, then the
 310  * match is for exact matching frequency and is available in the stored OPP
 311  * table. if false, the match is for exact frequency which is not available.
 312  *
 313  * This provides a mechanism to enable an opp which is not available currently
 314  * or the opposite as well.
 315  *
 316  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 317  * protected pointer. The reason for the same is that the opp pointer which is
 318  * returned will remain valid for use with opp_get_{voltage, freq} only while
 319  * under the locked area. The pointer returned must be used prior to unlocking
 320  * with rcu_read_unlock() to maintain the integrity of the pointer.
 321  */
 322 struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
 323                                               unsigned long freq,
 324                                               bool available)
 325 {
 326         struct device_opp *dev_opp;
 327         struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 328
 329         opp_rcu_lockdep_assert();
 330
 331         dev_opp = _find_device_opp(dev);
 332         if (IS_ERR(dev_opp)) {
 333                 int r = PTR_ERR(dev_opp);
 334                 dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r);
 335                 return ERR_PTR(r);
 336         }
 337
 338         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
 339                 if (temp_opp->available == available &&
 340                                 temp_opp->rate == freq) {
 341                         opp = temp_opp;
 342                         break;
 343                 }
 344         }
 345
 346         return opp;
 347 }
 348 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);
 349
 350 /**
 351  * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq
 352  * @dev:        device for which we do this operation
 353  * @freq:       Start frequency
 354  *
 355  * Search for the matching ceil *available* OPP from a starting freq
 356  * for a device.
 357  *
 358  * Return: matching *opp and refreshes *freq accordingly, else returns
 359  * ERR_PTR in case of error and should be handled using IS_ERR. Error return
 360  * values can be:
 361  * EINVAL:      for bad pointer
 362  * ERANGE:      no match found for search
 363  * ENODEV:      if device not found in list of registered devices
 364  *
 365  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 366  * protected pointer. The reason for the same is that the opp pointer which is
 367  * returned will remain valid for use with opp_get_{voltage, freq} only while
 368  * under the locked area. The pointer returned must be used prior to unlocking
 369  * with rcu_read_unlock() to maintain the integrity of the pointer.
 370  */
 371 struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
 372                                              unsigned long *freq)
 373 {
 374         struct device_opp *dev_opp;
 375         struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 376
 377         opp_rcu_lockdep_assert();
 378
 379         if (!dev || !freq) {
 380                 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
 381                 return ERR_PTR(-EINVAL);
 382         }
 383
 384         dev_opp = _find_device_opp(dev);
 385         if (IS_ERR(dev_opp))
 386                 return ERR_CAST(dev_opp);
 387
 388         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
 389                 if (temp_opp->available && temp_opp->rate >= *freq) {
 390                         opp = temp_opp;
 391                         *freq = opp->rate;
 392                         break;
 393                 }
 394         }
 395
 396         return opp;
 397 }
 398 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);
 399
 400 /**
 401  * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq
 402  * @dev:        device for which we do this operation
 403  * @freq:       Start frequency
 404  *
 405  * Search for the matching floor *available* OPP from a starting freq
 406  * for a device.
 407  *
 408  * Return: matching *opp and refreshes *freq accordingly, else returns
 409  * ERR_PTR in case of error and should be handled using IS_ERR. Error return
 410  * values can be:
 411  * EINVAL:      for bad pointer
 412  * ERANGE:      no match found for search
 413  * ENODEV:      if device not found in list of registered devices
 414  *
 415  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 416  * protected pointer. The reason for the same is that the opp pointer which is
 417  * returned will remain valid for use with opp_get_{voltage, freq} only while
 418  * under the locked area. The pointer returned must be used prior to unlocking
 419  * with rcu_read_unlock() to maintain the integrity of the pointer.
 420  */
 421 struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
 422                                               unsigned long *freq)
 423 {
 424         struct device_opp *dev_opp;
 425         struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 426
 427         opp_rcu_lockdep_assert();
 428
 429         if (!dev || !freq) {
 430                 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
 431                 return ERR_PTR(-EINVAL);
 432         }
 433
 434         dev_opp = _find_device_opp(dev);
 435         if (IS_ERR(dev_opp))
 436                 return ERR_CAST(dev_opp);
 437
 438         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
 439                 if (temp_opp->available) {
 440                         /* go to the next node, before choosing prev */
 441                         if (temp_opp->rate > *freq)
 442                                 break;
 443                         else
 444                                 opp = temp_opp;
 445                 }
 446         }
 447         if (!IS_ERR(opp))
 448                 *freq = opp->rate;
 449
 450         return opp;
 451 }
 452 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
 453
 454 /* List-dev Helpers */
 455 static void _kfree_list_dev_rcu(struct rcu_head *head)
 456 {
 457         struct device_list_opp *list_dev;
 458
 459         list_dev = container_of(head, struct device_list_opp, rcu_head);
 460         kfree_rcu(list_dev, rcu_head);
 461 }
 462
 463 static void _remove_list_dev(struct device_list_opp *list_dev,
 464                              struct device_opp *dev_opp)
 465 {
 466         list_del(&list_dev->node);
 467         call_srcu(&dev_opp->srcu_head.srcu, &list_dev->rcu_head,
 468                   _kfree_list_dev_rcu);
 469 }
 470
 471 struct device_list_opp *_add_list_dev(const struct device *dev,
 472                                       struct device_opp *dev_opp)
 473 {
 474         struct device_list_opp *list_dev;
 475
 476         list_dev = kzalloc(sizeof(*list_dev), GFP_KERNEL);
 477         if (!list_dev)
 478                 return NULL;
 479
 480         /* Initialize list-dev */
 481         list_dev->dev = dev;
 482         list_add_rcu(&list_dev->node, &dev_opp->dev_list);
 483
 484         return list_dev;
 485 }
 486
 487 /**
 488  * _add_device_opp() - Find device OPP table or allocate a new one
 489  * @dev:        device for which we do this operation
 490  *
 491  * It tries to find an existing table first, if it couldn't find one, it
 492  * allocates a new OPP table and returns that.
 493  *
 494  * Return: valid device_opp pointer if success, else NULL.
 495  */
 496 static struct device_opp *_add_device_opp(struct device *dev)
 497 {
 498         struct device_opp *dev_opp;
 499         struct device_list_opp *list_dev;
 500
 501         /* Check for existing list for 'dev' first */
 502         dev_opp = _find_device_opp(dev);
 503         if (!IS_ERR(dev_opp))
 504                 return dev_opp;
 505
 506         /*
 507          * Allocate a new device OPP table. In the infrequent case where a new
 508          * device is needed to be added, we pay this penalty.
 509          */
 510         dev_opp = kzalloc(sizeof(*dev_opp), GFP_KERNEL);
 511         if (!dev_opp)
 512                 return NULL;
 513
 514         INIT_LIST_HEAD(&dev_opp->dev_list);
 515
 516         list_dev = _add_list_dev(dev, dev_opp);
 517         if (!list_dev) {
 518                 kfree(dev_opp);
 519                 return NULL;
 520         }
 521
 522         srcu_init_notifier_head(&dev_opp->srcu_head);
 523         INIT_LIST_HEAD(&dev_opp->opp_list);
 524
 525         /* Secure the device list modification */
 526         list_add_rcu(&dev_opp->node, &dev_opp_list);
 527         return dev_opp;
 528 }
 529
 530 /**
 531  * _kfree_device_rcu() - Free device_opp RCU handler
 532  * @head:       RCU head
 533  */
 534 static void _kfree_device_rcu(struct rcu_head *head)
 535 {
 536         struct device_opp *device_opp = container_of(head, struct device_opp, rcu_head);
 537
 538         kfree_rcu(device_opp, rcu_head);
 539 }
 540
 541 /**
 542  * _remove_device_opp() - Removes a device OPP table
 543  * @dev_opp: device OPP table to be removed.
 544  *
 545  * Removes/frees device OPP table it it doesn't contain any OPPs.
 546  */
 547 static void _remove_device_opp(struct device_opp *dev_opp)
 548 {
 549         struct device_list_opp *list_dev;
 550
 551         if (!list_empty(&dev_opp->opp_list))
 552                 return;
 553
 554         list_dev = list_first_entry(&dev_opp->dev_list, struct device_list_opp,
 555                                     node);
 556
 557         _remove_list_dev(list_dev, dev_opp);
 558
 559         /* dev_list must be empty now */
 560         WARN_ON(!list_empty(&dev_opp->dev_list));
 561
 562         list_del_rcu(&dev_opp->node);
 563         call_srcu(&dev_opp->srcu_head.srcu, &dev_opp->rcu_head,
 564                   _kfree_device_rcu);
 565 }
 566
 567 /**
 568  * _kfree_opp_rcu() - Free OPP RCU handler
 569  * @head:       RCU head
 570  */
 571 static void _kfree_opp_rcu(struct rcu_head *head)
 572 {
 573         struct dev_pm_opp *opp = container_of(head, struct dev_pm_opp, rcu_head);
 574
 575         kfree_rcu(opp, rcu_head);
 576 }
 577
 578 /**
 579  * _opp_remove()  - Remove an OPP from a table definition
 580  * @dev_opp:    points back to the device_opp struct this opp belongs to
 581  * @opp:        pointer to the OPP to remove
 582  * @notify:     OPP_EVENT_REMOVE notification should be sent or not
 583  *
 584  * This function removes an opp definition from the opp list.
 585  *
 586  * Locking: The internal device_opp and opp structures are RCU protected.
 587  * It is assumed that the caller holds required mutex for an RCU updater
 588  * strategy.
 589  */
 590 static void _opp_remove(struct device_opp *dev_opp,
 591                         struct dev_pm_opp *opp, bool notify)
 592 {
 593         /*
 594          * Notify the changes in the availability of the operable
 595          * frequency/voltage list.
 596          */
 597         if (notify)
 598                 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_REMOVE, opp);
 599         list_del_rcu(&opp->node);
 600         call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
 601
 602         _remove_device_opp(dev_opp);
 603 }
 604
 605 /**
 606  * dev_pm_opp_remove()  - Remove an OPP from OPP list
 607  * @dev:        device for which we do this operation
 608  * @freq:       OPP to remove with matching 'freq'
 609  *
 610  * This function removes an opp from the opp list.
 611  *
 612  * Locking: The internal device_opp and opp structures are RCU protected.
 613  * Hence this function internally uses RCU updater strategy with mutex locks
 614  * to keep the integrity of the internal data structures. Callers should ensure
 615  * that this function is *NOT* called under RCU protection or in contexts where
 616  * mutex cannot be locked.
 617  */
 618 void dev_pm_opp_remove(struct device *dev, unsigned long freq)
 619 {
 620         struct dev_pm_opp *opp;
 621         struct device_opp *dev_opp;
 622         bool found = false;
 623
 624         /* Hold our list modification lock here */
 625         mutex_lock(&dev_opp_list_lock);
 626
 627         dev_opp = _find_device_opp(dev);
 628         if (IS_ERR(dev_opp))
 629                 goto unlock;
 630
 631         list_for_each_entry(opp, &dev_opp->opp_list, node) {
 632                 if (opp->rate == freq) {
 633                         found = true;
 634                         break;
 635                 }
 636         }
 637
 638         if (!found) {
 639                 dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
 640                          __func__, freq);
 641                 goto unlock;
 642         }
 643
 644         _opp_remove(dev_opp, opp, true);
 645 unlock:
 646         mutex_unlock(&dev_opp_list_lock);
 647 }
 648 EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
 649
 650 static struct dev_pm_opp *_allocate_opp(struct device *dev,
 651                                         struct device_opp **dev_opp)
 652 {
 653         struct dev_pm_opp *opp;
 654
 655         /* allocate new OPP node */
 656         opp = kzalloc(sizeof(*opp), GFP_KERNEL);
 657         if (!opp)
 658                 return NULL;
 659
 660         INIT_LIST_HEAD(&opp->node);
 661
 662         *dev_opp = _add_device_opp(dev);
 663         if (!*dev_opp) {
 664                 kfree(opp);
 665                 return NULL;
 666         }
 667
 668         return opp;
 669 }
 670
 671 static int _opp_add(struct device *dev, struct dev_pm_opp *new_opp,
 672                     struct device_opp *dev_opp)
 673 {
 674         struct dev_pm_opp *opp;
 675         struct list_head *head = &dev_opp->opp_list;
 676
 677         /*
 678          * Insert new OPP in order of increasing frequency and discard if
 679          * already present.
 680          *
 681          * Need to use &dev_opp->opp_list in the condition part of the 'for'
 682          * loop, don't replace it with head otherwise it will become an infinite
 683          * loop.
 684          */
 685         list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
 686                 if (new_opp->rate > opp->rate) {
 687                         head = &opp->node;
 688                         continue;
 689                 }
 690
 691                 if (new_opp->rate < opp->rate)
 692                         break;
 693
 694                 /* Duplicate OPPs */
 695                 dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
 696                          __func__, opp->rate, opp->u_volt, opp->available,
 697                          new_opp->rate, new_opp->u_volt, new_opp->available);
 698
 699                 return opp->available && new_opp->u_volt == opp->u_volt ?
 700                         0 : -EEXIST;
 701         }
 702
 703         new_opp->dev_opp = dev_opp;
 704         list_add_rcu(&new_opp->node, head);
 705
 706         return 0;
 707 }
 708
 709 /**
 710  * _opp_add_v1() - Allocate a OPP based on v1 bindings.
 711  * @dev:        device for which we do this operation
 712  * @freq:       Frequency in Hz for this OPP
 713  * @u_volt:     Voltage in uVolts for this OPP
 714  * @dynamic:    Dynamically added OPPs.
 715  *
 716  * This function adds an opp definition to the opp list and returns status.
 717  * The opp is made available by default and it can be controlled using
 718  * dev_pm_opp_enable/disable functions and may be removed by dev_pm_opp_remove.
 719  *
 720  * NOTE: "dynamic" parameter impacts OPPs added by the dev_pm_opp_of_add_table
 721  * and freed by dev_pm_opp_of_remove_table.
 722  *
 723  * Locking: The internal device_opp and opp structures are RCU protected.
 724  * Hence this function internally uses RCU updater strategy with mutex locks
 725  * to keep the integrity of the internal data structures. Callers should ensure
 726  * that this function is *NOT* called under RCU protection or in contexts where
 727  * mutex cannot be locked.
 728  *
 729  * Return:
 730  * 0            On success OR
 731  *              Duplicate OPPs (both freq and volt are same) and opp->available
 732  * -EEXIST      Freq are same and volt are different OR
 733  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 734  * -ENOMEM      Memory allocation failure
 735  */
 736 static int _opp_add_v1(struct device *dev, unsigned long freq, long u_volt,
 737                        bool dynamic)
 738 {
 739         struct device_opp *dev_opp;
 740         struct dev_pm_opp *new_opp;
 741         int ret;
 742
 743         /* Hold our list modification lock here */
 744         mutex_lock(&dev_opp_list_lock);
 745
 746         new_opp = _allocate_opp(dev, &dev_opp);
 747         if (!new_opp) {
 748                 ret = -ENOMEM;
 749                 goto unlock;
 750         }
 751
 752         /* populate the opp table */
 753         new_opp->rate = freq;
 754         new_opp->u_volt = u_volt;
 755         new_opp->available = true;
 756         new_opp->dynamic = dynamic;
 757
 758         ret = _opp_add(dev, new_opp, dev_opp);
 759         if (ret)
 760                 goto free_opp;
 761
 762         mutex_unlock(&dev_opp_list_lock);
 763
 764         /*
 765          * Notify the changes in the availability of the operable
 766          * frequency/voltage list.
 767          */
 768         srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
 769         return 0;
 770
 771 free_opp:
 772         _opp_remove(dev_opp, new_opp, false);
 773 unlock:
 774         mutex_unlock(&dev_opp_list_lock);
 775         return ret;
 776 }
 777
 778 /* TODO: Support multiple regulators */
 779 static int opp_parse_supplies(struct dev_pm_opp *opp, struct device *dev)
 780 {
 781         u32 microvolt[3] = {0};
 782         u32 val;
 783         int count, ret;
 784
 785         count = of_property_count_u32_elems(opp->np, "opp-microvolt");
 786         if (!count)
 787                 return 0;
 788
 789         /* There can be one or three elements here */
 790         if (count != 1 && count != 3) {
 791                 dev_err(dev, "%s: Invalid number of elements in opp-microvolt property (%d)\n",
 792                         __func__, count);
 793                 return -EINVAL;
 794         }
 795
 796         ret = of_property_read_u32_array(opp->np, "opp-microvolt", microvolt,
 797                                          count);
 798         if (ret) {
 799                 dev_err(dev, "%s: error parsing opp-microvolt: %d\n", __func__,
 800                         ret);
 801                 return -EINVAL;
 802         }
 803
 804         opp->u_volt = microvolt[0];
 805         opp->u_volt_min = microvolt[1];
 806         opp->u_volt_max = microvolt[2];
 807
 808         if (!of_property_read_u32(opp->np, "opp-microamp", &val))
 809                 opp->u_amp = val;
 810
 811         return 0;
 812 }
 813
 814 /**
 815  * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
 816  * @dev:        device for which we do this operation
 817  * @np:         device node
 818  *
 819  * This function adds an opp definition to the opp list and returns status. The
 820  * opp can be controlled using dev_pm_opp_enable/disable functions and may be
 821  * removed by dev_pm_opp_remove.
 822  *
 823  * Locking: The internal device_opp and opp structures are RCU protected.
 824  * Hence this function internally uses RCU updater strategy with mutex locks
 825  * to keep the integrity of the internal data structures. Callers should ensure
 826  * that this function is *NOT* called under RCU protection or in contexts where
 827  * mutex cannot be locked.
 828  *
 829  * Return:
 830  * 0            On success OR
 831  *              Duplicate OPPs (both freq and volt are same) and opp->available
 832  * -EEXIST      Freq are same and volt are different OR
 833  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 834  * -ENOMEM      Memory allocation failure
 835  * -EINVAL      Failed parsing the OPP node
 836  */
 837 static int _opp_add_static_v2(struct device *dev, struct device_node *np)
 838 {
 839         struct device_opp *dev_opp;
 840         struct dev_pm_opp *new_opp;
 841         u64 rate;
 842         u32 val;
 843         int ret;
 844
 845         /* Hold our list modification lock here */
 846         mutex_lock(&dev_opp_list_lock);
 847
 848         new_opp = _allocate_opp(dev, &dev_opp);
 849         if (!new_opp) {
 850                 ret = -ENOMEM;
 851                 goto unlock;
 852         }
 853
 854         ret = of_property_read_u64(np, "opp-hz", &rate);
 855         if (ret < 0) {
 856                 dev_err(dev, "%s: opp-hz not found\n", __func__);
 857                 goto free_opp;
 858         }
 859
 860         /*
 861          * Rate is defined as an unsigned long in clk API, and so casting
 862          * explicitly to its type. Must be fixed once rate is 64 bit
 863          * guaranteed in clk API.
 864          */
 865         new_opp->rate = (unsigned long)rate;
 866         new_opp->turbo = of_property_read_bool(np, "turbo-mode");
 867
 868         new_opp->np = np;
 869         new_opp->dynamic = false;
 870         new_opp->available = true;
 871
 872         if (!of_property_read_u32(np, "clock-latency-ns", &val))
 873                 new_opp->clock_latency_ns = val;
 874
 875         ret = opp_parse_supplies(new_opp, dev);
 876         if (ret)
 877                 goto free_opp;
 878
 879         ret = _opp_add(dev, new_opp, dev_opp);
 880         if (ret)
 881                 goto free_opp;
 882
 883         /* OPP to select on device suspend */
 884         if (of_property_read_bool(np, "opp-suspend")) {
 885                 if (dev_opp->suspend_opp)
 886                         dev_warn(dev, "%s: Multiple suspend OPPs found (%lu %lu)\n",
 887                                  __func__, dev_opp->suspend_opp->rate,
 888                                  new_opp->rate);
 889                 else
 890                         dev_opp->suspend_opp = new_opp;
 891         }
 892
 893         if (new_opp->clock_latency_ns > dev_opp->clock_latency_ns_max)
 894                 dev_opp->clock_latency_ns_max = new_opp->clock_latency_ns;
 895
 896         mutex_unlock(&dev_opp_list_lock);
 897
 898         pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
 899                  __func__, new_opp->turbo, new_opp->rate, new_opp->u_volt,
 900                  new_opp->u_volt_min, new_opp->u_volt_max,
 901                  new_opp->clock_latency_ns);
 902
 903         /*
 904          * Notify the changes in the availability of the operable
 905          * frequency/voltage list.
 906          */
 907         srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
 908         return 0;
 909
 910 free_opp:
 911         _opp_remove(dev_opp, new_opp, false);
 912 unlock:
 913         mutex_unlock(&dev_opp_list_lock);
 914         return ret;
 915 }
 916
 917 /**
 918  * dev_pm_opp_add()  - Add an OPP table from a table definitions
 919  * @dev:        device for which we do this operation
 920  * @freq:       Frequency in Hz for this OPP
 921  * @u_volt:     Voltage in uVolts for this OPP
 922  *
 923  * This function adds an opp definition to the opp list and returns status.
 924  * The opp is made available by default and it can be controlled using
 925  * dev_pm_opp_enable/disable functions.
 926  *
 927  * Locking: The internal device_opp and opp structures are RCU protected.
 928  * Hence this function internally uses RCU updater strategy with mutex locks
 929  * to keep the integrity of the internal data structures. Callers should ensure
 930  * that this function is *NOT* called under RCU protection or in contexts where
 931  * mutex cannot be locked.
 932  *
 933  * Return:
 934  * 0            On success OR
 935  *              Duplicate OPPs (both freq and volt are same) and opp->available
 936  * -EEXIST      Freq are same and volt are different OR
 937  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 938  * -ENOMEM      Memory allocation failure
 939  */
 940 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
 941 {
 942         return _opp_add_v1(dev, freq, u_volt, true);
 943 }
 944 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
 945
 946 /**
 947  * _opp_set_availability() - helper to set the availability of an opp
 948  * @dev:                device for which we do this operation
 949  * @freq:               OPP frequency to modify availability
 950  * @availability_req:   availability status requested for this opp
 951  *
 952  * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
 953  * share a common logic which is isolated here.
 954  *
 955  * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
 956  * copy operation, returns 0 if no modifcation was done OR modification was
 957  * successful.
 958  *
 959  * Locking: The internal device_opp and opp structures are RCU protected.
 960  * Hence this function internally uses RCU updater strategy with mutex locks to
 961  * keep the integrity of the internal data structures. Callers should ensure
 962  * that this function is *NOT* called under RCU protection or in contexts where
 963  * mutex locking or synchronize_rcu() blocking calls cannot be used.
 964  */
 965 static int _opp_set_availability(struct device *dev, unsigned long freq,
 966                                  bool availability_req)
 967 {
 968         struct device_opp *dev_opp;
 969         struct dev_pm_opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
 970         int r = 0;
 971
 972         /* keep the node allocated */
 973         new_opp = kmalloc(sizeof(*new_opp), GFP_KERNEL);
 974         if (!new_opp)
 975                 return -ENOMEM;
 976
 977         mutex_lock(&dev_opp_list_lock);
 978
 979         /* Find the device_opp */
 980         dev_opp = _find_device_opp(dev);
 981         if (IS_ERR(dev_opp)) {
 982                 r = PTR_ERR(dev_opp);
 983                 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
 984                 goto unlock;
 985         }
 986
 987         /* Do we have the frequency? */
 988         list_for_each_entry(tmp_opp, &dev_opp->opp_list, node) {
 989                 if (tmp_opp->rate == freq) {
 990                         opp = tmp_opp;
 991                         break;
 992                 }
 993         }
 994         if (IS_ERR(opp)) {
 995                 r = PTR_ERR(opp);
 996                 goto unlock;
 997         }
 998
 999         /* Is update really needed? */
1000         if (opp->available == availability_req)
1001                 goto unlock;
1002         /* copy the old data over */
1003         *new_opp = *opp;
1004
1005         /* plug in new node */
1006         new_opp->available = availability_req;
1007
1008         list_replace_rcu(&opp->node, &new_opp->node);
1009         mutex_unlock(&dev_opp_list_lock);
1010         call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
1011
1012         /* Notify the change of the OPP availability */
1013         if (availability_req)
1014                 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ENABLE,
1015                                          new_opp);
1016         else
1017                 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_DISABLE,
1018                                          new_opp);
1019
1020         return 0;
1021
1022 unlock:
1023         mutex_unlock(&dev_opp_list_lock);
1024         kfree(new_opp);
1025         return r;
1026 }
1027
1028 /**
1029  * dev_pm_opp_enable() - Enable a specific OPP
1030  * @dev:        device for which we do this operation
1031  * @freq:       OPP frequency to enable
1032  *
1033  * Enables a provided opp. If the operation is valid, this returns 0, else the
1034  * corresponding error value. It is meant to be used for users an OPP available
1035  * after being temporarily made unavailable with dev_pm_opp_disable.
1036  *
1037  * Locking: The internal device_opp and opp structures are RCU protected.
1038  * Hence this function indirectly uses RCU and mutex locks to keep the
1039  * integrity of the internal data structures. Callers should ensure that
1040  * this function is *NOT* called under RCU protection or in contexts where
1041  * mutex locking or synchronize_rcu() blocking calls cannot be used.
1042  *
1043  * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1044  * copy operation, returns 0 if no modifcation was done OR modification was
1045  * successful.
1046  */
1047 int dev_pm_opp_enable(struct device *dev, unsigned long freq)
1048 {
1049         return _opp_set_availability(dev, freq, true);
1050 }
1051 EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
1052
1053 /**
1054  * dev_pm_opp_disable() - Disable a specific OPP
1055  * @dev:        device for which we do this operation
1056  * @freq:       OPP frequency to disable
1057  *
1058  * Disables a provided opp. If the operation is valid, this returns
1059  * 0, else the corresponding error value. It is meant to be a temporary
1060  * control by users to make this OPP not available until the circumstances are
1061  * right to make it available again (with a call to dev_pm_opp_enable).
1062  *
1063  * Locking: The internal device_opp and opp structures are RCU protected.
1064  * Hence this function indirectly uses RCU and mutex locks to keep the
1065  * integrity of the internal data structures. Callers should ensure that
1066  * this function is *NOT* called under RCU protection or in contexts where
1067  * mutex locking or synchronize_rcu() blocking calls cannot be used.
1068  *
1069  * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1070  * copy operation, returns 0 if no modifcation was done OR modification was
1071  * successful.
1072  */
1073 int dev_pm_opp_disable(struct device *dev, unsigned long freq)
1074 {
1075         return _opp_set_availability(dev, freq, false);
1076 }
1077 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
1078
1079 /**
1080  * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
1081  * @dev:        device pointer used to lookup device OPPs.
1082  *
1083  * Return: pointer to  notifier head if found, otherwise -ENODEV or
1084  * -EINVAL based on type of error casted as pointer. value must be checked
1085  *  with IS_ERR to determine valid pointer or error result.
1086  *
1087  * Locking: This function must be called under rcu_read_lock(). dev_opp is a RCU
1088  * protected pointer. The reason for the same is that the opp pointer which is
1089  * returned will remain valid for use with opp_get_{voltage, freq} only while
1090  * under the locked area. The pointer returned must be used prior to unlocking
1091  * with rcu_read_unlock() to maintain the integrity of the pointer.
1092  */
1093 struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
1094 {
1095         struct device_opp *dev_opp = _find_device_opp(dev);
1096
1097         if (IS_ERR(dev_opp))
1098                 return ERR_CAST(dev_opp); /* matching type */
1099
1100         return &dev_opp->srcu_head;
1101 }
1102 EXPORT_SYMBOL_GPL(dev_pm_opp_get_notifier);
1103
1104 #ifdef CONFIG_OF
1105 /**
1106  * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
1107  *                                entries
1108  * @dev:        device pointer used to lookup device OPPs.
1109  *
1110  * Free OPPs created using static entries present in DT.
1111  *
1112  * Locking: The internal device_opp and opp structures are RCU protected.
1113  * Hence this function indirectly uses RCU updater strategy with mutex locks
1114  * to keep the integrity of the internal data structures. Callers should ensure
1115  * that this function is *NOT* called under RCU protection or in contexts where
1116  * mutex cannot be locked.
1117  */
1118 void dev_pm_opp_of_remove_table(struct device *dev)
1119 {
1120         struct device_opp *dev_opp;
1121         struct dev_pm_opp *opp, *tmp;
1122
1123         /* Hold our list modification lock here */
1124         mutex_lock(&dev_opp_list_lock);
1125
1126         /* Check for existing list for 'dev' */
1127         dev_opp = _find_device_opp(dev);
1128         if (IS_ERR(dev_opp)) {
1129                 int error = PTR_ERR(dev_opp);
1130
1131                 if (error != -ENODEV)
1132                         WARN(1, "%s: dev_opp: %d\n",
1133                              IS_ERR_OR_NULL(dev) ?
1134                                         "Invalid device" : dev_name(dev),
1135                              error);
1136                 goto unlock;
1137         }
1138
1139         /* Find if dev_opp manages a single device */
1140         if (list_is_singular(&dev_opp->dev_list)) {
1141                 /* Free static OPPs */
1142                 list_for_each_entry_safe(opp, tmp, &dev_opp->opp_list, node) {
1143                         if (!opp->dynamic)
1144                                 _opp_remove(dev_opp, opp, true);
1145                 }
1146         } else {
1147                 _remove_list_dev(_find_list_dev(dev, dev_opp), dev_opp);
1148         }
1149
1150 unlock:
1151         mutex_unlock(&dev_opp_list_lock);
1152 }
1153 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
1154
1155 /* Returns opp descriptor node for a device, caller must do of_node_put() */
1156 struct device_node *_of_get_opp_desc_node(struct device *dev)
1157 {
1158         /*
1159          * TODO: Support for multiple OPP tables.
1160          *
1161          * There should be only ONE phandle present in "operating-points-v2"
1162          * property.
1163          */
1164
1165         return of_parse_phandle(dev->of_node, "operating-points-v2", 0);
1166 }
1167
1168 /* Initializes OPP tables based on new bindings */
1169 static int _of_add_opp_table_v2(struct device *dev, struct device_node *opp_np)
1170 {
1171         struct device_node *np;
1172         struct device_opp *dev_opp;
1173         int ret = 0, count = 0;
1174
1175         mutex_lock(&dev_opp_list_lock);
1176
1177         dev_opp = _managed_opp(opp_np);
1178         if (dev_opp) {
1179                 /* OPPs are already managed */
1180                 if (!_add_list_dev(dev, dev_opp))
1181                         ret = -ENOMEM;
1182                 mutex_unlock(&dev_opp_list_lock);
1183                 return ret;
1184         }
1185         mutex_unlock(&dev_opp_list_lock);
1186
1187         /* We have opp-list node now, iterate over it and add OPPs */
1188         for_each_available_child_of_node(opp_np, np) {
1189                 count++;
1190
1191                 ret = _opp_add_static_v2(dev, np);
1192                 if (ret) {
1193                         dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
1194                                 ret);
1195                         goto free_table;
1196                 }
1197         }
1198
1199         /* There should be one of more OPP defined */
1200         if (WARN_ON(!count))
1201                 return -ENOENT;
1202
1203         mutex_lock(&dev_opp_list_lock);
1204
1205         dev_opp = _find_device_opp(dev);
1206         if (WARN_ON(IS_ERR(dev_opp))) {
1207                 ret = PTR_ERR(dev_opp);
1208                 mutex_unlock(&dev_opp_list_lock);
1209                 goto free_table;
1210         }
1211
1212         dev_opp->np = opp_np;
1213         dev_opp->shared_opp = of_property_read_bool(opp_np, "opp-shared");
1214
1215         mutex_unlock(&dev_opp_list_lock);
1216
1217         return 0;
1218
1219 free_table:
1220         dev_pm_opp_of_remove_table(dev);
1221
1222         return ret;
1223 }
1224
1225 /* Initializes OPP tables based on old-deprecated bindings */
1226 static int _of_add_opp_table_v1(struct device *dev)
1227 {
1228         const struct property *prop;
1229         const __be32 *val;
1230         int nr;
1231
1232         prop = of_find_property(dev->of_node, "operating-points", NULL);
1233         if (!prop)
1234                 return -ENODEV;
1235         if (!prop->value)
1236                 return -ENODATA;
1237
1238         /*
1239          * Each OPP is a set of tuples consisting of frequency and
1240          * voltage like <freq-kHz vol-uV>.
1241          */
1242         nr = prop->length / sizeof(u32);
1243         if (nr % 2) {
1244                 dev_err(dev, "%s: Invalid OPP list\n", __func__);
1245                 return -EINVAL;
1246         }
1247
1248         val = prop->value;
1249         while (nr) {
1250                 unsigned long freq = be32_to_cpup(val++) * 1000;
1251                 unsigned long volt = be32_to_cpup(val++);
1252
1253                 if (_opp_add_v1(dev, freq, volt, false))
1254                         dev_warn(dev, "%s: Failed to add OPP %ld\n",
1255                                  __func__, freq);
1256                 nr -= 2;
1257         }
1258
1259         return 0;
1260 }
1261
1262 /**
1263  * dev_pm_opp_of_add_table() - Initialize opp table from device tree
1264  * @dev:        device pointer used to lookup device OPPs.
1265  *
1266  * Register the initial OPP table with the OPP library for given device.
1267  *
1268  * Locking: The internal device_opp and opp structures are RCU protected.
1269  * Hence this function indirectly uses RCU updater strategy with mutex locks
1270  * to keep the integrity of the internal data structures. Callers should ensure
1271  * that this function is *NOT* called under RCU protection or in contexts where
1272  * mutex cannot be locked.
1273  *
1274  * Return:
1275  * 0            On success OR
1276  *              Duplicate OPPs (both freq and volt are same) and opp->available
1277  * -EEXIST      Freq are same and volt are different OR
1278  *              Duplicate OPPs (both freq and volt are same) and !opp->available
1279  * -ENOMEM      Memory allocation failure
1280  * -ENODEV      when 'operating-points' property is not found or is invalid data
1281  *              in device node.
1282  * -ENODATA     when empty 'operating-points' property is found
1283  * -EINVAL      when invalid entries are found in opp-v2 table
1284  */
1285 int dev_pm_opp_of_add_table(struct device *dev)
1286 {
1287         struct device_node *opp_np;
1288         int ret;
1289
1290         /*
1291          * OPPs have two version of bindings now. The older one is deprecated,
1292          * try for the new binding first.
1293          */
1294         opp_np = _of_get_opp_desc_node(dev);
1295         if (!opp_np) {
1296                 /*
1297                  * Try old-deprecated bindings for backward compatibility with
1298                  * older dtbs.
1299                  */
1300                 return _of_add_opp_table_v1(dev);
1301         }
1302
1303         ret = _of_add_opp_table_v2(dev, opp_np);
1304         of_node_put(opp_np);
1305
1306         return ret;
1307 }
1308 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
1309 #endif