drivers/base/power/opp.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 #include <linux/kernel.h>
  15 #include <linux/errno.h>
  16 #include <linux/err.h>
  17 #include <linux/slab.h>
  18 #include <linux/device.h>
  19 #include <linux/list.h>
  20 #include <linux/rculist.h>
  21 #include <linux/rcupdate.h>
  22 #include <linux/pm_opp.h>
  23 #include <linux/of.h>
  24 #include <linux/export.h>
  25
  26 /*
  27  * Internal data structure organization with the OPP layer library is as
  28  * follows:
  29  * dev_opp_list (root)
  30  *      |- device 1 (represents voltage domain 1)
  31  *      |       |- opp 1 (availability, freq, voltage)
  32  *      |       |- opp 2 ..
  33  *      ...     ...
  34  *      |       `- opp n ..
  35  *      |- device 2 (represents the next voltage domain)
  36  *      ...
  37  *      `- device m (represents mth voltage domain)
  38  * device 1, 2.. are represented by dev_opp structure while each opp
  39  * is represented by the opp structure.
  40  */
  41
  42 /**
  43  * struct dev_pm_opp - Generic OPP description structure
  44  * @node:       opp list node. The nodes are maintained throughout the lifetime
  45  *              of boot. It is expected only an optimal set of OPPs are
  46  *              added to the library by the SoC framework.
  47  *              RCU usage: opp list is traversed with RCU locks. node
  48  *              modification is possible realtime, hence the modifications
  49  *              are protected by the dev_opp_list_lock for integrity.
  50  *              IMPORTANT: the opp nodes should be maintained in increasing
  51  *              order.
  52  * @dynamic:    not-created from static DT entries.
  53  * @available:  true/false - marks if this OPP as available or not
  54  * @rate:       Frequency in hertz
  55  * @u_volt:     Nominal voltage in microvolts corresponding to this OPP
  56  * @dev_opp:    points back to the device_opp struct this opp belongs to
  57  * @rcu_head:   RCU callback head used for deferred freeing
  58  *
  59  * This structure stores the OPP information for a given device.
  60  */
  61 struct dev_pm_opp {
  62         struct list_head node;
  63
  64         bool available;
  65         bool dynamic;
  66         unsigned long rate;
  67         unsigned long u_volt;
  68
  69         struct device_opp *dev_opp;
  70         struct rcu_head rcu_head;
  71 };
  72
  73 /**
  74  * struct device_opp - Device opp structure
  75  * @node:       list node - contains the devices with OPPs that
  76  *              have been registered. Nodes once added are not modified in this
  77  *              list.
  78  *              RCU usage: nodes are not modified in the list of device_opp,
  79  *              however addition is possible and is secured by dev_opp_list_lock
  80  * @dev:        device pointer
  81  * @srcu_head:  notifier head to notify the OPP availability changes.
  82  * @rcu_head:   RCU callback head used for deferred freeing
  83  * @opp_list:   list of opps
  84  *
  85  * This is an internal data structure maintaining the link to opps attached to
  86  * a device. This structure is not meant to be shared to users as it is
  87  * meant for book keeping and private to OPP library.
  88  *
  89  * Because the opp structures can be used from both rcu and srcu readers, we
  90  * need to wait for the grace period of both of them before freeing any
  91  * resources. And so we have used kfree_rcu() from within call_srcu() handlers.
  92  */
  93 struct device_opp {
  94         struct list_head node;
  95
  96         struct device *dev;
  97         struct srcu_notifier_head srcu_head;
  98         struct rcu_head rcu_head;
  99         struct list_head opp_list;
 100 };
 101
 102 /*
 103  * The root of the list of all devices. All device_opp structures branch off
 104  * from here, with each device_opp containing the list of opp it supports in
 105  * various states of availability.
 106  */
 107 static LIST_HEAD(dev_opp_list);
 108 /* Lock to allow exclusive modification to the device and opp lists */
 109 static DEFINE_MUTEX(dev_opp_list_lock);
 110
 111 /**
 112  * find_device_opp() - find device_opp struct using device pointer
 113  * @dev:        device pointer used to lookup device OPPs
 114  *
 115  * Search list of device OPPs for one containing matching device. Does a RCU
 116  * reader operation to grab the pointer needed.
 117  *
 118  * Returns pointer to 'struct device_opp' if found, otherwise -ENODEV or
 119  * -EINVAL based on type of error.
 120  *
 121  * Locking: This function must be called under rcu_read_lock(). device_opp
 122  * is a RCU protected pointer. This means that device_opp is valid as long
 123  * as we are under RCU lock.
 124  */
 125 static struct device_opp *find_device_opp(struct device *dev)
 126 {
 127         struct device_opp *tmp_dev_opp, *dev_opp = ERR_PTR(-ENODEV);
 128
 129         if (unlikely(IS_ERR_OR_NULL(dev))) {
 130                 pr_err("%s: Invalid parameters\n", __func__);
 131                 return ERR_PTR(-EINVAL);
 132         }
 133
 134         list_for_each_entry_rcu(tmp_dev_opp, &dev_opp_list, node) {
 135                 if (tmp_dev_opp->dev == dev) {
 136                         dev_opp = tmp_dev_opp;
 137                         break;
 138                 }
 139         }
 140
 141         return dev_opp;
 142 }
 143
 144 /**
 145  * dev_pm_opp_get_voltage() - Gets the voltage corresponding to an available opp
 146  * @opp:        opp for which voltage has to be returned for
 147  *
 148  * Return voltage in micro volt corresponding to the opp, else
 149  * return 0
 150  *
 151  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 152  * protected pointer. This means that opp which could have been fetched by
 153  * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
 154  * under RCU lock. The pointer returned by the opp_find_freq family must be
 155  * used in the same section as the usage of this function with the pointer
 156  * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
 157  * pointer.
 158  */
 159 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
 160 {
 161         struct dev_pm_opp *tmp_opp;
 162         unsigned long v = 0;
 163
 164         tmp_opp = rcu_dereference(opp);
 165         if (unlikely(IS_ERR_OR_NULL(tmp_opp)) || !tmp_opp->available)
 166                 pr_err("%s: Invalid parameters\n", __func__);
 167         else
 168                 v = tmp_opp->u_volt;
 169
 170         return v;
 171 }
 172 EXPORT_SYMBOL_GPL(dev_pm_opp_get_voltage);
 173
 174 /**
 175  * dev_pm_opp_get_freq() - Gets the frequency corresponding to an available opp
 176  * @opp:        opp for which frequency has to be returned for
 177  *
 178  * Return frequency in hertz corresponding to the opp, else
 179  * return 0
 180  *
 181  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 182  * protected pointer. This means that opp which could have been fetched by
 183  * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
 184  * under RCU lock. The pointer returned by the opp_find_freq family must be
 185  * used in the same section as the usage of this function with the pointer
 186  * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
 187  * pointer.
 188  */
 189 unsigned long dev_pm_opp_get_freq(struct dev_pm_opp *opp)
 190 {
 191         struct dev_pm_opp *tmp_opp;
 192         unsigned long f = 0;
 193
 194         tmp_opp = rcu_dereference(opp);
 195         if (unlikely(IS_ERR_OR_NULL(tmp_opp)) || !tmp_opp->available)
 196                 pr_err("%s: Invalid parameters\n", __func__);
 197         else
 198                 f = tmp_opp->rate;
 199
 200         return f;
 201 }
 202 EXPORT_SYMBOL_GPL(dev_pm_opp_get_freq);
 203
 204 /**
 205  * dev_pm_opp_get_opp_count() - Get number of opps available in the opp list
 206  * @dev:        device for which we do this operation
 207  *
 208  * This function returns the number of available opps if there are any,
 209  * else returns 0 if none or the corresponding error value.
 210  *
 211  * Locking: This function must be called under rcu_read_lock(). This function
 212  * internally references two RCU protected structures: device_opp and opp which
 213  * are safe as long as we are under a common RCU locked section.
 214  */
 215 int dev_pm_opp_get_opp_count(struct device *dev)
 216 {
 217         struct device_opp *dev_opp;
 218         struct dev_pm_opp *temp_opp;
 219         int count = 0;
 220
 221         dev_opp = find_device_opp(dev);
 222         if (IS_ERR(dev_opp)) {
 223                 int r = PTR_ERR(dev_opp);
 224                 dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r);
 225                 return r;
 226         }
 227
 228         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
 229                 if (temp_opp->available)
 230                         count++;
 231         }
 232
 233         return count;
 234 }
 235 EXPORT_SYMBOL_GPL(dev_pm_opp_get_opp_count);
 236
 237 /**
 238  * dev_pm_opp_find_freq_exact() - search for an exact frequency
 239  * @dev:                device for which we do this operation
 240  * @freq:               frequency to search for
 241  * @available:          true/false - match for available opp
 242  *
 243  * Searches for exact match in the opp list and returns pointer to the matching
 244  * opp if found, else returns ERR_PTR in case of error and should be handled
 245  * using IS_ERR. Error return values can be:
 246  * EINVAL:      for bad pointer
 247  * ERANGE:      no match found for search
 248  * ENODEV:      if device not found in list of registered devices
 249  *
 250  * Note: available is a modifier for the search. if available=true, then the
 251  * match is for exact matching frequency and is available in the stored OPP
 252  * table. if false, the match is for exact frequency which is not available.
 253  *
 254  * This provides a mechanism to enable an opp which is not available currently
 255  * or the opposite as well.
 256  *
 257  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 258  * protected pointer. The reason for the same is that the opp pointer which is
 259  * returned will remain valid for use with opp_get_{voltage, freq} only while
 260  * under the locked area. The pointer returned must be used prior to unlocking
 261  * with rcu_read_unlock() to maintain the integrity of the pointer.
 262  */
 263 struct dev_pm_opp *dev_pm_opp_find_freq_exact(struct device *dev,
 264                                               unsigned long freq,
 265                                               bool available)
 266 {
 267         struct device_opp *dev_opp;
 268         struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 269
 270         dev_opp = find_device_opp(dev);
 271         if (IS_ERR(dev_opp)) {
 272                 int r = PTR_ERR(dev_opp);
 273                 dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r);
 274                 return ERR_PTR(r);
 275         }
 276
 277         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
 278                 if (temp_opp->available == available &&
 279                                 temp_opp->rate == freq) {
 280                         opp = temp_opp;
 281                         break;
 282                 }
 283         }
 284
 285         return opp;
 286 }
 287 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_exact);
 288
 289 /**
 290  * dev_pm_opp_find_freq_ceil() - Search for an rounded ceil freq
 291  * @dev:        device for which we do this operation
 292  * @freq:       Start frequency
 293  *
 294  * Search for the matching ceil *available* OPP from a starting freq
 295  * for a device.
 296  *
 297  * Returns matching *opp and refreshes *freq accordingly, else returns
 298  * ERR_PTR in case of error and should be handled using IS_ERR. Error return
 299  * values can be:
 300  * EINVAL:      for bad pointer
 301  * ERANGE:      no match found for search
 302  * ENODEV:      if device not found in list of registered devices
 303  *
 304  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 305  * protected pointer. The reason for the same is that the opp pointer which is
 306  * returned will remain valid for use with opp_get_{voltage, freq} only while
 307  * under the locked area. The pointer returned must be used prior to unlocking
 308  * with rcu_read_unlock() to maintain the integrity of the pointer.
 309  */
 310 struct dev_pm_opp *dev_pm_opp_find_freq_ceil(struct device *dev,
 311                                              unsigned long *freq)
 312 {
 313         struct device_opp *dev_opp;
 314         struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 315
 316         if (!dev || !freq) {
 317                 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
 318                 return ERR_PTR(-EINVAL);
 319         }
 320
 321         dev_opp = find_device_opp(dev);
 322         if (IS_ERR(dev_opp))
 323                 return ERR_CAST(dev_opp);
 324
 325         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
 326                 if (temp_opp->available && temp_opp->rate >= *freq) {
 327                         opp = temp_opp;
 328                         *freq = opp->rate;
 329                         break;
 330                 }
 331         }
 332
 333         return opp;
 334 }
 335 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_ceil);
 336
 337 /**
 338  * dev_pm_opp_find_freq_floor() - Search for a rounded floor freq
 339  * @dev:        device for which we do this operation
 340  * @freq:       Start frequency
 341  *
 342  * Search for the matching floor *available* OPP from a starting freq
 343  * for a device.
 344  *
 345  * Returns matching *opp and refreshes *freq accordingly, else returns
 346  * ERR_PTR in case of error and should be handled using IS_ERR. Error return
 347  * values can be:
 348  * EINVAL:      for bad pointer
 349  * ERANGE:      no match found for search
 350  * ENODEV:      if device not found in list of registered devices
 351  *
 352  * Locking: This function must be called under rcu_read_lock(). opp is a rcu
 353  * protected pointer. The reason for the same is that the opp pointer which is
 354  * returned will remain valid for use with opp_get_{voltage, freq} only while
 355  * under the locked area. The pointer returned must be used prior to unlocking
 356  * with rcu_read_unlock() to maintain the integrity of the pointer.
 357  */
 358 struct dev_pm_opp *dev_pm_opp_find_freq_floor(struct device *dev,
 359                                               unsigned long *freq)
 360 {
 361         struct device_opp *dev_opp;
 362         struct dev_pm_opp *temp_opp, *opp = ERR_PTR(-ERANGE);
 363
 364         if (!dev || !freq) {
 365                 dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
 366                 return ERR_PTR(-EINVAL);
 367         }
 368
 369         dev_opp = find_device_opp(dev);
 370         if (IS_ERR(dev_opp))
 371                 return ERR_CAST(dev_opp);
 372
 373         list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
 374                 if (temp_opp->available) {
 375                         /* go to the next node, before choosing prev */
 376                         if (temp_opp->rate > *freq)
 377                                 break;
 378                         else
 379                                 opp = temp_opp;
 380                 }
 381         }
 382         if (!IS_ERR(opp))
 383                 *freq = opp->rate;
 384
 385         return opp;
 386 }
 387 EXPORT_SYMBOL_GPL(dev_pm_opp_find_freq_floor);
 388
 389 static struct device_opp *add_device_opp(struct device *dev)
 390 {
 391         struct device_opp *dev_opp;
 392
 393         /*
 394          * Allocate a new device OPP table. In the infrequent case where a new
 395          * device is needed to be added, we pay this penalty.
 396          */
 397         dev_opp = kzalloc(sizeof(*dev_opp), GFP_KERNEL);
 398         if (!dev_opp)
 399                 return NULL;
 400
 401         dev_opp->dev = dev;
 402         srcu_init_notifier_head(&dev_opp->srcu_head);
 403         INIT_LIST_HEAD(&dev_opp->opp_list);
 404
 405         /* Secure the device list modification */
 406         list_add_rcu(&dev_opp->node, &dev_opp_list);
 407         return dev_opp;
 408 }
 409
 410 static int dev_pm_opp_add_dynamic(struct device *dev, unsigned long freq,
 411                                   unsigned long u_volt, bool dynamic)
 412 {
 413         struct device_opp *dev_opp = NULL;
 414         struct dev_pm_opp *opp, *new_opp;
 415         struct list_head *head;
 416         int ret;
 417
 418         /* allocate new OPP node */
 419         new_opp = kzalloc(sizeof(*new_opp), GFP_KERNEL);
 420         if (!new_opp) {
 421                 dev_warn(dev, "%s: Unable to create new OPP node\n", __func__);
 422                 return -ENOMEM;
 423         }
 424
 425         /* Hold our list modification lock here */
 426         mutex_lock(&dev_opp_list_lock);
 427
 428         /* populate the opp table */
 429         new_opp->rate = freq;
 430         new_opp->u_volt = u_volt;
 431         new_opp->available = true;
 432         new_opp->dynamic = dynamic;
 433
 434         /* Check for existing list for 'dev' */
 435         dev_opp = find_device_opp(dev);
 436         if (IS_ERR(dev_opp)) {
 437                 dev_opp = add_device_opp(dev);
 438                 if (!dev_opp) {
 439                         ret = -ENOMEM;
 440                         goto free_opp;
 441                 }
 442
 443                 head = &dev_opp->opp_list;
 444                 goto list_add;
 445         }
 446
 447         /*
 448          * Insert new OPP in order of increasing frequency
 449          * and discard if already present
 450          */
 451         head = &dev_opp->opp_list;
 452         list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
 453                 if (new_opp->rate <= opp->rate)
 454                         break;
 455                 else
 456                         head = &opp->node;
 457         }
 458
 459         /* Duplicate OPPs ? */
 460         if (new_opp->rate == opp->rate) {
 461                 ret = opp->available && new_opp->u_volt == opp->u_volt ?
 462                         0 : -EEXIST;
 463
 464                 dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
 465                          __func__, opp->rate, opp->u_volt, opp->available,
 466                          new_opp->rate, new_opp->u_volt, new_opp->available);
 467                 goto free_opp;
 468         }
 469
 470 list_add:
 471         new_opp->dev_opp = dev_opp;
 472         list_add_rcu(&new_opp->node, head);
 473         mutex_unlock(&dev_opp_list_lock);
 474
 475         /*
 476          * Notify the changes in the availability of the operable
 477          * frequency/voltage list.
 478          */
 479         srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ADD, new_opp);
 480         return 0;
 481
 482 free_opp:
 483         mutex_unlock(&dev_opp_list_lock);
 484         kfree(new_opp);
 485         return ret;
 486 }
 487
 488 /**
 489  * dev_pm_opp_add()  - Add an OPP table from a table definitions
 490  * @dev:        device for which we do this operation
 491  * @freq:       Frequency in Hz for this OPP
 492  * @u_volt:     Voltage in uVolts for this OPP
 493  *
 494  * This function adds an opp definition to the opp list and returns status.
 495  * The opp is made available by default and it can be controlled using
 496  * dev_pm_opp_enable/disable functions.
 497  *
 498  * Locking: The internal device_opp and opp structures are RCU protected.
 499  * Hence this function internally uses RCU updater strategy with mutex locks
 500  * to keep the integrity of the internal data structures. Callers should ensure
 501  * that this function is *NOT* called under RCU protection or in contexts where
 502  * mutex cannot be locked.
 503  *
 504  * Return:
 505  * 0:           On success OR
 506  *              Duplicate OPPs (both freq and volt are same) and opp->available
 507  * -EEXIST:     Freq are same and volt are different OR
 508  *              Duplicate OPPs (both freq and volt are same) and !opp->available
 509  * -ENOMEM:     Memory allocation failure
 510  */
 511 int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
 512 {
 513         return dev_pm_opp_add_dynamic(dev, freq, u_volt, true);
 514 }
 515 EXPORT_SYMBOL_GPL(dev_pm_opp_add);
 516
 517 static void kfree_opp_rcu(struct rcu_head *head)
 518 {
 519         struct dev_pm_opp *opp = container_of(head, struct dev_pm_opp, rcu_head);
 520
 521         kfree_rcu(opp, rcu_head);
 522 }
 523
 524 static void kfree_device_rcu(struct rcu_head *head)
 525 {
 526         struct device_opp *device_opp = container_of(head, struct device_opp, rcu_head);
 527
 528         kfree_rcu(device_opp, rcu_head);
 529 }
 530
 531 static void __dev_pm_opp_remove(struct device_opp *dev_opp,
 532                                 struct dev_pm_opp *opp)
 533 {
 534         /*
 535          * Notify the changes in the availability of the operable
 536          * frequency/voltage list.
 537          */
 538         srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_REMOVE, opp);
 539         list_del_rcu(&opp->node);
 540         call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, kfree_opp_rcu);
 541
 542         if (list_empty(&dev_opp->opp_list)) {
 543                 list_del_rcu(&dev_opp->node);
 544                 call_srcu(&dev_opp->srcu_head.srcu, &dev_opp->rcu_head,
 545                           kfree_device_rcu);
 546         }
 547 }
 548
 549 /**
 550  * dev_pm_opp_remove()  - Remove an OPP from OPP list
 551  * @dev:        device for which we do this operation
 552  * @freq:       OPP to remove with matching 'freq'
 553  *
 554  * This function removes an opp from the opp list.
 555  */
 556 void dev_pm_opp_remove(struct device *dev, unsigned long freq)
 557 {
 558         struct dev_pm_opp *opp;
 559         struct device_opp *dev_opp;
 560         bool found = false;
 561
 562         /* Hold our list modification lock here */
 563         mutex_lock(&dev_opp_list_lock);
 564
 565         dev_opp = find_device_opp(dev);
 566         if (IS_ERR(dev_opp))
 567                 goto unlock;
 568
 569         list_for_each_entry(opp, &dev_opp->opp_list, node) {
 570                 if (opp->rate == freq) {
 571                         found = true;
 572                         break;
 573                 }
 574         }
 575
 576         if (!found) {
 577                 dev_warn(dev, "%s: Couldn't find OPP with freq: %lu\n",
 578                          __func__, freq);
 579                 goto unlock;
 580         }
 581
 582         __dev_pm_opp_remove(dev_opp, opp);
 583 unlock:
 584         mutex_unlock(&dev_opp_list_lock);
 585 }
 586 EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
 587
 588 /**
 589  * opp_set_availability() - helper to set the availability of an opp
 590  * @dev:                device for which we do this operation
 591  * @freq:               OPP frequency to modify availability
 592  * @availability_req:   availability status requested for this opp
 593  *
 594  * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
 595  * share a common logic which is isolated here.
 596  *
 597  * Returns -EINVAL for bad pointers, -ENOMEM if no memory available for the
 598  * copy operation, returns 0 if no modifcation was done OR modification was
 599  * successful.
 600  *
 601  * Locking: The internal device_opp and opp structures are RCU protected.
 602  * Hence this function internally uses RCU updater strategy with mutex locks to
 603  * keep the integrity of the internal data structures. Callers should ensure
 604  * that this function is *NOT* called under RCU protection or in contexts where
 605  * mutex locking or synchronize_rcu() blocking calls cannot be used.
 606  */
 607 static int opp_set_availability(struct device *dev, unsigned long freq,
 608                 bool availability_req)
 609 {
 610         struct device_opp *dev_opp;
 611         struct dev_pm_opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
 612         int r = 0;
 613
 614         /* keep the node allocated */
 615         new_opp = kmalloc(sizeof(*new_opp), GFP_KERNEL);
 616         if (!new_opp) {
 617                 dev_warn(dev, "%s: Unable to create OPP\n", __func__);
 618                 return -ENOMEM;
 619         }
 620
 621         mutex_lock(&dev_opp_list_lock);
 622
 623         /* Find the device_opp */
 624         dev_opp = find_device_opp(dev);
 625         if (IS_ERR(dev_opp)) {
 626                 r = PTR_ERR(dev_opp);
 627                 dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
 628                 goto unlock;
 629         }
 630
 631         /* Do we have the frequency? */
 632         list_for_each_entry(tmp_opp, &dev_opp->opp_list, node) {
 633                 if (tmp_opp->rate == freq) {
 634                         opp = tmp_opp;
 635                         break;
 636                 }
 637         }
 638         if (IS_ERR(opp)) {
 639                 r = PTR_ERR(opp);
 640                 goto unlock;
 641         }
 642
 643         /* Is update really needed? */
 644         if (opp->available == availability_req)
 645                 goto unlock;
 646         /* copy the old data over */
 647         *new_opp = *opp;
 648
 649         /* plug in new node */
 650         new_opp->available = availability_req;
 651
 652         list_replace_rcu(&opp->node, &new_opp->node);
 653         mutex_unlock(&dev_opp_list_lock);
 654         call_srcu(&dev_opp->srcu_head.srcu, &opp->rcu_head, kfree_opp_rcu);
 655
 656         /* Notify the change of the OPP availability */
 657         if (availability_req)
 658                 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_ENABLE,
 659                                          new_opp);
 660         else
 661                 srcu_notifier_call_chain(&dev_opp->srcu_head, OPP_EVENT_DISABLE,
 662                                          new_opp);
 663
 664         return 0;
 665
 666 unlock:
 667         mutex_unlock(&dev_opp_list_lock);
 668         kfree(new_opp);
 669         return r;
 670 }
 671
 672 /**
 673  * dev_pm_opp_enable() - Enable a specific OPP
 674  * @dev:        device for which we do this operation
 675  * @freq:       OPP frequency to enable
 676  *
 677  * Enables a provided opp. If the operation is valid, this returns 0, else the
 678  * corresponding error value. It is meant to be used for users an OPP available
 679  * after being temporarily made unavailable with dev_pm_opp_disable.
 680  *
 681  * Locking: The internal device_opp and opp structures are RCU protected.
 682  * Hence this function indirectly uses RCU and mutex locks to keep the
 683  * integrity of the internal data structures. Callers should ensure that
 684  * this function is *NOT* called under RCU protection or in contexts where
 685  * mutex locking or synchronize_rcu() blocking calls cannot be used.
 686  */
 687 int dev_pm_opp_enable(struct device *dev, unsigned long freq)
 688 {
 689         return opp_set_availability(dev, freq, true);
 690 }
 691 EXPORT_SYMBOL_GPL(dev_pm_opp_enable);
 692
 693 /**
 694  * dev_pm_opp_disable() - Disable a specific OPP
 695  * @dev:        device for which we do this operation
 696  * @freq:       OPP frequency to disable
 697  *
 698  * Disables a provided opp. If the operation is valid, this returns
 699  * 0, else the corresponding error value. It is meant to be a temporary
 700  * control by users to make this OPP not available until the circumstances are
 701  * right to make it available again (with a call to dev_pm_opp_enable).
 702  *
 703  * Locking: The internal device_opp and opp structures are RCU protected.
 704  * Hence this function indirectly uses RCU and mutex locks to keep the
 705  * integrity of the internal data structures. Callers should ensure that
 706  * this function is *NOT* called under RCU protection or in contexts where
 707  * mutex locking or synchronize_rcu() blocking calls cannot be used.
 708  */
 709 int dev_pm_opp_disable(struct device *dev, unsigned long freq)
 710 {
 711         return opp_set_availability(dev, freq, false);
 712 }
 713 EXPORT_SYMBOL_GPL(dev_pm_opp_disable);
 714
 715 /**
 716  * dev_pm_opp_get_notifier() - find notifier_head of the device with opp
 717  * @dev:        device pointer used to lookup device OPPs.
 718  */
 719 struct srcu_notifier_head *dev_pm_opp_get_notifier(struct device *dev)
 720 {
 721         struct device_opp *dev_opp = find_device_opp(dev);
 722
 723         if (IS_ERR(dev_opp))
 724                 return ERR_CAST(dev_opp); /* matching type */
 725
 726         return &dev_opp->srcu_head;
 727 }
 728
 729 #ifdef CONFIG_OF
 730 /**
 731  * of_init_opp_table() - Initialize opp table from device tree
 732  * @dev:        device pointer used to lookup device OPPs.
 733  *
 734  * Register the initial OPP table with the OPP library for given device.
 735  */
 736 int of_init_opp_table(struct device *dev)
 737 {
 738         const struct property *prop;
 739         const __be32 *val;
 740         int nr;
 741
 742         prop = of_find_property(dev->of_node, "operating-points", NULL);
 743         if (!prop)
 744                 return -ENODEV;
 745         if (!prop->value)
 746                 return -ENODATA;
 747
 748         /*
 749          * Each OPP is a set of tuples consisting of frequency and
 750          * voltage like <freq-kHz vol-uV>.
 751          */
 752         nr = prop->length / sizeof(u32);
 753         if (nr % 2) {
 754                 dev_err(dev, "%s: Invalid OPP list\n", __func__);
 755                 return -EINVAL;
 756         }
 757
 758         val = prop->value;
 759         while (nr) {
 760                 unsigned long freq = be32_to_cpup(val++) * 1000;
 761                 unsigned long volt = be32_to_cpup(val++);
 762
 763                 if (dev_pm_opp_add_dynamic(dev, freq, volt, false))
 764                         dev_warn(dev, "%s: Failed to add OPP %ld\n",
 765                                  __func__, freq);
 766                 nr -= 2;
 767         }
 768
 769         return 0;
 770 }
 771 EXPORT_SYMBOL_GPL(of_init_opp_table);
 772
 773 /**
 774  * of_free_opp_table() - Free OPP table entries created from static DT entries
 775  * @dev:        device pointer used to lookup device OPPs.
 776  *
 777  * Free OPPs created using static entries present in DT.
 778  */
 779 void of_free_opp_table(struct device *dev)
 780 {
 781         struct device_opp *dev_opp;
 782         struct dev_pm_opp *opp, *tmp;
 783
 784         /* Check for existing list for 'dev' */
 785         dev_opp = find_device_opp(dev);
 786         if (WARN(IS_ERR(dev_opp), "%s: dev_opp: %ld\n", dev_name(dev),
 787                  PTR_ERR(dev_opp)))
 788                 return;
 789
 790         /* Hold our list modification lock here */
 791         mutex_lock(&dev_opp_list_lock);
 792
 793         /* Free static OPPs */
 794         list_for_each_entry_safe(opp, tmp, &dev_opp->opp_list, node) {
 795                 if (!opp->dynamic)
 796                         __dev_pm_opp_remove(dev_opp, opp);
 797         }
 798
 799         mutex_unlock(&dev_opp_list_lock);
 800 }
 801 EXPORT_SYMBOL_GPL(of_free_opp_table);
 802 #endif