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 - 2019, 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 && (!(expected_btypes & ACPI_RTYPE_NONE))) {
 185                         if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {
 186                                 ACPI_WARN_PREDEFINED((AE_INFO,
 187                                                       info->full_pathname,
 188                                                       ACPI_WARN_ALWAYS,
 189                                                       "Found unexpected NULL package element"));
 190
 191                                 status =
 192                                     acpi_ns_repair_null_element(info,
 193                                                                 expected_btypes,
 194                                                                 package_index,
 195                                                                 return_object_ptr);
 196                                 if (ACPI_SUCCESS(status)) {
 197                                         return (AE_OK); /* Repair was successful */
 198                                 }
 199                         } else {
 200                                 ACPI_WARN_PREDEFINED((AE_INFO,
 201                                                       info->full_pathname,
 202                                                       ACPI_WARN_ALWAYS,
 203                                                       "Missing expected return value"));
 204                         }
 205
 206                         return (AE_AML_NO_RETURN_VALUE);
 207                 }
 208         }
 209
 210         if (expected_btypes & ACPI_RTYPE_INTEGER) {
 211                 status = acpi_ns_convert_to_integer(return_object, &new_object);
 212                 if (ACPI_SUCCESS(status)) {
 213                         goto object_repaired;
 214                 }
 215         }
 216         if (expected_btypes & ACPI_RTYPE_STRING) {
 217                 status = acpi_ns_convert_to_string(return_object, &new_object);
 218                 if (ACPI_SUCCESS(status)) {
 219                         goto object_repaired;
 220                 }
 221         }
 222         if (expected_btypes & ACPI_RTYPE_BUFFER) {
 223                 status = acpi_ns_convert_to_buffer(return_object, &new_object);
 224                 if (ACPI_SUCCESS(status)) {
 225                         goto object_repaired;
 226                 }
 227         }
 228         if (expected_btypes & ACPI_RTYPE_PACKAGE) {
 229                 /*
 230                  * A package is expected. We will wrap the existing object with a
 231                  * new package object. It is often the case that if a variable-length
 232                  * package is required, but there is only a single object needed, the
 233                  * BIOS will return that object instead of wrapping it with a Package
 234                  * object. Note: after the wrapping, the package will be validated
 235                  * for correct contents (expected object type or types).
 236                  */
 237                 status =
 238                     acpi_ns_wrap_with_package(info, return_object, &new_object);
 239                 if (ACPI_SUCCESS(status)) {
 240                         /*
 241                          * The original object just had its reference count
 242                          * incremented for being inserted into the new package.
 243                          */
 244                         *return_object_ptr = new_object;        /* New Package object */
 245                         info->return_flags |= ACPI_OBJECT_REPAIRED;
 246                         return (AE_OK);
 247                 }
 248         }
 249
 250         /* We cannot repair this object */
 251
 252         return (AE_AML_OPERAND_TYPE);
 253
 254 object_repaired:
 255
 256         /* Object was successfully repaired */
 257
 258         if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {
 259
 260                 /* Update reference count of new object */
 261
 262                 if (!(info->return_flags & ACPI_OBJECT_WRAPPED)) {
 263                         new_object->common.reference_count =
 264                             return_object->common.reference_count;
 265                 }
 266
 267                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 268                                   "%s: Converted %s to expected %s at Package index %u\n",
 269                                   info->full_pathname,
 270                                   acpi_ut_get_object_type_name(return_object),
 271                                   acpi_ut_get_object_type_name(new_object),
 272                                   package_index));
 273         } else {
 274                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 275                                   "%s: Converted %s to expected %s\n",
 276                                   info->full_pathname,
 277                                   acpi_ut_get_object_type_name(return_object),
 278                                   acpi_ut_get_object_type_name(new_object)));
 279         }
 280
 281         /* Delete old object, install the new return object */
 282
 283         acpi_ut_remove_reference(return_object);
 284         *return_object_ptr = new_object;
 285         info->return_flags |= ACPI_OBJECT_REPAIRED;
 286         return (AE_OK);
 287 }
 288
 289 /******************************************************************************
 290  *
 291  * FUNCTION:    acpi_ns_match_simple_repair
 292  *
 293  * PARAMETERS:  node                - Namespace node for the method/object
 294  *              return_btype        - Object type that was returned
 295  *              package_index       - Index of object within parent package (if
 296  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 297  *                                    otherwise)
 298  *
 299  * RETURN:      Pointer to entry in repair table. NULL indicates not found.
 300  *
 301  * DESCRIPTION: Check an object name against the repairable object list.
 302  *
 303  *****************************************************************************/
 304
 305 static const struct acpi_simple_repair_info *acpi_ns_match_simple_repair(struct
 306                                                                          acpi_namespace_node
 307                                                                          *node,
 308                                                                          u32
 309                                                                          return_btype,
 310                                                                          u32
 311                                                                          package_index)
 312 {
 313         const struct acpi_simple_repair_info *this_name;
 314
 315         /* Search info table for a repairable predefined method/object name */
 316
 317         this_name = acpi_object_repair_info;
 318         while (this_name->object_converter) {
 319                 if (ACPI_COMPARE_NAME(node->name.ascii, this_name->name)) {
 320
 321                         /* Check if we can actually repair this name/type combination */
 322
 323                         if ((return_btype & this_name->unexpected_btypes) &&
 324                             (this_name->package_index ==
 325                              ACPI_ALL_PACKAGE_ELEMENTS
 326                              || package_index == this_name->package_index)) {
 327                                 return (this_name);
 328                         }
 329
 330                         return (NULL);
 331                 }
 332
 333                 this_name++;
 334         }
 335
 336         return (NULL);          /* Name was not found in the repair table */
 337 }
 338
 339 /*******************************************************************************
 340  *
 341  * FUNCTION:    acpi_ns_repair_null_element
 342  *
 343  * PARAMETERS:  info                - Method execution information block
 344  *              expected_btypes     - Object types expected
 345  *              package_index       - Index of object within parent package (if
 346  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 347  *                                    otherwise)
 348  *              return_object_ptr   - Pointer to the object returned from the
 349  *                                    evaluation of a method or object
 350  *
 351  * RETURN:      Status. AE_OK if repair was successful.
 352  *
 353  * DESCRIPTION: Attempt to repair a NULL element of a returned Package object.
 354  *
 355  ******************************************************************************/
 356
 357 acpi_status
 358 acpi_ns_repair_null_element(struct acpi_evaluate_info *info,
 359                             u32 expected_btypes,
 360                             u32 package_index,
 361                             union acpi_operand_object **return_object_ptr)
 362 {
 363         union acpi_operand_object *return_object = *return_object_ptr;
 364         union acpi_operand_object *new_object;
 365
 366         ACPI_FUNCTION_NAME(ns_repair_null_element);
 367
 368         /* No repair needed if return object is non-NULL */
 369
 370         if (return_object) {
 371                 return (AE_OK);
 372         }
 373
 374         /*
 375          * Attempt to repair a NULL element of a Package object. This applies to
 376          * predefined names that return a fixed-length package and each element
 377          * is required. It does not apply to variable-length packages where NULL
 378          * elements are allowed, especially at the end of the package.
 379          */
 380         if (expected_btypes & ACPI_RTYPE_INTEGER) {
 381
 382                 /* Need an integer - create a zero-value integer */
 383
 384                 new_object = acpi_ut_create_integer_object((u64)0);
 385         } else if (expected_btypes & ACPI_RTYPE_STRING) {
 386
 387                 /* Need a string - create a NULL string */
 388
 389                 new_object = acpi_ut_create_string_object(0);
 390         } else if (expected_btypes & ACPI_RTYPE_BUFFER) {
 391
 392                 /* Need a buffer - create a zero-length buffer */
 393
 394                 new_object = acpi_ut_create_buffer_object(0);
 395         } else {
 396                 /* Error for all other expected types */
 397
 398                 return (AE_AML_OPERAND_TYPE);
 399         }
 400
 401         if (!new_object) {
 402                 return (AE_NO_MEMORY);
 403         }
 404
 405         /* Set the reference count according to the parent Package object */
 406
 407         new_object->common.reference_count =
 408             info->parent_package->common.reference_count;
 409
 410         ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 411                           "%s: Converted NULL package element to expected %s at index %u\n",
 412                           info->full_pathname,
 413                           acpi_ut_get_object_type_name(new_object),
 414                           package_index));
 415
 416         *return_object_ptr = new_object;
 417         info->return_flags |= ACPI_OBJECT_REPAIRED;
 418         return (AE_OK);
 419 }
 420
 421 /******************************************************************************
 422  *
 423  * FUNCTION:    acpi_ns_remove_null_elements
 424  *
 425  * PARAMETERS:  info                - Method execution information block
 426  *              package_type        - An acpi_return_package_types value
 427  *              obj_desc            - A Package object
 428  *
 429  * RETURN:      None.
 430  *
 431  * DESCRIPTION: Remove all NULL package elements from packages that contain
 432  *              a variable number of subpackages. For these types of
 433  *              packages, NULL elements can be safely removed.
 434  *
 435  *****************************************************************************/
 436
 437 void
 438 acpi_ns_remove_null_elements(struct acpi_evaluate_info *info,
 439                              u8 package_type,
 440                              union acpi_operand_object *obj_desc)
 441 {
 442         union acpi_operand_object **source;
 443         union acpi_operand_object **dest;
 444         u32 count;
 445         u32 new_count;
 446         u32 i;
 447
 448         ACPI_FUNCTION_NAME(ns_remove_null_elements);
 449
 450         /*
 451          * We can safely remove all NULL elements from these package types:
 452          * PTYPE1_VAR packages contain a variable number of simple data types.
 453          * PTYPE2 packages contain a variable number of subpackages.
 454          */
 455         switch (package_type) {
 456         case ACPI_PTYPE1_VAR:
 457         case ACPI_PTYPE2:
 458         case ACPI_PTYPE2_COUNT:
 459         case ACPI_PTYPE2_PKG_COUNT:
 460         case ACPI_PTYPE2_FIXED:
 461         case ACPI_PTYPE2_MIN:
 462         case ACPI_PTYPE2_REV_FIXED:
 463         case ACPI_PTYPE2_FIX_VAR:
 464                 break;
 465
 466         default:
 467         case ACPI_PTYPE2_VAR_VAR:
 468         case ACPI_PTYPE1_FIXED:
 469         case ACPI_PTYPE1_OPTION:
 470                 return;
 471         }
 472
 473         count = obj_desc->package.count;
 474         new_count = count;
 475
 476         source = obj_desc->package.elements;
 477         dest = source;
 478
 479         /* Examine all elements of the package object, remove nulls */
 480
 481         for (i = 0; i < count; i++) {
 482                 if (!*source) {
 483                         new_count--;
 484                 } else {
 485                         *dest = *source;
 486                         dest++;
 487                 }
 488
 489                 source++;
 490         }
 491
 492         /* Update parent package if any null elements were removed */
 493
 494         if (new_count < count) {
 495                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 496                                   "%s: Found and removed %u NULL elements\n",
 497                                   info->full_pathname, (count - new_count)));
 498
 499                 /* NULL terminate list and update the package count */
 500
 501                 *dest = NULL;
 502                 obj_desc->package.count = new_count;
 503         }
 504 }
 505
 506 /*******************************************************************************
 507  *
 508  * FUNCTION:    acpi_ns_wrap_with_package
 509  *
 510  * PARAMETERS:  info                - Method execution information block
 511  *              original_object     - Pointer to the object to repair.
 512  *              obj_desc_ptr        - The new package object is returned here
 513  *
 514  * RETURN:      Status, new object in *obj_desc_ptr
 515  *
 516  * DESCRIPTION: Repair a common problem with objects that are defined to
 517  *              return a variable-length Package of sub-objects. If there is
 518  *              only one sub-object, some BIOS code mistakenly simply declares
 519  *              the single object instead of a Package with one sub-object.
 520  *              This function attempts to repair this error by wrapping a
 521  *              Package object around the original object, creating the
 522  *              correct and expected Package with one sub-object.
 523  *
 524  *              Names that can be repaired in this manner include:
 525  *              _ALR, _CSD, _HPX, _MLS, _PLD, _PRT, _PSS, _TRT, _TSS,
 526  *              _BCL, _DOD, _FIX, _Sx
 527  *
 528  ******************************************************************************/
 529
 530 acpi_status
 531 acpi_ns_wrap_with_package(struct acpi_evaluate_info *info,
 532                           union acpi_operand_object *original_object,
 533                           union acpi_operand_object **obj_desc_ptr)
 534 {
 535         union acpi_operand_object *pkg_obj_desc;
 536
 537         ACPI_FUNCTION_NAME(ns_wrap_with_package);
 538
 539         /*
 540          * Create the new outer package and populate it. The new
 541          * package will have a single element, the lone sub-object.
 542          */
 543         pkg_obj_desc = acpi_ut_create_package_object(1);
 544         if (!pkg_obj_desc) {
 545                 return (AE_NO_MEMORY);
 546         }
 547
 548         pkg_obj_desc->package.elements[0] = original_object;
 549
 550         ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
 551                           "%s: Wrapped %s with expected Package object\n",
 552                           info->full_pathname,
 553                           acpi_ut_get_object_type_name(original_object)));
 554
 555         /* Return the new object in the object pointer */
 556
 557         *obj_desc_ptr = pkg_obj_desc;
 558         info->return_flags |= ACPI_OBJECT_REPAIRED | ACPI_OBJECT_WRAPPED;
 559         return (AE_OK);
 560 }