[mirror_edk2.git] / MdeModulePkg / Universal / DebugSupportDxe / Ipf / PlDebugSupport.c

/** @file\r
  IPF specific functions to support Debug Support protocol.\r
\r
Copyright (c) 2006 - 2010, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "PlDebugSupport.h"\r
\r
BOOLEAN  mInHandler = FALSE;\r
\r
//\r
// number of bundles to swap in ivt\r
//\r
#define NUM_BUNDLES_IN_STUB 5\r
#define NUM_IVT_ENTRIES     64\r
\r
typedef struct {\r
  BUNDLE         OrigBundles[NUM_BUNDLES_IN_STUB];\r
  CALLBACK_FUNC  RegisteredCallback;\r
} IVT_ENTRY;\r
\r
IVT_ENTRY IvtEntryTable[NUM_IVT_ENTRIES];\r
\r
//\r
// IPF context record is overallocated by 512 bytes to guarantee a 512 byte alignment exists\r
// within the buffer and still have a large enough buffer to hold a whole IPF context record.\r
//\r
UINT8     IpfContextBuf[sizeof (EFI_SYSTEM_CONTEXT_IPF) + 512];\r
\r
//\r
// The PatchSaveBuffer is used to store the original bundles from the IVT where it is patched\r
// with the common handler.\r
//\r
UINT8     PatchSaveBuffer[0x400];\r
UINTN     ExternalInterruptCount;\r
\r
\r
/**\r
  IPF specific DebugSupport driver initialization.\r
\r
  Must be public because it's referenced from DebugSupport.c\r
\r
  @retval  EFI_SUCCESS     Always.\r
\r
**/\r
EFI_STATUS\r
PlInitializeDebugSupportDriver (\r
  VOID\r
  )\r
{\r
  ZeroMem (IvtEntryTable, sizeof (IvtEntryTable));\r
  ExternalInterruptCount = 0;\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Unload handler that is called during UnloadImage() - deallocates pool memory\r
  used by the driver.\r
\r
  Must be public because it's referenced from DebugSuport.c\r
\r
  @param  ImageHandle    The firmware allocated handle for the EFI image.\r
\r
  @retval EFI_SUCCESS    Always.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
PlUnloadDebugSupportDriver (\r
  IN EFI_HANDLE       ImageHandle\r
  )\r
{\r
  EFI_EXCEPTION_TYPE  ExceptionType;\r
\r
  for (ExceptionType = 0; ExceptionType < NUM_IVT_ENTRIES; ExceptionType++) {\r
    ManageIvtEntryTable (ExceptionType, NULL, NULL);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  C routine that is called for all registered exceptions.  This is the main\r
  exception dispatcher.\r
\r
  Must be public because it's referenced from AsmFuncs.s.\r
\r
  @param  ExceptionType        Specifies which processor exception.\r
  @param  Context              System Context.\r
**/\r
VOID\r
CommonHandler (\r
  IN EFI_EXCEPTION_TYPE ExceptionType,\r
  IN EFI_SYSTEM_CONTEXT Context\r
  )\r
{\r
  DEBUG_CODE_BEGIN ();\r
    if (mInHandler) {\r
      DEBUG ((EFI_D_INFO, "ERROR: Re-entered debugger!\n"\r
                                    "       ExceptionType == %X\n"\r
                                    "       Context       == %X\n"\r
                                    "       Context.SystemContextIpf->CrIip  == %LX\n"\r
                                    "       Context.SystemContextIpf->CrIpsr == %LX\n"\r
                                    "       mInHandler     == %X\n",\r
                                    (INT32)ExceptionType,\r
                                    Context,\r
                                    Context.SystemContextIpf->CrIip,\r
                                    Context.SystemContextIpf->CrIpsr,\r
                                    mInHandler));\r
    }\r
  DEBUG_CODE_END ();\r
\r
  ASSERT (!mInHandler);\r
  mInHandler = TRUE;\r
  if (IvtEntryTable[ExceptionType].RegisteredCallback != NULL) {\r
    if (ExceptionType != EXCEPT_IPF_EXTERNAL_INTERRUPT) {\r
      IvtEntryTable[ExceptionType].RegisteredCallback (ExceptionType, Context.SystemContextIpf);\r
    } else {\r
      IvtEntryTable[ExceptionType].RegisteredCallback (Context.SystemContextIpf);\r
    }\r
  } else {\r
    ASSERT (0);\r
  }\r
\r
  mInHandler = FALSE;\r
}\r
\r
/**\r
  Given an integer number, return the physical address of the entry point in the IFT.\r
\r
  @param  HandlerIndex       Index of the Handler\r
  @param  EntryPoint         IFT Entrypoint\r
\r
**/\r
VOID\r
GetHandlerEntryPoint (\r
  UINTN   HandlerIndex,\r
  VOID    **EntryPoint\r
  )\r
{\r
  UINT8 *TempPtr;\r
\r
  //\r
  // get base address of IVT\r
  //\r
  TempPtr = GetIva ();\r
\r
  if (HandlerIndex < 20) {\r
    //\r
    // first 20 provide 64 bundles per vector\r
    //\r
    TempPtr += 0x400 * HandlerIndex;\r
  } else {\r
    //\r
    // the rest provide 16 bundles per vector\r
    //\r
    TempPtr += 0x5000 + 0x100 * (HandlerIndex - 20);\r
  }\r
\r
  *EntryPoint = (VOID *) TempPtr;\r
}\r
\r
/**\r
  This is the worker function that uninstalls and removes all handlers.\r
\r
  @param  ExceptionType     Specifies which processor exception.\r
  @param  NewBundles        New Boundles.\r
  @param  NewCallback       A pointer to the new function to be registered.\r
\r
  @retval EFI_ALEADY_STARTED Ivt already hooked.\r
  @retval EFI_SUCCESS        Successfully uninstalled.\r
\r
**/\r
EFI_STATUS\r
ManageIvtEntryTable (\r
  IN  EFI_EXCEPTION_TYPE           ExceptionType,\r
  IN  BUNDLE                       NewBundles[NUM_BUNDLES_IN_STUB],\r
  IN  CALLBACK_FUNC                NewCallback\r
  )\r
{\r
  BUNDLE  *B0Ptr;\r
  UINT64  InterruptFlags;\r
  EFI_TPL OldTpl;\r
\r
  //\r
  // Get address of bundle 0\r
  //\r
  GetHandlerEntryPoint (ExceptionType, (VOID **) &B0Ptr);\r
\r
  if (IvtEntryTable[ExceptionType].RegisteredCallback != NULL) {\r
    //\r
    // we've already installed to this vector\r
    //\r
    if (NewCallback != NULL) {\r
      //\r
      // if the input handler is non-null, error\r
      //\r
      return EFI_ALREADY_STARTED;\r
    } else {\r
      //\r
      // else remove the previously installed handler\r
      //\r
      OldTpl          = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
      InterruptFlags  = ProgramInterruptFlags (DISABLE_INTERRUPTS);\r
      if (ExceptionType == EXCEPT_IPF_EXTERNAL_INTERRUPT) {\r
        UnchainExternalInterrupt ();\r
      } else {\r
        UnhookEntry (ExceptionType);\r
      }\r
\r
      ProgramInterruptFlags (InterruptFlags);\r
      gBS->RestoreTPL (OldTpl);\r
      //\r
      // re-init IvtEntryTable\r
      //\r
      ZeroMem (&IvtEntryTable[ExceptionType], sizeof (IVT_ENTRY));\r
    }\r
  } else {\r
    //\r
    // no user handler installed on this vector\r
    //\r
    if (NewCallback != NULL) {\r
      OldTpl          = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
      InterruptFlags  = ProgramInterruptFlags (DISABLE_INTERRUPTS);\r
      if (ExceptionType == EXCEPT_IPF_EXTERNAL_INTERRUPT) {\r
        ChainExternalInterrupt (NewCallback);\r
      } else {\r
        HookEntry (ExceptionType, NewBundles, NewCallback);\r
      }\r
\r
      ProgramInterruptFlags (InterruptFlags);\r
      gBS->RestoreTPL (OldTpl);\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Saves original IVT contents and inserts a few new bundles which are fixed up\r
  to store the ExceptionType and then call the common handler.\r
\r
  @param  ExceptionType      Specifies which processor exception.\r
  @param  NewBundles         New Boundles.\r
  @param  NewCallback        A pointer to the new function to be hooked.\r
\r
**/\r
VOID\r
HookEntry (\r
  IN  EFI_EXCEPTION_TYPE  ExceptionType,\r
  IN  BUNDLE              NewBundles[4],\r
  IN  CALLBACK_FUNC       NewCallback\r
  )\r
{\r
  BUNDLE  *FixupBundle;\r
  BUNDLE  *B0Ptr;\r
\r
  //\r
  // Get address of bundle 0\r
  //\r
  GetHandlerEntryPoint (ExceptionType, (VOID **) &B0Ptr);\r
\r
  //\r
  // copy original bundles from IVT to IvtEntryTable so we can restore them later\r
  //\r
  CopyMem (\r
    IvtEntryTable[ExceptionType].OrigBundles,\r
    B0Ptr,\r
    sizeof (BUNDLE) * NUM_BUNDLES_IN_STUB\r
    );\r
  //\r
  // insert new B0\r
  //\r
  CopyMem (B0Ptr, NewBundles, sizeof (BUNDLE) * NUM_BUNDLES_IN_STUB);\r
\r
  //\r
  // fixup IVT entry so it stores its index and whether or not to chain...\r
  //\r
  FixupBundle = B0Ptr + 2;\r
  FixupBundle->High |= ExceptionType << 36;\r
\r
  InstructionCacheFlush (B0Ptr, 5);\r
  IvtEntryTable[ExceptionType].RegisteredCallback = NewCallback;\r
}\r
\r
/**\r
  Restores original IVT contents when unregistering a callback function.\r
\r
  @param  ExceptionType     Specifies which processor exception.\r
\r
**/\r
VOID\r
UnhookEntry (\r
  IN  EFI_EXCEPTION_TYPE  ExceptionType\r
  )\r
{\r
  BUNDLE  *B0Ptr;\r
\r
  //\r
  // Get address of bundle 0\r
  //\r
  GetHandlerEntryPoint (ExceptionType, (VOID **) &B0Ptr);\r
  //\r
  // restore original bundles in IVT\r
  //\r
  CopyMem (\r
    B0Ptr,\r
    IvtEntryTable[ExceptionType].OrigBundles,\r
    sizeof (BUNDLE) * NUM_BUNDLES_IN_STUB\r
    );\r
  InstructionCacheFlush (B0Ptr, 5);\r
}\r
\r
/**\r
  Sets up cache flush and calls assembly function to chain external interrupt.\r
\r
  Records new callback in IvtEntryTable.\r
\r
  @param  NewCallback     A pointer to the interrupt handle.\r
\r
**/\r
VOID\r
ChainExternalInterrupt (\r
  IN  CALLBACK_FUNC  NewCallback\r
  )\r
{\r
  VOID  *Start;\r
\r
  Start = (VOID *) ((UINT8 *) GetIva () + 0x400 * EXCEPT_IPF_EXTERNAL_INTERRUPT + 0x400);\r
  IvtEntryTable[EXCEPT_IPF_EXTERNAL_INTERRUPT].RegisteredCallback = NewCallback;\r
  ChainHandler ();\r
  InstructionCacheFlush (Start, 0x400);\r
}\r
\r
/**\r
  Sets up cache flush and calls assembly function to restore external interrupt.\r
  Removes registered callback from IvtEntryTable.\r
\r
**/\r
VOID\r
UnchainExternalInterrupt (\r
  VOID\r
  )\r
{\r
  VOID  *Start;\r
\r
  Start = (VOID *) ((UINT8 *) GetIva () + 0x400 * EXCEPT_IPF_EXTERNAL_INTERRUPT + 0x400);\r
  UnchainHandler ();\r
  InstructionCacheFlush (Start, 0x400);\r
  IvtEntryTable[EXCEPT_IPF_EXTERNAL_INTERRUPT].RegisteredCallback = NULL;\r
}\r
\r
/**\r
  Returns the maximum value that may be used for the ProcessorIndex parameter in\r
  RegisterPeriodicCallback() and RegisterExceptionCallback().\r
\r
  Hard coded to support only 1 processor for now.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.\r
  @param  MaxProcessorIndex     Pointer to a caller-allocated UINTN in which the maximum supported\r
                                processor index is returned. Always 0 returned.\r
\r
  @retval EFI_SUCCESS           Always returned with **MaxProcessorIndex set to 0.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
GetMaximumProcessorIndex (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL    *This,\r
  OUT UINTN                        *MaxProcessorIndex\r
  )\r
{\r
  *MaxProcessorIndex = 0;\r
  return (EFI_SUCCESS);\r
}\r
\r
/**\r
  Registers a function to be called back periodically in interrupt context.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.\r
  @param  ProcessorIndex        Specifies which processor the callback function applies to.\r
  @param  PeriodicCallback      A pointer to a function of type PERIODIC_CALLBACK that is the main\r
                                periodic entry point of the debug agent.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback\r
                                function was previously registered.\r
  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback\r
                                function.\r
**/\r
EFI_STATUS\r
EFIAPI\r
RegisterPeriodicCallback (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL     *This,\r
  IN UINTN                          ProcessorIndex,\r
  IN EFI_PERIODIC_CALLBACK          PeriodicCallback\r
  )\r
{\r
  return ManageIvtEntryTable (EXCEPT_IPF_EXTERNAL_INTERRUPT, NULL, PeriodicCallback);\r
}\r
\r
/**\r
  Registers a function to be called when a given processor exception occurs.\r
\r
  This code executes in boot services context.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.\r
  @param  ProcessorIndex        Specifies which processor the callback function applies to.\r
  @param  ExceptionCallback     A pointer to a function of type EXCEPTION_CALLBACK that is called\r
                                when the processor exception specified by ExceptionType occurs.\r
  @param  ExceptionType         Specifies which processor exception to hook.\r
\r
  @retval EFI_SUCCESS           The function completed successfully.\r
  @retval EFI_ALREADY_STARTED   Non-NULL PeriodicCallback parameter when a callback\r
                                function was previously registered.\r
  @retval EFI_OUT_OF_RESOURCES  System has insufficient memory resources to register new callback\r
                                function.\r
**/\r
EFI_STATUS\r
EFIAPI\r
RegisterExceptionCallback (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL    *This,\r
  IN UINTN                         ProcessorIndex,\r
  IN EFI_EXCEPTION_CALLBACK        ExceptionCallback,\r
  IN EFI_EXCEPTION_TYPE            ExceptionType\r
  )\r
{\r
  return ManageIvtEntryTable (\r
          ExceptionType,\r
          (BUNDLE *) ((EFI_PLABEL *) HookStub)->EntryPoint,\r
          ExceptionCallback\r
          );\r
}\r
\r
/**\r
  Invalidates processor instruction cache for a memory range. Subsequent execution in this range\r
  causes a fresh memory fetch to retrieve code to be executed.\r
\r
  @param  This                  A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.\r
  @param  ProcessorIndex        Specifies which processor's instruction cache is to be invalidated.\r
  @param  Start                 Specifies the physical base of the memory range to be invalidated.\r
  @param  Length                Specifies the minimum number of bytes in the processor's instruction\r
                                cache to invalidate.\r
\r
  @retval EFI_SUCCESS           Always returned.\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
InvalidateInstructionCache (\r
  IN EFI_DEBUG_SUPPORT_PROTOCOL    *This,\r
  IN UINTN                         ProcessorIndex,\r
  IN VOID                          *Start,\r
  IN UINTN                         Length\r
  )\r
{\r
  InstructionCacheFlush (Start, Length);\r
  return EFI_SUCCESS;\r
}\r
Commit	Line	Data
	1	/** @file\r
	2	IPF specific functions to support Debug Support protocol.\r
	3	\r
	4	Copyright (c) 2006 - 2010, Intel Corporation\r
	5	All rights reserved. This program and the accompanying materials\r
	6	are licensed and made available under the terms and conditions of the BSD License\r
	7	which accompanies this distribution. The full text of the license may be found at\r
	8	http://opensource.org/licenses/bsd-license.php\r
	9	\r
	10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
	11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
	12	\r
	13	**/\r
	14	\r
	15	#include "PlDebugSupport.h"\r
	16	\r
	17	BOOLEAN mInHandler = FALSE;\r
	18	\r
	19	//\r
	20	// number of bundles to swap in ivt\r
	21	//\r
	22	#define NUM_BUNDLES_IN_STUB 5\r
	23	#define NUM_IVT_ENTRIES 64\r
	24	\r
	25	typedef struct {\r
	26	BUNDLE OrigBundles[NUM_BUNDLES_IN_STUB];\r
	27	CALLBACK_FUNC RegisteredCallback;\r
	28	} IVT_ENTRY;\r
	29	\r
	30	IVT_ENTRY IvtEntryTable[NUM_IVT_ENTRIES];\r
	31	\r
	32	//\r
	33	// IPF context record is overallocated by 512 bytes to guarantee a 512 byte alignment exists\r
	34	// within the buffer and still have a large enough buffer to hold a whole IPF context record.\r
	35	//\r
	36	UINT8 IpfContextBuf[sizeof (EFI_SYSTEM_CONTEXT_IPF) + 512];\r
	37	\r
	38	//\r
	39	// The PatchSaveBuffer is used to store the original bundles from the IVT where it is patched\r
	40	// with the common handler.\r
	41	//\r
	42	UINT8 PatchSaveBuffer[0x400];\r
	43	UINTN ExternalInterruptCount;\r
	44	\r
	45	\r
	46	/**\r
	47	IPF specific DebugSupport driver initialization.\r
	48	\r
	49	Must be public because it's referenced from DebugSupport.c\r
	50	\r
	51	@retval EFI_SUCCESS Always.\r
	52	\r
	53	**/\r
	54	EFI_STATUS\r
	55	PlInitializeDebugSupportDriver (\r
	56	VOID\r
	57	)\r
	58	{\r
	59	ZeroMem (IvtEntryTable, sizeof (IvtEntryTable));\r
	60	ExternalInterruptCount = 0;\r
	61	return EFI_SUCCESS;\r
	62	}\r
	63	\r
	64	/**\r
	65	Unload handler that is called during UnloadImage() - deallocates pool memory\r
	66	used by the driver.\r
	67	\r
	68	Must be public because it's referenced from DebugSuport.c\r
	69	\r
	70	@param ImageHandle The firmware allocated handle for the EFI image.\r
	71	\r
	72	@retval EFI_SUCCESS Always.\r
	73	\r
	74	**/\r
	75	EFI_STATUS\r
	76	EFIAPI\r
	77	PlUnloadDebugSupportDriver (\r
	78	IN EFI_HANDLE ImageHandle\r
	79	)\r
	80	{\r
	81	EFI_EXCEPTION_TYPE ExceptionType;\r
	82	\r
	83	for (ExceptionType = 0; ExceptionType < NUM_IVT_ENTRIES; ExceptionType++) {\r
	84	ManageIvtEntryTable (ExceptionType, NULL, NULL);\r
	85	}\r
	86	\r
	87	return EFI_SUCCESS;\r
	88	}\r
	89	\r
	90	/**\r
	91	C routine that is called for all registered exceptions. This is the main\r
	92	exception dispatcher.\r
	93	\r
	94	Must be public because it's referenced from AsmFuncs.s.\r
	95	\r
	96	@param ExceptionType Specifies which processor exception.\r
	97	@param Context System Context.\r
	98	**/\r
	99	VOID\r
	100	CommonHandler (\r
	101	IN EFI_EXCEPTION_TYPE ExceptionType,\r
	102	IN EFI_SYSTEM_CONTEXT Context\r
	103	)\r
	104	{\r
	105	DEBUG_CODE_BEGIN ();\r
	106	if (mInHandler) {\r
	107	DEBUG ((EFI_D_INFO, "ERROR: Re-entered debugger!\n"\r
	108	" ExceptionType == %X\n"\r
	109	" Context == %X\n"\r
	110	" Context.SystemContextIpf->CrIip == %LX\n"\r
	111	" Context.SystemContextIpf->CrIpsr == %LX\n"\r
	112	" mInHandler == %X\n",\r
	113	(INT32)ExceptionType,\r
	114	Context,\r
	115	Context.SystemContextIpf->CrIip,\r
	116	Context.SystemContextIpf->CrIpsr,\r
	117	mInHandler));\r
	118	}\r
	119	DEBUG_CODE_END ();\r
	120	\r
	121	ASSERT (!mInHandler);\r
	122	mInHandler = TRUE;\r
	123	if (IvtEntryTable[ExceptionType].RegisteredCallback != NULL) {\r
	124	if (ExceptionType != EXCEPT_IPF_EXTERNAL_INTERRUPT) {\r
	125	IvtEntryTable[ExceptionType].RegisteredCallback (ExceptionType, Context.SystemContextIpf);\r
	126	} else {\r
	127	IvtEntryTable[ExceptionType].RegisteredCallback (Context.SystemContextIpf);\r
	128	}\r
	129	} else {\r
	130	ASSERT (0);\r
	131	}\r
	132	\r
	133	mInHandler = FALSE;\r
	134	}\r
	135	\r
	136	/**\r
	137	Given an integer number, return the physical address of the entry point in the IFT.\r
	138	\r
	139	@param HandlerIndex Index of the Handler\r
	140	@param EntryPoint IFT Entrypoint\r
	141	\r
	142	**/\r
	143	VOID\r
	144	GetHandlerEntryPoint (\r
	145	UINTN HandlerIndex,\r
	146	VOID **EntryPoint\r
	147	)\r
	148	{\r
	149	UINT8 *TempPtr;\r
	150	\r
	151	//\r
	152	// get base address of IVT\r
	153	//\r
	154	TempPtr = GetIva ();\r
	155	\r
	156	if (HandlerIndex < 20) {\r
	157	//\r
	158	// first 20 provide 64 bundles per vector\r
	159	//\r
	160	TempPtr += 0x400 * HandlerIndex;\r
	161	} else {\r
	162	//\r
	163	// the rest provide 16 bundles per vector\r
	164	//\r
	165	TempPtr += 0x5000 + 0x100 * (HandlerIndex - 20);\r
	166	}\r
	167	\r
	168	EntryPoint = (VOID ) TempPtr;\r
	169	}\r
	170	\r
	171	/**\r
	172	This is the worker function that uninstalls and removes all handlers.\r
	173	\r
	174	@param ExceptionType Specifies which processor exception.\r
	175	@param NewBundles New Boundles.\r
	176	@param NewCallback A pointer to the new function to be registered.\r
	177	\r
	178	@retval EFI_ALEADY_STARTED Ivt already hooked.\r
	179	@retval EFI_SUCCESS Successfully uninstalled.\r
	180	\r
	181	**/\r
	182	EFI_STATUS\r
	183	ManageIvtEntryTable (\r
	184	IN EFI_EXCEPTION_TYPE ExceptionType,\r
	185	IN BUNDLE NewBundles[NUM_BUNDLES_IN_STUB],\r
	186	IN CALLBACK_FUNC NewCallback\r
	187	)\r
	188	{\r
	189	BUNDLE *B0Ptr;\r
	190	UINT64 InterruptFlags;\r
	191	EFI_TPL OldTpl;\r
	192	\r
	193	//\r
	194	// Get address of bundle 0\r
	195	//\r
	196	GetHandlerEntryPoint (ExceptionType, (VOID **) &B0Ptr);\r
	197	\r
	198	if (IvtEntryTable[ExceptionType].RegisteredCallback != NULL) {\r
	199	//\r
	200	// we've already installed to this vector\r
	201	//\r
	202	if (NewCallback != NULL) {\r
	203	//\r
	204	// if the input handler is non-null, error\r
	205	//\r
	206	return EFI_ALREADY_STARTED;\r
	207	} else {\r
	208	//\r
	209	// else remove the previously installed handler\r
	210	//\r
	211	OldTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
	212	InterruptFlags = ProgramInterruptFlags (DISABLE_INTERRUPTS);\r
	213	if (ExceptionType == EXCEPT_IPF_EXTERNAL_INTERRUPT) {\r
	214	UnchainExternalInterrupt ();\r
	215	} else {\r
	216	UnhookEntry (ExceptionType);\r
	217	}\r
	218	\r
	219	ProgramInterruptFlags (InterruptFlags);\r
	220	gBS->RestoreTPL (OldTpl);\r
	221	//\r
	222	// re-init IvtEntryTable\r
	223	//\r
	224	ZeroMem (&IvtEntryTable[ExceptionType], sizeof (IVT_ENTRY));\r
	225	}\r
	226	} else {\r
	227	//\r
	228	// no user handler installed on this vector\r
	229	//\r
	230	if (NewCallback != NULL) {\r
	231	OldTpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
	232	InterruptFlags = ProgramInterruptFlags (DISABLE_INTERRUPTS);\r
	233	if (ExceptionType == EXCEPT_IPF_EXTERNAL_INTERRUPT) {\r
	234	ChainExternalInterrupt (NewCallback);\r
	235	} else {\r
	236	HookEntry (ExceptionType, NewBundles, NewCallback);\r
	237	}\r
	238	\r
	239	ProgramInterruptFlags (InterruptFlags);\r
	240	gBS->RestoreTPL (OldTpl);\r
	241	}\r
	242	}\r
	243	\r
	244	return EFI_SUCCESS;\r
	245	}\r
	246	\r
	247	/**\r
	248	Saves original IVT contents and inserts a few new bundles which are fixed up\r
	249	to store the ExceptionType and then call the common handler.\r
	250	\r
	251	@param ExceptionType Specifies which processor exception.\r
	252	@param NewBundles New Boundles.\r
	253	@param NewCallback A pointer to the new function to be hooked.\r
	254	\r
	255	**/\r
	256	VOID\r
	257	HookEntry (\r
	258	IN EFI_EXCEPTION_TYPE ExceptionType,\r
	259	IN BUNDLE NewBundles[4],\r
	260	IN CALLBACK_FUNC NewCallback\r
	261	)\r
	262	{\r
	263	BUNDLE *FixupBundle;\r
	264	BUNDLE *B0Ptr;\r
	265	\r
	266	//\r
	267	// Get address of bundle 0\r
	268	//\r
	269	GetHandlerEntryPoint (ExceptionType, (VOID **) &B0Ptr);\r
	270	\r
	271	//\r
	272	// copy original bundles from IVT to IvtEntryTable so we can restore them later\r
	273	//\r
	274	CopyMem (\r
	275	IvtEntryTable[ExceptionType].OrigBundles,\r
	276	B0Ptr,\r
	277	sizeof (BUNDLE) * NUM_BUNDLES_IN_STUB\r
	278	);\r
	279	//\r
	280	// insert new B0\r
	281	//\r
	282	CopyMem (B0Ptr, NewBundles, sizeof (BUNDLE) * NUM_BUNDLES_IN_STUB);\r
	283	\r
	284	//\r
	285	// fixup IVT entry so it stores its index and whether or not to chain...\r
	286	//\r
	287	FixupBundle = B0Ptr + 2;\r
	288	FixupBundle->High \|= ExceptionType << 36;\r
	289	\r
	290	InstructionCacheFlush (B0Ptr, 5);\r
	291	IvtEntryTable[ExceptionType].RegisteredCallback = NewCallback;\r
	292	}\r
	293	\r
	294	/**\r
	295	Restores original IVT contents when unregistering a callback function.\r
	296	\r
	297	@param ExceptionType Specifies which processor exception.\r
	298	\r
	299	**/\r
	300	VOID\r
	301	UnhookEntry (\r
	302	IN EFI_EXCEPTION_TYPE ExceptionType\r
	303	)\r
	304	{\r
	305	BUNDLE *B0Ptr;\r
	306	\r
	307	//\r
	308	// Get address of bundle 0\r
	309	//\r
	310	GetHandlerEntryPoint (ExceptionType, (VOID **) &B0Ptr);\r
	311	//\r
	312	// restore original bundles in IVT\r
	313	//\r
	314	CopyMem (\r
	315	B0Ptr,\r
	316	IvtEntryTable[ExceptionType].OrigBundles,\r
	317	sizeof (BUNDLE) * NUM_BUNDLES_IN_STUB\r
	318	);\r
	319	InstructionCacheFlush (B0Ptr, 5);\r
	320	}\r
	321	\r
	322	/**\r
	323	Sets up cache flush and calls assembly function to chain external interrupt.\r
	324	\r
	325	Records new callback in IvtEntryTable.\r
	326	\r
	327	@param NewCallback A pointer to the interrupt handle.\r
	328	\r
	329	**/\r
	330	VOID\r
	331	ChainExternalInterrupt (\r
	332	IN CALLBACK_FUNC NewCallback\r
	333	)\r
	334	{\r
	335	VOID *Start;\r
	336	\r
	337	Start = (VOID ) ((UINT8 ) GetIva () + 0x400 * EXCEPT_IPF_EXTERNAL_INTERRUPT + 0x400);\r
	338	IvtEntryTable[EXCEPT_IPF_EXTERNAL_INTERRUPT].RegisteredCallback = NewCallback;\r
	339	ChainHandler ();\r
	340	InstructionCacheFlush (Start, 0x400);\r
	341	}\r
	342	\r
	343	/**\r
	344	Sets up cache flush and calls assembly function to restore external interrupt.\r
	345	Removes registered callback from IvtEntryTable.\r
	346	\r
	347	**/\r
	348	VOID\r
	349	UnchainExternalInterrupt (\r
	350	VOID\r
	351	)\r
	352	{\r
	353	VOID *Start;\r
	354	\r
	355	Start = (VOID ) ((UINT8 ) GetIva () + 0x400 * EXCEPT_IPF_EXTERNAL_INTERRUPT + 0x400);\r
	356	UnchainHandler ();\r
	357	InstructionCacheFlush (Start, 0x400);\r
	358	IvtEntryTable[EXCEPT_IPF_EXTERNAL_INTERRUPT].RegisteredCallback = NULL;\r
	359	}\r
	360	\r
	361	/**\r
	362	Returns the maximum value that may be used for the ProcessorIndex parameter in\r
	363	RegisterPeriodicCallback() and RegisterExceptionCallback().\r
	364	\r
	365	Hard coded to support only 1 processor for now.\r
	366	\r
	367	@param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.\r
	368	@param MaxProcessorIndex Pointer to a caller-allocated UINTN in which the maximum supported\r
	369	processor index is returned. Always 0 returned.\r
	370	\r
	371	@retval EFI_SUCCESS Always returned with **MaxProcessorIndex set to 0.\r
	372	\r
	373	**/\r
	374	EFI_STATUS\r
	375	EFIAPI\r
	376	GetMaximumProcessorIndex (\r
	377	IN EFI_DEBUG_SUPPORT_PROTOCOL *This,\r
	378	OUT UINTN *MaxProcessorIndex\r
	379	)\r
	380	{\r
	381	*MaxProcessorIndex = 0;\r
	382	return (EFI_SUCCESS);\r
	383	}\r
	384	\r
	385	/**\r
	386	Registers a function to be called back periodically in interrupt context.\r
	387	\r
	388	@param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.\r
	389	@param ProcessorIndex Specifies which processor the callback function applies to.\r
	390	@param PeriodicCallback A pointer to a function of type PERIODIC_CALLBACK that is the main\r
	391	periodic entry point of the debug agent.\r
	392	\r
	393	@retval EFI_SUCCESS The function completed successfully.\r
	394	@retval EFI_ALREADY_STARTED Non-NULL PeriodicCallback parameter when a callback\r
	395	function was previously registered.\r
	396	@retval EFI_OUT_OF_RESOURCES System has insufficient memory resources to register new callback\r
	397	function.\r
	398	**/\r
	399	EFI_STATUS\r
	400	EFIAPI\r
	401	RegisterPeriodicCallback (\r
	402	IN EFI_DEBUG_SUPPORT_PROTOCOL *This,\r
	403	IN UINTN ProcessorIndex,\r
	404	IN EFI_PERIODIC_CALLBACK PeriodicCallback\r
	405	)\r
	406	{\r
	407	return ManageIvtEntryTable (EXCEPT_IPF_EXTERNAL_INTERRUPT, NULL, PeriodicCallback);\r
	408	}\r
	409	\r
	410	/**\r
	411	Registers a function to be called when a given processor exception occurs.\r
	412	\r
	413	This code executes in boot services context.\r
	414	\r
	415	@param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.\r
	416	@param ProcessorIndex Specifies which processor the callback function applies to.\r
	417	@param ExceptionCallback A pointer to a function of type EXCEPTION_CALLBACK that is called\r
	418	when the processor exception specified by ExceptionType occurs.\r
	419	@param ExceptionType Specifies which processor exception to hook.\r
	420	\r
	421	@retval EFI_SUCCESS The function completed successfully.\r
	422	@retval EFI_ALREADY_STARTED Non-NULL PeriodicCallback parameter when a callback\r
	423	function was previously registered.\r
	424	@retval EFI_OUT_OF_RESOURCES System has insufficient memory resources to register new callback\r
	425	function.\r
	426	**/\r
	427	EFI_STATUS\r
	428	EFIAPI\r
	429	RegisterExceptionCallback (\r
	430	IN EFI_DEBUG_SUPPORT_PROTOCOL *This,\r
	431	IN UINTN ProcessorIndex,\r
	432	IN EFI_EXCEPTION_CALLBACK ExceptionCallback,\r
	433	IN EFI_EXCEPTION_TYPE ExceptionType\r
	434	)\r
	435	{\r
	436	return ManageIvtEntryTable (\r
	437	ExceptionType,\r
	438	(BUNDLE ) ((EFI_PLABEL ) HookStub)->EntryPoint,\r
	439	ExceptionCallback\r
	440	);\r
	441	}\r
	442	\r
	443	/**\r
	444	Invalidates processor instruction cache for a memory range. Subsequent execution in this range\r
	445	causes a fresh memory fetch to retrieve code to be executed.\r
	446	\r
	447	@param This A pointer to the EFI_DEBUG_SUPPORT_PROTOCOL instance.\r
	448	@param ProcessorIndex Specifies which processor's instruction cache is to be invalidated.\r
	449	@param Start Specifies the physical base of the memory range to be invalidated.\r
	450	@param Length Specifies the minimum number of bytes in the processor's instruction\r
	451	cache to invalidate.\r
	452	\r
	453	@retval EFI_SUCCESS Always returned.\r
	454	\r
	455	**/\r
	456	EFI_STATUS\r
	457	EFIAPI\r
	458	InvalidateInstructionCache (\r
	459	IN EFI_DEBUG_SUPPORT_PROTOCOL *This,\r
	460	IN UINTN ProcessorIndex,\r
	461	IN VOID *Start,\r
	462	IN UINTN Length\r
	463	)\r
	464	{\r
	465	InstructionCacheFlush (Start, Length);\r
	466	return EFI_SUCCESS;\r
	467	}\r