IntelFrameworkModulePkg/Universal/BdsDxe/MemoryTest.c

   1 /** @file
   2   Perform the platform memory test
   3
   4 Copyright (c) 2004 - 2009, Intel Corporation. <BR>
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "Bds.h"
  16 #include "String.h"
  17
  18 //
  19 // BDS Platform Functions
  20 //
  21 /**
  22
  23   Show progress bar with title above it. It only works in Graphics mode.
  24
  25
  26   @param TitleForeground Foreground color for Title.
  27   @param TitleBackground Background color for Title.
  28   @param Title           Title above progress bar.
  29   @param ProgressColor   Progress bar color.
  30   @param Progress        Progress (0-100)
  31   @param PreviousValue   The previous value of the progress.
  32
  33   @retval  EFI_STATUS       Success update the progress bar
  34
  35 **/
  36 EFI_STATUS
  37 PlatformBdsShowProgress (
  38   IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleForeground,
  39   IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL TitleBackground,
  40   IN CHAR16                        *Title,
  41   IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL ProgressColor,
  42   IN UINTN                         Progress,
  43   IN UINTN                         PreviousValue
  44   )
  45 {
  46   EFI_STATUS                     Status;
  47   EFI_GRAPHICS_OUTPUT_PROTOCOL   *GraphicsOutput;
  48   EFI_UGA_DRAW_PROTOCOL          *UgaDraw;
  49   UINT32                         SizeOfX;
  50   UINT32                         SizeOfY;
  51   UINT32                         ColorDepth;
  52   UINT32                         RefreshRate;
  53   EFI_GRAPHICS_OUTPUT_BLT_PIXEL  Color;
  54   UINTN                          BlockHeight;
  55   UINTN                          BlockWidth;
  56   UINTN                          BlockNum;
  57   UINTN                          PosX;
  58   UINTN                          PosY;
  59   UINTN                          Index;
  60
  61   if (Progress > 100) {
  62     return EFI_INVALID_PARAMETER;
  63   }
  64
  65   UgaDraw = NULL;
  66   Status = gBS->HandleProtocol (
  67                   gST->ConsoleOutHandle,
  68                   &gEfiGraphicsOutputProtocolGuid,
  69                   (VOID **) &GraphicsOutput
  70                   );
  71   if (EFI_ERROR (Status) && FeaturePcdGet (PcdUgaConsumeSupport)) {
  72     GraphicsOutput = NULL;
  73
  74     Status = gBS->HandleProtocol (
  75                     gST->ConsoleOutHandle,
  76                     &gEfiUgaDrawProtocolGuid,
  77                     (VOID **) &UgaDraw
  78                     );
  79   }
  80   if (EFI_ERROR (Status)) {
  81     return EFI_UNSUPPORTED;
  82   }
  83
  84   SizeOfX = 0;
  85   SizeOfY = 0;
  86   if (GraphicsOutput != NULL) {
  87     SizeOfX = GraphicsOutput->Mode->Info->HorizontalResolution;
  88     SizeOfY = GraphicsOutput->Mode->Info->VerticalResolution;
  89   } else if (UgaDraw != NULL) {
  90     Status = UgaDraw->GetMode (
  91                         UgaDraw,
  92                         &SizeOfX,
  93                         &SizeOfY,
  94                         &ColorDepth,
  95                         &RefreshRate
  96                         );
  97     if (EFI_ERROR (Status)) {
  98       return EFI_UNSUPPORTED;
  99     }
 100   } else {
 101     return EFI_UNSUPPORTED;
 102   }
 103
 104   BlockWidth  = SizeOfX / 100;
 105   BlockHeight = SizeOfY / 50;
 106
 107   BlockNum    = Progress;
 108
 109   PosX        = 0;
 110   PosY        = SizeOfY * 48 / 50;
 111
 112   if (BlockNum == 0) {
 113     //
 114     // Clear progress area
 115     //
 116     SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
 117
 118     if (GraphicsOutput != NULL) {
 119       Status = GraphicsOutput->Blt (
 120                           GraphicsOutput,
 121                           &Color,
 122                           EfiBltVideoFill,
 123                           0,
 124                           0,
 125                           0,
 126                           PosY - EFI_GLYPH_HEIGHT - 1,
 127                           SizeOfX,
 128                           SizeOfY - (PosY - EFI_GLYPH_HEIGHT - 1),
 129                           SizeOfX * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
 130                           );
 131     } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
 132       Status = UgaDraw->Blt (
 133                           UgaDraw,
 134                           (EFI_UGA_PIXEL *) &Color,
 135                           EfiUgaVideoFill,
 136                           0,
 137                           0,
 138                           0,
 139                           PosY - EFI_GLYPH_HEIGHT - 1,
 140                           SizeOfX,
 141                           SizeOfY - (PosY - EFI_GLYPH_HEIGHT - 1),
 142                           SizeOfX * sizeof (EFI_UGA_PIXEL)
 143                           );
 144     } else {
 145       return EFI_UNSUPPORTED;
 146     }
 147   }
 148   //
 149   // Show progress by drawing blocks
 150   //
 151   for (Index = PreviousValue; Index < BlockNum; Index++) {
 152     PosX = Index * BlockWidth;
 153     if (GraphicsOutput != NULL) {
 154       Status = GraphicsOutput->Blt (
 155                           GraphicsOutput,
 156                           &ProgressColor,
 157                           EfiBltVideoFill,
 158                           0,
 159                           0,
 160                           PosX,
 161                           PosY,
 162                           BlockWidth - 1,
 163                           BlockHeight,
 164                           (BlockWidth) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
 165                           );
 166     } else if (FeaturePcdGet (PcdUgaConsumeSupport)) {
 167       Status = UgaDraw->Blt (
 168                           UgaDraw,
 169                           (EFI_UGA_PIXEL *) &ProgressColor,
 170                           EfiUgaVideoFill,
 171                           0,
 172                           0,
 173                           PosX,
 174                           PosY,
 175                           BlockWidth - 1,
 176                           BlockHeight,
 177                           (BlockWidth) * sizeof (EFI_UGA_PIXEL)
 178                           );
 179     } else {
 180       return EFI_UNSUPPORTED;
 181     }
 182   }
 183
 184   PrintXY (
 185     (SizeOfX - StrLen (Title) * EFI_GLYPH_WIDTH) / 2,
 186     PosY - EFI_GLYPH_HEIGHT - 1,
 187     &TitleForeground,
 188     &TitleBackground,
 189     Title
 190     );
 191
 192   return EFI_SUCCESS;
 193 }
 194
 195 /**
 196   Perform the memory test base on the memory test intensive level,
 197   and update the memory resource.
 198
 199   @param  Level         The memory test intensive level.
 200
 201   @retval EFI_STATUS    Success test all the system memory and update
 202                         the memory resource
 203
 204 **/
 205 EFI_STATUS
 206 BdsMemoryTest (
 207   IN EXTENDMEM_COVERAGE_LEVEL Level
 208   )
 209 {
 210   EFI_STATUS                        Status;
 211   EFI_STATUS                        KeyStatus;
 212   EFI_STATUS                        InitStatus;
 213   EFI_STATUS                        ReturnStatus;
 214   BOOLEAN                           RequireSoftECCInit;
 215   EFI_GENERIC_MEMORY_TEST_PROTOCOL  *GenMemoryTest;
 216   UINT64                            TestedMemorySize;
 217   UINT64                            TotalMemorySize;
 218   UINTN                             TestPercent;
 219   UINT64                            PreviousValue;
 220   BOOLEAN                           ErrorOut;
 221   BOOLEAN                           TestAbort;
 222   EFI_INPUT_KEY                     Key;
 223   CHAR16                            StrPercent[80];
 224   CHAR16                            *StrTotalMemory;
 225   CHAR16                            *Pos;
 226   CHAR16                            *TmpStr;
 227   EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Foreground;
 228   EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Background;
 229   EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Color;
 230   BOOLEAN                           IsFirstBoot;
 231   UINT32                            TempData;
 232
 233   ReturnStatus = EFI_SUCCESS;
 234   ZeroMem (&Key, sizeof (EFI_INPUT_KEY));
 235
 236   Pos = AllocatePool (128);
 237
 238   if (Pos == NULL) {
 239     return ReturnStatus;
 240   }
 241
 242   StrTotalMemory    = Pos;
 243
 244   TestedMemorySize  = 0;
 245   TotalMemorySize   = 0;
 246   PreviousValue     = 0;
 247   ErrorOut          = FALSE;
 248   TestAbort         = FALSE;
 249
 250   SetMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
 251   SetMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
 252   SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
 253
 254   RequireSoftECCInit = FALSE;
 255
 256   Status = gBS->LocateProtocol (
 257                   &gEfiGenericMemTestProtocolGuid,
 258                   NULL,
 259                   (VOID **) &GenMemoryTest
 260                   );
 261   if (EFI_ERROR (Status)) {
 262     FreePool (Pos);
 263     return EFI_SUCCESS;
 264   }
 265
 266   InitStatus = GenMemoryTest->MemoryTestInit (
 267                                 GenMemoryTest,
 268                                 Level,
 269                                 &RequireSoftECCInit
 270                                 );
 271   if (InitStatus == EFI_NO_MEDIA) {
 272     //
 273     // The PEI codes also have the relevant memory test code to check the memory,
 274     // it can select to test some range of the memory or all of them. If PEI code
 275     // checks all the memory, this BDS memory test will has no not-test memory to
 276     // do the test, and then the status of EFI_NO_MEDIA will be returned by
 277     // "MemoryTestInit". So it does not need to test memory again, just return.
 278     //
 279     FreePool (Pos);
 280     return EFI_SUCCESS;
 281   }
 282
 283   TmpStr = GetStringById (STRING_TOKEN (STR_ESC_TO_SKIP_MEM_TEST));
 284
 285   if (TmpStr != NULL) {
 286     PrintXY (10, 10, NULL, NULL, TmpStr);
 287     FreePool (TmpStr);
 288   }
 289
 290   do {
 291     Status = GenMemoryTest->PerformMemoryTest (
 292                               GenMemoryTest,
 293                               &TestedMemorySize,
 294                               &TotalMemorySize,
 295                               &ErrorOut,
 296                               TestAbort
 297                               );
 298     if (ErrorOut && (Status == EFI_DEVICE_ERROR)) {
 299       TmpStr = GetStringById (STRING_TOKEN (STR_SYSTEM_MEM_ERROR));
 300       if (TmpStr != NULL) {
 301         PrintXY (10, 10, NULL, NULL, TmpStr);
 302         FreePool (TmpStr);
 303       }
 304
 305       ASSERT (0);
 306     }
 307
 308     TempData = (UINT32) DivU64x32 (TotalMemorySize, 16);
 309     TestPercent = (UINTN) DivU64x32 (
 310                             DivU64x32 (MultU64x32 (TestedMemorySize, 100), 16),
 311                             TempData
 312                             );
 313     if (TestPercent != PreviousValue) {
 314       UnicodeValueToString (StrPercent, 0, TestPercent, 0);
 315       TmpStr = GetStringById (STRING_TOKEN (STR_MEMORY_TEST_PERCENT));
 316       if (TmpStr != NULL) {
 317         //
 318         // TmpStr size is 64, StrPercent is reserved to 16.
 319         //
 320         StrCat (StrPercent, TmpStr);
 321         PrintXY (10, 10, NULL, NULL, StrPercent);
 322         FreePool (TmpStr);
 323       }
 324
 325       TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
 326       if (TmpStr != NULL) {
 327         PlatformBdsShowProgress (
 328           Foreground,
 329           Background,
 330           TmpStr,
 331           Color,
 332           TestPercent,
 333           (UINTN) PreviousValue
 334           );
 335         FreePool (TmpStr);
 336       }
 337     }
 338
 339     PreviousValue = TestPercent;
 340
 341     KeyStatus     = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 342     if (!EFI_ERROR (KeyStatus) && (Key.ScanCode == SCAN_ESC)) {
 343       if (!RequireSoftECCInit) {
 344         TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
 345         if (TmpStr != NULL) {
 346           PlatformBdsShowProgress (
 347             Foreground,
 348             Background,
 349             TmpStr,
 350             Color,
 351             100,
 352             (UINTN) PreviousValue
 353             );
 354           FreePool (TmpStr);
 355         }
 356
 357         PrintXY (10, 10, NULL, NULL, L"100");
 358         Status = GenMemoryTest->Finished (GenMemoryTest);
 359         goto Done;
 360       }
 361
 362       TestAbort = TRUE;
 363     }
 364   } while (Status != EFI_NOT_FOUND);
 365
 366   Status = GenMemoryTest->Finished (GenMemoryTest);
 367
 368 Done:
 369   UnicodeValueToString (StrTotalMemory, COMMA_TYPE, TotalMemorySize, 0);
 370   if (StrTotalMemory[0] == L',') {
 371     StrTotalMemory++;
 372   }
 373
 374   TmpStr = GetStringById (STRING_TOKEN (STR_MEM_TEST_COMPLETED));
 375   if (TmpStr != NULL) {
 376     StrCat (StrTotalMemory, TmpStr);
 377     FreePool (TmpStr);
 378   }
 379
 380   PrintXY (10, 10, NULL, NULL, StrTotalMemory);
 381   PlatformBdsShowProgress (
 382     Foreground,
 383     Background,
 384     StrTotalMemory,
 385     Color,
 386     100,
 387     (UINTN) PreviousValue
 388     );
 389
 390   FreePool (Pos);
 391
 392   //
 393   // Use a DynamicHii type pcd to save the boot status, which is used to
 394   // control configuration mode, such as FULL/MINIMAL/NO_CHANGES configuration.
 395   //
 396   IsFirstBoot = PcdGetBool(PcdBootState);
 397   if (IsFirstBoot) {
 398     PcdSetBool(PcdBootState, FALSE);
 399   }
 400
 401   return ReturnStatus;
 402 }