boot_task.c

T89C51CC01 uart BOOTLOAD

/*C*****************************************************************************
* FILE_NAME         : bootloader.c                                             
*----------------------------------------------------------------------------
* FILE_CREATED_BY   : BERTHY JS                                             
* FILE_CREATION_DATE: 16/05/00                                              
*----------------------------------------------------------------------------
* FILE_PURPOSE:    
*
******************************************************************************/

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

#include "compiler.h"
#include "config.h"
#include "can_lib.h"
#include "bootloader.h"
/*_____ P R I V A T E - F U N C T I O N S ____________________________________*/

extern void boot_manage_display (void);
extern void fct_calc_nb_byte (void);
extern void fct_load_data (Uchar nb_data);

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

Uint16 address_start;
Uint16 address_end;
Uint16 size_bloc;
Uint16 nb_bloc;
Uint16 nb_octet_rest;




/*F****************************************************************************
* FUNCTION_NAME:  boot_task                                                 
*----------------------------------------------------------------------------
* FUNCTION_AUTHOR: BERTHY J.S.                                              
* FUNCTION_DATE  :                                          
*----------------------------------------------------------------------------
* FUNCTION_PURPOSE: 
* This task managed all request from isp.
* If Some request are similar to user api call then used api_task.  
* FUNCTION_INPUTS : void                                                          
* FUNCTION_OUTPUTS: void                                                       
******************************************************************************/
void boot_task(void)
{

  if (f_new_protoc_command && 
      (api_command == WAIT_COMMAND)&&
      f_communication_open && !f_command_ongoing)
  {
    f_new_protoc_command = 0;
    f_command_ongoing    = 1;

    switch(can_id - offset_id_copy)
    {

/* CAN_ID_PROG_START (Only for isp)
 * This command prepare information for flash prog.
 * nb_octet_rest : nb of byte to program
 * nb_bloc_128   : nb of full column latch
 * size_bloc		 : size of the first bloc 
 */
      case CAN_ID_PROG_START: 
      {
		    f_command_ongoing = 0;
        f_frame_to_send 	= 1;
        can_ctrl       		= 0x00;
				if (can_rx[0] == 0)				/* Flash access */
				{
					f_flash_eeprom_area = 0;
				}
				else  										/* Eeprom access */
				{
					f_flash_eeprom_area = 1;
				}

				fct_calc_nb_byte();
    
				if (can_rx[2] >= SIZE_COLUMN_LATCH)
				{
        	size_bloc = can_rx[2] - SIZE_COLUMN_LATCH;  // size for the first bloc !! column latch size
				}
				else
				{
        	size_bloc = SIZE_COLUMN_LATCH - can_rx[2];  // size for the first bloc !! column latch size
				}

        if (nb_octet_rest < size_bloc)
        {
          size_bloc = nb_octet_rest;
        }
        else
        {
          nb_bloc = nb_octet_rest/ SIZE_COLUMN_LATCH; 
        }
				if ((size_bloc == 0)&&(nb_octet_rest>SIZE_COLUMN_LATCH))
				{
					size_bloc = SIZE_COLUMN_LATCH;
					nb_bloc--;
				}

        break;
      }

/* CAN_ID_PROG_DATA command we need:
 * nb_octet_rest : nb of byte to program
 * nb_bloc_128   : nb of full column latch
 * size_bloc     : for the first bloc if not modulo 128
 * This command request data.
 * When column latch full, launch programming action
 */
      case CAN_ID_PROG_DATA:
      {
			/* Request new data, column latch not full. */
			/*------------------------------------------*/ 
        if (size_bloc > NB_DATA_MAX)
	      {
					fct_load_data (NB_DATA_MAX);
/*					for (cpt_var = 0; cpt_var < NB_DATA_MAX; cpt_var++)
					{
						DPTR = address_start; 
						api_value = can_rx[cpt_var];
						ACC = api_value;
						if (f_flash_eeprom_area)
						{
						  API_WR_EEPROM_CL();				
						}
						else
						{
	        		API_WR_FLASH_CL();
						}
						size_bloc--;
						address_start ++; 
					}
					address_start += NB_DATA_MAX;
	        nb_octet_rest -= NB_DATA_MAX;*/
	      }
			/* Last load before launch programming.  */
			/*---------------------------------------*/ 
        else  
        {
					fct_load_data (size_bloc);

/*					for(cpt_var = 0; cpt_var < size_bloc; cpt_var++)
					{
						DPTR = address_start; 
						api_value = can_rx[cpt_var];
						ACC = api_value;
						if (f_flash_eeprom_area)
						{
						  API_WR_EEPROM_CL();				
						}
						else
						{
	        		API_WR_FLASH_CL();
						}
		        nb_octet_rest --;
    		    address_start ++; 
					}*/

					if (f_flash_eeprom_area)
					{
            api_command = ID_API_LAUNCH_EEPROM;    
						API_LAUNCH_PRG_EEPROM(); // request API for launch programming   
          }
					else
					{
            api_command = ID_API_LAUNCH_PRG_FLASH; // request API for launch programming   
					}
 
	        if (nb_bloc)		
          {
            nb_bloc--;
          }
        }

   		/* If last frame before launch programming, prepare the next bloc */
   		/*----------------------------------------------------------------*/
        if ((api_command==ID_API_LAUNCH_PRG_FLASH)||
						(api_command==ID_API_LAUNCH_EEPROM)) 
        {							
          if (nb_octet_rest >= SIZE_COLUMN_LATCH)
          {
            size_bloc = SIZE_COLUMN_LATCH; 
          }
          else
          {
            size_bloc = nb_octet_rest;
          }
        }
        break; 
      }

/* CAN_ID_DISPLAY_DATA 
 * can_rx[0] = 0x01 -> BLANK_CHECK (Only for ISP)
 * This command check if data between address_start and address_end is erased
 *
 * can_rx[1] = 0x00 -> DISPLAY_DATA
 * This command return data from address_start to address_end
 * Send data read by bloc of NB_DATA_MAX
 */
      case CAN_ID_DISPLAY_DATA:
      {
				fct_calc_nb_byte();
        size_bloc 		= nb_octet_rest / NB_DATA_MAX;

        if (can_rx[0]==0x01) // BLANK CHECK
        { 
					do{
			      can_ctrl = 0;
      			DPTR = address_start;
						API_RD_FLASH();
      			api_value = ACC;
						if(api_value != ERASE_SYMBOL)
						{
							can_tx[0] = DPH;
							can_tx[1] = DPL;
			        can_ctrl  = 2;
							break;
						}  
						nb_octet_rest--;
						address_start++;   	
		      }while(nb_octet_rest);		
    		  f_frame_to_send 	= 1;
					f_command_ongoing = 0;										
        }
        else  								// DISPLAY 
        {
          if (can_rx[0]==00)
					{
						f_flash_eeprom_area = 0;
					}
					else
					{
						f_flash_eeprom_area = 1;
					}
    		  f_frame_to_send 	= 1;
					boot_manage_display();		
        }
	    	break;
      }

/* CAN_ID_WRITE_FUNCTION 
 * can_rx[0] = 00h : Erase command
 * can_rx[0] = 01h : Write Xaf command
 * can_rx[0] = 02h : Write Fuse
 * can_rx[0] = 03h : Start Application
 */
      case CAN_ID_WRITE_FUNCTION:
      {
        switch (can_rx[0])
  	    {
		  		case 00: // Erase Command
		  		{
            if(can_rx[1]==0xFF)		//----> Full chip erase	
            {
              api_command = ID_API_FULL_CHIP_ERASE;
              ssb_copy    = NO_SECURITY; 
            }
            else									//----> Erase block command
            { 
              api_command = ID_API_ERASE_BLOCK;
              api_dph     = can_rx[1];
            }
            break;
		  		}
		  		case 01: // Write Xaf Command
		  		{
            api_command = ID_API_PROGRAM_XAF;
            if (can_rx[1] == 0x05)   // If SSB access. 
            {
              ssb_copy = can_rx[2];
            }
            api_dpl     = can_rx[1];
            api_value   = can_rx[2];
						break;
		  		}
		  		case 02: // Write Fuse Command !! can_rx[1] not used
		  		{
            api_command = ID_API_PROGRAM_FUSE_BIT;
            api_value   = can_rx[2];
						break;
		  		}
		  		case 03: // Start Application
		  		{
						if (can_rx[1]==0x00) // Hardware Reset
						{
							WDTRST = 0x1E;
							WDTRST = 0xE1;
						}
						else  							// JMP address
						{
							DPL = can_rx[3];
							DPH = can_rx[2];
							ASM_JMP_DPTR();
						}
						break;
		  		}
        }
        break;
      }

/* CAN_ID_READ_FUNCTION 
 * can_rx[0] = 00h	: 
 * can_rx[0] = 01h : Read Xaf command
 * can_rx[0] = 02h : Read Fuse
 */
      case CAN_ID_READ_FUNCTION:
      {
        switch (can_rx[0])
  	    {
				  case 00: // Special Read
				  {
            api_command = ID_API_READ_SPECIAL;
						api_dpl   = can_rx[1];
						break;
		  		}
		  		case 01: // Read Xaf
		  		{
            api_command = ID_API_READ_XAF;
            api_dpl     = can_rx[1];
						break;
		  		}
		  		case 02: // Read Fuse
		  		{
            api_command = ID_API_READ_HW;
						break;
		  		}
        }
        break;
      }
			default:
			{
   			f_command_ongoing = 0;
				break;
			}
    }
  }

/* WAIT end of api_task execution */
/*-------------------------------*/
	else if(f_command_ongoing) 
	{
		if (api_command == WAIT_COMMAND)
		{
			f_command_ongoing = 0;
      f_frame_to_send 	= 1;
      can_ctrl       		= 1;

			switch(can_id - offset_id_copy)
			{
	      case CAN_ID_PROG_DATA:
  	    {
	        if (nb_octet_rest)
  	      {
    	      can_tx[0] = COMMAND_NEW_DATA;
      	  }
        	else
        	{
          	can_tx[0] = COMMAND_OK;
        	}
					break;
				}

	      case CAN_ID_DISPLAY_DATA:
				{
					boot_manage_display();
					break;
				}

	      case CAN_ID_WRITE_FUNCTION:
				{
          can_tx[0] = COMMAND_OK;
					break;
				}

	      case CAN_ID_READ_FUNCTION:
				{
          can_tx[0] = api_value;
					break;
				}

				default:
				{
					break;
				}
			}
		}
	} 
}



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

// Prepare data to send

	if (size_bloc)
	{
	  can_ctrl = NB_DATA_MAX;
		size_bloc--;
		nb_octet_rest -= NB_DATA_MAX;
		f_command_ongoing = 1;
	}
	else
	{
		if (nb_octet_rest==0)
		{
      f_frame_to_send = 0;
		}
		can_ctrl          = nb_octet_rest;
		nb_octet_rest     = 0;
		f_command_ongoing = 0;
	}

	for (i=0; i<can_ctrl; i++)
	{
		DPTR = address_start;
		if(f_flash_eeprom_area)
		{
			API_RD_EEPROM();
		}
		else
		{
			API_RD_FLASH();
		}
		temp 			= ACC;				// !!! Pas touche
		can_tx[i] = temp;
		address_start++;
 	}

}

/*F****************************************************************************
* FUNCTION_NAME:  fct_calc_nb_byte                                                 
*----------------------------------------------------------------------------
* FUNCTION_AUTHOR: BERTHY J.S.                                              
* FUNCTION_DATE  :                                          
*----------------------------------------------------------------------------
* FUNCTION_PURPOSE: 
* FUNCTION_INPUTS : void                                                          
* FUNCTION_OUTPUTS: void                                                       
******************************************************************************/
void fct_calc_nb_byte (void)
{
	address_start = can_rx[1]<<8 | can_rx[2];
 	address_end   = can_rx[3]<<8 | can_rx[4];
  nb_octet_rest = (address_end - address_start)+1 ;
}

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

	for (cpt_var = 0; cpt_var < nb_data; cpt_var++)
	{
		DPTR = address_start; 
		api_value = can_rx[cpt_var];
		ACC = api_value;
		if (f_flash_eeprom_area)
		{
			API_WR_EEPROM_CL();				
		}
		else
		{
	    API_WR_FLASH_CL();
		}
		size_bloc--;
		address_start ++; 
		nb_octet_rest--;
	}
}