2 * This file is part of the coreboot project.
4 * Copyright (C) 2011 Advanced Micro Devices, Inc.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 #include "agesawrapper.h"
23 #include "BiosCallOuts.h"
24 #include "heapManager.h"
27 STATIC BIOS_CALLOUT_STRUCT BiosCallouts[] =
29 {AGESA_ALLOCATE_BUFFER,
33 {AGESA_DEALLOCATE_BUFFER,
49 {AGESA_READ_SPD_RECOVERY,
57 {AGESA_GNB_PCIE_SLOT_RESET,
61 {AGESA_HOOKBEFORE_DRAM_INIT,
62 BiosHookBeforeDramInit
65 {AGESA_HOOKBEFORE_DRAM_INIT_RECOVERY,
66 BiosHookBeforeDramInitRecovery
69 {AGESA_HOOKBEFORE_DQS_TRAINING,
70 BiosHookBeforeDQSTraining
73 {AGESA_HOOKBEFORE_EXIT_SELF_REF,
74 BiosHookBeforeExitSelfRefresh
78 AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
81 AGESA_STATUS CalloutStatus;
82 UINTN CallOutCount = sizeof (BiosCallouts) / sizeof (BiosCallouts [0]);
84 CalloutStatus = AGESA_UNSUPPORTED;
86 for (i = 0; i < CallOutCount; i++) {
87 if (BiosCallouts[i].CalloutName == Func) {
88 CalloutStatus = BiosCallouts[i].CalloutPtr (Func, Data, ConfigPtr);
96 AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
98 UINT32 AvailableHeapSize;
99 UINT8 *BiosHeapBaseAddr;
100 UINT32 CurrNodeOffset;
101 UINT32 PrevNodeOffset;
102 UINT32 FreedNodeOffset;
103 UINT32 BestFitNodeOffset;
104 UINT32 BestFitPrevNodeOffset;
105 UINT32 NextFreeOffset;
106 BIOS_BUFFER_NODE *CurrNodePtr;
107 BIOS_BUFFER_NODE *FreedNodePtr;
108 BIOS_BUFFER_NODE *BestFitNodePtr;
109 BIOS_BUFFER_NODE *BestFitPrevNodePtr;
110 BIOS_BUFFER_NODE *NextFreePtr;
111 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
112 AGESA_BUFFER_PARAMS *AllocParams;
114 AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
115 AllocParams->BufferPointer = NULL;
117 AvailableHeapSize = BIOS_HEAP_SIZE - sizeof (BIOS_HEAP_MANAGER);
118 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
119 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
121 if (BiosHeapBasePtr->StartOfAllocatedNodes == 0) {
122 /* First allocation */
123 CurrNodeOffset = sizeof (BIOS_HEAP_MANAGER);
124 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
125 CurrNodePtr->BufferHandle = AllocParams->BufferHandle;
126 CurrNodePtr->BufferSize = AllocParams->BufferLength;
127 CurrNodePtr->NextNodeOffset = 0;
128 AllocParams->BufferPointer = (UINT8 *) CurrNodePtr + sizeof (BIOS_BUFFER_NODE);
130 /* Update the remaining free space */
131 FreedNodeOffset = CurrNodeOffset + CurrNodePtr->BufferSize + sizeof (BIOS_BUFFER_NODE);
132 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
133 FreedNodePtr->BufferSize = AvailableHeapSize - sizeof (BIOS_BUFFER_NODE) - CurrNodePtr->BufferSize;
134 FreedNodePtr->NextNodeOffset = 0;
136 /* Update the offsets for Allocated and Freed nodes */
137 BiosHeapBasePtr->StartOfAllocatedNodes = CurrNodeOffset;
138 BiosHeapBasePtr->StartOfFreedNodes = FreedNodeOffset;
140 /* Find out whether BufferHandle has been allocated on the heap. */
141 /* If it has, return AGESA_BOUNDS_CHK */
142 CurrNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
143 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
145 while (CurrNodeOffset != 0) {
146 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
147 if (CurrNodePtr->BufferHandle == AllocParams->BufferHandle) {
148 return AGESA_BOUNDS_CHK;
150 CurrNodeOffset = CurrNodePtr->NextNodeOffset;
151 /* If BufferHandle has not been allocated on the heap, CurrNodePtr here points
152 to the end of the allocated nodes list.
155 /* Find the node that best fits the requested buffer size */
156 FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
157 PrevNodeOffset = FreedNodeOffset;
158 BestFitNodeOffset = 0;
159 BestFitPrevNodeOffset = 0;
160 while (FreedNodeOffset != 0) {
161 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
162 if (FreedNodePtr->BufferSize >= (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
163 if (BestFitNodeOffset == 0) {
164 /* First node that fits the requested buffer size */
165 BestFitNodeOffset = FreedNodeOffset;
166 BestFitPrevNodeOffset = PrevNodeOffset;
168 /* Find out whether current node is a better fit than the previous nodes */
169 BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
170 if (BestFitNodePtr->BufferSize > FreedNodePtr->BufferSize) {
171 BestFitNodeOffset = FreedNodeOffset;
172 BestFitPrevNodeOffset = PrevNodeOffset;
176 PrevNodeOffset = FreedNodeOffset;
177 FreedNodeOffset = FreedNodePtr->NextNodeOffset;
178 } /* end of while loop */
181 if (BestFitNodeOffset == 0) {
182 /* If we could not find a node that fits the requested buffer */
183 /* size, return AGESA_BOUNDS_CHK */
184 return AGESA_BOUNDS_CHK;
186 BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
187 BestFitPrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitPrevNodeOffset);
189 /* If BestFitNode is larger than the requested buffer, fragment the node further */
190 if (BestFitNodePtr->BufferSize > (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
191 NextFreeOffset = BestFitNodeOffset + AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE);
193 NextFreePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextFreeOffset);
194 NextFreePtr->BufferSize = BestFitNodePtr->BufferSize - (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE));
195 NextFreePtr->NextNodeOffset = BestFitNodePtr->NextNodeOffset;
197 /* Otherwise, next free node is NextNodeOffset of BestFitNode */
198 NextFreeOffset = BestFitNodePtr->NextNodeOffset;
201 /* If BestFitNode is the first buffer in the list, then update
202 StartOfFreedNodes to reflect the new free node
204 if (BestFitNodeOffset == BiosHeapBasePtr->StartOfFreedNodes) {
205 BiosHeapBasePtr->StartOfFreedNodes = NextFreeOffset;
207 BestFitPrevNodePtr->NextNodeOffset = NextFreeOffset;
210 /* Add BestFitNode to the list of Allocated nodes */
211 CurrNodePtr->NextNodeOffset = BestFitNodeOffset;
212 BestFitNodePtr->BufferSize = AllocParams->BufferLength;
213 BestFitNodePtr->BufferHandle = AllocParams->BufferHandle;
214 BestFitNodePtr->NextNodeOffset = 0;
216 /* Remove BestFitNode from list of Freed nodes */
217 AllocParams->BufferPointer = (UINT8 *) BestFitNodePtr + sizeof (BIOS_BUFFER_NODE);
221 return AGESA_SUCCESS;
224 AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
227 UINT8 *BiosHeapBaseAddr;
228 UINT32 AllocNodeOffset;
229 UINT32 PrevNodeOffset;
230 UINT32 NextNodeOffset;
231 UINT32 FreedNodeOffset;
232 UINT32 EndNodeOffset;
233 BIOS_BUFFER_NODE *AllocNodePtr;
234 BIOS_BUFFER_NODE *PrevNodePtr;
235 BIOS_BUFFER_NODE *FreedNodePtr;
236 BIOS_BUFFER_NODE *NextNodePtr;
237 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
238 AGESA_BUFFER_PARAMS *AllocParams;
240 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
241 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
243 AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
245 /* Find target node to deallocate in list of allocated nodes.
246 Return AGESA_BOUNDS_CHK if the BufferHandle is not found
248 AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
249 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
250 PrevNodeOffset = AllocNodeOffset;
252 while (AllocNodePtr->BufferHandle != AllocParams->BufferHandle) {
253 if (AllocNodePtr->NextNodeOffset == 0) {
254 return AGESA_BOUNDS_CHK;
256 PrevNodeOffset = AllocNodeOffset;
257 AllocNodeOffset = AllocNodePtr->NextNodeOffset;
258 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
261 /* Remove target node from list of allocated nodes */
262 PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
263 PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
265 /* Zero out the buffer, and clear the BufferHandle */
266 LibAmdMemFill ((UINT8 *)AllocNodePtr + sizeof (BIOS_BUFFER_NODE), 0, AllocNodePtr->BufferSize, &(AllocParams->StdHeader));
267 AllocNodePtr->BufferHandle = 0;
268 AllocNodePtr->BufferSize += sizeof (BIOS_BUFFER_NODE);
270 /* Add deallocated node in order to the list of freed nodes */
271 FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
272 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
274 EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize;
276 if (AllocNodeOffset < FreedNodeOffset) {
277 /* Add to the start of the freed list */
278 if (EndNodeOffset == FreedNodeOffset) {
279 /* If the freed node is adjacent to the first node in the list, concatenate both nodes */
280 AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
281 AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
283 /* Clear the BufferSize and NextNodeOffset of the previous first node */
284 FreedNodePtr->BufferSize = 0;
285 FreedNodePtr->NextNodeOffset = 0;
287 /* Otherwise, add freed node to the start of the list
288 Update NextNodeOffset and BufferSize to include the
289 size of BIOS_BUFFER_NODE
291 AllocNodePtr->NextNodeOffset = FreedNodeOffset;
293 /* Update StartOfFreedNodes to the new first node */
294 BiosHeapBasePtr->StartOfFreedNodes = AllocNodeOffset;
296 /* Traverse list of freed nodes to find where the deallocated node
299 NextNodeOffset = FreedNodeOffset;
300 NextNodePtr = FreedNodePtr;
301 while (AllocNodeOffset > NextNodeOffset) {
302 PrevNodeOffset = NextNodeOffset;
303 if (NextNodePtr->NextNodeOffset == 0) {
306 NextNodeOffset = NextNodePtr->NextNodeOffset;
307 NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
310 /* If deallocated node is adjacent to the next node,
311 concatenate both nodes
313 if (NextNodeOffset == EndNodeOffset) {
314 NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
315 AllocNodePtr->BufferSize += NextNodePtr->BufferSize;
316 AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;
318 NextNodePtr->BufferSize = 0;
319 NextNodePtr->NextNodeOffset = 0;
321 /*AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset; */
322 AllocNodePtr->NextNodeOffset = NextNodeOffset;
324 /* If deallocated node is adjacent to the previous node,
325 concatenate both nodes
327 PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
328 EndNodeOffset = PrevNodeOffset + PrevNodePtr->BufferSize;
329 if (AllocNodeOffset == EndNodeOffset) {
330 PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
331 PrevNodePtr->BufferSize += AllocNodePtr->BufferSize;
332 AllocNodePtr->BufferSize = 0;
333 AllocNodePtr->NextNodeOffset = 0;
335 PrevNodePtr->NextNodeOffset = AllocNodeOffset;
338 return AGESA_SUCCESS;
341 AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
343 UINT32 AllocNodeOffset;
344 UINT8 *BiosHeapBaseAddr;
345 BIOS_BUFFER_NODE *AllocNodePtr;
346 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
347 AGESA_BUFFER_PARAMS *AllocParams;
349 AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
351 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
352 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
354 AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
355 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
357 while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
358 if (AllocNodePtr->NextNodeOffset == 0) {
359 AllocParams->BufferPointer = NULL;
360 AllocParams->BufferLength = 0;
361 return AGESA_BOUNDS_CHK;
363 AllocNodeOffset = AllocNodePtr->NextNodeOffset;
364 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
368 AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
369 AllocParams->BufferLength = AllocNodePtr->BufferSize;
371 return AGESA_SUCCESS;
375 AGESA_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
379 Status = agesawrapper_amdlaterunaptask (Func, Data, ConfigPtr);
383 AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
388 AMD_CONFIG_PARAMS *StdHeader;
391 StdHeader = ConfigPtr;
394 // Perform the RESET based upon the ResetType. In case of
395 // WARM_RESET_WHENVER and COLD_RESET_WHENEVER, the request will go to
396 // AmdResetManager. During the critical condition, where reset is required
397 // immediately, the reset will be invoked directly by writing 0x04 to port
398 // 0xCF9 (Reset Port).
401 case WARM_RESET_WHENEVER:
402 case COLD_RESET_WHENEVER:
405 case WARM_RESET_IMMEDIATELY:
406 case COLD_RESET_IMMEDIATELY:
408 LibAmdIoWrite (AccessWidth8, 0xCf9, &Value, StdHeader);
419 AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
422 Status = AmdMemoryReadSPD (Func, Data, (AGESA_READ_SPD_PARAMS *)ConfigPtr);
427 AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
429 return AGESA_UNSUPPORTED;
431 /* Call the host environment interface to provide a user hook opportunity. */
432 AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
434 return AGESA_SUCCESS;
436 /* Call the host environment interface to provide a user hook opportunity. */
437 AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
441 MEM_DATA_STRUCT *MemData;
451 Status = AGESA_SUCCESS;
452 /* Get SB MMIO Base (AcpiMmioAddr) */
453 WriteIo8 (0xCD6, 0x27);
454 Data8 = ReadIo8(0xCD7);
456 WriteIo8 (0xCD6, 0x26);
457 Data8 = ReadIo8(0xCD7);
459 AcpiMmioAddr = (UINT32)Data16 << 16;
460 GpioMmioAddr = AcpiMmioAddr + GPIO_BASE;
462 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG178);
464 TempData8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
467 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, TempData8);
471 TempData8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
474 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, TempData8);
476 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG179);
478 TempData8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
481 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, TempData8);
485 TempData8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
488 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, TempData8);
490 switch(MemData->ParameterListPtr->DDR3Voltage){
492 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
493 Data8 &= ~(UINT8)BIT6;
494 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
495 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
496 Data8 |= (UINT8)BIT6;
497 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, Data8);
500 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
501 Data8 &= ~(UINT8)BIT6;
502 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
503 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
504 Data8 &= ~(UINT8)BIT6;
505 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, Data8);
509 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
510 Data8 |= (UINT8)BIT6;
511 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
512 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
513 Data8 &= ~(UINT8)BIT6;
514 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, Data8);
519 /* Call the host environment interface to provide a user hook opportunity. */
520 AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
522 return AGESA_SUCCESS;
525 /* Call the host environment interface to provide a user hook opportunity. */
526 AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
528 return AGESA_SUCCESS;
530 /* PCIE slot reset control */
531 AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
535 PCIe_SLOT_RESET_INFO *ResetInfo;
543 ResetInfo = ConfigPtr;
544 // Get SB800 MMIO Base (AcpiMmioAddr)
545 WriteIo8(0xCD6, 0x27);
546 Data8 = ReadIo8(0xCD7);
548 WriteIo8(0xCD6, 0x26);
549 Data8 = ReadIo8(0xCD7);
551 AcpiMmioAddr = (UINT32)Data16 << 16;
552 Status = AGESA_UNSUPPORTED;
553 GpioMmioAddr = AcpiMmioAddr + GPIO_BASE;
554 switch (ResetInfo->ResetId)
557 switch (ResetInfo->ResetControl) {
558 case AssertSlotReset:
559 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG21);
560 Data8 &= ~(UINT8)BIT6 ;
561 Write64Mem8(GpioMmioAddr+SB_GPIO_REG21, Data8); // MXM_GPIO0. GPIO21
562 Status = AGESA_SUCCESS;
564 case DeassertSlotReset:
565 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG21);
567 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG21, Data8); // MXM_GPIO0. GPIO21
568 Status = AGESA_SUCCESS;
573 switch (ResetInfo->ResetControl) {
574 case AssertSlotReset:
575 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG25);
576 Data8 &= ~(UINT8)BIT6 ;
577 Write64Mem8(GpioMmioAddr+SB_GPIO_REG25, Data8); // PCIE_RST#_LAN, GPIO25
578 Status = AGESA_SUCCESS;
580 case DeassertSlotReset:
581 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG25);
583 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG25, Data8); // PCIE_RST#_LAN, GPIO25
584 Status = AGESA_SUCCESS;
589 switch (ResetInfo->ResetControl) {
590 case AssertSlotReset:
591 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG02);
592 Data8 &= ~(UINT8)BIT6 ;
593 Write64Mem8(GpioMmioAddr+SB_GPIO_REG02, Data8); // MPCIE_RST0, GPIO02
594 Status = AGESA_SUCCESS;
596 case DeassertSlotReset:
597 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG25);
599 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG02, Data8); // MPCIE_RST0, GPIO02
600 Status = AGESA_SUCCESS;