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(cpumask_t mask, char *buf) 588 { 589 ssize_t i = 0; 590 unsigned int cpu; 591 592 for_each_cpu_mask_nr(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 (cpus_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 758 /** 759 * cpufreq_add_dev - add a CPU device 760 * 761 * Adds the cpufreq interface for a CPU device. 762 */ 763 static int cpufreq_add_dev(struct sys_device *sys_dev) 764 { 765 unsigned int cpu = sys_dev->id; 766 int ret = 0; 767 struct cpufreq_policy new_policy; 768 struct cpufreq_policy *policy; 769 struct freq_attr **drv_attr; 770 struct sys_device *cpu_sys_dev; 771 unsigned long flags; 772 unsigned int j; 773 #ifdef CONFIG_SMP 774 struct cpufreq_policy *managed_policy; 775 #endif 776 777 if (cpu_is_offline(cpu)) 778 return 0; 779 780 cpufreq_debug_disable_ratelimit(); 781 dprintk("adding CPU %u\n", cpu); 782 783 #ifdef CONFIG_SMP 784 /* check whether a different CPU already registered this 785 * CPU because it is in the same boat. */ 786 policy = cpufreq_cpu_get(cpu); 787 if (unlikely(policy)) { 788 cpufreq_cpu_put(policy); 789 cpufreq_debug_enable_ratelimit(); 790 return 0; 791 } 792 #endif 793 794 if (!try_module_get(cpufreq_driver->owner)) { 795 ret = -EINVAL; 796 goto module_out; 797 } 798 799 policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL); 800 if (!policy) { 801 ret = -ENOMEM; 802 goto nomem_out; 803 } 804 805 policy->cpu = cpu; 806 policy->cpus = cpumask_of_cpu(cpu); 807 808 /* Initially set CPU itself as the policy_cpu */ 809 per_cpu(policy_cpu, cpu) = cpu; 810 lock_policy_rwsem_write(cpu); 811 812 init_completion(&policy->kobj_unregister); 813 INIT_WORK(&policy->update, handle_update); 814 815 /* Set governor before ->init, so that driver could check it */ 816 policy->governor = CPUFREQ_DEFAULT_GOVERNOR; 817 /* call driver. From then on the cpufreq must be able 818 * to accept all calls to ->verify and ->setpolicy for this CPU 819 */ 820 ret = cpufreq_driver->init(policy); 821 if (ret) { 822 dprintk("initialization failed\n"); 823 goto err_out; 824 } 825 policy->user_policy.min = policy->cpuinfo.min_freq; 826 policy->user_policy.max = policy->cpuinfo.max_freq; 827 828 blocking_notifier_call_chain(&cpufreq_policy_notifier_list, 829 CPUFREQ_START, policy); 830 831 #ifdef CONFIG_SMP 832 833 #ifdef CONFIG_HOTPLUG_CPU 834 if (per_cpu(cpufreq_cpu_governor, cpu)) { 835 policy->governor = per_cpu(cpufreq_cpu_governor, cpu); 836 dprintk("Restoring governor %s for cpu %d\n", 837 policy->governor->name, cpu); 838 } 839 #endif 840 841 for_each_cpu_mask_nr(j, policy->cpus) { 842 if (cpu == j) 843 continue; 844 845 /* check for existing affected CPUs. They may not be aware 846 * of it due to CPU Hotplug. 847 */ 848 managed_policy = cpufreq_cpu_get(j); // FIXME: Where is this released? What about error paths? 849 if (unlikely(managed_policy)) { 850 851 /* Set proper policy_cpu */ 852 unlock_policy_rwsem_write(cpu); 853 per_cpu(policy_cpu, cpu) = managed_policy->cpu; 854 855 if (lock_policy_rwsem_write(cpu) < 0) 856 goto err_out_driver_exit; 857 858 spin_lock_irqsave(&cpufreq_driver_lock, flags); 859 managed_policy->cpus = policy->cpus; 860 per_cpu(cpufreq_cpu_data, cpu) = managed_policy; 861 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 862 863 dprintk("CPU already managed, adding link\n"); 864 ret = sysfs_create_link(&sys_dev->kobj, 865 &managed_policy->kobj, 866 "cpufreq"); 867 if (ret) 868 goto err_out_driver_exit; 869 870 cpufreq_debug_enable_ratelimit(); 871 ret = 0; 872 goto err_out_driver_exit; /* call driver->exit() */ 873 } 874 } 875 #endif 876 memcpy(&new_policy, policy, sizeof(struct cpufreq_policy)); 877 878 /* prepare interface data */ 879 ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq, &sys_dev->kobj, 880 "cpufreq"); 881 if (ret) 882 goto err_out_driver_exit; 883 884 /* set up files for this cpu device */ 885 drv_attr = cpufreq_driver->attr; 886 while ((drv_attr) && (*drv_attr)) { 887 ret = sysfs_create_file(&policy->kobj, &((*drv_attr)->attr)); 888 if (ret) 889 goto err_out_driver_exit; 890 drv_attr++; 891 } 892 if (cpufreq_driver->get) { 893 ret = sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr); 894 if (ret) 895 goto err_out_driver_exit; 896 } 897 if (cpufreq_driver->target) { 898 ret = sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr); 899 if (ret) 900 goto err_out_driver_exit; 901 } 902 903 spin_lock_irqsave(&cpufreq_driver_lock, flags); 904 for_each_cpu_mask_nr(j, policy->cpus) { 905 per_cpu(cpufreq_cpu_data, j) = policy; 906 per_cpu(policy_cpu, j) = policy->cpu; 907 } 908 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 909 910 /* symlink affected CPUs */ 911 for_each_cpu_mask_nr(j, policy->cpus) { 912 if (j == cpu) 913 continue; 914 if (!cpu_online(j)) 915 continue; 916 917 dprintk("CPU %u already managed, adding link\n", j); 918 cpufreq_cpu_get(cpu); 919 cpu_sys_dev = get_cpu_sysdev(j); 920 ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj, 921 "cpufreq"); 922 if (ret) 923 goto err_out_unregister; 924 } 925 926 policy->governor = NULL; /* to assure that the starting sequence is 927 * run in cpufreq_set_policy */ 928 929 /* set default policy */ 930 ret = __cpufreq_set_policy(policy, &new_policy); 931 policy->user_policy.policy = policy->policy; 932 policy->user_policy.governor = policy->governor; 933 934 if (ret) { 935 dprintk("setting policy failed\n"); 936 goto err_out_unregister; 937 } 938 939 unlock_policy_rwsem_write(cpu); 940 941 kobject_uevent(&policy->kobj, KOBJ_ADD); 942 module_put(cpufreq_driver->owner); 943 dprintk("initialization complete\n"); 944 cpufreq_debug_enable_ratelimit(); 945 946 return 0; 947 948 949 err_out_unregister: 950 spin_lock_irqsave(&cpufreq_driver_lock, flags); 951 for_each_cpu_mask_nr(j, policy->cpus) 952 per_cpu(cpufreq_cpu_data, j) = NULL; 953 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 954 955 kobject_put(&policy->kobj); 956 wait_for_completion(&policy->kobj_unregister); 957 958 err_out_driver_exit: 959 if (cpufreq_driver->exit) 960 cpufreq_driver->exit(policy); 961 962 err_out: 963 unlock_policy_rwsem_write(cpu); 964 kfree(policy); 965 966 nomem_out: 967 module_put(cpufreq_driver->owner); 968 module_out: 969 cpufreq_debug_enable_ratelimit(); 970 return ret; 971 } 972 973 974 /** 975 * __cpufreq_remove_dev - remove a CPU device 976 * 977 * Removes the cpufreq interface for a CPU device. 978 * Caller should already have policy_rwsem in write mode for this CPU. 979 * This routine frees the rwsem before returning. 980 */ 981 static int __cpufreq_remove_dev(struct sys_device *sys_dev) 982 { 983 unsigned int cpu = sys_dev->id; 984 unsigned long flags; 985 struct cpufreq_policy *data; 986 #ifdef CONFIG_SMP 987 struct sys_device *cpu_sys_dev; 988 unsigned int j; 989 #endif 990 991 cpufreq_debug_disable_ratelimit(); 992 dprintk("unregistering CPU %u\n", cpu); 993 994 spin_lock_irqsave(&cpufreq_driver_lock, flags); 995 data = per_cpu(cpufreq_cpu_data, cpu); 996 997 if (!data) { 998 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 999 cpufreq_debug_enable_ratelimit(); 1000 unlock_policy_rwsem_write(cpu); 1001 return -EINVAL; 1002 } 1003 per_cpu(cpufreq_cpu_data, cpu) = NULL; 1004 1005 1006 #ifdef CONFIG_SMP 1007 /* if this isn't the CPU which is the parent of the kobj, we 1008 * only need to unlink, put and exit 1009 */ 1010 if (unlikely(cpu != data->cpu)) { 1011 dprintk("removing link\n"); 1012 cpu_clear(cpu, data->cpus); 1013 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 1014 sysfs_remove_link(&sys_dev->kobj, "cpufreq"); 1015 cpufreq_cpu_put(data); 1016 cpufreq_debug_enable_ratelimit(); 1017 unlock_policy_rwsem_write(cpu); 1018 return 0; 1019 } 1020 #endif 1021 1022 #ifdef CONFIG_SMP 1023 1024 #ifdef CONFIG_HOTPLUG_CPU 1025 per_cpu(cpufreq_cpu_governor, cpu) = data->governor; 1026 #endif 1027 1028 /* if we have other CPUs still registered, we need to unlink them, 1029 * or else wait_for_completion below will lock up. Clean the 1030 * per_cpu(cpufreq_cpu_data) while holding the lock, and remove 1031 * the sysfs links afterwards. 1032 */ 1033 if (unlikely(cpus_weight(data->cpus) > 1)) { 1034 for_each_cpu_mask_nr(j, data->cpus) { 1035 if (j == cpu) 1036 continue; 1037 per_cpu(cpufreq_cpu_data, j) = NULL; 1038 } 1039 } 1040 1041 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 1042 1043 if (unlikely(cpus_weight(data->cpus) > 1)) { 1044 for_each_cpu_mask_nr(j, data->cpus) { 1045 if (j == cpu) 1046 continue; 1047 dprintk("removing link for cpu %u\n", j); 1048 #ifdef CONFIG_HOTPLUG_CPU 1049 per_cpu(cpufreq_cpu_governor, j) = data->governor; 1050 #endif 1051 cpu_sys_dev = get_cpu_sysdev(j); 1052 sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq"); 1053 cpufreq_cpu_put(data); 1054 } 1055 } 1056 #else 1057 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 1058 #endif 1059 1060 if (cpufreq_driver->target) 1061 __cpufreq_governor(data, CPUFREQ_GOV_STOP); 1062 1063 unlock_policy_rwsem_write(cpu); 1064 1065 kobject_put(&data->kobj); 1066 1067 /* we need to make sure that the underlying kobj is actually 1068 * not referenced anymore by anybody before we proceed with 1069 * unloading. 1070 */ 1071 dprintk("waiting for dropping of refcount\n"); 1072 wait_for_completion(&data->kobj_unregister); 1073 dprintk("wait complete\n"); 1074 1075 if (cpufreq_driver->exit) 1076 cpufreq_driver->exit(data); 1077 1078 kfree(data); 1079 1080 cpufreq_debug_enable_ratelimit(); 1081 return 0; 1082 } 1083 1084 1085 static int cpufreq_remove_dev(struct sys_device *sys_dev) 1086 { 1087 unsigned int cpu = sys_dev->id; 1088 int retval; 1089 1090 if (cpu_is_offline(cpu)) 1091 return 0; 1092 1093 if (unlikely(lock_policy_rwsem_write(cpu))) 1094 BUG(); 1095 1096 retval = __cpufreq_remove_dev(sys_dev); 1097 return retval; 1098 } 1099 1100 1101 static void handle_update(struct work_struct *work) 1102 { 1103 struct cpufreq_policy *policy = 1104 container_of(work, struct cpufreq_policy, update); 1105 unsigned int cpu = policy->cpu; 1106 dprintk("handle_update for cpu %u called\n", cpu); 1107 cpufreq_update_policy(cpu); 1108 } 1109 1110 /** 1111 * cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble. 1112 * @cpu: cpu number 1113 * @old_freq: CPU frequency the kernel thinks the CPU runs at 1114 * @new_freq: CPU frequency the CPU actually runs at 1115 * 1116 * We adjust to current frequency first, and need to clean up later. So either call 1117 * to cpufreq_update_policy() or schedule handle_update()). 1118 */ 1119 static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, 1120 unsigned int new_freq) 1121 { 1122 struct cpufreq_freqs freqs; 1123 1124 dprintk("Warning: CPU frequency out of sync: cpufreq and timing " 1125 "core thinks of %u, is %u kHz.\n", old_freq, new_freq); 1126 1127 freqs.cpu = cpu; 1128 freqs.old = old_freq; 1129 freqs.new = new_freq; 1130 cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); 1131 cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); 1132 } 1133 1134 1135 /** 1136 * cpufreq_quick_get - get the CPU frequency (in kHz) from policy->cur 1137 * @cpu: CPU number 1138 * 1139 * This is the last known freq, without actually getting it from the driver. 1140 * Return value will be same as what is shown in scaling_cur_freq in sysfs. 1141 */ 1142 unsigned int cpufreq_quick_get(unsigned int cpu) 1143 { 1144 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu); 1145 unsigned int ret_freq = 0; 1146 1147 if (policy) { 1148 ret_freq = policy->cur; 1149 cpufreq_cpu_put(policy); 1150 } 1151 1152 return ret_freq; 1153 } 1154 EXPORT_SYMBOL(cpufreq_quick_get); 1155 1156 1157 static unsigned int __cpufreq_get(unsigned int cpu) 1158 { 1159 struct cpufreq_policy *policy = per_cpu(cpufreq_cpu_data, cpu); 1160 unsigned int ret_freq = 0; 1161 1162 if (!cpufreq_driver->get) 1163 return ret_freq; 1164 1165 ret_freq = cpufreq_driver->get(cpu); 1166 1167 if (ret_freq && policy->cur && 1168 !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) { 1169 /* verify no discrepancy between actual and 1170 saved value exists */ 1171 if (unlikely(ret_freq != policy->cur)) { 1172 cpufreq_out_of_sync(cpu, policy->cur, ret_freq); 1173 schedule_work(&policy->update); 1174 } 1175 } 1176 1177 return ret_freq; 1178 } 1179 1180 /** 1181 * cpufreq_get - get the current CPU frequency (in kHz) 1182 * @cpu: CPU number 1183 * 1184 * Get the CPU current (static) CPU frequency 1185 */ 1186 unsigned int cpufreq_get(unsigned int cpu) 1187 { 1188 unsigned int ret_freq = 0; 1189 struct cpufreq_policy *policy = cpufreq_cpu_get(cpu); 1190 1191 if (!policy) 1192 goto out; 1193 1194 if (unlikely(lock_policy_rwsem_read(cpu))) 1195 goto out_policy; 1196 1197 ret_freq = __cpufreq_get(cpu); 1198 1199 unlock_policy_rwsem_read(cpu); 1200 1201 out_policy: 1202 cpufreq_cpu_put(policy); 1203 out: 1204 return ret_freq; 1205 } 1206 EXPORT_SYMBOL(cpufreq_get); 1207 1208 1209 /** 1210 * cpufreq_suspend - let the low level driver prepare for suspend 1211 */ 1212 1213 static int cpufreq_suspend(struct sys_device *sysdev, pm_message_t pmsg) 1214 { 1215 int cpu = sysdev->id; 1216 int ret = 0; 1217 unsigned int cur_freq = 0; 1218 struct cpufreq_policy *cpu_policy; 1219 1220 dprintk("suspending cpu %u\n", cpu); 1221 1222 if (!cpu_online(cpu)) 1223 return 0; 1224 1225 /* we may be lax here as interrupts are off. Nonetheless 1226 * we need to grab the correct cpu policy, as to check 1227 * whether we really run on this CPU. 1228 */ 1229 1230 cpu_policy = cpufreq_cpu_get(cpu); 1231 if (!cpu_policy) 1232 return -EINVAL; 1233 1234 /* only handle each CPU group once */ 1235 if (unlikely(cpu_policy->cpu != cpu)) 1236 goto out; 1237 1238 if (cpufreq_driver->suspend) { 1239 ret = cpufreq_driver->suspend(cpu_policy, pmsg); 1240 if (ret) { 1241 printk(KERN_ERR "cpufreq: suspend failed in ->suspend " 1242 "step on CPU %u\n", cpu_policy->cpu); 1243 goto out; 1244 } 1245 } 1246 1247 if (cpufreq_driver->flags & CPUFREQ_CONST_LOOPS) 1248 goto out; 1249 1250 if (cpufreq_driver->get) 1251 cur_freq = cpufreq_driver->get(cpu_policy->cpu); 1252 1253 if (!cur_freq || !cpu_policy->cur) { 1254 printk(KERN_ERR "cpufreq: suspend failed to assert current " 1255 "frequency is what timing core thinks it is.\n"); 1256 goto out; 1257 } 1258 1259 if (unlikely(cur_freq != cpu_policy->cur)) { 1260 struct cpufreq_freqs freqs; 1261 1262 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN)) 1263 dprintk("Warning: CPU frequency is %u, " 1264 "cpufreq assumed %u kHz.\n", 1265 cur_freq, cpu_policy->cur); 1266 1267 freqs.cpu = cpu; 1268 freqs.old = cpu_policy->cur; 1269 freqs.new = cur_freq; 1270 1271 srcu_notifier_call_chain(&cpufreq_transition_notifier_list, 1272 CPUFREQ_SUSPENDCHANGE, &freqs); 1273 adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs); 1274 1275 cpu_policy->cur = cur_freq; 1276 } 1277 1278 out: 1279 cpufreq_cpu_put(cpu_policy); 1280 return ret; 1281 } 1282 1283 /** 1284 * cpufreq_resume - restore proper CPU frequency handling after resume 1285 * 1286 * 1.) resume CPUfreq hardware support (cpufreq_driver->resume()) 1287 * 2.) if ->target and !CPUFREQ_CONST_LOOPS: verify we're in sync 1288 * 3.) schedule call cpufreq_update_policy() ASAP as interrupts are 1289 * restored. 1290 */ 1291 static int cpufreq_resume(struct sys_device *sysdev) 1292 { 1293 int cpu = sysdev->id; 1294 int ret = 0; 1295 struct cpufreq_policy *cpu_policy; 1296 1297 dprintk("resuming cpu %u\n", cpu); 1298 1299 if (!cpu_online(cpu)) 1300 return 0; 1301 1302 /* we may be lax here as interrupts are off. Nonetheless 1303 * we need to grab the correct cpu policy, as to check 1304 * whether we really run on this CPU. 1305 */ 1306 1307 cpu_policy = cpufreq_cpu_get(cpu); 1308 if (!cpu_policy) 1309 return -EINVAL; 1310 1311 /* only handle each CPU group once */ 1312 if (unlikely(cpu_policy->cpu != cpu)) 1313 goto fail; 1314 1315 if (cpufreq_driver->resume) { 1316 ret = cpufreq_driver->resume(cpu_policy); 1317 if (ret) { 1318 printk(KERN_ERR "cpufreq: resume failed in ->resume " 1319 "step on CPU %u\n", cpu_policy->cpu); 1320 goto fail; 1321 } 1322 } 1323 1324 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) { 1325 unsigned int cur_freq = 0; 1326 1327 if (cpufreq_driver->get) 1328 cur_freq = cpufreq_driver->get(cpu_policy->cpu); 1329 1330 if (!cur_freq || !cpu_policy->cur) { 1331 printk(KERN_ERR "cpufreq: resume failed to assert " 1332 "current frequency is what timing core " 1333 "thinks it is.\n"); 1334 goto out; 1335 } 1336 1337 if (unlikely(cur_freq != cpu_policy->cur)) { 1338 struct cpufreq_freqs freqs; 1339 1340 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN)) 1341 dprintk("Warning: CPU frequency " 1342 "is %u, cpufreq assumed %u kHz.\n", 1343 cur_freq, cpu_policy->cur); 1344 1345 freqs.cpu = cpu; 1346 freqs.old = cpu_policy->cur; 1347 freqs.new = cur_freq; 1348 1349 srcu_notifier_call_chain( 1350 &cpufreq_transition_notifier_list, 1351 CPUFREQ_RESUMECHANGE, &freqs); 1352 adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs); 1353 1354 cpu_policy->cur = cur_freq; 1355 } 1356 } 1357 1358 out: 1359 schedule_work(&cpu_policy->update); 1360 fail: 1361 cpufreq_cpu_put(cpu_policy); 1362 return ret; 1363 } 1364 1365 static struct sysdev_driver cpufreq_sysdev_driver = { 1366 .add = cpufreq_add_dev, 1367 .remove = cpufreq_remove_dev, 1368 .suspend = cpufreq_suspend, 1369 .resume = cpufreq_resume, 1370 }; 1371 1372 1373 /********************************************************************* 1374 * NOTIFIER LISTS INTERFACE * 1375 *********************************************************************/ 1376 1377 /** 1378 * cpufreq_register_notifier - register a driver with cpufreq 1379 * @nb: notifier function to register 1380 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER 1381 * 1382 * Add a driver to one of two lists: either a list of drivers that 1383 * are notified about clock rate changes (once before and once after 1384 * the transition), or a list of drivers that are notified about 1385 * changes in cpufreq policy. 1386 * 1387 * This function may sleep, and has the same return conditions as 1388 * blocking_notifier_chain_register. 1389 */ 1390 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list) 1391 { 1392 int ret; 1393 1394 WARN_ON(!init_cpufreq_transition_notifier_list_called); 1395 1396 switch (list) { 1397 case CPUFREQ_TRANSITION_NOTIFIER: 1398 ret = srcu_notifier_chain_register( 1399 &cpufreq_transition_notifier_list, nb); 1400 break; 1401 case CPUFREQ_POLICY_NOTIFIER: 1402 ret = blocking_notifier_chain_register( 1403 &cpufreq_policy_notifier_list, nb); 1404 break; 1405 default: 1406 ret = -EINVAL; 1407 } 1408 1409 return ret; 1410 } 1411 EXPORT_SYMBOL(cpufreq_register_notifier); 1412 1413 1414 /** 1415 * cpufreq_unregister_notifier - unregister a driver with cpufreq 1416 * @nb: notifier block to be unregistered 1417 * @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER 1418 * 1419 * Remove a driver from the CPU frequency notifier list. 1420 * 1421 * This function may sleep, and has the same return conditions as 1422 * blocking_notifier_chain_unregister. 1423 */ 1424 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list) 1425 { 1426 int ret; 1427 1428 switch (list) { 1429 case CPUFREQ_TRANSITION_NOTIFIER: 1430 ret = srcu_notifier_chain_unregister( 1431 &cpufreq_transition_notifier_list, nb); 1432 break; 1433 case CPUFREQ_POLICY_NOTIFIER: 1434 ret = blocking_notifier_chain_unregister( 1435 &cpufreq_policy_notifier_list, nb); 1436 break; 1437 default: 1438 ret = -EINVAL; 1439 } 1440 1441 return ret; 1442 } 1443 EXPORT_SYMBOL(cpufreq_unregister_notifier); 1444 1445 1446 /********************************************************************* 1447 * GOVERNORS * 1448 *********************************************************************/ 1449 1450 1451 int __cpufreq_driver_target(struct cpufreq_policy *policy, 1452 unsigned int target_freq, 1453 unsigned int relation) 1454 { 1455 int retval = -EINVAL; 1456 1457 dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu, 1458 target_freq, relation); 1459 if (cpu_online(policy->cpu) && cpufreq_driver->target) 1460 retval = cpufreq_driver->target(policy, target_freq, relation); 1461 1462 return retval; 1463 } 1464 EXPORT_SYMBOL_GPL(__cpufreq_driver_target); 1465 1466 int cpufreq_driver_target(struct cpufreq_policy *policy, 1467 unsigned int target_freq, 1468 unsigned int relation) 1469 { 1470 int ret; 1471 1472 policy = cpufreq_cpu_get(policy->cpu); 1473 if (!policy) 1474 return -EINVAL; 1475 1476 if (unlikely(lock_policy_rwsem_write(policy->cpu))) 1477 return -EINVAL; 1478 1479 ret = __cpufreq_driver_target(policy, target_freq, relation); 1480 1481 unlock_policy_rwsem_write(policy->cpu); 1482 1483 cpufreq_cpu_put(policy); 1484 return ret; 1485 } 1486 EXPORT_SYMBOL_GPL(cpufreq_driver_target); 1487 1488 int __cpufreq_driver_getavg(struct cpufreq_policy *policy) 1489 { 1490 int ret = 0; 1491 1492 policy = cpufreq_cpu_get(policy->cpu); 1493 if (!policy) 1494 return -EINVAL; 1495 1496 if (cpu_online(policy->cpu) && cpufreq_driver->getavg) 1497 ret = cpufreq_driver->getavg(policy->cpu); 1498 1499 cpufreq_cpu_put(policy); 1500 return ret; 1501 } 1502 EXPORT_SYMBOL_GPL(__cpufreq_driver_getavg); 1503 1504 /* 1505 * when "event" is CPUFREQ_GOV_LIMITS 1506 */ 1507 1508 static int __cpufreq_governor(struct cpufreq_policy *policy, 1509 unsigned int event) 1510 { 1511 int ret; 1512 1513 /* Only must be defined when default governor is known to have latency 1514 restrictions, like e.g. conservative or ondemand. 1515 That this is the case is already ensured in Kconfig 1516 */ 1517 #ifdef CONFIG_CPU_FREQ_GOV_PERFORMANCE 1518 struct cpufreq_governor *gov = &cpufreq_gov_performance; 1519 #else 1520 struct cpufreq_governor *gov = NULL; 1521 #endif 1522 1523 if (policy->governor->max_transition_latency && 1524 policy->cpuinfo.transition_latency > 1525 policy->governor->max_transition_latency) { 1526 if (!gov) 1527 return -EINVAL; 1528 else { 1529 printk(KERN_WARNING "%s governor failed, too long" 1530 " transition latency of HW, fallback" 1531 " to %s governor\n", 1532 policy->governor->name, 1533 gov->name); 1534 policy->governor = gov; 1535 } 1536 } 1537 1538 if (!try_module_get(policy->governor->owner)) 1539 return -EINVAL; 1540 1541 dprintk("__cpufreq_governor for CPU %u, event %u\n", 1542 policy->cpu, event); 1543 ret = policy->governor->governor(policy, event); 1544 1545 /* we keep one module reference alive for 1546 each CPU governed by this CPU */ 1547 if ((event != CPUFREQ_GOV_START) || ret) 1548 module_put(policy->governor->owner); 1549 if ((event == CPUFREQ_GOV_STOP) && !ret) 1550 module_put(policy->governor->owner); 1551 1552 return ret; 1553 } 1554 1555 1556 int cpufreq_register_governor(struct cpufreq_governor *governor) 1557 { 1558 int err; 1559 1560 if (!governor) 1561 return -EINVAL; 1562 1563 mutex_lock(&cpufreq_governor_mutex); 1564 1565 err = -EBUSY; 1566 if (__find_governor(governor->name) == NULL) { 1567 err = 0; 1568 list_add(&governor->governor_list, &cpufreq_governor_list); 1569 } 1570 1571 mutex_unlock(&cpufreq_governor_mutex); 1572 return err; 1573 } 1574 EXPORT_SYMBOL_GPL(cpufreq_register_governor); 1575 1576 1577 void cpufreq_unregister_governor(struct cpufreq_governor *governor) 1578 { 1579 if (!governor) 1580 return; 1581 1582 mutex_lock(&cpufreq_governor_mutex); 1583 list_del(&governor->governor_list); 1584 mutex_unlock(&cpufreq_governor_mutex); 1585 return; 1586 } 1587 EXPORT_SYMBOL_GPL(cpufreq_unregister_governor); 1588 1589 1590 1591 /********************************************************************* 1592 * POLICY INTERFACE * 1593 *********************************************************************/ 1594 1595 /** 1596 * cpufreq_get_policy - get the current cpufreq_policy 1597 * @policy: struct cpufreq_policy into which the current cpufreq_policy is written 1598 * 1599 * Reads the current cpufreq policy. 1600 */ 1601 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu) 1602 { 1603 struct cpufreq_policy *cpu_policy; 1604 if (!policy) 1605 return -EINVAL; 1606 1607 cpu_policy = cpufreq_cpu_get(cpu); 1608 if (!cpu_policy) 1609 return -EINVAL; 1610 1611 memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy)); 1612 1613 cpufreq_cpu_put(cpu_policy); 1614 return 0; 1615 } 1616 EXPORT_SYMBOL(cpufreq_get_policy); 1617 1618 1619 /* 1620 * data : current policy. 1621 * policy : policy to be set. 1622 */ 1623 static int __cpufreq_set_policy(struct cpufreq_policy *data, 1624 struct cpufreq_policy *policy) 1625 { 1626 int ret = 0; 1627 1628 cpufreq_debug_disable_ratelimit(); 1629 dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu, 1630 policy->min, policy->max); 1631 1632 memcpy(&policy->cpuinfo, &data->cpuinfo, 1633 sizeof(struct cpufreq_cpuinfo)); 1634 1635 if (policy->min > data->max || policy->max < data->min) { 1636 ret = -EINVAL; 1637 goto error_out; 1638 } 1639 1640 /* verify the cpu speed can be set within this limit */ 1641 ret = cpufreq_driver->verify(policy); 1642 if (ret) 1643 goto error_out; 1644 1645 /* adjust if necessary - all reasons */ 1646 blocking_notifier_call_chain(&cpufreq_policy_notifier_list, 1647 CPUFREQ_ADJUST, policy); 1648 1649 /* adjust if necessary - hardware incompatibility*/ 1650 blocking_notifier_call_chain(&cpufreq_policy_notifier_list, 1651 CPUFREQ_INCOMPATIBLE, policy); 1652 1653 /* verify the cpu speed can be set within this limit, 1654 which might be different to the first one */ 1655 ret = cpufreq_driver->verify(policy); 1656 if (ret) 1657 goto error_out; 1658 1659 /* notification of the new policy */ 1660 blocking_notifier_call_chain(&cpufreq_policy_notifier_list, 1661 CPUFREQ_NOTIFY, policy); 1662 1663 data->min = policy->min; 1664 data->max = policy->max; 1665 1666 dprintk("new min and max freqs are %u - %u kHz\n", 1667 data->min, data->max); 1668 1669 if (cpufreq_driver->setpolicy) { 1670 data->policy = policy->policy; 1671 dprintk("setting range\n"); 1672 ret = cpufreq_driver->setpolicy(policy); 1673 } else { 1674 if (policy->governor != data->governor) { 1675 /* save old, working values */ 1676 struct cpufreq_governor *old_gov = data->governor; 1677 1678 dprintk("governor switch\n"); 1679 1680 /* end old governor */ 1681 if (data->governor) 1682 __cpufreq_governor(data, CPUFREQ_GOV_STOP); 1683 1684 /* start new governor */ 1685 data->governor = policy->governor; 1686 if (__cpufreq_governor(data, CPUFREQ_GOV_START)) { 1687 /* new governor failed, so re-start old one */ 1688 dprintk("starting governor %s failed\n", 1689 data->governor->name); 1690 if (old_gov) { 1691 data->governor = old_gov; 1692 __cpufreq_governor(data, 1693 CPUFREQ_GOV_START); 1694 } 1695 ret = -EINVAL; 1696 goto error_out; 1697 } 1698 /* might be a policy change, too, so fall through */ 1699 } 1700 dprintk("governor: change or update limits\n"); 1701 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS); 1702 } 1703 1704 error_out: 1705 cpufreq_debug_enable_ratelimit(); 1706 return ret; 1707 } 1708 1709 /** 1710 * cpufreq_update_policy - re-evaluate an existing cpufreq policy 1711 * @cpu: CPU which shall be re-evaluated 1712 * 1713 * Usefull for policy notifiers which have different necessities 1714 * at different times. 1715 */ 1716 int cpufreq_update_policy(unsigned int cpu) 1717 { 1718 struct cpufreq_policy *data = cpufreq_cpu_get(cpu); 1719 struct cpufreq_policy policy; 1720 int ret = 0; 1721 1722 if (!data) 1723 return -ENODEV; 1724 1725 if (unlikely(lock_policy_rwsem_write(cpu))) 1726 return -EINVAL; 1727 1728 dprintk("updating policy for CPU %u\n", cpu); 1729 memcpy(&policy, data, sizeof(struct cpufreq_policy)); 1730 policy.min = data->user_policy.min; 1731 policy.max = data->user_policy.max; 1732 policy.policy = data->user_policy.policy; 1733 policy.governor = data->user_policy.governor; 1734 1735 /* BIOS might change freq behind our back 1736 -> ask driver for current freq and notify governors about a change */ 1737 if (cpufreq_driver->get) { 1738 policy.cur = cpufreq_driver->get(cpu); 1739 if (!data->cur) { 1740 dprintk("Driver did not initialize current freq"); 1741 data->cur = policy.cur; 1742 } else { 1743 if (data->cur != policy.cur) 1744 cpufreq_out_of_sync(cpu, data->cur, 1745 policy.cur); 1746 } 1747 } 1748 1749 ret = __cpufreq_set_policy(data, &policy); 1750 1751 unlock_policy_rwsem_write(cpu); 1752 1753 cpufreq_cpu_put(data); 1754 return ret; 1755 } 1756 EXPORT_SYMBOL(cpufreq_update_policy); 1757 1758 static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb, 1759 unsigned long action, void *hcpu) 1760 { 1761 unsigned int cpu = (unsigned long)hcpu; 1762 struct sys_device *sys_dev; 1763 1764 sys_dev = get_cpu_sysdev(cpu); 1765 if (sys_dev) { 1766 switch (action) { 1767 case CPU_ONLINE: 1768 case CPU_ONLINE_FROZEN: 1769 cpufreq_add_dev(sys_dev); 1770 break; 1771 case CPU_DOWN_PREPARE: 1772 case CPU_DOWN_PREPARE_FROZEN: 1773 if (unlikely(lock_policy_rwsem_write(cpu))) 1774 BUG(); 1775 1776 __cpufreq_remove_dev(sys_dev); 1777 break; 1778 case CPU_DOWN_FAILED: 1779 case CPU_DOWN_FAILED_FROZEN: 1780 cpufreq_add_dev(sys_dev); 1781 break; 1782 } 1783 } 1784 return NOTIFY_OK; 1785 } 1786 1787 static struct notifier_block __refdata cpufreq_cpu_notifier = 1788 { 1789 .notifier_call = cpufreq_cpu_callback, 1790 }; 1791 1792 /********************************************************************* 1793 * REGISTER / UNREGISTER CPUFREQ DRIVER * 1794 *********************************************************************/ 1795 1796 /** 1797 * cpufreq_register_driver - register a CPU Frequency driver 1798 * @driver_data: A struct cpufreq_driver containing the values# 1799 * submitted by the CPU Frequency driver. 1800 * 1801 * Registers a CPU Frequency driver to this core code. This code 1802 * returns zero on success, -EBUSY when another driver got here first 1803 * (and isn't unregistered in the meantime). 1804 * 1805 */ 1806 int cpufreq_register_driver(struct cpufreq_driver *driver_data) 1807 { 1808 unsigned long flags; 1809 int ret; 1810 1811 if (!driver_data || !driver_data->verify || !driver_data->init || 1812 ((!driver_data->setpolicy) && (!driver_data->target))) 1813 return -EINVAL; 1814 1815 dprintk("trying to register driver %s\n", driver_data->name); 1816 1817 if (driver_data->setpolicy) 1818 driver_data->flags |= CPUFREQ_CONST_LOOPS; 1819 1820 spin_lock_irqsave(&cpufreq_driver_lock, flags); 1821 if (cpufreq_driver) { 1822 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 1823 return -EBUSY; 1824 } 1825 cpufreq_driver = driver_data; 1826 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 1827 1828 ret = sysdev_driver_register(&cpu_sysdev_class, 1829 &cpufreq_sysdev_driver); 1830 1831 if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) { 1832 int i; 1833 ret = -ENODEV; 1834 1835 /* check for at least one working CPU */ 1836 for (i = 0; i < nr_cpu_ids; i++) 1837 if (cpu_possible(i) && per_cpu(cpufreq_cpu_data, i)) { 1838 ret = 0; 1839 break; 1840 } 1841 1842 /* if all ->init() calls failed, unregister */ 1843 if (ret) { 1844 dprintk("no CPU initialized for driver %s\n", 1845 driver_data->name); 1846 sysdev_driver_unregister(&cpu_sysdev_class, 1847 &cpufreq_sysdev_driver); 1848 1849 spin_lock_irqsave(&cpufreq_driver_lock, flags); 1850 cpufreq_driver = NULL; 1851 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 1852 } 1853 } 1854 1855 if (!ret) { 1856 register_hotcpu_notifier(&cpufreq_cpu_notifier); 1857 dprintk("driver %s up and running\n", driver_data->name); 1858 cpufreq_debug_enable_ratelimit(); 1859 } 1860 1861 return ret; 1862 } 1863 EXPORT_SYMBOL_GPL(cpufreq_register_driver); 1864 1865 1866 /** 1867 * cpufreq_unregister_driver - unregister the current CPUFreq driver 1868 * 1869 * Unregister the current CPUFreq driver. Only call this if you have 1870 * the right to do so, i.e. if you have succeeded in initialising before! 1871 * Returns zero if successful, and -EINVAL if the cpufreq_driver is 1872 * currently not initialised. 1873 */ 1874 int cpufreq_unregister_driver(struct cpufreq_driver *driver) 1875 { 1876 unsigned long flags; 1877 1878 cpufreq_debug_disable_ratelimit(); 1879 1880 if (!cpufreq_driver || (driver != cpufreq_driver)) { 1881 cpufreq_debug_enable_ratelimit(); 1882 return -EINVAL; 1883 } 1884 1885 dprintk("unregistering driver %s\n", driver->name); 1886 1887 sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver); 1888 unregister_hotcpu_notifier(&cpufreq_cpu_notifier); 1889 1890 spin_lock_irqsave(&cpufreq_driver_lock, flags); 1891 cpufreq_driver = NULL; 1892 spin_unlock_irqrestore(&cpufreq_driver_lock, flags); 1893 1894 return 0; 1895 } 1896 EXPORT_SYMBOL_GPL(cpufreq_unregister_driver); 1897 1898 static int __init cpufreq_core_init(void) 1899 { 1900 int cpu; 1901 1902 for_each_possible_cpu(cpu) { 1903 per_cpu(policy_cpu, cpu) = -1; 1904 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu)); 1905 } 1906 return 0; 1907 } 1908 1909 core_initcall(cpufreq_core_init); 1910