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