自学教程：C++ AcpiUtCreateBufferObject函数代码示例

ACPI_STATUSAcpiExConcatTemplate (    ACPI_OPERAND_OBJECT     *ObjDesc1,    ACPI_OPERAND_OBJECT     *ObjDesc2,    ACPI_OPERAND_OBJECT     **ActualReturnDesc,    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     *ReturnDesc;    UINT8                   *NewBuf;    UINT8                   *EndTag1;    UINT8                   *EndTag2;    ACPI_SIZE               Length1;    ACPI_SIZE               Length2;    ACPI_FUNCTION_TRACE ("ExConcatTemplate");    /* Find the EndTags in each resource template */    EndTag1 = AcpiUtGetResourceEndTag (ObjDesc1);    EndTag2 = AcpiUtGetResourceEndTag (ObjDesc2);    if (!EndTag1 || !EndTag2)    {        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);    }    /* Compute the length of each part */    Length1 = ACPI_PTR_DIFF (EndTag1, ObjDesc1->Buffer.Pointer);    Length2 = ACPI_PTR_DIFF (EndTag2, ObjDesc2->Buffer.Pointer) +                             2; /* Size of END_TAG */    /* Create a new buffer object for the result */    ReturnDesc = AcpiUtCreateBufferObject (Length1 + Length2);    if (!ReturnDesc)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Copy the templates to the new descriptor */    NewBuf = ReturnDesc->Buffer.Pointer;    ACPI_MEMCPY (NewBuf, ObjDesc1->Buffer.Pointer, Length1);    ACPI_MEMCPY (NewBuf + Length1, ObjDesc2->Buffer.Pointer, Length2);    /* Compute the new checksum */    NewBuf[ReturnDesc->Buffer.Length - 1] =            AcpiUtGenerateChecksum (ReturnDesc->Buffer.Pointer,                                   (ReturnDesc->Buffer.Length - 1));    /* Return the completed template descriptor */    *ActualReturnDesc = ReturnDesc;    return_ACPI_STATUS (AE_OK);}

ACPI_STATUSAcpiNsConvertToUnicode (    ACPI_NAMESPACE_NODE     *Scope,    ACPI_OPERAND_OBJECT     *OriginalObject,    ACPI_OPERAND_OBJECT     **ReturnObject){    ACPI_OPERAND_OBJECT     *NewObject;    char                    *AsciiString;    UINT16                  *UnicodeBuffer;    UINT32                  UnicodeLength;    UINT32                  i;    if (!OriginalObject)    {        return (AE_OK);    }    /* If a Buffer was returned, it must be at least two bytes long */    if (OriginalObject->Common.Type == ACPI_TYPE_BUFFER)    {        if (OriginalObject->Buffer.Length < 2)        {            return (AE_AML_OPERAND_VALUE);        }        *ReturnObject = NULL;        return (AE_OK);    }    /*     * The original object is an ASCII string. Convert this string to     * a unicode buffer.     */    AsciiString = OriginalObject->String.Pointer;    UnicodeLength = (OriginalObject->String.Length * 2) + 2;    /* Create a new buffer object for the Unicode data */    NewObject = AcpiUtCreateBufferObject (UnicodeLength);    if (!NewObject)    {        return (AE_NO_MEMORY);    }    UnicodeBuffer = ACPI_CAST_PTR (UINT16, NewObject->Buffer.Pointer);    /* Convert ASCII to Unicode */    for (i = 0; i < OriginalObject->String.Length; i++)    {        UnicodeBuffer[i] = (UINT16) AsciiString[i];    }    *ReturnObject = NewObject;    return (AE_OK);}

ACPI_STATUSAcpiExConvertToBuffer (    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_OPERAND_OBJECT     **ResultDesc){    ACPI_OPERAND_OBJECT     *ReturnDesc;    UINT8                   *NewBuf;    ACPI_FUNCTION_TRACE_PTR (ExConvertToBuffer, ObjDesc);    switch (ObjDesc->Common.Type)    {    case ACPI_TYPE_BUFFER:        /* No conversion necessary */        *ResultDesc = ObjDesc;        return_ACPI_STATUS (AE_OK);    case ACPI_TYPE_INTEGER:        /*         * Create a new Buffer object.         * Need enough space for one integer         */        ReturnDesc = AcpiUtCreateBufferObject (AcpiGbl_IntegerByteWidth);        if (!ReturnDesc)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        /* Copy the integer to the buffer, LSB first */        NewBuf = ReturnDesc->Buffer.Pointer;        ACPI_MEMCPY (NewBuf,                        &ObjDesc->Integer.Value,                        AcpiGbl_IntegerByteWidth);        break;    case ACPI_TYPE_STRING:        /*         * Create a new Buffer object         * Size will be the string length         *         * NOTE: Add one to the string length to include the null terminator.         * The ACPI spec is unclear on this subject, but there is existing         * ASL/AML code that depends on the null being transferred to the new         * buffer.         */        ReturnDesc = AcpiUtCreateBufferObject (                        (ACPI_SIZE) ObjDesc->String.Length + 1);        if (!ReturnDesc)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        /* Copy the string to the buffer */        NewBuf = ReturnDesc->Buffer.Pointer;        ACPI_STRNCPY ((char *) NewBuf, (char *) ObjDesc->String.Pointer,            ObjDesc->String.Length);        break;    default:        return_ACPI_STATUS (AE_TYPE);    }    /* Mark buffer initialized */    ReturnDesc->Common.Flags |= AOPOBJ_DATA_VALID;    *ResultDesc = ReturnDesc;    return_ACPI_STATUS (AE_OK);}

static ACPI_STATUSAcpiNsRepair_FDE (    ACPI_EVALUATE_INFO      *Info,    ACPI_OPERAND_OBJECT     **ReturnObjectPtr){    ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;    ACPI_OPERAND_OBJECT     *BufferObject;    UINT8                   *ByteBuffer;    UINT32                  *DwordBuffer;    UINT32                  i;    ACPI_FUNCTION_NAME (NsRepair_FDE);    switch (ReturnObject->Common.Type)    {    case ACPI_TYPE_BUFFER:        /* This is the expected type. Length should be (at least) 5 DWORDs */        if (ReturnObject->Buffer.Length >= ACPI_FDE_DWORD_BUFFER_SIZE)        {            return (AE_OK);        }        /* We can only repair if we have exactly 5 BYTEs */        if (ReturnObject->Buffer.Length != ACPI_FDE_BYTE_BUFFER_SIZE)        {            ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,                "Incorrect return buffer length %u, expected %u",                ReturnObject->Buffer.Length, ACPI_FDE_DWORD_BUFFER_SIZE));            return (AE_AML_OPERAND_TYPE);        }        /* Create the new (larger) buffer object */        BufferObject = AcpiUtCreateBufferObject (ACPI_FDE_DWORD_BUFFER_SIZE);        if (!BufferObject)        {            return (AE_NO_MEMORY);        }        /* Expand each byte to a DWORD */        ByteBuffer = ReturnObject->Buffer.Pointer;        DwordBuffer = ACPI_CAST_PTR (UINT32, BufferObject->Buffer.Pointer);        for (i = 0; i < ACPI_FDE_FIELD_COUNT; i++)        {            *DwordBuffer = (UINT32) *ByteBuffer;            DwordBuffer++;            ByteBuffer++;        }        ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,            "%s Expanded Byte Buffer to expected DWord Buffer/n",            Info->FullPathname));        break;    default:        return (AE_AML_OPERAND_TYPE);    }    /* Delete the original return object, return the new buffer object */    AcpiUtRemoveReference (ReturnObject);    *ReturnObjectPtr = BufferObject;    Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;    return (AE_OK);}

ACPI_STATUSAcpiNsConvertToResource (    ACPI_NAMESPACE_NODE     *Scope,    ACPI_OPERAND_OBJECT     *OriginalObject,    ACPI_OPERAND_OBJECT     **ReturnObject){    ACPI_OPERAND_OBJECT     *NewObject;    UINT8                   *Buffer;    /*     * We can fix the following cases for an expected resource template:     * 1. No return value (interpreter slack mode is disabled)     * 2. A "Return (Zero)" statement     * 3. A "Return empty buffer" statement     *     * We will return a buffer containing a single EndTag     * resource descriptor.     */    if (OriginalObject)    {        switch (OriginalObject->Common.Type)        {        case ACPI_TYPE_INTEGER:            /* We can only repair an Integer==0 */            if (OriginalObject->Integer.Value)            {                return (AE_AML_OPERAND_TYPE);            }            break;        case ACPI_TYPE_BUFFER:            if (OriginalObject->Buffer.Length)            {                /* Additional checks can be added in the future */                *ReturnObject = NULL;                return (AE_OK);            }            break;        case ACPI_TYPE_STRING:        default:            return (AE_AML_OPERAND_TYPE);        }    }    /* Create the new buffer object for the resource descriptor */    NewObject = AcpiUtCreateBufferObject (2);    if (!NewObject)    {        return (AE_NO_MEMORY);    }    Buffer = ACPI_CAST_PTR (UINT8, NewObject->Buffer.Pointer);    /* Initialize the Buffer with a single EndTag descriptor */    Buffer[0] = (ACPI_RESOURCE_NAME_END_TAG | ASL_RDESC_END_TAG_SIZE);    Buffer[1] = 0x00;    *ReturnObject = NewObject;    return (AE_OK);}

ACPI_STATUSAcpiNsConvertToBuffer (    ACPI_OPERAND_OBJECT     *OriginalObject,    ACPI_OPERAND_OBJECT     **ReturnObject){    ACPI_OPERAND_OBJECT     *NewObject;    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     **Elements;    UINT32                  *DwordBuffer;    UINT32                  Count;    UINT32                  i;    switch (OriginalObject->Common.Type)    {    case ACPI_TYPE_INTEGER:        /*         * Integer-to-Buffer conversion.         * Convert the Integer to a packed-byte buffer. _MAT and other         * objects need this sometimes, if a read has been performed on a         * Field object that is less than or equal to the global integer         * size (32 or 64 bits).         */        Status = AcpiExConvertToBuffer (OriginalObject, &NewObject);        if (ACPI_FAILURE (Status))        {            return (Status);        }        break;    case ACPI_TYPE_STRING:        /* String-to-Buffer conversion. Simple data copy */        NewObject = AcpiUtCreateBufferObject            (OriginalObject->String.Length);        if (!NewObject)        {            return (AE_NO_MEMORY);        }        memcpy (NewObject->Buffer.Pointer,            OriginalObject->String.Pointer, OriginalObject->String.Length);        break;    case ACPI_TYPE_PACKAGE:        /*         * This case is often seen for predefined names that must return a         * Buffer object with multiple DWORD integers within. For example,         * _FDE and _GTM. The Package can be converted to a Buffer.         */        /* All elements of the Package must be integers */        Elements = OriginalObject->Package.Elements;        Count = OriginalObject->Package.Count;        for (i = 0; i < Count; i++)        {            if ((!*Elements) ||                ((*Elements)->Common.Type != ACPI_TYPE_INTEGER))            {                return (AE_AML_OPERAND_TYPE);            }            Elements++;        }        /* Create the new buffer object to replace the Package */        NewObject = AcpiUtCreateBufferObject (ACPI_MUL_4 (Count));        if (!NewObject)        {            return (AE_NO_MEMORY);        }        /* Copy the package elements (integers) to the buffer as DWORDs */        Elements = OriginalObject->Package.Elements;        DwordBuffer = ACPI_CAST_PTR (UINT32, NewObject->Buffer.Pointer);        for (i = 0; i < Count; i++)        {            *DwordBuffer = (UINT32) (*Elements)->Integer.Value;            DwordBuffer++;            Elements++;        }        break;    default:        return (AE_AML_OPERAND_TYPE);    }    *ReturnObject = NewObject;    return (AE_OK);}

ACPI_STATUSAcpiExDoConcatenate (    ACPI_OPERAND_OBJECT     *Operand0,    ACPI_OPERAND_OBJECT     *Operand1,    ACPI_OPERAND_OBJECT     **ActualReturnDesc,    ACPI_WALK_STATE         *WalkState){    ACPI_OPERAND_OBJECT     *LocalOperand1 = Operand1;    ACPI_OPERAND_OBJECT     *ReturnDesc;    char                    *NewBuf;    ACPI_STATUS             Status;    ACPI_FUNCTION_TRACE (ExDoConcatenate);    /*     * Convert the second operand if necessary.  The first operand     * determines the type of the second operand, (See the Data Types     * section of the ACPI specification.)  Both object types are     * guaranteed to be either Integer/String/Buffer by the operand     * resolution mechanism.     */    switch (ACPI_GET_OBJECT_TYPE (Operand0))    {    case ACPI_TYPE_INTEGER:        Status = AcpiExConvertToInteger (Operand1, &LocalOperand1, 16);        break;    case ACPI_TYPE_STRING:        Status = AcpiExConvertToString (Operand1, &LocalOperand1,                    ACPI_IMPLICIT_CONVERT_HEX);        break;    case ACPI_TYPE_BUFFER:        Status = AcpiExConvertToBuffer (Operand1, &LocalOperand1);        break;    default:        ACPI_ERROR ((AE_INFO, "Invalid object type: %X",            ACPI_GET_OBJECT_TYPE (Operand0)));        Status = AE_AML_INTERNAL;    }    if (ACPI_FAILURE (Status))    {        goto Cleanup;    }    /*     * Both operands are now known to be the same object type     * (Both are Integer, String, or Buffer), and we can now perform the     * concatenation.     */    /*     * There are three cases to handle:     *     * 1) Two Integers concatenated to produce a new Buffer     * 2) Two Strings concatenated to produce a new String     * 3) Two Buffers concatenated to produce a new Buffer     */    switch (ACPI_GET_OBJECT_TYPE (Operand0))    {    case ACPI_TYPE_INTEGER:        /* Result of two Integers is a Buffer */        /* Need enough buffer space for two integers */        ReturnDesc = AcpiUtCreateBufferObject ((ACPI_SIZE)                            ACPI_MUL_2 (AcpiGbl_IntegerByteWidth));        if (!ReturnDesc)        {            Status = AE_NO_MEMORY;            goto Cleanup;        }        NewBuf = (char *) ReturnDesc->Buffer.Pointer;        /* Copy the first integer, LSB first */        ACPI_MEMCPY (NewBuf, &Operand0->Integer.Value,                        AcpiGbl_IntegerByteWidth);        /* Copy the second integer (LSB first) after the first */        ACPI_MEMCPY (NewBuf + AcpiGbl_IntegerByteWidth,                        &LocalOperand1->Integer.Value,                        AcpiGbl_IntegerByteWidth);        break;    case ACPI_TYPE_STRING:        /* Result of two Strings is a String */        ReturnDesc = AcpiUtCreateStringObject ((ACPI_SIZE)                        (Operand0->String.Length +                        LocalOperand1->String.Length));        if (!ReturnDesc)        {//.........这里部分代码省略.........

ACPI_STATUSAcpiNsRepairNullElement (    ACPI_EVALUATE_INFO      *Info,    UINT32                  ExpectedBtypes,    UINT32                  PackageIndex,    ACPI_OPERAND_OBJECT     **ReturnObjectPtr){    ACPI_OPERAND_OBJECT     *ReturnObject = *ReturnObjectPtr;    ACPI_OPERAND_OBJECT     *NewObject;    ACPI_FUNCTION_NAME (NsRepairNullElement);    /* No repair needed if return object is non-NULL */    if (ReturnObject)    {        return (AE_OK);    }    /*     * Attempt to repair a NULL element of a Package object. This applies to     * predefined names that return a fixed-length package and each element     * is required. It does not apply to variable-length packages where NULL     * elements are allowed, especially at the end of the package.     */    if (ExpectedBtypes & ACPI_RTYPE_INTEGER)    {        /* Need an Integer - create a zero-value integer */        NewObject = AcpiUtCreateIntegerObject ((UINT64) 0);    }    else if (ExpectedBtypes & ACPI_RTYPE_STRING)    {        /* Need a String - create a NULL string */        NewObject = AcpiUtCreateStringObject (0);    }    else if (ExpectedBtypes & ACPI_RTYPE_BUFFER)    {        /* Need a Buffer - create a zero-length buffer */        NewObject = AcpiUtCreateBufferObject (0);    }    else    {        /* Error for all other expected types */        return (AE_AML_OPERAND_TYPE);    }    if (!NewObject)    {        return (AE_NO_MEMORY);    }    /* Set the reference count according to the parent Package object */    NewObject->Common.ReferenceCount =        Info->ParentPackage->Common.ReferenceCount;    ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR,        "%s: Converted NULL package element to expected %s at index %u/n",        Info->FullPathname, AcpiUtGetObjectTypeName (NewObject),        PackageIndex));    *ReturnObjectPtr = NewObject;    Info->ReturnFlags |= ACPI_OBJECT_REPAIRED;    return (AE_OK);}

ACPI_STATUSAcpiExReadDataFromField (    ACPI_WALK_STATE         *WalkState,    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_OPERAND_OBJECT     **RetBufferDesc){    ACPI_STATUS             Status;    ACPI_OPERAND_OBJECT     *BufferDesc;    ACPI_SIZE               Length;    void                    *Buffer;    UINT32                  Function;    ACPI_FUNCTION_TRACE_PTR (ExReadDataFromField, ObjDesc);    /* Parameter validation */    if (!ObjDesc)    {        return_ACPI_STATUS (AE_AML_NO_OPERAND);    }    if (!RetBufferDesc)    {        return_ACPI_STATUS (AE_BAD_PARAMETER);    }    if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)    {        /*         * If the BufferField arguments have not been previously evaluated,         * evaluate them now and save the results.         */        if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))        {            Status = AcpiDsGetBufferFieldArguments (ObjDesc);            if (ACPI_FAILURE (Status))            {                return_ACPI_STATUS (Status);            }        }    }    else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&             (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||              ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS ||              ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))    {        /*         * This is an SMBus, GSBus or IPMI read. We must create a buffer to hold         * the data and then directly access the region handler.         *         * Note: SMBus and GSBus protocol value is passed in upper 16-bits of Function         */        if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)        {            Length = ACPI_SMBUS_BUFFER_SIZE;            Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);        }        else if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS)        {            Length = ACPI_GSBUS_BUFFER_SIZE;            Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);        }        else /* IPMI */        {            Length = ACPI_IPMI_BUFFER_SIZE;            Function = ACPI_READ;        }        BufferDesc = AcpiUtCreateBufferObject (Length);        if (!BufferDesc)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        /* Lock entire transaction if requested */        AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);        /* Call the region handler for the read */        Status = AcpiExAccessRegion (ObjDesc, 0,                    ACPI_CAST_PTR (UINT64, BufferDesc->Buffer.Pointer),                    Function);        AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);        goto Exit;    }    /*     * Allocate a buffer for the contents of the field.     *     * If the field is larger than the current integer width, create     * a BUFFER to hold it.  Otherwise, use an INTEGER.  This allows     * the use of arithmetic operators on the returned value if the     * field size is equal or smaller than an Integer.     *     * Note: Field.length is in bits.     */    Length = (ACPI_SIZE) ACPI_ROUND_BITS_UP_TO_BYTES (ObjDesc->Field.BitLength);    if (Length > AcpiGbl_IntegerByteWidth)//.........这里部分代码省略.........

ACPI_STATUSAcpiExWriteDataToField (    ACPI_OPERAND_OBJECT     *SourceDesc,    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_OPERAND_OBJECT     **ResultDesc){    ACPI_STATUS             Status;    UINT32                  Length;    void                    *Buffer;    ACPI_OPERAND_OBJECT     *BufferDesc;    UINT32                  Function;    ACPI_FUNCTION_TRACE_PTR (ExWriteDataToField, ObjDesc);    /* Parameter validation */    if (!SourceDesc || !ObjDesc)    {        return_ACPI_STATUS (AE_AML_NO_OPERAND);    }    if (ObjDesc->Common.Type == ACPI_TYPE_BUFFER_FIELD)    {        /*         * If the BufferField arguments have not been previously evaluated,         * evaluate them now and save the results.         */        if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID))        {            Status = AcpiDsGetBufferFieldArguments (ObjDesc);            if (ACPI_FAILURE (Status))            {                return_ACPI_STATUS (Status);            }        }    }    else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&             (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS ||              ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS ||              ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_IPMI))    {        /*         * This is an SMBus, GSBus or IPMI write. We will bypass the entire field         * mechanism and handoff the buffer directly to the handler. For         * these address spaces, the buffer is bi-directional; on a write,         * return data is returned in the same buffer.         *         * Source must be a buffer of sufficient size:         * ACPI_SMBUS_BUFFER_SIZE, ACPI_GSBUS_BUFFER_SIZE, or ACPI_IPMI_BUFFER_SIZE.         *         * Note: SMBus and GSBus protocol type is passed in upper 16-bits of Function         */        if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)        {            ACPI_ERROR ((AE_INFO,                "SMBus/IPMI/GenericSerialBus write requires Buffer, found type %s",                AcpiUtGetObjectTypeName (SourceDesc)));            return_ACPI_STATUS (AE_AML_OPERAND_TYPE);        }        if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_SMBUS)        {            Length = ACPI_SMBUS_BUFFER_SIZE;            Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);        }        else if (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GSBUS)        {            Length = ACPI_GSBUS_BUFFER_SIZE;            Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);        }        else /* IPMI */        {            Length = ACPI_IPMI_BUFFER_SIZE;            Function = ACPI_WRITE;        }        if (SourceDesc->Buffer.Length < Length)        {            ACPI_ERROR ((AE_INFO,                "SMBus/IPMI/GenericSerialBus write requires Buffer of length %u, found length %u",                Length, SourceDesc->Buffer.Length));            return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);        }        /* Create the bi-directional buffer */        BufferDesc = AcpiUtCreateBufferObject (Length);        if (!BufferDesc)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        Buffer = BufferDesc->Buffer.Pointer;        ACPI_MEMCPY (Buffer, SourceDesc->Buffer.Pointer, Length);        /* Lock entire transaction if requested *///.........这里部分代码省略.........

//.........这里部分代码省略.........        {            AccessorType = ObjDesc->Field.Attribute;            Length = AcpiExGetSerialAccessLength (                AccessorType, ObjDesc->Field.AccessLength);            /*             * Add additional 2 bytes for the GenericSerialBus data buffer:             *             *     Status;    (Byte 0 of the data buffer)             *     Length;    (Byte 1 of the data buffer)             *     Data[x-1]: (Bytes 2-x of the arbitrary length data buffer)             */            Length += 2;            Function = ACPI_WRITE | (AccessorType << 16);        }        else /* IPMI */        {            Length = ACPI_IPMI_BUFFER_SIZE;            Function = ACPI_WRITE;        }        if (SourceDesc->Buffer.Length < Length)        {            ACPI_ERROR ((AE_INFO,                "SMBus/IPMI/GenericSerialBus write requires "                "Buffer of length %u, found length %u",                Length, SourceDesc->Buffer.Length));            return_ACPI_STATUS (AE_AML_BUFFER_LIMIT);        }        /* Create the bi-directional buffer */        BufferDesc = AcpiUtCreateBufferObject (Length);        if (!BufferDesc)        {            return_ACPI_STATUS (AE_NO_MEMORY);        }        Buffer = BufferDesc->Buffer.Pointer;        memcpy (Buffer, SourceDesc->Buffer.Pointer, Length);        /* Lock entire transaction if requested */        AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);        /*         * Perform the write (returns status and perhaps data in the         * same buffer)         */        Status = AcpiExAccessRegion (            ObjDesc, 0, (UINT64 *) Buffer, Function);        AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);        *ResultDesc = BufferDesc;        return_ACPI_STATUS (Status);    }    else if ((ObjDesc->Common.Type == ACPI_TYPE_LOCAL_REGION_FIELD) &&             (ObjDesc->Field.RegionObj->Region.SpaceId == ACPI_ADR_SPACE_GPIO))    {        /*         * For GPIO (GeneralPurposeIo), we will bypass the entire field         * mechanism and handoff the bit address and bit width directly to         * the handler. The Address will be the bit offset         * from the previous Connection() operator, making it effectively a         * pin number index. The BitLength is the length of the field, which

ACPI_STATUSAcpiExDoConcatenate (    ACPI_OPERAND_OBJECT     *ObjDesc1,    ACPI_OPERAND_OBJECT     *ObjDesc2,    ACPI_OPERAND_OBJECT     **ActualReturnDesc,    ACPI_WALK_STATE         *WalkState){    ACPI_STATUS             Status;    UINT32                  i;    ACPI_INTEGER            ThisInteger;    ACPI_OPERAND_OBJECT     *ReturnDesc;    NATIVE_CHAR             *NewBuf;    ACPI_FUNCTION_ENTRY ();    /*     * There are three cases to handle:     *     * 1) Two Integers concatenated to produce a new Buffer     * 2) Two Strings concatenated to produce a new String     * 3) Two Buffers concatenated to produce a new Buffer     */    switch (ACPI_GET_OBJECT_TYPE (ObjDesc1))    {    case ACPI_TYPE_INTEGER:        /* Result of two Integers is a Buffer */        /* Need enough buffer space for two integers */        ReturnDesc = AcpiUtCreateBufferObject (AcpiGbl_IntegerByteWidth * 2);        if (!ReturnDesc)        {            return (AE_NO_MEMORY);        }        NewBuf = (NATIVE_CHAR *) ReturnDesc->Buffer.Pointer;        /* Convert the first integer */        ThisInteger = ObjDesc1->Integer.Value;        for (i = 0; i < AcpiGbl_IntegerByteWidth; i++)        {            NewBuf[i] = (NATIVE_CHAR) ThisInteger;            ThisInteger >>= 8;        }        /* Convert the second integer */        ThisInteger = ObjDesc2->Integer.Value;        for (; i < (ACPI_MUL_2 (AcpiGbl_IntegerByteWidth)); i++)        {            NewBuf[i] = (NATIVE_CHAR) ThisInteger;            ThisInteger >>= 8;        }        break;    case ACPI_TYPE_STRING:        /* Result of two Strings is a String */        ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING);        if (!ReturnDesc)        {            return (AE_NO_MEMORY);        }        /* Operand0 is string  */        NewBuf = ACPI_MEM_ALLOCATE ((ACPI_SIZE) ObjDesc1->String.Length +                                    (ACPI_SIZE) ObjDesc2->String.Length + 1);        if (!NewBuf)        {            ACPI_REPORT_ERROR                (("ExDoConcatenate: String allocation failure/n"));            Status = AE_NO_MEMORY;            goto Cleanup;        }        /* Concatenate the strings */        ACPI_STRCPY (NewBuf, ObjDesc1->String.Pointer);        ACPI_STRCPY (NewBuf + ObjDesc1->String.Length,                              ObjDesc2->String.Pointer);        /* Complete the String object initialization */        ReturnDesc->String.Pointer = NewBuf;        ReturnDesc->String.Length  = ObjDesc1->String.Length +                                     ObjDesc2->String.Length;        break;    case ACPI_TYPE_BUFFER:        /* Result of two Buffers is a Buffer *///.........这里部分代码省略.........

ACPI_STATUSAcpiExWriteSerialBus (    ACPI_OPERAND_OBJECT     *SourceDesc,    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_OPERAND_OBJECT     **ReturnBuffer){    ACPI_STATUS             Status;    UINT32                  BufferLength;    UINT32                  DataLength;    void                    *Buffer;    ACPI_OPERAND_OBJECT     *BufferDesc;    UINT32                  Function;    UINT16                  AccessorType;    ACPI_FUNCTION_TRACE_PTR (ExWriteSerialBus, ObjDesc);    /*     * This is an SMBus, GSBus or IPMI write. We will bypass the entire     * field mechanism and handoff the buffer directly to the handler.     * For these address spaces, the buffer is bidirectional; on a     * write, return data is returned in the same buffer.     *     * Source must be a buffer of sufficient size, these are fixed size:     * ACPI_SMBUS_BUFFER_SIZE, or ACPI_IPMI_BUFFER_SIZE.     *     * Note: SMBus and GSBus protocol type is passed in upper 16-bits     * of Function     *     * Common buffer format:     *     Status;    (Byte 0 of the data buffer)     *     Length;    (Byte 1 of the data buffer)     *     Data[x-1]: (Bytes 2-x of the arbitrary length data buffer)     */    if (SourceDesc->Common.Type != ACPI_TYPE_BUFFER)    {        ACPI_ERROR ((AE_INFO,            "SMBus/IPMI/GenericSerialBus write requires "            "Buffer, found type %s",            AcpiUtGetObjectTypeName (SourceDesc)));        return_ACPI_STATUS (AE_AML_OPERAND_TYPE);    }    switch (ObjDesc->Field.RegionObj->Region.SpaceId)    {    case ACPI_ADR_SPACE_SMBUS:        BufferLength = ACPI_SMBUS_BUFFER_SIZE;        Function = ACPI_WRITE | (ObjDesc->Field.Attribute << 16);        break;    case ACPI_ADR_SPACE_IPMI:        BufferLength = ACPI_IPMI_BUFFER_SIZE;        Function = ACPI_WRITE;        break;    case ACPI_ADR_SPACE_GSBUS:        AccessorType = ObjDesc->Field.Attribute;        Status = AcpiExGetProtocolBufferLength (AccessorType, &BufferLength);        if (ACPI_FAILURE (Status))        {            ACPI_ERROR ((AE_INFO,                "Invalid protocol ID for GSBus: 0x%4.4X", AccessorType));            return_ACPI_STATUS (Status);        }        /* Add header length to get the full size of the buffer */        BufferLength += ACPI_SERIAL_HEADER_SIZE;        Function = ACPI_WRITE | (AccessorType << 16);        break;    default:        return_ACPI_STATUS (AE_AML_INVALID_SPACE_ID);    }    /* Create the transfer/bidirectional/return buffer */    BufferDesc = AcpiUtCreateBufferObject (BufferLength);    if (!BufferDesc)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Copy the input buffer data to the transfer buffer */    Buffer = BufferDesc->Buffer.Pointer;    DataLength = (BufferLength < SourceDesc->Buffer.Length ?        BufferLength : SourceDesc->Buffer.Length);    memcpy (Buffer, SourceDesc->Buffer.Pointer, DataLength);    /* Lock entire transaction if requested */    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);//.........这里部分代码省略.........

ACPI_STATUSAcpiExReadSerialBus (    ACPI_OPERAND_OBJECT     *ObjDesc,    ACPI_OPERAND_OBJECT     **ReturnBuffer){    ACPI_STATUS             Status;    UINT32                  BufferLength;    ACPI_OPERAND_OBJECT     *BufferDesc;    UINT32                  Function;    UINT16                  AccessorType;    ACPI_FUNCTION_TRACE_PTR (ExReadSerialBus, ObjDesc);    /*     * This is an SMBus, GSBus or IPMI read. We must create a buffer to     * hold the data and then directly access the region handler.     *     * Note: SMBus and GSBus protocol value is passed in upper 16-bits     * of Function     *     * Common buffer format:     *     Status;    (Byte 0 of the data buffer)     *     Length;    (Byte 1 of the data buffer)     *     Data[x-1]: (Bytes 2-x of the arbitrary length data buffer)     */    switch (ObjDesc->Field.RegionObj->Region.SpaceId)    {    case ACPI_ADR_SPACE_SMBUS:        BufferLength = ACPI_SMBUS_BUFFER_SIZE;        Function = ACPI_READ | (ObjDesc->Field.Attribute << 16);        break;    case ACPI_ADR_SPACE_IPMI:        BufferLength = ACPI_IPMI_BUFFER_SIZE;        Function = ACPI_READ;        break;    case ACPI_ADR_SPACE_GSBUS:        AccessorType = ObjDesc->Field.Attribute;        if (AccessorType == AML_FIELD_ATTRIB_RAW_PROCESS_BYTES)        {            ACPI_ERROR ((AE_INFO,                "Invalid direct read using bidirectional write-then-read protocol"));            return_ACPI_STATUS (AE_AML_PROTOCOL);        }        Status = AcpiExGetProtocolBufferLength (AccessorType, &BufferLength);        if (ACPI_FAILURE (Status))        {            ACPI_ERROR ((AE_INFO,                "Invalid protocol ID for GSBus: 0x%4.4X", AccessorType));            return_ACPI_STATUS (Status);        }        /* Add header length to get the full size of the buffer */        BufferLength += ACPI_SERIAL_HEADER_SIZE;        Function = ACPI_READ | (AccessorType << 16);        break;    default:        return_ACPI_STATUS (AE_AML_INVALID_SPACE_ID);    }    /* Create the local transfer buffer that is returned to the caller */    BufferDesc = AcpiUtCreateBufferObject (BufferLength);    if (!BufferDesc)    {        return_ACPI_STATUS (AE_NO_MEMORY);    }    /* Lock entire transaction if requested */    AcpiExAcquireGlobalLock (ObjDesc->CommonField.FieldFlags);    /* Call the region handler for the write-then-read */    Status = AcpiExAccessRegion (ObjDesc, 0,        ACPI_CAST_PTR (UINT64, BufferDesc->Buffer.Pointer), Function);    AcpiExReleaseGlobalLock (ObjDesc->CommonField.FieldFlags);    *ReturnBuffer = BufferDesc;    return_ACPI_STATUS (Status);}