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