lupyuen/local-nuttx-update
1
0
Fork 0
forked from nuttx/nuttx-update
Code Pull requests Activity

timekeeping: initial implementation

Browse source
This commit is contained in:
Max Neklyudov 2016-07-10 16:14:25 -06:00 committed by Gregory Nutt
parent 90917d9741
commit 8db29071da
17 changed files with 533 additions and 12 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
arch/arm/Kconfig
View file

@ -225,6 +225,7 @@ config ARCH_CHIP_STM32
select ARCH_HAVE_I2CRESET
select ARCH_HAVE_HEAPCHECK
select ARCH_HAVE_TICKLESS
select ARCH_HAVE_TIMEKEEPING
select ARMV7M_HAVE_STACKCHECK
---help---
STMicro STM32 architectures (ARM Cortex-M3/4).

33
arch/arm/src/stm32/stm32_freerun.c
View file

@ -53,7 +53,7 @@
#ifdef CONFIG_STM32_FREERUN
/****************************************************************************
* Private Functions
* Private Data
****************************************************************************/
static struct stm32_freerun_s *g_freerun;
@ -80,6 +80,7 @@ static struct stm32_freerun_s *g_freerun;
*
****************************************************************************/
#ifndef CONFIG_SCHED_TIMEKEEPING
static int stm32_freerun_handler(int irq, void *context)
{
struct stm32_freerun_s *freerun = g_freerun;
@ -90,6 +91,7 @@ static int stm32_freerun_handler(int irq, void *context)
STM32_TIM_ACKINT(freerun->tch, 0);
return OK;
}
#endif /* CONFIG_SCHED_TIMEKEEPING */
/****************************************************************************
* Public Functions
@ -140,15 +142,21 @@ int stm32_freerun_initialize(struct stm32_freerun_s *freerun, int chan,
* success.
*/
freerun->chan = chan;
freerun->running = false;
freerun->overflow = 0;
freerun->chan = chan;
freerun->running = false;
g_freerun = freerun;
#ifdef CONFIG_SCHED_TIMEKEEPING
freerun->counter_mask = 0xffffffffull;
#endif
#ifndef CONFIG_SCHED_TIMEKEEPING
freerun->overflow = 0;
g_freerun = freerun;
/* Set up to receive the callback when the counter overflow occurs */
STM32_TIM_SETISR(freerun->tch, stm32_freerun_handler, 0);
#endif
/* Set timer period */
@ -157,8 +165,11 @@ int stm32_freerun_initialize(struct stm32_freerun_s *freerun, int chan,
/* Start the counter */
STM32_TIM_SETMODE(freerun->tch, STM32_TIM_MODE_UP);
#ifndef CONFIG_SCHED_TIMEKEEPING
STM32_TIM_ACKINT(freerun->tch, 0);
STM32_TIM_ENABLEINT(freerun->tch, 0);
#endif
return OK;
}
@ -182,6 +193,8 @@ int stm32_freerun_initialize(struct stm32_freerun_s *freerun, int chan,
*
****************************************************************************/
#ifndef CONFIG_SCHED_TIMEKEEPING
int stm32_freerun_counter(struct stm32_freerun_s *freerun,
struct timespec *ts)
{
@ -257,6 +270,16 @@ int stm32_freerun_counter(struct stm32_freerun_s *freerun,
return OK;
}
#else /* CONFIG_SCHED_TIMEKEEPING */
int stm32_freerun_counter(struct stm32_freerun_s *freerun, uint64_t *counter)
{
*counter = (uint64_t)STM32_TIM_GETCOUNTER(freerun->tch);
return OK;
}
#endif /* CONFIG_SCHED_TIMEKEEPING */
/****************************************************************************
* Name: stm32_freerun_uninitialize
*

18
arch/arm/src/stm32/stm32_freerun.h
View file

@ -64,9 +64,16 @@ struct stm32_freerun_s
{
uint8_t chan; /* The timer/counter in use */
bool running; /* True: the timer is running */
uint32_t overflow; /* Timer counter overflow */
FAR struct stm32_tim_dev_s *tch; /* Handle returned by stm32_tim_init() */
uint32_t frequency;
#ifndef CONFIG_SCHED_TIMEKEEPING
uint32_t overflow; /* Timer counter overflow */
#endif
#ifdef CONFIG_SCHED_TIMEKEEPING
uint64_t counter_mask;
#endif
};
/****************************************************************************
@ -127,9 +134,18 @@ int stm32_freerun_initialize(struct stm32_freerun_s *freerun, int chan,
*
****************************************************************************/
#ifndef CONFIG_SCHED_TIMEKEEPING
int stm32_freerun_counter(struct stm32_freerun_s *freerun,
struct timespec *ts);
#else /* CONFIG_SCHED_TIMEKEEPING */
int stm32_freerun_counter(struct stm32_freerun_s *freerun,
uint64_t *counter);
#endif /* CONFIG_SCHED_TIMEKEEPING */
/****************************************************************************
* Name: stm32_freerun_uninitialize
*

33
arch/arm/src/stm32/stm32_tickless.c
View file

@ -272,11 +272,44 @@ void up_timer_initialize(void)
*
****************************************************************************/
#ifndef CONFIG_SCHED_TIMEKEEPING
int up_timer_gettime(FAR struct timespec *ts)
{
return stm32_freerun_counter(&g_tickless.freerun, ts);
}
#else
int up_timer_getcounter(FAR uint64_t *cycles)
{
return stm32_freerun_counter(&g_tickless.freerun, cycles);
}
#endif /* CONFIG_SCHED_TIMEKEEPING */
/****************************************************************************
* Name: up_timer_getmask
*
* Description:
* To be provided
*
* Input Parameters:
* mask - Location to return the 64-bit mask
*
* Returned Value:
* None
*
****************************************************************************/
#ifdef CONFIG_SCHED_TIMEKEEPING
void up_timer_getmask(FAR uint64_t *mask)
{
DEBUGASSERT(mask != NULL);
*mask = g_tickless.freerun.counter_mask;
}
#endif /* CONFIG_SCHED_TIMEKEEPING */
/****************************************************************************
* Name: up_timer_cancel
*

7
include/nuttx/arch.h
View file

@ -1496,10 +1496,15 @@ void up_timer_initialize(void);
*
****************************************************************************/
#ifdef CONFIG_SCHED_TICKLESS
#if defined(CONFIG_SCHED_TICKLESS) && !defined(CONFIG_SCHED_TIMEKEEPING)
int up_timer_gettime(FAR struct timespec *ts);
#endif
#ifdef CONFIG_SCHED_TIMEKEEPING
int up_timer_getcounter(FAR uint64_t *cycles);
void up_timer_getmask(FAR uint64_t *mask);
#endif
/****************************************************************************
* Name: up_alarm_cancel
*

15
include/sys/time.h
View file

@ -1,7 +1,7 @@
/****************************************************************************
* include/sys/time.h
*
* Copyright (C) 2009, 2015 Gregory Nutt. All rights reserved.
* Copyright (C) 2009, 2015-2016 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -112,6 +112,7 @@
/****************************************************************************
* Public Type Definitions
****************************************************************************/
/* struct timeval represents time as seconds plus microseconds */
struct timeval
@ -190,6 +191,18 @@ int gettimeofday(FAR struct timeval *tv, FAR struct timezone *tz);
int settimeofday(FAR const struct timeval *tv, FAR struct timezone *tz);
/****************************************************************************
* Name: adjtime
*
* Description:
* Correct the time to synchronize the system clock
*
****************************************************************************/
#ifdef CONFIG_SCHED_TIMEKEEPING
int adjtime(const struct timeval *delta, struct timeval *olddelta);
#endif
#undef EXTERN
#if defined(__cplusplus)
}

11
sched/Kconfig
View file

@ -167,6 +167,17 @@ config CLOCK_MONOTONIC
The value of the CLOCK_MONOTONIC clock cannot be set via clock_settime().
config ARCH_HAVE_TIMEKEEPING
bool
default n
config SCHED_TIMEKEEPING
bool "Support timekeeping algorithms"
default n
depends on EXPERIMENTAL && ARCH_HAVE_TIMEKEEPING
---help---
SCHED_TIMEKEEPING enables experimental time management algorithms.
config JULIAN_TIME
bool "Enables Julian time conversions"
default n

4
sched/clock/Make.defs
View file

@ -38,6 +38,10 @@ CSRCS += clock_time2ticks.c clock_abstime2ticks.c clock_ticks2time.c
CSRCS += clock_systimer.c clock_systimespec.c clock_timespec_add.c
CSRCS += clock_timespec_subtract.c
ifeq ($(CONFIG_SCHED_TIMEKEEPING),y
CSRCS += clock_timekeeping.c
endif
# Include clock build support
DEPPATH += --dep-path clock

2
sched/clock/clock.h
View file

@ -79,7 +79,9 @@ extern volatile uint32_t g_system_timer;
# endif
#endif
#ifndef CONFIG_SCHED_TIMEKEEPING
extern struct timespec g_basetime;
#endif
/********************************************************************************
* Public Function Prototypes

16
sched/clock/clock_gettime.c
View file

@ -49,6 +49,9 @@
#include <nuttx/arch.h>
#include "clock/clock.h"
#ifdef CONFIG_SCHED_TIMEKEEPING
# include "clock/clock_timekeeping.h"
#endif
/****************************************************************************
* Public Functions
@ -90,7 +93,9 @@ int clock_gettime(clockid_t clock_id, struct timespec *tp)
* reset.
*/
#ifdef CONFIG_SCHED_TICKLESS
#if defined(CONFIG_SCHED_TIMEKEEPING)
ret = clock_timekeeping_get_monotonic_time(tp);
#elif defined(CONFIG_SCHED_TICKLESS)
ret = up_timer_gettime(tp);
#else
ret = clock_systimespec(tp);
@ -113,7 +118,15 @@ int clock_gettime(clockid_t clock_id, struct timespec *tp)
* last set.
*/
#if defined(CONFIG_SCHED_TIMEKEEPING)
ret = clock_timekeeping_get_wall_time(tp);
#elif defined(CONFIG_SCHED_TICKLESS)
ret = up_timer_gettime(&ts);
#else
ret = clock_systimespec(&ts);
#endif
#ifndef CONFIG_SCHED_TIMEKEEPING
if (ret == OK)
{
/* Add the base time to this. The base time is the time-of-day
@ -138,6 +151,7 @@ int clock_gettime(clockid_t clock_id, struct timespec *tp)
tp->tv_sec = ts.tv_sec;
tp->tv_nsec = ts.tv_nsec;
}
#endif /* CONFIG_SCHED_TIMEKEEPING */
}
else
{

11
sched/clock/clock_initialize.c
View file

@ -54,6 +54,9 @@
#include <nuttx/time.h>
#include "clock/clock.h"
#ifdef CONFIG_SCHED_TIMEKEEPING
# include "clock/clock_timekeeping.h"
#endif
/****************************************************************************
* Pre-processor Definitions
@ -172,10 +175,16 @@ static void clock_inittime(void)
{
/* (Re-)initialize the time value to match the RTC */
(void)clock_basetime(&g_basetime);
#ifndef CONFIG_SCHED_TIMEKEEPING
#ifndef CONFIG_RTC_HIRES
clock_basetime(&g_basetime);
#endif
#ifndef CONFIG_SCHED_TICKLESS
g_system_timer = 0;
#endif
#else
clock_inittimekeeping();
#endif
}
/****************************************************************************

7
sched/clock/clock_settime.c
View file

@ -48,6 +48,9 @@
#include <nuttx/irq.h>
#include "clock/clock.h"
#ifdef CONFIG_SCHED_TIMEKEEPING
# include "clock/clock_timekeeping.h"
#endif
/****************************************************************************
* Public Functions
@ -76,6 +79,7 @@ int clock_settime(clockid_t clock_id, FAR const struct timespec *tp)
if (clock_id == CLOCK_REALTIME)
{
#ifndef CONFIG_SCHED_TIMEKEEPING
/* Interrupts are disabled here so that the in-memory time
* representation and the RTC setting will be as close as
* possible.
@ -123,6 +127,9 @@ int clock_settime(clockid_t clock_id, FAR const struct timespec *tp)
sinfo("basetime=(%ld,%lu) bias=(%ld,%lu)\n",
(long)g_basetime.tv_sec, (unsigned long)g_basetime.tv_nsec,
(long)bias.tv_sec, (unsigned long)bias.tv_nsec);
#else
ret = clock_timekeeping_set_wall_time(tp);
#endif
}
else
{

8
sched/clock/clock_systimer.c
View file

@ -83,7 +83,11 @@ systime_t clock_systimer(void)
/* Get the time from the platform specific hardware */
#ifndef CONFIG_SCHED_TIMEKEEPING
(void)up_timer_gettime(&ts);
#else
(void)clock_timekeeping_get_monotonic_time(&ts);
#endif
/* Convert to a 64-bit value in microseconds, then in clock tick units */
@ -96,7 +100,11 @@ systime_t clock_systimer(void)
/* Get the time from the platform specific hardware */
#ifndef CONFIG_SCHED_TIMEKEEPING
(void)up_timer_gettime(&ts);
#else
(void)clock_timekeeping_get_monotonic_time(&ts);
#endif
/* Convert to a 64- then a 32-bit value */

297
sched/clock/clock_timekeeping.c Normal file
View file

@ -0,0 +1,297 @@
/************************************************************************
* sched/clock/clock_timekeeping.c
*
* Copyright (C) 2016 Gregory Nutt. All rights reserved.
* Author: Max Neklyudov <macscomp@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
************************************************************************/
/************************************************************************
* Included Files
************************************************************************/
#include <nuttx/config.h>
#ifdef CONFIG_SCHED_TIMEKEEPING
#include <sys/time.h>
#include <stdint.h>
#include <time.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/irq.h>
#include <nuttx/arch.h>
#include "clock/clock.h"
/************************************************************************
* Pre-processor Definitions
************************************************************************/
#define NTP_MAX_ADJUST 500
/**********************************************************************
* Private Data
**********************************************************************/
static struct timespec g_clock_wall_time;
static struct timespec g_clock_monotonic_time;
static uint64_t g_clock_last_counter;
static uint64_t g_clock_mask;
static long g_clock_adjust;
/************************************************************************
* Private Functions
************************************************************************/
/************************************************************************
* Name: clock_get_current_time
************************************************************************/
static int clock_get_current_time(FAR struct timespec *ts,
FAR struct timespec *base)
{
irqstate_t flags;
uint64_t counter;
uint64_t offset;
uint64_t nsec;
time_t sec;
int ret;
flags = enter_critical_section();
ret = up_timer_getcounter(&counter);
if (ret < 0)
{
goto errout_in_critical_section;
}
offset = (counter - g_clock_last_counter) & g_clock_mask;
nsec = offset * NSEC_PER_TICK;
sec = nsec / NSEC_PER_SEC;
nsec -= sec * NSEC_PER_SEC;
nsec += base->tv_nsec;
if (nsec > NSEC_PER_SEC)
{
nsec -= NSEC_PER_SEC;
sec += 1;
}
ts->tv_nsec = nsec;
ts->tv_sec = base->tv_sec + sec;
errout_in_critical_section:
leave_critical_section(flags);
return ret;
}
/************************************************************************
* Public Functions
************************************************************************/
/************************************************************************
* Name: clock_timekeeping_get_monotonic_time
************************************************************************/
int clock_timekeeping_get_monotonic_time(FAR struct timespec *ts)
{
return clock_get_current_time(ts, &g_clock_monotonic_time);
}
/************************************************************************
* Name: clock_timekeeping_get_wall_time
************************************************************************/
int clock_timekeeping_get_wall_time(FAR struct timespec *ts)
{
return clock_get_current_time(ts, &g_clock_wall_time);
}
/************************************************************************
* Name: clock_timekeeping_set_wall_time
************************************************************************/
int clock_timekeeping_set_wall_time(FAR struct timespec *ts)
{
irqstate_t flags;
uint64_t counter;
int ret;
flags = enter_critical_section();
ret = up_timer_getcounter(&counter);
if (ret < 0)
{
goto errout_in_critical_section;
}
g_clock_wall_time = *ts;
g_clock_adjust = 0;
g_clock_last_counter = counter;
errout_in_critical_section:
leave_critical_section(flags);
return ret;
}
/************************************************************************
* Name: adjtime
************************************************************************/
int adjtime(const struct timeval *delta, struct timeval *olddelta)
{
irqstate_t flags;
long adjust_usec;
if (!delta)
{
set_errno(EINVAL);
return -1;
}
flags = enter_critical_section();
adjust_usec = delta->tv_sec * USEC_PER_SEC + delta->tv_usec;
if (olddelta)
{
olddelta->tv_usec = g_clock_adjust;
}
g_clock_adjust = adjust_usec;
leave_critical_section(flags);
return OK;
}
/************************************************************************
* Name: clock_update_wall_time
************************************************************************/
void clock_update_wall_time(void)
{
irqstate_t flags;
uint64_t counter;
uint64_t offset;
int64_t nsec;
time_t sec;
int ret;
flags = enter_critical_section();
ret = up_timer_getcounter(&counter);
if (ret < 0)
{
goto errout_in_critical_section;
}
offset = (counter - g_clock_last_counter) & g_clock_mask;
if (offset == 0)
{
goto errout_in_critical_section;
}
nsec = offset * NSEC_PER_TICK;
sec = nsec / NSEC_PER_SEC;
nsec -= sec * NSEC_PER_SEC;
g_clock_monotonic_time.tv_sec += sec;
g_clock_monotonic_time.tv_nsec += nsec;
if (g_clock_monotonic_time.tv_nsec > NSEC_PER_SEC)
{
g_clock_monotonic_time.tv_nsec -= NSEC_PER_SEC;
g_clock_monotonic_time.tv_sec += 1;
}
nsec += g_clock_wall_time.tv_nsec;
if (nsec > NSEC_PER_SEC)
{
nsec -= NSEC_PER_SEC;
sec += 1;
}
if (g_clock_adjust != 0 && sec > 0)
{
long adjust = NTP_MAX_ADJUST * (long)sec;
if (g_clock_adjust < adjust && g_clock_adjust > -adjust)
{
adjust = g_clock_adjust;
}
nsec += adjust * NSEC_PER_USEC;
while (nsec < 0)
{
nsec += NSEC_PER_SEC;
sec -= 1;
}
while (nsec > NSEC_PER_SEC)
{
nsec -= NSEC_PER_SEC;
sec += 1;
}
}
g_clock_wall_time.tv_sec += sec;
g_clock_wall_time.tv_nsec = (long)nsec;
g_clock_last_counter = counter;
errout_in_critical_section:
leave_critical_section(flags);
}
/************************************************************************
* Name: clock_inittimekeeping
************************************************************************/
void clock_inittimekeeping(void)
{
struct tm rtctime;
up_timer_getmask(&g_clock_mask);
/* Get the broken-errout_in_critical_section time from the date/time RTC. */
(void)up_rtc_getdatetime(&rtctime);
/* And use the broken-errout_in_critical_section time to initialize the system time */
g_clock_wall_time.tv_sec = mktime(&rtctime);
g_clock_wall_time.tv_nsec = 0;
memset(&g_clock_monotonic_time, 0, sizeof(g_clock_monotonic_time));
}
#endif /* CONFIG_SCHED_TIMEKEEPING */

62
sched/clock/clock_timekeeping.h Normal file
View file

@ -0,0 +1,62 @@
/********************************************************************************
* sched/clock/clock_timekeeping.h
*
* Copyright (C) 2016 Gregory Nutt. All rights reserved.
* Author: Max Neklyudov <macscomp@gmail.com>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
********************************************************************************/
#ifndef __SCHED_CLOCK_CLOCK_TIMEKEEPING_H
#define __SCHED_CLOCK_CLOCK_TIMEKEEPING_H
/********************************************************************************
* Included Files
********************************************************************************/
#include <nuttx/config.h>
#include <nuttx/compiler.h>
#include <stdint.h>
#include <nuttx/clock.h>
/********************************************************************************
* Public Function Prototypes
********************************************************************************/
int clock_timekeeping_get_monotonic_time(FAR struct timespec *ts);
int clock_timekeeping_get_wall_time(FAR struct timespec *ts);
int clock_timekeeping_set_wall_time(FAR struct timespec *ts);
void clock_update_wall_time(void);
void clock_inittimekeeping(void);
#endif /* __SCHED_CLOCK_CLOCK_TIMEKEEPING_H */

8
sched/sched/sched_processtimer.c
View file

@ -1,7 +1,7 @@
/****************************************************************************
* sched/sched/sched_processtimer.c
*
* Copyright (C) 2007, 2009, 2014-2015 Gregory Nutt. All rights reserved.
* Copyright (C) 2007, 2009, 2014-2016 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -144,6 +144,12 @@ static inline void sched_process_scheduler(void)
void sched_process_timer(void)
{
#ifdef CONFIG_SCHED_TIMEKEEPING
/* Process wall time */
clock_update_wall_time();
#endif
/* Increment the system time (if in the link) */
#ifdef CONFIG_HAVE_WEAKFUNCTIONS

12
sched/sched/sched_timerexpiration.c
View file

@ -1,7 +1,7 @@
/****************************************************************************
* sched/sched/sched_timerexpiration.c
*
* Copyright (C) 2014-2015 Gregory Nutt. All rights reserved.
* Copyright (C) 2014-2016 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without
@ -53,6 +53,10 @@
#include "wdog/wdog.h"
#include "clock/clock.h"
#ifdef CONFIG_SCHED_TIMEKEEPING
# include "clock/clock_timekeeping.h"
#endif
#ifdef CONFIG_SCHED_TICKLESS
/****************************************************************************
@ -262,6 +266,12 @@ static unsigned int sched_timer_process(unsigned int ticks, bool noswitches)
unsigned int rettime = 0;
unsigned int tmp;
#ifdef CONFIG_SCHED_TIMEKEEPING
/* Process wall time */
clock_update_wall_time();
#endif
/* Process watchdogs */
tmp = wd_timer(ticks);