deprecated/w32repro/w32repro.cpp
changeset 600 6d08f4a05d93
equal deleted inserted replaced
599:fa7a3cc6effd 600:6d08f4a05d93
       
     1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     2 // All rights reserved.
       
     3 // This component and the accompanying materials are made available
       
     4 // under the terms of "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 // Based on PREPRO.CPP and ROMBUILD.CPP
       
    15 // 
       
    16 //
       
    17 
       
    18 #define WIN32_LEAN_AND_MEAN
       
    19 #pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union
       
    20 #include <windows.h>
       
    21 #include <winbase.h>
       
    22 
       
    23 #include <stdio.h>
       
    24 #include <stdlib.h>
       
    25 #include <string.h>
       
    26 #include "h_utl.h"
       
    27 #include "h_ver.h"
       
    28 
       
    29 // need to pretend we've done e32image.h, to avoid clashes with winnt.h
       
    30 #define __E32IMAGE_H__
       
    31 struct E32ImageFile
       
    32 	{
       
    33 	};
       
    34 class CBytePair;
       
    35 #include "r_rom.h"
       
    36 
       
    37 #define READ_BUFFER_SIZE 0x1000		// allows for exuberant T_REPRO without delays in it
       
    38 #define WRITE_BUFFER_SIZE 0x1000
       
    39 
       
    40 TRomLoad TheRomHeader;
       
    41 TUint ImageDataSize=0;
       
    42 TUint FileSize=0;
       
    43 TText PortNumber='1';
       
    44 TUint BaudRate=115200;
       
    45 TBool Kick=EFalse;
       
    46 TBool UseHex=EFalse;
       
    47 TBool Verbose=EFalse;
       
    48 TBool RawImage=EFalse;
       
    49 TText* BootstrapName=NULL;
       
    50 
       
    51 const TUint KReproWrapperSize = 0x100;	// REPRO protocol assumes a wrapper size of 256 bytes
       
    52 
       
    53 HANDLE comPort;
       
    54 TUint32 BytesWritten;
       
    55 
       
    56 TText *processCommandLine(int argc, char *argv[])
       
    57 //
       
    58 // Process the command line arguments, printing a helpful message if none are supplied
       
    59 //
       
    60 	{
       
    61 
       
    62 	char HelpText[] = 
       
    63 		"* Syntax: W32REPRO [options] filename[.bin]\n"
       
    64 		"* \n"
       
    65 		"* Option: -P<n>        port number, defaults to COM1,\n"
       
    66 		"* Option: -K           kick the other end, to force another repro attempt\n"
       
    67 		"* Option: -B<rate>     baud rate, minimum 9600, defaults to 115200\n"
       
    68 		"* Option: -RAW         raw image with no header\n"
       
    69 		"* Option: -BOOT <file> bootstrap with <file> transmitted at 9600 baud\n"
       
    70 		"* Option: -HEX         use base 16 (for use with ReproC)\n"
       
    71 		"* Option: -V           display raw protocol messages\n"
       
    72 		"* \n"
       
    73 		"* All messages from W32REPRO begin with '*', every thing else comes from the\n"
       
    74 		"* machine being reprogrammed.\n";
       
    75 
       
    76 	TText *filename=NULL;
       
    77 	if (argc == 1)
       
    78 		{
       
    79 		cout << HelpText;
       
    80 		return NULL;
       
    81 		}
       
    82 	for (int i=1; i<argc; i++)
       
    83 		{
       
    84 		strupr(argv[i]);
       
    85 		if ((argv[i][0] == '-') || (argv[i][0] == '/'))
       
    86 			{
       
    87 			if (strcmp(argv[i],"-RAW")==0)
       
    88 				{
       
    89 				RawImage=ETrue;
       
    90 				}
       
    91 			else if (strcmp(argv[i],"-HEX")==0)
       
    92 				{
       
    93 				UseHex=ETrue;
       
    94 				}
       
    95 			else if (strcmp(argv[i],"-BOOT")==0)
       
    96 				{
       
    97 				if (++i==argc)
       
    98 					{
       
    99 					cout << "**** Missing argument for -BOOT\n*\n";
       
   100 					cout << HelpText;
       
   101 					return NULL;
       
   102 					}
       
   103 				BootstrapName=(TText*)argv[i];
       
   104 				}
       
   105 			else if (argv[i][1] == 'P')
       
   106 				{
       
   107 				PortNumber=argv[i][2];
       
   108 				}
       
   109 			else if (argv[i][1] == 'K')
       
   110 				{
       
   111 				Kick=ETrue;
       
   112 				}
       
   113 			else if (argv[i][1] == 'V')
       
   114 				{
       
   115 				Verbose=ETrue;
       
   116 				}
       
   117 			else if (argv[i][1] == 'B')
       
   118 				{
       
   119 				TInt rate=atoi(argv[i]+2);
       
   120 				if (rate>=9600)
       
   121 					{
       
   122 					BaudRate=rate;
       
   123 					}
       
   124 				else
       
   125 					{
       
   126 					cout << "**** Invalid baud rate: " << argv[i] << "\n*\n";
       
   127 					cout << HelpText;
       
   128 					return NULL;
       
   129 					}
       
   130 				}
       
   131 			else if (argv[i][1] == '?')
       
   132 				{
       
   133 				cout << HelpText;
       
   134 				return NULL;
       
   135 				}
       
   136 			else
       
   137 				{
       
   138 				cout << "**** Unrecognised argument " << argv[i] << "\n*\n";
       
   139 				cout << HelpText;
       
   140 				return NULL;
       
   141 				}
       
   142 			}
       
   143 		else // Must be the image filename
       
   144 			filename=(TText *)argv[i];
       
   145 		}
       
   146 	if (filename==NULL)
       
   147 		{
       
   148 		cout << "**** Missing image filename\n*\n";
       
   149 		cout << HelpText;
       
   150 		}
       
   151 	return filename;
       
   152 	}
       
   153 
       
   154 TInt openComPort()
       
   155 //
       
   156 // Open the com port and configure it
       
   157 //
       
   158 	{
       
   159 	char port[5]="COM1";
       
   160 	port[3]=PortNumber;
       
   161 	comPort=CreateFile(port,GENERIC_READ+GENERIC_WRITE,0,0,OPEN_EXISTING,0,NULL);
       
   162 	if (comPort==INVALID_HANDLE_VALUE)
       
   163 		return Print(EError,"* Cannot open %s\n",port);
       
   164 
       
   165 	DCB settings;
       
   166 	if (!GetCommState(comPort,&settings))
       
   167 		return Print(EError,"* Cannot read settings for %s\n",port);
       
   168 
       
   169 	if (!SetupComm(comPort,READ_BUFFER_SIZE,WRITE_BUFFER_SIZE))
       
   170 		return Print(EError,"* Cannot set buffer sizes for %s\n",port);
       
   171 
       
   172 	settings.fBinary=TRUE;
       
   173 	settings.fParity=FALSE;
       
   174 	settings.fAbortOnError=TRUE;	// overrides EV_ERR
       
   175 	settings.BaudRate=BaudRate;
       
   176 	settings.ByteSize=8;
       
   177 	settings.Parity=NOPARITY;
       
   178 	settings.StopBits=ONESTOPBIT;
       
   179 	settings.fRtsControl=RTS_CONTROL_ENABLE;
       
   180 	settings.fDtrControl=DTR_CONTROL_ENABLE;
       
   181 	settings.fOutxCtsFlow=FALSE;
       
   182 	settings.fOutxDsrFlow=FALSE;
       
   183 	settings.fDsrSensitivity=FALSE;
       
   184 	settings.fOutX=FALSE;		// no XON/XOFF for transmission
       
   185 	settings.fInX=FALSE;		// no XON/XOFF for reception
       
   186 	settings.fNull=FALSE;		// don't discard null bytes
       
   187 
       
   188 	settings.EvtChar='\001';	// REPRO command separator
       
   189 
       
   190 	if (!SetCommState(comPort,&settings))
       
   191 		return Print(EError,"* Cannot configure %s\n",port);
       
   192 	
       
   193 	if (!SetCommMask(comPort,EV_RXFLAG+EV_ERR))
       
   194 		return Print(EError,"* Cannot set CommMask for %s\n",port);
       
   195 
       
   196 	COMMTIMEOUTS timeouts = {
       
   197 		//20,0,0,	// allow up to 20 milliseconds between characters, i.e. buffer them properly
       
   198 		MAXDWORD,0,0,	// return immediately
       
   199 		0,0	// no write timeouts
       
   200 		};
       
   201 	if (!SetCommTimeouts(comPort,&timeouts))
       
   202 		return Print(EError,"* Cannot set timeouts for %s\n",port);
       
   203 
       
   204 	if (!SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_HIGHEST))
       
   205 		Print(EError,"* Failed to raise priority of this thread err=%d\n",GetLastError());
       
   206 	if (!SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS))
       
   207 		Print(EError,"* Failed to raise priority of this process err=%d\n",GetLastError());
       
   208 
       
   209 	Print(EScreen,"* Using %s at %d baud\n\n",port,BaudRate);
       
   210 	return KErrNone;
       
   211 	}
       
   212 
       
   213 BOOL WriteToComPort(char* data, DWORD length, char* comment)
       
   214 	{
       
   215 	if (Verbose)
       
   216 		{
       
   217 		if (comment==NULL)
       
   218 			Print(EScreen, "* TX=%*s\n", length, data);
       
   219 		else
       
   220 			Print(EScreen, "* TX <%d bytes of %s>\n", length, comment);
       
   221 		}
       
   222 	return WriteFile(comPort, data, length, &BytesWritten, NULL);
       
   223 	}
       
   224 
       
   225 TInt Bootstrap9600()
       
   226 	{
       
   227 	DCB settings;
       
   228 	if (!GetCommState(comPort,&settings))
       
   229 		return Print(EError,"* Cannot read COM settings\n");
       
   230 
       
   231 	settings.BaudRate=9600;
       
   232 	if (!SetCommState(comPort,&settings))
       
   233 		return Print(EError,"* Cannot reconfigure to 9600 baud\n");
       
   234 	
       
   235 	FILE* bootstrapFile=fopen((const char*)BootstrapName,"rb");
       
   236 	if (bootstrapFile==NULL)
       
   237 		return Print(EError,"* Cannot open bootstrap file %s for input (errno=%d)\n",BootstrapName,errno);
       
   238 
       
   239 	Print(EScreen,"* Sending bootstrap %s at 9600 baud\n",BootstrapName,BaudRate);
       
   240 
       
   241 	char bootdata[WRITE_BUFFER_SIZE];
       
   242 	TUint32 imageBytes=0;
       
   243 
       
   244 	while (!feof(bootstrapFile))
       
   245 		{
       
   246 		imageBytes=fread(bootdata,1,WRITE_BUFFER_SIZE,bootstrapFile);
       
   247 		if (imageBytes==0 && feof(bootstrapFile))
       
   248 			break;
       
   249 		if (imageBytes!=WRITE_BUFFER_SIZE && ferror(bootstrapFile))
       
   250 			{
       
   251 			return Print(ESevereError,"* Read only %d bytes of bootstrap err=%d\n",imageBytes,ferror(bootstrapFile));
       
   252 			}
       
   253 		if (!WriteToComPort(bootdata,imageBytes,"bootstrap data"))
       
   254 			return Print(ESevereError,"* Wrote only %d of %d bytes of bootstrap err=%d\n",
       
   255 				BytesWritten,imageBytes,GetLastError());
       
   256 		}
       
   257 	fclose(bootstrapFile);
       
   258 
       
   259 	settings.BaudRate=BaudRate;
       
   260 	if (!SetCommState(comPort,&settings))
       
   261 		return Print(EError,"* Cannot reconfigure to %d baud\n",BaudRate);
       
   262 	
       
   263 	Print(EScreen,"* Bootstrap downloaded\n\n");
       
   264 
       
   265 	return KErrNone;
       
   266 	}
       
   267 
       
   268 TInt main(int argc, char *argv[])
       
   269 	{
       
   270 	TInt err=KErrNone;
       
   271 
       
   272 	Print(EScreen,"\n* W32REPRO - Win32 version of PREPRO");
       
   273   	Print(EScreen," V%02d.%02d (Build %03d)\n",MajorVersion,MinorVersion,Build);
       
   274   	Print(EScreen,"* %s",Copyright);
       
   275 
       
   276 	TText *imageFileName = processCommandLine(argc, argv);
       
   277 	if (imageFileName==NULL)
       
   278 		return KErrGeneral;
       
   279 
       
   280 	FILE* romFile=fopen((const char*)imageFileName,"rb");
       
   281 	if (romFile==NULL)
       
   282 		return Print(EError,"* Cannot open ROM Image file %s for input (errno=%d)\n",imageFileName,errno);
       
   283 
       
   284 	if (RawImage)
       
   285 		TheRomHeader.wrapSize=0;
       
   286 	else
       
   287 		{
       
   288 		if (fread(&TheRomHeader,sizeof(TheRomHeader),1,romFile)!=1)
       
   289 			return Print(EError,"* Cannot read ROM Image header\n");
       
   290 		if (TheRomHeader.wrapSize!=KRomWrapperSize)
       
   291 			return Print(EError,"* Incorrect ROM header - wrong wrapper size\n");
       
   292 		}
       
   293 	if (fseek(romFile,0,SEEK_END)!=0)
       
   294 		return Print(EError,"* Cannot seek in ROM Image file\n");
       
   295 	FileSize=ftell(romFile);
       
   296 	ImageDataSize=FileSize-TheRomHeader.wrapSize;
       
   297 
       
   298 	Print(EAlways,"\n* ROM Image %s - 0x%06x bytes\n",imageFileName,ImageDataSize);
       
   299 
       
   300 	err=openComPort();
       
   301 	if (err!=KErrNone)
       
   302 		return err;
       
   303 
       
   304 	if (BootstrapName != NULL)
       
   305 		{
       
   306 		err=Bootstrap9600();
       
   307 		if (err!=KErrNone)
       
   308 			return err;
       
   309 		}
       
   310 
       
   311 	char romdata[WRITE_BUFFER_SIZE];
       
   312 	if (Kick)
       
   313 		{
       
   314 		memset(romdata,'!',64);		// string of non-numeric characters, won't harm old REPRO
       
   315 		WriteToComPort(romdata,64,NULL);
       
   316 		}
       
   317 	//
       
   318 	// Wait around for REPRO on the other end to send us commands
       
   319 	//
       
   320 	char command[READ_BUFFER_SIZE+1];
       
   321 	char* cp=command;
       
   322 	TInt length=READ_BUFFER_SIZE;
       
   323 	TUint expectedOffset=0;
       
   324 	TInt done=0;
       
   325 	while (!done)
       
   326 		{
       
   327 		TUint32 bytesRead=0,imageBytes=0,offset=0;
       
   328 
       
   329 		TUint32 event;
       
   330 		if (!WaitCommEvent(comPort,&event,NULL))
       
   331 			{
       
   332 			if (GetLastError()!=ERROR_OPERATION_ABORTED)
       
   333 				Print(EAlways,"\n* Unexpected WaitCommEvent failure %d event %x\n",GetLastError(),event);
       
   334 			TUint32 commError;
       
   335 			if (!ClearCommError(comPort,&commError,NULL))
       
   336 				{
       
   337 				Print(ESevereError,"\n* Failed to clear CommError - give up now!\n");
       
   338 				return KErrGeneral;
       
   339 				}
       
   340 			if (commError!=CE_OVERRUN)
       
   341 				Print(EAlways,"\n* Unexpected comms error %x\n",commError);
       
   342 			}
       
   343 		if (!ReadFile(comPort,cp,length,&bytesRead,NULL))
       
   344 			{
       
   345 			if (GetLastError()!=ERROR_OPERATION_ABORTED)
       
   346 				Print(EAlways,"\n* Unexpected ReadFile failure %d bytes %d\n",GetLastError(),bytesRead);
       
   347 			}
       
   348 		if (bytesRead==0)
       
   349 			continue;
       
   350 
       
   351 		char* next;
       
   352 		char* end = cp+bytesRead;
       
   353 		*end='\0';	// stick a terminator on the end, just in case
       
   354 
       
   355 		for (cp=(char*)command; (next=(char*)memchr(cp,'\001',end-cp))!=NULL ;cp=next+1)
       
   356 			{
       
   357 			*next='\0';	// drop the terminator
       
   358 			if (Verbose)
       
   359 				Print(EScreen, " * RX=%s\n", cp);
       
   360 			switch (cp[0])
       
   361 				{
       
   362 			case 'D':	// disconnect after successful REPRO
       
   363 				Print(EScreen,"* Disconnect\n");
       
   364 				done=1;
       
   365 				break;
       
   366 			case 'M':	// print message
       
   367 				Print(EScreen,"%s",cp+1);
       
   368 				break;
       
   369 			case 'P':	// panic
       
   370 				Print(ESevereError,"%s",cp+1);
       
   371 				break;
       
   372 			case 'R':	// request for data from the image at specified address
       
   373 				if (end-next>1)
       
   374 					break;	// must be the last command in the buffer
       
   375 				offset=strtoul(cp+1,NULL,UseHex?16:10)-KReproWrapperSize; // REPRO assumes wrapSize=256	
       
   376 				if ((offset&4095)!=0)
       
   377 					{
       
   378 					Print(ESevereError,"* Image offset %x not a multiple of 4k (%s)\n", offset,cp);
       
   379 					break;
       
   380 					}
       
   381 				if (offset>expectedOffset)
       
   382 					{
       
   383 					Print(ESevereError,"* Image offset %x should have been %x\n", offset,expectedOffset);
       
   384 					break;
       
   385 					}
       
   386 				Print(EScreen,"%x       \r",offset);		// in case we lost the message
       
   387 				expectedOffset=offset+WRITE_BUFFER_SIZE;	// what we expect next time
       
   388 				offset+=TheRomHeader.wrapSize;	// offset into the file
       
   389 				if (fseek(romFile,offset,SEEK_SET)!=0)
       
   390 					{
       
   391 					Print(ESevereError,"* Can't seek to file offset %x", offset);
       
   392 					break;
       
   393 					}
       
   394 
       
   395 				memset(romdata,0xff,WRITE_BUFFER_SIZE);
       
   396 				imageBytes=fread(romdata,1,WRITE_BUFFER_SIZE,romFile);
       
   397 				if (imageBytes!=WRITE_BUFFER_SIZE && offset+imageBytes!=FileSize)
       
   398 					{
       
   399 					Print(ESevereError,"* Read only %d bytes of image data err=%d\n",imageBytes,ferror(romFile));
       
   400 					break;
       
   401 					}
       
   402 				if (!WriteToComPort(romdata,WRITE_BUFFER_SIZE,"image data"))
       
   403 					Print(ESevereError,"* Wrote only %d bytes of image data err=%x\n",BytesWritten,GetLastError());
       
   404 				break;
       
   405 			case 'S':	// request for the size of the image
       
   406 				if (end-next>1)
       
   407 					break;	// must be the last command in the buffer
       
   408 				if (next-cp==1)
       
   409 					{
       
   410 					sprintf((char*)romdata,"%010d\n",ImageDataSize+KReproWrapperSize);
       
   411 					if (!WriteToComPort(romdata,strlen(romdata),NULL) 
       
   412 							|| BytesWritten!=strlen(romdata))
       
   413 						Print(ESevereError,"* Failed to write file size\n");
       
   414 					expectedOffset=0;	// because we are starting again
       
   415 					break;
       
   416 					}
       
   417 				// otherwise fall through
       
   418 			default:
       
   419 				Print(EAlways,"\n* Unrecognised command >%s<\n", cp);
       
   420 				}
       
   421 			}
       
   422 		if (cp<end)	// copy trailing characters back to the start of the buffer
       
   423 			memmove(command,cp,end-cp);
       
   424 		cp=command+(end-cp);
       
   425 		length=command+READ_BUFFER_SIZE-cp;
       
   426 		}
       
   427 	return KErrNone;
       
   428 	}