Skip to content

P
PPSi
Commit 48b25f3c authored by Alessandro Rubini's avatar Alessandro Rubini
Browse files
Options

white rabbit: use wr_operations, not aliases 

This is a massive change, but one that we needed since time 0.
Aliases were a bad choice, while use of an operation structure shows
better the symmetry between the two white rabbit implementations.
But, mainly, maintainance is easier.

I really needed this because I need to change one prototype, to
add support for wrpc acting as grandmaster.

There are still some asymmetries to be fixed, but the thing is
acceptable at this point. While I was at it, I removed some
WR_DSPORT(ppi) using a local pointer "wrp".

The code after this commit is shorter by a dozen bytes or so,
both on wrpc and wrs.
Signed-off-by: Alessandro Rubini's avatarAlessandro Rubini <rubini@gnudd.com>
parent b71150bf
Hide whitespace changes
Inline Side-by-side
Showing with 198 additions and 188 deletions
arch-wrpc/wrc_ptp_ppsi.c
View file @ 48b25f3c
......@@ -27,15 +27,39 @@ extern int32_t cal_phase_transition;
int ptp_mode = WRC_MODE_UNKNOWN;
static int ptp_enabled = 0, ptp_forced_stop = 0;
static struct wr_operations wrpc_wr_operations = {
.locking_enable = wrpc_spll_locking_enable,
.locking_poll = wrpc_spll_locking_poll,
.locking_disable = wrpc_spll_locking_disable,
.enable_ptracker = wrpc_spll_enable_ptracker,
.adjust_in_progress = wrpc_adjust_in_progress,
.adjust_counters = wrpc_adjust_counters,
.adjust_phase = wrpc_adjust_phase,
.read_calib_data = wrpc_read_calibration_data,
.calib_disable = wrpc_calibrating_disable,
.calib_enable = wrpc_calibrating_enable,
.calib_poll = wrpc_calibrating_poll,
.calib_pattern_enable = wrpc_calibration_pattern_enable,
.calib_pattern_disable = wrpc_calibration_pattern_disable,
};
/*ppi fields*/
static DSDefault defaultDS;
static DSCurrent currentDS;
static DSParent parentDS;
static struct wr_dsport wr_dsport;
static DSPort portDS = {.ext_dsport = &wr_dsport};
static DSTimeProperties timePropertiesDS;
static struct pp_servo servo;
static struct wr_dsport wr_dsport = {
.ops = &wrpc_wr_operations,
};
static DSPort portDS = {
.ext_dsport = &wr_dsport
};
static int delay_ms = PP_DEFAULT_NEXT_DELAY_MS;
static int start_tics = 0;
static int last_link_up = 0;
......
arch-wrpc/wrpc-calibration.c
View file @ 48b25f3c
......@@ -12,7 +12,7 @@
#include "wrpc.h"
#include "../proto-ext-whiterabbit/wr-constants.h"
static int wrpc_read_calibration_data(struct pp_instance *ppi,
int wrpc_read_calibration_data(struct pp_instance *ppi,
uint32_t *deltaTx, uint32_t *deltaRx, int32_t *fix_alpha,
int32_t *clock_period)
{
......@@ -95,25 +95,3 @@ int wrpc_calibration_pattern_disable(struct pp_instance *ppi)
ep_cal_pattern_disable();
return WR_HW_CALIB_OK;
}
int wr_calibrating_disable(struct pp_instance *ppi, int txrx)
__attribute__((alias("wrpc_calibrating_disable")));
int wr_calibrating_enable(struct pp_instance *ppi, int txrx)
__attribute__((alias("wrpc_calibrating_enable")));
int wr_calibrating_poll(struct pp_instance *ppi, int txrx, uint32_t *delta)
__attribute__((alias("wrpc_calibrating_poll")));
int wr_calibration_pattern_enable(struct pp_instance *ppi,
unsigned int calibrationPeriod, unsigned int calibrationPattern,
unsigned int calibrationPatternLen)
__attribute__((alias("wrpc_calibration_pattern_enable")));
int wr_calibration_pattern_disable(struct pp_instance *ppi)
__attribute__((alias("wrpc_calibration_pattern_disable")));
int wr_read_calibration_data(struct pp_instance *ppi,
uint32_t *deltaTx, uint32_t *deltaRx, int32_t *fix_alpha,
int32_t *clock_period)
__attribute__((alias("wrpc_read_calibration_data")));
arch-wrpc/wrpc-spll.c
View file @ 48b25f3c
......@@ -53,13 +53,13 @@ int wrpc_spll_enable_ptracker(struct pp_instance *ppi)
return WR_SPLL_OK;
}
int wrpc_enable_timing_output(struct pp_instance *ppi, int enable)
int __wr_enable_timing_output(struct pp_instance *ppi, int enable)
{
shw_pps_gen_enable_output(enable);
return WR_SPLL_OK;
}
int wrpc_adjust_in_progress()
int wrpc_adjust_in_progress(void)
{
return shw_pps_gen_busy() || spll_shifter_busy(0);
}
......@@ -79,26 +79,3 @@ int wrpc_adjust_phase(int32_t phase_ps)
return WR_SPLL_OK;
}
int wr_locking_enable(struct pp_instance *ppi)
__attribute__((alias("wrpc_spll_locking_enable")));
int wr_locking_poll(struct pp_instance *ppi)
__attribute__((alias("wrpc_spll_locking_poll")));
int wr_locking_disable(struct pp_instance *ppi)
__attribute__((alias("wrpc_spll_locking_disable")));
int wr_enable_ptracker(struct pp_instance *ppi)
__attribute__((alias("wrpc_spll_enable_ptracker")));
int __wr_enable_timing_output(struct pp_instance *ppi, int enable)
__attribute__((alias("wrpc_enable_timing_output")));
int wr_adjust_in_progress()
__attribute__((alias("wrpc_adjust_in_progress")));
int wr_adjust_counters(int64_t adjust_sec, int32_t adjust_nsec)
__attribute__((alias("wrpc_adjust_counters")));
int wr_adjust_phase(int32_t phase_ps)
__attribute__((alias("wrpc_adjust_phase")));
arch-wrpc/wrpc.h
View file @ 48b25f3c
......@@ -38,4 +38,27 @@ struct wrpc_ethhdr {
uint16_t h_proto;
} __attribute__((packed));
/* wrpc-spll.c (some should move to time-wrpc/) */
int wrpc_spll_locking_enable(struct pp_instance *ppi);
int wrpc_spll_locking_poll(struct pp_instance *ppi);
int wrpc_spll_locking_disable(struct pp_instance *ppi);
int wrpc_spll_enable_ptracker(struct pp_instance *ppi);
int wrpc_adjust_in_progress(void);
int wrpc_adjust_counters(int64_t adjust_sec, int32_t adjust_nsec);
int wrpc_adjust_phase(int32_t phase_ps);
/* wrpc-calibration.c */
int wrpc_read_calibration_data(struct pp_instance *ppi,
uint32_t *deltaTx, uint32_t *deltaRx,
int32_t *fix_alpha, int32_t *clock_period);
int wrpc_calibrating_disable(struct pp_instance *ppi, int txrx);
int wrpc_calibrating_enable(struct pp_instance *ppi, int txrx);
int wrpc_calibrating_poll(struct pp_instance *ppi, int txrx, uint32_t *delta);
int wrpc_calibration_pattern_enable(struct pp_instance *ppi,
unsigned int calibrationPeriod,
unsigned int calibrationPattern,
unsigned int calibrationPatternLen);
int wrpc_calibration_pattern_disable(struct pp_instance *ppi);
#endif /* __WRPC_H */
arch-wrs/include/ppsi-wrs.h
View file @ 48b25f3c
......@@ -45,3 +45,25 @@ extern int unix_net_check_pkt(struct pp_globals *ppg, int delay_ms);
extern void wrs_main_loop(struct pp_globals *ppg);
extern void wrs_init_ipcserver(struct minipc_ch *ppsi_ch);
/* wrs-calibration.c */
int wrs_read_calibration_data(struct pp_instance *ppi,
uint32_t *delta_tx, uint32_t *delta_rx,
int32_t *fix_alpha, int32_t *clock_period);
int wrs_calibrating_disable(struct pp_instance *ppi, int txrx);
int wrs_calibrating_enable(struct pp_instance *ppi, int txrx);
int wrs_calibrating_poll(struct pp_instance *ppi, int txrx, uint32_t *delta);
int wrs_calibration_pattern_enable(struct pp_instance *ppi,
unsigned int calib_period,
unsigned int calib_pattern,
unsigned int calib_pattern_len);
int wrs_calibration_pattern_disable(struct pp_instance *ppi);
/* wrs-time.c (some should moce to wrs-spll.c) */
int wrs_locking_enable(struct pp_instance *ppi);
int wrs_locking_poll(struct pp_instance *ppi);
int wrs_locking_disable(struct pp_instance *ppi);
int wrs_enable_ptracker(struct pp_instance *ppi);
int wrs_adjust_in_progress(void);
int wrs_adjust_counters(int64_t adjust_sec, int32_t adjust_nsec);
int wrs_adjust_phase(int32_t phase_ps);
arch-wrs/wrs-calibration.c
View file @ 48b25f3c
......@@ -12,7 +12,7 @@
#define HAL_EXPORT_STRUCTURES
#include <hal_exports.h>
static int wrs_read_calibration_data(struct pp_instance *ppi,
int wrs_read_calibration_data(struct pp_instance *ppi,
uint32_t *delta_tx, uint32_t *delta_rx, int32_t *fix_alpha,
int32_t *clock_period)
{
......@@ -77,25 +77,3 @@ int wrs_calibration_pattern_disable(struct pp_instance *ppi)
{
return WR_HW_CALIB_OK;
}
int wr_calibrating_disable(struct pp_instance *ppi, int txrx)
__attribute__((alias("wrs_calibrating_disable")));
int wr_calibrating_enable(struct pp_instance *ppi, int txrx)
__attribute__((alias("wrs_calibrating_enable")));
int wr_calibrating_poll(struct pp_instance *ppi, int txrx, uint32_t *delta)
__attribute__((alias("wrs_calibrating_poll")));
int wr_calibration_pattern_enable(struct pp_instance *ppi,
unsigned int calibrationPeriod, unsigned int calibrationPattern,
unsigned int calibrationPatternLen)
__attribute__((alias("wrs_calibration_pattern_enable")));
int wr_calibration_pattern_disable(struct pp_instance *ppi)
__attribute__((alias("wrs_calibration_pattern_disable")));
int wr_read_calibration_data(struct pp_instance *ppi,
uint32_t *deltaTx, uint32_t *deltaRx, int32_t *fix_alpha,
int32_t *clock_period)
__attribute__((alias("wrs_read_calibration_data")));
arch-wrs/wrs-startup.c
View file @ 48b25f3c
......@@ -24,7 +24,24 @@
#include <ppsi/ppsi.h>
#include <ppsi-wrs.h>
#include "../proto-ext-whiterabbit/wr-api.h"
static struct wr_operations wrs_wr_operations = {
.locking_enable = wrs_locking_enable,
.locking_poll = wrs_locking_poll,
.locking_disable = wrs_locking_disable,
.enable_ptracker = wrs_enable_ptracker,
.adjust_in_progress = wrs_adjust_in_progress,
.adjust_counters = wrs_adjust_counters,
.adjust_phase = wrs_adjust_phase,
.read_calib_data = wrs_read_calibration_data,
.calib_disable = wrs_calibrating_disable,
.calib_enable = wrs_calibrating_enable,
.calib_poll = wrs_calibrating_poll,
.calib_pattern_enable = wrs_calibration_pattern_enable,
.calib_pattern_disable = wrs_calibration_pattern_disable,
};
/* ppg and fields */
static struct pp_globals ppg_static;
......@@ -41,6 +58,7 @@ int main(int argc, char **argv)
{
struct pp_globals *ppg;
struct pp_instance *ppi;
struct wr_dsport *wrp;
struct timex t;
int i;
......@@ -136,6 +154,8 @@ int main(int argc, char **argv)
ppi->portDS->ext_dsport = calloc(1, sizeof(struct wr_dsport));
if (!ppi->portDS->ext_dsport)
exit(__LINE__);
wrp = WR_DSPOR(ppi); /* just allocated above */
wrp->ops = &wrs_wr_operations;
/* The following default names depend on TIME= at build time */
ppi->n_ops = &DEFAULT_NET_OPS;
......
proto-ext-whiterabbit/state-wr-calibration.c
View file @ 48b25f3c
......@@ -11,124 +11,125 @@
int wr_calibration(struct pp_instance *ppi, unsigned char *pkt, int plen)
{
struct wr_dsport *wrp = WR_DSPOR(ppi);
int e = 0;
uint32_t delta;
if (ppi->is_new_state) {
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION;
wrp->wrPortState = WRS_CALIBRATION;
e = msg_issue_wrsig(ppi, CALIBRATE);
pp_timeout_set(ppi, PP_TO_EXT_0,
WR_DSPOR(ppi)->calPeriod);
if (WR_DSPOR(ppi)->calibrated)
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_2;
wrp->calPeriod);
if (wrp->calibrated)
wrp->wrPortState = WRS_CALIBRATION_2;
}
if (pp_timeout_z(ppi, PP_TO_EXT_0)) {
if (WR_DSPOR(ppi)->wrMode == WR_MASTER)
if (wrp->wrMode == WR_MASTER)
ppi->next_state = PPS_MASTER;
else
ppi->next_state = PPS_LISTENING;
WR_DSPOR(ppi)->wrPortState = WRS_IDLE;
wrp->wrPortState = WRS_IDLE;
goto out;
}
switch (WR_DSPOR(ppi)->wrPortState) {
switch (wrp->wrPortState) {
case WRS_CALIBRATION:
/* enable pattern sending */
if (wr_calibration_pattern_enable(ppi, 0, 0, 0) ==
if (wrp->ops->calib_pattern_enable(ppi, 0, 0, 0) ==
WR_HW_CALIB_OK)
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_1;
wrp->wrPortState = WRS_CALIBRATION_1;
else
break;
case WRS_CALIBRATION_1:
/* enable Tx calibration */
if (wr_calibrating_enable(ppi, WR_HW_CALIB_TX)
if (wrp->ops->calib_enable(ppi, WR_HW_CALIB_TX)
== WR_HW_CALIB_OK)
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_2;
wrp->wrPortState = WRS_CALIBRATION_2;
else
break;
case WRS_CALIBRATION_2:
/* wait until Tx calibration is finished */
if (wr_calibrating_poll(ppi, WR_HW_CALIB_TX, &delta) ==
if (wrp->ops->calib_poll(ppi, WR_HW_CALIB_TX, &delta) ==
WR_HW_CALIB_READY) {
WR_DSPOR(ppi)->deltaTx.scaledPicoseconds.msb =
wrp->deltaTx.scaledPicoseconds.msb =
0xFFFFFFFF & (((uint64_t)delta) >> 16);
WR_DSPOR(ppi)->deltaTx.scaledPicoseconds.lsb =
wrp->deltaTx.scaledPicoseconds.lsb =
0xFFFFFFFF & (((uint64_t)delta) << 16);
pp_diag(ppi, ext, 1, "Tx=>>scaledPicoseconds.msb = 0x%x\n",
WR_DSPOR(ppi)->deltaTx.scaledPicoseconds.msb);
wrp->deltaTx.scaledPicoseconds.msb);
pp_diag(ppi, ext, 1, "Tx=>>scaledPicoseconds.lsb = 0x%x\n",
WR_DSPOR(ppi)->deltaTx.scaledPicoseconds.lsb);
wrp->deltaTx.scaledPicoseconds.lsb);
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_3;
wrp->wrPortState = WRS_CALIBRATION_3;
} else {
break; /* again */
}
case WRS_CALIBRATION_3:
/* disable Tx calibration */
if (wr_calibrating_disable(ppi, WR_HW_CALIB_TX)
if (wrp->ops->calib_disable(ppi, WR_HW_CALIB_TX)
== WR_HW_CALIB_OK)
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_4;
wrp->wrPortState = WRS_CALIBRATION_4;
else
break;
case WRS_CALIBRATION_4:
/* disable pattern sending */
if (wr_calibration_pattern_disable(ppi) == WR_HW_CALIB_OK)
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_5;
if (wrp->ops->calib_pattern_disable(ppi) == WR_HW_CALIB_OK)
wrp->wrPortState = WRS_CALIBRATION_5;
else
break;
case WRS_CALIBRATION_5:
/* enable Rx calibration using the pattern sent by other port */
if (wr_calibrating_enable(ppi, WR_HW_CALIB_RX) ==
if (wrp->ops->calib_enable(ppi, WR_HW_CALIB_RX) ==
WR_HW_CALIB_OK)
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_6;
wrp->wrPortState = WRS_CALIBRATION_6;
else
break;
case WRS_CALIBRATION_6:
/* wait until Rx calibration is finished */
if (wr_calibrating_poll(ppi, WR_HW_CALIB_RX, &delta) ==
if (wrp->ops->calib_poll(ppi, WR_HW_CALIB_RX, &delta) ==
WR_HW_CALIB_READY) {
pp_diag(ppi, ext, 1, "Rx fixed delay = %d\n", (int)delta);
WR_DSPOR(ppi)->deltaRx.scaledPicoseconds.msb =
wrp->deltaRx.scaledPicoseconds.msb =
0xFFFFFFFF & (delta >> 16);
WR_DSPOR(ppi)->deltaRx.scaledPicoseconds.lsb =
wrp->deltaRx.scaledPicoseconds.lsb =
0xFFFFFFFF & (delta << 16);
pp_diag(ppi, ext, 1, "Rx=>>scaledPicoseconds.msb = 0x%x\n",
WR_DSPOR(ppi)->deltaRx.scaledPicoseconds.msb);
wrp->deltaRx.scaledPicoseconds.msb);
pp_diag(ppi, ext, 1, "Rx=>>scaledPicoseconds.lsb = 0x%x\n",
WR_DSPOR(ppi)->deltaRx.scaledPicoseconds.lsb);
wrp->deltaRx.scaledPicoseconds.lsb);
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_7;
wrp->wrPortState = WRS_CALIBRATION_7;
} else {
break; /* again */
}
case WRS_CALIBRATION_7:
/* disable Rx calibration */
if (wr_calibrating_disable(ppi, WR_HW_CALIB_RX)
if (wrp->ops->calib_disable(ppi, WR_HW_CALIB_RX)
== WR_HW_CALIB_OK)
WR_DSPOR(ppi)->wrPortState = WRS_CALIBRATION_8;
wrp->wrPortState = WRS_CALIBRATION_8;
else
break;
case WRS_CALIBRATION_8:
/* send deltas to the other port and go to the next state */
e = msg_issue_wrsig(ppi, CALIBRATED);
ppi->next_state = WRS_CALIBRATED;
WR_DSPOR(ppi)->calibrated = TRUE;
wrp->calibrated = TRUE;
default:
break;
}
out:
ppi->next_delay = WR_DSPOR(ppi)->wrStateTimeout;
ppi->next_delay = wrp->wrStateTimeout;
return e;
}
proto-ext-whiterabbit/state-wr-link-on.c
View file @ 48b25f3c
......@@ -11,25 +11,26 @@
int wr_link_on(struct pp_instance *ppi, unsigned char *pkt, int plen)
{
struct wr_dsport *wrp = WR_DSPOR(ppi);
int e = 0;
if (ppi->is_new_state) {
WR_DSPOR(ppi)->wrModeOn = TRUE;
wr_enable_ptracker(ppi);
wrp->wrModeOn = TRUE;
wrp->ops->enable_ptracker(ppi);
if (WR_DSPOR(ppi)->wrMode == WR_MASTER)
if (wrp->wrMode == WR_MASTER)
e = msg_issue_wrsig(ppi, WR_MODE_ON);
WR_DSPOR(ppi)->parentWrModeOn = TRUE;
WR_DSPOR(ppi)->wrPortState = WRS_WR_LINK_ON;
wrp->parentWrModeOn = TRUE;
wrp->wrPortState = WRS_WR_LINK_ON;
}
if (e != 0)
return -1;
WR_DSPOR(ppi)->wrPortState = WRS_IDLE;
wrp->wrPortState = WRS_IDLE;
if (WR_DSPOR(ppi)->wrMode == WR_SLAVE)
if (wrp->wrMode == WR_SLAVE)
ppi->next_state = PPS_SLAVE;
else
ppi->next_state = PPS_MASTER;
......
proto-ext-whiterabbit/state-wr-resp-calib-req.c
View file @ 48b25f3c
......@@ -11,26 +11,27 @@
int wr_resp_calib_req(struct pp_instance *ppi, unsigned char *pkt, int plen)
{
struct wr_dsport *wrp = WR_DSPOR(ppi);
int e = 0;
MsgSignaling wrsig_msg;
if (ppi->is_new_state) {
WR_DSPOR(ppi)->wrPortState = WRS_RESP_CALIB_REQ;
if (WR_DSPOR(ppi)->otherNodeCalSendPattern) {
wr_calibration_pattern_enable(ppi, 0, 0, 0);
wrp->wrPortState = WRS_RESP_CALIB_REQ;
if (wrp->otherNodeCalSendPattern) {
wrp->ops->calib_pattern_enable(ppi, 0, 0, 0);
pp_timeout_set(ppi, PP_TO_EXT_0,
WR_DSPOR(ppi)->otherNodeCalPeriod / 1000);
wrp->otherNodeCalPeriod / 1000);
}
}
if ((WR_DSPOR(ppi)->otherNodeCalSendPattern) &&
if ((wrp->otherNodeCalSendPattern) &&
(pp_timeout_z(ppi, PP_TO_EXT_0))) {
if (WR_DSPOR(ppi)->wrMode == WR_MASTER)
if (wrp->wrMode == WR_MASTER)
ppi->next_state = PPS_MASTER;
else
ppi->next_state = PPS_LISTENING;
WR_DSPOR(ppi)->wrPortState = WRS_IDLE;
wrp->wrPortState = WRS_IDLE;
goto out;
}
......@@ -40,12 +41,12 @@ int wr_resp_calib_req(struct pp_instance *ppi, unsigned char *pkt, int plen)
if (ppi->received_ptp_header.messageType == PPM_SIGNALING) {
msg_unpack_wrsig(ppi, pkt, &wrsig_msg,
&(WR_DSPOR(ppi)->msgTmpWrMessageID));
&(wrp->msgTmpWrMessageID));
if (WR_DSPOR(ppi)->msgTmpWrMessageID == CALIBRATED) {
if (WR_DSPOR(ppi)->otherNodeCalSendPattern)
wr_calibration_pattern_disable(ppi);
if (WR_DSPOR(ppi)->wrMode == WR_MASTER)
if (wrp->msgTmpWrMessageID == CALIBRATED) {
if (wrp->otherNodeCalSendPattern)
wrp->ops->calib_pattern_disable(ppi);
if (wrp->wrMode == WR_MASTER)
ppi->next_state = WRS_WR_LINK_ON;
else
ppi->next_state = WRS_CALIBRATION;
......@@ -54,6 +55,6 @@ int wr_resp_calib_req(struct pp_instance *ppi, unsigned char *pkt, int plen)
}
out:
ppi->next_delay = WR_DSPOR(ppi)->wrStateTimeout;
ppi->next_delay = wrp->wrStateTimeout;
return e;
}
proto-ext-whiterabbit/state-wr-s-lock.c
View file @ 48b25f3c
......@@ -11,26 +11,28 @@
int wr_s_lock(struct pp_instance *ppi, unsigned char *pkt, int plen)
{
struct wr_dsport *wrp = WR_DSPOR(ppi);
int e = 0;
if (ppi->is_new_state) {
WR_DSPOR(ppi)->wrPortState = WRS_S_LOCK;
wr_locking_enable(ppi);
wrp->wrPortState = WRS_S_LOCK;
wrp->ops->locking_enable(ppi);
pp_timeout_set(ppi, PP_TO_EXT_0, WR_S_LOCK_TIMEOUT_MS);
}
if (pp_timeout_z(ppi, PP_TO_EXT_0)) {
ppi->next_state = PPS_FAULTY;
WR_DSPOR(ppi)->wrPortState = WRS_IDLE;
WR_DSPOR(ppi)->wrMode = NON_WR;
wrp->wrPortState = WRS_IDLE;
wrp->wrMode = NON_WR;
goto out;
}
if (wr_locking_poll(ppi) == WR_SPLL_READY) {
if (wrp->ops->locking_poll(ppi) == WR_SPLL_READY) {
ppi->next_state = WRS_LOCKED;
wr_locking_disable(ppi);
wrp->ops->locking_disable(ppi);
}
out:
ppi->next_delay = WR_DSPOR(ppi)->wrStateTimeout;
ppi->next_delay = wrp->wrStateTimeout;
return e;
}
proto-ext-whiterabbit/wr-api.h
View file @ 48b25f3c
......@@ -17,6 +17,7 @@
* (see wrspec.v2-06-07-2011, page 17)
*/
struct wr_dsport {
struct wr_operations *ops; /* hardware-dependent, see below */
Enumeration8 wrConfig;
Enumeration8 wrMode;
Boolean wrModeOn;
......@@ -87,32 +88,35 @@ int wr_calibrated(struct pp_instance *ppi, unsigned char *pkt, int plen);
int wr_resp_calib_req(struct pp_instance *ppi, unsigned char *pkt, int plen);
int wr_link_on(struct pp_instance *ppi, unsigned char *pkt, int plen);
/* White Rabbit hw-dependent functions (they are indeed implemented in
* arch-wrpc or any other arch- */
int wr_locking_enable(struct pp_instance *ppi);
int wr_locking_poll(struct pp_instance *ppi);
int wr_locking_disable(struct pp_instance *ppi);
int wr_calibrating_disable(struct pp_instance *ppi, int txrx);
int wr_calibrating_enable(struct pp_instance *ppi, int txrx);
int wr_calibrating_poll(struct pp_instance *ppi, int txrx, uint32_t *delta);
int wr_calibration_pattern_enable(struct pp_instance *ppi,
unsigned int calibrationPeriod, unsigned int calibrationPattern,
unsigned int calibrationPatternLen);
int wr_calibration_pattern_disable(struct pp_instance *ppi);
int wr_read_calibration_data(struct pp_instance *ppi,
uint32_t *deltaTx, uint32_t *deltaRx, int32_t *fix_alpha,
int32_t *clock_period);
int wr_enable_ptracker(struct pp_instance *ppi);
/* White Rabbit hw-dependent functions (code in arch-wrpc and arch-wrs) */
struct wr_operations {
int (*locking_enable)(struct pp_instance *ppi);
int (*locking_poll)(struct pp_instance *ppi);
int (*locking_disable)(struct pp_instance *ppi);
int (*enable_ptracker)(struct pp_instance *ppi);
int (*adjust_in_progress)(void);
int (*adjust_counters)(int64_t adjust_sec, int32_t adjust_nsec);
int (*adjust_phase)(int32_t phase_ps);
int (*read_calib_data)(struct pp_instance *ppi,
uint32_t *deltaTx, uint32_t *deltaRx,
int32_t *fix_alpha, int32_t *clock_period);
int (*calib_disable)(struct pp_instance *ppi, int txrx);
int (*calib_enable)(struct pp_instance *ppi, int txrx);
int (*calib_poll)(struct pp_instance *ppi, int txrx, uint32_t *delta);
int (*calib_pattern_enable)(struct pp_instance *ppi,
unsigned int calibrationPeriod,
unsigned int calibrationPattern,
unsigned int calibrationPatternLen);
int (*calib_pattern_disable)(struct pp_instance *ppi);
};
/* The former is called by ppsi, the latter is the internal hw detail */
int wr_enable_timing_output(struct pp_instance *ppi, int enable);
int __wr_enable_timing_output(struct pp_instance *ppi, int enable);
/* FIXME: fold function above into wr_operations */
int wr_adjust_in_progress(void);
int wr_adjust_counters(int64_t adjust_sec, int32_t adjust_nsec);
int wr_adjust_phase(int32_t phase_ps);
/* wr_servo interface */
int wr_servo_init(struct pp_instance *ppi);
......
proto-ext-whiterabbit/wr-servo.c
View file @ 48b25f3c
......@@ -155,11 +155,12 @@ void wr_servo_reset()
int wr_servo_init(struct pp_instance *ppi)
{
struct wr_dsport *wrp = WR_DSPOR(ppi);
struct wr_servo_state_t *s =
&((struct wr_data_t *)ppi->ext_data)->servo_state;
/* Determine the alpha coefficient */
if (wr_read_calibration_data(ppi, 0, 0,
if (wrp->ops->read_calib_data(ppi, 0, 0,
&s->fiber_fix_alpha, &s->clock_period_ps) != WR_HW_CALIB_OK)
return -1;
......@@ -239,6 +240,7 @@ int wr_servo_got_delay(struct pp_instance *ppi, Integer32 cf)
int wr_servo_update(struct pp_instance *ppi)
{
struct wr_dsport *wrp = WR_DSPOR(ppi);
struct wr_servo_state_t *s =
&((struct wr_data_t *)ppi->ext_data)->servo_state;
......@@ -304,7 +306,7 @@ int wr_servo_update(struct pp_instance *ppi)
tics = ppi->t_ops->calc_timeout(ppi, 0);
if (wr_locking_poll(ppi) != WR_SPLL_READY) {
if (wrp->ops->locking_poll(ppi) != WR_SPLL_READY) {
pp_diag(ppi, servo, 1, "PLL OutOfLock, should restart sync\n");
wr_enable_timing_output(ppi, 0);
/* TODO check
......@@ -316,7 +318,7 @@ int wr_servo_update(struct pp_instance *ppi)
switch (s->state) {
case WR_WAIT_SYNC_IDLE:
if (!wr_adjust_in_progress()) {
if (!wrp->ops->adjust_in_progress()) {
s->state = s->next_state;
} else {
pp_diag(ppi, servo, 1, "servo:busy\n");
......@@ -328,8 +330,8 @@ int wr_servo_update(struct pp_instance *ppi)
if (ts_offset_hw.seconds != 0) {
strcpy(cur_servo_state.slave_servo_state, "SYNC_SEC");
wr_adjust_counters(ts_offset_hw.seconds, 0);
wr_adjust_phase(0);
wrp->ops->adjust_counters(ts_offset_hw.seconds, 0);
wrp->ops->adjust_phase(0);
s->next_state = WR_SYNC_NSEC;
s->state = WR_WAIT_SYNC_IDLE;
......@@ -344,7 +346,7 @@ int wr_servo_update(struct pp_instance *ppi)
strcpy(cur_servo_state.slave_servo_state, "SYNC_NSEC");
if (ts_offset_hw.nanoseconds != 0) {
wr_adjust_counters(0, ts_offset_hw.nanoseconds);
wrp->ops->adjust_counters(0, ts_offset_hw.nanoseconds);
s->next_state = WR_SYNC_NSEC;
s->state = WR_WAIT_SYNC_IDLE;
......@@ -360,7 +362,7 @@ int wr_servo_update(struct pp_instance *ppi)
s->cur_setpoint = ts_offset_hw.phase
+ ts_offset_hw.nanoseconds * 1000;
wr_adjust_phase(s->cur_setpoint);
wrp->ops->adjust_phase(s->cur_setpoint);
s->next_state = WR_WAIT_OFFSET_STABLE;
s->state = WR_WAIT_SYNC_IDLE;
......@@ -400,7 +402,7 @@ int wr_servo_update(struct pp_instance *ppi)
// just follow the changes of deltaMS
s->cur_setpoint += (s->delta_ms - s->delta_ms_prev);
wr_adjust_phase(s->cur_setpoint);
wrp->ops->adjust_phase(s->cur_setpoint);
s->delta_ms_prev = s->delta_ms;
s->next_state = WR_TRACK_PHASE;
......
time-wrs/wrs-time.c
View file @ 48b25f3c
......@@ -88,7 +88,7 @@ int wrs_enable_ptracker(struct pp_instance *ppi)
return WR_SPLL_OK;
}
int wrs_enable_timing_output(struct pp_instance *ppi, int enable)
int __wr_enable_timing_output(struct pp_instance *ppi, int enable)
{
int ret, rval;
......@@ -139,29 +139,6 @@ int wrs_locking_poll(struct pp_instance *ppi)
return WR_SPLL_READY;
}
int wr_locking_enable(struct pp_instance *ppi)
__attribute__((alias("wrs_locking_enable")));
int wr_locking_poll(struct pp_instance *ppi)
__attribute__((alias("wrs_locking_poll")));
int wr_locking_disable(struct pp_instance *ppi)
__attribute__((alias("wrs_locking_disable")));
int wr_enable_ptracker(struct pp_instance *ppi)
__attribute__((alias("wrs_enable_ptracker")));
int __wr_enable_timing_output(struct pp_instance *ppi, int enable)
__attribute__((alias("wrs_enable_timing_output")));
int wr_adjust_in_progress()
__attribute__((alias("wrs_adjust_in_progress")));
int wr_adjust_counters(int64_t adjust_sec, int32_t adjust_nsec)
__attribute__((alias("wrs_adjust_counters")));
int wr_adjust_phase(int32_t phase_ps)
__attribute__((alias("wrs_adjust_phase")));
static int wrs_time_get(struct pp_instance *ppi, TimeInternal *t)
{
......@@ -235,7 +212,7 @@ static int wrs_time_set(struct pp_instance *ppi, TimeInternal *t)
static int wrs_time_adjust_offset(struct pp_instance *ppi, long offset_ns)
{
pp_diag(ppi, time, 1, "adjust offset %09li\n", offset_ns);
return wr_adjust_counters(0, offset_ns);
return wrs_adjust_counters(0, offset_ns);
}
static int wrs_time_adjust(struct pp_instance *ppi, long offset_ns,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment