nuttx/sched/clock/clock_initialize.c

/****************************************************************************
 * sched/clock/clock_initialize.c
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.  The
 * ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>
#include <nuttx/compiler.h>

#include <stdint.h>
#include <time.h>
#include <errno.h>
#include <debug.h>

#ifdef CONFIG_RTC
#  include <nuttx/irq.h>
#endif

#include <nuttx/arch.h>
#include <nuttx/clock.h>

#include "clock/clock.h"
#ifdef CONFIG_CLOCK_TIMEKEEPING
#  include "clock/clock_timekeeping.h"
#endif

/****************************************************************************
 * Public Data
 ****************************************************************************/

#ifndef CONFIG_SCHED_TICKLESS
#ifdef CONFIG_SYSTEM_TIME64
volatile uint64_t g_system_ticks = INITIAL_SYSTEM_TIMER_TICKS;
#else
volatile uint32_t g_system_ticks = INITIAL_SYSTEM_TIMER_TICKS;
#endif
#endif

#ifndef CONFIG_CLOCK_TIMEKEEPING
struct timespec   g_basetime;
#endif

#ifdef CONFIG_CLOCK_ADJTIME
long long g_clk_adj_usec;
long long g_clk_adj_count;
#endif

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: clock_basetime
 *
 * Description:
 *   Get the initial time value from the best source available.
 *
 ****************************************************************************/

#ifdef CONFIG_RTC
#if defined(CONFIG_RTC_DATETIME)
/* Initialize the system time using a broken out date/time structure */

int clock_basetime(FAR struct timespec *tp)
{
  struct tm rtctime;
  long nsecs = 0;
  int ret;

  /* Get the broken-out time from the date/time RTC. */

#ifdef CONFIG_ARCH_HAVE_RTC_SUBSECONDS
  ret = up_rtc_getdatetime_with_subseconds(&rtctime, &nsecs);
#else
  ret = up_rtc_getdatetime(&rtctime);
#endif
  if (ret >= 0)
    {
      /* And use the broken-out time to initialize the system time */

      tp->tv_sec  = timegm(&rtctime);
      tp->tv_nsec = nsecs;
    }

  return ret;
}

#elif defined(CONFIG_RTC_HIRES)

/* Initialize the system time using a high-resolution structure */

int clock_basetime(FAR struct timespec *tp)
{
  /* Get the complete time from the hi-res RTC. */

  return up_rtc_gettime(tp);
}

#else

/* Initialize the system time using seconds only */

int clock_basetime(FAR struct timespec *tp)
{
  /* Get the seconds (only) from the lo-resolution RTC */

  tp->tv_sec  = up_rtc_time();
  tp->tv_nsec = 0;
  return OK;
}

#endif /* CONFIG_RTC_HIRES */
#else /* CONFIG_RTC */

int clock_basetime(FAR struct timespec *tp)
{
  time_t jdn = 0;

  /* Get the EPOCH-relative julian date from the calendar year,
   * month, and date
   */

  jdn = clock_calendar2utc(CONFIG_START_YEAR, CONFIG_START_MONTH - 1,
                           CONFIG_START_DAY);

  /* Set the base time as seconds into this julian day. */

  tp->tv_sec  = jdn * SEC_PER_DAY;
  tp->tv_nsec = 0;
  return OK;
}

#endif /* CONFIG_RTC */

/****************************************************************************
 * Name: clock_inittime
 *
 * Description:
 *   Get the initial time value from the best source available.
 *
 ****************************************************************************/

#ifdef CONFIG_RTC
static void clock_inittime(FAR const struct timespec *tp)
{
  /* (Re-)initialize the time value to match the RTC */

#ifndef CONFIG_CLOCK_TIMEKEEPING
  struct timespec ts;

  if (tp)
    {
      memcpy(&g_basetime, tp, sizeof(struct timespec));
    }
  else
    {
      clock_basetime(&g_basetime);
    }

  clock_systime_timespec(&ts);

  /* Adjust base time to hide initial timer ticks. */

  g_basetime.tv_sec  -= ts.tv_sec;
  g_basetime.tv_nsec -= ts.tv_nsec;
  while (g_basetime.tv_nsec < 0)
    {
      g_basetime.tv_nsec += NSEC_PER_SEC;
      g_basetime.tv_sec--;
    }
#else
  clock_inittimekeeping(tp);
#endif
}
#endif

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: clock_initialize
 *
 * Description:
 *   Perform one-time initialization of the timing facilities.
 *
 ****************************************************************************/

void clock_initialize(void)
{
#if !defined(CONFIG_SUPPRESS_INTERRUPTS) && \
    !defined(CONFIG_SUPPRESS_TIMER_INTS) && \
    !defined(CONFIG_SYSTEMTICK_EXTCLK)
  /* Initialize the system timer interrupt */

  up_timer_initialize();
#endif

#if defined(CONFIG_RTC)
  /* Initialize the internal RTC hardware.  Initialization of external RTC
   * must be deferred until the system has booted.
   */

  up_rtc_initialize();

#if !defined(CONFIG_RTC_EXTERNAL)
  /* Initialize the time value to match the RTC */

  clock_inittime(NULL);
#endif

#if defined(CONFIG_CLOCK_ADJTIME)
  g_clk_adj_count = 0;
  g_clk_adj_usec = 0;
#endif

#endif
}

/****************************************************************************
 * Name: clock_synchronize
 *
 * Description:
 *   Synchronize the system timer to a hardware RTC.  This operation is
 *   normally performed automatically by the system during clock
 *   initialization.  However, the user may also need to explicitly re-
 *   synchronize the system timer to the RTC under certain conditions where
 *   the system timer is known to be in error.  For example, in certain low-
 *   power states, the system timer may be stopped but the RTC will continue
 *   keep correct time.  After recovering from such low-power state, this
 *   function should be called to restore the correct system time.
 *
 *   Calling this function could result in system time going "backward" in
 *   time, especially with certain lower resolution RTC implementations.
 *   Time going backward could have bad consequences if there are ongoing
 *   timers and delays.  So use this interface with care.
 *
 * Input Parameters:
 *   tp: rtc time should be synced, set NULL to re-get time
 *
 * Returned Value:
 *   None
 *
 * Assumptions:
 *
 ****************************************************************************/

#ifdef CONFIG_RTC
void clock_synchronize(FAR const struct timespec *tp)
{
  irqstate_t flags;

  /* Re-initialize the time value to match the RTC */

  flags = enter_critical_section();
  clock_inittime(tp);
  leave_critical_section(flags);
}
#endif

/****************************************************************************
 * Name: clock_resynchronize
 *
 * Description:
 *   Resynchronize the system timer to a hardware RTC.  The user can
 *   explicitly re-synchronize the system timer to the RTC under certain
 *   conditions where the system timer is known to be in error.  For example,
 *   in certain low-power states, the system timer may be stopped but the
 *   RTC will continue keep correct time.  After recovering from such
 *   low-power state, this function should be called to restore the correct
 *   system time. Function also keeps monotonic clock at rate of RTC.
 *
 *   Calling this function will not result in system time going "backward" in
 *   time. If setting system time with RTC would result time going "backward"
 *   then resynchronization is not performed.
 *
 * Input Parameters:
 *   rtc_diff:  amount of time system-time is adjusted forward with RTC
 *
 * Returned Value:
 *   None
 *
 * Assumptions:
 *
 ****************************************************************************/

#if defined(CONFIG_RTC) && !defined(CONFIG_SCHED_TICKLESS) && !defined(CONFIG_CLOCK_TIMEKEEPING)
void clock_resynchronize(FAR struct timespec *rtc_diff)
{
  struct timespec rtc_time;
  struct timespec bias;
  struct timespec curr_ts;
  struct timespec rtc_diff_tmp;
  irqstate_t flags;
  int32_t carry;
  int ret;

  if (rtc_diff == NULL)
    {
      rtc_diff = &rtc_diff_tmp;
    }

  /* Set the time value to match the RTC */

  flags = enter_critical_section();

  /* Get RTC time */

  ret = clock_basetime(&rtc_time);
  if (ret < 0)
    {
      /* Error reading RTC, skip resynchronization. */

      sinfo("rtc error %d, skip resync\n", ret);

      rtc_diff->tv_sec = 0;
      rtc_diff->tv_nsec = 0;
      goto skip;
    }

  /* Get the elapsed time since power up (in milliseconds).  This is a
   * bias value that we need to use to correct the base time.
   */

  clock_systime_timespec(&bias);

  /* Add the base time to this.  The base time is the time-of-day
   * setting.  When added to the elapsed time since the time-of-day
   * was last set, this gives us the current time.
   */

  curr_ts.tv_sec  = bias.tv_sec + g_basetime.tv_sec;
  curr_ts.tv_nsec = bias.tv_nsec + g_basetime.tv_nsec;

  /* Handle carry to seconds. */

  if (curr_ts.tv_nsec >= NSEC_PER_SEC)
    {
      carry            = curr_ts.tv_nsec / NSEC_PER_SEC;
      curr_ts.tv_sec  += carry;
      curr_ts.tv_nsec -= (carry * NSEC_PER_SEC);
    }

  /* Check if RTC has advanced past system time. */

  if (curr_ts.tv_sec > rtc_time.tv_sec ||
      (curr_ts.tv_sec == rtc_time.tv_sec &&
       curr_ts.tv_nsec >= rtc_time.tv_nsec))
    {
      /* Setting system time with RTC now would result time going
       * backwards. Skip resynchronization.
       */

      sinfo("skip resync\n");

      rtc_diff->tv_sec = 0;
      rtc_diff->tv_nsec = 0;
    }
  else
    {
      /* Output difference between time at entry and new current time. */

      rtc_diff->tv_sec  = rtc_time.tv_sec  - curr_ts.tv_sec;
      rtc_diff->tv_nsec = rtc_time.tv_nsec - curr_ts.tv_nsec;

      /* Handle carry to seconds. */

      if (rtc_diff->tv_nsec < 0)
        {
          carry = -((-(rtc_diff->tv_nsec + 1)) / NSEC_PER_SEC + 1);
        }
      else if (rtc_diff->tv_nsec >= NSEC_PER_SEC)
        {
          carry = rtc_diff->tv_nsec / NSEC_PER_SEC;
        }
      else
        {
          carry = 0;
        }

      if (carry != 0)
        {
          rtc_diff->tv_sec  += carry;
          rtc_diff->tv_nsec -= (carry * NSEC_PER_SEC);
        }

      /* Add the sleep time to correct system timer */

      g_system_ticks += SEC2TICK(rtc_diff->tv_sec);
      g_system_ticks += NSEC2TICK(rtc_diff->tv_nsec);
    }

skip:
  leave_critical_section(flags);
}
#endif

/****************************************************************************
 * Name: clock_set_adjust
 *
 * Description:
 *   This function is called from adjtime() defined in clock_adjtime.c if
 *   CONFIG_CLOCK_ADJTIME is enabled. It sets global variables g_clk_adj_usec
 *   and g_clk_adj_count which are used for clock adjustment.
 *
 * Input Parameters:
 *   adj_usec  - period adjustment in usec
 *   adj_count - number of clock ticks over which we apply adj_usec
 *
 ****************************************************************************/

#ifdef CONFIG_CLOCK_ADJTIME
void clock_set_adjust(long long adj_usec, long long adj_count,
                      FAR long long *adj_usec_old,
                      FAR long long *adj_count_old)
{
  /* Get old adjust values. */

  *adj_usec_old  = g_clk_adj_usec;
  *adj_count_old = g_clk_adj_count;

  /* Set new adjust values. */

  g_clk_adj_usec  = adj_usec;
  g_clk_adj_count = adj_count;

  /* And change timer period. */

  up_adj_timer_period(g_clk_adj_usec);
}
#endif

/****************************************************************************
 * Name: clock_timer
 *
 * Description:
 *   This function must be called once every time the real time clock
 *   interrupt occurs.  The interval of this clock interrupt must be
 *   USEC_PER_TICK
 *
 ****************************************************************************/

#ifndef CONFIG_SCHED_TICKLESS
void clock_timer(void)
{
  /* Increment the per-tick system counter */

  g_system_ticks++;

#ifdef CONFIG_CLOCK_ADJTIME
  /* Do we apply timer adjustment? */

  if (g_clk_adj_count > 0)
    {
      /* Yes, decrement the count each tick. */

      g_clk_adj_count--;

      /* Check if clock adjusment is finished. */

      if (g_clk_adj_count == 0)
        {
          /* Yes... reset timer period. */

          up_adj_timer_period(0);
        }
    }
#endif
}
#endif