Skip to content

R
rt-thread

2345VOR / rt-thread
与 Fork 源项目一致

Fork自 RT-Thread / rt-thread

通知 1
Star 0
Fork 0
R
rt-thread

体验新版 GitCode，发现更多精彩内容 >>

提交 66628f10 编写于 作者: 斌cazure's avatar 斌cazure
浏览文件
操作

格式化代码

上级 b4b93940
隐藏空白更改
内联 并排
Showing with 454 addition and 466 deletion
bsp/n32g452xx/Libraries/rt_drivers/drv_can.c
浏览文件 @ 66628f10
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
* Copyright (c) 2006-2022, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
......@@ -17,33 +17,34 @@
struct n32g45x_baud_rate_tab
{
uint32_t baud_rate;
uint16_t PRESCALE;
uint8_t RSJW;
uint8_t TBS1;
uint8_t TBS2;
uint8_t notused;
uint32_t baud_rate;
uint16_t PRESCALE;
uint8_t RSJW;
uint8_t TBS1;
uint8_t TBS2;
uint8_t notused;
};
#define N32_CAN_BAUD_DEF(rate,rsjw,tbs1,tbs2,prescale) \
{.baud_rate = rate, \
.RSJW = rsjw, \
.TBS1 = tbs1, \
.TBS2 = tbs2, \
.PRESCALE = prescale \
}
#define N32_CAN_BAUD_DEF(rate, rsjw, tbs1, tbs2, prescale) \
{ \
.baud_rate = rate, \
.RSJW = rsjw, \
.TBS1 = tbs1, \
.TBS2 = tbs2, \
.PRESCALE = prescale \
}
/* N32G45x can device */
struct n32g45x_can
{
char *name;
CAN_Module * CANx;
CAN_InitType can_init;
CAN_FilterInitType can_filter_init;
struct rt_can_device device; /* inherit from can device */
CAN_Module *CANx;
CAN_InitType can_init;
CAN_FilterInitType can_filter_init;
struct rt_can_device device; /* inherit from can device */
};
#define LOG_TAG "drv_can"
#define LOG_TAG "drv_can"
#include <drv_log.h>
/*
......@@ -51,34 +52,34 @@ struct n32g45x_can
* baud calculation example: baud = Tclk / ((ss + bs1 + bs2) * brp)
* 36MHz / ((1 + 5 + 3) * 4) = 1MHz
*/
#if defined (N32G45X)/* APB1 36MHz(max) */
#if defined(N32G45X) /* APB1 36MHz(max) */
static const struct n32g45x_baud_rate_tab can_baud_rate_tab[] =
{
N32_CAN_BAUD_DEF(CAN1MBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 4),
N32_CAN_BAUD_DEF(CAN800kBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 5),
N32_CAN_BAUD_DEF(CAN500kBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 8),
N32_CAN_BAUD_DEF(CAN250kBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 16),
N32_CAN_BAUD_DEF(CAN125kBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 32),
N32_CAN_BAUD_DEF(CAN100kBaud, CAN_RSJW_2tq, CAN_TBS1_8tq, CAN_TBS2_8tq, 20),
N32_CAN_BAUD_DEF(CAN50kBaud, CAN_RSJW_2tq, CAN_TBS1_8tq, CAN_TBS2_8tq, 40),
N32_CAN_BAUD_DEF(CAN20kBaud, CAN_RSJW_2tq, CAN_TBS1_8tq, CAN_TBS2_8tq, 80),
N32_CAN_BAUD_DEF(CAN10kBaud, CAN_RSJW_2tq, CAN_TBS1_8tq, CAN_TBS2_8tq, 160),
{
N32_CAN_BAUD_DEF(CAN1MBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 4),
N32_CAN_BAUD_DEF(CAN800kBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 5),
N32_CAN_BAUD_DEF(CAN500kBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 8),
N32_CAN_BAUD_DEF(CAN250kBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 16),
N32_CAN_BAUD_DEF(CAN125kBaud, CAN_RSJW_1tq, CAN_TBS1_5tq, CAN_TBS2_3tq, 32),
N32_CAN_BAUD_DEF(CAN100kBaud, CAN_RSJW_2tq, CAN_TBS1_8tq, CAN_TBS2_8tq, 20),
N32_CAN_BAUD_DEF(CAN50kBaud, CAN_RSJW_2tq, CAN_TBS1_8tq, CAN_TBS2_8tq, 40),
N32_CAN_BAUD_DEF(CAN20kBaud, CAN_RSJW_2tq, CAN_TBS1_8tq, CAN_TBS2_8tq, 80),
N32_CAN_BAUD_DEF(CAN10kBaud, CAN_RSJW_2tq, CAN_TBS1_8tq, CAN_TBS2_8tq, 160),
};
#endif
#ifdef BSP_USING_CAN1
static struct n32g45x_can drv_can1 =
{
.name = "can1",
.CANx = CAN1,
{
.name = "can1",
.CANx = CAN1,
};
#endif
#ifdef BSP_USING_CAN2
static struct n32g45x_can drv_can2 =
{
.name = "can2",
.CANx = CAN2,
{
.name = "can2",
.CANx = CAN2,
};
#endif
......@@ -97,44 +98,43 @@ static uint32_t get_can_baud_index(rt_uint32_t baud)
static uint8_t get_can_mode_rtt2n32(uint8_t rtt_can_mode)
{
uint8_t mode = CAN_Normal_Mode;
switch (rtt_can_mode)
{
case RT_CAN_MODE_NORMAL:
mode = CAN_Normal_Mode;
break;
case RT_CAN_MODE_LISEN:
mode = CAN_Silent_Mode;
break;
case RT_CAN_MODE_LOOPBACK:
mode = CAN_LoopBack_Mode;
break;
case RT_CAN_MODE_LOOPBACKANLISEN:
mode = CAN_Silent_LoopBack_Mode;
break;
}
return mode;
uint8_t mode = CAN_Normal_Mode;
switch (rtt_can_mode)
{
case RT_CAN_MODE_NORMAL:
mode = CAN_Normal_Mode;
break;
case RT_CAN_MODE_LISEN:
mode = CAN_Silent_Mode;
break;
case RT_CAN_MODE_LOOPBACK:
mode = CAN_LoopBack_Mode;
break;
case RT_CAN_MODE_LOOPBACKANLISEN:
mode = CAN_Silent_LoopBack_Mode;
break;
}
return mode;
}
static rt_err_t _can_filter_config(struct n32g45x_can *drv_can)
{
if(drv_can->CANx == CAN1)
{
CAN1_InitFilter(&(drv_can->can_filter_init));
}
if (drv_can->CANx == CAN1)
{
CAN1_InitFilter(&(drv_can->can_filter_init));
}
#ifdef CAN2
else
if(drv_can->CANx == CAN2)
{
CAN2_InitFilter(&(drv_can->can_filter_init));
}
else if (drv_can->CANx == CAN2)
{
CAN2_InitFilter(&(drv_can->can_filter_init));
}
#endif
else
{
rt_kprintf("can filter config error\n");
return -RT_EINVAL;
}
return RT_EOK;
else
{
rt_kprintf("can filter config error\n");
return -RT_EINVAL;
}
return RT_EOK;
}
static rt_err_t _can_config(struct rt_can_device *can, struct can_configure *cfg)
......@@ -146,57 +146,53 @@ static rt_err_t _can_config(struct rt_can_device *can, struct can_configure *cfg
RT_ASSERT(cfg);
drv_can = (struct n32g45x_can *)can->parent.user_data;
RT_ASSERT(drv_can);
/* CAN1 and CAN2 register init */
//CAN_DeInit(drv_can->CANx);
/* Configure CAN1 and CAN2 */
if(drv_can->CANx == CAN1)
{
RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_CAN1 , ENABLE);
n32_msp_can_init(CAN1);
}
/* Configure CAN1 and CAN2 */
if (drv_can->CANx == CAN1)
{
RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_CAN1, ENABLE);
n32_msp_can_init(CAN1);
}
#ifdef CAN2
else
if(drv_can->CANx == CAN2)
{
RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_CAN2 , ENABLE);
n32_msp_can_init(CAN2);
}
else if (drv_can->CANx == CAN2)
{
RCC_EnableAPB1PeriphClk(RCC_APB1_PERIPH_CAN2, ENABLE);
n32_msp_can_init(CAN2);
}
#endif
else
{
rt_kprintf("can init error1\n");
return -RT_EINVAL;
}
else
{
rt_kprintf("can init error1\n");
return -RT_EINVAL;
}
/* Struct init*/
CAN_InitStruct(&(drv_can->can_init));
drv_can->can_init.TTCM = DISABLE;
drv_can->can_init.ABOM = DISABLE;
drv_can->can_init.AWKUM = DISABLE;
drv_can->can_init.NART = DISABLE;
drv_can->can_init.RFLM = DISABLE;
drv_can->can_init.TXFP = ENABLE;
//mode
drv_can->can_init.TTCM = DISABLE;
drv_can->can_init.ABOM = DISABLE;
drv_can->can_init.AWKUM = DISABLE;
drv_can->can_init.NART = DISABLE;
drv_can->can_init.RFLM = DISABLE;
drv_can->can_init.TXFP = ENABLE;
//mode
drv_can->can_init.OperatingMode = get_can_mode_rtt2n32(cfg->mode);
//baud
//baud
baud_index = get_can_baud_index(cfg->baud_rate);
drv_can->can_init.RSJW = can_baud_rate_tab[baud_index].RSJW;
drv_can->can_init.TBS1 = can_baud_rate_tab[baud_index].TBS1;
drv_can->can_init.TBS2 = can_baud_rate_tab[baud_index].TBS2;
drv_can->can_init.BaudRatePrescaler = can_baud_rate_tab[baud_index].PRESCALE;
drv_can->can_init.RSJW = can_baud_rate_tab[baud_index].RSJW;
drv_can->can_init.TBS1 = can_baud_rate_tab[baud_index].TBS1;
drv_can->can_init.TBS2 = can_baud_rate_tab[baud_index].TBS2;
drv_can->can_init.BaudRatePrescaler = can_baud_rate_tab[baud_index].PRESCALE;
/* init can */
if( CAN_Init(drv_can->CANx, &(drv_can->can_init) ) != CAN_InitSTS_Success )
{
rt_kprintf("can init error2\n");
return -RT_ERROR;
}
/* default filter config */
_can_filter_config(drv_can);
if (CAN_Init(drv_can->CANx, &(drv_can->can_init)) != CAN_InitSTS_Success)
{
rt_kprintf("can init error2\n");
return -RT_ERROR;
}
/* default filter config */
_can_filter_config(drv_can);
return RT_EOK;
}
......@@ -221,7 +217,7 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
switch (cmd)
{
case RT_DEVICE_CTRL_CLR_INT:
argval = (rt_uint32_t) arg;
argval = (rt_uint32_t)arg;
if (argval == RT_DEVICE_FLAG_INT_RX)
{
if (CAN1 == drv_can->CANx)
......@@ -236,12 +232,12 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
NVIC_DisableIRQ(CAN2_RX1_IRQn);
}
#endif
CAN_INTConfig(drv_can->CANx, CAN_INT_FMP0, DISABLE); /*!< DATFIFO 0 message pending Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FF0, DISABLE); /*!< DATFIFO 0 full Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FOV0, DISABLE); /*!< DATFIFO 0 overrun Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FMP1, DISABLE); /*!< DATFIFO 1 message pending Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FF1, DISABLE); /*!< DATFIFO 1 full Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FOV1, DISABLE); /*!< DATFIFO 1 overrun Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FMP0, DISABLE); /*!< DATFIFO 0 message pending Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FF0, DISABLE); /*!< DATFIFO 0 full Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FOV0, DISABLE); /*!< DATFIFO 0 overrun Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FMP1, DISABLE); /*!< DATFIFO 1 message pending Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FF1, DISABLE); /*!< DATFIFO 1 full Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FOV1, DISABLE); /*!< DATFIFO 1 overrun Interrupt*/
}
else if (argval == RT_DEVICE_FLAG_INT_TX)
{
......@@ -255,7 +251,7 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
NVIC_DisableIRQ(CAN2_TX_IRQn);
}
#endif
CAN_INTConfig(drv_can->CANx, CAN_INT_TME, DISABLE); /*!< Transmit mailbox empty Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_TME, DISABLE); /*!< Transmit mailbox empty Interrupt*/
}
else if (argval == RT_DEVICE_CAN_INT_ERR)
{
......@@ -269,24 +265,24 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
NVIC_DisableIRQ(CAN2_SCE_IRQn);
}
#endif
CAN_INTConfig(drv_can->CANx, CAN_INT_EWG, DISABLE); /*!< Error warning Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_EPV, DISABLE); /*!< Error passive Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_BOF, DISABLE); /*!< Bus-off Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_LEC, DISABLE); /*!< Last error code Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_ERR, DISABLE); /*!< Error Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_EWG, DISABLE); /*!< Error warning Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_EPV, DISABLE); /*!< Error passive Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_BOF, DISABLE); /*!< Bus-off Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_LEC, DISABLE); /*!< Last error code Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_ERR, DISABLE); /*!< Error Interrupt*/
}
break;
case RT_DEVICE_CTRL_SET_INT:
argval = (rt_uint32_t) arg;
argval = (rt_uint32_t)arg;
if (argval == RT_DEVICE_FLAG_INT_RX)
{
CAN_INTConfig(drv_can->CANx, CAN_INT_FMP0, ENABLE); /*!< DATFIFO 0 message pending Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FF0, ENABLE); /*!< DATFIFO 0 full Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FOV0, ENABLE); /*!< DATFIFO 0 overrun Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FMP1, ENABLE); /*!< DATFIFO 1 message pending Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FF1, ENABLE); /*!< DATFIFO 1 full Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FOV1, ENABLE); /*!< DATFIFO 1 overrun Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FMP0, ENABLE); /*!< DATFIFO 0 message pending Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FF0, ENABLE); /*!< DATFIFO 0 full Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FOV0, ENABLE); /*!< DATFIFO 0 overrun Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FMP1, ENABLE); /*!< DATFIFO 1 message pending Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FF1, ENABLE); /*!< DATFIFO 1 full Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_FOV1, ENABLE); /*!< DATFIFO 1 overrun Interrupt*/
if (CAN1 == drv_can->CANx)
{
NVIC_SetPriority(CAN1_RX0_IRQn, 1);
......@@ -306,7 +302,7 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
}
else if (argval == RT_DEVICE_FLAG_INT_TX)
{
CAN_INTConfig(drv_can->CANx, CAN_INT_TME, ENABLE); /*!< Transmit mailbox empty Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_TME, ENABLE); /*!< Transmit mailbox empty Interrupt*/
if (CAN1 == drv_can->CANx)
{
......@@ -323,11 +319,11 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
}
else if (argval == RT_DEVICE_CAN_INT_ERR)
{
CAN_INTConfig(drv_can->CANx, CAN_INT_EWG, ENABLE); /*!< Error warning Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_EPV, ENABLE); /*!< Error passive Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_BOF, ENABLE); /*!< Bus-off Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_LEC, ENABLE); /*!< Last error code Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_ERR, ENABLE); /*!< Error Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_EWG, ENABLE); /*!< Error warning Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_EPV, ENABLE); /*!< Error passive Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_BOF, ENABLE); /*!< Bus-off Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_LEC, ENABLE); /*!< Last error code Interrupt*/
CAN_INTConfig(drv_can->CANx, CAN_INT_ERR, ENABLE); /*!< Error Interrupt*/
if (CAN1 == drv_can->CANx)
{
......@@ -349,12 +345,12 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
rt_uint32_t id_l = 0;
rt_uint32_t mask_h = 0;
rt_uint32_t mask_l = 0;
rt_uint32_t mask_l_tail = 0; //CAN_FxR2 bit [2:0]
rt_uint32_t mask_l_tail = 0; //CAN_FxR2 bit [2:0]
if (RT_NULL == arg)
{
/* default filter config */
_can_filter_config(drv_can);
_can_filter_config(drv_can);
}
else
{
......@@ -370,43 +366,44 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
{
drv_can->can_filter_init.Filter_Num = filter_cfg->items[i].hdr;
}
if (filter_cfg->items[i].mode == 0x00)
{
drv_can->can_filter_init.Filter_Mode = CAN_Filter_IdMaskMode;
drv_can->can_filter_init.Filter_Mode = CAN_Filter_IdMaskMode;
}
else if (filter_cfg->items[i].mode == 0x01)
{
drv_can->can_filter_init.Filter_Mode = CAN_Filter_IdListMode;
drv_can->can_filter_init.Filter_Mode = CAN_Filter_IdListMode;
}
if (filter_cfg->items[i].ide == RT_CAN_STDID)
{
id_h = ((filter_cfg->items[i].id << 18) >> 13) & 0xFFFF;
id_l = ((filter_cfg->items[i].id << 18) |
(filter_cfg->items[i].ide << 2) |
(filter_cfg->items[i].rtr << 1)) & 0xFFFF;
id_l = ((filter_cfg->items[i].id << 18) |
(filter_cfg->items[i].ide << 2) |
(filter_cfg->items[i].rtr << 1)) &
0xFFFF;
mask_h = ((filter_cfg->items[i].mask << 21) >> 16) & 0xFFFF;
mask_l = ((filter_cfg->items[i].mask << 21) | mask_l_tail) & 0xFFFF;
}
else if (filter_cfg->items[i].ide == RT_CAN_EXTID)
{
id_h = (filter_cfg->items[i].id >> 13) & 0xFFFF;
id_l = ((filter_cfg->items[i].id << 3) |
(filter_cfg->items[i].ide << 2) |
(filter_cfg->items[i].rtr << 1)) & 0xFFFF;
id_l = ((filter_cfg->items[i].id << 3) |
(filter_cfg->items[i].ide << 2) |
(filter_cfg->items[i].rtr << 1)) &
0xFFFF;
mask_h = ((filter_cfg->items[i].mask << 3) >> 16) & 0xFFFF;
mask_l = ((filter_cfg->items[i].mask << 3) | mask_l_tail) & 0xFFFF;
}
drv_can->can_filter_init.Filter_Scale = CAN_Filter_32bitScale;
drv_can->can_filter_init.Filter_HighId = id_h;
drv_can->can_filter_init.Filter_LowId = id_l;
drv_can->can_filter_init.FilterMask_HighId = mask_h;
drv_can->can_filter_init.FilterMask_LowId = mask_l;
drv_can->can_filter_init.Filter_FIFOAssignment = CAN_FIFO0;
drv_can->can_filter_init.Filter_Act = ENABLE;
drv_can->can_filter_init.Filter_Scale = CAN_Filter_32bitScale;
drv_can->can_filter_init.Filter_HighId = id_h;
drv_can->can_filter_init.Filter_LowId = id_l;
drv_can->can_filter_init.FilterMask_HighId = mask_h;
drv_can->can_filter_init.FilterMask_LowId = mask_l;
drv_can->can_filter_init.Filter_FIFOAssignment = CAN_FIFO0;
drv_can->can_filter_init.Filter_Act = ENABLE;
/* Filter conf */
_can_filter_config(drv_can);
}
......@@ -414,11 +411,11 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
break;
}
case RT_CAN_CMD_SET_MODE:
argval = (rt_uint32_t) arg;
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)
argval != RT_CAN_MODE_LISEN &&
argval != RT_CAN_MODE_LOOPBACK &&
argval != RT_CAN_MODE_LOOPBACKANLISEN)
{
return -RT_ERROR;
}
......@@ -429,16 +426,16 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
}
break;
case RT_CAN_CMD_SET_BAUD:
argval = (rt_uint32_t) arg;
argval = (rt_uint32_t)arg;
if (argval != CAN1MBaud &&
argval != CAN800kBaud &&
argval != CAN500kBaud &&
argval != CAN250kBaud &&
argval != CAN125kBaud &&
argval != CAN100kBaud &&
argval != CAN50kBaud &&
argval != CAN20kBaud &&
argval != CAN10kBaud)
argval != CAN800kBaud &&
argval != CAN500kBaud &&
argval != CAN250kBaud &&
argval != CAN125kBaud &&
argval != CAN100kBaud &&
argval != CAN50kBaud &&
argval != CAN20kBaud &&
argval != CAN10kBaud)
{
return -RT_ERROR;
}
......@@ -449,9 +446,9 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
}
break;
case RT_CAN_CMD_SET_PRIV:
argval = (rt_uint32_t) arg;
argval = (rt_uint32_t)arg;
if (argval != RT_CAN_MODE_PRIV &&
argval != RT_CAN_MODE_NOPRIV)
argval != RT_CAN_MODE_NOPRIV)
{
return -RT_ERROR;
}
......@@ -463,11 +460,6 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
break;
case RT_CAN_CMD_GET_STATUS:
{
// drv_can->device.status.rcverrcnt = CAN_GetReceiveErrCounter(drv_can->CANx);
// drv_can->device.status.snderrcnt = CAN_GetLSBTransmitErrCounter(drv_can->CANx);
// drv_can->device.status.lasterrtype = CAN_GetLastErrCode(drv_can->CANx);
// drv_can->device.status.errcode = CAN_GetLastErrCode(drv_can->CANx);
rt_uint32_t errtype;
errtype = drv_can->CANx->ESTS;
drv_can->device.status.rcverrcnt = errtype >> 24;
......@@ -486,74 +478,73 @@ static rt_err_t _can_control(struct rt_can_device *can, int cmd, void *arg)
/* CAN Mailbox Transmit Request */
#define TMIDxR_TXRQ ((uint32_t)0x00000001) /* Transmit mailbox request */
static int _can_sendmsg_rtmsg(CAN_Module* CANx, struct rt_can_msg *pmsg, uint32_t mailbox_index)
static int _can_sendmsg_rtmsg(CAN_Module *CANx, struct rt_can_msg *pmsg, uint32_t mailbox_index)
{
CanTxMessage CAN_TxMessage = {0};
CanTxMessage* TxMessage = &CAN_TxMessage;
CanTxMessage CAN_TxMessage = {0};
CanTxMessage *TxMessage = &CAN_TxMessage;
/* Check the parameters */
assert_param(IS_CAN_ALL_PERIPH(CANx));
if (RT_CAN_STDID == pmsg->ide)
{
TxMessage->IDE = CAN_Standard_Id;
RT_ASSERT(IS_CAN_STDID(pmsg->id));
TxMessage->StdId = pmsg->id;
}
else
{
TxMessage->IDE = CAN_Extended_Id;
RT_ASSERT(IS_CAN_EXTID(pmsg->id));
TxMessage->ExtId = pmsg->id;
}
if (RT_CAN_DTR == pmsg->rtr)
{
TxMessage->RTR = CAN_RTRQ_DATA;
}
else
{
TxMessage->RTR = CAN_RTRQ_REMOTE;
}
if (RT_CAN_STDID == pmsg->ide)
{
TxMessage->IDE = CAN_Standard_Id;
RT_ASSERT(IS_CAN_STDID(pmsg->id));
TxMessage->StdId = pmsg->id;
}
else
{
TxMessage->IDE = CAN_Extended_Id;
RT_ASSERT(IS_CAN_EXTID(pmsg->id));
TxMessage->ExtId = pmsg->id;
}
if (RT_CAN_DTR == pmsg->rtr)
{
TxMessage->RTR = CAN_RTRQ_DATA;
}
else
{
TxMessage->RTR = CAN_RTRQ_REMOTE;
}
if (mailbox_index != CAN_TxSTS_NoMailBox)
{
/* Set up the Id */
CANx->sTxMailBox[mailbox_index].TMI &= TMIDxR_TXRQ;
if (TxMessage->IDE == CAN_Standard_Id)
{
assert_param(IS_CAN_STDID(TxMessage->StdId));
CANx->sTxMailBox[mailbox_index].TMI |= ((TxMessage->StdId << 21) | TxMessage->RTR);
}
else
{
assert_param(IS_CAN_EXTID(TxMessage->ExtId));
CANx->sTxMailBox[mailbox_index].TMI |= ((TxMessage->ExtId << 3) | TxMessage->IDE | TxMessage->RTR);
}
/* Set up the DLC */
TxMessage->DLC = pmsg->len & 0x0FU;
CANx->sTxMailBox[mailbox_index].TMDT &= (uint32_t)0xFFFFFFF0;
CANx->sTxMailBox[mailbox_index].TMDT |= TxMessage->DLC;
/* Set up the data field */
CANx->sTxMailBox[mailbox_index].TMDH =
(((uint32_t)pmsg->data[7] << 24) |
((uint32_t)pmsg->data[6] << 16) |
((uint32_t)pmsg->data[5] << 8) |
((uint32_t)pmsg->data[4]) );
CANx->sTxMailBox[mailbox_index].TMDL =
(((uint32_t)pmsg->data[3] << 24) |
((uint32_t)pmsg->data[2] << 16) |
((uint32_t)pmsg->data[1] << 8) |
((uint32_t)pmsg->data[0]) );
/* Request transmission */
CANx->sTxMailBox[mailbox_index].TMI |= TMIDxR_TXRQ;
return RT_EOK;
}
return -RT_ERROR;
}
/* Set up the Id */
CANx->sTxMailBox[mailbox_index].TMI &= TMIDxR_TXRQ;
if (TxMessage->IDE == CAN_Standard_Id)
{
assert_param(IS_CAN_STDID(TxMessage->StdId));
CANx->sTxMailBox[mailbox_index].TMI |= ((TxMessage->StdId << 21) | TxMessage->RTR);
}
else
{
assert_param(IS_CAN_EXTID(TxMessage->ExtId));
CANx->sTxMailBox[mailbox_index].TMI |= ((TxMessage->ExtId << 3) | TxMessage->IDE | TxMessage->RTR);
}
/* Set up the DLC */
TxMessage->DLC = pmsg->len & 0x0FU;
CANx->sTxMailBox[mailbox_index].TMDT &= (uint32_t)0xFFFFFFF0;
CANx->sTxMailBox[mailbox_index].TMDT |= TxMessage->DLC;
/* Set up the data field */
CANx->sTxMailBox[mailbox_index].TMDH =
(((uint32_t)pmsg->data[7] << 24) |
((uint32_t)pmsg->data[6] << 16) |
((uint32_t)pmsg->data[5] << 8) |
((uint32_t)pmsg->data[4]));
CANx->sTxMailBox[mailbox_index].TMDL =
(((uint32_t)pmsg->data[3] << 24) |
((uint32_t)pmsg->data[2] << 16) |
((uint32_t)pmsg->data[1] << 8) |
((uint32_t)pmsg->data[0]));
/* Request transmission */
CANx->sTxMailBox[mailbox_index].TMI |= TMIDxR_TXRQ;
return RT_EOK;
}
return -RT_ERROR;
}
static int _can_sendmsg(struct rt_can_device *can, const void *buf, rt_uint32_t box_num)
{
......@@ -563,67 +554,65 @@ static int _can_sendmsg(struct rt_can_device *can, const void *buf, rt_uint32_t
RT_ASSERT(buf != RT_NULL);
drv_can = (struct n32g45x_can *)can->parent.user_data;
RT_ASSERT(drv_can != RT_NULL);
/* Select one empty transmit mailbox */
switch(box_num)
{
case 0:
if ((drv_can->CANx->TSTS & CAN_TSTS_TMEM0) != CAN_TSTS_TMEM0)
{
/* Return function status */
return -RT_ERROR;
}
break;
case 1:
if ((drv_can->CANx->TSTS & CAN_TSTS_TMEM1) != CAN_TSTS_TMEM1)
{
/* Return function status */
return -RT_ERROR;
}
break;
case 2:
if ((drv_can->CANx->TSTS & CAN_TSTS_TMEM2) != CAN_TSTS_TMEM2)
{
/* Return function status */
return -RT_ERROR;
}
break;
default:
switch (box_num)
{
case 0:
if ((drv_can->CANx->TSTS & CAN_TSTS_TMEM0) != CAN_TSTS_TMEM0)
{
/* Return function status */
return -RT_ERROR;
}
break;
case 1:
if ((drv_can->CANx->TSTS & CAN_TSTS_TMEM1) != CAN_TSTS_TMEM1)
{
/* Return function status */
return -RT_ERROR;
}
break;
case 2:
if ((drv_can->CANx->TSTS & CAN_TSTS_TMEM2) != CAN_TSTS_TMEM2)
{
/* Return function status */
return -RT_ERROR;
}
break;
default:
RT_ASSERT(0);
break;
}
//start send msg
return _can_sendmsg_rtmsg(drv_can->CANx , ((struct rt_can_msg *) buf) ,box_num);
break;
}
//start send msg
return _can_sendmsg_rtmsg(drv_can->CANx, ((struct rt_can_msg *)buf), box_num);
}
static int _can_recvmsg_rtmsg(CAN_Module* CANx, struct rt_can_msg *pmsg, uint32_t FIFONum)
static int _can_recvmsg_rtmsg(CAN_Module *CANx, struct rt_can_msg *pmsg, uint32_t FIFONum)
{
CanRxMessage CAN_RxMessage = {0};
CanRxMessage* RxMessage = &CAN_RxMessage;
CanRxMessage CAN_RxMessage = {0};
CanRxMessage *RxMessage = &CAN_RxMessage;
/* Check the parameters */
assert_param(IS_CAN_ALL_PERIPH(CANx));
assert_param(IS_CAN_FIFO(FIFONum));
/* Check the Rx FIFO */
if (FIFONum == CAN_FIFO0) /* Rx element is assigned to Rx FIFO 0 */
{
/* Check that the Rx FIFO 0 is not empty */
if ((CANx->RFF0 & CAN_RFF0_FFMP0) == 0U)
{
return -RT_ERROR;
}
/* Check that the Rx FIFO 0 is not empty */
if ((CANx->RFF0 & CAN_RFF0_FFMP0) == 0U)
{
return -RT_ERROR;
}
}
else /* Rx element is assigned to Rx FIFO 1 */
{
/* Check that the Rx FIFO 1 is not empty */
if ((CANx->RFF1 & CAN_RFF1_FFMP1) == 0U)
{
return -RT_ERROR;
}
/* Check that the Rx FIFO 1 is not empty */
if ((CANx->RFF1 & CAN_RFF1_FFMP1) == 0U)
{
return -RT_ERROR;
}
}
/* Get the Id */
RxMessage->IDE = (uint8_t)0x04 & CANx->sFIFOMailBox[FIFONum].RMI;
if (RxMessage->IDE == CAN_Standard_Id)
......@@ -639,7 +628,7 @@ static int _can_recvmsg_rtmsg(CAN_Module* CANx, struct rt_can_msg *pmsg, uint32_
RxMessage->DLC = (uint8_t)0x0F & CANx->sFIFOMailBox[FIFONum].RMDT;
/* Get the FMI */
RxMessage->FMI = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONum].RMDT >> 8);
/* Get the data field */
pmsg->data[0] = (uint8_t)0xFF & CANx->sFIFOMailBox[FIFONum].RMDL;
pmsg->data[1] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONum].RMDL >> 8);
......@@ -649,11 +638,11 @@ static int _can_recvmsg_rtmsg(CAN_Module* CANx, struct rt_can_msg *pmsg, uint32_
pmsg->data[5] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONum].RMDH >> 8);
pmsg->data[6] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONum].RMDH >> 16);
pmsg->data[7] = (uint8_t)0xFF & (CANx->sFIFOMailBox[FIFONum].RMDH >> 24);
/* get len */
pmsg->len = RxMessage->DLC;
/* get id */
/* get len */
pmsg->len = RxMessage->DLC;
/* get id */
if (RxMessage->IDE == CAN_Standard_Id)
{
pmsg->ide = RT_CAN_STDID;
......@@ -673,7 +662,7 @@ static int _can_recvmsg_rtmsg(CAN_Module* CANx, struct rt_can_msg *pmsg, uint32_
{
pmsg->rtr = RT_CAN_RTR;
}
/* get hdr */
if (CANx == CAN1)
{
......@@ -682,7 +671,7 @@ static int _can_recvmsg_rtmsg(CAN_Module* CANx, struct rt_can_msg *pmsg, uint32_
#ifdef CAN2
else if (CANx == CAN2)
{
pmsg->hdr = (RxMessage->FMI >> 1) + 14;
pmsg->hdr = (RxMessage->FMI >> 1) + 14;
}
#endif
/* Release the DATFIFO */
......@@ -696,10 +685,9 @@ static int _can_recvmsg_rtmsg(CAN_Module* CANx, struct rt_can_msg *pmsg, uint32_
{
CANx->RFF1 |= CAN_RFF1_RFFOM1;
}
return RT_EOK;
return RT_EOK;
}
static int _can_recvmsg(struct rt_can_device *can, void *buf, rt_uint32_t fifo)
{
struct n32g45x_can *drv_can;
......@@ -708,17 +696,17 @@ static int _can_recvmsg(struct rt_can_device *can, void *buf, rt_uint32_t fifo)
RT_ASSERT(buf != RT_NULL);
drv_can = (struct n32g45x_can *)can->parent.user_data;
RT_ASSERT(drv_can != RT_NULL);
/* get data */
return _can_recvmsg_rtmsg(drv_can->CANx,((struct rt_can_msg *) buf),fifo);
return _can_recvmsg_rtmsg(drv_can->CANx, ((struct rt_can_msg *)buf), fifo);
}
static const struct rt_can_ops _can_ops =
{
_can_config,
_can_control,
_can_sendmsg,
_can_recvmsg,
{
_can_config,
_can_control,
_can_sendmsg,
_can_recvmsg,
};
static void _can_rx_isr(struct rt_can_device *can, rt_uint32_t fifo)
......@@ -727,48 +715,48 @@ static void _can_rx_isr(struct rt_can_device *can, rt_uint32_t fifo)
RT_ASSERT(can != RT_NULL);
drv_can = (struct n32g45x_can *)can->parent.user_data;
RT_ASSERT(drv_can != RT_NULL);
switch (fifo)
{
case CAN_FIFO0:
/* save to user list */
if( CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFMP0) && CAN_PendingMessage(drv_can->CANx, CAN_FIFO0) )
{
rt_hw_can_isr(can, RT_CAN_EVENT_RX_IND | fifo << 8);
}
/* Check FULL flag for FIFO0 */
if( CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFULL0) )
{
/* Clear FIFO0 FULL Flag */
CAN_ClearFlag(drv_can->CANx, CAN_FLAG_FFULL0);
}
/* Check Overrun flag for FIFO0 */
if( CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFOVR0) )
{
/* Clear FIFO0 Overrun Flag */
CAN_ClearFlag(drv_can->CANx, CAN_FLAG_FFOVR0);
rt_hw_can_isr(can, RT_CAN_EVENT_RXOF_IND | fifo << 8);
}
if (CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFMP0) && CAN_PendingMessage(drv_can->CANx, CAN_FIFO0))
{
rt_hw_can_isr(can, RT_CAN_EVENT_RX_IND | fifo << 8);
}
/* Check FULL flag for FIFO0 */
if (CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFULL0))
{
/* Clear FIFO0 FULL Flag */
CAN_ClearFlag(drv_can->CANx, CAN_FLAG_FFULL0);
}
/* Check Overrun flag for FIFO0 */
if (CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFOVR0))
{
/* Clear FIFO0 Overrun Flag */
CAN_ClearFlag(drv_can->CANx, CAN_FLAG_FFOVR0);
rt_hw_can_isr(can, RT_CAN_EVENT_RXOF_IND | fifo << 8);
}
break;
case CAN_FIFO1:
/* save to user list */
if( CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFMP1) && CAN_PendingMessage(drv_can->CANx, CAN_FIFO1) )
{
rt_hw_can_isr(can, RT_CAN_EVENT_RX_IND | fifo << 8);
}
/* Check FULL flag for FIFO1 */
if( CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFULL1) )
{
/* Clear FIFO1 FULL Flag */
CAN_ClearFlag(drv_can->CANx, CAN_FLAG_FFULL1);
}
/* Check Overrun flag for FIFO1 */
if( CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFOVR1) )
{
/* Clear FIFO1 Overrun Flag */
CAN_ClearFlag(drv_can->CANx, CAN_FLAG_FFOVR1);
rt_hw_can_isr(can, RT_CAN_EVENT_RXOF_IND | fifo << 8);
}
if (CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFMP1) && CAN_PendingMessage(drv_can->CANx, CAN_FIFO1))
{
rt_hw_can_isr(can, RT_CAN_EVENT_RX_IND | fifo << 8);
}
/* Check FULL flag for FIFO1 */
if (CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFULL1))
{
/* Clear FIFO1 FULL Flag */
CAN_ClearFlag(drv_can->CANx, CAN_FLAG_FFULL1);
}
/* Check Overrun flag for FIFO1 */
if (CAN_GetFlagSTS(drv_can->CANx, CAN_FLAG_FFOVR1))
{
/* Clear FIFO1 Overrun Flag */
CAN_ClearFlag(drv_can->CANx, CAN_FLAG_FFOVR1);
rt_hw_can_isr(can, RT_CAN_EVENT_RXOF_IND | fifo << 8);
}
break;
}
}
......@@ -780,23 +768,23 @@ static void _can_rx_isr(struct rt_can_device *can, rt_uint32_t fifo)
#define CAN1_TX_IRQHandler USB_HP_CAN1_TX_IRQHandler
void CAN1_TX_IRQHandler(void)
{
rt_interrupt_enter();
if(CAN_GetFlagSTS(drv_can1.CANx, CAN_FLAG_RQCPM0) )
{
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_DONE | (0x00 << 8) );
CAN_ClearFlag(drv_can1.CANx, CAN_FLAG_RQCPM0);
}
if(CAN_GetFlagSTS(drv_can1.CANx, CAN_FLAG_RQCPM1) )
{
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_DONE | (0x01 << 8) );
CAN_ClearFlag(drv_can1.CANx, CAN_FLAG_RQCPM1);
}
if(CAN_GetFlagSTS(drv_can1.CANx, CAN_FLAG_RQCPM2) )
{
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_DONE | (0x02 << 8) );
CAN_ClearFlag(drv_can1.CANx, CAN_FLAG_RQCPM2);
}
rt_interrupt_leave();
rt_interrupt_enter();
if (CAN_GetFlagSTS(drv_can1.CANx, CAN_FLAG_RQCPM0))
{
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_DONE | (0x00 << 8));
CAN_ClearFlag(drv_can1.CANx, CAN_FLAG_RQCPM0);
}
if (CAN_GetFlagSTS(drv_can1.CANx, CAN_FLAG_RQCPM1))
{
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_DONE | (0x01 << 8));
CAN_ClearFlag(drv_can1.CANx, CAN_FLAG_RQCPM1);
}
if (CAN_GetFlagSTS(drv_can1.CANx, CAN_FLAG_RQCPM2))
{
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_DONE | (0x02 << 8));
CAN_ClearFlag(drv_can1.CANx, CAN_FLAG_RQCPM2);
}
rt_interrupt_leave();
}
/**
......@@ -827,42 +815,42 @@ void CAN1_SCE_IRQHandler(void)
{
uint32_t errtype;
rt_interrupt_enter();
if(CAN_GetIntStatus(drv_can1.CANx, CAN_INT_ERR) )
{
errtype = drv_can1.CANx->ESTS;
// ESTS -> LEC
switch ((errtype & 0x70) >> 4)
{
case RT_CAN_BUS_BIT_PAD_ERR:
break;
case RT_CAN_BUS_FORMAT_ERR:
drv_can1.device.status.formaterrcnt++;
break;
case RT_CAN_BUS_ACK_ERR:/* attention !!! test ack err's unit is transmit unit */
drv_can1.device.status.ackerrcnt++;
if (!READ_BIT(drv_can1.CANx->TSTS, CAN_TSTS_TXOKM0))
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_FAIL | 0 << 8);
else if (!READ_BIT(drv_can1.CANx->TSTS, CAN_TSTS_TXOKM1))
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_FAIL | 1 << 8);
else if (!READ_BIT(drv_can1.CANx->TSTS, CAN_TSTS_TXOKM2))
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_FAIL | 2 << 8);
break;
case RT_CAN_BUS_IMPLICIT_BIT_ERR:
case RT_CAN_BUS_EXPLICIT_BIT_ERR:
drv_can1.device.status.biterrcnt++;
break;
case RT_CAN_BUS_CRC_ERR:
drv_can1.device.status.crcerrcnt++;
break;
}
drv_can1.device.status.lasterrtype = errtype & 0x70;
drv_can1.device.status.rcverrcnt = errtype >> 24;
drv_can1.device.status.snderrcnt = (errtype >> 16 & 0xFF);
drv_can1.device.status.errcode = errtype & 0x07;
CAN_ClearINTPendingBit(drv_can1.CANx, CAN_INT_ERR);
}
if (CAN_GetIntStatus(drv_can1.CANx, CAN_INT_ERR))
{
errtype = drv_can1.CANx->ESTS;
// ESTS -> LEC
switch ((errtype & 0x70) >> 4)
{
case RT_CAN_BUS_BIT_PAD_ERR:
break;
case RT_CAN_BUS_FORMAT_ERR:
drv_can1.device.status.formaterrcnt++;
break;
case RT_CAN_BUS_ACK_ERR: /* attention !!! test ack err's unit is transmit unit */
drv_can1.device.status.ackerrcnt++;
if (!READ_BIT(drv_can1.CANx->TSTS, CAN_TSTS_TXOKM0))
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_FAIL | 0 << 8);
else if (!READ_BIT(drv_can1.CANx->TSTS, CAN_TSTS_TXOKM1))
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_FAIL | 1 << 8);
else if (!READ_BIT(drv_can1.CANx->TSTS, CAN_TSTS_TXOKM2))
rt_hw_can_isr(&drv_can1.device, RT_CAN_EVENT_TX_FAIL | 2 << 8);
break;
case RT_CAN_BUS_IMPLICIT_BIT_ERR:
case RT_CAN_BUS_EXPLICIT_BIT_ERR:
drv_can1.device.status.biterrcnt++;
break;
case RT_CAN_BUS_CRC_ERR:
drv_can1.device.status.crcerrcnt++;
break;
}
drv_can1.device.status.lasterrtype = errtype & 0x70;
drv_can1.device.status.rcverrcnt = errtype >> 24;
drv_can1.device.status.snderrcnt = (errtype >> 16 & 0xFF);
drv_can1.device.status.errcode = errtype & 0x07;
CAN_ClearINTPendingBit(drv_can1.CANx, CAN_INT_ERR);
}
rt_interrupt_leave();
}
#endif /* BSP_USING_CAN1 */
......@@ -873,23 +861,23 @@ void CAN1_SCE_IRQHandler(void)
*/
void CAN2_TX_IRQHandler(void)
{
rt_interrupt_enter();
if(CAN_GetFlagSTS(drv_can2.CANx, CAN_FLAG_RQCPM0) )
{
CAN_ClearFlag(drv_can2.CANx, CAN_FLAG_RQCPM0);
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_DONE | (0x00 << 8) );
}
if(CAN_GetFlagSTS(drv_can2.CANx, CAN_FLAG_RQCPM1) )
{
CAN_ClearFlag(drv_can2.CANx, CAN_FLAG_RQCPM1);
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_DONE | (0x01 << 8) );
}
if(CAN_GetFlagSTS(drv_can2.CANx, CAN_FLAG_RQCPM2) )
{
CAN_ClearFlag(drv_can2.CANx, CAN_FLAG_RQCPM2);
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_DONE | (0x02 << 8) );
}
rt_interrupt_leave();
rt_interrupt_enter();
if (CAN_GetFlagSTS(drv_can2.CANx, CAN_FLAG_RQCPM0))
{
CAN_ClearFlag(drv_can2.CANx, CAN_FLAG_RQCPM0);
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_DONE | (0x00 << 8));
}
if (CAN_GetFlagSTS(drv_can2.CANx, CAN_FLAG_RQCPM1))
{
CAN_ClearFlag(drv_can2.CANx, CAN_FLAG_RQCPM1);
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_DONE | (0x01 << 8));
}
if (CAN_GetFlagSTS(drv_can2.CANx, CAN_FLAG_RQCPM2))
{
CAN_ClearFlag(drv_can2.CANx, CAN_FLAG_RQCPM2);
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_DONE | (0x02 << 8));
}
rt_interrupt_leave();
}
/**
......@@ -919,48 +907,47 @@ void CAN2_SCE_IRQHandler(void)
{
uint32_t errtype;
rt_interrupt_enter();
if(CAN_GetIntStatus(drv_can2.CANx, CAN_INT_ERR) )
{
errtype = drv_can2.CANx->ESTS;
// ESTS -> LEC
switch ((errtype & 0x70) >> 4)
{
case RT_CAN_BUS_BIT_PAD_ERR:
break;
case RT_CAN_BUS_FORMAT_ERR:
drv_can2.device.status.formaterrcnt++;
break;
case RT_CAN_BUS_ACK_ERR:/* attention !!! test ack err's unit is transmit unit */
drv_can2.device.status.ackerrcnt++;
if (!READ_BIT(drv_can2.CANx->TSTS, CAN_TSTS_TXOKM0))
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_FAIL | 0 << 8);
else if (!READ_BIT(drv_can2.CANx->TSTS, CAN_TSTS_TXOKM1))
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_FAIL | 1 << 8);
else if (!READ_BIT(drv_can2.CANx->TSTS, CAN_TSTS_TXOKM2))
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_FAIL | 2 << 8);
break;
case RT_CAN_BUS_IMPLICIT_BIT_ERR:
case RT_CAN_BUS_EXPLICIT_BIT_ERR:
drv_can2.device.status.biterrcnt++;
break;
case RT_CAN_BUS_CRC_ERR:
drv_can2.device.status.crcerrcnt++;
break;
}
drv_can2.device.status.lasterrtype = errtype & 0x70;
drv_can2.device.status.rcverrcnt = errtype >> 24;
drv_can2.device.status.snderrcnt = (errtype >> 16 & 0xFF);
drv_can2.device.status.errcode = errtype & 0x07;
CAN_ClearINTPendingBit(drv_can2.CANx, CAN_INT_ERR);
}
if (CAN_GetIntStatus(drv_can2.CANx, CAN_INT_ERR))
{
errtype = drv_can2.CANx->ESTS;
// ESTS -> LEC
switch ((errtype & 0x70) >> 4)
{
case RT_CAN_BUS_BIT_PAD_ERR:
break;
case RT_CAN_BUS_FORMAT_ERR:
drv_can2.device.status.formaterrcnt++;
break;
case RT_CAN_BUS_ACK_ERR: /* attention !!! test ack err's unit is transmit unit */
drv_can2.device.status.ackerrcnt++;
if (!READ_BIT(drv_can2.CANx->TSTS, CAN_TSTS_TXOKM0))
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_FAIL | 0 << 8);
else if (!READ_BIT(drv_can2.CANx->TSTS, CAN_TSTS_TXOKM1))
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_FAIL | 1 << 8);
else if (!READ_BIT(drv_can2.CANx->TSTS, CAN_TSTS_TXOKM2))
rt_hw_can_isr(&drv_can2.device, RT_CAN_EVENT_TX_FAIL | 2 << 8);
break;
case RT_CAN_BUS_IMPLICIT_BIT_ERR:
case RT_CAN_BUS_EXPLICIT_BIT_ERR:
drv_can2.device.status.biterrcnt++;
break;
case RT_CAN_BUS_CRC_ERR:
drv_can2.device.status.crcerrcnt++;
break;
}
drv_can2.device.status.lasterrtype = errtype & 0x70;
drv_can2.device.status.rcverrcnt = errtype >> 24;
drv_can2.device.status.snderrcnt = (errtype >> 16 & 0xFF);
drv_can2.device.status.errcode = errtype & 0x07;
CAN_ClearINTPendingBit(drv_can2.CANx, CAN_INT_ERR);
}
rt_interrupt_leave();
}
#endif /* BSP_USING_CAN2 */
int rt_hw_can_init(void)
{
struct can_configure config = CANDEFAULTCONFIG;
......@@ -975,15 +962,15 @@ int rt_hw_can_init(void)
#ifdef BSP_USING_CAN1
/* config default filter */
drv_can1.can_filter_init.Filter_Num = 0;
drv_can1.can_filter_init.Filter_Mode = CAN_Filter_IdMaskMode;
drv_can1.can_filter_init.Filter_Scale = CAN_Filter_32bitScale;
drv_can1.can_filter_init.Filter_HighId = 0x0000;
drv_can1.can_filter_init.Filter_LowId = 0x0000;
drv_can1.can_filter_init.FilterMask_HighId = 0;
drv_can1.can_filter_init.FilterMask_LowId = 0;
drv_can1.can_filter_init.Filter_Num = 0;
drv_can1.can_filter_init.Filter_Mode = CAN_Filter_IdMaskMode;
drv_can1.can_filter_init.Filter_Scale = CAN_Filter_32bitScale;
drv_can1.can_filter_init.Filter_HighId = 0x0000;
drv_can1.can_filter_init.Filter_LowId = 0x0000;
drv_can1.can_filter_init.FilterMask_HighId = 0;
drv_can1.can_filter_init.FilterMask_LowId = 0;
drv_can1.can_filter_init.Filter_FIFOAssignment = CAN_FIFO0;
drv_can1.can_filter_init.Filter_Act = ENABLE;
drv_can1.can_filter_init.Filter_Act = ENABLE;
drv_can1.device.config = config;
/* register CAN1 device */
rt_hw_can_register(&drv_can1.device, drv_can1.name, &_can_ops, &drv_can1);
......@@ -991,15 +978,15 @@ int rt_hw_can_init(void)
#ifdef BSP_USING_CAN2
/* config default filter */
drv_can2.can_filter_init.Filter_Num = 0;
drv_can2.can_filter_init.Filter_Mode = CAN_Filter_IdMaskMode;
drv_can2.can_filter_init.Filter_Scale = CAN_Filter_32bitScale;
drv_can2.can_filter_init.Filter_HighId = 0x0000;
drv_can2.can_filter_init.Filter_LowId = 0x0000;
drv_can2.can_filter_init.FilterMask_HighId = 0;
drv_can2.can_filter_init.FilterMask_LowId = 0;
drv_can2.can_filter_init.Filter_Num = 0;
drv_can2.can_filter_init.Filter_Mode = CAN_Filter_IdMaskMode;
drv_can2.can_filter_init.Filter_Scale = CAN_Filter_32bitScale;
drv_can2.can_filter_init.Filter_HighId = 0x0000;
drv_can2.can_filter_init.Filter_LowId = 0x0000;
drv_can2.can_filter_init.FilterMask_HighId = 0;
drv_can2.can_filter_init.FilterMask_LowId = 0;
drv_can2.can_filter_init.Filter_FIFOAssignment = CAN_FIFO0;
drv_can2.can_filter_init.Filter_Act = ENABLE;
drv_can2.can_filter_init.Filter_Act = ENABLE;
drv_can2.device.config = config;
/* register CAN2 device */
rt_hw_can_register(&drv_can2.device, drv_can2.name, &_can_ops, &drv_can2);
......
bsp/n32g452xx/Libraries/rt_drivers/drv_can.h
浏览文件 @ 66628f10
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
* Copyright (c) 2006-2022, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
......@@ -12,14 +12,15 @@
#define __DRV_CAN_H__
#ifdef __cplusplus
extern "C" {
extern "C"
{
#endif
#include <board.h>
#include <rtdevice.h>
#include <rtthread.h>
int rt_hw_can_init(void);
int rt_hw_can_init(void);
#ifdef __cplusplus
}
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或