hal_ipmac.h

#include "in_config.h"
#include <stdint.h>
#if !CFG_NO_OS
#include "cmsis_os.h"
#endif
#include "./hal/hal_power.h"
#include "ipmac.h"

#ifndef HAL_IPMAC_H
#define HAL_IPMAC_H

#if !CFG_NO_OS
#define SEMA_NUM (2*(CFG_IPMAC_MAX_SLV_NUM + 1 + 1))
#define BC_SEMA 0
#define BCA_SEMA 1
#define PDU_SEMA 2
#endif

#define BC_INT_BUF_LEN 7 //For hopping

enum ipmac_queue_prio {
    IPMAC_HIGH_PRI_QID = 0,
    IPMAC_LOW_PRI_QID = 1,
};

typedef struct {
    int mode; 
    int slv_num; 
    int slot_time; 
    int phy_rate; 
    uint32_t access_addr; 
    int irq_prio; 
    int single_rx; 
    int same_len; 
    uint8_t hopping_en; 
    uint8_t rssi_scan_en; 
    uint8_t join_en; 
} ipmac_init_t;

typedef struct {
    void (*prev_irq_cb)(void* arg, uint32_t status);    
    void *prev_irq_arg; 
    void (*post_irq_cb)(void* arg, uint32_t status); 
    void *post_irq_arg; 
    void (*rx_cb)(void *arg, int slv_id, int llid, uint8_t *buffer, uint16_t buffer_len); 
    void *rx_arg; 
    void (*tx_cb)(void* arg, int slv_id, int type, int order); 
    void *tx_arg; 
    void (*status_cb)(uint32_t status,uint8_t slv_id); 
} ipmac_mst_cb_t;

typedef struct {
    void (*prev_irq_cb)(void* arg, uint32_t status); 
    void *prev_irq_arg; 
    void (*post_irq_cb)(void* arg, uint32_t status); 
    void *post_irq_arg; 
    void (*rx_cb)(void *arg, int type, int llid, uint8_t *buffer, uint16_t buffer_len); 
    void *rx_arg; 
    void (*tx_cb)(void* arg, int order); 
    void *tx_arg; 
    void (*status_cb)(uint32_t status); 
    void (*sync_status_cb)(void *arg, uint32_t status);
} ipmac_slv_cb_t;

typedef struct {
    int type; 
    int slv_id; 
    uint8_t *buf; 
    uint16_t buf_len; 
    uint32_t tmo; 
    void *arg; 
    void (*callback)(void *arg, int type, int slv_id, int status); 
} ipmac_mst_tx_t;

typedef struct {
    int type; 
    int slv_id; 
    uint8_t *buf; 
    uint16_t buf_len; 
    int prio; 
} ipmac_mst_prio_tx_t;

typedef struct {
    uint8_t *buf; 
    uint16_t buf_len; 
    uint32_t tmo; 
    void *arg; 
    void (*callback)(void *arg, int status); 
} ipmac_slv_tx_t;

typedef struct {
    uint8_t *buf; 
    uint16_t buf_len; 
    uint32_t prio; 
} ipmac_slv_prio_tx_t;

typedef struct {
    int en_low_prio; 
    uint16_t item_num; 
    uint16_t pdu_sz; 
    uint8_t max_retry; 
} ipmac_queue_t;

typedef struct {
    uint8_t *sync; 
    int sync_len; 
    uint8_t *sync_loss; 
    int sync_loss_len; 
} ipmac_freq_tab_t;


typedef struct {
    int slv_id; 
    int type; 
    uint32_t tmo; 
    uint32_t access_addr; 
    ipmac_offset_param_t offset; 
    void *arg;
    void (*callback)(void *arg, int type, int slv_id, int status);
} ipmac_update_remote_t;

typedef struct {
    int slot_time; 
    int phy_rate; 
    int slv_num; 
    uint32_t access_addr; 
    ipmac_offset_param_t offset; 
} ipmac_mst_update_cfg_t;

typedef struct {
    int slot_time; 
    int phy_rate; 
    int slv_id; 
    uint32_t access_addr; 
    ipmac_offset_param_t offset; 
} ipmac_slv_update_cfg_t;

typedef struct {
    pkt_len_t tx_pdu_len[CFG_IPMAC_MAX_SLV_NUM];
    pkt_len_t resp_pdu_len[CFG_IPMAC_MAX_SLV_NUM];

#if !CFG_NO_OS
    osSemaphoreId semaphore[SEMA_NUM];
    uint32_t sma[2*SEMA_NUM];
    uint8_t wait[SEMA_NUM];
#endif
    void *tx_bc_arg;
    void (*tx_bc_cb)(void *arg, int type, int slv_id, int status);
    void *tx_bca_arg;
    void (*tx_bca_cb)(void *arg, int type, int slv_id, int status);
    void *tx_pdu_arg[CFG_IPMAC_MAX_SLV_NUM];
    void (*tx_pdu_cb[CFG_IPMAC_MAX_SLV_NUM])(void *arg, int type, int slv_id, int status);

    char queue_en[CFG_IPMAC_MAX_SLV_NUM];
    char low_prio_en[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t tx_e_cnt[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t tx_o_cnt[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t tx_e_prio[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t tx_o_prio[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t tx_max_retry[CFG_IPMAC_MAX_SLV_NUM];//for low priority
    void *mst_tx_arg;
    void (*mst_tx_cb)(void* arg, int type, int order, int slv_id);
    void *mst_rx_arg;
    void (*mst_rx_cb)(void *arg, int slv_id, int llid, uint8_t *buffer, uint16_t buffer_len);
    void (*mst_status_cb)(uint32_t status,uint8_t slv_id);
    #if !IPMAC_USE_SN
    //uint8_t state[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t tx_bc_order;
    uint8_t tx_bca_order;
    uint8_t tx_pdu_order[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t rx_pdu_order[CFG_IPMAC_MAX_SLV_NUM];
    //uint8_t extra_order;
    #endif
    uint8_t tx_bc_e_req;
    uint8_t tx_bc_o_req;
    uint8_t tx_bca_e_req;
    uint8_t tx_bca_o_req;
    uint8_t tx_pdu_e_req[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t tx_pdu_o_req[CFG_IPMAC_MAX_SLV_NUM];
    uint8_t irq_rx_slv_id;

    uint8_t *bc_app_buf;
    pkt_len_t bc_app_buf_max_len;
    pkt_len_t bc_app_buf_len;
    int bc_cont_tx;
#if BC_INT_BUF_LEN
    pkt_len_t bc_int_buf_len;
    uint8_t bc_int_buf[BC_INT_BUF_LEN];
#endif
} ipmac_mst_dev_t;
typedef struct {
    pkt_len_t tx_pdu_len;
    pkt_len_t resp_pdu_len;

#if !CFG_NO_OS
    osSemaphoreId semaphore[2];
    uint32_t sma[2*2];
    uint8_t wait[2];
#endif
    void *tx_arg;
    void (*tx_cb)(void *arg, int status);
    char queue_en;
    char low_prio_en;
    uint16_t tx_e_cnt;
    uint16_t tx_o_cnt;
    uint8_t tx_e_prio;
    uint8_t tx_o_prio;
    uint8_t tx_max_retry;//for low priority
    void *slv_rx_arg;
    void (*slv_rx_cb)(void *arg, int type, int llid, uint8_t *buffer, uint16_t buffer_len);
    void *slv_tx_arg;
    void (*slv_tx_cb)(void*arg, int order);
    void (*slv_status_cb)(uint32_t status);
    void (*slv_sync_status_cb)(void *arg, uint32_t status);
    #if !IPMAC_USE_SN   
    uint8_t resp_tx_order;
    uint8_t extra_tx_order;
    uint8_t bc_order;
    uint8_t bca_order;
    //uint8_t extra_pdu_order;
    #endif
    uint8_t resp_tx_e_req;
    uint8_t resp_tx_o_req;
    uint8_t extra_tx_e_req;
    uint8_t extra_tx_o_req;
    uint8_t rx_pdu_order;
} ipmac_slv_dev_t;
typedef struct {
#if !CFG_NO_OS
    osMutexId mutex;
#endif
    int mode;
    int slv_num;
    int slot_time;
    int phy_rate;
    uint32_t access_addr;

    int used;
    int slv_id;
    int sync_status;
    int16_t inst_rssi[CFG_IPMAC_MAX_SLV_NUM];
    uint16_t frame_duration;
    uint16_t slv_frame_oft[CFG_IPMAC_MAX_SLV_NUM];
    uint16_t resp_frame_oft;

    int bcn_margin;
    int slv_margin;
    uint8_t single_rx;
    uint8_t same_len;       
    uint8_t hopping_en; 
    uint8_t sync_tbl[32]; 
    int sync_len; 
    uint8_t sync_loss_tbl[32]; 
    int sync_loss_len; 
    uint8_t rssi_scan_en;
    uint8_t join_en;
    uint8_t join_start;

    void (*prev_irq_cb)(void* arg, uint32_t status); 
    void *prev_irq_arg; 
    void (*post_irq_cb)(void* arg, uint32_t status); 
    void *post_irq_arg; 


    pkt_len_t bc_len;
    pkt_len_t bca_len;
    ipmac_mst_dev_t mst;
    ipmac_slv_dev_t slv;
    ipmac_mem_t mm;
    #if CFG_PM_EN
    int power_state;
    struct pm_module pmd;
    #endif
} ipmac_dev_t;

typedef struct {
    uint8_t ctrl_pdu_type;
    uint8_t payload[];
} ipmac_ctrl_pdu_t;
/*
 * APIs
 ****************************************************************************************
 */
ipmac_dev_t* hal_ipmac_open(ipmac_init_t* para);

void hal_ipmac_close(ipmac_dev_t* pd);

int hal_ipmac_mst_cfg(ipmac_dev_t* pd,  ipmac_offset_param_t *offset);

int hal_ipmac_slv_cfg(ipmac_dev_t* pd, int slv_id, ipmac_offset_param_t *offset);

int hal_ipmac_set_freq_table(ipmac_dev_t* pd, ipmac_freq_tab_t* tab);

int hal_ipmac_mst_start(ipmac_dev_t* pd);

int hal_ipmac_slv_start(ipmac_dev_t* pd);

int hal_ipmac_mst_tx(ipmac_dev_t* pd, ipmac_mst_tx_t *para);

int hal_ipmac_slv_tx(ipmac_dev_t* pd, ipmac_slv_tx_t* para);


int hal_ipmac_slv_prio_tx(ipmac_dev_t* pd, ipmac_slv_prio_tx_t* para);

int hal_ipmac_mst_udpate_remote_offset(ipmac_dev_t* pd, ipmac_update_remote_t* update);

int hal_ipmac_mst_stop(ipmac_dev_t* pd);

int hal_ipmac_mst_set_cb(ipmac_dev_t* pd,  ipmac_mst_cb_t* cb);

int hal_ipmac_slv_set_cb(ipmac_dev_t* pd,  ipmac_slv_cb_t* cb);

int hal_ipmac_slv_stop(ipmac_dev_t* pd);

int hal_ipmac_slv_en_queue(ipmac_dev_t* pd, ipmac_queue_t *para);

int hal_ipmac_slv_dis_queue(ipmac_dev_t* pd);

int hal_ipmac_mst_en_queue(ipmac_dev_t* pd, int slv_id, ipmac_queue_t *para);

int hal_ipmac_mst_dis_queue(ipmac_dev_t* pd, int slv_id);


int hal_ipmac_mst_ota_tx(ipmac_dev_t* pd, ipmac_mst_tx_t *para);

int hal_ipmac_bc_int_set(ipmac_dev_t* pd, uint8_t *data, uint16_t len);

int hal_ipmac_set_bc_buf(ipmac_dev_t* pd,  uint8_t *buf, uint16_t max_len);

int hal_ipmac_mst_bc_cont_tx(ipmac_dev_t* pd, uint8_t *buffer, uint16_t buffer_len);

int hal_ipmac_slv_status(ipmac_dev_t* pd);

uint32_t  hal_ipmac_frame_time(ipmac_dev_t* pd);

int16_t  get_rssi(void);
int ipmac_get_rssi(int id);

uint32_t hal_ipmac_convert_sf_timestamp(ipmac_dev_t* pd, uint32_t sf_reg);

int hal_ipmac_enable_intr(ipmac_dev_t* pd, uint32_t intr_src);

int hal_ipmac_disable_intr(ipmac_dev_t* pd, uint32_t intr_src);

int hal_ipmac_set_sync(ipmac_dev_t* pd, uint8_t addr_idx, uint32_t address);
int hal_ipmac_set_resp_sync(ipmac_dev_t* pd, uint8_t addr_idx, uint32_t address);
int hal_ipmac_sync_sel(ipmac_dev_t* pd, uint8_t addr_idx, uint8_t sf_idx);

int hal_ipmac_resp_sync_sel(ipmac_dev_t* pd, uint8_t addr_idx, uint8_t sf_idx);

int hal_ipmac_sync_sel_clear(ipmac_dev_t* pd);

int hal_ipmac_resp_sync_sel_clear(ipmac_dev_t* pd);



#endif