libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #517 from aozima/pulls 

Pulls
This commit is contained in:
Bernard Xiong 2015-07-08 21:10:05 +08:00
parent 2fffc07d5e 7254c41207
commit dee31a7103
2 changed files with 945 additions and 827 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

314
bsp/lpc408x/drivers/drv_lpccan.c
View File

@ -27,25 +27,17 @@
#include "lpc_exti.h" #include "lpc_exti.h"
#include "lpc_clkpwr.h" #include "lpc_clkpwr.h"
struct lpccandata { struct lpccandata
{
en_CAN_unitId id; en_CAN_unitId id;
}; };
static const rt_uint32_t LPCBAUDTAB[] = {
1000000,
800000,
500000,
250000,
125000,
100000,
50000,
20000,
10000,
};
static LPC_CAN_TypeDef* lcpcan_get_reg_base(rt_uint32_t id) static LPC_CAN_TypeDef* lcpcan_get_reg_base(rt_uint32_t id)
{ {
LPC_CAN_TypeDef* pCan; LPC_CAN_TypeDef* pCan;
switch (id) { switch (id)
{
case CAN_ID_1: case CAN_ID_1:
pCan = LPC_CAN1; pCan = LPC_CAN1;
break; break;
@ -58,9 +50,11 @@ static LPC_CAN_TypeDef* lcpcan_get_reg_base(rt_uint32_t id)
} }
return pCan; return pCan;
} }
static void lpccan_irqstate_init(rt_uint32_t id) static void lpccan_irqstate_init(rt_uint32_t id)
{ {
LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(id); LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(id);
volatile rt_int32_t i;
pCan->MOD = 1; // Enter Reset Mode pCan->MOD = 1; // Enter Reset Mode
pCan->IER = 0; // Disable All CAN Interrupts pCan->IER = 0; // Disable All CAN Interrupts
@ -71,10 +65,13 @@ static void lpccan_irqstate_init(rt_uint32_t id)
pCan->CMR = (1 << 1) | (1 << 2) | (1 << 3); pCan->CMR = (1 << 1) | (1 << 2) | (1 << 3);
/* Read to clear interrupt pending in interrupt capture register */ /* Read to clear interrupt pending in interrupt capture register */
rt_int32_t i = pCan->ICR; i = pCan->ICR;
i = i;
pCan->MOD = 0;// Return Normal operating pCan->MOD = 0;// Return Normal operating
} }
static void lpccan_baud_set(rt_uint32_t id, rt_uint32_t baud)
static rt_err_t lpccan_baud_set(rt_uint32_t id, rt_uint32_t baud)
{ {
uint32_t result = 0; uint32_t result = 0;
uint8_t NT, TSEG1, TSEG2; uint8_t NT, TSEG1, TSEG2;
@ -83,7 +80,8 @@ static void lpccan_baud_set(rt_uint32_t id, rt_uint32_t baud)
LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(id); LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(id);
CANPclk = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER); CANPclk = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER);
result = CANPclk / LPCBAUDTAB[baud]; result = CANPclk / baud;
/* Calculate suitable nominal time value /* Calculate suitable nominal time value
* NT (nominal time) = (TSEG1 + TSEG2 + 3) * NT (nominal time) = (TSEG1 + TSEG2 + 3)
* NT <= 24 * NT <= 24
@ -100,6 +98,7 @@ static void lpccan_baud_set(rt_uint32_t id, rt_uint32_t baud)
break; break;
} }
} }
/* Enter reset mode */ /* Enter reset mode */
pCan->MOD = 0x01; pCan->MOD = 0x01;
/* Set bit timing /* Set bit timing
@ -109,7 +108,10 @@ static void lpccan_baud_set(rt_uint32_t id, rt_uint32_t baud)
pCan->BTR = (TSEG2 << 20) | (TSEG1 << 16) | (3 << 14) | BRP; pCan->BTR = (TSEG2 << 20) | (TSEG1 << 16) | (3 << 14) | BRP;
/* Return to normal operating */ /* Return to normal operating */
pCan->MOD = 0; pCan->MOD = 0;
return RT_EOK;
} }
static void lpccan_init_alut_ram(void) static void lpccan_init_alut_ram(void)
{ {
//Reset CANAF value //Reset CANAF value
@ -125,17 +127,21 @@ static void lpccan_init_alut_ram(void)
// Set AF Mode // Set AF Mode
CAN_SetAFMode(CAN_NORMAL); CAN_SetAFMode(CAN_NORMAL);
} }
#ifdef RT_USING_LPCCAN1 #ifdef RT_USING_LPCCAN1
static void lpccan1_turnon_clk(void) static void lpccan1_turnon_clk(void)
{ {
CLKPWR_ConfigPPWR(CLKPWR_PCONP_PCAN1, ENABLE); CLKPWR_ConfigPPWR(CLKPWR_PCONP_PCAN1, ENABLE);
} }
static void lpccan1_filter_init(struct rt_can_device *can) static void lpccan1_filter_init(struct rt_can_device *can)
{ {
} }
static void lpccan1_hw_init(enum CANBAUD baud, CAN_MODE_Type mode)
static void lpccan1_hw_init(uint32_t baud, CAN_MODE_Type mode)
{
if(mode != CAN_SELFTEST_MODE)
{ {
if(mode != CAN_SELFTEST_MODE) {
#ifndef LPCCAN1_USEING_GPIO_SECOND #ifndef LPCCAN1_USEING_GPIO_SECOND
PINSEL_ConfigPin (0, 0, 1); PINSEL_ConfigPin (0, 0, 1);
PINSEL_ConfigPin (0, 1, 1); PINSEL_ConfigPin (0, 1, 1);
@ -150,23 +156,28 @@ static void lpccan1_hw_init(enum CANBAUD baud, CAN_MODE_Type mode)
lpccan1_turnon_clk(); lpccan1_turnon_clk();
lpccan_baud_set(CAN_1, baud); lpccan_baud_set(CAN_1, baud);
CAN_ModeConfig(CAN_1, mode, ENABLE); CAN_ModeConfig(CAN_1, mode, ENABLE);
if(mode == CAN_SELFTEST_MODE) { if(mode == CAN_SELFTEST_MODE)
{
//CAN_ModeConfig(CAN_1, CAN_TEST_MODE, ENABLE); //CAN_ModeConfig(CAN_1, CAN_TEST_MODE, ENABLE);
CAN_SetAFMode(CAN_ACC_BP); CAN_SetAFMode(CAN_ACC_BP);
} }
} }
#endif /*RT_USING_LPCCAN1*/ #endif /*RT_USING_LPCCAN1*/
#ifdef RT_USING_LPCCAN2 #ifdef RT_USING_LPCCAN2
static void lpccan2_turnon_clk(void) static void lpccan2_turnon_clk(void)
{ {
CLKPWR_ConfigPPWR(CLKPWR_PCONP_PCAN2, ENABLE); CLKPWR_ConfigPPWR(CLKPWR_PCONP_PCAN2, ENABLE);
} }
static void lpccan2_filter_init(struct rt_can_device *can) static void lpccan2_filter_init(struct rt_can_device *can)
{ {
} }
static void lpccan2_hw_init(enum CANBAUD baud, CAN_MODE_Type mode)
static void lpccan2_hw_init(uint32_t baud, CAN_MODE_Type mode)
{
if(mode != CAN_SELFTEST_MODE)
{ {
if(mode != CAN_SELFTEST_MODE) {
#ifndef LPCCAN2_USEING_GPIO_SECOND #ifndef LPCCAN2_USEING_GPIO_SECOND
PINSEL_ConfigPin (0, 4, 2); PINSEL_ConfigPin (0, 4, 2);
PINSEL_ConfigPin (0, 5, 2); PINSEL_ConfigPin (0, 5, 2);
@ -182,15 +193,20 @@ static void lpccan2_hw_init(enum CANBAUD baud, CAN_MODE_Type mode)
#endif /*RT_USING_LPCCAN1*/ #endif /*RT_USING_LPCCAN1*/
lpccan_baud_set(CAN_2, baud); lpccan_baud_set(CAN_2, baud);
CAN_ModeConfig(CAN_2, mode, ENABLE); CAN_ModeConfig(CAN_2, mode, ENABLE);
if(mode == CAN_SELFTEST_MODE) { if(mode == CAN_SELFTEST_MODE)
{
CAN_SetAFMode(CAN_ACC_BP); CAN_SetAFMode(CAN_ACC_BP);
} }
} }
#endif /*RT_USING_LPCCAN2*/ #endif /*RT_USING_LPCCAN2*/
static rt_err_t configure(struct rt_can_device *can, struct can_configure *cfg) static rt_err_t configure(struct rt_can_device *can, struct can_configure *cfg)
{ {
CAN_MODE_Type mode; CAN_MODE_Type mode;
switch(cfg->mode) { rt_uint32_t canid;
switch(cfg->mode)
{
case RT_CAN_MODE_NORMAL: case RT_CAN_MODE_NORMAL:
mode = CAN_OPERATING_MODE; mode = CAN_OPERATING_MODE;
break; break;
@ -203,7 +219,7 @@ static rt_err_t configure(struct rt_can_device *can, struct can_configure *cfg)
default: default:
return RT_EIO; return RT_EIO;
} }
rt_uint32_t canid;
canid = ((struct lpccandata *) can->parent.user_data)->id; canid = ((struct lpccandata *) can->parent.user_data)->id;
#ifdef RT_USING_LPCCAN1 #ifdef RT_USING_LPCCAN1
if(canid == CAN_1) if(canid == CAN_1)
@ -223,6 +239,7 @@ static rt_err_t configure(struct rt_can_device *can, struct can_configure *cfg)
#endif /*RT_USING_LPCCAN2*/ #endif /*RT_USING_LPCCAN2*/
return RT_EOK; return RT_EOK;
} }
static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_item* pitem, rt_int32_t* pos) static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_item* pitem, rt_int32_t* pos)
{ {
extern uint16_t CANAF_FullCAN_cnt; extern uint16_t CANAF_FullCAN_cnt;
@ -235,12 +252,16 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
rt_int16_t cnt1 = 0, cnt2 = 0, bound1 = 0; rt_int16_t cnt1 = 0, cnt2 = 0, bound1 = 0;
CAN_ID_FORMAT_Type format; CAN_ID_FORMAT_Type format;
*pos = -1; *pos = -1;
if(pitem->ide) { if(pitem->ide)
{
format = EXT_ID_FORMAT; format = EXT_ID_FORMAT;
} else { }
else
{
format = STD_ID_FORMAT; format = STD_ID_FORMAT;
} }
if(pitem->mode) { if(pitem->mode)
{
rt_uint32_t id = pitem->id; rt_uint32_t id = pitem->id;
if(format == STD_ID_FORMAT) if(format == STD_ID_FORMAT)
{ {
@ -255,7 +276,8 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
else if (CANAF_std_cnt == 1) else if (CANAF_std_cnt == 1)
{ {
cnt2 = (CANAF_FullCAN_cnt + 1) >> 1; cnt2 = (CANAF_FullCAN_cnt + 1) >> 1;
if(id != LPC_CANAF_RAM->mask[cnt2] >> 16) { if(id != LPC_CANAF_RAM->mask[cnt2] >> 16)
{
return CAN_ENTRY_NOT_EXIT_ERROR; return CAN_ENTRY_NOT_EXIT_ERROR;
} }
} }
@ -319,7 +341,9 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
cnt2++; cnt2++;
} }
} }
} else { }
else
{
rt_uint32_t lowerID = pitem->id; rt_uint32_t lowerID = pitem->id;
rt_uint32_t upperID = pitem->mask; rt_uint32_t upperID = pitem->mask;
rt_uint32_t LID,UID; rt_uint32_t LID,UID;
@ -338,7 +362,8 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
{ {
bound1 = ((CANAF_FullCAN_cnt+1)>>1) + ((CANAF_std_cnt + 1) >> 1) + CANAF_gstd_cnt; bound1 = ((CANAF_FullCAN_cnt+1)>>1) + ((CANAF_std_cnt + 1) >> 1) + CANAF_gstd_cnt;
while(cnt1 < bound1) while(cnt1 < bound1)
{ //compare controller first {
//compare controller first
while((LPC_CANAF_RAM->mask[cnt1] >> 29) < (plpccan->id))//increase until meet greater or equal controller while((LPC_CANAF_RAM->mask[cnt1] >> 29) < (plpccan->id))//increase until meet greater or equal controller
cnt1++; cnt1++;
buf0 = LPC_CANAF_RAM->mask[cnt1]; buf0 = LPC_CANAF_RAM->mask[cnt1];
@ -429,6 +454,7 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
} }
return CAN_ENTRY_NOT_EXIT_ERROR; return CAN_ENTRY_NOT_EXIT_ERROR;
} }
static rt_err_t setfilter(struct lpccandata* plpccan,struct rt_can_filter_config *pconfig) static rt_err_t setfilter(struct lpccandata* plpccan,struct rt_can_filter_config *pconfig)
{ {
struct rt_can_filter_item* pitem = pconfig->items; struct rt_can_filter_item* pitem = pconfig->items;
@ -436,39 +462,61 @@ static rt_err_t setfilter(struct lpccandata* plpccan,struct rt_can_filter_config
rt_int32_t pos; rt_int32_t pos;
CAN_ID_FORMAT_Type format; CAN_ID_FORMAT_Type format;
CAN_ERROR lpccanres; CAN_ERROR lpccanres;
while(count) { while(count)
if(pitem->ide) { {
if(pitem->ide)
{
format = EXT_ID_FORMAT; format = EXT_ID_FORMAT;
} else { }
else
{
format = STD_ID_FORMAT; format = STD_ID_FORMAT;
} }
lpccanres = findfilter(plpccan, pitem, &pos); lpccanres = findfilter(plpccan, pitem, &pos);
if(pconfig->actived && lpccanres != CAN_OK) { if(pconfig->actived && lpccanres != CAN_OK)
if(pitem->mode) { {
if(pitem->mode)
{
lpccanres = CAN_LoadGroupEntry(plpccan->id, pitem->id, pitem->mask, format); lpccanres = CAN_LoadGroupEntry(plpccan->id, pitem->id, pitem->mask, format);
} else { }
else
{
lpccanres = CAN_LoadExplicitEntry(plpccan->id, pitem->id, format); lpccanres = CAN_LoadExplicitEntry(plpccan->id, pitem->id, format);
} }
} else if(!pconfig->actived && lpccanres == CAN_OK) { }
else if(!pconfig->actived && lpccanres == CAN_OK)
{
AFLUT_ENTRY_Type type; AFLUT_ENTRY_Type type;
if(pitem->mode) { if(pitem->mode)
if(format == EXT_ID_FORMAT) { {
if(format == EXT_ID_FORMAT)
{
type = GROUP_EXTEND_ENTRY; type = GROUP_EXTEND_ENTRY;
} else { }
else
{
type = GROUP_STANDARD_ENTRY; type = GROUP_STANDARD_ENTRY;
} }
} else { }
if(format == EXT_ID_FORMAT) { else
{
if(format == EXT_ID_FORMAT)
{
type = EXPLICIT_EXTEND_ENTRY; type = EXPLICIT_EXTEND_ENTRY;
} else { }
else
{
type = EXPLICIT_STANDARD_ENTRY; type = EXPLICIT_STANDARD_ENTRY;
} }
} }
lpccanres = CAN_RemoveEntry(type, (rt_uint16_t)(pos)); lpccanres = CAN_RemoveEntry(type, (rt_uint16_t)(pos));
} else if(!pconfig->actived && lpccanres != CAN_OK) { }
else if(!pconfig->actived && lpccanres != CAN_OK)
{
lpccanres = CAN_OK; lpccanres = CAN_OK;
} }
if(lpccanres != CAN_OK) { if(lpccanres != CAN_OK)
{
return RT_EIO; return RT_EIO;
} }
pitem++; pitem++;
@ -476,13 +524,16 @@ static rt_err_t setfilter(struct lpccandata* plpccan,struct rt_can_filter_config
} }
return RT_EOK; return RT_EOK;
} }
static rt_err_t control(struct rt_can_device *can, int cmd, void *arg) static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
{ {
struct lpccandata* plpccan; struct lpccandata* plpccan;
rt_uint32_t argval; rt_uint32_t argval;
CAN_MODE_Type mode; CAN_MODE_Type mode;
plpccan = (struct lpccandata* ) can->parent.user_data; plpccan = (struct lpccandata* ) can->parent.user_data;
RT_ASSERT(plpccan != RT_NULL); RT_ASSERT(plpccan != RT_NULL);
switch (cmd) switch (cmd)
{ {
case RT_DEVICE_CTRL_CLR_INT: case RT_DEVICE_CTRL_CLR_INT:
@ -491,40 +542,53 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
{ {
CAN_IRQCmd(plpccan->id, CANINT_RIE, DISABLE); CAN_IRQCmd(plpccan->id, CANINT_RIE, DISABLE);
CAN_IRQCmd(plpccan->id, CANINT_DOIE, DISABLE); CAN_IRQCmd(plpccan->id, CANINT_DOIE, DISABLE);
} else if(argval == RT_DEVICE_FLAG_INT_TX) { }
else if(argval == RT_DEVICE_FLAG_INT_TX)
{
CAN_IRQCmd(plpccan->id, CANINT_TIE1, DISABLE); CAN_IRQCmd(plpccan->id, CANINT_TIE1, DISABLE);
CAN_IRQCmd(plpccan->id, CANINT_TIE2, DISABLE); CAN_IRQCmd(plpccan->id, CANINT_TIE2, DISABLE);
CAN_IRQCmd(plpccan->id, CANINT_TIE3, DISABLE); CAN_IRQCmd(plpccan->id, CANINT_TIE3, DISABLE);
} else if(argval == RT_DEVICE_CAN_INT_ERR) { }
else if(argval == RT_DEVICE_CAN_INT_ERR)
{
CAN_IRQCmd(plpccan->id, CANINT_EIE, DISABLE); CAN_IRQCmd(plpccan->id, CANINT_EIE, DISABLE);
} }
break; break;
case RT_DEVICE_CTRL_SET_INT: case RT_DEVICE_CTRL_SET_INT:
argval = (rt_uint32_t) arg; argval = (rt_uint32_t) arg;
if(argval == RT_DEVICE_FLAG_INT_RX) if(argval == RT_DEVICE_FLAG_INT_RX)
{ {
CAN_IRQCmd(plpccan->id, CANINT_RIE, ENABLE); CAN_IRQCmd(plpccan->id, CANINT_RIE, ENABLE);
CAN_IRQCmd(plpccan->id, CANINT_DOIE, ENABLE); CAN_IRQCmd(plpccan->id, CANINT_DOIE, ENABLE);
} else if(argval == RT_DEVICE_FLAG_INT_TX) { }
else if(argval == RT_DEVICE_FLAG_INT_TX)
{
CAN_IRQCmd(plpccan->id, CANINT_TIE1, ENABLE); CAN_IRQCmd(plpccan->id, CANINT_TIE1, ENABLE);
CAN_IRQCmd(plpccan->id, CANINT_TIE2, ENABLE); CAN_IRQCmd(plpccan->id, CANINT_TIE2, ENABLE);
CAN_IRQCmd(plpccan->id, CANINT_TIE3, ENABLE); CAN_IRQCmd(plpccan->id, CANINT_TIE3, ENABLE);
} else if(argval == RT_DEVICE_CAN_INT_ERR) { }
else if(argval == RT_DEVICE_CAN_INT_ERR)
{
CAN_IRQCmd(plpccan->id, CANINT_EIE, ENABLE); CAN_IRQCmd(plpccan->id, CANINT_EIE, ENABLE);
} }
break; break;
case RT_CAN_CMD_SET_FILTER: case RT_CAN_CMD_SET_FILTER:
return setfilter(plpccan, (struct rt_can_filter_config*) arg); return setfilter(plpccan, (struct rt_can_filter_config*) arg);
case RT_CAN_CMD_SET_MODE: case RT_CAN_CMD_SET_MODE:
argval = (rt_uint32_t) arg; argval = (rt_uint32_t) arg;
if(argval != RT_CAN_MODE_NORMAL || if(argval != RT_CAN_MODE_NORMAL ||
argval != RT_CAN_MODE_LISEN) { argval != RT_CAN_MODE_LISEN)
{
return RT_ERROR; return RT_ERROR;
} }
if(argval != can->config.mode) if(argval != can->config.mode)
{ {
can->config.mode = argval; can->config.mode = argval;
switch(argval) { switch(argval)
{
case RT_CAN_MODE_NORMAL: case RT_CAN_MODE_NORMAL:
mode = CAN_OPERATING_MODE; mode = CAN_OPERATING_MODE;
break; break;
@ -538,35 +602,28 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
return RT_EIO; return RT_EIO;
} }
CAN_ModeConfig(plpccan->id, mode, ENABLE); CAN_ModeConfig(plpccan->id, mode, ENABLE);
if(mode == CAN_SELFTEST_MODE) { if(mode == CAN_SELFTEST_MODE)
{
//CAN_ModeConfig(CAN_1, CAN_TEST_MODE, ENABLE); //CAN_ModeConfig(CAN_1, CAN_TEST_MODE, ENABLE);
CAN_SetAFMode(CAN_ACC_BP); CAN_SetAFMode(CAN_ACC_BP);
} }
} }
break; break;
case RT_CAN_CMD_SET_BAUD: 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 ) {
return RT_ERROR;
}
if(argval != can->config.baud_rate) if(argval != can->config.baud_rate)
{ {
can->config.baud_rate = argval; can->config.baud_rate = argval;
lpccan_baud_set(plpccan->id, (rt_uint32_t) arg); return lpccan_baud_set(plpccan->id, (rt_uint32_t) arg);
} }
break; break;
case RT_CAN_CMD_SET_PRIV: case RT_CAN_CMD_SET_PRIV:
argval = (rt_uint32_t) arg; argval = (rt_uint32_t) arg;
if(argval != RT_CAN_MODE_PRIV || if(argval != RT_CAN_MODE_PRIV ||
argval != RT_CAN_MODE_NOPRIV) { argval != RT_CAN_MODE_NOPRIV)
{
return RT_ERROR; return RT_ERROR;
} }
if(argval != can->config.privmode) if(argval != can->config.privmode)
@ -575,40 +632,55 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
CAN_ModeConfig(plpccan->id, CAN_TXPRIORITY_MODE, ENABLE); CAN_ModeConfig(plpccan->id, CAN_TXPRIORITY_MODE, ENABLE);
} }
break; break;
case RT_CAN_CMD_GET_STATUS: case RT_CAN_CMD_GET_STATUS:
{ {
rt_uint32_t errtype;
can->status.rcverrcnt = 0; can->status.rcverrcnt = 0;
can->status.snderrcnt = 0; can->status.snderrcnt = 0;
can->status.errcode = 0; can->status.errcode = 0;
if(arg != &can->status) { if(arg != &can->status)
{
rt_memcpy(arg,&can->status,sizeof(can->status)); rt_memcpy(arg,&can->status,sizeof(can->status));
} }
} }
break; break;
} }
return RT_EOK; 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)
{ {
struct lpccandata* plpccan; struct lpccandata* plpccan;
LPC_CAN_TypeDef* pCan;
struct rt_can_msg* pmsg;
rt_uint32_t SR_Mask;
rt_uint32_t CMRMsk;
plpccan = (struct lpccandata* ) can->parent.user_data; plpccan = (struct lpccandata* ) can->parent.user_data;
RT_ASSERT(plpccan != RT_NULL); RT_ASSERT(plpccan != RT_NULL);
LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(plpccan->id);
pCan = lcpcan_get_reg_base(plpccan->id);
RT_ASSERT(pCan != RT_NULL); RT_ASSERT(pCan != RT_NULL);
struct rt_can_msg* pmsg = (struct rt_can_msg*) buf;
rt_uint32_t SR_Mask; pmsg = (struct rt_can_msg*) buf;
if(boxno > 2) {
if(boxno > 2)
{
return RT_ERROR; return RT_ERROR;
} }
rt_uint32_t CMRMsk = 0x01 | (0x01 << (boxno + 5));
CMRMsk = 0x01 | (0x01 << (boxno + 5));
SR_Mask = 0x01 <<(boxno * 8 + 2); SR_Mask = 0x01 <<(boxno * 8 + 2);
if(pCan->SR & SR_Mask)
{
volatile unsigned int *pTFI = (&pCan->TFI1 + 0 + 4 * boxno); volatile unsigned int *pTFI = (&pCan->TFI1 + 0 + 4 * boxno);
volatile unsigned int *pTID = (&pCan->TFI1 + 1 + 4 * boxno); volatile unsigned int *pTID = (&pCan->TFI1 + 1 + 4 * boxno);
volatile unsigned int *pTDA = (&pCan->TFI1 + 2 + 4 * boxno); volatile unsigned int *pTDA = (&pCan->TFI1 + 2 + 4 * boxno);
volatile unsigned int *pTDB = (&pCan->TFI1 + 3 + 4 * boxno); volatile unsigned int *pTDB = (&pCan->TFI1 + 3 + 4 * boxno);
rt_uint32_t data; rt_uint32_t data;
if(pCan->SR & SR_Mask) {
/* Transmit Channel 1 is available */ /* Transmit Channel 1 is available */
/* Write frame informations and frame data into its CANxTFI1, /* Write frame informations and frame data into its CANxTFI1,
* CANxTID1, CANxTDA1, CANxTDB1 register */ * CANxTID1, CANxTDA1, CANxTDB1 register */
@ -631,7 +703,8 @@ static int sendmsg(struct rt_can_device *can, const void* buf, rt_uint32_t boxno
{ {
*pTFI &= ~(((uint32_t)1) << 31); *pTFI &= ~(((uint32_t)1) << 31);
} }
if(can->config.privmode) { if(can->config.privmode)
{
*pTFI &= ~0x000000FF; *pTFI &= ~0x000000FF;
*pTFI |= pmsg->priv; *pTFI |= pmsg->priv;
} }
@ -646,23 +719,30 @@ static int sendmsg(struct rt_can_device *can, const void* buf, rt_uint32_t boxno
/*Write transmission request*/ /*Write transmission request*/
pCan->CMR = CMRMsk; pCan->CMR = CMRMsk;
return RT_EOK; return RT_EOK;
} else { }
else
{
return RT_ERROR; return RT_ERROR;
} }
} }
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)
{ {
struct lpccandata* plpccan; struct lpccandata* plpccan;
LPC_CAN_TypeDef* pCan;
plpccan = (struct lpccandata* ) can->parent.user_data; plpccan = (struct lpccandata* ) can->parent.user_data;
RT_ASSERT(plpccan != RT_NULL); RT_ASSERT(plpccan != RT_NULL);
LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(plpccan->id); pCan = lcpcan_get_reg_base(plpccan->id);
RT_ASSERT(pCan != RT_NULL); RT_ASSERT(pCan != RT_NULL);
//CAN_ReceiveMsg //CAN_ReceiveMsg
uint32_t data;
struct rt_can_msg* pmsg = (struct rt_can_msg*) buf;
//check status of Receive Buffer //check status of Receive Buffer
if((pCan->SR &0x00000001)) if((pCan->SR &0x00000001))
{ {
uint32_t data;
struct rt_can_msg* pmsg = (struct rt_can_msg*) buf;
/* Receive message is available */ /* Receive message is available */
/* Read frame informations */ /* Read frame informations */
pmsg->ide = (uint8_t)(((pCan->RFS) & 0x80000000) >> 31); pmsg->ide = (uint8_t)(((pCan->RFS) & 0x80000000) >> 31);
@ -680,7 +760,8 @@ static int recvmsg(struct rt_can_device *can, void* buf, rt_uint32_t boxno)
pmsg->data[2] = (data & 0x00FF0000) >> 16; pmsg->data[2] = (data & 0x00FF0000) >> 16;
pmsg->data[3] = (data & 0xFF000000) >> 24; pmsg->data[3] = (data & 0xFF000000) >> 24;
/* Read second 4 data bytes */ /* Read second 4 data bytes */
if(pmsg->len > 4) { if(pmsg->len > 4)
{
data = pCan->RDB; data = pCan->RDB;
pmsg->data[4] = data & 0x000000FF; pmsg->data[4] = data & 0x000000FF;
pmsg->data[5] = (data & 0x0000FF00) >> 8; pmsg->data[5] = (data & 0x0000FF00) >> 8;
@ -714,11 +795,13 @@ static const struct rt_can_ops canops =
sendmsg, sendmsg,
recvmsg, recvmsg,
}; };
#ifdef RT_USING_LPCCAN1 #ifdef RT_USING_LPCCAN1
#ifdef RT_CAN_USING_LED #ifdef RT_CAN_USING_LED
#endif #endif
static struct lpccandata lpccandata1 = { static struct lpccandata lpccandata1 =
CAN_1, {
CAN_ID_1,
}; };
static struct rt_can_device lpccan1; static struct rt_can_device lpccan1;
#endif /*RT_USINGLPCCAN1*/ #endif /*RT_USINGLPCCAN1*/
@ -726,11 +809,13 @@ static struct rt_can_device lpccan1;
#ifdef RT_USING_LPCCAN2 #ifdef RT_USING_LPCCAN2
#ifdef RT_CAN_USING_LED #ifdef RT_CAN_USING_LED
#endif #endif
static struct lpccandata lpccandata2 = { static struct lpccandata lpccandata2 =
CAN_2, {
CAN_ID_2,
}; };
static struct rt_can_device lpccan2; static struct rt_can_device lpccan2;
#endif /*RT_USINGLPCCAN2*/ #endif /*RT_USINGLPCCAN2*/
/*----------------- INTERRUPT SERVICE ROUTINES --------------------------*/ /*----------------- INTERRUPT SERVICE ROUTINES --------------------------*/
/*********************************************************************//** /*********************************************************************//**
* @brief Event Router IRQ Handler * @brief Event Router IRQ Handler
@ -755,7 +840,9 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 3)) if(state & (0x01 << 3))
{ {
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 0<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 0<<8);
} else { }
else
{
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 0<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 0<<8);
} }
} }
@ -763,9 +850,13 @@ void CAN_IRQHandler(void)
if((IntStatus >> 2) & 0x01) if((IntStatus >> 2) & 0x01)
{ {
rt_uint32_t errtype; rt_uint32_t errtype;
rt_uint32_t state;
errtype = (IntStatus >> 16); errtype = (IntStatus >> 16);
if(errtype & 0x1F && lpccan1.status.lasterrtype == (errtype & 0x1F)) { if(errtype & 0x1F && lpccan1.status.lasterrtype == (errtype & 0x1F))
switch((errtype & 0x1F)) { {
switch((errtype & 0x1F))
{
case 00011: // Start of Frame case 00011: // Start of Frame
case 00010: // ID28 ... ID21 case 00010: // ID28 ... ID21
case 00110: //ID20 ... ID18 case 00110: //ID20 ... ID18
@ -798,7 +889,7 @@ void CAN_IRQHandler(void)
} }
lpccan1.status.lasterrtype = errtype & 0x1F; lpccan1.status.lasterrtype = errtype & 0x1F;
} }
rt_uint32_t state = 0;
state = CAN_GetCTRLStatus(CAN_1, CANCTRL_GLOBAL_STS); state = CAN_GetCTRLStatus(CAN_1, CANCTRL_GLOBAL_STS);
lpccan1.status.rcverrcnt = (state >> 16) & 0xFF; lpccan1.status.rcverrcnt = (state >> 16) & 0xFF;
lpccan1.status.snderrcnt = (state >> 24) & 0xFF; lpccan1.status.snderrcnt = (state >> 24) & 0xFF;
@ -817,7 +908,9 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 11)) if(state & (0x01 << 11))
{ {
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 1<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 1<<8);
} else { }
else
{
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 1<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 1<<8);
} }
} }
@ -829,11 +922,14 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 19)) if(state & (0x01 << 19))
{ {
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 2<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 2<<8);
} else { }
else
{
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 2<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 2<<8);
} }
} }
#endif /*RT_USING_LPCCAN1*/ #endif /*RT_USING_LPCCAN1*/
#ifdef RT_USING_LPCCAN2 #ifdef RT_USING_LPCCAN2
IntStatus = CAN_IntGetStatus(CAN_2); IntStatus = CAN_IntGetStatus(CAN_2);
//check receive interrupt //check receive interrupt
@ -849,17 +945,22 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 3)) if(state & (0x01 << 3))
{ {
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 0<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 0<<8);
} else { }
else
{
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 0<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 0<<8);
} }
} }
//check Error Warning Interrupt //check Error Warning Interrupt
if((IntStatus >> 2) & 0x01) if((IntStatus >> 2) & 0x01)
{ {
rt_uint32_t errtype; rt_uint32_t errtype;
errtype = (IntStatus >> 16); errtype = (IntStatus >> 16);
if(errtype & 0x1F && lpccan2.status.lasterrtype == (errtype & 0x1F)) { if(errtype & 0x1F && lpccan2.status.lasterrtype == (errtype & 0x1F))
switch((errtype & 0x1F)) { {
switch((errtype & 0x1F))
{
case 00011: // Start of Frame case 00011: // Start of Frame
case 00010: // ID28 ... ID21 case 00010: // ID28 ... ID21
case 00110: //ID20 ... ID18 case 00110: //ID20 ... ID18
@ -898,11 +999,13 @@ void CAN_IRQHandler(void)
lpccan2.status.snderrcnt = (state >> 24) & 0xFF; lpccan2.status.snderrcnt = (state >> 24) & 0xFF;
lpccan2.status.errcode = (state >> 5) & 0x06; lpccan2.status.errcode = (state >> 5) & 0x06;
} }
//check Data Overrun Interrupt Interrupt //check Data Overrun Interrupt Interrupt
if((IntStatus >> 3) & 0x01) if((IntStatus >> 3) & 0x01)
{ {
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_RXOF_IND | 0<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_RXOF_IND | 0<<8);
} }
//check Transmit Interrupt interrupt2 //check Transmit Interrupt interrupt2
if((IntStatus >> 9) & 0x01) if((IntStatus >> 9) & 0x01)
{ {
@ -911,10 +1014,13 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 11)) if(state & (0x01 << 11))
{ {
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 1<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 1<<8);
} else { }
else
{
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 1<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 1<<8);
} }
} }
//check Transmit Interrupt interrupt3 //check Transmit Interrupt interrupt3
if((IntStatus >> 10) & 0x01) if((IntStatus >> 10) & 0x01)
{ {
@ -923,12 +1029,15 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 19)) if(state & (0x01 << 19))
{ {
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 2<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 2<<8);
} else { }
else
{
rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 2<<8); rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 2<<8);
} }
} }
#endif /*RT_USING_LPCCAN2*/ #endif /*RT_USING_LPCCAN2*/
} }
int lpc_can_init(void) int lpc_can_init(void)
{ {
#ifdef RT_USING_LPCCAN1 #ifdef RT_USING_LPCCAN1
@ -937,15 +1046,19 @@ int lpc_can_init(void)
lpccan1.config.sndboxnumber=3; lpccan1.config.sndboxnumber=3;
lpccan1.config.mode=RT_CAN_MODE_NORMAL; lpccan1.config.mode=RT_CAN_MODE_NORMAL;
lpccan1.config.privmode=0; lpccan1.config.privmode=0;
#ifdef RT_CAN_USING_LED #ifdef RT_CAN_USING_LED
#endif #endif
lpccan1.config.ticks = 50; lpccan1.config.ticks = 50;
#ifdef RT_CAN_USING_HDR #ifdef RT_CAN_USING_HDR
#endif #endif
//Enable CAN Interrupt //Enable CAN Interrupt
NVIC_EnableIRQ(CAN_IRQn); NVIC_EnableIRQ(CAN_IRQn);
rt_hw_can_register(&lpccan1, "lpccan1", &canops, &lpccandata1); rt_hw_can_register(&lpccan1, "lpccan1", &canops, &lpccandata1);
#endif #endif /*RT_USING_LPCCAN1*/
#ifdef RT_USING_LPCCAN2 #ifdef RT_USING_LPCCAN2
lpccan2.config.baud_rate=CAN1MBaud; lpccan2.config.baud_rate=CAN1MBaud;
@ -953,19 +1066,24 @@ int lpc_can_init(void)
lpccan2.config.sndboxnumber=3; lpccan2.config.sndboxnumber=3;
lpccan2.config.mode=RT_CAN_MODE_NORMAL; lpccan2.config.mode=RT_CAN_MODE_NORMAL;
lpccan2.config.privmode=0; lpccan2.config.privmode=0;
#ifdef RT_CAN_USING_LED #ifdef RT_CAN_USING_LED
#endif #endif
lpccan2.config.ticks = 50; lpccan2.config.ticks = 50;
#ifdef RT_CAN_USING_HDR #ifdef RT_CAN_USING_HDR
#endif #endif
#ifndef RT_USING_LPCCAN1
//Enable CAN Interrupt //Enable CAN Interrupt
NVIC_EnableIRQ(CAN_IRQn); NVIC_EnableIRQ(CAN_IRQn);
#endif
#ifdef RT_CAN_USING_HDR #ifdef RT_CAN_USING_HDR
#endif #endif
rt_hw_can_register(&lpccan2, "lpccan2", &canops, &lpccandata2); rt_hw_can_register(&lpccan2, "lpccan2", &canops, &lpccandata2);
#endif #endif /*RT_USING_LPCCAN2*/
return RT_EOK; return RT_EOK;
} }
INIT_BOARD_EXPORT(lpc_can_init); INIT_BOARD_EXPORT(lpc_can_init);

18
components/drivers/include/drivers/can.h
View File

@ -37,15 +37,15 @@
enum CANBAUD enum CANBAUD
{ {
CAN1MBaud = 0, /* 1 MBit/sec */ CAN1MBaud = 1000UL * 1000,/* 1 MBit/sec */
CAN800kBaud, /* 800 kBit/sec */ CAN800kBaud = 1000UL * 800, /* 800 kBit/sec */
CAN500kBaud, /* 500 kBit/sec */ CAN500kBaud = 1000UL * 500, /* 500 kBit/sec */
CAN250kBaud, /* 250 kBit/sec */ CAN250kBaud = 1000UL * 250, /* 250 kBit/sec */
CAN125kBaud, /* 125 kBit/sec */ CAN125kBaud = 1000UL * 125, /* 125 kBit/sec */
CAN100kBaud, /* 100 kBit/sec */ CAN100kBaud = 1000UL * 100, /* 100 kBit/sec */
CAN50kBaud, /* 50 kBit/sec */ CAN50kBaud = 1000UL * 50, /* 50 kBit/sec */
CAN20kBaud, /* 20 kBit/sec */ CAN20kBaud = 1000UL * 20, /* 20 kBit/sec */
CAN10kBaud /* 10 kBit/sec */ CAN10kBaud = 1000UL * 10 /* 10 kBit/sec */
}; };
#define RT_CAN_MODE_NORMAL 0 #define RT_CAN_MODE_NORMAL 0