392 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Functions corresponding to string type attributes under4 * 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 lengths29 *30 * @instance_id: The instance on which input is validated31 * @buf: Input value32 */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 NULL95};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 expected207 * element list pointing to the right obj[elem].type208 * when the size is zero. PREREQUISITES209 * object is omitted by BIOS when the size is210 * 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 attribute264 *265 * @string_obj: ACPI object with string data266 * @instance_id: The instance to enumerate267 * @attr_name_kobj: The parent kernel object268 */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 is298 * read. BIOS defines the order in which each * element is299 * read. Element 0 data is not relevant to this300 * driver hence it is ignored. For clarity, all element names301 * (DISPLAY_IN_UI) which defines the order in which is read302 * and the name matches the variable where the data is stored.303 *304 * In earlier implementation, reported errors were ignored305 * causing the data to remain uninitialized. It is not306 * possible to determine if data read from BIOS is valid or307 * not. It is for this reason functions may return a error308 * 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 attribute340 *341 * @buffer_ptr: Buffer pointer342 * @buffer_size: Buffer size343 * @instance_id: The instance to enumerate344 * @attr_name_kobj: The parent kernel object345 */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 data372 *373 * Clears all data allocated for this group of attributes374 */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}392