drivers/devfreq/devfreq.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * devfreq: Generic Dynamic Voltage and Frequency Scaling (DVFS) Framework
   4  *          for Non-CPU Devices.
   5  *
   6  * Copyright (C) 2011 Samsung Electronics
   7  *      MyungJoo Ham <myungjoo.ham@samsung.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/kmod.h>
  12 #include <linux/sched.h>
  13 #include <linux/errno.h>
  14 #include <linux/err.h>
  15 #include <linux/init.h>
  16 #include <linux/export.h>
  17 #include <linux/slab.h>
  18 #include <linux/stat.h>
  19 #include <linux/pm_opp.h>
  20 #include <linux/devfreq.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/list.h>
  24 #include <linux/printk.h>
  25 #include <linux/hrtimer.h>
  26 #include <linux/of.h>
  27 #include "governor.h"
  28
  29 #define CREATE_TRACE_POINTS
  30 #include <trace/events/devfreq.h>
  31
  32 static struct class *devfreq_class;
  33
  34 /*
  35  * devfreq core provides delayed work based load monitoring helper
  36  * functions. Governors can use these or can implement their own
  37  * monitoring mechanism.
  38  */
  39 static struct workqueue_struct *devfreq_wq;
  40
  41 /* The list of all device-devfreq governors */
  42 static LIST_HEAD(devfreq_governor_list);
  43 /* The list of all device-devfreq */
  44 static LIST_HEAD(devfreq_list);
  45 static DEFINE_MUTEX(devfreq_list_lock);
  46
  47 /**
  48  * find_device_devfreq() - find devfreq struct using device pointer
  49  * @dev:        device pointer used to lookup device devfreq.
  50  *
  51  * Search the list of device devfreqs and return the matched device's
  52  * devfreq info. devfreq_list_lock should be held by the caller.
  53  */
  54 static struct devfreq *find_device_devfreq(struct device *dev)
  55 {
  56         struct devfreq *tmp_devfreq;
  57
  58         if (IS_ERR_OR_NULL(dev)) {
  59                 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
  60                 return ERR_PTR(-EINVAL);
  61         }
  62         WARN(!mutex_is_locked(&devfreq_list_lock),
  63              "devfreq_list_lock must be locked.");
  64
  65         list_for_each_entry(tmp_devfreq, &devfreq_list, node) {
  66                 if (tmp_devfreq->dev.parent == dev)
  67                         return tmp_devfreq;
  68         }
  69
  70         return ERR_PTR(-ENODEV);
  71 }
  72
  73 static unsigned long find_available_min_freq(struct devfreq *devfreq)
  74 {
  75         struct dev_pm_opp *opp;
  76         unsigned long min_freq = 0;
  77
  78         opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &min_freq);
  79         if (IS_ERR(opp))
  80                 min_freq = 0;
  81         else
  82                 dev_pm_opp_put(opp);
  83
  84         return min_freq;
  85 }
  86
  87 static unsigned long find_available_max_freq(struct devfreq *devfreq)
  88 {
  89         struct dev_pm_opp *opp;
  90         unsigned long max_freq = ULONG_MAX;
  91
  92         opp = dev_pm_opp_find_freq_floor(devfreq->dev.parent, &max_freq);
  93         if (IS_ERR(opp))
  94                 max_freq = 0;
  95         else
  96                 dev_pm_opp_put(opp);
  97
  98         return max_freq;
  99 }
 100
 101 /**
 102  * devfreq_get_freq_level() - Lookup freq_table for the frequency
 103  * @devfreq:    the devfreq instance
 104  * @freq:       the target frequency
 105  */
 106 static int devfreq_get_freq_level(struct devfreq *devfreq, unsigned long freq)
 107 {
 108         int lev;
 109
 110         for (lev = 0; lev < devfreq->profile->max_state; lev++)
 111                 if (freq == devfreq->profile->freq_table[lev])
 112                         return lev;
 113
 114         return -EINVAL;
 115 }
 116
 117 static int set_freq_table(struct devfreq *devfreq)
 118 {
 119         struct devfreq_dev_profile *profile = devfreq->profile;
 120         struct dev_pm_opp *opp;
 121         unsigned long freq;
 122         int i, count;
 123
 124         /* Initialize the freq_table from OPP table */
 125         count = dev_pm_opp_get_opp_count(devfreq->dev.parent);
 126         if (count <= 0)
 127                 return -EINVAL;
 128
 129         profile->max_state = count;
 130         profile->freq_table = devm_kcalloc(devfreq->dev.parent,
 131                                         profile->max_state,
 132                                         sizeof(*profile->freq_table),
 133                                         GFP_KERNEL);
 134         if (!profile->freq_table) {
 135                 profile->max_state = 0;
 136                 return -ENOMEM;
 137         }
 138
 139         for (i = 0, freq = 0; i < profile->max_state; i++, freq++) {
 140                 opp = dev_pm_opp_find_freq_ceil(devfreq->dev.parent, &freq);
 141                 if (IS_ERR(opp)) {
 142                         devm_kfree(devfreq->dev.parent, profile->freq_table);
 143                         profile->max_state = 0;
 144                         return PTR_ERR(opp);
 145                 }
 146                 dev_pm_opp_put(opp);
 147                 profile->freq_table[i] = freq;
 148         }
 149
 150         return 0;
 151 }
 152
 153 /**
 154  * devfreq_update_status() - Update statistics of devfreq behavior
 155  * @devfreq:    the devfreq instance
 156  * @freq:       the update target frequency
 157  */
 158 int devfreq_update_status(struct devfreq *devfreq, unsigned long freq)
 159 {
 160         int lev, prev_lev, ret = 0;
 161         unsigned long cur_time;
 162
 163         cur_time = jiffies;
 164
 165         /* Immediately exit if previous_freq is not initialized yet. */
 166         if (!devfreq->previous_freq)
 167                 goto out;
 168
 169         prev_lev = devfreq_get_freq_level(devfreq, devfreq->previous_freq);
 170         if (prev_lev < 0) {
 171                 ret = prev_lev;
 172                 goto out;
 173         }
 174
 175         devfreq->time_in_state[prev_lev] +=
 176                          cur_time - devfreq->last_stat_updated;
 177
 178         lev = devfreq_get_freq_level(devfreq, freq);
 179         if (lev < 0) {
 180                 ret = lev;
 181                 goto out;
 182         }
 183
 184         if (lev != prev_lev) {
 185                 devfreq->trans_table[(prev_lev *
 186                                 devfreq->profile->max_state) + lev]++;
 187                 devfreq->total_trans++;
 188         }
 189
 190 out:
 191         devfreq->last_stat_updated = cur_time;
 192         return ret;
 193 }
 194 EXPORT_SYMBOL(devfreq_update_status);
 195
 196 /**
 197  * find_devfreq_governor() - find devfreq governor from name
 198  * @name:       name of the governor
 199  *
 200  * Search the list of devfreq governors and return the matched
 201  * governor's pointer. devfreq_list_lock should be held by the caller.
 202  */
 203 static struct devfreq_governor *find_devfreq_governor(const char *name)
 204 {
 205         struct devfreq_governor *tmp_governor;
 206
 207         if (IS_ERR_OR_NULL(name)) {
 208                 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
 209                 return ERR_PTR(-EINVAL);
 210         }
 211         WARN(!mutex_is_locked(&devfreq_list_lock),
 212              "devfreq_list_lock must be locked.");
 213
 214         list_for_each_entry(tmp_governor, &devfreq_governor_list, node) {
 215                 if (!strncmp(tmp_governor->name, name, DEVFREQ_NAME_LEN))
 216                         return tmp_governor;
 217         }
 218
 219         return ERR_PTR(-ENODEV);
 220 }
 221
 222 /**
 223  * try_then_request_governor() - Try to find the governor and request the
 224  *                               module if is not found.
 225  * @name:       name of the governor
 226  *
 227  * Search the list of devfreq governors and request the module and try again
 228  * if is not found. This can happen when both drivers (the governor driver
 229  * and the driver that call devfreq_add_device) are built as modules.
 230  * devfreq_list_lock should be held by the caller. Returns the matched
 231  * governor's pointer or an error pointer.
 232  */
 233 static struct devfreq_governor *try_then_request_governor(const char *name)
 234 {
 235         struct devfreq_governor *governor;
 236         int err = 0;
 237
 238         if (IS_ERR_OR_NULL(name)) {
 239                 pr_err("DEVFREQ: %s: Invalid parameters\n", __func__);
 240                 return ERR_PTR(-EINVAL);
 241         }
 242         WARN(!mutex_is_locked(&devfreq_list_lock),
 243              "devfreq_list_lock must be locked.");
 244
 245         governor = find_devfreq_governor(name);
 246         if (IS_ERR(governor)) {
 247                 mutex_unlock(&devfreq_list_lock);
 248
 249                 if (!strncmp(name, DEVFREQ_GOV_SIMPLE_ONDEMAND,
 250                              DEVFREQ_NAME_LEN))
 251                         err = request_module("governor_%s", "simpleondemand");
 252                 else
 253                         err = request_module("governor_%s", name);
 254                 /* Restore previous state before return */
 255                 mutex_lock(&devfreq_list_lock);
 256                 if (err)
 257                         return (err < 0) ? ERR_PTR(err) : ERR_PTR(-EINVAL);
 258
 259                 governor = find_devfreq_governor(name);
 260         }
 261
 262         return governor;
 263 }
 264
 265 static int devfreq_notify_transition(struct devfreq *devfreq,
 266                 struct devfreq_freqs *freqs, unsigned int state)
 267 {
 268         if (!devfreq)
 269                 return -EINVAL;
 270
 271         switch (state) {
 272         case DEVFREQ_PRECHANGE:
 273                 srcu_notifier_call_chain(&devfreq->transition_notifier_list,
 274                                 DEVFREQ_PRECHANGE, freqs);
 275                 break;
 276
 277         case DEVFREQ_POSTCHANGE:
 278                 srcu_notifier_call_chain(&devfreq->transition_notifier_list,
 279                                 DEVFREQ_POSTCHANGE, freqs);
 280                 break;
 281         default:
 282                 return -EINVAL;
 283         }
 284
 285         return 0;
 286 }
 287
 288 static int devfreq_set_target(struct devfreq *devfreq, unsigned long new_freq,
 289                               u32 flags)
 290 {
 291         struct devfreq_freqs freqs;
 292         unsigned long cur_freq;
 293         int err = 0;
 294
 295         if (devfreq->profile->get_cur_freq)
 296                 devfreq->profile->get_cur_freq(devfreq->dev.parent, &cur_freq);
 297         else
 298                 cur_freq = devfreq->previous_freq;
 299
 300         freqs.old = cur_freq;
 301         freqs.new = new_freq;
 302         devfreq_notify_transition(devfreq, &freqs, DEVFREQ_PRECHANGE);
 303
 304         err = devfreq->profile->target(devfreq->dev.parent, &new_freq, flags);
 305         if (err) {
 306                 freqs.new = cur_freq;
 307                 devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
 308                 return err;
 309         }
 310
 311         freqs.new = new_freq;
 312         devfreq_notify_transition(devfreq, &freqs, DEVFREQ_POSTCHANGE);
 313
 314         if (devfreq_update_status(devfreq, new_freq))
 315                 dev_err(&devfreq->dev,
 316                         "Couldn't update frequency transition information.\n");
 317
 318         devfreq->previous_freq = new_freq;
 319
 320         if (devfreq->suspend_freq)
 321                 devfreq->resume_freq = cur_freq;
 322
 323         return err;
 324 }
 325
 326 /* Load monitoring helper functions for governors use */
 327
 328 /**
 329  * update_devfreq() - Reevaluate the device and configure frequency.
 330  * @devfreq:    the devfreq instance.
 331  *
 332  * Note: Lock devfreq->lock before calling update_devfreq
 333  *       This function is exported for governors.
 334  */
 335 int update_devfreq(struct devfreq *devfreq)
 336 {
 337         unsigned long freq, min_freq, max_freq;
 338         int err = 0;
 339         u32 flags = 0;
 340
 341         if (!mutex_is_locked(&devfreq->lock)) {
 342                 WARN(true, "devfreq->lock must be locked by the caller.\n");
 343                 return -EINVAL;
 344         }
 345
 346         if (!devfreq->governor)
 347                 return -EINVAL;
 348
 349         /* Reevaluate the proper frequency */
 350         err = devfreq->governor->get_target_freq(devfreq, &freq);
 351         if (err)
 352                 return err;
 353
 354         /*
 355          * Adjust the frequency with user freq, QoS and available freq.
 356          *
 357          * List from the highest priority
 358          * max_freq
 359          * min_freq
 360          */
 361         max_freq = min(devfreq->scaling_max_freq, devfreq->max_freq);
 362         min_freq = max(devfreq->scaling_min_freq, devfreq->min_freq);
 363
 364         if (freq < min_freq) {
 365                 freq = min_freq;
 366                 flags &= ~DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use GLB */
 367         }
 368         if (freq > max_freq) {
 369                 freq = max_freq;
 370                 flags |= DEVFREQ_FLAG_LEAST_UPPER_BOUND; /* Use LUB */
 371         }
 372
 373         return devfreq_set_target(devfreq, freq, flags);
 374
 375 }
 376 EXPORT_SYMBOL(update_devfreq);
 377
 378 /**
 379  * devfreq_monitor() - Periodically poll devfreq objects.
 380  * @work:       the work struct used to run devfreq_monitor periodically.
 381  *
 382  */
 383 static void devfreq_monitor(struct work_struct *work)
 384 {
 385         int err;
 386         struct devfreq *devfreq = container_of(work,
 387                                         struct devfreq, work.work);
 388
 389         mutex_lock(&devfreq->lock);
 390         err = update_devfreq(devfreq);
 391         if (err)
 392                 dev_err(&devfreq->dev, "dvfs failed with (%d) error\n", err);
 393
 394         queue_delayed_work(devfreq_wq, &devfreq->work,
 395                                 msecs_to_jiffies(devfreq->profile->polling_ms));
 396         mutex_unlock(&devfreq->lock);
 397
 398         trace_devfreq_monitor(devfreq);
 399 }
 400
 401 /**
 402  * devfreq_monitor_start() - Start load monitoring of devfreq instance
 403  * @devfreq:    the devfreq instance.
 404  *
 405  * Helper function for starting devfreq device load monitoring. By
 406  * default delayed work based monitoring is supported. Function
 407  * to be called from governor in response to DEVFREQ_GOV_START
 408  * event when device is added to devfreq framework.
 409  */
 410 void devfreq_monitor_start(struct devfreq *devfreq)
 411 {
 412         INIT_DEFERRABLE_WORK(&devfreq->work, devfreq_monitor);
 413         if (devfreq->profile->polling_ms)
 414                 queue_delayed_work(devfreq_wq, &devfreq->work,
 415                         msecs_to_jiffies(devfreq->profile->polling_ms));
 416 }
 417 EXPORT_SYMBOL(devfreq_monitor_start);
 418
 419 /**
 420  * devfreq_monitor_stop() - Stop load monitoring of a devfreq instance
 421  * @devfreq:    the devfreq instance.
 422  *
 423  * Helper function to stop devfreq device load monitoring. Function
 424  * to be called from governor in response to DEVFREQ_GOV_STOP
 425  * event when device is removed from devfreq framework.
 426  */
 427 void devfreq_monitor_stop(struct devfreq *devfreq)
 428 {
 429         cancel_delayed_work_sync(&devfreq->work);
 430 }
 431 EXPORT_SYMBOL(devfreq_monitor_stop);
 432
 433 /**
 434  * devfreq_monitor_suspend() - Suspend load monitoring of a devfreq instance
 435  * @devfreq:    the devfreq instance.
 436  *
 437  * Helper function to suspend devfreq device load monitoring. Function
 438  * to be called from governor in response to DEVFREQ_GOV_SUSPEND
 439  * event or when polling interval is set to zero.
 440  *
 441  * Note: Though this function is same as devfreq_monitor_stop(),
 442  * intentionally kept separate to provide hooks for collecting
 443  * transition statistics.
 444  */
 445 void devfreq_monitor_suspend(struct devfreq *devfreq)
 446 {
 447         mutex_lock(&devfreq->lock);
 448         if (devfreq->stop_polling) {
 449                 mutex_unlock(&devfreq->lock);
 450                 return;
 451         }
 452
 453         devfreq_update_status(devfreq, devfreq->previous_freq);
 454         devfreq->stop_polling = true;
 455         mutex_unlock(&devfreq->lock);
 456         cancel_delayed_work_sync(&devfreq->work);
 457 }
 458 EXPORT_SYMBOL(devfreq_monitor_suspend);
 459
 460 /**
 461  * devfreq_monitor_resume() - Resume load monitoring of a devfreq instance
 462  * @devfreq:    the devfreq instance.
 463  *
 464  * Helper function to resume devfreq device load monitoring. Function
 465  * to be called from governor in response to DEVFREQ_GOV_RESUME
 466  * event or when polling interval is set to non-zero.
 467  */
 468 void devfreq_monitor_resume(struct devfreq *devfreq)
 469 {
 470         unsigned long freq;
 471
 472         mutex_lock(&devfreq->lock);
 473         if (!devfreq->stop_polling)
 474                 goto out;
 475
 476         if (!delayed_work_pending(&devfreq->work) &&
 477                         devfreq->profile->polling_ms)
 478                 queue_delayed_work(devfreq_wq, &devfreq->work,
 479                         msecs_to_jiffies(devfreq->profile->polling_ms));
 480
 481         devfreq->last_stat_updated = jiffies;
 482         devfreq->stop_polling = false;
 483
 484         if (devfreq->profile->get_cur_freq &&
 485                 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
 486                 devfreq->previous_freq = freq;
 487
 488 out:
 489         mutex_unlock(&devfreq->lock);
 490 }
 491 EXPORT_SYMBOL(devfreq_monitor_resume);
 492
 493 /**
 494  * devfreq_interval_update() - Update device devfreq monitoring interval
 495  * @devfreq:    the devfreq instance.
 496  * @delay:      new polling interval to be set.
 497  *
 498  * Helper function to set new load monitoring polling interval. Function
 499  * to be called from governor in response to DEVFREQ_GOV_INTERVAL event.
 500  */
 501 void devfreq_interval_update(struct devfreq *devfreq, unsigned int *delay)
 502 {
 503         unsigned int cur_delay = devfreq->profile->polling_ms;
 504         unsigned int new_delay = *delay;
 505
 506         mutex_lock(&devfreq->lock);
 507         devfreq->profile->polling_ms = new_delay;
 508
 509         if (devfreq->stop_polling)
 510                 goto out;
 511
 512         /* if new delay is zero, stop polling */
 513         if (!new_delay) {
 514                 mutex_unlock(&devfreq->lock);
 515                 cancel_delayed_work_sync(&devfreq->work);
 516                 return;
 517         }
 518
 519         /* if current delay is zero, start polling with new delay */
 520         if (!cur_delay) {
 521                 queue_delayed_work(devfreq_wq, &devfreq->work,
 522                         msecs_to_jiffies(devfreq->profile->polling_ms));
 523                 goto out;
 524         }
 525
 526         /* if current delay is greater than new delay, restart polling */
 527         if (cur_delay > new_delay) {
 528                 mutex_unlock(&devfreq->lock);
 529                 cancel_delayed_work_sync(&devfreq->work);
 530                 mutex_lock(&devfreq->lock);
 531                 if (!devfreq->stop_polling)
 532                         queue_delayed_work(devfreq_wq, &devfreq->work,
 533                                 msecs_to_jiffies(devfreq->profile->polling_ms));
 534         }
 535 out:
 536         mutex_unlock(&devfreq->lock);
 537 }
 538 EXPORT_SYMBOL(devfreq_interval_update);
 539
 540 /**
 541  * devfreq_notifier_call() - Notify that the device frequency requirements
 542  *                           has been changed out of devfreq framework.
 543  * @nb:         the notifier_block (supposed to be devfreq->nb)
 544  * @type:       not used
 545  * @devp:       not used
 546  *
 547  * Called by a notifier that uses devfreq->nb.
 548  */
 549 static int devfreq_notifier_call(struct notifier_block *nb, unsigned long type,
 550                                  void *devp)
 551 {
 552         struct devfreq *devfreq = container_of(nb, struct devfreq, nb);
 553         int ret;
 554
 555         mutex_lock(&devfreq->lock);
 556
 557         devfreq->scaling_min_freq = find_available_min_freq(devfreq);
 558         if (!devfreq->scaling_min_freq) {
 559                 mutex_unlock(&devfreq->lock);
 560                 return -EINVAL;
 561         }
 562
 563         devfreq->scaling_max_freq = find_available_max_freq(devfreq);
 564         if (!devfreq->scaling_max_freq) {
 565                 mutex_unlock(&devfreq->lock);
 566                 return -EINVAL;
 567         }
 568
 569         ret = update_devfreq(devfreq);
 570         mutex_unlock(&devfreq->lock);
 571
 572         return ret;
 573 }
 574
 575 /**
 576  * devfreq_dev_release() - Callback for struct device to release the device.
 577  * @dev:        the devfreq device
 578  *
 579  * Remove devfreq from the list and release its resources.
 580  */
 581 static void devfreq_dev_release(struct device *dev)
 582 {
 583         struct devfreq *devfreq = to_devfreq(dev);
 584
 585         mutex_lock(&devfreq_list_lock);
 586         if (IS_ERR(find_device_devfreq(devfreq->dev.parent))) {
 587                 mutex_unlock(&devfreq_list_lock);
 588                 dev_warn(&devfreq->dev, "releasing devfreq which doesn't exist\n");
 589                 return;
 590         }
 591         list_del(&devfreq->node);
 592         mutex_unlock(&devfreq_list_lock);
 593
 594         if (devfreq->profile->exit)
 595                 devfreq->profile->exit(devfreq->dev.parent);
 596
 597         mutex_destroy(&devfreq->lock);
 598         kfree(devfreq);
 599 }
 600
 601 /**
 602  * devfreq_add_device() - Add devfreq feature to the device
 603  * @dev:        the device to add devfreq feature.
 604  * @profile:    device-specific profile to run devfreq.
 605  * @governor_name:      name of the policy to choose frequency.
 606  * @data:       private data for the governor. The devfreq framework does not
 607  *              touch this value.
 608  */
 609 struct devfreq *devfreq_add_device(struct device *dev,
 610                                    struct devfreq_dev_profile *profile,
 611                                    const char *governor_name,
 612                                    void *data)
 613 {
 614         struct devfreq *devfreq;
 615         struct devfreq_governor *governor;
 616         static atomic_t devfreq_no = ATOMIC_INIT(-1);
 617         int err = 0;
 618
 619         if (!dev || !profile || !governor_name) {
 620                 dev_err(dev, "%s: Invalid parameters.\n", __func__);
 621                 return ERR_PTR(-EINVAL);
 622         }
 623
 624         mutex_lock(&devfreq_list_lock);
 625         devfreq = find_device_devfreq(dev);
 626         mutex_unlock(&devfreq_list_lock);
 627         if (!IS_ERR(devfreq)) {
 628                 dev_err(dev, "%s: Unable to create devfreq for the device.\n",
 629                         __func__);
 630                 err = -EINVAL;
 631                 goto err_out;
 632         }
 633
 634         devfreq = kzalloc(sizeof(struct devfreq), GFP_KERNEL);
 635         if (!devfreq) {
 636                 err = -ENOMEM;
 637                 goto err_out;
 638         }
 639
 640         mutex_init(&devfreq->lock);
 641         mutex_lock(&devfreq->lock);
 642         devfreq->dev.parent = dev;
 643         devfreq->dev.class = devfreq_class;
 644         devfreq->dev.release = devfreq_dev_release;
 645         devfreq->profile = profile;
 646         strncpy(devfreq->governor_name, governor_name, DEVFREQ_NAME_LEN);
 647         devfreq->previous_freq = profile->initial_freq;
 648         devfreq->last_status.current_frequency = profile->initial_freq;
 649         devfreq->data = data;
 650         devfreq->nb.notifier_call = devfreq_notifier_call;
 651
 652         if (!devfreq->profile->max_state && !devfreq->profile->freq_table) {
 653                 mutex_unlock(&devfreq->lock);
 654                 err = set_freq_table(devfreq);
 655                 if (err < 0)
 656                         goto err_dev;
 657                 mutex_lock(&devfreq->lock);
 658         }
 659
 660         devfreq->scaling_min_freq = find_available_min_freq(devfreq);
 661         if (!devfreq->scaling_min_freq) {
 662                 mutex_unlock(&devfreq->lock);
 663                 err = -EINVAL;
 664                 goto err_dev;
 665         }
 666         devfreq->min_freq = devfreq->scaling_min_freq;
 667
 668         devfreq->scaling_max_freq = find_available_max_freq(devfreq);
 669         if (!devfreq->scaling_max_freq) {
 670                 mutex_unlock(&devfreq->lock);
 671                 err = -EINVAL;
 672                 goto err_dev;
 673         }
 674         devfreq->max_freq = devfreq->scaling_max_freq;
 675
 676         devfreq->suspend_freq = dev_pm_opp_get_suspend_opp_freq(dev);
 677         atomic_set(&devfreq->suspend_count, 0);
 678
 679         dev_set_name(&devfreq->dev, "devfreq%d",
 680                                 atomic_inc_return(&devfreq_no));
 681         err = device_register(&devfreq->dev);
 682         if (err) {
 683                 mutex_unlock(&devfreq->lock);
 684                 put_device(&devfreq->dev);
 685                 goto err_out;
 686         }
 687
 688         devfreq->trans_table = devm_kzalloc(&devfreq->dev,
 689                         array3_size(sizeof(unsigned int),
 690                                     devfreq->profile->max_state,
 691                                     devfreq->profile->max_state),
 692                         GFP_KERNEL);
 693         if (!devfreq->trans_table) {
 694                 mutex_unlock(&devfreq->lock);
 695                 err = -ENOMEM;
 696                 goto err_devfreq;
 697         }
 698
 699         devfreq->time_in_state = devm_kcalloc(&devfreq->dev,
 700                         devfreq->profile->max_state,
 701                         sizeof(unsigned long),
 702                         GFP_KERNEL);
 703         if (!devfreq->time_in_state) {
 704                 mutex_unlock(&devfreq->lock);
 705                 err = -ENOMEM;
 706                 goto err_devfreq;
 707         }
 708
 709         devfreq->last_stat_updated = jiffies;
 710
 711         srcu_init_notifier_head(&devfreq->transition_notifier_list);
 712
 713         mutex_unlock(&devfreq->lock);
 714
 715         mutex_lock(&devfreq_list_lock);
 716
 717         governor = try_then_request_governor(devfreq->governor_name);
 718         if (IS_ERR(governor)) {
 719                 dev_err(dev, "%s: Unable to find governor for the device\n",
 720                         __func__);
 721                 err = PTR_ERR(governor);
 722                 goto err_init;
 723         }
 724
 725         devfreq->governor = governor;
 726         err = devfreq->governor->event_handler(devfreq, DEVFREQ_GOV_START,
 727                                                 NULL);
 728         if (err) {
 729                 dev_err(dev, "%s: Unable to start governor for the device\n",
 730                         __func__);
 731                 goto err_init;
 732         }
 733
 734         list_add(&devfreq->node, &devfreq_list);
 735
 736         mutex_unlock(&devfreq_list_lock);
 737
 738         return devfreq;
 739
 740 err_init:
 741         mutex_unlock(&devfreq_list_lock);
 742 err_devfreq:
 743         devfreq_remove_device(devfreq);
 744         devfreq = NULL;
 745 err_dev:
 746         kfree(devfreq);
 747 err_out:
 748         return ERR_PTR(err);
 749 }
 750 EXPORT_SYMBOL(devfreq_add_device);
 751
 752 /**
 753  * devfreq_remove_device() - Remove devfreq feature from a device.
 754  * @devfreq:    the devfreq instance to be removed
 755  *
 756  * The opposite of devfreq_add_device().
 757  */
 758 int devfreq_remove_device(struct devfreq *devfreq)
 759 {
 760         if (!devfreq)
 761                 return -EINVAL;
 762
 763         if (devfreq->governor)
 764                 devfreq->governor->event_handler(devfreq,
 765                                                  DEVFREQ_GOV_STOP, NULL);
 766         device_unregister(&devfreq->dev);
 767
 768         return 0;
 769 }
 770 EXPORT_SYMBOL(devfreq_remove_device);
 771
 772 static int devm_devfreq_dev_match(struct device *dev, void *res, void *data)
 773 {
 774         struct devfreq **r = res;
 775
 776         if (WARN_ON(!r || !*r))
 777                 return 0;
 778
 779         return *r == data;
 780 }
 781
 782 static void devm_devfreq_dev_release(struct device *dev, void *res)
 783 {
 784         devfreq_remove_device(*(struct devfreq **)res);
 785 }
 786
 787 /**
 788  * devm_devfreq_add_device() - Resource-managed devfreq_add_device()
 789  * @dev:        the device to add devfreq feature.
 790  * @profile:    device-specific profile to run devfreq.
 791  * @governor_name:      name of the policy to choose frequency.
 792  * @data:       private data for the governor. The devfreq framework does not
 793  *              touch this value.
 794  *
 795  * This function manages automatically the memory of devfreq device using device
 796  * resource management and simplify the free operation for memory of devfreq
 797  * device.
 798  */
 799 struct devfreq *devm_devfreq_add_device(struct device *dev,
 800                                         struct devfreq_dev_profile *profile,
 801                                         const char *governor_name,
 802                                         void *data)
 803 {
 804         struct devfreq **ptr, *devfreq;
 805
 806         ptr = devres_alloc(devm_devfreq_dev_release, sizeof(*ptr), GFP_KERNEL);
 807         if (!ptr)
 808                 return ERR_PTR(-ENOMEM);
 809
 810         devfreq = devfreq_add_device(dev, profile, governor_name, data);
 811         if (IS_ERR(devfreq)) {
 812                 devres_free(ptr);
 813                 return devfreq;
 814         }
 815
 816         *ptr = devfreq;
 817         devres_add(dev, ptr);
 818
 819         return devfreq;
 820 }
 821 EXPORT_SYMBOL(devm_devfreq_add_device);
 822
 823 #ifdef CONFIG_OF
 824 /*
 825  * devfreq_get_devfreq_by_phandle - Get the devfreq device from devicetree
 826  * @dev - instance to the given device
 827  * @index - index into list of devfreq
 828  *
 829  * return the instance of devfreq device
 830  */
 831 struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
 832 {
 833         struct device_node *node;
 834         struct devfreq *devfreq;
 835
 836         if (!dev)
 837                 return ERR_PTR(-EINVAL);
 838
 839         if (!dev->of_node)
 840                 return ERR_PTR(-EINVAL);
 841
 842         node = of_parse_phandle(dev->of_node, "devfreq", index);
 843         if (!node)
 844                 return ERR_PTR(-ENODEV);
 845
 846         mutex_lock(&devfreq_list_lock);
 847         list_for_each_entry(devfreq, &devfreq_list, node) {
 848                 if (devfreq->dev.parent
 849                         && devfreq->dev.parent->of_node == node) {
 850                         mutex_unlock(&devfreq_list_lock);
 851                         of_node_put(node);
 852                         return devfreq;
 853                 }
 854         }
 855         mutex_unlock(&devfreq_list_lock);
 856         of_node_put(node);
 857
 858         return ERR_PTR(-EPROBE_DEFER);
 859 }
 860 #else
 861 struct devfreq *devfreq_get_devfreq_by_phandle(struct device *dev, int index)
 862 {
 863         return ERR_PTR(-ENODEV);
 864 }
 865 #endif /* CONFIG_OF */
 866 EXPORT_SYMBOL_GPL(devfreq_get_devfreq_by_phandle);
 867
 868 /**
 869  * devm_devfreq_remove_device() - Resource-managed devfreq_remove_device()
 870  * @dev:        the device from which to remove devfreq feature.
 871  * @devfreq:    the devfreq instance to be removed
 872  */
 873 void devm_devfreq_remove_device(struct device *dev, struct devfreq *devfreq)
 874 {
 875         WARN_ON(devres_release(dev, devm_devfreq_dev_release,
 876                                devm_devfreq_dev_match, devfreq));
 877 }
 878 EXPORT_SYMBOL(devm_devfreq_remove_device);
 879
 880 /**
 881  * devfreq_suspend_device() - Suspend devfreq of a device.
 882  * @devfreq: the devfreq instance to be suspended
 883  *
 884  * This function is intended to be called by the pm callbacks
 885  * (e.g., runtime_suspend, suspend) of the device driver that
 886  * holds the devfreq.
 887  */
 888 int devfreq_suspend_device(struct devfreq *devfreq)
 889 {
 890         int ret;
 891
 892         if (!devfreq)
 893                 return -EINVAL;
 894
 895         if (atomic_inc_return(&devfreq->suspend_count) > 1)
 896                 return 0;
 897
 898         if (devfreq->governor) {
 899                 ret = devfreq->governor->event_handler(devfreq,
 900                                         DEVFREQ_GOV_SUSPEND, NULL);
 901                 if (ret)
 902                         return ret;
 903         }
 904
 905         if (devfreq->suspend_freq) {
 906                 ret = devfreq_set_target(devfreq, devfreq->suspend_freq, 0);
 907                 if (ret)
 908                         return ret;
 909         }
 910
 911         return 0;
 912 }
 913 EXPORT_SYMBOL(devfreq_suspend_device);
 914
 915 /**
 916  * devfreq_resume_device() - Resume devfreq of a device.
 917  * @devfreq: the devfreq instance to be resumed
 918  *
 919  * This function is intended to be called by the pm callbacks
 920  * (e.g., runtime_resume, resume) of the device driver that
 921  * holds the devfreq.
 922  */
 923 int devfreq_resume_device(struct devfreq *devfreq)
 924 {
 925         int ret;
 926
 927         if (!devfreq)
 928                 return -EINVAL;
 929
 930         if (atomic_dec_return(&devfreq->suspend_count) >= 1)
 931                 return 0;
 932
 933         if (devfreq->resume_freq) {
 934                 ret = devfreq_set_target(devfreq, devfreq->resume_freq, 0);
 935                 if (ret)
 936                         return ret;
 937         }
 938
 939         if (devfreq->governor) {
 940                 ret = devfreq->governor->event_handler(devfreq,
 941                                         DEVFREQ_GOV_RESUME, NULL);
 942                 if (ret)
 943                         return ret;
 944         }
 945
 946         return 0;
 947 }
 948 EXPORT_SYMBOL(devfreq_resume_device);
 949
 950 /**
 951  * devfreq_suspend() - Suspend devfreq governors and devices
 952  *
 953  * Called during system wide Suspend/Hibernate cycles for suspending governors
 954  * and devices preserving the state for resume. On some platforms the devfreq
 955  * device must have precise state (frequency) after resume in order to provide
 956  * fully operating setup.
 957  */
 958 void devfreq_suspend(void)
 959 {
 960         struct devfreq *devfreq;
 961         int ret;
 962
 963         mutex_lock(&devfreq_list_lock);
 964         list_for_each_entry(devfreq, &devfreq_list, node) {
 965                 ret = devfreq_suspend_device(devfreq);
 966                 if (ret)
 967                         dev_err(&devfreq->dev,
 968                                 "failed to suspend devfreq device\n");
 969         }
 970         mutex_unlock(&devfreq_list_lock);
 971 }
 972
 973 /**
 974  * devfreq_resume() - Resume devfreq governors and devices
 975  *
 976  * Called during system wide Suspend/Hibernate cycle for resuming governors and
 977  * devices that are suspended with devfreq_suspend().
 978  */
 979 void devfreq_resume(void)
 980 {
 981         struct devfreq *devfreq;
 982         int ret;
 983
 984         mutex_lock(&devfreq_list_lock);
 985         list_for_each_entry(devfreq, &devfreq_list, node) {
 986                 ret = devfreq_resume_device(devfreq);
 987                 if (ret)
 988                         dev_warn(&devfreq->dev,
 989                                  "failed to resume devfreq device\n");
 990         }
 991         mutex_unlock(&devfreq_list_lock);
 992 }
 993
 994 /**
 995  * devfreq_add_governor() - Add devfreq governor
 996  * @governor:   the devfreq governor to be added
 997  */
 998 int devfreq_add_governor(struct devfreq_governor *governor)
 999 {
1000         struct devfreq_governor *g;
1001         struct devfreq *devfreq;
1002         int err = 0;
1003
1004         if (!governor) {
1005                 pr_err("%s: Invalid parameters.\n", __func__);
1006                 return -EINVAL;
1007         }
1008
1009         mutex_lock(&devfreq_list_lock);
1010         g = find_devfreq_governor(governor->name);
1011         if (!IS_ERR(g)) {
1012                 pr_err("%s: governor %s already registered\n", __func__,
1013                        g->name);
1014                 err = -EINVAL;
1015                 goto err_out;
1016         }
1017
1018         list_add(&governor->node, &devfreq_governor_list);
1019
1020         list_for_each_entry(devfreq, &devfreq_list, node) {
1021                 int ret = 0;
1022                 struct device *dev = devfreq->dev.parent;
1023
1024                 if (!strncmp(devfreq->governor_name, governor->name,
1025                              DEVFREQ_NAME_LEN)) {
1026                         /* The following should never occur */
1027                         if (devfreq->governor) {
1028                                 dev_warn(dev,
1029                                          "%s: Governor %s already present\n",
1030                                          __func__, devfreq->governor->name);
1031                                 ret = devfreq->governor->event_handler(devfreq,
1032                                                         DEVFREQ_GOV_STOP, NULL);
1033                                 if (ret) {
1034                                         dev_warn(dev,
1035                                                  "%s: Governor %s stop = %d\n",
1036                                                  __func__,
1037                                                  devfreq->governor->name, ret);
1038                                 }
1039                                 /* Fall through */
1040                         }
1041                         devfreq->governor = governor;
1042                         ret = devfreq->governor->event_handler(devfreq,
1043                                                 DEVFREQ_GOV_START, NULL);
1044                         if (ret) {
1045                                 dev_warn(dev, "%s: Governor %s start=%d\n",
1046                                          __func__, devfreq->governor->name,
1047                                          ret);
1048                         }
1049                 }
1050         }
1051
1052 err_out:
1053         mutex_unlock(&devfreq_list_lock);
1054
1055         return err;
1056 }
1057 EXPORT_SYMBOL(devfreq_add_governor);
1058
1059 /**
1060  * devfreq_remove_governor() - Remove devfreq feature from a device.
1061  * @governor:   the devfreq governor to be removed
1062  */
1063 int devfreq_remove_governor(struct devfreq_governor *governor)
1064 {
1065         struct devfreq_governor *g;
1066         struct devfreq *devfreq;
1067         int err = 0;
1068
1069         if (!governor) {
1070                 pr_err("%s: Invalid parameters.\n", __func__);
1071                 return -EINVAL;
1072         }
1073
1074         mutex_lock(&devfreq_list_lock);
1075         g = find_devfreq_governor(governor->name);
1076         if (IS_ERR(g)) {
1077                 pr_err("%s: governor %s not registered\n", __func__,
1078                        governor->name);
1079                 err = PTR_ERR(g);
1080                 goto err_out;
1081         }
1082         list_for_each_entry(devfreq, &devfreq_list, node) {
1083                 int ret;
1084                 struct device *dev = devfreq->dev.parent;
1085
1086                 if (!strncmp(devfreq->governor_name, governor->name,
1087                              DEVFREQ_NAME_LEN)) {
1088                         /* we should have a devfreq governor! */
1089                         if (!devfreq->governor) {
1090                                 dev_warn(dev, "%s: Governor %s NOT present\n",
1091                                          __func__, governor->name);
1092                                 continue;
1093                                 /* Fall through */
1094                         }
1095                         ret = devfreq->governor->event_handler(devfreq,
1096                                                 DEVFREQ_GOV_STOP, NULL);
1097                         if (ret) {
1098                                 dev_warn(dev, "%s: Governor %s stop=%d\n",
1099                                          __func__, devfreq->governor->name,
1100                                          ret);
1101                         }
1102                         devfreq->governor = NULL;
1103                 }
1104         }
1105
1106         list_del(&governor->node);
1107 err_out:
1108         mutex_unlock(&devfreq_list_lock);
1109
1110         return err;
1111 }
1112 EXPORT_SYMBOL(devfreq_remove_governor);
1113
1114 static ssize_t governor_show(struct device *dev,
1115                              struct device_attribute *attr, char *buf)
1116 {
1117         if (!to_devfreq(dev)->governor)
1118                 return -EINVAL;
1119
1120         return sprintf(buf, "%s\n", to_devfreq(dev)->governor->name);
1121 }
1122
1123 static ssize_t governor_store(struct device *dev, struct device_attribute *attr,
1124                               const char *buf, size_t count)
1125 {
1126         struct devfreq *df = to_devfreq(dev);
1127         int ret;
1128         char str_governor[DEVFREQ_NAME_LEN + 1];
1129         const struct devfreq_governor *governor, *prev_governor;
1130
1131         ret = sscanf(buf, "%" __stringify(DEVFREQ_NAME_LEN) "s", str_governor);
1132         if (ret != 1)
1133                 return -EINVAL;
1134
1135         mutex_lock(&devfreq_list_lock);
1136         governor = try_then_request_governor(str_governor);
1137         if (IS_ERR(governor)) {
1138                 ret = PTR_ERR(governor);
1139                 goto out;
1140         }
1141         if (df->governor == governor) {
1142                 ret = 0;
1143                 goto out;
1144         } else if ((df->governor && df->governor->immutable) ||
1145                                         governor->immutable) {
1146                 ret = -EINVAL;
1147                 goto out;
1148         }
1149
1150         if (df->governor) {
1151                 ret = df->governor->event_handler(df, DEVFREQ_GOV_STOP, NULL);
1152                 if (ret) {
1153                         dev_warn(dev, "%s: Governor %s not stopped(%d)\n",
1154                                  __func__, df->governor->name, ret);
1155                         goto out;
1156                 }
1157         }
1158         prev_governor = df->governor;
1159         df->governor = governor;
1160         strncpy(df->governor_name, governor->name, DEVFREQ_NAME_LEN);
1161         ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1162         if (ret) {
1163                 dev_warn(dev, "%s: Governor %s not started(%d)\n",
1164                          __func__, df->governor->name, ret);
1165                 df->governor = prev_governor;
1166                 strncpy(df->governor_name, prev_governor->name,
1167                         DEVFREQ_NAME_LEN);
1168                 ret = df->governor->event_handler(df, DEVFREQ_GOV_START, NULL);
1169                 if (ret) {
1170                         dev_err(dev,
1171                                 "%s: reverting to Governor %s failed (%d)\n",
1172                                 __func__, df->governor_name, ret);
1173                         df->governor = NULL;
1174                 }
1175         }
1176 out:
1177         mutex_unlock(&devfreq_list_lock);
1178
1179         if (!ret)
1180                 ret = count;
1181         return ret;
1182 }
1183 static DEVICE_ATTR_RW(governor);
1184
1185 static ssize_t available_governors_show(struct device *d,
1186                                         struct device_attribute *attr,
1187                                         char *buf)
1188 {
1189         struct devfreq *df = to_devfreq(d);
1190         ssize_t count = 0;
1191
1192         mutex_lock(&devfreq_list_lock);
1193
1194         /*
1195          * The devfreq with immutable governor (e.g., passive) shows
1196          * only own governor.
1197          */
1198         if (df->governor->immutable) {
1199                 count = scnprintf(&buf[count], DEVFREQ_NAME_LEN,
1200                                   "%s ", df->governor_name);
1201         /*
1202          * The devfreq device shows the registered governor except for
1203          * immutable governors such as passive governor .
1204          */
1205         } else {
1206                 struct devfreq_governor *governor;
1207
1208                 list_for_each_entry(governor, &devfreq_governor_list, node) {
1209                         if (governor->immutable)
1210                                 continue;
1211                         count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1212                                            "%s ", governor->name);
1213                 }
1214         }
1215
1216         mutex_unlock(&devfreq_list_lock);
1217
1218         /* Truncate the trailing space */
1219         if (count)
1220                 count--;
1221
1222         count += sprintf(&buf[count], "\n");
1223
1224         return count;
1225 }
1226 static DEVICE_ATTR_RO(available_governors);
1227
1228 static ssize_t cur_freq_show(struct device *dev, struct device_attribute *attr,
1229                              char *buf)
1230 {
1231         unsigned long freq;
1232         struct devfreq *devfreq = to_devfreq(dev);
1233
1234         if (devfreq->profile->get_cur_freq &&
1235                 !devfreq->profile->get_cur_freq(devfreq->dev.parent, &freq))
1236                 return sprintf(buf, "%lu\n", freq);
1237
1238         return sprintf(buf, "%lu\n", devfreq->previous_freq);
1239 }
1240 static DEVICE_ATTR_RO(cur_freq);
1241
1242 static ssize_t target_freq_show(struct device *dev,
1243                                 struct device_attribute *attr, char *buf)
1244 {
1245         return sprintf(buf, "%lu\n", to_devfreq(dev)->previous_freq);
1246 }
1247 static DEVICE_ATTR_RO(target_freq);
1248
1249 static ssize_t polling_interval_show(struct device *dev,
1250                                      struct device_attribute *attr, char *buf)
1251 {
1252         return sprintf(buf, "%d\n", to_devfreq(dev)->profile->polling_ms);
1253 }
1254
1255 static ssize_t polling_interval_store(struct device *dev,
1256                                       struct device_attribute *attr,
1257                                       const char *buf, size_t count)
1258 {
1259         struct devfreq *df = to_devfreq(dev);
1260         unsigned int value;
1261         int ret;
1262
1263         if (!df->governor)
1264                 return -EINVAL;
1265
1266         ret = sscanf(buf, "%u", &value);
1267         if (ret != 1)
1268                 return -EINVAL;
1269
1270         df->governor->event_handler(df, DEVFREQ_GOV_INTERVAL, &value);
1271         ret = count;
1272
1273         return ret;
1274 }
1275 static DEVICE_ATTR_RW(polling_interval);
1276
1277 static ssize_t min_freq_store(struct device *dev, struct device_attribute *attr,
1278                               const char *buf, size_t count)
1279 {
1280         struct devfreq *df = to_devfreq(dev);
1281         unsigned long value;
1282         int ret;
1283
1284         ret = sscanf(buf, "%lu", &value);
1285         if (ret != 1)
1286                 return -EINVAL;
1287
1288         mutex_lock(&df->lock);
1289
1290         if (value) {
1291                 if (value > df->max_freq) {
1292                         ret = -EINVAL;
1293                         goto unlock;
1294                 }
1295         } else {
1296                 unsigned long *freq_table = df->profile->freq_table;
1297
1298                 /* Get minimum frequency according to sorting order */
1299                 if (freq_table[0] < freq_table[df->profile->max_state - 1])
1300                         value = freq_table[0];
1301                 else
1302                         value = freq_table[df->profile->max_state - 1];
1303         }
1304
1305         df->min_freq = value;
1306         update_devfreq(df);
1307         ret = count;
1308 unlock:
1309         mutex_unlock(&df->lock);
1310         return ret;
1311 }
1312
1313 static ssize_t min_freq_show(struct device *dev, struct device_attribute *attr,
1314                              char *buf)
1315 {
1316         struct devfreq *df = to_devfreq(dev);
1317
1318         return sprintf(buf, "%lu\n", max(df->scaling_min_freq, df->min_freq));
1319 }
1320
1321 static ssize_t max_freq_store(struct device *dev, struct device_attribute *attr,
1322                               const char *buf, size_t count)
1323 {
1324         struct devfreq *df = to_devfreq(dev);
1325         unsigned long value;
1326         int ret;
1327
1328         ret = sscanf(buf, "%lu", &value);
1329         if (ret != 1)
1330                 return -EINVAL;
1331
1332         mutex_lock(&df->lock);
1333
1334         if (value) {
1335                 if (value < df->min_freq) {
1336                         ret = -EINVAL;
1337                         goto unlock;
1338                 }
1339         } else {
1340                 unsigned long *freq_table = df->profile->freq_table;
1341
1342                 /* Get maximum frequency according to sorting order */
1343                 if (freq_table[0] < freq_table[df->profile->max_state - 1])
1344                         value = freq_table[df->profile->max_state - 1];
1345                 else
1346                         value = freq_table[0];
1347         }
1348
1349         df->max_freq = value;
1350         update_devfreq(df);
1351         ret = count;
1352 unlock:
1353         mutex_unlock(&df->lock);
1354         return ret;
1355 }
1356 static DEVICE_ATTR_RW(min_freq);
1357
1358 static ssize_t max_freq_show(struct device *dev, struct device_attribute *attr,
1359                              char *buf)
1360 {
1361         struct devfreq *df = to_devfreq(dev);
1362
1363         return sprintf(buf, "%lu\n", min(df->scaling_max_freq, df->max_freq));
1364 }
1365 static DEVICE_ATTR_RW(max_freq);
1366
1367 static ssize_t available_frequencies_show(struct device *d,
1368                                           struct device_attribute *attr,
1369                                           char *buf)
1370 {
1371         struct devfreq *df = to_devfreq(d);
1372         ssize_t count = 0;
1373         int i;
1374
1375         mutex_lock(&df->lock);
1376
1377         for (i = 0; i < df->profile->max_state; i++)
1378                 count += scnprintf(&buf[count], (PAGE_SIZE - count - 2),
1379                                 "%lu ", df->profile->freq_table[i]);
1380
1381         mutex_unlock(&df->lock);
1382         /* Truncate the trailing space */
1383         if (count)
1384                 count--;
1385
1386         count += sprintf(&buf[count], "\n");
1387
1388         return count;
1389 }
1390 static DEVICE_ATTR_RO(available_frequencies);
1391
1392 static ssize_t trans_stat_show(struct device *dev,
1393                                struct device_attribute *attr, char *buf)
1394 {
1395         struct devfreq *devfreq = to_devfreq(dev);
1396         ssize_t len;
1397         int i, j;
1398         unsigned int max_state = devfreq->profile->max_state;
1399
1400         if (!devfreq->stop_polling &&
1401                         devfreq_update_status(devfreq, devfreq->previous_freq))
1402                 return 0;
1403         if (max_state == 0)
1404                 return sprintf(buf, "Not Supported.\n");
1405
1406         len = sprintf(buf, "     From  :   To\n");
1407         len += sprintf(buf + len, "           :");
1408         for (i = 0; i < max_state; i++)
1409                 len += sprintf(buf + len, "%10lu",
1410                                 devfreq->profile->freq_table[i]);
1411
1412         len += sprintf(buf + len, "   time(ms)\n");
1413
1414         for (i = 0; i < max_state; i++) {
1415                 if (devfreq->profile->freq_table[i]
1416                                         == devfreq->previous_freq) {
1417                         len += sprintf(buf + len, "*");
1418                 } else {
1419                         len += sprintf(buf + len, " ");
1420                 }
1421                 len += sprintf(buf + len, "%10lu:",
1422                                 devfreq->profile->freq_table[i]);
1423                 for (j = 0; j < max_state; j++)
1424                         len += sprintf(buf + len, "%10u",
1425                                 devfreq->trans_table[(i * max_state) + j]);
1426                 len += sprintf(buf + len, "%10u\n",
1427                         jiffies_to_msecs(devfreq->time_in_state[i]));
1428         }
1429
1430         len += sprintf(buf + len, "Total transition : %u\n",
1431                                         devfreq->total_trans);
1432         return len;
1433 }
1434 static DEVICE_ATTR_RO(trans_stat);
1435
1436 static struct attribute *devfreq_attrs[] = {
1437         &dev_attr_governor.attr,
1438         &dev_attr_available_governors.attr,
1439         &dev_attr_cur_freq.attr,
1440         &dev_attr_available_frequencies.attr,
1441         &dev_attr_target_freq.attr,
1442         &dev_attr_polling_interval.attr,
1443         &dev_attr_min_freq.attr,
1444         &dev_attr_max_freq.attr,
1445         &dev_attr_trans_stat.attr,
1446         NULL,
1447 };
1448 ATTRIBUTE_GROUPS(devfreq);
1449
1450 static int __init devfreq_init(void)
1451 {
1452         devfreq_class = class_create(THIS_MODULE, "devfreq");
1453         if (IS_ERR(devfreq_class)) {
1454                 pr_err("%s: couldn't create class\n", __FILE__);
1455                 return PTR_ERR(devfreq_class);
1456         }
1457
1458         devfreq_wq = create_freezable_workqueue("devfreq_wq");
1459         if (!devfreq_wq) {
1460                 class_destroy(devfreq_class);
1461                 pr_err("%s: couldn't create workqueue\n", __FILE__);
1462                 return -ENOMEM;
1463         }
1464         devfreq_class->dev_groups = devfreq_groups;
1465
1466         return 0;
1467 }
1468 subsys_initcall(devfreq_init);
1469
1470 /*
1471  * The following are helper functions for devfreq user device drivers with
1472  * OPP framework.
1473  */
1474
1475 /**
1476  * devfreq_recommended_opp() - Helper function to get proper OPP for the
1477  *                           freq value given to target callback.
1478  * @dev:        The devfreq user device. (parent of devfreq)
1479  * @freq:       The frequency given to target function
1480  * @flags:      Flags handed from devfreq framework.
1481  *
1482  * The callers are required to call dev_pm_opp_put() for the returned OPP after
1483  * use.
1484  */
1485 struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
1486                                            unsigned long *freq,
1487                                            u32 flags)
1488 {
1489         struct dev_pm_opp *opp;
1490
1491         if (flags & DEVFREQ_FLAG_LEAST_UPPER_BOUND) {
1492                 /* The freq is an upper bound. opp should be lower */
1493                 opp = dev_pm_opp_find_freq_floor(dev, freq);
1494
1495                 /* If not available, use the closest opp */
1496                 if (opp == ERR_PTR(-ERANGE))
1497                         opp = dev_pm_opp_find_freq_ceil(dev, freq);
1498         } else {
1499                 /* The freq is an lower bound. opp should be higher */
1500                 opp = dev_pm_opp_find_freq_ceil(dev, freq);
1501
1502                 /* If not available, use the closest opp */
1503                 if (opp == ERR_PTR(-ERANGE))
1504                         opp = dev_pm_opp_find_freq_floor(dev, freq);
1505         }
1506
1507         return opp;
1508 }
1509 EXPORT_SYMBOL(devfreq_recommended_opp);
1510
1511 /**
1512  * devfreq_register_opp_notifier() - Helper function to get devfreq notified
1513  *                                   for any changes in the OPP availability
1514  *                                   changes
1515  * @dev:        The devfreq user device. (parent of devfreq)
1516  * @devfreq:    The devfreq object.
1517  */
1518 int devfreq_register_opp_notifier(struct device *dev, struct devfreq *devfreq)
1519 {
1520         return dev_pm_opp_register_notifier(dev, &devfreq->nb);
1521 }
1522 EXPORT_SYMBOL(devfreq_register_opp_notifier);
1523
1524 /**
1525  * devfreq_unregister_opp_notifier() - Helper function to stop getting devfreq
1526  *                                     notified for any changes in the OPP
1527  *                                     availability changes anymore.
1528  * @dev:        The devfreq user device. (parent of devfreq)
1529  * @devfreq:    The devfreq object.
1530  *
1531  * At exit() callback of devfreq_dev_profile, this must be included if
1532  * devfreq_recommended_opp is used.
1533  */
1534 int devfreq_unregister_opp_notifier(struct device *dev, struct devfreq *devfreq)
1535 {
1536         return dev_pm_opp_unregister_notifier(dev, &devfreq->nb);
1537 }
1538 EXPORT_SYMBOL(devfreq_unregister_opp_notifier);
1539
1540 static void devm_devfreq_opp_release(struct device *dev, void *res)
1541 {
1542         devfreq_unregister_opp_notifier(dev, *(struct devfreq **)res);
1543 }
1544
1545 /**
1546  * devm_devfreq_register_opp_notifier() - Resource-managed
1547  *                                        devfreq_register_opp_notifier()
1548  * @dev:        The devfreq user device. (parent of devfreq)
1549  * @devfreq:    The devfreq object.
1550  */
1551 int devm_devfreq_register_opp_notifier(struct device *dev,
1552                                        struct devfreq *devfreq)
1553 {
1554         struct devfreq **ptr;
1555         int ret;
1556
1557         ptr = devres_alloc(devm_devfreq_opp_release, sizeof(*ptr), GFP_KERNEL);
1558         if (!ptr)
1559                 return -ENOMEM;
1560
1561         ret = devfreq_register_opp_notifier(dev, devfreq);
1562         if (ret) {
1563                 devres_free(ptr);
1564                 return ret;
1565         }
1566
1567         *ptr = devfreq;
1568         devres_add(dev, ptr);
1569
1570         return 0;
1571 }
1572 EXPORT_SYMBOL(devm_devfreq_register_opp_notifier);
1573
1574 /**
1575  * devm_devfreq_unregister_opp_notifier() - Resource-managed
1576  *                                          devfreq_unregister_opp_notifier()
1577  * @dev:        The devfreq user device. (parent of devfreq)
1578  * @devfreq:    The devfreq object.
1579  */
1580 void devm_devfreq_unregister_opp_notifier(struct device *dev,
1581                                          struct devfreq *devfreq)
1582 {
1583         WARN_ON(devres_release(dev, devm_devfreq_opp_release,
1584                                devm_devfreq_dev_match, devfreq));
1585 }
1586 EXPORT_SYMBOL(devm_devfreq_unregister_opp_notifier);
1587
1588 /**
1589  * devfreq_register_notifier() - Register a driver with devfreq
1590  * @devfreq:    The devfreq object.
1591  * @nb:         The notifier block to register.
1592  * @list:       DEVFREQ_TRANSITION_NOTIFIER.
1593  */
1594 int devfreq_register_notifier(struct devfreq *devfreq,
1595                               struct notifier_block *nb,
1596                               unsigned int list)
1597 {
1598         int ret = 0;
1599
1600         if (!devfreq)
1601                 return -EINVAL;
1602
1603         switch (list) {
1604         case DEVFREQ_TRANSITION_NOTIFIER:
1605                 ret = srcu_notifier_chain_register(
1606                                 &devfreq->transition_notifier_list, nb);
1607                 break;
1608         default:
1609                 ret = -EINVAL;
1610         }
1611
1612         return ret;
1613 }
1614 EXPORT_SYMBOL(devfreq_register_notifier);
1615
1616 /*
1617  * devfreq_unregister_notifier() - Unregister a driver with devfreq
1618  * @devfreq:    The devfreq object.
1619  * @nb:         The notifier block to be unregistered.
1620  * @list:       DEVFREQ_TRANSITION_NOTIFIER.
1621  */
1622 int devfreq_unregister_notifier(struct devfreq *devfreq,
1623                                 struct notifier_block *nb,
1624                                 unsigned int list)
1625 {
1626         int ret = 0;
1627
1628         if (!devfreq)
1629                 return -EINVAL;
1630
1631         switch (list) {
1632         case DEVFREQ_TRANSITION_NOTIFIER:
1633                 ret = srcu_notifier_chain_unregister(
1634                                 &devfreq->transition_notifier_list, nb);
1635                 break;
1636         default:
1637                 ret = -EINVAL;
1638         }
1639
1640         return ret;
1641 }
1642 EXPORT_SYMBOL(devfreq_unregister_notifier);
1643
1644 struct devfreq_notifier_devres {
1645         struct devfreq *devfreq;
1646         struct notifier_block *nb;
1647         unsigned int list;
1648 };
1649
1650 static void devm_devfreq_notifier_release(struct device *dev, void *res)
1651 {
1652         struct devfreq_notifier_devres *this = res;
1653
1654         devfreq_unregister_notifier(this->devfreq, this->nb, this->list);
1655 }
1656
1657 /**
1658  * devm_devfreq_register_notifier()
1659         - Resource-managed devfreq_register_notifier()
1660  * @dev:        The devfreq user device. (parent of devfreq)
1661  * @devfreq:    The devfreq object.
1662  * @nb:         The notifier block to be unregistered.
1663  * @list:       DEVFREQ_TRANSITION_NOTIFIER.
1664  */
1665 int devm_devfreq_register_notifier(struct device *dev,
1666                                 struct devfreq *devfreq,
1667                                 struct notifier_block *nb,
1668                                 unsigned int list)
1669 {
1670         struct devfreq_notifier_devres *ptr;
1671         int ret;
1672
1673         ptr = devres_alloc(devm_devfreq_notifier_release, sizeof(*ptr),
1674                                 GFP_KERNEL);
1675         if (!ptr)
1676                 return -ENOMEM;
1677
1678         ret = devfreq_register_notifier(devfreq, nb, list);
1679         if (ret) {
1680                 devres_free(ptr);
1681                 return ret;
1682         }
1683
1684         ptr->devfreq = devfreq;
1685         ptr->nb = nb;
1686         ptr->list = list;
1687         devres_add(dev, ptr);
1688
1689         return 0;
1690 }
1691 EXPORT_SYMBOL(devm_devfreq_register_notifier);
1692
1693 /**
1694  * devm_devfreq_unregister_notifier()
1695         - Resource-managed devfreq_unregister_notifier()
1696  * @dev:        The devfreq user device. (parent of devfreq)
1697  * @devfreq:    The devfreq object.
1698  * @nb:         The notifier block to be unregistered.
1699  * @list:       DEVFREQ_TRANSITION_NOTIFIER.
1700  */
1701 void devm_devfreq_unregister_notifier(struct device *dev,
1702                                       struct devfreq *devfreq,
1703                                       struct notifier_block *nb,
1704                                       unsigned int list)
1705 {
1706         WARN_ON(devres_release(dev, devm_devfreq_notifier_release,
1707                                devm_devfreq_dev_match, devfreq));
1708 }
1709 EXPORT_SYMBOL(devm_devfreq_unregister_notifier);