Import ACPICA 20170831.
This commit is contained in:
Jung-uk Kim
parent
834d4c5613
commit
0810e26699
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/vendor-sys/acpica/dist/; revision=323060 svn path=/vendor-sys/acpica/20170831/; revision=323061; tag=vendor/acpica/20170831
49
changes.txt
49
changes.txt
@ -1,3 +1,52 @@
|
||||
----------------------------------------
|
||||
31 August 2017. Summary of changes for version 20170831:
|
||||
|
||||
|
||||
1) ACPICA kernel-resident subsystem:
|
||||
|
||||
Implemented internal support for full 64-bit addresses that appear in all
|
||||
Generic Address Structure (GAS) structures. Previously, only the lower 32
|
||||
bits were used. Affects the use of GAS structures in the FADT and other
|
||||
tables, as well as the GAS structures passed to the AcpiRead and
|
||||
AcpiWrite public external interfaces that are used by drivers. Lv Zheng.
|
||||
|
||||
Added header support for the PDTT ACPI table (Processor Debug Trigger
|
||||
Table). Full support in the iASL Data Table Compiler and disassembler is
|
||||
forthcoming.
|
||||
|
||||
|
||||
2) iASL Compiler/Disassembler and Tools:
|
||||
|
||||
iASL/Disassembler: Fixed a problem with the PPTT ACPI table (Processor
|
||||
Properties Topology Table) where a flag bit was specified in the wrong
|
||||
bit position ("Line Size Valid", bit 6).
|
||||
|
||||
iASL: Implemented support for Octal integer constants as defined by the
|
||||
ASL language grammar, per the ACPI specification. Any integer constant
|
||||
that starts with a zero is an octal constant. For example,
|
||||
Store (037777, Local0) /* Octal constant */
|
||||
Store (0x3FFF, Local0) /* Hex equivalent */
|
||||
Store (16383, Local0) /* Decimal equivalent */
|
||||
|
||||
iASL: Improved overflow detection for 64-bit string conversions during
|
||||
compilation of integer constants. "Overflow" in this case means a string
|
||||
that represents an integer that is too large to fit into a 64-bit value.
|
||||
Any 64-bit constants within a 32-bit DSDT or SSDT are still truncated to
|
||||
the low-order 32 bits with a warning, as previously implemented. Several
|
||||
new exceptions are defined that indicate a 64-bit overflow, as well as
|
||||
the base (radix) that was used during the attempted conversion. Examples:
|
||||
Local0 = 0xAAAABBBBCCCCDDDDEEEEFFFF // AE_HEX_OVERFLOW
|
||||
Local0 = 01111222233334444555566667777 // AE_OCTAL_OVERFLOW
|
||||
Local0 = 11112222333344445555666677778888 // AE_DECIMAL_OVERFLOW
|
||||
|
||||
iASL: Added a warning for the case where a ResourceTemplate is declared
|
||||
with no ResourceDescriptor entries (coded as "ResourceTemplate(){}"). In
|
||||
this case, the resulting template is created with a single END_TAG
|
||||
descriptor, which is essentially useless.
|
||||
|
||||
iASL: Expanded the -vw option (ignore specific warnings/remarks) to
|
||||
include compilation error codes as well.
|
||||
|
||||
----------------------------------------
|
||||
28 July 2017. Summary of changes for version 20170728:
|
||||
|
||||
|
||||
@ -47,6 +47,7 @@ OBJECTS = \
|
||||
$(OBJDIR)/utmath.o\
|
||||
$(OBJDIR)/utnonansi.o\
|
||||
$(OBJDIR)/utstring.o\
|
||||
$(OBJDIR)/utstrsuppt.o\
|
||||
$(OBJDIR)/utstrtoul64.o\
|
||||
$(OBJDIR)/utxferror.o
|
||||
|
||||
|
||||
@ -157,6 +157,7 @@ OBJECTS = \
|
||||
$(OBJDIR)/utresrc.o\
|
||||
$(OBJDIR)/utstate.o\
|
||||
$(OBJDIR)/utstring.o\
|
||||
$(OBJDIR)/utstrsuppt.o\
|
||||
$(OBJDIR)/utstrtoul64.o\
|
||||
$(OBJDIR)/utxface.o\
|
||||
$(OBJDIR)/utxferror.o\
|
||||
|
||||
@ -230,6 +230,7 @@ OBJECTS = \
|
||||
$(OBJDIR)/utresrc.o\
|
||||
$(OBJDIR)/utstate.o\
|
||||
$(OBJDIR)/utstring.o\
|
||||
$(OBJDIR)/utstrsuppt.o\
|
||||
$(OBJDIR)/utstrtoul64.o\
|
||||
$(OBJDIR)/uttrack.o\
|
||||
$(OBJDIR)/utuuid.o\
|
||||
|
||||
@ -231,6 +231,7 @@ OBJECTS = \
|
||||
$(OBJDIR)/utresrc.o\
|
||||
$(OBJDIR)/utstate.o\
|
||||
$(OBJDIR)/utstrtoul64.o\
|
||||
$(OBJDIR)/utstrsuppt.o\
|
||||
$(OBJDIR)/utstring.o\
|
||||
$(OBJDIR)/utuuid.o\
|
||||
$(OBJDIR)/utxface.o\
|
||||
|
||||
@ -2828,7 +2828,7 @@ ACPI_DMTABLE_INFO AcpiDmTableInfoPptt1[] =
|
||||
{ACPI_DMT_FLAG3, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Allocation Type valid", 0},
|
||||
{ACPI_DMT_FLAG4, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Cache Type valid", 0},
|
||||
{ACPI_DMT_FLAG5, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Write Policy valid", 0},
|
||||
{ACPI_DMT_FLAG5, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Line Size valid", 0},
|
||||
{ACPI_DMT_FLAG6, ACPI_PPTT1_FLAG_OFFSET (Flags,0), "Line Size valid", 0},
|
||||
{ACPI_DMT_UINT32, ACPI_PPTT1_OFFSET (NextLevelOfCache), "Next Level of Cache", 0},
|
||||
{ACPI_DMT_UINT32, ACPI_PPTT1_OFFSET (Size), "Size", 0},
|
||||
{ACPI_DMT_UINT32, ACPI_PPTT1_OFFSET (NumberOfSets), "Number of Sets", 0},
|
||||
|
||||
@ -890,6 +890,11 @@ void
|
||||
TrSetOpCurrentFilename (
|
||||
ACPI_PARSE_OBJECT *Op);
|
||||
|
||||
void
|
||||
TrSetOpIntegerWidth (
|
||||
ACPI_PARSE_OBJECT *TableSignature,
|
||||
ACPI_PARSE_OBJECT *Revision);
|
||||
|
||||
ACPI_PARSE_OBJECT *
|
||||
TrLinkOpChildren (
|
||||
ACPI_PARSE_OBJECT *Op,
|
||||
|
||||
@ -195,6 +195,7 @@ count (int type);
|
||||
|
||||
LeadNameChar [A-Za-z_]
|
||||
DigitChar [0-9]
|
||||
OctalChar [0-7]
|
||||
HexDigitChar [A-Fa-f0-9]
|
||||
RootChar [\\]
|
||||
Nothing []
|
||||
@ -278,8 +279,7 @@ NamePathTail [.]{NameSeg}
|
||||
/*
|
||||
* Begin standard ASL grammar
|
||||
*/
|
||||
0[xX]{HexDigitChar}+ |
|
||||
{DigitChar}+ { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext);
|
||||
[0-9][a-zA-Z0-9]* { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext);
|
||||
count (1); return (PARSEOP_INTEGER); }
|
||||
|
||||
"Include" { count (1); return (PARSEOP_INCLUDE); }
|
||||
|
||||
@ -165,6 +165,10 @@ UtDumpParseOpName (
|
||||
UINT32 Level,
|
||||
UINT32 DataLength);
|
||||
|
||||
static char *
|
||||
UtCreateEscapeSequences (
|
||||
char *InString);
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
@ -272,7 +276,6 @@ UtDumpStringOp (
|
||||
|
||||
|
||||
String = Op->Asl.Value.String;
|
||||
|
||||
if (Op->Asl.ParseOpcode != PARSEOP_STRING_LITERAL)
|
||||
{
|
||||
/*
|
||||
@ -294,6 +297,8 @@ UtDumpStringOp (
|
||||
return;
|
||||
}
|
||||
|
||||
String = UtCreateEscapeSequences (String);
|
||||
|
||||
/* Emit the ParseOp name, leaving room for the string */
|
||||
|
||||
UtDumpParseOpName (Op, Level, strlen (String));
|
||||
@ -301,6 +306,86 @@ UtDumpStringOp (
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: UtCreateEscapeSequences
|
||||
*
|
||||
* PARAMETERS: InString - ASCII string to be expanded
|
||||
*
|
||||
* RETURN: Expanded string
|
||||
*
|
||||
* DESCRIPTION: Expand all non-printable ASCII bytes (0-0x1F) to escape
|
||||
* sequences. For example, hex 14 becomes \x14
|
||||
*
|
||||
* NOTE: Since this function is used for debug output only, it does
|
||||
* not attempt to translate into the "known" escape sequences
|
||||
* such as \a, \f, \t, etc.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
static char *
|
||||
UtCreateEscapeSequences (
|
||||
char *InString)
|
||||
{
|
||||
char *String = InString;
|
||||
char *OutString;
|
||||
char *OutStringPtr;
|
||||
UINT32 InStringLength = 0;
|
||||
UINT32 EscapeCount = 0;
|
||||
|
||||
|
||||
/*
|
||||
* Determine up front how many escapes are within the string.
|
||||
* Obtain the input string length while doing so.
|
||||
*/
|
||||
while (*String)
|
||||
{
|
||||
if ((*String <= 0x1F) || (*String >= 0x7F))
|
||||
{
|
||||
EscapeCount++;
|
||||
}
|
||||
|
||||
InStringLength++;
|
||||
String++;
|
||||
}
|
||||
|
||||
if (!EscapeCount)
|
||||
{
|
||||
return (InString); /* No escapes, nothing to do */
|
||||
}
|
||||
|
||||
/* New string buffer, 3 extra chars per escape (4 total) */
|
||||
|
||||
OutString = UtLocalCalloc (InStringLength + (EscapeCount * 3));
|
||||
OutStringPtr = OutString;
|
||||
|
||||
/* Convert non-ascii or non-printable chars to escape sequences */
|
||||
|
||||
while (*InString)
|
||||
{
|
||||
if ((*InString <= 0x1F) || (*InString >= 0x7F))
|
||||
{
|
||||
/* Insert a \x hex escape sequence */
|
||||
|
||||
OutStringPtr[0] = '\\';
|
||||
OutStringPtr[1] = 'x';
|
||||
OutStringPtr[2] = AcpiUtHexToAsciiChar (*InString, 4);
|
||||
OutStringPtr[3] = AcpiUtHexToAsciiChar (*InString, 0);
|
||||
OutStringPtr += 4;
|
||||
}
|
||||
else /* Normal ASCII character */
|
||||
{
|
||||
*OutStringPtr = *InString;
|
||||
OutStringPtr++;
|
||||
}
|
||||
|
||||
InString++;
|
||||
}
|
||||
|
||||
return (OutString);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: UtDumpBasicOp
|
||||
|
||||
@ -757,6 +757,11 @@ AslCommonError (
|
||||
ASL_ERROR_MSG *Enode;
|
||||
|
||||
|
||||
if (AslIsExceptionIgnored (Level, MessageId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Enode = UtLocalCalloc (sizeof (ASL_ERROR_MSG));
|
||||
|
||||
if (ExtraMessage)
|
||||
@ -949,9 +954,9 @@ AslDisableException (
|
||||
|
||||
MessageId = (UINT32) strtoul (MessageIdString, NULL, 0);
|
||||
|
||||
if ((MessageId < 2000) || (MessageId > 5999))
|
||||
if ((MessageId < 2000) || (MessageId > 6999))
|
||||
{
|
||||
printf ("\"%s\" is not a valid warning/remark ID\n",
|
||||
printf ("\"%s\" is not a valid warning/remark/error ID\n",
|
||||
MessageIdString);
|
||||
return (AE_BAD_PARAMETER);
|
||||
}
|
||||
@ -1050,8 +1055,9 @@ AslIsExceptionDisabled (
|
||||
|
||||
case ASL_WARNING:
|
||||
case ASL_REMARK:
|
||||
case ASL_ERROR:
|
||||
/*
|
||||
* Ignore this warning/remark if it has been disabled by
|
||||
* Ignore this error/warning/remark if it has been disabled by
|
||||
* the user (-vw option)
|
||||
*/
|
||||
EncodedMessageId = AeBuildFullExceptionCode (Level, MessageId);
|
||||
@ -1097,14 +1103,6 @@ AslError (
|
||||
ACPI_PARSE_OBJECT *Op,
|
||||
char *ExtraMessage)
|
||||
{
|
||||
|
||||
/* Check if user wants to ignore this exception */
|
||||
|
||||
if (AslIsExceptionIgnored (Level, MessageId))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if (Op)
|
||||
{
|
||||
AslCommonError (Level, MessageId, Op->Asl.LineNumber,
|
||||
|
||||
@ -204,7 +204,7 @@ Usage (
|
||||
ACPI_OPTION ("-ve", "Report only errors (ignore warnings and remarks)");
|
||||
ACPI_OPTION ("-vi", "Less verbose errors and warnings for use with IDEs");
|
||||
ACPI_OPTION ("-vr", "Disable remarks");
|
||||
ACPI_OPTION ("-vw <messageid>", "Disable specific warning or remark");
|
||||
ACPI_OPTION ("-vw <messageid>", "Ignore specific error, warning or remark");
|
||||
ACPI_OPTION ("-vx <messageid>", "Expect a specific warning, remark, or error");
|
||||
ACPI_OPTION ("-w <1|2|3>", "Set warning reporting level");
|
||||
ACPI_OPTION ("-we", "Report warnings as errors");
|
||||
|
||||
@ -386,11 +386,11 @@ AslInitialize (
|
||||
|
||||
AcpiGbl_DmOpt_Verbose = FALSE;
|
||||
|
||||
/* Default integer width is 64 bits */
|
||||
/* Default integer width is 32 bits */
|
||||
|
||||
AcpiGbl_IntegerBitWidth = 64;
|
||||
AcpiGbl_IntegerNybbleWidth = 16;
|
||||
AcpiGbl_IntegerByteWidth = 8;
|
||||
AcpiGbl_IntegerBitWidth = 32;
|
||||
AcpiGbl_IntegerNybbleWidth = 8;
|
||||
AcpiGbl_IntegerByteWidth = 4;
|
||||
|
||||
for (i = 0; i < ASL_NUM_FILES; i++)
|
||||
{
|
||||
|
||||
@ -238,7 +238,7 @@ const char *AslCompilerMsgs [] =
|
||||
/* ASL_MSG_HID_SUFFIX */ "_HID suffix must be all hex digits",
|
||||
/* ASL_MSG_INCLUDE_FILE_OPEN */ "Could not open include file",
|
||||
/* ASL_MSG_INPUT_FILE_OPEN */ "Could not open input file",
|
||||
/* ASL_MSG_INTEGER_LENGTH */ "64-bit integer in 32-bit table, truncating (DSDT or SSDT version < 2)",
|
||||
/* ASL_MSG_INTEGER_LENGTH */ "Truncating 64-bit constant found in 32-bit table",
|
||||
/* ASL_MSG_INTEGER_OPTIMIZATION */ "Integer optimized to single-byte AML opcode",
|
||||
/* ASL_MSG_INTERRUPT_LIST */ "Too many interrupts (16 max)",
|
||||
/* ASL_MSG_INTERRUPT_NUMBER */ "Invalid interrupt number (must be 0-15)",
|
||||
@ -349,7 +349,8 @@ const char *AslCompilerMsgs [] =
|
||||
/* ASL_MSG_ARG_NOT_USED */ "Method Argument is never used",
|
||||
/* ASL_MSG_CONSTANT_REQUIRED */ "Non-reducible expression",
|
||||
/* ASL_MSG_CROSS_TABLE_SCOPE */ "Illegal open scope on external object from within DSDT",
|
||||
/* ASL_MSG_EXCEPTION_NOT_RECEIVED */ "Expected remark, warning, or error did not occur. Message ID:"
|
||||
/* ASL_MSG_EXCEPTION_NOT_RECEIVED */ "Expected remark, warning, or error did not occur. Message ID:",
|
||||
/* ASL_MSG_NULL_RESOURCE_TEMPLATE */ "Empty Resource Template (END_TAG only)"
|
||||
};
|
||||
|
||||
/* Table compiler */
|
||||
|
||||
@ -352,6 +352,7 @@ typedef enum
|
||||
ASL_MSG_CONSTANT_REQUIRED,
|
||||
ASL_MSG_CROSS_TABLE_SCOPE,
|
||||
ASL_MSG_EXCEPTION_NOT_RECEIVED,
|
||||
ASL_MSG_NULL_RESOURCE_TEMPLATE,
|
||||
|
||||
/* These messages are used by the Data Table compiler only */
|
||||
|
||||
|
||||
@ -1148,6 +1148,14 @@ RsDoResourceTemplate (
|
||||
|
||||
DescriptorTypeOp = ASL_GET_PEER_NODE (BufferOp);
|
||||
|
||||
/* DEFAULT_ARG indicates null template - ResourceTemplate(){} */
|
||||
|
||||
if (DescriptorTypeOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
|
||||
{
|
||||
AslError (ASL_WARNING, ASL_MSG_NULL_RESOURCE_TEMPLATE,
|
||||
DescriptorTypeOp, DescriptorTypeOp->Asl.Value.String);
|
||||
}
|
||||
|
||||
/*
|
||||
* Process all resource descriptors in the list
|
||||
* Note: It is assumed that the EndTag node has been automatically
|
||||
|
||||
@ -199,7 +199,8 @@ DefinitionBlockTerm
|
||||
String ','
|
||||
String ','
|
||||
DWordConst
|
||||
PARSEOP_CLOSE_PAREN {TrSetOpEndLineNumber ($<n>3); COMMENT_CAPTURE_ON;}
|
||||
PARSEOP_CLOSE_PAREN {TrSetOpIntegerWidth ($6,$8);
|
||||
TrSetOpEndLineNumber ($<n>3); COMMENT_CAPTURE_ON;}
|
||||
'{' TermList '}' {$$ = TrLinkOpChildren ($<n>3,7,
|
||||
$4,$6,$8,$10,$12,$14,$18);}
|
||||
;
|
||||
|
||||
@ -376,6 +376,39 @@ TrSetOpCurrentFilename (
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: TrSetOpIntegerWidth
|
||||
*
|
||||
* PARAMETERS: Op - An existing parse op
|
||||
*
|
||||
* RETURN: None
|
||||
*
|
||||
* DESCRIPTION:
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
void
|
||||
TrSetOpIntegerWidth (
|
||||
ACPI_PARSE_OBJECT *TableSignatureOp,
|
||||
ACPI_PARSE_OBJECT *RevisionOp)
|
||||
{
|
||||
|
||||
/* TBD: Check table sig? (DSDT vs. SSDT) */
|
||||
|
||||
/* Handle command-line version override */
|
||||
|
||||
if (Gbl_RevisionOverride)
|
||||
{
|
||||
AcpiUtSetIntegerWidth (Gbl_RevisionOverride);
|
||||
}
|
||||
else
|
||||
{
|
||||
AcpiUtSetIntegerWidth ((UINT8) RevisionOp->Asl.Value.Integer);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: TrSetOpEndLineNumber
|
||||
|
||||
@ -1004,11 +1004,11 @@ UtAttachNamepathToOwner (
|
||||
*
|
||||
* FUNCTION: UtDoConstant
|
||||
*
|
||||
* PARAMETERS: String - Hexadecimal or decimal string
|
||||
* PARAMETERS: String - Hex/Decimal/Octal
|
||||
*
|
||||
* RETURN: Converted Integer
|
||||
*
|
||||
* DESCRIPTION: Convert a string to an integer, with error checking.
|
||||
* DESCRIPTION: Convert a string to an integer, with overflow/error checking.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -1017,17 +1017,20 @@ UtDoConstant (
|
||||
char *String)
|
||||
{
|
||||
ACPI_STATUS Status;
|
||||
UINT64 Converted;
|
||||
UINT64 ConvertedInteger;
|
||||
char ErrBuf[64];
|
||||
|
||||
|
||||
Status = AcpiUtStrtoul64 (String, ACPI_STRTOUL_64BIT, &Converted);
|
||||
Status = AcpiUtStrtoul64 (String, &ConvertedInteger);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
sprintf (ErrBuf, "%s %s\n", "Conversion error:",
|
||||
sprintf (ErrBuf, "While creating 64-bit constant: %s\n",
|
||||
AcpiFormatException (Status));
|
||||
AslCompilererror (ErrBuf);
|
||||
|
||||
AslCommonError (ASL_ERROR, ASL_MSG_SYNTAX, Gbl_CurrentLineNumber,
|
||||
Gbl_LogicalLineNumber, Gbl_CurrentLineOffset,
|
||||
Gbl_CurrentColumn, Gbl_Files[ASL_FILE_INPUT].Filename, ErrBuf);
|
||||
}
|
||||
|
||||
return (Converted);
|
||||
return (ConvertedInteger);
|
||||
}
|
||||
|
||||
@ -319,6 +319,8 @@ DtInitialize (
|
||||
return (Status);
|
||||
}
|
||||
|
||||
AcpiUtSetIntegerWidth (2); /* Set width to 64 bits */
|
||||
|
||||
Gbl_FieldList = NULL;
|
||||
Gbl_RootTable = NULL;
|
||||
Gbl_SubtableStack = NULL;
|
||||
|
||||
@ -481,6 +481,10 @@ DtFatal (
|
||||
DT_FIELD *FieldObject,
|
||||
char *ExtraMessage);
|
||||
|
||||
UINT64
|
||||
DtDoConstant (
|
||||
char *String);
|
||||
|
||||
char*
|
||||
DtGetFieldValue (
|
||||
DT_FIELD *Field);
|
||||
|
||||
@ -628,15 +628,9 @@ DtCompileFlag (
|
||||
UINT64 Value = 0;
|
||||
UINT32 BitLength = 1;
|
||||
UINT8 BitPosition = 0;
|
||||
ACPI_STATUS Status;
|
||||
|
||||
|
||||
Status = AcpiUtStrtoul64 (Field->Value,
|
||||
(ACPI_STRTOUL_64BIT | ACPI_STRTOUL_BASE16), &Value);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
DtError (ASL_ERROR, ASL_MSG_INVALID_HEX_INTEGER, Field, NULL);
|
||||
}
|
||||
Value = AcpiUtImplicitStrtoul64 (Field->Value);
|
||||
|
||||
switch (Info->Opcode)
|
||||
{
|
||||
|
||||
@ -275,17 +275,24 @@ Expression
|
||||
|
||||
| EXPOP_LABEL { $$ = DtResolveLabel (DtParsertext);}
|
||||
|
||||
/* Default base for a non-prefixed integer is 16 */
|
||||
/*
|
||||
* All constants for the data table compiler are in hex, whether a (optional) 0x
|
||||
* prefix is present or not. For example, these two input strings are equivalent:
|
||||
* 1234
|
||||
* 0x1234
|
||||
*/
|
||||
|
||||
| EXPOP_NUMBER { AcpiUtStrtoul64 (DtParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);}
|
||||
/* Non-prefixed hex number */
|
||||
|
||||
| EXPOP_NUMBER { $$ = DtDoConstant (DtParsertext);}
|
||||
|
||||
/* Standard hex number (0x1234) */
|
||||
|
||||
| EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (DtParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);}
|
||||
| EXPOP_HEX_NUMBER { $$ = DtDoConstant (DtParsertext);}
|
||||
|
||||
/* TBD: Decimal number with prefix (0d1234) - Not supported by strtoul64 at this time */
|
||||
/* Possible TBD: Decimal number with prefix (0d1234) - Not supported this time */
|
||||
|
||||
| EXPOP_DECIMAL_NUMBER { AcpiUtStrtoul64 (DtParsertext, ACPI_STRTOUL_64BIT, &$$);}
|
||||
| EXPOP_DECIMAL_NUMBER { $$ = DtDoConstant (DtParsertext);}
|
||||
;
|
||||
%%
|
||||
|
||||
|
||||
@ -303,6 +303,38 @@ DtFatal (
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: DtDoConstant
|
||||
*
|
||||
* PARAMETERS: String - Only hex constants are supported,
|
||||
* regardless of whether the 0x prefix
|
||||
* is used
|
||||
*
|
||||
* RETURN: Converted Integer
|
||||
*
|
||||
* DESCRIPTION: Convert a string to an integer, with overflow/error checking.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
UINT64
|
||||
DtDoConstant (
|
||||
char *String)
|
||||
{
|
||||
UINT64 ConvertedInteger;
|
||||
|
||||
|
||||
/*
|
||||
* TBD: The ImplicitStrtoul64 function does not report overflow
|
||||
* conditions. The input string is simply truncated. If it is
|
||||
* desired to report overflow to the table compiler, this should
|
||||
* somehow be added here. Note: integers that are prefixed with 0x
|
||||
* or not are both hex integers.
|
||||
*/
|
||||
ConvertedInteger = AcpiUtImplicitStrtoul64 (String);
|
||||
return (ConvertedInteger);
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* FUNCTION: DtGetFieldValue
|
||||
|
||||
@ -290,11 +290,11 @@ Expression
|
||||
|
||||
/* Default base for a non-prefixed integer is 10 */
|
||||
|
||||
| EXPOP_NUMBER { AcpiUtStrtoul64 (PrParsertext, ACPI_STRTOUL_64BIT, &$$);}
|
||||
| EXPOP_NUMBER { AcpiUtStrtoul64 (PrParsertext, &$$);}
|
||||
|
||||
/* Standard hex number (0x1234) */
|
||||
|
||||
| EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (PrParsertext, (ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &$$);}
|
||||
| EXPOP_HEX_NUMBER { AcpiUtStrtoul64 (PrParsertext, &$$);}
|
||||
;
|
||||
%%
|
||||
|
||||
|
||||
@ -429,9 +429,7 @@ AcpiDbConvertToObject (
|
||||
default:
|
||||
|
||||
Object->Type = ACPI_TYPE_INTEGER;
|
||||
Status = AcpiUtStrtoul64 (String,
|
||||
(AcpiGbl_IntegerByteWidth | ACPI_STRTOUL_BASE16),
|
||||
&Object->Integer.Value);
|
||||
Status = AcpiUtStrtoul64 (String, &Object->Integer.Value);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
@ -539,6 +539,20 @@ AcpiDmIsResourceTemplate (
|
||||
Aml = NextOp->Named.Data;
|
||||
BufferLength = NextOp->Common.Value.Size;
|
||||
|
||||
/*
|
||||
* Any buffer smaller than one byte cannot possibly be a resource
|
||||
* template. Two bytes could possibly be a "NULL" resource template
|
||||
* with a lone end tag descriptor (as generated via
|
||||
* "ResourceTemplate(){}"), but this would be an extremely unusual
|
||||
* case, as the template would be essentially useless. The disassembler
|
||||
* therefore does not recognize any two-byte buffer as a resource
|
||||
* template.
|
||||
*/
|
||||
if (BufferLength <= 2)
|
||||
{
|
||||
return (AE_TYPE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Not a template if declared buffer length != actual length of the
|
||||
* intialization byte list. Because the resource macros will create
|
||||
|
||||
@ -253,7 +253,7 @@ AcpiDsGetPredicateValue (
|
||||
* object. Implicitly convert the argument if necessary.
|
||||
*/
|
||||
Status = AcpiExConvertToInteger (ObjDesc, &LocalObjDesc,
|
||||
ACPI_STRTOUL_BASE16);
|
||||
ACPI_IMPLICIT_CONVERSION);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
goto Cleanup;
|
||||
|
||||
@ -551,8 +551,8 @@ AcpiEvGpeDetect (
|
||||
ACPI_GPE_HANDLER_INFO *GpeHandlerInfo;
|
||||
UINT32 IntStatus = ACPI_INTERRUPT_NOT_HANDLED;
|
||||
UINT8 EnabledStatusByte;
|
||||
UINT32 StatusReg;
|
||||
UINT32 EnableReg;
|
||||
UINT64 StatusReg;
|
||||
UINT64 EnableReg;
|
||||
ACPI_CPU_FLAGS Flags;
|
||||
UINT32 i;
|
||||
UINT32 j;
|
||||
@ -629,7 +629,7 @@ AcpiEvGpeDetect (
|
||||
"RunEnable=%02X, WakeEnable=%02X\n",
|
||||
GpeRegisterInfo->BaseGpeNumber,
|
||||
GpeRegisterInfo->BaseGpeNumber + (ACPI_GPE_REGISTER_WIDTH - 1),
|
||||
StatusReg, EnableReg,
|
||||
(UINT32) StatusReg, (UINT32) EnableReg,
|
||||
GpeRegisterInfo->EnableForRun,
|
||||
GpeRegisterInfo->EnableForWake));
|
||||
|
||||
|
||||
@ -274,7 +274,7 @@ AcpiExDoConcatenate (
|
||||
case ACPI_TYPE_INTEGER:
|
||||
|
||||
Status = AcpiExConvertToInteger (LocalOperand1, &TempOperand1,
|
||||
ACPI_STRTOUL_BASE16);
|
||||
ACPI_IMPLICIT_CONVERSION);
|
||||
break;
|
||||
|
||||
case ACPI_TYPE_BUFFER:
|
||||
|
||||
@ -172,10 +172,10 @@ AcpiExConvertToAscii (
|
||||
*
|
||||
* FUNCTION: AcpiExConvertToInteger
|
||||
*
|
||||
* PARAMETERS: ObjDesc - Object to be converted. Must be an
|
||||
* Integer, Buffer, or String
|
||||
* ResultDesc - Where the new Integer object is returned
|
||||
* Flags - Used for string conversion
|
||||
* PARAMETERS: ObjDesc - Object to be converted. Must be an
|
||||
* Integer, Buffer, or String
|
||||
* ResultDesc - Where the new Integer object is returned
|
||||
* ImplicitConversion - Used for string conversion
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
@ -187,14 +187,13 @@ ACPI_STATUS
|
||||
AcpiExConvertToInteger (
|
||||
ACPI_OPERAND_OBJECT *ObjDesc,
|
||||
ACPI_OPERAND_OBJECT **ResultDesc,
|
||||
UINT32 Flags)
|
||||
UINT32 ImplicitConversion)
|
||||
{
|
||||
ACPI_OPERAND_OBJECT *ReturnDesc;
|
||||
UINT8 *Pointer;
|
||||
UINT64 Result;
|
||||
UINT32 i;
|
||||
UINT32 Count;
|
||||
ACPI_STATUS Status;
|
||||
|
||||
|
||||
ACPI_FUNCTION_TRACE_PTR (ExConvertToInteger, ObjDesc);
|
||||
@ -244,12 +243,17 @@ AcpiExConvertToInteger (
|
||||
* hexadecimal as per the ACPI specification. The only exception (as
|
||||
* of ACPI 3.0) is that the ToInteger() operator allows both decimal
|
||||
* and hexadecimal strings (hex prefixed with "0x").
|
||||
*
|
||||
* Explicit conversion is used only by ToInteger.
|
||||
* All other string-to-integer conversions are implicit conversions.
|
||||
*/
|
||||
Status = AcpiUtStrtoul64 (ACPI_CAST_PTR (char, Pointer),
|
||||
(AcpiGbl_IntegerByteWidth | Flags), &Result);
|
||||
if (ACPI_FAILURE (Status))
|
||||
if (ImplicitConversion)
|
||||
{
|
||||
return_ACPI_STATUS (Status);
|
||||
Result = AcpiUtImplicitStrtoul64 (ACPI_CAST_PTR (char, Pointer));
|
||||
}
|
||||
else
|
||||
{
|
||||
Result = AcpiUtExplicitStrtoul64 (ACPI_CAST_PTR (char, Pointer));
|
||||
}
|
||||
break;
|
||||
|
||||
@ -792,7 +796,7 @@ AcpiExConvertToTargetType (
|
||||
* a Buffer or a String to an Integer if necessary.
|
||||
*/
|
||||
Status = AcpiExConvertToInteger (SourceDesc, ResultDesc,
|
||||
ACPI_STRTOUL_BASE16);
|
||||
ACPI_IMPLICIT_CONVERSION);
|
||||
break;
|
||||
|
||||
case ACPI_TYPE_STRING:
|
||||
|
||||
@ -472,7 +472,7 @@ AcpiExDoLogicalOp (
|
||||
case ACPI_TYPE_INTEGER:
|
||||
|
||||
Status = AcpiExConvertToInteger (Operand1, &LocalOperand1,
|
||||
ACPI_STRTOUL_BASE16);
|
||||
ACPI_IMPLICIT_CONVERSION);
|
||||
break;
|
||||
|
||||
case ACPI_TYPE_STRING:
|
||||
|
||||
@ -541,7 +541,7 @@ AcpiExResolveOperands (
|
||||
* Known as "Implicit Source Operand Conversion"
|
||||
*/
|
||||
Status = AcpiExConvertToInteger (ObjDesc, StackPtr,
|
||||
ACPI_STRTOUL_BASE16);
|
||||
ACPI_IMPLICIT_CONVERSION);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
if (Status == AE_TYPE)
|
||||
|
||||
@ -217,7 +217,7 @@ AcpiHwLowSetGpe (
|
||||
{
|
||||
ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
|
||||
ACPI_STATUS Status = AE_OK;
|
||||
UINT32 EnableMask;
|
||||
UINT64 EnableMask;
|
||||
UINT32 RegisterBit;
|
||||
|
||||
|
||||
@ -342,7 +342,7 @@ AcpiHwGetGpeStatus (
|
||||
ACPI_GPE_EVENT_INFO *GpeEventInfo,
|
||||
ACPI_EVENT_STATUS *EventStatus)
|
||||
{
|
||||
UINT32 InByte;
|
||||
UINT64 InByte;
|
||||
UINT32 RegisterBit;
|
||||
ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
|
||||
ACPI_EVENT_STATUS LocalEventStatus = 0;
|
||||
|
||||
@ -355,9 +355,8 @@ AcpiHwValidateRegister (
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Read from either memory or IO space. This is a 32-bit max
|
||||
* version of AcpiRead, used internally since the overhead of
|
||||
* 64-bit values is not needed.
|
||||
* DESCRIPTION: Read from either memory or IO space. This is a 64-bit max
|
||||
* version of AcpiRead.
|
||||
*
|
||||
* LIMITATIONS: <These limitations also apply to AcpiHwWrite>
|
||||
* SpaceID must be SystemMemory or SystemIO.
|
||||
@ -366,7 +365,7 @@ AcpiHwValidateRegister (
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiHwRead (
|
||||
UINT32 *Value,
|
||||
UINT64 *Value,
|
||||
ACPI_GENERIC_ADDRESS *Reg)
|
||||
{
|
||||
UINT64 Address;
|
||||
@ -384,18 +383,18 @@ AcpiHwRead (
|
||||
|
||||
/* Validate contents of the GAS register */
|
||||
|
||||
Status = AcpiHwValidateRegister (Reg, 32, &Address);
|
||||
Status = AcpiHwValidateRegister (Reg, 64, &Address);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize entire 32-bit return value to zero, convert AccessWidth
|
||||
* Initialize entire 64-bit return value to zero, convert AccessWidth
|
||||
* into number of bits based
|
||||
*/
|
||||
*Value = 0;
|
||||
AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32);
|
||||
AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
|
||||
BitWidth = Reg->BitOffset + Reg->BitWidth;
|
||||
BitOffset = Reg->BitOffset;
|
||||
|
||||
@ -408,7 +407,7 @@ AcpiHwRead (
|
||||
{
|
||||
if (BitOffset >= AccessWidth)
|
||||
{
|
||||
Value32 = 0;
|
||||
Value64 = 0;
|
||||
BitOffset -= AccessWidth;
|
||||
}
|
||||
else
|
||||
@ -418,31 +417,31 @@ AcpiHwRead (
|
||||
Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
|
||||
Address + Index * ACPI_DIV_8 (AccessWidth),
|
||||
&Value64, AccessWidth);
|
||||
Value32 = (UINT32) Value64;
|
||||
}
|
||||
else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
|
||||
{
|
||||
Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
|
||||
Address + Index * ACPI_DIV_8 (AccessWidth),
|
||||
&Value32, AccessWidth);
|
||||
Value64 = (UINT64) Value32;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Use offset style bit writes because "Index * AccessWidth" is
|
||||
* ensured to be less than 32-bits by AcpiHwValidateRegister().
|
||||
* ensured to be less than 64-bits by AcpiHwValidateRegister().
|
||||
*/
|
||||
ACPI_SET_BITS (Value, Index * AccessWidth,
|
||||
ACPI_MASK_BITS_ABOVE_32 (AccessWidth), Value32);
|
||||
ACPI_MASK_BITS_ABOVE_64 (AccessWidth), Value64);
|
||||
|
||||
BitWidth -= BitWidth > AccessWidth ? AccessWidth : BitWidth;
|
||||
Index++;
|
||||
}
|
||||
|
||||
ACPI_DEBUG_PRINT ((ACPI_DB_IO,
|
||||
"Read: %8.8X width %2d from %8.8X%8.8X (%s)\n",
|
||||
*Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),
|
||||
AcpiUtGetRegionName (Reg->SpaceId)));
|
||||
"Read: %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n",
|
||||
ACPI_FORMAT_UINT64 (*Value), AccessWidth,
|
||||
ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
|
||||
|
||||
return (Status);
|
||||
}
|
||||
@ -457,15 +456,14 @@ AcpiHwRead (
|
||||
*
|
||||
* RETURN: Status
|
||||
*
|
||||
* DESCRIPTION: Write to either memory or IO space. This is a 32-bit max
|
||||
* version of AcpiWrite, used internally since the overhead of
|
||||
* 64-bit values is not needed.
|
||||
* DESCRIPTION: Write to either memory or IO space. This is a 64-bit max
|
||||
* version of AcpiWrite.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiHwWrite (
|
||||
UINT32 Value,
|
||||
UINT64 Value,
|
||||
ACPI_GENERIC_ADDRESS *Reg)
|
||||
{
|
||||
UINT64 Address;
|
||||
@ -473,7 +471,6 @@ AcpiHwWrite (
|
||||
UINT32 BitWidth;
|
||||
UINT8 BitOffset;
|
||||
UINT64 Value64;
|
||||
UINT32 Value32;
|
||||
UINT8 Index;
|
||||
ACPI_STATUS Status;
|
||||
|
||||
@ -483,7 +480,7 @@ AcpiHwWrite (
|
||||
|
||||
/* Validate contents of the GAS register */
|
||||
|
||||
Status = AcpiHwValidateRegister (Reg, 32, &Address);
|
||||
Status = AcpiHwValidateRegister (Reg, 64, &Address);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
@ -491,7 +488,7 @@ AcpiHwWrite (
|
||||
|
||||
/* Convert AccessWidth into number of bits based */
|
||||
|
||||
AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 32);
|
||||
AccessWidth = AcpiHwGetAccessBitWidth (Address, Reg, 64);
|
||||
BitWidth = Reg->BitOffset + Reg->BitWidth;
|
||||
BitOffset = Reg->BitOffset;
|
||||
|
||||
@ -504,10 +501,10 @@ AcpiHwWrite (
|
||||
{
|
||||
/*
|
||||
* Use offset style bit reads because "Index * AccessWidth" is
|
||||
* ensured to be less than 32-bits by AcpiHwValidateRegister().
|
||||
* ensured to be less than 64-bits by AcpiHwValidateRegister().
|
||||
*/
|
||||
Value32 = ACPI_GET_BITS (&Value, Index * AccessWidth,
|
||||
ACPI_MASK_BITS_ABOVE_32 (AccessWidth));
|
||||
Value64 = ACPI_GET_BITS (&Value, Index * AccessWidth,
|
||||
ACPI_MASK_BITS_ABOVE_64 (AccessWidth));
|
||||
|
||||
if (BitOffset >= AccessWidth)
|
||||
{
|
||||
@ -517,7 +514,6 @@ AcpiHwWrite (
|
||||
{
|
||||
if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
|
||||
{
|
||||
Value64 = (UINT64) Value32;
|
||||
Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
|
||||
Address + Index * ACPI_DIV_8 (AccessWidth),
|
||||
Value64, AccessWidth);
|
||||
@ -526,7 +522,7 @@ AcpiHwWrite (
|
||||
{
|
||||
Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
|
||||
Address + Index * ACPI_DIV_8 (AccessWidth),
|
||||
Value32, AccessWidth);
|
||||
(UINT32) Value64, AccessWidth);
|
||||
}
|
||||
}
|
||||
|
||||
@ -539,9 +535,9 @@ AcpiHwWrite (
|
||||
}
|
||||
|
||||
ACPI_DEBUG_PRINT ((ACPI_DB_IO,
|
||||
"Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n",
|
||||
Value, AccessWidth, ACPI_FORMAT_UINT64 (Address),
|
||||
AcpiUtGetRegionName (Reg->SpaceId)));
|
||||
"Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n",
|
||||
ACPI_FORMAT_UINT64 (Value), AccessWidth,
|
||||
ACPI_FORMAT_UINT64 (Address), AcpiUtGetRegionName (Reg->SpaceId)));
|
||||
|
||||
return (Status);
|
||||
}
|
||||
@ -688,6 +684,7 @@ AcpiHwRegisterRead (
|
||||
UINT32 *ReturnValue)
|
||||
{
|
||||
UINT32 Value = 0;
|
||||
UINT64 Value64;
|
||||
ACPI_STATUS Status;
|
||||
|
||||
|
||||
@ -726,12 +723,14 @@ AcpiHwRegisterRead (
|
||||
|
||||
case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
|
||||
|
||||
Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPm2ControlBlock);
|
||||
Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPm2ControlBlock);
|
||||
Value = (UINT32) Value64;
|
||||
break;
|
||||
|
||||
case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
|
||||
|
||||
Status = AcpiHwRead (&Value, &AcpiGbl_FADT.XPmTimerBlock);
|
||||
Status = AcpiHwRead (&Value64, &AcpiGbl_FADT.XPmTimerBlock);
|
||||
Value = (UINT32) Value64;
|
||||
break;
|
||||
|
||||
case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
|
||||
@ -749,7 +748,7 @@ AcpiHwRegisterRead (
|
||||
|
||||
if (ACPI_SUCCESS (Status))
|
||||
{
|
||||
*ReturnValue = Value;
|
||||
*ReturnValue = (UINT32) Value;
|
||||
}
|
||||
|
||||
return_ACPI_STATUS (Status);
|
||||
@ -789,6 +788,7 @@ AcpiHwRegisterWrite (
|
||||
{
|
||||
ACPI_STATUS Status;
|
||||
UINT32 ReadValue;
|
||||
UINT64 ReadValue64;
|
||||
|
||||
|
||||
ACPI_FUNCTION_TRACE (HwRegisterWrite);
|
||||
@ -850,11 +850,12 @@ AcpiHwRegisterWrite (
|
||||
* For control registers, all reserved bits must be preserved,
|
||||
* as per the ACPI spec.
|
||||
*/
|
||||
Status = AcpiHwRead (&ReadValue, &AcpiGbl_FADT.XPm2ControlBlock);
|
||||
Status = AcpiHwRead (&ReadValue64, &AcpiGbl_FADT.XPm2ControlBlock);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
goto Exit;
|
||||
}
|
||||
ReadValue = (UINT32) ReadValue64;
|
||||
|
||||
/* Insert the bits to be preserved */
|
||||
|
||||
@ -910,26 +911,29 @@ AcpiHwReadMultiple (
|
||||
{
|
||||
UINT32 ValueA = 0;
|
||||
UINT32 ValueB = 0;
|
||||
UINT64 Value64;
|
||||
ACPI_STATUS Status;
|
||||
|
||||
|
||||
/* The first register is always required */
|
||||
|
||||
Status = AcpiHwRead (&ValueA, RegisterA);
|
||||
Status = AcpiHwRead (&Value64, RegisterA);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
ValueA = (UINT32) Value64;
|
||||
|
||||
/* Second register is optional */
|
||||
|
||||
if (RegisterB->Address)
|
||||
{
|
||||
Status = AcpiHwRead (&ValueB, RegisterB);
|
||||
Status = AcpiHwRead (&Value64, RegisterB);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
ValueB = (UINT32) Value64;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -215,6 +215,7 @@ AcpiGetTimer (
|
||||
UINT32 *Ticks)
|
||||
{
|
||||
ACPI_STATUS Status;
|
||||
UINT64 TimerValue;
|
||||
|
||||
|
||||
ACPI_FUNCTION_TRACE (AcpiGetTimer);
|
||||
@ -232,7 +233,14 @@ AcpiGetTimer (
|
||||
return_ACPI_STATUS (AE_SUPPORT);
|
||||
}
|
||||
|
||||
Status = AcpiHwRead (Ticks, &AcpiGbl_FADT.XPmTimerBlock);
|
||||
Status = AcpiHwRead (&TimerValue, &AcpiGbl_FADT.XPmTimerBlock);
|
||||
if (ACPI_SUCCESS (Status))
|
||||
{
|
||||
/* ACPI PM Timer is defined to be 32 bits (PM_TMR_LEN) */
|
||||
|
||||
*Ticks = (UINT32) TimerValue;
|
||||
}
|
||||
|
||||
return_ACPI_STATUS (Status);
|
||||
}
|
||||
|
||||
|
||||
@ -247,84 +247,14 @@ AcpiRead (
|
||||
UINT64 *ReturnValue,
|
||||
ACPI_GENERIC_ADDRESS *Reg)
|
||||
{
|
||||
UINT32 ValueLo;
|
||||
UINT32 ValueHi;
|
||||
UINT32 Width;
|
||||
UINT64 Address;
|
||||
ACPI_STATUS Status;
|
||||
|
||||
|
||||
ACPI_FUNCTION_NAME (AcpiRead);
|
||||
|
||||
|
||||
if (!ReturnValue)
|
||||
{
|
||||
return (AE_BAD_PARAMETER);
|
||||
}
|
||||
|
||||
/* Validate contents of the GAS register. Allow 64-bit transfers */
|
||||
|
||||
Status = AcpiHwValidateRegister (Reg, 64, &Address);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
|
||||
/*
|
||||
* Two address spaces supported: Memory or I/O. PCI_Config is
|
||||
* not supported here because the GAS structure is insufficient
|
||||
*/
|
||||
if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
|
||||
{
|
||||
Status = AcpiOsReadMemory ((ACPI_PHYSICAL_ADDRESS)
|
||||
Address, ReturnValue, Reg->BitWidth);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
}
|
||||
else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
|
||||
{
|
||||
ValueLo = 0;
|
||||
ValueHi = 0;
|
||||
|
||||
Width = Reg->BitWidth;
|
||||
if (Width == 64)
|
||||
{
|
||||
Width = 32; /* Break into two 32-bit transfers */
|
||||
}
|
||||
|
||||
Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
|
||||
Address, &ValueLo, Width);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
|
||||
if (Reg->BitWidth == 64)
|
||||
{
|
||||
/* Read the top 32 bits */
|
||||
|
||||
Status = AcpiHwReadPort ((ACPI_IO_ADDRESS)
|
||||
(Address + 4), &ValueHi, 32);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
}
|
||||
|
||||
/* Set the return value only if status is AE_OK */
|
||||
|
||||
*ReturnValue = (ValueLo | ((UINT64) ValueHi << 32));
|
||||
}
|
||||
|
||||
ACPI_DEBUG_PRINT ((ACPI_DB_IO,
|
||||
"Read: %8.8X%8.8X width %2d from %8.8X%8.8X (%s)\n",
|
||||
ACPI_FORMAT_UINT64 (*ReturnValue), Reg->BitWidth,
|
||||
ACPI_FORMAT_UINT64 (Address),
|
||||
AcpiUtGetRegionName (Reg->SpaceId)));
|
||||
|
||||
return (AE_OK);
|
||||
Status = AcpiHwRead (ReturnValue, Reg);
|
||||
return (Status);
|
||||
}
|
||||
|
||||
ACPI_EXPORT_SYMBOL (AcpiRead)
|
||||
@ -348,67 +278,13 @@ AcpiWrite (
|
||||
UINT64 Value,
|
||||
ACPI_GENERIC_ADDRESS *Reg)
|
||||
{
|
||||
UINT32 Width;
|
||||
UINT64 Address;
|
||||
ACPI_STATUS Status;
|
||||
|
||||
|
||||
ACPI_FUNCTION_NAME (AcpiWrite);
|
||||
|
||||
|
||||
/* Validate contents of the GAS register. Allow 64-bit transfers */
|
||||
|
||||
Status = AcpiHwValidateRegister (Reg, 64, &Address);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
|
||||
/*
|
||||
* Two address spaces supported: Memory or IO. PCI_Config is
|
||||
* not supported here because the GAS structure is insufficient
|
||||
*/
|
||||
if (Reg->SpaceId == ACPI_ADR_SPACE_SYSTEM_MEMORY)
|
||||
{
|
||||
Status = AcpiOsWriteMemory ((ACPI_PHYSICAL_ADDRESS)
|
||||
Address, Value, Reg->BitWidth);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
}
|
||||
else /* ACPI_ADR_SPACE_SYSTEM_IO, validated earlier */
|
||||
{
|
||||
Width = Reg->BitWidth;
|
||||
if (Width == 64)
|
||||
{
|
||||
Width = 32; /* Break into two 32-bit transfers */
|
||||
}
|
||||
|
||||
Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
|
||||
Address, ACPI_LODWORD (Value), Width);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
|
||||
if (Reg->BitWidth == 64)
|
||||
{
|
||||
Status = AcpiHwWritePort ((ACPI_IO_ADDRESS)
|
||||
(Address + 4), ACPI_HIDWORD (Value), 32);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ACPI_DEBUG_PRINT ((ACPI_DB_IO,
|
||||
"Wrote: %8.8X%8.8X width %2d to %8.8X%8.8X (%s)\n",
|
||||
ACPI_FORMAT_UINT64 (Value), Reg->BitWidth,
|
||||
ACPI_FORMAT_UINT64 (Address),
|
||||
AcpiUtGetRegionName (Reg->SpaceId)));
|
||||
|
||||
Status = AcpiHwWrite (Value, Reg);
|
||||
return (Status);
|
||||
}
|
||||
|
||||
|
||||
@ -191,8 +191,7 @@ AcpiNsConvertToInteger (
|
||||
|
||||
/* String-to-Integer conversion */
|
||||
|
||||
Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer,
|
||||
AcpiGbl_IntegerByteWidth, &Value);
|
||||
Status = AcpiUtStrtoul64 (OriginalObject->String.Pointer, &Value);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
|
||||
@ -300,10 +300,13 @@ AcpiReallocateRootTable (
|
||||
|
||||
|
||||
/*
|
||||
* Only reallocate the root table if the host provided a static buffer
|
||||
* for the table array in the call to AcpiInitializeTables.
|
||||
* If there are tables unverified, it is required to reallocate the
|
||||
* root table list to clean up invalid table entries. Otherwise only
|
||||
* reallocate the root table list if the host provided a static buffer
|
||||
* for the table array in the call to AcpiInitializeTables().
|
||||
*/
|
||||
if (AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED)
|
||||
if ((AcpiGbl_RootTableList.Flags & ACPI_ROOT_ORIGIN_ALLOCATED) &&
|
||||
AcpiGbl_EnableTableValidation)
|
||||
{
|
||||
return_ACPI_STATUS (AE_SUPPORT);
|
||||
}
|
||||
|
||||
613
source/components/utilities/utstrsuppt.c
Normal file
613
source/components/utilities/utstrsuppt.c
Normal file
@ -0,0 +1,613 @@
|
||||
/*******************************************************************************
|
||||
*
|
||||
* Module Name: utstrsuppt - Support functions for string-to-integer conversion
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
* 1. Copyright Notice
|
||||
*
|
||||
* Some or all of this work - Copyright (c) 1999 - 2017, 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.
|
||||
*
|
||||
*****************************************************************************
|
||||
*
|
||||
* Alternatively, you may choose to be licensed under the terms of the
|
||||
* following license:
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions, and the following disclaimer,
|
||||
* without modification.
|
||||
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
||||
* substantially similar to the "NO WARRANTY" disclaimer below
|
||||
* ("Disclaimer") and any redistribution must be conditioned upon
|
||||
* including a substantially similar Disclaimer requirement for further
|
||||
* binary redistribution.
|
||||
* 3. Neither the names of the above-listed copyright holders nor the names
|
||||
* of any contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*
|
||||
* Alternatively, you may choose to be licensed under the terms of the
|
||||
* GNU General Public License ("GPL") version 2 as published by the Free
|
||||
* Software Foundation.
|
||||
*
|
||||
*****************************************************************************/
|
||||
|
||||
#include "acpi.h"
|
||||
#include "accommon.h"
|
||||
|
||||
#define _COMPONENT ACPI_UTILITIES
|
||||
ACPI_MODULE_NAME ("utstrsuppt")
|
||||
|
||||
|
||||
/* Local prototypes */
|
||||
|
||||
static ACPI_STATUS
|
||||
AcpiUtInsertDigit (
|
||||
UINT64 *AccumulatedValue,
|
||||
UINT32 Base,
|
||||
int AsciiDigit);
|
||||
|
||||
static ACPI_STATUS
|
||||
AcpiUtStrtoulMultiply64 (
|
||||
UINT64 Multiplicand,
|
||||
UINT64 Multiplier,
|
||||
UINT64 *OutProduct);
|
||||
|
||||
static ACPI_STATUS
|
||||
AcpiUtStrtoulAdd64 (
|
||||
UINT64 Addend1,
|
||||
UINT64 Addend2,
|
||||
UINT64 *OutSum);
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtConvertOctalString
|
||||
*
|
||||
* PARAMETERS: String - Null terminated input string
|
||||
* ReturnValuePtr - Where the converted value is returned
|
||||
*
|
||||
* RETURN: Status and 64-bit converted integer
|
||||
*
|
||||
* DESCRIPTION: Performs a base 8 conversion of the input string to an
|
||||
* integer value, either 32 or 64 bits.
|
||||
*
|
||||
* NOTE: Maximum 64-bit unsigned octal value is 01777777777777777777777
|
||||
* Maximum 32-bit unsigned octal value is 037777777777
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiUtConvertOctalString (
|
||||
char *String,
|
||||
UINT64 *ReturnValuePtr)
|
||||
{
|
||||
UINT64 AccumulatedValue = 0;
|
||||
ACPI_STATUS Status = AE_OK;
|
||||
|
||||
|
||||
/* Convert each ASCII byte in the input string */
|
||||
|
||||
while (*String)
|
||||
{
|
||||
/* Character must be ASCII 0-7, otherwise terminate with no error */
|
||||
|
||||
if (!(ACPI_IS_OCTAL_DIGIT (*String)))
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
/* Convert and insert this octal digit into the accumulator */
|
||||
|
||||
Status = AcpiUtInsertDigit (&AccumulatedValue, 8, *String);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
Status = AE_OCTAL_OVERFLOW;
|
||||
break;
|
||||
}
|
||||
|
||||
String++;
|
||||
}
|
||||
|
||||
/* Always return the value that has been accumulated */
|
||||
|
||||
*ReturnValuePtr = AccumulatedValue;
|
||||
return (Status);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtConvertDecimalString
|
||||
*
|
||||
* PARAMETERS: String - Null terminated input string
|
||||
* ReturnValuePtr - Where the converted value is returned
|
||||
*
|
||||
* RETURN: Status and 64-bit converted integer
|
||||
*
|
||||
* DESCRIPTION: Performs a base 10 conversion of the input string to an
|
||||
* integer value, either 32 or 64 bits.
|
||||
*
|
||||
* NOTE: Maximum 64-bit unsigned decimal value is 18446744073709551615
|
||||
* Maximum 32-bit unsigned decimal value is 4294967295
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiUtConvertDecimalString (
|
||||
char *String,
|
||||
UINT64 *ReturnValuePtr)
|
||||
{
|
||||
UINT64 AccumulatedValue = 0;
|
||||
ACPI_STATUS Status = AE_OK;
|
||||
|
||||
|
||||
/* Convert each ASCII byte in the input string */
|
||||
|
||||
while (*String)
|
||||
{
|
||||
/* Character must be ASCII 0-9, otherwise terminate with no error */
|
||||
|
||||
if (!isdigit (*String))
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
/* Convert and insert this decimal digit into the accumulator */
|
||||
|
||||
Status = AcpiUtInsertDigit (&AccumulatedValue, 10, *String);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
Status = AE_DECIMAL_OVERFLOW;
|
||||
break;
|
||||
}
|
||||
|
||||
String++;
|
||||
}
|
||||
|
||||
/* Always return the value that has been accumulated */
|
||||
|
||||
*ReturnValuePtr = AccumulatedValue;
|
||||
return (Status);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtConvertHexString
|
||||
*
|
||||
* PARAMETERS: String - Null terminated input string
|
||||
* ReturnValuePtr - Where the converted value is returned
|
||||
*
|
||||
* RETURN: Status and 64-bit converted integer
|
||||
*
|
||||
* DESCRIPTION: Performs a base 16 conversion of the input string to an
|
||||
* integer value, either 32 or 64 bits.
|
||||
*
|
||||
* NOTE: Maximum 64-bit unsigned hex value is 0xFFFFFFFFFFFFFFFF
|
||||
* Maximum 32-bit unsigned hex value is 0xFFFFFFFF
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiUtConvertHexString (
|
||||
char *String,
|
||||
UINT64 *ReturnValuePtr)
|
||||
{
|
||||
UINT64 AccumulatedValue = 0;
|
||||
ACPI_STATUS Status = AE_OK;
|
||||
|
||||
|
||||
/* Convert each ASCII byte in the input string */
|
||||
|
||||
while (*String)
|
||||
{
|
||||
/* Must be ASCII A-F, a-f, or 0-9, otherwise terminate with no error */
|
||||
|
||||
if (!isxdigit (*String))
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
/* Convert and insert this hex digit into the accumulator */
|
||||
|
||||
Status = AcpiUtInsertDigit (&AccumulatedValue, 16, *String);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
Status = AE_HEX_OVERFLOW;
|
||||
break;
|
||||
}
|
||||
|
||||
String++;
|
||||
}
|
||||
|
||||
/* Always return the value that has been accumulated */
|
||||
|
||||
*ReturnValuePtr = AccumulatedValue;
|
||||
return (Status);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtRemoveLeadingZeros
|
||||
*
|
||||
* PARAMETERS: String - Pointer to input ASCII string
|
||||
*
|
||||
* RETURN: Next character after any leading zeros. This character may be
|
||||
* used by the caller to detect end-of-string.
|
||||
*
|
||||
* DESCRIPTION: Remove any leading zeros in the input string. Return the
|
||||
* next character after the final ASCII zero to enable the caller
|
||||
* to check for the end of the string (NULL terminator).
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
char
|
||||
AcpiUtRemoveLeadingZeros (
|
||||
char **String)
|
||||
{
|
||||
|
||||
while (**String == ACPI_ASCII_ZERO)
|
||||
{
|
||||
*String += 1;
|
||||
}
|
||||
|
||||
return (**String);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtRemoveWhitespace
|
||||
*
|
||||
* PARAMETERS: String - Pointer to input ASCII string
|
||||
*
|
||||
* RETURN: Next character after any whitespace. This character may be
|
||||
* used by the caller to detect end-of-string.
|
||||
*
|
||||
* DESCRIPTION: Remove any leading whitespace in the input string. Return the
|
||||
* next character after the final ASCII zero to enable the caller
|
||||
* to check for the end of the string (NULL terminator).
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
char
|
||||
AcpiUtRemoveWhitespace (
|
||||
char **String)
|
||||
{
|
||||
|
||||
while (isspace ((UINT8) **String))
|
||||
{
|
||||
*String += 1;
|
||||
}
|
||||
|
||||
return (**String);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtDetectHexPrefix
|
||||
*
|
||||
* PARAMETERS: String - Pointer to input ASCII string
|
||||
*
|
||||
* RETURN: TRUE if a "0x" prefix was found at the start of the string
|
||||
*
|
||||
* DESCRIPTION: Detect and remove a hex "0x" prefix
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
BOOLEAN
|
||||
AcpiUtDetectHexPrefix (
|
||||
char **String)
|
||||
{
|
||||
|
||||
if ((**String == ACPI_ASCII_ZERO) &&
|
||||
(tolower ((int) *(*String + 1)) == 'x'))
|
||||
{
|
||||
*String += 2; /* Go past the leading 0x */
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
return (FALSE); /* Not a hex string */
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtDetectOctalPrefix
|
||||
*
|
||||
* PARAMETERS: String - Pointer to input ASCII string
|
||||
*
|
||||
* RETURN: True if an octal "0" prefix was found at the start of the
|
||||
* string
|
||||
*
|
||||
* DESCRIPTION: Detect and remove an octal prefix (zero)
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
BOOLEAN
|
||||
AcpiUtDetectOctalPrefix (
|
||||
char **String)
|
||||
{
|
||||
|
||||
if (**String == ACPI_ASCII_ZERO)
|
||||
{
|
||||
*String += 1; /* Go past the leading 0 */
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
return (FALSE); /* Not an octal string */
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtInsertDigit
|
||||
*
|
||||
* PARAMETERS: AccumulatedValue - Current value of the integer value
|
||||
* accumulator. The new value is
|
||||
* returned here.
|
||||
* Base - Radix, either 8/10/16
|
||||
* AsciiDigit - ASCII single digit to be inserted
|
||||
*
|
||||
* RETURN: Status and result of the convert/insert operation. The only
|
||||
* possible returned exception code is numeric overflow of
|
||||
* either the multiply or add conversion operations.
|
||||
*
|
||||
* DESCRIPTION: Generic conversion and insertion function for all bases:
|
||||
*
|
||||
* 1) Multiply the current accumulated/converted value by the
|
||||
* base in order to make room for the new character.
|
||||
*
|
||||
* 2) Convert the new character to binary and add it to the
|
||||
* current accumulated value.
|
||||
*
|
||||
* Note: The only possible exception indicates an integer
|
||||
* overflow (AE_NUMERIC_OVERFLOW)
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
static ACPI_STATUS
|
||||
AcpiUtInsertDigit (
|
||||
UINT64 *AccumulatedValue,
|
||||
UINT32 Base,
|
||||
int AsciiDigit)
|
||||
{
|
||||
ACPI_STATUS Status;
|
||||
UINT64 Product;
|
||||
|
||||
|
||||
/* Make room in the accumulated value for the incoming digit */
|
||||
|
||||
Status = AcpiUtStrtoulMultiply64 (*AccumulatedValue, Base, &Product);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
return (Status);
|
||||
}
|
||||
|
||||
/* Add in the new digit, and store the sum to the accumulated value */
|
||||
|
||||
Status = AcpiUtStrtoulAdd64 (Product, AcpiUtAsciiCharToHex (AsciiDigit),
|
||||
AccumulatedValue);
|
||||
|
||||
return (Status);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtStrtoulMultiply64
|
||||
*
|
||||
* PARAMETERS: Multiplicand - Current accumulated converted integer
|
||||
* Multiplier - Base/Radix
|
||||
* OutProduct - Where the product is returned
|
||||
*
|
||||
* RETURN: Status and 64-bit product
|
||||
*
|
||||
* DESCRIPTION: Multiply two 64-bit values, with checking for 64-bit overflow as
|
||||
* well as 32-bit overflow if necessary (if the current global
|
||||
* integer width is 32).
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
static ACPI_STATUS
|
||||
AcpiUtStrtoulMultiply64 (
|
||||
UINT64 Multiplicand,
|
||||
UINT64 Multiplier,
|
||||
UINT64 *OutProduct)
|
||||
{
|
||||
UINT64 Product;
|
||||
|
||||
|
||||
/* Exit if either operand is zero */
|
||||
|
||||
*OutProduct = 0;
|
||||
if (!Multiplicand || !Multiplier)
|
||||
{
|
||||
return (AE_OK);
|
||||
}
|
||||
|
||||
/* Check for 64-bit overflow before the actual multiplication */
|
||||
|
||||
if (Multiplicand > (ACPI_UINT64_MAX / Multiplier))
|
||||
{
|
||||
return (AE_NUMERIC_OVERFLOW);
|
||||
}
|
||||
|
||||
Product = Multiplicand * Multiplier;
|
||||
|
||||
/* Check for 32-bit overflow if necessary */
|
||||
|
||||
if ((AcpiGbl_IntegerBitWidth == 32) && (Product > ACPI_UINT32_MAX))
|
||||
{
|
||||
return (AE_NUMERIC_OVERFLOW);
|
||||
}
|
||||
|
||||
*OutProduct = Product;
|
||||
return (AE_OK);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtStrtoulAdd64
|
||||
*
|
||||
* PARAMETERS: Addend1 - Current accumulated converted integer
|
||||
* Addend2 - New hex value/char
|
||||
* OutSum - Where sum is returned (Accumulator)
|
||||
*
|
||||
* RETURN: Status and 64-bit sum
|
||||
*
|
||||
* DESCRIPTION: Add two 64-bit values, with checking for 64-bit overflow as
|
||||
* well as 32-bit overflow if necessary (if the current global
|
||||
* integer width is 32).
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
static ACPI_STATUS
|
||||
AcpiUtStrtoulAdd64 (
|
||||
UINT64 Addend1,
|
||||
UINT64 Addend2,
|
||||
UINT64 *OutSum)
|
||||
{
|
||||
UINT64 Sum;
|
||||
|
||||
|
||||
/* Check for 64-bit overflow before the actual addition */
|
||||
|
||||
if ((Addend1 > 0) && (Addend2 > (ACPI_UINT64_MAX - Addend1)))
|
||||
{
|
||||
return (AE_NUMERIC_OVERFLOW);
|
||||
}
|
||||
|
||||
Sum = Addend1 + Addend2;
|
||||
|
||||
/* Check for 32-bit overflow if necessary */
|
||||
|
||||
if ((AcpiGbl_IntegerBitWidth == 32) && (Sum > ACPI_UINT32_MAX))
|
||||
{
|
||||
return (AE_NUMERIC_OVERFLOW);
|
||||
}
|
||||
|
||||
*OutSum = Sum;
|
||||
return (AE_OK);
|
||||
}
|
||||
@ -1,6 +1,7 @@
|
||||
/*******************************************************************************
|
||||
*
|
||||
* Module Name: utstrtoul64 - string to 64-bit integer support
|
||||
* Module Name: utstrtoul64 - String-to-integer conversion support for both
|
||||
* 64-bit and 32-bit integers
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -152,84 +153,47 @@
|
||||
#include "acpi.h"
|
||||
#include "accommon.h"
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* The functions in this module satisfy the need for 64-bit string-to-integer
|
||||
* conversions on both 32-bit and 64-bit platforms.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
#define _COMPONENT ACPI_UTILITIES
|
||||
ACPI_MODULE_NAME ("utstrtoul64")
|
||||
|
||||
/* Local prototypes */
|
||||
|
||||
static UINT64
|
||||
AcpiUtStrtoulBase10 (
|
||||
char *String,
|
||||
UINT32 Flags);
|
||||
|
||||
static UINT64
|
||||
AcpiUtStrtoulBase16 (
|
||||
char *String,
|
||||
UINT32 Flags);
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* String conversion rules as written in the ACPI specification. The error
|
||||
* conditions and behavior are different depending on the type of conversion.
|
||||
* This module contains the top-level string to 64/32-bit unsigned integer
|
||||
* conversion functions:
|
||||
*
|
||||
* 1) A standard strtoul() function that supports 64-bit integers, base
|
||||
* 8/10/16, with integer overflow support. This is used mainly by the
|
||||
* iASL compiler, which implements tighter constraints on integer
|
||||
* constants than the runtime (interpreter) integer-to-string conversions.
|
||||
* 2) Runtime "Explicit conversion" as defined in the ACPI specification.
|
||||
* 3) Runtime "Implicit conversion" as defined in the ACPI specification.
|
||||
*
|
||||
* Implicit data type conversion: string-to-integer
|
||||
* --------------------------------------------------
|
||||
* Current users of this module:
|
||||
*
|
||||
* Base is always 16. This is the ACPI_STRTOUL_BASE16 case.
|
||||
* iASL - Preprocessor (constants and math expressions)
|
||||
* iASL - Main parser, conversion of constants to integers
|
||||
* iASL - Data Table Compiler parser (constants and math expressions)
|
||||
* Interpreter - Implicit and explicit conversions, GPE method names
|
||||
* Interpreter - Repair code for return values from predefined names
|
||||
* Debugger - Command line input string conversion
|
||||
* AcpiDump - ACPI table physical addresses
|
||||
* AcpiExec - Support for namespace overrides
|
||||
*
|
||||
* Example:
|
||||
* Add ("BA98", Arg0, Local0)
|
||||
* Notes concerning users of these interfaces:
|
||||
*
|
||||
* The integer is initialized to the value zero.
|
||||
* The ASCII string is interpreted as a hexadecimal constant.
|
||||
* AcpiGbl_IntegerByteWidth is used to set the 32/64 bit limit for explicit
|
||||
* and implicit conversions. This global must be set to the proper width.
|
||||
* For the core ACPICA code, the width depends on the DSDT version. For the
|
||||
* AcpiUtStrtoul64 interface, all conversions are 64 bits. This interface is
|
||||
* used primarily for iASL, where the default width is 64 bits for all parsers,
|
||||
* but error checking is performed later to flag cases where a 64-bit constant
|
||||
* is wrongly defined in a 32-bit DSDT/SSDT.
|
||||
*
|
||||
* 1) A "0x" prefix is not allowed. However, ACPICA allows this for
|
||||
* compatibility with previous ACPICA. (NO ERROR)
|
||||
*
|
||||
* 2) Terminates when the size of an integer is reached (32 or 64 bits).
|
||||
* (NO ERROR)
|
||||
*
|
||||
* 3) The first non-hex character terminates the conversion without error.
|
||||
* (NO ERROR)
|
||||
*
|
||||
* 4) Conversion of a null (zero-length) string to an integer is not
|
||||
* allowed. However, ACPICA allows this for compatibility with previous
|
||||
* ACPICA. This conversion returns the value 0. (NO ERROR)
|
||||
*
|
||||
*
|
||||
* Explicit data type conversion: ToInteger() with string operand
|
||||
* ---------------------------------------------------------------
|
||||
*
|
||||
* Base is either 10 (default) or 16 (with 0x prefix)
|
||||
*
|
||||
* Examples:
|
||||
* ToInteger ("1000")
|
||||
* ToInteger ("0xABCD")
|
||||
*
|
||||
* 1) Can be (must be) either a decimal or hexadecimal numeric string.
|
||||
* A hex value must be prefixed by "0x" or it is interpreted as a decimal.
|
||||
*
|
||||
* 2) The value must not exceed the maximum of an integer value. ACPI spec
|
||||
* states the behavior is "unpredictable", so ACPICA matches the behavior
|
||||
* of the implicit conversion case.(NO ERROR)
|
||||
*
|
||||
* 3) Behavior on the first non-hex character is not specified by the ACPI
|
||||
* spec, so ACPICA matches the behavior of the implicit conversion case
|
||||
* and terminates. (NO ERROR)
|
||||
*
|
||||
* 4) A null (zero-length) string is illegal.
|
||||
* However, ACPICA allows this for compatibility with previous ACPICA.
|
||||
* This conversion returns the value 0. (NO ERROR)
|
||||
* In ACPI, the only place where octal numbers are supported is within
|
||||
* the ASL language itself. This is implemented via the main AcpiUtStrtoul64
|
||||
* interface. According the ACPI specification, there is no ACPI runtime
|
||||
* support (explicit/implicit) for octal string conversions.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
@ -238,261 +202,301 @@ AcpiUtStrtoulBase16 (
|
||||
*
|
||||
* FUNCTION: AcpiUtStrtoul64
|
||||
*
|
||||
* PARAMETERS: String - Null terminated input string
|
||||
* Flags - Conversion info, see below
|
||||
* PARAMETERS: String - Null terminated input string,
|
||||
* must be a valid pointer
|
||||
* ReturnValue - Where the converted integer is
|
||||
* returned
|
||||
* returned. Must be a valid pointer
|
||||
*
|
||||
* RETURN: Status and Converted value
|
||||
* RETURN: Status and converted integer. Returns an exception on a
|
||||
* 64-bit numeric overflow
|
||||
*
|
||||
* DESCRIPTION: Convert a string into an unsigned value. Performs either a
|
||||
* 32-bit or 64-bit conversion, depending on the input integer
|
||||
* size in Flags (often the current mode of the interpreter).
|
||||
* DESCRIPTION: Convert a string into an unsigned integer. Always performs a
|
||||
* full 64-bit conversion, regardless of the current global
|
||||
* integer width. Supports Decimal, Hex, and Octal strings.
|
||||
*
|
||||
* Values for Flags:
|
||||
* ACPI_STRTOUL_32BIT - Max integer value is 32 bits
|
||||
* ACPI_STRTOUL_64BIT - Max integer value is 64 bits
|
||||
* ACPI_STRTOUL_BASE16 - Input string is hexadecimal. Default
|
||||
* is 10/16 based on string prefix (0x).
|
||||
* Current users of this function:
|
||||
*
|
||||
* NOTES:
|
||||
* Negative numbers are not supported, as they are not supported by ACPI.
|
||||
*
|
||||
* Supports only base 16 or base 10 strings/values. Does not
|
||||
* support Octal strings, as these are not supported by ACPI.
|
||||
*
|
||||
* Current users of this support:
|
||||
*
|
||||
* Interpreter - Implicit and explicit conversions, GPE method names
|
||||
* Debugger - Command line input string conversion
|
||||
* iASL - Main parser, conversion of constants to integers
|
||||
* iASL - Data Table Compiler parser (constant math expressions)
|
||||
* iASL - Preprocessor (constant math expressions)
|
||||
* AcpiDump - Input table addresses
|
||||
* AcpiExec - Testing of the AcpiUtStrtoul64 function
|
||||
*
|
||||
* Note concerning callers:
|
||||
* AcpiGbl_IntegerByteWidth can be used to set the 32/64 limit. If used,
|
||||
* this global should be set to the proper width. For the core ACPICA code,
|
||||
* this width depends on the DSDT version. For iASL, the default byte
|
||||
* width is always 8 for the parser, but error checking is performed later
|
||||
* to flag cases where a 64-bit constant is defined in a 32-bit DSDT/SSDT.
|
||||
* iASL - Preprocessor (constants and math expressions)
|
||||
* iASL - Main ASL parser, conversion of ASL constants to integers
|
||||
* iASL - Data Table Compiler parser (constants and math expressions)
|
||||
* Interpreter - Repair code for return values from predefined names
|
||||
* AcpiDump - ACPI table physical addresses
|
||||
* AcpiExec - Support for namespace overrides
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiUtStrtoul64 (
|
||||
char *String,
|
||||
UINT32 Flags,
|
||||
UINT64 *ReturnValue)
|
||||
{
|
||||
ACPI_STATUS Status = AE_OK;
|
||||
UINT32 Base;
|
||||
UINT8 OriginalBitWidth;
|
||||
UINT32 Base = 10; /* Default is decimal */
|
||||
|
||||
|
||||
ACPI_FUNCTION_TRACE_STR (UtStrtoul64, String);
|
||||
|
||||
|
||||
/* Parameter validation */
|
||||
|
||||
if (!String || !ReturnValue)
|
||||
{
|
||||
return_ACPI_STATUS (AE_BAD_PARAMETER);
|
||||
}
|
||||
|
||||
*ReturnValue = 0;
|
||||
|
||||
/* Check for zero-length string, returns 0 */
|
||||
/* A NULL return string returns a value of zero */
|
||||
|
||||
if (*String == 0)
|
||||
{
|
||||
return_ACPI_STATUS (AE_OK);
|
||||
}
|
||||
|
||||
/* Skip over any white space at start of string */
|
||||
|
||||
while (isspace ((int) *String))
|
||||
{
|
||||
String++;
|
||||
}
|
||||
|
||||
/* End of string? return 0 */
|
||||
|
||||
if (*String == 0)
|
||||
if (!AcpiUtRemoveWhitespace (&String))
|
||||
{
|
||||
return_ACPI_STATUS (AE_OK);
|
||||
}
|
||||
|
||||
/*
|
||||
* 1) The "0x" prefix indicates base 16. Per the ACPI specification,
|
||||
* the "0x" prefix is only allowed for implicit (non-strict) conversions.
|
||||
* However, we always allow it for compatibility with older ACPICA.
|
||||
* 1) Check for a hex constant. A "0x" prefix indicates base 16.
|
||||
*/
|
||||
if ((*String == ACPI_ASCII_ZERO) &&
|
||||
(tolower ((int) *(String + 1)) == 'x'))
|
||||
{
|
||||
String += 2; /* Go past the 0x */
|
||||
if (*String == 0)
|
||||
{
|
||||
return_ACPI_STATUS (AE_OK); /* Return value 0 */
|
||||
}
|
||||
|
||||
Base = 16;
|
||||
}
|
||||
|
||||
/* 2) Force to base 16 (implicit conversion case) */
|
||||
|
||||
else if (Flags & ACPI_STRTOUL_BASE16)
|
||||
if (AcpiUtDetectHexPrefix (&String))
|
||||
{
|
||||
Base = 16;
|
||||
}
|
||||
|
||||
/* 3) Default fallback is to Base 10 */
|
||||
|
||||
else
|
||||
/*
|
||||
* 2) Check for an octal constant, defined to be a leading zero
|
||||
* followed by sequence of octal digits (0-7)
|
||||
*/
|
||||
else if (AcpiUtDetectOctalPrefix (&String))
|
||||
{
|
||||
Base = 10;
|
||||
Base = 8;
|
||||
}
|
||||
|
||||
/* Skip all leading zeros */
|
||||
|
||||
while (*String == ACPI_ASCII_ZERO)
|
||||
if (!AcpiUtRemoveLeadingZeros (&String))
|
||||
{
|
||||
String++;
|
||||
if (*String == 0)
|
||||
{
|
||||
return_ACPI_STATUS (AE_OK); /* Return value 0 */
|
||||
}
|
||||
return_ACPI_STATUS (AE_OK); /* Return value 0 */
|
||||
}
|
||||
|
||||
/* Perform the base 16 or 10 conversion */
|
||||
/*
|
||||
* Force a full 64-bit conversion. The caller (usually iASL) must
|
||||
* check for a 32-bit overflow later as necessary (If current mode
|
||||
* is 32-bit, meaning a 32-bit DSDT).
|
||||
*/
|
||||
OriginalBitWidth = AcpiGbl_IntegerBitWidth;
|
||||
AcpiGbl_IntegerBitWidth = 64;
|
||||
|
||||
if (Base == 16)
|
||||
/*
|
||||
* Perform the base 8, 10, or 16 conversion. A 64-bit numeric overflow
|
||||
* will return an exception (to allow iASL to flag the statement).
|
||||
*/
|
||||
switch (Base)
|
||||
{
|
||||
*ReturnValue = AcpiUtStrtoulBase16 (String, Flags);
|
||||
}
|
||||
else
|
||||
{
|
||||
*ReturnValue = AcpiUtStrtoulBase10 (String, Flags);
|
||||
case 8:
|
||||
Status = AcpiUtConvertOctalString (String, ReturnValue);
|
||||
break;
|
||||
|
||||
case 10:
|
||||
Status = AcpiUtConvertDecimalString (String, ReturnValue);
|
||||
break;
|
||||
|
||||
case 16:
|
||||
default:
|
||||
Status = AcpiUtConvertHexString (String, ReturnValue);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Only possible exception from above is a 64-bit overflow */
|
||||
|
||||
AcpiGbl_IntegerBitWidth = OriginalBitWidth;
|
||||
return_ACPI_STATUS (Status);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtStrtoulBase10
|
||||
* FUNCTION: AcpiUtImplicitStrtoul64
|
||||
*
|
||||
* PARAMETERS: String - Null terminated input string
|
||||
* Flags - Conversion info
|
||||
* PARAMETERS: String - Null terminated input string,
|
||||
* must be a valid pointer
|
||||
*
|
||||
* RETURN: 64-bit converted integer
|
||||
* RETURN: Converted integer
|
||||
*
|
||||
* DESCRIPTION: Performs a base 10 conversion of the input string to an
|
||||
* integer value, either 32 or 64 bits.
|
||||
* Note: String must be valid and non-null.
|
||||
* DESCRIPTION: Perform a 64-bit conversion with restrictions placed upon
|
||||
* an "implicit conversion" by the ACPI specification. Used by
|
||||
* many ASL operators that require an integer operand, and support
|
||||
* an automatic (implicit) conversion from a string operand
|
||||
* to the final integer operand. The major restriction is that
|
||||
* only hex strings are supported.
|
||||
*
|
||||
* -----------------------------------------------------------------------------
|
||||
*
|
||||
* Base is always 16, either with or without the 0x prefix. Decimal and
|
||||
* Octal strings are not supported, as per the ACPI specification.
|
||||
*
|
||||
* Examples (both are hex values):
|
||||
* Add ("BA98", Arg0, Local0)
|
||||
* Subtract ("0x12345678", Arg1, Local1)
|
||||
*
|
||||
* Conversion rules as extracted from the ACPI specification:
|
||||
*
|
||||
* The converted integer is initialized to the value zero.
|
||||
* The ASCII string is always interpreted as a hexadecimal constant.
|
||||
*
|
||||
* 1) According to the ACPI specification, a "0x" prefix is not allowed.
|
||||
* However, ACPICA allows this as an ACPI extension on general
|
||||
* principle. (NO ERROR)
|
||||
*
|
||||
* 2) The conversion terminates when the size of an integer is reached
|
||||
* (32 or 64 bits). There are no numeric overflow conditions. (NO ERROR)
|
||||
*
|
||||
* 3) The first non-hex character terminates the conversion and returns
|
||||
* the current accumulated value of the converted integer (NO ERROR).
|
||||
*
|
||||
* 4) Conversion of a null (zero-length) string to an integer is
|
||||
* technically not allowed. However, ACPICA allows this as an ACPI
|
||||
* extension. The conversion returns the value 0. (NO ERROR)
|
||||
*
|
||||
* NOTE: There are no error conditions returned by this function. At
|
||||
* the minimum, a value of zero is returned.
|
||||
*
|
||||
* Current users of this function:
|
||||
*
|
||||
* Interpreter - All runtime implicit conversions, as per ACPI specification
|
||||
* iASL - Data Table Compiler parser (constants and math expressions)
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
static UINT64
|
||||
AcpiUtStrtoulBase10 (
|
||||
char *String,
|
||||
UINT32 Flags)
|
||||
UINT64
|
||||
AcpiUtImplicitStrtoul64 (
|
||||
char *String)
|
||||
{
|
||||
int AsciiDigit;
|
||||
UINT64 NextValue;
|
||||
UINT64 ReturnValue = 0;
|
||||
UINT64 ConvertedInteger = 0;
|
||||
|
||||
|
||||
/* Main loop: convert each ASCII byte in the input string */
|
||||
ACPI_FUNCTION_TRACE_STR (UtImplicitStrtoul64, String);
|
||||
|
||||
while (*String)
|
||||
|
||||
if (!AcpiUtRemoveWhitespace (&String))
|
||||
{
|
||||
AsciiDigit = *String;
|
||||
if (!isdigit (AsciiDigit))
|
||||
{
|
||||
/* Not ASCII 0-9, terminate */
|
||||
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* Convert and insert (add) the decimal digit */
|
||||
|
||||
AcpiUtShortMultiply (ReturnValue, 10, &NextValue);
|
||||
NextValue += (AsciiDigit - ACPI_ASCII_ZERO);
|
||||
|
||||
/* Check for overflow (32 or 64 bit) - return current converted value */
|
||||
|
||||
if (((Flags & ACPI_STRTOUL_32BIT) && (NextValue > ACPI_UINT32_MAX)) ||
|
||||
(NextValue < ReturnValue)) /* 64-bit overflow case */
|
||||
{
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
ReturnValue = NextValue;
|
||||
String++;
|
||||
return_VALUE (0);
|
||||
}
|
||||
|
||||
Exit:
|
||||
return (ReturnValue);
|
||||
/*
|
||||
* Per the ACPI specification, only hexadecimal is supported for
|
||||
* implicit conversions, and the "0x" prefix is "not allowed".
|
||||
* However, allow a "0x" prefix as an ACPI extension.
|
||||
*/
|
||||
AcpiUtDetectHexPrefix (&String);
|
||||
|
||||
if (!AcpiUtRemoveLeadingZeros (&String))
|
||||
{
|
||||
return_VALUE (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Ignore overflow as per the ACPI specification. This is implemented by
|
||||
* ignoring the return status from the conversion function called below.
|
||||
* On overflow, the input string is simply truncated.
|
||||
*/
|
||||
AcpiUtConvertHexString (String, &ConvertedInteger);
|
||||
return_VALUE (ConvertedInteger);
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AcpiUtStrtoulBase16
|
||||
* FUNCTION: AcpiUtExplicitStrtoul64
|
||||
*
|
||||
* PARAMETERS: String - Null terminated input string
|
||||
* Flags - conversion info
|
||||
* PARAMETERS: String - Null terminated input string,
|
||||
* must be a valid pointer
|
||||
*
|
||||
* RETURN: 64-bit converted integer
|
||||
* RETURN: Converted integer
|
||||
*
|
||||
* DESCRIPTION: Performs a base 16 conversion of the input string to an
|
||||
* integer value, either 32 or 64 bits.
|
||||
* Note: String must be valid and non-null.
|
||||
* DESCRIPTION: Perform a 64-bit conversion with the restrictions placed upon
|
||||
* an "explicit conversion" by the ACPI specification. The
|
||||
* main restriction is that only hex and decimal are supported.
|
||||
*
|
||||
* -----------------------------------------------------------------------------
|
||||
*
|
||||
* Base is either 10 (default) or 16 (with 0x prefix). Octal (base 8) strings
|
||||
* are not supported, as per the ACPI specification.
|
||||
*
|
||||
* Examples:
|
||||
* ToInteger ("1000") Decimal
|
||||
* ToInteger ("0xABCD") Hex
|
||||
*
|
||||
* Conversion rules as extracted from the ACPI specification:
|
||||
*
|
||||
* 1) The input string is either a decimal or hexadecimal numeric string.
|
||||
* A hex value must be prefixed by "0x" or it is interpreted as decimal.
|
||||
*
|
||||
* 2) The value must not exceed the maximum of an integer value
|
||||
* (32 or 64 bits). The ACPI specification states the behavior is
|
||||
* "unpredictable", so ACPICA matches the behavior of the implicit
|
||||
* conversion case. There are no numeric overflow conditions. (NO ERROR)
|
||||
*
|
||||
* 3) Behavior on the first non-hex character is not defined by the ACPI
|
||||
* specification (for the ToInteger operator), so ACPICA matches the
|
||||
* behavior of the implicit conversion case. It terminates the
|
||||
* conversion and returns the current accumulated value of the converted
|
||||
* integer. (NO ERROR)
|
||||
*
|
||||
* 4) Conversion of a null (zero-length) string to an integer is
|
||||
* technically not allowed. However, ACPICA allows this as an ACPI
|
||||
* extension. The conversion returns the value 0. (NO ERROR)
|
||||
*
|
||||
* NOTE: There are no error conditions returned by this function. At the
|
||||
* minimum, a value of zero is returned.
|
||||
*
|
||||
* Current users of this function:
|
||||
*
|
||||
* Interpreter - Runtime ASL ToInteger operator, as per the ACPI specification
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
static UINT64
|
||||
AcpiUtStrtoulBase16 (
|
||||
char *String,
|
||||
UINT32 Flags)
|
||||
UINT64
|
||||
AcpiUtExplicitStrtoul64 (
|
||||
char *String)
|
||||
{
|
||||
int AsciiDigit;
|
||||
UINT32 ValidDigits = 1;
|
||||
UINT64 ReturnValue = 0;
|
||||
UINT64 ConvertedInteger = 0;
|
||||
UINT32 Base = 10; /* Default is decimal */
|
||||
|
||||
|
||||
/* Main loop: convert each ASCII byte in the input string */
|
||||
ACPI_FUNCTION_TRACE_STR (UtExplicitStrtoul64, String);
|
||||
|
||||
while (*String)
|
||||
|
||||
if (!AcpiUtRemoveWhitespace (&String))
|
||||
{
|
||||
/* Check for overflow (32 or 64 bit) - return current converted value */
|
||||
|
||||
if ((ValidDigits > 16) ||
|
||||
((ValidDigits > 8) && (Flags & ACPI_STRTOUL_32BIT)))
|
||||
{
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
AsciiDigit = *String;
|
||||
if (!isxdigit (AsciiDigit))
|
||||
{
|
||||
/* Not Hex ASCII A-F, a-f, or 0-9, terminate */
|
||||
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* Convert and insert the hex digit */
|
||||
|
||||
AcpiUtShortShiftLeft (ReturnValue, 4, &ReturnValue);
|
||||
ReturnValue |= AcpiUtAsciiCharToHex (AsciiDigit);
|
||||
|
||||
String++;
|
||||
ValidDigits++;
|
||||
return_VALUE (0);
|
||||
}
|
||||
|
||||
Exit:
|
||||
return (ReturnValue);
|
||||
/*
|
||||
* Only Hex and Decimal are supported, as per the ACPI specification.
|
||||
* A "0x" prefix indicates hex; otherwise decimal is assumed.
|
||||
*/
|
||||
if (AcpiUtDetectHexPrefix (&String))
|
||||
{
|
||||
Base = 16;
|
||||
}
|
||||
|
||||
if (!AcpiUtRemoveLeadingZeros (&String))
|
||||
{
|
||||
return_VALUE (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Ignore overflow as per the ACPI specification. This is implemented by
|
||||
* ignoring the return status from the conversion functions called below.
|
||||
* On overflow, the input string is simply truncated.
|
||||
*/
|
||||
switch (Base)
|
||||
{
|
||||
case 10:
|
||||
default:
|
||||
AcpiUtConvertDecimalString (String, &ConvertedInteger);
|
||||
break;
|
||||
|
||||
case 16:
|
||||
AcpiUtConvertHexString (String, &ConvertedInteger);
|
||||
break;
|
||||
}
|
||||
|
||||
return_VALUE (ConvertedInteger);
|
||||
}
|
||||
|
||||
@ -237,8 +237,12 @@ typedef struct acpi_exception_info
|
||||
#define AE_NOT_CONFIGURED EXCEP_ENV (0x001C)
|
||||
#define AE_ACCESS EXCEP_ENV (0x001D)
|
||||
#define AE_IO_ERROR EXCEP_ENV (0x001E)
|
||||
#define AE_NUMERIC_OVERFLOW EXCEP_ENV (0x001F)
|
||||
#define AE_HEX_OVERFLOW EXCEP_ENV (0x0020)
|
||||
#define AE_DECIMAL_OVERFLOW EXCEP_ENV (0x0021)
|
||||
#define AE_OCTAL_OVERFLOW EXCEP_ENV (0x0022)
|
||||
|
||||
#define AE_CODE_ENV_MAX 0x001E
|
||||
#define AE_CODE_ENV_MAX 0x0022
|
||||
|
||||
|
||||
/*
|
||||
@ -371,7 +375,11 @@ static const ACPI_EXCEPTION_INFO AcpiGbl_ExceptionNames_Env[] =
|
||||
EXCEP_TXT ("AE_OWNER_ID_LIMIT", "There are no more Owner IDs available for ACPI tables or control methods"),
|
||||
EXCEP_TXT ("AE_NOT_CONFIGURED", "The interface is not part of the current subsystem configuration"),
|
||||
EXCEP_TXT ("AE_ACCESS", "Permission denied for the requested operation"),
|
||||
EXCEP_TXT ("AE_IO_ERROR", "An I/O error occurred")
|
||||
EXCEP_TXT ("AE_IO_ERROR", "An I/O error occurred"),
|
||||
EXCEP_TXT ("AE_NUMERIC_OVERFLOW", "Overflow during string-to-integer conversion"),
|
||||
EXCEP_TXT ("AE_HEX_OVERFLOW", "Overflow during ASCII hex-to-binary conversion"),
|
||||
EXCEP_TXT ("AE_DECIMAL_OVERFLOW", "Overflow during ASCII decimal-to-binary conversion"),
|
||||
EXCEP_TXT ("AE_OCTAL_OVERFLOW", "Overflow during ASCII octal-to-binary conversion")
|
||||
};
|
||||
|
||||
static const ACPI_EXCEPTION_INFO AcpiGbl_ExceptionNames_Pgm[] =
|
||||
|
||||
@ -185,12 +185,12 @@ AcpiHwValidateRegister (
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiHwRead (
|
||||
UINT32 *Value,
|
||||
UINT64 *Value,
|
||||
ACPI_GENERIC_ADDRESS *Reg);
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiHwWrite (
|
||||
UINT32 Value,
|
||||
UINT64 Value,
|
||||
ACPI_GENERIC_ADDRESS *Reg);
|
||||
|
||||
ACPI_BIT_REGISTER_INFO *
|
||||
|
||||
@ -214,7 +214,7 @@ ACPI_STATUS
|
||||
AcpiExConvertToInteger (
|
||||
ACPI_OPERAND_OBJECT *ObjDesc,
|
||||
ACPI_OPERAND_OBJECT **ResultDesc,
|
||||
UINT32 Flags);
|
||||
UINT32 ImplicitConversion);
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiExConvertToBuffer (
|
||||
@ -683,9 +683,6 @@ AcpiExStoreObjectToNode (
|
||||
ACPI_WALK_STATE *WalkState,
|
||||
UINT8 ImplicitConversion);
|
||||
|
||||
#define ACPI_IMPLICIT_CONVERSION TRUE
|
||||
#define ACPI_NO_IMPLICIT_CONVERSION FALSE
|
||||
|
||||
|
||||
/*
|
||||
* exstoren - resolve/store object
|
||||
|
||||
@ -154,7 +154,7 @@
|
||||
|
||||
/* Current ACPICA subsystem version in YYYYMMDD format */
|
||||
|
||||
#define ACPI_CA_VERSION 0x20170728
|
||||
#define ACPI_CA_VERSION 0x20170831
|
||||
|
||||
#include "acconfig.h"
|
||||
#include "actypes.h"
|
||||
|
||||
@ -179,6 +179,7 @@
|
||||
#define ACPI_SIG_HEST "HEST" /* Hardware Error Source Table */
|
||||
#define ACPI_SIG_MADT "APIC" /* Multiple APIC Description Table */
|
||||
#define ACPI_SIG_MSCT "MSCT" /* Maximum System Characteristics Table */
|
||||
#define ACPI_SIG_PDTT "PDTT" /* Processor Debug Trigger Table */
|
||||
#define ACPI_SIG_PPTT "PPTT" /* Processor Properties Topology Table */
|
||||
#define ACPI_SIG_SBST "SBST" /* Smart Battery Specification Table */
|
||||
#define ACPI_SIG_SLIT "SLIT" /* System Locality Distance Information Table */
|
||||
@ -1600,6 +1601,42 @@ typedef struct acpi_nfit_flush_address
|
||||
} ACPI_NFIT_FLUSH_ADDRESS;
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* PDTT - Processor Debug Trigger Table (ACPI 6.2)
|
||||
* Version 0
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
typedef struct acpi_table_pdtt
|
||||
{
|
||||
ACPI_TABLE_HEADER Header; /* Common ACPI table header */
|
||||
UINT8 TriggerCount;
|
||||
UINT8 Reserved[3];
|
||||
UINT32 ArrayOffset;
|
||||
|
||||
} ACPI_TABLE_PDTT;
|
||||
|
||||
|
||||
/*
|
||||
* PDTT Communication Channel Identifier Structure.
|
||||
* The number of these structures is defined by TriggerCount above,
|
||||
* starting at ArrayOffset.
|
||||
*/
|
||||
typedef struct acpi_pdtt_channel
|
||||
{
|
||||
UINT16 SubChannelId;
|
||||
|
||||
} ACPI_PDTT_CHANNEL;
|
||||
|
||||
|
||||
/* Mask and Flags for above */
|
||||
|
||||
#define ACPI_PDTT_SUBCHANNEL_ID_MASK 0x00FF
|
||||
#define ACPI_PDTT_RUNTIME_TRIGGER (1<<8)
|
||||
#define ACPI_PPTT_WAIT_COMPLETION (1<<9)
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* PPTT - Processor Properties Topology Table (ACPI 6.2)
|
||||
@ -1626,7 +1663,8 @@ enum AcpiPpttType
|
||||
|
||||
/* 0: Processor Hierarchy Node Structure */
|
||||
|
||||
typedef struct acpi_pptt_processor {
|
||||
typedef struct acpi_pptt_processor
|
||||
{
|
||||
ACPI_SUBTABLE_HEADER Header;
|
||||
UINT16 Reserved;
|
||||
UINT32 Flags;
|
||||
@ -1644,7 +1682,8 @@ typedef struct acpi_pptt_processor {
|
||||
|
||||
/* 1: Cache Type Structure */
|
||||
|
||||
typedef struct acpi_pptt_cache {
|
||||
typedef struct acpi_pptt_cache
|
||||
{
|
||||
ACPI_SUBTABLE_HEADER Header;
|
||||
UINT16 Reserved;
|
||||
UINT32 Flags;
|
||||
@ -1676,7 +1715,8 @@ typedef struct acpi_pptt_cache {
|
||||
|
||||
/* 2: ID Structure */
|
||||
|
||||
typedef struct acpi_pptt_id {
|
||||
typedef struct acpi_pptt_id
|
||||
{
|
||||
ACPI_SUBTABLE_HEADER Header;
|
||||
UINT16 Reserved;
|
||||
UINT32 VendorId;
|
||||
|
||||
@ -1030,6 +1030,7 @@ typedef struct acpi_iort_smmu_gsi
|
||||
UINT32 NSgIrptFlags;
|
||||
UINT32 NSgCfgIrpt;
|
||||
UINT32 NSgCfgIrptFlags;
|
||||
|
||||
} ACPI_IORT_SMMU_GSI;
|
||||
|
||||
|
||||
|
||||
@ -250,6 +250,10 @@ extern const char *AcpiGbl_PtypDecode[];
|
||||
#define ACPI_MSG_SUFFIX \
|
||||
AcpiOsPrintf (" (%8.8X/%s-%u)\n", ACPI_CA_VERSION, ModuleName, LineNumber)
|
||||
|
||||
/* Flags to indicate implicit or explicit string-to-integer conversion */
|
||||
|
||||
#define ACPI_IMPLICIT_CONVERSION TRUE
|
||||
#define ACPI_NO_IMPLICIT_CONVERSION FALSE
|
||||
|
||||
/* Types for Resource descriptor entries */
|
||||
|
||||
@ -330,19 +334,57 @@ AcpiUtStricmp (
|
||||
char *String1,
|
||||
char *String2);
|
||||
|
||||
|
||||
/*
|
||||
* utstrsuppt - string-to-integer conversion support functions
|
||||
*/
|
||||
ACPI_STATUS
|
||||
AcpiUtConvertOctalString (
|
||||
char *String,
|
||||
UINT64 *ReturnValue);
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiUtConvertDecimalString (
|
||||
char *String,
|
||||
UINT64 *ReturnValuePtr);
|
||||
|
||||
ACPI_STATUS
|
||||
AcpiUtConvertHexString (
|
||||
char *String,
|
||||
UINT64 *ReturnValuePtr);
|
||||
|
||||
char
|
||||
AcpiUtRemoveWhitespace (
|
||||
char **String);
|
||||
|
||||
char
|
||||
AcpiUtRemoveLeadingZeros (
|
||||
char **String);
|
||||
|
||||
BOOLEAN
|
||||
AcpiUtDetectHexPrefix (
|
||||
char **String);
|
||||
|
||||
BOOLEAN
|
||||
AcpiUtDetectOctalPrefix (
|
||||
char **String);
|
||||
|
||||
|
||||
/*
|
||||
* utstrtoul64 - string-to-integer conversion functions
|
||||
*/
|
||||
ACPI_STATUS
|
||||
AcpiUtStrtoul64 (
|
||||
char *String,
|
||||
UINT32 Flags,
|
||||
UINT64 *RetInteger);
|
||||
|
||||
/*
|
||||
* Values for Flags above
|
||||
* Note: LIMIT values correspond to AcpiGbl_IntegerByteWidth values (4/8)
|
||||
*/
|
||||
#define ACPI_STRTOUL_32BIT 0x04 /* 4 bytes */
|
||||
#define ACPI_STRTOUL_64BIT 0x08 /* 8 bytes */
|
||||
#define ACPI_STRTOUL_BASE16 0x10 /* Default: Base10/16 */
|
||||
UINT64
|
||||
AcpiUtExplicitStrtoul64 (
|
||||
char *String);
|
||||
|
||||
UINT64
|
||||
AcpiUtImplicitStrtoul64 (
|
||||
char *String);
|
||||
|
||||
|
||||
/*
|
||||
|
||||
@ -434,8 +434,7 @@ ApDumpTableByAddress (
|
||||
|
||||
/* Convert argument to an integer physical address */
|
||||
|
||||
Status = AcpiUtStrtoul64 (AsciiAddress, ACPI_STRTOUL_64BIT,
|
||||
&LongAddress);
|
||||
Status = AcpiUtStrtoul64 (AsciiAddress, &LongAddress);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
fprintf (stderr, "%s: Could not convert to a physical address\n",
|
||||
|
||||
@ -343,8 +343,7 @@ ApDoOptions (
|
||||
|
||||
case 'r': /* Dump tables from specified RSDP */
|
||||
|
||||
Status = AcpiUtStrtoul64 (AcpiGbl_Optarg, ACPI_STRTOUL_64BIT,
|
||||
&Gbl_RsdpBase);
|
||||
Status = AcpiUtStrtoul64 (AcpiGbl_Optarg, &Gbl_RsdpBase);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
fprintf (stderr, "%s: Could not convert to a physical address\n",
|
||||
|
||||
@ -311,8 +311,7 @@ AeDoOneOverride (
|
||||
|
||||
/* Extract the 64-bit integer */
|
||||
|
||||
Status = AcpiUtStrtoul64 (ValueString,
|
||||
(ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &Value);
|
||||
Status = AcpiUtStrtoul64 (ValueString, &Value);
|
||||
if (ACPI_FAILURE (Status))
|
||||
{
|
||||
AcpiOsPrintf ("%s %s\n", ValueString,
|
||||
|
||||
@ -598,11 +598,6 @@ main (
|
||||
goto ErrorExit;
|
||||
}
|
||||
|
||||
/* ACPICA runtime configuration */
|
||||
|
||||
AcpiGbl_MaxLoopIterations = 400;
|
||||
|
||||
|
||||
/* Initialize the AML debugger */
|
||||
|
||||
Status = AcpiInitializeDebugger ();
|
||||
|
||||
@ -598,6 +598,14 @@ AeInstallTables (
|
||||
Status = AcpiInitializeTables (NULL, ACPI_MAX_INIT_TABLES, TRUE);
|
||||
ACPI_CHECK_OK (AcpiInitializeTables, Status);
|
||||
|
||||
/*
|
||||
* The following code is prepared to test the deferred table
|
||||
* verification mechanism. When AcpiGbl_EnableTableValidation is set
|
||||
* to FALSE by default, AcpiReallocateRootTable() sets it back to TRUE
|
||||
* and triggers the deferred table verification mechanism accordingly.
|
||||
*/
|
||||
(void) AcpiReallocateRootTable ();
|
||||
|
||||
if (AcpiGbl_LoadTestTables)
|
||||
{
|
||||
/* Test multiple table/UEFI support. First, get the headers */
|
||||
|
||||
@ -230,6 +230,7 @@ extern BOOLEAN Gbl_IgnoreLoneLineFeeds;
|
||||
extern BOOLEAN Gbl_HasLoneLineFeeds;
|
||||
extern BOOLEAN Gbl_Cleanup;
|
||||
extern BOOLEAN Gbl_IgnoreTranslationEscapes;
|
||||
extern BOOLEAN Gbl_CheckAscii;
|
||||
extern void *Gbl_StructDefs;
|
||||
|
||||
#define PARAM_LIST(pl) pl
|
||||
|
||||
@ -167,6 +167,11 @@ AsDetectLoneLineFeeds (
|
||||
char *Filename,
|
||||
char *Buffer);
|
||||
|
||||
static BOOLEAN
|
||||
AsCheckForNonPrintableChars (
|
||||
char *FileBuffer,
|
||||
UINT32 FileSize);
|
||||
|
||||
static ACPI_INLINE int
|
||||
AsMaxInt (int a, int b)
|
||||
{
|
||||
@ -636,6 +641,45 @@ AsConvertFile (
|
||||
}
|
||||
}
|
||||
|
||||
/*******************************************************************************
|
||||
*
|
||||
* FUNCTION: AsCheckForNonPrintableChars
|
||||
*
|
||||
* PARAMETERS: FileBuffer - Buffer with contents of entire file
|
||||
* FileSize - Size of the file and buffer
|
||||
*
|
||||
* RETURN: TRUE if there are no non-printable characters
|
||||
*
|
||||
* DESCRIPTION: Scan a file for any non-printable ASCII bytes.
|
||||
*
|
||||
******************************************************************************/
|
||||
|
||||
static BOOLEAN
|
||||
AsCheckForNonPrintableChars (
|
||||
char *FileBuffer,
|
||||
UINT32 FileSize)
|
||||
{
|
||||
BOOLEAN Found = TRUE;
|
||||
UINT8 Byte;
|
||||
UINT32 i;
|
||||
|
||||
|
||||
/* Scan entire file for any non-printable characters */
|
||||
|
||||
for (i = 0; i < FileSize; i++)
|
||||
{
|
||||
Byte = FileBuffer[i];
|
||||
if (!isprint (Byte) && !isspace (Byte))
|
||||
{
|
||||
printf ( "Non-printable character (0x%2.2X) "
|
||||
"at file offset: %8u (0x%X)\n", Byte, i, i);
|
||||
Found = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
return (Found);
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************
|
||||
*
|
||||
@ -680,13 +724,20 @@ AsProcessOneFile (
|
||||
}
|
||||
|
||||
strcat (Pathname, Filename);
|
||||
|
||||
if (AsGetFile (Pathname, &Gbl_FileBuffer, &Gbl_FileSize))
|
||||
{
|
||||
Status = -1;
|
||||
goto Exit1;
|
||||
}
|
||||
|
||||
/* Exit now if simply checking the file for printable ascii chars */
|
||||
|
||||
if (Gbl_CheckAscii)
|
||||
{
|
||||
Status = 0;
|
||||
goto Exit2;
|
||||
}
|
||||
|
||||
Gbl_HeaderSize = 0;
|
||||
if (strstr (Filename, ".asl"))
|
||||
{
|
||||
@ -873,6 +924,19 @@ AsGetFile (
|
||||
Buffer [Size] = 0; /* Null terminate the buffer */
|
||||
fclose (File);
|
||||
|
||||
/* This option checks the entire file for non-printable chars */
|
||||
|
||||
if (Gbl_CheckAscii)
|
||||
{
|
||||
if (AsCheckForNonPrintableChars (Buffer, Size))
|
||||
{
|
||||
printf ("File contains only printable ASCII characters\n");
|
||||
}
|
||||
|
||||
free (Buffer);
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* Check for unix contamination */
|
||||
|
||||
Gbl_HasLoneLineFeeds = AsDetectLoneLineFeeds (Filename, Buffer);
|
||||
@ -891,7 +955,6 @@ AsGetFile (
|
||||
free (Buffer);
|
||||
|
||||
ErrorExit:
|
||||
|
||||
fclose (File);
|
||||
return (-1);
|
||||
}
|
||||
|
||||
@ -188,6 +188,7 @@ struct stat Gbl_StatBuf;
|
||||
char *Gbl_FileBuffer;
|
||||
UINT32 Gbl_FileSize;
|
||||
UINT32 Gbl_FileType;
|
||||
BOOLEAN Gbl_CheckAscii = FALSE;
|
||||
BOOLEAN Gbl_VerboseMode = FALSE;
|
||||
BOOLEAN Gbl_QuietMode = FALSE;
|
||||
BOOLEAN Gbl_BatchMode = FALSE;
|
||||
@ -201,7 +202,7 @@ BOOLEAN Gbl_Cleanup = FALSE;
|
||||
BOOLEAN Gbl_IgnoreTranslationEscapes = FALSE;
|
||||
|
||||
#define AS_UTILITY_NAME "ACPI Source Code Conversion Utility"
|
||||
#define AS_SUPPORTED_OPTIONS "cdhilqsuv^y"
|
||||
#define AS_SUPPORTED_OPTIONS "acdhilqsuv^y"
|
||||
|
||||
|
||||
/******************************************************************************
|
||||
@ -361,6 +362,7 @@ AsDisplayUsage (
|
||||
|
||||
ACPI_USAGE_HEADER ("acpisrc [-c|l|u] [-dsvy] <SourceDir> <DestinationDir>");
|
||||
|
||||
ACPI_OPTION ("-a <file>", "Check entire file for non-printable characters");
|
||||
ACPI_OPTION ("-c", "Generate cleaned version of the source");
|
||||
ACPI_OPTION ("-h", "Insert dual-license header into all modules");
|
||||
ACPI_OPTION ("-i", "Cleanup macro indentation");
|
||||
@ -505,6 +507,11 @@ main (
|
||||
Gbl_QuietMode = TRUE;
|
||||
break;
|
||||
|
||||
case 'a':
|
||||
|
||||
Gbl_CheckAscii = TRUE;
|
||||
break;
|
||||
|
||||
default:
|
||||
|
||||
AsDisplayUsage ();
|
||||
@ -520,6 +527,14 @@ main (
|
||||
return (-1);
|
||||
}
|
||||
|
||||
/* This option checks the entire file for printable ascii chars */
|
||||
|
||||
if (Gbl_CheckAscii)
|
||||
{
|
||||
AsProcessOneFile (NULL, NULL, NULL, 0, SourcePath, FILE_TYPE_SOURCE);
|
||||
return (0);
|
||||
}
|
||||
|
||||
TargetPath = argv[AcpiGbl_Optind+1];
|
||||
|
||||
if (!ConversionTable)
|
||||
@ -558,6 +573,13 @@ main (
|
||||
}
|
||||
else
|
||||
{
|
||||
if (Gbl_CheckAscii)
|
||||
{
|
||||
AsProcessOneFile (NULL, NULL, NULL, 0,
|
||||
SourcePath, FILE_TYPE_SOURCE);
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* Process a single file */
|
||||
|
||||
/* Differentiate between source and header files */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user