|
@@ -1,1086 +0,0 @@
|
|
|
-/*
|
|
|
- * Copyright (c) 2006-2018, RT-Thread Development Team
|
|
|
- *
|
|
|
- * SPDX-License-Identifier: Apache-2.0
|
|
|
- *
|
|
|
- * Change Logs:
|
|
|
- * Date Author Notes
|
|
|
- * 2015-06-30 aubrcool@qq.com first version
|
|
|
- */
|
|
|
-#include <rthw.h>
|
|
|
-#include <rtdevice.h>
|
|
|
-#include <board.h>
|
|
|
-#include <drv_lpccan.h>
|
|
|
-
|
|
|
-#ifdef RT_USING_CAN
|
|
|
-
|
|
|
-#include "lpc_types.h"
|
|
|
-#include "lpc_can.h"
|
|
|
-#include "lpc_pinsel.h"
|
|
|
-#include "lpc_exti.h"
|
|
|
-#include "lpc_clkpwr.h"
|
|
|
-
|
|
|
-struct lpccandata
|
|
|
-{
|
|
|
- en_CAN_unitId id;
|
|
|
-};
|
|
|
-
|
|
|
-static LPC_CAN_TypeDef* lcpcan_get_reg_base(rt_uint32_t id)
|
|
|
-{
|
|
|
- LPC_CAN_TypeDef* pCan;
|
|
|
-
|
|
|
- switch (id)
|
|
|
- {
|
|
|
- case CAN_ID_1:
|
|
|
- pCan = LPC_CAN1;
|
|
|
- break;
|
|
|
-
|
|
|
- case CAN_ID_2:
|
|
|
- pCan = LPC_CAN2;
|
|
|
- break;
|
|
|
- default:
|
|
|
- pCan = NULL;
|
|
|
- }
|
|
|
- return pCan;
|
|
|
-}
|
|
|
-
|
|
|
-static void lpccan_irqstate_init(rt_uint32_t id)
|
|
|
-{
|
|
|
- LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(id);
|
|
|
- volatile rt_int32_t i;
|
|
|
-
|
|
|
- pCan->MOD = 1; // Enter Reset Mode
|
|
|
- pCan->IER = 0; // Disable All CAN Interrupts
|
|
|
- pCan->GSR = 0;
|
|
|
-
|
|
|
- /* Request command to release Rx, Tx buffer and clear data overrun */
|
|
|
- //pCan->CMR = CAN_CMR_AT | CAN_CMR_RRB | CAN_CMR_CDO;
|
|
|
- pCan->CMR = (1 << 1) | (1 << 2) | (1 << 3);
|
|
|
-
|
|
|
- /* Read to clear interrupt pending in interrupt capture register */
|
|
|
- i = pCan->ICR;
|
|
|
- i = i;
|
|
|
-
|
|
|
- pCan->MOD = 0;// Return Normal operating
|
|
|
-}
|
|
|
-
|
|
|
-static rt_err_t lpccan_baud_set(rt_uint32_t id, rt_uint32_t baud)
|
|
|
-{
|
|
|
- uint32_t result = 0;
|
|
|
- uint8_t NT, TSEG1, TSEG2;
|
|
|
- uint32_t CANPclk = 0;
|
|
|
- uint32_t BRP;
|
|
|
- LPC_CAN_TypeDef* pCan = lcpcan_get_reg_base(id);
|
|
|
-
|
|
|
- CANPclk = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER);
|
|
|
- result = CANPclk / baud;
|
|
|
-
|
|
|
- /* Calculate suitable nominal time value
|
|
|
- * NT (nominal time) = (TSEG1 + TSEG2 + 3)
|
|
|
- * NT <= 24
|
|
|
- * TSEG1 >= 2*TSEG2
|
|
|
- */
|
|
|
- for(NT = 24; NT > 0; NT = NT-2)
|
|
|
- {
|
|
|
- if ((result % NT) == 0)
|
|
|
- {
|
|
|
- BRP = result / NT - 1;
|
|
|
- NT--;
|
|
|
- TSEG2 = (NT/3) - 1;
|
|
|
- TSEG1 = NT -(NT/3) - 1;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /* Enter reset mode */
|
|
|
- pCan->MOD = 0x01;
|
|
|
- /* Set bit timing
|
|
|
- * Default: SAM = 0x00;
|
|
|
- * SJW = 0x03;
|
|
|
- */
|
|
|
- pCan->BTR = (TSEG2 << 20) | (TSEG1 << 16) | (3 << 14) | BRP;
|
|
|
- /* Return to normal operating */
|
|
|
- pCan->MOD = 0;
|
|
|
-
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-static void lpccan_init_alut_ram(void)
|
|
|
-{
|
|
|
- //Reset CANAF value
|
|
|
- LPC_CANAF->AFMR = 0x01;
|
|
|
- //clear ALUT RAM
|
|
|
- rt_memset((void *)LPC_CANAF_RAM->mask, 0, 2048);
|
|
|
- LPC_CANAF->SFF_sa = 0;
|
|
|
- LPC_CANAF->SFF_GRP_sa = 0;
|
|
|
- LPC_CANAF->EFF_sa = 0;
|
|
|
- LPC_CANAF->EFF_GRP_sa = 0;
|
|
|
- LPC_CANAF->ENDofTable = 0;
|
|
|
- LPC_CANAF->AFMR = 0x00;
|
|
|
- // 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(uint32_t baud, CAN_MODE_Type mode)
|
|
|
-{
|
|
|
- if(mode != CAN_SELFTEST_MODE)
|
|
|
- {
|
|
|
-#ifndef LPCCAN1_USEING_GPIO_SECOND
|
|
|
- PINSEL_ConfigPin (0, 0, 1);
|
|
|
- PINSEL_ConfigPin (0, 1, 1);
|
|
|
-#else
|
|
|
- PINSEL_ConfigPin (0, 21, 4);
|
|
|
- PINSEL_ConfigPin (0, 22, 4);
|
|
|
-#endif
|
|
|
- }
|
|
|
- lpccan1_turnon_clk();
|
|
|
- lpccan_irqstate_init(CAN_1);
|
|
|
- lpccan_init_alut_ram();
|
|
|
- lpccan1_turnon_clk();
|
|
|
- lpccan_baud_set(CAN_1, baud);
|
|
|
- CAN_ModeConfig(CAN_1, mode, ENABLE);
|
|
|
- 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(uint32_t baud, CAN_MODE_Type mode)
|
|
|
-{
|
|
|
- if(mode != CAN_SELFTEST_MODE)
|
|
|
- {
|
|
|
-#ifndef LPCCAN2_USEING_GPIO_SECOND
|
|
|
- PINSEL_ConfigPin (0, 4, 2);
|
|
|
- PINSEL_ConfigPin (0, 5, 2);
|
|
|
-#else
|
|
|
- PINSEL_ConfigPin (2, 7, 1);
|
|
|
- PINSEL_ConfigPin (2, 8, 1);
|
|
|
-#endif
|
|
|
- }
|
|
|
- lpccan2_turnon_clk();
|
|
|
- lpccan_irqstate_init(CAN_2);
|
|
|
-#ifndef RT_USING_LPCCAN1
|
|
|
- lpccan_init_alut_ram();
|
|
|
-#endif /*RT_USING_LPCCAN1*/
|
|
|
- lpccan_baud_set(CAN_2, baud);
|
|
|
- CAN_ModeConfig(CAN_2, mode, ENABLE);
|
|
|
- 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;
|
|
|
- rt_uint32_t canid;
|
|
|
-
|
|
|
- switch(cfg->mode)
|
|
|
- {
|
|
|
- case RT_CAN_MODE_NORMAL:
|
|
|
- mode = CAN_OPERATING_MODE;
|
|
|
- break;
|
|
|
- case RT_CAN_MODE_LISEN:
|
|
|
- mode = CAN_LISTENONLY_MODE;
|
|
|
- break;
|
|
|
- case RT_CAN_MODE_LOOPBACKANLISEN:
|
|
|
- mode = CAN_SELFTEST_MODE;
|
|
|
- break;
|
|
|
- default:
|
|
|
- return RT_EIO;
|
|
|
- }
|
|
|
-
|
|
|
- canid = ((struct lpccandata *) can->parent.user_data)->id;
|
|
|
-#ifdef RT_USING_LPCCAN1
|
|
|
- if(canid == CAN_1)
|
|
|
- {
|
|
|
- lpccan1_hw_init(cfg->baud_rate, mode);
|
|
|
- lpccan1_filter_init(can);
|
|
|
- }
|
|
|
-#endif /*RT_USING_LPCCAN1*/
|
|
|
-#ifdef RT_USING_LPCCAN2
|
|
|
-#ifdef RT_USING_LPCCAN1
|
|
|
- else
|
|
|
-#endif /*RT_USING_LPCCAN1*/
|
|
|
- {
|
|
|
- lpccan2_hw_init(cfg->baud_rate, mode);
|
|
|
- lpccan2_filter_init(can);
|
|
|
- }
|
|
|
-#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;
|
|
|
- extern uint16_t CANAF_std_cnt;
|
|
|
- extern uint16_t CANAF_gstd_cnt;
|
|
|
- extern uint16_t CANAF_ext_cnt;
|
|
|
- extern uint16_t CANAF_gext_cnt;
|
|
|
-
|
|
|
- rt_uint32_t buf0 = 0, buf1 = 0;
|
|
|
- rt_int16_t cnt1 = 0, cnt2 = 0, bound1 = 0;
|
|
|
- CAN_ID_FORMAT_Type format;
|
|
|
- *pos = -1;
|
|
|
- if(pitem->ide)
|
|
|
- {
|
|
|
- format = EXT_ID_FORMAT;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- format = STD_ID_FORMAT;
|
|
|
- }
|
|
|
- if(pitem->mode)
|
|
|
- {
|
|
|
- rt_uint32_t id = pitem->id;
|
|
|
- if(format == STD_ID_FORMAT)
|
|
|
- {
|
|
|
- id &= 0x07FF;
|
|
|
-
|
|
|
- id |= plpccan->id << 13;/* Add controller number */
|
|
|
-
|
|
|
- if (CANAF_std_cnt == 0)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- else if (CANAF_std_cnt == 1)
|
|
|
- {
|
|
|
- cnt2 = (CANAF_FullCAN_cnt + 1) >> 1;
|
|
|
- if(id != LPC_CANAF_RAM->mask[cnt2] >> 16)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- cnt1 = (CANAF_FullCAN_cnt+1)>>1;
|
|
|
-
|
|
|
- bound1 = ((CANAF_FullCAN_cnt+1)>>1)+((CANAF_std_cnt+1)>>1);
|
|
|
-
|
|
|
- while (cnt1 < bound1)
|
|
|
- {
|
|
|
- /* Loop through standard existing IDs */
|
|
|
- if (((LPC_CANAF_RAM->mask[cnt1] >> 16) & 0xE7FF) == id)
|
|
|
- {
|
|
|
- *pos = cnt1 * 2;
|
|
|
- return CAN_OK;
|
|
|
- }
|
|
|
-
|
|
|
- if ((LPC_CANAF_RAM->mask[cnt1] & 0x0000E7FF) == id)
|
|
|
- {
|
|
|
- *pos = cnt1 * 2 + 1;
|
|
|
- return CAN_OK;
|
|
|
- }
|
|
|
- if (((LPC_CANAF_RAM->mask[cnt1] >> 16) & 0xE7FF) > id)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
-
|
|
|
- if ((LPC_CANAF_RAM->mask[cnt1] & 0x0000E7FF) > id)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- cnt1++;
|
|
|
- }
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- }
|
|
|
- /*********** Add Explicit Extended Identifier Frame Format entry *********/
|
|
|
- else
|
|
|
- {
|
|
|
- /* Add controller number */
|
|
|
- id |= plpccan->id << 29;
|
|
|
-
|
|
|
- cnt1 = ((CANAF_FullCAN_cnt+1) >> 1) + (((CANAF_std_cnt + 1) >> 1) + CANAF_gstd_cnt);
|
|
|
-
|
|
|
- cnt2 = 0;
|
|
|
-
|
|
|
- while (cnt2 < CANAF_ext_cnt)
|
|
|
- {
|
|
|
- /* Loop through extended existing masks*/
|
|
|
- if (LPC_CANAF_RAM->mask[cnt1] == id)
|
|
|
- {
|
|
|
- *pos = cnt2;
|
|
|
- return CAN_OK;
|
|
|
- }
|
|
|
- if (LPC_CANAF_RAM->mask[cnt1] > id)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- cnt1++;
|
|
|
- cnt2++;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- rt_uint32_t lowerID = pitem->id;
|
|
|
- rt_uint32_t upperID = pitem->mask;
|
|
|
- rt_uint32_t LID,UID;
|
|
|
- if(lowerID > upperID)
|
|
|
- return CAN_CONFLICT_ID_ERROR;
|
|
|
- if(format == STD_ID_FORMAT)
|
|
|
- {
|
|
|
- lowerID &=0x7FF; //mask ID
|
|
|
- upperID &=0x7FF;
|
|
|
- cnt1 = ((CANAF_FullCAN_cnt+1)>>1) + ((CANAF_std_cnt + 1) >> 1);
|
|
|
- if(CANAF_gstd_cnt == 0)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- bound1 = ((CANAF_FullCAN_cnt+1)>>1) + ((CANAF_std_cnt + 1) >> 1) + CANAF_gstd_cnt;
|
|
|
- while(cnt1 < bound1)
|
|
|
- {
|
|
|
- //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];
|
|
|
- if((LPC_CANAF_RAM->mask[cnt1] >> 29) > (plpccan->id)) //meet greater controller
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- else //meet equal controller
|
|
|
- {
|
|
|
- LID = (buf0 >> 16)&0x7FF;
|
|
|
- UID = buf0 & 0x7FF;
|
|
|
- if (upperID == LID && lowerID == UID)
|
|
|
- {
|
|
|
- *pos = cnt1;
|
|
|
- return CAN_OK;
|
|
|
- }
|
|
|
- if (upperID < LID)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- else if (lowerID >= UID)
|
|
|
- {
|
|
|
- cnt1 ++;
|
|
|
- }
|
|
|
- else
|
|
|
- return CAN_CONFLICT_ID_ERROR;
|
|
|
- }
|
|
|
- }
|
|
|
- if(cnt1 >= bound1)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- /*********Add Group of Extended Identifier Frame Format************/
|
|
|
- else
|
|
|
- {
|
|
|
- lowerID &= 0x1FFFFFFF; //mask ID
|
|
|
- upperID &= 0x1FFFFFFF;
|
|
|
- cnt1 = ((CANAF_FullCAN_cnt+1)>>1) + ((CANAF_std_cnt + 1) >> 1) + CANAF_gstd_cnt + CANAF_ext_cnt;
|
|
|
- //if this is the first Group standard ID entry
|
|
|
- if(CANAF_gext_cnt == 0)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- bound1 = ((CANAF_FullCAN_cnt+1)>>1) + ((CANAF_std_cnt + 1) >> 1) + CANAF_gstd_cnt \
|
|
|
- + CANAF_ext_cnt + (CANAF_gext_cnt<<1);
|
|
|
- while(cnt1 < bound1)
|
|
|
- {
|
|
|
- while((LPC_CANAF_RAM->mask[cnt1] >>29)< plpccan->id ) //increase until meet greater or equal controller
|
|
|
- cnt1++;
|
|
|
- buf0 = LPC_CANAF_RAM->mask[cnt1];
|
|
|
- buf1 = LPC_CANAF_RAM->mask[cnt1+1];
|
|
|
- if((LPC_CANAF_RAM->mask[cnt1] >> 29) > plpccan->id ) //meet greater controller
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- else //meet equal controller
|
|
|
- {
|
|
|
- LID = buf0 & 0x1FFFFFFF; //mask ID
|
|
|
- UID = buf1 & 0x1FFFFFFF;
|
|
|
- if (upperID == LID && lowerID == UID)
|
|
|
- {
|
|
|
- *pos = cnt1;
|
|
|
- return CAN_OK;
|
|
|
- }
|
|
|
- if (upperID < LID)
|
|
|
- {
|
|
|
- return CAN_ENTRY_NOT_EXIT_ERROR;
|
|
|
- }
|
|
|
- else if (lowerID >= UID)
|
|
|
- {
|
|
|
- //load next entry to compare
|
|
|
- cnt1 +=2;
|
|
|
- }
|
|
|
- else
|
|
|
- return CAN_CONFLICT_ID_ERROR;
|
|
|
- }
|
|
|
- }
|
|
|
- if(cnt1 >= bound1)
|
|
|
- {
|
|
|
- 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)
|
|
|
-{
|
|
|
- struct rt_can_filter_item* pitem = pconfig->items;
|
|
|
- rt_uint32_t count = pconfig->count;
|
|
|
- rt_int32_t pos;
|
|
|
- CAN_ID_FORMAT_Type format;
|
|
|
- CAN_ERROR lpccanres;
|
|
|
- while(count)
|
|
|
- {
|
|
|
- if(pitem->ide)
|
|
|
- {
|
|
|
- format = EXT_ID_FORMAT;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- format = STD_ID_FORMAT;
|
|
|
- }
|
|
|
- lpccanres = findfilter(plpccan, pitem, &pos);
|
|
|
- if(pconfig->actived && lpccanres != CAN_OK)
|
|
|
- {
|
|
|
- if(pitem->mode)
|
|
|
- {
|
|
|
- lpccanres = CAN_LoadGroupEntry(plpccan->id, pitem->id, pitem->mask, format);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- lpccanres = CAN_LoadExplicitEntry(plpccan->id, pitem->id, format);
|
|
|
- }
|
|
|
- }
|
|
|
- else if(!pconfig->actived && lpccanres == CAN_OK)
|
|
|
- {
|
|
|
- AFLUT_ENTRY_Type type;
|
|
|
- if(pitem->mode)
|
|
|
- {
|
|
|
- if(format == EXT_ID_FORMAT)
|
|
|
- {
|
|
|
- type = GROUP_EXTEND_ENTRY;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- type = GROUP_STANDARD_ENTRY;
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- if(format == EXT_ID_FORMAT)
|
|
|
- {
|
|
|
- type = EXPLICIT_EXTEND_ENTRY;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- type = EXPLICIT_STANDARD_ENTRY;
|
|
|
- }
|
|
|
- }
|
|
|
- lpccanres = CAN_RemoveEntry(type, (rt_uint16_t)(pos));
|
|
|
- }
|
|
|
- else if(!pconfig->actived && lpccanres != CAN_OK)
|
|
|
- {
|
|
|
- lpccanres = CAN_OK;
|
|
|
- }
|
|
|
- if(lpccanres != CAN_OK)
|
|
|
- {
|
|
|
- return RT_EIO;
|
|
|
- }
|
|
|
- pitem++;
|
|
|
- count--;
|
|
|
- }
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-static rt_err_t control(struct rt_can_device *can, int cmd, void *arg)
|
|
|
-{
|
|
|
- struct lpccandata* plpccan;
|
|
|
- rt_uint32_t argval;
|
|
|
- CAN_MODE_Type mode;
|
|
|
-
|
|
|
- plpccan = (struct lpccandata* ) can->parent.user_data;
|
|
|
- RT_ASSERT(plpccan != RT_NULL);
|
|
|
-
|
|
|
- switch (cmd)
|
|
|
- {
|
|
|
- case RT_DEVICE_CTRL_CLR_INT:
|
|
|
- argval = (rt_uint32_t) arg;
|
|
|
- if(argval == RT_DEVICE_FLAG_INT_RX)
|
|
|
- {
|
|
|
- CAN_IRQCmd(plpccan->id, CANINT_RIE, DISABLE);
|
|
|
- CAN_IRQCmd(plpccan->id, CANINT_DOIE, DISABLE);
|
|
|
- }
|
|
|
- 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)
|
|
|
- {
|
|
|
- CAN_IRQCmd(plpccan->id, CANINT_EIE, DISABLE);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case RT_DEVICE_CTRL_SET_INT:
|
|
|
- argval = (rt_uint32_t) arg;
|
|
|
- if(argval == RT_DEVICE_FLAG_INT_RX)
|
|
|
- {
|
|
|
- CAN_IRQCmd(plpccan->id, CANINT_RIE, ENABLE);
|
|
|
- CAN_IRQCmd(plpccan->id, CANINT_DOIE, ENABLE);
|
|
|
- }
|
|
|
- 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)
|
|
|
- {
|
|
|
- CAN_IRQCmd(plpccan->id, CANINT_EIE, ENABLE);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case RT_CAN_CMD_SET_FILTER:
|
|
|
- return setfilter(plpccan, (struct rt_can_filter_config*) arg);
|
|
|
-
|
|
|
- case RT_CAN_CMD_SET_MODE:
|
|
|
- argval = (rt_uint32_t) arg;
|
|
|
- if(argval != RT_CAN_MODE_NORMAL ||
|
|
|
- argval != RT_CAN_MODE_LISEN)
|
|
|
- {
|
|
|
- return RT_ERROR;
|
|
|
- }
|
|
|
- if(argval != can->config.mode)
|
|
|
- {
|
|
|
- can->config.mode = argval;
|
|
|
- switch(argval)
|
|
|
- {
|
|
|
- case RT_CAN_MODE_NORMAL:
|
|
|
- mode = CAN_OPERATING_MODE;
|
|
|
- break;
|
|
|
- case RT_CAN_MODE_LISEN:
|
|
|
- mode = CAN_LISTENONLY_MODE;
|
|
|
- break;
|
|
|
- case RT_CAN_MODE_LOOPBACKANLISEN:
|
|
|
- mode = CAN_SELFTEST_MODE;
|
|
|
- break;
|
|
|
- default:
|
|
|
- return RT_EIO;
|
|
|
- }
|
|
|
- CAN_ModeConfig(plpccan->id, mode, ENABLE);
|
|
|
- if(mode == CAN_SELFTEST_MODE)
|
|
|
- {
|
|
|
- //CAN_ModeConfig(CAN_1, CAN_TEST_MODE, ENABLE);
|
|
|
- CAN_SetAFMode(CAN_ACC_BP);
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case RT_CAN_CMD_SET_BAUD:
|
|
|
- argval = (rt_uint32_t) arg;
|
|
|
- if(argval != can->config.baud_rate)
|
|
|
- {
|
|
|
- can->config.baud_rate = argval;
|
|
|
- return lpccan_baud_set(plpccan->id, (rt_uint32_t) arg);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case RT_CAN_CMD_SET_PRIV:
|
|
|
- argval = (rt_uint32_t) arg;
|
|
|
- if(argval != RT_CAN_MODE_PRIV ||
|
|
|
- argval != RT_CAN_MODE_NOPRIV)
|
|
|
- {
|
|
|
- return RT_ERROR;
|
|
|
- }
|
|
|
- if(argval != can->config.privmode)
|
|
|
- {
|
|
|
- can->config.privmode = argval;
|
|
|
- CAN_ModeConfig(plpccan->id, CAN_TXPRIORITY_MODE, ENABLE);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case RT_CAN_CMD_GET_STATUS:
|
|
|
- {
|
|
|
- can->status.rcverrcnt = 0;
|
|
|
- can->status.snderrcnt = 0;
|
|
|
- can->status.errcode = 0;
|
|
|
- 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)
|
|
|
-{
|
|
|
- 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;
|
|
|
- RT_ASSERT(plpccan != RT_NULL);
|
|
|
-
|
|
|
- pCan = lcpcan_get_reg_base(plpccan->id);
|
|
|
- RT_ASSERT(pCan != RT_NULL);
|
|
|
-
|
|
|
- pmsg = (struct rt_can_msg*) buf;
|
|
|
-
|
|
|
- if(boxno > 2)
|
|
|
- {
|
|
|
- return RT_ERROR;
|
|
|
- }
|
|
|
-
|
|
|
- CMRMsk = 0x01 | (0x01 << (boxno + 5));
|
|
|
- SR_Mask = 0x01 <<(boxno * 8 + 2);
|
|
|
-
|
|
|
- if(pCan->SR & SR_Mask)
|
|
|
- {
|
|
|
- volatile unsigned int *pTFI = (&pCan->TFI1 + 0 + 4 * boxno);
|
|
|
- volatile unsigned int *pTID = (&pCan->TFI1 + 1 + 4 * boxno);
|
|
|
- volatile unsigned int *pTDA = (&pCan->TFI1 + 2 + 4 * boxno);
|
|
|
- volatile unsigned int *pTDB = (&pCan->TFI1 + 3 + 4 * boxno);
|
|
|
- rt_uint32_t data;
|
|
|
-
|
|
|
- /* Transmit Channel 1 is available */
|
|
|
- /* Write frame informations and frame data into its CANxTFI1,
|
|
|
- * CANxTID1, CANxTDA1, CANxTDB1 register */
|
|
|
- *pTFI &= ~ 0x000F0000;
|
|
|
- *pTFI |= (pmsg->len) << 16;
|
|
|
- if(pmsg->rtr == REMOTE_FRAME)
|
|
|
- {
|
|
|
- *pTFI |= (1 << 30); //set bit RTR
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- *pTFI &= ~(1 << 30);
|
|
|
- }
|
|
|
-
|
|
|
- if(pmsg->ide == EXT_ID_FORMAT)
|
|
|
- {
|
|
|
- *pTFI |= (((uint32_t)1) << 31); //set bit FF
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- *pTFI &= ~(((uint32_t)1) << 31);
|
|
|
- }
|
|
|
- if(can->config.privmode)
|
|
|
- {
|
|
|
- *pTFI &= ~0x000000FF;
|
|
|
- *pTFI |= pmsg->priv;
|
|
|
- }
|
|
|
- /* Write CAN ID*/
|
|
|
- *pTID = pmsg->id;
|
|
|
- /*Write first 4 data bytes*/
|
|
|
- data = (pmsg->data[0]) | (((pmsg->data[1]))<< 8) | ((pmsg->data[2]) << 16) | ((pmsg->data[3]) << 24);
|
|
|
- *pTDA = data;
|
|
|
- /*Write second 4 data bytes*/
|
|
|
- data = (pmsg->data[4]) | (((pmsg->data[5])) << 8) | ((pmsg->data[6]) << 16) | ((pmsg->data[7]) << 24);
|
|
|
- *pTDB = data;
|
|
|
- /*Write transmission request*/
|
|
|
- pCan->CMR = CMRMsk;
|
|
|
- return RT_EOK;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- return RT_ERROR;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static int recvmsg(struct rt_can_device *can, void* buf, rt_uint32_t boxno)
|
|
|
-{
|
|
|
- struct lpccandata* plpccan;
|
|
|
- LPC_CAN_TypeDef* pCan;
|
|
|
-
|
|
|
- plpccan = (struct lpccandata* ) can->parent.user_data;
|
|
|
- RT_ASSERT(plpccan != RT_NULL);
|
|
|
- pCan = lcpcan_get_reg_base(plpccan->id);
|
|
|
- RT_ASSERT(pCan != RT_NULL);
|
|
|
-
|
|
|
- //CAN_ReceiveMsg
|
|
|
- //check status of Receive Buffer
|
|
|
- if((pCan->SR &0x00000001))
|
|
|
- {
|
|
|
- uint32_t data;
|
|
|
- struct rt_can_msg* pmsg = (struct rt_can_msg*) buf;
|
|
|
-
|
|
|
- /* Receive message is available */
|
|
|
- /* Read frame informations */
|
|
|
- pmsg->ide = (uint8_t)(((pCan->RFS) & 0x80000000) >> 31);
|
|
|
- pmsg->rtr = (uint8_t)(((pCan->RFS) & 0x40000000) >> 30);
|
|
|
- pmsg->len = (uint8_t)(((pCan->RFS) & 0x000F0000) >> 16);
|
|
|
- /* Read CAN message identifier */
|
|
|
- pmsg->id = pCan->RID;
|
|
|
- /* Read the data if received message was DATA FRAME */
|
|
|
- if (!pmsg->rtr)
|
|
|
- {
|
|
|
- /* Read first 4 data bytes */
|
|
|
- data = pCan->RDA;
|
|
|
- pmsg->data[0] = data & 0x000000FF;
|
|
|
- pmsg->data[1] = (data & 0x0000FF00) >> 8;
|
|
|
- pmsg->data[2] = (data & 0x00FF0000) >> 16;
|
|
|
- pmsg->data[3] = (data & 0xFF000000) >> 24;
|
|
|
- /* Read second 4 data bytes */
|
|
|
- if(pmsg->len > 4)
|
|
|
- {
|
|
|
- data = pCan->RDB;
|
|
|
- pmsg->data[4] = data & 0x000000FF;
|
|
|
- pmsg->data[5] = (data & 0x0000FF00) >> 8;
|
|
|
- pmsg->data[6] = (data & 0x00FF0000) >> 16;
|
|
|
- pmsg->data[7] = (data & 0xFF000000) >> 24;
|
|
|
- }
|
|
|
- pmsg->hdr = 0;
|
|
|
- /*release receive buffer*/
|
|
|
- pCan->CMR = 0x04;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- /* Received Frame is a Remote Frame, not have data, we just receive
|
|
|
- * message information only */
|
|
|
- pCan->CMR = 0x04; /*release receive buffer*/
|
|
|
- return SUCCESS;
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // no receive message available
|
|
|
- return ERROR;
|
|
|
- }
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-static const struct rt_can_ops canops =
|
|
|
-{
|
|
|
- configure,
|
|
|
- control,
|
|
|
- sendmsg,
|
|
|
- recvmsg,
|
|
|
-};
|
|
|
-
|
|
|
-#ifdef RT_USING_LPCCAN1
|
|
|
-#ifdef RT_CAN_USING_LED
|
|
|
-#endif
|
|
|
-static struct lpccandata lpccandata1 =
|
|
|
-{
|
|
|
- CAN_ID_1,
|
|
|
-};
|
|
|
-static struct rt_can_device lpccan1;
|
|
|
-#endif /*RT_USINGLPCCAN1*/
|
|
|
-
|
|
|
-#ifdef RT_USING_LPCCAN2
|
|
|
-#ifdef RT_CAN_USING_LED
|
|
|
-#endif
|
|
|
-static struct lpccandata lpccandata2 =
|
|
|
-{
|
|
|
- CAN_ID_2,
|
|
|
-};
|
|
|
-static struct rt_can_device lpccan2;
|
|
|
-#endif /*RT_USINGLPCCAN2*/
|
|
|
-
|
|
|
-/*----------------- INTERRUPT SERVICE ROUTINES --------------------------*/
|
|
|
-/*********************************************************************//**
|
|
|
- * @brief Event Router IRQ Handler
|
|
|
- * @param[in] None
|
|
|
- * @return None
|
|
|
- **********************************************************************/
|
|
|
-void CAN_IRQHandler(void)
|
|
|
-{
|
|
|
- rt_uint32_t IntStatus;
|
|
|
- rt_interrupt_enter();
|
|
|
-#ifdef RT_USING_LPCCAN1
|
|
|
- IntStatus = CAN_IntGetStatus(CAN_1);
|
|
|
- //check receive interrupt
|
|
|
- if((IntStatus >> 0) & 0x01)
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_RX_IND | 0<<8);
|
|
|
- }
|
|
|
- //check Transmit Interrupt interrupt1
|
|
|
- if((IntStatus >> 1) & 0x01)
|
|
|
- {
|
|
|
- rt_uint32_t state = 0;
|
|
|
- state = CAN_GetCTRLStatus(CAN_1, CANCTRL_STS);
|
|
|
- if(state & (0x01 << 3))
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 0<<8);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 0<<8);
|
|
|
- }
|
|
|
- }
|
|
|
- //check Error Warning Interrupt
|
|
|
- if((IntStatus >> 2) & 0x01)
|
|
|
- {
|
|
|
- rt_uint32_t errtype;
|
|
|
- rt_uint32_t state;
|
|
|
-
|
|
|
- errtype = (IntStatus >> 16);
|
|
|
- if(errtype & 0x1F && lpccan1.status.lasterrtype == (errtype & 0x1F))
|
|
|
- {
|
|
|
- switch((errtype & 0x1F))
|
|
|
- {
|
|
|
- case 00011: // Start of Frame
|
|
|
- case 00010: // ID28 ... ID21
|
|
|
- case 00110: //ID20 ... ID18
|
|
|
- case 00100: // SRTR Bit
|
|
|
- case 00101: // IDE bit
|
|
|
- case 00111: // ID17 ... 13
|
|
|
- case 01111: // ID12 ... ID5
|
|
|
- case 01110: // ID4 ... ID0
|
|
|
- case 01100: // RTR Bit
|
|
|
- case 01011: // Data Length Code
|
|
|
- case 01010: // Data Field
|
|
|
- lpccan1.status.formaterrcnt++;
|
|
|
- break;
|
|
|
- case 01101: // Reserved Bit 1
|
|
|
- case 01001: // Reserved Bit 0
|
|
|
- lpccan1.status.bitpaderrcnt++;
|
|
|
- break;
|
|
|
- case 01000: // CRC Sequence
|
|
|
- case 11000: // CRC Delimiter
|
|
|
- lpccan1.status.crcerrcnt++;
|
|
|
- break;
|
|
|
- case 11001: // Acknowledge Slot
|
|
|
- case 11011: // Acknowledge Delimiter
|
|
|
- lpccan1.status.ackerrcnt++;
|
|
|
- break;
|
|
|
- case 11010: // End of Frame
|
|
|
- case 10010: // Intermission
|
|
|
- lpccan1.status.formaterrcnt++;
|
|
|
- break;
|
|
|
- }
|
|
|
- lpccan1.status.lasterrtype = errtype & 0x1F;
|
|
|
- }
|
|
|
-
|
|
|
- state = CAN_GetCTRLStatus(CAN_1, CANCTRL_GLOBAL_STS);
|
|
|
- lpccan1.status.rcverrcnt = (state >> 16) & 0xFF;
|
|
|
- lpccan1.status.snderrcnt = (state >> 24) & 0xFF;
|
|
|
- lpccan1.status.errcode = (state >> 5) & 0x06;
|
|
|
- }
|
|
|
- //check Data Overrun Interrupt Interrupt
|
|
|
- if((IntStatus >> 3) & 0x01)
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_RXOF_IND | 0<<8);
|
|
|
- }
|
|
|
- //check Transmit Interrupt interrupt2
|
|
|
- if((IntStatus >> 9) & 0x01)
|
|
|
- {
|
|
|
- rt_uint32_t state = 0;
|
|
|
- state = CAN_GetCTRLStatus(CAN_1, CANCTRL_STS);
|
|
|
- if(state & (0x01 << 11))
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 1<<8);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 1<<8);
|
|
|
- }
|
|
|
- }
|
|
|
- //check Transmit Interrupt interrupt3
|
|
|
- if((IntStatus >> 10) & 0x01)
|
|
|
- {
|
|
|
- rt_uint32_t state = 0;
|
|
|
- state = CAN_GetCTRLStatus(CAN_1, CANCTRL_STS);
|
|
|
- if(state & (0x01 << 19))
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 2<<8);
|
|
|
- }
|
|
|
- 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
|
|
|
- if((IntStatus >> 0) & 0x01)
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan2,RT_CAN_EVENT_RX_IND | 0<<8);
|
|
|
- }
|
|
|
- //check Transmit Interrupt interrupt1
|
|
|
- if((IntStatus >> 1) & 0x01)
|
|
|
- {
|
|
|
- rt_uint32_t state = 0;
|
|
|
- state = CAN_GetCTRLStatus(CAN_2, CANCTRL_STS);
|
|
|
- if(state & (0x01 << 3))
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 0<<8);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 0<<8);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //check Error Warning Interrupt
|
|
|
- if((IntStatus >> 2) & 0x01)
|
|
|
- {
|
|
|
- rt_uint32_t errtype;
|
|
|
- errtype = (IntStatus >> 16);
|
|
|
- if(errtype & 0x1F && lpccan2.status.lasterrtype == (errtype & 0x1F))
|
|
|
- {
|
|
|
- switch((errtype & 0x1F))
|
|
|
- {
|
|
|
- case 00011: // Start of Frame
|
|
|
- case 00010: // ID28 ... ID21
|
|
|
- case 00110: //ID20 ... ID18
|
|
|
- case 00100: // SRTR Bit
|
|
|
- case 00101: // IDE bit
|
|
|
- case 00111: // ID17 ... 13
|
|
|
- case 01111: // ID12 ... ID5
|
|
|
- case 01110: // ID4 ... ID0
|
|
|
- case 01100: // RTR Bit
|
|
|
- case 01011: // Data Length Code
|
|
|
- case 01010: // Data Field
|
|
|
- lpccan2.status.formaterrcnt++;
|
|
|
- break;
|
|
|
- case 01101: // Reserved Bit 1
|
|
|
- case 01001: // Reserved Bit 0
|
|
|
- lpccan2.status.bitpaderrcnt++;
|
|
|
- break;
|
|
|
- case 01000: // CRC Sequence
|
|
|
- case 11000: // CRC Delimiter
|
|
|
- lpccan2.status.crcerrcnt++;
|
|
|
- break;
|
|
|
- case 11001: // Acknowledge Slot
|
|
|
- case 11011: // Acknowledge Delimiter
|
|
|
- lpccan2.status.ackerrcnt++;
|
|
|
- break;
|
|
|
- case 11010: // End of Frame
|
|
|
- case 10010: // Intermission
|
|
|
- lpccan2.status.formaterrcnt++;
|
|
|
- break;
|
|
|
- }
|
|
|
- lpccan2.status.lasterrtype = errtype & 0x1F;
|
|
|
- }
|
|
|
- rt_uint32_t state = 0;
|
|
|
- state = CAN_GetCTRLStatus(CAN_2, CANCTRL_GLOBAL_STS);
|
|
|
- lpccan2.status.rcverrcnt = (state >> 16) & 0xFF;
|
|
|
- lpccan2.status.snderrcnt = (state >> 24) & 0xFF;
|
|
|
- lpccan2.status.errcode = (state >> 5) & 0x06;
|
|
|
- }
|
|
|
-
|
|
|
- //check Data Overrun Interrupt Interrupt
|
|
|
- if((IntStatus >> 3) & 0x01)
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_RXOF_IND | 0<<8);
|
|
|
- }
|
|
|
-
|
|
|
- //check Transmit Interrupt interrupt2
|
|
|
- if((IntStatus >> 9) & 0x01)
|
|
|
- {
|
|
|
- rt_uint32_t state = 0;
|
|
|
- state = CAN_GetCTRLStatus(CAN_2, CANCTRL_STS);
|
|
|
- if(state & (0x01 << 11))
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 1<<8);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 1<<8);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //check Transmit Interrupt interrupt3
|
|
|
- if((IntStatus >> 10) & 0x01)
|
|
|
- {
|
|
|
- rt_uint32_t state = 0;
|
|
|
- state = CAN_GetCTRLStatus(CAN_2, CANCTRL_STS);
|
|
|
- if(state & (0x01 << 19))
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_DONE | 2<<8);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- rt_hw_can_isr(&lpccan1,RT_CAN_EVENT_TX_FAIL | 2<<8);
|
|
|
- }
|
|
|
- }
|
|
|
-#endif /*RT_USING_LPCCAN2*/
|
|
|
- rt_interrupt_leave();
|
|
|
-}
|
|
|
-
|
|
|
-int lpc_can_init(void)
|
|
|
-{
|
|
|
-#ifdef RT_USING_LPCCAN1
|
|
|
- lpccan1.config.baud_rate=CAN1MBaud;
|
|
|
- lpccan1.config.msgboxsz=16;
|
|
|
- lpccan1.config.sndboxnumber=3;
|
|
|
- lpccan1.config.mode=RT_CAN_MODE_NORMAL;
|
|
|
- lpccan1.config.privmode=0;
|
|
|
-
|
|
|
-#ifdef RT_CAN_USING_LED
|
|
|
-#endif
|
|
|
-
|
|
|
- lpccan1.config.ticks = 50;
|
|
|
-
|
|
|
-#ifdef RT_CAN_USING_HDR
|
|
|
-#endif
|
|
|
-
|
|
|
- //Enable CAN Interrupt
|
|
|
- NVIC_EnableIRQ(CAN_IRQn);
|
|
|
- rt_hw_can_register(&lpccan1, "lpccan1", &canops, &lpccandata1);
|
|
|
-#endif /*RT_USING_LPCCAN1*/
|
|
|
-
|
|
|
-#ifdef RT_USING_LPCCAN2
|
|
|
- lpccan2.config.baud_rate=CAN1MBaud;
|
|
|
- lpccan2.config.msgboxsz=16;
|
|
|
- lpccan2.config.sndboxnumber=3;
|
|
|
- lpccan2.config.mode=RT_CAN_MODE_NORMAL;
|
|
|
- lpccan2.config.privmode=0;
|
|
|
-
|
|
|
-#ifdef RT_CAN_USING_LED
|
|
|
-#endif
|
|
|
-
|
|
|
- lpccan2.config.ticks = 50;
|
|
|
-
|
|
|
-#ifdef RT_CAN_USING_HDR
|
|
|
-#endif
|
|
|
-
|
|
|
- //Enable CAN Interrupt
|
|
|
- NVIC_EnableIRQ(CAN_IRQn);
|
|
|
-
|
|
|
-#ifdef RT_CAN_USING_HDR
|
|
|
-#endif
|
|
|
-
|
|
|
- rt_hw_can_register(&lpccan2, "lpccan2", &canops, &lpccandata2);
|
|
|
-#endif /*RT_USING_LPCCAN2*/
|
|
|
-
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-INIT_BOARD_EXPORT(lpc_can_init);
|
|
|
-
|
|
|
-#endif /*RT_USING_CAN*/
|