imgmain.c

M-System DOC(Disk on a Chip) Flash芯片映像读写工具, 可以进行二片Flash芯片的内容互相拷贝, 提高烧录程序的效率.

#include "flsystem.h"
#include <stdio.h>
#include <stdlib.h>
#include "excustom.h"
#include "exdevice.h"
#include "exos.h"
#include "extffs.h"
#include "exparser.h"

#include "flcustom.h"
#include "blockdev.h"
#include "image.h"

static EXBYTE bPrintLevel=0;

enum eComLineParam{
CO_BDKPSRC=0, CO_BDKPTRG, CO_BDTLPSRC, CO_BDTLPTRG, CO_BDKPCH, CO_BDTLPCH,
CO_WINSRC, CO_WINTRG, CO_FILESRC, CO_FILETRG, CO_QUES, CO_H, CO_SINGLE,
CO_SHIFT,CO_WIDTH,CO_LEVEL,CO_FAST,CO_VERIFY
};

static const EXCHAR*pCommands[]=
{
"SRCBDK", "TRGBDK", "SRCBDTL", "TRGBDTL", "CHBDK", "CHBDTL",
"WINSRC", "WINTRG", "FILESRC", "FILETRG", "?", "H", "SINGLE",
"SHIFT", "WIDTH", "LEVEL", "FAST","VERIFY",
"*****"
};

#ifdef ENVIRONMENT_VARS
extern unsigned char flUse8Bit;
#endif
EXCHAR pMsg[0xff],pError[0xff];
EXDWORD dwWinBegin,dwWinEnd;
ExDevice msgDev;
Params params;
EXDWORD ext_busConfig=0;

unsigned long GetDocWinLAddress(void);
unsigned long GetDocWinHAddress(void);
void EXAPI PrintErrorMessage(EXWORD err);
ExStatus EXAPI DParseCommandLine();
void EXAPI Usage(void);

ExStatus EXAPI ExMain(void)
{
	EXWORD wErr;

	OpenMsgDevice(&msgDev);
	ExSprintf(pMsg,"DiskOnChip DImage version %c.%c.%c.%d\n%s\nLast Update : %s\n",TrueFFSVersion[0],TrueFFSVersion[1],TrueFFSVersion[2],VER_DIMAGE,COPYRIGHT,LAST_UPDATED);
	WriteMsgDevice(&msgDev,pMsg);

	if((wErr=DParseCommandLine())==EX_OK)
	{
		wErr=ImageSaftl();
	}
	PrintErrorMessage(wErr);
	CloseMsgDevice(&msgDev);
	ExCloseAllDevices();
	return (ExStatus)wErr;
}

ExStatus EXAPI DParseCommandLine()
{
	ExStatus wErr;
	CommandLineStruct cls;
	ExDevice cmlDev;
	EXBYTE bSrcDoc=2,bTarDoc=2;
	EXWORD w;
	EXCHAR*pParam;
	EXBYTE bTarPassNum=0,bSrcPassNum=0,bChPassNum=0;
	

/* init vars, usefull when activating dimage in a loop */
#ifndef PUTIMAGE
	params.srcPass[0].bPartType=2;
	params.srcPass[1].bPartType=2;
#endif
	params.tarPass[0].bPartType=2;
	params.tarPass[1].bPartType=2;
	params.chPass[0].bPartType=2;
	params.chPass[1].bPartType=2;
	dwWinBegin=EXDWORD_MAX;
	dwWinEnd=EXDWORD_MAX;
	params.dwBusConfig=0;
#ifndef NO_SINGLE
	params.bSingle=0xff;
#endif
	params.bVerify=EXFALSE;

	if((wErr=OpenCmdLineDevice(&cmlDev))!=EX_OK)
		return wErr;

	wErr=EX_OK;
	for(w=0;wErr==EX_OK;w++)
	{
		if((wErr=ReadCmdLineDevice(&cmlDev,w,(void**)&pParam))==EX_OK)
		{
			ExGetCommandLineStruct(pParam,&cls,(EXCHAR **)pCommands);

			switch(cls.bCommandNumber)
			{

			case CO_SHIFT:
			{
				unsigned long dwTmp;
				if(cls.bArgLen==0 || cls.fSuffix)
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				dwTmp=ExStrtol((const EXCHAR*)cls.pArg,NULL,10);				
				   switch(dwTmp)
				   {
					  case 0 :
						 params.dwBusConfig |= FL_NO_ADDR_SHIFT;
						 break;
					  case 1:
						 params.dwBusConfig |= FL_SINGLE_ADDR_SHIFT;
						 break;
					  case 2:
						 params.dwBusConfig |= FL_DOUBLE_ADDR_SHIFT;
						 break;
					  default:
						  break;
				   }
			}
				break;
			case CO_WIDTH:
			{
				unsigned long dwTmp;
				if(cls.bArgLen==0 || cls.fSuffix)
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				dwTmp=ExStrtol((const EXCHAR*)cls.pArg,NULL,10);
				if(dwTmp&(!(8|16|32)))
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				if(dwTmp&8)
				{
				   params.dwBusConfig |= FL_BUS_HAS_8BIT_ACCESS;
				}

			   if(dwTmp&16)
			   {
				  params.dwBusConfig |= FL_BUS_HAS_16BIT_ACCESS;
			   }

			   if(dwTmp&32)
			   {
				  params.dwBusConfig |= FL_BUS_HAS_32BIT_ACCESS;
			   }

			}
			break;

		case CO_LEVEL:
			if((cls.bArgLen==0) || (cls.fSuffix!=0))
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
			bPrintLevel=(EXBYTE)ExStrtol((const EXCHAR*)cls.pArg,NULL,10);
			break;

		case CO_FAST:
#ifdef ENVIRONMENT_VARS
			flUse8Bit = 0;
#endif
			break;

		case CO_VERIFY:
            params.bVerify = EXTRUE;
            break;

		case CO_FILESRC:
				if(bSrcDoc!=2)			/* already open */
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				if((wErr=OpenSerialReadFileDevice(&params.imageDevSrc,cls.pArg))!=EX_OK)
				{
					ExSprintf((EXCHAR*)pError,"Can't open %s",cls.pArg);
					return EX_USER_CUSTOM_ERROR;
				}
				bSrcDoc=EXFALSE;
				break;

#ifndef PUTIMAGE
			case CO_FILETRG:
				if(bTarDoc!=2)			/* already open */
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				if((wErr=OpenSerialWriteFileDevice(&params.imageDevTar,cls.pArg))!=EX_OK)
				{
					ExSprintf((EXCHAR*)pError,"Can't open %s",cls.pArg);
					return EX_USER_CUSTOM_ERROR;
				}
				bTarDoc=EXFALSE;
				break;

			case CO_WINSRC:
				if(cls.fSuffix || cls.bArgLen==0 || dwWinBegin!=EXDWORD_MAX || bSrcDoc!=2)
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				dwWinBegin=ExStrtoul((const EXCHAR*)cls.pArg,NULL,16);
				if(dwWinBegin==EXDWORD_MAX)
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				bSrcDoc=EXTRUE;
				break;

			case CO_WINTRG:
				if(cls.fSuffix || cls.bArgLen==0 || dwWinEnd!=EXDWORD_MAX || bTarDoc!=2)
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				dwWinEnd=ExStrtoul((const EXCHAR*)cls.pArg,NULL,16);
				if(dwWinEnd==EXDWORD_MAX)
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				bTarDoc=EXTRUE;
				break;

			case CO_BDKPSRC:
			case CO_BDTLPSRC:
				{
					if(cls.bArgLen!=8 || cls.bSuffix>4 || bSrcPassNum>1 )
					{
						strcpy((char*)pError,cls.pCommand);
						return EX_COMMAND_LINE_ERROR;
					}
					ExMemCpy(params.srcPass[bSrcPassNum].pPassword,cls.pArg,8);
					params.srcPass[bSrcPassNum].bPart=cls.bSuffix;
					params.srcPass[bSrcPassNum].bPartType=(EXBYTE)((cls.bCommandNumber==CO_BDKPSRC)?0:1);
					bSrcPassNum++;
				}
				break;
#endif
			case CO_BDKPTRG:
			case CO_BDTLPTRG:
				{
					if(cls.bArgLen!=8 || cls.bSuffix>4 || bTarPassNum>1 )
					{
						strcpy((char*)pError,cls.pCommand);
						return EX_COMMAND_LINE_ERROR;
					}
					ExMemCpy(params.tarPass[bTarPassNum].pPassword,cls.pArg,8);
					params.tarPass[bTarPassNum].bPart=cls.bSuffix;
					params.tarPass[bTarPassNum].bPartType=(EXBYTE)((cls.bCommandNumber==CO_BDKPTRG)?0:1);
					bTarPassNum++;
				}
				break;

			case CO_BDKPCH:
			case CO_BDTLPCH:
				{
					if(cls.bArgLen!=8 || cls.bSuffix>4 || bChPassNum>1 )
					{
						strcpy((char*)pError,cls.pCommand);
						return EX_COMMAND_LINE_ERROR;
					}
					ExMemCpy(params.chPass[bChPassNum].pPassword,cls.pArg,8);
					params.chPass[bChPassNum].bPart=cls.bSuffix;
					params.chPass[bChPassNum].bPartType=(EXBYTE)((cls.bCommandNumber==CO_BDKPCH)?0:1);
					bChPassNum++;
				}
				break;

			case CO_H:
			case CO_QUES:
				Usage();
				CloseCmdLineDevice(&cmlDev);
				return (ExStatus)EXE_USAGE;

#ifndef NO_SINGLE
			case CO_SINGLE:
				if(cls.bArgLen==0 || cls.fSuffix)
				{
					strcpy((char*)pError,cls.pCommand);
					return EX_COMMAND_LINE_ERROR;
				}
				params.bSingle=(EXBYTE)ExStrtol((const EXCHAR*)cls.pArg,NULL,10);
				break;
#endif
			default:
				strcpy((char*)pError,cls.pCommand);
				return EX_COMMAND_LINE_ERROR;
			}
		}
		else
			if(wErr!=EX_EOF_ERROR)
			{
				return wErr;
			}
	}

	if(bSrcDoc==2 || bTarDoc==2)
	{
		strcpy(pError,"DiskOnChip address or image file must be selected");
		return EX_COMMAND_LINE_ERROR;
	}

	params.bSocketSrc=bSrcDoc?0:SOCKETS;
	params.bSocketTar=bTarDoc?0:SOCKETS;

	if(dwWinBegin==EXDWORD_MAX)
		dwWinBegin=dwWinEnd;
	if(dwWinEnd==EXDWORD_MAX)
		dwWinEnd=dwWinBegin;

	if(dwWinBegin<=dwWinEnd)
	{
		if(bSrcDoc==1 && bTarDoc==1)
		{
			params.bSocketSrc=0;
			params.bSocketTar=1;
		}
	}
	else
	{
		EXDWORD dw=dwWinEnd;
		dwWinEnd=dwWinBegin;
		dwWinBegin=dw;
		if(bSrcDoc==1 && bTarDoc==1)
		{
			params.bSocketSrc=1;
			params.bSocketTar=0;
		}
	}

    if(params.dwBusConfig == 0)
		params.dwBusConfig = ext_busConfig;

	CloseCmdLineDevice(&cmlDev);
	return EX_OK;
}

void EXAPI PrintErrorMessage(EXWORD err)
{
	if(err==EXE_USAGE)
		return;
	if(err==EX_OK)
		WriteMsgDevice(&msgDev,"\nOK\n");
	else
	{
		ExDevice errDev;
		pMsg[0]=0;
		OpenErrorMsgDevice(&errDev);

		if(err==EX_USER_CUSTOM_ERROR)
			ExSprintf((EXCHAR*)pMsg,"\n%s\n\n",pError);
		else
		{
			if(err<=EXE_LAST_TFFS)
			{
				ExSprintf((EXCHAR*)pMsg,"\nTrueFFS error #%d - %s\n\n",err,TranslateFLStatus((FLStatus)err));
			}
			else
			{
				switch(err)
				{
				case EX_MALLOC_ERROR:
					strcpy((EXCHAR*)pMsg,"\nNo enough memory\n\n");
					break;
				case EX_COMMAND_LINE_ERROR:
					ExSprintf((EXCHAR*)pMsg,"\nWrong parameters passed: %s\n\n",pError);
					break;
				case EX_CLOSE_ERROR:
					strcpy((EXCHAR*)pMsg,"\nCan't close file\n\n");
					break;
				case EX_WRITE_ERROR:
					strcpy((EXCHAR*)pMsg,"\nCan't write to file\n\n");
					break;
				case EX_READ_ERROR:
					strcpy((EXCHAR*)pMsg,"\nCan't read from file\n\n");
					break;
				case EXE_NOT_COMPATIBLE:
					strcpy((EXCHAR*)pMsg,"\nSource not compatible to target\n\n");
					break;
				case EXE_IMAGE:
					strcpy((EXCHAR*)pMsg,"\nSource file format error\n\n");
					break;
				}
			}
		}
		if(pMsg[0]!=0)
			WriteErrorMsgDevice(&errDev,pMsg);
		WriteMsgDevice(&errDev,"DImage failed\n\n");
		CloseErrorMsgDevice(&errDev);
	}
}

EXDWORD GetDocWinLAddress(void)
{
	return dwWinBegin;
}

EXDWORD GetDocWinHAddress(void)
{
	return dwWinEnd;
}

void EXAPI Usage(void)
{
	WriteMsgDevice(&msgDev,"\n\
    DIMAGE /WINSRC:addr /WINTRG:addr\n\
		   [/SRCBDTL#:pswd] [/SRCBDK#:pswd] [/TRGBDTL#:pswd] [/TRGBDK#:pswd]\n\
copy DiskOnChip to another DiskOnChip\n\
	DIMAGE /WINSRC:addr /FILETRG:file\n\
		   [/TRGBDK#:pswd] [/TRGBDTL:pswd]\n\
get image of DiskOnChip\n\
	DIMAGE /FILESRC:file /WINTRG:addr\n\
		   [/SRCBDK#:pswd] [/SRCBDTL:pswd]\n\
put image to DiskOnChip\n\
\n\
/FILESRC:file /FILETRG:file  Name of image.\n\
/WINSRC:addr /WINTRG:addr    Memory address at which the DiskOnChip is located.\n\
/SRCBDK#:pswd                  Protection key of source DiskOnChip binary\n\
							 partition number #.\n\
/SRCBDTL#:pswd                  Protection key of source DiskOnChip BDTL\n\
							 partition number #.\n\
/TRGBDK#:pswd                  Protection key of target DiskOnChip binary\n\
							 partition number #.\n\
/TRGBDTL#:pswd                  Protection key of target DiskOnChip BDTL\n\
							 partition number #.\n\
/SINGLE:floor                 Copy 1 floor to target DiskOnChip\n\
/VERIFY                       Verify the programming operation\n\
");
}

EXBYTE GetPrintLevel(void)
{
	return bPrintLevel;
}