Subversion Repositories or1k

/* -*- c -*- --------------------------------------------------------- *
 *
 * linux/drivers/char/mk712.c
 *
 * Copyright 1999-2002 Transmeta Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * This driver supports the MK712 touch screen.
 * based on busmouse.c, pc_keyb.c, and other mouse drivers
 *
 * 1999-12-18: original version, Daniel Quinlan
 * 1999-12-19: added anti-jitter code, report pen-up events, fixed mk712_poll
 *             to use queue_empty, Nathan Laredo
 * 1999-12-20: improved random point rejection, Nathan Laredo
 * 2000-01-05: checked in new anti-jitter code, changed mouse protocol, fixed
 *             queue code, added module options, other fixes, Daniel Quinlan
 * 2002-03-15: Clean up for kernel merge <alan@redhat.com>
 *	       Fixed multi open race, fixed memory checks, fixed resource
 *	       allocation, fixed close/powerdown bug, switched to new init
 *
 * ------------------------------------------------------------------------- */
 
#include <linux/module.h>
 
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/poll.h>
#include <linux/miscdevice.h>
#include <linux/random.h>
#include <linux/delay.h>
#include <linux/ioport.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
 
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/irq.h>
 
#define DEBUG(x)	x
#define SQUARE(x)	((x)*(x))
 
#define MK712_DEFAULT_IO 0x260		/* demo board: 0x200, 0x208, 0x300 */
#define MK712_DEFAULT_IRQ 10		/* demo board: 10, 12, 14 or 15  */
 
/* eight 8-bit registers */
#define MK712_STATUS_LOW 0	/* READ */
#define MK712_STATUS_HIGH 1	/* READ */
#define MK712_X_LOW 2		/* READ */
#define MK712_X_HIGH 3		/* READ */
#define MK712_Y_LOW 4		/* READ */
#define MK712_Y_HIGH 5		/* READ */
#define MK712_CONTROL 6		/* R/W */
#define MK712_RATE 7		/* R/W */
 
/* status */
#define	MK712_STATUS_TOUCH 0x10
#define	MK712_CONVERSION_COMPLETE 0x80
 
#define MK712_ENABLE_INT			0x01 /* enable interrupts */
#define MK712_INT_ON_CONVERSION_COMPLETE	0x02 /* if bit 0 = 1 */
#define MK712_INT_ON_CHANGE_IN_TOUCH_STATUS_A	0x04 /* if bit 0 = 1 */
#define MK712_INT_ON_CHANGE_IN_TOUCH_STATUS_B	0x08 /* if bit 0 = 1 */
#define MK712_ENABLE_PERIODIC_CONVERSIONS	0x10
#define MK712_READ_ONE_POINT			0x20
#define MK712_POWERDOWN_A			0x40
#define MK712_POWERDOWN_B			0x80
 
#define MK712_BUF_SIZE 256      /* a page */
 
struct mk712_packet {
        unsigned int header;
        unsigned int x;
        unsigned int y;
        unsigned int reserved;
};
 
struct mk712_queue {
	unsigned long head;
	unsigned long tail;
	wait_queue_head_t proc_list;
	struct fasync_struct *fasync;
	struct mk712_packet buf[256];
};
 
#ifdef MODULE
static int io = 0;
static int irq = 0;
#endif
static int mk712_io = MK712_DEFAULT_IO;
static int mk712_irq = MK712_DEFAULT_IRQ;
static int mk712_users = 0;
static spinlock_t mk712_lock = SPIN_LOCK_UNLOCKED;
static struct mk712_queue *queue; /* mouse data buffer */
 
static struct mk712_packet get_from_queue(void)
{
	struct mk712_packet result;
	unsigned long flags;
 
	spin_lock_irqsave(&mk712_lock, flags);
	result = queue->buf[queue->tail];
	queue->tail = (queue->tail + 1) & (MK712_BUF_SIZE-1);
	spin_unlock_irqrestore(&mk712_lock, flags);
	return result;
}
 
static inline int queue_empty(void)
{
	return queue->head == queue->tail;
}
 
static int mk712_fasync(int fd, struct file *filp, int on)
{
	int retval;
 
	retval = fasync_helper(fd, filp, on, &queue->fasync);
	if (retval < 0)
		return retval;
	return 0;
}
 
static void mk712_output_packet(struct mk712_packet data)
{
        int head = queue->head;
 
        queue->buf[head] = data;
        head = (head + 1) & (MK712_BUF_SIZE-1);
        if (head != queue->tail) {
                queue->head = head;
                kill_fasync(&queue->fasync, SIGIO, POLL_IN);
                wake_up_interruptible(&queue->proc_list);
        }
}
 
static int points = 0;          /* number of stored points */
static int output_point = 0;    /* did I output a point since last release? */
 
static void mk712_output_point(int x, int y)
{
        struct mk712_packet t;
 
        t.header = 0;
        t.x = x;
        t.y = y;
        t.reserved = 0;
 
        mk712_output_packet(t);
        output_point = 1;
}
 
static void mk712_store_point(int x_new, int y_new)
{
        static int x[3], y[3];
        int x_out, y_out;
 
        x[points] = x_new;
        y[points] = y_new;
 
        if (points == 1 && abs(x[0] - x[1]) < 88 && abs(y[0] - y[1]) < 88)
	{
		x_out = (x[0] + x[1]) >> 1;
                y_out = (y[0] + y[1]) >> 1;
                mk712_output_point(x_out, y_out);
        }
 
        if (points == 2) {
                if ((abs(x[1] - x[2]) < 88 && abs(y[1] - y[2]) < 88) &&
                    (abs(x[0] - x[1]) < 88 && abs(y[0] - y[1]) < 88))
                {
                        x_out = (x[0] + x[1] + x[2]) / 3;
                        y_out = (y[0] + y[1] + y[2]) / 3;
                        mk712_output_point(x_out, y_out);
                }
                else if (abs(x[1] - x[2]) < 88 && abs(y[1] - y[2]) < 88)
                {
                        x_out = (x[1] + x[2]) >> 1;
                        y_out = (y[1] + y[2]) >> 1;
                        mk712_output_point(x_out, y_out);
                }
                else
                {
                        int x_avg, y_avg, d0, d1, d2;
 
                        x_avg = (x[0] + x[1] + x[2]) / 3;
                        y_avg = (y[0] + y[1] + y[2]) / 3;
 
                        d0 = SQUARE(x[0] - x_avg) + SQUARE(y[0] - y_avg);
                        d1 = SQUARE(x[1] - x_avg) + SQUARE(y[1] - y_avg);
                        d2 = SQUARE(x[2] - x_avg) + SQUARE(y[2] - y_avg);
 
                        if (d2 > d1 && d2 > d0)
			{
                                x_out = (x[0] + x[1]) >> 1;
                                y_out = (y[0] + y[1]) >> 1;
                        }
                        if (d1 > d0 && d1 > d2)
			{
                                x_out = (x[0] + x[2]) >> 1;
                                y_out = (y[0] + y[2]) >> 1;
                        }
                        else
                        {
                                x_out = (x[1] + x[2]) >> 1;
                                y_out = (y[1] + y[2]) >> 1;
                        }
 
                        mk712_output_point(x_out, y_out);
 
                        x[0] = x[1];
                        x[1] = x[2];
                        y[0] = y[1];
                        y[1] = y[2];
                }
        }
        else
	{
                points++;
        }
}
 
static void mk712_release_event(void)
{
        struct mk712_packet t;
 
        if (!output_point) {
                points = 0;
                return;
        }
        output_point = 0;
 
        t.header = 1;
        t.x = t.y = t.reserved = 0;
 
        mk712_output_packet(t);
        points = 0;
}
 
#define MK712_FILTER
static void mk712_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
	unsigned short x;
	unsigned short y;
        unsigned char status;
	unsigned long flags;
#ifdef MK712_FILTER
        static int drop_next = 1;
#endif
 
	spin_lock_irqsave(&mk712_lock, flags);
 
        status = inb(mk712_io + MK712_STATUS_LOW);
 
	if (!(status & MK712_CONVERSION_COMPLETE)) {
#ifdef MK712_FILTER
                drop_next = 1;
#endif
		return;
	}
	if (!(status & MK712_STATUS_TOUCH))	/* release event */
	{
#ifdef MK712_FILTER
                drop_next = 1;
#endif
                mk712_release_event();
 
                spin_unlock_irqrestore(&mk712_lock, flags);
                wake_up_interruptible(&queue->proc_list);
 
		return;
	}
 
        x = inw(mk712_io + MK712_X_LOW) & 0x0fff;
        y = inw(mk712_io + MK712_Y_LOW) & 0x0fff;
 
#ifdef MK712_FILTER
        if (drop_next)
        {
                drop_next = 0;
 
                spin_unlock_irqrestore(&mk712_lock, flags);
                wake_up_interruptible(&queue->proc_list);
 
                return;
        }
#endif
 
        x = inw(mk712_io + MK712_X_LOW) & 0x0fff;
	y = inw(mk712_io + MK712_Y_LOW) & 0x0fff;
 
        mk712_store_point(x, y);
 
        spin_unlock_irqrestore(&mk712_lock, flags);
        wake_up_interruptible(&queue->proc_list);
}
 
static int mk712_open(struct inode *inode, struct file *file) 
{
	unsigned char control;
	unsigned long flags;
 
	control = 0;
 
	spin_lock_irqsave(&mk712_lock, flags);
	if(!mk712_users++)
	{
		outb(0, mk712_io + MK712_CONTROL);
 
		control |= (MK712_ENABLE_INT |
	                    MK712_INT_ON_CONVERSION_COMPLETE |
	                    MK712_INT_ON_CHANGE_IN_TOUCH_STATUS_B |
	                    MK712_ENABLE_PERIODIC_CONVERSIONS |
	                    MK712_POWERDOWN_A);
		outb(control, mk712_io + MK712_CONTROL);
 
	        outb(10, mk712_io + MK712_RATE); /* default count = 10 */
 
		queue->head = queue->tail = 0;          /* Flush input queue */
	}
	spin_unlock_irqrestore(&mk712_lock, flags);
	return 0;
}
 
static int mk712_close(struct inode * inode, struct file * file) {
        /* power down controller */
        unsigned long flags;
        spin_lock_irqsave(&mk712_lock, flags);
	if(--mk712_users==0)
		outb(0, mk712_io + MK712_CONTROL);
	spin_unlock_irqrestore(&mk712_lock, flags);
	return 0;
}
 
static unsigned int mk712_poll(struct file *file, poll_table *wait)
{
	poll_wait(file, &queue->proc_list, wait);
	if(!queue_empty())
		return POLLIN | POLLRDNORM;
	return 0;
}
 
static int mk712_ioctl(struct inode *inode, struct file * file,
	unsigned int cmd, unsigned long arg)
{
	if (!inode)
		BUG();
	return -ENOTTY;
}
 
 
static ssize_t mk712_read(struct file *file, char *buffer,
			  size_t count, loff_t *pos)
{
	DECLARE_WAITQUEUE(wait, current);
	ssize_t bytes_read = 0;
	struct mk712_packet p;
 
	/* wait for an event */
	if (queue_empty()) {
		if (file->f_flags & O_NONBLOCK)
			return -EAGAIN;
		add_wait_queue(&queue->proc_list, &wait);
repeat:
		set_current_state(TASK_INTERRUPTIBLE);
		if (queue_empty() && !signal_pending(current)) {
			schedule();
			goto repeat;
		}
		current->state = TASK_RUNNING;
		remove_wait_queue(&queue->proc_list, &wait);
	}
 
	while (bytes_read < count && !queue_empty()) {
		p = get_from_queue();
		if (copy_to_user (buffer+bytes_read, (void *) &p, sizeof(p)))
		{
			bytes_read = -EFAULT;
			break;
		}
		bytes_read += sizeof(p);
	}
 
        if (bytes_read > 0)
        {
                file->f_dentry->d_inode->i_atime = CURRENT_TIME;
                return bytes_read;
        }
 
	if (signal_pending(current))
		return -ERESTARTSYS;
 
	return bytes_read;
}
 
static ssize_t mk712_write(struct file *file, const char *buffer, size_t count,
			   loff_t *ppos)
{
	return -EINVAL;
}
 
struct file_operations mk712_fops = {
	owner: THIS_MODULE,
	read: mk712_read,
	write: mk712_write,
	poll: mk712_poll,
	ioctl: mk712_ioctl,
	open: mk712_open,
	release: mk712_close,
	fasync: mk712_fasync,
};
 
static struct miscdevice mk712_touchscreen = {
	MK712_MINOR, "mk712_touchscreen", &mk712_fops
};
 
int __init mk712_init(void)
{
#ifdef MODULE
        if (io)
                mk712_io = io;
        if (irq)
                mk712_irq = irq;
#endif
 
	if(!request_region(mk712_io, 8, "mk712_touchscreen"))
	{
		printk("mk712: unable to get IO region\n");
		return -ENODEV;
	}
 
	/* set up wait queue */
	queue = (struct mk712_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
	if(queue == NULL)
	{
		release_region(mk712_io, 8);
		return -ENOMEM;
	}
	memset(queue, 0, sizeof(*queue));
	queue->head = queue->tail = 0;
	init_waitqueue_head(&queue->proc_list);
 
        /* The MK712 is ISA and hard-coded to a particular IRQ, so the
           driver should keep the IRQ as long as it is loaded. */
	if(request_irq(mk712_irq, mk712_interrupt, 0, "mk712_touchscreen",
		       queue))
	{
		printk("mk712: unable to get IRQ\n");
		release_region(mk712_io, 8);
		kfree(queue);
		return -EBUSY;
	}
 
        /* register misc device */
	if(misc_register(&mk712_touchscreen)<0)
	{
		release_region(mk712_io, 8);
		kfree(queue);
		free_irq(mk712_irq, queue);
		return -ENODEV;
	}
	return 0;
}
 
static void __exit mk712_exit(void)
{
	misc_deregister(&mk712_touchscreen);
	release_region(mk712_io, 8);
	free_irq(mk712_irq, queue);
	kfree(queue);
	printk(KERN_INFO "mk712 touchscreen uninstalled\n");
}
 
MODULE_AUTHOR("Daniel Quinlan");
MODULE_DESCRIPTION("MK712 touch screen driver");
MODULE_PARM(io, "i");
MODULE_PARM_DESC(io, "I/O base address of MK712 touch screen controller");
MODULE_PARM(irq, "i");
MODULE_PARM_DESC(irq, "IRQ of MK712 touch screen controller");
MODULE_LICENSE("GPL");
 
module_init(mk712_init);
module_exit(mk712_exit);
 
/*
 * Local variables:
 * c-file-style: "linux"
 * End:
 */