1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * PowerNV system parameter code
4  *
5  * Copyright (C) 2013 IBM
6  */
7 
8 #include <linux/kobject.h>
9 #include <linux/mutex.h>
10 #include <linux/slab.h>
11 #include <linux/of.h>
12 #include <linux/gfp.h>
13 #include <linux/stat.h>
14 #include <asm/opal.h>
15 
16 #define MAX_PARAM_DATA_LEN	64
17 
18 static DEFINE_MUTEX(opal_sysparam_mutex);
19 static struct kobject *sysparam_kobj;
20 static void *param_data_buf;
21 
22 struct param_attr {
23 	struct list_head list;
24 	u32 param_id;
25 	u32 param_size;
26 	struct kobj_attribute kobj_attr;
27 };
28 
29 static ssize_t opal_get_sys_param(u32 param_id, u32 length, void *buffer)
30 {
31 	struct opal_msg msg;
32 	ssize_t ret;
33 	int token;
34 
35 	token = opal_async_get_token_interruptible();
36 	if (token < 0) {
37 		if (token != -ERESTARTSYS)
38 			pr_err("%s: Couldn't get the token, returning\n",
39 					__func__);
40 		ret = token;
41 		goto out;
42 	}
43 
44 	ret = opal_get_param(token, param_id, (u64)buffer, length);
45 	if (ret != OPAL_ASYNC_COMPLETION) {
46 		ret = opal_error_code(ret);
47 		goto out_token;
48 	}
49 
50 	ret = opal_async_wait_response(token, &msg);
51 	if (ret) {
52 		pr_err("%s: Failed to wait for the async response, %zd\n",
53 				__func__, ret);
54 		goto out_token;
55 	}
56 
57 	ret = opal_error_code(opal_get_async_rc(msg));
58 
59 out_token:
60 	opal_async_release_token(token);
61 out:
62 	return ret;
63 }
64 
65 static int opal_set_sys_param(u32 param_id, u32 length, void *buffer)
66 {
67 	struct opal_msg msg;
68 	int ret, token;
69 
70 	token = opal_async_get_token_interruptible();
71 	if (token < 0) {
72 		if (token != -ERESTARTSYS)
73 			pr_err("%s: Couldn't get the token, returning\n",
74 					__func__);
75 		ret = token;
76 		goto out;
77 	}
78 
79 	ret = opal_set_param(token, param_id, (u64)buffer, length);
80 
81 	if (ret != OPAL_ASYNC_COMPLETION) {
82 		ret = opal_error_code(ret);
83 		goto out_token;
84 	}
85 
86 	ret = opal_async_wait_response(token, &msg);
87 	if (ret) {
88 		pr_err("%s: Failed to wait for the async response, %d\n",
89 				__func__, ret);
90 		goto out_token;
91 	}
92 
93 	ret = opal_error_code(opal_get_async_rc(msg));
94 
95 out_token:
96 	opal_async_release_token(token);
97 out:
98 	return ret;
99 }
100 
101 static ssize_t sys_param_show(struct kobject *kobj,
102 		struct kobj_attribute *kobj_attr, char *buf)
103 {
104 	struct param_attr *attr = container_of(kobj_attr, struct param_attr,
105 			kobj_attr);
106 	ssize_t ret;
107 
108 	mutex_lock(&opal_sysparam_mutex);
109 	ret = opal_get_sys_param(attr->param_id, attr->param_size,
110 			param_data_buf);
111 	if (ret)
112 		goto out;
113 
114 	memcpy(buf, param_data_buf, attr->param_size);
115 
116 	ret = attr->param_size;
117 out:
118 	mutex_unlock(&opal_sysparam_mutex);
119 	return ret;
120 }
121 
122 static ssize_t sys_param_store(struct kobject *kobj,
123 		struct kobj_attribute *kobj_attr, const char *buf, size_t count)
124 {
125 	struct param_attr *attr = container_of(kobj_attr, struct param_attr,
126 			kobj_attr);
127 	ssize_t ret;
128 
129         /* MAX_PARAM_DATA_LEN is sizeof(param_data_buf) */
130         if (count > MAX_PARAM_DATA_LEN)
131                 count = MAX_PARAM_DATA_LEN;
132 
133 	mutex_lock(&opal_sysparam_mutex);
134 	memcpy(param_data_buf, buf, count);
135 	ret = opal_set_sys_param(attr->param_id, attr->param_size,
136 			param_data_buf);
137 	mutex_unlock(&opal_sysparam_mutex);
138 	if (!ret)
139 		ret = count;
140 	return ret;
141 }
142 
143 void __init opal_sys_param_init(void)
144 {
145 	struct device_node *sysparam;
146 	struct param_attr *attr;
147 	u32 *id, *size;
148 	int count, i;
149 	u8 *perm;
150 
151 	if (!opal_kobj) {
152 		pr_warn("SYSPARAM: opal kobject is not available\n");
153 		goto out;
154 	}
155 
156 	/* Some systems do not use sysparams; this is not an error */
157 	sysparam = of_find_node_by_path("/ibm,opal/sysparams");
158 	if (!sysparam)
159 		goto out;
160 
161 	if (!of_device_is_compatible(sysparam, "ibm,opal-sysparams")) {
162 		pr_err("SYSPARAM: Opal sysparam node not compatible\n");
163 		goto out_node_put;
164 	}
165 
166 	sysparam_kobj = kobject_create_and_add("sysparams", opal_kobj);
167 	if (!sysparam_kobj) {
168 		pr_err("SYSPARAM: Failed to create sysparam kobject\n");
169 		goto out_node_put;
170 	}
171 
172 	/* Allocate big enough buffer for any get/set transactions */
173 	param_data_buf = kzalloc(MAX_PARAM_DATA_LEN, GFP_KERNEL);
174 	if (!param_data_buf) {
175 		pr_err("SYSPARAM: Failed to allocate memory for param data "
176 				"buf\n");
177 		goto out_kobj_put;
178 	}
179 
180 	/* Number of parameters exposed through DT */
181 	count = of_property_count_strings(sysparam, "param-name");
182 	if (count < 0) {
183 		pr_err("SYSPARAM: No string found of property param-name in "
184 				"the node %pOFn\n", sysparam);
185 		goto out_param_buf;
186 	}
187 
188 	id = kcalloc(count, sizeof(*id), GFP_KERNEL);
189 	if (!id) {
190 		pr_err("SYSPARAM: Failed to allocate memory to read parameter "
191 				"id\n");
192 		goto out_param_buf;
193 	}
194 
195 	size = kcalloc(count, sizeof(*size), GFP_KERNEL);
196 	if (!size) {
197 		pr_err("SYSPARAM: Failed to allocate memory to read parameter "
198 				"size\n");
199 		goto out_free_id;
200 	}
201 
202 	perm = kcalloc(count, sizeof(*perm), GFP_KERNEL);
203 	if (!perm) {
204 		pr_err("SYSPARAM: Failed to allocate memory to read supported "
205 				"action on the parameter");
206 		goto out_free_size;
207 	}
208 
209 	if (of_property_read_u32_array(sysparam, "param-id", id, count)) {
210 		pr_err("SYSPARAM: Missing property param-id in the DT\n");
211 		goto out_free_perm;
212 	}
213 
214 	if (of_property_read_u32_array(sysparam, "param-len", size, count)) {
215 		pr_err("SYSPARAM: Missing property param-len in the DT\n");
216 		goto out_free_perm;
217 	}
218 
219 
220 	if (of_property_read_u8_array(sysparam, "param-perm", perm, count)) {
221 		pr_err("SYSPARAM: Missing property param-perm in the DT\n");
222 		goto out_free_perm;
223 	}
224 
225 	attr = kcalloc(count, sizeof(*attr), GFP_KERNEL);
226 	if (!attr) {
227 		pr_err("SYSPARAM: Failed to allocate memory for parameter "
228 				"attributes\n");
229 		goto out_free_perm;
230 	}
231 
232 	/* For each of the parameters, populate the parameter attributes */
233 	for (i = 0; i < count; i++) {
234 		if (size[i] > MAX_PARAM_DATA_LEN) {
235 			pr_warn("SYSPARAM: Not creating parameter %d as size "
236 				"exceeds buffer length\n", i);
237 			continue;
238 		}
239 
240 		sysfs_attr_init(&attr[i].kobj_attr.attr);
241 		attr[i].param_id = id[i];
242 		attr[i].param_size = size[i];
243 		if (of_property_read_string_index(sysparam, "param-name", i,
244 				&attr[i].kobj_attr.attr.name))
245 			continue;
246 
247 		/* If the parameter is read-only or read-write */
248 		switch (perm[i] & 3) {
249 		case OPAL_SYSPARAM_READ:
250 			attr[i].kobj_attr.attr.mode = 0444;
251 			break;
252 		case OPAL_SYSPARAM_WRITE:
253 			attr[i].kobj_attr.attr.mode = 0200;
254 			break;
255 		case OPAL_SYSPARAM_RW:
256 			attr[i].kobj_attr.attr.mode = 0644;
257 			break;
258 		default:
259 			break;
260 		}
261 
262 		attr[i].kobj_attr.show = sys_param_show;
263 		attr[i].kobj_attr.store = sys_param_store;
264 
265 		if (sysfs_create_file(sysparam_kobj, &attr[i].kobj_attr.attr)) {
266 			pr_err("SYSPARAM: Failed to create sysfs file %s\n",
267 					attr[i].kobj_attr.attr.name);
268 			goto out_free_attr;
269 		}
270 	}
271 
272 	kfree(perm);
273 	kfree(size);
274 	kfree(id);
275 	of_node_put(sysparam);
276 	return;
277 
278 out_free_attr:
279 	kfree(attr);
280 out_free_perm:
281 	kfree(perm);
282 out_free_size:
283 	kfree(size);
284 out_free_id:
285 	kfree(id);
286 out_param_buf:
287 	kfree(param_data_buf);
288 out_kobj_put:
289 	kobject_put(sysparam_kobj);
290 out_node_put:
291 	of_node_put(sysparam);
292 out:
293 	return;
294 }
295