mirrors/acpica
1
0
Fork 0
mirror of https://github.com/acpica/acpica/ synced 2025-01-26 19:32:05 +03:00
Code Issues Packages Projects Releases Wiki Activity
cedd5d194a
acpica/tests/aapits/atinit.c
Robert Moore 5cf391810f Fix some typos in comments. No functional changes. 
Some small fixes within commments. Colin Ian King.
2012-09-25 12:28:13 -07:00

4320 lines
108 KiB
C
Raw Blame History

/******************************************************************************
*
* Module Name: atinit - ACPICA Subsystem Initialization, Shutdown, and Status
* API tests
*
*****************************************************************************/
#include "atcommon.h"
#include "atinit.h"
#include "atosxfctrl.h"
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("atinit")
/*
* Init/Term check flags
*/
#define CHECK_INIT_TERM 0x01
#define CHECK_INIT_COND 0x02
#define CHECK_TERM_ACT 0x04
#define CHECK_FREE_COND 0x08
/*
FILE *AcpiGbl_DebugFile = NULL;
*/
static UINT32 IhFunctionIniCounter = 0;
static UINT32 IhFunctionOthersCounter = 0;
static UINT32 IhUnexpectedTypeCounter = 0;
static UINT32 AlternativeHandlerCounter = 0;
static UINT32 EstimatedINVC = 0;
static UINT32 EstimatedINVM = 0;
static ACPI_STATUS AtAcpiInitHandlerSpecRet = AE_OK;
static UINT8 *AtAcpiInitHandlerSpecName = NULL;
/*
* Expected digits of AML code init0032 processing
*/
#define _SB_DEV_ACTIVE 1
#define TOTAL_DEVS (9 + _SB_DEV_ACTIVE)
#define _INI_TOTAL 7
#define _STA_TOTAL 7
#define TOTAL_MASK 0x0FCF
#define _STA_NEGATIV_CALLS 2 /* DEV4 + _INI, DEV8 */
#define _STA_NEGATIV_MASK 0x2020 /* DEV4, DEV8 */
/*
* Managing AML code update
*/
static struct aml_control
{
UINT8 Flag;
UINT32 Index;
UINT8 Value;
} AmlControl;
void
AtSetAmlControl(
UINT32 Index,
UINT8 Value)
{
AmlControl.Flag = 1;
AmlControl.Index = Index;
AmlControl.Value = Value;
}
ACPI_STATUS
AtAcpiInitHandler(
ACPI_HANDLE Object,
UINT32 Function)
{
ACPI_STATUS Status = AE_OK;
UINT8 ShortName[5];
UINT8 ParentName[5];
ACPI_BUFFER OutName;
ACPI_OBJECT_TYPE OutType;
ACPI_HANDLE Parent;
OutName.Length = 5;
OutName.Pointer = ShortName;
if (ACPI_FAILURE(AcpiGetName (Object, ACPI_SINGLE_NAME, &OutName)))
{
strcpy((char *)ShortName, "NONE");
}
if (ACPI_FAILURE(AcpiGetType (Object, &OutType)))
{
OutType = 0xff;
}
if (ACPI_FAILURE(AcpiGetParent (Object, &Parent)))
{
strcpy((char *)ParentName, "NONE");
}
else
{
OutName.Length = 5;
OutName.Pointer = ParentName;
if (ACPI_FAILURE(AcpiGetName (Parent, ACPI_SINGLE_NAME, &OutName)))
{
strcpy((char *)ParentName, "NONE");
}
}
printf ("\nAtAcpiInitHandler: Object %p('%s.%s', Type 0x%.2x),"
" Function %d\n",
Object, ParentName, ShortName, OutType, Function);
if (OutType != ACPI_TYPE_DEVICE &&
OutType != ACPI_TYPE_PROCESSOR &&
OutType != ACPI_TYPE_THERMAL)
{
++IhUnexpectedTypeCounter;
}
if (Function == ACPI_INIT_DEVICE_INI)
{
++IhFunctionIniCounter;
}
else
{
++IhFunctionOthersCounter;
}
if (strcmp((char *)ShortName, "DEV0") == 0)
{
/* Without the _STA or _INI methods */
EstimatedINVC += 0;
EstimatedINVM |= 0;
}
if (strcmp((char *)ShortName, "DEV1") == 0)
{
/* With the _INI method only (default _STA) */
EstimatedINVC += 1;
EstimatedINVM |= 0x01;
}
if (strcmp((char *)ShortName, "DEV2") == 0)
{
/* With the _STA method only */
EstimatedINVC += 1;
EstimatedINVM |= 0x02;
}
if (strcmp((char *)ShortName, "DEV3") == 0)
{
/* With the both _INI and _STA methods */
EstimatedINVC += 2;
EstimatedINVM |= 0x0C;
}
if (strcmp((char *)ShortName, "DEV4") == 0)
{
/* With the both _INI and _STA methods but the last indicates
* that the device is not configured
*/
EstimatedINVC += 1;
EstimatedINVM |= 0x20;
}
if (strcmp((char *)ShortName, "DEV5") == 0)
{
/* With the both _INI and _STA methods */
EstimatedINVC += 2;
EstimatedINVM |= 0xC0;
}
if (strcmp((char *)ShortName, "DEV6") == 0)
{
/* With the both _INI and _STA methods */
EstimatedINVC += 2;
EstimatedINVM |= 0x300;
}
if (strcmp((char *)ShortName, "DEV7") == 0)
{
/* With the both _INI and _STA methods */
EstimatedINVC += 2;
EstimatedINVM |= 0xC00;
}
if (strcmp((char *)ShortName, "DEV8") == 0)
{
/* With the both _INI and _STA methods but the last indicates
* that the device is not: present, enabled
*/
EstimatedINVC += 1;
EstimatedINVM |= 0x2000;
}
if (strcmp((char *)ShortName, "DEV9") == 0)
{
/* With the both _INI and _STA methods, children
* of not present but functioning Device
*/
EstimatedINVC += 2;
EstimatedINVM |= 0xC000;
}
if (strcmp((char *)ShortName, "DEVA") == 0)
{
/* With the both _INI and _STA methods but the last indicates
* that the device is not: present, enabled, functioning
*/
EstimatedINVC += 1;
EstimatedINVM |= 0x20000;
}
if (strcmp((char *)ShortName, "DEVB") == 0)
{
/* With the both _INI and _STA methods */
EstimatedINVC += 2;
EstimatedINVM |= 0xC0000;
}
if (AtAcpiInitHandlerSpecRet != AE_OK)
{
if (AtAcpiInitHandlerSpecName)
{
if (strcmp((char *)ShortName,
(char *)AtAcpiInitHandlerSpecName) == 0 ||
strcmp((char *)ParentName,
(char *)AtAcpiInitHandlerSpecName) == 0)
{
Status = AtAcpiInitHandlerSpecRet;
AtAcpiInitHandlerSpecRet = AE_OK;
}
}
else
{
Status = AtAcpiInitHandlerSpecRet;
AtAcpiInitHandlerSpecRet = AE_OK;
}
}
return (Status);
}
ACPI_STATUS
AlternativeAcpiInitHandler(
ACPI_HANDLE Object,
UINT32 Function)
{
printf ("\nAlternativeAcpiInitHandler: Object %p, Function %d\n",
Object, Function);
++AlternativeHandlerCounter;
return (AE_OK);
}
ACPI_STATUS
AtInitTest0030AcpiInitHandler(
ACPI_HANDLE Object,
UINT32 Function)
{
printf ("\nAtInitTest0030AcpiInitHandler: Object %p, Function %d\n",
Object, Function);
return (AE_ERROR);
}
/*
* AcpiSubsystemStatus testing auxiliary macro
*/
#define CHECK_SUBSYSTEM_STATUS(Benchmark) \
Status = AcpiSubsystemStatus(); \
if (Status != Benchmark) \
{ \
AapiErrors++; \
printf ("API error: AcpiSubsystemStatus" \
" returned %s, expected %s\n", \
AcpiFormatException(Status), \
AcpiFormatException(Benchmark)); \
return (AE_ERROR); \
}
/*
* ACPI_STATUS
* AtSubsystemInit(
* UINT32 StagesScale, - scale of initialization steps
* UINT32 EnFlags, - AcpiEnableSubsystem flags
* UINT32 OiFlags) - AcpiInitializeObjects flags
* UINT32 StatusFlag) - flag of call to AcpiSubsystemStatus
*
* Performs the ACPICA Core Subsystem intitialization functions
* according to the specified stages scale while the actions are
* being successfully completed.
*/
ACPI_STATUS
AtSubsystemInit(
UINT32 StagesScale,
UINT32 EnFlags,
UINT32 OiFlags,
char *AMLcodeFileName)
{
return (AtInitCommonTest(StagesScale, 0, 0,
EnFlags, OiFlags, AMLcodeFileName));
}
void
AtPrintInitStagesScale(
UINT32 StagesScale)
{
printf ("Stages Init Core:");
if (StagesScale & AAPITS_INITIALIZE_SS)
{
printf (" SubSystem,");
}
if (StagesScale & AAPITS_INSTALL_IH)
{
printf (" InstIH,");
}
if (StagesScale & AAPITS_INITABLES)
{
printf (" InitTables,");
}
if (StagesScale & AAPITS_REALLOCROOTTABLE)
{
printf (" ReallocRootTable,");
}
if (StagesScale & AAPITS_LOADTABLES)
{
printf (" LoadTables,");
}
if (StagesScale & AAPITS_ENABLE_SS)
{
printf (" EnableSS,");
}
if (StagesScale & AAPITS_INITIALIZE_OBJS)
{
printf (" InitOBJS,");
}
if (StagesScale & AAPITS_INSTALL_HS)
{
printf (" InstAdrSH,");
}
if (!StagesScale)
{
printf (" NONE,");
}
printf ("\n");
}
/*
* ACPI_STATUS
* AtInitCommonTest(
* UINT32 StagesScale, - scale of initialization steps
* UINT32 ErrStagesScale,- relevant scale of errors emulation
* UINT32 ErrExpScale, - scale of interfaces expected to fail
* UINT32 EnFlags, - AcpiEnableSubsystem flags
* UINT32 OiFlags, - AcpiInitializeObjects flags
* char *AMLcodeFileName)
*
* Performs the ACPICA Core Subsystem intitialization functions
* according to the specified stages scale while the actions are
* being successfully completed.
*/
ACPI_STATUS
AtInitCommonTest(
UINT32 StagesScale,
UINT32 ErrStagesScale,
UINT32 ErrExpScale,
UINT32 EnFlags,
UINT32 OiFlags,
char *AMLcodeFileName)
{
ACPI_STATUS Status;
ACPI_TABLE_HEADER UserTableStructure, *UserTable = &UserTableStructure;
AtPrintInitStagesScale(StagesScale);
if ((StagesScale & ErrStagesScale) != ErrStagesScale)
{
TestErrors++;
printf ("AtInitCommonTest test error 1: StagesScale & ErrStagesScale (0x%x)"
" != ErrStagesScale (0x%x)\n", StagesScale & ErrStagesScale, ErrStagesScale);
return (AE_ERROR);
}
if ((StagesScale & ErrExpScale) != ErrExpScale)
{
TestErrors++;
printf ("AtInitCommonTest test error 2: StagesScale & ErrExpScale (0x%x)"
" != ErrStagesScale (0x%x)\n", StagesScale & ErrExpScale, ErrExpScale);
return (AE_ERROR);
}
if (ErrStagesScale & ErrExpScale)
{
TestErrors++;
printf ("AtInitCommonTest test error 3: ErrStagesScale"
" & ErrExpScale (0x%x) != 0\n", ErrStagesScale & ErrExpScale);
return (AE_ERROR);
}
if ((StagesScale & AAPITS_INSTALL_IH) &&
(ErrStagesScale & AAPITS_INITIALIZE_OBJS))
{
TestErrors++;
printf ("AtInitCommonTest test error 4: AAPITS_INSTALL_IH and"
" ErrStagesScale & AAPITS_INITIALIZE_OBJS simulteneously\n");
return (AE_ERROR);
}
if (StagesScale & AAPITS_INITIALIZE_SS)
{
if (ErrStagesScale & AAPITS_INITIALIZE_SS)
{
Status = OsxfCtrlSet(OSXF_NUM(AcpiOsInitialize),
1, AtActD_OneTime, AtActRet_ERROR);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("AtInitCommonTest test error 5: %s\n",
AcpiFormatException(Status));
return (Status);
}
}
/* Clean Registers Emulation */
OsxfCtrlRegService(0);
Status = AcpiInitializeSubsystem();
if (ACPI_FAILURE(Status))
{
if (ErrExpScale & AAPITS_INITIALIZE_SS)
{
}
else if (!(ErrStagesScale & AAPITS_INITIALIZE_SS))
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiInitializeSubsystem() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (Status != AE_ERROR)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiInitializeSubsystem()"
" returned %s, expected AE_ERROR emulation\n",
AcpiFormatException(Status));
return (Status);
}
}
else if (ErrExpScale & AAPITS_INITIALIZE_SS)
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiInitializeSubsystem()"
" succeeded, expected to fail\n");
return (AE_ERROR);
}
else if (ErrStagesScale & AAPITS_INITIALIZE_SS)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiInitializeSubsystem()"
" succeeded, expected AE_ERROR emulation\n");
return (AE_ERROR);
}
/*
* Mark the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
return (Status);
}
}
if (StagesScale & AAPITS_INSTALL_IH)
{
Status = AcpiInstallInitializationHandler(AtAcpiInitHandler, 0);
if (ACPI_FAILURE(Status))
{
printf ("AtInitCommonTest: AcpiInstallInitializationHandler() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
}
if (StagesScale & AAPITS_INITABLES)
{
memset(&UserTableStructure, 0, sizeof (ACPI_TABLE_HEADER));
if (AMLcodeFileName)
{
Status = AtReadTableFromFile (AMLcodeFileName, &UserTable);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("AtInitCommonTest: AtReadTableFromFile() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
if (AmlControl.Flag)
{
AmlControl.Flag = 0;
if (!(AmlControl.Index < UserTable->Length)) {
TestErrors++;
printf ("AtInitCommonTest: AmlControl.Index (%d) >="
" UserTable->Length (%d)\n",
AmlControl.Index, UserTable->Length);
return (AE_ERROR);
}
((UINT8 *)UserTable)[AmlControl.Index] = AmlControl.Value;
printf ("AtInitCommonTest: AmlCode Index %d updated into %c\n",
AmlControl.Index, (UINT32)AmlControl.Value);
}
}
AtBuildLocalTables(UserTable, NullBldTask);
if (ErrStagesScale & AAPITS_INITABLES)
{
Status = OsxfCtrlSet(OSXF_NUM(AcpiOsAllocate),
1 , AtActD_OneTime, AtActRet_NULL);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("AtInitCommonTest test error 6: %s\n",
AcpiFormatException(Status));
return (Status);
}
Status = AcpiInitializeTables(NULL, 20, FALSE);
}
else
{
Status = AtInitializeTables (FALSE);
}
if (ACPI_FAILURE(Status))
{
if (ErrExpScale & AAPITS_INITABLES)
{
;
}
else if (!(ErrStagesScale & AAPITS_INITABLES))
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiInitializeTables() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (Status != AE_NO_MEMORY)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiInitializeTables()"
" returned %s, expected AE_NO_MEMORY emulation\n",
AcpiFormatException(Status));
return (Status);
}
}
else if (ErrExpScale & AAPITS_INITABLES)
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiInitializeTables()"
" succeeded, expected to fail\n");
return (AE_ERROR);
}
else if (ErrStagesScale & AAPITS_INITABLES)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiInitializeTables()"
" succeeded, expected AE_NO_MEMORY emulation\n");
return (AE_ERROR);
}
}
if (StagesScale & AAPITS_REALLOCROOTTABLE)
{
Status = AcpiReallocateRootTable();
if (ACPI_FAILURE(Status))
{
if (ErrExpScale & AAPITS_REALLOCROOTTABLE)
{
;
}
else if (!(ErrStagesScale & AAPITS_REALLOCROOTTABLE))
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiReallocateRootTable() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (Status != AE_NO_MEMORY)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiReallocateRootTable()"
" returned %s, expected AE_NO_MEMORY emulation\n",
AcpiFormatException(Status));
return (Status);
}
}
else if (ErrExpScale & AAPITS_REALLOCROOTTABLE)
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiReallocateRootTable()"
" succeeded, expected to fail\n");
return (AE_ERROR);
}
else if (ErrStagesScale & AAPITS_REALLOCROOTTABLE)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiReallocateRootTable()"
" succeeded, expected AE_NO_MEMORY emulation\n");
return (AE_ERROR);
}
}
if (StagesScale & AAPITS_LOADTABLES)
{
if (ErrStagesScale & AAPITS_LOADTABLES)
{
/* 2.3.2.1 ACPI Table Validation:
A warning is issued for tables that do not pass one or more of these tests
...
4. The table checksum must be valid (with the exception of the FACS,
which has no checksum).
LocalRSDT = MemRSDT;
LocalRSDT->Checksum = (UINT8)(~LocalRSDT->Checksum);
*/
Status = OsxfCtrlSet(OSXF_NUM(AcpiOsAllocate),
2, AtActD_OneTime, AtActRet_NULL);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("AtInitCommonTest test error 6: %s\n",
AcpiFormatException(Status));
return (Status);
}
}
Status = AcpiLoadTables();
if (ACPI_FAILURE(Status))
{
if (ErrExpScale & AAPITS_LOADTABLES)
{
;
}
else if (!(ErrStagesScale & AAPITS_LOADTABLES))
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiLoadTables() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (Status != AE_NO_MEMORY)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiLoadTables()"
" returned %s, expected AE_NO_MEMORY emulation\n",
AcpiFormatException(Status));
return (Status);
}
}
else if (ErrExpScale & AAPITS_LOADTABLES)
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiLoadTables()"
" succeeded, expected to fail\n");
return (AE_ERROR);
}
else if (ErrStagesScale & AAPITS_LOADTABLES)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiLoadTables()"
" succeeded, expected AE_NO_MEMORY emulation\n");
return (AE_ERROR);
}
Status = OsxfCtrlAcpiRegsInit(
&AcpiGbl_FADT, AcpiGbl_XPm1aEnable, AcpiGbl_XPm1bEnable);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("AtInitCommonTest: OsxfCtrlAcpiRegsInit failed\n");
return (Status);
}
}
if (StagesScale & AAPITS_INSTALL_HS)
{
Status = AeInstallHandlers();
if (ACPI_FAILURE (Status))
{
AapiErrors++;
printf ("AtInitCommonTest: AtInstallHandlers() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
}
if (StagesScale & AAPITS_ENABLE_SS)
{
if (ErrStagesScale & AAPITS_ENABLE_SS)
{
Status = OsxfCtrlSet(OSXF_NUM(AcpiOsAllocate),
2, AtActD_OneTime, AtActRet_NULL);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("AtInitCommonTest test error 7: %s\n",
AcpiFormatException(Status));
return (Status);
}
}
Status = AcpiEnableSubsystem(EnFlags);
if (ACPI_FAILURE(Status))
{
if (ErrExpScale & AAPITS_ENABLE_SS)
{
}
else if (!(ErrStagesScale & AAPITS_ENABLE_SS))
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiEnableSubsystem() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (Status != AE_NO_MEMORY)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiEnableSubsystem()"
" returned %s, expected AE_NO_MEMORY emulation\n",
AcpiFormatException(Status));
return (Status);
}
}
else if (ErrExpScale & AAPITS_ENABLE_SS)
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiEnableSubsystem()"
" succeeded, expected to fail\n");
return (AE_ERROR);
}
else if (ErrStagesScale & AAPITS_ENABLE_SS)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiEnableSubsystem()"
" succeeded, expected AE_NO_MEMORY emulation\n");
return (AE_ERROR);
}
}
if (StagesScale & AAPITS_INITIALIZE_OBJS)
{
if (ErrStagesScale & AAPITS_INITIALIZE_OBJS)
{
/* This doesn't work
Status = OsxfCtrlSet(OSXF_NUM(AcpiOsAllocate),
1, AtActD_OneTime, AtActRet_NULL);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("AtInitCommonTest test error 8: %s\n",
AcpiFormatException(Status));
return (Status);
}
*/
Status = AcpiInstallInitializationHandler(AtInitTest0030AcpiInitHandler, 0);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("AtInitCommonTest: AcpiInstallInitializationHandler() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
}
Status = AcpiInitializeObjects(OiFlags);
if (ACPI_FAILURE(Status))
{
if (ErrExpScale & AAPITS_INITIALIZE_OBJS)
{
}
else if (!(ErrStagesScale & AAPITS_INITIALIZE_OBJS))
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiInitializeObjects() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (Status != AE_ERROR)
{
TestErrors++;
printf ("AtInitCommonTest: AcpiInitializeObjects()"
" returned %s, expected AE_ERROR emulation\n",
AcpiFormatException(Status));
return (Status);
}
}
else if (ErrExpScale & AAPITS_INITIALIZE_OBJS)
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiInitializeObjects()"
" succeeded, expected to fail\n");
return (AE_ERROR);
}
else if (ErrStagesScale & AAPITS_INITIALIZE_OBJS)
{
AapiErrors++;
printf ("AtInitCommonTest: AcpiInitializeObjects()"
" succeeded, expected AE_ERROR emulation\n");
return (AE_ERROR);
}
}
return (AE_OK);
}
#ifdef xxxxACPI_DEBUGGER
ACPI_EXTERN ACPI_TABLE_HEADER *AcpiGbl_DbTablePtr;
ACPI_EXTERN char *AcpiGbl_DbBuffer;
#endif
/*
* Check Subsystem shutdown
*/
ACPI_STATUS
AtTerminateCheck(
ACPI_STATUS SuccessStatus,
UINT32 CtrlCheck)
{
ACPI_STATUS Status;
#ifdef xxxxACPI_DEBUGGER
/* Shut down the debugger */
if (AcpiGbl_DbTablePtr)
{
AcpiGbl_DbTablePtr = NULL;
}
if (AcpiGbl_DbBuffer)
{
AcpiGbl_DbBuffer = NULL;
}
#endif
if (AT_SKIP_ALL_MALLOC_CHECK) {
CtrlCheck &= ~MALLOC_STAT;
}
if (AT_SKIP_MAPPED_CHECK) {
CtrlCheck &= ~MMAP_STAT;
}
Status = OsxfCtrlCheck(CtrlCheck, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
return (Status);
}
return (SuccessStatus);
}
/*
* Initiate and check Subsystem shutdown
*/
ACPI_STATUS
AtTerminateCtrlCheck(
ACPI_STATUS SuccessStatus,
UINT32 CtrlCheck)
{
ACPI_STATUS Status;
Status = AcpiTerminate();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API error: AcpiTerminate() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
return (AtTerminateCheck(SuccessStatus, CtrlCheck));
}
/*
* 6.1 Subsystem Initialization, Shutdown, and Status
*/
/*
* ACPI_STATUS
* AtInitTermCommonTest(
* AT_ACTD_FLAG ActFlag, - flag of one-time/permanent action mode
* UINT32 TFst, - number of the first call to OS IF for the action
* ACPI_OSXF OsxfNum, - number of the specified OS IF
* UINT32 ActCode, - code of the action
* UINT32 Check_Flags)- flags of the additional check of AcpiTerminate:
* 0 - without any check
* 1 - check before and after AcpiTerminate
* 2 - the second check without call to AcpiTerminate
* 3 - without any check and call to AcpiTerminate
*
* Performs actions which are common for AcpiInitializeSubsystem
* and AcpiTerminate routines test cases.
*
*/
ACPI_STATUS
AtInitTermCommonTest(
ACPI_OSXF OsxfNum,
AT_ACTD_FLAG ActFlag,
UINT32 ActCode,
UINT32 TFst,
UINT32 Check_Flags,
ACPI_STATUS Benchmark)
{
ACPI_STATUS Status;
ACPI_STATUS Init_Os_Status = AE_OK;
ACPI_STATUS Init_Sub_Status;
UINT32 i;
UINT32 Continue_Cond = 1;
UINT32 Check_Stat = ALL_STAT;
UINT32 TMax = 10000;
ACPI_OSXF OsxfNumAct;
printf ("AtInitTermCommonTest: ActFlag % d, TFst %d, TMax %d\n",
ActFlag, TFst, TMax);
if (TFst == 0)
{
TestErrors++;
printf ("Test error, TFst = 0\n");
return (AE_ERROR);
}
if (Check_Flags & CHECK_INIT_TERM)
{
/* Exclude check of AcpiInitializeSubsystem/AcpiTerminate agreement */
Check_Stat &= ~OSINIT_STAT;
}
for (i = TFst; (i < TMax) && Continue_Cond; i++)
{
printf ("AtInitTermCommonTest: i = %d\n", i);
Status = OsxfCtrlSet(OsxfNum, i, ActFlag, ActCode);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("Test error: %s\n",
AcpiFormatException(Status));
return (Status);
}
Init_Sub_Status = AcpiInitializeSubsystem();
if (!(OsxfNumAct = OsxfCtrlGetActOsxf(OsxfNum, 1)))
{
if (i == TFst)
{
TestSkipped++;
printf ("Test note: test action hasn't occur\n");
return (AE_ERROR);
}
TestPass++;
Continue_Cond = 0;
}
else
{
if ((ACPI_SUCCESS(Benchmark) && Init_Sub_Status != Benchmark) ||
(ACPI_FAILURE(Benchmark) && ACPI_SUCCESS(Init_Sub_Status)))
{
AapiErrors++;
printf ("API Error: AcpiInitializeSubsystem returned %s,\n"
" expected to return %s\n",
AcpiFormatException(Init_Sub_Status),
AcpiFormatException(Benchmark));
return (AE_ERROR);
}
else if (Init_Sub_Status != Benchmark)
{
printf ("Test note: AcpiInitializeSubsystem returned %s,\n"
" expected to return %s\n",
AcpiFormatException(Init_Sub_Status),
AcpiFormatException(Benchmark));
}
if (OsxfNumAct == OSXF_NUM(AcpiOsInitialize) &&
ActCode == AtActRet_ERROR)
{
Init_Os_Status = AE_ERROR;
}
}
if (AT_SKIP_OS_PRINTF_CHECK && ACPI_FAILURE(Init_Os_Status))
{
OsxfUpdateCallsMark();
}
Status = InitOsxfCtrlCheck(Init_Os_Status);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
return (Status);
}
if (Check_Flags & CHECK_INIT_COND)
{
Status = OsxfCtrlCheck(SYS_STAT, 0);
if (ACPI_FAILURE(Status))
{
TestErrors++;
return (Status);
}
}
if (Check_Flags & CHECK_TERM_ACT)
{
Status = AcpiTerminate();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiTerminate() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
#ifdef xxxxACPI_DEBUGGER
/* Shut down the debugger */
if (AcpiGbl_DbTablePtr)
{
AcpiGbl_DbTablePtr = NULL;
}
if (AcpiGbl_DbBuffer)
{
AcpiGbl_DbBuffer = NULL;
}
#endif
Init_Os_Status = AE_OK;
}
else
{
if (OsxfNumAct == OSXF_NUM(AcpiOsInitialize))
{
Init_Os_Status = AE_OK;
}
else
{
Init_Os_Status = AE_ERROR;
}
}
if (Check_Flags & CHECK_FREE_COND)
{
Status = OsxfCtrlCheck(Check_Stat, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
return (Status);
}
}
}
if (i >= TMax)
{
TestErrors++;
printf ("Test error: there are test cases remained\n");
return (AE_ERROR);
}
return (AE_OK);
}
/*
* ACPI_STATUS
* AtExceptionCommonTest(
* AT_ACTD_FLAG ActFlag, - flag of one-time/permanent action mode
* UINT32 TFst, - number of the first call to OS IF for the action
* ACPI_OSXF OsxfNum, - number of the specified OS IF
* UINT32 ActCode) - code of the action
*
* Performs actions which are common for AcpiInitializeSubsystem
* and AcpiTerminate routines test cases.
*
*/
ACPI_STATUS
AtExceptionCommonTest(
UINT32 FlagIFVerified,
ACPI_OSXF OsxfNum,
AT_ACTD_FLAG ActFlag,
UINT32 ActCode,
UINT32 TFst,
ACPI_STATUS Benchmark)
{
ACPI_STATUS Status;
ACPI_OSXF OsxfNumAct;
UINT32 Continue_Cond = 1;
UINT32 StagesScale = AAPITS_INI_PRELOAD;
UINT32 TMax = 10000;
UINT32 i;
char *NameIF = "AcpiLoadTables";
printf ("AtExceptionCommonTest: ActFlag % d, TFst %d, TMax %d\n",
ActFlag, TFst, TMax);
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0032.aml")))
{
return (Status);
}
if (FlagIFVerified != AAPITS_LOADTABLES &&
FlagIFVerified != AAPITS_ENABLE_SS &&
FlagIFVerified != AAPITS_INITIALIZE_OBJS)
{
TestErrors++;
printf ("AtExceptionCommonTest: test error, incorrect"
" FlagIFVerified (0x%x)\n", FlagIFVerified);
return (AE_ERROR);
}
if (TFst == 0)
{
TestErrors++;
printf ("Test error, TFst = 0\n");
return (AE_ERROR);
}
if (FlagIFVerified == AAPITS_ENABLE_SS)
{
StagesScale |= AAPITS_LOADTABLES;
NameIF = "AcpiEnableSubsystem";
}
else if (FlagIFVerified == AAPITS_INITIALIZE_OBJS)
{
StagesScale |= (AAPITS_LOADTABLES | AAPITS_ENABLE_SS);
NameIF = "AcpiInitializeObjects";
}
for (i = TFst; (i < TMax) && Continue_Cond; i++)
{
printf ("AtExceptionCommonTest: i = %d\n", i);
Status = AtInitCommonTest(StagesScale,
0, 0,
AAPITS_EN_FLAGS, 0, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
Status = OsxfCtrlSet(OsxfNum, i, ActFlag, ActCode);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("Test error: %s\n",
AcpiFormatException(Status));
return (Status);
}
switch (FlagIFVerified)
{
case (AAPITS_LOADTABLES):
Status = AcpiLoadTables();
break;
case (AAPITS_ENABLE_SS):
Status = AcpiEnableSubsystem(AAPITS_EN_FLAGS);
break;
case (AAPITS_INITIALIZE_OBJS):
Status = AcpiInitializeObjects(AAPITS_OI_FLAGS);
break;
}
if (!(OsxfNumAct = OsxfCtrlGetActOsxf(OsxfNum, 1)))
{
if (i == TFst)
{
TestSkipped++;
printf ("Test note: test action hasn't occur\n");
return (AE_ERROR);
}
TestPass++;
Continue_Cond = 0;
}
else
{
if (Status != Benchmark)
{
AapiErrors++;
printf ("API Error: %s returned %s,\n"
" expected to return %s\n", NameIF,
AcpiFormatException(Status), AcpiFormatException(Benchmark));
return (AE_ERROR);
}
}
Status = AtTerminateCtrlCheck(AE_OK, ALL_STAT);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
if (i >= TMax)
{
TestErrors++;
printf ("Test error: there are test cases remained\n");
return (AE_ERROR);
}
return (AE_OK);
}
/*
* ASSERTION 0000:
*/
ACPI_STATUS
AtInitTest0000(void)
{
ACPI_STATUS Status;
Status = AcpiInitializeSubsystem();
if (Status != AE_OK)
{
AapiErrors++;
printf ("API Error: AcpiInitializeSubsystem returned %s,\n"
" expected to return (AE_OK)\n",
AcpiFormatException(Status));
}
Status = InitOsxfCtrlCheck(AE_OK);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
}
return (AE_OK);
}
/*
* ASSERTION 0001:
*/
ACPI_STATUS
AtInitTest0001(void)
{
return (AtInitTermCommonTest(OSXF_NUM(AcpiOsInitialize),
AtActD_OneTime, AtActRet_ERROR, 1, CHECK_INIT_TERM, AE_ERROR));
}
/*
* ASSERTION 0002:
*/
ACPI_STATUS
Init_NO_MEMORY_Test1(
UINT32 TFst1,
UINT32 TFst2,
UINT32 Check)
{
ACPI_STATUS Status;
/*
* AcpiOsAllocate returns NULL permanently since the specified call
*/
Status = AtInitTermCommonTest(OSXF_NUM(AcpiOsAllocate),
AtActD_Permanent, AtActRet_NULL, TFst1, Check,
AE_NO_MEMORY);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* AcpiOsAllocate returns NULL one time on the specified call
*/
return (AtInitTermCommonTest(OSXF_NUM(AcpiOsAllocate),
AtActD_OneTime, AtActRet_NULL, TFst2, Check,
AE_NO_MEMORY));
}
ACPI_STATUS
AtInitTest0002(void)
{
return (Init_NO_MEMORY_Test1(1, 1, CHECK_TERM_ACT));
}
/*
* ASSERTION 0003:
*/
ACPI_STATUS
Init_NO_MEMORY_Test2(
UINT32 TFst1,
UINT32 TFst2,
UINT32 Check)
{
ACPI_STATUS Status;
/*
* AcpiOsCreateLock returns AE_NO_MEMORY permanently since the specified call
*/
Status = AtInitTermCommonTest(OSXF_NUM(AcpiOsCreateLock),
AtActD_Permanent, AtActRet_NO_MEMORY, TFst1, Check,
AE_NO_MEMORY);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* AcpiOsCreateLock returns AE_NO_MEMORY one time on the specified call
*/
return (AtInitTermCommonTest(OSXF_NUM(AcpiOsCreateLock),
AtActD_OneTime, AtActRet_NO_MEMORY, TFst2, Check,
AE_NO_MEMORY));
}
ACPI_STATUS
AtInitTest0003(void)
{
return (Init_NO_MEMORY_Test2(1, 1, CHECK_TERM_ACT));
}
/*
* ASSERTION 0004:
*/
ACPI_STATUS
Init_NO_MEMORY_Test3(
UINT32 TFst1,
UINT32 TFst2,
UINT32 Check)
{
ACPI_STATUS Status;
/*
* AcpiOsCreateSemaphore returns AE_NO_MEMORY
* permanently since the specified call
*/
Status = AtInitTermCommonTest(OSXF_NUM(AcpiOsCreateSemaphore),
AtActD_Permanent, AtActRet_NO_MEMORY, TFst1, Check,
AE_NO_MEMORY);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* AcpiOsCreateSemaphore returns AE_NO_MEMORY
* one time on the specified call
*/
return (AtInitTermCommonTest(OSXF_NUM(AcpiOsCreateSemaphore),
AtActD_OneTime, AtActRet_NO_MEMORY, TFst2, Check,
AE_NO_MEMORY));
}
ACPI_STATUS
AtInitTest0004(void)
{
return (Init_NO_MEMORY_Test3(1, 1, CHECK_TERM_ACT));
}
/*
* ASSERTION 0005:
*/
ACPI_STATUS
AtInitTest0005(void)
{
ACPI_STATUS Status;
UINT32 TMax = 3;
UINT32 i;
for (i = 0; i < TMax; i++)
{
printf ("i == %d\n", i);
Status = AcpiInitializeSubsystem();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("AcpiInitializeSubsystem() failure, %s\n",
AcpiFormatException(Status));
break;
}
Status = OsxfCtrlCheck(SYS_STAT, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
break;
}
Status = AtTerminateCtrlCheck(AE_OK, ALL_STAT);
if (ACPI_FAILURE(Status))
{
break;
}
}
return (AE_OK);
}
/*
* ASSERTION 0006:
*/
ACPI_STATUS
AtInitTest0006(void)
{
ACPI_STATUS Status;
UINT32 TMax = 3;
UINT32 i;
for (i = 0; i < TMax; i++)
{
printf ("i == %d\n", i);
Status = AcpiTerminate();
if (ACPI_FAILURE(Status))
{
/* It is not an aapi error without previous
* successful call to AcpiInitializeSubsystem()
* AapiErrors++;
* break;
*/
printf ("AcpiTerminate() returned %s\n",
AcpiFormatException(Status));
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
break;
}
}
return (AE_OK);
}
/*
* ASSERTION 0007:
*/
ACPI_STATUS
AtInitTest0007(void)
{
ACPI_STATUS Status;
UINT32 TMax = 3, RMax = 3;
UINT32 i, j;
for (i = 0; i < RMax; i++)
{
Status = AcpiInitializeSubsystem();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("AcpiInitializeSubsystem() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
Status = OsxfCtrlCheck(SYS_STAT, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
return (Status);
}
Status = AtTerminateCtrlCheck(AE_OK, ALL_STAT);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* Mark the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
return (Status);
}
for (j = 0; j < TMax; j++)
{
printf ("j == %d\n", j);
/*
* Check the total number of AcpiOS* invocations
*/
Status = AtTerminateCtrlCheck(AE_OK, TOTAL_STAT);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
}
return (AE_OK);
}
/*
* ASSERTION 0008:
*/
ACPI_STATUS
AtInitTest0008(void)
{
return (AtInitTermCommonTest(OSXF_NUM(AcpiOsInitialize),
AtActD_OneTime, AtActRet_ERROR, 1, CHECK_TERM_ACT, AE_ERROR));
}
/*
* ASSERTION 0009:
*/
ACPI_STATUS
AtInitTest0009(void)
{
ACPI_STATUS Status;
UINT32 Test_Flags = MALLOC_STAT | LOCK_STAT | SEMAPH_STAT;
if (Test_Flags & MALLOC_STAT)
{
Status = Init_NO_MEMORY_Test1(1, 1,
CHECK_INIT_COND | CHECK_TERM_ACT | CHECK_FREE_COND);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
if (Test_Flags & LOCK_STAT)
{
Status = Init_NO_MEMORY_Test2(1, 1,
CHECK_INIT_COND | CHECK_TERM_ACT | CHECK_FREE_COND);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
if (Test_Flags & SEMAPH_STAT)
{
Status = Init_NO_MEMORY_Test3(1, 1,
CHECK_INIT_COND | CHECK_TERM_ACT | CHECK_FREE_COND);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AE_OK);
}
/*
* ASSERTION 0010:
*/
ACPI_STATUS
AtInitTest0010(void)
{
UINT32 Check_Flags = CHECK_INIT_TERM |
CHECK_TERM_ACT | CHECK_FREE_COND;
if (AT_SKIP_FREE_STAT_CHECK)
{
Check_Flags &= ~CHECK_FREE_COND;
}
return (AtInitTermCommonTest(OSXF_NUM(AcpiOsTotal),
AtActD_OneTime, AtActRet_ERROR, 1,
Check_Flags, AE_ERROR));
}
/*
* ASSERTION 0011:
*/
ACPI_STATUS
AtInitTest0011(void)
{
ACPI_STATUS Status;
UINT32 Test_Flags = MALLOC_STAT | LOCK_STAT | SEMAPH_STAT;
if (Test_Flags & MALLOC_STAT)
{
Status = Init_NO_MEMORY_Test1(1, 1, CHECK_INIT_TERM | CHECK_FREE_COND);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
if (Test_Flags & LOCK_STAT)
{
Status = Init_NO_MEMORY_Test2(1, 1, CHECK_INIT_TERM | CHECK_FREE_COND);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
if (Test_Flags & SEMAPH_STAT)
{
Status = Init_NO_MEMORY_Test3(1, 1, CHECK_INIT_TERM | CHECK_FREE_COND);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AE_OK);
}
/*
* ASSERTION 0012:
*/
ACPI_STATUS
AtInitTest0012(void)
{
ACPI_STATUS Status;
int RMax = 100;
int i;
for (i = 0; i < RMax; i++)
{
Status = AcpiInitializeSubsystem();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiInitializeSubsystem() failure, %s,"
" step %d\n", AcpiFormatException(Status), i);
return (Status);
}
Status = OsxfCtrlCheck(SYS_STAT, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: no any resources allocated, step %d\n", i);
return (Status);
}
Status = AtTerminateCtrlCheck(AE_OK, ALL_STAT);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AE_OK);
}
/*
* ASSERTION 0013:
*/
ACPI_STATUS
AtInitTest0013(void)
{
ACPI_STATUS Status;
int RMax = 3;
int i;
printf ("Test 0013:\n");
Status = AcpiInitializeSubsystem();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiInitializeSubsystem() failure, %s,"
" step %d\n", AcpiFormatException(Status), 0);
return (Status);
}
Status = OsxfCtrlCheck(SYS_STAT, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: no any resources allocated, step %d\n", 1);
return (Status);
}
/*
* Mark the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AcpiInitializeSubsystem();
if (ACPI_SUCCESS(Status))
{
AapiErrors++;
printf ("API Error: repeated AcpiInitializeSubsystem() returned %s,"
" step %d\n", AcpiFormatException(Status), i + 2);
return (Status);
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
break;
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0014:
*/
ACPI_STATUS
AtInitTest0014(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
0, 0,
AAPITS_EN_FLAGS, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0015:
*/
ACPI_STATUS
AtInitTest0015(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
0, 0,
AAPITS_EN_FLAGS, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0016:
*/
ACPI_STATUS
AtInitTest0016(void)
{
ACPI_STATUS Status;
int RMax = 3;
int i;
/*
* Mark the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error 1: AcpiOS* calls withoout Subsystem init., %s\n",
AcpiFormatException(Status));
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AcpiEnableSubsystem(AAPITS_EN_FLAGS);
if (Status != AE_ERROR)
{
AapiErrors++;
printf ("API Error 2: AcpiEnableSubsystem() returned %s,"
" expected AE_ERROR\n",
AcpiFormatException(Status));
return (AE_ERROR);
}
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error 2: AcpiOS* calls during AcpiEnableSubsystem, %s\n",
AcpiFormatException(Status));
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0017:
*/
ACPI_STATUS
AtInitTest0017(void)
{
ACPI_STATUS Status;
int RMax = 3;
int i;
Status = AtInitCommonTest(AAPITS_INITIALIZE_SS,
AAPITS_INITIALIZE_SS, 0,
0, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AcpiEnableSubsystem(AAPITS_EN_FLAGS);
if (Status != AE_ERROR)
{
AapiErrors++;
printf ("API Error: AcpiEnableSubsystem() returned %s,"
" expected AE_ERROR\n",
AcpiFormatException(Status));
return (AE_ERROR);
}
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiOS* calls during AcpiEnableSubsystem, %s\n",
AcpiFormatException(Status));
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0018:
*/
ACPI_STATUS
AtInitTest0018(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INITIALIZE_SS | AAPITS_ENABLE_SS,
0, AAPITS_ENABLE_SS,
AAPITS_EN_FLAGS, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0019:
*/
ACPI_STATUS
AtInitTest0019(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
AAPITS_LOADTABLES, AAPITS_ENABLE_SS,
AAPITS_EN_FLAGS, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0020:
*/
ACPI_STATUS
AtInitTest0020(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
AAPITS_ENABLE_SS, 0,
AAPITS_EN_FLAGS, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0021:
*/
ACPI_STATUS
AtInitTest0021(void)
{
ACPI_STATUS Status;
int RMax = 3;
int i;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
0, 0,
AAPITS_EN_FLAGS, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AtInitCommonTest(AAPITS_ENABLE_SS,
0, AAPITS_ENABLE_SS,
AAPITS_EN_FLAGS, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0121:
* > 3. acpi_enable_subsystem(~(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE));
* > 4. acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
*/
ACPI_STATUS
AtInitTest0121(void)
{
ACPI_STATUS Status;
int RMax = 1;
int i;
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0121.aml")))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
0, 0,
~(UINT32)(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE), 0, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AtInitCommonTest(AAPITS_ENABLE_SS,
0, AAPITS_ENABLE_SS,
ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0022:
*/
ACPI_STATUS
AtInitTest0022(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0023:
*/
ACPI_STATUS
AtInitTest0023(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0024:
*/
ACPI_STATUS
AtInitTest0024(void)
{
ACPI_STATUS Status;
int RMax = 3;
int i;
/*
* Mark the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error 1: AcpiOS* calls withoout Subsystem init., %s\n",
AcpiFormatException(Status));
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AcpiInitializeObjects(AAPITS_OI_FLAGS);
if (Status != AE_ERROR)
{
AapiErrors++;
printf ("API Error 2: AcpiInitializeObjects() returned %s,"
" expected AE_ERROR\n",
AcpiFormatException(Status));
return (Status);
}
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error 2: AcpiOS* calls during AcpiInitializeObjects, %s\n",
AcpiFormatException(Status));
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0025:
*/
ACPI_STATUS
AtInitTest0025(void)
{
ACPI_STATUS Status;
int RMax = 3;
int i;
Status = AtInitCommonTest(AAPITS_INITIALIZE_SS,
AAPITS_INITIALIZE_SS, 0,
0, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AcpiInitializeObjects(AAPITS_OI_FLAGS);
if (Status != AE_ERROR)
{
AapiErrors++;
printf ("API Error: AcpiInitializeObjects() returned %s,"
" expected AE_ERROR\n",
AcpiFormatException(Status));
return (Status);
}
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiOS* calls during AcpiInitializeObjects, %s\n",
AcpiFormatException(Status));
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0026:
*/
ACPI_STATUS
AtInitTest0026(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INITIALIZE_SS | AAPITS_INITIALIZE_OBJS,
0, AAPITS_INITIALIZE_OBJS,
0, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0027:
*/
ACPI_STATUS
AtInitTest0027(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_INITIALIZE_OBJS,
AAPITS_LOADTABLES, AAPITS_INITIALIZE_OBJS,
0, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0028:
*/
ACPI_STATUS
AtInitTest0028(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_INITIALIZE_OBJS,
0, AAPITS_INITIALIZE_OBJS,
0, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0029:
*/
ACPI_STATUS
AtInitTest0029(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
AAPITS_ENABLE_SS, AAPITS_INITIALIZE_OBJS,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0030:
*/
ACPI_STATUS
AtInitTest0030(void)
{
ACPI_STATUS Status;
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0030.aml")))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
AAPITS_INITIALIZE_OBJS, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0031:
*/
ACPI_STATUS
AtInitTest0031(void)
{
ACPI_STATUS Status;
int RMax = 3;
int i;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AtInitCommonTest(AAPITS_INITIALIZE_OBJS,
0, AAPITS_INITIALIZE_OBJS,
0, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0032:
*/
ACPI_STATUS
AtInitTest0032(void)
{
ACPI_STATUS Status;
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0032.aml")))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
0, 0,
AAPITS_EN_FLAGS, 0, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVC", 0)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVM", 0)))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INITIALIZE_OBJS,
0, 0,
0, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVC",
_INI_TOTAL + _STA_TOTAL - 2)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVM",
TOTAL_MASK | _STA_NEGATIV_MASK)))
{
return (Status);
}
return (AE_OK);
}
/*
* Check InitializationHandler calls
*/
ACPI_STATUS
AtInitializationHandlerCallsCheck(
UINT32 Function_INI)
{
if (Function_INI)
{
if (IhFunctionIniCounter != Function_INI)
{
AapiErrors++;
printf ("API Error: %d INI Function calls"
" of InitializationHandler, expected %d ones\n",
IhFunctionIniCounter, Function_INI);
return (AE_ERROR);
}
}
else
{
if (IhFunctionIniCounter)
{
AapiErrors++;
printf ("API Error: unexpected INI Function calls"
" of InitializationHandler, %d times\n",
IhFunctionIniCounter);
return (AE_ERROR);
}
}
if (IhFunctionOthersCounter)
{
AapiErrors++;
printf ("API Error: unexpected Unknown Function calls"
" of InitializationHandler, %d times\n",
IhFunctionOthersCounter);
return (AE_ERROR);
}
if (!AT_SKIP_IH_OTYPE_CHECK && IhUnexpectedTypeCounter)
{
AapiErrors++;
printf ("API Error: unexpected type of Object"
" in InitializationHandler, %d times\n",
IhUnexpectedTypeCounter);
return (AE_ERROR);
}
if (AlternativeHandlerCounter)
{
AapiErrors++;
printf ("API Error: unexpected calls"
" of AlternativeInitHandler, %d times\n",
AlternativeHandlerCounter);
return (AE_ERROR);
}
return (AE_OK);
}
/*
* ASSERTION 0033:
*/
ACPI_STATUS
AtInitTest0033(void)
{
ACPI_STATUS Status;
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0032.aml")))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS | AAPITS_INSTALL_IH,
0, 0,
AAPITS_EN_FLAGS, ACPI_NO_DEVICE_INIT, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtInitializationHandlerCallsCheck(0)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVC", 0)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVM", 0)))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0034:
*/
ACPI_STATUS
AtInitTest0034(void)
{
ACPI_STATUS Status;
UINT8 BenchmarkField[] = {
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x1};
UINT8 BenchmarkBuffer[] = {
9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0034.aml")))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
0, 0,
AAPITS_EN_FLAGS, 0, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/* Region */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTR", 49)))
{
return (Status);
}
/* Buffer Fields */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTF", 64)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTG", 6)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTH", 4)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTI", 2)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTJ", 0)))
{
return (Status);
}
/* Buffer */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTB", 9)))
{
return (Status);
}
/* Package */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTP", 3)))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INITIALIZE_OBJS,
0, 0,
0, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* Check OperationRegions, BufferFields, Buffers, and Packages
* initialization AML code execution
*/
/* Region */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTR", 50)))
{
return (Status);
}
/* Buffer Fields */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTF", 65)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckBuffer("\\BFL0",
sizeof (BenchmarkField), BenchmarkField)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTG", 7)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\BFL1", 0x87)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTH", 5)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\BFL2", 0x8685)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTI", 3)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\BFL3", 0x86858483)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTJ", 1)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\BFL4",
((UINT64)0x8090a0b << 32) | 0x0c0d0e0f)))
{
return (Status);
}
/* Buffer */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTB", 10)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckBuffer("\\BUF0",
sizeof (BenchmarkBuffer), BenchmarkBuffer)))
{
return (Status);
}
/* Package */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTP", 4)))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0035:
*/
ACPI_STATUS
AtInitTest0035(void)
{
ACPI_STATUS Status;
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0034.aml")))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
AAPITS_EN_FLAGS, ACPI_NO_OBJECT_INIT, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* Check OperationRegions, BufferFields, Buffers, and Packages
* initialization AML code is not executed
*/
/* Region */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTR", 49)))
{
return (Status);
}
/* Buffer Fields */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTF", 64)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTG", 6)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTH", 4)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTI", 2)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTJ", 0)))
{
return (Status);
}
/* Buffer */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTB", 9)))
{
return (Status);
}
/* Package */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INTP", 3)))
{
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0036:
*/
ACPI_STATUS
AtInitTest0036(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* Mark the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 0);
if (ACPI_FAILURE(Status))
{
TestErrors++;
return (Status);
}
Status = AcpiPurgeCachedObjects();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiPurgeCachedObjects() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiOS* calls during AcpiPurgeCachedObjects, %s\n",
AcpiFormatException(Status));
return (Status);
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0037:
*/
ACPI_STATUS
AtInitTest0037(void)
{
ACPI_STATUS Status;
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
CHECK_SUBSYSTEM_STATUS(AE_OK);
return (AE_OK);
}
/*
* ASSERTION 0038:
*/
ACPI_STATUS
AtInitTest0038(void)
{
ACPI_STATUS Status;
UINT32 CtrlCheck = ALL_STAT;
if (AT_SKIP_MMAP_CHECK)
{
CtrlCheck &= ~MMAP_STAT;
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
CHECK_SUBSYSTEM_STATUS(AE_OK);
Status = AcpiTerminate();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiTerminate() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
CHECK_SUBSYSTEM_STATUS(AE_ERROR);
Status = OsxfCtrlCheck(CtrlCheck, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: some resources don't released\n");
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0039:
*/
ACPI_STATUS
AtInitTest0039(void)
{
ACPI_STATUS Status;
UINT32 StagesScale = 0;
UINT32 i = 0;
UINT32 Stages[3] = {AAPITS_INITIALIZE_SS,
AAPITS_LOADTABLES, AAPITS_ENABLE_SS};
for (i = 0; i < 3; i++)
{
StagesScale |= Stages[i];
Status = AtInitCommonTest(StagesScale,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
CHECK_SUBSYSTEM_STATUS(AE_ERROR);
Status = AcpiTerminate();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiTerminate() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
CHECK_SUBSYSTEM_STATUS(AE_ERROR);
Status = AtTerminateCheck(Status, ALL_STAT);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AE_OK);
}
/*
* ASSERTION 0040:
*/
ACPI_STATUS
AtInitTest0040(void)
{
ACPI_STATUS Status;
UINT32 StagesScale = 0;
UINT32 ErrStagesScale;
UINT32 i = 0;
UINT32 Stages[5] = {
AAPITS_INITIALIZE_SS, AAPITS_INITABLES, AAPITS_LOADTABLES,
AAPITS_ENABLE_SS, AAPITS_INITIALIZE_OBJS};
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0030.aml")))
{
return (Status);
}
for (i = 0; i < 5; i++)
{
StagesScale |= Stages[i];
ErrStagesScale = Stages[i];
Status = AtInitCommonTest(StagesScale,
ErrStagesScale, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
CHECK_SUBSYSTEM_STATUS(AE_ERROR);
Status = AcpiTerminate();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiTerminate() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
CHECK_SUBSYSTEM_STATUS(AE_ERROR);
/* AcpiOsTerminate redundancy issue */
if (1) continue;
Status = OsxfCtrlCheck(ALL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: some resources don't released\n");
return (Status);
}
}
return (AE_OK);
}
#define NUM_ACPI_TABLE_TYPES 7
char *Table_Names[NUM_ACPI_TABLE_TYPES] = {
"RSDP", "DSDT", "FADT", "FACS", "PSDT", "SSDT", "XSDT"};
/*
* ASSERTION 0041:
*/
ACPI_STATUS
AtCheckSystemInfo(
ACPI_SYSTEM_INFO *InfoPtr)
{
if (!(InfoPtr->TimerResolution == 24 || InfoPtr->TimerResolution == 32))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned"
" TimerResolution (%d) != 24 (or 32)\n",
InfoPtr->TimerResolution);
return (AE_ERROR);
}
return (AE_OK);
}
/*
* ASSERTION 0041:
*/
ACPI_STATUS
AtInitTest0041(void)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_BUFFER OutBuffer;
ACPI_SYSTEM_INFO Info;
UINT32 Stages[6] = {
0, AAPITS_INITIALIZE_SS, AAPITS_INITABLES, AAPITS_LOADTABLES,
AAPITS_ENABLE_SS, AAPITS_INITIALIZE_OBJS};
for (i = 0; i < 6; i++)
{
Status = AtInitCommonTest(Stages[i],
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
OutBuffer.Pointer = &Info;
OutBuffer.Length = 0;
Status = AcpiGetSystemInfo(&OutBuffer);
if (Status != AE_BUFFER_OVERFLOW)
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned %s,"
" expected AE_BUFFER_OVERFLOW\n",
AcpiFormatException(Status));
return (Status);
}
if (OutBuffer.Length != sizeof (Info))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned"
" Length %d, expected %d\n",
OutBuffer.Length, sizeof (Info));
return (AE_ERROR);
}
OutBuffer.Pointer = &Info;
OutBuffer.Length = sizeof (Info) - 1;
Status = AcpiGetSystemInfo(&OutBuffer);
if (Status != AE_BUFFER_OVERFLOW)
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned %s,"
" expected AE_BUFFER_OVERFLOW\n",
AcpiFormatException(Status));
return (Status);
}
if (OutBuffer.Length != sizeof (Info))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned"
" Length %d, expected %d\n",
OutBuffer.Length, sizeof (Info));
return (AE_ERROR);
}
OutBuffer.Pointer = &Info;
OutBuffer.Length = sizeof (Info);
Status = AcpiGetSystemInfo(&OutBuffer);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (OutBuffer.Length != sizeof (Info))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned"
" Length %d, expected %d\n",
OutBuffer.Length, sizeof (Info));
return (AE_ERROR);
}
else if (OutBuffer.Pointer != &Info)
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() succeeded but"
" OutBuffer.Pointer (%p) is not &Info (%p)\n",
OutBuffer.Pointer, &Info);
return (AE_ERROR);
}
if (ACPI_FAILURE(Status = AtCheckSystemInfo(OutBuffer.Pointer)))
{
return (Status);
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0042:
*/
ACPI_STATUS
AtInitTest0042(void)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_BUFFER OutBuffer;
ACPI_SYSTEM_INFO Info;
UINT32 Stages[6] = {
0, AAPITS_INITIALIZE_SS, AAPITS_INITABLES, AAPITS_LOADTABLES,
AAPITS_ENABLE_SS, AAPITS_INITIALIZE_OBJS};
for (i = 0; i < 6; i++)
{
Status = AtInitCommonTest(Stages[i],
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
Status = AcpiGetSystemInfo(NULL);
if (Status != AE_BAD_PARAMETER)
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo(NULL) returned %s,"
" expected AE_BAD_PARAMETER\n",
AcpiFormatException(Status));
return (Status);
}
OutBuffer.Pointer = NULL;
OutBuffer.Length = sizeof (Info);
Status = AcpiGetSystemInfo(&OutBuffer);
if (Status != AE_BAD_PARAMETER)
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo(OutBuffer.Pointer = NULL)"
" returned %s, expected AE_BAD_PARAMETER\n",
AcpiFormatException(Status));
return (Status);
}
OutBuffer.Pointer = &Info;
OutBuffer.Length = sizeof (Info);
Status = AcpiGetSystemInfo(&OutBuffer);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (OutBuffer.Length != sizeof (Info))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned"
" Length %d, expected %d\n",
OutBuffer.Length, sizeof (Info));
return (AE_ERROR);
}
else if (OutBuffer.Pointer != &Info)
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() succeeded but"
" OutBuffer.Pointer (%p) is not &Info (%p)\n",
OutBuffer.Pointer, &Info);
return (AE_ERROR);
}
if (ACPI_FAILURE(Status = AtCheckSystemInfo(OutBuffer.Pointer)))
{
return (Status);
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0043:
*/
ACPI_STATUS
AtInitTest0043(void)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_BUFFER OutBuffer;
UINT32 Stages[5] = {
AAPITS_INITIALIZE_SS, AAPITS_INITABLES, AAPITS_LOADTABLES,
AAPITS_ENABLE_SS, AAPITS_INITIALIZE_OBJS};
for (i = 0; i < 5; i++)
{
Status = AtInitCommonTest(Stages[i],
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
OutBuffer.Length = ACPI_ALLOCATE_BUFFER;
OutBuffer.Pointer = NULL;
Status = AcpiGetSystemInfo(&OutBuffer);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned %s\n",
AcpiFormatException(Status));
return (Status);
}
else if (OutBuffer.Pointer == NULL)
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() succeeded but returned NULL\n");
return (AE_ERROR);
}
else if (OutBuffer.Length != sizeof (ACPI_SYSTEM_INFO))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned"
" Length %d, expected %d\n",
OutBuffer.Length, sizeof (ACPI_SYSTEM_INFO));
return (AE_ERROR);
}
else
{
/* Check ACPI_SYSTEM_INFO structure*/
if (ACPI_FAILURE(Status = AtCheckSystemInfo(OutBuffer.Pointer)))
{
return (Status);
}
AcpiOsFree(OutBuffer.Pointer);
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0044:
*/
ACPI_STATUS
AtInitTest0044(void)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_BUFFER OutBuffer;
UINT32 Stages[5] = {
AAPITS_INITIALIZE_SS, AAPITS_INITABLES, AAPITS_LOADTABLES,
AAPITS_ENABLE_SS, AAPITS_INITIALIZE_OBJS};
for (i = 0; i < 5; i++)
{
Status = AtInitCommonTest(Stages[i],
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
Status = OsxfCtrlSet(OSXF_NUM(AcpiOsAllocate),
1, AtActD_OneTime, AtActRet_NULL);
if (ACPI_FAILURE(Status))
{
TestErrors++;
printf ("Test Error: OsxfCtrlSet() returned %s\n",
AcpiFormatException(Status));
return (Status);
}
OutBuffer.Length = ACPI_ALLOCATE_BUFFER;
OutBuffer.Pointer = NULL;
Status = AcpiGetSystemInfo(&OutBuffer);
if (Status != AE_NO_MEMORY)
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned %s,\n"
" expected AE_NO_MEMORY\n",
AcpiFormatException(Status));
return (Status);
}
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0045:
*/
ACPI_STATUS
AtInitTest0045(void)
{
ACPI_STATUS Status;
ACPI_BUFFER OutBuffer;
OutBuffer.Length = ACPI_ALLOCATE_BUFFER;
OutBuffer.Pointer = NULL;
Status = AcpiGetSystemInfo(&OutBuffer);
if (ACPI_SUCCESS(Status))
{
AapiErrors++;
printf ("API Error: AcpiGetSystemInfo() returned %s,"
" expected FAILURE\n",
AcpiFormatException(Status));
return (Status);
}
return (AtInitTest0044());
}
/*
* ASSERTION 0046:
*/
ACPI_STATUS
AtInitTest0046(void)
{
ACPI_STATUS Status;
UINT32 StagesScale = 0;
UINT32 i;
UINT32 Stages[6] = {
0, AAPITS_INITIALIZE_SS, AAPITS_INITABLES, AAPITS_LOADTABLES,
AAPITS_ENABLE_SS, AAPITS_INITIALIZE_OBJS};
for (i = 0; i < 6; i++)
{
StagesScale |= Stages[i];
Status = AtInitCommonTest(StagesScale,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
Status = AcpiInstallInitializationHandler(NULL, 0);
if (!ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiInstallInitializationHandler(NULL)"
" returned %s, expected FAILURE\n",
AcpiFormatException(Status));
return (Status);
}
if (i < 1) continue;
Status = AcpiTerminate();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiTerminate() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
/* AcpiOsTerminate redundancy issue */
if (1) continue;
Status = OsxfCtrlCheck(ALL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: some resources don't released\n");
return (Status);
}
}
return (AE_OK);
}
/*
* AtInitializationHandlerCommon:
*/
/******************************************************************************
*
* FUNCTION: AtInitializationHandlerCommon
*
* PARAMETERS: SpecName - Device to apply the special return value
* SpecRet - The Status code to return from the Handler
* ExpectedINVC - Expected value of the invocation counter
* ExpectedINVM - Expected mask of the invoked Methods
* ExpectedNegativeC_STA - Number of negative _STA invocations
* ExpectedNegativeM_STA - Mask of negative _STA invocations
* ExpectedCalls - Total number of Handler calls
*
* RETURN: Status
*
* DESCRIPTION: Common test of Global Initialization Handler installation.
*
*****************************************************************************/
ACPI_STATUS
AtInitializationHandlerCommon(
char *AmlName,
UINT8 *SpecName,
ACPI_STATUS SpecRet,
UINT32 ExpectedINVC,
UINT32 ExpectedINVM,
UINT32 ExpectedNegativeC_STA,
UINT32 ExpectedNegativeM_STA,
UINT32 ExpectedCalls)
{
ACPI_STATUS Status;
UINT32 StagesScale = 0;
UINT32 i, j;
UINT32 Stages[3] = {
AAPITS_INITIALIZE_SS, AAPITS_LOADTABLES, AAPITS_ENABLE_SS};
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet(AmlName)))
{
return (Status);
}
for (i = 0; i < 3; i++)
{
StagesScale |= Stages[i];
Status = AtInitCommonTest(StagesScale,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
IhFunctionIniCounter = 0;
Status = AcpiInstallInitializationHandler(AtAcpiInitHandler, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiInstallInitializationHandler()"
" returned %s, expected SUCCESS\n",
AcpiFormatException(Status));
return (Status);
}
for (j = i + 1; j < 3; j++)
{
Status = AtInitCommonTest(Stages[j],
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtInitializationHandlerCallsCheck(0)))
{
printf ("AtInitializationHandlerCallsCheck Error"
" after Stage 0x%x (0x%x)\n",
Stages[j], StagesScale);
return (Status);
}
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVC", 0)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVM", 0)))
{
return (Status);
}
AtAcpiInitHandlerSpecName = SpecName;
AtAcpiInitHandlerSpecRet = SpecRet;
EstimatedINVC = 0;
EstimatedINVM = 0;
Status = AtInitCommonTest(AAPITS_INITIALIZE_OBJS,
0, 0,
0, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
if (AtAcpiInitHandlerSpecRet != AE_OK)
{
AapiErrors++;
printf ("API Error: None InitializationHandler() call"
" on the Object Name '%s'\n",
AtAcpiInitHandlerSpecName);
return (AE_ERROR);
}
if (EstimatedINVM & ExpectedNegativeM_STA)
{
AapiErrors++;
printf ("API Error: EstimatedINVM (0x%x) & ExpectedNegativeM_STA"
" (0x%x) != 0 (unexpected call for not present device)\n",
EstimatedINVM, ExpectedNegativeM_STA);
return (AE_ERROR);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVC",
EstimatedINVC + ExpectedNegativeC_STA)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INVM",
EstimatedINVM | ExpectedNegativeM_STA)))
{
return (Status);
}
if (EstimatedINVC != ExpectedINVC)
{
AapiErrors++;
printf ("API Error: EstimatedINVC (%d) != ExpectedINVC (%d)\n",
EstimatedINVC, ExpectedINVC);
return (AE_ERROR);
}
if (EstimatedINVM != ExpectedINVM)
{
AapiErrors++;
printf ("API Error: EstimatedINVM (0x%x) != ExpectedINVM (0x%x)\n",
EstimatedINVM, ExpectedINVM);
return (AE_ERROR);
}
if (ACPI_FAILURE(Status = AtInitializationHandlerCallsCheck(
ExpectedCalls)))
{
return (Status);
}
Status = AtTerminateCtrlCheck(AE_OK, ALL_STAT);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AE_OK);
}
/*
* ASSERTION 0047:
*/
ACPI_STATUS
AtInitTest0047(void)
{
return (AtInitializationHandlerCommon(
"init0032.aml",
NULL, AE_OK, 10, TOTAL_MASK,
_STA_NEGATIV_CALLS, _STA_NEGATIV_MASK, 8));
}
/*
* ASSERTION 0048:
*/
ACPI_STATUS
AtInitTest0048(void)
{
ACPI_STATUS Status;
UINT32 StagesScale = 0;
UINT32 i, j;
UINT32 Stages[3] = {
AAPITS_INITIALIZE_SS, AAPITS_LOADTABLES, AAPITS_ENABLE_SS};
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0032.aml")))
{
return (Status);
}
for (i = 0; i < 3; i++)
{
StagesScale |= Stages[i];
Status = AtInitCommonTest(StagesScale,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
IhFunctionIniCounter = 0;
Status = AcpiInstallInitializationHandler(AtAcpiInitHandler, 0);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiInstallInitializationHandler()"
" returned %s, expected SUCCESS\n",
AcpiFormatException(Status));
return (Status);
}
Status = AcpiInstallInitializationHandler(AlternativeAcpiInitHandler, 0);
if (Status != AE_ALREADY_EXISTS)
{
AapiErrors++;
printf ("API Error: AcpiInstallInitializationHandler()"
" returned %s, expected AE_ALREADY_EXISTS\n",
AcpiFormatException(Status));
return (AE_ERROR);
}
for (j = i + 1; j < 3; j++)
{
Status = AtInitCommonTest(Stages[j],
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtInitializationHandlerCallsCheck(0)))
{
printf ("AtInitializationHandlerCallsCheck Error"
" after Stage 0x%x (0x%x)\n",
Stages[j], StagesScale);
return (Status);
}
Status = AcpiInstallInitializationHandler(AlternativeAcpiInitHandler, 0);
if (Status != AE_ALREADY_EXISTS)
{
AapiErrors++;
printf ("API Error: AcpiInstallInitializationHandler()"
" returned %s, expected AE_ALREADY_EXISTS\n",
AcpiFormatException(Status));
return (AE_ERROR);
}
}
Status = AtInitCommonTest(AAPITS_INITIALIZE_OBJS,
0, 0,
0, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtInitializationHandlerCallsCheck(5)))
{
return (Status);
}
Status = AtTerminateCtrlCheck(AE_OK, ALL_STAT);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AE_OK);
}
/*
* ASSERTION 0049:
*/
ACPI_STATUS
AtInitTest0049(void)
{
ACPI_STATUS Status;
UINT32 RMax = 3;
UINT32 i;
/*
* Mark the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error 1: AcpiOS* calls withoout Subsystem init., %s\n",
AcpiFormatException(Status));
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AcpiInstallInitializationHandler(AlternativeAcpiInitHandler, 0);
if (Status != AE_ERROR)
{
AapiErrors++;
printf ("API Error: AcpiInstallInitializationHandler()"
" returned %s, expected AE_ERROR\n",
AcpiFormatException(Status));
return (AE_ERROR);
}
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error 2: AcpiOS* calls during AcpiInitializeObjects, %s\n",
AcpiFormatException(Status));
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0050:
*/
ACPI_STATUS
AtInitTest0050(void)
{
ACPI_STATUS Status;
UINT32 RMax = 3;
UINT32 i;
Status = AtInitCommonTest(AAPITS_INITIALIZE_SS,
AAPITS_INITIALIZE_SS, 0,
0, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
for (i = 0; i < RMax; i++)
{
Status = AcpiInstallInitializationHandler(
AlternativeAcpiInitHandler, 0);
if (Status != AE_ERROR)
{
AapiErrors++;
printf ("API Error: AcpiInstallInitializationHandler()"
" returned %s, expected AE_ERROR\n",
AcpiFormatException(Status));
return (Status);
}
}
/*
* Check the total number of AcpiOS* invocations
*/
Status = OsxfCtrlCheck(TOTAL_STAT, 1);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiOS* calls during AcpiInitializeObjects, %s\n",
AcpiFormatException(Status));
return (Status);
}
return (AE_OK);
}
/*
* ASSERTION 0051:
*/
ACPI_STATUS
AtInitTest0051(void)
{
return (AtInitializationHandlerCommon(
"init0032.aml",
(UINT8 *)"DEV5", AE_CTRL_TERMINATE, 5, 0xCE,
1, 0x20 /* DEV4 */, 5));
}
/*
* ASSERTION 0052:
*/
ACPI_STATUS
AtInitTest0052(void)
{
return (AtInitializationHandlerCommon(
"init0032.aml",
(UINT8 *)"DEV5", AE_CTRL_DEPTH,
8, TOTAL_MASK & ~0x330,
_STA_NEGATIV_CALLS, _STA_NEGATIV_MASK, 7));
}
/*
* ASSERTION 0053:
*/
ACPI_STATUS
AtInitTest0053(void)
{
ACPI_STATUS Status;
UINT32 AllEnFlags[] = {
ACPI_NO_ADDRESS_SPACE_INIT,
ACPI_NO_HARDWARE_INIT,
ACPI_NO_EVENT_INIT,
ACPI_NO_HANDLER_INIT,
ACPI_NO_ACPI_ENABLE,
/* ACPI_NO_PCI_INIT */};
UINT32 MaxEnFlags = 5; /* 6 with ACPI_NO_PCI_INIT */
UINT32 ScaleEnFlags = (1 << MaxEnFlags);
UINT32 EnFlags = 0, i, j;
for (i = 1; i < ScaleEnFlags; i++)
{
printf ("i == %d\n", i);
EnFlags = 0;
for (j = 0; j < MaxEnFlags; j++)
{
if ((i >> j) & 1)
{
EnFlags |= AllEnFlags[j];
}
}
/*
* If ACPI events is not initialized then
* the handlers can not be initialized too.
*/
if (EnFlags & ACPI_NO_EVENT_INIT &&
!(EnFlags & ACPI_NO_HANDLER_INIT) &&
AT_SKIP_NO_HANDLER_INIT)
{
continue;
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
EnFlags, AAPITS_OI_FLAGS, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
CHECK_SUBSYSTEM_STATUS(AE_OK);
Status = AtTerminateCtrlCheck(AE_OK, ALL_STAT);
if (ACPI_FAILURE(Status))
{
return (Status);
}
}
return (AE_OK);
}
/*
* ASSERTION 0054:
*/
ACPI_STATUS
AtInitTest0054(void)
{
ACPI_STATUS Status;
/*
* AcpiOsAllocate returns NULL permanently since the specified call
*/
Status = AtExceptionCommonTest(AAPITS_ENABLE_SS,
OSXF_NUM(AcpiOsAllocate),
AtActD_Permanent, AtActRet_NULL, 1,
AE_NO_MEMORY);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* AcpiOsAllocate returns NULL one time on the specified call
*/
return (AtExceptionCommonTest(AAPITS_ENABLE_SS,
OSXF_NUM(AcpiOsAllocate),
AtActD_OneTime, AtActRet_NULL, 1,
AE_NO_MEMORY));
}
/*
* ASSERTION 0055:
*/
ACPI_STATUS
AtInitTest0055(void)
{
ACPI_STATUS Status;
/*
* AcpiOsAllocate returns NULL permanently since the specified call
*/
Status = AtExceptionCommonTest(AAPITS_INITIALIZE_OBJS,
OSXF_NUM(AcpiOsAllocate),
AtActD_Permanent, AtActRet_NULL, 1,
AE_NO_MEMORY);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
* AcpiOsAllocate returns NULL one time on the specified call
*/
return (AtExceptionCommonTest(AAPITS_INITIALIZE_OBJS,
OSXF_NUM(AcpiOsAllocate),
AtActD_OneTime, AtActRet_NULL, 1,
AE_NO_MEMORY));
}
#define TO_STRING(a) #a
ACPI_STATUS AllExceptionsCodes[] = {
AE_OK,
AE_ERROR,
AE_NO_ACPI_TABLES,
AE_NO_NAMESPACE,
AE_NO_MEMORY,
AE_NOT_FOUND,
AE_NOT_EXIST,
AE_ALREADY_EXISTS,
AE_TYPE,
AE_NULL_OBJECT,
AE_NULL_ENTRY,
AE_BUFFER_OVERFLOW,
AE_STACK_OVERFLOW,
AE_STACK_UNDERFLOW,
AE_NOT_IMPLEMENTED,
AE_SUPPORT,
AE_LIMIT,
AE_TIME,
AE_ACQUIRE_DEADLOCK,
AE_RELEASE_DEADLOCK,
AE_NOT_ACQUIRED,
AE_ALREADY_ACQUIRED,
AE_NO_HARDWARE_RESPONSE,
AE_NO_GLOBAL_LOCK,
AE_ABORT_METHOD,
AE_SAME_HANDLER,
AE_NO_HANDLER,
// AE_OWNER_ID_LIMIT,
AE_BAD_PARAMETER,
AE_BAD_CHARACTER,
AE_BAD_PATHNAME,
AE_BAD_DATA,
AE_BAD_ADDRESS,
AE_BAD_HEX_CONSTANT,
AE_BAD_OCTAL_CONSTANT,
AE_BAD_DECIMAL_CONSTANT,
AE_BAD_SIGNATURE,
AE_BAD_HEADER,
AE_BAD_CHECKSUM,
AE_BAD_VALUE,
AE_INVALID_TABLE_LENGTH,
AE_AML_BAD_OPCODE,
AE_AML_NO_OPERAND,
AE_AML_OPERAND_TYPE,
AE_AML_OPERAND_VALUE,
AE_AML_UNINITIALIZED_LOCAL,
AE_AML_UNINITIALIZED_ARG,
AE_AML_UNINITIALIZED_ELEMENT,
AE_AML_NUMERIC_OVERFLOW,
AE_AML_REGION_LIMIT,
AE_AML_BUFFER_LIMIT,
AE_AML_PACKAGE_LIMIT,
AE_AML_DIVIDE_BY_ZERO,
AE_AML_BAD_NAME,
AE_AML_NAME_NOT_FOUND,
AE_AML_INTERNAL,
AE_AML_INVALID_SPACE_ID,
AE_AML_STRING_LIMIT,
AE_AML_NO_RETURN_VALUE,
AE_AML_METHOD_LIMIT,
AE_AML_NOT_OWNER,
AE_AML_MUTEX_ORDER,
AE_AML_MUTEX_NOT_ACQUIRED,
AE_AML_INVALID_RESOURCE_TYPE,
AE_AML_INVALID_INDEX,
AE_AML_REGISTER_LIMIT,
AE_AML_NO_WHILE,
AE_AML_ALIGNMENT,
AE_AML_NO_RESOURCE_END_TAG,
AE_AML_BAD_RESOURCE_VALUE,
AE_AML_CIRCULAR_REFERENCE,
AE_AML_BAD_RESOURCE_LENGTH,
AE_CTRL_RETURN_VALUE,
AE_CTRL_PENDING,
AE_CTRL_TERMINATE,
AE_CTRL_TRUE,
AE_CTRL_FALSE,
AE_CTRL_DEPTH,
AE_CTRL_END,
AE_CTRL_TRANSFER,
AE_CTRL_BREAK,
AE_CTRL_CONTINUE,
AE_CTRL_SKIP
};
char *AllExceptionsStrings[] = {
TO_STRING(AE_OK),
TO_STRING(AE_ERROR),
TO_STRING(AE_NO_ACPI_TABLES),
TO_STRING(AE_NO_NAMESPACE),
TO_STRING(AE_NO_MEMORY),
TO_STRING(AE_NOT_FOUND),
TO_STRING(AE_NOT_EXIST),
TO_STRING(AE_ALREADY_EXISTS),
TO_STRING(AE_TYPE),
TO_STRING(AE_NULL_OBJECT),
TO_STRING(AE_NULL_ENTRY),
TO_STRING(AE_BUFFER_OVERFLOW),
TO_STRING(AE_STACK_OVERFLOW),
TO_STRING(AE_STACK_UNDERFLOW),
TO_STRING(AE_NOT_IMPLEMENTED),
TO_STRING(AE_SUPPORT),
TO_STRING(AE_LIMIT),
TO_STRING(AE_TIME),
TO_STRING(AE_ACQUIRE_DEADLOCK),
TO_STRING(AE_RELEASE_DEADLOCK),
TO_STRING(AE_NOT_ACQUIRED),
TO_STRING(AE_ALREADY_ACQUIRED),
TO_STRING(AE_NO_HARDWARE_RESPONSE),
TO_STRING(AE_NO_GLOBAL_LOCK),
TO_STRING(AE_ABORT_METHOD),
TO_STRING(AE_SAME_HANDLER),
TO_STRING(AE_WAKE_ONLY_GPE),
// TO_STRING(AE_OWNER_ID_LIMIT),
TO_STRING(AE_BAD_PARAMETER),
TO_STRING(AE_BAD_CHARACTER),
TO_STRING(AE_BAD_PATHNAME),
TO_STRING(AE_BAD_DATA),
TO_STRING(AE_BAD_ADDRESS),
TO_STRING(AE_BAD_HEX_CONSTANT),
TO_STRING(AE_BAD_OCTAL_CONSTANT),
TO_STRING(AE_BAD_DECIMAL_CONSTANT),
TO_STRING(AE_BAD_SIGNATURE),
TO_STRING(AE_BAD_HEADER),
TO_STRING(AE_BAD_CHECKSUM),
TO_STRING(AE_BAD_VALUE),
TO_STRING(AE_INVALID_TABLE_LENGTH),
TO_STRING(AE_AML_BAD_OPCODE),
TO_STRING(AE_AML_NO_OPERAND),
TO_STRING(AE_AML_OPERAND_TYPE),
TO_STRING(AE_AML_OPERAND_VALUE),
TO_STRING(AE_AML_UNINITIALIZED_LOCAL),
TO_STRING(AE_AML_UNINITIALIZED_ARG),
TO_STRING(AE_AML_UNINITIALIZED_ELEMENT),
TO_STRING(AE_AML_NUMERIC_OVERFLOW),
TO_STRING(AE_AML_REGION_LIMIT),
TO_STRING(AE_AML_BUFFER_LIMIT),
TO_STRING(AE_AML_PACKAGE_LIMIT),
TO_STRING(AE_AML_DIVIDE_BY_ZERO),
TO_STRING(AE_AML_BAD_NAME),
TO_STRING(AE_AML_NAME_NOT_FOUND),
TO_STRING(AE_AML_INTERNAL),
TO_STRING(AE_AML_INVALID_SPACE_ID),
TO_STRING(AE_AML_STRING_LIMIT),
TO_STRING(AE_AML_NO_RETURN_VALUE),
TO_STRING(AE_AML_METHOD_LIMIT),
TO_STRING(AE_AML_NOT_OWNER),
TO_STRING(AE_AML_MUTEX_ORDER),
TO_STRING(AE_AML_MUTEX_NOT_ACQUIRED),
TO_STRING(AE_AML_INVALID_RESOURCE_TYPE),
TO_STRING(AE_AML_INVALID_INDEX),
TO_STRING(AE_AML_REGISTER_LIMIT),
TO_STRING(AE_AML_NO_WHILE),
TO_STRING(AE_AML_ALIGNMENT),
TO_STRING(AE_AML_NO_RESOURCE_END_TAG),
TO_STRING(AE_AML_BAD_RESOURCE_VALUE),
TO_STRING(AE_AML_CIRCULAR_REFERENCE),
TO_STRING(AE_AML_BAD_RESOURCE_LENGTH),
TO_STRING(AE_CTRL_RETURN_VALUE),
TO_STRING(AE_CTRL_PENDING),
TO_STRING(AE_CTRL_TERMINATE),
TO_STRING(AE_CTRL_TRUE),
TO_STRING(AE_CTRL_FALSE),
TO_STRING(AE_CTRL_DEPTH),
TO_STRING(AE_CTRL_END),
TO_STRING(AE_CTRL_TRANSFER),
TO_STRING(AE_CTRL_BREAK),
TO_STRING(AE_CTRL_CONTINUE),
TO_STRING(AE_CTRL_SKIP)
};
/*
* ASSERTION 0056:
*/
ACPI_STATUS
AtInitTest0056(void)
{
const char *ExceptionString;
UINT32 i;
UINT32 NumCodes =
sizeof (AllExceptionsCodes) / sizeof (ACPI_STATUS);
for (i = 0; i < NumCodes; i++)
{
ExceptionString = AcpiFormatException(AllExceptionsCodes[i]);
if (!ExceptionString)
{
AapiErrors++;
printf ("API Error: AcpiFormatException(0x%x) returned NULL\n",
AllExceptionsCodes[i]);
}
else if (strcmp(ExceptionString, AllExceptionsStrings[i]) != 0){
AapiErrors++;
printf ("API Error: AcpiFormatException(0x%x) returned %s,"
" expected %s\n",
AllExceptionsCodes[i], ExceptionString, AllExceptionsStrings[i]);
}
}
return (AE_OK);
}
/*
* ASSERTION 0057:
*/
ACPI_STATUS
AtInitTest0057(void)
{
ACPI_STATUS Status;
const char *ExceptionString;
UINT32 i, k = 0, NumChecked = 0, NumChecks = 10;
UINT32 NumCodes =
sizeof (AllExceptionsCodes) / sizeof (ACPI_STATUS);
Status = AllExceptionsCodes[k++];
while (NumChecked < NumChecks)
{
for (i = 0; i < NumCodes; i++)
{
if (Status == AllExceptionsCodes[i])
{
break;
}
}
if (i < NumCodes)
{
Status++;
k++;
}
else
{
NumChecked++;
ExceptionString = AcpiFormatException(Status);
if (ExceptionString)
{
for (i = 0; i < NumCodes; i++)
{
if (strcmp(ExceptionString, AllExceptionsStrings[i]) == 0)
{
AapiErrors++;
printf ("API Error: AcpiFormatException(0x%x) returned"
" unexpected '%s' related to 0x%x code\n",
Status, ExceptionString, AllExceptionsCodes[i]);
break;
}
}
}
else
{
AapiErrors++;
printf ("API Error: AcpiFormatException(0x%x) for unknown"
" code returned NULL, expected string\n",
Status);
}
if (k < NumCodes)
{
Status = AllExceptionsCodes[k++];
}
else
{
Status++;
}
}
}
return (AE_OK);
}
/*
* ASSERTION 0058:
*/
ACPI_STATUS
AtInitTest0058(void)
{
ACPI_STATUS Status;
UINT64 MallocCount[4];
INT64 MallocDiff[4];
INT64 Diff[4];
UINT32 RMax = 3;
UINT32 i;
if (ACPI_MAX_OBJECT_CACHE_DEPTH < 64)
{
TestErrors++;
printf ("Test Error: AtInitTest0058 skipped due to too small"
"ACPI_MAX_OBJECT_CACHE_DEPTH constant (%d)\n",
ACPI_MAX_OBJECT_CACHE_DEPTH);
return (Status);
}
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0058.aml")))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS | AAPITS_INITIALIZE_OBJS,
0, 0,
AAPITS_EN_FLAGS, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
MallocCount[0] = OsxfCtrlGetCalls(OSXF_NUM(AcpiOsAllocate), 1);
Diff[0] = OsxfCtrlGetDiff(MALLOC_STAT);
Status = AcpiEvaluateObject (NULL, "\\MAIN", NULL, NULL);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiEvaluateObject(\\MAIN) returned %s\n",
AcpiFormatException(Status));
return (Status);
}
MallocCount[1] = OsxfCtrlGetCalls(OSXF_NUM(AcpiOsAllocate), 1);
MallocDiff[0] = MallocCount[1] - MallocCount[0];
Diff[1] = OsxfCtrlGetDiff(MALLOC_STAT);
/*
* Specified AML code should initiate memory allocations
* which occupy enough caches positions, but don't exceed
* any cache limit
*/
if ((Diff[1] - Diff[0]) < ACPI_MAX_OBJECT_CACHE_DEPTH / 2)
{
TestErrors++;
printf ("Test Error: AtInitTest0058 skipped due to too weak"
" memory allocation activity (%d)\n",
(UINT32)(Diff[1] - Diff[0]));
return (AE_ERROR);
}
/*
* Repeat Specified AML code execution
*/
for (i = 0; i < RMax; i++)
{
Status = AcpiEvaluateObject (NULL, "\\MAIN", NULL, NULL);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiEvaluateObject(\\MAIN) returned %s\n",
AcpiFormatException(Status));
return (Status);
}
MallocCount[2] = OsxfCtrlGetCalls(OSXF_NUM(AcpiOsAllocate), 1);
MallocDiff[1] = MallocCount[2] - MallocCount[1];
Diff[2] = OsxfCtrlGetDiff(MALLOC_STAT);
/*
* Specified AML code should not initiate needless memory allocations,
* check that objects from caches were used for memory consumption.
*/
if ((MallocDiff[0] - MallocDiff[1]) < (Diff[1] - Diff[0]) / 2)
{
TestErrors++;
printf ("Test Error %d: too little %d memory allocations"
" shortening basing on caches\n",
i, (UINT32)(MallocDiff[0] - MallocDiff[1]));
return (AE_ERROR);
}
if (Diff[2] != Diff[1])
{
TestErrors++;
printf ("Test Error %d: AtInitTest0058 skipped due to %d memory allocations"
" outside caches\n",
i, (UINT32)(Diff[2] - Diff[1]));
return (AE_ERROR);
}
if (i > 0)
{
if (MallocDiff[2] != MallocDiff[1])
{
TestErrors++;
printf ("API Error %d: %d memory allocations"
" against %d previous\n",
i, (UINT32)MallocDiff[2], (UINT32)MallocDiff[1]);
return (AE_ERROR);
}
}
MallocCount[1] = MallocCount[2];
MallocDiff[2] = MallocDiff[1];
}
Status = AcpiPurgeCachedObjects();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API Error: AcpiPurgeCachedObjects() failure, %s\n",
AcpiFormatException(Status));
return (Status);
}
MallocCount[3] = OsxfCtrlGetCalls(OSXF_NUM(AcpiOsAllocate), 1);
Diff[3] = OsxfCtrlGetDiff(MALLOC_STAT);
/*
* AcpiPurgeCachedObjects is expected to release Cached Objects.
*/
if (Diff[3] != Diff[0])
{
AapiErrors++;
printf ("API Error: AcpiPurgeCachedObjects is not release %d"
" allocations\n",
(UINT32)(Diff[3] - Diff[0]));
return (AE_ERROR);
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0059: extension of 0047
*/
ACPI_STATUS
AtInitTest0059(void)
{
return (AtInitializationHandlerCommon(
"init0059.aml",
NULL, AE_OK, 12, TOTAL_MASK | 0xC000,
_STA_NEGATIV_CALLS + 1, _STA_NEGATIV_MASK | 0x20000,
9));
}
/*
* ASSERTION 0060:
*/
ACPI_STATUS
AtInitTest0060(void)
{
ACPI_STATUS Status;
ACPI_TABLE_HEADER UserTableStructure, *UserTable = &UserTableStructure;
BLD_TABLES_TASK BldTask = {BLD_NO_FADT, 0};
memset(&UserTableStructure, 0, sizeof (ACPI_TABLE_HEADER));
AtBuildLocalTables(UserTable, BldTask);
Status = AtSubsystemInit(AAPITS_INITIALIZE_SS,
0, 0, NULL);
if (ACPI_FAILURE(Status))
{
return (Status);
}
Status = AtInitializeTables(FALSE);
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API error: AcpiInitializeTables() returned %s\n",
AcpiFormatException(Status));
return (Status);
}
Status = AcpiLoadTables();
if (ACPI_FAILURE(Status))
{
AapiErrors++;
printf ("API error: AcpiLoadTables() returned %s\n",
AcpiFormatException(Status));
return (Status);
}
Status = AcpiEnableSubsystem(0);
if (Status != AE_NO_ACPI_TABLES)
{
AapiErrors++;
printf ("API error: AcpiEnableSubsystem () returned %s, expected %s\n",
AcpiFormatException(Status), AcpiFormatException(AE_NO_ACPI_TABLES));
return (Status);
}
return (AtTerminateCtrlCheck(AE_OK, ALL_STAT));
}
/*
* ASSERTION 0066:
*/
ACPI_STATUS
AtInitTest0066(void)
{
ACPI_STATUS Status;
UINT8 BenchmarkBuffer[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
if (ACPI_FAILURE(Status = AtAMLcodeFileNameSet("init0066.aml")))
{
return (Status);
}
Status = AtInitCommonTest(AAPITS_INI_LOAD |
AAPITS_ENABLE_SS,
0, 0,
AAPITS_EN_FLAGS, 0, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
/*
Status = AtInitCommonTest(AAPITS_INITIALIZE_OBJS,
0, 0,
0, AAPITS_OI_FLAGS, AtAMLcodeFileName);
if (ACPI_FAILURE(Status))
{
return (Status);
}
*/
/* Buffer Fields */
if (ACPI_FAILURE(Status = AtCheckInteger(NULL, "\\INT0", 64)))
{
return (Status);
}
if (ACPI_FAILURE(Status = AtCheckBuffer("\\MBF0",
sizeof (BenchmarkBuffer), BenchmarkBuffer)))
{
return (Status);
}
return (AE_OK);
}
Reference in New Issue View Git Blame Copy Permalink