/*
 * Module_Upgrade.h
 *
 *  Created on: 2019
 *      Author: user75
 */

#ifndef MODULE_UPGRADE_H_
#define MODULE_UPGRADE_H_

#endif /* MODULE_UPGRADE_H_ */

#include 	<sys/time.h>
#include 	<sys/timeb.h>
#include    <sys/types.h>
#include    <sys/stat.h>
#include 	<sys/types.h>
#include 	<sys/ioctl.h>
#include 	<sys/socket.h>
#include 	<sys/ipc.h>
#include 	<sys/shm.h>
#include 	<sys/shm.h>
#include 	<sys/mman.h>
#include 	<linux/wireless.h>
#include 	<linux/can.h>
#include 	<linux/can/raw.h>
#include 	<arpa/inet.h>
#include 	<netinet/in.h>

#include 	<unistd.h>
#include 	<stdarg.h>
#include    <stdio.h>
#include    <stdlib.h>
#include    <unistd.h>
#include    <fcntl.h>
#include    <termios.h>
#include    <errno.h>
#include 	<errno.h>
#include 	<string.h>
#include	<time.h>
#include	<ctype.h>
#include 	<ifaddrs.h>

#define Debug
#define ARRAY_SIZE(A)		(sizeof(A) / sizeof(A[0]))
#define PASS				1
#define FAIL				-1

struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct FanModuleData			*ShmFanModuleData;

enum Image_Type
{
	CSU_BOOTLOADER 		           = 0x10000001,
	CSU_KERNEL_CONFIGURATION       = 0x10000002,
	CSU_KERNEL_IMAGE 	           = 0x10000003,
	CSU_ROOT_FILE_SYSTEM	       = 0x10000004,
	CSU_USER_CONFIGURATION         = 0x10000005,
	CSU_PRIMARY_CONTROLLER 		   = 0x10000006,
	CCS_BOARD_BOOTLOADER 		   = 0x10000007,
	CCS_BOARD_KERNEL_CONFIGURATION = 0x10000008,
	CCS_BOARD_KERNEL_IMAGE 		   = 0x10000009,
	CCS_BOARD_FILE_SYSTEM		   = 0x1000000A,
	CHAdeMO_BOARD                  = 0x1000000B,
	GB_BOARD                       = 0x1000000C,
	RELAY_CONTROL_BOARD            = 0x1000000D,
	FAN_CONTROL_BOARD              = 0x1000000E,
	LCM                            = 0x1000000F,
	F750_PSU_PRIMARY_CONTROLLER    = 0x10000010,
	F750_PSU_SECONDARY_CONTROLLER  = 0x10000011,
	F950_PSU_PRIMARY_CONTROLLER    = 0x10000012,
	F950_PSU_SECONDARY_CONTROLLER  = 0x10000013,
	AC_CORDSET_CONTROLLER          = 0x20000001,
	AC_WALLMOUNT_CONTROLLER        = 0x20000002,
	CMU_IN_BMS                     = 0x30000001,
	BMU_IN_BMS                     = 0x30000002
};

enum Flash_ImageType
{
	FLASH_IMAGE_TYPE_SPL						= 0x01,
	FLASH_IMAGE_TYPE_UBOOT						= 0x02,
	FLASH_IMAGE_TYPE_DTB						= 0x03,
	FLASH_IMAGE_TYPE_KERNEL						= 0x04,
	FLASH_IMAGE_TYPE_ROOTFS						= 0x05,
	FLASH_IMAGE_TYPE_CONFIG						= 0x06
};

enum Canbus_ImageType
{
	CANBUS_IMAGE_TYPE_SPL						= 0x01,
	CANBUS_IMAGE_TYPE_UBOOT						= 0x02,
	CANBUS_IMAGE_TYPE_DTB						= 0x03,
	CANBUS_IMAGE_TYPE_KERNEL					= 0x04,
	CANBUS_IMAGE_TYPE_ROOTFS					= 0x05,
	CANBUS_IMAGE_TYPE_CONFIG					= 0x06,
	CANBUS_IMAGE_TYPE_MCU						= 0x07
};

enum Canbus_MessageId
{
	CANBUS_MESSAGE_ID_UPGRADE_REQUEST			= 0x00000e00,
	CANBUS_MESSAGE_ID_UPGRADE_TRANS_BLOCK		= 0x00000f00,
	CANBUS_MESSAGE_ID_UPGRADE_TRANS_DATA		= 0x00001000,
	CANBUS_MESSAGE_ID_UPGRADE_FINISH			= 0x00001100
};

enum Uart_Command
{
	UART_CMD_UPDATE_START 		= 0xe0,
	UART_CMD_UPDATE_ABORD 		= 0xe1,
	UART_CMD_UPDATE_TRANSFER 	= 0xe2,
	UART_CMD_UPDATE_FINISH 		= 0xe3
};

int DiffTimebByUpgrade(struct timeb ST, struct timeb ET)
{
	//return milli-second
	unsigned int StartTime,StopTime;

	StartTime=(unsigned int)ST.time;
	StopTime=(unsigned int)ET.time;
	return (StopTime-StartTime)*1000+ET.millitm-ST.millitm;
}



unsigned char *memcat(unsigned char *dest, unsigned int dest_len, unsigned char *src, unsigned int src_len)
{
	memcpy(dest+dest_len, src, src_len);
	return dest;
}

//==========================================
// Init all share memory
//==========================================
int InitShareMemory()
{
	int result = PASS;
	int MeterSMId;

	//creat ShmSysConfigAndInfo
	if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0)
    {
		#ifdef SystemLogMessage
		printf("shmget ShmSysConfigAndInfo NG\n");
		#endif
		result = FAIL;
	}
    else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
    	#ifdef SystemLogMessage
    	printf("shmat ShmSysConfigAndInfo NG\n");
		#endif
    	result = FAIL;
   	 }
    else
    {}

   	 //creat ShmStatusCodeData
   	 if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
    {
		#ifdef SystemLogMessage
   		printf("shmget ShmStatusCodeData NG\n");
		#endif
   		result = FAIL;
	}
    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
    	#ifdef SystemLogMessage
    	printf("shmat ShmStatusCodeData NG\n");
		#endif
    	result = FAIL;
   	}
    else
    {}

    return result;
}

unsigned int crc32h(unsigned char *message) {
   int i, crc;
   unsigned int byte, c;
   const unsigned int g0 = 0xEDB88320,    g1 = g0>>1,
      g2 = g0>>2, g3 = g0>>3, g4 = g0>>4, g5 = g0>>5,
      g6 = (g0>>6)^g0, g7 = ((g0>>6)^g0)>>1;

   i = 0;
   crc = 0xFFFFFFFF;
   while ((byte = message[i]) != 0) {    // Get next byte.
      crc = crc ^ byte;
      c = ((crc<<31>>31) & g7) ^ ((crc<<30>>31) & g6) ^
          ((crc<<29>>31) & g5) ^ ((crc<<28>>31) & g4) ^
          ((crc<<27>>31) & g3) ^ ((crc<<26>>31) & g2) ^
          ((crc<<25>>31) & g1) ^ ((crc<<24>>31) & g0);
      crc = ((unsigned)crc >> 8) ^ c;
      i = i + 1;
   }
   return ~crc;
}

uint32_t crc32(uint8_t *data, unsigned int length)
{
    uint8_t i;
    uint32_t cnt = 0;
    uint32_t crc = 0xffffffff;  // Initial value
    while(length--)
    {
    	if(cnt>33 && cnt<48) {
    		data++;
    	}else {
    		crc ^= *data++;         // crc ^= *data; data++;
			for (i = 0; i < 8; ++i)
			{
				if (crc & 1)
					crc = (crc >> 1) ^ 0xEDB88320;// 0xEDB88320= reverse 0x04C11DB7
				else
					crc = (crc >> 1);
			}
    	}
    	cnt++;
    }
    return ~crc;
}

int Upgrade_Flash(unsigned int Type,char *SourcePath, struct SysConfigAndInfo *SysInfo)
{
	int result = FAIL;

	long int MaxLen=48*1024*1024, ImageLen=0;
	unsigned int ImageCRC=0, DataLength=0;
	int wrd,fd;

	// space max size set

	switch(Type)
	{
		case CSU_BOOTLOADER:
			MaxLen = 1*1024*1024;
			printf("Image type: U-Boot\r\n");
			break;
		case CSU_KERNEL_CONFIGURATION:
			MaxLen = 0.5*1024*1024;
			printf("Image type: DTB\r\n");
			break;
		case CSU_KERNEL_IMAGE:
			MaxLen = 10*1024*1024;
			printf("Image type: Kernel\r\n");
			break;
		case CSU_ROOT_FILE_SYSTEM:
			MaxLen = 48*1024*1024;
			printf("Image type: Root fs\r\n");
			break;
		case CSU_USER_CONFIGURATION:
			MaxLen = 6*1024*1024;
			printf("Image type: Config\r\n");
			break;
		default:
			break;
	}

	fd = open(SourcePath, O_RDONLY);
	if(fd < 0)
	{
		printf("UpdateRootfs NG - can not open rootfs\n");
		return result;
	}

	unsigned char *ptr = malloc(MaxLen); //-48 is take out the header
	memset(ptr,0xFF,MaxLen);  //-48 is take out the header

	//get the image length
	ImageLen = read(fd,ptr,MaxLen);
	close(fd);
	//read out the header
	int i;
	int isModelNameOK = PASS;
	for(i=0;i<16;i++) {
		if(SysInfo->SysConfig.ModelName[i] != ptr[i]){
			isModelNameOK = FAIL;
		}
	}

	if(isModelNameOK == FAIL) {
		printf("The model name is wrong...\n");
		return result;
	}else {
		// check if the firmware type is correct
		printf(">> Model name checked.\n");
		if(Type == (((unsigned int)ptr[16])<<24 | ((unsigned int)ptr[17])<<16 | ((unsigned int)ptr[18])<<8 | ((unsigned int)ptr[19]))) {
			printf(">> Image type checked.\n");
			if((ImageLen-48) == (((unsigned int)ptr[20])<<24 | ((unsigned int)ptr[21])<<16 | ((unsigned int)ptr[22])<<8 | ((unsigned int)ptr[23]))) {
				DataLength = ImageLen-48;
				printf(">> Image length checked...%d\r\n",DataLength);

				// get CRC in the header
				ImageCRC = ((unsigned int)ptr[34])<<24 | ((unsigned int)ptr[35])<<16 | ((unsigned int)ptr[36])<<8 | ((unsigned int)ptr[37]);

				printf("ImageCRC: 0x%x\r\n",ImageCRC);
				printf("crc32: 0x%x\r\n",crc32(ptr,ImageLen/*34+DataLength*/));
				// calculate the image CRC
				printf("Calculating CRC-32...\n");
				if(crc32(ptr,ImageLen/*34+DataLength*/) == ImageCRC) {
					printf(">> CRC-32 checked.\n");

					// Write image to target flash block
					switch(Type)
					{
						/*case FLASH_IMAGE_TYPE_SPL:
							fd = open("/dev/mtdblock0", O_RDWR);
							if (fd < 0)
							{
								DEBUG_ERROR("Can not open mtdblock0\r\n");
								result = FAIL;
							}
							else
							{
								// Write image to flash
								DEBUG_INFO("Writing image to mtdblock0...\n");
								wrd=write(fd, ptr, DataLength);
								close(fd);
								DEBUG_INFO(">> mtdblock0 Written length: 0x%x\r\n", wrd);
								if(wrd != DataLength)
								{
									result = FAIL;
								}
								else
								{
									result = PASS;
								}
							}
							break;*/
						case CSU_BOOTLOADER:
							fd = open("/dev/mtdblock1", O_RDWR);
							if (fd < 0)
							{
								printf("Can not open mtdblock1\r\n");
								result = FAIL;
							}
							else
							{
								// Write image to flash
								printf("Writing image to mtdblock1...\n");
								wrd=write(fd, ptr+48, DataLength);
								close(fd);
								printf(">> mtdblock1 written length: 0x%x\r\n", wrd);
								if(wrd != DataLength)
								{
									result = FAIL;
								}
								else
								{
									// Open flash target mtdblock
									fd = open("/dev/mtdblock3", O_RDWR);
									if (fd < 0)
									{
										printf("Can not open mtdblock3\r\n");
										result = FAIL;
									}
									else
									{
										// Write image to flash
										printf("Writing image to mtdblock3...\n");
										wrd=write(fd, ptr, DataLength);
										close(fd);
										printf(">> mtdblock3 written length: 0x%x\r\n", wrd);
										if(wrd != DataLength)
										{
											result = FAIL;
										}
										else
										{
											result = PASS;
										}
									}
								}
							}
							break;
						case CSU_KERNEL_CONFIGURATION:
							fd = open("/dev/mtdblock4", O_RDWR);
							if (fd < 0)
							{
								printf("Can not open mtdblock4\r\n");
								result = FAIL;
							}
							else
							{
								// Write image to flash
								printf("Writing image to mtdblock4...\n");
								wrd=write(fd, ptr+48, DataLength);
								close(fd);
								printf(">> mtdblock4 written length: 0x%x\r\n", wrd);
								if(wrd != DataLength)
								{
									result = FAIL;
								}
								else
								{
									// Open flash target mtdblock
									fd = open("/dev/mtdblock5", O_RDWR);
									if (fd < 0)
									{
										printf("Can not open mtdblock5\r\n");
										result = FAIL;
									}
									else
									{
										// Write image to flash
										printf("Writing image to mtdblock5...\n");
										wrd=write(fd, ptr+48, DataLength);
										close(fd);
										printf(">> mtdblock5 written length: 0x%x\r\n", wrd);
										if(wrd != DataLength)
										{
											result = FAIL;
										}
										else
										{
											result = PASS;
										}
									}
								}
							}
							break;
						case CSU_KERNEL_IMAGE:
							fd = open("/dev/mtdblock6", O_RDWR);
							if (fd < 0)
							{
								printf("Can not open mtdblock6\r\n");
								result = FAIL;
							}
							else
							{
								// Write image to flash
								printf("Writing image to mtdblock6...\n");
								wrd=write(fd, ptr+48, DataLength);
								close(fd);
								printf(">> mtdblock6 written length: 0x%x\r\n", wrd);
								if(wrd != DataLength)
								{
									result = FAIL;
								}
								else
								{
									// Open flash target mtdblock
									fd = open("/dev/mtdblock7", O_RDWR);
									if (fd < 0)
									{
										printf("Can not open mtdblock7\r\n");
										result = FAIL;
									}
									else
									{
										// Write image to flash
										printf("Writing image to mtdblock7...\n");
										wrd=write(fd, ptr+48, DataLength);
										close(fd);
										printf(">> mtdblock7 written length: 0x%x\r\n", wrd);
										if(wrd != DataLength)
										{
											result = FAIL;
										}
										else
										{
											result = PASS;
										}
									}
								}
							}
							break;
						case CSU_ROOT_FILE_SYSTEM:
							fd = open("/dev/mtdblock8", O_RDWR);
							if(fd < 0)
							{
								printf("UpdateRootfs NG - can not open rootfs\n");
								result = FAIL;
							}
							else
							{
								printf("Writing image to mtdblock8...\n");
								wrd=write(fd, ptr+48, DataLength);
								close(fd);
								printf(">> mtdblock8 written length: 0x%x\r\n", wrd);
								if(wrd!=DataLength)
								{
									result = FAIL;
								}
								else
								{
									fd = open("/dev/mtdblock9", O_RDWR);
									if(fd < 0)
									{
										printf("UpdateRootfs NG - can not open rootfs\n");
										result = FAIL;
									}

									printf("Writing image to mtdblock9...\n");
									wrd=write(fd, ptr+48, DataLength);
									close(fd);
									printf(">> mtdblock9 written length: 0x%x\r\n", wrd);
									if(wrd!=DataLength)
									{
										result = FAIL;
									}
									else
									{
										result = PASS;
									}
								}
							}
							break;
						case CSU_USER_CONFIGURATION:
							// Open flash target mtdblock
							fd = open("/dev/mtdblock10", O_RDWR);
							if (fd < 0)
							{
								printf("Can not open mtdblock10\r\n");
								result = FAIL;
							}
							else
							{
								// Write image to flash
								printf("Writing image to mtdblock10...\n");
								wrd=write(fd, ptr+48, DataLength);
								close(fd);
								printf(">> mtdblock10 written length: 0x%x\r\n", wrd);
								if(wrd != DataLength)
								{
									result = FAIL;
								}
								else
								{
									// Open flash target mtdblock
									fd = open("/dev/mtdblock11", O_RDWR);
									if (fd < 0)
									{
										printf("Can not open mtdblock11\r\n");
										result = FAIL;
									}
									else
									{
										// Write image to flash
										printf("Writing image to mtdblock11...\n");
										wrd=write(fd, ptr+48, DataLength);
										close(fd);
										printf(">> mtdblock11 written length: 0x%x\r\n", wrd);
										if(wrd != DataLength)
										{
											result = FAIL;
										}
										else
										{
											result = PASS;
										}
									}
								}
							}
							break;
						default:
							break;
					}
				}
			}
		}
	}

	free(ptr);
	if(result == PASS)
		printf("Update image success\r\n");
	else
		printf("Update image fail\r\n");

	return result;
}

//================================================
// UART update function
//================================================
int uart_tranceive(int fd, unsigned char* cmd, unsigned char* rx, int len, unsigned char needErase)
{
	//sleep(2); //required to make flush work, for some reason
	/*
	 TODO: RS-485 direction control logic maybe need operate here
	 * */
	tcflush(fd,TCIOFLUSH);
	printf("tx len = %d \n", len);
	if(write(fd, cmd, len) >= len)
	{
		len = 0;
		if (needErase == 0x01)
			sleep(5);
		else
			usleep(500000);
		len = read(fd, rx, 512);
	}
	else
	{
		#ifdef SystemLogMessage
		printf("Serial command %s response fail.\n", cmd);
		#endif
	}

	return len;
}

unsigned char uart_update_start(unsigned char fd, unsigned char targetAddr, unsigned int crc32)
{
	unsigned char result = FAIL;
	unsigned char tx[11] = {0xaa, 0x00, targetAddr, UART_CMD_UPDATE_START, 0x04, 0x00, (crc32>>0)&0xff, (crc32>>8)&0xff, (crc32>>16)&0xff, (crc32>>24)&0xff, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[10] = chksum;

	if(uart_tranceive(fd, tx, rx, 11, 0x01) >0)
	{
		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
			printf("UART target is ready for upgrade.\n");
		}else {
			printf("UART target is not ready...\n");
		}
	}else {
		printf("UART receiving update start ack failed...\n");
	}

	return result;
}

unsigned char uart_update_abord(unsigned char fd, unsigned char targetAddr)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, UART_CMD_UPDATE_ABORD, 0x04, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;


	if(uart_tranceive(fd, tx, rx, 7, 0x00) >0)
	{
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
			printf("UART target abord update OK.\n");
		}else {
			printf("UART target abord update failed.\n");
		}
	}else {
		printf("UART receiving update abord ack failed...\n");
	}

	return result;
}

unsigned char uart_update_transfer(unsigned char fd, unsigned char targetAddr, unsigned int startAddr, unsigned char *data, unsigned short int length)
{
	unsigned char result = FAIL;
	unsigned char tx[11 + length];
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	tx[0] = 0xaa;
	tx[1] = 0x00;
	tx[2] = targetAddr;
	tx[3] = UART_CMD_UPDATE_TRANSFER;
	tx[4] = (4 + length) & 0xff;
	tx[5] = ((4 + length)>>8) & 0xff;
	tx[6] = (startAddr>>0) & 0xff;
	tx[7] = (startAddr>>8) & 0xff;
	tx[8] = (startAddr>>16) & 0xff;
	tx[9] = (startAddr>>24) & 0xff;
	memcpy(tx+10, data, length);

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[sizeof(tx)-1] = chksum;

	if(uart_tranceive(fd, tx, rx, 11 + length,0x00) >0)
	{
		chksum = 0;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
			printf("Data transfer OK.\n");
		}else {
			printf("Data transfer failed.\n");
		}
	}else {
		printf("UART receiving update transfer ack failed...\n");
	}

	return result;
}

unsigned char uart_update_finish(unsigned char fd, unsigned char targetAddr)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, UART_CMD_UPDATE_FINISH, 0x04, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;


	if(uart_tranceive(fd, tx, rx, 7,0x00) >0)
	{
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
			printf("UART update finish check OK...\n");
		}else {
			printf("UART update finish check failed...\n");
		}
	}else {
		printf("UART receiving update finish ack failed...\n");
	}

	return result;
}

int Upgrade_UART(unsigned char uartfd,unsigned int Type,unsigned char TargetAddr,char *SourcePath,struct SysConfigAndInfo *SysInfo)
{
	int result = FAIL;

	long int MaxLen=48*1024*1024, ImageLen=0;
	unsigned int ImageCRC=0, DataLength=0;
    int fd;

	fd = open(SourcePath, O_RDONLY);
	if(fd < 0)
	{
		printf("UpdateRootfs NG - can not open rootfs\n");
		return result;
	}

	unsigned char *ptr = malloc(MaxLen); //-48 is take out the header
	memset(ptr,0xFF,MaxLen);  //-48 is take out the header

	//get the image length
	ImageLen = read(fd,ptr,MaxLen);
	close(fd);
	//read out the header
	int i;
	int isModelNameOK = PASS;
	for(i=0;i<16;i++) {
		if(SysInfo->SysConfig.ModelName[i] != ptr[i]){
			isModelNameOK = FAIL;
		}
	}

	if(isModelNameOK == FAIL) {
		printf("The model name is wrong...\n");
		return result;
	}else {
		// check if the firmware type is correct
		printf(">> Model name checked.\n");
		if(Type == (((unsigned int)ptr[16])<<24 | ((unsigned int)ptr[17])<<16 | ((unsigned int)ptr[18])<<8 | ((unsigned int)ptr[19]))) {
			printf(">> Image type checked.\n");
			if((ImageLen-48) == (((unsigned int)ptr[20])<<24 | ((unsigned int)ptr[21])<<16 | ((unsigned int)ptr[22])<<8 | ((unsigned int)ptr[23]))) {
				DataLength = ImageLen-48;
				printf(">> Image length checked...%d\r\n",DataLength);

				// get CRC in the header
				ImageCRC = ((unsigned int)ptr[34])<<24 | ((unsigned int)ptr[35])<<16 | ((unsigned int)ptr[36])<<8 | ((unsigned int)ptr[37]);

				printf("ImageCRC: 0x%x\r\n",ImageCRC);
				printf("crc32: 0x%x\r\n",crc32(ptr,ImageLen/*34+DataLength*/));
				// calculate the image CRC
				printf("Calculating CRC-32...\n");
				if(crc32(ptr,ImageLen/*34+DataLength*/) == ImageCRC) {
					printf(">> CRC-32 checked.\n");

					if(uart_update_start(uartfd, TargetAddr, crc32(ptr+48,DataLength))==PASS) {
						printf("uart_update_start pass.\n");
						int CNT_Fail = 0;
						int CNT_Trans = 0;
						do{
							if(uart_update_transfer(uartfd, TargetAddr, 0x080A0000 + CNT_Trans*1024, ptr+48+(CNT_Trans*1024), 1024)==PASS) {
								printf("uart_update_transfer pass.\n");
								CNT_Fail = 0;
								CNT_Trans++;
							}else {
								CNT_Fail++;
							}
						}while(DataLength-(CNT_Trans*1024)>0 && CNT_Fail<1);

						if(CNT_Fail>=3) {
							uart_update_abord(uartfd, TargetAddr);
						}else if(uart_update_finish(uartfd, TargetAddr)==PASS) {
							result = PASS;
						}
					}
					else
					{
						printf("UART asked update failed.\n");
					}
				}
			}
		}
	}
	free(ptr);
	return result;
}

int CAN_Download_REQ(int canfd,unsigned int Slave_Addr, unsigned int imageSize)
{
	struct can_frame frame;
	frame.can_id = (0x00000E00 + Slave_Addr) | 0x80000000;		//extended frame : �� 31 ��n�� 1
	frame.can_dlc = 0x07;

	frame.data[0] = 0x04;  //0x01:Configuration file, 0x02:Bootloader of primary side MCU, 0x03:Firmware (main code) of primary side MCU, 0x04:Bootloader of secondary side MCU, 0x05:Firmware (main code) of secondary side MCU
	frame.data[1] = (imageSize>>0)&0xff;  //Total 384 KBytes
	frame.data[2] = (imageSize>>8)&0xff;  //Total 384 KBytes
	frame.data[3] = (imageSize>>16)&0xff;  //Total 384 KBytes
	frame.data[4] = (imageSize>>24)&0xff;  //Total 384 KBytes
	frame.data[5] = 0x10;  //16 blocks
	frame.data[6] = 0x18;  //24 KBytes

	printf(	"File size = %x, %d \n", imageSize, imageSize);
	write(canfd, &frame, sizeof(struct can_frame));
	if (canfd > 0)
	{
		struct timeval timer;
		gettimeofday(&timer, NULL);
		while (GetTimeoutValue(timer) < 5000000)
		{
			struct can_frame frame;
			int len;
			len = read(canfd, &frame, sizeof(struct can_frame));
			if (len >= 0)
			{
				printf(	"*****************************CAN_Download_REQ Get***************************** \n");
				printf("data = %x \n", frame.can_id & CAN_EFF_MASK);
				if (((int)(frame.can_id & CAN_EFF_MASK & 0xFFFFFF00) ==  0x08000E00) && frame.data[0] == 1)
				{
					printf("PASS \n");
					return PASS;
				}
			}

		}
	}
	return FAIL;
}

int CAN_Start_BLK_Trans(int canfd,unsigned int Slave_Addr,unsigned int Block_No,unsigned int Block_Checksum)
{
	struct can_frame frame;
	frame.can_id = (0x00000F00 + Slave_Addr) | 0x80000000;		//extended frame : �� 31 ��n�� 1
	frame.can_dlc = 0x02;

	frame.data[0] = Block_No;
	frame.data[1] = Block_Checksum;

	printf("Block_No = %x, Block_Checksum = %x \n", Block_No, Block_Checksum);
	write(canfd, &frame, sizeof(struct can_frame));
	usleep(100000);

	if (canfd > 0)
	{
		struct timeval timer;
		gettimeofday(&timer, NULL);
		while (GetTimeoutValue(timer) < 1000000)
		{
			struct can_frame frame;
			int len;
			len = read(canfd, &frame, sizeof(struct can_frame));
			if(len >= 0)
			{
				printf("*****************************CAN_Start_BLK_Trans Get***************************** \n");
				printf("data = %x \n", frame.can_id & CAN_EFF_MASK); // extended frame ����T�ݭn���z�L CAN_EFF_MASK �~�|����u������T
				if(((int)(frame.can_id & CAN_EFF_MASK & 0xFFFFFF00) ==  0x08000F00) &&frame.data[0] == 1)
				{
					printf("CAN_Start_BLK_Trans PASS \n");
					return PASS;
				}
			}
		}

	}
	return FAIL;
}

void CAN_Data_Trans(int canfd,unsigned int Slave_Addr,long Data_num,unsigned char Data[])
{
	struct can_frame frame;
	frame.can_id = (0x00001000 + Slave_Addr) | 0x80000000;		//extended frame : �� 31 ��n�� 1
	frame.can_dlc = 0x08;

	frame.data[0] = Data[Data_num+0];
	frame.data[1] = Data[Data_num+1];
	frame.data[2] = Data[Data_num+2];
	frame.data[3] = Data[Data_num+3];
	frame.data[4] = Data[Data_num+4];
	frame.data[5] = Data[Data_num+5];
	frame.data[6] = Data[Data_num+6];
	frame.data[7] = Data[Data_num+7];

//	printf("%02x %02x %02x %02x %02x %02x %02x %02x \n", frame.data[0], frame.data[1], frame.data[2], frame.data[3],
//			frame.data[4], frame.data[5], frame.data[6], frame.data[7]);
	write(canfd, &frame, sizeof(struct can_frame));
	usleep(2000);
}

int CAN_Download_FIN(int canfd,unsigned int Slave_Addr)
{
	struct can_frame frame;
	frame.can_id = (0x00001100 + Slave_Addr) | 0x80000000;		//extended frame
	frame.can_dlc = 0x00;

	write(canfd, &frame, sizeof(struct can_frame));
	usleep(10000);
	if (canfd > 0)
	{
		struct timeval timer;
		gettimeofday(&timer, NULL);
		while (GetTimeoutValue(timer) < 1000000)
		{
			struct can_frame frame;
			int len;
			len = read(canfd, &frame, sizeof(struct can_frame));
			if(len >= 0)
			{
				printf("data = %x \n", frame.can_id & CAN_EFF_MASK); // extended frame
				if(((int)(frame.can_id & CAN_EFF_MASK & 0xFFFFFF00) ==  0x08001100) && frame.data[0] == 1)
				{
					printf("CAN_Download_FIN PASS \n");
					return PASS;
				}
			}
		}
	}
	return FAIL;
}

int Checksum_Cal(unsigned int StartAdress,unsigned int length, unsigned char Data[])
{
	unsigned char checksum = 0x00;

	for(unsigned int i = 0; i < length; i++)
	{
		//printf("value = %x \n", Data[StartAdress + i]);
		checksum ^= Data[StartAdress + i];
		//printf("checksum = %x \n", checksum);
	}

	return checksum;
}

int Upgrade_CAN(int canfd,unsigned int Type,unsigned char TargetAddr,char *SourcePath,struct SysConfigAndInfo *SysInfo)
{
	int result = FAIL;

	long int MaxLen=48*1024*1024, ImageLen=0;
	unsigned int ImageCRC=0, DataLength=0;
	int fd;

	fd = open(SourcePath, O_RDONLY);
	if(fd < 0)
	{
		printf("UpdateRootfs NG - can not open rootfs\n");
		return result;
	}

	unsigned char *ptr = malloc(MaxLen); //-48 is take out the header
	memset(ptr,0xFF,MaxLen);  //-48 is take out the header

	//get the image length
	ImageLen = read(fd,ptr,MaxLen);
	close(fd);
	//read out the header
	int i;
	int isModelNameOK = PASS;
	for(i=0;i<16;i++) {
		if(SysInfo->SysConfig.ModelName[i] != ptr[i]){
			isModelNameOK = FAIL;
		}
	}

	if(isModelNameOK == FAIL) {
		printf("The model name is wrong...\n");
		return result;
	}else {
		// check if the firmware type is correct
		printf(">> Model name checked.\n");
		if(Type == (((unsigned int)ptr[16])<<24 | ((unsigned int)ptr[17])<<16 | ((unsigned int)ptr[18])<<8 | ((unsigned int)ptr[19]))) {
			printf(">> Image type checked.\n");
			if((ImageLen-48) == (((unsigned int)ptr[20])<<24 | ((unsigned int)ptr[21])<<16 | ((unsigned int)ptr[22])<<8 | ((unsigned int)ptr[23]))) {
				DataLength = ImageLen-48;
				printf(">> Image length checked...%d\r\n",DataLength);

				// get CRC in the header
				ImageCRC = ((unsigned int)ptr[34])<<24 | ((unsigned int)ptr[35])<<16 | ((unsigned int)ptr[36])<<8 | ((unsigned int)ptr[37]);

				printf("ImageCRC: 0x%x\r\n",ImageCRC);
				printf("crc32: 0x%x\r\n",crc32(ptr,ImageLen/*34+DataLength*/));
				// calculate the image CRC
				printf("Calculating CRC-32...\n");
				if(crc32(ptr,ImageLen/*34+DataLength*/) == ImageCRC) {
					printf(">> CRC-32 checked.\n");

					unsigned int Checksum[16];

					for(int i=0;i<16;i++)
					{
						Checksum[i] = Checksum_Cal(i * 24576, 24576, ptr + 48);
					}

					if(CAN_Download_REQ(canfd, TargetAddr, DataLength) == PASS)
					{
						for(int block = 1; block <= 16; block++)
						{
							if(CAN_Start_BLK_Trans(canfd, TargetAddr, block, Checksum[block - 1]) == PASS)
							{
								for(int times = 0; times < 3072; times++)
								{
									CAN_Data_Trans(canfd, TargetAddr, ((block - 1) * 24576 + times * 8), ptr + 48);
								}
								printf(" \n");
								printf(" \n");
							}
							else
							{
								free(ptr);
								return result;
							}
						}

						if (CAN_Download_FIN(canfd, TargetAddr) == PASS)
							result = true;
					}
				}
			}
		}
	}
	free(ptr);
	return result;
}