src/northbridge/amd/pi/agesawrapper.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2012 - 2014 Advanced Micro Devices, Inc.
   5  *
   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.
   9  *
  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.
  14  */
  15
  16 #include <AGESA.h>
  17 #include <cbfs.h>
  18 #include <cpu/amd/pi/s3_resume.h>
  19 #include <cpu/x86/mtrr.h>
  20 #include <cpuRegisters.h>
  21 #include <FchPlatform.h>
  22 #include <heapManager.h>
  23 #include <northbridge/amd/pi/agesawrapper.h>
  24 #include <northbridge/amd/pi/BiosCallOuts.h>
  25
  26 VOID FchInitS3LateRestore (IN FCH_DATA_BLOCK *FchDataPtr);
  27 VOID FchInitS3EarlyRestore (IN FCH_DATA_BLOCK *FchDataPtr);
  28
  29 #define FILECODE UNASSIGNED_FILE_FILECODE
  30
  31 #ifndef __PRE_RAM__
  32 /* ACPI table pointers returned by AmdInitLate */
  33 static void *DmiTable    = NULL;
  34 static void *AcpiPstate  = NULL;
  35 static void *AcpiSrat    = NULL;
  36 static void *AcpiSlit    = NULL;
  37
  38 static void *AcpiWheaMce = NULL;
  39 static void *AcpiWheaCmc = NULL;
  40 static void *AcpiAlib    = NULL;
  41 static void *AcpiIvrs    = NULL;
  42 static void *AcpiCrat    = NULL;
  43 #endif /* #ifndef __PRE_RAM__ */
  44
  45 AGESA_STATUS agesawrapper_amdinitreset(void)
  46 {
  47         AGESA_STATUS status;
  48         AMD_INTERFACE_PARAMS AmdParamStruct;
  49         AMD_RESET_PARAMS AmdResetParams;
  50
  51         LibAmdMemFill (&AmdParamStruct,
  52                        0,
  53                        sizeof (AMD_INTERFACE_PARAMS),
  54                        &(AmdParamStruct.StdHeader));
  55
  56         LibAmdMemFill (&AmdResetParams,
  57                        0,
  58                        sizeof (AMD_RESET_PARAMS),
  59                        &(AmdResetParams.StdHeader));
  60
  61         AmdParamStruct.AgesaFunctionName = AMD_INIT_RESET;
  62         AmdParamStruct.AllocationMethod = ByHost;
  63         AmdParamStruct.NewStructSize = sizeof(AMD_RESET_PARAMS);
  64         AmdParamStruct.NewStructPtr = &AmdResetParams;
  65         AmdParamStruct.StdHeader.AltImageBasePtr = 0;
  66         AmdParamStruct.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
  67         AmdParamStruct.StdHeader.Func = 0;
  68         AmdParamStruct.StdHeader.ImageBasePtr = 0;
  69         AmdCreateStruct (&AmdParamStruct);
  70
  71         AmdResetParams.FchInterface.Xhci0Enable = IS_ENABLED(CONFIG_HUDSON_XHCI_ENABLE);
  72         if (IS_ENABLED(CONFIG_SOUTHBRIDGE_AMD_PI_BOLTON))
  73                 AmdResetParams.FchInterface.Xhci1Enable = TRUE;
  74
  75         AmdResetParams.FchInterface.SataEnable = !((CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3));
  76         AmdResetParams.FchInterface.IdeEnable = (CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3);
  77
  78         status = AmdInitReset(&AmdResetParams);
  79         if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(AmdParamStruct.StdHeader.HeapStatus);
  80         AmdReleaseStruct (&AmdParamStruct);
  81         return status;
  82 }
  83
  84 AGESA_STATUS agesawrapper_amdinitearly(void)
  85 {
  86         AGESA_STATUS status;
  87         AMD_INTERFACE_PARAMS AmdParamStruct;
  88         AMD_EARLY_PARAMS     *AmdEarlyParamsPtr;
  89
  90         LibAmdMemFill (&AmdParamStruct,
  91                        0,
  92                        sizeof (AMD_INTERFACE_PARAMS),
  93                        &(AmdParamStruct.StdHeader));
  94
  95         AmdParamStruct.AgesaFunctionName = AMD_INIT_EARLY;
  96         AmdParamStruct.AllocationMethod = PreMemHeap;
  97         AmdParamStruct.StdHeader.AltImageBasePtr = 0;
  98         AmdParamStruct.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
  99         AmdParamStruct.StdHeader.Func = 0;
 100         AmdParamStruct.StdHeader.ImageBasePtr = 0;
 101         AmdCreateStruct (&AmdParamStruct);
 102
 103         AmdEarlyParamsPtr = (AMD_EARLY_PARAMS *)AmdParamStruct.NewStructPtr;
 104         OemCustomizeInitEarly (AmdEarlyParamsPtr);
 105
 106         AmdEarlyParamsPtr->GnbConfig.PsppPolicy = PsppDisabled;
 107         status = AmdInitEarly ((AMD_EARLY_PARAMS *)AmdParamStruct.NewStructPtr);
 108         if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(AmdParamStruct.StdHeader.HeapStatus);
 109         AmdReleaseStruct (&AmdParamStruct);
 110
 111         return status;
 112 }
 113
 114 AGESA_STATUS agesawrapper_amdinitpost(void)
 115 {
 116         AGESA_STATUS status;
 117         AMD_INTERFACE_PARAMS  AmdParamStruct;
 118         AMD_POST_PARAMS       *PostParams;
 119
 120         LibAmdMemFill (&AmdParamStruct,
 121                        0,
 122                        sizeof (AMD_INTERFACE_PARAMS),
 123                        &(AmdParamStruct.StdHeader));
 124
 125         AmdParamStruct.AgesaFunctionName = AMD_INIT_POST;
 126         AmdParamStruct.AllocationMethod = PreMemHeap;
 127         AmdParamStruct.StdHeader.AltImageBasePtr = NULL;
 128         AmdParamStruct.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 129         AmdParamStruct.StdHeader.Func = 0;
 130         AmdParamStruct.StdHeader.ImageBasePtr = 0;
 131
 132         AmdCreateStruct (&AmdParamStruct);
 133         PostParams = (AMD_POST_PARAMS *)AmdParamStruct.NewStructPtr;
 134
 135         // Do not use IS_ENABLED here.  CONFIG_GFXUMA should always have a value.  Allow
 136         // the compiler to flag the error if CONFIG_GFXUMA is not set.
 137         PostParams->MemConfig.UmaMode = CONFIG_GFXUMA ? UMA_AUTO : UMA_NONE;
 138         PostParams->MemConfig.UmaSize = 0;
 139         PostParams->MemConfig.BottomIo = (UINT16)(0xD0000000 >> 24);
 140         status = AmdInitPost (PostParams);
 141         printk(
 142                         BIOS_SPEW,
 143                         "setup_uma_memory: umamode %s\n",
 144                         (PostParams->MemConfig.UmaMode == UMA_AUTO) ? "UMA_AUTO" :
 145                         (PostParams->MemConfig.UmaMode == UMA_SPECIFIED) ? "UMA_SPECIFIED" :
 146                         (PostParams->MemConfig.UmaMode == UMA_NONE) ? "UMA_NONE" :
 147                         "unknown"
 148         );
 149         printk(
 150                         BIOS_SPEW,
 151                         "setup_uma_memory: syslimit 0x%08llX, bottomio 0x%08lx\n",
 152                         (unsigned long long)(PostParams->MemConfig.SysLimit) << 16,
 153                         (unsigned long)(PostParams->MemConfig.BottomIo) << 16
 154         );
 155         printk(
 156                         BIOS_SPEW,
 157                         "setup_uma_memory: uma size %luMB, uma start 0x%08lx\n",
 158                         (unsigned long)(PostParams->MemConfig.UmaSize) >> (20 - 16),
 159                         (unsigned long)(PostParams->MemConfig.UmaBase) << 16
 160         );
 161
 162         if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(PostParams->StdHeader.HeapStatus);
 163         AmdReleaseStruct (&AmdParamStruct);
 164         /* Initialize heap space */
 165         EmptyHeap();
 166
 167         return status;
 168 }
 169
 170 AGESA_STATUS agesawrapper_amdinitenv(void)
 171 {
 172         AGESA_STATUS status;
 173         AMD_INTERFACE_PARAMS AmdParamStruct;
 174         AMD_ENV_PARAMS       *EnvParam;
 175
 176         LibAmdMemFill (&AmdParamStruct,
 177                        0,
 178                        sizeof (AMD_INTERFACE_PARAMS),
 179                        &(AmdParamStruct.StdHeader));
 180
 181         AmdParamStruct.AgesaFunctionName = AMD_INIT_ENV;
 182         AmdParamStruct.AllocationMethod = PostMemDram;
 183         AmdParamStruct.StdHeader.AltImageBasePtr = 0;
 184         AmdParamStruct.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 185         AmdParamStruct.StdHeader.Func = 0;
 186         AmdParamStruct.StdHeader.ImageBasePtr = 0;
 187         status = AmdCreateStruct (&AmdParamStruct);
 188         EnvParam = (AMD_ENV_PARAMS *)AmdParamStruct.NewStructPtr;
 189
 190         EnvParam->FchInterface.AzaliaController = AzEnable;
 191         EnvParam->FchInterface.SataClass = CONFIG_HUDSON_SATA_MODE;
 192         EnvParam->FchInterface.SataEnable = !((CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3));
 193         EnvParam->FchInterface.IdeEnable = (CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3);
 194         EnvParam->FchInterface.SataIdeMode = (CONFIG_HUDSON_SATA_MODE == 3);
 195         EnvParam->GnbEnvConfiguration.IommuSupport = FALSE;
 196
 197         status = AmdInitEnv (EnvParam);
 198         if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(EnvParam->StdHeader.HeapStatus);
 199         /* Initialize Subordinate Bus Number and Secondary Bus Number
 200          * In platform BIOS this address is allocated by PCI enumeration code
 201          Modify D1F0x18
 202         */
 203
 204         return status;
 205 }
 206
 207 #ifndef __PRE_RAM__
 208 VOID* agesawrapper_getlateinitptr (int pick)
 209 {
 210         switch (pick) {
 211         case PICK_DMI:
 212                 return DmiTable;
 213         case PICK_PSTATE:
 214                 return AcpiPstate;
 215         case PICK_SRAT:
 216                 return AcpiSrat;
 217         case PICK_SLIT:
 218                 return AcpiSlit;
 219         case PICK_WHEA_MCE:
 220                 return AcpiWheaMce;
 221         case PICK_WHEA_CMC:
 222                 return AcpiWheaCmc;
 223         case PICK_ALIB:
 224                 return AcpiAlib;
 225         case PICK_IVRS:
 226                 return AcpiIvrs;
 227         case PICK_CRAT:
 228                 return AcpiCrat;
 229         default:
 230                 return NULL;
 231         }
 232 }
 233 #endif /* #ifndef __PRE_RAM__ */
 234
 235 AGESA_STATUS agesawrapper_amdinitmid(void)
 236 {
 237         AGESA_STATUS status;
 238         AMD_INTERFACE_PARAMS AmdParamStruct;
 239         AMD_MID_PARAMS *MidParam;
 240
 241         /* Enable MMIO on AMD CPU Address Map Controller */
 242         amd_initcpuio ();
 243
 244         LibAmdMemFill (&AmdParamStruct,
 245                        0,
 246                        sizeof (AMD_INTERFACE_PARAMS),
 247                        &(AmdParamStruct.StdHeader));
 248
 249         AmdParamStruct.AgesaFunctionName = AMD_INIT_MID;
 250         AmdParamStruct.AllocationMethod = PostMemDram;
 251         AmdParamStruct.StdHeader.AltImageBasePtr = 0;
 252         AmdParamStruct.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 253         AmdParamStruct.StdHeader.Func = 0;
 254         AmdParamStruct.StdHeader.ImageBasePtr = 0;
 255
 256         AmdCreateStruct (&AmdParamStruct);
 257         MidParam = (AMD_MID_PARAMS *)AmdParamStruct.NewStructPtr;
 258
 259         MidParam->GnbMidConfiguration.iGpuVgaMode = 0;/* 0 iGpuVgaAdapter, 1 iGpuVgaNonAdapter; */
 260         MidParam->GnbMidConfiguration.GnbIoapicAddress = 0xFEC20000;
 261
 262         MidParam->FchInterface.AzaliaController = AzEnable;
 263         MidParam->FchInterface.SataClass = CONFIG_HUDSON_SATA_MODE;
 264         MidParam->FchInterface.SataEnable = !((CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3));
 265         MidParam->FchInterface.IdeEnable = (CONFIG_HUDSON_SATA_MODE == 0) || (CONFIG_HUDSON_SATA_MODE == 3);
 266         MidParam->FchInterface.SataIdeMode = (CONFIG_HUDSON_SATA_MODE == 3);
 267
 268         status = AmdInitMid ((AMD_MID_PARAMS *)AmdParamStruct.NewStructPtr);
 269         if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(AmdParamStruct.StdHeader.HeapStatus);
 270         AmdReleaseStruct (&AmdParamStruct);
 271
 272         return status;
 273 }
 274
 275 #ifndef __PRE_RAM__
 276 AGESA_STATUS agesawrapper_amdinitlate(void)
 277 {
 278         AGESA_STATUS Status;
 279         AMD_INTERFACE_PARAMS AmdParamStruct;
 280         AMD_LATE_PARAMS *AmdLateParams;
 281
 282         LibAmdMemFill (&AmdParamStruct,
 283                        0,
 284                        sizeof (AMD_INTERFACE_PARAMS),
 285                        &(AmdParamStruct.StdHeader));
 286
 287         AmdParamStruct.AgesaFunctionName = AMD_INIT_LATE;
 288         AmdParamStruct.AllocationMethod = PostMemDram;
 289         AmdParamStruct.StdHeader.AltImageBasePtr = 0;
 290         AmdParamStruct.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 291         AmdParamStruct.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
 292         AmdParamStruct.StdHeader.Func = 0;
 293         AmdParamStruct.StdHeader.ImageBasePtr = 0;
 294
 295         /* NOTE: if not call amdcreatestruct, the initializer(AmdInitLateInitializer) would not be called */
 296         AmdCreateStruct(&AmdParamStruct);
 297         AmdLateParams = (AMD_LATE_PARAMS *)AmdParamStruct.NewStructPtr;
 298         Status = AmdInitLate(AmdLateParams);
 299         if (Status != AGESA_SUCCESS) {
 300                 agesawrapper_amdreadeventlog(AmdLateParams->StdHeader.HeapStatus);
 301                 ASSERT(Status == AGESA_SUCCESS);
 302         }
 303
 304         DmiTable    = AmdLateParams->DmiTable;
 305         AcpiPstate  = AmdLateParams->AcpiPState;
 306 #if IS_ENABLED(CONFIG_NORTHBRIDGE_AMD_PI_00630F01) || IS_ENABLED(CONFIG_NORTHBRIDGE_AMD_PI_00730F01)
 307         AcpiSrat    = AmdLateParams->AcpiSrat;
 308         AcpiSlit    = AmdLateParams->AcpiSlit;
 309 #endif
 310
 311         AcpiWheaMce = AmdLateParams->AcpiWheaMce;
 312         AcpiWheaCmc = AmdLateParams->AcpiWheaCmc;
 313         AcpiAlib    = AmdLateParams->AcpiAlib;
 314         AcpiIvrs    = AmdLateParams->AcpiIvrs;
 315         AcpiCrat    = AmdLateParams->AcpiCrat;
 316
 317         printk(BIOS_DEBUG, "DmiTable:%x, AcpiPstatein: %x, AcpiSrat:%x,"
 318                "AcpiSlit:%x, Mce:%x, Cmc:%x,"
 319                "Alib:%x, AcpiIvrs:%x in %s\n",
 320                (unsigned int)DmiTable, (unsigned int)AcpiPstate, (unsigned int)AcpiSrat,
 321                (unsigned int)AcpiSlit, (unsigned int)AcpiWheaMce, (unsigned int)AcpiWheaCmc,
 322                (unsigned int)AcpiAlib, (unsigned int)AcpiIvrs, __func__);
 323
 324         /* AmdReleaseStruct (&AmdParamStruct); */
 325         return Status;
 326 }
 327 #endif /* #ifndef __PRE_RAM__ */
 328
 329 AGESA_STATUS agesawrapper_amdlaterunaptask (
 330         UINT32 Func,
 331         UINT32 Data,
 332         VOID *ConfigPtr
 333         )
 334 {
 335         AGESA_STATUS Status;
 336         AP_EXE_PARAMS ApExeParams;
 337
 338         LibAmdMemFill (&ApExeParams,
 339                        0,
 340                        sizeof (AP_EXE_PARAMS),
 341                        &(ApExeParams.StdHeader));
 342
 343         ApExeParams.StdHeader.AltImageBasePtr = 0;
 344         ApExeParams.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 345         ApExeParams.StdHeader.Func = 0;
 346         ApExeParams.StdHeader.ImageBasePtr = 0;
 347         ApExeParams.FunctionNumber = Func;
 348         ApExeParams.RelatedDataBlock = ConfigPtr;
 349
 350         Status = AmdLateRunApTask (&ApExeParams);
 351         if (Status != AGESA_SUCCESS) {
 352                 /* agesawrapper_amdreadeventlog(); */
 353                 ASSERT(Status == AGESA_SUCCESS);
 354         }
 355
 356         return Status;
 357 }
 358
 359 #if CONFIG_HAVE_ACPI_RESUME
 360
 361 AGESA_STATUS agesawrapper_amdinitresume(void)
 362 {
 363         AGESA_STATUS status;
 364         AMD_INTERFACE_PARAMS AmdParamStruct;
 365         AMD_RESUME_PARAMS     *AmdResumeParamsPtr;
 366         S3_DATA_TYPE            S3DataType;
 367
 368         LibAmdMemFill (&AmdParamStruct,
 369                        0,
 370                        sizeof (AMD_INTERFACE_PARAMS),
 371                        &(AmdParamStruct.StdHeader));
 372
 373         AmdParamStruct.AgesaFunctionName = AMD_INIT_RESUME;
 374         AmdParamStruct.AllocationMethod = PreMemHeap;
 375         AmdParamStruct.StdHeader.AltImageBasePtr = 0;
 376         AmdParamStruct.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 377         AmdParamStruct.StdHeader.Func = 0;
 378         AmdParamStruct.StdHeader.ImageBasePtr = 0;
 379         AmdCreateStruct (&AmdParamStruct);
 380
 381         AmdResumeParamsPtr = (AMD_RESUME_PARAMS *)AmdParamStruct.NewStructPtr;
 382
 383         AmdResumeParamsPtr->S3DataBlock.NvStorageSize = 0;
 384         AmdResumeParamsPtr->S3DataBlock.VolatileStorageSize = 0;
 385         S3DataType = S3DataTypeNonVolatile;
 386         OemAgesaGetS3Info (S3DataType,
 387                            (u32 *) &AmdResumeParamsPtr->S3DataBlock.NvStorageSize,
 388                            (void **) &AmdResumeParamsPtr->S3DataBlock.NvStorage);
 389
 390         status = AmdInitResume ((AMD_RESUME_PARAMS *)AmdParamStruct.NewStructPtr);
 391
 392         if (status != AGESA_SUCCESS) agesawrapper_amdreadeventlog(AmdParamStruct.StdHeader.HeapStatus);
 393         AmdReleaseStruct (&AmdParamStruct);
 394
 395         return status;
 396 }
 397
 398 #ifndef __PRE_RAM__
 399 AGESA_STATUS agesawrapper_fchs3earlyrestore(void)
 400 {
 401         AGESA_STATUS status = AGESA_SUCCESS;
 402
 403         FCH_DATA_BLOCK      FchParams;
 404         AMD_CONFIG_PARAMS StdHeader;
 405
 406         StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
 407         StdHeader.HeapBasePtr = GetHeapBase(&StdHeader) + 0x10;
 408         StdHeader.AltImageBasePtr = 0;
 409         StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 410         StdHeader.Func = 0;
 411         StdHeader.ImageBasePtr = 0;
 412
 413         LibAmdMemFill (&FchParams,
 414                        0,
 415                        sizeof (FchParams),
 416                        &StdHeader);
 417
 418         FchParams.StdHeader = &StdHeader;
 419         s3_resume_init_data(&FchParams);
 420
 421         FchInitS3EarlyRestore(&FchParams);
 422
 423         return status;
 424 }
 425 #endif /* #ifndef __PRE_RAM__ */
 426
 427 AGESA_STATUS agesawrapper_amds3laterestore(void)
 428 {
 429         AGESA_STATUS Status;
 430         AMD_INTERFACE_PARAMS    AmdInterfaceParams;
 431         AMD_S3LATE_PARAMS       AmdS3LateParams;
 432         AMD_S3LATE_PARAMS       *AmdS3LateParamsPtr;
 433         S3_DATA_TYPE          S3DataType;
 434
 435         agesawrapper_amdinitcpuio();
 436         LibAmdMemFill (&AmdS3LateParams,
 437                        0,
 438                        sizeof (AMD_S3LATE_PARAMS),
 439                        &(AmdS3LateParams.StdHeader));
 440         AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
 441         AmdInterfaceParams.AllocationMethod = ByHost;
 442         AmdInterfaceParams.AgesaFunctionName = AMD_S3LATE_RESTORE;
 443         AmdInterfaceParams.NewStructPtr = &AmdS3LateParams;
 444         AmdInterfaceParams.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 445         AmdS3LateParamsPtr = &AmdS3LateParams;
 446         AmdInterfaceParams.NewStructSize = sizeof (AMD_S3LATE_PARAMS);
 447
 448         AmdCreateStruct (&AmdInterfaceParams);
 449
 450         AmdS3LateParamsPtr->S3DataBlock.VolatileStorageSize = 0;
 451         S3DataType = S3DataTypeVolatile;
 452
 453         OemAgesaGetS3Info (S3DataType,
 454                            (u32 *) &AmdS3LateParamsPtr->S3DataBlock.VolatileStorageSize,
 455                            (void **) &AmdS3LateParamsPtr->S3DataBlock.VolatileStorage);
 456
 457         Status = AmdS3LateRestore (AmdS3LateParamsPtr);
 458         if (Status != AGESA_SUCCESS) {
 459                 agesawrapper_amdreadeventlog(AmdInterfaceParams.StdHeader.HeapStatus);
 460                 ASSERT(Status == AGESA_SUCCESS);
 461         }
 462
 463         return Status;
 464 }
 465
 466 #ifndef __PRE_RAM__
 467
 468 AGESA_STATUS agesawrapper_fchs3laterestore(void)
 469 {
 470         AGESA_STATUS status = AGESA_SUCCESS;
 471
 472         AMD_CONFIG_PARAMS       StdHeader;
 473         FCH_DATA_BLOCK          FchParams;
 474
 475         StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
 476         StdHeader.HeapBasePtr = GetHeapBase(&StdHeader) + 0x10;
 477         StdHeader.AltImageBasePtr = 0;
 478         StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 479         StdHeader.Func = 0;
 480         StdHeader.ImageBasePtr = 0;
 481
 482         LibAmdMemFill (&FchParams,
 483                        0,
 484                        sizeof (FchParams),
 485                        &StdHeader);
 486
 487         FchParams.StdHeader = &StdHeader;
 488         s3_resume_init_data(&FchParams);
 489         FchInitS3LateRestore(&FchParams);
 490
 491         /* PIC IRQ routine */
 492         for (byte = 0x0; byte < sizeof(picr_data); byte ++) {
 493                 outb(byte, 0xC00);
 494                 outb(picr_data[byte], 0xC01);
 495         }
 496
 497         /* APIC IRQ routine */
 498         for (byte = 0x0; byte < sizeof(intr_data); byte ++) {
 499                 outb(byte | 0x80, 0xC00);
 500                 outb(intr_data[byte], 0xC01);
 501         }
 502
 503         return status;
 504 }
 505
 506 AGESA_STATUS agesawrapper_amdS3Save(void)
 507 {
 508         AGESA_STATUS Status;
 509         AMD_S3SAVE_PARAMS *AmdS3SaveParamsPtr;
 510         AMD_INTERFACE_PARAMS  AmdInterfaceParams;
 511         S3_DATA_TYPE          S3DataType;
 512
 513         LibAmdMemFill (&AmdInterfaceParams,
 514                        0,
 515                        sizeof (AMD_INTERFACE_PARAMS),
 516                        &(AmdInterfaceParams.StdHeader));
 517
 518         AmdInterfaceParams.StdHeader.ImageBasePtr = 0;
 519         AmdInterfaceParams.StdHeader.HeapStatus = HEAP_SYSTEM_MEM;
 520         AmdInterfaceParams.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 521         AmdInterfaceParams.AllocationMethod = PostMemDram;
 522         AmdInterfaceParams.AgesaFunctionName = AMD_S3_SAVE;
 523         AmdInterfaceParams.StdHeader.AltImageBasePtr = 0;
 524         AmdInterfaceParams.StdHeader.Func = 0;
 525
 526         AmdCreateStruct(&AmdInterfaceParams);
 527         AmdS3SaveParamsPtr = (AMD_S3SAVE_PARAMS *)AmdInterfaceParams.NewStructPtr;
 528         AmdS3SaveParamsPtr->StdHeader = AmdInterfaceParams.StdHeader;
 529
 530         Status = AmdS3Save(AmdS3SaveParamsPtr);
 531         if (Status != AGESA_SUCCESS) {
 532                 agesawrapper_amdreadeventlog(AmdInterfaceParams.StdHeader.HeapStatus);
 533                 ASSERT(Status == AGESA_SUCCESS);
 534         }
 535
 536         S3DataType = S3DataTypeNonVolatile;
 537         printk(BIOS_DEBUG, "NvStorageSize=%x, NvStorage=%x\n",
 538                (unsigned int)AmdS3SaveParamsPtr->S3DataBlock.NvStorageSize,
 539                (unsigned int)AmdS3SaveParamsPtr->S3DataBlock.NvStorage);
 540
 541         Status = OemAgesaSaveS3Info (
 542                 S3DataType,
 543                 AmdS3SaveParamsPtr->S3DataBlock.NvStorageSize,
 544                 AmdS3SaveParamsPtr->S3DataBlock.NvStorage);
 545
 546         printk(BIOS_DEBUG, "VolatileStorageSize=%x, VolatileStorage=%x\n",
 547                (unsigned int)AmdS3SaveParamsPtr->S3DataBlock.VolatileStorageSize,
 548                (unsigned int)AmdS3SaveParamsPtr->S3DataBlock.VolatileStorage);
 549
 550         if (AmdS3SaveParamsPtr->S3DataBlock.VolatileStorageSize != 0) {
 551                 S3DataType = S3DataTypeVolatile;
 552
 553                 Status = OemAgesaSaveS3Info (
 554                         S3DataType,
 555                         AmdS3SaveParamsPtr->S3DataBlock.VolatileStorageSize,
 556                         AmdS3SaveParamsPtr->S3DataBlock.VolatileStorage);
 557         }
 558         OemAgesaSaveMtrr();
 559
 560         AmdReleaseStruct (&AmdInterfaceParams);
 561
 562         return Status;
 563 }
 564
 565 #endif  /* #ifndef __PRE_RAM__ */
 566 #endif  /* CONFIG_HAVE_ACPI_RESUME */
 567
 568 AGESA_STATUS agesawrapper_amdreadeventlog (UINT8 HeapStatus)
 569 {
 570         AGESA_STATUS Status;
 571         EVENT_PARAMS AmdEventParams;
 572
 573         LibAmdMemFill (&AmdEventParams,
 574                        0,
 575                        sizeof (EVENT_PARAMS),
 576                        &(AmdEventParams.StdHeader));
 577
 578         AmdEventParams.StdHeader.AltImageBasePtr = 0;
 579         AmdEventParams.StdHeader.CalloutPtr = (CALLOUT_ENTRY) &GetBiosCallout;
 580         AmdEventParams.StdHeader.Func = 0;
 581         AmdEventParams.StdHeader.ImageBasePtr = 0;
 582         AmdEventParams.StdHeader.HeapStatus = HeapStatus;
 583         Status = AmdReadEventLog (&AmdEventParams);
 584         while (AmdEventParams.EventClass != 0) {
 585                 printk(BIOS_DEBUG,"\nEventLog:  EventClass = %x, EventInfo = %x.\n", (unsigned int)AmdEventParams.EventClass,(unsigned int)AmdEventParams.EventInfo);
 586                 printk(BIOS_DEBUG,"  Param1 = %x, Param2 = %x.\n",(unsigned int)AmdEventParams.DataParam1, (unsigned int)AmdEventParams.DataParam2);
 587                 printk(BIOS_DEBUG,"  Param3 = %x, Param4 = %x.\n",(unsigned int)AmdEventParams.DataParam3, (unsigned int)AmdEventParams.DataParam4);
 588                 Status = AmdReadEventLog (&AmdEventParams);
 589         }
 590
 591         return Status;
 592 }
 593
 594 const void *agesawrapper_locate_module (const CHAR8 name[8])
 595 {
 596         const void* agesa;
 597         const AMD_IMAGE_HEADER* image;
 598         const AMD_MODULE_HEADER* module;
 599         size_t file_size;
 600
 601         agesa = cbfs_boot_map_with_leak((const char *)CONFIG_CBFS_AGESA_NAME,
 602                                         CBFS_TYPE_RAW, &file_size);
 603         if (!agesa)
 604                 return NULL;
 605         image =  LibAmdLocateImage(agesa, agesa + file_size - 1, 4096, name);
 606         module = (AMD_MODULE_HEADER*)image->ModuleInfoOffset;
 607
 608         return module;
 609 }