xref: /linux/drivers/platform/x86/hp/hp-bioscfg/bioscfg.c (revision df46426745ac58618c822ce3f93d2bb25b9a5060)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Common methods for use with hp-bioscfg driver
4  *
5  *  Copyright (c) 2022 HP Development Company, L.P.
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
10 #include <linux/fs.h>
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/wmi.h>
14 #include "bioscfg.h"
15 #include "../../firmware_attributes_class.h"
16 #include <linux/nls.h>
17 #include <linux/errno.h>
18 
19 MODULE_AUTHOR("Jorge Lopez <jorge.lopez2@hp.com>");
20 MODULE_DESCRIPTION("HP BIOS Configuration Driver");
21 MODULE_LICENSE("GPL");
22 
23 struct bioscfg_priv bioscfg_drv = {
24 	.mutex = __MUTEX_INITIALIZER(bioscfg_drv.mutex),
25 };
26 
display_name_language_code_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)27 ssize_t display_name_language_code_show(struct kobject *kobj,
28 					struct kobj_attribute *attr,
29 					char *buf)
30 {
31 	return sysfs_emit(buf, "%s\n", LANG_CODE_STR);
32 }
33 
34 struct kobj_attribute common_display_langcode =
35 	__ATTR_RO(display_name_language_code);
36 
hp_get_integer_from_buffer(u8 ** buffer,u32 * buffer_size,u32 * integer)37 int hp_get_integer_from_buffer(u8 **buffer, u32 *buffer_size, u32 *integer)
38 {
39 	int *ptr = PTR_ALIGN((int *)*buffer, sizeof(int));
40 
41 	/* Ensure there is enough space remaining to read the integer */
42 	if (*buffer_size < sizeof(int))
43 		return -EINVAL;
44 
45 	*integer = *(ptr++);
46 	*buffer = (u8 *)ptr;
47 	*buffer_size -= sizeof(int);
48 
49 	return 0;
50 }
51 
hp_get_string_from_buffer(u8 ** buffer,u32 * buffer_size,char * dst,u32 dst_size)52 int hp_get_string_from_buffer(u8 **buffer, u32 *buffer_size, char *dst, u32 dst_size)
53 {
54 	u16 *src = (u16 *)*buffer;
55 	u16 src_size;
56 
57 	u16 size;
58 	int i;
59 	int conv_dst_size;
60 
61 	if (*buffer_size < sizeof(u16))
62 		return -EINVAL;
63 
64 	src_size = *(src++);
65 	/* size value in u16 chars */
66 	size = src_size / sizeof(u16);
67 
68 	/* Ensure there is enough space remaining to read and convert
69 	 * the string
70 	 */
71 	if (*buffer_size < src_size)
72 		return -EINVAL;
73 
74 	for (i = 0; i < size; i++)
75 		if (src[i] == '\\' ||
76 		    src[i] == '\r' ||
77 		    src[i] == '\n' ||
78 		    src[i] == '\t')
79 			size++;
80 
81 	/*
82 	 * Conversion is limited to destination string max number of
83 	 * bytes.
84 	 */
85 	conv_dst_size = size;
86 	if (size > dst_size)
87 		conv_dst_size = dst_size - 1;
88 
89 	/*
90 	 * convert from UTF-16 unicode to ASCII
91 	 */
92 	utf16s_to_utf8s(src, src_size, UTF16_HOST_ENDIAN, dst, conv_dst_size);
93 	dst[conv_dst_size] = 0;
94 
95 	for (i = 0; i < conv_dst_size; i++) {
96 		if (*src == '\\' ||
97 		    *src == '\r' ||
98 		    *src == '\n' ||
99 		    *src == '\t') {
100 			dst[i++] = '\\';
101 			if (i == conv_dst_size)
102 				break;
103 		}
104 
105 		if (*src == '\r')
106 			dst[i] = 'r';
107 		else if (*src == '\n')
108 			dst[i] = 'n';
109 		else if (*src == '\t')
110 			dst[i] = 't';
111 		else if (*src == '"')
112 			dst[i] = '\'';
113 		else
114 			dst[i] = *src;
115 		src++;
116 	}
117 
118 	*buffer = (u8 *)src;
119 	*buffer_size -= size * sizeof(u16);
120 
121 	return size;
122 }
123 
hp_get_common_data_from_buffer(u8 ** buffer_ptr,u32 * buffer_size,struct common_data * common_data)124 int hp_get_common_data_from_buffer(u8 **buffer_ptr, u32 *buffer_size,
125 				   struct common_data *common_data)
126 {
127 	int ret = 0;
128 	int reqs;
129 
130 	// PATH:
131 	ret = hp_get_string_from_buffer(buffer_ptr, buffer_size, common_data->path,
132 					sizeof(common_data->path));
133 	if (ret < 0)
134 		goto common_exit;
135 
136 	// IS_READONLY:
137 	ret = hp_get_integer_from_buffer(buffer_ptr, buffer_size,
138 					 &common_data->is_readonly);
139 	if (ret < 0)
140 		goto common_exit;
141 
142 	//DISPLAY_IN_UI:
143 	ret = hp_get_integer_from_buffer(buffer_ptr, buffer_size,
144 					 &common_data->display_in_ui);
145 	if (ret < 0)
146 		goto common_exit;
147 
148 	// REQUIRES_PHYSICAL_PRESENCE:
149 	ret = hp_get_integer_from_buffer(buffer_ptr, buffer_size,
150 					 &common_data->requires_physical_presence);
151 	if (ret < 0)
152 		goto common_exit;
153 
154 	// SEQUENCE:
155 	ret = hp_get_integer_from_buffer(buffer_ptr, buffer_size,
156 					 &common_data->sequence);
157 	if (ret < 0)
158 		goto common_exit;
159 
160 	// PREREQUISITES_SIZE:
161 	ret = hp_get_integer_from_buffer(buffer_ptr, buffer_size,
162 					 &common_data->prerequisites_size);
163 	if (ret < 0)
164 		goto common_exit;
165 
166 	if (common_data->prerequisites_size > MAX_PREREQUISITES_SIZE) {
167 		/* Report a message and limit prerequisite size to maximum value */
168 		pr_warn("Prerequisites size value exceeded the maximum number of elements supported or data may be malformed\n");
169 		common_data->prerequisites_size = MAX_PREREQUISITES_SIZE;
170 	}
171 
172 	// PREREQUISITES:
173 	for (reqs = 0; reqs < common_data->prerequisites_size; reqs++) {
174 		ret = hp_get_string_from_buffer(buffer_ptr, buffer_size,
175 						common_data->prerequisites[reqs],
176 						sizeof(common_data->prerequisites[reqs]));
177 		if (ret < 0)
178 			break;
179 	}
180 
181 	// SECURITY_LEVEL:
182 	ret = hp_get_integer_from_buffer(buffer_ptr, buffer_size,
183 					 &common_data->security_level);
184 
185 common_exit:
186 	return ret;
187 }
188 
hp_enforce_single_line_input(char * buf,size_t count)189 int hp_enforce_single_line_input(char *buf, size_t count)
190 {
191 	char *p;
192 
193 	p = memchr(buf, '\n', count);
194 
195 	if (p == buf + count - 1)
196 		*p = '\0'; /* strip trailing newline */
197 	else if (p)
198 		return -EINVAL;  /* enforce single line input */
199 
200 	return 0;
201 }
202 
203 /* Set pending reboot value and generate KOBJ_NAME event */
hp_set_reboot_and_signal_event(void)204 void hp_set_reboot_and_signal_event(void)
205 {
206 	bioscfg_drv.pending_reboot = true;
207 	kobject_uevent(&bioscfg_drv.class_dev->kobj, KOBJ_CHANGE);
208 }
209 
210 /**
211  * hp_calculate_string_buffer() - determines size of string buffer for
212  * use with BIOS communication
213  *
214  * @str: the string to calculate based upon
215  */
hp_calculate_string_buffer(const char * str)216 size_t hp_calculate_string_buffer(const char *str)
217 {
218 	size_t length = strlen(str);
219 
220 	/* BIOS expects 4 bytes when an empty string is found */
221 	if (length == 0)
222 		return 4;
223 
224 	/* u16 length field + one UTF16 char for each input char */
225 	return sizeof(u16) + strlen(str) * sizeof(u16);
226 }
227 
hp_wmi_error_and_message(int error_code)228 int hp_wmi_error_and_message(int error_code)
229 {
230 	char *error_msg = NULL;
231 	int ret;
232 
233 	switch (error_code) {
234 	case SUCCESS:
235 		error_msg = "Success";
236 		ret = 0;
237 		break;
238 	case CMD_FAILED:
239 		error_msg = "Command failed";
240 		ret = -EINVAL;
241 		break;
242 	case INVALID_SIGN:
243 		error_msg = "Invalid signature";
244 		ret = -EINVAL;
245 		break;
246 	case INVALID_CMD_VALUE:
247 		error_msg = "Invalid command value/Feature not supported";
248 		ret = -EOPNOTSUPP;
249 		break;
250 	case INVALID_CMD_TYPE:
251 		error_msg = "Invalid command type";
252 		ret = -EINVAL;
253 		break;
254 	case INVALID_DATA_SIZE:
255 		error_msg = "Invalid data size";
256 		ret = -EINVAL;
257 		break;
258 	case INVALID_CMD_PARAM:
259 		error_msg = "Invalid command parameter";
260 		ret = -EINVAL;
261 		break;
262 	case ENCRYP_CMD_REQUIRED:
263 		error_msg = "Secure/encrypted command required";
264 		ret = -EACCES;
265 		break;
266 	case NO_SECURE_SESSION:
267 		error_msg = "No secure session established";
268 		ret = -EACCES;
269 		break;
270 	case SECURE_SESSION_FOUND:
271 		error_msg = "Secure session already established";
272 		ret = -EACCES;
273 		break;
274 	case SECURE_SESSION_FAILED:
275 		error_msg = "Secure session failed";
276 		ret = -EIO;
277 		break;
278 	case AUTH_FAILED:
279 		error_msg = "Other permission/Authentication failed";
280 		ret = -EACCES;
281 		break;
282 	case INVALID_BIOS_AUTH:
283 		error_msg = "Invalid BIOS administrator password";
284 		ret = -EINVAL;
285 		break;
286 	case NONCE_DID_NOT_MATCH:
287 		error_msg = "Nonce did not match";
288 		ret = -EINVAL;
289 		break;
290 	case GENERIC_ERROR:
291 		error_msg = "Generic/Other error";
292 		ret = -EIO;
293 		break;
294 	case BIOS_ADMIN_POLICY_NOT_MET:
295 		error_msg = "BIOS Admin password does not meet password policy requirements";
296 		ret = -EINVAL;
297 		break;
298 	case BIOS_ADMIN_NOT_SET:
299 		error_msg = "BIOS Setup password is not set";
300 		ret = -EPERM;
301 		break;
302 	case P21_NO_PROVISIONED:
303 		error_msg = "P21 is not provisioned";
304 		ret = -EPERM;
305 		break;
306 	case P21_PROVISION_IN_PROGRESS:
307 		error_msg = "P21 is already provisioned or provisioning is in progress and a signing key has already been sent";
308 		ret = -EINPROGRESS;
309 		break;
310 	case P21_IN_USE:
311 		error_msg = "P21 in use (cannot deprovision)";
312 		ret = -EPERM;
313 		break;
314 	case HEP_NOT_ACTIVE:
315 		error_msg = "HEP not activated";
316 		ret = -EPERM;
317 		break;
318 	case HEP_ALREADY_SET:
319 		error_msg = "HEP Transport already set";
320 		ret = -EINVAL;
321 		break;
322 	case HEP_CHECK_STATE:
323 		error_msg = "Check the current HEP state";
324 		ret = -EINVAL;
325 		break;
326 	default:
327 		error_msg = "Generic/Other error";
328 		ret = -EIO;
329 		break;
330 	}
331 
332 	if (error_code)
333 		pr_warn_ratelimited("Returned error 0x%x, \"%s\"\n", error_code, error_msg);
334 
335 	return ret;
336 }
337 
pending_reboot_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)338 static ssize_t pending_reboot_show(struct kobject *kobj,
339 				   struct kobj_attribute *attr,
340 				   char *buf)
341 {
342 	return sysfs_emit(buf, "%d\n", bioscfg_drv.pending_reboot);
343 }
344 
345 static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
346 
347 /*
348  * create_attributes_level_sysfs_files() - Creates pending_reboot attributes
349  */
create_attributes_level_sysfs_files(void)350 static int create_attributes_level_sysfs_files(void)
351 {
352 	return  sysfs_create_file(&bioscfg_drv.main_dir_kset->kobj,
353 				  &pending_reboot.attr);
354 }
355 
attr_name_release(struct kobject * kobj)356 static void attr_name_release(struct kobject *kobj)
357 {
358 	kfree(kobj);
359 }
360 
361 static const struct kobj_type attr_name_ktype = {
362 	.release	= attr_name_release,
363 	.sysfs_ops	= &kobj_sysfs_ops,
364 };
365 
366 /**
367  * hp_get_wmiobj_pointer() - Get Content of WMI block for particular instance
368  *
369  * @instance_id: WMI instance ID
370  * @guid_string: WMI GUID (in str form)
371  *
372  * Fetches the content for WMI block (instance_id) under GUID (guid_string)
373  * Caller must kfree the return
374  */
hp_get_wmiobj_pointer(int instance_id,const char * guid_string)375 union acpi_object *hp_get_wmiobj_pointer(int instance_id, const char *guid_string)
376 {
377 	struct acpi_buffer out = { ACPI_ALLOCATE_BUFFER, NULL };
378 	acpi_status status;
379 
380 	status = wmi_query_block(guid_string, instance_id, &out);
381 	return ACPI_SUCCESS(status) ? (union acpi_object *)out.pointer : NULL;
382 }
383 
384 /**
385  * hp_get_instance_count() - Compute total number of instances under guid_string
386  *
387  * @guid_string: WMI GUID (in string form)
388  */
hp_get_instance_count(const char * guid_string)389 int hp_get_instance_count(const char *guid_string)
390 {
391 	int ret;
392 
393 	ret = wmi_instance_count(guid_string);
394 	if (ret < 0)
395 		return 0;
396 
397 	return ret;
398 }
399 
400 /**
401  * hp_alloc_attributes_data() - Allocate attributes data for a particular type
402  *
403  * @attr_type: Attribute type to allocate
404  */
hp_alloc_attributes_data(int attr_type)405 static int hp_alloc_attributes_data(int attr_type)
406 {
407 	switch (attr_type) {
408 	case HPWMI_STRING_TYPE:
409 		return hp_alloc_string_data();
410 
411 	case HPWMI_INTEGER_TYPE:
412 		return hp_alloc_integer_data();
413 
414 	case HPWMI_ENUMERATION_TYPE:
415 		return hp_alloc_enumeration_data();
416 
417 	case HPWMI_ORDERED_LIST_TYPE:
418 		return hp_alloc_ordered_list_data();
419 
420 	case HPWMI_PASSWORD_TYPE:
421 		return hp_alloc_password_data();
422 
423 	default:
424 		return 0;
425 	}
426 }
427 
hp_convert_hexstr_to_str(const char * input,u32 input_len,char ** str,int * len)428 int hp_convert_hexstr_to_str(const char *input, u32 input_len, char **str, int *len)
429 {
430 	int ret = 0;
431 	int new_len = 0;
432 	char tmp[] = "0x00";
433 	char *new_str = NULL;
434 	long  ch;
435 	int i;
436 
437 	if (input_len <= 0 || !input || !str || !len)
438 		return -EINVAL;
439 
440 	*len = 0;
441 	*str = NULL;
442 
443 	new_str = kmalloc(input_len, GFP_KERNEL);
444 	if (!new_str)
445 		return -ENOMEM;
446 
447 	for (i = 0; i < input_len; i += 5) {
448 		strscpy(tmp, input + i);
449 		if (kstrtol(tmp, 16, &ch) == 0) {
450 			// escape char
451 			if (ch == '\\' ||
452 			    ch == '\r' ||
453 			    ch == '\n' || ch == '\t') {
454 				if (ch == '\r')
455 					ch = 'r';
456 				else if (ch == '\n')
457 					ch = 'n';
458 				else if (ch == '\t')
459 					ch = 't';
460 				new_str[new_len++] = '\\';
461 			}
462 			new_str[new_len++] = ch;
463 			if (ch == '\0')
464 				break;
465 		}
466 	}
467 
468 	if (new_len) {
469 		new_str[new_len] = '\0';
470 		*str = krealloc(new_str, (new_len + 1) * sizeof(char),
471 				GFP_KERNEL);
472 		if (*str)
473 			*len = new_len;
474 		else
475 			ret = -ENOMEM;
476 	} else {
477 		ret = -EFAULT;
478 	}
479 
480 	if (ret)
481 		kfree(new_str);
482 	return ret;
483 }
484 
485 /* map output size to the corresponding WMI method id */
hp_encode_outsize_for_pvsz(int outsize)486 int hp_encode_outsize_for_pvsz(int outsize)
487 {
488 	if (outsize > 4096)
489 		return -EINVAL;
490 	if (outsize > 1024)
491 		return 5;
492 	if (outsize > 128)
493 		return 4;
494 	if (outsize > 4)
495 		return 3;
496 	if (outsize > 0)
497 		return 2;
498 	return 1;
499 }
500 
501 /*
502  * Update friendly display name for several attributes associated to
503  * 'Schedule Power-On'
504  */
hp_friendly_user_name_update(char * path,const char * attr_name,char * attr_display,int attr_size)505 void hp_friendly_user_name_update(char *path, const char *attr_name,
506 				  char *attr_display, int attr_size)
507 {
508 	if (strstr(path, SCHEDULE_POWER_ON))
509 		snprintf(attr_display, attr_size, "%s - %s", SCHEDULE_POWER_ON, attr_name);
510 	else
511 		strscpy(attr_display, attr_name, attr_size);
512 }
513 
514 /**
515  * hp_update_attribute_permissions() - Update attributes permissions when
516  * isReadOnly value is 1
517  *
518  * @is_readonly:  bool value to indicate if it a readonly attribute.
519  * @current_val: kobj_attribute corresponding to attribute.
520  *
521  */
hp_update_attribute_permissions(bool is_readonly,struct kobj_attribute * current_val)522 void hp_update_attribute_permissions(bool is_readonly, struct kobj_attribute *current_val)
523 {
524 	current_val->attr.mode = is_readonly ? 0444 : 0644;
525 }
526 
527 /**
528  * destroy_attribute_objs() - Free a kset of kobjects
529  * @kset: The kset to destroy
530  *
531  * Fress kobjects created for each attribute_name under attribute type kset
532  */
destroy_attribute_objs(struct kset * kset)533 static void destroy_attribute_objs(struct kset *kset)
534 {
535 	struct kobject *pos, *next;
536 
537 	list_for_each_entry_safe(pos, next, &kset->list, entry)
538 		kobject_put(pos);
539 }
540 
541 /**
542  * release_attributes_data() - Clean-up all sysfs directories and files created
543  */
release_attributes_data(void)544 static void release_attributes_data(void)
545 {
546 	mutex_lock(&bioscfg_drv.mutex);
547 
548 	hp_exit_string_attributes();
549 	hp_exit_integer_attributes();
550 	hp_exit_enumeration_attributes();
551 	hp_exit_ordered_list_attributes();
552 	hp_exit_password_attributes();
553 	hp_exit_sure_start_attributes();
554 	hp_exit_secure_platform_attributes();
555 
556 	if (bioscfg_drv.authentication_dir_kset) {
557 		destroy_attribute_objs(bioscfg_drv.authentication_dir_kset);
558 		kset_unregister(bioscfg_drv.authentication_dir_kset);
559 		bioscfg_drv.authentication_dir_kset = NULL;
560 	}
561 	if (bioscfg_drv.main_dir_kset) {
562 		sysfs_remove_file(&bioscfg_drv.main_dir_kset->kobj, &pending_reboot.attr);
563 		destroy_attribute_objs(bioscfg_drv.main_dir_kset);
564 		kset_unregister(bioscfg_drv.main_dir_kset);
565 		bioscfg_drv.main_dir_kset = NULL;
566 	}
567 	mutex_unlock(&bioscfg_drv.mutex);
568 }
569 
570 /**
571  * hp_add_other_attributes() - Initialize HP custom attributes not
572  * reported by BIOS and required to support Secure Platform and Sure
573  * Start.
574  *
575  * @attr_type: Custom HP attribute not reported by BIOS
576  *
577  * Initialize all 2 types of attributes: Platform and Sure Start
578  * object.  Populates each attribute types respective properties
579  * under sysfs files.
580  *
581  * Returns zero(0) if successful. Otherwise, a negative value.
582  */
hp_add_other_attributes(int attr_type)583 static int hp_add_other_attributes(int attr_type)
584 {
585 	struct kobject *attr_name_kobj;
586 	int ret;
587 	char *attr_name;
588 
589 	attr_name_kobj = kzalloc(sizeof(*attr_name_kobj), GFP_KERNEL);
590 	if (!attr_name_kobj)
591 		return -ENOMEM;
592 
593 	mutex_lock(&bioscfg_drv.mutex);
594 
595 	/* Check if attribute type is supported */
596 	switch (attr_type) {
597 	case HPWMI_SECURE_PLATFORM_TYPE:
598 		attr_name_kobj->kset = bioscfg_drv.authentication_dir_kset;
599 		attr_name = SPM_STR;
600 		break;
601 
602 	case HPWMI_SURE_START_TYPE:
603 		attr_name_kobj->kset = bioscfg_drv.main_dir_kset;
604 		attr_name = SURE_START_STR;
605 		break;
606 
607 	default:
608 		pr_err("Error: Unknown attr_type: %d\n", attr_type);
609 		ret = -EINVAL;
610 		kfree(attr_name_kobj);
611 		goto unlock_drv_mutex;
612 	}
613 
614 	ret = kobject_init_and_add(attr_name_kobj, &attr_name_ktype,
615 				   NULL, "%s", attr_name);
616 	if (ret) {
617 		pr_err("Error encountered [%d]\n", ret);
618 		goto err_other_attr_init;
619 	}
620 
621 	/* Populate attribute data */
622 	switch (attr_type) {
623 	case HPWMI_SECURE_PLATFORM_TYPE:
624 		ret = hp_populate_secure_platform_data(attr_name_kobj);
625 		break;
626 
627 	case HPWMI_SURE_START_TYPE:
628 		ret = hp_populate_sure_start_data(attr_name_kobj);
629 		break;
630 
631 	default:
632 		ret = -EINVAL;
633 	}
634 
635 	if (ret)
636 		goto err_other_attr_init;
637 
638 	mutex_unlock(&bioscfg_drv.mutex);
639 	return 0;
640 
641 err_other_attr_init:
642 	kobject_put(attr_name_kobj);
643 unlock_drv_mutex:
644 	mutex_unlock(&bioscfg_drv.mutex);
645 	return ret;
646 }
647 
hp_init_bios_package_attribute(enum hp_wmi_data_type attr_type,union acpi_object * obj,const char * guid,int min_elements,int instance_id)648 static int hp_init_bios_package_attribute(enum hp_wmi_data_type attr_type,
649 					  union acpi_object *obj,
650 					  const char *guid, int min_elements,
651 					  int instance_id)
652 {
653 	struct kobject *attr_name_kobj, *duplicate;
654 	union acpi_object *elements;
655 	struct kset *temp_kset;
656 
657 	char *str_value = NULL;
658 	int str_len;
659 	int ret = 0;
660 
661 	/* Take action appropriate to each ACPI TYPE */
662 	if (obj->package.count < min_elements) {
663 		pr_err("ACPI-package does not have enough elements: %d < %d\n",
664 		       obj->package.count, min_elements);
665 		goto pack_attr_exit;
666 	}
667 
668 	elements = obj->package.elements;
669 
670 	/* sanity checking */
671 	if (elements[NAME].type != ACPI_TYPE_STRING) {
672 		pr_debug("incorrect element type\n");
673 		goto pack_attr_exit;
674 	}
675 	if (strlen(elements[NAME].string.pointer) == 0) {
676 		pr_debug("empty attribute found\n");
677 		goto pack_attr_exit;
678 	}
679 
680 	if (attr_type == HPWMI_PASSWORD_TYPE)
681 		temp_kset = bioscfg_drv.authentication_dir_kset;
682 	else
683 		temp_kset = bioscfg_drv.main_dir_kset;
684 
685 	/* convert attribute name to string */
686 	ret = hp_convert_hexstr_to_str(elements[NAME].string.pointer,
687 				       elements[NAME].string.length,
688 				       &str_value, &str_len);
689 
690 	if (ret) {
691 		pr_debug("Failed to populate integer package data. Error [0%0x]\n",
692 			 ret);
693 		kfree(str_value);
694 		return ret;
695 	}
696 
697 	/* All duplicate attributes found are ignored */
698 	duplicate = kset_find_obj(temp_kset, str_value);
699 	if (duplicate) {
700 		pr_debug("Duplicate attribute name found - %s\n", str_value);
701 		/* kset_find_obj() returns a reference */
702 		kobject_put(duplicate);
703 		goto pack_attr_exit;
704 	}
705 
706 	/* build attribute */
707 	attr_name_kobj = kzalloc(sizeof(*attr_name_kobj), GFP_KERNEL);
708 	if (!attr_name_kobj) {
709 		ret = -ENOMEM;
710 		goto pack_attr_exit;
711 	}
712 
713 	attr_name_kobj->kset = temp_kset;
714 
715 	ret = kobject_init_and_add(attr_name_kobj, &attr_name_ktype,
716 				   NULL, "%s", str_value);
717 
718 	if (ret) {
719 		kobject_put(attr_name_kobj);
720 		goto pack_attr_exit;
721 	}
722 
723 	/* enumerate all of these attributes */
724 	switch (attr_type) {
725 	case HPWMI_STRING_TYPE:
726 		ret = hp_populate_string_package_data(elements,
727 						      instance_id,
728 						      attr_name_kobj);
729 		break;
730 	case HPWMI_INTEGER_TYPE:
731 		ret = hp_populate_integer_package_data(elements,
732 						       instance_id,
733 						       attr_name_kobj);
734 		break;
735 	case HPWMI_ENUMERATION_TYPE:
736 		ret = hp_populate_enumeration_package_data(elements,
737 							   instance_id,
738 							   attr_name_kobj);
739 		break;
740 	case HPWMI_ORDERED_LIST_TYPE:
741 		ret = hp_populate_ordered_list_package_data(elements,
742 							    instance_id,
743 							    attr_name_kobj);
744 		break;
745 	case HPWMI_PASSWORD_TYPE:
746 		ret = hp_populate_password_package_data(elements,
747 							instance_id,
748 							attr_name_kobj);
749 		break;
750 	default:
751 		pr_debug("Unknown attribute type found: 0x%x\n", attr_type);
752 		break;
753 	}
754 
755 pack_attr_exit:
756 	kfree(str_value);
757 	return ret;
758 }
759 
hp_init_bios_buffer_attribute(enum hp_wmi_data_type attr_type,union acpi_object * obj,const char * guid,int min_elements,int instance_id)760 static int hp_init_bios_buffer_attribute(enum hp_wmi_data_type attr_type,
761 					 union acpi_object *obj,
762 					 const char *guid, int min_elements,
763 					 int instance_id)
764 {
765 	struct kobject *attr_name_kobj, *duplicate;
766 	struct kset *temp_kset;
767 	char str[MAX_BUFF_SIZE];
768 
769 	char *temp_str = NULL;
770 	char *str_value = NULL;
771 	u8 *buffer_ptr = NULL;
772 	int buffer_size;
773 	int ret = 0;
774 
775 	buffer_size = obj->buffer.length;
776 	buffer_ptr = obj->buffer.pointer;
777 
778 	ret = hp_get_string_from_buffer(&buffer_ptr,
779 					&buffer_size, str, MAX_BUFF_SIZE);
780 
781 	if (ret < 0)
782 		goto buff_attr_exit;
783 
784 	if (attr_type == HPWMI_PASSWORD_TYPE ||
785 	    attr_type == HPWMI_SECURE_PLATFORM_TYPE)
786 		temp_kset = bioscfg_drv.authentication_dir_kset;
787 	else
788 		temp_kset = bioscfg_drv.main_dir_kset;
789 
790 	/* All duplicate attributes found are ignored */
791 	duplicate = kset_find_obj(temp_kset, str);
792 	if (duplicate) {
793 		pr_debug("Duplicate attribute name found - %s\n", str);
794 		/* kset_find_obj() returns a reference */
795 		kobject_put(duplicate);
796 		goto buff_attr_exit;
797 	}
798 
799 	/* build attribute */
800 	attr_name_kobj = kzalloc(sizeof(*attr_name_kobj), GFP_KERNEL);
801 	if (!attr_name_kobj) {
802 		ret = -ENOMEM;
803 		goto buff_attr_exit;
804 	}
805 
806 	attr_name_kobj->kset = temp_kset;
807 
808 	temp_str = str;
809 	if (attr_type == HPWMI_SECURE_PLATFORM_TYPE)
810 		temp_str = "SPM";
811 
812 	ret = kobject_init_and_add(attr_name_kobj,
813 				   &attr_name_ktype, NULL, "%s", temp_str);
814 	if (ret) {
815 		kobject_put(attr_name_kobj);
816 		goto buff_attr_exit;
817 	}
818 
819 	/* enumerate all of these attributes */
820 	switch (attr_type) {
821 	case HPWMI_STRING_TYPE:
822 		ret = hp_populate_string_buffer_data(buffer_ptr,
823 						     &buffer_size,
824 						     instance_id,
825 						     attr_name_kobj);
826 		break;
827 	case HPWMI_INTEGER_TYPE:
828 		ret = hp_populate_integer_buffer_data(buffer_ptr,
829 						      &buffer_size,
830 						      instance_id,
831 						      attr_name_kobj);
832 		break;
833 	case HPWMI_ENUMERATION_TYPE:
834 		ret = hp_populate_enumeration_buffer_data(buffer_ptr,
835 							  &buffer_size,
836 							  instance_id,
837 							  attr_name_kobj);
838 		break;
839 	case HPWMI_ORDERED_LIST_TYPE:
840 		ret = hp_populate_ordered_list_buffer_data(buffer_ptr,
841 							   &buffer_size,
842 							   instance_id,
843 							   attr_name_kobj);
844 		break;
845 	case HPWMI_PASSWORD_TYPE:
846 		ret = hp_populate_password_buffer_data(buffer_ptr,
847 						       &buffer_size,
848 						       instance_id,
849 						       attr_name_kobj);
850 		break;
851 	default:
852 		pr_debug("Unknown attribute type found: 0x%x\n", attr_type);
853 		break;
854 	}
855 
856 buff_attr_exit:
857 	kfree(str_value);
858 	return ret;
859 }
860 
861 /**
862  * hp_init_bios_attributes() - Initialize all attributes for a type
863  * @attr_type: The attribute type to initialize
864  * @guid: The WMI GUID associated with this type to initialize
865  *
866  * Initialize all 5 types of attributes: enumeration, integer,
867  * string, password, ordered list  object.  Populates each attribute types
868  * respective properties under sysfs files
869  */
hp_init_bios_attributes(enum hp_wmi_data_type attr_type,const char * guid)870 static int hp_init_bios_attributes(enum hp_wmi_data_type attr_type, const char *guid)
871 {
872 	union acpi_object *obj = NULL;
873 	int min_elements;
874 
875 	/* instance_id needs to be reset for each type GUID
876 	 * also, instance IDs are unique within GUID but not across
877 	 */
878 	int instance_id = 0;
879 	int cur_instance_id = instance_id;
880 	int ret = 0;
881 
882 	ret = hp_alloc_attributes_data(attr_type);
883 	if (ret)
884 		return ret;
885 
886 	switch (attr_type) {
887 	case HPWMI_STRING_TYPE:
888 		min_elements = STR_ELEM_CNT;
889 		break;
890 	case HPWMI_INTEGER_TYPE:
891 		min_elements = INT_ELEM_CNT;
892 		break;
893 	case HPWMI_ENUMERATION_TYPE:
894 		min_elements = ENUM_ELEM_CNT;
895 		break;
896 	case HPWMI_ORDERED_LIST_TYPE:
897 		min_elements = ORD_ELEM_CNT;
898 		break;
899 	case HPWMI_PASSWORD_TYPE:
900 		min_elements = PSWD_ELEM_CNT;
901 		break;
902 	default:
903 		pr_err("Error: Unknown attr_type: %d\n", attr_type);
904 		return -EINVAL;
905 	}
906 
907 	/* need to use specific instance_id and guid combination to get right data */
908 	obj = hp_get_wmiobj_pointer(instance_id, guid);
909 	if (!obj)
910 		return -ENODEV;
911 
912 	mutex_lock(&bioscfg_drv.mutex);
913 	while (obj) {
914 		/* Take action appropriate to each ACPI TYPE */
915 		if (obj->type == ACPI_TYPE_PACKAGE) {
916 			ret = hp_init_bios_package_attribute(attr_type, obj,
917 							     guid, min_elements,
918 							     cur_instance_id);
919 
920 		} else if (obj->type == ACPI_TYPE_BUFFER) {
921 			ret = hp_init_bios_buffer_attribute(attr_type, obj,
922 							    guid, min_elements,
923 							    cur_instance_id);
924 
925 		} else {
926 			pr_err("Expected ACPI-package or buffer type, got: %d\n",
927 			       obj->type);
928 			ret = -EIO;
929 			goto err_attr_init;
930 		}
931 
932 		/*
933 		 * Failure reported in one attribute must not
934 		 * stop process of the remaining attribute values.
935 		 */
936 		if (ret >= 0)
937 			cur_instance_id++;
938 
939 		kfree(obj);
940 		instance_id++;
941 		obj = hp_get_wmiobj_pointer(instance_id, guid);
942 	}
943 
944 err_attr_init:
945 	mutex_unlock(&bioscfg_drv.mutex);
946 	kfree(obj);
947 	return ret;
948 }
949 
hp_init(void)950 static int __init hp_init(void)
951 {
952 	int ret;
953 	int hp_bios_capable = wmi_has_guid(HP_WMI_BIOS_GUID);
954 	int set_bios_settings = wmi_has_guid(HP_WMI_SET_BIOS_SETTING_GUID);
955 
956 	if (!hp_bios_capable) {
957 		pr_err("Unable to run on non-HP system\n");
958 		return -ENODEV;
959 	}
960 
961 	if (!set_bios_settings) {
962 		pr_err("Unable to set BIOS settings on HP systems\n");
963 		return -ENODEV;
964 	}
965 
966 	ret = hp_init_attr_set_interface();
967 	if (ret)
968 		return ret;
969 
970 	bioscfg_drv.class_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0),
971 					      NULL, "%s", DRIVER_NAME);
972 	if (IS_ERR(bioscfg_drv.class_dev)) {
973 		ret = PTR_ERR(bioscfg_drv.class_dev);
974 		goto err_unregister_class;
975 	}
976 
977 	bioscfg_drv.main_dir_kset = kset_create_and_add("attributes", NULL,
978 							&bioscfg_drv.class_dev->kobj);
979 	if (!bioscfg_drv.main_dir_kset) {
980 		ret = -ENOMEM;
981 		pr_debug("Failed to create and add attributes\n");
982 		goto err_destroy_classdev;
983 	}
984 
985 	bioscfg_drv.authentication_dir_kset = kset_create_and_add("authentication", NULL,
986 								  &bioscfg_drv.class_dev->kobj);
987 	if (!bioscfg_drv.authentication_dir_kset) {
988 		ret = -ENOMEM;
989 		pr_debug("Failed to create and add authentication\n");
990 		goto err_release_attributes_data;
991 	}
992 
993 	/*
994 	 * sysfs level attributes.
995 	 * - pending_reboot
996 	 */
997 	ret = create_attributes_level_sysfs_files();
998 	if (ret)
999 		pr_debug("Failed to create sysfs level attributes\n");
1000 
1001 	ret = hp_init_bios_attributes(HPWMI_STRING_TYPE, HP_WMI_BIOS_STRING_GUID);
1002 	if (ret)
1003 		pr_debug("Failed to populate string type attributes\n");
1004 
1005 	ret = hp_init_bios_attributes(HPWMI_INTEGER_TYPE, HP_WMI_BIOS_INTEGER_GUID);
1006 	if (ret)
1007 		pr_debug("Failed to populate integer type attributes\n");
1008 
1009 	ret = hp_init_bios_attributes(HPWMI_ENUMERATION_TYPE, HP_WMI_BIOS_ENUMERATION_GUID);
1010 	if (ret)
1011 		pr_debug("Failed to populate enumeration type attributes\n");
1012 
1013 	ret = hp_init_bios_attributes(HPWMI_ORDERED_LIST_TYPE, HP_WMI_BIOS_ORDERED_LIST_GUID);
1014 	if (ret)
1015 		pr_debug("Failed to populate ordered list object type attributes\n");
1016 
1017 	ret = hp_init_bios_attributes(HPWMI_PASSWORD_TYPE, HP_WMI_BIOS_PASSWORD_GUID);
1018 	if (ret)
1019 		pr_debug("Failed to populate password object type attributes\n");
1020 
1021 	bioscfg_drv.spm_data.attr_name_kobj = NULL;
1022 	ret = hp_add_other_attributes(HPWMI_SECURE_PLATFORM_TYPE);
1023 	if (ret)
1024 		pr_debug("Failed to populate secure platform object type attribute\n");
1025 
1026 	bioscfg_drv.sure_start_attr_kobj = NULL;
1027 	ret = hp_add_other_attributes(HPWMI_SURE_START_TYPE);
1028 	if (ret)
1029 		pr_debug("Failed to populate sure start object type attribute\n");
1030 
1031 	return 0;
1032 
1033 err_release_attributes_data:
1034 	release_attributes_data();
1035 
1036 err_destroy_classdev:
1037 	device_unregister(bioscfg_drv.class_dev);
1038 
1039 err_unregister_class:
1040 	hp_exit_attr_set_interface();
1041 
1042 	return ret;
1043 }
1044 
hp_exit(void)1045 static void __exit hp_exit(void)
1046 {
1047 	release_attributes_data();
1048 	device_unregister(bioscfg_drv.class_dev);
1049 
1050 	hp_exit_attr_set_interface();
1051 }
1052 
1053 module_init(hp_init);
1054 module_exit(hp_exit);
1055