2 * PowerNV system parameter code
4 * Copyright (C) 2013 IBM
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <linux/kobject.h>
22 #include <linux/mutex.h>
23 #include <linux/slab.h>
25 #include <linux/gfp.h>
26 #include <linux/stat.h>
29 #define MAX_PARAM_DATA_LEN 64
31 static DEFINE_MUTEX(opal_sysparam_mutex);
32 static struct kobject *sysparam_kobj;
33 static void *param_data_buf;
36 struct list_head list;
39 struct kobj_attribute kobj_attr;
42 static ssize_t opal_get_sys_param(u32 param_id, u32 length, void *buffer)
48 token = opal_async_get_token_interruptible();
50 if (token != -ERESTARTSYS)
51 pr_err("%s: Couldn't get the token, returning\n",
57 ret = opal_get_param(token, param_id, (u64)buffer, length);
58 if (ret != OPAL_ASYNC_COMPLETION)
61 ret = opal_async_wait_response(token, &msg);
63 pr_err("%s: Failed to wait for the async response, %zd\n",
68 ret = be64_to_cpu(msg.params[1]);
71 opal_async_release_token(token);
76 static int opal_set_sys_param(u32 param_id, u32 length, void *buffer)
81 token = opal_async_get_token_interruptible();
83 if (token != -ERESTARTSYS)
84 pr_err("%s: Couldn't get the token, returning\n",
90 ret = opal_set_param(token, param_id, (u64)buffer, length);
92 if (ret != OPAL_ASYNC_COMPLETION)
95 ret = opal_async_wait_response(token, &msg);
97 pr_err("%s: Failed to wait for the async response, %d\n",
102 ret = be64_to_cpu(msg.params[1]);
105 opal_async_release_token(token);
110 static ssize_t sys_param_show(struct kobject *kobj,
111 struct kobj_attribute *kobj_attr, char *buf)
113 struct param_attr *attr = container_of(kobj_attr, struct param_attr,
117 mutex_lock(&opal_sysparam_mutex);
118 ret = opal_get_sys_param(attr->param_id, attr->param_size,
123 memcpy(buf, param_data_buf, attr->param_size);
125 ret = attr->param_size;
127 mutex_unlock(&opal_sysparam_mutex);
131 static ssize_t sys_param_store(struct kobject *kobj,
132 struct kobj_attribute *kobj_attr, const char *buf, size_t count)
134 struct param_attr *attr = container_of(kobj_attr, struct param_attr,
138 /* MAX_PARAM_DATA_LEN is sizeof(param_data_buf) */
139 if (count > MAX_PARAM_DATA_LEN)
140 count = MAX_PARAM_DATA_LEN;
142 mutex_lock(&opal_sysparam_mutex);
143 memcpy(param_data_buf, buf, count);
144 ret = opal_set_sys_param(attr->param_id, attr->param_size,
146 mutex_unlock(&opal_sysparam_mutex);
152 void __init opal_sys_param_init(void)
154 struct device_node *sysparam;
155 struct param_attr *attr;
161 pr_warn("SYSPARAM: opal kobject is not available\n");
165 /* Some systems do not use sysparams; this is not an error */
166 sysparam = of_find_node_by_path("/ibm,opal/sysparams");
170 if (!of_device_is_compatible(sysparam, "ibm,opal-sysparams")) {
171 pr_err("SYSPARAM: Opal sysparam node not compatible\n");
175 sysparam_kobj = kobject_create_and_add("sysparams", opal_kobj);
176 if (!sysparam_kobj) {
177 pr_err("SYSPARAM: Failed to create sysparam kobject\n");
181 /* Allocate big enough buffer for any get/set transactions */
182 param_data_buf = kzalloc(MAX_PARAM_DATA_LEN, GFP_KERNEL);
183 if (!param_data_buf) {
184 pr_err("SYSPARAM: Failed to allocate memory for param data "
189 /* Number of parameters exposed through DT */
190 count = of_property_count_strings(sysparam, "param-name");
192 pr_err("SYSPARAM: No string found of property param-name in "
193 "the node %s\n", sysparam->name);
197 id = kzalloc(sizeof(*id) * count, GFP_KERNEL);
199 pr_err("SYSPARAM: Failed to allocate memory to read parameter "
204 size = kzalloc(sizeof(*size) * count, GFP_KERNEL);
206 pr_err("SYSPARAM: Failed to allocate memory to read parameter "
211 perm = kzalloc(sizeof(*perm) * count, GFP_KERNEL);
213 pr_err("SYSPARAM: Failed to allocate memory to read supported "
214 "action on the parameter");
218 if (of_property_read_u32_array(sysparam, "param-id", id, count)) {
219 pr_err("SYSPARAM: Missing property param-id in the DT\n");
223 if (of_property_read_u32_array(sysparam, "param-len", size, count)) {
224 pr_err("SYSPARAM: Missing property param-len in the DT\n");
229 if (of_property_read_u8_array(sysparam, "param-perm", perm, count)) {
230 pr_err("SYSPARAM: Missing property param-perm in the DT\n");
234 attr = kzalloc(sizeof(*attr) * count, GFP_KERNEL);
236 pr_err("SYSPARAM: Failed to allocate memory for parameter "
241 /* For each of the parameters, populate the parameter attributes */
242 for (i = 0; i < count; i++) {
243 if (size[i] > MAX_PARAM_DATA_LEN) {
244 pr_warn("SYSPARAM: Not creating parameter %d as size "
245 "exceeds buffer length\n", i);
249 sysfs_attr_init(&attr[i].kobj_attr.attr);
250 attr[i].param_id = id[i];
251 attr[i].param_size = size[i];
252 if (of_property_read_string_index(sysparam, "param-name", i,
253 &attr[i].kobj_attr.attr.name))
256 /* If the parameter is read-only or read-write */
257 switch (perm[i] & 3) {
258 case OPAL_SYSPARAM_READ:
259 attr[i].kobj_attr.attr.mode = S_IRUGO;
261 case OPAL_SYSPARAM_WRITE:
262 attr[i].kobj_attr.attr.mode = S_IWUSR;
264 case OPAL_SYSPARAM_RW:
265 attr[i].kobj_attr.attr.mode = S_IRUGO | S_IWUSR;
271 attr[i].kobj_attr.show = sys_param_show;
272 attr[i].kobj_attr.store = sys_param_store;
274 if (sysfs_create_file(sysparam_kobj, &attr[i].kobj_attr.attr)) {
275 pr_err("SYSPARAM: Failed to create sysfs file %s\n",
276 attr[i].kobj_attr.attr.name);
284 of_node_put(sysparam);
296 kfree(param_data_buf);
298 kobject_put(sysparam_kobj);
300 of_node_put(sysparam);