mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
362 lines
8.3 KiB
362 lines
8.3 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* POWER platform energy management driver |
|
* Copyright (C) 2010 IBM Corporation |
|
* |
|
* This pseries platform device driver provides access to |
|
* platform energy management capabilities. |
|
*/ |
|
|
|
#include <linux/module.h> |
|
#include <linux/types.h> |
|
#include <linux/errno.h> |
|
#include <linux/init.h> |
|
#include <linux/seq_file.h> |
|
#include <linux/device.h> |
|
#include <linux/cpu.h> |
|
#include <linux/of.h> |
|
#include <asm/cputhreads.h> |
|
#include <asm/page.h> |
|
#include <asm/hvcall.h> |
|
#include <asm/firmware.h> |
|
#include <asm/prom.h> |
|
|
|
|
|
#define MODULE_VERS "1.0" |
|
#define MODULE_NAME "pseries_energy" |
|
|
|
/* Driver flags */ |
|
|
|
static int sysfs_entries; |
|
|
|
/* Helper routines */ |
|
|
|
/* Helper Routines to convert between drc_index to cpu numbers */ |
|
|
|
static u32 cpu_to_drc_index(int cpu) |
|
{ |
|
struct device_node *dn = NULL; |
|
struct property *info; |
|
int thread_index; |
|
int rc = 1; |
|
u32 ret = 0; |
|
|
|
dn = of_find_node_by_path("/cpus"); |
|
if (dn == NULL) |
|
goto err; |
|
|
|
/* Convert logical cpu number to core number */ |
|
thread_index = cpu_core_index_of_thread(cpu); |
|
|
|
info = of_find_property(dn, "ibm,drc-info", NULL); |
|
if (info) { |
|
struct of_drc_info drc; |
|
int j; |
|
u32 num_set_entries; |
|
const __be32 *value; |
|
|
|
value = of_prop_next_u32(info, NULL, &num_set_entries); |
|
if (!value) |
|
goto err_of_node_put; |
|
else |
|
value++; |
|
|
|
for (j = 0; j < num_set_entries; j++) { |
|
|
|
of_read_drc_info_cell(&info, &value, &drc); |
|
if (strncmp(drc.drc_type, "CPU", 3)) |
|
goto err; |
|
|
|
if (thread_index < drc.last_drc_index) |
|
break; |
|
} |
|
|
|
ret = drc.drc_index_start + (thread_index * drc.sequential_inc); |
|
} else { |
|
u32 nr_drc_indexes, thread_drc_index; |
|
|
|
/* |
|
* The first element of ibm,drc-indexes array is the |
|
* number of drc_indexes returned in the list. Hence |
|
* thread_index+1 will get the drc_index corresponding |
|
* to core number thread_index. |
|
*/ |
|
rc = of_property_read_u32_index(dn, "ibm,drc-indexes", |
|
0, &nr_drc_indexes); |
|
if (rc) |
|
goto err_of_node_put; |
|
|
|
WARN_ON_ONCE(thread_index > nr_drc_indexes); |
|
rc = of_property_read_u32_index(dn, "ibm,drc-indexes", |
|
thread_index + 1, |
|
&thread_drc_index); |
|
if (rc) |
|
goto err_of_node_put; |
|
|
|
ret = thread_drc_index; |
|
} |
|
|
|
rc = 0; |
|
|
|
err_of_node_put: |
|
of_node_put(dn); |
|
err: |
|
if (rc) |
|
printk(KERN_WARNING "cpu_to_drc_index(%d) failed", cpu); |
|
return ret; |
|
} |
|
|
|
static int drc_index_to_cpu(u32 drc_index) |
|
{ |
|
struct device_node *dn = NULL; |
|
struct property *info; |
|
const int *indexes; |
|
int thread_index = 0, cpu = 0; |
|
int rc = 1; |
|
|
|
dn = of_find_node_by_path("/cpus"); |
|
if (dn == NULL) |
|
goto err; |
|
info = of_find_property(dn, "ibm,drc-info", NULL); |
|
if (info) { |
|
struct of_drc_info drc; |
|
int j; |
|
u32 num_set_entries; |
|
const __be32 *value; |
|
|
|
value = of_prop_next_u32(info, NULL, &num_set_entries); |
|
if (!value) |
|
goto err_of_node_put; |
|
else |
|
value++; |
|
|
|
for (j = 0; j < num_set_entries; j++) { |
|
|
|
of_read_drc_info_cell(&info, &value, &drc); |
|
if (strncmp(drc.drc_type, "CPU", 3)) |
|
goto err; |
|
|
|
if (drc_index > drc.last_drc_index) { |
|
cpu += drc.num_sequential_elems; |
|
continue; |
|
} |
|
cpu += ((drc_index - drc.drc_index_start) / |
|
drc.sequential_inc); |
|
|
|
thread_index = cpu_first_thread_of_core(cpu); |
|
rc = 0; |
|
break; |
|
} |
|
} else { |
|
unsigned long int i; |
|
|
|
indexes = of_get_property(dn, "ibm,drc-indexes", NULL); |
|
if (indexes == NULL) |
|
goto err_of_node_put; |
|
/* |
|
* First element in the array is the number of drc_indexes |
|
* returned. Search through the list to find the matching |
|
* drc_index and get the core number |
|
*/ |
|
for (i = 0; i < indexes[0]; i++) { |
|
if (indexes[i + 1] == drc_index) |
|
break; |
|
} |
|
/* Convert core number to logical cpu number */ |
|
thread_index = cpu_first_thread_of_core(i); |
|
rc = 0; |
|
} |
|
|
|
err_of_node_put: |
|
of_node_put(dn); |
|
err: |
|
if (rc) |
|
printk(KERN_WARNING "drc_index_to_cpu(%d) failed", drc_index); |
|
return thread_index; |
|
} |
|
|
|
/* |
|
* pseries hypervisor call H_BEST_ENERGY provides hints to OS on |
|
* preferred logical cpus to activate or deactivate for optimized |
|
* energy consumption. |
|
*/ |
|
|
|
#define FLAGS_MODE1 0x004E200000080E01UL |
|
#define FLAGS_MODE2 0x004E200000080401UL |
|
#define FLAGS_ACTIVATE 0x100 |
|
|
|
static ssize_t get_best_energy_list(char *page, int activate) |
|
{ |
|
int rc, cnt, i, cpu; |
|
unsigned long retbuf[PLPAR_HCALL9_BUFSIZE]; |
|
unsigned long flags = 0; |
|
u32 *buf_page; |
|
char *s = page; |
|
|
|
buf_page = (u32 *) get_zeroed_page(GFP_KERNEL); |
|
if (!buf_page) |
|
return -ENOMEM; |
|
|
|
flags = FLAGS_MODE1; |
|
if (activate) |
|
flags |= FLAGS_ACTIVATE; |
|
|
|
rc = plpar_hcall9(H_BEST_ENERGY, retbuf, flags, 0, __pa(buf_page), |
|
0, 0, 0, 0, 0, 0); |
|
if (rc != H_SUCCESS) { |
|
free_page((unsigned long) buf_page); |
|
return -EINVAL; |
|
} |
|
|
|
cnt = retbuf[0]; |
|
for (i = 0; i < cnt; i++) { |
|
cpu = drc_index_to_cpu(buf_page[2*i+1]); |
|
if ((cpu_online(cpu) && !activate) || |
|
(!cpu_online(cpu) && activate)) |
|
s += sprintf(s, "%d,", cpu); |
|
} |
|
if (s > page) { /* Something to show */ |
|
s--; /* Suppress last comma */ |
|
s += sprintf(s, "\n"); |
|
} |
|
|
|
free_page((unsigned long) buf_page); |
|
return s-page; |
|
} |
|
|
|
static ssize_t get_best_energy_data(struct device *dev, |
|
char *page, int activate) |
|
{ |
|
int rc; |
|
unsigned long retbuf[PLPAR_HCALL9_BUFSIZE]; |
|
unsigned long flags = 0; |
|
|
|
flags = FLAGS_MODE2; |
|
if (activate) |
|
flags |= FLAGS_ACTIVATE; |
|
|
|
rc = plpar_hcall9(H_BEST_ENERGY, retbuf, flags, |
|
cpu_to_drc_index(dev->id), |
|
0, 0, 0, 0, 0, 0, 0); |
|
|
|
if (rc != H_SUCCESS) |
|
return -EINVAL; |
|
|
|
return sprintf(page, "%lu\n", retbuf[1] >> 32); |
|
} |
|
|
|
/* Wrapper functions */ |
|
|
|
static ssize_t cpu_activate_hint_list_show(struct device *dev, |
|
struct device_attribute *attr, char *page) |
|
{ |
|
return get_best_energy_list(page, 1); |
|
} |
|
|
|
static ssize_t cpu_deactivate_hint_list_show(struct device *dev, |
|
struct device_attribute *attr, char *page) |
|
{ |
|
return get_best_energy_list(page, 0); |
|
} |
|
|
|
static ssize_t percpu_activate_hint_show(struct device *dev, |
|
struct device_attribute *attr, char *page) |
|
{ |
|
return get_best_energy_data(dev, page, 1); |
|
} |
|
|
|
static ssize_t percpu_deactivate_hint_show(struct device *dev, |
|
struct device_attribute *attr, char *page) |
|
{ |
|
return get_best_energy_data(dev, page, 0); |
|
} |
|
|
|
/* |
|
* Create sysfs interface: |
|
* /sys/devices/system/cpu/pseries_activate_hint_list |
|
* /sys/devices/system/cpu/pseries_deactivate_hint_list |
|
* Comma separated list of cpus to activate or deactivate |
|
* /sys/devices/system/cpu/cpuN/pseries_activate_hint |
|
* /sys/devices/system/cpu/cpuN/pseries_deactivate_hint |
|
* Per-cpu value of the hint |
|
*/ |
|
|
|
static struct device_attribute attr_cpu_activate_hint_list = |
|
__ATTR(pseries_activate_hint_list, 0444, |
|
cpu_activate_hint_list_show, NULL); |
|
|
|
static struct device_attribute attr_cpu_deactivate_hint_list = |
|
__ATTR(pseries_deactivate_hint_list, 0444, |
|
cpu_deactivate_hint_list_show, NULL); |
|
|
|
static struct device_attribute attr_percpu_activate_hint = |
|
__ATTR(pseries_activate_hint, 0444, |
|
percpu_activate_hint_show, NULL); |
|
|
|
static struct device_attribute attr_percpu_deactivate_hint = |
|
__ATTR(pseries_deactivate_hint, 0444, |
|
percpu_deactivate_hint_show, NULL); |
|
|
|
static int __init pseries_energy_init(void) |
|
{ |
|
int cpu, err; |
|
struct device *cpu_dev; |
|
|
|
if (!firmware_has_feature(FW_FEATURE_BEST_ENERGY)) |
|
return 0; /* H_BEST_ENERGY hcall not supported */ |
|
|
|
/* Create the sysfs files */ |
|
err = device_create_file(cpu_subsys.dev_root, |
|
&attr_cpu_activate_hint_list); |
|
if (!err) |
|
err = device_create_file(cpu_subsys.dev_root, |
|
&attr_cpu_deactivate_hint_list); |
|
|
|
if (err) |
|
return err; |
|
for_each_possible_cpu(cpu) { |
|
cpu_dev = get_cpu_device(cpu); |
|
err = device_create_file(cpu_dev, |
|
&attr_percpu_activate_hint); |
|
if (err) |
|
break; |
|
err = device_create_file(cpu_dev, |
|
&attr_percpu_deactivate_hint); |
|
if (err) |
|
break; |
|
} |
|
|
|
if (err) |
|
return err; |
|
|
|
sysfs_entries = 1; /* Removed entries on cleanup */ |
|
return 0; |
|
|
|
} |
|
|
|
static void __exit pseries_energy_cleanup(void) |
|
{ |
|
int cpu; |
|
struct device *cpu_dev; |
|
|
|
if (!sysfs_entries) |
|
return; |
|
|
|
/* Remove the sysfs files */ |
|
device_remove_file(cpu_subsys.dev_root, &attr_cpu_activate_hint_list); |
|
device_remove_file(cpu_subsys.dev_root, &attr_cpu_deactivate_hint_list); |
|
|
|
for_each_possible_cpu(cpu) { |
|
cpu_dev = get_cpu_device(cpu); |
|
sysfs_remove_file(&cpu_dev->kobj, |
|
&attr_percpu_activate_hint.attr); |
|
sysfs_remove_file(&cpu_dev->kobj, |
|
&attr_percpu_deactivate_hint.attr); |
|
} |
|
} |
|
|
|
module_init(pseries_energy_init); |
|
module_exit(pseries_energy_cleanup); |
|
MODULE_DESCRIPTION("Driver for pSeries platform energy management"); |
|
MODULE_AUTHOR("Vaidyanathan Srinivasan"); |
|
MODULE_LICENSE("GPL");
|
|
|