1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * POWER platform energy management driver 4 * Copyright (C) 2010 IBM Corporation 5 * 6 * This pseries platform device driver provides access to 7 * platform energy management capabilities. 8 */ 9 10 #include <linux/module.h> 11 #include <linux/types.h> 12 #include <linux/errno.h> 13 #include <linux/init.h> 14 #include <linux/seq_file.h> 15 #include <linux/device.h> 16 #include <linux/cpu.h> 17 #include <linux/of.h> 18 #include <asm/cputhreads.h> 19 #include <asm/page.h> 20 #include <asm/hvcall.h> 21 #include <asm/firmware.h> 22 #include <asm/prom.h> 23 24 25 #define MODULE_VERS "1.0" 26 #define MODULE_NAME "pseries_energy" 27 28 /* Driver flags */ 29 30 static int sysfs_entries; 31 32 /* Helper routines */ 33 34 /* Helper Routines to convert between drc_index to cpu numbers */ 35 36 static u32 cpu_to_drc_index(int cpu) 37 { 38 struct device_node *dn = NULL; 39 struct property *info; 40 int thread_index; 41 int rc = 1; 42 u32 ret = 0; 43 44 dn = of_find_node_by_path("/cpus"); 45 if (dn == NULL) 46 goto err; 47 48 /* Convert logical cpu number to core number */ 49 thread_index = cpu_core_index_of_thread(cpu); 50 51 info = of_find_property(dn, "ibm,drc-info", NULL); 52 if (info) { 53 struct of_drc_info drc; 54 int j; 55 u32 num_set_entries; 56 const __be32 *value; 57 58 value = of_prop_next_u32(info, NULL, &num_set_entries); 59 if (!value) 60 goto err_of_node_put; 61 else 62 value++; 63 64 for (j = 0; j < num_set_entries; j++) { 65 66 of_read_drc_info_cell(&info, &value, &drc); 67 if (strncmp(drc.drc_type, "CPU", 3)) 68 goto err; 69 70 if (thread_index < drc.last_drc_index) 71 break; 72 } 73 74 ret = drc.drc_index_start + (thread_index * drc.sequential_inc); 75 } else { 76 u32 nr_drc_indexes, thread_drc_index; 77 78 /* 79 * The first element of ibm,drc-indexes array is the 80 * number of drc_indexes returned in the list. Hence 81 * thread_index+1 will get the drc_index corresponding 82 * to core number thread_index. 83 */ 84 rc = of_property_read_u32_index(dn, "ibm,drc-indexes", 85 0, &nr_drc_indexes); 86 if (rc) 87 goto err_of_node_put; 88 89 WARN_ON_ONCE(thread_index > nr_drc_indexes); 90 rc = of_property_read_u32_index(dn, "ibm,drc-indexes", 91 thread_index + 1, 92 &thread_drc_index); 93 if (rc) 94 goto err_of_node_put; 95 96 ret = thread_drc_index; 97 } 98 99 rc = 0; 100 101 err_of_node_put: 102 of_node_put(dn); 103 err: 104 if (rc) 105 printk(KERN_WARNING "cpu_to_drc_index(%d) failed", cpu); 106 return ret; 107 } 108 109 static int drc_index_to_cpu(u32 drc_index) 110 { 111 struct device_node *dn = NULL; 112 struct property *info; 113 const int *indexes; 114 int thread_index = 0, cpu = 0; 115 int rc = 1; 116 117 dn = of_find_node_by_path("/cpus"); 118 if (dn == NULL) 119 goto err; 120 info = of_find_property(dn, "ibm,drc-info", NULL); 121 if (info) { 122 struct of_drc_info drc; 123 int j; 124 u32 num_set_entries; 125 const __be32 *value; 126 127 value = of_prop_next_u32(info, NULL, &num_set_entries); 128 if (!value) 129 goto err_of_node_put; 130 else 131 value++; 132 133 for (j = 0; j < num_set_entries; j++) { 134 135 of_read_drc_info_cell(&info, &value, &drc); 136 if (strncmp(drc.drc_type, "CPU", 3)) 137 goto err; 138 139 if (drc_index > drc.last_drc_index) { 140 cpu += drc.num_sequential_elems; 141 continue; 142 } 143 cpu += ((drc_index - drc.drc_index_start) / 144 drc.sequential_inc); 145 146 thread_index = cpu_first_thread_of_core(cpu); 147 rc = 0; 148 break; 149 } 150 } else { 151 unsigned long int i; 152 153 indexes = of_get_property(dn, "ibm,drc-indexes", NULL); 154 if (indexes == NULL) 155 goto err_of_node_put; 156 /* 157 * First element in the array is the number of drc_indexes 158 * returned. Search through the list to find the matching 159 * drc_index and get the core number 160 */ 161 for (i = 0; i < indexes[0]; i++) { 162 if (indexes[i + 1] == drc_index) 163 break; 164 } 165 /* Convert core number to logical cpu number */ 166 thread_index = cpu_first_thread_of_core(i); 167 rc = 0; 168 } 169 170 err_of_node_put: 171 of_node_put(dn); 172 err: 173 if (rc) 174 printk(KERN_WARNING "drc_index_to_cpu(%d) failed", drc_index); 175 return thread_index; 176 } 177 178 /* 179 * pseries hypervisor call H_BEST_ENERGY provides hints to OS on 180 * preferred logical cpus to activate or deactivate for optimized 181 * energy consumption. 182 */ 183 184 #define FLAGS_MODE1 0x004E200000080E01UL 185 #define FLAGS_MODE2 0x004E200000080401UL 186 #define FLAGS_ACTIVATE 0x100 187 188 static ssize_t get_best_energy_list(char *page, int activate) 189 { 190 int rc, cnt, i, cpu; 191 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE]; 192 unsigned long flags = 0; 193 u32 *buf_page; 194 char *s = page; 195 196 buf_page = (u32 *) get_zeroed_page(GFP_KERNEL); 197 if (!buf_page) 198 return -ENOMEM; 199 200 flags = FLAGS_MODE1; 201 if (activate) 202 flags |= FLAGS_ACTIVATE; 203 204 rc = plpar_hcall9(H_BEST_ENERGY, retbuf, flags, 0, __pa(buf_page), 205 0, 0, 0, 0, 0, 0); 206 if (rc != H_SUCCESS) { 207 free_page((unsigned long) buf_page); 208 return -EINVAL; 209 } 210 211 cnt = retbuf[0]; 212 for (i = 0; i < cnt; i++) { 213 cpu = drc_index_to_cpu(buf_page[2*i+1]); 214 if ((cpu_online(cpu) && !activate) || 215 (!cpu_online(cpu) && activate)) 216 s += sprintf(s, "%d,", cpu); 217 } 218 if (s > page) { /* Something to show */ 219 s--; /* Suppress last comma */ 220 s += sprintf(s, "\n"); 221 } 222 223 free_page((unsigned long) buf_page); 224 return s-page; 225 } 226 227 static ssize_t get_best_energy_data(struct device *dev, 228 char *page, int activate) 229 { 230 int rc; 231 unsigned long retbuf[PLPAR_HCALL9_BUFSIZE]; 232 unsigned long flags = 0; 233 234 flags = FLAGS_MODE2; 235 if (activate) 236 flags |= FLAGS_ACTIVATE; 237 238 rc = plpar_hcall9(H_BEST_ENERGY, retbuf, flags, 239 cpu_to_drc_index(dev->id), 240 0, 0, 0, 0, 0, 0, 0); 241 242 if (rc != H_SUCCESS) 243 return -EINVAL; 244 245 return sprintf(page, "%lu\n", retbuf[1] >> 32); 246 } 247 248 /* Wrapper functions */ 249 250 static ssize_t cpu_activate_hint_list_show(struct device *dev, 251 struct device_attribute *attr, char *page) 252 { 253 return get_best_energy_list(page, 1); 254 } 255 256 static ssize_t cpu_deactivate_hint_list_show(struct device *dev, 257 struct device_attribute *attr, char *page) 258 { 259 return get_best_energy_list(page, 0); 260 } 261 262 static ssize_t percpu_activate_hint_show(struct device *dev, 263 struct device_attribute *attr, char *page) 264 { 265 return get_best_energy_data(dev, page, 1); 266 } 267 268 static ssize_t percpu_deactivate_hint_show(struct device *dev, 269 struct device_attribute *attr, char *page) 270 { 271 return get_best_energy_data(dev, page, 0); 272 } 273 274 /* 275 * Create sysfs interface: 276 * /sys/devices/system/cpu/pseries_activate_hint_list 277 * /sys/devices/system/cpu/pseries_deactivate_hint_list 278 * Comma separated list of cpus to activate or deactivate 279 * /sys/devices/system/cpu/cpuN/pseries_activate_hint 280 * /sys/devices/system/cpu/cpuN/pseries_deactivate_hint 281 * Per-cpu value of the hint 282 */ 283 284 static struct device_attribute attr_cpu_activate_hint_list = 285 __ATTR(pseries_activate_hint_list, 0444, 286 cpu_activate_hint_list_show, NULL); 287 288 static struct device_attribute attr_cpu_deactivate_hint_list = 289 __ATTR(pseries_deactivate_hint_list, 0444, 290 cpu_deactivate_hint_list_show, NULL); 291 292 static struct device_attribute attr_percpu_activate_hint = 293 __ATTR(pseries_activate_hint, 0444, 294 percpu_activate_hint_show, NULL); 295 296 static struct device_attribute attr_percpu_deactivate_hint = 297 __ATTR(pseries_deactivate_hint, 0444, 298 percpu_deactivate_hint_show, NULL); 299 300 static int __init pseries_energy_init(void) 301 { 302 int cpu, err; 303 struct device *cpu_dev, *dev_root; 304 305 if (!firmware_has_feature(FW_FEATURE_BEST_ENERGY)) 306 return 0; /* H_BEST_ENERGY hcall not supported */ 307 308 /* Create the sysfs files */ 309 dev_root = bus_get_dev_root(&cpu_subsys); 310 if (dev_root) { 311 err = device_create_file(dev_root, &attr_cpu_activate_hint_list); 312 if (!err) 313 err = device_create_file(dev_root, &attr_cpu_deactivate_hint_list); 314 put_device(dev_root); 315 if (err) 316 return err; 317 } 318 319 for_each_possible_cpu(cpu) { 320 cpu_dev = get_cpu_device(cpu); 321 err = device_create_file(cpu_dev, 322 &attr_percpu_activate_hint); 323 if (err) 324 break; 325 err = device_create_file(cpu_dev, 326 &attr_percpu_deactivate_hint); 327 if (err) 328 break; 329 } 330 331 if (err) 332 return err; 333 334 sysfs_entries = 1; /* Removed entries on cleanup */ 335 return 0; 336 337 } 338 339 static void __exit pseries_energy_cleanup(void) 340 { 341 int cpu; 342 struct device *cpu_dev, *dev_root; 343 344 if (!sysfs_entries) 345 return; 346 347 /* Remove the sysfs files */ 348 dev_root = bus_get_dev_root(&cpu_subsys); 349 if (dev_root) { 350 device_remove_file(dev_root, &attr_cpu_activate_hint_list); 351 device_remove_file(dev_root, &attr_cpu_deactivate_hint_list); 352 put_device(dev_root); 353 } 354 355 for_each_possible_cpu(cpu) { 356 cpu_dev = get_cpu_device(cpu); 357 sysfs_remove_file(&cpu_dev->kobj, 358 &attr_percpu_activate_hint.attr); 359 sysfs_remove_file(&cpu_dev->kobj, 360 &attr_percpu_deactivate_hint.attr); 361 } 362 } 363 364 module_init(pseries_energy_init); 365 module_exit(pseries_energy_cleanup); 366 MODULE_DESCRIPTION("Driver for pSeries platform energy management"); 367 MODULE_AUTHOR("Vaidyanathan Srinivasan"); 368 MODULE_LICENSE("GPL"); 369