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:

 */