clock.h

/*
 * Copyright (C) 2006,2007 Philippe Gerum <rpm@xenomai.org>.
 *
 * Xenomai is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License,
 * or (at your option) any later version.
 *
 * Xenomai is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Xenomai; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */
#ifndef _COBALT_KERNEL_CLOCK_H
#define _COBALT_KERNEL_CLOCK_H
 
#include <pipeline/pipeline.h>
#include <pipeline/clock.h>
#include <cobalt/kernel/list.h>
#include <cobalt/kernel/vfile.h>
#include <cobalt/uapi/kernel/types.h>
#include <asm/xenomai/wrappers.h>
 
struct xnsched;
struct xntimerdata;
struct __kernel_timex;
 
struct xnclock_gravity {
        unsigned long irq;
        unsigned long kernel;
        unsigned long user;
};
 
struct xnclock {
        xnsticks_t wallclock_offset;
        xnticks_t resolution;
        struct xnclock_gravity gravity;
        const char *name;
        struct {
#ifdef CONFIG_XENO_OPT_EXTCLOCK
                xnticks_t (*read_raw)(struct xnclock *clock);
                xnticks_t (*read_monotonic)(struct xnclock *clock);
                int (*set_time)(struct xnclock *clock,
                                const struct timespec64 *ts);
                xnsticks_t (*ns_to_ticks)(struct xnclock *clock,
                                          xnsticks_t ns);
                xnsticks_t (*ticks_to_ns)(struct xnclock *clock,
                                          xnsticks_t ticks);
                xnsticks_t (*ticks_to_ns_rounded)(struct xnclock *clock,
                                                  xnsticks_t ticks);
                void (*program_local_shot)(struct xnclock *clock,
                                           struct xnsched *sched);
                void (*program_remote_shot)(struct xnclock *clock,
                                            struct xnsched *sched);
#endif
                int (*adjust_time)(struct xnclock *clock,
                                   struct __kernel_timex *tx);
                int (*set_gravity)(struct xnclock *clock,
                                   const struct xnclock_gravity *p);
                void (*reset_gravity)(struct xnclock *clock);
#ifdef CONFIG_XENO_OPT_VFILE
                void (*print_status)(struct xnclock *clock,
                                     struct xnvfile_regular_iterator *it);
#endif
        } ops;
        /* Private section. */
        struct xntimerdata __percpu *timerdata;
        int id;
#ifdef CONFIG_SMP
        cpumask_t affinity;
#endif
#ifdef CONFIG_XENO_OPT_STATS
        struct xnvfile_snapshot timer_vfile;
        struct xnvfile_rev_tag timer_revtag;
        struct list_head timerq;
        int nrtimers;
#endif /* CONFIG_XENO_OPT_STATS */
#ifdef CONFIG_XENO_OPT_VFILE
        struct xnvfile_regular vfile;
#endif
};
 
struct xnclock_ratelimit_state {
        xnticks_t interval;
        xnticks_t begin;
        int burst;
        int printed;
        int missed;
};
 
extern struct xnclock nkclock;
 
int xnclock_register(struct xnclock *clock,
                     const cpumask_t *affinity);
 
void xnclock_deregister(struct xnclock *clock);
 
void xnclock_tick(struct xnclock *clock);
 
void xnclock_core_local_shot(struct xnsched *sched);
 
void xnclock_core_remote_shot(struct xnsched *sched);
 
xnsticks_t xnclock_core_ns_to_ticks(xnsticks_t ns);
 
xnsticks_t xnclock_core_ticks_to_ns(xnsticks_t ticks);
 
xnsticks_t xnclock_core_ticks_to_ns_rounded(xnsticks_t ticks);
 
xnticks_t xnclock_core_read_monotonic(void);
 
static inline xnticks_t xnclock_core_read_raw(void)
{
        return pipeline_read_cycle_counter();
}
 
/* We use the Linux defaults */
#define XN_RATELIMIT_INTERVAL   5000000000LL
#define XN_RATELIMIT_BURST      10
 
int __xnclock_ratelimit(struct xnclock_ratelimit_state *rs, const char *func);
 
#define xnclock_ratelimit()     ({                                      \
        static struct xnclock_ratelimit_state __state = {               \
                .interval       = XN_RATELIMIT_INTERVAL,                \
                .burst          = XN_RATELIMIT_BURST,                   \
        };                                                              \
        __xnclock_ratelimit(&__state, __func__);                        \
})
 
#ifdef CONFIG_XENO_OPT_EXTCLOCK
 
static inline void xnclock_program_shot(struct xnclock *clock,
                                        struct xnsched *sched)
{
        if (likely(clock == &nkclock))
                xnclock_core_local_shot(sched);
        else if (clock->ops.program_local_shot)
                clock->ops.program_local_shot(clock, sched);
}
 
static inline void xnclock_remote_shot(struct xnclock *clock,
                                       struct xnsched *sched)
{
#ifdef CONFIG_SMP
        if (likely(clock == &nkclock))
                xnclock_core_remote_shot(sched);
        else if (clock->ops.program_remote_shot)
                clock->ops.program_remote_shot(clock, sched);
#endif
}
 
static inline xnticks_t xnclock_read_raw(struct xnclock *clock)
{
        if (likely(clock == &nkclock))
                return xnclock_core_read_raw();
 
        return clock->ops.read_raw(clock);
}
 
static inline xnsticks_t xnclock_ns_to_ticks(struct xnclock *clock,
                                             xnsticks_t ns)
{
        if (likely(clock == &nkclock))
                return xnclock_core_ns_to_ticks(ns);
 
        return clock->ops.ns_to_ticks(clock, ns);
}
 
static inline xnsticks_t xnclock_ticks_to_ns(struct xnclock *clock,
                                             xnsticks_t ticks)
{
        if (likely(clock == &nkclock))
                return xnclock_core_ticks_to_ns(ticks);
 
        return clock->ops.ticks_to_ns(clock, ticks);
}
 
static inline xnsticks_t xnclock_ticks_to_ns_rounded(struct xnclock *clock,
                                                     xnsticks_t ticks)
{
        if (likely(clock == &nkclock))
                return xnclock_core_ticks_to_ns_rounded(ticks);
 
        return clock->ops.ticks_to_ns_rounded(clock, ticks);
}
 
static inline xnticks_t xnclock_read_monotonic(struct xnclock *clock)
{
        if (likely(clock == &nkclock))
                return xnclock_core_read_monotonic();
 
        return clock->ops.read_monotonic(clock);
}
 
static inline int xnclock_set_time(struct xnclock *clock,
                                   const struct timespec64 *ts)
{
        if (likely(clock == &nkclock))
                return -EINVAL;
 
        return clock->ops.set_time(clock, ts);
}
 
#else /* !CONFIG_XENO_OPT_EXTCLOCK */
 
static inline void xnclock_program_shot(struct xnclock *clock,
                                        struct xnsched *sched)
{
        xnclock_core_local_shot(sched);
}
 
static inline void xnclock_remote_shot(struct xnclock *clock,
                                       struct xnsched *sched)
{
#ifdef CONFIG_SMP
        xnclock_core_remote_shot(sched);
#endif
}
 
static inline xnticks_t xnclock_read_raw(struct xnclock *clock)
{
        return xnclock_core_read_raw();
}
 
static inline xnsticks_t xnclock_ns_to_ticks(struct xnclock *clock,
                                             xnsticks_t ns)
{
        return xnclock_core_ns_to_ticks(ns);
}
 
static inline xnsticks_t xnclock_ticks_to_ns(struct xnclock *clock,
                                             xnsticks_t ticks)
{
        return xnclock_core_ticks_to_ns(ticks);
}
 
static inline xnsticks_t xnclock_ticks_to_ns_rounded(struct xnclock *clock,
                                                     xnsticks_t ticks)
{
        return xnclock_core_ticks_to_ns_rounded(ticks);
}
 
static inline xnticks_t xnclock_read_monotonic(struct xnclock *clock)
{
        return xnclock_core_read_monotonic();
}
 
static inline int xnclock_set_time(struct xnclock *clock,
                                   const struct timespec64 *ts)
{
        /*
         * There is no way to change the core clock's idea of time.
         */
        return -EINVAL;
}
 
#endif /* !CONFIG_XENO_OPT_EXTCLOCK */
 
static inline int xnclock_adjust_time(struct xnclock *clock,
                                      struct __kernel_timex *tx)
{
        if (clock->ops.adjust_time == NULL)
                return -EOPNOTSUPP;
 
        return clock->ops.adjust_time(clock, tx);
}
 
static inline xnticks_t xnclock_get_offset(struct xnclock *clock)
{
        return clock->wallclock_offset;
}
 
static inline xnticks_t xnclock_get_resolution(struct xnclock *clock)
{
        return clock->resolution; /* ns */
}
 
static inline void xnclock_set_resolution(struct xnclock *clock,
                                          xnticks_t resolution)
{
        clock->resolution = resolution; /* ns */
}
 
static inline int xnclock_set_gravity(struct xnclock *clock,
                                      const struct xnclock_gravity *gravity)
{
        if (clock->ops.set_gravity)
                return clock->ops.set_gravity(clock, gravity);
 
        return -EINVAL;
}
 
static inline void xnclock_reset_gravity(struct xnclock *clock)
{
        if (clock->ops.reset_gravity)
                clock->ops.reset_gravity(clock);
}
 
#define xnclock_get_gravity(__clock, __type)  ((__clock)->gravity.__type)
 
static inline xnticks_t xnclock_read_realtime(struct xnclock *clock)
{
        if (likely(clock == &nkclock))
                return pipeline_read_wallclock();
        /*
         * Return an adjusted value of the monotonic time with the
         * translated system wallclock offset.
         */
        return xnclock_read_monotonic(clock) + xnclock_get_offset(clock);
}
 
void xnclock_apply_offset(struct xnclock *clock,
                          xnsticks_t delta_ns);
 
void xnclock_set_wallclock(xnticks_t epoch_ns);
 
unsigned long long xnclock_divrem_billion(unsigned long long value,
                                          unsigned long *rem);
 
#ifdef CONFIG_XENO_OPT_VFILE
 
void xnclock_init_proc(void);
 
void xnclock_cleanup_proc(void);
 
static inline void xnclock_print_status(struct xnclock *clock,
                                        struct xnvfile_regular_iterator *it)
{
        if (clock->ops.print_status)
                clock->ops.print_status(clock, it);
}
 
#else
static inline void xnclock_init_proc(void) { }
static inline void xnclock_cleanup_proc(void) { }
#endif
 
int xnclock_init(void);
 
void xnclock_cleanup(void);
 
#endif /* !_COBALT_KERNEL_CLOCK_H */