drivers/acpi/acpica/nsrepair.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: nsrepair - Repair for objects returned by predefined methods
   5  *
   6  * Copyright (C) 2000 - 2023, Intel Corp.
   7  *
   8  *****************************************************************************/
   9
  10 #include <acpi/acpi.h>
  11 #include "accommon.h"
  12 #include "acnamesp.h"
  13 #include "acinterp.h"
  14 #include "acpredef.h"
  15 #include "amlresrc.h"
  16
  17 #define _COMPONENT          ACPI_NAMESPACE
  18 ACPI_MODULE_NAME("nsrepair")
  19
  20 /*******************************************************************************
  21  *
  22  * This module attempts to repair or convert objects returned by the
  23  * predefined methods to an object type that is expected, as per the ACPI
  24  * specification. The need for this code is dictated by the many machines that
  25  * return incorrect types for the standard predefined methods. Performing these
  26  * conversions here, in one place, eliminates the need for individual ACPI
  27  * device drivers to do the same. Note: Most of these conversions are different
  28  * than the internal object conversion routines used for implicit object
  29  * conversion.
  30  *
  31  * The following conversions can be performed as necessary:
  32  *
  33  * Integer -> String
  34  * Integer -> Buffer
  35  * String  -> Integer
  36  * String  -> Buffer
  37  * Buffer  -> Integer
  38  * Buffer  -> String
  39  * Buffer  -> Package of Integers
  40  * Package -> Package of one Package
  41  *
  42  * Additional conversions that are available:
  43  *  Convert a null return or zero return value to an end_tag descriptor
  44  *  Convert an ASCII string to a Unicode buffer
  45  *
  46  * An incorrect standalone object is wrapped with required outer package
  47  *
  48  * Additional possible repairs:
  49  * Required package elements that are NULL replaced by Integer/String/Buffer
  50  *
  51  ******************************************************************************/
  52 /* Local prototypes */
  53 static const struct acpi_simple_repair_info *acpi_ns_match_simple_repair(struct
  54                                                                          acpi_namespace_node
  55                                                                          *node,
  56                                                                          u32
  57                                                                          return_btype,
  58                                                                          u32
  59                                                                          package_index);
  60
  61 /*
  62  * Special but simple repairs for some names.
  63  *
  64  * 2nd argument: Unexpected types that can be repaired
  65  */
  66 static const struct acpi_simple_repair_info acpi_object_repair_info[] = {
  67         /* Resource descriptor conversions */
  68
  69         {"_CRS",
  70          ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER |
  71          ACPI_RTYPE_NONE,
  72          ACPI_NOT_PACKAGE_ELEMENT,
  73          acpi_ns_convert_to_resource},
  74         {"_DMA",
  75          ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER |
  76          ACPI_RTYPE_NONE,
  77          ACPI_NOT_PACKAGE_ELEMENT,
  78          acpi_ns_convert_to_resource},
  79         {"_PRS",
  80          ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER |
  81          ACPI_RTYPE_NONE,
  82          ACPI_NOT_PACKAGE_ELEMENT,
  83          acpi_ns_convert_to_resource},
  84
  85         /* Object reference conversions */
  86
  87         {"_DEP", ACPI_RTYPE_STRING, ACPI_ALL_PACKAGE_ELEMENTS,
  88          acpi_ns_convert_to_reference},
  89
  90         /* Unicode conversions */
  91
  92         {"_MLS", ACPI_RTYPE_STRING, 1,
  93          acpi_ns_convert_to_unicode},
  94         {"_STR", ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER,
  95          ACPI_NOT_PACKAGE_ELEMENT,
  96          acpi_ns_convert_to_unicode},
  97         {{0, 0, 0, 0}, 0, 0, NULL}      /* Table terminator */
  98 };
  99
 100 /*******************************************************************************
 101  *
 102  * FUNCTION:    acpi_ns_simple_repair
 103  *
 104  * PARAMETERS:  info                - Method execution information block
 105  *              expected_btypes     - Object types expected
 106  *              package_index       - Index of object within parent package (if
 107  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 108  *                                    otherwise)
 109  *              return_object_ptr   - Pointer to the object returned from the
 110  *                                    evaluation of a method or object
 111  *
 112  * RETURN:      Status. AE_OK if repair was successful.
 113  *
 114  * DESCRIPTION: Attempt to repair/convert a return object of a type that was
 115  *              not expected.
 116  *
 117  ******************************************************************************/
 118
 119 acpi_status
 120 acpi_ns_simple_repair(struct acpi_evaluate_info *info,
 121                       u32 expected_btypes,
 122                       u32 package_index,
 123                       union acpi_operand_object **return_object_ptr)
 124 {
 125         union acpi_operand_object *return_object = *return_object_ptr;
 126         union acpi_operand_object *new_object = NULL;
 127         acpi_status status;
 128         const struct acpi_simple_repair_info *predefined;
 129
 130         ACPI_FUNCTION_NAME(ns_simple_repair);
 131
 132         /*
 133          * Special repairs for certain names that are in the repair table.
 134          * Check if this name is in the list of repairable names.
 135          */
 136         predefined = acpi_ns_match_simple_repair(info->node,
 137                                                  info->return_btype,
 138                                                  package_index);
 139         if (predefined) {
 140                 if (!return_object) {
 141                         ACPI_WARN_PREDEFINED((AE_INFO, info->full_pathname,
 142                                               ACPI_WARN_ALWAYS,
 143                                               "Missing expected return value"));
 144                 }
 145
 146                 status = predefined->object_converter(info->node, return_object,
 147                                                       &new_object);
 148                 if (ACPI_FAILURE(status)) {
 149
 150                         /* A fatal error occurred during a conversion */
 151
 152                         ACPI_EXCEPTION((AE_INFO, status,
 153                                         "During return object analysis"));
 154                         return (status);
 155                 }
 156                 if (new_object) {
 157                         goto object_repaired;
 158                 }
 159         }
 160
 161         /*
 162          * Do not perform simple object repair unless the return type is not
 163          * expected.
 164          */
 165         if (info->return_btype & expected_btypes) {
 166                 return (AE_OK);
 167         }
 168
 169         /*
 170          * At this point, we know that the type of the returned object was not
 171          * one of the expected types for this predefined name. Attempt to
 172          * repair the object by converting it to one of the expected object
 173          * types for this predefined name.
 174          */
 175
 176         /*
 177          * If there is no return value, check if we require a return value for
 178          * this predefined name. Either one return value is expected, or none,
 179          * for both methods and other objects.
 180          *
 181          * Try to fix if there was no return object. Warning if failed to fix.
 182          */
 183         if (!return_object) {
 184                 if (expected_btypes) {
 185                         if (!(expected_btypes & ACPI_RTYPE_NONE) &&
 186                             package_index != ACPI_NOT_PACKAGE_ELEMENT) {
 187                                 ACPI_WARN_PREDEFINED((AE_INFO,
 188                                                       info->full_pathname,
 189                                                       ACPI_WARN_ALWAYS,
 190                                                       "Found unexpected NULL package element"));
 191
 192                                 status =
 193                                     acpi_ns_repair_null_element(info,
 194                                                                 expected_btypes,
 195                                                                 package_index,
 196                                                                 return_object_ptr);
 197                                 if (ACPI_SUCCESS(status)) {
 198                                         return (AE_OK); /* Repair was successful */
 199                                 }
 200                         }
 201
 202                         if (expected_btypes != ACPI_RTYPE_NONE) {
 203                                 ACPI_WARN_PREDEFINED((AE_INFO,
 204                                                       info->full_pathname,
 205                                                       ACPI_WARN_ALWAYS,
 206                                                       "Missing expected return value"));
 207                                 return (AE_AML_NO_RETURN_VALUE);
 208                         }
 209                 }
 210         }
 211
 212         if (expected_btypes & ACPI_RTYPE_INTEGER) {
 213                 status = acpi_ns_convert_to_integer(return_object, &new_object);
 214                 if (ACPI_SUCCESS(status)) {
 215                         goto object_repaired;
 216                 }
 217         }
 218         if (expected_btypes & ACPI_RTYPE_STRING) {
 219                 status = acpi_ns_convert_to_string(return_object, &new_object);
 220                 if (ACPI_SUCCESS(status)) {
 221                         goto object_repaired;
 222                 }
 223         }
 224         if (expected_btypes & ACPI_RTYPE_BUFFER) {
 225                 status = acpi_ns_convert_to_buffer(return_object, &new_object);
 226                 if (ACPI_SUCCESS(status)) {
 227                         goto object_repaired;
 228                 }
 229         }
 230         if (expected_btypes & ACPI_RTYPE_PACKAGE) {
 231                 /*
 232                  * A package is expected. We will wrap the existing object with a
 233                  * new package object. It is often the case that if a variable-length
 234                  * package is required, but there is only a single object needed, the
 235                  * BIOS will return that object instead of wrapping it with a Package
 236                  * object. Note: after the wrapping, the package will be validated
 237                  * for correct contents (expected object type or types).
 238                  */
 239                 status =
 240                     acpi_ns_wrap_with_package(info, return_object, &new_object);
 241                 if (ACPI_SUCCESS(status)) {
 242                         /*
 243                          * The original object just had its reference count
 244                          * incremented for being inserted into the new package.
 245                          */
 246                         *return_object_ptr = new_object;        /* New Package object */
 247                         info->return_flags |= ACPI_OBJECT_REPAIRED;
 248                         return (AE_OK);
 249                 }
 250         }
 251
 252         /* We cannot repair this object */
 253
 254         return (AE_AML_OPERAND_TYPE);
 255
 256 object_repaired:
 257
 258         /* Object was successfully repaired */
 259
 260         if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {
 261
 262                 /* Update reference count of new object */
 263
 264                 if (!(info->return_flags & ACPI_OBJECT_WRAPPED)) {
 265                         new_object->common.reference_count =
 266                             return_object->common.reference_count;
 267                 }
 268
 269                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 270                                   "%s: Converted %s to expected %s at Package index %u\n",
 271                                   info->full_pathname,
 272                                   acpi_ut_get_object_type_name(return_object),
 273                                   acpi_ut_get_object_type_name(new_object),
 274                                   package_index));
 275         } else {
 276                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 277                                   "%s: Converted %s to expected %s\n",
 278                                   info->full_pathname,
 279                                   acpi_ut_get_object_type_name(return_object),
 280                                   acpi_ut_get_object_type_name(new_object)));
 281         }
 282
 283         /* Delete old object, install the new return object */
 284
 285         acpi_ut_remove_reference(return_object);
 286         *return_object_ptr = new_object;
 287         info->return_flags |= ACPI_OBJECT_REPAIRED;
 288         return (AE_OK);
 289 }
 290
 291 /******************************************************************************
 292  *
 293  * FUNCTION:    acpi_ns_match_simple_repair
 294  *
 295  * PARAMETERS:  node                - Namespace node for the method/object
 296  *              return_btype        - Object type that was returned
 297  *              package_index       - Index of object within parent package (if
 298  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 299  *                                    otherwise)
 300  *
 301  * RETURN:      Pointer to entry in repair table. NULL indicates not found.
 302  *
 303  * DESCRIPTION: Check an object name against the repairable object list.
 304  *
 305  *****************************************************************************/
 306
 307 static const struct acpi_simple_repair_info *acpi_ns_match_simple_repair(struct
 308                                                                          acpi_namespace_node
 309                                                                          *node,
 310                                                                          u32
 311                                                                          return_btype,
 312                                                                          u32
 313                                                                          package_index)
 314 {
 315         const struct acpi_simple_repair_info *this_name;
 316
 317         /* Search info table for a repairable predefined method/object name */
 318
 319         this_name = acpi_object_repair_info;
 320         while (this_name->object_converter) {
 321                 if (ACPI_COMPARE_NAMESEG(node->name.ascii, this_name->name)) {
 322
 323                         /* Check if we can actually repair this name/type combination */
 324
 325                         if ((return_btype & this_name->unexpected_btypes) &&
 326                             (this_name->package_index ==
 327                              ACPI_ALL_PACKAGE_ELEMENTS
 328                              || package_index == this_name->package_index)) {
 329                                 return (this_name);
 330                         }
 331
 332                         return (NULL);
 333                 }
 334
 335                 this_name++;
 336         }
 337
 338         return (NULL);          /* Name was not found in the repair table */
 339 }
 340
 341 /*******************************************************************************
 342  *
 343  * FUNCTION:    acpi_ns_repair_null_element
 344  *
 345  * PARAMETERS:  info                - Method execution information block
 346  *              expected_btypes     - Object types expected
 347  *              package_index       - Index of object within parent package (if
 348  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 349  *                                    otherwise)
 350  *              return_object_ptr   - Pointer to the object returned from the
 351  *                                    evaluation of a method or object
 352  *
 353  * RETURN:      Status. AE_OK if repair was successful.
 354  *
 355  * DESCRIPTION: Attempt to repair a NULL element of a returned Package object.
 356  *
 357  ******************************************************************************/
 358
 359 acpi_status
 360 acpi_ns_repair_null_element(struct acpi_evaluate_info *info,
 361                             u32 expected_btypes,
 362                             u32 package_index,
 363                             union acpi_operand_object **return_object_ptr)
 364 {
 365         union acpi_operand_object *return_object = *return_object_ptr;
 366         union acpi_operand_object *new_object;
 367
 368         ACPI_FUNCTION_NAME(ns_repair_null_element);
 369
 370         /* No repair needed if return object is non-NULL */
 371
 372         if (return_object) {
 373                 return (AE_OK);
 374         }
 375
 376         /*
 377          * Attempt to repair a NULL element of a Package object. This applies to
 378          * predefined names that return a fixed-length package and each element
 379          * is required. It does not apply to variable-length packages where NULL
 380          * elements are allowed, especially at the end of the package.
 381          */
 382         if (expected_btypes & ACPI_RTYPE_INTEGER) {
 383
 384                 /* Need an integer - create a zero-value integer */
 385
 386                 new_object = acpi_ut_create_integer_object((u64)0);
 387         } else if (expected_btypes & ACPI_RTYPE_STRING) {
 388
 389                 /* Need a string - create a NULL string */
 390
 391                 new_object = acpi_ut_create_string_object(0);
 392         } else if (expected_btypes & ACPI_RTYPE_BUFFER) {
 393
 394                 /* Need a buffer - create a zero-length buffer */
 395
 396                 new_object = acpi_ut_create_buffer_object(0);
 397         } else {
 398                 /* Error for all other expected types */
 399
 400                 return (AE_AML_OPERAND_TYPE);
 401         }
 402
 403         if (!new_object) {
 404                 return (AE_NO_MEMORY);
 405         }
 406
 407         /* Set the reference count according to the parent Package object */
 408
 409         new_object->common.reference_count =
 410             info->parent_package->common.reference_count;
 411
 412         ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 413                           "%s: Converted NULL package element to expected %s at index %u\n",
 414                           info->full_pathname,
 415                           acpi_ut_get_object_type_name(new_object),
 416                           package_index));
 417
 418         *return_object_ptr = new_object;
 419         info->return_flags |= ACPI_OBJECT_REPAIRED;
 420         return (AE_OK);
 421 }
 422
 423 /******************************************************************************
 424  *
 425  * FUNCTION:    acpi_ns_remove_null_elements
 426  *
 427  * PARAMETERS:  info                - Method execution information block
 428  *              package_type        - An acpi_return_package_types value
 429  *              obj_desc            - A Package object
 430  *
 431  * RETURN:      None.
 432  *
 433  * DESCRIPTION: Remove all NULL package elements from packages that contain
 434  *              a variable number of subpackages. For these types of
 435  *              packages, NULL elements can be safely removed.
 436  *
 437  *****************************************************************************/
 438
 439 void
 440 acpi_ns_remove_null_elements(struct acpi_evaluate_info *info,
 441                              u8 package_type,
 442                              union acpi_operand_object *obj_desc)
 443 {
 444         union acpi_operand_object **source;
 445         union acpi_operand_object **dest;
 446         u32 count;
 447         u32 new_count;
 448         u32 i;
 449
 450         ACPI_FUNCTION_NAME(ns_remove_null_elements);
 451
 452         /*
 453          * We can safely remove all NULL elements from these package types:
 454          * PTYPE1_VAR packages contain a variable number of simple data types.
 455          * PTYPE2 packages contain a variable number of subpackages.
 456          */
 457         switch (package_type) {
 458         case ACPI_PTYPE1_VAR:
 459         case ACPI_PTYPE2:
 460         case ACPI_PTYPE2_COUNT:
 461         case ACPI_PTYPE2_PKG_COUNT:
 462         case ACPI_PTYPE2_FIXED:
 463         case ACPI_PTYPE2_MIN:
 464         case ACPI_PTYPE2_REV_FIXED:
 465         case ACPI_PTYPE2_FIX_VAR:
 466                 break;
 467
 468         default:
 469         case ACPI_PTYPE2_VAR_VAR:
 470         case ACPI_PTYPE1_FIXED:
 471         case ACPI_PTYPE1_OPTION:
 472                 return;
 473         }
 474
 475         count = obj_desc->package.count;
 476         new_count = count;
 477
 478         source = obj_desc->package.elements;
 479         dest = source;
 480
 481         /* Examine all elements of the package object, remove nulls */
 482
 483         for (i = 0; i < count; i++) {
 484                 if (!*source) {
 485                         new_count--;
 486                 } else {
 487                         *dest = *source;
 488                         dest++;
 489                 }
 490
 491                 source++;
 492         }
 493
 494         /* Update parent package if any null elements were removed */
 495
 496         if (new_count < count) {
 497                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 498                                   "%s: Found and removed %u NULL elements\n",
 499                                   info->full_pathname, (count - new_count)));
 500
 501                 /* NULL terminate list and update the package count */
 502
 503                 *dest = NULL;
 504                 obj_desc->package.count = new_count;
 505         }
 506 }
 507
 508 /*******************************************************************************
 509  *
 510  * FUNCTION:    acpi_ns_wrap_with_package
 511  *
 512  * PARAMETERS:  info                - Method execution information block
 513  *              original_object     - Pointer to the object to repair.
 514  *              obj_desc_ptr        - The new package object is returned here
 515  *
 516  * RETURN:      Status, new object in *obj_desc_ptr
 517  *
 518  * DESCRIPTION: Repair a common problem with objects that are defined to
 519  *              return a variable-length Package of sub-objects. If there is
 520  *              only one sub-object, some BIOS code mistakenly simply declares
 521  *              the single object instead of a Package with one sub-object.
 522  *              This function attempts to repair this error by wrapping a
 523  *              Package object around the original object, creating the
 524  *              correct and expected Package with one sub-object.
 525  *
 526  *              Names that can be repaired in this manner include:
 527  *              _ALR, _CSD, _HPX, _MLS, _PLD, _PRT, _PSS, _TRT, _TSS,
 528  *              _BCL, _DOD, _FIX, _Sx
 529  *
 530  ******************************************************************************/
 531
 532 acpi_status
 533 acpi_ns_wrap_with_package(struct acpi_evaluate_info *info,
 534                           union acpi_operand_object *original_object,
 535                           union acpi_operand_object **obj_desc_ptr)
 536 {
 537         union acpi_operand_object *pkg_obj_desc;
 538
 539         ACPI_FUNCTION_NAME(ns_wrap_with_package);
 540
 541         /*
 542          * Create the new outer package and populate it. The new
 543          * package will have a single element, the lone sub-object.
 544          */
 545         pkg_obj_desc = acpi_ut_create_package_object(1);
 546         if (!pkg_obj_desc) {
 547                 return (AE_NO_MEMORY);
 548         }
 549
 550         pkg_obj_desc->package.elements[0] = original_object;
 551
 552         ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 553                           "%s: Wrapped %s with expected Package object\n",
 554                           info->full_pathname,
 555                           acpi_ut_get_object_type_name(original_object)));
 556
 557         /* Return the new object in the object pointer */
 558
 559         *obj_desc_ptr = pkg_obj_desc;
 560         info->return_flags |= ACPI_OBJECT_REPAIRED | ACPI_OBJECT_WRAPPED;
 561         return (AE_OK);
 562 }