reactos/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  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2015, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include "acpi.h"
 117 #include "accommon.h"
 118 #include "acnamesp.h"
 119 #include "acinterp.h"
 120 #include "acpredef.h"
 121 #include "amlresrc.h"
 122
 123 #define _COMPONENT          ACPI_NAMESPACE
 124         ACPI_MODULE_NAME    ("nsrepair")
 125
 126
 127 /*******************************************************************************
 128  *
 129  * This module attempts to repair or convert objects returned by the
 130  * predefined methods to an object type that is expected, as per the ACPI
 131  * specification. The need for this code is dictated by the many machines that
 132  * return incorrect types for the standard predefined methods. Performing these
 133  * conversions here, in one place, eliminates the need for individual ACPI
 134  * device drivers to do the same. Note: Most of these conversions are different
 135  * than the internal object conversion routines used for implicit object
 136  * conversion.
 137  *
 138  * The following conversions can be performed as necessary:
 139  *
 140  * Integer -> String
 141  * Integer -> Buffer
 142  * String  -> Integer
 143  * String  -> Buffer
 144  * Buffer  -> Integer
 145  * Buffer  -> String
 146  * Buffer  -> Package of Integers
 147  * Package -> Package of one Package
 148  *
 149  * Additional conversions that are available:
 150  *  Convert a null return or zero return value to an EndTag descriptor
 151  *  Convert an ASCII string to a Unicode buffer
 152  *
 153  * An incorrect standalone object is wrapped with required outer package
 154  *
 155  * Additional possible repairs:
 156  * Required package elements that are NULL replaced by Integer/String/Buffer
 157  *
 158  ******************************************************************************/
 159
 160
 161 /* Local prototypes */
 162
 163 static const ACPI_SIMPLE_REPAIR_INFO *
 164 AcpiNsMatchSimpleRepair (
 165     ACPI_NAMESPACE_NODE     *Node,
 166     UINT32                  ReturnBtype,
 167     UINT32                  PackageIndex);
 168
 169
 170 /*
 171  * Special but simple repairs for some names.
 172  *
 173  * 2nd argument: Unexpected types that can be repaired
 174  */
 175 static const ACPI_SIMPLE_REPAIR_INFO    AcpiObjectRepairInfo[] =
 176 {
 177     /* Resource descriptor conversions */
 178
 179     { "_CRS", ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE,
 180                 ACPI_NOT_PACKAGE_ELEMENT,
 181                 AcpiNsConvertToResource },
 182     { "_DMA", ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE,
 183                 ACPI_NOT_PACKAGE_ELEMENT,
 184                 AcpiNsConvertToResource },
 185     { "_PRS", ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE,
 186                 ACPI_NOT_PACKAGE_ELEMENT,
 187                 AcpiNsConvertToResource },
 188
 189     /* Object reference conversions */
 190
 191     { "_DEP", ACPI_RTYPE_STRING, ACPI_ALL_PACKAGE_ELEMENTS,
 192                 AcpiNsConvertToReference },
 193
 194     /* Unicode conversions */
 195
 196     { "_MLS", ACPI_RTYPE_STRING, 1,
 197                 AcpiNsConvertToUnicode },
 198     { "_STR", ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER,
 199                 ACPI_NOT_PACKAGE_ELEMENT,
 200                 AcpiNsConvertToUnicode },
 201     { {0,0,0,0}, 0, 0, NULL } /* Table terminator */
 202 };
 203
 204
 205 /*******************************************************************************
 206  *
 207  * FUNCTION:    AcpiNsSimpleRepair
 208  *
 209  * PARAMETERS:  Info                - Method execution information block
 210  *              ExpectedBtypes      - Object types expected
 211  *              PackageIndex        - Index of object within parent package (if
 212  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 213  *                                    otherwise)
 214  *              ReturnObjectPtr     - Pointer to the object returned from the
 215  *                                    evaluation of a method or object
 216  *
 217  * RETURN:      Status. AE_OK if repair was successful.
 218  *
 219  * DESCRIPTION: Attempt to repair/convert a return object of a type that was
 220  *              not expected.
 221  *
 222  ******************************************************************************/
 223
 224 ACPI_STATUS
 225 AcpiNsSimpleRepair (
 226     ACPI_EVALUATE_INFO      *Info,
 227     UINT32                  ExpectedBtypes,
 228     UINT32                  PackageIndex,
 229     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 230 {
 231     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 232     ACPI_OPERAND_OBJECT     *NewObject = NULL;
 233     ACPI_STATUS             Status;
 234     const ACPI_SIMPLE_REPAIR_INFO   *Predefined;
 235
 236
 237     ACPI_FUNCTION_NAME (NsSimpleRepair);
 238
 239
 240     /*
 241      * Special repairs for certain names that are in the repair table.
 242      * Check if this name is in the list of repairable names.
 243      */
 244     Predefined = AcpiNsMatchSimpleRepair (Info->Node,
 245         Info->ReturnBtype, PackageIndex);
 246     if (Predefined)
 247     {
 248         if (!ReturnObject)
 249         {
 250             ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
 251                 ACPI_WARN_ALWAYS, "Missing expected return value"));
 252         }
 253
 254         Status = Predefined->ObjectConverter (Info->Node, ReturnObject,
 255             &NewObject);
 256         if (ACPI_FAILURE (Status))
 257         {
 258             /* A fatal error occurred during a conversion */
 259
 260             ACPI_EXCEPTION ((AE_INFO, Status,
 261                 "During return object analysis"));
 262             return (Status);
 263         }
 264         if (NewObject)
 265         {
 266             goto ObjectRepaired;
 267         }
 268     }
 269
 270     /*
 271      * Do not perform simple object repair unless the return type is not
 272      * expected.
 273      */
 274     if (Info->ReturnBtype & ExpectedBtypes)
 275     {
 276         return (AE_OK);
 277     }
 278
 279     /*
 280      * At this point, we know that the type of the returned object was not
 281      * one of the expected types for this predefined name. Attempt to
 282      * repair the object by converting it to one of the expected object
 283      * types for this predefined name.
 284      */
 285
 286     /*
 287      * If there is no return value, check if we require a return value for
 288      * this predefined name. Either one return value is expected, or none,
 289      * for both methods and other objects.
 290      *
 291      * Try to fix if there was no return object. Warning if failed to fix.
 292      */
 293     if (!ReturnObject)
 294     {
 295         if (ExpectedBtypes && (!(ExpectedBtypes & ACPI_RTYPE_NONE)))
 296         {
 297             if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
 298             {
 299                 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
 300                     ACPI_WARN_ALWAYS, "Found unexpected NULL package element"));
 301
 302                 Status = AcpiNsRepairNullElement (Info, ExpectedBtypes,
 303                     PackageIndex, ReturnObjectPtr);
 304                 if (ACPI_SUCCESS (Status))
 305                 {
 306                     return (AE_OK); /* Repair was successful */
 307                 }
 308             }
 309             else
 310             {
 311                 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname,
 312                     ACPI_WARN_ALWAYS, "Missing expected return value"));
 313             }
 314
 315             return (AE_AML_NO_RETURN_VALUE);
 316         }
 317     }
 318
 319     if (ExpectedBtypes & ACPI_RTYPE_INTEGER)
 320     {
 321         Status = AcpiNsConvertToInteger (ReturnObject, &NewObject);
 322         if (ACPI_SUCCESS (Status))
 323         {
 324             goto ObjectRepaired;
 325         }
 326     }
 327     if (ExpectedBtypes & ACPI_RTYPE_STRING)
 328     {
 329         Status = AcpiNsConvertToString (ReturnObject, &NewObject);
 330         if (ACPI_SUCCESS (Status))
 331         {
 332             goto ObjectRepaired;
 333         }
 334     }
 335     if (ExpectedBtypes & ACPI_RTYPE_BUFFER)
 336     {
 337         Status = AcpiNsConvertToBuffer (ReturnObject, &NewObject);
 338         if (ACPI_SUCCESS (Status))
 339         {
 340             goto ObjectRepaired;
 341         }
 342     }
 343     if (ExpectedBtypes & ACPI_RTYPE_PACKAGE)
 344     {
 345         /*
 346          * A package is expected. We will wrap the existing object with a
 347          * new package object. It is often the case that if a variable-length
 348          * package is required, but there is only a single object needed, the
 349          * BIOS will return that object instead of wrapping it with a Package
 350          * object. Note: after the wrapping, the package will be validated
 351          * for correct contents (expected object type or types).
 352          */
 353         Status = AcpiNsWrapWithPackage (Info, ReturnObject, &NewObject);
 354         if (ACPI_SUCCESS (Status))
 355         {
 356             /*
 357              * The original object just had its reference count
 358              * incremented for being inserted into the new package.
 359              */
 360             *ReturnObjectPtr = NewObject;       /* New Package object */
 361             Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 362             return (AE_OK);
 363         }
 364     }
 365
 366     /* We cannot repair this object */
 367
 368     return (AE_AML_OPERAND_TYPE);
 369
 370
 371 ObjectRepaired:
 372
 373     /* Object was successfully repaired */
 374
 375     if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
 376     {
 377         /*
 378          * The original object is a package element. We need to
 379          * decrement the reference count of the original object,
 380          * for removing it from the package.
 381          *
 382          * However, if the original object was just wrapped with a
 383          * package object as part of the repair, we don't need to
 384          * change the reference count.
 385          */
 386         if (!(Info->ReturnFlags & ACPI_OBJECT_WRAPPED))
 387         {
 388             NewObject->Common.ReferenceCount =
 389                 ReturnObject->Common.ReferenceCount;
 390
 391             if (ReturnObject->Common.ReferenceCount > 1)
 392             {
 393                 ReturnObject->Common.ReferenceCount--;
 394             }
 395         }
 396
 397         ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 398             "%s: Converted %s to expected %s at Package index %u\n",
 399             Info->FullPathname, AcpiUtGetObjectTypeName (ReturnObject),
 400             AcpiUtGetObjectTypeName (NewObject), PackageIndex));
 401     }
 402     else
 403     {
 404         ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 405             "%s: Converted %s to expected %s\n",
 406             Info->FullPathname, AcpiUtGetObjectTypeName (ReturnObject),
 407             AcpiUtGetObjectTypeName (NewObject)));
 408     }
 409
 410     /* Delete old object, install the new return object */
 411
 412     AcpiUtRemoveReference (ReturnObject);
 413     *ReturnObjectPtr = NewObject;
 414     Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 415     return (AE_OK);
 416 }
 417
 418
 419 /******************************************************************************
 420  *
 421  * FUNCTION:    AcpiNsMatchSimpleRepair
 422  *
 423  * PARAMETERS:  Node                - Namespace node for the method/object
 424  *              ReturnBtype         - Object type that was returned
 425  *              PackageIndex        - Index of object within parent package (if
 426  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 427  *                                    otherwise)
 428  *
 429  * RETURN:      Pointer to entry in repair table. NULL indicates not found.
 430  *
 431  * DESCRIPTION: Check an object name against the repairable object list.
 432  *
 433  *****************************************************************************/
 434
 435 static const ACPI_SIMPLE_REPAIR_INFO *
 436 AcpiNsMatchSimpleRepair (
 437     ACPI_NAMESPACE_NODE     *Node,
 438     UINT32                  ReturnBtype,
 439     UINT32                  PackageIndex)
 440 {
 441     const ACPI_SIMPLE_REPAIR_INFO   *ThisName;
 442
 443
 444     /* Search info table for a repairable predefined method/object name */
 445
 446     ThisName = AcpiObjectRepairInfo;
 447     while (ThisName->ObjectConverter)
 448     {
 449         if (ACPI_COMPARE_NAME (Node->Name.Ascii, ThisName->Name))
 450         {
 451             /* Check if we can actually repair this name/type combination */
 452
 453             if ((ReturnBtype & ThisName->UnexpectedBtypes) &&
 454                 (ThisName->PackageIndex == ACPI_ALL_PACKAGE_ELEMENTS ||
 455                  PackageIndex == ThisName->PackageIndex))
 456             {
 457                 return (ThisName);
 458             }
 459
 460             return (NULL);
 461         }
 462
 463         ThisName++;
 464     }
 465
 466     return (NULL); /* Name was not found in the repair table */
 467 }
 468
 469
 470 /*******************************************************************************
 471  *
 472  * FUNCTION:    AcpiNsRepairNullElement
 473  *
 474  * PARAMETERS:  Info                - Method execution information block
 475  *              ExpectedBtypes      - Object types expected
 476  *              PackageIndex        - Index of object within parent package (if
 477  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
 478  *                                    otherwise)
 479  *              ReturnObjectPtr     - Pointer to the object returned from the
 480  *                                    evaluation of a method or object
 481  *
 482  * RETURN:      Status. AE_OK if repair was successful.
 483  *
 484  * DESCRIPTION: Attempt to repair a NULL element of a returned Package object.
 485  *
 486  ******************************************************************************/
 487
 488 ACPI_STATUS
 489 AcpiNsRepairNullElement (
 490     ACPI_EVALUATE_INFO      *Info,
 491     UINT32                  ExpectedBtypes,
 492     UINT32                  PackageIndex,
 493     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 494 {
 495     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 496     ACPI_OPERAND_OBJECT     *NewObject;
 497
 498
 499     ACPI_FUNCTION_NAME (NsRepairNullElement);
 500
 501
 502     /* No repair needed if return object is non-NULL */
 503
 504     if (ReturnObject)
 505     {
 506         return (AE_OK);
 507     }
 508
 509     /*
 510      * Attempt to repair a NULL element of a Package object. This applies to
 511      * predefined names that return a fixed-length package and each element
 512      * is required. It does not apply to variable-length packages where NULL
 513      * elements are allowed, especially at the end of the package.
 514      */
 515     if (ExpectedBtypes & ACPI_RTYPE_INTEGER)
 516     {
 517         /* Need an Integer - create a zero-value integer */
 518
 519         NewObject = AcpiUtCreateIntegerObject ((UINT64) 0);
 520     }
 521     else if (ExpectedBtypes & ACPI_RTYPE_STRING)
 522     {
 523         /* Need a String - create a NULL string */
 524
 525         NewObject = AcpiUtCreateStringObject (0);
 526     }
 527     else if (ExpectedBtypes & ACPI_RTYPE_BUFFER)
 528     {
 529         /* Need a Buffer - create a zero-length buffer */
 530
 531         NewObject = AcpiUtCreateBufferObject (0);
 532     }
 533     else
 534     {
 535         /* Error for all other expected types */
 536
 537         return (AE_AML_OPERAND_TYPE);
 538     }
 539
 540     if (!NewObject)
 541     {
 542         return (AE_NO_MEMORY);
 543     }
 544
 545     /* Set the reference count according to the parent Package object */
 546
 547     NewObject->Common.ReferenceCount =
 548         Info->ParentPackage->Common.ReferenceCount;
 549
 550     ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 551         "%s: Converted NULL package element to expected %s at index %u\n",
 552         Info->FullPathname, AcpiUtGetObjectTypeName (NewObject),
 553         PackageIndex));
 554
 555     *ReturnObjectPtr = NewObject;
 556     Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 557     return (AE_OK);
 558 }
 559
 560
 561 /******************************************************************************
 562  *
 563  * FUNCTION:    AcpiNsRemoveNullElements
 564  *
 565  * PARAMETERS:  Info                - Method execution information block
 566  *              PackageType         - An AcpiReturnPackageTypes value
 567  *              ObjDesc             - A Package object
 568  *
 569  * RETURN:      None.
 570  *
 571  * DESCRIPTION: Remove all NULL package elements from packages that contain
 572  *              a variable number of subpackages. For these types of
 573  *              packages, NULL elements can be safely removed.
 574  *
 575  *****************************************************************************/
 576
 577 void
 578 AcpiNsRemoveNullElements (
 579     ACPI_EVALUATE_INFO      *Info,
 580     UINT8                   PackageType,
 581     ACPI_OPERAND_OBJECT     *ObjDesc)
 582 {
 583     ACPI_OPERAND_OBJECT     **Source;
 584     ACPI_OPERAND_OBJECT     **Dest;
 585     UINT32                  Count;
 586     UINT32                  NewCount;
 587     UINT32                  i;
 588
 589
 590     ACPI_FUNCTION_NAME (NsRemoveNullElements);
 591
 592
 593     /*
 594      * We can safely remove all NULL elements from these package types:
 595      * PTYPE1_VAR packages contain a variable number of simple data types.
 596      * PTYPE2 packages contain a variable number of subpackages.
 597      */
 598     switch (PackageType)
 599     {
 600     case ACPI_PTYPE1_VAR:
 601     case ACPI_PTYPE2:
 602     case ACPI_PTYPE2_COUNT:
 603     case ACPI_PTYPE2_PKG_COUNT:
 604     case ACPI_PTYPE2_FIXED:
 605     case ACPI_PTYPE2_MIN:
 606     case ACPI_PTYPE2_REV_FIXED:
 607     case ACPI_PTYPE2_FIX_VAR:
 608         break;
 609
 610     default:
 611     case ACPI_PTYPE2_VAR_VAR:
 612     case ACPI_PTYPE1_FIXED:
 613     case ACPI_PTYPE1_OPTION:
 614         return;
 615     }
 616
 617     Count = ObjDesc->Package.Count;
 618     NewCount = Count;
 619
 620     Source = ObjDesc->Package.Elements;
 621     Dest = Source;
 622
 623     /* Examine all elements of the package object, remove nulls */
 624
 625     for (i = 0; i < Count; i++)
 626     {
 627         if (!*Source)
 628         {
 629             NewCount--;
 630         }
 631         else
 632         {
 633             *Dest = *Source;
 634             Dest++;
 635         }
 636
 637         Source++;
 638     }
 639
 640     /* Update parent package if any null elements were removed */
 641
 642     if (NewCount < Count)
 643     {
 644         ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 645             "%s: Found and removed %u NULL elements\n",
 646             Info->FullPathname, (Count - NewCount)));
 647
 648         /* NULL terminate list and update the package count */
 649
 650         *Dest = NULL;
 651         ObjDesc->Package.Count = NewCount;
 652     }
 653 }
 654
 655
 656 /*******************************************************************************
 657  *
 658  * FUNCTION:    AcpiNsWrapWithPackage
 659  *
 660  * PARAMETERS:  Info                - Method execution information block
 661  *              OriginalObject      - Pointer to the object to repair.
 662  *              ObjDescPtr          - The new package object is returned here
 663  *
 664  * RETURN:      Status, new object in *ObjDescPtr
 665  *
 666  * DESCRIPTION: Repair a common problem with objects that are defined to
 667  *              return a variable-length Package of sub-objects. If there is
 668  *              only one sub-object, some BIOS code mistakenly simply declares
 669  *              the single object instead of a Package with one sub-object.
 670  *              This function attempts to repair this error by wrapping a
 671  *              Package object around the original object, creating the
 672  *              correct and expected Package with one sub-object.
 673  *
 674  *              Names that can be repaired in this manner include:
 675  *              _ALR, _CSD, _HPX, _MLS, _PLD, _PRT, _PSS, _TRT, _TSS,
 676  *              _BCL, _DOD, _FIX, _Sx
 677  *
 678  ******************************************************************************/
 679
 680 ACPI_STATUS
 681 AcpiNsWrapWithPackage (
 682     ACPI_EVALUATE_INFO      *Info,
 683     ACPI_OPERAND_OBJECT     *OriginalObject,
 684     ACPI_OPERAND_OBJECT     **ObjDescPtr)
 685 {
 686     ACPI_OPERAND_OBJECT     *PkgObjDesc;
 687
 688
 689     ACPI_FUNCTION_NAME (NsWrapWithPackage);
 690
 691
 692     /*
 693      * Create the new outer package and populate it. The new
 694      * package will have a single element, the lone sub-object.
 695      */
 696     PkgObjDesc = AcpiUtCreatePackageObject (1);
 697     if (!PkgObjDesc)
 698     {
 699         return (AE_NO_MEMORY);
 700     }
 701
 702     PkgObjDesc->Package.Elements[0] = OriginalObject;
 703
 704     ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 705         "%s: Wrapped %s with expected Package object\n",
 706         Info->FullPathname, AcpiUtGetObjectTypeName (OriginalObject)));
 707
 708     /* Return the new object in the object pointer */
 709
 710     *ObjDescPtr = PkgObjDesc;
 711     Info->ReturnFlags |= ACPI_OBJECT_REPAIRED | ACPI_OBJECT_WRAPPED;
 712     return (AE_OK);
 713 }