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