Subversion Repositories or1k

/*
 * Atari Mouse Driver for Linux
 * by Robert de Vries (robert@and.nl) 19Jul93
 *
 * 16 Nov 1994 Andreas Schwab
 * Compatibility with busmouse
 * Support for three button mouse (shamelessly stolen from MiNT)
 * third button wired to one of the joystick directions on joystick 1
 *
 * 1996/02/11 Andreas Schwab
 * Module support
 * Allow multiple open's
 */
 
#include <linux/module.h>
 
#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/mm.h>
#include <linux/random.h>
 
#include <asm/atarikb.h>
#include <asm/atari_mouse.h>
#include <asm/segment.h>
#include <asm/bootinfo.h>
 
static struct mouse_status mouse;
static int atari_mouse_x_threshold = 2, atari_mouse_y_threshold = 2;
extern int atari_mouse_buttons;
 
static void atari_mouse_interrupt(char *buf)
{
    int buttons;
 
/*    ikbd_mouse_disable(); */
 
    buttons = ((buf[0] & 1 ? 1 : 0)
	       | (buf[0] & 2 ? 4 : 0)
	       | (atari_mouse_buttons & 2));
    atari_mouse_buttons = buttons;
    add_mouse_randomness((buttons << 16) + (buf[2] << 8) + buf[1]);
    mouse.buttons = ~buttons & 7;
    mouse.dx += buf[1];
    mouse.dy -= buf[2];
    mouse.ready = 1;
    wake_up_interruptible(&mouse.wait);
    if (mouse.fasyncptr)
	kill_fasync(mouse.fasyncptr, SIGIO);
 
/*    ikbd_mouse_rel_pos(); */
}
 
static int fasync_mouse(struct inode *inode, struct file *filp, int on)
{
	int retval;
 
	retval = fasync_helper(inode, filp, on, &mouse.fasyncptr);
	if (retval < 0)
		return retval;
	return 0;
}
 
static void release_mouse(struct inode *inode, struct file *file)
{
    fasync_mouse(inode, file, 0);
    if (--mouse.active)
      return;
    ikbd_mouse_disable();
 
    atari_mouse_interrupt_hook = NULL;
    MOD_DEC_USE_COUNT;
}
 
static int open_mouse(struct inode *inode, struct file *file)
{
    if (mouse.active++)
	return 0;
    mouse.ready = 0;
    mouse.dx = mouse.dy = 0;
    atari_mouse_buttons = 0;
    ikbd_mouse_y0_top ();
    ikbd_mouse_thresh (atari_mouse_x_threshold, atari_mouse_y_threshold);
    ikbd_mouse_rel_pos();
    MOD_INC_USE_COUNT;
    atari_mouse_interrupt_hook = atari_mouse_interrupt;
    return 0;
}
 
static int write_mouse(struct inode *inode, struct file *file, const char *buffer, int count)
{
    return -EINVAL;
}
 
static int read_mouse(struct inode *inode, struct file *file, char *buffer, int count)
{
    int dx, dy, buttons;
    int r;
 
    if (count < 3)
	return -EINVAL;
    if ((r = verify_area(VERIFY_WRITE, buffer, count)))
	return r;
    if (!mouse.ready)
	return -EAGAIN;
    /* ikbd_mouse_disable */
    dx = mouse.dx;
    dy = mouse.dy;
    buttons = mouse.buttons;
    if (dx > 127)
      dx = 127;
    else if (dx < -128)
      dx = -128;
    if (dy > 127)
      dy = 127;
    else if (dy < -128)
      dy = -128;
    mouse.dx -= dx;
    mouse.dy -= dy;
    if (mouse.dx == 0 && mouse.dy == 0)
      mouse.ready = 0;
    /* ikbd_mouse_rel_pos(); */
    put_user(buttons | 0x80, buffer);
    put_user((char) dx, buffer + 1);
    put_user((char) dy, buffer + 2);
    for (r = 3; r < count; r++)
      put_user (0, buffer + r);
    return r;
}
 
static int mouse_select(struct inode *inode, struct file *file, int sel_type, select_table *wait)
{
	if (sel_type == SEL_IN) {
	    	if (mouse.ready)
			return 1;
		select_wait(&mouse.wait, wait);
	}
	return 0;
}
 
struct file_operations atari_mouse_fops = {
    NULL,		/* mouse_seek */
    read_mouse,
    write_mouse,
    NULL,		/* mouse_readdir */
    mouse_select,
    NULL,		/* mouse_ioctl */
    NULL,		/* mouse_mmap */
    open_mouse,
    release_mouse,
    NULL,
    fasync_mouse,
};
 
static struct miscdevice atari_mouse = {
    ATARIMOUSE_MINOR, "atarimouse", &atari_mouse_fops
};
 
int atari_mouse_init(void)
{
    mouse.active = 0;
    mouse.ready = 0;
    mouse.wait = NULL;
 
    if (!MACH_IS_ATARI)
	return -ENODEV;
    printk(KERN_INFO "Atari mouse installed.\n");
    misc_register(&atari_mouse);
    return 0;
}
 
 
#define	MIN_THRESHOLD 1
#define	MAX_THRESHOLD 20	/* more seems not reasonable... */
 
void atari_mouse_setup( char *str, int *ints )
{
    if (ints[0] < 1) {
	printk( "atari_mouse_setup: no arguments!\n" );
	return;
    }
    else if (ints[0] > 2) {
	printk( "atari_mouse_setup: too many arguments\n" );
    }
 
    if (ints[1] < MIN_THRESHOLD || ints[1] > MAX_THRESHOLD)
	printk( "atari_mouse_setup: bad threshold value (ignored)\n" );
    else {
	atari_mouse_x_threshold = ints[1];
	atari_mouse_y_threshold = ints[1];
	if (ints[0] > 1) {
	    if (ints[2] < MIN_THRESHOLD || ints[2] > MAX_THRESHOLD)
		printk("atari_mouse_setup: bad threshold value (ignored)\n" );
	    else
		atari_mouse_y_threshold = ints[2];
	}
    }
 
}
 
#ifdef MODULE
#include <asm/bootinfo.h>
 
int init_module(void)
{
	return atari_mouse_init();
}
 
void cleanup_module(void)
{
  misc_deregister(&atari_mouse);
}
#endif