/*
|
* Copyright (C) 2001,2002,2003 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_TIMER_H
|
#define _COBALT_KERNEL_TIMER_H
|
|
#include <cobalt/kernel/clock.h>
|
#include <cobalt/kernel/stat.h>
|
#include <cobalt/kernel/list.h>
|
#include <cobalt/kernel/assert.h>
|
#include <cobalt/kernel/ancillaries.h>
|
#include <asm/xenomai/wrappers.h>
|
|
/**
|
* @addtogroup cobalt_core_timer
|
* @{
|
*/
|
#define XN_INFINITE ((xnticks_t)0)
|
#define XN_NONBLOCK ((xnticks_t)-1)
|
|
/* Timer modes */
|
typedef enum xntmode {
|
XN_RELATIVE,
|
XN_ABSOLUTE,
|
XN_REALTIME
|
} xntmode_t;
|
|
/* Timer status */
|
#define XNTIMER_DEQUEUED 0x00000001
|
#define XNTIMER_KILLED 0x00000002
|
#define XNTIMER_PERIODIC 0x00000004
|
#define XNTIMER_REALTIME 0x00000008
|
#define XNTIMER_FIRED 0x00000010
|
#define XNTIMER_RUNNING 0x00000020
|
#define XNTIMER_KGRAVITY 0x00000040
|
#define XNTIMER_UGRAVITY 0x00000080
|
#define XNTIMER_IGRAVITY 0 /* most conservative */
|
|
#define XNTIMER_GRAVITY_MASK (XNTIMER_KGRAVITY|XNTIMER_UGRAVITY)
|
#define XNTIMER_INIT_MASK XNTIMER_GRAVITY_MASK
|
|
/* These flags are available to the real-time interfaces */
|
#define XNTIMER_SPARE0 0x01000000
|
#define XNTIMER_SPARE1 0x02000000
|
#define XNTIMER_SPARE2 0x04000000
|
#define XNTIMER_SPARE3 0x08000000
|
#define XNTIMER_SPARE4 0x10000000
|
#define XNTIMER_SPARE5 0x20000000
|
#define XNTIMER_SPARE6 0x40000000
|
#define XNTIMER_SPARE7 0x80000000
|
|
/* Timer priorities */
|
#define XNTIMER_LOPRIO (-999999999)
|
#define XNTIMER_STDPRIO 0
|
#define XNTIMER_HIPRIO 999999999
|
|
struct xntlholder {
|
struct list_head link;
|
xnticks_t key;
|
int prio;
|
};
|
|
#define xntlholder_date(h) ((h)->key)
|
#define xntlholder_prio(h) ((h)->prio)
|
#define xntlist_init(q) INIT_LIST_HEAD(q)
|
#define xntlist_empty(q) list_empty(q)
|
|
static inline struct xntlholder *xntlist_head(struct list_head *q)
|
{
|
if (list_empty(q))
|
return NULL;
|
|
return list_first_entry(q, struct xntlholder, link);
|
}
|
|
static inline struct xntlholder *xntlist_next(struct list_head *q,
|
struct xntlholder *h)
|
{
|
if (list_is_last(&h->link, q))
|
return NULL;
|
|
return list_entry(h->link.next, struct xntlholder, link);
|
}
|
|
static inline struct xntlholder *xntlist_second(struct list_head *q,
|
struct xntlholder *h)
|
{
|
return xntlist_next(q, h);
|
}
|
|
static inline void xntlist_insert(struct list_head *q, struct xntlholder *holder)
|
{
|
struct xntlholder *p;
|
|
if (list_empty(q)) {
|
list_add(&holder->link, q);
|
return;
|
}
|
|
/*
|
* Insert the new timer at the proper place in the single
|
* queue. O(N) here, but this is the price for the increased
|
* flexibility...
|
*/
|
list_for_each_entry_reverse(p, q, link) {
|
if ((xnsticks_t) (holder->key - p->key) > 0 ||
|
(holder->key == p->key && holder->prio <= p->prio))
|
break;
|
}
|
|
list_add(&holder->link, &p->link);
|
}
|
|
#define xntlist_remove(q, h) \
|
do { \
|
(void)(q); \
|
list_del(&(h)->link); \
|
} while (0)
|
|
#if defined(CONFIG_XENO_OPT_TIMER_RBTREE)
|
|
#include <linux/rbtree.h>
|
|
typedef struct {
|
unsigned long long date;
|
unsigned prio;
|
struct rb_node link;
|
} xntimerh_t;
|
|
#define xntimerh_date(h) ((h)->date)
|
#define xntimerh_prio(h) ((h)->prio)
|
#define xntimerh_init(h) do { } while (0)
|
|
typedef struct {
|
struct rb_root root;
|
xntimerh_t *head;
|
} xntimerq_t;
|
|
#define xntimerq_init(q) \
|
({ \
|
xntimerq_t *_q = (q); \
|
_q->root = RB_ROOT; \
|
_q->head = NULL; \
|
})
|
|
#define xntimerq_destroy(q) do { } while (0)
|
#define xntimerq_empty(q) ((q)->head == NULL)
|
|
#define xntimerq_head(q) ((q)->head)
|
|
#define xntimerq_next(q, h) \
|
({ \
|
struct rb_node *_node = rb_next(&(h)->link); \
|
_node ? (container_of(_node, xntimerh_t, link)) : NULL; \
|
})
|
|
#define xntimerq_second(q, h) xntimerq_next(q, h)
|
|
void xntimerq_insert(xntimerq_t *q, xntimerh_t *holder);
|
|
static inline void xntimerq_remove(xntimerq_t *q, xntimerh_t *holder)
|
{
|
if (holder == q->head)
|
q->head = xntimerq_second(q, holder);
|
|
rb_erase(&holder->link, &q->root);
|
}
|
|
typedef struct { } xntimerq_it_t;
|
|
#define xntimerq_it_begin(q,i) ((void) (i), xntimerq_head(q))
|
#define xntimerq_it_next(q,i,h) ((void) (i), xntimerq_next((q),(h)))
|
|
#else /* CONFIG_XENO_OPT_TIMER_LIST */
|
|
typedef struct xntlholder xntimerh_t;
|
|
#define xntimerh_date(h) xntlholder_date(h)
|
#define xntimerh_prio(h) xntlholder_prio(h)
|
#define xntimerh_init(h) do { } while (0)
|
|
typedef struct list_head xntimerq_t;
|
|
#define xntimerq_init(q) xntlist_init(q)
|
#define xntimerq_destroy(q) do { } while (0)
|
#define xntimerq_empty(q) xntlist_empty(q)
|
#define xntimerq_head(q) xntlist_head(q)
|
#define xntimerq_second(q, h) xntlist_second((q),(h))
|
#define xntimerq_insert(q, h) xntlist_insert((q),(h))
|
#define xntimerq_remove(q, h) xntlist_remove((q),(h))
|
|
typedef struct { } xntimerq_it_t;
|
|
#define xntimerq_it_begin(q,i) ((void) (i), xntlist_head(q))
|
#define xntimerq_it_next(q,i,h) ((void) (i), xntlist_next((q),(h)))
|
|
#endif /* CONFIG_XENO_OPT_TIMER_LIST */
|
|
struct xnsched;
|
|
struct xntimerdata {
|
xntimerq_t q;
|
};
|
|
static inline struct xntimerdata *
|
xnclock_percpu_timerdata(struct xnclock *clock, int cpu)
|
{
|
return per_cpu_ptr(clock->timerdata, cpu);
|
}
|
|
static inline struct xntimerdata *
|
xnclock_this_timerdata(struct xnclock *clock)
|
{
|
return raw_cpu_ptr(clock->timerdata);
|
}
|
|
struct xntimer {
|
#ifdef CONFIG_XENO_OPT_EXTCLOCK
|
struct xnclock *clock;
|
#endif
|
/** Link in timers list. */
|
xntimerh_t aplink;
|
struct list_head adjlink;
|
/** Timer status. */
|
unsigned long status;
|
/** Periodic interval (clock ticks, 0 == one shot). */
|
xnticks_t interval;
|
/** Periodic interval (nanoseconds, 0 == one shot). */
|
xnticks_t interval_ns;
|
/** Count of timer ticks in periodic mode. */
|
xnticks_t periodic_ticks;
|
/** First tick date in periodic mode. */
|
xnticks_t start_date;
|
/** Date of next periodic release point (timer ticks). */
|
xnticks_t pexpect_ticks;
|
/** Sched structure to which the timer is attached. */
|
struct xnsched *sched;
|
/** Timeout handler. */
|
void (*handler)(struct xntimer *timer);
|
#ifdef CONFIG_XENO_OPT_STATS
|
#ifdef CONFIG_XENO_OPT_EXTCLOCK
|
struct xnclock *tracker;
|
#endif
|
/** Timer name to be displayed. */
|
char name[XNOBJECT_NAME_LEN];
|
/** Timer holder in timebase. */
|
struct list_head next_stat;
|
/** Number of timer schedules. */
|
xnstat_counter_t scheduled;
|
/** Number of timer events. */
|
xnstat_counter_t fired;
|
#endif /* CONFIG_XENO_OPT_STATS */
|
};
|
|
#ifdef CONFIG_XENO_OPT_EXTCLOCK
|
|
static inline struct xnclock *xntimer_clock(struct xntimer *timer)
|
{
|
return timer->clock;
|
}
|
|
void xntimer_set_clock(struct xntimer *timer,
|
struct xnclock *newclock);
|
|
#else /* !CONFIG_XENO_OPT_EXTCLOCK */
|
|
static inline struct xnclock *xntimer_clock(struct xntimer *timer)
|
{
|
return &nkclock;
|
}
|
|
static inline void xntimer_set_clock(struct xntimer *timer,
|
struct xnclock *newclock)
|
{
|
XENO_BUG_ON(COBALT, newclock != &nkclock);
|
}
|
|
#endif /* !CONFIG_XENO_OPT_EXTCLOCK */
|
|
#ifdef CONFIG_SMP
|
static inline struct xnsched *xntimer_sched(struct xntimer *timer)
|
{
|
return timer->sched;
|
}
|
#else /* !CONFIG_SMP */
|
#define xntimer_sched(t) xnsched_current()
|
#endif /* !CONFIG_SMP */
|
|
#define xntimer_percpu_queue(__timer) \
|
({ \
|
struct xntimerdata *tmd; \
|
int cpu = xnsched_cpu((__timer)->sched); \
|
tmd = xnclock_percpu_timerdata(xntimer_clock(__timer), cpu); \
|
&tmd->q; \
|
})
|
|
static inline unsigned long xntimer_gravity(struct xntimer *timer)
|
{
|
struct xnclock *clock = xntimer_clock(timer);
|
|
if (timer->status & XNTIMER_KGRAVITY)
|
return clock->gravity.kernel;
|
|
if (timer->status & XNTIMER_UGRAVITY)
|
return clock->gravity.user;
|
|
return clock->gravity.irq;
|
}
|
|
static inline void xntimer_update_date(struct xntimer *timer)
|
{
|
xntimerh_date(&timer->aplink) = timer->start_date
|
+ xnclock_ns_to_ticks(xntimer_clock(timer),
|
timer->periodic_ticks * timer->interval_ns)
|
- xntimer_gravity(timer);
|
}
|
|
static inline xnticks_t xntimer_pexpect(struct xntimer *timer)
|
{
|
return timer->start_date +
|
xnclock_ns_to_ticks(xntimer_clock(timer),
|
timer->pexpect_ticks * timer->interval_ns);
|
}
|
|
static inline void xntimer_set_priority(struct xntimer *timer,
|
int prio)
|
{
|
xntimerh_prio(&timer->aplink) = prio;
|
}
|
|
static inline int xntimer_active_p(struct xntimer *timer)
|
{
|
return timer->sched != NULL;
|
}
|
|
static inline int xntimer_running_p(struct xntimer *timer)
|
{
|
return (timer->status & XNTIMER_RUNNING) != 0;
|
}
|
|
static inline int xntimer_fired_p(struct xntimer *timer)
|
{
|
return (timer->status & XNTIMER_FIRED) != 0;
|
}
|
|
static inline int xntimer_periodic_p(struct xntimer *timer)
|
{
|
return (timer->status & XNTIMER_PERIODIC) != 0;
|
}
|
|
void __xntimer_init(struct xntimer *timer,
|
struct xnclock *clock,
|
void (*handler)(struct xntimer *timer),
|
struct xnsched *sched,
|
int flags);
|
|
void xntimer_set_gravity(struct xntimer *timer,
|
int gravity);
|
|
#ifdef CONFIG_XENO_OPT_STATS
|
|
#define xntimer_init(__timer, __clock, __handler, __sched, __flags) \
|
do { \
|
__xntimer_init(__timer, __clock, __handler, __sched, __flags); \
|
xntimer_set_name(__timer, #__handler); \
|
} while (0)
|
|
static inline void xntimer_reset_stats(struct xntimer *timer)
|
{
|
xnstat_counter_set(&timer->scheduled, 0);
|
xnstat_counter_set(&timer->fired, 0);
|
}
|
|
static inline void xntimer_account_scheduled(struct xntimer *timer)
|
{
|
xnstat_counter_inc(&timer->scheduled);
|
}
|
|
static inline void xntimer_account_fired(struct xntimer *timer)
|
{
|
xnstat_counter_inc(&timer->fired);
|
}
|
|
static inline void xntimer_set_name(struct xntimer *timer, const char *name)
|
{
|
knamecpy(timer->name, name);
|
}
|
|
#else /* !CONFIG_XENO_OPT_STATS */
|
|
#define xntimer_init __xntimer_init
|
|
static inline void xntimer_reset_stats(struct xntimer *timer) { }
|
|
static inline void xntimer_account_scheduled(struct xntimer *timer) { }
|
|
static inline void xntimer_account_fired(struct xntimer *timer) { }
|
|
static inline void xntimer_set_name(struct xntimer *timer, const char *name) { }
|
|
#endif /* !CONFIG_XENO_OPT_STATS */
|
|
#if defined(CONFIG_XENO_OPT_EXTCLOCK) && defined(CONFIG_XENO_OPT_STATS)
|
void xntimer_switch_tracking(struct xntimer *timer,
|
struct xnclock *newclock);
|
#else
|
static inline
|
void xntimer_switch_tracking(struct xntimer *timer,
|
struct xnclock *newclock) { }
|
#endif
|
|
void xntimer_destroy(struct xntimer *timer);
|
|
/**
|
* @fn xnticks_t xntimer_interval(struct xntimer *timer)
|
*
|
* @brief Return the timer interval value.
|
*
|
* Return the timer interval value in nanoseconds.
|
*
|
* @param timer The address of a valid timer descriptor.
|
*
|
* @return The duration of a period in nanoseconds. The special value
|
* XN_INFINITE is returned if @a timer is currently disabled or
|
* one shot.
|
*
|
* @coretags{unrestricted, atomic-entry}
|
*/
|
static inline xnticks_t xntimer_interval(struct xntimer *timer)
|
{
|
return timer->interval_ns;
|
}
|
|
static inline xnticks_t xntimer_expiry(struct xntimer *timer)
|
{
|
/* Real expiry date in ticks without anticipation (no gravity) */
|
return xntimerh_date(&timer->aplink) + xntimer_gravity(timer);
|
}
|
|
int xntimer_start(struct xntimer *timer,
|
xnticks_t value,
|
xnticks_t interval,
|
xntmode_t mode);
|
|
void __xntimer_stop(struct xntimer *timer);
|
|
xnticks_t xntimer_get_date(struct xntimer *timer);
|
|
xnticks_t __xntimer_get_timeout(struct xntimer *timer);
|
|
xnticks_t xntimer_get_interval(struct xntimer *timer);
|
|
int xntimer_heading_p(struct xntimer *timer);
|
|
static inline void xntimer_stop(struct xntimer *timer)
|
{
|
if (timer->status & XNTIMER_RUNNING)
|
__xntimer_stop(timer);
|
}
|
|
static inline xnticks_t xntimer_get_timeout(struct xntimer *timer)
|
{
|
if (!xntimer_running_p(timer))
|
return XN_INFINITE;
|
|
return __xntimer_get_timeout(timer);
|
}
|
|
static inline xnticks_t xntimer_get_timeout_stopped(struct xntimer *timer)
|
{
|
return __xntimer_get_timeout(timer);
|
}
|
|
static inline void xntimer_enqueue(struct xntimer *timer,
|
xntimerq_t *q)
|
{
|
xntimerq_insert(q, &timer->aplink);
|
timer->status &= ~XNTIMER_DEQUEUED;
|
xntimer_account_scheduled(timer);
|
}
|
|
static inline void xntimer_dequeue(struct xntimer *timer,
|
xntimerq_t *q)
|
{
|
xntimerq_remove(q, &timer->aplink);
|
timer->status |= XNTIMER_DEQUEUED;
|
}
|
|
unsigned long long xntimer_get_overruns(struct xntimer *timer,
|
struct xnthread *waiter,
|
xnticks_t now);
|
|
#ifdef CONFIG_SMP
|
|
void __xntimer_migrate(struct xntimer *timer, struct xnsched *sched);
|
|
static inline
|
void xntimer_migrate(struct xntimer *timer, struct xnsched *sched)
|
{ /* nklocked, IRQs off */
|
if (timer->sched != sched)
|
__xntimer_migrate(timer, sched);
|
}
|
|
void __xntimer_set_affinity(struct xntimer *timer,
|
struct xnsched *sched);
|
|
static inline void xntimer_set_affinity(struct xntimer *timer,
|
struct xnsched *sched)
|
{
|
if (sched != xntimer_sched(timer))
|
__xntimer_set_affinity(timer, sched);
|
}
|
|
#else /* ! CONFIG_SMP */
|
|
static inline void xntimer_migrate(struct xntimer *timer,
|
struct xnsched *sched)
|
{
|
timer->sched = sched;
|
}
|
|
static inline void xntimer_set_affinity(struct xntimer *timer,
|
struct xnsched *sched)
|
{
|
xntimer_migrate(timer, sched);
|
}
|
|
#endif /* CONFIG_SMP */
|
|
char *xntimer_format_time(xnticks_t ns,
|
char *buf, size_t bufsz);
|
|
/** @} */
|
|
#endif /* !_COBALT_KERNEL_TIMER_H */
|
