gptpipc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Texas Instruments Incorporated
 * Copyright (c) 2023 Excelfore Corporation (https://excelfore.com)
 *
 * All rights reserved not granted herein.
 * Limited License.
 *
 * Texas Instruments Incorporated grants a world-wide, royalty-free,
 * non-exclusive license under copyrights and patents it now or hereafter
 * owns or controls to make, have made, use, import, offer to sell and sell ("Utilize")
 * this software subject to the terms herein. With respect to the foregoing patent
 * license, such license is granted solely to the extent that any such patent is necessary
 * to Utilize the software alone. The patent license shall not apply to any combinations which
 * include this software, other than combinations with devices manufactured by or for TI ("TI Devices").
 * No hardware patent is licensed hereunder.
 *
 * Redistributions must preserve existing copyright notices and reproduce this license (including the
 * above copyright notice and the disclaimer and (if applicable) source code license limitations below)
 * in the documentation and/or other materials provided with the distribution
 *
 * Redistribution and use in binary form, without modification, are permitted provided that the following
 * conditions are met:
 *
 * * No reverse engineering, decompilation, or disassembly of this software is permitted with respect to any
 * software provided in binary form.
 * * any redistribution and use are licensed by TI for use only with TI Devices.
 * * Nothing shall obligate TI to provide you with source code for the software licensed and provided to you in object code.
 *
 * If software source code is provided to you, modification and redistribution of the source code are permitted
 * provided that the following conditions are met:
 *
 * * any redistribution and use of the source code, including any resulting derivative works, are licensed by
 * TI for use only with TI Devices.
 * * any redistribution and use of any object code compiled from the source code and any resulting derivative
 * works, are licensed by TI for use only with TI Devices.
 *
 * Neither the name of Texas Instruments Incorporated nor the names of its suppliers may be used to endorse or
 * promote products derived from this software without specific prior written permission.
 *
 * DISCLAIMER.
 *
 * THIS SOFTWARE IS PROVIDED BY TI AND TI"S LICENSORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL TI AND TI"S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __GPTPIPC_H_
#define __GPTPIPC_H_

#include "gptpbasetypes.h"
#include <stdint.h>

#define GPTP2D_IPC_CB_SOCKET_NODE "/tmp/gptp2d_ipc"


typedef enum {
    GPTPIPC_CMD_NOP=0,
    GPTPIPC_CMD_REQ_NDPORT_INFO,
    GPTPIPC_CMD_REQ_GPORT_INFO,
    GPTPIPC_CMD_REQ_CLOCK_INFO,
    GPTPIPC_CMD_ACTIVE_DOMAINT_SWITCH,
    GPTPIPC_CMD_RUN_EXT_SCRIPT,
    GPTPIPC_CMD_TSN_SCHEDULE_CONTROL,
    GPTPIPC_CMD_REQ_STAT_INFO,
    GPTPIPC_CMD_REQ_STAT_INFO_RESET,
    GPTPIPC_CMD_REG_ABNORMAL_EVENT,
    GPTPIPC_CMD_DISCONNECT,
} gptp_ipc_command_t;

#define GPTPIPC_EXT_SCRIPT "gptpipc_extscript"

typedef enum {
    GPTPIPC_EVENT_CLOCK_NETDEV_DOWN = 0,
    GPTPIPC_EVENT_CLOCK_NETDEV_UP,
    GPTPIPC_EVENT_CLOCK_PHASE_UPDATE,
    GPTPIPC_EVENT_CLOCK_FREQ_UPDATE,
    GPTPIPC_EVENT_CLOCK_GM_SYNCED,
    GPTPIPC_EVENT_CLOCK_GM_UNSYNCED,
    GPTPIPC_EVENT_CLOCK_GM_CHANGE,
    GPTPIPC_EVENT_PORT_AS_CAPABLE_DOWN,
    GPTPIPC_EVENT_PORT_AS_CAPABLE_UP,
    GPTPIPC_EVENT_CLOCK_ACTIVE_DOMAIN,
    GPTPIPC_EVENT_CLOCK_TIMELEAP_FUTURE,
    GPTPIPC_EVENT_CLOCK_TIMELEAP_PAST,
} gptpipc_event_t;

#define GPTPIPC_EVENT_CLOCK_FLAG_NETDEV_DOWN (1<<GPTPIPC_EVENT_CLOCK_NETDEV_DOWN)
#define GPTPIPC_EVENT_CLOCK_FLAG_NETDEV_UP (1<<GPTPIPC_EVENT_CLOCK_NETDEV_UP)
#define GPTPIPC_EVENT_CLOCK_FLAG_PHASE_UPDATE (1<<GPTPIPC_EVENT_CLOCK_PHASE_UPDATE)
#define GPTPIPC_EVENT_CLOCK_FLAG_FREQ_UPDATE (1<<GPTPIPC_EVENT_CLOCK_FREQ_UPDATE)
#define GPTPIPC_EVENT_CLOCK_FLAG_GM_SYNCED (1<<GPTPIPC_EVENT_CLOCK_GM_SYNCED)
#define GPTPIPC_EVENT_CLOCK_FLAG_GM_UNSYNCED (1<<GPTPIPC_EVENT_CLOCK_GM_UNSYNCED)
#define GPTPIPC_EVENT_CLOCK_FLAG_GM_CHANGE (1<<GPTPIPC_EVENT_CLOCK_GM_CHANGE)
#define GPTPIPC_EVENT_PORT_FLAG_AS_CAPABLE_DOWN (1<<GPTPIPC_EVENT_PORT_AS_CAPABLE_DOWN)
#define GPTPIPC_EVENT_PORT_FLAG_AS_CAPABLE_UP (1<<GPTPIPC_EVENT_PORT_AS_CAPABLE_UP)
#define GPTPIPC_EVENT_CLOCK_FLAG_ACTIVE_DOMAIN (1<<GPTPIPC_EVENT_CLOCK_ACTIVE_DOMAIN)
#define GPTPIPC_EVENT_CLOCK_FLAG_TIMELEAP_FUTURE (1<<GPTPIPC_EVENT_CLOCK_TIMELEAP_FUTURE)
#define GPTPIPC_EVENT_CLOCK_FLAG_TIMELEAP_PAST (1<<GPTPIPC_EVENT_CLOCK_TIMELEAP_PAST)

typedef struct gptpipc_notice_data {
    uint32_t event_flags;
    int32_t domainNumber;
    int32_t domainIndex;
    int32_t portIndex;
    ClockIdentity gmIdentity;
    int64_t lastGmPhaseChange_nsec;
    uint16_t gmTimeBaseIndicator;
    uint8_t lastGmFreqChangePk[sizeof(double)];
} __attribute__((packed)) gptpipc_notice_data_t;

typedef struct gptpipc_client_req_abnormal {
    int32_t subcmd;
    int32_t msgtype;
    int32_t eventtype;
    float eventrate;
    int32_t repeat;
    int32_t interval;
    int32_t eventpara;
} __attribute__((packed)) gptpipc_client_req_abnormal_t;

typedef struct gptpipc_client_req_data {
    gptp_ipc_command_t cmd;
    // if domainNumber==-1, use domainIndex; if domainIndex==-1, use domainNumber
    // if domainNumber==-1 and domainIndex==-1, all domains info is requested
    int32_t domainNumber;
    int32_t domainIndex;
    // for ndprot, if portIndex=0, all ports info is requested. domain is always 0
    // for gprot, if portIndex=0, all ports info for a specific domain or all domains
    int32_t portIndex;
    union {
        gptpipc_client_req_abnormal_t abnd;
    }u;
} __attribute__((packed)) gptpipc_client_req_data_t;

#define GPTPIPC_MAX_NETDEV_NAME 16
#define GPTPIPC_MAX_PTPDEV_NAME 32
typedef struct gptpipc_data_netlink {
    uint32_t speed;
    uint32_t duplex;
    ClockIdentity portid;
    uint8_t up;
    char devname[GPTPIPC_MAX_NETDEV_NAME];
    char ptpdev[GPTPIPC_MAX_PTPDEV_NAME];
} __attribute__((packed)) gptpipc_data_netlink_t;

typedef struct gptpipc_ndport_data {
    gptpipc_data_netlink_t nlstatus;
} __attribute__((packed)) gptpipc_ndport_data_t;

typedef struct gptpipc_gport_data {
    int32_t domainNumber;
    int32_t portIndex;
    ClockIdentity gmClockId;
    uint8_t asCapable;
    uint8_t portOper;
    uint8_t gmStable;
    uint8_t selectedState;
    uint64_t pDelay;
    double pDelayRateRatio;
    uint8_t annPathSequenceCount;
    ClockIdentity annPathSequence[MAX_PATH_TRACE_N];
} __attribute__((packed)) gptpipc_gport_data_t;

typedef struct gptpipc_clock_data{
    int32_t domainNumber;
    int32_t portIndex;
    int64_t lastGmPhaseChange_nsec;
    ClockIdentity clockId;
    ClockIdentity gmClockId;
    uint64_t lastSyncReceiptTime_nsec;
    uint64_t lastSyncReceiptLocalTime_nsec;
    int32_t adjppb;
    uint16_t gmTimeBaseIndicator;
    uint16_t lastSyncSeqID;
    uint8_t gmsync;
    uint8_t domainActive;
    uint8_t lastGmFreqChangePk[sizeof(double)];
} __attribute__((packed)) gptpipc_clock_data_t;

typedef struct gptpipc_statistics_system{
    int32_t portIndex;
    uint32_t pdelay_req_send;
    uint32_t pdelay_resp_rec;
    uint32_t pdelay_resp_rec_valid;
    uint32_t pdelay_resp_fup_rec;
    uint32_t pdelay_resp_fup_rec_valid;
    uint32_t pdelay_req_rec;
    uint32_t pdelay_req_rec_valid;
    uint32_t pdelay_resp_send;
    uint32_t pdelay_resp_fup_send;
} __attribute__((packed)) gptpipc_statistics_system_t;

typedef struct gptpipc_statistics_tas{
    int32_t domainNumber;
    int32_t portIndex;
    uint32_t sync_send;
    uint32_t sync_fup_send;
    uint32_t sync_rec;
    uint32_t sync_rec_valid;
    uint32_t sync_fup_rec;
    uint32_t sync_fup_rec_valid;
    uint32_t announce_send;
    uint32_t announce_rec;
    uint32_t announce_rec_valid;
    uint32_t signal_msg_interval_send;
    uint32_t signal_gptp_capable_send;
    uint32_t signal_rec;
    uint32_t signal_msg_interval_rec;
    uint32_t signal_gptp_capable_rec;
} __attribute__((packed)) gptpipc_statistics_tas_t;

typedef enum {
    GPTPIPC_GPTPD_NOTICE = 0,
    GPTPIPC_GPTPD_NDPORTD,
    GPTPIPC_GPTPD_GPORTD,
    GPTPIPC_GPTPD_CLOCKD,
    GPTPIPC_GPTPD_STATSD,
    GPTPIPC_GPTPD_STATTD,
} gptpd_data_type_t;

typedef struct gptpipc_gptpd_data{
    gptpd_data_type_t dtype;
    union {
        gptpipc_notice_data_t notice;
        gptpipc_ndport_data_t ndportd;
        gptpipc_gport_data_t gportd;
        gptpipc_clock_data_t clockd;
        gptpipc_statistics_system_t statsd;
        gptpipc_statistics_tas_t stattd;
    }u;
} __attribute__((packed)) gptpipc_gptpd_data_t;

typedef int (*gptpipc_cb_t)(gptpipc_gptpd_data_t *ipcrd, void *cb_data);

typedef struct gptpipc_thread_data{
    CB_THREAD_T ipcthread;
    int ipcstop;
    char *pname;
    int query_interval; //in msec
    bool printdata;
    int ipcfd;
    gptpipc_cb_t cb;
    void *cbdata;
    int udpport;
    char *udpaddr;
} gptpipc_thread_data_t;

int send_ipc_request(int ipcfd, int domainNumber, int portIndex, gptp_ipc_command_t cmd);

int gptpipc_init(gptpipc_thread_data_t *ipctd, int wait_toutsec);

int gptpipc_close(gptpipc_thread_data_t *ipctd);

#endif