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

   1 /******************************************************************************
   2  *
   3  * Module Name: nsrepair2 - Repair for objects returned by specific
   4  *                          predefined methods
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  * Copyright (C) 2000 - 2021, Intel Corp.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions, and the following disclaimer,
  17  *    without modification.
  18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19  *    substantially similar to the "NO WARRANTY" disclaimer below
  20  *    ("Disclaimer") and any redistribution must be conditioned upon
  21  *    including a substantially similar Disclaimer requirement for further
  22  *    binary redistribution.
  23  * 3. Neither the names of the above-listed copyright holders nor the names
  24  *    of any contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * Alternatively, this software may be distributed under the terms of the
  28  * GNU General Public License ("GPL") version 2 as published by the Free
  29  * Software Foundation.
  30  *
  31  * NO WARRANTY
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGES.
  43  */
  44
  45 #include "acpi.h"
  46 #include "accommon.h"
  47 #include "acnamesp.h"
  48
  49 #define _COMPONENT          ACPI_NAMESPACE
  50         ACPI_MODULE_NAME    ("nsrepair2")
  51
  52
  53 /*
  54  * Information structure and handler for ACPI predefined names that can
  55  * be repaired on a per-name basis.
  56  */
  57 typedef
  58 ACPI_STATUS (*ACPI_REPAIR_FUNCTION) (
  59     ACPI_EVALUATE_INFO      *Info,
  60     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
  61
  62 typedef struct acpi_repair_info
  63 {
  64     char                    Name[ACPI_NAMESEG_SIZE];
  65     ACPI_REPAIR_FUNCTION    RepairFunction;
  66
  67 } ACPI_REPAIR_INFO;
  68
  69
  70 /* Local prototypes */
  71
  72 static const ACPI_REPAIR_INFO *
  73 AcpiNsMatchComplexRepair (
  74     ACPI_NAMESPACE_NODE     *Node);
  75
  76 static ACPI_STATUS
  77 AcpiNsRepair_ALR (
  78     ACPI_EVALUATE_INFO      *Info,
  79     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
  80
  81 static ACPI_STATUS
  82 AcpiNsRepair_CID (
  83     ACPI_EVALUATE_INFO      *Info,
  84     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
  85
  86 static ACPI_STATUS
  87 AcpiNsRepair_CST (
  88     ACPI_EVALUATE_INFO      *Info,
  89     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
  90
  91 static ACPI_STATUS
  92 AcpiNsRepair_FDE (
  93     ACPI_EVALUATE_INFO      *Info,
  94     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
  95
  96 static ACPI_STATUS
  97 AcpiNsRepair_HID (
  98     ACPI_EVALUATE_INFO      *Info,
  99     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
 100
 101 static ACPI_STATUS
 102 AcpiNsRepair_PRT (
 103     ACPI_EVALUATE_INFO      *Info,
 104     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
 105
 106 static ACPI_STATUS
 107 AcpiNsRepair_PSS (
 108     ACPI_EVALUATE_INFO      *Info,
 109     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
 110
 111 static ACPI_STATUS
 112 AcpiNsRepair_TSS (
 113     ACPI_EVALUATE_INFO      *Info,
 114     ACPI_OPERAND_OBJECT     **ReturnObjectPtr);
 115
 116 static ACPI_STATUS
 117 AcpiNsCheckSortedList (
 118     ACPI_EVALUATE_INFO      *Info,
 119     ACPI_OPERAND_OBJECT     *ReturnObject,
 120     UINT32                  StartIndex,
 121     UINT32                  ExpectedCount,
 122     UINT32                  SortIndex,
 123     UINT8                   SortDirection,
 124     char                    *SortKeyName);
 125
 126 /* Values for SortDirection above */
 127
 128 #define ACPI_SORT_ASCENDING     0
 129 #define ACPI_SORT_DESCENDING    1
 130
 131 static void
 132 AcpiNsRemoveElement (
 133     ACPI_OPERAND_OBJECT     *ObjDesc,
 134     UINT32                  Index);
 135
 136 static void
 137 AcpiNsSortList (
 138     ACPI_OPERAND_OBJECT     **Elements,
 139     UINT32                  Count,
 140     UINT32                  Index,
 141     UINT8                   SortDirection);
 142
 143
 144 /*
 145  * This table contains the names of the predefined methods for which we can
 146  * perform more complex repairs.
 147  *
 148  * As necessary:
 149  *
 150  * _ALR: Sort the list ascending by AmbientIlluminance
 151  * _CID: Strings: uppercase all, remove any leading asterisk
 152  * _CST: Sort the list ascending by C state type
 153  * _FDE: Convert Buffer of BYTEs to a Buffer of DWORDs
 154  * _GTM: Convert Buffer of BYTEs to a Buffer of DWORDs
 155  * _HID: Strings: uppercase all, remove any leading asterisk
 156  * _PRT: Fix reversed SourceName and SourceIndex
 157  * _PSS: Sort the list descending by Power
 158  * _TSS: Sort the list descending by Power
 159  *
 160  * Names that must be packages, but cannot be sorted:
 161  *
 162  * _BCL: Values are tied to the Package index where they appear, and cannot
 163  * be moved or sorted. These index values are used for _BQC and _BCM.
 164  * However, we can fix the case where a buffer is returned, by converting
 165  * it to a Package of integers.
 166  */
 167 static const ACPI_REPAIR_INFO       AcpiNsRepairableNames[] =
 168 {
 169     {"_ALR", AcpiNsRepair_ALR},
 170     {"_CID", AcpiNsRepair_CID},
 171     {"_CST", AcpiNsRepair_CST},
 172     {"_FDE", AcpiNsRepair_FDE},
 173     {"_GTM", AcpiNsRepair_FDE},     /* _GTM has same repair as _FDE */
 174     {"_HID", AcpiNsRepair_HID},
 175     {"_PRT", AcpiNsRepair_PRT},
 176     {"_PSS", AcpiNsRepair_PSS},
 177     {"_TSS", AcpiNsRepair_TSS},
 178     {{0,0,0,0}, NULL}               /* Table terminator */
 179 };
 180
 181
 182 #define ACPI_FDE_FIELD_COUNT        5
 183 #define ACPI_FDE_BYTE_BUFFER_SIZE   5
 184 #define ACPI_FDE_DWORD_BUFFER_SIZE  (ACPI_FDE_FIELD_COUNT * (UINT32) sizeof (UINT32))
 185
 186
 187 /******************************************************************************
 188  *
 189  * FUNCTION:    AcpiNsComplexRepairs
 190  *
 191  * PARAMETERS:  Info                - Method execution information block
 192  *              Node                - Namespace node for the method/object
 193  *              ValidateStatus      - Original status of earlier validation
 194  *              ReturnObjectPtr     - Pointer to the object returned from the
 195  *                                    evaluation of a method or object
 196  *
 197  * RETURN:      Status. AE_OK if repair was successful. If name is not
 198  *              matched, ValidateStatus is returned.
 199  *
 200  * DESCRIPTION: Attempt to repair/convert a return object of a type that was
 201  *              not expected.
 202  *
 203  *****************************************************************************/
 204
 205 ACPI_STATUS
 206 AcpiNsComplexRepairs (
 207     ACPI_EVALUATE_INFO      *Info,
 208     ACPI_NAMESPACE_NODE     *Node,
 209     ACPI_STATUS             ValidateStatus,
 210     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 211 {
 212     const ACPI_REPAIR_INFO  *Predefined;
 213     ACPI_STATUS             Status;
 214
 215
 216     ACPI_FUNCTION_TRACE (NsComplexRepairs);
 217
 218     /* Check if this name is in the list of repairable names */
 219
 220     Predefined = AcpiNsMatchComplexRepair (Node);
 221     if (!Predefined)
 222     {
 223         return_ACPI_STATUS (ValidateStatus);
 224     }
 225
 226     Status = Predefined->RepairFunction (Info, ReturnObjectPtr);
 227     return_ACPI_STATUS (Status);
 228 }
 229
 230
 231 /******************************************************************************
 232  *
 233  * FUNCTION:    AcpiNsMatchComplexRepair
 234  *
 235  * PARAMETERS:  Node                - Namespace node for the method/object
 236  *
 237  * RETURN:      Pointer to entry in repair table. NULL indicates not found.
 238  *
 239  * DESCRIPTION: Check an object name against the repairable object list.
 240  *
 241  *****************************************************************************/
 242
 243 static const ACPI_REPAIR_INFO *
 244 AcpiNsMatchComplexRepair (
 245     ACPI_NAMESPACE_NODE     *Node)
 246 {
 247     const ACPI_REPAIR_INFO  *ThisName;
 248
 249
 250     /* Search info table for a repairable predefined method/object name */
 251
 252     ThisName = AcpiNsRepairableNames;
 253     while (ThisName->RepairFunction)
 254     {
 255         if (ACPI_COMPARE_NAMESEG (Node->Name.Ascii, ThisName->Name))
 256         {
 257             return (ThisName);
 258         }
 259
 260         ThisName++;
 261     }
 262
 263     return (NULL); /* Not found */
 264 }
 265
 266
 267 /******************************************************************************
 268  *
 269  * FUNCTION:    AcpiNsRepair_ALR
 270  *
 271  * PARAMETERS:  Info                - Method execution information block
 272  *              ReturnObjectPtr     - Pointer to the object returned from the
 273  *                                    evaluation of a method or object
 274  *
 275  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
 276  *
 277  * DESCRIPTION: Repair for the _ALR object. If necessary, sort the object list
 278  *              ascending by the ambient illuminance values.
 279  *
 280  *****************************************************************************/
 281
 282 static ACPI_STATUS
 283 AcpiNsRepair_ALR (
 284     ACPI_EVALUATE_INFO      *Info,
 285     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 286 {
 287     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 288     ACPI_STATUS             Status;
 289
 290
 291     Status = AcpiNsCheckSortedList (Info, ReturnObject, 0, 2, 1,
 292         ACPI_SORT_ASCENDING, "AmbientIlluminance");
 293
 294     return (Status);
 295 }
 296
 297
 298 /******************************************************************************
 299  *
 300  * FUNCTION:    AcpiNsRepair_FDE
 301  *
 302  * PARAMETERS:  Info                - Method execution information block
 303  *              ReturnObjectPtr     - Pointer to the object returned from the
 304  *                                    evaluation of a method or object
 305  *
 306  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
 307  *
 308  * DESCRIPTION: Repair for the _FDE and _GTM objects. The expected return
 309  *              value is a Buffer of 5 DWORDs. This function repairs a common
 310  *              problem where the return value is a Buffer of BYTEs, not
 311  *              DWORDs.
 312  *
 313  *****************************************************************************/
 314
 315 static ACPI_STATUS
 316 AcpiNsRepair_FDE (
 317     ACPI_EVALUATE_INFO      *Info,
 318     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 319 {
 320     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 321     ACPI_OPERAND_OBJECT     *BufferObject;
 322     UINT8                   *ByteBuffer;
 323     UINT32                  *DwordBuffer;
 324     UINT32                  i;
 325
 326
 327     ACPI_FUNCTION_NAME (NsRepair_FDE);
 328
 329
 330     switch (ReturnObject->Common.Type)
 331     {
 332     case ACPI_TYPE_BUFFER:
 333
 334         /* This is the expected type. Length should be (at least) 5 DWORDs */
 335
 336         if (ReturnObject->Buffer.Length >= ACPI_FDE_DWORD_BUFFER_SIZE)
 337         {
 338             return (AE_OK);
 339         }
 340
 341         /* We can only repair if we have exactly 5 BYTEs */
 342
 343         if (ReturnObject->Buffer.Length != ACPI_FDE_BYTE_BUFFER_SIZE)
 344         {
 345             ACPI_WARN_PREDEFINED ((AE_INFO,
 346                 Info->FullPathname, Info->NodeFlags,
 347                 "Incorrect return buffer length %u, expected %u",
 348                 ReturnObject->Buffer.Length, ACPI_FDE_DWORD_BUFFER_SIZE));
 349
 350             return (AE_AML_OPERAND_TYPE);
 351         }
 352
 353         /* Create the new (larger) buffer object */
 354
 355         BufferObject = AcpiUtCreateBufferObject (
 356             ACPI_FDE_DWORD_BUFFER_SIZE);
 357         if (!BufferObject)
 358         {
 359             return (AE_NO_MEMORY);
 360         }
 361
 362         /* Expand each byte to a DWORD */
 363
 364         ByteBuffer = ReturnObject->Buffer.Pointer;
 365         DwordBuffer = ACPI_CAST_PTR (UINT32,
 366             BufferObject->Buffer.Pointer);
 367
 368         for (i = 0; i < ACPI_FDE_FIELD_COUNT; i++)
 369         {
 370             *DwordBuffer = (UINT32) *ByteBuffer;
 371             DwordBuffer++;
 372             ByteBuffer++;
 373         }
 374
 375         ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 376             "%s Expanded Byte Buffer to expected DWord Buffer\n",
 377             Info->FullPathname));
 378         break;
 379
 380     default:
 381
 382         return (AE_AML_OPERAND_TYPE);
 383     }
 384
 385     /* Delete the original return object, return the new buffer object */
 386
 387     AcpiUtRemoveReference (ReturnObject);
 388     *ReturnObjectPtr = BufferObject;
 389
 390     Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 391     return (AE_OK);
 392 }
 393
 394
 395 /******************************************************************************
 396  *
 397  * FUNCTION:    AcpiNsRepair_CID
 398  *
 399  * PARAMETERS:  Info                - Method execution information block
 400  *              ReturnObjectPtr     - Pointer to the object returned from the
 401  *                                    evaluation of a method or object
 402  *
 403  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
 404  *
 405  * DESCRIPTION: Repair for the _CID object. If a string, ensure that all
 406  *              letters are uppercase and that there is no leading asterisk.
 407  *              If a Package, ensure same for all string elements.
 408  *
 409  *****************************************************************************/
 410
 411 static ACPI_STATUS
 412 AcpiNsRepair_CID (
 413     ACPI_EVALUATE_INFO      *Info,
 414     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 415 {
 416     ACPI_STATUS             Status;
 417     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 418     ACPI_OPERAND_OBJECT     **ElementPtr;
 419     ACPI_OPERAND_OBJECT     *OriginalElement;
 420     UINT16                  OriginalRefCount;
 421     UINT32                  i;
 422
 423     ACPI_FUNCTION_TRACE (NsRepair_CID);
 424
 425     /* Check for _CID as a simple string */
 426
 427     if (ReturnObject->Common.Type == ACPI_TYPE_STRING)
 428     {
 429         Status = AcpiNsRepair_HID (Info, ReturnObjectPtr);
 430         return_ACPI_STATUS (Status);
 431     }
 432
 433     /* Exit if not a Package */
 434
 435     if (ReturnObject->Common.Type != ACPI_TYPE_PACKAGE)
 436     {
 437         return_ACPI_STATUS (AE_OK);
 438     }
 439
 440     /* Examine each element of the _CID package */
 441
 442     ElementPtr = ReturnObject->Package.Elements;
 443     for (i = 0; i < ReturnObject->Package.Count; i++)
 444     {
 445         OriginalElement = *ElementPtr;
 446         OriginalRefCount = OriginalElement->Common.ReferenceCount;
 447
 448         Status = AcpiNsRepair_HID (Info, ElementPtr);
 449         if (ACPI_FAILURE (Status))
 450         {
 451             return_ACPI_STATUS (Status);
 452         }
 453
 454         if (OriginalElement != *ElementPtr)
 455         {
 456             /* Update reference count of new object */
 457
 458             (*ElementPtr)->Common.ReferenceCount =
 459                 OriginalRefCount;
 460
 461             /*
 462              * The OriginalElement holds a reference from the package object
 463              * that represents _HID. Since a new element was created by _HID,
 464              * remove the reference from the _CID package.
 465              */
 466             AcpiUtRemoveReference (OriginalElement);
 467         }
 468
 469         ElementPtr++;
 470     }
 471
 472     return_ACPI_STATUS (AE_OK);
 473 }
 474
 475
 476 /******************************************************************************
 477  *
 478  * FUNCTION:    AcpiNsRepair_CST
 479  *
 480  * PARAMETERS:  Info                - Method execution information block
 481  *              ReturnObjectPtr     - Pointer to the object returned from the
 482  *                                    evaluation of a method or object
 483  *
 484  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
 485  *
 486  * DESCRIPTION: Repair for the _CST object:
 487  *              1. Sort the list ascending by C state type
 488  *              2. Ensure type cannot be zero
 489  *              3. A subpackage count of zero means _CST is meaningless
 490  *              4. Count must match the number of C state subpackages
 491  *
 492  *****************************************************************************/
 493
 494 static ACPI_STATUS
 495 AcpiNsRepair_CST (
 496     ACPI_EVALUATE_INFO      *Info,
 497     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 498 {
 499     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 500     ACPI_OPERAND_OBJECT     **OuterElements;
 501     UINT32                  OuterElementCount;
 502     ACPI_OPERAND_OBJECT     *ObjDesc;
 503     ACPI_STATUS             Status;
 504     BOOLEAN                 Removing;
 505     UINT32                  i;
 506
 507
 508     ACPI_FUNCTION_NAME (NsRepair_CST);
 509
 510
 511     /*
 512      * Check if the C-state type values are proportional.
 513      */
 514     OuterElementCount = ReturnObject->Package.Count - 1;
 515     i = 0;
 516     while (i < OuterElementCount)
 517     {
 518         OuterElements = &ReturnObject->Package.Elements[i + 1];
 519         Removing = FALSE;
 520
 521         if ((*OuterElements)->Package.Count == 0)
 522         {
 523             ACPI_WARN_PREDEFINED ((AE_INFO,
 524                 Info->FullPathname, Info->NodeFlags,
 525                 "SubPackage[%u] - removing entry due to zero count", i));
 526             Removing = TRUE;
 527             goto RemoveElement;
 528         }
 529
 530         ObjDesc = (*OuterElements)->Package.Elements[1]; /* Index1 = Type */
 531         if ((UINT32) ObjDesc->Integer.Value == 0)
 532         {
 533             ACPI_WARN_PREDEFINED ((AE_INFO,
 534                 Info->FullPathname, Info->NodeFlags,
 535                 "SubPackage[%u] - removing entry due to invalid Type(0)", i));
 536             Removing = TRUE;
 537         }
 538
 539 RemoveElement:
 540         if (Removing)
 541         {
 542             AcpiNsRemoveElement (ReturnObject, i + 1);
 543             OuterElementCount--;
 544         }
 545         else
 546         {
 547             i++;
 548         }
 549     }
 550
 551     /* Update top-level package count, Type "Integer" checked elsewhere */
 552
 553     ObjDesc = ReturnObject->Package.Elements[0];
 554     ObjDesc->Integer.Value = OuterElementCount;
 555
 556     /*
 557      * Entries (subpackages) in the _CST Package must be sorted by the
 558      * C-state type, in ascending order.
 559      */
 560     Status = AcpiNsCheckSortedList (Info, ReturnObject, 1, 4, 1,
 561         ACPI_SORT_ASCENDING, "C-State Type");
 562     if (ACPI_FAILURE (Status))
 563     {
 564         return (Status);
 565     }
 566
 567     return (AE_OK);
 568 }
 569
 570
 571 /******************************************************************************
 572  *
 573  * FUNCTION:    AcpiNsRepair_HID
 574  *
 575  * PARAMETERS:  Info                - Method execution information block
 576  *              ReturnObjectPtr     - Pointer to the object returned from the
 577  *                                    evaluation of a method or object
 578  *
 579  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
 580  *
 581  * DESCRIPTION: Repair for the _HID object. If a string, ensure that all
 582  *              letters are uppercase and that there is no leading asterisk.
 583  *
 584  *****************************************************************************/
 585
 586 static ACPI_STATUS
 587 AcpiNsRepair_HID (
 588     ACPI_EVALUATE_INFO      *Info,
 589     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 590 {
 591     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 592     ACPI_OPERAND_OBJECT     *NewString;
 593     char                    *Source;
 594     char                    *Dest;
 595
 596
 597     ACPI_FUNCTION_NAME (NsRepair_HID);
 598
 599
 600     /* We only care about string _HID objects (not integers) */
 601
 602     if (ReturnObject->Common.Type != ACPI_TYPE_STRING)
 603     {
 604         return_ACPI_STATUS (AE_OK);
 605     }
 606
 607     if (ReturnObject->String.Length == 0)
 608     {
 609         ACPI_WARN_PREDEFINED ((AE_INFO,
 610             Info->FullPathname, Info->NodeFlags,
 611             "Invalid zero-length _HID or _CID string"));
 612
 613         /* Return AE_OK anyway, let driver handle it */
 614
 615         Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 616         return_ACPI_STATUS (AE_OK);
 617     }
 618
 619     /* It is simplest to always create a new string object */
 620
 621     NewString = AcpiUtCreateStringObject (ReturnObject->String.Length);
 622     if (!NewString)
 623     {
 624         return_ACPI_STATUS (AE_NO_MEMORY);
 625     }
 626
 627     /*
 628      * Remove a leading asterisk if present. For some unknown reason, there
 629      * are many machines in the field that contains IDs like this.
 630      *
 631      * Examples: "*PNP0C03", "*ACPI0003"
 632      */
 633     Source = ReturnObject->String.Pointer;
 634     if (*Source == '*')
 635     {
 636         Source++;
 637         NewString->String.Length--;
 638
 639         ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 640             "%s: Removed invalid leading asterisk\n", Info->FullPathname));
 641     }
 642
 643     /*
 644      * Copy and uppercase the string. From the ACPI 5.0 specification:
 645      *
 646      * A valid PNP ID must be of the form "AAA####" where A is an uppercase
 647      * letter and # is a hex digit. A valid ACPI ID must be of the form
 648      * "NNNN####" where N is an uppercase letter or decimal digit, and
 649      * # is a hex digit.
 650      */
 651     for (Dest = NewString->String.Pointer; *Source; Dest++, Source++)
 652     {
 653         *Dest = (char) toupper ((int) *Source);
 654     }
 655
 656     AcpiUtRemoveReference (ReturnObject);
 657     *ReturnObjectPtr = NewString;
 658     return_ACPI_STATUS (AE_OK);
 659 }
 660
 661
 662 /******************************************************************************
 663  *
 664  * FUNCTION:    AcpiNsRepair_PRT
 665  *
 666  * PARAMETERS:  Info                - Method execution information block
 667  *              ReturnObjectPtr     - Pointer to the object returned from the
 668  *                                    evaluation of a method or object
 669  *
 670  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
 671  *
 672  * DESCRIPTION: Repair for the _PRT object. If necessary, fix reversed
 673  *              SourceName and SourceIndex field, a common BIOS bug.
 674  *
 675  *****************************************************************************/
 676
 677 static ACPI_STATUS
 678 AcpiNsRepair_PRT (
 679     ACPI_EVALUATE_INFO      *Info,
 680     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 681 {
 682     ACPI_OPERAND_OBJECT     *PackageObject = *ReturnObjectPtr;
 683     ACPI_OPERAND_OBJECT     **TopObjectList;
 684     ACPI_OPERAND_OBJECT     **SubObjectList;
 685     ACPI_OPERAND_OBJECT     *ObjDesc;
 686     ACPI_OPERAND_OBJECT     *SubPackage;
 687     UINT32                  ElementCount;
 688     UINT32                  Index;
 689
 690
 691     /* Each element in the _PRT package is a subpackage */
 692
 693     TopObjectList = PackageObject->Package.Elements;
 694     ElementCount = PackageObject->Package.Count;
 695
 696     /* Examine each subpackage */
 697
 698     for (Index = 0; Index < ElementCount; Index++, TopObjectList++)
 699     {
 700         SubPackage = *TopObjectList;
 701         SubObjectList = SubPackage->Package.Elements;
 702
 703         /* Check for minimum required element count */
 704
 705         if (SubPackage->Package.Count < 4)
 706         {
 707             continue;
 708         }
 709
 710         /*
 711          * If the BIOS has erroneously reversed the _PRT SourceName (index 2)
 712          * and the SourceIndex (index 3), fix it. _PRT is important enough to
 713          * workaround this BIOS error. This also provides compatibility with
 714          * other ACPI implementations.
 715          */
 716         ObjDesc = SubObjectList[3];
 717         if (!ObjDesc || (ObjDesc->Common.Type != ACPI_TYPE_INTEGER))
 718         {
 719             SubObjectList[3] = SubObjectList[2];
 720             SubObjectList[2] = ObjDesc;
 721             Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 722
 723             ACPI_WARN_PREDEFINED ((AE_INFO,
 724                 Info->FullPathname, Info->NodeFlags,
 725                 "PRT[%X]: Fixed reversed SourceName and SourceIndex",
 726                 Index));
 727         }
 728     }
 729
 730     return (AE_OK);
 731 }
 732
 733
 734 /******************************************************************************
 735  *
 736  * FUNCTION:    AcpiNsRepair_PSS
 737  *
 738  * PARAMETERS:  Info                - Method execution information block
 739  *              ReturnObjectPtr     - Pointer to the object returned from the
 740  *                                    evaluation of a method or object
 741  *
 742  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
 743  *
 744  * DESCRIPTION: Repair for the _PSS object. If necessary, sort the object list
 745  *              by the CPU frequencies. Check that the power dissipation values
 746  *              are all proportional to CPU frequency (i.e., sorting by
 747  *              frequency should be the same as sorting by power.)
 748  *
 749  *****************************************************************************/
 750
 751 static ACPI_STATUS
 752 AcpiNsRepair_PSS (
 753     ACPI_EVALUATE_INFO      *Info,
 754     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 755 {
 756     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 757     ACPI_OPERAND_OBJECT     **OuterElements;
 758     UINT32                  OuterElementCount;
 759     ACPI_OPERAND_OBJECT     **Elements;
 760     ACPI_OPERAND_OBJECT     *ObjDesc;
 761     UINT32                  PreviousValue;
 762     ACPI_STATUS             Status;
 763     UINT32                  i;
 764
 765
 766     /*
 767      * Entries (subpackages) in the _PSS Package must be sorted by power
 768      * dissipation, in descending order. If it appears that the list is
 769      * incorrectly sorted, sort it. We sort by CpuFrequency, since this
 770      * should be proportional to the power.
 771      */
 772     Status = AcpiNsCheckSortedList (Info, ReturnObject, 0, 6, 0,
 773         ACPI_SORT_DESCENDING, "CpuFrequency");
 774     if (ACPI_FAILURE (Status))
 775     {
 776         return (Status);
 777     }
 778
 779     /*
 780      * We now know the list is correctly sorted by CPU frequency. Check if
 781      * the power dissipation values are proportional.
 782      */
 783     PreviousValue = ACPI_UINT32_MAX;
 784     OuterElements = ReturnObject->Package.Elements;
 785     OuterElementCount = ReturnObject->Package.Count;
 786
 787     for (i = 0; i < OuterElementCount; i++)
 788     {
 789         Elements = (*OuterElements)->Package.Elements;
 790         ObjDesc = Elements[1]; /* Index1 = PowerDissipation */
 791
 792         if ((UINT32) ObjDesc->Integer.Value > PreviousValue)
 793         {
 794             ACPI_WARN_PREDEFINED ((AE_INFO,
 795                 Info->FullPathname, Info->NodeFlags,
 796                 "SubPackage[%u,%u] - suspicious power dissipation values",
 797                 i-1, i));
 798         }
 799
 800         PreviousValue = (UINT32) ObjDesc->Integer.Value;
 801         OuterElements++;
 802     }
 803
 804     return (AE_OK);
 805 }
 806
 807
 808 /******************************************************************************
 809  *
 810  * FUNCTION:    AcpiNsRepair_TSS
 811  *
 812  * PARAMETERS:  Info                - Method execution information block
 813  *              ReturnObjectPtr     - Pointer to the object returned from the
 814  *                                    evaluation of a method or object
 815  *
 816  * RETURN:      Status. AE_OK if object is OK or was repaired successfully
 817  *
 818  * DESCRIPTION: Repair for the _TSS object. If necessary, sort the object list
 819  *              descending by the power dissipation values.
 820  *
 821  *****************************************************************************/
 822
 823 static ACPI_STATUS
 824 AcpiNsRepair_TSS (
 825     ACPI_EVALUATE_INFO      *Info,
 826     ACPI_OPERAND_OBJECT     **ReturnObjectPtr)
 827 {
 828     ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;
 829     ACPI_STATUS             Status;
 830     ACPI_NAMESPACE_NODE     *Node;
 831
 832
 833     /*
 834      * We can only sort the _TSS return package if there is no _PSS in the
 835      * same scope. This is because if _PSS is present, the ACPI specification
 836      * dictates that the _TSS Power Dissipation field is to be ignored, and
 837      * therefore some BIOSs leave garbage values in the _TSS Power field(s).
 838      * In this case, it is best to just return the _TSS package as-is.
 839      * (May, 2011)
 840      */
 841     Status = AcpiNsGetNode (Info->Node, "^_PSS",
 842         ACPI_NS_NO_UPSEARCH, &Node);
 843     if (ACPI_SUCCESS (Status))
 844     {
 845         return (AE_OK);
 846     }
 847
 848     Status = AcpiNsCheckSortedList (Info, ReturnObject, 0, 5, 1,
 849         ACPI_SORT_DESCENDING, "PowerDissipation");
 850
 851     return (Status);
 852 }
 853
 854
 855 /******************************************************************************
 856  *
 857  * FUNCTION:    AcpiNsCheckSortedList
 858  *
 859  * PARAMETERS:  Info                - Method execution information block
 860  *              ReturnObject        - Pointer to the top-level returned object
 861  *              StartIndex          - Index of the first subpackage
 862  *              ExpectedCount       - Minimum length of each subpackage
 863  *              SortIndex           - Subpackage entry to sort on
 864  *              SortDirection       - Ascending or descending
 865  *              SortKeyName         - Name of the SortIndex field
 866  *
 867  * RETURN:      Status. AE_OK if the list is valid and is sorted correctly or
 868  *              has been repaired by sorting the list.
 869  *
 870  * DESCRIPTION: Check if the package list is valid and sorted correctly by the
 871  *              SortIndex. If not, then sort the list.
 872  *
 873  *****************************************************************************/
 874
 875 static ACPI_STATUS
 876 AcpiNsCheckSortedList (
 877     ACPI_EVALUATE_INFO      *Info,
 878     ACPI_OPERAND_OBJECT     *ReturnObject,
 879     UINT32                  StartIndex,
 880     UINT32                  ExpectedCount,
 881     UINT32                  SortIndex,
 882     UINT8                   SortDirection,
 883     char                    *SortKeyName)
 884 {
 885     UINT32                  OuterElementCount;
 886     ACPI_OPERAND_OBJECT     **OuterElements;
 887     ACPI_OPERAND_OBJECT     **Elements;
 888     ACPI_OPERAND_OBJECT     *ObjDesc;
 889     UINT32                  i;
 890     UINT32                  PreviousValue;
 891
 892
 893     ACPI_FUNCTION_NAME (NsCheckSortedList);
 894
 895
 896     /* The top-level object must be a package */
 897
 898     if (ReturnObject->Common.Type != ACPI_TYPE_PACKAGE)
 899     {
 900         return (AE_AML_OPERAND_TYPE);
 901     }
 902
 903     /*
 904      * NOTE: assumes list of subpackages contains no NULL elements.
 905      * Any NULL elements should have been removed by earlier call
 906      * to AcpiNsRemoveNullElements.
 907      */
 908     OuterElementCount = ReturnObject->Package.Count;
 909     if (!OuterElementCount || StartIndex >= OuterElementCount)
 910     {
 911         return (AE_AML_PACKAGE_LIMIT);
 912     }
 913
 914     OuterElements = &ReturnObject->Package.Elements[StartIndex];
 915     OuterElementCount -= StartIndex;
 916
 917     PreviousValue = 0;
 918     if (SortDirection == ACPI_SORT_DESCENDING)
 919     {
 920         PreviousValue = ACPI_UINT32_MAX;
 921     }
 922
 923     /* Examine each subpackage */
 924
 925     for (i = 0; i < OuterElementCount; i++)
 926     {
 927         /* Each element of the top-level package must also be a package */
 928
 929         if ((*OuterElements)->Common.Type != ACPI_TYPE_PACKAGE)
 930         {
 931             return (AE_AML_OPERAND_TYPE);
 932         }
 933
 934         /* Each subpackage must have the minimum length */
 935
 936         if ((*OuterElements)->Package.Count < ExpectedCount)
 937         {
 938             return (AE_AML_PACKAGE_LIMIT);
 939         }
 940
 941         Elements = (*OuterElements)->Package.Elements;
 942         ObjDesc = Elements[SortIndex];
 943
 944         if (ObjDesc->Common.Type != ACPI_TYPE_INTEGER)
 945         {
 946             return (AE_AML_OPERAND_TYPE);
 947         }
 948
 949         /*
 950          * The list must be sorted in the specified order. If we detect a
 951          * discrepancy, sort the entire list.
 952          */
 953         if (((SortDirection == ACPI_SORT_ASCENDING) &&
 954                 (ObjDesc->Integer.Value < PreviousValue)) ||
 955             ((SortDirection == ACPI_SORT_DESCENDING) &&
 956                 (ObjDesc->Integer.Value > PreviousValue)))
 957         {
 958             AcpiNsSortList (&ReturnObject->Package.Elements[StartIndex],
 959                 OuterElementCount, SortIndex, SortDirection);
 960
 961             Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;
 962
 963             ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,
 964                 "%s: Repaired unsorted list - now sorted by %s\n",
 965                 Info->FullPathname, SortKeyName));
 966             return (AE_OK);
 967         }
 968
 969         PreviousValue = (UINT32) ObjDesc->Integer.Value;
 970         OuterElements++;
 971     }
 972
 973     return (AE_OK);
 974 }
 975
 976
 977 /******************************************************************************
 978  *
 979  * FUNCTION:    AcpiNsSortList
 980  *
 981  * PARAMETERS:  Elements            - Package object element list
 982  *              Count               - Element count for above
 983  *              Index               - Sort by which package element
 984  *              SortDirection       - Ascending or Descending sort
 985  *
 986  * RETURN:      None
 987  *
 988  * DESCRIPTION: Sort the objects that are in a package element list.
 989  *
 990  * NOTE: Assumes that all NULL elements have been removed from the package,
 991  *       and that all elements have been verified to be of type Integer.
 992  *
 993  *****************************************************************************/
 994
 995 static void
 996 AcpiNsSortList (
 997     ACPI_OPERAND_OBJECT     **Elements,
 998     UINT32                  Count,
 999     UINT32                  Index,
1000     UINT8                   SortDirection)
1001 {
1002     ACPI_OPERAND_OBJECT     *ObjDesc1;
1003     ACPI_OPERAND_OBJECT     *ObjDesc2;
1004     ACPI_OPERAND_OBJECT     *TempObj;
1005     UINT32                  i;
1006     UINT32                  j;
1007
1008
1009     /* Simple bubble sort */
1010
1011     for (i = 1; i < Count; i++)
1012     {
1013         for (j = (Count - 1); j >= i; j--)
1014         {
1015             ObjDesc1 = Elements[j-1]->Package.Elements[Index];
1016             ObjDesc2 = Elements[j]->Package.Elements[Index];
1017
1018             if (((SortDirection == ACPI_SORT_ASCENDING) &&
1019                     (ObjDesc1->Integer.Value > ObjDesc2->Integer.Value)) ||
1020
1021                 ((SortDirection == ACPI_SORT_DESCENDING) &&
1022                     (ObjDesc1->Integer.Value < ObjDesc2->Integer.Value)))
1023             {
1024                 TempObj = Elements[j-1];
1025                 Elements[j-1] = Elements[j];
1026                 Elements[j] = TempObj;
1027             }
1028         }
1029     }
1030 }
1031
1032
1033 /******************************************************************************
1034  *
1035  * FUNCTION:    AcpiNsRemoveElement
1036  *
1037  * PARAMETERS:  ObjDesc             - Package object element list
1038  *              Index               - Index of element to remove
1039  *
1040  * RETURN:      None
1041  *
1042  * DESCRIPTION: Remove the requested element of a package and delete it.
1043  *
1044  *****************************************************************************/
1045
1046 static void
1047 AcpiNsRemoveElement (
1048     ACPI_OPERAND_OBJECT     *ObjDesc,
1049     UINT32                  Index)
1050 {
1051     ACPI_OPERAND_OBJECT     **Source;
1052     ACPI_OPERAND_OBJECT     **Dest;
1053     UINT32                  Count;
1054     UINT32                  NewCount;
1055     UINT32                  i;
1056
1057
1058     ACPI_FUNCTION_NAME (NsRemoveElement);
1059
1060
1061     Count = ObjDesc->Package.Count;
1062     NewCount = Count - 1;
1063
1064     Source = ObjDesc->Package.Elements;
1065     Dest = Source;
1066
1067     /* Examine all elements of the package object, remove matched index */
1068
1069     for (i = 0; i < Count; i++)
1070     {
1071         if (i == Index)
1072         {
1073             AcpiUtRemoveReference (*Source); /* Remove one ref for being in pkg */
1074             AcpiUtRemoveReference (*Source);
1075         }
1076         else
1077         {
1078             *Dest = *Source;
1079             Dest++;
1080         }
1081
1082         Source++;
1083     }
1084
1085     /* NULL terminate list and update the package count */
1086
1087     *Dest = NULL;
1088     ObjDesc->Package.Count = NewCount;
1089 }