mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-17 10:26:15 +00:00
Code Issues Releases Activity

Resolve conflicts arising from the ACPI CA 20020217 import.

Browse Source
This commit is contained in:
Mike Smith 2002-02-23 05:16:34 +00:00
parent 8f296b2e5d
commit afa56f0b6d
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=91119
12 changed files with 612 additions and 539 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
sys/contrib/dev/acpica/acconfig.h
View File

@ -1,7 +1,7 @@
/****************************************************************************** /******************************************************************************
* *
* Name: acconfig.h - Global configuration constants * Name: acconfig.h - Global configuration constants
* $Revision: 78 $ * $Revision: 90 $
* *
*****************************************************************************/ *****************************************************************************/
@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -125,9 +125,9 @@
*****************************************************************************/ *****************************************************************************/
/* /*
* ACPI_DEBUG - This switch enables all the debug facilities of the * ACPI_DEBUG - This switch enables all the debug facilities of the
* ACPI subsystem. This includes the DEBUG_PRINT output * ACPI subsystem. This includes the DEBUG_PRINT output
* statements. When disabled, all DEBUG_PRINT * statements. When disabled, all DEBUG_PRINT
* statements are compiled out. * statements are compiled out.
* *
* ACPI_APPLICATION - Use this switch if the subsystem is going to be run * ACPI_APPLICATION - Use this switch if the subsystem is going to be run
@ -145,13 +145,12 @@
/* Version string */ /* Version string */
#define ACPI_CA_VERSION 0x20011120 #define ACPI_CA_VERSION 0x20020214
/* Version of ACPI supported */ /* Version of ACPI supported */
#define ACPI_CA_SUPPORT_LEVEL 2 #define ACPI_CA_SUPPORT_LEVEL 2
/* Maximum objects in the various object caches */ /* 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 */
@ -160,28 +159,30 @@
#define MAX_OBJECT_CACHE_DEPTH 64 /* Interpreter operand objects */ #define MAX_OBJECT_CACHE_DEPTH 64 /* Interpreter operand objects */
#define MAX_WALK_CACHE_DEPTH 4 /* Objects for parse tree walks */ #define MAX_WALK_CACHE_DEPTH 4 /* Objects for parse tree walks */
/* String size constants */ /* String size constants */
#define MAX_STRING_LENGTH 512 #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 */ /* Maximum count for a semaphore object */
#define MAX_SEMAPHORE_COUNT 256 #define MAX_SEMAPHORE_COUNT 256
/* Max reference count (for debug only) */ /* Max reference count (for debug only) */
#define MAX_REFERENCE_COUNT 0x400 #define MAX_REFERENCE_COUNT 0x400
/* Size of cached memory mapping for system memory operation region */ /* Size of cached memory mapping for system memory operation region */
#define SYSMEM_REGION_WINDOW_SIZE 4096 #define SYSMEM_REGION_WINDOW_SIZE 4096
/******************************************************************************
*
* Configuration of subsystem behavior
*
*****************************************************************************/
/* /*
* Debugger threading model * Debugger threading model
* Use single threaded if the entire subsystem is contained in an application * Use single threaded if the entire subsystem is contained in an application
@ -190,7 +191,6 @@
* By default the model is single threaded if ACPI_APPLICATION is set, * By default the model is single threaded if ACPI_APPLICATION is set,
* multi-threaded if ACPI_APPLICATION is not set. * multi-threaded if ACPI_APPLICATION is not set.
*/ */
#define DEBUGGER_SINGLE_THREADED 0 #define DEBUGGER_SINGLE_THREADED 0
#define DEBUGGER_MULTI_THREADED 1 #define DEBUGGER_MULTI_THREADED 1
@ -203,16 +203,26 @@
#endif #endif
#endif #endif
/*
* Should the subystem abort the loading of an ACPI table if the
* table checksum is incorrect?
*/
#define ACPI_CHECKSUM_ABORT FALSE
/****************************************************************************** /******************************************************************************
* *
* ACPI Specification constants (Do not change unless the specification changes) * ACPI Specification constants (Do not change unless the specification changes)
* *
*****************************************************************************/ *****************************************************************************/
/* Number of distinct GPE register blocks */
#define ACPI_MAX_GPE_BLOCKS 2
/* /*
* Method info (in WALK_STATE), containing local variables and argumetns * Method info (in WALK_STATE), containing local variables and argumetns
*/ */
#define MTH_NUM_LOCALS 8 #define MTH_NUM_LOCALS 8
#define MTH_MAX_LOCAL 7 #define MTH_MAX_LOCAL 7
@ -226,7 +236,6 @@
/* /*
* Operand Stack (in WALK_STATE), Must be large enough to contain MTH_MAX_ARG * Operand Stack (in WALK_STATE), Must be large enough to contain MTH_MAX_ARG
*/ */
#define OBJ_NUM_OPERANDS 8 #define OBJ_NUM_OPERANDS 8
#define OBJ_MAX_OPERAND 7 #define OBJ_MAX_OPERAND 7
@ -236,7 +245,6 @@
#define PATH_SEGMENT_LENGTH 5 /* 4 chars for name + 1 char for separator */ #define PATH_SEGMENT_LENGTH 5 /* 4 chars for name + 1 char for separator */
#define PATH_SEPARATOR '.' #define PATH_SEPARATOR '.'
/* Constants used in searching for the RSDP in low memory */ /* Constants used in searching for the RSDP in low memory */
#define LO_RSDP_WINDOW_BASE 0 /* Physical Address */ #define LO_RSDP_WINDOW_BASE 0 /* Physical Address */
@ -245,16 +253,33 @@
#define HI_RSDP_WINDOW_SIZE 0x20000 #define HI_RSDP_WINDOW_SIZE 0x20000
#define RSDP_SCAN_STEP 16 #define RSDP_SCAN_STEP 16
/* Operation regions */ /* Operation regions */
#define ACPI_NUM_PREDEFINED_REGIONS 7 #define ACPI_NUM_PREDEFINED_REGIONS 8
#define ACPI_USER_REGION_BEGIN 0x80 #define ACPI_USER_REGION_BEGIN 0x80
/* Maximum SpaceIds for Operation Regions */ /* Maximum SpaceIds for Operation Regions */
#define ACPI_MAX_ADDRESS_SPACE 255 #define ACPI_MAX_ADDRESS_SPACE 255
/* RSDP checksums */
#define ACPI_RSDP_CHECKSUM_LENGTH 20
#define ACPI_RSDP_XCHECKSUM_LENGTH 36
/******************************************************************************
*
* ACPI AML Debugger
*
*****************************************************************************/
#define ACPI_DEBUGGER_MAX_ARGS 8 /* Must be max method args + 1 */
#define ACPI_DEBUGGER_COMMAND_PROMPT '-'
#define ACPI_DEBUGGER_EXECUTE_PROMPT '%'
#endif /* _ACCONFIG_H */ #endif /* _ACCONFIG_H */

4
sys/contrib/dev/acpica/acfreebsd.h
View File

@ -1,7 +1,7 @@
/****************************************************************************** /******************************************************************************
* *
* Name: acfreebsd.h - OS specific defines, etc. * Name: acfreebsd.h - OS specific defines, etc.
* $Revision: 6 $ * $Revision: 7 $
* *
*****************************************************************************/ *****************************************************************************/
@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License

12
sys/contrib/dev/acpica/acgcc.h
View File

@ -1,7 +1,7 @@
/****************************************************************************** /******************************************************************************
* *
* Name: acgcc.h - GCC specific defines, etc. * Name: acgcc.h - GCC specific defines, etc.
* $Revision: 15 $ * $Revision: 17 $
* *
*****************************************************************************/ *****************************************************************************/
@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -128,8 +128,8 @@
#define ACPI_ASM_MACROS #define ACPI_ASM_MACROS
#define causeinterrupt(level) #define causeinterrupt(level)
#define BREAKPOINT3 #define BREAKPOINT3
#define disable() __cli() #define acpi_disable_irqs() __cli()
#define enable() __sti() #define acpi_enable_irqs() __sti()
/*! [Begin] no source code translation */ /*! [Begin] no source code translation */
@ -189,8 +189,8 @@
#define ACPI_ASM_MACROS #define ACPI_ASM_MACROS
#define causeinterrupt(level) #define causeinterrupt(level)
#define BREAKPOINT3 #define BREAKPOINT3
#define disable() __cli() #define acpi_disable_irqs() __cli()
#define enable() __sti() #define acpi_enable_irqs() __sti()
#define halt() __asm__ __volatile__ ("sti; hlt":::"memory") #define halt() __asm__ __volatile__ ("sti; hlt":::"memory")
/*! [Begin] no source code translation /*! [Begin] no source code translation

4
sys/contrib/dev/acpica/acpi.h
View File

@ -1,7 +1,7 @@
/****************************************************************************** /******************************************************************************
* *
* Name: acpi.h - Master include file, Publics and external data. * Name: acpi.h - Master include file, Publics and external data.
* $Revision: 54 $ * $Revision: 55 $
* *
*****************************************************************************/ *****************************************************************************/
@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License

16
sys/contrib/dev/acpica/acpiosxf.h
View File

@ -12,7 +12,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -213,11 +213,7 @@ AcpiOsSignalSemaphore (
void * void *
AcpiOsAllocate ( AcpiOsAllocate (
UINT32 Size); ACPI_SIZE Size);
void *
AcpiOsCallocate (
UINT32 Size);
void void
AcpiOsFree ( AcpiOsFree (
@ -226,13 +222,13 @@ AcpiOsFree (
ACPI_STATUS ACPI_STATUS
AcpiOsMapMemory ( AcpiOsMapMemory (
ACPI_PHYSICAL_ADDRESS PhysicalAddress, ACPI_PHYSICAL_ADDRESS PhysicalAddress,
UINT32 Length, ACPI_SIZE Size,
void **LogicalAddress); void **LogicalAddress);
void void
AcpiOsUnmapMemory ( AcpiOsUnmapMemory (
void *LogicalAddress, void *LogicalAddress,
UINT32 Length); ACPI_SIZE Size);
ACPI_STATUS ACPI_STATUS
AcpiOsGetPhysicalAddress ( AcpiOsGetPhysicalAddress (
@ -364,12 +360,12 @@ AcpiOsSignal (
* Debug print routines * Debug print routines
*/ */
INT32 void
AcpiOsPrintf ( AcpiOsPrintf (
const NATIVE_CHAR *Format, const NATIVE_CHAR *Format,
...); ...);
INT32 void
AcpiOsVprintf ( AcpiOsVprintf (
const NATIVE_CHAR *Format, const NATIVE_CHAR *Format,
va_list Args); va_list Args);

7
sys/contrib/dev/acpica/acpixf.h
View File

@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -356,11 +356,12 @@ AcpiInstallGpeHandler (
ACPI_STATUS ACPI_STATUS
AcpiAcquireGlobalLock ( AcpiAcquireGlobalLock (
void); UINT32 Timeout,
UINT32 *Handle);
ACPI_STATUS ACPI_STATUS
AcpiReleaseGlobalLock ( AcpiReleaseGlobalLock (
void); UINT32 Handle);
ACPI_STATUS ACPI_STATUS
AcpiRemoveGpeHandler ( AcpiRemoveGpeHandler (

137
sys/contrib/dev/acpica/exfldio.c
View File

@ -1,7 +1,7 @@
/****************************************************************************** /******************************************************************************
* *
* Module Name: exfldio - Aml Field I/O * Module Name: exfldio - Aml Field I/O
* $Revision: 75 $ * $Revision: 82 $
* *
*****************************************************************************/ *****************************************************************************/
@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -127,7 +127,7 @@
#define _COMPONENT ACPI_EXECUTER #define _COMPONENT ACPI_EXECUTER
MODULE_NAME ("exfldio") ACPI_MODULE_NAME ("exfldio")
/******************************************************************************* /*******************************************************************************
@ -154,7 +154,7 @@ AcpiExSetupRegion (
ACPI_OPERAND_OBJECT *RgnDesc; ACPI_OPERAND_OBJECT *RgnDesc;
FUNCTION_TRACE_U32 ("ExSetupRegion", FieldDatumByteOffset); ACPI_FUNCTION_TRACE_U32 ("ExSetupRegion", FieldDatumByteOffset);
RgnDesc = ObjDesc->CommonField.RegionObj; RgnDesc = ObjDesc->CommonField.RegionObj;
@ -196,8 +196,9 @@ AcpiExSetupRegion (
* byte, and a field with Dword access specified. * byte, and a field with Dword access specified.
*/ */
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Field access width (%d bytes) too large for region size (%X)\n", "Field [%4.4s] access width (%d bytes) too large for region [%4.4s] (length %X)\n",
ObjDesc->CommonField.AccessByteWidth, RgnDesc->Region.Length)); (char *) &ObjDesc->CommonField.Node->Name, ObjDesc->CommonField.AccessByteWidth,
(char *) &RgnDesc->Region.Node->Name, RgnDesc->Region.Length));
} }
/* /*
@ -205,10 +206,10 @@ AcpiExSetupRegion (
* exceeds region length, indicate an error * exceeds region length, indicate an error
*/ */
ACPI_DEBUG_PRINT ((ACPI_DB_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 [%4.4s] Base+Offset+Width %X+%X+%X is beyond end of region [%4.4s] (length %X)\n",
ObjDesc->CommonField.BaseByteOffset, FieldDatumByteOffset, (char *) &ObjDesc->CommonField.Node->Name, ObjDesc->CommonField.BaseByteOffset,
ObjDesc->CommonField.AccessByteWidth, FieldDatumByteOffset, ObjDesc->CommonField.AccessByteWidth,
RgnDesc->Region.Length, ObjDesc, RgnDesc)); (char *) &RgnDesc->Region.Node->Name, RgnDesc->Region.Length));
return_ACPI_STATUS (AE_AML_REGION_LIMIT); return_ACPI_STATUS (AE_AML_REGION_LIMIT);
} }
@ -245,7 +246,7 @@ AcpiExAccessRegion (
ACPI_PHYSICAL_ADDRESS Address; ACPI_PHYSICAL_ADDRESS Address;
FUNCTION_TRACE ("AcpiExAccessRegion"); ACPI_FUNCTION_TRACE ("AcpiExAccessRegion");
/* /*
@ -270,18 +271,18 @@ AcpiExAccessRegion (
} }
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_BFIELD, ACPI_DEBUG_PRINT_RAW ((ACPI_DB_BFIELD,
" Region[%s-%X] Width %X Base:Off %X:%X at %8.8X%8.8X\n", " Region[%s-%X] Access %X Base:Off %X:%X at %8.8X%8.8X\n",
AcpiUtGetRegionName (RgnDesc->Region.SpaceId), AcpiUtGetRegionName (RgnDesc->Region.SpaceId),
RgnDesc->Region.SpaceId, RgnDesc->Region.SpaceId,
ObjDesc->CommonField.AccessBitWidth, ObjDesc->CommonField.AccessByteWidth,
ObjDesc->CommonField.BaseByteOffset, ObjDesc->CommonField.BaseByteOffset,
FieldDatumByteOffset, FieldDatumByteOffset,
HIDWORD (Address), LODWORD (Address))); ACPI_HIDWORD (Address), ACPI_LODWORD (Address)));
/* Invoke the appropriate AddressSpace/OpRegion handler */ /* Invoke the appropriate AddressSpace/OpRegion handler */
Status = AcpiEvAddressSpaceDispatch (RgnDesc, ReadWrite, Status = AcpiEvAddressSpaceDispatch (RgnDesc, ReadWrite,
Address, ObjDesc->CommonField.AccessBitWidth, Value); Address, ACPI_MUL_8 (ObjDesc->CommonField.AccessByteWidth), Value);
if (ACPI_FAILURE (Status)) if (ACPI_FAILURE (Status))
{ {
@ -329,15 +330,26 @@ AcpiExRegisterOverflow (
ACPI_INTEGER Value) ACPI_INTEGER Value)
{ {
/* if (ObjDesc->CommonField.BitLength >= ACPI_INTEGER_BIT_SIZE)
* Is the Value larger than the maximum value that can fit into {
* the field? /*
*/ * The field is large enough to hold the maximum integer, so we can
* never overflow it.
*/
return (FALSE);
}
if (Value >= (ACPI_INTEGER) (1 << ObjDesc->CommonField.BitLength)) if (Value >= (ACPI_INTEGER) (1 << ObjDesc->CommonField.BitLength))
{ {
/*
* The Value is larger than the maximum value that can fit into
* the register.
*/
return (TRUE); return (TRUE);
} }
/* The Value will fit into the field with no truncation */
return (FALSE); return (FALSE);
} }
@ -371,7 +383,7 @@ AcpiExFieldDatumIo (
ACPI_INTEGER LocalValue; ACPI_INTEGER LocalValue;
FUNCTION_TRACE_U32 ("ExFieldDatumIo", FieldDatumByteOffset); ACPI_FUNCTION_TRACE_U32 ("ExFieldDatumIo", FieldDatumByteOffset);
if (ReadWrite == ACPI_READ) if (ReadWrite == ACPI_READ)
@ -417,7 +429,7 @@ AcpiExFieldDatumIo (
* Copy the data from the source buffer. * Copy the data from the source buffer.
* Length is the field width in bytes. * Length is the field width in bytes.
*/ */
MEMCPY (Value, (ObjDesc->BufferField.BufferObj)->Buffer.Pointer ACPI_MEMCPY (Value, (ObjDesc->BufferField.BufferObj)->Buffer.Pointer
+ ObjDesc->BufferField.BaseByteOffset + ObjDesc->BufferField.BaseByteOffset
+ FieldDatumByteOffset, + FieldDatumByteOffset,
ObjDesc->CommonField.AccessByteWidth); ObjDesc->CommonField.AccessByteWidth);
@ -428,7 +440,7 @@ AcpiExFieldDatumIo (
* Copy the data to the target buffer. * Copy the data to the target buffer.
* Length is the field width in bytes. * Length is the field width in bytes.
*/ */
MEMCPY ((ObjDesc->BufferField.BufferObj)->Buffer.Pointer ACPI_MEMCPY ((ObjDesc->BufferField.BufferObj)->Buffer.Pointer
+ ObjDesc->BufferField.BaseByteOffset + ObjDesc->BufferField.BaseByteOffset
+ FieldDatumByteOffset, + FieldDatumByteOffset,
Value, ObjDesc->CommonField.AccessByteWidth); Value, ObjDesc->CommonField.AccessByteWidth);
@ -535,12 +547,12 @@ AcpiExFieldDatumIo (
if (ReadWrite == ACPI_READ) if (ReadWrite == ACPI_READ)
{ {
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value Read=%8.8X%8.8X\n", ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value Read=%8.8X%8.8X\n",
HIDWORD(*Value), LODWORD(*Value))); ACPI_HIDWORD (*Value), ACPI_LODWORD (*Value)));
} }
else else
{ {
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value Written=%8.8X%8.8X\n", ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value Written=%8.8X%8.8X\n",
HIDWORD(*Value), LODWORD(*Value))); ACPI_HIDWORD (*Value), ACPI_LODWORD (*Value)));
} }
} }
@ -573,7 +585,7 @@ AcpiExWriteWithUpdateRule (
ACPI_INTEGER CurrentValue; ACPI_INTEGER CurrentValue;
FUNCTION_TRACE_U32 ("ExWriteWithUpdateRule", Mask); ACPI_FUNCTION_TRACE_U32 ("ExWriteWithUpdateRule", Mask);
/* Start with the new bits */ /* Start with the new bits */
@ -593,8 +605,8 @@ AcpiExWriteWithUpdateRule (
* Check if update rule needs to be applied (not if mask is all * Check if update rule needs to be applied (not if mask is all
* ones) The left shift drops the bits we want to ignore. * ones) The left shift drops the bits we want to ignore.
*/ */
if ((~Mask << (sizeof (Mask) * 8 - if ((~Mask << (ACPI_MUL_8 (sizeof (Mask)) -
ObjDesc->CommonField.AccessBitWidth)) != 0) ACPI_MUL_8 (ObjDesc->CommonField.AccessByteWidth))) != 0)
{ {
/* /*
* Read the current contents of the byte/word/dword containing * Read the current contents of the byte/word/dword containing
@ -625,7 +637,6 @@ AcpiExWriteWithUpdateRule (
"WriteWithUpdateRule: Unknown UpdateRule setting: %x\n", "WriteWithUpdateRule: Unknown UpdateRule setting: %x\n",
(ObjDesc->CommonField.FieldFlags & AML_FIELD_UPDATE_RULE_MASK))); (ObjDesc->CommonField.FieldFlags & AML_FIELD_UPDATE_RULE_MASK)));
return_ACPI_STATUS (AE_AML_OPERAND_VALUE); return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
break;
} }
} }
@ -636,10 +647,10 @@ AcpiExWriteWithUpdateRule (
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
"Mask %8.8X%8.8X DatumOffset %X Value %8.8X%8.8X, MergedValue %8.8X%8.8X\n", "Mask %8.8X%8.8X DatumOffset %X Value %8.8X%8.8X, MergedValue %8.8X%8.8X\n",
HIDWORD(Mask), LODWORD(Mask), ACPI_HIDWORD (Mask), ACPI_LODWORD (Mask),
FieldDatumByteOffset, FieldDatumByteOffset,
HIDWORD(FieldValue), LODWORD(FieldValue), ACPI_HIDWORD (FieldValue), ACPI_LODWORD (FieldValue),
HIDWORD(MergedValue),LODWORD(MergedValue))); ACPI_HIDWORD (MergedValue),ACPI_LODWORD (MergedValue)));
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
@ -670,25 +681,29 @@ AcpiExGetBufferDatum(
UINT32 Offset) UINT32 Offset)
{ {
FUNCTION_ENTRY (); ACPI_FUNCTION_ENTRY ();
switch (ByteGranularity) switch (ByteGranularity)
{ {
case ACPI_FIELD_BYTE_GRANULARITY: case ACPI_FIELD_BYTE_GRANULARITY:
*Datum = ((UINT8 *) Buffer) [Offset]; *Datum = ((UINT8 *) Buffer) [Offset];
break; break;
case ACPI_FIELD_WORD_GRANULARITY: case ACPI_FIELD_WORD_GRANULARITY:
MOVE_UNALIGNED16_TO_32 (Datum, &(((UINT16 *) Buffer) [Offset]));
ACPI_MOVE_UNALIGNED16_TO_32 (Datum, &(((UINT16 *) Buffer) [Offset]));
break; break;
case ACPI_FIELD_DWORD_GRANULARITY: case ACPI_FIELD_DWORD_GRANULARITY:
MOVE_UNALIGNED32_TO_32 (Datum, &(((UINT32 *) Buffer) [Offset]));
ACPI_MOVE_UNALIGNED32_TO_32 (Datum, &(((UINT32 *) Buffer) [Offset]));
break; break;
case ACPI_FIELD_QWORD_GRANULARITY: case ACPI_FIELD_QWORD_GRANULARITY:
MOVE_UNALIGNED64_TO_64 (Datum, &(((UINT64 *) Buffer) [Offset]));
ACPI_MOVE_UNALIGNED64_TO_64 (Datum, &(((UINT64 *) Buffer) [Offset]));
break; break;
} }
} }
@ -719,25 +734,29 @@ AcpiExSetBufferDatum (
UINT32 Offset) UINT32 Offset)
{ {
FUNCTION_ENTRY (); ACPI_FUNCTION_ENTRY ();
switch (ByteGranularity) switch (ByteGranularity)
{ {
case ACPI_FIELD_BYTE_GRANULARITY: case ACPI_FIELD_BYTE_GRANULARITY:
((UINT8 *) Buffer) [Offset] = (UINT8) MergedDatum; ((UINT8 *) Buffer) [Offset] = (UINT8) MergedDatum;
break; break;
case ACPI_FIELD_WORD_GRANULARITY: case ACPI_FIELD_WORD_GRANULARITY:
MOVE_UNALIGNED16_TO_16 (&(((UINT16 *) Buffer)[Offset]), &MergedDatum);
ACPI_MOVE_UNALIGNED16_TO_16 (&(((UINT16 *) Buffer)[Offset]), &MergedDatum);
break; break;
case ACPI_FIELD_DWORD_GRANULARITY: case ACPI_FIELD_DWORD_GRANULARITY:
MOVE_UNALIGNED32_TO_32 (&(((UINT32 *) Buffer)[Offset]), &MergedDatum);
ACPI_MOVE_UNALIGNED32_TO_32 (&(((UINT32 *) Buffer)[Offset]), &MergedDatum);
break; break;
case ACPI_FIELD_QWORD_GRANULARITY: case ACPI_FIELD_QWORD_GRANULARITY:
MOVE_UNALIGNED64_TO_64 (&(((UINT64 *) Buffer)[Offset]), &MergedDatum);
ACPI_MOVE_UNALIGNED64_TO_64 (&(((UINT64 *) Buffer)[Offset]), &MergedDatum);
break; break;
} }
} }
@ -772,16 +791,16 @@ AcpiExExtractFromField (
UINT32 DatumCount; UINT32 DatumCount;
FUNCTION_TRACE ("ExExtractFromField"); ACPI_FUNCTION_TRACE ("ExExtractFromField");
/* /*
* The field must fit within the caller's buffer * The field must fit within the caller's buffer
*/ */
ByteFieldLength = ROUND_BITS_UP_TO_BYTES (ObjDesc->CommonField.BitLength); ByteFieldLength = ACPI_ROUND_BITS_UP_TO_BYTES (ObjDesc->CommonField.BitLength);
if (ByteFieldLength > BufferLength) if (ByteFieldLength > BufferLength)
{ {
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Field size %X (bytes) too large for buffer (%X)\n", "Field size %X (bytes) too large for buffer (%X)\n",
ByteFieldLength, BufferLength)); ByteFieldLength, BufferLength));
@ -790,20 +809,19 @@ AcpiExExtractFromField (
/* Convert field byte count to datum count, round up if necessary */ /* Convert field byte count to datum count, round up if necessary */
DatumCount = ROUND_UP_TO (ByteFieldLength, DatumCount = ACPI_ROUND_UP_TO (ByteFieldLength,
ObjDesc->CommonField.AccessByteWidth); ObjDesc->CommonField.AccessByteWidth);
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"ByteLen=%x, DatumLen=%x, BitGran=%x, ByteGran=%x\n", "ByteLen=%x, DatumLen=%x, ByteGran=%x\n",
ByteFieldLength, DatumCount, ObjDesc->CommonField.AccessBitWidth, ByteFieldLength, DatumCount,ObjDesc->CommonField.AccessByteWidth));
ObjDesc->CommonField.AccessByteWidth));
/* /*
* Clear the caller's buffer (the whole buffer length as given) * Clear the caller's buffer (the whole buffer length as given)
* This is very important, especially in the cases where a byte is read, * This is very important, especially in the cases where a byte is read,
* but the buffer is really a UINT32 (4 bytes). * but the buffer is really a UINT32 (4 bytes).
*/ */
MEMSET (Buffer, 0, BufferLength); ACPI_MEMSET (Buffer, 0, BufferLength);
/* Read the first raw datum to prime the loop */ /* Read the first raw datum to prime the loop */
@ -831,7 +849,7 @@ AcpiExExtractFromField (
if (ObjDesc->CommonField.EndBufferValidBits) if (ObjDesc->CommonField.EndBufferValidBits)
{ {
MergedDatum &= MASK_BITS_ABOVE (ObjDesc->CommonField.EndBufferValidBits); MergedDatum &= ACPI_MASK_BITS_ABOVE (ObjDesc->CommonField.EndBufferValidBits);
} }
/* Store the datum to the caller buffer */ /* Store the datum to the caller buffer */
@ -854,7 +872,7 @@ AcpiExExtractFromField (
* to perform a final read, since this would potentially read * to perform a final read, since this would potentially read
* past the end of the region. * past the end of the region.
* *
* We could just split the aligned and non-aligned cases since the * We could just split the aligned and non-aligned cases since the
* aligned case is so very simple, but this would require more code. * aligned case is so very simple, but this would require more code.
*/ */
if ((ObjDesc->CommonField.StartFieldBitOffset != 0) || if ((ObjDesc->CommonField.StartFieldBitOffset != 0) ||
@ -907,7 +925,7 @@ AcpiExExtractFromField (
if (ObjDesc->CommonField.EndBufferValidBits) if (ObjDesc->CommonField.EndBufferValidBits)
{ {
MergedDatum &= MergedDatum &=
MASK_BITS_ABOVE (ObjDesc->CommonField.EndBufferValidBits); ACPI_MASK_BITS_ABOVE (ObjDesc->CommonField.EndBufferValidBits);
} }
} }
} }
@ -916,7 +934,7 @@ AcpiExExtractFromField (
* Store the merged field datum in the caller's buffer, according to * Store the merged field datum in the caller's buffer, according to
* the granularity of the field (size of each datum). * the granularity of the field (size of each datum).
*/ */
AcpiExSetBufferDatum (MergedDatum, Buffer, AcpiExSetBufferDatum (MergedDatum, Buffer,
ObjDesc->CommonField.AccessByteWidth, DatumOffset); ObjDesc->CommonField.AccessByteWidth, DatumOffset);
/* /*
@ -961,7 +979,7 @@ AcpiExInsertIntoField (
UINT32 DatumCount; UINT32 DatumCount;
FUNCTION_TRACE ("ExInsertIntoField"); ACPI_FUNCTION_TRACE ("ExInsertIntoField");
/* /*
@ -970,7 +988,7 @@ AcpiExInsertIntoField (
* larger than the field, this typically happens when an integer is * larger than the field, this typically happens when an integer is
* written to a field that is actually smaller than an integer. * written to a field that is actually smaller than an integer.
*/ */
ByteFieldLength = ROUND_BITS_UP_TO_BYTES (ObjDesc->CommonField.BitLength); ByteFieldLength = ACPI_ROUND_BITS_UP_TO_BYTES (ObjDesc->CommonField.BitLength);
if (BufferLength < ByteFieldLength) if (BufferLength < ByteFieldLength)
{ {
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Buffer length %X too small for field %X\n", ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Buffer length %X too small for field %X\n",
@ -981,12 +999,11 @@ AcpiExInsertIntoField (
/* Convert byte count to datum count, round up if necessary */ /* Convert byte count to datum count, round up if necessary */
DatumCount = ROUND_UP_TO (ByteFieldLength, ObjDesc->CommonField.AccessByteWidth); DatumCount = ACPI_ROUND_UP_TO (ByteFieldLength, ObjDesc->CommonField.AccessByteWidth);
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"ByteLen=%x, DatumLen=%x, BitGran=%x, ByteGran=%x\n", "ByteLen=%x, DatumLen=%x, ByteGran=%x\n",
ByteFieldLength, DatumCount, ObjDesc->CommonField.AccessBitWidth, ByteFieldLength, DatumCount, ObjDesc->CommonField.AccessByteWidth));
ObjDesc->CommonField.AccessByteWidth));
/* /*
* Break the request into up to three parts (similar to an I/O request): * Break the request into up to three parts (similar to an I/O request):
@ -1012,7 +1029,7 @@ AcpiExInsertIntoField (
* *
* Mask off bits that are "below" the field (if any) * Mask off bits that are "below" the field (if any)
*/ */
Mask = MASK_BITS_BELOW (ObjDesc->CommonField.StartFieldBitOffset); Mask = ACPI_MASK_BITS_BELOW (ObjDesc->CommonField.StartFieldBitOffset);
/* If the field fits in one datum, may need to mask upper bits */ /* If the field fits in one datum, may need to mask upper bits */
@ -1021,7 +1038,7 @@ AcpiExInsertIntoField (
{ {
/* There are bits above the field, mask them off also */ /* There are bits above the field, mask them off also */
Mask &= MASK_BITS_ABOVE (ObjDesc->CommonField.EndFieldValidBits); Mask &= ACPI_MASK_BITS_ABOVE (ObjDesc->CommonField.EndFieldValidBits);
} }
/* Shift and mask the value into the field position */ /* Shift and mask the value into the field position */
@ -1108,7 +1125,7 @@ AcpiExInsertIntoField (
* *
* Mask off the unused bits above (after) the end-of-field * Mask off the unused bits above (after) the end-of-field
*/ */
Mask = MASK_BITS_ABOVE (ObjDesc->CommonField.EndFieldValidBits); Mask = ACPI_MASK_BITS_ABOVE (ObjDesc->CommonField.EndFieldValidBits);
MergedDatum &= Mask; MergedDatum &= Mask;
/* Write the last datum with the update rule */ /* Write the last datum with the update rule */

46
sys/contrib/dev/acpica/exsystem.c
View File

@ -2,7 +2,7 @@
/****************************************************************************** /******************************************************************************
* *
* Module Name: exsystem - Interface to OS services * Module Name: exsystem - Interface to OS services
* $Revision: 67 $ * $Revision: 71 $
* *
*****************************************************************************/ *****************************************************************************/
@ -10,7 +10,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -124,7 +124,7 @@
#include "acevents.h" #include "acevents.h"
#define _COMPONENT ACPI_EXECUTER #define _COMPONENT ACPI_EXECUTER
MODULE_NAME ("exsystem") ACPI_MODULE_NAME ("exsystem")
/******************************************************************************* /*******************************************************************************
@ -147,10 +147,11 @@ AcpiExSystemWaitSemaphore (
ACPI_HANDLE Semaphore, ACPI_HANDLE Semaphore,
UINT32 Timeout) UINT32 Timeout)
{ {
ACPI_STATUS Status, Status2; ACPI_STATUS Status;
ACPI_STATUS Status2;
FUNCTION_TRACE ("ExSystemWaitSemaphore"); ACPI_FUNCTION_TRACE ("ExSystemWaitSemaphore");
Status = AcpiOsWaitSemaphore (Semaphore, 1, 0); Status = AcpiOsWaitSemaphore (Semaphore, 1, 0);
@ -191,17 +192,20 @@ AcpiExSystemWaitSemaphore (
* *
* PARAMETERS: HowLong - The amount of time to stall * PARAMETERS: HowLong - The amount of time to stall
* *
* RETURN: None * RETURN: Status
* *
* DESCRIPTION: Suspend running thread for specified amount of time. * DESCRIPTION: Suspend running thread for specified amount of time.
* *
******************************************************************************/ ******************************************************************************/
void ACPI_STATUS
AcpiExSystemDoStall ( AcpiExSystemDoStall (
UINT32 HowLong) UINT32 HowLong)
{ {
FUNCTION_ENTRY (); ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_ENTRY ();
if (HowLong > 1000) /* 1 millisecond */ if (HowLong > 1000) /* 1 millisecond */
@ -214,13 +218,15 @@ AcpiExSystemDoStall (
/* And now we must get the interpreter again */ /* And now we must get the interpreter again */
AcpiExEnterInterpreter (); Status = AcpiExEnterInterpreter ();
} }
else else
{ {
AcpiOsSleep (0, (HowLong / 1000) + 1); AcpiOsSleep (0, (HowLong / 1000) + 1);
} }
return (Status);
} }
@ -236,12 +242,14 @@ AcpiExSystemDoStall (
* *
******************************************************************************/ ******************************************************************************/
void ACPI_STATUS
AcpiExSystemDoSuspend ( AcpiExSystemDoSuspend (
UINT32 HowLong) UINT32 HowLong)
{ {
ACPI_STATUS Status;
FUNCTION_ENTRY ();
ACPI_FUNCTION_ENTRY ();
/* Since this thread will sleep, we must release the interpreter */ /* Since this thread will sleep, we must release the interpreter */
@ -253,7 +261,8 @@ AcpiExSystemDoSuspend (
/* And now we must get the interpreter again */ /* And now we must get the interpreter again */
AcpiExEnterInterpreter (); Status = AcpiExEnterInterpreter ();
return (Status);
} }
@ -280,7 +289,7 @@ AcpiExSystemAcquireMutex (
ACPI_STATUS Status = AE_OK; ACPI_STATUS Status = AE_OK;
FUNCTION_TRACE_PTR ("ExSystemAcquireMutex", ObjDesc); ACPI_FUNCTION_TRACE_PTR ("ExSystemAcquireMutex", ObjDesc);
if (!ObjDesc) if (!ObjDesc)
@ -293,7 +302,7 @@ AcpiExSystemAcquireMutex (
*/ */
if (ObjDesc->Mutex.Semaphore == AcpiGbl_GlobalLockSemaphore) if (ObjDesc->Mutex.Semaphore == AcpiGbl_GlobalLockSemaphore)
{ {
Status = AcpiEvAcquireGlobalLock (); Status = AcpiEvAcquireGlobalLock ((UINT32) TimeDesc->Integer.Value);
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
@ -325,7 +334,7 @@ AcpiExSystemReleaseMutex (
ACPI_STATUS Status = AE_OK; ACPI_STATUS Status = AE_OK;
FUNCTION_TRACE ("ExSystemReleaseMutex"); ACPI_FUNCTION_TRACE ("ExSystemReleaseMutex");
if (!ObjDesc) if (!ObjDesc)
@ -367,7 +376,7 @@ AcpiExSystemSignalEvent (
ACPI_STATUS Status = AE_OK; ACPI_STATUS Status = AE_OK;
FUNCTION_TRACE ("ExSystemSignalEvent"); ACPI_FUNCTION_TRACE ("ExSystemSignalEvent");
if (ObjDesc) if (ObjDesc)
@ -402,7 +411,7 @@ AcpiExSystemWaitEvent (
ACPI_STATUS Status = AE_OK; ACPI_STATUS Status = AE_OK;
FUNCTION_TRACE ("ExSystemWaitEvent"); ACPI_FUNCTION_TRACE ("ExSystemWaitEvent");
if (ObjDesc) if (ObjDesc)
@ -411,7 +420,6 @@ AcpiExSystemWaitEvent (
(UINT32) TimeDesc->Integer.Value); (UINT32) TimeDesc->Integer.Value);
} }
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
@ -436,7 +444,7 @@ AcpiExSystemResetEvent (
void *TempSemaphore; void *TempSemaphore;
FUNCTION_ENTRY (); ACPI_FUNCTION_ENTRY ();
/* /*

186
sys/contrib/dev/acpica/hwsleep.c
View File

@ -2,7 +2,7 @@
/****************************************************************************** /******************************************************************************
* *
* Name: hwsleep.c - ACPI Hardware Sleep/Wake Interface * Name: hwsleep.c - ACPI Hardware Sleep/Wake Interface
* $Revision: 25 $ * $Revision: 35 $
* *
*****************************************************************************/ *****************************************************************************/
@ -10,7 +10,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -120,10 +120,7 @@
#include "achware.h" #include "achware.h"
#define _COMPONENT ACPI_HARDWARE #define _COMPONENT ACPI_HARDWARE
MODULE_NAME ("hwsleep") ACPI_MODULE_NAME ("hwsleep")
static UINT8 SleepTypeA;
static UINT8 SleepTypeB;
/****************************************************************************** /******************************************************************************
@ -133,7 +130,7 @@ static UINT8 SleepTypeB;
* PARAMETERS: PhysicalAddress - Physical address of ACPI real mode * PARAMETERS: PhysicalAddress - Physical address of ACPI real mode
* entry point. * entry point.
* *
* RETURN: AE_OK or AE_ERROR * RETURN: Status
* *
* DESCRIPTION: Access function for dFirmwareWakingVector field in FACS * DESCRIPTION: Access function for dFirmwareWakingVector field in FACS
* *
@ -144,25 +141,18 @@ AcpiSetFirmwareWakingVector (
ACPI_PHYSICAL_ADDRESS PhysicalAddress) ACPI_PHYSICAL_ADDRESS PhysicalAddress)
{ {
FUNCTION_TRACE ("AcpiSetFirmwareWakingVector"); ACPI_FUNCTION_TRACE ("AcpiSetFirmwareWakingVector");
/* Make sure that we have an FACS */
if (!AcpiGbl_FACS)
{
return_ACPI_STATUS (AE_NO_ACPI_TABLES);
}
/* Set the vector */ /* Set the vector */
if (AcpiGbl_FACS->VectorWidth == 32) if (AcpiGbl_CommonFACS.VectorWidth == 32)
{ {
* (UINT32 *) AcpiGbl_FACS->FirmwareWakingVector = (UINT32) PhysicalAddress; *(UINT32 *) AcpiGbl_CommonFACS.FirmwareWakingVector = (UINT32) PhysicalAddress;
} }
else else
{ {
*AcpiGbl_FACS->FirmwareWakingVector = PhysicalAddress; *AcpiGbl_CommonFACS.FirmwareWakingVector = PhysicalAddress;
} }
return_ACPI_STATUS (AE_OK); return_ACPI_STATUS (AE_OK);
@ -179,7 +169,7 @@ AcpiSetFirmwareWakingVector (
* *
* RETURN: Status * RETURN: Status
* *
* DESCRIPTION: Access function for dFirmwareWakingVector field in FACS * DESCRIPTION: Access function for FirmwareWakingVector field in FACS
* *
******************************************************************************/ ******************************************************************************/
@ -188,7 +178,7 @@ AcpiGetFirmwareWakingVector (
ACPI_PHYSICAL_ADDRESS *PhysicalAddress) ACPI_PHYSICAL_ADDRESS *PhysicalAddress)
{ {
FUNCTION_TRACE ("AcpiGetFirmwareWakingVector"); ACPI_FUNCTION_TRACE ("AcpiGetFirmwareWakingVector");
if (!PhysicalAddress) if (!PhysicalAddress)
@ -196,22 +186,15 @@ AcpiGetFirmwareWakingVector (
return_ACPI_STATUS (AE_BAD_PARAMETER); return_ACPI_STATUS (AE_BAD_PARAMETER);
} }
/* Make sure that we have an FACS */
if (!AcpiGbl_FACS)
{
return_ACPI_STATUS (AE_NO_ACPI_TABLES);
}
/* Get the vector */ /* Get the vector */
if (AcpiGbl_FACS->VectorWidth == 32) if (AcpiGbl_CommonFACS.VectorWidth == 32)
{ {
*PhysicalAddress = * (UINT32 *) AcpiGbl_FACS->FirmwareWakingVector; *PhysicalAddress = *(UINT32 *) AcpiGbl_CommonFACS.FirmwareWakingVector;
} }
else else
{ {
*PhysicalAddress = *AcpiGbl_FACS->FirmwareWakingVector; *PhysicalAddress = *AcpiGbl_CommonFACS.FirmwareWakingVector;
} }
return_ACPI_STATUS (AE_OK); return_ACPI_STATUS (AE_OK);
@ -242,35 +225,45 @@ AcpiEnterSleepStatePrep (
ACPI_OBJECT Arg; ACPI_OBJECT Arg;
FUNCTION_TRACE ("AcpiEnterSleepStatePrep"); ACPI_FUNCTION_TRACE ("AcpiEnterSleepStatePrep");
/* /*
* _PSW methods could be run here to enable wake-on keyboard, LAN, etc. * _PSW methods could be run here to enable wake-on keyboard, LAN, etc.
*/ */
Status = AcpiHwObtainSleepTypeRegisterData (SleepState, &SleepTypeA, &SleepTypeB); Status = AcpiHwGetSleepTypeData (SleepState,
if (!ACPI_SUCCESS (Status)) &AcpiGbl_SleepTypeA, &AcpiGbl_SleepTypeB);
if (ACPI_FAILURE (Status))
{ {
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* run the _PTS and _GTS methods */ /* Setup parameter object */
MEMSET(&ArgList, 0, sizeof(ArgList));
ArgList.Count = 1; ArgList.Count = 1;
ArgList.Pointer = &Arg; ArgList.Pointer = &Arg;
MEMSET(&Arg, 0, sizeof(Arg));
Arg.Type = ACPI_TYPE_INTEGER; Arg.Type = ACPI_TYPE_INTEGER;
Arg.Integer.Value = SleepState; Arg.Integer.Value = SleepState;
AcpiEvaluateObject (NULL, "\\_PTS", &ArgList, NULL); /* Run the _PTS and _GTS methods */
AcpiEvaluateObject (NULL, "\\_GTS", &ArgList, NULL);
Status = AcpiEvaluateObject (NULL, "\\_PTS", &ArgList, NULL);
if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND)
{
return_ACPI_STATUS (Status);
}
Status = AcpiEvaluateObject (NULL, "\\_GTS", &ArgList, NULL);
if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND)
{
return_ACPI_STATUS (Status);
}
return_ACPI_STATUS (AE_OK); return_ACPI_STATUS (AE_OK);
} }
/****************************************************************************** /******************************************************************************
* *
* FUNCTION: AcpiEnterSleepState * FUNCTION: AcpiEnterSleepState
@ -286,86 +279,93 @@ AcpiEnterSleepStatePrep (
ACPI_STATUS ACPI_STATUS
AcpiEnterSleepState ( AcpiEnterSleepState (
UINT8 SleepState) UINT8 SleepState)
{ {
UINT16 PM1AControl; UINT16 PM1AControl;
UINT16 PM1BControl; UINT16 PM1BControl;
UINT32 Retry; ACPI_BIT_REGISTER_INFO *SleepTypeRegInfo;
ACPI_BIT_REGISTER_INFO *SleepEnableRegInfo;
UINT32 Retry;
FUNCTION_TRACE ("AcpiEnterSleepState"); ACPI_FUNCTION_TRACE ("AcpiEnterSleepState");
if ((SleepTypeA > ACPI_SLEEP_TYPE_MAX) ||
(SleepTypeB > ACPI_SLEEP_TYPE_MAX)) if ((AcpiGbl_SleepTypeA > ACPI_SLEEP_TYPE_MAX) ||
(AcpiGbl_SleepTypeB > ACPI_SLEEP_TYPE_MAX))
{ {
REPORT_ERROR (("Sleep values out of range: A=%x B=%x\n", ACPI_REPORT_ERROR (("Sleep values out of range: A=%x B=%x\n",
SleepTypeA, SleepTypeB)); AcpiGbl_SleepTypeA, AcpiGbl_SleepTypeB));
return_ACPI_STATUS (AE_ERROR); return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
} }
/* clear wake status */
AcpiHwRegisterBitAccess (ACPI_WRITE, ACPI_MTX_LOCK, WAK_STS, 1); SleepTypeRegInfo = AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_TYPE_A);
SleepEnableRegInfo = AcpiHwGetBitRegisterInfo (ACPI_BITREG_SLEEP_ENABLE);
/* Clear wake status */
AcpiHwBitRegisterWrite (ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_LOCK);
AcpiHwClearAcpiStatus(); AcpiHwClearAcpiStatus();
/* disable arbitration here? */ /* TBD: Disable arbitration here? */
AcpiHwDisableNonWakeupGpes(); AcpiHwDisableNonWakeupGpes();
PM1AControl = (UINT16) AcpiHwRegisterRead (ACPI_MTX_LOCK, PM1_CONTROL); /* Get current value of PM1A control */
PM1AControl = (UINT16) AcpiHwRegisterRead (ACPI_MTX_LOCK, ACPI_REGISTER_PM1_CONTROL);
ACPI_DEBUG_PRINT ((ACPI_DB_OK, "Entering S%d\n", SleepState)); ACPI_DEBUG_PRINT ((ACPI_DB_OK, "Entering S%d\n", SleepState));
/* mask off SLP_EN and SLP_TYP fields */ /* Clear SLP_EN and SLP_TYP fields */
PM1AControl &= ~(SLP_TYPE_X_MASK | SLP_EN_MASK); PM1AControl &= ~(SleepTypeRegInfo->AccessBitMask | SleepEnableRegInfo->AccessBitMask);
PM1BControl = PM1AControl; PM1BControl = PM1AControl;
/* mask in SLP_TYP */ /* Insert SLP_TYP bits */
PM1AControl |= (SleepTypeA << AcpiHwGetBitShift (SLP_TYPE_X_MASK)); PM1AControl |= (AcpiGbl_SleepTypeA << SleepTypeRegInfo->BitPosition);
PM1BControl |= (SleepTypeB << AcpiHwGetBitShift (SLP_TYPE_X_MASK)); PM1BControl |= (AcpiGbl_SleepTypeB << SleepTypeRegInfo->BitPosition);
/* write #1: fill in SLP_TYP data */ /* Write #1: fill in SLP_TYP data */
AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1A_CONTROL, PM1AControl); AcpiHwRegisterWrite (ACPI_MTX_LOCK, ACPI_REGISTER_PM1A_CONTROL, PM1AControl);
AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1B_CONTROL, PM1BControl); AcpiHwRegisterWrite (ACPI_MTX_LOCK, ACPI_REGISTER_PM1B_CONTROL, PM1BControl);
/* mask in SLP_EN */ /* Insert SLP_ENABLE bit */
PM1AControl |= (1 << AcpiHwGetBitShift (SLP_EN_MASK)); PM1AControl |= SleepEnableRegInfo->AccessBitMask;
PM1BControl |= (1 << AcpiHwGetBitShift (SLP_EN_MASK)); PM1BControl |= SleepEnableRegInfo->AccessBitMask;
/* write #2: SLP_TYP + SLP_EN */ /* Write #2: SLP_TYP + SLP_EN */
AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1A_CONTROL, PM1AControl); AcpiHwRegisterWrite (ACPI_MTX_LOCK, ACPI_REGISTER_PM1A_CONTROL, PM1AControl);
AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1B_CONTROL, PM1BControl); AcpiHwRegisterWrite (ACPI_MTX_LOCK, ACPI_REGISTER_PM1B_CONTROL, PM1BControl);
/* /*
* Wait a second, then try again. This is to get S4/5 to work on all machines. * Wait a second, then try again. This is to get S4/5 to work on all machines.
*/ */
if (SleepState > ACPI_STATE_S3) if (SleepState > ACPI_STATE_S3)
{ {
AcpiOsStall(1000000); AcpiOsStall (1000000);
AcpiHwRegisterWrite (ACPI_MTX_LOCK, PM1_CONTROL, AcpiHwRegisterWrite (ACPI_MTX_LOCK, ACPI_REGISTER_PM1_CONTROL,
(1 << AcpiHwGetBitShift (SLP_EN_MASK))); SleepEnableRegInfo->AccessBitMask);
} }
/* wait until we enter sleep state */ /* Wait until we enter sleep state */
/* spin until we wake */ /* Spin until we wake */
Retry = 1000; Retry = 1000;
while (!AcpiHwRegisterBitAccess (ACPI_READ, ACPI_MTX_LOCK, WAK_STS)) while (!AcpiHwBitRegisterRead (ACPI_BITREG_WAKE_STATUS, ACPI_MTX_LOCK))
{ {
/* /*
* Some BIOSes don't set WAK_STS at all, * Some BIOSes don't set WAK_STS at all,
* give up waiting for wakeup if we time out. * give up waiting for wakeup if we time out.
*/ */
if (Retry-- == 0) { if (Retry-- == 0) {
break; /* giving up */ break; /* giving up */
} }
} }
return_ACPI_STATUS (AE_OK); return_ACPI_STATUS (AE_OK);
@ -389,23 +389,37 @@ AcpiLeaveSleepState (
{ {
ACPI_OBJECT_LIST ArgList; ACPI_OBJECT_LIST ArgList;
ACPI_OBJECT Arg; ACPI_OBJECT Arg;
ACPI_STATUS Status;
FUNCTION_TRACE ("AcpiLeaveSleepState"); ACPI_FUNCTION_TRACE ("AcpiLeaveSleepState");
/* Ensure EnterSleepStatePrep -> EnterSleepState ordering */ /* Ensure EnterSleepStatePrep -> EnterSleepState ordering */
SleepTypeA = ACPI_SLEEP_TYPE_INVALID;
MEMSET (&ArgList, 0, sizeof(ArgList)); AcpiGbl_SleepTypeA = ACPI_SLEEP_TYPE_INVALID;
/* Setup parameter object */
ArgList.Count = 1; ArgList.Count = 1;
ArgList.Pointer = &Arg; ArgList.Pointer = &Arg;
MEMSET (&Arg, 0, sizeof(Arg));
Arg.Type = ACPI_TYPE_INTEGER; Arg.Type = ACPI_TYPE_INTEGER;
Arg.Integer.Value = SleepState; Arg.Integer.Value = SleepState;
AcpiEvaluateObject (NULL, "\\_BFS", &ArgList, NULL); /* Ignore any errors from these methods */
AcpiEvaluateObject (NULL, "\\_WAK", &ArgList, NULL);
Status = AcpiEvaluateObject (NULL, "\\_BFS", &ArgList, NULL);
if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND)
{
ACPI_REPORT_ERROR (("Method _BFS failed, %s\n", AcpiFormatException (Status)));
}
Status = AcpiEvaluateObject (NULL, "\\_WAK", &ArgList, NULL);
if (ACPI_FAILURE (Status) && Status != AE_NOT_FOUND)
{
ACPI_REPORT_ERROR (("Method _WAK failed, %s\n", AcpiFormatException (Status)));
}
/* _WAK returns stuff - do we want to look at it? */ /* _WAK returns stuff - do we want to look at it? */

382
sys/contrib/dev/acpica/psparse.c
View File

@ -1,7 +1,7 @@
/****************************************************************************** /******************************************************************************
* *
* Module Name: psparse - Parser top level AML parse routines * Module Name: psparse - Parser top level AML parse routines
* $Revision: 109 $ * $Revision: 119 $
* *
*****************************************************************************/ *****************************************************************************/
@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -133,7 +133,7 @@
#include "acinterp.h" #include "acinterp.h"
#define _COMPONENT ACPI_PARSER #define _COMPONENT ACPI_PARSER
MODULE_NAME ("psparse") ACPI_MODULE_NAME ("psparse")
UINT32 AcpiGbl_Depth = 0; UINT32 AcpiGbl_Depth = 0;
@ -191,7 +191,7 @@ AcpiPsPeekOpcode (
Aml = ParserState->Aml; Aml = ParserState->Aml;
Opcode = (UINT16) GET8 (Aml); Opcode = (UINT16) ACPI_GET8 (Aml);
if (Opcode == AML_EXTOP) if (Opcode == AML_EXTOP)
@ -199,7 +199,7 @@ AcpiPsPeekOpcode (
/* Extended opcode */ /* Extended opcode */
Aml++; Aml++;
Opcode = (UINT16) ((Opcode << 8) | GET8 (Aml)); Opcode = (UINT16) ((Opcode << 8) | ACPI_GET8 (Aml));
} }
return (Opcode); return (Opcode);
@ -285,9 +285,16 @@ AcpiPsCompleteThisOp (
ACPI_PARSE_OBJECT *ReplacementOp = NULL; ACPI_PARSE_OBJECT *ReplacementOp = NULL;
FUNCTION_TRACE_PTR ("PsCompleteThisOp", Op); ACPI_FUNCTION_TRACE_PTR ("PsCompleteThisOp", Op);
/* Check for null Op, can happen if AML code is corrupt */
if (!Op)
{
return_VALUE (TRUE);
}
/* Delete this op and the subtree below it if asked to */ /* Delete this op and the subtree below it if asked to */
if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) == ACPI_PARSE_DELETE_TREE) && if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) == ACPI_PARSE_DELETE_TREE) &&
@ -429,11 +436,9 @@ AcpiPsNextParseState (
{ {
ACPI_PARSE_STATE *ParserState = &WalkState->ParserState; ACPI_PARSE_STATE *ParserState = &WalkState->ParserState;
ACPI_STATUS Status = AE_CTRL_PENDING; ACPI_STATUS Status = AE_CTRL_PENDING;
UINT8 *Start;
UINT32 PackageLength;
FUNCTION_TRACE_PTR ("PsNextParseState", Op); ACPI_FUNCTION_TRACE_PTR ("PsNextParseState", Op);
switch (CallbackStatus) switch (CallbackStatus)
@ -449,17 +454,22 @@ AcpiPsNextParseState (
break; break;
case AE_CTRL_BREAK:
ParserState->Aml = WalkState->AmlLastWhile;
WalkState->ControlState->Common.Value = FALSE;
Status = AE_CTRL_BREAK;
break;
case AE_CTRL_CONTINUE:
ParserState->Aml = WalkState->AmlLastWhile;
Status = AE_CTRL_CONTINUE;
break;
case AE_CTRL_PENDING: case AE_CTRL_PENDING:
/*
* Predicate of a WHILE was true and the loop just completed an
* execution. Go back to the start of the loop and reevaluate the
* predicate.
*/
/* TBD: How to handle a break within a while. */
/* This code attempts it */
ParserState->Aml = WalkState->AmlLastWhile; ParserState->Aml = WalkState->AmlLastWhile;
break; break;
@ -469,13 +479,8 @@ AcpiPsNextParseState (
/* /*
* Predicate of an IF was true, and we are at the matching ELSE. * Predicate of an IF was true, and we are at the matching ELSE.
* Just close out this package * Just close out this package
*
* Note: ParserState->Aml is modified by the package length procedure
* TBD: [Investigate] perhaps it shouldn't, too much trouble
*/ */
Start = ParserState->Aml; ParserState->Aml = AcpiPsGetNextPackageEnd (ParserState);
PackageLength = AcpiPsGetNextPackageLength (ParserState);
ParserState->Aml = Start + PackageLength;
break; break;
@ -551,14 +556,14 @@ AcpiPsParseLoop (
UINT8 *AmlOpStart; UINT8 *AmlOpStart;
FUNCTION_TRACE_PTR ("PsParseLoop", WalkState); ACPI_FUNCTION_TRACE_PTR ("PsParseLoop", WalkState);
ParserState = &WalkState->ParserState; ParserState = &WalkState->ParserState;
WalkState->ArgTypes = 0; WalkState->ArgTypes = 0;
#ifndef PARSER_ONLY #ifndef PARSER_ONLY
if (WalkState->WalkType & WALK_METHOD_RESTART) if (WalkState->WalkType & ACPI_WALK_METHOD_RESTART)
{ {
/* We are restarting a preempted control method */ /* We are restarting a preempted control method */
@ -573,7 +578,7 @@ AcpiPsParseLoop (
(ParserState->Scope->ParseScope.Op->Opcode == AML_WHILE_OP)) && (ParserState->Scope->ParseScope.Op->Opcode == AML_WHILE_OP)) &&
(WalkState->ControlState) && (WalkState->ControlState) &&
(WalkState->ControlState->Common.State == (WalkState->ControlState->Common.State ==
CONTROL_PREDICATE_EXECUTING)) ACPI_CONTROL_PREDICATE_EXECUTING))
{ {
/* /*
@ -581,7 +586,7 @@ AcpiPsParseLoop (
* predicate and branch based on that value * predicate and branch based on that value
*/ */
WalkState->Op = NULL; WalkState->Op = NULL;
Status = AcpiDsGetPredicateValue (WalkState, TRUE); Status = AcpiDsGetPredicateValue (WalkState, ACPI_TO_POINTER (TRUE));
if (ACPI_FAILURE (Status) && if (ACPI_FAILURE (Status) &&
((Status & AE_CODE_MASK) != AE_CODE_CONTROL)) ((Status & AE_CODE_MASK) != AE_CODE_CONTROL))
{ {
@ -654,7 +659,7 @@ AcpiPsParseLoop (
"Found unknown opcode %X at AML offset %X, ignoring\n", "Found unknown opcode %X at AML offset %X, ignoring\n",
WalkState->Opcode, WalkState->AmlOffset)); WalkState->Opcode, WalkState->AmlOffset));
DUMP_BUFFER (ParserState->Aml, 128); ACPI_DUMP_BUFFER (ParserState->Aml, 128);
/* Assume one-byte bad opcode */ /* Assume one-byte bad opcode */
@ -800,8 +805,8 @@ AcpiPsParseLoop (
if (WalkState->OpInfo) if (WalkState->OpInfo)
{ {
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Op=%p Opcode=%4.4X Aml %p Oft=%5.5X\n", "Opcode %4.4X [%s] Op %p Aml %p AmlOffset %5.5X\n",
Op, Op->Opcode, ParserState->Aml, Op->AmlOffset)); Op->Opcode, WalkState->OpInfo->Name, Op, ParserState->Aml, Op->AmlOffset));
} }
} }
@ -863,9 +868,9 @@ AcpiPsParseLoop (
* because we don't have enough info in the first pass * because we don't have enough info in the first pass
* to parse them correctly. * to parse them correctly.
*/ */
((ACPI_PARSE2_OBJECT * ) Op)->Data = ParserState->Aml; ((ACPI_PARSE2_OBJECT * ) Op)->Data = ParserState->Aml;
((ACPI_PARSE2_OBJECT * ) Op)->Length = (UINT32) (ParserState->PkgEnd - ((ACPI_PARSE2_OBJECT * ) Op)->Length = (UINT32) (ParserState->PkgEnd -
ParserState->Aml); ParserState->Aml);
/* /*
* Skip body of method. For OpRegions, we must continue * Skip body of method. For OpRegions, we must continue
@ -873,173 +878,212 @@ AcpiPsParseLoop (
* package (We don't know where the end is). * package (We don't know where the end is).
*/ */
ParserState->Aml = ParserState->PkgEnd; ParserState->Aml = ParserState->PkgEnd;
WalkState->ArgCount = 0; WalkState->ArgCount = 0;
}
else if (Op->Opcode == AML_WHILE_OP)
{
if (WalkState->ControlState)
{
WalkState->ControlState->Control.PackageEnd = ParserState->PkgEnd;
}
} }
break; break;
} }
} }
/* /* Check for arguments that need to be processed */
* Zero ArgCount means that all arguments for this op have been processed
*/ if (WalkState->ArgCount)
if (!WalkState->ArgCount)
{ {
/* completed Op, prepare for next */ /* There are arguments (complex ones), push Op and prepare for argument */
WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode); AcpiPsPushScope (ParserState, Op, WalkState->ArgTypes, WalkState->ArgCount);
if (WalkState->OpInfo->Flags & AML_NAMED) Op = NULL;
continue;
}
/* All arguments have been processed -- Op is complete, prepare for next */
WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode);
if (WalkState->OpInfo->Flags & AML_NAMED)
{
if (AcpiGbl_Depth)
{ {
if (AcpiGbl_Depth) AcpiGbl_Depth--;
{
AcpiGbl_Depth--;
}
if (Op->Opcode == AML_REGION_OP)
{
/*
* Skip parsing of control method or opregion body,
* because we don't have enough info in the first pass
* to parse them correctly.
*
* Completed parsing an OpRegion declaration, we now
* know the length.
*/
((ACPI_PARSE2_OBJECT * ) Op)->Length = (UINT32) (ParserState->Aml -
((ACPI_PARSE2_OBJECT * ) Op)->Data);
}
} }
if (WalkState->OpInfo->Flags & AML_CREATE) if (Op->Opcode == AML_REGION_OP)
{ {
/* /*
* Backup to beginning of CreateXXXfield declaration (1 for * Skip parsing of control method or opregion body,
* Opcode) * because we don't have enough info in the first pass
* to parse them correctly.
* *
* BodyLength is unknown until we parse the body * Completed parsing an OpRegion declaration, we now
* know the length.
*/ */
((ACPI_PARSE2_OBJECT * ) Op)->Length = (UINT32) (ParserState->Aml - ((ACPI_PARSE2_OBJECT * ) Op)->Length = (UINT32) (ParserState->Aml -
((ACPI_PARSE2_OBJECT * ) Op)->Data); ((ACPI_PARSE2_OBJECT * ) Op)->Data);
} }
}
/* This op complete, notify the dispatcher */ if (WalkState->OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration (1 for
* Opcode)
*
* BodyLength is unknown until we parse the body
*/
((ACPI_PARSE2_OBJECT * ) Op)->Length = (UINT32) (ParserState->Aml -
((ACPI_PARSE2_OBJECT * ) Op)->Data);
}
if (WalkState->AscendingCallback != NULL) /* This op complete, notify the dispatcher */
if (WalkState->AscendingCallback != NULL)
{
WalkState->Op = Op;
WalkState->Opcode = Op->Opcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{ {
WalkState->Op = Op; Status = AE_OK;
WalkState->Opcode = Op->Opcode; goto CloseThisOp;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
} }
}
CloseThisOp: CloseThisOp:
/*
* Finished one argument of the containing scope
*/
ParserState->Scope->ParseScope.ArgCount--;
/* Close this Op (may result in parse subtree deletion) */
if (AcpiPsCompleteThisOp (WalkState, Op))
{
Op = NULL;
}
switch (Status)
{
case AE_OK:
break;
case AE_CTRL_TRANSFER:
/* /*
* Finished one argument of the containing scope * We are about to transfer to a called method.
*/ */
ParserState->Scope->ParseScope.ArgCount--; WalkState->PrevOp = Op;
WalkState->PrevArgTypes = WalkState->ArgTypes;
return_ACPI_STATUS (Status);
/* Close this Op (may result in parse subtree deletion) */
if (AcpiPsCompleteThisOp (WalkState, Op)) case AE_CTRL_END:
AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
WalkState->Op = Op;
WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode);
WalkState->Opcode = Op->Opcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, Op, Status);
AcpiPsCompleteThisOp (WalkState, Op);
Op = NULL;
Status = AE_OK;
break;
case AE_CTRL_BREAK:
case AE_CTRL_CONTINUE:
/* Pop off scopes until we find the While */
while (!Op || (Op->Opcode != AML_WHILE_OP))
{ {
Op = NULL; AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
} }
switch (Status) /* Close this iteration of the While loop */
WalkState->Op = Op;
WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode);
WalkState->Opcode = Op->Opcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, Op, Status);
AcpiPsCompleteThisOp (WalkState, Op);
Op = NULL;
Status = AE_OK;
break;
case AE_CTRL_TERMINATE:
Status = AE_OK;
/* Clean up */
do
{ {
case AE_OK: if (Op)
break;
case AE_CTRL_TRANSFER:
/*
* We are about to transfer to a called method.
*/
WalkState->PrevOp = Op;
WalkState->PrevArgTypes = WalkState->ArgTypes;
return_ACPI_STATUS (Status);
break;
case AE_CTRL_END:
AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
WalkState->Op = Op;
WalkState->OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode);
WalkState->Opcode = Op->Opcode;
Status = WalkState->AscendingCallback (WalkState);
Status = AcpiPsNextParseState (WalkState, Op, Status);
AcpiPsCompleteThisOp (WalkState, Op);
Op = NULL;
Status = AE_OK;
break;
case AE_CTRL_TERMINATE:
Status = AE_OK;
/* Clean up */
do
{ {
if (Op) AcpiPsCompleteThisOp (WalkState, Op);
{
AcpiPsCompleteThisOp (WalkState, Op);
}
AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
break;
default: /* All other non-AE_OK status */
if (Op == NULL)
{
AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
} }
WalkState->PrevOp = Op; AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
WalkState->PrevArgTypes = WalkState->ArgTypes;
/* } while (Op);
* TBD: TEMP:
*/
return_ACPI_STATUS (Status);
break;
}
/* This scope complete? */ return_ACPI_STATUS (Status);
if (AcpiPsHasCompletedScope (ParserState))
default: /* All other non-AE_OK status */
do
{
if (Op)
{
AcpiPsCompleteThisOp (WalkState, Op);
}
AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
} while (Op);
/*
* TBD: Cleanup parse ops on error
*/
#if 0
if (Op == NULL)
{ {
AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount); AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
}
else
{
Op = NULL;
} }
#endif
WalkState->PrevOp = Op;
WalkState->PrevArgTypes = WalkState->ArgTypes;
return_ACPI_STATUS (Status);
}
/* This scope complete? */
if (AcpiPsHasCompletedScope (ParserState))
{
AcpiPsPopScope (ParserState, &Op, &WalkState->ArgTypes, &WalkState->ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
} }
else else
{ {
/* ArgCount is non-zero */
/* complex argument, push Op and prepare for argument */
AcpiPsPushScope (ParserState, Op, WalkState->ArgTypes, WalkState->ArgCount);
Op = NULL; Op = NULL;
} }
@ -1137,7 +1181,7 @@ AcpiPsParseAml (
FUNCTION_TRACE ("PsParseAml"); ACPI_FUNCTION_TRACE ("PsParseAml");
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Entered with WalkState=%p Aml=%p size=%X\n", ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Entered with WalkState=%p Aml=%p size=%X\n",
WalkState, WalkState->ParserState.Aml, WalkState->ParserState.AmlSize)); WalkState, WalkState->ParserState.Aml, WalkState->ParserState.AmlSize));
@ -1154,8 +1198,9 @@ AcpiPsParseAml (
WalkState->Thread = Thread; WalkState->Thread = Thread;
AcpiDsPushWalkState (WalkState, Thread); AcpiDsPushWalkState (WalkState, Thread);
/*
/* TBD: [Restructure] TEMP until we pass WalkState to the interpreter * This global allows the AML debugger to get a handle to the currently
* executing control method.
*/ */
AcpiGbl_CurrentWalkList = Thread; AcpiGbl_CurrentWalkList = Thread;
@ -1243,14 +1288,23 @@ AcpiPsParseAml (
{ {
if (ACPI_SUCCESS (Status)) if (ACPI_SUCCESS (Status))
{ {
/* There is another walk state, restart it */
/* /*
* If the method returned value is not used by the parent, * There is another walk state, restart it.
* If the method return value is not used by the parent,
* The object is deleted * The object is deleted
*/ */
AcpiDsRestartControlMethod (WalkState, PreviousWalkState->ReturnDesc); AcpiDsRestartControlMethod (WalkState, PreviousWalkState->ReturnDesc);
WalkState->WalkType |= WALK_METHOD_RESTART; WalkState->WalkType |= ACPI_WALK_METHOD_RESTART;
}
else
{
/* On error, delete any return object */
AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
ACPI_REPORT_ERROR (("Method execution failed, %s\n", AcpiFormatException (Status)));
ACPI_DUMP_PATHNAME (WalkState->MethodNode, "Method pathname: ",
ACPI_LV_ERROR, _COMPONENT);
} }
} }

187
sys/contrib/dev/acpica/rscreate.c
View File

@ -1,7 +1,7 @@
/******************************************************************************* /*******************************************************************************
* *
* Module Name: rscreate - Create resource lists/tables * Module Name: rscreate - Create resource lists/tables
* $Revision: 38 $ * $Revision: 53 $
* *
******************************************************************************/ ******************************************************************************/
@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -123,7 +123,7 @@
#include "acnamesp.h" #include "acnamesp.h"
#define _COMPONENT ACPI_RESOURCES #define _COMPONENT ACPI_RESOURCES
MODULE_NAME ("rscreate") ACPI_MODULE_NAME ("rscreate")
/******************************************************************************* /*******************************************************************************
@ -148,17 +148,16 @@
ACPI_STATUS ACPI_STATUS
AcpiRsCreateResourceList ( AcpiRsCreateResourceList (
ACPI_OPERAND_OBJECT *ByteStreamBuffer, ACPI_OPERAND_OBJECT *ByteStreamBuffer,
UINT8 *OutputBuffer, ACPI_BUFFER *OutputBuffer)
UINT32 *OutputBufferLength)
{ {
ACPI_STATUS Status; ACPI_STATUS Status;
UINT8 *ByteStreamStart; UINT8 *ByteStreamStart;
UINT32 ListSizeNeeded = 0; ACPI_SIZE ListSizeNeeded = 0;
UINT32 ByteStreamBufferLength; UINT32 ByteStreamBufferLength;
FUNCTION_TRACE ("RsCreateResourceList"); ACPI_FUNCTION_TRACE ("RsCreateResourceList");
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ByteStreamBuffer = %p\n", ByteStreamBuffer)); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "ByteStreamBuffer = %p\n", ByteStreamBuffer));
@ -183,29 +182,25 @@ AcpiRsCreateResourceList (
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* /* Validate/Allocate/Clear caller buffer */
* Is caller buffer large enough?
*/
if (ListSizeNeeded > *OutputBufferLength)
{
*OutputBufferLength = ListSizeNeeded;
return_ACPI_STATUS (AE_BUFFER_OVERFLOW);
}
/* Status = AcpiUtInitializeBuffer (OutputBuffer, ListSizeNeeded);
* Zero out the return buffer before proceeding
*/
MEMSET (OutputBuffer, 0x00, *OutputBufferLength);
Status = AcpiRsByteStreamToList (ByteStreamStart, ByteStreamBufferLength,
&OutputBuffer);
if (ACPI_FAILURE (Status)) if (ACPI_FAILURE (Status))
{ {
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer = %p\n", OutputBuffer)); /* Do the conversion */
*OutputBufferLength = ListSizeNeeded;
Status = AcpiRsByteStreamToList (ByteStreamStart, ByteStreamBufferLength,
OutputBuffer->Pointer);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
OutputBuffer->Pointer, OutputBuffer->Length));
return_ACPI_STATUS (AE_OK); return_ACPI_STATUS (AE_OK);
} }
@ -221,71 +216,68 @@ AcpiRsCreateResourceList (
* *
* RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code. * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code.
* If the OutputBuffer is too small, the error will be * If the OutputBuffer is too small, the error will be
* AE_BUFFER_OVERFLOW and OutputBufferLength will point * AE_BUFFER_OVERFLOW and OutputBuffer->Length will point
* to the size buffer needed. * to the size buffer needed.
* *
* DESCRIPTION: Takes the ACPI_OPERAND_OBJECT package and creates a * DESCRIPTION: Takes the ACPI_OPERAND_OBJECT package and creates a
* linked list of PCI interrupt descriptions * linked list of PCI interrupt descriptions
* *
* NOTE: It is the caller's responsibility to ensure that the start of the
* output buffer is aligned properly (if necessary).
*
******************************************************************************/ ******************************************************************************/
ACPI_STATUS ACPI_STATUS
AcpiRsCreatePciRoutingTable ( AcpiRsCreatePciRoutingTable (
ACPI_OPERAND_OBJECT *PackageObject, ACPI_OPERAND_OBJECT *PackageObject,
UINT8 *OutputBuffer, ACPI_BUFFER *OutputBuffer)
UINT32 *OutputBufferLength)
{ {
UINT8 *Buffer = OutputBuffer; UINT8 *Buffer;
ACPI_OPERAND_OBJECT **TopObjectList = NULL; ACPI_OPERAND_OBJECT **TopObjectList = NULL;
ACPI_OPERAND_OBJECT **SubObjectList = NULL; ACPI_OPERAND_OBJECT **SubObjectList = NULL;
ACPI_OPERAND_OBJECT *PackageElement = NULL; ACPI_OPERAND_OBJECT *PackageElement = NULL;
UINT32 BufferSizeNeeded = 0; ACPI_SIZE BufferSizeNeeded = 0;
UINT32 NumberOfElements = 0; UINT32 NumberOfElements = 0;
UINT32 Index = 0; UINT32 Index = 0;
PCI_ROUTING_TABLE *UserPrt = NULL; ACPI_PCI_ROUTING_TABLE *UserPrt = NULL;
ACPI_NAMESPACE_NODE *Node; ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status; ACPI_STATUS Status;
ACPI_BUFFER PathBuffer;
FUNCTION_TRACE ("RsCreatePciRoutingTable"); ACPI_FUNCTION_TRACE ("RsCreatePciRoutingTable");
/* Params already validated, so we don't re-validate here */
/* /*
* Params already validated, so we don't re-validate here * Get the required buffer length
*/ */
Status = AcpiRsCalculatePciRoutingTableLength (PackageObject, Status = AcpiRsCalculatePciRoutingTableLength (PackageObject,
&BufferSizeNeeded); &BufferSizeNeeded);
if (!ACPI_SUCCESS(Status)) if (ACPI_FAILURE (Status))
{ {
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "BufferSizeNeeded = %X\n", BufferSizeNeeded)); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "BufferSizeNeeded = %X\n", BufferSizeNeeded));
/* Is caller buffer large enough? */ /* Validate/Allocate/Clear caller buffer */
if (BufferSizeNeeded > *OutputBufferLength) Status = AcpiUtInitializeBuffer (OutputBuffer, BufferSizeNeeded);
if (ACPI_FAILURE (Status))
{ {
*OutputBufferLength = BufferSizeNeeded; return_ACPI_STATUS (Status);
return_ACPI_STATUS (AE_BUFFER_OVERFLOW);
} }
/* /*
* Zero out the return buffer before proceeding * Loop through the ACPI_INTERNAL_OBJECTS - Each object should contain an
*/ * ACPI_INTEGER Address, a UINT8 Pin, a Name and a UINT8 SourceIndex.
MEMSET (OutputBuffer, 0x00, *OutputBufferLength);
/*
* Loop through the ACPI_INTERNAL_OBJECTS - Each object should
* contain a UINT32 Address, a UINT8 Pin, a Name and a UINT8
* SourceIndex.
*/ */
TopObjectList = PackageObject->Package.Elements; TopObjectList = PackageObject->Package.Elements;
NumberOfElements = PackageObject->Package.Count; NumberOfElements = PackageObject->Package.Count;
UserPrt = (PCI_ROUTING_TABLE *) Buffer; Buffer = OutputBuffer->Pointer;
UserPrt = (ACPI_PCI_ROUTING_TABLE *) Buffer;
Buffer = ROUND_PTR_UP_TO_8 (Buffer, UINT8);
for (Index = 0; Index < NumberOfElements; Index++) for (Index = 0; Index < NumberOfElements; Index++)
{ {
@ -296,15 +288,14 @@ AcpiRsCreatePciRoutingTable (
* be zero because we cleared the return buffer earlier * be zero because we cleared the return buffer earlier
*/ */
Buffer += UserPrt->Length; Buffer += UserPrt->Length;
UserPrt = (PCI_ROUTING_TABLE *) Buffer; UserPrt = (ACPI_PCI_ROUTING_TABLE *) Buffer;
/* /*
* Fill in the Length field with the information we * Fill in the Length field with the information we have at this point.
* have at this point. * The minus four is to subtract the size of the UINT8 Source[4] member
* The minus four is to subtract the size of the * because it is added below.
* UINT8 Source[4] member because it is added below.
*/ */
UserPrt->Length = (sizeof (PCI_ROUTING_TABLE) -4); UserPrt->Length = (sizeof (ACPI_PCI_ROUTING_TABLE) -4);
/* /*
* Dereference the sub-package * Dereference the sub-package
@ -312,9 +303,8 @@ AcpiRsCreatePciRoutingTable (
PackageElement = *TopObjectList; PackageElement = *TopObjectList;
/* /*
* The SubObjectList will now point to an array of * The SubObjectList will now point to an array of the four IRQ
* the four IRQ elements: Address, Pin, Source and * elements: Address, Pin, Source and SourceIndex
* SourceIndex
*/ */
SubObjectList = PackageElement->Package.Elements; SubObjectList = PackageElement->Package.Elements;
@ -368,37 +358,33 @@ AcpiRsCreatePciRoutingTable (
/* Use *remaining* length of the buffer as max for pathname */ /* Use *remaining* length of the buffer as max for pathname */
BufferSizeNeeded = *OutputBufferLength - PathBuffer.Length = OutputBuffer->Length -
(UINT32) ((UINT8 *) UserPrt->Source - OutputBuffer); (UINT32) ((UINT8 *) UserPrt->Source - (UINT8 *) OutputBuffer->Pointer);
PathBuffer.Pointer = UserPrt->Source;
Status = AcpiNsHandleToPathname ((ACPI_HANDLE *) Node, Status = AcpiNsHandleToPathname ((ACPI_HANDLE *) Node, &PathBuffer);
&BufferSizeNeeded, UserPrt->Source);
UserPrt->Length += STRLEN (UserPrt->Source) + 1; /* include null terminator */ UserPrt->Length += ACPI_STRLEN (UserPrt->Source) + 1; /* include null terminator */
break; break;
case ACPI_TYPE_STRING: case ACPI_TYPE_STRING:
STRCPY (UserPrt->Source, ACPI_STRCPY (UserPrt->Source,
(*SubObjectList)->String.Pointer); (*SubObjectList)->String.Pointer);
/* /* Add to the Length field the length of the string */
* Add to the Length field the length of the string
*/
UserPrt->Length += (*SubObjectList)->String.Length; UserPrt->Length += (*SubObjectList)->String.Length;
break; break;
case ACPI_TYPE_INTEGER: case ACPI_TYPE_INTEGER:
/* /*
* If this is a number, then the Source Name * If this is a number, then the Source Name is NULL, since the
* is NULL, since the entire buffer was zeroed * entire buffer was zeroed out, we can leave this alone.
* out, we can leave this alone. *
*/ * Add to the Length field the length of the UINT32 NULL
/*
* Add to the Length field the length of
* the UINT32 NULL
*/ */
UserPrt->Length += sizeof (UINT32); UserPrt->Length += sizeof (UINT32);
break; break;
@ -409,12 +395,11 @@ AcpiRsCreatePciRoutingTable (
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n",
AcpiUtGetTypeName ((*SubObjectList)->Common.Type))); AcpiUtGetTypeName ((*SubObjectList)->Common.Type)));
return_ACPI_STATUS (AE_BAD_DATA); return_ACPI_STATUS (AE_BAD_DATA);
break;
} }
/* Now align the current length */ /* Now align the current length */
UserPrt->Length = ROUND_UP_TO_64BITS (UserPrt->Length); UserPrt->Length = ACPI_ROUND_UP_TO_64BITS (UserPrt->Length);
/* /*
* 4) Fourth subobject: Dereference the Source Index * 4) Fourth subobject: Dereference the Source Index
@ -432,16 +417,13 @@ AcpiRsCreatePciRoutingTable (
return_ACPI_STATUS (AE_BAD_DATA); return_ACPI_STATUS (AE_BAD_DATA);
} }
/* /* Point to the next ACPI_OPERAND_OBJECT */
* Point to the next ACPI_OPERAND_OBJECT
*/
TopObjectList++; TopObjectList++;
} }
/* ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
* Report the amount of buffer used OutputBuffer->Pointer, OutputBuffer->Length));
*/
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer = %p\n", OutputBuffer));
return_ACPI_STATUS (AE_OK); return_ACPI_STATUS (AE_OK);
} }
@ -452,11 +434,10 @@ AcpiRsCreatePciRoutingTable (
* *
* PARAMETERS: LinkedListBuffer - Pointer to the resource linked list * PARAMETERS: LinkedListBuffer - Pointer to the resource linked list
* OutputBuffer - Pointer to the user's buffer * OutputBuffer - Pointer to the user's buffer
* OutputBufferLength - Size of OutputBuffer
* *
* RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code. * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code.
* If the OutputBuffer is too small, the error will be * If the OutputBuffer is too small, the error will be
* AE_BUFFER_OVERFLOW and OutputBufferLength will point * AE_BUFFER_OVERFLOW and OutputBuffer->Length will point
* to the size buffer needed. * to the size buffer needed.
* *
* DESCRIPTION: Takes the linked list of device resources and * DESCRIPTION: Takes the linked list of device resources and
@ -468,14 +449,13 @@ AcpiRsCreatePciRoutingTable (
ACPI_STATUS ACPI_STATUS
AcpiRsCreateByteStream ( AcpiRsCreateByteStream (
ACPI_RESOURCE *LinkedListBuffer, ACPI_RESOURCE *LinkedListBuffer,
UINT8 *OutputBuffer, ACPI_BUFFER *OutputBuffer)
UINT32 *OutputBufferLength)
{ {
ACPI_STATUS Status; ACPI_STATUS Status;
UINT32 ByteStreamSizeNeeded = 0; ACPI_SIZE ByteStreamSizeNeeded = 0;
FUNCTION_TRACE ("RsCreateByteStream"); ACPI_FUNCTION_TRACE ("RsCreateByteStream");
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "LinkedListBuffer = %p\n", LinkedListBuffer)); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "LinkedListBuffer = %p\n", LinkedListBuffer));
@ -496,28 +476,25 @@ AcpiRsCreateByteStream (
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* /* Validate/Allocate/Clear caller buffer */
* Is caller buffer large enough?
*/
if (ByteStreamSizeNeeded > *OutputBufferLength)
{
*OutputBufferLength = ByteStreamSizeNeeded;
return_ACPI_STATUS (AE_BUFFER_OVERFLOW);
}
/* Status = AcpiUtInitializeBuffer (OutputBuffer, ByteStreamSizeNeeded);
* Zero out the return buffer before proceeding
*/
MEMSET (OutputBuffer, 0x00, *OutputBufferLength);
Status = AcpiRsListToByteStream (LinkedListBuffer, ByteStreamSizeNeeded,
&OutputBuffer);
if (ACPI_FAILURE (Status)) if (ACPI_FAILURE (Status))
{ {
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer = %p\n", OutputBuffer)); /* Do the conversion */
Status = AcpiRsListToByteStream (LinkedListBuffer, ByteStreamSizeNeeded,
OutputBuffer->Pointer);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "OutputBuffer %p Length %X\n",
OutputBuffer->Pointer, OutputBuffer->Length));
return_ACPI_STATUS (AE_OK); return_ACPI_STATUS (AE_OK);
} }

111
sys/contrib/dev/acpica/tbget.c
View File

@ -1,7 +1,7 @@
/****************************************************************************** /******************************************************************************
* *
* Module Name: tbget - ACPI Table get* routines * Module Name: tbget - ACPI Table get* routines
* $Revision: 57 $ * $Revision: 63 $
* *
*****************************************************************************/ *****************************************************************************/
@ -9,7 +9,7 @@
* *
* 1. Copyright Notice * 1. Copyright Notice
* *
* Some or all of this work - Copyright (c) 1999, 2000, 2001, Intel Corp. * Some or all of this work - Copyright (c) 1999 - 2002, Intel Corp.
* All rights reserved. * All rights reserved.
* *
* 2. License * 2. License
@ -117,14 +117,11 @@
#define __TBGET_C__ #define __TBGET_C__
#include "acpi.h" #include "acpi.h"
#include "achware.h"
#include "actables.h" #include "actables.h"
#define _COMPONENT ACPI_TABLES #define _COMPONENT ACPI_TABLES
MODULE_NAME ("tbget") ACPI_MODULE_NAME ("tbget")
#define RSDP_CHECKSUM_LENGTH 20
/******************************************************************************* /*******************************************************************************
@ -152,7 +149,7 @@ AcpiTbGetTablePtr (
UINT32 i; UINT32 i;
FUNCTION_TRACE ("TbGetTablePtr"); ACPI_FUNCTION_TRACE ("TbGetTablePtr");
if (!AcpiGbl_DSDT) if (!AcpiGbl_DSDT)
@ -165,7 +162,6 @@ AcpiTbGetTablePtr (
return_ACPI_STATUS (AE_BAD_PARAMETER); return_ACPI_STATUS (AE_BAD_PARAMETER);
} }
/* /*
* For all table types (Single/Multiple), the first * For all table types (Single/Multiple), the first
* instance is always in the list head. * instance is always in the list head.
@ -180,7 +176,6 @@ AcpiTbGetTablePtr (
return_ACPI_STATUS (AE_OK); return_ACPI_STATUS (AE_OK);
} }
/* /*
* Check for instance out of range * Check for instance out of range
*/ */
@ -238,7 +233,7 @@ AcpiTbGetTable (
ACPI_STATUS Status = AE_OK; ACPI_STATUS Status = AE_OK;
FUNCTION_TRACE ("TbGetTable"); ACPI_FUNCTION_TRACE ("TbGetTable");
if (!TableInfo) if (!TableInfo)
@ -246,7 +241,6 @@ AcpiTbGetTable (
return_ACPI_STATUS (AE_BAD_PARAMETER); return_ACPI_STATUS (AE_BAD_PARAMETER);
} }
if (BufferPtr) if (BufferPtr)
{ {
/* /*
@ -272,14 +266,13 @@ AcpiTbGetTable (
/* Copy the entire table (including header) to the local buffer */ /* Copy the entire table (including header) to the local buffer */
Size = TableHeader->Length; Size = TableHeader->Length;
MEMCPY (FullTable, BufferPtr, Size); ACPI_MEMCPY (FullTable, BufferPtr, Size);
/* Save allocation type */ /* Save allocation type */
Allocation = ACPI_MEM_ALLOCATED; Allocation = ACPI_MEM_ALLOCATED;
} }
/* /*
* Not reading from a buffer, just map the table's physical memory * Not reading from a buffer, just map the table's physical memory
* into our address space. * into our address space.
@ -299,7 +292,6 @@ AcpiTbGetTable (
Allocation = ACPI_MEM_MAPPED; Allocation = ACPI_MEM_MAPPED;
} }
/* Return values */ /* Return values */
TableInfo->Pointer = FullTable; TableInfo->Pointer = FullTable;
@ -335,7 +327,7 @@ AcpiTbGetAllTables (
ACPI_TABLE_DESC TableInfo; ACPI_TABLE_DESC TableInfo;
FUNCTION_TRACE ("TbGetAllTables"); ACPI_FUNCTION_TRACE ("TbGetAllTables");
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Number of tables: %d\n", NumberOfTables)); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Number of tables: %d\n", NumberOfTables));
@ -349,7 +341,7 @@ AcpiTbGetAllTables (
{ {
/* Clear the TableInfo each time */ /* Clear the TableInfo each time */
MEMSET (&TableInfo, 0, sizeof (ACPI_TABLE_DESC)); ACPI_MEMSET (&TableInfo, 0, sizeof (ACPI_TABLE_DESC));
/* Get the table via the XSDT */ /* Get the table via the XSDT */
@ -385,7 +377,6 @@ AcpiTbGetAllTables (
} }
} }
/* /*
* Convert the FADT to a common format. This allows earlier revisions of the * Convert the FADT to a common format. This allows earlier revisions of the
* table to coexist with newer versions, using common access code. * table to coexist with newer versions, using common access code.
@ -396,7 +387,6 @@ AcpiTbGetAllTables (
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* /*
* Get the minimum set of ACPI tables, namely: * Get the minimum set of ACPI tables, namely:
* *
@ -434,7 +424,6 @@ AcpiTbGetAllTables (
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* /*
* Get the DSDT (We know that the FADT is valid now) * Get the DSDT (We know that the FADT is valid now)
*/ */
@ -458,19 +447,18 @@ AcpiTbGetAllTables (
/* Dump the DSDT Header */ /* Dump the DSDT Header */
ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "Hex dump of DSDT Header:\n")); ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "Hex dump of DSDT Header:\n"));
DUMP_BUFFER ((UINT8 *) AcpiGbl_DSDT, sizeof (ACPI_TABLE_HEADER)); ACPI_DUMP_BUFFER ((UINT8 *) AcpiGbl_DSDT, sizeof (ACPI_TABLE_HEADER));
/* Dump the entire DSDT */ /* Dump the entire DSDT */
ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, ACPI_DEBUG_PRINT ((ACPI_DB_TABLES,
"Hex dump of DSDT (After header), size %d (%x)\n", "Hex dump of DSDT (After header), size %d (%x)\n",
AcpiGbl_DSDT->Length, AcpiGbl_DSDT->Length)); AcpiGbl_DSDT->Length, AcpiGbl_DSDT->Length));
DUMP_BUFFER ((UINT8 *) (AcpiGbl_DSDT + 1), AcpiGbl_DSDT->Length); ACPI_DUMP_BUFFER ((UINT8 *) (AcpiGbl_DSDT + 1), AcpiGbl_DSDT->Length);
/* Always delete the RSDP mapping, we are done with it */ /* Always delete the RSDP mapping, we are done with it */
AcpiTbDeleteAcpiTable (ACPI_TABLE_RSDP); AcpiTbDeleteAcpiTable (ACPI_TABLE_RSDP);
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
@ -493,17 +481,17 @@ AcpiTbVerifyRsdp (
{ {
ACPI_TABLE_DESC TableInfo; ACPI_TABLE_DESC TableInfo;
ACPI_STATUS Status; ACPI_STATUS Status;
UINT8 *TablePtr; RSDP_DESCRIPTOR *Rsdp;
FUNCTION_TRACE ("TbVerifyRsdp"); ACPI_FUNCTION_TRACE ("TbVerifyRsdp");
/* /*
* Obtain access to the RSDP structure * Obtain access to the RSDP structure
*/ */
Status = AcpiOsMapMemory (RsdpPhysicalAddress, sizeof (RSDP_DESCRIPTOR), Status = AcpiOsMapMemory (RsdpPhysicalAddress, sizeof (RSDP_DESCRIPTOR),
(void **) &TablePtr); (void **) &Rsdp);
if (ACPI_FAILURE (Status)) if (ACPI_FAILURE (Status))
{ {
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
@ -512,7 +500,7 @@ AcpiTbVerifyRsdp (
/* /*
* The signature and checksum must both be correct * The signature and checksum must both be correct
*/ */
if (STRNCMP ((NATIVE_CHAR *) TablePtr, RSDP_SIG, sizeof (RSDP_SIG)-1) != 0) if (ACPI_STRNCMP ((NATIVE_CHAR *) Rsdp, RSDP_SIG, sizeof (RSDP_SIG)-1) != 0)
{ {
/* Nope, BAD Signature */ /* Nope, BAD Signature */
@ -520,22 +508,32 @@ AcpiTbVerifyRsdp (
goto Cleanup; goto Cleanup;
} }
if (AcpiTbChecksum (TablePtr, RSDP_CHECKSUM_LENGTH) != 0) /* Check the standard checksum */
{
/* Nope, BAD Checksum */
if (AcpiTbChecksum (Rsdp, ACPI_RSDP_CHECKSUM_LENGTH) != 0)
{
Status = AE_BAD_CHECKSUM; Status = AE_BAD_CHECKSUM;
goto Cleanup; goto Cleanup;
} }
/* TBD: Check extended checksum if table version >= 2 */ /* Check extended checksum if table version >= 2 */
if (Rsdp->Revision >= 2)
{
if (AcpiTbChecksum (Rsdp, ACPI_RSDP_XCHECKSUM_LENGTH) != 0)
{
Status = AE_BAD_CHECKSUM;
goto Cleanup;
}
}
/* The RSDP supplied is OK */ /* The RSDP supplied is OK */
TableInfo.Pointer = (ACPI_TABLE_HEADER *) TablePtr; TableInfo.Pointer = (ACPI_TABLE_HEADER *) Rsdp;
TableInfo.Length = sizeof (RSDP_DESCRIPTOR); TableInfo.Length = sizeof (RSDP_DESCRIPTOR);
TableInfo.Allocation = ACPI_MEM_MAPPED; TableInfo.Allocation = ACPI_MEM_MAPPED;
TableInfo.BasePointer = TablePtr; TableInfo.BasePointer = Rsdp;
/* Save the table pointers and allocation info */ /* Save the table pointers and allocation info */
@ -545,7 +543,6 @@ AcpiTbVerifyRsdp (
goto Cleanup; goto Cleanup;
} }
/* Save the RSDP in a global for easy access */ /* Save the RSDP in a global for easy access */
AcpiGbl_RSDP = (RSDP_DESCRIPTOR *) TableInfo.Pointer; AcpiGbl_RSDP = (RSDP_DESCRIPTOR *) TableInfo.Pointer;
@ -555,7 +552,7 @@ AcpiTbVerifyRsdp (
/* Error exit */ /* Error exit */
Cleanup: Cleanup:
AcpiOsUnmapMemory (TablePtr, sizeof (RSDP_DESCRIPTOR)); AcpiOsUnmapMemory (Rsdp, sizeof (RSDP_DESCRIPTOR));
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
@ -579,7 +576,7 @@ AcpiTbGetRsdtAddress (void)
ACPI_PHYSICAL_ADDRESS PhysicalAddress; ACPI_PHYSICAL_ADDRESS PhysicalAddress;
FUNCTION_ENTRY (); ACPI_FUNCTION_ENTRY ();
/* /*
@ -588,14 +585,8 @@ AcpiTbGetRsdtAddress (void)
*/ */
if (AcpiGbl_RSDP->Revision < 2) if (AcpiGbl_RSDP->Revision < 2)
{ {
#ifdef _IA64
/* 0.71 RSDP has 64bit Rsdt address field */
PhysicalAddress = ((RSDP_DESCRIPTOR_REV071 *)AcpiGbl_RSDP)->RsdtPhysicalAddress;
#else
PhysicalAddress = (ACPI_PHYSICAL_ADDRESS) AcpiGbl_RSDP->RsdtPhysicalAddress; PhysicalAddress = (ACPI_PHYSICAL_ADDRESS) AcpiGbl_RSDP->RsdtPhysicalAddress;
#endif
} }
else else
{ {
PhysicalAddress = (ACPI_PHYSICAL_ADDRESS) PhysicalAddress = (ACPI_PHYSICAL_ADDRESS)
@ -625,32 +616,31 @@ AcpiTbValidateRsdt (
UINT32 NoMatch; UINT32 NoMatch;
PROC_NAME ("TbValidateRsdt"); ACPI_FUNCTION_NAME ("TbValidateRsdt");
/* /*
* For RSDP revision 0 or 1, we use the RSDT. * For RSDP revision 0 or 1, we use the RSDT.
* For RSDP revision 2 (and above), we use the XSDT * For RSDP revision 2 and above, we use the XSDT
*/ */
if (AcpiGbl_RSDP->Revision < 2) if (AcpiGbl_RSDP->Revision < 2)
{ {
NoMatch = STRNCMP ((char *) TablePtr, RSDT_SIG, NoMatch = ACPI_STRNCMP ((char *) TablePtr, RSDT_SIG,
sizeof (RSDT_SIG) -1); sizeof (RSDT_SIG) -1);
} }
else else
{ {
NoMatch = STRNCMP ((char *) TablePtr, XSDT_SIG, NoMatch = ACPI_STRNCMP ((char *) TablePtr, XSDT_SIG,
sizeof (XSDT_SIG) -1); sizeof (XSDT_SIG) -1);
} }
if (NoMatch) if (NoMatch)
{ {
/* Invalid RSDT or XSDT signature */ /* Invalid RSDT or XSDT signature */
REPORT_ERROR (("Invalid signature where RSDP indicates RSDT/XSDT should be located\n")); ACPI_REPORT_ERROR (("Invalid signature where RSDP indicates RSDT/XSDT should be located\n"));
DUMP_BUFFER (AcpiGbl_RSDP, 20); ACPI_DUMP_BUFFER (AcpiGbl_RSDP, 20);
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ERROR, ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ERROR,
"RSDT/XSDT signature at %X is invalid\n", "RSDT/XSDT signature at %X is invalid\n",
@ -687,7 +677,7 @@ AcpiTbGetTablePointer (
ACPI_STATUS Status; ACPI_STATUS Status;
FUNCTION_ENTRY (); ACPI_FUNCTION_ENTRY ();
if ((Flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) if ((Flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING)
@ -695,12 +685,10 @@ AcpiTbGetTablePointer (
*Size = SIZE_IN_HEADER; *Size = SIZE_IN_HEADER;
Status = AcpiTbMapAcpiTable (PhysicalAddress, Size, TablePtr); Status = AcpiTbMapAcpiTable (PhysicalAddress, Size, TablePtr);
} }
else else
{ {
*Size = 0; *Size = 0;
*TablePtr = (ACPI_TABLE_HEADER *) (ACPI_TBLPTR) PhysicalAddress; *TablePtr = ACPI_PHYSADDR_TO_PTR (PhysicalAddress);
Status = AE_OK; Status = AE_OK;
} }
@ -729,7 +717,7 @@ AcpiTbGetTableRsdt (
ACPI_PHYSICAL_ADDRESS PhysicalAddress; ACPI_PHYSICAL_ADDRESS PhysicalAddress;
FUNCTION_TRACE ("TbGetTableRsdt"); ACPI_FUNCTION_TRACE ("TbGetTableRsdt");
/* /*
@ -737,13 +725,12 @@ AcpiTbGetTableRsdt (
*/ */
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"RSDP located at %p, RSDT physical=%8.8X%8.8X \n", "RSDP located at %p, RSDT physical=%8.8X%8.8X \n",
AcpiGbl_RSDP, HIDWORD(AcpiGbl_RSDP->RsdtPhysicalAddress), AcpiGbl_RSDP,
LODWORD(AcpiGbl_RSDP->RsdtPhysicalAddress))); ACPI_HIDWORD (AcpiGbl_RSDP->RsdtPhysicalAddress),
ACPI_LODWORD (AcpiGbl_RSDP->RsdtPhysicalAddress)));
PhysicalAddress = AcpiTbGetRsdtAddress (); PhysicalAddress = AcpiTbGetRsdtAddress ();
/* Get the RSDT/XSDT */ /* Get the RSDT/XSDT */
Status = AcpiTbGetTable (PhysicalAddress, NULL, &TableInfo); Status = AcpiTbGetTable (PhysicalAddress, NULL, &TableInfo);
@ -754,7 +741,6 @@ AcpiTbGetTableRsdt (
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* Check the RSDT or XSDT signature */ /* Check the RSDT or XSDT signature */
Status = AcpiTbValidateRsdt (TableInfo.Pointer); Status = AcpiTbValidateRsdt (TableInfo.Pointer);
@ -763,14 +749,12 @@ AcpiTbGetTableRsdt (
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* /*
* Valid RSDT signature, verify the checksum. If it fails, just * Valid RSDT signature, verify the checksum. If it fails, just
* print a warning and ignore it. * print a warning and ignore it.
*/ */
Status = AcpiTbVerifyTableChecksum (TableInfo.Pointer); Status = AcpiTbVerifyTableChecksum (TableInfo.Pointer);
/* Convert and/or copy to an XSDT structure */ /* Convert and/or copy to an XSDT structure */
Status = AcpiTbConvertToXsdt (&TableInfo, NumberOfTables); Status = AcpiTbConvertToXsdt (&TableInfo, NumberOfTables);
@ -790,7 +774,6 @@ AcpiTbGetTableRsdt (
AcpiGbl_XSDT = (XSDT_DESCRIPTOR *) TableInfo.Pointer; AcpiGbl_XSDT = (XSDT_DESCRIPTOR *) TableInfo.Pointer;
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "XSDT located at %p\n", AcpiGbl_XSDT)); ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "XSDT located at %p\n", AcpiGbl_XSDT));
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
@ -823,7 +806,7 @@ AcpiTbGetTableFacs (
ACPI_STATUS Status = AE_OK; ACPI_STATUS Status = AE_OK;
FUNCTION_TRACE ("TbGetTableFacs"); ACPI_FUNCTION_TRACE ("TbGetTableFacs");
/* Must have a valid FADT pointer */ /* Must have a valid FADT pointer */
@ -846,13 +829,12 @@ AcpiTbGetTableFacs (
return_ACPI_STATUS (AE_NO_MEMORY); return_ACPI_STATUS (AE_NO_MEMORY);
} }
MEMCPY (TablePtr, BufferPtr, Size); ACPI_MEMCPY (TablePtr, BufferPtr, Size);
/* Save allocation type */ /* Save allocation type */
Allocation = ACPI_MEM_ALLOCATED; Allocation = ACPI_MEM_ALLOCATED;
} }
else else
{ {
/* Just map the physical memory to our address space */ /* Just map the physical memory to our address space */
@ -869,7 +851,6 @@ AcpiTbGetTableFacs (
Allocation = ACPI_MEM_MAPPED; Allocation = ACPI_MEM_MAPPED;
} }
/* Return values */ /* Return values */
TableInfo->Pointer = TablePtr; TableInfo->Pointer = TablePtr;