#define LINCFG_C
/******************************************************************************
*                                                       
*       Copyright (C) 2005 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                                                                                     */
/********************************************************************************************/
#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) */	

/* 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
#define LIN_TO3DIVIDER LIN_TO3DIVIDER5
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER6) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER6
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER7) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER7
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER8) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER8
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER9) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER9
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER10) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER10
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER11) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER11
#elif ((LIN_MAXFRAME_3_TIMEOUT / LIN_TO3DIVIDER12) * LIN_BITTIME) < LIN_MAXTOCOUNTER
#define LIN_TO3DIVIDER LIN_TO3DIVIDER12
#endif

/********************************************************************************************/
/* 4 bytes:     119 - 15 = 104                                                              */
/********************************************************************************************/
#define LIN_MAXFRAME_4_TIMEOUT  104ul
                                        
    /* dividers set */
#define LIN_TO4DIVIDER1 1ul