///////////////////////////////////////////////////////////////////////////////
// Includes
///////////////////////////////////////////////////////////////////////////////

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <ctype.h>
#include <windows.h>

///////////////////////////////////////////////////////////////////////////////
// Typedefs
///////////////////////////////////////////////////////////////////////////////

typedef unsigned int  _int16;
typedef unsigned long _int32;
typedef unsigned char _byte;

///////////////////////////////////////////////////////////////////////////////
// Constants
///////////////////////////////////////////////////////////////////////////////

#define	VERSION			"1.02"
#define	DEFAULT_PORT	1
#define	DEFAULT_SPEED	115200

///////////////////////////////////////////////////////////////////////////////
// Debugging functions
///////////////////////////////////////////////////////////////////////////////

// printf() for debugging
void odprintf(const char *format, ...)
{
  char     buf[4096], *p = buf;
  va_list  args;

  va_start(args, format);
  p += _vsnprintf(p, sizeof buf - 1, format, args);
  va_end(args);

  while (p > buf && isspace(p[-1]))
    *--p = '\0';

  *p++ = '\r';
  *p++ = '\n';
  *p   = '\0';

  OutputDebugString(buf);
}

#ifdef DEBUG
#define LOG(x) odprintf("%s:%s[%d]: %s", __FILE__, __PRETTY_FUNCTION__, __LINE__, x);
#else
#define LOG(x)
#endif

///////////////////////////////////////////////////////////////////////////////
// Serial port driver functions
///////////////////////////////////////////////////////////////////////////////

static	HANDLE		hCom;

int	serial_Init(int comNumber, int baudRate)
{
	DCB				dcb;
	COMMTIMEOUTS	CommTimeOuts;
	char			comName[32];
	
	// generate the device name
	sprintf(comName, "COM%d", comNumber);

	// open the port
	if ((hCom = CreateFile(comName,
			GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
			FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE) {
		// error opening port
		return 1;
	}

    CommTimeOuts.ReadIntervalTimeout =  MAXDWORD;
    CommTimeOuts.ReadTotalTimeoutMultiplier = 0;
    CommTimeOuts.ReadTotalTimeoutConstant = 1000;
    CommTimeOuts.WriteTotalTimeoutMultiplier = 0;
    CommTimeOuts.WriteTotalTimeoutConstant = 1000;
    if ( !SetCommTimeouts( hCom, &CommTimeOuts )){
      CloseHandle(hCom);
      return 2; // SetCommTimeouts error
    }
    dcb.DCBlength = sizeof ( DCB ) ;
    dcb.BaudRate = baudRate;
    dcb.fBinary = TRUE ;
    dcb.fParity = FALSE;
    dcb.fOutxCtsFlow = TRUE;         // CTS output flow control
    dcb.fOutxDsrFlow = FALSE;         // DSR output flow control
    dcb.fDtrControl =  DTR_CONTROL_ENABLE;         // DTR flow control type
    dcb.fDsrSensitivity = FALSE;      // DSR sensitivity
    dcb.fTXContinueOnXoff = 0;    // XOFF continues Tx
    dcb.fOutX = FALSE;                // XON/XOFF output flow control
    dcb.fInX = FALSE;                 // XON/XOFF input flow control
    dcb.fErrorChar = 0;           // enable error replacement
    dcb.fNull = FALSE;                // enable null stripping
    dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;          // RTS flow control
    dcb.fAbortOnError = FALSE;        // abort reads/writes on error
    dcb.XonLim = 2048;            // transmit XON threshold
    dcb.XoffLim = 512;            // transmit XOFF threshold
    dcb.ByteSize = 8;             // number of bits/byte, 4-8
    dcb.Parity = NOPARITY;        // 0-4=no,odd,even,mark,space
    dcb.StopBits = ONESTOPBIT;    // 0,1,2 = 1, 1.5, 2
    dcb.XonChar = 17;             // Tx and Rx XON character
    dcb.XoffChar = 19;            // Tx and Rx XOFF character
    dcb.ErrorChar = 0;            // error replacement character
    dcb.EofChar = 0;              // end of input character
    dcb.EvtChar = 0;              // received event character

	if (!SetCommState(hCom, &dcb)){
		CloseHandle(hCom);
		return 3;		// SetCommState error
	}

	return 0;
}         

void serial_Done(void)
{
	CloseHandle(hCom);
}

/*
  Read one character
    when it reads a character, it returns 1
    when there is no character to read, it returns 0
*/
int serial_ReadChar(unsigned char *c)
{
	DWORD length;
	if( !ReadFile(hCom, c, 1, &length, NULL) ) return 0;
	return length;
}

void serial_WriteChar(unsigned char c)
{
	DWORD length;
	WriteFile(hCom, &c, 1, &length, NULL);
}

int serial_ReadBlock(unsigned char *c, size_t size)
{
	DWORD length;

	if (!ReadFile(hCom, c, size, &length, NULL) ) return 0;
	return length;
}

void serial_WriteBlock(unsigned char *c, size_t size)
{
	DWORD length;
	WriteFile(hCom, c, size, &length, NULL);
}

void serial_Flush(void)
{	
	PurgeComm(hCom, PURGE_RXCLEAR | PURGE_TXCLEAR);
}

///////////////////////////////////////////////////////////////////////////////
// Syntax error handler / help screen
///////////////////////////////////////////////////////////////////////////////

static struct option long_opts[] = {
	{"input",	required_argument,	0,	'i'},
	{"device",	required_argument,	0,	'd'},
	{"port",	required_argument,	0,	'p'},
	{"speed",	required_argument,	0,	's'}
};

static char *short_opts = "i:d:p:s:";

void syntax(void)
{
	printf("Syntax:\n");
	printf("\tepromemu {--device=|-d}<device> {--input=|-i}<filename>\n");
	printf("\t         {--port | -p}<port> {--speed | -s}<speed>\n");
	printf("\nWhere:\n");
	printf("\t--device (or -d):\tSelect device type (see list below).\n");
	printf("\t--input  (or -i):\tSet input file name.\n");
	printf("\t--port   (or -p):\tSet COM port number (default 1 = COM1).\n");
	printf("\t--speed  (or -s):\tSet COM port baud rate (default 115200).\n");
	printf("\n\n");
	printf("Supported devices: 2764/64, 27128/128, 27256/256, 27512/512.\n");
}

///////////////////////////////////////////////////////////////////////////////
// Entry point
///////////////////////////////////////////////////////////////////////////////

int main(int argc, char **argv)
{
	FILE			*fin;							// Input file
	unsigned char	buffer[256];					// Data buffer
	unsigned char	packet[512];					// Packet buffer
	unsigned long	pktlen;							// Packet length
	unsigned char	checksum;						// Checksum accumulator
	unsigned char	retCode;						// Return code / error code
	unsigned long	i, count;						// Loop variables
	unsigned long	addr;							// Current address
	DWORD			timeA, timeB;					// Time of start/finish
	double			time;							// Time taken to load ROM
///// Command line params
	char			*filename = NULL;				// Input filename
	int				device = -1;					// Device type
	unsigned long	maxaddr;						// Maximum address for the selected device
	int				port = DEFAULT_PORT;			// COM port number
	unsigned long	speed = DEFAULT_SPEED;			// Baud rate
	
///// Internal versions of the params
	unsigned char	deviceid;						// Device ID

	// Display the startup banner
	printf("EPROM emulator downloader ver. %s\n", VERSION);
	printf("Copyleft 2005, Philip Pemberton <philpem@dsl.pipex.com>. All rights reversed.\n");

	// Parse the command line
	while (TRUE) {
		int opt_index, c;

		c = getopt_long(argc, argv, short_opts, long_opts, &opt_index);
		if (c == -1) {
			break;
		}
		
		switch (c) {
			case 'i':
				// "-i" or "--input" --> set input filename
				filename = strdup(optarg);
				break;

			case 'd':
				// "-d" or "--device" --> set device type

				for (i=0; i<strlen(optarg); i++) {
					if (!isdigit(optarg[i])) {
						printf("Error: Invalid character in device ID.\n");
						return 1;
					}
				}

				device = atoi(optarg);
				break;

			case 'p':
				// "-p" or "--port" --> set com port
				if (port != DEFAULT_PORT) {
					printf("Can't specify more than one baud rate.\n");
					return 1;
				}

				for (i=0; i<strlen(optarg); i++) {
					if (!isdigit(optarg[i])) {
						printf("Error: Invalid character in COM port number.\n");
						return 1;
					}
				}
				port = atoi(optarg);
				break;

			case 's':
				// "-s" or "--speed" --> set com port baud rate
				if (speed != DEFAULT_SPEED) {
					printf("Can't specify more than one baud rate.\n");
					return 1;
				}

				for (i=0; i<strlen(optarg); i++) {
					if (!isdigit(optarg[i])) {
						printf("Error: Invalid character in baud rate.\n");
						return 1;
					}
				}
				speed = atoi(optarg);
				break;
		}
	}

	// Make sure all the required parameters have been provided
	if (filename == NULL) {
		printf("Error: no filename specified.\n");
		syntax();
		return 1;
	}

	if (device == -1) {
		printf("Error: no device specified.\n");
		syntax();
		return 1;
	}

	// Convert the device type into an actual device ID
	switch (device) {
		case 64:
		case 2764:
			// 2764. We have to load the data twice.
			deviceid = 0x00;
			maxaddr = 0x2000;
			break;
		case 128:
		case 27128:
			// 27128
			deviceid = 0x01;
			maxaddr = 0x4000;
			break;
		case 256:
		case 27256:
			// 27256
			deviceid = 0x02;
			maxaddr = 0x8000;
			break;
		case 512:
		case 27512:
			// 27512
			deviceid = 0x03;
			maxaddr = 0x10000;
			break;
		default:
			printf("Error: invalid device type.\n");
			syntax();
			return 1;
	}

	// Open the serial port
	if (serial_Init(port, speed)) {
		// Error...
		printf("Error opening serial port. Aborting.\n");
		return 1;
	}
	atexit(serial_Done);

	// now upload it
	timeA = GetTickCount();

	// Flush the emulator's serial buffer
	if (sizeof(packet) < 512) {
		printf("COMPILE FUCKUP: sizeof(packet) < 512!\n");
	}
	memset(packet, 0, sizeof(packet));
	serial_WriteBlock(packet, 400);

////////////////

	// Get the version ID
	pktlen = 0; checksum = 0;
	packet[pktlen++] = 0x56; checksum += 0x56;
	packet[pktlen++] = (~checksum)+1;
    serial_Flush();
	serial_WriteBlock(packet, pktlen);

	if (!serial_ReadChar(&retCode)) { printf("Error reading from COM port. Aborting.\n"); return 1; }
	if (!serial_ReadChar(&packet[0])) { printf("Error reading from COM port. Aborting.\n"); return 1; }
	if (!serial_ReadChar(&packet[1])) { printf("Error reading from COM port. Aborting.\n"); return 1; }
	if (!serial_ReadChar(&packet[2])) { printf("Error reading from COM port. Aborting.\n"); return 1; }

	if (retCode != 0x00) {
		printf("Error %d getting version number. Aborting.\n", retCode);
		return(0);
	}
	printf("Firmware ver: %d.%d (hardware ID 0x%02X)\n", packet[0], packet[1], packet[2]);

////////////////

	// Get the hardware ID
	pktlen = 0; checksum = 0;
	packet[pktlen++] = 'G'; checksum += 'G';
	packet[pktlen++] = (~checksum)+1;
    serial_Flush();
	serial_WriteBlock(packet, pktlen);

	if (!serial_ReadChar(&retCode)) { printf("Error reading from COM port. Aborting.\n"); return 1; }

	pktlen = 0;
    do {
		serial_ReadChar(&packet[pktlen++]);
    } while (packet[pktlen-1] != 0);

	if (retCode != 0x00) {
		printf("Error %d getting hardware ID. Aborting.\n", retCode);
		return(0);
	}
	printf("Hardware: %s\n", packet);

////////////////

	// Put the emulator into "Load" mode
	pktlen = 0; checksum = 0;
	packet[pktlen++] = 'M'; checksum += 'M';
	packet[pktlen++] = 0x00; checksum += 0x00;
	packet[pktlen++] = deviceid; checksum += deviceid;
	packet[pktlen++] = (~checksum)+1;
    serial_Flush();
	serial_WriteBlock(packet, pktlen);

	if (!serial_ReadChar(&retCode)) { printf("Error reading from COM port. Aborting.\n"); return 1; }

	if (retCode != 0x00) {
		printf("Error %d setting load mode. Aborting.\n", retCode);
		return(0);
	}

////////////////

	// Open the input file
	fin = fopen(filename, "rb");
	free(filename);
	if (fin == NULL) {
		printf("Error opening input file for binary read. Aborting.\n");
		return 1;
	}

////////////////

	addr = 0x0000;

	// Main loop
	while ((!feof(fin)) && (addr < maxaddr)) {
		// Read a data block from the file
		count = fread(&buffer, 1, 256, fin);

		if (count == 0) break;

		// Convert it into a packet
		pktlen = 0; checksum = 0;
		packet[pktlen++] = 'W'; checksum += 'W';
		packet[pktlen++] = (addr >> 8);   checksum += (addr >> 8);
		packet[pktlen++] = (addr & 0xff); checksum += (addr & 0xff);
		packet[pktlen++] = count-1;       checksum += count-1;

		for (i=0; i<count; i++) {
			packet[pktlen++] = buffer[i]; checksum += buffer[i];
		}

		packet[pktlen++] = (~checksum)+1;
	    serial_Flush();
		serial_WriteBlock(packet, pktlen);

       	if (!serial_ReadChar(&retCode)) { printf("Error reading from COM port [%04lX]. Aborting.\n", addr); return 1; }
		if (retCode != 0x00) {
			printf("Error %d loading block 0x%04lX. Aborting.\n", retCode, addr);
		}

		addr += count;
	}

	// 2764?
	if (deviceid == 0x00) {
		// Yes. We need to load the data again.
		rewind(fin);
		while ((!feof(fin)) && (addr < 0x4000)) {
			// Read a data block from the file
			count = fread(&buffer, 1, 256, fin);
	
			if (count == 0) break;
	
			// Convert it into a packet
			pktlen = 0; checksum = 0;
			packet[pktlen++] = 'W'; checksum += 'W';
			packet[pktlen++] = (addr >> 8);   checksum += (addr >> 8);
			packet[pktlen++] = (addr & 0xff); checksum += (addr & 0xff);
			packet[pktlen++] = count-1;       checksum += count-1;
	
			for (i=0; i<count; i++) {
				packet[pktlen++] = buffer[i]; checksum += buffer[i];
			}
	
			packet[pktlen++] = (~checksum)+1;
		    serial_Flush();
			serial_WriteBlock(packet, pktlen);
	
	       	if (!serial_ReadChar(&retCode)) { printf("Error reading from COM port [%04lX]. Aborting.\n", addr); return 1; }
			if (retCode != 0x00) {
				printf("Error %d loading block 0x%04lX. Aborting.\n", retCode, addr);
			}
	
			addr += count;
		}
	}

////////////////

	// Put the emulator into "Run" mode, 27512 target
	pktlen = 0; checksum = 0;
	packet[pktlen++] = 'M'; checksum += 'M';
	packet[pktlen++] = 0x01; checksum += 0x01;
	packet[pktlen++] = deviceid; checksum += deviceid;
	packet[pktlen++] = (~checksum)+1;
    serial_Flush();

	serial_WriteBlock(packet, pktlen);

	if (!serial_ReadChar(&retCode)) { printf("Error reading from COM port. Aborting.\n"); return 1; }

	if (retCode != 0x00) {
		printf("Error %d setting load mode. Aborting.\n", retCode);
		return(0);
	}

////////////////

	// Close the input file
	fclose(fin);

	timeB = GetTickCount();

	time = (timeB - timeA) / 1000.0;
	printf("Load completed in %0.2lf seconds.\n", time);

	return 0;
}