static inline void handle_mouse_event(unsigned char scancode)
{
if (mouse_reply_expected) {
if (scancode == AUX_ACK) {
mouse_reply_expected--;
return;
}
mouse_reply_expected = 0;
}
add_mouse_randomness(scancode);
if (aux_count) {
int head = queue->head;
queue->buf[head] = scancode;
head = (head + 1) & (AUX_BUF_SIZE - 1);
if (head != queue->tail) {
queue->head = head;
if (queue->fasync)
kill_fasync(&queue->fasync, SIGIO,
POLL_IN);
wake_up_interruptible(&queue->proc_list);
}
}
}
static void psaux_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
int val = iomd_readb(IOMD_MSEDAT);
if (mouse_reply_expected) {
if (val == AUX_ACK) {
mouse_reply_expected--;
return;
}
mouse_reply_expected = 0;
}
add_mouse_randomness(val);
if (aux_count) {
int head = queue->head;
queue->buf[head] = val;
head = (head + 1) & (AUX_BUF_SIZE-1);
if (head != queue->tail) {
queue->head = head;
kill_fasync(&queue->fasync, SIGIO, POLL_IN);
wake_up_interruptible(&queue->proc_list);
}
}
}
static inline void handle_mouse_event(unsigned char scancode)
{
#ifdef CONFIG_PSMOUSE
static unsigned char prev_code;
if (mouse_reply_expected) {
if (scancode == AUX_ACK) {
mouse_reply_expected--;
return;
}
mouse_reply_expected = 0;
}
else if(scancode == AUX_RECONNECT2 && prev_code == AUX_RECONNECT1
&& aux_reconnect) {
printk (KERN_INFO "PS/2 mouse reconnect detected\n");
queue->head = queue->tail = 0; /* Flush input queue */
__aux_write_ack(AUX_ENABLE_DEV); /* ping the mouse :) */
return;
}
prev_code = scancode;
add_mouse_randomness(scancode);
if (aux_count) {
int head = queue->head;
queue->buf[head] = scancode;
head = (head + 1) & (AUX_BUF_SIZE-1);
if (head != queue->tail) {
queue->head = head;
kill_fasync(&queue->fasync, SIGIO, POLL_IN);
wake_up_interruptible(&queue->proc_list);
}
}
#endif
}
static void ms_mouse_interrupt(int irq, void *dev_id, struct pt_regs * regs)
{
char dx, dy;
unsigned char buttons;
outb(MS_MSE_COMMAND_MODE, MS_MSE_CONTROL_PORT);
outb((inb(MS_MSE_DATA_PORT) | 0x20), MS_MSE_DATA_PORT);
outb(MS_MSE_READ_X, MS_MSE_CONTROL_PORT);
dx = inb(MS_MSE_DATA_PORT);
outb(MS_MSE_READ_Y, MS_MSE_CONTROL_PORT);
dy = inb(MS_MSE_DATA_PORT);
outb(MS_MSE_READ_BUTTONS, MS_MSE_CONTROL_PORT);
buttons = ~(inb(MS_MSE_DATA_PORT)) & 0x07;
outb(MS_MSE_COMMAND_MODE, MS_MSE_CONTROL_PORT);
outb((inb(MS_MSE_DATA_PORT) & 0xdf), MS_MSE_DATA_PORT);
if (dx != 0 || dy != 0 || buttons != mouse.buttons || ((~buttons) & 0x07)) {
add_mouse_randomness((buttons << 16) + (dy << 8) + dx);
mouse.buttons = buttons;
mouse.dx += dx;
mouse.dy += dy;
mouse.ready = 1;
wake_up_interruptible(&mouse.wait);
if (mouse.fasyncptr)
kill_fasync(mouse.fasyncptr, SIGIO);
}
}
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 void aux_interrupt(int cpl, void *dev_id, struct pt_regs * regs)
{
int head = queue->head;
int maxhead = (queue->tail-1) & (AUX_BUF_SIZE-1);
if ((inb(AUX_STATUS) & AUX_OBUF_FULL) != AUX_OBUF_FULL)
return;
add_mouse_randomness(queue->buf[head] = inb(AUX_INPUT_PORT));
if (head != maxhead) {
head++;
head &= AUX_BUF_SIZE-1;
}
queue->head = head;
aux_ready = 1;
if (queue->fasync)
kill_fasync(queue->fasync, SIGIO);
wake_up_interruptible(&queue->proc_list);
}
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(); */
}
void qp_interrupt(int cpl, void *dev_id, struct pt_regs * regs)
{
int head;
int maxhead;
// TRACER
__u32 seed;
head = queue->head;
maxhead = (queue->tail-1) & (2048 -1);
add_mouse_randomness(seed /* queue->buf[head] = inb(qp_data) */);
if (head != maxhead) {
head++;
head = head & 2048 -1;
}
queue->head = head;
if (queue->fasync)
kill_fasync(queue->fasync, 29 , 1 );
__wake_up(( &queue->proc_list ),1 ) ;
}
void mouse_interrupt(int irq, void *dev_id, struct pt_regs * regs)
{
char dx, dy, buttons;
ATIXL_MSE_DISABLE_UPDATE(); /* Note that interrupts are still enabled */
outb(ATIXL_MSE_READ_X, ATIXL_MSE_CONTROL_PORT); /* Select IR1 - X movement */
dx = inb( ATIXL_MSE_DATA_PORT);
outb(ATIXL_MSE_READ_Y, ATIXL_MSE_CONTROL_PORT); /* Select IR2 - Y movement */
dy = inb( ATIXL_MSE_DATA_PORT);
outb(ATIXL_MSE_READ_BUTTONS, ATIXL_MSE_CONTROL_PORT); /* Select IR0 - Button Status */
buttons = inb( ATIXL_MSE_DATA_PORT);
if (dx != 0 || dy != 0 || buttons != mouse.latch_buttons) {
add_mouse_randomness((buttons << 16) + (dy << 8) + dx);
mouse.latch_buttons |= buttons;
mouse.dx += dx;
mouse.dy += dy;
mouse.ready = 1;
wake_up_interruptible(&mouse.wait);
if (mouse.fasync)
kill_fasync(mouse.fasync, SIGIO);
}
ATIXL_MSE_ENABLE_UPDATE();
}
void
wsmouse_input(struct device *wsmousedev, u_int btns, /* 0 is up */
int x, int y, int z, int w, u_int flags)
{
struct wsmouse_softc *sc = (struct wsmouse_softc *)wsmousedev;
struct wscons_event *ev;
struct wseventvar *evar;
int mb, ub, d, get, put, any;
add_mouse_randomness(x ^ y ^ z ^ w ^ btns);
/*
* Discard input if not ready.
*/
evar = sc->sc_base.me_evp;
if (evar == NULL)
return;
#ifdef DIAGNOSTIC
if (evar->q == NULL) {
printf("wsmouse_input: evar->q=NULL\n");
return;
}
#endif
#if NWSMUX > 0
DPRINTFN(5,("wsmouse_input: %s mux=%p, evar=%p\n",
sc->sc_base.me_dv.dv_xname, sc->sc_base.me_parent, evar));
#endif
sc->sc_mb = btns;
if (!(flags & WSMOUSE_INPUT_ABSOLUTE_X))
sc->sc_dx += x;
if (!(flags & WSMOUSE_INPUT_ABSOLUTE_Y))
sc->sc_dy += y;
if (!(flags & WSMOUSE_INPUT_ABSOLUTE_Z))
sc->sc_dz += z;
if (!(flags & WSMOUSE_INPUT_ABSOLUTE_W))
sc->sc_dw += w;
/*
* We have at least one event (mouse button, delta-X, or
* delta-Y; possibly all three, and possibly three separate
* button events). Deliver these events until we are out
* of changes or out of room. As events get delivered,
* mark them `unchanged'.
*/
ub = sc->sc_ub;
any = 0;
get = evar->get;
put = evar->put;
ev = &evar->q[put];
/* NEXT prepares to put the next event, backing off if necessary */
#define NEXT \
if ((++put) % WSEVENT_QSIZE == get) { \
put--; \
goto out; \
}
/* ADVANCE completes the `put' of the event */
#define ADVANCE \
ev++; \
if (put >= WSEVENT_QSIZE) { \
put = 0; \
ev = &evar->q[0]; \
} \
any = 1
/* TIMESTAMP sets `time' field of the event to the current time */
#define TIMESTAMP \
do { \
getnanotime(&ev->time); \
} while (0)
if (flags & WSMOUSE_INPUT_ABSOLUTE_X) {
if (sc->sc_x != x) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_X;
ev->value = x;
TIMESTAMP;
ADVANCE;
sc->sc_x = x;
}
} else {
if (sc->sc_dx) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_DELTA_X;
ev->value = sc->sc_dx;
TIMESTAMP;
ADVANCE;
sc->sc_dx = 0;
}
}
if (flags & WSMOUSE_INPUT_ABSOLUTE_Y) {
if (sc->sc_y != y) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_Y;
ev->value = y;
TIMESTAMP;
ADVANCE;
sc->sc_y = y;
}
} else {
if (sc->sc_dy) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_DELTA_Y;
ev->value = sc->sc_dy;
TIMESTAMP;
ADVANCE;
sc->sc_dy = 0;
}
}
if (flags & WSMOUSE_INPUT_ABSOLUTE_Z) {
if (sc->sc_z != z) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_Z;
ev->value = z;
TIMESTAMP;
ADVANCE;
sc->sc_z = z;
}
} else {
if (sc->sc_dz) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_DELTA_Z;
ev->value = sc->sc_dz;
TIMESTAMP;
ADVANCE;
sc->sc_dz = 0;
}
}
if (flags & WSMOUSE_INPUT_ABSOLUTE_W) {
if (sc->sc_w != w) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_W;
ev->value = w;
TIMESTAMP;
ADVANCE;
sc->sc_w = w;
}
} else {
if (sc->sc_dw) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_DELTA_W;
ev->value = sc->sc_dw;
TIMESTAMP;
ADVANCE;
sc->sc_dw = 0;
}
}
mb = sc->sc_mb;
while ((d = mb ^ ub) != 0) {
/*
* Mouse button change. Find the first change and drop
* it into the event queue.
*/
NEXT;
ev->value = ffs(d) - 1;
KASSERT(ev->value >= 0);
d = 1 << ev->value;
ev->type =
(mb & d) ? WSCONS_EVENT_MOUSE_DOWN : WSCONS_EVENT_MOUSE_UP;
TIMESTAMP;
ADVANCE;
ub ^= d;
}
/* XXX fake wscons_event notifying wsmoused(8) to close mouse device */
if (flags & WSMOUSE_INPUT_WSMOUSED_CLOSE) {
NEXT;
ev->type = WSCONS_EVENT_WSMOUSED_CLOSE;
ev->value = 0;
TIMESTAMP;
ADVANCE;
}
#undef TIMESTAMP
#undef ADVANCE
#undef NEXT
out:
if (any) {
sc->sc_ub = ub;
evar->put = put;
WSEVENT_WAKEUP(evar);
#ifdef BURNER_SUPPORT
/* wsdisplay_burn(sc->sc_displaydv, WSDISPLAY_BURN_MOUSE); */
#endif
#if NWSMUX > 0
DPRINTFN(5,("wsmouse_input: %s wakeup evar=%p\n",
sc->sc_base.me_dv.dv_xname, evar));
#endif
}
}
/* 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 >= 0x80 && byte <= 0x87)
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
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.
*/
sunmouse.ready = 1;
if (sunmouse.fasync)
kill_fasync (sunmouse.fasync, SIGIO);
wake_up_interruptible(&sunmouse.proc_list);
}
return;
}
