can_drv.c

CAN DRIVER FOR FREESCALE

       canuint8       ucBtReg0;            /* Bit-Timing-Register  0        */
      canuint8       ucBtReg1;            /* Bit-Timing-Register  1        */
#else
      canuint16      uiBtReg;             /* Bit-Timing-Register           */
#endif
    } in;                                /* internal 82527 (16xCR) -------*/
  } u;
  canuint8       ucGlobalMaskStdHigh;       /* Global-Mask                   */
  canuint8       ucGlobalMaskStdLow;        /* Global-Mask                   */
  canuint32      ulGlobalMaskExt;           /* Global-Mask                   */
  canuint8       ucMsg15MaskHigh;           /* Global-Mask                   */
  canuint8       ucMsg15MaskLow;            /* Global-Mask                   */
  canuint16      uiMsg15MaskExt;            /* Global-Mask                   */

  CanMsgObj  sMsg1Obj;                   /* Message Object                */
  CanMsgObj  sMsg2Obj;                   /* Message Object                */
  CanMsgObj  sMsg3Obj;                   /* Message Object                */
  CanMsgObj  sMsg4Obj;                   /* Message Object                */
  CanMsgObj  sMsg5Obj;                   /* Message Object                */
  CanMsgObj  sMsg6Obj;                   /* Message Object                */
  CanMsgObj  sMsg7Obj;                   /* Message Object                */
  CanMsgObj  sMsg8Obj;                   /* Message Object                */
  CanMsgObj  sMsg9Obj;                   /* Message Object                */
  CanMsgObj  sMsg10Obj;                  /* Message Object                */
  CanMsgObj  sMsg11Obj;                  /* Message Object                */
  CanMsgObj  sMsg12Obj;                  /* Message Object                */
  CanMsgObj  sMsg13Obj;                  /* Message Object                */
  CanMsgObj  sMsg14Obj;                  /* Message Object                */
  CanMsgObj  sMsg15Obj;                  /* Message Object                */

} Can82527AddrMapNamed;


typedef volatile struct sCan82527AddrMapIndexed
{
#if defined( C_COMP_TASKING_C16x )
  #pragma align nb=b /* near data = byte */
#endif
  canuint8            fdum1;
  canuint8            fdum2;
  canuint8            fdum3;
  canuint8            fdum4;
  canuint16           fdum5;
  canuint16           fdum6;
  canuint32           fdum7;
  canuint32           fdum8;
  struct s
  {
    CanMsgObj       sMsgObj;             /* message objects               */
  } obj[15];
} Can82527AddrMapIndexed;

typedef volatile struct sCan82527AddrMap
{
#if defined( C_COMP_TASKING_C16x )
  #pragma align nb=b /* near data = byte */
#endif
  union
  {
    Can82527AddrMapIndexed indexed;
    Can82527AddrMapNamed   named;
  } u;
} Can82527AddrMap;

#if defined( C_COMP_TASKING_C16x )
  extern Can82527AddrMap  Can82527;
  #pragma align nb=w  /* for further usage: near data = word */
#endif

#if defined( C_COMP_KEIL_C5X5C )
 #if defined( C_CAN_CHIP_PDATA )
  // pdata-Segment has to be located on address 0x7F00
  // XPAGE-register hat to be initialized corrctly before CAN access
  static Can82527AddrMap pdata Can82527;
 #elif defined( C_CAN_CHIP_XDATA )
  static Can82527AddrMap xdata Can82527 _at_ 0xF700;
 #endif
#endif



#endif /* #if defined(C_COMP_TASKING_C16x) || defined(C_COMP_KEIL_C5X5C) */



#if defined( C_COMP_KEIL_C16x )
 extern Can82527AddrMap idata Can82527;
#endif

#if defined( C_COMP_TASKING_C16x )
 #pragma class nb=CAN82527ADDRESS0
 #pragma noclear
        Can82527AddrMap       Can82527;
 #pragma default_attributes
#endif


/***************************************************************************/
/*  External Declarations                                                  */
/***************************************************************************/

/****************************************************************************/
/* Constants                                                                */
/****************************************************************************/
// Global constants with CAN driver main and subversion
MEMORY_ROM canuint8 kCanMainVersion = (canuint8)(( CAN_DRIVER_VERSION ) >> 8);
MEMORY_ROM canuint8 kCanSubVersion  = (canuint8)(  CAN_DRIVER_VERSION );

#if defined( C_ENABLE_TP_SUPPORT )
 canuint8 TpPrecopy (pChipDataPtr data);
#endif

/***************************************************************************/
/* Data Definitions                                                        */
/***************************************************************************/

#if defined( C_ENABLE_ECU_SWITCH_PASS )
 static canuint8 fCanIsPassive;
#endif

#if defined( C_ENABLE_VARIABLE_DLC )
 volatile canuint8 CanRxActualDLC;    /* Store received DLC for global access */
#endif

#if defined( C_ENABLE_CANID_ACCESS ) || defined( C__NM_OSEK )
 volatile          canuint8  CanEcuNumber;
 extern MEMORY_ROM canuint16 kTpRxBaseAddress;
 extern MEMORY_ROM canuint16 kTpRxBaseOffset;
#endif


#if defined( C_ENABLE_CONFIRMATION_FLAG )
 #if defined( C_COMP_KEIL_C5X5C )
  extern idata canuint8 CanConfirmationFlags[];
 #else
   /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
   /* MEG - Karl-Fredrik Uhlander 2000-07-05: Fix to remove compiler warning. */
   /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
   //extern       canuint8 CanConfirmationFlags[];
 #endif
#endif

#if defined( C_COMP_KEIL_C5X5C )
 extern idata canuint8 CanIndicationFlags[];
#else
   /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
   /* MEG - Karl-Fredrik Uhlander 2000-07-05: Fix to remove compiler warning. */
   /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
   //extern       canuint8 CanIndicationFlags[];
#endif

#if defined( C_COMP_KEIL_C5X5C )
 static canuint8 initObject;
#endif

static canuint8 fCanStatus;
static cansint8 gInterruptCounter;

#if defined( C_TMT_QUE_USED )
 static canuint8 TxQueCnt;
#endif

static canuint8 Handle_curTxObj[2];

/* CanInterruptOldStatus is necessary to save the status of IEN before
   disabling CAN interrupts and restore THIS(!) status when restoring
   CAN interrupts */
static canuint8 CanInterruptOldStatus;


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

/****************************************************************************
| NAME:             CanTestChip
| PROTOTYPE:        depends on configuration
| CALLED BY:        CanInit()
| PRECONDITIONS:
| INPUT PARAMETERS: depends on configuration
| RETURN VALUES:    kCanTxOk, if Chip responds correctly
|                   kErrorInit, if not
| DESCRIPTION:      tests function of chip (reset-bit and cce-bit)
| GLOBAL DATA:
| STACK:
| RUNTIME:
****************************************************************************/

#if ( defined ( C_ENABLE_HARDWARE_CHECK ) || defined ( C_ENABLE_TEST_CHIP ) )
 #if defined( C_COMP_KEIL_C5X5C )
  static  ErrorCode CanTestChip( void )
#else
static  ErrorCode CanTestChip( CanInitHandle initObject )
#endif
{
  canuint16 i;

#if defined( C_COMP_KEIL_C5X5C )
 #if defined( C_CAN_CHIP_PDATA )
  XPAGE = 0xF7;                  /* 8 bit addressing of CAN */
 #endif
#endif

   /* wait until CANChip hardware reset status is not active ---------------*/
#if !CAN527internal
  for(i = kWaitReset; (Can82527.u.named.u.ex.ucCPUIntf & kRstSt); i--)
  {
    if ( i == 0 )                 /* while set: no access to 82527 possible */
    {
      return kErrorInit;          /* no access to CPU possible              */
    }
  }

   Can82527.u.named.u.ex.ucCPUIntf    = CanInitCPUIntf[initObject];
                                                     /* Diese Register-       */
                                                     /* Einstellung muss hier */
                                                     /* erfolgen wg. DMC      */
                                                     /* sonst bringt HW Test  */
                                                     /* nach SpAus Fehler     */
  for (i = kWaitTime1; i > 0; i--)
  {   /* wait */
  }
#endif

  /*  test for CAN-Chip responding ----------------------------------------  */
  /* start software initialization: set Init and CangeConfigEnable-Bit       */
  Can82527.u.named.ucCntrlReg  = kInit | kCCE;           /* SET INIT/CCE REG */

#if !CAN527internal
  Can82527.u.named.ucExBt0Reg   = 0x01;/* access to config regs must be poss.*/
#else
  Can82527.u.named.u.in.uiBtReg = 0x01;/* access to config regs must be poss.*/
#endif

  for (i = kWaitTime2; i > 0; i--)
  {   /* wait */
  }

#if !CAN527internal
  if (Can82527.u.named.ucExBt0Reg != 1)
#else
  if (Can82527.u.named.u.in.uiBtReg != 1)
#endif
  {
    return kErrorInit;                  /* access to config reg.not possible*/
  }

#if !CAN527internal
  Can82527.u.named.ucExBt0Reg =  0x00;
#else
  Can82527.u.named.u.in.uiBtReg =  0x00;
#endif
  for (i = kWaitTime2; i > 0; i--)
  {   /* wait */
  }

#if !CAN527internal
  if (Can82527.u.named.ucExBt0Reg != 0)
#else
  if (Can82527.u.named.u.in.uiBtReg != 0)
#endif
  {
    return kErrorInit;                  /* access to config reg.not possible*/
  }
  for (i = kWaitTime2; i > 0; i--)
  {   /* wait */
  }

  Can82527.u.named.ucCntrlReg &= ~kCCE;  /* disable writing to Config regs   */


#if !CAN527internal
  Can82527.u.named.ucExBt0Reg = 0x01;    /* access to config regs must not   */
#else
  Can82527.u.named.u.in.uiBtReg = 0x01;  /* access to config regs must not   */
                                          /* be possible                      */
#endif
  for (i = kWaitTime2; i > 0; i--)
  {   /* wait */
  }

#if !CAN527internal
  if (Can82527.u.named.ucExBt0Reg != 0)
#else
  if (Can82527.u.named.u.in.uiBtReg != 0)
#endif
  {
    return kErrorInit;                  /* access to config reg.possible    */
  }

  return kCanTxOk;
} /* END OF CanTestChip */
#endif


/****************************************************************************
| NAME:             CanInit
| PROTOTYPE:        depends on configuration
| CALLED BY:        CanInitPowerOn(), Network management
| PRECONDITIONS:    this function must be called with disabled interrupts
|                   (if not called while processor- and system-startup)
| INPUT PARAMETERS: depends on configuration
| RETURN VALUES:    kCanTxOk, if Chip responds correctly
|                   kErrorInit, if not
| DESCRIPTION:      initialization of chip-hardware
|                   initialization of receive and transmit message objects
| GLOBAL DATA:
| STACK:
| RUNTIME:
****************************************************************************/

#if defined( C_COMP_KEIL_C5X5C )
#pragma NOAREGS
ErrorCode CanInit( void ) small
#else
  ErrorCode CanInit( CanInitHandle initObject )
#endif
{
#if defined( C_COMP_KEIL_C5X5C )
  static CanMsgObj CAN_CHIP_ADR_MODE *pMsgObject;
  static cansint8 i;
#endif
#if defined( C_COMP_KEIL_C16x ) || \
    defined( C_COMP_TASKING_C16x )
  static   CanMsgObj                 *pMsgObject;
  static   cansint8 i;
#endif

#if defined( C_COMP_KEIL_C5X5C )
 #if defined( C_CAN_CHIP_PDATA )
  XPAGE = 0xF7;                  /* 8 bit addressing of CAN */
 #endif
#endif

#if !CAN527internal