2 CPU Register Table Library functions.
4 Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "RegisterCpuFeatures.h"
18 Checks if two CPU feature bit masks are equal.
20 @param[in] FirstFeatureMask The first input CPU feature bit mask
21 @param[in] SecondFeatureMask The second input CPU feature bit mask
23 @retval TRUE Two CPU feature bit masks are equal.
24 @retval FALSE Two CPU feature bit masks are not equal.
28 IN UINT8
*FirstFeatureMask
,
29 IN UINT8
*SecondFeatureMask
34 BitMaskSize
= PcdGetSize (PcdCpuFeaturesSupport
);
35 if (CompareMem (FirstFeatureMask
, SecondFeatureMask
, BitMaskSize
) == 0) {
43 Function that uses DEBUG() macros to display the contents of a a CPU feature bit mask.
45 @param[in] FeatureMask A pointer to the CPU feature bit mask.
56 BitMaskSize
= PcdGetSize (PcdCpuFeaturesSupport
);
57 Data8
= (UINT8
*) FeatureMask
;
58 for (Index
= 0; Index
< BitMaskSize
; Index
++) {
59 DEBUG ((DEBUG_INFO
, " %02x ", *Data8
++));
61 DEBUG ((DEBUG_INFO
, "\n"));
65 Dump CPU feature name or CPU feature bit mask.
67 @param[in] CpuFeature Pointer to CPU_FEATURES_ENTRY
71 IN CPU_FEATURES_ENTRY
*CpuFeature
75 if (CpuFeature
->FeatureName
!= NULL
) {
76 DEBUG ((DEBUG_INFO
, "FeatureName: %a\n", CpuFeature
->FeatureName
));
78 DEBUG ((DEBUG_INFO
, "FeatureMask = "));
79 DumpCpuFeatureMask (CpuFeature
->FeatureMask
);
84 Determines if the feature bit mask is in dependent CPU feature bit mask buffer.
86 @param[in] FeatureMask Pointer to CPU feature bit mask
87 @param[in] DependentBitMask Pointer to dependent CPU feature bit mask buffer
89 @retval TRUE The feature bit mask is in dependent CPU feature bit mask buffer.
90 @retval FALSE The feature bit mask is not in dependent CPU feature bit mask buffer.
94 IN UINT8
*FeatureMask
,
95 IN UINT8
*DependentBitMask
103 BitMaskSize
= PcdGetSize (PcdCpuFeaturesSupport
);
106 Data2
= DependentBitMask
;
107 for (Index
= 0; Index
< BitMaskSize
; Index
++) {
108 if (((*(Data1
++)) & (*(Data2
++))) != 0) {
116 Checks and adjusts CPU features order per dependency relationship.
118 @param[in] FeatureList Pointer to CPU feature list
121 CheckCpuFeaturesDependency (
122 IN LIST_ENTRY
*FeatureList
125 LIST_ENTRY
*CurrentEntry
;
126 CPU_FEATURES_ENTRY
*CpuFeature
;
127 LIST_ENTRY
*CheckEntry
;
128 CPU_FEATURES_ENTRY
*CheckFeature
;
130 LIST_ENTRY
*TempEntry
;
132 CurrentEntry
= GetFirstNode (FeatureList
);
133 while (!IsNull (FeatureList
, CurrentEntry
)) {
135 CpuFeature
= CPU_FEATURE_ENTRY_FROM_LINK (CurrentEntry
);
136 if (CpuFeature
->BeforeAll
) {
138 // Check all features dispatched before this entry
140 CheckEntry
= GetFirstNode (FeatureList
);
141 while (CheckEntry
!= CurrentEntry
) {
142 CheckFeature
= CPU_FEATURE_ENTRY_FROM_LINK (CheckEntry
);
143 if (!CheckFeature
->BeforeAll
) {
145 // If this feature has no BeforeAll flag and is dispatched before CpuFeature,
146 // insert currentEntry before Checked feature
148 RemoveEntryList (CurrentEntry
);
149 InsertTailList (CheckEntry
, CurrentEntry
);
153 CheckEntry
= CheckEntry
->ForwardLink
;
160 if (CpuFeature
->AfterAll
) {
162 // Check all features dispatched after this entry
164 CheckEntry
= GetNextNode (FeatureList
, CurrentEntry
);
165 while (!IsNull (FeatureList
, CheckEntry
)) {
166 CheckFeature
= CPU_FEATURE_ENTRY_FROM_LINK (CheckEntry
);
167 if (!CheckFeature
->AfterAll
) {
169 // If this feature has no AfterAll flag and is dispatched after CpuFeature,
170 // insert currentEntry after Checked feature
172 TempEntry
= GetNextNode (FeatureList
, CurrentEntry
);
173 RemoveEntryList (CurrentEntry
);
174 InsertHeadList (CheckEntry
, CurrentEntry
);
175 CurrentEntry
= TempEntry
;
179 CheckEntry
= CheckEntry
->ForwardLink
;
186 if (CpuFeature
->BeforeFeatureBitMask
!= NULL
) {
188 // Check all features dispatched before this entry
190 CheckEntry
= GetFirstNode (FeatureList
);
191 while (CheckEntry
!= CurrentEntry
) {
192 CheckFeature
= CPU_FEATURE_ENTRY_FROM_LINK (CheckEntry
);
193 if (IsBitMaskMatchCheck (CheckFeature
->FeatureMask
, CpuFeature
->BeforeFeatureBitMask
)) {
195 // If there is dependency, swap them
197 RemoveEntryList (CurrentEntry
);
198 InsertTailList (CheckEntry
, CurrentEntry
);
202 CheckEntry
= CheckEntry
->ForwardLink
;
209 if (CpuFeature
->AfterFeatureBitMask
!= NULL
) {
211 // Check all features dispatched after this entry
213 CheckEntry
= GetNextNode (FeatureList
, CurrentEntry
);
214 while (!IsNull (FeatureList
, CheckEntry
)) {
215 CheckFeature
= CPU_FEATURE_ENTRY_FROM_LINK (CheckEntry
);
216 if (IsBitMaskMatchCheck (CheckFeature
->FeatureMask
, CpuFeature
->AfterFeatureBitMask
)) {
218 // If there is dependency, swap them
220 TempEntry
= GetNextNode (FeatureList
, CurrentEntry
);
221 RemoveEntryList (CurrentEntry
);
222 InsertHeadList (CheckEntry
, CurrentEntry
);
223 CurrentEntry
= TempEntry
;
227 CheckEntry
= CheckEntry
->ForwardLink
;
234 // No swap happened, check the next feature
236 CurrentEntry
= CurrentEntry
->ForwardLink
;
241 Worker function to register CPU Feature.
243 @param[in] CpuFeature Pointer to CPU feature entry
245 @retval RETURN_SUCCESS The CPU feature was successfully registered.
246 @retval RETURN_OUT_OF_RESOURCES There are not enough resources to register
248 @retval RETURN_UNSUPPORTED Registration of the CPU feature is not
249 supported due to a circular dependency between
250 BEFORE and AFTER features.
253 RegisterCpuFeatureWorker (
254 IN CPU_FEATURES_ENTRY
*CpuFeature
258 CPU_FEATURES_DATA
*CpuFeaturesData
;
259 CPU_FEATURES_ENTRY
*CpuFeatureEntry
;
262 BOOLEAN FeatureExist
;
264 BitMaskSize
= PcdGetSize (PcdCpuFeaturesSupport
);
265 CpuFeaturesData
= GetCpuFeaturesData ();
266 if (CpuFeaturesData
->FeaturesCount
== 0) {
267 InitializeListHead (&CpuFeaturesData
->FeatureList
);
268 InitializeSpinLock (&CpuFeaturesData
->MsrLock
);
269 InitializeSpinLock (&CpuFeaturesData
->MemoryMappedLock
);
270 CpuFeaturesData
->BitMaskSize
= (UINT32
) BitMaskSize
;
272 ASSERT (CpuFeaturesData
->BitMaskSize
== BitMaskSize
);
274 FeatureExist
= FALSE
;
275 CpuFeatureEntry
= NULL
;
276 Entry
= GetFirstNode (&CpuFeaturesData
->FeatureList
);
277 while (!IsNull (&CpuFeaturesData
->FeatureList
, Entry
)) {
278 CpuFeatureEntry
= CPU_FEATURE_ENTRY_FROM_LINK (Entry
);
279 if (IsCpuFeatureMatch (CpuFeature
->FeatureMask
, CpuFeatureEntry
->FeatureMask
)) {
281 // If this feature already registered
286 Entry
= Entry
->ForwardLink
;
290 DEBUG ((DEBUG_INFO
, "[NEW] "));
291 DumpCpuFeature (CpuFeature
);
292 InsertTailList (&CpuFeaturesData
->FeatureList
, &CpuFeature
->Link
);
293 CpuFeaturesData
->FeaturesCount
++;
295 DEBUG ((DEBUG_INFO
, "[OVERRIDE] "));
296 DumpCpuFeature (CpuFeature
);
297 ASSERT (CpuFeatureEntry
!= NULL
);
299 // Overwrite original parameters of CPU feature
301 if (CpuFeature
->GetConfigDataFunc
!= NULL
) {
302 CpuFeatureEntry
->GetConfigDataFunc
= CpuFeature
->GetConfigDataFunc
;
304 if (CpuFeature
->SupportFunc
!= NULL
) {
305 CpuFeatureEntry
->SupportFunc
= CpuFeature
->SupportFunc
;
307 if (CpuFeature
->InitializeFunc
!= NULL
) {
308 CpuFeatureEntry
->InitializeFunc
= CpuFeature
->InitializeFunc
;
310 if (CpuFeature
->FeatureName
!= NULL
) {
311 if (CpuFeatureEntry
->FeatureName
== NULL
) {
312 CpuFeatureEntry
->FeatureName
= AllocatePool (CPU_FEATURE_NAME_SIZE
);
313 ASSERT (CpuFeatureEntry
->FeatureName
!= NULL
);
315 Status
= AsciiStrCpyS (CpuFeatureEntry
->FeatureName
, CPU_FEATURE_NAME_SIZE
, CpuFeature
->FeatureName
);
316 ASSERT_EFI_ERROR (Status
);
317 FreePool (CpuFeature
->FeatureName
);
319 if (CpuFeature
->BeforeFeatureBitMask
!= NULL
) {
320 if (CpuFeatureEntry
->BeforeFeatureBitMask
!= NULL
) {
321 FreePool (CpuFeatureEntry
->BeforeFeatureBitMask
);
323 CpuFeatureEntry
->BeforeFeatureBitMask
= CpuFeature
->BeforeFeatureBitMask
;
325 if (CpuFeature
->AfterFeatureBitMask
!= NULL
) {
326 if (CpuFeatureEntry
->AfterFeatureBitMask
!= NULL
) {
327 FreePool (CpuFeatureEntry
->AfterFeatureBitMask
);
329 CpuFeatureEntry
->AfterFeatureBitMask
= CpuFeature
->AfterFeatureBitMask
;
331 CpuFeatureEntry
->BeforeAll
= CpuFeature
->BeforeAll
;
332 CpuFeatureEntry
->AfterAll
= CpuFeature
->AfterAll
;
334 FreePool (CpuFeature
->FeatureMask
);
335 FreePool (CpuFeature
);
338 // Verify CPU features dependency can change CPU feature order
340 CheckCpuFeaturesDependency (&CpuFeaturesData
->FeatureList
);
341 return RETURN_SUCCESS
;
345 Sets CPU feature bit mask in CPU feature bit mask buffer.
347 @param[in] FeaturesBitMask Pointer to CPU feature bit mask buffer
348 @param[in] Feature The bit number of the CPU feature
349 @param[in] BitMaskSize CPU feature bit mask buffer size
352 SetCpuFeaturesBitMask (
353 IN UINT8
**FeaturesBitMask
,
358 UINT8
*CpuFeaturesBitMask
;
360 ASSERT (FeaturesBitMask
!= NULL
);
361 CpuFeaturesBitMask
= *FeaturesBitMask
;
362 if (CpuFeaturesBitMask
== NULL
) {
363 CpuFeaturesBitMask
= AllocateZeroPool (BitMaskSize
);
364 ASSERT (CpuFeaturesBitMask
!= NULL
);
365 *FeaturesBitMask
= CpuFeaturesBitMask
;
368 CpuFeaturesBitMask
+= (Feature
/ 8);
369 *CpuFeaturesBitMask
|= (UINT8
) (1 << (Feature
% 8));
373 Registers a CPU Feature.
375 @param[in] FeatureName A Null-terminated Ascii string indicates CPU feature
377 @param[in] GetConfigDataFunc CPU feature get configuration data function. This
378 is an optional parameter that may be NULL. If NULL,
379 then the most recently registered function for the
380 CPU feature is used. If no functions are registered
381 for a CPU feature, then the CPU configuration data
382 for the registered feature is NULL.
383 @param[in] SupportFunc CPU feature support function. This is an optional
384 parameter that may be NULL. If NULL, then the most
385 recently registered function for the CPU feature is
386 used. If no functions are registered for a CPU
387 feature, then the CPU feature is assumed to be
388 supported by all CPUs.
389 @param[in] InitializeFunc CPU feature initialize function. This is an optional
390 parameter that may be NULL. If NULL, then the most
391 recently registered function for the CPU feature is
392 used. If no functions are registered for a CPU
393 feature, then the CPU feature initialization is
395 @param[in] ... Variable argument list of UINT32 CPU feature value.
396 Values with no modifiers are the features provided
397 by the registered functions.
398 Values with CPU_FEATURE_BEFORE modifier are features
399 that must be initialized after the features provided
400 by the registered functions are used.
401 Values with CPU_FEATURE_AFTER modifier are features
402 that must be initialized before the features provided
403 by the registered functions are used.
404 The last argument in this variable argument list must
405 always be CPU_FEATURE_END.
407 @retval RETURN_SUCCESS The CPU feature was successfully registered.
408 @retval RETURN_OUT_OF_RESOURCES There are not enough resources to register
410 @retval RETURN_UNSUPPORTED Registration of the CPU feature is not
411 supported due to a circular dependency between
412 BEFORE and AFTER features.
414 @note This service could be called by BSP only.
419 IN CHAR8
*FeatureName
, OPTIONAL
420 IN CPU_FEATURE_GET_CONFIG_DATA GetConfigDataFunc
, OPTIONAL
421 IN CPU_FEATURE_SUPPORT SupportFunc
, OPTIONAL
422 IN CPU_FEATURE_INITIALIZE InitializeFunc
, OPTIONAL
430 CPU_FEATURES_ENTRY
*CpuFeature
;
432 UINT8
*BeforeFeatureBitMask
;
433 UINT8
*AfterFeatureBitMask
;
438 BeforeFeatureBitMask
= NULL
;
439 AfterFeatureBitMask
= NULL
;
443 BitMaskSize
= PcdGetSize (PcdCpuFeaturesSupport
);
445 VA_START (Marker
, InitializeFunc
);
446 Feature
= VA_ARG (Marker
, UINT32
);
447 while (Feature
!= CPU_FEATURE_END
) {
448 ASSERT ((Feature
& (CPU_FEATURE_BEFORE
| CPU_FEATURE_AFTER
))
449 != (CPU_FEATURE_BEFORE
| CPU_FEATURE_AFTER
));
450 ASSERT ((Feature
& (CPU_FEATURE_BEFORE_ALL
| CPU_FEATURE_AFTER_ALL
))
451 != (CPU_FEATURE_BEFORE_ALL
| CPU_FEATURE_AFTER_ALL
));
452 if (Feature
< CPU_FEATURE_BEFORE
) {
453 BeforeAll
= ((Feature
& CPU_FEATURE_BEFORE_ALL
) != 0) ? TRUE
: FALSE
;
454 AfterAll
= ((Feature
& CPU_FEATURE_AFTER_ALL
) != 0) ? TRUE
: FALSE
;
455 Feature
&= ~(CPU_FEATURE_BEFORE_ALL
| CPU_FEATURE_AFTER_ALL
);
456 ASSERT (FeatureMask
== NULL
);
457 SetCpuFeaturesBitMask (&FeatureMask
, Feature
, BitMaskSize
);
458 } else if ((Feature
& CPU_FEATURE_BEFORE
) != 0) {
459 SetCpuFeaturesBitMask (&BeforeFeatureBitMask
, Feature
& ~CPU_FEATURE_BEFORE
, BitMaskSize
);
460 } else if ((Feature
& CPU_FEATURE_AFTER
) != 0) {
461 SetCpuFeaturesBitMask (&AfterFeatureBitMask
, Feature
& ~CPU_FEATURE_AFTER
, BitMaskSize
);
463 Feature
= VA_ARG (Marker
, UINT32
);
467 CpuFeature
= AllocateZeroPool (sizeof (CPU_FEATURES_ENTRY
));
468 ASSERT (CpuFeature
!= NULL
);
469 CpuFeature
->Signature
= CPU_FEATURE_ENTRY_SIGNATURE
;
470 CpuFeature
->FeatureMask
= FeatureMask
;
471 CpuFeature
->BeforeFeatureBitMask
= BeforeFeatureBitMask
;
472 CpuFeature
->AfterFeatureBitMask
= AfterFeatureBitMask
;
473 CpuFeature
->BeforeAll
= BeforeAll
;
474 CpuFeature
->AfterAll
= AfterAll
;
475 CpuFeature
->GetConfigDataFunc
= GetConfigDataFunc
;
476 CpuFeature
->SupportFunc
= SupportFunc
;
477 CpuFeature
->InitializeFunc
= InitializeFunc
;
478 if (FeatureName
!= NULL
) {
479 CpuFeature
->FeatureName
= AllocatePool (CPU_FEATURE_NAME_SIZE
);
480 ASSERT (CpuFeature
->FeatureName
!= NULL
);
481 Status
= AsciiStrCpyS (CpuFeature
->FeatureName
, CPU_FEATURE_NAME_SIZE
, FeatureName
);
482 ASSERT_EFI_ERROR (Status
);
485 Status
= RegisterCpuFeatureWorker (CpuFeature
);
486 ASSERT_EFI_ERROR (Status
);
488 return RETURN_SUCCESS
;
492 Allocates boot service data to save ACPI_CPU_DATA.
494 @return Pointer to allocated ACPI_CPU_DATA.
498 AllocateAcpiCpuData (
504 UINTN NumberOfEnabledProcessors
;
505 ACPI_CPU_DATA
*AcpiCpuData
;
507 CPU_REGISTER_TABLE
*RegisterTable
;
509 EFI_PROCESSOR_INFORMATION ProcessorInfoBuffer
;
511 AcpiCpuData
= AllocatePages (EFI_SIZE_TO_PAGES (sizeof (ACPI_CPU_DATA
)));
512 ASSERT (AcpiCpuData
!= NULL
);
514 GetNumberOfProcessor (&NumberOfCpus
, &NumberOfEnabledProcessors
);
515 AcpiCpuData
->NumberOfCpus
= (UINT32
)NumberOfCpus
;
518 // Allocate buffer for empty RegisterTable and PreSmmInitRegisterTable for all CPUs
520 TableSize
= 2 * NumberOfCpus
* sizeof (CPU_REGISTER_TABLE
);
521 RegisterTable
= AllocatePages (EFI_SIZE_TO_PAGES (TableSize
));
522 ASSERT (RegisterTable
!= NULL
);
524 for (Index
= 0; Index
< NumberOfCpus
; Index
++) {
525 Status
= GetProcessorInformation (Index
, &ProcessorInfoBuffer
);
526 ASSERT_EFI_ERROR (Status
);
528 RegisterTable
[Index
].InitialApicId
= (UINT32
)ProcessorInfoBuffer
.ProcessorId
;
529 RegisterTable
[Index
].TableLength
= 0;
530 RegisterTable
[Index
].AllocatedSize
= 0;
531 RegisterTable
[Index
].RegisterTableEntry
= 0;
533 RegisterTable
[NumberOfCpus
+ Index
].InitialApicId
= (UINT32
)ProcessorInfoBuffer
.ProcessorId
;
534 RegisterTable
[NumberOfCpus
+ Index
].TableLength
= 0;
535 RegisterTable
[NumberOfCpus
+ Index
].AllocatedSize
= 0;
536 RegisterTable
[NumberOfCpus
+ Index
].RegisterTableEntry
= 0;
538 AcpiCpuData
->RegisterTable
= (EFI_PHYSICAL_ADDRESS
)(UINTN
)RegisterTable
;
539 AcpiCpuData
->PreSmmInitRegisterTable
= (EFI_PHYSICAL_ADDRESS
)(UINTN
)(RegisterTable
+ NumberOfCpus
);
545 Enlarges CPU register table for each processor.
547 @param[in, out] RegisterTable Pointer processor's CPU register table
551 EnlargeRegisterTable (
552 IN OUT CPU_REGISTER_TABLE
*RegisterTable
555 EFI_PHYSICAL_ADDRESS Address
;
558 UsedPages
= RegisterTable
->AllocatedSize
/ EFI_PAGE_SIZE
;
559 Address
= (UINTN
)AllocatePages (UsedPages
+ 1);
560 ASSERT (Address
!= 0);
563 // If there are records existing in the register table, then copy its contents
564 // to new region and free the old one.
566 if (RegisterTable
->AllocatedSize
> 0) {
568 (VOID
*) (UINTN
) Address
,
569 (VOID
*) (UINTN
) RegisterTable
->RegisterTableEntry
,
570 RegisterTable
->AllocatedSize
573 FreePages ((VOID
*)(UINTN
)RegisterTable
->RegisterTableEntry
, UsedPages
);
577 // Adjust the allocated size and register table base address.
579 RegisterTable
->AllocatedSize
+= EFI_PAGE_SIZE
;
580 RegisterTable
->RegisterTableEntry
= Address
;
584 Add an entry in specified register table.
586 This function adds an entry in specified register table, with given register type,
587 register index, bit section and value.
589 @param[in] PreSmmFlag If TRUE, entry will be added into PreSmm register table
590 If FALSE, entry will be added into register table
591 @param[in] ProcessorNumber The index of the CPU to add a register table entry
592 @param[in] RegisterType Type of the register to program
593 @param[in] Index Index of the register to program
594 @param[in] ValidBitStart Start of the bit section
595 @param[in] ValidBitLength Length of the bit section
596 @param[in] Value Value to write
599 CpuRegisterTableWriteWorker (
600 IN BOOLEAN PreSmmFlag
,
601 IN UINTN ProcessorNumber
,
602 IN REGISTER_TYPE RegisterType
,
604 IN UINT8 ValidBitStart
,
605 IN UINT8 ValidBitLength
,
610 CPU_FEATURES_DATA
*CpuFeaturesData
;
611 ACPI_CPU_DATA
*AcpiCpuData
;
612 CPU_REGISTER_TABLE
*RegisterTable
;
613 CPU_REGISTER_TABLE_ENTRY
*RegisterTableEntry
;
615 CpuFeaturesData
= GetCpuFeaturesData ();
616 if (CpuFeaturesData
->RegisterTable
== NULL
) {
617 AcpiCpuData
= (ACPI_CPU_DATA
*) (UINTN
) PcdGet64 (PcdCpuS3DataAddress
);
618 if (AcpiCpuData
== NULL
) {
619 AcpiCpuData
= AllocateAcpiCpuData ();
620 ASSERT (AcpiCpuData
!= NULL
);
622 // Set PcdCpuS3DataAddress to the base address of the ACPI_CPU_DATA structure
624 Status
= PcdSet64S (PcdCpuS3DataAddress
, (UINT64
)(UINTN
)AcpiCpuData
);
625 ASSERT_EFI_ERROR (Status
);
627 ASSERT (AcpiCpuData
->RegisterTable
!= 0);
628 CpuFeaturesData
->RegisterTable
= (CPU_REGISTER_TABLE
*) (UINTN
) AcpiCpuData
->RegisterTable
;
629 CpuFeaturesData
->PreSmmRegisterTable
= (CPU_REGISTER_TABLE
*) (UINTN
) AcpiCpuData
->PreSmmInitRegisterTable
;
633 RegisterTable
= &CpuFeaturesData
->PreSmmRegisterTable
[ProcessorNumber
];
635 RegisterTable
= &CpuFeaturesData
->RegisterTable
[ProcessorNumber
];
638 if (RegisterTable
->TableLength
== RegisterTable
->AllocatedSize
/ sizeof (CPU_REGISTER_TABLE_ENTRY
)) {
639 EnlargeRegisterTable (RegisterTable
);
643 // Append entry in the register table.
645 RegisterTableEntry
= (CPU_REGISTER_TABLE_ENTRY
*) (UINTN
) RegisterTable
->RegisterTableEntry
;
646 RegisterTableEntry
[RegisterTable
->TableLength
].RegisterType
= RegisterType
;
647 RegisterTableEntry
[RegisterTable
->TableLength
].Index
= (UINT32
) Index
;
648 RegisterTableEntry
[RegisterTable
->TableLength
].HighIndex
= (UINT32
) RShiftU64 (Index
, 32);
649 RegisterTableEntry
[RegisterTable
->TableLength
].ValidBitStart
= ValidBitStart
;
650 RegisterTableEntry
[RegisterTable
->TableLength
].ValidBitLength
= ValidBitLength
;
651 RegisterTableEntry
[RegisterTable
->TableLength
].Value
= Value
;
653 RegisterTable
->TableLength
++;
657 Adds an entry in specified register table.
659 This function adds an entry in specified register table, with given register type,
660 register index, bit section and value.
662 @param[in] ProcessorNumber The index of the CPU to add a register table entry
663 @param[in] RegisterType Type of the register to program
664 @param[in] Index Index of the register to program
665 @param[in] ValueMask Mask of bits in register to write
666 @param[in] Value Value to write
668 @note This service could be called by BSP only.
672 CpuRegisterTableWrite (
673 IN UINTN ProcessorNumber
,
674 IN REGISTER_TYPE RegisterType
,
684 Start
= (UINT8
)LowBitSet64 (ValueMask
);
685 End
= (UINT8
)HighBitSet64 (ValueMask
);
686 Length
= End
- Start
+ 1;
687 CpuRegisterTableWriteWorker (FALSE
, ProcessorNumber
, RegisterType
, Index
, Start
, Length
, Value
);
691 Adds an entry in specified Pre-SMM register table.
693 This function adds an entry in specified register table, with given register type,
694 register index, bit section and value.
696 @param[in] ProcessorNumber The index of the CPU to add a register table entry.
697 @param[in] RegisterType Type of the register to program
698 @param[in] Index Index of the register to program
699 @param[in] ValueMask Mask of bits in register to write
700 @param[in] Value Value to write
702 @note This service could be called by BSP only.
706 PreSmmCpuRegisterTableWrite (
707 IN UINTN ProcessorNumber
,
708 IN REGISTER_TYPE RegisterType
,
718 Start
= (UINT8
)LowBitSet64 (ValueMask
);
719 End
= (UINT8
)HighBitSet64 (ValueMask
);
720 Length
= End
- Start
+ 1;
721 CpuRegisterTableWriteWorker (TRUE
, ProcessorNumber
, RegisterType
, Index
, Start
, Length
, Value
);
725 Worker function to determine if a CPU feature is set in input CPU feature bit mask buffer.
727 @param[in] CpuBitMask CPU feature bit mask buffer
728 @param[in] CpuBitMaskSize The size of CPU feature bit mask buffer
729 @param[in] Feature The bit number of the CPU feature
731 @retval TRUE The CPU feature is set in PcdCpuFeaturesSupport.
732 @retval FALSE The CPU feature is not set in PcdCpuFeaturesSupport.
736 IsCpuFeatureSetInCpuPcd (
737 IN UINT8
*CpuBitMask
,
738 IN UINTN CpuBitMaskSize
,
742 if ((Feature
>> 3) >= CpuBitMaskSize
) {
745 return ((*(CpuBitMask
+ (Feature
>> 3)) & (1 << (Feature
& 0x07))) != 0);
749 Determines if a CPU feature is enabled in PcdCpuFeaturesSupport bit mask.
750 If a CPU feature is disabled in PcdCpuFeaturesSupport then all the code/data
751 associated with that feature should be optimized away if compiler
752 optimizations are enabled.
754 @param[in] Feature The bit number of the CPU feature to check in the PCD
755 PcdCpuFeaturesSupport
757 @retval TRUE The CPU feature is set in PcdCpuFeaturesSupport.
758 @retval FALSE The CPU feature is not set in PcdCpuFeaturesSupport.
760 @note This service could be called by BSP only.
764 IsCpuFeatureSupported (
768 return IsCpuFeatureSetInCpuPcd (
769 (UINT8
*)PcdGetPtr (PcdCpuFeaturesSupport
),
770 PcdGetSize (PcdCpuFeaturesSupport
),
776 Determines if a CPU feature is set in PcdCpuFeaturesSetting bit mask.
778 @param[in] Feature The bit number of the CPU feature to check in the PCD
779 PcdCpuFeaturesSetting
781 @retval TRUE The CPU feature is set in PcdCpuFeaturesSetting.
782 @retval FALSE The CPU feature is not set in PcdCpuFeaturesSetting.
784 @note This service could be called by BSP only.
788 IsCpuFeatureInSetting (
792 return IsCpuFeatureSetInCpuPcd (
793 (UINT8
*)PcdGetPtr (PcdCpuFeaturesSetting
),
794 PcdGetSize (PcdCpuFeaturesSetting
),
800 Determines if a CPU feature is set in PcdCpuFeaturesCapability bit mask.
802 @param[in] Feature The bit number of the CPU feature to check in the PCD
803 PcdCpuFeaturesCapability
805 @retval TRUE The CPU feature is set in PcdCpuFeaturesCapability.
806 @retval FALSE The CPU feature is not set in PcdCpuFeaturesCapability.
808 @note This service could be called by BSP only.
812 IsCpuFeatureCapability (
816 return IsCpuFeatureSetInCpuPcd (
817 (UINT8
*)PcdGetPtr (PcdCpuFeaturesCapability
),
818 PcdGetSize (PcdCpuFeaturesCapability
),
825 Determines if a CPU feature is set in PcdCpuFeaturesUserConfiguration bit mask.
827 @param[in] Feature The bit number of the CPU feature to check in the PCD
828 PcdCpuFeaturesUserConfiguration
830 @retval TRUE The CPU feature is set in PcdCpuFeaturesUserConfiguration.
831 @retval FALSE The CPU feature is not set in PcdCpuFeaturesUserConfiguration.
833 @note This service could be called by BSP only.
837 IsCpuFeatureUserConfiguration (
841 return IsCpuFeatureSetInCpuPcd (
842 (UINT8
*)PcdGetPtr (PcdCpuFeaturesUserConfiguration
),
843 PcdGetSize (PcdCpuFeaturesUserConfiguration
),
850 Switches to assigned BSP after CPU features initialization.
852 @param[in] ProcessorNumber The index of the CPU executing this function.
854 @note This service could be called by BSP only.
858 SwitchBspAfterFeaturesInitialize (
859 IN UINTN ProcessorNumber
862 CPU_FEATURES_DATA
*CpuFeaturesData
;
864 CpuFeaturesData
= GetCpuFeaturesData ();
865 CpuFeaturesData
->BspNumber
= ProcessorNumber
;