From 02c92eb332c4d56cd990b07b9cecc1ada735ed68 Mon Sep 17 00:00:00 2001 From: msmith Date: Wed, 28 Nov 2001 04:34:52 +0000 Subject: Merge local changes. Add a fix for a minor error in the PCI routing table creation handler where the correct size for the buffer is not returned. --- sys/contrib/dev/acpica/acconfig.h | 28 +- sys/contrib/dev/acpica/acgcc.h | 18 +- sys/contrib/dev/acpica/acpiosxf.h | 6 +- sys/contrib/dev/acpica/acpixf.h | 26 ++ sys/contrib/dev/acpica/exfldio.c | 729 ++++++++++++++++++++++---------------- sys/contrib/dev/acpica/hwsleep.c | 86 +++-- sys/contrib/dev/acpica/psparse.c | 111 +++--- sys/contrib/dev/acpica/rscreate.c | 2 +- sys/contrib/dev/acpica/tbget.c | 9 +- 9 files changed, 575 insertions(+), 440 deletions(-) (limited to 'sys/contrib') diff --git a/sys/contrib/dev/acpica/acconfig.h b/sys/contrib/dev/acpica/acconfig.h index fb97fc2..9a48eaa 100644 --- a/sys/contrib/dev/acpica/acconfig.h +++ b/sys/contrib/dev/acpica/acconfig.h @@ -1,7 +1,7 @@ /****************************************************************************** * * Name: acconfig.h - Global configuration constants - * $Revision: 74 $ + * $Revision: 78 $ * *****************************************************************************/ @@ -125,12 +125,13 @@ *****************************************************************************/ /* - * ACPI_DEBUG - This switch enables all the debug facilities of the ACPI - * subsystem. This includes the DEBUG_PRINT output statements - * When disabled, all DEBUG_PRINT statements are compiled out. + * ACPI_DEBUG - This switch enables all the debug facilities of the + * ACPI subsystem. This includes the DEBUG_PRINT output + * statements. When disabled, all DEBUG_PRINT + * statements are compiled out. * * ACPI_APPLICATION - Use this switch if the subsystem is going to be run - * at the application level. + * at the application level. * */ @@ -144,7 +145,7 @@ /* Version string */ -#define ACPI_CA_VERSION 0x20011018 +#define ACPI_CA_VERSION 0x20011120 /* Version of ACPI supported */ @@ -153,17 +154,17 @@ /* Maximum objects in the various object caches */ -#define MAX_STATE_CACHE_DEPTH 64 /* State objects for stacks */ +#define MAX_STATE_CACHE_DEPTH 64 /* State objects for stacks */ #define MAX_PARSE_CACHE_DEPTH 96 /* Parse tree objects */ #define MAX_EXTPARSE_CACHE_DEPTH 64 /* Parse tree objects */ #define MAX_OBJECT_CACHE_DEPTH 64 /* Interpreter operand objects */ -#define MAX_WALK_CACHE_DEPTH 4 /* Objects for parse tree walks (method execution) */ +#define MAX_WALK_CACHE_DEPTH 4 /* Objects for parse tree walks */ /* String size constants */ #define MAX_STRING_LENGTH 512 -#define PATHNAME_MAX 256 /* A full namespace pathname */ +#define PATHNAME_MAX 256 /* A full namespace pathname */ /* Maximum count for a semaphore object */ @@ -232,7 +233,7 @@ /* Names within the namespace are 4 bytes long */ #define ACPI_NAME_SIZE 4 -#define PATH_SEGMENT_LENGTH 5 /* 4 chars for name + 1 INT8 for separator */ +#define PATH_SEGMENT_LENGTH 5 /* 4 chars for name + 1 char for separator */ #define PATH_SEPARATOR '.' @@ -244,10 +245,15 @@ #define HI_RSDP_WINDOW_SIZE 0x20000 #define RSDP_SCAN_STEP 16 + +/* Operation regions */ + +#define ACPI_NUM_PREDEFINED_REGIONS 7 +#define ACPI_USER_REGION_BEGIN 0x80 + /* Maximum SpaceIds for Operation Regions */ #define ACPI_MAX_ADDRESS_SPACE 255 -#define ACPI_NUM_ADDRESS_SPACES 256 #endif /* _ACCONFIG_H */ diff --git a/sys/contrib/dev/acpica/acgcc.h b/sys/contrib/dev/acpica/acgcc.h index 9ca66f1..5581e48 100644 --- a/sys/contrib/dev/acpica/acgcc.h +++ b/sys/contrib/dev/acpica/acgcc.h @@ -1,7 +1,7 @@ /****************************************************************************** * * Name: acgcc.h - GCC specific defines, etc. - * $Revision: 14 $ + * $Revision: 15 $ * *****************************************************************************/ @@ -235,17 +235,17 @@ * Math helper asm macros */ #define ACPI_DIV_64_BY_32(n_hi, n_lo, d32, q32, r32) \ - asm("divl %2;" \ - :"=a"(q32), "=d"(r32) \ - :"r"(d32), \ - "0"(n_lo), "1"(n_hi)) + asm("divl %2;" \ + :"=a"(q32), "=d"(r32) \ + :"r"(d32), \ + "0"(n_lo), "1"(n_hi)) #define ACPI_SHIFT_RIGHT_64(n_hi, n_lo) \ - asm("shrl $1,%2;" \ - "rcrl $1,%3;" \ - :"=r"(n_hi), "=r"(n_lo) \ - :"0"(n_hi), "1"(n_lo)) + asm("shrl $1,%2;" \ + "rcrl $1,%3;" \ + :"=r"(n_hi), "=r"(n_lo) \ + :"0"(n_hi), "1"(n_lo)) /*! [End] no source code translation !*/ diff --git a/sys/contrib/dev/acpica/acpiosxf.h b/sys/contrib/dev/acpica/acpiosxf.h index 57c9f97..e7a8637 100644 --- a/sys/contrib/dev/acpica/acpiosxf.h +++ b/sys/contrib/dev/acpica/acpiosxf.h @@ -294,7 +294,7 @@ AcpiOsReadPort ( ACPI_STATUS AcpiOsWritePort ( ACPI_IO_ADDRESS Address, - NATIVE_UINT Value, + ACPI_INTEGER Value, UINT32 Width); @@ -312,7 +312,7 @@ AcpiOsReadMemory ( ACPI_STATUS AcpiOsWriteMemory ( ACPI_PHYSICAL_ADDRESS Address, - NATIVE_UINT Value, + ACPI_INTEGER Value, UINT32 Width); @@ -332,7 +332,7 @@ ACPI_STATUS AcpiOsWritePciConfiguration ( ACPI_PCI_ID *PciId, UINT32 Register, - NATIVE_UINT Value, + ACPI_INTEGER Value, UINT32 Width); diff --git a/sys/contrib/dev/acpica/acpixf.h b/sys/contrib/dev/acpica/acpixf.h index 2c25e15..ec03fb4 100644 --- a/sys/contrib/dev/acpica/acpixf.h +++ b/sys/contrib/dev/acpica/acpixf.h @@ -158,6 +158,10 @@ const char * AcpiFormatException ( ACPI_STATUS Exception); +ACPI_STATUS +AcpiPurgeCachedObjects ( + void); + /* * ACPI Memory manager @@ -249,6 +253,23 @@ AcpiGetHandle ( ACPI_STRING Pathname, ACPI_HANDLE *RetHandle); +ACPI_STATUS +AcpiAttachData ( + ACPI_HANDLE ObjHandle, + ACPI_OBJECT_HANDLER Handler, + void *Data); + +ACPI_STATUS +AcpiDetachData ( + ACPI_HANDLE ObjHandle, + ACPI_OBJECT_HANDLER Handler); + +ACPI_STATUS +AcpiGetData ( + ACPI_HANDLE ObjHandle, + ACPI_OBJECT_HANDLER Handler, + void **Data); + /* * Object manipulation and enumeration @@ -406,6 +427,11 @@ ACPI_STATUS AcpiGetFirmwareWakingVector ( ACPI_PHYSICAL_ADDRESS *PhysicalAddress); + +ACPI_STATUS +AcpiEnterSleepStatePrep ( + UINT8 SleepState); + ACPI_STATUS AcpiEnterSleepState ( UINT8 SleepState); diff --git a/sys/contrib/dev/acpica/exfldio.c b/sys/contrib/dev/acpica/exfldio.c index c10b336..7e60ea8 100644 --- a/sys/contrib/dev/acpica/exfldio.c +++ b/sys/contrib/dev/acpica/exfldio.c @@ -1,7 +1,7 @@ /****************************************************************************** * * Module Name: exfldio - Aml Field I/O - * $Revision: 66 $ + * $Revision: 75 $ * *****************************************************************************/ @@ -132,20 +132,21 @@ /******************************************************************************* * - * FUNCTION: AcpiExSetupField + * FUNCTION: AcpiExSetupRegion * - * PARAMETERS: *ObjDesc - Field to be read or written - * FieldDatumByteOffset - Current offset into the field + * PARAMETERS: *ObjDesc - Field to be read or written + * FieldDatumByteOffset - Byte offset of this datum within the + * parent field * * RETURN: Status * * DESCRIPTION: Common processing for AcpiExExtractFromField and - * AcpiExInsertIntoField + * AcpiExInsertIntoField. Initialize the * ******************************************************************************/ ACPI_STATUS -AcpiExSetupField ( +AcpiExSetupRegion ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 FieldDatumByteOffset) { @@ -153,7 +154,7 @@ AcpiExSetupField ( ACPI_OPERAND_OBJECT *RgnDesc; - FUNCTION_TRACE_U32 ("ExSetupField", FieldDatumByteOffset); + FUNCTION_TRACE_U32 ("ExSetupRegion", FieldDatumByteOffset); RgnDesc = ObjDesc->CommonField.RegionObj; @@ -171,7 +172,6 @@ AcpiExSetupField ( */ if (!(RgnDesc->Region.Flags & AOPOBJ_DATA_VALID)) { - Status = AcpiDsGetRegionArguments (RgnDesc); if (ACPI_FAILURE (Status)) { @@ -184,9 +184,9 @@ AcpiExSetupField ( * length of one field datum (access width) must fit within the region. * (Region length is specified in bytes) */ - if (RgnDesc->Region.Length < (ObjDesc->CommonField.BaseByteOffset + - FieldDatumByteOffset + - ObjDesc->CommonField.AccessByteWidth)) + if (RgnDesc->Region.Length < (ObjDesc->CommonField.BaseByteOffset + + FieldDatumByteOffset + + ObjDesc->CommonField.AccessByteWidth)) { if (RgnDesc->Region.Length < ObjDesc->CommonField.AccessByteWidth) { @@ -205,7 +205,7 @@ AcpiExSetupField ( * exceeds region length, indicate an error */ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "Field base+offset+width %X+%X+%X exceeds region size (%X bytes) field=%p region=%p\n", + "Field Base+Offset+Width %X+%X+%X exceeds region size (%X bytes) field=%p region=%p\n", ObjDesc->CommonField.BaseByteOffset, FieldDatumByteOffset, ObjDesc->CommonField.AccessByteWidth, RgnDesc->Region.Length, ObjDesc, RgnDesc)); @@ -219,121 +219,427 @@ AcpiExSetupField ( /******************************************************************************* * - * FUNCTION: AcpiExReadFieldDatum + * FUNCTION: AcpiExAccessRegion * - * PARAMETERS: *ObjDesc - Field to be read - * *Value - Where to store value (must be 32 bits) + * PARAMETERS: *ObjDesc - Field to be read + * FieldDatumByteOffset - Byte offset of this datum within the + * parent field + * *Value - Where to store value (must be 32 bits) + * ReadWrite - Read or Write flag * * RETURN: Status * - * DESCRIPTION: Retrieve the value of the given field + * DESCRIPTION: Read or Write a single field datum to an Operation Region. * ******************************************************************************/ ACPI_STATUS -AcpiExReadFieldDatum ( +AcpiExAccessRegion ( ACPI_OPERAND_OBJECT *ObjDesc, UINT32 FieldDatumByteOffset, - UINT32 *Value) + ACPI_INTEGER *Value, + UINT32 ReadWrite) { ACPI_STATUS Status; ACPI_OPERAND_OBJECT *RgnDesc; ACPI_PHYSICAL_ADDRESS Address; - UINT32 LocalValue; - FUNCTION_TRACE_U32 ("ExReadFieldDatum", FieldDatumByteOffset); + FUNCTION_TRACE ("AcpiExAccessRegion"); - if (!Value) + /* + * The physical address of this field datum is: + * + * 1) The base of the region, plus + * 2) The base offset of the field, plus + * 3) The current offset into the field + */ + RgnDesc = ObjDesc->CommonField.RegionObj; + Address = RgnDesc->Region.Address + + ObjDesc->CommonField.BaseByteOffset + + FieldDatumByteOffset; + + if (ReadWrite == ACPI_READ) + { + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "[READ]")); + } + else { - LocalValue = 0; - Value = &LocalValue; /* support reads without saving value */ + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "[WRITE]")); } - /* Clear the entire return buffer first, [Very Important!] */ + ACPI_DEBUG_PRINT_RAW ((ACPI_DB_BFIELD, + " Region[%s-%X] Width %X Base:Off %X:%X at %8.8X%8.8X\n", + AcpiUtGetRegionName (RgnDesc->Region.SpaceId), + RgnDesc->Region.SpaceId, + ObjDesc->CommonField.AccessBitWidth, + ObjDesc->CommonField.BaseByteOffset, + FieldDatumByteOffset, + HIDWORD (Address), LODWORD (Address))); - *Value = 0; + /* Invoke the appropriate AddressSpace/OpRegion handler */ + + Status = AcpiEvAddressSpaceDispatch (RgnDesc, ReadWrite, + Address, ObjDesc->CommonField.AccessBitWidth, Value); + + if (ACPI_FAILURE (Status)) + { + if (Status == AE_NOT_IMPLEMENTED) + { + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Region %s(%X) not implemented\n", + AcpiUtGetRegionName (RgnDesc->Region.SpaceId), + RgnDesc->Region.SpaceId)); + } + + else if (Status == AE_NOT_EXIST) + { + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Region %s(%X) has no handler\n", + AcpiUtGetRegionName (RgnDesc->Region.SpaceId), + RgnDesc->Region.SpaceId)); + } + } + + return_ACPI_STATUS (Status); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiExRegisterOverflow + * + * PARAMETERS: *ObjDesc - Register(Field) to be written + * Value - Value to be stored + * + * RETURN: TRUE if value overflows the field, FALSE otherwise + * + * DESCRIPTION: Check if a value is out of range of the field being written. + * Used to check if the values written to Index and Bank registers + * are out of range. Normally, the value is simply truncated + * to fit the field, but this case is most likely a serious + * coding error in the ASL. + * + ******************************************************************************/ + +BOOLEAN +AcpiExRegisterOverflow ( + ACPI_OPERAND_OBJECT *ObjDesc, + ACPI_INTEGER Value) +{ /* - * BufferFields - Read from a Buffer - * Other Fields - Read from a Operation Region. + * Is the Value larger than the maximum value that can fit into + * the field? + */ + if (Value >= (ACPI_INTEGER) (1 << ObjDesc->CommonField.BitLength)) + { + return (TRUE); + } + + return (FALSE); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiExFieldDatumIo + * + * PARAMETERS: *ObjDesc - Field to be read + * FieldDatumByteOffset - Byte offset of this datum within the + * parent field + * *Value - Where to store value (must be 64 bits) + * ReadWrite - Read or Write flag + * + * RETURN: Status + * + * DESCRIPTION: Read or Write a single datum of a field. The FieldType is + * demultiplexed here to handle the different types of fields + * (BufferField, RegionField, IndexField, BankField) + * + ******************************************************************************/ + +ACPI_STATUS +AcpiExFieldDatumIo ( + ACPI_OPERAND_OBJECT *ObjDesc, + UINT32 FieldDatumByteOffset, + ACPI_INTEGER *Value, + UINT32 ReadWrite) +{ + ACPI_STATUS Status; + ACPI_INTEGER LocalValue; + + + FUNCTION_TRACE_U32 ("ExFieldDatumIo", FieldDatumByteOffset); + + + if (ReadWrite == ACPI_READ) + { + if (!Value) + { + LocalValue = 0; + Value = &LocalValue; /* To support reads without saving return value */ + } + + /* Clear the entire return buffer first, [Very Important!] */ + + *Value = 0; + } + + /* + * The four types of fields are: + * + * BufferFields - Read/write from/to a Buffer + * RegionFields - Read/write from/to a Operation Region. + * BankFields - Write to a Bank Register, then read/write from/to an OpRegion + * IndexFields - Write to an Index Register, then read/write from/to a Data Register */ switch (ObjDesc->Common.Type) { case ACPI_TYPE_BUFFER_FIELD: - /* - * For BufferFields, we only need to copy the data from the - * source buffer. Length is the field width in bytes. + * If the BufferField arguments have not been previously evaluated, + * evaluate them now and save the results. */ - MEMCPY (Value, (ObjDesc->BufferField.BufferObj)->Buffer.Pointer - + ObjDesc->BufferField.BaseByteOffset + FieldDatumByteOffset, - ObjDesc->CommonField.AccessByteWidth); + if (!(ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)) + { + Status = AcpiDsGetBufferFieldArguments (ObjDesc); + if (ACPI_FAILURE (Status)) + { + return_ACPI_STATUS (Status); + } + } + + if (ReadWrite == ACPI_READ) + { + /* + * Copy the data from the source buffer. + * Length is the field width in bytes. + */ + MEMCPY (Value, (ObjDesc->BufferField.BufferObj)->Buffer.Pointer + + ObjDesc->BufferField.BaseByteOffset + + FieldDatumByteOffset, + ObjDesc->CommonField.AccessByteWidth); + } + else + { + /* + * Copy the data to the target buffer. + * Length is the field width in bytes. + */ + MEMCPY ((ObjDesc->BufferField.BufferObj)->Buffer.Pointer + + ObjDesc->BufferField.BaseByteOffset + + FieldDatumByteOffset, + Value, ObjDesc->CommonField.AccessByteWidth); + } + Status = AE_OK; break; - case INTERNAL_TYPE_REGION_FIELD: case INTERNAL_TYPE_BANK_FIELD: + /* Ensure that the BankValue is not beyond the capacity of the register */ + + if (AcpiExRegisterOverflow (ObjDesc->BankField.BankObj, + ObjDesc->BankField.Value)) + { + return_ACPI_STATUS (AE_AML_REGISTER_LIMIT); + } + /* - * For other fields, we need to go through an Operation Region - * (Only types that will get here are RegionFields and BankFields) + * For BankFields, we must write the BankValue to the BankRegister + * (itself a RegionField) before we can access the data. */ - Status = AcpiExSetupField (ObjDesc, FieldDatumByteOffset); + Status = AcpiExInsertIntoField (ObjDesc->BankField.BankObj, + &ObjDesc->BankField.Value, + sizeof (ObjDesc->BankField.Value)); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } /* - * The physical address of this field datum is: - * - * 1) The base of the region, plus - * 2) The base offset of the field, plus - * 3) The current offset into the field + * Now that the Bank has been selected, fall through to the + * RegionField case and write the datum to the Operation Region */ - RgnDesc = ObjDesc->CommonField.RegionObj; - Address = RgnDesc->Region.Address + ObjDesc->CommonField.BaseByteOffset + - FieldDatumByteOffset; - ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Region %s(%X) width %X base:off %X:%X at %8.8X%8.8X\n", - AcpiUtGetRegionName (RgnDesc->Region.SpaceId), - RgnDesc->Region.SpaceId, ObjDesc->CommonField.AccessBitWidth, - ObjDesc->CommonField.BaseByteOffset, FieldDatumByteOffset, - HIDWORD(Address), LODWORD(Address))); + /* No break; ! */ - /* Invoke the appropriate AddressSpace/OpRegion handler */ - Status = AcpiEvAddressSpaceDispatch (RgnDesc, ACPI_READ_ADR_SPACE, - Address, ObjDesc->CommonField.AccessBitWidth, Value); - if (Status == AE_NOT_IMPLEMENTED) + case INTERNAL_TYPE_REGION_FIELD: + /* + * For simple RegionFields, we just directly access the owning + * Operation Region. + */ + Status = AcpiExSetupRegion (ObjDesc, FieldDatumByteOffset); + if (ACPI_FAILURE (Status)) { - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region %s(%X) not implemented\n", - AcpiUtGetRegionName (RgnDesc->Region.SpaceId), - RgnDesc->Region.SpaceId)); + return_ACPI_STATUS (Status); } - else if (Status == AE_NOT_EXIST) + Status = AcpiExAccessRegion (ObjDesc, FieldDatumByteOffset, Value, + ReadWrite); + break; + + + case INTERNAL_TYPE_INDEX_FIELD: + + + /* Ensure that the IndexValue is not beyond the capacity of the register */ + + if (AcpiExRegisterOverflow (ObjDesc->IndexField.IndexObj, + ObjDesc->IndexField.Value)) { - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region %s(%X) has no handler\n", - AcpiUtGetRegionName (RgnDesc->Region.SpaceId), - RgnDesc->Region.SpaceId)); + return_ACPI_STATUS (AE_AML_REGISTER_LIMIT); + } + + /* Write the index value to the IndexRegister (itself a RegionField) */ + + Status = AcpiExInsertIntoField (ObjDesc->IndexField.IndexObj, + &ObjDesc->IndexField.Value, + sizeof (ObjDesc->IndexField.Value)); + if (ACPI_FAILURE (Status)) + { + return_ACPI_STATUS (Status); + } + + if (ReadWrite == ACPI_READ) + { + /* Read the datum from the DataRegister */ + + Status = AcpiExExtractFromField (ObjDesc->IndexField.DataObj, + Value, ObjDesc->CommonField.AccessByteWidth); + } + else + { + /* Write the datum to the Data register */ + + Status = AcpiExInsertIntoField (ObjDesc->IndexField.DataObj, + Value, ObjDesc->CommonField.AccessByteWidth); } break; default: - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%p, wrong source type - %s\n", + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%p, Wrong object type - %s\n", ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type))); Status = AE_AML_INTERNAL; break; } + if (ACPI_SUCCESS (Status)) + { + if (ReadWrite == ACPI_READ) + { + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value Read=%8.8X%8.8X\n", + HIDWORD(*Value), LODWORD(*Value))); + } + else + { + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value Written=%8.8X%8.8X\n", + HIDWORD(*Value), LODWORD(*Value))); + } + } + + return_ACPI_STATUS (Status); +} + + +/******************************************************************************* + * + * FUNCTION: AcpiExWriteWithUpdateRule + * + * PARAMETERS: *ObjDesc - Field to be set + * Value - Value to store + * + * RETURN: Status + * + * DESCRIPTION: Apply the field update rule to a field write + * + ******************************************************************************/ + +ACPI_STATUS +AcpiExWriteWithUpdateRule ( + ACPI_OPERAND_OBJECT *ObjDesc, + ACPI_INTEGER Mask, + ACPI_INTEGER FieldValue, + UINT32 FieldDatumByteOffset) +{ + ACPI_STATUS Status = AE_OK; + ACPI_INTEGER MergedValue; + ACPI_INTEGER CurrentValue; + + + FUNCTION_TRACE_U32 ("ExWriteWithUpdateRule", Mask); + + + /* Start with the new bits */ + + MergedValue = FieldValue; + + /* If the mask is all ones, we don't need to worry about the update rule */ + + if (Mask != ACPI_UINT32_MAX) + { + /* Decode the update rule */ + + switch (ObjDesc->CommonField.FieldFlags & AML_FIELD_UPDATE_RULE_MASK) + { + case AML_FIELD_UPDATE_PRESERVE: + /* + * Check if update rule needs to be applied (not if mask is all + * ones) The left shift drops the bits we want to ignore. + */ + if ((~Mask << (sizeof (Mask) * 8 - + ObjDesc->CommonField.AccessBitWidth)) != 0) + { + /* + * Read the current contents of the byte/word/dword containing + * the field, and merge with the new field value. + */ + Status = AcpiExFieldDatumIo (ObjDesc, FieldDatumByteOffset, + &CurrentValue, ACPI_READ); + MergedValue |= (CurrentValue & ~Mask); + } + break; + + case AML_FIELD_UPDATE_WRITE_AS_ONES: + + /* Set positions outside the field to all ones */ + + MergedValue |= ~Mask; + break; + + case AML_FIELD_UPDATE_WRITE_AS_ZEROS: + + /* Set positions outside the field to all zeros */ + + MergedValue &= Mask; + break; + + default: + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "WriteWithUpdateRule: Unknown UpdateRule setting: %x\n", + (ObjDesc->CommonField.FieldFlags & AML_FIELD_UPDATE_RULE_MASK))); + return_ACPI_STATUS (AE_AML_OPERAND_VALUE); + break; + } + } + + /* Write the merged value */ + + Status = AcpiExFieldDatumIo (ObjDesc, FieldDatumByteOffset, + &MergedValue, ACPI_WRITE); - ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Returned value=%08X \n", *Value)); + ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, + "Mask %8.8X%8.8X DatumOffset %X Value %8.8X%8.8X, MergedValue %8.8X%8.8X\n", + HIDWORD(Mask), LODWORD(Mask), + FieldDatumByteOffset, + HIDWORD(FieldValue), LODWORD(FieldValue), + HIDWORD(MergedValue),LODWORD(MergedValue))); return_ACPI_STATUS (Status); } @@ -343,22 +649,22 @@ AcpiExReadFieldDatum ( * * FUNCTION: AcpiExGetBufferDatum * - * PARAMETERS: MergedDatum - Value to store - * Buffer - Receiving buffer - * ByteGranularity - 1/2/4 Granularity of the field + * PARAMETERS: Datum - Where the Datum is returned + * Buffer - Raw field buffer + * ByteGranularity - 1/2/4/8 Granularity of the field * (aka Datum Size) * Offset - Datum offset into the buffer * * RETURN: none * - * DESCRIPTION: Store the merged datum to the buffer according to the + * DESCRIPTION: Get a datum from the buffer according to the buffer field * byte granularity * ******************************************************************************/ -static void +void AcpiExGetBufferDatum( - UINT32 *Datum, + ACPI_INTEGER *Datum, void *Buffer, UINT32 ByteGranularity, UINT32 Offset) @@ -380,6 +686,10 @@ AcpiExGetBufferDatum( case ACPI_FIELD_DWORD_GRANULARITY: MOVE_UNALIGNED32_TO_32 (Datum, &(((UINT32 *) Buffer) [Offset])); break; + + case ACPI_FIELD_QWORD_GRANULARITY: + MOVE_UNALIGNED64_TO_64 (Datum, &(((UINT64 *) Buffer) [Offset])); + break; } } @@ -390,7 +700,7 @@ AcpiExGetBufferDatum( * * PARAMETERS: MergedDatum - Value to store * Buffer - Receiving buffer - * ByteGranularity - 1/2/4 Granularity of the field + * ByteGranularity - 1/2/4/8 Granularity of the field * (aka Datum Size) * Offset - Datum offset into the buffer * @@ -401,9 +711,9 @@ AcpiExGetBufferDatum( * ******************************************************************************/ -static void +void AcpiExSetBufferDatum ( - UINT32 MergedDatum, + ACPI_INTEGER MergedDatum, void *Buffer, UINT32 ByteGranularity, UINT32 Offset) @@ -425,6 +735,10 @@ AcpiExSetBufferDatum ( case ACPI_FIELD_DWORD_GRANULARITY: MOVE_UNALIGNED32_TO_32 (&(((UINT32 *) Buffer)[Offset]), &MergedDatum); break; + + case ACPI_FIELD_QWORD_GRANULARITY: + MOVE_UNALIGNED64_TO_64 (&(((UINT64 *) Buffer)[Offset]), &MergedDatum); + break; } } @@ -451,9 +765,9 @@ AcpiExExtractFromField ( ACPI_STATUS Status; UINT32 FieldDatumByteOffset; UINT32 DatumOffset; - UINT32 PreviousRawDatum; - UINT32 ThisRawDatum = 0; - UINT32 MergedDatum = 0; + ACPI_INTEGER PreviousRawDatum; + ACPI_INTEGER ThisRawDatum = 0; + ACPI_INTEGER MergedDatum = 0; UINT32 ByteFieldLength; UINT32 DatumCount; @@ -467,7 +781,8 @@ AcpiExExtractFromField ( ByteFieldLength = ROUND_BITS_UP_TO_BYTES (ObjDesc->CommonField.BitLength); if (ByteFieldLength > BufferLength) { - ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Field size %X (bytes) too large for buffer (%X)\n", + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, + "Field size %X (bytes) too large for buffer (%X)\n", ByteFieldLength, BufferLength)); return_ACPI_STATUS (AE_BUFFER_OVERFLOW); @@ -475,7 +790,8 @@ AcpiExExtractFromField ( /* Convert field byte count to datum count, round up if necessary */ - DatumCount = ROUND_UP_TO (ByteFieldLength, ObjDesc->CommonField.AccessByteWidth); + DatumCount = ROUND_UP_TO (ByteFieldLength, + ObjDesc->CommonField.AccessByteWidth); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ByteLen=%x, DatumLen=%x, BitGran=%x, ByteGran=%x\n", @@ -494,7 +810,8 @@ AcpiExExtractFromField ( FieldDatumByteOffset = 0; DatumOffset= 0; - Status = AcpiExReadFieldDatum (ObjDesc, FieldDatumByteOffset, &PreviousRawDatum); + Status = AcpiExFieldDatumIo (ObjDesc, FieldDatumByteOffset, + &PreviousRawDatum, ACPI_READ); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); @@ -504,7 +821,7 @@ AcpiExExtractFromField ( /* We might actually be done if the request fits in one datum */ if ((DatumCount == 1) && - (ObjDesc->CommonField.AccessFlags & AFIELD_SINGLE_DATUM)) + (ObjDesc->CommonField.Flags & AOPOBJ_SINGLE_DATUM)) { /* 1) Shift the valid data bits down to start at bit 0 */ @@ -537,18 +854,19 @@ AcpiExExtractFromField ( * to perform a final read, since this would potentially read * past the end of the region. * - * TBD: [Investigate] It may make more sense to just split the aligned - * and non-aligned cases since the aligned case is so very simple, + * We could just split the aligned and non-aligned cases since the + * aligned case is so very simple, but this would require more code. */ - if ((ObjDesc->CommonField.StartFieldBitOffset != 0) || - ((ObjDesc->CommonField.StartFieldBitOffset == 0) && + if ((ObjDesc->CommonField.StartFieldBitOffset != 0) || + ((ObjDesc->CommonField.StartFieldBitOffset == 0) && (DatumOffset < (DatumCount -1)))) { /* * Get the next raw datum, it contains some or all bits * of the current field datum */ - Status = AcpiExReadFieldDatum (ObjDesc, FieldDatumByteOffset, &ThisRawDatum); + Status = AcpiExFieldDatumIo (ObjDesc, FieldDatumByteOffset, + &ThisRawDatum, ACPI_READ); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); @@ -564,7 +882,6 @@ AcpiExExtractFromField ( MergedDatum = PreviousRawDatum; } - else { /* @@ -599,8 +916,8 @@ AcpiExExtractFromField ( * Store the merged field datum in the caller's buffer, according to * the granularity of the field (size of each datum). */ - AcpiExSetBufferDatum (MergedDatum, Buffer, ObjDesc->CommonField.AccessByteWidth, - DatumOffset); + AcpiExSetBufferDatum (MergedDatum, Buffer, + ObjDesc->CommonField.AccessByteWidth, DatumOffset); /* * Save the raw datum that was just acquired since it may contain bits @@ -616,218 +933,6 @@ AcpiExExtractFromField ( /******************************************************************************* * - * FUNCTION: AcpiExWriteFieldDatum - * - * PARAMETERS: *ObjDesc - Field to be set - * Value - Value to store - * - * RETURN: Status - * - * DESCRIPTION: Store the value into the given field - * - ******************************************************************************/ - -static ACPI_STATUS -AcpiExWriteFieldDatum ( - ACPI_OPERAND_OBJECT *ObjDesc, - UINT32 FieldDatumByteOffset, - UINT32 Value) -{ - ACPI_STATUS Status = AE_OK; - ACPI_OPERAND_OBJECT *RgnDesc = NULL; - ACPI_PHYSICAL_ADDRESS Address; - - - FUNCTION_TRACE_U32 ("ExWriteFieldDatum", FieldDatumByteOffset); - - - /* - * BufferFields - Read from a Buffer - * Other Fields - Read from a Operation Region. - */ - switch (ObjDesc->Common.Type) - { - case ACPI_TYPE_BUFFER_FIELD: - - /* - * For BufferFields, we only need to copy the data to the - * target buffer. Length is the field width in bytes. - */ - MEMCPY ((ObjDesc->BufferField.BufferObj)->Buffer.Pointer - + ObjDesc->BufferField.BaseByteOffset + FieldDatumByteOffset, - &Value, ObjDesc->CommonField.AccessByteWidth); - Status = AE_OK; - break; - - - case INTERNAL_TYPE_REGION_FIELD: - case INTERNAL_TYPE_BANK_FIELD: - - /* - * For other fields, we need to go through an Operation Region - * (Only types that will get here are RegionFields and BankFields) - */ - Status = AcpiExSetupField (ObjDesc, FieldDatumByteOffset); - if (ACPI_FAILURE (Status)) - { - return_ACPI_STATUS (Status); - } - - /* - * The physical address of this field datum is: - * - * 1) The base of the region, plus - * 2) The base offset of the field, plus - * 3) The current offset into the field - */ - RgnDesc = ObjDesc->CommonField.RegionObj; - Address = RgnDesc->Region.Address + - ObjDesc->CommonField.BaseByteOffset + - FieldDatumByteOffset; - - ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, - "Store %X in Region %s(%X) at %8.8X%8.8X width %X\n", - Value, AcpiUtGetRegionName (RgnDesc->Region.SpaceId), - RgnDesc->Region.SpaceId, HIDWORD(Address), LODWORD(Address), - ObjDesc->CommonField.AccessBitWidth)); - - /* Invoke the appropriate AddressSpace/OpRegion handler */ - - Status = AcpiEvAddressSpaceDispatch (RgnDesc, ACPI_WRITE_ADR_SPACE, - Address, ObjDesc->CommonField.AccessBitWidth, &Value); - - if (Status == AE_NOT_IMPLEMENTED) - { - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "**** Region type %s(%X) not implemented\n", - AcpiUtGetRegionName (RgnDesc->Region.SpaceId), - RgnDesc->Region.SpaceId)); - } - - else if (Status == AE_NOT_EXIST) - { - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "**** Region type %s(%X) does not have a handler\n", - AcpiUtGetRegionName (RgnDesc->Region.SpaceId), - RgnDesc->Region.SpaceId)); - } - - break; - - - default: - - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%p, wrong source type - %s\n", - ObjDesc, AcpiUtGetTypeName (ObjDesc->Common.Type))); - Status = AE_AML_INTERNAL; - break; - } - - - ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value written=%08X \n", Value)); - return_ACPI_STATUS (Status); -} - - -/******************************************************************************* - * - * FUNCTION: AcpiExWriteFieldDatumWithUpdateRule - * - * PARAMETERS: *ObjDesc - Field to be set - * Value - Value to store - * - * RETURN: Status - * - * DESCRIPTION: Apply the field update rule to a field write - * - ******************************************************************************/ - -static ACPI_STATUS -AcpiExWriteFieldDatumWithUpdateRule ( - ACPI_OPERAND_OBJECT *ObjDesc, - UINT32 Mask, - UINT32 FieldValue, - UINT32 FieldDatumByteOffset) -{ - ACPI_STATUS Status = AE_OK; - UINT32 MergedValue; - UINT32 CurrentValue; - - - FUNCTION_TRACE ("ExWriteFieldDatumWithUpdateRule"); - - - /* Start with the new bits */ - - MergedValue = FieldValue; - - /* If the mask is all ones, we don't need to worry about the update rule */ - - if (Mask != ACPI_UINT32_MAX) - { - /* Decode the update rule */ - - switch (ObjDesc->CommonField.UpdateRule) - { - case UPDATE_PRESERVE: - /* - * Check if update rule needs to be applied (not if mask is all - * ones) The left shift drops the bits we want to ignore. - */ - if ((~Mask << (sizeof (Mask) * 8 - - ObjDesc->CommonField.AccessBitWidth)) != 0) - { - /* - * Read the current contents of the byte/word/dword containing - * the field, and merge with the new field value. - */ - Status = AcpiExReadFieldDatum (ObjDesc, FieldDatumByteOffset, - &CurrentValue); - MergedValue |= (CurrentValue & ~Mask); - } - break; - - - case UPDATE_WRITE_AS_ONES: - - /* Set positions outside the field to all ones */ - - MergedValue |= ~Mask; - break; - - - case UPDATE_WRITE_AS_ZEROS: - - /* Set positions outside the field to all zeros */ - - MergedValue &= Mask; - break; - - - default: - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "WriteWithUpdateRule: Unknown UpdateRule setting: %x\n", - ObjDesc->CommonField.UpdateRule)); - return_ACPI_STATUS (AE_AML_OPERAND_VALUE); - break; - } - } - - - /* Write the merged value */ - - Status = AcpiExWriteFieldDatum (ObjDesc, FieldDatumByteOffset, - MergedValue); - - ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Mask %X DatumOffset %X Value %X, MergedValue %X\n", - Mask, FieldDatumByteOffset, FieldValue, MergedValue)); - - return_ACPI_STATUS (Status); -} - - -/******************************************************************************* - * * FUNCTION: AcpiExInsertIntoField * * PARAMETERS: *ObjDesc - Field to be set @@ -848,10 +953,10 @@ AcpiExInsertIntoField ( ACPI_STATUS Status; UINT32 FieldDatumByteOffset; UINT32 DatumOffset; - UINT32 Mask; - UINT32 MergedDatum; - UINT32 PreviousRawDatum; - UINT32 ThisRawDatum; + ACPI_INTEGER Mask; + ACPI_INTEGER MergedDatum; + ACPI_INTEGER PreviousRawDatum; + ACPI_INTEGER ThisRawDatum; UINT32 ByteFieldLength; UINT32 DatumCount; @@ -871,8 +976,6 @@ AcpiExInsertIntoField ( ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Buffer length %X too small for field %X\n", BufferLength, ByteFieldLength)); - /* TBD: Need a better error code */ - return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } @@ -913,7 +1016,7 @@ AcpiExInsertIntoField ( /* If the field fits in one datum, may need to mask upper bits */ - if ((ObjDesc->CommonField.AccessFlags & AFIELD_SINGLE_DATUM) && + if ((ObjDesc->CommonField.Flags & AOPOBJ_SINGLE_DATUM) && ObjDesc->CommonField.EndFieldValidBits) { /* There are bits above the field, mask them off also */ @@ -928,7 +1031,7 @@ AcpiExInsertIntoField ( /* Apply the update rule (if necessary) and write the datum to the field */ - Status = AcpiExWriteFieldDatumWithUpdateRule (ObjDesc, Mask, MergedDatum, + Status = AcpiExWriteWithUpdateRule (ObjDesc, Mask, MergedDatum, FieldDatumByteOffset); if (ACPI_FAILURE (Status)) { @@ -938,7 +1041,7 @@ AcpiExInsertIntoField ( /* If the entire field fits within one datum, we are done. */ if ((DatumCount == 1) && - (ObjDesc->CommonField.AccessFlags & AFIELD_SINGLE_DATUM)) + (ObjDesc->CommonField.Flags & AOPOBJ_SINGLE_DATUM)) { return_ACPI_STATUS (AE_OK); } @@ -978,7 +1081,6 @@ AcpiExInsertIntoField ( (PreviousRawDatum >> ObjDesc->CommonField.DatumValidBits) | (ThisRawDatum << ObjDesc->CommonField.StartFieldBitOffset); } - else { /* Field began aligned on datum boundary */ @@ -1011,21 +1113,20 @@ AcpiExInsertIntoField ( /* Write the last datum with the update rule */ - Status = AcpiExWriteFieldDatumWithUpdateRule (ObjDesc, Mask, - MergedDatum, FieldDatumByteOffset); + Status = AcpiExWriteWithUpdateRule (ObjDesc, Mask, MergedDatum, + FieldDatumByteOffset); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); } } } - else { /* Normal case -- write the completed datum */ - Status = AcpiExWriteFieldDatum (ObjDesc, - FieldDatumByteOffset, MergedDatum); + Status = AcpiExFieldDatumIo (ObjDesc, FieldDatumByteOffset, + &MergedDatum, ACPI_WRITE); if (ACPI_FAILURE (Status)) { return_ACPI_STATUS (Status); diff --git a/sys/contrib/dev/acpica/hwsleep.c b/sys/contrib/dev/acpica/hwsleep.c index 29336b2..2015b32 100644 --- a/sys/contrib/dev/acpica/hwsleep.c +++ b/sys/contrib/dev/acpica/hwsleep.c @@ -2,7 +2,7 @@ /****************************************************************************** * * Name: hwsleep.c - ACPI Hardware Sleep/Wake Interface - * $Revision: 22 $ + * $Revision: 25 $ * *****************************************************************************/ @@ -122,6 +122,9 @@ #define _COMPONENT ACPI_HARDWARE MODULE_NAME ("hwsleep") +static UINT8 SleepTypeA; +static UINT8 SleepTypeB; + /****************************************************************************** * @@ -214,42 +217,40 @@ AcpiGetFirmwareWakingVector ( return_ACPI_STATUS (AE_OK); } + /****************************************************************************** * - * FUNCTION: AcpiEnterSleepState + * FUNCTION: AcpiEnterSleepStatePrep * * PARAMETERS: SleepState - Which sleep state to enter * * RETURN: Status * - * DESCRIPTION: Enter a system sleep state (see ACPI 2.0 spec p 231) + * DESCRIPTION: Prepare to enter a system sleep state (see ACPI 2.0 spec p 231) + * This function must execute with interrupts enabled. + * We break sleeping into 2 stages so that OSPM can handle + * various OS-specific tasks between the two steps. * ******************************************************************************/ ACPI_STATUS -AcpiEnterSleepState ( +AcpiEnterSleepStatePrep ( UINT8 SleepState) { ACPI_STATUS Status; ACPI_OBJECT_LIST ArgList; ACPI_OBJECT Arg; - UINT8 TypeA; - UINT8 TypeB; - UINT16 PM1AControl; - UINT16 PM1BControl; - UINT32 Retry; - - FUNCTION_TRACE ("AcpiEnterSleepState"); + FUNCTION_TRACE ("AcpiEnterSleepStatePrep"); /* * _PSW methods could be run here to enable wake-on keyboard, LAN, etc. */ - Status = AcpiHwObtainSleepTypeRegisterData (SleepState, &TypeA, &TypeB); + Status = AcpiHwObtainSleepTypeRegisterData (SleepState, &SleepTypeA, &SleepTypeB); if (!ACPI_SUCCESS (Status)) { - return Status; + return_ACPI_STATUS (Status); } /* run the _PTS and _GTS methods */ @@ -265,11 +266,50 @@ AcpiEnterSleepState ( AcpiEvaluateObject (NULL, "\\_PTS", &ArgList, NULL); AcpiEvaluateObject (NULL, "\\_GTS", &ArgList, NULL); + return_ACPI_STATUS (AE_OK); +} + + + +/****************************************************************************** + * + * FUNCTION: AcpiEnterSleepState + * + * PARAMETERS: SleepState - Which sleep state to enter + * + * RETURN: Status + * + * DESCRIPTION: Enter a system sleep state (see ACPI 2.0 spec p 231) + * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED + * + ******************************************************************************/ + +ACPI_STATUS +AcpiEnterSleepState ( + UINT8 SleepState) +{ + UINT16 PM1AControl; + UINT16 PM1BControl; + UINT32 Retry; + + + FUNCTION_TRACE ("AcpiEnterSleepState"); + + if ((SleepTypeA > ACPI_SLEEP_TYPE_MAX) || + (SleepTypeB > ACPI_SLEEP_TYPE_MAX)) + { + REPORT_ERROR (("Sleep values out of range: A=%x B=%x\n", + SleepTypeA, SleepTypeB)); + return_ACPI_STATUS (AE_ERROR); + } + /* clear wake status */ AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, WAK_STS, 1); - disable (); + AcpiHwClearAcpiStatus(); + + /* disable arbitration here? */ AcpiHwDisableNonWakeupGpes(); @@ -284,8 +324,8 @@ AcpiEnterSleepState ( /* mask in SLP_TYP */ - PM1AControl |= (TypeA << AcpiHwGetBitShift (SLP_TYPE_X_MASK)); - PM1BControl |= (TypeB << AcpiHwGetBitShift (SLP_TYPE_X_MASK)); + PM1AControl |= (SleepTypeA << AcpiHwGetBitShift (SLP_TYPE_X_MASK)); + PM1BControl |= (SleepTypeB << AcpiHwGetBitShift (SLP_TYPE_X_MASK)); /* write #1: fill in SLP_TYP data */ @@ -297,10 +337,6 @@ AcpiEnterSleepState ( PM1AControl |= (1 << AcpiHwGetBitShift (SLP_EN_MASK)); PM1BControl |= (1 << AcpiHwGetBitShift (SLP_EN_MASK)); - /* flush caches */ - - wbinvd(); - /* write #2: SLP_TYP + SLP_EN */ AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1A_CONTROL, PM1AControl); @@ -319,8 +355,9 @@ AcpiEnterSleepState ( /* wait until we enter sleep state */ + /* spin until we wake */ Retry = 1000; - do + while (!AcpiHwRegisterBitAccess (ACPI_READ, ACPI_MTX_LOCK, WAK_STS)) { /* * Some BIOSes don't set WAK_STS at all, @@ -330,11 +367,6 @@ AcpiEnterSleepState ( break; /* giving up */ } } - while (!AcpiHwRegisterBitAccess (ACPI_READ, ACPI_MTX_LOCK, WAK_STS)); - - AcpiHwEnableNonWakeupGpes(); - - enable (); return_ACPI_STATUS (AE_OK); } @@ -361,6 +393,8 @@ AcpiLeaveSleepState ( FUNCTION_TRACE ("AcpiLeaveSleepState"); + /* Ensure EnterSleepStatePrep -> EnterSleepState ordering */ + SleepTypeA = ACPI_SLEEP_TYPE_INVALID; MEMSET (&ArgList, 0, sizeof(ArgList)); ArgList.Count = 1; diff --git a/sys/contrib/dev/acpica/psparse.c b/sys/contrib/dev/acpica/psparse.c index 1829586..2cc8625 100644 --- a/sys/contrib/dev/acpica/psparse.c +++ b/sys/contrib/dev/acpica/psparse.c @@ -1,7 +1,7 @@ /****************************************************************************** * * Module Name: psparse - Parser top level AML parse routines - * $Revision: 104 $ + * $Revision: 109 $ * *****************************************************************************/ @@ -152,7 +152,7 @@ extern UINT32 AcpiGbl_ScopeDepth; * ******************************************************************************/ -static UINT32 +UINT32 AcpiPsGetOpcodeSize ( UINT32 Opcode) { @@ -193,31 +193,15 @@ AcpiPsPeekOpcode ( Aml = ParserState->Aml; Opcode = (UINT16) GET8 (Aml); - Aml++; - - /* - * Original code special cased LNOTEQUAL, LLESSEQUAL, LGREATEREQUAL. - * These opcodes are no longer recognized. Instead, they are broken into - * two opcodes. - * - * - * if (Opcode == AML_EXTOP - * || (Opcode == AML_LNOT - * && (GET8 (Aml) == AML_LEQUAL - * || GET8 (Aml) == AML_LGREATER - * || GET8 (Aml) == AML_LLESS))) - * - * extended Opcode, !=, <=, or >= - */ if (Opcode == AML_EXTOP) { /* Extended opcode */ + Aml++; Opcode = (UINT16) ((Opcode << 8) | GET8 (Aml)); } - return (Opcode); } @@ -289,7 +273,7 @@ AcpiPsFindObject ( * ******************************************************************************/ -static BOOLEAN +BOOLEAN AcpiPsCompleteThisOp ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op) @@ -304,8 +288,6 @@ AcpiPsCompleteThisOp ( FUNCTION_TRACE_PTR ("PsCompleteThisOp", Op); - - /* Delete this op and the subtree below it if asked to */ if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) == ACPI_PARSE_DELETE_TREE) && @@ -323,23 +305,30 @@ AcpiPsCompleteThisOp ( switch (ParentInfo->Class) { - case AML_CLASS_CONTROL: /* IF, ELSE, WHILE only */ + case AML_CLASS_CONTROL: break; - case AML_CLASS_NAMED_OBJECT: /* Scope, method, etc. */ case AML_CLASS_CREATE: /* * These opcodes contain TermArg operands. The current * op must be replace by a placeholder return op */ + ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP); + if (!ReplacementOp) + { + return_VALUE (FALSE); + } + break; + + case AML_CLASS_NAMED_OBJECT: + + /* + * These opcodes contain TermArg operands. The current + * op must be replace by a placeholder return op + */ if ((Op->Parent->Opcode == AML_REGION_OP) || - (Op->Parent->Opcode == AML_CREATE_FIELD_OP) || - (Op->Parent->Opcode == AML_CREATE_BIT_FIELD_OP) || - (Op->Parent->Opcode == AML_CREATE_BYTE_FIELD_OP) || - (Op->Parent->Opcode == AML_CREATE_WORD_FIELD_OP) || - (Op->Parent->Opcode == AML_CREATE_DWORD_FIELD_OP) || - (Op->Parent->Opcode == AML_CREATE_QWORD_FIELD_OP)) + (Op->Parent->Opcode == AML_DATA_REGION_OP)) { ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP); if (!ReplacementOp) @@ -347,7 +336,6 @@ AcpiPsCompleteThisOp ( return_VALUE (FALSE); } } - break; default: @@ -404,7 +392,6 @@ AcpiPsCompleteThisOp ( Prev = Next; } - } /* Now we can actually delete the subtree rooted at op */ @@ -434,7 +421,7 @@ AcpiPsCompleteThisOp ( * ******************************************************************************/ -static ACPI_STATUS +ACPI_STATUS AcpiPsNextParseState ( ACPI_WALK_STATE *WalkState, ACPI_PARSE_OBJECT *Op, @@ -478,6 +465,7 @@ AcpiPsNextParseState ( case AE_CTRL_TRUE: + /* * Predicate of an IF was true, and we are at the matching ELSE. * Just close out this package @@ -714,9 +702,6 @@ AcpiPsParseLoop ( WalkState->Op = NULL; Status = WalkState->DescendingCallback (WalkState, &Op); - - /* TBD: check status here? */ - if (ACPI_FAILURE (Status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "During name lookup/catalog, %s\n", @@ -728,6 +713,7 @@ AcpiPsParseLoop ( { continue; } + Status = AcpiPsNextParseState (WalkState, Op, Status); if (Status == AE_CTRL_PENDING) { @@ -744,7 +730,6 @@ AcpiPsParseLoop ( AcpiPsAppendArg (Op, PreOp.Value.Arg); AcpiGbl_Depth++; - if (Op->Opcode == AML_REGION_OP) { /* @@ -764,7 +749,6 @@ AcpiPsParseLoop ( } } - else { /* Not a named opcode, just allocate Op and append to parent */ @@ -776,7 +760,6 @@ AcpiPsParseLoop ( return_ACPI_STATUS (AE_NO_MEMORY); } - if (WalkState->OpInfo->Flags & AML_CREATE) { /* @@ -795,7 +778,7 @@ AcpiPsParseLoop ( * Find the object. This will either insert the object into * the namespace or simply look it up */ - WalkState->Op = Op; + WalkState->Op = Op; Status = WalkState->DescendingCallback (WalkState, &Op); Status = AcpiPsNextParseState (WalkState, Op, Status); @@ -827,7 +810,6 @@ AcpiPsParseLoop ( WalkState->ArgCount = 0; - if (WalkState->ArgTypes) /* Are there any arguments that must be processed? */ { /* get arguments */ @@ -872,7 +854,6 @@ AcpiPsParseLoop ( INCREMENT_ARG_LIST (WalkState->ArgTypes); } - /* For a method, save the length and address of the body */ if (Op->Opcode == AML_METHOD_OP) @@ -960,7 +941,6 @@ AcpiPsParseLoop ( CloseThisOp: - /* * Finished one argument of the containing scope */ @@ -973,7 +953,6 @@ CloseThisOp: Op = NULL; } - switch (Status) { case AE_OK: @@ -1019,8 +998,8 @@ CloseThisOp: { AcpiPsCompleteThisOp (WalkState, Op); } - AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount); + } while (Op); return_ACPI_STATUS (Status); @@ -1037,9 +1016,8 @@ CloseThisOp: WalkState->PrevArgTypes = WalkState->ArgTypes; /* - * TEMP: + * TBD: TEMP: */ - return_ACPI_STATUS (Status); break; } @@ -1051,19 +1029,14 @@ CloseThisOp: AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount); ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op)); } - else { Op = NULL; } - } - - - /* ArgCount is non-zero */ - else { + /* ArgCount is non-zero */ /* complex argument, push Op and prepare for argument */ AcpiPsPushScope (ParserState, Op, WalkState->ArgTypes, WalkState->ArgCount); @@ -1156,8 +1129,8 @@ AcpiPsParseAml ( ACPI_WALK_STATE *WalkState) { ACPI_STATUS Status; - ACPI_WALK_LIST WalkList; - ACPI_WALK_LIST *PrevWalkList = AcpiGbl_CurrentWalkList; + ACPI_THREAD_STATE *Thread; + ACPI_THREAD_STATE *PrevWalkList = AcpiGbl_CurrentWalkList; ACPI_WALK_STATE *PreviousWalkState; ACPI_OPERAND_OBJECT **CallerReturnDesc = WalkState->CallerReturnDesc; ACPI_OPERAND_OBJECT *EffectiveReturnDesc = NULL; @@ -1170,19 +1143,21 @@ AcpiPsParseAml ( WalkState, WalkState->ParserState.Aml, WalkState->ParserState.AmlSize)); - /* Create and initialize a new walk list */ + /* Create and initialize a new thread state */ - WalkList.WalkState = NULL; - WalkList.AcquiredMutexList.Prev = NULL; - WalkList.AcquiredMutexList.Next = NULL; + Thread = AcpiUtCreateThreadState (); + if (!Thread) + { + return_ACPI_STATUS (AE_NO_MEMORY); + } - WalkState->WalkList = &WalkList; - AcpiDsPushWalkState (WalkState, &WalkList); + WalkState->Thread = Thread; + AcpiDsPushWalkState (WalkState, Thread); /* TBD: [Restructure] TEMP until we pass WalkState to the interpreter */ - AcpiGbl_CurrentWalkList = &WalkList; + AcpiGbl_CurrentWalkList = Thread; /* * Execute the walk loop as long as there is a valid Walk State. This @@ -1211,13 +1186,13 @@ AcpiPsParseAml ( * A method call was detected. * Transfer control to the called control method */ - Status = AcpiDsCallControlMethod (&WalkList, WalkState, NULL); + Status = AcpiDsCallControlMethod (Thread, WalkState, NULL); /* * If the transfer to the new method method call worked, a new walk * state was created -- get it */ - WalkState = AcpiDsGetCurrentWalkState (&WalkList); + WalkState = AcpiDsGetCurrentWalkState (Thread); continue; } @@ -1228,7 +1203,7 @@ AcpiPsParseAml ( /* We are done with this walk, move on to the parent if any */ - WalkState = AcpiDsPopWalkState (&WalkList); + WalkState = AcpiDsPopWalkState (Thread); /* Save the last effective return value */ @@ -1263,7 +1238,7 @@ AcpiPsParseAml ( /* Check if we have restarted a preempted walk */ - WalkState = AcpiDsGetCurrentWalkState (&WalkList); + WalkState = AcpiDsGetCurrentWalkState (Thread); if (WalkState) { if (ACPI_SUCCESS (Status)) @@ -1309,11 +1284,11 @@ AcpiPsParseAml ( AcpiDsDeleteWalkState (PreviousWalkState); } - /* Normal exit */ AcpiUtRemoveReference (EffectiveReturnDesc); - AcpiExReleaseAllMutexes ((ACPI_OPERAND_OBJECT *) &WalkList.AcquiredMutexList); + AcpiExReleaseAllMutexes (Thread); + AcpiUtDeleteGenericState ((ACPI_GENERIC_STATE *) Thread); AcpiGbl_CurrentWalkList = PrevWalkList; return_ACPI_STATUS (Status); } diff --git a/sys/contrib/dev/acpica/rscreate.c b/sys/contrib/dev/acpica/rscreate.c index 14aaf5d..60edaa5 100644 --- a/sys/contrib/dev/acpica/rscreate.c +++ b/sys/contrib/dev/acpica/rscreate.c @@ -266,9 +266,9 @@ AcpiRsCreatePciRoutingTable ( if (BufferSizeNeeded > *OutputBufferLength) { + *OutputBufferLength = BufferSizeNeeded; return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } - *OutputBufferLength = BufferSizeNeeded; /* * Zero out the return buffer before proceeding diff --git a/sys/contrib/dev/acpica/tbget.c b/sys/contrib/dev/acpica/tbget.c index a6c3cf5..ff8538b 100644 --- a/sys/contrib/dev/acpica/tbget.c +++ b/sys/contrib/dev/acpica/tbget.c @@ -1,7 +1,7 @@ /****************************************************************************** * * Module Name: tbget - ACPI Table get* routines - * $Revision: 56 $ + * $Revision: 57 $ * *****************************************************************************/ @@ -467,13 +467,6 @@ AcpiTbGetAllTables ( AcpiGbl_DSDT->Length, AcpiGbl_DSDT->Length)); DUMP_BUFFER ((UINT8 *) (AcpiGbl_DSDT + 1), AcpiGbl_DSDT->Length); - /* - * Initialize the capabilities flags. - * Assumes that platform supports ACPI_MODE since we have tables! - */ - AcpiGbl_SystemFlags |= AcpiHwGetModeCapabilities (); - - /* Always delete the RSDP mapping, we are done with it */ AcpiTbDeleteAcpiTable (ACPI_TABLE_RSDP); -- cgit v1.1