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