lint: simplify board-status check
[coreboot.git] / src / vendorcode / amd / agesa / f15 / Proc / CPU / cpuApicUtilities.c
1 /* $NoKeywords:$ */
2 /**
3  * @file
4  *
5  * AMD CPU APIC related utility functions.
6  *
7  * Contains code that provides mechanism to invoke and control APIC communication.
8  *
9  * @xrefitem bom "File Content Label" "Release Content"
10  * @e project:      AGESA
11  * @e sub-project:  CPU
12  * @e \$Revision: 56279 $   @e \$Date: 2011-07-11 13:11:28 -0600 (Mon, 11 Jul 2011) $
13  *
14  */
15 /*
16  ******************************************************************************
17  *
18  * Copyright (C) 2012 Advanced Micro Devices, Inc.
19  * All rights reserved.
20  *
21  * Redistribution and use in source and binary forms, with or without
22  * modification, are permitted provided that the following conditions are met:
23  *     * Redistributions of source code must retain the above copyright
24  *       notice, this list of conditions and the following disclaimer.
25  *     * Redistributions in binary form must reproduce the above copyright
26  *       notice, this list of conditions and the following disclaimer in the
27  *       documentation and/or other materials provided with the distribution.
28  *     * Neither the name of Advanced Micro Devices, Inc. nor the names of
29  *       its contributors may be used to endorse or promote products derived
30  *       from this software without specific prior written permission.
31  *
32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
33  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
34  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
35  * DISCLAIMED. IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. BE LIABLE FOR ANY
36  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
37  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
38  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
39  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
40  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
41  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42  *
43  ******************************************************************************
44  */
45
46 /*----------------------------------------------------------------------------------------
47  *                             M O D U L E S    U S E D
48  *----------------------------------------------------------------------------------------
49  */
50 #include "AGESA.h"
51 #include "amdlib.h"
52 #include "Ids.h"
53 #include "cpuCacheInit.h"
54 #include "cpuRegisters.h"
55 #include "cpuApicUtilities.h"
56 #include "cpuFamilyTranslation.h"
57 #include "GeneralServices.h"
58 #include "cpuServices.h"
59 #include "heapManager.h"
60 #include "Filecode.h"
61 CODE_GROUP (G1_PEICC)
62 RDATA_GROUP (G2_PEI)
63
64 #define FILECODE PROC_CPU_CPUAPICUTILITIES_FILECODE
65
66 /*----------------------------------------------------------------------------------------
67  *                   D E F I N I T I O N S    A N D    M A C R O S
68  *----------------------------------------------------------------------------------------
69  */
70 /* ApFlags bits */
71 #define AP_TASK_HAS_INPUT    0x00000001ul
72 #define AP_TASK_HAS_OUTPUT   0x00000002ul
73 #define AP_RETURN_PARAMS     0x00000004ul
74 #define AP_END_AT_HLT        0x00000008ul
75 #define AP_PASS_EARLY_PARAMS 0x00000010ul
76
77 #define XFER_ELEMENT_SIZE    sizeof (UINT32)
78
79 /*----------------------------------------------------------------------------------------
80  *                  T Y P E D E F S     A N D     S T R U C T U R E S
81  *----------------------------------------------------------------------------------------
82  */
83
84 typedef VOID F_CPU_AMD_NMI_HANDLER (
85   IN       AMD_CONFIG_PARAMS *StdHeader
86   );
87 typedef F_CPU_AMD_NMI_HANDLER *PF_CPU_AMD_NMI_HANDLER;
88
89 /*----------------------------------------------------------------------------------------
90  *           P R O T O T Y P E S     O F     L O C A L     F U N C T I O N S
91  *----------------------------------------------------------------------------------------
92  */
93 VOID
94 STATIC
95 ApUtilSetupIdtForHlt (
96   IN       IDT_DESCRIPTOR *NmiIdtDescPtr,
97   IN       AMD_CONFIG_PARAMS *StdHeader
98   );
99
100 UINT32
101 STATIC
102 ApUtilRemoteRead (
103   IN       UINT32 TargetApicId,
104   IN       UINT8  RegAddr,
105   IN       AMD_CONFIG_PARAMS *StdHeader
106   );
107
108 VOID
109 STATIC
110 ApUtilLocalWrite (
111   IN       UINT32 RegAddr,
112   IN       UINT32 Value,
113   IN       AMD_CONFIG_PARAMS *StdHeader
114   );
115
116 UINT32
117 STATIC
118 ApUtilLocalRead (
119   IN       UINT32 RegAddr,
120   IN       AMD_CONFIG_PARAMS *StdHeader
121   );
122
123 VOID
124 STATIC
125 ApUtilGetLocalApicBase (
126      OUT   UINT64 *ApicBase,
127   IN       AMD_CONFIG_PARAMS *StdHeader
128   );
129
130 UINT8
131 STATIC
132 ApUtilCalculateUniqueId (
133   IN      UINT8 Socket,
134   IN      UINT8 Core,
135   IN      AMD_CONFIG_PARAMS *StdHeader
136   );
137
138 VOID
139 STATIC
140 ApUtilFireDirectedNmi (
141   IN      UINT32 TargetApicId,
142   IN      AMD_CONFIG_PARAMS *StdHeader
143   );
144
145 VOID
146 STATIC
147 ApUtilReceivePointer (
148   IN       UINT32 TargetApicId,
149      OUT   VOID  **ReturnPointer,
150   IN       AMD_CONFIG_PARAMS *StdHeader
151   );
152
153 VOID
154 STATIC
155 ApUtilTransmitPointer (
156   IN       UINT32 TargetApicId,
157   IN       VOID  **Pointer,
158   IN       AMD_CONFIG_PARAMS *StdHeader
159   );
160
161 VOID
162 STATIC
163 PerformFinalHalt (
164   IN       AMD_CONFIG_PARAMS *StdHeader
165   );
166
167 VOID
168 LocalApicInitialization (
169   IN       AMD_CPU_EARLY_PARAMS *CpuEarlyParamsPtr,
170   IN       AMD_CONFIG_PARAMS    *StdHeader
171   );
172
173 VOID
174 LocalApicInitializationAtEarly (
175   IN       CPU_SPECIFIC_SERVICES  *FamilyServices,
176   IN       AMD_CPU_EARLY_PARAMS   *EarlyParams,
177   IN       AMD_CONFIG_PARAMS      *StdHeader
178   );
179 /*----------------------------------------------------------------------------------------
180  *                          E X P O R T E D    F U N C T I O N S
181  *----------------------------------------------------------------------------------------
182  */
183 extern
184 VOID
185 ExecuteHltInstruction (
186   IN       AMD_CONFIG_PARAMS *StdHeader
187   );
188
189 extern
190 VOID
191 NmiHandler (
192   IN       AMD_CONFIG_PARAMS *StdHeader
193   );
194
195 extern
196 VOID
197 ExecuteFinalHltInstruction (
198   IN       UINT32 SharedCore,
199   IN       AP_MTRR_SETTINGS  *ApMtrrSettingsList,
200   IN       AMD_CONFIG_PARAMS *StdHeader
201   );
202
203 extern BUILD_OPT_CFG UserOptions;
204
205 /*---------------------------------------------------------------------------------------*/
206 /**
207  * Initialize the Local APIC.
208  *
209  * This function determines and programs the appropriate APIC ID value
210  * for the executing core.  This code must be run after HT initialization
211  * is complete.
212  *
213  *  @param[in]     CpuEarlyParamsPtr  Service parameters.
214  *  @param[in]     StdHeader          Config handle for library and services.
215  *
216  */
217 VOID
218 LocalApicInitialization (
219   IN       AMD_CPU_EARLY_PARAMS *CpuEarlyParamsPtr,
220   IN       AMD_CONFIG_PARAMS    *StdHeader
221   )
222 {
223   UINT32    CurrentCore;
224   UINT32    CurrentNodeNum;
225   UINT32    CoreIdBits;
226   UINT32    Mnc;
227   UINT32    ProcessorCount;
228   UINT32    ProcessorApicIndex;
229   UINT32    IoApicNum;
230   UINT32    StartLocalApicId;
231   UINT64    LocalApicBase;
232   UINT32    TempVar_a;
233   UINT64    MsrData;
234   UINT64    Address;
235   CPUID_DATA  CpuidData;
236
237   // Local variables default values
238   IoApicNum = CpuEarlyParamsPtr->PlatformConfig.NumberOfIoApics;
239
240   GetCurrentCore (&CurrentCore, StdHeader);
241   GetCurrentNodeNum (&CurrentNodeNum, StdHeader);
242
243   // Get Mnc
244   LibAmdCpuidRead (AMD_CPUID_ASIZE_PCCOUNT, &CpuidData, StdHeader);
245   CoreIdBits = (CpuidData.ECX_Reg & 0x0000F000) >> 12;
246   Mnc = 1 << (CoreIdBits & 0x000F);
247
248   // Get ProcessorCount in the system
249   ProcessorCount = GetNumberOfProcessors (StdHeader);
250
251   // Get the APIC Index of this processor.
252   ProcessorApicIndex = GetProcessorApicIndex (CurrentNodeNum, StdHeader);
253
254   TempVar_a = (Mnc * ProcessorCount) + IoApicNum;
255   ASSERT (TempVar_a < 255);
256
257   // Apply apic enumeration rules
258   // For systems with >= 16 APICs, put the IO-APICs at 0..n and
259   // put the local-APICs at m..z
260   // For systems with < 16 APICs, put the Local-APICs at 0..n and
261   // put the IO-APICs at (n + 1)..z
262   // This is needed because many IO-APIC devices only have 4 bits
263   // for their APIC id and therefore must reside at 0..15
264   StartLocalApicId = 0;
265   if (TempVar_a >= 16) {
266     if (IoApicNum >= 1) {
267       StartLocalApicId = (IoApicNum - 1) / Mnc;
268       StartLocalApicId = (StartLocalApicId + 1) * Mnc;
269     }
270   }
271
272   // Set local apic id
273   TempVar_a = (ProcessorApicIndex * Mnc) + CurrentCore + StartLocalApicId;
274   IDS_HDT_CONSOLE (CPU_TRACE, "  Node %d core %d APIC ID = 0x%x\n", CurrentNodeNum, CurrentCore, TempVar_a);
275   TempVar_a = TempVar_a << APIC20_ApicId;
276
277   // Enable local apic id
278   LibAmdMsrRead (MSR_APIC_BAR, &MsrData, StdHeader);
279   MsrData |= APIC_ENABLE_BIT;
280   LibAmdMsrWrite (MSR_APIC_BAR, &MsrData, StdHeader);
281
282   // Get local apic base Address
283   ApUtilGetLocalApicBase (&LocalApicBase, StdHeader);
284
285   Address = LocalApicBase + APIC_ID_REG;
286   LibAmdMemWrite (AccessWidth32, Address, &TempVar_a, StdHeader);
287 }
288
289 /*---------------------------------------------------------------------------------------*/
290 /**
291  * Initialize the Local APIC at the AmdInitEarly entry point.
292  *
293  * This function acts as a wrapper for calling the LocalApicInitialization
294  * routine at AmdInitEarly.
295  *
296  *  @param[in]   FamilyServices      The current Family Specific Services.
297  *  @param[in]   EarlyParams         Service parameters.
298  *  @param[in]   StdHeader           Config handle for library and services.
299  *
300  */
301 VOID
302 LocalApicInitializationAtEarly (
303   IN       CPU_SPECIFIC_SERVICES  *FamilyServices,
304   IN       AMD_CPU_EARLY_PARAMS   *EarlyParams,
305   IN       AMD_CONFIG_PARAMS      *StdHeader
306   )
307 {
308   AGESA_TESTPOINT (TpProcCpuLocalApicInit, StdHeader);
309   LocalApicInitialization (EarlyParams, StdHeader);
310 }
311
312
313 /*---------------------------------------------------------------------------------------*/
314 /**
315  * Main entry point for all APs in the system.
316  *
317  * This routine puts the AP cores in an infinite loop in which the cores
318  * will poll their masters, waiting to be told to perform a task.  At early,
319  * all socket-relative core zeros will receive their tasks from the BSC.
320  * All others will receive their tasks from the core zero of their local
321  * processor.  At the end of AmdInitEarly, all cores will switch to receiving
322  * their tasks from the BSC.
323  *
324  * @param[in]     StdHeader       Handle to config for library and services.
325  * @param[in]     CpuEarlyParams  AMD_CPU_EARLY_PARAMS pointer.
326  *
327  */
328 VOID
329 ApEntry (
330   IN       AMD_CONFIG_PARAMS *StdHeader,
331   IN       AMD_CPU_EARLY_PARAMS *CpuEarlyParams
332   )
333 {
334   UINT8   RemoteCmd;
335   UINT8   SourceSocket;
336   UINT8   CommandStart;
337   UINT32  ApFlags;
338   UINT32  FuncType;
339   UINT32  ReturnCode;
340   UINT32  CurrentSocket;
341   UINT32  CurrentCore;
342   UINT32  *InputDataPtr;
343   UINT32  BscSocket;
344   UINT32  Ignored;
345   UINT32  TargetApicId;
346   AP_FUNCTION_PTR FuncAddress;
347   IDT_DESCRIPTOR IdtDesc[32];
348   AP_DATA_TRANSFER DataTransferInfo;
349   AGESA_STATUS IgnoredSts;
350
351   ASSERT (!IsBsp (StdHeader, &IgnoredSts));
352
353   // Initialize local variables
354   ReturnCode = 0;
355   DataTransferInfo.DataTransferFlags = 0;
356   InputDataPtr = NULL;
357
358   // Determine the executing core's socket and core numbers
359   IdentifyCore (StdHeader, &CurrentSocket, &Ignored, &CurrentCore, &IgnoredSts);
360
361   IDS_HDT_CONSOLE (CPU_TRACE, "  Socket %d core %d begin AP tasking engine\n", CurrentSocket, CurrentCore);
362
363   // Determine the BSC's socket number
364   GetSocketModuleOfNode ((UINT32) 0x00000000, &BscSocket, &Ignored, StdHeader);
365
366   // Setup Interrupt Descriptor Table for sleep mode
367   ApUtilSetupIdtForHlt (&IdtDesc[2], StdHeader);
368
369   // Indicate to the BSC that we have reached the tasking engine
370   ApUtilWriteControlByte (CORE_IDLE, StdHeader);
371
372   if (CurrentCore == 0) {
373     // Core 0s receive their tasks from the BSC
374     SourceSocket = (UINT8) BscSocket;
375   } else {
376     // All non-zero cores receive their tasks from the core 0 of their socket
377     SourceSocket = (UINT8) CurrentSocket;
378   }
379
380   GetLocalApicIdForCore (SourceSocket, 0, &TargetApicId, StdHeader);
381
382   // Determine the unique value that the master will write when it has a task
383   // for this core to perform.
384   CommandStart = ApUtilCalculateUniqueId (
385                    (UINT8)CurrentSocket,
386                    (UINT8)CurrentCore,
387                    StdHeader
388                    );
389   for (;;) {
390     RemoteCmd = ApUtilReadRemoteControlByte (TargetApicId, StdHeader);
391     if (RemoteCmd == CommandStart) {
392       ApFlags = ApUtilReadRemoteDataDword (TargetApicId, StdHeader);
393
394       ApUtilReceivePointer (TargetApicId, (VOID **) &FuncAddress, StdHeader);
395
396       FuncType = ApFlags & (UINT32) (AP_TASK_HAS_INPUT | AP_TASK_HAS_OUTPUT | AP_PASS_EARLY_PARAMS);
397       if ((ApFlags & AP_TASK_HAS_INPUT) != 0) {
398         DataTransferInfo.DataSizeInDwords = 0;
399         DataTransferInfo.DataPtr = NULL;
400         DataTransferInfo.DataTransferFlags = 0;
401         if (ApUtilReceiveBuffer (SourceSocket, 0, &DataTransferInfo, StdHeader) == AGESA_ERROR) {
402           // There is not enough space to put the input data on the heap.  Undefined behavior is about
403           // to result.
404           IDS_ERROR_TRAP;
405         }
406         InputDataPtr = (UINT32 *) DataTransferInfo.DataPtr;
407       }
408       ApUtilWriteControlByte (CORE_ACTIVE, StdHeader);
409       switch (FuncType) {
410       case 0:
411         FuncAddress.PfApTask (StdHeader);
412         break;
413       case AP_TASK_HAS_INPUT:
414         FuncAddress.PfApTaskI (InputDataPtr, StdHeader);
415         break;
416       case AP_PASS_EARLY_PARAMS:
417         FuncAddress.PfApTaskC (StdHeader, CpuEarlyParams);
418         break;
419       case (AP_TASK_HAS_INPUT | AP_PASS_EARLY_PARAMS):
420         FuncAddress.PfApTaskIC (InputDataPtr, StdHeader, CpuEarlyParams);
421         break;
422       case AP_TASK_HAS_OUTPUT:
423         ReturnCode = FuncAddress.PfApTaskO (StdHeader);
424         break;
425       case (AP_TASK_HAS_INPUT | AP_TASK_HAS_OUTPUT):
426         ReturnCode = FuncAddress.PfApTaskIO (InputDataPtr, StdHeader);
427         break;
428       case (AP_TASK_HAS_OUTPUT | AP_PASS_EARLY_PARAMS):
429         ReturnCode = FuncAddress.PfApTaskOC (StdHeader, CpuEarlyParams);
430         break;
431       case (AP_TASK_HAS_INPUT | AP_TASK_HAS_OUTPUT | AP_PASS_EARLY_PARAMS):
432         ReturnCode = FuncAddress.PfApTaskIOC (InputDataPtr, StdHeader, CpuEarlyParams);
433         break;
434       default:
435         ReturnCode = 0;
436         break;
437       }
438       if (((ApFlags & AP_RETURN_PARAMS) != 0)) {
439         ApUtilTransmitBuffer (SourceSocket, 0, &DataTransferInfo, StdHeader);
440       }
441       if ((ApFlags & AP_TASK_HAS_OUTPUT) != 0) {
442         ApUtilWriteDataDword (ReturnCode, StdHeader);
443       }
444       if ((ApFlags & AP_END_AT_HLT) != 0) {
445         RemoteCmd = CORE_IDLE_HLT;
446       } else {
447         ApUtilWriteControlByte (CORE_IDLE, StdHeader);
448       }
449     }
450     if (RemoteCmd == CORE_IDLE_HLT) {
451       SourceSocket = (UINT8) BscSocket;
452       GetLocalApicIdForCore (SourceSocket, 0, &TargetApicId, StdHeader);
453       ApUtilWriteControlByte (CORE_IDLE_HLT, StdHeader);
454       ExecuteHltInstruction (StdHeader);
455       ApUtilWriteControlByte (CORE_IDLE, StdHeader);
456     }
457   }
458 }
459
460
461 /*---------------------------------------------------------------------------------------*/
462 /**
463  * Reads the 'control byte' on the designated remote core.
464  *
465  * This function will read the current contents of the control byte
466  * on the designated core using the APIC remote read inter-
467  * processor interrupt sequence.
468  *
469  * @param[in]      TargetApicId  Local APIC ID of the desired core
470  * @param[in]      StdHeader     Configuration parameters pointer
471  *
472  * @return         The current value of the remote cores control byte
473  *
474  */
475 UINT8
476 ApUtilReadRemoteControlByte (
477   IN       UINT32 TargetApicId,
478   IN       AMD_CONFIG_PARAMS *StdHeader
479   )
480 {
481   UINT8  ControlByte;
482   UINT32 ApicRegister;
483
484   ApicRegister = ApUtilRemoteRead (TargetApicId, APIC_CTRL_DWORD, StdHeader);
485   ControlByte = (UINT8) ((ApicRegister & APIC_CTRL_MASK) >> APIC_CTRL_SHIFT);
486   return (ControlByte);
487 }
488
489
490 /*---------------------------------------------------------------------------------------*/
491 /**
492  * Writes the 'control byte' on the executing core.
493  *
494  * This function writes data to a local APIC offset used in inter-
495  * processor communication.
496  *
497  * @param[in]       Value
498  * @param[in]       StdHeader
499  *
500  */
501 VOID
502 ApUtilWriteControlByte (
503   IN       UINT8 Value,
504   IN       AMD_CONFIG_PARAMS *StdHeader
505   )
506 {
507   UINT32 ApicRegister;
508
509   ApicRegister = ApUtilLocalRead (APIC_CTRL_REG, StdHeader);
510   ApicRegister = ((ApicRegister & ~APIC_CTRL_MASK) | (UINT32) (Value << APIC_CTRL_SHIFT));
511   ApUtilLocalWrite (APIC_CTRL_REG, ApicRegister, StdHeader);
512 }
513
514
515 /*---------------------------------------------------------------------------------------*/
516 /**
517  * Reads the 'data dword' on the designated remote core.
518  *
519  * This function will read the current contents of the data dword
520  * on the designated core using the APIC remote read inter-
521  * processor interrupt sequence.
522  *
523  * @param[in]      TargetApicId  Local APIC ID of the desired core
524  * @param[in]      StdHeader     Configuration parameters pointer
525  *
526  * @return         The current value of the remote core's data dword
527  *
528  */
529 UINT32
530 ApUtilReadRemoteDataDword (
531   IN       UINT32 TargetApicId,
532   IN       AMD_CONFIG_PARAMS *StdHeader
533   )
534 {
535   return (ApUtilRemoteRead (TargetApicId, APIC_DATA_DWORD, StdHeader));
536 }
537
538
539 /*---------------------------------------------------------------------------------------*/
540 /**
541  * Writes the 'data dword' on the executing core.
542  *
543  * This function writes data to a local APIC offset used in inter-
544  * processor communication.
545  *
546  * @param[in]      Value        Value to write
547  * @param[in]      StdHeader    Configuration parameters pointer
548  *
549  */
550 VOID
551 ApUtilWriteDataDword (
552   IN       UINT32 Value,
553   IN       AMD_CONFIG_PARAMS *StdHeader
554   )
555 {
556   ApUtilLocalWrite (APIC_DATA_REG, Value, StdHeader);
557 }
558
559
560 /*---------------------------------------------------------------------------------------*/
561 /**
562  * Runs the given task on the specified local core.
563  *
564  * This function is used to invoke an AP to run a specified AGESA
565  * procedure.  It can only be called by cores that have subordinate
566  * APs -- the BSC at POST, or any socket-relative core 0s at Early.
567  *
568  * @param[in]      Socket       Socket number of the target core
569  * @param[in]      Core         Core number of the target core
570  * @param[in]      TaskPtr      Function descriptor
571  * @param[in]      StdHeader    Configuration parameters pointer
572  *
573  * @return         Return value of the task that the AP core ran,
574  *                 or zero if the task was VOID.
575  *
576  */
577 UINT32
578 ApUtilRunCodeOnSocketCore (
579   IN       UINT8   Socket,
580   IN       UINT8   Core,
581   IN       AP_TASK *TaskPtr,
582   IN       AMD_CONFIG_PARAMS *StdHeader
583   )
584 {
585   UINT8  CoreId;
586   UINT8  CurrentStatus;
587   UINT8  WaitStatus[3];
588   UINT32 ApFlags;
589   UINT32 ReturnCode;
590   UINT32 TargetApicId;
591   AP_WAIT_FOR_STATUS WaitForStatus;
592
593   ApFlags = 0;
594   ReturnCode = 0;
595
596   CoreId = ApUtilCalculateUniqueId (Socket, Core, StdHeader);
597
598   GetLocalApicIdForCore (Socket, Core, &TargetApicId, StdHeader);
599
600   if (TaskPtr->DataTransfer.DataSizeInDwords != 0) {
601     ApFlags |= AP_TASK_HAS_INPUT;
602     if (((TaskPtr->ExeFlags & RETURN_PARAMS) != 0) &&
603         ((TaskPtr->DataTransfer.DataTransferFlags & DATA_IN_MEMORY) == 0)) {
604       ApFlags |= AP_RETURN_PARAMS;
605     }
606   }
607
608   if ((TaskPtr->ExeFlags & TASK_HAS_OUTPUT) != 0) {
609     ApFlags |= AP_TASK_HAS_OUTPUT;
610   }
611
612   if ((TaskPtr->ExeFlags & END_AT_HLT) != 0) {
613     ApFlags |= AP_END_AT_HLT;
614   }
615
616   if ((TaskPtr->ExeFlags & PASS_EARLY_PARAMS) != 0) {
617     ApFlags |= AP_PASS_EARLY_PARAMS;
618   }
619
620   WaitStatus[0] = CORE_IDLE;
621   WaitStatus[1] = CORE_IDLE_HLT;
622   WaitStatus[2] = CORE_UNAVAILABLE;
623   WaitForStatus.Status = WaitStatus;
624   WaitForStatus.NumberOfElements = 3;
625   WaitForStatus.RetryCount = WAIT_INFINITELY;
626   WaitForStatus.WaitForStatusFlags = WAIT_STATUS_EQUALITY;
627   CurrentStatus = ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
628
629   if (CurrentStatus != CORE_UNAVAILABLE) {
630     ApUtilWriteDataDword (ApFlags, StdHeader);
631     ApUtilWriteControlByte (CoreId, StdHeader);
632
633     if (CurrentStatus == CORE_IDLE_HLT) {
634       ApUtilFireDirectedNmi (TargetApicId, StdHeader);
635     }
636
637     ApUtilTransmitPointer (TargetApicId, (VOID **) &TaskPtr->FuncAddress, StdHeader);
638
639     if ((ApFlags & AP_TASK_HAS_INPUT) != 0) {
640       ApUtilTransmitBuffer (Socket, Core, &TaskPtr->DataTransfer, StdHeader);
641     }
642
643     if ((TaskPtr->ExeFlags & WAIT_FOR_CORE) != 0) {
644       if (((ApFlags & AP_TASK_HAS_INPUT) != 0) &&
645           ((ApFlags & AP_RETURN_PARAMS) != 0) &&
646           ((TaskPtr->DataTransfer.DataTransferFlags & DATA_IN_MEMORY) == 0)) {
647         if (ApUtilReceiveBuffer (Socket, Core, &TaskPtr->DataTransfer, StdHeader) == AGESA_ERROR) {
648           // There is not enough space to put the return data.  This should never occur.  If it
649           // does, this would point to strange heap corruption.
650           IDS_ERROR_TRAP;
651         }
652       }
653
654       ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
655       if ((ApFlags & AP_TASK_HAS_OUTPUT) != 0) {
656         ReturnCode = ApUtilReadRemoteDataDword (TargetApicId, StdHeader);
657       }
658     }
659   } else {
660     ReturnCode = 0;
661   }
662   return (ReturnCode);
663 }
664
665
666 /*---------------------------------------------------------------------------------------*/
667 /**
668  * Waits for a remote core's control byte value to either be equal or
669  * not equal to any number of specified values.
670  *
671  * This function will loop doing remote read IPIs until the remote core's
672  * control byte becomes one of the values in the input array if the input
673  * flags are set for equality.  Otherwise, the loop will continue until
674  * the control byte value is not equal to one of the elements in the
675  * array.  The caller can also specify an iteration count for timeout
676  * purposes.
677  *
678  * @param[in]      TargetApicId   Local APIC ID of the desired core
679  * @param[in]      WaitParamsPtr  Wait parameter structure
680  * @param[in]      StdHeader      Configuration parameteres pointer
681  *
682  * @return         The current value of the remote core's control byte
683  *
684  */
685 UINT8
686 ApUtilWaitForCoreStatus (
687   IN       UINT32 TargetApicId,
688   IN       AP_WAIT_FOR_STATUS *WaitParamsPtr,
689   IN       AMD_CONFIG_PARAMS  *StdHeader
690   )
691 {
692   BOOLEAN  IsEqual;
693   UINT8 CoreStatus;
694   UINT8 i;
695   UINT8 j;
696
697   CoreStatus = 0;
698   for (i = 0; (WaitParamsPtr->RetryCount == WAIT_INFINITELY) ||
699               (i < WaitParamsPtr->RetryCount); ++i) {
700     CoreStatus = ApUtilReadRemoteControlByte (TargetApicId, StdHeader);
701     // Determine whether or not the current remote status is equal
702     // to an element in the array.
703     IsEqual = FALSE;
704     for (j = 0; !IsEqual && j < WaitParamsPtr->NumberOfElements; ++j) {
705       if (CoreStatus == WaitParamsPtr->Status[j]) {
706         IsEqual = TRUE;
707       }
708     }
709     if ((((WaitParamsPtr->WaitForStatusFlags & WAIT_STATUS_EQUALITY) != 0) && IsEqual) ||
710         (((WaitParamsPtr->WaitForStatusFlags & WAIT_STATUS_EQUALITY) == 0) && !IsEqual)) {
711       break;
712     }
713   }
714   return (CoreStatus);
715 }
716
717
718 /*---------------------------------------------------------------------------------------*/
719 /**
720  * Runs the AP task on the executing core.
721  *
722  * @param[in]      TaskPtr      Function descriptor
723  * @param[in]      StdHeader    Configuration parameters pointer
724  * @param[in]      ConfigParams Entry point CPU parameters pointer
725  *
726  * @return         Return value of the task, or zero if the task
727  *                 was VOID.
728  *
729  */
730 UINT32
731 ApUtilTaskOnExecutingCore (
732   IN       AP_TASK *TaskPtr,
733   IN       AMD_CONFIG_PARAMS *StdHeader,
734   IN       VOID *ConfigParams
735   )
736 {
737   UINT32   InvocationOptions;
738   UINT32   ReturnCode;
739
740   ReturnCode = 0;
741   InvocationOptions = 0;
742
743   if (TaskPtr->DataTransfer.DataSizeInDwords != 0) {
744     InvocationOptions |= AP_TASK_HAS_INPUT;
745   }
746   if ((TaskPtr->ExeFlags & TASK_HAS_OUTPUT) != 0) {
747     InvocationOptions |= AP_TASK_HAS_OUTPUT;
748   }
749   if ((TaskPtr->ExeFlags & PASS_EARLY_PARAMS) != 0) {
750     InvocationOptions |= AP_PASS_EARLY_PARAMS;
751   }
752
753   switch (InvocationOptions) {
754   case 0:
755     TaskPtr->FuncAddress.PfApTask (StdHeader);
756     break;
757   case AP_TASK_HAS_INPUT:
758     TaskPtr->FuncAddress.PfApTaskI (TaskPtr->DataTransfer.DataPtr, StdHeader);
759     break;
760   case AP_PASS_EARLY_PARAMS:
761     TaskPtr->FuncAddress.PfApTaskC (StdHeader, ConfigParams);
762     break;
763   case (AP_TASK_HAS_INPUT | AP_PASS_EARLY_PARAMS):
764     TaskPtr->FuncAddress.PfApTaskIC (TaskPtr->DataTransfer.DataPtr, StdHeader, ConfigParams);
765     break;
766   case AP_TASK_HAS_OUTPUT:
767     ReturnCode = TaskPtr->FuncAddress.PfApTaskO (StdHeader);
768     break;
769   case (AP_TASK_HAS_INPUT | AP_TASK_HAS_OUTPUT):
770     ReturnCode = TaskPtr->FuncAddress.PfApTaskIO (TaskPtr->DataTransfer.DataPtr, StdHeader);
771     break;
772   case (AP_TASK_HAS_OUTPUT | AP_PASS_EARLY_PARAMS):
773     ReturnCode = TaskPtr->FuncAddress.PfApTaskOC (StdHeader, ConfigParams);
774     break;
775   case (AP_TASK_HAS_INPUT | AP_TASK_HAS_OUTPUT | AP_PASS_EARLY_PARAMS):
776     ReturnCode = TaskPtr->FuncAddress.PfApTaskIOC (TaskPtr->DataTransfer.DataPtr, StdHeader, ConfigParams);
777     break;
778   default:
779     ReturnCode = 0;
780     break;
781   }
782   return (ReturnCode);
783 }
784
785 /*---------------------------------------------------------------------------------------*/
786 /**
787  * Sets up the AP's IDT with NMI (INT2) being the only valid descriptor
788  *
789  * This function prepares the executing AP core for recovering from a hlt
790  * instruction by initializing its IDTR.
791  *
792  * @param[in]        NmiIdtDescPtr Pointer to a writable IDT entry to
793  *                                 be used for NMIs
794  * @param[in]        StdHeader     Configuration parameters pointer
795  *
796  */
797 VOID
798 STATIC
799 ApUtilSetupIdtForHlt (
800   IN       IDT_DESCRIPTOR *NmiIdtDescPtr,
801   IN       AMD_CONFIG_PARAMS *StdHeader
802   )
803 {
804   UINT8   DescSize;
805   UINT64  HandlerOffset;
806   UINT64  EferRegister;
807   IDT_BASE_LIMIT IdtInfo;
808
809   LibAmdMsrRead (MSR_EXTENDED_FEATURE_EN, &EferRegister, StdHeader);
810   if ((EferRegister & 0x100) != 0) {
811     DescSize = 16;
812   } else {
813     DescSize = 8;
814   }
815
816   HandlerOffset = (UINT64) (UINTN) NmiHandler;
817   NmiIdtDescPtr->OffsetLo = (UINT16) HandlerOffset & 0xFFFF;
818   NmiIdtDescPtr->OffsetHi = (UINT16) (HandlerOffset >> 16);
819   GetCsSelector (&NmiIdtDescPtr->Selector, StdHeader);
820   NmiIdtDescPtr->Flags = IDT_DESC_PRESENT | IDT_DESC_TYPE_INT32;
821   NmiIdtDescPtr->Rsvd = 0;
822   NmiIdtDescPtr->Offset64 = (UINT32) (HandlerOffset >> 32);
823   NmiIdtDescPtr->Rsvd64 = 0;
824   IdtInfo.Limit = (UINT16) ((DescSize * 3) - 1);
825   IdtInfo.Base = (UINT64) (UINTN) NmiIdtDescPtr - (DescSize * 2);
826   IDS_EXCEPTION_TRAP (IDS_IDT_UPDATE_EXCEPTION_VECTOR_FOR_AP, &IdtInfo, StdHeader);
827   SetIdtr (&IdtInfo , StdHeader);
828 }
829
830
831 /*---------------------------------------------------------------------------------------*/
832 /**
833  * Calculate the APIC ID for a given core.
834  *
835  * Get the current node's apic id and deconstruct it to the base id of local apic id space.
836  * Then construct the target's apic id using that base.
837  * @b Assumes: The target Socket and Core exist!
838  * Other Notes:
839  *  - Must run after HT initialization is complete.
840  *  - Code sync: This calculation MUST match the assignment
841  *    calculation done above in LocalApicInitializationAtEarly function.
842  *  - Assumes family homogeneous population of all sockets.
843  *
844  *  @param[in]      TargetSocket   The socket in which the Core's Processor is installed.
845  *  @param[in]      TargetCore     The Core on that Processor
846  *  @param[out]     LocalApicId    Its APIC Id
847  *  @param[in]      StdHeader      Handle to header for library and services.
848  *
849  */
850 VOID
851 GetLocalApicIdForCore (
852   IN       UINT32            TargetSocket,
853   IN       UINT32            TargetCore,
854      OUT   UINT32            *LocalApicId,
855   IN       AMD_CONFIG_PARAMS *StdHeader
856   )
857 {
858   UINT32  CoreIdBits;
859   UINT32  CurrentNode;
860   UINT32  CurrentCore;
861   UINT32  TargetNode;
862   UINT32  MaxCoresInProcessor;
863   UINT32  TotalCores;
864   UINT32  CurrentLocalApicId;
865   UINT64  LocalApicBase;
866   UINT32  TempVar_a;
867   UINT64  Address;
868   UINT32  ProcessorApicIndex;
869   BOOLEAN ReturnResult;
870   CPUID_DATA  CpuidData;
871
872   TargetNode = 0;
873
874   // Get local apic base Address
875   ApUtilGetLocalApicBase (&LocalApicBase, StdHeader);
876   Address = LocalApicBase + APIC_ID_REG;
877
878   LibAmdMemRead (AccessWidth32, Address, &TempVar_a, StdHeader);
879
880   // ApicId [7:0]
881   CurrentLocalApicId = (TempVar_a >> APIC20_ApicId) & 0x000000FF;
882
883   GetCurrentNodeAndCore (&CurrentNode, &CurrentCore, StdHeader);
884   LibAmdCpuidRead (AMD_CPUID_ASIZE_PCCOUNT, &CpuidData, StdHeader);
885   CoreIdBits = (CpuidData.ECX_Reg & 0x0000F000) >> 12;
886   MaxCoresInProcessor = (1 << CoreIdBits);
887
888   // Get the APIC Index of this processor.
889   ProcessorApicIndex = GetProcessorApicIndex (CurrentNode, StdHeader);
890
891   TotalCores = (MaxCoresInProcessor * ProcessorApicIndex) + CurrentCore;
892   CurrentLocalApicId -= TotalCores;
893
894   // Use the Node Id of TargetSocket, Module 0.  No socket transitions are missed or added,
895   // even if the TargetCore is not on Module 0 in that processor and that's all that matters now.
896   ReturnResult = GetNodeId (TargetSocket, 0, (UINT8 *)&TargetNode, StdHeader);
897   ASSERT (ReturnResult);
898
899   // Get the APIC Index of this processor.
900   ProcessorApicIndex = GetProcessorApicIndex (TargetNode, StdHeader);
901
902   CurrentLocalApicId += ((MaxCoresInProcessor * ProcessorApicIndex) + TargetCore);
903   *LocalApicId = CurrentLocalApicId;
904 }
905
906 /*---------------------------------------------------------------------------------------*/
907 /**
908  * Securely passes a buffer to the designated remote core.
909  *
910  * This function uses a sequence of remote reads to transmit a data
911  * buffer, one UINT32 at a time.
912  *
913  * @param[in]      Socket       Socket number of the remote core
914  * @param[in]      Core         Core number of the remote core
915  * @param[in]      BufferInfo   Information about the buffer to pass, and
916  *                              how to pass it
917  * @param[in]      StdHeader    Configuration parameters pointer
918  *
919  */
920 VOID
921 ApUtilTransmitBuffer (
922   IN       UINT8   Socket,
923   IN       UINT8   Core,
924   IN       AP_DATA_TRANSFER  *BufferInfo,
925   IN       AMD_CONFIG_PARAMS *StdHeader
926   )
927 {
928   UINT8  TargetCore;
929   UINT8  MyUniqueId;
930   UINT8  CurrentStatus;
931   UINT32 *CurrentPtr;
932   UINT32 i;
933   UINT32 MyCore;
934   UINT32 MySocket;
935   UINT32 Ignored;
936   UINT32 TargetApicId;
937   AP_WAIT_FOR_STATUS WaitForStatus;
938   AGESA_STATUS IgnoredSts;
939
940   GetLocalApicIdForCore ((UINT32) Socket, (UINT32) Core, &TargetApicId, StdHeader);
941
942   if ((BufferInfo->DataTransferFlags & DATA_IN_MEMORY) != 0) {
943     ApUtilWriteDataDword ((UINT32) 0x00000000, StdHeader);
944   } else {
945     ApUtilWriteDataDword ((UINT32) BufferInfo->DataSizeInDwords, StdHeader);
946   }
947   TargetCore = ApUtilCalculateUniqueId (Socket, Core, StdHeader);
948
949   ApUtilWriteControlByte (TargetCore, StdHeader);
950
951   IdentifyCore (StdHeader, &MySocket, &Ignored, &MyCore, &IgnoredSts);
952
953   MyUniqueId = ApUtilCalculateUniqueId ((UINT8)MySocket, (UINT8)MyCore, StdHeader);
954
955   WaitForStatus.Status = &MyUniqueId;
956   WaitForStatus.NumberOfElements = 1;
957   WaitForStatus.RetryCount = WAIT_INFINITELY;
958   WaitForStatus.WaitForStatusFlags = WAIT_STATUS_EQUALITY;
959
960   ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
961   ApUtilWriteDataDword (BufferInfo->DataTransferFlags, StdHeader);
962
963   ApUtilWriteControlByte (CORE_DATA_FLAGS_READY, StdHeader);
964   WaitForStatus.WaitForStatusFlags = 0;
965   ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
966   if ((BufferInfo->DataTransferFlags & DATA_IN_MEMORY) != 0) {
967     ApUtilTransmitPointer (TargetApicId, (VOID **) &BufferInfo->DataPtr, StdHeader);
968   } else {
969     ApUtilWriteControlByte (CORE_STS_DATA_READY_1, StdHeader);
970     CurrentStatus = CORE_STS_DATA_READY_0;
971     WaitForStatus.Status = &CurrentStatus;
972     WaitForStatus.WaitForStatusFlags = WAIT_STATUS_EQUALITY;
973     ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
974     WaitForStatus.WaitForStatusFlags = 0;
975     CurrentPtr = (UINT32 *) BufferInfo->DataPtr;
976     for (i = 0; i < BufferInfo->DataSizeInDwords; ++i) {
977       ApUtilWriteDataDword (*CurrentPtr++, StdHeader);
978       ApUtilWriteControlByte (CurrentStatus, StdHeader);
979       ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
980       CurrentStatus ^= 0x01;
981     }
982   }
983   ApUtilWriteControlByte (CORE_ACTIVE, StdHeader);
984 }
985
986
987 /*---------------------------------------------------------------------------------------*/
988 /**
989  * Securely receives a buffer from the designated remote core.
990  *
991  * This function uses a sequence of remote reads to receive a data
992  * buffer, one UINT32 at a time.
993  *
994  * @param[in]      Socket       Socket number of the remote core
995  * @param[in]      Core         Core number of the remote core
996  * @param[in]      BufferInfo   Information about where to place the buffer
997  * @param[in]      StdHeader    Configuration parameters pointer
998  *
999  * @retval         AGESA_SUCCESS Transaction was successful
1000  * @retval         AGESA_ALERT   The non-NULL desired location to place
1001  *                               the buffer was not used as the buffer
1002  *                               resides in a shared memory space.  The
1003  *                               input data pointer has changed.
1004  * @retval         AGESA_ERROR   There is not enough room to receive the
1005  *                               buffer.
1006  *
1007  */
1008 AGESA_STATUS
1009 ApUtilReceiveBuffer (
1010   IN       UINT8   Socket,
1011   IN       UINT8   Core,
1012   IN OUT   AP_DATA_TRANSFER  *BufferInfo,
1013   IN       AMD_CONFIG_PARAMS *StdHeader
1014   )
1015 {
1016   UINT8    MyUniqueId;
1017   UINT8    SourceUniqueId;
1018   UINT8    CurrentStatus;
1019   UINT32   i;
1020   UINT32   MySocket;
1021   UINT32   MyCore;
1022   UINT32   Ignored;
1023   UINT32   *CurrentPtr;
1024   UINT32   TransactionSize;
1025   UINT32   TargetApicId;
1026   AGESA_STATUS ReturnStatus;
1027   ALLOCATE_HEAP_PARAMS HeapMalloc;
1028   AP_WAIT_FOR_STATUS WaitForStatus;
1029
1030   ReturnStatus = AGESA_SUCCESS;
1031   IdentifyCore (StdHeader, &MySocket, &Ignored, &MyCore, &ReturnStatus);
1032
1033   MyUniqueId = ApUtilCalculateUniqueId ((UINT8)MySocket, (UINT8)MyCore, StdHeader);
1034
1035   GetLocalApicIdForCore ((UINT32) Socket, (UINT32) Core, &TargetApicId, StdHeader);
1036
1037   WaitForStatus.Status = &MyUniqueId;
1038   WaitForStatus.NumberOfElements = 1;
1039   WaitForStatus.RetryCount = WAIT_INFINITELY;
1040   WaitForStatus.WaitForStatusFlags = WAIT_STATUS_EQUALITY;
1041
1042   ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
1043   TransactionSize = ApUtilReadRemoteDataDword (TargetApicId, StdHeader);
1044
1045   if (BufferInfo->DataPtr == NULL && TransactionSize != 0) {
1046     HeapMalloc.BufferHandle = AMD_CPU_AP_TASKING_HANDLE;
1047     HeapMalloc.Persist = HEAP_LOCAL_CACHE;
1048     // Deallocate the general purpose heap structure, if it exists.  Ignore
1049     // the status in case it does not exist.
1050     HeapDeallocateBuffer (HeapMalloc.BufferHandle, StdHeader);
1051     HeapMalloc.RequestedBufferSize = (TransactionSize * XFER_ELEMENT_SIZE);
1052     if (HeapAllocateBuffer (&HeapMalloc, StdHeader) == AGESA_SUCCESS) {
1053       BufferInfo->DataPtr = (UINT32 *) HeapMalloc.BufferPtr;
1054       BufferInfo->DataSizeInDwords = (UINT16) (HeapMalloc.RequestedBufferSize / XFER_ELEMENT_SIZE);
1055     } else {
1056       BufferInfo->DataSizeInDwords = 0;
1057     }
1058   }
1059
1060   if (TransactionSize <= BufferInfo->DataSizeInDwords) {
1061     SourceUniqueId = ApUtilCalculateUniqueId (Socket, Core, StdHeader);
1062     ApUtilWriteControlByte (SourceUniqueId, StdHeader);
1063     CurrentStatus = CORE_DATA_FLAGS_READY;
1064     WaitForStatus.Status = &CurrentStatus;
1065     ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
1066     BufferInfo->DataTransferFlags =  ApUtilReadRemoteDataDword (TargetApicId, StdHeader);
1067     ApUtilWriteControlByte (CORE_DATA_FLAGS_ACKNOWLEDGE, StdHeader);
1068     if ((BufferInfo->DataTransferFlags & DATA_IN_MEMORY) != 0) {
1069       if (BufferInfo->DataPtr != NULL) {
1070         ReturnStatus = AGESA_ALERT;
1071       }
1072       ApUtilReceivePointer (TargetApicId, (VOID **) &BufferInfo->DataPtr, StdHeader);
1073     } else {
1074       CurrentStatus = CORE_STS_DATA_READY_1;
1075       ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
1076       CurrentStatus = CORE_STS_DATA_READY_0;
1077       ApUtilWriteControlByte (CurrentStatus, StdHeader);
1078       CurrentPtr = BufferInfo->DataPtr;
1079       for (i = 0; i < TransactionSize; ++i) {
1080         ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
1081         *CurrentPtr++ = ApUtilReadRemoteDataDword (TargetApicId, StdHeader);
1082         CurrentStatus ^= 0x01;
1083         ApUtilWriteControlByte (CurrentStatus, StdHeader);
1084       }
1085     }
1086     ApUtilWriteControlByte (CORE_ACTIVE, StdHeader);
1087   } else {
1088     BufferInfo->DataSizeInDwords = (UINT16) TransactionSize;
1089     ReturnStatus = AGESA_ERROR;
1090   }
1091   return (ReturnStatus);
1092 }
1093
1094
1095 VOID
1096 RelinquishControlOfAllAPs (
1097   IN       AMD_CONFIG_PARAMS   *StdHeader
1098   )
1099 {
1100   UINT32        BscSocket;
1101   UINT32        Ignored;
1102   UINT32        BscCoreNum;
1103   UINT32        Core;
1104   UINT32        Socket;
1105   UINT32        NumberOfSockets;
1106   AP_TASK       TaskPtr;
1107   AGESA_STATUS  IgnoredSts;
1108
1109   ASSERT (IsBsp (StdHeader, &IgnoredSts));
1110
1111   TaskPtr.FuncAddress.PfApTask = PerformFinalHalt;
1112   TaskPtr.DataTransfer.DataSizeInDwords = 0;
1113   TaskPtr.ExeFlags = WAIT_FOR_CORE;
1114
1115   IdentifyCore (StdHeader, &BscSocket, &Ignored, &BscCoreNum, &IgnoredSts);
1116   NumberOfSockets = GetPlatformNumberOfSockets ();
1117
1118   for (Socket = 0; Socket < NumberOfSockets; Socket++) {
1119     if (GetActiveCoresInGivenSocket (Socket, &Core, StdHeader)) {
1120       while (Core-- > 0) {
1121         if ((Socket != BscSocket) || (Core != BscCoreNum)) {
1122           ApUtilRunCodeOnSocketCore ((UINT8) Socket, (UINT8) Core, &TaskPtr, StdHeader);
1123         }
1124       }
1125     }
1126   }
1127 }
1128
1129 /*---------------------------------------------------------------------------------------
1130  *                           L O C A L    F U N C T I O N S
1131  *---------------------------------------------------------------------------------------
1132  */
1133
1134 /*---------------------------------------------------------------------------------------*/
1135 /**
1136  * The last AGESA code that an AP performs
1137  *
1138  * This function, run only by APs, breaks down their cache subsystem, sets up
1139  * for memory to be present upon wake (from IBV Init/Startup IPIs), and halts.
1140  *
1141  * @param[in]  StdHeader         Config handle for library and services
1142  *
1143  */
1144 VOID
1145 STATIC
1146 PerformFinalHalt (
1147   IN       AMD_CONFIG_PARAMS *StdHeader
1148   )
1149 {
1150   UINT32 PrimaryCore;
1151   UINT32 HaltFlags;
1152   UINT32 CacheEnDis;
1153   CPU_SPECIFIC_SERVICES *FamilyServices;
1154
1155   GetCpuServicesOfCurrentCore ((CONST CPU_SPECIFIC_SERVICES **)&FamilyServices, StdHeader);
1156   ASSERT (FamilyServices != NULL);
1157   // CacheEnDis is a family specific flag, that lets the code to decide whether to
1158   // keep the cache control bits set or cleared.
1159   CacheEnDis = FamilyServices->InitCacheDisabled;
1160
1161   // Determine if the current core has the primary core role.  The first core to execute
1162   // in each compute unit has the primary role.
1163   PrimaryCore = (UINT32) IsCorePairPrimary (FirstCoreIsComputeUnitPrimary, StdHeader);
1164
1165   // Aggregate the flags for the halt service.
1166   HaltFlags = PrimaryCore | (CacheEnDis << 1);
1167
1168   ApUtilWriteControlByte (CORE_UNAVAILABLE, StdHeader);
1169   ExecuteFinalHltInstruction (HaltFlags, UserOptions.CfgApMtrrSettingsList, StdHeader);
1170 }
1171
1172 /*---------------------------------------------------------------------------------------*/
1173 /**
1174  * Reads the APIC register on the designated remote core.
1175  *
1176  * This function uses the remote read inter-processor interrupt protocol
1177  * to read an APIC register from the remote core
1178  *
1179  * @param[in]        TargetApicId  Local APIC ID of the desired core
1180  * @param[in]        RegAddr       APIC register to read
1181  * @param[in]        StdHeader     Configuration parameters pointer
1182  *
1183  * @return           The current value of the remote core's desired APIC register
1184  *
1185  */
1186 UINT32
1187 STATIC
1188 ApUtilRemoteRead (
1189   IN       UINT32            TargetApicId,
1190   IN       UINT8             RegAddr,
1191   IN       AMD_CONFIG_PARAMS *StdHeader
1192   )
1193 {
1194   UINT32 ApicRegister;
1195   UINT64 ApicBase;
1196   UINT64 ApicAddr;
1197
1198   ApUtilGetLocalApicBase (&ApicBase, StdHeader);
1199   TargetApicId <<= LOCAL_APIC_ID;
1200
1201   do {
1202     ApicAddr = ApicBase + APIC_CMD_HI_REG;
1203     LibAmdMemWrite (AccessWidth32, ApicAddr, &TargetApicId, StdHeader);
1204     ApicAddr = ApicBase + APIC_CMD_LO_REG;
1205     ApicRegister = CMD_REG_TO_READ | (UINT32) RegAddr;
1206     LibAmdMemWrite (AccessWidth32, ApicAddr, &ApicRegister, StdHeader);
1207     do {
1208       LibAmdMemRead (AccessWidth32, ApicAddr, &ApicRegister, StdHeader);
1209     } while ((ApicRegister & CMD_REG_DELIVERY_STATUS) != 0);
1210     while ((ApicRegister & CMD_REG_REMOTE_RD_STS_MSK) == CMD_REG_REMOTE_DELIVERY_PENDING) {
1211       LibAmdMemRead (AccessWidth32, ApicAddr, &ApicRegister, StdHeader);
1212     }
1213   } while ((ApicRegister & CMD_REG_REMOTE_RD_STS_MSK) != CMD_REG_REMOTE_DELIVERY_DONE);
1214   ApicAddr = ApicBase + APIC_REMOTE_READ_REG;
1215   LibAmdMemRead (AccessWidth32, ApicAddr, &ApicRegister, StdHeader);
1216   return (ApicRegister);
1217 }
1218
1219
1220 /*---------------------------------------------------------------------------------------*/
1221 /**
1222  * Writes an APIC register on the executing core.
1223  *
1224  * This function gets the base address of the executing core's local APIC,
1225  * and writes a UINT32 value to a specified offset.
1226  *
1227  * @param[in]      RegAddr      APIC register to write to
1228  * @param[in]      Value        Data to be written to the desired APIC register
1229  * @param[in]      StdHeader    Configuration parameters pointer
1230  *
1231  */
1232 VOID
1233 STATIC
1234 ApUtilLocalWrite (
1235   IN       UINT32 RegAddr,
1236   IN       UINT32 Value,
1237   IN       AMD_CONFIG_PARAMS *StdHeader
1238   )
1239 {
1240   UINT64 ApicAddr;
1241
1242   ApUtilGetLocalApicBase (&ApicAddr, StdHeader);
1243   ApicAddr += RegAddr;
1244
1245   LibAmdMemWrite (AccessWidth32, ApicAddr, &Value, StdHeader);
1246 }
1247
1248
1249 /*---------------------------------------------------------------------------------------*/
1250 /**
1251  * Reads an APIC register on the executing core.
1252  *
1253  * This function gets the base address of the executing core's local APIC,
1254  * and reads a UINT32 value from a specified offset.
1255  *
1256  * @param[in]      RegAddr      APIC register to read from
1257  * @param[in]      StdHeader    Configuration parameters pointer
1258  *
1259  * @return         The current value of the local APIC register
1260  *
1261  */
1262 UINT32
1263 STATIC
1264 ApUtilLocalRead (
1265   IN       UINT32  RegAddr,
1266   IN       AMD_CONFIG_PARAMS *StdHeader
1267   )
1268 {
1269   UINT32 ApicRegister;
1270   UINT64 ApicAddr;
1271
1272   ApUtilGetLocalApicBase (&ApicAddr, StdHeader);
1273   ApicAddr += RegAddr;
1274   LibAmdMemRead (AccessWidth32, ApicAddr, &ApicRegister, StdHeader);
1275
1276   return (ApicRegister);
1277 }
1278
1279
1280 /*---------------------------------------------------------------------------------------*/
1281 /**
1282  * Returns the 64-bit base address of the executing core's local APIC.
1283  *
1284  * This function reads the APICBASE MSR and isolates the programmed address.
1285  *
1286  * @param[out]     ApicBase     Base address
1287  * @param[in]      StdHeader    Configuration parameters pointer
1288  *
1289  */
1290 VOID
1291 STATIC
1292 ApUtilGetLocalApicBase (
1293      OUT   UINT64 *ApicBase,
1294   IN       AMD_CONFIG_PARAMS *StdHeader
1295   )
1296 {
1297   LibAmdMsrRead (MSR_APIC_BAR, ApicBase, StdHeader);
1298   *ApicBase &= LAPIC_BASE_ADDR_MASK;
1299 }
1300
1301
1302 /*---------------------------------------------------------------------------------------*/
1303 /**
1304  * Determines the unique ID of the input Socket/Core.
1305  *
1306  * This routine converts a socket-core combination to to a number
1307  * that will be used to directly address a particular core.  This
1308  * unique value must be less than 128 because we only have a byte
1309  * to use for status.  APIC IDs are not guaranteed to be below
1310  * 128.
1311  *
1312  * @param[in]      Socket       Socket number of the remote core
1313  * @param[in]      Core         Core number of the remote core
1314  * @param[in]      StdHeader    Configuration parameters pointer
1315  *
1316  * @return         The unique ID of the desired core
1317  *
1318  */
1319 UINT8
1320 STATIC
1321 ApUtilCalculateUniqueId (
1322   IN       UINT8 Socket,
1323   IN       UINT8 Core,
1324   IN       AMD_CONFIG_PARAMS *StdHeader
1325   )
1326 {
1327   UINT8 UniqueId;
1328
1329   UniqueId = ((Core << 3) | Socket);
1330   ASSERT ((UniqueId & 0x80) == 0);
1331   return (UniqueId);
1332 }
1333
1334
1335 /*---------------------------------------------------------------------------------------*/
1336 /**
1337  * Wakes up a core from the halted state.
1338  *
1339  * This function sends a directed NMI inter-processor interrupt to
1340  * the input Socket/Core.
1341  *
1342  * @param[in]      TargetApicId    Local APIC ID of the desired core
1343  * @param[in]      StdHeader       Configuration parameters pointer
1344  *
1345  */
1346 VOID
1347 STATIC
1348 ApUtilFireDirectedNmi (
1349   IN       UINT32 TargetApicId,
1350   IN       AMD_CONFIG_PARAMS *StdHeader
1351   )
1352 {
1353   TargetApicId <<= LOCAL_APIC_ID;
1354
1355   ApUtilLocalWrite ((UINT32) APIC_CMD_HI_REG, TargetApicId, StdHeader);
1356   ApUtilLocalWrite ((UINT32) APIC_CMD_LO_REG, (UINT32) CMD_REG_TO_NMI, StdHeader);
1357 }
1358
1359
1360 /*---------------------------------------------------------------------------------------*/
1361 /**
1362  * Securely receives a pointer from the designated remote core.
1363  *
1364  * This function uses a sequence of remote reads to receive a pointer,
1365  * one UINT32 at a time.
1366  *
1367  * @param[in]      TargetApicId  Local APIC ID of the desired core
1368  * @param[out]     ReturnPointer Pointer passed from remote core
1369  * @param[in]      StdHeader     Configuration parameters pointer
1370  *
1371  */
1372 VOID
1373 STATIC
1374 ApUtilReceivePointer (
1375   IN       UINT32 TargetApicId,
1376      OUT   VOID  **ReturnPointer,
1377   IN       AMD_CONFIG_PARAMS *StdHeader
1378   )
1379 {
1380   UINT8   i;
1381   UINT8   WaitStatus;
1382   UINT32  *AddressScratchPtr;
1383   AP_WAIT_FOR_STATUS WaitForStatus;
1384
1385   WaitStatus = CORE_STS_DATA_READY_0;
1386   WaitForStatus.Status = &WaitStatus;
1387   WaitForStatus.NumberOfElements = 1;
1388   WaitForStatus.RetryCount = WAIT_INFINITELY;
1389   AddressScratchPtr = (UINT32 *) ReturnPointer;
1390   for (i = 0; i < SIZE_IN_DWORDS (AddressScratchPtr); ++i) {
1391     ApUtilWriteControlByte (CORE_NEEDS_PTR, StdHeader);
1392     WaitForStatus.WaitForStatusFlags = WAIT_STATUS_EQUALITY;
1393     ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
1394     *AddressScratchPtr++ = ApUtilReadRemoteDataDword (TargetApicId, StdHeader);
1395     ApUtilWriteControlByte (CORE_ACTIVE, StdHeader);
1396     WaitForStatus.WaitForStatusFlags = 0;
1397     ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
1398   }
1399 }
1400
1401
1402 /*---------------------------------------------------------------------------------------*/
1403 /**
1404  * Securely transmits a pointer to the designated remote core.
1405  *
1406  * This function uses a sequence of remote reads to transmit a pointer,
1407  * one UINT32 at a time.
1408  *
1409  * @param[in]      TargetApicId  Local APIC ID of the desired core
1410  * @param[out]     Pointer       Pointer passed from remote core
1411  * @param[in]      StdHeader     Configuration parameters pointer
1412  *
1413  */
1414 VOID
1415 STATIC
1416 ApUtilTransmitPointer (
1417   IN       UINT32 TargetApicId,
1418   IN       VOID  **Pointer,
1419   IN       AMD_CONFIG_PARAMS *StdHeader
1420   )
1421 {
1422   UINT8   i;
1423   UINT8   WaitStatus;
1424   UINT32  *AddressScratchPtr;
1425   AP_WAIT_FOR_STATUS WaitForStatus;
1426
1427   WaitStatus = CORE_NEEDS_PTR;
1428   WaitForStatus.Status = &WaitStatus;
1429   WaitForStatus.NumberOfElements = 1;
1430   WaitForStatus.RetryCount = WAIT_INFINITELY;
1431
1432   AddressScratchPtr = (UINT32 *) Pointer;
1433
1434   for (i = 0; i < SIZE_IN_DWORDS (AddressScratchPtr); i++) {
1435     WaitForStatus.WaitForStatusFlags = WAIT_STATUS_EQUALITY;
1436     ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
1437     ApUtilWriteDataDword (*AddressScratchPtr++, StdHeader);
1438     ApUtilWriteControlByte (CORE_STS_DATA_READY_0, StdHeader);
1439     WaitForStatus.WaitForStatusFlags = 0;
1440     ApUtilWaitForCoreStatus (TargetApicId, &WaitForStatus, StdHeader);
1441     ApUtilWriteControlByte (CORE_ACTIVE, StdHeader);
1442   }
1443 }