sys/contrib/dev/acpica/source/tools/acpiexec/aeregion.c

   1 /******************************************************************************
   2  *
   3  * Module Name: aeregion - Handler for operation regions
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2019, 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  * Alternatively, you may choose to be licensed under the terms of the
 117  * following license:
 118  *
 119  * Redistribution and use in source and binary forms, with or without
 120  * modification, are permitted provided that the following conditions
 121  * are met:
 122  * 1. Redistributions of source code must retain the above copyright
 123  *    notice, this list of conditions, and the following disclaimer,
 124  *    without modification.
 125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 126  *    substantially similar to the "NO WARRANTY" disclaimer below
 127  *    ("Disclaimer") and any redistribution must be conditioned upon
 128  *    including a substantially similar Disclaimer requirement for further
 129  *    binary redistribution.
 130  * 3. Neither the names of the above-listed copyright holders nor the names
 131  *    of any contributors may be used to endorse or promote products derived
 132  *    from this software without specific prior written permission.
 133  *
 134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 145  *
 146  * Alternatively, you may choose to be licensed under the terms of the
 147  * GNU General Public License ("GPL") version 2 as published by the Free
 148  * Software Foundation.
 149  *
 150  *****************************************************************************/
 151
 152 #include "aecommon.h"
 153
 154 #define _COMPONENT          ACPI_TOOLS
 155         ACPI_MODULE_NAME    ("aeregion")
 156
 157
 158 static AE_DEBUG_REGIONS     AeRegions;
 159
 160
 161 /******************************************************************************
 162  *
 163  * FUNCTION:    AeRegionHandler
 164  *
 165  * PARAMETERS:  Standard region handler parameters
 166  *
 167  * RETURN:      Status
 168  *
 169  * DESCRIPTION: Test handler - Handles some dummy regions via memory that can
 170  *              be manipulated in Ring 3. Simulates actual reads and writes.
 171  *
 172  *****************************************************************************/
 173
 174 ACPI_STATUS
 175 AeRegionHandler (
 176     UINT32                  Function,
 177     ACPI_PHYSICAL_ADDRESS   Address,
 178     UINT32                  BitWidth,
 179     UINT64                  *Value,
 180     void                    *HandlerContext,
 181     void                    *RegionContext)
 182 {
 183
 184     ACPI_OPERAND_OBJECT     *RegionObject = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, RegionContext);
 185     UINT8                   *Buffer = ACPI_CAST_PTR (UINT8, Value);
 186     UINT8                   *OldBuffer;
 187     UINT8                   *NewBuffer;
 188     ACPI_PHYSICAL_ADDRESS   BaseAddress;
 189     ACPI_PHYSICAL_ADDRESS   BaseAddressEnd;
 190     ACPI_PHYSICAL_ADDRESS   RegionAddress;
 191     ACPI_PHYSICAL_ADDRESS   RegionAddressEnd;
 192     UINT32                  Length;
 193     UINT8                   DataLength;
 194     UINT8                   *DataBuffer;
 195     BOOLEAN                 BufferExists;
 196     BOOLEAN                 BufferResize;
 197     AE_REGION               *RegionElement;
 198     void                    *BufferValue;
 199     ACPI_STATUS             Status;
 200     UINT32                  ByteWidth;
 201     UINT32                  RegionLength;
 202     UINT32                  i;
 203     UINT8                   SpaceId;
 204     ACPI_CONNECTION_INFO    *MyContext;
 205     UINT32                  Value1;
 206     UINT32                  Value2;
 207     ACPI_RESOURCE           *Resource;
 208
 209
 210     ACPI_FUNCTION_NAME (AeRegionHandler);
 211
 212
 213     /* If the object is not a region, simply return */
 214
 215     if (RegionObject->Region.Type != ACPI_TYPE_REGION)
 216     {
 217         return (AE_OK);
 218     }
 219
 220     /* Check that we actually got back our context parameter */
 221
 222     if (HandlerContext != &AeMyContext)
 223     {
 224         AcpiOsPrintf (
 225             "Region handler received incorrect context %p, should be %p\n",
 226             HandlerContext, &AeMyContext);
 227     }
 228
 229     MyContext = ACPI_CAST_PTR (ACPI_CONNECTION_INFO, HandlerContext);
 230
 231     /*
 232      * Find the region's address space and length before searching
 233      * the linked list.
 234      */
 235     BaseAddress = RegionObject->Region.Address;
 236     Length = RegionObject->Region.Length;
 237     SpaceId = RegionObject->Region.SpaceId;
 238
 239     ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
 240         "Operation Region request on %s at 0x%X, BitWidth 0x%X, RegionLength 0x%X\n",
 241         AcpiUtGetRegionName (RegionObject->Region.SpaceId),
 242         (UINT32) Address, BitWidth, (UINT32) Length));
 243
 244     /*
 245      * Region support can be disabled with the -do option.
 246      * We use this to support dynamically loaded tables where we pass a valid
 247      * address to the AML.
 248      */
 249     if (AcpiGbl_DbOpt_NoRegionSupport)
 250     {
 251         BufferValue = ACPI_TO_POINTER (Address);
 252         ByteWidth = (BitWidth / 8);
 253
 254         if (BitWidth % 8)
 255         {
 256             ByteWidth += 1;
 257         }
 258         goto DoFunction;
 259     }
 260
 261     switch (SpaceId)
 262     {
 263     case ACPI_ADR_SPACE_SYSTEM_IO:
 264         /*
 265          * For I/O space, exercise the port validation
 266          * Note: ReadPort currently always returns all ones, length=BitLength
 267          */
 268         switch (Function & ACPI_IO_MASK)
 269         {
 270         case ACPI_READ:
 271
 272             if (BitWidth == 64)
 273             {
 274                 /* Split the 64-bit request into two 32-bit requests */
 275
 276                 Status = AcpiHwReadPort (Address, &Value1, 32);
 277                 ACPI_CHECK_OK (AcpiHwReadPort, Status);
 278                 Status = AcpiHwReadPort (Address+4, &Value2, 32);
 279                 ACPI_CHECK_OK (AcpiHwReadPort, Status);
 280
 281                 *Value = Value1 | ((UINT64) Value2 << 32);
 282             }
 283             else
 284             {
 285                 Status = AcpiHwReadPort (Address, &Value1, BitWidth);
 286                 ACPI_CHECK_OK (AcpiHwReadPort, Status);
 287                 *Value = (UINT64) Value1;
 288             }
 289             break;
 290
 291         case ACPI_WRITE:
 292
 293             if (BitWidth == 64)
 294             {
 295                 /* Split the 64-bit request into two 32-bit requests */
 296
 297                 Status = AcpiHwWritePort (Address, ACPI_LODWORD (*Value), 32);
 298                 ACPI_CHECK_OK (AcpiHwWritePort, Status);
 299                 Status = AcpiHwWritePort (Address+4, ACPI_HIDWORD (*Value), 32);
 300                 ACPI_CHECK_OK (AcpiHwWritePort, Status);
 301             }
 302             else
 303             {
 304                 Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth);
 305                 ACPI_CHECK_OK (AcpiHwWritePort, Status);
 306             }
 307             break;
 308
 309         default:
 310
 311             Status = AE_BAD_PARAMETER;
 312             break;
 313         }
 314
 315         if (ACPI_FAILURE (Status))
 316         {
 317             return (Status);
 318         }
 319
 320         /* Now go ahead and simulate the hardware */
 321         break;
 322
 323     /*
 324      * SMBus and GenericSerialBus support the various bidirectional
 325      * protocols.
 326      */
 327     case ACPI_ADR_SPACE_SMBUS:
 328     case ACPI_ADR_SPACE_GSBUS:  /* ACPI 5.0 */
 329
 330         Status = AcpiExGetProtocolBufferLength ((Function >> 16), &Length);
 331         if (ACPI_FAILURE (Status))
 332         {
 333             AcpiOsPrintf ("AcpiExec: Invalid SMbus/GSbus protocol ID: 0x%X\n",
 334                 (Function >> 16));
 335             return (Status);
 336         }
 337
 338         /* Adjust for fixed SMBus buffer size */
 339
 340         if ((SpaceId == ACPI_ADR_SPACE_SMBUS) &&
 341             (Length > ACPI_SMBUS_DATA_SIZE))
 342         {
 343             Length = ACPI_SMBUS_DATA_SIZE; /* SMBus buffer is fixed-length */
 344         }
 345
 346         if (AcpiGbl_DisplayRegionAccess)
 347         {
 348             AcpiOsPrintf ("AcpiExec: %s "
 349                 "%s: Attr %X Addr %.4X BaseAddr %.4X Length %.2X BitWidth %X BufLen %X\n",
 350                 AcpiUtGetRegionName (SpaceId),
 351                 (Function & ACPI_IO_MASK) ? "Write" : "Read ",
 352                 (UINT32) (Function >> 16),
 353                 (UINT32) Address, (UINT32) BaseAddress,
 354                 Length, BitWidth, Buffer[1]);
 355
 356             /* GenericSerialBus has a Connection() parameter */
 357
 358             if ((SpaceId == ACPI_ADR_SPACE_GSBUS) && MyContext)
 359             {
 360                 Status = AcpiBufferToResource (MyContext->Connection,
 361                     MyContext->Length, &Resource);
 362                 if (ACPI_SUCCESS (Status))
 363                 {
 364                     ACPI_FREE (Resource);
 365                 }
 366
 367                 AcpiOsPrintf (" [AccessLength %.2X Connnection %p]",
 368                     MyContext->AccessLength, MyContext->Connection);
 369             }
 370
 371             AcpiOsPrintf ("\n");
 372         }
 373
 374         DataBuffer = &Buffer[2];
 375         DataLength = (UINT8) Length;
 376
 377         /* Setup the return buffer. Note: ASLTS depends on these fill values */
 378
 379         if (Length == ACPI_MAX_GSBUS_DATA_SIZE)
 380         {
 381             DataLength = 0x20; /* For ASLTS only */
 382         }
 383
 384         for (i = 0; i < Length; i++)
 385         {
 386             DataBuffer[i] = (UINT8) (0xA0 + i);
 387         }
 388
 389         Buffer[0] = 0;                  /* Return Status, OK */
 390         Buffer[1] = DataLength;         /* Length of valid data */
 391         return (AE_OK);
 392
 393     case ACPI_ADR_SPACE_IPMI: /* ACPI 4.0 */
 394
 395         if (AcpiGbl_DisplayRegionAccess)
 396         {
 397             AcpiOsPrintf ("AcpiExec: IPMI "
 398                 "%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X\n",
 399                 (Function & ACPI_IO_MASK) ? "Write" : "Read ",
 400                 (UINT32) (Function >> 16), (UINT32) Address, (UINT32) BaseAddress,
 401                 Length, BitWidth, Buffer[1]);
 402         }
 403
 404         /*
 405          * Regardless of a READ or WRITE, this handler is passed a 66-byte
 406          * buffer in which to return the IPMI status/length/data.
 407          *
 408          * Return some example data to show use of the bidirectional buffer
 409          */
 410         Buffer[0] = 0;                      /* Status byte */
 411         Buffer[1] = ACPI_IPMI_DATA_SIZE;    /* Return buffer data length */
 412         Buffer[2] = 0;                      /* Completion code */
 413         Buffer[3] = 0;                      /* Reserved */
 414
 415         /*
 416          * Fill the 66-byte buffer with the return data.
 417          * Note: ASLTS depends on these fill values.
 418          */
 419         for (i = 4; i < ACPI_IPMI_BUFFER_SIZE; i++)
 420         {
 421             Buffer[i] = (UINT8) (i);
 422         }
 423         return (AE_OK);
 424
 425     /*
 426      * GPIO has some special semantics:
 427      * 1) Address is the pin number index into the Connection() pin list
 428      * 2) BitWidth is the actual number of bits (pins) defined by the field
 429      */
 430     case ACPI_ADR_SPACE_GPIO: /* ACPI 5.0 */
 431
 432         if (AcpiGbl_DisplayRegionAccess)
 433         {
 434             AcpiOsPrintf ("AcpiExec: GPIO "
 435                 "%s: Address %.4X Length %X BitWidth %X Conn %p\n",
 436                 (Function & ACPI_IO_MASK) ? "Write" : "Read ",
 437                 (UINT32) Address, Length, BitWidth, MyContext->Connection);
 438         }
 439
 440         /* Now perform the "normal" SystemMemory handling, for AcpiExec only */
 441         break;
 442
 443     default:
 444         break;
 445     }
 446
 447     /*
 448      * Search through the linked list for this region's buffer
 449      */
 450     BufferExists = FALSE;
 451     BufferResize = FALSE;
 452     RegionElement = AeRegions.RegionList;
 453
 454     if (AeRegions.NumberOfRegions)
 455     {
 456         BaseAddressEnd = BaseAddress + Length - 1;
 457         while (!BufferExists && RegionElement)
 458         {
 459             RegionAddress = RegionElement->Address;
 460             RegionAddressEnd = RegionElement->Address + RegionElement->Length - 1;
 461             RegionLength = RegionElement->Length;
 462
 463             /*
 464              * Overlapping Region Support
 465              *
 466              * While searching through the region buffer list, determine if an
 467              * overlap exists between the requested buffer space and the current
 468              * RegionElement space. If there is an overlap then replace the old
 469              * buffer with a new buffer of increased size before continuing to
 470              * do the read or write
 471              */
 472             if (RegionElement->SpaceId != SpaceId ||
 473                 BaseAddressEnd < RegionAddress ||
 474                 BaseAddress > RegionAddressEnd)
 475             {
 476                 /*
 477                  * Requested buffer is outside of the current RegionElement
 478                  * bounds
 479                  */
 480                 RegionElement = RegionElement->NextRegion;
 481             }
 482             else
 483             {
 484                 /*
 485                  * Some amount of buffer space sharing exists. There are 4 cases
 486                  * to consider:
 487                  *
 488                  * 1. Right overlap
 489                  * 2. Left overlap
 490                  * 3. Left and right overlap
 491                  * 4. Fully contained - no resizing required
 492                  */
 493                 BufferExists = TRUE;
 494
 495                 if ((BaseAddress >= RegionAddress) &&
 496                     (BaseAddress <= RegionAddressEnd) &&
 497                     (BaseAddressEnd > RegionAddressEnd))
 498                 {
 499                     /* Right overlap */
 500
 501                     RegionElement->Length = (UINT32) (BaseAddress -
 502                         RegionAddress + Length);
 503                     BufferResize = TRUE;
 504                 }
 505
 506                 else if ((BaseAddressEnd >= RegionAddress) &&
 507                          (BaseAddressEnd <= RegionAddressEnd) &&
 508                          (BaseAddress < RegionAddress))
 509                 {
 510                     /* Left overlap */
 511
 512                     RegionElement->Address = BaseAddress;
 513                     RegionElement->Length = (UINT32) (RegionAddress -
 514                         BaseAddress + RegionElement->Length);
 515                     BufferResize = TRUE;
 516                 }
 517
 518                 else if ((BaseAddress < RegionAddress) &&
 519                          (BaseAddressEnd > RegionAddressEnd))
 520                 {
 521                     /* Left and right overlap */
 522
 523                     RegionElement->Address = BaseAddress;
 524                     RegionElement->Length = Length;
 525                     BufferResize = TRUE;
 526                 }
 527
 528                 /*
 529                  * only remaining case is fully contained for which we don't
 530                  * need to do anything
 531                  */
 532                 if (BufferResize)
 533                 {
 534                     NewBuffer = AcpiOsAllocate (RegionElement->Length);
 535                     if (!NewBuffer)
 536                     {
 537                         return (AE_NO_MEMORY);
 538                     }
 539
 540                     OldBuffer = RegionElement->Buffer;
 541                     RegionElement->Buffer = NewBuffer;
 542                     NewBuffer = NULL;
 543
 544                     /* Initialize the region with the default fill value */
 545
 546                     memset (RegionElement->Buffer,
 547                         AcpiGbl_RegionFillValue, RegionElement->Length);
 548
 549                     /*
 550                      * Get BufferValue to point (within the new buffer) to the
 551                      * base address of the old buffer
 552                      */
 553                     BufferValue = (UINT8 *) RegionElement->Buffer +
 554                         (UINT64) RegionAddress -
 555                         (UINT64) RegionElement->Address;
 556
 557                     /*
 558                      * Copy the old buffer to its same location within the new
 559                      * buffer
 560                      */
 561                     memcpy (BufferValue, OldBuffer, RegionLength);
 562                     AcpiOsFree (OldBuffer);
 563                 }
 564             }
 565         }
 566     }
 567
 568     /*
 569      * If the Region buffer does not exist, create it now
 570      */
 571     if (!BufferExists)
 572     {
 573         /* Do the memory allocations first */
 574
 575         RegionElement = AcpiOsAllocate (sizeof (AE_REGION));
 576         if (!RegionElement)
 577         {
 578             return (AE_NO_MEMORY);
 579         }
 580
 581         RegionElement->Buffer = AcpiOsAllocate (Length);
 582         if (!RegionElement->Buffer)
 583         {
 584             AcpiOsFree (RegionElement);
 585             return (AE_NO_MEMORY);
 586         }
 587
 588         /* Initialize the region with the default fill value */
 589
 590         memset (RegionElement->Buffer, AcpiGbl_RegionFillValue, Length);
 591
 592         RegionElement->Address      = BaseAddress;
 593         RegionElement->Length       = Length;
 594         RegionElement->SpaceId      = SpaceId;
 595         RegionElement->NextRegion   = NULL;
 596
 597         /*
 598          * Increment the number of regions and put this one
 599          * at the head of the list as it will probably get accessed
 600          * more often anyway.
 601          */
 602         AeRegions.NumberOfRegions += 1;
 603
 604         if (AeRegions.RegionList)
 605         {
 606             RegionElement->NextRegion = AeRegions.RegionList;
 607         }
 608
 609         AeRegions.RegionList = RegionElement;
 610     }
 611
 612     /* Calculate the size of the memory copy */
 613
 614     ByteWidth = (BitWidth / 8);
 615     if (BitWidth % 8)
 616     {
 617         ByteWidth += 1;
 618     }
 619
 620     /*
 621      * The buffer exists and is pointed to by RegionElement.
 622      * We now need to verify the request is valid and perform the operation.
 623      *
 624      * NOTE: RegionElement->Length is in bytes, therefore it we compare against
 625      * ByteWidth (see above)
 626      */
 627     if ((RegionObject->Region.SpaceId != ACPI_ADR_SPACE_GPIO) &&
 628         ((UINT64) Address + ByteWidth) >
 629         ((UINT64)(RegionElement->Address) + RegionElement->Length))
 630     {
 631         ACPI_WARNING ((AE_INFO,
 632             "Request on [%4.4s] is beyond region limit "
 633             "Req-0x%X+0x%X, Base=0x%X, Len-0x%X",
 634             (RegionObject->Region.Node)->Name.Ascii, (UINT32) Address,
 635             ByteWidth, (UINT32)(RegionElement->Address),
 636             RegionElement->Length));
 637
 638         return (AE_AML_REGION_LIMIT);
 639     }
 640
 641     /*
 642      * Get BufferValue to point to the "address" in the buffer
 643      */
 644     BufferValue = ((UINT8 *) RegionElement->Buffer +
 645         ((UINT64) Address - (UINT64) RegionElement->Address));
 646
 647 DoFunction:
 648     /*
 649      * Perform a read or write to the buffer space
 650      */
 651     switch (Function)
 652     {
 653     case ACPI_READ:
 654         /*
 655          * Set the pointer Value to whatever is in the buffer
 656          */
 657         memcpy (Value, BufferValue, ByteWidth);
 658         break;
 659
 660     case ACPI_WRITE:
 661         /*
 662          * Write the contents of Value to the buffer
 663          */
 664         memcpy (BufferValue, Value, ByteWidth);
 665         break;
 666
 667     default:
 668
 669         return (AE_BAD_PARAMETER);
 670     }
 671
 672     if (AcpiGbl_DisplayRegionAccess)
 673     {
 674         switch (SpaceId)
 675         {
 676         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
 677
 678             AcpiOsPrintf ("AcpiExec: SystemMemory "
 679                 "%s: Val %.8X Addr %.4X BitWidth %X [REGION: BaseAddr %.4X Len %.2X]\n",
 680                 (Function & ACPI_IO_MASK) ? "Write" : "Read ",
 681                 (UINT32) *Value, (UINT32) Address, BitWidth, (UINT32) BaseAddress, Length);
 682             break;
 683
 684         case ACPI_ADR_SPACE_GSBUS:
 685
 686             AcpiOsPrintf ("AcpiExec: GenericSerialBus\n");
 687             break;
 688
 689         case ACPI_ADR_SPACE_GPIO:   /* ACPI 5.0 */
 690
 691             /* This space is required to always be ByteAcc */
 692
 693             Status = AcpiBufferToResource (MyContext->Connection,
 694                 MyContext->Length, &Resource);
 695
 696             AcpiOsPrintf ("AcpiExec: GeneralPurposeIo "
 697                 "%s: %.8X Addr %.4X BaseAddr %.4X Length %.2X "
 698                 "BitWidth %X AccLen %.2X Conn %p\n",
 699                 (Function & ACPI_IO_MASK) ? "Write" : "Read ", (UINT32) *Value,
 700                 (UINT32) Address, (UINT32) BaseAddress, Length, BitWidth,
 701                 MyContext->AccessLength, MyContext->Connection);
 702             if (ACPI_SUCCESS (Status))
 703             {
 704                 ACPI_FREE (Resource);
 705             }
 706             break;
 707
 708         default:
 709
 710             AcpiOsPrintf ("AcpiExec: Region access on SpaceId %2.2X\n", SpaceId);
 711             break;
 712         }
 713     }
 714
 715     return (AE_OK);
 716 }