IntelFrameworkModulePkg/Universal/BdsDxe/MemoryTest.c

   1 /** @file
   2   Perform the platform memory test
   3
   4 Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
   5 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 EFIAPI
 207 BdsMemoryTest (
 208   IN EXTENDMEM_COVERAGE_LEVEL Level
 209   )
 210 {
 211   EFI_STATUS                        Status;
 212   EFI_STATUS                        KeyStatus;
 213   EFI_STATUS                        InitStatus;
 214   EFI_STATUS                        ReturnStatus;
 215   BOOLEAN                           RequireSoftECCInit;
 216   EFI_GENERIC_MEMORY_TEST_PROTOCOL  *GenMemoryTest;
 217   UINT64                            TestedMemorySize;
 218   UINT64                            TotalMemorySize;
 219   UINTN                             TestPercent;
 220   UINT64                            PreviousValue;
 221   BOOLEAN                           ErrorOut;
 222   BOOLEAN                           TestAbort;
 223   EFI_INPUT_KEY                     Key;
 224   CHAR16                            StrPercent[80];
 225   CHAR16                            *StrTotalMemory;
 226   CHAR16                            *Pos;
 227   CHAR16                            *TmpStr;
 228   EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Foreground;
 229   EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Background;
 230   EFI_GRAPHICS_OUTPUT_BLT_PIXEL     Color;
 231   BOOLEAN                           IsFirstBoot;
 232   UINT32                            TempData;
 233
 234   ReturnStatus = EFI_SUCCESS;
 235   ZeroMem (&Key, sizeof (EFI_INPUT_KEY));
 236
 237   Pos = AllocatePool (128);
 238
 239   if (Pos == NULL) {
 240     return ReturnStatus;
 241   }
 242
 243   StrTotalMemory    = Pos;
 244
 245   TestedMemorySize  = 0;
 246   TotalMemorySize   = 0;
 247   PreviousValue     = 0;
 248   ErrorOut          = FALSE;
 249   TestAbort         = FALSE;
 250
 251   SetMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
 252   SetMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
 253   SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
 254
 255   RequireSoftECCInit = FALSE;
 256
 257   Status = gBS->LocateProtocol (
 258                   &gEfiGenericMemTestProtocolGuid,
 259                   NULL,
 260                   (VOID **) &GenMemoryTest
 261                   );
 262   if (EFI_ERROR (Status)) {
 263     FreePool (Pos);
 264     return EFI_SUCCESS;
 265   }
 266
 267   InitStatus = GenMemoryTest->MemoryTestInit (
 268                                 GenMemoryTest,
 269                                 Level,
 270                                 &RequireSoftECCInit
 271                                 );
 272   if (InitStatus == EFI_NO_MEDIA) {
 273     //
 274     // The PEI codes also have the relevant memory test code to check the memory,
 275     // it can select to test some range of the memory or all of them. If PEI code
 276     // checks all the memory, this BDS memory test will has no not-test memory to
 277     // do the test, and then the status of EFI_NO_MEDIA will be returned by
 278     // "MemoryTestInit". So it does not need to test memory again, just return.
 279     //
 280     FreePool (Pos);
 281     return EFI_SUCCESS;
 282   }
 283
 284   TmpStr = GetStringById (STRING_TOKEN (STR_ESC_TO_SKIP_MEM_TEST));
 285
 286   if (TmpStr != NULL) {
 287     PrintXY (10, 10, NULL, NULL, TmpStr);
 288     FreePool (TmpStr);
 289   }
 290
 291   do {
 292     Status = GenMemoryTest->PerformMemoryTest (
 293                               GenMemoryTest,
 294                               &TestedMemorySize,
 295                               &TotalMemorySize,
 296                               &ErrorOut,
 297                               TestAbort
 298                               );
 299     if (ErrorOut && (Status == EFI_DEVICE_ERROR)) {
 300       TmpStr = GetStringById (STRING_TOKEN (STR_SYSTEM_MEM_ERROR));
 301       if (TmpStr != NULL) {
 302         PrintXY (10, 10, NULL, NULL, TmpStr);
 303         FreePool (TmpStr);
 304       }
 305
 306       ASSERT (0);
 307     }
 308
 309     TempData = (UINT32) DivU64x32 (TotalMemorySize, 16);
 310     TestPercent = (UINTN) DivU64x32 (
 311                             DivU64x32 (MultU64x32 (TestedMemorySize, 100), 16),
 312                             TempData
 313                             );
 314     if (TestPercent != PreviousValue) {
 315       UnicodeValueToString (StrPercent, 0, TestPercent, 0);
 316       TmpStr = GetStringById (STRING_TOKEN (STR_MEMORY_TEST_PERCENT));
 317       if (TmpStr != NULL) {
 318         //
 319         // TmpStr size is 64, StrPercent is reserved to 16.
 320         //
 321         StrCat (StrPercent, TmpStr);
 322         PrintXY (10, 10, NULL, NULL, StrPercent);
 323         FreePool (TmpStr);
 324       }
 325
 326       TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
 327       if (TmpStr != NULL) {
 328         PlatformBdsShowProgress (
 329           Foreground,
 330           Background,
 331           TmpStr,
 332           Color,
 333           TestPercent,
 334           (UINTN) PreviousValue
 335           );
 336         FreePool (TmpStr);
 337       }
 338     }
 339
 340     PreviousValue = TestPercent;
 341
 342     KeyStatus     = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 343     if (!EFI_ERROR (KeyStatus) && (Key.ScanCode == SCAN_ESC)) {
 344       if (!RequireSoftECCInit) {
 345         TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
 346         if (TmpStr != NULL) {
 347           PlatformBdsShowProgress (
 348             Foreground,
 349             Background,
 350             TmpStr,
 351             Color,
 352             100,
 353             (UINTN) PreviousValue
 354             );
 355           FreePool (TmpStr);
 356         }
 357
 358         PrintXY (10, 10, NULL, NULL, L"100");
 359         Status = GenMemoryTest->Finished (GenMemoryTest);
 360         goto Done;
 361       }
 362
 363       TestAbort = TRUE;
 364     }
 365   } while (Status != EFI_NOT_FOUND);
 366
 367   Status = GenMemoryTest->Finished (GenMemoryTest);
 368
 369 Done:
 370   UnicodeValueToString (StrTotalMemory, COMMA_TYPE, TotalMemorySize, 0);
 371   if (StrTotalMemory[0] == L',') {
 372     StrTotalMemory++;
 373   }
 374
 375   TmpStr = GetStringById (STRING_TOKEN (STR_MEM_TEST_COMPLETED));
 376   if (TmpStr != NULL) {
 377     StrCat (StrTotalMemory, TmpStr);
 378     FreePool (TmpStr);
 379   }
 380
 381   PrintXY (10, 10, NULL, NULL, StrTotalMemory);
 382   PlatformBdsShowProgress (
 383     Foreground,
 384     Background,
 385     StrTotalMemory,
 386     Color,
 387     100,
 388     (UINTN) PreviousValue
 389     );
 390
 391   FreePool (Pos);
 392
 393   //
 394   // Use a DynamicHii type pcd to save the boot status, which is used to
 395   // control configuration mode, such as FULL/MINIMAL/NO_CHANGES configuration.
 396   //
 397   IsFirstBoot = PcdGetBool(PcdBootState);
 398   if (IsFirstBoot) {
 399     PcdSetBool(PcdBootState, FALSE);
 400   }
 401
 402   return ReturnStatus;
 403 }