Add CAN driver for LPC17xx.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@6743 35acf78f-673a-0410-8e92-d51de3d6d3f4

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 */
+
+/** @} */