]>
Commit | Line | Data |
---|---|---|
1 | ||
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 | ||
14 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
15 | ||
16 | #include <linux/cpufreq.h> | |
17 | #include <linux/init.h> | |
18 | #include <linux/module.h> | |
19 | #include <linux/mutex.h> | |
20 | #include <linux/slab.h> | |
21 | ||
22 | static DEFINE_PER_CPU(unsigned int, cpu_is_managed); | |
23 | static DEFINE_MUTEX(userspace_mutex); | |
24 | ||
25 | /** | |
26 | * cpufreq_set - set the CPU frequency | |
27 | * @policy: pointer to policy struct where freq is being set | |
28 | * @freq: target frequency in kHz | |
29 | * | |
30 | * Sets the CPU frequency to freq. | |
31 | */ | |
32 | static int cpufreq_set(struct cpufreq_policy *policy, unsigned int freq) | |
33 | { | |
34 | int ret = -EINVAL; | |
35 | unsigned int *setspeed = policy->governor_data; | |
36 | ||
37 | pr_debug("cpufreq_set for cpu %u, freq %u kHz\n", policy->cpu, freq); | |
38 | ||
39 | mutex_lock(&userspace_mutex); | |
40 | if (!per_cpu(cpu_is_managed, policy->cpu)) | |
41 | goto err; | |
42 | ||
43 | *setspeed = freq; | |
44 | ||
45 | ret = __cpufreq_driver_target(policy, freq, CPUFREQ_RELATION_L); | |
46 | err: | |
47 | mutex_unlock(&userspace_mutex); | |
48 | return ret; | |
49 | } | |
50 | ||
51 | static ssize_t show_speed(struct cpufreq_policy *policy, char *buf) | |
52 | { | |
53 | return sprintf(buf, "%u\n", policy->cur); | |
54 | } | |
55 | ||
56 | static int cpufreq_userspace_policy_init(struct cpufreq_policy *policy) | |
57 | { | |
58 | unsigned int *setspeed; | |
59 | ||
60 | setspeed = kzalloc(sizeof(*setspeed), GFP_KERNEL); | |
61 | if (!setspeed) | |
62 | return -ENOMEM; | |
63 | ||
64 | policy->governor_data = setspeed; | |
65 | return 0; | |
66 | } | |
67 | ||
68 | static void cpufreq_userspace_policy_exit(struct cpufreq_policy *policy) | |
69 | { | |
70 | mutex_lock(&userspace_mutex); | |
71 | kfree(policy->governor_data); | |
72 | policy->governor_data = NULL; | |
73 | mutex_unlock(&userspace_mutex); | |
74 | } | |
75 | ||
76 | static int cpufreq_userspace_policy_start(struct cpufreq_policy *policy) | |
77 | { | |
78 | unsigned int *setspeed = policy->governor_data; | |
79 | ||
80 | BUG_ON(!policy->cur); | |
81 | pr_debug("started managing cpu %u\n", policy->cpu); | |
82 | ||
83 | mutex_lock(&userspace_mutex); | |
84 | per_cpu(cpu_is_managed, policy->cpu) = 1; | |
85 | *setspeed = policy->cur; | |
86 | mutex_unlock(&userspace_mutex); | |
87 | return 0; | |
88 | } | |
89 | ||
90 | static void cpufreq_userspace_policy_stop(struct cpufreq_policy *policy) | |
91 | { | |
92 | unsigned int *setspeed = policy->governor_data; | |
93 | ||
94 | pr_debug("managing cpu %u stopped\n", policy->cpu); | |
95 | ||
96 | mutex_lock(&userspace_mutex); | |
97 | per_cpu(cpu_is_managed, policy->cpu) = 0; | |
98 | *setspeed = 0; | |
99 | mutex_unlock(&userspace_mutex); | |
100 | } | |
101 | ||
102 | static void cpufreq_userspace_policy_limits(struct cpufreq_policy *policy) | |
103 | { | |
104 | unsigned int *setspeed = policy->governor_data; | |
105 | ||
106 | mutex_lock(&userspace_mutex); | |
107 | ||
108 | pr_debug("limit event for cpu %u: %u - %u kHz, currently %u kHz, last set to %u kHz\n", | |
109 | policy->cpu, policy->min, policy->max, policy->cur, *setspeed); | |
110 | ||
111 | if (policy->max < *setspeed) | |
112 | __cpufreq_driver_target(policy, policy->max, CPUFREQ_RELATION_H); | |
113 | else if (policy->min > *setspeed) | |
114 | __cpufreq_driver_target(policy, policy->min, CPUFREQ_RELATION_L); | |
115 | else | |
116 | __cpufreq_driver_target(policy, *setspeed, CPUFREQ_RELATION_L); | |
117 | ||
118 | mutex_unlock(&userspace_mutex); | |
119 | } | |
120 | ||
121 | static struct cpufreq_governor cpufreq_gov_userspace = { | |
122 | .name = "userspace", | |
123 | .init = cpufreq_userspace_policy_init, | |
124 | .exit = cpufreq_userspace_policy_exit, | |
125 | .start = cpufreq_userspace_policy_start, | |
126 | .stop = cpufreq_userspace_policy_stop, | |
127 | .limits = cpufreq_userspace_policy_limits, | |
128 | .store_setspeed = cpufreq_set, | |
129 | .show_setspeed = show_speed, | |
130 | .owner = THIS_MODULE, | |
131 | }; | |
132 | ||
133 | static int __init cpufreq_gov_userspace_init(void) | |
134 | { | |
135 | return cpufreq_register_governor(&cpufreq_gov_userspace); | |
136 | } | |
137 | ||
138 | static void __exit cpufreq_gov_userspace_exit(void) | |
139 | { | |
140 | cpufreq_unregister_governor(&cpufreq_gov_userspace); | |
141 | } | |
142 | ||
143 | MODULE_AUTHOR("Dominik Brodowski <linux@brodo.de>, " | |
144 | "Russell King <rmk@arm.linux.org.uk>"); | |
145 | MODULE_DESCRIPTION("CPUfreq policy governor 'userspace'"); | |
146 | MODULE_LICENSE("GPL"); | |
147 | ||
148 | #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE | |
149 | struct cpufreq_governor *cpufreq_default_governor(void) | |
150 | { | |
151 | return &cpufreq_gov_userspace; | |
152 | } | |
153 | ||
154 | fs_initcall(cpufreq_gov_userspace_init); | |
155 | #else | |
156 | module_init(cpufreq_gov_userspace_init); | |
157 | #endif | |
158 | module_exit(cpufreq_gov_userspace_exit); |