Merge master.kernel.org:/home/rmk/linux-2.6-arm
[linux-2.6] / 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  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  *
14  */
15
16 #include <linux/config.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/notifier.h>
21 #include <linux/cpufreq.h>
22 #include <linux/delay.h>
23 #include <linux/interrupt.h>
24 #include <linux/spinlock.h>
25 #include <linux/device.h>
26 #include <linux/slab.h>
27 #include <linux/cpu.h>
28 #include <linux/completion.h>
29
30 #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_CORE, "cpufreq-core", msg)
31
32 /**
33  * The "cpufreq driver" - the arch- or hardware-dependend low
34  * level driver of CPUFreq support, and its spinlock. This lock
35  * also protects the cpufreq_cpu_data array.
36  */
37 static struct cpufreq_driver    *cpufreq_driver;
38 static struct cpufreq_policy    *cpufreq_cpu_data[NR_CPUS];
39 static DEFINE_SPINLOCK(cpufreq_driver_lock);
40
41
42 /* internal prototypes */
43 static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event);
44 static void handle_update(void *data);
45 static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci);
46
47 /**
48  * Two notifier lists: the "policy" list is involved in the 
49  * validation process for a new CPU frequency policy; the 
50  * "transition" list for kernel code that needs to handle
51  * changes to devices when the CPU clock speed changes.
52  * The mutex locks both lists.
53  */
54 static struct notifier_block    *cpufreq_policy_notifier_list;
55 static struct notifier_block    *cpufreq_transition_notifier_list;
56 static DECLARE_RWSEM            (cpufreq_notifier_rwsem);
57
58
59 static LIST_HEAD(cpufreq_governor_list);
60 static DECLARE_MUTEX            (cpufreq_governor_sem);
61
62 struct cpufreq_policy * cpufreq_cpu_get(unsigned int cpu)
63 {
64         struct cpufreq_policy *data;
65         unsigned long flags;
66
67         if (cpu >= NR_CPUS)
68                 goto err_out;
69
70         /* get the cpufreq driver */
71         spin_lock_irqsave(&cpufreq_driver_lock, flags);
72
73         if (!cpufreq_driver)
74                 goto err_out_unlock;
75
76         if (!try_module_get(cpufreq_driver->owner))
77                 goto err_out_unlock;
78
79
80         /* get the CPU */
81         data = cpufreq_cpu_data[cpu];
82
83         if (!data)
84                 goto err_out_put_module;
85
86         if (!kobject_get(&data->kobj))
87                 goto err_out_put_module;
88
89
90         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
91
92         return data;
93
94  err_out_put_module:
95         module_put(cpufreq_driver->owner);
96  err_out_unlock:
97         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
98  err_out:
99         return NULL;
100 }
101 EXPORT_SYMBOL_GPL(cpufreq_cpu_get);
102
103 void cpufreq_cpu_put(struct cpufreq_policy *data)
104 {
105         kobject_put(&data->kobj);
106         module_put(cpufreq_driver->owner);
107 }
108 EXPORT_SYMBOL_GPL(cpufreq_cpu_put);
109
110
111 /*********************************************************************
112  *                     UNIFIED DEBUG HELPERS                         *
113  *********************************************************************/
114 #ifdef CONFIG_CPU_FREQ_DEBUG
115
116 /* what part(s) of the CPUfreq subsystem are debugged? */
117 static unsigned int debug;
118
119 /* is the debug output ratelimit'ed using printk_ratelimit? User can
120  * set or modify this value.
121  */
122 static unsigned int debug_ratelimit = 1;
123
124 /* is the printk_ratelimit'ing enabled? It's enabled after a successful
125  * loading of a cpufreq driver, temporarily disabled when a new policy
126  * is set, and disabled upon cpufreq driver removal
127  */
128 static unsigned int disable_ratelimit = 1;
129 static DEFINE_SPINLOCK(disable_ratelimit_lock);
130
131 static inline void cpufreq_debug_enable_ratelimit(void)
132 {
133         unsigned long flags;
134
135         spin_lock_irqsave(&disable_ratelimit_lock, flags);
136         if (disable_ratelimit)
137                 disable_ratelimit--;
138         spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
139 }
140
141 static inline void cpufreq_debug_disable_ratelimit(void)
142 {
143         unsigned long flags;
144
145         spin_lock_irqsave(&disable_ratelimit_lock, flags);
146         disable_ratelimit++;
147         spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
148 }
149
150 void cpufreq_debug_printk(unsigned int type, const char *prefix, const char *fmt, ...)
151 {
152         char s[256];
153         va_list args;
154         unsigned int len;
155         unsigned long flags;
156         
157         WARN_ON(!prefix);
158         if (type & debug) {
159                 spin_lock_irqsave(&disable_ratelimit_lock, flags);
160                 if (!disable_ratelimit && debug_ratelimit && !printk_ratelimit()) {
161                         spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
162                         return;
163                 }
164                 spin_unlock_irqrestore(&disable_ratelimit_lock, flags);
165
166                 len = snprintf(s, 256, KERN_DEBUG "%s: ", prefix);
167
168                 va_start(args, fmt);
169                 len += vsnprintf(&s[len], (256 - len), fmt, args);
170                 va_end(args);
171
172                 printk(s);
173
174                 WARN_ON(len < 5);
175         }
176 }
177 EXPORT_SYMBOL(cpufreq_debug_printk);
178
179
180 module_param(debug, uint, 0644);
181 MODULE_PARM_DESC(debug, "CPUfreq debugging: add 1 to debug core, 2 to debug drivers, and 4 to debug governors.");
182
183 module_param(debug_ratelimit, uint, 0644);
184 MODULE_PARM_DESC(debug_ratelimit, "CPUfreq debugging: set to 0 to disable ratelimiting.");
185
186 #else /* !CONFIG_CPU_FREQ_DEBUG */
187
188 static inline void cpufreq_debug_enable_ratelimit(void) { return; }
189 static inline void cpufreq_debug_disable_ratelimit(void) { return; }
190
191 #endif /* CONFIG_CPU_FREQ_DEBUG */
192
193
194 /*********************************************************************
195  *            EXTERNALLY AFFECTING FREQUENCY CHANGES                 *
196  *********************************************************************/
197
198 /**
199  * adjust_jiffies - adjust the system "loops_per_jiffy"
200  *
201  * This function alters the system "loops_per_jiffy" for the clock
202  * speed change. Note that loops_per_jiffy cannot be updated on SMP
203  * systems as each CPU might be scaled differently. So, use the arch 
204  * per-CPU loops_per_jiffy value wherever possible.
205  */
206 #ifndef CONFIG_SMP
207 static unsigned long l_p_j_ref;
208 static unsigned int  l_p_j_ref_freq;
209
210 static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci)
211 {
212         if (ci->flags & CPUFREQ_CONST_LOOPS)
213                 return;
214
215         if (!l_p_j_ref_freq) {
216                 l_p_j_ref = loops_per_jiffy;
217                 l_p_j_ref_freq = ci->old;
218                 dprintk("saving %lu as reference value for loops_per_jiffy; freq is %u kHz\n", l_p_j_ref, l_p_j_ref_freq);
219         }
220         if ((val == CPUFREQ_PRECHANGE  && ci->old < ci->new) ||
221             (val == CPUFREQ_POSTCHANGE && ci->old > ci->new) ||
222             (val == CPUFREQ_RESUMECHANGE || val == CPUFREQ_SUSPENDCHANGE)) {
223                 loops_per_jiffy = cpufreq_scale(l_p_j_ref, l_p_j_ref_freq, ci->new);
224                 dprintk("scaling loops_per_jiffy to %lu for frequency %u kHz\n", loops_per_jiffy, ci->new);
225         }
226 }
227 #else
228 static inline void adjust_jiffies(unsigned long val, struct cpufreq_freqs *ci) { return; }
229 #endif
230
231
232 /**
233  * cpufreq_notify_transition - call notifier chain and adjust_jiffies on frequency transition
234  *
235  * This function calls the transition notifiers and the "adjust_jiffies" function. It is called
236  * twice on all CPU frequency changes that have external effects. 
237  */
238 void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
239 {
240         BUG_ON(irqs_disabled());
241
242         freqs->flags = cpufreq_driver->flags;
243         dprintk("notification %u of frequency transition to %u kHz\n", state, freqs->new);
244
245         down_read(&cpufreq_notifier_rwsem);
246         switch (state) {
247         case CPUFREQ_PRECHANGE:
248                 /* detect if the driver reported a value as "old frequency" which
249                  * is not equal to what the cpufreq core thinks is "old frequency".
250                  */
251                 if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
252                         if ((likely(cpufreq_cpu_data[freqs->cpu])) &&
253                             (likely(cpufreq_cpu_data[freqs->cpu]->cpu == freqs->cpu)) &&
254                             (likely(cpufreq_cpu_data[freqs->cpu]->cur)) &&
255                             (unlikely(freqs->old != cpufreq_cpu_data[freqs->cpu]->cur)))
256                         {
257                                 dprintk(KERN_WARNING "Warning: CPU frequency is %u, "
258                                        "cpufreq assumed %u kHz.\n", freqs->old, cpufreq_cpu_data[freqs->cpu]->cur);
259                                 freqs->old = cpufreq_cpu_data[freqs->cpu]->cur;
260                         }
261                 }
262                 notifier_call_chain(&cpufreq_transition_notifier_list, CPUFREQ_PRECHANGE, freqs);
263                 adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
264                 break;
265         case CPUFREQ_POSTCHANGE:
266                 adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
267                 notifier_call_chain(&cpufreq_transition_notifier_list, CPUFREQ_POSTCHANGE, freqs);
268                 if ((likely(cpufreq_cpu_data[freqs->cpu])) && 
269                     (likely(cpufreq_cpu_data[freqs->cpu]->cpu == freqs->cpu)))
270                         cpufreq_cpu_data[freqs->cpu]->cur = freqs->new;
271                 break;
272         }
273         up_read(&cpufreq_notifier_rwsem);
274 }
275 EXPORT_SYMBOL_GPL(cpufreq_notify_transition);
276
277
278
279 /*********************************************************************
280  *                          SYSFS INTERFACE                          *
281  *********************************************************************/
282
283 /**
284  * cpufreq_parse_governor - parse a governor string
285  */
286 static int cpufreq_parse_governor (char *str_governor, unsigned int *policy,
287                                 struct cpufreq_governor **governor)
288 {
289         if (!cpufreq_driver)
290                 return -EINVAL;
291         if (cpufreq_driver->setpolicy) {
292                 if (!strnicmp(str_governor, "performance", CPUFREQ_NAME_LEN)) {
293                         *policy = CPUFREQ_POLICY_PERFORMANCE;
294                         return 0;
295                 } else if (!strnicmp(str_governor, "powersave", CPUFREQ_NAME_LEN)) {
296                         *policy = CPUFREQ_POLICY_POWERSAVE;
297                         return 0;
298                 }
299                 return -EINVAL;
300         } else {
301                 struct cpufreq_governor *t;
302                 down(&cpufreq_governor_sem);
303                 if (!cpufreq_driver || !cpufreq_driver->target)
304                         goto out;
305                 list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
306                         if (!strnicmp(str_governor,t->name,CPUFREQ_NAME_LEN)) {
307                                 *governor = t;
308                                 up(&cpufreq_governor_sem);
309                                 return 0;
310                         }
311                 }
312         out:
313                 up(&cpufreq_governor_sem);
314         }
315         return -EINVAL;
316 }
317 EXPORT_SYMBOL_GPL(cpufreq_parse_governor);
318
319
320 /* drivers/base/cpu.c */
321 extern struct sysdev_class cpu_sysdev_class;
322
323
324 /**
325  * cpufreq_per_cpu_attr_read() / show_##file_name() - print out cpufreq information
326  *
327  * Write out information from cpufreq_driver->policy[cpu]; object must be
328  * "unsigned int".
329  */
330
331 #define show_one(file_name, object)                                     \
332 static ssize_t show_##file_name                                         \
333 (struct cpufreq_policy * policy, char *buf)                             \
334 {                                                                       \
335         return sprintf (buf, "%u\n", policy->object);                   \
336 }
337
338 show_one(cpuinfo_min_freq, cpuinfo.min_freq);
339 show_one(cpuinfo_max_freq, cpuinfo.max_freq);
340 show_one(scaling_min_freq, min);
341 show_one(scaling_max_freq, max);
342 show_one(scaling_cur_freq, cur);
343
344 /**
345  * cpufreq_per_cpu_attr_write() / store_##file_name() - sysfs write access
346  */
347 #define store_one(file_name, object)                    \
348 static ssize_t store_##file_name                                        \
349 (struct cpufreq_policy * policy, const char *buf, size_t count)         \
350 {                                                                       \
351         unsigned int ret = -EINVAL;                                     \
352         struct cpufreq_policy new_policy;                               \
353                                                                         \
354         ret = cpufreq_get_policy(&new_policy, policy->cpu);             \
355         if (ret)                                                        \
356                 return -EINVAL;                                         \
357                                                                         \
358         ret = sscanf (buf, "%u", &new_policy.object);                   \
359         if (ret != 1)                                                   \
360                 return -EINVAL;                                         \
361                                                                         \
362         ret = cpufreq_set_policy(&new_policy);                          \
363                                                                         \
364         return ret ? ret : count;                                       \
365 }
366
367 store_one(scaling_min_freq,min);
368 store_one(scaling_max_freq,max);
369
370 /**
371  * show_cpuinfo_cur_freq - current CPU frequency as detected by hardware
372  */
373 static ssize_t show_cpuinfo_cur_freq (struct cpufreq_policy * policy, char *buf)
374 {
375         unsigned int cur_freq = cpufreq_get(policy->cpu);
376         if (!cur_freq)
377                 return sprintf(buf, "<unknown>");
378         return sprintf(buf, "%u\n", cur_freq);
379 }
380
381
382 /**
383  * show_scaling_governor - show the current policy for the specified CPU
384  */
385 static ssize_t show_scaling_governor (struct cpufreq_policy * policy, char *buf)
386 {
387         if(policy->policy == CPUFREQ_POLICY_POWERSAVE)
388                 return sprintf(buf, "powersave\n");
389         else if (policy->policy == CPUFREQ_POLICY_PERFORMANCE)
390                 return sprintf(buf, "performance\n");
391         else if (policy->governor)
392                 return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", policy->governor->name);
393         return -EINVAL;
394 }
395
396
397 /**
398  * store_scaling_governor - store policy for the specified CPU
399  */
400 static ssize_t store_scaling_governor (struct cpufreq_policy * policy, 
401                                        const char *buf, size_t count) 
402 {
403         unsigned int ret = -EINVAL;
404         char    str_governor[16];
405         struct cpufreq_policy new_policy;
406
407         ret = cpufreq_get_policy(&new_policy, policy->cpu);
408         if (ret)
409                 return ret;
410
411         ret = sscanf (buf, "%15s", str_governor);
412         if (ret != 1)
413                 return -EINVAL;
414
415         if (cpufreq_parse_governor(str_governor, &new_policy.policy, &new_policy.governor))
416                 return -EINVAL;
417
418         ret = cpufreq_set_policy(&new_policy);
419
420         return ret ? ret : count;
421 }
422
423 /**
424  * show_scaling_driver - show the cpufreq driver currently loaded
425  */
426 static ssize_t show_scaling_driver (struct cpufreq_policy * policy, char *buf)
427 {
428         return scnprintf(buf, CPUFREQ_NAME_LEN, "%s\n", cpufreq_driver->name);
429 }
430
431 /**
432  * show_scaling_available_governors - show the available CPUfreq governors
433  */
434 static ssize_t show_scaling_available_governors (struct cpufreq_policy * policy,
435                                 char *buf)
436 {
437         ssize_t i = 0;
438         struct cpufreq_governor *t;
439
440         if (!cpufreq_driver->target) {
441                 i += sprintf(buf, "performance powersave");
442                 goto out;
443         }
444
445         list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
446                 if (i >= (ssize_t) ((PAGE_SIZE / sizeof(char)) - (CPUFREQ_NAME_LEN + 2)))
447                         goto out;
448                 i += scnprintf(&buf[i], CPUFREQ_NAME_LEN, "%s ", t->name);
449         }
450  out:
451         i += sprintf(&buf[i], "\n");
452         return i;
453 }
454 /**
455  * show_affected_cpus - show the CPUs affected by each transition
456  */
457 static ssize_t show_affected_cpus (struct cpufreq_policy * policy, char *buf)
458 {
459         ssize_t i = 0;
460         unsigned int cpu;
461
462         for_each_cpu_mask(cpu, policy->cpus) {
463                 if (i)
464                         i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), " ");
465                 i += scnprintf(&buf[i], (PAGE_SIZE - i - 2), "%u", cpu);
466                 if (i >= (PAGE_SIZE - 5))
467                     break;
468         }
469         i += sprintf(&buf[i], "\n");
470         return i;
471 }
472
473
474 #define define_one_ro(_name) \
475 static struct freq_attr _name = \
476 __ATTR(_name, 0444, show_##_name, NULL)
477
478 #define define_one_ro0400(_name) \
479 static struct freq_attr _name = \
480 __ATTR(_name, 0400, show_##_name, NULL)
481
482 #define define_one_rw(_name) \
483 static struct freq_attr _name = \
484 __ATTR(_name, 0644, show_##_name, store_##_name)
485
486 define_one_ro0400(cpuinfo_cur_freq);
487 define_one_ro(cpuinfo_min_freq);
488 define_one_ro(cpuinfo_max_freq);
489 define_one_ro(scaling_available_governors);
490 define_one_ro(scaling_driver);
491 define_one_ro(scaling_cur_freq);
492 define_one_ro(affected_cpus);
493 define_one_rw(scaling_min_freq);
494 define_one_rw(scaling_max_freq);
495 define_one_rw(scaling_governor);
496
497 static struct attribute * default_attrs[] = {
498         &cpuinfo_min_freq.attr,
499         &cpuinfo_max_freq.attr,
500         &scaling_min_freq.attr,
501         &scaling_max_freq.attr,
502         &affected_cpus.attr,
503         &scaling_governor.attr,
504         &scaling_driver.attr,
505         &scaling_available_governors.attr,
506         NULL
507 };
508
509 #define to_policy(k) container_of(k,struct cpufreq_policy,kobj)
510 #define to_attr(a) container_of(a,struct freq_attr,attr)
511
512 static ssize_t show(struct kobject * kobj, struct attribute * attr ,char * buf)
513 {
514         struct cpufreq_policy * policy = to_policy(kobj);
515         struct freq_attr * fattr = to_attr(attr);
516         ssize_t ret;
517         policy = cpufreq_cpu_get(policy->cpu);
518         if (!policy)
519                 return -EINVAL;
520         ret = fattr->show ? fattr->show(policy,buf) : -EIO;
521         cpufreq_cpu_put(policy);
522         return ret;
523 }
524
525 static ssize_t store(struct kobject * kobj, struct attribute * attr, 
526                      const char * buf, size_t count)
527 {
528         struct cpufreq_policy * policy = to_policy(kobj);
529         struct freq_attr * fattr = to_attr(attr);
530         ssize_t ret;
531         policy = cpufreq_cpu_get(policy->cpu);
532         if (!policy)
533                 return -EINVAL;
534         ret = fattr->store ? fattr->store(policy,buf,count) : -EIO;
535         cpufreq_cpu_put(policy);
536         return ret;
537 }
538
539 static void cpufreq_sysfs_release(struct kobject * kobj)
540 {
541         struct cpufreq_policy * policy = to_policy(kobj);
542         dprintk("last reference is dropped\n");
543         complete(&policy->kobj_unregister);
544 }
545
546 static struct sysfs_ops sysfs_ops = {
547         .show   = show,
548         .store  = store,
549 };
550
551 static struct kobj_type ktype_cpufreq = {
552         .sysfs_ops      = &sysfs_ops,
553         .default_attrs  = default_attrs,
554         .release        = cpufreq_sysfs_release,
555 };
556
557
558 /**
559  * cpufreq_add_dev - add a CPU device
560  *
561  * Adds the cpufreq interface for a CPU device. 
562  */
563 static int cpufreq_add_dev (struct sys_device * sys_dev)
564 {
565         unsigned int cpu = sys_dev->id;
566         int ret = 0;
567         struct cpufreq_policy new_policy;
568         struct cpufreq_policy *policy;
569         struct freq_attr **drv_attr;
570         unsigned long flags;
571         unsigned int j;
572
573         if (cpu_is_offline(cpu))
574                 return 0;
575
576         cpufreq_debug_disable_ratelimit();
577         dprintk("adding CPU %u\n", cpu);
578
579 #ifdef CONFIG_SMP
580         /* check whether a different CPU already registered this
581          * CPU because it is in the same boat. */
582         policy = cpufreq_cpu_get(cpu);
583         if (unlikely(policy)) {
584                 dprintk("CPU already managed, adding link\n");
585                 sysfs_create_link(&sys_dev->kobj, &policy->kobj, "cpufreq");
586                 cpufreq_debug_enable_ratelimit();
587                 return 0;
588         }
589 #endif
590
591         if (!try_module_get(cpufreq_driver->owner)) {
592                 ret = -EINVAL;
593                 goto module_out;
594         }
595
596         policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
597         if (!policy) {
598                 ret = -ENOMEM;
599                 goto nomem_out;
600         }
601
602         policy->cpu = cpu;
603         policy->cpus = cpumask_of_cpu(cpu);
604
605         init_MUTEX_LOCKED(&policy->lock);
606         init_completion(&policy->kobj_unregister);
607         INIT_WORK(&policy->update, handle_update, (void *)(long)cpu);
608
609         /* call driver. From then on the cpufreq must be able
610          * to accept all calls to ->verify and ->setpolicy for this CPU
611          */
612         ret = cpufreq_driver->init(policy);
613         if (ret) {
614                 dprintk("initialization failed\n");
615                 goto err_out;
616         }
617
618         memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
619
620         /* prepare interface data */
621         policy->kobj.parent = &sys_dev->kobj;
622         policy->kobj.ktype = &ktype_cpufreq;
623         strlcpy(policy->kobj.name, "cpufreq", KOBJ_NAME_LEN);
624
625         ret = kobject_register(&policy->kobj);
626         if (ret)
627                 goto err_out_driver_exit;
628
629         /* set up files for this cpu device */
630         drv_attr = cpufreq_driver->attr;
631         while ((drv_attr) && (*drv_attr)) {
632                 sysfs_create_file(&policy->kobj, &((*drv_attr)->attr));
633                 drv_attr++;
634         }
635         if (cpufreq_driver->get)
636                 sysfs_create_file(&policy->kobj, &cpuinfo_cur_freq.attr);
637         if (cpufreq_driver->target)
638                 sysfs_create_file(&policy->kobj, &scaling_cur_freq.attr);
639
640         spin_lock_irqsave(&cpufreq_driver_lock, flags);
641         for_each_cpu_mask(j, policy->cpus)
642                 cpufreq_cpu_data[j] = policy;
643         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
644         policy->governor = NULL; /* to assure that the starting sequence is
645                                   * run in cpufreq_set_policy */
646         up(&policy->lock);
647         
648         /* set default policy */
649         
650         ret = cpufreq_set_policy(&new_policy);
651         if (ret) {
652                 dprintk("setting policy failed\n");
653                 goto err_out_unregister;
654         }
655
656         module_put(cpufreq_driver->owner);
657         dprintk("initialization complete\n");
658         cpufreq_debug_enable_ratelimit();
659         
660         return 0;
661
662
663 err_out_unregister:
664         spin_lock_irqsave(&cpufreq_driver_lock, flags);
665         for_each_cpu_mask(j, policy->cpus)
666                 cpufreq_cpu_data[j] = NULL;
667         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
668
669         kobject_unregister(&policy->kobj);
670         wait_for_completion(&policy->kobj_unregister);
671
672 err_out_driver_exit:
673         if (cpufreq_driver->exit)
674                 cpufreq_driver->exit(policy);
675
676 err_out:
677         kfree(policy);
678
679 nomem_out:
680         module_put(cpufreq_driver->owner);
681 module_out:
682         cpufreq_debug_enable_ratelimit();
683         return ret;
684 }
685
686
687 /**
688  * cpufreq_remove_dev - remove a CPU device
689  *
690  * Removes the cpufreq interface for a CPU device.
691  */
692 static int cpufreq_remove_dev (struct sys_device * sys_dev)
693 {
694         unsigned int cpu = sys_dev->id;
695         unsigned long flags;
696         struct cpufreq_policy *data;
697         struct sys_device *cpu_sys_dev;
698 #ifdef CONFIG_SMP
699         unsigned int j;
700 #endif
701
702         cpufreq_debug_disable_ratelimit();
703         dprintk("unregistering CPU %u\n", cpu);
704
705         spin_lock_irqsave(&cpufreq_driver_lock, flags);
706         data = cpufreq_cpu_data[cpu];
707
708         if (!data) {
709                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
710                 cpufreq_debug_enable_ratelimit();
711                 return -EINVAL;
712         }
713         cpufreq_cpu_data[cpu] = NULL;
714
715
716 #ifdef CONFIG_SMP
717         /* if this isn't the CPU which is the parent of the kobj, we
718          * only need to unlink, put and exit 
719          */
720         if (unlikely(cpu != data->cpu)) {
721                 dprintk("removing link\n");
722                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
723                 sysfs_remove_link(&sys_dev->kobj, "cpufreq");
724                 cpufreq_cpu_put(data);
725                 cpufreq_debug_enable_ratelimit();
726                 return 0;
727         }
728 #endif
729
730
731         if (!kobject_get(&data->kobj)) {
732                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
733                 cpufreq_debug_enable_ratelimit();
734                 return -EFAULT;
735         }
736
737 #ifdef CONFIG_SMP
738         /* if we have other CPUs still registered, we need to unlink them,
739          * or else wait_for_completion below will lock up. Clean the
740          * cpufreq_cpu_data[] while holding the lock, and remove the sysfs
741          * links afterwards.
742          */
743         if (unlikely(cpus_weight(data->cpus) > 1)) {
744                 for_each_cpu_mask(j, data->cpus) {
745                         if (j == cpu)
746                                 continue;
747                         cpufreq_cpu_data[j] = NULL;
748                 }
749         }
750
751         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
752
753         if (unlikely(cpus_weight(data->cpus) > 1)) {
754                 for_each_cpu_mask(j, data->cpus) {
755                         if (j == cpu)
756                                 continue;
757                         dprintk("removing link for cpu %u\n", j);
758                         cpu_sys_dev = get_cpu_sysdev(j);
759                         sysfs_remove_link(&cpu_sys_dev->kobj, "cpufreq");
760                         cpufreq_cpu_put(data);
761                 }
762         }
763 #else
764         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
765 #endif
766
767         down(&data->lock);
768         if (cpufreq_driver->target)
769                 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
770         up(&data->lock);
771
772         kobject_unregister(&data->kobj);
773
774         kobject_put(&data->kobj);
775
776         /* we need to make sure that the underlying kobj is actually
777          * not referenced anymore by anybody before we proceed with 
778          * unloading.
779          */
780         dprintk("waiting for dropping of refcount\n");
781         wait_for_completion(&data->kobj_unregister);
782         dprintk("wait complete\n");
783
784         if (cpufreq_driver->exit)
785                 cpufreq_driver->exit(data);
786
787         kfree(data);
788
789         cpufreq_debug_enable_ratelimit();
790
791         return 0;
792 }
793
794
795 static void handle_update(void *data)
796 {
797         unsigned int cpu = (unsigned int)(long)data;
798         dprintk("handle_update for cpu %u called\n", cpu);
799         cpufreq_update_policy(cpu);
800 }
801
802 /**
803  *      cpufreq_out_of_sync - If actual and saved CPU frequency differs, we're in deep trouble.
804  *      @cpu: cpu number
805  *      @old_freq: CPU frequency the kernel thinks the CPU runs at
806  *      @new_freq: CPU frequency the CPU actually runs at
807  *
808  *      We adjust to current frequency first, and need to clean up later. So either call
809  *      to cpufreq_update_policy() or schedule handle_update()).
810  */
811 static void cpufreq_out_of_sync(unsigned int cpu, unsigned int old_freq, unsigned int new_freq)
812 {
813         struct cpufreq_freqs freqs;
814
815         dprintk(KERN_WARNING "Warning: CPU frequency out of sync: cpufreq and timing "
816                "core thinks of %u, is %u kHz.\n", old_freq, new_freq);
817
818         freqs.cpu = cpu;
819         freqs.old = old_freq;
820         freqs.new = new_freq;
821         cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE);
822         cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
823 }
824
825
826 /** 
827  * cpufreq_get - get the current CPU frequency (in kHz)
828  * @cpu: CPU number
829  *
830  * Get the CPU current (static) CPU frequency
831  */
832 unsigned int cpufreq_get(unsigned int cpu)
833 {
834         struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
835         unsigned int ret = 0;
836
837         if (!policy)
838                 return 0;
839
840         if (!cpufreq_driver->get)
841                 goto out;
842
843         down(&policy->lock);
844
845         ret = cpufreq_driver->get(cpu);
846
847         if (ret && policy->cur && !(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) 
848         {
849                 /* verify no discrepancy between actual and saved value exists */
850                 if (unlikely(ret != policy->cur)) {
851                         cpufreq_out_of_sync(cpu, policy->cur, ret);
852                         schedule_work(&policy->update);
853                 }
854         }
855
856         up(&policy->lock);
857
858  out:
859         cpufreq_cpu_put(policy);
860
861         return (ret);
862 }
863 EXPORT_SYMBOL(cpufreq_get);
864
865
866 /**
867  *      cpufreq_suspend - let the low level driver prepare for suspend
868  */
869
870 static int cpufreq_suspend(struct sys_device * sysdev, pm_message_t pmsg)
871 {
872         int cpu = sysdev->id;
873         unsigned int ret = 0;
874         unsigned int cur_freq = 0;
875         struct cpufreq_policy *cpu_policy;
876
877         dprintk("resuming cpu %u\n", cpu);
878
879         if (!cpu_online(cpu))
880                 return 0;
881
882         /* we may be lax here as interrupts are off. Nonetheless
883          * we need to grab the correct cpu policy, as to check
884          * whether we really run on this CPU.
885          */
886
887         cpu_policy = cpufreq_cpu_get(cpu);
888         if (!cpu_policy)
889                 return -EINVAL;
890
891         /* only handle each CPU group once */
892         if (unlikely(cpu_policy->cpu != cpu)) {
893                 cpufreq_cpu_put(cpu_policy);
894                 return 0;
895         }
896
897         if (cpufreq_driver->suspend) {
898                 ret = cpufreq_driver->suspend(cpu_policy, pmsg);
899                 if (ret) {
900                         printk(KERN_ERR "cpufreq: suspend failed in ->suspend "
901                                         "step on CPU %u\n", cpu_policy->cpu);
902                         cpufreq_cpu_put(cpu_policy);
903                         return ret;
904                 }
905         }
906
907
908         if (cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)
909                 goto out;
910
911         if (cpufreq_driver->get)
912                 cur_freq = cpufreq_driver->get(cpu_policy->cpu);
913
914         if (!cur_freq || !cpu_policy->cur) {
915                 printk(KERN_ERR "cpufreq: suspend failed to assert current "
916                        "frequency is what timing core thinks it is.\n");
917                 goto out;
918         }
919
920         if (unlikely(cur_freq != cpu_policy->cur)) {
921                 struct cpufreq_freqs freqs;
922
923                 if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
924                         dprintk(KERN_DEBUG "Warning: CPU frequency is %u, "
925                                "cpufreq assumed %u kHz.\n",
926                                cur_freq, cpu_policy->cur);
927
928                 freqs.cpu = cpu;
929                 freqs.old = cpu_policy->cur;
930                 freqs.new = cur_freq;
931
932                 notifier_call_chain(&cpufreq_transition_notifier_list,
933                                     CPUFREQ_SUSPENDCHANGE, &freqs);
934                 adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs);
935
936                 cpu_policy->cur = cur_freq;
937         }
938
939  out:
940         cpufreq_cpu_put(cpu_policy);
941         return 0;
942 }
943
944 /**
945  *      cpufreq_resume -  restore proper CPU frequency handling after resume
946  *
947  *      1.) resume CPUfreq hardware support (cpufreq_driver->resume())
948  *      2.) if ->target and !CPUFREQ_CONST_LOOPS: verify we're in sync
949  *      3.) schedule call cpufreq_update_policy() ASAP as interrupts are
950  *          restored.
951  */
952 static int cpufreq_resume(struct sys_device * sysdev)
953 {
954         int cpu = sysdev->id;
955         unsigned int ret = 0;
956         struct cpufreq_policy *cpu_policy;
957
958         dprintk("resuming cpu %u\n", cpu);
959
960         if (!cpu_online(cpu))
961                 return 0;
962
963         /* we may be lax here as interrupts are off. Nonetheless
964          * we need to grab the correct cpu policy, as to check
965          * whether we really run on this CPU.
966          */
967
968         cpu_policy = cpufreq_cpu_get(cpu);
969         if (!cpu_policy)
970                 return -EINVAL;
971
972         /* only handle each CPU group once */
973         if (unlikely(cpu_policy->cpu != cpu)) {
974                 cpufreq_cpu_put(cpu_policy);
975                 return 0;
976         }
977
978         if (cpufreq_driver->resume) {
979                 ret = cpufreq_driver->resume(cpu_policy);
980                 if (ret) {
981                         printk(KERN_ERR "cpufreq: resume failed in ->resume "
982                                         "step on CPU %u\n", cpu_policy->cpu);
983                         cpufreq_cpu_put(cpu_policy);
984                         return ret;
985                 }
986         }
987
988         if (!(cpufreq_driver->flags & CPUFREQ_CONST_LOOPS)) {
989                 unsigned int cur_freq = 0;
990
991                 if (cpufreq_driver->get)
992                         cur_freq = cpufreq_driver->get(cpu_policy->cpu);
993
994                 if (!cur_freq || !cpu_policy->cur) {
995                         printk(KERN_ERR "cpufreq: resume failed to assert "
996                                         "current frequency is what timing core "
997                                         "thinks it is.\n");
998                         goto out;
999                 }
1000
1001                 if (unlikely(cur_freq != cpu_policy->cur)) {
1002                         struct cpufreq_freqs freqs;
1003
1004                         if (!(cpufreq_driver->flags & CPUFREQ_PM_NO_WARN))
1005                                 dprintk(KERN_WARNING "Warning: CPU frequency"
1006                                        "is %u, cpufreq assumed %u kHz.\n",
1007                                        cur_freq, cpu_policy->cur);
1008
1009                         freqs.cpu = cpu;
1010                         freqs.old = cpu_policy->cur;
1011                         freqs.new = cur_freq;
1012
1013                         notifier_call_chain(&cpufreq_transition_notifier_list,
1014                                         CPUFREQ_RESUMECHANGE, &freqs);
1015                         adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs);
1016
1017                         cpu_policy->cur = cur_freq;
1018                 }
1019         }
1020
1021 out:
1022         schedule_work(&cpu_policy->update);
1023         cpufreq_cpu_put(cpu_policy);
1024         return ret;
1025 }
1026
1027 static struct sysdev_driver cpufreq_sysdev_driver = {
1028         .add            = cpufreq_add_dev,
1029         .remove         = cpufreq_remove_dev,
1030         .suspend        = cpufreq_suspend,
1031         .resume         = cpufreq_resume,
1032 };
1033
1034
1035 /*********************************************************************
1036  *                     NOTIFIER LISTS INTERFACE                      *
1037  *********************************************************************/
1038
1039 /**
1040  *      cpufreq_register_notifier - register a driver with cpufreq
1041  *      @nb: notifier function to register
1042  *      @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1043  *
1044  *      Add a driver to one of two lists: either a list of drivers that 
1045  *      are notified about clock rate changes (once before and once after
1046  *      the transition), or a list of drivers that are notified about
1047  *      changes in cpufreq policy.
1048  *
1049  *      This function may sleep, and has the same return conditions as
1050  *      notifier_chain_register.
1051  */
1052 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
1053 {
1054         int ret;
1055
1056         down_write(&cpufreq_notifier_rwsem);
1057         switch (list) {
1058         case CPUFREQ_TRANSITION_NOTIFIER:
1059                 ret = notifier_chain_register(&cpufreq_transition_notifier_list, nb);
1060                 break;
1061         case CPUFREQ_POLICY_NOTIFIER:
1062                 ret = notifier_chain_register(&cpufreq_policy_notifier_list, nb);
1063                 break;
1064         default:
1065                 ret = -EINVAL;
1066         }
1067         up_write(&cpufreq_notifier_rwsem);
1068
1069         return ret;
1070 }
1071 EXPORT_SYMBOL(cpufreq_register_notifier);
1072
1073
1074 /**
1075  *      cpufreq_unregister_notifier - unregister a driver with cpufreq
1076  *      @nb: notifier block to be unregistered
1077  *      @list: CPUFREQ_TRANSITION_NOTIFIER or CPUFREQ_POLICY_NOTIFIER
1078  *
1079  *      Remove a driver from the CPU frequency notifier list.
1080  *
1081  *      This function may sleep, and has the same return conditions as
1082  *      notifier_chain_unregister.
1083  */
1084 int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
1085 {
1086         int ret;
1087
1088         down_write(&cpufreq_notifier_rwsem);
1089         switch (list) {
1090         case CPUFREQ_TRANSITION_NOTIFIER:
1091                 ret = notifier_chain_unregister(&cpufreq_transition_notifier_list, nb);
1092                 break;
1093         case CPUFREQ_POLICY_NOTIFIER:
1094                 ret = notifier_chain_unregister(&cpufreq_policy_notifier_list, nb);
1095                 break;
1096         default:
1097                 ret = -EINVAL;
1098         }
1099         up_write(&cpufreq_notifier_rwsem);
1100
1101         return ret;
1102 }
1103 EXPORT_SYMBOL(cpufreq_unregister_notifier);
1104
1105
1106 /*********************************************************************
1107  *                              GOVERNORS                            *
1108  *********************************************************************/
1109
1110
1111 int __cpufreq_driver_target(struct cpufreq_policy *policy,
1112                             unsigned int target_freq,
1113                             unsigned int relation)
1114 {
1115         int retval = -EINVAL;
1116
1117         /*
1118          * Converted the lock_cpu_hotplug to preempt_disable()
1119          * and preempt_enable(). This is a bit kludgy and relies on how cpu
1120          * hotplug works. All we need is a guarantee that cpu hotplug won't make
1121          * progress on any cpu. Once we do preempt_disable(), this would ensure
1122          * that hotplug threads don't get onto this cpu, thereby delaying
1123          * the cpu remove process.
1124          *
1125          * We removed the lock_cpu_hotplug since we need to call this function
1126          * via cpu hotplug callbacks, which result in locking the cpu hotplug
1127          * thread itself. Agree this is not very clean, cpufreq community
1128          * could improve this if required. - Ashok Raj <ashok.raj@intel.com>
1129          */
1130         preempt_disable();
1131         dprintk("target for CPU %u: %u kHz, relation %u\n", policy->cpu,
1132                 target_freq, relation);
1133         if (cpu_online(policy->cpu) && cpufreq_driver->target)
1134                 retval = cpufreq_driver->target(policy, target_freq, relation);
1135         preempt_enable();
1136         return retval;
1137 }
1138 EXPORT_SYMBOL_GPL(__cpufreq_driver_target);
1139
1140 int cpufreq_driver_target(struct cpufreq_policy *policy,
1141                           unsigned int target_freq,
1142                           unsigned int relation)
1143 {
1144         int ret;
1145
1146         policy = cpufreq_cpu_get(policy->cpu);
1147         if (!policy)
1148                 return -EINVAL;
1149
1150         down(&policy->lock);
1151
1152         ret = __cpufreq_driver_target(policy, target_freq, relation);
1153
1154         up(&policy->lock);
1155
1156         cpufreq_cpu_put(policy);
1157
1158         return ret;
1159 }
1160 EXPORT_SYMBOL_GPL(cpufreq_driver_target);
1161
1162
1163 static int __cpufreq_governor(struct cpufreq_policy *policy, unsigned int event)
1164 {
1165         int ret;
1166
1167         if (!try_module_get(policy->governor->owner))
1168                 return -EINVAL;
1169
1170         dprintk("__cpufreq_governor for CPU %u, event %u\n", policy->cpu, event);
1171         ret = policy->governor->governor(policy, event);
1172
1173         /* we keep one module reference alive for each CPU governed by this CPU */
1174         if ((event != CPUFREQ_GOV_START) || ret)
1175                 module_put(policy->governor->owner);
1176         if ((event == CPUFREQ_GOV_STOP) && !ret)
1177                 module_put(policy->governor->owner);
1178
1179         return ret;
1180 }
1181
1182
1183 int cpufreq_governor(unsigned int cpu, unsigned int event)
1184 {
1185         int ret = 0;
1186         struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
1187
1188         if (!policy)
1189                 return -EINVAL;
1190
1191         down(&policy->lock);
1192         ret = __cpufreq_governor(policy, event);
1193         up(&policy->lock);
1194
1195         cpufreq_cpu_put(policy);
1196
1197         return ret;
1198 }
1199 EXPORT_SYMBOL_GPL(cpufreq_governor);
1200
1201
1202 int cpufreq_register_governor(struct cpufreq_governor *governor)
1203 {
1204         struct cpufreq_governor *t;
1205
1206         if (!governor)
1207                 return -EINVAL;
1208
1209         down(&cpufreq_governor_sem);
1210         
1211         list_for_each_entry(t, &cpufreq_governor_list, governor_list) {
1212                 if (!strnicmp(governor->name,t->name,CPUFREQ_NAME_LEN)) {
1213                         up(&cpufreq_governor_sem);
1214                         return -EBUSY;
1215                 }
1216         }
1217         list_add(&governor->governor_list, &cpufreq_governor_list);
1218
1219         up(&cpufreq_governor_sem);
1220
1221         return 0;
1222 }
1223 EXPORT_SYMBOL_GPL(cpufreq_register_governor);
1224
1225
1226 void cpufreq_unregister_governor(struct cpufreq_governor *governor)
1227 {
1228         if (!governor)
1229                 return;
1230
1231         down(&cpufreq_governor_sem);
1232         list_del(&governor->governor_list);
1233         up(&cpufreq_governor_sem);
1234         return;
1235 }
1236 EXPORT_SYMBOL_GPL(cpufreq_unregister_governor);
1237
1238
1239
1240 /*********************************************************************
1241  *                          POLICY INTERFACE                         *
1242  *********************************************************************/
1243
1244 /**
1245  * cpufreq_get_policy - get the current cpufreq_policy
1246  * @policy: struct cpufreq_policy into which the current cpufreq_policy is written
1247  *
1248  * Reads the current cpufreq policy.
1249  */
1250 int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu)
1251 {
1252         struct cpufreq_policy *cpu_policy;
1253         if (!policy)
1254                 return -EINVAL;
1255
1256         cpu_policy = cpufreq_cpu_get(cpu);
1257         if (!cpu_policy)
1258                 return -EINVAL;
1259
1260         down(&cpu_policy->lock);
1261         memcpy(policy, cpu_policy, sizeof(struct cpufreq_policy));
1262         up(&cpu_policy->lock);
1263
1264         cpufreq_cpu_put(cpu_policy);
1265
1266         return 0;
1267 }
1268 EXPORT_SYMBOL(cpufreq_get_policy);
1269
1270
1271 static int __cpufreq_set_policy(struct cpufreq_policy *data, struct cpufreq_policy *policy)
1272 {
1273         int ret = 0;
1274
1275         cpufreq_debug_disable_ratelimit();
1276         dprintk("setting new policy for CPU %u: %u - %u kHz\n", policy->cpu,
1277                 policy->min, policy->max);
1278
1279         memcpy(&policy->cpuinfo, 
1280                &data->cpuinfo, 
1281                sizeof(struct cpufreq_cpuinfo));
1282
1283         /* verify the cpu speed can be set within this limit */
1284         ret = cpufreq_driver->verify(policy);
1285         if (ret)
1286                 goto error_out;
1287
1288         down_read(&cpufreq_notifier_rwsem);
1289
1290         /* adjust if necessary - all reasons */
1291         notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_ADJUST,
1292                             policy);
1293
1294         /* adjust if necessary - hardware incompatibility*/
1295         notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_INCOMPATIBLE,
1296                             policy);
1297
1298         /* verify the cpu speed can be set within this limit,
1299            which might be different to the first one */
1300         ret = cpufreq_driver->verify(policy);
1301         if (ret) {
1302                 up_read(&cpufreq_notifier_rwsem);
1303                 goto error_out;
1304         }
1305
1306         /* notification of the new policy */
1307         notifier_call_chain(&cpufreq_policy_notifier_list, CPUFREQ_NOTIFY,
1308                             policy);
1309
1310         up_read(&cpufreq_notifier_rwsem);
1311
1312         data->min    = policy->min;
1313         data->max    = policy->max;
1314
1315         dprintk("new min and max freqs are %u - %u kHz\n", data->min, data->max);
1316
1317         if (cpufreq_driver->setpolicy) {
1318                 data->policy = policy->policy;
1319                 dprintk("setting range\n");
1320                 ret = cpufreq_driver->setpolicy(policy);
1321         } else {
1322                 if (policy->governor != data->governor) {
1323                         /* save old, working values */
1324                         struct cpufreq_governor *old_gov = data->governor;
1325
1326                         dprintk("governor switch\n");
1327
1328                         /* end old governor */
1329                         if (data->governor)
1330                                 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
1331
1332                         /* start new governor */
1333                         data->governor = policy->governor;
1334                         if (__cpufreq_governor(data, CPUFREQ_GOV_START)) {
1335                                 /* new governor failed, so re-start old one */
1336                                 dprintk("starting governor %s failed\n", data->governor->name);
1337                                 if (old_gov) {
1338                                         data->governor = old_gov;
1339                                         __cpufreq_governor(data, CPUFREQ_GOV_START);
1340                                 }
1341                                 ret = -EINVAL;
1342                                 goto error_out;
1343                         }
1344                         /* might be a policy change, too, so fall through */
1345                 }
1346                 dprintk("governor: change or update limits\n");
1347                 __cpufreq_governor(data, CPUFREQ_GOV_LIMITS);
1348         }
1349
1350  error_out:
1351         cpufreq_debug_enable_ratelimit();
1352         return ret;
1353 }
1354
1355 /**
1356  *      cpufreq_set_policy - set a new CPUFreq policy
1357  *      @policy: policy to be set.
1358  *
1359  *      Sets a new CPU frequency and voltage scaling policy.
1360  */
1361 int cpufreq_set_policy(struct cpufreq_policy *policy)
1362 {
1363         int ret = 0;
1364         struct cpufreq_policy *data;
1365
1366         if (!policy)
1367                 return -EINVAL;
1368
1369         data = cpufreq_cpu_get(policy->cpu);
1370         if (!data)
1371                 return -EINVAL;
1372
1373         /* lock this CPU */
1374         down(&data->lock);
1375
1376         ret = __cpufreq_set_policy(data, policy);
1377         data->user_policy.min = data->min;
1378         data->user_policy.max = data->max;
1379         data->user_policy.policy = data->policy;
1380         data->user_policy.governor = data->governor;
1381
1382         up(&data->lock);
1383         cpufreq_cpu_put(data);
1384
1385         return ret;
1386 }
1387 EXPORT_SYMBOL(cpufreq_set_policy);
1388
1389
1390 /**
1391  *      cpufreq_update_policy - re-evaluate an existing cpufreq policy
1392  *      @cpu: CPU which shall be re-evaluated
1393  *
1394  *      Usefull for policy notifiers which have different necessities
1395  *      at different times.
1396  */
1397 int cpufreq_update_policy(unsigned int cpu)
1398 {
1399         struct cpufreq_policy *data = cpufreq_cpu_get(cpu);
1400         struct cpufreq_policy policy;
1401         int ret = 0;
1402
1403         if (!data)
1404                 return -ENODEV;
1405
1406         down(&data->lock);
1407
1408         dprintk("updating policy for CPU %u\n", cpu);
1409         memcpy(&policy, 
1410                data,
1411                sizeof(struct cpufreq_policy));
1412         policy.min = data->user_policy.min;
1413         policy.max = data->user_policy.max;
1414         policy.policy = data->user_policy.policy;
1415         policy.governor = data->user_policy.governor;
1416
1417         ret = __cpufreq_set_policy(data, &policy);
1418
1419         up(&data->lock);
1420
1421         cpufreq_cpu_put(data);
1422         return ret;
1423 }
1424 EXPORT_SYMBOL(cpufreq_update_policy);
1425
1426 static int __cpuinit cpufreq_cpu_callback(struct notifier_block *nfb,
1427                                         unsigned long action, void *hcpu)
1428 {
1429         unsigned int cpu = (unsigned long)hcpu;
1430         struct cpufreq_policy *policy;
1431         struct sys_device *sys_dev;
1432
1433         sys_dev = get_cpu_sysdev(cpu);
1434
1435         if (sys_dev) {
1436                 switch (action) {
1437                 case CPU_ONLINE:
1438                         cpufreq_add_dev(sys_dev);
1439                         break;
1440                 case CPU_DOWN_PREPARE:
1441                         /*
1442                          * We attempt to put this cpu in lowest frequency
1443                          * possible before going down. This will permit
1444                          * hardware-managed P-State to switch other related
1445                          * threads to min or higher speeds if possible.
1446                          */
1447                         policy = cpufreq_cpu_data[cpu];
1448                         if (policy) {
1449                                 cpufreq_driver_target(policy, policy->min,
1450                                                 CPUFREQ_RELATION_H);
1451                         }
1452                         break;
1453                 case CPU_DEAD:
1454                         cpufreq_remove_dev(sys_dev);
1455                         break;
1456                 }
1457         }
1458         return NOTIFY_OK;
1459 }
1460
1461 static struct notifier_block cpufreq_cpu_notifier =
1462 {
1463     .notifier_call = cpufreq_cpu_callback,
1464 };
1465
1466 /*********************************************************************
1467  *               REGISTER / UNREGISTER CPUFREQ DRIVER                *
1468  *********************************************************************/
1469
1470 /**
1471  * cpufreq_register_driver - register a CPU Frequency driver
1472  * @driver_data: A struct cpufreq_driver containing the values#
1473  * submitted by the CPU Frequency driver.
1474  *
1475  *   Registers a CPU Frequency driver to this core code. This code 
1476  * returns zero on success, -EBUSY when another driver got here first
1477  * (and isn't unregistered in the meantime). 
1478  *
1479  */
1480 int cpufreq_register_driver(struct cpufreq_driver *driver_data)
1481 {
1482         unsigned long flags;
1483         int ret;
1484
1485         if (!driver_data || !driver_data->verify || !driver_data->init ||
1486             ((!driver_data->setpolicy) && (!driver_data->target)))
1487                 return -EINVAL;
1488
1489         dprintk("trying to register driver %s\n", driver_data->name);
1490
1491         if (driver_data->setpolicy)
1492                 driver_data->flags |= CPUFREQ_CONST_LOOPS;
1493
1494         spin_lock_irqsave(&cpufreq_driver_lock, flags);
1495         if (cpufreq_driver) {
1496                 spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1497                 return -EBUSY;
1498         }
1499         cpufreq_driver = driver_data;
1500         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1501
1502         ret = sysdev_driver_register(&cpu_sysdev_class,&cpufreq_sysdev_driver);
1503
1504         if ((!ret) && !(cpufreq_driver->flags & CPUFREQ_STICKY)) {
1505                 int i;
1506                 ret = -ENODEV;
1507
1508                 /* check for at least one working CPU */
1509                 for (i=0; i<NR_CPUS; i++)
1510                         if (cpufreq_cpu_data[i])
1511                                 ret = 0;
1512
1513                 /* if all ->init() calls failed, unregister */
1514                 if (ret) {
1515                         dprintk("no CPU initialized for driver %s\n", driver_data->name);
1516                         sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
1517
1518                         spin_lock_irqsave(&cpufreq_driver_lock, flags);
1519                         cpufreq_driver = NULL;
1520                         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1521                 }
1522         }
1523
1524         if (!ret) {
1525                 register_cpu_notifier(&cpufreq_cpu_notifier);
1526                 dprintk("driver %s up and running\n", driver_data->name);
1527                 cpufreq_debug_enable_ratelimit();
1528         }
1529
1530         return (ret);
1531 }
1532 EXPORT_SYMBOL_GPL(cpufreq_register_driver);
1533
1534
1535 /**
1536  * cpufreq_unregister_driver - unregister the current CPUFreq driver
1537  *
1538  *    Unregister the current CPUFreq driver. Only call this if you have 
1539  * the right to do so, i.e. if you have succeeded in initialising before!
1540  * Returns zero if successful, and -EINVAL if the cpufreq_driver is
1541  * currently not initialised.
1542  */
1543 int cpufreq_unregister_driver(struct cpufreq_driver *driver)
1544 {
1545         unsigned long flags;
1546
1547         cpufreq_debug_disable_ratelimit();
1548
1549         if (!cpufreq_driver || (driver != cpufreq_driver)) {
1550                 cpufreq_debug_enable_ratelimit();
1551                 return -EINVAL;
1552         }
1553
1554         dprintk("unregistering driver %s\n", driver->name);
1555
1556         sysdev_driver_unregister(&cpu_sysdev_class, &cpufreq_sysdev_driver);
1557         unregister_cpu_notifier(&cpufreq_cpu_notifier);
1558
1559         spin_lock_irqsave(&cpufreq_driver_lock, flags);
1560         cpufreq_driver = NULL;
1561         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
1562
1563         return 0;
1564 }
1565 EXPORT_SYMBOL_GPL(cpufreq_unregister_driver);