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"
25 #include "OptionsIds.h"
26 #include "heapManager.h"
30 #define SB_GPIO_REG01 1
34 #define SB_GPIO_REG24 24
38 #define SB_GPIO_REG27 27
41 STATIC BIOS_CALLOUT_STRUCT BiosCallouts[] =
43 {AGESA_ALLOCATE_BUFFER,
47 {AGESA_DEALLOCATE_BUFFER,
63 {AGESA_READ_SPD_RECOVERY,
71 {AGESA_GNB_PCIE_SLOT_RESET,
75 {AGESA_GET_IDS_INIT_DATA,
79 {AGESA_HOOKBEFORE_DRAM_INIT,
80 BiosHookBeforeDramInit
83 {AGESA_HOOKBEFORE_DRAM_INIT_RECOVERY,
84 BiosHookBeforeDramInitRecovery
87 {AGESA_HOOKBEFORE_DQS_TRAINING,
88 BiosHookBeforeDQSTraining
91 {AGESA_HOOKBEFORE_EXIT_SELF_REF,
92 BiosHookBeforeExitSelfRefresh
96 AGESA_STATUS GetBiosCallout (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
99 AGESA_STATUS CalloutStatus;
100 UINTN CallOutCount = sizeof (BiosCallouts) / sizeof (BiosCallouts [0]);
102 for (i = 0; i < CallOutCount; i++)
104 if (BiosCallouts[i].CalloutName == Func)
110 if(i >= CallOutCount)
112 return AGESA_UNSUPPORTED;
115 CalloutStatus = BiosCallouts[i].CalloutPtr (Func, Data, ConfigPtr);
117 return CalloutStatus;
121 CONST IDS_NV_ITEM IdsData[] =
124 AGESA_IDS_NV_MAIN_PLL_CON,
128 AGESA_IDS_NV_MAIN_PLL_FID_EN,
132 AGESA_IDS_NV_MAIN_PLL_FID,
137 AGESA_IDS_NV_CUSTOM_NB_PSTATE,
140 AGESA_IDS_NV_CUSTOM_NB_P0_DIV_CTRL,
143 AGESA_IDS_NV_CUSTOM_NB_P1_DIV_CTRL,
146 AGESA_IDS_NV_FORCE_NB_PSTATE,
155 #define NUM_IDS_ENTRIES (sizeof (IdsData) / sizeof (IDS_NV_ITEM))
158 AGESA_STATUS BiosGetIdsInitData (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
163 IdsPtr = ((IDS_CALLOUT_STRUCT *) ConfigPtr)->IdsNvPtr;
165 if (Data == IDS_CALLOUT_INIT) {
166 for (i = 0; i < NUM_IDS_ENTRIES; i++) {
167 IdsPtr[i].IdsNvValue = IdsData[i].IdsNvValue;
168 IdsPtr[i].IdsNvId = IdsData[i].IdsNvId;
171 return AGESA_SUCCESS;
175 AGESA_STATUS BiosAllocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
177 UINT32 AvailableHeapSize;
178 UINT8 *BiosHeapBaseAddr;
179 UINT32 CurrNodeOffset;
180 UINT32 PrevNodeOffset;
181 UINT32 FreedNodeOffset;
182 UINT32 BestFitNodeOffset;
183 UINT32 BestFitPrevNodeOffset;
184 UINT32 NextFreeOffset;
185 BIOS_BUFFER_NODE *CurrNodePtr;
186 BIOS_BUFFER_NODE *FreedNodePtr;
187 BIOS_BUFFER_NODE *BestFitNodePtr;
188 BIOS_BUFFER_NODE *BestFitPrevNodePtr;
189 BIOS_BUFFER_NODE *NextFreePtr;
190 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
191 AGESA_BUFFER_PARAMS *AllocParams;
193 AllocParams = ((AGESA_BUFFER_PARAMS *) ConfigPtr);
194 AllocParams->BufferPointer = NULL;
196 AvailableHeapSize = BIOS_HEAP_SIZE - sizeof (BIOS_HEAP_MANAGER);
197 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
198 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
200 if (BiosHeapBasePtr->StartOfAllocatedNodes == 0) {
201 /* First allocation */
202 CurrNodeOffset = sizeof (BIOS_HEAP_MANAGER);
203 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
204 CurrNodePtr->BufferHandle = AllocParams->BufferHandle;
205 CurrNodePtr->BufferSize = AllocParams->BufferLength;
206 CurrNodePtr->NextNodeOffset = 0;
207 AllocParams->BufferPointer = (UINT8 *) CurrNodePtr + sizeof (BIOS_BUFFER_NODE);
209 /* Update the remaining free space */
210 FreedNodeOffset = CurrNodeOffset + CurrNodePtr->BufferSize + sizeof (BIOS_BUFFER_NODE);
211 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
212 FreedNodePtr->BufferSize = AvailableHeapSize - sizeof (BIOS_BUFFER_NODE) - CurrNodePtr->BufferSize;
213 FreedNodePtr->NextNodeOffset = 0;
215 /* Update the offsets for Allocated and Freed nodes */
216 BiosHeapBasePtr->StartOfAllocatedNodes = CurrNodeOffset;
217 BiosHeapBasePtr->StartOfFreedNodes = FreedNodeOffset;
219 /* Find out whether BufferHandle has been allocated on the heap. */
220 /* If it has, return AGESA_BOUNDS_CHK */
221 CurrNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
222 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
224 while (CurrNodeOffset != 0) {
225 CurrNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + CurrNodeOffset);
226 if (CurrNodePtr->BufferHandle == AllocParams->BufferHandle) {
227 return AGESA_BOUNDS_CHK;
229 CurrNodeOffset = CurrNodePtr->NextNodeOffset;
230 /* If BufferHandle has not been allocated on the heap, CurrNodePtr here points
231 to the end of the allocated nodes list.
235 /* Find the node that best fits the requested buffer size */
236 FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
237 PrevNodeOffset = FreedNodeOffset;
238 BestFitNodeOffset = 0;
239 BestFitPrevNodeOffset = 0;
240 while (FreedNodeOffset != 0) {
241 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
242 if (FreedNodePtr->BufferSize >= (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
243 if (BestFitNodeOffset == 0) {
244 /* First node that fits the requested buffer size */
245 BestFitNodeOffset = FreedNodeOffset;
246 BestFitPrevNodeOffset = PrevNodeOffset;
248 /* Find out whether current node is a better fit than the previous nodes */
249 BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
250 if (BestFitNodePtr->BufferSize > FreedNodePtr->BufferSize) {
251 BestFitNodeOffset = FreedNodeOffset;
252 BestFitPrevNodeOffset = PrevNodeOffset;
256 PrevNodeOffset = FreedNodeOffset;
257 FreedNodeOffset = FreedNodePtr->NextNodeOffset;
258 } /* end of while loop */
261 if (BestFitNodeOffset == 0) {
262 /* If we could not find a node that fits the requested buffer */
263 /* size, return AGESA_BOUNDS_CHK */
264 return AGESA_BOUNDS_CHK;
266 BestFitNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitNodeOffset);
267 BestFitPrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + BestFitPrevNodeOffset);
269 /* If BestFitNode is larger than the requested buffer, fragment the node further */
270 if (BestFitNodePtr->BufferSize > (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE))) {
271 NextFreeOffset = BestFitNodeOffset + AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE);
273 NextFreePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextFreeOffset);
274 NextFreePtr->BufferSize = BestFitNodePtr->BufferSize - (AllocParams->BufferLength + sizeof (BIOS_BUFFER_NODE));
275 NextFreePtr->NextNodeOffset = BestFitNodePtr->NextNodeOffset;
277 /* Otherwise, next free node is NextNodeOffset of BestFitNode */
278 NextFreeOffset = BestFitNodePtr->NextNodeOffset;
281 /* If BestFitNode is the first buffer in the list, then update
282 StartOfFreedNodes to reflect the new free node
284 if (BestFitNodeOffset == BiosHeapBasePtr->StartOfFreedNodes) {
285 BiosHeapBasePtr->StartOfFreedNodes = NextFreeOffset;
287 BestFitPrevNodePtr->NextNodeOffset = NextFreeOffset;
290 /* Add BestFitNode to the list of Allocated nodes */
291 CurrNodePtr->NextNodeOffset = BestFitNodeOffset;
292 BestFitNodePtr->BufferSize = AllocParams->BufferLength;
293 BestFitNodePtr->BufferHandle = AllocParams->BufferHandle;
294 BestFitNodePtr->NextNodeOffset = 0;
296 /* Remove BestFitNode from list of Freed nodes */
297 AllocParams->BufferPointer = (UINT8 *) BestFitNodePtr + sizeof (BIOS_BUFFER_NODE);
301 return AGESA_SUCCESS;
304 AGESA_STATUS BiosDeallocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
307 UINT8 *BiosHeapBaseAddr;
308 UINT32 AllocNodeOffset;
309 UINT32 PrevNodeOffset;
310 UINT32 NextNodeOffset;
311 UINT32 FreedNodeOffset;
312 UINT32 EndNodeOffset;
313 BIOS_BUFFER_NODE *AllocNodePtr;
314 BIOS_BUFFER_NODE *PrevNodePtr;
315 BIOS_BUFFER_NODE *FreedNodePtr;
316 BIOS_BUFFER_NODE *NextNodePtr;
317 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
318 AGESA_BUFFER_PARAMS *AllocParams;
320 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
321 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
323 AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
325 /* Find target node to deallocate in list of allocated nodes.
326 Return AGESA_BOUNDS_CHK if the BufferHandle is not found
328 AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
329 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
330 PrevNodeOffset = AllocNodeOffset;
332 while (AllocNodePtr->BufferHandle != AllocParams->BufferHandle) {
333 if (AllocNodePtr->NextNodeOffset == 0) {
334 return AGESA_BOUNDS_CHK;
336 PrevNodeOffset = AllocNodeOffset;
337 AllocNodeOffset = AllocNodePtr->NextNodeOffset;
338 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
341 /* Remove target node from list of allocated nodes */
342 PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
343 PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
345 /* Zero out the buffer, and clear the BufferHandle */
346 LibAmdMemFill ((UINT8 *)AllocNodePtr + sizeof (BIOS_BUFFER_NODE), 0, AllocNodePtr->BufferSize, &(AllocParams->StdHeader));
347 AllocNodePtr->BufferHandle = 0;
348 AllocNodePtr->BufferSize += sizeof (BIOS_BUFFER_NODE);
350 /* Add deallocated node in order to the list of freed nodes */
351 FreedNodeOffset = BiosHeapBasePtr->StartOfFreedNodes;
352 FreedNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + FreedNodeOffset);
354 EndNodeOffset = AllocNodeOffset + AllocNodePtr->BufferSize;
356 if (AllocNodeOffset < FreedNodeOffset) {
357 /* Add to the start of the freed list */
358 if (EndNodeOffset == FreedNodeOffset) {
359 /* If the freed node is adjacent to the first node in the list, concatenate both nodes */
360 AllocNodePtr->BufferSize += FreedNodePtr->BufferSize;
361 AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset;
363 /* Clear the BufferSize and NextNodeOffset of the previous first node */
364 FreedNodePtr->BufferSize = 0;
365 FreedNodePtr->NextNodeOffset = 0;
368 /* Otherwise, add freed node to the start of the list
369 Update NextNodeOffset and BufferSize to include the
370 size of BIOS_BUFFER_NODE
372 AllocNodePtr->NextNodeOffset = FreedNodeOffset;
374 /* Update StartOfFreedNodes to the new first node */
375 BiosHeapBasePtr->StartOfFreedNodes = AllocNodeOffset;
377 /* Traverse list of freed nodes to find where the deallocated node
380 NextNodeOffset = FreedNodeOffset;
381 NextNodePtr = FreedNodePtr;
382 while (AllocNodeOffset > NextNodeOffset) {
383 PrevNodeOffset = NextNodeOffset;
384 if (NextNodePtr->NextNodeOffset == 0) {
387 NextNodeOffset = NextNodePtr->NextNodeOffset;
388 NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
391 /* If deallocated node is adjacent to the next node,
392 concatenate both nodes
394 if (NextNodeOffset == EndNodeOffset) {
395 NextNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + NextNodeOffset);
396 AllocNodePtr->BufferSize += NextNodePtr->BufferSize;
397 AllocNodePtr->NextNodeOffset = NextNodePtr->NextNodeOffset;
399 NextNodePtr->BufferSize = 0;
400 NextNodePtr->NextNodeOffset = 0;
402 /*AllocNodePtr->NextNodeOffset = FreedNodePtr->NextNodeOffset; */
403 AllocNodePtr->NextNodeOffset = NextNodeOffset;
405 /* If deallocated node is adjacent to the previous node,
406 concatenate both nodes
408 PrevNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + PrevNodeOffset);
409 EndNodeOffset = PrevNodeOffset + PrevNodePtr->BufferSize;
410 if (AllocNodeOffset == EndNodeOffset) {
411 PrevNodePtr->NextNodeOffset = AllocNodePtr->NextNodeOffset;
412 PrevNodePtr->BufferSize += AllocNodePtr->BufferSize;
414 AllocNodePtr->BufferSize = 0;
415 AllocNodePtr->NextNodeOffset = 0;
417 PrevNodePtr->NextNodeOffset = AllocNodeOffset;
420 return AGESA_SUCCESS;
423 AGESA_STATUS BiosLocateBuffer (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
425 UINT32 AllocNodeOffset;
426 UINT8 *BiosHeapBaseAddr;
427 BIOS_BUFFER_NODE *AllocNodePtr;
428 BIOS_HEAP_MANAGER *BiosHeapBasePtr;
429 AGESA_BUFFER_PARAMS *AllocParams;
431 AllocParams = (AGESA_BUFFER_PARAMS *) ConfigPtr;
433 BiosHeapBaseAddr = (UINT8 *) BIOS_HEAP_START_ADDRESS;
434 BiosHeapBasePtr = (BIOS_HEAP_MANAGER *) BIOS_HEAP_START_ADDRESS;
436 AllocNodeOffset = BiosHeapBasePtr->StartOfAllocatedNodes;
437 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
439 while (AllocParams->BufferHandle != AllocNodePtr->BufferHandle) {
440 if (AllocNodePtr->NextNodeOffset == 0) {
441 AllocParams->BufferPointer = NULL;
442 AllocParams->BufferLength = 0;
443 return AGESA_BOUNDS_CHK;
445 AllocNodeOffset = AllocNodePtr->NextNodeOffset;
446 AllocNodePtr = (BIOS_BUFFER_NODE *) (BiosHeapBaseAddr + AllocNodeOffset);
450 AllocParams->BufferPointer = (UINT8 *) ((UINT8 *) AllocNodePtr + sizeof (BIOS_BUFFER_NODE));
451 AllocParams->BufferLength = AllocNodePtr->BufferSize;
453 return AGESA_SUCCESS;
457 AGESA_STATUS BiosRunFuncOnAp (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
461 Status = agesawrapper_amdlaterunaptask (Data, ConfigPtr);
465 AGESA_STATUS BiosReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
470 AMD_CONFIG_PARAMS *StdHeader;
473 StdHeader = ConfigPtr;
476 // Perform the RESET based upon the ResetType. In case of
477 // WARM_RESET_WHENVER and COLD_RESET_WHENEVER, the request will go to
478 // AmdResetManager. During the critical condition, where reset is required
479 // immediately, the reset will be invoked directly by writing 0x04 to port
480 // 0xCF9 (Reset Port).
483 case WARM_RESET_WHENEVER:
484 case COLD_RESET_WHENEVER:
487 case WARM_RESET_IMMEDIATELY:
488 case COLD_RESET_IMMEDIATELY:
490 LibAmdIoWrite (AccessWidth8, 0xCf9, &Value, StdHeader);
501 AGESA_STATUS BiosReadSpd (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
504 Status = AmdMemoryReadSPD (Func, Data, (AGESA_READ_SPD_PARAMS *)ConfigPtr);
509 AGESA_STATUS BiosDefaultRet (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
511 return AGESA_UNSUPPORTED;
513 /* Call the host environment interface to provide a user hook opportunity. */
514 AGESA_STATUS BiosHookBeforeDQSTraining (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
516 return AGESA_SUCCESS;
518 /* Call the host environment interface to provide a user hook opportunity. */
519 AGESA_STATUS BiosHookBeforeDramInit (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
523 MEM_DATA_STRUCT *MemData;
532 Status = AGESA_SUCCESS;
533 /* Get SB MMIO Base (AcpiMmioAddr) */
534 WriteIo8 (0xCD6, 0x27);
535 Data8 = ReadIo8(0xCD7);
537 WriteIo8 (0xCD6, 0x26);
538 Data8 = ReadIo8(0xCD7);
540 AcpiMmioAddr = (UINT32)Data16 << 16;
541 GpioMmioAddr = AcpiMmioAddr + GPIO_BASE;
543 switch(MemData->ParameterListPtr->DDR3Voltage){
545 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
546 Data8 &= ~(UINT8)BIT6;
547 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
548 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
549 Data8 |= (UINT8)BIT6;
550 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, Data8);
553 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
554 Data8 &= ~(UINT8)BIT6;
555 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
556 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG179);
557 Data8 &= ~(UINT8)BIT6;
558 Write64Mem8(GpioMmioAddr+SB_GPIO_REG179, Data8);
562 Data8 = Read64Mem8 (GpioMmioAddr+SB_GPIO_REG178);
563 Data8 |= (UINT8)BIT6;
564 Write64Mem8(GpioMmioAddr+SB_GPIO_REG178, Data8);
569 /* Call the host environment interface to provide a user hook opportunity. */
570 AGESA_STATUS BiosHookBeforeDramInitRecovery (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
572 return AGESA_SUCCESS;
574 /* Call the host environment interface to provide a user hook opportunity. */
575 AGESA_STATUS BiosHookBeforeExitSelfRefresh (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
577 return AGESA_SUCCESS;
579 /* PCIE slot reset control */
580 AGESA_STATUS BiosGnbPcieSlotReset (UINT32 Func, UINT32 Data, VOID *ConfigPtr)
584 PCIe_SLOT_RESET_INFO *ResetInfo;
592 ResetInfo = ConfigPtr;
593 // Get SB MMIO Base (AcpiMmioAddr)
594 WriteIo8(0xCD6, 0x27);
595 Data8 = ReadIo8(0xCD7);
597 WriteIo8(0xCD6, 0x26);
598 Data8 = ReadIo8(0xCD7);
600 AcpiMmioAddr = (UINT32)Data16 << 16;
601 Status = AGESA_UNSUPPORTED;
602 GpioMmioAddr = AcpiMmioAddr + GPIO_BASE;
604 if (ResetInfo->ResetControl == DeassertSlotReset) {
605 if (ResetInfo->ResetId & (BIT2+BIT3)) { //de-assert
606 // [GPIO] GPIO45: PE_GPIO1 MXM_POWER_ENABLE, SET HIGH
607 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG45);
609 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG28);
610 while (!(Data8 & BIT7)) {
611 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG28);
613 // GPIO44: PE_GPIO0 MXM Reset
614 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG44);
616 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG44, Data8);
617 Status = AGESA_SUCCESS;
620 Status = AGESA_UNSUPPORTED;
623 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG24);
625 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG24, Data8);
626 //DE-Assert ALL PCIE RESET
628 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG25);
630 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG25, Data8);
632 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG01);
634 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG01, Data8);
636 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG00);
638 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG00, Data8);
640 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG27);
642 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG27, Data8);
644 if (ResetInfo->ResetId & (BIT2+BIT3)) { //Pcie Slot Reset is supported
645 // GPIO44: PE_GPIO0 MXM Reset
646 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG44);
647 Data8 &= ~(UINT8)BIT6;
648 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG44, Data8);
649 Status = AGESA_SUCCESS;
652 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG24);
653 Data8 &= ~(UINT8)BIT6 ;
654 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG24, Data8);
655 //Assert ALL PCIE RESET
657 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG25);
658 Data8 &= ~(UINT8)BIT6;
659 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG25, Data8);
661 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG01);
662 Data8 &= ~(UINT8)BIT6;
663 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG01, Data8);
665 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG00);
666 Data8 &= ~(UINT8)BIT6;
667 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG00, Data8);
669 Data8 = Read64Mem8(GpioMmioAddr+SB_GPIO_REG27);
670 Data8 &= ~(UINT8)BIT6;
671 Write64Mem8 (GpioMmioAddr+SB_GPIO_REG27, Data8);