static void
AeGenericRegisters (
void)
{
ACPI_STATUS Status;
UINT64 Value;
GenericRegister.Address = 0x1234;
GenericRegister.BitWidth = 64;
GenericRegister.BitOffset = 0;
GenericRegister.SpaceId = ACPI_ADR_SPACE_SYSTEM_IO;
Status = AcpiRead (&Value, &GenericRegister);
AE_CHECK_OK (AcpiRead, Status);
Status = AcpiWrite (Value, &GenericRegister);
AE_CHECK_OK (AcpiWrite, Status);
GenericRegister.Address = 0x12345678;
GenericRegister.BitOffset = 0;
GenericRegister.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY;
Status = AcpiRead (&Value, &GenericRegister);
AE_CHECK_OK (AcpiRead, Status);
Status = AcpiWrite (Value, &GenericRegister);
AE_CHECK_OK (AcpiWrite, Status);
}
ACPI_STATUS
AeInstallLateHandlers (
void)
{
ACPI_STATUS Status;
UINT32 i;
#if (!ACPI_REDUCED_HARDWARE)
if (!AcpiGbl_ReducedHardware)
{
/* Install a user SCI handler */
Status = AeInstallSciHandler ();
AE_CHECK_OK (AeInstallSciHandler, Status);
/* Install some fixed event handlers */
Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL, AeEventHandler, NULL);
AE_CHECK_OK (AcpiInstallFixedEventHandler, Status);
Status = AcpiInstallFixedEventHandler (ACPI_EVENT_RTC, AeEventHandler, NULL);
AE_CHECK_OK (AcpiInstallFixedEventHandler, Status);
}
#endif /* !ACPI_REDUCED_HARDWARE */
AeMyContext.Connection = NULL;
AeMyContext.AccessLength = 0xA5;
/*
* We will install a handler for each EC device, directly under the EC
* device definition. This is unlike the other handlers which we install
* at the root node. Also install memory and I/O handlers at any PCI
* devices.
*/
AeInstallDeviceHandlers ();
/*
* Install handlers for some of the "device driver" address spaces
* such as SMBus, etc.
*/
for (i = 0; i < ACPI_ARRAY_LENGTH (SpaceIdList); i++)
{
/* Install handler at the root object */
Status = AcpiInstallAddressSpaceHandler (ACPI_ROOT_OBJECT,
SpaceIdList[i], AeRegionHandler,
AeRegionInit, &AeMyContext);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"Could not install an OpRegion handler for %s space(%u)",
AcpiUtGetRegionName((UINT8) SpaceIdList[i]), SpaceIdList[i]));
return (Status);
}
}
return (AE_OK);
}
static void
AeHardwareInterfaces (
void)
{
ACPI_STATUS Status;
UINT32 Value;
Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, 1);
AE_CHECK_OK (AcpiWriteBitRegister, Status);
Status = AcpiWriteBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, 1);
AE_CHECK_OK (AcpiWriteBitRegister, Status);
Status = AcpiWriteBitRegister (ACPI_BITREG_SLEEP_ENABLE, 1);
AE_CHECK_OK (AcpiWriteBitRegister, Status);
Status = AcpiWriteBitRegister (ACPI_BITREG_ARB_DISABLE, 1);
AE_CHECK_OK (AcpiWriteBitRegister, Status);
Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &Value);
AE_CHECK_OK (AcpiReadBitRegister, Status);
Status = AcpiReadBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, &Value);
AE_CHECK_OK (AcpiReadBitRegister, Status);
Status = AcpiReadBitRegister (ACPI_BITREG_SLEEP_ENABLE, &Value);
AE_CHECK_OK (AcpiReadBitRegister, Status);
Status = AcpiReadBitRegister (ACPI_BITREG_ARB_DISABLE, &Value);
AE_CHECK_OK (AcpiReadBitRegister, Status);
}
static void
AfInstallGpeBlock (
void)
{
ACPI_STATUS Status;
ACPI_HANDLE Handle;
ACPI_HANDLE Handle2 = NULL;
ACPI_HANDLE Handle3 = NULL;
ACPI_GENERIC_ADDRESS BlockAddress;
ACPI_HANDLE GpeDevice;
Status = AcpiGetHandle (NULL, "\\_GPE", &Handle);
if (ACPI_FAILURE (Status))
{
return;
}
ACPI_MEMSET (&BlockAddress, 0, sizeof (ACPI_GENERIC_ADDRESS));
BlockAddress.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY;
BlockAddress.Address = 0x76540000;
Status = AcpiGetHandle (NULL, "\\GPE2", &Handle2);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallGpeBlock (Handle2, &BlockAddress, 7, 8);
AE_CHECK_OK (AcpiInstallGpeBlock, Status);
Status = AcpiInstallGpeHandler (Handle2, 8,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (Handle2, 8);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiGetGpeDevice (0x30, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (0x42, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount-1, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount, &GpeDevice);
AE_CHECK_STATUS (AcpiGetGpeDevice, Status, AE_NOT_EXIST);
Status = AcpiRemoveGpeHandler (Handle2, 8, AeGpeHandler);
AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
}
Status = AcpiGetHandle (NULL, "\\GPE3", &Handle3);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallGpeBlock (Handle3, &BlockAddress, 8, 11);
AE_CHECK_OK (AcpiInstallGpeBlock, Status);
}
}
static ACPI_STATUS
AeTableHandler (
UINT32 Event,
void *Table,
void *Context)
{
#if (!ACPI_REDUCED_HARDWARE)
ACPI_STATUS Status;
#endif /* !ACPI_REDUCED_HARDWARE */
if (Event > ACPI_NUM_TABLE_EVENTS)
{
Event = ACPI_NUM_TABLE_EVENTS;
}
#if (!ACPI_REDUCED_HARDWARE)
/* Enable any GPEs associated with newly-loaded GPE methods */
Status = AcpiUpdateAllGpes ();
AE_CHECK_OK (AcpiUpdateAllGpes, Status);
printf ("[AcpiExec] Table Event %s, [%4.4s] %p\n",
TableEvents[Event], ((ACPI_TABLE_HEADER *) Table)->Signature, Table);
#endif /* !ACPI_REDUCED_HARDWARE */
return (AE_OK);
}
ACPI_STATUS
AeInstallTables (
void)
{
ACPI_STATUS Status;
ACPI_TABLE_HEADER Header;
ACPI_TABLE_HEADER *Table;
Status = AcpiInitializeTables (Tables, ACPI_MAX_INIT_TABLES, TRUE);
AE_CHECK_OK (AcpiInitializeTables, Status);
Status = AcpiReallocateRootTable ();
AE_CHECK_OK (AcpiReallocateRootTable, Status);
Status = AcpiLoadTables ();
AE_CHECK_OK (AcpiLoadTables, Status);
/*
* Test run-time control method installation. Do it twice to test code
* for an existing name.
*/
Status = AcpiInstallMethod (MethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install method\n",
AcpiFormatException (Status));
}
Status = AcpiInstallMethod (MethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install method\n",
AcpiFormatException (Status));
}
/* Test multiple table/UEFI support. First, get the headers */
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 1, &Header);
AE_CHECK_OK (AcpiGetTableHeader, Status);
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 2, &Header);
AE_CHECK_OK (AcpiGetTableHeader, Status);
Status = AcpiGetTableHeader (ACPI_SIG_UEFI, 3, &Header);
AE_CHECK_STATUS (AcpiGetTableHeader, Status, AE_NOT_FOUND);
/* Now get the actual tables */
Status = AcpiGetTable (ACPI_SIG_UEFI, 1, &Table);
AE_CHECK_OK (AcpiGetTable, Status);
Status = AcpiGetTable (ACPI_SIG_UEFI, 2, &Table);
AE_CHECK_OK (AcpiGetTable, Status);
Status = AcpiGetTable (ACPI_SIG_UEFI, 3, &Table);
AE_CHECK_STATUS (AcpiGetTable, Status, AE_NOT_FOUND);
return (AE_OK);
}
ACPI_STATUS
AeInstallLateHandlers (
void)
{
ACPI_STATUS Status;
#if (!ACPI_REDUCED_HARDWARE)
if (!AcpiGbl_ReducedHardware)
{
/* Install a user SCI handler */
Status = AeInstallSciHandler ();
AE_CHECK_OK (AeInstallSciHandler, Status);
/* Install some fixed event handlers */
Status = AcpiInstallFixedEventHandler (ACPI_EVENT_GLOBAL, AeEventHandler, NULL);
AE_CHECK_OK (AcpiInstallFixedEventHandler, Status);
Status = AcpiInstallFixedEventHandler (ACPI_EVENT_RTC, AeEventHandler, NULL);
AE_CHECK_OK (AcpiInstallFixedEventHandler, Status);
}
#endif /* !ACPI_REDUCED_HARDWARE */
AeMyContext.Connection = NULL;
AeMyContext.AccessLength = 0xA5;
/*
* We will install a handler for each EC device, directly under the EC
* device definition. This is unlike the other handlers which we install
* at the root node. Also install memory and I/O handlers at any PCI
* devices.
*/
AeInstallDeviceHandlers ();
/*
* Install handlers for some of the "device driver" address spaces
* such as SMBus, etc.
*/
AeInstallRegionHandlers ();
return (AE_OK);
}
int ACPI_SYSTEM_XFACE
main (
int argc,
char **argv)
{
ACPI_STATUS Status;
int j;
ACPI_DEBUG_INITIALIZE (); /* For debug version only */
/* Init debug globals and ACPICA */
AcpiDbgLevel = ACPI_LV_TABLES;
AcpiDbgLayer = 0xFFFFFFFF;
Status = AcpiInitializeSubsystem ();
AE_CHECK_OK (AcpiInitializeSubsystem, Status);
if (ACPI_FAILURE (Status))
{
return (-1);
}
printf (ACPI_COMMON_SIGNON (AN_UTILITY_NAME));
if (argc < 2)
{
usage ();
return (0);
}
/* Get the command line options */
while ((j = AcpiGetopt (argc, argv, AN_SUPPORTED_OPTIONS)) != ACPI_OPT_END) switch(j)
{
case 'v': /* -v: (Version): signon already emitted, just exit */
return (0);
case '?':
case 'h':
default:
usage();
return (0);
}
/*
* The next argument is the filename for the DSDT or SSDT.
* Open the file, build namespace and dump it.
*/
return (NsDumpEntireNamespace (argv[AcpiGbl_Optind]));
}
ACPI_STATUS
AeInstallTables (
void)
{
ACPI_STATUS Status;
Status = AcpiInitializeTables (Tables, ACPI_MAX_INIT_TABLES, TRUE);
AE_CHECK_OK (AcpiInitializeTables, Status);
Status = AcpiReallocateRootTable ();
AE_CHECK_OK (AcpiReallocateRootTable, Status);
Status = AcpiLoadTables ();
AE_CHECK_OK (AcpiLoadTables, Status);
/*
* Test run-time control method installation. Do it twice to test code
* for an existing name.
*/
Status = AcpiInstallMethod (MethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install method\n",
AcpiFormatException (Status));
}
Status = AcpiInstallMethod (MethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install method\n",
AcpiFormatException (Status));
}
return (AE_OK);
}
static void
AeMutexInterfaces (
void)
{
ACPI_STATUS Status;
ACPI_HANDLE MutexHandle;
/* Get a handle to an AML mutex */
Status = AcpiGetHandle (NULL, "\\MTX1", &MutexHandle);
if (Status == AE_NOT_FOUND)
{
return;
}
AE_CHECK_OK (AcpiGetHandle, Status);
if (ACPI_FAILURE (Status))
{
return;
}
/* Acquire the mutex */
Status = AcpiAcquireMutex (NULL, "\\MTX1", 0xFFFF);
AE_CHECK_OK (AcpiAcquireMutex, Status);
if (ACPI_FAILURE (Status))
{
return;
}
/* Release mutex with different parameters */
Status = AcpiReleaseMutex (MutexHandle, NULL);
AE_CHECK_OK (AcpiReleaseMutex, Status);
}
static void
AeHardwareInterfaces (
void)
{
#if (!ACPI_REDUCED_HARDWARE)
ACPI_STATUS Status;
UINT32 Value;
/* If Hardware Reduced flag is set, we are all done */
if (AcpiGbl_ReducedHardware)
{
return;
}
Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, 1);
AE_CHECK_OK (AcpiWriteBitRegister, Status);
Status = AcpiWriteBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, 1);
AE_CHECK_OK (AcpiWriteBitRegister, Status);
Status = AcpiWriteBitRegister (ACPI_BITREG_SLEEP_ENABLE, 1);
AE_CHECK_OK (AcpiWriteBitRegister, Status);
Status = AcpiWriteBitRegister (ACPI_BITREG_ARB_DISABLE, 1);
AE_CHECK_OK (AcpiWriteBitRegister, Status);
Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &Value);
AE_CHECK_OK (AcpiReadBitRegister, Status);
Status = AcpiReadBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, &Value);
AE_CHECK_OK (AcpiReadBitRegister, Status);
Status = AcpiReadBitRegister (ACPI_BITREG_SLEEP_ENABLE, &Value);
AE_CHECK_OK (AcpiReadBitRegister, Status);
Status = AcpiReadBitRegister (ACPI_BITREG_ARB_DISABLE, &Value);
AE_CHECK_OK (AcpiReadBitRegister, Status);
#endif /* !ACPI_REDUCED_HARDWARE */
}
int ACPI_SYSTEM_XFACE
main (
int argc,
char **argv)
{
ACPI_STATUS Status;
int j;
printf (ACPI_COMMON_SIGNON ("ACPI Namespace Dump Utility"));
if (argc < 2)
{
usage ();
return (0);
}
/* Init globals and ACPICA */
AcpiDbgLevel = ACPI_NORMAL_DEFAULT | ACPI_LV_TABLES;
AcpiDbgLayer = 0xFFFFFFFF;
Status = AcpiInitializeSubsystem ();
AE_CHECK_OK (AcpiInitializeSubsystem, Status);
/* Get the command line options */
while ((j = AcpiGetopt (argc, argv, AE_SUPPORTED_OPTIONS)) != EOF) switch(j)
{
case '?':
case 'h':
default:
usage();
return (0);
}
/*
* The next argument is the filename for the DSDT or SSDT.
* Open the file, build namespace and dump it.
*/
return (NsDumpEntireNamespace (argv[AcpiGbl_Optind]));
}
ACPI_STATUS
AeInstallEarlyHandlers (
void)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_HANDLE Handle;
ACPI_FUNCTION_ENTRY ();
Status = AcpiInstallInterfaceHandler (AeInterfaceHandler);
if (ACPI_FAILURE (Status))
{
printf ("Could not install interface handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallTableHandler (AeTableHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install table handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallExceptionHandler (AeExceptionHandler);
if (ACPI_FAILURE (Status))
{
printf ("Could not install exception handler, %s\n",
AcpiFormatException (Status));
}
/* Install global notify handlers */
Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
AeSystemNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a global system notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_DEVICE_NOTIFY,
AeDeviceNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a global notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler1, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiRemoveNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler1);
if (ACPI_FAILURE (Status))
{
printf ("Could not remove a notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler1, NULL);
AE_CHECK_OK (AcpiInstallNotifyHandler, Status);
Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler1);
AE_CHECK_OK (AcpiRemoveNotifyHandler, Status);
#if 0
Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler1, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a notify handler, %s\n",
AcpiFormatException (Status));
}
#endif
/* Install two handlers for _SB_ */
Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));
Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));
/* Attempt duplicate handler installation, should fail */
Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler1, ACPI_CAST_PTR (void, 0x77777777));
Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
AE_CHECK_OK (AcpiAttachData, Status);
Status = AcpiDetachData (Handle, AeAttachedDataHandler);
AE_CHECK_OK (AcpiDetachData, Status);
/* Test attach data at the root object */
Status = AcpiAttachData (ACPI_ROOT_OBJECT, AeAttachedDataHandler,
AcpiGbl_RootNode);
AE_CHECK_OK (AcpiAttachData, Status);
Status = AcpiAttachData (ACPI_ROOT_OBJECT, AeAttachedDataHandler2,
AcpiGbl_RootNode);
AE_CHECK_OK (AcpiAttachData, Status);
/* Test support for multiple attaches */
Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
AE_CHECK_OK (AcpiAttachData, Status);
Status = AcpiAttachData (Handle, AeAttachedDataHandler2, Handle);
AE_CHECK_OK (AcpiAttachData, Status);
}
else
{
int ACPI_SYSTEM_XFACE
main (
int argc,
char **argv)
{
int j;
ACPI_STATUS Status;
UINT32 InitFlags;
ACPI_TABLE_HEADER *Table = NULL;
UINT32 TableCount;
AE_TABLE_DESC *TableDesc;
char **WildcardList;
char *Filename;
char *Directory;
char *FullPathname;
#ifdef _DEBUG
_CrtSetDbgFlag (_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF |
_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
#endif
printf (ACPI_COMMON_SIGNON ("AML Execution/Debug Utility"));
if (argc < 2)
{
usage ();
return (0);
}
signal (SIGINT, AeCtrlCHandler);
/* Init globals */
AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
AcpiDbgLayer = 0xFFFFFFFF;
/* Init ACPI and start debugger thread */
Status = AcpiInitializeSubsystem ();
AE_CHECK_OK (AcpiInitializeSubsystem, Status);
/* Get the command line options */
while ((j = AcpiGetopt (argc, argv, AE_SUPPORTED_OPTIONS)) != EOF) switch(j)
{
case 'b':
if (strlen (AcpiGbl_Optarg) > 127)
{
printf ("**** The length of command line (%u) exceeded maximum (127)\n",
(UINT32) strlen (AcpiGbl_Optarg));
return (-1);
}
AcpiGbl_BatchMode = 1;
strcpy (BatchBuffer, AcpiGbl_Optarg);
break;
case 'd':
switch (AcpiGbl_Optarg[0])
{
case 'a':
AcpiGbl_IgnoreErrors = TRUE;
break;
case 'i':
AcpiGbl_DbOpt_ini_methods = FALSE;
break;
case 'o':
AcpiGbl_DbOpt_NoRegionSupport = TRUE;
break;
case 'r':
AcpiGbl_DisableAutoRepair = TRUE;
break;
case 't':
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
AcpiGbl_DisableMemTracking = TRUE;
#endif
break;
default:
printf ("Unknown option: -d%s\n", AcpiGbl_Optarg);
return (-1);
}
break;
case 'e':
switch (AcpiGbl_Optarg[0])
{
case 'f':
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
AcpiGbl_DisplayFinalMemStats = TRUE;
#endif
break;
case 'm':
AcpiGbl_AllMethodsSerialized = TRUE;
printf ("Enabling AML Interpreter serialized mode\n");
break;
case 's':
AcpiGbl_EnableInterpreterSlack = TRUE;
printf ("Enabling AML Interpreter slack mode\n");
break;
case 't':
AcpiGbl_DebugTimeout = TRUE;
break;
default:
printf ("Unknown option: -e%s\n", AcpiGbl_Optarg);
return (-1);
}
break;
case 'f':
AcpiGbl_RegionFillValue = (UINT8) strtoul (AcpiGbl_Optarg, NULL, 0);
break;
case 'g':
AcpiGbl_DbOpt_tables = TRUE;
AcpiGbl_DbFilename = NULL;
break;
case 'm':
AcpiGbl_BatchMode = 2;
switch (AcpiGbl_Optarg[0])
{
case '^':
strcpy (BatchBuffer, "MAIN");
break;
default:
strcpy (BatchBuffer, AcpiGbl_Optarg);
break;
}
break;
case 'o':
AcpiGbl_DbOpt_disasm = TRUE;
AcpiGbl_DbOpt_stats = TRUE;
break;
case 'v':
AcpiDbgLevel |= ACPI_LV_INIT_NAMES;
break;
case 'x':
AcpiDbgLevel = strtoul (AcpiGbl_Optarg, NULL, 0);
AcpiGbl_DbConsoleDebugLevel = AcpiDbgLevel;
printf ("Debug Level: 0x%8.8X\n", AcpiDbgLevel);
break;
case '?':
case 'h':
default:
usage();
return (-1);
}
InitFlags = (ACPI_NO_HANDLER_INIT | ACPI_NO_ACPI_ENABLE);
if (!AcpiGbl_DbOpt_ini_methods)
{
InitFlags |= (ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT);
}
/* The remaining arguments are filenames for ACPI tables */
if (argv[AcpiGbl_Optind])
{
AcpiGbl_DbOpt_tables = TRUE;
TableCount = 0;
/* Get each of the ACPI table files on the command line */
while (argv[AcpiGbl_Optind])
{
/* Split incoming path into a directory/filename combo */
Status = FlSplitInputPathname (argv[AcpiGbl_Optind], &Directory, &Filename);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Expand wildcards (Windows only) */
WildcardList = AsDoWildcard (Directory, Filename);
if (!WildcardList)
{
return (-1);
}
while (*WildcardList)
{
FullPathname = AcpiOsAllocate (
strlen (Directory) + strlen (*WildcardList) + 1);
/* Construct a full path to the file */
strcpy (FullPathname, Directory);
strcat (FullPathname, *WildcardList);
/* Get one table */
Status = AcpiDbReadTableFromFile (FullPathname, &Table);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not get input table %s, %s\n", FullPathname,
AcpiFormatException (Status));
goto enterloop;
}
AcpiOsFree (FullPathname);
AcpiOsFree (*WildcardList);
*WildcardList = NULL;
WildcardList++;
/*
* Ignore an FACS or RSDT, we can't use them.
*/
if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS) ||
ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_RSDT))
{
AcpiOsFree (Table);
continue;
}
/* Allocate and link a table descriptor */
TableDesc = AcpiOsAllocate (sizeof (AE_TABLE_DESC));
TableDesc->Table = Table;
TableDesc->Next = AeTableListHead;
AeTableListHead = TableDesc;
TableCount++;
}
AcpiGbl_Optind++;
}
/* Build a local RSDT with all tables and let ACPICA process the RSDT */
Status = AeBuildLocalTables (TableCount, AeTableListHead);
if (ACPI_FAILURE (Status))
{
return (-1);
}
Status = AeInstallTables ();
if (ACPI_FAILURE (Status))
{
printf ("**** Could not load ACPI tables, %s\n", AcpiFormatException (Status));
goto enterloop;
}
/*
* Install most of the handlers.
* Override some default region handlers, especially SystemMemory
*/
Status = AeInstallEarlyHandlers ();
if (ACPI_FAILURE (Status))
{
goto enterloop;
}
/*
* TBD: Need a way to call this after the "LOAD" command
*/
Status = AcpiEnableSubsystem (InitFlags);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not EnableSubsystem, %s\n", AcpiFormatException (Status));
goto enterloop;
}
Status = AcpiInitializeObjects (InitFlags);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not InitializeObjects, %s\n", AcpiFormatException (Status));
goto enterloop;
}
/*
* Install handlers for "device driver" space IDs (EC,SMBus, etc.)
* and fixed event handlers
*/
AeInstallLateHandlers ();
AeMiscellaneousTests ();
}
enterloop:
if (AcpiGbl_BatchMode == 1)
{
AcpiDbRunBatchMode ();
}
else if (AcpiGbl_BatchMode == 2)
{
AcpiDbExecute (BatchBuffer, NULL, NULL, EX_NO_SINGLE_STEP);
}
else
{
/* Enter the debugger command loop */
AcpiDbUserCommands (ACPI_DEBUGGER_COMMAND_PROMPT, NULL);
}
return (0);
}
void
AeMiscellaneousTests (
void)
{
ACPI_BUFFER ReturnBuf;
char Buffer[32];
ACPI_STATUS Status;
ACPI_STATISTICS Stats;
ACPI_HANDLE Handle;
#if (!ACPI_REDUCED_HARDWARE)
ACPI_VENDOR_UUID Uuid = {0, {ACPI_INIT_UUID (0,0,0,0,0,0,0,0,0,0,0)}};
UINT32 LockHandle1;
UINT32 LockHandle2;
#endif /* !ACPI_REDUCED_HARDWARE */
Status = AcpiGetHandle (NULL, "\\", &Handle);
AE_CHECK_OK (AcpiGetHandle, Status);
if (AcpiGbl_DoInterfaceTests)
{
/*
* Tests for AcpiLoadTable and AcpiUnloadParentTable
*/
/* Attempt unload of DSDT, should fail */
Status = AcpiGetHandle (NULL, "\\_SB_", &Handle);
AE_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
AE_CHECK_STATUS (AcpiUnloadParentTable, Status, AE_TYPE);
/* Load and unload SSDT4 */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code);
AE_CHECK_OK (AcpiLoadTable, Status);
Status = AcpiGetHandle (NULL, "\\_T96", &Handle);
AE_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
AE_CHECK_OK (AcpiUnloadParentTable, Status);
/* Re-load SSDT4 */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code);
AE_CHECK_OK (AcpiLoadTable, Status);
/* Unload and re-load SSDT2 (SSDT2 is in the XSDT) */
Status = AcpiGetHandle (NULL, "\\_T99", &Handle);
AE_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
AE_CHECK_OK (AcpiUnloadParentTable, Status);
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt2Code);
AE_CHECK_OK (AcpiLoadTable, Status);
/* Load OEM9 table (causes table override) */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt3Code);
AE_CHECK_OK (AcpiLoadTable, Status);
}
AeHardwareInterfaces ();
AeGenericRegisters ();
AeSetupConfiguration (Ssdt3Code);
AeTestBufferArgument();
AeTestPackageArgument ();
AeMutexInterfaces ();
/* Test _OSI install/remove */
Status = AcpiInstallInterface ("");
AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_BAD_PARAMETER);
Status = AcpiInstallInterface ("TestString");
AE_CHECK_OK (AcpiInstallInterface, Status);
Status = AcpiInstallInterface ("TestString");
AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_ALREADY_EXISTS);
Status = AcpiRemoveInterface ("Windows 2006");
AE_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("TestString");
AE_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("XXXXXX");
AE_CHECK_STATUS (AcpiRemoveInterface, Status, AE_NOT_EXIST);
Status = AcpiInstallInterface ("AnotherTestString");
AE_CHECK_OK (AcpiInstallInterface, Status);
/* Test _OSI execution */
Status = ExecuteOSI ("Extended Address Space Descriptor", 0xFFFFFFFF);
AE_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("Windows 2001", 0xFFFFFFFF);
AE_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("MichiganTerminalSystem", 0);
AE_CHECK_OK (ExecuteOSI, Status);
ReturnBuf.Length = 32;
ReturnBuf.Pointer = Buffer;
Status = AcpiGetName (ACPI_ROOT_OBJECT, ACPI_FULL_PATHNAME, &ReturnBuf);
AE_CHECK_OK (AcpiGetName, Status);
/* Get Devices */
Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL);
AE_CHECK_OK (AcpiGetDevices, Status);
Status = AcpiGetStatistics (&Stats);
AE_CHECK_OK (AcpiGetStatistics, Status);
#if (!ACPI_REDUCED_HARDWARE)
Status = AcpiInstallGlobalEventHandler (AeGlobalEventHandler, NULL);
AE_CHECK_OK (AcpiInstallGlobalEventHandler, Status);
/* If Hardware Reduced flag is set, we are all done */
if (AcpiGbl_ReducedHardware)
{
return;
}
Status = AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0);
AE_CHECK_OK (AcpiEnableEvent, Status);
/*
* GPEs: Handlers, enable/disable, etc.
*/
Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler);
AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE);
AE_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE);
AE_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 1, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 1);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 2, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 2);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 3, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 4, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 5, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
AE_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 5);
AE_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetGpeWakeMask (NULL, 5, ACPI_GPE_ENABLE);
AE_CHECK_OK (AcpiSetGpeWakeMask, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 6);
AE_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetupGpeForWake (ACPI_ROOT_OBJECT, NULL, 6);
AE_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 9);
AE_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiInstallGpeHandler (NULL, 0x19, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x19);
AE_CHECK_OK (AcpiEnableGpe, Status);
/* GPE block 1 */
Status = AcpiInstallGpeHandler (NULL, 101, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 101);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiDisableGpe (NULL, 101);
AE_CHECK_OK (AcpiDisableGpe, Status);
AfInstallGpeBlock ();
/* Here is where the GPEs are actually "enabled" */
Status = AcpiUpdateAllGpes ();
AE_CHECK_OK (AcpiUpdateAllGpes, Status);
Status = AcpiGetHandle (NULL, "RSRC", &Handle);
if (ACPI_SUCCESS (Status))
{
ReturnBuf.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiGetVendorResource (Handle, "_CRS", &Uuid, &ReturnBuf);
if (ACPI_SUCCESS (Status))
{
AcpiOsFree (ReturnBuf.Pointer);
}
}
/* Test global lock */
Status = AcpiAcquireGlobalLock (0xFFFF, &LockHandle1);
AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiAcquireGlobalLock (0x5, &LockHandle2);
AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle1);
AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle2);
AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
#endif /* !ACPI_REDUCED_HARDWARE */
}
static int
NsDumpEntireNamespace (
char *AmlFilename)
{
ACPI_STATUS Status;
ACPI_TABLE_HEADER *Table = NULL;
UINT32 TableCount = 0;
AE_TABLE_DESC *TableDesc;
ACPI_HANDLE Handle;
/* Open the binary AML file and read the entire table */
Status = AcpiUtReadTableFromFile (AmlFilename, &Table);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not get input table %s, %s\n", AmlFilename,
AcpiFormatException (Status));
return (-1);
}
/* Table must be a DSDT. SSDTs are not currently supported */
if (!ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_DSDT))
{
printf ("**** Input table signature is [%4.4s], must be [DSDT]\n",
Table->Signature);
return (-1);
}
/*
* Allocate and link a table descriptor (allows for future expansion to
* multiple input files)
*/
TableDesc = AcpiOsAllocate (sizeof (AE_TABLE_DESC));
TableDesc->Table = Table;
TableDesc->Next = AeTableListHead;
AeTableListHead = TableDesc;
TableCount++;
/*
* Build a local XSDT with all tables. Normally, here is where the
* RSDP search is performed to find the ACPI tables
*/
Status = AeBuildLocalTables (TableCount, AeTableListHead);
if (ACPI_FAILURE (Status))
{
return (-1);
}
/* Initialize table manager, get XSDT */
Status = AcpiInitializeTables (Tables, ACPI_MAX_INIT_TABLES, TRUE);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not initialize ACPI table manager, %s\n",
AcpiFormatException (Status));
return (-1);
}
/* Reallocate root table to dynamic memory */
Status = AcpiReallocateRootTable ();
if (ACPI_FAILURE (Status))
{
printf ("**** Could not reallocate root table, %s\n",
AcpiFormatException (Status));
return (-1);
}
/* Load the ACPI namespace */
Status = AcpiLoadTables ();
if (ACPI_FAILURE (Status))
{
printf ("**** Could not load ACPI tables, %s\n",
AcpiFormatException (Status));
return (-1);
}
/*
* Enable ACPICA. These calls don't do much for this
* utility, since we only dump the namespace. There is no
* hardware or event manager code underneath.
*/
Status = AcpiEnableSubsystem (
ACPI_NO_ACPI_ENABLE |
ACPI_NO_ADDRESS_SPACE_INIT |
ACPI_NO_EVENT_INIT |
ACPI_NO_HANDLER_INIT);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not EnableSubsystem, %s\n",
AcpiFormatException (Status));
return (-1);
}
Status = AcpiInitializeObjects (
ACPI_NO_ADDRESS_SPACE_INIT |
ACPI_NO_DEVICE_INIT |
ACPI_NO_EVENT_INIT);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not InitializeObjects, %s\n",
AcpiFormatException (Status));
return (-1);
}
/*
* Perform a namespace walk to dump the contents
*/
AcpiOsPrintf ("\nACPI Namespace:\n");
AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, ACPI_UINT32_MAX,
ACPI_OWNER_ID_MAX, AcpiGbl_RootNode);
/* Example: get a handle to the _GPE scope */
Status = AcpiGetHandle (NULL, "\\_GPE", &Handle);
AE_CHECK_OK (AcpiGetHandle, Status);
return (0);
}
static void
AfInstallGpeBlock (
void)
{
ACPI_STATUS Status;
ACPI_HANDLE Handle;
ACPI_GENERIC_ADDRESS BlockAddress;
ACPI_HANDLE GpeDevice;
ACPI_OBJECT_TYPE Type;
/* _GPE should always exist */
Status = AcpiGetHandle (NULL, "\\_GPE", &Handle);
AE_CHECK_OK (AcpiGetHandle, Status);
if (ACPI_FAILURE (Status))
{
return;
}
ACPI_MEMSET (&BlockAddress, 0, sizeof (ACPI_GENERIC_ADDRESS));
BlockAddress.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY;
BlockAddress.Address = 0x76540000;
/* Attempt to install a GPE block on GPE2 (if present) */
Status = AcpiGetHandle (NULL, "\\GPE2", &Handle);
if (ACPI_SUCCESS (Status))
{
Status = AcpiGetType (Handle, &Type);
if (ACPI_FAILURE (Status) ||
(Type != ACPI_TYPE_DEVICE))
{
return;
}
Status = AcpiInstallGpeBlock (Handle, &BlockAddress, 7, 8);
AE_CHECK_OK (AcpiInstallGpeBlock, Status);
Status = AcpiInstallGpeHandler (Handle, 8,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (Handle, 8);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiGetGpeDevice (0x30, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (0x42, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount-1, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount, &GpeDevice);
AE_CHECK_STATUS (AcpiGetGpeDevice, Status, AE_NOT_EXIST);
Status = AcpiRemoveGpeHandler (Handle, 8, AeGpeHandler);
AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
}
/* Attempt to install a GPE block on GPE3 (if present) */
Status = AcpiGetHandle (NULL, "\\GPE3", &Handle);
if (ACPI_SUCCESS (Status))
{
Status = AcpiGetType (Handle, &Type);
if (ACPI_FAILURE (Status) ||
(Type != ACPI_TYPE_DEVICE))
{
return;
}
Status = AcpiInstallGpeBlock (Handle, &BlockAddress, 8, 11);
AE_CHECK_OK (AcpiInstallGpeBlock, Status);
}
}
int ACPI_SYSTEM_XFACE
main (
int argc,
char **argv)
{
ACPI_STATUS Status;
UINT32 InitFlags;
ACPI_TABLE_HEADER *Table = NULL;
UINT32 TableCount;
AE_TABLE_DESC *TableDesc;
ACPI_DEBUG_INITIALIZE (); /* For debug version only */
signal (SIGINT, AeCtrlCHandler);
/* Init debug globals */
AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
AcpiDbgLayer = 0xFFFFFFFF;
/* Init ACPICA and start debugger thread */
Status = AcpiInitializeSubsystem ();
AE_CHECK_OK (AcpiInitializeSubsystem, Status);
if (ACPI_FAILURE (Status))
{
goto ErrorExit;
}
printf (ACPI_COMMON_SIGNON (ACPIEXEC_NAME));
if (argc < 2)
{
usage ();
(void) AcpiOsTerminate ();
return (0);
}
/* Get the command line options */
if (AeDoOptions (argc, argv))
{
goto ErrorExit;
}
/* The remaining arguments are filenames for ACPI tables */
if (!argv[AcpiGbl_Optind])
{
goto EnterDebugger;
}
AcpiGbl_DbOpt_tables = TRUE;
AcpiGbl_CstyleDisassembly = FALSE; /* Not supported for AcpiExec */
TableCount = 0;
/* Get each of the ACPI table files on the command line */
while (argv[AcpiGbl_Optind])
{
/* Get one entire table */
Status = AcpiUtReadTableFromFile (argv[AcpiGbl_Optind], &Table);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not get table from file %s, %s\n",
argv[AcpiGbl_Optind], AcpiFormatException (Status));
goto ErrorExit;
}
/* Ignore non-AML tables, we can't use them. Except for an FADT */
if (!ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FADT) &&
!AcpiUtIsAmlTable (Table))
{
ACPI_INFO ((AE_INFO,
"Table [%4.4s] is not an AML table, ignoring",
Table->Signature));
AcpiOsFree (Table);
}
else
{
/* Allocate and link a table descriptor */
TableDesc = AcpiOsAllocate (sizeof (AE_TABLE_DESC));
TableDesc->Table = Table;
TableDesc->Next = AeTableListHead;
AeTableListHead = TableDesc;
TableCount++;
}
AcpiGbl_Optind++;
}
printf ("\n");
/* Build a local RSDT with all tables and let ACPICA process the RSDT */
Status = AeBuildLocalTables (TableCount, AeTableListHead);
if (ACPI_FAILURE (Status))
{
goto ErrorExit;
}
Status = AeInstallTables ();
if (ACPI_FAILURE (Status))
{
printf ("**** Could not load ACPI tables, %s\n",
AcpiFormatException (Status));
goto EnterDebugger;
}
/*
* Install most of the handlers.
* Override some default region handlers, especially SystemMemory
*/
Status = AeInstallEarlyHandlers ();
if (ACPI_FAILURE (Status))
{
goto EnterDebugger;
}
/* Setup initialization flags for ACPICA */
InitFlags = (ACPI_NO_HANDLER_INIT | ACPI_NO_ACPI_ENABLE);
if (!AcpiGbl_DbOpt_ini_methods)
{
InitFlags |= (ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT);
}
/*
* Main initialization for ACPICA subsystem
* TBD: Need a way to call this after the ACPI table "LOAD" command
*/
Status = AcpiEnableSubsystem (InitFlags);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not EnableSubsystem, %s\n",
AcpiFormatException (Status));
goto EnterDebugger;
}
/*
* Install handlers for "device driver" space IDs (EC,SMBus, etc.)
* and fixed event handlers
*/
AeInstallLateHandlers ();
/* Finish the ACPICA initialization */
Status = AcpiInitializeObjects (InitFlags);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not InitializeObjects, %s\n",
AcpiFormatException (Status));
goto EnterDebugger;
}
AeMiscellaneousTests ();
EnterDebugger:
/* Exit if error above and we are in one of the batch modes */
if (ACPI_FAILURE (Status) && (AcpiGbl_ExecutionMode > 0))
{
goto ErrorExit;
}
/* Run a batch command or enter the command loop */
switch (AcpiGbl_ExecutionMode)
{
default:
case AE_MODE_COMMAND_LOOP:
AcpiDbUserCommands (ACPI_DEBUGGER_COMMAND_PROMPT, NULL);
break;
case AE_MODE_BATCH_MULTIPLE:
AcpiDbRunBatchMode ();
break;
case AE_MODE_BATCH_SINGLE:
AcpiDbExecute (BatchBuffer, NULL, NULL, EX_NO_SINGLE_STEP);
Status = AcpiTerminate ();
break;
}
return (0);
ErrorExit:
(void) AcpiOsTerminate ();
return (-1);
}
int ACPI_SYSTEM_XFACE
main (
int argc,
char **argv)
{
ACPI_STATUS Status;
UINT32 InitFlags;
ACPI_TABLE_HEADER *Table = NULL;
UINT32 TableCount;
AE_TABLE_DESC *TableDesc;
char **WildcardList;
char *Filename;
char *Directory;
char *FullPathname;
#ifdef _DEBUG
_CrtSetDbgFlag (_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF |
_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
#endif
printf (ACPI_COMMON_SIGNON ("AML Execution/Debug Utility"));
if (argc < 2)
{
usage ();
return (0);
}
signal (SIGINT, AeCtrlCHandler);
/* Init globals */
AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
AcpiDbgLayer = 0xFFFFFFFF;
/* Init ACPI and start debugger thread */
Status = AcpiInitializeSubsystem ();
AE_CHECK_OK (AcpiInitializeSubsystem, Status);
if (ACPI_FAILURE (Status))
{
return (-1);
}
/* Get the command line options */
if (AeDoOptions (argc, argv))
{
return (-1);
}
/* The remaining arguments are filenames for ACPI tables */
if (argv[AcpiGbl_Optind])
{
AcpiGbl_DbOpt_tables = TRUE;
TableCount = 0;
/* Get each of the ACPI table files on the command line */
while (argv[AcpiGbl_Optind])
{
/* Split incoming path into a directory/filename combo */
Status = FlSplitInputPathname (argv[AcpiGbl_Optind],
&Directory, &Filename);
if (ACPI_FAILURE (Status))
{
return (-1);
}
/* Expand wildcards (Windows only) */
WildcardList = AsDoWildcard (Directory, Filename);
if (!WildcardList)
{
return (-1);
}
while (*WildcardList)
{
FullPathname = AcpiOsAllocate (
strlen (Directory) + strlen (*WildcardList) + 1);
/* Construct a full path to the file */
strcpy (FullPathname, Directory);
strcat (FullPathname, *WildcardList);
/* Get one table */
Status = AcpiDbReadTableFromFile (FullPathname, &Table);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not get input table %s, %s\n",
FullPathname, AcpiFormatException (Status));
goto EnterDebugger;
}
AcpiOsFree (FullPathname);
AcpiOsFree (*WildcardList);
*WildcardList = NULL;
WildcardList++;
/* Ignore non-AML tables, we can't use them. Except for an FADT */
if (!ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FADT) &&
!AcpiUtIsAmlTable (Table))
{
ACPI_WARNING ((AE_INFO,
"Table %4.4s is not an AML table, ignoring",
Table->Signature));
AcpiOsFree (Table);
continue;
}
/* Allocate and link a table descriptor */
TableDesc = AcpiOsAllocate (sizeof (AE_TABLE_DESC));
TableDesc->Table = Table;
TableDesc->Next = AeTableListHead;
AeTableListHead = TableDesc;
TableCount++;
}
AcpiGbl_Optind++;
}
/* Build a local RSDT with all tables and let ACPICA process the RSDT */
Status = AeBuildLocalTables (TableCount, AeTableListHead);
if (ACPI_FAILURE (Status))
{
return (-1);
}
Status = AeInstallTables ();
if (ACPI_FAILURE (Status))
{
printf ("**** Could not load ACPI tables, %s\n",
AcpiFormatException (Status));
goto EnterDebugger;
}
/*
* Install most of the handlers.
* Override some default region handlers, especially SystemMemory
*/
Status = AeInstallEarlyHandlers ();
if (ACPI_FAILURE (Status))
{
goto EnterDebugger;
}
/* Setup initialization flags for ACPICA */
InitFlags = (ACPI_NO_HANDLER_INIT | ACPI_NO_ACPI_ENABLE);
if (!AcpiGbl_DbOpt_ini_methods)
{
InitFlags |= (ACPI_NO_DEVICE_INIT | ACPI_NO_OBJECT_INIT);
}
/*
* Main initialization for ACPICA subsystem
* TBD: Need a way to call this after the ACPI table "LOAD" command
*/
Status = AcpiEnableSubsystem (InitFlags);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not EnableSubsystem, %s\n",
AcpiFormatException (Status));
goto EnterDebugger;
}
Status = AcpiInitializeObjects (InitFlags);
if (ACPI_FAILURE (Status))
{
printf ("**** Could not InitializeObjects, %s\n",
AcpiFormatException (Status));
goto EnterDebugger;
}
/*
* Install handlers for "device driver" space IDs (EC,SMBus, etc.)
* and fixed event handlers
*/
AeInstallLateHandlers ();
AeMiscellaneousTests ();
}
EnterDebugger:
/* Exit if error above and we are in one of the batch modes */
if (ACPI_FAILURE (Status) && (AcpiGbl_ExecutionMode > 0))
{
return (-1);
}
/* Run a batch command or enter the command loop */
switch (AcpiGbl_ExecutionMode)
{
default:
case AE_MODE_COMMAND_LOOP:
AcpiDbUserCommands (ACPI_DEBUGGER_COMMAND_PROMPT, NULL);
break;
case AE_MODE_BATCH_MULTIPLE:
AcpiDbRunBatchMode ();
break;
case AE_MODE_BATCH_SINGLE:
AcpiDbExecute (BatchBuffer, NULL, NULL, EX_NO_SINGLE_STEP);
break;
}
return (0);
}
void
AeMiscellaneousTests (
void)
{
ACPI_HANDLE Handle;
ACPI_BUFFER ReturnBuf;
char Buffer[32];
ACPI_VENDOR_UUID Uuid = {0, {ACPI_INIT_UUID (0,0,0,0,0,0,0,0,0,0,0)}};
ACPI_STATUS Status;
UINT32 LockHandle1;
UINT32 LockHandle2;
ACPI_STATISTICS Stats;
AeHardwareInterfaces ();
AeGenericRegisters ();
AeSetupConfiguration (Ssdt3Code);
AeTestBufferArgument();
AeTestPackageArgument ();
Status = AcpiInstallInterface ("");
AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_BAD_PARAMETER);
Status = AcpiInstallInterface ("TestString");
AE_CHECK_OK (AcpiInstallInterface, Status);
Status = AcpiInstallInterface ("TestString");
AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_ALREADY_EXISTS);
Status = AcpiRemoveInterface ("Windows 2006");
AE_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("TestString");
AE_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("XXXXXX");
AE_CHECK_STATUS (AcpiRemoveInterface, Status, AE_NOT_EXIST);
Status = AcpiInstallInterface ("AnotherTestString");
AE_CHECK_OK (AcpiInstallInterface, Status);
Status = ExecuteOSI ("Windows 2001", 0xFFFFFFFF);
AE_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("MichiganTerminalSystem", 0);
AE_CHECK_OK (ExecuteOSI, Status);
ReturnBuf.Length = 32;
ReturnBuf.Pointer = Buffer;
Status = AcpiGetName (AcpiGbl_RootNode, ACPI_FULL_PATHNAME, &ReturnBuf);
AE_CHECK_OK (AcpiGetName, Status);
Status = AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0);
AE_CHECK_OK (AcpiEnableEvent, Status);
/*
* GPEs: Handlers, enable/disable, etc.
*/
Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler);
AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE);
AE_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE);
AE_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 1, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 1);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 2, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 2);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 3, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 4, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 5, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0x19, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x19);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 0x62, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x62);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiDisableGpe (NULL, 0x62);
AE_CHECK_OK (AcpiDisableGpe, Status);
AfInstallGpeBlock ();
Status = AcpiGetHandle (NULL, "RSRC", &Handle);
if (ACPI_SUCCESS (Status))
{
ReturnBuf.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiGetVendorResource (Handle, "_CRS", &Uuid, &ReturnBuf);
if (ACPI_SUCCESS (Status))
{
AcpiOsFree (ReturnBuf.Pointer);
}
}
/* Test global lock */
Status = AcpiAcquireGlobalLock (0xFFFF, &LockHandle1);
AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiAcquireGlobalLock (0x5, &LockHandle2);
AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle1);
AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle2);
AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
/* Get Devices */
Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL);
AE_CHECK_OK (AcpiGetDevices, Status);
Status = AcpiGetStatistics (&Stats);
AE_CHECK_OK (AcpiGetStatistics, Status);
}