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