Program SD Cards into 4-bit mode (support for this is required in the spec). This...

[mirror_edk2.git] / PerformancePkg / Dp_App / DpUtilities.c

/** @file\r
  * Utility functions used by the Dp application.\r
  *\r
  * Copyright (c) 2009 - 2010, 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
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/TimerLib.h>\r
#include <Library/PeCoffGetEntryPointLib.h>\r
#include <Library/PrintLib.h>\r
#include <Library/HiiLib.h>\r
#include <Library/PcdLib.h>\r
\r
#include <Protocol/LoadedImage.h>\r
#include <Protocol/Driverbinding.h>\r
\r
#include <Guid/Performance.h>\r
\r
#include "Dp.h"\r
#include "Literals.h"\r
#include "DpInternal.h"\r
\r
/** Calculate an event's duration in timer ticks.\r
  *\r
  * Given the count direction and the event's start and end timer values,\r
  * calculate the duration of the event in timer ticks.  Information for\r
  * the current measurement is pointed to by the parameter.\r
  *\r
  * If the measurement's start time is 1, it indicates that the developer\r
  * is indicating that the measurement began at the release of reset.\r
  * The start time is adjusted to the timer's starting count before performing\r
  * the elapsed time calculation.\r
  *\r
  * The calculated duration, in ticks, is the absolute difference between\r
  * the measurement's ending and starting counts.\r
  *\r
  * @pre  The global TimerInfo structure must have already been initialized\r
  *       before this function is called.\r
  *\r
  * @param[in,out]    Measurement   Pointer to a MEASUREMENT_RECORD structure containing\r
  *                   data for the current measurement.\r
  *\r
  * @return       The 64-bit duration of the event.\r
**/\r
UINT64\r
GetDuration (\r
  IN OUT MEASUREMENT_RECORD   *Measurement\r
  )\r
{\r
  UINT64    Duration;\r
  BOOLEAN   Error;\r
\r
  // PERF_START macros are called with a value of 1 to indicate\r
  // the beginning of time.  So, adjust the start ticker value\r
  // to the real beginning of time.\r
  // Assumes no wraparound.  Even then, there is a very low probability\r
  // of having a valid StartTicker value of 1.\r
  if (Measurement->StartTimeStamp == 1) {\r
    Measurement->StartTimeStamp = TimerInfo.StartCount;\r
  }\r
  if (TimerInfo.CountUp) {\r
    Duration = Measurement->EndTimeStamp - Measurement->StartTimeStamp;\r
    Error = (BOOLEAN)(Duration > Measurement->EndTimeStamp);\r
  }\r
  else {\r
    Duration = Measurement->StartTimeStamp - Measurement->EndTimeStamp;\r
    Error = (BOOLEAN)(Duration > Measurement->StartTimeStamp);\r
  }\r
\r
  if (Error) {\r
    DEBUG ((EFI_D_ERROR, ALit_TimerLibError));\r
    Duration = 0;\r
  }\r
  return Duration;\r
}\r
\r
/** Determine whether the Measurement record is for an EFI Phase.\r
  *\r
  * The Token and Module members of the measurement record are checked.\r
  * Module must be empty and Token must be one of SEC, PEI, DXE, BDS, or SHELL.\r
  *\r
  * @param[in]  Measurement A pointer to the Measurement record to test.\r
  *\r
  * @retval     TRUE        The measurement record is for an EFI Phase.\r
  * @retval     FALSE       The measurement record is NOT for an EFI Phase.\r
**/\r
BOOLEAN\r
IsPhase(\r
  IN MEASUREMENT_RECORD        *Measurement\r
  )\r
{\r
  BOOLEAN   RetVal;\r
\r
  RetVal = (BOOLEAN)( ( *Measurement->Module == '\0')                               &&\r
            ((AsciiStrnCmp (Measurement->Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0)    ||\r
             (AsciiStrnCmp (Measurement->Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0)    ||\r
             (AsciiStrnCmp (Measurement->Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0)    ||\r
             (AsciiStrnCmp (Measurement->Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0))\r
            );\r
  return RetVal;\r
}\r
\r
/** Get the file name portion of the Pdb File Name.\r
  *\r
  * The portion of the Pdb File Name between the last backslash and\r
  * either a following period or the end of the string is converted\r
  * to Unicode and copied into UnicodeBuffer.  The name is truncated,\r
  * if necessary, to ensure that UnicodeBuffer is not overrun.\r
  *\r
  * @param[in]  PdbFileName     Pdb file name.\r
  * @param[out] UnicodeBuffer   The resultant Unicode File Name.\r
  *\r
**/\r
VOID\r
GetShortPdbFileName (\r
  IN  CHAR8     *PdbFileName,\r
  OUT CHAR16    *UnicodeBuffer\r
  )\r
{\r
  UINTN IndexA;     // Current work location within an ASCII string.\r
  UINTN IndexU;     // Current work location within a Unicode string.\r
  UINTN StartIndex;\r
  UINTN EndIndex;\r
\r
  ZeroMem (UnicodeBuffer, DXE_PERFORMANCE_STRING_LENGTH * sizeof (CHAR16));\r
\r
  if (PdbFileName == NULL) {\r
    StrCpy (UnicodeBuffer, L" ");\r
  } else {\r
    StartIndex = 0;\r
    for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++)\r
      ;\r
    for (IndexA = 0; PdbFileName[IndexA] != 0; IndexA++) {\r
      if (PdbFileName[IndexA] == '\\') {\r
        StartIndex = IndexA + 1;\r
      }\r
\r
      if (PdbFileName[IndexA] == '.') {\r
        EndIndex = IndexA;\r
      }\r
    }\r
\r
    IndexU = 0;\r
    for (IndexA = StartIndex; IndexA < EndIndex; IndexA++) {\r
      UnicodeBuffer[IndexU] = (CHAR16) PdbFileName[IndexA];\r
      IndexU++;\r
      if (IndexU >= DXE_PERFORMANCE_STRING_LENGTH) {\r
        UnicodeBuffer[DXE_PERFORMANCE_STRING_LENGTH] = 0;\r
        break;\r
      }\r
    }\r
  }\r
}\r
\r
/** Get a human readable name for an image handle.\r
  *\r
  * @param[in]    Handle\r
  *\r
  * @post   The resulting Unicode name string is stored in the\r
  *         mGaugeString global array.\r
  *\r
**/\r
VOID\r
GetNameFromHandle (\r
  IN EFI_HANDLE   Handle\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  EFI_LOADED_IMAGE_PROTOCOL   *Image;\r
  CHAR8                       *PdbFileName;\r
  EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;\r
  EFI_STRING                  StringPtr;\r
\r
  // Proactively get the error message so it will be ready if needed\r
  StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL);\r
  ASSERT (StringPtr != NULL);\r
\r
  // Get handle name from image protocol\r
  //\r
  Status = gBS->HandleProtocol (\r
                Handle,\r
                &gEfiLoadedImageProtocolGuid,\r
                &Image\r
                );\r
\r
  if (EFI_ERROR (Status)) {\r
    Status = gBS->OpenProtocol (\r
                  Handle,\r
                  &gEfiDriverBindingProtocolGuid,\r
                  (VOID **) &DriverBinding,\r
                  NULL,\r
                  NULL,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
    if (EFI_ERROR (Status)) {\r
      StrCpy (mGaugeString, StringPtr);\r
      return ;\r
    }\r
\r
    // Get handle name from image protocol\r
    //\r
    Status = gBS->HandleProtocol (\r
                  DriverBinding->ImageHandle,\r
                  &gEfiLoadedImageProtocolGuid,\r
                  &Image\r
                  );\r
  }\r
\r
  PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase);\r
\r
  if (PdbFileName != NULL) {\r
    GetShortPdbFileName (PdbFileName, mGaugeString);\r
  } else {\r
    StrCpy (mGaugeString, StringPtr);\r
  }\r
  return ;\r
}\r
\r
/** Calculate the Duration in microseconds.\r
  *\r
  * Duration is multiplied by 1000, instead of Frequency being divided by 1000 or\r
  * multiplying the result by 1000, in order to maintain precision.  Since Duration is\r
  * a 64-bit value, multiplying it by 1000 is unlikely to produce an overflow.\r
  *\r
  * The time is calculated as (Duration * 1000) / Timer_Frequency.\r
  *\r
  * @param[in]  Duration   The event duration in timer ticks.\r
  *\r
  * @return     A 64-bit value which is the Elapsed time in microseconds.\r
**/\r
UINT64\r
DurationInMicroSeconds (\r
  IN UINT64 Duration\r
  )\r
{\r
  UINT64 Temp;\r
\r
  Temp = MultU64x32 (Duration, 1000);\r
  return DivU64x32 (Temp, TimerInfo.Frequency);\r
}\r
\r
/** Formatted Print using a Hii Token to reference the localized format string.\r
  *\r
  * @param[in]  Token   A HII token associated with a localized Unicode string.\r
  *\r
  * @return             The number of characters converted by UnicodeVSPrint().\r
  *\r
**/\r
UINTN\r
PrintToken (\r
  IN UINT16           Token,\r
  ...\r
  )\r
{\r
  VA_LIST           Marker;\r
  EFI_STRING        StringPtr;\r
  UINTN             Return;\r
  UINTN             BufferSize;\r
\r
  StringPtr = HiiGetString (gHiiHandle, Token, NULL);\r
  ASSERT (StringPtr != NULL);\r
\r
  VA_START (Marker, Token);\r
\r
  BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);\r
\r
  if (mPrintTokenBuffer == NULL) {\r
    mPrintTokenBuffer = AllocatePool (BufferSize);\r
    ASSERT (mPrintTokenBuffer != NULL);\r
  }\r
  SetMem( mPrintTokenBuffer, BufferSize, 0);\r
\r
  Return = UnicodeVSPrint (mPrintTokenBuffer, BufferSize, StringPtr, Marker);\r
  if (Return > 0 && gST->ConOut != NULL) {\r
    gST->ConOut->OutputString (gST->ConOut, mPrintTokenBuffer);\r
  }\r
  return Return;\r
}\r
\r
/** Get index of Measurement Record's match in the CumData array.\r
  *\r
  * If the Measurement's Token value matches a Token in one of the CumData\r
  * records, the index of the matching record is returned.  The returned\r
  * index is a signed value so that negative values can indicate that\r
  * the Measurement didn't match any entry in the CumData array.\r
  *\r
  * @param[in]  Measurement A pointer to a Measurement Record to match against the CumData array.\r
  *\r
  * @retval     <0    Token is not in the CumData array.\r
  * @retval     >=0   Return value is the index into CumData where Token is found.\r
**/\r
INTN\r
GetCumulativeItem(\r
  IN MEASUREMENT_RECORD   *Measurement\r
  )\r
{\r
  INTN    Index;\r
\r
  for( Index = 0; Index < (INTN)NumCum; ++Index) {\r
    if (AsciiStrnCmp (Measurement->Token, CumData[Index].Name, PERF_TOKEN_LENGTH) == 0) {\r
      return Index;  // Exit, we found a match\r
    }\r
  }\r
  // If the for loop exits, Token was not found.\r
  return -1;   // Indicate failure\r
}\r