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]);
85 * printk(BIOS_SPEW,"%s function: %x\n", __func__, (u32) Func);
88 CalloutStatus = AGESA_UNSUPPORTED;
90 for (i = 0; i < CallOutCount; i++) {
91 if (BiosCallouts[i].CalloutName == Func) {
92 CalloutStatus = BiosCallouts[i].CalloutPtr (Func, Data, ConfigPtr);
100 AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
102 UINT32 AvailableHeapSize;
103 UINT8 *BiosHeapBaseAddr;
104 UINT32 CurrNodeOffset;
105 UINT32 PrevNodeOffset;
106 UINT32 FreedNodeOffset;
107 UINT32 BestFitNodeOffset;
108 UINT32 BestFitPrevNodeOffset;
109 UINT32 NextFreeOffset;
110 BIOS_BUFFER_NODE *CurrNodePtr;
111 BIOS_BUFFER_NODE *FreedNodePtr;
112 BIOS_BUFFER_NODE *BestFitNodePtr;
113 BIOS_BUFFER_NODE *BestFitPrevNodePtr;
114 BIOS_BUFFER_NODE *NextFreePtr;
115 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
116 AGESA_BUFFER_PARAMS *AllocParams;
118 AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
119 AllocParams->BufferPointer = NULL;
121 AvailableHeapSize = BIOS_HEAP_SIZE - sizeof (BIOS_HEAP_MANAGER);
122 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
123 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
125 if (BiosHeapBasePtr->StartOfAllocatedNodes == 0) {
126 /* First allocation */
127 CurrNodeOffset = sizeof (BIOS_HEAP_MANAGER);
128 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
129 CurrNodePtr->BufferHandle = AllocParams->BufferHandle;
130 CurrNodePtr->BufferSize = AllocParams->BufferLength;
131 CurrNodePtr->NextNodeOffset = 0;
132 AllocParams->BufferPointer = (UINT8 *) CurrNodePtr + sizeof (BIOS_BUFFER_NODE);
134 /* Update the remaining free space */
135 FreedNodeOffset = CurrNodeOffset + CurrNodePtr->BufferSize + sizeof (BIOS_BUFFER_NODE);
136 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
137 FreedNodePtr->BufferSize = AvailableHeapSize - sizeof (BIOS_BUFFER_NODE) - CurrNodePtr->BufferSize;
138 FreedNodePtr->NextNodeOffset = 0;
140 /* Update the offsets for Allocated and Freed nodes */
141 BiosHeapBasePtr->StartOfAllocatedNodes = CurrNodeOffset;
142 BiosHeapBasePtr->StartOfFreedNodes = FreedNodeOffset;
144 /* Find out whether BufferHandle has been allocated on the heap. */
145 /* If it has, return AGESA_BOUNDS_CHK */
146 CurrNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
147 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
149 while (CurrNodeOffset != 0) {
150 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
151 if (CurrNodePtr->BufferHandle == AllocParams->BufferHandle) {
152 return AGESA_BOUNDS_CHK;
154 CurrNodeOffset = CurrNodePtr->NextNodeOffset;
155 /* If BufferHandle has not been allocated on the heap, CurrNodePtr here points
156 to the end of the allocated nodes list.
160 /* Find the node that best fits the requested buffer size */
161 FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
162 PrevNodeOffset = FreedNodeOffset;
163 BestFitNodeOffset = 0;
164 BestFitPrevNodeOffset = 0;
165 while (FreedNodeOffset != 0) {
166 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
167 if (FreedNodePtr->BufferSize >= (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
168 if (BestFitNodeOffset == 0) {
169 /* First node that fits the requested buffer size */
170 BestFitNodeOffset = FreedNodeOffset;
171 BestFitPrevNodeOffset = PrevNodeOffset;
173 /* Find out whether current node is a better fit than the previous nodes */
174 BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
175 if (BestFitNodePtr->BufferSize > FreedNodePtr->BufferSize) {
176 BestFitNodeOffset = FreedNodeOffset;
177 BestFitPrevNodeOffset = PrevNodeOffset;
181 PrevNodeOffset = FreedNodeOffset;
182 FreedNodeOffset = FreedNodePtr->NextNodeOffset;
183 } /* end of while loop */
186 if (BestFitNodeOffset == 0) {
187 /* If we could not find a node that fits the requested buffer */
188 /* size, return AGESA_BOUNDS_CHK */
189 return AGESA_BOUNDS_CHK;
191 BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
192 BestFitPrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitPrevNodeOffset);
194 /* If BestFitNode is larger than the requested buffer, fragment the node further */
195 if (BestFitNodePtr->BufferSize > (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
196 NextFreeOffset = BestFitNodeOffset + AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE);
198 NextFreePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextFreeOffset);
199 NextFreePtr->BufferSize = BestFitNodePtr->BufferSize - (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE));
200 NextFreePtr->NextNodeOffset = BestFitNodePtr->NextNodeOffset;
202 /* Otherwise, next free node is NextNodeOffset of BestFitNode */
203 NextFreeOffset = BestFitNodePtr->NextNodeOffset;
206 /* If BestFitNode is the first buffer in the list, then update
207 StartOfFreedNodes to reflect the new free node
209 if (BestFitNodeOffset == BiosHeapBasePtr->StartOfFreedNodes) {
210 BiosHeapBasePtr->StartOfFreedNodes = NextFreeOffset;
212 BestFitPrevNodePtr->NextNodeOffset = NextFreeOffset;
215 /* Add BestFitNode to the list of Allocated nodes */
216 CurrNodePtr->NextNodeOffset = BestFitNodeOffset;
217 BestFitNodePtr->BufferSize = AllocParams->BufferLength;
218 BestFitNodePtr->BufferHandle = AllocParams->BufferHandle;
219 BestFitNodePtr->NextNodeOffset = 0;
221 /* Remove BestFitNode from list of Freed nodes */
222 AllocParams->BufferPointer = (UINT8 *) BestFitNodePtr + sizeof (BIOS_BUFFER_NODE);
226 return AGESA_SUCCESS;
229 AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
232 UINT8 *BiosHeapBaseAddr;
233 UINT32 AllocNodeOffset;
234 UINT32 PrevNodeOffset;
235 UINT32 NextNodeOffset;
236 UINT32 FreedNodeOffset;
237 UINT32 EndNodeOffset;
238 BIOS_BUFFER_NODE *AllocNodePtr;
239 BIOS_BUFFER_NODE *PrevNodePtr;
240 BIOS_BUFFER_NODE *FreedNodePtr;
241 BIOS_BUFFER_NODE *NextNodePtr;
242 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
243 AGESA_BUFFER_PARAMS *AllocParams;
245 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
246 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
248 AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
250 /* Find target node to deallocate in list of allocated nodes.
251 Return AGESA_BOUNDS_CHK if the BufferHandle is not found
253 AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
254 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
255 PrevNodeOffset = AllocNodeOffset;
257 while (AllocNodePtr->BufferHandle != AllocParams->BufferHandle) {
258 if (AllocNodePtr->NextNodeOffset == 0) {
259 return AGESA_BOUNDS_CHK;
261 PrevNodeOffset = AllocNodeOffset;
262 AllocNodeOffset = AllocNodePtr->NextNodeOffset;
263 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
266 /* Remove target node from list of allocated nodes */
267 PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
268 PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
270 /* Zero out the buffer, and clear the BufferHandle */
271 LibAmdMemFill ((UINT8 *)AllocNodePtr + sizeof (BIOS_BUFFER_NODE), 0, AllocNodePtr->BufferSize, &(AllocParams->StdHeader));
272 AllocNodePtr->BufferHandle = 0;
273 AllocNodePtr->BufferSize += sizeof (BIOS_BUFFER_NODE);
275 /* Add deallocated node in order to the list of freed nodes */
276 FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
277 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
279 EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize;
281 if (AllocNodeOffset < FreedNodeOffset) {
282 /* Add to the start of the freed list */
283 if (EndNodeOffset == FreedNodeOffset) {
284 /* If the freed node is adjacent to the first node in the list, concatenate both nodes */
285 AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
286 AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
288 /* Clear the BufferSize and NextNodeOffset of the previous first node */
289 FreedNodePtr->BufferSize = 0;
290 FreedNodePtr->NextNodeOffset = 0;
293 /* Otherwise, add freed node to the start of the list
294 Update NextNodeOffset and BufferSize to include the
295 size of BIOS_BUFFER_NODE
297 AllocNodePtr->NextNodeOffset = FreedNodeOffset;
299 /* Update StartOfFreedNodes to the new first node */
300 BiosHeapBasePtr->StartOfFreedNodes = AllocNodeOffset;
302 /* Traverse list of freed nodes to find where the deallocated node
305 NextNodeOffset = FreedNodeOffset;
306 NextNodePtr = FreedNodePtr;
307 while (AllocNodeOffset > NextNodeOffset) {
308 PrevNodeOffset = NextNodeOffset;
309 if (NextNodePtr->NextNodeOffset == 0) {
312 NextNodeOffset = NextNodePtr->NextNodeOffset;
313 NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
316 /* If deallocated node is adjacent to the next node,
317 concatenate both nodes
319 if (NextNodeOffset == EndNodeOffset) {
320 NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
321 AllocNodePtr->BufferSize += NextNodePtr->BufferSize;
322 AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;
324 NextNodePtr->BufferSize = 0;
325 NextNodePtr->NextNodeOffset = 0;
327 /*AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset; */
328 AllocNodePtr->NextNodeOffset = NextNodeOffset;
330 /* If deallocated node is adjacent to the previous node,
331 concatenate both nodes
333 PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
334 EndNodeOffset = PrevNodeOffset + PrevNodePtr->BufferSize;
335 if (AllocNodeOffset == EndNodeOffset) {
336 PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
337 PrevNodePtr->BufferSize += AllocNodePtr->BufferSize;
339 AllocNodePtr->BufferSize = 0;
340 AllocNodePtr->NextNodeOffset = 0;
342 PrevNodePtr->NextNodeOffset = AllocNodeOffset;
345 return AGESA_SUCCESS;
348 AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
350 UINT32 AllocNodeOffset;
351 UINT8 *BiosHeapBaseAddr;
352 BIOS_BUFFER_NODE *AllocNodePtr;
353 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
354 AGESA_BUFFER_PARAMS *AllocParams;
356 AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
358 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
359 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
361 AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
362 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
364 while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
365 if (AllocNodePtr->NextNodeOffset == 0) {
366 AllocParams->BufferPointer = NULL;
367 AllocParams->BufferLength = 0;
368 return AGESA_BOUNDS_CHK;
370 AllocNodeOffset = AllocNodePtr->NextNodeOffset;
371 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
375 AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
376 AllocParams->BufferLength = AllocNodePtr->BufferSize;
378 return AGESA_SUCCESS;
382 AGESA_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
386 Status = agesawrapper_amdlaterunaptask (Func, Data, ConfigPtr);
390 AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
395 AMD_CONFIG_PARAMS *StdHeader;
398 StdHeader = ConfigPtr;
401 // Perform the RESET based upon the ResetType. In case of
402 // WARM_RESET_WHENVER and COLD_RESET_WHENEVER, the request will go to
403 // AmdResetManager. During the critical condition, where reset is required
404 // immediately, the reset will be invoked directly by writing 0x04 to port
405 // 0xCF9 (Reset Port).
408 case WARM_RESET_WHENEVER:
409 case COLD_RESET_WHENEVER:
412 case WARM_RESET_IMMEDIATELY:
413 case COLD_RESET_IMMEDIATELY:
415 LibAmdIoWrite (AccessWidth8, 0xCf9, &Value, StdHeader);
426 AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
429 Status = AmdMemoryReadSPD (Func, Data, (AGESA_READ_SPD_PARAMS *)ConfigPtr);
434 AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
436 return AGESA_UNSUPPORTED;
438 /* Call the host environment interface to provide a user hook opportunity. */
439 AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
441 return AGESA_SUCCESS;
443 /* Call the host environment interface to provide a user hook opportunity. */
444 AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
448 MEM_DATA_STRUCT *MemData;
458 Status = AGESA_SUCCESS;
459 /* Get SB MMIO Base (AcpiMmioAddr) */
460 WriteIo8 (0xCD6, 0x27);
461 Data8 = ReadIo8(0xCD7);
463 WriteIo8 (0xCD6, 0x26);
464 Data8 = ReadIo8(0xCD7);
466 AcpiMmioAddr = (UINT32)Data16 << 16;
467 GpioMmioAddr = AcpiMmioAddr + GPIO_BASE;
469 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG178);
471 TempData8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
474 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, TempData8);
478 TempData8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
481 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, TempData8);
483 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG179);
485 TempData8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
488 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, TempData8);
492 TempData8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
495 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, TempData8);
497 switch(MemData->ParameterListPtr->DDR3Voltage){
499 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
500 Data8 &= ~(UINT8)BIT6;
501 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
502 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
503 Data8 |= (UINT8)BIT6;
504 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, Data8);
507 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
508 Data8 &= ~(UINT8)BIT6;
509 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
510 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
511 Data8 &= ~(UINT8)BIT6;
512 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, Data8);
516 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
517 Data8 |= (UINT8)BIT6;
518 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
519 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
520 Data8 &= ~(UINT8)BIT6;
521 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, Data8);
526 /* Call the host environment interface to provide a user hook opportunity. */
527 AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
529 return AGESA_SUCCESS;
532 /* Call the host environment interface to provide a user hook opportunity. */
533 AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
535 return AGESA_SUCCESS;
537 /* PCIE slot reset control */
538 AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
542 PCIe_SLOT_RESET_INFO *ResetInfo;
550 ResetInfo = ConfigPtr;
551 // Get SB800 MMIO Base (AcpiMmioAddr)
552 WriteIo8(0xCD6, 0x27);
553 Data8 = ReadIo8(0xCD7);
555 WriteIo8(0xCD6, 0x26);
556 Data8 = ReadIo8(0xCD7);
558 AcpiMmioAddr = (UINT32)Data16 << 16;
559 Status = AGESA_UNSUPPORTED;
560 GpioMmioAddr = AcpiMmioAddr + GPIO_BASE;
561 switch (ResetInfo->ResetId)
564 switch (ResetInfo->ResetControl) {
565 case AssertSlotReset:
566 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG21);
567 Data8 &= ~(UINT8)BIT6 ;
568 Write64Mem8(GpioMmioAddr+SB_GPIO_REG21, Data8); // MXM_GPIO0. GPIO21
569 Status = AGESA_SUCCESS;
571 case DeassertSlotReset:
572 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG21);
574 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG21, Data8); // MXM_GPIO0. GPIO21
575 Status = AGESA_SUCCESS;
580 switch (ResetInfo->ResetControl) {
581 case AssertSlotReset:
582 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG25);
583 Data8 &= ~(UINT8)BIT6 ;
584 Write64Mem8(GpioMmioAddr+SB_GPIO_REG25, Data8); // PCIE_RST#_LAN, GPIO25
585 Status = AGESA_SUCCESS;
587 case DeassertSlotReset:
588 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG25);
590 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG25, Data8); // PCIE_RST#_LAN, GPIO25
591 Status = AGESA_SUCCESS;
596 switch (ResetInfo->ResetControl) {
597 case AssertSlotReset:
598 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG02);
599 Data8 &= ~(UINT8)BIT6 ;
600 Write64Mem8(GpioMmioAddr+SB_GPIO_REG02, Data8); // MPCIE_RST0, GPIO02
601 Status = AGESA_SUCCESS;
603 case DeassertSlotReset:
604 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG25);
606 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG02, Data8); // MPCIE_RST0, GPIO02
607 Status = AGESA_SUCCESS;