ptp.h

Go to the documentation of this file.

/*
 * Copyright (C) 2020 Otto-von-Guericke-Universität Magdeburg
 *
 * 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 "periph_cpu.h"
#include "timex.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* verify settings from periph_cpu.h */
#if !defined(HAVE_PTP_CLOCK_READ) && !defined(HAVE_PTP_CLOCK_READ_U64)
#error "Neither ptp_clock_read() nor ptp_clock_read_u64() implemented"
#endif
 
#if !defined(HAVE_PTP_CLOCK_SET) && !defined(HAVE_PTP_CLOCK_SET_U64)
#error "Neither ptp_clock_set() nor ptp_clock_set_u64() implemented"
#endif
 
#if \
    !defined(HAVE_PTP_TIMER_SET_ABSOLUTE) && \
    !defined(HAVE_PTP_TIMER_SET_ABSOLUTE_U64) && \
    IS_USED(MODULE_PERIPH_PTP_TIMER)
#error "Neither ptp_timer_set_absolute() nor ptp_timer_set_absolute_u64() implemented"
#endif

typedef uint32_t ptp_seconds_t;

typedef struct {
    ptp_seconds_t seconds;  
    uint32_t nanoseconds;   
} ptp_timestamp_t;

static inline int ptp_cmp(const ptp_timestamp_t *a, const ptp_timestamp_t *b)
{
    if (a->seconds < b->seconds) {
        return -1;
    }
 
    if (a->seconds > b->seconds) {
        return 1;
    }
 
    if (a->nanoseconds < b->nanoseconds) {
        return -1;
    }
 
    if (a->nanoseconds > b->nanoseconds) {
        return 1;
    }
 
    return 0;
}

static inline void ptp_add(ptp_timestamp_t *t, int64_t offset)
{
    /* Modulo for negative numbers should be avoided */
    if (offset >= 0) {
        uint64_t abs_offset = offset;
        t->seconds += abs_offset / NS_PER_SEC;
        t->nanoseconds += abs_offset % NS_PER_SEC;
        /* correct overflow of nanosecond part */
        if (t->nanoseconds >= NS_PER_SEC) {
            t->nanoseconds -= NS_PER_SEC;
            t->seconds++;
        }
    }
    else {
        uint64_t abs_offset = -offset;
        t->seconds -= abs_offset / NS_PER_SEC;
        t->nanoseconds -= abs_offset % NS_PER_SEC;
        /* correct underflow of nanosecond part */
        if (t->nanoseconds > NS_PER_SEC) {
            t->nanoseconds += NS_PER_SEC;
            t->seconds--;
        }
    }
}

static inline void ptp_ns2ts(ptp_timestamp_t *dest, uint64_t ns_since_epoch)
{
    dest->seconds = ns_since_epoch / NS_PER_SEC;
    dest->nanoseconds = ns_since_epoch % NS_PER_SEC;
}

static inline uint64_t ptp_ts2ns(const ptp_timestamp_t *t)
{
    return t->seconds * NS_PER_SEC + t->nanoseconds;
}

void ptp_init(void);

void ptp_clock_adjust_speed(int32_t correction);

void ptp_clock_adjust(int64_t offset);
 
#if defined(HAVE_PTP_CLOCK_READ) || defined(DOXYGEN)
void ptp_clock_read(ptp_timestamp_t *timestamp);
#endif /* HAVE_PTP_CLOCK_READ */
 
#if defined(HAVE_PTP_CLOCK_READ_U64) || defined(DOXYGEN)
uint64_t ptp_clock_read_u64(void);
#endif /* HAVE_PTP_CLOCK_READ_U64 */
 
#if defined(HAVE_PTP_CLOCK_SET) || defined(DOXYGEN)
void ptp_clock_set(const ptp_timestamp_t *time);
#endif /* HAVE_PTP_CLOCK_SET */
 
#if defined(HAVE_PTP_CLOCK_SET_U64) || defined(DOXYGEN)
void ptp_clock_set_u64(uint64_t ns_since_epoch);
#endif /* HAVE_PTP_CLOCK_SET_U64 */

void ptp_timer_cb(void);
 
#if defined(HAVE_PTP_TIMER_SET_ABSOLUTE) || defined(DOXYGEN)
void ptp_timer_set_absolute(const ptp_timestamp_t *target);
#endif /* HAVE_PTP_TIMER_SET_ABSOLUTE */
 
#if defined(HAVE_PTP_TIMER_SET_ABSOLUTE_U64) || defined(DOXYGEN)
void ptp_timer_set_absolute_u64(uint64_t target);
#endif /* HAVE_PTP_TIMER_SET_ABSOLUTE_U64 */

void ptp_timer_set_u64(uint64_t target);

void ptp_timer_clear(void);
 
/* Fallback implementations (the driver can implement either the
 * functions using `ptp_timestamp_t` or `uint64_t`, the other flavor will
 * be provided on top here): */
 
#ifndef HAVE_PTP_CLOCK_READ
static inline void ptp_clock_read(struct ptp_timestamp_t *timestamp)
{
    ptp_ns2ts(timestamp, ptp_clock_read_u64());
}
#endif /* !HAVE_PTP_CLOCK_READ */
 
#ifndef HAVE_PTP_CLOCK_READ_U64
static inline uint64_t ptp_clock_read_u64(void)
{
    ptp_timestamp_t ts;
    ptp_clock_read(&ts);
    return ptp_ts2ns(&ts);
}
#endif /* !HAVE_PTP_CLOCK_READ_U64 */
 
#ifndef HAVE_PTP_CLOCK_SET
static inline void ptp_clock_set(const ptp_timestamp_t *time)
{
    ptp_clock_set_u64(ptp_ts2ns(time));
}
#endif /* !HAVE_PTP_CLOCK_SET */
 
#ifndef HAVE_PTP_CLOCK_SET_U64
static inline void ptp_clock_set_u64(uint64_t ns_since_epoch)
{
    ptp_timestamp_t time;
    ptp_ns2ts(&time, ns_since_epoch);
    ptp_clock_set(&time);
}
#endif /* !HAVE_PTP_CLOCK_SET_U64 */
 
#ifndef HAVE_PTP_TIMER_SET_ABSOLUTE
static inline void ptp_timer_set_absolute(const ptp_timestamp_t *target)
{
    ptp_timer_set_absolute_u64(ptp_ts2ns(target));
}
#endif /* !HAVE_PTP_TIMER_SET_ABSOLUTE */
 
#ifndef HAVE_PTP_TIMER_SET_ABSOLUTE_U64
static inline void ptp_timer_set_absolute_u64(uint64_t target)
{
    ptp_timestamp_t ts;
    ptp_ns2ts(&ts, target);
    ptp_timer_set_absolute(&ts);
}
#endif /* !HAVE_PTP_TIMER_SET_ABSOLUTE_U64 */
 
#ifdef __cplusplus
}
#endif