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