drivers/bus/acpi/acpica/namespace/nsrepair.c

   1 /******************************************************************************
   2  *
   3  * Module Name: nsrepair - Repair for objects returned by predefined methods
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2019, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include "acpi.h"
  45 #include "accommon.h"
  46 #include "acnamesp.h"
  47 #include "acinterp.h"
  48 #include "acpredef.h"
  49 #include "amlresrc.h"
  50
  51 #define _COMPONENT          ACPI_NAMESPACE
  52         ACPI_MODULE_NAME    ("nsrepair")
  53
  54
  55 /*******************************************************************************
  56  *
  57  * This module attempts to repair or convert objects returned by the
  58  * predefined methods to an object type that is expected, as per the ACPI
  59  * specification. The need for this code is dictated by the many machines that
  60  * return incorrect types for the standard predefined methods. Performing these
  61  * conversions here, in one place, eliminates the need for individual ACPI
  62  * device drivers to do the same. Note: Most of these conversions are different
  63  * than the internal object conversion routines used for implicit object
  64  * conversion.
  65  *
  66  * The following conversions can be performed as necessary:
  67  *
  68  * Integer -> String
  69  * Integer -> Buffer
  70  * String  -> Integer
  71  * String  -> Buffer
  72  * Buffer  -> Integer
  73  * Buffer  -> String
  74  * Buffer  -> Package of Integers
  75  * Package -> Package of one Package
  76  *
  77  * Additional conversions that are available:
  78  *  Convert a null return or zero return value to an EndTag descriptor
  79  *  Convert an ASCII string to a Unicode buffer
  80  *
  81  * An incorrect standalone object is wrapped with required outer package
  82  *
  83  * Additional possible repairs:
  84  * Required package elements that are NULL replaced by Integer/String/Buffer
  85  *
  86  ******************************************************************************/
  87
  88
  89 /* Local prototypes */
  90
  91 static const ACPI_SIMPLE_REPAIR_INFO *
  92 AcpiNsMatchSimpleRepair (
  93     ACPI_NAMESPACE_NODE     *Node,
  94     UINT32                  ReturnBtype,
  95     UINT32                  PackageIndex);
  96
  97
  98 /*
  99  * Special but simple repairs for some names.
 100  *
 101  * 2nd argument: Unexpected types that can be repaired
 102  */
 103 static const ACPI_SIMPLE_REPAIR_INFO    AcpiObjectRepairInfo[] =
 104 {
 105     /* Resource descriptor conversions */
 106
 107     { "_CRS", ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE,
 108                 ACPI_NOT_PACKAGE_ELEMENT,
 109                 AcpiNsConvertToResource },
 110     { "_DMA", ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE,
 111                 ACPI_NOT_PACKAGE_ELEMENT,
 112                 AcpiNsConvertToResource },
 113     { "_PRS", ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE,
 114                 ACPI_NOT_PACKAGE_ELEMENT,
 115                 AcpiNsConvertToResource },
 116
 117     /* Object reference conversions */
 118
 119     { "_DEP", ACPI_RTYPE_STRING, ACPI_ALL_PACKAGE_ELEMENTS,
 120                 AcpiNsConvertToReference },
 121
 122     /* Unicode conversions */
 123
 124     { "_MLS", ACPI_RTYPE_STRING, 1,
 125                 AcpiNsConvertToUnicode },
 126     { "_STR", ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER,
 127                 ACPI_NOT_PACKAGE_ELEMENT,
 128                 AcpiNsConvertToUnicode },
 129     { {0,0,0,0}, 0, 0, NULL } /* Table terminator */
 130 };
 131
 132
 133 /*******************************************************************************
 134  *
 135  * FUNCTION:    AcpiNsSimpleRepair
 136  *
 137  * PARAMETERS:  Info                - Method execution information block
 138  *              ExpectedBtypes      - Object types expected
 139  *              PackageIndex        - Index of object within parent package (if
 140  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 141  *                                    otherwise)
 142  *              ReturnObjectPtr     - Pointer to the object returned from the
 143  *                                    evaluation of a method or object
 144  *
 145  * RETURN:      Status. AE_OK if repair was successful.
 146  *
 147  * DESCRIPTION: Attempt to repair/convert a return object of a type that was
 148  *              not expected.
 149  *
 150  ******************************************************************************/
 151
 152 ACPI_STATUS
 153 AcpiNsSimpleRepair (
 154     ACPI_EVALUATE_INFO      *Info,
 155     UINT32                  ExpectedBtypes,
 156     UINT32                  PackageIndex,
 157     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 158 {
 159     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 160     ACPI_OPERAND_OBJECT     *NewObject = NULL;
 161     ACPI_STATUS             Status;
 162     const ACPI_SIMPLE_REPAIR_INFO   *Predefined;
 163
 164
 165     ACPI_FUNCTION_NAME (NsSimpleRepair);
 166
 167
 168     /*
 169      * Special repairs for certain names that are in the repair table.
 170      * Check if this name is in the list of repairable names.
 171      */
 172     Predefined = AcpiNsMatchSimpleRepair (Info->Node,
 173         Info->ReturnBtype, PackageIndex);
 174     if (Predefined)
 175     {
 176         if (!ReturnObject)
 177         {
 178             ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
 179                 ACPI_WARN_ALWAYS, "Missing expected return value"));
 180         }
 181
 182         Status = Predefined->ObjectConverter (Info->Node, ReturnObject,
 183             &NewObject);
 184         if (ACPI_FAILURE (Status))
 185         {
 186             /* A fatal error occurred during a conversion */
 187
 188             ACPI_EXCEPTION ((AE_INFO, Status,
 189                 "During return object analysis"));
 190             return (Status);
 191         }
 192         if (NewObject)
 193         {
 194             goto ObjectRepaired;
 195         }
 196     }
 197
 198     /*
 199      * Do not perform simple object repair unless the return type is not
 200      * expected.
 201      */
 202     if (Info->ReturnBtype & ExpectedBtypes)
 203     {
 204         return (AE_OK);
 205     }
 206
 207     /*
 208      * At this point, we know that the type of the returned object was not
 209      * one of the expected types for this predefined name. Attempt to
 210      * repair the object by converting it to one of the expected object
 211      * types for this predefined name.
 212      */
 213
 214     /*
 215      * If there is no return value, check if we require a return value for
 216      * this predefined name. Either one return value is expected, or none,
 217      * for both methods and other objects.
 218      *
 219      * Try to fix if there was no return object. Warning if failed to fix.
 220      */
 221     if (!ReturnObject)
 222     {
 223         if (ExpectedBtypes && (!(ExpectedBtypes & ACPI_RTYPE_NONE)))
 224         {
 225             if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
 226             {
 227                 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
 228                     ACPI_WARN_ALWAYS, "Found unexpected NULL package element"));
 229
 230                 Status = AcpiNsRepairNullElement (Info, ExpectedBtypes,
 231                     PackageIndex, ReturnObjectPtr);
 232                 if (ACPI_SUCCESS (Status))
 233                 {
 234                     return (AE_OK); /* Repair was successful */
 235                 }
 236             }
 237             else
 238             {
 239                 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
 240                     ACPI_WARN_ALWAYS, "Missing expected return value"));
 241             }
 242
 243             return (AE_AML_NO_RETURN_VALUE);
 244         }
 245     }
 246
 247     if (ExpectedBtypes & ACPI_RTYPE_INTEGER)
 248     {
 249         Status = AcpiNsConvertToInteger (ReturnObject, &NewObject);
 250         if (ACPI_SUCCESS (Status))
 251         {
 252             goto ObjectRepaired;
 253         }
 254     }
 255     if (ExpectedBtypes & ACPI_RTYPE_STRING)
 256     {
 257         Status = AcpiNsConvertToString (ReturnObject, &NewObject);
 258         if (ACPI_SUCCESS (Status))
 259         {
 260             goto ObjectRepaired;
 261         }
 262     }
 263     if (ExpectedBtypes & ACPI_RTYPE_BUFFER)
 264     {
 265         Status = AcpiNsConvertToBuffer (ReturnObject, &NewObject);
 266         if (ACPI_SUCCESS (Status))
 267         {
 268             goto ObjectRepaired;
 269         }
 270     }
 271     if (ExpectedBtypes & ACPI_RTYPE_PACKAGE)
 272     {
 273         /*
 274          * A package is expected. We will wrap the existing object with a
 275          * new package object. It is often the case that if a variable-length
 276          * package is required, but there is only a single object needed, the
 277          * BIOS will return that object instead of wrapping it with a Package
 278          * object. Note: after the wrapping, the package will be validated
 279          * for correct contents (expected object type or types).
 280          */
 281         Status = AcpiNsWrapWithPackage (Info, ReturnObject, &NewObject);
 282         if (ACPI_SUCCESS (Status))
 283         {
 284             /*
 285              * The original object just had its reference count
 286              * incremented for being inserted into the new package.
 287              */
 288             *ReturnObjectPtr = NewObject;       /* New Package object */
 289             Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 290             return (AE_OK);
 291         }
 292     }
 293
 294     /* We cannot repair this object */
 295
 296     return (AE_AML_OPERAND_TYPE);
 297
 298
 299 ObjectRepaired:
 300
 301     /* Object was successfully repaired */
 302
 303     if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
 304     {
 305         /* Update reference count of new object */
 306
 307         if (!(Info->ReturnFlags & ACPI_OBJECT_WRAPPED))
 308         {
 309             NewObject->Common.ReferenceCount =
 310                 ReturnObject->Common.ReferenceCount;
 311         }
 312
 313         ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 314             "%s: Converted %s to expected %s at Package index %u\n",
 315             Info->FullPathname, AcpiUtGetObjectTypeName (ReturnObject),
 316             AcpiUtGetObjectTypeName (NewObject), PackageIndex));
 317     }
 318     else
 319     {
 320         ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 321             "%s: Converted %s to expected %s\n",
 322             Info->FullPathname, AcpiUtGetObjectTypeName (ReturnObject),
 323             AcpiUtGetObjectTypeName (NewObject)));
 324     }
 325
 326     /* Delete old object, install the new return object */
 327
 328     AcpiUtRemoveReference (ReturnObject);
 329     *ReturnObjectPtr = NewObject;
 330     Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 331     return (AE_OK);
 332 }
 333
 334
 335 /******************************************************************************
 336  *
 337  * FUNCTION:    AcpiNsMatchSimpleRepair
 338  *
 339  * PARAMETERS:  Node                - Namespace node for the method/object
 340  *              ReturnBtype         - Object type that was returned
 341  *              PackageIndex        - Index of object within parent package (if
 342  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 343  *                                    otherwise)
 344  *
 345  * RETURN:      Pointer to entry in repair table. NULL indicates not found.
 346  *
 347  * DESCRIPTION: Check an object name against the repairable object list.
 348  *
 349  *****************************************************************************/
 350
 351 static const ACPI_SIMPLE_REPAIR_INFO *
 352 AcpiNsMatchSimpleRepair (
 353     ACPI_NAMESPACE_NODE     *Node,
 354     UINT32                  ReturnBtype,
 355     UINT32                  PackageIndex)
 356 {
 357     const ACPI_SIMPLE_REPAIR_INFO   *ThisName;
 358
 359
 360     /* Search info table for a repairable predefined method/object name */
 361
 362     ThisName = AcpiObjectRepairInfo;
 363     while (ThisName->ObjectConverter)
 364     {
 365         if (ACPI_COMPARE_NAMESEG (Node->Name.Ascii, ThisName->Name))
 366         {
 367             /* Check if we can actually repair this name/type combination */
 368
 369             if ((ReturnBtype & ThisName->UnexpectedBtypes) &&
 370                 (ThisName->PackageIndex == ACPI_ALL_PACKAGE_ELEMENTS ||
 371                  PackageIndex == ThisName->PackageIndex))
 372             {
 373                 return (ThisName);
 374             }
 375
 376             return (NULL);
 377         }
 378
 379         ThisName++;
 380     }
 381
 382     return (NULL); /* Name was not found in the repair table */
 383 }
 384
 385
 386 /*******************************************************************************
 387  *
 388  * FUNCTION:    AcpiNsRepairNullElement
 389  *
 390  * PARAMETERS:  Info                - Method execution information block
 391  *              ExpectedBtypes      - Object types expected
 392  *              PackageIndex        - Index of object within parent package (if
 393  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 394  *                                    otherwise)
 395  *              ReturnObjectPtr     - Pointer to the object returned from the
 396  *                                    evaluation of a method or object
 397  *
 398  * RETURN:      Status. AE_OK if repair was successful.
 399  *
 400  * DESCRIPTION: Attempt to repair a NULL element of a returned Package object.
 401  *
 402  ******************************************************************************/
 403
 404 ACPI_STATUS
 405 AcpiNsRepairNullElement (
 406     ACPI_EVALUATE_INFO      *Info,
 407     UINT32                  ExpectedBtypes,
 408     UINT32                  PackageIndex,
 409     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 410 {
 411     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 412     ACPI_OPERAND_OBJECT     *NewObject;
 413
 414
 415     ACPI_FUNCTION_NAME (NsRepairNullElement);
 416
 417
 418     /* No repair needed if return object is non-NULL */
 419
 420     if (ReturnObject)
 421     {
 422         return (AE_OK);
 423     }
 424
 425     /*
 426      * Attempt to repair a NULL element of a Package object. This applies to
 427      * predefined names that return a fixed-length package and each element
 428      * is required. It does not apply to variable-length packages where NULL
 429      * elements are allowed, especially at the end of the package.
 430      */
 431     if (ExpectedBtypes & ACPI_RTYPE_INTEGER)
 432     {
 433         /* Need an Integer - create a zero-value integer */
 434
 435         NewObject = AcpiUtCreateIntegerObject ((UINT64) 0);
 436     }
 437     else if (ExpectedBtypes & ACPI_RTYPE_STRING)
 438     {
 439         /* Need a String - create a NULL string */
 440
 441         NewObject = AcpiUtCreateStringObject (0);
 442     }
 443     else if (ExpectedBtypes & ACPI_RTYPE_BUFFER)
 444     {
 445         /* Need a Buffer - create a zero-length buffer */
 446
 447         NewObject = AcpiUtCreateBufferObject (0);
 448     }
 449     else
 450     {
 451         /* Error for all other expected types */
 452
 453         return (AE_AML_OPERAND_TYPE);
 454     }
 455
 456     if (!NewObject)
 457     {
 458         return (AE_NO_MEMORY);
 459     }
 460
 461     /* Set the reference count according to the parent Package object */
 462
 463     NewObject->Common.ReferenceCount =
 464         Info->ParentPackage->Common.ReferenceCount;
 465
 466     ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 467         "%s: Converted NULL package element to expected %s at index %u\n",
 468         Info->FullPathname, AcpiUtGetObjectTypeName (NewObject),
 469         PackageIndex));
 470
 471     *ReturnObjectPtr = NewObject;
 472     Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 473     return (AE_OK);
 474 }
 475
 476
 477 /******************************************************************************
 478  *
 479  * FUNCTION:    AcpiNsRemoveNullElements
 480  *
 481  * PARAMETERS:  Info                - Method execution information block
 482  *              PackageType         - An AcpiReturnPackageTypes value
 483  *              ObjDesc             - A Package object
 484  *
 485  * RETURN:      None.
 486  *
 487  * DESCRIPTION: Remove all NULL package elements from packages that contain
 488  *              a variable number of subpackages. For these types of
 489  *              packages, NULL elements can be safely removed.
 490  *
 491  *****************************************************************************/
 492
 493 void
 494 AcpiNsRemoveNullElements (
 495     ACPI_EVALUATE_INFO      *Info,
 496     UINT8                   PackageType,
 497     ACPI_OPERAND_OBJECT     *ObjDesc)
 498 {
 499     ACPI_OPERAND_OBJECT     **Source;
 500     ACPI_OPERAND_OBJECT     **Dest;
 501     UINT32                  Count;
 502     UINT32                  NewCount;
 503     UINT32                  i;
 504
 505
 506     ACPI_FUNCTION_NAME (NsRemoveNullElements);
 507
 508
 509     /*
 510      * We can safely remove all NULL elements from these package types:
 511      * PTYPE1_VAR packages contain a variable number of simple data types.
 512      * PTYPE2 packages contain a variable number of subpackages.
 513      */
 514     switch (PackageType)
 515     {
 516     case ACPI_PTYPE1_VAR:
 517     case ACPI_PTYPE2:
 518     case ACPI_PTYPE2_COUNT:
 519     case ACPI_PTYPE2_PKG_COUNT:
 520     case ACPI_PTYPE2_FIXED:
 521     case ACPI_PTYPE2_MIN:
 522     case ACPI_PTYPE2_REV_FIXED:
 523     case ACPI_PTYPE2_FIX_VAR:
 524         break;
 525
 526     default:
 527     case ACPI_PTYPE2_VAR_VAR:
 528     case ACPI_PTYPE1_FIXED:
 529     case ACPI_PTYPE1_OPTION:
 530         return;
 531     }
 532
 533     Count = ObjDesc->Package.Count;
 534     NewCount = Count;
 535
 536     Source = ObjDesc->Package.Elements;
 537     Dest = Source;
 538
 539     /* Examine all elements of the package object, remove nulls */
 540
 541     for (i = 0; i < Count; i++)
 542     {
 543         if (!*Source)
 544         {
 545             NewCount--;
 546         }
 547         else
 548         {
 549             *Dest = *Source;
 550             Dest++;
 551         }
 552
 553         Source++;
 554     }
 555
 556     /* Update parent package if any null elements were removed */
 557
 558     if (NewCount < Count)
 559     {
 560         ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 561             "%s: Found and removed %u NULL elements\n",
 562             Info->FullPathname, (Count - NewCount)));
 563
 564         /* NULL terminate list and update the package count */
 565
 566         *Dest = NULL;
 567         ObjDesc->Package.Count = NewCount;
 568     }
 569 }
 570
 571
 572 /*******************************************************************************
 573  *
 574  * FUNCTION:    AcpiNsWrapWithPackage
 575  *
 576  * PARAMETERS:  Info                - Method execution information block
 577  *              OriginalObject      - Pointer to the object to repair.
 578  *              ObjDescPtr          - The new package object is returned here
 579  *
 580  * RETURN:      Status, new object in *ObjDescPtr
 581  *
 582  * DESCRIPTION: Repair a common problem with objects that are defined to
 583  *              return a variable-length Package of sub-objects. If there is
 584  *              only one sub-object, some BIOS code mistakenly simply declares
 585  *              the single object instead of a Package with one sub-object.
 586  *              This function attempts to repair this error by wrapping a
 587  *              Package object around the original object, creating the
 588  *              correct and expected Package with one sub-object.
 589  *
 590  *              Names that can be repaired in this manner include:
 591  *              _ALR, _CSD, _HPX, _MLS, _PLD, _PRT, _PSS, _TRT, _TSS,
 592  *              _BCL, _DOD, _FIX, _Sx
 593  *
 594  ******************************************************************************/
 595
 596 ACPI_STATUS
 597 AcpiNsWrapWithPackage (
 598     ACPI_EVALUATE_INFO      *Info,
 599     ACPI_OPERAND_OBJECT     *OriginalObject,
 600     ACPI_OPERAND_OBJECT     **ObjDescPtr)
 601 {
 602     ACPI_OPERAND_OBJECT     *PkgObjDesc;
 603
 604
 605     ACPI_FUNCTION_NAME (NsWrapWithPackage);
 606
 607
 608     /*
 609      * Create the new outer package and populate it. The new
 610      * package will have a single element, the lone sub-object.
 611      */
 612     PkgObjDesc = AcpiUtCreatePackageObject (1);
 613     if (!PkgObjDesc)
 614     {
 615         return (AE_NO_MEMORY);
 616     }
 617
 618     PkgObjDesc->Package.Elements[0] = OriginalObject;
 619
 620     ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 621         "%s: Wrapped %s with expected Package object\n",
 622         Info->FullPathname, AcpiUtGetObjectTypeName (OriginalObject)));
 623
 624     /* Return the new object in the object pointer */
 625
 626     *ObjDescPtr = PkgObjDesc;
 627     Info->ReturnFlags |= ACPI_OBJECT_REPAIRED | ACPI_OBJECT_WRAPPED;
 628     return (AE_OK);
 629 }