controller.h

浏览该文件的文档.

 
#ifndef __xwcd_ds_can_controller_h__
#define __xwcd_ds_can_controller_h__
 
#include <xwcd/ds/standard.h>
#include <xwos/lib/xwbop.h>
#include <xwos/osal/lock/spinlock.h>
#include <xwos/osal/sync/sem.h>
#include <xwcd/ds/device.h>
#include <xwcd/ds/i2c/peripheral.h>
#include <xwcd/ds/spi/peripheral.h>
 
#if defined(XWCDCFG_ds_CAN_CONTROLLER_ROCBT) && (1 == XWCDCFG_ds_CAN_CONTROLLER_ROCBT)
#  define __xwds_canc_cbtbl_qualifier const
#else
#  define __xwds_canc_cbtbl_qualifier
#endif
 
#define XWDS_CANC_RXQNUM        (XWCDCFG_ds_CAN_CONTROLLER_RXQNUM)
#define XWDS_CANC_SDU_MAXSIZE   (XWCDCFG_ds_CAN_CONTROLLER_SDU_MAXSIZE)
 
enum xwds_can_msgflag_em {
        XWDS_CAN_MSG_F_EXID = (1U), 
        XWDS_CAN_MSG_F_REMOTE = (2U), 
};
 
struct xwds_can_msg {
        xwu32_t id; 
        xwsq_t flag; 
        xwsz_t dlc; 
        xwu8_t sdu[XWDS_CANC_SDU_MAXSIZE]; 
};
 
struct xwds_canc_bd_cfg {
        xwid_t id; 
        xwu32_t bdkb; 
        struct {
                xwu8_t ss; 
                xwu8_t pts; 
                xwu8_t ps1; 
                xwu8_t ps2; 
                xwu8_t sjw; 
        } time_seg; 
};
 
enum xwds_canc_hwobj_type_em {
        XWDS_CANC_HWOBJ_T_ID_STD = XWBOP_BIT(0), 
        XWDS_CANC_HWOBJ_T_ID_EXT = XWBOP_BIT(1), 
        XWDS_CANC_HWOBJ_T_ID_MIXED = XWBOP_BIT(0) | XWBOP_BIT(1), 
};
 
struct xwds_canc_txobj_cfg {
        xwid_t objid; 
        xwsq_t type; 
};
 
struct xwds_canc_rxobj_cfg {
        xwid_t objid; 
        xwsq_t type; 
        void * soc_hwfilter_cfgs; 
        xwsz_t soc_hwfilter_cfgs_num; 
};
 
struct xwds_canc_cfg {
        const struct xwds_canc_bd_cfg * bdcfgs; 
        xwsz_t bdcfgs_num; 
        xwid_t default_bdid; 
        const struct xwds_canc_txobj_cfg * txobjs; 
        xwsz_t txobjs_num; 
        const struct xwds_canc_rxobj_cfg * rxobjs; 
        xwsz_t rxobjs_num; 
        void * xwccfg; 
};
 
enum xwds_canc_mode_em {
        XWDS_CANC_MODE_MIN = 0,
        XWDS_CANC_MODE_UNINIT = XWDS_CANC_MODE_MIN, 
        XWDS_CANC_MODE_STOPPED, 
        XWDS_CANC_MODE_STARTED, 
        XWDS_CANC_MODE_SLEEP, 
        XWDS_CANC_MODE_NUM, 
};
 
enum xwds_canc_err_em {
        CANC_ERR_NOERR = 0,
        CANC_ERR_BUS, 
        CANC_ERR_STUFF, 
        CANC_ERR_FORM, 
        CANC_ERR_ACK, 
        CANC_ERR_CRC, 
        CANC_ERR_B1, 
        CANC_ERR_B0, 
        CANC_ERR_ACKDELIMITER, 
        CANC_ERR_PASSIVE, 
        CANC_ERR_WARNING, 
};
 
struct xwds_canc;
 
struct xwds_canc_driver {
        struct xwds_driver base; 
        xwer_t (* write)(struct xwds_canc *, const struct xwds_canc_txobj_cfg *,
                         struct xwds_can_msg *); 
        xwer_t (* set_mode)(struct xwds_canc *, xwsq_t); 
        xwer_t (* set_bd)(struct xwds_canc *,
                          const struct xwds_canc_bd_cfg *); 
        xwer_t (* enable_irqs)(struct xwds_canc *); 
        xwer_t (* disable_irqs)(struct xwds_canc *); 
};
 
struct xwds_canc_cbtbl {
        void (* tx_indication)(struct xwds_canc *, xwid_t,
                               xwer_t); 
        void (* rx_indication)(struct xwds_canc *, xwid_t,
                               struct xwds_can_msg *); 
        void (* wakeup_notification)(struct xwds_canc *); 
        void (* mode_indication)(struct xwds_canc *, xwsq_t); 
        void (* err_indication)(struct xwds_canc *, xwsq_t,
                                xwsq_t, xwsq_t); 
        void (* busoff_indication)(struct xwds_canc *); 
};
 
struct xwds_canc_rxqueue {
        struct xwds_can_msg q[XWDS_CANC_RXQNUM]; 
        struct xwos_sem sem; 
        struct xwos_splk lock; 
        xwssq_t pos; 
        xwssz_t num; 
};
 
struct xwds_canc {
        union { /* union中继承多个基类相当于C++中的virtual继承，
                   struct xwds_device只继承一次。 */
                struct xwds_device dev; 
#if (defined(XWCDCFG_ds_I2C_PERIPHERAL) && (1 == XWCDCFG_ds_I2C_PERIPHERAL))
                struct xwds_i2cp i2cp; 
#endif
#if (defined(XWCDCFG_ds_SPI_PERIPHERAL) && (1 == XWCDCFG_ds_SPI_PERIPHERAL))
                struct xwds_spip spip; 
#endif
        } bc; 
        /* attributes */
        const struct xwds_canc_cfg * cfg; 
        __xwds_canc_cbtbl_qualifier struct xwds_canc_cbtbl * cbtbl; 
        /* private */
        xwsq_t mode; 
};
 
void xwds_canc_construct(struct xwds_canc * canc);
 
void xwds_canc_destruct(struct xwds_canc * canc);
 
xwer_t xwds_canc_grab(struct xwds_canc * canc);
 
xwer_t xwds_canc_put(struct xwds_canc * canc);
 
xwer_t xwds_canc_write(struct xwds_canc * canc, xwid_t txobjid,
                       struct xwds_can_msg * msg);
 
xwer_t xwds_canc_enable_irqs(struct xwds_canc * canc);
 
xwer_t xwds_canc_disable_irqs(struct xwds_canc * canc);
 
xwer_t xwds_canc_set_mode(struct xwds_canc * canc, xwsq_t mode);
 
xwer_t xwds_canc_set_bd(struct xwds_canc * canc, xwid_t bdcfgid);
 
void xwds_canc_setcb_tx_indication(struct xwds_canc * canc,
                                   void (*cb)(struct xwds_canc *,
                                              xwid_t, xwer_t));
 
void xwds_canc_setcb_rx_indication(struct xwds_canc * canc,
                                   void (*cb)(struct xwds_canc *,
                                              xwid_t,
                                              struct xwds_can_msg *));
 
void xwds_canc_setcb_wakeup_notification(struct xwds_canc * canc,
                                         void (*cb)(struct xwds_canc *));
 
void xwds_canc_setcb_mode_indication(struct xwds_canc * canc,
                                     void (*cb)(struct xwds_canc *, xwsq_t));
 
void xwds_canc_setcb_err_indication(struct xwds_canc * canc,
                                    void (*cb)(struct xwds_canc *,
                                               xwsq_t, xwsq_t, xwsq_t));
 
void xwds_canc_setcb_busoff_indication(struct xwds_canc * canc,
                                       void (*cb)(struct xwds_canc *));
 
/******** ******** RX Queue ******** ********/
void xwds_canc_rxq_init(struct xwds_canc_rxqueue * rxq);
 
void xwds_canc_rxq_publish(struct xwds_canc_rxqueue * rxq,
                           struct xwds_can_msg * msg);
 
xwer_t xwds_canc_rxq_acquire(struct xwds_canc_rxqueue * rxq,
                             struct xwds_can_msg * buf,
                             xwtm_t to);
 
/******** ******** Callbacks for driver ******** ********/
void xwds_canc_drvcb_init_msg(struct xwds_can_msg * msg, xwu32_t canid,
                              xwsq_t flag, xwsz_t dlc, xwu8_t sdu[]);
 
void xwds_canc_drvcb_tx_indication(struct xwds_canc * canc,
                                   xwid_t txobjid,
                                   xwer_t rc);
 
void xwds_canc_drvcb_rx_indication(struct xwds_canc * canc,
                                   xwid_t rxobjid,
                                   struct xwds_can_msg * rxmsg);
 
void xwds_canc_drvcb_wakeup_notification(struct xwds_canc * canc);
 
void xwds_canc_drvcb_mode_indication(struct xwds_canc * canc,
                                     xwsq_t mode);
 
void xwds_canc_drvcb_err_indication(struct xwds_canc * canc,
                                    xwsq_t errcode,
                                    xwsq_t tec,
                                    xwsq_t rec);
 
void xwds_canc_drvcb_busoff_indication(struct xwds_canc * canc);
 
#endif /* xwcd/ds/can/controller.h */