/*C**************************************************************************
* NAME:         protocol_task.c
*----------------------------------------------------------------------------
* Copyright (c) 2004 Atmel.
*----------------------------------------------------------------------------
* RELEASE:      cc03-bl-can-1_0_4      
* REVISION:     1.4     
*----------------------------------------------------------------------------
* FILE_PURPOSE:    
*
* Contains all CAN protocole.
******************************************************************************/

/*_____ I N C L U D E - F I L E S ____________________________________________*/


#include "config.h"
#include "can_lib.h"
#include "bootloader.h"


/*_____ G L O B A L S ________________________________________________________*/

/*_____ P R I V A T E - F U N C T I O N S - D E C L A R A T I O N ____________*/


/*_____ L O C A L S __________________________________________________________*/

/*_____ P U B L I C - F U N C T I O N S ______________________________________*/
Uint16 can_id;
Uchar can_ctrl;
Uchar can_rx[NB_DATA_MAX];
Uchar can_tx[NB_DATA_MAX];

Uchar dlc_rx;
Uchar ssb_copy; /* copy of ssb */

/*_____ P R I V A T E - F U N C T I O N S ____________________________________*/
void send_error_security (void);
void can_autobaud(void);
void load_can_config(void);

#ifdef DEBUG

#define BT1_500k
#define BT2_500k
#define BT3_500k

#endif // DEBUG
Uint16 	offset_id_copy;
Uchar 	nnb_copy, eb_copy;

/*F****************************************************************************
* FUNCTION_NAME: com_task_init                                                   
*----------------------------------------------------------------------------
* FUNCTION_AUTHOR: BERTHY J.S.                                              
* FUNCTION_DATE  :                                          
*----------------------------------------------------------------------------
* FUNCTION_PURPOSE:   
* FUNCTION_INPUTS : void                                                          
* FUNCTION_OUTPUTS: void                                                       
******************************************************************************/
void protocol_task_init (void)
{
	Uchar cpt;

//	flag = 0;		// RAS all the flags

// Reading of CRIS
//-----------------
#ifndef DEBUG
  DPH = 0x00;
  DPL = CRIS_ADD; 
  API_RD_XAF();
  offset_id_copy = ACC << 4;
	if (offset_id_copy > MAX_OFFSET_ID)
	{
		offset_id_copy = 0;
	}

// Reading of NNB
//-----------------
  DPL = NNB_ADD; 
  API_RD_XAF();
  nnb_copy = ACC;

// Reading of EB
//-----------------
  DPL = XEB_ADD; 
  API_RD_XAF();
  eb_copy = ACC;

	if (!f_start_from_appli)
	{
	  CAN_CONTROLLER_RESET;     

	// Reading of Bit timing
	//----------------------
  	if (eb_copy != 0xFF)
		{
  		DPL = BT1_ADD; 
  		API_RD_XAF();
  		CANBT1 = ACC;
			DPTR++;
  		API_RD_XAF();
  		CANBT2 = ACC;
			DPTR++;
  		API_RD_XAF();
  		CANBT3 = ACC;
		}
	}// if (! f_start_from_appli)
#endif
#ifdef DEBUG
  offset_id_copy = 0x00;
	nnb_copy = 0xFF;
	eb_copy = 0x00;
  CAN_CONTROLLER_RESET;     
#endif

// New config CAN
//---------------------------------------------------------------------
  can_id = offset_id_copy;

  for(cpt=0; cpt<15; cpt++)
	{
  	CAN_SET_CHANNEL(cpt);
  	CANCONCH = 0;
  	CANSTCH  = 0;
  	CANIDT1  = 0;
  	CANIDT2  = 0;
  	CANIDT3  = 0;
  	CANIDT4  = 0;
	  CANIDM1  = 0;
  	CANIDM2  = 0;
  	CANIDM3  = 0;
  	CANIDM4  = 0;
	}

  CAN_SET_CHANNEL(CHANNEL_0);
  CANIDT1  = (offset_id_copy>>3);
  CANIDM1  = 0xFF;
  ENABLE_CHANNEL_RX; /* Reception enabled.*/
  CANCONCH |= 0x08;

	if (!f_start_from_appli)
	{
	//	can_autobaud();
		if ((eb_copy ==0xFF)||
			 ((eb_copy!= 0xFF)&&((CANBT1==0xFF) ||(CANBT2 == 0xFF)||(CANBT3 == 0xFF))))
		{
			ASM_CAN_AUTOBAUD();
			CANGCON &= ~MSK_CANGCON_AUTBAUD; /* End of listening mode */
			f_timing_ok = 1;
		}
	}

	CAN_CONTROLLER_ENABLE;

// End New config
//-----------------------------------------------------------------------------

// init of ssb copy 
//------------------
#ifndef DEBUG
  DPL = SSB_ADD; 
  API_RD_XAF();
  ssb_copy = ACC;
#endif
#ifdef DEBUG
  ssb_copy = NO_SECURITY;
#endif
}


/*F****************************************************************************
* FUNCTION_NAME: protocol_task                                                   
*----------------------------------------------------------------------------
* FUNCTION_AUTHOR: BERTHY J.S.                                              
* FUNCTION_DATE  :                                          
*----------------------------------------------------------------------------
* FUNCTION_PURPOSE:   
* FUNCTION_INPUTS : void                                                          
* FUNCTION_OUTPUTS: void                                                       
******************************************************************************/
void protocol_task (void)
{
  Uchar i;

/************** ERROR MANAGEMENT ********************/
/****************************************************/ 
	if((CANREC)&&(!f_timing_ok))
	{
		f_timing_ok = 1;
		ASM_CAN_AUTOBAUD();
		CANGCON &= ~MSK_CANGCON_AUTBAUD; /* End of listening mode */
 	}

/************** RECEPTION MANAGEMENT ********************/
/********************************************************/ 
  CAN_SET_CHANNEL(CHANNEL_0);

  if (CANSTCH) 
  {
 // if Message received
    if ((CANSTCH & MSK_CANSTCH_RxOk) == MSK_CANSTCH_RxOk)
    {
	    CANSTCH 		= 0x00;
			f_timing_ok = 1;

      can_id = (CANIDT1 << 3) | (CANIDT2 >> 5);
			
      for (i=0; i<NB_DATA_MAX; i++)
      {
        can_rx[i] = CANMSG;
      }

      dlc_rx = CANCONCH & 0x0F;

			switch ((can_id - offset_id_copy))
      {
        case CAN_ID_PROG_START:
        case CAN_ID_PROG_DATA:
        {
          if (ssb_copy == NO_SECURITY)
          {
            f_new_protoc_command = 1;
						
          }
          else
          {
            send_error_security();
          }
          break;
        }

        case CAN_ID_WRITE_FUNCTION:
        {
          if ((ssb_copy == NO_SECURITY)||
              ((can_rx[1] == 0x05)&&(can_rx[2]== RD_WR_SECURITY)&&(ssb_copy != RD_WR_SECURITY))|| // SSB access
              ((can_rx[0] == 0x00)&&(can_rx[1]==0xFF))) // full chip erase command
          {
            f_new_protoc_command = 1;
          }
          else
          {
            send_error_security();
          }
          break;
        }

        case CAN_ID_DISPLAY_DATA:
        case CAN_ID_READ_FUNCTION:
        {
          if ((ssb_copy != RD_WR_SECURITY)||
              ((ssb_copy == RD_WR_SECURITY)&&(can_rx[0]==0x01)&&(can_rx[1]==0x05)))
          {
            f_new_protoc_command = 1;
          }
          else
          {
            send_error_security();
          }
          break;
        }

        case CAN_ID_SELECT_NODE:
        {
          if (((can_rx[0] == nnb_copy) ||
							 (can_rx[0] == 0xFF)      ) && ((CANCONCH&0x0F)== 0x01))
					{
	          if (!_testbit_(f_communication_open))
  	        {
            	f_communication_open = 1;
	            f_new_protoc_command = 0;
      	    }
  	        f_frame_to_send = 1;
    	      can_tx[0] = BOOTLOADER_VERSION;
      	    can_tx[1] = f_communication_open;
        	  can_ctrl  = 2;
					}
          break;
        }  

        default:
        {
          f_new_protoc_command = 0;
          break;
        }
      }
      ENABLE_CHANNEL_RX; /* Reconfigure the channel.*/
    }
  } /* end if(CANSTCH) */

/************** TRANSMISION MANAGEMENT ********************/
/********************************************************/ 
  CAN_SET_CHANNEL(CHANNEL_1);

	while((CANEN2 & 0x02)==0x02) ; //wait channel free (end of last transmission)

  CANSTCH = 0x00;

  if (_testbit_(f_frame_to_send))
  {
    CANIDT1 = CAN_SET_STD_ID_10_4 (can_id);
    CANIDT2 = CAN_SET_STD_ID_3_0  (can_id);
    for(i=0; i<can_ctrl; i++)
    {
      CANMSG = can_tx[i];
    }
    CANCONCH = can_ctrl;
    ENABLE_CHANNEL_TX;

  }
}

/*F****************************************************************************
* FUNCTION_NAME: send_error_security                                                   
*----------------------------------------------------------------------------
* FUNCTION_AUTHOR: BERTHY J.S.                                              
* FUNCTION_DATE  :                                          
*----------------------------------------------------------------------------
* FUNCTION_PURPOSE:   
* FUNCTION_INPUTS : void                                                          
* FUNCTION_OUTPUTS: void                                                       
******************************************************************************/
void send_error_security (void)
{
  can_id 					= CAN_ID_ERROR + offset_id_copy;
  f_frame_to_send = 1;
  can_tx[0] 			= ERROR_SECURITY;
  can_ctrl  			= 1;
}