T536_DTU/app_public/fuxi_public/fuxi_bsp/source/flexcan.c

/******************************************************************************
版权所有：	
文件名称：	flexcan.c
文件版本：	01.01
创建作者:	sunxi
创建日期：	2025-09-28
功能说明：	FLEXCAN驱动
其它说明：
修改记录：
*/
/*------------------------------- 头文件 --------------------------------------
*/
#include "bspconfig.h"
#include "rt_printf.h"
#include "ustimer.h"
#include "rt.h"
#include "flexcan.h"
#include <string.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <sys/prctl.h>
#include <unistd.h>

#ifdef BSP_CAN_ENABLE

 
/*------------------------------- 宏定义 --------------------------------------
*/

#define CAN_FIFO

// 优先级
#define CAN_PRIO_MAX					4

// 短帧BUF
#define CAN_FRAME_NUM					256 // CAN短帧BUF数量
#define CAN_FRAME_LEN					16  // CAN短帧BUF长度
#define CAN_FRAME_HEAD_LEN				8	// CAN短帧帧头长度
#define CAN_FRAME_DATA_LEN				8	// CAN短帧数据长度

// 长帧BUF
#define CAN_LONGFRAME_NUM				16	// CAN长帧BUF数量
#define CAN_LONGFRAME_LEN				CAN_FRAME_LEN_MAX	// CAN长帧BUF长度
#define CAN_LONGFRAME_HEAD_LEN			4   // CAN长帧头长度
#define CAN_LONGFRAME_DATA_LEN			(CAN_LONGFRAME_LEN-CAN_LONGFRAME_HEAD_LEN)   // CAN长帧数据长度

// 帧标志,数字越小，优先级越高
#define CAN_FRAME_SINGLE				0 // 单帧（既是起始帧，又是结束帧）
#define CAN_FRAME_END					1 // 结束帧
#define CAN_FRAME_MIDDLE				2 // 中间帧
#define CAN_FRAME_BEGIN					3 // 开始帧

//帧ID中各个域的位偏移
#define CAN_FRAME_OFFSET_SN				0    // 帧序号偏移
#define CAN_FRAME_OFFSET_MARK			6    // 帧标志偏移
#define CAN_FRAME_OFFSET_SRC			8    // 帧源地址偏移
#define CAN_FRAME_OFFSET_DST			12   // 帧目的地址偏移
#define CAN_FRAME_OFFSET_TYPE			16   // 帧类型偏移
#define CAN_FRAME_OFFSET_PRIOR			23 	 // 帧优先级偏移(帧优先级是帧类型的高2位)
#define CAN_FRAME_OFFSET_LEN			16   // 帧长度偏移

#define CAN_FRAME_MASK_SN				0X3F // 帧序号屏蔽位
#define CAN_FRAME_MASK_MARK				0X03 // 帧标志屏蔽位
#define CAN_FRAME_MASK_SRC				0X0F // 帧源地址屏蔽位
#define CAN_FRAME_MASK_DST				0X0F // 帧目的地址屏蔽位
#define CAN_FRAME_MASK_TYPE				0XFF // 帧类型屏蔽位
#define CAN_FRAME_MASK_PRIOR			0X03 // 帧优先级屏蔽位(帧优先级是帧类型的高2位)
#define CAN_FRAME_MASK_LEN				0X0F // 帧长度屏蔽位

// 缓冲区为空
#define CAN_BUF_EMPTY(ring) ((ring)->head == (ring)->tail)
// 缓冲区满
#define CAN_BUF_FULL(ring, size) (((unsigned char)((ring)->head - (ring)->tail)) == ((unsigned char)(size - 1)))
// 缓冲区剩余空间
#define CAN_BUF_SPACE(ring, size) (((unsigned char)((ring)->tail - (ring)->head) - 1) & (unsigned char)(size - 1))

// 强制中断寄存器
#define REG_MCF_INTFRCL1 (*(volatile unsigned int *)(0xFC04C014))

// 调试开关
// #define CAN_DEBUG
#ifdef CAN_DEBUG
#define can_printf(x...) rt_printf(x)
#else
#define can_printf(x...)
#endif

// 打印报文
#ifdef CAN_DEBUG
#define can_print_mem(x...) print_mem_time(x)
#else
#define can_print_mem(x...)
#endif

/*------------------------------ 类型结构 -------------------------------------
 */
typedef enum
{
    CAN_1,
    CAN_2,
    CAN_RES
} can_type;

// CANFD 基地址
static unsigned int g_rt_canfd_baseaddr[RT_CAN_NUM][RT_CAN_DEV_TYPE] =
    {
        {RT_M_CAN0, RT_M_RAM0, RT_M_TOP0, RT_M_DMA0},
        {RT_M_CAN1, RT_M_RAM1, RT_M_TOP1, RT_M_DMA1},
        {RT_M_CAN2, RT_M_RAM2, RT_M_TOP2, RT_M_DMA2},
        {RT_M_CAN3, RT_M_RAM3, RT_M_TOP3, RT_M_DMA3},

};

// 保证所有结构的大小都是4的倍数
// 长帧缓冲区
struct can_longframe_buf
{
    unsigned char head; // 头位置
    unsigned char tail; // 尾位置
    unsigned char reserverd[2];
    unsigned char buf[CAN_LONGFRAME_NUM][CAN_LONGFRAME_LEN];
};

// 缓冲区描述符
struct can_buf
{
    unsigned char head;    // 头位置
    unsigned char tail;    // 尾位置
    unsigned char frameno; // 帧序号
    unsigned char reserverd;
    unsigned char buf[CAN_FRAME_NUM][CAN_FRAME_LEN];
};

// CAN统计信息数据结构
struct can_dev_stats
{
    uint32_t rx_shortframes; // 接收短帧数
    uint32_t tx_shortframes; // 发送短帧数
    uint32_t rx_longframes;  // 接收长帧数
    uint32_t tx_longframes;  // 发送长帧数
    uint32_t rx_dropped;     // 接收缓冲区满溢出次数
    uint32_t tx_dropped;     // 发送缓冲区满溢出次数
    uint32_t hw_bus_errors;
    uint32_t overrun;
    uint32_t max_mbcnt;    // 统计最大的未处理的MB个数
    uint32_t max_proctime; // 处理MB的最大时间
};

#if 0
//短帧描述符
struct can_shortframe_des
{
	unsigned char info;
	unsigned char flag1;
	unsigned char srcaddr;
	unsigned char dstaddr;
	unsigned char frameno;
	unsigned char data[8];
	unsigned char reserved[3];	
};
#endif

// 时间戳差值数据结构
struct can_timestamp
{
    unsigned short timestamp; // 时间戳差值，该差值是指当前时间戳与有数据的MB的时间戳差值
    short caniflg_bit;        // MB下标即是那一个MB
};

// flexcan 设备数据结构
struct can_dev
{
    int can_sock;
    uint32_t no;
    uint32_t base_addr;

    struct can_dev_stats stats; // 网络统计信息

    struct can_timestamp ts[CAN_MB];                         // 记录各时间戳差值
    struct can_buf tx_buf[CAN_PRIO_MAX];                     // 发送缓冲区
    struct can_buf rx_buf[CAN_PRIO_MAX];                     // 接收缓冲区
    struct can_longframe_buf longframe_buf_rx[CAN_PRIO_MAX]; // 接收长帧缓冲区
};

/* Message type access macros.*/
#define FLEXCAN_SET_MODE_RETRIES 255

/* Message Buffer 0  configure as Tx */
#define SEND_BUF 15
#define SEND_BUF_BIT (1 << SEND_BUF)

/* Structure of the message buffer */
struct can_mb
{
    volatile u32 can_dlc;
    volatile u32 can_id;
    u8 data[8];
};

struct can_regs
{

    volatile u32 canmcr;   /* FLEXCAN 0x00 */
    volatile u32 canctrl;  /* FLEXCAN 0x04 */
    volatile u32 cantimer; /* FLEXCAN 0x08 */
    volatile u32 reserved1;
    volatile u32 canrxgmsk;  /* FLEXCAN 0x10 */
    volatile u32 canrx14msk; /* FLEXCAN 0x14 */
    volatile u32 canrx15msk; /* FLEXCAN 0x18 */
    volatile u32 canerrcnt;  /* FLEXCAN 0x1C */
    volatile u32 canerrstat; /* FLEXCAN 0x20 */
    volatile u32 reserved2;
    volatile u32 canimask; /* FLEXCAN 0x28 */
    volatile u32 reserved3;
    volatile u32 caniflg; /* FLEXCAN 0x30 */

    volatile u32 reserved4[19];
    struct can_mb cantxfg[CAN_MB];
    volatile u32 reserved5[448];
    volatile u32 rximr[CAN_MB];
};

/* @clock_src:
    1 = The FLEXCAN clock source is the onchip Bus Clock.
    0 = The FLEXCAN clock source is the chip Oscillator Clock.*/
struct can_platform_data
{
    unsigned int clock_src; /* FLEXCAN_CLKSRC_BUS or FLEXCAN_CLKSRC_XTAL */
    unsigned int clock_frq; /* can ref. clock, in Hz */
};

/*------------------------------ 全局变量 -------------------------------------
 */
// flexcan设备
int g_can_fd = -1;
static int bexit = 0;
static u8 g_can_tx_call[CAN_BUS_NUM] = {0};
pthread_t can_tid[CAN_BUS_NUM];
pthread_t can_tid_s[CAN_BUS_NUM];
unsigned g_can_mapped_size;
void *g_can_map_base[CAN_BUS_NUM], *g_can_virt_addr[CAN_BUS_NUM];

static struct can_dev g_can_dev[CAN_BUS_NUM] __attribute__((aligned(4)));

FN_CAN_RECV_CALLBACK g_can_recv_callback;

u8 g_app_buf_tx[CAN_PRIO_MAX][CAN_FRAME_LEN_MAX]; // 应用可根据优先级申请的长帧缓冲区

extern int g_print_can;
extern int g_print_can_monitor;

/*------------------------------ 函数声明 -------------------------------------
 */
static void can_soft_recv_data(int sock);
static int _can_set_reset_mode(struct can_dev *dev);
static int _can_set_normal_mode(struct can_dev *dev);
static int _can_set_bittiming(struct can_dev *dev);
static void _can_chipset_init(struct can_dev *dev, int clock_src);

static void _can_app_tx(int _no);
static void _can_app_rx(struct can_dev *dev, struct can_frame *frame);

void _can_isr_0(void);
void _can_isr_1(void);
void _can_isr_err_0(void);
void _can_isr_err_1(void);
int _can_irq_force(int no);
int _can_irq_clear(int no);
int _can_irq_is_force(int no);

/*------------------------------ 内部函数 -------------------------------------
 */
static int can_soft_send(int sock, struct can_frame frame)
{
    int nbytes;
    int wlen = sizeof(struct can_frame);
    int times = 2;

    while (times--)
    {
        nbytes = write(sock, &frame, wlen);
        if (nbytes != wlen)
        {
            // rt_printf("Send Error frame(nbytes:%d, wlen:%d)\n", nbytes, wlen);
            usleep(200);
            continue;
        }
        else
        {
            // printf("Send frame(nbytes:%d, wlen:%d)\n", nbytes, wlen);
            return (0);
        }
    }

    return -1;
}

static int can_send_data(can_type type, unsigned char *buf, int len)
{
    int i, j;
    int cnt;
    int sock;
    int ret = 0;
    struct can_frame frame;

    if (type == CAN_1)
    {
        // DEMO
        sock = g_can_dev[0].can_sock;
        frame.can_id = 0x100;
    }
    else
    {
        // DEMO
        sock = g_can_dev[1].can_sock;
        frame.can_id = 0x101;
    }

    for (i = 0; i < len; i += 8)
    {
        cnt = len - i;

        if (cnt > 8)
            frame.can_dlc = 8;
        else
            frame.can_dlc = cnt;

        for (j = 0; j < frame.can_dlc; j++)
        {
            frame.data[j] = buf[i + j];
        }

        if (can_soft_send(sock, frame) < 0)
        {
            ret = -1;
            break;
        }
    }

    return ret;
}

static void *can_proc_send(void *arg)
{
    int sock = *(int *)arg;

    int index = g_can_dev[0].can_sock == sock ? 0 : 1;
    if (index == 0)
    {
        prctl(PR_SET_NAME, "can_send_func0");
    }
    else
    {
        prctl(PR_SET_NAME, "can_send_func1");
    }

    while (!bexit)
    {
        if (main_mod_is_exit())
        {
            break;
        }

        switch (index)
        {
        case 0:
            // can_send_data(CAN_1, (unsigned char *)"hello stm32", strlen("hello stm32") - 1);
            _can_app_tx(0);
            break;

        case 1:
            _can_app_tx(1);
            // can_send_data(CAN_2, (unsigned char *)"hello stm32", strlen("hello stm32") - 1);
            break;

        default:
            break;
        }
        // xenomai内核中此处usleep(10)创建第二个线程会出问题
        // 延时太短导致CPU占用？改为1ms就正常了需验证动作时间
        usleep(1000);
    }
}

static void *can_proc_recv(void *arg)
{
    int nready;
    int maxfd;
    fd_set readfds;
    int sock = *(int *)arg;

    FD_ZERO(&readfds);
    FD_SET(sock, &readfds);
    maxfd = sock;

    int index = g_can_dev[0].can_sock == sock ? 0 : 1;
    if (index == 0)
    {
        prctl(PR_SET_NAME, "can_rev_func0");
    }
    else
    {
        prctl(PR_SET_NAME, "can_rev_func1");
    }

    while (!bexit)
    {
        if (main_mod_is_exit())
        {
            break;
        }

        nready = select(maxfd + 1, &readfds, NULL, NULL, NULL);
        if (nready < 0)
        {
            perror("can select");
            break;
        }
        else if (nready == 0)
        {
            continue;
        }

        /* data is ready */
        if (FD_ISSET(sock, &readfds))
        {
            can_soft_recv_data(sock);
        }
        else
        {
            ;
        }
    }
}

static int can_open(char *can_name)
{
    struct ifreq ifr;
    struct sockaddr_can addr;
    int sock;
    int ret = -1;
    int loopback = 0;
    //	struct can_filter rfilter[1];

    /* open socket */
    sock = socket(PF_CAN, SOCK_RAW, CAN_RAW);
    if (sock < 0)
    {
        return ret;
    }

    strcpy(ifr.ifr_name, can_name);
    if (ioctl(sock, SIOCGIFINDEX, &ifr) < 0)
    {
        goto err_can_open;
    }
    addr.can_family = AF_CAN;
    addr.can_ifindex = ifr.ifr_ifindex;
    //  fcntl(sock, F_SETFL, O_NONBLOCK);
    if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    {
        goto err_can_open;
    }

    // close loopback
    setsockopt(sock, SOL_CAN_RAW, CAN_RAW_LOOPBACK, &loopback, sizeof(loopback));
    /*
        rfilter[0].can_id = 0x12;
        rfilter[0].can_mask = CAN_SFF_MASK;
        setsockopt(sock, SOL_CAN_RAW, CAN_RAW_FILTER, &rfilter, sizeof(rfilter));
    */
    return sock;

err_can_open:
    close(sock);
    return ret;
}

static int can_soft_recv(int sock, struct can_frame *frame)
{
    int nbytes;

    nbytes = read(sock, frame, sizeof(struct can_frame));
    if (nbytes)
    {
        ; // printf("[can_recv]dlc = %d, nbytes = %d\n", frame->can_dlc, nbytes);
    }

    return nbytes;
}

static void can_soft_recv_data(int sock)
{
    static unsigned char tail = 0;
    int i;
    int can_id;
    unsigned char can_dlc;
    unsigned char *data;
    struct can_frame frame;
    int index = g_can_dev[0].can_sock == sock ? 0 : 1;

    if (can_soft_recv(sock, &frame) < 0)
        return;

    frame.can_id = frame.can_id & CAN_EFF_MASK;
    can_dlc = frame.can_dlc;
    data = frame.data;

    // printf("CAN%d dlc = %d, can_id = %x\ndata:", index,frame.can_dlc, frame.can_id);
    // for(i=0; i<frame.can_dlc; i++)
    //     printf("0x%02x ", frame.data[i]);
    // printf("\n");

    _can_app_rx(&g_can_dev[index], &frame);
}

/*------------------------------ 外部函数 -------------------------------------
外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
*/
int can_init(void)
{
    struct can_dev *dev;
    int i;
    off_t target;
    unsigned page_size, offset_in_page;
    unsigned width = 8 * sizeof(int);

    g_can_mapped_size = page_size = sysconf(_SC_PAGESIZE);
    offset_in_page = (unsigned)target & (page_size - 1);
    if (offset_in_page + width > page_size)
    {
        /* This access spans pages.
         * Must map two pages to make it possible: */
        g_can_mapped_size *= 2;
    }

    g_can_fd = open("/dev/mem", O_RDWR | O_SYNC);
    if (g_can_fd < 0)
    {
        printf("open(/dev/mem) failed.\n");
        return -1;
    }
    fflush(stdout);

    // 初始化缓冲区
    memset(g_can_dev, 0, sizeof(g_can_dev));

    for (i = 0; i < CAN_BUS_NUM; i++)
    {
        dev = &g_can_dev[i];
        dev->no = i;
        target = g_rt_canfd_baseaddr[i][0];

        if (i == 0)
        {
            /* CAN0 */
            g_can_map_base[i] = mmap(NULL, g_can_mapped_size, PROT_READ | PROT_WRITE, MAP_SHARED, g_can_fd, target & ~(off_t)(page_size - 1));
            if (g_can_map_base[i] == (void *)-1)
            {
                printf("can[%d] dev null pointer!\n", i);
            }
            else
            {
                printf("BSP can[%d] map Successfull!\n", i);
            }
            fflush(stdout);

            dev->base_addr = g_can_map_base[i];
        }
        else
        {
            /* CAN1 */
            g_can_map_base[i] = mmap(NULL, g_can_mapped_size, PROT_READ | PROT_WRITE, MAP_SHARED, g_can_fd, target & ~(off_t)(page_size - 1));
            if (g_can_map_base[i] == (void *)-1)
            {
                printf("can[%d] dev null pointer!\n", i);
            }
            else
            {
                printf("BSP can[%d] map Successfull!\n", i);
            }
            fflush(stdout);

            dev->base_addr = g_can_map_base[i];
        }

        /* set chip into reset mode */
        _can_set_reset_mode(dev);
        _can_set_bittiming(dev);

        // 申请实时中断
        if (i == 0)
        {
            rt_request_irq(CFG_CAN_VECTOR_BEGIN + 0, CFG_INT_LEVEL_CAN, _can_isr_0, "can_isr_0");
            rt_request_irq(CFG_CAN_VECTOR_BEGIN + 1, CFG_INT_LEVEL_CAN, _can_isr_err_0, "can_isr_err_00");
            rt_request_irq(CFG_CAN_VECTOR_BEGIN + 3, CFG_INT_LEVEL_CAN, _can_isr_err_0, "can_isr_err_01");
        }
        else
        {
            rt_request_irq(CFG_CAN_VECTOR_BEGIN + 4, CFG_INT_LEVEL_CAN, _can_isr_1, "can_isr_1");
            rt_request_irq(CFG_CAN_VECTOR_BEGIN + 5, CFG_INT_LEVEL_CAN, _can_isr_err_1, "can_isr_err_10");
            rt_request_irq(CFG_CAN_VECTOR_BEGIN + 7, CFG_INT_LEVEL_CAN, _can_isr_err_1, "can_isr_err_11");
        }

        // 获取CAN设备句柄
        if (i == 0)
        {
            g_can_dev[i].can_sock = can_open("can0");
        }
        else
        {
            g_can_dev[i].can_sock = can_open("can1");
        }

        // 创建CAN设备接收线程
        if (0 != pthread_create(&can_tid[i], NULL, can_proc_recv, (void *)&g_can_dev[i].can_sock))
        {
            return -2;
        }

        // 创建CAN设备发送线程
        if (0 != pthread_create(&can_tid_s[i], NULL, can_proc_send, (void *)&g_can_dev[i].can_sock))
        {
            return -3;
        }

        /* init and start flexcan */
        _can_chipset_init(dev, 0);
        _can_set_normal_mode(dev);
    }

    return 0;
}

int can_exit(void)
{
    int i = 0;
    // exit can recv thread
    bexit = 1;
    for (i = 0; i < CAN_BUS_NUM; i++)
    {
        pthread_join(can_tid[i], NULL);
        pthread_join(can_tid_s[i], NULL);

        if (g_can_map_base[i])
        {
            if (munmap(g_can_map_base, g_can_mapped_size) == -1)
            {
                printf("can[%d] dev munmap failed!", i);
                return -1;
            }
        }

        if (g_can_dev[i].can_sock >= 0)
        {
            close(g_can_dev[i].can_sock);
        }
    }

    if (g_can_fd >= 0)
    {
        close(g_can_fd);
        g_can_fd = -1;
    }

    rt_free_irq(CFG_CAN_VECTOR_BEGIN + 0);
    rt_free_irq(CFG_CAN_VECTOR_BEGIN + 1);
    rt_free_irq(CFG_CAN_VECTOR_BEGIN + 3);
    rt_free_irq(CFG_CAN_VECTOR_BEGIN + 4);
    rt_free_irq(CFG_CAN_VECTOR_BEGIN + 5);
    rt_free_irq(CFG_CAN_VECTOR_BEGIN + 7);

    pthread_mutex_destroy(&printf_mutex);

    return 0;
}

int can_regester_recv_callback(FN_CAN_RECV_CALLBACK fn)
{
    g_can_recv_callback = fn;

    return 0;
}

u8 *can_request_tx_buf(u8 type)
{
    int prior;

    // 提取优先级
    prior = (type >> 6) & CAN_FRAME_MASK_PRIOR;

    return g_app_buf_tx[prior];
}

int can_send(u32 no, u8 *buf)
{
    struct can_dev *dev;
    struct can_mb *pfm;

    int i, sf_num, sf_len;
    int frame_mark;      // 帧标识
    unsigned char prior; // 应用优先级
    unsigned char *p;

    u32 len;

    // 检查参数
    if (no >= CAN_BUS_NUM)
    {
        return -1;
    }
    if (buf == NULL)
    {
        return -2;
    }

    // 检查地址
    if (buf[1] >= CAN_BUS_ADDR_NUM || buf[2] >= CAN_BUS_ADDR_NUM)
    {
        return -5;
    }
    // 检查长度
    len = buf[3];
    if (len > CAN_LONGFRAME_DATA_LEN)
    {
        return -6;
    }

    dev = &g_can_dev[no];

    // 提取优先级
    prior = (buf[0] >> 6) & CAN_FRAME_MASK_PRIOR;

    // 将长帧转换为短帧
    // 计算需要分为多少帧短帧
    sf_num = (len + CAN_FRAME_DATA_LEN - 1) / CAN_FRAME_DATA_LEN;
    if (sf_num == 0)
    {
        sf_num = 1;
    }

    // 空间够吗？
    if (CAN_BUF_SPACE(&dev->tx_buf[prior], CAN_FRAME_NUM) < sf_num)
    {
        // 发送溢出次数
        dev->stats.tx_dropped++;
        return -7;
    }

    // 打印报文
    if (g_print_can)
    {
        print_msg("TX_CAN:", buf, len + CAN_LONGFRAME_HEAD_LEN);
    }

    // 帧序号递加
    dev->tx_buf[prior].frameno++;

    i = 0;
    p = buf + CAN_LONGFRAME_HEAD_LEN;
    while (i < sf_num)
    {
        // 短帧数据长度
        sf_len = len >= CAN_FRAME_DATA_LEN ? CAN_FRAME_DATA_LEN : len;

        // 帧标识
        if (sf_num == 1)
        {
            frame_mark = CAN_FRAME_SINGLE;
        }
        else
        {
            if (i == 0)
            {
                frame_mark = CAN_FRAME_BEGIN;
            }
            else if (i == (sf_num - 1))
            {
                frame_mark = CAN_FRAME_END;
            }
            else
            {
                frame_mark = CAN_FRAME_MIDDLE;
            }
        }

        // 指向当前头位置缓冲区
        pfm = (struct can_mb *)dev->tx_buf[prior].buf[dev->tx_buf[prior].head];

        // 结构信息
        pfm->can_dlc = sf_len; // MB_CNT_CODE(0x08)|(1 << 21)|(1 << 22)|(sf_len << 16)

        // 帧ID
        pfm->can_id = (buf[0] << CAN_FRAME_OFFSET_TYPE) | (buf[1] << CAN_FRAME_OFFSET_DST) | (buf[2] << CAN_FRAME_OFFSET_SRC) | (frame_mark << CAN_FRAME_OFFSET_MARK) | (dev->tx_buf[prior].frameno & CAN_FRAME_MASK_SN);

        // 数据
        memcpy(pfm->data, p, sf_len);
        len -= sf_len; // 剩余多少数据
        p += sf_len;   // 调整数据指针

        // 头下标往后移
        dev->tx_buf[prior].head++;

        // 下一短帧
        i++;
    }

    // 统计发送长帧
    dev->stats.tx_longframes++;

    // 启动发送
    _can_irq_force(no);

    return (buf[3] + CAN_LONGFRAME_HEAD_LEN);
}

int can_recv(u32 no, u8 *buf, u32 len)
{
    struct can_dev *dev;
    int i;
    int framelen;

    // 检查参数
    if (no >= CAN_BUS_NUM)
    {
        return -1;
    }
    if (buf == NULL)
    {
        return -2;
    }

    dev = &g_can_dev[no];

    // 从0优先级开始，读取接收缓冲区的数据
    for (i = 0; i < CAN_PRIO_MAX; i++)
    {
        // 对应的长帧缓冲区没有长帧
        if (CAN_BUF_EMPTY(&dev->longframe_buf_rx[i]))
            continue;

        // 长帧长度
        framelen = dev->longframe_buf_rx[i].buf[dev->longframe_buf_rx[i].tail][CAN_LONGFRAME_HEAD_LEN - 1] + CAN_LONGFRAME_HEAD_LEN;

        // 拷贝数据到用户空间
        if (framelen <= len)
        {
            memcpy(buf, dev->longframe_buf_rx[i].buf[dev->longframe_buf_rx[i].tail], framelen);

            // 调整尾位置
            dev->longframe_buf_rx[i].tail = (dev->longframe_buf_rx[i].tail + 1) & (CAN_LONGFRAME_NUM - 1);
        }
        else
        {
            rt_printf("can_recv:framelen=%d, len=%d\r\n", framelen, len);
            framelen = -3;
        }

        return framelen;
    }

    return 0;
}

int can_stat(void)
{
    int i = 0;

    rt_printf("flexcan communicate stat\r\n");
    for (i = 0; i < CAN_BUS_NUM; i++)
    {
        rt_printf("flexcan%d:\r\n", i);
        rt_printf("tx_longframes:\t%u\r\n", g_can_dev[i].stats.tx_longframes);
        rt_printf("rx_longframes:\t%u\r\n", g_can_dev[i].stats.rx_longframes);
        rt_printf("tx_shortframes:\t%u\r\n", g_can_dev[i].stats.tx_shortframes);
        rt_printf("rx_shortframes:\t%u\r\n", g_can_dev[i].stats.rx_shortframes);
        rt_printf("tx_dropped:\t%u\r\n", g_can_dev[i].stats.tx_dropped);
        rt_printf("rx_dropped:\t%u\r\n", g_can_dev[i].stats.rx_dropped);
        rt_printf("hw_bus_errors:\t%u\r\n", g_can_dev[i].stats.hw_bus_errors);
        rt_printf("overrun:\t%u\r\n", g_can_dev[i].stats.overrun);
    }

    return 0;
}

int can_stat_reset(void)
{
    int i = 0;

    for (i = 0; i < CAN_BUS_NUM; i++)
    {
        memset(&g_can_dev[i].stats, 0, sizeof(g_can_dev[i].stats));
    }

    return 0;
}

/*------------------------------ 内部函数 -------------------------------------
内部函数以下划线‘_’开头，不需要检查参数的合法性.
*/
/******************************************************************************
函数名称：	_can_set_reset_mode
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2010-09-25
函数说明：	复位FLEXCAN
参数说明：
        dev: flexcan 设备

返回值：成功返回0，失败返回1
修改记录：
*/
static int _can_set_reset_mode(struct can_dev *dev)
{
    // TODO: ocean

    return 1;
}

/******************************************************************************
函数名称：	_can_set_normal_mode
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2010-09-25
函数说明：	设置正常模式
参数说明：
        dev: flexcan 设备

返回值：成功返回0，失败返回1
修改记录：
*/
static int _can_set_normal_mode(struct can_dev *dev)
{
    // TODO: ocean

    return 1;
}

/******************************************************************************
函数名称：	_can_set_bittiming
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2010-09-25
函数说明：	波特率设置函数

使用外部晶振50M
配置为500K:
    reg = CANCTRL_PRESDIV(9) | CANCTRL_RJW(0);
    reg |= (CANCTRL_PROPSEG(2) |
        CANCTRL_PSEG1(3) |
        CANCTRL_PSEG2(1) |
        CANCTRL_SAMP(0));
    regs->canctrl |= reg;
配置为1M:
    reg = CANCTRL_PRESDIV(4) | CANCTRL_RJW(0);
    reg |= (CANCTRL_PROPSEG(3) |
        CANCTRL_PSEG1(2) |
        CANCTRL_PSEG2(1) |
        CANCTRL_SAMP(0));
    regs->canctrl |= reg;
参数说明：
            dev: flexcan 设备

返回值：	返回0
修改记录：
*/
static int _can_set_bittiming(struct can_dev *dev)
{
    /* Clear the old bittiming */
    char cmd_buf[256] = {0x00};
    sprintf(cmd_buf, "ip link set can%d down", dev->no);
    system(cmd_buf);

    /* 设置队列宽度 */
    memset(cmd_buf, 0, sizeof(cmd_buf));
    sprintf(cmd_buf, "ip link set can%d qlen %d", dev->no, 100);
    system(cmd_buf);

    /* 配置波特率为1M */
    memset(cmd_buf, 0, sizeof(cmd_buf));
    sprintf(cmd_buf, "ip link set can%d type can bitrate %d loopback off restart-ms %d", dev->no, 1000000, 100);
    system(cmd_buf);

    /* 启动can设备 */
    memset(cmd_buf, 0, sizeof(cmd_buf));
    sprintf(cmd_buf, "ip link set can%d up", dev->no);
    system(cmd_buf);
    return 0;
}

/******************************************************************************
函数名称：	_can_chipset_init
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2010-09-25
函数说明：	初始化flexcan
参数说明：
            dev: flexcan 设备
            clock_src: 时钟源,0表示外部晶振，1表示内部总线时钟

返回值：
修改记录：
*/
/*
 * initialize flexcan:
 *   - set clock source
 *   - set output mode
 *   - set baudrate
 *   - enable interrupts
 *   - start operating mode
 */
static void _can_chipset_init(struct can_dev *dev, int clock_src)
{
}

static void _can_app_tx(int _no)
{
    int sock;
    int i = 0;
    struct can_mb *pfm;
    struct can_frame frame;

    struct can_dev *dev = &g_can_dev[_no];

    // if(g_can_tx_call[_no] == 0)
    // return;

    // g_can_tx_call[_no] = 0;

    for (i = 0; i < CAN_PRIO_MAX; i++)
    {
        // 对应优先级的缓冲区是否有数据
        if (CAN_BUF_EMPTY(&dev->tx_buf[i]))
        {
            continue;
        }

        // 当前位置的缓冲区
        pfm = (struct can_mb *)dev->tx_buf[i].buf[dev->tx_buf[i].tail];

        frame.can_id = pfm->can_id | CAN_EFF_FLAG; // 使用扩展帧ID
        frame.can_dlc = pfm->can_dlc;
        memcpy(frame.data, pfm->data, sizeof(frame.data));

        sock = g_can_dev[_no].can_sock;
        if (can_soft_send(sock, frame) < 0)
        {
            rt_printf("%s send err!\r\n", __func__);
            break;
        }

        // 调整尾指针
        dev->tx_buf[i].tail++;

        // 统计发送短帧总数加一
        dev->stats.tx_shortframes++;
    }
}

/******************************************************************************
函数名称：	_can_int_tx
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2010-09-25
函数说明：	flexcan发送处理
参数说明：
            dev: flexcan 设备

返回值：
修改记录：
*/
static void _can_int_tx(struct can_dev *dev)
{
    int i = 0;
    struct can_mb *pfm;
    int txbuf = SEND_BUF;
    volatile struct can_regs *regs = (volatile struct can_regs *)dev->base_addr;

    for (i = 0; i < CAN_PRIO_MAX; i++)
    {
        int j = 0;
        unsigned int code = 0;

        // 对应优先级的缓冲区是否有数据
        if (CAN_BUF_EMPTY(&dev->tx_buf[i]))
        {
            continue;
        }

        // 当前位置的缓冲区
        pfm = (struct can_mb *)dev->tx_buf[i].buf[dev->tx_buf[i].tail];

        // 检查是否可以发送. code==8说明上一次成功发送完毕，code==0是第一次将CODE配置0了即是MB_CNT_CODE(0)
        code = (regs->cantxfg[txbuf].can_dlc >> 24) & 0x0F;
        if (!((code == 8) || (code == 0)))
        {
            // rt_printf("bus is busy\r\n");
            break;
        }

        // 写数据到寄存器
        regs->cantxfg[txbuf].can_dlc = pfm->can_dlc;
        regs->cantxfg[txbuf].can_id = pfm->can_id;

        for (j = 0; j < 8; j++)
        {
            regs->cantxfg[txbuf].data[j] = pfm->data[j];
        }

        /*Control/status word to hold Tx MB active */
        regs->cantxfg[txbuf].can_dlc |= MB_CNT_CODE(0x0c);

        // 调整尾指针
        dev->tx_buf[i].tail++;

        // 统计发送短帧总数加一
        dev->stats.tx_shortframes++;

        break;
    }
}

/******************************************************************************
函数名称：	_can_frame_short2long
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2010-09-25
函数说明：	短帧组长帧
参数说明：
            dev: flexcan 设备
            prior: 优先级

返回值：
修改记录：
*/
static int _can_frame_short2long(struct can_dev *dev, int prior)
{
    static unsigned char pos_rec[CAN_FRAME_NUM];
    int pos_index;
    int i, len, is_deal;
    struct can_mb *pfm;
    struct can_mb *pfmtmp;
    unsigned char *pd, *p;
    unsigned char tmppos = dev->rx_buf[prior].head - 1;
    unsigned char srcaddr;
    unsigned char dstaddr;
    unsigned char frameno;
    unsigned char frame_type;
    unsigned char frame_len;
    unsigned int frame_mark;
    unsigned char srcaddrtmp;
    unsigned char dstaddrtmp;
    unsigned char framenotmp;
    unsigned char frame_type_tmp;

    // 结束帧指针
    pfm = (struct can_mb *)dev->rx_buf[prior].buf[tmppos];

    srcaddr = (pfm->can_id >> CAN_FRAME_OFFSET_SRC) & CAN_FRAME_MASK_SRC;
    dstaddr = (pfm->can_id >> CAN_FRAME_OFFSET_DST) & CAN_FRAME_MASK_DST;
    frameno = pfm->can_id & CAN_FRAME_MASK_SN;
    frame_type = (unsigned char)(pfm->can_id >> CAN_FRAME_OFFSET_TYPE) & CAN_FRAME_MASK_TYPE;
    frame_len = pfm->can_dlc & CAN_FRAME_MASK_LEN; //(pfm->can_dlc >> CAN_FRAME_OFFSET_LEN) & CAN_FRAME_MASK_LEN;

    // 查找起始帧
    pos_index = 0;
    for (i = 0; i < CAN_FRAME_NUM; i++)
    {
        // 短帧
        pfmtmp = (struct can_mb *)dev->rx_buf[prior].buf[tmppos];
        frame_mark = (pfmtmp->can_id >> CAN_FRAME_OFFSET_MARK) & CAN_FRAME_MASK_MARK;
        srcaddrtmp = (pfmtmp->can_id >> CAN_FRAME_OFFSET_SRC) & CAN_FRAME_MASK_SRC;
        dstaddrtmp = (pfmtmp->can_id >> CAN_FRAME_OFFSET_DST) & CAN_FRAME_MASK_DST;
        framenotmp = pfmtmp->can_id & CAN_FRAME_MASK_SN;
        frame_type_tmp = (unsigned char)(pfmtmp->can_id >> CAN_FRAME_OFFSET_TYPE) & CAN_FRAME_MASK_TYPE;

        // 是要找的短帧
        if ((srcaddr == srcaddrtmp) && (dstaddr == dstaddrtmp) && (frameno == framenotmp) && (frame_type == frame_type_tmp))
        {
            // 记录短帧位置
            pos_rec[pos_index++] = tmppos;

            // 找到起始帧
            if ((frame_mark == CAN_FRAME_BEGIN) || (frame_mark == CAN_FRAME_SINGLE))
            {
                break;
            }
        }

        // 前一短帧
        tmppos--;
    }

    if (pos_index == 0)
    {
        rt_printf("_can_frame_short2long:pos_index=%d\r\n", pos_index);
        dev->stats.rx_dropped++;
        return -1;
    }
    if (i == CAN_FRAME_NUM)
    {
#if 0
		rt_printf("_can_frame_short2long:i=%d,pos_index=%d.\r\n",i,pos_index);
#endif
        dev->stats.rx_dropped++;
        return -11;
    }

    // 检查长度
    len = frame_len + (pos_index - 1) * CAN_FRAME_DATA_LEN;
    if (len > CAN_LONGFRAME_DATA_LEN)
    {
        rt_printf("_can_frame_short2long:i=%d\r\n", i);
        dev->stats.rx_dropped++;
        return -2;
    }

    // 长帧缓冲区首指针
    pd = dev->longframe_buf_rx[prior].buf[dev->longframe_buf_rx[prior].head];
    p = pd;

    // 长帧头
    p[0] = (pfmtmp->can_id >> CAN_FRAME_OFFSET_TYPE);
    p[1] = dstaddrtmp;
    p[2] = srcaddrtmp;
    p[3] = len;

    // 长帧数据
    p += CAN_LONGFRAME_HEAD_LEN;
    while (pos_index--)
    {
        len = pos_index == 0 ? frame_len : 8;
        pfmtmp = (struct can_mb *)dev->rx_buf[prior].buf[pos_rec[pos_index]];
        memcpy(p, pfmtmp->data, len);

        // 置帧空标志
        pfmtmp->can_dlc = 0;

        p += 8;
    }

    // 打印报文
    if (g_print_can)
    {
        print_msg("RX_CAN:", pd, pd[3] + CAN_LONGFRAME_HEAD_LEN);
    }

    // 回调处理此长帧
    is_deal = 0;
    if (g_can_recv_callback)
    {
        is_deal = g_can_recv_callback(dev->no, pd);
    }

    // 如果此长帧没有处理，调整头位置
    if (is_deal != 1)
    {
        if (CAN_BUF_SPACE(&dev->longframe_buf_rx[prior], CAN_LONGFRAME_NUM) == 0)
        {
            dev->stats.rx_dropped++;
            rt_printf("长帧溢出\r\n");
        }
        else
        {
            dev->longframe_buf_rx[prior].head = (dev->longframe_buf_rx[prior].head + 1) & (CAN_LONGFRAME_NUM - 1);
        }

        // 唤醒主循环处理此长帧
        mainloop_wakeup();
    }

    return 0;
}

/******************************************************************************
函数名称：	_can_int_rx
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2010-09-25
函数说明：	flexcan接收中断处理
参数说明：
            dev: flexcan 设备
            i: 表示第几个接收MB

返回值：
修改记录：
*/
void _can_bus_monitor(u8 *buf)
{
    static s8 str[128];
    s8 *p;
    int i;

    sprintf(str, "CAN_RS:");
    p = str + 7;
    for (i = 0; i < 16; i++)
    {
        sprintf(p, "%02x ", buf[i]);
        p += 3;
    }

    sprintf(p, "\r\n");

    rt_printf(str);
}

static void _can_app_rx(struct can_dev *dev, struct can_frame *frame)
{
    struct can_mb *pfm;

    int ctrl = frame->can_dlc;
    int canid = frame->can_id;
    u32 prior = (canid >> CAN_FRAME_OFFSET_PRIOR) & 0x03;
    u32 srcaddr = (canid >> CAN_FRAME_OFFSET_SRC) & CAN_FRAME_MASK_SRC;
    int k;

    // 取短帧BUF
    pfm = (struct can_mb *)dev->rx_buf[prior].buf[dev->rx_buf[prior].head];
    if (pfm->can_dlc)
    {
#if 0
		print_mem("CAN_BUF_FULL: ",(u8*)pfm,16);
#endif
        dev->stats.overrun++;
    }

    // 得到内容
    pfm->can_dlc = ctrl;
    pfm->can_id = frame->can_id;
    for (k = 0; k < 8; k++)
        pfm->data[k] = frame->data[k];

    // 如果总线监视，打印短帧
    if (g_print_can_monitor)
    {
        _can_bus_monitor((u8 *)pfm);
    }

    // 如果是自己发送的帧，直接返回
    if (srcaddr == 0)
    {
        // 置帧空标志
        pfm->can_dlc = 0;
        return;
    }

    // 统计接收短帧总数
    dev->stats.rx_shortframes++;

    // 调整当前位置
    dev->rx_buf[prior].head++;

    // 是结束帧就开始组长帧
    if (((canid >> CAN_FRAME_OFFSET_MARK) & CAN_FRAME_MASK_MARK) < 0x02)
    {
        // 统计接收长帧总数
        dev->stats.rx_longframes++;

        // 短帧组长帧
        _can_frame_short2long(dev, prior);
    }
}

static void _can_int_rx(struct can_dev *dev, int i)
{
    volatile struct can_regs *regs = (volatile struct can_regs *)dev->base_addr;
    struct can_mb *mb = (struct can_mb *)&regs->cantxfg[i];
    struct can_mb *pfm;

    int ctrl = mb->can_dlc;
    int canid = mb->can_id;
    u32 prior = (canid >> CAN_FRAME_OFFSET_PRIOR) & 0x03;
    u32 srcaddr = (canid >> CAN_FRAME_OFFSET_SRC) & CAN_FRAME_MASK_SRC;
    int k;

    // 取短帧BUF
    pfm = (struct can_mb *)dev->rx_buf[prior].buf[dev->rx_buf[prior].head];
    if (pfm->can_dlc)
    {
#if 0
		print_mem("CAN_BUF_FULL: ",(u8*)pfm,16);
#endif
        dev->stats.overrun++;
    }

    // 得到内容
    pfm->can_dlc = ctrl;
    pfm->can_id = mb->can_id;
    for (k = 0; k < 8; k++)
        pfm->data[k] =
            regs->cantxfg[i].data[k];

    // 如果总线监视，打印短帧
    if (g_print_can_monitor)
    {
        _can_bus_monitor((u8 *)pfm);
    }

    // 如果是自己发送的帧，直接返回
    if (srcaddr == 0)
    {
        // 置帧空标志
        pfm->can_dlc = 0;
        return;
    }

    // 统计接收短帧总数
    dev->stats.rx_shortframes++;

    // 调整当前位置
    dev->rx_buf[prior].head++;

    // 是结束帧就开始组长帧
    if (((canid >> CAN_FRAME_OFFSET_MARK) & CAN_FRAME_MASK_MARK) < 0x02)
    {
        // 统计接收长帧总数
        dev->stats.rx_longframes++;

        // 短帧组长帧
        _can_frame_short2long(dev, prior);
    }
}

void _can_isr(int no)
{
    struct can_dev *dev = &g_can_dev[no];
    volatile struct can_regs *regs = (volatile struct can_regs *)dev->base_addr;

    u32 oflags;

    // 得到中断标志
    oflags = regs->caniflg;

    // 处理发送软中断
    if (_can_irq_is_force(no))
    {
        // 应用程序启动发送
        oflags |= SEND_BUF_BIT;
        _can_irq_clear(no);
    }

    // 检查发送标志
    if (oflags & SEND_BUF_BIT)
    {
        // 清发送中断
        regs->caniflg = SEND_BUF_BIT;
        oflags &= (~SEND_BUF_BIT);
        // 发送一帧
        _can_int_tx(dev);
    }

    // 处理接收中断
    // 硬件overrun
    if (oflags & 0x80)
    {
        dev->stats.overrun++;
    }

    // 接收一帧
    if (oflags & 0x20)
    {
        _can_int_rx(dev, 0);
    }

    // 清接收中断标志
    regs->caniflg = oflags;

    return;
}

void _can_isr_err(int no)
{
    struct can_dev *dev = &g_can_dev[no];
    volatile struct can_regs *regs = (struct can_regs *)dev->base_addr;

    u32 errstate = regs->canerrstat;
    regs->canerrstat = errstate;

    dev->stats.hw_bus_errors++; // 统计出错信息

    return;
}

void _can_isr_0(void)
{

    _can_isr(0);
}
void _can_isr_1(void)
{

    _can_isr(1);
}

void _can_isr_err_0(void)
{

    _can_isr_err(0);
}
void _can_isr_err_1(void)
{

    _can_isr_err(1);
}

int _can_irq_force(int no)
{
#ifdef __KERNEL__
    uint32_t flags;

    no *= 4;
    rt_irq_save(flags);
    REG_MCF_INTFRCL1 |= 1 << no;
    rt_irq_restore(flags);
#else
    g_can_tx_call[no] = 1;
#endif
    return 0;
}

int _can_irq_clear(int no)
{
    uint32_t flags;

    no *= 4;

    rt_irq_save(flags);
    REG_MCF_INTFRCL1 &= ~(1 << no);
    rt_irq_restore(flags);

    return 0;
}

int _can_irq_is_force(int no)
{
    no *= 4;

    if (REG_MCF_INTFRCL1 & (1 << no))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

/*------------------------------ 测试函数 -------------------------------------
一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.
*/
#define LOOP_BEGIN 1
int can_test(void)
{
    static unsigned char buf_tx[CAN_LONGFRAME_LEN], buf_rx[CAN_LONGFRAME_LEN];
    static unsigned char loop = LOOP_BEGIN;
    static uint32_t us0 = 0, err_count = 0;

    uint32_t us1;
    int i;
    int len_tx, len_rx;

    // 1S调用一次
    us1 = ustimer_get_origin();
    if (us1 - us0 < USTIMER_SEC * 10)
    {

        return 0;
    }
    us0 = us1;

    // 发送一帧
    memset(buf_tx, 0, sizeof(buf_tx));
    buf_tx[0] = loop;
    buf_tx[1] = 1;
    buf_tx[2] = 2;
    buf_tx[3] = loop;

    for (i = 0; i < buf_tx[3]; i++)
    {
        buf_tx[CAN_LONGFRAME_HEAD_LEN + i] = i;
    }
    len_tx = can_send(0, buf_tx);
    //	len_tx = can_send(1,buf_tx);

    // 延时5ms
    ustimer_delay(USTIMER_MS * 50);

    // 接收一帧
    memset(buf_rx, 0, sizeof(buf_rx));
    len_rx = can_recv(0, buf_rx, 256);

    if ((len_tx == len_rx) && (memcmp(buf_tx, buf_rx, len_tx) == 0))
    {
        rt_printf("can_test ok(%03d,err_count=%d):[len_tx=%d,len_rx=%d]\r\n", loop, err_count, len_tx, len_rx);
    }
    else
    {
        err_count++;
        rt_printf("can_test err(%03d,err_count=%d):[len_tx=%d,len_rx=%d]\r\n", loop, err_count, len_tx, len_rx);
        //	can_print_mem("TX:",buf_tx,len_tx);
        //	can_print_mem("RX:",buf_rx,len_rx);
    }

    //	loop++;
    if (loop > CAN_LONGFRAME_DATA_LEN)
    {
        loop = LOOP_BEGIN;
    }

    return 0;
}

#endif
/*------------------------------ 文件结束 -------------------------------------
 */