]> git.proxmox.com Git - mirror_edk2.git/blob - Vlv2TbltDevicePkg/AcpiPlatform/AcpiPlatform.c
projects / mirror_edk2.git / blob
? search:


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