upgrade.c

一种操作系统源码核

#include "Page1.h"
#include "PalmChip.h"
#include "protocol.h"

#define TCP_UPGRADE_SIZE	128

extern BOOLEAN Key_bSetupMode;

// upgrade data

// Tcp connection data
static XCHAR _pTcbData[TCB_LENGTH];
static BOOLEAN _bDataAcked;

static DCHAR _iCurMsgPos;
static PXCHAR _pSendData;
static DCHAR _iCodePage, _iSdramLo, _iInputSdramHi, _iOutputSdramHi;
static BOOLEAN _bSdramFull;

void UpgradeInitialize()
{
	// Tcp init
	_bDataAcked = TcbInit(_pTcbData, TCP_LOCAL_PORT_HIGH, TCP_UPGRADE_PORT_LOW);

	// protocol init
	_iCurMsgPos = 0;
	_iCodePage = 0xff;
	_iSdramLo = 0;
	_iInputSdramHi = FILE_IN_SDRAM_HI;
//	_iOutputSdramHi = FILE_IN_SDRAM_HI;
	_iOutputSdramHi = FILE_OUT_SDRAM_HI;
	_bSdramFull = FALSE;
	_pSendData = (PXCHAR)(Sdram_pDataCache2+EP_DATA+IP_DATA+TCP_DATA);
}

void _HandleUpgradeData(UCHAR iLength, PXCHAR pData)
{
	DCHAR iFirst;

	iFirst = pData[0];
	if (iLength == 1)	// This is the indication of which page to erase
	{
		_iCodePage = iFirst;
		_iCurMsgPos = 1;
		_pSendData[0] = 0xff;
	}
	else if (iLength == 2)	// Request data from sdram
	{
		if (iFirst == 'd')	// data hint
		{
			if (_bSdramFull)
			{
				SdramRead(_iOutputSdramHi, _iSdramLo, SRAM_DMA_HALF_DWORD);
				p_memcpy_x2x(_pSendData, Sdram_pDataCache1, TCP_UPGRADE_SIZE);
				_iSdramLo ++;
				if (_iSdramLo == 0)
				{
					_iOutputSdramHi ++;
				}
				_bSdramFull = FALSE;
			}
			else
			{
				SdramRead(_iOutputSdramHi, _iSdramLo, SRAM_DMA_HALF_DWORD/2);
				p_memcpy_x2x(_pSendData, Sdram_pDataCache, TCP_UPGRADE_SIZE);
				_bSdramFull = TRUE;
			}
			_iCurMsgPos = TCP_UPGRADE_SIZE;
		}
		else if (iFirst == 's')	// settings hint
		{
			SdramReadOptions();
			if (_bSdramFull)
			{
				p_memcpy_x2x(_pSendData, Sdram_pDataCache1, TCP_UPGRADE_SIZE);
				_bSdramFull = FALSE;
			}
			else
			{
				p_memcpy_x2x(_pSendData, Sdram_pDataCache, TCP_UPGRADE_SIZE);
				_bSdramFull = TRUE;
			}
			_iCurMsgPos = TCP_UPGRADE_SIZE;
		}
	}
	else	// Data to sdram
	{
		if (_bSdramFull)
		{
			SdramRead(FLAGS_SDRAM_HI, UPGRADE_TMP_SDRAM_LO, SRAM_DMA_HALF_DWORD/2);
			p_memcpy_x2x(Sdram_pDataCache1, pData, TCP_UPGRADE_SIZE);
			SdramWrite(_iInputSdramHi, _iSdramLo, SRAM_DMA_HALF_DWORD);
			_iSdramLo ++;
			if (_iSdramLo == 0)
			{
				_iInputSdramHi ++;
			}
			_bSdramFull = FALSE;
		}
		else
		{
			p_memcpy_x2x(Sdram_pDataCache, pData, TCP_UPGRADE_SIZE);
			SdramWrite(FLAGS_SDRAM_HI, UPGRADE_TMP_SDRAM_LO, SRAM_DMA_HALF_DWORD/2);
			_bSdramFull = TRUE;
		}
		_iCurMsgPos = 1;
		_pSendData[0] = 0xff;
	}
}

void _HandleUpgrade()
{
#ifndef _USE_DISPLAY
	if (!Key_bSetupMode)	goto End;	// Only perform upgrade in setup mode
#endif
	if (_iCodePage == 0xff)	goto End;
	if (_iCodePage == 0)	goto End;	// Do not upgrade page0 in page1

	SdramMove(UPGRADE_SDRAM_HI, FILE_IN_SDRAM_HI);
	Sdram_pDataCache[FLAG_UPGRADE_MODE] = TCPIP_UPGRADE_MODE;
	Sdram_pDataCache[FLAG_UPGRADE_PAGE] = _iCodePage;
	Sdram_pDataCache[FLAG_UPGRADE_SIZE] = _iSdramLo;
	SdramWrite(FLAGS_SDRAM_HI, FLAGS_SDRAM_LO, FLAGS_DWORD_SIZE);
	OnSwitchUpgrade();
End:
	UpgradeInitialize();	// re-initialize all since we are only to load data to sdram
}

void _HandleConnect()
{
	_iCodePage = 0xff;
	p_memset_x(Sdram_pDataCache, 0, 4);
	SdramWrite(FLAGS_SDRAM_HI, FLAGS_SDRAM_LO, FLAGS_DWORD_SIZE);
}

BOOLEAN UpgradeRun()
{
	if (!TcbCheckData(_pTcbData))
		return FALSE;

	SdramRead2(UPGRADE_SDRAM_LO);
	TcbRun(_pTcbData);
	if (Tcp_bAcceptEvent)
	{
		TcpPrepareData(Sdram_pDataCache2);
		Tcp_bAcceptEvent = FALSE;
	}
	if (Tcp_bConnectEvent)
	{
		Tcp_bConnectEvent = FALSE;
		_HandleConnect();
	}
    if (Tcp_bDataEvent)
    {
        // Handle upgrade data here
		_HandleUpgradeData(Adapter_iReceiveLen - Tcp_iReceiveHeaderLen, (PXCHAR)(Adapter_pReceivePacket + Tcp_iReceiveHeaderLen));
		Tcp_bDataEvent = FALSE;
    }
    if (Tcp_bCloseEvent)
    {
		TcpClose(_pTcbData);	// Just call TcpClose to ensure, it is ok to call it repeatly
		Tcp_bCloseEvent = FALSE;
	}
	_bDataAcked = TcpSend(Sdram_pDataCache2, _iCurMsgPos);
	_iCurMsgPos = 0;
	SdramWrite2(UPGRADE_SDRAM_LO);

    if (Tcp_bFreeEvent)
    {
		Tcp_bFreeEvent = FALSE;
		_HandleUpgrade();
	}
	return TRUE;
}

void UpgradeHandleTimer()
{
	if (_bDataAcked)	return;
	SdramRead2(UPGRADE_SDRAM_LO);
	if (TcbHandleTimer(_pTcbData, Sdram_pDataCache2))
	{
		return;
	}

	// Handle time out failure
	UpgradeInitialize();	// re-initialize all
}