Viewing file:  sunmouse.c (14.39 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/* sunmouse.c: Sun mouse driver for the Sparc
*
* Copyright (C) 1995, 1996, 1997 David S. Miller (davem@caip.rutgers.edu)
* Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
*
* Parts based on the psaux.c driver written by:
* Johan Myreen.
*
* Dec/19/95 Added SunOS mouse ioctls - miguel.
* Jan/5/96 Added VUID support, sigio support - miguel.
* Mar/5/96 Added proper mouse stream support - miguel.
* Sep/96 Allow more than one reader -miguel.
* Aug/97 Added PCI 8042 controller support -DaveM
*/
/* The mouse is run off of one of the Zilog serial ports. On
* that port is the mouse and the keyboard, each gets a zs channel.
* The mouse itself is mouse-systems in nature. So the protocol is:
*
* Byte 1) Button state which is bit-encoded as
* 0x4 == left-button down, else up
* 0x2 == middle-button down, else up
* 0x1 == right-button down, else up
*
* Byte 2) Delta-x
* Byte 3) Delta-y
* Byte 4) Delta-x again
* Byte 5) Delta-y again
*
* One day this driver will have to support more than one mouse in the system.
*
* This driver has two modes of operation: the default VUID_NATIVE is
* set when the device is opened and allows the application to see the
* mouse character stream as we get it from the serial (for gpm for
* example). The second method, VUID_FIRM_EVENT will provide cooked
* events in Firm_event records as expected by SunOS/Solaris applications.
*
* FIXME: We need to support more than one mouse.
* */
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/fcntl.h>
#include <linux/signal.h>
#include <linux/timer.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/mm.h>
#include <linux/poll.h>
#include <linux/spinlock.h>
#include <linux/smp_lock.h>
#include <linux/init.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/vuid_event.h>
#include <linux/random.h>
/* The following keeps track of software state for the Sun
* mouse.
*/
#define STREAM_SIZE 2048
#define EV_SIZE (STREAM_SIZE/sizeof (Firm_event))
#define BUTTON_LEFT 4
#define BUTTON_MIDDLE 2
#define BUTTON_RIGHT 1
struct sun_mouse {
unsigned char transaction[5]; /* Each protocol transaction */
unsigned char byte; /* Counter, starts at 0 */
unsigned char button_state; /* Current button state */
unsigned char prev_state; /* Previous button state */
int delta_x; /* Current delta-x */
int delta_y; /* Current delta-y */
int active; /* set if device is open */
int vuid_mode; /* VUID_NATIVE or VUID_FIRM_EVENT */
wait_queue_head_t proc_list;
struct fasync_struct *fasync;
/* The event/stream queue */
spinlock_t lock;
unsigned int head;
unsigned int tail;
union {
char stream [STREAM_SIZE];
Firm_event ev [EV_SIZE];
} queue;
};
static struct sun_mouse sunmouse;
#define gen_events (sunmouse.vuid_mode != VUID_NATIVE)
#define bstate sunmouse.button_state
#define pstate sunmouse.prev_state
extern void mouse_put_char(char ch);
#undef SMOUSE_DEBUG
static int
push_event (Firm_event *ev)
{
unsigned long flags;
int next, ret;
spin_lock_irqsave(&sunmouse.lock, flags);
next = (sunmouse.head + 1) % EV_SIZE;
ret = 0;
if (next != sunmouse.tail) {
sunmouse.queue.ev [sunmouse.head] = *ev;
sunmouse.head = next;
ret = 1;
}
spin_unlock_irqrestore(&sunmouse.lock, flags);
return ret;
}
static int
queue_empty (void)
{
return sunmouse.head == sunmouse.tail;
}
/* Must be invoked under the sunmouse.lock */
static void get_from_queue (Firm_event *p)
{
*p = sunmouse.queue.ev [sunmouse.tail];
sunmouse.tail = (sunmouse.tail + 1) % EV_SIZE;
}
static void
push_char (char c)
{
unsigned long flags;
int next;
spin_lock_irqsave(&sunmouse.lock, flags);
next = (sunmouse.head + 1) % STREAM_SIZE;
if (next != sunmouse.tail) {
#ifdef SMOUSE_DEBUG
printk("P<%02x>\n", (unsigned char)c);
#endif
sunmouse.queue.stream [sunmouse.head] = c;
sunmouse.head = next;
}
spin_unlock_irqrestore(&sunmouse.lock, flags);
kill_fasync (&sunmouse.fasync, SIGIO, POLL_IN);
wake_up_interruptible (&sunmouse.proc_list);
}
/* Auto baud rate "detection". ;-) */
static int mouse_baud = 4800; /* Initial rate set by zilog driver. */
/* Change the baud rate after receiving too many "bogon bytes". */
void sun_mouse_change_baud(void)
{
extern void rs_change_mouse_baud(int newbaud);
if(mouse_baud == 1200)
mouse_baud = 2400;
else if(mouse_baud == 2400)
mouse_baud = 4800;
else if(mouse_baud == 4800)
mouse_baud = 9600;
else
mouse_baud = 1200;
rs_change_mouse_baud(mouse_baud);
}
/* This tries to monitor the mouse state so that it
* can automatically adjust to the correct baud rate.
* The mouse spits out BRKs when the baud rate is
* incorrect.
*
* It returns non-zero if we should ignore this byte.
*/
int mouse_baud_detection(unsigned char c, int is_break)
{
static int mouse_got_break = 0;
static int ctr = 0;
if (is_break) {
/* Let a few normal bytes go by before
* we jump the gun and say we need to
* try another baud rate.
*/
if (mouse_got_break && ctr < 8)
return 1;
/* OK, we need to try another baud rate. */
sun_mouse_change_baud();
ctr = 0;
mouse_got_break = 1;
return 1;
}
if (mouse_got_break) {
ctr++;
if (c == 0x87) {
printk(KERN_INFO "sunmouse: Successfully "
"adjusted to %d baud.\n", mouse_baud);
mouse_got_break = 0;
}
return 1;
}
return 0;
}
/* You ask me, why does this cap the lower bound at -127 and not
* -128? Because the xf86 mouse code is crap and treats -128
* as an illegal value and resets it's protocol state machine
* when it sees this value.
*/
#define CLIP(__X) (((__X) > 127) ? 127 : (((__X) < -127) ? -127 : (__X)))
/* The following is called from the serial driver when bytes/breaks
* are received on the Mouse line.
*/
void
sun_mouse_inbyte(unsigned char byte, int is_break)
{
signed char mvalue;
int d, pushed = 0;
Firm_event ev;
add_mouse_randomness (byte);
#if 0
{
static int xxx = 0;
printk("mouse(%02x:%d) ",
byte, is_break);
if (byte == 0x87) {
xxx = 0;
printk("\n");
}
}
#endif
if (mouse_baud_detection(byte, is_break))
return;
if(!sunmouse.active)
return;
/* Ignore this if it is garbage. */
if (sunmouse.byte == 69) {
if (byte != 0x87)
return;
/* Ok, we've begun the state machine. */
sunmouse.byte = 0;
}
#if 0
/* If the mouse sends us a byte from 0x80 to 0x87
* we are starting at byte zero in the transaction
* protocol.
*/
if((byte & ~0x0f) == 0x80)
sunmouse.byte = 0;
#endif
mvalue = (signed char) byte;
switch(sunmouse.byte) {
case 0:
/* If we get a bogus button byte, just skip it.
* When we get here the baud detection code has
* passed, so the only other things which can
* cause this are dropped serial characters and
* confused mouse. We check this because otherwise
* begin posting erroneous mouse events.
*/
if ((byte & 0xf0) != 0x80)
return;
/* Button state */
sunmouse.button_state = (~byte) & 0x7;
#ifdef SMOUSE_DEBUG
printk("B<Left %s, Middle %s, Right %s>",
((sunmouse.button_state & 0x4) ? "DOWN" : "UP"),
((sunmouse.button_state & 0x2) ? "DOWN" : "UP"),
((sunmouse.button_state & 0x1) ? "DOWN" : "UP"));
#endif
/* To deal with the Sparcbook 3 */
if (byte & 0x8) {
sunmouse.byte += 2;
sunmouse.delta_y = 0;
sunmouse.delta_x = 0;
}
sunmouse.byte++;
return;
case 1:
/* Delta-x 1 */
#ifdef SMOUSE_DEBUG
printk("DX1<%d>", mvalue);
#endif
sunmouse.delta_x = mvalue;
sunmouse.byte++;
return;
case 2:
/* Delta-y 1 */
#ifdef SMOUSE_DEBUG
printk("DY1<%d>", mvalue);
#endif
sunmouse.delta_y = mvalue;
sunmouse.byte++;
return;
case 3:
/* Delta-x 2 */
#ifdef SMOUSE_DEBUG
printk("DX2<%d>", mvalue);
#endif
sunmouse.delta_x += mvalue;
sunmouse.delta_x = CLIP(sunmouse.delta_x);
sunmouse.byte++;
return;
case 4:
/* Last byte, Delta-y 2 */
#ifdef SMOUSE_DEBUG
printk("DY2<%d>", mvalue);
#endif
sunmouse.delta_y += mvalue;
sunmouse.delta_y = CLIP(sunmouse.delta_y);
sunmouse.byte = 0; /* Back to button state */
break;
case 69:
/* Until we get the (0x80 -> 0x87) value we aren't
* in the middle of a real transaction, so just
* return.
*/
return;
default:
printk("sunmouse: bogon transaction state\n");
sunmouse.byte = 69; /* What could cause this? */
return;
};
if (!gen_events) {
push_char (~sunmouse.button_state & 0x87);
push_char (sunmouse.delta_x);
push_char (sunmouse.delta_y);
return;
}
d = bstate ^ pstate;
pstate = bstate;
if (d) {
if (d & BUTTON_LEFT) {
ev.id = MS_LEFT;
ev.value = bstate & BUTTON_LEFT;
}
if (d & BUTTON_RIGHT) {
ev.id = MS_RIGHT;
ev.value = bstate & BUTTON_RIGHT;
}
if (d & BUTTON_MIDDLE) {
ev.id = MS_MIDDLE;
ev.value = bstate & BUTTON_MIDDLE;
}
ev.time = xtime;
ev.value = ev.value ? VKEY_DOWN : VKEY_UP;
pushed += push_event (&ev);
}
if (sunmouse.delta_x) {
ev.id = LOC_X_DELTA;
ev.time = xtime;
ev.value = sunmouse.delta_x;
pushed += push_event (&ev);
sunmouse.delta_x = 0;
}
if (sunmouse.delta_y) {
ev.id = LOC_Y_DELTA;
ev.time = xtime;
ev.value = sunmouse.delta_y;
pushed += push_event (&ev);
}
if (pushed != 0) {
/* We just completed a transaction, wake up whoever is awaiting
* this event.
*/
kill_fasync (&sunmouse.fasync, SIGIO, POLL_IN);
wake_up_interruptible(&sunmouse.proc_list);
}
return;
}
static int
sun_mouse_open(struct inode * inode, struct file * file)
{
spin_lock_irq(&sunmouse.lock);
if (sunmouse.active++)
goto out;
sunmouse.delta_x = sunmouse.delta_y = 0;
sunmouse.button_state = 0x80;
sunmouse.vuid_mode = VUID_NATIVE;
out:
spin_unlock_irq(&sunmouse.lock);
return 0;
}
static int sun_mouse_fasync (int fd, struct file *filp, int on)
{
int retval;
retval = fasync_helper (fd, filp, on, &sunmouse.fasync);
if (retval < 0)
return retval;
return 0;
}
static int
sun_mouse_close(struct inode *inode, struct file *file)
{
sun_mouse_fasync (-1, file, 0);
spin_lock_irq(&sunmouse.lock);
sunmouse.active--;
spin_unlock_irq(&sunmouse.lock);
return 0;
}
static ssize_t
sun_mouse_write(struct file *file, const char *buffer,
size_t count, loff_t *ppos)
{
return -EINVAL; /* foo on you */
}
static ssize_t
sun_mouse_read(struct file *file, char *buffer,
size_t count, loff_t *ppos)
{
DECLARE_WAITQUEUE(wait, current);
unsigned long flags;
if (queue_empty ()) {
if (file->f_flags & O_NONBLOCK)
return -EWOULDBLOCK;
add_wait_queue (&sunmouse.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 (&sunmouse.proc_list, &wait);
}
if (gen_events) {
char *p = buffer, *end = buffer+count;
spin_lock_irqsave(&sunmouse.lock, flags);
while (p < end && !queue_empty ()){
Firm_event this_event;
get_from_queue(&this_event);
spin_unlock_irqrestore(&sunmouse.lock, flags);
#ifdef CONFIG_SPARC32_COMPAT
if (current->thread.flags & SPARC_FLAG_32BIT) {
if ((end - p) <
((sizeof(Firm_event) - sizeof(struct timeval) +
(sizeof(u32) * 2))))
break;
if (copy_to_user((Firm_event *)p, &this_event,
sizeof(Firm_event)-sizeof(struct timeval)))
return -EFAULT;
p += sizeof(Firm_event)-sizeof(struct timeval);
if (__put_user(this_event.time.tv_sec, (u32 *)p))
return -EFAULT;
p += sizeof(u32);
if (__put_user(this_event.time.tv_usec, (u32 *)p))
return -EFAULT;
p += sizeof(u32);
} else
#endif
{
if ((end - p) < sizeof(Firm_event))
break;
if (copy_to_user((Firm_event *)p, &this_event,
sizeof(Firm_event)))
return -EFAULT;
p += sizeof (Firm_event);
}
spin_lock_irqsave(&sunmouse.lock, flags);
}
spin_unlock_irqrestore(&sunmouse.lock, flags);
file->f_dentry->d_inode->i_atime = CURRENT_TIME;
return p-buffer;
} else {
int c, limit = 3;
if (count < limit)
limit = count;
for (c = 0; c < limit; c++) {
unsigned char val;
int empty = 0;
spin_lock_irqsave(&sunmouse.lock, flags);
if (queue_empty()) {
empty = 1;
val = 0;
} else {
val = sunmouse.queue.stream[sunmouse.tail];
sunmouse.tail = (sunmouse.tail + 1) % STREAM_SIZE;
}
spin_unlock_irqrestore(&sunmouse.lock, flags);
if (empty)
break;
put_user(val, buffer);
buffer++;
}
while (c < count) {
if (c >= 5)
break;
put_user(0, buffer);
buffer++;
c++;
}
file->f_dentry->d_inode->i_atime = CURRENT_TIME;
return c;
}
/* Only called if nothing was sent */
if (signal_pending(current))
return -ERESTARTSYS;
return 0;
}
static unsigned int sun_mouse_poll(struct file *file, poll_table *wait)
{
poll_wait(file, &sunmouse.proc_list, wait);
if(!queue_empty())
return POLLIN | POLLRDNORM;
return 0;
}
int
sun_mouse_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
int i;
switch (cmd){
/* VUIDGFORMAT - Get input device byte stream format */
case _IOR('v', 2, int):
if (put_user(sunmouse.vuid_mode, (int *) arg))
return -EFAULT;
break;
/* VUIDSFORMAT - Set input device byte stream format*/
case _IOW('v', 1, int):
if (get_user(i, (int *) arg))
return -EFAULT;
if (i == VUID_NATIVE || i == VUID_FIRM_EVENT){
int value;
if (get_user(value, (int *)arg))
return -EFAULT;
spin_lock_irq(&sunmouse.lock);
sunmouse.vuid_mode = value;
sunmouse.head = sunmouse.tail = 0;
spin_unlock_irq(&sunmouse.lock);
} else
return -EINVAL;
break;
case 0x8024540b:
case 0x40245408:
/* This is a buggy application doing termios on the mouse driver */
/* we ignore it. I keep this check here so that we will notice */
/* future mouse vuid ioctls */
return -ENOTTY;
default:
#ifdef DEBUG
printk ("[MOUSE-ioctl: %8.8x]\n", cmd);
#endif
return -EINVAL;
}
return 0;
}
struct file_operations sun_mouse_fops = {
read: sun_mouse_read,
write: sun_mouse_write,
poll: sun_mouse_poll,
ioctl: sun_mouse_ioctl,
open: sun_mouse_open,
release: sun_mouse_close,
fasync: sun_mouse_fasync,
};
static struct miscdevice sun_mouse_mouse = {
SUN_MOUSE_MINOR, "sunmouse", &sun_mouse_fops
};
void sun_mouse_zsinit(void)
{
printk("Sun Mouse-Systems mouse driver version 1.00\n");
sunmouse.active = 0;
misc_register (&sun_mouse_mouse);
sunmouse.delta_x = sunmouse.delta_y = 0;
sunmouse.button_state = 0x80;
init_waitqueue_head(&sunmouse.proc_list);
spin_lock_init(&sunmouse.lock);
sunmouse.byte = 69;
}
|