rs232down.c

kermit protocol 嵌入式系统使用kermit协议,与pc传送文件. 可方便的使用windows 超级终端等.

#define OK			0
#define NODATA		0x1000
#define NODETECT	0x2000
#define COMERROR	0xfe00
#define ERROR		(-1)

#if 1
#define CRDR            ((volatile unsigned int *)0xFF103000)
#define CTDR            ((volatile unsigned int *)0xFF103004)
#define CSCR            ((volatile unsigned int *)0xFF10300C)
#define CSSR            ((volatile unsigned int *)0xFF103010)
#define CBBR            ((volatile unsigned int *)0xFF103014)

/* bit fields in CSCR register */
#define TIE             0x80
#define RIE             0x40
#define TE              0x20
#define RE              0x10
#define SUPH            0x08
#define TEIE            0x04

/* bit fields in CSSR register */
#define TDRE            0x80
#define RDRF            0x40
#define ORER            0x20
#define FER             0x10
#define PER             0x08
#define TEND            0x04
#endif
/*****************************************************************************
 
                             Defines
 
*****************************************************************************/

/* Symbol Definitions */

#define MAXPACKSIZ  94      /* Maximum packet size */
#define SOH         1       /* Start of header */
#define CR          13      /* ASCII Carriage Return */
#define SP          32      /* ASCII space */
#define DEL         127     /* Delete (rubout) */
#define ESCCHR      '^'     /* Default escape character for CONNECT */

#define MAXTRY      10      /* Times to retry a packet */
#define MYQUOTE     '#'     /* Quote character I will use */
#define MYPAD       0       /* Number of padding characters I will need */
#define MYPCHAR     0       /* Padding character I need (NULL) */
#define MYEOL       '\n'
#define MYSPEED     38400

#define MYTIME      10      /* Seconds after which I should be timed out */
#define MAXTIM      60      /* Maximum timeout interval */
#define MINTIM      2       /* Minumum timeout interval */


/*****************************************************************************
 
                             Enums
 
*****************************************************************************/
 
 
/*****************************************************************************
 
                             Typedefs
 
*****************************************************************************/


/*****************************************************************************
 
                             Macros
 
*****************************************************************************/
 
/*
 * tochar: converts a control character to a printable one by adding a space.
 *
 * unchar: undoes tochar.
 *
 * ctl:    converts between control characters and printable characters by
 *         toggling the control bit (ie. ^A becomes A and A becomes ^A).
 */
#define tochar(ch)  ((ch) + ' ')
#define unchar(ch)  ((ch) - ' ')
#define ctl(ch)     ((ch) ^ 64 )


/*****************************************************************************
  
                             Global Variables
 
*****************************************************************************/
 
 
/*****************************************************************************
 
                             Local Variables
 
*****************************************************************************/

static int        spsiz,              /* Maximum send packet size */
        pad,                /* How much padding to send */
        timint,             /* Timeout for foreign host on sends */
        n,                  /* Packet number */
        numtry,             /* Times this packet retried */
        oldtry,             /* Times previous packet retried */
        image,              /* -1 means 8-bit mode */
        debug,              /* indicates level of debugging output (0=none) */

        numFlashData,      /* number of bytes to be written into Flash */
        totalBytes;        /* which have been written into Flash */


static char    state,              /* Present state of the automaton */
        padchar,            /* Padding character to send */
        eol,                /* End-Of-Line character to send */
        quote,              /* Quote character in incoming data */
        recpkt[MAXPACKSIZ], /* Receive packet buffer */
        packet[MAXPACKSIZ]; /* Packet buffer */

//static UINT8  *wPtr, *orgwPtr;
static UINT8  *flashDataPtr;
static UINT16 flashData;

//extern BYTE* awData ;

static BYTE rsFlashBuff[4096];
static const BYTE* rsPtrFlashBuff = (&(rsFlashBuff[0]));
static DWORD nDataNum=0,wChkSum=0;
static DWORD bufCount=0;

#define F_STARTADDR	((DWORD)0x00000000L)
static DWORD rsFlashStartAddr =F_STARTADDR;


void rsDownloadDetect(void);
static void rsInitFlashBuff(void);
static BOOL rsFlushFlashBuff(void);
static BOOL rsData2FlashBuff(BYTE* bSrcDataPtr, int num);
static BOOL ChannelClose( void );
static BOOL ChannelOpen( void );
static BOOL ChannelSet( BYTE  data );
static BOOL ChannelGet( BYTE  *dataPtr );
static BOOL Recsw(void);
static char Rinit(void);
static char Rfile(void);
static char Rdata(void);
static void Spack( char type, int num, int len, char *data);
static char Rpack( int *len, int *num, char *data );
static void Spar( char data[] );
static void Rpar( char data[] );
static void Bufemp( char buffer[], int len);
static void Prerrpkt( char *msg );
static void DBG_MSG(UINT8 *msg);
static BOOL rs_getbyte(UINT8* bPtr);
static WORD UartCommDetect(void);


void rsDownloadDetect(void)
{
	WORD tmp;
	outbyte('d');
	outbyte('o');
	outbyte('w');
	outbyte('n');
	outbyte('?');
//	outbyte('?');
//	outbyte('?');
	for(tmp=0;tmp<5;tmp++)
		{
		outbyte('.');
		delay(10);
		if(UartCommDetect()==OK)
//		if(UartCommSubTask())
			break;
		}
	if(tmp<5)
		{
		unsigned char ch=0;
		printf("\n\n\n\n\n\n\n\n\n\n\n");
		printf("                        ********************************\n");
		printf("                        *     Flash Loader Ver1.01     *\n");
		printf("                        *            R&D Pd-tech       *\n");
		printf("                        *     ㊣      2004.11.27       *\n");
		printf("                        ********************************\n");
		printf("\n\n\n\n\n\n\n\n");
		printf("\n\n\n");
		printf("... Are You sure to erase the Flash-Memory? (y/n)\n");
		ch =inbyte();
		while(ch=='r' || ch=='R') ch =inbyte();

		if(ch == 'Y' || ch=='y')
			{
//			BYTE tmp_uch;
		    ter_tsk(TASK_ID_UI);
		    ter_tsk(TASK_ID_FP);
		    ter_tsk(TASK_ID_PE);
		    ter_tsk(TASK_ID_DVDENG);
		    ter_tsk(TASK_ID_VOBU);
		    ter_tsk(TASK_ID_ATA);
		    ter_tsk(TASK_ID_SERVO);
			
			DisInt();
//			while((rs_getbyte(&tmp_uch)==OK));
//			printf("Start Uart download...\n");
			rsFlashStartAddr =F_STARTADDR;
			printf("\n\nok.\n\n\n");
			printf("Flash-Memory Erasing ...\n");
			if (Erase_Flash() == FALSE)
			{
				printf("Flash-Memory Erase Failure.\n");
//			    return 0;
			}
			printf("Flash-Memory Erased OK.\n");
			printf("\n\n\n\n\nReady to receive bin-file to updata flash rom\n");
			printf("Please Send bin-file by kermit protocol. \n\n\n");
			outbyte('*');
			outbyte('*');
			if(Recsw())
				{
                printf("\n\n\nKermit File Transfering Completed.\n\n");
                printf("File Size: %d Bytes,  CheckSum: 0x%08x\n", nDataNum, wChkSum);
				printf("Flash-Memory Program Completed.\n");
//				printf("Kermit transfer OK!\n");
				printf("\n\n\n\n\n\n\n\n");
				printf("           Any Key to ReBoot\n\n\n\n\n");
				ch =inbyte();
				printf("\n\n\n\n\n\n\n\n");
				printf("***********************\n");
				printf("*   Rebooting system   *\n");
				printf("***********************\n");
				printf("\n\n\n\n\n\n\n\n");
				RebootSystem();
				}
			else
				{
				printf("Kermit transfer fail!\n");
				while(1);
				}
			}
		}

}
static void rsInitFlashBuff(void)
{
//	WORD n;
//	for (n=0;n<4096;n++)
//		rsFlashBuff[n]=0xff;
	
	bufCount=0;
	nDataNum=0;
	wChkSum=0;

//	rsPtrFlashBuff = (BYTE*) &(rsFlashBuff[0]);
	
	rsFlashStartAddr =F_STARTADDR;

}
#if 1
static BOOL rsFlushFlashBuff(void)
{
	int n,j;
	
		for(n=bufCount; n<2048; n++)
			rsFlashBuff[n] = 0xff;

//			rsPtrFlashBuff = (BYTE*) (rsFlashBuff);
	    	if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) != TRUE)
	    	{
	    		for (j = 0; j < 3; j++)
	    		{
	    			if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) == TRUE) break;    				
	    		}
	    		if (j >= 3)
	    			{
//	    			DBG_MSG("StartAddr=0x%x  Flash-memory program error\n",rsFlashStartAddr);
	    			return ERROR;
	    			}
	    	}
	    	
//			rsFlashStartAddr += 2048;
			bufCount=0;
			return OK;
}
static BOOL rsData2FlashBuff(BYTE* bSrcDataPtr, int num)
{
	int n,j;
	
		for(n=0;n<num;n++)
			{
			rsFlashBuff[bufCount]= *bSrcDataPtr;
			wChkSum += *bSrcDataPtr;

			bufCount++;
			bSrcDataPtr++;
			}
		
		nDataNum += n;

		if(bufCount>=2048)
			{
//			rsPtrFlashBuff = (BYTE*) (rsFlashBuff);

	    	if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) != TRUE)
	    	{
	    		for (j = 0; j < 3; j++)
	    		{
	    			if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) == TRUE) break;    				
	    		}
	    		if (j >= 3)
	    			{
//	    			DBG_MSG("StartAddr=0x%x  Flash-memory program error\n",rsFlashStartAddr);
	    			return ERROR;
	    			}
	    	}

			rsFlashStartAddr += 2048;
			
			bufCount -= 2048;
			if(bufCount>0)
				{
				for (j=0;j<bufCount;j++)
					rsFlashBuff[j]= rsFlashBuff[j+2048];
				}
			}
	return OK;
}
#elif 1
static BOOL rsData2FlashBuff(BYTE* bSrcDataPtr, int num)
{
	int n,j;
	if(num==0)
		{
		for(n=bufCount; n<2048; n++)
			rsFlashBuff[n] = 0xff;

//			rsPtrFlashBuff = (BYTE*) (rsFlashBuff);
	    	if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) != TRUE)
	    	{
	    		for (j = 0; j < 3; j++)
	    		{
	    			if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) == TRUE) break;    				
	    		}
	    		if (j >= 3)
	    			{
//	    			DBG_MSG("StartAddr=0x%x  Flash-memory program error\n",rsFlashStartAddr);
	    			return ERROR;
	    			}
	    	}
	    	
			rsFlashStartAddr += 2048;
			bufCount=0;
			return OK;
		}
	else
		{
		for(n=0;n<num;n++)
			{
			rsFlashBuff[bufCount]= *bSrcDataPtr;
			wChkSum += *bSrcDataPtr;

			bufCount++;
			bSrcDataPtr++;
			}
		
		nDataNum += n;

		if(bufCount>=2048)
			{
//			rsPtrFlashBuff = (BYTE*) (rsFlashBuff);

	    	if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) != TRUE)
	    	{
	    		for (j = 0; j < 3; j++)
	    		{
	    			if (Write2flash(rsFlashStartAddr, rsPtrFlashBuff) == TRUE) break;    				
	    		}
	    		if (j >= 3)
	    			{
//	    			DBG_MSG("StartAddr=0x%x  Flash-memory program error\n",rsFlashStartAddr);
	    			return ERROR;
	    			}
	    	}

			rsFlashStartAddr += 2048;
			
			if(bufCount>2048)
				{
				for (j=0;j<bufCount-2048;j++)
					rsFlashBuff[j]= rsFlashBuff[j+2048];
				bufCount -= 2048;
				}
			else
				bufCount=0;
			return OK;
			}
		}
}
#elif 0
static BOOL DataFlush2Ram(BYTE* bDesDataPtr, BYTE* bSrcDataPtr, int num)
{
	return OK;
}
#else
static BOOL DataFlush2Ram(BYTE* bDesDataPtr, BYTE* bSrcDataPtr, int num)
{
	int n,j;
	BYTE* wDesDataPtr;