11CXX_rom_can.c

Go to the documentation of this file.

 
#ifdef TARGET_LPC11Cxx
 
#include "11CXX_rom_driver_CAN.h"
#include "can.h"
 
typedef struct _ROM {
   const unsigned p_usbd;
   const unsigned p_clib;
   const CAND *pCAND;
} ROM;
 
ROM **rom = (ROM **)0x1fff1ff8;
 
static const int RX_MSG_OBJ_NUM = 1;
static const int TX_MSG_OBJ_NUM = 2;
 
typedef struct lpc11crom_can_priv
{
    CanPriv canPriv; 
    char txPending; 
} LPC11CRomCanPriv;
 
static LPC11CRomCanPriv can_private[1] =
{
    {
        .txPending = 0
    }
};
 
void CAN_IRQHandler (void){
  (*rom)->pCAND->isr();
}
 
static int lpc11crom_can_init(devtab_t *dev);
static void ignore_dev_function(devtab_t *dev);
static void lpc11crom_can_tx_msg(devtab_t *dev);
 
static void CAN_rx(uint8_t msg_obj_num);
static void CAN_tx(uint8_t msg_obj_num);
static void CAN_error(uint32_t error_info);
 
static const CAN_CALLBACKS callbacks = {
   CAN_rx,
   CAN_tx,
   CAN_error,
   NULL,
   NULL,
   NULL,
   NULL,
   NULL,
};
 
 
const uint32_t ClkInitTable125[2] = {
    0x00000000UL, // CANCLKDIV
    0x00001C57UL  // CAN_BTR
};
 
static const uint32_t ClkInitTable250[2] = {
    0x00000000UL, // CANCLKDIV
    0x00001C4BUL  // CAN_BTR
};
 
static int lpc11crom_can_init(devtab_t *dev)
{
    /* Initialize the CAN controller */
    (*rom)->pCAND->init_can((uint32_t*) &ClkInitTable250[0], 1);
    /* Configure the CAN callback functions */
    (*rom)->pCAND->config_calb((CAN_CALLBACKS*) &callbacks);
 
    /* Enable the CAN Interrupt */
    NVIC_EnableIRQ(CAN_IRQn);
 
    /* Configures msgobj 1 to receive all extended frames. */
    CAN_MSG_OBJ msg_obj;
    msg_obj.msgobj = RX_MSG_OBJ_NUM;
    msg_obj.mode_id = 0x000 | CAN_MSGOBJ_EXT;
    msg_obj.mask = 0x000;
    msg_obj.dlc = 0x000;
    (*rom)->pCAND->config_rxmsgobj(&msg_obj);
 
    LPC11CRomCanPriv *priv = (LPC11CRomCanPriv*)dev->priv;
    priv->canPriv.enable = ignore_dev_function;
    priv->canPriv.disable = ignore_dev_function;
    priv->canPriv.tx_msg = lpc11crom_can_tx_msg;
    return can_init(dev);
}
 
static void ignore_dev_function(devtab_t *dev) {}
 
static void send_frame(struct can_frame *can_frame)
{
    CAN_MSG_OBJ msg_obj;
    msg_obj.msgobj  = TX_MSG_OBJ_NUM;
    msg_obj.mode_id = can_frame->can_id |
        (can_frame->can_rtr ? CAN_MSGOBJ_RTR : 0) |
        (can_frame->can_eff ? CAN_MSGOBJ_EXT : 0);
    msg_obj.mask    = 0x0;
    msg_obj.dlc     = can_frame->can_dlc;
    memcpy(msg_obj.data, can_frame->data, can_frame->can_dlc);
    (*rom)->pCAND->can_transmit(&msg_obj);
}
 
static void lpc11crom_can_tx_msg(devtab_t *dev)
{
    LPC11CRomCanPriv *priv = (LPC11CRomCanPriv*)dev->priv;
    if (priv->txPending) return;
 
    struct can_frame can_frame;
    taskENTER_CRITICAL();
    if (os_mq_timedreceive(priv->canPriv.txQ, &can_frame, 0) != OS_MQ_NONE)
    {
        return;
    }
    priv->txPending = 1;
    send_frame(&can_frame);
    taskEXIT_CRITICAL();
}
 
void CAN_rx(uint8_t msg_obj_num)
{
    CAN_MSG_OBJ msg_obj;
    /* Determine which CAN message has been received */
    msg_obj.msgobj = msg_obj_num;
 
    /* Now load up the msg_obj structure with the CAN message */
    (*rom)->pCAND->can_receive(&msg_obj);
 
    struct can_frame can_frame;
    can_frame.can_id = msg_obj.mode_id & ((1<<30) - 1);
    can_frame.can_rtr = (msg_obj.mode_id & CAN_MSGOBJ_RTR) ? 1 : 0;
    can_frame.can_eff = (msg_obj.mode_id & CAN_MSGOBJ_EXT) ? 1 : 0;
    can_frame.can_err = 0;
    can_frame.can_dlc = msg_obj.dlc;
    memcpy(can_frame.data, msg_obj.data, msg_obj.dlc);
    int woken = 0;
    if (os_mq_send_from_isr(can_private[0].canPriv.rxQ, &can_frame, &woken)
        == OS_MQ_FULL)
    {
        can_private[0].canPriv.overrunCount++;
    }
    if (woken)
    {
      portYIELD();
    }
}
 
void CAN_tx(uint8_t msg_obj_num){
    // If we don't know the msg object number, let's not do anything.
    if (msg_obj_num != TX_MSG_OBJ_NUM) return;
    struct can_frame can_frame;
    int woken = 0;
    if (os_mq_receive_from_isr(can_private[0].canPriv.txQ, &can_frame, &woken)
        != OS_MQ_NONE)
    {
        can_private[0].txPending = 0;
        return;
    }
    send_frame(&can_frame);
 
    if (woken)
    {
      portYIELD();
    }
}
 
void CAN_error(uint32_t error_info)
{
    return;
}
 
static CAN_DEVTAB_ENTRY(can0, "/dev/can0", lpc11crom_can_init, &can_private[0]);
 
#else
#error You need to define TARGET_LPC11Cxx if you want to compiple its rom driver.
#endif