2019-07-08 07:47:48 +08:00
|
|
|
/**
|
|
|
|
* @file ts2phc_slave.c
|
|
|
|
* @brief Utility program to synchronize the PHC clock to external events
|
|
|
|
* @note Copyright (C) 2019 Balint Ferencz <fernya@sch.bme.hu>
|
|
|
|
* @note SPDX-License-Identifier: GPL-2.0+
|
|
|
|
*/
|
|
|
|
#include <errno.h>
|
|
|
|
#include <linux/ptp_clock.h>
|
|
|
|
#include <poll.h>
|
2020-07-23 05:56:36 +08:00
|
|
|
#include <stdbool.h>
|
2019-07-08 07:47:48 +08:00
|
|
|
#include <stdint.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/queue.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
|
|
#include "clockadj.h"
|
ts2phc: instantiate a full clock structure for every PHC master
This propagates the use of "struct ts2phc_private" all the way into the
master API, in preparation of a new use case that will be supported
soon: some PPS masters (to be precise, the "PHC" kind) instantiate a
struct clock which could be disciplined by ts2phc.
When a PHC A emits a pulse and another PHC B timestamps it, the offset
between their precise timestamps can be used to synchronize either one
of them. So far in ts2phc, only the slave PHC (the one using extts) has
been synchronized to the master (the one using perout).
This is partly because there is no proper kernel API to report the
precise timestamp of a perout pulse. We only have the periodic API, and
that doesn't report precise timestamps either; we just use vague
approximations of what the PPS master PHC's time was, based on reading
that PHC immediately after a slave extts event was received by the
application. While this is far from ideal, it does work, and does allow
PHC A to be synchronized to B.
This is particularly useful with the yet-to-be-introduced "automatic"
mode of ts2phc (similar to '-a' of phc2sys), and the PPS distribution
tree is fixed in hardware (as opposed to port states, which in
"automatic" mode are dynamic, as the name suggests).
Signed-off-by: Vladimir Oltean <olteanv@gmail.com>
2020-07-28 07:52:16 +08:00
|
|
|
#include "config.h"
|
2019-07-08 07:47:48 +08:00
|
|
|
#include "missing.h"
|
|
|
|
#include "phc.h"
|
|
|
|
#include "print.h"
|
|
|
|
#include "servo.h"
|
2020-06-29 03:02:38 +08:00
|
|
|
#include "ts2phc.h"
|
2019-07-08 07:47:48 +08:00
|
|
|
#include "util.h"
|
|
|
|
|
|
|
|
#define NS_PER_SEC 1000000000LL
|
|
|
|
#define SAMPLE_WEIGHT 1.0
|
|
|
|
|
|
|
|
struct ts2phc_slave {
|
|
|
|
char *name;
|
|
|
|
STAILQ_ENTRY(ts2phc_slave) list;
|
|
|
|
struct ptp_pin_desc pin_desc;
|
|
|
|
unsigned int polarity;
|
|
|
|
int32_t correction;
|
|
|
|
uint32_t ignore_lower;
|
|
|
|
uint32_t ignore_upper;
|
2020-07-28 07:51:28 +08:00
|
|
|
struct clock *clock;
|
2019-07-08 07:47:48 +08:00
|
|
|
int no_adj;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ts2phc_slave_array {
|
|
|
|
struct ts2phc_slave **slave;
|
|
|
|
struct pollfd *pfd;
|
2020-06-29 03:02:38 +08:00
|
|
|
};
|
2019-07-08 07:47:48 +08:00
|
|
|
|
|
|
|
struct ts2phc_source_timestamp {
|
|
|
|
struct timespec ts;
|
2020-07-23 05:56:36 +08:00
|
|
|
bool valid;
|
2019-07-08 07:47:48 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
enum extts_result {
|
|
|
|
EXTTS_ERROR = -1,
|
|
|
|
EXTTS_OK = 0,
|
|
|
|
EXTTS_IGNORE = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
static enum extts_result ts2phc_slave_offset(struct ts2phc_slave *slave,
|
|
|
|
struct ts2phc_source_timestamp ts,
|
|
|
|
int64_t *offset,
|
|
|
|
uint64_t *local_ts);
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
static int ts2phc_slave_array_create(struct ts2phc_private *priv)
|
2019-07-08 07:47:48 +08:00
|
|
|
{
|
2020-06-29 03:02:38 +08:00
|
|
|
struct ts2phc_slave_array *polling_array;
|
2019-07-08 07:47:48 +08:00
|
|
|
struct ts2phc_slave *slave;
|
|
|
|
unsigned int i;
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
polling_array = malloc(sizeof(*polling_array));
|
|
|
|
if (!polling_array) {
|
|
|
|
pr_err("low memory");
|
|
|
|
return -1;
|
2019-07-08 07:47:48 +08:00
|
|
|
}
|
2020-06-29 03:02:38 +08:00
|
|
|
|
|
|
|
polling_array->slave = malloc(priv->n_slaves *
|
|
|
|
sizeof(*polling_array->slave));
|
|
|
|
if (!polling_array->slave) {
|
2019-07-08 07:47:48 +08:00
|
|
|
pr_err("low memory");
|
|
|
|
return -1;
|
|
|
|
}
|
2020-06-29 03:02:38 +08:00
|
|
|
polling_array->pfd = malloc(priv->n_slaves *
|
|
|
|
sizeof(*polling_array->pfd));
|
|
|
|
if (!polling_array->pfd) {
|
2019-07-08 07:47:48 +08:00
|
|
|
pr_err("low memory");
|
2020-06-29 03:02:38 +08:00
|
|
|
free(polling_array->slave);
|
|
|
|
polling_array->slave = NULL;
|
2019-07-08 07:47:48 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
i = 0;
|
2020-06-29 03:02:38 +08:00
|
|
|
STAILQ_FOREACH(slave, &priv->slaves, list) {
|
|
|
|
polling_array->slave[i] = slave;
|
2019-07-08 07:47:48 +08:00
|
|
|
i++;
|
|
|
|
}
|
2020-06-29 03:02:38 +08:00
|
|
|
for (i = 0; i < priv->n_slaves; i++) {
|
2020-07-28 07:51:28 +08:00
|
|
|
struct ts2phc_slave *slave = polling_array->slave[i];
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
polling_array->pfd[i].events = POLLIN | POLLPRI;
|
2020-07-28 07:51:28 +08:00
|
|
|
polling_array->pfd[i].fd = CLOCKID_TO_FD(slave->clock->clkid);
|
2019-07-08 07:47:48 +08:00
|
|
|
}
|
2020-06-29 03:02:38 +08:00
|
|
|
|
|
|
|
priv->polling_array = polling_array;
|
|
|
|
|
2019-07-08 07:47:48 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
static void ts2phc_slave_array_destroy(struct ts2phc_private *priv)
|
2019-07-08 07:47:48 +08:00
|
|
|
{
|
2020-06-29 03:02:38 +08:00
|
|
|
struct ts2phc_slave_array *polling_array = priv->polling_array;
|
|
|
|
|
|
|
|
free(polling_array->slave);
|
|
|
|
free(polling_array->pfd);
|
2020-07-28 07:51:28 +08:00
|
|
|
free(polling_array);
|
|
|
|
priv->polling_array = NULL;
|
2019-07-08 07:47:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ts2phc_slave_clear_fifo(struct ts2phc_slave *slave)
|
|
|
|
{
|
|
|
|
struct pollfd pfd = {
|
|
|
|
.events = POLLIN | POLLPRI,
|
2020-07-28 07:51:28 +08:00
|
|
|
.fd = CLOCKID_TO_FD(slave->clock->clkid),
|
2019-07-08 07:47:48 +08:00
|
|
|
};
|
|
|
|
struct ptp_extts_event event;
|
|
|
|
int cnt, size;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
cnt = poll(&pfd, 1, 0);
|
|
|
|
if (cnt < 0) {
|
|
|
|
if (EINTR == errno) {
|
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
pr_emerg("poll failed");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else if (!cnt) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
size = read(pfd.fd, &event, sizeof(event));
|
|
|
|
if (size != sizeof(event)) {
|
|
|
|
pr_err("read failed");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
pr_debug("%s SKIP extts index %u at %lld.%09u",
|
|
|
|
slave->name, event.index, event.t.sec, event.t.nsec);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
static struct ts2phc_slave *ts2phc_slave_create(struct ts2phc_private *priv,
|
|
|
|
const char *device)
|
2019-07-08 07:47:48 +08:00
|
|
|
{
|
|
|
|
struct ptp_extts_request extts;
|
|
|
|
struct ts2phc_slave *slave;
|
2020-07-28 07:51:28 +08:00
|
|
|
int err, pulsewidth;
|
2019-07-08 07:47:48 +08:00
|
|
|
|
|
|
|
slave = calloc(1, sizeof(*slave));
|
|
|
|
if (!slave) {
|
|
|
|
pr_err("low memory");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
slave->name = strdup(device);
|
|
|
|
if (!slave->name) {
|
|
|
|
pr_err("low memory");
|
|
|
|
free(slave);
|
|
|
|
return NULL;
|
|
|
|
}
|
2020-06-29 03:02:38 +08:00
|
|
|
slave->pin_desc.index = config_get_int(priv->cfg, device,
|
|
|
|
"ts2phc.pin_index");
|
2019-07-08 07:47:48 +08:00
|
|
|
slave->pin_desc.func = PTP_PF_EXTTS;
|
2020-06-29 03:02:38 +08:00
|
|
|
slave->pin_desc.chan = config_get_int(priv->cfg, device,
|
|
|
|
"ts2phc.channel");
|
|
|
|
slave->polarity = config_get_int(priv->cfg, device,
|
|
|
|
"ts2phc.extts_polarity");
|
|
|
|
slave->correction = config_get_int(priv->cfg, device,
|
|
|
|
"ts2phc.extts_correction");
|
|
|
|
|
|
|
|
pulsewidth = config_get_int(priv->cfg, device,
|
|
|
|
"ts2phc.pulsewidth");
|
2019-07-08 07:47:48 +08:00
|
|
|
pulsewidth /= 2;
|
|
|
|
slave->ignore_upper = 1000000000 - pulsewidth;
|
|
|
|
slave->ignore_lower = pulsewidth;
|
|
|
|
|
2020-07-28 07:51:28 +08:00
|
|
|
slave->clock = clock_add(priv, device);
|
|
|
|
if (!slave->clock) {
|
2019-07-08 07:47:48 +08:00
|
|
|
pr_err("failed to open clock");
|
|
|
|
goto no_posix_clock;
|
|
|
|
}
|
|
|
|
|
2020-07-28 07:51:28 +08:00
|
|
|
pr_debug("PHC slave %s has ptp index %d", device,
|
|
|
|
slave->clock->phc_index);
|
2019-07-08 07:47:48 +08:00
|
|
|
|
2020-07-28 07:51:28 +08:00
|
|
|
if (phc_number_pins(slave->clock->clkid) > 0) {
|
|
|
|
err = phc_pin_setfunc(slave->clock->clkid, &slave->pin_desc);
|
2019-07-08 07:47:48 +08:00
|
|
|
if (err < 0) {
|
|
|
|
pr_err("PTP_PIN_SETFUNC request failed");
|
|
|
|
goto no_pin_func;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable external time stamping, and then read out any stale
|
|
|
|
* time stamps.
|
|
|
|
*/
|
|
|
|
memset(&extts, 0, sizeof(extts));
|
|
|
|
extts.index = slave->pin_desc.chan;
|
|
|
|
extts.flags = 0;
|
2020-07-28 07:51:28 +08:00
|
|
|
if (ioctl(CLOCKID_TO_FD(slave->clock->clkid), PTP_EXTTS_REQUEST2,
|
|
|
|
&extts)) {
|
2019-07-08 07:47:48 +08:00
|
|
|
pr_err(PTP_EXTTS_REQUEST_FAILED);
|
|
|
|
}
|
|
|
|
if (ts2phc_slave_clear_fifo(slave)) {
|
|
|
|
goto no_ext_ts;
|
|
|
|
}
|
|
|
|
|
|
|
|
return slave;
|
|
|
|
no_ext_ts:
|
|
|
|
no_pin_func:
|
2020-07-28 07:51:28 +08:00
|
|
|
clock_destroy(slave->clock);
|
2019-07-08 07:47:48 +08:00
|
|
|
no_posix_clock:
|
|
|
|
free(slave->name);
|
|
|
|
free(slave);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ts2phc_slave_destroy(struct ts2phc_slave *slave)
|
|
|
|
{
|
|
|
|
struct ptp_extts_request extts;
|
|
|
|
|
|
|
|
memset(&extts, 0, sizeof(extts));
|
|
|
|
extts.index = slave->pin_desc.chan;
|
|
|
|
extts.flags = 0;
|
2020-07-28 07:51:28 +08:00
|
|
|
if (ioctl(CLOCKID_TO_FD(slave->clock->clkid), PTP_EXTTS_REQUEST2,
|
|
|
|
&extts)) {
|
2019-07-08 07:47:48 +08:00
|
|
|
pr_err(PTP_EXTTS_REQUEST_FAILED);
|
|
|
|
}
|
2020-07-28 07:51:28 +08:00
|
|
|
clock_destroy(slave->clock);
|
2019-07-08 07:47:48 +08:00
|
|
|
free(slave->name);
|
|
|
|
free(slave);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ts2phc_slave_event(struct ts2phc_slave *slave,
|
|
|
|
struct ts2phc_source_timestamp source_ts)
|
|
|
|
{
|
|
|
|
enum extts_result result;
|
|
|
|
uint64_t extts_ts;
|
|
|
|
int64_t offset;
|
|
|
|
double adj;
|
|
|
|
|
|
|
|
result = ts2phc_slave_offset(slave, source_ts, &offset, &extts_ts);
|
|
|
|
switch (result) {
|
|
|
|
case EXTTS_ERROR:
|
|
|
|
return -1;
|
|
|
|
case EXTTS_OK:
|
|
|
|
break;
|
|
|
|
case EXTTS_IGNORE:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (slave->no_adj) {
|
|
|
|
pr_info("%s master offset %10" PRId64, slave->name, offset);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-07-28 07:51:28 +08:00
|
|
|
adj = servo_sample(slave->clock->servo, offset, extts_ts,
|
|
|
|
SAMPLE_WEIGHT, &slave->clock->servo_state);
|
2019-07-08 07:47:48 +08:00
|
|
|
|
|
|
|
pr_debug("%s master offset %10" PRId64 " s%d freq %+7.0f",
|
2020-07-28 07:51:28 +08:00
|
|
|
slave->name, offset, slave->clock->servo_state, adj);
|
2019-07-08 07:47:48 +08:00
|
|
|
|
2020-07-28 07:51:28 +08:00
|
|
|
switch (slave->clock->servo_state) {
|
2019-07-08 07:47:48 +08:00
|
|
|
case SERVO_UNLOCKED:
|
|
|
|
break;
|
|
|
|
case SERVO_JUMP:
|
2020-07-28 07:51:28 +08:00
|
|
|
clockadj_set_freq(slave->clock->clkid, -adj);
|
|
|
|
clockadj_step(slave->clock->clkid, -offset);
|
2019-07-08 07:47:48 +08:00
|
|
|
break;
|
|
|
|
case SERVO_LOCKED:
|
|
|
|
case SERVO_LOCKED_STABLE:
|
2020-07-28 07:51:28 +08:00
|
|
|
clockadj_set_freq(slave->clock->clkid, -adj);
|
2019-07-08 07:47:48 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum extts_result ts2phc_slave_offset(struct ts2phc_slave *slave,
|
|
|
|
struct ts2phc_source_timestamp src,
|
|
|
|
int64_t *offset,
|
|
|
|
uint64_t *local_ts)
|
|
|
|
{
|
|
|
|
struct timespec source_ts = src.ts;
|
|
|
|
struct ptp_extts_event event;
|
|
|
|
uint64_t event_ns, source_ns;
|
|
|
|
int cnt;
|
|
|
|
|
2020-07-28 07:51:28 +08:00
|
|
|
cnt = read(CLOCKID_TO_FD(slave->clock->clkid), &event, sizeof(event));
|
2019-07-08 07:47:48 +08:00
|
|
|
if (cnt != sizeof(event)) {
|
|
|
|
pr_err("read extts event failed: %m");
|
|
|
|
return EXTTS_ERROR;
|
|
|
|
}
|
|
|
|
if (event.index != slave->pin_desc.chan) {
|
|
|
|
pr_err("extts on unexpected channel");
|
|
|
|
return EXTTS_ERROR;
|
|
|
|
}
|
|
|
|
event_ns = event.t.sec * NS_PER_SEC;
|
|
|
|
event_ns += event.t.nsec;
|
|
|
|
|
|
|
|
if (slave->polarity == (PTP_RISING_EDGE | PTP_FALLING_EDGE) &&
|
|
|
|
source_ts.tv_nsec > slave->ignore_lower &&
|
|
|
|
source_ts.tv_nsec < slave->ignore_upper) {
|
|
|
|
|
|
|
|
pr_debug("%s SKIP extts index %u at %lld.%09u src %" PRIi64 ".%ld",
|
|
|
|
slave->name, event.index, event.t.sec, event.t.nsec,
|
|
|
|
(int64_t) source_ts.tv_sec, source_ts.tv_nsec);
|
|
|
|
|
|
|
|
return EXTTS_IGNORE;
|
|
|
|
}
|
|
|
|
if (source_ts.tv_nsec > 500000000) {
|
|
|
|
source_ts.tv_sec++;
|
|
|
|
}
|
|
|
|
source_ns = source_ts.tv_sec * NS_PER_SEC;
|
|
|
|
*offset = event_ns + slave->correction - source_ns;
|
|
|
|
*local_ts = event_ns + slave->correction;
|
|
|
|
|
|
|
|
pr_debug("%s extts index %u at %lld.%09u corr %d src %" PRIi64
|
|
|
|
".%ld diff %" PRId64,
|
|
|
|
slave->name, event.index, event.t.sec, event.t.nsec,
|
|
|
|
slave->correction,
|
|
|
|
(int64_t) source_ts.tv_sec, source_ts.tv_nsec, *offset);
|
|
|
|
|
|
|
|
return EXTTS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* public methods */
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
int ts2phc_slave_add(struct ts2phc_private *priv, const char *name)
|
2019-07-08 07:47:48 +08:00
|
|
|
{
|
|
|
|
struct ts2phc_slave *slave;
|
|
|
|
|
|
|
|
/* Create each interface only once. */
|
2020-06-29 03:02:38 +08:00
|
|
|
STAILQ_FOREACH(slave, &priv->slaves, list) {
|
2019-07-08 07:47:48 +08:00
|
|
|
if (0 == strcmp(name, slave->name)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
2020-06-29 03:02:38 +08:00
|
|
|
slave = ts2phc_slave_create(priv, name);
|
2019-07-08 07:47:48 +08:00
|
|
|
if (!slave) {
|
|
|
|
pr_err("failed to create slave");
|
|
|
|
return -1;
|
|
|
|
}
|
2020-06-29 03:02:38 +08:00
|
|
|
STAILQ_INSERT_TAIL(&priv->slaves, slave, list);
|
|
|
|
priv->n_slaves++;
|
2019-07-08 07:47:48 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
int ts2phc_slave_arm(struct ts2phc_private *priv)
|
2019-07-08 07:47:48 +08:00
|
|
|
{
|
|
|
|
struct ptp_extts_request extts;
|
|
|
|
struct ts2phc_slave *slave;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
memset(&extts, 0, sizeof(extts));
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
STAILQ_FOREACH(slave, &priv->slaves, list) {
|
2019-07-08 07:47:48 +08:00
|
|
|
extts.index = slave->pin_desc.chan;
|
|
|
|
extts.flags = slave->polarity | PTP_ENABLE_FEATURE;
|
2020-07-28 07:51:28 +08:00
|
|
|
err = ioctl(CLOCKID_TO_FD(slave->clock->clkid),
|
|
|
|
PTP_EXTTS_REQUEST2, &extts);
|
2019-07-08 07:47:48 +08:00
|
|
|
if (err < 0) {
|
|
|
|
pr_err(PTP_EXTTS_REQUEST_FAILED);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
int ts2phc_slaves_init(struct ts2phc_private *priv)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = ts2phc_slave_array_create(priv);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return ts2phc_slave_arm(priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ts2phc_slave_cleanup(struct ts2phc_private *priv)
|
2019-07-08 07:47:48 +08:00
|
|
|
{
|
|
|
|
struct ts2phc_slave *slave;
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
ts2phc_slave_array_destroy(priv);
|
2019-07-08 07:47:48 +08:00
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
while ((slave = STAILQ_FIRST(&priv->slaves))) {
|
|
|
|
STAILQ_REMOVE_HEAD(&priv->slaves, list);
|
2019-07-08 07:47:48 +08:00
|
|
|
ts2phc_slave_destroy(slave);
|
2020-06-29 03:02:38 +08:00
|
|
|
priv->n_slaves--;
|
2019-07-08 07:47:48 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
int ts2phc_slave_poll(struct ts2phc_private *priv)
|
2019-07-08 07:47:48 +08:00
|
|
|
{
|
2020-06-29 03:02:38 +08:00
|
|
|
struct ts2phc_slave_array *polling_array = priv->polling_array;
|
2019-07-08 07:47:48 +08:00
|
|
|
struct ts2phc_source_timestamp source_ts;
|
|
|
|
unsigned int i;
|
2020-07-23 05:56:36 +08:00
|
|
|
int cnt, err;
|
2019-07-08 07:47:48 +08:00
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
cnt = poll(polling_array->pfd, priv->n_slaves, 2000);
|
2019-07-08 07:47:48 +08:00
|
|
|
if (cnt < 0) {
|
|
|
|
if (EINTR == errno) {
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
pr_emerg("poll failed");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} else if (!cnt) {
|
|
|
|
pr_debug("poll returns zero, no events");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
err = ts2phc_master_getppstime(priv->master, &source_ts.ts);
|
2020-07-23 05:56:36 +08:00
|
|
|
source_ts.valid = err ? false : true;
|
2019-07-08 07:47:48 +08:00
|
|
|
|
2020-07-28 07:51:28 +08:00
|
|
|
if (!source_ts.valid) {
|
|
|
|
pr_debug("ignoring invalid master time stamp");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-06-29 03:02:38 +08:00
|
|
|
for (i = 0; i < priv->n_slaves; i++) {
|
|
|
|
if (polling_array->pfd[i].revents & (POLLIN|POLLPRI)) {
|
|
|
|
ts2phc_slave_event(polling_array->slave[i], source_ts);
|
2019-07-08 07:47:48 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|