kernel/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 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))
 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         /* Missing property isn't a problem, but an invalid entry is */
 786         if (!of_find_property(opp->np, "opp-microvolt", NULL))
 787                 return 0;
 788
 789         count = of_property_count_u32_elems(opp->np, "opp-microvolt");
 790         if (count < 0) {
 791                 dev_err(dev, "%s: Invalid opp-microvolt property (%d)\n",
 792                         __func__, count);
 793                 return count;
 794         }
 795
 796         /* There can be one or three elements here */
 797         if (count != 1 && count != 3) {
 798                 dev_err(dev, "%s: Invalid number of elements in opp-microvolt property (%d)\n",
 799                         __func__, count);
 800                 return -EINVAL;
 801         }
 802
 803         ret = of_property_read_u32_array(opp->np, "opp-microvolt", microvolt,
 804                                          count);
 805         if (ret) {
 806                 dev_err(dev, "%s: error parsing opp-microvolt: %d\n", __func__,
 807                         ret);
 808                 return -EINVAL;
 809         }
 810
 811         opp->u_volt = microvolt[0];
 812
 813         if (count == 1) {
 814                 opp->u_volt_min = opp->u_volt;
 815                 opp->u_volt_max = opp->u_volt;
 816         } else {
 817                 opp->u_volt_min = microvolt[1];
 818                 opp->u_volt_max = microvolt[2];
 819         }
 820
 821         if (!of_property_read_u32(opp->np, "opp-microamp", &val))
 822                 opp->u_amp = val;
 823
 824         return 0;
 825 }
 826
 827 /**
 828  * _opp_add_static_v2() - Allocate static OPPs (As per 'v2' DT bindings)
 829  * @dev:        device for which we do this operation
 830  * @np:         device node
 831  *
 832  * This function adds an opp definition to the opp list and returns status. The
 833  * opp can be controlled using dev_pm_opp_enable/disable functions and may be
 834  * removed by dev_pm_opp_remove.
 835  *
 836  * Locking: The internal device_opp and opp structures are RCU protected.
 837  * Hence this function internally uses RCU updater strategy with mutex locks
 838  * to keep the integrity of the internal data structures. Callers should ensure
 839  * that this function is *NOT* called under RCU protection or in contexts where
 840  * mutex cannot be locked.
 841  *
 842  * Return:
 843  * 0            On success OR
 844  *              Duplicate OPPs (both freq and volt are same) and opp->available
 845  * -EEXIST      Freq are same and volt are different OR
 846  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 847  * -ENOMEM      Memory allocation failure
 848  * -EINVAL      Failed parsing the OPP node
 849  */
 850 static int _opp_add_static_v2(struct device *dev, struct device_node *np)
 851 {
 852         struct device_opp *dev_opp;
 853         struct dev_pm_opp *new_opp;
 854         u64 rate;
 855         u32 val;
 856         int ret;
 857
 858         /* Hold our list modification lock here */
 859         mutex_lock(&dev_opp_list_lock);
 860
 861         new_opp = _allocate_opp(dev, &dev_opp);
 862         if (!new_opp) {
 863                 ret = -ENOMEM;
 864                 goto unlock;
 865         }
 866
 867         ret = of_property_read_u64(np, "opp-hz", &rate);
 868         if (ret < 0) {
 869                 dev_err(dev, "%s: opp-hz not found\n", __func__);
 870                 goto free_opp;
 871         }
 872
 873         /*
 874          * Rate is defined as an unsigned long in clk API, and so casting
 875          * explicitly to its type. Must be fixed once rate is 64 bit
 876          * guaranteed in clk API.
 877          */
 878         new_opp->rate = (unsigned long)rate;
 879         new_opp->turbo = of_property_read_bool(np, "turbo-mode");
 880
 881         new_opp->np = np;
 882         new_opp->dynamic = false;
 883         new_opp->available = true;
 884
 885         if (!of_property_read_u32(np, "clock-latency-ns", &val))
 886                 new_opp->clock_latency_ns = val;
 887
 888         ret = opp_parse_supplies(new_opp, dev);
 889         if (ret)
 890                 goto free_opp;
 891
 892         ret = _opp_add(dev, new_opp, dev_opp);
 893         if (ret)
 894                 goto free_opp;
 895
 896         /* OPP to select on device suspend */
 897         if (of_property_read_bool(np, "opp-suspend")) {
 898                 if (dev_opp->suspend_opp)
 899                         dev_warn(dev, "%s: Multiple suspend OPPs found (%lu %lu)\n",
 900                                  __func__, dev_opp->suspend_opp->rate,
 901                                  new_opp->rate);
 902                 else
 903                         dev_opp->suspend_opp = new_opp;
 904         }
 905
 906         if (new_opp->clock_latency_ns > dev_opp->clock_latency_ns_max)
 907                 dev_opp->clock_latency_ns_max = new_opp->clock_latency_ns;
 908
 909         mutex_unlock(&dev_opp_list_lock);
 910
 911         pr_debug("%s: turbo:%d rate:%lu uv:%lu uvmin:%lu uvmax:%lu latency:%lu\n",
 912                  __func__, new_opp->turbo, new_opp->rate, new_opp->u_volt,
 913                  new_opp->u_volt_min, new_opp->u_volt_max,
 914                  new_opp->clock_latency_ns);
 915
 916         /*
 917          * Notify the changes in the availability of the operable
 918          * frequency/voltage list.
 919          */
 920         srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
 921         return 0;
 922
 923 free_opp:
 924         _opp_remove(dev_opp, new_opp, false);
 925 unlock:
 926         mutex_unlock(&dev_opp_list_lock);
 927         return ret;
 928 }
 929
 930 /**
 931  * dev_pm_opp_add()  - Add an OPP table from a table definitions
 932  * @dev:        device for which we do this operation
 933  * @freq:       Frequency in Hz for this OPP
 934  * @u_volt:     Voltage in uVolts for this OPP
 935  *
 936  * This function adds an opp definition to the opp list and returns status.
 937  * The opp is made available by default and it can be controlled using
 938  * dev_pm_opp_enable/disable functions.
 939  *
 940  * Locking: The internal device_opp and opp structures are RCU protected.
 941  * Hence this function internally uses RCU updater strategy with mutex locks
 942  * to keep the integrity of the internal data structures. Callers should ensure
 943  * that this function is *NOT* called under RCU protection or in contexts where
 944  * mutex cannot be locked.
 945  *
 946  * Return:
 947  * 0            On success OR
 948  *              Duplicate OPPs (both freq and volt are same) and opp->available
 949  * -EEXIST      Freq are same and volt are different OR
 950  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 951  * -ENOMEM      Memory allocation failure
 952  */
 953 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
 954 {
 955         return _opp_add_v1(dev, freq, u_volt, true);
 956 }
 957 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
 958
 959 /**
 960  * _opp_set_availability() - helper to set the availability of an opp
 961  * @dev:                device for which we do this operation
 962  * @freq:               OPP frequency to modify availability
 963  * @availability_req:   availability status requested for this opp
 964  *
 965  * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
 966  * share a common logic which is isolated here.
 967  *
 968  * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
 969  * copy operation, returns 0 if no modification was done OR modification was
 970  * successful.
 971  *
 972  * Locking: The internal device_opp and opp structures are RCU protected.
 973  * Hence this function internally uses RCU updater strategy with mutex locks to
 974  * keep the integrity of the internal data structures. Callers should ensure
 975  * that this function is *NOT* called under RCU protection or in contexts where
 976  * mutex locking or synchronize_rcu() blocking calls cannot be used.
 977  */
 978 static int _opp_set_availability(struct device *dev, unsigned long freq,
 979                                  bool availability_req)
 980 {
 981         struct device_opp *dev_opp;
 982         struct dev_pm_opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
 983         int r = 0;
 984
 985         /* keep the node allocated */
 986         new_opp = kmalloc(sizeof(*new_opp), GFP_KERNEL);
 987         if (!new_opp)
 988                 return -ENOMEM;
 989
 990         mutex_lock(&dev_opp_list_lock);
 991
 992         /* Find the device_opp */
 993         dev_opp = _find_device_opp(dev);
 994         if (IS_ERR(dev_opp)) {
 995                 r = PTR_ERR(dev_opp);
 996                 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
 997                 goto unlock;
 998         }
 999
1000         /* Do we have the frequency? */
1001         list_for_each_entry(tmp_opp, &dev_opp->opp_list, node) {
1002                 if (tmp_opp->rate == freq) {
1003                         opp = tmp_opp;
1004                         break;
1005                 }
1006         }
1007         if (IS_ERR(opp)) {
1008                 r = PTR_ERR(opp);
1009                 goto unlock;
1010         }
1011
1012         /* Is update really needed? */
1013         if (opp->available == availability_req)
1014                 goto unlock;
1015         /* copy the old data over */
1016         *new_opp = *opp;
1017
1018         /* plug in new node */
1019         new_opp->available = availability_req;
1020
1021         list_replace_rcu(&opp->node, &new_opp->node);
1022         mutex_unlock(&dev_opp_list_lock);
1023         call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, _kfree_opp_rcu);
1024
1025         /* Notify the change of the OPP availability */
1026         if (availability_req)
1027                 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ENABLE,
1028                                          new_opp);
1029         else
1030                 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_DISABLE,
1031                                          new_opp);
1032
1033         return 0;
1034
1035 unlock:
1036         mutex_unlock(&dev_opp_list_lock);
1037         kfree(new_opp);
1038         return r;
1039 }
1040
1041 /**
1042  * dev_pm_opp_enable() - Enable a specific OPP
1043  * @dev:        device for which we do this operation
1044  * @freq:       OPP frequency to enable
1045  *
1046  * Enables a provided opp. If the operation is valid, this returns 0, else the
1047  * corresponding error value. It is meant to be used for users an OPP available
1048  * after being temporarily made unavailable with dev_pm_opp_disable.
1049  *
1050  * Locking: The internal device_opp and opp structures are RCU protected.
1051  * Hence this function indirectly uses RCU and mutex locks to keep the
1052  * integrity of the internal data structures. Callers should ensure that
1053  * this function is *NOT* called under RCU protection or in contexts where
1054  * mutex locking or synchronize_rcu() blocking calls cannot be used.
1055  *
1056  * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1057  * copy operation, returns 0 if no modification was done OR modification was
1058  * successful.
1059  */
1060 int dev_pm_opp_enable(struct device *dev, unsigned long freq)
1061 {
1062         return _opp_set_availability(dev, freq, true);
1063 }
1064 EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
1065
1066 /**
1067  * dev_pm_opp_disable() - Disable a specific OPP
1068  * @dev:        device for which we do this operation
1069  * @freq:       OPP frequency to disable
1070  *
1071  * Disables a provided opp. If the operation is valid, this returns
1072  * 0, else the corresponding error value. It is meant to be a temporary
1073  * control by users to make this OPP not available until the circumstances are
1074  * right to make it available again (with a call to dev_pm_opp_enable).
1075  *
1076  * Locking: The internal device_opp and opp structures are RCU protected.
1077  * Hence this function indirectly uses RCU and mutex locks to keep the
1078  * integrity of the internal data structures. Callers should ensure that
1079  * this function is *NOT* called under RCU protection or in contexts where
1080  * mutex locking or synchronize_rcu() blocking calls cannot be used.
1081  *
1082  * Return: -EINVAL for bad pointers, -ENOMEM if no memory available for the
1083  * copy operation, returns 0 if no modification was done OR modification was
1084  * successful.
1085  */
1086 int dev_pm_opp_disable(struct device *dev, unsigned long freq)
1087 {
1088         return _opp_set_availability(dev, freq, false);
1089 }
1090 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
1091
1092 /**
1093  * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
1094  * @dev:        device pointer used to lookup device OPPs.
1095  *
1096  * Return: pointer to  notifier head if found, otherwise -ENODEV or
1097  * -EINVAL based on type of error casted as pointer. value must be checked
1098  *  with IS_ERR to determine valid pointer or error result.
1099  *
1100  * Locking: This function must be called under rcu_read_lock(). dev_opp is a RCU
1101  * protected pointer. The reason for the same is that the opp pointer which is
1102  * returned will remain valid for use with opp_get_{voltage, freq} only while
1103  * under the locked area. The pointer returned must be used prior to unlocking
1104  * with rcu_read_unlock() to maintain the integrity of the pointer.
1105  */
1106 struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
1107 {
1108         struct device_opp *dev_opp = _find_device_opp(dev);
1109
1110         if (IS_ERR(dev_opp))
1111                 return ERR_CAST(dev_opp); /* matching type */
1112
1113         return &dev_opp->srcu_head;
1114 }
1115 EXPORT_SYMBOL_GPL(dev_pm_opp_get_notifier);
1116
1117 #ifdef CONFIG_OF
1118 /**
1119  * dev_pm_opp_of_remove_table() - Free OPP table entries created from static DT
1120  *                                entries
1121  * @dev:        device pointer used to lookup device OPPs.
1122  *
1123  * Free OPPs created using static entries present in DT.
1124  *
1125  * Locking: The internal device_opp and opp structures are RCU protected.
1126  * Hence this function indirectly uses RCU updater strategy with mutex locks
1127  * to keep the integrity of the internal data structures. Callers should ensure
1128  * that this function is *NOT* called under RCU protection or in contexts where
1129  * mutex cannot be locked.
1130  */
1131 void dev_pm_opp_of_remove_table(struct device *dev)
1132 {
1133         struct device_opp *dev_opp;
1134         struct dev_pm_opp *opp, *tmp;
1135
1136         /* Hold our list modification lock here */
1137         mutex_lock(&dev_opp_list_lock);
1138
1139         /* Check for existing list for 'dev' */
1140         dev_opp = _find_device_opp(dev);
1141         if (IS_ERR(dev_opp)) {
1142                 int error = PTR_ERR(dev_opp);
1143
1144                 if (error != -ENODEV)
1145                         WARN(1, "%s: dev_opp: %d\n",
1146                              IS_ERR_OR_NULL(dev) ?
1147                                         "Invalid device" : dev_name(dev),
1148                              error);
1149                 goto unlock;
1150         }
1151
1152         /* Find if dev_opp manages a single device */
1153         if (list_is_singular(&dev_opp->dev_list)) {
1154                 /* Free static OPPs */
1155                 list_for_each_entry_safe(opp, tmp, &dev_opp->opp_list, node) {
1156                         if (!opp->dynamic)
1157                                 _opp_remove(dev_opp, opp, true);
1158                 }
1159         } else {
1160                 _remove_list_dev(_find_list_dev(dev, dev_opp), dev_opp);
1161         }
1162
1163 unlock:
1164         mutex_unlock(&dev_opp_list_lock);
1165 }
1166 EXPORT_SYMBOL_GPL(dev_pm_opp_of_remove_table);
1167
1168 /* Returns opp descriptor node for a device, caller must do of_node_put() */
1169 struct device_node *_of_get_opp_desc_node(struct device *dev)
1170 {
1171         /*
1172          * TODO: Support for multiple OPP tables.
1173          *
1174          * There should be only ONE phandle present in "operating-points-v2"
1175          * property.
1176          */
1177
1178         return of_parse_phandle(dev->of_node, "operating-points-v2", 0);
1179 }
1180
1181 /* Initializes OPP tables based on new bindings */
1182 static int _of_add_opp_table_v2(struct device *dev, struct device_node *opp_np)
1183 {
1184         struct device_node *np;
1185         struct device_opp *dev_opp;
1186         int ret = 0, count = 0;
1187
1188         mutex_lock(&dev_opp_list_lock);
1189
1190         dev_opp = _managed_opp(opp_np);
1191         if (dev_opp) {
1192                 /* OPPs are already managed */
1193                 if (!_add_list_dev(dev, dev_opp))
1194                         ret = -ENOMEM;
1195                 mutex_unlock(&dev_opp_list_lock);
1196                 return ret;
1197         }
1198         mutex_unlock(&dev_opp_list_lock);
1199
1200         /* We have opp-list node now, iterate over it and add OPPs */
1201         for_each_available_child_of_node(opp_np, np) {
1202                 count++;
1203
1204                 ret = _opp_add_static_v2(dev, np);
1205                 if (ret) {
1206                         dev_err(dev, "%s: Failed to add OPP, %d\n", __func__,
1207                                 ret);
1208                         goto free_table;
1209                 }
1210         }
1211
1212         /* There should be one of more OPP defined */
1213         if (WARN_ON(!count))
1214                 return -ENOENT;
1215
1216         mutex_lock(&dev_opp_list_lock);
1217
1218         dev_opp = _find_device_opp(dev);
1219         if (WARN_ON(IS_ERR(dev_opp))) {
1220                 ret = PTR_ERR(dev_opp);
1221                 mutex_unlock(&dev_opp_list_lock);
1222                 goto free_table;
1223         }
1224
1225         dev_opp->np = opp_np;
1226         dev_opp->shared_opp = of_property_read_bool(opp_np, "opp-shared");
1227
1228         mutex_unlock(&dev_opp_list_lock);
1229
1230         return 0;
1231
1232 free_table:
1233         dev_pm_opp_of_remove_table(dev);
1234
1235         return ret;
1236 }
1237
1238 /* Initializes OPP tables based on old-deprecated bindings */
1239 static int _of_add_opp_table_v1(struct device *dev)
1240 {
1241         const struct property *prop;
1242         const __be32 *val;
1243         int nr;
1244
1245         prop = of_find_property(dev->of_node, "operating-points", NULL);
1246         if (!prop)
1247                 return -ENODEV;
1248         if (!prop->value)
1249                 return -ENODATA;
1250
1251         /*
1252          * Each OPP is a set of tuples consisting of frequency and
1253          * voltage like <freq-kHz vol-uV>.
1254          */
1255         nr = prop->length / sizeof(u32);
1256         if (nr % 2) {
1257                 dev_err(dev, "%s: Invalid OPP list\n", __func__);
1258                 return -EINVAL;
1259         }
1260
1261         val = prop->value;
1262         while (nr) {
1263                 unsigned long freq = be32_to_cpup(val++) * 1000;
1264                 unsigned long volt = be32_to_cpup(val++);
1265
1266                 if (_opp_add_v1(dev, freq, volt, false))
1267                         dev_warn(dev, "%s: Failed to add OPP %ld\n",
1268                                  __func__, freq);
1269                 nr -= 2;
1270         }
1271
1272         return 0;
1273 }
1274
1275 /**
1276  * dev_pm_opp_of_add_table() - Initialize opp table from device tree
1277  * @dev:        device pointer used to lookup device OPPs.
1278  *
1279  * Register the initial OPP table with the OPP library for given device.
1280  *
1281  * Locking: The internal device_opp and opp structures are RCU protected.
1282  * Hence this function indirectly uses RCU updater strategy with mutex locks
1283  * to keep the integrity of the internal data structures. Callers should ensure
1284  * that this function is *NOT* called under RCU protection or in contexts where
1285  * mutex cannot be locked.
1286  *
1287  * Return:
1288  * 0            On success OR
1289  *              Duplicate OPPs (both freq and volt are same) and opp->available
1290  * -EEXIST      Freq are same and volt are different OR
1291  *              Duplicate OPPs (both freq and volt are same) and !opp->available
1292  * -ENOMEM      Memory allocation failure
1293  * -ENODEV      when 'operating-points' property is not found or is invalid data
1294  *              in device node.
1295  * -ENODATA     when empty 'operating-points' property is found
1296  * -EINVAL      when invalid entries are found in opp-v2 table
1297  */
1298 int dev_pm_opp_of_add_table(struct device *dev)
1299 {
1300         struct device_node *opp_np;
1301         int ret;
1302
1303         /*
1304          * OPPs have two version of bindings now. The older one is deprecated,
1305          * try for the new binding first.
1306          */
1307         opp_np = _of_get_opp_desc_node(dev);
1308         if (!opp_np) {
1309                 /*
1310                  * Try old-deprecated bindings for backward compatibility with
1311                  * older dtbs.
1312                  */
1313                 return _of_add_opp_table_v1(dev);
1314         }
1315
1316         ret = _of_add_opp_table_v2(dev, opp_np);
1317         of_node_put(opp_np);
1318
1319         return ret;
1320 }
1321 EXPORT_SYMBOL_GPL(dev_pm_opp_of_add_table);
1322 #endif