SourceLevelDebugPkg/Library/DebugAgent/SecPeiDebugAgent/SecPeiDebugAgentLib.c

   1 /** @file
   2   SEC Core Debug Agent Library instance implementition.
   3
   4   Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php.
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "SecPeiDebugAgentLib.h"
  16
  17 BOOLEAN  mSkipBreakpoint = FALSE;
  18
  19
  20 EFI_PEI_VECTOR_HANDOFF_INFO_PPI mVectorHandoffInfoPpi = {
  21   &mVectorHandoffInfoDebugAgent[0]
  22 };
  23
  24 //
  25 // Ppis to be installed
  26 //
  27 EFI_PEI_PPI_DESCRIPTOR           mVectorHandoffInfoPpiList[] = {
  28   {
  29     (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  30     &gEfiVectorHandoffInfoPpiGuid,
  31     &mVectorHandoffInfoPpi
  32   }
  33 };
  34
  35 EFI_PEI_NOTIFY_DESCRIPTOR mMemoryDiscoveredNotifyList[1] = {
  36   {
  37     (EFI_PEI_PPI_DESCRIPTOR_NOTIFY_CALLBACK | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
  38     &gEfiPeiMemoryDiscoveredPpiGuid,
  39     DebugAgentCallbackMemoryDiscoveredPpi
  40   }
  41 };
  42
  43 /**
  44   Check if debug agent support multi-processor.
  45
  46   @retval TRUE    Multi-processor is supported.
  47   @retval FALSE   Multi-processor is not supported.
  48
  49 **/
  50 BOOLEAN
  51 MultiProcessorDebugSupport (
  52   VOID
  53   )
  54 {
  55   return FALSE;
  56 }
  57
  58 /**
  59   Read the Attach/Break-in symbols from the debug port.
  60
  61   @param[in]  Handle         Pointer to Debug Port handle.
  62   @param[out] BreakSymbol    Returned break symbol.
  63
  64   @retval EFI_SUCCESS        Read the symbol in BreakSymbol.
  65   @retval EFI_NOT_FOUND      No read the break symbol.
  66
  67 **/
  68 EFI_STATUS
  69 DebugReadBreakSymbol (
  70   IN  DEBUG_PORT_HANDLE      Handle,
  71   OUT UINT8                  *BreakSymbol
  72   )
  73 {
  74   EFI_STATUS                 Status;
  75   DEBUG_PACKET_HEADER        DebugHeader;
  76   UINT8                      *Data8;
  77
  78   *BreakSymbol = 0;
  79   //
  80   // If Debug Port buffer has data, read it till it was break symbol or Debug Port buffer empty.
  81   //
  82   Data8 = (UINT8 *) &DebugHeader;
  83   while (TRUE) {
  84     //
  85     // If start symbol is not received
  86     //
  87     if (!DebugPortPollBuffer (Handle)) {
  88       //
  89       // If no data in Debug Port, exit
  90       //
  91       break;
  92     }
  93     //
  94     // Try to read the start symbol
  95     //
  96     DebugPortReadBuffer (Handle, Data8, 1, 0);
  97     if (*Data8 == DEBUG_STARTING_SYMBOL_ATTACH) {
  98       *BreakSymbol = *Data8;
  99       DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Debug Timer attach symbol received %x", *BreakSymbol);
 100       return EFI_SUCCESS;
 101     }
 102     if (*Data8 == DEBUG_STARTING_SYMBOL_NORMAL) {
 103       Status = ReadRemainingBreakPacket (Handle, &DebugHeader);
 104       if (Status == EFI_SUCCESS) {
 105         *BreakSymbol = DebugHeader.Command;
 106         DebugAgentMsgPrint (DEBUG_AGENT_INFO, "Debug Timer break symbol received %x", *BreakSymbol);
 107         return EFI_SUCCESS;
 108       }
 109       if (Status == EFI_TIMEOUT) {
 110         break;
 111       }
 112     }
 113   }
 114
 115   return EFI_NOT_FOUND;
 116 }
 117
 118 /**
 119   Get the pointer to location saved Mailbox pointer from IDT entry.
 120
 121 **/
 122 VOID *
 123 GetLocationSavedMailboxPointerInIdtEntry (
 124   VOID
 125   )
 126 {
 127   UINTN                     *MailboxLocation;
 128
 129   MailboxLocation = (UINTN *) GetExceptionHandlerInIdtEntry (DEBUG_MAILBOX_VECTOR);
 130   //
 131   // *MailboxLocation is the pointer to Mailbox
 132   //
 133   VerifyMailboxChecksum ((DEBUG_AGENT_MAILBOX *) (*MailboxLocation));
 134   return MailboxLocation;
 135 }
 136
 137 /**
 138   Set the pointer of Mailbox into IDT entry before memory is ready.
 139
 140   @param[in]  MailboxLocation    Pointer to location saved Mailbox pointer.
 141
 142 **/
 143 VOID
 144 SetLocationSavedMailboxPointerInIdtEntry (
 145   IN VOID                  *MailboxLocation
 146   )
 147 {
 148   SetExceptionHandlerInIdtEntry (DEBUG_MAILBOX_VECTOR, MailboxLocation);
 149 }
 150
 151 /**
 152   Get the location of Mailbox pointer from the GUIDed HOB.
 153
 154   @return Pointer to the location saved Mailbox pointer.
 155
 156 **/
 157 UINT64 *
 158 GetMailboxLocationFromHob (
 159   VOID
 160   )
 161 {
 162   EFI_HOB_GUID_TYPE        *GuidHob;
 163
 164   GuidHob = GetFirstGuidHob (&gEfiDebugAgentGuid);
 165   if (GuidHob == NULL) {
 166     return NULL;
 167   }
 168   return (UINT64 *) (GET_GUID_HOB_DATA(GuidHob));
 169 }
 170
 171 /**
 172   Get Debug Agent Mailbox pointer.
 173
 174   @return Mailbox pointer.
 175
 176 **/
 177 DEBUG_AGENT_MAILBOX *
 178 GetMailboxPointer (
 179   VOID
 180   )
 181 {
 182   UINT64               DebugPortHandle;
 183   UINT64               *MailboxLocationInIdt;
 184   UINT64               *MailboxLocationInHob;
 185   DEBUG_AGENT_MAILBOX  *Mailbox;
 186
 187   //
 188   // Get mailbox from IDT entry firstly
 189   //
 190   MailboxLocationInIdt = GetLocationSavedMailboxPointerInIdtEntry ();
 191   Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocationInIdt);
 192   //
 193   // Cannot used GetDebugFlag() to get Debug Flag to avoid GetMailboxPointer() nested
 194   //
 195   if (Mailbox->DebugFlag.Bits.CheckMailboxInHob != 1 ||
 196       Mailbox->DebugFlag.Bits.InitArch != DEBUG_ARCH_SYMBOL) {
 197     //
 198     // If mailbox was setup in SEC or the current CPU arch is different from the init arch
 199     // Debug Agent initialized, return the mailbox from IDT entry directly.
 200     // Otherwise, we need to check the mailbox location saved in GUIDed HOB further.
 201     //
 202     return Mailbox;
 203   }
 204
 205   MailboxLocationInHob = GetMailboxLocationFromHob ();
 206   //
 207   // Compare mailbox in IDT enry with mailbox in HOB,
 208   // need to fix mailbox location if HOB moved by PEI CORE
 209   //
 210   if (MailboxLocationInHob != MailboxLocationInIdt && MailboxLocationInHob != NULL) {
 211     Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocationInHob);
 212     //
 213     // Fix up Debug Port handler and save new mailbox in IDT entry
 214     //
 215     Mailbox = (DEBUG_AGENT_MAILBOX *)((UINTN)Mailbox + ((UINTN)(MailboxLocationInHob) - (UINTN)MailboxLocationInIdt));
 216     DebugPortHandle = (UINT64)((UINTN)Mailbox->DebugPortHandle + ((UINTN)(MailboxLocationInHob) - (UINTN)MailboxLocationInIdt));
 217     UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle);
 218     *MailboxLocationInHob = (UINT64)(UINTN)Mailbox;
 219     SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationInHob);
 220     //
 221     // Clean CheckMailboxInHob flag
 222     //
 223     Mailbox->DebugFlag.Bits.CheckMailboxInHob = 0;
 224     UpdateMailboxChecksum (Mailbox);
 225   }
 226
 227   return Mailbox;
 228 }
 229
 230 /**
 231   Get debug port handle.
 232
 233   @return Debug port handle.
 234
 235 **/
 236 DEBUG_PORT_HANDLE
 237 GetDebugPortHandle (
 238   VOID
 239   )
 240 {
 241   DEBUG_AGENT_MAILBOX    *DebugAgentMailbox;
 242
 243   DebugAgentMailbox = GetMailboxPointer ();
 244
 245   return (DEBUG_PORT_HANDLE) (UINTN)(DebugAgentMailbox->DebugPortHandle);
 246 }
 247
 248 /**
 249   Debug Agent provided notify callback function on Memory Discovered PPI.
 250
 251   @param[in] PeiServices      Indirect reference to the PEI Services Table.
 252   @param[in] NotifyDescriptor Address of the notification descriptor data structure.
 253   @param[in] Ppi              Address of the PPI that was installed.
 254
 255   @retval EFI_SUCCESS If the function completed successfully.
 256
 257 **/
 258 EFI_STATUS
 259 EFIAPI
 260 DebugAgentCallbackMemoryDiscoveredPpi (
 261   IN EFI_PEI_SERVICES                     **PeiServices,
 262   IN EFI_PEI_NOTIFY_DESCRIPTOR            *NotifyDescriptor,
 263   IN VOID                                 *Ppi
 264   )
 265 {
 266   EFI_STATUS                     Status;
 267   DEBUG_AGENT_MAILBOX            *Mailbox;
 268   BOOLEAN                        InterruptStatus;
 269   EFI_PHYSICAL_ADDRESS           Address;
 270   DEBUG_AGENT_MAILBOX            *NewMailbox;
 271   UINT64                         *MailboxLocationInHob;
 272
 273   //
 274   // Save and disable original interrupt status
 275   //
 276   InterruptStatus = SaveAndDisableInterrupts ();
 277
 278   //
 279   // Allocate ACPI NVS memory for new Mailbox and Debug Port Handle buffer
 280   //
 281   Status = PeiServicesAllocatePages (
 282              EfiACPIMemoryNVS,
 283              EFI_SIZE_TO_PAGES (sizeof(DEBUG_AGENT_MAILBOX) + PcdGet16(PcdDebugPortHandleBufferSize)),
 284              &Address
 285              );
 286   ASSERT_EFI_ERROR (Status);
 287   NewMailbox = (DEBUG_AGENT_MAILBOX *) (UINTN) Address;
 288   //
 289   // Copy Mailbox and Debug Port Handle buffer to new location in ACPI NVS memory, because original Mailbox
 290   // and Debug Port Handle buffer in the allocated pool that may be marked as free by DXE Core after DXE Core
 291   // reallocates the HOB.
 292   //
 293   Mailbox = GetMailboxPointer ();
 294   CopyMem (NewMailbox, Mailbox, sizeof (DEBUG_AGENT_MAILBOX));
 295   CopyMem (NewMailbox + 1, (VOID *)(UINTN)Mailbox->DebugPortHandle, PcdGet16(PcdDebugPortHandleBufferSize));
 296   //
 297   // Update Mailbox Location pointer in GUIDed HOB and IDT entry with new one
 298   //
 299   MailboxLocationInHob = GetMailboxLocationFromHob ();
 300   ASSERT (MailboxLocationInHob != NULL);
 301   *MailboxLocationInHob = (UINT64)(UINTN)NewMailbox;
 302   SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationInHob);
 303   //
 304   // Update Debug Port Handle in new Mailbox
 305   //
 306   UpdateMailboxContent (NewMailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, (UINT64)(UINTN)(NewMailbox + 1));
 307   //
 308   // Set physical memory ready flag
 309   //
 310   SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);
 311
 312   if (IsHostAttached ()) {
 313     //
 314     // Trigger one software interrupt to inform HOST
 315     //
 316     TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);
 317   }
 318
 319   //
 320   // Restore interrupt state.
 321   //
 322   SetInterruptState (InterruptStatus);
 323
 324   return EFI_SUCCESS;
 325 }
 326
 327 /**
 328   Initialize debug agent.
 329
 330   This function is used to set up debug environment for SEC and PEI phase.
 331
 332   If InitFlag is DEBUG_AGENT_INIT_PREMEM_SEC, it will overirde IDT table entries
 333   and initialize debug port. It will enable interrupt to support break-in feature.
 334   It will set up debug agent Mailbox in cache-as-ramfrom. It will be called before
 335   physical memory is ready.
 336   If InitFlag is DEBUG_AGENT_INIT_POSTMEM_SEC, debug agent will build one GUIDed
 337   HOB to copy debug agent Mailbox. It will be called after physical memory is ready.
 338
 339   This function is used to set up debug environment to support source level debugging.
 340   If certain Debug Agent Library instance has to save some private data in the stack,
 341   this function must work on the mode that doesn't return to the caller, then
 342   the caller needs to wrap up all rest of logic after InitializeDebugAgent() into one
 343   function and pass it into InitializeDebugAgent(). InitializeDebugAgent() is
 344   responsible to invoke the passing-in function at the end of InitializeDebugAgent().
 345
 346   If the parameter Function is not NULL, Debug Agent Libary instance will invoke it by
 347   passing in the Context to be its parameter.
 348
 349   If Function() is NULL, Debug Agent Library instance will return after setup debug
 350   environment.
 351
 352   @param[in] InitFlag     Init flag is used to decide the initialize process.
 353   @param[in] Context      Context needed according to InitFlag; it was optional.
 354   @param[in] Function     Continue function called by debug agent library; it was
 355                           optional.
 356
 357 **/
 358 VOID
 359 EFIAPI
 360 InitializeDebugAgent (
 361   IN UINT32                InitFlag,
 362   IN VOID                  *Context, OPTIONAL
 363   IN DEBUG_AGENT_CONTINUE  Function  OPTIONAL
 364   )
 365 {
 366   DEBUG_AGENT_MAILBOX              *Mailbox;
 367   DEBUG_AGENT_MAILBOX              *NewMailbox;
 368   DEBUG_AGENT_MAILBOX              MailboxInStack;
 369   DEBUG_AGENT_PHASE2_CONTEXT       Phase2Context;
 370   DEBUG_AGENT_CONTEXT_POSTMEM_SEC  *DebugAgentContext;
 371   EFI_STATUS                       Status;
 372   IA32_DESCRIPTOR                  *Ia32Idtr;
 373   IA32_IDT_ENTRY                   *Ia32IdtEntry;
 374   UINT64                           DebugPortHandle;
 375   UINT64                           MailboxLocation;
 376   UINT64                           *MailboxLocationPointer;
 377   EFI_PHYSICAL_ADDRESS             Address;
 378
 379   DisableInterrupts ();
 380
 381   switch (InitFlag) {
 382
 383   case DEBUG_AGENT_INIT_PREMEM_SEC:
 384
 385     InitializeDebugIdt ();
 386
 387     MailboxLocation = (UINT64)(UINTN)&MailboxInStack;
 388     Mailbox = &MailboxInStack;
 389     ZeroMem ((VOID *) Mailbox, sizeof (DEBUG_AGENT_MAILBOX));
 390     //
 391     // Get and save debug port handle and set the length of memory block.
 392     //
 393     SetLocationSavedMailboxPointerInIdtEntry (&MailboxLocation);
 394     //
 395     // Force error message could be printed during the first shakehand between Target/HOST.
 396     //
 397     SetDebugFlag (DEBUG_AGENT_FLAG_PRINT_ERROR_LEVEL, DEBUG_AGENT_ERROR);
 398     //
 399     // Save init arch type when debug agent initialized
 400     //
 401     SetDebugFlag (DEBUG_AGENT_FLAG_INIT_ARCH, DEBUG_ARCH_SYMBOL);
 402
 403     InitializeDebugTimer ();
 404
 405     Phase2Context.InitFlag = InitFlag;
 406     Phase2Context.Context  = Context;
 407     Phase2Context.Function = Function;
 408     DebugPortInitialize ((VOID *) &Phase2Context, InitializeDebugAgentPhase2);
 409     //
 410     // If reaches here, it means Debug Port initialization failed.
 411     //
 412     DEBUG ((EFI_D_ERROR, "Debug Agent: Debug port initialization failed.\n"));
 413
 414     break;
 415
 416   case DEBUG_AGENT_INIT_POSTMEM_SEC:
 417     Mailbox = GetMailboxPointer ();
 418     //
 419     // Memory has been ready
 420     //
 421     SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);
 422     if (IsHostAttached ()) {
 423       //
 424       // Trigger one software interrupt to inform HOST
 425       //
 426       TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);
 427     }
 428     //
 429     // Install Vector Handoff Info PPI to persist vectors used by Debug Agent
 430     //
 431     Status = PeiServicesInstallPpi (&mVectorHandoffInfoPpiList[0]);
 432     if (EFI_ERROR (Status)) {
 433       DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to install Vector Handoff Info PPI!\n"));
 434       CpuDeadLoop ();
 435     }
 436     //
 437     // Fix up Debug Port handle address and mailbox address
 438     //
 439     DebugAgentContext = (DEBUG_AGENT_CONTEXT_POSTMEM_SEC *) Context;
 440     if (DebugAgentContext != NULL) {
 441       DebugPortHandle = (UINT64)(UINT32)(Mailbox->DebugPortHandle + DebugAgentContext->StackMigrateOffset);
 442       UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle);
 443       Mailbox = (DEBUG_AGENT_MAILBOX *) ((UINTN) Mailbox + DebugAgentContext->StackMigrateOffset);
 444       MailboxLocation = (UINT64)(UINTN)Mailbox;
 445       //
 446       // Build mailbox location in HOB and fix-up its address
 447       //
 448       MailboxLocationPointer = BuildGuidDataHob (
 449                                  &gEfiDebugAgentGuid,
 450                                  &MailboxLocation,
 451                                  sizeof (UINT64)
 452                                  );
 453       MailboxLocationPointer = (UINT64 *) ((UINTN) MailboxLocationPointer + DebugAgentContext->HeapMigrateOffset);
 454     } else {
 455       //
 456       // DebugAgentContext is NULL. Then, Mailbox can directly be copied into memory.
 457       // Allocate ACPI NVS memory for new Mailbox and Debug Port Handle buffer
 458       //
 459       Status = PeiServicesAllocatePages (
 460                  EfiACPIMemoryNVS,
 461                  EFI_SIZE_TO_PAGES (sizeof(DEBUG_AGENT_MAILBOX) + PcdGet16(PcdDebugPortHandleBufferSize)),
 462                  &Address
 463                  );
 464       if (EFI_ERROR (Status)) {
 465         DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to allocate pages!\n"));
 466         CpuDeadLoop ();
 467       }
 468       NewMailbox = (DEBUG_AGENT_MAILBOX *) (UINTN) Address;
 469       //
 470       // Copy Mailbox and Debug Port Handle buffer to new location in ACPI NVS memory, because original Mailbox
 471       // and Debug Port Handle buffer in the allocated pool that may be marked as free by DXE Core after DXE Core
 472       // reallocates the HOB.
 473       //
 474       CopyMem (NewMailbox, Mailbox, sizeof (DEBUG_AGENT_MAILBOX));
 475       CopyMem (NewMailbox + 1, (VOID *)(UINTN)Mailbox->DebugPortHandle, PcdGet16(PcdDebugPortHandleBufferSize));
 476       UpdateMailboxContent (NewMailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, (UINT64)(UINTN)(NewMailbox + 1));
 477       MailboxLocation = (UINT64)(UINTN)NewMailbox;
 478       //
 479       // Build mailbox location in HOB
 480       //
 481       MailboxLocationPointer = BuildGuidDataHob (
 482                                  &gEfiDebugAgentGuid,
 483                                  &MailboxLocation,
 484                                  sizeof (UINT64)
 485                                  );
 486     }
 487     //
 488     // Update IDT entry to save the location saved mailbox pointer
 489     //
 490     SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer);
 491     break;
 492
 493   case DEBUG_AGENT_INIT_PEI:
 494     if (Context == NULL) {
 495       DEBUG ((EFI_D_ERROR, "DebugAgent: Input parameter Context cannot be NULL!\n"));
 496       CpuDeadLoop ();
 497     }
 498     //
 499     // Check if Debug Agent has initialized before
 500     //
 501     if (IsDebugAgentInitialzed()) {
 502       DEBUG ((EFI_D_WARN, "Debug Agent: It has already initialized in SEC Core!\n"));
 503       break;
 504     }
 505     //
 506     // Install Vector Handoff Info PPI to persist vectors used by Debug Agent
 507     //
 508     Status = PeiServicesInstallPpi (&mVectorHandoffInfoPpiList[0]);
 509     if (EFI_ERROR (Status)) {
 510       DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to install Vector Handoff Info PPI!\n"));
 511       CpuDeadLoop ();
 512     }
 513     //
 514     // Set up IDT entries
 515     //
 516     InitializeDebugIdt ();
 517     //
 518     // Build mailbox in HOB and setup Mailbox Set In Pei flag
 519     //
 520     Mailbox = AllocateZeroPool (sizeof (DEBUG_AGENT_MAILBOX));
 521     MailboxLocation = (UINT64)(UINTN)Mailbox;
 522     MailboxLocationPointer = BuildGuidDataHob (
 523                                &gEfiDebugAgentGuid,
 524                                &MailboxLocation,
 525                                sizeof (UINT64)
 526                                );
 527
 528     InitializeDebugTimer ();
 529     //
 530     // Update IDT entry to save the location pointer saved mailbox pointer
 531     //
 532     SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer);
 533     //
 534     // Save init arch type when debug agent initialized
 535     //
 536     SetDebugFlag (DEBUG_AGENT_FLAG_INIT_ARCH, DEBUG_ARCH_SYMBOL);
 537     //
 538     // Register for a callback once memory has been initialized.
 539     // If memery has been ready, the callback funtion will be invoked immediately
 540     //
 541     Status = PeiServicesNotifyPpi (&mMemoryDiscoveredNotifyList[0]);
 542     if (EFI_ERROR (Status)) {
 543       DEBUG ((EFI_D_ERROR, "DebugAgent: Failed to register memory discovered callback function!\n"));
 544       CpuDeadLoop ();
 545     }
 546     //
 547     // Set HOB check flag if memory has not been ready yet
 548     //
 549     if (GetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY) == 0) {
 550       SetDebugFlag (DEBUG_AGENT_FLAG_CHECK_MAILBOX_IN_HOB, 1);
 551     }
 552
 553     Phase2Context.InitFlag = InitFlag;
 554     Phase2Context.Context  = Context;
 555     Phase2Context.Function = Function;
 556     DebugPortInitialize ((VOID *) &Phase2Context, InitializeDebugAgentPhase2);
 557
 558     FindAndReportModuleImageInfo (4);
 559
 560     break;
 561
 562   case DEBUG_AGENT_INIT_THUNK_PEI_IA32TOX64:
 563     if (Context == NULL) {
 564       DEBUG ((EFI_D_ERROR, "DebugAgent: Input parameter Context cannot be NULL!\n"));
 565       CpuDeadLoop ();
 566     } else {
 567       Ia32Idtr =  (IA32_DESCRIPTOR *) Context;
 568       Ia32IdtEntry = (IA32_IDT_ENTRY *)(Ia32Idtr->Base);
 569       MailboxLocationPointer = (UINT64 *) (UINTN) (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetLow +
 570                                                 (Ia32IdtEntry[DEBUG_MAILBOX_VECTOR].Bits.OffsetHigh << 16));
 571       Mailbox = (DEBUG_AGENT_MAILBOX *) (UINTN)(*MailboxLocationPointer);
 572       //
 573       // Mailbox should valid and setup before executing thunk code
 574       //
 575       VerifyMailboxChecksum (Mailbox);
 576
 577       DebugPortHandle = (UINT64) (UINTN)DebugPortInitialize ((VOID *)(UINTN)Mailbox->DebugPortHandle, NULL);
 578       UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, DebugPortHandle);
 579       //
 580       // Set up IDT entries
 581       //
 582       InitializeDebugIdt ();
 583       //
 584       // Update IDT entry to save location pointer saved the mailbox pointer
 585       //
 586       SetLocationSavedMailboxPointerInIdtEntry (MailboxLocationPointer);
 587
 588       FindAndReportModuleImageInfo (4);
 589     }
 590     break;
 591
 592   default:
 593     //
 594     // Only DEBUG_AGENT_INIT_PREMEM_SEC and DEBUG_AGENT_INIT_POSTMEM_SEC are allowed for this
 595     // Debug Agent library instance.
 596     //
 597     DEBUG ((EFI_D_ERROR, "Debug Agent: The InitFlag value is not allowed!\n"));
 598     CpuDeadLoop ();
 599     break;
 600   }
 601
 602   //
 603   // Enable CPU interrupts so debug timer interrupts can be delivered
 604   //
 605   EnableInterrupts ();
 606
 607   //
 608   // If Function is not NULL, invoke it always whatever debug agent was initialized sucesssfully or not.
 609   //
 610   if (Function != NULL) {
 611     Function (Context);
 612   }
 613   //
 614   // Set return status for DEBUG_AGENT_INIT_PEI
 615   //
 616   if (InitFlag == DEBUG_AGENT_INIT_PEI) {
 617     *(EFI_STATUS *)Context = EFI_SUCCESS;
 618   }
 619 }
 620
 621 /**
 622   Caller provided function to be invoked at the end of DebugPortInitialize().
 623
 624   Refer to the descrption for DebugPortInitialize() for more details.
 625
 626   @param[in] Context           The first input argument of DebugPortInitialize().
 627   @param[in] DebugPortHandle   Debug port handle created by Debug Communication Libary.
 628
 629 **/
 630 VOID
 631 EFIAPI
 632 InitializeDebugAgentPhase2 (
 633   IN VOID                  *Context,
 634   IN DEBUG_PORT_HANDLE     DebugPortHandle
 635   )
 636 {
 637   DEBUG_AGENT_PHASE2_CONTEXT *Phase2Context;
 638   UINT64                     *MailboxLocation;
 639   DEBUG_AGENT_MAILBOX        *Mailbox;
 640   EFI_SEC_PEI_HAND_OFF       *SecCoreData;
 641   UINT16                     BufferSize;
 642   UINT64                     NewDebugPortHandle;
 643
 644   Phase2Context = (DEBUG_AGENT_PHASE2_CONTEXT *) Context;
 645   MailboxLocation = GetLocationSavedMailboxPointerInIdtEntry ();
 646   Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocation);
 647   BufferSize = PcdGet16(PcdDebugPortHandleBufferSize);
 648   if (Phase2Context->InitFlag == DEBUG_AGENT_INIT_PEI) {
 649     NewDebugPortHandle = (UINT64)(UINTN)AllocateCopyPool (BufferSize, DebugPortHandle);
 650   } else {
 651     NewDebugPortHandle = (UINT64)(UINTN)DebugPortHandle;
 652   }
 653   UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, NewDebugPortHandle);
 654
 655   //
 656   // Trigger one software interrupt to inform HOST
 657   //
 658   TriggerSoftInterrupt (SYSTEM_RESET_SIGNATURE);
 659
 660   if (Phase2Context->InitFlag == DEBUG_AGENT_INIT_PREMEM_SEC) {
 661     //
 662     // If Temporary RAM region is below 128 MB, then send message to
 663     // host to disable low memory filtering.
 664     //
 665     SecCoreData = (EFI_SEC_PEI_HAND_OFF *)Phase2Context->Context;
 666     if ((UINTN)SecCoreData->TemporaryRamBase < BASE_128MB && IsHostAttached ()) {
 667       SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);
 668       TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);
 669     }
 670     //
 671     // Enable CPU interrupts so debug timer interrupts can be delivered
 672     //
 673     EnableInterrupts ();
 674     //
 675     // Call continuation function if it is not NULL.
 676     //
 677     Phase2Context->Function (Phase2Context->Context);
 678   }
 679 }