*
* 1. Copyright Notice
*
- * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2012, Intel Corp.
* All rights reserved.
*
* 2. License
*
* 2.1. This is your license from Intel Corp. under its intellectual property
- * rights. You may have additional license terms from the party that provided
+ * rights. You may have additional license terms from the party that provided
* you this software, covering your right to use that party's intellectual
* property rights.
*
* offer to sell, and import the Covered Code and derivative works thereof
* solely to the minimum extent necessary to exercise the above copyright
* license, and in no event shall the patent license extend to any additions
- * to or modifications of the Original Intel Code. No other license or right
+ * to or modifications of the Original Intel Code. No other license or right
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* Redistribution of source code of any substantial portion of the Covered
* Code or modification with rights to further distribute source must include
* the above Copyright Notice, the above License, this list of Conditions,
- * and the following Disclaimer and Export Compliance provision. In addition,
+ * and the following Disclaimer and Export Compliance provision. In addition,
* Licensee must cause all Covered Code to which Licensee contributes to
* contain a file documenting the changes Licensee made to create that Covered
- * Code and the date of any change. Licensee must include in that file the
- * documentation of any changes made by any predecessor Licensee. Licensee
+ * Code and the date of any change. Licensee must include in that file the
+ * documentation of any changes made by any predecessor Licensee. Licensee
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* Redistribution of source code of any substantial portion of the Covered
* Code or modification without rights to further distribute source must
* include the following Disclaimer and Export Compliance provision in the
- * documentation and/or other materials provided with distribution. In
+ * documentation and/or other materials provided with distribution. In
* addition, Licensee may not authorize further sublicense of source of any
* portion of the Covered Code, and must include terms to the effect that the
* license from Licensee to its licensee is limited to the intellectual
* 4. Disclaimer and Export Compliance
*
* 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
- * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
- * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
- * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
- * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
+ * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
+ * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
+ * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
+ * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
* SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
* CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
- * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
+ * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
* SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
* LIMITED REMEDY.
*
* 4.3. Licensee shall not export, either directly or indirectly, any of this
* software or system incorporating such software without first obtaining any
* required license or other approval from the U. S. Department of Commerce or
- * any other agency or department of the United States Government. In the
+ * any other agency or department of the United States Government. In the
* event Licensee exports any such software from the United States or
* re-exports any such software from a foreign destination, Licensee shall
* ensure that the distribution and export/re-export of the software is in
/* Local prototypes */
-void
-AeNotifyHandler (
+static void
+AeNotifyHandler1 (
ACPI_HANDLE Device,
UINT32 Value,
void *Context);
-void
+static void
+AeNotifyHandler2 (
+ ACPI_HANDLE Device,
+ UINT32 Value,
+ void *Context);
+
+static void
+AeCommonNotifyHandler (
+ ACPI_HANDLE Device,
+ UINT32 Value,
+ UINT32 HandlerId);
+
+static void
AeDeviceNotifyHandler (
ACPI_HANDLE Device,
UINT32 Value,
void *Context);
-ACPI_STATUS
+static ACPI_STATUS
AeExceptionHandler (
ACPI_STATUS AmlStatus,
ACPI_NAME Name,
UINT32 AmlOffset,
void *Context);
-ACPI_STATUS
+static ACPI_STATUS
AeTableHandler (
UINT32 Event,
void *Table,
void *Context);
-ACPI_STATUS
+static ACPI_STATUS
AeRegionInit (
ACPI_HANDLE RegionHandle,
UINT32 Function,
void *HandlerContext,
void **RegionContext);
-void
+static void
AeAttachedDataHandler (
ACPI_HANDLE Object,
void *Data);
-UINT32 SigintCount = 0;
-AE_DEBUG_REGIONS AeRegions;
+static UINT32
+AeInterfaceHandler (
+ ACPI_STRING InterfaceName,
+ UINT32 Supported);
+
+#if (!ACPI_REDUCED_HARDWARE)
+static UINT32
+AeEventHandler (
+ void *Context);
+
+static char *TableEvents[] =
+{
+ "LOAD",
+ "UNLOAD",
+ "UNKNOWN"
+};
+#endif /* !ACPI_REDUCED_HARDWARE */
+
+static UINT32 SigintCount = 0;
+static AE_DEBUG_REGIONS AeRegions;
+BOOLEAN AcpiGbl_DisplayRegionAccess = FALSE;
+
+
+/*
+ * We will override some of the default region handlers, especially the
+ * SystemMemory handler, which must be implemented locally. Do not override
+ * the PCI_Config handler since we would like to exercise the default handler
+ * code. These handlers are installed "early" - before any _REG methods
+ * are executed - since they are special in the sense that tha ACPI spec
+ * declares that they must "always be available". Cannot override the
+ * DataTable region handler either -- needed for test execution.
+ */
+static ACPI_ADR_SPACE_TYPE DefaultSpaceIdList[] =
+{
+ ACPI_ADR_SPACE_SYSTEM_MEMORY,
+ ACPI_ADR_SPACE_SYSTEM_IO
+};
+
+/*
+ * We will install handlers for some of the various address space IDs.
+ * Test one user-defined address space (used by aslts.)
+ */
+#define ACPI_ADR_SPACE_USER_DEFINED1 0x80
+#define ACPI_ADR_SPACE_USER_DEFINED2 0xE4
+
+static ACPI_ADR_SPACE_TYPE SpaceIdList[] =
+{
+ ACPI_ADR_SPACE_EC,
+ ACPI_ADR_SPACE_SMBUS,
+ ACPI_ADR_SPACE_GSBUS,
+ ACPI_ADR_SPACE_GPIO,
+ ACPI_ADR_SPACE_PCI_BAR_TARGET,
+ ACPI_ADR_SPACE_IPMI,
+ ACPI_ADR_SPACE_FIXED_HARDWARE,
+ ACPI_ADR_SPACE_USER_DEFINED1,
+ ACPI_ADR_SPACE_USER_DEFINED2
+};
+
+static ACPI_CONNECTION_INFO AeMyContext;
/******************************************************************************
*
*
* RETURN: none
*
- * DESCRIPTION: Control-C handler. Abort running control method if any.
+ * DESCRIPTION: Control-C handler. Abort running control method if any.
*
*****************************************************************************/
-void __cdecl
+void ACPI_SYSTEM_XFACE
AeCtrlCHandler (
int Sig)
{
signal (SIGINT, SIG_IGN);
SigintCount++;
- AcpiOsPrintf ("Caught a ctrl-c (#%d)\n\n", SigintCount);
+ AcpiOsPrintf ("Caught a ctrl-c (#%u)\n\n", SigintCount);
if (AcpiGbl_MethodExecuting)
{
/******************************************************************************
*
- * FUNCTION: AeNotifyHandler
+ * FUNCTION: AeNotifyHandler(s)
*
* PARAMETERS: Standard notify handler parameters
*
* RETURN: Status
*
- * DESCRIPTION: System notify handler for AcpiExec utility. Used by the ASL
+ * DESCRIPTION: Notify handlers for AcpiExec utility. Used by the ASL
* test suite(s) to communicate errors and other information to
- * this utility via the Notify() operator.
+ * this utility via the Notify() operator. Tests notify handling
+ * and multiple notify handler support.
*
*****************************************************************************/
-void
-AeNotifyHandler (
- ACPI_HANDLE Device,
- UINT32 Value,
- void *Context)
+static void
+AeNotifyHandler1 (
+ ACPI_HANDLE Device,
+ UINT32 Value,
+ void *Context)
+{
+ AeCommonNotifyHandler (Device, Value, 1);
+}
+
+static void
+AeNotifyHandler2 (
+ ACPI_HANDLE Device,
+ UINT32 Value,
+ void *Context)
+{
+ AeCommonNotifyHandler (Device, Value, 2);
+}
+
+static void
+AeCommonNotifyHandler (
+ ACPI_HANDLE Device,
+ UINT32 Value,
+ UINT32 HandlerId)
{
+ char *Type;
+
+
+ Type = "Device";
+ if (Value <= ACPI_MAX_SYS_NOTIFY)
+ {
+ Type = "System";
+ }
switch (Value)
{
#endif
default:
- printf ("[AcpiExec] Received a System Notify on [%4.4s] %p Value 0x%2.2X (%s)\n",
- AcpiUtGetNodeName (Device), Device, Value,
+ printf ("[AcpiExec] Handler %u: Received a %s Notify on [%4.4s] %p Value 0x%2.2X (%s)\n",
+ HandlerId, Type, AcpiUtGetNodeName (Device), Device, Value,
AcpiUtGetNotifyName (Value));
if (AcpiGbl_DebugFile)
{
- AcpiOsPrintf ("[AcpiExec] Received a system notify, Value 0x%2.2X\n", Value);
+ AcpiOsPrintf ("[AcpiExec] Handler %u: Received a %s notify, Value 0x%2.2X\n",
+ HandlerId, Type, Value);
}
(void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);
break;
}
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AeSystemNotifyHandler
+ *
+ * PARAMETERS: Standard notify handler parameters
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: System notify handler for AcpiExec utility. Used by the ASL
+ * test suite(s) to communicate errors and other information to
+ * this utility via the Notify() operator.
+ *
+ *****************************************************************************/
+
+static void
+AeSystemNotifyHandler (
+ ACPI_HANDLE Device,
+ UINT32 Value,
+ void *Context)
+{
+
+ printf ("[AcpiExec] Global: Received a System Notify on [%4.4s] %p Value 0x%2.2X (%s)\n",
+ AcpiUtGetNodeName (Device), Device, Value,
+ AcpiUtGetNotifyName (Value));
+ if (AcpiGbl_DebugFile)
+ {
+ AcpiOsPrintf ("[AcpiExec] Global: Received a System Notify, Value 0x%2.2X\n", Value);
+ }
+ (void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);
}
*
* RETURN: Status
*
- * DESCRIPTION: Device notify handler for AcpiExec utility. Used by the ASL
+ * DESCRIPTION: Device notify handler for AcpiExec utility. Used by the ASL
* test suite(s) to communicate errors and other information to
* this utility via the Notify() operator.
*
*****************************************************************************/
-void
+static void
AeDeviceNotifyHandler (
ACPI_HANDLE Device,
UINT32 Value,
void *Context)
{
- printf ("[AcpiExec] Received a Device Notify on [%4.4s] %p Value 0x%2.2X (%s)\n",
+ printf ("[AcpiExec] Global: Received a Device Notify on [%4.4s] %p Value 0x%2.2X (%s)\n",
AcpiUtGetNodeName (Device), Device, Value,
AcpiUtGetNotifyName (Value));
if (AcpiGbl_DebugFile)
{
- AcpiOsPrintf ("[AcpiExec] Received a device notify, Value 0x%2.2X\n", Value);
+ AcpiOsPrintf ("[AcpiExec] Global: Received a Device Notify, Value 0x%2.2X\n", Value);
}
(void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);
*
*****************************************************************************/
-ACPI_STATUS
+static ACPI_STATUS
AeExceptionHandler (
ACPI_STATUS AmlStatus,
ACPI_NAME Name,
Arg[1].String.Length = ACPI_STRLEN (Exception);
Arg[2].Type = ACPI_TYPE_INTEGER;
- Arg[2].Integer.Value = ACPI_TO_INTEGER (AcpiOsGetThreadId());
+ Arg[2].Integer.Value = AcpiOsGetThreadId();
/* Setup return buffer */
*
*****************************************************************************/
-char *TableEvents[] =
-{
- "LOAD",
- "UNLOAD",
- "UNKNOWN"
-};
-
-ACPI_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;
}
- /* TBD: could dump entire table header, need a header dump routine */
+#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);
}
*
* FUNCTION: AeGpeHandler
*
- * DESCRIPTION: GPE handler for acpiexec
+ * DESCRIPTION: Common GPE handler for acpiexec
*
*****************************************************************************/
UINT32
AeGpeHandler (
+ ACPI_HANDLE GpeDevice,
+ UINT32 GpeNumber,
void *Context)
{
- AcpiOsPrintf ("Received a GPE at handler\n");
- return (0);
+ ACPI_NAMESPACE_NODE *DeviceNode = (ACPI_NAMESPACE_NODE *) GpeDevice;
+
+
+ AcpiOsPrintf ("[AcpiExec] GPE Handler received GPE%02X (GPE block %4.4s)\n",
+ GpeNumber, GpeDevice ? DeviceNode->Name.Ascii : "FADT");
+
+ return (ACPI_REENABLE_GPE);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AeGlobalEventHandler
+ *
+ * DESCRIPTION: Global GPE/Fixed event handler
+ *
+ *****************************************************************************/
+
+void
+AeGlobalEventHandler (
+ UINT32 Type,
+ ACPI_HANDLE Device,
+ UINT32 EventNumber,
+ void *Context)
+{
+ char *TypeName;
+
+
+ switch (Type)
+ {
+ case ACPI_EVENT_TYPE_GPE:
+ TypeName = "GPE";
+ break;
+
+ case ACPI_EVENT_TYPE_FIXED:
+ TypeName = "FixedEvent";
+ break;
+
+ default:
+ TypeName = "UNKNOWN";
+ break;
+ }
+
+ AcpiOsPrintf ("[AcpiExec] Global Event Handler received: Type %s Number %.2X Dev %p\n",
+ TypeName, EventNumber, Device);
}
*
*****************************************************************************/
-void
+static void
AeAttachedDataHandler (
ACPI_HANDLE Object,
void *Data)
}
+/******************************************************************************
+ *
+ * FUNCTION: AeInterfaceHandler
+ *
+ * DESCRIPTION: Handler for _OSI invocations
+ *
+ *****************************************************************************/
+
+static UINT32
+AeInterfaceHandler (
+ ACPI_STRING InterfaceName,
+ UINT32 Supported)
+{
+ ACPI_FUNCTION_NAME (AeInterfaceHandler);
+
+
+ ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
+ "Received _OSI (\"%s\"), is %ssupported\n",
+ InterfaceName, Supported == 0 ? "not " : ""));
+
+ return (Supported);
+}
+
+
+#if (!ACPI_REDUCED_HARDWARE)
+/******************************************************************************
+ *
+ * FUNCTION: AeEventHandler
+ *
+ * DESCRIPTION: Handler for Fixed Events
+ *
+ *****************************************************************************/
+
+static UINT32
+AeEventHandler (
+ void *Context)
+{
+ return (0);
+}
+#endif /* !ACPI_REDUCED_HARDWARE */
+
+
/******************************************************************************
*
* FUNCTION: AeRegionInit
*
*****************************************************************************/
-ACPI_STATUS
+static ACPI_STATUS
AeRegionInit (
ACPI_HANDLE RegionHandle,
UINT32 Function,
*/
*RegionContext = RegionHandle;
- return AE_OK;
+ return (AE_OK);
}
/******************************************************************************
*
- * FUNCTION: AeInstallHandlers
+ * FUNCTION: AeInstallLateHandlers
*
* PARAMETERS: None
*
*
*****************************************************************************/
-ACPI_ADR_SPACE_TYPE SpaceId[] = {0, 1, 2, 3, 4, 5, 6, 7, 0x80};
-#define AEXEC_NUM_REGIONS 9
+ACPI_STATUS
+AeInstallLateHandlers (
+ void)
+{
+ ACPI_STATUS Status;
+ UINT32 i;
+
+
+#if (!ACPI_REDUCED_HARDWARE)
+ if (!AcpiGbl_ReducedHardware)
+ {
+ /* 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;
+
+ /*
+ * Install handlers for some of the "device driver" address spaces
+ * such as EC, SMBus, etc.
+ */
+ for (i = 0; i < ACPI_ARRAY_LENGTH (SpaceIdList); i++)
+ {
+ /* Install handler at the root object */
+
+ Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode,
+ 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);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AeInstallEarlyHandlers
+ *
+ * PARAMETERS: None
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Install handlers for the AcpiExec utility.
+ *
+ * Notes: Don't install handler for PCI_Config, we want to use the
+ * default handler to exercise that code.
+ *
+ *****************************************************************************/
ACPI_STATUS
-AeInstallHandlers (void)
+AeInstallEarlyHandlers (
+ void)
{
ACPI_STATUS Status;
UINT32 i;
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))
{
AcpiFormatException (Status));
}
- /* Install global notify handler */
+ /* Install global notify handlers */
Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
- AeNotifyHandler, NULL);
+ AeSystemNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
- printf ("Could not install a global notify handler, %s\n",
+ printf ("Could not install a global system notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_DEVICE_NOTIFY,
- AeDeviceNotifyHandler, NULL);
+ AeDeviceNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a global notify handler, %s\n",
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
- AeNotifyHandler, NULL);
+ AeNotifyHandler1, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a notify handler, %s\n",
}
Status = AcpiRemoveNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
- AeNotifyHandler);
+ AeNotifyHandler1);
if (ACPI_FAILURE (Status))
{
printf ("Could not remove a notify handler, %s\n",
}
Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
- AeNotifyHandler, NULL);
+ AeNotifyHandler1, NULL);
+ AE_CHECK_OK (AcpiInstallNotifyHandler, Status);
+
Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
- AeNotifyHandler);
+ AeNotifyHandler1);
+ AE_CHECK_OK (AcpiRemoveNotifyHandler, Status);
+
+#if 0
Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
- AeNotifyHandler, NULL);
+ 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);
+
Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
+ AE_CHECK_OK (AcpiAttachData, Status);
}
else
{
printf ("No _SB_ found, %s\n", AcpiFormatException (Status));
}
- /* Set a handler for all supported operation regions */
- for (i = 0; i < AEXEC_NUM_REGIONS; i++)
+ Status = AcpiGetHandle (NULL, "\\_TZ.TZ1", &Handle);
+ if (ACPI_SUCCESS (Status))
{
- Status = AcpiRemoveAddressSpaceHandler (AcpiGbl_RootNode,
- SpaceId[i], AeRegionHandler);
+ Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
+ AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));
+
+ Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
+ AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));
+
+ Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
+ AeNotifyHandler1);
+ Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
+ AeNotifyHandler2);
+
+ Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
+ AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));
+
+ Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
+ AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));
+ }
+
+ Status = AcpiGetHandle (NULL, "\\_PR.CPU0", &Handle);
+ if (ACPI_SUCCESS (Status))
+ {
+ Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
+ AeNotifyHandler1, ACPI_CAST_PTR (void, 0x01234567));
+
+ Status = AcpiInstallNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
+ AeNotifyHandler2, ACPI_CAST_PTR (void, 0x89ABCDEF));
+ }
+
+ /*
+ * Install handlers that will override the default handlers for some of
+ * the space IDs.
+ */
+ for (i = 0; i < ACPI_ARRAY_LENGTH (DefaultSpaceIdList); i++)
+ {
+ /* Install handler at the root object */
- /* Install handler at the root object.
- * TBD: all default handlers should be installed here!
- */
Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode,
- SpaceId[i], AeRegionHandler, AeRegionInit, NULL);
+ DefaultSpaceIdList[i], AeRegionHandler,
+ AeRegionInit, &AeMyContext);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
- "Could not install an OpRegion handler for %s space(%d)",
- AcpiUtGetRegionName((UINT8) SpaceId[i]), SpaceId[i]));
+ "Could not install a default OpRegion handler for %s space(%u)",
+ AcpiUtGetRegionName ((UINT8) DefaultSpaceIdList[i]),
+ DefaultSpaceIdList[i]));
return (Status);
}
}
*/
AeRegions.NumberOfRegions = 0;
AeRegions.RegionList = NULL;
-
- return Status;
+ return (Status);
}
UINT32 Function,
ACPI_PHYSICAL_ADDRESS Address,
UINT32 BitWidth,
- ACPI_INTEGER *Value,
+ UINT64 *Value,
void *HandlerContext,
void *RegionContext)
{
UINT32 ByteWidth;
UINT32 i;
UINT8 SpaceId;
+ ACPI_CONNECTION_INFO *MyContext;
+ UINT32 Value1;
+ UINT32 Value2;
+ ACPI_RESOURCE *Resource;
ACPI_FUNCTION_NAME (AeRegionHandler);
*/
if (RegionObject->Region.Type != ACPI_TYPE_REGION)
{
- return AE_OK;
+ return (AE_OK);
+ }
+
+ /* Check that we actually got back our context parameter */
+
+ if (HandlerContext != &AeMyContext)
+ {
+ printf ("Region handler received incorrect context %p, should be %p\n",
+ HandlerContext, &AeMyContext);
}
+ MyContext = ACPI_CAST_PTR (ACPI_CONNECTION_INFO, HandlerContext);
+
/*
- * Region support can be disabled with the -r option.
+ * Find the region's address space and length before searching
+ * the linked list.
+ */
+ BaseAddress = RegionObject->Region.Address;
+ Length = (ACPI_SIZE) RegionObject->Region.Length;
+ SpaceId = RegionObject->Region.SpaceId;
+
+ ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, "Operation Region request on %s at 0x%X\n",
+ AcpiUtGetRegionName (RegionObject->Region.SpaceId),
+ (UINT32) Address));
+
+ /*
+ * Region support can be disabled with the -do option.
* We use this to support dynamically loaded tables where we pass a valid
* address to the AML.
*/
goto DoFunction;
}
- /*
- * Find the region's address space and length before searching
- * the linked list.
- */
- BaseAddress = RegionObject->Region.Address;
- Length = (ACPI_SIZE) RegionObject->Region.Length;
- SpaceId = RegionObject->Region.SpaceId;
-
- ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION, "Operation Region request on %s at 0x%X\n",
- AcpiUtGetRegionName (RegionObject->Region.SpaceId),
- (UINT32) Address));
-
switch (SpaceId)
{
case ACPI_ADR_SPACE_SYSTEM_IO:
/*
* For I/O space, exercise the port validation
+ * Note: ReadPort currently always returns all ones, length=BitLength
*/
switch (Function & ACPI_IO_MASK)
{
case ACPI_READ:
- Status = AcpiHwReadPort (Address, (UINT32 *) Value, BitWidth);
+
+ if (BitWidth == 64)
+ {
+ /* Split the 64-bit request into two 32-bit requests */
+
+ Status = AcpiHwReadPort (Address, &Value1, 32);
+ AE_CHECK_OK (AcpiHwReadPort, Status);
+ Status = AcpiHwReadPort (Address+4, &Value2, 32);
+ AE_CHECK_OK (AcpiHwReadPort, Status);
+
+ *Value = Value1 | ((UINT64) Value2 << 32);
+ }
+ else
+ {
+ Status = AcpiHwReadPort (Address, &Value1, BitWidth);
+ AE_CHECK_OK (AcpiHwReadPort, Status);
+ *Value = (UINT64) Value1;
+ }
break;
case ACPI_WRITE:
- Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth);
+
+ if (BitWidth == 64)
+ {
+ /* Split the 64-bit request into two 32-bit requests */
+
+ Status = AcpiHwWritePort (Address, ACPI_LODWORD (*Value), 32);
+ AE_CHECK_OK (AcpiHwWritePort, Status);
+ Status = AcpiHwWritePort (Address+4, ACPI_HIDWORD (*Value), 32);
+ AE_CHECK_OK (AcpiHwWritePort, Status);
+ }
+ else
+ {
+ Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth);
+ AE_CHECK_OK (AcpiHwWritePort, Status);
+ }
break;
default:
/* Now go ahead and simulate the hardware */
break;
-
+ /*
+ * SMBus and GenericSerialBus support the various bidirectional
+ * protocols.
+ */
case ACPI_ADR_SPACE_SMBUS:
+ case ACPI_ADR_SPACE_GSBUS: /* ACPI 5.0 */
Length = 0;
case ACPI_READ:
switch (Function >> 16)
{
- case AML_FIELD_ATTRIB_SMB_QUICK:
- case AML_FIELD_ATTRIB_SMB_SEND_RCV:
- case AML_FIELD_ATTRIB_SMB_BYTE:
+ case AML_FIELD_ATTRIB_QUICK:
+ case AML_FIELD_ATTRIB_SEND_RCV:
+ case AML_FIELD_ATTRIB_BYTE:
Length = 1;
break;
- case AML_FIELD_ATTRIB_SMB_WORD:
- case AML_FIELD_ATTRIB_SMB_WORD_CALL:
+ case AML_FIELD_ATTRIB_WORD:
+ case AML_FIELD_ATTRIB_WORD_CALL:
Length = 2;
break;
- case AML_FIELD_ATTRIB_SMB_BLOCK:
- case AML_FIELD_ATTRIB_SMB_BLOCK_CALL:
+ case AML_FIELD_ATTRIB_BLOCK:
+ case AML_FIELD_ATTRIB_BLOCK_CALL:
Length = 32;
break;
+
+ case AML_FIELD_ATTRIB_MULTIBYTE:
+ case AML_FIELD_ATTRIB_RAW_BYTES:
+ case AML_FIELD_ATTRIB_RAW_PROCESS:
+
+ /* (-2) for status/length */
+ Length = MyContext->AccessLength - 2;
+ break;
+
default:
break;
}
case ACPI_WRITE:
switch (Function >> 16)
{
- case AML_FIELD_ATTRIB_SMB_QUICK:
- case AML_FIELD_ATTRIB_SMB_SEND_RCV:
- case AML_FIELD_ATTRIB_SMB_BYTE:
- case AML_FIELD_ATTRIB_SMB_WORD:
- case AML_FIELD_ATTRIB_SMB_BLOCK:
+ case AML_FIELD_ATTRIB_QUICK:
+ case AML_FIELD_ATTRIB_SEND_RCV:
+ case AML_FIELD_ATTRIB_BYTE:
+ case AML_FIELD_ATTRIB_WORD:
+ case AML_FIELD_ATTRIB_BLOCK:
Length = 0;
break;
- case AML_FIELD_ATTRIB_SMB_WORD_CALL:
+ case AML_FIELD_ATTRIB_WORD_CALL:
Length = 2;
break;
- case AML_FIELD_ATTRIB_SMB_BLOCK_CALL:
+ case AML_FIELD_ATTRIB_BLOCK_CALL:
Length = 32;
break;
+ case AML_FIELD_ATTRIB_MULTIBYTE:
+ case AML_FIELD_ATTRIB_RAW_BYTES:
+ case AML_FIELD_ATTRIB_RAW_PROCESS:
+
+ /* (-2) for status/length */
+ Length = MyContext->AccessLength - 2;
+ break;
+
default:
break;
}
break;
}
+ if (AcpiGbl_DisplayRegionAccess)
+ {
+ AcpiOsPrintf ("AcpiExec: %s "
+ "%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X",
+ AcpiUtGetRegionName (SpaceId),
+ (Function & ACPI_IO_MASK) ? "Write" : "Read ",
+ (UINT32) (Function >> 16),
+ (UINT32) Address, (UINT32) BaseAddress,
+ Length, BitWidth, Buffer[1]);
+
+ /* GenericSerialBus has a Connection() parameter */
+
+ if (SpaceId == ACPI_ADR_SPACE_GSBUS)
+ {
+ Status = AcpiBufferToResource (MyContext->Connection,
+ MyContext->Length, &Resource);
+
+ AcpiOsPrintf (" [AccLen %.2X Conn %p]",
+ MyContext->AccessLength, MyContext->Connection);
+ }
+ AcpiOsPrintf ("\n");
+ }
+
+ /* Setup the return buffer. Note: ASLTS depends on these fill values */
+
for (i = 0; i < Length; i++)
{
Buffer[i+2] = (UINT8) (0xA0 + i);
case ACPI_ADR_SPACE_IPMI: /* ACPI 4.0 */
- AcpiOsPrintf ("AcpiExec: Received IPMI request: "
- "Address %X BaseAddress %X Length %X Width %X BufferLength %u\n",
- (UINT32) Address, (UINT32) BaseAddress,
- Length, BitWidth, Buffer[1]);
+ if (AcpiGbl_DisplayRegionAccess)
+ {
+ AcpiOsPrintf ("AcpiExec: IPMI "
+ "%s: Attr %X Addr %.4X BaseAddr %.4X Len %.2X Width %X BufLen %X\n",
+ (Function & ACPI_IO_MASK) ? "Write" : "Read ",
+ (UINT32) (Function >> 16), (UINT32) Address, (UINT32) BaseAddress,
+ Length, BitWidth, Buffer[1]);
+ }
/*
* Regardless of a READ or WRITE, this handler is passed a 66-byte
Buffer[0] = 0; /* Status byte */
Buffer[1] = 64; /* Return buffer data length */
Buffer[2] = 0; /* Completion code */
- Buffer[3] = 0x34; /* Power measurement */
- Buffer[4] = 0x12; /* Power measurement */
- Buffer[65] = 0xEE; /* last buffer byte */
+ Buffer[3] = 0; /* Reserved */
+
+ /*
+ * Fill the 66-byte buffer with the return data.
+ * Note: ASLTS depends on these fill values.
+ */
+ for (i = 4; i < 66; i++)
+ {
+ Buffer[i] = (UINT8) (i);
+ }
return (AE_OK);
default:
RegionElement = AcpiOsAllocate (sizeof (AE_REGION));
if (!RegionElement)
{
- return AE_NO_MEMORY;
+ return (AE_NO_MEMORY);
}
RegionElement->Buffer = AcpiOsAllocate (Length);
if (!RegionElement->Buffer)
{
AcpiOsFree (RegionElement);
- return AE_NO_MEMORY;
+ return (AE_NO_MEMORY);
}
/* Initialize the region with the default fill value */
* NOTE: RegionElement->Length is in bytes, therefore it we compare against
* ByteWidth (see above)
*/
- if (((ACPI_INTEGER) Address + ByteWidth) >
- ((ACPI_INTEGER)(RegionElement->Address) + RegionElement->Length))
+ if (((UINT64) Address + ByteWidth) >
+ ((UINT64)(RegionElement->Address) + RegionElement->Length))
{
ACPI_WARNING ((AE_INFO,
- "Request on [%4.4s] is beyond region limit Req-%X+%X, Base=%X, Len-%X",
+ "Request on [%4.4s] is beyond region limit Req-0x%X+0x%X, Base=0x%X, Len-0x%X",
(RegionObject->Region.Node)->Name.Ascii, (UINT32) Address,
ByteWidth, (UINT32)(RegionElement->Address),
RegionElement->Length));
- return AE_AML_REGION_LIMIT;
+ return (AE_AML_REGION_LIMIT);
}
/*
* Get BufferValue to point to the "address" in the buffer
*/
BufferValue = ((UINT8 *) RegionElement->Buffer +
- ((ACPI_INTEGER) Address - (ACPI_INTEGER) RegionElement->Address));
+ ((UINT64) Address - (UINT64) RegionElement->Address));
DoFunction:
-
/*
* Perform a read or write to the buffer space
*/
break;
default:
- return AE_BAD_PARAMETER;
+ return (AE_BAD_PARAMETER);
}
- return AE_OK;
-}
+ if (AcpiGbl_DisplayRegionAccess)
+ {
+ switch (SpaceId)
+ {
+ case ACPI_ADR_SPACE_SYSTEM_MEMORY:
+
+ AcpiOsPrintf ("AcpiExec: SystemMemory "
+ "%s: Val %.8X Addr %.4X Width %X [REGION: BaseAddr %.4X Len %.2X]\n",
+ (Function & ACPI_IO_MASK) ? "Write" : "Read ",
+ (UINT32) *Value, (UINT32) Address, BitWidth, (UINT32) BaseAddress, Length);
+ break;
+
+ case ACPI_ADR_SPACE_GPIO: /* ACPI 5.0 */
+
+ /* This space is required to always be ByteAcc */
+
+ Status = AcpiBufferToResource (MyContext->Connection,
+ MyContext->Length, &Resource);
+ AcpiOsPrintf ("AcpiExec: GeneralPurposeIo "
+ "%s: Val %.8X Addr %.4X BaseAddr %.4X Len %.2X Width %X AccLen %.2X Conn %p\n",
+ (Function & ACPI_IO_MASK) ? "Write" : "Read ", (UINT32) *Value,
+ (UINT32) Address, (UINT32) BaseAddress, Length, BitWidth,
+ MyContext->AccessLength, MyContext->Connection);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return (AE_OK);
+}
projects / l4.git / blobdiff