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.
294 lines
6.7 KiB
294 lines
6.7 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* PowerNV system parameter code |
|
* |
|
* Copyright (C) 2013 IBM |
|
*/ |
|
|
|
#include <linux/kobject.h> |
|
#include <linux/mutex.h> |
|
#include <linux/slab.h> |
|
#include <linux/of.h> |
|
#include <linux/gfp.h> |
|
#include <linux/stat.h> |
|
#include <asm/opal.h> |
|
|
|
#define MAX_PARAM_DATA_LEN 64 |
|
|
|
static DEFINE_MUTEX(opal_sysparam_mutex); |
|
static struct kobject *sysparam_kobj; |
|
static void *param_data_buf; |
|
|
|
struct param_attr { |
|
struct list_head list; |
|
u32 param_id; |
|
u32 param_size; |
|
struct kobj_attribute kobj_attr; |
|
}; |
|
|
|
static ssize_t opal_get_sys_param(u32 param_id, u32 length, void *buffer) |
|
{ |
|
struct opal_msg msg; |
|
ssize_t ret; |
|
int token; |
|
|
|
token = opal_async_get_token_interruptible(); |
|
if (token < 0) { |
|
if (token != -ERESTARTSYS) |
|
pr_err("%s: Couldn't get the token, returning\n", |
|
__func__); |
|
ret = token; |
|
goto out; |
|
} |
|
|
|
ret = opal_get_param(token, param_id, (u64)buffer, length); |
|
if (ret != OPAL_ASYNC_COMPLETION) { |
|
ret = opal_error_code(ret); |
|
goto out_token; |
|
} |
|
|
|
ret = opal_async_wait_response(token, &msg); |
|
if (ret) { |
|
pr_err("%s: Failed to wait for the async response, %zd\n", |
|
__func__, ret); |
|
goto out_token; |
|
} |
|
|
|
ret = opal_error_code(opal_get_async_rc(msg)); |
|
|
|
out_token: |
|
opal_async_release_token(token); |
|
out: |
|
return ret; |
|
} |
|
|
|
static int opal_set_sys_param(u32 param_id, u32 length, void *buffer) |
|
{ |
|
struct opal_msg msg; |
|
int ret, token; |
|
|
|
token = opal_async_get_token_interruptible(); |
|
if (token < 0) { |
|
if (token != -ERESTARTSYS) |
|
pr_err("%s: Couldn't get the token, returning\n", |
|
__func__); |
|
ret = token; |
|
goto out; |
|
} |
|
|
|
ret = opal_set_param(token, param_id, (u64)buffer, length); |
|
|
|
if (ret != OPAL_ASYNC_COMPLETION) { |
|
ret = opal_error_code(ret); |
|
goto out_token; |
|
} |
|
|
|
ret = opal_async_wait_response(token, &msg); |
|
if (ret) { |
|
pr_err("%s: Failed to wait for the async response, %d\n", |
|
__func__, ret); |
|
goto out_token; |
|
} |
|
|
|
ret = opal_error_code(opal_get_async_rc(msg)); |
|
|
|
out_token: |
|
opal_async_release_token(token); |
|
out: |
|
return ret; |
|
} |
|
|
|
static ssize_t sys_param_show(struct kobject *kobj, |
|
struct kobj_attribute *kobj_attr, char *buf) |
|
{ |
|
struct param_attr *attr = container_of(kobj_attr, struct param_attr, |
|
kobj_attr); |
|
ssize_t ret; |
|
|
|
mutex_lock(&opal_sysparam_mutex); |
|
ret = opal_get_sys_param(attr->param_id, attr->param_size, |
|
param_data_buf); |
|
if (ret) |
|
goto out; |
|
|
|
memcpy(buf, param_data_buf, attr->param_size); |
|
|
|
ret = attr->param_size; |
|
out: |
|
mutex_unlock(&opal_sysparam_mutex); |
|
return ret; |
|
} |
|
|
|
static ssize_t sys_param_store(struct kobject *kobj, |
|
struct kobj_attribute *kobj_attr, const char *buf, size_t count) |
|
{ |
|
struct param_attr *attr = container_of(kobj_attr, struct param_attr, |
|
kobj_attr); |
|
ssize_t ret; |
|
|
|
/* MAX_PARAM_DATA_LEN is sizeof(param_data_buf) */ |
|
if (count > MAX_PARAM_DATA_LEN) |
|
count = MAX_PARAM_DATA_LEN; |
|
|
|
mutex_lock(&opal_sysparam_mutex); |
|
memcpy(param_data_buf, buf, count); |
|
ret = opal_set_sys_param(attr->param_id, attr->param_size, |
|
param_data_buf); |
|
mutex_unlock(&opal_sysparam_mutex); |
|
if (!ret) |
|
ret = count; |
|
return ret; |
|
} |
|
|
|
void __init opal_sys_param_init(void) |
|
{ |
|
struct device_node *sysparam; |
|
struct param_attr *attr; |
|
u32 *id, *size; |
|
int count, i; |
|
u8 *perm; |
|
|
|
if (!opal_kobj) { |
|
pr_warn("SYSPARAM: opal kobject is not available\n"); |
|
goto out; |
|
} |
|
|
|
/* Some systems do not use sysparams; this is not an error */ |
|
sysparam = of_find_node_by_path("/ibm,opal/sysparams"); |
|
if (!sysparam) |
|
goto out; |
|
|
|
if (!of_device_is_compatible(sysparam, "ibm,opal-sysparams")) { |
|
pr_err("SYSPARAM: Opal sysparam node not compatible\n"); |
|
goto out_node_put; |
|
} |
|
|
|
sysparam_kobj = kobject_create_and_add("sysparams", opal_kobj); |
|
if (!sysparam_kobj) { |
|
pr_err("SYSPARAM: Failed to create sysparam kobject\n"); |
|
goto out_node_put; |
|
} |
|
|
|
/* Allocate big enough buffer for any get/set transactions */ |
|
param_data_buf = kzalloc(MAX_PARAM_DATA_LEN, GFP_KERNEL); |
|
if (!param_data_buf) { |
|
pr_err("SYSPARAM: Failed to allocate memory for param data " |
|
"buf\n"); |
|
goto out_kobj_put; |
|
} |
|
|
|
/* Number of parameters exposed through DT */ |
|
count = of_property_count_strings(sysparam, "param-name"); |
|
if (count < 0) { |
|
pr_err("SYSPARAM: No string found of property param-name in " |
|
"the node %pOFn\n", sysparam); |
|
goto out_param_buf; |
|
} |
|
|
|
id = kcalloc(count, sizeof(*id), GFP_KERNEL); |
|
if (!id) { |
|
pr_err("SYSPARAM: Failed to allocate memory to read parameter " |
|
"id\n"); |
|
goto out_param_buf; |
|
} |
|
|
|
size = kcalloc(count, sizeof(*size), GFP_KERNEL); |
|
if (!size) { |
|
pr_err("SYSPARAM: Failed to allocate memory to read parameter " |
|
"size\n"); |
|
goto out_free_id; |
|
} |
|
|
|
perm = kcalloc(count, sizeof(*perm), GFP_KERNEL); |
|
if (!perm) { |
|
pr_err("SYSPARAM: Failed to allocate memory to read supported " |
|
"action on the parameter"); |
|
goto out_free_size; |
|
} |
|
|
|
if (of_property_read_u32_array(sysparam, "param-id", id, count)) { |
|
pr_err("SYSPARAM: Missing property param-id in the DT\n"); |
|
goto out_free_perm; |
|
} |
|
|
|
if (of_property_read_u32_array(sysparam, "param-len", size, count)) { |
|
pr_err("SYSPARAM: Missing property param-len in the DT\n"); |
|
goto out_free_perm; |
|
} |
|
|
|
|
|
if (of_property_read_u8_array(sysparam, "param-perm", perm, count)) { |
|
pr_err("SYSPARAM: Missing property param-perm in the DT\n"); |
|
goto out_free_perm; |
|
} |
|
|
|
attr = kcalloc(count, sizeof(*attr), GFP_KERNEL); |
|
if (!attr) { |
|
pr_err("SYSPARAM: Failed to allocate memory for parameter " |
|
"attributes\n"); |
|
goto out_free_perm; |
|
} |
|
|
|
/* For each of the parameters, populate the parameter attributes */ |
|
for (i = 0; i < count; i++) { |
|
if (size[i] > MAX_PARAM_DATA_LEN) { |
|
pr_warn("SYSPARAM: Not creating parameter %d as size " |
|
"exceeds buffer length\n", i); |
|
continue; |
|
} |
|
|
|
sysfs_attr_init(&attr[i].kobj_attr.attr); |
|
attr[i].param_id = id[i]; |
|
attr[i].param_size = size[i]; |
|
if (of_property_read_string_index(sysparam, "param-name", i, |
|
&attr[i].kobj_attr.attr.name)) |
|
continue; |
|
|
|
/* If the parameter is read-only or read-write */ |
|
switch (perm[i] & 3) { |
|
case OPAL_SYSPARAM_READ: |
|
attr[i].kobj_attr.attr.mode = 0444; |
|
break; |
|
case OPAL_SYSPARAM_WRITE: |
|
attr[i].kobj_attr.attr.mode = 0200; |
|
break; |
|
case OPAL_SYSPARAM_RW: |
|
attr[i].kobj_attr.attr.mode = 0644; |
|
break; |
|
default: |
|
break; |
|
} |
|
|
|
attr[i].kobj_attr.show = sys_param_show; |
|
attr[i].kobj_attr.store = sys_param_store; |
|
|
|
if (sysfs_create_file(sysparam_kobj, &attr[i].kobj_attr.attr)) { |
|
pr_err("SYSPARAM: Failed to create sysfs file %s\n", |
|
attr[i].kobj_attr.attr.name); |
|
goto out_free_attr; |
|
} |
|
} |
|
|
|
kfree(perm); |
|
kfree(size); |
|
kfree(id); |
|
of_node_put(sysparam); |
|
return; |
|
|
|
out_free_attr: |
|
kfree(attr); |
|
out_free_perm: |
|
kfree(perm); |
|
out_free_size: |
|
kfree(size); |
|
out_free_id: |
|
kfree(id); |
|
out_param_buf: |
|
kfree(param_data_buf); |
|
out_kobj_put: |
|
kobject_put(sysparam_kobj); |
|
out_node_put: |
|
of_node_put(sysparam); |
|
out: |
|
return; |
|
}
|
|
|