/*
|
* 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>
|
|
/**
|
* @addtogroup cobalt_core_clock
|
* @{
|
*/
|
|
struct xnsched;
|
struct xntimerdata;
|
struct __kernel_timex;
|
|
struct xnclock_gravity {
|
unsigned long irq;
|
unsigned long kernel;
|
unsigned long user;
|
};
|
|
struct xnclock {
|
/** (ns) */
|
xnsticks_t wallclock_offset;
|
/** (ns) */
|
xnticks_t resolution;
|
/** (raw clock ticks). */
|
struct xnclock_gravity gravity;
|
/** Clock name. */
|
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 *timerdata;
|
int id;
|
#ifdef CONFIG_SMP
|
/** Possible CPU affinity of clock beat. */
|
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 */
|
