[mirror_edk2.git] / MdeModulePkg / Universal / Acpi / AcpiTableDxe / AmlString.c

/** @file\r
  ACPI Sdt Protocol Driver\r
\r
  Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved. <BR>\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "AcpiTable.h"\r
\r
/**\r
  Check if it is AML Root name\r
\r
  @param[in]    Buffer AML path.\r
\r
  @retval       TRUE  AML path is root.\r
  @retval       FALSE AML path is not root.\r
**/\r
BOOLEAN\r
AmlIsRootPath (\r
  IN UINT8              *Buffer\r
  )\r
{\r
  if ((Buffer[0] == AML_ROOT_CHAR) && (Buffer[1] == 0)) {\r
    return TRUE;\r
  } else {\r
    return FALSE;\r
  }\r
}\r
\r
/**\r
  Check if it is AML LeadName.\r
\r
  @param[in]    Ch   Char.\r
\r
  @retval       TRUE  Char is AML LeadName.\r
  @retval       FALSE Char is not AML LeadName.\r
**/\r
BOOLEAN\r
AmlIsLeadName (\r
  IN CHAR8 Ch\r
  )\r
{\r
  if ((Ch == '_') || (Ch >= 'A' && Ch <= 'Z')) {\r
    return TRUE;\r
  } else {\r
    return FALSE;\r
  }\r
}\r
\r
/**\r
  Check if it is AML Name.\r
\r
  @param[in]    Ch   Char.\r
\r
  @retval       TRUE  Char is AML Name.\r
  @retval       FALSE Char is not AML Name.\r
**/\r
BOOLEAN\r
AmlIsName (\r
  IN CHAR8 Ch\r
  )\r
{\r
  if (AmlIsLeadName (Ch) || (Ch >= '0' && Ch <= '9')) {\r
    return TRUE;\r
  } else {\r
    return FALSE;\r
  }\r
}\r
\r
/**\r
  Return is buffer is AML NameSeg.\r
\r
  @param[in]    Buffer     AML NameSement.\r
\r
  @retval       TRUE       It is AML NameSegment.\r
  @retval       FALSE      It is not AML NameSegment.\r
**/\r
BOOLEAN\r
AmlIsNameSeg (\r
  IN  UINT8              *Buffer\r
  )\r
{\r
  UINTN  Index;\r
  if (!AmlIsLeadName (Buffer[0])) {\r
    return FALSE;\r
  }\r
  for (Index = 1; Index < AML_NAME_SEG_SIZE; Index++) {\r
    if (!AmlIsName (Buffer[Index])) {\r
      return FALSE;\r
    }\r
  }\r
  return TRUE;\r
}\r
\r
/**\r
  Get AML NameString size.\r
\r
  @param[in]    Buffer     AML NameString.\r
  @param[out]   BufferSize AML NameString size\r
\r
  @retval       EFI_SUCCESS           Success.\r
  @retval       EFI_INVALID_PARAMETER Buffer does not refer to a valid AML NameString.\r
**/\r
EFI_STATUS\r
AmlGetNameStringSize (\r
  IN  UINT8              *Buffer,\r
  OUT UINTN              *BufferSize\r
  )\r
{\r
  UINTN                 SegCount;\r
  UINTN                 Length;\r
  UINTN                 Index;\r
\r
  Length = 0;\r
\r
  //\r
  // Parse root or parent prefix\r
  //\r
  if (*Buffer == AML_ROOT_CHAR) {\r
    Buffer ++;\r
    Length ++;\r
  } else if (*Buffer == AML_PARENT_PREFIX_CHAR) {\r
    do {\r
      Buffer ++;\r
      Length ++;\r
    } while (*Buffer == AML_PARENT_PREFIX_CHAR);\r
  }\r
\r
  //\r
  // Parse name segment\r
  //\r
  if (*Buffer == AML_DUAL_NAME_PREFIX) {\r
    Buffer ++;\r
    Length ++;\r
    SegCount = 2;\r
  } else if (*Buffer == AML_MULTI_NAME_PREFIX) {\r
    Buffer ++;\r
    Length ++;\r
    SegCount = *Buffer;\r
    Buffer ++;\r
    Length ++;\r
  } else if (*Buffer == 0) {\r
    //\r
    // NULL Name, only for Root\r
    //\r
    SegCount = 0;\r
    Buffer --;\r
    if ((Length == 1) && (*Buffer == AML_ROOT_CHAR)) {\r
      *BufferSize = 2;\r
      return EFI_SUCCESS;\r
    } else {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  } else {\r
    //\r
    // NameSeg\r
    //\r
    SegCount = 1;\r
  }\r
\r
  Index = 0;\r
  do {\r
    if (!AmlIsNameSeg (Buffer)) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    Buffer += AML_NAME_SEG_SIZE;\r
    Length += AML_NAME_SEG_SIZE;\r
    Index ++;\r
  } while (Index < SegCount);\r
\r
  *BufferSize = Length;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Check if it is ASL LeadName.\r
\r
  @param[in]    Ch   Char.\r
\r
  @retval       TRUE  Char is ASL LeadName.\r
  @retval       FALSE Char is not ASL LeadName.\r
**/\r
BOOLEAN\r
AmlIsAslLeadName (\r
  IN CHAR8 Ch\r
  )\r
{\r
  if (AmlIsLeadName (Ch) || (Ch >= 'a' && Ch <= 'z')) {\r
    return TRUE;\r
  } else {\r
    return FALSE;\r
  }\r
}\r
\r
/**\r
  Check if it is ASL Name.\r
\r
  @param[in]    Ch   Char.\r
\r
  @retval       TRUE  Char is ASL Name.\r
  @retval       FALSE Char is not ASL Name.\r
**/\r
BOOLEAN\r
AmlIsAslName (\r
  IN CHAR8 Ch\r
  )\r
{\r
  if (AmlIsAslLeadName (Ch) || (Ch >= '0' && Ch <= '9')) {\r
    return TRUE;\r
  } else {\r
    return FALSE;\r
  }\r
}\r
\r
/**\r
  Get ASL NameString size.\r
\r
  @param[in]    Buffer   ASL NameString.\r
\r
  @return       ASL NameString size.\r
**/\r
UINTN\r
AmlGetAslNameSegLength (\r
  IN UINT8 *Buffer\r
  )\r
{\r
  UINTN Length;\r
  UINTN Index;\r
\r
  if (*Buffer == 0) {\r
    return 0;\r
  }\r
\r
  Length = 0;\r
  //\r
  // 1st\r
  //\r
  if (AmlIsAslLeadName (*Buffer)) {\r
    Length ++;\r
    Buffer ++;\r
  }\r
  if ((*Buffer == 0) || (*Buffer == '.')) {\r
    return Length;\r
  }\r
  //\r
  // 2, 3, 4 name char\r
  //\r
  for (Index = 0; Index < 3; Index++) {\r
    if (AmlIsAslName (*Buffer)) {\r
      Length ++;\r
      Buffer ++;\r
    }\r
    if ((*Buffer == 0) || (*Buffer == '.')) {\r
      return Length;\r
    }\r
  }\r
\r
  //\r
  // Invalid ASL name\r
  //\r
  return 0;\r
}\r
\r
/**\r
  Get ASL NameString size.\r
\r
  @param[in]    Buffer   ASL NameString.\r
  @param[out]   Root     On return, points to Root char number.\r
  @param[out]   Parent   On return, points to Parent char number.\r
  @param[out]   SegCount On return, points to Segment count.\r
\r
  @return       ASL NameString size.\r
**/\r
UINTN\r
AmlGetAslNameStringSize (\r
  IN UINT8              *Buffer,\r
  OUT UINTN             *Root,\r
  OUT UINTN             *Parent,\r
  OUT UINTN             *SegCount\r
  )\r
{\r
  UINTN NameLength;\r
  UINTN TotalLength;\r
\r
  *Root   = 0;\r
  *Parent = 0;\r
  *SegCount = 0;\r
  TotalLength = 0;\r
  NameLength = 0;\r
  if (*Buffer == AML_ROOT_CHAR) {\r
    *Root = 1;\r
    Buffer ++;\r
  } else if (*Buffer == AML_PARENT_PREFIX_CHAR) {\r
    do {\r
      Buffer ++;\r
      (*Parent) ++;\r
    } while (*Buffer == AML_PARENT_PREFIX_CHAR);\r
  }\r
\r
  //\r
  // Now parse name\r
  //\r
  while (*Buffer != 0) {\r
    NameLength = AmlGetAslNameSegLength (Buffer);\r
    if ((NameLength == 0) || (NameLength > AML_NAME_SEG_SIZE)) {\r
      return 0;\r
    }\r
    (*SegCount) ++;\r
    Buffer += NameLength;\r
    if (*Buffer == 0) {\r
      break;\r
    }\r
    Buffer ++;\r
  }\r
\r
  //\r
  // Check SegCoount\r
  //\r
  if (*SegCount > 0xFF) {\r
    return 0;\r
  }\r
\r
  //\r
  // Calculate total length\r
  //\r
  TotalLength = *Root + *Parent + (*SegCount) * AML_NAME_SEG_SIZE;\r
  if (*SegCount > 2) {\r
    TotalLength += 2;\r
  } else if (*SegCount == 2) {\r
    TotalLength += 1;\r
  }\r
\r
  //\r
  // Add NULL char\r
  //\r
  TotalLength ++;\r
\r
  return TotalLength;\r
}\r
\r
/**\r
  Copy mem, and cast all the char in dest to be upper case.\r
\r
  @param[in]    DstBuffer   Destination buffer.\r
  @param[in]    SrcBuffer   Source buffer.\r
  @param[in]    Length      Buffer length.\r
**/\r
VOID\r
AmlUpperCaseCopyMem (\r
  IN UINT8 *DstBuffer,\r
  IN UINT8 *SrcBuffer,\r
  IN UINTN Length\r
  )\r
{\r
  UINTN Index;\r
\r
  for (Index = 0; Index < Length; Index++) {\r
    if (SrcBuffer[Index] >= 'a' && SrcBuffer[Index] <= 'z') {\r
      DstBuffer[Index] = (UINT8)(SrcBuffer[Index] - 'a' + 'A');\r
    } else {\r
      DstBuffer[Index] = SrcBuffer[Index];\r
    }\r
  }\r
}\r
\r
/**\r
  Return AML name according to ASL name.\r
  The caller need free the AmlName returned.\r
\r
  @param[in]    AslPath     ASL name.\r
\r
  @return AmlName\r
**/\r
UINT8 *\r
AmlNameFromAslName (\r
  IN UINT8 *AslPath\r
  )\r
{\r
  UINTN Root;\r
  UINTN Parent;\r
  UINTN SegCount;\r
  UINTN TotalLength;\r
  UINTN NameLength;\r
  UINT8 *Buffer;\r
  UINT8 *AmlPath;\r
  UINT8 *AmlBuffer;\r
\r
  TotalLength = AmlGetAslNameStringSize (AslPath, &Root, &Parent, &SegCount);\r
  if (TotalLength == 0) {\r
    return NULL;\r
  }\r
\r
  AmlPath = AllocatePool (TotalLength);\r
  ASSERT (AmlPath != NULL);\r
\r
  AmlBuffer = AmlPath;\r
  Buffer = AslPath;\r
\r
  //\r
  // Handle Root and Parent\r
  //\r
  if (Root == 1) {\r
    *AmlBuffer = AML_ROOT_CHAR;\r
    AmlBuffer ++;\r
    Buffer ++;\r
  } else if (Parent > 0) {\r
    SetMem (AmlBuffer, Parent, AML_PARENT_PREFIX_CHAR);\r
    AmlBuffer += Parent;\r
    Buffer += Parent;\r
  }\r
\r
  //\r
  // Handle SegCount\r
  //\r
  if (SegCount > 2) {\r
    *AmlBuffer = AML_MULTI_NAME_PREFIX;\r
    AmlBuffer ++;\r
    *AmlBuffer = (UINT8)SegCount;\r
    AmlBuffer ++;\r
  } else if (SegCount == 2) {\r
    *AmlBuffer = AML_DUAL_NAME_PREFIX;\r
    AmlBuffer ++;\r
  }\r
\r
  //\r
  // Now to name\r
  //\r
  while (*Buffer != 0) {\r
    NameLength = AmlGetAslNameSegLength (Buffer);\r
    ASSERT ((NameLength != 0) && (NameLength <= AML_NAME_SEG_SIZE));\r
    AmlUpperCaseCopyMem (AmlBuffer, Buffer, NameLength);\r
    SetMem (AmlBuffer + NameLength, AML_NAME_SEG_SIZE - NameLength, AML_NAME_CHAR__);\r
    Buffer += NameLength;\r
    AmlBuffer += AML_NAME_SEG_SIZE;\r
    if (*Buffer == 0) {\r
      break;\r
    }\r
    Buffer ++;\r
  }\r
\r
  //\r
  // Add NULL\r
  //\r
  AmlPath[TotalLength - 1] = 0;\r
\r
  return AmlPath;\r
}\r
\r
/**\r
  Print AML NameSeg.\r
\r
  @param[in] Buffer AML NameSeg.\r
**/\r
VOID\r
AmlPrintNameSeg (\r
  IN UINT8              *Buffer\r
  )\r
{\r
  DEBUG ((EFI_D_ERROR, "%c", Buffer[0]));\r
  if ((Buffer[1] == '_') && (Buffer[2] == '_') && (Buffer[3] == '_')) {\r
    return ;\r
  }\r
  DEBUG ((EFI_D_ERROR, "%c", Buffer[1]));\r
  if ((Buffer[2] == '_') && (Buffer[3] == '_')) {\r
    return ;\r
  }\r
  DEBUG ((EFI_D_ERROR, "%c", Buffer[2]));\r
  if (Buffer[3] == '_') {\r
    return ;\r
  }\r
  DEBUG ((EFI_D_ERROR, "%c", Buffer[3]));\r
  return ;\r
}\r
\r
/**\r
  Print AML NameString.\r
\r
  @param[in] Buffer AML NameString.\r
**/\r
VOID\r
AmlPrintNameString (\r
  IN UINT8              *Buffer\r
  )\r
{\r
  UINT8                 SegCount;\r
  UINT8                 Index;\r
\r
  if (*Buffer == AML_ROOT_CHAR) {\r
    //\r
    // RootChar\r
    //\r
    Buffer ++;\r
    DEBUG ((EFI_D_ERROR, "\\"));\r
  } else if (*Buffer == AML_PARENT_PREFIX_CHAR) {\r
    //\r
    // ParentPrefixChar\r
    //\r
    do {\r
      Buffer ++;\r
      DEBUG ((EFI_D_ERROR, "^"));\r
    } while (*Buffer == AML_PARENT_PREFIX_CHAR);\r
  }\r
\r
  if (*Buffer == AML_DUAL_NAME_PREFIX) {\r
    //\r
    // DualName\r
    //\r
    Buffer ++;\r
    SegCount = 2;\r
  } else if (*Buffer == AML_MULTI_NAME_PREFIX) {\r
    //\r
    // MultiName\r
    //\r
    Buffer ++;\r
    SegCount = *Buffer;\r
    Buffer ++;\r
  } else if (*Buffer == 0) {\r
    //\r
    // NULL Name\r
    //\r
    return ;\r
  } else {\r
    //\r
    // NameSeg\r
    //\r
    SegCount = 1;\r
  }\r
\r
  AmlPrintNameSeg (Buffer);\r
  Buffer += AML_NAME_SEG_SIZE;\r
  for (Index = 0; Index < SegCount - 1; Index++) {\r
    DEBUG ((EFI_D_ERROR, "."));\r
    AmlPrintNameSeg (Buffer);\r
    Buffer += AML_NAME_SEG_SIZE;\r
  }\r
\r
  return ;\r
}\r
Commit	Line	Data
3dc8585e JY	1	/** @file\r
	2	ACPI Sdt Protocol Driver\r
	3	\r
d1102dba	4	Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved. <BR>\r
3dc8585e JY	5	This program and the accompanying materials\r
	6	are licensed and made available under the terms and conditions of the BSD License\r
	7	which accompanies this distribution. The full text of the license may be found at\r
	8	http://opensource.org/licenses/bsd-license.php\r
	9	\r
	10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	12	\r
	13	**/\r
	14	\r
	15	#include "AcpiTable.h"\r
	16	\r
	17	/**\r
	18	Check if it is AML Root name\r
	19	\r
	20	@param[in] Buffer AML path.\r
d1102dba	21	\r
3dc8585e JY	22	@retval TRUE AML path is root.\r
	23	@retval FALSE AML path is not root.\r
	24	**/\r
	25	BOOLEAN\r
	26	AmlIsRootPath (\r
	27	IN UINT8 *Buffer\r
	28	)\r
	29	{\r
	30	if ((Buffer[0] == AML_ROOT_CHAR) && (Buffer[1] == 0)) {\r
	31	return TRUE;\r
	32	} else {\r
	33	return FALSE;\r
	34	}\r
	35	}\r
	36	\r
	37	/**\r
	38	Check if it is AML LeadName.\r
	39	\r
	40	@param[in] Ch Char.\r
d1102dba	41	\r
3dc8585e JY	42	@retval TRUE Char is AML LeadName.\r
	43	@retval FALSE Char is not AML LeadName.\r
	44	**/\r
	45	BOOLEAN\r
	46	AmlIsLeadName (\r
	47	IN CHAR8 Ch\r
	48	)\r
	49	{\r
	50	if ((Ch == '_') \|\| (Ch >= 'A' && Ch <= 'Z')) {\r
	51	return TRUE;\r
	52	} else {\r
	53	return FALSE;\r
	54	}\r
	55	}\r
	56	\r
	57	/**\r
	58	Check if it is AML Name.\r
	59	\r
	60	@param[in] Ch Char.\r
d1102dba	61	\r
3dc8585e JY	62	@retval TRUE Char is AML Name.\r
	63	@retval FALSE Char is not AML Name.\r
	64	**/\r
	65	BOOLEAN\r
	66	AmlIsName (\r
	67	IN CHAR8 Ch\r
	68	)\r
	69	{\r
	70	if (AmlIsLeadName (Ch) \|\| (Ch >= '0' && Ch <= '9')) {\r
	71	return TRUE;\r
	72	} else {\r
	73	return FALSE;\r
	74	}\r
	75	}\r
	76	\r
	77	/**\r
	78	Return is buffer is AML NameSeg.\r
	79	\r
	80	@param[in] Buffer AML NameSement.\r
d1102dba	81	\r
3dc8585e JY	82	@retval TRUE It is AML NameSegment.\r
	83	@retval FALSE It is not AML NameSegment.\r
	84	**/\r
	85	BOOLEAN\r
	86	AmlIsNameSeg (\r
	87	IN UINT8 *Buffer\r
	88	)\r
	89	{\r
	90	UINTN Index;\r
	91	if (!AmlIsLeadName (Buffer[0])) {\r
	92	return FALSE;\r
	93	}\r
	94	for (Index = 1; Index < AML_NAME_SEG_SIZE; Index++) {\r
	95	if (!AmlIsName (Buffer[Index])) {\r
	96	return FALSE;\r
	97	}\r
	98	}\r
	99	return TRUE;\r
	100	}\r
	101	\r
	102	/**\r
	103	Get AML NameString size.\r
	104	\r
	105	@param[in] Buffer AML NameString.\r
d1102dba LG	106	@param[out] BufferSize AML NameString size\r
d1102dba LG	107	\r
3dc8585e JY	108	@retval EFI_SUCCESS Success.\r
	109	@retval EFI_INVALID_PARAMETER Buffer does not refer to a valid AML NameString.\r
	110	**/\r
	111	EFI_STATUS\r
	112	AmlGetNameStringSize (\r
	113	IN UINT8 *Buffer,\r
	114	OUT UINTN *BufferSize\r
	115	)\r
	116	{\r
	117	UINTN SegCount;\r
	118	UINTN Length;\r
	119	UINTN Index;\r
3dc8585e	120	\r
3dc8585e JY	121	Length = 0;\r
	122	\r
	123	//\r
	124	// Parse root or parent prefix\r
	125	//\r
	126	if (*Buffer == AML_ROOT_CHAR) {\r
	127	Buffer ++;\r
	128	Length ++;\r
	129	} else if (*Buffer == AML_PARENT_PREFIX_CHAR) {\r
	130	do {\r
	131	Buffer ++;\r
	132	Length ++;\r
	133	} while (*Buffer == AML_PARENT_PREFIX_CHAR);\r
	134	}\r
	135	\r
	136	//\r
	137	// Parse name segment\r
	138	//\r
	139	if (*Buffer == AML_DUAL_NAME_PREFIX) {\r
	140	Buffer ++;\r
	141	Length ++;\r
	142	SegCount = 2;\r
	143	} else if (*Buffer == AML_MULTI_NAME_PREFIX) {\r
	144	Buffer ++;\r
	145	Length ++;\r
	146	SegCount = *Buffer;\r
	147	Buffer ++;\r
	148	Length ++;\r
	149	} else if (*Buffer == 0) {\r
	150	//\r
	151	// NULL Name, only for Root\r
	152	//\r
	153	SegCount = 0;\r
	154	Buffer --;\r
	155	if ((Length == 1) && (*Buffer == AML_ROOT_CHAR)) {\r
	156	*BufferSize = 2;\r
	157	return EFI_SUCCESS;\r
	158	} else {\r
	159	return EFI_INVALID_PARAMETER;\r
	160	}\r
	161	} else {\r
	162	//\r
	163	// NameSeg\r
	164	//\r
	165	SegCount = 1;\r
	166	}\r
	167	\r
	168	Index = 0;\r
	169	do {\r
	170	if (!AmlIsNameSeg (Buffer)) {\r
	171	return EFI_INVALID_PARAMETER;\r
	172	}\r
	173	Buffer += AML_NAME_SEG_SIZE;\r
	174	Length += AML_NAME_SEG_SIZE;\r
	175	Index ++;\r
	176	} while (Index < SegCount);\r
	177	\r
	178	*BufferSize = Length;\r
	179	return EFI_SUCCESS;\r
	180	}\r
	181	\r
	182	/**\r
	183	Check if it is ASL LeadName.\r
	184	\r
185	@param[in] Ch Char.\r
d1102dba	186	\r
3dc8585e JY	187	@retval TRUE Char is ASL LeadName.\r
	188	@retval FALSE Char is not ASL LeadName.\r
	189	**/\r
	190	BOOLEAN\r
	191	AmlIsAslLeadName (\r
	192	IN CHAR8 Ch\r
	193	)\r
	194	{\r
	195	if (AmlIsLeadName (Ch) \|\| (Ch >= 'a' && Ch <= 'z')) {\r
	196	return TRUE;\r
	197	} else {\r
	198	return FALSE;\r
	199	}\r
	200	}\r
	201	\r
	202	/**\r
	203	Check if it is ASL Name.\r
	204	\r
	205	@param[in] Ch Char.\r
d1102dba	206	\r
3dc8585e JY	207	@retval TRUE Char is ASL Name.\r
	208	@retval FALSE Char is not ASL Name.\r
	209	**/\r
	210	BOOLEAN\r
	211	AmlIsAslName (\r
	212	IN CHAR8 Ch\r
	213	)\r
	214	{\r
	215	if (AmlIsAslLeadName (Ch) \|\| (Ch >= '0' && Ch <= '9')) {\r
	216	return TRUE;\r
	217	} else {\r
	218	return FALSE;\r
	219	}\r
	220	}\r
	221	\r
	222	/**\r
	223	Get ASL NameString size.\r
	224	\r
	225	@param[in] Buffer ASL NameString.\r
d1102dba	226	\r
3dc8585e JY	227	@return ASL NameString size.\r
	228	**/\r
	229	UINTN\r
	230	AmlGetAslNameSegLength (\r
	231	IN UINT8 *Buffer\r
	232	)\r
	233	{\r
	234	UINTN Length;\r
	235	UINTN Index;\r
	236	\r
	237	if (*Buffer == 0) {\r
	238	return 0;\r
	239	}\r
d1102dba	240	\r
3dc8585e JY	241	Length = 0;\r
	242	//\r
	243	// 1st\r
	244	//\r
	245	if (AmlIsAslLeadName (*Buffer)) {\r
	246	Length ++;\r
	247	Buffer ++;\r
	248	}\r
	249	if ((Buffer == 0) \|\| (Buffer == '.')) {\r
	250	return Length;\r
	251	}\r
	252	//\r
	253	// 2, 3, 4 name char\r
	254	//\r
	255	for (Index = 0; Index < 3; Index++) {\r
	256	if (AmlIsAslName (*Buffer)) {\r
	257	Length ++;\r
	258	Buffer ++;\r
	259	}\r
	260	if ((Buffer == 0) \|\| (Buffer == '.')) {\r
	261	return Length;\r
	262	}\r
	263	}\r
	264	\r
	265	//\r
	266	// Invalid ASL name\r
	267	//\r
	268	return 0;\r
	269	}\r
	270	\r
	271	/**\r
	272	Get ASL NameString size.\r
	273	\r
	274	@param[in] Buffer ASL NameString.\r
	275	@param[out] Root On return, points to Root char number.\r
	276	@param[out] Parent On return, points to Parent char number.\r
	277	@param[out] SegCount On return, points to Segment count.\r
d1102dba	278	\r
3dc8585e JY	279	@return ASL NameString size.\r
	280	**/\r
	281	UINTN\r
	282	AmlGetAslNameStringSize (\r
	283	IN UINT8 *Buffer,\r
	284	OUT UINTN *Root,\r
	285	OUT UINTN *Parent,\r
	286	OUT UINTN *SegCount\r
	287	)\r
	288	{\r
	289	UINTN NameLength;\r
	290	UINTN TotalLength;\r
	291	\r
	292	*Root = 0;\r
	293	*Parent = 0;\r
	294	*SegCount = 0;\r
	295	TotalLength = 0;\r
	296	NameLength = 0;\r
	297	if (*Buffer == AML_ROOT_CHAR) {\r
	298	*Root = 1;\r
	299	Buffer ++;\r
	300	} else if (*Buffer == AML_PARENT_PREFIX_CHAR) {\r
	301	do {\r
	302	Buffer ++;\r
	303	(*Parent) ++;\r
	304	} while (*Buffer == AML_PARENT_PREFIX_CHAR);\r
	305	}\r
	306	\r
	307	//\r
	308	// Now parse name\r
	309	//\r
	310	while (*Buffer != 0) {\r
	311	NameLength = AmlGetAslNameSegLength (Buffer);\r
	312	if ((NameLength == 0) \|\| (NameLength > AML_NAME_SEG_SIZE)) {\r
	313	return 0;\r
	314	}\r
	315	(*SegCount) ++;\r
	316	Buffer += NameLength;\r
	317	if (*Buffer == 0) {\r
	318	break;\r
	319	}\r
	320	Buffer ++;\r
	321	}\r
	322	\r
	323	//\r
	324	// Check SegCoount\r
	325	//\r
	326	if (*SegCount > 0xFF) {\r
	327	return 0;\r
	328	}\r
	329	\r
	330	//\r
	331	// Calculate total length\r
	332	//\r
	333	TotalLength = Root + Parent + (SegCount) AML_NAME_SEG_SIZE;\r
	334	if (*SegCount > 2) {\r
	335	TotalLength += 2;\r
	336	} else if (*SegCount == 2) {\r
	337	TotalLength += 1;\r
	338	}\r
	339	\r
	340	//\r
	341	// Add NULL char\r
	342	//\r
343	TotalLength ++;\r
344	\r
345	return TotalLength;\r
346	}\r
347	\r
348	/**\r
349	Copy mem, and cast all the char in dest to be upper case.\r
350	\r
351	@param[in] DstBuffer Destination buffer.\r
352	@param[in] SrcBuffer Source buffer.\r
353	@param[in] Length Buffer length.\r
354	**/\r
355	VOID\r
356	AmlUpperCaseCopyMem (\r
357	IN UINT8 *DstBuffer,\r
358	IN UINT8 *SrcBuffer,\r
359	IN UINTN Length\r
360	)\r
361	{\r
362	UINTN Index;\r
363	\r
364	for (Index = 0; Index < Length; Index++) {\r
365	if (SrcBuffer[Index] >= 'a' && SrcBuffer[Index] <= 'z') {\r
366	DstBuffer[Index] = (UINT8)(SrcBuffer[Index] - 'a' + 'A');\r
367	} else {\r
368	DstBuffer[Index] = SrcBuffer[Index];\r
369	}\r
370	}\r
371	}\r
372	\r
373	/**\r
374	Return AML name according to ASL name.\r
375	The caller need free the AmlName returned.\r
376	\r
377	@param[in] AslPath ASL name.\r
378	\r
379	@return AmlName\r
380	**/\r
381	UINT8 *\r
382	AmlNameFromAslName (\r
383	IN UINT8 *AslPath\r
384	)\r
385	{\r
386	UINTN Root;\r
387	UINTN Parent;\r
388	UINTN SegCount;\r
389	UINTN TotalLength;\r
390	UINTN NameLength;\r
391	UINT8 *Buffer;\r
392	UINT8 *AmlPath;\r
393	UINT8 *AmlBuffer;\r
394	\r
395	TotalLength = AmlGetAslNameStringSize (AslPath, &Root, &Parent, &SegCount);\r
396	if (TotalLength == 0) {\r
397	return NULL;\r
398	}\r
399	\r
400	AmlPath = AllocatePool (TotalLength);\r
401	ASSERT (AmlPath != NULL);\r
402	\r
403	AmlBuffer = AmlPath;\r
404	Buffer = AslPath;\r
405	\r
406	//\r
407	// Handle Root and Parent\r
408	//\r
409	if (Root == 1) {\r
410	*AmlBuffer = AML_ROOT_CHAR;\r
411	AmlBuffer ++;\r
412	Buffer ++;\r
413	} else if (Parent > 0) {\r
414	SetMem (AmlBuffer, Parent, AML_PARENT_PREFIX_CHAR);\r
415	AmlBuffer += Parent;\r
416	Buffer += Parent;\r
417	}\r
418	\r
419	//\r
420	// Handle SegCount\r
421	//\r
422	if (SegCount > 2) {\r
423	*AmlBuffer = AML_MULTI_NAME_PREFIX;\r
424	AmlBuffer ++;\r
425	*AmlBuffer = (UINT8)SegCount;\r
426	AmlBuffer ++;\r
427	} else if (SegCount == 2) {\r
428	*AmlBuffer = AML_DUAL_NAME_PREFIX;\r
429	AmlBuffer ++;\r
430	}\r
431	\r
432	//\r
433	// Now to name\r
434	//\r
435	while (*Buffer != 0) {\r
436	NameLength = AmlGetAslNameSegLength (Buffer);\r
437	ASSERT ((NameLength != 0) && (NameLength <= AML_NAME_SEG_SIZE));\r
438	AmlUpperCaseCopyMem (AmlBuffer, Buffer, NameLength);\r
439	SetMem (AmlBuffer + NameLength, AML_NAME_SEG_SIZE - NameLength, AML_NAME_CHAR__);\r
440	Buffer += NameLength;\r
441	AmlBuffer += AML_NAME_SEG_SIZE;\r
442	if (*Buffer == 0) {\r
443	break;\r
444	}\r
445	Buffer ++;\r
446	}\r
447	\r
448	//\r
449	// Add NULL\r
450	//\r
451	AmlPath[TotalLength - 1] = 0;\r
452	\r
453	return AmlPath;\r
454	}\r
455	\r
456	/**\r
457	Print AML NameSeg.\r
458	\r
459	@param[in] Buffer AML NameSeg.\r
460	**/\r
461	VOID\r
462	AmlPrintNameSeg (\r
463	IN UINT8 *Buffer\r
464	)\r
465	{\r
466	DEBUG ((EFI_D_ERROR, "%c", Buffer[0]));\r
467	if ((Buffer[1] == '_') && (Buffer[2] == '_') && (Buffer[3] == '_')) {\r
468	return ;\r
469	}\r
470	DEBUG ((EFI_D_ERROR, "%c", Buffer[1]));\r
471	if ((Buffer[2] == '_') && (Buffer[3] == '_')) {\r
472	return ;\r
473	}\r
474	DEBUG ((EFI_D_ERROR, "%c", Buffer[2]));\r
475	if (Buffer[3] == '_') {\r
476	return ;\r
477	}\r
478	DEBUG ((EFI_D_ERROR, "%c", Buffer[3]));\r
479	return ;\r
480	}\r
481	\r
482	/**\r
483	Print AML NameString.\r
484	\r
485	@param[in] Buffer AML NameString.\r
486	**/\r
487	VOID\r
488	AmlPrintNameString (\r
489	IN UINT8 *Buffer\r
490	)\r
491	{\r
492	UINT8 SegCount;\r
493	UINT8 Index;\r
7538d536	494	\r
3dc8585e JY	495	if (*Buffer == AML_ROOT_CHAR) {\r
	496	//\r
	497	// RootChar\r
	498	//\r
	499	Buffer ++;\r
	500	DEBUG ((EFI_D_ERROR, "\\"));\r
	501	} else if (*Buffer == AML_PARENT_PREFIX_CHAR) {\r
	502	//\r
	503	// ParentPrefixChar\r
	504	//\r
	505	do {\r
	506	Buffer ++;\r
	507	DEBUG ((EFI_D_ERROR, "^"));\r
	508	} while (*Buffer == AML_PARENT_PREFIX_CHAR);\r
	509	}\r
	510	\r
	511	if (*Buffer == AML_DUAL_NAME_PREFIX) {\r
	512	//\r
	513	// DualName\r
	514	//\r
	515	Buffer ++;\r
	516	SegCount = 2;\r
	517	} else if (*Buffer == AML_MULTI_NAME_PREFIX) {\r
	518	//\r
	519	// MultiName\r
	520	//\r
	521	Buffer ++;\r
	522	SegCount = *Buffer;\r
	523	Buffer ++;\r
	524	} else if (*Buffer == 0) {\r
	525	//\r
	526	// NULL Name\r
	527	//\r
	528	return ;\r
	529	} else {\r
	530	//\r
	531	// NameSeg\r
	532	//\r
	533	SegCount = 1;\r
	534	}\r
d1102dba	535	\r
3dc8585e JY	536	AmlPrintNameSeg (Buffer);\r
	537	Buffer += AML_NAME_SEG_SIZE;\r
	538	for (Index = 0; Index < SegCount - 1; Index++) {\r
	539	DEBUG ((EFI_D_ERROR, "."));\r
	540	AmlPrintNameSeg (Buffer);\r
	541	Buffer += AML_NAME_SEG_SIZE;\r
	542	}\r
	543	\r
	544	return ;\r
	545	}\r