ztimer.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Kaspar Schleiser <kaspar@schleiser.de>
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
#ifndef ZTIMER_H
#define ZTIMER_H
 
#include <stdint.h>
 
#include "sched.h"
#include "msg.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define ZTIMER_CLOCK_NO_REQUIRED_PM_MODE (UINT8_MAX)
 
typedef struct ztimer_base ztimer_base_t;
 
typedef struct ztimer_clock ztimer_clock_t;
 
struct ztimer_base {
    ztimer_base_t *next;        
    uint32_t offset;            
};
 
#if MODULE_ZTIMER_NOW64
typedef uint64_t ztimer_now_t;  
#else
typedef uint32_t ztimer_now_t;  
#endif
 
typedef struct {
    ztimer_base_t base;             
    void (*callback)(void *arg);    
    void *arg;                      
} ztimer_t;
 
typedef struct {
    void (*set)(ztimer_clock_t *clock, uint32_t val);
 
    uint32_t (*now)(ztimer_clock_t *clock);
 
    void (*cancel)(ztimer_clock_t *clock);
} ztimer_ops_t;
 
struct ztimer_clock {
    ztimer_base_t list;             
    const ztimer_ops_t *ops;        
    ztimer_base_t *last;            
    uint16_t adjust_set;            
    uint16_t adjust_sleep;          
#if MODULE_ZTIMER_EXTEND || MODULE_ZTIMER_NOW64 || DOXYGEN
    /* values used for checkpointed intervals and 32bit extension */
    uint32_t max_value;             
    uint32_t lower_last;            
    ztimer_now_t checkpoint;        
#endif
#if MODULE_PM_LAYERED || DOXYGEN
    uint8_t required_pm_mode;       
#endif
};
 
void ztimer_handler(ztimer_clock_t *clock);
 
/* User API */
void ztimer_set(ztimer_clock_t *clock, ztimer_t *timer, uint32_t val);
 
void ztimer_remove(ztimer_clock_t *clock, ztimer_t *timer);
 
void ztimer_set_msg(ztimer_clock_t *clock, ztimer_t *timer, uint32_t offset,
                    msg_t *msg, kernel_pid_t target_pid);
 
int ztimer_msg_receive_timeout(ztimer_clock_t *clock, msg_t *msg,
                               uint32_t timeout);
 
 /* created with dist/tools/define2u16.py */
#define MSG_ZTIMER 0xc83e   
ztimer_now_t _ztimer_now_extend(ztimer_clock_t *clock);
 
static inline ztimer_now_t ztimer_now(ztimer_clock_t *clock)
{
#if MODULE_ZTIMER_NOW64
    if (1) {
#elif MODULE_ZTIMER_EXTEND
    if (clock->max_value < UINT32_MAX) {
#else
    if (0) {
#endif
        return _ztimer_now_extend(clock);
    }
    else {
        return clock->ops->now(clock);
    }
}
 
void ztimer_periodic_wakeup(ztimer_clock_t *clock, uint32_t *last_wakeup,
                            uint32_t period);
 
void ztimer_sleep(ztimer_clock_t *clock, uint32_t duration);
 
static inline void ztimer_spin(ztimer_clock_t *clock, uint32_t duration) {
    uint32_t end = ztimer_now(clock) + duration;
 
    /* Rely on integer overflow. `end - now` will be smaller than `duration`,
     * counting down, until it underflows to UINT32_MAX. Loop ends then. */
    while ((end - ztimer_now(clock)) <= duration) {}
}
 
void ztimer_set_wakeup(ztimer_clock_t *clock, ztimer_t *timer, uint32_t offset,
                       kernel_pid_t pid);
 
void ztimer_set_timeout_flag(ztimer_clock_t *clock, ztimer_t *timer,
                             uint32_t timeout);
 
void ztimer_update_head_offset(ztimer_clock_t *clock);
 
void ztimer_init(void);
 
#if defined(MODULE_ZTIMER_EXTEND) || defined(DOXYGEN)
 
static inline void ztimer_init_extend(ztimer_clock_t *clock)
{
    if (clock->max_value < UINT32_MAX) {
        clock->ops->set(clock, clock->max_value >> 1);
    }
}
#endif /* MODULE_ZTIMER_EXTEND */
 
/* default ztimer virtual devices */
extern ztimer_clock_t *const ZTIMER_USEC;
 
extern ztimer_clock_t *const ZTIMER_MSEC;
 
extern ztimer_clock_t *const ZTIMER_USEC_BASE;
 
extern ztimer_clock_t *const ZTIMER_MSEC_BASE;
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZTIMER_H */