/* based on dumprom.c -- program a 27c010, 1mbit, 128kbyte eprom */

#include <stdio.h>
#include <sys/ioctl.h>
#include <linux/ppdev.h>
#include <linux/parport.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>

int pport=-1;

/*
 * Controlling the parallel interface
 */

void check_if_bidirectional() {
	unsigned int modes;

	if(ioctl(pport,PPGETMODES,&modes)) {
		perror("ioctl");
		exit(1);
	}
	if(!(modes&PARPORT_MODE_TRISTATE)) {
		fprintf(stderr,"Port is not bidirectional!\n");
		exit(1);
	}
}

void init_os() {
	pport=open("/dev/parport0",O_RDWR);
	if(pport==-1) {
		perror("open parallel port");
		exit(1);
	}
	if(ioctl(pport,PPEXCL)) {
		perror("ioctl");
		exit(1);
	}
	if(ioctl(pport,PPCLAIM)) {
		perror("ioctl");
		exit(1);
	}
	check_if_bidirectional();
}

/* set the data lines to be outputs */
void direction_output() {
	int i=0;

	if(ioctl(pport,PPDATADIR,&i)) {
		perror("ioctl");
		exit(1);
	}
}

/* set the data lines to be inputs */
void direction_input() {
	int i=1;

	if(ioctl(pport,PPDATADIR,&i)) {
		perror("ioctl");
		exit(1);
	}
}

/* write to the pport data lines */
void data_out(unsigned char c) {
	if(ioctl(pport,PPWDATA,&c)) {
		perror("ioctl");
		exit(1);
	}
}

/* read from the pport data lines */
unsigned char data_in() {
	char c;

	if(ioctl(pport,PPRDATA,&c)) {
		perror("ioctl");
		exit(1);
	}
	return c;
}

void frob_control(unsigned char mask, unsigned char val) {
	static struct ppdev_frob_struct foo;

	foo.mask=mask;
	foo.val=val;

	if(ioctl(pport,PPFCONTROL,&foo)) {
		perror("ioctl");
		exit(1);
	}
}

/* set the eprom's output enable line inactive (logic high) */
void disable_oe() {
	frob_control(PARPORT_CONTROL_SELECT,0);
}

/* set the eprom's output enable line active (logic low) */
void enable_oe() {
	frob_control(PARPORT_CONTROL_SELECT,PARPORT_CONTROL_SELECT);
}

/* set the shift-register strobe low */
void strobe_low() {
	frob_control(PARPORT_CONTROL_STROBE,PARPORT_CONTROL_STROBE);
}

/* set the shift-register strobe high; clock in the bits */
void strobe_high() {
	frob_control(PARPORT_CONTROL_STROBE,0);
}

void autofeed_high() {
	frob_control(PARPORT_CONTROL_AUTOFD,0);
}

void autofeed_low() {
	frob_control(PARPORT_CONTROL_AUTOFD,PARPORT_CONTROL_AUTOFD);
}

inline void init_high() {
	frob_control(PARPORT_CONTROL_INIT,PARPORT_CONTROL_INIT);
}

inline void init_low() {
	frob_control(PARPORT_CONTROL_INIT,0);
}

/*
 * Delays
 */

void shiftreg_delay() {
	struct timespec foo;
	struct sched_param high, normal;

	high.sched_priority=99;
	normal.sched_priority=0;

	foo.tv_sec=0; foo.tv_nsec=666;
	sched_setscheduler(0,SCHED_FIFO,&high);
	nanosleep(foo,NULL);
	sched_setscheduler(0,SCHED_OTHER,&normal);
	/* actually we barely need to delay at all from a setup/hold point of
	   view. however, we have to keep the clocking to the register less
	   than 1.5MHz */
}

void read_delay() {
	/*shiftreg_delay();*/
}

/*
 * Controlling the epromseed hardware
 */

/* if the abit'th bit in addr is set, return a value with the dbit'th bit set */
int dbit(int dbit, int abit, int addr) {
	dbit=1<<dbit;
	abit=1<<abit;
	if(addr&abit) {
		return dbit;
	} else {
		return 0;
	}
}

void set_address(int addr) {
	unsigned char d;

	disable_oe();
	direction_output();

	/* The Qd bits */
	d=0;
	d|=dbit(0,4,addr);
	d|=dbit(1,16,addr);
	d|=dbit(2,10,addr);
	d|=dbit(3,15,addr);
	data_out(d);
	strobe_low();
	shiftreg_delay();
	strobe_high();
	shiftreg_delay();

	/* The Qc bits */
	d=0;
	d|=dbit(0,1,addr);
	d|=dbit(1,5,addr);
	d|=dbit(2,12,addr);
	d|=dbit(3,11,addr);
	data_out(d);
	strobe_low();
	shiftreg_delay();
	strobe_high();
	shiftreg_delay();

	/* The Qb bits */
	d=0;
	d|=dbit(0,2,addr);
	d|=dbit(1,6,addr);
	d|=dbit(2,14,addr);
	d|=dbit(3,9,addr);
	data_out(d);
	strobe_low();
	shiftreg_delay();
	strobe_high();
	shiftreg_delay();

	/* The Qa bits */
	d=0;
	d|=dbit(0,3,addr);
	d|=dbit(1,7,addr);
	d|=dbit(2,13,addr);
	d|=dbit(3,8,addr);
	data_out(d);
	strobe_low();
	shiftreg_delay();
	strobe_high();
	shiftreg_delay();

	/* A0 */
	if((addr&1)==0)
		strobe_low();

	/* dedicated lines */
	if(addr&(1<<17)) {
		autofeed_high();
	} else {
		autofeed_low();
	}
/* init line is used as /PGM
	if(addr&(1<<18)) {
		init_high();
	} else {
		init_low();
	}
*/
}

unsigned char get_data() {
	unsigned char c;

	direction_input();
	enable_oe();
	read_delay();
	c=data_in();
	disable_oe();
	return c;
}

void make_hw_safe() {
	/* or as safe as possible. */
	/* the optimal solution: drive all the address lines low, the oe and ce
	   low (active), the data lines high-Z, and the vcc high-Z. */
	/* but we can't really do that; if we try to high-Z the data lines, we
	   might actually end up with them weakly pulled up; and with no vcc,
	   that might cause the chip to latch up. */
	/* so what we actually do is: address lines low, oe and ce high,
	   data lines driven low, vcc high. */
	set_address(0);
	direction_output();
	data_out(0);
	disable_oe();
	init_low(); /* warning: this is /PGM! */
	/* autofeed, strobe were set by set_address */
}

void insert_chip() {
	char foo[42];

	fprintf(stderr,"Set jumpers, disconnect Vpp, insert chip, press enter\n");
	fprintf(stderr,"(JP6/JP1 no jumper)\n");
	fgets(foo,13,stdin);
	init_high(); /* Inhibit program */
	fprintf(stderr,"Now connect Vpp and press enter\n");
	fprintf(stderr,"(JP1 jumpered)\n");
	fgets(foo,13,stdin);
}

void init_hw() {
	init_os();
	make_hw_safe();
	insert_chip();
}

void exit_hw() {
	make_hw_safe();
}

/*
 * The high-level algorithm
 */

unsigned char *read_data(int bytes) {
	unsigned char *p;
	int i;
	FILE *f;

	p=malloc(bytes);
	if(!p) {
		perror("malloc");
		exit(1);
	}

	f=fopen("rom","r");
	if(!f) {
		perror("fopen");
		exit(1);
	}

	i=fread(p,bytes,1,f);
	if(i!=1) {
		perror("fread");
		exit(1);
	}

	fclose(f);

	return p;
}

void program_pulse() {
	static struct timespec timespec;

	timespec.tv_sec=0; timespec.tv_nsec=90000; /* 90us+program delay=~105us */

	init_low();
	nanosleep(timespec,NULL);
	init_high();
}

void write_data(unsigned char data) {
	direction_output();	
	data_out(data);
	program_pulse();
	/* here, we could data_out(data^0xff) to detect a missing chip, but
	   that'd slow down programming, so let it slide and catch it on the
	   full chip verify */
	direction_input();
}

void write_device(unsigned char *data, int bytes) {
	int addr;
	unsigned char readback;
	int retries;

	retries=0;
	for(addr=0;addr<bytes;addr++) {
		if((addr&0xfff)==0)
			fprintf(stderr,"\rWriting: %x [%d pulse%s]   ",addr,retries+1,retries==0?"":"s");
		retries=0;
		set_address(addr);
		for(;;) {
			write_data(data[addr]);
			readback=get_data();
			if(readback==data[addr]) {
				write_data(data[addr]); /* 1 extra pulse (since we didn't verify at correct voltage) */
				break;
			}
			retries++;
			if(retries>=25) {
				fprintf(stderr,"\nDevice failed while writing address %x. wanted %x got %x\n",addr,data[addr],readback);
				exit(1);
			}
		}
	}
	fprintf(stderr,"\n");
}

unsigned char read_byte(int addr) {
	set_address(addr);
	return get_data();
}

void verify_device(unsigned char *data, int bytes) {
	int addr;
	unsigned char readback;

	for(addr=0;addr<bytes;addr++) {
		if((addr&0xffff)==0)
			fprintf(stderr,"\rVerifying: %x",addr);
		readback=read_byte(addr);
		if(readback!=data[addr]) {
			fprintf(stderr,"\nDevice failed while verifying address %x. wanted %x got %x\n",addr,data[addr],readback);
			exit(1);
		}
	}
	fprintf(stderr,"\n");
}

void write_chip(int bytes) {
	unsigned char *data;

	fprintf(stderr,"Reading data...");
	data=read_data(bytes);
	fprintf(stderr,"\n");
	write_device(data,bytes);
	verify_device(data,bytes);
	fprintf(stderr,"Done!\n");
}

int get_size() {
	return 131072;
}

void vibrate() {
	for(;;) {
		program_pulse();
	}
}

void bug() {
	vibrate();
}

int main(int argc, char **argv) {
	int size;

	size=get_size();
	init_hw();
	if(argc==2) {
		bug();
	} else {
		write_chip(size);
	}
	exit_hw();
	exit(0);
}