]> git.proxmox.com Git - mirror_edk2.git/blob - IntelFrameworkModulePkg/Universal/BdsDxe/MemoryTest.c
854f8952c44bf340a2088e94c3561913e38b425f
[mirror_edk2.git] / IntelFrameworkModulePkg / 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 (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[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 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 gST->ConOut->ClearScreen (gST->ConOut);
259 gST->ConOut->SetAttribute (gST->ConOut, EFI_YELLOW | EFI_BRIGHT);
260 gST->ConOut->EnableCursor (gST->ConOut, FALSE);
261
262 Status = gBS->LocateProtocol (
263 &gEfiGenericMemTestProtocolGuid,
264 NULL,
265 (VOID **) &GenMemoryTest
266 );
267 if (EFI_ERROR (Status)) {
268 FreePool (Pos);
269 return EFI_SUCCESS;
270 }
271
272 InitStatus = GenMemoryTest->MemoryTestInit (
273 GenMemoryTest,
274 Level,
275 &RequireSoftECCInit
276 );
277 if (InitStatus == EFI_NO_MEDIA) {
278 //
279 // The PEI codes also have the relevant memory test code to check the memory,
280 // it can select to test some range of the memory or all of them. If PEI code
281 // checks all the memory, this BDS memory test will has no not-test memory to
282 // do the test, and then the status of EFI_NO_MEDIA will be returned by
283 // "MemoryTestInit". So it does not need to test memory again, just return.
284 //
285 FreePool (Pos);
286 return EFI_SUCCESS;
287 }
288
289 gST->ConOut->SetCursorPosition (gST->ConOut, 0, 2);
290 TmpStr = GetStringById (STRING_TOKEN (STR_ESC_TO_SKIP_MEM_TEST));
291
292 if (TmpStr != NULL) {
293 gST->ConOut->OutputString (gST->ConOut, TmpStr);
294 FreePool (TmpStr);
295 }
296
297 do {
298 Status = GenMemoryTest->PerformMemoryTest (
299 GenMemoryTest,
300 &TestedMemorySize,
301 &TotalMemorySize,
302 &ErrorOut,
303 TestAbort
304 );
305 if (ErrorOut && (Status == EFI_DEVICE_ERROR)) {
306 TmpStr = GetStringById (STRING_TOKEN (STR_SYSTEM_MEM_ERROR));
307 if (TmpStr != NULL) {
308 PrintXY (10, 10, NULL, NULL, TmpStr);
309 gST->ConOut->SetCursorPosition (gST->ConOut, 0, 4);
310 gST->ConOut->OutputString (gST->ConOut, TmpStr);
311 FreePool (TmpStr);
312 }
313
314 ASSERT (0);
315 }
316
317 TempData = (UINT32) DivU64x32 (TotalMemorySize, 16);
318 TestPercent = (UINTN) DivU64x32 (
319 DivU64x32 (MultU64x32 (TestedMemorySize, 100), 16),
320 TempData
321 );
322 if (TestPercent != PreviousValue) {
323 UnicodeValueToString (StrPercent, 0, TestPercent, 0);
324 gST->ConOut->SetCursorPosition (gST->ConOut, 0, 0);
325 TmpStr = GetStringById (STRING_TOKEN (STR_MEMORY_TEST_PERCENT));
326 if (TmpStr != NULL) {
327 BdsLibOutputStrings (gST->ConOut, StrPercent, TmpStr, NULL);
328 FreePool (TmpStr);
329 }
330
331 TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
332 if (TmpStr != NULL) {
333 PlatformBdsShowProgress (
334 Foreground,
335 Background,
336 TmpStr,
337 Color,
338 TestPercent,
339 (UINTN) PreviousValue
340 );
341 FreePool (TmpStr);
342 }
343 }
344
345 PreviousValue = TestPercent;
346
347 KeyStatus = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
348 if (!EFI_ERROR (KeyStatus) && (Key.ScanCode == SCAN_ESC)) {
349 if (!RequireSoftECCInit) {
350 TmpStr = GetStringById (STRING_TOKEN (STR_PERFORM_MEM_TEST));
351 if (TmpStr != NULL) {
352 PlatformBdsShowProgress (
353 Foreground,
354 Background,
355 TmpStr,
356 Color,
357 100,
358 (UINTN) PreviousValue
359 );
360 FreePool (TmpStr);
361 }
362
363 gST->ConOut->SetCursorPosition (gST->ConOut, 0, 0);
364 gST->ConOut->OutputString (gST->ConOut, L"100");
365 Status = GenMemoryTest->Finished (GenMemoryTest);
366 goto Done;
367 }
368
369 TestAbort = TRUE;
370 }
371 } while (Status != EFI_NOT_FOUND);
372
373 Status = GenMemoryTest->Finished (GenMemoryTest);
374
375 Done:
376 UnicodeValueToString (StrTotalMemory, COMMA_TYPE, TotalMemorySize, 0);
377 if (StrTotalMemory[0] == L',') {
378 StrTotalMemory++;
379 }
380
381 TmpStr = GetStringById (STRING_TOKEN (STR_MEM_TEST_COMPLETED));
382 if (TmpStr != NULL) {
383 StrCat (StrTotalMemory, TmpStr);
384 FreePool (TmpStr);
385 }
386
387 gST->ConOut->ClearScreen (gST->ConOut);
388 gST->ConOut->SetAttribute (gST->ConOut, EFI_YELLOW | EFI_BRIGHT);
389 gST->ConOut->EnableCursor (gST->ConOut, FALSE);
390 gST->ConOut->OutputString (gST->ConOut, StrTotalMemory);
391 PlatformBdsShowProgress (
392 Foreground,
393 Background,
394 StrTotalMemory,
395 Color,
396 100,
397 (UINTN) PreviousValue
398 );
399
400 FreePool (Pos);
401
402 //
403 // Use a DynamicHii type pcd to save the boot status, which is used to
404 // control configuration mode, such as FULL/MINIMAL/NO_CHANGES configuration.
405 //
406 IsFirstBoot = PcdGetBool(PcdBootState);
407 if (IsFirstBoot) {
408 PcdSetBool(PcdBootState, FALSE);
409 }
410
411 return ReturnStatus;
412 }