/*
 * linux/drivers/char/qpmouse.c
 *
 * Driver for a 82C710 C&T mouse interface chip.
 *
 * Based on the PS/2 driver by Johan Myreen.
 *
 * Corrections in device setup for some laptop mice & trackballs.
 * 02Feb93  (troyer@saifr00.cfsat.Honeywell.COM,mch@wimsey.bc.ca)
 *
 * Modified by Johan Myreen (jem@iki.fi) 04Aug93
 *   to include support for QuickPort mouse.
 *
 * Changed references to "QuickPort" with "82C710" since "QuickPort"
 * is not what this driver is all about -- QuickPort is just a
 * connector type, and this driver is for the mouse port on the Chips
 * & Technologies 82C710 interface chip. 15Nov93 jem@iki.fi
 *
 * Added support for SIGIO. 28Jul95 jem@iki.fi
 *
 * Rearranged SIGIO support to use code from tty_io.  9Sept95 ctm@ardi.com
 *
 * Modularised 8-Sep-95 Philip Blundell <pjb27@cam.ac.uk>
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/fcntl.h>
#include <linux/errno.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/miscdevice.h>
#include <linux/random.h>
#include <linux/poll.h>
#include <linux/init.h>
#include <linux/smp_lock.h>

#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/semaphore.h>

#include <linux/pc_keyb.h>              /* mouse enable command.. */


/*
 * We use the same minor number as the PS/2 mouse for (bad) historical
 * reasons..
 */
#define PSMOUSE_MINOR      1                    /* Minor device # for this mouse */
#define QP_BUF_SIZE     2048

struct qp_queue {
        unsigned long head;
        unsigned long tail;
        wait_queue_head_t proc_list;
        struct fasync_struct *fasync;
        unsigned char buf[QP_BUF_SIZE];
};

static struct qp_queue *queue;

static unsigned int get_from_queue(void)
{
        unsigned int result;
        unsigned long flags;

        save_flags(flags);
        cli();
        result = queue->buf[queue->tail];
        queue->tail = (queue->tail + 1) & (QP_BUF_SIZE-1);
        restore_flags(flags);
        return result;
}


static inline int queue_empty(void)
{
        return queue->head == queue->tail;
}

static int fasync_qp(int fd, struct file *filp, int on)
{
        int retval;

        retval = fasync_helper(fd, filp, on, &queue->fasync);
        if (retval < 0)
                return retval;
        return 0;
}

/*
 *      82C710 Interface
 */

#define QP_DATA         0x310           /* Data Port I/O Address */
#define QP_STATUS       0x311           /* Status Port I/O Address */

#define QP_DEV_IDLE     0x01            /* Device Idle */
#define QP_RX_FULL      0x02            /* Device Char received */
#define QP_TX_IDLE      0x04            /* Device XMIT Idle */
#define QP_RESET        0x08            /* Device Reset */
#define QP_INTS_ON      0x10            /* Device Interrupt On */
#define QP_ERROR_FLAG   0x20            /* Device Error */
#define QP_CLEAR        0x40            /* Device Clear */
#define QP_ENABLE       0x80            /* Device Enable */

#define QP_IRQ          12

static int qp_present;
static int qp_count;
static int qp_data = QP_DATA;
static int qp_status = QP_STATUS;

static int poll_qp_status(void);
static int probe_qp(void);

/*
 * Interrupt handler for the 82C710 mouse port. A character
 * is waiting in the 82C710.
 */

static void qp_interrupt(int cpl, void *dev_id, struct pt_regs * regs)
{
        int head = queue->head;
        int maxhead = (queue->tail-1) & (QP_BUF_SIZE-1);

        add_mouse_randomness(queue->buf[head] = inb(qp_data));
        if (head != maxhead) {
                head++;
                head &= QP_BUF_SIZE-1;
        }
        queue->head = head;
        kill_fasync(&queue->fasync, SIGIO, POLL_IN);
        wake_up_interruptible(&queue->proc_list);
}

static int release_qp(struct inode * inode, struct file * file)
{
        unsigned char status;

        lock_kernel();
        fasync_qp(-1, file, 0);
        if (!--qp_count) {
                if (!poll_qp_status())
                        printk(KERN_WARNING "Warning: Mouse device busy in release_qp()\n");
                status = inb_p(qp_status);
                outb_p(status & ~(QP_ENABLE|QP_INTS_ON), qp_status);
                if (!poll_qp_status())
                        printk(KERN_WARNING "Warning: Mouse device busy in release_qp()\n");
                free_irq(QP_IRQ, NULL);
        }
        unlock_kernel();
        return 0;
}

/*
 * Install interrupt handler.
 * Enable the device, enable interrupts. 
 */

static int open_qp(struct inode * inode, struct file * file)
{
        unsigned char status;

        if (!qp_present)
                return -EINVAL;

        if (qp_count++)
                return 0;

        if (request_irq(QP_IRQ, qp_interrupt, 0, "PS/2 Mouse", NULL)) {
                qp_count--;
                return -EBUSY;
        }

        status = inb_p(qp_status);
        status |= (QP_ENABLE|QP_RESET);
        outb_p(status, qp_status);
        status &= ~(QP_RESET);
        outb_p(status, qp_status);

        queue->head = queue->tail = 0;          /* Flush input queue */
        status |= QP_INTS_ON;
        outb_p(status, qp_status);              /* Enable interrupts */

        while (!poll_qp_status()) {
                printk(KERN_ERR "Error: Mouse device busy in open_qp()\n");
                qp_count--;
                status &= ~(QP_ENABLE|QP_INTS_ON);
                outb_p(status, qp_status);
                free_irq(QP_IRQ, NULL);
                return -EBUSY;
        }

        outb_p(AUX_ENABLE_DEV, qp_data);        /* Wake up mouse */
        return 0;
}

/*
 * Write to the 82C710 mouse device.
 */

static ssize_t write_qp(struct file * file, const char * buffer,
                        size_t count, loff_t *ppos)
{
        ssize_t i = count;

        while (i--) {
                char c;
                if (!poll_qp_status())
                        return -EIO;
                get_user(c, buffer++);
                outb_p(c, qp_data);
        }
        file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
        return count;
}

static unsigned int poll_qp(struct file *file, poll_table * wait)
{
        poll_wait(file, &queue->proc_list, wait);
        if (!queue_empty())
                return POLLIN | POLLRDNORM;
        return 0;
}

/*
 * Wait for device to send output char and flush any input char.
 */

#define MAX_RETRIES (60)

static int poll_qp_status(void)
{
        int retries=0;

        while ((inb(qp_status)&(QP_RX_FULL|QP_TX_IDLE|QP_DEV_IDLE))
                       != (QP_DEV_IDLE|QP_TX_IDLE)
                       && retries < MAX_RETRIES) {

                if (inb_p(qp_status)&(QP_RX_FULL))
                        inb_p(qp_data);
                current->state = TASK_INTERRUPTIBLE;
                schedule_timeout((5*HZ + 99) / 100);
                retries++;
        }
        return !(retries==MAX_RETRIES);
}

/*
 * Put bytes from input queue to buffer.
 */

static ssize_t read_qp(struct file * file, char * buffer,
                        size_t count, loff_t *ppos)
{
        DECLARE_WAITQUEUE(wait, current);
        ssize_t i = count;
        unsigned char c;

        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 (i > 0 && !queue_empty()) {
                c = get_from_queue();
                put_user(c, buffer++);
                i--;
        }
        if (count-i) {
                file->f_dentry->d_inode->i_atime = CURRENT_TIME;
                return count-i;
        }
        if (signal_pending(current))
                return -ERESTARTSYS;
        return 0;
}

struct file_operations qp_fops = {
        owner:          THIS_MODULE,
        read:           read_qp,
        write:          write_qp,
        poll:           poll_qp,
        open:           open_qp,
        release:        release_qp,
        fasync:         fasync_qp,
};

/*
 * Initialize driver.
 */
static struct miscdevice qp_mouse = {
        minor:          PSMOUSE_MINOR,
        name:           "QPmouse",
        fops:           &qp_fops,
};

/*
 * Function to read register in 82C710.
 */

static inline unsigned char read_710(unsigned char index)
{
        outb_p(index, 0x390);                   /* Write index */
        return inb_p(0x391);                    /* Read the data */
}


/*
 * See if we can find a 82C710 device. Read mouse address.
 */

static int __init probe_qp(void)
{
        outb_p(0x55, 0x2fa);                    /* Any value except 9, ff or 36 */
        outb_p(0xaa, 0x3fa);                    /* Inverse of 55 */
        outb_p(0x36, 0x3fa);                    /* Address the chip */
        outb_p(0xe4, 0x3fa);                    /* 390/4; 390 = config address */
        outb_p(0x1b, 0x2fa);                    /* Inverse of e4 */
        if (read_710(0x0f) != 0xe4)             /* Config address found? */
          return 0;                             /* No: no 82C710 here */
        qp_data = read_710(0x0d)*4;             /* Get mouse I/O address */
        qp_status = qp_data+1;
        outb_p(0x0f, 0x390);
        outb_p(0x0f, 0x391);                    /* Close config mode */
        return 1;
}

static char msg_banner[] __initdata = KERN_INFO "82C710 type pointing device detected -- driver installed.\n";
static char msg_nomem[]  __initdata = KERN_ERR "qpmouse: no queue memory.\n";

static int __init qpmouse_init_driver(void)
{
        if (!probe_qp())
                return -EIO;

        printk(msg_banner);

/*      printk("82C710 address = %x (should be 0x310)\n", qp_data); */
        queue = (struct qp_queue *) kmalloc(sizeof(*queue), GFP_KERNEL);
        if (queue == NULL) {
                printk(msg_nomem);
                return -ENOMEM;
        }
        qp_present = 1;
        misc_register(&qp_mouse);
        memset(queue, 0, sizeof(*queue));
        queue->head = queue->tail = 0;
        init_waitqueue_head(&queue->proc_list);
        return 0;
}

static void __exit qpmouse_exit_driver(void)
{
        misc_deregister(&qp_mouse);
        kfree(queue);
}

module_init(qpmouse_init_driver);
module_exit(qpmouse_exit_driver);


MODULE_LICENSE("GPL");
EXPORT_NO_SYMBOLS;