UserEvent.c

Go to the documentation of this file.

 
#include <UserEvent.h>
 
#include <stdlib.h>
#include <stdio.h>
 
#ifdef __MACH__
  #include <mach/clock.h>
  #include <mach/mach.h>
#else
  #include <time.h>
#endif
 
typedef struct {
  BOOLEAN             IsClosed;
  BOOLEAN             Signaled;
  UINT32              Type;
  EFI_TPL             TplLevel;
  EFI_EVENT_NOTIFY    NotifyFn;
  VOID                *NotifyCtx;
  UINT64              TimerEmit;
  UINT64              TimerDelta;
} USER_EVENT;
 
STATIC BOOLEAN     mEventNeedInit = TRUE;
STATIC EFI_TPL     mCurTPL        = 0;
STATIC USER_EVENT  mEvents[USER_EVENT_MAXNUM];
 
STATIC
UINT64
UserEventGetTimeNow (
  VOID
  )
{
  UINT64  TimeNow;
 
  TimeNow = 0;
 
 #if defined (_WIN32)
 
  time_t  TimeRes = time (NULL);
 
  if (TimeRes < 0) {
    return TimeNow;
  }
 
  TimeNow = (UINT64)TimeRes;
  TimeNow = TimeNow*1000000000;
 
 #elif defined (__MACH__)
  clock_serv_t     Cclock;
  mach_timespec_t  Now;
 
  host_get_clock_service (mach_host_self (), SYSTEM_CLOCK, &Cclock);
  clock_get_time (Cclock, &Now);
  mach_port_deallocate (mach_task_self (), Cclock);
 
  TimeNow = (UINT64)Now.tv_sec*1000000000 + Now.tv_nsec;
 
 #else
  struct timespec  Now;
 
  clock_gettime (CLOCK_MONOTONIC, &Now);
  TimeNow = (UINT64)Now.tv_sec*1000000000 + Now.tv_nsec;
 
 #endif
 
  return TimeNow;
}
 
STATIC
USER_EVENT *
UserEventAlloc (
  VOID
  )
{
  INTN  Index;
 
  for (Index = 0; Index < USER_EVENT_MAXNUM; Index++) {
    if (mEvents[Index].IsClosed == TRUE) {
      mEvents[Index].IsClosed = 0;
      return (&(mEvents[Index]));
    }
  }
 
  return NULL;
}
 
STATIC
VOID
UserEventDispatch (
  VOID
  )
{
  UINT64  TimeNow;
  INTN    Index;
 
  TimeNow = UserEventGetTimeNow ();
 
  for (Index = 0; Index < USER_EVENT_MAXNUM; Index++) {
    if (mEvents[Index].IsClosed == TRUE) {
      //
      // Skip unused descriptors
      //
      continue;
    }
 
    //
    // Is it an active timer?
    //
    if (((mEvents[Index].Type & EVT_TIMER) != 0) && (mEvents[Index].TimerEmit != 0)) {
      if (TimeNow >= mEvents[Index].TimerEmit) {
        //
        // Signal Event
        //
        mEvents[Index].Signaled = TRUE;
 
        //
        // Is it a periodic timer?
        //
        if (mEvents[Index].TimerDelta != 0) {
          //
          // Update trigger time
          //
          mEvents[Index].TimerEmit += mEvents[Index].TimerDelta;
        } else {
          mEvents[Index].TimerEmit = 0;
        }
      }
    }
 
    //
    //  Is it a signaled event?
    //
    if ((mEvents[Index].Signaled == TRUE) && ((mEvents[Index].Type & EVT_NOTIFY_SIGNAL) != 0)) {
      //
      // Is TPL of Event valid?
      //
      if (mCurTPL <= mEvents[Index].TplLevel) {
        //
        // Reset state
        //
        mEvents[Index].Signaled = FALSE;
        //
        // Call handler
        //
        mEvents[Index].NotifyFn ((EFI_EVENT)&mEvents[Index], mEvents[Index].NotifyCtx);
      }
    }
  }
}
 
STATIC
VOID
UserEventInitializer (
  VOID
  )
{
  INTN  Index;
 
  for (Index = 0; Index < USER_EVENT_MAXNUM; Index++) {
    mEvents[Index].IsClosed  = TRUE;
    mEvents[Index].TplLevel  = 0;
    mEvents[Index].TimerEmit = 0;
  }
 
  //
  // Init current TPL
  //
  mCurTPL = TPL_APPLICATION;
}
 
STATIC
VOID
UserEventInit (
  VOID
  )
{
  if (mEventNeedInit == TRUE) {
    mEventNeedInit = FALSE;
    UserEventInitializer ();
  }
}
 
EFI_STATUS
EFIAPI
UserCreateEventEx (
  IN UINT32            Type,
  IN EFI_TPL           NotifyTpl,
  IN EFI_EVENT_NOTIFY  NotifyFunction OPTIONAL,
  IN CONST VOID        *NotifyContext OPTIONAL,
  IN CONST EFI_GUID    *EventGroup OPTIONAL,
  OUT EFI_EVENT        *Event
  )
{
  USER_EVENT  *Ev;
 
  UserEventInit ();
 
  //
  // Check input params
  //
  if (Event == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (((Type & EVT_NOTIFY_SIGNAL) != 0) && ((Type & EVT_NOTIFY_WAIT) != 0)) {
    //
    // The Type param can't combine EVT_NOTIFY_SIGNAL and EVT_NOTIFY_WAIT flags
    //
    return EFI_INVALID_PARAMETER;
  }
 
  if ((Type & (EVT_NOTIFY_SIGNAL | EVT_NOTIFY_WAIT)) != 0) {
    //
    // Event type is signal or event
    //
    if (NotifyFunction == NULL) {
      //
      // callback function isn't set
      //
      return EFI_INVALID_PARAMETER;
    }
 
    if (NotifyTpl >= USER_EVENT_MAXTPL) {
      //
      // Required TPL is invalid
      //
      return EFI_INVALID_PARAMETER;
    }
  }
 
  //
  // Try to allocate an Event descriptor
  //
  Ev = UserEventAlloc ();
  if (Ev == NULL) {
    *Event = NULL;
    return EFI_OUT_OF_RESOURCES;
  }
 
  Ev->Type      = Type;
  Ev->TplLevel  = NotifyTpl;
  Ev->Signaled  = 0;
  Ev->NotifyFn  = NotifyFunction;
  Ev->NotifyCtx = (VOID *)NotifyContext;
  Ev->TimerEmit = 0;
 
  *Event = (EFI_EVENT)Ev;
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
UserCreateEvent (
  IN UINT32            Type,
  IN EFI_TPL           NotifyTpl,
  IN EFI_EVENT_NOTIFY  NotifyFunction OPTIONAL,
  IN VOID              *NotifyContext OPTIONAL,
  OUT EFI_EVENT        *Event
  )
{
  return UserCreateEventEx (
           Type,
           NotifyTpl,
           NotifyFunction,
           NotifyContext,
           NULL,
           Event
           );
}
 
EFI_STATUS
EFIAPI
UserCloseEvent (
  IN EFI_EVENT  Event
  )
{
  USER_EVENT  *Ev;
 
  UserEventInit ();
 
  ASSERT (Event != NULL);
 
  Ev = (USER_EVENT *)Event;
 
  Ev->IsClosed  = TRUE;
  Ev->TimerEmit = 0;
  Ev->TplLevel  = 0;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
UserSignalEvent (
  IN EFI_EVENT  Event
  )
{
  USER_EVENT  *Ev;
 
  UserEventInit ();
 
  ASSERT (Event != NULL);
 
  Ev = (USER_EVENT *)Event;
  ASSERT (Ev->IsClosed == FALSE);
 
  if (Ev->IsClosed == FALSE) {
    Ev->Signaled = TRUE;
  }
 
  UserEventDispatch ();
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
UserCheckEvent (
  IN EFI_EVENT  Event
  )
{
  USER_EVENT  *Ev;
  EFI_STATUS  Status;
 
  UserEventInit ();
 
  ASSERT (Event != NULL);
 
  Ev = (USER_EVENT *)Event;
  ASSERT (Ev->IsClosed == FALSE);
 
  if ((Ev->Type & EVT_NOTIFY_SIGNAL) != 0) {
    //
    // The Event can't have the EVT_NOTIFY_SIGNAL type
    //
    return EFI_INVALID_PARAMETER;
  }
 
  UserEventDispatch ();
 
  if (Ev->Signaled == TRUE) {
    Ev->Signaled = FALSE;
    Status       = EFI_SUCCESS;
  } else {
    //
    // It isn't signaled event, but it can have the EVT_NOTIFY_WAIT type
    // In that case, we need to emit callback function if TPL is valid
    //
    if (((Ev->Type & EVT_NOTIFY_WAIT) != 0) && (mCurTPL <= Ev->TplLevel)) {
      Ev->NotifyFn ((EFI_EVENT)Ev, Ev->NotifyCtx);
    }
 
    Status = EFI_NOT_READY;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
UserWaitForEvent (
  IN UINTN      NumberOfEvents,
  IN EFI_EVENT  *Events,
  OUT UINTN     *Index
  )
{
  USER_EVENT  **Evs;
  USER_EVENT  *Ev;
  UINTN       Jndex;
 
  UserEventInit ();
 
  if (mCurTPL != TPL_APPLICATION) {
    return EFI_UNSUPPORTED;
  }
 
  ASSERT (Events != NULL);
  ASSERT (Index != NULL);
 
  Evs = (USER_EVENT **)Events;
 
  if (NumberOfEvents == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  while (TRUE) {
    //
    // Blocking wait
    //
 
    UserEventDispatch ();
 
    for (Jndex = 0; Jndex < NumberOfEvents; Jndex++) {
      Ev = Evs[Jndex];
 
      if (Ev == NULL) {
        continue;
      }
 
      if (Ev->IsClosed == TRUE) {
        continue;
      }
 
      if ((Ev->Type & EVT_NOTIFY_SIGNAL) != 0) {
        *Index = Jndex;
        return EFI_INVALID_PARAMETER;
      }
 
      if (Ev->Signaled == TRUE) {
        *Index       = Jndex;
        Ev->Signaled = FALSE;
        return EFI_SUCCESS;
      } else {
        if (((Ev->Type & EVT_NOTIFY_WAIT) != 0) && (mCurTPL <= Ev->TplLevel)) {
          Ev->NotifyFn ((EFI_EVENT)Ev, Ev->NotifyCtx);
        }
      }
    }
  }
}
 
EFI_STATUS
EFIAPI
UserSetTimer (
  IN EFI_EVENT        Event,
  IN EFI_TIMER_DELAY  Type,
  IN UINT64           TriggerTime
  )
{
  UINT64      TimeNow;
  USER_EVENT  *Ev;
 
  UserEventInit ();
 
  // check input params
  ASSERT (Event != NULL);
  Ev = (USER_EVENT *)Event;
  ASSERT (Ev->IsClosed == FALSE);
 
  if ((Ev->Type & EVT_TIMER) == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  TimeNow = UserEventGetTimeNow ();
 
  switch (Type) {
    case TimerCancel:
      Ev->TimerEmit = 0;
      break;
 
    case TimerRelative:
      Ev->TimerEmit  = TimeNow + TriggerTime * 100;
      Ev->TimerDelta = 0;
      break;
 
    case TimerPeriodic:
      Ev->TimerEmit  = TimeNow + TriggerTime * 100;
      Ev->TimerDelta = TriggerTime * 100;
      break;
 
    default:
      return EFI_INVALID_PARAMETER;
  }
 
  UserEventDispatch ();
  return EFI_SUCCESS;
}
 
EFI_TPL
EFIAPI
UserRaiseTPL (
  IN EFI_TPL  NewTpl
  )
{
  EFI_TPL  Old;
 
  UserEventInit ();
 
  UserEventDispatch ();
 
  Old = mCurTPL;
  if ((NewTpl >= Old) && (NewTpl < USER_EVENT_MAXTPL)) {
    mCurTPL = NewTpl;
  }
 
  return Old;
}
 
VOID
EFIAPI
UserRestoreTPL (
  IN EFI_TPL  OldTpl
  )
{
  UserEventInit ();
  ASSERT (OldTpl <= mCurTPL);
 
  if (OldTpl < USER_EVENT_MAXTPL) {
    mCurTPL = OldTpl;
  }
 
  UserEventDispatch ();
}
 
BOOLEAN
UserEventDispatchNow (
  VOID
  )
{
  UINT64   TimeNow;
  BOOLEAN  Res;
  INTN     Index;
 
  UserEventInit ();
 
  TimeNow = UserEventGetTimeNow ();
 
  Res = FALSE;
  for (Index = 0; Index < USER_EVENT_MAXNUM; Index++) {
    if (mEvents[Index].IsClosed == TRUE) {
      continue;
    }
 
    Res = TRUE;
    if (((mEvents[Index].Type & EVT_TIMER) != 0) && (mEvents[Index].TimerEmit != 0)) {
      if (TimeNow >= mEvents[Index].TimerEmit) {
        mEvents[Index].Signaled = TRUE;
        if (mEvents[Index].TimerDelta != 0) {
          mEvents[Index].TimerEmit += mEvents[Index].TimerDelta;
        } else {
          mEvents[Index].TimerEmit = 0;
        }
      }
    }
 
    if ((mEvents[Index].Signaled == TRUE) && ((mEvents[Index].Type & EVT_NOTIFY_SIGNAL) != 0)) {
      if (mCurTPL <= mEvents[Index].TplLevel) {
        mEvents[Index].Signaled = FALSE;
        mEvents[Index].NotifyFn ((EFI_EVENT)&mEvents[Index], mEvents[Index].NotifyCtx);
      }
    }
  }
 
  return Res;
}