#include <windows.h>
#include <stdio.h>
#include <conio.h>

// RTS is connected to PGC for clock
// CTS is connected to PGD for reading back data
// TXD is also connected to PGD via a 4.7k resistor for sending data
// SETBREAK makes PGD low
// SETRTS makes PGC low

typedef unsigned short U16;
typedef unsigned char U8;

char *_pszPort="COM1";
HANDLE _hComm=INVALID_HANDLE_VALUE;

static void SetPGC(int n)
{
	EscapeCommFunction(_hComm,n ? CLRRTS : SETRTS);
}

static void SetPGD(int n)
{
	EscapeCommFunction(_hComm,n ? CLRBREAK : SETBREAK);
}

static void Prompt(char *psz)
{
	printf("\n%s. Hit any key to continue.",psz);

	getch();
	while (kbhit())
	{
		getch();
	}
}

static void BitSend(int n)
{
	SetPGD(n & 1);
	SetPGC(1);
	SetPGC(0);
}

static int BitRead(void)
{
	DWORD dw;

	SetPGC(1);
	GetCommModemStatus(_hComm,&dw);
	SetPGC(0);
	return (dw & MS_CTS_ON) ? 0 : 1;
}

static void CmdSend(U8 u8)
{
	int n;

	u8&=0x3F;

	for (n=0;n<6;n++)
	{
		BitSend(u8);
		u8>>=1;
	}
}

static void DataSend(U16 u16)
{
	int n;

	u16<<=1;
	u16&=0x7FFE;
	for (n=0;n<16;n++)
	{
		BitSend(u16 & 0x01);
		u16>>=1;
	}
}

static U16 DataRead(void)
{
	int n;
	U16 u16=0;

	for (n=0;n<16;n++)
	{
		u16=(u16>>1) | (BitRead() ? 0x8000 : 0);
	}
	return (u16>>1) & 0x3FFF;
}

static void CmdLoadConfiguration(void)
{
	CmdSend(0x00);
	DataSend(0x3FFF); /* Send dummy data */
}

static void CmdLoadDataProgram(U16 u16)
{
	CmdSend(0x02);
	DataSend(u16);
}

static void CmdLoadDataMemory(U16 u16)
{
	CmdSend(0x03);
	DataSend(u16);
}

static U16 CmdReadDataProgram(void)
{
	CmdSend(0x04);
	return DataRead();
}

static U16 CmdReadDataMemory(void)
{
	CmdSend(0x05);
	return DataRead();
}

static void CmdEraseProgram(U16 u16Wait)
{
	CmdSend(0x08);
	Sleep(u16Wait);
}

static void CmdIncrement(void)
{
	CmdSend(0x06);
}

static void CmdBulkEraseSetup1(void)
{
	CmdSend(0x01);
}

static void CmdBulkEraseSetup2(void)
{
	CmdSend(0x07);
}

static void CmdProgram(U16 u16Wait)
{
	CmdSend(0x18);
	Sleep(u16Wait);
}

static void CmdChipErase(void)
{
	CmdSend(0x1F);
	Sleep(10);
}

static void CmdEndProgramming(void)
{
	CmdSend(0x17);
}

static BOOL ReadHexDigit(char *psz,U8 *pu8)
{
	char c=*psz;

	if (c>='0' && c<='9')
	{
		*pu8=c-'0';
	}
	else
	{
		if (c>='a' && c<='f')
		{
			*pu8=c-'a'+10;
		}
		else
		{
			if (c>='A' && c<='F')
			{
				*pu8=c-'A'+10;
			}
			else
			{
				return FALSE;
			}
		}
	}
	return TRUE;
}

static BOOL ReadHexPair(char *psz,U8 *pu8)
{
	U8 u8;

	if (psz[0]=='\0' || psz[1]=='\0')
	{
		return FALSE;
	}
	if (!ReadHexDigit(psz,&u8))
	{
		return FALSE;
	}
	*pu8=u8<<4;
	if (!ReadHexDigit(psz+1,&u8))
	{
		return FALSE;
	}
	*pu8|=u8 & 0x0F;
	return TRUE;
}

int main(int nArgs,char *apszArgs[])
{
	FILE *pfIn=NULL;
	DCB dcb;
	U16 u16PC=0;
	int nLine=0;
	BOOL bFinished=FALSE;
	U16 au16Data[16384];
	U16 u16DeviceID;

	fprintf(stderr,"LVB Tracker firmware uploader v0.2 G6LVB\n");

	{
		int n;

		for (n=0;n<16384;n++)
		{
			au16Data[n]=0x3FFF;
		}
	}

	// Default config bits...
	// Osc=XT, WDT off, PUT on, BOD off, LVP off, FPW on, DBG off, data EE prot off, CodeProt off
	au16Data[0x2007]=0x3F31; 

	if (nArgs<=1)
	{
		fprintf(stderr,"Usage: %0 <hexfile> [<port>]\n");
		fprintf(stderr,"where <port> is of the from COM1, COM2 etc. Default is COM1.\n");
		return -1;
	}

	if (nArgs>=3)
	{
		_pszPort=apszArgs[2];
	}

	if ((pfIn=fopen(apszArgs[1],"rb"))==NULL)
	{
		fprintf(stderr,"OS Error: %d. Unable to open file: %s\n",_doserrno,apszArgs[1]);
		return _doserrno;
	}

	printf("Reading Hex file...\n");

	while (!feof(pfIn) && !bFinished)
	{
		char szLine[1024];
		char *psz=szLine;
		U8 u8Len;
		U16 u16Addr;
		U8 u8RecType;
		U8 u8;
		U8 u8Checksum=0;
		int n;

		if (fgets(szLine,sizeof(szLine)-1,pfIn)!=NULL)
		{
			szLine[1023]='\0';

			if (szLine[strlen(szLine)-1]=='\r')
			{
				szLine[strlen(szLine)-1]='\0';
			}
			nLine++;
		}
		else
		{
			if (!feof(pfIn))
			{
				fprintf(stderr,"OS Error: %d. fgets() failed on file %s\n",_doserrno,apszArgs[1]);
				fclose(pfIn);
				pfIn=NULL;
				return _doserrno;
			}
			else
			{
				break;
			}
		}
		if (*psz++!=':')
		{
			fprintf(stderr,"':' expected in file %s, line %d\n",apszArgs[1],nLine);
			fclose(pfIn);
			pfIn=NULL;
			return -1;
		}
		if (!ReadHexPair(psz,&u8Len))
		{
			fprintf(stderr,"Record length hexadecimal pair expected in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
			fclose(pfIn);
			pfIn=NULL;
			return -1;
		}
		u8Checksum+=u8Len;
		psz+=2;
		if ((u8Len & 1)!=0)
		{
			fprintf(stderr,"Record length must be even in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
			fclose(pfIn);
			pfIn=NULL;
			return -1;
		}
		u8Len>>=1;
		if (!ReadHexPair(psz,&u8))
		{
			fprintf(stderr,"Load address high hexadecimal pair expected in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
			fclose(pfIn);
			pfIn=NULL;
			return -1;
		}
		u8Checksum+=u8;
		psz+=2;
		u16Addr=((U16)u8)<<8;
		if (!ReadHexPair(psz,&u8))
		{
			fprintf(stderr,"Load address low hexadecimal pair expected in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
			fclose(pfIn);
			pfIn=NULL;
			return -1;
		}
		u8Checksum+=u8;
		psz+=2;
		u16Addr|=u8;
		if ((u16Addr & 0x01)!=0)
		{
			fprintf(stderr,"Invalid load address (must be even) in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
			fclose(pfIn);
			pfIn=NULL;
			return -1;
		}
		u16Addr>>=1;

		if (!ReadHexPair(psz,&u8RecType))
		{
			fprintf(stderr,"Record type hexadecimal pair expected in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
			fclose(pfIn);
			pfIn=NULL;
			return -1;
		}
		u8Checksum+=u8RecType;
		psz+=2;

		switch(u8RecType)
		{
			case 0:

				for (n=0;n<u8Len;n++)
				{
					U16 u16Data;

					if (!ReadHexPair(psz,&u8))
					{
						fprintf(stderr,"Data hexadecimal pair expected in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
						fclose(pfIn);
						pfIn=NULL;
						return -1;
					}
					u8Checksum+=u8;
					psz+=2;
					u16Data=u8;

					if (!ReadHexPair(psz,&u8))
					{
						fprintf(stderr,"Data hexadecimal pair expected in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
						fclose(pfIn);
						pfIn=NULL;
						return -1;
					}
					u8Checksum+=u8;
					psz+=2;
					u16Data|=((U16)u8)<<8;

					u16PC=u16Addr;

					if (u16PC%16==0)
					{
						printf("Reading: %04X\r",u16PC);
					}
					au16Data[u16PC & 0x3FFF]=u16Data;
					u16PC++;
					u16Addr++;
					if (u16PC%16==0)
					{
						printf("Reading: %04X\r",u16PC);
					}
				}
				if (!ReadHexPair(psz,&u8))
				{
					fprintf(stderr,"Checksum hexadecimal pair expected in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
					fclose(pfIn);
					pfIn=NULL;
					return -1;
				}
				u8Checksum+=u8;
				psz+=2;
				if (u8Checksum!=0)
				{
					fprintf(stderr,"Checksum failed in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
					fclose(pfIn);
					pfIn=NULL;
					return -1;
				}
				break;

			case 1:
				if (strnicmp(szLine,":00000001FF",11)!=0)
				{
					fprintf(stderr,"Invalid end of file record in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
					fclose(pfIn);
					pfIn=NULL;
					return -1;
				}
				printf("Reading: %04X\r",u16PC);
				bFinished=TRUE;
				break;

			default:
				fprintf(stderr,"Unsupported record type in file %s, line %d, position %d\n",apszArgs[1],nLine,psz-szLine);
				fclose(pfIn);
				pfIn=NULL;
				return -1;
		}
	}
	fclose(pfIn);
	pfIn=NULL;

	Prompt("\nSwitch OFF device");
	Prompt("Place HDR1 into PGM mode");
	Prompt("Insert HDR3");
	Prompt("Switch ON device");

	_hComm=CreateFile(_pszPort,GENERIC_READ | GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);

   if (_hComm==INVALID_HANDLE_VALUE)
	{
		fprintf(stderr,"OS Error: %d. Unable to open port: %s\n",GetLastError(),_pszPort);
		return GetLastError();
	}

	if (!GetCommState(_hComm,&dcb))
	{
		CloseHandle(_hComm);
		_hComm=INVALID_HANDLE_VALUE;
		fprintf(stderr,"OS Error: %d. GetCommState failed.\n",GetLastError());
      return GetLastError();
   }

	dcb.BaudRate=CBR_9600;      // set the baud rate
	dcb.ByteSize=8;             // data size, xmit, and rcv
	dcb.Parity=NOPARITY;        // no parity bit
	dcb.StopBits=ONESTOPBIT;    // one stop bit

	if (!SetCommState(_hComm,&dcb))
	{
		CloseHandle(_hComm);
		_hComm=INVALID_HANDLE_VALUE;
		fclose(pfIn);
		pfIn=NULL;
		fprintf(stderr,"OS Error: %d. SetCommState failed.\n",GetLastError());
      return GetLastError();
   }

	printf("\nCOM port %s is configured.\n",_pszPort);

	SetPGC(0);
	SetPGD(0);

	Prompt("Press RESET button");

	printf("\nIdentifying device... ");

	CmdLoadConfiguration(); // Procedure to bulk erase if code protected
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();

	// Identify chip...
	u16DeviceID=CmdReadDataProgram();
	printf("\nChip ID=%04X",u16DeviceID);

	switch (u16DeviceID & 0x3FE0)
	{
		case 0x09E0: // 16F876
			printf("\n16F876 identified");
			break;
		case 0x0E00: // 16F876A
			printf("\n16F876A identified");
			break;
		default:
			printf("\nChip not recognised (must be 16F876 or 16F876A)\n");
			return -1;
	}
	switch (u16DeviceID & 0x3FE0)
	{
		case 0x09E0:
			printf("\nBeginning bulk erase... ");

			CmdLoadConfiguration(); // Need to restart load config for a 16f87x
			CmdIncrement();
			CmdIncrement();
			CmdIncrement();
			CmdIncrement();
			CmdIncrement();
			CmdIncrement();
			CmdIncrement();
			CmdBulkEraseSetup1();
			CmdBulkEraseSetup2();
			CmdEraseProgram(40);
			CmdBulkEraseSetup1();
			CmdBulkEraseSetup2();
			printf("\nBulk erase finished.\n");
			break;

		case 0x0E00:
			printf("\nBeginning chip erase... ");

			CmdChipErase();
			break;
	}

	SetPGC(0);
	SetPGD(0);
	Prompt("Press RESET button");

	printf("\nProgramming device...\n");

	for (u16PC=0;u16PC<8192;u16PC++)
	{
		U16 u16Data=au16Data[u16PC];
		U16 u16MaskTest;

		switch (u16DeviceID & 0x3FE0)
		{
			case 0x09E0:
				if (u16Data!=0x3FFF)
				{
					CmdLoadDataProgram(u16Data);
					CmdProgram(20);
				}
				break;
			case 0x0E00:
				if (u16PC%8==0)
				{
					u16MaskTest=u16Data;
				}
				else
				{
					u16MaskTest&=u16Data;
				}
				CmdLoadDataProgram(u16Data);

				// Eight loads done and at least one zero bit to write, then program...
				if (u16PC%8==7 && u16MaskTest!=0x3FFF) 
				{
					CmdProgram(2);
					CmdEndProgramming();
				}
				break;
		}
		if (u16PC%16==0)
		{
			printf("Programming: %04X\r",u16PC);
		}
		CmdIncrement();
	}

	printf("Verifying device...\n");

	for (u16PC=0;u16PC<8192;u16PC++)
	{
		U16 u16Data=au16Data[u16PC];
		U16 u16Read=CmdReadDataProgram();

		if (u16PC%16==0)
		{
			printf("Verifying: %04X\r",u16PC);
		}
		if (u16Data!=u16Read)
		{
			fprintf(stderr,"Incorrect program data found at address %04X reads %04X should be %04X\n",u16PC,u16Read,u16Data);
		}
		CmdIncrement();
	}

	printf("Configuring device...\n");

	CmdLoadConfiguration();
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();
	CmdIncrement();
	CmdLoadDataProgram(au16Data[0x2007]);

	switch (u16DeviceID & 0x3FE0)
	{
		case 0x09E0:
			CmdProgram(20);
			break;
		case 0x0E00:
			CmdEraseProgram(20);
			break;
	}

	printf("Verifying configuration...\n");

	{
		U16 u16Data=au16Data[0x2007];
		U16 u16Read=CmdReadDataProgram();

		if (u16Data!=u16Read)
		{
			fprintf(stderr,"Incorrect configuration data found: reads %04X should be %04X\n",u16Read,u16Data);
		}
	}

	Prompt("\nSwitch OFF device");
	Prompt("Remove HDR3");
	Prompt("Place HDR1 into RUN mode");
	Prompt("Device programmed");
	
	CloseHandle(_hComm);
	_hComm=INVALID_HANDLE_VALUE;

	return 0;
}