FspWrapperHobProcessLib.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753
  1. /** @file
  2. Provide FSP wrapper hob process related function.
  3. Copyright (c) 2017 - 2019, Intel Corporation. All rights reserved.<BR>
  4. SPDX-License-Identifier: BSD-2-Clause-Patent
  5. **/
  6. #include <PiPei.h>
  7. #include <Library/PeiServicesLib.h>
  8. #include <Library/PeiServicesTablePointerLib.h>
  9. #include <Library/BaseLib.h>
  10. #include <Library/DebugLib.h>
  11. #include <Library/BaseMemoryLib.h>
  12. #include <Library/HobLib.h>
  13. #include <Library/PcdLib.h>
  14. #include <Library/FspWrapperPlatformLib.h>
  15. #include <Guid/AcpiS3Context.h>
  16. #include <Guid/GuidHobFspEas.h>
  17. #include <Guid/MemoryTypeInformation.h>
  18. #include <Guid/GraphicsInfoHob.h>
  19. #include <Guid/PcdDataBaseHobGuid.h>
  20. #include <Guid/ZeroGuid.h>
  21. #include <Ppi/Capsule.h>
  22. #include <Ppi/ReadOnlyVariable2.h>
  23. #include <FspEas.h>
  24. #include <AcpiS3MemoryNvData.h>
  25. //
  26. // Additional pages are used by DXE memory manager.
  27. // It should be consistent between RetrieveRequiredMemorySize() and GetPeiMemSize()
  28. //
  29. #define PEI_ADDITIONAL_MEMORY_SIZE (16 * EFI_PAGE_SIZE)
  30. /**
  31. Get the mem size in memory type infromation table.
  32. @param[in] PeiServices PEI Services table.
  33. @return the mem size in memory type infromation table.
  34. **/
  35. UINT64
  36. GetMemorySizeInMemoryTypeInformation (
  37. IN EFI_PEI_SERVICES **PeiServices
  38. )
  39. {
  40. EFI_STATUS Status;
  41. EFI_PEI_HOB_POINTERS Hob;
  42. EFI_MEMORY_TYPE_INFORMATION *MemoryData;
  43. UINT8 Index;
  44. UINTN TempPageNum;
  45. MemoryData = NULL;
  46. Status = (*PeiServices)->GetHobList ((CONST EFI_PEI_SERVICES**)PeiServices, (VOID **) &Hob.Raw);
  47. ASSERT_EFI_ERROR (Status);
  48. while (!END_OF_HOB_LIST (Hob)) {
  49. if (Hob.Header->HobType == EFI_HOB_TYPE_GUID_EXTENSION &&
  50. CompareGuid (&Hob.Guid->Name, &gEfiMemoryTypeInformationGuid)) {
  51. MemoryData = (EFI_MEMORY_TYPE_INFORMATION *) (Hob.Raw + sizeof (EFI_HOB_GENERIC_HEADER) + sizeof (EFI_GUID));
  52. break;
  53. }
  54. Hob.Raw = GET_NEXT_HOB (Hob);
  55. }
  56. if (MemoryData == NULL) {
  57. return 0;
  58. }
  59. TempPageNum = 0;
  60. for (Index = 0; MemoryData[Index].Type != EfiMaxMemoryType; Index++) {
  61. //
  62. // Accumulate default memory size requirements
  63. //
  64. TempPageNum += MemoryData[Index].NumberOfPages;
  65. }
  66. return TempPageNum * EFI_PAGE_SIZE;
  67. }
  68. /**
  69. Get the mem size need to be reserved in PEI phase.
  70. @param[in] PeiServices PEI Services table.
  71. @return the mem size need to be reserved in PEI phase.
  72. **/
  73. UINT64
  74. RetrieveRequiredMemorySize (
  75. IN EFI_PEI_SERVICES **PeiServices
  76. )
  77. {
  78. UINT64 Size;
  79. Size = GetMemorySizeInMemoryTypeInformation (PeiServices);
  80. return Size + PEI_ADDITIONAL_MEMORY_SIZE;
  81. }
  82. /**
  83. Get the mem size need to be consumed and reserved in PEI phase.
  84. @param[in] PeiServices PEI Services table.
  85. @param[in] BootMode Current boot mode.
  86. @return the mem size need to be consumed and reserved in PEI phase.
  87. **/
  88. UINT64
  89. GetPeiMemSize (
  90. IN EFI_PEI_SERVICES **PeiServices,
  91. IN UINT32 BootMode
  92. )
  93. {
  94. UINT64 Size;
  95. UINT64 MinSize;
  96. if (BootMode == BOOT_IN_RECOVERY_MODE) {
  97. return PcdGet32 (PcdPeiRecoveryMinMemSize);
  98. }
  99. Size = GetMemorySizeInMemoryTypeInformation (PeiServices);
  100. if (BootMode == BOOT_ON_FLASH_UPDATE) {
  101. //
  102. // Maybe more size when in CapsuleUpdate phase ?
  103. //
  104. MinSize = PcdGet32 (PcdPeiMinMemSize);
  105. } else {
  106. MinSize = PcdGet32 (PcdPeiMinMemSize);
  107. }
  108. return MinSize + Size + PEI_ADDITIONAL_MEMORY_SIZE;
  109. }
  110. /**
  111. Get S3 PEI memory information.
  112. @note At this point, memory is ready, and PeiServices are available to use.
  113. Platform can get some data from SMRAM directly.
  114. @param[out] S3PeiMemSize PEI memory size to be installed in S3 phase.
  115. @param[out] S3PeiMemBase PEI memory base to be installed in S3 phase.
  116. @return If S3 PEI memory information is got successfully.
  117. **/
  118. EFI_STATUS
  119. EFIAPI
  120. GetS3MemoryInfo (
  121. OUT UINT64 *S3PeiMemSize,
  122. OUT EFI_PHYSICAL_ADDRESS *S3PeiMemBase
  123. )
  124. {
  125. EFI_STATUS Status;
  126. EFI_PEI_READ_ONLY_VARIABLE2_PPI *VariablePpi;
  127. UINTN DataSize;
  128. ACPI_S3_MEMORY S3MemoryInfo;
  129. *S3PeiMemBase = 0;
  130. *S3PeiMemSize = 0;
  131. Status = PeiServicesLocatePpi (&gEfiPeiReadOnlyVariable2PpiGuid, 0, NULL, (VOID **) &VariablePpi);
  132. ASSERT_EFI_ERROR (Status);
  133. DataSize = sizeof (S3MemoryInfo);
  134. Status = VariablePpi->GetVariable (
  135. VariablePpi,
  136. ACPI_S3_MEMORY_NV_NAME,
  137. &gEfiAcpiVariableGuid,
  138. NULL,
  139. &DataSize,
  140. &S3MemoryInfo
  141. );
  142. ASSERT_EFI_ERROR (Status);
  143. if (EFI_ERROR (Status)) {
  144. return Status;
  145. }
  146. *S3PeiMemBase = S3MemoryInfo.S3PeiMemBase;
  147. *S3PeiMemSize = S3MemoryInfo.S3PeiMemSize;
  148. return EFI_SUCCESS;
  149. }
  150. /**
  151. Post FSP-M HOB process for Memory Resource Descriptor.
  152. @param[in] FspHobList Pointer to the HOB data structure produced by FSP.
  153. @return If platform process the FSP hob list successfully.
  154. **/
  155. EFI_STATUS
  156. EFIAPI
  157. PostFspmHobProcess (
  158. IN VOID *FspHobList
  159. )
  160. {
  161. EFI_PEI_HOB_POINTERS Hob;
  162. UINT64 PeiMemSize;
  163. EFI_PHYSICAL_ADDRESS PeiMemBase;
  164. EFI_STATUS Status;
  165. EFI_BOOT_MODE BootMode;
  166. EFI_PEI_CAPSULE_PPI *Capsule;
  167. VOID *CapsuleBuffer;
  168. UINTN CapsuleBufferLength;
  169. UINT64 RequiredMemSize;
  170. UINT64 ResourceLength;
  171. EFI_PEI_SERVICES **PeiServices;
  172. PeiServices = (EFI_PEI_SERVICES **)GetPeiServicesTablePointer ();
  173. PeiServicesGetBootMode (&BootMode);
  174. PeiMemBase = 0;
  175. PeiMemSize = 0;
  176. RequiredMemSize = 0;
  177. ResourceLength = 0;
  178. //
  179. // Parse the hob list from fsp
  180. // Report all the resource hob except MMIO and IO resource Hob's
  181. //
  182. if (BootMode != BOOT_ON_S3_RESUME) {
  183. PeiMemSize = GetPeiMemSize (PeiServices, BootMode);
  184. RequiredMemSize = RetrieveRequiredMemorySize (PeiServices);
  185. Hob.Raw = (UINT8 *)(UINTN)FspHobList;
  186. DEBUG((DEBUG_INFO, "FspHobList - 0x%x\n", FspHobList));
  187. //
  188. // Find the largest available system Memory and use it for PeiMemory
  189. //
  190. while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw)) != NULL) {
  191. if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY)
  192. && (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength <= BASE_4GB)
  193. && (Hob.ResourceDescriptor->PhysicalStart >= PeiMemBase)
  194. && (Hob.ResourceDescriptor->ResourceLength >= PeiMemSize)) {
  195. PeiMemBase = Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength - PeiMemSize;
  196. }
  197. Hob.Raw = GET_NEXT_HOB (Hob);
  198. }
  199. }
  200. Hob.Raw = (UINT8 *)(UINTN)FspHobList;
  201. //
  202. // Skip the MMIO and IO reource map from the FSP Hob list
  203. //
  204. while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw)) != NULL) {
  205. if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_IO) || (Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_MEMORY_MAPPED_IO)) {
  206. Hob.Raw = GET_NEXT_HOB (Hob);
  207. continue;
  208. }
  209. ResourceLength = Hob.ResourceDescriptor->ResourceLength;
  210. DEBUG((DEBUG_INFO, "Resource start %lx resource length %lx resource type %d\n",Hob.ResourceDescriptor->PhysicalStart,Hob.ResourceDescriptor->ResourceLength,Hob.ResourceDescriptor->ResourceType));
  211. if (BootMode != BOOT_ON_S3_RESUME) {
  212. //
  213. // If the system memory found in FSP Hob is determined for PeiMemory. Split the Resource descriptor Hob
  214. //
  215. if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY)
  216. && (Hob.ResourceDescriptor->PhysicalStart <= PeiMemBase)
  217. && (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength >= PeiMemBase + PeiMemSize)
  218. && (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength <= BASE_4GB)) {
  219. if ((CompareGuid (&Hob.ResourceDescriptor->Owner, &gZeroGuid))) {
  220. BuildResourceDescriptorHob (
  221. Hob.ResourceDescriptor->ResourceType,
  222. Hob.ResourceDescriptor->ResourceAttribute,
  223. PeiMemBase,
  224. PeiMemSize
  225. );
  226. } else {
  227. BuildResourceDescriptorWithOwnerHob (
  228. Hob.ResourceDescriptor->ResourceType,
  229. Hob.ResourceDescriptor->ResourceAttribute,
  230. PeiMemBase,
  231. PeiMemSize,
  232. &Hob.ResourceDescriptor->Owner
  233. );
  234. }
  235. ResourceLength = (Hob.ResourceDescriptor->ResourceLength) -(PeiMemSize);
  236. }
  237. }
  238. //
  239. // Report the resource hob
  240. //
  241. if ((CompareGuid (&Hob.ResourceDescriptor->Owner, &gZeroGuid))) {
  242. BuildResourceDescriptorHob (
  243. Hob.ResourceDescriptor->ResourceType,
  244. Hob.ResourceDescriptor->ResourceAttribute,
  245. Hob.ResourceDescriptor->PhysicalStart,
  246. ResourceLength
  247. );
  248. } else {
  249. BuildResourceDescriptorWithOwnerHob (
  250. Hob.ResourceDescriptor->ResourceType,
  251. Hob.ResourceDescriptor->ResourceAttribute,
  252. Hob.ResourceDescriptor->PhysicalStart,
  253. ResourceLength,
  254. &Hob.ResourceDescriptor->Owner
  255. );
  256. }
  257. Hob.Raw = GET_NEXT_HOB (Hob);
  258. }
  259. //
  260. // @todo: It is a W/A for SetMemorySpaceAttribute issue in PchSpi and PchReset drivers.
  261. // We need to modify it instead of hard code here. Due to InstallEfiMemory is using hard code to
  262. // describe memory resource, we have to hard code in here. Once InstallEfiMemory is merged, we should
  263. // be able to remove this.
  264. //
  265. BuildResourceDescriptorHob (
  266. EFI_RESOURCE_MEMORY_MAPPED_IO,
  267. EFI_RESOURCE_ATTRIBUTE_PRESENT | EFI_RESOURCE_ATTRIBUTE_INITIALIZED | EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE,
  268. 0xFFA00000,
  269. 0x80000
  270. );
  271. BuildResourceDescriptorHob (
  272. EFI_RESOURCE_MEMORY_MAPPED_IO,
  273. EFI_RESOURCE_ATTRIBUTE_PRESENT | EFI_RESOURCE_ATTRIBUTE_INITIALIZED | EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE,
  274. 0xFE000000,
  275. 0x10000
  276. );
  277. BuildResourceDescriptorHob (
  278. EFI_RESOURCE_MEMORY_MAPPED_IO,
  279. EFI_RESOURCE_ATTRIBUTE_PRESENT | EFI_RESOURCE_ATTRIBUTE_INITIALIZED | EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE,
  280. PcdGet64 (PcdPciExpressBaseAddress),
  281. PcdGet32 (PcdPciExpressRegionLength)
  282. );
  283. BuildResourceDescriptorHob (
  284. EFI_RESOURCE_MEMORY_MAPPED_IO,
  285. EFI_RESOURCE_ATTRIBUTE_PRESENT | EFI_RESOURCE_ATTRIBUTE_INITIALIZED | EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE,
  286. 0xFE010000,
  287. 0x1000
  288. );
  289. if (BootMode != BOOT_ON_S3_RESUME) {
  290. //
  291. // Capsule mode
  292. //
  293. Capsule = NULL;
  294. CapsuleBuffer = NULL;
  295. CapsuleBufferLength = 0;
  296. if (BootMode == BOOT_ON_FLASH_UPDATE) {
  297. Status = PeiServicesLocatePpi (
  298. &gEfiPeiCapsulePpiGuid,
  299. 0,
  300. NULL,
  301. (VOID **) &Capsule
  302. );
  303. ASSERT_EFI_ERROR (Status);
  304. if (Status == EFI_SUCCESS) {
  305. Status = PeiServicesGetHobList ((void**)&Hob.Raw);
  306. ASSERT_EFI_ERROR (Status);
  307. while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw)) != NULL) {
  308. if ((Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY)
  309. && (Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength <= BASE_4GB)
  310. && (Hob.ResourceDescriptor->PhysicalStart >= BASE_1MB)
  311. && (Hob.ResourceDescriptor->PhysicalStart != PeiMemBase)
  312. && (Hob.ResourceDescriptor->ResourceLength >= CapsuleBufferLength)) {
  313. CapsuleBufferLength = (UINTN)Hob.ResourceDescriptor->ResourceLength;
  314. CapsuleBuffer = (VOID*)(UINTN)Hob.ResourceDescriptor->PhysicalStart;
  315. }
  316. Hob.Raw = GET_NEXT_HOB (Hob);
  317. }
  318. //
  319. // Call the Capsule PPI Coalesce function to coalesce the capsule data.
  320. //
  321. Status = Capsule->Coalesce (PeiServices, &CapsuleBuffer, &CapsuleBufferLength);
  322. }
  323. }
  324. DEBUG((DEBUG_INFO, "FSP wrapper PeiMemBase : 0x%08x\n", PeiMemBase));
  325. DEBUG((DEBUG_INFO, "FSP wrapper PeiMemSize : 0x%08x\n", PeiMemSize));
  326. DEBUG((DEBUG_INFO, "FSP wrapper RequiredMemSize : 0x%08x\n", RequiredMemSize));
  327. //
  328. // Install efi memory
  329. //
  330. Status = PeiServicesInstallPeiMemory (
  331. PeiMemBase,
  332. PeiMemSize - RequiredMemSize
  333. );
  334. ASSERT_EFI_ERROR (Status);
  335. if (Capsule != NULL) {
  336. Status = Capsule->CreateState ((EFI_PEI_SERVICES **)PeiServices, CapsuleBuffer, CapsuleBufferLength);
  337. }
  338. } else {
  339. Status = GetS3MemoryInfo (&PeiMemSize, &PeiMemBase);
  340. ASSERT_EFI_ERROR (Status);
  341. DEBUG ((DEBUG_INFO, "S3 resume PeiMemBase : 0x%08x\n", PeiMemBase));
  342. DEBUG ((DEBUG_INFO, "S3 resume PeiMemSize : 0x%08x\n", PeiMemSize));
  343. //
  344. // Install efi memory
  345. //
  346. Status = PeiServicesInstallPeiMemory (
  347. PeiMemBase,
  348. PeiMemSize
  349. );
  350. ASSERT_EFI_ERROR (Status);
  351. }
  352. //
  353. // Create a memory allocation HOB at fixed location for MP Services PPI AP wait loop.
  354. // Report memory region used by FSP.
  355. //
  356. BuildMemoryAllocationHob (
  357. PcdGet32 (PcdFspCpuPeiApWakeupBufferAddr),
  358. EFI_PAGE_SIZE,
  359. EfiBootServicesData
  360. );
  361. return EFI_SUCCESS;
  362. }
  363. /**
  364. Process FSP HOB list
  365. @param[in] FspHobList Pointer to the HOB data structure produced by FSP.
  366. **/
  367. VOID
  368. ProcessFspHobList (
  369. IN VOID *FspHobList
  370. )
  371. {
  372. UINT8 PhysicalAddressBits;
  373. UINT32 RegEax;
  374. EFI_PEI_HOB_POINTERS FspHob;
  375. FspHob.Raw = FspHobList;
  376. AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
  377. if (RegEax >= 0x80000008) {
  378. AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);
  379. PhysicalAddressBits = (UINT8) RegEax;
  380. } else {
  381. PhysicalAddressBits = 36;
  382. }
  383. ///
  384. /// Create a CPU hand-off information
  385. ///
  386. BuildCpuHob (PhysicalAddressBits, 16);
  387. //
  388. // Add all the HOBs from FSP binary to FSP wrapper
  389. //
  390. while (!END_OF_HOB_LIST (FspHob)) {
  391. if (FspHob.Header->HobType == EFI_HOB_TYPE_GUID_EXTENSION) {
  392. //
  393. // Skip FSP binary creates PcdDataBaseHobGuid
  394. //
  395. if (!CompareGuid(&FspHob.Guid->Name, &gPcdDataBaseHobGuid)) {
  396. BuildGuidDataHob (
  397. &FspHob.Guid->Name,
  398. GET_GUID_HOB_DATA(FspHob),
  399. GET_GUID_HOB_DATA_SIZE(FspHob)
  400. );
  401. }
  402. }
  403. FspHob.Raw = GET_NEXT_HOB (FspHob);
  404. }
  405. }
  406. VOID
  407. CheckFspGraphicsDeviceInfoHob (
  408. VOID
  409. )
  410. {
  411. EFI_PEI_HOB_POINTERS Hob;
  412. EFI_STATUS Status;
  413. EFI_PEI_GRAPHICS_INFO_HOB *FspGraphicsInfo = NULL;
  414. EFI_PEI_GRAPHICS_DEVICE_INFO_HOB *FspGraphicsDeviceInfo = NULL;
  415. EFI_PEI_GRAPHICS_DEVICE_INFO_HOB GraphicsDeviceInfo;
  416. Status = PeiServicesGetHobList ((VOID **)&Hob.Raw);
  417. if (!EFI_ERROR (Status)) {
  418. if (Hob.Raw != NULL) {
  419. if ((Hob.Raw = GetNextGuidHob (&gEfiGraphicsInfoHobGuid, Hob.Raw)) != NULL) {
  420. FspGraphicsInfo = GET_GUID_HOB_DATA (Hob.Guid);
  421. }
  422. }
  423. }
  424. if (FspGraphicsInfo == NULL) {
  425. return ;
  426. }
  427. Status = PeiServicesGetHobList ((VOID **)&Hob.Raw);
  428. if (!EFI_ERROR (Status)) {
  429. if (Hob.Raw != NULL) {
  430. if ((Hob.Raw = GetNextGuidHob (&gEfiGraphicsDeviceInfoHobGuid, Hob.Raw)) != NULL) {
  431. FspGraphicsDeviceInfo = GET_GUID_HOB_DATA (Hob.Guid);
  432. }
  433. }
  434. }
  435. if (FspGraphicsDeviceInfo != NULL) {
  436. return ;
  437. }
  438. //
  439. // FSP only publish FspGraphicsInfo, but no FspGraphicsDeviceInfo.
  440. //
  441. // Workaround: Need publish FspGraphicsDeviceInfo, because Intel Graphics BarIndex is 1.
  442. //
  443. GraphicsDeviceInfo.VendorId = MAX_UINT16;
  444. GraphicsDeviceInfo.DeviceId = MAX_UINT16;
  445. GraphicsDeviceInfo.SubsystemVendorId = MAX_UINT16;
  446. GraphicsDeviceInfo.SubsystemId = MAX_UINT16;
  447. GraphicsDeviceInfo.RevisionId = MAX_UINT8;
  448. GraphicsDeviceInfo.BarIndex = 1;
  449. BuildGuidDataHob (
  450. &gEfiGraphicsDeviceInfoHobGuid,
  451. &GraphicsDeviceInfo,
  452. sizeof(GraphicsDeviceInfo)
  453. );
  454. return ;
  455. }
  456. /**
  457. Dump FSP SMBIOS memory info HOB
  458. **/
  459. VOID
  460. DumpFspSmbiosMemoryInfoHob (
  461. VOID
  462. )
  463. {
  464. }
  465. /**
  466. Dump FSP SMBIOS Processor Info HOB
  467. **/
  468. VOID
  469. DumpFspSmbiosProcessorInfoHob (
  470. VOID
  471. )
  472. {
  473. }
  474. /**
  475. Dump FSP SMBIOS Cache Info Hob
  476. **/
  477. VOID
  478. DumpFspSmbiosCacheInfoHob (
  479. VOID
  480. )
  481. {
  482. }
  483. /**
  484. Dump FSP HOB list
  485. **/
  486. VOID
  487. DumpFspHobList (
  488. VOID
  489. )
  490. {
  491. EFI_PEI_HOB_POINTERS Hob;
  492. EFI_STATUS Status;
  493. Status = PeiServicesGetHobList ((VOID **)&Hob.Raw);
  494. ASSERT_EFI_ERROR (Status);
  495. while (!END_OF_HOB_LIST (Hob)) {
  496. if (Hob.Header->HobType == EFI_HOB_TYPE_GUID_EXTENSION) {
  497. DEBUG ((DEBUG_INFO, "FSP Extended GUID HOB: {%g}\n", &(Hob.Guid->Name)));
  498. }
  499. if ((Hob.Header->HobType == EFI_HOB_TYPE_RESOURCE_DESCRIPTOR) &&
  500. (Hob.ResourceDescriptor->ResourceType == EFI_RESOURCE_MEMORY_RESERVED)) {
  501. DEBUG ((DEBUG_INFO, "FSP Reserved Resource HOB: %016lX ~ %016lX\n", \
  502. Hob.ResourceDescriptor->PhysicalStart, Hob.ResourceDescriptor->PhysicalStart \
  503. + Hob.ResourceDescriptor->ResourceLength));
  504. }
  505. Hob.Raw = GET_NEXT_HOB (Hob);
  506. }
  507. }
  508. /**
  509. Dump FSP memory resource
  510. **/
  511. VOID
  512. DumpFspMemoryResource (
  513. VOID
  514. )
  515. {
  516. EFI_PEI_HOB_POINTERS Hob;
  517. EFI_STATUS Status;
  518. Status = PeiServicesGetHobList ((VOID **)&Hob.Raw);
  519. ASSERT_EFI_ERROR (Status);
  520. DEBUG ((DEBUG_INFO, "\nFSP Memory Resource\n"));
  521. DEBUG ((DEBUG_INFO, " Resource Range Type Attribute Owner\n"));
  522. DEBUG ((DEBUG_INFO, "================================= ==== ================ ====================================\n"));
  523. while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, Hob.Raw)) != NULL) {
  524. if (!CompareGuid (&(Hob.ResourceDescriptor->Owner), &gZeroGuid)) {
  525. DEBUG ((DEBUG_INFO, "%016lx-%016lx %4x %016x %g\n",
  526. Hob.ResourceDescriptor->PhysicalStart,
  527. Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength,
  528. Hob.ResourceDescriptor->ResourceType,
  529. Hob.ResourceDescriptor->ResourceAttribute,
  530. &(Hob.ResourceDescriptor->Owner)
  531. ));
  532. } else {
  533. DEBUG ((DEBUG_INFO, "%016lx-%016lx %4x %016x \n",
  534. Hob.ResourceDescriptor->PhysicalStart,
  535. Hob.ResourceDescriptor->PhysicalStart + Hob.ResourceDescriptor->ResourceLength,
  536. Hob.ResourceDescriptor->ResourceType,
  537. Hob.ResourceDescriptor->ResourceAttribute
  538. ));
  539. }
  540. Hob.Raw = GET_NEXT_HOB (Hob);
  541. }
  542. DEBUG ((DEBUG_INFO, "\n"));
  543. }
  544. /**
  545. Dump FSP memory resource
  546. **/
  547. VOID
  548. DumpFspGraphicsInfoHob (
  549. VOID
  550. )
  551. {
  552. EFI_PEI_HOB_POINTERS Hob;
  553. EFI_STATUS Status;
  554. EFI_PEI_GRAPHICS_INFO_HOB *FspGraphicsInfo = NULL;
  555. Status = PeiServicesGetHobList ((VOID **)&Hob.Raw);
  556. if (!EFI_ERROR (Status)) {
  557. if (Hob.Raw != NULL) {
  558. if ((Hob.Raw = GetNextGuidHob (&gEfiGraphicsInfoHobGuid, Hob.Raw)) != NULL) {
  559. FspGraphicsInfo = GET_GUID_HOB_DATA (Hob.Guid);
  560. }
  561. }
  562. if (FspGraphicsInfo != NULL) {
  563. DEBUG((DEBUG_INFO, "\nGraphicsInfo\n"));
  564. DEBUG((DEBUG_INFO, " |-> FrameBufferBase : 0x%016lx\n", FspGraphicsInfo->FrameBufferBase));
  565. DEBUG((DEBUG_INFO, " |-> FrameBufferSize : 0x%016lx\n", FspGraphicsInfo->FrameBufferSize));
  566. DEBUG((DEBUG_INFO, " |-> GraphicsMode\n"));
  567. DEBUG((DEBUG_INFO, " |-> Version : 0x%08x\n", FspGraphicsInfo->GraphicsMode.Version));
  568. DEBUG((DEBUG_INFO, " |-> HorizontalResolution : %d\n", FspGraphicsInfo->GraphicsMode.HorizontalResolution));
  569. DEBUG((DEBUG_INFO, " |-> VerticalResolution : %d\n", FspGraphicsInfo->GraphicsMode.VerticalResolution));
  570. DEBUG((DEBUG_INFO, " |-> PixelFormat : %d\n", FspGraphicsInfo->GraphicsMode.PixelFormat));
  571. DEBUG((DEBUG_INFO, " |-> PixelInformation : %d|%d|%d|%d\n",
  572. FspGraphicsInfo->GraphicsMode.PixelInformation.RedMask,
  573. FspGraphicsInfo->GraphicsMode.PixelInformation.GreenMask,
  574. FspGraphicsInfo->GraphicsMode.PixelInformation.BlueMask,
  575. FspGraphicsInfo->GraphicsMode.PixelInformation.ReservedMask
  576. ));
  577. DEBUG((DEBUG_INFO, " |-> PixelsPerScanLine : %d\n", FspGraphicsInfo->GraphicsMode.PixelsPerScanLine));
  578. DEBUG((DEBUG_INFO, "\n"));
  579. } else {
  580. DEBUG((DEBUG_INFO, "\nNo GraphicsInfo\n"));
  581. }
  582. }
  583. }
  584. VOID
  585. DumpFspGraphicsDeviceInfoHob (
  586. VOID
  587. )
  588. {
  589. EFI_PEI_HOB_POINTERS Hob;
  590. EFI_STATUS Status;
  591. EFI_PEI_GRAPHICS_DEVICE_INFO_HOB *FspGraphicsDeviceInfo = NULL;
  592. Status = PeiServicesGetHobList ((VOID **)&Hob.Raw);
  593. if (!EFI_ERROR (Status)) {
  594. if (Hob.Raw != NULL) {
  595. if ((Hob.Raw = GetNextGuidHob (&gEfiGraphicsDeviceInfoHobGuid, Hob.Raw)) != NULL) {
  596. FspGraphicsDeviceInfo = GET_GUID_HOB_DATA (Hob.Guid);
  597. }
  598. }
  599. if (FspGraphicsDeviceInfo != NULL) {
  600. DEBUG((DEBUG_INFO, "\nGraphicsDeviceInfo\n"));
  601. DEBUG((DEBUG_INFO, " |-> VendorId : 0x%04x\n", FspGraphicsDeviceInfo->VendorId));
  602. DEBUG((DEBUG_INFO, " |-> DeviceId : 0x%04x\n", FspGraphicsDeviceInfo->DeviceId));
  603. DEBUG((DEBUG_INFO, " |-> SubsystemVendorId : 0x%04x\n", FspGraphicsDeviceInfo->SubsystemVendorId));
  604. DEBUG((DEBUG_INFO, " |-> SubsystemId : 0x%04x\n", FspGraphicsDeviceInfo->SubsystemId));
  605. DEBUG((DEBUG_INFO, " |-> RevisionId : 0x%02x\n", FspGraphicsDeviceInfo->RevisionId));
  606. DEBUG((DEBUG_INFO, " |-> BarIndex : 0x%02x\n", FspGraphicsDeviceInfo->BarIndex));
  607. DEBUG((DEBUG_INFO, "\n"));
  608. } else {
  609. DEBUG((DEBUG_INFO, "\nNo GraphicsDeviceInfo\n"));
  610. }
  611. }
  612. }
  613. EFI_PEI_PPI_DESCRIPTOR mSiliconInitializedDesc = {
  614. (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  615. &gEdkiiSiliconInitializedPpiGuid,
  616. NULL
  617. };
  618. /**
  619. Post FSP-S HOB process (not Memory Resource Descriptor).
  620. @param[in] FspHobList Pointer to the HOB data structure produced by FSP.
  621. @return If platform process the FSP hob list successfully.
  622. **/
  623. EFI_STATUS
  624. EFIAPI
  625. PostFspsHobProcess (
  626. IN VOID *FspHobList
  627. )
  628. {
  629. EFI_STATUS Status;
  630. if (PcdGet8 (PcdFspModeSelection) == 1) {
  631. //
  632. // Only in FSP API mode the wrapper has to build hobs basing on FSP output data.
  633. //
  634. ASSERT (FspHobList != NULL);
  635. ProcessFspHobList (FspHobList);
  636. } else {
  637. //
  638. // Only in FSP Dispatch mode, FSP-S should be reported to DXE dispatcher.
  639. //
  640. BuildFvHob (
  641. (EFI_PHYSICAL_ADDRESS) (UINTN) PcdGet32 (PcdFlashFvFspSBase),
  642. PcdGet32 (PcdFlashFvFspSSize)
  643. );
  644. }
  645. CheckFspGraphicsDeviceInfoHob ();
  646. DEBUG_CODE_BEGIN ();
  647. DumpFspSmbiosMemoryInfoHob ();
  648. DumpFspSmbiosProcessorInfoHob();
  649. DumpFspSmbiosCacheInfoHob();
  650. DumpFspGraphicsInfoHob ();
  651. DumpFspGraphicsDeviceInfoHob ();
  652. DumpFspHobList ();
  653. DumpFspMemoryResource ();
  654. DEBUG_CODE_END ();
  655. Status = PeiServicesInstallPpi (&mSiliconInitializedDesc);
  656. ASSERT_EFI_ERROR (Status);
  657. return EFI_SUCCESS;
  658. }