Loading...
Note: File does not exist in v4.6.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Functions corresponding to string type attributes under
4 * HP_WMI_BIOS_STRING_GUID for use with hp-bioscfg driver.
5 *
6 * Copyright (c) 2022 HP Development Company, L.P.
7 */
8
9#include "bioscfg.h"
10
11#define WMI_STRING_TYPE "HPBIOS_BIOSString"
12
13GET_INSTANCE_ID(string);
14
15static ssize_t current_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
16{
17 int instance_id = get_string_instance_id(kobj);
18
19 if (instance_id < 0)
20 return -EIO;
21
22 return sysfs_emit(buf, "%s\n",
23 bioscfg_drv.string_data[instance_id].current_value);
24}
25
26/**
27 * validate_string_input() -
28 * Validate input of current_value against min and max lengths
29 *
30 * @instance_id: The instance on which input is validated
31 * @buf: Input value
32 */
33static int validate_string_input(int instance_id, const char *buf)
34{
35 int in_len = strlen(buf);
36 struct string_data *string_data = &bioscfg_drv.string_data[instance_id];
37
38 /* BIOS treats it as a read only attribute */
39 if (string_data->common.is_readonly)
40 return -EIO;
41
42 if (in_len < string_data->min_length || in_len > string_data->max_length)
43 return -ERANGE;
44
45 return 0;
46}
47
48static void update_string_value(int instance_id, char *attr_value)
49{
50 struct string_data *string_data = &bioscfg_drv.string_data[instance_id];
51
52 /* Write settings to BIOS */
53 strscpy(string_data->current_value, attr_value);
54}
55
56/*
57 * ATTRIBUTE_S_COMMON_PROPERTY_SHOW(display_name_language_code, string);
58 * static struct kobj_attribute string_display_langcode =
59 * __ATTR_RO(display_name_language_code);
60 */
61
62ATTRIBUTE_S_COMMON_PROPERTY_SHOW(display_name, string);
63static struct kobj_attribute string_display_name =
64 __ATTR_RO(display_name);
65
66ATTRIBUTE_PROPERTY_STORE(current_value, string);
67static struct kobj_attribute string_current_val =
68 __ATTR_RW_MODE(current_value, 0644);
69
70ATTRIBUTE_N_PROPERTY_SHOW(min_length, string);
71static struct kobj_attribute string_min_length =
72 __ATTR_RO(min_length);
73
74ATTRIBUTE_N_PROPERTY_SHOW(max_length, string);
75static struct kobj_attribute string_max_length =
76 __ATTR_RO(max_length);
77
78static ssize_t type_show(struct kobject *kobj, struct kobj_attribute *attr,
79 char *buf)
80{
81 return sysfs_emit(buf, "string\n");
82}
83
84static struct kobj_attribute string_type =
85 __ATTR_RO(type);
86
87static struct attribute *string_attrs[] = {
88 &common_display_langcode.attr,
89 &string_display_name.attr,
90 &string_current_val.attr,
91 &string_min_length.attr,
92 &string_max_length.attr,
93 &string_type.attr,
94 NULL
95};
96
97static const struct attribute_group string_attr_group = {
98 .attrs = string_attrs,
99};
100
101int hp_alloc_string_data(void)
102{
103 bioscfg_drv.string_instances_count = hp_get_instance_count(HP_WMI_BIOS_STRING_GUID);
104 bioscfg_drv.string_data = kcalloc(bioscfg_drv.string_instances_count,
105 sizeof(*bioscfg_drv.string_data), GFP_KERNEL);
106 if (!bioscfg_drv.string_data) {
107 bioscfg_drv.string_instances_count = 0;
108 return -ENOMEM;
109 }
110 return 0;
111}
112
113/* Expected Values types associated with each element */
114static const acpi_object_type expected_string_types[] = {
115 [NAME] = ACPI_TYPE_STRING,
116 [VALUE] = ACPI_TYPE_STRING,
117 [PATH] = ACPI_TYPE_STRING,
118 [IS_READONLY] = ACPI_TYPE_INTEGER,
119 [DISPLAY_IN_UI] = ACPI_TYPE_INTEGER,
120 [REQUIRES_PHYSICAL_PRESENCE] = ACPI_TYPE_INTEGER,
121 [SEQUENCE] = ACPI_TYPE_INTEGER,
122 [PREREQUISITES_SIZE] = ACPI_TYPE_INTEGER,
123 [PREREQUISITES] = ACPI_TYPE_STRING,
124 [SECURITY_LEVEL] = ACPI_TYPE_INTEGER,
125 [STR_MIN_LENGTH] = ACPI_TYPE_INTEGER,
126 [STR_MAX_LENGTH] = ACPI_TYPE_INTEGER,
127};
128
129static int hp_populate_string_elements_from_package(union acpi_object *string_obj,
130 int string_obj_count,
131 int instance_id)
132{
133 char *str_value = NULL;
134 int value_len;
135 int ret = 0;
136 u32 int_value = 0;
137 int elem;
138 int reqs;
139 int eloc;
140 int size;
141 struct string_data *string_data = &bioscfg_drv.string_data[instance_id];
142
143 if (!string_obj)
144 return -EINVAL;
145
146 for (elem = 1, eloc = 1; elem < string_obj_count; elem++, eloc++) {
147 /* ONLY look at the first STRING_ELEM_CNT elements */
148 if (eloc == STR_ELEM_CNT)
149 goto exit_string_package;
150
151 switch (string_obj[elem].type) {
152 case ACPI_TYPE_STRING:
153 if (elem != PREREQUISITES) {
154 ret = hp_convert_hexstr_to_str(string_obj[elem].string.pointer,
155 string_obj[elem].string.length,
156 &str_value, &value_len);
157
158 if (ret)
159 continue;
160 }
161 break;
162 case ACPI_TYPE_INTEGER:
163 int_value = (u32)string_obj[elem].integer.value;
164 break;
165 default:
166 pr_warn("Unsupported object type [%d]\n", string_obj[elem].type);
167 continue;
168 }
169
170 /* Check that both expected and read object type match */
171 if (expected_string_types[eloc] != string_obj[elem].type) {
172 pr_err("Error expected type %d for elem %d, but got type %d instead\n",
173 expected_string_types[eloc], elem, string_obj[elem].type);
174 kfree(str_value);
175 return -EIO;
176 }
177
178 /* Assign appropriate element value to corresponding field*/
179 switch (eloc) {
180 case VALUE:
181 strscpy(string_data->current_value, str_value);
182 break;
183 case PATH:
184 strscpy(string_data->common.path, str_value);
185 break;
186 case IS_READONLY:
187 string_data->common.is_readonly = int_value;
188 break;
189 case DISPLAY_IN_UI:
190 string_data->common.display_in_ui = int_value;
191 break;
192 case REQUIRES_PHYSICAL_PRESENCE:
193 string_data->common.requires_physical_presence = int_value;
194 break;
195 case SEQUENCE:
196 string_data->common.sequence = int_value;
197 break;
198 case PREREQUISITES_SIZE:
199 if (int_value > MAX_PREREQUISITES_SIZE) {
200 pr_warn("Prerequisites size value exceeded the maximum number of elements supported or data may be malformed\n");
201 int_value = MAX_PREREQUISITES_SIZE;
202 }
203 string_data->common.prerequisites_size = int_value;
204
205 /*
206 * This step is needed to keep the expected
207 * element list pointing to the right obj[elem].type
208 * when the size is zero. PREREQUISITES
209 * object is omitted by BIOS when the size is
210 * zero.
211 */
212 if (string_data->common.prerequisites_size == 0)
213 eloc++;
214 break;
215 case PREREQUISITES:
216 size = min_t(u32, string_data->common.prerequisites_size,
217 MAX_PREREQUISITES_SIZE);
218
219 for (reqs = 0; reqs < size; reqs++) {
220 if (elem >= string_obj_count) {
221 pr_err("Error elem-objects package is too small\n");
222 return -EINVAL;
223 }
224
225 ret = hp_convert_hexstr_to_str(string_obj[elem + reqs].string.pointer,
226 string_obj[elem + reqs].string.length,
227 &str_value, &value_len);
228
229 if (ret)
230 continue;
231
232 strscpy(string_data->common.prerequisites[reqs], str_value);
233 kfree(str_value);
234 str_value = NULL;
235 }
236 break;
237
238 case SECURITY_LEVEL:
239 string_data->common.security_level = int_value;
240 break;
241 case STR_MIN_LENGTH:
242 string_data->min_length = int_value;
243 break;
244 case STR_MAX_LENGTH:
245 string_data->max_length = int_value;
246 break;
247 default:
248 pr_warn("Invalid element: %d found in String attribute or data may be malformed\n", elem);
249 break;
250 }
251
252 kfree(str_value);
253 str_value = NULL;
254 }
255
256exit_string_package:
257 kfree(str_value);
258 return 0;
259}
260
261/**
262 * hp_populate_string_package_data() -
263 * Populate all properties of an instance under string attribute
264 *
265 * @string_obj: ACPI object with string data
266 * @instance_id: The instance to enumerate
267 * @attr_name_kobj: The parent kernel object
268 */
269int hp_populate_string_package_data(union acpi_object *string_obj,
270 int instance_id,
271 struct kobject *attr_name_kobj)
272{
273 struct string_data *string_data = &bioscfg_drv.string_data[instance_id];
274
275 string_data->attr_name_kobj = attr_name_kobj;
276
277 hp_populate_string_elements_from_package(string_obj,
278 string_obj->package.count,
279 instance_id);
280
281 hp_update_attribute_permissions(string_data->common.is_readonly,
282 &string_current_val);
283 hp_friendly_user_name_update(string_data->common.path,
284 attr_name_kobj->name,
285 string_data->common.display_name,
286 sizeof(string_data->common.display_name));
287 return sysfs_create_group(attr_name_kobj, &string_attr_group);
288}
289
290static int hp_populate_string_elements_from_buffer(u8 *buffer_ptr, u32 *buffer_size,
291 int instance_id)
292{
293 int ret = 0;
294 struct string_data *string_data = &bioscfg_drv.string_data[instance_id];
295
296 /*
297 * Only data relevant to this driver and its functionality is
298 * read. BIOS defines the order in which each * element is
299 * read. Element 0 data is not relevant to this
300 * driver hence it is ignored. For clarity, all element names
301 * (DISPLAY_IN_UI) which defines the order in which is read
302 * and the name matches the variable where the data is stored.
303 *
304 * In earlier implementation, reported errors were ignored
305 * causing the data to remain uninitialized. It is not
306 * possible to determine if data read from BIOS is valid or
307 * not. It is for this reason functions may return a error
308 * without validating the data itself.
309 */
310
311 // VALUE:
312 ret = hp_get_string_from_buffer(&buffer_ptr, buffer_size, string_data->current_value,
313 sizeof(string_data->current_value));
314 if (ret < 0)
315 goto buffer_exit;
316
317 // COMMON:
318 ret = hp_get_common_data_from_buffer(&buffer_ptr, buffer_size, &string_data->common);
319 if (ret < 0)
320 goto buffer_exit;
321
322 // STR_MIN_LENGTH:
323 ret = hp_get_integer_from_buffer(&buffer_ptr, buffer_size,
324 &string_data->min_length);
325 if (ret < 0)
326 goto buffer_exit;
327
328 // STR_MAX_LENGTH:
329 ret = hp_get_integer_from_buffer(&buffer_ptr, buffer_size,
330 &string_data->max_length);
331
332buffer_exit:
333
334 return ret;
335}
336
337/**
338 * hp_populate_string_buffer_data() -
339 * Populate all properties of an instance under string attribute
340 *
341 * @buffer_ptr: Buffer pointer
342 * @buffer_size: Buffer size
343 * @instance_id: The instance to enumerate
344 * @attr_name_kobj: The parent kernel object
345 */
346int hp_populate_string_buffer_data(u8 *buffer_ptr, u32 *buffer_size,
347 int instance_id,
348 struct kobject *attr_name_kobj)
349{
350 struct string_data *string_data = &bioscfg_drv.string_data[instance_id];
351 int ret = 0;
352
353 string_data->attr_name_kobj = attr_name_kobj;
354
355 ret = hp_populate_string_elements_from_buffer(buffer_ptr, buffer_size,
356 instance_id);
357 if (ret < 0)
358 return ret;
359
360 hp_update_attribute_permissions(string_data->common.is_readonly,
361 &string_current_val);
362 hp_friendly_user_name_update(string_data->common.path,
363 attr_name_kobj->name,
364 string_data->common.display_name,
365 sizeof(string_data->common.display_name));
366
367 return sysfs_create_group(attr_name_kobj, &string_attr_group);
368}
369
370/**
371 * hp_exit_string_attributes() - Clear all attribute data
372 *
373 * Clears all data allocated for this group of attributes
374 */
375void hp_exit_string_attributes(void)
376{
377 int instance_id;
378
379 for (instance_id = 0; instance_id < bioscfg_drv.string_instances_count;
380 instance_id++) {
381 struct kobject *attr_name_kobj =
382 bioscfg_drv.string_data[instance_id].attr_name_kobj;
383
384 if (attr_name_kobj)
385 sysfs_remove_group(attr_name_kobj, &string_attr_group);
386 }
387 bioscfg_drv.string_instances_count = 0;
388
389 kfree(bioscfg_drv.string_data);
390 bioscfg_drv.string_data = NULL;
391}