kaspar/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2025-12-25 06:23:53 +01:00
Code Releases Activity

Merge pull request #4181 from gebart/pr/xtimer-small-cleanups

Browse Source 
xtimer: small cleanups
This commit is contained in:
Joakim Nohlgård 2015-10-29 07:24:15 +01:00
commit 8b378d660f
3 changed files with 39 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
sys/include/xtimer.h
View File

@ -401,7 +401,7 @@ extern volatile uint32_t _high_cnt;
/**
* @brief returns the (masked) low-level timer counter value.
*/
static inline uint32_t _xtimer_now(void)
static inline uint32_t _lltimer_now(void)
{
#if XTIMER_SHIFT
return ((uint32_t)timer_read(XTIMER)) << XTIMER_SHIFT;
@ -413,7 +413,7 @@ static inline uint32_t _xtimer_now(void)
/**
* @brief drop bits of a value that don't fit into the low-level timer.
*/
static inline uint32_t _mask(uint32_t val)
static inline uint32_t _lltimer_mask(uint32_t val)
{
return val & ~XTIMER_MASK_SHIFTED;
}
@ -436,8 +436,8 @@ static inline void xtimer_spin_until(uint32_t value);
*
* (only relevant when XTIMER_MASK != 0, e.g., timers < 32bit.)
*
* When combining _xtimer_now() and _high_cnt, we have to get the same value in
* order to work around a race between overflowing _xtimer_now() and OR'ing the
* When combining _lltimer_now() and _high_cnt, we have to get the same value in
* order to work around a race between overflowing _lltimer_now() and OR'ing the
* resulting values.
* But some platforms are too slow to get the same timer
* value twice, so we use this define to ignore some of the bits.
@ -460,31 +460,31 @@ static inline uint32_t xtimer_now(void)
#if XTIMER_MASK
uint32_t a, b;
do {
a = _xtimer_now() | _high_cnt;
b = _xtimer_now() | _high_cnt;
a = _lltimer_now() | _high_cnt;
b = _lltimer_now() | _high_cnt;
} while ((a >> XTIMER_SHIFT_ON_COMPARE) != (b >> XTIMER_SHIFT_ON_COMPARE));
return b;
#else
return _xtimer_now();
return _lltimer_now();
#endif
}
static inline void xtimer_spin_until(uint32_t value) {
static inline void xtimer_spin_until(uint32_t target) {
#if XTIMER_MASK
value = _mask(value);
target = _lltimer_mask(target);
#endif
while (_xtimer_now() > value);
while (_xtimer_now() < value);
while (_lltimer_now() > target);
while (_lltimer_now() < target);
}
static inline void xtimer_spin(uint32_t offset) {
uint32_t start = _xtimer_now();
while ((_xtimer_now() - start) < offset);
uint32_t start = _lltimer_now();
while ((_lltimer_now() - start) < offset);
}
static inline void xtimer_usleep(uint32_t offset)
static inline void xtimer_usleep(uint32_t microseconds)
{
_xtimer_sleep(offset, 0);
_xtimer_sleep(microseconds, 0);
}
static inline void xtimer_usleep64(uint64_t microseconds)
@ -494,12 +494,12 @@ static inline void xtimer_usleep64(uint64_t microseconds)
static inline void xtimer_sleep(uint32_t seconds)
{
xtimer_usleep64((uint64_t)seconds*SEC_IN_USEC);
xtimer_usleep64((uint64_t)seconds * SEC_IN_USEC);
}
static inline void xtimer_nanosleep(uint32_t nanoseconds)
{
_xtimer_sleep(nanoseconds/1000, 0);
_xtimer_sleep(nanoseconds / USEC_IN_NS, 0);
}
#ifdef __cplusplus

40
sys/xtimer/xtimer_core.c
View File

@ -113,7 +113,7 @@ void _xtimer_set64(xtimer_t *timer, uint32_t offset, uint32_t long_offset)
void xtimer_set(xtimer_t *timer, uint32_t offset)
{
DEBUG("timer_set(): offset=%" PRIu32 " now=%" PRIu32 " (%" PRIu32 ")\n", offset, xtimer_now(), _xtimer_now());
DEBUG("timer_set(): offset=%" PRIu32 " now=%" PRIu32 " (%" PRIu32 ")\n", offset, xtimer_now(), _lltimer_now());
if (!timer->callback) {
DEBUG("timer_set(): timer has no callback.\n");
return;
@ -147,14 +147,14 @@ static inline void _lltimer_set(uint32_t target)
if (_in_handler) {
return;
}
DEBUG("__lltimer_set(): setting %" PRIu32 "\n", _mask(target));
DEBUG("_lltimer_set(): setting %" PRIu32 "\n", _lltimer_mask(target));
#ifdef XTIMER_SHIFT
target >>= XTIMER_SHIFT;
if (!target) {
target++;
}
#endif
timer_set_absolute(XTIMER, XTIMER_CHAN, _mask(target));
timer_set_absolute(XTIMER, XTIMER_CHAN, _lltimer_mask(target));
}
int _xtimer_set_absolute(xtimer_t *timer, uint32_t target)
@ -167,7 +167,7 @@ int _xtimer_set_absolute(xtimer_t *timer, uint32_t target)
timer->next = NULL;
if ((target >= now) && ((target - XTIMER_BACKOFF) < now)) {
/* backoff */
xtimer_spin_until(target+XTIMER_BACKOFF);
xtimer_spin_until(target + XTIMER_BACKOFF);
_shoot(timer);
return 0;
}
@ -184,7 +184,7 @@ int _xtimer_set_absolute(xtimer_t *timer, uint32_t target)
_add_timer_to_long_list(&long_list_head, timer);
}
else {
if (_mask(now) >= target) {
if (_lltimer_mask(now) >= target) {
DEBUG("xtimer_set_absolute(): the timer will expire in the next timer period\n");
_add_timer_to_list(&overflow_list_head, timer);
}
@ -255,7 +255,7 @@ int xtimer_remove(xtimer_t *timer)
next = timer_list_head->target - XTIMER_OVERHEAD;
}
else {
next = _mask(0xFFFFFFFF);
next = _lltimer_mask(0xFFFFFFFF);
}
_lltimer_set(next);
}
@ -275,7 +275,7 @@ int xtimer_remove(xtimer_t *timer)
static uint32_t _time_left(uint32_t target, uint32_t reference)
{
uint32_t now = _xtimer_now();
uint32_t now = _lltimer_now();
if (now < reference) {
return 0;
@ -307,10 +307,10 @@ static inline int _this_high_period(uint32_t target) {
static inline xtimer_t *_compare(xtimer_t *a, xtimer_t *b)
{
if (a && b) {
return a->target <= b->target ? a : b;
return ((a->target <= b->target) ? a : b);
}
else {
return a ? a : b;
return (a ? a : b);
}
}
@ -423,7 +423,7 @@ static void _timer_callback(void)
_in_handler = 1;
DEBUG("_timer_callback() now=%" PRIu32 " (%" PRIu32 ")pleft=%" PRIu32 "\n", xtimer_now(),
_mask(xtimer_now()), _mask(0xffffffff-xtimer_now()));
_lltimer_mask(xtimer_now()), _lltimer_mask(0xffffffff-xtimer_now()));
if (!timer_list_head) {
DEBUG("_timer_callback(): tick\n");
@ -438,21 +438,21 @@ static void _timer_callback(void)
/* make sure the timer counter also arrived
* in the next timer period */
while (_xtimer_now() == _mask(0xFFFFFFFF));
while (_lltimer_now() == _lltimer_mask(0xFFFFFFFF));
}
else {
/* we ended up in _timer_callback and there is
* a timer waiting.
*/
/* set our period reference to the current time. */
reference = _xtimer_now();
reference = _lltimer_now();
}
overflow:
/* check if next timers are close to expiring */
while (timer_list_head && (_time_left(_mask(timer_list_head->target), reference) < XTIMER_ISR_BACKOFF)) {
while (timer_list_head && (_time_left(_lltimer_mask(timer_list_head->target), reference) < XTIMER_ISR_BACKOFF)) {
/* make sure we don't fire too early */
while (_time_left(_mask(timer_list_head->target), reference));
while (_time_left(_lltimer_mask(timer_list_head->target), reference));
/* pick first timer in list */
xtimer_t *timer = timer_list_head;
@ -472,7 +472,7 @@ overflow:
* time to overflow. In that case we advance to
* next timer period and check again for expired
* timers.*/
if (reference > _xtimer_now()) {
if (reference > _lltimer_now()) {
DEBUG("_timer_callback: overflowed while executing callbacks. %i\n", timer_list_head != 0);
_next_period();
reference = 0;
@ -484,15 +484,15 @@ overflow:
next_target = timer_list_head->target - XTIMER_OVERHEAD;
/* make sure we're not setting a time in the past */
if (next_target < (_xtimer_now() + XTIMER_ISR_BACKOFF)) {
if (next_target < (_lltimer_now() + XTIMER_ISR_BACKOFF)) {
goto overflow;
}
}
else {
/* there's no timer planned for this timer period */
/* schedule callback on next overflow */
next_target = _mask(0xFFFFFFFF);
uint32_t now = _xtimer_now();
next_target = _lltimer_mask(0xFFFFFFFF);
uint32_t now = _lltimer_now();
/* check for overflow again */
if (now < reference) {
@ -502,9 +502,9 @@ overflow:
}
else {
/* check if the end of this period is very soon */
if (_mask(now + XTIMER_ISR_BACKOFF) < now) {
if (_lltimer_mask(now + XTIMER_ISR_BACKOFF) < now) {
/* spin until next period, then advance */
while (_xtimer_now() >= now);
while (_lltimer_now() >= now);
_next_period();
reference = 0;
goto overflow;

4
tests/xtimer_shift_on_compare/main.c
View File

@ -55,8 +55,8 @@ int main(void)
else {
}
a = _xtimer_now() | _high_cnt;
b = _xtimer_now() | _high_cnt;
a = _lltimer_now() | _high_cnt;
b = _lltimer_now() | _high_cnt;
} while ((a>>shift) != (b>>shift));
min[shift] = i < min[shift] ? i : min[shift];