drivers/cpufreq/cpufreq.c

   1 /*
   2  *  linux/drivers/cpufreq/cpufreq.c
   3  *
   4  *  Copyright (C) 2001 Russell King
   5  *            (C) 2002 - 2003 Dominik Brodowski <linux@brodo.de>
   6  *            (C) 2013 Viresh Kumar <viresh.kumar@linaro.org>
   7  *
   8  *  Oct 2005 - Ashok Raj <ashok.raj@intel.com>
   9  *      Added handling for CPU hotplug
  10  *  Feb 2006 - Jacob Shin <jacob.shin@amd.com>
  11  *      Fix handling for CPU hotplug -- affected CPUs
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License version 2 as
  15  * published by the Free Software Foundation.
  16  */
  17
  18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include <linux/cpu.h>
  21 #include <linux/cpufreq.h>
  22 #include <linux/delay.h>
  23 #include <linux/device.h>
  24 #include <linux/init.h>
  25 #include <linux/kernel_stat.h>
  26 #include <linux/module.h>
  27 #include <linux/mutex.h>
  28 #include <linux/slab.h>
  29 #include <linux/syscore_ops.h>
  30 #include <linux/tick.h>
  31 #include <trace/events/power.h>
  32
  33 /**
  34  * The "cpufreq driver" - the arch- or hardware-dependent low
  35  * level driver of CPUFreq support, and its spinlock. This lock
  36  * also protects the cpufreq_cpu_data array.
  37  */
  38 static struct cpufreq_driver *cpufreq_driver;
  39 static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data);
  40 static DEFINE_PER_CPU(struct cpufreq_policy *, cpufreq_cpu_data_fallback);
  41 static DEFINE_RWLOCK(cpufreq_driver_lock);
  42 static DEFINE_MUTEX(cpufreq_governor_lock);
  43 static LIST_HEAD(cpufreq_policy_list);
  44
  45 #ifdef CONFIG_HOTPLUG_CPU
  46 /* This one keeps track of the previously set governor of a removed CPU */
  47 static DEFINE_PER_CPU(char[CPUFREQ_NAME_LEN], cpufreq_cpu_governor);
  48 #endif
  49
  50 /*
  51  * cpu_policy_rwsem is a per CPU reader-writer semaphore designed to cure
  52  * all cpufreq/hotplug/workqueue/etc related lock issues.
  53  *
  54  * The rules for this semaphore:
  55  * - Any routine that wants to read from the policy structure will
  56  *   do a down_read on this semaphore.
  57  * - Any routine that will write to the policy structure and/or may take away
  58  *   the policy altogether (eg. CPU hotplug), will hold this lock in write
  59  *   mode before doing so.
  60  *
  61  * Additional rules:
  62  * - Governor routines that can be called in cpufreq hotplug path should not
  63  *   take this sem as top level hotplug notifier handler takes this.
  64  * - Lock should not be held across
  65  *     __cpufreq_governor(data, CPUFREQ_GOV_STOP);
  66  */
  67 static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
  68
  69 #define lock_policy_rwsem(mode, cpu)                                    \
  70 static void lock_policy_rwsem_##mode(int cpu)                           \
  71 {                                                                       \
  72         struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); \
  73         BUG_ON(!policy);                                                \
  74         down_##mode(&per_cpu(cpu_policy_rwsem, policy->cpu));           \
  75 }
  76
  77 lock_policy_rwsem(read, cpu);
  78 lock_policy_rwsem(write, cpu);
  79
  80 #define unlock_policy_rwsem(mode, cpu)                                  \
  81 static void unlock_policy_rwsem_##mode(int cpu)                         \
  82 {                                                                       \
  83         struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); \
  84         BUG_ON(!policy);                                                \
  85         up_##mode(&per_cpu(cpu_policy_rwsem, policy->cpu));             \
  86 }
  87
  88 unlock_policy_rwsem(read, cpu);
  89 unlock_policy_rwsem(write, cpu);
  90
  91 /*
  92  * rwsem to guarantee that cpufreq driver module doesn't unload during critical
  93  * sections
  94  */
  95 static DECLARE_RWSEM(cpufreq_rwsem);
  96
  97 /* internal prototypes */
  98 static int __cpufreq_governor(struct cpufreq_policy *policy,
  99                 unsigned int event);
 100 static unsigned int __cpufreq_get(unsigned int cpu);
 101 static void handle_update(struct work_struct *work);
 102
 103 /**
 104  * Two notifier lists: the "policy" list is involved in the
 105  * validation process for a new CPU frequency policy; the
 106  * "transition" list for kernel code that needs to handle
 107  * changes to devices when the CPU clock speed changes.
 108  * The mutex locks both lists.
 109  */
 110 static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
 111 static struct srcu_notifier_head cpufreq_transition_notifier_list;
 112
 113 static bool init_cpufreq_transition_notifier_list_called;
 114 static int __init init_cpufreq_transition_notifier_list(void)
 115 {
 116         srcu_init_notifier_head(&cpufreq_transition_notifier_list);
 117         init_cpufreq_transition_notifier_list_called = true;
 118         return 0;
 119 }
 120 pure_initcall(init_cpufreq_transition_notifier_list);
 121
 122 static int off __read_mostly;
 123 static int cpufreq_disabled(void)
 124 {
 125         return off;
 126 }
 127 void disable_cpufreq(void)
 128 {
 129         off = 1;
 130 }
 131 static LIST_HEAD(cpufreq_governor_list);
 132 static DEFINE_MUTEX(cpufreq_governor_mutex);
 133
 134 bool have_governor_per_policy(void)
 135 {
 136         return !!(cpufreq_driver->flags & CPUFREQ_HAVE_GOVERNOR_PER_POLICY);
 137 }
 138 EXPORT_SYMBOL_GPL(have_governor_per_policy);
 139
 140 struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy)
 141 {
 142         if (have_governor_per_policy())
 143                 return &policy->kobj;
 144         else
 145                 return cpufreq_global_kobject;
 146 }
 147 EXPORT_SYMBOL_GPL(get_governor_parent_kobj);
 148
 149 static inline u64 get_cpu_idle_time_jiffy(unsigned int cpu, u64 *wall)
 150 {
 151         u64 idle_time;
 152         u64 cur_wall_time;
 153         u64 busy_time;
 154
 155         cur_wall_time = jiffies64_to_cputime64(get_jiffies_64());
 156
 157         busy_time = kcpustat_cpu(cpu).cpustat[CPUTIME_USER];
 158         busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SYSTEM];
 159         busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_IRQ];
 160         busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_SOFTIRQ];
 161         busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_STEAL];
 162         busy_time += kcpustat_cpu(cpu).cpustat[CPUTIME_NICE];
 163
 164         idle_time = cur_wall_time - busy_time;
 165         if (wall)
 166                 *wall = cputime_to_usecs(cur_wall_time);
 167
 168         return cputime_to_usecs(idle_time);
 169 }
 170
 171 u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy)
 172 {
 173         u64 idle_time = get_cpu_idle_time_us(cpu, io_busy ? wall : NULL);
 174
 175         if (idle_time == -1ULL)
 176                 return get_cpu_idle_time_jiffy(cpu, wall);
 177         else if (!io_busy)
 178                 idle_time += get_cpu_iowait_time_us(cpu, wall);
 179
 180         return idle_time;
 181 }
 182 EXPORT_SYMBOL_GPL(get_cpu_idle_time);
 183
 184 struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu)
 185 {
 186         struct cpufreq_policy *policy = NULL;
 187         unsigned long flags;
 188
 189         if (cpufreq_disabled() || (cpu >= nr_cpu_ids))
 190                 return NULL;
 191
 192         if (!down_read_trylock(&cpufreq_rwsem))
 193                 return NULL;
 194
 195         /* get the cpufreq driver */
 196         read_lock_irqsave(&cpufreq_driver_lock, flags);
 197
 198         if (cpufreq_driver) {
 199                 /* get the CPU */
 200                 policy = per_cpu(cpufreq_cpu_data, cpu);
 201                 if (policy)
 202                         kobject_get(&policy->kobj);
 203         }
 204
 205         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
 206
 207         if (!policy)
 208                 up_read(&cpufreq_rwsem);
 209
 210         return policy;
 211 }
 212 EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
 213
 214 void cpufreq_cpu_put(struct cpufreq_policy *policy)
 215 {
 216         if (cpufreq_disabled())
 217                 return;
 218
 219         kobject_put(&policy->kobj);
 220         up_read(&cpufreq_rwsem);
 221 }
 222 EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
 223
 224 /*********************************************************************
 225  *            EXTERNALLY AFFECTING FREQUENCY CHANGES                 *
 226  *********************************************************************/
 227
 228 /**
 229  * adjust_jiffies - adjust the system "loops_per_jiffy"
 230  *
 231  * This function alters the system "loops_per_jiffy" for the clock
 232  * speed change. Note that loops_per_jiffy cannot be updated on SMP
 233  * systems as each CPU might be scaled differently. So, use the arch
 234  * per-CPU loops_per_jiffy value wherever possible.
 235  */
 236 #ifndef CONFIG_SMP
 237 static unsigned long l_p_j_ref;
 238 static unsigned int l_p_j_ref_freq;
 239
 240 static void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
 241 {
 242         if (ci->flags & CPUFREQ_CONST_LOOPS)
 243                 return;
 244
 245         if (!l_p_j_ref_freq) {
 246                 l_p_j_ref = loops_per_jiffy;
 247                 l_p_j_ref_freq = ci->old;
 248                 pr_debug("saving %lu as reference value for loops_per_jiffy; "
 249                         "freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
 250         }
 251         if ((val == CPUFREQ_POSTCHANGE && ci->old != ci->new) ||
 252             (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
 253                 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq,
 254                                                                 ci->new);
 255                 pr_debug("scaling loops_per_jiffy to %lu "
 256                         "for frequency %u kHz\n", loops_per_jiffy, ci->new);
 257         }
 258 }
 259 #else
 260 static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
 261 {
 262         return;
 263 }
 264 #endif
 265
 266 static void __cpufreq_notify_transition(struct cpufreq_policy *policy,
 267                 struct cpufreq_freqs *freqs, unsigned int state)
 268 {
 269         BUG_ON(irqs_disabled());
 270
 271         if (cpufreq_disabled())
 272                 return;
 273
 274         freqs->flags = cpufreq_driver->flags;
 275         pr_debug("notification %u of frequency transition to %u kHz\n",
 276                 state, freqs->new);
 277
 278         switch (state) {
 279
 280         case CPUFREQ_PRECHANGE:
 281                 /* detect if the driver reported a value as "old frequency"
 282                  * which is not equal to what the cpufreq core thinks is
 283                  * "old frequency".
 284                  */
 285                 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
 286                         if ((policy) && (policy->cpu == freqs->cpu) &&
 287                             (policy->cur) && (policy->cur != freqs->old)) {
 288                                 pr_debug("Warning: CPU frequency is"
 289                                         " %u, cpufreq assumed %u kHz.\n",
 290                                         freqs->old, policy->cur);
 291                                 freqs->old = policy->cur;
 292                         }
 293                 }
 294                 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
 295                                 CPUFREQ_PRECHANGE, freqs);
 296                 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
 297                 break;
 298
 299         case CPUFREQ_POSTCHANGE:
 300                 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
 301                 pr_debug("FREQ: %lu - CPU: %lu", (unsigned long)freqs->new,
 302                         (unsigned long)freqs->cpu);
 303                 trace_cpu_frequency(freqs->new, freqs->cpu);
 304                 srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
 305                                 CPUFREQ_POSTCHANGE, freqs);
 306                 if (likely(policy) && likely(policy->cpu == freqs->cpu))
 307                         policy->cur = freqs->new;
 308                 break;
 309         }
 310 }
 311
 312 /**
 313  * cpufreq_notify_transition - call notifier chain and adjust_jiffies
 314  * on frequency transition.
 315  *
 316  * This function calls the transition notifiers and the "adjust_jiffies"
 317  * function. It is called twice on all CPU frequency changes that have
 318  * external effects.
 319  */
 320 void cpufreq_notify_transition(struct cpufreq_policy *policy,
 321                 struct cpufreq_freqs *freqs, unsigned int state)
 322 {
 323         for_each_cpu(freqs->cpu, policy->cpus)
 324                 __cpufreq_notify_transition(policy, freqs, state);
 325 }
 326 EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
 327
 328
 329 /*********************************************************************
 330  *                          SYSFS INTERFACE                          *
 331  *********************************************************************/
 332
 333 static struct cpufreq_governor *__find_governor(const char *str_governor)
 334 {
 335         struct cpufreq_governor *t;
 336
 337         list_for_each_entry(t, &cpufreq_governor_list, governor_list)
 338                 if (!strnicmp(str_governor, t->name, CPUFREQ_NAME_LEN))
 339                         return t;
 340
 341         return NULL;
 342 }
 343
 344 /**
 345  * cpufreq_parse_governor - parse a governor string
 346  */
 347 static int cpufreq_parse_governor(char *str_governor, unsigned int *policy,
 348                                 struct cpufreq_governor **governor)
 349 {
 350         int err = -EINVAL;
 351
 352         if (!cpufreq_driver)
 353                 goto out;
 354
 355         if (cpufreq_driver->setpolicy) {
 356                 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
 357                         *policy = CPUFREQ_POLICY_PERFORMANCE;
 358                         err = 0;
 359                 } else if (!strnicmp(str_governor, "powersave",
 360                                                 CPUFREQ_NAME_LEN)) {
 361                         *policy = CPUFREQ_POLICY_POWERSAVE;
 362                         err = 0;
 363                 }
 364         } else if (cpufreq_driver->target) {
 365                 struct cpufreq_governor *t;
 366
 367                 mutex_lock(&cpufreq_governor_mutex);
 368
 369                 t = __find_governor(str_governor);
 370
 371                 if (t == NULL) {
 372                         int ret;
 373
 374                         mutex_unlock(&cpufreq_governor_mutex);
 375                         ret = request_module("cpufreq_%s", str_governor);
 376                         mutex_lock(&cpufreq_governor_mutex);
 377
 378                         if (ret == 0)
 379                                 t = __find_governor(str_governor);
 380                 }
 381
 382                 if (t != NULL) {
 383                         *governor = t;
 384                         err = 0;
 385                 }
 386
 387                 mutex_unlock(&cpufreq_governor_mutex);
 388         }
 389 out:
 390         return err;
 391 }
 392
 393 /**
 394  * cpufreq_per_cpu_attr_read() / show_##file_name() -
 395  * print out cpufreq information
 396  *
 397  * Write out information from cpufreq_driver->policy[cpu]; object must be
 398  * "unsigned int".
 399  */
 400
 401 #define show_one(file_name, object)                     \
 402 static ssize_t show_##file_name                         \
 403 (struct cpufreq_policy *policy, char *buf)              \
 404 {                                                       \
 405         return sprintf(buf, "%u\n", policy->object);    \
 406 }
 407
 408 show_one(cpuinfo_min_freq, cpuinfo.min_freq);
 409 show_one(cpuinfo_max_freq, cpuinfo.max_freq);
 410 show_one(cpuinfo_transition_latency, cpuinfo.transition_latency);
 411 show_one(scaling_min_freq, min);
 412 show_one(scaling_max_freq, max);
 413 show_one(scaling_cur_freq, cur);
 414
 415 static int cpufreq_set_policy(struct cpufreq_policy *policy,
 416                                 struct cpufreq_policy *new_policy);
 417
 418 /**
 419  * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
 420  */
 421 #define store_one(file_name, object)                    \
 422 static ssize_t store_##file_name                                        \
 423 (struct cpufreq_policy *policy, const char *buf, size_t count)          \
 424 {                                                                       \
 425         int ret;                                                        \
 426         struct cpufreq_policy new_policy;                               \
 427                                                                         \
 428         ret = cpufreq_get_policy(&new_policy, policy->cpu);             \
 429         if (ret)                                                        \
 430                 return -EINVAL;                                         \
 431                                                                         \
 432         ret = sscanf(buf, "%u", &new_policy.object);                    \
 433         if (ret != 1)                                                   \
 434                 return -EINVAL;                                         \
 435                                                                         \
 436         ret = cpufreq_set_policy(policy, &new_policy);          \
 437         policy->user_policy.object = policy->object;                    \
 438                                                                         \
 439         return ret ? ret : count;                                       \
 440 }
 441
 442 store_one(scaling_min_freq, min);
 443 store_one(scaling_max_freq, max);
 444
 445 /**
 446  * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
 447  */
 448 static ssize_t show_cpuinfo_cur_freq(struct cpufreq_policy *policy,
 449                                         char *buf)
 450 {
 451         unsigned int cur_freq = __cpufreq_get(policy->cpu);
 452         if (!cur_freq)
 453                 return sprintf(buf, "<unknown>");
 454         return sprintf(buf, "%u\n", cur_freq);
 455 }
 456
 457 /**
 458  * show_scaling_governor - show the current policy for the specified CPU
 459  */
 460 static ssize_t show_scaling_governor(struct cpufreq_policy *policy, char *buf)
 461 {
 462         if (policy->policy == CPUFREQ_POLICY_POWERSAVE)
 463                 return sprintf(buf, "powersave\n");
 464         else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
 465                 return sprintf(buf, "performance\n");
 466         else if (policy->governor)
 467                 return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n",
 468                                 policy->governor->name);
 469         return -EINVAL;
 470 }
 471
 472 /**
 473  * store_scaling_governor - store policy for the specified CPU
 474  */
 475 static ssize_t store_scaling_governor(struct cpufreq_policy *policy,
 476                                         const char *buf, size_t count)
 477 {
 478         int ret;
 479         char    str_governor[16];
 480         struct cpufreq_policy new_policy;
 481
 482         ret = cpufreq_get_policy(&new_policy, policy->cpu);
 483         if (ret)
 484                 return ret;
 485
 486         ret = sscanf(buf, "%15s", str_governor);
 487         if (ret != 1)
 488                 return -EINVAL;
 489
 490         if (cpufreq_parse_governor(str_governor, &new_policy.policy,
 491                                                 &new_policy.governor))
 492                 return -EINVAL;
 493
 494         ret = cpufreq_set_policy(policy, &new_policy);
 495
 496         policy->user_policy.policy = policy->policy;
 497         policy->user_policy.governor = policy->governor;
 498
 499         if (ret)
 500                 return ret;
 501         else
 502                 return count;
 503 }
 504
 505 /**
 506  * show_scaling_driver - show the cpufreq driver currently loaded
 507  */
 508 static ssize_t show_scaling_driver(struct cpufreq_policy *policy, char *buf)
 509 {
 510         return scnprintf(buf, CPUFREQ_NAME_PLEN, "%s\n", cpufreq_driver->name);
 511 }
 512
 513 /**
 514  * show_scaling_available_governors - show the available CPUfreq governors
 515  */
 516 static ssize_t show_scaling_available_governors(struct cpufreq_policy *policy,
 517                                                 char *buf)
 518 {
 519         ssize_t i = 0;
 520         struct cpufreq_governor *t;
 521
 522         if (!cpufreq_driver->target) {
 523                 i += sprintf(buf, "performance powersave");
 524                 goto out;
 525         }
 526
 527         list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
 528                 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char))
 529                     - (CPUFREQ_NAME_LEN + 2)))
 530                         goto out;
 531                 i += scnprintf(&buf[i], CPUFREQ_NAME_PLEN, "%s ", t->name);
 532         }
 533 out:
 534         i += sprintf(&buf[i], "\n");
 535         return i;
 536 }
 537
 538 ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf)
 539 {
 540         ssize_t i = 0;
 541         unsigned int cpu;
 542
 543         for_each_cpu(cpu, mask) {
 544                 if (i)
 545                         i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
 546                 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
 547                 if (i >= (PAGE_SIZE - 5))
 548                         break;
 549         }
 550         i += sprintf(&buf[i], "\n");
 551         return i;
 552 }
 553 EXPORT_SYMBOL_GPL(cpufreq_show_cpus);
 554
 555 /**
 556  * show_related_cpus - show the CPUs affected by each transition even if
 557  * hw coordination is in use
 558  */
 559 static ssize_t show_related_cpus(struct cpufreq_policy *policy, char *buf)
 560 {
 561         return cpufreq_show_cpus(policy->related_cpus, buf);
 562 }
 563
 564 /**
 565  * show_affected_cpus - show the CPUs affected by each transition
 566  */
 567 static ssize_t show_affected_cpus(struct cpufreq_policy *policy, char *buf)
 568 {
 569         return cpufreq_show_cpus(policy->cpus, buf);
 570 }
 571
 572 static ssize_t store_scaling_setspeed(struct cpufreq_policy *policy,
 573                                         const char *buf, size_t count)
 574 {
 575         unsigned int freq = 0;
 576         unsigned int ret;
 577
 578         if (!policy->governor || !policy->governor->store_setspeed)
 579                 return -EINVAL;
 580
 581         ret = sscanf(buf, "%u", &freq);
 582         if (ret != 1)
 583                 return -EINVAL;
 584
 585         policy->governor->store_setspeed(policy, freq);
 586
 587         return count;
 588 }
 589
 590 static ssize_t show_scaling_setspeed(struct cpufreq_policy *policy, char *buf)
 591 {
 592         if (!policy->governor || !policy->governor->show_setspeed)
 593                 return sprintf(buf, "<unsupported>\n");
 594
 595         return policy->governor->show_setspeed(policy, buf);
 596 }
 597
 598 /**
 599  * show_bios_limit - show the current cpufreq HW/BIOS limitation
 600  */
 601 static ssize_t show_bios_limit(struct cpufreq_policy *policy, char *buf)
 602 {
 603         unsigned int limit;
 604         int ret;
 605         if (cpufreq_driver->bios_limit) {
 606                 ret = cpufreq_driver->bios_limit(policy->cpu, &limit);
 607                 if (!ret)
 608                         return sprintf(buf, "%u\n", limit);
 609         }
 610         return sprintf(buf, "%u\n", policy->cpuinfo.max_freq);
 611 }
 612
 613 cpufreq_freq_attr_ro_perm(cpuinfo_cur_freq, 0400);
 614 cpufreq_freq_attr_ro(cpuinfo_min_freq);
 615 cpufreq_freq_attr_ro(cpuinfo_max_freq);
 616 cpufreq_freq_attr_ro(cpuinfo_transition_latency);
 617 cpufreq_freq_attr_ro(scaling_available_governors);
 618 cpufreq_freq_attr_ro(scaling_driver);
 619 cpufreq_freq_attr_ro(scaling_cur_freq);
 620 cpufreq_freq_attr_ro(bios_limit);
 621 cpufreq_freq_attr_ro(related_cpus);
 622 cpufreq_freq_attr_ro(affected_cpus);
 623 cpufreq_freq_attr_rw(scaling_min_freq);
 624 cpufreq_freq_attr_rw(scaling_max_freq);
 625 cpufreq_freq_attr_rw(scaling_governor);
 626 cpufreq_freq_attr_rw(scaling_setspeed);
 627
 628 static struct attribute *default_attrs[] = {
 629         &cpuinfo_min_freq.attr,
 630         &cpuinfo_max_freq.attr,
 631         &cpuinfo_transition_latency.attr,
 632         &scaling_min_freq.attr,
 633         &scaling_max_freq.attr,
 634         &affected_cpus.attr,
 635         &related_cpus.attr,
 636         &scaling_governor.attr,
 637         &scaling_driver.attr,
 638         &scaling_available_governors.attr,
 639         &scaling_setspeed.attr,
 640         NULL
 641 };
 642
 643 #define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
 644 #define to_attr(a) container_of(a, struct freq_attr, attr)
 645
 646 static ssize_t show(struct kobject *kobj, struct attribute *attr, char *buf)
 647 {
 648         struct cpufreq_policy *policy = to_policy(kobj);
 649         struct freq_attr *fattr = to_attr(attr);
 650         ssize_t ret;
 651
 652         if (!down_read_trylock(&cpufreq_rwsem))
 653                 return -EINVAL;
 654
 655         lock_policy_rwsem_read(policy->cpu);
 656
 657         if (fattr->show)
 658                 ret = fattr->show(policy, buf);
 659         else
 660                 ret = -EIO;
 661
 662         unlock_policy_rwsem_read(policy->cpu);
 663         up_read(&cpufreq_rwsem);
 664
 665         return ret;
 666 }
 667
 668 static ssize_t store(struct kobject *kobj, struct attribute *attr,
 669                      const char *buf, size_t count)
 670 {
 671         struct cpufreq_policy *policy = to_policy(kobj);
 672         struct freq_attr *fattr = to_attr(attr);
 673         ssize_t ret = -EINVAL;
 674
 675         get_online_cpus();
 676
 677         if (!cpu_online(policy->cpu))
 678                 goto unlock;
 679
 680         if (!down_read_trylock(&cpufreq_rwsem))
 681                 goto unlock;
 682
 683         lock_policy_rwsem_write(policy->cpu);
 684
 685         if (fattr->store)
 686                 ret = fattr->store(policy, buf, count);
 687         else
 688                 ret = -EIO;
 689
 690         unlock_policy_rwsem_write(policy->cpu);
 691
 692         up_read(&cpufreq_rwsem);
 693 unlock:
 694         put_online_cpus();
 695
 696         return ret;
 697 }
 698
 699 static void cpufreq_sysfs_release(struct kobject *kobj)
 700 {
 701         struct cpufreq_policy *policy = to_policy(kobj);
 702         pr_debug("last reference is dropped\n");
 703         complete(&policy->kobj_unregister);
 704 }
 705
 706 static const struct sysfs_ops sysfs_ops = {
 707         .show   = show,
 708         .store  = store,
 709 };
 710
 711 static struct kobj_type ktype_cpufreq = {
 712         .sysfs_ops      = &sysfs_ops,
 713         .default_attrs  = default_attrs,
 714         .release        = cpufreq_sysfs_release,
 715 };
 716
 717 struct kobject *cpufreq_global_kobject;
 718 EXPORT_SYMBOL(cpufreq_global_kobject);
 719
 720 static int cpufreq_global_kobject_usage;
 721
 722 int cpufreq_get_global_kobject(void)
 723 {
 724         if (!cpufreq_global_kobject_usage++)
 725                 return kobject_add(cpufreq_global_kobject,
 726                                 &cpu_subsys.dev_root->kobj, "%s", "cpufreq");
 727
 728         return 0;
 729 }
 730 EXPORT_SYMBOL(cpufreq_get_global_kobject);
 731
 732 void cpufreq_put_global_kobject(void)
 733 {
 734         if (!--cpufreq_global_kobject_usage)
 735                 kobject_del(cpufreq_global_kobject);
 736 }
 737 EXPORT_SYMBOL(cpufreq_put_global_kobject);
 738
 739 int cpufreq_sysfs_create_file(const struct attribute *attr)
 740 {
 741         int ret = cpufreq_get_global_kobject();
 742
 743         if (!ret) {
 744                 ret = sysfs_create_file(cpufreq_global_kobject, attr);
 745                 if (ret)
 746                         cpufreq_put_global_kobject();
 747         }
 748
 749         return ret;
 750 }
 751 EXPORT_SYMBOL(cpufreq_sysfs_create_file);
 752
 753 void cpufreq_sysfs_remove_file(const struct attribute *attr)
 754 {
 755         sysfs_remove_file(cpufreq_global_kobject, attr);
 756         cpufreq_put_global_kobject();
 757 }
 758 EXPORT_SYMBOL(cpufreq_sysfs_remove_file);
 759
 760 /* symlink affected CPUs */
 761 static int cpufreq_add_dev_symlink(struct cpufreq_policy *policy)
 762 {
 763         unsigned int j;
 764         int ret = 0;
 765
 766         for_each_cpu(j, policy->cpus) {
 767                 struct device *cpu_dev;
 768
 769                 if (j == policy->cpu)
 770                         continue;
 771
 772                 pr_debug("Adding link for CPU: %u\n", j);
 773                 cpu_dev = get_cpu_device(j);
 774                 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
 775                                         "cpufreq");
 776                 if (ret)
 777                         break;
 778         }
 779         return ret;
 780 }
 781
 782 static int cpufreq_add_dev_interface(struct cpufreq_policy *policy,
 783                                      struct device *dev)
 784 {
 785         struct freq_attr **drv_attr;
 786         int ret = 0;
 787
 788         /* prepare interface data */
 789         ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
 790                                    &dev->kobj, "cpufreq");
 791         if (ret)
 792                 return ret;
 793
 794         /* set up files for this cpu device */
 795         drv_attr = cpufreq_driver->attr;
 796         while ((drv_attr) && (*drv_attr)) {
 797                 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
 798                 if (ret)
 799                         goto err_out_kobj_put;
 800                 drv_attr++;
 801         }
 802         if (cpufreq_driver->get) {
 803                 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
 804                 if (ret)
 805                         goto err_out_kobj_put;
 806         }
 807         if (cpufreq_driver->target) {
 808                 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
 809                 if (ret)
 810                         goto err_out_kobj_put;
 811         }
 812         if (cpufreq_driver->bios_limit) {
 813                 ret = sysfs_create_file(&policy->kobj, &bios_limit.attr);
 814                 if (ret)
 815                         goto err_out_kobj_put;
 816         }
 817
 818         ret = cpufreq_add_dev_symlink(policy);
 819         if (ret)
 820                 goto err_out_kobj_put;
 821
 822         return ret;
 823
 824 err_out_kobj_put:
 825         kobject_put(&policy->kobj);
 826         wait_for_completion(&policy->kobj_unregister);
 827         return ret;
 828 }
 829
 830 static void cpufreq_init_policy(struct cpufreq_policy *policy)
 831 {
 832         struct cpufreq_policy new_policy;
 833         int ret = 0;
 834
 835         memcpy(&new_policy, policy, sizeof(*policy));
 836         /* assure that the starting sequence is run in cpufreq_set_policy */
 837         policy->governor = NULL;
 838
 839         /* set default policy */
 840         ret = cpufreq_set_policy(policy, &new_policy);
 841         policy->user_policy.policy = policy->policy;
 842         policy->user_policy.governor = policy->governor;
 843
 844         if (ret) {
 845                 pr_debug("setting policy failed\n");
 846                 if (cpufreq_driver->exit)
 847                         cpufreq_driver->exit(policy);
 848         }
 849 }
 850
 851 #ifdef CONFIG_HOTPLUG_CPU
 852 static int cpufreq_add_policy_cpu(struct cpufreq_policy *policy,
 853                                   unsigned int cpu, struct device *dev,
 854                                   bool frozen)
 855 {
 856         int ret = 0, has_target = !!cpufreq_driver->target;
 857         unsigned long flags;
 858
 859         if (has_target) {
 860                 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
 861                 if (ret) {
 862                         pr_err("%s: Failed to stop governor\n", __func__);
 863                         return ret;
 864                 }
 865         }
 866
 867         lock_policy_rwsem_write(policy->cpu);
 868
 869         write_lock_irqsave(&cpufreq_driver_lock, flags);
 870
 871         cpumask_set_cpu(cpu, policy->cpus);
 872         per_cpu(cpufreq_cpu_data, cpu) = policy;
 873         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
 874
 875         unlock_policy_rwsem_write(policy->cpu);
 876
 877         if (has_target) {
 878                 if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
 879                         (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
 880                         pr_err("%s: Failed to start governor\n", __func__);
 881                         return ret;
 882                 }
 883         }
 884
 885         /* Don't touch sysfs links during light-weight init */
 886         if (!frozen)
 887                 ret = sysfs_create_link(&dev->kobj, &policy->kobj, "cpufreq");
 888
 889         return ret;
 890 }
 891 #endif
 892
 893 static struct cpufreq_policy *cpufreq_policy_restore(unsigned int cpu)
 894 {
 895         struct cpufreq_policy *policy;
 896         unsigned long flags;
 897
 898         read_lock_irqsave(&cpufreq_driver_lock, flags);
 899
 900         policy = per_cpu(cpufreq_cpu_data_fallback, cpu);
 901
 902         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
 903
 904         return policy;
 905 }
 906
 907 static struct cpufreq_policy *cpufreq_policy_alloc(void)
 908 {
 909         struct cpufreq_policy *policy;
 910
 911         policy = kzalloc(sizeof(*policy), GFP_KERNEL);
 912         if (!policy)
 913                 return NULL;
 914
 915         if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
 916                 goto err_free_policy;
 917
 918         if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
 919                 goto err_free_cpumask;
 920
 921         INIT_LIST_HEAD(&policy->policy_list);
 922         return policy;
 923
 924 err_free_cpumask:
 925         free_cpumask_var(policy->cpus);
 926 err_free_policy:
 927         kfree(policy);
 928
 929         return NULL;
 930 }
 931
 932 static void cpufreq_policy_free(struct cpufreq_policy *policy)
 933 {
 934         free_cpumask_var(policy->related_cpus);
 935         free_cpumask_var(policy->cpus);
 936         kfree(policy);
 937 }
 938
 939 static void update_policy_cpu(struct cpufreq_policy *policy, unsigned int cpu)
 940 {
 941         if (cpu == policy->cpu)
 942                 return;
 943
 944         /*
 945          * Take direct locks as lock_policy_rwsem_write wouldn't work here.
 946          * Also lock for last cpu is enough here as contention will happen only
 947          * after policy->cpu is changed and after it is changed, other threads
 948          * will try to acquire lock for new cpu. And policy is already updated
 949          * by then.
 950          */
 951         down_write(&per_cpu(cpu_policy_rwsem, policy->cpu));
 952
 953         policy->last_cpu = policy->cpu;
 954         policy->cpu = cpu;
 955
 956         up_write(&per_cpu(cpu_policy_rwsem, policy->last_cpu));
 957
 958 #ifdef CONFIG_CPU_FREQ_TABLE
 959         cpufreq_frequency_table_update_policy_cpu(policy);
 960 #endif
 961         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
 962                         CPUFREQ_UPDATE_POLICY_CPU, policy);
 963 }
 964
 965 static int __cpufreq_add_dev(struct device *dev, struct subsys_interface *sif,
 966                              bool frozen)
 967 {
 968         unsigned int j, cpu = dev->id;
 969         int ret = -ENOMEM;
 970         struct cpufreq_policy *policy;
 971         unsigned long flags;
 972 #ifdef CONFIG_HOTPLUG_CPU
 973         struct cpufreq_policy *tpolicy;
 974         struct cpufreq_governor *gov;
 975 #endif
 976
 977         if (cpu_is_offline(cpu))
 978                 return 0;
 979
 980         pr_debug("adding CPU %u\n", cpu);
 981
 982 #ifdef CONFIG_SMP
 983         /* check whether a different CPU already registered this
 984          * CPU because it is in the same boat. */
 985         policy = cpufreq_cpu_get(cpu);
 986         if (unlikely(policy)) {
 987                 cpufreq_cpu_put(policy);
 988                 return 0;
 989         }
 990 #endif
 991
 992         if (!down_read_trylock(&cpufreq_rwsem))
 993                 return 0;
 994
 995 #ifdef CONFIG_HOTPLUG_CPU
 996         /* Check if this cpu was hot-unplugged earlier and has siblings */
 997         read_lock_irqsave(&cpufreq_driver_lock, flags);
 998         list_for_each_entry(tpolicy, &cpufreq_policy_list, policy_list) {
 999                 if (cpumask_test_cpu(cpu, tpolicy->related_cpus)) {
1000                         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1001                         ret = cpufreq_add_policy_cpu(tpolicy, cpu, dev, frozen);
1002                         up_read(&cpufreq_rwsem);
1003                         return ret;
1004                 }
1005         }
1006         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1007 #endif
1008
1009         if (frozen)
1010                 /* Restore the saved policy when doing light-weight init */
1011                 policy = cpufreq_policy_restore(cpu);
1012         else
1013                 policy = cpufreq_policy_alloc();
1014
1015         if (!policy)
1016                 goto nomem_out;
1017
1018
1019         /*
1020          * In the resume path, since we restore a saved policy, the assignment
1021          * to policy->cpu is like an update of the existing policy, rather than
1022          * the creation of a brand new one. So we need to perform this update
1023          * by invoking update_policy_cpu().
1024          */
1025         if (frozen && cpu != policy->cpu)
1026                 update_policy_cpu(policy, cpu);
1027         else
1028                 policy->cpu = cpu;
1029
1030         policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
1031         cpumask_copy(policy->cpus, cpumask_of(cpu));
1032
1033         init_completion(&policy->kobj_unregister);
1034         INIT_WORK(&policy->update, handle_update);
1035
1036         /* call driver. From then on the cpufreq must be able
1037          * to accept all calls to ->verify and ->setpolicy for this CPU
1038          */
1039         ret = cpufreq_driver->init(policy);
1040         if (ret) {
1041                 pr_debug("initialization failed\n");
1042                 goto err_set_policy_cpu;
1043         }
1044
1045         /* related cpus should atleast have policy->cpus */
1046         cpumask_or(policy->related_cpus, policy->related_cpus, policy->cpus);
1047
1048         /*
1049          * affected cpus must always be the one, which are online. We aren't
1050          * managing offline cpus here.
1051          */
1052         cpumask_and(policy->cpus, policy->cpus, cpu_online_mask);
1053
1054         policy->user_policy.min = policy->min;
1055         policy->user_policy.max = policy->max;
1056
1057         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1058                                      CPUFREQ_START, policy);
1059
1060 #ifdef CONFIG_HOTPLUG_CPU
1061         gov = __find_governor(per_cpu(cpufreq_cpu_governor, cpu));
1062         if (gov) {
1063                 policy->governor = gov;
1064                 pr_debug("Restoring governor %s for cpu %d\n",
1065                        policy->governor->name, cpu);
1066         }
1067 #endif
1068
1069         write_lock_irqsave(&cpufreq_driver_lock, flags);
1070         for_each_cpu(j, policy->cpus)
1071                 per_cpu(cpufreq_cpu_data, j) = policy;
1072         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1073
1074         if (!frozen) {
1075                 ret = cpufreq_add_dev_interface(policy, dev);
1076                 if (ret)
1077                         goto err_out_unregister;
1078         }
1079
1080         write_lock_irqsave(&cpufreq_driver_lock, flags);
1081         list_add(&policy->policy_list, &cpufreq_policy_list);
1082         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1083
1084         cpufreq_init_policy(policy);
1085
1086         kobject_uevent(&policy->kobj, KOBJ_ADD);
1087         up_read(&cpufreq_rwsem);
1088
1089         pr_debug("initialization complete\n");
1090
1091         return 0;
1092
1093 err_out_unregister:
1094         write_lock_irqsave(&cpufreq_driver_lock, flags);
1095         for_each_cpu(j, policy->cpus)
1096                 per_cpu(cpufreq_cpu_data, j) = NULL;
1097         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1098
1099 err_set_policy_cpu:
1100         cpufreq_policy_free(policy);
1101 nomem_out:
1102         up_read(&cpufreq_rwsem);
1103
1104         return ret;
1105 }
1106
1107 /**
1108  * cpufreq_add_dev - add a CPU device
1109  *
1110  * Adds the cpufreq interface for a CPU device.
1111  *
1112  * The Oracle says: try running cpufreq registration/unregistration concurrently
1113  * with with cpu hotplugging and all hell will break loose. Tried to clean this
1114  * mess up, but more thorough testing is needed. - Mathieu
1115  */
1116 static int cpufreq_add_dev(struct device *dev, struct subsys_interface *sif)
1117 {
1118         return __cpufreq_add_dev(dev, sif, false);
1119 }
1120
1121 static int cpufreq_nominate_new_policy_cpu(struct cpufreq_policy *policy,
1122                                            unsigned int old_cpu, bool frozen)
1123 {
1124         struct device *cpu_dev;
1125         int ret;
1126
1127         /* first sibling now owns the new sysfs dir */
1128         cpu_dev = get_cpu_device(cpumask_any_but(policy->cpus, old_cpu));
1129
1130         /* Don't touch sysfs files during light-weight tear-down */
1131         if (frozen)
1132                 return cpu_dev->id;
1133
1134         sysfs_remove_link(&cpu_dev->kobj, "cpufreq");
1135         ret = kobject_move(&policy->kobj, &cpu_dev->kobj);
1136         if (ret) {
1137                 pr_err("%s: Failed to move kobj: %d", __func__, ret);
1138
1139                 lock_policy_rwsem_write(old_cpu);
1140                 cpumask_set_cpu(old_cpu, policy->cpus);
1141                 unlock_policy_rwsem_write(old_cpu);
1142
1143                 ret = sysfs_create_link(&cpu_dev->kobj, &policy->kobj,
1144                                         "cpufreq");
1145
1146                 return -EINVAL;
1147         }
1148
1149         return cpu_dev->id;
1150 }
1151
1152 static int __cpufreq_remove_dev_prepare(struct device *dev,
1153                                         struct subsys_interface *sif,
1154                                         bool frozen)
1155 {
1156         unsigned int cpu = dev->id, cpus;
1157         int new_cpu, ret;
1158         unsigned long flags;
1159         struct cpufreq_policy *policy;
1160
1161         pr_debug("%s: unregistering CPU %u\n", __func__, cpu);
1162
1163         write_lock_irqsave(&cpufreq_driver_lock, flags);
1164
1165         policy = per_cpu(cpufreq_cpu_data, cpu);
1166
1167         /* Save the policy somewhere when doing a light-weight tear-down */
1168         if (frozen)
1169                 per_cpu(cpufreq_cpu_data_fallback, cpu) = policy;
1170
1171         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1172
1173         if (!policy) {
1174                 pr_debug("%s: No cpu_data found\n", __func__);
1175                 return -EINVAL;
1176         }
1177
1178         if (cpufreq_driver->target) {
1179                 ret = __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1180                 if (ret) {
1181                         pr_err("%s: Failed to stop governor\n", __func__);
1182                         return ret;
1183                 }
1184         }
1185
1186 #ifdef CONFIG_HOTPLUG_CPU
1187         if (!cpufreq_driver->setpolicy)
1188                 strncpy(per_cpu(cpufreq_cpu_governor, cpu),
1189                         policy->governor->name, CPUFREQ_NAME_LEN);
1190 #endif
1191
1192         lock_policy_rwsem_read(cpu);
1193         cpus = cpumask_weight(policy->cpus);
1194         unlock_policy_rwsem_read(cpu);
1195
1196         if (cpu != policy->cpu) {
1197                 if (!frozen)
1198                         sysfs_remove_link(&dev->kobj, "cpufreq");
1199         } else if (cpus > 1) {
1200                 new_cpu = cpufreq_nominate_new_policy_cpu(policy, cpu, frozen);
1201                 if (new_cpu >= 0) {
1202                         update_policy_cpu(policy, new_cpu);
1203
1204                         if (!frozen) {
1205                                 pr_debug("%s: policy Kobject moved to cpu: %d from: %d\n",
1206                                                 __func__, new_cpu, cpu);
1207                         }
1208                 }
1209         }
1210
1211         return 0;
1212 }
1213
1214 static int __cpufreq_remove_dev_finish(struct device *dev,
1215                                        struct subsys_interface *sif,
1216                                        bool frozen)
1217 {
1218         unsigned int cpu = dev->id, cpus;
1219         int ret;
1220         unsigned long flags;
1221         struct cpufreq_policy *policy;
1222         struct kobject *kobj;
1223         struct completion *cmp;
1224
1225         read_lock_irqsave(&cpufreq_driver_lock, flags);
1226         policy = per_cpu(cpufreq_cpu_data, cpu);
1227         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1228
1229         if (!policy) {
1230                 pr_debug("%s: No cpu_data found\n", __func__);
1231                 return -EINVAL;
1232         }
1233
1234         lock_policy_rwsem_write(cpu);
1235         cpus = cpumask_weight(policy->cpus);
1236
1237         if (cpus > 1)
1238                 cpumask_clear_cpu(cpu, policy->cpus);
1239         unlock_policy_rwsem_write(cpu);
1240
1241         /* If cpu is last user of policy, free policy */
1242         if (cpus == 1) {
1243                 if (cpufreq_driver->target) {
1244                         ret = __cpufreq_governor(policy,
1245                                         CPUFREQ_GOV_POLICY_EXIT);
1246                         if (ret) {
1247                                 pr_err("%s: Failed to exit governor\n",
1248                                                 __func__);
1249                                 return ret;
1250                         }
1251                 }
1252
1253                 if (!frozen) {
1254                         lock_policy_rwsem_read(cpu);
1255                         kobj = &policy->kobj;
1256                         cmp = &policy->kobj_unregister;
1257                         unlock_policy_rwsem_read(cpu);
1258                         kobject_put(kobj);
1259
1260                         /*
1261                          * We need to make sure that the underlying kobj is
1262                          * actually not referenced anymore by anybody before we
1263                          * proceed with unloading.
1264                          */
1265                         pr_debug("waiting for dropping of refcount\n");
1266                         wait_for_completion(cmp);
1267                         pr_debug("wait complete\n");
1268                 }
1269
1270                 /*
1271                  * Perform the ->exit() even during light-weight tear-down,
1272                  * since this is a core component, and is essential for the
1273                  * subsequent light-weight ->init() to succeed.
1274                  */
1275                 if (cpufreq_driver->exit)
1276                         cpufreq_driver->exit(policy);
1277
1278                 /* Remove policy from list of active policies */
1279                 write_lock_irqsave(&cpufreq_driver_lock, flags);
1280                 list_del(&policy->policy_list);
1281                 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
1282
1283                 if (!frozen)
1284                         cpufreq_policy_free(policy);
1285         } else {
1286                 if (cpufreq_driver->target) {
1287                         if ((ret = __cpufreq_governor(policy, CPUFREQ_GOV_START)) ||
1288                                         (ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS))) {
1289                                 pr_err("%s: Failed to start governor\n",
1290                                                 __func__);
1291                                 return ret;
1292                         }
1293                 }
1294         }
1295
1296         per_cpu(cpufreq_cpu_data, cpu) = NULL;
1297         return 0;
1298 }
1299
1300 /**
1301  * cpufreq_remove_dev - remove a CPU device
1302  *
1303  * Removes the cpufreq interface for a CPU device.
1304  */
1305 static int cpufreq_remove_dev(struct device *dev, struct subsys_interface *sif)
1306 {
1307         unsigned int cpu = dev->id;
1308         int ret;
1309
1310         if (cpu_is_offline(cpu))
1311                 return 0;
1312
1313         ret = __cpufreq_remove_dev_prepare(dev, sif, false);
1314
1315         if (!ret)
1316                 ret = __cpufreq_remove_dev_finish(dev, sif, false);
1317
1318         return ret;
1319 }
1320
1321 static void handle_update(struct work_struct *work)
1322 {
1323         struct cpufreq_policy *policy =
1324                 container_of(work, struct cpufreq_policy, update);
1325         unsigned int cpu = policy->cpu;
1326         pr_debug("handle_update for cpu %u called\n", cpu);
1327         cpufreq_update_policy(cpu);
1328 }
1329
1330 /**
1331  *      cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're
1332  *      in deep trouble.
1333  *      @cpu: cpu number
1334  *      @old_freq: CPU frequency the kernel thinks the CPU runs at
1335  *      @new_freq: CPU frequency the CPU actually runs at
1336  *
1337  *      We adjust to current frequency first, and need to clean up later.
1338  *      So either call to cpufreq_update_policy() or schedule handle_update()).
1339  */
1340 static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq,
1341                                 unsigned int new_freq)
1342 {
1343         struct cpufreq_policy *policy;
1344         struct cpufreq_freqs freqs;
1345         unsigned long flags;
1346
1347         pr_debug("Warning: CPU frequency out of sync: cpufreq and timing "
1348                "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
1349
1350         freqs.old = old_freq;
1351         freqs.new = new_freq;
1352
1353         read_lock_irqsave(&cpufreq_driver_lock, flags);
1354         policy = per_cpu(cpufreq_cpu_data, cpu);
1355         read_unlock_irqrestore(&cpufreq_driver_lock, flags);
1356
1357         cpufreq_notify_transition(policy, &freqs, CPUFREQ_PRECHANGE);
1358         cpufreq_notify_transition(policy, &freqs, CPUFREQ_POSTCHANGE);
1359 }
1360
1361 /**
1362  * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur
1363  * @cpu: CPU number
1364  *
1365  * This is the last known freq, without actually getting it from the driver.
1366  * Return value will be same as what is shown in scaling_cur_freq in sysfs.
1367  */
1368 unsigned int cpufreq_quick_get(unsigned int cpu)
1369 {
1370         struct cpufreq_policy *policy;
1371         unsigned int ret_freq = 0;
1372
1373         if (cpufreq_driver && cpufreq_driver->setpolicy && cpufreq_driver->get)
1374                 return cpufreq_driver->get(cpu);
1375
1376         policy = cpufreq_cpu_get(cpu);
1377         if (policy) {
1378                 ret_freq = policy->cur;
1379                 cpufreq_cpu_put(policy);
1380         }
1381
1382         return ret_freq;
1383 }
1384 EXPORT_SYMBOL(cpufreq_quick_get);
1385
1386 /**
1387  * cpufreq_quick_get_max - get the max reported CPU frequency for this CPU
1388  * @cpu: CPU number
1389  *
1390  * Just return the max possible frequency for a given CPU.
1391  */
1392 unsigned int cpufreq_quick_get_max(unsigned int cpu)
1393 {
1394         struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1395         unsigned int ret_freq = 0;
1396
1397         if (policy) {
1398                 ret_freq = policy->max;
1399                 cpufreq_cpu_put(policy);
1400         }
1401
1402         return ret_freq;
1403 }
1404 EXPORT_SYMBOL(cpufreq_quick_get_max);
1405
1406 static unsigned int __cpufreq_get(unsigned int cpu)
1407 {
1408         struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu);
1409         unsigned int ret_freq = 0;
1410
1411         if (!cpufreq_driver->get)
1412                 return ret_freq;
1413
1414         ret_freq = cpufreq_driver->get(cpu);
1415
1416         if (ret_freq && policy->cur &&
1417                 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
1418                 /* verify no discrepancy between actual and
1419                                         saved value exists */
1420                 if (unlikely(ret_freq != policy->cur)) {
1421                         cpufreq_out_of_sync(cpu, policy->cur, ret_freq);
1422                         schedule_work(&policy->update);
1423                 }
1424         }
1425
1426         return ret_freq;
1427 }
1428
1429 /**
1430  * cpufreq_get - get the current CPU frequency (in kHz)
1431  * @cpu: CPU number
1432  *
1433  * Get the CPU current (static) CPU frequency
1434  */
1435 unsigned int cpufreq_get(unsigned int cpu)
1436 {
1437         unsigned int ret_freq = 0;
1438
1439         if (cpufreq_disabled() || !cpufreq_driver)
1440                 return -ENOENT;
1441
1442         if (!down_read_trylock(&cpufreq_rwsem))
1443                 return 0;
1444
1445         lock_policy_rwsem_read(cpu);
1446
1447         ret_freq = __cpufreq_get(cpu);
1448
1449         unlock_policy_rwsem_read(cpu);
1450         up_read(&cpufreq_rwsem);
1451
1452         return ret_freq;
1453 }
1454 EXPORT_SYMBOL(cpufreq_get);
1455
1456 static struct subsys_interface cpufreq_interface = {
1457         .name           = "cpufreq",
1458         .subsys         = &cpu_subsys,
1459         .add_dev        = cpufreq_add_dev,
1460         .remove_dev     = cpufreq_remove_dev,
1461 };
1462
1463 /**
1464  * cpufreq_bp_suspend - Prepare the boot CPU for system suspend.
1465  *
1466  * This function is only executed for the boot processor.  The other CPUs
1467  * have been put offline by means of CPU hotplug.
1468  */
1469 static int cpufreq_bp_suspend(void)
1470 {
1471         int ret = 0;
1472
1473         int cpu = smp_processor_id();
1474         struct cpufreq_policy *policy;
1475
1476         pr_debug("suspending cpu %u\n", cpu);
1477
1478         /* If there's no policy for the boot CPU, we have nothing to do. */
1479         policy = cpufreq_cpu_get(cpu);
1480         if (!policy)
1481                 return 0;
1482
1483         if (cpufreq_driver->suspend) {
1484                 ret = cpufreq_driver->suspend(policy);
1485                 if (ret)
1486                         printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
1487                                         "step on CPU %u\n", policy->cpu);
1488         }
1489
1490         cpufreq_cpu_put(policy);
1491         return ret;
1492 }
1493
1494 /**
1495  * cpufreq_bp_resume - Restore proper frequency handling of the boot CPU.
1496  *
1497  *      1.) resume CPUfreq hardware support (cpufreq_driver->resume())
1498  *      2.) schedule call cpufreq_update_policy() ASAP as interrupts are
1499  *          restored. It will verify that the current freq is in sync with
1500  *          what we believe it to be. This is a bit later than when it
1501  *          should be, but nonethteless it's better than calling
1502  *          cpufreq_driver->get() here which might re-enable interrupts...
1503  *
1504  * This function is only executed for the boot CPU.  The other CPUs have not
1505  * been turned on yet.
1506  */
1507 static void cpufreq_bp_resume(void)
1508 {
1509         int ret = 0;
1510
1511         int cpu = smp_processor_id();
1512         struct cpufreq_policy *policy;
1513
1514         pr_debug("resuming cpu %u\n", cpu);
1515
1516         /* If there's no policy for the boot CPU, we have nothing to do. */
1517         policy = cpufreq_cpu_get(cpu);
1518         if (!policy)
1519                 return;
1520
1521         if (cpufreq_driver->resume) {
1522                 ret = cpufreq_driver->resume(policy);
1523                 if (ret) {
1524                         printk(KERN_ERR "cpufreq: resume failed in ->resume "
1525                                         "step on CPU %u\n", policy->cpu);
1526                         goto fail;
1527                 }
1528         }
1529
1530         schedule_work(&policy->update);
1531
1532 fail:
1533         cpufreq_cpu_put(policy);
1534 }
1535
1536 static struct syscore_ops cpufreq_syscore_ops = {
1537         .suspend        = cpufreq_bp_suspend,
1538         .resume         = cpufreq_bp_resume,
1539 };
1540
1541 /**
1542  *      cpufreq_get_current_driver - return current driver's name
1543  *
1544  *      Return the name string of the currently loaded cpufreq driver
1545  *      or NULL, if none.
1546  */
1547 const char *cpufreq_get_current_driver(void)
1548 {
1549         if (cpufreq_driver)
1550                 return cpufreq_driver->name;
1551
1552         return NULL;
1553 }
1554 EXPORT_SYMBOL_GPL(cpufreq_get_current_driver);
1555
1556 /*********************************************************************
1557  *                     NOTIFIER LISTS INTERFACE                      *
1558  *********************************************************************/
1559
1560 /**
1561  *      cpufreq_register_notifier - register a driver with cpufreq
1562  *      @nb: notifier function to register
1563  *      @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1564  *
1565  *      Add a driver to one of two lists: either a list of drivers that
1566  *      are notified about clock rate changes (once before and once after
1567  *      the transition), or a list of drivers that are notified about
1568  *      changes in cpufreq policy.
1569  *
1570  *      This function may sleep, and has the same return conditions as
1571  *      blocking_notifier_chain_register.
1572  */
1573 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1574 {
1575         int ret;
1576
1577         if (cpufreq_disabled())
1578                 return -EINVAL;
1579
1580         WARN_ON(!init_cpufreq_transition_notifier_list_called);
1581
1582         switch (list) {
1583         case CPUFREQ_TRANSITION_NOTIFIER:
1584                 ret = srcu_notifier_chain_register(
1585                                 &cpufreq_transition_notifier_list, nb);
1586                 break;
1587         case CPUFREQ_POLICY_NOTIFIER:
1588                 ret = blocking_notifier_chain_register(
1589                                 &cpufreq_policy_notifier_list, nb);
1590                 break;
1591         default:
1592                 ret = -EINVAL;
1593         }
1594
1595         return ret;
1596 }
1597 EXPORT_SYMBOL(cpufreq_register_notifier);
1598
1599 /**
1600  *      cpufreq_unregister_notifier - unregister a driver with cpufreq
1601  *      @nb: notifier block to be unregistered
1602  *      @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1603  *
1604  *      Remove a driver from the CPU frequency notifier list.
1605  *
1606  *      This function may sleep, and has the same return conditions as
1607  *      blocking_notifier_chain_unregister.
1608  */
1609 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1610 {
1611         int ret;
1612
1613         if (cpufreq_disabled())
1614                 return -EINVAL;
1615
1616         switch (list) {
1617         case CPUFREQ_TRANSITION_NOTIFIER:
1618                 ret = srcu_notifier_chain_unregister(
1619                                 &cpufreq_transition_notifier_list, nb);
1620                 break;
1621         case CPUFREQ_POLICY_NOTIFIER:
1622                 ret = blocking_notifier_chain_unregister(
1623                                 &cpufreq_policy_notifier_list, nb);
1624                 break;
1625         default:
1626                 ret = -EINVAL;
1627         }
1628
1629         return ret;
1630 }
1631 EXPORT_SYMBOL(cpufreq_unregister_notifier);
1632
1633
1634 /*********************************************************************
1635  *                              GOVERNORS                            *
1636  *********************************************************************/
1637
1638 int __cpufreq_driver_target(struct cpufreq_policy *policy,
1639                             unsigned int target_freq,
1640                             unsigned int relation)
1641 {
1642         int retval = -EINVAL;
1643         unsigned int old_target_freq = target_freq;
1644
1645         if (cpufreq_disabled())
1646                 return -ENODEV;
1647
1648         /* Make sure that target_freq is within supported range */
1649         if (target_freq > policy->max)
1650                 target_freq = policy->max;
1651         if (target_freq < policy->min)
1652                 target_freq = policy->min;
1653
1654         pr_debug("target for CPU %u: %u kHz, relation %u, requested %u kHz\n",
1655                         policy->cpu, target_freq, relation, old_target_freq);
1656
1657         if (target_freq == policy->cur)
1658                 return 0;
1659
1660         if (cpufreq_driver->target)
1661                 retval = cpufreq_driver->target(policy, target_freq, relation);
1662
1663         return retval;
1664 }
1665 EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1666
1667 int cpufreq_driver_target(struct cpufreq_policy *policy,
1668                           unsigned int target_freq,
1669                           unsigned int relation)
1670 {
1671         int ret = -EINVAL;
1672
1673         lock_policy_rwsem_write(policy->cpu);
1674
1675         ret = __cpufreq_driver_target(policy, target_freq, relation);
1676
1677         unlock_policy_rwsem_write(policy->cpu);
1678
1679         return ret;
1680 }
1681 EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1682
1683 /*
1684  * when "event" is CPUFREQ_GOV_LIMITS
1685  */
1686
1687 static int __cpufreq_governor(struct cpufreq_policy *policy,
1688                                         unsigned int event)
1689 {
1690         int ret;
1691
1692         /* Only must be defined when default governor is known to have latency
1693            restrictions, like e.g. conservative or ondemand.
1694            That this is the case is already ensured in Kconfig
1695         */
1696 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE
1697         struct cpufreq_governor *gov = &cpufreq_gov_performance;
1698 #else
1699         struct cpufreq_governor *gov = NULL;
1700 #endif
1701
1702         if (policy->governor->max_transition_latency &&
1703             policy->cpuinfo.transition_latency >
1704             policy->governor->max_transition_latency) {
1705                 if (!gov)
1706                         return -EINVAL;
1707                 else {
1708                         printk(KERN_WARNING "%s governor failed, too long"
1709                                " transition latency of HW, fallback"
1710                                " to %s governor\n",
1711                                policy->governor->name,
1712                                gov->name);
1713                         policy->governor = gov;
1714                 }
1715         }
1716
1717         if (event == CPUFREQ_GOV_POLICY_INIT)
1718                 if (!try_module_get(policy->governor->owner))
1719                         return -EINVAL;
1720
1721         pr_debug("__cpufreq_governor for CPU %u, event %u\n",
1722                                                 policy->cpu, event);
1723
1724         mutex_lock(&cpufreq_governor_lock);
1725         if ((policy->governor_enabled && event == CPUFREQ_GOV_START)
1726             || (!policy->governor_enabled
1727             && (event == CPUFREQ_GOV_LIMITS || event == CPUFREQ_GOV_STOP))) {
1728                 mutex_unlock(&cpufreq_governor_lock);
1729                 return -EBUSY;
1730         }
1731
1732         if (event == CPUFREQ_GOV_STOP)
1733                 policy->governor_enabled = false;
1734         else if (event == CPUFREQ_GOV_START)
1735                 policy->governor_enabled = true;
1736
1737         mutex_unlock(&cpufreq_governor_lock);
1738
1739         ret = policy->governor->governor(policy, event);
1740
1741         if (!ret) {
1742                 if (event == CPUFREQ_GOV_POLICY_INIT)
1743                         policy->governor->initialized++;
1744                 else if (event == CPUFREQ_GOV_POLICY_EXIT)
1745                         policy->governor->initialized--;
1746         } else {
1747                 /* Restore original values */
1748                 mutex_lock(&cpufreq_governor_lock);
1749                 if (event == CPUFREQ_GOV_STOP)
1750                         policy->governor_enabled = true;
1751                 else if (event == CPUFREQ_GOV_START)
1752                         policy->governor_enabled = false;
1753                 mutex_unlock(&cpufreq_governor_lock);
1754         }
1755
1756         if (((event == CPUFREQ_GOV_POLICY_INIT) && ret) ||
1757                         ((event == CPUFREQ_GOV_POLICY_EXIT) && !ret))
1758                 module_put(policy->governor->owner);
1759
1760         return ret;
1761 }
1762
1763 int cpufreq_register_governor(struct cpufreq_governor *governor)
1764 {
1765         int err;
1766
1767         if (!governor)
1768                 return -EINVAL;
1769
1770         if (cpufreq_disabled())
1771                 return -ENODEV;
1772
1773         mutex_lock(&cpufreq_governor_mutex);
1774
1775         governor->initialized = 0;
1776         err = -EBUSY;
1777         if (__find_governor(governor->name) == NULL) {
1778                 err = 0;
1779                 list_add(&governor->governor_list, &cpufreq_governor_list);
1780         }
1781
1782         mutex_unlock(&cpufreq_governor_mutex);
1783         return err;
1784 }
1785 EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1786
1787 void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1788 {
1789 #ifdef CONFIG_HOTPLUG_CPU
1790         int cpu;
1791 #endif
1792
1793         if (!governor)
1794                 return;
1795
1796         if (cpufreq_disabled())
1797                 return;
1798
1799 #ifdef CONFIG_HOTPLUG_CPU
1800         for_each_present_cpu(cpu) {
1801                 if (cpu_online(cpu))
1802                         continue;
1803                 if (!strcmp(per_cpu(cpufreq_cpu_governor, cpu), governor->name))
1804                         strcpy(per_cpu(cpufreq_cpu_governor, cpu), "\0");
1805         }
1806 #endif
1807
1808         mutex_lock(&cpufreq_governor_mutex);
1809         list_del(&governor->governor_list);
1810         mutex_unlock(&cpufreq_governor_mutex);
1811         return;
1812 }
1813 EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1814
1815
1816 /*********************************************************************
1817  *                          POLICY INTERFACE                         *
1818  *********************************************************************/
1819
1820 /**
1821  * cpufreq_get_policy - get the current cpufreq_policy
1822  * @policy: struct cpufreq_policy into which the current cpufreq_policy
1823  *      is written
1824  *
1825  * Reads the current cpufreq policy.
1826  */
1827 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1828 {
1829         struct cpufreq_policy *cpu_policy;
1830         if (!policy)
1831                 return -EINVAL;
1832
1833         cpu_policy = cpufreq_cpu_get(cpu);
1834         if (!cpu_policy)
1835                 return -EINVAL;
1836
1837         memcpy(policy, cpu_policy, sizeof(*policy));
1838
1839         cpufreq_cpu_put(cpu_policy);
1840         return 0;
1841 }
1842 EXPORT_SYMBOL(cpufreq_get_policy);
1843
1844 /*
1845  * policy : current policy.
1846  * new_policy: policy to be set.
1847  */
1848 static int cpufreq_set_policy(struct cpufreq_policy *policy,
1849                                 struct cpufreq_policy *new_policy)
1850 {
1851         int ret = 0, failed = 1;
1852
1853         pr_debug("setting new policy for CPU %u: %u - %u kHz\n", new_policy->cpu,
1854                 new_policy->min, new_policy->max);
1855
1856         memcpy(&new_policy->cpuinfo, &policy->cpuinfo, sizeof(policy->cpuinfo));
1857
1858         if (new_policy->min > policy->max || new_policy->max < policy->min) {
1859                 ret = -EINVAL;
1860                 goto error_out;
1861         }
1862
1863         /* verify the cpu speed can be set within this limit */
1864         ret = cpufreq_driver->verify(new_policy);
1865         if (ret)
1866                 goto error_out;
1867
1868         /* adjust if necessary - all reasons */
1869         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1870                         CPUFREQ_ADJUST, new_policy);
1871
1872         /* adjust if necessary - hardware incompatibility*/
1873         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1874                         CPUFREQ_INCOMPATIBLE, new_policy);
1875
1876         /*
1877          * verify the cpu speed can be set within this limit, which might be
1878          * different to the first one
1879          */
1880         ret = cpufreq_driver->verify(new_policy);
1881         if (ret)
1882                 goto error_out;
1883
1884         /* notification of the new policy */
1885         blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
1886                         CPUFREQ_NOTIFY, new_policy);
1887
1888         policy->min = new_policy->min;
1889         policy->max = new_policy->max;
1890
1891         pr_debug("new min and max freqs are %u - %u kHz\n",
1892                                         policy->min, policy->max);
1893
1894         if (cpufreq_driver->setpolicy) {
1895                 policy->policy = new_policy->policy;
1896                 pr_debug("setting range\n");
1897                 ret = cpufreq_driver->setpolicy(new_policy);
1898         } else {
1899                 if (new_policy->governor != policy->governor) {
1900                         /* save old, working values */
1901                         struct cpufreq_governor *old_gov = policy->governor;
1902
1903                         pr_debug("governor switch\n");
1904
1905                         /* end old governor */
1906                         if (policy->governor) {
1907                                 __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
1908                                 unlock_policy_rwsem_write(new_policy->cpu);
1909                                 __cpufreq_governor(policy,
1910                                                 CPUFREQ_GOV_POLICY_EXIT);
1911                                 lock_policy_rwsem_write(new_policy->cpu);
1912                         }
1913
1914                         /* start new governor */
1915                         policy->governor = new_policy->governor;
1916                         if (!__cpufreq_governor(policy, CPUFREQ_GOV_POLICY_INIT)) {
1917                                 if (!__cpufreq_governor(policy, CPUFREQ_GOV_START)) {
1918                                         failed = 0;
1919                                 } else {
1920                                         unlock_policy_rwsem_write(new_policy->cpu);
1921                                         __cpufreq_governor(policy,
1922                                                         CPUFREQ_GOV_POLICY_EXIT);
1923                                         lock_policy_rwsem_write(new_policy->cpu);
1924                                 }
1925                         }
1926
1927                         if (failed) {
1928                                 /* new governor failed, so re-start old one */
1929                                 pr_debug("starting governor %s failed\n",
1930                                                         policy->governor->name);
1931                                 if (old_gov) {
1932                                         policy->governor = old_gov;
1933                                         __cpufreq_governor(policy,
1934                                                         CPUFREQ_GOV_POLICY_INIT);
1935                                         __cpufreq_governor(policy,
1936                                                            CPUFREQ_GOV_START);
1937                                 }
1938                                 ret = -EINVAL;
1939                                 goto error_out;
1940                         }
1941                         /* might be a policy change, too, so fall through */
1942                 }
1943                 pr_debug("governor: change or update limits\n");
1944                 ret = __cpufreq_governor(policy, CPUFREQ_GOV_LIMITS);
1945         }
1946
1947 error_out:
1948         return ret;
1949 }
1950
1951 /**
1952  *      cpufreq_update_policy - re-evaluate an existing cpufreq policy
1953  *      @cpu: CPU which shall be re-evaluated
1954  *
1955  *      Useful for policy notifiers which have different necessities
1956  *      at different times.
1957  */
1958 int cpufreq_update_policy(unsigned int cpu)
1959 {
1960         struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1961         struct cpufreq_policy new_policy;
1962         int ret;
1963
1964         if (!policy) {
1965                 ret = -ENODEV;
1966                 goto no_policy;
1967         }
1968
1969         lock_policy_rwsem_write(cpu);
1970
1971         pr_debug("updating policy for CPU %u\n", cpu);
1972         memcpy(&new_policy, policy, sizeof(*policy));
1973         new_policy.min = policy->user_policy.min;
1974         new_policy.max = policy->user_policy.max;
1975         new_policy.policy = policy->user_policy.policy;
1976         new_policy.governor = policy->user_policy.governor;
1977
1978         /*
1979          * BIOS might change freq behind our back
1980          * -> ask driver for current freq and notify governors about a change
1981          */
1982         if (cpufreq_driver->get) {
1983                 new_policy.cur = cpufreq_driver->get(cpu);
1984                 if (!policy->cur) {
1985                         pr_debug("Driver did not initialize current freq");
1986                         policy->cur = new_policy.cur;
1987                 } else {
1988                         if (policy->cur != new_policy.cur && cpufreq_driver->target)
1989                                 cpufreq_out_of_sync(cpu, policy->cur,
1990                                                                 new_policy.cur);
1991                 }
1992         }
1993
1994         ret = cpufreq_set_policy(policy, &new_policy);
1995
1996         unlock_policy_rwsem_write(cpu);
1997
1998         cpufreq_cpu_put(policy);
1999 no_policy:
2000         return ret;
2001 }
2002 EXPORT_SYMBOL(cpufreq_update_policy);
2003
2004 static int cpufreq_cpu_callback(struct notifier_block *nfb,
2005                                         unsigned long action, void *hcpu)
2006 {
2007         unsigned int cpu = (unsigned long)hcpu;
2008         struct device *dev;
2009         bool frozen = false;
2010
2011         dev = get_cpu_device(cpu);
2012         if (dev) {
2013
2014                 if (action & CPU_TASKS_FROZEN)
2015                         frozen = true;
2016
2017                 switch (action & ~CPU_TASKS_FROZEN) {
2018                 case CPU_ONLINE:
2019                         __cpufreq_add_dev(dev, NULL, frozen);
2020                         cpufreq_update_policy(cpu);
2021                         break;
2022
2023                 case CPU_DOWN_PREPARE:
2024                         __cpufreq_remove_dev_prepare(dev, NULL, frozen);
2025                         break;
2026
2027                 case CPU_POST_DEAD:
2028                         __cpufreq_remove_dev_finish(dev, NULL, frozen);
2029                         break;
2030
2031                 case CPU_DOWN_FAILED:
2032                         __cpufreq_add_dev(dev, NULL, frozen);
2033                         break;
2034                 }
2035         }
2036         return NOTIFY_OK;
2037 }
2038
2039 static struct notifier_block __refdata cpufreq_cpu_notifier = {
2040         .notifier_call = cpufreq_cpu_callback,
2041 };
2042
2043 /*********************************************************************
2044  *               REGISTER / UNREGISTER CPUFREQ DRIVER                *
2045  *********************************************************************/
2046
2047 /**
2048  * cpufreq_register_driver - register a CPU Frequency driver
2049  * @driver_data: A struct cpufreq_driver containing the values#
2050  * submitted by the CPU Frequency driver.
2051  *
2052  * Registers a CPU Frequency driver to this core code. This code
2053  * returns zero on success, -EBUSY when another driver got here first
2054  * (and isn't unregistered in the meantime).
2055  *
2056  */
2057 int cpufreq_register_driver(struct cpufreq_driver *driver_data)
2058 {
2059         unsigned long flags;
2060         int ret;
2061
2062         if (cpufreq_disabled())
2063                 return -ENODEV;
2064
2065         if (!driver_data || !driver_data->verify || !driver_data->init ||
2066             ((!driver_data->setpolicy) && (!driver_data->target)))
2067                 return -EINVAL;
2068
2069         pr_debug("trying to register driver %s\n", driver_data->name);
2070
2071         if (driver_data->setpolicy)
2072                 driver_data->flags |= CPUFREQ_CONST_LOOPS;
2073
2074         write_lock_irqsave(&cpufreq_driver_lock, flags);
2075         if (cpufreq_driver) {
2076                 write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2077                 return -EEXIST;
2078         }
2079         cpufreq_driver = driver_data;
2080         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2081
2082         ret = subsys_interface_register(&cpufreq_interface);
2083         if (ret)
2084                 goto err_null_driver;
2085
2086         if (!(cpufreq_driver->flags & CPUFREQ_STICKY)) {
2087                 int i;
2088                 ret = -ENODEV;
2089
2090                 /* check for at least one working CPU */
2091                 for (i = 0; i < nr_cpu_ids; i++)
2092                         if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) {
2093                                 ret = 0;
2094                                 break;
2095                         }
2096
2097                 /* if all ->init() calls failed, unregister */
2098                 if (ret) {
2099                         pr_debug("no CPU initialized for driver %s\n",
2100                                                         driver_data->name);
2101                         goto err_if_unreg;
2102                 }
2103         }
2104
2105         register_hotcpu_notifier(&cpufreq_cpu_notifier);
2106         pr_debug("driver %s up and running\n", driver_data->name);
2107
2108         return 0;
2109 err_if_unreg:
2110         subsys_interface_unregister(&cpufreq_interface);
2111 err_null_driver:
2112         write_lock_irqsave(&cpufreq_driver_lock, flags);
2113         cpufreq_driver = NULL;
2114         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2115         return ret;
2116 }
2117 EXPORT_SYMBOL_GPL(cpufreq_register_driver);
2118
2119 /**
2120  * cpufreq_unregister_driver - unregister the current CPUFreq driver
2121  *
2122  * Unregister the current CPUFreq driver. Only call this if you have
2123  * the right to do so, i.e. if you have succeeded in initialising before!
2124  * Returns zero if successful, and -EINVAL if the cpufreq_driver is
2125  * currently not initialised.
2126  */
2127 int cpufreq_unregister_driver(struct cpufreq_driver *driver)
2128 {
2129         unsigned long flags;
2130
2131         if (!cpufreq_driver || (driver != cpufreq_driver))
2132                 return -EINVAL;
2133
2134         pr_debug("unregistering driver %s\n", driver->name);
2135
2136         subsys_interface_unregister(&cpufreq_interface);
2137         unregister_hotcpu_notifier(&cpufreq_cpu_notifier);
2138
2139         down_write(&cpufreq_rwsem);
2140         write_lock_irqsave(&cpufreq_driver_lock, flags);
2141
2142         cpufreq_driver = NULL;
2143
2144         write_unlock_irqrestore(&cpufreq_driver_lock, flags);
2145         up_write(&cpufreq_rwsem);
2146
2147         return 0;
2148 }
2149 EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);
2150
2151 static int __init cpufreq_core_init(void)
2152 {
2153         int cpu;
2154
2155         if (cpufreq_disabled())
2156                 return -ENODEV;
2157
2158         for_each_possible_cpu(cpu)
2159                 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
2160
2161         cpufreq_global_kobject = kobject_create();
2162         BUG_ON(!cpufreq_global_kobject);
2163         register_syscore_ops(&cpufreq_syscore_ops);
2164
2165         return 0;
2166 }
2167 core_initcall(cpufreq_core_init);