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