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