Add in TimerDxe
authorqwang12 <qwang12@6f19259b-4bc3-4df7-8a09-765794883524>
Wed, 27 Jun 2007 08:08:24 +0000 (08:08 +0000)
committerqwang12 <qwang12@6f19259b-4bc3-4df7-8a09-765794883524>
Wed, 27 Jun 2007 08:08:24 +0000 (08:08 +0000)
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2791 6f19259b-4bc3-4df7-8a09-765794883524

Nt32Pkg/TimerDxe/CommonHeader.h [new file with mode: 0644]
Nt32Pkg/TimerDxe/Timer.c [new file with mode: 0644]
Nt32Pkg/TimerDxe/Timer.dxs [new file with mode: 0644]
Nt32Pkg/TimerDxe/Timer.h [new file with mode: 0644]
Nt32Pkg/TimerDxe/Timer.inf [new file with mode: 0644]
Nt32Pkg/TimerDxe/Timer.msa [new file with mode: 0644]

diff --git a/Nt32Pkg/TimerDxe/CommonHeader.h b/Nt32Pkg/TimerDxe/CommonHeader.h
new file mode 100644 (file)
index 0000000..e497b7c
--- /dev/null
@@ -0,0 +1,37 @@
+/**@file\r
+  Common header file shared by all source files.\r
+\r
+  This file includes package header files, library classes and protocol, PPI & GUID definitions.\r
+\r
+  Copyright (c) 2006 - 2007, 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
+   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
+#ifndef __COMMON_HEADER_H_\r
+#define __COMMON_HEADER_H_\r
+\r
+\r
+//\r
+// The package level header files this module uses\r
+//\r
+#include <PiDxe.h>\r
+#include <WinNtDxe.h>\r
+//\r
+// The protocols, PPI and GUID defintions for this module\r
+//\r
+#include <Protocol/Timer.h>\r
+#include <Protocol/Cpu.h>\r
+//\r
+// The Library classes this module consumes\r
+//\r
+#include <Library/DebugLib.h>\r
+#include <Library/UefiDriverEntryPoint.h>\r
+#include <Library/WinNtLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+\r
+#endif\r
diff --git a/Nt32Pkg/TimerDxe/Timer.c b/Nt32Pkg/TimerDxe/Timer.c
new file mode 100644 (file)
index 0000000..363f104
--- /dev/null
@@ -0,0 +1,602 @@
+/*++\r
+\r
+Copyright (c) 2006, 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
+Module Name:\r
+\r
+  Timer.c\r
+\r
+Abstract:\r
+\r
+  NT Emulation Timer Architectural Protocol Driver as defined in DXE CIS\r
+\r
+  This Timer module uses an NT Thread to simulate the timer-tick driven\r
+  timer service.  In the future, the Thread creation should possibly be \r
+  abstracted by the CPU architectural protocol\r
+\r
+--*/\r
+\r
+//\r
+// Include common header file for this module.\r
+//\r
+#include "CommonHeader.h"\r
+\r
+#include "Timer.h"\r
+\r
+//\r
+// Pointer to the CPU Architectural Protocol instance\r
+//\r
+EFI_CPU_ARCH_PROTOCOL   *mCpu;\r
+\r
+//\r
+// The Timer Architectural Protocol that this driver produces\r
+//\r
+EFI_TIMER_ARCH_PROTOCOL mTimer = {\r
+  WinNtTimerDriverRegisterHandler,\r
+  WinNtTimerDriverSetTimerPeriod,\r
+  WinNtTimerDriverGetTimerPeriod,\r
+  WinNtTimerDriverGenerateSoftInterrupt\r
+};\r
+\r
+//\r
+// Define a global that we can use to shut down the NT timer thread when\r
+// the timer is canceled.\r
+//\r
+BOOLEAN                 mCancelTimerThread = FALSE;\r
+\r
+//\r
+// The notification function to call on every timer interrupt\r
+//\r
+EFI_TIMER_NOTIFY        mTimerNotifyFunction = NULL;\r
+\r
+//\r
+// The current period of the timer interrupt\r
+//\r
+UINT64                  mTimerPeriod;\r
+\r
+//\r
+// The thread handle for this driver\r
+//\r
+HANDLE                  mNtMainThreadHandle;\r
+\r
+//\r
+// The timer value from the last timer interrupt\r
+//\r
+UINT32                  mNtLastTick;\r
+\r
+//\r
+// Critical section used to update varibles shared between the main thread and\r
+// the timer interrupt thread.\r
+//\r
+CRITICAL_SECTION        mNtCriticalSection;\r
+\r
+//\r
+// Worker Functions\r
+//\r
+UINT                    mMMTimerThreadID = 0;\r
+\r
+VOID\r
+CALLBACK\r
+MMTimerThread (\r
+  UINT  wTimerID,\r
+  UINT  msg,\r
+  DWORD dwUser,\r
+  DWORD dw1,\r
+  DWORD dw2\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  TODO: Add function description\r
+\r
+Arguments:\r
+\r
+  wTimerID  - TODO: add argument description\r
+  msg       - TODO: add argument description\r
+  dwUser    - TODO: add argument description\r
+  dw1       - TODO: add argument description\r
+  dw2       - TODO: add argument description\r
+\r
+Returns:\r
+\r
+  TODO: add return values\r
+\r
+--*/\r
+{\r
+  EFI_TPL           OriginalTPL;\r
+  UINT32            CurrentTick;\r
+  UINT32            Delta;\r
+  EFI_TIMER_NOTIFY  CallbackFunction;\r
+  BOOLEAN           InterruptState;\r
+\r
+  if (!mCancelTimerThread) {\r
+  \r
+    //\r
+    //  Suspend the main thread until we are done\r
+    //\r
+\r
+    gWinNt->SuspendThread (mNtMainThreadHandle);\r
+\r
+    //\r
+    // If the timer thread is being canceled, then bail immediately.\r
+    // We check again here because there's a small window of time from when\r
+    // this thread was kicked off and when we suspended the main thread above.\r
+    //\r
+    if (mCancelTimerThread) {\r
+      gWinNt->ResumeThread (mNtMainThreadHandle);\r
+      gWinNt->timeKillEvent (wTimerID);\r
+      mMMTimerThreadID = 0;\r
+      return ;\r
+    }\r
+\r
+    mCpu->GetInterruptState (mCpu, &InterruptState);\r
+    while (!InterruptState) {\r
+      //\r
+      //  Resume the main thread\r
+      //\r
+      gWinNt->ResumeThread (mNtMainThreadHandle);\r
+\r
+      //\r
+      //  Wait for interrupts to be enabled.\r
+      //\r
+      mCpu->GetInterruptState (mCpu, &InterruptState);\r
+      while (!InterruptState) {\r
+        gWinNt->Sleep (0);\r
+        mCpu->GetInterruptState (mCpu, &InterruptState);\r
+      }\r
+       \r
+      //\r
+      //  Suspend the main thread until we are done\r
+      //\r
+      gWinNt->SuspendThread (mNtMainThreadHandle);\r
+      mCpu->GetInterruptState (mCpu, &InterruptState);\r
+    }\r
+\r
+    //\r
+    //  Get the current system tick\r
+    //\r
+    CurrentTick = gWinNt->GetTickCount ();\r
+    Delta       = CurrentTick - mNtLastTick;\r
+    mNtLastTick = CurrentTick;\r
+\r
+    //\r
+    //  If delay was more then 1 second, ignore it (probably debugging case)\r
+    //\r
+    if (Delta < 1000) {\r
+\r
+      OriginalTPL = gBS->RaiseTPL (TPL_HIGH_LEVEL);\r
+\r
+      //\r
+      //  Inform the firmware of an "timer interrupt".  The time\r
+      //  expired since the last call is 10,000 times the number\r
+      //  of ms.  (or 100ns units)\r
+      //\r
+      gWinNt->EnterCriticalSection (&mNtCriticalSection);\r
+      CallbackFunction = mTimerNotifyFunction;\r
+      gWinNt->LeaveCriticalSection (&mNtCriticalSection);\r
+\r
+      //\r
+      // Only invoke the callback function if a Non-NULL handler has been\r
+      // registered. Assume all other handlers are legal.\r
+      //\r
+      if (CallbackFunction != NULL) {\r
+        CallbackFunction ((UINT64) (Delta * 10000));\r
+      }\r
+\r
+      gBS->RestoreTPL (OriginalTPL);\r
+\r
+    }\r
+\r
+    //\r
+    //  Resume the main thread\r
+    //\r
+    gWinNt->ResumeThread (mNtMainThreadHandle);\r
+  } else {\r
+    gWinNt->timeKillEvent (wTimerID);\r
+    mMMTimerThreadID = 0;\r
+  }\r
+\r
+}\r
+\r
+UINT\r
+CreateNtTimer (\r
+  VOID\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+   It is used to emulate a platform \r
+  timer-driver interrupt handler.  \r
+\r
+Returns:\r
+\r
+  Timer ID\r
+\r
+--*/\r
+// TODO: function comment is missing 'Arguments:'\r
+{\r
+  UINT32  SleepCount;\r
+\r
+  //\r
+  //  Set our thread priority higher than the "main" thread.\r
+  //\r
+  gWinNt->SetThreadPriority (\r
+            gWinNt->GetCurrentThread (),\r
+            THREAD_PRIORITY_HIGHEST\r
+            );\r
+\r
+  //\r
+  //  Calc the appropriate interval\r
+  //\r
+  gWinNt->EnterCriticalSection (&mNtCriticalSection);\r
+  SleepCount = (UINT32) (mTimerPeriod + 5000) / 10000;\r
+  gWinNt->LeaveCriticalSection (&mNtCriticalSection);\r
+\r
+  return gWinNt->timeSetEvent (\r
+                  SleepCount,\r
+                  0,\r
+                  MMTimerThread,\r
+                  (DWORD_PTR) NULL,\r
+                  TIME_PERIODIC | TIME_KILL_SYNCHRONOUS | TIME_CALLBACK_FUNCTION\r
+                  );\r
+\r
+}\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverRegisterHandler (\r
+  IN EFI_TIMER_ARCH_PROTOCOL           *This,\r
+  IN EFI_TIMER_NOTIFY                  NotifyFunction\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  This function registers the handler NotifyFunction so it is called every time \r
+  the timer interrupt fires.  It also passes the amount of time since the last \r
+  handler call to the NotifyFunction.  If NotifyFunction is NULL, then the \r
+  handler is unregistered.  If the handler is registered, then EFI_SUCCESS is \r
+  returned.  If the CPU does not support registering a timer interrupt handler, \r
+  then EFI_UNSUPPORTED is returned.  If an attempt is made to register a handler \r
+  when a handler is already registered, then EFI_ALREADY_STARTED is returned.  \r
+  If an attempt is made to unregister a handler when a handler is not registered, \r
+  then EFI_INVALID_PARAMETER is returned.  If an error occurs attempting to \r
+  register the NotifyFunction with the timer interrupt, then EFI_DEVICE_ERROR \r
+  is returned.\r
+\r
+Arguments:\r
+\r
+  This           - The EFI_TIMER_ARCH_PROTOCOL instance.\r
+\r
+  NotifyFunction - The function to call when a timer interrupt fires.  This \r
+                   function executes at TPL_HIGH_LEVEL.  The DXE Core will \r
+                   register a handler for the timer interrupt, so it can know \r
+                   how much time has passed.  This information is used to \r
+                   signal timer based events.  NULL will unregister the handler.\r
+\r
+Returns: \r
+\r
+  EFI_SUCCESS           - The timer handler was registered.\r
+\r
+  EFI_UNSUPPORTED       - The platform does not support timer interrupts.\r
+\r
+  EFI_ALREADY_STARTED   - NotifyFunction is not NULL, and a handler is already \r
+                          registered.\r
+\r
+  EFI_INVALID_PARAMETER - NotifyFunction is NULL, and a handler was not \r
+                          previously registered.\r
+\r
+  EFI_DEVICE_ERROR      - The timer handler could not be registered.\r
+\r
+--*/\r
+{\r
+  //\r
+  // Check for invalid parameters\r
+  //\r
+  if (NotifyFunction == NULL && mTimerNotifyFunction == NULL) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (NotifyFunction != NULL && mTimerNotifyFunction != NULL) {\r
+    return EFI_ALREADY_STARTED;\r
+  }\r
+\r
+  //\r
+  // Use Critical Section to update the notification function that is\r
+  // used from the timer interrupt thread.\r
+  //\r
+  gWinNt->EnterCriticalSection (&mNtCriticalSection);\r
+\r
+  mTimerNotifyFunction = NotifyFunction;\r
+\r
+  gWinNt->LeaveCriticalSection (&mNtCriticalSection);\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverSetTimerPeriod (\r
+  IN EFI_TIMER_ARCH_PROTOCOL  *This,\r
+  IN UINT64                   TimerPeriod\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  This function adjusts the period of timer interrupts to the value specified \r
+  by TimerPeriod.  If the timer period is updated, then the selected timer \r
+  period is stored in EFI_TIMER.TimerPeriod, and EFI_SUCCESS is returned.  If \r
+  the timer hardware is not programmable, then EFI_UNSUPPORTED is returned.  \r
+  If an error occurs while attempting to update the timer period, then the \r
+  timer hardware will be put back in its state prior to this call, and \r
+  EFI_DEVICE_ERROR is returned.  If TimerPeriod is 0, then the timer interrupt \r
+  is disabled.  This is not the same as disabling the CPU's interrupts.  \r
+  Instead, it must either turn off the timer hardware, or it must adjust the \r
+  interrupt controller so that a CPU interrupt is not generated when the timer \r
+  interrupt fires. \r
+\r
+Arguments:\r
+\r
+  This        - The EFI_TIMER_ARCH_PROTOCOL instance.\r
+\r
+  TimerPeriod - The rate to program the timer interrupt in 100 nS units.  If \r
+                the timer hardware is not programmable, then EFI_UNSUPPORTED is \r
+                returned.  If the timer is programmable, then the timer period \r
+                will be rounded up to the nearest timer period that is supported \r
+                by the timer hardware.  If TimerPeriod is set to 0, then the \r
+                timer interrupts will be disabled.\r
+\r
+Returns: \r
+\r
+  EFI_SUCCESS      - The timer period was changed.\r
+\r
+  EFI_UNSUPPORTED  - The platform cannot change the period of the timer interrupt.\r
+\r
+  EFI_DEVICE_ERROR - The timer period could not be changed due to a device error.\r
+\r
+--*/\r
+{\r
+\r
+  //\r
+  // If TimerPeriod is 0, then the timer thread should be canceled\r
+  //\r
+  if (TimerPeriod == 0) {\r
+    //\r
+    // Cancel the timer thread\r
+    //\r
+    gWinNt->EnterCriticalSection (&mNtCriticalSection);\r
+\r
+    mCancelTimerThread = TRUE;\r
+\r
+    gWinNt->LeaveCriticalSection (&mNtCriticalSection);\r
+\r
+    //\r
+    // Wait for the timer thread to exit\r
+    //\r
+\r
+    if (mMMTimerThreadID) {\r
+      gWinNt->timeKillEvent (mMMTimerThreadID);\r
+    }\r
+\r
+    mMMTimerThreadID = 0;\r
+\r
+    //\r
+    // Update the timer period\r
+    //\r
+    gWinNt->EnterCriticalSection (&mNtCriticalSection);\r
+\r
+    mTimerPeriod = TimerPeriod;\r
+\r
+    gWinNt->LeaveCriticalSection (&mNtCriticalSection);\r
+\r
+    //\r
+    // NULL out the thread handle so it will be re-created if the timer is enabled again\r
+    //\r
+\r
+  } else if ((TimerPeriod > TIMER_MINIMUM_VALUE) && (TimerPeriod < TIMER_MAXIMUM_VALUE)) {\r
+    //\r
+    // If the TimerPeriod is valid, then create and/or adjust the period of the timer thread\r
+    //\r
+    gWinNt->EnterCriticalSection (&mNtCriticalSection);\r
+\r
+    mTimerPeriod        = TimerPeriod;\r
+\r
+    mCancelTimerThread  = FALSE;\r
+\r
+    gWinNt->LeaveCriticalSection (&mNtCriticalSection);\r
+\r
+    //\r
+    //  Get the starting tick location if we are just starting the timer thread\r
+    //\r
+    mNtLastTick = gWinNt->GetTickCount ();\r
+\r
+    if (mMMTimerThreadID) {\r
+      gWinNt->timeKillEvent (mMMTimerThreadID);\r
+    }\r
+\r
+    mMMTimerThreadID  = 0;\r
+\r
+    mMMTimerThreadID  = CreateNtTimer ();\r
+\r
+  }\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverGetTimerPeriod (\r
+  IN EFI_TIMER_ARCH_PROTOCOL            *This,\r
+  OUT UINT64                            *TimerPeriod\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  This function retrieves the period of timer interrupts in 100 ns units, \r
+  returns that value in TimerPeriod, and returns EFI_SUCCESS.  If TimerPeriod \r
+  is NULL, then EFI_INVALID_PARAMETER is returned.  If a TimerPeriod of 0 is \r
+  returned, then the timer is currently disabled.\r
+\r
+Arguments:\r
+\r
+  This        - The EFI_TIMER_ARCH_PROTOCOL instance.\r
+\r
+  TimerPeriod - A pointer to the timer period to retrieve in 100 ns units.  If \r
+                0 is returned, then the timer is currently disabled.\r
+\r
+Returns: \r
+\r
+  EFI_SUCCESS           - The timer period was returned in TimerPeriod.\r
+\r
+  EFI_INVALID_PARAMETER - TimerPeriod is NULL.\r
+\r
+--*/\r
+{\r
+  if (TimerPeriod == NULL) {\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  *TimerPeriod = mTimerPeriod;\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverGenerateSoftInterrupt (\r
+  IN EFI_TIMER_ARCH_PROTOCOL  *This\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  This function generates a soft timer interrupt. If the platform does not support soft \r
+  timer interrupts, then EFI_UNSUPPORTED is returned. Otherwise, EFI_SUCCESS is returned. \r
+  If a handler has been registered through the EFI_TIMER_ARCH_PROTOCOL.RegisterHandler() \r
+  service, then a soft timer interrupt will be generated. If the timer interrupt is \r
+  enabled when this service is called, then the registered handler will be invoked. The \r
+  registered handler should not be able to distinguish a hardware-generated timer \r
+  interrupt from a software-generated timer interrupt.\r
+\r
+Arguments:\r
+\r
+  This  -  The EFI_TIMER_ARCH_PROTOCOL instance.\r
+\r
+Returns: \r
+\r
+  EFI_SUCCESS       - The soft timer interrupt was generated.\r
+\r
+  EFI_UNSUPPORTEDT  - The platform does not support the generation of soft timer interrupts.\r
+\r
+--*/\r
+{\r
+  return EFI_UNSUPPORTED;\r
+}\r
+\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverInitialize (\r
+  IN EFI_HANDLE        ImageHandle,\r
+  IN EFI_SYSTEM_TABLE  *SystemTable\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Initialize the Timer Architectural Protocol driver\r
+\r
+Arguments:\r
+\r
+  ImageHandle - ImageHandle of the loaded driver\r
+\r
+  SystemTable - Pointer to the System Table\r
+\r
+Returns:\r
+\r
+  EFI_SUCCESS           - Timer Architectural Protocol created\r
+\r
+  EFI_OUT_OF_RESOURCES  - Not enough resources available to initialize driver.\r
+  \r
+  EFI_DEVICE_ERROR      - A device error occured attempting to initialize the driver.\r
+\r
+--*/\r
+{\r
+  EFI_STATUS  Status;\r
+  UINTN       Result;\r
+  EFI_HANDLE  Handle;\r
+\r
+  //\r
+  // Make sure the Timer Architectural Protocol is not already installed in the system\r
+  //\r
+  ASSERT_PROTOCOL_ALREADY_INSTALLED (NULL, &gEfiTimerArchProtocolGuid);\r
+\r
+  //\r
+  // Get the CPU Architectural Protocol instance\r
+  //\r
+  Status = gBS->LocateProtocol (&gEfiCpuArchProtocolGuid, NULL, &mCpu);\r
+  ASSERT_EFI_ERROR (Status);\r
+\r
+  //\r
+  //  Get our handle so the timer tick thread can suspend\r
+  //\r
+  Result = gWinNt->DuplicateHandle (\r
+                    gWinNt->GetCurrentProcess (),\r
+                    gWinNt->GetCurrentThread (),\r
+                    gWinNt->GetCurrentProcess (),\r
+                    &mNtMainThreadHandle,\r
+                    0,\r
+                    FALSE,\r
+                    DUPLICATE_SAME_ACCESS\r
+                    );\r
+  if (Result == 0) {\r
+    return EFI_DEVICE_ERROR;\r
+  }\r
+\r
+  //\r
+  // Initialize Critical Section used to update variables shared between the main\r
+  // thread and the timer interrupt thread.\r
+  //\r
+  gWinNt->InitializeCriticalSection (&mNtCriticalSection);\r
+\r
+  //\r
+  // Start the timer thread at the default timer period\r
+  //\r
+  Status = mTimer.SetTimerPeriod (&mTimer, DEFAULT_TIMER_TICK_DURATION);\r
+  if (EFI_ERROR (Status)) {\r
+    gWinNt->DeleteCriticalSection (&mNtCriticalSection);\r
+    return Status;\r
+  }\r
+\r
+  //\r
+  // Install the Timer Architectural Protocol onto a new handle\r
+  //\r
+  Handle = NULL;\r
+  Status = gBS->InstallProtocolInterface (\r
+                  &Handle,\r
+                  &gEfiTimerArchProtocolGuid,\r
+                  EFI_NATIVE_INTERFACE,\r
+                  &mTimer\r
+                  );\r
+  if (EFI_ERROR (Status)) {\r
+    //\r
+    // Cancel the timer\r
+    //\r
+    mTimer.SetTimerPeriod (&mTimer, 0);\r
+    gWinNt->DeleteCriticalSection (&mNtCriticalSection);\r
+    return Status;\r
+  }\r
+\r
+  return EFI_SUCCESS;\r
+}\r
diff --git a/Nt32Pkg/TimerDxe/Timer.dxs b/Nt32Pkg/TimerDxe/Timer.dxs
new file mode 100644 (file)
index 0000000..86624d3
--- /dev/null
@@ -0,0 +1,32 @@
+/*++\r
+\r
+Copyright (c) 2006, 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
+Module Name:\r
+\r
+  Timer.dxs\r
+\r
+Abstract:\r
+\r
+  Dependency expression source file.\r
+  \r
+--*/ \r
+\r
+\r
+//\r
+// Include common header file for this module.\r
+//\r
+#include "CommonHeader.h"\r
+\r
+#include <DxeDepex.h>\r
+\r
+DEPENDENCY_START\r
+  EFI_CPU_ARCH_PROTOCOL_GUID\r
+DEPENDENCY_END\r
diff --git a/Nt32Pkg/TimerDxe/Timer.h b/Nt32Pkg/TimerDxe/Timer.h
new file mode 100644 (file)
index 0000000..566ab95
--- /dev/null
@@ -0,0 +1,167 @@
+/*++\r
+\r
+Copyright (c) 2006, 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
+Module Name:\r
+\r
+  Timer.h\r
+\r
+Abstract:\r
+\r
+  NT Emulation Architectural Protocol Driver as defined in Tiano.\r
+  This Timer module uses an NT Thread to simulate the timer-tick driven\r
+  timer service.\r
+\r
+--*/\r
+\r
+#ifndef _TIMER_H_\r
+#define _TIMER_H_\r
+\r
+\r
+\r
+\r
+//\r
+// Include common header file for this module.\r
+//\r
+#include "CommonHeader.h"\r
+\r
+//\r
+// Legal timer value range in 100 ns units\r
+//\r
+#define TIMER_MINIMUM_VALUE 0\r
+#define TIMER_MAXIMUM_VALUE (0x100000000 - 1)\r
+\r
+//\r
+// Default timer value in 100 ns units (10 ms)\r
+//\r
+#define DEFAULT_TIMER_TICK_DURATION 100000\r
+\r
+//\r
+// Function Prototypes\r
+//\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverInitialize (\r
+  IN EFI_HANDLE        ImageHandle,\r
+  IN EFI_SYSTEM_TABLE  *SystemTable\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  TODO: Add function description\r
+\r
+Arguments:\r
+\r
+  ImageHandle - TODO: add argument description\r
+  SystemTable - TODO: add argument description\r
+\r
+Returns:\r
+\r
+  TODO: add return values\r
+\r
+--*/\r
+;\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverRegisterHandler (\r
+  IN EFI_TIMER_ARCH_PROTOCOL  *This,\r
+  IN EFI_TIMER_NOTIFY         NotifyFunction\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  TODO: Add function description\r
+\r
+Arguments:\r
+\r
+  This            - TODO: add argument description\r
+  NotifyFunction  - TODO: add argument description\r
+\r
+Returns:\r
+\r
+  TODO: add return values\r
+\r
+--*/\r
+;\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverSetTimerPeriod (\r
+  IN EFI_TIMER_ARCH_PROTOCOL  *This,\r
+  IN UINT64                   TimerPeriod\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  TODO: Add function description\r
+\r
+Arguments:\r
+\r
+  This        - TODO: add argument description\r
+  TimerPeriod - TODO: add argument description\r
+\r
+Returns:\r
+\r
+  TODO: add return values\r
+\r
+--*/\r
+;\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverGetTimerPeriod (\r
+  IN EFI_TIMER_ARCH_PROTOCOL   *This,\r
+  OUT UINT64                   *TimerPeriod\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  TODO: Add function description\r
+\r
+Arguments:\r
+\r
+  This        - TODO: add argument description\r
+  TimerPeriod - TODO: add argument description\r
+\r
+Returns:\r
+\r
+  TODO: add return values\r
+\r
+--*/\r
+;\r
+\r
+EFI_STATUS\r
+EFIAPI\r
+WinNtTimerDriverGenerateSoftInterrupt (\r
+  IN EFI_TIMER_ARCH_PROTOCOL  *This\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  TODO: Add function description\r
+\r
+Arguments:\r
+\r
+  This  - TODO: add argument description\r
+\r
+Returns:\r
+\r
+  TODO: add return values\r
+\r
+--*/\r
+;\r
+\r
+#endif\r
diff --git a/Nt32Pkg/TimerDxe/Timer.inf b/Nt32Pkg/TimerDxe/Timer.inf
new file mode 100644 (file)
index 0000000..a5bb8fe
--- /dev/null
@@ -0,0 +1,100 @@
+#/** @file\r
+# NT Emulation Timer Architectural Protocol Driver as defined in DXE CIS\r
+#\r
+# This Timer module uses an NT Thread to simulate the timer-tick driven\r
+#  timer service. In the future, the Thread creation should possibly be\r
+#  abstracted by the CPU architectural protocol\r
+# Copyright (c) 2006 - 2007, Intel Corporation\r
+#\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
+#  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
+\r
+################################################################################\r
+#\r
+# Defines Section - statements that will be processed to create a Makefile.\r
+#\r
+################################################################################\r
+[Defines]\r
+  INF_VERSION                    = 0x00010005\r
+  BASE_NAME                      = Timer\r
+  FILE_GUID                      = C3811036-710B-4E39-8CF1-0AF9BE3A8198\r
+  MODULE_TYPE                    = DXE_DRIVER\r
+  VERSION_STRING                 = 1.0\r
+  EDK_RELEASE_VERSION            = 0x00020000\r
+  EFI_SPECIFICATION_VERSION      = 0x00020000\r
+\r
+  ENTRY_POINT                    = WinNtTimerDriverInitialize\r
+\r
+#\r
+# The following information is for reference only and not required by the build tools.\r
+#\r
+#  VALID_ARCHITECTURES           = IA32\r
+#\r
+\r
+################################################################################\r
+#\r
+# Sources Section - list of files that are required for the build to succeed.\r
+#\r
+################################################################################\r
+\r
+[Sources.common]\r
+  Timer.dxs\r
+  Timer.c\r
+  Timer.h\r
+  CommonHeader.h\r
+\r
+\r
+################################################################################\r
+#\r
+# Includes Section - list of Include locations that are required for\r
+#                    this module.\r
+#\r
+################################################################################\r
+\r
+[Includes]\r
+  $(WORKSPACE)/MdePkg/Include/Library\r
+  $(WORKSPACE)/EdkNt32Pkg/Include/Library\r
+\r
+################################################################################\r
+#\r
+# Package Dependency Section - list of Package files that are required for\r
+#                              this module.\r
+#\r
+################################################################################\r
+\r
+[Packages]\r
+  MdePkg/MdePkg.dec\r
+  Nt32Pkg/Nt32Pkg.dec\r
+\r
+\r
+################################################################################\r
+#\r
+# Library Class Section - list of Library Classes that are required for\r
+#                         this module.\r
+#\r
+################################################################################\r
+\r
+[LibraryClasses]\r
+  UefiBootServicesTableLib\r
+  WinNtLib\r
+  UefiDriverEntryPoint\r
+  DebugLib\r
+\r
+\r
+################################################################################\r
+#\r
+# Protocol C Name Section - list of Protocol and Protocol Notify C Names\r
+#                           that this module uses or produces.\r
+#\r
+################################################################################\r
+\r
+[Protocols]\r
+  gEfiCpuArchProtocolGuid                       # PROTOCOL ALWAYS_CONSUMED\r
+  gEfiTimerArchProtocolGuid                     # PROTOCOL ALWAYS_PRODUCED\r
diff --git a/Nt32Pkg/TimerDxe/Timer.msa b/Nt32Pkg/TimerDxe/Timer.msa
new file mode 100644 (file)
index 0000000..b022741
--- /dev/null
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8"?>\r
+<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\r
+  <MsaHeader>\r
+    <ModuleName>Timer</ModuleName>\r
+    <ModuleType>DXE_DRIVER</ModuleType>\r
+    <GuidValue>C3811036-710B-4E39-8CF1-0AF9BE3A8198</GuidValue>\r
+    <Version>1.0</Version>\r
+    <Abstract>NT Emulation Timer Architectural Protocol Driver as defined in DXE CIS</Abstract>\r
+    <Description>This Timer module uses an NT Thread to simulate the timer-tick driven\r
+      timer service.  In the future, the Thread creation should possibly be\r
+      abstracted by the CPU architectural protocol</Description>\r
+    <Copyright>Copyright (c) 2006 - 2007, Intel Corporation</Copyright>\r
+    <License>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
+      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.</License>\r
+    <Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION   0x00000052</Specification>\r
+  </MsaHeader>\r
+  <ModuleDefinitions>\r
+    <SupportedArchitectures>IA32</SupportedArchitectures>\r
+    <BinaryModule>false</BinaryModule>\r
+    <OutputFileBasename>Timer</OutputFileBasename>\r
+  </ModuleDefinitions>\r
+  <LibraryClassDefinitions>\r
+    <LibraryClass Usage="ALWAYS_CONSUMED">\r
+      <Keyword>DebugLib</Keyword>\r
+    </LibraryClass>\r
+    <LibraryClass Usage="ALWAYS_CONSUMED">\r
+      <Keyword>UefiDriverEntryPoint</Keyword>\r
+    </LibraryClass>\r
+    <LibraryClass Usage="ALWAYS_CONSUMED">\r
+      <Keyword>WinNtLib</Keyword>\r
+    </LibraryClass>\r
+    <LibraryClass Usage="ALWAYS_CONSUMED">\r
+      <Keyword>UefiBootServicesTableLib</Keyword>\r
+    </LibraryClass>\r
+  </LibraryClassDefinitions>\r
+  <SourceFiles>\r
+    <Filename>Timer.h</Filename>\r
+    <Filename>Timer.c</Filename>\r
+    <Filename>Timer.dxs</Filename>\r
+  </SourceFiles>\r
+  <PackageDependencies>\r
+    <Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>\r
+    <Package PackageGuid="0fb2aa2d-10d5-40a5-a9dc-060c12a4a3f3"/>\r
+  </PackageDependencies>\r
+  <Protocols>\r
+    <Protocol Usage="ALWAYS_PRODUCED">\r
+      <ProtocolCName>gEfiTimerArchProtocolGuid</ProtocolCName>\r
+    </Protocol>\r
+    <Protocol Usage="ALWAYS_CONSUMED">\r
+      <ProtocolCName>gEfiCpuArchProtocolGuid</ProtocolCName>\r
+    </Protocol>\r
+  </Protocols>\r
+  <Externs>\r
+    <Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>\r
+    <Specification>EDK_RELEASE_VERSION 0x00020000</Specification>\r
+    <Extern>\r
+      <ModuleEntryPoint>WinNtTimerDriverInitialize</ModuleEntryPoint>\r
+    </Extern>\r
+  </Externs>\r
+</ModuleSurfaceArea>
\ No newline at end of file