clock.c

#include <stdio.h>
#include <lib/assert.h>
#include <sys/clock.h>
#include <sys/cc.h>
#include <sys/etimer.h>
#include <debug-uart.h>
#include <core/atomic.h>
#include <core/irq-prio.h>
#include <core/uwork.h>
#include <core/mwork.h>
#include <core/pm.h>
#include <app_util_platform.h>
#include <nrf_nvic.h>

#define CLOCK_SYNC_GUARD        (4)
#define CLOCK_GUARD_WIDTH       (2)
#define CLOCK_COUNTER_WIDTH     (24)
#define CLOCK_COUNTER_MSB       (1 << (CLOCK_COUNTER_WIDTH - 1))
#define CLOCK_SECOND_WIDTH      (12)
#define CLOCK_LFCLK_DIV         (8 - 1) /* 4096 Hz */
#define CLOCK_HZ                (1 << (CLOCK_SECOND_WIDTH - CLOCK_GUARD_WIDTH))

struct clock_state_t
{
  uint32_t seconds_const;
  uint32_t seconds_volatile;
  uint32_t etimer_wrap_rem;
  uint16_t etimer_wrap_cnt;
  uint8_t  clock_wait;
};

void
RTC1_IRQHandler(void) __attribute__ ((interrupt));

static void
clock_delay_usec_done(struct uwork_t *work);

DECLARE_PM_LOCK(PM_LEVEL_LOWPWR, clock_pm_lock, NULL, 0);

static DECLARE_UWORK(udelay_work, clock_delay_usec_done);

static volatile struct clock_state_t clock_state;

uint32_t rtc1_pending_interrupt;

static inline uint32_t current_clock()
{
  return (clock_state.seconds_const << (CLOCK_SECOND_WIDTH - CLOCK_GUARD_WIDTH))
       + (nrf_rtc_counter_get(NRF_RTC1) >> CLOCK_GUARD_WIDTH);
}

static inline uint32_t current_seconds()
{
  return clock_state.seconds_volatile
       + (nrf_rtc_counter_get(NRF_RTC1) >> (CLOCK_COUNTER_WIDTH - CLOCK_SECOND_WIDTH));
}

void clock_cc_set(NRF_RTC_Type *rtc, uint32_t ch, uint32_t cc_val)
{
  uint32_t now;
  nrf_rtc_cc_set(rtc, ch, cc_val);

  now = nrf_rtc_counter_get(rtc);
  if ((cc_val - now - CLOCK_SYNC_GUARD) & CLOCK_COUNTER_MSB) {
    /* Work is in the past. Trigger the event */
    atomic_or32(&rtc1_pending_interrupt, NRF_RTC_INT_COMPARE0_MASK << ch);
    NVIC->STIR = RTC1_IRQn;
  }
}

static void update_wakeup(uint32_t dist)
{
  CRITICAL_REGION_ENTER();
  uint32_t now = nrf_rtc_counter_get(NRF_RTC1);
  uint32_t wrap = dist >> (CLOCK_COUNTER_WIDTH - CLOCK_GUARD_WIDTH);
  uint32_t negative = dist >> (CLOCK_COUNTER_WIDTH - CLOCK_GUARD_WIDTH - 1);
  if (!wrap && negative)
  {
    dist = (1 << (CLOCK_COUNTER_WIDTH - CLOCK_GUARD_WIDTH - 1)) - 1;
  }
  uint32_t wup = now + (dist << CLOCK_GUARD_WIDTH);

  if (wrap)
  {
    clock_state.etimer_wrap_cnt = wrap;
    clock_state.etimer_wrap_rem = wup;
    nrf_rtc_int_disable(NRF_RTC1, NRF_RTC_INT_COMPARE0_MASK);
  }
  else
  {
    clock_cc_set(NRF_RTC1, 0, wup);
    nrf_rtc_int_enable(NRF_RTC1, NRF_RTC_INT_COMPARE0_MASK);
  }
  CRITICAL_REGION_EXIT();
}

void
RTC1_IRQHandler(void)
{
  uint32_t interrupt = atomic_xchg32(&rtc1_pending_interrupt, 0);
  uint32_t comp;

  if (nrf_rtc_event_pending(NRF_RTC1, NRF_RTC_EVENT_COMPARE_1)
      || (interrupt & NRF_RTC_INT_COMPARE1_MASK))
  {
    nrf_rtc_event_clear(NRF_RTC1, NRF_RTC_EVENT_COMPARE_1);
    mwork_timer();
  }

  if (nrf_rtc_event_pending(NRF_RTC1, NRF_RTC_EVENT_OVERFLOW))
  {
    nrf_rtc_event_clear(NRF_RTC1, NRF_RTC_EVENT_OVERFLOW);

    /* Update long-term clock */
    clock_state.seconds_const    += (1 << (CLOCK_COUNTER_WIDTH - CLOCK_SECOND_WIDTH));
    clock_state.seconds_volatile += (1 << (CLOCK_COUNTER_WIDTH - CLOCK_SECOND_WIDTH));

    /* Update long-term etimers */
    if (clock_state.etimer_wrap_cnt != 0)
    {
      clock_state.etimer_wrap_cnt--;
      if (!clock_state.etimer_wrap_cnt)
      {
        comp = clock_state.etimer_wrap_rem;

        if (comp < CLOCK_SYNC_GUARD)
          comp = CLOCK_SYNC_GUARD;

        clock_cc_set(NRF_RTC1, 0, comp);
        nrf_rtc_int_enable(NRF_RTC1, NRF_RTC_INT_COMPARE0_MASK);

        clock_state.etimer_wrap_rem = 0;
      }
    }
  }

  if (nrf_rtc_event_pending(NRF_RTC1, NRF_RTC_EVENT_COMPARE_0)
      || (interrupt & NRF_RTC_INT_COMPARE0_MASK))
  {
    nrf_rtc_event_clear(NRF_RTC1, NRF_RTC_EVENT_COMPARE_0);

    if (clock_state.clock_wait)
    {
      pm_wakeup();
    }
    if (etimer_pending())
    {
      uint32_t clock = current_clock();
      int32_t dist = etimer_next_expiration_time() - clock;

      if (dist <= 0)
      {
        nrf_rtc_int_disable(NRF_RTC1, NRF_RTC_INT_COMPARE0_MASK);
        etimer_request_poll();
        pm_wakeup();
      }
      else
      {
        update_wakeup(dist);
      }
    }
    else
    {
      nrf_rtc_int_disable(NRF_RTC1, NRF_RTC_INT_COMPARE0_MASK);
    }
  }
}

void
clock_init()
{
  nrf_rtc_task_trigger(NRF_RTC1, NRF_RTC_TASK_STOP);
  do
  {
    nrf_rtc_prescaler_set(NRF_RTC1, CLOCK_LFCLK_DIV + 1);
  } while (rtc_prescaler_get(NRF_RTC1) != CLOCK_LFCLK_DIV + 1);
  do
  {
    nrf_rtc_prescaler_set(NRF_RTC1, CLOCK_LFCLK_DIV);
  } while (rtc_prescaler_get(NRF_RTC1) != CLOCK_LFCLK_DIV);
  nrf_rtc_task_trigger(NRF_RTC1, NRF_RTC_TASK_CLEAR);
  nrf_rtc_task_trigger(NRF_RTC1, NRF_RTC_TASK_START);
  nrf_rtc_int_enable(NRF_RTC1, NRF_RTC_INT_OVERFLOW_MASK);

//  nrf_rtc_event_enable(NRF_RTC1, RTC_EVTENSET_COMPARE0_Msk
//      | RTC_EVTENSET_COMPARE1_Msk
//      | RTC_EVTENSET_OVRFLW_Msk);

  sd_nvic_ClearPendingIRQ(RTC1_IRQn);
  sd_nvic_SetPriority(RTC1_IRQn, EVE_IRQ_PRIORITY_LOW);
  sd_nvic_EnableIRQ(RTC1_IRQn);
}

clock_time_t
clock_time(void)
{
  return current_clock();
}

unsigned long
clock_seconds(void)
{
  return current_seconds();
}

void
clock_set_seconds(unsigned long sec)
{
  clock_state.seconds_volatile = sec
       - (nrf_rtc_counter_get(NRF_RTC1) >> (CLOCK_COUNTER_WIDTH - CLOCK_SECOND_WIDTH));
}

void
clock_wait(clock_time_t t)
{
  clock_time_t stop;
  int32_t dist;

  stop = clock_time() + t;
  /* This loop blocks all the running timers until timeout is expired.
   * It's fine, anyway the timers have no chance to be executed before
   * the function is finished */
  PM_LOCK(clock_pm_lock);
  clock_state.clock_wait = 1;
  while (1)
  {
    dist = stop - clock_time();
    if (dist <= 0)
      break;
    update_wakeup(dist);
    pm_relax();
  }
  clock_state.clock_wait = 0;
  PM_UNLOCK(clock_pm_lock);
}

static void
clock_delay_usec_done(struct uwork_t *work)
{
  pm_wakeup();
}

void
clock_delay_usec(uint16_t dt)
{
  udelay_work.at = uwork_now();
  udelay_work.at += UWORK_USEC(dt);
  uwork_schedule(&udelay_work);
  while (uwork_pending(&udelay_work))
    pm_relax();
}

void
arch_update_time(void)
{
  uint32_t clock = current_clock();
  uint32_t next_expiration_time = etimer_next_expiration_time();
  int32_t dist = next_expiration_time - clock;

  if (next_expiration_time == 0)
  {
    if (clock_pm_lock.locked)
      PM_UNLOCK(clock_pm_lock);
  }
  else
  {
    if (dist <= 0)
      dist = 1;
    update_wakeup(dist);
    if (!clock_pm_lock.locked)
      PM_LOCK(clock_pm_lock);
  }
}