upgrade_lg.c

M3355的源代码

				//mark 40315
				RebootSystem();
//				SPRINTF("<<<<<<<< UpgradeFlash OK\r\n");
				return TRUE;
			}
		}
	}
	//mark 40315
//	ShowUpgInfo(UPGRADE_WARNING,2);
//	SPRINTF("<<<<<<<< UpgradeFlash fail\r\n");
	return FALSE;
}

BOOL (*p_UpgradeFlash)(BYTE* buffer, DWORD ROMSize);
BOOL UpgradeFlash(BYTE* buffer, DWORD ROMSize)
{
	p_UpgradeFlash = UpgradeFlash_ram;
	return (*p_UpgradeFlash)(buffer, ROMSize);
}

//////////////////////////////////////////////////////////////////////
//
// Read Data for upgrade
//

void ResetFrameBufObj(FRAME_BUFFER_OBJ* pFobj)
{
	pFobj->dwDataSize = 0;
	pFobj->dwCurPos   = 0;
}

//rewind the position
void RewindFrameBufObj(FRAME_BUFFER_OBJ* pFobj)
{
	pFobj->dwCurPos  = 0;
}

//write data into the frame buffer object
//return value: size written indeed.
DWORD WriteFrameBufObj(LPBYTE pBuf, DWORD dwSize,
		FRAME_BUFFER_OBJ* pFobj)
{
	LPBYTE pCur = pBuf;
	LPBYTE pAddr;	//addr of frame buffer
	DWORD dwCurLine;
	DWORD dwCurLineOffset;
	DWORD dwCurLineLeft;
	DWORD dwSizeToWrite;
	int   i;
	DWORD dwRes = dwSize;

	if (pFobj->dwSize == pFobj->dwDataSize
		|| dwSize > (pFobj->dwSize - pFobj->dwDataSize))
	{
		PRINTF("Full now!\n");
		return 0;
	}

	//whole line is used fully,
	//that's the buffer is continuous
	if (pFobj->dwLineSize == pFobj->dwLineSizeOffset)
	{
		pAddr = (LPBYTE)(pFobj->dwStartAddr	+ pFobj->dwCurPos);
		for (i=0; i<dwSize; i++)
		{
			*pAddr++ = *pCur++;
		}

		pFobj->dwDataSize += dwSize;

		pFobj->dwCurPos += dwSize;
		return dwRes;
	}

	dwCurLine = pFobj->dwCurPos / pFobj->dwLineSize;
	dwCurLineOffset = pFobj->dwCurPos % pFobj->dwLineSize;
	dwCurLineLeft = pFobj->dwLineSize - dwCurLineOffset;
	pAddr = (LPBYTE)(pFobj->dwStartAddr	\
					 + dwCurLine * pFobj->dwLineSizeOffset	\
					 + dwCurLineOffset);

	while (dwSize > 0)
	{
		if (dwCurLineLeft == 0)
		{
			dwCurLine ++;
			dwCurLineOffset = 0;
			dwCurLineLeft = pFobj->dwLineSize;
			pAddr = (LPBYTE)(pFobj->dwStartAddr + dwCurLine * pFobj->dwLineSizeOffset);
		}

		dwSizeToWrite = (dwCurLineLeft>dwSize)?dwSize:dwCurLineLeft;

		for (i=0; i<dwSizeToWrite; i++)
		{
			*pAddr++ = *pCur++;
		}
		
		dwSize -= dwSizeToWrite;
		dwCurLineLeft -= dwSizeToWrite;
		dwCurLineOffset += dwSizeToWrite;
		pFobj->dwDataSize += dwSizeToWrite;
	}

	pFobj->dwCurPos  = pFobj->dwDataSize;
	return dwRes;
}

DWORD ReadFrameBufObj(LPBYTE pBuf, DWORD dwSize,
		FRAME_BUFFER_OBJ* pFobj)
{
	LPBYTE pCur = pBuf;
	LPBYTE pAddr;	//addr of frame buffer
	DWORD dwCurLine;
	DWORD dwCurLineOffset;
	DWORD dwCurLineLeft;
	DWORD dwSizeToRead;
	int   i;
	DWORD dwRes = dwSize;

	if (dwSize == 0
		|| pFobj->dwCurPos >= pFobj->dwDataSize)
		return 0;
	
	if (dwSize > (pFobj->dwDataSize - pFobj->dwCurPos))
	{
		dwSize = pFobj->dwDataSize - pFobj->dwCurPos;
		dwRes  = dwSize;
	}

	//whole line is used fully,
	//that's the buffer is continuous
	if (pFobj->dwLineSize == pFobj->dwLineSizeOffset)
	{
		pAddr = (LPBYTE)(pFobj->dwStartAddr	+ pFobj->dwCurPos);
		for (i=0; i<dwRes; i++)
		{
			*pCur++ = *pAddr++;
		}

		pFobj->dwCurPos += dwRes;
		return dwRes;
	}

	dwCurLine = pFobj->dwCurPos / pFobj->dwLineSize;
	dwCurLineOffset = pFobj->dwCurPos % pFobj->dwLineSize;
	dwCurLineLeft = pFobj->dwLineSize - dwCurLineOffset;
	pAddr = (LPBYTE)(pFobj->dwStartAddr	\
					 + dwCurLine * pFobj->dwLineSizeOffset	\
					 + dwCurLineOffset);

	while (dwSize > 0)
	{
		if (dwCurLineLeft == 0)
		{
			dwCurLine ++;
			dwCurLineOffset = 0;
			dwCurLineLeft = pFobj->dwLineSize;
			pAddr = (LPBYTE)(pFobj->dwStartAddr + dwCurLine * pFobj->dwLineSizeOffset);
		}

		dwSizeToRead = (dwCurLineLeft>dwSize)?dwSize:dwCurLineLeft;

		for (i=0; i<dwSizeToRead; i++)
		{
			 *pCur++ = *pAddr++;
		}
		
		dwSize -= dwSizeToRead;
		dwCurLineLeft -= dwSizeToRead;
		dwCurLineOffset += dwSizeToRead;
		pFobj->dwCurPos += dwSizeToRead;
	}

	return dwRes;
}

void  UpResetData()
{
	int i;

	for (i=0; i<g_bFrmObjCount; i++)
		ResetFrameBufObj(&FrameBuf[i]);
/*
#if ((UPGRADE_MODE == UPGRADE_DRAM_MODE))
	FrameBuf[0].dwStartAddr = (DWORD)APMALLOC(FLASH_SIZE);
	if (FrameBuf[0].dwStartAddr== NULL)
	{
		SPRINTF("Fatal Error: APMALLOC return NULL!\r\n");
	}
	FrameBuf[0].dwSize = 1024*1024;
	FrameBuf[0].dwLine = FrameBuf[0].dwSize / FrameBuf[0].dwLineSize;
#endif
*/
	g_bFrmObjCurNum = 0;
}

void  UpFreeData()
{
/*
#if ((UPGRADE_MODE == UPGRADE_DRAM_MODE))
	APFREE((void*)FrameBuf[0].dwStartAddr);
	FrameBuf[0].dwSize = 0;
	FrameBuf[0].dwLine = 0;
#endif
*/
}

void  UpRewindData()
{
	int i;

	for (i=0; i<g_bFrmObjCount; i++)
		RewindFrameBufObj(&FrameBuf[i]);

	g_bFrmObjCurNum = 0;
}

DWORD UpWriteData(LPBYTE pBuf, DWORD dwSize)
{
	DWORD dwWriteSize;

	dwWriteSize = WriteFrameBufObj(pBuf, dwSize, &FrameBuf[g_bFrmObjCurNum]);
	if (0 == dwWriteSize)
	{
		if (g_bFrmObjCurNum+1 < g_bFrmObjCount)
		{
			g_bFrmObjCurNum ++;
			return WriteFrameBufObj(pBuf, dwSize, &FrameBuf[g_bFrmObjCurNum]);
		}
		else
		{
			SPRINTF("Error: g_bFrmObjCurNum = %d\r\n", g_bFrmObjCurNum);
			return 0;
		}
	}
	return dwWriteSize;
}

DWORD UpReadData_ram(LPBYTE pBuf, DWORD dwSize)
{
	DWORD dwReadSize;

	dwReadSize= ReadFrameBufObj(pBuf, dwSize, &FrameBuf[g_bFrmObjCurNum]);
	if (0 == dwReadSize)
	{
		if (g_bFrmObjCurNum+1 < g_bFrmObjCount)
		{
			g_bFrmObjCurNum ++;
			return ReadFrameBufObj(pBuf, dwSize, &FrameBuf[g_bFrmObjCurNum]);
		}
		else
		{
			SPRINTF("Error: g_bFrmObjCurNum = %d\r\n", g_bFrmObjCurNum);
			return 0;
		}
	}
	return dwReadSize;
}

DWORD (*p_UpReadData)(LPBYTE pBuf, DWORD dwSize);
DWORD UpReadData(LPBYTE pBuf, DWORD dwSize)
{
	p_UpReadData = UpReadData_ram;
	return (*p_UpReadData)(pBuf, dwSize);
}


BOOL UpgradeRead(BYTE* buffer, DWORD Start, DWORD EndNum, WORD type)
{
    int j;
    ATA_EndCondition AtaRes;

    for (j=0; j<C_ATA_RETRY_TIMES; j++)
    {
        AtaRes = ReadSectorUp(buffer, Start, EndNum, type, TRUE);
        if (AtaRes!=ATAEC_Error)
        {
            break;
        }
    }

    if (AtaRes==ATAEC_OK)
        return TRUE;
    else
        return FALSE;
}

BOOL ReadROMFromDisc(char* fileName, DWORD* size)
{
    DWORD filelen, filelocation;
    DWORD totle_read_times, read_times;
    FS_FILE *fp;            /* file pointer  */
    int objnum = 0;

    BYTE* ECCBuffer = NULL;

    int index = 0;
	int i;

    SPRINTF(">>>>>>>> ReadROMFromDisc\r\n");
    ECCBuffer = APMALLOC(2352 * 16);
    if (ECCBuffer == NULL) return FALSE;    

    /* 2.Locate PRODUCT.BIN*/
    fp = FsOpen(fileName, "rb");

    if (fp != NULL)
    {
        filelocation = fp->pExtentDescript->dwExtentLocation;
        filelen = fp->pExtentDescript->dwExtentLength;
        FsClose(fp);
    }
    else
    {
        SPRINTF("not found product.bin on disc\r\n");
        return FALSE;
    }

	*size = filelen;

    totle_read_times = FLASH_SIZE / 2048 / 16;

	UpResetData();
	
    for (read_times = 0;read_times < totle_read_times;read_times++)
    {
        if ( UpgradeRead(ECCBuffer, filelocation + read_times*16, 16, C_LBA) )
        {
        	if (read_times == 0)
        	{
        		if ( (ECCBuffer[16] != 'A') ||
        			 (ECCBuffer[17] != 'L') ||
        			 (ECCBuffer[18] != 'i') )
        		{
//        			APFREE(ECCBuffer);
//					UpFreeData();
        			SPRINTF("[ERR]=ReadROMFromDisc()::Can not find signature 'ALi'\r\n");
//        			return FALSE;
        		}
        	}
        	index = read_times * 2048 * 16;

			//write to frame buffer
			if ( 0 == UpWriteData(ECCBuffer, 2048 * 16))
			{
				SPRINTF("Fatal Error: UpWriteData return 0\r\n");
			}
			SPRINTF("UpgradeRead %d OK\r\n", read_times);
        }
        else
        {
        	APFREE(ECCBuffer);
			UpFreeData();
        	SPRINTF("[ERR]=ReadROMFromDisc()::Can not read file\r\n");
        	return FALSE;
        }
    }    

	APFREE(ECCBuffer);

	UpRewindData();
//	JpegClearCache();
	
    SPRINTF("<<<<<<<< ReadROMFromDisc\r\n");
	return TRUE;
}


BOOL ROMCheckSum(BYTE* buffer, DWORD* ROMSize)
{
	DWORD ROMSum;
	DWORD size;
	DWORD i;
	DWORD index = 0;
	DWORD sum = 0;
	DWORD* ptr ;
	BYTE  Data[2048];

    SPRINTF(">>>>>>>> ROMCheckSum\r\n");
	if ( 0 == UpReadData(Data, 2048))
	{
	    SPRINTF("Error: UpReadData return 0\r\n");
		return FALSE;
	}

	ptr =(DWORD*) Data;
	*ROMSize = ptr[5];
	size = ptr[5];
	ROMSum = ptr[6];

	SPRINTF("ROM Size = 0x%X\r\n", size);
	SPRINTF("ROM sum = 0x%X\r\n", ROMSum);

	do
	{
		for (i = 0; i < 2048; i++)
		{
			if (index >= 0x20 && index < size-0x20)
				sum += Data[i];

			index++;
		}

	 	if ( 0 == UpReadData(Data, 2048))
		{
		    SPRINTF("Error: UpReadData return 0\r\n");
			return FALSE;
		}

	} while (index < size-0x20);

	SPRINTF("sum = 0x%X\r\n", sum);

	UpRewindData();

	if (sum == ROMSum)
	{
	    SPRINTF("<<<<<<<< ROMCheckSum return TRUE\r\n");
		return TRUE;
	}
	else
	{
	    SPRINTF("<<<<<<<< ROMCheckSum return FALSE\r\n");
		return FALSE;
	}
}


/////////////////////////////////////////////////////////////////////////////
//
// Flash operation
//

#if ( _FLASH_TYPE==MX1611 )

/*****************************************************************************
 Function	 : Erase_MX1611()
 Description  : Erase_MX1611
 Arguments	: None
 Return value : C_TRUE -> success
				C_FAIL -> fail
*****************************************************************************/
int Erase_MX1611()
{
    int ret;
    ret = Chip_Erase_Op();
    PRINTF("\n Erase MX1611 end!!!!!!!!!!!!!!!!!!!\n");
    return (ret);
}

/*****************************************************************************
 Function	 : Write2MX1611()
 Description  : Write2MX1611
 Arguments	: None
 Return value : C_TRUE -> success
		C_FAIL -> fail