aboutsummaryrefslogtreecommitdiffstats
path: root/os/hal/platforms/LPC17xx/can_lld.c
diff options
context:
space:
mode:
Diffstat (limited to 'os/hal/platforms/LPC17xx/can_lld.c')
-rw-r--r--os/hal/platforms/LPC17xx/can_lld.c657
1 files changed, 657 insertions, 0 deletions
diff --git a/os/hal/platforms/LPC17xx/can_lld.c b/os/hal/platforms/LPC17xx/can_lld.c
new file mode 100644
index 000000000..1e789d9b9
--- /dev/null
+++ b/os/hal/platforms/LPC17xx/can_lld.c
@@ -0,0 +1,657 @@
+/*
+ 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 */
+
+/** @} */
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-10 11:24:17 +0000