libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

[LPC4088] format code by Astyle.

This commit is contained in:
aozima 2015-07-08 10:44:49 +08:00
parent defa6f37ff
commit b15fb70616
1 changed files with 906 additions and 809 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -27,10 +27,13 @@
#include "lpc_exti.h"
#include "lpc_clkpwr.h"
struct lpccandata {
struct lpccandata
{
en_CAN_unitId id;
};
static const rt_uint32_t LPCBAUDTAB[] = {
static const rt_uint32_t LPCBAUDTAB[] =
{
1000000,
800000,
500000,
@ -41,11 +44,13 @@ static const rt_uint32_t LPCBAUDTAB[] = {
20000,
10000,
};
static LPC_CAN_TypeDef* lcpcan_get_reg_base(rt_uint32_t id)
{
LPC_CAN_TypeDef* pCan;
switch (id) {
switch (id)
{
case CAN_ID_1:
pCan = LPC_CAN1;
break;
@ -58,6 +63,7 @@ static LPC_CAN_TypeDef* lcpcan_get_reg_base(rt_uint32_t id)
}
return pCan;
}
static void lpccan_irqstate_init(rt_uint32_t id)
{
LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(id);
@ -74,6 +80,7 @@ static void lpccan_irqstate_init(rt_uint32_t id)
rt_int32_t i = pCan->ICR;
pCan->MOD = 0;// Return Normal operating
}
static void lpccan_baud_set(rt_uint32_t id, rt_uint32_t baud)
{
uint32_t result = 0;
@ -110,6 +117,7 @@ static void lpccan_baud_set(rt_uint32_t id, rt_uint32_t baud)
/* Return to normal operating */
pCan->MOD = 0;
}
static void lpccan_init_alut_ram(void)
{
//Reset CANAF value
@ -125,17 +133,21 @@ static void lpccan_init_alut_ram(void)
// Set AF Mode
CAN_SetAFMode(CAN_NORMAL);
}
#ifdef RT_USING_LPCCAN1
static void lpccan1_turnon_clk(void)
{
CLKPWR_ConfigPPWR(CLKPWR_PCONP_PCAN1, ENABLE);
}
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
PINSEL_ConfigPin (0, 0, 1);
PINSEL_ConfigPin (0, 1, 1);
@ -150,23 +162,28 @@ static void lpccan1_hw_init(enum CANBAUD baud, CAN_MODE_Type mode)
lpccan1_turnon_clk();
lpccan_baud_set(CAN_1, baud);
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_SetAFMode(CAN_ACC_BP);
}
}
#endif /*RT_USING_LPCCAN1*/
#ifdef RT_USING_LPCCAN2
static void lpccan2_turnon_clk(void)
{
CLKPWR_ConfigPPWR(CLKPWR_PCONP_PCAN2, ENABLE);
}
static void lpccan2_filter_init(struct rt_can_device *can)
{
}
static void lpccan2_hw_init(enum CANBAUD baud, CAN_MODE_Type mode)
{
if(mode != CAN_SELFTEST_MODE) {
if(mode != CAN_SELFTEST_MODE)
{
#ifndef LPCCAN2_USEING_GPIO_SECOND
PINSEL_ConfigPin (0, 4, 2);
PINSEL_ConfigPin (0, 5, 2);
@ -182,15 +199,18 @@ static void lpccan2_hw_init(enum CANBAUD baud, CAN_MODE_Type mode)
#endif /*RT_USING_LPCCAN1*/
lpccan_baud_set(CAN_2, baud);
CAN_ModeConfig(CAN_2, mode, ENABLE);
if(mode == CAN_SELFTEST_MODE) {
if(mode == CAN_SELFTEST_MODE)
{
CAN_SetAFMode(CAN_ACC_BP);
}
}
#endif /*RT_USING_LPCCAN2*/
static rt_err_t configure(struct rt_can_device *can, struct can_configure *cfg)
{
CAN_MODE_Type mode;
switch(cfg->mode) {
switch(cfg->mode)
{
case RT_CAN_MODE_NORMAL:
mode = CAN_OPERATING_MODE;
break;
@ -223,6 +243,7 @@ static rt_err_t configure(struct rt_can_device *can, struct can_configure *cfg)
#endif /*RT_USING_LPCCAN2*/
return RT_EOK;
}
static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_item* pitem, rt_int32_t* pos)
{
extern uint16_t CANAF_FullCAN_cnt;
@ -235,12 +256,16 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
rt_int16_t cnt1 = 0, cnt2 = 0, bound1 = 0;
CAN_ID_FORMAT_Type format;
*pos = -1;
if(pitem->ide) {
if(pitem->ide)
{
format = EXT_ID_FORMAT;
} else {
}
else
{
format = STD_ID_FORMAT;
}
if(pitem->mode) {
if(pitem->mode)
{
rt_uint32_t id = pitem->id;
if(format == STD_ID_FORMAT)
{
@ -255,7 +280,8 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
else if (CANAF_std_cnt == 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;
}
}
@ -319,7 +345,9 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
cnt2++;
}
}
} else {
}
else
{
rt_uint32_t lowerID = pitem->id;
rt_uint32_t upperID = pitem->mask;
rt_uint32_t LID,UID;
@ -338,7 +366,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;
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
cnt1++;
buf0 = LPC_CANAF_RAM->mask[cnt1];
@ -429,6 +458,7 @@ static CAN_ERROR findfilter(struct lpccandata* plpccan, struct rt_can_filter_ite
}
return CAN_ENTRY_NOT_EXIT_ERROR;
}
static rt_err_t setfilter(struct lpccandata* plpccan,struct rt_can_filter_config *pconfig)
{
struct rt_can_filter_item* pitem = pconfig->items;
@ -436,39 +466,61 @@ static rt_err_t setfilter(struct lpccandata* plpccan,struct rt_can_filter_config
rt_int32_t pos;
CAN_ID_FORMAT_Type format;
CAN_ERROR lpccanres;
while(count) {
if(pitem->ide) {
while(count)
{
if(pitem->ide)
{
format = EXT_ID_FORMAT;
} else {
}
else
{
format = STD_ID_FORMAT;
}
lpccanres = findfilter(plpccan, pitem, &pos);
if(pconfig->actived && lpccanres != CAN_OK) {
if(pitem->mode) {
if(pconfig->actived && lpccanres != CAN_OK)
{
if(pitem->mode)
{
lpccanres = CAN_LoadGroupEntry(plpccan->id, pitem->id, pitem->mask, format);
} else {
}
else
{
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;
if(pitem->mode) {
if(format == EXT_ID_FORMAT) {
if(pitem->mode)
{
if(format == EXT_ID_FORMAT)
{
type = GROUP_EXTEND_ENTRY;
} else {
}
else
{
type = GROUP_STANDARD_ENTRY;
}
} else {
if(format == EXT_ID_FORMAT) {
}
else
{
if(format == EXT_ID_FORMAT)
{
type = EXPLICIT_EXTEND_ENTRY;
} else {
}
else
{
type = EXPLICIT_STANDARD_ENTRY;
}
}
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;
}
if(lpccanres != CAN_OK) {
if(lpccanres != CAN_OK)
{
return RT_EIO;
}
pitem++;
@ -476,6 +528,7 @@ static rt_err_t setfilter(struct lpccandata* plpccan,struct rt_can_filter_config
}
return RT_EOK;
}
static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
{
struct lpccandata* plpccan;
@ -491,11 +544,15 @@ 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_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_TIE2, 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);
}
break;
@ -505,11 +562,15 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
{
CAN_IRQCmd(plpccan->id, CANINT_RIE, 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_TIE2, 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);
}
break;
@ -518,13 +579,15 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
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_LISEN)
{
return RT_ERROR;
}
if(argval != can->config.mode)
{
can->config.mode = argval;
switch(argval) {
switch(argval)
{
case RT_CAN_MODE_NORMAL:
mode = CAN_OPERATING_MODE;
break;
@ -538,7 +601,8 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
return RT_EIO;
}
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_SetAFMode(CAN_ACC_BP);
}
@ -554,7 +618,8 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
argval != CAN100kBaud &&
argval != CAN50kBaud &&
argval != CAN20kBaud &&
argval != CAN10kBaud ) {
argval != CAN10kBaud )
{
return RT_ERROR;
}
if(argval != can->config.baud_rate)
@ -566,7 +631,8 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
case RT_CAN_CMD_SET_PRIV:
argval = (rt_uint32_t) arg;
if(argval != RT_CAN_MODE_PRIV ||
argval != RT_CAN_MODE_NOPRIV) {
argval != RT_CAN_MODE_NOPRIV)
{
return RT_ERROR;
}
if(argval != can->config.privmode)
@ -581,7 +647,8 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
can->status.rcverrcnt = 0;
can->status.snderrcnt = 0;
can->status.errcode = 0;
if(arg != &can->status) {
if(arg != &can->status)
{
rt_memcpy(arg,&can->status,sizeof(can->status));
}
}
@ -589,6 +656,7 @@ static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
}
return RT_EOK;
}
static int sendmsg(struct rt_can_device *can, const void* buf, rt_uint32_t boxno)
{
struct lpccandata* plpccan;
@ -598,7 +666,8 @@ static int sendmsg(struct rt_can_device *can, const void* buf, rt_uint32_t boxno
RT_ASSERT(pCan != RT_NULL);
struct rt_can_msg* pmsg = (struct rt_can_msg*) buf;
rt_uint32_t SR_Mask;
if(boxno > 2) {
if(boxno > 2)
{
return RT_ERROR;
}
rt_uint32_t CMRMsk = 0x01 | (0x01 << (boxno + 5));
@ -608,7 +677,8 @@ static int sendmsg(struct rt_can_device *can, const void* buf, rt_uint32_t boxno
volatile unsigned int *pTDA = (&pCan->TFI1 + 2 + 4 * boxno);
volatile unsigned int *pTDB = (&pCan->TFI1 + 3 + 4 * boxno);
rt_uint32_t data;
if(pCan->SR & SR_Mask) {
if(pCan->SR & SR_Mask)
{
/* Transmit Channel 1 is available */
/* Write frame informations and frame data into its CANxTFI1,
* CANxTID1, CANxTDA1, CANxTDB1 register */
@ -631,7 +701,8 @@ static int sendmsg(struct rt_can_device *can, const void* buf, rt_uint32_t boxno
{
*pTFI &= ~(((uint32_t)1) << 31);
}
if(can->config.privmode) {
if(can->config.privmode)
{
*pTFI &= ~0x000000FF;
*pTFI |= pmsg->priv;
}
@ -646,10 +717,13 @@ static int sendmsg(struct rt_can_device *can, const void* buf, rt_uint32_t boxno
/*Write transmission request*/
pCan->CMR = CMRMsk;
return RT_EOK;
} else {
}
else
{
return RT_ERROR;
}
}
static int recvmsg(struct rt_can_device *can, void* buf, rt_uint32_t boxno)
{
struct lpccandata* plpccan;
@ -680,7 +754,8 @@ static int recvmsg(struct rt_can_device *can, void* buf, rt_uint32_t boxno)
pmsg->data[2] = (data & 0x00FF0000) >> 16;
pmsg->data[3] = (data & 0xFF000000) >> 24;
/* Read second 4 data bytes */
if(pmsg->len > 4) {
if(pmsg->len > 4)
{
data = pCan->RDB;
pmsg->data[4] = data & 0x000000FF;
pmsg->data[5] = (data & 0x0000FF00) >> 8;
@ -714,11 +789,13 @@ static const struct rt_can_ops canops =
sendmsg,
recvmsg,
};
#ifdef RT_USING_LPCCAN1
#ifdef RT_CAN_USING_LED
#endif
static struct lpccandata lpccandata1 = {
CAN_1,
static struct lpccandata lpccandata1 =
{
CAN_ID_1,
};
static struct rt_can_device lpccan1;
#endif /*RT_USINGLPCCAN1*/
@ -726,11 +803,13 @@ static struct rt_can_device lpccan1;
#ifdef RT_USING_LPCCAN2
#ifdef RT_CAN_USING_LED
#endif
static struct lpccandata lpccandata2 = {
CAN_2,
static struct lpccandata lpccandata2 =
{
CAN_ID_2,
};
static struct rt_can_device lpccan2;
#endif /*RT_USINGLPCCAN2*/
/*----------------- INTERRUPT SERVICE ROUTINES --------------------------*/
/*********************************************************************//**
* @brief Event Router IRQ Handler
@ -755,7 +834,9 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 3))
{
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);
}
}
@ -764,8 +845,10 @@ void CAN_IRQHandler(void)
{
rt_uint32_t errtype;
errtype = (IntStatus >> 16);
if(errtype & 0x1F && lpccan1.status.lasterrtype == (errtype & 0x1F)) {
switch((errtype & 0x1F)) {
if(errtype & 0x1F && lpccan1.status.lasterrtype == (errtype & 0x1F))
{
switch((errtype & 0x1F))
{
case 00011: // Start of Frame
case 00010: // ID28 ... ID21
case 00110: //ID20 ... ID18
@ -817,7 +900,9 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 11))
{
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);
}
}
@ -829,11 +914,14 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 19))
{
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);
}
}
#endif /*RT_USING_LPCCAN1*/
#ifdef RT_USING_LPCCAN2
IntStatus = CAN_IntGetStatus(CAN_2);
//check receive interrupt
@ -849,7 +937,9 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 3))
{
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);
}
}
@ -858,8 +948,10 @@ void CAN_IRQHandler(void)
{
rt_uint32_t errtype;
errtype = (IntStatus >> 16);
if(errtype & 0x1F && lpccan2.status.lasterrtype == (errtype & 0x1F)) {
switch((errtype & 0x1F)) {
if(errtype & 0x1F && lpccan2.status.lasterrtype == (errtype & 0x1F))
{
switch((errtype & 0x1F))
{
case 00011: // Start of Frame
case 00010: // ID28 ... ID21
case 00110: //ID20 ... ID18
@ -911,7 +1003,9 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 11))
{
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);
}
}
@ -923,12 +1017,15 @@ void CAN_IRQHandler(void)
if(state & (0x01 << 19))
{
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);
}
}
#endif /*RT_USING_LPCCAN2*/
}
int lpc_can_init(void)
{
#ifdef RT_USING_LPCCAN1