/*
 * linux/drivers/char/busmouse.c
 *
 * Copyright (C) 1995 - 1998 Russell King <linux@arm.linux.org.uk>
 *  Protocol taken from original busmouse.c
 *  read() waiting taken from psaux.c
 *
 * Medium-level interface for quadrature or bus mice.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/poll.h>
#include <linux/miscdevice.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/smp_lock.h>

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

#include "busmouse.h"

/* Uncomment this if your mouse drivers expect the kernel to
 * return with EAGAIN if the mouse does not have any events
 * available, even if the mouse is opened in blocking mode.
 * Please report use of this "feature" to the author using the
 * above address.
 */
/*#define BROKEN_MOUSE*/

struct busmouse_data {
        struct miscdevice       miscdev;
        struct busmouse         *ops;
        spinlock_t              lock;

        wait_queue_head_t       wait;
        struct fasync_struct    *fasyncptr;
        char                    active;
        char                    buttons;
        char                    ready;
        int                     dxpos;
        int                     dypos;
};

#define NR_MICE                 15
#define FIRST_MOUSE             0
#define DEV_TO_MOUSE(dev)       MINOR_TO_MOUSE(MINOR(dev))
#define MINOR_TO_MOUSE(minor)   ((minor) - FIRST_MOUSE)

/*
 *      List of mice and guarding semaphore. You must take the semaphore
 *      before you take the misc device semaphore if you need both
 */
 
static struct busmouse_data *busmouse_data[NR_MICE];
static DECLARE_MUTEX(mouse_sem);

/**
 *      busmouse_add_movement - notification of a change of mouse position
 *      @mousedev: mouse number
 *      @dx: delta X movement
 *      @dy: delta Y movement
 *      @buttons: new button state
 *
 *      Updates the mouse position and button information. The mousedev
 *      parameter is the value returned from register_busmouse. The
 *      movement information is updated, and the new button state is
 *      saved.  A waiting user thread is woken.
 */
 
void busmouse_add_movementbuttons(int mousedev, int dx, int dy, int buttons)
{
        struct busmouse_data *mse = busmouse_data[mousedev];
        int changed;

        spin_lock(&mse->lock);
        changed = (dx != 0 || dy != 0 || mse->buttons != buttons);

        if (changed) {
                add_mouse_randomness((buttons << 16) + (dy << 8) + dx);

                mse->buttons = buttons;
                mse->dxpos += dx;
                mse->dypos += dy;
                mse->ready = 1;

                /*
                 * keep dx/dy reasonable, but still able to track when X (or
                 * whatever) must page or is busy (i.e. long waits between
                 * reads)
                 */
                if (mse->dxpos < -2048)
                        mse->dxpos = -2048;
                if (mse->dxpos > 2048)
                        mse->dxpos = 2048;
                if (mse->dypos < -2048)
                        mse->dypos = -2048;
                if (mse->dypos > 2048)
                        mse->dypos = 2048;
        }

        spin_unlock(&mse->lock);

        if (changed) {
                wake_up(&mse->wait);

                kill_fasync(&mse->fasyncptr, SIGIO, POLL_IN);
        }
}

/**
 *      busmouse_add_movement - notification of a change of mouse position
 *      @mousedev: mouse number
 *      @dx: delta X movement
 *      @dy: delta Y movement
 *
 *      Updates the mouse position. The mousedev parameter is the value
 *      returned from register_busmouse. The movement information is
 *      updated, and a waiting user thread is woken.
 */
 
void busmouse_add_movement(int mousedev, int dx, int dy)
{
        struct busmouse_data *mse = busmouse_data[mousedev];

        busmouse_add_movementbuttons(mousedev, dx, dy, mse->buttons);
}

/**
 *      busmouse_add_buttons - notification of a change of button state
 *      @mousedev: mouse number
 *      @clear: mask of buttons to clear
 *      @eor: mask of buttons to change
 *
 *      Updates the button state. The mousedev parameter is the value
 *      returned from register_busmouse. The buttons are updated by:
 *              new_state = (old_state & ~clear) ^ eor
 *      A waiting user thread is woken up.
 */
 
void busmouse_add_buttons(int mousedev, int clear, int eor)
{
        struct busmouse_data *mse = busmouse_data[mousedev];

        busmouse_add_movementbuttons(mousedev, 0, 0, (mse->buttons & ~clear) ^ eor);
}

static int busmouse_fasync(int fd, struct file *filp, int on)
{
        struct busmouse_data *mse = (struct busmouse_data *)filp->private_data;
        int retval;

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

static int busmouse_release(struct inode *inode, struct file *file)
{
        struct busmouse_data *mse = (struct busmouse_data *)file->private_data;
        int ret = 0;

        lock_kernel();
        busmouse_fasync(-1, file, 0);

        if (--mse->active == 0) {
                if (mse->ops->release)
                        ret = mse->ops->release(inode, file);
                if (mse->ops->owner)
                        __MOD_DEC_USE_COUNT(mse->ops->owner);
                mse->ready = 0;
        }
        unlock_kernel();

        return ret;
}

static int busmouse_open(struct inode *inode, struct file *file)
{
        struct busmouse_data *mse;
        unsigned int mousedev;
        int ret;

        mousedev = DEV_TO_MOUSE(inode->i_rdev);
        if (mousedev >= NR_MICE)
                return -EINVAL;

        down(&mouse_sem);
        mse = busmouse_data[mousedev];
        ret = -ENODEV;
        if (!mse || !mse->ops)  /* shouldn't happen, but... */
                goto end;

        if (mse->ops->owner && !try_inc_mod_count(mse->ops->owner))
                goto end;

        ret = 0;
        if (mse->ops->open) {
                ret = mse->ops->open(inode, file);
                if (ret && mse->ops->owner)
                        __MOD_DEC_USE_COUNT(mse->ops->owner);
        }

        if (ret)
                goto end;

        file->private_data = mse;

        if (mse->active++)
                goto end;

        spin_lock_irq(&mse->lock);

        mse->ready   = 0;
        mse->dxpos   = 0;
        mse->dypos   = 0;
        mse->buttons = mse->ops->init_button_state;

        spin_unlock_irq(&mse->lock);
end:
        up(&mouse_sem);
        return ret;
}

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

static ssize_t busmouse_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
{
        struct busmouse_data *mse = (struct busmouse_data *)file->private_data;
        DECLARE_WAITQUEUE(wait, current);
        int dxpos, dypos, buttons;

        if (count < 3)
                return -EINVAL;

        spin_lock_irq(&mse->lock);

        if (!mse->ready) {
#ifdef BROKEN_MOUSE
                spin_unlock_irq(&mse->lock);
                return -EAGAIN;
#else
                if (file->f_flags & O_NONBLOCK) {
                        spin_unlock_irq(&mse->lock);
                        return -EAGAIN;
                }

                add_wait_queue(&mse->wait, &wait);
repeat:
                set_current_state(TASK_INTERRUPTIBLE);
                if (!mse->ready && !signal_pending(current)) {
                        spin_unlock_irq(&mse->lock);
                        schedule();
                        spin_lock_irq(&mse->lock);
                        goto repeat;
                }

                current->state = TASK_RUNNING;
                remove_wait_queue(&mse->wait, &wait);

                if (signal_pending(current)) {
                        spin_unlock_irq(&mse->lock);
                        return -ERESTARTSYS;
                }
#endif
        }

        dxpos = mse->dxpos;
        dypos = mse->dypos;
        buttons = mse->buttons;

        if (dxpos < -127)
                dxpos =- 127;
        if (dxpos > 127)
                dxpos = 127;
        if (dypos < -127)
                dypos =- 127;
        if (dypos > 127)
                dypos = 127;

        mse->dxpos -= dxpos;
        mse->dypos -= dypos;

        /* This is something that many drivers have apparantly
         * forgotten...  If the X and Y positions still contain
         * information, we still have some info ready for the
         * user program...
         */
        mse->ready = mse->dxpos || mse->dypos;

        spin_unlock_irq(&mse->lock);

        /* Write out data to the user.  Format is:
         *   byte 0 - identifer (0x80) and (inverted) mouse buttons
         *   byte 1 - X delta position +/- 127
         *   byte 2 - Y delta position +/- 127
         */
        if (put_user((char)buttons | 128, buffer) ||
            put_user((char)dxpos, buffer + 1) ||
            put_user((char)dypos, buffer + 2))
                return -EFAULT;

        if (count > 3 && clear_user(buffer + 3, count - 3))
                return -EFAULT;

        file->f_dentry->d_inode->i_atime = CURRENT_TIME;

        return count;
}

/* No kernel lock held - fine */
static unsigned int busmouse_poll(struct file *file, poll_table *wait)
{
        struct busmouse_data *mse = (struct busmouse_data *)file->private_data;

        poll_wait(file, &mse->wait, wait);

        if (mse->ready)
                return POLLIN | POLLRDNORM;

        return 0;
}

struct file_operations busmouse_fops=
{
        owner:          THIS_MODULE,
        read:           busmouse_read,
        write:          busmouse_write,
        poll:           busmouse_poll,
        open:           busmouse_open,
        release:        busmouse_release,
        fasync:         busmouse_fasync,
};

/**
 *      register_busmouse - register a bus mouse interface
 *      @ops: busmouse structure for the mouse
 *
 *      Registers a mouse with the driver. The return is mouse number on
 *      success and a negative errno code on an error. The passed ops
 *      structure most not be freed until the mouser is unregistered
 */
 
int register_busmouse(struct busmouse *ops)
{
        unsigned int msedev = MINOR_TO_MOUSE(ops->minor);
        struct busmouse_data *mse;
        int ret;

        if (msedev >= NR_MICE) {
                printk(KERN_ERR "busmouse: trying to allocate mouse on minor %d\n",
                       ops->minor);
                return -EINVAL;
        }

        mse = kmalloc(sizeof(*mse), GFP_KERNEL);
        if (!mse)
                return -ENOMEM;

        down(&mouse_sem);
        if (busmouse_data[msedev])
        {
                up(&mouse_sem);
                kfree(mse);
                return -EBUSY;
        }

        memset(mse, 0, sizeof(*mse));

        mse->miscdev.minor = ops->minor;
        mse->miscdev.name = ops->name;
        mse->miscdev.fops = &busmouse_fops;
        mse->ops = ops;
        mse->lock = (spinlock_t)SPIN_LOCK_UNLOCKED;
        init_waitqueue_head(&mse->wait);

        busmouse_data[msedev] = mse;

        ret = misc_register(&mse->miscdev);
        if (!ret)
                ret = msedev;
        up(&mouse_sem);
        
        return ret;
}

/**
 *      unregister_busmouse - unregister a bus mouse interface
 *      @mousedev: Mouse number to release
 *
 *      Unregister a previously installed mouse handler. The mousedev
 *      passed is the return code from a previous call to register_busmouse
 */
 

int unregister_busmouse(int mousedev)
{
        int err = -EINVAL;

        if (mousedev < 0)
                return 0;
        if (mousedev >= NR_MICE) {
                printk(KERN_ERR "busmouse: trying to free mouse on"
                       " mousedev %d\n", mousedev);
                return -EINVAL;
        }

        down(&mouse_sem);
        
        if (!busmouse_data[mousedev]) {
                printk(KERN_WARNING "busmouse: trying to free free mouse"
                       " on mousedev %d\n", mousedev);
                goto fail;
        }

        if (busmouse_data[mousedev]->active) {
                printk(KERN_ERR "busmouse: trying to free active mouse"
                       " on mousedev %d\n", mousedev);
                goto fail;
        }

        err = misc_deregister(&busmouse_data[mousedev]->miscdev);

        kfree(busmouse_data[mousedev]);
        busmouse_data[mousedev] = NULL;
fail:
        up(&mouse_sem);
        return err;
}

EXPORT_SYMBOL(busmouse_add_movementbuttons);
EXPORT_SYMBOL(busmouse_add_movement);
EXPORT_SYMBOL(busmouse_add_buttons);
EXPORT_SYMBOL(register_busmouse);
EXPORT_SYMBOL(unregister_busmouse);

MODULE_LICENSE("GPL");