can_drv.c

CAN DRIVER FOR FREESCALE

            /******************************************************************/
            /************ Goal Part *******************************************/
            /******************************************************************/

            #ifdef C_ENABLE_GOAL
            // Timeout auf Vorgabe
            #ifdef COMAL_USE_CHANNEL_0
            {
             canuint8 j;

             for (j = COM_RX_COUNT-1; j >= 0; j--)
             {
               if (COM_RxIndex[j] == i) // Ist empf. Message == zu ueberwachende msg.?
               {
                 /* Reload Timeout Counter */
                 COM_RxTimeout_Cntr[j] = COM_RxTimeout[j];

                 #ifdef COMAL_RxFirstValue_0
                 SetRxFirstValueFlag(j);
                 #endif

                 #ifdef COMAL_RxChanged_0
                 ResetRxChangedFlag(j);

                 /* cmp via index -------------------------------------------*/
                 len = CanRxDataLen[i];
                 dst = CanRxDataPtr[i] + len - 1  ;
                 for (  ; len > 0; len--)
                 {
                    if ((*dst--) != (Can82527.u.named.sMsg15Obj.aucCanData(len-1)))
                    {
                       SetRxChangedFlag(j);
                       break;
                    }
                 }
                 #endif  //  changed
                 break;
               } /* if */
             } /* for */
            }
            #endif // use channel 0
            #endif // C_ENABLE_GOAL

            /******************************************************************/
            /************ Ende Goal Part **************************************/
            /******************************************************************/

            /******************************************************************/
            /************ OSEK Part *******************************************/
            /******************************************************************/

            #ifdef C_ENABLE_OSEK
            /* activate an event or a task if defined */
            /* i = index of received message */

            if ( C_RX_Event[i].event != NULL)
            {
              SetEvent(C_RX_Task[i],C_RX_Event[i].event);  /* call Task */
            }
            else
            {
              if ( C_RX_Task[i] != INVALID_TASK )
              {
                ActivateTask(C_RX_Task[i]);  /* call Task */
              }
            }
            #endif /* C_ENABLE_OSEK */

            /******************************************************************/
            /************ Ende OSEK Part **************************************/
            /******************************************************************/

            /******************************************************************/
            /************ Message Manager *************************************/
            /******************************************************************/


            /******************************************************************/
            /************ End of Message manager part *************************/
            /******************************************************************/

            /* no precopy or precopy returns false : copy data -------------- */
            /* copy via index -------------------------------------------*/
            if ( CanRxDataPtr[i] != NULL )      /* copy if buffer exists */
            {
              #if defined (C_OPTIMIZE_CODE)
              /* copy via index -------------------------------------------*/
              len = CanRxDataLen[i];
              dst = CanRxDataPtr[i] + len - 1  ;
              for (  ; len > 0; len--)
              {
                 *dst-- = Can82527.u.named.sMsg15Obj.aucCanData(len-1);
              }
              #else  /*  O_OPTIMIZE_SPEED */
              len = CanRxDataLen[i];
              dst = CanRxDataPtr[i];
              switch (len)
              {
                 case 8: *(dst+7) = Can82527.u.named.sMsg15Obj.aucCanData(7);
                 case 7: *(dst+6) = Can82527.u.named.sMsg15Obj.aucCanData(6);
                 case 6: *(dst+5) = Can82527.u.named.sMsg15Obj.aucCanData(5);
                 case 5: *(dst+4) = Can82527.u.named.sMsg15Obj.aucCanData(4);
                 case 4: *(dst+3) = Can82527.u.named.sMsg15Obj.aucCanData(3);
                 case 3: *(dst+2) = Can82527.u.named.sMsg15Obj.aucCanData(2);
                 case 2: *(dst+1) = Can82527.u.named.sMsg15Obj.aucCanData(1);
                 case 1: *(dst  ) = Can82527.u.named.sMsg15Obj.aucCanData(0);
                 default:
                    break;
              }
              #endif /* defined (C_OPTIMIZE_CODE) */
            }
            if ( CanIndicationMask[i] != 0 )
            {
                /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
            /* MEG - Karl-Fredrik Uhlander 2000-07-05: Fix to remove compiler warning. */
            /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
            //CanIndicationFlags.[CanIndicationOffset[i]] |= CanIndicationMask[i];
            CanIndicationFlags._c[CanIndicationOffset[i]] |= CanIndicationMask[i];
            }

            if ( CanRxApplIndicationPtr[i] != NULL )
            {
               CanRxApplIndicationPtr[i](i);  /* call IndicationRoutine */
            }
         }   /* if ( i >= 0 ) */
         /* end of msg found in rom table ------------------------------------*/
         else
         {  /* id not found in rom table */
            #ifdef C__NM_OSEK
             /* check for nwm msg: look at (id & C_NWM_ACCEPT_MASK) */
             if ((Can82527.u.named.sMsg15Obj.aucArbitrFld[0] & C_NWM_ACCEPT_MASK) == C_NWM_BASE_ID_HI)
               {
                  CanEcuNumber =
                  ( ( ( Can82527.u.named.sMsg15Obj.aucArbitrFld[0] & (~C_NWM_MASK) ) << 3 ) |
                  ( (   Can82527.u.named.sMsg15Obj.aucArbitrFld[1] ) >> 5 )   );

                  NmPrecopy( &Can82527.u.named.sMsg15Obj.aucCanData(0) ); /* precopy routine */

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/*    MEG - Karl-Fredrik Uhlander 2000-07-03: Fix to adapt this CAN Driver to our TP.                          */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
              TpPrecopy(&Can82527.u.named.sMsg15Obj.aucCanData(0));  /* To mirror nm frames! */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

                  Can82527.u.named.sMsg15Obj.ucCntrl0 = kResetIntPnd; /* reset pending interrupt */
                  Can82527.u.named.sMsg15Obj.ucCntrl1 = kResetNewDat; /* make receive buffer free*/
                  continue;
               /* returns always kNoCopyData: */
               }
            #endif

            /* check for tp message can id: kTpRxBaseAddress... (example: 0x600 - 0x6ff) */
            #ifdef C_ENABLE_TP_SUPPORT
             id = ( (canuint16)(Can82527.u.named.sMsg15Obj.aucArbitrFld[0])<<3 | Can82527.u.named.sMsg15Obj.aucArbitrFld[1]>>5 );

             if ( (id>=kTpRxBaseAddress) && (id<=(kTpRxBaseAddress+kTpRxBaseOffset)) )
             {
               CanEcuNumber = (canuint8)( id );
               TpPrecopy(&Can82527.u.named.sMsg15Obj.aucCanData(0));  /* Possible parameter: address of basic object */
               Can82527.u.named.sMsg15Obj.ucCntrl0 = kResetIntPnd; /* reset pending interrupt */
               Can82527.u.named.sMsg15Obj.ucCntrl1 = kResetNewDat; /* make receive buffer free*/
               continue;
             }
            #endif


         } /* id not found in rom table */

         Can82527.u.named.sMsg15Obj.ucCntrl0 = kResetIntPnd; /* reset pending interrupt */
         Can82527.u.named.sMsg15Obj.ucCntrl1 = kResetNewDat; /* make receive buffer free*/


         /*====================================== FCAN INTERRUPT ==============*/
      }  /* if ( irptId == 2 ) */
      else
      {
         CC_BusoffCounter = 0; /* Clear busoff counter when message received */

         /* interrupt in message object 1..14 -----*/
         irptId -= 3;
         pMsgObject = &Can82527.u.indexed.obj[irptId].sMsgObj; /* get ptr to message object */

         if ( ( pMsgObject->ucCntrl0 & kTestIntPnd ) == 0)
         {
           continue;  /* no valid IRQ pending(!?), check for another interrupt */
         }

         if ( irptId > 1 )
         {
            /*=================================== FCAN RECEIVE  INTERRUPT =====*/

            /* irptId neu berechnen */
            irptId = CanNumberOfRxBasicCANObjects + 13 - irptId; /* msgObj->index: 13->0; 12->1; 11->2; ... */

            if ( CanRxApplPrecopyPtr[irptId] != NULL )
            {
               #ifdef C_ENABLE_CANID_ACCESS
               CanEcuNumber =           /* CanEcuNumber = lower 8 bits of ID */
                  ( ( ( pMsgObject->aucArbitrFld[0] ) << 3 ) |
                    ( ( pMsgObject->aucArbitrFld[1] ) >> 5 )   );
               #endif
               #if defined( C_ENABLE_VARIABLE_DLC )
               CanRxActualDLC = ((pMsgObject->ucMsgConf)>>4);
               #endif
               /*precopy routine */
               if ( CanRxApplPrecopyPtr[irptId](&(pMsgObject->aucCanData(0)))==kCanNoCopyData )
               {
                  pMsgObject->ucCntrl0 = kResetIntPnd; /* reset pending interrupt  */
                  pMsgObject->ucCntrl1 = kResetNewDat;
                  continue;                /* precopy routine returns true  : */
               }                           /* don't copy data check next irpt */
            }

            /******************************************************************/
            /************ Goal Part *******************************************/
            /******************************************************************/

            #ifdef C_ENABLE_GOAL
            // Timeout auf Vorgabe
            #ifdef COMAL_USE_CHANNEL_0
            {
              canuint8 jk;

              for (jk = COM_RX_COUNT-1; jk >= 0; jk--)
              if (COM_RxIndex[jk] == irptId) // is received message == message to check
              {
                 /* Reload Timeout Counter */
                 COM_RxTimeout_Cntr[jk] = COM_RxTimeout[jk];

                 #ifdef COMAL_RxFirstValue_0
                 SetRxFirstValueFlag(jk);
                 #endif

                 #ifdef COMAL_RxChanged_0

                 ResetRxChangedFlag(jk);

                 /* cmp via index -------------------------------------------*/

                 len = CanRxDataLen[irptId];
                 dst = CanRxDataPtr[irptId] + len - 1  ;
                 for (  ; len > 0; len--)
                 {
                    if ((*dst--) != (pMsgObject->aucCanData(len-1)))
                    {
                       SetRxChangedFlag(jk);
                       break; // leave loop
                    }
                 }
                 #endif  //  changed
                 break;  // leave loop
              }
            }
            #endif // use channel 0
            #endif // C_ENABLE_GOAL

            /******************************************************************/
            /************ Ende Goal Part **************************************/
            /******************************************************************/

            /******************************************************************/
            /************ OSEK Part *******************************************/
            /******************************************************************/
            #ifdef C_ENABLE_OSEK
            /* activate an event or a task if defined */
            /* i = index of received message */
            /* call of task and event exclude each other
               first test event than task */

            if ( C_RX_Event[irptId].event != NULL)
            {
              SetEvent(C_RX_Task[irptId],C_RX_Event[irptId].event);  /* call Task */
            }
            else
            {
              if ( C_RX_Task[irptId] != INVALID_TASK )
              {
                ActivateTask(C_RX_Task[irptId]);  /* call Task */
              }
            }
            #endif
            /******************************************************************/
            /************ Ende OSEK Part **************************************/
            /******************************************************************/

            /* no precopy or precopy returns false : copy data ------------- */
            if ( CanRxDataPtr[irptId] != NULL ) /* copy if buffer exists */
            {
              do
              {
                pMsgObject->ucCntrl1 = kResetNewDat;
                #if defined(C_OPTIMIZE_CODE)
                /* copy via index -------------------------------------------*/
                len = CanRxDataLen[irptId];
                dst = CanRxDataPtr[irptId] + len - 1  ;
                for (  ; len > 0; len--)
                {
                  *dst-- = pMsgObject->aucCanData(len-1);
                }
                #else  /*  O_OPTIMIZE_SPEED */
                {
                  #ifdef C_COMP_KEIL_C5X5C
                     static volatile canuint8 CAN_CHIP_ADR_MODE *src;
                  #else
                    register volatile canuint8       *src;
                  #endif
                  len = CanRxDataLen[irptId];
                  dst = CanRxDataPtr[irptId];
                  src = &(pMsgObject->aucCanData(0));
                  switch (len)
                  {
                    case 8:   *(dst+7) = *(src+7);
                    case 7:   *(dst+6) = *(src+6);
                    case 6:   *(dst+5) = *(src+5);
                    case 5:   *(dst+4) = *(src+4);
                    case 4:   *(dst+3) = *(src+3);
                    case 3:   *(dst+2) = *(src+2);
                    case 2:   *(dst+1) = *(src+1);
                    case 1:   *(dst  ) = *(src  );
                    default:
                       break;
                  }
                }
                #endif  /* C_OPTIMIZE_CODE */
              /* while copying another msg may have been received. If so:     */
              } while ( (pMsgObject->ucCntrl1) & (kTestNewDat) ); /* read again */
            }
            if ( CanIndicationMask[irptId] != 0 )
            {
               /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/