andreika-git
/
ChibiOS
mirror of https://github.com/andreika-git/ChibiOS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ChibiOS/os/hal/platforms/LPC17xx/can_lld.c

658 lines
16 KiB
C
Raw Blame History

/*
ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/**
* @file LPC17xx/can_lld.c
* @brief LPC17xx CAN subsystem low level driver source.
*
* @addtogroup CAN
* @{
*/
/*
This file has been contributed by:
Marcin Jokel.
*/
#include "ch.h"
#include "hal.h"
#if HAL_USE_CAN || defined(__DOXYGEN__)
/* TODO: FullCAN mode. */
/*===========================================================================*/
/* Driver local definitions. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver exported variables. */
/*===========================================================================*/
/** @brief CAN1 driver identifier.*/
#if LPC17xx_CAN_USE_CAN1 || defined(__DOXYGEN__)
CANDriver CAND1;
#endif
/** @brief CAN2 driver identifier.*/
#if LPC17xx_CAN_USE_CAN2 || defined(__DOXYGEN__)
CANDriver CAND2;
#endif
/*===========================================================================*/
/* Driver local variables and types. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver local functions. */
/*===========================================================================*/
#if LPC17xx_CAN_USE_FILTER
/**
* @brief Copy table to filter ram.
*
* @param[in] reg
* @param[in] ptable
* @param[in] addr_start
* @param[in] addr_end
*
* @notapi
*/
static void can_lld_copy_table_to_ram(volatile uint32_t * reg,
const uint32_t * ptable,
uint32_t addr_start,
uint32_t addr_end) {
uint32_t i;
if (reg != NULL) {
*reg = ((addr_start * 4) << 2);
}
for (i = addr_start; i < addr_end; i++) {
LPC_CANAF_RAM->mask[i] = ptable[i];
}
}
/**
* @brief Programs the filters.
*
* @param[in] cfc pointer to the can filter configuration structure
*
* @notapi
*/
static void can_lld_set_filter( const CANFilterConfig *cfc) {
uint32_t addr_start;
uint32_t addr_end;
LPC_CANAF->AFMR = AFMR_ACC_OFF; /* Acceptance filter off mode. */
addr_start = cfc->fc_id_table_n;
if (addr_start > 0) {
can_lld_copy_table_to_ram(NULL, cfc->fc_id_table, 0, addr_start);
}
addr_start = cfc->fc_id_table_n;
addr_end = cfc->std_id_table_n;
can_lld_copy_table_to_ram(&LPC_CANAF->SFF_sa, cfc->std_id_table, addr_start, addr_end);
addr_start = addr_end;
addr_end += cfc->std_range_id_table_n;
can_lld_copy_table_to_ram(&LPC_CANAF->SFF_GRP_sa, cfc->std_range_id_table, addr_start, addr_end);
addr_start = addr_end;
addr_end += cfc->ext_id_table_n;
can_lld_copy_table_to_ram(&LPC_CANAF->EFF_sa, cfc->ext_id_table, addr_start, addr_end);
addr_start = addr_end;
addr_end += cfc->ext_range_id_table_n;
can_lld_copy_table_to_ram(&LPC_CANAF->EFF_GRP_sa, cfc->ext_range_id_table, addr_start, addr_end);
LPC_CANAF->ENDofTable = (addr_end * 4) << 2;
LPC_CANAF->AFMR = cfc->afmr;
}
#endif
/**
* @brief Common TX ISR handler.
*
* @param[in] canp pointer to the @p CANDriver object
*
* @notapi
*/
static void can_lld_tx_handler(CANDriver *canp) {
/* All transmit buffers are available.*/
if (canp->can->GSR & CANGSR_TBS) {
chSysLockFromIsr();
while (chSemGetCounterI(&canp->txsem) < 0)
chSemSignalI(&canp->txsem);
chEvtBroadcastFlagsI(&canp->txempty_event, CAN_MAILBOX_TO_MASK(1));
chSysUnlockFromIsr();
}
}
/**
* @brief Common RX ISR handler.
*
* @param[in] canp pointer to the @p CANDriver object
* @param[in] status
* @notapi
*/
static void can_lld_rx_handler(CANDriver *canp, uint32_t status) {
/* No more receive events until the queue 0 has been emptied.*/
canp->can->IER &= ~CANIER_RIE;
chSysLockFromIsr();
while (chSemGetCounterI(&canp->rxsem) < 0)
chSemSignalI(&canp->rxsem);
chEvtBroadcastFlagsI(&canp->rxfull_event, CAN_MAILBOX_TO_MASK(1));
chSysUnlockFromIsr();
if (( status & CANICR_DOI) > 0) {
/* Overflow events handling.*/
canp->can->CMR = CANCMR_CDO;
chSysLockFromIsr();
chEvtBroadcastFlagsI(&canp->error_event, CAN_OVERFLOW_ERROR);
chSysUnlockFromIsr();
}
}
/**
* @brief Error ISR handler.
*
* @param[in] canp pointer to the @p CANDriver object
* @param[in] flags
*
* @notapi
*/
static void can_lld_error_handler(CANDriver *canp, uint32_t status) {
uint32_t flags;
/* Error event.*/
/* The high 16-bits of the ICR register (error codes for bus error)
is copied unchanged in the upper half word of the listener flags mask.*/
flags = status & 0xFFFF0000;
if (status & CANICR_EI)
flags |= CAN_WARNING_ERROR;
if (status & CANICR_EPI)
flags |= CAN_PASSIVE_ERROR;
if (status & CANICR_BEI)
flags |= CAN_BUS_ERROR;
chSysLockFromIsr();
chEvtBroadcastFlagsI(&canp->error_event, flags);
chSysUnlockFromIsr();
}
#if CAN_USE_SLEEP_MODE
/**
* @brief Wake up ISR handler.
*
* @param[in] canp pointer to the @p CANDriver object
*
* @notapi
*/
static void can_lld_wakeup_handler(CANDriver *canp) {
/* Wakeup event.*/
canp->state = CAN_READY;
can_lld_wakeup(canp);
chSysLockFromIsr();
chEvtBroadcastI(&canp->wakeup_event);
chSysUnlockFromIsr();
}
#endif /* CAN_USE_SLEEP_MODE */
/*===========================================================================*/
/* Driver interrupt handlers. */
/*===========================================================================*/
#if LPC17xx_CAN_USE_CAN1 || LPC17xx_CAN_USE_CAN2 ||defined(__DOXYGEN__)
/**
* @brief CAN Common, CAN 1 Tx, CAN 1 Rx, CAN 2 Tx, CAN 2 Rx.
*
* @isr
*/
CH_IRQ_HANDLER(VectorA4) {
#if LPC17xx_CAN_USE_CAN1
volatile uint32_t can1_status;
#endif
#if LPC17xx_CAN_USE_CAN2
volatile uint32_t can2_status;
#endif
CH_IRQ_PROLOGUE();
#if LPC17xx_CAN_USE_CAN1
can1_status = LPC_CAN1->ICR;
#endif
#if LPC17xx_CAN_USE_CAN2
can2_status = LPC_CAN2->ICR;
#endif
#if LPC17xx_CAN_USE_CAN1
if (can1_status & 0x000007FF) {
if (can1_status & (CANICR_EI | CANICR_EPI | CANICR_BEI)) {
can_lld_error_handler(&CAND1, can1_status);
}
if (can1_status & (CANICR_RI | CANICR_DOI)) {
can_lld_rx_handler(&CAND1, can1_status);
}
if (can1_status & (CANICR_TI1 | CANICR_TI2 | CANICR_TI3)){
can_lld_tx_handler(&CAND1);
}
}
#endif
#if LPC17xx_CAN_USE_CAN2
if (can2_status & 0x000007FF) {
if (can2_status & CANICR_EI) {
can_lld_error_handler(&CAND2, can2_status);
}
if (can2_status & (CANICR_RI | CANICR_DOI)) {
can_lld_rx_handler(&CAND2, can2_status);
}
if (can2_status & (CANICR_TI1 | CANICR_TI2 | CANICR_TI3)){
can_lld_tx_handler(&CAND2);
}
}
#endif
CH_IRQ_EPILOGUE();
}
#if CAN_USE_SLEEP_MODE
/**
* @brief CAN Common, CAN 1 Tx, CAN 1 Rx, CAN 2 Tx, CAN 2 Rx.
*
* @isr
*/
CH_IRQ_HANDLER(VectorC8) {
#if LPC17xx_CAN_USE_CAN1
uint32_t can1_status;
#endif
#if LPC17xx_CAN_USE_CAN2
uint32_t can2_status;
#endif
CH_IRQ_PROLOGUE();
#if LPC17xx_CAN_USE_CAN1
can1_status = LPC_CAN1->ICR;
#endif
#if LPC17xx_CAN_USE_CAN2
can2_status = LPC_CAN2->ICR;
#endif
#if LPC17xx_CAN_USE_CAN1
if (can1_status & CANICR_WUI) {
can_lld_wakeup_handler(&CAND1);
}
#endif
#if LPC17xx_CAN_USE_CAN2
if (can2_status & CANICR_WUI) {
can_lld_wakeup_handler(&CAND2);
}
#endif
CH_IRQ_EPILOGUE();
}
#endif /* CAN_USE_SLEEP_MODE */
#endif /* LPC17xx_CAN_USE_CAN1 || LPC17xx_CAN_USE_CAN2 */
/*===========================================================================*/
/* Driver exported functions. */
/*===========================================================================*/
/**
* @brief Low level CAN driver initialization.
*
* @notapi
*/
void can_lld_init(void) {
#if LPC17xx_CAN_USE_CAN1
/* Driver initialization.*/
canObjectInit(&CAND1);
CAND1.can = LPC_CAN1;
#endif
#if LPC17xx_CAN_USE_CAN2
/* Driver initialization.*/
canObjectInit(&CAND2);
CAND2.can = LPC_CAN2;
#endif
}
/**
* @brief Configures and activates the CAN peripheral.
*
* @param[in] canp pointer to the @p CANDriver object
*
* @notapi
*/
void can_lld_start(CANDriver *canp) {
#if LPC17xx_CAN_USE_CAN1
if (&CAND1 == canp) {
LPC_SC->PCONP |= (1UL << 13);
}
#endif
#if LPC17xx_CAN_USE_CAN2
if (&CAND2 == canp) {
LPC_SC->PCONP |= (1UL << 14);
}
#endif
canp->can->MOD = CANMOD_RM; /* Reset mode. */
#if !LPC17xx_CAN_USE_FILTER
LPC_CANAF->AFMR = AFMR_ACC_BP; /* Bypass can filter. */
#endif
/* Entering initialization mode. */
canp->state = CAN_STARTING;
canp->can->BTR = canp->config->btr; /* BTR initialization.*/
canp->can->CMR = CANCMR_RRB;
/* Interrupt sources initialization.*/
canp->can->IER = CANIER_TIE3 | CANIER_TIE2 | CANIER_BEIE |
CANIER_EPIE | CANIER_DOIE | CANIER_EIE |
CANIER_TIE1 | CANIER_RIE;
#if CAN_USE_SLEEP_MODE
canp->can->IER |= CANIER_WUIE;
nvicEnableVector(CANActivity_IRQn,
CORTEX_PRIORITY_MASK(LPC17xx_CAN_IRQ_PRIORITY));
#endif /* CAN_USE_SLEEP_MODE */
canp->can->MOD = canp->config->mod; /* Operating mode. */
nvicEnableVector(CAN_IRQn,
CORTEX_PRIORITY_MASK(LPC17xx_CAN_IRQ_PRIORITY));
}
/**
* @brief Deactivates the CAN peripheral.
*
* @param[in] canp pointer to the @p CANDriver object
*
* @notapi
*/
void can_lld_stop(CANDriver *canp) {
/* If in ready state then disables the CAN peripheral.*/
if (canp->state == CAN_READY) {
canp->can->MOD = CANMOD_RM; /* Reset mode. */
canp->can->IER = 0;
#if (LPC17xx_CAN_USE_CAN1 && LPC17xx_CAN_USE_CAN2) == 0
nvicDisableVector(CAN_IRQn); /* Interrupt disabled only if one CAN is in use. */
#endif
#if LPC17xx_CAN_USE_CAN1
if (&CAND1 == canp) {
LPC_SC->PCONP &= ~(1UL << 13);
}
#endif
#if LPC17xx_CAN_USE_CAN2
if (&CAND2 == canp) {
LPC_SC->PCONP &= ~(1UL << 14);
}
#endif
#if CAN_USE_SLEEP_MODE
nvicDisableVector(CANActivity_IRQn);
#endif /* CAN_USE_SLEEP_MODE */
}
}
/**
* @brief Determines whether a frame can be transmitted.
*
* @param[in] canp pointer to the @p CANDriver object
* @param[in] mailbox mailbox number, @p CAN_ANY_MAILBOX for any mailbox
*
* @return The queue space availability.
* @retval FALSE no space in the transmit queue.
* @retval TRUE transmit slot available.
*
* @notapi
*/
bool_t can_lld_is_tx_empty(CANDriver *canp, canmbx_t mailbox) {
switch (mailbox) {
case CAN_ANY_MAILBOX:
return ((canp->can->SR & (CANSR_TBS1 | CANSR_TBS2 | CANSR_TBS3)) != 0);
case 1:
return (canp->can->SR & CANSR_TBS1) != 0;
case 2:
return (canp->can->SR & CANSR_TBS2) != 0;
case 3:
return (canp->can->SR & CANSR_TBS3) != 0;
default:
return FALSE;
}
}
/**
* @brief Inserts a frame into the transmit queue.
*
* @param[in] canp pointer to the @p CANDriver object
* @param[in] ctfp pointer to the CAN frame to be transmitted
* @param[in] mailbox mailbox number, @p CAN_ANY_MAILBOX for any mailbox
*
* @notapi
*/
void can_lld_transmit(CANDriver *canp,
canmbx_t mailbox,
const CANTxFrame *ctfp) {
volatile uint32_t * tfi;
uint32_t tbs_n;
uint32_t sr;
tbs_n = mailbox;
if (mailbox == CAN_ANY_MAILBOX) {
sr = canp->can->SR;
if (sr & CANSR_TBS1) {
tbs_n = 1;
}
else if (sr & CANSR_TBS2) {
tbs_n = 2;
}
else if (sr & CANSR_TBS3) {
tbs_n = 3;
}
else {
return;
}
}
/* Pointer to a free transmission mailbox.*/
switch (tbs_n) {
case 1:
tfi = &canp->can->TFI1;
break;
case 2:
tfi = &canp->can->TFI2;
break;
case 3:
tfi = &canp->can->TFI3;
break;
default:
return;
}
/* Preparing the message.*/
* tfi = ((uint32_t)ctfp->IDE << 31) | ((uint32_t)ctfp->RTR << 30) |
(((uint32_t)ctfp->DLC) << 16); /* CAN Transmit Frame Information Register. */
if (ctfp->IDE)
*(tfi + 1) = ctfp->EID; /* CAN Transmit Identifier register 29-bit. */
else
*(tfi + 1) = ctfp->SID; /* CAN Transmit Identifier register 11-bit. */
*(tfi + 2) = ctfp->data32[0]; /* CAN Transmit Data Register A. */
*(tfi + 3) = ctfp->data32[1]; /* CAN Transmit Data Register B. */
#if LPC17xx_CAN_USE_LOCAL_SELF_TEST
canp->can->CMR = (1UL << (4 + tbs_n)) | CANCMR_SRR;
#else
canp->can->CMR = (1UL << (4 + tbs_n)) | CANCMR_TR;
#endif
}
/**
* @brief Determines whether a frame has been received.
*
* @param[in] canp pointer to the @p CANDriver object
* @param[in] mailbox mailbox number, @p CAN_ANY_MAILBOX for any mailbox
*
* @return The queue space availability.
* @retval FALSE no space in the transmit queue.
* @retval TRUE transmit slot available.
*
* @notapi
*/
bool_t can_lld_is_rx_nonempty(CANDriver *canp, canmbx_t mailbox) {
switch (mailbox) {
case CAN_ANY_MAILBOX:
case 1:
return ((canp->can->GSR & CANGSR_RBS) != 0);
default:
return FALSE;
}
}
/**
* @brief Receives a frame from the input queue.
*
* @param[in] canp pointer to the @p CANDriver object
* @param[in] mailbox mailbox number, @p CAN_ANY_MAILBOX for any mailbox
* @param[out] crfp pointer to the buffer where the CAN frame is copied
*
* @notapi
*/
void can_lld_receive(CANDriver *canp,
canmbx_t mailbox,
CANRxFrame *crfp) {
uint32_t rfs, rid;
switch (mailbox) {
case CAN_ANY_MAILBOX:
case 1:
/* Fetches the message.*/
rfs = canp->can->RFS;
rid = canp->can->RID;
crfp->data32[0] = canp->can->RDA;
crfp->data32[1] = canp->can->RDB;
/* Releases the mailbox.*/
canp->can->CMR = CANCMR_RRB;
/* Re-enables the interrupt in order to generate
events again. */
canp->can->IER |= CANIER_RIE;
break;
default:
/* Should not happen, do nothing.*/
return;
}
/* Decodes the various fields in the RX frame.*/
crfp->RTR = (rfs & CANRFS_RTR) >> 30;
crfp->IDE = (rfs & CANRFS_FF) >> 31;
if (crfp->IDE) {
crfp->EID = rid;
}
else {
crfp->SID = rid;
}
crfp->DLC = (rfs & CANRFS_DLC) >> 16;
crfp->IDF = (uint16_t)(rfs & CANRFS_ID);
}
#if CAN_USE_SLEEP_MODE || defined(__DOXYGEN__)
/**
* @brief Enters the sleep mode.
*
* @param[in] canp pointer to the @p CANDriver object
*
* @notapi
*/
void can_lld_sleep(CANDriver *canp) {
canp->can->MOD |= CANMOD_SM;
}
/**
* @brief Enforces leaving the sleep mode.
*
* @param[in] canp pointer to the @p CANDriver object
*
* @notapi
*/
void can_lld_wakeup(CANDriver *canp) {
uint32_t reg_val;
#if LPC17xx_CAN_USE_CAN1
if (&CAND1 == canp) {
reg_val = (1UL << 1);
}
#endif
#if LPC17xx_CAN_USE_CAN2
if (&CAND2 == canp) {
reg_val = (1UL << 2);
}
#endif
LPC_SC->CANSLEEPCLR = reg_val;
canp->can->MOD &= ~CANMOD_SM;
LPC_SC->CANWAKEFLAGS = reg_val;
}
#endif /* CAN_USE_SLEEP_MODE */
#if LPC17xx_CAN_USE_FILTER
void canSetFilter(const CANFilterConfig *cfc) {
can_lld_set_filter(cfc);
}
#endif
#endif /* HAL_USE_CAN */
/** @} */
Reference in New Issue View Git Blame Copy Permalink