rt-thread/bsp/stm32f10x/drivers/bxcan.c

/*
 * File      : bxcan.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2015, RT-Thread Development Team
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
 * http://www.rt-thread.org/license/LICENSE
 *
 * Change Logs:
 * Date           Author            Notes
 * 2015-05-14     aubrcool@qq.com   first version
 */
#include <rthw.h>
#include <rtdevice.h>
#include <board.h>
#include <bxcan.h>
#ifdef RT_USING_COMPONENTS_INIT
#include <components.h>
#endif
#ifdef RT_USING_CAN

#ifndef STM32F10X_CL
#define BX_CAN_FMRNUMBER 14
#define BX_CAN2_FMRSTART 7
#else
#define BX_CAN_FMRNUMBER 28
#define BX_CAN2_FMRSTART 14
#endif
#ifdef STM32F10X_HD
#undef USING_BXCAN2

#define CAN1_RX0_IRQn USB_LP_CAN1_RX0_IRQn
#define CAN1_TX_IRQn USB_HP_CAN1_TX_IRQn
#endif
#define BX_CAN_MAX_FILTERS (BX_CAN_FMRNUMBER * 4)
#define BX_CAN_MAX_FILTER_MASKS BX_CAN_MAX_FILTERS
#define BX_CAN_FILTER_MAX_ARRAY_SIZE ((BX_CAN_MAX_FILTERS + 32 - 1) / 32)

struct stm_bxcanfiltermap
{
    rt_uint32_t id32mask_cnt;
    rt_uint32_t id32bit_cnt;
    rt_uint32_t id16mask_cnt;
    rt_uint32_t id16bit_cnt;
};
struct stm_bxcanfilter_masks
{
    rt_uint32_t id32maskm[BX_CAN_FILTER_MAX_ARRAY_SIZE];
    rt_uint32_t id32bitm[BX_CAN_FILTER_MAX_ARRAY_SIZE];
    rt_uint32_t id16maskm[BX_CAN_FILTER_MAX_ARRAY_SIZE];
    rt_uint32_t id16bitm[BX_CAN_FILTER_MAX_ARRAY_SIZE];
    rt_uint32_t id32maskshift[2];
    rt_uint32_t id32bitshift[2];
    rt_uint32_t id16maskshift[2];
    rt_uint32_t id16bitshift[2];
};
struct stm_bxcan
{
    CAN_TypeDef *reg;
    void *mfrbase;
    IRQn_Type sndirq;
    IRQn_Type rcvirq0;
    IRQn_Type rcvirq1;
    IRQn_Type errirq;
    struct stm_bxcanfilter_masks filtermask;
    rt_uint32_t alocmask[BX_CAN_FILTER_MAX_ARRAY_SIZE];
    const rt_uint32_t filtercnt;
    const rt_uint32_t fifo1filteroff;
    const struct stm_bxcanfiltermap filtermap[2];
};
struct stm_baud_rate_tab
{
	rt_uint32_t baud_rate;
	rt_uint32_t confdata;
};
static void calcfiltermasks(struct stm_bxcan *pbxcan);
static void bxcan1_filter_init(struct rt_can_device *can)
{
    rt_uint32_t i;
    rt_uint32_t mask;
    struct stm_bxcan *pbxcan = (struct stm_bxcan *) can->parent.user_data;
    for (i = 0; i < BX_CAN2_FMRSTART; i++)
    {
        CAN1->FMR |= FMR_FINIT;
        mask = 0x01 << (i + 0);
        if (i < pbxcan->fifo1filteroff)
        {
            if (pbxcan->filtermap[0].id32mask_cnt && i < pbxcan->filtermap[0].id32mask_cnt)
            {
                CAN1->FS1R |= mask;
                CAN1->FM1R &= ~mask;
                CAN1->FFA1R &= ~mask;
            }
            else if (pbxcan->filtermap[0].id32bit_cnt &&
                     i < pbxcan->filtermap[0].id32mask_cnt + pbxcan->filtermap[0].id32bit_cnt / 2)
            {
                CAN1->FS1R |= mask;
                CAN1->FM1R |= mask;
                CAN1->FFA1R &= ~mask;
            }
            else if (pbxcan->filtermap[0].id16mask_cnt &&
                     i < pbxcan->filtermap[0].id32mask_cnt + pbxcan->filtermap[0].id32bit_cnt / 2
                     + pbxcan->filtermap[0].id16mask_cnt / 2)
            {
                CAN1->FS1R &= ~mask;
                CAN1->FM1R &= ~mask;
                CAN1->FFA1R &= ~mask;
            }
            else if (pbxcan->filtermap[0].id16bit_cnt &&
                     i < pbxcan->filtermap[0].id32mask_cnt + pbxcan->filtermap[0].id32bit_cnt / 2
                     + pbxcan->filtermap[0].id16mask_cnt / 2 + pbxcan->filtermap[0].id16bit_cnt / 4
                    )
            {
                CAN1->FS1R &= ~mask;
                CAN1->FM1R |= mask;
                CAN1->FFA1R &= ~mask;
            }
        }
        else
        {
            if (pbxcan->filtermap[1].id32mask_cnt &&
                    i < pbxcan->filtermap[1].id32mask_cnt + pbxcan->fifo1filteroff)
            {
                CAN1->FS1R |= mask;
                CAN1->FM1R &= ~mask;
                CAN1->FFA1R |= mask;
            }
            else if (pbxcan->filtermap[1].id32bit_cnt &&
                     i < pbxcan->filtermap[1].id32mask_cnt + pbxcan->filtermap[1].id32bit_cnt / 2
                     + pbxcan->fifo1filteroff)
            {
                CAN1->FS1R |= mask;
                CAN1->FM1R |= mask;
                CAN1->FFA1R |= mask;
            }
            else if (pbxcan->filtermap[1].id16mask_cnt &&
                     i < pbxcan->filtermap[1].id32mask_cnt + pbxcan->filtermap[1].id32bit_cnt / 2
                     + pbxcan->filtermap[1].id16mask_cnt / 2 + pbxcan->fifo1filteroff)
            {
                CAN1->FS1R &= ~mask;
                CAN1->FM1R &= ~mask;
                CAN1->FFA1R |= mask;
            }
            else if (pbxcan->filtermap[1].id16bit_cnt &&
                     i < pbxcan->filtermap[1].id32mask_cnt + pbxcan->filtermap[1].id32bit_cnt / 2
                     + pbxcan->filtermap[1].id16mask_cnt / 2 + pbxcan->filtermap[1].id16bit_cnt / 4
                     + pbxcan->fifo1filteroff)
            {
                CAN1->FS1R &= ~mask;
                CAN1->FM1R |= mask;
                CAN1->FFA1R |= mask;
            }
        }
        CAN1->sFilterRegister[i].FR1 = 0xFFFFFFFF;
        CAN1->sFilterRegister[i].FR2 = 0xFFFFFFFF;
        CAN1->FMR &= ~FMR_FINIT;
    }
    calcfiltermasks(pbxcan);
}
#ifdef USING_BXCAN2
static void bxcan2_filter_init(struct rt_can_device *can)
{
    rt_uint32_t i;
    rt_uint32_t off;
    rt_uint32_t mask;
    CAN_SlaveStartBank(BX_CAN2_FMRSTART);
    struct stm_bxcan *pbxcan = (struct stm_bxcan *) can->parent.user_data;
    for (i = BX_CAN2_FMRSTART; i < BX_CAN_FMRNUMBER; i++)
    {
        CAN1->FMR |= FMR_FINIT;
        mask = 0x01 << (i + 0);
        off = i - BX_CAN2_FMRSTART;
        if (off < pbxcan->fifo1filteroff)
        {
            if (pbxcan->filtermap[0].id32mask_cnt && off < pbxcan->filtermap[0].id32mask_cnt)
            {
                CAN1->FS1R |= mask;
                CAN1->FM1R &= ~mask;
                CAN1->FFA1R &= ~mask;
            }
            else if (pbxcan->filtermap[0].id32bit_cnt &&
                     off < pbxcan->filtermap[0].id32mask_cnt + pbxcan->filtermap[0].id32bit_cnt / 2)
            {
                CAN1->FS1R |= mask;
                CAN1->FM1R |= mask;
                CAN1->FFA1R &= ~mask;
            }
            else if (pbxcan->filtermap[0].id16mask_cnt &&
                     off < pbxcan->filtermap[0].id32mask_cnt + pbxcan->filtermap[0].id32bit_cnt / 2
                     + pbxcan->filtermap[0].id16mask_cnt / 2)
            {
                CAN1->FS1R &= ~mask;
                CAN1->FM1R &= ~mask;
                CAN1->FFA1R &= ~mask;
            }
            else if (pbxcan->filtermap[0].id16bit_cnt &&
                     off < pbxcan->filtermap[0].id32mask_cnt + pbxcan->filtermap[0].id32bit_cnt / 2
                     + pbxcan->filtermap[0].id16mask_cnt / 2 + pbxcan->filtermap[0].id16bit_cnt / 4
                    )
            {
                CAN1->FS1R &= ~mask;
                CAN1->FM1R |= mask;
                CAN1->FFA1R &= ~mask;
            }
        }
        else
        {
            if (pbxcan->filtermap[1].id32mask_cnt &&
                    off < pbxcan->filtermap[1].id32mask_cnt + pbxcan->fifo1filteroff)
            {
                CAN1->FS1R |= mask;
                CAN1->FM1R &= ~mask;
                CAN1->FFA1R |= mask;
            }
            else if (pbxcan->filtermap[1].id32bit_cnt &&
                     off < pbxcan->filtermap[1].id32mask_cnt + pbxcan->filtermap[1].id32bit_cnt / 2
                     + pbxcan->fifo1filteroff)
            {
                CAN1->FS1R |= mask;
                CAN1->FM1R |= mask;
                CAN1->FFA1R |= mask;
            }
            else if (pbxcan->filtermap[1].id16mask_cnt &&
                     off < pbxcan->filtermap[1].id32mask_cnt + pbxcan->filtermap[1].id32bit_cnt / 2
                     + pbxcan->filtermap[1].id16mask_cnt / 2 + pbxcan->fifo1filteroff)
            {
                CAN1->FS1R &= ~mask;
                CAN1->FM1R &= ~mask;
                CAN1->FFA1R |= mask;
            }
            else if (pbxcan->filtermap[1].id16bit_cnt &&
                     off < pbxcan->filtermap[1].id32mask_cnt + pbxcan->filtermap[1].id32bit_cnt / 2
                     + pbxcan->filtermap[1].id16mask_cnt / 2 + pbxcan->filtermap[1].id16bit_cnt / 4
                     + pbxcan->fifo1filteroff)
            {
                CAN1->FS1R &= ~mask;
                CAN1->FM1R |= mask;
                CAN1->FFA1R |= mask;
            }
        }
        CAN1->sFilterRegister[i].FR1 = 0xFFFFFFFF;
        CAN1->sFilterRegister[i].FR2 = 0xFFFFFFFF;
        CAN1->FMR &= ~FMR_FINIT;
    }
    calcfiltermasks(pbxcan);
}
#endif

#define BS1SHIFT 16
#define BS2SHIFT 20
#define RRESCLSHIFT 0
#define SJWSHIFT 24
#define BS1MASK ( (0x0F) << BS1SHIFT )
#define BS2MASK ( (0x07) << BS2SHIFT )
#define RRESCLMASK ( 0x3FF << RRESCLSHIFT )
#define SJWMASK ( 0x3 << SJWSHIFT )

#define MK_BKCAN_BAUD(SJW,BS1,BS2,PRES) \
    ((SJW << SJWSHIFT) | (BS1 << BS1SHIFT) | (BS2 << BS2SHIFT) | (PRES << RRESCLSHIFT))

static const struct stm_baud_rate_tab bxcan_baud_rate_tab[] =
{
#ifdef STM32F10X_CL
    // 48 M
    {1000UL * 1000, MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 3)},
    {1000UL * 800,  MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_6tq,  CAN_BS2_3tq, 6)},
    {1000UL * 500,  MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 5)},
    {1000UL * 250,  MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 11)},//1
    {1000UL * 125,  MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 23)},
    {1000UL * 100,  MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 29)},
    {1000UL * 50,   MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 59)},
    {1000UL * 20,   MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_14tq, CAN_BS2_3tq, 149)},
    {1000UL * 10,   MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_16tq, CAN_BS2_8tq, 199)}
#else
	// 36 M
	{1000UL * 1000, MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_8tq,  CAN_BS2_3tq, 3)},
	{1000UL * 800,	MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_11tq, CAN_BS2_3tq, 3)},
	{1000UL * 500,	MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_9tq,  CAN_BS2_2tq, 6)},
	{1000UL * 250,	MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_13tq, CAN_BS2_2tq, 9)},//1
	{1000UL * 125,	MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_13tq, CAN_BS2_2tq, 18)},
	{1000UL * 100,	MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_9tq,  CAN_BS2_2tq, 30)},
	{1000UL * 50,	MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_13tq, CAN_BS2_2tq, 45)},
	{1000UL * 20,	MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_14tq, CAN_BS2_3tq, 100)},
	{1000UL * 10,	MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_14tq, CAN_BS2_3tq, 200)}
#endif
};

#define BAUD_DATA(TYPE,NO) \
    ((bxcan_baud_rate_tab[NO].confdata & TYPE##MASK) >> TYPE##SHIFT)

static rt_uint32_t bxcan_get_baud_index(rt_uint32_t baud)
{
	rt_uint32_t len, index, default_index;
	
	len = sizeof(bxcan_baud_rate_tab)/sizeof(bxcan_baud_rate_tab[0]);
	default_index = len;

	for(index = 0; index < len; index++)
	{
		if(bxcan_baud_rate_tab[index].baud_rate == baud)
			return index;

		if(bxcan_baud_rate_tab[index].baud_rate == 1000UL * 250)
			default_index = index;
	}

	if(default_index != len)
		return default_index;

	return 0;	
}


static void bxcan_init(CAN_TypeDef *pcan, rt_uint32_t baud, rt_uint32_t mode)
{
    CAN_InitTypeDef        CAN_InitStructure;
	
	rt_uint32_t baud_index = bxcan_get_baud_index(baud);

    CAN_InitStructure.CAN_TTCM = DISABLE;
    CAN_InitStructure.CAN_ABOM = ENABLE;
    CAN_InitStructure.CAN_AWUM = DISABLE;
    CAN_InitStructure.CAN_NART = DISABLE;
    CAN_InitStructure.CAN_RFLM = DISABLE;
    CAN_InitStructure.CAN_TXFP = ENABLE;
    switch (mode)
    {
    case RT_CAN_MODE_NORMAL:
        CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
        break;
    case RT_CAN_MODE_LISEN:
        CAN_InitStructure.CAN_Mode = CAN_Mode_Silent;
        break;
    case RT_CAN_MODE_LOOPBACK:
        CAN_InitStructure.CAN_Mode = CAN_Mode_LoopBack;
        break;
    case RT_CAN_MODE_LOOPBACKANLISEN:
        CAN_InitStructure.CAN_Mode = CAN_Mode_Silent_LoopBack;
        break;
    }
    CAN_InitStructure.CAN_SJW = BAUD_DATA(SJW, baud_index);
    CAN_InitStructure.CAN_BS1 = BAUD_DATA(BS1, baud_index);
    CAN_InitStructure.CAN_BS2 = BAUD_DATA(BS2, baud_index);
    CAN_InitStructure.CAN_Prescaler = BAUD_DATA(RRESCL, baud_index);

    CAN_Init(pcan, &CAN_InitStructure);
}
static void bxcan1_hw_init(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
    NVIC_Init(&NVIC_InitStructure);
    NVIC_InitStructure.NVIC_IRQChannel = CAN1_RX1_IRQn;
    NVIC_Init(&NVIC_InitStructure);
    NVIC_InitStructure.NVIC_IRQChannel = CAN1_TX_IRQn;
    NVIC_Init(&NVIC_InitStructure);
}
#ifdef USING_BXCAN2
static void bxcan2_hw_init(void)
{
    GPIO_InitTypeDef  GPIO_InitStructure;
    NVIC_InitTypeDef  NVIC_InitStructure;

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    NVIC_InitStructure.NVIC_IRQChannel = CAN2_RX0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x1;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
    NVIC_Init(&NVIC_InitStructure);
    NVIC_InitStructure.NVIC_IRQChannel = CAN2_RX1_IRQn;
    NVIC_Init(&NVIC_InitStructure);
    NVIC_InitStructure.NVIC_IRQChannel = CAN2_TX_IRQn;
    NVIC_Init(&NVIC_InitStructure);
}
#endif
static inline rt_err_t bxcan_enter_init(CAN_TypeDef *pcan)
{
    uint32_t wait_ack = 0x00000000;

    pcan->MCR |= CAN_MCR_INRQ ;

    while (((pcan->MSR & CAN_MSR_INAK) != CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT))
    {
        wait_ack++;
    }
    if ((pcan->MSR & CAN_MSR_INAK) != CAN_MSR_INAK)
    {
        return RT_ERROR;
    }
    return RT_EOK;
}
static inline rt_err_t bxcan_exit_init(CAN_TypeDef *pcan)
{
    uint32_t wait_ack = 0x00000000;

    pcan->MCR &= ~(uint32_t)CAN_MCR_INRQ;

    while (((pcan->MSR & CAN_MSR_INAK) == CAN_MSR_INAK) && (wait_ack != INAK_TIMEOUT))
    {
        wait_ack++;
    }
    if ((pcan->MSR & CAN_MSR_INAK) != CAN_MSR_INAK)
    {
        return RT_ERROR;
    }
    return RT_EOK;
}
static rt_err_t bxcan_set_mode(CAN_TypeDef *pcan, rt_uint32_t mode)
{
    if (bxcan_enter_init(pcan) != RT_EOK)
    {
        return RT_ERROR;
    }
    pcan->BTR &= ~(uint32_t)((uint32_t)0x03 << 30);
    switch (mode)
    {
    case RT_CAN_MODE_NORMAL:
        mode = CAN_Mode_Normal;
        break;
    case RT_CAN_MODE_LISEN:
        mode = CAN_Mode_Silent;
        break;
    case RT_CAN_MODE_LOOPBACK:
        mode = CAN_Mode_LoopBack;
        break;
    case RT_CAN_MODE_LOOPBACKANLISEN:
        mode = CAN_Mode_Silent_LoopBack;
        break;
    }
    pcan->BTR |= ~(uint32_t)(mode << 30);
    if (bxcan_exit_init(pcan) != RT_EOK)
    {
        return RT_ERROR;
    }
    return RT_EOK;
}
static rt_err_t bxcan_set_privmode(CAN_TypeDef *pcan, rt_uint32_t mode)
{
    if (bxcan_enter_init(pcan) != RT_EOK)
    {
        return RT_ERROR;
    }
    if (mode == ENABLE)
    {
        pcan->MCR |= CAN_MCR_TXFP;
    }
    else
    {
        pcan->MCR &= ~(uint32_t)CAN_MCR_TXFP;
    }
    if (bxcan_exit_init(pcan) != RT_EOK)
    {
        return RT_ERROR;
    }
    return RT_EOK;
}
static rt_err_t bxcan_set_baud_rate(CAN_TypeDef *pcan, rt_uint32_t baud)
{
    rt_uint32_t mode;

	rt_uint32_t baud_index = bxcan_get_baud_index(baud);
	
    if (bxcan_enter_init(pcan) != RT_EOK)
    {
        return RT_ERROR;
    }
    pcan->BTR = 0;
    mode = pcan->BTR & ((rt_uint32_t)0x03 << 30);
    pcan->BTR = (mode                         | \
                 ((BAUD_DATA(SJW, baud_index)) << 24) | \
                 ((BAUD_DATA(BS1, baud_index)) << 16) | \
                 ((BAUD_DATA(BS2, baud_index)) << 20) | \
                 (BAUD_DATA(RRESCL, baud_index)));
    if (bxcan_exit_init(pcan) != RT_EOK)
    {
        return RT_ERROR;
    }
    return RT_EOK;
}
static rt_err_t bxcancalcbaseoff(struct stm_bxcan *pbxcan, rt_int32_t hdr,
                                 rt_int32_t *pbase, rt_int32_t   *poff)
{
    rt_uint32_t fifo0start, fifo0end;
    rt_uint32_t fifo1start, fifo1end;
    rt_uint32_t ptr;
    fifo0start = 0;
    fifo0end = pbxcan->filtermap[0].id32mask_cnt
               + pbxcan->filtermap[0].id32bit_cnt
               + pbxcan->filtermap[0].id16mask_cnt
               + pbxcan->filtermap[0].id16bit_cnt ;
    fifo1start = pbxcan->fifo1filteroff * 4;
    fifo1end = pbxcan->filtermap[1].id32mask_cnt
               + pbxcan->filtermap[1].id32bit_cnt
               + pbxcan->filtermap[1].id16mask_cnt
               + pbxcan->filtermap[1].id16bit_cnt ;
    if (hdr >= fifo0start && hdr < fifo0end)
    {
        *pbase = 0;
        ptr = 0;
    }
    else if (hdr >= fifo1start && hdr < fifo1end)
    {
        *pbase = pbxcan->fifo1filteroff;
        ptr = 1;
    }
    else
    {
        return RT_ERROR;
    }
    ptr = 0;
    if (hdr > pbxcan->filtermap[ptr].id32mask_cnt)
    {
        hdr -= pbxcan->filtermap[ptr].id32mask_cnt;
        *pbase += pbxcan->filtermap[ptr].id32mask_cnt;
    }
    else
    {
        *pbase += hdr;
        *poff = 0;
        return RT_EOK;
    }
    if (hdr > pbxcan->filtermap[ptr].id32bit_cnt)
    {
        hdr -= pbxcan->filtermap[ptr].id32bit_cnt;
        *pbase += pbxcan->filtermap[ptr].id32bit_cnt / 2;
    }
    else
    {
        *pbase += hdr / 2;
        *poff = hdr % 2;
        return RT_EOK;
    }
    if (hdr > pbxcan->filtermap[ptr].id16mask_cnt)
    {
        hdr -= pbxcan->filtermap[ptr].id16mask_cnt;
        *pbase += pbxcan->filtermap[ptr].id16mask_cnt / 2;
    }
    else
    {
        *pbase += hdr / 2;
        *poff = hdr % 2;
        return RT_EOK;
    }
    if (hdr > pbxcan->filtermap[ptr].id16bit_cnt)
    {
        return RT_ERROR;
    }
    else
    {
        *pbase += hdr / 4;
        *poff = hdr % 4;
        return RT_EOK;
    }
}
static void calcandormask(rt_uint32_t *pmask, rt_uint32_t shift, rt_int32_t count)
{
    rt_uint32_t tmpmask;
    rt_uint32_t tmpmaskarray[BX_CAN_FILTER_MAX_ARRAY_SIZE] = {0,};
    rt_int32_t i;
    i = 0;
    while (count > 0)
    {
        if (i >= 32)
        {
            tmpmaskarray[i] = 0xFFFFFFFF;
        }
        else
        {
            tmpmaskarray[i] = (0x01 << count) - 1;
        }
        count -= 32;
        i++;
    };
    count = i;
    for (i = 0; i < count && i < BX_CAN_FILTER_MAX_ARRAY_SIZE; i++)
    {
        tmpmask = tmpmaskarray[i];
        pmask[i] |= (rt_uint32_t)(tmpmask << shift);
        if (i < BX_CAN_FILTER_MAX_ARRAY_SIZE - 1)
        {
            pmask[i + 1] |= (rt_uint32_t)(tmpmask >> (32 - shift));
        }
    }
}
static void calcfiltermasks(struct stm_bxcan *pbxcan)
{
    rt_memset(&pbxcan->filtermask, 0, sizeof(pbxcan->filtermask));
    pbxcan->filtermask.id32maskshift[0] = 0;
    if (pbxcan->filtermap[0].id32mask_cnt)
    {
        calcandormask(pbxcan->filtermask.id32maskm, pbxcan->filtermask.id32maskshift[0],
                      pbxcan->filtermap[0].id32mask_cnt);
    }
    pbxcan->filtermask.id32maskshift[1] = pbxcan->fifo1filteroff * 4;
    if (pbxcan->filtermap[1].id32mask_cnt)
    {
        calcandormask(pbxcan->filtermask.id32maskm, pbxcan->filtermask.id32maskshift[1],
                      pbxcan->filtermap[1].id32mask_cnt);
    }
    pbxcan->filtermask.id32bitshift[0] = pbxcan->filtermask.id32maskshift[0] +
                                         pbxcan->filtermap[0].id32mask_cnt;
    if (pbxcan->filtermap[0].id32bit_cnt)
    {
        calcandormask(pbxcan->filtermask.id32bitm, pbxcan->filtermask.id32bitshift[0],
                      pbxcan->filtermap[0].id32bit_cnt);
    }
    pbxcan->filtermask.id32bitshift[1] = pbxcan->filtermask.id32maskshift[1] +
                                         pbxcan->filtermap[1].id32mask_cnt;
    if (pbxcan->filtermap[1].id32bit_cnt)
    {
        calcandormask(pbxcan->filtermask.id32bitm, pbxcan->filtermask.id32bitshift[1],
                      pbxcan->filtermap[1].id32bit_cnt);
    }
    pbxcan->filtermask.id16maskshift[0] = pbxcan->filtermask.id32bitshift[0] +
                                          pbxcan->filtermap[0].id32bit_cnt;
    if (pbxcan->filtermap[0].id16mask_cnt)
    {
        calcandormask(pbxcan->filtermask.id16maskm, pbxcan->filtermask.id16maskshift[0],
                      pbxcan->filtermap[0].id16mask_cnt);
    }
    pbxcan->filtermask.id16maskshift[1] = pbxcan->filtermask.id32bitshift[1] +
                                          pbxcan->filtermap[1].id32bit_cnt;
    if (pbxcan->filtermap[1].id16mask_cnt)
    {
        calcandormask(pbxcan->filtermask.id16maskm, pbxcan->filtermask.id16maskshift[1],
                      pbxcan->filtermap[1].id16mask_cnt);
    }
    pbxcan->filtermask.id16bitshift[0] = pbxcan->filtermask.id16maskshift[0] +
                                         pbxcan->filtermap[0].id16mask_cnt;
    if (pbxcan->filtermap[0].id16bit_cnt)
    {
        calcandormask(pbxcan->filtermask.id16bitm, pbxcan->filtermask.id16bitshift[0],
                      pbxcan->filtermap[0].id16bit_cnt);
    }
    pbxcan->filtermask.id16bitshift[1] = pbxcan->filtermask.id16maskshift[1] +
                                         pbxcan->filtermap[1].id16mask_cnt;
    if (pbxcan->filtermap[1].id16bit_cnt)
    {
        calcandormask(pbxcan->filtermask.id16bitm, pbxcan->filtermask.id16bitshift[1],
                      pbxcan->filtermap[1].id16bit_cnt);
    }
}
static rt_int32_t bxcanfindfilter(struct stm_bxcan *pbxcan, struct rt_can_filter_item *pitem,
                                  rt_int32_t type, rt_int32_t *base, rt_int32_t *off)
{
    rt_int32_t i;
    rt_uint32_t bits, thisid, thismask, shift, found;
    CAN_FilterRegister_TypeDef *pfilterreg;
    found = 0;
    switch (type)
    {
    case 3:
        shift = 3;
        for (i = 0; i < BX_CAN_MAX_FILTERS; i++)
        {
            bits = 0x01 << (i & 0x1F);
            if (bits & (pbxcan->filtermask.id32maskm[i >> 5] & pbxcan->alocmask[i >> 5]))
            {
                bxcancalcbaseoff(pbxcan, i, base, off);
                pfilterreg = &((CAN_FilterRegister_TypeDef *)pbxcan->mfrbase)[*base];
                thisid = (rt_uint32_t)pitem->id << shift;
                thismask = (rt_uint32_t)pitem->mask << shift;
                if (pitem->ide)
                {
                    thisid |= CAN_ID_EXT;
                    thismask |= CAN_ID_EXT;
                }
                if (pitem->rtr)
                {
                    thisid |= CAN_RTR_REMOTE;
                    thismask |= CAN_RTR_REMOTE;
                }
                if (pfilterreg->FR1 == thisid && pfilterreg->FR2 == thismask)
                {
                    found = 1;
                    break;
                }
            }
        }
        break;
    case 2:
        shift = 3;
        for (i = 0; i < BX_CAN_MAX_FILTERS; i++)
        {
            bits = 0x01 << (i % 32);
            if (bits & (pbxcan->filtermask.id32bitm[i >> 5] & pbxcan->alocmask[i >> 5]))
            {
                bxcancalcbaseoff(pbxcan, i, base, off);
                pfilterreg = &((CAN_FilterRegister_TypeDef *)pbxcan->mfrbase)[*base];
                thisid = (rt_uint32_t)pitem->id << shift;
                if (pitem->ide)
                {
                    thisid |= CAN_ID_EXT;
                }
                if (pitem->rtr)
                {
                    thisid |= CAN_RTR_REMOTE;
                }
                if ((*off == 0 && pfilterreg->FR1 == thisid) ||
                        (*off == 1 && pfilterreg->FR2 == thisid)
                   )
                {
                    found = 1;
                    break;
                }
            }
        }
        break;
    case 1:
        shift = 5;
        for (i = 0; i < BX_CAN_MAX_FILTERS; i++)
        {
            bits = 0x01 << (i % 32);
            if (bits & (pbxcan->filtermask.id16maskm[i >> 5] & pbxcan->alocmask[i >> 5]))
            {
                bxcancalcbaseoff(pbxcan, i, base, off);
                pfilterreg = &((CAN_FilterRegister_TypeDef *)pbxcan->mfrbase)[*base];
                thisid = pitem->id << shift;
                if (pitem->rtr)
                {
                    thisid |= CAN_RTR_REMOTE << (shift - 2);
                }
                thismask = pitem->mask << shift;
                if (pitem->rtr)
                {
                    thismask |= CAN_RTR_REMOTE << (shift - 2);
                }
                if (*off == 0 && pfilterreg->FR1 == ((thisid & 0x0000FFFF) | ((thismask & 0x0000FFFF) << 16)) ||
                        *off == 1 && pfilterreg->FR2 == ((thisid & 0x0000FFFF) | ((thismask & 0x0000FFFF) << 16))
                   )
                {
                    found = 1;
                    break;
                }
            }
        }
        break;
    case 0:
        shift = 5;
        for (i = 0; i < BX_CAN_MAX_FILTERS; i++)
        {
            bits = 0x01 << (i % 32);
            if (bits & (pbxcan->filtermask.id16bitm[i >> 5] & pbxcan->alocmask[i >> 5]))
            {
                bxcancalcbaseoff(pbxcan, i, base, off);
                pfilterreg = &((CAN_FilterRegister_TypeDef *)pbxcan->mfrbase)[*base];
                thisid = pitem->id << shift;
                if (pitem->rtr)
                {
                    thisid |= CAN_RTR_REMOTE << (shift - 2);
                }
                if (*off < 2 && ((rt_uint16_t *)&pfilterreg->FR1)[*off & 0x01] == thisid ||
                        *off >= 2 && ((rt_uint16_t *)&pfilterreg->FR2)[*off & 0x01] == thisid)
                {
                    found = 1;
                    break;
                }
            }
        }
        break;
    }
    if (found)
    {
        return i;
    }
    return -1;
}
extern int __rt_ffs(int value);
static rt_err_t bxcanallocfilter(rt_uint32_t *pmask, rt_uint32_t *palocmask,
                                 rt_uint32_t count, rt_int32_t *hdr)
{
    rt_int32_t i;
    for (i = 0; i < count; i++)
    {
        rt_enter_critical();
        if ((pmask[i] & ~palocmask[i]) != 0)
        {
            *hdr = __rt_ffs(pmask[i] & ~palocmask[i]) - 1 + i * 32;
            palocmask[i] |= 0x01 << (*hdr % 0x1F);
            rt_exit_critical();
            return RT_EOK;
        }
        rt_exit_critical();
    }
    if (i >= count)
    {
        return RT_ENOMEM;
    }
    return RT_EOK;
}
static rt_err_t bxcanallocnewfilter(struct stm_bxcan *pbxcan, rt_int32_t actived,
                                    rt_int32_t type, rt_int32_t *hdr, rt_int32_t *base, rt_int32_t *off)
{
    rt_err_t res;
    *hdr = -1;
    switch (type)
    {
    case 0x03:
        res = bxcanallocfilter(pbxcan->filtermask.id32maskm, pbxcan->alocmask,
                               BX_CAN_FILTER_MAX_ARRAY_SIZE, hdr);
        break;
    case 0x02:
        res = bxcanallocfilter(pbxcan->filtermask.id32bitm, pbxcan->alocmask,
                               BX_CAN_FILTER_MAX_ARRAY_SIZE, hdr);
        break;
    case 0x01:
        res = bxcanallocfilter(pbxcan->filtermask.id16maskm, pbxcan->alocmask,
                               BX_CAN_FILTER_MAX_ARRAY_SIZE, hdr);
        break;
    case 0x00:
        res = bxcanallocfilter(pbxcan->filtermask.id16bitm, pbxcan->alocmask,
                               BX_CAN_FILTER_MAX_ARRAY_SIZE, hdr);
        break;
    }
    if (res != RT_EOK  || *hdr < 0)
    {
        return RT_ENOMEM;
    }
    bxcancalcbaseoff(pbxcan, *hdr, base, off);
    return RT_EOK;
}
static rt_err_t bxmodifyfilter(struct stm_bxcan *pbxcan, struct rt_can_filter_item *pitem, rt_uint32_t actived)
{
    rt_int32_t fcase;
    rt_err_t res;
    rt_int32_t hdr, fbase, foff;

    fcase = (pitem->mode | (pitem->ide << 1));
    hdr = bxcanfindfilter(pbxcan, pitem, fcase, &fbase, &foff);
    if (hdr < 0)
    {
        if (!actived)
        {
            return RT_EOK;
        }
        else if (pitem->hdr == -1)
        {
            res = bxcanallocnewfilter(pbxcan, actived, fcase, &hdr, &fbase, &foff);
            if (res != RT_EOK)
            {
                return res;
            }
        }
        else if (pitem->hdr >= 0)
        {
            rt_enter_critical();
            res = bxcancalcbaseoff(pbxcan, pitem->hdr, &fbase, &foff);
            if (res != RT_EOK)
            {
                return res;
            }
            hdr = pitem->hdr;
            if (actived)
            {
                pbxcan->alocmask[hdr >> 5] |= 0x01 << (hdr % 0x1F);
            }
            rt_exit_critical();
        }
    }
    else
    {
        if (!actived)
        {
            pitem->hdr = hdr;
        }
        else if (hdr >= 0 && (pitem->hdr >= 0 || pitem->hdr == -1))
        {
            pitem->hdr = hdr;
            return RT_EBUSY;
        }
    }
    rt_uint32_t ID[2];
    rt_uint32_t shift;
    rt_uint32_t thisid;
    rt_uint32_t thismask;
    CAN_FilterInitTypeDef  CAN_FilterInitStructure;

    pitem->hdr =  hdr;
    CAN_FilterRegister_TypeDef *pfilterreg = &((CAN_FilterRegister_TypeDef *)pbxcan->mfrbase)[fbase];
    ID[0] = pfilterreg->FR1;
    ID[1] = pfilterreg->FR2;
    CAN_FilterInitStructure.CAN_FilterNumber = (pfilterreg - &CAN1->sFilterRegister[0]);
    if (pitem->mode)
    {
        CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;
    }
    else
    {
        CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdList;
    }
    if (pitem->ide)
    {
        CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;
    }
    else
    {
        CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_16bit;
    }
    switch (fcase)
    {
    case 0x03:
        if (actived)
        {
            shift = 3;
            thisid = (rt_uint32_t)pitem->id << shift;
            thismask = (rt_uint32_t)pitem->mask << shift;
            if (pitem->ide)
            {
                thisid |= CAN_ID_EXT;
                thismask |= CAN_ID_EXT;
            }
            if (pitem->rtr)
            {
                thisid |= CAN_RTR_REMOTE;
                thismask |= CAN_RTR_REMOTE;
            }
            ID[0] = thisid;
            ID[1] = thismask;
        }
        else
        {
            ID[0] = 0xFFFFFFFF;
            ID[1] = 0xFFFFFFFF;
        }
        break;
    case 0x02:
        if (actived)
        {
            shift = 3;
            thisid = (rt_uint32_t)pitem->id << shift;
            if (pitem->ide)
            {
                thisid |= CAN_ID_EXT;
            }
            if (pitem->rtr)
            {
                thisid |= CAN_RTR_REMOTE;
            }
            ID[foff] = thisid;
        }
        else
        {
            ID[foff] = 0xFFFFFFFF;
        }
        break;
    case 0x01:
        if (actived)
        {
            shift = 5;
            thisid = pitem->id << shift;
            if (pitem->rtr)
            {
                thisid |= CAN_RTR_REMOTE << (shift - 2);
            }
            thismask = pitem->mask << shift;
            if (pitem->rtr)
            {
                thismask |= CAN_RTR_REMOTE << (shift - 2);
            }
            ID[foff] = (thisid & 0x0000FFFF) | ((thismask & 0x0000FFFF) << 16);
        }
        else
        {
            ID[foff] = 0xFFFFFFFF;
        }
        break;
    case 0x00:
        if (actived)
        {
            shift = 5;
            thisid = pitem->id << shift;
            if (pitem->rtr)
            {
                thisid |= CAN_RTR_REMOTE << (shift - 2);
            }
            ((rt_uint16_t *) ID)[foff] = thisid;
        }
        else
        {
            ((rt_uint16_t *) ID)[foff] = 0xFFFF;
        }
        break;
    }
    CAN_FilterInitStructure.CAN_FilterIdHigh = ((ID[1]) & 0x0000FFFF);
    CAN_FilterInitStructure.CAN_FilterIdLow = ID[0] & 0x0000FFFF;
    CAN_FilterInitStructure.CAN_FilterMaskIdHigh = (ID[1] & 0xFFFF0000) >> 16;
    CAN_FilterInitStructure.CAN_FilterMaskIdLow = (ID[0] & 0xFFFF0000) >> 16;
    if (fbase >= pbxcan->fifo1filteroff)
    {
        CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 1;
    }
    else
    {
        CAN_FilterInitStructure.CAN_FilterFIFOAssignment = 0;
    }
    if (ID[0] != 0xFFFFFFFF || ID[1] != 0xFFFFFFFF)
    {
        CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;
    }
    else
    {
        CAN_FilterInitStructure.CAN_FilterActivation = DISABLE;
    }
    if (!actived)
    {
        rt_enter_critical();
        pbxcan->alocmask[hdr >> 5] &= ~(0x01 << (hdr % 0x1F));
        rt_exit_critical();
    }
    CAN_FilterInit(&CAN_FilterInitStructure);
    return RT_EOK;
}
static rt_err_t setfilter(struct stm_bxcan *pbxcan, struct rt_can_filter_config *pconfig)
{
    struct rt_can_filter_item *pitem = pconfig->items;
    rt_uint32_t count = pconfig->count;
    rt_err_t res;
    while (count)
    {
        res = bxmodifyfilter(pbxcan, pitem, pconfig->actived);
        if (res != RT_EOK)
        {
            return res;
        }
        pitem++;
        count--;
    }
    return RT_EOK;
}
static rt_err_t configure(struct rt_can_device *can, struct can_configure *cfg)
{
    CAN_TypeDef *pbxcan;

    pbxcan = ((struct stm_bxcan *) can->parent.user_data)->reg;
    assert_param(IS_CAN_ALL_PERIPH(pbxcan));
    if (pbxcan == CAN1)
    {
        bxcan1_hw_init();
        bxcan_init(pbxcan, cfg->baud_rate, can->config.mode);
        bxcan1_filter_init(can);
    }
    else
    {
#ifdef USING_BXCAN2
        bxcan2_hw_init();
        bxcan_init(pbxcan, cfg->baud_rate, can->config.mode);
        bxcan2_filter_init(can);
#endif
    }
    return RT_EOK;
}
static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
{
    struct stm_bxcan *pbxcan;
    rt_uint32_t argval;
    NVIC_InitTypeDef  NVIC_InitStructure;

    pbxcan = (struct stm_bxcan *) can->parent.user_data;
    assert_param(pbxcan != RT_NULL);

    switch (cmd)
    {
    case RT_DEVICE_CTRL_CLR_INT:
        argval = (rt_uint32_t) arg;
        if (argval == RT_DEVICE_FLAG_INT_RX)
        {
            NVIC_DisableIRQ(pbxcan->rcvirq0);
            NVIC_DisableIRQ(pbxcan->rcvirq1);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FMP0 , DISABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FF0 , DISABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FOV0 , DISABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FMP1 , DISABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FF1 , DISABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FOV1 , DISABLE);
        }
        else if (argval == RT_DEVICE_FLAG_INT_TX)
        {
            NVIC_DisableIRQ(pbxcan->sndirq);
            CAN_ITConfig(pbxcan->reg, CAN_IT_TME, DISABLE);
        }
        else if (argval == RT_DEVICE_CAN_INT_ERR)
        {
            CAN_ITConfig(pbxcan->reg, CAN_IT_BOF , DISABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_LEC , DISABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_ERR , DISABLE);
            NVIC_DisableIRQ(pbxcan->errirq);
        }
        break;
    case RT_DEVICE_CTRL_SET_INT:
        argval = (rt_uint32_t) arg;
        if (argval == RT_DEVICE_FLAG_INT_RX)
        {
            CAN_ITConfig(pbxcan->reg, CAN_IT_FMP0 , ENABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FF0 , ENABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FOV0 , ENABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FMP1 , ENABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FF1 , ENABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_FOV1 , ENABLE);
            NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x1;
            NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
            NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
            NVIC_InitStructure.NVIC_IRQChannel = pbxcan->rcvirq0;
            NVIC_Init(&NVIC_InitStructure);
            NVIC_InitStructure.NVIC_IRQChannel = pbxcan->rcvirq1;
            NVIC_Init(&NVIC_InitStructure);
        }
        else if (argval == RT_DEVICE_FLAG_INT_TX)
        {
            CAN_ITConfig(pbxcan->reg, CAN_IT_TME, ENABLE);
            NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x1;
            NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
            NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
            NVIC_InitStructure.NVIC_IRQChannel = pbxcan->sndirq;
            NVIC_Init(&NVIC_InitStructure);
        }
        else if (argval == RT_DEVICE_CAN_INT_ERR)
        {
            CAN_ITConfig(pbxcan->reg, CAN_IT_BOF , ENABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_LEC , ENABLE);
            CAN_ITConfig(pbxcan->reg, CAN_IT_ERR , ENABLE);
            NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x1;
            NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0;
            NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
            NVIC_InitStructure.NVIC_IRQChannel = pbxcan->errirq;
            NVIC_Init(&NVIC_InitStructure);
        }
        break;
    case RT_CAN_CMD_SET_FILTER:
        return setfilter(pbxcan, (struct rt_can_filter_config *) arg);
        break;
    case RT_CAN_CMD_SET_MODE:
        argval = (rt_uint32_t) arg;
        if (argval != RT_CAN_MODE_NORMAL ||
                argval != RT_CAN_MODE_LISEN ||
                argval != RT_CAN_MODE_LOOPBACK ||
                argval != RT_CAN_MODE_LOOPBACKANLISEN)
        {
            return RT_ERROR;
        }
        if (argval != can->config.mode)
        {
            can->config.mode = argval;
            return bxcan_set_mode(pbxcan->reg, argval);
        }
        break;
    case RT_CAN_CMD_SET_BAUD:
        argval = (rt_uint32_t) arg;
        if (argval != CAN1MBaud &&
                argval != CAN800kBaud &&
                argval != CAN500kBaud &&
                argval != CAN250kBaud &&
                argval != CAN125kBaud &&
                argval != CAN100kBaud &&
                argval != CAN50kBaud  &&
                argval != CAN20kBaud  &&
                argval != CAN10kBaud)
        {
            return RT_ERROR;
        }
        if (argval != can->config.baud_rate)
        {
            can->config.baud_rate = argval;
            return bxcan_set_baud_rate(pbxcan->reg, argval);
        }
        break;
    case RT_CAN_CMD_SET_PRIV:
        argval = (rt_uint32_t) arg;
        if (argval != RT_CAN_MODE_PRIV ||
                argval != RT_CAN_MODE_NOPRIV)
        {
            return RT_ERROR;
        }
        if (argval != can->config.privmode)
        {
            can->config.privmode = argval;
            return bxcan_set_privmode(pbxcan->reg, argval);
        }
        break;
    case RT_CAN_CMD_GET_STATUS:
    {
        rt_uint32_t errtype;
        errtype = pbxcan->reg->ESR;
        can->status.rcverrcnt = errtype >> 24;
        can->status.snderrcnt = (errtype >> 16 & 0xFF);
        can->status.errcode = errtype & 0x07;
        if (arg != &can->status)
        {
            rt_memcpy(arg, &can->status, sizeof(can->status));
        }
    }
    break;
    }

    return RT_EOK;
}
static int sendmsg(struct rt_can_device *can, const void *buf, rt_uint32_t boxno)
{
    CAN_TypeDef *pbxcan;
    struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;

    pbxcan = ((struct stm_bxcan *) can->parent.user_data)->reg;
    assert_param(IS_CAN_ALL_PERIPH(pbxcan));

    pbxcan->sTxMailBox[boxno].TIR &= TMIDxR_TXRQ;
    if (pmsg->ide == RT_CAN_STDID)
    {
        assert_param(IS_CAN_STDID(pmsg->id));
        pbxcan->sTxMailBox[boxno].TIR |= ((pmsg->id << 21) | \
                                          (pmsg->rtr << 1));
    }
    else
    {
        assert_param(IS_CAN_EXTID(pmsg->id));
        pbxcan->sTxMailBox[boxno].TIR |= ((pmsg->id << 3) | \
                                          (pmsg->ide << 2) | \
                                          (pmsg->rtr << 1));
    }

    pmsg->len &= (uint8_t)0x0000000F;
    pbxcan->sTxMailBox[boxno].TDTR &= (uint32_t)0xFFFFFFF0;
    pbxcan->sTxMailBox[boxno].TDTR |= pmsg->len;

    pbxcan->sTxMailBox[boxno].TDLR = (((uint32_t)pmsg->data[3] << 24) |
                                      ((uint32_t)pmsg->data[2] << 16) |
                                      ((uint32_t)pmsg->data[1] << 8) |
                                      ((uint32_t)pmsg->data[0]));
    if (pmsg->len > 4)
    {
        pbxcan->sTxMailBox[boxno].TDHR = (((uint32_t)pmsg->data[7] << 24) |
                                          ((uint32_t)pmsg->data[6] << 16) |
                                          ((uint32_t)pmsg->data[5] << 8) |
                                          ((uint32_t)pmsg->data[4]));
    }
    pbxcan->sTxMailBox[boxno].TIR |= TMIDxR_TXRQ;

    return RT_EOK;
}
static int recvmsg(struct rt_can_device *can, void *buf, rt_uint32_t boxno)
{
    CAN_TypeDef *pbxcan;
    struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;

    pbxcan = ((struct stm_bxcan *) can->parent.user_data)->reg;
    assert_param(IS_CAN_ALL_PERIPH(pbxcan));
    assert_param(IS_CAN_FIFO(boxno));
    pmsg->ide = ((uint8_t)0x04 & pbxcan->sFIFOMailBox[boxno].RIR) >> 2;
    if (pmsg->ide == CAN_Id_Standard)
    {
        pmsg->id = (uint32_t)0x000007FF & (pbxcan->sFIFOMailBox[boxno].RIR >> 21);
    }
    else
    {
        pmsg->id = (uint32_t)0x1FFFFFFF & (pbxcan->sFIFOMailBox[boxno].RIR >> 3);
    }

    pmsg->rtr = (uint8_t)((0x02 & pbxcan->sFIFOMailBox[boxno].RIR) >> 1);
    pmsg->len = (uint8_t)0x0F & pbxcan->sFIFOMailBox[boxno].RDTR;
    pmsg->data[0] = (uint8_t)0xFF & pbxcan->sFIFOMailBox[boxno].RDLR;
    pmsg->data[1] = (uint8_t)0xFF & (pbxcan->sFIFOMailBox[boxno].RDLR >> 8);
    pmsg->data[2] = (uint8_t)0xFF & (pbxcan->sFIFOMailBox[boxno].RDLR >> 16);
    pmsg->data[3] = (uint8_t)0xFF & (pbxcan->sFIFOMailBox[boxno].RDLR >> 24);
    if (pmsg->len > 4)
    {
        pmsg->data[4] = (uint8_t)0xFF & pbxcan->sFIFOMailBox[boxno].RDHR;
        pmsg->data[5] = (uint8_t)0xFF & (pbxcan->sFIFOMailBox[boxno].RDHR >> 8);
        pmsg->data[6] = (uint8_t)0xFF & (pbxcan->sFIFOMailBox[boxno].RDHR >> 16);
        pmsg->data[7] = (uint8_t)0xFF & (pbxcan->sFIFOMailBox[boxno].RDHR >> 24);
    }
    pmsg->hdr = (uint8_t)0xFF & (pbxcan->sFIFOMailBox[boxno].RDTR >> 8);
    if (boxno) pmsg->hdr += ((struct stm_bxcan *) can->parent.user_data)->fifo1filteroff * 4;
    return RT_EOK;
}

static const struct rt_can_ops canops =
{
    configure,
    control,
    sendmsg,
    recvmsg,
};
#ifdef USING_BXCAN1
static struct stm_bxcan bxcan1data =
{
    .reg = CAN1,
    .mfrbase = (void *) &CAN1->sFilterRegister[0],
    .sndirq = CAN1_TX_IRQn,
    .rcvirq0 = CAN1_RX0_IRQn,
    .rcvirq1 = CAN1_RX1_IRQn,
    .errirq =  CAN1_SCE_IRQn,
    .alocmask = {0, 0},
    .filtercnt = BX_CAN2_FMRSTART,
    .fifo1filteroff = 7,
    .filtermap = {
        [0] = {
            .id32mask_cnt = 0,
            .id32bit_cnt = 0,
            .id16mask_cnt = 2,
            .id16bit_cnt = 24,
        },
        [1] = {
            .id32mask_cnt = 0,
            .id32bit_cnt = 0,
            .id16mask_cnt = 2,
            .id16bit_cnt = 24,
        },
    },
};
struct rt_can_device bxcan1;
void CAN1_RX0_IRQHandler(void)
{
    if (CAN1->RF0R & 0x03)
    {
        if ((CAN1->RF0R & CAN_RF0R_FOVR0) != 0)
        {
            CAN1->RF0R = CAN_RF0R_FOVR0;
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_RXOF_IND | 0 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_RX_IND | 0 << 8);
        }
        CAN1->RF0R |= CAN_RF0R_RFOM0;
    }
}
void CAN1_RX1_IRQHandler(void)
{
    if (CAN1->RF1R & 0x03)
    {
        if ((CAN1->RF1R & CAN_RF1R_FOVR1) != 0)
        {
            CAN1->RF1R = CAN_RF1R_FOVR1;
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_RXOF_IND | 1 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_RX_IND | 1 << 8);
        }
        CAN1->RF1R |= CAN_RF1R_RFOM1;
    }
}
void CAN1_TX_IRQHandler(void)
{
    rt_uint32_t state;
    if (CAN1->TSR & (CAN_TSR_RQCP0))
    {
        state =  CAN1->TSR & (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0);
        CAN1->TSR |= CAN_TSR_RQCP0;
        if (state == (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0))
        {
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_TX_DONE | 0 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_TX_FAIL | 0 << 8);
        }
    }
    if (CAN1->TSR & (CAN_TSR_RQCP1))
    {
        state =  CAN1->TSR & (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1);
        CAN1->TSR |= CAN_TSR_RQCP1;
        if (state == (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1))
        {
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_TX_DONE | 1 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_TX_FAIL | 1 << 8);
        }
    }
    if (CAN1->TSR & (CAN_TSR_RQCP2))
    {
        state =  CAN1->TSR & (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2);
        CAN1->TSR |= CAN_TSR_RQCP2;
        if (state == (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2))
        {
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_TX_DONE | 2 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan1, RT_CAN_EVENT_TX_FAIL | 2 << 8);
        }
    }
}
void CAN1_SCE_IRQHandler(void)
{
    rt_uint32_t errtype;
    errtype = CAN1->ESR;
    if (errtype & 0x70 && bxcan1.status.lasterrtype == (errtype & 0x70))
    {
        switch ((errtype & 0x70) >> 4)
        {
        case RT_CAN_BUS_BIT_PAD_ERR:
            bxcan1.status.bitpaderrcnt++;
            break;
        case RT_CAN_BUS_FORMAT_ERR:
            bxcan1.status.formaterrcnt++;
            break;
        case RT_CAN_BUS_ACK_ERR:
            bxcan1.status.ackerrcnt++;
            break;
        case RT_CAN_BUS_IMPLICIT_BIT_ERR:
        case RT_CAN_BUS_EXPLICIT_BIT_ERR:
            bxcan1.status.biterrcnt++;
            break;
        case RT_CAN_BUS_CRC_ERR:
            bxcan1.status.crcerrcnt++;
            break;
        }
        bxcan1.status.lasterrtype = errtype & 0x70;
        CAN1->ESR &= ~0x70;
    }
    bxcan1.status.rcverrcnt = errtype >> 24;
    bxcan1.status.snderrcnt = (errtype >> 16 & 0xFF);
    bxcan1.status.errcode = errtype & 0x07;
    CAN1->MSR |= CAN_MSR_ERRI;
}
#endif /*USING_BXCAN1*/

#ifdef USING_BXCAN2
static struct stm_bxcan bxcan2data =
{
    .reg = CAN2,
    .mfrbase = (void *) &CAN1->sFilterRegister[BX_CAN2_FMRSTART],
    .sndirq = CAN2_TX_IRQn,
    .rcvirq0 = CAN2_RX0_IRQn,
    .rcvirq1 = CAN2_RX1_IRQn,
    .errirq =  CAN2_SCE_IRQn,
    .alocmask = {0, 0},
    .filtercnt = BX_CAN_FMRNUMBER - BX_CAN2_FMRSTART,
    .fifo1filteroff = 7,
    .filtermap = {
        [0] = {
            .id32mask_cnt = 0,
            .id32bit_cnt = 0,
            .id16mask_cnt = 2,
            .id16bit_cnt = 24,
        },
        [1] = {
            .id32mask_cnt = 0,
            .id32bit_cnt = 0,
            .id16mask_cnt = 2,
            .id16bit_cnt = 24,
        },
    },
};

struct rt_can_device bxcan2;
void CAN2_RX0_IRQHandler(void)
{
    if (CAN2->RF0R & 0x03)
    {
        if ((CAN2->RF0R & CAN_RF0R_FOVR0) != 0)
        {
            CAN2->RF0R = CAN_RF0R_FOVR0;
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_RXOF_IND | 0 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_RX_IND | 0 << 8);
        }
        CAN2->RF0R |= CAN_RF0R_RFOM0;
    }
}
void CAN2_RX1_IRQHandler(void)
{
    if (CAN2->RF1R & 0x03)
    {
        if ((CAN2->RF1R & CAN_RF1R_FOVR1) != 0)
        {
            CAN2->RF1R = CAN_RF1R_FOVR1;
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_RXOF_IND | 1 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_RX_IND | 1 << 8);
        }
        CAN2->RF1R |= CAN_RF1R_RFOM1;
    }
}
void CAN2_TX_IRQHandler(void)
{
    rt_uint32_t state;
    if (CAN2->TSR & (CAN_TSR_RQCP0))
    {
        state =  CAN2->TSR & (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0);
        CAN2->TSR |= CAN_TSR_RQCP0;
        if (state == (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0))
        {
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_TX_DONE | 0 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_TX_FAIL | 0 << 8);
        }
    }
    if (CAN2->TSR & (CAN_TSR_RQCP1))
    {
        state =  CAN2->TSR & (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1);
        CAN2->TSR |= CAN_TSR_RQCP1;
        if (state == (CAN_TSR_RQCP1 | CAN_TSR_TXOK1 | CAN_TSR_TME1))
        {
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_TX_DONE | 1 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_TX_FAIL | 1 << 8);
        }
    }
    if (CAN2->TSR & (CAN_TSR_RQCP2))
    {
        state =  CAN2->TSR & (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2);
        CAN2->TSR |= CAN_TSR_RQCP2;
        if (state == (CAN_TSR_RQCP2 | CAN_TSR_TXOK2 | CAN_TSR_TME2))
        {
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_TX_DONE | 2 << 8);
        }
        else
        {
            rt_hw_can_isr(&bxcan2, RT_CAN_EVENT_TX_FAIL | 2 << 8);
        }
    }
}
void CAN2_SCE_IRQHandler(void)
{
    rt_uint32_t errtype;
    errtype = CAN2->ESR;
    if (errtype & 0x70 && bxcan2.status.lasterrtype == (errtype & 0x70))
    {
        switch ((errtype & 0x70) >> 4)
        {
        case RT_CAN_BUS_BIT_PAD_ERR:
            bxcan2.status.bitpaderrcnt++;
            break;
        case RT_CAN_BUS_FORMAT_ERR:
            bxcan2.status.formaterrcnt++;
            break;
        case RT_CAN_BUS_ACK_ERR:
            bxcan2.status.ackerrcnt++;
            break;
        case RT_CAN_BUS_IMPLICIT_BIT_ERR:
        case RT_CAN_BUS_EXPLICIT_BIT_ERR:
            bxcan2.status.biterrcnt++;
            break;
        case RT_CAN_BUS_CRC_ERR:
            bxcan2.status.crcerrcnt++;
            break;
        }
        bxcan2.status.lasterrtype = errtype & 0x70;
        CAN2->ESR &= ~0x70;
    }
    bxcan2.status.rcverrcnt = errtype >> 24;
    bxcan2.status.snderrcnt = (errtype >> 16 & 0xFF);
    bxcan2.status.errcode = errtype & 0x07;
    CAN2->MSR |= CAN_MSR_ERRI;
}
#endif /*USING_BXCAN2*/

int stm32_bxcan_init(void)
{

#ifdef USING_BXCAN1
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1 , ENABLE);
    CAN_DeInit(CAN1);
    bxcan1.config.baud_rate = CAN1MBaud;
    bxcan1.config.msgboxsz = 16;
    bxcan1.config.sndboxnumber = 3;
    bxcan1.config.mode = RT_CAN_MODE_NORMAL;
    bxcan1.config.privmode = 0;
    bxcan1.config.ticks = 50;
#ifdef RT_CAN_USING_HDR
    bxcan1.config.maxhdr = BX_CAN2_FMRSTART * 4;
#endif
    rt_hw_can_register(&bxcan1, "bxcan1", &canops, &bxcan1data);
#endif

#ifdef USING_BXCAN2
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);
#ifndef USING_BXCAN1
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1 , ENABLE);
#endif
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2, ENABLE);
    CAN_DeInit(CAN2);
    bxcan2.config.baud_rate = CAN1MBaud;
    bxcan2.config.msgboxsz = 16;
    bxcan2.config.sndboxnumber = 3;
    bxcan2.config.mode = RT_CAN_MODE_NORMAL;
    bxcan2.config.privmode = 0;
    bxcan2.config.ticks = 50;
#ifdef RT_CAN_USING_HDR
    bxcan2.config.maxhdr = (BX_CAN_FMRNUMBER - BX_CAN2_FMRSTART) * 4;
#endif
    rt_hw_can_register(&bxcan2, "bxcan2", &canops, &bxcan2data);
#endif
    return RT_EOK;
}
INIT_BOARD_EXPORT(stm32_bxcan_init);

#endif /*RT_USING_CAN*/