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