sys/contrib/dev/acpica/components/executer/exfield.c

   1 /******************************************************************************
   2  *
   3  * Module Name: exfield - ACPI AML (p-code) execution - field manipulation
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2015, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include <contrib/dev/acpica/include/acpi.h>
  45 #include <contrib/dev/acpica/include/accommon.h>
  46 #include <contrib/dev/acpica/include/acdispat.h>
  47 #include <contrib/dev/acpica/include/acinterp.h>
  48 #include <contrib/dev/acpica/include/amlcode.h>
  49
  50
  51 #define _COMPONENT          ACPI_EXECUTER
  52         ACPI_MODULE_NAME    ("exfield")
  53
  54 /* Local prototypes */
  55
  56 static UINT32
  57 AcpiExGetSerialAccessLength (
  58     UINT32                  AccessorType,
  59     UINT32                  AccessLength);
  60
  61
  62 /*******************************************************************************
  63  *
  64  * FUNCTION:    AcpiExGetSerialAccessLength
  65  *
  66  * PARAMETERS:  AccessorType    - The type of the protocol indicated by region
  67  *                                field access attributes
  68  *              AccessLength    - The access length of the region field
  69  *
  70  * RETURN:      Decoded access length
  71  *
  72  * DESCRIPTION: This routine returns the length of the GenericSerialBus
  73  *              protocol bytes
  74  *
  75  ******************************************************************************/
  76
  77 static UINT32
  78 AcpiExGetSerialAccessLength (
  79     UINT32                  AccessorType,
  80     UINT32                  AccessLength)
  81 {
  82     UINT32                  Length;
  83
  84
  85     switch (AccessorType)
  86     {
  87     case AML_FIELD_ATTRIB_QUICK:
  88
  89         Length = 0;
  90         break;
  91
  92     case AML_FIELD_ATTRIB_SEND_RCV:
  93     case AML_FIELD_ATTRIB_BYTE:
  94
  95         Length = 1;
  96         break;
  97
  98     case AML_FIELD_ATTRIB_WORD:
  99     case AML_FIELD_ATTRIB_WORD_CALL:
 100
 101         Length = 2;
 102         break;
 103
 104     case AML_FIELD_ATTRIB_MULTIBYTE:
 105     case AML_FIELD_ATTRIB_RAW_BYTES:
 106     case AML_FIELD_ATTRIB_RAW_PROCESS:
 107
 108         Length = AccessLength;
 109         break;
 110
 111     case AML_FIELD_ATTRIB_BLOCK:
 112     case AML_FIELD_ATTRIB_BLOCK_CALL:
 113     default:
 114
 115         Length = ACPI_GSBUS_BUFFER_SIZE - 2;
 116         break;
 117     }
 118
 119     return (Length);
 120 }
 121
 122
 123 /*******************************************************************************
 124  *
 125  * FUNCTION:    AcpiExReadDataFromField
 126  *
 127  * PARAMETERS:  WalkState           - Current execution state
 128  *              ObjDesc             - The named field
 129  *              RetBufferDesc       - Where the return data object is stored
 130  *
 131  * RETURN:      Status
 132  *
 133  * DESCRIPTION: Read from a named field. Returns either an Integer or a
 134  *              Buffer, depending on the size of the field.
 135  *
 136  ******************************************************************************/
 137
 138 ACPI_STATUS
 139 AcpiExReadDataFromField (
 140     ACPI_WALK_STATE         *WalkState,
 141     ACPI_OPERAND_OBJECT     *ObjDesc,
 142     ACPI_OPERAND_OBJECT     **RetBufferDesc)
 143 {
 144     ACPI_STATUS             Status;
 145     ACPI_OPERAND_OBJECT     *BufferDesc;
 146     ACPI_SIZE               Length;
 147     void                    *Buffer;
 148     UINT32                  Function;
 149     UINT16                  AccessorType;
 150
 151
 152     ACPI_FUNCTION_TRACE_PTR (ExReadDataFromField, ObjDesc);
 153
 154
 155     /* Parameter validation */
 156
 157     if (!ObjDesc)
 158     {
 159         return_ACPI_STATUS (AE_AML_NO_OPERAND);
 160     }
 161     if (!RetBufferDesc)
 162     {
 163         return_ACPI_STATUS (AE_BAD_PARAMETER);
 164     }
 165
 166     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
 167     {
 168         /*
 169          * If the BufferField arguments have not been previously evaluated,
 170          * evaluate them now and save the results.
 171          */
 172         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
 173         {
 174             Status = AcpiDsGetBufferFieldArguments (ObjDesc);
 175             if (ACPI_FAILURE (Status))
 176             {
 177                 return_ACPI_STATUS (Status);
 178             }
 179         }
 180     }
 181     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 182              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||
 183               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS ||
 184               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))
 185     {
 186         /*
 187          * This is an SMBus, GSBus or IPMI read. We must create a buffer to hold
 188          * the data and then directly access the region handler.
 189          *
 190          * Note: SMBus and GSBus protocol value is passed in upper 16-bits of Function
 191          */
 192         if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)
 193         {
 194             Length = ACPI_SMBUS_BUFFER_SIZE;
 195             Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);
 196         }
 197         else if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS)
 198         {
 199             AccessorType = ObjDesc->Field.Attribute;
 200             Length = AcpiExGetSerialAccessLength (AccessorType,
 201                 ObjDesc->Field.AccessLength);
 202
 203             /*
 204              * Add additional 2 bytes for the GenericSerialBus data buffer:
 205              *
 206              *     Status;      (Byte 0 of the data buffer)
 207              *     Length;      (Byte 1 of the data buffer)
 208              *     Data[x-1];   (Bytes 2-x of the arbitrary length data buffer)
 209              */
 210             Length += 2;
 211             Function = ACPI_READ | (AccessorType << 16);
 212         }
 213         else /* IPMI */
 214         {
 215             Length = ACPI_IPMI_BUFFER_SIZE;
 216             Function = ACPI_READ;
 217         }
 218
 219         BufferDesc = AcpiUtCreateBufferObject (Length);
 220         if (!BufferDesc)
 221         {
 222             return_ACPI_STATUS (AE_NO_MEMORY);
 223         }
 224
 225         /* Lock entire transaction if requested */
 226
 227         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 228
 229         /* Call the region handler for the read */
 230
 231         Status = AcpiExAccessRegion (ObjDesc, 0,
 232                     ACPI_CAST_PTR (UINT64, BufferDesc->Buffer.Pointer),
 233                     Function);
 234         AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 235         goto Exit;
 236     }
 237
 238     /*
 239      * Allocate a buffer for the contents of the field.
 240      *
 241      * If the field is larger than the current integer width, create
 242      * a BUFFER to hold it. Otherwise, use an INTEGER. This allows
 243      * the use of arithmetic operators on the returned value if the
 244      * field size is equal or smaller than an Integer.
 245      *
 246      * Note: Field.length is in bits.
 247      */
 248     Length = (ACPI_SIZE) ACPI_ROUND_BITS_UP_TO_BYTES (ObjDesc->Field.BitLength);
 249     if (Length > AcpiGbl_IntegerByteWidth)
 250     {
 251         /* Field is too large for an Integer, create a Buffer instead */
 252
 253         BufferDesc = AcpiUtCreateBufferObject (Length);
 254         if (!BufferDesc)
 255         {
 256             return_ACPI_STATUS (AE_NO_MEMORY);
 257         }
 258         Buffer = BufferDesc->Buffer.Pointer;
 259     }
 260     else
 261     {
 262         /* Field will fit within an Integer (normal case) */
 263
 264         BufferDesc = AcpiUtCreateIntegerObject ((UINT64) 0);
 265         if (!BufferDesc)
 266         {
 267             return_ACPI_STATUS (AE_NO_MEMORY);
 268         }
 269
 270         Length = AcpiGbl_IntegerByteWidth;
 271         Buffer = &BufferDesc->Integer.Value;
 272     }
 273
 274     if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 275         (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GPIO))
 276     {
 277         /*
 278          * For GPIO (GeneralPurposeIo), the Address will be the bit offset
 279          * from the previous Connection() operator, making it effectively a
 280          * pin number index. The BitLength is the length of the field, which
 281          * is thus the number of pins.
 282          */
 283         ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 284             "GPIO FieldRead [FROM]:  Pin %u Bits %u\n",
 285             ObjDesc->Field.PinNumberIndex, ObjDesc->Field.BitLength));
 286
 287         /* Lock entire transaction if requested */
 288
 289         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 290
 291         /* Perform the write */
 292
 293         Status = AcpiExAccessRegion (ObjDesc, 0,
 294                     (UINT64 *) Buffer, ACPI_READ);
 295         AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 296         if (ACPI_FAILURE (Status))
 297         {
 298             AcpiUtRemoveReference (BufferDesc);
 299         }
 300         else
 301         {
 302             *RetBufferDesc = BufferDesc;
 303         }
 304         return_ACPI_STATUS (Status);
 305     }
 306
 307     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 308         "FieldRead [TO]:   Obj %p, Type %X, Buf %p, ByteLen %X\n",
 309         ObjDesc, ObjDesc->Common.Type, Buffer, (UINT32) Length));
 310     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 311         "FieldRead [FROM]: BitLen %X, BitOff %X, ByteOff %X\n",
 312         ObjDesc->CommonField.BitLength,
 313         ObjDesc->CommonField.StartFieldBitOffset,
 314         ObjDesc->CommonField.BaseByteOffset));
 315
 316     /* Lock entire transaction if requested */
 317
 318     AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 319
 320     /* Read from the field */
 321
 322     Status = AcpiExExtractFromField (ObjDesc, Buffer, (UINT32) Length);
 323     AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 324
 325
 326 Exit:
 327     if (ACPI_FAILURE (Status))
 328     {
 329         AcpiUtRemoveReference (BufferDesc);
 330     }
 331     else
 332     {
 333         *RetBufferDesc = BufferDesc;
 334     }
 335
 336     return_ACPI_STATUS (Status);
 337 }
 338
 339
 340 /*******************************************************************************
 341  *
 342  * FUNCTION:    AcpiExWriteDataToField
 343  *
 344  * PARAMETERS:  SourceDesc          - Contains data to write
 345  *              ObjDesc             - The named field
 346  *              ResultDesc          - Where the return value is returned, if any
 347  *
 348  * RETURN:      Status
 349  *
 350  * DESCRIPTION: Write to a named field
 351  *
 352  ******************************************************************************/
 353
 354 ACPI_STATUS
 355 AcpiExWriteDataToField (
 356     ACPI_OPERAND_OBJECT     *SourceDesc,
 357     ACPI_OPERAND_OBJECT     *ObjDesc,
 358     ACPI_OPERAND_OBJECT     **ResultDesc)
 359 {
 360     ACPI_STATUS             Status;
 361     UINT32                  Length;
 362     void                    *Buffer;
 363     ACPI_OPERAND_OBJECT     *BufferDesc;
 364     UINT32                  Function;
 365     UINT16                  AccessorType;
 366
 367
 368     ACPI_FUNCTION_TRACE_PTR (ExWriteDataToField, ObjDesc);
 369
 370
 371     /* Parameter validation */
 372
 373     if (!SourceDesc || !ObjDesc)
 374     {
 375         return_ACPI_STATUS (AE_AML_NO_OPERAND);
 376     }
 377
 378     if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)
 379     {
 380         /*
 381          * If the BufferField arguments have not been previously evaluated,
 382          * evaluate them now and save the results.
 383          */
 384         if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))
 385         {
 386             Status = AcpiDsGetBufferFieldArguments (ObjDesc);
 387             if (ACPI_FAILURE (Status))
 388             {
 389                 return_ACPI_STATUS (Status);
 390             }
 391         }
 392     }
 393     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 394              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||
 395               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS ||
 396               ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))
 397     {
 398         /*
 399          * This is an SMBus, GSBus or IPMI write. We will bypass the entire field
 400          * mechanism and handoff the buffer directly to the handler. For
 401          * these address spaces, the buffer is bi-directional; on a write,
 402          * return data is returned in the same buffer.
 403          *
 404          * Source must be a buffer of sufficient size:
 405          * ACPI_SMBUS_BUFFER_SIZE, ACPI_GSBUS_BUFFER_SIZE, or ACPI_IPMI_BUFFER_SIZE.
 406          *
 407          * Note: SMBus and GSBus protocol type is passed in upper 16-bits of Function
 408          */
 409         if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)
 410         {
 411             ACPI_ERROR ((AE_INFO,
 412                 "SMBus/IPMI/GenericSerialBus write requires Buffer, found type %s",
 413                 AcpiUtGetObjectTypeName (SourceDesc)));
 414
 415             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 416         }
 417
 418         if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)
 419         {
 420             Length = ACPI_SMBUS_BUFFER_SIZE;
 421             Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);
 422         }
 423         else if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS)
 424         {
 425             AccessorType = ObjDesc->Field.Attribute;
 426             Length = AcpiExGetSerialAccessLength (AccessorType,
 427                 ObjDesc->Field.AccessLength);
 428
 429             /*
 430              * Add additional 2 bytes for the GenericSerialBus data buffer:
 431              *
 432              *     Status;      (Byte 0 of the data buffer)
 433              *     Length;      (Byte 1 of the data buffer)
 434              *     Data[x-1];   (Bytes 2-x of the arbitrary length data buffer)
 435              */
 436             Length += 2;
 437             Function = ACPI_WRITE | (AccessorType << 16);
 438         }
 439         else /* IPMI */
 440         {
 441             Length = ACPI_IPMI_BUFFER_SIZE;
 442             Function = ACPI_WRITE;
 443         }
 444
 445         if (SourceDesc->Buffer.Length < Length)
 446         {
 447             ACPI_ERROR ((AE_INFO,
 448                 "SMBus/IPMI/GenericSerialBus write requires Buffer of length %u, found length %u",
 449                 Length, SourceDesc->Buffer.Length));
 450
 451             return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);
 452         }
 453
 454         /* Create the bi-directional buffer */
 455
 456         BufferDesc = AcpiUtCreateBufferObject (Length);
 457         if (!BufferDesc)
 458         {
 459             return_ACPI_STATUS (AE_NO_MEMORY);
 460         }
 461
 462         Buffer = BufferDesc->Buffer.Pointer;
 463         ACPI_MEMCPY (Buffer, SourceDesc->Buffer.Pointer, Length);
 464
 465         /* Lock entire transaction if requested */
 466
 467         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 468
 469         /*
 470          * Perform the write (returns status and perhaps data in the
 471          * same buffer)
 472          */
 473         Status = AcpiExAccessRegion (ObjDesc, 0,
 474                     (UINT64 *) Buffer, Function);
 475         AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 476
 477         *ResultDesc = BufferDesc;
 478         return_ACPI_STATUS (Status);
 479     }
 480     else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&
 481              (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GPIO))
 482     {
 483         /*
 484          * For GPIO (GeneralPurposeIo), we will bypass the entire field
 485          * mechanism and handoff the bit address and bit width directly to
 486          * the handler. The Address will be the bit offset
 487          * from the previous Connection() operator, making it effectively a
 488          * pin number index. The BitLength is the length of the field, which
 489          * is thus the number of pins.
 490          */
 491         if (SourceDesc->Common.Type != ACPI_TYPE_INTEGER)
 492         {
 493             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 494         }
 495
 496         ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 497             "GPIO FieldWrite [FROM]: (%s:%X), Val %.8X  [TO]:  Pin %u Bits %u\n",
 498             AcpiUtGetTypeName (SourceDesc->Common.Type),
 499             SourceDesc->Common.Type, (UINT32) SourceDesc->Integer.Value,
 500             ObjDesc->Field.PinNumberIndex, ObjDesc->Field.BitLength));
 501
 502         Buffer = &SourceDesc->Integer.Value;
 503
 504         /* Lock entire transaction if requested */
 505
 506         AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 507
 508         /* Perform the write */
 509
 510         Status = AcpiExAccessRegion (ObjDesc, 0,
 511                     (UINT64 *) Buffer, ACPI_WRITE);
 512         AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 513         return_ACPI_STATUS (Status);
 514     }
 515
 516     /* Get a pointer to the data to be written */
 517
 518     switch (SourceDesc->Common.Type)
 519     {
 520     case ACPI_TYPE_INTEGER:
 521
 522         Buffer = &SourceDesc->Integer.Value;
 523         Length = sizeof (SourceDesc->Integer.Value);
 524         break;
 525
 526     case ACPI_TYPE_BUFFER:
 527
 528         Buffer = SourceDesc->Buffer.Pointer;
 529         Length = SourceDesc->Buffer.Length;
 530         break;
 531
 532     case ACPI_TYPE_STRING:
 533
 534         Buffer = SourceDesc->String.Pointer;
 535         Length = SourceDesc->String.Length;
 536         break;
 537
 538     default:
 539
 540         return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 541     }
 542
 543     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 544         "FieldWrite [FROM]: Obj %p (%s:%X), Buf %p, ByteLen %X\n",
 545         SourceDesc, AcpiUtGetTypeName (SourceDesc->Common.Type),
 546         SourceDesc->Common.Type, Buffer, Length));
 547
 548     ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
 549         "FieldWrite [TO]:   Obj %p (%s:%X), BitLen %X, BitOff %X, ByteOff %X\n",
 550         ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type),
 551         ObjDesc->Common.Type,
 552         ObjDesc->CommonField.BitLength,
 553         ObjDesc->CommonField.StartFieldBitOffset,
 554         ObjDesc->CommonField.BaseByteOffset));
 555
 556     /* Lock entire transaction if requested */
 557
 558     AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);
 559
 560     /* Write to the field */
 561
 562     Status = AcpiExInsertIntoField (ObjDesc, Buffer, Length);
 563     AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);
 564
 565     return_ACPI_STATUS (Status);
 566 }