1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/module.h>
14#include <linux/types.h>
15#include <linux/errno.h>
16#include <linux/init.h>
17#include <linux/seq_file.h>
18#include <linux/device.h>
19#include <linux/cpu.h>
20#include <linux/of.h>
21#include <asm/cputhreads.h>
22#include <asm/page.h>
23#include <asm/hvcall.h>
24#include <asm/firmware.h>
25
26
27#define MODULE_VERS "1.0"
28#define MODULE_NAME "pseries_energy"
29
30
31
32static int sysfs_entries;
33
34
35
36
37
38static u32 cpu_to_drc_index(int cpu)
39{
40 struct device_node *dn = NULL;
41 const int *indexes;
42 int i;
43 int rc = 1;
44 u32 ret = 0;
45
46 dn = of_find_node_by_path("/cpus");
47 if (dn == NULL)
48 goto err;
49 indexes = of_get_property(dn, "ibm,drc-indexes", NULL);
50 if (indexes == NULL)
51 goto err_of_node_put;
52
53 i = cpu_core_index_of_thread(cpu);
54
55
56
57
58
59 WARN_ON(i > indexes[0]);
60 ret = indexes[i + 1];
61 rc = 0;
62
63err_of_node_put:
64 of_node_put(dn);
65err:
66 if (rc)
67 printk(KERN_WARNING "cpu_to_drc_index(%d) failed", cpu);
68 return ret;
69}
70
71static int drc_index_to_cpu(u32 drc_index)
72{
73 struct device_node *dn = NULL;
74 const int *indexes;
75 int i, cpu = 0;
76 int rc = 1;
77
78 dn = of_find_node_by_path("/cpus");
79 if (dn == NULL)
80 goto err;
81 indexes = of_get_property(dn, "ibm,drc-indexes", NULL);
82 if (indexes == NULL)
83 goto err_of_node_put;
84
85
86
87
88
89 for (i = 0; i < indexes[0]; i++) {
90 if (indexes[i + 1] == drc_index)
91 break;
92 }
93
94 cpu = cpu_first_thread_of_core(i);
95 rc = 0;
96
97err_of_node_put:
98 of_node_put(dn);
99err:
100 if (rc)
101 printk(KERN_WARNING "drc_index_to_cpu(%d) failed", drc_index);
102 return cpu;
103}
104
105
106
107
108
109
110
111#define FLAGS_MODE1 0x004E200000080E01UL
112#define FLAGS_MODE2 0x004E200000080401UL
113#define FLAGS_ACTIVATE 0x100
114
115static ssize_t get_best_energy_list(char *page, int activate)
116{
117 int rc, cnt, i, cpu;
118 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
119 unsigned long flags = 0;
120 u32 *buf_page;
121 char *s = page;
122
123 buf_page = (u32 *) get_zeroed_page(GFP_KERNEL);
124 if (!buf_page)
125 return -ENOMEM;
126
127 flags = FLAGS_MODE1;
128 if (activate)
129 flags |= FLAGS_ACTIVATE;
130
131 rc = plpar_hcall9(H_BEST_ENERGY, retbuf, flags, 0, __pa(buf_page),
132 0, 0, 0, 0, 0, 0);
133 if (rc != H_SUCCESS) {
134 free_page((unsigned long) buf_page);
135 return -EINVAL;
136 }
137
138 cnt = retbuf[0];
139 for (i = 0; i < cnt; i++) {
140 cpu = drc_index_to_cpu(buf_page[2*i+1]);
141 if ((cpu_online(cpu) && !activate) ||
142 (!cpu_online(cpu) && activate))
143 s += sprintf(s, "%d,", cpu);
144 }
145 if (s > page) {
146 s--;
147 s += sprintf(s, "\n");
148 }
149
150 free_page((unsigned long) buf_page);
151 return s-page;
152}
153
154static ssize_t get_best_energy_data(struct device *dev,
155 char *page, int activate)
156{
157 int rc;
158 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE];
159 unsigned long flags = 0;
160
161 flags = FLAGS_MODE2;
162 if (activate)
163 flags |= FLAGS_ACTIVATE;
164
165 rc = plpar_hcall9(H_BEST_ENERGY, retbuf, flags,
166 cpu_to_drc_index(dev->id),
167 0, 0, 0, 0, 0, 0, 0);
168
169 if (rc != H_SUCCESS)
170 return -EINVAL;
171
172 return sprintf(page, "%lu\n", retbuf[1] >> 32);
173}
174
175
176
177static ssize_t cpu_activate_hint_list_show(struct device *dev,
178 struct device_attribute *attr, char *page)
179{
180 return get_best_energy_list(page, 1);
181}
182
183static ssize_t cpu_deactivate_hint_list_show(struct device *dev,
184 struct device_attribute *attr, char *page)
185{
186 return get_best_energy_list(page, 0);
187}
188
189static ssize_t percpu_activate_hint_show(struct device *dev,
190 struct device_attribute *attr, char *page)
191{
192 return get_best_energy_data(dev, page, 1);
193}
194
195static ssize_t percpu_deactivate_hint_show(struct device *dev,
196 struct device_attribute *attr, char *page)
197{
198 return get_best_energy_data(dev, page, 0);
199}
200
201
202
203
204
205
206
207
208
209
210
211static struct device_attribute attr_cpu_activate_hint_list =
212 __ATTR(pseries_activate_hint_list, 0444,
213 cpu_activate_hint_list_show, NULL);
214
215static struct device_attribute attr_cpu_deactivate_hint_list =
216 __ATTR(pseries_deactivate_hint_list, 0444,
217 cpu_deactivate_hint_list_show, NULL);
218
219static struct device_attribute attr_percpu_activate_hint =
220 __ATTR(pseries_activate_hint, 0444,
221 percpu_activate_hint_show, NULL);
222
223static struct device_attribute attr_percpu_deactivate_hint =
224 __ATTR(pseries_deactivate_hint, 0444,
225 percpu_deactivate_hint_show, NULL);
226
227static int __init pseries_energy_init(void)
228{
229 int cpu, err;
230 struct device *cpu_dev;
231
232 if (!firmware_has_feature(FW_FEATURE_BEST_ENERGY)) {
233 printk(KERN_INFO "Hypercall H_BEST_ENERGY not supported\n");
234 return 0;
235 }
236
237 err = device_create_file(cpu_subsys.dev_root,
238 &attr_cpu_activate_hint_list);
239 if (!err)
240 err = device_create_file(cpu_subsys.dev_root,
241 &attr_cpu_deactivate_hint_list);
242
243 if (err)
244 return err;
245 for_each_possible_cpu(cpu) {
246 cpu_dev = get_cpu_device(cpu);
247 err = device_create_file(cpu_dev,
248 &attr_percpu_activate_hint);
249 if (err)
250 break;
251 err = device_create_file(cpu_dev,
252 &attr_percpu_deactivate_hint);
253 if (err)
254 break;
255 }
256
257 if (err)
258 return err;
259
260 sysfs_entries = 1;
261 return 0;
262
263}
264
265static void __exit pseries_energy_cleanup(void)
266{
267 int cpu;
268 struct device *cpu_dev;
269
270 if (!sysfs_entries)
271 return;
272
273
274 device_remove_file(cpu_subsys.dev_root, &attr_cpu_activate_hint_list);
275 device_remove_file(cpu_subsys.dev_root, &attr_cpu_deactivate_hint_list);
276
277 for_each_possible_cpu(cpu) {
278 cpu_dev = get_cpu_device(cpu);
279 sysfs_remove_file(&cpu_dev->kobj,
280 &attr_percpu_activate_hint.attr);
281 sysfs_remove_file(&cpu_dev->kobj,
282 &attr_percpu_deactivate_hint.attr);
283 }
284}
285
286module_init(pseries_energy_init);
287module_exit(pseries_energy_cleanup);
288MODULE_DESCRIPTION("Driver for pSeries platform energy management");
289MODULE_AUTHOR("Vaidyanathan Srinivasan");
290MODULE_LICENSE("GPL");
291