AcpiPlatform.c 42 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241
  1. /** @file
  2. Copyright (c) 2004 - 2019, Intel Corporation. All rights reserved.<BR>
  3. SPDX-License-Identifier: BSD-2-Clause-Patent
  4. Module Name:
  5. AcpiPlatform.c
  6. Abstract:
  7. ACPI Platform Driver
  8. **/
  9. #include <PiDxe.h>
  10. #include <Protocol/TcgService.h>
  11. #include <Protocol/FirmwareVolume2.h>
  12. #include "AcpiPlatform.h"
  13. #include "AcpiPlatformHooks.h"
  14. #include "AcpiPlatformHooksLib.h"
  15. #include "Platform.h"
  16. #include <Hpet.h>
  17. #include <Mcfg.h>
  18. #include "Osfr.h"
  19. #include <Guid/GlobalVariable.h>
  20. #include <Guid/SetupVariable.h>
  21. #include <Guid/PlatformInfo.h>
  22. #include <Guid/BoardFeatures.h>
  23. #include <Protocol/AcpiTable.h>
  24. #include <Library/CpuIA32.h>
  25. #include <SetupMode.h>
  26. #include <Guid/AcpiTableStorage.h>
  27. #include <Guid/EfiVpdData.h>
  28. #include <PchAccess.h>
  29. #include <Guid/Vlv2Variable.h>
  30. #include <Guid/PlatformCpuInfo.h>
  31. #include <IndustryStandard/WindowsSmmSecurityMitigationTable.h>
  32. CHAR16 EfiPlatformCpuInfoVariable[] = L"PlatformCpuInfo";
  33. CHAR16 gACPIOSFRModelStringVariableName[] = ACPI_OSFR_MODEL_STRING_VARIABLE_NAME;
  34. CHAR16 gACPIOSFRRefDataBlockVariableName[] = ACPI_OSFR_REF_DATA_BLOCK_VARIABLE_NAME;
  35. CHAR16 gACPIOSFRMfgStringVariableName[] = ACPI_OSFR_MFG_STRING_VARIABLE_NAME;
  36. EFI_GLOBAL_NVS_AREA_PROTOCOL mGlobalNvsArea;
  37. #ifndef __GNUC__
  38. #pragma optimize("", off)
  39. #endif
  40. BOOLEAN mFirstNotify;
  41. EFI_PLATFORM_INFO_HOB *mPlatformInfo;
  42. EFI_GUID mSystemConfigurationGuid = SYSTEM_CONFIGURATION_GUID;
  43. SYSTEM_CONFIGURATION mSystemConfiguration;
  44. SYSTEM_CONFIGURATION mSystemConfig;
  45. UINT8 mSmbusRsvdAddresses[] = PLATFORM_SMBUS_RSVD_ADDRESSES;
  46. UINT8 mNumberSmbusAddress = sizeof( mSmbusRsvdAddresses ) / sizeof( mSmbusRsvdAddresses[0] );
  47. /**
  48. Locate the first instance of a protocol. If the protocol requested is an
  49. FV protocol, then it will return the first FV that contains the ACPI table
  50. storage file.
  51. @param[in] Protocol The protocol to find.
  52. @param[in] Instance Return pointer to the first instance of the protocol.
  53. @param[in] Type The type of protocol to locate.
  54. @retval EFI_SUCCESS The function completed successfully.
  55. @retval EFI_NOT_FOUND The protocol could not be located.
  56. @retval EFI_OUT_OF_RESOURCES There are not enough resources to find the protocol.
  57. **/
  58. EFI_STATUS
  59. LocateSupportProtocol (
  60. IN EFI_GUID *Protocol,
  61. OUT VOID **Instance,
  62. IN UINT32 Type
  63. )
  64. {
  65. EFI_STATUS Status;
  66. EFI_HANDLE *HandleBuffer;
  67. UINTN NumberOfHandles;
  68. EFI_FV_FILETYPE FileType;
  69. UINT32 FvStatus;
  70. EFI_FV_FILE_ATTRIBUTES Attributes;
  71. UINTN Size;
  72. UINTN Index;
  73. FvStatus = 0;
  74. //
  75. // Locate protocol.
  76. //
  77. Status = gBS->LocateHandleBuffer (
  78. ByProtocol,
  79. Protocol,
  80. NULL,
  81. &NumberOfHandles,
  82. &HandleBuffer
  83. );
  84. if (EFI_ERROR (Status)) {
  85. //
  86. // Defined errors at this time are not found and out of resources.
  87. //
  88. return Status;
  89. }
  90. //
  91. // Looking for FV with ACPI storage file.
  92. //
  93. for (Index = 0; Index < NumberOfHandles; Index++) {
  94. //
  95. // Get the protocol on this handle.
  96. // This should not fail because of LocateHandleBuffer.
  97. //
  98. Status = gBS->HandleProtocol (
  99. HandleBuffer[Index],
  100. Protocol,
  101. Instance
  102. );
  103. ASSERT (!EFI_ERROR (Status));
  104. if (!Type) {
  105. //
  106. // Not looking for the FV protocol, so find the first instance of the
  107. // protocol. There should not be any errors because our handle buffer
  108. // should always contain at least one or LocateHandleBuffer would have
  109. // returned not found.
  110. //
  111. break;
  112. }
  113. //
  114. // See if it has the ACPI storage file.
  115. //
  116. Status = ((EFI_FIRMWARE_VOLUME2_PROTOCOL *) (*Instance))->ReadFile (
  117. *Instance,
  118. &gEfiAcpiTableStorageGuid,
  119. NULL,
  120. &Size,
  121. &FileType,
  122. &Attributes,
  123. &FvStatus
  124. );
  125. //
  126. // If we found it, then we are done.
  127. //
  128. if (!EFI_ERROR (Status)) {
  129. break;
  130. }
  131. }
  132. //
  133. // Our exit status is determined by the success of the previous operations.
  134. // If the protocol was found, Instance already points to it.
  135. //
  136. //
  137. // Free any allocated buffers.
  138. //
  139. gBS->FreePool (HandleBuffer);
  140. return Status;
  141. }
  142. /**
  143. This function will update any runtime platform specific information.
  144. This currently includes:
  145. Setting OEM table values, ID, table ID, creator ID and creator revision.
  146. Enabling the proper processor entries in the APIC tables.
  147. @param[in] Table The table to update.
  148. @retval EFI_SUCCESS The function completed successfully.
  149. **/
  150. EFI_STATUS
  151. PlatformUpdateTables (
  152. IN OUT EFI_ACPI_COMMON_HEADER *Table
  153. )
  154. {
  155. EFI_ACPI_DESCRIPTION_HEADER *TableHeader;
  156. UINT8 *CurrPtr;
  157. UINT8 *EndPtr;
  158. ACPI_APIC_STRUCTURE_PTR *ApicPtr;
  159. UINT8 CurrProcessor;
  160. EFI_STATUS Status;
  161. EFI_MP_SERVICES_PROTOCOL *MpService;
  162. UINTN MaximumNumberOfCPUs;
  163. UINTN NumberOfEnabledCPUs;
  164. UINTN BspIndex;
  165. EFI_ACPI_1_0_ASF_DESCRIPTION_TABLE *AsfEntry;
  166. EFI_ACPI_HIGH_PRECISION_EVENT_TIMER_TABLE_HEADER *HpetTbl;
  167. UINT64 OemIdValue;
  168. UINT8 Index;
  169. EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *Facp;
  170. EFI_ACPI_OSFR_TABLE *OsfrTable;
  171. EFI_ACPI_OSFR_OCUR_OBJECT *pOcurObject;
  172. EFI_ACPI_OSFR_OCUR_OBJECT OcurObject = {{0xB46F133D, 0x235F, 0x4634, 0x9F, 0x03, 0xB1, 0xC0, 0x1C, 0x54, 0x78, 0x5B}, 0, 0, 0, 0, 0};
  173. CHAR16 *OcurMfgStringBuffer = NULL;
  174. CHAR16 *OcurModelStringBuffer = NULL;
  175. UINT8 *OcurRefDataBlockBuffer = NULL;
  176. UINTN OcurMfgStringBufferSize;
  177. UINTN OcurModelStringBufferSize;
  178. UINTN OcurRefDataBlockBufferSize;
  179. #if defined (IDCC2_SUPPORTED) && IDCC2_SUPPORTED
  180. EFI_ACPI_ASPT_TABLE *pSpttTable;
  181. #endif
  182. UINT16 NumberOfHpets;
  183. UINT16 HpetCapIdValue;
  184. UINT32 HpetBlockID;
  185. EFI_PROCESSOR_INFORMATION ProcessorInfoBuffer;
  186. UINT8 TempVal;
  187. EFI_ACPI_3_0_IO_APIC_STRUCTURE *IOApicType;
  188. EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *APICTableHeader;
  189. EFI_ACPI_WSMT_TABLE *WsmtTable;
  190. CurrPtr = NULL;
  191. EndPtr = NULL;
  192. ApicPtr = NULL;
  193. CurrProcessor = 0;
  194. if (Table->Signature != EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE) {
  195. TableHeader = (EFI_ACPI_DESCRIPTION_HEADER *) Table;
  196. //
  197. // Update the OEMID.
  198. //
  199. OemIdValue = mPlatformInfo->AcpiOemId;
  200. *(UINT32 *)(TableHeader->OemId) = (UINT32)OemIdValue;
  201. *(UINT16 *)(TableHeader->OemId + 4) = *(UINT16*)(((UINT8 *)&OemIdValue) + 4);
  202. if ((Table->Signature != EFI_ACPI_2_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE)) {
  203. //
  204. // Update the OEM Table ID.
  205. //
  206. TableHeader->OemTableId = mPlatformInfo->AcpiOemTableId;
  207. }
  208. //
  209. // Update the OEM Table ID.
  210. //
  211. TableHeader->OemRevision = EFI_ACPI_OEM_REVISION;
  212. //
  213. // Update the creator ID.
  214. //
  215. TableHeader->CreatorId = EFI_ACPI_CREATOR_ID;
  216. //
  217. // Update the creator revision.
  218. //
  219. TableHeader->CreatorRevision = EFI_ACPI_CREATOR_REVISION;
  220. }
  221. //
  222. // Complete this function.
  223. //
  224. //
  225. // Locate the MP services protocol.
  226. //
  227. //
  228. // Find the MP Protocol. This is an MP platform, so MP protocol must be
  229. // there.
  230. //
  231. Status = gBS->LocateProtocol (
  232. &gEfiMpServiceProtocolGuid,
  233. NULL,
  234. (VOID **) &MpService
  235. );
  236. if (EFI_ERROR (Status)) {
  237. return Status;
  238. }
  239. //
  240. // Determine the number of processors.
  241. //
  242. MpService->GetNumberOfProcessors (
  243. MpService,
  244. &MaximumNumberOfCPUs,
  245. &NumberOfEnabledCPUs
  246. );
  247. ASSERT (MaximumNumberOfCPUs <= MAX_CPU_NUM && NumberOfEnabledCPUs >= 1);
  248. //
  249. // Assign a invalid intial value for update.
  250. //
  251. //
  252. // Update the processors in the APIC table.
  253. //
  254. switch (Table->Signature) {
  255. case EFI_ACPI_1_0_ASF_DESCRIPTION_TABLE_SIGNATURE:
  256. //
  257. // Update the table if ASF is enabled. Otherwise, return error so caller will not install.
  258. //
  259. if (mSystemConfig.Asf == 1) {
  260. return EFI_UNSUPPORTED;
  261. }
  262. AsfEntry = (EFI_ACPI_1_0_ASF_DESCRIPTION_TABLE *) Table;
  263. TempVal = (mNumberSmbusAddress < ASF_ADDR_DEVICE_ARRAY_LENGTH)? mNumberSmbusAddress : ASF_ADDR_DEVICE_ARRAY_LENGTH;
  264. for (Index = 0; Index < TempVal; Index++) {
  265. AsfEntry->AsfAddr.FixedSmbusAddresses[Index] = mSmbusRsvdAddresses[Index];
  266. }
  267. break;
  268. case EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE:
  269. Status = MpService->WhoAmI (
  270. MpService,
  271. &BspIndex
  272. );
  273. //
  274. // PCAT_COMPAT Set to 1 indicate 8259 vectors should be disabled.
  275. //
  276. APICTableHeader = (EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_HEADER *)Table;
  277. APICTableHeader->Flags |= EFI_ACPI_3_0_PCAT_COMPAT;
  278. CurrPtr = (UINT8 *) &((EFI_ACPI_DESCRIPTION_HEADER *) Table)[1];
  279. CurrPtr = CurrPtr + 8;
  280. //
  281. // Size of Local APIC Address & Flag.
  282. //
  283. EndPtr = (UINT8 *) Table;
  284. EndPtr = EndPtr + Table->Length;
  285. while (CurrPtr < EndPtr) {
  286. ApicPtr = (ACPI_APIC_STRUCTURE_PTR *) CurrPtr;
  287. switch (ApicPtr->AcpiApicCommon.Type) {
  288. case EFI_ACPI_3_0_PROCESSOR_LOCAL_APIC:
  289. //
  290. // ESS override
  291. // Fix for Ordering of MADT to be maintained as it is in MADT table.
  292. //
  293. // Update processor enabled or disabled and keep the local APIC
  294. // order in MADT intact.
  295. //
  296. // Sanity check to make sure proc-id is not arbitrary.
  297. //
  298. DEBUG ((EFI_D_ERROR, "ApicPtr->AcpiLocalApic.AcpiProcessorId = %x, MaximumNumberOfCPUs = %x\n", \
  299. ApicPtr->AcpiLocalApic.AcpiProcessorId, MaximumNumberOfCPUs));
  300. if(ApicPtr->AcpiLocalApic.AcpiProcessorId > MaximumNumberOfCPUs) {
  301. ApicPtr->AcpiLocalApic.AcpiProcessorId = (UINT8)MaximumNumberOfCPUs;
  302. }
  303. ApicPtr->AcpiLocalApic.Flags = 0;
  304. for (CurrProcessor = 0; CurrProcessor < MaximumNumberOfCPUs; CurrProcessor++) {
  305. Status = MpService->GetProcessorInfo (
  306. MpService,
  307. CurrProcessor,
  308. &ProcessorInfoBuffer
  309. );
  310. if (Status == EFI_SUCCESS && ProcessorInfoBuffer.ProcessorId == ApicPtr->AcpiLocalApic.ApicId) {
  311. //
  312. // Check to see whether or not a processor (or thread) is enabled.
  313. //
  314. if ((BspIndex == CurrProcessor) || ((ProcessorInfoBuffer.StatusFlag & PROCESSOR_ENABLED_BIT) != 0)) {
  315. //
  316. // Go on and check if Hyper Threading is enabled. If HT not enabled
  317. // hide this thread from OS by not setting the flag to 1. This is the
  318. // software way to disable Hyper Threading. Basically we just hide it
  319. // from the OS.
  320. //
  321. ApicPtr->AcpiLocalApic.Flags = EFI_ACPI_1_0_LOCAL_APIC_ENABLED;
  322. if(ProcessorInfoBuffer.Location.Thread != 0) {
  323. ApicPtr->AcpiLocalApic.Flags = 0;
  324. }
  325. AppendCpuMapTableEntry (&(ApicPtr->AcpiLocalApic));
  326. }
  327. break;
  328. }
  329. }
  330. //
  331. // If no APIC-ID match, the cpu may not be populated.
  332. //
  333. break;
  334. case EFI_ACPI_3_0_IO_APIC:
  335. IOApicType = (EFI_ACPI_3_0_IO_APIC_STRUCTURE *)CurrPtr;
  336. IOApicType->IoApicId = 0x02;
  337. //
  338. // IO APIC entries can be patched here.
  339. //
  340. break;
  341. }
  342. CurrPtr = CurrPtr + ApicPtr->AcpiApicCommon.Length;
  343. }
  344. break;
  345. case EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE:
  346. Facp = (EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE *) Table;
  347. Facp->Flags &= (UINT32)(~(3<<2));
  348. break;
  349. case EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE:
  350. //
  351. // Patch the memory resource.
  352. //
  353. PatchDsdtTable ((EFI_ACPI_DESCRIPTION_HEADER *) Table);
  354. break;
  355. case EFI_ACPI_3_0_SECONDARY_SYSTEM_DESCRIPTION_TABLE_SIGNATURE:
  356. //
  357. // Gv3 support
  358. //
  359. // TBD: Need re-design based on the ValleyTrail platform.
  360. //
  361. break;
  362. case EFI_ACPI_3_0_HIGH_PRECISION_EVENT_TIMER_TABLE_SIGNATURE:
  363. //
  364. // Adjust HPET Table to correct the Base Address.
  365. //
  366. // Enable HPET always as Hpet.asi always indicates that Hpet is enabled.
  367. //
  368. MmioOr8 (R_PCH_PCH_HPET + R_PCH_PCH_HPET_GCFG, B_PCH_PCH_HPET_GCFG_EN);
  369. HpetTbl = (EFI_ACPI_HIGH_PRECISION_EVENT_TIMER_TABLE_HEADER *) Table;
  370. HpetTbl->BaseAddressLower32Bit.Address = HPET_BASE_ADDRESS;
  371. HpetTbl->EventTimerBlockId = *((UINT32*)(UINTN)HPET_BASE_ADDRESS);
  372. HpetCapIdValue = *(UINT16 *)(UINTN)(HPET_BASE_ADDRESS);
  373. NumberOfHpets = HpetCapIdValue & B_PCH_PCH_HPET_GCID_NT; // Bits [8:12] contains the number of Hpets
  374. HpetBlockID = EFI_ACPI_EVENT_TIMER_BLOCK_ID;
  375. if((NumberOfHpets) && (NumberOfHpets & B_PCH_PCH_HPET_GCID_NT)) {
  376. HpetBlockID |= (NumberOfHpets);
  377. }
  378. HpetTbl->EventTimerBlockId = HpetBlockID;
  379. break;
  380. case EFI_ACPI_3_0_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE:
  381. //
  382. // Update MCFG base and end bus number.
  383. //
  384. ((EFI_ACPI_MEMORY_MAPPED_CONFIGURATION_BASE_ADDRESS_TABLE *) Table)->Segment[0].BaseAddress
  385. = mPlatformInfo->PciData.PciExpressBase;
  386. ((EFI_ACPI_MEMORY_MAPPED_CONFIGURATION_BASE_ADDRESS_TABLE *) Table)->Segment[0].EndBusNumber
  387. = (UINT8)RShiftU64 (mPlatformInfo->PciData.PciExpressSize, 20) - 1;
  388. break;
  389. case EFI_ACPI_OSFR_TABLE_SIGNATURE:
  390. //
  391. // Get size of OSFR variable.
  392. //
  393. OcurMfgStringBufferSize = 0;
  394. Status = gRT->GetVariable (
  395. gACPIOSFRMfgStringVariableName,
  396. &gACPIOSFRMfgStringVariableGuid,
  397. NULL,
  398. &OcurMfgStringBufferSize,
  399. NULL
  400. );
  401. if (Status != EFI_BUFFER_TOO_SMALL) {
  402. //
  403. // Variable must not be present on the system.
  404. //
  405. return EFI_UNSUPPORTED;
  406. }
  407. //
  408. // Allocate memory for variable data.
  409. //
  410. OcurMfgStringBuffer = AllocatePool (OcurMfgStringBufferSize);
  411. Status = gRT->GetVariable (
  412. gACPIOSFRMfgStringVariableName,
  413. &gACPIOSFRMfgStringVariableGuid,
  414. NULL,
  415. &OcurMfgStringBufferSize,
  416. OcurMfgStringBuffer
  417. );
  418. if (!EFI_ERROR (Status)) {
  419. OcurModelStringBufferSize = 0;
  420. Status = gRT->GetVariable (
  421. gACPIOSFRModelStringVariableName,
  422. &gACPIOSFRModelStringVariableGuid,
  423. NULL,
  424. &OcurModelStringBufferSize,
  425. NULL
  426. );
  427. if (Status != EFI_BUFFER_TOO_SMALL) {
  428. //
  429. // Variable must not be present on the system.
  430. //
  431. return EFI_UNSUPPORTED;
  432. }
  433. //
  434. // Allocate memory for variable data.
  435. //
  436. OcurModelStringBuffer = AllocatePool (OcurModelStringBufferSize);
  437. Status = gRT->GetVariable (
  438. gACPIOSFRModelStringVariableName,
  439. &gACPIOSFRModelStringVariableGuid,
  440. NULL,
  441. &OcurModelStringBufferSize,
  442. OcurModelStringBuffer
  443. );
  444. if (!EFI_ERROR (Status)) {
  445. OcurRefDataBlockBufferSize = 0;
  446. Status = gRT->GetVariable (
  447. gACPIOSFRRefDataBlockVariableName,
  448. &gACPIOSFRRefDataBlockVariableGuid,
  449. NULL,
  450. &OcurRefDataBlockBufferSize,
  451. NULL
  452. );
  453. if (Status == EFI_BUFFER_TOO_SMALL) {
  454. //
  455. // Allocate memory for variable data.
  456. //
  457. OcurRefDataBlockBuffer = AllocatePool (OcurRefDataBlockBufferSize);
  458. Status = gRT->GetVariable (
  459. gACPIOSFRRefDataBlockVariableName,
  460. &gACPIOSFRRefDataBlockVariableGuid,
  461. NULL,
  462. &OcurRefDataBlockBufferSize,
  463. OcurRefDataBlockBuffer
  464. );
  465. }
  466. OsfrTable = (EFI_ACPI_OSFR_TABLE *) Table;
  467. //
  468. // Currently only one object is defined: OCUR_OSFR_TABLE.
  469. //
  470. OsfrTable->ObjectCount = 1;
  471. //
  472. // Initialize table length to fixed portion of the ACPI OSFR table.
  473. //
  474. OsfrTable->Header.Length = sizeof (EFI_ACPI_OSFR_TABLE_FIXED_PORTION);
  475. *(UINT32 *)((UINTN) OsfrTable + sizeof (EFI_ACPI_OSFR_TABLE_FIXED_PORTION)) = \
  476. (UINT32) (sizeof (EFI_ACPI_OSFR_TABLE_FIXED_PORTION) + sizeof (UINT32));
  477. pOcurObject = (EFI_ACPI_OSFR_OCUR_OBJECT *)((UINTN) OsfrTable + sizeof (EFI_ACPI_OSFR_TABLE_FIXED_PORTION) + \
  478. sizeof (UINT32));
  479. CopyMem (pOcurObject, &OcurObject, sizeof (EFI_ACPI_OSFR_OCUR_OBJECT));
  480. pOcurObject->ManufacturerNameStringOffset = (UINT32)((UINTN) pOcurObject - (UINTN) OsfrTable + \
  481. sizeof (EFI_ACPI_OSFR_OCUR_OBJECT));
  482. pOcurObject->ModelNameStringOffset = (UINT32)((UINTN) pOcurObject - (UINTN) OsfrTable + \
  483. sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + OcurMfgStringBufferSize);
  484. if (OcurRefDataBlockBufferSize > 0) {
  485. pOcurObject->MicrosoftReferenceOffset = (UINT32)((UINTN) pOcurObject - (UINTN) OsfrTable + \
  486. sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + OcurMfgStringBufferSize + OcurModelStringBufferSize);
  487. }
  488. CopyMem ((UINTN *)((UINTN) pOcurObject + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT)), OcurMfgStringBuffer, \
  489. OcurMfgStringBufferSize);
  490. CopyMem ((UINTN *)((UINTN) pOcurObject + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + OcurMfgStringBufferSize), \
  491. OcurModelStringBuffer, OcurModelStringBufferSize);
  492. if (OcurRefDataBlockBufferSize > 0) {
  493. CopyMem ((UINTN *)((UINTN) pOcurObject + sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + OcurMfgStringBufferSize + \
  494. OcurModelStringBufferSize),OcurRefDataBlockBuffer, OcurRefDataBlockBufferSize);
  495. }
  496. OsfrTable->Header.Length += (UINT32)(OcurMfgStringBufferSize + OcurModelStringBufferSize + OcurRefDataBlockBufferSize);
  497. OsfrTable->Header.Length += sizeof (EFI_ACPI_OSFR_OCUR_OBJECT) + sizeof (UINT32);
  498. }
  499. }
  500. gBS->FreePool (OcurMfgStringBuffer);
  501. gBS->FreePool (OcurModelStringBuffer);
  502. gBS->FreePool (OcurRefDataBlockBuffer);
  503. break;
  504. case EFI_ACPI_WINDOWS_SMM_SECURITY_MITIGATION_TABLE_SIGNATURE:
  505. WsmtTable = (EFI_ACPI_WSMT_TABLE *) Table;
  506. //
  507. // Update Microsoft WSMT table Protections flags.
  508. //
  509. WsmtTable->ProtectionFlags = ((WsmtTable->ProtectionFlags) | (EFI_WSMT_PROTECTION_FLAGS_FIXED_COMM_BUFFERS | EFI_WSMT_PROTECTION_FLAGS_COMM_BUFFER_NESTED_PTR_PROTECTION ));
  510. break;
  511. default:
  512. break;
  513. }
  514. //
  515. //
  516. // Update the hardware signature in the FACS structure.
  517. //
  518. //
  519. // Locate the SPCR table and update based on current settings.
  520. // The user may change CR settings via setup or other methods.
  521. // The SPCR table must match.
  522. //
  523. return EFI_SUCCESS;
  524. }
  525. /**
  526. Routine Description:
  527. GC_TODO: Add function description.
  528. Arguments:
  529. Event - GC_TODO: add argument description
  530. Context - GC_TODO: add argument description
  531. Returns:
  532. GC_TODO: add return values
  533. **/
  534. STATIC
  535. VOID
  536. EFIAPI
  537. OnReadyToBoot (
  538. IN EFI_EVENT Event,
  539. IN VOID *Context
  540. )
  541. {
  542. EFI_STATUS Status;
  543. SYSTEM_CONFIGURATION SetupVarBuffer;
  544. UINTN VariableSize;
  545. EFI_PLATFORM_CPU_INFO *PlatformCpuInfoPtr = NULL;
  546. EFI_PLATFORM_CPU_INFO PlatformCpuInfo;
  547. EFI_PEI_HOB_POINTERS GuidHob;
  548. if (mFirstNotify) {
  549. return;
  550. }
  551. mFirstNotify = TRUE;
  552. //
  553. // To avoid compiler warning of "C4701: potentially uninitialized local variable 'PlatformCpuInfo' used".
  554. //
  555. PlatformCpuInfo.CpuVersion.FullCpuId = 0;
  556. //
  557. // Get Platform CPU Info HOB.
  558. //
  559. PlatformCpuInfoPtr = NULL;
  560. ZeroMem (&PlatformCpuInfo, sizeof(EFI_PLATFORM_CPU_INFO));
  561. VariableSize = sizeof(EFI_PLATFORM_CPU_INFO);
  562. Status = gRT->GetVariable(
  563. EfiPlatformCpuInfoVariable,
  564. &gEfiVlv2VariableGuid,
  565. NULL,
  566. &VariableSize,
  567. PlatformCpuInfoPtr
  568. );
  569. if (EFI_ERROR(Status)) {
  570. GuidHob.Raw = GetHobList ();
  571. if (GuidHob.Raw != NULL) {
  572. if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformCpuInfoGuid, GuidHob.Raw)) != NULL) {
  573. PlatformCpuInfoPtr = GET_GUID_HOB_DATA (GuidHob.Guid);
  574. }
  575. }
  576. }
  577. if ((PlatformCpuInfoPtr != NULL)) {
  578. CopyMem(&PlatformCpuInfo, PlatformCpuInfoPtr, sizeof(EFI_PLATFORM_CPU_INFO));
  579. }
  580. //
  581. // Update the ACPI parameter blocks finally.
  582. //
  583. VariableSize = sizeof (SYSTEM_CONFIGURATION);
  584. Status = gRT->GetVariable (
  585. L"Setup",
  586. &mSystemConfigurationGuid,
  587. NULL,
  588. &VariableSize,
  589. &SetupVarBuffer
  590. );
  591. if (EFI_ERROR (Status) || VariableSize != sizeof(SYSTEM_CONFIGURATION)) {
  592. //The setup variable is corrupted
  593. VariableSize = sizeof(SYSTEM_CONFIGURATION);
  594. Status = gRT->GetVariable(
  595. L"SetupRecovery",
  596. &mSystemConfigurationGuid,
  597. NULL,
  598. &VariableSize,
  599. &SetupVarBuffer
  600. );
  601. ASSERT_EFI_ERROR (Status);
  602. }
  603. }
  604. VOID
  605. PR1FSASetting (
  606. IN VOID
  607. )
  608. {
  609. //
  610. // for FSA on PR1.
  611. //
  612. if (mPlatformInfo->BoardId == BOARD_ID_BL_FFRD && mPlatformInfo->BoardRev >= PR1) {
  613. DEBUG((EFI_D_ERROR, "Set FSA status = 1 for FFRD PR1\n"));
  614. mGlobalNvsArea.Area->FsaStatus = mSystemConfiguration.PchFSAOn;
  615. }
  616. if (mPlatformInfo->BoardId == BOARD_ID_BL_FFRD8) {
  617. DEBUG((EFI_D_ERROR, "Set FSA status = 1 for FFRD8\n"));
  618. mGlobalNvsArea.Area->FsaStatus = mSystemConfiguration.PchFSAOn;
  619. }
  620. }
  621. /**
  622. Entry point for Acpi platform driver.
  623. @param[in] ImageHandle A handle for the image that is initializing this driver.
  624. @param[in] SystemTable A pointer to the EFI system table.
  625. @retval EFI_SUCCESS Driver initialized successfully.
  626. @retval EFI_LOAD_ERROR Failed to Initialize or has been loaded.
  627. @retval EFI_OUT_OF_RESOURCES Could not allocate needed resources.
  628. **/
  629. EFI_STATUS
  630. EFIAPI
  631. AcpiPlatformEntryPoint (
  632. IN EFI_HANDLE ImageHandle,
  633. IN EFI_SYSTEM_TABLE *SystemTable
  634. )
  635. {
  636. EFI_STATUS Status;
  637. EFI_STATUS AcpiStatus;
  638. EFI_ACPI_TABLE_PROTOCOL *AcpiTable;
  639. EFI_FIRMWARE_VOLUME2_PROTOCOL *FwVol;
  640. INTN Instance;
  641. EFI_ACPI_COMMON_HEADER *CurrentTable;
  642. UINTN TableHandle;
  643. UINT32 FvStatus;
  644. UINTN Size;
  645. EFI_EVENT Event;
  646. EFI_ACPI_TABLE_VERSION TableVersion;
  647. UINTN VarSize;
  648. UINTN SysCfgSize;
  649. EFI_HANDLE Handle;
  650. EFI_PEI_HOB_POINTERS GuidHob;
  651. EFI_MP_SERVICES_PROTOCOL *MpService;
  652. UINTN MaximumNumberOfCPUs;
  653. UINTN NumberOfEnabledCPUs;
  654. PCH_STEPPING pchStepping;
  655. mFirstNotify = FALSE;
  656. TableVersion = EFI_ACPI_TABLE_VERSION_2_0;
  657. Instance = 0;
  658. CurrentTable = NULL;
  659. TableHandle = 0;
  660. //
  661. // Update HOB variable for PCI resource information.
  662. // Get the HOB list. If it is not present, then ASSERT.
  663. //
  664. GuidHob.Raw = GetHobList ();
  665. if (GuidHob.Raw != NULL) {
  666. if ((GuidHob.Raw = GetNextGuidHob (&gEfiPlatformInfoGuid, GuidHob.Raw)) != NULL) {
  667. mPlatformInfo = GET_GUID_HOB_DATA (GuidHob.Guid);
  668. }
  669. }
  670. //
  671. // Search for the Memory Configuration GUID HOB. If it is not present, then
  672. // there's nothing we can do. It may not exist on the update path.
  673. //
  674. VarSize = sizeof(SYSTEM_CONFIGURATION);
  675. Status = gRT->GetVariable(
  676. L"Setup",
  677. &mSystemConfigurationGuid,
  678. NULL,
  679. &VarSize,
  680. &mSystemConfiguration
  681. );
  682. if (EFI_ERROR (Status) || VarSize != sizeof(SYSTEM_CONFIGURATION)) {
  683. //The setup variable is corrupted
  684. VarSize = sizeof(SYSTEM_CONFIGURATION);
  685. Status = gRT->GetVariable(
  686. L"SetupRecovery",
  687. &mSystemConfigurationGuid,
  688. NULL,
  689. &VarSize,
  690. &mSystemConfiguration
  691. );
  692. ASSERT_EFI_ERROR (Status);
  693. }
  694. //
  695. // Find the AcpiTable protocol.
  696. //
  697. Status = LocateSupportProtocol (&gEfiAcpiTableProtocolGuid, (VOID **) &AcpiTable, 0);
  698. ASSERT_EFI_ERROR (Status);
  699. //
  700. // Locate the firmware volume protocol.
  701. //
  702. Status = LocateSupportProtocol (&gEfiFirmwareVolume2ProtocolGuid, (VOID **) &FwVol, 1);
  703. ASSERT_EFI_ERROR (Status);
  704. //
  705. // Read the current system configuration variable store.
  706. //
  707. SysCfgSize = sizeof(SYSTEM_CONFIGURATION);
  708. Status = gRT->GetVariable (
  709. L"Setup",
  710. &gEfiNormalSetupGuid,
  711. NULL,
  712. &SysCfgSize,
  713. &mSystemConfig
  714. );
  715. if (EFI_ERROR (Status) || SysCfgSize != sizeof(SYSTEM_CONFIGURATION)) {
  716. //The setup variable is corrupted
  717. SysCfgSize = sizeof(SYSTEM_CONFIGURATION);
  718. Status = gRT->GetVariable(
  719. L"SetupRecovery",
  720. &gEfiNormalSetupGuid,
  721. NULL,
  722. &SysCfgSize,
  723. &mSystemConfig
  724. );
  725. ASSERT_EFI_ERROR (Status);
  726. }
  727. Status = EFI_SUCCESS;
  728. Instance = 0;
  729. //
  730. // TBD: Need re-design based on the ValleyTrail platform.
  731. //
  732. Status = gBS->LocateProtocol (
  733. &gEfiMpServiceProtocolGuid,
  734. NULL,
  735. (VOID **) &MpService
  736. );
  737. if (EFI_ERROR (Status)) {
  738. return Status;
  739. }
  740. //
  741. // Determine the number of processors.
  742. //
  743. MpService->GetNumberOfProcessors (
  744. MpService,
  745. &MaximumNumberOfCPUs,
  746. &NumberOfEnabledCPUs
  747. );
  748. //
  749. // Allocate and initialize the NVS area for SMM and ASL communication.
  750. //
  751. Status = gBS->AllocatePool (
  752. EfiACPIMemoryNVS,
  753. sizeof (EFI_GLOBAL_NVS_AREA),
  754. (void **)&mGlobalNvsArea.Area
  755. );
  756. ASSERT_EFI_ERROR (Status);
  757. gBS->SetMem (
  758. mGlobalNvsArea.Area,
  759. sizeof (EFI_GLOBAL_NVS_AREA),
  760. 0
  761. );
  762. DEBUG((EFI_D_ERROR, "mGlobalNvsArea.Area is at 0x%X\n", mGlobalNvsArea.Area));
  763. //
  764. // Update global NVS area for ASL and SMM init code to use.
  765. //
  766. mGlobalNvsArea.Area->ApicEnable = 1;
  767. mGlobalNvsArea.Area->EmaEnable = 0;
  768. mGlobalNvsArea.Area->NumberOfBatteries = 1;
  769. mGlobalNvsArea.Area->BatteryCapacity0 = 100;
  770. mGlobalNvsArea.Area->BatteryStatus0 = 84;
  771. mGlobalNvsArea.Area->OnboardCom = 1;
  772. mGlobalNvsArea.Area->IdeMode = 0;
  773. mGlobalNvsArea.Area->PowerState = 0;
  774. mGlobalNvsArea.Area->LogicalProcessorCount = (UINT8)NumberOfEnabledCPUs;
  775. mGlobalNvsArea.Area->PassiveThermalTripPoint = mSystemConfiguration.PassiveThermalTripPoint;
  776. mGlobalNvsArea.Area->PassiveTc1Value = mSystemConfiguration.PassiveTc1Value;
  777. mGlobalNvsArea.Area->PassiveTc2Value = mSystemConfiguration.PassiveTc2Value;
  778. mGlobalNvsArea.Area->PassiveTspValue = mSystemConfiguration.PassiveTspValue;
  779. mGlobalNvsArea.Area->CriticalThermalTripPoint = mSystemConfiguration.CriticalThermalTripPoint;
  780. mGlobalNvsArea.Area->IgdPanelType = mSystemConfiguration.IgdFlatPanel;
  781. mGlobalNvsArea.Area->IgdPanelScaling = mSystemConfiguration.PanelScaling;
  782. mGlobalNvsArea.Area->IgdSciSmiMode = 0;
  783. mGlobalNvsArea.Area->IgdTvFormat = 0;
  784. mGlobalNvsArea.Area->IgdTvMinor = 0;
  785. mGlobalNvsArea.Area->IgdSscConfig = 1;
  786. mGlobalNvsArea.Area->IgdBiaConfig = mSystemConfiguration.IgdLcdIBia;
  787. mGlobalNvsArea.Area->IgdBlcConfig = mSystemConfiguration.IgdLcdIGmchBlc;
  788. mGlobalNvsArea.Area->IgdDvmtMemSize = mSystemConfiguration.IgdDvmt50TotalAlloc;
  789. mGlobalNvsArea.Area->IgdPAVP = mSystemConfiguration.PavpMode;
  790. mGlobalNvsArea.Area->AlsEnable = mSystemConfiguration.AlsEnable;
  791. mGlobalNvsArea.Area->BacklightControlSupport = 2;
  792. mGlobalNvsArea.Area->BrightnessPercentage = 100;
  793. mGlobalNvsArea.Area->IgdState = 1;
  794. mGlobalNvsArea.Area->LidState = 1;
  795. mGlobalNvsArea.Area->DeviceId1 = 0x80000100 ;
  796. mGlobalNvsArea.Area->DeviceId2 = 0x80000400 ;
  797. mGlobalNvsArea.Area->DeviceId3 = 0x80000200 ;
  798. mGlobalNvsArea.Area->DeviceId4 = 0x04;
  799. mGlobalNvsArea.Area->DeviceId5 = 0x05;
  800. mGlobalNvsArea.Area->NumberOfValidDeviceId = 4 ;
  801. mGlobalNvsArea.Area->CurrentDeviceList = 0x0F ;
  802. mGlobalNvsArea.Area->PreviousDeviceList = 0x0F ;
  803. mGlobalNvsArea.Area->UartSelection = mSystemConfiguration.UartInterface;
  804. mGlobalNvsArea.Area->PcuUart1Enable = mSystemConfiguration.PcuUart1;
  805. mGlobalNvsArea.Area->NativePCIESupport = 1;
  806. mGlobalNvsArea.Area->RtcBattery = mSystemConfiguration.RtcBattery;
  807. //
  808. // Update BootMode: 0:ACPI mode; 1:PCI mode
  809. //
  810. mGlobalNvsArea.Area->LpssSccMode = mSystemConfiguration.LpssPciModeEnabled;
  811. if (mSystemConfiguration.LpssMipiHsi == 0) {
  812. mGlobalNvsArea.Area->MipiHsiAddr = 0;
  813. mGlobalNvsArea.Area->MipiHsiLen = 0;
  814. mGlobalNvsArea.Area->MipiHsi1Addr = 0;
  815. mGlobalNvsArea.Area->MipiHsi1Len = 0;
  816. }
  817. //
  818. // Platform Flavor
  819. //
  820. mGlobalNvsArea.Area->PlatformFlavor = mPlatformInfo->PlatformFlavor;
  821. //
  822. // Update the Platform id
  823. //
  824. mGlobalNvsArea.Area->BoardID = mPlatformInfo->BoardId;
  825. //
  826. // Update the Board Revision
  827. //
  828. mGlobalNvsArea.Area->FabID = mPlatformInfo->BoardRev;
  829. //
  830. // Update SOC Stepping
  831. //
  832. mGlobalNvsArea.Area->SocStepping = (UINT8)(PchStepping());
  833. mGlobalNvsArea.Area->OtgMode = mSystemConfiguration.PchUsbOtg;
  834. pchStepping = PchStepping();
  835. if (mSystemConfiguration.UsbAutoMode == 1) {
  836. //
  837. // Auto mode is enabled.
  838. //
  839. if (PchA0 == pchStepping) {
  840. //
  841. // For A0, EHCI is enabled as default.
  842. //
  843. mSystemConfiguration.PchUsb20 = 1;
  844. mSystemConfiguration.PchUsb30Mode = 0;
  845. mSystemConfiguration.UsbXhciSupport = 0;
  846. DEBUG ((EFI_D_INFO, "EHCI is enabled as default. SOC 0x%x\n", pchStepping));
  847. } else {
  848. //
  849. // For A1 and later, XHCI is enabled as default.
  850. //
  851. mSystemConfiguration.PchUsb20 = 0;
  852. mSystemConfiguration.PchUsb30Mode = 1;
  853. mSystemConfiguration.UsbXhciSupport = 1;
  854. DEBUG ((EFI_D_INFO, "XHCI is enabled as default. SOC 0x%x\n", pchStepping));
  855. }
  856. }
  857. mGlobalNvsArea.Area->XhciMode = mSystemConfiguration.PchUsb30Mode;
  858. mGlobalNvsArea.Area->Stepping = mPlatformInfo->IchRevision;
  859. //
  860. // Override invalid Pre-Boot Driver and XhciMode combination.
  861. //
  862. if ((mSystemConfiguration.UsbXhciSupport == 0) && (mSystemConfiguration.PchUsb30Mode == 3)) {
  863. mGlobalNvsArea.Area->XhciMode = 2;
  864. }
  865. if ((mSystemConfiguration.UsbXhciSupport == 1) && (mSystemConfiguration.PchUsb30Mode == 2)) {
  866. mGlobalNvsArea.Area->XhciMode = 3;
  867. }
  868. DEBUG ((EFI_D_ERROR, "ACPI NVS XHCI:0x%x\n", mGlobalNvsArea.Area->XhciMode));
  869. mGlobalNvsArea.Area->PmicEnable = GLOBAL_NVS_DEVICE_DISABLE;
  870. mGlobalNvsArea.Area->BatteryChargingSolution = GLOBAL_NVS_DEVICE_DISABLE;
  871. mGlobalNvsArea.Area->ISPDevSel = mSystemConfiguration.ISPDevSel;
  872. mGlobalNvsArea.Area->LpeEnable = mSystemConfiguration.Lpe;
  873. mGlobalNvsArea.Area->LpeAudioReportedByDSDT = mSystemConfiguration.LpeAudioReportedByDSDT;
  874. if (mSystemConfiguration.ISPEn == 0) {
  875. mGlobalNvsArea.Area->ISPDevSel = GLOBAL_NVS_DEVICE_DISABLE;
  876. }
  877. mGlobalNvsArea.Area->WittEnable = mSystemConfiguration.WittEnable;
  878. mGlobalNvsArea.Area->UtsEnable = mSystemConfiguration.UtsEnable;
  879. mGlobalNvsArea.Area->SarEnable = mSystemConfiguration.SAR1;
  880. mGlobalNvsArea.Area->ReservedO = 1;
  881. SettingI2CTouchAddress();
  882. mGlobalNvsArea.Area->IdleReserve= mSystemConfiguration.IdleReserve;
  883. //
  884. // Read BMBOUND and store it in GlobalNVS to pass into ASL.
  885. //
  886. // BUGBUG: code was moved into silicon reference code.
  887. //
  888. if (mSystemConfiguration.eMMCBootMode== 1) {
  889. //
  890. // Auto detect mode.
  891. //
  892. DEBUG ((EFI_D_ERROR, "Auto detect mode------------start\n"));
  893. //
  894. // Silicon Steppings.
  895. //
  896. switch (PchStepping()) {
  897. case PchA0: // A0/A1
  898. case PchA1:
  899. DEBUG ((EFI_D_ERROR, "SOC A0/A1: eMMC 4.41 Configuration\n"));
  900. mSystemConfiguration.LpsseMMCEnabled = 1;
  901. mSystemConfiguration.LpsseMMC45Enabled = 0;
  902. break;
  903. case PchB0: // B0 and later.
  904. default:
  905. DEBUG ((EFI_D_ERROR, "SOC B0 and later: eMMC 4.5 Configuration\n"));
  906. mSystemConfiguration.LpsseMMCEnabled = 0;
  907. mSystemConfiguration.LpsseMMC45Enabled = 1;
  908. break;
  909. }
  910. } else if (mSystemConfiguration.eMMCBootMode == 2) {
  911. //
  912. // eMMC 4.41
  913. //
  914. DEBUG ((EFI_D_ERROR, "Force to eMMC 4.41 Configuration\n"));
  915. mSystemConfiguration.LpsseMMCEnabled = 1;
  916. mSystemConfiguration.LpsseMMC45Enabled = 0;
  917. } else if (mSystemConfiguration.eMMCBootMode == 3) {
  918. //
  919. // eMMC 4.5
  920. //
  921. DEBUG ((EFI_D_ERROR, "Force to eMMC 4.5 Configuration\n"));
  922. mSystemConfiguration.LpsseMMCEnabled = 0;
  923. mSystemConfiguration.LpsseMMC45Enabled = 1;
  924. } else {
  925. //
  926. // Disable eMMC controllers.
  927. //
  928. DEBUG ((EFI_D_ERROR, "Disable eMMC controllers\n"));
  929. mSystemConfiguration.LpsseMMCEnabled = 0;
  930. mSystemConfiguration.LpsseMMC45Enabled = 0;
  931. }
  932. mGlobalNvsArea.Area->emmcVersion = 0;
  933. if (mSystemConfiguration.LpsseMMCEnabled) {
  934. DEBUG ((EFI_D_ERROR, "mGlobalNvsArea.Area->emmcVersion = 0\n"));
  935. mGlobalNvsArea.Area->emmcVersion = 0;
  936. }
  937. if (mSystemConfiguration.LpsseMMC45Enabled) {
  938. DEBUG ((EFI_D_ERROR, "mGlobalNvsArea.Area->emmcVersion = 1\n"));
  939. mGlobalNvsArea.Area->emmcVersion = 1;
  940. }
  941. mGlobalNvsArea.Area->SdCardRemovable = mSystemConfiguration.SdCardRemovable;
  942. //
  943. // Microsoft IOT
  944. //
  945. if ((mSystemConfiguration.LpssHsuart0FlowControlEnabled == 1) && \
  946. (mSystemConfiguration.LpssPwm0Enabled == 0) && \
  947. (mSystemConfiguration.LpssPwm1Enabled == 0)) {
  948. mGlobalNvsArea.Area->MicrosoftIoT = GLOBAL_NVS_DEVICE_ENABLE;
  949. DEBUG ((EFI_D_ERROR, "JP1 is set to be MSFT IOT configuration.\n"));
  950. } else {
  951. mGlobalNvsArea.Area->MicrosoftIoT = GLOBAL_NVS_DEVICE_DISABLE;
  952. DEBUG ((EFI_D_ERROR, "JP1 is not set to be MSFT IOT configuration.\n"));
  953. }
  954. //
  955. // SIO related option.
  956. //
  957. mGlobalNvsArea.Area->WPCN381U = GLOBAL_NVS_DEVICE_DISABLE;
  958. mGlobalNvsArea.Area->DockedSioPresent = GLOBAL_NVS_DEVICE_DISABLE;
  959. mGlobalNvsArea.Area->SDIOMode = mSystemConfiguration.LpssSdioMode;
  960. Handle = NULL;
  961. Status = gBS->InstallMultipleProtocolInterfaces (
  962. &Handle,
  963. &gEfiGlobalNvsAreaProtocolGuid,
  964. &mGlobalNvsArea,
  965. NULL
  966. );
  967. //
  968. // Read tables from the storage file.
  969. //
  970. while (!EFI_ERROR (Status)) {
  971. CurrentTable = NULL;
  972. Status = FwVol->ReadSection (
  973. FwVol,
  974. &gEfiAcpiTableStorageGuid,
  975. EFI_SECTION_RAW,
  976. Instance,
  977. (VOID **) &CurrentTable,
  978. &Size,
  979. &FvStatus
  980. );
  981. if (!EFI_ERROR (Status)) {
  982. //
  983. // Allow platform specific code to reject the table or update it.
  984. //
  985. AcpiStatus = AcpiPlatformHooksIsActiveTable (CurrentTable);
  986. if (!EFI_ERROR (AcpiStatus)) {
  987. //
  988. // Perform any table specific updates.
  989. //
  990. AcpiStatus = PlatformUpdateTables (CurrentTable);
  991. if (!EFI_ERROR (AcpiStatus)) {
  992. //
  993. // Add the table.
  994. //
  995. TableHandle = 0;
  996. AcpiStatus = AcpiTable->InstallAcpiTable (
  997. AcpiTable,
  998. CurrentTable,
  999. Size,
  1000. &TableHandle
  1001. );
  1002. ASSERT_EFI_ERROR (AcpiStatus);
  1003. }
  1004. }
  1005. //
  1006. // Increment the instance.
  1007. //
  1008. Instance++;
  1009. }
  1010. }
  1011. Event = NULL;
  1012. OnReadyToBoot (Event, NULL);
  1013. //
  1014. // Finished.
  1015. //
  1016. return EFI_SUCCESS;
  1017. }
  1018. UINT8
  1019. ReadCmosBank1Byte (
  1020. IN UINT8 Index
  1021. )
  1022. {
  1023. UINT8 Data;
  1024. IoWrite8(0x72, Index);
  1025. Data = IoRead8 (0x73);
  1026. return Data;
  1027. }
  1028. VOID
  1029. WriteCmosBank1Byte (
  1030. IN UINT8 Index,
  1031. IN UINT8 Data
  1032. )
  1033. {
  1034. IoWrite8 (0x72, Index);
  1035. IoWrite8 (0x73, Data);
  1036. }
  1037. VOID
  1038. SettingI2CTouchAddress (
  1039. IN VOID
  1040. )
  1041. {
  1042. if (mSystemConfiguration.I2CTouchAd == 0) {
  1043. //
  1044. // If setup menu select auto set I2C Touch Address base on board id.
  1045. //
  1046. if (mPlatformInfo->BoardId == BOARD_ID_BL_RVP ||
  1047. mPlatformInfo->BoardId == BOARD_ID_BL_STHI ||
  1048. mPlatformInfo->BoardId == BOARD_ID_BL_RVP_DDR3L ) {
  1049. //
  1050. //RVP
  1051. //
  1052. mGlobalNvsArea.Area->I2CTouchAddress = 0x4B;
  1053. } else if (mPlatformInfo->BoardId == BOARD_ID_BL_FFRD) {
  1054. //
  1055. //FFRD
  1056. //
  1057. mGlobalNvsArea.Area->I2CTouchAddress = 0x4A;
  1058. } else if (mPlatformInfo->BoardId == BOARD_ID_BB_RVP) {
  1059. mGlobalNvsArea.Area->I2CTouchAddress = 0x4C;
  1060. } else if (mPlatformInfo->BoardId == BOARD_ID_CVH) {
  1061. mGlobalNvsArea.Area->I2CTouchAddress = 0x4C;
  1062. } else if (mPlatformInfo->BoardId == BOARD_ID_BL_FFRD8) {
  1063. //
  1064. //FFRD8 uses 0x4A.
  1065. //
  1066. mGlobalNvsArea.Area->I2CTouchAddress = 0x4A;
  1067. }
  1068. } else {
  1069. mGlobalNvsArea.Area->I2CTouchAddress = mSystemConfiguration.I2CTouchAd;
  1070. }
  1071. DEBUG((EFI_D_ERROR, "GlobalNvsArea.Area->I2CTouchAddress: [%02x]\n", mGlobalNvsArea.Area->I2CTouchAddress));
  1072. }