drivers/cpufreq/cpufreq_governor.c

   1 /*
   2  * drivers/cpufreq/cpufreq_governor.c
   3  *
   4  * CPUFREQ governors common code
   5  *
   6  * Copyright    (C) 2001 Russell King
   7  *              (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
   8  *              (C) 2003 Jun Nakajima <jun.nakajima@intel.com>
   9  *              (C) 2009 Alexander Clouter <alex@digriz.org.uk>
  10  *              (c) 2012 Viresh Kumar <viresh.kumar@linaro.org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License version 2 as
  14  * published by the Free Software Foundation.
  15  */
  16
  17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18
  19 #include <linux/export.h>
  20 #include <linux/kernel_stat.h>
  21 #include <linux/slab.h>
  22
  23 #include "cpufreq_governor.h"
  24
  25 DEFINE_MUTEX(dbs_data_mutex);
  26 EXPORT_SYMBOL_GPL(dbs_data_mutex);
  27
  28 /* Common sysfs tunables */
  29 /**
  30  * store_sampling_rate - update sampling rate effective immediately if needed.
  31  *
  32  * If new rate is smaller than the old, simply updating
  33  * dbs.sampling_rate might not be appropriate. For example, if the
  34  * original sampling_rate was 1 second and the requested new sampling rate is 10
  35  * ms because the user needs immediate reaction from ondemand governor, but not
  36  * sure if higher frequency will be required or not, then, the governor may
  37  * change the sampling rate too late; up to 1 second later. Thus, if we are
  38  * reducing the sampling rate, we need to make the new value effective
  39  * immediately.
  40  *
  41  * On the other hand, if new rate is larger than the old, then we may evaluate
  42  * the load too soon, and it might we worth updating sample_delay_ns then as
  43  * well.
  44  *
  45  * This must be called with dbs_data->mutex held, otherwise traversing
  46  * policy_dbs_list isn't safe.
  47  */
  48 ssize_t store_sampling_rate(struct dbs_data *dbs_data, const char *buf,
  49                             size_t count)
  50 {
  51         struct policy_dbs_info *policy_dbs;
  52         unsigned int rate;
  53         int ret;
  54         ret = sscanf(buf, "%u", &rate);
  55         if (ret != 1)
  56                 return -EINVAL;
  57
  58         dbs_data->sampling_rate = max(rate, dbs_data->min_sampling_rate);
  59
  60         /*
  61          * We are operating under dbs_data->mutex and so the list and its
  62          * entries can't be freed concurrently.
  63          */
  64         list_for_each_entry(policy_dbs, &dbs_data->policy_dbs_list, list) {
  65                 mutex_lock(&policy_dbs->timer_mutex);
  66                 /*
  67                  * On 32-bit architectures this may race with the
  68                  * sample_delay_ns read in dbs_update_util_handler(), but that
  69                  * really doesn't matter.  If the read returns a value that's
  70                  * too big, the sample will be skipped, but the next invocation
  71                  * of dbs_update_util_handler() (when the update has been
  72                  * completed) will take a sample.  If the returned value is too
  73                  * small, the sample will be taken immediately, but that isn't a
  74                  * problem, as we want the new rate to take effect immediately
  75                  * anyway.
  76                  *
  77                  * If this runs in parallel with dbs_work_handler(), we may end
  78                  * up overwriting the sample_delay_ns value that it has just
  79                  * written, but the difference should not be too big and it will
  80                  * be corrected next time a sample is taken, so it shouldn't be
  81                  * significant.
  82                  */
  83                 gov_update_sample_delay(policy_dbs, dbs_data->sampling_rate);
  84                 mutex_unlock(&policy_dbs->timer_mutex);
  85         }
  86
  87         return count;
  88 }
  89 EXPORT_SYMBOL_GPL(store_sampling_rate);
  90
  91 static inline struct dbs_data *to_dbs_data(struct kobject *kobj)
  92 {
  93         return container_of(kobj, struct dbs_data, kobj);
  94 }
  95
  96 static inline struct governor_attr *to_gov_attr(struct attribute *attr)
  97 {
  98         return container_of(attr, struct governor_attr, attr);
  99 }
 100
 101 static ssize_t governor_show(struct kobject *kobj, struct attribute *attr,
 102                              char *buf)
 103 {
 104         struct dbs_data *dbs_data = to_dbs_data(kobj);
 105         struct governor_attr *gattr = to_gov_attr(attr);
 106         int ret = -EIO;
 107
 108         if (gattr->show)
 109                 ret = gattr->show(dbs_data, buf);
 110
 111         return ret;
 112 }
 113
 114 static ssize_t governor_store(struct kobject *kobj, struct attribute *attr,
 115                               const char *buf, size_t count)
 116 {
 117         struct dbs_data *dbs_data = to_dbs_data(kobj);
 118         struct governor_attr *gattr = to_gov_attr(attr);
 119         int ret = -EIO;
 120
 121         mutex_lock(&dbs_data->mutex);
 122
 123         if (gattr->store)
 124                 ret = gattr->store(dbs_data, buf, count);
 125
 126         mutex_unlock(&dbs_data->mutex);
 127
 128         return ret;
 129 }
 130
 131 /*
 132  * Sysfs Ops for accessing governor attributes.
 133  *
 134  * All show/store invocations for governor specific sysfs attributes, will first
 135  * call the below show/store callbacks and the attribute specific callback will
 136  * be called from within it.
 137  */
 138 static const struct sysfs_ops governor_sysfs_ops = {
 139         .show   = governor_show,
 140         .store  = governor_store,
 141 };
 142
 143 void dbs_check_cpu(struct cpufreq_policy *policy)
 144 {
 145         int cpu = policy->cpu;
 146         struct dbs_governor *gov = dbs_governor_of(policy);
 147         struct policy_dbs_info *policy_dbs = policy->governor_data;
 148         struct dbs_data *dbs_data = policy_dbs->dbs_data;
 149         struct od_dbs_tuners *od_tuners = dbs_data->tuners;
 150         unsigned int sampling_rate = dbs_data->sampling_rate;
 151         unsigned int ignore_nice = dbs_data->ignore_nice_load;
 152         unsigned int max_load = 0;
 153         unsigned int j;
 154
 155         if (gov->governor == GOV_ONDEMAND) {
 156                 struct od_cpu_dbs_info_s *od_dbs_info =
 157                                 gov->get_cpu_dbs_info_s(cpu);
 158
 159                 /*
 160                  * Sometimes, the ondemand governor uses an additional
 161                  * multiplier to give long delays. So apply this multiplier to
 162                  * the 'sampling_rate', so as to keep the wake-up-from-idle
 163                  * detection logic a bit conservative.
 164                  */
 165                 sampling_rate *= od_dbs_info->rate_mult;
 166
 167         }
 168
 169         /* Get Absolute Load */
 170         for_each_cpu(j, policy->cpus) {
 171                 struct cpu_dbs_info *j_cdbs;
 172                 u64 cur_wall_time, cur_idle_time;
 173                 unsigned int idle_time, wall_time;
 174                 unsigned int load;
 175                 int io_busy = 0;
 176
 177                 j_cdbs = gov->get_cpu_cdbs(j);
 178
 179                 /*
 180                  * For the purpose of ondemand, waiting for disk IO is
 181                  * an indication that you're performance critical, and
 182                  * not that the system is actually idle. So do not add
 183                  * the iowait time to the cpu idle time.
 184                  */
 185                 if (gov->governor == GOV_ONDEMAND)
 186                         io_busy = od_tuners->io_is_busy;
 187                 cur_idle_time = get_cpu_idle_time(j, &cur_wall_time, io_busy);
 188
 189                 wall_time = (unsigned int)
 190                         (cur_wall_time - j_cdbs->prev_cpu_wall);
 191                 j_cdbs->prev_cpu_wall = cur_wall_time;
 192
 193                 if (cur_idle_time < j_cdbs->prev_cpu_idle)
 194                         cur_idle_time = j_cdbs->prev_cpu_idle;
 195
 196                 idle_time = (unsigned int)
 197                         (cur_idle_time - j_cdbs->prev_cpu_idle);
 198                 j_cdbs->prev_cpu_idle = cur_idle_time;
 199
 200                 if (ignore_nice) {
 201                         struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
 202                         u64 cur_nice;
 203                         unsigned long cur_nice_jiffies;
 204
 205                         cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE] -
 206                                          cdbs->prev_cpu_nice;
 207                         /*
 208                          * Assumption: nice time between sampling periods will
 209                          * be less than 2^32 jiffies for 32 bit sys
 210                          */
 211                         cur_nice_jiffies = (unsigned long)
 212                                         cputime64_to_jiffies64(cur_nice);
 213
 214                         cdbs->prev_cpu_nice =
 215                                 kcpustat_cpu(j).cpustat[CPUTIME_NICE];
 216                         idle_time += jiffies_to_usecs(cur_nice_jiffies);
 217                 }
 218
 219                 if (unlikely(!wall_time || wall_time < idle_time))
 220                         continue;
 221
 222                 /*
 223                  * If the CPU had gone completely idle, and a task just woke up
 224                  * on this CPU now, it would be unfair to calculate 'load' the
 225                  * usual way for this elapsed time-window, because it will show
 226                  * near-zero load, irrespective of how CPU intensive that task
 227                  * actually is. This is undesirable for latency-sensitive bursty
 228                  * workloads.
 229                  *
 230                  * To avoid this, we reuse the 'load' from the previous
 231                  * time-window and give this task a chance to start with a
 232                  * reasonably high CPU frequency. (However, we shouldn't over-do
 233                  * this copy, lest we get stuck at a high load (high frequency)
 234                  * for too long, even when the current system load has actually
 235                  * dropped down. So we perform the copy only once, upon the
 236                  * first wake-up from idle.)
 237                  *
 238                  * Detecting this situation is easy: the governor's utilization
 239                  * update handler would not have run during CPU-idle periods.
 240                  * Hence, an unusually large 'wall_time' (as compared to the
 241                  * sampling rate) indicates this scenario.
 242                  *
 243                  * prev_load can be zero in two cases and we must recalculate it
 244                  * for both cases:
 245                  * - during long idle intervals
 246                  * - explicitly set to zero
 247                  */
 248                 if (unlikely(wall_time > (2 * sampling_rate) &&
 249                              j_cdbs->prev_load)) {
 250                         load = j_cdbs->prev_load;
 251
 252                         /*
 253                          * Perform a destructive copy, to ensure that we copy
 254                          * the previous load only once, upon the first wake-up
 255                          * from idle.
 256                          */
 257                         j_cdbs->prev_load = 0;
 258                 } else {
 259                         load = 100 * (wall_time - idle_time) / wall_time;
 260                         j_cdbs->prev_load = load;
 261                 }
 262
 263                 if (load > max_load)
 264                         max_load = load;
 265         }
 266
 267         gov->gov_check_cpu(cpu, max_load);
 268 }
 269 EXPORT_SYMBOL_GPL(dbs_check_cpu);
 270
 271 void gov_set_update_util(struct policy_dbs_info *policy_dbs,
 272                          unsigned int delay_us)
 273 {
 274         struct cpufreq_policy *policy = policy_dbs->policy;
 275         struct dbs_governor *gov = dbs_governor_of(policy);
 276         int cpu;
 277
 278         gov_update_sample_delay(policy_dbs, delay_us);
 279         policy_dbs->last_sample_time = 0;
 280
 281         for_each_cpu(cpu, policy->cpus) {
 282                 struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(cpu);
 283
 284                 cpufreq_set_update_util_data(cpu, &cdbs->update_util);
 285         }
 286 }
 287 EXPORT_SYMBOL_GPL(gov_set_update_util);
 288
 289 static inline void gov_clear_update_util(struct cpufreq_policy *policy)
 290 {
 291         int i;
 292
 293         for_each_cpu(i, policy->cpus)
 294                 cpufreq_set_update_util_data(i, NULL);
 295
 296         synchronize_rcu();
 297 }
 298
 299 static void gov_cancel_work(struct cpufreq_policy *policy)
 300 {
 301         struct policy_dbs_info *policy_dbs = policy->governor_data;
 302
 303         /* Tell dbs_update_util_handler() to skip queuing up work items. */
 304         atomic_inc(&policy_dbs->work_count);
 305         /*
 306          * If dbs_update_util_handler() is already running, it may not notice
 307          * the incremented work_count, so wait for it to complete to prevent its
 308          * work item from being queued up after the cancel_work_sync() below.
 309          */
 310         gov_clear_update_util(policy_dbs->policy);
 311         irq_work_sync(&policy_dbs->irq_work);
 312         cancel_work_sync(&policy_dbs->work);
 313         atomic_set(&policy_dbs->work_count, 0);
 314 }
 315
 316 static void dbs_work_handler(struct work_struct *work)
 317 {
 318         struct policy_dbs_info *policy_dbs;
 319         struct cpufreq_policy *policy;
 320         struct dbs_governor *gov;
 321         unsigned int delay;
 322
 323         policy_dbs = container_of(work, struct policy_dbs_info, work);
 324         policy = policy_dbs->policy;
 325         gov = dbs_governor_of(policy);
 326
 327         /*
 328          * Make sure cpufreq_governor_limits() isn't evaluating load or the
 329          * ondemand governor isn't updating the sampling rate in parallel.
 330          */
 331         mutex_lock(&policy_dbs->timer_mutex);
 332         delay = gov->gov_dbs_timer(policy);
 333         policy_dbs->sample_delay_ns = jiffies_to_nsecs(delay);
 334         mutex_unlock(&policy_dbs->timer_mutex);
 335
 336         /*
 337          * If the atomic operation below is reordered with respect to the
 338          * sample delay modification, the utilization update handler may end
 339          * up using a stale sample delay value.
 340          */
 341         smp_mb__before_atomic();
 342         atomic_dec(&policy_dbs->work_count);
 343 }
 344
 345 static void dbs_irq_work(struct irq_work *irq_work)
 346 {
 347         struct policy_dbs_info *policy_dbs;
 348
 349         policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work);
 350         schedule_work(&policy_dbs->work);
 351 }
 352
 353 static inline void gov_queue_irq_work(struct policy_dbs_info *policy_dbs)
 354 {
 355 #ifdef CONFIG_SMP
 356         irq_work_queue_on(&policy_dbs->irq_work, smp_processor_id());
 357 #else
 358         irq_work_queue(&policy_dbs->irq_work);
 359 #endif
 360 }
 361
 362 static void dbs_update_util_handler(struct update_util_data *data, u64 time,
 363                                     unsigned long util, unsigned long max)
 364 {
 365         struct cpu_dbs_info *cdbs = container_of(data, struct cpu_dbs_info, update_util);
 366         struct policy_dbs_info *policy_dbs = cdbs->policy_dbs;
 367
 368         /*
 369          * The work may not be allowed to be queued up right now.
 370          * Possible reasons:
 371          * - Work has already been queued up or is in progress.
 372          * - The governor is being stopped.
 373          * - It is too early (too little time from the previous sample).
 374          */
 375         if (atomic_inc_return(&policy_dbs->work_count) == 1) {
 376                 u64 delta_ns;
 377
 378                 delta_ns = time - policy_dbs->last_sample_time;
 379                 if ((s64)delta_ns >= policy_dbs->sample_delay_ns) {
 380                         policy_dbs->last_sample_time = time;
 381                         gov_queue_irq_work(policy_dbs);
 382                         return;
 383                 }
 384         }
 385         atomic_dec(&policy_dbs->work_count);
 386 }
 387
 388 static struct policy_dbs_info *alloc_policy_dbs_info(struct cpufreq_policy *policy,
 389                                                      struct dbs_governor *gov)
 390 {
 391         struct policy_dbs_info *policy_dbs;
 392         int j;
 393
 394         /* Allocate memory for the common information for policy->cpus */
 395         policy_dbs = kzalloc(sizeof(*policy_dbs), GFP_KERNEL);
 396         if (!policy_dbs)
 397                 return NULL;
 398
 399         policy_dbs->policy = policy;
 400         mutex_init(&policy_dbs->timer_mutex);
 401         atomic_set(&policy_dbs->work_count, 0);
 402         init_irq_work(&policy_dbs->irq_work, dbs_irq_work);
 403         INIT_WORK(&policy_dbs->work, dbs_work_handler);
 404
 405         /* Set policy_dbs for all CPUs, online+offline */
 406         for_each_cpu(j, policy->related_cpus) {
 407                 struct cpu_dbs_info *j_cdbs = gov->get_cpu_cdbs(j);
 408
 409                 j_cdbs->policy_dbs = policy_dbs;
 410                 j_cdbs->update_util.func = dbs_update_util_handler;
 411         }
 412         return policy_dbs;
 413 }
 414
 415 static void free_policy_dbs_info(struct cpufreq_policy *policy,
 416                                  struct dbs_governor *gov)
 417 {
 418         struct cpu_dbs_info *cdbs = gov->get_cpu_cdbs(policy->cpu);
 419         struct policy_dbs_info *policy_dbs = cdbs->policy_dbs;
 420         int j;
 421
 422         mutex_destroy(&policy_dbs->timer_mutex);
 423
 424         for_each_cpu(j, policy->related_cpus) {
 425                 struct cpu_dbs_info *j_cdbs = gov->get_cpu_cdbs(j);
 426
 427                 j_cdbs->policy_dbs = NULL;
 428                 j_cdbs->update_util.func = NULL;
 429         }
 430         kfree(policy_dbs);
 431 }
 432
 433 static int cpufreq_governor_init(struct cpufreq_policy *policy)
 434 {
 435         struct dbs_governor *gov = dbs_governor_of(policy);
 436         struct dbs_data *dbs_data = gov->gdbs_data;
 437         struct policy_dbs_info *policy_dbs;
 438         unsigned int latency;
 439         int ret;
 440
 441         /* State should be equivalent to EXIT */
 442         if (policy->governor_data)
 443                 return -EBUSY;
 444
 445         policy_dbs = alloc_policy_dbs_info(policy, gov);
 446         if (!policy_dbs)
 447                 return -ENOMEM;
 448
 449         if (dbs_data) {
 450                 if (WARN_ON(have_governor_per_policy())) {
 451                         ret = -EINVAL;
 452                         goto free_policy_dbs_info;
 453                 }
 454                 policy_dbs->dbs_data = dbs_data;
 455                 policy->governor_data = policy_dbs;
 456
 457                 mutex_lock(&dbs_data->mutex);
 458                 dbs_data->usage_count++;
 459                 list_add(&policy_dbs->list, &dbs_data->policy_dbs_list);
 460                 mutex_unlock(&dbs_data->mutex);
 461
 462                 return 0;
 463         }
 464
 465         dbs_data = kzalloc(sizeof(*dbs_data), GFP_KERNEL);
 466         if (!dbs_data) {
 467                 ret = -ENOMEM;
 468                 goto free_policy_dbs_info;
 469         }
 470
 471         INIT_LIST_HEAD(&dbs_data->policy_dbs_list);
 472         mutex_init(&dbs_data->mutex);
 473
 474         ret = gov->init(dbs_data, !policy->governor->initialized);
 475         if (ret)
 476                 goto free_policy_dbs_info;
 477
 478         /* policy latency is in ns. Convert it to us first */
 479         latency = policy->cpuinfo.transition_latency / 1000;
 480         if (latency == 0)
 481                 latency = 1;
 482
 483         /* Bring kernel and HW constraints together */
 484         dbs_data->min_sampling_rate = max(dbs_data->min_sampling_rate,
 485                                           MIN_LATENCY_MULTIPLIER * latency);
 486         dbs_data->sampling_rate = max(dbs_data->min_sampling_rate,
 487                                       LATENCY_MULTIPLIER * latency);
 488
 489         if (!have_governor_per_policy())
 490                 gov->gdbs_data = dbs_data;
 491
 492         policy->governor_data = policy_dbs;
 493
 494         policy_dbs->dbs_data = dbs_data;
 495         dbs_data->usage_count = 1;
 496         list_add(&policy_dbs->list, &dbs_data->policy_dbs_list);
 497
 498         gov->kobj_type.sysfs_ops = &governor_sysfs_ops;
 499         ret = kobject_init_and_add(&dbs_data->kobj, &gov->kobj_type,
 500                                    get_governor_parent_kobj(policy),
 501                                    "%s", gov->gov.name);
 502         if (!ret)
 503                 return 0;
 504
 505         /* Failure, so roll back. */
 506         pr_err("cpufreq: Governor initialization failed (dbs_data kobject init error %d)\n", ret);
 507
 508         policy->governor_data = NULL;
 509
 510         if (!have_governor_per_policy())
 511                 gov->gdbs_data = NULL;
 512         gov->exit(dbs_data, !policy->governor->initialized);
 513         kfree(dbs_data);
 514
 515 free_policy_dbs_info:
 516         free_policy_dbs_info(policy, gov);
 517         return ret;
 518 }
 519
 520 static int cpufreq_governor_exit(struct cpufreq_policy *policy)
 521 {
 522         struct dbs_governor *gov = dbs_governor_of(policy);
 523         struct policy_dbs_info *policy_dbs = policy->governor_data;
 524         struct dbs_data *dbs_data = policy_dbs->dbs_data;
 525         int count;
 526
 527         mutex_lock(&dbs_data->mutex);
 528         list_del(&policy_dbs->list);
 529         count = --dbs_data->usage_count;
 530         mutex_unlock(&dbs_data->mutex);
 531
 532         if (!count) {
 533                 kobject_put(&dbs_data->kobj);
 534
 535                 policy->governor_data = NULL;
 536
 537                 if (!have_governor_per_policy())
 538                         gov->gdbs_data = NULL;
 539
 540                 gov->exit(dbs_data, policy->governor->initialized == 1);
 541                 mutex_destroy(&dbs_data->mutex);
 542                 kfree(dbs_data);
 543         } else {
 544                 policy->governor_data = NULL;
 545         }
 546
 547         free_policy_dbs_info(policy, gov);
 548         return 0;
 549 }
 550
 551 static int cpufreq_governor_start(struct cpufreq_policy *policy)
 552 {
 553         struct dbs_governor *gov = dbs_governor_of(policy);
 554         struct policy_dbs_info *policy_dbs = policy->governor_data;
 555         struct dbs_data *dbs_data = policy_dbs->dbs_data;
 556         unsigned int sampling_rate, ignore_nice, j, cpu = policy->cpu;
 557         int io_busy = 0;
 558
 559         if (!policy->cur)
 560                 return -EINVAL;
 561
 562         sampling_rate = dbs_data->sampling_rate;
 563         ignore_nice = dbs_data->ignore_nice_load;
 564
 565         if (gov->governor == GOV_ONDEMAND) {
 566                 struct od_dbs_tuners *od_tuners = dbs_data->tuners;
 567
 568                 io_busy = od_tuners->io_is_busy;
 569         }
 570
 571         for_each_cpu(j, policy->cpus) {
 572                 struct cpu_dbs_info *j_cdbs = gov->get_cpu_cdbs(j);
 573                 unsigned int prev_load;
 574
 575                 j_cdbs->prev_cpu_idle =
 576                         get_cpu_idle_time(j, &j_cdbs->prev_cpu_wall, io_busy);
 577
 578                 prev_load = (unsigned int)(j_cdbs->prev_cpu_wall -
 579                                             j_cdbs->prev_cpu_idle);
 580                 j_cdbs->prev_load = 100 * prev_load /
 581                                     (unsigned int)j_cdbs->prev_cpu_wall;
 582
 583                 if (ignore_nice)
 584                         j_cdbs->prev_cpu_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE];
 585         }
 586
 587         if (gov->governor == GOV_CONSERVATIVE) {
 588                 struct cs_cpu_dbs_info_s *cs_dbs_info =
 589                         gov->get_cpu_dbs_info_s(cpu);
 590
 591                 cs_dbs_info->down_skip = 0;
 592                 cs_dbs_info->requested_freq = policy->cur;
 593         } else {
 594                 struct od_ops *od_ops = gov->gov_ops;
 595                 struct od_cpu_dbs_info_s *od_dbs_info = gov->get_cpu_dbs_info_s(cpu);
 596
 597                 od_dbs_info->rate_mult = 1;
 598                 od_dbs_info->sample_type = OD_NORMAL_SAMPLE;
 599                 od_ops->powersave_bias_init_cpu(cpu);
 600         }
 601
 602         gov_set_update_util(policy_dbs, sampling_rate);
 603         return 0;
 604 }
 605
 606 static int cpufreq_governor_stop(struct cpufreq_policy *policy)
 607 {
 608         gov_cancel_work(policy);
 609
 610         return 0;
 611 }
 612
 613 static int cpufreq_governor_limits(struct cpufreq_policy *policy)
 614 {
 615         struct policy_dbs_info *policy_dbs = policy->governor_data;
 616
 617         mutex_lock(&policy_dbs->timer_mutex);
 618         if (policy->max < policy->cur)
 619                 __cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H);
 620         else if (policy->min > policy->cur)
 621                 __cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L);
 622         dbs_check_cpu(policy);
 623         mutex_unlock(&policy_dbs->timer_mutex);
 624
 625         return 0;
 626 }
 627
 628 int cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event)
 629 {
 630         int ret = -EINVAL;
 631
 632         /* Lock governor to block concurrent initialization of governor */
 633         mutex_lock(&dbs_data_mutex);
 634
 635         if (event == CPUFREQ_GOV_POLICY_INIT) {
 636                 ret = cpufreq_governor_init(policy);
 637         } else if (policy->governor_data) {
 638                 switch (event) {
 639                 case CPUFREQ_GOV_POLICY_EXIT:
 640                         ret = cpufreq_governor_exit(policy);
 641                         break;
 642                 case CPUFREQ_GOV_START:
 643                         ret = cpufreq_governor_start(policy);
 644                         break;
 645                 case CPUFREQ_GOV_STOP:
 646                         ret = cpufreq_governor_stop(policy);
 647                         break;
 648                 case CPUFREQ_GOV_LIMITS:
 649                         ret = cpufreq_governor_limits(policy);
 650                         break;
 651                 }
 652         }
 653
 654         mutex_unlock(&dbs_data_mutex);
 655         return ret;
 656 }
 657 EXPORT_SYMBOL_GPL(cpufreq_governor_dbs);