char *
MpGetHidFromParseTree (
ACPI_NAMESPACE_NODE *HidNode)
{
ACPI_PARSE_OBJECT *Op;
ACPI_PARSE_OBJECT *Arg;
char *HidString;
Op = HidNode->Op;
if (!Op)
{
/* Object is not resolved, probably an External */
return ("Unresolved Symbol - referenced but not defined in this table");
}
switch (Op->Asl.ParseOpcode)
{
case PARSEOP_NAME:
Arg = Op->Asl.Child; /* Get the NameSeg/NameString node */
Arg = Arg->Asl.Next; /* First peer is the object to be associated with the name */
switch (Arg->Asl.ParseOpcode)
{
case PARSEOP_STRING_LITERAL:
return (Arg->Asl.Value.String);
case PARSEOP_INTEGER:
/* Convert EISAID to a string */
HidString = UtLocalCacheCalloc (ACPI_EISAID_STRING_SIZE);
AcpiExEisaIdToString (HidString, Arg->Asl.Value.Integer);
return (HidString);
default:
return ("UNKNOWN");
}
default:
return ("-No HID-");
}
}
void
PrPushInputFileStack (
FILE *InputFile,
char *Filename)
{
PR_FILE_NODE *Fnode;
AslGbl_HasIncludeFiles = TRUE;
/* Save the current state in an Fnode */
Fnode = UtLocalCalloc (sizeof (PR_FILE_NODE));
Fnode->File = AslGbl_Files[ASL_FILE_INPUT].Handle;
Fnode->Next = AslGbl_InputFileList;
Fnode->Filename = AslGbl_Files[ASL_FILE_INPUT].Filename;
Fnode->CurrentLineNumber = AslGbl_CurrentLineNumber;
/* Push it on the stack */
AslGbl_InputFileList = Fnode;
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"Push InputFile Stack: handle %p\n\n",
AslGbl_CurrentLineNumber, InputFile);
/* Reset the global line count and filename */
AslGbl_Files[ASL_FILE_INPUT].Filename =
UtLocalCacheCalloc (strlen (Filename) + 1);
strcpy (AslGbl_Files[ASL_FILE_INPUT].Filename, Filename);
AslGbl_Files[ASL_FILE_INPUT].Handle = InputFile;
AslGbl_CurrentLineNumber = 1;
/* Emit a new #line directive for the include file */
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n", 1, Filename);
}
void
DtCreateSubtable (
UINT8 *Buffer,
UINT32 Length,
DT_SUBTABLE **RetSubtable)
{
DT_SUBTABLE *Subtable;
char *String;
Subtable = UtSubtableCacheCalloc ();
/* Create a new buffer for the subtable data */
String = UtLocalCacheCalloc (Length);
Subtable->Buffer = ACPI_CAST_PTR (UINT8, String);
memcpy (Subtable->Buffer, Buffer, Length);
Subtable->Length = Length;
Subtable->TotalLength = Length;
*RetSubtable = Subtable;
}
char *
FlMergePathnames (
char *PrefixDir,
char *FilePathname)
{
char *CommonPath;
char *Pathname;
char *LastElement;
DbgPrint (ASL_PARSE_OUTPUT, "Include: Prefix path - \"%s\"\n"
"Include: FilePathname - \"%s\"\n",
PrefixDir, FilePathname);
/*
* If there is no prefix directory or if the file pathname is absolute,
* just return the original file pathname
*/
if (!PrefixDir || (!*PrefixDir) ||
(*FilePathname == '/') ||
(FilePathname[1] == ':'))
{
Pathname = UtLocalCacheCalloc (strlen (FilePathname) + 1);
strcpy (Pathname, FilePathname);
goto ConvertBackslashes;
}
/* Need a local copy of the prefix directory path */
CommonPath = UtLocalCacheCalloc (strlen (PrefixDir) + 1);
strcpy (CommonPath, PrefixDir);
/*
* Walk forward through the file path, and simultaneously backward
* through the prefix directory path until there are no more
* relative references at the start of the file path.
*/
while (*FilePathname && (!strncmp (FilePathname, "../", 3)))
{
/* Remove last element of the prefix directory path */
LastElement = strrchr (CommonPath, '/');
if (!LastElement)
{
goto ConcatenatePaths;
}
*LastElement = 0; /* Terminate CommonPath string */
FilePathname += 3; /* Point to next path element */
}
/*
* Remove the last element of the prefix directory path (it is the same as
* the first element of the file pathname), and build the final merged
* pathname.
*/
LastElement = strrchr (CommonPath, '/');
if (LastElement)
{
*LastElement = 0;
}
/* Build the final merged pathname */
ConcatenatePaths:
Pathname = UtLocalCacheCalloc (
strlen (CommonPath) + strlen (FilePathname) + 2);
if (LastElement && *CommonPath)
{
strcpy (Pathname, CommonPath);
strcat (Pathname, "/");
}
strcat (Pathname, FilePathname);
/* Convert all backslashes to normal slashes */
ConvertBackslashes:
UtConvertBackslashes (Pathname);
DbgPrint (ASL_PARSE_OUTPUT, "Include: Merged Pathname - \"%s\"\n",
Pathname);
return (Pathname);
}
static void
OpnDoDefinitionBlock (
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *Child;
ACPI_SIZE Length;
UINT32 i;
char *Filename;
/*
* These nodes get stuffed into the table header. They are special
* cased when the table is written to the output file.
*
* Mark all of these nodes as non-usable so they won't get output
* as AML opcodes!
*/
/* Get AML filename. Use it if non-null */
Child = Op->Asl.Child;
if (Child->Asl.Value.Buffer &&
*Child->Asl.Value.Buffer &&
(Gbl_UseDefaultAmlFilename))
{
/*
* We will use the AML filename that is embedded in the source file
* for the output filename.
*/
Filename = UtLocalCacheCalloc (strlen (Gbl_DirectoryPath) +
strlen ((char *) Child->Asl.Value.Buffer) + 1);
/* Prepend the current directory path */
strcpy (Filename, Gbl_DirectoryPath);
strcat (Filename, (char *) Child->Asl.Value.Buffer);
Gbl_OutputFilenamePrefix = Filename;
UtConvertBackslashes (Gbl_OutputFilenamePrefix);
}
Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
/* Signature */
Child = Child->Asl.Next;
Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
if (Child->Asl.Value.String)
{
Gbl_TableSignature = Child->Asl.Value.String;
if (strlen (Gbl_TableSignature) != ACPI_NAME_SIZE)
{
AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child,
"Length must be exactly 4 characters");
}
for (i = 0; i < ACPI_NAME_SIZE; i++)
{
if (!isalnum ((int) Gbl_TableSignature[i]))
{
AslError (ASL_ERROR, ASL_MSG_TABLE_SIGNATURE, Child,
"Contains non-alphanumeric characters");
}
}
}
/* Revision */
Child = Child->Asl.Next;
Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
/*
* We used the revision to set the integer width earlier
*/
/* OEMID */
Child = Child->Asl.Next;
Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
if (Child->Asl.Value.String &&
strlen (Child->Asl.Value.String) > ACPI_OEM_ID_SIZE)
{
AslError (ASL_ERROR, ASL_MSG_OEM_ID, Child,
"Length cannot exceed 6 characters");
}
/* OEM TableID */
Child = Child->Asl.Next;
Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
if (Child->Asl.Value.String)
{
Length = strlen (Child->Asl.Value.String);
if (Length > ACPI_OEM_TABLE_ID_SIZE)
{
AslError (ASL_ERROR, ASL_MSG_OEM_TABLE_ID, Child,
"Length cannot exceed 8 characters");
}
Gbl_TableId = UtLocalCacheCalloc (Length + 1);
strcpy (Gbl_TableId, Child->Asl.Value.String);
/*
* Convert anything non-alphanumeric to an underscore. This
* allows us to use the TableID to generate unique C symbols.
*/
for (i = 0; i < Length; i++)
{
if (!isalnum ((int) Gbl_TableId[i]))
{
Gbl_TableId[i] = '_';
}
}
}
/* OEM Revision */
Child = Child->Asl.Next;
Child->Asl.ParseOpcode = PARSEOP_DEFAULT_ARG;
}
ACPI_STATUS
AslDoOneFile (
char *Filename)
{
ACPI_STATUS Status;
/* Re-initialize "some" compiler/preprocessor globals */
AslInitializeGlobals ();
PrInitializeGlobals ();
/*
* Extract the directory path. This path is used for possible include
* files and the optional AML filename embedded in the input file
* DefinitionBlock declaration.
*/
Status = FlSplitInputPathname (Filename, &AslGbl_DirectoryPath, NULL);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Take a copy of the input filename, convert any backslashes */
AslGbl_Files[ASL_FILE_INPUT].Filename =
UtLocalCacheCalloc (strlen (Filename) + 1);
strcpy (AslGbl_Files[ASL_FILE_INPUT].Filename, Filename);
UtConvertBackslashes (AslGbl_Files[ASL_FILE_INPUT].Filename);
/*
* AML Disassembly (Optional)
*/
if (AcpiGbl_DisasmFlag)
{
Status = AslDoDisassembly ();
if (Status != AE_CTRL_CONTINUE)
{
return (Status);
}
}
/*
* Open the input file. Here, this should be an ASCII source file,
* either an ASL file or a Data Table file
*/
Status = FlOpenInputFile (AslGbl_Files[ASL_FILE_INPUT].Filename);
if (ACPI_FAILURE (Status))
{
AePrintErrorLog (ASL_FILE_STDERR);
return (AE_ERROR);
}
AslGbl_OriginalInputFileSize = FlGetFileSize (ASL_FILE_INPUT);
/* Determine input file type */
AslGbl_FileType = AslDetectSourceFileType (&AslGbl_Files[ASL_FILE_INPUT]);
if (AslGbl_FileType == ASL_INPUT_TYPE_BINARY)
{
return (AE_ERROR);
}
/*
* If -p not specified, we will use the input filename as the
* output filename prefix
*/
if (AslGbl_UseDefaultAmlFilename)
{
AslGbl_OutputFilenamePrefix = AslGbl_Files[ASL_FILE_INPUT].Filename;
}
/* Open the optional output files (listings, etc.) */
Status = FlOpenMiscOutputFiles (AslGbl_OutputFilenamePrefix);
if (ACPI_FAILURE (Status))
{
AePrintErrorLog (ASL_FILE_STDERR);
return (AE_ERROR);
}
/*
* Compilation of ASL source versus DataTable source uses different
* compiler subsystems
*/
switch (AslGbl_FileType)
{
/*
* Data Table Compilation
*/
case ASL_INPUT_TYPE_ASCII_DATA:
Status = DtDoCompile ();
if (ACPI_FAILURE (Status))
{
return (Status);
}
if (AslGbl_Signature)
{
AslGbl_Signature = NULL;
}
/* Check if any errors occurred during compile */
Status = AslCheckForErrorExit ();
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Cleanup (for next source file) and exit */
AeClearErrorLog ();
PrTerminatePreprocessor ();
return (Status);
/*
* ASL Compilation
*/
case ASL_INPUT_TYPE_ASCII_ASL:
/* ACPICA subsystem initialization */
Status = AdInitialize ();
if (ACPI_FAILURE (Status))
{
return (Status);
}
(void) CmDoCompile ();
(void) AcpiTerminate ();
/* Check if any errors occurred during compile */
Status = AslCheckForErrorExit ();
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Cleanup (for next source file) and exit */
AeClearErrorLog ();
PrTerminatePreprocessor ();
/* ASL-to-ASL+ conversion - Perform immediate disassembly */
if (AslGbl_DoAslConversion)
{
/*
* New input file is the output AML file from above.
* New output is from the input ASL file from above.
*/
AslGbl_OutputFilenamePrefix = AslGbl_Files[ASL_FILE_INPUT].Filename;
CvDbgPrint ("OUTPUTFILENAME: %s\n", AslGbl_OutputFilenamePrefix);
AslGbl_Files[ASL_FILE_INPUT].Filename =
AslGbl_Files[ASL_FILE_AML_OUTPUT].Filename;
AcpiGbl_DisasmFlag = TRUE;
fprintf (stderr, "\n");
AslDoDisassembly ();
/* delete the AML file. This AML file should never be utilized by AML interpreters. */
FlDeleteFile (ASL_FILE_AML_OUTPUT);
}
return (AE_OK);
/*
* Binary ACPI table was auto-detected, disassemble it
*/
case ASL_INPUT_TYPE_BINARY_ACPI_TABLE:
/* We have what appears to be an ACPI table, disassemble it */
FlCloseFile (ASL_FILE_INPUT);
AslGbl_DoCompile = FALSE;
AcpiGbl_DisasmFlag = TRUE;
Status = AslDoDisassembly ();
return (Status);
/* Unknown binary table */
case ASL_INPUT_TYPE_BINARY:
AePrintErrorLog (ASL_FILE_STDERR);
return (AE_ERROR);
default:
printf ("Unknown file type %X\n", AslGbl_FileType);
return (AE_ERROR);
}
}
ACPI_STATUS
DtCompileTable (
DT_FIELD **Field,
ACPI_DMTABLE_INFO *Info,
DT_SUBTABLE **RetSubtable)
{
DT_FIELD *LocalField;
UINT32 Length;
DT_SUBTABLE *Subtable;
DT_SUBTABLE *InlineSubtable = NULL;
UINT32 FieldLength = 0;
UINT8 FieldType;
UINT8 *Buffer;
UINT8 *FlagBuffer = NULL;
char *String;
UINT32 CurrentFlagByteOffset = 0;
ACPI_STATUS Status = AE_OK;
if (!Field)
{
return (AE_BAD_PARAMETER);
}
if (!*Field)
{
/*
* The field list is empty, this means that we are out of fields to
* parse. In other words, we are at the end of the table.
*/
return (AE_END_OF_TABLE);
}
/* Ignore optional subtable if name does not match */
if ((Info->Flags & DT_OPTIONAL) &&
strcmp ((*Field)->Name, Info->Name))
{
*RetSubtable = NULL;
return (AE_OK);
}
Length = DtGetSubtableLength (*Field, Info);
if (Length == ASL_EOF)
{
return (AE_ERROR);
}
Subtable = UtSubtableCacheCalloc ();
if (Length > 0)
{
String = UtLocalCacheCalloc (Length);
Subtable->Buffer = ACPI_CAST_PTR (UINT8, String);
}
Subtable->Length = Length;
Subtable->TotalLength = Length;
Buffer = Subtable->Buffer;
LocalField = *Field;
Subtable->Name = LocalField->Name;
/*
* Main loop walks the info table for this ACPI table or subtable
*/
for (; Info->Name; Info++)
{
if (Info->Opcode == ACPI_DMT_EXTRA_TEXT)
{
continue;
}
if (!LocalField)
{
sprintf (AslGbl_MsgBuffer, "Found NULL field - Field name \"%s\" needed",
Info->Name);
DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, AslGbl_MsgBuffer);
Status = AE_BAD_DATA;
goto Error;
}
/* Maintain table offsets */
LocalField->TableOffset = AslGbl_CurrentTableOffset;
FieldLength = DtGetFieldLength (LocalField, Info);
AslGbl_CurrentTableOffset += FieldLength;
FieldType = DtGetFieldType (Info);
AslGbl_InputFieldCount++;
switch (FieldType)
{
case DT_FIELD_TYPE_FLAGS_INTEGER:
/*
* Start of the definition of a flags field.
* This master flags integer starts at value zero, in preparation
* to compile and insert the flag fields from the individual bits
*/
LocalField = LocalField->Next;
*Field = LocalField;
FlagBuffer = Buffer;
CurrentFlagByteOffset = Info->Offset;
break;
case DT_FIELD_TYPE_FLAG:
/* Individual Flag field, can be multiple bits */
if (FlagBuffer)
{
/*
* We must increment the FlagBuffer when we have crossed
* into the next flags byte within the flags field
* of type DT_FIELD_TYPE_FLAGS_INTEGER.
*/
FlagBuffer += (Info->Offset - CurrentFlagByteOffset);
CurrentFlagByteOffset = Info->Offset;
DtCompileFlag (FlagBuffer, LocalField, Info);
}
else
{
/* TBD - this is an internal error */
}
LocalField = LocalField->Next;
*Field = LocalField;
break;
case DT_FIELD_TYPE_INLINE_SUBTABLE:
/*
* Recursion (one level max): compile GAS (Generic Address)
* or Notify in-line subtable
*/
*Field = LocalField;
switch (Info->Opcode)
{
case ACPI_DMT_GAS:
Status = DtCompileTable (Field, AcpiDmTableInfoGas,
&InlineSubtable);
break;
case ACPI_DMT_HESTNTFY:
Status = DtCompileTable (Field, AcpiDmTableInfoHestNotify,
&InlineSubtable);
break;
case ACPI_DMT_IORTMEM:
Status = DtCompileTable (Field, AcpiDmTableInfoIortAcc,
&InlineSubtable);
break;
default:
sprintf (AslGbl_MsgBuffer, "Invalid DMT opcode: 0x%.2X",
Info->Opcode);
DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, AslGbl_MsgBuffer);
Status = AE_BAD_DATA;
break;
}
if (ACPI_FAILURE (Status))
{
goto Error;
}
DtSetSubtableLength (InlineSubtable);
memcpy (Buffer, InlineSubtable->Buffer, FieldLength);
LocalField = *Field;
break;
case DT_FIELD_TYPE_LABEL:
DtWriteFieldToListing (Buffer, LocalField, 0);
LocalField = LocalField->Next;
break;
default:
/* Normal case for most field types (Integer, String, etc.) */
DtCompileOneField (Buffer, LocalField,
FieldLength, FieldType, Info->Flags);
DtWriteFieldToListing (Buffer, LocalField, FieldLength);
LocalField = LocalField->Next;
if (Info->Flags & DT_LENGTH)
{
/* Field is an Integer that will contain a subtable length */
Subtable->LengthField = Buffer;
Subtable->SizeOfLengthField = FieldLength;
}
break;
}
Buffer += FieldLength;
}
*Field = LocalField;
*RetSubtable = Subtable;
return (AE_OK);
Error:
ACPI_FREE (Subtable->Buffer);
ACPI_FREE (Subtable);
return (Status);
}
static ACPI_STATUS
DtCompileDataTable (
DT_FIELD **FieldList)
{
const ACPI_DMTABLE_DATA *TableData;
DT_SUBTABLE *Subtable;
char *Signature;
ACPI_TABLE_HEADER *AcpiTableHeader;
ACPI_STATUS Status;
DT_FIELD *RootField = *FieldList;
/* Verify that we at least have a table signature and save it */
Signature = DtGetFieldValue (*FieldList);
if (!Signature)
{
sprintf (AslGbl_MsgBuffer, "Expected \"%s\"", "Signature");
DtNameError (ASL_ERROR, ASL_MSG_INVALID_FIELD_NAME,
*FieldList, AslGbl_MsgBuffer);
return (AE_ERROR);
}
AslGbl_Signature = UtLocalCacheCalloc (strlen (Signature) + 1);
strcpy (AslGbl_Signature, Signature);
/*
* Handle tables that don't use the common ACPI table header structure.
* Currently, these are the FACS and RSDP. Also check for an OEMx table,
* these tables have user-defined contents.
*/
if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_FACS))
{
Status = DtCompileFacs (FieldList);
if (ACPI_FAILURE (Status))
{
return (Status);
}
DtSetTableLength ();
return (Status);
}
else if (ACPI_VALIDATE_RSDP_SIG (Signature))
{
Status = DtCompileRsdp (FieldList);
return (Status);
}
else if (ACPI_COMPARE_NAMESEG (Signature, ACPI_SIG_S3PT))
{
Status = DtCompileS3pt (FieldList);
if (ACPI_FAILURE (Status))
{
return (Status);
}
DtSetTableLength ();
return (Status);
}
/*
* All other tables must use the common ACPI table header. Insert the
* current iASL IDs (name, version), and compile the header now.
*/
DtInsertCompilerIds (*FieldList);
Status = DtCompileTable (FieldList, AcpiDmTableInfoHeader,
&AslGbl_RootTable);
if (ACPI_FAILURE (Status))
{
return (Status);
}
DtPushSubtable (AslGbl_RootTable);
/* Validate the signature via the ACPI table list */
TableData = AcpiDmGetTableData (Signature);
if (!TableData || AslGbl_CompileGeneric)
{
/* Unknown table signature and/or force generic compile */
DtCompileGeneric ((void **) FieldList, NULL, NULL);
goto FinishHeader;
}
/* Dispatch to per-table compile */
if (TableData->CmTableHandler)
{
/* Complex table, has a handler */
Status = TableData->CmTableHandler ((void **) FieldList);
if (ACPI_FAILURE (Status))
{
return (Status);
}
}
else if (TableData->TableInfo)
{
/* Simple table, just walk the info table, unless its empty */
if (FieldList && *FieldList)
{
Subtable = NULL;
Status = DtCompileTable (FieldList, TableData->TableInfo,
&Subtable);
if (ACPI_FAILURE (Status))
{
return (Status);
}
DtInsertSubtable (AslGbl_RootTable, Subtable);
DtPopSubtable ();
}
}
else
{
DtFatal (ASL_MSG_COMPILER_INTERNAL, *FieldList,
"Missing table dispatch info");
return (AE_ERROR);
}
FinishHeader:
/* Set the final table length and then the checksum */
DtSetTableLength ();
AcpiTableHeader = ACPI_CAST_PTR (
ACPI_TABLE_HEADER, AslGbl_RootTable->Buffer);
DtSetTableChecksum (&AcpiTableHeader->Checksum);
DtDumpFieldList (RootField);
DtDumpSubtableList ();
return (AE_OK);
}
static UINT8 *
OpcEncodePldBuffer (
ACPI_PLD_INFO *PldInfo)
{
UINT32 *Buffer;
UINT32 Dword;
Buffer = ACPI_CAST_PTR (UINT32, UtLocalCacheCalloc (ACPI_PLD_BUFFER_SIZE));
/* First 32 bits */
Dword = 0;
ACPI_PLD_SET_REVISION (&Dword, PldInfo->Revision);
ACPI_PLD_SET_IGNORE_COLOR (&Dword, PldInfo->IgnoreColor);
ACPI_PLD_SET_RED (&Dword, PldInfo->Red);
ACPI_PLD_SET_GREEN (&Dword, PldInfo->Green);
ACPI_PLD_SET_BLUE (&Dword, PldInfo->Blue);
ACPI_MOVE_32_TO_32 (&Buffer[0], &Dword);
/* Second 32 bits */
Dword = 0;
ACPI_PLD_SET_WIDTH (&Dword, PldInfo->Width);
ACPI_PLD_SET_HEIGHT (&Dword, PldInfo->Height);
ACPI_MOVE_32_TO_32 (&Buffer[1], &Dword);
/* Third 32 bits */
Dword = 0;
ACPI_PLD_SET_USER_VISIBLE (&Dword, PldInfo->UserVisible);
ACPI_PLD_SET_DOCK (&Dword, PldInfo->Dock);
ACPI_PLD_SET_LID (&Dword, PldInfo->Lid);
ACPI_PLD_SET_PANEL (&Dword, PldInfo->Panel);
ACPI_PLD_SET_VERTICAL (&Dword, PldInfo->VerticalPosition);
ACPI_PLD_SET_HORIZONTAL (&Dword, PldInfo->HorizontalPosition);
ACPI_PLD_SET_SHAPE (&Dword, PldInfo->Shape);
ACPI_PLD_SET_ORIENTATION (&Dword, PldInfo->GroupOrientation);
ACPI_PLD_SET_TOKEN (&Dword, PldInfo->GroupToken);
ACPI_PLD_SET_POSITION (&Dword, PldInfo->GroupPosition);
ACPI_PLD_SET_BAY (&Dword, PldInfo->Bay);
ACPI_MOVE_32_TO_32 (&Buffer[2], &Dword);
/* Fourth 32 bits */
Dword = 0;
ACPI_PLD_SET_EJECTABLE (&Dword, PldInfo->Ejectable);
ACPI_PLD_SET_OSPM_EJECT (&Dword, PldInfo->OspmEjectRequired);
ACPI_PLD_SET_CABINET (&Dword, PldInfo->CabinetNumber);
ACPI_PLD_SET_CARD_CAGE (&Dword, PldInfo->CardCageNumber);
ACPI_PLD_SET_REFERENCE (&Dword, PldInfo->Reference);
ACPI_PLD_SET_ROTATION (&Dword, PldInfo->Rotation);
ACPI_PLD_SET_ORDER (&Dword, PldInfo->Order);
ACPI_MOVE_32_TO_32 (&Buffer[3], &Dword);
/* Revision 2 adds an additional DWORD */
if (PldInfo->Revision >= 2)
{
/* Fifth 32 bits */
Dword = 0;
ACPI_PLD_SET_VERT_OFFSET (&Dword, PldInfo->VerticalOffset);
ACPI_PLD_SET_HORIZ_OFFSET (&Dword, PldInfo->HorizontalOffset);
ACPI_MOVE_32_TO_32 (&Buffer[4], &Dword);
}
return (ACPI_CAST_PTR (UINT8, Buffer));
}
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 = UtLocalCacheCalloc (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);
}