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