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