BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /drivers/devman/acpica/tools/acpiexec/ @ 1497

  → /drivers/devman/acpica/tools/acpiexec/ @ 1498

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

No changes between revisions

Regard whitespace Rev 1497 → Rev 1498

/drivers/devman/acpica/tools/acpiexec/Makefile
0,0 → 1,152
PROG= acpiexec
SRCS= aetables.c aehandlers.c aeexec.c aemain.c \
../../common/getopt.c \
../../debugger/dbcmds.c \
../../debugger/dbdisply.c \
../../debugger/dbexec.c \
../../debugger/dbfileio.c \
../../debugger/dbhistry.c \
../../debugger/dbinput.c \
../../debugger/dbstats.c \
../../debugger/dbutils.c \
../../debugger/dbxface.c \
../../disassembler/dmbuffer.c \
../../disassembler/dmnames.c \
../../disassembler/dmobject.c \
../../disassembler/dmopcode.c \
../../disassembler/dmresrc.c \
../../disassembler/dmresrcl.c \
../../disassembler/dmresrcs.c \
../../disassembler/dmutils.c \
../../disassembler/dmwalk.c \
../../events/evevent.c \
../../events/evgpe.c \
../../events/evgpeblk.c \
../../events/evgpeinit.c \
../../events/evgpeutil.c \
../../events/evmisc.c \
../../events/evregion.c \
../../events/evrgnini.c \
../../events/evsci.c \
../../events/evxface.c \
../../events/evxfevnt.c \
../../events/evxfregn.c \
../../hardware/hwacpi.c \
../../hardware/hwgpe.c \
../../hardware/hwregs.c \
../../hardware/hwsleep.c \
../../hardware/hwvalid.c \
../../hardware/hwxface.c \
../../dispatcher/dsfield.c \
../../dispatcher/dsinit.c \
../../dispatcher/dsmethod.c \
../../dispatcher/dsmthdat.c \
../../dispatcher/dsobject.c \
../../dispatcher/dsopcode.c \
../../dispatcher/dsutils.c \
../../dispatcher/dswexec.c \
../../dispatcher/dswload.c \
../../dispatcher/dswscope.c \
../../dispatcher/dswstate.c \
../../executer/exconfig.c \
../../executer/exconvrt.c \
../../executer/excreate.c \
../../executer/exdebug.c \
../../executer/exdump.c \
../../executer/exfield.c \
../../executer/exfldio.c \
../../executer/exmisc.c \
../../executer/exmutex.c \
../../executer/exnames.c \
../../executer/exoparg1.c \
../../executer/exoparg2.c \
../../executer/exoparg3.c \
../../executer/exoparg6.c \
../../executer/exprep.c \
../../executer/exregion.c \
../../executer/exresnte.c \
../../executer/exresolv.c \
../../executer/exresop.c \
../../executer/exstore.c \
../../executer/exstoren.c \
../../executer/exstorob.c \
../../executer/exsystem.c \
../../executer/exutils.c \
../../parser/psargs.c \
../../parser/psloop.c \
../../parser/psopcode.c \
../../parser/psparse.c \
../../parser/psscope.c \
../../parser/pstree.c \
../../parser/psutils.c \
../../parser/pswalk.c \
../../parser/psxface.c \
../../namespace/nsaccess.c \
../../namespace/nsalloc.c \
../../namespace/nsdump.c \
../../namespace/nsdumpdv.c \
../../namespace/nseval.c \
../../namespace/nsinit.c \
../../namespace/nsload.c \
../../namespace/nsnames.c \
../../namespace/nsobject.c \
../../namespace/nsparse.c \
../../namespace/nspredef.c \
../../namespace/nsrepair.c \
../../namespace/nsrepair2.c \
../../namespace/nssearch.c \
../../namespace/nsutils.c \
../../namespace/nswalk.c \
../../namespace/nsxfeval.c \
../../namespace/nsxfname.c \
../../namespace/nsxfobj.c \
../../resources/rsaddr.c \
../../resources/rscalc.c \
../../resources/rscreate.c \
../../resources/rsdump.c \
../../resources/rsio.c \
../../resources/rsinfo.c \
../../resources/rsirq.c \
../../resources/rslist.c \
../../resources/rsmemory.c \
../../resources/rsmisc.c \
../../resources/rsutils.c \
../../resources/rsxface.c \
../../tables/tbfadt.c \
../../tables/tbfind.c \
../../tables/tbinstal.c \
../../tables/tbutils.c \
../../tables/tbxface.c \
../../tables/tbxfroot.c \
../../utilities/utalloc.c \
../../utilities/utcache.c \
../../utilities/utcopy.c \
../../utilities/utdebug.c \
../../utilities/utdelete.c \
../../utilities/uteval.c \
../../utilities/utglobal.c \
../../utilities/utids.c \
../../utilities/utinit.c \
../../utilities/utlock.c \
../../utilities/utmath.c \
../../utilities/utmisc.c \
../../utilities/utmutex.c \
../../utilities/utobject.c \
../../utilities/utresrc.c \
../../utilities/utstate.c \
../../utilities/uttrack.c \
../../utilities/utxface.c \
../../osunixxf.c
CFLAGS+= -Wall -g -D_LINUX -DNDEBUG -D_CONSOLE -DACPI_EXEC_APP -D_MULTI_THREADED -Wstrict-prototypes -I../../include
acpiexec : $(patsubst %.c,%.o, $(SRCS))
$(CC) $(LDFLAGS) $(patsubst %.c,%.o, $(SRCS)) -lrt -lpthread -o $(PROG)
CLEANFILES= $(PROG)
clean :
rm -f $(CLEANFILES) $(patsubst %.c,%.o, $(SRCS))

/drivers/devman/acpica/tools/acpiexec/aecommon.h
0,0 → 1,244
/******************************************************************************
*
* Module Name: aecommon - common include for the AcpiExec utility
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2010, 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
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* 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
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* 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,
* 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
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* 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
* 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
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 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
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* 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
* 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
* 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
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
#ifndef _AECOMMON
#define _AECOMMON
#ifdef _MSC_VER /* disable some level-4 warnings */
#pragma warning(disable:4100) /* warning C4100: unreferenced formal parameter */
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include "acpi.h"
#include "accommon.h"
#include "acparser.h"
#include "amlcode.h"
#include "acnamesp.h"
#include "acdebug.h"
#include "actables.h"
#include "acinterp.h"
#include "acapps.h"
extern FILE *AcpiGbl_DebugFile;
extern BOOLEAN AcpiGbl_IgnoreErrors;
extern UINT8 AcpiGbl_RegionFillValue;
typedef struct ae_table_desc
{
ACPI_TABLE_HEADER *Table;
struct ae_table_desc *Next;
} AE_TABLE_DESC;
/*
* Debug Regions
*/
typedef struct ae_region
{
ACPI_PHYSICAL_ADDRESS Address;
UINT32 Length;
void *Buffer;
void *NextRegion;
UINT8 SpaceId;
} AE_REGION;
typedef struct ae_debug_regions
{
UINT32 NumberOfRegions;
AE_REGION *RegionList;
} AE_DEBUG_REGIONS;
#define TEST_OUTPUT_LEVEL(lvl) if ((lvl) & OutputLevel)
#define OSD_PRINT(lvl,fp) TEST_OUTPUT_LEVEL(lvl) {\
AcpiOsPrintf PARAM_LIST(fp);}
void __cdecl
AeCtrlCHandler (
int Sig);
ACPI_STATUS
AeBuildLocalTables (
UINT32 TableCount,
AE_TABLE_DESC *TableList);
ACPI_STATUS
AeInstallTables (
void);
void
AeDumpNamespace (
void);
void
AeDumpObject (
char *MethodName,
ACPI_BUFFER *ReturnObj);
void
AeDumpBuffer (
UINT32 Address);
void
AeExecute (
char *Name);
void
AeSetScope (
char *Name);
void
AeCloseDebugFile (
void);
void
AeOpenDebugFile (
char *Name);
ACPI_STATUS
AeDisplayAllMethods (
UINT32 DisplayCount);
ACPI_STATUS
AeInstallHandlers (
void);
void
AeMiscellaneousTests (
void);
ACPI_STATUS
AeRegionHandler (
UINT32 Function,
ACPI_PHYSICAL_ADDRESS Address,
UINT32 BitWidth,
UINT64 *Value,
void *HandlerContext,
void *RegionContext);
UINT32
AeGpeHandler (
void *Context);
#endif /* _AECOMMON */

/drivers/devman/acpica/tools/acpiexec/aeexec.c
0,0 → 1,614
/******************************************************************************
*
* Module Name: aeexec - Support routines for AcpiExec utility
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2010, 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
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* 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
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* 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,
* 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
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* 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
* 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
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 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
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* 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
* 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
* 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
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
#include "aecommon.h"
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("aeexec")
/* Local prototypes */
ACPI_STATUS
AeSetupConfiguration (
void *RegionAddr);
void
AfInstallGpeBlock (
void);
void
AeTestBufferArgument (
void);
void
AeTestPackageArgument (
void);
ACPI_STATUS
AeGetDevices (
ACPI_HANDLE ObjHandle,
UINT32 NestingLevel,
void *Context,
void **ReturnValue);
ACPI_STATUS
ExecuteOSI (
char *OsiString,
UINT32 ExpectedResult);
void
AeHardwareInterfaces (
void);
void
AeGenericRegisters (
void);
extern unsigned char Ssdt3Code[];
/******************************************************************************
*
* FUNCTION: AeSetupConfiguration
*
* PARAMETERS: RegionAddr - Address for an ACPI table to be loaded
* dynamically. Test purposes only.
*
* RETURN: Status
*
* DESCRIPTION: Call AML _CFG configuration control method
*
*****************************************************************************/
ACPI_STATUS
AeSetupConfiguration (
void *RegionAddr)
{
ACPI_STATUS Status;
ACPI_OBJECT_LIST ArgList;
ACPI_OBJECT Arg[3];
/*
* Invoke _CFG method if present
*/
ArgList.Count = 1;
ArgList.Pointer = Arg;
Arg[0].Type = ACPI_TYPE_INTEGER;
Arg[0].Integer.Value = ACPI_TO_INTEGER (RegionAddr);
Status = AcpiEvaluateObject (NULL, "\\_CFG", &ArgList, NULL);
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: AfInstallGpeBlock
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Test GPE block device initialization. Requires test ASL with
* A \GPE2 device.
*
*****************************************************************************/
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);
AcpiInstallGpeHandler (Handle2, 8, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AcpiEnableGpe (Handle2, 8, ACPI_GPE_TYPE_RUNTIME);
Status = AcpiGetGpeDevice (0x30, &GpeDevice);
Status = AcpiGetGpeDevice (0x42, &GpeDevice);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount-1, &GpeDevice);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount, &GpeDevice);
AcpiRemoveGpeHandler (Handle2, 8, AeGpeHandler);
}
Status = AcpiGetHandle (NULL, "\\GPE3", &Handle3);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallGpeBlock (Handle3, &BlockAddress, 8, 11);
}
}
/* Test using a Buffer object as a method argument */
void
AeTestBufferArgument (
void)
{
ACPI_STATUS Status;
ACPI_OBJECT_LIST Params;
ACPI_OBJECT BufArg;
UINT8 Buffer[] = {
0,0,0,0,
4,0,0,0,
1,2,3,4};
BufArg.Type = ACPI_TYPE_BUFFER;
BufArg.Buffer.Length = 12;
BufArg.Buffer.Pointer = Buffer;
Params.Count = 1;
Params.Pointer = &BufArg;
Status = AcpiEvaluateObject (NULL, "\\BUF", &Params, NULL);
}
ACPI_OBJECT PkgArg;
ACPI_OBJECT PkgElements[5];
ACPI_OBJECT Pkg2Elements[5];
ACPI_OBJECT_LIST Params;
/*
* Test using a Package object as an method argument
*/
void
AeTestPackageArgument (
void)
{
ACPI_STATUS Status;
/* Main package */
PkgArg.Type = ACPI_TYPE_PACKAGE;
PkgArg.Package.Count = 4;
PkgArg.Package.Elements = PkgElements;
/* Main package elements */
PkgElements[0].Type = ACPI_TYPE_INTEGER;
PkgElements[0].Integer.Value = 0x22228888;
PkgElements[1].Type = ACPI_TYPE_STRING;
PkgElements[1].String.Length = sizeof ("Top-level package");
PkgElements[1].String.Pointer = "Top-level package";
PkgElements[2].Type = ACPI_TYPE_BUFFER;
PkgElements[2].Buffer.Length = sizeof ("XXXX");
PkgElements[2].Buffer.Pointer = (UINT8 *) "XXXX";
PkgElements[3].Type = ACPI_TYPE_PACKAGE;
PkgElements[3].Package.Count = 2;
PkgElements[3].Package.Elements = Pkg2Elements;
/* Sub-package elements */
Pkg2Elements[0].Type = ACPI_TYPE_INTEGER;
Pkg2Elements[0].Integer.Value = 0xAAAABBBB;
Pkg2Elements[1].Type = ACPI_TYPE_STRING;
Pkg2Elements[1].String.Length = sizeof ("Nested Package");
Pkg2Elements[1].String.Pointer = "Nested Package";
/* Parameter object */
Params.Count = 1;
Params.Pointer = &PkgArg;
Status = AcpiEvaluateObject (NULL, "\\_PKG", &Params, NULL);
}
ACPI_STATUS
AeGetDevices (
ACPI_HANDLE ObjHandle,
UINT32 NestingLevel,
void *Context,
void **ReturnValue)
{
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: ExecuteOSI
*
* PARAMETERS: OsiString - String passed to _OSI method
* ExpectedResult - 0 (FALSE) or 0xFFFFFFFF (TRUE)
*
* RETURN: Status
*
* DESCRIPTION: Execute the internally implemented (in ACPICA) _OSI method.
*
*****************************************************************************/
ACPI_STATUS
ExecuteOSI (
char *OsiString,
UINT32 ExpectedResult)
{
ACPI_STATUS Status;
ACPI_OBJECT_LIST ArgList;
ACPI_OBJECT Arg[1];
ACPI_BUFFER ReturnValue;
ACPI_OBJECT *Obj;
/* Setup input argument */
ArgList.Count = 1;
ArgList.Pointer = Arg;
Arg[0].Type = ACPI_TYPE_STRING;
Arg[0].String.Pointer = OsiString;
Arg[0].String.Length = strlen (Arg[0].String.Pointer);
/* Ask ACPICA to allocate space for the return object */
ReturnValue.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiEvaluateObject (NULL, "\\_OSI", &ArgList, &ReturnValue);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not execute _OSI method, %s\n",
AcpiFormatException (Status));
return (Status);
}
if (ReturnValue.Length < sizeof (ACPI_OBJECT))
{
AcpiOsPrintf ("Return value from _OSI method too small, %.8X\n",
ReturnValue.Length);
return (AE_ERROR);
}
Obj = ReturnValue.Pointer;
if (Obj->Type != ACPI_TYPE_INTEGER)
{
AcpiOsPrintf ("Invalid return type from _OSI method, %.2X\n", Obj->Type);
return (AE_ERROR);
}
if (Obj->Integer.Value != ExpectedResult)
{
AcpiOsPrintf ("Invalid return value from _OSI, expected %.8X found %.8X\n",
ExpectedResult, (UINT32) Obj->Integer.Value);
return (AE_ERROR);
}
/* Reset the OSI data */
AcpiGbl_OsiData = 0;
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: AeGenericRegisters
*
* DESCRIPTION: Call the AcpiRead/Write interfaces.
*
*****************************************************************************/
ACPI_GENERIC_ADDRESS GenericRegister;
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);
Status = AcpiWrite (Value, &GenericRegister);
GenericRegister.Address = 0x12345678;
GenericRegister.BitOffset = 0;
GenericRegister.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY;
Status = AcpiRead (&Value, &GenericRegister);
Status = AcpiWrite (Value, &GenericRegister);
}
/******************************************************************************
*
* FUNCTION: AeHardwareInterfaces
*
* DESCRIPTION: Call various hardware support interfaces
*
*****************************************************************************/
void
AeHardwareInterfaces (
void)
{
ACPI_STATUS Status;
UINT32 Value;
Status = AcpiWriteBitRegister (ACPI_BITREG_WAKE_STATUS, 1);
Status = AcpiWriteBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, 1);
Status = AcpiWriteBitRegister (ACPI_BITREG_SLEEP_ENABLE, 1);
Status = AcpiWriteBitRegister (ACPI_BITREG_ARB_DISABLE, 1);
Status = AcpiReadBitRegister (ACPI_BITREG_WAKE_STATUS, &Value);
Status = AcpiReadBitRegister (ACPI_BITREG_GLOBAL_LOCK_ENABLE, &Value);
Status = AcpiReadBitRegister (ACPI_BITREG_SLEEP_ENABLE, &Value);
Status = AcpiReadBitRegister (ACPI_BITREG_ARB_DISABLE, &Value);
}
/******************************************************************************
*
* FUNCTION: AeMiscellaneousTests
*
* DESCRIPTION: Various ACPICA validation tests.
*
*****************************************************************************/
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 ();
ExecuteOSI ("Windows 2001", 0xFFFFFFFF);
ExecuteOSI ("MichiganTerminalSystem", 0);
ReturnBuf.Length = 32;
ReturnBuf.Pointer = Buffer;
AcpiGetName (AcpiGbl_RootNode, ACPI_FULL_PATHNAME, &ReturnBuf);
AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0);
/*
* GPEs: Handlers, enable/disable, etc.
*/
AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AcpiEnableGpe (NULL, 0, ACPI_GPE_TYPE_RUNTIME);
AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler);
AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AcpiEnableGpe (NULL, 0, ACPI_GPE_TYPE_RUNTIME);
AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE);
AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE);
AcpiInstallGpeHandler (NULL, 1, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AcpiEnableGpe (NULL, 1, ACPI_GPE_TYPE_RUNTIME);
AcpiInstallGpeHandler (NULL, 2, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AcpiEnableGpe (NULL, 2, ACPI_GPE_TYPE_RUNTIME);
AcpiInstallGpeHandler (NULL, 3, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AcpiInstallGpeHandler (NULL, 4, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AcpiInstallGpeHandler (NULL, 5, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AcpiInstallGpeHandler (NULL, 0x19, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AcpiEnableGpe (NULL, 0x19, ACPI_GPE_TYPE_RUNTIME);
AcpiInstallGpeHandler (NULL, 0x62, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AcpiEnableGpe (NULL, 0x62, ACPI_GPE_TYPE_RUNTIME);
AcpiDisableGpe (NULL, 0x62, ACPI_GPE_TYPE_RUNTIME);
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);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not get GlobalLock, %X\n", Status);
}
Status = AcpiAcquireGlobalLock (0x5, &LockHandle2);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not get GlobalLock, %X\n", Status);
}
Status = AcpiReleaseGlobalLock (LockHandle1);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not release GlobalLock, %X\n", Status);
}
Status = AcpiReleaseGlobalLock (LockHandle2);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not release GlobalLock, %X\n", Status);
}
/* Get Devices */
Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not AcpiGetDevices, %X\n", Status);
}
Status = AcpiGetStatistics (&Stats);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not AcpiGetStatistics, %X\n", Status);
}
}

/drivers/devman/acpica/tools/acpiexec/aehandlers.c
0,0 → 1,966
/******************************************************************************
*
* Module Name: aehandlers - Various handlers for acpiexec
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2010, 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
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* 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
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* 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,
* 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
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* 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
* 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
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 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
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* 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
* 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
* 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
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
#include "aecommon.h"
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("aehandlers")
/* Local prototypes */
void
AeNotifyHandler (
ACPI_HANDLE Device,
UINT32 Value,
void *Context);
void
AeDeviceNotifyHandler (
ACPI_HANDLE Device,
UINT32 Value,
void *Context);
ACPI_STATUS
AeExceptionHandler (
ACPI_STATUS AmlStatus,
ACPI_NAME Name,
UINT16 Opcode,
UINT32 AmlOffset,
void *Context);
ACPI_STATUS
AeTableHandler (
UINT32 Event,
void *Table,
void *Context);
ACPI_STATUS
AeRegionInit (
ACPI_HANDLE RegionHandle,
UINT32 Function,
void *HandlerContext,
void **RegionContext);
void
AeAttachedDataHandler (
ACPI_HANDLE Object,
void *Data);
UINT32 SigintCount = 0;
AE_DEBUG_REGIONS AeRegions;
/******************************************************************************
*
* FUNCTION: AeCtrlCHandler
*
* PARAMETERS: Sig
*
* RETURN: none
*
* DESCRIPTION: Control-C handler. Abort running control method if any.
*
*****************************************************************************/
void __cdecl
AeCtrlCHandler (
int Sig)
{
signal (SIGINT, SIG_IGN);
SigintCount++;
AcpiOsPrintf ("Caught a ctrl-c (#%u)\n\n", SigintCount);
if (AcpiGbl_MethodExecuting)
{
AcpiGbl_AbortMethod = TRUE;
signal (SIGINT, AeCtrlCHandler);
if (SigintCount < 10)
{
return;
}
}
exit (0);
}
/******************************************************************************
*
* FUNCTION: AeNotifyHandler
*
* 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.
*
*****************************************************************************/
void
AeNotifyHandler (
ACPI_HANDLE Device,
UINT32 Value,
void *Context)
{
switch (Value)
{
#if 0
case 0:
printf ("[AcpiExec] Method Error 0x%X: Results not equal\n", Value);
if (AcpiGbl_DebugFile)
{
AcpiOsPrintf ("[AcpiExec] Method Error: Results not equal\n");
}
break;
case 1:
printf ("[AcpiExec] Method Error: Incorrect numeric result\n");
if (AcpiGbl_DebugFile)
{
AcpiOsPrintf ("[AcpiExec] Method Error: Incorrect numeric result\n");
}
break;
case 2:
printf ("[AcpiExec] Method Error: An operand was overwritten\n");
if (AcpiGbl_DebugFile)
{
AcpiOsPrintf ("[AcpiExec] Method Error: An operand was overwritten\n");
}
break;
#endif
default:
printf ("[AcpiExec] 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] Received a system notify, Value 0x%2.2X\n", Value);
}
(void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);
break;
}
}
/******************************************************************************
*
* FUNCTION: AeDeviceNotifyHandler
*
* PARAMETERS: Standard notify handler parameters
*
* RETURN: Status
*
* 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
AeDeviceNotifyHandler (
ACPI_HANDLE Device,
UINT32 Value,
void *Context)
{
printf ("[AcpiExec] 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);
}
(void) AcpiEvaluateObject (Device, "_NOT", NULL, NULL);
}
/******************************************************************************
*
* FUNCTION: AeExceptionHandler
*
* PARAMETERS: Standard exception handler parameters
*
* RETURN: Status
*
* DESCRIPTION: System exception handler for AcpiExec utility.
*
*****************************************************************************/
ACPI_STATUS
AeExceptionHandler (
ACPI_STATUS AmlStatus,
ACPI_NAME Name,
UINT16 Opcode,
UINT32 AmlOffset,
void *Context)
{
ACPI_STATUS NewAmlStatus = AmlStatus;
ACPI_STATUS Status;
ACPI_BUFFER ReturnObj;
ACPI_OBJECT_LIST ArgList;
ACPI_OBJECT Arg[3];
const char *Exception;
Exception = AcpiFormatException (AmlStatus);
AcpiOsPrintf ("[AcpiExec] Exception %s during execution ", Exception);
if (Name)
{
AcpiOsPrintf ("of method [%4.4s]", (char *) &Name);
}
else
{
AcpiOsPrintf ("at module level (table load)");
}
AcpiOsPrintf (" Opcode [%s] @%X\n", AcpiPsGetOpcodeName (Opcode), AmlOffset);
/*
* Invoke the _ERR method if present
*
* Setup parameter object
*/
ArgList.Count = 3;
ArgList.Pointer = Arg;
Arg[0].Type = ACPI_TYPE_INTEGER;
Arg[0].Integer.Value = AmlStatus;
Arg[1].Type = ACPI_TYPE_STRING;
Arg[1].String.Pointer = ACPI_CAST_PTR (char, Exception);
Arg[1].String.Length = ACPI_STRLEN (Exception);
Arg[2].Type = ACPI_TYPE_INTEGER;
Arg[2].Integer.Value = ACPI_TO_INTEGER (AcpiOsGetThreadId());
/* Setup return buffer */
ReturnObj.Pointer = NULL;
ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiEvaluateObject (NULL, "\\_ERR", &ArgList, &ReturnObj);
if (ACPI_SUCCESS (Status))
{
if (ReturnObj.Pointer)
{
/* Override original status */
NewAmlStatus = (ACPI_STATUS)
((ACPI_OBJECT *) ReturnObj.Pointer)->Integer.Value;
AcpiOsFree (ReturnObj.Pointer);
}
}
else if (Status != AE_NOT_FOUND)
{
AcpiOsPrintf ("[AcpiExec] Could not execute _ERR method, %s\n",
AcpiFormatException (Status));
}
/* Global override */
if (AcpiGbl_IgnoreErrors)
{
NewAmlStatus = AE_OK;
}
if (NewAmlStatus != AmlStatus)
{
AcpiOsPrintf ("[AcpiExec] Exception override, new status %s\n",
AcpiFormatException (NewAmlStatus));
}
return (NewAmlStatus);
}
/******************************************************************************
*
* FUNCTION: AeTableHandler
*
* PARAMETERS: Table handler
*
* RETURN: Status
*
* DESCRIPTION: System table handler for AcpiExec utility.
*
*****************************************************************************/
char *TableEvents[] =
{
"LOAD",
"UNLOAD",
"UNKNOWN"
};
ACPI_STATUS
AeTableHandler (
UINT32 Event,
void *Table,
void *Context)
{
if (Event > ACPI_NUM_TABLE_EVENTS)
{
Event = ACPI_NUM_TABLE_EVENTS;
}
/* TBD: could dump entire table header, need a header dump routine */
printf ("[AcpiExec] Table Event %s, [%4.4s] %p\n",
TableEvents[Event], ((ACPI_TABLE_HEADER *) Table)->Signature, Table);
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: AeGpeHandler
*
* DESCRIPTION: GPE handler for acpiexec
*
*****************************************************************************/
UINT32
AeGpeHandler (
void *Context)
{
AcpiOsPrintf ("Received a GPE at handler\n");
return (0);
}
/******************************************************************************
*
* FUNCTION: AeAttachedDataHandler
*
* DESCRIPTION: Handler for deletion of nodes with attached data (attached via
* AcpiAttachData)
*
*****************************************************************************/
void
AeAttachedDataHandler (
ACPI_HANDLE Object,
void *Data)
{
ACPI_NAMESPACE_NODE *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Data);
AcpiOsPrintf ("Received an attached data deletion on %4.4s\n",
Node->Name.Ascii);
}
/******************************************************************************
*
* FUNCTION: AeRegionInit
*
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: Opregion init function.
*
*****************************************************************************/
ACPI_STATUS
AeRegionInit (
ACPI_HANDLE RegionHandle,
UINT32 Function,
void *HandlerContext,
void **RegionContext)
{
/*
* Real simple, set the RegionContext to the RegionHandle
*/
*RegionContext = RegionHandle;
return AE_OK;
}
/******************************************************************************
*
* FUNCTION: AeInstallHandlers
*
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: Install handlers for the AcpiExec utility.
*
*****************************************************************************/
ACPI_ADR_SPACE_TYPE SpaceId[] = {0, 1, 2, 3, 4, 5, 6, 7, 0x80};
#define AEXEC_NUM_REGIONS 9
ACPI_STATUS
AeInstallHandlers (void)
{
ACPI_STATUS Status;
UINT32 i;
ACPI_HANDLE Handle;
ACPI_FUNCTION_ENTRY ();
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 handler */
Status = AcpiInstallNotifyHandler (ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a global 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,
AeNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiRemoveNotifyHandler (Handle, ACPI_SYSTEM_NOTIFY,
AeNotifyHandler);
if (ACPI_FAILURE (Status))
{
printf ("Could not remove a notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler, NULL);
Status = AcpiRemoveNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler);
Status = AcpiInstallNotifyHandler (Handle, ACPI_ALL_NOTIFY,
AeNotifyHandler, NULL);
if (ACPI_FAILURE (Status))
{
printf ("Could not install a notify handler, %s\n",
AcpiFormatException (Status));
}
Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
Status = AcpiDetachData (Handle, AeAttachedDataHandler);
Status = AcpiAttachData (Handle, AeAttachedDataHandler, Handle);
}
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 = AcpiRemoveAddressSpaceHandler (AcpiGbl_RootNode,
SpaceId[i], AeRegionHandler);
/* Install handler at the root object.
* TBD: all default handlers should be installed here!
*/
Status = AcpiInstallAddressSpaceHandler (AcpiGbl_RootNode,
SpaceId[i], AeRegionHandler, AeRegionInit, NULL);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"Could not install an OpRegion handler for %s space(%u)",
AcpiUtGetRegionName((UINT8) SpaceId[i]), SpaceId[i]));
return (Status);
}
}
/*
* Initialize the global Region Handler space
* MCW 3/23/00
*/
AeRegions.NumberOfRegions = 0;
AeRegions.RegionList = NULL;
return Status;
}
/******************************************************************************
*
* FUNCTION: AeRegionHandler
*
* PARAMETERS: Standard region handler parameters
*
* RETURN: Status
*
* DESCRIPTION: Test handler - Handles some dummy regions via memory that can
* be manipulated in Ring 3. Simulates actual reads and writes.
*
*****************************************************************************/
ACPI_STATUS
AeRegionHandler (
UINT32 Function,
ACPI_PHYSICAL_ADDRESS Address,
UINT32 BitWidth,
UINT64 *Value,
void *HandlerContext,
void *RegionContext)
{
ACPI_OPERAND_OBJECT *RegionObject = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, RegionContext);
UINT8 *Buffer = ACPI_CAST_PTR (UINT8, Value);
ACPI_PHYSICAL_ADDRESS BaseAddress;
ACPI_SIZE Length;
BOOLEAN BufferExists;
AE_REGION *RegionElement;
void *BufferValue;
ACPI_STATUS Status;
UINT32 ByteWidth;
UINT32 i;
UINT8 SpaceId;
ACPI_FUNCTION_NAME (AeRegionHandler);
/*
* If the object is not a region, simply return
*/
if (RegionObject->Region.Type != ACPI_TYPE_REGION)
{
return AE_OK;
}
/*
* Region support can be disabled with the -r option.
* We use this to support dynamically loaded tables where we pass a valid
* address to the AML.
*/
if (AcpiGbl_DbOpt_NoRegionSupport)
{
BufferValue = ACPI_TO_POINTER (Address);
ByteWidth = (BitWidth / 8);
if (BitWidth % 8)
{
ByteWidth += 1;
}
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
*/
switch (Function & ACPI_IO_MASK)
{
case ACPI_READ:
Status = AcpiHwReadPort (Address, (UINT32 *) Value, BitWidth);
break;
case ACPI_WRITE:
Status = AcpiHwWritePort (Address, (UINT32) *Value, BitWidth);
break;
default:
Status = AE_BAD_PARAMETER;
break;
}
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Now go ahead and simulate the hardware */
break;
case ACPI_ADR_SPACE_SMBUS:
Length = 0;
switch (Function & ACPI_IO_MASK)
{
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:
Length = 1;
break;
case AML_FIELD_ATTRIB_SMB_WORD:
case AML_FIELD_ATTRIB_SMB_WORD_CALL:
Length = 2;
break;
case AML_FIELD_ATTRIB_SMB_BLOCK:
case AML_FIELD_ATTRIB_SMB_BLOCK_CALL:
Length = 32;
break;
default:
break;
}
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:
Length = 0;
break;
case AML_FIELD_ATTRIB_SMB_WORD_CALL:
Length = 2;
break;
case AML_FIELD_ATTRIB_SMB_BLOCK_CALL:
Length = 32;
break;
default:
break;
}
break;
default:
break;
}
for (i = 0; i < Length; i++)
{
Buffer[i+2] = (UINT8) (0xA0 + i);
}
Buffer[0] = 0x7A;
Buffer[1] = (UINT8) Length;
return (AE_OK);
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]);
/*
* Regardless of a READ or WRITE, this handler is passed a 66-byte
* buffer in which to return the IPMI status/length/data.
*
* Return some example data to show use of the bidirectional buffer
*/
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 */
return (AE_OK);
default:
break;
}
/*
* Search through the linked list for this region's buffer
*/
BufferExists = FALSE;
RegionElement = AeRegions.RegionList;
if (AeRegions.NumberOfRegions)
{
while (!BufferExists && RegionElement)
{
if (RegionElement->Address == BaseAddress &&
RegionElement->Length == Length &&
RegionElement->SpaceId == SpaceId)
{
BufferExists = TRUE;
}
else
{
RegionElement = RegionElement->NextRegion;
}
}
}
/*
* If the Region buffer does not exist, create it now
*/
if (!BufferExists)
{
/*
* Do the memory allocations first
*/
RegionElement = AcpiOsAllocate (sizeof (AE_REGION));
if (!RegionElement)
{
return AE_NO_MEMORY;
}
RegionElement->Buffer = AcpiOsAllocate (Length);
if (!RegionElement->Buffer)
{
AcpiOsFree (RegionElement);
return AE_NO_MEMORY;
}
/* Initialize the region with the default fill value */
ACPI_MEMSET (RegionElement->Buffer, AcpiGbl_RegionFillValue, Length);
RegionElement->Address = BaseAddress;
RegionElement->Length = Length;
RegionElement->SpaceId = SpaceId;
RegionElement->NextRegion = NULL;
/*
* Increment the number of regions and put this one
* at the head of the list as it will probably get accessed
* more often anyway.
*/
AeRegions.NumberOfRegions += 1;
if (AeRegions.RegionList)
{
RegionElement->NextRegion = AeRegions.RegionList;
}
AeRegions.RegionList = RegionElement;
}
/*
* Calculate the size of the memory copy
*/
ByteWidth = (BitWidth / 8);
if (BitWidth % 8)
{
ByteWidth += 1;
}
/*
* The buffer exists and is pointed to by RegionElement.
* We now need to verify the request is valid and perform the operation.
*
* NOTE: RegionElement->Length is in bytes, therefore it we compare against
* ByteWidth (see above)
*/
if (((UINT64) Address + ByteWidth) >
((UINT64)(RegionElement->Address) + RegionElement->Length))
{
ACPI_WARNING ((AE_INFO,
"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;
}
/*
* Get BufferValue to point to the "address" in the buffer
*/
BufferValue = ((UINT8 *) RegionElement->Buffer +
((UINT64) Address - (UINT64) RegionElement->Address));
DoFunction:
/*
* Perform a read or write to the buffer space
*/
switch (Function)
{
case ACPI_READ:
/*
* Set the pointer Value to whatever is in the buffer
*/
ACPI_MEMCPY (Value, BufferValue, ByteWidth);
break;
case ACPI_WRITE:
/*
* Write the contents of Value to the buffer
*/
ACPI_MEMCPY (BufferValue, Value, ByteWidth);
break;
default:
return AE_BAD_PARAMETER;
}
return AE_OK;
}

/drivers/devman/acpica/tools/acpiexec/aemain.c
0,0 → 1,735
/******************************************************************************
*
* Module Name: aemain - Main routine for the AcpiExec utility
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2010, 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
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* 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
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* 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,
* 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
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* 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
* 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
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 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
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* 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
* 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
* 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
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
#include "aecommon.h"
#ifdef _DEBUG
#include <crtdbg.h>
#endif
#define _COMPONENT PARSER
ACPI_MODULE_NAME ("aemain")
UINT8 AcpiGbl_BatchMode = 0;
UINT8 AcpiGbl_RegionFillValue = 0;
BOOLEAN AcpiGbl_IgnoreErrors = FALSE;
BOOLEAN AcpiGbl_DbOpt_NoRegionSupport = FALSE;
BOOLEAN AcpiGbl_DebugTimeout = FALSE;
char BatchBuffer[128];
AE_TABLE_DESC *AeTableListHead = NULL;
#define ASL_MAX_FILES 256
char *FileList[ASL_MAX_FILES];
int FileCount;
#define AE_SUPPORTED_OPTIONS "?b:d:e:f:gm^ovx:"
/******************************************************************************
*
* FUNCTION: usage
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Print a usage message
*
*****************************************************************************/
static void
usage (void)
{
printf ("Usage: acpiexec [options] AMLfile1 AMLfile2 ...\n\n");
printf ("Where:\n");
printf (" -? Display this message\n");
printf (" -b <CommandLine> Batch mode command execution\n");
printf (" -m [Method] Batch mode method execution. Default=MAIN\n");
printf ("\n");
printf (" -da Disable method abort on error\n");
printf (" -di Disable execution of STA/INI methods during init\n");
printf (" -do Disable Operation Region address simulation\n");
printf (" -dt Disable allocation tracking (performance)\n");
printf ("\n");
printf (" -ef Enable display of final memory statistics\n");
printf (" -em Enable Interpreter Serialized Mode\n");
printf (" -es Enable Interpreter Slack Mode\n");
printf (" -et Enable debug semaphore timeout\n");
printf ("\n");
printf (" -f <Value> Operation Region initialization fill value\n");
printf (" -v Verbose initialization output\n");
printf (" -x <DebugLevel> Debug output level\n");
}
/******************************************************************************
*
* FUNCTION: AcpiDbRunBatchMode
*
* PARAMETERS: BatchCommandLine - A semicolon separated list of commands
* to be executed.
* Use only commas to separate elements of
* particular command.
* RETURN: Status
*
* DESCRIPTION: For each command of list separated by ';' prepare the command
* buffer and pass it to AcpiDbCommandDispatch.
*
*****************************************************************************/
static ACPI_STATUS
AcpiDbRunBatchMode (
void)
{
ACPI_STATUS Status;
char *Ptr = BatchBuffer;
char *Cmd = Ptr;
UINT8 Run = 0;
AcpiGbl_MethodExecuting = FALSE;
AcpiGbl_StepToNextCall = FALSE;
while (*Ptr)
{
if (*Ptr == ',')
{
/* Convert commas to spaces */
*Ptr = ' ';
}
else if (*Ptr == ';')
{
*Ptr = '\0';
Run = 1;
}
Ptr++;
if (Run || (*Ptr == '\0'))
{
(void) AcpiDbCommandDispatch (Cmd, NULL, NULL);
Run = 0;
Cmd = Ptr;
}
}
Status = AcpiTerminate ();
return (Status);
}
/*******************************************************************************
*
* FUNCTION: FlStrdup
*
* DESCRIPTION: Local strdup function
*
******************************************************************************/
static char *
FlStrdup (
char *String)
{
char *NewString;
NewString = AcpiOsAllocate (strlen (String) + 1);
if (!NewString)
{
return (NULL);
}
strcpy (NewString, String);
return (NewString);
}
/*******************************************************************************
*
* FUNCTION: FlSplitInputPathname
*
* PARAMETERS: InputFilename - The user-specified ASL source file to be
* compiled
* OutDirectoryPath - Where the directory path prefix is
* returned
* OutFilename - Where the filename part is returned
*
* RETURN: Status
*
* DESCRIPTION: Split the input path into a directory and filename part
* 1) Directory part used to open include files
* 2) Filename part used to generate output filenames
*
******************************************************************************/
ACPI_STATUS
FlSplitInputPathname (
char *InputPath,
char **OutDirectoryPath,
char **OutFilename)
{
char *Substring;
char *DirectoryPath;
char *Filename;
*OutDirectoryPath = NULL;
*OutFilename = NULL;
if (!InputPath)
{
return (AE_OK);
}
/* Get the path to the input filename's directory */
DirectoryPath = FlStrdup (InputPath);
if (!DirectoryPath)
{
return (AE_NO_MEMORY);
}
Substring = strrchr (DirectoryPath, '\\');
if (!Substring)
{
Substring = strrchr (DirectoryPath, '/');
if (!Substring)
{
Substring = strrchr (DirectoryPath, ':');
}
}
if (!Substring)
{
DirectoryPath[0] = 0;
Filename = FlStrdup (InputPath);
}
else
{
Filename = FlStrdup (Substring + 1);
*(Substring+1) = 0;
}
if (!Filename)
{
return (AE_NO_MEMORY);
}
*OutDirectoryPath = DirectoryPath;
*OutFilename = Filename;
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: AsDoWildcard
*
* PARAMETERS: DirectoryPathname - Path to parent directory
* FileSpecifier - the wildcard specification (*.c, etc.)
*
* RETURN: Pointer to a list of filenames
*
* DESCRIPTION: Process files via wildcards. This function is for the Windows
* case only.
*
******************************************************************************/
static char **
AsDoWildcard (
char *DirectoryPathname,
char *FileSpecifier)
{
#ifdef WIN32
void *DirInfo;
char *Filename;
FileCount = 0;
/* Open parent directory */
DirInfo = AcpiOsOpenDirectory (DirectoryPathname, FileSpecifier, REQUEST_FILE_ONLY);
if (!DirInfo)
{
/* Either the directory or file does not exist */
printf ("File or directory %s%s does not exist\n", DirectoryPathname, FileSpecifier);
return (NULL);
}
/* Process each file that matches the wildcard specification */
while ((Filename = AcpiOsGetNextFilename (DirInfo)))
{
/* Add the filename to the file list */
FileList[FileCount] = AcpiOsAllocate (strlen (Filename) + 1);
strcpy (FileList[FileCount], Filename);
FileCount++;
if (FileCount >= ASL_MAX_FILES)
{
printf ("Max files reached\n");
FileList[0] = NULL;
return (FileList);
}
}
/* Cleanup */
AcpiOsCloseDirectory (DirInfo);
FileList[FileCount] = NULL;
return (FileList);
#else
if (!FileSpecifier)
{
return (NULL);
}
/*
* Linux/Unix cases - Wildcards are expanded by the shell automatically.
* Just return the filename in a null terminated list
*/
FileList[0] = AcpiOsAllocate (strlen (FileSpecifier) + 1);
strcpy (FileList[0], FileSpecifier);
FileList[1] = NULL;
return (FileList);
#endif
}
/******************************************************************************
*
* FUNCTION: main
*
* PARAMETERS: argc, argv
*
* RETURN: Status
*
* DESCRIPTION: Main routine for AcpiDump utility
*
*****************************************************************************/
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 **FileList;
char *Filename;
char *Directory;
char *FullPathname;
#ifdef _DEBUG
_CrtSetDbgFlag (_CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF |
_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG));
#endif
printf ("\nIntel ACPI Component Architecture\nAML Execution/Debug Utility");
printf (" version %8.8X", ((UINT32) ACPI_CA_VERSION));
printf (" [%s]\n\n", __DATE__);
if (argc < 2)
{
usage ();
return 0;
}
signal (SIGINT, AeCtrlCHandler);
/* Init globals */
AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
AcpiDbgLayer = 0xFFFFFFFF;
/* Init ACPI and start debugger thread */
AcpiInitializeSubsystem ();
/* 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 '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) */
FileList = AsDoWildcard (Directory, Filename);
if (!FileList)
{
return -1;
}
while (*FileList)
{
FullPathname = AcpiOsAllocate (
strlen (Directory) + strlen (*FileList) + 1);
/* Construct a full path to the file */
strcpy (FullPathname, Directory);
strcat (FullPathname, *FileList);
/* 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 (*FileList);
*FileList = NULL;
FileList++;
/*
* 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;
}
Status = AeInstallHandlers ();
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;
}
AeMiscellaneousTests ();
}
enterloop:
if (AcpiGbl_BatchMode == 1)
{
AcpiDbRunBatchMode ();
}
else if (AcpiGbl_BatchMode == 2)
{
AcpiDbExecute (BatchBuffer, NULL, EX_NO_SINGLE_STEP);
}
else
{
/* Enter the debugger command loop */
AcpiDbUserCommands (ACPI_DEBUGGER_COMMAND_PROMPT, NULL);
}
return 0;
}

/drivers/devman/acpica/tools/acpiexec/aetables.c
0,0 → 1,724
/******************************************************************************
*
* Module Name: aetables - Miscellaneous ACPI tables for acpiexec utility
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2010, 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
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* 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
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* 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,
* 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
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* 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
* 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
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 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
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* 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
* 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
* 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
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
#include "aecommon.h"
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("aetables")
/* Local prototypes */
void
AeTableOverride (
ACPI_TABLE_HEADER *ExistingTable,
ACPI_TABLE_HEADER **NewTable);
ACPI_PHYSICAL_ADDRESS
AeLocalGetRootPointer (
void);
/*
* Misc ACPI tables to be installed
*/
/* Default DSDT. This will be replaced with the input DSDT */
unsigned char DsdtCode[] =
{
0x44,0x53,0x44,0x54,0x24,0x00,0x00,0x00, /* 00000000 "DSDT$..." */
0x02,0x6F,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 ".oIntel." */
0x4E,0x75,0x6C,0x6C,0x44,0x53,0x44,0x54, /* 00000010 "NullDSDT" */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x04,0x12,0x08,0x20,
};
unsigned char LocalDsdtCode[] =
{
0x44,0x53,0x44,0x54,0x24,0x00,0x00,0x00, /* 00000000 "DSDT$..." */
0x02,0x2C,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 ".,Intel." */
0x4C,0x6F,0x63,0x61,0x6C,0x00,0x00,0x00, /* 00000010 "Local..." */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x30,0x07,0x09,0x20,
};
/* Several example SSDTs */
unsigned char Ssdt1Code[] = /* Has method _T98 */
{
0x53,0x53,0x44,0x54,0x30,0x00,0x00,0x00, /* 00000000 "SSDT0..." */
0x01,0xB8,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 "..Intel." */
0x4D,0x61,0x6E,0x79,0x00,0x00,0x00,0x00, /* 00000010 "Many...." */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x24,0x04,0x03,0x20,0x14,0x0B,0x5F,0x54, /* 00000020 "$.. .._T" */
0x39,0x38,0x00,0x70,0x0A,0x04,0x60,0xA4, /* 00000028 "98.p..`." */
};
unsigned char Ssdt2Code[] = /* Has method _T99 */
{
0x53,0x53,0x44,0x54,0x30,0x00,0x00,0x00, /* 00000000 "SSDT0..." */
0x01,0xB7,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 "..Intel." */
0x4D,0x61,0x6E,0x79,0x00,0x00,0x00,0x00, /* 00000010 "Many...." */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x24,0x04,0x03,0x20,0x14,0x0B,0x5F,0x54, /* 00000020 "$.. .._T" */
0x39,0x39,0x00,0x70,0x0A,0x04,0x60,0xA4, /* 00000028 "99.p..`." */
};
unsigned char Ssdt3Code[] = /* Has method _T97 */
{
0x54,0x53,0x44,0x54,0x30,0x00,0x00,0x00, /* 00000000 "TSDT0..." */
0x01,0xB8,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 "..Intel." */
0x4D,0x61,0x6E,0x79,0x00,0x00,0x00,0x00, /* 00000010 "Many...." */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x24,0x04,0x03,0x20,0x14,0x0B,0x5F,0x54, /* 00000020 "$.. .._T" */
0x39,0x37,0x00,0x70,0x0A,0x04,0x60,0xA4, /* 00000028 "97.p..`." */
};
/* Example OEM table */
unsigned char Oem1Code[] =
{
0x4F,0x45,0x4D,0x31,0x38,0x00,0x00,0x00, /* 00000000 "OEM18..." */
0x01,0x4B,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 ".KIntel." */
0x4D,0x61,0x6E,0x79,0x00,0x00,0x00,0x00, /* 00000010 "Many...." */
0x01,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */
0x18,0x09,0x03,0x20,0x08,0x5F,0x58,0x54, /* 00000020 "... ._XT" */
0x32,0x0A,0x04,0x14,0x0C,0x5F,0x58,0x54, /* 00000028 "2...._XT" */
0x31,0x00,0x70,0x01,0x5F,0x58,0x54,0x32, /* 00000030 "1.p._XT2" */
};
/* ASL source for this table is at the end of this file */
unsigned char OemxCode[] =
{
0x4F,0x45,0x4D,0x58,0xB0,0x00,0x00,0x00, /* 00000000 "OEMX...." */
0x02,0x54,0x4D,0x79,0x4F,0x45,0x4D,0x00, /* 00000008 ".TMyOEM." */
0x54,0x65,0x73,0x74,0x00,0x00,0x00,0x00, /* 00000010 "Test...." */
0x32,0x04,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "2...INTL" */
0x31,0x03,0x10,0x20,0x14,0x1D,0x5F,0x49, /* 00000020 "1.. .._I" */
0x4E,0x49,0x00,0x70,0x0D,0x54,0x61,0x62, /* 00000028 "NI.p.Tab" */
0x6C,0x65,0x20,0x4F,0x45,0x4D,0x58,0x20, /* 00000030 "le OEMX " */
0x72,0x75,0x6E,0x6E,0x69,0x6E,0x67,0x00, /* 00000038 "running." */
0x5B,0x31,0x10,0x22,0x5C,0x5F,0x47,0x50, /* 00000040 "[1."\_GP" */
0x45,0x14,0x06,0x5F,0x45,0x30,0x37,0x00, /* 00000048 "E.._E07." */
0x14,0x06,0x5F,0x45,0x32,0x32,0x00,0x14, /* 00000050 ".._E22.." */
0x06,0x5F,0x4C,0x33,0x31,0x00,0x14,0x06, /* 00000058 "._L31..." */
0x5F,0x4C,0x36,0x36,0x00,0x5B,0x82,0x10, /* 00000060 "_L66.[.." */
0x4F,0x45,0x4D,0x31,0x08,0x5F,0x50,0x52, /* 00000068 "OEM1._PR" */
0x57,0x12,0x05,0x02,0x0A,0x07,0x00,0x5B, /* 00000070 "W......[" */
0x82,0x10,0x4F,0x45,0x4D,0x32,0x08,0x5F, /* 00000078 "..OEM2._" */
0x50,0x52,0x57,0x12,0x05,0x02,0x0A,0x66, /* 00000080 "PRW....f" */
0x00,0x10,0x26,0x5C,0x47,0x50,0x45,0x32, /* 00000088 "..&\GPE2" */
0x14,0x06,0x5F,0x4C,0x30,0x31,0x00,0x14, /* 00000090 ".._L01.." */
0x06,0x5F,0x45,0x30,0x37,0x00,0x08,0x5F, /* 00000098 "._E07.._" */
0x50,0x52,0x57,0x12,0x0C,0x02,0x12,0x08, /* 000000A0 "PRW....." */
0x02,0x5C,0x47,0x50,0x45,0x32,0x01,0x00 /* 000000A8 ".\GPE2.." */
};
/*
* Example installable control method
*
* DefinitionBlock ("", "DSDT", 2, "Intel", "MTHDTEST", 0x20090512)
* {
* Method (\_SI_._T97, 1, Serialized)
* {
* Store ("Example installed method", Debug)
* Store (Arg0, Debug)
* Return ()
* }
* }
*
* Compiled byte code below.
*/
unsigned char MethodCode[] =
{
0x44,0x53,0x44,0x54,0x53,0x00,0x00,0x00, /* 00000000 "DSDTS..." */
0x02,0xF9,0x49,0x6E,0x74,0x65,0x6C,0x00, /* 00000008 "..Intel." */
0x4D,0x54,0x48,0x44,0x54,0x45,0x53,0x54, /* 00000010 "MTHDTEST" */
0x12,0x05,0x09,0x20,0x49,0x4E,0x54,0x4C, /* 00000018 "... INTL" */
0x22,0x04,0x09,0x20,0x14,0x2E,0x2E,0x5F, /* 00000020 "".. ..._" */
0x54,0x49,0x5F,0x5F,0x54,0x39,0x37,0x09, /* 00000028 "SI__T97." */
0x70,0x0D,0x45,0x78,0x61,0x6D,0x70,0x6C, /* 00000030 "p.Exampl" */
0x65,0x20,0x69,0x6E,0x73,0x74,0x61,0x6C, /* 00000038 "e instal" */
0x6C,0x65,0x64,0x20,0x6D,0x65,0x74,0x68, /* 00000040 "led meth" */
0x6F,0x64,0x00,0x5B,0x31,0x70,0x68,0x5B, /* 00000048 "od.[1ph[" */
0x31,0xA4,0x00,
};
/*
* We need a local FADT so that the hardware subcomponent will function,
* even though the underlying OSD HW access functions don't do
* anything.
*/
ACPI_TABLE_HEADER *DsdtToInstallOverride;
ACPI_TABLE_RSDP LocalRSDP;
ACPI_TABLE_FADT LocalFADT;
ACPI_TABLE_FACS LocalFACS;
ACPI_TABLE_HEADER LocalTEST;
ACPI_TABLE_HEADER LocalBADTABLE;
ACPI_TABLE_RSDT *LocalRSDT;
#define BASE_RSDT_TABLES 7
#define BASE_RSDT_SIZE (sizeof (ACPI_TABLE_RSDT) + ((BASE_RSDT_TABLES -1) * sizeof (UINT32)))
#define ACPI_MAX_INIT_TABLES (32)
static ACPI_TABLE_DESC Tables[ACPI_MAX_INIT_TABLES];
/******************************************************************************
*
* FUNCTION: AeTableOverride
*
* DESCRIPTION: Local implementation of AcpiOsTableOverride.
* Exercise the override mechanism
*
*****************************************************************************/
void
AeTableOverride (
ACPI_TABLE_HEADER *ExistingTable,
ACPI_TABLE_HEADER **NewTable)
{
/* This code exercises the table override mechanism in the core */
if (ACPI_COMPARE_NAME (ExistingTable->Signature, ACPI_SIG_DSDT))
{
*NewTable = DsdtToInstallOverride;
}
/* This code tests override of dynamically loaded tables */
else if (ACPI_COMPARE_NAME (ExistingTable->Signature, "TSDT"))
{
*NewTable = ACPI_CAST_PTR (ACPI_TABLE_HEADER, Ssdt3Code);
}
}
/******************************************************************************
*
* FUNCTION: AeBuildLocalTables
*
* PARAMETERS: TableCount - Number of tables on the command line
* TableList - List of actual tables from files
*
* RETURN: Status
*
* DESCRIPTION: Build a complete ACPI table chain, with a local RSDP, RSDT,
* FADT, and several other test tables.
*
*****************************************************************************/
ACPI_STATUS
AeBuildLocalTables (
UINT32 TableCount,
AE_TABLE_DESC *TableList)
{
ACPI_PHYSICAL_ADDRESS DsdtAddress = 0;
UINT32 RsdtSize;
AE_TABLE_DESC *NextTable;
UINT32 NextIndex;
ACPI_TABLE_FADT *ExternalFadt = NULL;
/*
* Update the table count. For DSDT, it is not put into the RSDT. For
* FADT, this is already accounted for since we usually install a
* local FADT.
*/
NextTable = TableList;
while (NextTable)
{
if (ACPI_COMPARE_NAME (NextTable->Table->Signature, ACPI_SIG_DSDT) ||
ACPI_COMPARE_NAME (NextTable->Table->Signature, ACPI_SIG_FADT))
{
TableCount--;
}
NextTable = NextTable->Next;
}
RsdtSize = BASE_RSDT_SIZE + (TableCount * sizeof (UINT32));
/* Build an RSDT */
LocalRSDT = AcpiOsAllocate (RsdtSize);
if (!LocalRSDT)
{
return AE_NO_MEMORY;
}
ACPI_MEMSET (LocalRSDT, 0, RsdtSize);
ACPI_STRNCPY (LocalRSDT->Header.Signature, ACPI_SIG_RSDT, 4);
LocalRSDT->Header.Length = RsdtSize;
LocalRSDT->TableOffsetEntry[0] = ACPI_PTR_TO_PHYSADDR (&LocalTEST);
LocalRSDT->TableOffsetEntry[1] = ACPI_PTR_TO_PHYSADDR (&LocalBADTABLE);
LocalRSDT->TableOffsetEntry[2] = ACPI_PTR_TO_PHYSADDR (&LocalFADT);
/* Install two SSDTs to test multiple table support */
LocalRSDT->TableOffsetEntry[3] = ACPI_PTR_TO_PHYSADDR (&Ssdt1Code);
LocalRSDT->TableOffsetEntry[4] = ACPI_PTR_TO_PHYSADDR (&Ssdt2Code);
/* Install the OEM1 table to test LoadTable */
LocalRSDT->TableOffsetEntry[5] = ACPI_PTR_TO_PHYSADDR (&Oem1Code);
/* Install the OEMx table to test LoadTable */
LocalRSDT->TableOffsetEntry[6] = ACPI_PTR_TO_PHYSADDR (&OemxCode);
/*
* Install the user tables. The DSDT must be installed in the FADT.
* All other tables are installed directly into the RSDT.
*/
NextIndex = BASE_RSDT_TABLES;
NextTable = TableList;
while (NextTable)
{
/*
* Incoming DSDT or FADT are special cases. All other tables are
* just immediately installed into the RSDT.
*/
if (ACPI_COMPARE_NAME (NextTable->Table->Signature, ACPI_SIG_DSDT))
{
if (DsdtAddress)
{
printf ("Already found a DSDT, only one allowed\n");
return AE_ALREADY_EXISTS;
}
/* The incoming user table is a DSDT */
DsdtAddress = ACPI_PTR_TO_PHYSADDR (&DsdtCode);
DsdtToInstallOverride = NextTable->Table;
}
else if (ACPI_COMPARE_NAME (NextTable->Table->Signature, ACPI_SIG_FADT))
{
ExternalFadt = ACPI_CAST_PTR (ACPI_TABLE_FADT, NextTable->Table);
LocalRSDT->TableOffsetEntry[2] = ACPI_PTR_TO_PHYSADDR (NextTable->Table);
}
else
{
/* Install the table in the RSDT */
LocalRSDT->TableOffsetEntry[NextIndex] = ACPI_PTR_TO_PHYSADDR (NextTable->Table);
NextIndex++;
}
NextTable = NextTable->Next;
}
/* Build an RSDP */
ACPI_MEMSET (&LocalRSDP, 0, sizeof (ACPI_TABLE_RSDP));
ACPI_MEMCPY (LocalRSDP.Signature, ACPI_SIG_RSDP, 8);
ACPI_MEMCPY (LocalRSDP.OemId, "I_TEST", 6);
LocalRSDP.Revision = 1;
LocalRSDP.RsdtPhysicalAddress = ACPI_PTR_TO_PHYSADDR (LocalRSDT);
LocalRSDP.Length = sizeof (ACPI_TABLE_RSDT);
/* Set checksums for both RSDT and RSDP */
LocalRSDT->Header.Checksum = (UINT8) -AcpiTbChecksum (
(void *) LocalRSDT, LocalRSDT->Header.Length);
LocalRSDP.Checksum = (UINT8) -AcpiTbChecksum (
(void *) &LocalRSDP, ACPI_RSDP_CHECKSUM_LENGTH);
if (!DsdtAddress)
{
/* Use the local DSDT because incoming table(s) are all SSDT(s) */
DsdtAddress = ACPI_PTR_TO_PHYSADDR (LocalDsdtCode);
DsdtToInstallOverride = ACPI_CAST_PTR (ACPI_TABLE_HEADER, LocalDsdtCode);
}
if (ExternalFadt)
{
/*
* Use the external FADT, but we must update the DSDT/FACS addresses
* as well as the checksum
*/
ExternalFadt->Dsdt = DsdtAddress;
ExternalFadt->Facs = ACPI_PTR_TO_PHYSADDR (&LocalFACS);
if (ExternalFadt->Header.Length > ACPI_PTR_DIFF (&ExternalFadt->XDsdt, ExternalFadt))
{
ExternalFadt->XDsdt = DsdtAddress;
ExternalFadt->XFacs = ACPI_PTR_TO_PHYSADDR (&LocalFACS);
}
/* Complete the FADT with the checksum */
ExternalFadt->Header.Checksum = 0;
ExternalFadt->Header.Checksum = (UINT8) -AcpiTbChecksum (
(void *) ExternalFadt, ExternalFadt->Header.Length);
}
else
{
/*
* Build a local FADT so we can test the hardware/event init
*/
ACPI_MEMSET (&LocalFADT, 0, sizeof (ACPI_TABLE_FADT));
ACPI_STRNCPY (LocalFADT.Header.Signature, ACPI_SIG_FADT, 4);
/* Setup FADT header and DSDT/FACS addresses */
LocalFADT.Dsdt = DsdtAddress;
LocalFADT.Facs = ACPI_PTR_TO_PHYSADDR (&LocalFACS);
LocalFADT.XDsdt = DsdtAddress;
LocalFADT.XFacs = ACPI_PTR_TO_PHYSADDR (&LocalFACS);
LocalFADT.Header.Revision = 3;
LocalFADT.Header.Length = sizeof (ACPI_TABLE_FADT);
/* Miscellaneous FADT fields */
LocalFADT.Gpe0BlockLength = 16;
LocalFADT.Gpe1BlockLength = 6;
LocalFADT.Gpe1Base = 96;
LocalFADT.Pm1EventLength = 4;
LocalFADT.Pm1ControlLength = 2;
LocalFADT.PmTimerLength = 4;
LocalFADT.Gpe0Block = 0x00001234;
LocalFADT.Gpe1Block = 0x00005678;
LocalFADT.Pm1aEventBlock = 0x00001aaa;
LocalFADT.Pm1bEventBlock = 0x00001bbb;
LocalFADT.PmTimerBlock = 0xA0;
LocalFADT.Pm1aControlBlock = 0xB0;
/* Setup one example X-64 field */
LocalFADT.XPm1bEventBlock.SpaceId = ACPI_ADR_SPACE_SYSTEM_IO;
LocalFADT.XPm1bEventBlock.Address = LocalFADT.Pm1bEventBlock;
LocalFADT.XPm1bEventBlock.BitWidth = (UINT8) ACPI_MUL_8 (LocalFADT.Pm1EventLength);
/* Complete the FADT with the checksum */
LocalFADT.Header.Checksum = 0;
LocalFADT.Header.Checksum = (UINT8) -AcpiTbChecksum (
(void *) &LocalFADT, LocalFADT.Header.Length);
}
/* Build a FACS */
ACPI_MEMSET (&LocalFACS, 0, sizeof (ACPI_TABLE_FACS));
ACPI_STRNCPY (LocalFACS.Signature, ACPI_SIG_FACS, 4);
LocalFACS.Length = sizeof (ACPI_TABLE_FACS);
LocalFACS.GlobalLock = 0x11AA0011;
/* Build a fake table [TEST] so that we make sure that the CA core ignores it */
ACPI_MEMSET (&LocalTEST, 0, sizeof (ACPI_TABLE_HEADER));
ACPI_STRNCPY (LocalTEST.Signature, "TEST", 4);
LocalTEST.Revision = 1;
LocalTEST.Length = sizeof (ACPI_TABLE_HEADER);
LocalTEST.Checksum = (UINT8) -AcpiTbChecksum (
(void *) &LocalTEST, LocalTEST.Length);
/* Build a fake table with a bad signature [BAD!] so that we make sure that the CA core ignores it */
ACPI_MEMSET (&LocalBADTABLE, 0, sizeof (ACPI_TABLE_HEADER));
ACPI_STRNCPY (LocalBADTABLE.Signature, "BAD!", 4);
LocalBADTABLE.Revision = 1;
LocalBADTABLE.Length = sizeof (ACPI_TABLE_HEADER);
LocalBADTABLE.Checksum = (UINT8) -AcpiTbChecksum (
(void *) &LocalBADTABLE, LocalBADTABLE.Length);
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: AeInstallTables
*
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: Install the various ACPI tables
*
*****************************************************************************/
ACPI_STATUS
AeInstallTables (
void)
{
ACPI_STATUS Status;
Status = AcpiInitializeTables (Tables, ACPI_MAX_INIT_TABLES, TRUE);
Status = AcpiReallocateRootTable ();
Status = AcpiLoadTables ();
/*
* 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);
}
/******************************************************************************
*
* FUNCTION: AeLocalGetRootPointer
*
* PARAMETERS: Flags - not used
* Address - Where the root pointer is returned
*
* RETURN: Status
*
* DESCRIPTION: Return a local RSDP, used to dynamically load tables via the
* standard ACPI mechanism.
*
*****************************************************************************/
ACPI_PHYSICAL_ADDRESS
AeLocalGetRootPointer (
void)
{
return ((ACPI_PHYSICAL_ADDRESS) &LocalRSDP);
}
#if 0
/******************************************************************************
*
* DESCRIPTION: ASL tables that are used in RSDT/XSDT, also used to test
* Load/LoadTable operators.
*
*****************************************************************************/
DefinitionBlock ("", "OEMX", 2, "MyOEM", "Test", 0x00000432)
{
External (GPE2, DeviceObj)
Method (_INI)
{
Store ("Table OEMX running", Debug)
}
Scope (\_GPE)
{
Method (_E07) {}
Method (_E22) {}
Method (_L31) {}
Method (_L66) {}
}
Device (OEM1)
{
Name (_PRW, Package(){7,0})
}
Device (OEM2)
{
Name (_PRW, Package(){0x66,0})
}
Scope (\GPE2)
{
Method (_L01) {}
Method (_E07) {}
Name (_PRW, Package() {Package() {\GPE2, 1}, 0})
}
}
/* Parent gr.asl file */
DefinitionBlock ("", "DSDT", 2, "Intel", "Many", 0x00000001)
{
Name (BUF1, Buffer()
{
0x4F,0x45,0x4D,0x58,0xB0,0x00,0x00,0x00, /* 00000000 "OEMX...." */
0x02,0x54,0x4D,0x79,0x4F,0x45,0x4D,0x00, /* 00000008 ".TMyOEM." */
0x54,0x65,0x73,0x74,0x00,0x00,0x00,0x00, /* 00000010 "Test...." */
0x32,0x04,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "2...INTL" */
0x31,0x03,0x10,0x20,0x14,0x1D,0x5F,0x49, /* 00000020 "1.. .._I" */
0x4E,0x49,0x00,0x70,0x0D,0x54,0x61,0x62, /* 00000028 "NI.p.Tab" */
0x6C,0x65,0x20,0x4F,0x45,0x4D,0x58,0x20, /* 00000030 "le OEMX " */
0x72,0x75,0x6E,0x6E,0x69,0x6E,0x67,0x00, /* 00000038 "running." */
0x5B,0x31,0x10,0x22,0x5C,0x5F,0x47,0x50, /* 00000040 "[1."\_GP" */
0x45,0x14,0x06,0x5F,0x45,0x30,0x37,0x00, /* 00000048 "E.._E07." */
0x14,0x06,0x5F,0x45,0x32,0x32,0x00,0x14, /* 00000050 ".._E22.." */
0x06,0x5F,0x4C,0x33,0x31,0x00,0x14,0x06, /* 00000058 "._L31..." */
0x5F,0x4C,0x36,0x36,0x00,0x5B,0x82,0x10, /* 00000060 "_L66.[.." */
0x4F,0x45,0x4D,0x31,0x08,0x5F,0x50,0x52, /* 00000068 "OEM1._PR" */
0x57,0x12,0x05,0x02,0x0A,0x07,0x00,0x5B, /* 00000070 "W......[" */
0x82,0x10,0x4F,0x45,0x4D,0x32,0x08,0x5F, /* 00000078 "..OEM2._" */
0x50,0x52,0x57,0x12,0x05,0x02,0x0A,0x66, /* 00000080 "PRW....f" */
0x00,0x10,0x26,0x5C,0x47,0x50,0x45,0x32, /* 00000088 "..&\GPE2" */
0x14,0x06,0x5F,0x4C,0x30,0x31,0x00,0x14, /* 00000090 ".._L01.." */
0x06,0x5F,0x45,0x30,0x37,0x00,0x08,0x5F, /* 00000098 "._E07.._" */
0x50,0x52,0x57,0x12,0x0C,0x02,0x12,0x08, /* 000000A0 "PRW....." */
0x02,0x5C,0x47,0x50,0x45,0x32,0x01,0x00 /* 000000A8 ".\GPE2.." */
})
Name (HNDL, 0)
Method (LD)
{
Load (BUF1, HNDL)
Store ("Load operator, handle:", Debug)
Store (HNDL, Debug)
}
Method (MAIN, 0, NotSerialized)
{
Store ("Loading OEMX table", Debug)
Store (LoadTable ("OEMX", "MyOEM", "Test"), Debug)
}
Scope (\_GPE)
{
Method (_L08) {}
Method (_E08) {}
Method (_L0B) {}
}
Device (DEV0)
{
Name (_PRW, Package() {0x11, 0})
}
Device (\GPE2)
{
Method (_L00) {}
}
}
#endif

/drivers/devman/acpica/tools/acpiexec/aetables.o
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/drivers/devman/acpica/tools/acpiexec/osunixdir.c
0,0 → 1,306
/******************************************************************************
*
* Module Name: osunixdir - Unix directory access interfaces
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2010, 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
* you this software, covering your right to use that party's intellectual
* property rights.
*
* 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
* copy of the source code appearing in this file ("Covered Code") an
* irrevocable, perpetual, worldwide license under Intel's copyrights in the
* base code distributed originally by Intel ("Original Intel Code") to copy,
* make derivatives, distribute, use and display any portion of the Covered
* Code in any form, with the right to sublicense such rights; and
*
* 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
* license (with the right to sublicense), under only those claims of Intel
* patents that are infringed by the Original Intel Code, to make, use, sell,
* 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
* is granted directly or by implication, estoppel or otherwise;
*
* The above copyright and patent license is granted only if the following
* conditions are met:
*
* 3. Conditions
*
* 3.1. Redistribution of Source with Rights to Further Distribute Source.
* 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,
* 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
* must include a prominent statement that the modification is derived,
* directly or indirectly, from Original Intel Code.
*
* 3.2. Redistribution of Source with no Rights to Further Distribute Source.
* 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
* 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
* property embodied in the software Licensee provides to its licensee, and
* not to intellectual property embodied in modifications its licensee may
* make.
*
* 3.3. Redistribution of Executable. Redistribution in executable form of any
* substantial portion of the Covered Code or modification must reproduce the
* above Copyright Notice, and the following Disclaimer and Export Compliance
* provision in the documentation and/or other materials provided with the
* distribution.
*
* 3.4. Intel retains all right, title, and interest in and to the Original
* Intel Code.
*
* 3.5. Neither the name Intel nor any other trademark owned or controlled by
* Intel shall be used in advertising or otherwise to promote the sale, use or
* other dealings in products derived from or relating to the Covered Code
* without prior written authorization from Intel.
*
* 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
* IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
* OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
* 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
* 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
* 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
* compliance with all laws, regulations, orders, or other restrictions of the
* U.S. Export Administration Regulations. Licensee agrees that neither it nor
* any of its subsidiaries will export/re-export any technical data, process,
* software, or service, directly or indirectly, to any country for which the
* United States government or any agency thereof requires an export license,
* other governmental approval, or letter of assurance, without first obtaining
* such license, approval or letter.
*
*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <fnmatch.h>
#include <ctype.h>
#include <sys/stat.h>
#include "acpisrc.h"
typedef struct ExternalFindInfo
{
char *DirPathname;
DIR *DirPtr;
char temp_buffer[128];
char *WildcardSpec;
char RequestedFileType;
} EXTERNAL_FIND_INFO;
/*******************************************************************************
*
* FUNCTION: AcpiOsOpenDirectory
*
* PARAMETERS: DirPathname - Full pathname to the directory
* WildcardSpec - string of the form "*.c", etc.
*
* RETURN: A directory "handle" to be used in subsequent search operations.
* NULL returned on failure.
*
* DESCRIPTION: Open a directory in preparation for a wildcard search
*
******************************************************************************/
void *
AcpiOsOpenDirectory (
char *DirPathname,
char *WildcardSpec,
char RequestedFileType)
{
EXTERNAL_FIND_INFO *ExternalInfo;
DIR *dir;
/* Allocate the info struct that will be returned to the caller */
ExternalInfo = calloc (sizeof (EXTERNAL_FIND_INFO), 1);
if (!ExternalInfo)
{
return (NULL);
}
/* Get the directory stream */
dir = opendir (DirPathname);
if (!dir)
{
free (ExternalInfo);
return (NULL);
}
/* Save the info in the return structure */
ExternalInfo->WildcardSpec = WildcardSpec;
ExternalInfo->RequestedFileType = RequestedFileType;
ExternalInfo->DirPathname = DirPathname;
ExternalInfo->DirPtr = dir;
return (ExternalInfo);
}
/*******************************************************************************
*
* FUNCTION: AcpiOsGetNextFilename
*
* PARAMETERS: DirHandle - Created via AcpiOsOpenDirectory
*
* RETURN: Next filename matched. NULL if no more matches.
*
* DESCRIPTION: Get the next file in the directory that matches the wildcard
* specification.
*
******************************************************************************/
char *
AcpiOsGetNextFilename (
void *DirHandle)
{
EXTERNAL_FIND_INFO *ExternalInfo = DirHandle;
struct dirent *dir_entry;
char *temp_str;
int str_len;
struct stat temp_stat;
int err;
while ((dir_entry = readdir (ExternalInfo->DirPtr)))
{
if (!fnmatch (ExternalInfo->WildcardSpec, dir_entry->d_name, 0))
{
if (dir_entry->d_name[0] == '.')
continue;
str_len = strlen (dir_entry->d_name) +
strlen (ExternalInfo->DirPathname) + 2;
temp_str = calloc (str_len, 1);
if (!temp_str)
{
printf ("Could not allocate buffer for temporary string\n");
return NULL;
}
strcpy (temp_str, ExternalInfo->DirPathname);
strcat (temp_str, "/");
strcat (temp_str, dir_entry->d_name);
err = stat (temp_str, &temp_stat);
free (temp_str);
if (err == -1)
{
printf ("stat() error - should not happen\n");
return NULL;
}
if ((S_ISDIR (temp_stat.st_mode)
&& (ExternalInfo->RequestedFileType == REQUEST_DIR_ONLY))
||
((!S_ISDIR (temp_stat.st_mode)
&& ExternalInfo->RequestedFileType == REQUEST_FILE_ONLY)))
{
/* copy to a temp buffer because dir_entry struct is on the stack */
strcpy (ExternalInfo->temp_buffer, dir_entry->d_name);
return (ExternalInfo->temp_buffer);
}
}
}
return NULL;
}
/*******************************************************************************
*
* FUNCTION: AcpiOsCloseDirectory
*
* PARAMETERS: DirHandle - Created via AcpiOsOpenDirectory
*
* RETURN: None.
*
* DESCRIPTION: Close the open directory and cleanup.
*
******************************************************************************/
void
AcpiOsCloseDirectory (
void *DirHandle)
{
EXTERNAL_FIND_INFO *ExternalInfo = DirHandle;
/* Close the directory and free allocations */
closedir (ExternalInfo->DirPtr);
free (DirHandle);
}
/* Other functions acpisrc uses but that aren't standard on Unix */
/* lowercase a string */
char*
strlwr (
char *str)
{
int length;
int i;
length = strlen (str);
for (i = 0; i < length; i++)
{
str[i] = tolower ((int) str[i]);
}
return (str);
}