can_man.h

Go to the documentation of this file.

#ifndef INCLUDE_JBUS_CAN_DEV_H_
#define INCLUDE_JBUS_CAN_DEV_H_

#include "das_clt.h"
#include "sja1000.h"
#include <sys/iomsg.h>
#include <sys/iofunc.h>
#include "utils/common.h"
#include "utils/buffer.h"


#define MAX_MSG_BUF 1000


/* Macros used when processing can messages. */
#define PATH_CAN_ID(j)  ((((j)->priority & 0x7) << 26) | \
            (((j)->reserved & 0x1) << 25) | \
            (((j)->data_page & 0x1) << 24) | \
            (((j)->pdu_format & 0xff) << 16) | \
            (((j)->pdu_specific & 0xff) << 8) | \
            (((j)->src_address & 0xff)))                
#define PATH_CAN_PRIORITY(j)    (((j) >> 26) & 0x7)     
#define PATH_CAN_PF(j)          (((j) >> 16) & 0xff)    
#define PATH_CAN_PS(j)          (((j) >> 8) & 0xff)     
#define PATH_CAN_SA(j)          ((j) & 0xff)            
/* most significant bit sets frame as extended */
#define IS_EXTENDED_FRAME(MSG)      ((MSG).id &  0x80000000)    
#define SET_EXTENDED_FRAME(MSG)     ((MSG).id |= 0x80000000)    
#define CAN_ID(MSG)                 ((MSG).id & ~0x80000000)    
typedef struct {
    unsigned long id;       
    BYTE size;              
    BYTE data[8];           
    int error;              
} can_msg_t;


typedef struct {
    unsigned long id;       
    unsigned long mask;     
} can_filter_t;


typedef struct {
    int fd;
    int channel_id;
    int flags;
    std::string filename;
} can_dev_handle_t;


typedef struct {
    int port;                   
    int irq;                    
    int use_extended_frame;     
    int bit_speed;              
    int intr_id;                
    can_filter_t filter;        
} can_info_t;


typedef struct {
    unsigned int shadow_buffer_count;   
    unsigned int intr_in_handler_count; 
    unsigned int rx_interrupt_count;    
    unsigned int rx_message_lost_count; 
    unsigned int tx_interrupt_count;    
} can_err_count_t;


typedef struct
{
    iofunc_ocb_t io_ocb;    
    int rcvid;              
    sigevent clt_event;     
} can_ocb_t;


/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */


#define DEFAULT_CONFIG   "realtime.ini"

#define DEFAULT_DEVICE   "/dev/can1"

#define INI_IRQ_ENTRY    "Irq"

#define INI_PORT_ENTRY   "Port"

#define INI_EXT_ENTRY    "Ext"

#define DEFAULT_IRQ      0

#define DEFAULT_PORT     0x210

#define DEFAULT_QSIZE    150


class CANDeviceManager
{
public:
    int can_timeout_count = 0;

    int tx_buffer_flush = 0;

    int can_notify_client_err = 0;

    int mask_count_non_zero = 0;

    virtual void init(unsigned int base_address, unsigned int bit_speed,
            BYTE extended_frame);

    virtual int interrupt(CircularBuffer *in_buff, CircularBuffer *out_buff,
            can_filter_t filter);

    virtual void send(CircularBuffer *out_buff);

    virtual can_msg_t read(CircularBuffer *in_buff);

    virtual int write(CircularBuffer *out_buff, can_msg_t *pmsg);

    virtual can_err_count_t clear_errs();

    virtual can_err_count_t get_errs();

    virtual void tx_process_interrupt(CircularBuffer *out_buff);

    virtual void rx_process_interrupt(CircularBuffer *in_buff,
            can_filter_t filter);

    virtual ~CANDeviceManager();

private:
    int _baud[MAX_CHANNELS]                 = { 0x0 };
    unsigned int _acc_code[MAX_CHANNELS]    = { 0x0 };
    unsigned int _acc_mask[MAX_CHANNELS]    = { 0x0 };

    time_t _last_time_can_sent;

    can_err_count_t _errs;

    canregs_t *_base_addr;

    virtual int _start_chip(int minor);

    int _stop_chip(int minor);


    virtual int _reset_chip(int minor);

    virtual int _set_timing(int minor, int baud);

    virtual int _set_mask(int minor, unsigned int code, unsigned int mask);

    /* Set value of the output control register.
     *
     * @param minor
     *      index of the current device within the channels
     * @param arg
     *      value to set the output control register to
     * @return
     *      0 for success, or -1 if an error occurs
     */
    int _set_omode(int minor, int arg);

    /* Set listen-only mode.
     *
     * In listen-only mode, the CAN module is able to receive messages without
     * giving an acknowledgment. Since the module does not influence the CAN bus
     * in this mode the host device is capable of functioning like a monitor or
     * for automatic bit-rate detection.
     *
     * Must be done after CMD_START(CAN_StopChip) and before
     * CMD_START(CAN_StartChip).
     *
     * @param minor
     *      index of the current device within the channels
     * @param arg
     *      if 1 the canmode variable is set, otherwise it is reset
     * @return
     *      0 for success, or -1 if an error occurs
     */
    int _set_listen_only_mode(int minor, int arg);
};


/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */


typedef struct
{
    CANDeviceManager *can_dev;  
    iofunc_attr_t io_attr;      
    char *devname;              
    can_info_t can_info;        
    CircularBuffer *in_buff;    
    CircularBuffer *out_buff;   
    can_ocb_t *notify_pocb;     
    bool verbose_flag;          
    sigevent hw_event;          
} can_attr_t;


/* Forward declarations needed so new IOFUNC_OCB_T and IOFUNC_ATTR_T defines
 * can be used in sys/iofunc.h */

#ifndef IOFUNC_OCB_T
#define IOFUNC_OCB_T can_ocb_t
#endif

#undef IOFUNC_ATTR_T
#define IOFUNC_ATTR_T can_attr_t


/* -------------------------------------------------------------------------- */
/* ----------------------- Implemented in can_if.cpp ------------------------ */
/* -------------------------------------------------------------------------- */


extern int can_dev_arm(resmgr_context_t *ctp, iofunc_ocb_t *io_ocb,
        sigevent event);


/* -------------------------------------------------------------------------- */
/* ---------------------- Implemented in can_init.cpp ----------------------- */
/* -------------------------------------------------------------------------- */


extern void pulse_init(dispatch_t *dpp, IOFUNC_ATTR_T *pattr);


/* -------------------------------------------------------------------------- */
/* ----------------------- Implemented in io_func.cpp ----------------------- */
/* -------------------------------------------------------------------------- */


extern int io_devctl(resmgr_context_t *ctp, io_devctl_t *msg,
        RESMGR_OCB_T *io_ocb);


extern int io_open(resmgr_context_t *ctp, io_open_t *msg,
    RESMGR_HANDLE_T *handle, void *extra);


#endif /* INCLUDE_JBUS_CAN_DEV_H_ */