[mirror_edk2.git] / ArmRealViewEbPkg / TimerDxe / Timer.c

/** @file
  Template for Timer Architecture Protocol driver of the ARM flavor

  Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
  
  This program and the accompanying materials                          
  are licensed and made available under the terms and conditions of the BSD License         
  which accompanies this distribution.  The full text of the license may be found at        
  http://opensource.org/licenses/bsd-license.php                                            

  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

**/


#include <PiDxe.h>

#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Library/PcdLib.h>
#include <Library/IoLib.h>

#include <Protocol/Timer.h>
#include <Protocol/HardwareInterrupt.h>

#include <ArmEb/ArmEb.h>


// The notification function to call on every timer interrupt.
volatile EFI_TIMER_NOTIFY      mTimerNotifyFunction   = (EFI_TIMER_NOTIFY)NULL;


// The current period of the timer interrupt
volatile UINT64 mTimerPeriod = 0;

// Cached copy of the Hardware Interrupt protocol instance
EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;

// Cached interrupt vector
UINTN  gVector;

UINT32 mLastTickCount;


/**

  C Interrupt Handler calledin the interrupt context when Source interrupt is active.


  @param Source         Source of the interrupt. Hardware routing off a specific platform defines
                        what source means.

  @param SystemContext  Pointer to system register context. Mostly used by debuggers and will
                        update the system context after the return from the interrupt if 
                        modified. Don't change these values unless you know what you are doing

**/
VOID
EFIAPI
TimerInterruptHandler (
  IN  HARDWARE_INTERRUPT_SOURCE   Source,
  IN  EFI_SYSTEM_CONTEXT          SystemContext       
  )
{
  EFI_TPL OriginalTPL;

  //
  // DXE core uses this callback for the EFI timer tick. The DXE core uses locks 
  // that raise to TPL_HIGH and then restore back to current level. Thus we need
  // to make sure TPL level is set to TPL_HIGH while we are handling the timer tick. 
  //
  OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);

  // clear the periodic interrupt

  MmioWrite32 (EB_SP804_TIMER0_BASE + SP804_TIMER_INT_CLR_REG, 0);

  // signal end of interrupt early to help avoid losing subsequent ticks from long duration handlers
  gInterrupt->EndOfInterrupt (gInterrupt, Source);

  if (mTimerNotifyFunction) {
    mTimerNotifyFunction (mTimerPeriod);
  }

  gBS->RestoreTPL (OriginalTPL);
}


/**
  This function registers the handler NotifyFunction so it is called every time 
  the timer interrupt fires.  It also passes the amount of time since the last 
  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the 
  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is 
  returned.  If the CPU does not support registering a timer interrupt handler, 
  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler 
  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  
  If an attempt is made to unregister a handler when a handler is not registered, 
  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to 
  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR 
  is returned.

  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
  @param  NotifyFunction   The function to call when a timer interrupt fires. This
                           function executes at TPL_HIGH_LEVEL. The DXE Core will
                           register a handler for the timer interrupt, so it can know
                           how much time has passed. This information is used to
                           signal timer based events. NULL will unregister the handler.
  @retval EFI_SUCCESS           The timer handler was registered.
  @retval EFI_UNSUPPORTED       The platform does not support timer interrupts.
  @retval EFI_ALREADY_STARTED   NotifyFunction is not NULL, and a handler is already
                                registered.
  @retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
                                previously registered.
  @retval EFI_DEVICE_ERROR      The timer handler could not be registered.

**/
EFI_STATUS
EFIAPI
TimerDriverRegisterHandler (
  IN EFI_TIMER_ARCH_PROTOCOL  *This,
  IN EFI_TIMER_NOTIFY         NotifyFunction
  )
{
  if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {
    return EFI_ALREADY_STARTED;
  }

  mTimerNotifyFunction = NotifyFunction;

  return EFI_SUCCESS;
}

/**

  This function adjusts the period of timer interrupts to the value specified 
  by TimerPeriod.  If the timer period is updated, then the selected timer 
  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If 
  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  
  If an error occurs while attempting to update the timer period, then the 
  timer hardware will be put back in its state prior to this call, and 
  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt 
  is disabled.  This is not the same as disabling the CPU's interrupts.  
  Instead, it must either turn off the timer hardware, or it must adjust the 
  interrupt controller so that a CPU interrupt is not generated when the timer 
  interrupt fires. 

  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
  @param  TimerPeriod      The rate to program the timer interrupt in 100 nS units. If
                           the timer hardware is not programmable, then EFI_UNSUPPORTED is
                           returned. If the timer is programmable, then the timer period
                           will be rounded up to the nearest timer period that is supported
                           by the timer hardware. If TimerPeriod is set to 0, then the
                           timer interrupts will be disabled.


  @retval EFI_SUCCESS           The timer period was changed.
  @retval EFI_UNSUPPORTED       The platform cannot change the period of the timer interrupt.
  @retval EFI_DEVICE_ERROR      The timer period could not be changed due to a device error.

**/
EFI_STATUS
EFIAPI
TimerDriverSetTimerPeriod (
  IN EFI_TIMER_ARCH_PROTOCOL  *This,
  IN UINT64                   TimerPeriod
  )
{
  EFI_STATUS  Status;
  UINT64      TimerTicks;

  
  // always disable the timer
  MmioAnd32 (EB_SP804_TIMER0_BASE + SP804_TIMER_CONTROL_REG, ~SP804_TIMER_CTRL_ENABLE);

  if (TimerPeriod == 0) {
    // leave timer disabled from above, and...

    // disable timer 0/1 interrupt for a TimerPeriod of 0

    
    Status = gInterrupt->DisableInterruptSource (gInterrupt, gVector);    
  } else {  
    // Convert TimerPeriod into 1MHz clock counts (us units = 100ns units / 10)

    TimerTicks = DivU64x32 (TimerPeriod, 10);

   
    // if it's larger than 32-bits, pin to highest value

    if (TimerTicks > 0xffffffff) {

      TimerTicks = 0xffffffff;

    }


    // Program the SP804 timer with the new count value

    MmioWrite32 (EB_SP804_TIMER0_BASE + SP804_TIMER_LOAD_REG, TimerTicks);

    
    // enable the timer

    MmioOr32 (EB_SP804_TIMER0_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);


    // enable timer 0/1 interrupts

    Status = gInterrupt->EnableInterruptSource (gInterrupt, gVector);    
  }

  //
  // Save the new timer period
  //
  mTimerPeriod = TimerPeriod;
  return Status;
}


/**
  This function retrieves the period of timer interrupts in 100 ns units, 
  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod 
  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is 
  returned, then the timer is currently disabled.

  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.
  @param  TimerPeriod      A pointer to the timer period to retrieve in 100 ns units. If
                           0 is returned, then the timer is currently disabled.


  @retval EFI_SUCCESS           The timer period was returned in TimerPeriod.
  @retval EFI_INVALID_PARAMETER TimerPeriod is NULL.

**/
EFI_STATUS
EFIAPI
TimerDriverGetTimerPeriod (
  IN EFI_TIMER_ARCH_PROTOCOL   *This,
  OUT UINT64                   *TimerPeriod
  )
{
  if (TimerPeriod == NULL) {
    return EFI_INVALID_PARAMETER;
  }

  *TimerPeriod = mTimerPeriod;
  return EFI_SUCCESS;
}

/**
  This function generates a soft timer interrupt. If the platform does not support soft 
  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. 
  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() 
  service, then a soft timer interrupt will be generated. If the timer interrupt is 
  enabled when this service is called, then the registered handler will be invoked. The 
  registered handler should not be able to distinguish a hardware-generated timer 
  interrupt from a software-generated timer interrupt.

  @param  This             The EFI_TIMER_ARCH_PROTOCOL instance.

  @retval EFI_SUCCESS           The soft timer interrupt was generated.
  @retval EFI_UNSUPPORTED       The platform does not support the generation of soft timer interrupts.

**/
EFI_STATUS
EFIAPI
TimerDriverGenerateSoftInterrupt (
  IN EFI_TIMER_ARCH_PROTOCOL  *This
  )
{
  return EFI_UNSUPPORTED;
}


/**
  Interface stucture for the Timer Architectural Protocol.

  @par Protocol Description:
  This protocol provides the services to initialize a periodic timer 
  interrupt, and to register a handler that is called each time the timer
  interrupt fires.  It may also provide a service to adjust the rate of the
  periodic timer interrupt.  When a timer interrupt occurs, the handler is 
  passed the amount of time that has passed since the previous timer 
  interrupt.

  @param RegisterHandler
  Registers a handler that will be called each time the 
  timer interrupt fires.  TimerPeriod defines the minimum 
  time between timer interrupts, so TimerPeriod will also 
  be the minimum time between calls to the registered 
  handler.

  @param SetTimerPeriod
  Sets the period of the timer interrupt in 100 nS units.  
  This function is optional, and may return EFI_UNSUPPORTED.  
  If this function is supported, then the timer period will 
  be rounded up to the nearest supported timer period.


  @param GetTimerPeriod
  Retrieves the period of the timer interrupt in 100 nS units.

  @param GenerateSoftInterrupt
  Generates a soft timer interrupt that simulates the firing of 
  the timer interrupt. This service can be used to invoke the   registered handler if the timer interrupt has been masked for 
  a period of time.

**/
EFI_TIMER_ARCH_PROTOCOL   gTimer = {
  TimerDriverRegisterHandler,
  TimerDriverSetTimerPeriod,
  TimerDriverGetTimerPeriod,
  TimerDriverGenerateSoftInterrupt
};


/**
  Initialize the state information for the Timer Architectural Protocol and
  the Timer Debug support protocol that allows the debugger to break into a
  running program.

  @param  ImageHandle   of the loaded driver
  @param  SystemTable   Pointer to the System Table

  @retval EFI_SUCCESS           Protocol registered
  @retval EFI_OUT_OF_RESOURCES  Cannot allocate protocol data structure
  @retval EFI_DEVICE_ERROR      Hardware problems

**/
EFI_STATUS
EFIAPI
TimerInitialize (
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
  EFI_HANDLE  Handle = NULL;
  EFI_STATUS  Status;

  Status = gBS->LocateProtocol(&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);\r
  ASSERT_EFI_ERROR(Status);\r

  // configure free running timer (TIMER1) for 1MHz operation
  

  // AND disable clock, OR configure 1MHz clock
  MmioAndThenOr32 (EB_SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER1_EN, SP810_SYS_CTRL_TIMER1_TIMCLK);  


  // Renable timer
  MmioOr32 (EB_SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER1_EN);  

    
  // configure timer 1 for free running operation, 32 bits, no prescaler, interrupt disabled
  MmioWrite32 (EB_SP804_TIMER1_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_32BIT | SP804_PRESCALE_DIV_1);

  // enable the free running timer
  MmioOr32 (EB_SP804_TIMER1_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);

  // record free running tick value (should be close to 0xffffffff)
  mLastTickCount = MmioRead32 (EB_SP804_TIMER1_BASE + SP804_TIMER_CURRENT_REG);


  // Disable the timer
  Status = TimerDriverSetTimerPeriod (&gTimer, 0);
  ASSERT_EFI_ERROR (Status);

  // Install interrupt handler
  gVector = EB_TIMER01_INTERRUPT_NUM;
  Status = gInterrupt->RegisterInterruptSource (gInterrupt, gVector, TimerInterruptHandler);
  ASSERT_EFI_ERROR (Status);


  // configure periodic timer (TIMER0) for 1MHz operation
  MmioAndThenOr32 (EB_SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER0_EN, SP810_SYS_CTRL_TIMER0_TIMCLK);


  // Renable timer
  MmioOr32 (EB_SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER0_EN);  


  // configure timer 0 for periodic operation, 32 bits, no prescaler, and interrupt enabled
  MmioWrite32 (EB_SP804_TIMER0_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_PERIODIC | SP804_TIMER_CTRL_32BIT | SP804_PRESCALE_DIV_1 | SP804_TIMER_CTRL_INT_ENABLE);

  // Set up default timer
  Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD
  ASSERT_EFI_ERROR (Status);

  // Install the Timer Architectural Protocol onto a new handle
  Status = gBS->InstallMultipleProtocolInterfaces(
                  &Handle,
                  &gEfiTimerArchProtocolGuid,      &gTimer,
                  NULL
                  );
  ASSERT_EFI_ERROR(Status);

  return Status;
}
Commit	Line	Data
5f4dc6dd	1	/** @file
	2	Template for Timer Architecture Protocol driver of the ARM flavor
	3
	4	Copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
	5
	6	This program and the accompanying materials
	7	are licensed and made available under the terms and conditions of the BSD License
	8	which accompanies this distribution. The full text of the license may be found at
	9	http://opensource.org/licenses/bsd-license.php
	10
	11	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
	12	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
	13
	14	**/
	15
	16
	17	#include <PiDxe.h>
	18
	19	#include <Library/BaseLib.h>
	20	#include <Library/DebugLib.h>
	21	#include <Library/BaseMemoryLib.h>
	22	#include <Library/UefiBootServicesTableLib.h>
	23	#include <Library/UefiLib.h>
	24	#include <Library/PcdLib.h>
	25	#include <Library/IoLib.h>
5f4dc6dd	26
	27	#include <Protocol/Timer.h>
	28	#include <Protocol/HardwareInterrupt.h>
	29
	30	#include <ArmEb/ArmEb.h>
	31
	32
	33	// The notification function to call on every timer interrupt.
	34	volatile EFI_TIMER_NOTIFY mTimerNotifyFunction = (EFI_TIMER_NOTIFY)NULL;
	35
	36
	37	// The current period of the timer interrupt
	38	volatile UINT64 mTimerPeriod = 0;
	39
	40	// Cached copy of the Hardware Interrupt protocol instance
	41	EFI_HARDWARE_INTERRUPT_PROTOCOL *gInterrupt = NULL;
	42
	43	// Cached interrupt vector
	44	UINTN gVector;
	45
92032841	46	UINT32 mLastTickCount;
92032841	47
5f4dc6dd	48
	49	/**
	50
	51	C Interrupt Handler calledin the interrupt context when Source interrupt is active.
	52
	53
	54	@param Source Source of the interrupt. Hardware routing off a specific platform defines
	55	what source means.
	56
	57	@param SystemContext Pointer to system register context. Mostly used by debuggers and will
	58	update the system context after the return from the interrupt if
	59	modified. Don't change these values unless you know what you are doing
	60
	61	**/
	62	VOID
	63	EFIAPI
	64	TimerInterruptHandler (
	65	IN HARDWARE_INTERRUPT_SOURCE Source,
	66	IN EFI_SYSTEM_CONTEXT SystemContext
	67	)
	68	{
	69	EFI_TPL OriginalTPL;
	70
	71	//
	72	// DXE core uses this callback for the EFI timer tick. The DXE core uses locks
	73	// that raise to TPL_HIGH and then restore back to current level. Thus we need
	74	// to make sure TPL level is set to TPL_HIGH while we are handling the timer tick.
	75	//
	76	OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);
	77
4cb67745	78	// clear the periodic interrupt
4cb67745	79
5f4dc6dd	80	MmioWrite32 (EB_SP804_TIMER0_BASE + SP804_TIMER_INT_CLR_REG, 0);
	81
	82	// signal end of interrupt early to help avoid losing subsequent ticks from long duration handlers
	83	gInterrupt->EndOfInterrupt (gInterrupt, Source);
	84
	85	if (mTimerNotifyFunction) {
	86	mTimerNotifyFunction (mTimerPeriod);
	87	}
	88
	89	gBS->RestoreTPL (OriginalTPL);
	90	}
	91
	92
	93	/**
	94	This function registers the handler NotifyFunction so it is called every time
	95	the timer interrupt fires. It also passes the amount of time since the last
	96	handler call to the NotifyFunction. If NotifyFunction is NULL, then the
	97	handler is unregistered. If the handler is registered, then EFI_SUCCESS is
	98	returned. If the CPU does not support registering a timer interrupt handler,
	99	then EFI_UNSUPPORTED is returned. If an attempt is made to register a handler
	100	when a handler is already registered, then EFI_ALREADY_STARTED is returned.
	101	If an attempt is made to unregister a handler when a handler is not registered,
	102	then EFI_INVALID_PARAMETER is returned. If an error occurs attempting to
	103	register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR
	104	is returned.
	105
	106	@param This The EFI_TIMER_ARCH_PROTOCOL instance.
	107	@param NotifyFunction The function to call when a timer interrupt fires. This
	108	function executes at TPL_HIGH_LEVEL. The DXE Core will
	109	register a handler for the timer interrupt, so it can know
	110	how much time has passed. This information is used to
	111	signal timer based events. NULL will unregister the handler.
	112	@retval EFI_SUCCESS The timer handler was registered.
	113	@retval EFI_UNSUPPORTED The platform does not support timer interrupts.
	114	@retval EFI_ALREADY_STARTED NotifyFunction is not NULL, and a handler is already
	115	registered.
	116	@retval EFI_INVALID_PARAMETER NotifyFunction is NULL, and a handler was not
	117	previously registered.
	118	@retval EFI_DEVICE_ERROR The timer handler could not be registered.
	119
	120	**/
	121	EFI_STATUS
	122	EFIAPI
	123	TimerDriverRegisterHandler (
	124	IN EFI_TIMER_ARCH_PROTOCOL *This,
	125	IN EFI_TIMER_NOTIFY NotifyFunction
	126	)
	127	{
	128	if ((NotifyFunction == NULL) && (mTimerNotifyFunction == NULL)) {
	129	return EFI_INVALID_PARAMETER;
	130	}
	131
	132	if ((NotifyFunction != NULL) && (mTimerNotifyFunction != NULL)) {
	133	return EFI_ALREADY_STARTED;
	134	}
	135
	136	mTimerNotifyFunction = NotifyFunction;
	137
	138	return EFI_SUCCESS;
	139	}
	140
	141	/**
	142
	143	This function adjusts the period of timer interrupts to the value specified
144	by TimerPeriod. If the timer period is updated, then the selected timer
145	period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned. If
146	the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.
147	If an error occurs while attempting to update the timer period, then the
148	timer hardware will be put back in its state prior to this call, and
149	EFI_DEVICE_ERROR is returned. If TimerPeriod is 0, then the timer interrupt
150	is disabled. This is not the same as disabling the CPU's interrupts.
151	Instead, it must either turn off the timer hardware, or it must adjust the
152	interrupt controller so that a CPU interrupt is not generated when the timer
153	interrupt fires.
154
155	@param This The EFI_TIMER_ARCH_PROTOCOL instance.
156	@param TimerPeriod The rate to program the timer interrupt in 100 nS units. If
157	the timer hardware is not programmable, then EFI_UNSUPPORTED is
158	returned. If the timer is programmable, then the timer period
159	will be rounded up to the nearest timer period that is supported
160	by the timer hardware. If TimerPeriod is set to 0, then the
161	timer interrupts will be disabled.
162
163
164	@retval EFI_SUCCESS The timer period was changed.
165	@retval EFI_UNSUPPORTED The platform cannot change the period of the timer interrupt.
166	@retval EFI_DEVICE_ERROR The timer period could not be changed due to a device error.
167
168	**/
169	EFI_STATUS
170	EFIAPI
171	TimerDriverSetTimerPeriod (
172	IN EFI_TIMER_ARCH_PROTOCOL *This,
173	IN UINT64 TimerPeriod
174	)
175	{
176	EFI_STATUS Status;
4cb67745	177	UINT64 TimerTicks;
4cb67745	178
5f4dc6dd	179
	180	// always disable the timer
	181	MmioAnd32 (EB_SP804_TIMER0_BASE + SP804_TIMER_CONTROL_REG, ~SP804_TIMER_CTRL_ENABLE);
	182
	183	if (TimerPeriod == 0) {
4cb67745	184	// leave timer disabled from above, and...
	185
	186	// disable timer 0/1 interrupt for a TimerPeriod of 0
	187
5f4dc6dd	188
	189	Status = gInterrupt->DisableInterruptSource (gInterrupt, gVector);
	190	} else {
4cb67745	191	// Convert TimerPeriod into 1MHz clock counts (us units = 100ns units / 10)
	192
	193	TimerTicks = DivU64x32 (TimerPeriod, 10);
	194
	195
	196
	197	// if it's larger than 32-bits, pin to highest value
	198
	199	if (TimerTicks > 0xffffffff) {
	200
	201	TimerTicks = 0xffffffff;
	202
	203	}
	204
	205
	206
	207	// Program the SP804 timer with the new count value
	208
	209	MmioWrite32 (EB_SP804_TIMER0_BASE + SP804_TIMER_LOAD_REG, TimerTicks);
	210
	211
	212
	213	// enable the timer
	214
	215	MmioOr32 (EB_SP804_TIMER0_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);
	216
	217
	218
	219	// enable timer 0/1 interrupts
	220
5f4dc6dd	221	Status = gInterrupt->EnableInterruptSource (gInterrupt, gVector);
	222	}
	223
	224	//
	225	// Save the new timer period
	226	//
	227	mTimerPeriod = TimerPeriod;
	228	return Status;
	229	}
	230
	231
	232	/**
	233	This function retrieves the period of timer interrupts in 100 ns units,
	234	returns that value in TimerPeriod, and returns EFI_SUCCESS. If TimerPeriod
	235	is NULL, then EFI_INVALID_PARAMETER is returned. If a TimerPeriod of 0 is
	236	returned, then the timer is currently disabled.
	237
	238	@param This The EFI_TIMER_ARCH_PROTOCOL instance.
	239	@param TimerPeriod A pointer to the timer period to retrieve in 100 ns units. If
	240	0 is returned, then the timer is currently disabled.
	241
	242
	243	@retval EFI_SUCCESS The timer period was returned in TimerPeriod.
	244	@retval EFI_INVALID_PARAMETER TimerPeriod is NULL.
	245
	246	**/
	247	EFI_STATUS
	248	EFIAPI
	249	TimerDriverGetTimerPeriod (
	250	IN EFI_TIMER_ARCH_PROTOCOL *This,
	251	OUT UINT64 *TimerPeriod
	252	)
	253	{
	254	if (TimerPeriod == NULL) {
	255	return EFI_INVALID_PARAMETER;
	256	}
	257
	258	*TimerPeriod = mTimerPeriod;
	259	return EFI_SUCCESS;
	260	}
	261
	262	/**
	263	This function generates a soft timer interrupt. If the platform does not support soft
	264	timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned.
	265	If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler()
	266	service, then a soft timer interrupt will be generated. If the timer interrupt is
	267	enabled when this service is called, then the registered handler will be invoked. The
	268	registered handler should not be able to distinguish a hardware-generated timer
	269	interrupt from a software-generated timer interrupt.
	270
	271	@param This The EFI_TIMER_ARCH_PROTOCOL instance.
	272
	273	@retval EFI_SUCCESS The soft timer interrupt was generated.
	274	@retval EFI_UNSUPPORTED The platform does not support the generation of soft timer interrupts.
	275
	276	**/
	277	EFI_STATUS
	278	EFIAPI
	279	TimerDriverGenerateSoftInterrupt (
	280	IN EFI_TIMER_ARCH_PROTOCOL *This
	281	)
	282	{
	283	return EFI_UNSUPPORTED;
	284	}
285
286
287
288	/**
289	Interface stucture for the Timer Architectural Protocol.
290
291	@par Protocol Description:
292	This protocol provides the services to initialize a periodic timer
293	interrupt, and to register a handler that is called each time the timer
294	interrupt fires. It may also provide a service to adjust the rate of the
295	periodic timer interrupt. When a timer interrupt occurs, the handler is
296	passed the amount of time that has passed since the previous timer
297	interrupt.
298
299	@param RegisterHandler
300	Registers a handler that will be called each time the
301	timer interrupt fires. TimerPeriod defines the minimum
302	time between timer interrupts, so TimerPeriod will also
303	be the minimum time between calls to the registered
304	handler.
305
306	@param SetTimerPeriod
307	Sets the period of the timer interrupt in 100 nS units.
308	This function is optional, and may return EFI_UNSUPPORTED.
309	If this function is supported, then the timer period will
310	be rounded up to the nearest supported timer period.
311
312
313	@param GetTimerPeriod
314	Retrieves the period of the timer interrupt in 100 nS units.
315
316	@param GenerateSoftInterrupt
317	Generates a soft timer interrupt that simulates the firing of
318	the timer interrupt. This service can be used to invoke the registered handler if the timer interrupt has been masked for
319	a period of time.
320
321	**/
322	EFI_TIMER_ARCH_PROTOCOL gTimer = {
323	TimerDriverRegisterHandler,
324	TimerDriverSetTimerPeriod,
325	TimerDriverGetTimerPeriod,
326	TimerDriverGenerateSoftInterrupt
327	};
328
329
330	/**
331	Initialize the state information for the Timer Architectural Protocol and
332	the Timer Debug support protocol that allows the debugger to break into a
333	running program.
334
335	@param ImageHandle of the loaded driver
336	@param SystemTable Pointer to the System Table
337
338	@retval EFI_SUCCESS Protocol registered
339	@retval EFI_OUT_OF_RESOURCES Cannot allocate protocol data structure
340	@retval EFI_DEVICE_ERROR Hardware problems
341
342	**/
343	EFI_STATUS
344	EFIAPI
345	TimerInitialize (
346	IN EFI_HANDLE ImageHandle,
347	IN EFI_SYSTEM_TABLE *SystemTable
348	)
349	{
350	EFI_HANDLE Handle = NULL;
351	EFI_STATUS Status;
4cb67745	352
afdfe8f0	353	Status = gBS->LocateProtocol(&gHardwareInterruptProtocolGuid, NULL, (VOID **)&gInterrupt);\r
afdfe8f0	354	ASSERT_EFI_ERROR(Status);\r
4cb67745	355
	356	// configure free running timer (TIMER1) for 1MHz operation
	357
	358
	359	// AND disable clock, OR configure 1MHz clock
	360	MmioAndThenOr32 (EB_SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER1_EN, SP810_SYS_CTRL_TIMER1_TIMCLK);
	361
	362
	363	// Renable timer
	364	MmioOr32 (EB_SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER1_EN);
	365
	366
	367	// configure timer 1 for free running operation, 32 bits, no prescaler, interrupt disabled
	368	MmioWrite32 (EB_SP804_TIMER1_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_32BIT \| SP804_PRESCALE_DIV_1);
	369
	370	// enable the free running timer
	371	MmioOr32 (EB_SP804_TIMER1_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_ENABLE);
	372
	373	// record free running tick value (should be close to 0xffffffff)
	374	mLastTickCount = MmioRead32 (EB_SP804_TIMER1_BASE + SP804_TIMER_CURRENT_REG);
	375
	376
5f4dc6dd	377	// Disable the timer
	378	Status = TimerDriverSetTimerPeriod (&gTimer, 0);
	379	ASSERT_EFI_ERROR (Status);
5f4dc6dd	380
	381	// Install interrupt handler
	382	gVector = EB_TIMER01_INTERRUPT_NUM;
	383	Status = gInterrupt->RegisterInterruptSource (gInterrupt, gVector, TimerInterruptHandler);
	384	ASSERT_EFI_ERROR (Status);
5f4dc6dd	385
5f4dc6dd	386
4cb67745	387	// configure periodic timer (TIMER0) for 1MHz operation
	388	MmioAndThenOr32 (EB_SP810_CTRL_BASE + SP810_SYS_CTRL_REG, ~SP810_SYS_CTRL_TIMER0_EN, SP810_SYS_CTRL_TIMER0_TIMCLK);
	389
	390
	391	// Renable timer
	392	MmioOr32 (EB_SP810_CTRL_BASE + SP810_SYS_CTRL_REG, SP810_SYS_CTRL_TIMER0_EN);
	393
	394
	395	// configure timer 0 for periodic operation, 32 bits, no prescaler, and interrupt enabled
	396	MmioWrite32 (EB_SP804_TIMER0_BASE + SP804_TIMER_CONTROL_REG, SP804_TIMER_CTRL_PERIODIC \| SP804_TIMER_CTRL_32BIT \| SP804_PRESCALE_DIV_1 \| SP804_TIMER_CTRL_INT_ENABLE);
	397
5f4dc6dd	398	// Set up default timer
	399	Status = TimerDriverSetTimerPeriod (&gTimer, FixedPcdGet32(PcdTimerPeriod)); // TIMER_DEFAULT_PERIOD
	400	ASSERT_EFI_ERROR (Status);
	401
	402	// Install the Timer Architectural Protocol onto a new handle
	403	Status = gBS->InstallMultipleProtocolInterfaces(
	404	&Handle,
	405	&gEfiTimerArchProtocolGuid, &gTimer,
	406	NULL
	407	);
	408	ASSERT_EFI_ERROR(Status);
	409
	410	return Status;
	411	}
	412