drivers/platform/x86/hp/hp-bioscfg/bioscfg.c

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