Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/drivers/cpufreq/cpufreq_userspace.c | |
3 | * | |
4 | * Copyright (C) 2001 Russell King | |
5 | * (C) 2002 - 2004 Dominik Brodowski <linux@brodo.de> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License version 2 as | |
9 | * published by the Free Software Foundation. | |
10 | * | |
11 | */ | |
12 | ||
13 | #include <linux/config.h> | |
14 | #include <linux/kernel.h> | |
15 | #include <linux/module.h> | |
16 | #include <linux/smp.h> | |
17 | #include <linux/init.h> | |
18 | #include <linux/spinlock.h> | |
19 | #include <linux/interrupt.h> | |
20 | #include <linux/cpufreq.h> | |
21 | #include <linux/types.h> | |
22 | #include <linux/fs.h> | |
23 | #include <linux/sysfs.h> | |
24 | ||
25 | #include <asm/uaccess.h> | |
26 | ||
27 | ||
28 | /** | |
29 | * A few values needed by the userspace governor | |
30 | */ | |
31 | static unsigned int cpu_max_freq[NR_CPUS]; | |
32 | static unsigned int cpu_min_freq[NR_CPUS]; | |
33 | static unsigned int cpu_cur_freq[NR_CPUS]; /* current CPU freq */ | |
34 | static unsigned int cpu_set_freq[NR_CPUS]; /* CPU freq desired by userspace */ | |
35 | static unsigned int cpu_is_managed[NR_CPUS]; | |
36 | static struct cpufreq_policy current_policy[NR_CPUS]; | |
37 | ||
38 | static DECLARE_MUTEX (userspace_sem); | |
39 | ||
40 | #define dprintk(msg...) cpufreq_debug_printk(CPUFREQ_DEBUG_GOVERNOR, "userspace", msg) | |
41 | ||
42 | /* keep track of frequency transitions */ | |
43 | static int | |
44 | userspace_cpufreq_notifier(struct notifier_block *nb, unsigned long val, | |
45 | void *data) | |
46 | { | |
47 | struct cpufreq_freqs *freq = data; | |
48 | ||
49 | dprintk("saving cpu_cur_freq of cpu %u to be %u kHz\n", freq->cpu, freq->new); | |
50 | cpu_cur_freq[freq->cpu] = freq->new; | |
51 | ||
52 | return 0; | |
53 | } | |
54 | ||
55 | static struct notifier_block userspace_cpufreq_notifier_block = { | |
56 | .notifier_call = userspace_cpufreq_notifier | |
57 | }; | |
58 | ||
59 | ||
60 | /** | |
61 | * cpufreq_set - set the CPU frequency | |
62 | * @freq: target frequency in kHz | |
63 | * @cpu: CPU for which the frequency is to be set | |
64 | * | |
65 | * Sets the CPU frequency to freq. | |
66 | */ | |
67 | static int cpufreq_set(unsigned int freq, unsigned int cpu) | |
68 | { | |
69 | int ret = -EINVAL; | |
70 | ||
71 | dprintk("cpufreq_set for cpu %u, freq %u kHz\n", cpu, freq); | |
72 | ||
73 | down(&userspace_sem); | |
74 | if (!cpu_is_managed[cpu]) | |
75 | goto err; | |
76 | ||
77 | cpu_set_freq[cpu] = freq; | |
78 | ||
79 | if (freq < cpu_min_freq[cpu]) | |
80 | freq = cpu_min_freq[cpu]; | |
81 | if (freq > cpu_max_freq[cpu]) | |
82 | freq = cpu_max_freq[cpu]; | |
83 | ||
84 | /* | |
85 | * We're safe from concurrent calls to ->target() here | |
86 | * as we hold the userspace_sem lock. If we were calling | |
87 | * cpufreq_driver_target, a deadlock situation might occur: | |
88 | * A: cpufreq_set (lock userspace_sem) -> cpufreq_driver_target(lock policy->lock) | |
89 | * B: cpufreq_set_policy(lock policy->lock) -> __cpufreq_governor -> cpufreq_governor_userspace (lock userspace_sem) | |
90 | */ | |
91 | ret = __cpufreq_driver_target(¤t_policy[cpu], freq, | |
92 | CPUFREQ_RELATION_L); | |
93 | ||
94 | err: | |
95 | up(&userspace_sem); | |
96 | return ret; | |
97 | } | |
98 | ||
99 | ||
100 | /************************** sysfs interface ************************/ | |
101 | static ssize_t show_speed (struct cpufreq_policy *policy, char *buf) | |
102 | { | |
103 | return sprintf (buf, "%u\n", cpu_cur_freq[policy->cpu]); | |
104 | } | |
105 | ||
106 | static ssize_t | |
107 | store_speed (struct cpufreq_policy *policy, const char *buf, size_t count) | |
108 | { | |
109 | unsigned int freq = 0; | |
110 | unsigned int ret; | |
111 | ||
112 | ret = sscanf (buf, "%u", &freq); | |
113 | if (ret != 1) | |
114 | return -EINVAL; | |
115 | ||
116 | cpufreq_set(freq, policy->cpu); | |
117 | ||
118 | return count; | |
119 | } | |
120 | ||
121 | static struct freq_attr freq_attr_scaling_setspeed = | |
122 | { | |
123 | .attr = { .name = "scaling_setspeed", .mode = 0644, .owner = THIS_MODULE }, | |
124 | .show = show_speed, | |
125 | .store = store_speed, | |
126 | }; | |
127 | ||
128 | static int cpufreq_governor_userspace(struct cpufreq_policy *policy, | |
129 | unsigned int event) | |
130 | { | |
131 | unsigned int cpu = policy->cpu; | |
132 | switch (event) { | |
133 | case CPUFREQ_GOV_START: | |
134 | if (!cpu_online(cpu)) | |
135 | return -EINVAL; | |
136 | BUG_ON(!policy->cur); | |
137 | down(&userspace_sem); | |
138 | cpu_is_managed[cpu] = 1; | |
139 | cpu_min_freq[cpu] = policy->min; | |
140 | cpu_max_freq[cpu] = policy->max; | |
141 | cpu_cur_freq[cpu] = policy->cur; | |
142 | cpu_set_freq[cpu] = policy->cur; | |
143 | sysfs_create_file (&policy->kobj, &freq_attr_scaling_setspeed.attr); | |
144 | memcpy (¤t_policy[cpu], policy, sizeof(struct cpufreq_policy)); | |
145 | dprintk("managing cpu %u started (%u - %u kHz, currently %u kHz)\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu]); | |
146 | up(&userspace_sem); | |
147 | break; | |
148 | case CPUFREQ_GOV_STOP: | |
149 | down(&userspace_sem); | |
150 | cpu_is_managed[cpu] = 0; | |
151 | cpu_min_freq[cpu] = 0; | |
152 | cpu_max_freq[cpu] = 0; | |
153 | cpu_set_freq[cpu] = 0; | |
154 | sysfs_remove_file (&policy->kobj, &freq_attr_scaling_setspeed.attr); | |
155 | dprintk("managing cpu %u stopped\n", cpu); | |
156 | up(&userspace_sem); | |
157 | break; | |
158 | case CPUFREQ_GOV_LIMITS: | |
159 | down(&userspace_sem); | |
160 | cpu_min_freq[cpu] = policy->min; | |
161 | cpu_max_freq[cpu] = policy->max; | |
162 | dprintk("limit event for cpu %u: %u - %u kHz, currently %u kHz, last set to %u kHz\n", cpu, cpu_min_freq[cpu], cpu_max_freq[cpu], cpu_cur_freq[cpu], cpu_set_freq[cpu]); | |
163 | if (policy->max < cpu_set_freq[cpu]) { | |
164 | __cpufreq_driver_target(¤t_policy[cpu], policy->max, | |
165 | CPUFREQ_RELATION_H); | |
166 | } else if (policy->min > cpu_set_freq[cpu]) { | |
167 | __cpufreq_driver_target(¤t_policy[cpu], policy->min, | |
168 | CPUFREQ_RELATION_L); | |
169 | } else { | |
170 | __cpufreq_driver_target(¤t_policy[cpu], cpu_set_freq[cpu], | |
171 | CPUFREQ_RELATION_L); | |
172 | } | |
173 | memcpy (¤t_policy[cpu], policy, sizeof(struct cpufreq_policy)); | |
174 | up(&userspace_sem); | |
175 | break; | |
176 | } | |
177 | return 0; | |
178 | } | |
179 | ||
180 | ||
181 | struct cpufreq_governor cpufreq_gov_userspace = { | |
182 | .name = "userspace", | |
183 | .governor = cpufreq_governor_userspace, | |
184 | .owner = THIS_MODULE, | |
185 | }; | |
186 | EXPORT_SYMBOL(cpufreq_gov_userspace); | |
187 | ||
188 | static int __init cpufreq_gov_userspace_init(void) | |
189 | { | |
190 | cpufreq_register_notifier(&userspace_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); | |
191 | return cpufreq_register_governor(&cpufreq_gov_userspace); | |
192 | } | |
193 | ||
194 | ||
195 | static void __exit cpufreq_gov_userspace_exit(void) | |
196 | { | |
197 | cpufreq_unregister_governor(&cpufreq_gov_userspace); | |
198 | cpufreq_unregister_notifier(&userspace_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); | |
199 | } | |
200 | ||
201 | ||
202 | MODULE_AUTHOR ("Dominik Brodowski <linux@brodo.de>, Russell King <rmk@arm.linux.org.uk>"); | |
203 | MODULE_DESCRIPTION ("CPUfreq policy governor 'userspace'"); | |
204 | MODULE_LICENSE ("GPL"); | |
205 | ||
206 | fs_initcall(cpufreq_gov_userspace_init); | |
207 | module_exit(cpufreq_gov_userspace_exit); |