#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);
}

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

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();
	}
	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();
	/* autofeed, init, strobe were set by set_address */
}

void insert_chip() {
	char foo[42];

	fprintf(stderr,"Set jumpers, insert chip, press enter\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
 */

void read_byte(int addr) {
	set_address(addr);
	putchar(get_data());
}

void read_chip(int bytes) {
	int i;

	for(i=0;i<bytes;i++) {
		read_byte(i);
	}
}

int get_size() {
	return 1048576;
}

void vibrate() {
	static struct ppdev_frob_struct en, di;

	en.mask=PARPORT_CONTROL_SELECT;
	en.val=PARPORT_CONTROL_SELECT;

	di.mask=PARPORT_CONTROL_SELECT;
	di.val=0;

	for(;;) {
		ioctl(pport,PPFCONTROL,&en);
		getuid();
		ioctl(pport,PPFCONTROL,&di);
	}
}

void pulse() {
	struct timespec timespec;

	timespec.tv_sec=0; timespec.tv_nsec=50000;

	for(;;) {
		enable_oe();
		/* nanosleep(timespec,NULL); */
		usleep(50);
		disable_oe();
	}
}

void bug() {
	unsigned int addr;
	unsigned char c;

	for(;;) {
		fprintf(stderr,"> ");
		scanf("%x",&addr);
		if(addr==0x6660)
			vibrate();
		if(addr==0x6661)
			pulse();
		set_address(addr);
		c=get_data();
		fprintf(stderr,"%x=%x\n",addr,c);
	}
}

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

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