bl08.c

/*
File: bl08.c

Version: 1.0.0.1

Copyright (c) 2004,2008  Kustaa Nyholm
Copyright (c) 2008 Robert Larice (SWI return to MON, QY2 chip)
Copyright (c) 2010 Tormod Volden

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public
License as published by the Free Software Foundation; either
version 2.0 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/
// This code compiles cleanly with i686-apple-darwin8-gcc-4.0.1 with command:
// gcc -Wall -std=c99 -pedantic -o bl08 bl08.c
// and uses only POSIX standard headers so this should be pretty 
// easy to port anywhere: Mac OS X,  Linux , MinGW, Cygwin
//
// Having said that I'm pretty sure there is implicit assumptions that
// int is 32 bits, char is signed 8 bits
// I also expect that extending this code to handle S-records in the +2G range
// will uncover more implicit assumptions.
//
// cheers Kusti

#include <stdlib.h>
#include <fcntl.h>
#include <termios.h>
#include <stdarg.h>
#include <ctype.h>
#include <stdio.h>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include <signal.h>


#if defined(__linux__)

# include <sys/wait.h>
# include <sys/ioctl.h> 

#else

// Terrible hack here because POSIX says 'ioctl()' is in <stropts.h> but
// for example Mac OS X Tiger does not have this header, OTOH I think
// that <sys/ioctl.h> is not POSIX either so how do you write
// actual POSIX compliant code that compiles cleanly on POSIX...
extern int ioctl (int filedes, int command, ...);
// End of hack

#endif

	
#define PIDFILENAME "bl08PIDfile.temp"

//char* COM = "/dev/tty.usbserial-FTOXM3NX";
char* COM = "/dev/ttyS0";

typedef struct {
char* str;
int val;
} pair;

pair portPins[]= {
{"LE",TIOCM_LE},
{"DTR",TIOCM_DTR},
{"RTS",TIOCM_RTS},
{"ST",TIOCM_ST},
{"SR",TIOCM_SR},
{"CTS",TIOCM_CTS},
{"CAR",TIOCM_CAR},
{"CD",TIOCM_CD},
{"RNG",TIOCM_RNG},
{"RI",TIOCM_RI},
{"DSR",TIOCM_DSR}
};

int forcePins[sizeof(portPins)/sizeof(portPins[0])] = {0};

pair baudrates[]= {
// Some common, but non POSIX baudrates here
#ifdef B14400
{"14400",B14400},
#endif
#ifdef B57600
{"57600",B57600},
#endif
#ifdef B115200
{"115200",B115200},
#endif
#ifdef B230400
{"230400",B230400},
#endif

{"0",B0},
{"50",B50},
{"75",B75},
{"110",B110},
{"134",B134},
{"150",B150},
{"200",B200},
{"300",B300},
{"600",B600},
{"1200",B1200},
{"1800",B1800},
{"2400",B2400},
{"4800",B4800},
{"9600",B9600},
{"19200",B19200},
{"38400",B38400},
};
	
int baudRate=B9600;

int com;

char version[] = "1.0.0.1";

unsigned char image[ 0x10000 ]; // HC908 memory image
unsigned char scode[8]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};

// EARRNG, CTRLBYT parameter
#define ERARRNG_PAGE_ERASE 0x00
#define ERARRNG_MASS_ERASE 0x40

// These will be initialized by setCPUtype()
int CPUSPEED;	// 2 x Fbus freq, e.g.  ext osc 16 MHz -> Fbus == 4 Mh => CPUSPEED==2
int RAM;
int FLASH;	// Flash start address
int PUTBYTE;	// Receive byte routine address
int GETBYTE;	// Receive byte routine address
int RDVRRNG;	// Read/verify flash routine address
int ERARRNG;	// Erase flash routine address
int PRGRNGE;	// Flash programming routine address
int FLBPR;	// Flash block proctection register address
int MONRTN;	// Monitor mode return jump address
int EADDR;	// For FLBPR in Flash the mass erase must use FLBPR as the erase address
// These will be calculated
int MONDATA;	// Flashing routines parameter block address (==RAM+8)
int CTRLBYT;	// Address of flashing routine control variable (==MONDATA+0)
int CPUSPD;	// Address of flashing routine cpu speed variable (==MONDATA+1)
int LADDR;	// Address of flashing routine last address variable (==MONDATA+2)
int DATABUF;	// Flashing routines data buffer address (==MONDATA+4)
int PAGESIZE;	// Databuffer size
int WORKRAM;	// Work storage needed for calling flashing routines
int WORKTOP;	// Topmost work storage address

// HC908GZ16 Memory usage (note for some HC908 variants the ROM routines use memory starting from 0x80):
// 0x40 - 0x47 reserved for future ROM routine expansion needs
// 0x48 - 0x4B ROM routine parameters
// 0x4C - 0x6C ROM routine data buffer (64 bytes as used in this code)
// 0xAC - 0xFF Working storage for calling the ROM routines (about 17 bytes used)

int tickP1=15;
int tickP2=1023;
int verbose = 1;
int size = sizeof(image);
int useStdin=0;
int dumpStart=0;
int dumpSize=0;
char* dumpFormat="hex";
int eraseFlash=0;
int verify=0;
char* executeCode=NULL;
int pageErase=0;
int uploadOnly=0;
int terminalMode=0;
int connected=0;
int useFastProg=0;
int resetPulse=0;
int killPrevious=0;
int loadOnly=0;

void comErr(char *fmt, ...) {
	char buf[ 500 ];
	va_list va;
	va_start(va, fmt);
	vsnprintf(buf, sizeof(buf), fmt, va);
	fprintf(stderr,"%s", buf);
	perror(COM);
	va_end(va);
	abort(); 
	}

void flsprintf(FILE* f, char *fmt, ...) {
	char buf[ 500 ];
	va_list va;
	va_start(va, fmt);
	vsnprintf(buf, sizeof(buf), fmt, va);
	fprintf(f,"%s", buf);
	fflush(f);
	va_end(va);
	}
	
void ioctlErrCheck(int e) {
	if (e) {
		flsprintf(stdout,"ioctl returned %d\n",e);
		abort();
		}
	}
	
void setHandshake() {
	int i,s;
	ioctlErrCheck(ioctl(com, TIOCMGET, &s)); 	
	for (i=0; i<sizeof(forcePins)/sizeof(forcePins[0]); i++) {
		int v=forcePins[i]-1;
		if (v==1) 
			s &= ~portPins[i].val;
		
		if (v==0) 
			s |= portPins[i].val;
		}			
	ioctlErrCheck(ioctl(com, TIOCMSET, &s)); 
	}
	
	
void initSerialPort() {
	com =  open(COM, O_RDWR | O_NOCTTY | O_NDELAY);
	if (com <0) 
		comErr("Failed to open serial port\n");
		
	fcntl(com, F_SETFL, 0);
		
	struct termios opts;
	
	tcgetattr(com, &opts);

	opts.c_lflag  &=  ~(ICANON | ECHO | ECHOE | ISIG);

	opts.c_cflag |=  (CLOCAL | CREAD);
	opts.c_cflag &=  ~PARENB;
	opts.c_cflag |=  CSTOPB; // two stop bits
	opts.c_cflag &=  ~CSIZE;
	opts.c_cflag |=  CS8;
	
	opts.c_oflag &=  ~OPOST;
	
	opts.c_iflag &=  ~INPCK;
	opts.c_iflag &=  ~(IXON | IXOFF | IXANY);	
	opts.c_cc[ VMIN ] = 0;
	opts.c_cc[ VTIME ] = 10;//0.1 sec
	

	cfsetispeed(&opts, baudRate);   
	cfsetospeed(&opts, baudRate);   
	
	setHandshake();
	
	if (tcsetattr(com, TCSANOW, &opts) != 0) {
		perror(COM); 
		abort(); 
		}
		
	tcflush(com,TCIOFLUSH); // just in case some crap is the buffers
			
	if (!terminalMode) {
		char buf = -2;
		while (read(com, &buf, 1)>0) {
			if (verbose)
				flsprintf(stderr,"Unexpected data from serial port: %02X\n",buf & 0xFF);
			}
		}

	}
	

void putByte(int byte) {
	char buf = byte;
	if (verbose>3)
		flsprintf(stdout,"TX: 0x%02X\n", byte);
	int n = write(com, &buf, 1);
	if (n != 1)
		comErr("Serial port failed to send a byte, write returned %d\n", n);
	}
	
int getByte() {
	char buf;
	int n = read(com, &buf, 1);
	if (verbose>3)
		flsprintf(stdout,n<1?"RX: fail\n":"RX:  0x%02X\n", buf & 0xFF);
	if (n == 1)
		return buf & 0xFF;
	
	comErr("Serial port failed to receive a byte, read returned %d\n", n);
	return -1; // never reached
	}

// This reads away break 'character' from the serial line
void flushBreak() { 
	int i;
	for (i=0; i<2; ++i) {
		char buf;
		int n = read(com, &buf, 1);
		if (verbose>3)
			flsprintf(stdout,n<1?"FL: nothing\n":"FL:  0x%02X\n", buf & 0xFF);
		}
	}
		
void sendByte(int byte) {
	byte &=  0xFF;
	putByte(byte);
	char buf;
	if (read(com, &buf, 1)!=1)
		comErr("Loopback failed, nothing was received\n");
	int rx=buf &0xFF;
	if (byte !=  rx)
		comErr("Loopback failed, sent 0x%02X, got 0x%02X\n", byte,  rx);
	rx = getByte();
	if (byte !=  rx)
		comErr("Target echo failed, sent 0x%02X, got 0x%02X\n", byte, rx);
	}
	

void readMemory(int addr, int n,int tick) {
	if (verbose>2) 
		flsprintf(stdout,"Read memory address %04X size %04X\n",addr,n);
	unsigned char* p = &image[ addr ];
	sendByte(0x4A); // Monitor mode READ command
	sendByte(addr >> 8);
	sendByte(addr & 0xFF);
	*(p++) = getByte();
	n--;
	int tc=0;
	while (n>0) {
		sendByte(0x1A); // Monitor mode IREAD command
		int b1 = getByte();
		int b2 = getByte();
		*(p++) = b1;
		n--;
		if (n > 0)
			*(p++) = b2;
		n--;
		if (tick) {
			tc++;
			if ((tc & tickP1)==0)
				flsprintf(stdout,".");
			//if ((tc & tickP2)==0)
			//	flsprintf(stdout,"\n");
			}
		}
	}

void writeMemory(int addr, int n, int tick) {

	struct timespec tspec;
	tspec.tv_sec=0;
	tspec.tv_nsec=1000000; /* wait at least 1 ms (datasheet specifies 11 bit times) */

	if (verbose>2) 
		flsprintf(stdout,"Write memory address %04X size %04X\n",addr,n);
	unsigned char* p = &image[ addr ];
	sendByte(0x49); // Monitor mode WRITE command
	sendByte(addr >> 8);
	sendByte(addr & 0xFF);
	sendByte(*(p++));
	if (verbose>3)
		flsprintf(stdout,"Command delay\n");
	nanosleep(&tspec,0);
	int tc=1;
	while (n>1) {
		sendByte(0x19); // Monitor mode IWRITE command
		sendByte(*(p++));
		if (verbose>3)
			flsprintf(stdout,"Command delay\n");
		nanosleep(&tspec,0);
		n -= 1;
		if (tick) {
			tc++;
			if ((tc & tickP1)==0)
				flsprintf(stdout,".");
			//if ((tc & tickP2)==0)
			//	flsprintf(stdout,"\n");
			}
		}


	}
	
void connectTarget() {
	int j;
	if (connected)
		return;

	flsprintf(stdout, "Security code: ");
	for (j = 0; j<8; ++j) {
		sendByte(scode[j]);
	        flsprintf(stdout, ".");
		}
	flsprintf(stdout, " ");

	flushBreak();
	readMemory(RAM, 1 , 0);
	connected=1;
	if ((image[ RAM ] & 0x40) == 0)
		flsprintf(stdout,"failed\n");
	else
		flsprintf(stdout,"passed\n");
	
	// in case FLBPR is RAM based we clear it first by just writing it
	image[FLBPR]=0xFF;
	writeMemory(FLBPR,1,0);
	}
	

void dumpMemory(int addr, int n) {
	unsigned char* p = &image[ addr ];
	int i;
	for (i = 0; i<n; ++i) {
		if ((i&0xF) == 0)
			flsprintf(stdout,"%04X  ", addr+i);
		flsprintf(stdout,"%02X ", *(p++) & 0xFF);
		if ((i&0xF) == 7)
			flsprintf(stdout," ");
		if ((i&0xF) == 15)
			flsprintf(stdout,"\n");
		}
	if ((i&0xF) != 0)
		flsprintf(stdout,"\n");
	}
	
	
void dumpMemorySrec(int addr, int size) {
	unsigned char* p = &image[ addr ];
	while (size>0) {
		int n = size>16 ? 16 : size;
		int bc=2+n+1;
		flsprintf(stdout,"S1%02X%04X",bc,addr);
		int s=(addr >> 8) + (addr & 0xFF) + bc;	
		int i;
		for (i=0; i<n; ++i) {
			int bty=*p & 0xFF;
			s += bty;
			flsprintf(stdout,"%02X",bty);
			++p;
			++addr;
			}
		size -= n;
		flsprintf(stdout,"%02X\n",~s & 0xFF);
		}
	}

int readSP() {
	if (verbose>2) 
		flsprintf(stdout,"Read Stack Pointer\n");
	sendByte(0x0C); // Monitor mode READSP command
	return  (((getByte() << 8) | (getByte() & 0xFF)) - 1) & 0xFFFF;
	}	

int runFrom(int PC, int A, int CC, int HX) {
	int SP=readSP();
	if (verbose>2) 
		flsprintf(stdout,"Execute code PC=%04X A=%02X CC=%02X H:X=%04X SP=%04X\n",PC,A,CC,HX,SP);
	image[ SP + 1 ] = HX >> 8;
	image[ SP + 2 ] = CC;
	image[ SP + 3 ] = A;
	image[ SP + 4 ] = HX & 0xFF;
	image[ SP + 5 ] = PC >> 8;
	image[ SP + 6 ] = PC & 0xFF;
	writeMemory(SP + 1 , 6 , 0);
	sendByte(0x28); // Monitor mode RUN command
	//struct timespec tspec;
	//tspec.tv_sec=0;
	//tspec.tv_nsec=5000000; /* wait at least 1 ms (datasheet specifies 11 bit times) */
	//nanosleep(&tspec,0);
	return SP;
	}	
			
int lastMon=-1;

int callMonitor(int mon, int ctrlbyt, int accu, int faddr, int laddr) {
	int SP;

	image[ CTRLBYT ] = ctrlbyt; // CTRLBYT BIT 6  =  1  = > mass erase
	image[ CPUSPD ] = CPUSPEED; // CPUSPD  =  16 MHz ext clock  = > 4 MHz Fbus speed  = > 8
	if (verbose>3)
		flsprintf(stdout,"CPUSPEED=%02X\n",CPUSPEED);
	image[ LADDR ] = laddr>>8;
	image[ LADDR+1 ] = laddr&0xFF;
	writeMemory(MONDATA, 4, 0);
		
	if (WORKRAM>0xFF) {
		flsprintf(stderr,"Work RAM must be on zero page\n");
		abort();
		}

	if (lastMon!=mon) {
		// construct small HC908 code fragment to call the monitor function and return results
		int i = WORKRAM;
		
		image[ i++ ] = 0xCD; // JSR mon ; calls the monitor routine
		image[ i++ ] = mon>>8;
		image[ i++ ] = mon&0xFF;

		image[ i++ ] = 0x83; // SWI ; return to monitor
		
		if (WORKRAM>=WORKTOP) { // leave some stack space for monitor routines
			flsprintf(stderr,"Not enough WORKRAM on target\n");
			abort();
			}
		
		writeMemory(WORKRAM , i-WORKRAM , 0);
		lastMon=mon;
		}
	
	// now execute the fragment
	runFrom(WORKRAM, accu, 0x00, faddr); 

        // SWI drops into MON, which will send a BREAK
	{ 	char buf;
		if (read(com, &buf, 1) != 1)
			comErr("ERROR: waiting for MON, nothing was received\n");
		if (verbose>3)
			flsprintf(stdout,"MON returned %02X\n", buf);
		if(buf != 0)
			comErr("ERROR: unexpected swi answer read %x\n", buf);
	}

        // BREAK seems to introduce a frame error on the FT230X, read once more to clear that
	{ 	char buf;
		if (read(com, &buf, 1) != 1)
			comErr("ERROR: waiting for MON, nothing was received\n");
		if (verbose>3)
			flsprintf(stdout,"MON returned %02X\n", buf);
	}


	SP = readSP();
	readMemory(SP + 1 , 6 , 0);
	if (verbose>2) 
		flsprintf(stdout, "SP=%02x SP+1..6: hi(X)=%02x CC=%02x A=%02x lo(X)=%02x hi(PC)=%02x lo(PC)=%02x\n",
			SP,
			image[SP+1],  // hi(X)
			image[SP+2],  // CC
			image[SP+3],  // A
			image[SP+4],  // lo(X)
			image[SP+5],  // hi(PC)
			image[SP+6]); // lo(PC)
	return ((image[SP+2] & 0xff) << 8) | (image[SP+3] & 0xff); // return condition codes and accu
	}	
	
int fastProg(int faddr,int n) {
	static int n_addr;
	static int last_n;
	if (WORKRAM>0xFF) {
		flsprintf(stderr,"Work RAM must be on zero page\n");
		abort();
		}


	if (lastMon!=-1) {
		int SP = readSP();
		image[ CTRLBYT ] = 0; // CTRLBYT =0
		image[ CPUSPD ] = CPUSPEED; // CPUSPD  =  16 MHz ext clock  = > 4 MHz Fbus speed  = > 8

		// construct small HC908 code fragment to call the monitor function and return results
		int i = WORKRAM;
		image[ i++ ] = 0x9D; // NOP / reserve space
		image[ i++ ] = 0x9D; // NOP / reserve space
				
		image[ i++ ] = 0x35; // STHX WORKRAM (dir)
		image[ i++ ] = WORKRAM;
		
		image[ i++ ] = 0x45; // LDHX #DATABUF
		image[ i++ ] = DATABUF>>8;
		image[ i++ ] = DATABUF&0xFF;
		
		image[ i++ ] = 0xCD; // JSR GETBYTE ; calls the monitor routine
		image[ i++ ] = GETBYTE>>8;
		image[ i++ ] = GETBYTE&0xFF;
//		image[ i++ ] = 0xFE9C>>8;  ; // 0xFE9C = GET WITH echo
//		image[ i++ ] = 0xFE9C&0xFF;

		image[ i++ ] = 0xF7; // STA ,X
		
		image[ i++ ] = 0x5C; // INCX
		
		image[ i++ ] = 0xA3; // cpx #DATABUF+n
		n_addr=i;
		image[ i++ ] = 0; // place holder

		image[ i++ ] = 0x25; // BLO *-10
		image[ i++ ] = (-9)&0xFF;
		
		image[ i++ ] = 0x55; // LDHX WORKRAM (dir)
		image[ i++ ] = WORKRAM;
		
		image[ i++ ] = 0xCD; // JSR PRGRNGE ; calls the monitor routine
		image[ i++ ] = PRGRNGE>>8;
		image[ i++ ] = PRGRNGE&0xFF;
		
		image[ i++ ] = 0x45; // LDHX #SP+1 ; restore stack pointer
		image[ i++ ] = (SP+1) >> 8;
		image[ i++ ] = (SP+1) & 0xFF;
		
		image[ i++ ] = 0x94; // TXS 
		
		image[ i++ ] = 0xCC; // JMP back to MON (this is the only way)
		image[ i++ ] = MONRTN>>8;
		image[ i++ ] = MONRTN&0xFF;
		
		if (WORKRAM>=WORKTOP) { // leave some stack space for monitor routines
			flsprintf(stderr,"Not enough WORKRAM on target\n");
			abort();
			}
		
		writeMemory(WORKRAM , i-WORKRAM , 0);
		//dumpMemorySrec(WORKRAM , i-WORKRAM);
		lastMon=-1;
		}
		
	if (last_n!=n) {
		image[ n_addr ] = DATABUF+n;
		writeMemory(n_addr,1,0);
		last_n=n;
		}
		
	int laddr = faddr+n-1;
	image[ LADDR ] = laddr>>8;
	image[ LADDR+1 ] = laddr&0xFF;
	writeMemory(LADDR, 2, 0); 
	
	// now execute the fragment
	runFrom(WORKRAM+2, 0x00, 0x00, faddr); // NOTE! to override flash security and erase FLBPR at be used as the erase address for mass erase
	
	int i;
	for (i=0; i<n; ++i) 
		putByte(image[faddr+i]);
	for (i=0; i<n; ++i) 
		getByte();
		
	readSP();
	return 0;
	}	
	
int fastProg2(int faddr,int progn) {
	if (WORKRAM>0xFF) {
		flsprintf(stderr,"Work RAM must be on zero page\n");
		abort();
		}


	int SP = readSP();
	image[ CTRLBYT ] = 0; // CTRLBYT =0
	image[ CPUSPD ] = CPUSPEED; // CPUSPD=  16 MHz ext  => 4 MHz Fbus  = > 8

	// construct small HC908 code fragment to call the monitor function 
	int i = WORKRAM;
	int j;
	
	int FADDR=i;
	image[ i++ ] = faddr>>8; // FADDR initial contents
	image[ i++ ] = faddr&0xFF; 
	
	int PROGN=i;
	image[ i++ ] = progn>>8; // PROGN initial contents
	image[ i++ ] = progn&0xFF;	
		
	int start=i;
	
	if (lastMon!=-1) {
		image[ i++ ] = 0x55 ; //	LDHX PROGN  get bytes left to program
		image[ i++ ] = PROGN;		
		
		image[ i++ ] = 0x27 ; //	BEQ	DONE branch if all done
		int patchDone=i;
		image[ i++ ] = 0 ;
		
		image[ i++ ] = 0x65 ; //	CPHX #PAGESIZE  only page full at a time
		image[ i++ ] = 0 ; 
		image[ i++ ] = PAGESIZE; 
		
		
		image[ i++ ] = 0x25 ; //	BLO DOIT
		image[ i++ ] = 2 ; 
		
		image[ i++ ] = 0xAE ; //	LDX #PAGESIZE
		image[ i++ ] = PAGESIZE;  
		
		image[ i++ ] = 0x9F ; //	TXA
		
		image[ i++ ] = 0x87 ; //	PSHA
		
		image[ i++ ] = 0xB6 ; //	LDA  PROGN+1
		image[ i++ ] = PROGN+1;	
		
		image[ i++ ] = 0x9E; //		SUB 1,SP	
		image[ i++ ] = 0xE0;	
		image[ i++ ] = 1;	
		
		image[ i++ ] = 0xB7 ; //	STA PROGN+1
		image[ i++ ] = PROGN+1;	
		
		image[ i++ ] = 0xB6 ; //	LDA  PROGN
		image[ i++ ] = PROGN;	
		
		image[ i++ ] = 0xA2 ; //	SBC #0
		image[ i++ ] = 0 ; 
		
		image[ i++ ] = 0xB7 ; //	STA PROGN
		image[ i++ ] = PROGN;	

		image[ i++ ] = 0x9F ; //	TXA
				
		image[ i++ ] = 0x4A ; //	DECA
		
		image[ i++ ] = 0xBB ; //	ADD FADDR+1
		image[ i++ ] = FADDR+1;	
			
		image[ i++ ] = 0xB7 ; //	STA LADDR+1
		image[ i++ ] = LADDR+1;	
			
		image[ i++ ] = 0xB6 ; //	LDA  FADDR
		image[ i++ ] = FADDR;	
		
		image[ i++ ] = 0xA9 ; //	ADC #0
		image[ i++ ] = 0 ; 
		
		image[ i++ ] = 0xB7 ; //	STA  LADDR
		image[ i++ ] = LADDR;	
		
		image[ i++ ] = 0x45; //		LDHX #DATABUF
		image[ i++ ] = DATABUF>>8;
		image[ i++ ] = DATABUF&0xFF;
		
		image[ i++ ] = 0x86 ;//		PULA		

		int getMore=i;
		
		image[ i++ ] = 0x87 ; //	PSHA
				
		image[ i++ ] = 0xCD; //		JSR GETBYTE 
		image[ i++ ] = GETBYTE>>8;
		image[ i++ ] = GETBYTE&0xFF;
		
		image[ i++ ] = 0xF7; //		STA ,X
		
		image[ i++ ] = 0x5C; //		INCX
		
		image[ i++ ] = 0x86 ; //	PULA
		
		image[ i++ ] = 0x4A ; //	DECA
		
		image[ i++ ] = 0x26 ; //	BNE GETMORE
		j=i;
		image[ i++ ] = (getMore-(j+1))&0xFF ; 
		
		image[ i++ ] = 0x55 ; //	LDHX FADDR
		image[ i++ ] = FADDR;		

		image[ i++ ] = 0xCD; //		JSR PRGRNGE 
		image[ i++ ] = PRGRNGE>>8;
		image[ i++ ] = PRGRNGE&0xFF;
		
		image[ i++ ] = 0x8B;		// PSHH Annoyingly JB8 RDVRNG leaves H:X off by one
		image[ i++ ] = 0x89;		// PSHX compared to GZ16 necessiating this pus/pul sequence
		
		
		image[ i++ ] = 0x55 ;//		LDHX FADDR
		image[ i++ ] = FADDR;		

		image[ i++ ] = 0xA6 ; //	LDAA #1
		image[ i++ ] = 1 ; 
		
		image[ i++ ] = 0xCD; //		JSR RDVRRNG 
		image[ i++ ] = RDVRRNG>>8;
		image[ i++ ] = RDVRRNG&0xFF;
		
		image[ i++ ] = 0x88;		// PULX
		image[ i++ ] = 0x8A;		// PULH

		image[ i++ ] = 0x35 ; //	STHX FADDR
		image[ i++ ] = FADDR;	
		
		image[ i++ ] = 0xCD; //		JSR PUTBYTE 
		image[ i++ ] = PUTBYTE>>8;
		image[ i++ ] = PUTBYTE&0xFF;
							
		image[ i++ ] = 0x20 ; //	BRA start
		j=i;
		image[ i++ ] = (start-(j+1))&0xFF;
		
		image[patchDone] = (i-(patchDone+1))&0xFF;
		
		image[ i++ ] = 0x45; // LDHX #SP+1 ; restore stack pointer
		image[ i++ ] = (SP+1) >> 8;
		image[ i++ ] = (SP+1) & 0xFF;
		
		image[ i++ ] = 0x94; // TXS 
		
		image[ i++ ] = 0xCC; // JMP back to MON (this is the only way)
		image[ i++ ] = MONRTN>>8;
		image[ i++ ] = MONRTN&0xFF;
	
		if (i>=WORKTOP) { // leave some stack space for monitor routines
			flsprintf(stderr,"Not enough WORKRAM on target\n");
			abort();
			}
		
		writeMemory(WORKRAM , i-WORKRAM , 0);
		lastMon=-1;
		}
	else
		writeMemory(WORKRAM , 4 , 0);
		
	runFrom(start, 0x00, 0x00, 0); 
	
	while (progn) {
		int n = progn < PAGESIZE ? progn : PAGESIZE;
		int sum=0;
		for (i=0; i<n; ++i) {
			putByte(image[faddr+i]);
			}
		for (i=0; i<n; ++i) {
			int b=getByte();
			//flsprintf(stderr,"%d %02X\n",i,b);
			sum = (sum+b)&0xFF;
			if (b != image[faddr+i])
				flsprintf(stderr,"Program data transfer error, at %04X sent %02X got %02X\n",faddr+i,image[faddr+i],b);
			}
		int back=getByte();
			//flsprintf(stderr,"%02X\n",back);
		if (back != sum) {
			flsprintf(stderr,"Program checksum failure, at %04X size %04X checksum calculated %02X received %02X\n",faddr,n,sum,back);
			abort();
			}
		progn -= n;
		faddr += n;
		if (verbose)
			flsprintf(stdout,".");
		}
	return 0;
	}	
		
void massErase() {
// NOTE! to override flash security and erase FLBPR must be used as the erase address for mass erase
	if (verbose) 
		flsprintf(stdout,"Mass erase\n");
	callMonitor(ERARRNG , ERARRNG_MASS_ERASE, 0, EADDR, 0);
	}
	
void flashProgram(int addr,int size,int verify) {
	if (addr < FLASH) {
		flsprintf(stdout,"Programming address %04X below flash start address %04X\n",addr,FLASH);
		abort();
		}
	
	if (useFastProg) {
		if (verbose) 
			flsprintf(stdout,"Program %04X - %04X ",addr,addr+size-1);
				
		fastProg2(addr,size);
		if (verbose)
			flsprintf(stdout,"\n");
		}
	else {
		while (size>0) {
			int	n=size <= PAGESIZE ? size : PAGESIZE;
			if (verbose) 
				flsprintf(stdout,"Program %04X - %04X ",addr,addr+n-1);
				
			memcpy(&image[ DATABUF ] , &image[addr] , n);
			writeMemory(DATABUF , n , verbose);
			callMonitor(PRGRNGE, 0 , 0, addr , addr+n-1);
			
			if (verify) {
				int cca=callMonitor(RDVRRNG, 0 , 1 , addr , addr+n-1);
				int sum=0;
				int i;
				for (i=0; i<n; ++i) 
					sum = (sum + image[addr+i]) & 0xFF;
				int back= cca & 0xFF; // get Accu from target
				if (sum != back) {
					flsprintf(stderr,"Program checksum failure, at %04X size %04X checksum calculated %02X received %02X\n",addr,n,sum,back);
					abort();
					}
					
				if (!(cca & 0x0100)) { // check Carry bit from target
					flsprintf(stderr,"Verify failed\n");
					abort();
					}
				if (verbose)
					flsprintf(stdout,"OK");
				}
			if (verbose)
				flsprintf(stdout,"\n");
			addr += n;
			size -= n;
			}
		}
	}

int readSrec(int verbose,FILE* sf,unsigned char* image, int size,  int base, int* ranges, int rn) {
	if (verbose)
		flsprintf(stdout,"Reading S-records\n");
	memset(image,0xff,size);
	char line[2+2+255*2+2+1]; // Sx + count + 255 bytes for data address & checksum + CR/LF +nul (in windows)
	int amax=0;
	int rc=0;
	while (fgets(line,sizeof(line),sf)!=NULL) {
	   int o=0;
	   if (line[0]=='S') {
			unsigned int n,a;
			sscanf(line+2,"%2x",&n);
			n--;
			if (line[1]=='1') {
				sscanf(line+4,"%4x",&a);
				n=n-2;
				o=8;
			}
			if (line[1]=='2') {
				sscanf(line+4,"%6x",&a);
				n=n-4;
				o=10;
			}
			if (line[1]=='3') {
				sscanf(line+4,"%8x",&a);
				n=n-6;
				o=12;
			}
			if (o!=0) {
				int i,j;
				if (ranges) {
				    for (i=0; i<rc; i+=2) {
						int rlo=ranges[i];
						int rhi=rlo+ranges[i+1];
						if (!((a+n<=rlo) || (rhi<=a))) {
							flsprintf(stderr,"Overlapping S-record ranges %04X,%04X and %0x4 %04X\n",rlo,rhi-rlo,a,n);
							abort();
							}
						}
					if (rc + 2 >= rn) 
						return -1;
					ranges[rc]=a;
					ranges[rc+1]=n;
					rc += 2;
					
					int cf=0;
					do compact: {
						for (i=0; i<rc; i+=2) {
							for (j=i+2; j<rc; j+=2) {
								cf=1;
								if (ranges[i]+ranges[i+1]==ranges[j])
									ranges[i+1] += ranges[j+1];
								else if (ranges[i]==ranges[j]+ranges[j+1])
									ranges[i]-=ranges[j+1];
								else 
									cf=0;
								if (cf) {
									for (i=j+2; i<rc; i++)	
										ranges[i]=ranges[i+2];
									rc-=2;
									cf=0;
									goto compact;
									}
								}
							}
						} while (cf);
					}
				for (i=0; i<n; ++i) {
					unsigned int d;
					sscanf(line+o+i*2,"%2x",&d);
					if ( (a >= base) && (a < base+size)) {
						image[ a - base ] = d;
						a++;
						amax = a>amax ? a : amax;
						}
					}
				}
			}
		if (verbose>1)
			flsprintf(stdout,">>> %s",line);
		if (verbose && o==0)
			flsprintf(stdout,"Line ignored: %s\n",line);
		}
	if (verbose) {
		if (ranges) {
			int i;
			for (i=0; i<rc; i+=2) 
				flsprintf(stdout,"S-record data address %06X size %06X\n",ranges[i],ranges[i+1]);
			}
		flsprintf(stdout,"\n");
		}
	return rc;
	}
void printHelp() {
		flsprintf(stdout,"bl08 burns MC68HC908 Flash memory from S-record file(s) using Monitor mode\n");
		flsprintf(stdout,"Usage: \n");
		flsprintf(stdout," bl08 [-aBbcdefhiklmnpqrstuvwxy] [filename...]\n");
		flsprintf(stdout,"  -a address     Set dump memory address (needs -s option too)\n");
		flsprintf(stdout,"  -B baudrate    Set baud rate for target communication\n");
		flsprintf(stdout,"  -b speed       Set baud rate using speed_t value as defined in termios.h.\n");
		flsprintf(stdout,"                 The value is passed directly to cfsetXspeed() and can be\n");
		flsprintf(stdout,"                 used to set non-Posix baud rates. On MacOSX the value is\n");
		flsprintf(stdout,"                 equivalent to actual baud rate, whereas on Linux it is\n");
		flsprintf(stdout,"                 very different. If in doubt, use the -B option instead.\n");
		flsprintf(stdout,"  -c device      Set serial com device used to communicate with target\n"); 
		flsprintf(stdout,"                 (default '/dev/ttyS0')\n");
		flsprintf(stdout,"  -d dumpformat  Set dump format, supported formats are: 'srec'\n");
		flsprintf(stdout,"  -e             Erase target using mass erase mode, clearing security bytes\n");
		flsprintf(stdout,"  -f             Use fast programming method\n");		
		flsprintf(stdout,"  -g address     Go execute target code from address or use '-g reset'\n");
		flsprintf(stdout,"  -h             Print out this help text\n");
		flsprintf(stdout,"  -i             Read input (S-records) from standard input\n");
		flsprintf(stdout,"  -k             Kill previous instance of bl08\n");
		flsprintf(stdout,"  -l verbosity   Set verbosity level, valid values are 0-4, default 1\n");
		flsprintf(stdout,"  -m             Terminal emulator mode\n");
		flsprintf(stdout,"  -n             Print bl08 version number\n");
		flsprintf(stdout,"  -o param=value Override target parameter value\n");	
		flsprintf(stdout,"                 param = ROMBASE,FLASH,PUTBYTE,GETBYTE,RDVRRNG,MONRTN\n");
		flsprintf(stdout,"                         ERARRNG,PRGRNGE,FLBPR,MONDATA,PAGESIZE,EADDR,RAM\n");	
		flsprintf(stdout,"  -p             Use page erase when programming flash\n");	
		flsprintf(stdout,"  -q             Run quietly, same as -l 0\n");		
		flsprintf(stdout,"  -s size        Set dump memory size\n");
		flsprintf(stdout,"  -r pulse       Pulse DTR for pulse milliseconds\n");
		flsprintf(stdout,"  -t cputype     Set CPU type, valid values are: gz16, jb8, qy2\n");
		flsprintf(stdout,"  -u             Upload only (do not program flash)\n");
		flsprintf(stdout,"  -v             Verify when programming \n");
		flsprintf(stdout,"  -w pin=value   Set serial port pin state\n");
		flsprintf(stdout,"                 pin=LE,DTR,RTS,ST,SR,CTS,CAR,CD,RNG,RI,DSR\n");
		flsprintf(stdout,"                 val=1/0, 1=negative pin voltage\n");
		flsprintf(stdout,"  -x cpuspeed    Set CPU speed, typically set for Fbus (in MHz) x 4 \n");
		flsprintf(stdout,"  -y string      Security code, as a string of hex bytes\n");
		flsprintf(stdout,"  -z             Do not program, do no upload, just read in the S-rec file \n");
		flsprintf(stdout," addresses and sizes in decimal, for hex prefix with '0x'\n");
		// Example
	exit(0);
	}


void termEmu()
	{
	int STDIN=0;
	int STDOUT=1;
	// get rid of stuff that has been echoed to us
	tcflush(com,TCIFLUSH ); // .. then get rid of the echoes and what ever...


	struct termios newtio,oldtio;
	tcgetattr(STDIN,&oldtio);  // we do not want to change the console setting forever, so keep the old
	tcgetattr(STDIN,&newtio);  // configure the console to return as soon as it a key is pressed
    newtio.c_lflag = 0;    
    newtio.c_cc[VTIME]    = 0;   
    newtio.c_cc[VMIN]     = 1;   
    tcsetattr(STDIN,TCSANOW,&newtio);

	flsprintf(stdout,"\nTerminal mode, press CTRL-C to exit.\n");

    fd_set readfs;    
    int    maxfd;     
    int res;
	char buf[2];
    maxfd = com+1;  
    
    while (1) {
		// wait for something from console or serial port
		FD_SET(STDIN, &readfs);  
		FD_SET(com, &readfs);  
		struct timeval tout;
		tout.tv_usec = 10; 
		tout.tv_sec  = 0; 
		select(maxfd, &readfs, NULL, NULL, &tout);

		// copy console stuff to the serial port
		if (FD_ISSET(STDIN,&readfs))   {    
			res=read(STDIN,buf,1);
			if (buf[0]==3) break; // CTRL-C terminates terminal mode
			write(com,buf,res);
		}
		// copy serial port stuff to console				
		if (FD_ISSET(com,&readfs)){    
			res=read(com,buf,1);
			write(STDOUT,buf,res);
			fflush(stdout);
			}
	}

	tcsetattr(0,TCSANOW,&oldtio); // restore console settings

///	close(con);
	}

void setCPUtype(char* cpu) {
	if (strcmp("gz16",cpu)==0 || strcmp("mc68hc908gz16",cpu)==0) {
		// These settings depend on the CPU version
		CPUSPEED=8;
		FLASH=0xC000;
		PUTBYTE=0xFEAF; 
		GETBYTE=0x1C00;
		RDVRRNG=0x1C03;
		ERARRNG=0x1C06;
		PRGRNGE=0x1C09;
		MONRTN=0xFE20;
		FLBPR=0xFF7E;
		EADDR=FLBPR;
		RAM = 0x40;
		}
	else if (strcmp("jb8",cpu)==0 || strcmp("mc68hc908jb8",cpu)==0) {
		// These settings depend on the CPU version
		CPUSPEED=12; // typically run at 6 MHz, bus freq 3 Mhz
		FLASH=0xDC00;
		PUTBYTE=0xFED6; 
		GETBYTE=0xFC00;
		RDVRRNG=0xFC03;
		ERARRNG=0xFC06;
		PRGRNGE=0xFC09;
		MONRTN=0xFE55;
		FLBPR=0xFE09;
		EADDR=FLASH;
		RAM = 0x40;
		}
	else if (strcmp("qy2",cpu)==0 || strcmp("mc68hlc908qy",cpu)==0) {
		// These settings depend on the CPU version
		//CPUSPEED=12;
		FLASH=0xF800;
		PUTBYTE=0xFE9F;  // FIXME?
		GETBYTE=0x2800;
		RDVRRNG=0x2803;
		ERARRNG=0x2806;
		PRGRNGE=0x2809;
		MONRTN=0xFE55;   // FIXME?
		FLBPR=0xFFBE;
		EADDR=FLASH;     // FIXME?
		RAM = 0x80;
		}
	else {
		flsprintf(stderr,"Unsupported CPU type '%s'\n",cpu);
		flsprintf(stderr,"The supported CPU types are:\n");
		flsprintf(stderr,"\tmc68hc908gz16 (gz16)\n");
		flsprintf(stderr,"\tmc68hc908jb8 (jb8)\n");
		flsprintf(stderr,"\tmc68hlc908qy2 (qy2)\n");
		abort();
		}
	// These are independent of CPU type
	PAGESIZE = 64;
	MONDATA = RAM+8;
	CTRLBYT  =  MONDATA+0;
	CPUSPD  =  MONDATA+1;
	LADDR  =  MONDATA+2;
	DATABUF  =  MONDATA+4;
	WORKRAM = DATABUF + PAGESIZE;
	WORKTOP = 0xF0; // this leaves 16 bytes for stack, the deepest ROM routines use 11 so there some for myself too
	if (DATABUF+PAGESIZE>0xFF) {
		flsprintf(stderr,"bl08 limitation, DATABUF+PAGESIZE>0xFF, DATABUF=%04X, PAGESIZE=%04X\n",DATABUF,PAGESIZE);
		abort();
		}
	}
	
	
int getIntArg(char* arg) {
	if (strlen(arg)>=2 && memcmp(arg,"0x",2)==0) {
		unsigned int u;
		sscanf(arg+2,"%X",&u);
		return u;
		}
	else {
		int d;
		sscanf(arg,"%d",&d);
		return d;
		}
	}
	
	
void parseOverride(char* str) {	
	char* vp=strstr(str,"=");
	if (!vp) {
		flsprintf(stderr,"Bad override syntax, no '=' found\n");
		abort();
		}
	*vp=0;
	vp++;
	int val=getIntArg(vp);
	if (strcmp("ROMBASE",str)==0) {
		GETBYTE=val+0;
		RDVRRNG=val+3;
		ERARRNG=val+6;
		PRGRNGE=val+9;
		}
	else if (strcmp("FLASH",str)==0) FLASH=val;
	else if (strcmp("PUTBYTE",str)==0) PUTBYTE=val;
	else if (strcmp("GETBYTE",str)==0) GETBYTE=val;
	else if (strcmp("RDVRRNG",str)==0) RDVRRNG=val;
	else if (strcmp("ERARRNG",str)==0) ERARRNG=val;
	else if (strcmp("PRGRNGE",str)==0) PRGRNGE=val;
	else if (strcmp("FLBPR",str)==0) FLBPR=val;
	else if (strcmp("RAM",str)==0) RAM=val;
	else if (strcmp("MONDATA",str)==0) MONDATA=val;
	else if (strcmp("PAGESIZE",str)==0) PAGESIZE=val;
	else if (strcmp("MONRTN",str)==0) MONRTN=val;
	else if (strcmp("EADDR",str)==0) EADDR=val;
	else {
		flsprintf(stderr,"Attempt to override unrecognized variable %s\n",str);
		abort();
		}
	}
	
void parseIOControl(char* str) {	
	char* vp=strstr(str,"=");
	if (!vp) {
		flsprintf(stderr,"Bad pin control syntax, no '=' found\n");
		abort();
		}
	*vp=0;
	vp++;
	int val=getIntArg(vp);
	if (val!=0 && val!=1) {
		flsprintf(stderr,"Bad pin control value %d (not 1/0)\n",val);
		abort();
		}
	
	int i;
	for (i=0; i<sizeof(portPins)/sizeof(portPins[0]); i++) {
		if (strcmp(portPins[i].str,str)==0)  {
			forcePins[i]=val+1;
			return;
			}
	}
	
	flsprintf(stderr,"Attempt to set unrecognized pin %s\n",str);
	abort();	
	}


void parseBaudrate(char* str) {	
	int i;
	for (i=0; i<sizeof(baudrates)/sizeof(baudrates[0]); ++i) {
		if (strcmp(baudrates[i].str,str)==0) {
			baudRate=baudrates[i].val;
			return;
			}
		}
	flsprintf(stderr,"Attempt to set unrecognized baud rate %s\n",str);
	abort();	
	}

void parseTermSpeed(char* str) {	
	if (sscanf(str,"%d",&baudRate)!=1) {
		flsprintf(stderr,"Failed to set terminal speed %s\n",str);
		abort();	
		}
	}

void setSecurityCode(char* str) {
	int i;
	int consumed;
	for (i=0; i<8 && *str; ++i) {
		if (sscanf(str," %2hhx%n",&scode[i],&consumed)!=1) {
			flsprintf(stderr,"Bad security code: %s\n",str);
			abort();
			}
		str += consumed;
		while (*str==' ') str++; /* tolerate spaces */
		if (*str==':') str++;    /* and one colon */
		}
	if (i<8) {
		flsprintf(stderr,"Found only %d bytes in security code\n",i);
		abort();
		}
	}
	
void parseArgs(int argc, char *argv[]) {	
	int c;
	while ((c = getopt (argc, argv, "a:B:b:c:d:efg:hikl:mno:pqr:s:t:uvw:x:y:z")) != -1) {
		switch (c) {
			case 'a' :
				dumpStart=getIntArg(optarg);
				break;
			case 'B' : 
				parseBaudrate(optarg);
				break;
			case 'b' : 
				parseTermSpeed(optarg);
				break;
			case 'c' : 
				COM=optarg;
				break;
			case 'd' :
				dumpFormat=optarg;
				break;
			case 'e' :
				eraseFlash = 1;
				break;
			case 'f' :
				useFastProg = 1;
				break;
			case 'g' :
				executeCode=optarg;
				break;
			case 'h' :
				printHelp();
				break;
			case 'i' :
				useStdin = 1;
				break;
			case 'k' :
				killPrevious = 1;
				break;
			case 'l' :
				sscanf(optarg,"%d",&verbose); 
				break;
			case 'm' :
				terminalMode=1;
				break;
			case 'n' :
				flsprintf(stdout,"%s\n",version);
				break;
			case 'o' :
				parseOverride(optarg);
				break;
			case 'p' :
				pageErase=1;
				break;
			case 'q' :
				verbose=0;
				break;
			case 'r' :
				resetPulse=getIntArg(optarg);
				break;
			case 's' :
				dumpSize=getIntArg(optarg);
				break;
			case 't' :
				setCPUtype(optarg);
				break;
			case 'u' :
				uploadOnly=1;
				break;
			case 'v' :
				verify=1;
				break;
			case 'w' :
				parseIOControl(optarg);
				break;
			case 'x' :
				sscanf(optarg,"%d",&CPUSPEED); 
				break;
			case 'y' :
				setSecurityCode(optarg);
				break;
			case 'z' :
				loadOnly=1; 
				break;
			case '?' :
				if (isprint (optopt))
					flsprintf(stderr,"Unknown option `-%c'.\n", optopt);
				else
					flsprintf(stderr,"Unknown option character `\\x%x'.\n",optopt);
			  default:
				flsprintf(stderr,"Bug, unhandled option '%c'\n",c);
				abort ();
			}
		}
	if (argc<=1) 
		printHelp();
	}


void generateReset() {
	struct timespec tspec;
	int s;
	
	ioctlErrCheck(ioctl(com, TIOCMGET, &s)); 
	s |= TIOCM_DTR;
	ioctlErrCheck(ioctl(com, TIOCMSET, &s)); 
		
	tspec.tv_sec=resetPulse/1000;
	tspec.tv_nsec=(resetPulse%1000)*1000000; 
	nanosleep(&tspec,0);
	
	s &= ~TIOCM_DTR;
	ioctlErrCheck(ioctl(com, TIOCMSET, &s)); 

	tspec.tv_sec=0;
	tspec.tv_nsec=1000000; /* wait at least 1 ms */
	nanosleep(&tspec,0);
	}


void deletePidFile() {
	int stat=remove(PIDFILENAME);
	if (stat)
		flsprintf(stderr,"remove returned %d\n",stat);
	}
	
void killPreviousInstance() {
	atexit(deletePidFile);
	int pid;
	FILE* pidf=fopen(PIDFILENAME,"r");
	if (pidf) {
		fscanf(pidf,"%d",&pid);
		int stat=kill(pid,SIGKILL);
		if (stat!=0)
			flsprintf(stderr,"kill returned %d\n",stat);
			
		fclose(pidf);
		waitpid(pid,&stat,0);
		if (WIFEXITED(stat)==0)
			flsprintf(stderr,"waitpid returned %d\n",WIFEXITED(stat));
		}
	pidf=fopen(PIDFILENAME,"w");
	fprintf(pidf,"%d\n",getpid());
	fclose(pidf);
	}

int main(int argc, char *argv[]) {	
	
	// default values
	setCPUtype("gz16");
	
	parseArgs(argc,argv);
	
	
	if (killPrevious)
		killPreviousInstance();
	

	if (verbose)
		flsprintf(stdout,"bl08 - MC68HC908 Bootloader - version %s\n",version);
	
	memset(image,0xFF,sizeof(image));
	
	int maxrc=256;
	int ranges[maxrc];
	int rc=0;
	
	if (useStdin) 
		rc += readSrec(verbose , stdin , image , sizeof(image) , 0x0000 , ranges+rc , maxrc - rc);
	
	int i;
	for (i=optind; i<argc; i++) {
		char* filename=argv[i];
		FILE* sf = fopen(filename, "r");
		if (sf == NULL) { 
			flsprintf(stderr,"Failed to open '%s'\n", filename);
			abort();
			}
		
		int rn=readSrec(verbose , sf , image , sizeof(image) , 0x0000 , ranges+rc , maxrc - rc);
		if (rn<0) {
			flsprintf(stderr,"Too many discontinuous data ranges in S-record file '%s'\n",filename);
			abort();
			}
		rc += rn;		
		fclose(sf);
		}
		
	if (!loadOnly) {
		initSerialPort();
			
		if (resetPulse)
			generateReset();
		
		if (eraseFlash) {
			connectTarget();
			massErase();
			}
		
		if (rc>0) {
			connectTarget();
			if (pageErase) {
				for (i=0; i<rc; ) {
					int addr=ranges[ i++ ];
					int size=ranges[ i++ ];
					int a = addr / PAGESIZE * PAGESIZE;
					while (a<addr+size) {
						if (verbose)
							flsprintf(stdout,"Erase %04X - %04X\n",a,PAGESIZE);
					
						callMonitor(ERARRNG, ERARRNG_PAGE_ERASE, 0, a, 0);
						a += PAGESIZE;
						}
					}
				}
			else
				massErase();	
		
			int i;
			for (i=0; i<rc;) {
				int addr=ranges[ i++ ];
				int size=ranges[ i++ ];
				if (uploadOnly) {
					if (verbose)
						flsprintf(stdout,"Uploading memory contents\n");
					writeMemory(addr,size,verbose);
					if (verbose)
						flsprintf(stdout,"\n");
					}
				else 
					flashProgram(addr , size , verify);
				if (verbose>1) {
					flsprintf(stdout,"Reading back memory/flash content\n");
					readMemory(addr , size, verbose);
					flsprintf(stdout,"\n");
					dumpMemory(addr , size);
					}
				}
			}


		if (executeCode) {
			connectTarget();
			int addr;
			if (strcmp("reset",executeCode)==0) {
				readMemory(0xFFFE,2,0);
				addr=((image[0xFFFE]&0xFF)<<8) | (image[0xFFFF]&0xFF);
				/* Unlocked flash reads as 0xAD everywhere */
				if (addr == 0xADAD) {
					flsprintf(stdout,"Could not read reset vector, flash security locked?\n");
					abort();
					}
				}
			else  
				addr=getIntArg(executeCode);

			if (verbose)
				flsprintf(stdout,"Execute code from %04X\n",addr);
			runFrom(addr,0,0,0);
			}
		
		if (terminalMode) 
			termEmu();
		}

	if (dumpSize>0) {
		if (!loadOnly) {
			connectTarget();
			if (verbose) 
				flsprintf(stdout,"Reading memory\n");
			readMemory(dumpStart,dumpSize, verbose);
			}
		if (verbose) 
			flsprintf(stdout,"\n");
		
		if (dumpFormat) {
			if (strcmp("srec",dumpFormat)==0)
				dumpMemorySrec(dumpStart,dumpSize);
			else if (strcmp("hex",dumpFormat)==0)
				dumpMemory(dumpStart,dumpSize);
			else
				flsprintf(stderr,"Unknown dump format '%s'\n",dumpFormat);
			}
		}
			
	return 0;
	}