root/dev/wscons/wsmouse.c

DEFINITIONS

1. wsmousedevprint
2. wsmouse_match
3. wsmouse_attach
4. wsmouse_activate
5. wsmouse_detach
6. wsmouse_input
7. wsmouseopen
8. wsmouseclose
9. wsmousedoopen
10. wsmouseread
11. wsmouseioctl
12. wsmousedoioctl
13. wsmouse_do_ioctl
14. wsmousepoll
15. wsmouse_mux_open
16. wsmouse_mux_close
17. wsmouse_add_mux

    1 /* $OpenBSD: wsmouse.c,v 1.19 2007/04/10 22:37:17 miod Exp $ */
    2 /* $NetBSD: wsmouse.c,v 1.35 2005/02/27 00:27:52 perry Exp $ */
    4 /*
    5  * Copyright (c) 1996, 1997 Christopher G. Demetriou.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *    must display the following acknowledgement:
   17  *      This product includes software developed by Christopher G. Demetriou
   18  *      for the NetBSD Project.
   19  * 4. The name of the author may not be used to endorse or promote products
   20  *    derived from this software without specific prior written permission
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   32  */
   34 /*
   35  * Copyright (c) 1992, 1993
   36  *      The Regents of the University of California.  All rights reserved.
   37  *
   38  * This software was developed by the Computer Systems Engineering group
   39  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   40  * contributed to Berkeley.
   41  *
   42  * All advertising materials mentioning features or use of this software
   43  * must display the following acknowledgement:
   44  *      This product includes software developed by the University of
   45  *      California, Lawrence Berkeley Laboratory.
   46  *
   47  * Redistribution and use in source and binary forms, with or without
   48  * modification, are permitted provided that the following conditions
   49  * are met:
   50  * 1. Redistributions of source code must retain the above copyright
   51  *    notice, this list of conditions and the following disclaimer.
   52  * 2. Redistributions in binary form must reproduce the above copyright
   53  *    notice, this list of conditions and the following disclaimer in the
   54  *    documentation and/or other materials provided with the distribution.
   55  * 3. Neither the name of the University nor the names of its contributors
   56  *    may be used to endorse or promote products derived from this software
   57  *    without specific prior written permission.
   58  *
   59  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   60  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   61  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   62  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   63  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   65  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   66  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   67  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   68  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   69  * SUCH DAMAGE.
   70  *
   71  *      @(#)ms.c        8.1 (Berkeley) 6/11/93
   72  */
   74 /*
   75  * Mouse driver.
   76  */
   78 #ifndef SMALL_KERNEL
   79 #define BURNER_SUPPORT
   80 #endif
   82 #include <sys/param.h>
   83 #include <sys/conf.h>
   84 #include <sys/ioctl.h>
   85 #include <sys/fcntl.h>
   86 #include <sys/kernel.h>
   87 #include <sys/proc.h>
   88 #include <sys/syslog.h>
   89 #include <sys/systm.h>
   90 #include <sys/tty.h>
   91 #include <sys/signalvar.h>
   92 #include <sys/device.h>
   93 #include <sys/vnode.h>
   94 #include <sys/poll.h>
   96 #include <dev/wscons/wsconsio.h>
   97 #include <dev/wscons/wsmousevar.h>
   98 #include <dev/wscons/wseventvar.h>
   99 #include <dev/wscons/wsdisplayvar.h>
  100 #include <dev/rndvar.h>
  102 #include "wsmux.h"
  103 #include "wsdisplay.h"
  104 #include "wskbd.h"
  106 #include <dev/wscons/wsmuxvar.h>
  108 #if defined(WSMUX_DEBUG) && NWSMUX > 0
  109 #define DPRINTF(x)      if (wsmuxdebug) printf x
  110 #define DPRINTFN(n,x)   if (wsmuxdebug > (n)) printf x
  111 extern int wsmuxdebug;
  112 #else
  113 #define DPRINTF(x)
  114 #define DPRINTFN(n,x)
  115 #endif
  117 #define INVALID_X       INT_MAX
  118 #define INVALID_Y       INT_MAX
  119 #define INVALID_Z       INT_MAX
  120 #define INVALID_W       INT_MAX
  122 struct wsmouse_softc {
  123         struct wsevsrc  sc_base;
  125         const struct wsmouse_accessops *sc_accessops;
  126         void            *sc_accesscookie;
u_int           sc_mb;          /* mouse button state */
u_int           sc_ub;          /* user button state */
  130         int             sc_dx;          /* delta-x */
  131         int             sc_dy;          /* delta-y */
  132         int             sc_dz;          /* delta-z */
  133         int             sc_dw;          /* delta-w */
  134         int             sc_x;           /* absolute-x */
  135         int             sc_y;           /* absolute-y */
  136         int             sc_z;           /* absolute-z */
  137         int             sc_w;           /* absolute-w */
  139         int             sc_refcnt;
u_char          sc_dying;       /* device is being detached */
  141 };
  143 int     wsmouse_match(struct device *, void *, void *);
  144 void    wsmouse_attach(struct device *, struct device *, void *);
  145 int     wsmouse_detach(struct device *, int);
  146 int     wsmouse_activate(struct device *, enum devact);
  148 int     wsmouse_do_ioctl(struct wsmouse_softc *, u_long, caddr_t, 
  149                               int, struct proc *);
  151 #if NWSMUX > 0
  152 int     wsmouse_mux_open(struct wsevsrc *, struct wseventvar *);
  153 int     wsmouse_mux_close(struct wsevsrc *);
  154 #endif
  156 int     wsmousedoioctl(struct device *, u_long, caddr_t, int, 
  157                             struct proc *);
  158 int     wsmousedoopen(struct wsmouse_softc *, struct wseventvar *);
  160 struct cfdriver wsmouse_cd = {
NULL, "wsmouse", DV_TTY
  162 };
  164 struct cfattach wsmouse_ca = {
  165         sizeof (struct wsmouse_softc), wsmouse_match, wsmouse_attach,
wsmouse_detach, wsmouse_activate
  167 };
  169 #if NWSMUX > 0
  170 struct wssrcops wsmouse_srcops = {
WSMUX_MOUSE,
wsmouse_mux_open, wsmouse_mux_close, wsmousedoioctl, NULL, NULL
  173 };
  174 #endif
  176 /*
  177  * Print function (for parent devices).
  178  */
  179 int
wsmousedevprint(void *aux, const char *pnp)
  181 {
  183         if (pnp)
printf("wsmouse at %s", pnp);
  185         return (UNCONF);
  186 }
  188 int
wsmouse_match(struct device *parent, void *match, void *aux)
  190 {
  191         return (1);
  192 }
  194 void
wsmouse_attach(struct device *parent, struct device *self, void *aux)
  196 {
  197         struct wsmouse_softc *sc = (struct wsmouse_softc *)self;
  198         struct wsmousedev_attach_args *ap = aux;
  199 #if NWSMUX > 0
  200         int mux, error;
  201 #endif
sc->sc_accessops = ap->accessops;
sc->sc_accesscookie = ap->accesscookie;
  206 #if NWSMUX > 0
sc->sc_base.me_ops = &wsmouse_srcops;
mux = sc->sc_base.me_dv.dv_cfdata->wsmousedevcf_mux;
  209         if (mux >= 0) {
error = wsmux_attach_sc(wsmux_getmux(mux), &sc->sc_base);
  211                 if (error)
printf(" attach error=%d", error);
  213                 else
printf(" mux %d", mux);
  215         }
  216 #else
  217 #if 0   /* not worth keeping, especially since the default value is not -1... */
  218         if (sc->sc_base.me_dv.dv_cfdata->wsmousedevcf_mux >= 0)
printf(" (mux ignored)");
  220 #endif
  221 #endif  /* NWSMUX > 0 */
printf("\n");
  224 }
  226 int
wsmouse_activate(struct device *self, enum devact act)
  228 {
  229         struct wsmouse_softc *sc = (struct wsmouse_softc *)self;
  231         if (act == DVACT_DEACTIVATE)
sc->sc_dying = 1;
  233         return (0);
  234 }
  236 /*
  237  * Detach a mouse.  To keep track of users of the softc we keep
  238  * a reference count that's incremented while inside, e.g., read.
  239  * If the mouse is active and the reference count is > 0 (0 is the
  240  * normal state) we post an event and then wait for the process
  241  * that had the reference to wake us up again.  Then we blow away the
  242  * vnode and return (which will deallocate the softc).
  243  */
  244 int
wsmouse_detach(struct device *self, int flags)
  246 {
  247         struct wsmouse_softc *sc = (struct wsmouse_softc *)self;
  248         struct wseventvar *evar;
  249         int maj, mn;
  250         int s;
  252 #if NWSMUX > 0
  253         /* Tell parent mux we're leaving. */
  254         if (sc->sc_base.me_parent != NULL) {
DPRINTF(("wsmouse_detach:\n"));
wsmux_detach_sc(&sc->sc_base);
  257         }
  258 #endif
  260         /* If we're open ... */
evar = sc->sc_base.me_evp;
  262         if (evar != NULL && evar->io != NULL) {
s = spltty();
  264                 if (--sc->sc_refcnt >= 0) {
  265                         /* Wake everyone by generating a dummy event. */
  266                         if (++evar->put >= WSEVENT_QSIZE)
evar->put = 0;
WSEVENT_WAKEUP(evar);
  269                         /* Wait for processes to go away. */
  270                         if (tsleep(sc, PZERO, "wsmdet", hz * 60))
printf("wsmouse_detach: %s didn't detach\n",
sc->sc_base.me_dv.dv_xname);
  273                 }
splx(s);
  275         }
  277         /* locate the major number */
  278         for (maj = 0; maj < nchrdev; maj++)
  279                 if (cdevsw[maj].d_open == wsmouseopen)
  280                         break;
  282         /* Nuke the vnodes for any open instances (calls close). */
mn = self->dv_unit;
vdevgone(maj, mn, mn, VCHR);
  286         return (0);
  287 }
  289 void
wsmouse_input(struct device *wsmousedev, u_int btns, /* 0 is up */
  291     int x, int y, int z, int w, u_int flags)
  292 {
  293         struct wsmouse_softc *sc = (struct wsmouse_softc *)wsmousedev;
  294         struct wscons_event *ev;
  295         struct wseventvar *evar;
  296         int mb, ub, d, get, put, any;
add_mouse_randomness(x ^ y ^ z ^ w ^ btns);
  300         /*
  301          * Discard input if not ready.
  302          */
evar = sc->sc_base.me_evp;
  304         if (evar == NULL)
  305                 return;
  307 #ifdef DIAGNOSTIC
  308         if (evar->q == NULL) {
printf("wsmouse_input: evar->q=NULL\n");
  310                 return;
  311         }
  312 #endif
  314 #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));
  317 #endif
sc->sc_mb = btns;
  320         if (!(flags & WSMOUSE_INPUT_ABSOLUTE_X))
sc->sc_dx += x;
  322         if (!(flags & WSMOUSE_INPUT_ABSOLUTE_Y))
sc->sc_dy += y;
  324         if (!(flags & WSMOUSE_INPUT_ABSOLUTE_Z))
sc->sc_dz += z;
  326         if (!(flags & WSMOUSE_INPUT_ABSOLUTE_W))
sc->sc_dw += w;
  329         /*
  330          * We have at least one event (mouse button, delta-X, or
  331          * delta-Y; possibly all three, and possibly three separate
  332          * button events).  Deliver these events until we are out
  333          * of changes or out of room.  As events get delivered,
  334          * mark them `unchanged'.
  335          */
ub = sc->sc_ub;
any = 0;
get = evar->get;
put = evar->put;
ev = &evar->q[put];
  342         /* NEXT prepares to put the next event, backing off if necessary */
  343 #define NEXT                                                            \
  344         if ((++put) % WSEVENT_QSIZE == get) {                           \
put--;                                                  \
  346                 goto out;                                               \
  347         }
  348         /* ADVANCE completes the `put' of the event */
  349 #define ADVANCE                                                         \
ev++;                                                           \
  351         if (put >= WSEVENT_QSIZE) {                                     \
put = 0;                                                \
ev = &evar->q[0];                               \
  354         }                                                               \
any = 1
  356         /* TIMESTAMP sets `time' field of the event to the current time */
  357 #define TIMESTAMP                                                       \
  358         do {                                                            \
getnanotime(&ev->time);                                 \
  360         } while (0)
  362         if (flags & WSMOUSE_INPUT_ABSOLUTE_X) {
  363                 if (sc->sc_x != x) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_X;
ev->value = x;
TIMESTAMP;
ADVANCE;
sc->sc_x = x;
  370                 }
  371         } else {
  372                 if (sc->sc_dx) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_DELTA_X;
ev->value = sc->sc_dx;
TIMESTAMP;
ADVANCE;
sc->sc_dx = 0;
  379                 }
  380         }
  381         if (flags & WSMOUSE_INPUT_ABSOLUTE_Y) {
  382                 if (sc->sc_y != y) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_Y;
ev->value = y;
TIMESTAMP;
ADVANCE;
sc->sc_y = y;
  389                 }
  390         } else {
  391                 if (sc->sc_dy) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_DELTA_Y;
ev->value = sc->sc_dy;
TIMESTAMP;
ADVANCE;
sc->sc_dy = 0;
  398                 }
  399         }
  400         if (flags & WSMOUSE_INPUT_ABSOLUTE_Z) {
  401                 if (sc->sc_z != z) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_Z;
ev->value = z;
TIMESTAMP;
ADVANCE;
sc->sc_z = z;
  408                 }
  409         } else {
  410                 if (sc->sc_dz) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_DELTA_Z;
ev->value = sc->sc_dz;
TIMESTAMP;
ADVANCE;
sc->sc_dz = 0;
  417                 }
  418         }
  419         if (flags & WSMOUSE_INPUT_ABSOLUTE_W) {
  420                 if (sc->sc_w != w) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_W;
ev->value = w;
TIMESTAMP;
ADVANCE;
sc->sc_w = w;
  427                 }
  428         } else {
  429                 if (sc->sc_dw) {
NEXT;
ev->type = WSCONS_EVENT_MOUSE_DELTA_W;
ev->value = sc->sc_dw;
TIMESTAMP;
ADVANCE;
sc->sc_dw = 0;
  436                 }
  437         }
mb = sc->sc_mb;
  440         while ((d = mb ^ ub) != 0) {
  441                 /*
  442                  * Mouse button change.  Find the first change and drop
  443                  * it into the event queue.
  444                  */
NEXT;
ev->value = ffs(d) - 1;
KASSERT(ev->value >= 0);
d = 1 << ev->value;
ev->type =
  452                     (mb & d) ? WSCONS_EVENT_MOUSE_DOWN : WSCONS_EVENT_MOUSE_UP;
TIMESTAMP;
ADVANCE;
ub ^= d;
  456         }
  458         /* XXX fake wscons_event notifying wsmoused(8) to close mouse device */
  459         if (flags & WSMOUSE_INPUT_WSMOUSED_CLOSE) {
NEXT;
ev->type = WSCONS_EVENT_WSMOUSED_CLOSE;
ev->value = 0;
TIMESTAMP;
ADVANCE;
  465         }
  467 #undef  TIMESTAMP
  468 #undef  ADVANCE
  469 #undef  NEXT
out:
  472         if (any) {
sc->sc_ub = ub;
evar->put = put;
WSEVENT_WAKEUP(evar);
  476 #ifdef BURNER_SUPPORT
  477                 /* wsdisplay_burn(sc->sc_displaydv, WSDISPLAY_BURN_MOUSE); */
  478 #endif
  479 #if NWSMUX > 0
DPRINTFN(5,("wsmouse_input: %s wakeup evar=%p\n",
sc->sc_base.me_dv.dv_xname, evar));
  482 #endif
  483         }
  484 }
  486 int
wsmouseopen(dev_t dev, int flags, int mode, struct proc *p)
  488 {
  489         struct wsmouse_softc *sc;
  490         struct wseventvar *evar;
  491         int error, unit;
unit = minor(dev);
  494         if (unit >= wsmouse_cd.cd_ndevs ||      /* make sure it was attached */
  495             (sc = wsmouse_cd.cd_devs[unit]) == NULL)
  496                 return (ENXIO);
  498 #if NWSMUX > 0
DPRINTF(("wsmouseopen: %s mux=%p p=%p\n", sc->sc_base.me_dv.dv_xname,
sc->sc_base.me_parent, p));
  501 #endif
  503         if (sc->sc_dying)
  504                 return (EIO);
  506         if ((flags & (FREAD | FWRITE)) == FWRITE)
  507                 return (0);                     /* always allow open for write
  508                                                    so ioctl() is possible. */
  510         if (sc->sc_base.me_evp != NULL)
  511                 return (EBUSY);
evar = &sc->sc_base.me_evar;
wsevent_init(evar);
evar->io = p;
error = wsmousedoopen(sc, evar);
  518         if (error) {
DPRINTF(("wsmouseopen: %s open failed\n",
sc->sc_base.me_dv.dv_xname));
sc->sc_base.me_evp = NULL;
wsevent_fini(evar);
  523         }
  524         return (error);
  525 }
  527 int
  528 wsmouseclose(dev_t dev, int flags, int mode, struct proc *p)
  529 {
  530         struct wsmouse_softc *sc =
  531             (struct wsmouse_softc *)wsmouse_cd.cd_devs[minor(dev)];
  532         struct wseventvar *evar = sc->sc_base.me_evp;
  534         if ((flags & (FREAD | FWRITE)) == FWRITE)
  535                 return (0);                     /* see wsmouseopen() */
  537         if (evar == NULL)
  538                 /* not open for read */
  539                 return (0);
sc->sc_base.me_evp = NULL;
  541         (*sc->sc_accessops->disable)(sc->sc_accesscookie);
wsevent_fini(evar);
  544         return (0);
  545 }
  547 int
wsmousedoopen(struct wsmouse_softc *sc, struct wseventvar *evp)
  549 {
sc->sc_base.me_evp = evp;
sc->sc_x = INVALID_X;
sc->sc_y = INVALID_Y;
sc->sc_z = INVALID_Z;
sc->sc_w = INVALID_W;
  556         /* enable the device, and punt if that's not possible */
  557         return (*sc->sc_accessops->enable)(sc->sc_accesscookie);
  558 }
  560 int
  561 wsmouseread(dev_t dev, struct uio *uio, int flags)
  562 {
  563         struct wsmouse_softc *sc = wsmouse_cd.cd_devs[minor(dev)];
  564         int error;
  566         if (sc->sc_dying)
  567                 return (EIO);
  569 #ifdef DIAGNOSTIC
  570         if (sc->sc_base.me_evp == NULL) {
printf("wsmouseread: evp == NULL\n");
  572                 return (EINVAL);
  573         }
  574 #endif
sc->sc_refcnt++;
error = wsevent_read(sc->sc_base.me_evp, uio, flags);
  578         if (--sc->sc_refcnt < 0) {
wakeup(sc);
error = EIO;
  581         }
  582         return (error);
  583 }
  585 int
  586 wsmouseioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
  587 {
  588         return (wsmousedoioctl(wsmouse_cd.cd_devs[minor(dev)],
cmd, data, flag, p));
  590 }
  592 /* A wrapper around the ioctl() workhorse to make reference counting easy. */
  593 int
wsmousedoioctl(struct device *dv, u_long cmd, caddr_t data, int flag,
  595     struct proc *p)
  596 {
  597         struct wsmouse_softc *sc = (struct wsmouse_softc *)dv;
  598         int error;
sc->sc_refcnt++;
error = wsmouse_do_ioctl(sc, cmd, data, flag, p);
  602         if (--sc->sc_refcnt < 0)
wakeup(sc);
  604         return (error);
  605 }
  607 int
wsmouse_do_ioctl(struct wsmouse_softc *sc, u_long cmd, caddr_t data, int flag,
  609     struct proc *p)
  610 {
  611         int error;
  613         if (sc->sc_dying)
  614                 return (EIO);
  616         /*
  617          * Try the generic ioctls that the wsmouse interface supports.
  618          */
  620         switch (cmd) {
  621         case FIOASYNC:
  622         case FIOSETOWN:
  623         case TIOCSPGRP:
  624                 if ((flag & FWRITE) == 0)
  625                         return (EACCES);
  626         }
  628         switch (cmd) {
  629         case FIONBIO:           /* we will remove this someday (soon???) */
  630                 return (0);
  632         case FIOASYNC:
  633                 if (sc->sc_base.me_evp == NULL)
  634                         return (EINVAL);
sc->sc_base.me_evp->async = *(int *)data != 0;
  636                 return (0);
  638         case FIOSETOWN:
  639                 if (sc->sc_base.me_evp == NULL)
  640                         return (EINVAL);
  641                 if (-*(int *)data != sc->sc_base.me_evp->io->p_pgid
  642                     && *(int *)data != sc->sc_base.me_evp->io->p_pid)
  643                         return (EPERM);
  644                 return (0);
  646         case TIOCSPGRP:
  647                 if (sc->sc_base.me_evp == NULL)
  648                         return (EINVAL);
  649                 if (*(int *)data != sc->sc_base.me_evp->io->p_pgid)
  650                         return (EPERM);
  651                 return (0);
  652         }
  654         /*
  655          * Try the mouse driver for WSMOUSEIO ioctls.  It returns -1
  656          * if it didn't recognize the request.
  657          */
error = (*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd,
data, flag, p);
  660         return (error != -1 ? error : ENOTTY);
  661 }
  663 int
  664 wsmousepoll(dev_t dev, int events, struct proc *p)
  665 {
  666         struct wsmouse_softc *sc = wsmouse_cd.cd_devs[minor(dev)];
  668         if (sc->sc_base.me_evp == NULL)
  669                 return (POLLERR);
  670         return (wsevent_poll(sc->sc_base.me_evp, events, p));
  671 }
  673 #if NWSMUX > 0
  674 int
wsmouse_mux_open(struct wsevsrc *me, struct wseventvar *evp)
  676 {
  677         struct wsmouse_softc *sc = (struct wsmouse_softc *)me;
  679         if (sc->sc_base.me_evp != NULL)
  680                 return (EBUSY);
  682         return wsmousedoopen(sc, evp);
  683 }
  685 int
wsmouse_mux_close(struct wsevsrc *me)
  687 {
  688         struct wsmouse_softc *sc = (struct wsmouse_softc *)me;
sc->sc_base.me_evp = NULL;
  691         (*sc->sc_accessops->disable)(sc->sc_accesscookie);
  693         return (0);
  694 }
  696 int
wsmouse_add_mux(int unit, struct wsmux_softc *muxsc)
  698 {
  699         struct wsmouse_softc *sc;
  701         if (unit < 0 || unit >= wsmouse_cd.cd_ndevs ||
  702             (sc = wsmouse_cd.cd_devs[unit]) == NULL)
  703                 return (ENXIO);
  705         if (sc->sc_base.me_parent != NULL || sc->sc_base.me_evp != NULL)
  706                 return (EBUSY);
  708         return (wsmux_attach_sc(muxsc, &sc->sc_base));
  709 }
  710 #endif  /* NWSMUX > 0 */