POWERFIP Library : User’s Guide

int pwrfip_init()

void pwrfip_exit()

const struct pwrfip_version *pwrfip_version_get()

int main(int argc, char *argv[])
{
    const struct pwrfip_version *lib_version;

    pwrfip_init();

    /* pwrfip - get lib version */
    lib_version = pwrfip_version_get();

    printf("pwrfip lib: v%d.%d.%d [build date: %02d/%02d/%02d]\n",
        lib_version->info.major,
        lib_version->info.minor,
        lib_version->info.patch,
        lib_version->date.info.month,
        lib_version->date.info.day,
        lib_version->date.info.year);

    pwrfip_exit();

    return 0;
}

const char *pwrfip_strerror(int err)

int pwrfip_device_list_get(struct pwrfip_dev_infos *dev_infos,
                int *dev_cnt)

struct pwrfip_dev *pwrfip_device_open(uint8_t dev_id)

int pwrfip_device_reset(struct pwrfip_dev *dev)

int pwrfip_device_close(struct pwrfip_dev *dev)

int pwrfip_device_infos_get(struct pwrfip_dev *dev,
                struct pwrfip_dev_infos *info)

int pwrfip_device_report_get(struct pwrfip_dev *dev,
                struct pwrfip_dev_report *report)

struct pwrfip_aele *pwrfip_aele_create(struct pwrfip_node *node);

int pwrfip_aele_delete(struct pwrfip_aele *aele)

struct pwrfip_var *pwrfip_var_create(struct pwrfip_aele *aele,
                struct pwrfip_var_cfg *cfg)

void sync_var_handler(struct pwrfip_node *node,
    struct pwrfip_var *var, struct pwrfip_event *evt);

static struct pwrfip_var_cfg prod_var_cfg = {
    .type = PWRFIP_VAR_TYPE_PROD,
    .id = 0x8426,
    .prod.payload_bsz = 12,
    .prod.flags = \
        /* enable prod status */
        PWRFIP_VAR_FLAGS_REFRESH | \
        /* enable aper msg request */
        PWRFIP_VAR_FLAGS_APER_MSG_REQ,
    .prod.refreshment_ustime = 16000, /* 16ms */
    .prod.evt_type = PWRFIP_EVT_TYPE_NONE,
    .pwrfip_var_handler = NULL,
};

static struct pwrfip_var_cfg cons_var_cfg = {
    .type = PWRFIP_VAR_TYPE_CONS,
    .id = 0x8427,
    .cons.payload_bsz = 12,
    .cons.flags = \
        /* enable prod status */
        PWRFIP_VAR_FLAGS_REFRESH | \
        /* enable promptness checking */
        PWRFIP_VAR_FLAGS_PROMPT | \
        /* enable pdu + len bytes checking */
        PWRFIP_VAR_FLAGS_CHK_PDU_LEN,
    .cons.promptness_ustime = 16000, /* 16ms */
    .cons.evt_type = PWRFIP_EVT_TYPE_NONE,
    .pwrfip_var_handler = NULL,
};

static struct pwrfip_var_cfg sync_var_cfg = {
    .type = PWRFIP_VAR_TYPE_SYNC,
    .id = 0x9003,
    .pwrfip_var_handler = sync_var_handler,
};

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_aele *al;
    struct pwrfip_var *prod_var, *cons_var, *sync_var;

    /**
     * Node initialization
     */
    /*...*/

    /* create an aele context */
    al = pwrfip_aele_create(node);
    if (!al) {
        printf("aele creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a production variable */
    prod_var = pwrfip_var_create(al, &prod_var_cfg);
    if (!prod_var) {
        printf("production variable creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a consumption variable */
    cons_var = pwrfip_var_create(al, &cons_var_cfg);
    if (!cons_var) {
        printf("consumption variable creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a synchronization variable */
    sync_var = pwrfip_var_create(al, &sync_var_cfg);
    if (!sync_var) {
        printf("synchronization variable creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_var_delete(struct pwrfip_var *var)

struct pwrfip_ba_mcycle *pwrfip_ba_mcycle_create(
                            struct pwrfip_node *node,
                            struct pwrfip_ba_mcycle_cfg *cfg)

#define TST_BA_PER_REQ_COUNT 4
static struct pwrfip_ba_request tst_ba_per_req[TST_BA_PER_REQ_COUNT] = {
    {
        .type = PWRFIP_BA_ID_DAT,
        .id = 0x8426,
    },
    {
        .type = PWRFIP_BA_ID_DAT,
        .id = 0x8427,
    },
    {
        .type = PWRFIP_BA_ID_DAT,
        .id = 0x0001,
    },
    {
        .type = PWRFIP_BA_ID_DAT,
        .id = 0x9003,
    },
};

static struct pwrfip_ba_wind_cfg tst_ba_wind_cfg[2][4] = {
    /* ba mcycle 1 */
    {
        /* 1 - periodic variable window */
        {
            .type = PWRFIP_BA_WIND_PER,
            .per.req_cnt = TST_BA_PER_REQ_COUNT,
            .per.req_list = &tst_ba_per_req[0],
        },
        /* 2 - aperiodic message window */
        {
            .type = PWRFIP_BA_WIND_APER_MSG,
            .aper_msg.end_ustime = 5000,
        },
        /* 3 - aperiodic variable window */
        {
            .type = PWRFIP_BA_WIND_APER_VAR,
            .aper_var.end_ustime = 10000,
        },
        /* 4 - resync wait window */
        {
            .type = PWRFIP_BA_WIND_WAIT,
            .wait.end_ustime = 15000,
            .wait.is_silent = 0, /* fill window with padding frames */
            .wait.is_ext_resync = 0, /* internal resynchronization */
        },
    },
    /* ba mcycle 2 */
    {
        /* 1 - periodic variable window */
        {
            .type = PWRFIP_BA_WIND_PER,
            .per.req_cnt = TST_BA_PER_REQ_COUNT,
            .per.req_list = &tst_ba_per_req[0],
        },
        /* 2 - aperiodic message window */
        {
            .type = PWRFIP_BA_WIND_APER_MSG,
            .aper_msg.end_ustime = 5000,
        },
        /* 3 - resync wait window */
        {
            .type = PWRFIP_BA_WIND_WAIT,
            .wait.end_ustime = 30000,
            .wait.is_silent = 0, /* fill window with padding frames */
            .wait.is_ext_resync = 0, /* internal resynchronization */
        },
        /* no other window */
        {
            .type = 0,
        }
    },
};

static struct pwrfip_ba_mcycle_cfg tst_ba_mcycle_cfg[2] = {
    /* ba mcycle 1 */
    {
        .wind_cnt = 4,
        .wind_list = &tst_ba_wind_cfg[0][0],
    },
    /* ba mcycle 2 */
    {
        .wind_cnt = 3,
        .wind_list = &tst_ba_wind_cfg[1][0],
    },
};

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_ba_mcycle *mcycle[2];

    /**
     * Node initialization
     */
    /*...*/

    /* create two bus arbiter macrocycles */
    for (i = 0; i < 2; ++i) {
        struct pwrfip_ba_mcycle_cfg *mcycle_cfg = &tst_ba_mcycle_cfg[i];

        mcycle[i] = pwrfip_ba_mcycle_create(node, mcycle_cfg);
        if (!mcycle[i]) {
            /* get error */*
            printf("macrocycle creation failed: %s\n", pwrfip_strerror(errno));
            err = -1;
            goto end;
        }
    }

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_ba_mcycle_delete(struct pwrfip_ba_mcycle *mcycle)

int pwrfip_ba_startup_calculate(uint32_t *stup_ustime, uint32_t *elec_ustime,
        struct pwrfip_ba_startup_cfg *cfg)

int pwrfip_ba_start(struct pwrfip_ba_mcycle *mcycle)

int pwrfip_ba_stop(struct pwrfip_node *node)

int pwrfip_ba_commute(struct pwrfip_ba_mcycle *mcycle)

int pwrfip_ba_status_get(struct pwrfip_node *node, struct pwrfip_ba_status *status)

struct pwrfip_node *pwrfip_node_init(struct pwrfip_node_cfg *cfg)

void usr_rst_handler(struct pwrfip_node *node)
{
    /* calling the reset function for a pci/pcie device */
    if (pwrfip_device_reset(node->infos->cfg.dev)) {
        printf("reset failed: %s\n", pwrfip_strerror(errno));
        return;
    }
    _print(src, evt, "reset coprocessor component (powerfip) done\n");
}

void usr_err_handler(struct pwrfip_node *node,
        enum pwrfip_error_code code)
{
    printf("error_handler: %s (err_code=%d)\n",
        pwrfip_strerror(code), code);
}

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_dev *dev;
    struct pwrfip_node *node;
    struct pwrfip_node_cfg cfg;

    /* pwrfip lib initialization [mandatory] */
    if (pwrfip_init()) {
        printf("cannot init pwrfip library: %s\n",
            pwrfip_strerror(errno));
        return -1;
    }

    /* open a pci/pcie device (1st index) */
    dev = pwrfip_device_open(1);
    if (!dev) {
        printf("cannot open device: %s\n",
            pwrfip_strerror(errno));
        pwrfip_exit();
        return -1;
    }

    /**
     * Node initialization:
     * Minimal set-up for a PCI/PCIe device
     */
    cfg.fip_phy_addr = 1; /* fip node addr = 0x01 */
    cfg.fip_seg_num = 0; /* fip node belongs to fip segment 0 */
    cfg.fip_frm_type = PWRFIP_FRM_WORLDFIP; /* WorldFIP frame (IEC) */
    cfg.fip_bitrate = PWRFIP_BITRATE_1M; /* 1Mbps */
    cfg.turn_around_ustime = 0; /* default TR time for 1Mbps (30us) */
    cfg.silence_ustime = 0; /* default TS time for 1Mbps (150us) */
    cfg.enable_bimedium = 0; /* mono-medium topology (just one channel) */
    cfg.msg.enable = 0; /* fip messaging not supported */
    cfg.ba.enable = 0; /* no master capability for this node */
    cfg.dev = dev; /* coprocessor attachment: pci/pcie device to bind */
    cfg.pwrfip_error_handler = usr_err_handler; /* local handler to notify
                                                   the internal errors of
                                                   the library */
    cfg.pwrfip_reset_handler = usr_rst_handler; /* local handler to reset
                                                   the bound device */

    node = pwrfip_node_init(&cfg);
    if (!node) {
        printf("node initialization failed: %s\n",
            pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/

    /* close device */
    pwrfip_device_close(dev);

    /* pwrfip lib exit [mandatory] */
    pwrfip_exit();
    return err;
}

int pwrfip_node_exit(struct pwrfip_node *node)

int pwrfip_node_status_get(struct pwrfip_node *node,
                struct pwrfip_node_status *status)

static const char *pwrfip_node_state_str[_PWRFIP_NODE_STATE_MAX] = {
    /* PWRFIP_NODE_STATE_INITIAL */
    "intial",
    /* PWRFIP_NODE_STATE_LOADED */
    "loaded",
    /* PWRFIP_NODE_STATE_READY */
    "ready",
    /* PWRFIP_NODE_STATE_RUNNING */
    "running",
};

static const char *pwrfip_node_op_str[_PWRFIP_NODE_OP_MAX] = {
    /* _PWRFIP_NODE_OP_UNKNOWN */
    "unknown",
    /* PWRFIP_NODE_OP_WAIT_RX_RP_FRM */
    "rx rp frame",
    /* PWRFIP_NODE_OP_WAIT_TX_RP_FRM */
    "tx rp frame",
    /* PWRFIP_NODE_OP_WAIT_RX_ID_FRM */
    "rx id frame",
    /* PWRFIP_NODE_OP_WAIT_TX_ID_FRM */
    "tx id frame",
};

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_node_status n_status;

    /**
     * Node initialization
     */
    /*...*/

    /* get node status */
    err = pwrfip_node_status_get(node, &n_status);
    if (err) {
        printf("node status getter failed: %s\n", pwrfip_strerror(errno));
        goto end;
    }

    printf("node_status\n");
    printf("  node_state    : %d (%s)\n", n_status.state,
            pwrfip_node_state_str[n_status.state]);
    printf("  node_op       : %d (%s)\n", n_status.op,
            pwrfip_node_op_str[n_status.op]);

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_node_report_get(struct pwrfip_node *node,
                struct pwrfip_node_report *report)

static const char *pwrfip_node_state_str[_PWRFIP_NODE_STATE_MAX] = {
    /* PWRFIP_NODE_STATE_INITIAL */
    "intial",
    /* PWRFIP_NODE_STATE_LOADED */
    "loaded",
    /* PWRFIP_NODE_STATE_READY */
    "ready",
    /* PWRFIP_NODE_STATE_RUNNING */
    "running",
};

static const char *pwrfip_ba_state_str[_PWRFIP_BA_STATE_MAX] = {
    /* PWRFIP_BA_STATE_INITIAL */
    "intial",
    /* PWRFIP_BA_STATE_READY */
    "ready",
    /* PWRFIP_BA_STATE_STARTING */
    "starting",
    /* PWRFIP_BA_STATE_IDLE */
    "idle",
    /* PWRFIP_BA_STATE_RUNNING */
    "running",
};

static const char *pwrfip_node_op_str[_PWRFIP_NODE_OP_MAX] = {
    /* _PWRFIP_NODE_OP_UNKNOWN */
    "unknown",
    /* PWRFIP_NODE_OP_WAIT_RX_RP_FRM */
    "rx rp frame",
    /* PWRFIP_NODE_OP_WAIT_TX_RP_FRM */
    "tx rp frame",
    /* PWRFIP_NODE_OP_WAIT_RX_ID_FRM */
    "rx id frame",
    /* PWRFIP_NODE_OP_WAIT_TX_ID_FRM */
    "tx id frame",
};

static const char *pwrfip_ba_wind_str[_PWRFIP_BA_WIND_TYPE_MAX] = {
    /* _PWRFIP_BA_WIND_TYPE_NONE */
    "none",
    /* PWRFIP_BA_WIND_PER */
    "periodic",
    /* PWRFIP_BA_WIND_APER_VAR */
    "aper. var",
    /* PWRFIP_BA_WIND_APER_MSG */
    "aper. msg",
    /* PWRFIP_BA_WIND_WAIT */
    "wait",
};

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_node_report n_report; /* full report */
    uint16_t m_state; /* medium state */

    /**
     * Node initialization
     */
    /*...*/

    /**
     * Node startup
     */
    /*...*/

    /* get node report */
    err = pwrfip_node_report_get(node, &n_report);
    if (err) {
        printf("node report getter failed: %s\n", pwrfip_strerror(errno));
        goto end;
    }

    m_state = n_report.medium_status.state;
    printf("** coprocessor report:\n");
    printf("  node_state    : %d (%s)\n", n_report.node_status.state,
            pwrfip_node_state_str[n_report.node_status.state]);
    printf("  node_op       : %d (%s)\n", n_report.node_status.op,
            pwrfip_node_op_str[n_report.node_status.op]);
    printf("  ba_state      : %d (%s)\n", n_report.ba_status.state,
            pwrfip_ba_state_str[n_report.ba_status.state]);
    printf("  ba_window     : %d (%s)\n", n_report.ba_status.window,
            pwrfip_ba_wind_str[n_report.ba_status.window]);
    printf("  medium_state  : 0x%04x\n", m_state);
    printf("    [channel 1]\n");
    printf("      enable    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_VALID) ? "yes": "no");
    printf("      tx_err    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_TX_ERROR) ? "yes": "no");
    printf("      watchdog  : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_WATCHDOG) ? "yes": "no");
    printf("    [channel 2]\n");
    printf("      enable    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_VALID) ? "yes": "no");
    printf("      tx_err    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_TX_ERROR) ? "yes": "no");
    printf("      watchdog  : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_WATCHDOG) ? "yes": "no");
    printf("  tx_err        :\n");
    printf("    ok          : %d\n", n_report.tx_err.ok);
    printf("    collision   : %d\n", n_report.tx_err.collision);
    printf("    consistency : %d\n", n_report.tx_err.consistency);
    printf("    not_fresh   : %d\n", n_report.tx_err.not_fresh);
    printf("  rx_err        :\n");
    printf("    ok          : %d\n", n_report.rx_err.ok);
    printf("    pre_mis     : %d\n", n_report.rx_err.pre_mis);
    printf("    fsd_mis     : %d\n", n_report.rx_err.fsd_mis);
    printf("    fsd_unk     : %d\n", n_report.rx_err.fsd_unk);
    printf("    fed_mis     : %d\n", n_report.rx_err.fed_mis);
    printf("    crc_bad     : %d\n", n_report.rx_err.crc_bad);
    printf("    pdu_bad     : %d\n", n_report.rx_err.pdu_bad);
    printf("    len_bad     : %d\n", n_report.rx_err.len_bad);
    printf("    not_fresh   : %d\n", n_report.rx_err.not_fresh);
    printf("    not_prompt  : %d\n", n_report.rx_err.not_prompt);

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_node_start(struct pwrfip_aele *aele,
                struct pwrfip_ba_mcycle **mcycle_list, int mcycle_cnt)

int pwrfip_node_stop(struct pwrfip_node *node)

int pwrfip_var_write(struct pwrfip_var *var)

static struct pwrfip_var_cfg prod_var_cfg = {
    .type = PWRFIP_VAR_TYPE_PROD,
    .id = 0x8426,
    .prod.payload_bsz = 12,
    .prod.flags = \
        /* enable prod status */
        PWRFIP_VAR_FLAGS_REFRESH,
    .prod.refreshment_ustime = 16000, /* 16ms */
    .prod.evt_type = PWRFIP_EVT_TYPE_NONE,
    .pwrfip_var_handler = NULL,
};

int main(int argc, char *argv[])
{
    int i, err = 0;
    struct pwrfip_node *node;
    struct pwrfip_aele *al;
    struct pwrfip_var *prod_var;
    uint8_t w_byte = 0;

    /**
     * Node initialization
     */
    /*...*/

    /* create an aele context */
    al = pwrfip_aele_create(node);
    if (!al) {
        printf("aele creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a production variable */
    prod_var = pwrfip_var_create(al, &prod_var_cfg);
    if (!prod_var) {
        printf("production variable creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* node startup (slave) */
    err = pwrfip_node_start(al, NULL, 0);
    if (err) {
        printf("node startup failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* writing loop */
    for(;;) {
        /* update var payload */
        /* for the example, we increment all the bytes of the
           frame by 1 at each write */
        w_byte++;
        memset(prod_var->buffer, w_byte, prod_var->bsz);

        /* write it to fip network */
        if (pwrfip_var_write(prod_var)) {
            printf("w_var[0x%04x] failed: %s\n", prod_var->id,
                pwrfip_strerror(errno));
            /* we consider this error as fatal error; so we
             * stop the test */
            break;
        }

        /* check var state errors */
        if (prod_var->error) {
            printf("w_var[0x%04x] state error: %d\n",
                prod_var->id, prod_var->error);
        }

        usleep(5000); /* 5ms */
    }

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_var_read(struct pwrfip_var *var)

static struct pwrfip_var_cfg cons_var_cfg = {
    .type = PWRFIP_VAR_TYPE_CONS,
    .id = 0x8427,
    .cons.payload_bsz = 12,
    .cons.flags = \
        /* enable prod status */
        PWRFIP_VAR_FLAGS_REFRESH | \
        /* enable promptness checking */
        PWRFIP_VAR_FLAGS_PROMPT | \
        /* enable pdu + len bytes checking */
        PWRFIP_VAR_FLAGS_CHK_PDU_LEN,
    .cons.promptness_ustime = 16000, /* 16ms */
    .cons.evt_type = PWRFIP_EVT_TYPE_NONE,
    .pwrfip_var_handler = NULL,
};

int main(int argc, char *argv[])
{
    int i, err = 0;
    struct pwrfip_node *node;
    struct pwrfip_aele *al;
    struct pwrfip_var *cons_var;

    /**
     * Node initialization
     */
    /*...*/

    /* create an aele context */
    al = pwrfip_aele_create(node);
    if (!al) {
        printf("aele creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* create a consumption variable */
    cons_var = pwrfip_var_create(al, &cons_var_cfg);
    if (!cons_var) {
        printf("consumption variable creation failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* node startup (slave) */
    err = pwrfip_node_start(al, NULL, 0);
    if (err) {
        printf("node startup failed: %s\n", pwrfip_strerror(errno));
        err = -1;
        goto end;
    }

    /* reading loop */
    for(;;) {
        if (pwrfip_var_read(cons_var)) {
            printf("r_var[0x%04x] failed: %s\n", cons_var->id,
                pwrfip_strerror(errno));
            /* we consider this error as fatal error; so we
             * stop the test */
            break;
        }
        /* print var payload */
        printf("r_var[0x%04x]: ", cons_var->id);
        for (i = 0; i < cons_var->bsz; ++i)
            printf("%02x ", cons_var->buffer[i]);
        printf("\n");

        usleep(5000); /* 5ms */
    }

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_var_evt_set(struct pwrfip_var *var,
                enum pwrfip_evt_type type)

int pwrfip_medium_status_get(struct pwrfip_node *node,
        struct pwrfip_medium_status *status)

int main(int argc, char *argv[])
{
    int err = 0;
    struct pwrfip_node *node;
    struct pwrfip_medium_status m_status;
    uint16_t m_state;

    /**
     * Node initialization
     */
    /*...*/

    /**
     * Node startup
     */
    /*...*/

    /* get medium state */
    err = pwrfip_medium_status_get(node, &m_status);
    if (err) {
        printf("medium status getter failed: %s\n", pwrfip_strerror(errno));
        goto end;
    }

    m_state = m_status.state;
    printf("medium_state  : 0x%04x\n", m_state);
    printf("  [channel 1]\n");
    printf("    enable    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_VALID) ? "yes": "no");
    printf("    tx_err    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_TX_ERROR) ? "yes": "no");
    printf("    watchdog  : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH1_WATCHDOG) ? "yes": "no");
    printf("  [channel 2]\n");
    printf("    enable    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_VALID) ? "yes": "no");
    printf("    tx_err    : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_TX_ERROR) ? "yes": "no");
    printf("    watchdog  : %s\n",
        (m_state & PWRFIP_MEDIUM_STATE_CH2_WATCHDOG) ? "yes": "no");

    /**
     * Other tasks
     */
    /* ... */

end:
    /**
     * Node exit
     */
    /*...*/
    return err;
}

int pwrfip_medium_cmd_set(struct pwrfip_node *node, uint16_t flags)

int pwrfip_evt_process(struct pwrfip_node *node)

struct pwrfip_date {
    union {
        uint32_t raw;
        struct {
            uint8_t day;
            uint8_t month;
            uint8_t year;
            uint8_t reserved;
        } info;
    };
};

struct pwrfip_version {
    union {
        uint32_t raw;
        struct {
            uint8_t patch;
            uint8_t minor;
            uint8_t major;
            uint8_t reserved;
        } info;
    };
    /* build date */
    struct pwrfip_date date;
};

struct pwrfip_ba_request {
    enum pwrfip_ba_id_type type;
    uint16_t id;
};

struct pwrfip_ba_aper_msg_wind_cfg {
    uint32_t end_ustime;
};

struct pwrfip_ba_aper_var_wind_cfg {
    uint32_t end_ustime;
    int enable_testp;
};

struct pwrfip_ba_per_wind_cfg {
    int req_cnt;
    struct pwrfip_ba_request *req_list;
};

struct pwrfip_ba_wait_wind_cfg {
    uint32_t end_ustime;
    int is_silent;
    int is_ext_resync;
};

struct pwrfip_ba_wind_cfg {
    enum pwrfip_ba_wind_type type;
    union {
        struct pwrfip_ba_per_wind_cfg per;
        struct pwrfip_ba_aper_var_wind_cfg aper_var;
        struct pwrfip_ba_aper_msg_wind_cfg aper_msg;
        struct pwrfip_ba_wait_wind_cfg wait;
    };
};

struct pwrfip_ba_mcycle_cfg {
    int wind_cnt;
    struct pwrfip_ba_wind_cfg *wind_list;
};

struct pwrfip_ba_startup_cfg {
    enum pwrfip_ba_startup_mode mode;
    uint32_t silence_ustime;
    uint8_t max_phy_addr;
    uint8_t max_prio;
    uint8_t my_phy_addr;
    uint8_t my_prio;
};

struct pwrfip_node_ba_cfg {
    int enable;
    /**
     * => BA: StartUp/Election settings
     */
    uint32_t start_ustime;
    uint32_t election_ustime;
    /**
     * => BA: Aperiodic requests FIFOs settings
     */
    uint32_t msg_req_fifo_size;
    uint32_t urgent_var_req_fifo_size;
    uint32_t normal_var_req_fifo_size;
};

struct pwrfip_node_cfg {
    /**
     * General FIP settings
     */
    uint8_t fip_phy_addr;
    uint8_t fip_seg_num;
    uint8_t fip_frm_type;
    uint8_t fip_bitrate;
    uint32_t turn_around_ustime;
    uint32_t silence_ustime;
    /**
     * Extra FIP settings
     */
    int enable_bimedium;
    struct pwrfip_node_msg_cfg msg;
    struct pwrfip_node_ba_cfg ba;
    /**
     * Hardware access
     */
    struct pwrfip_dev *dev;
    unsigned long dpm_base_addr;
    /**
     * General Handlers
     */
    void *user_ctx;
    void (* pwrfip_var_handler)(
        struct pwrfip_node *node,
        struct pwrfip_var *var,
        struct pwrfip_event *evt);
    void (* pwrfip_msg_recv_handler)(
        struct pwrfip_node *node,
        struct pwrfip_msg *msg,
        struct pwrfip_event *evt);
    void (* pwrfip_msg_send_handler)(
        struct pwrfip_node *node,
        struct pwrfip_msg *msg,
        struct pwrfip_event *evt);
    void (* pwrfip_urg_req_handler)(
        struct pwrfip_node *node,
        struct pwrfip_event *evt);
    void (* pwrfip_nor_req_handler)(
        struct pwrfip_node *node,
        struct pwrfip_event *evt);
    void (* pwrfip_ba_state_handler)(
        struct pwrfip_node *node,
        struct pwrfip_event *evt);
    void (* pwrfip_error_handler)(
        struct pwrfip_node *node,
        enum pwrfip_error_code error);
    void (* pwrfip_reset_handler)(
        struct pwrfip_node *node);
};

#define PWRFIP_MAX_TX_MSG_FIFO_COUNT 9

struct pwrfip_node_msg_cfg {
    int enable;
    /**
     * => Reception settings
     */
    uint32_t rx_fifo_size;
    uint8_t rx_segment_tab[256];
    /**
     * => Emission settings
     */
    uint32_t tx_fifo_size[PWRFIP_MAX_TX_MSG_FIFO_COUNT];
    uint8_t tx_max_repeat;
};

struct pwrfip_var_cons_cfg {
    uint16_t payload_bsz;
    uint16_t flags;
    uint32_t promptness_ustime;
    uint32_t evt_type;
};

struct pwrfip_var_prod_cfg {
    uint16_t payload_bsz;
    uint16_t flags;
    uint32_t refreshment_ustime;
    uint32_t evt_type;
};

struct pwrfip_var_sync_cfg {
    uint32_t reserved[3];
};

struct pwrfip_var_cfg {
    enum pwrfip_var_type type;
    uint16_t id;
    union {
        struct pwrfip_var_cons_cfg cons;
        struct pwrfip_var_prod_cfg prod;
        struct pwrfip_var_sync_cfg sync;
    };
    void (* pwrfip_var_handler) (
        struct pwrfip_node *node,
        struct pwrfip_var *var,
        struct pwrfip_event *evt
    );
};

struct pwrfip_node {
    struct pwrfip_node_infos *infos;
    void *priv;
};

struct pwrfip_var {
    uint16_t id;
    uint16_t bsz;
    uint8_t *buffer;
    uint8_t error;
    void *priv;
};