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