MdeModulePkg/Universal/BdsDxe/MemoryTest.c

   1 /** @file
   2   Perform the platform memory test
   3
   4 Copyright (c) 2004 - 2008, 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 (FeaturePcdGet (PcdUgaConsumeSupport)) {
  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[16];
 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   UINT8                             Value;
 233   UINTN                             DataSize;
 234   UINT32                            Attributes;
 235   UINT32                            TempData;
 236
 237   ReturnStatus = EFI_SUCCESS;
 238   ZeroMem (&Key, sizeof (EFI_INPUT_KEY));
 239
 240   Pos = AllocatePool (128);
 241
 242   if (Pos == NULL) {
 243     return ReturnStatus;
 244   }
 245
 246   StrTotalMemory    = Pos;
 247
 248   TestedMemorySize  = 0;
 249   TotalMemorySize   = 0;
 250   PreviousValue     = 0;
 251   ErrorOut          = FALSE;
 252   TestAbort         = FALSE;
 253
 254   SetMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
 255   SetMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0x0);
 256   SetMem (&Color, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL), 0xff);
 257
 258   RequireSoftECCInit = FALSE;
 259
 260   gST->ConOut->ClearScreen (gST->ConOut);
 261   gST->ConOut->SetAttribute (gST->ConOut, EFI_YELLOW | EFI_BRIGHT);
 262   gST->ConOut->EnableCursor (gST->ConOut, FALSE);
 263
 264   Status = gBS->LocateProtocol (
 265                   &gEfiGenericMemTestProtocolGuid,
 266                   NULL,
 267                   (VOID **) &GenMemoryTest
 268                   );
 269   if (EFI_ERROR (Status)) {
 270     FreePool (Pos);
 271     return EFI_SUCCESS;
 272   }
 273
 274   InitStatus = GenMemoryTest->MemoryTestInit (
 275                                 GenMemoryTest,
 276                                 Level,
 277                                 &RequireSoftECCInit
 278                                 );
 279   if (InitStatus == EFI_NO_MEDIA) {
 280     //
 281     // The PEI codes also have the relevant memory test code to check the memory,
 282     // it can select to test some range of the memory or all of them. If PEI code
 283     // checks all the memory, this BDS memory test will has no not-test memory to
 284     // do the test, and then the status of EFI_NO_MEDIA will be returned by
 285     // "MemoryTestInit". So it does not need to test memory again, just return.
 286     //
 287     FreePool (Pos);
 288     return EFI_SUCCESS;
 289   }
 290
 291   gST->ConOut->SetCursorPosition (gST->ConOut, 0, 2);
 292   TmpStr = GetStringById (STRING_TOKEN (STR_ESC_TO_SKIP_MEM_TEST));
 293
 294   if (TmpStr != NULL) {
 295     gST->ConOut->OutputString (gST->ConOut, TmpStr);
 296     FreePool (TmpStr);
 297   }
 298
 299   do {
 300     Status = GenMemoryTest->PerformMemoryTest (
 301                               GenMemoryTest,
 302                               &TestedMemorySize,
 303                               &TotalMemorySize,
 304                               &ErrorOut,
 305                               TestAbort
 306                               );
 307     if (ErrorOut && (Status == EFI_DEVICE_ERROR)) {
 308       TmpStr = GetStringById (STRING_TOKEN (STR_SYSTEM_MEM_ERROR));
 309       if (TmpStr != NULL) {
 310         PrintXY (10, 10, NULL, NULL, TmpStr);
 311         gST->ConOut->SetCursorPosition (gST->ConOut, 0, 4);
 312         gST->ConOut->OutputString (gST->ConOut, TmpStr);
 313         FreePool (TmpStr);
 314       }
 315
 316       ASSERT (0);
 317     }
 318
 319     TempData = (UINT32) DivU64x32 (TotalMemorySize, 16);
 320     TestPercent = (UINTN) DivU64x32 (
 321                             DivU64x32 (MultU64x32 (TestedMemorySize, 100), 16),
 322                             TempData
 323                             );
 324     if (TestPercent != PreviousValue) {
 325       UnicodeValueToString (StrPercent, 0, TestPercent, 0);
 326       gST->ConOut->SetCursorPosition (gST->ConOut, 0, 0);
 327       TmpStr = GetStringById (STRING_TOKEN (STR_MEMORY_TEST_PERCENT));
 328       if (TmpStr != NULL) {
 329         BdsLibOutputStrings (gST->ConOut, StrPercent, TmpStr, NULL);
 330         FreePool (TmpStr);
 331       }
 332
 333       TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
 334       if (TmpStr != NULL) {
 335         PlatformBdsShowProgress (
 336           Foreground,
 337           Background,
 338           TmpStr,
 339           Color,
 340           TestPercent,
 341           (UINTN) PreviousValue
 342           );
 343         FreePool (TmpStr);
 344       }
 345     }
 346
 347     PreviousValue = TestPercent;
 348
 349     KeyStatus     = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 350     if (!EFI_ERROR (KeyStatus) && (Key.ScanCode == SCAN_ESC)) {
 351       if (!RequireSoftECCInit) {
 352         TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
 353         if (TmpStr != NULL) {
 354           PlatformBdsShowProgress (
 355             Foreground,
 356             Background,
 357             TmpStr,
 358             Color,
 359             100,
 360             (UINTN) PreviousValue
 361             );
 362           FreePool (TmpStr);
 363         }
 364
 365         gST->ConOut->SetCursorPosition (gST->ConOut, 0, 0);
 366         gST->ConOut->OutputString (gST->ConOut, L"100");
 367         Status = GenMemoryTest->Finished (GenMemoryTest);
 368         goto Done;
 369       }
 370
 371       TestAbort = TRUE;
 372     }
 373   } while (Status != EFI_NOT_FOUND);
 374
 375   Status = GenMemoryTest->Finished (GenMemoryTest);
 376
 377 Done:
 378   UnicodeValueToString (StrTotalMemory, COMMA_TYPE, TotalMemorySize, 0);
 379   if (StrTotalMemory[0] == L',') {
 380     StrTotalMemory++;
 381   }
 382
 383   TmpStr = GetStringById (STRING_TOKEN (STR_MEM_TEST_COMPLETED));
 384   if (TmpStr != NULL) {
 385     StrCat (StrTotalMemory, TmpStr);
 386     FreePool (TmpStr);
 387   }
 388
 389   gST->ConOut->ClearScreen (gST->ConOut);
 390   gST->ConOut->SetAttribute (gST->ConOut, EFI_YELLOW | EFI_BRIGHT);
 391   gST->ConOut->EnableCursor (gST->ConOut, FALSE);
 392   gST->ConOut->OutputString (gST->ConOut, StrTotalMemory);
 393   PlatformBdsShowProgress (
 394     Foreground,
 395     Background,
 396     StrTotalMemory,
 397     Color,
 398     100,
 399     (UINTN) PreviousValue
 400     );
 401
 402   FreePool (Pos);
 403
 404   DataSize = sizeof (Value);
 405   Status = gRT->GetVariable (
 406                   L"BootState",
 407                   &gEfiBootStateGuid,
 408                   &Attributes,
 409                   &DataSize,
 410                   &Value
 411                   );
 412
 413   if (EFI_ERROR (Status)) {
 414     Value = 1;
 415     gRT->SetVariable (
 416           L"BootState",
 417           &gEfiBootStateGuid,
 418           EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS,
 419           sizeof (Value),
 420           &Value
 421           );
 422   }
 423
 424   return ReturnStatus;
 425 }