static int ntp_process(struct p *p, const double *t, int force)
{
double delay = 0;
double offset = 0;
double disp = MAXDISPERSE;
int ret;
ret = gettime();
if (ret)
return ret;
if (t) {
delay = (t[3] - t[0]) - (t[2] - t[1]);
offset = ((t[1] - t[0]) + (t[2] - t[3]))/2.0;
disp = (delay / 2) + (t[3] - t[0]) * PHI + LOG2D(PRECISION);
dprint("ntp_process: offset:%f, delay:%f, disp:%f, force:%i\n", offset, delay, disp, force);
}
/*if (fabs(offset) < disp)
return NTP_ERR_IGNORED;
if (offset > 0)
offset -= disp;
else
offset += disp;*/
return clock_filter(p, offset, delay, disp);
}
/*
* refclock_transmit - simulate the transmit procedure
*
* This routine implements the NTP transmit procedure for a reference
* clock. This provides a mechanism to call the driver at the NTP poll
* interval, as well as provides a reachability mechanism to detect a
* broken radio or other madness.
*/
void
refclock_transmit(
struct peer *peer /* peer structure pointer */
)
{
u_char clktype;
int unit;
clktype = peer->refclktype;
unit = peer->refclkunit;
peer->sent++;
get_systime(&peer->xmt);
/*
* This is a ripoff of the peer transmit routine, but
* specialized for reference clocks. We do a little less
* protocol here and call the driver-specific transmit routine.
*/
if (peer->burst == 0) {
u_char oreach;
#ifdef DEBUG
if (debug)
printf("refclock_transmit: at %ld %s\n",
current_time, stoa(&(peer->srcadr)));
#endif
/*
* Update reachability and poll variables like the
* network code.
*/
oreach = peer->reach;
peer->reach <<= 1;
peer->outdate = current_time;
if (!peer->reach) {
if (oreach) {
report_event(EVNT_UNREACH, peer);
peer->timereachable = current_time;
}
} else {
if (!(oreach & 0x07)) {
clock_filter(peer, 0., 0., MAXDISPERSE);
clock_select();
}
if (peer->flags & FLAG_BURST)
peer->burst = NSTAGE;
}
} else {
peer->burst--;
}
if (refclock_conf[clktype]->clock_poll != noentry)
(refclock_conf[clktype]->clock_poll)(unit, peer);
poll_update(peer, peer->hpoll);
}
/*
* refclock_receive - simulate the receive and packet procedures
*
* This routine simulates the NTP receive and packet procedures for a
* reference clock. This provides a mechanism in which the ordinary NTP
* filter, selection and combining algorithms can be used to suppress
* misbehaving radios and to mitigate between them when more than one is
* available for backup.
*/
void
refclock_receive(
struct peer *peer /* peer structure pointer */
)
{
struct refclockproc *pp;
#ifdef DEBUG
if (debug)
printf("refclock_receive: at %lu %s\n",
current_time, stoa(&peer->srcadr));
#endif
/*
* Do a little sanity dance and update the peer structure. Groom
* the median filter samples and give the data to the clock
* filter.
*/
pp = peer->procptr;
peer->leap = pp->leap;
if (peer->leap == LEAP_NOTINSYNC)
return;
peer->received++;
peer->timereceived = current_time;
if (!peer->reach) {
report_event(EVNT_REACH, peer);
peer->timereachable = current_time;
}
peer->reach |= 1;
peer->reftime = pp->lastref;
peer->org = pp->lastrec;
peer->rootdispersion = pp->disp;
get_systime(&peer->rec);
if (!refclock_sample(pp))
return;
clock_filter(peer, pp->offset, 0., pp->jitter);
record_peer_stats(&peer->srcadr, ctlpeerstatus(peer),
peer->offset, peer->delay, clock_phi * (current_time -
peer->epoch), peer->jitter);
if (cal_enable && last_offset < MINDISPERSE) {
#ifdef KERNEL_PLL
if (peer != sys_peer || pll_status & STA_PPSTIME)
#else
if (peer != sys_peer)
#endif /* KERNEL_PLL */
pp->fudgetime1 -= pp->offset * FUDGEFAC;
else
pp->fudgetime1 -= pp->fudgetime1 * FUDGEFAC;
}
}
/*
* refclock_receive - simulate the receive and packet procedures
*
* This routine simulates the NTP receive and packet procedures for a
* reference clock. This provides a mechanism in which the ordinary NTP
* filter, selection and combining algorithms can be used to suppress
* misbehaving radios and to mitigate between them when more than one is
* available for backup.
*/
void
refclock_receive(
struct peer *peer /* peer structure pointer */
)
{
struct refclockproc *pp;
#ifdef DEBUG
if (debug)
printf("refclock_receive: at %lu %s\n",
current_time, stoa(&peer->srcadr));
#endif
/*
* Do a little sanity dance and update the peer structure. Groom
* the median filter samples and give the data to the clock
* filter.
*/
pp = peer->procptr;
peer->leap = pp->leap;
if (peer->leap == LEAP_NOTINSYNC)
return;
peer->received++;
peer->timereceived = current_time;
if (!peer->reach) {
report_event(PEVNT_REACH, peer, NULL);
peer->timereachable = current_time;
}
peer->reach |= 1;
peer->reftime = pp->lastref;
peer->aorg = pp->lastrec;
peer->rootdisp = pp->disp;
get_systime(&peer->dst);
if (!refclock_sample(pp))
return;
clock_filter(peer, pp->offset, 0., pp->jitter);
if (cal_enable && fabs(last_offset) < sys_mindisp && sys_peer !=
NULL) {
if (sys_peer->refclktype == REFCLK_ATOM_PPS &&
peer->refclktype != REFCLK_ATOM_PPS)
pp->fudgetime1 -= pp->offset * FUDGEFAC;
}
}
