ptp.h

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-3.0-or-later
   SPDX-FileCopyrightText: Copyright © 2021 Erez Geva <ErezGeva2@gmail.com> */
 
#ifndef __PTPMGMT_IF_H
#define __PTPMGMT_IF_H
 
#ifdef __cplusplus
#include <vector>
#include <ctime>
#include "types.h"
#ifdef __linux__
#include <linux/ethtool.h>
#endif
 
__PTPMGMT_NAMESPACE_BEGIN
 
/* The macro might be used, we prefer C++ const */
#ifndef CLOCK_INVALID
const clockid_t CLOCK_INVALID = -1;
#endif
const int NO_SUCH_IF = -1;
const int NO_SUCH_PTP = -1;
typedef long double float_freq;
 
class IfInfo
{
  private:
    bool m_isInit;
    int m_ifIndex, m_ptpIndex;
    std::string m_ifName;
    Binary m_mac;
 
    bool initPtp(int fd, struct ifreq &m_ifr);
 
  public:
    IfInfo() : m_isInit(false), m_ifIndex(NO_SUCH_IF), m_ptpIndex(NO_SUCH_PTP) {}
    bool initUsingName(const std::string &ifName);
    bool initUsingIndex(int ifIndex);
    bool isInit() const { return m_isInit; }
    int ifIndex() const { return m_ifIndex; }
    const std::string &ifName() const { return m_ifName; }
    const char *ifName_c() const { return m_ifName.c_str(); }
    const Binary &mac() const { return m_mac; }
    const uint8_t *mac_c() const { return m_mac.get(); }
    size_t mac_size() const { return m_mac.length(); }
    int ptpIndex() const { return m_ptpIndex; }
};
struct PtpCaps_t {
    int64_t max_ppb; 
    int num_alarm; 
    int num_external_channels; 
    int num_periodic_sig; 
    bool pps; 
    int num_pins; 
    bool cross_timestamping;
    bool adjust_phase; 
    int64_t max_phase_adj; 
};
enum PtpPinFunc_e {
    PTP_PIN_UNUSED,       
    PTP_PIN_EXTERNAL_TS,  
    PTP_PIN_PERIODIC_OUT, 
    PTP_PIN_PHY_SYNC,     
};
struct PtpPin_t {
    unsigned int index; 
    std::string description;
    PtpPinFunc_e functional; 
    unsigned int channel; 
};
const uint8_t PTP_EXTERN_TS_RISING_EDGE = 1 << 1;
const uint8_t PTP_EXTERN_TS_FALLING_EDGE = 1 << 2;
const uint8_t PTP_EXTERN_TS_STRICT = 1 << 3;
const uint8_t PTP_PERIOD_ONE_SHOT = 1 << 0;
const uint8_t PTP_PERIOD_WIDTH = 1 << 1;
const uint8_t PTP_PERIOD_PHASE = 1 << 2;
 
struct PtpEvent_t {
    unsigned int index; 
    Timestamp_t time; 
};
struct PtpSample_t {
    Timestamp_t sysClk; 
    Timestamp_t phcClk; 
};
struct PtpSampleExt_t {
    Timestamp_t before; 
    Timestamp_t phcClk; 
    Timestamp_t after; 
};
struct PtpSamplePrecise_t {
    Timestamp_t phcClk; 
    Timestamp_t sysClk; 
    Timestamp_t monoClk; 
};
struct PtpPinPeriodDef_t {
    Timestamp_t period; 
    Timestamp_t width; 
    Timestamp_t phase; 
};
class BaseClock
{
  protected:
    clockid_t m_clkId; 
    bool m_isInit; 
    bool m_freq; 
    BaseClock(clockid_t clkId, bool freq) : m_clkId(clkId), m_isInit(true),
        m_freq(freq) {}
    BaseClock() : m_clkId(CLOCK_INVALID), m_isInit(false), m_freq(false) {}
  public:
    Timestamp_t getTime() const;
    bool setTime(const Timestamp_t &ts) const;
    bool offsetClock(int64_t offset) const;
    float_freq getFreq() const;
    bool setFreq(float_freq freq) const;
    bool setPhase(int64_t offset) const;
};
class SysClock : public BaseClock
{
  public:
    SysClock();
};
class PtpClock : public BaseClock
{
  private:
    int m_fd, m_ptpIndex;
    std::string m_device;
    bool init(const char *device, bool readonly);
 
  public:
    PtpClock() : m_fd(-1), m_ptpIndex(NO_SUCH_PTP) {}
    ~PtpClock();
    static bool isCharFile(const std::string &file);
    bool initUsingDevice(const std::string &device, bool readonly = false);
    bool initUsingIndex(int ptpIndex, bool readonly = false);
    bool isInit() const { return m_isInit; }
    clockid_t clkId() const { return m_clkId; }
    int getFd() const { return m_fd; }
    int fileno() const { return m_fd; }
    int ptpIndex() const { return m_ptpIndex; }
    const std::string &device() const { return m_device; }
    const char *device_c() const { return m_device.c_str(); }
    bool setTimeFromSys() const;
    bool setTimeToSys() const;
    bool fetchCaps(PtpCaps_t &caps) const;
    bool readPin(unsigned int index, PtpPin_t &pin) const;
    bool writePin(PtpPin_t &pin) const;
    bool ExternTSEbable(unsigned int index, uint8_t flags) const;
    bool ExternTSDisable(unsigned int index) const;
    bool MaskClearAll() const;
    bool MaskEnable(unsigned int index) const;
    bool readEvent(PtpEvent_t &event) const;
    bool readEvents(std::vector<PtpEvent_t> &events, size_t max = 0) const;
    bool setPinPeriod(unsigned int index, PtpPinPeriodDef_t times,
        uint8_t flags = 0) const;
    bool setPtpPpsEvent(bool enable) const;
    bool samplePtpSys(size_t count, std::vector<PtpSample_t> &samples) const;
    bool extSamplePtpSys(size_t count, std::vector<PtpSampleExt_t> &samples) const;
 
    bool preciseSamplePtpSys(PtpSamplePrecise_t &sample) const;
};
 
__PTPMGMT_NAMESPACE_END
#else /* __cplusplus */
#include "c/ptp.h"
#endif /* __cplusplus */
 
#endif /* __PTPMGMT_IF_H */