EdkModulePkg/Library/EdkGenericPlatformBdsLib/MemoryTest.c

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