/*
 *	Linux driver for the PC110 pad
 */
 
/**
 * 	DOC: PC110 Digitizer Hardware
 *
 *	The pad provides triples of data. The first byte has
 *	0x80=bit 8 X, 0x01=bit 7 X, 0x08=bit 8 Y, 0x01=still down
 *	The second byte is bits 0-6 X
 *	The third is bits 0-6 Y
 *
 *	This is read internally and used to synthesize a stream of
 *	triples in the form expected from a PS/2 device. Specialist
 *	applications can choose to obtain the pad data in other formats
 *	including a debugging mode.
 *
 *	It would be good to add a joystick driver mode to this pad so
 *	that doom and other game playing are better. One possible approach
 *	would be to deactive the mouse mode while the joystick port is opened.
 */
 
/*
 *	History
 *
 *	0.0 1997-05-16 Alan Cox <alan@redhat.com> - Pad reader
 *	0.1 1997-05-19 Robin O'Leary <robin@acm.org> - PS/2 emulation
 *	0.2 1997-06-03 Robin O'Leary <robin@acm.org> - tap gesture
 *	0.3 1997-06-27 Alan Cox <alan@redhat.com> - 2.1 commit
 *	0.4 1997-11-09 Alan Cox <alan@redhat.com> - Single Unix VFS API changes
 *	0.5 2000-02-10 Alan Cox <alan@redhat.com> - 2.3.x cleanup, documentation
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/miscdevice.h>
#include <linux/ptrace.h>
#include <linux/poll.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/smp_lock.h>
#include <linux/init.h>

#include <asm/signal.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/semaphore.h>
#include <linux/spinlock.h>
#include <asm/uaccess.h>

#include "pc110pad.h"


static struct pc110pad_params default_params = {
	mode:			PC110PAD_PS2,
	bounce_interval:	50 MS,
	tap_interval:		200 MS,
	irq:			10,
	io:			0x15E0,
};

static struct pc110pad_params current_params;


/* driver/filesystem interface management */
static wait_queue_head_t queue;
static struct fasync_struct *asyncptr;
static int active;	/* number of concurrent open()s */
static struct semaphore reader_lock;

/**
 *	wake_readers:
 *
 *	Take care of letting any waiting processes know that
 *	now would be a good time to do a read().  Called
 *	whenever a state transition occurs, real or synthetic. Also
 *	issue any SIGIO's to programs that use SIGIO on mice (eg
 *	Executor)
 */
 
static void wake_readers(void)
{
	wake_up_interruptible(&queue);
	kill_fasync(&asyncptr, SIGIO, POLL_IN);
}


/*****************************************************************************/
/*
 * Deal with the messy business of synthesizing button tap and drag
 * events.
 *
 * Exports:
 *	notify_pad_up_down()
 *		Must be called whenever debounced pad up/down state changes.
 *	button_pending
 *		Flag is set whenever read_button() has new values
 *		to return.
 *	read_button()
 *		Obtains the current synthetic mouse button state.
 */

/*
 * These keep track of up/down transitions needed to generate the
 * synthetic mouse button events.  While recent_transition is set,
 * up/down events cause transition_count to increment.  tap_timer
 * turns off the recent_transition flag and may cause some synthetic
 * up/down mouse events to be created by incrementing synthesize_tap.
 */
 
static int button_pending;
static int recent_transition;
static int transition_count;
static int synthesize_tap;
static void tap_timeout(unsigned long data);
static struct timer_list tap_timer = { function: tap_timeout };


/**
 * tap_timeout:
 * @data: Unused
 *
 * This callback goes off a short time after an up/down transition;
 * before it goes off, transitions will be considered part of a
 * single PS/2 event and counted in transition_count.  Once the
 * timeout occurs the recent_transition flag is cleared and
 * any synthetic mouse up/down events are generated.
 */
 
static void tap_timeout(unsigned long data)
{
	if(!recent_transition)
	{
		printk(KERN_ERR "pc110pad: tap_timeout but no recent transition!\n");
	}
	if( transition_count==2 || transition_count==4 || transition_count==6 )
	{
		synthesize_tap+=transition_count;
		button_pending = 1;
		wake_readers();
	}
	recent_transition=0;
}


/**
 * notify_pad_up_down:
 *
 * Called by the raw pad read routines when a (debounced) up/down
 * transition is detected.
 */
 
void notify_pad_up_down(void)
{
	if(recent_transition)
	{
		transition_count++;
	}
	else
	{
		transition_count=1;
		recent_transition=1;
	}
	mod_timer(&tap_timer, jiffies + current_params.tap_interval);

	/* changes to transition_count can cause reported button to change */
	button_pending = 1;
	wake_readers();
}

/**
 *	read_button:
 *	@b: pointer to the button status.
 *
 *	The actual button state depends on what we are seeing. We have to check
 *	for the tap gesture and also for dragging.
 */

static void read_button(int *b)
{
	if(synthesize_tap)
	{
		*b=--synthesize_tap & 1;
	}
	else
	{
		*b=(!recent_transition && transition_count==3);	/* drag */
	}
	button_pending=(synthesize_tap>0);
}


/*****************************************************************************/
/*
 * Read pad absolute co-ordinates and debounced up/down state.
 *
 * Exports:
 *	pad_irq()
 *		Function to be called whenever the pad signals
 *		that it has new data available.
 *	read_raw_pad()
 *		Returns the most current pad state.
 *	xy_pending
 *		Flag is set whenever read_raw_pad() has new values
 *		to return.
 * Imports:
 *	wake_readers()
 *		Called when movement occurs.
 *	notify_pad_up_down()
 *		Called when debounced up/down status changes.
 */

/*
 * These are up/down state and absolute co-ords read directly from pad 
 */

static int raw_data[3];
static int raw_data_count;
static int raw_x, raw_y;	/* most recent absolute co-ords read */
static int raw_down;		/* raw up/down state */
static int debounced_down;	/* up/down state after debounce processing */
static enum { NO_BOUNCE, JUST_GONE_UP, JUST_GONE_DOWN } bounce=NO_BOUNCE;
				/* set just after an up/down transition */
static int xy_pending;	/* set if new data have not yet been read */

/* 
 * Timer goes off a short while after an up/down transition and copies
 * the value of raw_down to debounced_down.
 */
 
static void bounce_timeout(unsigned long data);
static struct timer_list bounce_timer = { function: bounce_timeout };



/**
 * bounce_timeout:
 * @data: Unused
 *
 * No further up/down transitions happened within the
 * bounce period, so treat this as a genuine transition.
 */

static void bounce_timeout(unsigned long data)
{
	switch(bounce)
	{
		case NO_BOUNCE:
		{
			/*
			 * Strange; the timer callback should only go off if
			 * we were expecting to do bounce processing!
			 */
			printk(KERN_WARNING "pc110pad, bounce_timeout: bounce flag not set!\n");
			break;
		}
		case JUST_GONE_UP:
		{
			/*
			 * The last up we spotted really was an up, so set
			 * debounced state the same as raw state.
			 */
			bounce=NO_BOUNCE;
			if(debounced_down==raw_down)
			{
				printk(KERN_WARNING "pc110pad, bounce_timeout: raw already debounced!\n");
			}
			debounced_down=raw_down;

			notify_pad_up_down();
			break;
		}
		case JUST_GONE_DOWN:
		{
			/*
			 * We don't debounce down events, but we still time
			 * out soon after one occurs so we can avoid the (x,y)
			 * skittering that sometimes happens.
			 */
			bounce=NO_BOUNCE;
			break;
		}
	}
}


/**
 * pad_irq:
 * @irq: Interrupt number
 * @ptr: Unused
 * @regs: Unused
 *
 * Callback when pad's irq goes off; copies values in to raw_* globals;
 * initiates debounce processing. This isn't SMP safe however there are
 * no SMP machines with a PC110 touchpad on them.
 */
 
static void pad_irq(int irq, void *ptr, struct pt_regs *regs)
{

	/* Obtain byte from pad and prime for next byte */
	{
		int value=inb_p(current_params.io);
		int handshake=inb_p(current_params.io+2);
		outb_p(handshake | 1, current_params.io+2);
		outb_p(handshake &~1, current_params.io+2);
		inb_p(0x64);

		raw_data[raw_data_count++]=value;
	}

	if(raw_data_count==3)
	{
		int new_down=raw_data[0]&0x01;
		int new_x=raw_data[1];
		int new_y=raw_data[2];
		if(raw_data[0]&0x10) new_x+=128;
		if(raw_data[0]&0x80) new_x+=256;
		if(raw_data[0]&0x08) new_y+=128;

		if( (raw_x!=new_x) || (raw_y!=new_y) )
		{
			raw_x=new_x;
			raw_y=new_y;
			xy_pending=1;
		}

		if(new_down != raw_down)
		{
			/* Down state has changed.  raw_down always holds
			 * the most recently observed state.
			 */
			raw_down=new_down;

			/* Forget any earlier bounce processing */
			if(bounce)
			{
				del_timer(&bounce_timer);
				bounce=NO_BOUNCE;
			}

			if(new_down)
			{
				if(debounced_down)
				{
					/* pad gone down, but we were reporting
					 * it down anyway because we suspected
					 * (correctly) that the last up was just
					 * a bounce
					 */
				}
				else
				{
					bounce=JUST_GONE_DOWN;
					mod_timer(&bounce_timer,
						jiffies+current_params.bounce_interval);
					/* start new stroke/tap */
					debounced_down=new_down;
					notify_pad_up_down();
				}
			}
			else /* just gone up */
			{
				if(recent_transition)
				{
					/* early bounces are probably part of
					 * a multi-tap gesture, so process
					 * immediately
					 */
					debounced_down=new_down;
					notify_pad_up_down();
				}
				else
				{
					/* don't trust it yet */
					bounce=JUST_GONE_UP;
					mod_timer(&bounce_timer,
						jiffies+current_params.bounce_interval);
				}
			}
		}
		wake_readers();
		raw_data_count=0;
	}
}

/**
 *	read_raw_pad:
 *	@down: set if the pen is down
 *	@debounced: set if the debounced pen position is down
 *	@x: X position
 *	@y: Y position
 *
 *	Retrieve the data saved by the interrupt handler and indicate we
 *	have no more pending XY to do. 
 *
 *	FIXME: We should switch to a spinlock for this.
 */

static void read_raw_pad(int *down, int *debounced, int *x, int *y)
{
	disable_irq(current_params.irq);
	{
		*down=raw_down;
		*debounced=debounced_down;
		*x=raw_x;
		*y=raw_y;
		xy_pending = 0;
	}
	enable_irq(current_params.irq);
}

/*****************************************************************************/
/*
 * Filesystem interface
 */

/* 
 * Read returns byte triples, so we need to keep track of
 * how much of a triple has been read.  This is shared across
 * all processes which have this device open---not that anything
 * will make much sense in that case.
 */
static int read_bytes[3];
static int read_byte_count;

/**
 *	sample_raw:
 *	@d: sample buffer
 *
 *	Retrieve a triple of sample data. 
 */


static void sample_raw(int d[3])
{
	d[0]=raw_data[0];
	d[1]=raw_data[1];
	d[2]=raw_data[2];
}

/**
 *	sample_rare:
 *	@d: sample buffer
 *
 *	Retrieve a triple of sample data and sanitize it. We do the needed
 *	scaling and masking to get the current status.
 */


static void sample_rare(int d[3])
{
	int thisd, thisdd, thisx, thisy;

	read_raw_pad(&thisd, &thisdd, &thisx, &thisy);

	d[0]=(thisd?0x80:0)
	   | (thisx/256)<<4
	   | (thisdd?0x08:0)
	   | (thisy/256)
	;
	d[1]=thisx%256;
	d[2]=thisy%256;
}

/**
 *	sample_debug:
 *	@d: sample buffer
 *
 *	Retrieve a triple of sample data and mix it up with the state 
 *	information in the gesture parser. Not useful for normal users but
 *	handy when debugging
 */

static void sample_debug(int d[3])
{
	int thisd, thisdd, thisx, thisy;
	int b;
	unsigned long flags;
	
	save_flags(flags);
	cli();
	read_raw_pad(&thisd, &thisdd, &thisx, &thisy);
	d[0]=(thisd?0x80:0) | (thisdd?0x40:0) | bounce;
	d[1]=(recent_transition?0x80:0)+transition_count;
	read_button(&b);
	d[2]=(synthesize_tap<<4) | (b?0x01:0);
	restore_flags(flags);
}

/**
 *	sample_ps2:
 *	@d: sample buffer
 *
 *	Retrieve a triple of sample data and turn the debounced tap and
 *	stroke information into what appears to be a PS/2 mouse. This means
 *	the PC110 pad needs no funny application side support.
 */


static void sample_ps2(int d[3])
{
	static int lastx, lasty, lastd;

	int thisd, thisdd, thisx, thisy;
	int dx, dy, b;

	/*
	 * Obtain the current mouse parameters and limit as appropriate for
	 * the return data format.  Interrupts are only disabled while 
	 * obtaining the parameters, NOT during the puts_fs_byte() calls,
	 * so paging in put_user() does not affect mouse tracking.
	 */
	read_raw_pad(&thisd, &thisdd, &thisx, &thisy);
	read_button(&b);

	/* Now compare with previous readings.  Note that we use the
	 * raw down flag rather than the debounced one.
	 */
	if( (thisd && !lastd) /* new stroke */
	 || (bounce!=NO_BOUNCE) )
	{
		dx=0;
		dy=0;
	}
	else
	{
		dx =  (thisx-lastx);
		dy = -(thisy-lasty);
	}
	lastx=thisx;
	lasty=thisy;
	lastd=thisd;

/*
	d[0]= ((dy<0)?0x20:0)
	    | ((dx<0)?0x10:0)
	    | 0x08
	    | (b? 0x01:0x00)
	;
*/
	d[0]= ((dy<0)?0x20:0)
	    | ((dx<0)?0x10:0)
	    | (b? 0x00:0x08)
	;
	d[1]=dx;
	d[2]=dy;
}


/**
 *	fasync_pad:
 *	@fd:	file number for the file 
 *	@filp:	file handle
 *	@on:	1 to add, 0 to remove a notifier
 *
 *	Update the queue of asynchronous event notifiers. We can use the
 *	same helper the mice do and that does almost everything we need.
 */
 
static int fasync_pad(int fd, struct file *filp, int on)
{
	int retval;

	retval = fasync_helper(fd, filp, on, &asyncptr);
	if (retval < 0)
		return retval;
	return 0;
}


/**
 *	close_pad:
 *	@inode: inode of pad
 *	@file: file handle to pad
 *
 *	Close access to the pad. We turn the pad power off if this is the
 *	last user of the pad. I've not actually measured the power draw but
 *	the DOS driver is careful to do this so we follow suit.
 */
 
static int close_pad(struct inode * inode, struct file * file)
{
	lock_kernel();
	fasync_pad(-1, file, 0);
	if (!--active)
		outb(0x30, current_params.io+2);  /* switch off digitiser */
	unlock_kernel();
	return 0;
}


/**
 *	open_pad:
 *	@inode: inode of pad
 *	@file: file handle to pad
 *
 *	Open access to the pad. We turn the pad off first (we turned it off
 *	on close but if this is the first open after a crash the state is
 *	indeterminate). The device has a small fifo so we empty that before
 *	we kick it back into action.
 */
 
static int open_pad(struct inode * inode, struct file * file)
{
	unsigned long flags;
	
	if (active++)
		return 0;

	save_flags(flags);
	cli();
	outb(0x30, current_params.io+2);	/* switch off digitiser */
	pad_irq(0,0,0);		/* read to flush any pending bytes */
	pad_irq(0,0,0);		/* read to flush any pending bytes */
	pad_irq(0,0,0);		/* read to flush any pending bytes */
	outb(0x38, current_params.io+2);	/* switch on digitiser */
	current_params = default_params;
	raw_data_count=0;		/* re-sync input byte counter */
	read_byte_count=0;		/* re-sync output byte counter */
	button_pending=0;
	recent_transition=0;
	transition_count=0;
	synthesize_tap=0;
	del_timer(&bounce_timer);
	del_timer(&tap_timer);
	restore_flags(flags);

	return 0;
}


/**
 *	write_pad:
 *	@file: File handle to the pad
 *	@buffer: Unused
 *	@count: Unused
 *	@ppos: Unused
 *
 *	Writes are disallowed. A true PS/2 mouse lets you write stuff. Everyone
 *	seems happy with this and not faking the write modes.
 */

static ssize_t write_pad(struct file * file, const char * buffer, size_t count, loff_t *ppos)
{
	return -EINVAL;
}


/*
 *	new_sample:
 *	@d: sample buffer
 *
 *	Fetch a new sample according the current mouse mode the pad is 
 *	using.
 */
 
void new_sample(int d[3])
{
	switch(current_params.mode)
	{
		case PC110PAD_RAW:	sample_raw(d);		break;
		case PC110PAD_RARE:	sample_rare(d);		break;
		case PC110PAD_DEBUG:	sample_debug(d);	break;
		case PC110PAD_PS2:	sample_ps2(d);		break;
	}
}


/**
 * read_pad:
 * @file: File handle to pad
 * @buffer: Target for the mouse data
 * @count: Buffer length
 * @ppos: Offset (unused)
 *
 * Read data from the pad. We use the reader_lock to avoid mess when there are
 * two readers. This shouldnt be happening anyway but we play safe.
 */
 
static ssize_t read_pad(struct file * file, char * buffer, size_t count, loff_t *ppos)
{
	int r;

	down(&reader_lock);
	for(r=0; r<count; r++)
	{
		if(!read_byte_count)
			new_sample(read_bytes);
		if(put_user(read_bytes[read_byte_count], buffer+r))
		{
			r = -EFAULT;
			break;
		}
		read_byte_count = (read_byte_count+1)%3;
	}
	up(&reader_lock);
	return r;
}


/**
 * pad_poll:
 * @file: File of the pad device
 * @wait: Poll table
 *
 * The pad is ready to read if there is a button or any position change
 * pending in the queue. The reading and interrupt routines maintain the
 * required state for us and do needed wakeups.
 */

static unsigned int pad_poll(struct file *file, poll_table * wait)
{
	poll_wait(file, &queue, wait);
    	if(button_pending || xy_pending)
		return POLLIN | POLLRDNORM;
	return 0;
}


/**
 *	pad_ioctl;
 *	@inode: Inode of the pad
 *	@file: File handle to the pad
 *	@cmd: Ioctl command
 *	@arg: Argument pointer
 *
 *	The PC110 pad supports two ioctls both of which use the pc110pad_params
 *	structure. GETP queries the current pad status. SETP changes the pad
 *	configuration. Changing configuration during normal mouse operations
 *	may give momentarily odd results as things like tap gesture state
 *	may be lost.
 */
 
static int pad_ioctl(struct inode *inode, struct file * file,
	unsigned int cmd, unsigned long arg)
{
	struct pc110pad_params new;

	if (!inode)
		return -EINVAL;
		
	switch (cmd) {
	case PC110PADIOCGETP:
		new = current_params;
		if(copy_to_user((void *)arg, &new, sizeof(new)))
			return -EFAULT;
		return 0;

	case PC110PADIOCSETP:
		if(copy_from_user(&new, (void *)arg, sizeof(new)))
			return -EFAULT;

		if( (new.mode<PC110PAD_RAW)
		 || (new.mode>PC110PAD_PS2)
		 || (new.bounce_interval<0)
		 || (new.tap_interval<0)
		)
			return -EINVAL;

		current_params.mode	= new.mode;
		current_params.bounce_interval	= new.bounce_interval;
		current_params.tap_interval	= new.tap_interval;
		return 0;
	}
	return -ENOIOCTLCMD;
}


static struct file_operations pad_fops = {
	owner:		THIS_MODULE,
	read:		read_pad,
	write:		write_pad,
	poll:		pad_poll,
	ioctl:		pad_ioctl,
	open:		open_pad,
	release:	close_pad,
	fasync:		fasync_pad,
};


static struct miscdevice pc110_pad = {
	minor:		PC110PAD_MINOR,
	name:		"pc110 pad",
	fops:		&pad_fops,
};


/**
 *	pc110pad_init_driver:
 *
 *	We configure the pad with the default parameters (that is PS/2 
 *	emulation mode. We then claim the needed I/O and interrupt resources.
 *	Finally as a matter of paranoia we turn the pad off until we are
 *	asked to open it by an application.
 */

static const char banner[] __initdata = KERN_INFO "PC110 digitizer pad at 0x%X, irq %d.\n";

static int __init pc110pad_init_driver(void)
{
	init_MUTEX(&reader_lock);
	current_params = default_params;

	if (request_irq(current_params.irq, pad_irq, 0, "pc110pad", 0)) {
		printk(KERN_ERR "pc110pad: Unable to get IRQ.\n");
		return -EBUSY;
	}
	if (!request_region(current_params.io, 4, "pc110pad"))	{
		printk(KERN_ERR "pc110pad: I/O area in use.\n");
		free_irq(current_params.irq,0);
		return -EBUSY;
	}
	init_waitqueue_head(&queue);
	printk(banner, current_params.io, current_params.irq);
	misc_register(&pc110_pad);
	outb(0x30, current_params.io+2);	/* switch off digitiser */
	return 0;
}

/*
 *	pc110pad_exit_driver:
 *
 *	Free the resources we acquired when the module was loaded. We also
 *	turn the pad off to be sure we don't leave it using power.
 */

static void __exit pc110pad_exit_driver(void)
{
	outb(0x30, current_params.io+2);	/* switch off digitiser */
	if (current_params.irq)
		free_irq(current_params.irq, 0);
	current_params.irq = 0;
	release_region(current_params.io, 4);
	misc_deregister(&pc110_pad);
}

module_init(pc110pad_init_driver);
module_exit(pc110pad_exit_driver);
