1/** @file
2  Sample to provide FSP hob process related function.
3
4  Copyright (c) 2014 - 2015, 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 <PiPei.h>
16
17#include <Library/PeiServicesLib.h>
18#include <Library/PeiServicesTablePointerLib.h>
19#include <Library/BaseLib.h>
20#include <Library/DebugLib.h>
21#include <Library/BaseMemoryLib.h>
22#include <Library/HobLib.h>
23#include <Library/PcdLib.h>
24#include <Library/FspPlatformInfoLib.h>
25
26#include <Guid/GuidHobFspEas.h>
27#include <Guid/MemoryTypeInformation.h>
28#include <Guid/PcdDataBaseHobGuid.h>
29#include <Ppi/Capsule.h>
30
31//
32// Additional pages are used by DXE memory manager.
33// It should be consistent between RetrieveRequiredMemorySize() and GetPeiMemSize()
34//
35#define PEI_ADDITIONAL_MEMORY_SIZE    (16 * EFI_PAGE_SIZE)
36
37/**
38  Get the mem size in memory type infromation table.
39
40  @param[in] PeiServices  PEI Services table.
41
42  @return the mem size in memory type infromation table.
43**/
44UINT64
45GetMemorySizeInMemoryTypeInformation (
46  IN EFI_PEI_SERVICES **PeiServices
47  )
48{
49  EFI_STATUS                  Status;
50  EFI_PEI_HOB_POINTERS        Hob;
51  EFI_MEMORY_TYPE_INFORMATION *MemoryData;
52  UINT8                       Index;
53  UINTN                       TempPageNum;
54
55  MemoryData = NULL;
56  Status     = (*PeiServices)->GetHobList ((CONST EFI_PEI_SERVICES**)PeiServices, (VOID **) &Hob.Raw);
57  while (!END_OF_HOB_LIST (Hob)) {
58    if (Hob.Header->HobType == EFI_HOB_TYPE_GUID_EXTENSION &&
59      CompareGuid (&Hob.Guid->Name, &gEfiMemoryTypeInformationGuid)) {
60      MemoryData = (EFI_MEMORY_TYPE_INFORMATION *) (Hob.Raw + sizeof (EFI_HOB_GENERIC_HEADER) + sizeof (EFI_GUID));
61      break;
62    }
63
64    Hob.Raw = GET_NEXT_HOB (Hob);
65  }
66
67  if (MemoryData == NULL) {
68    return 0;
69  }
70
71  TempPageNum = 0;
72  for (Index = 0; MemoryData[Index].Type != EfiMaxMemoryType; Index++) {
73    //
74    // Accumulate default memory size requirements
75    //
76    TempPageNum += MemoryData[Index].NumberOfPages;
77  }
78
79  return TempPageNum * EFI_PAGE_SIZE;
80}
81
82/**
83  Get the mem size need to be reserved in PEI phase.
84
85  @param[in] PeiServices  PEI Services table.
86
87  @return the mem size need to be reserved in PEI phase.
88**/
89UINT64
90RetrieveRequiredMemorySize (
91  IN EFI_PEI_SERVICES **PeiServices
92  )
93{
94  UINT64                      Size;
95
96  Size = GetMemorySizeInMemoryTypeInformation (PeiServices);
97  return Size + PEI_ADDITIONAL_MEMORY_SIZE;
98}
99
100/**
101  Get the mem size need to be consumed and reserved in PEI phase.
102
103  @param[in] PeiServices  PEI Services table.
104  @param[in] BootMode     Current boot mode.
105
106  @return the mem size need to be consumed and reserved in PEI phase.
107**/
108UINT64
109GetPeiMemSize (
110  IN EFI_PEI_SERVICES **PeiServices,
111  IN UINT32           BootMode
112  )
113{
114  UINT64                      Size;
115  UINT64                      MinSize;
116
117  if (BootMode == BOOT_IN_RECOVERY_MODE) {
118    return PcdGet32 (PcdPeiRecoveryMinMemSize);
119  }
120
121  Size = GetMemorySizeInMemoryTypeInformation (PeiServices);
122
123  if (BootMode == BOOT_ON_FLASH_UPDATE) {
124    //
125    // Maybe more size when in CapsuleUpdate phase ?
126    //
127    MinSize = PcdGet32 (PcdPeiMinMemSize);
128  } else {
129    MinSize = PcdGet32 (PcdPeiMinMemSize);
130  }
131
132  return MinSize + Size + PEI_ADDITIONAL_MEMORY_SIZE;
133}
134
135/**
136  BIOS process FspBobList for Memory Resource Descriptor.
137
138  @param[in] FspHobList  Pointer to the HOB data structure produced by FSP.
139
140  @return If platform process the FSP hob list successfully.
141**/
142EFI_STATUS
143EFIAPI
144FspHobProcessForMemoryResource (
145  IN VOID                 *FspHobList
146  )
147{
148  EFI_PEI_HOB_POINTERS Hob;
149  UINT64               LowMemorySize;
150  UINT64               FspMemorySize;
151  EFI_PHYSICAL_ADDRESS FspMemoryBase;
152  UINT64               PeiMemSize;
153  EFI_PHYSICAL_ADDRESS PeiMemBase;
154  UINT64               S3PeiMemSize;
155  EFI_PHYSICAL_ADDRESS S3PeiMemBase;
156  BOOLEAN              FoundFspMemHob;
157  EFI_STATUS           Status;
158  EFI_BOOT_MODE        BootMode;
159  EFI_PEI_CAPSULE_PPI  *Capsule;
160  VOID                 *CapsuleBuffer;
161  UINTN                CapsuleBufferLength;
162  UINT64               RequiredMemSize;
163  EFI_PEI_SERVICES     **PeiServices;
164
165  PeiServices = (EFI_PEI_SERVICES **)GetPeiServicesTablePointer ();
166
167  PeiServicesGetBootMode (&BootMode);
168
169  PeiMemBase = 0;
170  LowMemorySize = 0;
171  FspMemorySize = 0;
172  FspMemoryBase = 0;
173  FoundFspMemHob = FALSE;
174
175  //
176  // Parse the hob list from fsp
177  // Report all the resource hob except the memory between 1M and 4G
178  //
179  Hob.Raw = (UINT8 *)(UINTN)FspHobList;
180  DEBUG((DEBUG_INFO, "FspHobList - 0x%x\n", FspHobList));
181
182  while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw)) != NULL) {
183    DEBUG((DEBUG_INFO, "\nResourceType: 0x%x\n", Hob.ResourceDescriptor->ResourceType));
184    if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) ||
185        (Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_MEMORY_RESERVED)) {
186      DEBUG((DEBUG_INFO, "ResourceAttribute: 0x%x\n", Hob.ResourceDescriptor->ResourceAttribute));
187      DEBUG((DEBUG_INFO, "PhysicalStart: 0x%x\n", Hob.ResourceDescriptor->PhysicalStart));
188      DEBUG((DEBUG_INFO, "ResourceLength: 0x%x\n", Hob.ResourceDescriptor->ResourceLength));
189      DEBUG((DEBUG_INFO, "Owner: %g\n\n", &Hob.ResourceDescriptor->Owner));
190    }
191
192    if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY)  // Found the low memory length below 4G
193        && (Hob.ResourceDescriptor->PhysicalStart >= BASE_1MB)
194        && (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength <= BASE_4GB)) {
195        LowMemorySize += Hob.ResourceDescriptor->ResourceLength;
196      Hob.Raw = GET_NEXT_HOB (Hob);
197      continue;
198    }
199
200    if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_MEMORY_RESERVED)  // Found the low memory length below 4G
201        && (Hob.ResourceDescriptor->PhysicalStart >= BASE_1MB)
202        && (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength <= BASE_4GB)
203        && (CompareGuid (&Hob.ResourceDescriptor->Owner, &gFspReservedMemoryResourceHobGuid))) {
204      FoundFspMemHob = TRUE;
205      FspMemoryBase = Hob.ResourceDescriptor->PhysicalStart;
206      FspMemorySize = Hob.ResourceDescriptor->ResourceLength;
207      DEBUG((DEBUG_INFO, "Find fsp mem hob, base 0x%x, len 0x%x\n", FspMemoryBase, FspMemorySize));
208    }
209
210    //
211    // Report the resource hob
212    //
213    BuildResourceDescriptorHob (
214      Hob.ResourceDescriptor->ResourceType,
215      Hob.ResourceDescriptor->ResourceAttribute,
216      Hob.ResourceDescriptor->PhysicalStart,
217      Hob.ResourceDescriptor->ResourceLength
218      );
219
220    Hob.Raw = GET_NEXT_HOB (Hob);
221  }
222
223  if (!FoundFspMemHob) {
224    DEBUG((DEBUG_INFO, "Didn't find the fsp used memory information.\n"));
225    //ASSERT(FALSE);
226  }
227
228  DEBUG((DEBUG_INFO, "LowMemorySize: 0x%x.\n", LowMemorySize));
229  DEBUG((DEBUG_INFO, "FspMemoryBase: 0x%x.\n", FspMemoryBase));
230  DEBUG((DEBUG_INFO, "FspMemorySize: 0x%x.\n", FspMemorySize));
231
232  if (BootMode == BOOT_ON_S3_RESUME) {
233    BuildResourceDescriptorHob (
234      EFI_RESOURCE_SYSTEM_MEMORY,
235      (
236         EFI_RESOURCE_ATTRIBUTE_PRESENT |
237         EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
238         // EFI_RESOURCE_ATTRIBUTE_TESTED |
239         EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
240         EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
241         EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
242         EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE
243      ),
244      BASE_1MB,
245      LowMemorySize
246      );
247
248    S3PeiMemBase = 0;
249    S3PeiMemSize = 0;
250    Status = GetS3MemoryInfo (&S3PeiMemSize, &S3PeiMemBase);
251    ASSERT_EFI_ERROR (Status);
252    DEBUG((DEBUG_INFO, "S3 memory %Xh - %Xh bytes\n", S3PeiMemBase, S3PeiMemSize));
253
254    //
255    // Make sure Stack and PeiMemory are not overlap
256    //
257
258    Status = PeiServicesInstallPeiMemory (
259               S3PeiMemBase,
260               S3PeiMemSize
261               );
262    ASSERT_EFI_ERROR (Status);
263  } else {
264    PeiMemSize = GetPeiMemSize (PeiServices, BootMode);
265    DEBUG((DEBUG_INFO, "PEI memory size = %Xh bytes\n", PeiMemSize));
266
267    //
268    // Capsule mode
269    //
270    Capsule = NULL;
271    CapsuleBuffer = NULL;
272    CapsuleBufferLength = 0;
273    if (BootMode == BOOT_ON_FLASH_UPDATE) {
274      Status = PeiServicesLocatePpi (
275                 &gEfiPeiCapsulePpiGuid,
276                 0,
277                 NULL,
278                 (VOID **) &Capsule
279                 );
280      ASSERT_EFI_ERROR (Status);
281
282      if (Status == EFI_SUCCESS) {
283        //
284        // Make sure Stack and CapsuleBuffer are not overlap
285        //
286        CapsuleBuffer = (VOID *)(UINTN)BASE_1MB;
287        CapsuleBufferLength = (UINTN)(LowMemorySize - PeiMemSize);
288        //
289        // Call the Capsule PPI Coalesce function to coalesce the capsule data.
290        //
291        Status = Capsule->Coalesce (PeiServices, &CapsuleBuffer, &CapsuleBufferLength);
292      }
293    }
294
295    RequiredMemSize = RetrieveRequiredMemorySize (PeiServices);
296    DEBUG((DEBUG_INFO, "Required memory size = %Xh bytes\n", RequiredMemSize));
297
298    //
299    // Report the main memory
300    //
301    BuildResourceDescriptorHob (
302      EFI_RESOURCE_SYSTEM_MEMORY,
303      (
304         EFI_RESOURCE_ATTRIBUTE_PRESENT |
305         EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
306         EFI_RESOURCE_ATTRIBUTE_TESTED |
307         EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
308         EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
309         EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
310         EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE
311      ),
312      BASE_1MB,
313      LowMemorySize
314      );
315
316    //
317    // Make sure Stack and CapsuleBuffer are not overlap
318    //
319
320    //
321    // Install efi memory
322    //
323    PeiMemBase = BASE_1MB + LowMemorySize - PeiMemSize;
324    Status = PeiServicesInstallPeiMemory (
325               PeiMemBase,
326               PeiMemSize - RequiredMemSize
327               );
328    ASSERT_EFI_ERROR (Status);
329
330    if (Capsule != NULL) {
331      Status = Capsule->CreateState (PeiServices, CapsuleBuffer, CapsuleBufferLength);
332    }
333  }
334
335  return EFI_SUCCESS;
336}
337
338/**
339  Process FSP HOB list
340
341  @param[in] FspHobList  Pointer to the HOB data structure produced by FSP.
342
343**/
344VOID
345ProcessFspHobList (
346  IN VOID                 *FspHobList
347  )
348{
349  EFI_PEI_HOB_POINTERS  FspHob;
350
351  FspHob.Raw = FspHobList;
352
353  //
354  // Add all the HOBs from FSP binary to FSP wrapper
355  //
356  while (!END_OF_HOB_LIST (FspHob)) {
357    if (FspHob.Header->HobType == EFI_HOB_TYPE_GUID_EXTENSION) {
358      //
359      // Skip FSP binary creates PcdDataBaseHobGuid
360      //
361      if (!CompareGuid(&FspHob.Guid->Name, &gPcdDataBaseHobGuid)) {
362        BuildGuidDataHob (
363          &FspHob.Guid->Name,
364          GET_GUID_HOB_DATA(FspHob),
365          GET_GUID_HOB_DATA_SIZE(FspHob)
366        );
367      }
368    }
369    FspHob.Raw = GET_NEXT_HOB (FspHob);
370  }
371}
372
373/**
374  BIOS process FspBobList for other data (not Memory Resource Descriptor).
375
376  @param[in] FspHobList  Pointer to the HOB data structure produced by FSP.
377
378  @return If platform process the FSP hob list successfully.
379**/
380EFI_STATUS
381EFIAPI
382FspHobProcessForOtherData (
383  IN VOID                 *FspHobList
384  )
385{
386  ProcessFspHobList (FspHobList);
387
388  return EFI_SUCCESS;
389}
390
391/**
392  BIOS process FspBobList.
393
394  @param[in] FspHobList  Pointer to the HOB data structure produced by FSP.
395
396  @return If platform process the FSP hob list successfully.
397**/
398EFI_STATUS
399EFIAPI
400FspHobProcess (
401  IN VOID                 *FspHobList
402  )
403{
404  EFI_STATUS  Status;
405
406  Status = FspHobProcessForMemoryResource (FspHobList);
407  if (EFI_ERROR (Status)) {
408    return Status;
409  }
410  Status = FspHobProcessForOtherData (FspHobList);
411
412  return Status;
413}
414