lincfg.c

LINKit for dz60 freescale code warrior

#define LINCFG_C
/******************************************************************************
*                                                       
*       Copyright (C) 2007 Freescale Semiconductor, Inc.
*       All Rights Reserved								              
*														                            
* Filename:     lincfg.c                
*														                            
* Revision:      										                    
*														                            
* Functions:    LIN Driver internal configuration
*												                            
* Description:  
*
* Notes:        This file is NOT allowed to modify by user
*
******************************************************************************/

#include <linapi.h>

/********************************************************************************************/
/********************************************************************************************/
/**     Driver hardware configuration                                                      **/
/********************************************************************************************/
/********************************************************************************************/

#if defined(S08DZ60)
/********************************************************************************************/
/* S08DZ60                                                                                     */
/********************************************************************************************/
/* checking configuration */
/* User should not change this section */
#if defined(MASTER)	
#if (!((LIN_TO_WAKEUPDEL >= 4) & (LIN_TO_WAKEUPDEL <= 64)))
#warning "The wake up delimiter is out of range. Therefore the wake up delimiter will be set to 4"
#undef  LIN_TO_WAKEUPDEL
#define LIN_TO_WAKEUPDEL        4
#endif /* (!((LIN_TO_WAKEUPDEL >= 4) & (LIN_TO_WAKEUPDEL <= 64))) */
#endif /* defined(MASTER) */	

#if !defined(S08) 
#error "S08 has to be defined as global define "
#endif

#if !defined(CW08) 
#error "CW08 has to be defined as global define "
#endif

#if !defined(S08DZ60) 
#error "S08DZ60 has to be defined as global define"
#endif


#if !defined(SLAVE) && !defined(MASTER)
#warning"SLAVE or MASTER has not been defined. MASTER has been defined as default"
#define MASTER
#endif

#if !defined(SCI_1) && !defined(SCI_2)
#warning"SCI_1 or SCI_2 has not been defined in order to select the required SCI module. SCI1 has been selected as default"
//#define SCI_1
#define SCI_2
#endif


#if (!defined(TPM_1) && !defined(TPM_2)) && defined(MASTER)
#warning"TPM_1 or TPM_2 has not been defined in MASTER mode in order to select the required TPM module. TPM1 has been selected as default"
#define TPM_1
#endif


#if defined(MASTER) && defined(TPM_1) 
#if !defined(CHANNEL_5) && !defined(CHANNEL_4) && !defined(CHANNEL_3) && !defined(CHANNEL_2) && !defined(CHANNEL_1) && !defined(CHANNEL_0)
#warning"TPM1 has channel 0 - 5. None of them is selected. Channel 0 has been selected as default"
#define CHANNEL_0
#endif
#endif

#if defined(MASTER) && defined(TPM_2) 
#if !defined(CHANNEL_1) && !defined(CHANNEL_0)
#warning"TPM1 has channel 0 - 1. None of them is selected. Channel 0 has been selected as default"
#define CHANNEL_0
#endif
#endif 



/* LIN baud rate masks */
#define LIN_BAUDRATE_MASK          0x1FFFu
#define LIN_TIMER_CLOCKSOURCE_MASK 0x18

const struct
{
    unsigned int    LIN_IdleTimeoutClocks;  /* number of LIN_IdleClock() calls per LIN idle timeout */
    unsigned int    LIN_BaudRate;       /* LIN baud rate setting */
#if defined(MASTER)
    unsigned char   LIN_to_wakeup_delimiter; /* Tbit wake up  delimiter */
    unsigned char   LIN_TimerPrescaler; /* timer prescaler */
    unsigned char   LIN_TimerCLK;
#endif /* defined(MASTER) */
} LIN_CfgConst =
{
    LIN_IDLETIMEOUT,
    (LIN_BAUDRATE & LIN_BAUDRATE_MASK),
#if defined(MASTER)
    LIN_TO_WAKEUPDEL,
    LIN_TIMERPRESCALER,
    (LIN_TIMER_CLOCKSOURCE_MASK & LIN_TIMERCLK),
#endif /* defined(MASTER) */
};
#endif /* defined(S08DZ60) */

#if defined(MASTER)

/********************************************************************************************/
/********************************************************************************************/
/**     Timeout module constants calculation                                               **/
/********************************************************************************************/
/********************************************************************************************/

#define LIN_MAXTOCOUNTER 0xFFFFul       /* maximal allowed timer 16-bit counter value */
                                        /* it must be long for correct computation */

/********************************************************************************************/
/* Wakeup Delimiter                                                                         */
/********************************************************************************************/
#define LIN_WKUPDELLEN_TO   10ul

    /* dividers set */
#define LIN_TO9DIVIDER1     1ul
#define LIN_TO9DIVIDER2     2ul
#define LIN_TO9DIVIDER3     5ul
#define LIN_TO9DIVIDER4     10ul
    
    /* maximal integral divider search */
#if   ((LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO9DIVIDER LIN_TO9DIVIDER1
#elif ((LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO9DIVIDER LIN_TO9DIVIDER2
#elif ((LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO9DIVIDER LIN_TO9DIVIDER3
#elif ((LIN_WKUPDELLEN_TO / LIN_TO9DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO9DIVIDER LIN_TO9DIVIDER4
#endif

/********************************************************************************************/
/* MaxFrame Timeout module constants calculation                                            */
/*      Nmax = (10 * Ndata + 45) * 1.4                                                      */
/*      Tmax = Nmax - 15                                                                    */
/*          for S08: Nmax - 15                                                             */
/********************************************************************************************/

/********************************************************************************************/
/* 1 byte:      77 - 15 = 62                                                                */
/********************************************************************************************/
#define LIN_MAXFRAME_1_TIMEOUT  62ul
                                        
    /* dividers set */
#define LIN_TO1DIVIDER1 1ul
#define LIN_TO1DIVIDER2 2ul
#define LIN_TO1DIVIDER3 31ul
#define LIN_TO1DIVIDER4 62ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO1DIVIDER LIN_TO1DIVIDER1
#elif ((LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO1DIVIDER LIN_TO1DIVIDER2
#elif ((LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO1DIVIDER LIN_TO1DIVIDER3
#elif ((LIN_MAXFRAME_1_TIMEOUT / LIN_TO1DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO1DIVIDER LIN_TO1DIVIDER4
#endif

/********************************************************************************************/
/* 2 bytes:     91 - 15 = 76                                                                */
/********************************************************************************************/
#define LIN_MAXFRAME_2_TIMEOUT  76ul
                                        
    /* dividers set */
#define LIN_TO2DIVIDER1 1ul
#define LIN_TO2DIVIDER2 2ul
#define LIN_TO2DIVIDER3 4ul
#define LIN_TO2DIVIDER4 19ul
#define LIN_TO2DIVIDER5 38ul
#define LIN_TO2DIVIDER6 76ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER1
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER2
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER3
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER4
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER5) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER5
#elif ((LIN_MAXFRAME_2_TIMEOUT / LIN_TO2DIVIDER6) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO2DIVIDER LIN_TO2DIVIDER6
#endif

/********************************************************************************************/
/* 3 bytes:     105 - 15 = 90                                                               */
/********************************************************************************************/
#define LIN_MAXFRAME_3_TIMEOUT  90ul
                                        
    /* dividers set */
#define LIN_TO3DIVIDER1 1ul
#define LIN_TO3DIVIDER2 2ul
#define LIN_TO3DIVIDER3 3ul
#define LIN_TO3DIVIDER4 5ul
#define LIN_TO3DIVIDER5 6ul
#define LIN_TO3DIVIDER6 9ul
#define LIN_TO3DIVIDER7 10ul
#define LIN_TO3DIVIDER8 15ul
#define LIN_TO3DIVIDER9 18ul
#define LIN_TO3DIVIDER10 30ul
#define LIN_TO3DIVIDER11 45ul
#define LIN_TO3DIVIDER12 90ul

    /* maximal integral divider search */
#if   ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER1) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER1
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER2) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER2
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER3) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER3
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER4) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER4
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER5) * LIN_BITTIME) < LIN_MAXTOCOUNTER