sys/contrib/dev/acpica/resources/rscalc.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: rscalc - Calculate stream and list lengths
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2011, 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 #define __RSCALC_C__
  45
  46 #include <contrib/dev/acpica/include/acpi.h>
  47 #include <contrib/dev/acpica/include/accommon.h>
  48 #include <contrib/dev/acpica/include/acresrc.h>
  49 #include <contrib/dev/acpica/include/acnamesp.h>
  50
  51
  52 #define _COMPONENT          ACPI_RESOURCES
  53         ACPI_MODULE_NAME    ("rscalc")
  54
  55
  56 /* Local prototypes */
  57
  58 static UINT8
  59 AcpiRsCountSetBits (
  60     UINT16                  BitField);
  61
  62 static ACPI_RS_LENGTH
  63 AcpiRsStructOptionLength (
  64     ACPI_RESOURCE_SOURCE    *ResourceSource);
  65
  66 static UINT32
  67 AcpiRsStreamOptionLength (
  68     UINT32                  ResourceLength,
  69     UINT32                  MinimumTotalLength);
  70
  71
  72 /*******************************************************************************
  73  *
  74  * FUNCTION:    AcpiRsCountSetBits
  75  *
  76  * PARAMETERS:  BitField        - Field in which to count bits
  77  *
  78  * RETURN:      Number of bits set within the field
  79  *
  80  * DESCRIPTION: Count the number of bits set in a resource field. Used for
  81  *              (Short descriptor) interrupt and DMA lists.
  82  *
  83  ******************************************************************************/
  84
  85 static UINT8
  86 AcpiRsCountSetBits (
  87     UINT16                  BitField)
  88 {
  89     UINT8                   BitsSet;
  90
  91
  92     ACPI_FUNCTION_ENTRY ();
  93
  94
  95     for (BitsSet = 0; BitField; BitsSet++)
  96     {
  97         /* Zero the least significant bit that is set */
  98
  99         BitField &= (UINT16) (BitField - 1);
 100     }
 101
 102     return (BitsSet);
 103 }
 104
 105
 106 /*******************************************************************************
 107  *
 108  * FUNCTION:    AcpiRsStructOptionLength
 109  *
 110  * PARAMETERS:  ResourceSource      - Pointer to optional descriptor field
 111  *
 112  * RETURN:      Status
 113  *
 114  * DESCRIPTION: Common code to handle optional ResourceSourceIndex and
 115  *              ResourceSource fields in some Large descriptors. Used during
 116  *              list-to-stream conversion
 117  *
 118  ******************************************************************************/
 119
 120 static ACPI_RS_LENGTH
 121 AcpiRsStructOptionLength (
 122     ACPI_RESOURCE_SOURCE    *ResourceSource)
 123 {
 124     ACPI_FUNCTION_ENTRY ();
 125
 126
 127     /*
 128      * If the ResourceSource string is valid, return the size of the string
 129      * (StringLength includes the NULL terminator) plus the size of the
 130      * ResourceSourceIndex (1).
 131      */
 132     if (ResourceSource->StringPtr)
 133     {
 134         return ((ACPI_RS_LENGTH) (ResourceSource->StringLength + 1));
 135     }
 136
 137     return (0);
 138 }
 139
 140
 141 /*******************************************************************************
 142  *
 143  * FUNCTION:    AcpiRsStreamOptionLength
 144  *
 145  * PARAMETERS:  ResourceLength      - Length from the resource header
 146  *              MinimumTotalLength  - Minimum length of this resource, before
 147  *                                    any optional fields. Includes header size
 148  *
 149  * RETURN:      Length of optional string (0 if no string present)
 150  *
 151  * DESCRIPTION: Common code to handle optional ResourceSourceIndex and
 152  *              ResourceSource fields in some Large descriptors. Used during
 153  *              stream-to-list conversion
 154  *
 155  ******************************************************************************/
 156
 157 static UINT32
 158 AcpiRsStreamOptionLength (
 159     UINT32                  ResourceLength,
 160     UINT32                  MinimumAmlResourceLength)
 161 {
 162     UINT32                  StringLength = 0;
 163
 164
 165     ACPI_FUNCTION_ENTRY ();
 166
 167
 168     /*
 169      * The ResourceSourceIndex and ResourceSource are optional elements of some
 170      * Large-type resource descriptors.
 171      */
 172
 173     /*
 174      * If the length of the actual resource descriptor is greater than the ACPI
 175      * spec-defined minimum length, it means that a ResourceSourceIndex exists
 176      * and is followed by a (required) null terminated string. The string length
 177      * (including the null terminator) is the resource length minus the minimum
 178      * length, minus one byte for the ResourceSourceIndex itself.
 179      */
 180     if (ResourceLength > MinimumAmlResourceLength)
 181     {
 182         /* Compute the length of the optional string */
 183
 184         StringLength = ResourceLength - MinimumAmlResourceLength - 1;
 185     }
 186
 187     /*
 188      * Round the length up to a multiple of the native word in order to
 189      * guarantee that the entire resource descriptor is native word aligned
 190      */
 191     return ((UINT32) ACPI_ROUND_UP_TO_NATIVE_WORD (StringLength));
 192 }
 193
 194
 195 /*******************************************************************************
 196  *
 197  * FUNCTION:    AcpiRsGetAmlLength
 198  *
 199  * PARAMETERS:  Resource            - Pointer to the resource linked list
 200  *              SizeNeeded          - Where the required size is returned
 201  *
 202  * RETURN:      Status
 203  *
 204  * DESCRIPTION: Takes a linked list of internal resource descriptors and
 205  *              calculates the size buffer needed to hold the corresponding
 206  *              external resource byte stream.
 207  *
 208  ******************************************************************************/
 209
 210 ACPI_STATUS
 211 AcpiRsGetAmlLength (
 212     ACPI_RESOURCE           *Resource,
 213     ACPI_SIZE               *SizeNeeded)
 214 {
 215     ACPI_SIZE               AmlSizeNeeded = 0;
 216     ACPI_RS_LENGTH          TotalSize;
 217
 218
 219     ACPI_FUNCTION_TRACE (RsGetAmlLength);
 220
 221
 222     /* Traverse entire list of internal resource descriptors */
 223
 224     while (Resource)
 225     {
 226         /* Validate the descriptor type */
 227
 228         if (Resource->Type > ACPI_RESOURCE_TYPE_MAX)
 229         {
 230             return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
 231         }
 232
 233         /* Get the base size of the (external stream) resource descriptor */
 234
 235         TotalSize = AcpiGbl_AmlResourceSizes [Resource->Type];
 236
 237         /*
 238          * Augment the base size for descriptors with optional and/or
 239          * variable-length fields
 240          */
 241         switch (Resource->Type)
 242         {
 243         case ACPI_RESOURCE_TYPE_IRQ:
 244
 245             /* Length can be 3 or 2 */
 246
 247             if (Resource->Data.Irq.DescriptorLength == 2)
 248             {
 249                 TotalSize--;
 250             }
 251             break;
 252
 253
 254         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 255
 256             /* Length can be 1 or 0 */
 257
 258             if (Resource->Data.Irq.DescriptorLength == 0)
 259             {
 260                 TotalSize--;
 261             }
 262             break;
 263
 264
 265         case ACPI_RESOURCE_TYPE_VENDOR:
 266             /*
 267              * Vendor Defined Resource:
 268              * For a Vendor Specific resource, if the Length is between 1 and 7
 269              * it will be created as a Small Resource data type, otherwise it
 270              * is a Large Resource data type.
 271              */
 272             if (Resource->Data.Vendor.ByteLength > 7)
 273             {
 274                 /* Base size of a Large resource descriptor */
 275
 276                 TotalSize = sizeof (AML_RESOURCE_LARGE_HEADER);
 277             }
 278
 279             /* Add the size of the vendor-specific data */
 280
 281             TotalSize = (ACPI_RS_LENGTH)
 282                 (TotalSize + Resource->Data.Vendor.ByteLength);
 283             break;
 284
 285
 286         case ACPI_RESOURCE_TYPE_END_TAG:
 287             /*
 288              * End Tag:
 289              * We are done -- return the accumulated total size.
 290              */
 291             *SizeNeeded = AmlSizeNeeded + TotalSize;
 292
 293             /* Normal exit */
 294
 295             return_ACPI_STATUS (AE_OK);
 296
 297
 298         case ACPI_RESOURCE_TYPE_ADDRESS16:
 299             /*
 300              * 16-Bit Address Resource:
 301              * Add the size of the optional ResourceSource info
 302              */
 303             TotalSize = (ACPI_RS_LENGTH)
 304                 (TotalSize + AcpiRsStructOptionLength (
 305                                 &Resource->Data.Address16.ResourceSource));
 306             break;
 307
 308
 309         case ACPI_RESOURCE_TYPE_ADDRESS32:
 310             /*
 311              * 32-Bit Address Resource:
 312              * Add the size of the optional ResourceSource info
 313              */
 314             TotalSize = (ACPI_RS_LENGTH)
 315                 (TotalSize + AcpiRsStructOptionLength (
 316                                 &Resource->Data.Address32.ResourceSource));
 317             break;
 318
 319
 320         case ACPI_RESOURCE_TYPE_ADDRESS64:
 321             /*
 322              * 64-Bit Address Resource:
 323              * Add the size of the optional ResourceSource info
 324              */
 325             TotalSize = (ACPI_RS_LENGTH)
 326                 (TotalSize + AcpiRsStructOptionLength (
 327                                 &Resource->Data.Address64.ResourceSource));
 328             break;
 329
 330
 331         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 332             /*
 333              * Extended IRQ Resource:
 334              * Add the size of each additional optional interrupt beyond the
 335              * required 1 (4 bytes for each UINT32 interrupt number)
 336              */
 337             TotalSize = (ACPI_RS_LENGTH)
 338                 (TotalSize +
 339                 ((Resource->Data.ExtendedIrq.InterruptCount - 1) * 4) +
 340
 341                 /* Add the size of the optional ResourceSource info */
 342
 343                 AcpiRsStructOptionLength (
 344                     &Resource->Data.ExtendedIrq.ResourceSource));
 345             break;
 346
 347
 348         default:
 349             break;
 350         }
 351
 352         /* Update the total */
 353
 354         AmlSizeNeeded += TotalSize;
 355
 356         /* Point to the next object */
 357
 358         Resource = ACPI_ADD_PTR (ACPI_RESOURCE, Resource, Resource->Length);
 359     }
 360
 361     /* Did not find an EndTag resource descriptor */
 362
 363     return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
 364 }
 365
 366
 367 /*******************************************************************************
 368  *
 369  * FUNCTION:    AcpiRsGetListLength
 370  *
 371  * PARAMETERS:  AmlBuffer           - Pointer to the resource byte stream
 372  *              AmlBufferLength     - Size of AmlBuffer
 373  *              SizeNeeded          - Where the size needed is returned
 374  *
 375  * RETURN:      Status
 376  *
 377  * DESCRIPTION: Takes an external resource byte stream and calculates the size
 378  *              buffer needed to hold the corresponding internal resource
 379  *              descriptor linked list.
 380  *
 381  ******************************************************************************/
 382
 383 ACPI_STATUS
 384 AcpiRsGetListLength (
 385     UINT8                   *AmlBuffer,
 386     UINT32                  AmlBufferLength,
 387     ACPI_SIZE               *SizeNeeded)
 388 {
 389     ACPI_STATUS             Status;
 390     UINT8                   *EndAml;
 391     UINT8                   *Buffer;
 392     UINT32                  BufferSize;
 393     UINT16                  Temp16;
 394     UINT16                  ResourceLength;
 395     UINT32                  ExtraStructBytes;
 396     UINT8                   ResourceIndex;
 397     UINT8                   MinimumAmlResourceLength;
 398
 399
 400     ACPI_FUNCTION_TRACE (RsGetListLength);
 401
 402
 403     *SizeNeeded = 0;
 404     EndAml = AmlBuffer + AmlBufferLength;
 405
 406     /* Walk the list of AML resource descriptors */
 407
 408     while (AmlBuffer < EndAml)
 409     {
 410         /* Validate the Resource Type and Resource Length */
 411
 412         Status = AcpiUtValidateResource (AmlBuffer, &ResourceIndex);
 413         if (ACPI_FAILURE (Status))
 414         {
 415             return_ACPI_STATUS (Status);
 416         }
 417
 418         /* Get the resource length and base (minimum) AML size */
 419
 420         ResourceLength = AcpiUtGetResourceLength (AmlBuffer);
 421         MinimumAmlResourceLength = AcpiGbl_ResourceAmlSizes[ResourceIndex];
 422
 423         /*
 424          * Augment the size for descriptors with optional
 425          * and/or variable length fields
 426          */
 427         ExtraStructBytes = 0;
 428         Buffer = AmlBuffer + AcpiUtGetResourceHeaderLength (AmlBuffer);
 429
 430         switch (AcpiUtGetResourceType (AmlBuffer))
 431         {
 432         case ACPI_RESOURCE_NAME_IRQ:
 433             /*
 434              * IRQ Resource:
 435              * Get the number of bits set in the 16-bit IRQ mask
 436              */
 437             ACPI_MOVE_16_TO_16 (&Temp16, Buffer);
 438             ExtraStructBytes = AcpiRsCountSetBits (Temp16);
 439             break;
 440
 441
 442         case ACPI_RESOURCE_NAME_DMA:
 443             /*
 444              * DMA Resource:
 445              * Get the number of bits set in the 8-bit DMA mask
 446              */
 447             ExtraStructBytes = AcpiRsCountSetBits (*Buffer);
 448             break;
 449
 450
 451         case ACPI_RESOURCE_NAME_VENDOR_SMALL:
 452         case ACPI_RESOURCE_NAME_VENDOR_LARGE:
 453             /*
 454              * Vendor Resource:
 455              * Get the number of vendor data bytes
 456              */
 457             ExtraStructBytes = ResourceLength;
 458             break;
 459
 460
 461         case ACPI_RESOURCE_NAME_END_TAG:
 462             /*
 463              * End Tag:
 464              * This is the normal exit, add size of EndTag
 465              */
 466             *SizeNeeded += ACPI_RS_SIZE_MIN;
 467             return_ACPI_STATUS (AE_OK);
 468
 469
 470         case ACPI_RESOURCE_NAME_ADDRESS32:
 471         case ACPI_RESOURCE_NAME_ADDRESS16:
 472         case ACPI_RESOURCE_NAME_ADDRESS64:
 473             /*
 474              * Address Resource:
 475              * Add the size of the optional ResourceSource
 476              */
 477             ExtraStructBytes = AcpiRsStreamOptionLength (
 478                 ResourceLength, MinimumAmlResourceLength);
 479             break;
 480
 481
 482         case ACPI_RESOURCE_NAME_EXTENDED_IRQ:
 483             /*
 484              * Extended IRQ Resource:
 485              * Using the InterruptTableLength, add 4 bytes for each additional
 486              * interrupt. Note: at least one interrupt is required and is
 487              * included in the minimum descriptor size (reason for the -1)
 488              */
 489             ExtraStructBytes = (Buffer[1] - 1) * sizeof (UINT32);
 490
 491             /* Add the size of the optional ResourceSource */
 492
 493             ExtraStructBytes += AcpiRsStreamOptionLength (
 494                 ResourceLength - ExtraStructBytes, MinimumAmlResourceLength);
 495             break;
 496
 497
 498         default:
 499             break;
 500         }
 501
 502         /*
 503          * Update the required buffer size for the internal descriptor structs
 504          *
 505          * Important: Round the size up for the appropriate alignment. This
 506          * is a requirement on IA64.
 507          */
 508         BufferSize = AcpiGbl_ResourceStructSizes[ResourceIndex] +
 509                         ExtraStructBytes;
 510         BufferSize = (UINT32) ACPI_ROUND_UP_TO_NATIVE_WORD (BufferSize);
 511
 512         *SizeNeeded += BufferSize;
 513
 514         ACPI_DEBUG_PRINT ((ACPI_DB_RESOURCES,
 515             "Type %.2X, AmlLength %.2X InternalLength %.2X\n",
 516             AcpiUtGetResourceType (AmlBuffer),
 517             AcpiUtGetDescriptorLength (AmlBuffer), BufferSize));
 518
 519         /*
 520          * Point to the next resource within the AML stream using the length
 521          * contained in the resource descriptor header
 522          */
 523         AmlBuffer += AcpiUtGetDescriptorLength (AmlBuffer);
 524     }
 525
 526     /* Did not find an EndTag resource descriptor */
 527
 528     return_ACPI_STATUS (AE_AML_NO_RESOURCE_END_TAG);
 529 }
 530
 531
 532 /*******************************************************************************
 533  *
 534  * FUNCTION:    AcpiRsGetPciRoutingTableLength
 535  *
 536  * PARAMETERS:  PackageObject           - Pointer to the package object
 537  *              BufferSizeNeeded        - UINT32 pointer of the size buffer
 538  *                                        needed to properly return the
 539  *                                        parsed data
 540  *
 541  * RETURN:      Status
 542  *
 543  * DESCRIPTION: Given a package representing a PCI routing table, this
 544  *              calculates the size of the corresponding linked list of
 545  *              descriptions.
 546  *
 547  ******************************************************************************/
 548
 549 ACPI_STATUS
 550 AcpiRsGetPciRoutingTableLength (
 551     ACPI_OPERAND_OBJECT     *PackageObject,
 552     ACPI_SIZE               *BufferSizeNeeded)
 553 {
 554     UINT32                  NumberOfElements;
 555     ACPI_SIZE               TempSizeNeeded = 0;
 556     ACPI_OPERAND_OBJECT     **TopObjectList;
 557     UINT32                  Index;
 558     ACPI_OPERAND_OBJECT     *PackageElement;
 559     ACPI_OPERAND_OBJECT     **SubObjectList;
 560     BOOLEAN                 NameFound;
 561     UINT32                  TableIndex;
 562
 563
 564     ACPI_FUNCTION_TRACE (RsGetPciRoutingTableLength);
 565
 566
 567     NumberOfElements = PackageObject->Package.Count;
 568
 569     /*
 570      * Calculate the size of the return buffer.
 571      * The base size is the number of elements * the sizes of the
 572      * structures.  Additional space for the strings is added below.
 573      * The minus one is to subtract the size of the UINT8 Source[1]
 574      * member because it is added below.
 575      *
 576      * But each PRT_ENTRY structure has a pointer to a string and
 577      * the size of that string must be found.
 578      */
 579     TopObjectList = PackageObject->Package.Elements;
 580
 581     for (Index = 0; Index < NumberOfElements; Index++)
 582     {
 583         /* Dereference the sub-package */
 584
 585         PackageElement = *TopObjectList;
 586
 587         /* We must have a valid Package object */
 588
 589         if (!PackageElement ||
 590             (PackageElement->Common.Type != ACPI_TYPE_PACKAGE))
 591         {
 592             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 593         }
 594
 595         /*
 596          * The SubObjectList will now point to an array of the
 597          * four IRQ elements: Address, Pin, Source and SourceIndex
 598          */
 599         SubObjectList = PackageElement->Package.Elements;
 600
 601         /* Scan the IrqTableElements for the Source Name String */
 602
 603         NameFound = FALSE;
 604
 605         for (TableIndex = 0; TableIndex < 4 && !NameFound; TableIndex++)
 606         {
 607             if (*SubObjectList && /* Null object allowed */
 608
 609                 ((ACPI_TYPE_STRING ==
 610                     (*SubObjectList)->Common.Type) ||
 611
 612                 ((ACPI_TYPE_LOCAL_REFERENCE ==
 613                     (*SubObjectList)->Common.Type) &&
 614
 615                     ((*SubObjectList)->Reference.Class ==
 616                         ACPI_REFCLASS_NAME))))
 617             {
 618                 NameFound = TRUE;
 619             }
 620             else
 621             {
 622                 /* Look at the next element */
 623
 624                 SubObjectList++;
 625             }
 626         }
 627
 628         TempSizeNeeded += (sizeof (ACPI_PCI_ROUTING_TABLE) - 4);
 629
 630         /* Was a String type found? */
 631
 632         if (NameFound)
 633         {
 634             if ((*SubObjectList)->Common.Type == ACPI_TYPE_STRING)
 635             {
 636                 /*
 637                  * The length String.Length field does not include the
 638                  * terminating NULL, add 1
 639                  */
 640                 TempSizeNeeded += ((ACPI_SIZE)
 641                     (*SubObjectList)->String.Length + 1);
 642             }
 643             else
 644             {
 645                 TempSizeNeeded += AcpiNsGetPathnameLength (
 646                                     (*SubObjectList)->Reference.Node);
 647             }
 648         }
 649         else
 650         {
 651             /*
 652              * If no name was found, then this is a NULL, which is
 653              * translated as a UINT32 zero.
 654              */
 655             TempSizeNeeded += sizeof (UINT32);
 656         }
 657
 658         /* Round up the size since each element must be aligned */
 659
 660         TempSizeNeeded = ACPI_ROUND_UP_TO_64BIT (TempSizeNeeded);
 661
 662         /* Point to the next ACPI_OPERAND_OBJECT */
 663
 664         TopObjectList++;
 665     }
 666
 667     /*
 668      * Add an extra element to the end of the list, essentially a
 669      * NULL terminator
 670      */
 671     *BufferSizeNeeded = TempSizeNeeded + sizeof (ACPI_PCI_ROUTING_TABLE);
 672     return_ACPI_STATUS (AE_OK);
 673 }