netx_drv_canctrl.c

Go to the documentation of this file.

/**************************************************************************/
#include "netx_drv_user_conf.h"
#ifdef DRV_CANCTRL_MODULE_ENABLED

/*****************************************************************************/
/*  Includes                                                                 */
/*****************************************************************************/
#ifdef DRV_DEVICE_NETX_90_MPW
#error "The MPW chip is no longer supported!"
#else
#ifdef DRV_DEVICE_NETX_90
#include "regdef/netx90_app/regdef_netx90_arm_app.h"
#else
#error "No chip Selected!"
#endif
#endif
#include "netx_drv_canctrl.h"

#define HW_PTR_CANCTRL(var)             static NX90_CANCTRL_AREA_T*              const var[] = \
  {\
    (NX90_CANCTRL_AREA_T*) Addr_NX90_can_ctrl0_app,\
    (NX90_CANCTRL_AREA_T*) Addr_NX90_can_ctrl1_app\
  };

#ifndef _HW_CONCAT
#define _HW_CONCAT(a,b) a ## b
#define HW_MSK(bf)         _HW_CONCAT(MSK_NX90_, bf)
#define HW_SRT(bf)         _HW_CONCAT(SRT_NX90_, bf)
#define HW_DFLT_BF_VAL(bf) _HW_CONCAT(DFLT_BF_VAL_NX90_, bf)
#define HW_DFLT_VAL(reg)   _HW_CONCAT(DFLT_VAL_NX90_, reg)
#define HW_REGADR(reg)     _HW_CONCAT(Adr_NX90_, reg)
#define HW_AREAADR(area)   _HW_CONCAT(Addr_NX90_, area)
#define HW_TYPE(area)      _HW_CONCAT(NX90_, area)
#endif

#define HAL_CANCTRL_CNT 2

#ifndef HALDEF
#define HALDEF(name) HALDEC(name)
#endif

/*****************************************************************************/
/*  Variables                                                                */
/*****************************************************************************/
HW_PTR_CANCTRL(s_aptCanCtrl)

/*****************************************************************************/
/*  Functions                                                                */
/*****************************************************************************/

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_EnterResetMode)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  s_aptCanCtrl[uiInst]->ulCanctrl_mode |= HW_MSK(canctrl_mode_reset_mode);
  s_aptCanCtrl[uiInst]->ulCanctrl_mode_control = HW_MSK(canctrl_mode_control_mode);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_LeaveResetMode)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  s_aptCanCtrl[uiInst]->ulCanctrl_mode_control = HW_MSK(canctrl_mode_control_mode);
  s_aptCanCtrl[uiInst]->ulCanctrl_mode &= ~HW_MSK(canctrl_mode_reset_mode);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SetBaudrate)( unsigned int uiInst, uint32_t ulBaudrate, unsigned int uOversampling )
{
  uint32_t ulPrescaler = 0;
  uint32_t ulTseg1 = 0;
  uint32_t ulTseg2 = 0;

  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  switch(ulBaudrate)
  {
  case DRV_CANCTRL_BAUDRATE_1000K: ulPrescaler = 10; ulTseg1 = 7; break;
  case DRV_CANCTRL_BAUDRATE_800K: ulPrescaler = 25; ulTseg1 = 2; break;
  case DRV_CANCTRL_BAUDRATE_500K: ulPrescaler = 20; ulTseg1 = 7; break;
  case DRV_CANCTRL_BAUDRATE_250K: ulPrescaler = 40; ulTseg1 = 7; break;
  case DRV_CANCTRL_BAUDRATE_125K: ulPrescaler = 80; ulTseg1 = 7; break;
  case DRV_CANCTRL_BAUDRATE_50K: ulPrescaler = 200; ulTseg1 = 7; break;
  case DRV_CANCTRL_BAUDRATE_20K: ulPrescaler = 500; ulTseg1 = 7; break;
  case DRV_CANCTRL_BAUDRATE_10K: ulPrescaler = 500; ulTseg1 = 16; ulTseg2 = 1; break;
  default: return DRV_CANCTRL_RESULT_INVAL_PARAM;
  }

  s_aptCanCtrl[uiInst]->aulCanctrl_bus_timing[0] = ulPrescaler << HW_SRT(canctrl_bus_timing0_prescaler);
  s_aptCanCtrl[uiInst]->aulCanctrl_bus_timing[1] = (ulTseg1 << HW_SRT(canctrl_bus_timing1_tseg1))
                                         |(ulTseg2 << HW_SRT(canctrl_bus_timing1_tseg2))
                                         |((uint32_t)uOversampling << HW_SRT(canctrl_bus_timing1_oversampling));
  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SetSingleAcceptanceFilter)( unsigned int uiInst, DRV_CANCTRL_SINGLEFILTER_T* ptFilter )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->aulCanctrl_data[3] = ptFilter->ulAcceptanceCode & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[2] = (ptFilter->ulAcceptanceCode >> 8) & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[1] = (ptFilter->ulAcceptanceCode >> 16) & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[0] = (ptFilter->ulAcceptanceCode >> 24) & 0xff;
#if defined(__NETX51)
  /* Note: In netX51/52 there is a failure when writing to Acceptance Mask 0 and 1.
     The write content of Acceptance Mask 0 goes correctly into register Acceptance Mask 0 and additionally abnormal into register Acceptance Mask 1.
     Acceptance Mask 1 is not writable individually.
     Because of this bug the content of Acceptance Mask 0 and Acceptance Mask 1 must be the same and that leads to restricted filter possibilities.
     Furthermore the locations of Acceptance Mask 2/3 changed to Registers Data 5 and Data 6.
  */
  s_aptCanCtrl[uiInst]->aulCanctrl_data[6] = ptFilter->ulAcceptanceMask & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[5] = (ptFilter->ulAcceptanceMask >> 8) & 0xff;
  /*s_aptCanCtrl[uiInst]->aulCanctrl_data[4] = (ptFilter->ulAcceptanceMask >> 16) & 0xff; */ /* disabled: bug!!! */
  s_aptCanCtrl[uiInst]->aulCanctrl_data[4] = (ptFilter->ulAcceptanceMask >> 24) & 0xff;
#else
  s_aptCanCtrl[uiInst]->aulCanctrl_data[7] = ptFilter->ulAcceptanceMask & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[6] = (ptFilter->ulAcceptanceMask >> 8) & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[5] = (ptFilter->ulAcceptanceMask >> 16) & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[4] = (ptFilter->ulAcceptanceMask >> 24) & 0xff;
#endif
  s_aptCanCtrl[uiInst]->ulCanctrl_mode |= HW_MSK(canctrl_mode_acceptance_mode);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_GetSingleAcceptanceFilter)( unsigned int uiInst, DRV_CANCTRL_SINGLEFILTER_T* ptFilter )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)))
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_acceptance_mode)))
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  ptFilter->ulAcceptanceCode = (s_aptCanCtrl[uiInst]->aulCanctrl_data[3] << 0)
                              |(s_aptCanCtrl[uiInst]->aulCanctrl_data[2] << 8)
                              |(s_aptCanCtrl[uiInst]->aulCanctrl_data[1] << 16)
                              |(s_aptCanCtrl[uiInst]->aulCanctrl_data[0] << 24);

  ptFilter->ulAcceptanceMask = (s_aptCanCtrl[uiInst]->aulCanctrl_data[7] << 0)
                              |(s_aptCanCtrl[uiInst]->aulCanctrl_data[6] << 8)
                              |(s_aptCanCtrl[uiInst]->aulCanctrl_data[5] << 16)
                              |(s_aptCanCtrl[uiInst]->aulCanctrl_data[4] << 24);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SetDualAcceptanceFilter)( unsigned int uiInst, DRV_CANCTRL_DUALFILTER_T* ptFilter )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->aulCanctrl_data[1] = (uint32_t)ptFilter->usAcceptanceCode0 & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[0] = ((uint32_t)ptFilter->usAcceptanceCode0 >> 8) & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[3] = (uint32_t)ptFilter->usAcceptanceCode1 & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[2] = ((uint32_t)ptFilter->usAcceptanceCode1 >> 8) & 0xff;
#if defined(__NETX51)
  /* Note: In netX51/52 there is a failure when writing to Acceptance Mask 0 and 1.
     The write content of Acceptance Mask 0 goes correctly into register Acceptance Mask 0 and additionally abnormal into register Acceptance Mask 1.
     Acceptance Mask 1 is not writable individually.
     Because of this bug the content of Acceptance Mask 0 and Acceptance Mask 1 must be the same and that leads to restricted filter possibilities.
     Furthermore the locations of Acceptance Mask 2/3 changed to Registers Data 5 and Data 6.
  */
  s_aptCanCtrl[uiInst]->aulCanctrl_data[4] = (uint32_t)ptFilter->usAcceptanceMask0 & 0xff;
  /*s_aptCanCtrl[uiInst]->aulCanctrl_data[4] = ((uint32_t)ptFilter->usAcceptanceMask0 >> 8) & 0xff; */ /* disabled: bug!!! */
  s_aptCanCtrl[uiInst]->aulCanctrl_data[6] = (uint32_t)ptFilter->usAcceptanceMask1 & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[5] = ((uint32_t)ptFilter->usAcceptanceMask1 >> 8) & 0xff;
#else
  s_aptCanCtrl[uiInst]->aulCanctrl_data[5] = (uint32_t)ptFilter->usAcceptanceMask0 & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[4] = ((uint32_t)ptFilter->usAcceptanceMask0 >> 8) & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[7] = (uint32_t)ptFilter->usAcceptanceMask1 & 0xff;
  s_aptCanCtrl[uiInst]->aulCanctrl_data[6] = ((uint32_t)ptFilter->usAcceptanceMask1 >> 8) & 0xff;
#endif
  s_aptCanCtrl[uiInst]->ulCanctrl_mode &= ~HW_MSK(canctrl_mode_acceptance_mode);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_GetDualAcceptanceFilter)( unsigned int uiInst, DRV_CANCTRL_DUALFILTER_T* ptFilter )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;
  
  if( 0 != (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_acceptance_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  ptFilter->usAcceptanceCode0 = (uint16_t)(s_aptCanCtrl[uiInst]->aulCanctrl_data[1] << 0)
                               |(uint16_t)(s_aptCanCtrl[uiInst]->aulCanctrl_data[0] << 8);

  ptFilter->usAcceptanceCode1 = (uint16_t)(s_aptCanCtrl[uiInst]->aulCanctrl_data[3] << 0)
                               |(uint16_t)(s_aptCanCtrl[uiInst]->aulCanctrl_data[2] << 8);

  ptFilter->usAcceptanceMask0 = (uint16_t)(s_aptCanCtrl[uiInst]->aulCanctrl_data[5] << 0)
                               |(uint16_t)(s_aptCanCtrl[uiInst]->aulCanctrl_data[4] << 8);

  ptFilter->usAcceptanceMask1 = (uint16_t)(s_aptCanCtrl[uiInst]->aulCanctrl_data[7] << 0)
                               |(uint16_t)(s_aptCanCtrl[uiInst]->aulCanctrl_data[6] << 8);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_EnterListenMode)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->ulCanctrl_mode |= HW_MSK(canctrl_mode_listen_mode);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_LeaveListenMode)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->ulCanctrl_mode &= ~HW_MSK(canctrl_mode_listen_mode);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_EnterSelftestMode)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->ulCanctrl_mode |= HW_MSK(canctrl_mode_selftest);

  return DRV_CANCTRL_RESULT_OKAY;
}


/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_LeaveSelftestMode)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->ulCanctrl_mode &= ~HW_MSK(canctrl_mode_selftest);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SendMessage)( unsigned int uiInst, DRV_CANCTRL_MESSAGE_T* ptMessage, bool fSingleShot, bool fSelfRx )
{
  uint32_t  ulCmd;
  unsigned int uLength, uIdx, uDataPtr;

  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 != (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_status & HW_MSK(canctrl_status_tx_buf_status)) )
    return DRV_CANCTRL_RESULT_TX_BUFFER_NOT_FREE;

  /* build message */
  s_aptCanCtrl[uiInst]->aulCanctrl_data[0] = ((uint32_t)ptMessage->uFrameFormat << 7)
                                            |((uint32_t)ptMessage->uRtr << 6)
                                            |(uint32_t)ptMessage->uDlc;

  if( 0 == ptMessage->uFrameFormat )
  {
    /* Standard ID */
    s_aptCanCtrl[uiInst]->aulCanctrl_data[1] = (ptMessage->ulIdentifier >> 3) & 0xff;
    s_aptCanCtrl[uiInst]->aulCanctrl_data[2] = (ptMessage->ulIdentifier << 5) & 0xff;
    uDataPtr = 3;
  }
  else
  {
    /* Extended ID */
    s_aptCanCtrl[uiInst]->aulCanctrl_data[1] = (ptMessage->ulIdentifier >> 21) & 0xff;
    s_aptCanCtrl[uiInst]->aulCanctrl_data[2] = (ptMessage->ulIdentifier >> 13) & 0xff;
    s_aptCanCtrl[uiInst]->aulCanctrl_data[3] = (ptMessage->ulIdentifier >> 5)  & 0xff;
    s_aptCanCtrl[uiInst]->aulCanctrl_data[4] = (ptMessage->ulIdentifier << 3)  & 0xff;
    uDataPtr = 5;
  }

  if( 0 == ptMessage->uRtr )
  {
    /* Data frame */
    uLength = ptMessage->uDlc;
    if( uLength > 8 ) uLength = 8;

    /* put transmit data to CAN controller */
    for( uIdx = 0; uIdx < uLength; ++uIdx ) {
      s_aptCanCtrl[uiInst]->aulCanctrl_data[uDataPtr + uIdx] = ptMessage->abData[uIdx];
    }
  }

  /* send message */
  if( !fSelfRx )
  {
    ulCmd = HW_MSK(canctrl_command_tx_request);

    /* Setting the command bits tx_request and abort_tx simultaneously results in sending the transmit message once */
    if( fSingleShot ) {
      ulCmd |= HW_MSK(canctrl_command_abort_tx);
    }
  }
  else {
    ulCmd = HW_MSK(canctrl_command_self_rx_request);
  }

  s_aptCanCtrl[uiInst]->ulCanctrl_command = ulCmd;

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_AbortMessage)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 != (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->ulCanctrl_command = HW_MSK(canctrl_command_abort_tx);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_ReceiveMessage)( unsigned int uiInst, DRV_CANCTRL_MESSAGE_T* ptMessage )
{
  unsigned int uDataPtr, uLength, uIdx;

  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  /* check that we are operational */
  if( 0 != (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  /* check that message available */
  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_status & HW_MSK(canctrl_status_rx_buf_status)) )
    return DRV_CANCTRL_RESULT_NO_MESSAGE_AVAILABLE;

  /* check for overrun */
  if( 0 != (s_aptCanCtrl[uiInst]->ulCanctrl_status & HW_MSK(canctrl_status_overrun)) ) {
    /* clear overrun condition */
    s_aptCanCtrl[uiInst]->ulCanctrl_command = HW_MSK(canctrl_command_clr_overrun)
                                    |HW_MSK(canctrl_command_release_rx_buf);
    return DRV_CANCTRL_RESULT_MESSAGE_DROPPED;
  }

  /* get message type */
  ptMessage->uFrameFormat = (s_aptCanCtrl[uiInst]->aulCanctrl_data[0] >> 7) & 0x1;

  /* get RTR bit */
  ptMessage->uRtr = (s_aptCanCtrl[uiInst]->aulCanctrl_data[0] >> 6) & 0x1;
  if( 0 == ptMessage->uFrameFormat ) {
    /* Standard ID */
    ptMessage->ulIdentifier = ( (s_aptCanCtrl[uiInst]->aulCanctrl_data[1] << 24)
                             | ((s_aptCanCtrl[uiInst]->aulCanctrl_data[2] & 0xef) << 16)
                              ) >> 21;
    uDataPtr = 3;
  }
  else {
    /* Extended ID */
    ptMessage->ulIdentifier = ( (s_aptCanCtrl[uiInst]->aulCanctrl_data[1] << 24)
                               |(s_aptCanCtrl[uiInst]->aulCanctrl_data[2] << 16)
                               |(s_aptCanCtrl[uiInst]->aulCanctrl_data[3] << 8)
                               |(s_aptCanCtrl[uiInst]->aulCanctrl_data[4] << 0)
                              ) >> 3;
    uDataPtr = 5;
  }

  /* get DLC */
  ptMessage->uDlc = (unsigned int)(s_aptCanCtrl[uiInst]->aulCanctrl_data[0] & 0xf);

  if( 0 == ptMessage->uRtr )
  {
    /* Data frame */
    uLength = ptMessage->uDlc;
    if( uLength > 8 ) uLength = 8;

    /* get data bytes */
    for( uIdx = 0; uIdx < uLength; ++uIdx )
      ptMessage->abData[uIdx] = (uint8_t)s_aptCanCtrl[uiInst]->aulCanctrl_data[uDataPtr + uIdx];
  }

  /* release buffer */
  s_aptCanCtrl[uiInst]->ulCanctrl_command = HW_MSK(canctrl_command_release_rx_buf);

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetRxMessageCnt)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_rx_message_cnt;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetMode)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_mode;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetStatus)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_status;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetAndClearIrqStatus)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_irq;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SetIrqMask)( unsigned int uiInst, uint32_t ulIrqMask )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  s_aptCanCtrl[uiInst]->ulCanctrl_irq_en = ulIrqMask;

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetIrqMask)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_irq_en;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetAndClearArblostStatus)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_arb_lost_capture;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetAndClearErrorCode)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_err_code_capture;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SetWarningLimit)( unsigned int uiInst, uint32_t ulLimit )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->ulCanctrl_err_warning_limit = ulLimit;

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetWarningLimit)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_err_warning_limit;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SetRxErrorCnt)( unsigned int uiInst, uint32_t ulCnt )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->ulCanctrl_rx_error_cnt = ulCnt;

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetRxErrorCnt)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_rx_error_cnt;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SetTxErrorCnt)( unsigned int uiInst, uint32_t ulCnt )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  s_aptCanCtrl[uiInst]->ulCanctrl_tx_error_cnt = ulCnt;

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
uint32_t HALDEF(CanCtrl_GetTxErrorCnt)( unsigned int uiInst )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return 0;

  return s_aptCanCtrl[uiInst]->ulCanctrl_tx_error_cnt;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_SetPrm)( unsigned int uiInst, DRV_CANCTRL_PRM_E ePrmID, uint32_t ulPrmVal )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  switch( ePrmID )
  {
    case DRV_CANCTRL_PRM_IRQEN:             s_aptCanCtrl[uiInst]->ulCanctrl_irq_en = ulPrmVal; break;
    case DRV_CANCTRL_PRM_BT0:               s_aptCanCtrl[uiInst]->aulCanctrl_bus_timing[0] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_BT1:               s_aptCanCtrl[uiInst]->aulCanctrl_bus_timing[1] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ERR_WARNING_LIMIT: s_aptCanCtrl[uiInst]->ulCanctrl_err_warning_limit = ulPrmVal; break;
    case DRV_CANCTRL_PRM_RXERR_CNT:         s_aptCanCtrl[uiInst]->ulCanctrl_rx_error_cnt = ulPrmVal; break;
    case DRV_CANCTRL_PRM_TXERR_CNT:         s_aptCanCtrl[uiInst]->ulCanctrl_tx_error_cnt = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_CODE0:  s_aptCanCtrl[uiInst]->aulCanctrl_data[0] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_CODE1:  s_aptCanCtrl[uiInst]->aulCanctrl_data[1] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_CODE2:  s_aptCanCtrl[uiInst]->aulCanctrl_data[2] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_CODE3:  s_aptCanCtrl[uiInst]->aulCanctrl_data[3] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_MASK0:  s_aptCanCtrl[uiInst]->aulCanctrl_data[4] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_MASK1:  s_aptCanCtrl[uiInst]->aulCanctrl_data[5] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_MASK2:  s_aptCanCtrl[uiInst]->aulCanctrl_data[6] = ulPrmVal; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_MASK3:  s_aptCanCtrl[uiInst]->aulCanctrl_data[7] = ulPrmVal; break;
    /* Default */
    default:
      return DRV_CANCTRL_RESULT_INVAL_PARAM;
  } /* end switch */

  return DRV_CANCTRL_RESULT_OKAY;
}

/*****************************************************************************/
/*****************************************************************************/
DRV_CANCTRL_RESULT HALDEF(CanCtrl_GetPrm)( unsigned int uiInst, DRV_CANCTRL_PRM_E ePrmID, uint32_t* pulPrmVal )
{
  if( uiInst >= HAL_CANCTRL_CNT )
    return DRV_CANCTRL_RESULT_INVAL_PARAM;

  if( 0 == (s_aptCanCtrl[uiInst]->ulCanctrl_mode & HW_MSK(canctrl_mode_reset_mode)) )
    return DRV_CANCTRL_RESULT_WRONG_MODE;

  switch( ePrmID )
  {
    case DRV_CANCTRL_PRM_IRQEN:             *pulPrmVal = s_aptCanCtrl[uiInst]->ulCanctrl_irq_en; break;
    case DRV_CANCTRL_PRM_BT0:               *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_bus_timing[0]; break;
    case DRV_CANCTRL_PRM_BT1:               *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_bus_timing[1]; break;
    case DRV_CANCTRL_PRM_ERR_WARNING_LIMIT: *pulPrmVal = s_aptCanCtrl[uiInst]->ulCanctrl_err_warning_limit; break;
    case DRV_CANCTRL_PRM_RXERR_CNT:         *pulPrmVal = s_aptCanCtrl[uiInst]->ulCanctrl_rx_error_cnt; break;
    case DRV_CANCTRL_PRM_TXERR_CNT:         *pulPrmVal = s_aptCanCtrl[uiInst]->ulCanctrl_tx_error_cnt; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_CODE0:  *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_data[0]; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_CODE1:  *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_data[1]; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_CODE2:  *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_data[2]; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_CODE3:  *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_data[3]; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_MASK0:  *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_data[4]; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_MASK1:  *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_data[5]; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_MASK2:  *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_data[6]; break;
    case DRV_CANCTRL_PRM_ACCEPTANCE_MASK3:  *pulPrmVal = s_aptCanCtrl[uiInst]->aulCanctrl_data[7]; break;

    /* Default */
    default:
      return DRV_CANCTRL_RESULT_INVAL_PARAM;
  } /* end switch */

  return DRV_CANCTRL_RESULT_OKAY;
}
/* End of group CANCTRL */


#endif /* DRV_CANCTRL_MODULE_DISABLED */