Skip to content

R
rt-thread

天中雨水 / rt-thread
该项目与 Fork 源项目分叉

Fork自 RT-Thread / rt-thread

通知 2
Star 1
Fork 0
R
rt-thread

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

提交 6fad73c9 编写于 作者: A Aubr.Cool
浏览文件
操作

[BSP] stm32f10x can code format

上级 b750e11e
隐藏空白更改
内联 并排
Showing with 1231 addition and 1023 deletion
bsp/stm32f10x/applications/canapp.c
浏览文件 @ 6fad73c9
......@@ -8,8 +8,8 @@
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2015-05-14 aubrcool@qq.com first version
* Date Author Notes
* 2015-05-14 aubrcool@qq.com first version
*/
#include <board.h>
......@@ -22,69 +22,80 @@
#define CANERR2 38
static struct canledtype
{
struct stm32_hw_pin_userdata rtd;
struct stm32_hw_pin_userdata err;
struct stm32_hw_pin_userdata rtd;
struct stm32_hw_pin_userdata err;
} canled[] =
{
#ifdef USING_BXCAN1
{
{CANRT1, PIN_MODE_OUTPUT_OD,},
{CANERR1, PIN_MODE_OUTPUT_OD,},
},
{
{CANRT1, PIN_MODE_OUTPUT_OD,},
{CANERR1, PIN_MODE_OUTPUT_OD,},
},
#endif /*USING_BXCAN1*/
#ifdef USING_BXCAN2
{
{CANRT2, PIN_MODE_OUTPUT_OD,},
{CANERR2, PIN_MODE_OUTPUT_OD,},
},
{
{CANRT2, PIN_MODE_OUTPUT_OD,},
{CANERR2, PIN_MODE_OUTPUT_OD,},
},
#endif /*USING_BXCAN2*/
};
void can_bus_hook(struct rt_can_device * can, struct canledtype* led)
void can_bus_hook(struct rt_can_device *can, struct canledtype *led)
{
if(can->timerinitflag == 1) {
rt_pin_write(led->rtd.pin, 0);
} else {
if(can->status.rcvchange == 1 || can->status.sndchange == 1)
if (can->timerinitflag == 1)
{
rt_pin_write(led->rtd.pin, 0);
}
else
{
if (can->status.rcvchange == 1 || can->status.sndchange == 1)
{
can->status.rcvchange = 0;
can->status.sndchange = 0;
rt_pin_write(led->rtd.pin,rt_pin_read(led->rtd.pin)?0:1);
} else {
rt_pin_write(led->rtd.pin,1);
rt_pin_write(led->rtd.pin, rt_pin_read(led->rtd.pin) ? 0 : 1);
}
else
{
rt_pin_write(led->rtd.pin, 1);
}
}
if (can->timerinitflag == 1)
{
rt_pin_write(led->err.pin, 0);
}
else
{
if (can->status.errcode)
{
rt_pin_write(led->err.pin, 0);
}
else
{
rt_pin_write(led->err.pin, 1);
}
}
if(can->timerinitflag == 1) {
rt_pin_write(led->err.pin, 0);
} else {
if(can->status.errcode) {
rt_pin_write(led->err.pin,0);
} else {
rt_pin_write(led->err.pin,1);
}
}
}
#ifdef USING_BXCAN1
void can1_bus_hook(struct rt_can_device * can)
void can1_bus_hook(struct rt_can_device *can)
{
static rt_int32_t inited = 0;
if(!inited)
if (!inited)
{
inited = 1;
rt_pin_mode(canled[0].rtd.pin, canled[0].rtd.mode);
rt_pin_mode(canled[0].err.pin, canled[0].err.mode);
inited = 1;
rt_pin_mode(canled[0].rtd.pin, canled[0].rtd.mode);
rt_pin_mode(canled[0].err.pin, canled[0].err.mode);
}
can_bus_hook(can, &canled[0]);
}
#endif /*USING_BXCAN1*/
#ifdef USING_BXCAN2
void can2_bus_hook(struct rt_can_device * can)
void can2_bus_hook(struct rt_can_device *can)
{
static rt_int32_t inited = 0;
if(!inited)
if (!inited)
{
inited = 1;
rt_pin_mode(canled[1].rtd.pin, canled[1].rtd.mode);
rt_pin_mode(canled[1].err.pin, canled[1].err.mode);
inited = 1;
rt_pin_mode(canled[1].rtd.pin, canled[1].rtd.mode);
rt_pin_mode(canled[1].err.pin, canled[1].err.mode);
}
can_bus_hook(can, &canled[1]);
}
......@@ -95,31 +106,31 @@ int can_bus_hook_init(void)
#ifdef USING_BXCAN1
candev = rt_device_find("bxcan1");
RT_ASSERT(candev);
rt_device_control(candev,RT_CAN_CMD_SET_BUS_HOOK,(void*)can1_bus_hook);
rt_device_control(candev, RT_CAN_CMD_SET_BUS_HOOK, (void *)can1_bus_hook);
#endif /*USING_BXCAN1*/
#ifdef USING_BXCAN2
candev = rt_device_find("bxcan2");
RT_ASSERT(candev);
rt_device_control(candev,RT_CAN_CMD_SET_BUS_HOOK,(void*)can2_bus_hook);
rt_device_control(candev, RT_CAN_CMD_SET_BUS_HOOK, (void *)can2_bus_hook);
#endif /*USING_BXCAN2*/
return RT_EOK;
}
INIT_DEVICE_EXPORT(can_bus_hook_init);
struct can_app_struct
{
const char* name;
const char *name;
struct rt_event event;
struct rt_can_filter_config * filter;
struct rt_can_filter_config *filter;
rt_uint8_t eventopt;
};
static struct can_app_struct can_data[2];
static rt_err_t can1ind(rt_device_t dev, void* args, rt_int32_t hdr, rt_size_t size)
static rt_err_t can1ind(rt_device_t dev, void *args, rt_int32_t hdr, rt_size_t size)
{
rt_event_t pevent = (rt_event_t)args;
rt_event_send(pevent, 1 << (hdr));
return RT_EOK;
}
static rt_err_t can2ind(rt_device_t dev, void* args, rt_int32_t hdr, rt_size_t size)
static rt_err_t can2ind(rt_device_t dev, void *args, rt_int32_t hdr, rt_size_t size)
{
rt_event_t pevent = (rt_event_t)args;
rt_event_send(pevent, 1 << (hdr));
......@@ -127,106 +138,117 @@ static rt_err_t can2ind(rt_device_t dev, void* args, rt_int32_t hdr, rt_size_t
}
struct rt_can_filter_item filter1item[4] =
{
RT_CAN_FILTER_STD_INIT(1,can1ind,&can_data[0].event),
RT_CAN_FILTER_STD_INIT(2,can1ind,&can_data[0].event),
RT_CAN_STD_RMT_FILTER_INIT(3,can1ind,&can_data[0].event),
RT_CAN_STD_RMT_DATA_FILTER_INIT(4,can1ind,&can_data[0].event),
RT_CAN_FILTER_STD_INIT(1, can1ind, &can_data[0].event),
RT_CAN_FILTER_STD_INIT(2, can1ind, &can_data[0].event),
RT_CAN_STD_RMT_FILTER_INIT(3, can1ind, &can_data[0].event),
RT_CAN_STD_RMT_DATA_FILTER_INIT(4, can1ind, &can_data[0].event),
};
struct rt_can_filter_item filter2item[4] =
{
RT_CAN_FILTER_STD_INIT(1,can2ind,&can_data[1].event),
RT_CAN_FILTER_STD_INIT(2,can2ind,&can_data[1].event),
RT_CAN_STD_RMT_FILTER_INIT(3,can2ind,&can_data[1].event),
RT_CAN_STD_RMT_DATA_FILTER_INIT(4,can2ind,&can_data[1].event),
RT_CAN_FILTER_STD_INIT(1, can2ind, &can_data[1].event),
RT_CAN_FILTER_STD_INIT(2, can2ind, &can_data[1].event),
RT_CAN_STD_RMT_FILTER_INIT(3, can2ind, &can_data[1].event),
RT_CAN_STD_RMT_DATA_FILTER_INIT(4, can2ind, &can_data[1].event),
};
struct rt_can_filter_config filter1 =
{
.count = 4,
.actived = 1,
.items = filter1item,
.count = 4,
.actived = 1,
.items = filter1item,
};
struct rt_can_filter_config filter2 =
{
.count = 4,
.actived = 1,
.items = filter2item,
.count = 4,
.actived = 1,
.items = filter2item,
};
static struct can_app_struct can_data[2] = {
static struct can_app_struct can_data[2] =
{
{
.name = "bxcan1",
.filter = &filter1,
.eventopt = RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
.name = "bxcan1",
.filter = &filter1,
.eventopt = RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
},
{
.name = "bxcan2",
.filter = &filter2,
.eventopt = RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
.name = "bxcan2",
.filter = &filter2,
.eventopt = RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
},
};
void rt_can_thread_entry(void* parameter)
void rt_can_thread_entry(void *parameter)
{
struct rt_can_msg msg;
struct can_app_struct* canpara = (struct can_app_struct*) parameter;
rt_device_t candev;
rt_uint32_t e;
struct rt_can_msg msg;
struct can_app_struct *canpara = (struct can_app_struct *) parameter;
rt_device_t candev;
rt_uint32_t e;
candev = rt_device_find(canpara->name);
RT_ASSERT(candev);
rt_event_init(&canpara->event, canpara->name, RT_IPC_FLAG_FIFO);
rt_device_open(candev, (RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX));
rt_device_control(candev,RT_CAN_CMD_SET_FILTER,canpara->filter);
while(1) {
if (
rt_event_recv(&canpara->event,
((1 << canpara->filter->items[0].hdr) |
(1 << canpara->filter->items[1].hdr) |
(1 << canpara->filter->items[2].hdr) |
(1 << canpara->filter->items[3].hdr)),
canpara->eventopt,
RT_WAITING_FOREVER, &e) != RT_EOK
) {
continue;
}
if(e & (1 << canpara->filter->items[0].hdr)) {
msg.hdr = canpara->filter->items[0].hdr;
while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg)) {
rt_device_write(candev, 0, &msg, sizeof(msg));
}
}
if(e & (1 << canpara->filter->items[1].hdr)) {
msg.hdr = canpara->filter->items[1].hdr;
while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg)) {
rt_device_write(candev, 0, &msg, sizeof(msg));
}
}
if(e & (1 << canpara->filter->items[2].hdr)) {
msg.hdr = canpara->filter->items[2].hdr;
while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg)) {
rt_device_write(candev, 0, &msg, sizeof(msg));
}
}
if(e & (1 << canpara->filter->items[3].hdr)) {
msg.hdr = canpara->filter->items[3].hdr;
while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg)) {
rt_device_write(candev, 0, &msg, sizeof(msg));
}
}
}
candev = rt_device_find(canpara->name);
RT_ASSERT(candev);
rt_event_init(&canpara->event, canpara->name, RT_IPC_FLAG_FIFO);
rt_device_open(candev, (RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX));
rt_device_control(candev, RT_CAN_CMD_SET_FILTER, canpara->filter);
while (1)
{
if (
rt_event_recv(&canpara->event,
((1 << canpara->filter->items[0].hdr) |
(1 << canpara->filter->items[1].hdr) |
(1 << canpara->filter->items[2].hdr) |
(1 << canpara->filter->items[3].hdr)),
canpara->eventopt,
RT_WAITING_FOREVER, &e) != RT_EOK
)
{
continue;
}
if (e & (1 << canpara->filter->items[0].hdr))
{
msg.hdr = canpara->filter->items[0].hdr;
while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg))
{
rt_device_write(candev, 0, &msg, sizeof(msg));
}
}
if (e & (1 << canpara->filter->items[1].hdr))
{
msg.hdr = canpara->filter->items[1].hdr;
while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg))
{
rt_device_write(candev, 0, &msg, sizeof(msg));
}
}
if (e & (1 << canpara->filter->items[2].hdr))
{
msg.hdr = canpara->filter->items[2].hdr;
while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg))
{
rt_device_write(candev, 0, &msg, sizeof(msg));
}
}
if (e & (1 << canpara->filter->items[3].hdr))
{
msg.hdr = canpara->filter->items[3].hdr;
while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg))
{
rt_device_write(candev, 0, &msg, sizeof(msg));
}
}
}
}
int rt_can_app_init(void)
{
rt_thread_t tid;
tid = rt_thread_create("canapp1",
rt_can_thread_entry, &can_data[0],
512, RT_THREAD_PRIORITY_MAX /3 - 1, 20);
rt_can_thread_entry, &can_data[0],
512, RT_THREAD_PRIORITY_MAX / 3 - 1, 20);
if (tid != RT_NULL) rt_thread_startup(tid);
tid = rt_thread_create("canapp2",
rt_can_thread_entry, &can_data[1],
512, RT_THREAD_PRIORITY_MAX /3 - 1, 20);
rt_can_thread_entry, &can_data[1],
512, RT_THREAD_PRIORITY_MAX / 3 - 1, 20);
if (tid != RT_NULL) rt_thread_startup(tid);
return 0;
}
......
bsp/stm32f10x/drivers/bxcan.c
浏览文件 @ 6fad73c9
......@@ -8,8 +8,8 @@
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2015-05-14 aubrcool@qq.com first version
* Date Author Notes
* 2015-05-14 aubrcool@qq.com first version
*/
#include <rthw.h>
#include <rtdevice.h>
......@@ -32,26 +32,28 @@
#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 {
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_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;
CAN_TypeDef *reg;
void *mfrbase;
IRQn_Type sndirq;
IRQn_Type rcvirq0;
IRQn_Type rcvirq1;
......@@ -68,62 +70,80 @@ 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++) {
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;
}
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;
}
}
CAN1->sFilterRegister[i].FR1 = 0xFFFFFFFF;
CAN1->sFilterRegister[i].FR2 = 0xFFFFFFFF;
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);
......@@ -135,63 +155,81 @@ static void bxcan2_filter_init(struct rt_can_device *can)
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++) {
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;
}
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->sFilterRegister[i].FR1 = 0xFFFFFFFF;
CAN1->sFilterRegister[i].FR2 = 0xFFFFFFFF;
CAN1->FMR &= ~FMR_FINIT;
}
calcfiltermasks(pbxcan);
......@@ -207,212 +245,212 @@ static void bxcan2_filter_init(struct rt_can_device *can)
#define MK_BKCAN_BAUD(SJW,BS1,BS2,PRES) \
((SJW << SJWSHIFT) | (BS1 << BS1SHIFT) | (BS2 << BS2SHIFT) | (PRES << RRESCLSHIFT))
static const rt_uint32_t bxcan_baud_rate_tab[] =
{
// 48 M
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_12tq,CAN_BS2_3tq,3),
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_6tq,CAN_BS2_3tq,6),
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_12tq,CAN_BS2_3tq,5),
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_12tq,CAN_BS2_3tq,11),
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_12tq,CAN_BS2_3tq,23),
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_12tq,CAN_BS2_3tq,29),
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_12tq,CAN_BS2_3tq,59),
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_14tq,CAN_BS2_3tq,149),
MK_BKCAN_BAUD(CAN_SJW_2tq,CAN_BS1_16tq,CAN_BS2_8tq,199),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 3),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_6tq, CAN_BS2_3tq, 6),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 5),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 11),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 23),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 29),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_12tq, CAN_BS2_3tq, 59),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_14tq, CAN_BS2_3tq, 149),
MK_BKCAN_BAUD(CAN_SJW_2tq, CAN_BS1_16tq, CAN_BS2_8tq, 199),
};
#define BAUD_DATA(TYPE,NO) \
((bxcan_baud_rate_tab[NO] & TYPE##MASK) >> TYPE##SHIFT)
static void bxcan_init(CAN_TypeDef* pcan, rt_uint32_t baud, rt_uint32_t mode)
static void bxcan_init(CAN_TypeDef *pcan, rt_uint32_t baud, rt_uint32_t mode)
{
CAN_InitTypeDef CAN_InitStructure;
CAN_InitTypeDef CAN_InitStructure;
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_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:
break;
case RT_CAN_MODE_LISEN:
CAN_InitStructure.CAN_Mode = CAN_Mode_Silent;
break;
case RT_CAN_MODE_LOOPBACK:
break;
case RT_CAN_MODE_LOOPBACK:
CAN_InitStructure.CAN_Mode = CAN_Mode_LoopBack;
break;
case RT_CAN_MODE_LOOPBACKANLISEN:
break;
case RT_CAN_MODE_LOOPBACKANLISEN:
CAN_InitStructure.CAN_Mode = CAN_Mode_Silent_LoopBack;
break;
}
CAN_InitStructure.CAN_SJW = BAUD_DATA(SJW,baud);
CAN_InitStructure.CAN_BS1 = BAUD_DATA(BS1,baud);
CAN_InitStructure.CAN_BS2 = BAUD_DATA(BS2,baud);
CAN_InitStructure.CAN_Prescaler =BAUD_DATA(RRESCL,baud);
break;
}
CAN_InitStructure.CAN_SJW = BAUD_DATA(SJW, baud);
CAN_InitStructure.CAN_BS1 = BAUD_DATA(BS1, baud);
CAN_InitStructure.CAN_BS2 = BAUD_DATA(BS2, baud);
CAN_InitStructure.CAN_Prescaler = BAUD_DATA(RRESCL, baud);
CAN_Init(pcan, &CAN_InitStructure);
CAN_Init(pcan, &CAN_InitStructure);
}
static void bxcan1_hw_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
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);
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);
}
static void bxcan2_hw_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
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_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);
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);
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);
}
static inline rt_err_t bxcan_enter_init(CAN_TypeDef* pcan)
static inline rt_err_t bxcan_enter_init(CAN_TypeDef *pcan)
{
uint32_t wait_ack = 0x00000000;
uint32_t wait_ack = 0x00000000;
pcan->MCR |= CAN_MCR_INRQ ;
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;
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)
static inline rt_err_t bxcan_exit_init(CAN_TypeDef *pcan)
{
uint32_t wait_ack = 0x00000000;
uint32_t wait_ack = 0x00000000;
pcan->MCR &= ~(uint32_t)CAN_MCR_INRQ;
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;
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)
static rt_err_t bxcan_set_mode(CAN_TypeDef *pcan, rt_uint32_t mode)
{
if(bxcan_enter_init(pcan) != RT_EOK)
if (bxcan_enter_init(pcan) != RT_EOK)
{
return RT_ERROR;
return RT_ERROR;
}
pcan->BTR &= ~(uint32_t)((uint32_t)0x03 << 30);
switch(mode)
switch (mode)
{
case RT_CAN_MODE_NORMAL:
mode = CAN_Mode_Normal;
break;
mode = CAN_Mode_Normal;
break;
case RT_CAN_MODE_LISEN:
mode = CAN_Mode_Silent;
break;
mode = CAN_Mode_Silent;
break;
case RT_CAN_MODE_LOOPBACK:
mode = CAN_Mode_LoopBack;
break;
mode = CAN_Mode_LoopBack;
break;
case RT_CAN_MODE_LOOPBACKANLISEN:
mode = CAN_Mode_Silent_LoopBack;
break;
mode = CAN_Mode_Silent_LoopBack;
break;
}
pcan->BTR |= ~(uint32_t)(mode << 30);
if(bxcan_exit_init(pcan) != RT_EOK)
if (bxcan_exit_init(pcan) != RT_EOK)
{
return RT_ERROR;
return RT_ERROR;
}
return RT_EOK;
return RT_EOK;
}
static rt_err_t bxcan_set_privmode(CAN_TypeDef* pcan, rt_uint32_t mode)
static rt_err_t bxcan_set_privmode(CAN_TypeDef *pcan, rt_uint32_t mode)
{
if(bxcan_enter_init(pcan) != RT_EOK)
if (bxcan_enter_init(pcan) != RT_EOK)
{
return RT_ERROR;
return RT_ERROR;
}
if (mode == ENABLE)
{
pcan->MCR |= CAN_MCR_TXFP;
pcan->MCR |= CAN_MCR_TXFP;
}
else
{
pcan->MCR &= ~(uint32_t)CAN_MCR_TXFP;
pcan->MCR &= ~(uint32_t)CAN_MCR_TXFP;
}
if(bxcan_exit_init(pcan) != RT_EOK)
if (bxcan_exit_init(pcan) != RT_EOK)
{
return RT_ERROR;
return RT_ERROR;
}
return RT_EOK;
return RT_EOK;
}
static rt_err_t bxcan_set_baud_rate(CAN_TypeDef* pcan, rt_uint32_t baud)
static rt_err_t bxcan_set_baud_rate(CAN_TypeDef *pcan, rt_uint32_t baud)
{
rt_uint32_t mode;
if(bxcan_enter_init(pcan) != RT_EOK)
if (bxcan_enter_init(pcan) != RT_EOK)
{
return RT_ERROR;
return RT_ERROR;
}
pcan->BTR = 0;
mode = pcan->BTR & ((rt_uint32_t)0x03 << 30);
pcan->BTR = (mode | \
((BAUD_DATA(SJW,baud)) << 24) | \
((BAUD_DATA(BS1,baud)) << 16) | \
((BAUD_DATA(BS2,baud)) << 20) | \
(BAUD_DATA(RRESCL,baud)));
if(bxcan_exit_init(pcan) != RT_EOK)
((BAUD_DATA(SJW, baud)) << 24) | \
((BAUD_DATA(BS1, baud)) << 16) | \
((BAUD_DATA(BS2, baud)) << 20) | \
(BAUD_DATA(RRESCL, baud)));
if (bxcan_exit_init(pcan) != RT_EOK)
{
return RT_ERROR;
return RT_ERROR;
}
return RT_EOK;
return RT_EOK;
}
static rt_err_t bxcancalcbaseoff(struct stm_bxcan *pbxcan, rt_int32_t hdr,
rt_int32_t * pbase, rt_int32_t * poff)
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 fifo0start, fifo0end;
rt_uint32_t fifo1start, fifo1end;
rt_uint32_t ptr;
fifo0start = 0;
fifo0end = pbxcan->filtermap[0].id32mask_cnt
......@@ -424,607 +462,725 @@ static rt_err_t bxcancalcbaseoff(struct stm_bxcan *pbxcan, rt_int32_t hdr,
+ 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) {
if (hdr >= fifo0start && hdr < fifo0end)
{
*pbase = 0;
ptr = 0;
}
else if (hdr >= fifo1start && hdr < fifo1end)
{
*pbase = pbxcan->fifo1filteroff;
ptr = 1;
} else {
return RT_ERROR;
}
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;
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)
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) {
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 {
}
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) {
}
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);
}
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)
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:
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++) {
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);
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;
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) {
if (pitem->rtr)
{
thisid |= CAN_RTR_REMOTE;
thismask |= CAN_RTR_REMOTE;
}
if(pfilterreg->FR1 == thisid && pfilterreg->FR2 == thismask) {
if (pfilterreg->FR1 == thisid && pfilterreg->FR2 == thismask)
{
found = 1;
break;
}
}
}
break;
case 2:
case 2:
shift = 3;
for(i = 0; i < BX_CAN_MAX_FILTERS; i++) {
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)
) {
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:
case 1:
shift = 5;
for(i = 0; i < BX_CAN_MAX_FILTERS; i++) {
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);
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) {
if (pitem->rtr)
{
thisid |= CAN_RTR_REMOTE << (shift - 2);
}
thismask = pitem->mask << shift;
if(pitem->rtr) {
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))
){
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:
case 0:
shift = 5;
for(i = 0; i < BX_CAN_MAX_FILTERS; i++) {
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;
}
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;
}
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)
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_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;
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;
}
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_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);
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);
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);
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);
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;
}
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)
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;
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();
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;
}
} else {
if(!actived) {
pitem->hdr = hdr;
} else if(hdr >= 0 && (pitem->hdr >= 0 || pitem->hdr == -1)) {
pitem->hdr = hdr;
return RT_EBUSY;
hdr = pitem->hdr;
if (actived)
{
pbxcan->alocmask[hdr >> 5] |= 0x01 << (hdr % 0x1F);
}
}
rt_uint32_t ID[2];
rt_uint32_t shift;
rt_uint32_t thisid;
rt_uint32_t thismask;
CAN_FilterInitTypeDef CAN_FilterInitStructure;
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;
}
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;
}
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;
}
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;
}
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;
}
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)
static rt_err_t setfilter(struct stm_bxcan *pbxcan, struct rt_can_filter_config *pconfig)
{
struct rt_can_filter_item* pitem = pconfig->items;
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--;
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;
CAN_TypeDef *pbxcan;
pbxcan = ((struct stm_bxcan *) can->parent.user_data)->reg;
assert_param(IS_CAN_ALL_PERIPH(pbxcan));
if(pbxcan == CAN1)
if (pbxcan == CAN1)
{
bxcan1_hw_init();
bxcan_init(pbxcan,cfg->baud_rate,can->config.mode);
bxcan_init(pbxcan, cfg->baud_rate, can->config.mode);
bxcan1_filter_init(can);
} else {
}
else
{
bxcan2_hw_init();
bxcan_init(pbxcan,cfg->baud_rate,can->config.mode);
bxcan_init(pbxcan, cfg->baud_rate, can->config.mode);
bxcan2_filter_init(can);
}
return RT_EOK;
}
static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
{
struct stm_bxcan* pbxcan;
struct stm_bxcan *pbxcan;
rt_uint32_t argval;
NVIC_InitTypeDef NVIC_InitStructure;
pbxcan= (struct stm_bxcan *) can->parent.user_data;
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)
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->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);
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)
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_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);
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);
return setfilter(pbxcan, (struct rt_can_filter_config *) arg);
break;
case RT_CAN_CMD_SET_MODE:
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);
}
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:
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);
}
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:
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:
if (argval != RT_CAN_MODE_PRIV ||
argval != RT_CAN_MODE_NOPRIV)
{
return RT_ERROR;
}
if (argval != can->config.privmode)
{
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));
}
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)
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;
CAN_TypeDef *pbxcan;
struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;
pbxcan= ((struct stm_bxcan *) can->parent.user_data)->reg;
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);
assert_param(IS_CAN_STDID(pmsg->id));
pbxcan->sTxMailBox[boxno].TIR |= ((pmsg->id << 21) | \
pmsg->rtr);
}
else
{
assert_param(IS_CAN_EXTID(pmsg->id));
pbxcan->sTxMailBox[boxno].TIR |= ((pmsg->id << 3) | \
pmsg->ide <<2 | \
pmsg->rtr);
assert_param(IS_CAN_EXTID(pmsg->id));
pbxcan->sTxMailBox[boxno].TIR |= ((pmsg->id << 3) | \
pmsg->ide << 2 | \
pmsg->rtr);
}
pmsg->len &= (uint8_t)0x0000000F;
......@@ -1032,51 +1188,53 @@ static int sendmsg(struct rt_can_device *can, const void* buf, rt_uint32_t boxno
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]));
((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)
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;
CAN_TypeDef *pbxcan;
struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;
pbxcan= ((struct stm_bxcan *) can->parent.user_data)->reg;
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;
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);
pmsg->id = (uint32_t)0x000007FF & (pbxcan->sFIFOMailBox[boxno].RIR >> 21);
}
else
{
pmsg->id = (uint32_t)0x1FFFFFFF & (pbxcan->sFIFOMailBox[boxno].RIR >> 3);
pmsg->id = (uint32_t)0x1FFFFFFF & (pbxcan->sFIFOMailBox[boxno].RIR >> 3);
}
pmsg->rtr = (uint8_t) ((0x02 & pbxcan->sFIFOMailBox[boxno].RIR) >> 1);
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);
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;
if (boxno) pmsg->hdr += ((struct stm_bxcan *) can->parent.user_data)->fifo1filteroff * 4;
return RT_EOK;
}
......@@ -1091,123 +1249,137 @@ static const struct rt_can_ops canops =
static struct stm_bxcan bxcan1data =
{
.reg = CAN1,
.mfrbase = (void*)&CAN1->sFilterRegister[0],
.mfrbase = (void *) &CAN1->sFilterRegister[0],
.sndirq = CAN1_TX_IRQn,
.rcvirq0 = CAN1_RX0_IRQn,
.rcvirq1 = CAN1_RX1_IRQn,
.errirq = CAN1_SCE_IRQn,
.alocmask = {0,0},
.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,
},
[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 & 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;
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 & 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;
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))
if (CAN1->TSR & (CAN_TSR_RQCP0))
{
state = CAN1->TSR & (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0);
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))
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_DONE | 0<<8);
} else {
rt_hw_can_isr(&bxcan1,RT_CAN_EVENT_TX_FAIL | 0<<8);
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))
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_DONE | 1<<8);
} else {
rt_hw_can_isr(&bxcan1,RT_CAN_EVENT_TX_FAIL | 1<<8);
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))
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);
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;
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*/
......@@ -1215,91 +1387,103 @@ void CAN1_SCE_IRQHandler(void)
static struct stm_bxcan bxcan2data =
{
.reg = CAN2,
.mfrbase = (void*)&CAN1->sFilterRegister[BX_CAN2_FMRSTART],
.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},
.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,
},
[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 & 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;
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 & 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;
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))
if (CAN2->TSR & (CAN_TSR_RQCP0))
{
state = CAN2->TSR & (CAN_TSR_RQCP0 | CAN_TSR_TXOK0 | CAN_TSR_TME0);
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))
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_DONE | 0<<8);
} else {
rt_hw_can_isr(&bxcan2,RT_CAN_EVENT_TX_FAIL | 0<<8);
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))
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_DONE | 1<<8);
} else {
rt_hw_can_isr(&bxcan2,RT_CAN_EVENT_TX_FAIL | 1<<8);
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))
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);
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);
}
}
}
......@@ -1307,24 +1491,26 @@ void CAN2_SCE_IRQHandler(void)
{
rt_uint32_t errtype;
errtype = CAN2->ESR;
if(errtype & 0x70 && bxcan2.status.lasterrtype == (errtype & 0x70)) {
switch((errtype & 0x70)>>4) {
if (errtype & 0x70 && bxcan2.status.lasterrtype == (errtype & 0x70))
{
switch ((errtype & 0x70) >> 4)
{
case RT_CAN_BUS_BIT_PAD_ERR:
bxcan2.status.bitpaderrcnt++;
break;
bxcan2.status.bitpaderrcnt++;
break;
case RT_CAN_BUS_FORMAT_ERR:
bxcan2.status.formaterrcnt++;
break;
bxcan2.status.formaterrcnt++;
break;
case RT_CAN_BUS_ACK_ERR:
bxcan2.status.ackerrcnt++;
break;
bxcan2.status.ackerrcnt++;
break;
case RT_CAN_BUS_IMPLICIT_BIT_ERR:
case RT_CAN_BUS_EXPLICIT_BIT_ERR:
bxcan2.status.biterrcnt++;
break;
bxcan2.status.biterrcnt++;
break;
case RT_CAN_BUS_CRC_ERR:
bxcan2.status.crcerrcnt++;
break;
bxcan2.status.crcerrcnt++;
break;
}
bxcan2.status.lasterrtype = errtype & 0x70;
CAN2->ESR &= ~0x70;
......@@ -1340,40 +1526,40 @@ 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;
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;
bxcan1.config.maxhdr = BX_CAN2_FMRSTART * 4;
#endif
rt_hw_can_register(&bxcan1, "bxcan1", &canops, &bxcan1data);
rt_hw_can_register(&bxcan1, "bxcan1", &canops, &bxcan1data);
#endif
#ifdef USING_BXCAN2
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);
#ifndef USING_BXCAN1
RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1 , ENABLE);
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;
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;
bxcan2.config.maxhdr = (BX_CAN_FMRNUMBER - BX_CAN2_FMRSTART) * 4;
#endif
rt_hw_can_register(&bxcan2, "bxcan2", &canops, &bxcan2data);
rt_hw_can_register(&bxcan2, "bxcan2", &canops, &bxcan2data);
#endif
return RT_EOK;
return RT_EOK;
}
INIT_BOARD_EXPORT(stm32_bxcan_init);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或