d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge ACPICA 20091013.

Browse Source
This commit is contained in:
jkim 2009-10-19 16:12:58 +00:00
commit fca91fda32
23 changed files with 1109 additions and 490 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
sys/contrib/dev/acpica/changes.txt
View File

@ -1,10 +1,69 @@
----------------------------------------
03 September 2009. Summary of changes for version 20090903:
13 October 2009. Summary of changes for version 20091013:
This release is available at www.acpica.org/downloads
1) ACPI CA Core Subsystem:
Fixed a problem where an Operation Region _REG method could be executed more
than once. If a custom address space handler is installed by the host before
the "initialize operation regions" phase of the ACPICA initialization, any
_REG methods for that address space could be executed twice. This change
fixes the problem. ACPICA BZ 427. Lin Ming.
Fixed a possible memory leak for the Scope() ASL operator. When the exact
invocation of "Scope(\)" is executed (change scope to root), one internal
operand object was leaked. Lin Ming.
Implemented a run-time repair for the _MAT predefined method. If the _MAT
return value is defined as a Field object in the AML, and the field
size is less than or equal to the default width of an integer (32 or 64),_MAT
can incorrectly return an Integer instead of a Buffer. ACPICA now
automatically repairs this problem. ACPICA BZ 810.
Implemented a run-time repair for the _BIF and _BIX predefined methods. The
"OEM Information" field is often incorrectly returned as an Integer with
value zero if the field is not supported by the platform. This is due to an
ambiguity in the ACPI specification. The field should always be a string.
ACPICA now automatically repairs this problem by returning a NULL string
within the returned Package. ACPICA BZ 807.
Example Code and Data Size: These are the sizes for the OS-independent
acpica.lib produced by the Microsoft Visual C++ 6.0 32-bit compiler. The
debug version of the code includes the debug output trace mechanism and has a
much larger code and data size.
Previous Release:
Non-Debug Version: 85.6K Code, 18.0K Data, 103.6K Total
Debug Version: 161.7K Code, 50.9K Data, 212.6K Total
Current Release:
Non-Debug Version: 85.8K Code, 18.0K Data, 103.8K Total
Debug Version: 161.8K Code, 50.6K Data, 212.4K Total
2) iASL Compiler/Disassembler and Tools:
Disassembler: Fixed a problem where references to external symbols that
contained one or more parent-prefixes (carats) were not handled correctly,
possibly causing a fault. ACPICA BZ 806. Lin Ming.
Disassembler: Restructured the code so that all functions that handle
external symbols are in a single module. One new file is added,
common/dmextern.c.
AML Debugger: Added a max count argument for the Batch command (which
executes multiple predefined methods within the namespace.)
iASL: Updated the compiler documentation (User Reference.) Available at
http://www.acpica.org/documentation/. ACPICA BZ 750.
AcpiXtract: Updated for Lint and other formatting changes. Close all open
files.
----------------------------------------
03 September 2009. Summary of changes for version 20090903:
1) ACPI CA Core Subsystem:
For Windows Vista compatibility, added the automatic execution of an _INI
method located at the namespace root (\_INI). This method is executed at
table load time. This support is in addition to the automatic execution of
@ -74,8 +133,6 @@ subtables.
----------------------------------------
30 July 2009. Summary of changes for version 20090730:
This release is available at www.acpica.org/downloads
The ACPI 4.0 implementation for ACPICA is complete with this release.
1) ACPI CA Core Subsystem:
@ -146,8 +203,6 @@ changes to existing tables. ACPICA BZ 775.
----------------------------------------
25 June 2009. Summary of changes for version 20090625:
This release is available at www.acpica.org/downloads
The ACPI 4.0 Specification was released on June 16 and is available at
www.acpi.info. ACPICA implementation of ACPI 4.0 is underway and will
continue for the next few releases.
@ -224,8 +279,6 @@ predefined names and control methods (31 total). ACPICA BZ 769.
----------------------------------------
21 May 2009. Summary of changes for version 20090521:
This release is available at www.acpica.org/downloads
1) ACPI CA Core Subsystem:
Disabled the preservation of the SCI enable bit in the PM1 control register.
@ -297,8 +350,6 @@ after an invalid sub-table ID.
----------------------------------------
22 April 2009. Summary of changes for version 20090422:
This release is available at www.acpica.org/downloads
1) ACPI CA Core Subsystem:
Fixed a compatibility issue with the recently released I/O port protection

24
sys/contrib/dev/acpica/common/adfile.c
View File

@ -119,7 +119,6 @@
#include <contrib/dev/acpica/include/acapps.h>
#include <stdio.h>
#include <string.h>
#define _COMPONENT ACPI_TOOLS
@ -135,12 +134,13 @@ AdWriteBuffer (
char FilenameBuf[20];
/******************************************************************************
*
* FUNCTION: AfGenerateFilename
*
* PARAMETERS: Prefix - prefix string
* TableId - The table ID
* PARAMETERS: Prefix - prefix string
* TableId - The table ID
*
* RETURN: Pointer to the completed string
*
@ -180,9 +180,9 @@ AdGenerateFilename (
*
* FUNCTION: AfWriteBuffer
*
* PARAMETERS: Filename - name of file
* Buffer - data to write
* Length - length of data
* PARAMETERS: Filename - name of file
* Buffer - data to write
* Length - length of data
*
* RETURN: Actual number of bytes written
*
@ -217,10 +217,10 @@ AdWriteBuffer (
*
* FUNCTION: AfWriteTable
*
* PARAMETERS: Table - pointer to the ACPI table
* Length - length of the table
* TableName - the table signature
* OemTableID - from the table header
* PARAMETERS: Table - pointer to the ACPI table
* Length - length of the table
* TableName - the table signature
* OemTableID - from the table header
*
* RETURN: None
*
@ -272,7 +272,7 @@ FlGenerateFilename (
* Copy the original filename to a new buffer. Leave room for the worst case
* where we append the suffix, an added dot and the null terminator.
*/
NewFilename = ACPI_ALLOCATE_ZEROED (
NewFilename = ACPI_ALLOCATE_ZEROED ((ACPI_SIZE)
strlen (InputFilename) + strlen (Suffix) + 2);
strcpy (NewFilename, InputFilename);
@ -314,7 +314,7 @@ FlStrdup (
char *NewString;
NewString = ACPI_ALLOCATE (strlen (String) + 1);
NewString = ACPI_ALLOCATE ((ACPI_SIZE) strlen (String) + 1);
if (!NewString)
{
return (NULL);

159
sys/contrib/dev/acpica/common/adisasm.c
View File

@ -132,14 +132,18 @@
#define _COMPONENT ACPI_TOOLS
ACPI_MODULE_NAME ("adisasm")
extern int AslCompilerdebug;
extern int AslCompilerdebug;
extern char *Gbl_ExternalFilename;
ACPI_STATUS
LsDisplayNamespace (
void);
void
LsSetupNsList (void * Handle);
LsSetupNsList (
void *Handle);
/* Local prototypes */
@ -153,14 +157,6 @@ void
AdDisassemblerHeader (
char *Filename);
void
AdAddExternalsToNamespace (
void);
UINT32
AdMethodExternalCount (
void);
ACPI_STATUS
AdDeferredParse (
ACPI_PARSE_OBJECT *Op,
@ -171,8 +167,6 @@ ACPI_STATUS
AdParseDeferredOps (
ACPI_PARSE_OBJECT *Root);
ACPI_PARSE_OBJECT *AcpiGbl_ParseOpRoot;
/* Stubs for ASL compiler */
@ -192,7 +186,6 @@ AcpiDsMethodError (
{
return (Status);
}
#endif
ACPI_STATUS
@ -238,18 +231,19 @@ AcpiDsMethodDataInitArgs (
}
ACPI_TABLE_DESC LocalTables[1];
static ACPI_TABLE_DESC LocalTables[1];
static ACPI_PARSE_OBJECT *AcpiGbl_ParseOpRoot;
/*******************************************************************************
*
* FUNCTION: AdInitialize
*
* PARAMETERS: None.
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: CA initialization
* DESCRIPTION: ACPICA and local initialization
*
******************************************************************************/
@ -296,89 +290,15 @@ AdInitialize (
}
/*******************************************************************************
*
* FUNCTION: AdAddExternalsToNamespace
*
* PARAMETERS:
*
* RETURN: None
*
* DESCRIPTION:
*
******************************************************************************/
void
AdAddExternalsToNamespace (
void)
{
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *Node;
ACPI_EXTERNAL_LIST *External = AcpiGbl_ExternalList;
ACPI_OPERAND_OBJECT *MethodDesc;
while (External)
{
Status = AcpiNsLookup (NULL, External->InternalPath, External->Type,
ACPI_IMODE_LOAD_PASS1, ACPI_NS_EXTERNAL | ACPI_NS_DONT_OPEN_SCOPE,
NULL, &Node);
if (External->Type == ACPI_TYPE_METHOD)
{
MethodDesc = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);
MethodDesc->Method.ParamCount = (UINT8) External->Value;
Node->Object = MethodDesc;
}
External = External->Next;
}
}
/*******************************************************************************
*
* FUNCTION: AdMethodExternalCount
*
* PARAMETERS: None
*
* RETURN: Status
*
* DESCRIPTION: Return the number of externals that have been generated
*
******************************************************************************/
UINT32
AdMethodExternalCount (
void)
{
ACPI_EXTERNAL_LIST *External = AcpiGbl_ExternalList;
UINT32 Count = 0;
while (External)
{
if (External->Type == ACPI_TYPE_METHOD)
{
Count++;
}
External = External->Next;
}
return (Count);
}
/******************************************************************************
*
* FUNCTION: AdAmlDisassemble
*
* PARAMETERS: Filename - AML input filename
* OutToFile - TRUE if output should go to a file
* Prefix - Path prefix for output
* OutFilename - where the filename is returned
* GetAllTables - TRUE if all tables are desired
* PARAMETERS: Filename - AML input filename
* OutToFile - TRUE if output should go to a file
* Prefix - Path prefix for output
* OutFilename - where the filename is returned
* GetAllTables - TRUE if all tables are desired
*
* RETURN: Status
*
@ -386,8 +306,6 @@ AdMethodExternalCount (
*
*****************************************************************************/
extern char *Gbl_ExternalFilename;
ACPI_STATUS
AdAmlDisassemble (
BOOLEAN OutToFile,
@ -403,12 +321,11 @@ AdAmlDisassemble (
ACPI_TABLE_HEADER *Table = NULL;
ACPI_TABLE_HEADER *ExternalTable;
ACPI_OWNER_ID OwnerId;
ACPI_EXTERNAL_LIST *NextExternal;
/*
* Input: AML Code from either a file,
* or via GetTables (memory or registry)
* Input: AML code from either a file or via GetTables (memory or
* registry)
*/
if (Filename)
{
@ -462,13 +379,7 @@ AdAmlDisassemble (
/* Clear external list generated by Scope in external tables */
while (AcpiGbl_ExternalList)
{
NextExternal = AcpiGbl_ExternalList->Next;
ACPI_FREE (AcpiGbl_ExternalList->Path);
ACPI_FREE (AcpiGbl_ExternalList);
AcpiGbl_ExternalList = NextExternal;
}
AcpiDmClearExternalList ();
}
}
else
@ -501,8 +412,7 @@ AdAmlDisassemble (
}
/*
* Output: ASL code.
* Redirect to a file if requested
* Output: ASL code. Redirect to a file if requested
*/
if (OutToFile)
{
@ -589,11 +499,11 @@ AdAmlDisassemble (
* tree with the new information (namely, the number of arguments per
* method)
*/
if (AdMethodExternalCount ())
if (AcpiDmGetExternalMethodCount ())
{
fprintf (stderr,
"\nFound %d external control methods, reparsing with new information\n",
AdMethodExternalCount());
AcpiDmGetExternalMethodCount ());
/*
* Reparse, rebuild namespace. no need to xref namespace
@ -611,7 +521,7 @@ AdAmlDisassemble (
AcpiGbl_RootNodeStruct.Flags = ANOBJ_END_OF_PEER_LIST;
Status = AcpiNsRootInitialize ();
AdAddExternalsToNamespace ();
AcpiDmAddExternalsToNamespace ();
/* Parse table. No need to reload it, however (FALSE) */
@ -855,9 +765,9 @@ AdDisplayTables (
*
* FUNCTION: AdDeferredParse
*
* PARAMETERS: Op - Root Op of the deferred opcode
* Aml - Pointer to the raw AML
* AmlLength - Length of the AML
* PARAMETERS: Op - Root Op of the deferred opcode
* Aml - Pointer to the raw AML
* AmlLength - Length of the AML
*
* RETURN: Status
*
@ -981,7 +891,7 @@ AdDeferredParse (
*
* FUNCTION: AdParseDeferredOps
*
* PARAMETERS: Root - Root of the parse tree
* PARAMETERS: Root - Root of the parse tree
*
* RETURN: Status
*
@ -1055,8 +965,8 @@ AdParseDeferredOps (
*
* FUNCTION: AdGetLocalTables
*
* PARAMETERS: Filename - Not used
* GetAllTables - TRUE if all tables are desired
* PARAMETERS: Filename - Not used
* GetAllTables - TRUE if all tables are desired
*
* RETURN: Status
*
@ -1138,6 +1048,11 @@ AdGetLocalTables (
Status = AcpiTbStoreTable (0, NewTable, NewTable->Length,
0, &TableIndex);
if (ACPI_FAILURE (Status))
{
fprintf (stderr, "Could not store DSDT\n");
return AE_NO_ACPI_TABLES;
}
}
else
{
@ -1169,10 +1084,10 @@ AdGetLocalTables (
*
* FUNCTION: AdParseTable
*
* PARAMETERS: Table - Pointer to the raw table
* OwnerId - Returned OwnerId of the table
* LoadTable - If add table to the global table list
* External - If this is an external table
* PARAMETERS: Table - Pointer to the raw table
* OwnerId - Returned OwnerId of the table
* LoadTable - If add table to the global table list
* External - If this is an external table
*
* RETURN: Status
*

34
sys/contrib/dev/acpica/common/adwalk.c
View File

@ -118,7 +118,6 @@
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acparser.h>
#include <contrib/dev/acpica/include/amlcode.h>
#include <contrib/dev/acpica/include/acdebug.h>
#include <contrib/dev/acpica/include/acdisasm.h>
#include <contrib/dev/acpica/include/acdispat.h>
#include <contrib/dev/acpica/include/acnamesp.h>
@ -184,7 +183,7 @@ AcpiDmResourceDescendingOp (
*
* FUNCTION: AcpiDmDumpTree
*
* PARAMETERS: Origin - Starting object
* PARAMETERS: Origin - Starting object
*
* RETURN: None
*
@ -218,7 +217,7 @@ AcpiDmDumpTree (
*
* FUNCTION: AcpiDmFindOrphanMethods
*
* PARAMETERS: Origin - Starting object
* PARAMETERS: Origin - Starting object
*
* RETURN: None
*
@ -426,7 +425,6 @@ AcpiDmDumpDescending (
void *Context)
{
ACPI_OP_WALK_INFO *Info = Context;
const ACPI_OPCODE_INFO *OpInfo;
char *Path;
@ -435,11 +433,9 @@ AcpiDmDumpDescending (
return (AE_OK);
}
OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode);
Info->Count++;
/* Most of the information (count, level, name) here */
Info->Count++;
AcpiOsPrintf ("% 5d [%2.2d] ", Info->Count, Level);
AcpiDmIndent (Level);
AcpiOsPrintf ("%-28s", AcpiPsGetOpcodeName (Op->Common.AmlOpcode));
@ -472,7 +468,7 @@ AcpiDmDumpDescending (
case AML_METHOD_OP:
case AML_DEVICE_OP:
case AML_INT_NAMEDFIELD_OP:
AcpiOsPrintf ("%4.4s", &Op->Named.Name);
AcpiOsPrintf ("%4.4s", ACPI_CAST_PTR (char, &Op->Named.Name));
break;
default:
@ -536,7 +532,7 @@ AcpiDmFindOrphanDescending (
{
/* This NamePath has no args, assume it is an integer */
AcpiDmAddToExternalList (ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
return (AE_OK);
}
@ -547,11 +543,11 @@ AcpiDmFindOrphanDescending (
{
/* One Arg means this is just a Store(Name,Target) */
AcpiDmAddToExternalList (ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
return (AE_OK);
}
AcpiDmAddToExternalList (ChildOp->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
}
break;
#endif
@ -567,7 +563,7 @@ AcpiDmFindOrphanDescending (
{
/* This NamePath has no args, assume it is an integer */
AcpiDmAddToExternalList (ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
return (AE_OK);
}
@ -576,11 +572,11 @@ AcpiDmFindOrphanDescending (
{
/* One Arg means this is just a Store(Name,Target) */
AcpiDmAddToExternalList (ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_INTEGER, 0);
return (AE_OK);
}
AcpiDmAddToExternalList (ChildOp->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
AcpiDmAddToExternalList (ChildOp, ChildOp->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
}
break;
@ -611,7 +607,7 @@ AcpiDmFindOrphanDescending (
/* And namepath is the first argument */
(ParentOp->Common.Value.Arg == Op))
{
AcpiDmAddToExternalList (Op->Common.Value.String, ACPI_TYPE_INTEGER, 0);
AcpiDmAddToExternalList (Op, Op->Common.Value.String, ACPI_TYPE_INTEGER, 0);
break;
}
}
@ -621,7 +617,7 @@ AcpiDmFindOrphanDescending (
* operator) - it *must* be a method invocation, nothing else is
* grammatically possible.
*/
AcpiDmAddToExternalList (Op->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
AcpiDmAddToExternalList (Op, Op->Common.Value.String, ACPI_TYPE_METHOD, ArgCount);
}
break;
@ -858,7 +854,7 @@ AcpiDmXrefDescendingOp (
{
if (Status == AE_NOT_FOUND)
{
AcpiDmAddToExternalList (Path, (UINT8) ObjectType, 0);
AcpiDmAddToExternalList (Op, Path, (UINT8) ObjectType, 0);
/*
* We could install this into the namespace, but we catch duplicate
@ -888,12 +884,12 @@ AcpiDmXrefDescendingOp (
if (ObjectType2 == ACPI_TYPE_METHOD)
{
AcpiDmAddToExternalList (Path, ACPI_TYPE_METHOD,
AcpiDmAddToExternalList (Op, Path, ACPI_TYPE_METHOD,
Object->Method.ParamCount);
}
else
{
AcpiDmAddToExternalList (Path, (UINT8) ObjectType2, 0);
AcpiDmAddToExternalList (Op, Path, (UINT8) ObjectType2, 0);
}
Op->Common.Node = Node;

646
sys/contrib/dev/acpica/common/dmextern.c Normal file
View File

@ -0,0 +1,646 @@
/******************************************************************************
*
* Module Name: dmextern - Support for External() ASL statements
*
*****************************************************************************/
/******************************************************************************
*
* 1. Copyright Notice
*
* Some or all of this work - Copyright (c) 1999 - 2009, 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 <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/amlcode.h>
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/acdisasm.h>
/*
* This module is used for application-level code (iASL disassembler) only.
*
* It contains the code to create and emit any necessary External() ASL
* statements for the module being disassembled.
*/
#define _COMPONENT ACPI_CA_DISASSEMBLER
ACPI_MODULE_NAME ("dmextern")
/*
* This table maps ACPI_OBJECT_TYPEs to the corresponding ASL
* ObjectTypeKeyword. Used to generate typed external declarations
*/
static const char *AcpiGbl_DmTypeNames[] =
{
/* 00 */ "", /* Type ANY */
/* 01 */ ", IntObj",
/* 02 */ ", StrObj",
/* 03 */ ", BuffObj",
/* 04 */ ", PkgObj",
/* 05 */ ", FieldUnitObj",
/* 06 */ ", DeviceObj",
/* 07 */ ", EventObj",
/* 08 */ ", MethodObj",
/* 09 */ ", MutexObj",
/* 10 */ ", OpRegionObj",
/* 11 */ ", PowerResObj",
/* 12 */ ", ProcessorObj",
/* 13 */ ", ThermalZoneObj",
/* 14 */ ", BuffFieldObj",
/* 15 */ ", DDBHandleObj",
/* 16 */ "", /* Debug object */
/* 17 */ ", FieldUnitObj",
/* 18 */ ", FieldUnitObj",
/* 19 */ ", FieldUnitObj"
};
/* Local prototypes */
static const char *
AcpiDmGetObjectTypeName (
ACPI_OBJECT_TYPE Type);
static char *
AcpiDmNormalizeParentPrefix (
ACPI_PARSE_OBJECT *Op,
char *Path);
/*******************************************************************************
*
* FUNCTION: AcpiDmGetObjectTypeName
*
* PARAMETERS: Type - An ACPI_OBJECT_TYPE
*
* RETURN: Pointer to a string
*
* DESCRIPTION: Map an object type to the ASL object type string.
*
******************************************************************************/
static const char *
AcpiDmGetObjectTypeName (
ACPI_OBJECT_TYPE Type)
{
if (Type == ACPI_TYPE_LOCAL_SCOPE)
{
Type = ACPI_TYPE_DEVICE;
}
else if (Type > ACPI_TYPE_LOCAL_INDEX_FIELD)
{
return ("");
}
return (AcpiGbl_DmTypeNames[Type]);
}
/*******************************************************************************
*
* FUNCTION: AcpiDmNormalizeParentPrefix
*
* PARAMETERS: Op - Parse op
* Path - Path with parent prefix
*
* RETURN: The full pathname to the object (from the namespace root)
*
* DESCRIPTION: Returns the full pathname of a path with parent prefix
* The caller must free the fullpath returned.
*
******************************************************************************/
static char *
AcpiDmNormalizeParentPrefix (
ACPI_PARSE_OBJECT *Op,
char *Path)
{
ACPI_NAMESPACE_NODE *Node;
char *Fullpath;
char *ParentPath;
ACPI_SIZE Length;
/* Search upwards in the parse tree until we reach a namespace node */
while (Op)
{
if (Op->Common.Node)
{
break;
}
Op = Op->Common.Parent;
}
if (!Op)
{
return (NULL);
}
/*
* Find the actual parent node for the reference:
* Remove all carat prefixes from the input path.
* There may be multiple parent prefixes (For example, ^^^M000)
*/
Node = Op->Common.Node;
while (Node && (*Path == (UINT8) AML_PARENT_PREFIX))
{
Node = AcpiNsGetParentNode (Node);
Path++;
}
if (!Node)
{
return (NULL);
}
/* Get the full pathname for the parent node */
ParentPath = AcpiNsGetExternalPathname (Node);
if (!ParentPath)
{
return (NULL);
}
Length = (ACPI_STRLEN (ParentPath) + ACPI_STRLEN (Path) + 1);
Fullpath = ACPI_ALLOCATE_ZEROED (Length);
if (!Fullpath)
{
goto Cleanup;
}
/*
* Concatenate parent fullpath and path. For example,
* parent fullpath "\_SB_", Path "^INIT", Fullpath "\_SB_.INIT"
*
* Copy the parent path
*/
ACPI_STRCAT (Fullpath, ParentPath);
/* Add dot separator (don't need dot if parent fullpath is a single "\") */
if (ParentPath[1])
{
ACPI_STRCAT (Fullpath, ".");
}
/* Copy child path (carat parent prefix(es) were skipped above) */
ACPI_STRCAT (Fullpath, Path);
Cleanup:
ACPI_FREE (ParentPath);
return (Fullpath);
}
/*******************************************************************************
*
* FUNCTION: AcpiDmAddToExternalList
*
* PARAMETERS: Op - Current parser Op
* Path - Internal (AML) path to the object
* Type - ACPI object type to be added
* Value - Arg count if adding a Method object
*
* RETURN: None
*
* DESCRIPTION: Insert a new name into the global list of Externals which
* will in turn be later emitted as an External() declaration
* in the disassembled output.
*
******************************************************************************/
void
AcpiDmAddToExternalList (
ACPI_PARSE_OBJECT *Op,
char *Path,
UINT8 Type,
UINT32 Value)
{
char *ExternalPath;
char *Fullpath = NULL;
ACPI_EXTERNAL_LIST *NewExternal;
ACPI_EXTERNAL_LIST *NextExternal;
ACPI_EXTERNAL_LIST *PrevExternal = NULL;
ACPI_STATUS Status;
if (!Path)
{
return;
}
/* Externalize the ACPI path */
Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, Path,
NULL, &ExternalPath);
if (ACPI_FAILURE (Status))
{
return;
}
/* Get the full pathname from root if "Path" has a parent prefix */
if (*Path == (UINT8) AML_PARENT_PREFIX)
{
Fullpath = AcpiDmNormalizeParentPrefix (Op, ExternalPath);
if (Fullpath)
{
/* Set new external path */
ACPI_FREE (ExternalPath);
ExternalPath = Fullpath;
}
}
/* Check all existing externals to ensure no duplicates */
NextExternal = AcpiGbl_ExternalList;
while (NextExternal)
{
if (!ACPI_STRCMP (ExternalPath, NextExternal->Path))
{
/* Duplicate method, check that the Value (ArgCount) is the same */
if ((NextExternal->Type == ACPI_TYPE_METHOD) &&
(NextExternal->Value != Value))
{
ACPI_ERROR ((AE_INFO,
"Argument count mismatch for method %s %d %d",
NextExternal->Path, NextExternal->Value, Value));
}
/* Allow upgrade of type from ANY */
else if (NextExternal->Type == ACPI_TYPE_ANY)
{
NextExternal->Type = Type;
NextExternal->Value = Value;
}
ACPI_FREE (ExternalPath);
return;
}
NextExternal = NextExternal->Next;
}
/* Allocate and init a new External() descriptor */
NewExternal = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EXTERNAL_LIST));
if (!NewExternal)
{
ACPI_FREE (ExternalPath);
return;
}
NewExternal->Path = ExternalPath;
NewExternal->Type = Type;
NewExternal->Value = Value;
NewExternal->Length = (UINT16) ACPI_STRLEN (ExternalPath);
/* Was the external path with parent prefix normalized to a fullpath? */
if (Fullpath == ExternalPath)
{
/* Get new internal path */
Status = AcpiNsInternalizeName (ExternalPath, &Path);
if (ACPI_FAILURE (Status))
{
ACPI_FREE (ExternalPath);
ACPI_FREE (NewExternal);
return;
}
/* Set flag to indicate External->InternalPath need to be freed */
NewExternal->Flags |= ACPI_IPATH_ALLOCATED;
}
NewExternal->InternalPath = Path;
/* Link the new descriptor into the global list, ordered by string length */
NextExternal = AcpiGbl_ExternalList;
while (NextExternal)
{
if (NewExternal->Length <= NextExternal->Length)
{
if (PrevExternal)
{
PrevExternal->Next = NewExternal;
}
else
{
AcpiGbl_ExternalList = NewExternal;
}
NewExternal->Next = NextExternal;
return;
}
PrevExternal = NextExternal;
NextExternal = NextExternal->Next;
}
if (PrevExternal)
{
PrevExternal->Next = NewExternal;
}
else
{
AcpiGbl_ExternalList = NewExternal;
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmAddExternalsToNamespace
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Add all externals to the namespace. Allows externals to be
* "resolved".
*
******************************************************************************/
void
AcpiDmAddExternalsToNamespace (
void)
{
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *Node;
ACPI_OPERAND_OBJECT *MethodDesc;
ACPI_EXTERNAL_LIST *External = AcpiGbl_ExternalList;
while (External)
{
/* Add the external name (object) into the namespace */
Status = AcpiNsLookup (NULL, External->InternalPath, External->Type,
ACPI_IMODE_LOAD_PASS1,
ACPI_NS_EXTERNAL | ACPI_NS_DONT_OPEN_SCOPE,
NULL, &Node);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"while adding external to namespace [%s]",
External->Path));
}
else if (External->Type == ACPI_TYPE_METHOD)
{
/* For methods, we need to save the argument count */
MethodDesc = AcpiUtCreateInternalObject (ACPI_TYPE_METHOD);
MethodDesc->Method.ParamCount = (UINT8) External->Value;
Node->Object = MethodDesc;
}
External = External->Next;
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmGetExternalMethodCount
*
* PARAMETERS: None
*
* RETURN: The number of control method externals in the external list
*
* DESCRIPTION: Return the number of method externals that have been generated.
* If any control method externals have been found, we must
* re-parse the entire definition block with the new information
* (number of arguments for the methods.) This is limitation of
* AML, we don't know the number of arguments from the control
* method invocation itself.
*
******************************************************************************/
UINT32
AcpiDmGetExternalMethodCount (
void)
{
ACPI_EXTERNAL_LIST *External = AcpiGbl_ExternalList;
UINT32 Count = 0;
while (External)
{
if (External->Type == ACPI_TYPE_METHOD)
{
Count++;
}
External = External->Next;
}
return (Count);
}
/*******************************************************************************
*
* FUNCTION: AcpiDmClearExternalList
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Free the entire External info list
*
******************************************************************************/
void
AcpiDmClearExternalList (
void)
{
ACPI_EXTERNAL_LIST *NextExternal;
while (AcpiGbl_ExternalList)
{
NextExternal = AcpiGbl_ExternalList->Next;
ACPI_FREE (AcpiGbl_ExternalList->Path);
ACPI_FREE (AcpiGbl_ExternalList);
AcpiGbl_ExternalList = NextExternal;
}
}
/*******************************************************************************
*
* FUNCTION: AcpiDmEmitExternals
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Emit an External() ASL statement for each of the externals in
* the global external info list.
*
******************************************************************************/
void
AcpiDmEmitExternals (
void)
{
ACPI_EXTERNAL_LIST *NextExternal;
if (!AcpiGbl_ExternalList)
{
return;
}
/*
* Walk the list of externals (unresolved references)
* found during the AML parsing
*/
while (AcpiGbl_ExternalList)
{
AcpiOsPrintf (" External (%s%s",
AcpiGbl_ExternalList->Path,
AcpiDmGetObjectTypeName (AcpiGbl_ExternalList->Type));
if (AcpiGbl_ExternalList->Type == ACPI_TYPE_METHOD)
{
AcpiOsPrintf (") // %d Arguments\n",
AcpiGbl_ExternalList->Value);
}
else
{
AcpiOsPrintf (")\n");
}
/* Free this external info block and move on to next external */
NextExternal = AcpiGbl_ExternalList->Next;
if (AcpiGbl_ExternalList->Flags & ACPI_IPATH_ALLOCATED)
{
ACPI_FREE (AcpiGbl_ExternalList->InternalPath);
}
ACPI_FREE (AcpiGbl_ExternalList->Path);
ACPI_FREE (AcpiGbl_ExternalList);
AcpiGbl_ExternalList = NextExternal;
}
AcpiOsPrintf ("\n");
}

3
sys/contrib/dev/acpica/common/dmtable.c
View File

@ -218,7 +218,6 @@ static const char *AcpiDmIvrsSubnames[] =
};
#define ACPI_FADT_PM_RESERVED 8
static const char *AcpiDmFadtProfiles[] =
@ -954,7 +953,7 @@ AcpiDmCheckAscii (
for (i = 0; i < Count; i++)
{
RepairedName[i] = Name[i];
RepairedName[i] = (char) Name[i];
if (!Name[i])
{

8
sys/contrib/dev/acpica/common/getopt.c
View File

@ -195,9 +195,9 @@ AcpiGetopt(
if (*++OptsPtr == ':')
{
if (argv[AcpiGbl_Optind][CurrentCharPtr+1] != '\0')
if (argv[AcpiGbl_Optind][(int) (CurrentCharPtr+1)] != '\0')
{
AcpiGbl_Optarg = &argv[AcpiGbl_Optind++][CurrentCharPtr+1];
AcpiGbl_Optarg = &argv[AcpiGbl_Optind++][(int) (CurrentCharPtr+1)];
}
else if (++AcpiGbl_Optind >= argc)
{
@ -218,9 +218,9 @@ AcpiGetopt(
else if (*OptsPtr == '^')
{
if (argv[AcpiGbl_Optind][CurrentCharPtr+1] != '\0')
if (argv[AcpiGbl_Optind][(int) (CurrentCharPtr+1)] != '\0')
{
AcpiGbl_Optarg = &argv[AcpiGbl_Optind][CurrentCharPtr+1];
AcpiGbl_Optarg = &argv[AcpiGbl_Optind][(int) (CurrentCharPtr+1)];
}
else
{

9
sys/contrib/dev/acpica/compiler/aslload.c
View File

@ -575,7 +575,9 @@ LdNamespace1Begin (
goto FinishNode;
}
AslCoreSubsystemError (Op, Status, "Failure from lookup\n", FALSE);
AslCoreSubsystemError (Op, Status,
"Failure from namespace lookup", FALSE);
goto Exit;
}
@ -718,7 +720,7 @@ LdNamespace1Begin (
else
{
AslCoreSubsystemError (Op, Status,
"Failure from lookup %s\n", FALSE);
"Failure from namespace lookup", FALSE);
goto Exit;
}
}
@ -885,7 +887,8 @@ LdNamespace2Begin (
return (AE_OK);
}
AslCoreSubsystemError (Op, Status, "Failure from lookup\n", FALSE);
AslCoreSubsystemError (Op, Status,
"Failure from namespace lookup", FALSE);
return (AE_OK);
}

44
sys/contrib/dev/acpica/debugger/dbcmds.c
View File

@ -130,6 +130,7 @@
#define _COMPONENT ACPI_CA_DEBUGGER
ACPI_MODULE_NAME ("dbcmds")
/* Local prototypes */
static ACPI_STATUS
@ -501,7 +502,7 @@ AcpiDbWalkForExecute (
void **ReturnValue)
{
ACPI_NAMESPACE_NODE *Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
UINT32 *Count = (UINT32 *) Context;
ACPI_EXECUTE_WALK *Info = (ACPI_EXECUTE_WALK *) Context;
ACPI_BUFFER ReturnObj;
ACPI_STATUS Status;
char *Pathname;
@ -542,7 +543,6 @@ AcpiDbWalkForExecute (
if (ObjInfo->Type == ACPI_TYPE_METHOD)
{
/* Setup default parameters */
for (i = 0; i < ObjInfo->ParamCount; i++)
@ -556,11 +556,9 @@ AcpiDbWalkForExecute (
}
ACPI_FREE (ObjInfo);
ReturnObj.Pointer = NULL;
ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
/* Do the actual method execution */
AcpiGbl_MethodExecuting = TRUE;
@ -569,11 +567,21 @@ AcpiDbWalkForExecute (
AcpiOsPrintf ("%-32s returned %s\n", Pathname, AcpiFormatException (Status));
AcpiGbl_MethodExecuting = FALSE;
ACPI_FREE (Pathname);
(*Count)++;
return (AE_OK);
/* Ignore status from method execution */
Status = AE_OK;
/* Update count, check if we have executed enough methods */
Info->Count++;
if (Info->Count >= Info->MaxCount)
{
Status = AE_CTRL_TERMINATE;
}
return (Status);
}
@ -581,27 +589,37 @@ AcpiDbWalkForExecute (
*
* FUNCTION: AcpiDbBatchExecute
*
* PARAMETERS: None
* PARAMETERS: CountArg - Max number of methods to execute
*
* RETURN: None
*
* DESCRIPTION: Namespace batch execution.
* DESCRIPTION: Namespace batch execution. Execute predefined names in the
* namespace, up to the max count, if specified.
*
******************************************************************************/
void
AcpiDbBatchExecute (
void)
char *CountArg)
{
UINT32 Count = 0;
ACPI_EXECUTE_WALK Info;
Info.Count = 0;
Info.MaxCount = ACPI_UINT32_MAX;
if (CountArg)
{
Info.MaxCount = ACPI_STRTOUL (CountArg, NULL, 0);
}
/* Search all nodes in namespace */
(void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, ACPI_UINT32_MAX,
AcpiDbWalkForExecute, (void *) &Count, NULL);
AcpiDbWalkForExecute, (void *) &Info, NULL);
AcpiOsPrintf ("Executed %d predefined names in the namespace\n", Count);
AcpiOsPrintf ("Executed %d predefined names in the namespace\n", Info.Count);
}

2
sys/contrib/dev/acpica/debugger/dbinput.c
View File

@ -644,7 +644,7 @@ AcpiDbCommandDispatch (
break;
case CMD_BATCH:
AcpiDbBatchExecute ();
AcpiDbBatchExecute (AcpiGbl_DbArgs[1]);
break;
case CMD_BREAKPOINT:

118
sys/contrib/dev/acpica/disassembler/dmutils.c
View File

@ -129,9 +129,6 @@
ACPI_MODULE_NAME ("dmutils")
ACPI_EXTERNAL_LIST *AcpiGbl_ExternalList = NULL;
/* Data used in keeping track of fields */
#if 0
const char *AcpiGbl_FENames[] =
@ -202,121 +199,6 @@ const char *AcpiGbl_IrqDecode[] =
};
#ifdef ACPI_ASL_COMPILER
/*******************************************************************************
*
* FUNCTION: AcpiDmAddToExternalList
*
* PARAMETERS: Path - Internal (AML) path to the object
*
* RETURN: None
*
* DESCRIPTION: Insert a new path into the list of Externals which will in
* turn be emitted as an External() declaration in the disassembled
* output.
*
******************************************************************************/
void
AcpiDmAddToExternalList (
char *Path,
UINT8 Type,
UINT32 Value)
{
char *ExternalPath;
ACPI_EXTERNAL_LIST *NewExternal;
ACPI_EXTERNAL_LIST *NextExternal;
ACPI_EXTERNAL_LIST *PrevExternal = NULL;
ACPI_STATUS Status;
if (!Path)
{
return;
}
/* Externalize the ACPI path */
Status = AcpiNsExternalizeName (ACPI_UINT32_MAX, Path,
NULL, &ExternalPath);
if (ACPI_FAILURE (Status))
{
return;
}
/* Ensure that we don't have duplicate externals */
NextExternal = AcpiGbl_ExternalList;
while (NextExternal)
{
/* Allow upgrade of type from ANY */
if (!ACPI_STRCMP (ExternalPath, NextExternal->Path))
{
/* Duplicate method, check that the Value (ArgCount) is the same */
if ((NextExternal->Type == ACPI_TYPE_METHOD) &&
(NextExternal->Value != Value))
{
ACPI_ERROR ((AE_INFO, "Argument count mismatch for method %s %d %d",
NextExternal->Path, NextExternal->Value, Value));
}
if (NextExternal->Type == ACPI_TYPE_ANY)
{
NextExternal->Type = Type;
NextExternal->Value = Value;
}
ACPI_FREE (ExternalPath);
return;
}
NextExternal = NextExternal->Next;
}
/* Allocate and init a new External() descriptor */
NewExternal = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EXTERNAL_LIST));
NewExternal->InternalPath = Path;
NewExternal->Path = ExternalPath;
NewExternal->Type = Type;
NewExternal->Value = Value;
NewExternal->Length = (UINT16) ACPI_STRLEN (ExternalPath);
/* Link the new descriptor into the global list, ordered by string length */
NextExternal = AcpiGbl_ExternalList;
while (NextExternal)
{
if (NewExternal->Length <= NextExternal->Length)
{
if (PrevExternal)
{
PrevExternal->Next = NewExternal;
}
else
{
AcpiGbl_ExternalList = NewExternal;
}
NewExternal->Next = NextExternal;
return;
}
PrevExternal = NextExternal;
NextExternal = NextExternal->Next;
}
if (PrevExternal)
{
PrevExternal->Next = NewExternal;
}
else
{
AcpiGbl_ExternalList = NewExternal;
}
}
#endif
/*******************************************************************************
*
* FUNCTION: AcpiDmDecodeAttribute

104
sys/contrib/dev/acpica/disassembler/dmwalk.c
View File

@ -130,6 +130,17 @@
#define DB_FULL_OP_INFO "[%4.4s] @%5.5X #%4.4X: "
/* Stub for non-compiler code */
#ifndef ACPI_ASL_COMPILER
void
AcpiDmEmitExternals (
void)
{
return;
}
#endif
/* Local prototypes */
static ACPI_STATUS
@ -148,68 +159,6 @@ static UINT32
AcpiDmBlockType (
ACPI_PARSE_OBJECT *Op);
static const char *
AcpiDmGetObjectTypeName (
ACPI_OBJECT_TYPE Type);
/*
* This table maps ACPI_OBJECT_TYPEs to the corresponding ASL
* ObjectTypeKeyword. Used to generate typed external declarations
*/
static const char *AcpiGbl_DmTypeNames[] =
{
/* 00 */ "", /* Type ANY */
/* 01 */ ", IntObj",
/* 02 */ ", StrObj",
/* 03 */ ", BuffObj",
/* 04 */ ", PkgObj",
/* 05 */ ", FieldUnitObj",
/* 06 */ ", DeviceObj",
/* 07 */ ", EventObj",
/* 08 */ ", MethodObj",
/* 09 */ ", MutexObj",
/* 10 */ ", OpRegionObj",
/* 11 */ ", PowerResObj",
/* 12 */ ", ProcessorObj",
/* 13 */ ", ThermalZoneObj",
/* 14 */ ", BuffFieldObj",
/* 15 */ ", DDBHandleObj",
/* 16 */ "", /* Debug object */
/* 17 */ ", FieldUnitObj",
/* 18 */ ", FieldUnitObj",
/* 19 */ ", FieldUnitObj"
};
/*******************************************************************************
*
* FUNCTION: AcpiDmGetObjectTypeName
*
* PARAMETERS: Type - An ACPI_OBJECT_TYPE
*
* RETURN: Pointer to a string
*
* DESCRIPTION: Map an object type to the ASL object type string.
*
******************************************************************************/
static const char *
AcpiDmGetObjectTypeName (
ACPI_OBJECT_TYPE Type)
{
if (Type == ACPI_TYPE_LOCAL_SCOPE)
{
Type = ACPI_TYPE_DEVICE;
}
else if (Type > ACPI_TYPE_LOCAL_INDEX_FIELD)
{
return ("");
}
return (AcpiGbl_DmTypeNames[Type]);
}
/*******************************************************************************
@ -522,7 +471,6 @@ AcpiDmDescendingOp (
const ACPI_OPCODE_INFO *OpInfo;
UINT32 Name;
ACPI_PARSE_OBJECT *NextOp;
ACPI_EXTERNAL_LIST *NextExternal;
if (Op->Common.DisasmFlags & ACPI_PARSEOP_IGNORE)
@ -554,35 +502,7 @@ AcpiDmDescendingOp (
/* Emit all External() declarations here */
if (AcpiGbl_ExternalList)
{
/*
* Walk the list of externals (unresolved references)
* found during parsing
*/
while (AcpiGbl_ExternalList)
{
AcpiOsPrintf (" External (%s%s",
AcpiGbl_ExternalList->Path,
AcpiDmGetObjectTypeName (AcpiGbl_ExternalList->Type));
if (AcpiGbl_ExternalList->Type == ACPI_TYPE_METHOD)
{
AcpiOsPrintf (") // %d Arguments\n", AcpiGbl_ExternalList->Value);
}
else
{
AcpiOsPrintf (")\n");
}
NextExternal = AcpiGbl_ExternalList->Next;
ACPI_FREE (AcpiGbl_ExternalList->Path);
ACPI_FREE (AcpiGbl_ExternalList);
AcpiGbl_ExternalList = NextExternal;
}
AcpiOsPrintf ("\n");
}
AcpiDmEmitExternals ();
return (AE_OK);
}
}

54
sys/contrib/dev/acpica/dispatcher/dswload.c
View File

@ -263,7 +263,7 @@ AcpiDsLoad1BeginOp (
* Target of Scope() not found. Generate an External for it, and
* insert the name into the namespace.
*/
AcpiDmAddToExternalList (Path, ACPI_TYPE_DEVICE, 0);
AcpiDmAddToExternalList (Op, Path, ACPI_TYPE_DEVICE, 0);
Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT,
WalkState, &Node);
@ -732,29 +732,45 @@ AcpiDsLoad2BeginOp (
break;
case AML_SCOPE_OP:
/*
* The Path is an object reference to an existing object.
* Don't enter the name into the namespace, but look it up
* for use later.
*/
Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
/* Special case for Scope(\) -> refers to the Root node */
if (Op && (Op->Named.Node == AcpiGbl_RootNode))
{
Node = Op->Named.Node;
Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
else
{
/*
* The Path is an object reference to an existing object.
* Don't enter the name into the namespace, but look it up
* for use later.
*/
Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
WalkState, &(Node));
if (ACPI_FAILURE (Status))
{
if (ACPI_FAILURE (Status))
{
#ifdef ACPI_ASL_COMPILER
if (Status == AE_NOT_FOUND)
{
Status = AE_OK;
}
else
{
ACPI_ERROR_NAMESPACE (BufferPtr, Status);
}
if (Status == AE_NOT_FOUND)
{
Status = AE_OK;
}
else
{
ACPI_ERROR_NAMESPACE (BufferPtr, Status);
}
#else
ACPI_ERROR_NAMESPACE (BufferPtr, Status);
ACPI_ERROR_NAMESPACE (BufferPtr, Status);
#endif
return_ACPI_STATUS (Status);
return_ACPI_STATUS (Status);
}
}
/*

69
sys/contrib/dev/acpica/events/evregion.c
View File

@ -128,6 +128,11 @@
/* Local prototypes */
static BOOLEAN
AcpiEvHasDefaultHandler (
ACPI_NAMESPACE_NODE *Node,
ACPI_ADR_SPACE_TYPE SpaceId);
static ACPI_STATUS
AcpiEvRegRun (
ACPI_HANDLE ObjHandle,
@ -231,6 +236,57 @@ AcpiEvInstallRegionHandlers (
}
/*******************************************************************************
*
* FUNCTION: AcpiEvHasDefaultHandler
*
* PARAMETERS: Node - Namespace node for the device
* SpaceId - The address space ID
*
* RETURN: TRUE if default handler is installed, FALSE otherwise
*
* DESCRIPTION: Check if the default handler is installed for the requested
* space ID.
*
******************************************************************************/
static BOOLEAN
AcpiEvHasDefaultHandler (
ACPI_NAMESPACE_NODE *Node,
ACPI_ADR_SPACE_TYPE SpaceId)
{
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj;
/* Must have an existing internal object */
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
HandlerObj = ObjDesc->Device.Handler;
/* Walk the linked list of handlers for this object */
while (HandlerObj)
{
if (HandlerObj->AddressSpace.SpaceId == SpaceId)
{
if (HandlerObj->AddressSpace.HandlerFlags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)
{
return (TRUE);
}
}
HandlerObj = HandlerObj->AddressSpace.Next;
}
}
return (FALSE);
}
/*******************************************************************************
*
* FUNCTION: AcpiEvInitializeOpRegions
@ -266,11 +322,16 @@ AcpiEvInitializeOpRegions (
for (i = 0; i < ACPI_NUM_DEFAULT_SPACES; i++)
{
/*
* TBD: Make sure handler is the DEFAULT handler, otherwise
* _REG will have already been run.
* Make sure the installed handler is the DEFAULT handler. If not the
* default, the _REG methods will have already been run (when the
* handler was installed)
*/
Status = AcpiEvExecuteRegMethods (AcpiGbl_RootNode,
AcpiGbl_DefaultAddressSpaces[i]);
if (AcpiEvHasDefaultHandler (AcpiGbl_RootNode,
AcpiGbl_DefaultAddressSpaces[i]))
{
Status = AcpiEvExecuteRegMethods (AcpiGbl_RootNode,
AcpiGbl_DefaultAddressSpaces[i]);
}
}
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);

26
sys/contrib/dev/acpica/include/acapps.h
View File

@ -124,21 +124,20 @@
#define FILE_SUFFIX_DISASSEMBLY "dsl"
#define ACPI_TABLE_FILE_SUFFIX ".dat"
extern UINT8 *DsdtPtr;
extern UINT32 AcpiDsdtLength;
extern UINT8 *AmlStart;
extern UINT32 AmlLength;
extern int AcpiGbl_Optind;
extern char *AcpiGbl_Optarg;
/*
* getopt
*/
int
AcpiGetopt(
int argc,
char **argv,
char *opts);
extern int AcpiGbl_Optind;
extern char *AcpiGbl_Optarg;
/*
* adisasm
*/
@ -151,7 +150,8 @@ AdAmlDisassemble (
BOOLEAN GetAllTables);
void
AdPrintStatistics (void);
AdPrintStatistics (
void);
ACPI_STATUS
AdFindDsdt(
@ -159,7 +159,8 @@ AdFindDsdt(
UINT32 *DsdtLength);
void
AdDumpTables (void);
AdDumpTables (
void);
ACPI_STATUS
AdGetLocalTables (
@ -179,7 +180,9 @@ AdDisplayTables (
ACPI_TABLE_HEADER *Table);
ACPI_STATUS
AdDisplayStatistics (void);
AdDisplayStatistics (
void);
/*
* adwalk
@ -209,6 +212,7 @@ AcpiDmConvertResourceIndexes (
ACPI_PARSE_OBJECT *ParseTreeRoot,
ACPI_NAMESPACE_NODE *NamespaceRoot);
/*
* adfile
*/

10
sys/contrib/dev/acpica/include/acdebug.h
View File

@ -126,13 +126,19 @@ typedef struct CommandInfo
} COMMAND_INFO;
typedef struct ArgumentInfo
{
char *Name; /* Argument Name */
} ARGUMENT_INFO;
typedef struct acpi_execute_walk
{
UINT32 Count;
UINT32 MaxCount;
} ACPI_EXECUTE_WALK;
#define PARAM_LIST(pl) pl
#define DBTEST_OUTPUT_LEVEL(lvl) if (AcpiGbl_DbOpt_verbose)
@ -265,7 +271,7 @@ AcpiDbCheckPredefinedNames (
void
AcpiDbBatchExecute (
void);
char *CountArg);
/*
* dbdisply - debug display commands

74
sys/contrib/dev/acpica/include/acdisasm.h
View File

@ -125,18 +125,6 @@
#define BLOCK_COMMA_LIST 4
#define ACPI_DEFAULT_RESNAME *(UINT32 *) "__RD"
typedef struct acpi_external_list
{
char *Path;
char *InternalPath;
struct acpi_external_list *Next;
UINT32 Value;
UINT16 Length;
UINT8 Type;
} ACPI_EXTERNAL_LIST;
extern ACPI_EXTERNAL_LIST *AcpiGbl_ExternalList;
typedef const struct acpi_dmtable_info
{
@ -475,14 +463,6 @@ void
AcpiDmMatchOp (
ACPI_PARSE_OBJECT *Op);
BOOLEAN
AcpiDmCommaIfListMember (
ACPI_PARSE_OBJECT *Op);
void
AcpiDmCommaIfFieldMember (
ACPI_PARSE_OBJECT *Op);
/*
* dmnames
@ -555,6 +535,33 @@ AcpiDmIsStringBuffer (
ACPI_PARSE_OBJECT *Op);
/*
* dmextern
*/
void
AcpiDmAddToExternalList (
ACPI_PARSE_OBJECT *Op,
char *Path,
UINT8 Type,
UINT32 Value);
void
AcpiDmAddExternalsToNamespace (
void);
UINT32
AcpiDmGetExternalMethodCount (
void);
void
AcpiDmClearExternalList (
void);
void
AcpiDmEmitExternals (
void);
/*
* dmresrc
*/
@ -589,18 +596,10 @@ ACPI_STATUS
AcpiDmIsResourceTemplate (
ACPI_PARSE_OBJECT *Op);
void
AcpiDmIndent (
UINT32 Level);
void
AcpiDmBitList (
UINT16 Mask);
void
AcpiDmDecodeAttribute (
UINT8 Attribute);
void
AcpiDmDescriptorName (
void);
@ -727,10 +726,21 @@ AcpiDmVendorSmallDescriptor (
* dmutils
*/
void
AcpiDmAddToExternalList (
char *Path,
UINT8 Type,
UINT32 Value);
AcpiDmDecodeAttribute (
UINT8 Attribute);
void
AcpiDmIndent (
UINT32 Level);
BOOLEAN
AcpiDmCommaIfListMember (
ACPI_PARSE_OBJECT *Op);
void
AcpiDmCommaIfFieldMember (
ACPI_PARSE_OBJECT *Op);
/*
* dmrestag

1
sys/contrib/dev/acpica/include/acglobal.h
View File

@ -446,6 +446,7 @@ ACPI_EXTERN UINT8 AcpiGbl_DbOutputFlags;
ACPI_EXTERN BOOLEAN AcpiGbl_DbOpt_disasm;
ACPI_EXTERN BOOLEAN AcpiGbl_DbOpt_verbose;
ACPI_EXTERN ACPI_EXTERNAL_LIST *AcpiGbl_ExternalList;
#endif

23
sys/contrib/dev/acpica/include/aclocal.h
View File

@ -1216,6 +1216,29 @@ typedef struct acpi_port_info
#define ACPI_ASCII_ZERO 0x30
/*****************************************************************************
*
* Disassembler
*
****************************************************************************/
typedef struct acpi_external_list
{
char *Path;
char *InternalPath;
struct acpi_external_list *Next;
UINT32 Value;
UINT16 Length;
UINT8 Type;
UINT8 Flags;
} ACPI_EXTERNAL_LIST;
/* Values for Flags field above */
#define ACPI_IPATH_ALLOCATED 0x01
/*****************************************************************************
*
* Debugger

2
sys/contrib/dev/acpica/include/acpixf.h
View File

@ -120,7 +120,7 @@
/* Current ACPICA subsystem version in YYYYMMDD format */
#define ACPI_CA_VERSION 0x20090903
#define ACPI_CA_VERSION 0x20091013
#include <contrib/dev/acpica/include/actypes.h>
#include <contrib/dev/acpica/include/actbl.h>

113
sys/contrib/dev/acpica/namespace/nsrepair.c
View File

@ -118,6 +118,7 @@
#include <contrib/dev/acpica/include/acpi.h>
#include <contrib/dev/acpica/include/accommon.h>
#include <contrib/dev/acpica/include/acnamesp.h>
#include <contrib/dev/acpica/include/acinterp.h>
#include <contrib/dev/acpica/include/acpredef.h>
#define _COMPONENT ACPI_NAMESPACE
@ -153,8 +154,14 @@ AcpiNsRepairObject (
ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr;
ACPI_OPERAND_OBJECT *NewObject;
ACPI_SIZE Length;
ACPI_STATUS Status;
/*
* At this point, we know that the type of the returned object was not
* one of the expected types for this predefined name. Attempt to
* repair the object. Only a limited number of repairs are possible.
*/
switch (ReturnObject->Common.Type)
{
case ACPI_TYPE_BUFFER:
@ -193,45 +200,101 @@ AcpiNsRepairObject (
*/
ACPI_MEMCPY (NewObject->String.Pointer,
ReturnObject->Buffer.Pointer, Length);
break;
/*
* If the original object is a package element, we need to:
* 1. Set the reference count of the new object to match the
* reference count of the old object.
* 2. Decrement the reference count of the original object.
*/
if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
case ACPI_TYPE_INTEGER:
/* 1) Does the method/object legally return a buffer? */
if (ExpectedBtypes & ACPI_RTYPE_BUFFER)
{
NewObject->Common.ReferenceCount =
ReturnObject->Common.ReferenceCount;
if (ReturnObject->Common.ReferenceCount > 1)
/*
* Convert the Integer to a packed-byte buffer. _MAT needs
* this sometimes, if a read has been performed on a Field
* object that is less than or equal to the global integer
* size (32 or 64 bits).
*/
Status = AcpiExConvertToBuffer (ReturnObject, &NewObject);
if (ACPI_FAILURE (Status))
{
ReturnObject->Common.ReferenceCount--;
return (Status);
}
}
/* 2) Does the method/object legally return a string? */
else if (ExpectedBtypes & ACPI_RTYPE_STRING)
{
/*
* The only supported Integer-to-String conversion is to convert
* an integer of value 0 to a NULL string. The last element of
* _BIF and _BIX packages occasionally need this fix.
*/
if (ReturnObject->Integer.Value != 0)
{
return (AE_AML_OPERAND_TYPE);
}
ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
"Converted Buffer to expected String at index %u",
PackageIndex));
/* Allocate a new NULL string object */
NewObject = AcpiUtCreateStringObject (0);
if (!NewObject)
{
return (AE_NO_MEMORY);
}
}
else
{
ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
"Converted Buffer to expected String"));
return (AE_AML_OPERAND_TYPE);
}
break;
/* Delete old object, install the new return object */
AcpiUtRemoveReference (ReturnObject);
*ReturnObjectPtr = NewObject;
Data->Flags |= ACPI_OBJECT_REPAIRED;
return (AE_OK);
default:
break;
/* We cannot repair this object */
return (AE_AML_OPERAND_TYPE);
}
return (AE_AML_OPERAND_TYPE);
/* Object was successfully repaired */
/*
* If the original object is a package element, we need to:
* 1. Set the reference count of the new object to match the
* reference count of the old object.
* 2. Decrement the reference count of the original object.
*/
if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT)
{
NewObject->Common.ReferenceCount =
ReturnObject->Common.ReferenceCount;
if (ReturnObject->Common.ReferenceCount > 1)
{
ReturnObject->Common.ReferenceCount--;
}
ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
"Converted %s to expected %s at index %u",
AcpiUtGetObjectTypeName (ReturnObject),
AcpiUtGetObjectTypeName (NewObject), PackageIndex));
}
else
{
ACPI_WARN_PREDEFINED ((AE_INFO, Data->Pathname, Data->NodeFlags,
"Converted %s to expected %s",
AcpiUtGetObjectTypeName (ReturnObject),
AcpiUtGetObjectTypeName (NewObject)));
}
/* Delete old object, install the new return object */
AcpiUtRemoveReference (ReturnObject);
*ReturnObjectPtr = NewObject;
Data->Flags |= ACPI_OBJECT_REPAIRED;
return (AE_OK);
}

4
sys/contrib/dev/acpica/utilities/utglobal.c
View File

@ -949,6 +949,10 @@ AcpiUtInitGlobals (
AcpiGbl_RootNodeStruct.Flags = ANOBJ_END_OF_PEER_LIST;
#ifdef ACPI_DISASSEMBLER
AcpiGbl_ExternalList = NULL;
#endif
#ifdef ACPI_DEBUG_OUTPUT
AcpiGbl_LowestStackPointer = ACPI_CAST_PTR (ACPI_SIZE, ACPI_SIZE_MAX);
#endif

3
usr.sbin/acpi/iasl/Makefile
View File

@ -5,7 +5,8 @@ SRCS= adfile.c adisasm.c adwalk.c
SRCS+= osunixxf.c
# common
SRCS+= dmrestag.c dmtable.c dmtbdump.c dmtbinfo.c getopt.c
SRCS+= dmextern.c dmrestag.c dmtable.c dmtbdump.c dmtbinfo.c \
getopt.c
# compiler
SRCS+= aslanalyze.c aslcodegen.c aslcompile.c aslcompiler.y.h \