/* $NetBSD: ms_pckbport.c,v 1.9 2012/10/27 17:18:11 chs Exp $ */ /* * Copyright (c) 2002 Valeriy E. Ushakov * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include __KERNEL_RCSID(0, "$NetBSD: ms_pckbport.c,v 1.9 2012/10/27 17:18:11 chs Exp $"); /* * Attach PS/2 mouse at pckbport aux port * and convert PS/2 mouse protocol to Sun firm events. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* * NB: we {re,ab}use ms_softc input translator state and ignore its * zs-related members. Not quite clean, but what the heck. */ struct ms_pckbport_softc { struct ms_softc sc_ms; /* pckbport attachment */ pckbport_tag_t sc_kbctag; pckbport_slot_t sc_kbcslot; int sc_enabled; /* input enabled? */ }; static int ms_pckbport_match(device_t, cfdata_t, void *); static void ms_pckbport_attach(device_t, device_t, void *); CFATTACH_DECL_NEW(ms_pckbport, sizeof(struct ms_pckbport_softc), ms_pckbport_match, ms_pckbport_attach, NULL, NULL); static int ms_pckbport_iopen(device_t, int); static int ms_pckbport_iclose(device_t, int); static void ms_pckbport_input(void *, int); static int ms_pckbport_match(device_t parent, cfdata_t cf, void *aux) { struct pckbport_attach_args *pa = aux; return (pa->pa_slot == PCKBPORT_AUX_SLOT); } static void ms_pckbport_attach(device_t parent, device_t self, void *aux) { struct ms_pckbport_softc *sc = device_private(self); struct ms_softc *ms = &sc->sc_ms; struct pckbport_attach_args *pa = aux; u_char cmd[1], resp[2]; int res; ms->ms_dev = self; /* save our pckbport attachment */ sc->sc_kbctag = pa->pa_tag; sc->sc_kbcslot = pa->pa_slot; /* Hooks called by upper layer on device open/close */ ms->ms_deviopen = ms_pckbport_iopen; ms->ms_deviclose = ms_pckbport_iclose; aprint_normal("\n"); /* reset the device */ cmd[0] = PMS_RESET; res = pckbport_poll_cmd(sc->sc_kbctag, sc->sc_kbcslot, cmd, 1, 2, resp, 1); #ifdef DIAGNOSTIC if (res || resp[0] != PMS_RSTDONE || resp[1] != 0) { aprint_error("%s: reset error\n", __func__); /* return; */ } #endif pckbport_set_inputhandler(sc->sc_kbctag, sc->sc_kbcslot, ms_pckbport_input, sc, device_xname(self)); /* no interrupts until device is actually opened */ cmd[0] = PMS_DEV_DISABLE; res = pckbport_poll_cmd(sc->sc_kbctag, sc->sc_kbcslot, cmd, 1, 0, 0, 0); if (res) aprint_error("%s: failed to disable interrupts\n", __func__); pckbport_slot_enable(sc->sc_kbctag, sc->sc_kbcslot, 0); } static int ms_pckbport_iopen(device_t self, int flags) { struct ms_pckbport_softc *sc = device_private(self); struct ms_softc *ms = &sc->sc_ms; u_char cmd[1]; int res; ms->ms_byteno = 0; ms->ms_dx = ms->ms_dy = 0; ms->ms_ub = ms->ms_mb = 0; pckbport_slot_enable(sc->sc_kbctag, sc->sc_kbcslot, 1); cmd[0] = PMS_DEV_ENABLE; res = pckbport_enqueue_cmd(sc->sc_kbctag, sc->sc_kbcslot, cmd, 1, 0, 1, NULL); if (res) { printf("%s: command error\n", __func__); return (res); } sc->sc_enabled = 1; return (0); } static int ms_pckbport_iclose(device_t self, int flags) { struct ms_pckbport_softc *sc = device_private(self); u_char cmd[1]; int res; cmd[0] = PMS_DEV_DISABLE; res = pckbport_enqueue_cmd(sc->sc_kbctag, sc->sc_kbcslot, cmd, 1, 0, 1, NULL); if (res) printf("%s: command error\n", __func__); pckbport_slot_enable(sc->sc_kbctag, sc->sc_kbcslot, 0); sc->sc_enabled = 0; return (0); } /* Masks for the first byte of a PS/2 mouse packet */ #define PS2LBUTMASK 0x01 #define PS2RBUTMASK 0x02 #define PS2MBUTMASK 0x04 /* * Got a receive interrupt - pckbport wants to give us a byte. */ static void ms_pckbport_input(void *vsc, int data) { struct ms_pckbport_softc *sc = vsc; struct ms_softc *ms = &sc->sc_ms; struct firm_event *fe; int mb, ub, d, get, put, any; /* map changed buttons mask to the highest bit */ static const char to_one[] = { 1, 2, 2, 4, 4, 4, 4 }; /* map bits to mouse buttons */ static const int to_id[] = { MS_LEFT, MS_MIDDLE, 0, MS_RIGHT }; if (!sc->sc_enabled) { /* Interrupts are not expected. Discard the byte. */ return; } switch (ms->ms_byteno) { case 0: if ((data & 0xc0) == 0) { /* no ovfl, bit 3 == 1 too? */ ms->ms_mb = ((data & PS2LBUTMASK) ? 0x1 : 0) | ((data & PS2MBUTMASK) ? 0x2 : 0) | ((data & PS2RBUTMASK) ? 0x4 : 0) ; ++ms->ms_byteno; } return; case 1: ms->ms_dx += (int8_t)data; ++ms->ms_byteno; return; case 2: ms->ms_dy += (int8_t)data; ms->ms_byteno = 0; break; /* last byte processed, report changes */ } any = 0; get = ms->ms_events.ev_get; put = ms->ms_events.ev_put; fe = &ms->ms_events.ev_q[put]; /* NEXT prepares to put the next event, backing off if necessary */ #define NEXT do { \ if ((++put) % EV_QSIZE == get) { \ --put; \ goto out; \ } \ } while (0) /* ADVANCE completes the `put' of the event */ #define ADVANCE do { \ ++fe; \ if (put >= EV_QSIZE) { \ put = 0; \ fe = &ms->ms_events.ev_q[0]; \ } \ any = 1; \ } while (0) ub = ms->ms_ub; /* old buttons state */ mb = ms->ms_mb; /* new buttons state */ while ((d = mb ^ ub) != 0) { /* * Mouse button change. Convert up to three state changes * to the `first' change, and drop it into the event queue. */ NEXT; d = to_one[d - 1]; /* from 1..7 to {1,2,4} */ fe->id = to_id[d - 1]; /* from {1,2,4} to ID */ fe->value = (mb & d) ? VKEY_DOWN : VKEY_UP; firm_gettime(fe); ADVANCE; ub ^= d; /* reflect the button state change */ } if (ms->ms_dx != 0) { NEXT; fe->id = LOC_X_DELTA; fe->value = ms->ms_dx; firm_gettime(fe); ADVANCE; ms->ms_dx = 0; } if (ms->ms_dy != 0) { NEXT; fe->id = LOC_Y_DELTA; fe->value = ms->ms_dy; firm_gettime(fe); ADVANCE; ms->ms_dy = 0; } out: if (any) { ms->ms_ub = ub; /* save button state */ ms->ms_events.ev_put = put; EV_WAKEUP(&ms->ms_events); } }