WebSVN – Kolibri OS – Diff – /drivers/devman/acpica/compiler/dtfield.c

 /******************************************************************************
+ *
  * 1. Copyright Notice
  *
- * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
+ * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  * All rights reserved.
+ *
  * 2. License
+ *
 DtCompileString (
     UINT8                   *Buffer,
     DT_FIELD                *Field,
     UINT32                  ByteLength);
-static char *
-DtPciPathToBuffer (
-    char                    *PciPath);
 static void
-DtCompilePciPath (
+DtCompileUnicode (
-    UINT8                   *Buffer,
-    char                    *StringValue,
+    UINT8                   *Buffer,
     DT_FIELD                *Field,
+    UINT32                  ByteLength);
+static ACPI_STATUS
+DtCompileUuid (
+    UINT8                   *Buffer,
+    DT_FIELD                *Field,
+    UINT32                  ByteLength);
+static char *
+DtNormalizeBuffer (
+    char                    *Buffer,
-    UINT32                  ByteLength);
+    UINT32                  *Count);
 /******************************************************************************
     DT_FIELD                *Field,
     UINT32                  ByteLength,
     UINT8                   Type,
     UINT8                   Flags)
+{
+    ACPI_STATUS             Status;
     switch (Type)
+    {
     case DT_FIELD_TYPE_INTEGER:
     case DT_FIELD_TYPE_STRING:
         DtCompileString (Buffer, Field, ByteLength);
+        break;
+    case DT_FIELD_TYPE_UUID:
+        Status = DtCompileUuid (Buffer, Field, ByteLength);
+        if (ACPI_SUCCESS (Status))
+        {
+            break;
+        }
-        break;
+        /* Fall through. */
     case DT_FIELD_TYPE_BUFFER:
         DtCompileBuffer (Buffer, Field->Value, Field, ByteLength);
         break;
+    case DT_FIELD_TYPE_UNICODE:
+        DtCompileUnicode (Buffer, Field, ByteLength);
         break;
     case DT_FIELD_TYPE_PCI_PATH:
-        DtCompilePciPath (Buffer, Field->Value, Field, ByteLength);
+    case DT_FIELD_TYPE_DEVICE_PATH:
         break;
         sprintf (MsgBuffer, "Maximum %u characters", ByteLength);
         DtError (ASL_ERROR, ASL_MSG_STRING_LENGTH, Field, MsgBuffer);
         Length = ByteLength;
+    }
-    /* If input string is shorter than ByteLength, pad with blanks */
     ACPI_MEMSET (Buffer, 0x20, ByteLength);
     ACPI_MEMCPY (Buffer, Field->Value, Length);
+}
+/******************************************************************************
+ *
+ * FUNCTION:    DtCompileUnicode
+ *
+ * PARAMETERS:  Buffer              - Output buffer
+ *              Field               - String to be copied to buffer
+ *              ByteLength          - Maximum length of string
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Convert ASCII string to Unicode string
+ *
+ * Note:  The Unicode string is 16 bits per character, no leading signature,
+ *        with a 16-bit terminating NULL.
+ *
+ *****************************************************************************/
+static void
+DtCompileUnicode (
+    UINT8                   *Buffer,
+    DT_FIELD                *Field,
+    UINT32                  ByteLength)
+{
+    UINT32                  Count;
+    UINT32                  i;
+    char                    *AsciiString;
+    UINT16                  *UnicodeString;
+    AsciiString = Field->Value;
+    UnicodeString = (UINT16 *) Buffer;
+    Count = ACPI_STRLEN (AsciiString) + 1;
+    /* Convert to Unicode string (including null terminator) */
+    for (i = 0; i < Count; i++)
+    {
+        UnicodeString[i] = (UINT16) AsciiString[i];
+    }
+}
+/*******************************************************************************
+ *
+ * FUNCTION:    DtCompileUuid
+ *
+ * PARAMETERS:  Buffer              - Output buffer
+ *              Field               - String to be copied to buffer
+ *              ByteLength          - Maximum length of string
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Convert UUID string to 16-byte buffer
+ *
+ ******************************************************************************/
+static ACPI_STATUS
+DtCompileUuid (
+    UINT8                   *Buffer,
+    DT_FIELD                *Field,
+    UINT32                  ByteLength)
+{
+    char                    *InString;
+    ACPI_STATUS             Status;
+    InString = Field->Value;
+    Status = AuValidateUuid (InString);
+    if (ACPI_FAILURE (Status))
+    {
+        sprintf (MsgBuffer, "%s", Field->Value);
+        DtNameError (ASL_ERROR, ASL_MSG_INVALID_UUID, Field, MsgBuffer);
+    }
+    else
+    {
+        Status = AuConvertStringToUuid (InString, (char *) Buffer);
+    }
+    return (Status);
+}
 /******************************************************************************
+ *
  * FUNCTION:    DtCompileInteger
+ *
+ * PARAMETERS:  Buffer              - Output buffer
- * PARAMETERS:  Buffer              - Output buffer
+ *              Field               - Field obj with Integer to be compiled
- *              Field               - Field obj with Integer to be compiled
+ *              ByteLength          - Byte length of the integer
- *              ByteLength          - Byte length of the integer
+ *              Flags               - Additional compile info
  *
+ * RETURN:      None
  * RETURN:      None
  * DESCRIPTION: Compile an integer. Supports integer expressions with C-style
- * DESCRIPTION: Compile an integer
+ *              operators.
+ *
  *****************************************************************************/
 void
 DtCompileInteger (
     UINT8                   *Buffer,
     DT_FIELD                *Field,
     UINT32                  ByteLength,
-    UINT8                   Flags)
-{
-    UINT64                  Value = 0;
+    UINT8                   Flags)
-    UINT64                  MaxValue;
-    UINT8                   *Hex;
+{
-    char                    *Message = NULL;
+    UINT64                  Value;
-    ACPI_STATUS             Status;
+    UINT64                  MaxValue;
-    int                     i;
+    ACPI_STATUS             Status;
-    /* Byte length must be in range 1-8 */
+    /* Output buffer byte length must be in range 1-8 */
     if ((ByteLength > 8) || (ByteLength == 0))
+    {
         DtFatal (ASL_MSG_COMPILER_INTERNAL, Field,
-            "Invalid internal Byte length");
-        return;
-    }
-    /* Convert string to an actual integer */
-    Status = DtStrtoul64 (Field->Value, &Value);
-    if (ACPI_FAILURE (Status))
-    {
-        if (Status == AE_LIMIT)
-        {
+            "Invalid internal Byte length");
-            Message = "Constant larger than 64 bits";
+        return;
+    }
         else if (Status == AE_BAD_CHARACTER)
     /* Resolve integer expression to a single integer value */
     /* Validate that the input value is within range of the target */
     if (Value > MaxValue)
+    {
-        sprintf (MsgBuffer, "Maximum %u bytes", ByteLength);
+        sprintf (MsgBuffer, "%8.8X%8.8X", ACPI_FORMAT_UINT64 (Value));
-        DtError (ASL_ERROR, ASL_MSG_INTEGER_SIZE, Field, MsgBuffer);
-    }
-    /*
-     * TBD: hard code for ASF! Capabilites field.
-     *
-     * This field is actually a buffer, not a 56-bit integer --
-     * so, the ordering is reversed. Something should be fixed
-     * so we don't need this code.
-     */
-    if (ByteLength == 7)
-    {
-        Hex = ACPI_CAST_PTR (UINT8, &Value);
-        for (i = 6; i >= 0; i--)
-        {
-            Buffer[i] = *Hex;
-            Hex++;
-        }
-        return;
         DtError (ASL_ERROR, ASL_MSG_INTEGER_SIZE, Field, MsgBuffer);
+    }
 Exit:
     ACPI_MEMCPY (Buffer, &Value, ByteLength);
     return;
 }
+/******************************************************************************
+ *
-/******************************************************************************
+ * FUNCTION:    DtNormalizeBuffer
  *
- * FUNCTION:    DtPciPathToBuffer
+ * PARAMETERS:  Buffer              - Input buffer
- *
+ *              Count               - Output the count of hex number in
- * PARAMETERS:  PciPath             - DMAR "PCI Path" field
+ *                                    the Buffer
+ *
- * RETURN:      Strings of PCI path
+ * RETURN:      The normalized buffer, freed by caller
+ *
- * DESCRIPTION: Remove brackets and comma from DMAR "PCI Path" string, for
+ * DESCRIPTION: [1A,2B,3C,4D] or 1A, 2B, 3C, 4D will be normalized
- *              example: [1D, 01] ==> 1D 01
+ *              to 1A 2B 3C 4D
+ *
  *****************************************************************************/
- *****************************************************************************/
+static char *
+DtNormalizeBuffer (
+    char                    *Buffer,
+    UINT32                  *Count)
+{
+    char                    *NewBuffer;
+    char                    *TmpBuffer;
+    UINT32                  BufferCount = 0;
+    BOOLEAN                 Separator = TRUE;
+    char                    c;
+    NewBuffer = UtLocalCalloc (ACPI_STRLEN (Buffer) + 1);
+    TmpBuffer = NewBuffer;
+    while ((c = *Buffer++))
+    {
+        switch (c)
+        {
+        /* Valid separators */
+        case '[':
+        case ']':
+        case ' ':
+        case ',':
+            Separator = TRUE;
+            break;
+        default:
+            if (Separator)
-static char *
-DtPciPathToBuffer (
+            {
-    char                    *PciPath)
+                /* Insert blank as the standard separator */
-{
-    char                    *Buffer;
+                if (NewBuffer[0])
+                {
+                    *TmpBuffer++ = ' ';
+                    BufferCount++;
+                }
                 Separator = FALSE;
     Buffer = UtLocalCalloc (6);
     UINT64                  Value;
     UINT32                  i;
     UINT32                  Count;
+    /* Allow several different types of value separators */
-    Count = ACPI_STRLEN (StringValue) / 3 + 1;
+    StringValue = DtNormalizeBuffer (StringValue, &Count);
+    Hex[2] = 0;
+    for (i = 0; i < Count; i++)
-    Hex[2] = 0;
+    {
-    for (i = 0; i < Count; i++)
+        /* Each element of StringValue is three chars */
-        Hex[0] = StringValue[0];
+        Hex[0] = StringValue[(3 * i)];
-        Hex[1] = StringValue[1];
+        Hex[1] = StringValue[(3 * i) + 1];
             DtError (ASL_ERROR, ASL_MSG_BUFFER_ELEMENT, Field, MsgBuffer);
             return (ByteLength - Count);
+        }
-        Buffer[i] = (UINT8) Value;
-        StringValue += 3;
+        Buffer[i] = (UINT8) Value;
+    }
     ACPI_FREE (StringValue);
     return (ByteLength - Count);
+}
-/******************************************************************************
- *
- * FUNCTION:    DtCompilePciPath
- *
- * PARAMETERS:  Buffer              - Output buffer
- *              StringValue         - DMAR pci path string
- *              ByteLength          - Byte length of DMAR pci path string, 2
- *
- * RETURN:      None
- *
- * DESCRIPTION: Compile DMAR PCI path string to binary
- *
- *****************************************************************************/
-static void
-DtCompilePciPath (
-    UINT8                   *Buffer,
-    char                    *StringValue,
-    DT_FIELD                *Field,
-    UINT32                  ByteLength)
-{
-    char                    *PciPathBuffer;
-    /* Parse path to simple hex digits, then convert to binary */
-    PciPathBuffer = DtPciPathToBuffer (StringValue);
-    DtCompileBuffer (Buffer, PciPathBuffer, Field, ByteLength);
-    ACPI_FREE (PciPathBuffer);
-}
 /******************************************************************************
+ *
  * FUNCTION:    DtCompileFlag
- *
  * PARAMETERS:  Buffer              - Output buffer
- *              Field               - Field to be compiled
+ * PARAMETERS:  Buffer              - Output buffer
- *              Info                - Flag info
+ *              Field               - Field to be compiled
- *              BitPosition         - Flag bit position
+ *              Info                - Flag info
+ *
- * RETURN:      Next flag bit position
+ * RETURN:
  *
  * DESCRIPTION: Compile a flag
+ *
  *****************************************************************************/
-UINT32
-DtCompileFlag (
+void
-    UINT8                   *Buffer,
+DtCompileFlag (
-    DT_FIELD                *Field,
+    UINT8                   *Buffer,
+    DT_FIELD                *Field,
-    ACPI_DMTABLE_INFO       *Info,
+    ACPI_DMTABLE_INFO       *Info)
     UINT32                  BitPosition)
     UINT64                  Value = 0;
     case ACPI_DMT_FLAG4:
     case ACPI_DMT_FLAG5:
     case ACPI_DMT_FLAG6:
     case ACPI_DMT_FLAG7:
         BitPosition = Info->Opcode;
         BitLength = 1;
         break;
+    case ACPI_DMT_FLAGS0:
+        BitPosition = 0;
+        BitLength = 2;
+        break;
-    case ACPI_DMT_FLAGS0:
+    case ACPI_DMT_FLAGS2:
     case ACPI_DMT_FLAGS2:
         BitPosition = 2;
         sprintf (MsgBuffer, "Maximum %u bit", BitLength);
         DtError (ASL_ERROR, ASL_MSG_FLAG_VALUE, Field, MsgBuffer);
         Value = 0;
+    }
-    /* Insert the flag, return next flag bit position */
-    Buffer += ACPI_DIV_8 (BitPosition);
-    *Buffer |= (UINT8) (Value << ACPI_MOD_8 (BitPosition));
-    return (BitPosition + BitLength);
+    *Buffer |= (UINT8) (Value << BitPosition);

Subversion Repositories Kolibri OS

(root)/drivers/devman/acpica/compiler/dtfield.c – Rev 1498 → 2216