ztimer64.h

Go to the documentation of this file.

/*
 * Copyright (C) 2021 Inria
 *               2021 Freie Universität Berlin
 *               2021 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.
 */
 
#pragma once
 
#include <stdint.h>
 
#include "irq.h"
#include "mutex.h"
#include "msg.h"
#include "ztimer.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct ztimer64_base ztimer64_base_t;
typedef struct ztimer64_clock ztimer64_clock_t;
 
struct ztimer64_base {
    ztimer64_base_t *next;          
    uint64_t target;                
};
 
typedef struct {
    ztimer64_base_t base;               
    void (*callback)(void *arg);        
    void *arg;                          
} ztimer64_t;
 
struct ztimer64_clock {
    ztimer64_base_t *first;         
    ztimer_clock_t *base_clock;     
    ztimer_t base_timer;            
    uint64_t checkpoint;            
    uint16_t adjust_set;            
    uint16_t adjust_sleep;          
#if MODULE_PM_LAYERED || DOXYGEN
    uint8_t block_pm_mode;          
#endif
};
 
uint64_t ztimer64_now(ztimer64_clock_t *clock);
 
static inline uint64_t ztimer64_offset2absolute(ztimer64_clock_t *clock,
                                                uint64_t offset)
{
    unsigned state = irq_disable();
    uint64_t result = ztimer64_now(clock) + offset;
 
    irq_restore(state);
    return result;
}
 
void ztimer64_set_at(ztimer64_clock_t *clock, ztimer64_t *timer,
                     uint64_t target);
 
static inline void ztimer64_set(ztimer64_clock_t *clock, ztimer64_t *timer,
                                uint64_t offset)
{
    ztimer64_set_at(clock, timer,
                    ztimer64_offset2absolute(clock, offset));
}
 
unsigned ztimer64_is_set(const ztimer64_t *timer);
 
void ztimer64_remove(ztimer64_clock_t *clock, ztimer64_t *timer);
 
void ztimer64_set_msg_at(ztimer64_clock_t *clock, ztimer64_t *timer,
                         uint64_t target,
                         msg_t *msg, kernel_pid_t target_pid);
 
static inline void ztimer64_set_msg(ztimer64_clock_t *clock, ztimer64_t *timer,
                                    uint64_t offset,
                                    msg_t *msg, kernel_pid_t target_pid)
{
    ztimer64_set_msg_at(clock, timer,
                        ztimer64_offset2absolute(clock, offset),
                        msg, target_pid);
}
 
int ztimer64_msg_receive_until(ztimer64_clock_t *clock, msg_t *msg,
                               uint64_t target);
 
static inline int ztimer64_msg_receive_timeout(ztimer64_clock_t *clock,
                                               msg_t *msg,
                                               uint64_t timeout)
{
    return ztimer64_msg_receive_until(clock, msg,
                                      ztimer64_offset2absolute(clock, timeout));
}
 
#define MSG_ZTIMER64 0xc83f   
void ztimer64_periodic_wakeup(ztimer64_clock_t *clock, uint64_t *last_wakeup,
                              uint64_t period);
 
void ztimer64_sleep_until(ztimer64_clock_t *clock, uint64_t target);
 
static inline void ztimer64_sleep(ztimer64_clock_t *clock, uint64_t duration)
{
    ztimer64_sleep_until(clock, ztimer64_offset2absolute(clock, duration));
}
 
static inline void ztimer64_spin_until(ztimer64_clock_t *clock, uint64_t target)
{
    while (ztimer64_now(clock) <= target) {}
}
 
void ztimer64_set_wakeup_at(ztimer64_clock_t *clock, ztimer64_t *timer,
                            uint64_t target,
                            kernel_pid_t pid);
 
static inline void ztimer64_set_wakeup(ztimer64_clock_t *clock,
                                       ztimer64_t *timer, uint64_t offset,
                                       kernel_pid_t pid)
{
    ztimer64_set_wakeup_at(clock, timer,
                           ztimer64_offset2absolute(clock, offset), pid);
}
 
void ztimer64_set_timeout_flag_at(ztimer64_clock_t *clock, ztimer64_t *timer,
                                  uint64_t target);
 
static inline void ztimer64_set_timeout_flag(ztimer64_clock_t *clock,
                                             ztimer64_t *timer,
                                             uint64_t timeout)
{
    ztimer64_set_timeout_flag_at(clock, timer,
                                 ztimer64_offset2absolute(clock, timeout));
}
 
int ztimer64_mutex_lock_until(ztimer64_clock_t *clock, mutex_t *mutex,
                              uint64_t target);
 
static inline int ztimer64_mutex_lock_timeout(ztimer64_clock_t *clock,
                                              mutex_t *mutex,
                                              uint64_t timeout)
{
    return ztimer64_mutex_lock_until(clock, mutex,
                                     ztimer64_offset2absolute(clock, timeout));
}
 
int ztimer64_rmutex_lock_until(ztimer64_clock_t *clock, rmutex_t *rmutex,
                               uint64_t target);
 
static inline int ztimer64_rmutex_lock_timeout(ztimer64_clock_t *clock,
                                               rmutex_t *rmutex,
                                               uint64_t timeout)
{
    return ztimer64_rmutex_lock_until(clock, rmutex,
                                      ztimer64_offset2absolute(clock, timeout));
}
 
void ztimer64_update_head_offset(ztimer64_clock_t *clock);
 
void ztimer64_init(void);
 
void ztimer64_clock_init(ztimer64_clock_t *clock, ztimer_clock_t *base_clock);
 
/* default ztimer virtual devices */
extern ztimer64_clock_t *const ZTIMER64_USEC;
 
extern ztimer64_clock_t *const ZTIMER64_MSEC;
 
extern ztimer64_clock_t *const ZTIMER64_SEC;
 
int64_t ztimer64_overhead(ztimer64_clock_t *clock, uint64_t base);
 
#ifdef __cplusplus
}
#endif