/*
 *      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 -ENOTTY;
}


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

MODULE_AUTHOR("Alan Cox, Robin O'Leary");
MODULE_DESCRIPTION("Driver for the touchpad on the IBM PC110 palmtop");
MODULE_LICENSE("GPL");

EXPORT_NO_SYMBOLS;