root/dev/wscons/wsmux.c

DEFINITIONS

1. wsmuxattach
2. wsmux_getmux
3. wsmuxopen
4. wsmux_mux_open
5. wsmux_do_open
6. wsmuxclose
7. wsmux_mux_close
8. wsmux_do_close
9. wsmuxread
10. wsmuxioctl
11. wsmux_do_ioctl
12. wsmuxpoll
13. wsmux_add_mux
14. wsmux_create
15. wsmux_attach_sc
16. wsmux_detach_sc
17. wsmux_do_displayioctl
18. wsmux_evsrc_set_display
19. wsmux_set_display

    1 /*      $OpenBSD: wsmux.c,v 1.20 2007/05/14 09:03:34 tedu Exp $ */
    2 /*      $NetBSD: wsmux.c,v 1.37 2005/04/30 03:47:12 augustss Exp $      */
    4 /*
    5  * Copyright (c) 1998, 2005 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * Author: Lennart Augustsson <augustss@carlstedt.se>
    9  *         Carlstedt Research & Technology
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. All advertising materials mentioning features or use of this software
   20  *    must display the following acknowledgement:
   21  *        This product includes software developed by the NetBSD
   22  *        Foundation, Inc. and its contributors.
   23  * 4. Neither the name of The NetBSD Foundation nor the names of its
   24  *    contributors may be used to endorse or promote products derived
   25  *    from this software without specific prior written permission.
   26  *
   27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   37  * POSSIBILITY OF SUCH DAMAGE.
   38  */
   40 #include "wsmux.h"
   41 #include "wsdisplay.h"
   42 #include "wskbd.h"
   43 #include "wsmouse.h"
   45 /*
   46  * wscons mux device.
   47  *
   48  * The mux device is a collection of real mice and keyboards and acts as 
   49  * a merge point for all the events from the different real devices.
   50  */
   52 #include <sys/param.h>
   53 #include <sys/conf.h>
   54 #include <sys/ioctl.h>
   55 #include <sys/fcntl.h>
   56 #include <sys/kernel.h>
   57 #include <sys/malloc.h>
   58 #include <sys/proc.h>
   59 #include <sys/queue.h>
   60 #include <sys/syslog.h>
   61 #include <sys/systm.h>
   62 #include <sys/tty.h>
   63 #include <sys/signalvar.h>
   64 #include <sys/device.h>
   65 #include <sys/poll.h>
   67 #include <dev/wscons/wsconsio.h>
   68 #include <dev/wscons/wsksymdef.h>
   69 #include <dev/wscons/wseventvar.h>
   70 #include <dev/wscons/wscons_callbacks.h>
   71 #include <dev/wscons/wsmuxvar.h>
   73 #ifdef WSMUX_DEBUG
   74 #define DPRINTF(x)      if (wsmuxdebug) printf x
   75 #define DPRINTFN(n,x)   if (wsmuxdebug > (n)) printf x
   76 int     wsmuxdebug = 0;
   77 #else
   78 #define DPRINTF(x)
   79 #define DPRINTFN(n,x)
   80 #endif
   82 /*
   83  * The wsmux pseudo device is used to multiplex events from several wsmouse,
   84  * wskbd, and/or wsmux devices together.
   85  * The devices connected together form a tree with muxes in the interior
   86  * and real devices (mouse and kbd) at the leaves.  The special case of
   87  * a tree with one node (mux or other) is supported as well.
   88  * Only the device at the root of the tree can be opened (if a non-root
   89  * device is opened the subtree rooted at that point is severed from the
   90  * containing tree).  When the root is opened it allocates a wseventvar
   91  * struct which all the nodes in the tree will send their events too.
   92  * An ioctl() performed on the root is propagated to all the nodes.
   93  * There are also ioctl() operations to add and remove nodes from a tree.
   94  */
   96 int     wsmux_mux_open(struct wsevsrc *, struct wseventvar *);
   97 int     wsmux_mux_close(struct wsevsrc *);
   99 void    wsmux_do_open(struct wsmux_softc *, struct wseventvar *);
  101 void    wsmux_do_close(struct wsmux_softc *);
  102 #if NWSDISPLAY > 0
  103 int     wsmux_evsrc_set_display(struct device *, struct device *);
  104 #else
  105 #define wsmux_evsrc_set_display NULL
  106 #endif
  108 int     wsmux_do_displayioctl(struct device *dev, u_long cmd, caddr_t data,
  109             int flag, struct proc *p);
  110 int     wsmux_do_ioctl(struct device *, u_long, caddr_t,int,struct proc *);
  112 int     wsmux_add_mux(int, struct wsmux_softc *);
  114 void    wsmuxattach(int);
  116 struct wssrcops wsmux_srcops = {
WSMUX_MUX,
wsmux_mux_open, wsmux_mux_close, wsmux_do_ioctl, wsmux_do_displayioctl,
wsmux_evsrc_set_display
  120 };
  122 /* From upper level */
  123 void
wsmuxattach(int n)
  125 {
  126 }
  128 /* Keep track of all muxes that have been allocated */
  129 int nwsmux = 0;
  130 struct wsmux_softc **wsmuxdevs = NULL;
  132 /* Return mux n, create if necessary */
  133 struct wsmux_softc *
wsmux_getmux(int n)
  135 {
  136         struct wsmux_softc *sc;
  137         struct wsmux_softc **new, **old;
  138         int i;
  140         /* Make sure there is room for mux n in the table */
  141         if (n >= nwsmux) {
old = wsmuxdevs;
new = (struct wsmux_softc **)
malloc((n + 1) * sizeof (*wsmuxdevs), M_DEVBUF, M_NOWAIT);
  145                 if (new == NULL) {
printf("wsmux_getmux: no memory for mux %d\n", n);
  147                         return (NULL);
  148                 }
  149                 if (old != NULL)
bcopy(old, new, nwsmux * sizeof(*wsmuxdevs));
  151                 for (i = nwsmux; i < (n + 1); i++)
new[i] = NULL;
wsmuxdevs = new;
nwsmux = n + 1;
  155                 if (old != NULL)
free(old, M_DEVBUF);
  157         }
sc = wsmuxdevs[n];
  160         if (sc == NULL) {
sc = wsmux_create("wsmux", n);
  162                 if (sc == NULL)
printf("wsmux: attach out of memory\n");
wsmuxdevs[n] = sc;
  165         }
  166         return (sc);
  167 }
  169 /*
  170  * open() of the pseudo device from device table.
  171  */
  172 int
wsmuxopen(dev_t dev, int flags, int mode, struct proc *p)
  174 {
  175         struct wsmux_softc *sc;
  176         struct wseventvar *evar;
  177         int unit;
unit = minor(dev);
sc = wsmux_getmux(unit);
  181         if (sc == NULL)
  182                 return (ENXIO);
DPRINTF(("wsmuxopen: %s: sc=%p p=%p\n", sc->sc_base.me_dv.dv_xname, sc, p));
  186         if ((flags & (FREAD | FWRITE)) == FWRITE) {
  187                 /* Not opening for read, only ioctl is available. */
  188                 return (0);
  189         }
  191         if (sc->sc_base.me_parent != NULL) {
  192                 /* Grab the mux out of the greedy hands of the parent mux. */
DPRINTF(("wsmuxopen: detach\n"));
wsmux_detach_sc(&sc->sc_base);
  195         }
  197         if (sc->sc_base.me_evp != NULL)
  198                 /* Already open. */
  199                 return (EBUSY);
evar = &sc->sc_base.me_evar;
wsevent_init(evar);
evar->io = p;
  204 #ifdef WSDISPLAY_COMPAT_RAWKBD
sc->sc_rawkbd = 0;
  206 #endif
wsmux_do_open(sc, evar);
  210         return (0);
  211 }
  213 /*
  214  * Open of a mux via the parent mux.
  215  */
  216 int
wsmux_mux_open(struct wsevsrc *me, struct wseventvar *evar)
  218 {
  219         struct wsmux_softc *sc = (struct wsmux_softc *)me;
  221 #ifdef DIAGNOSTIC
  222         if (sc->sc_base.me_evp != NULL) {
printf("wsmux_mux_open: busy\n");
  224                 return (EBUSY);
  225         }
  226         if (sc->sc_base.me_parent == NULL) {
printf("wsmux_mux_open: no parent\n");
  228                 return (EINVAL);
  229         }
  230 #endif
wsmux_do_open(sc, evar);
  234         return (0);
  235 }
  237 /* Common part of opening a mux. */
  238 void
wsmux_do_open(struct wsmux_softc *sc, struct wseventvar *evar)
  240 {
  241         struct wsevsrc *me;
  242 #ifdef DIAGNOSTIC
  243         int error;
  244 #endif
sc->sc_base.me_evp = evar; /* remember event variable, mark as open */
  248         /* Open all children. */
CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
DPRINTF(("wsmuxopen: %s: m=%p dev=%s\n",
sc->sc_base.me_dv.dv_xname, me, me->me_dv.dv_xname));
  252 #ifdef DIAGNOSTIC
  253                 if (me->me_evp != NULL) {
printf("wsmuxopen: dev already in use\n");
  255                         continue;
  256                 }
  257                 if (me->me_parent != sc) {
printf("wsmux_do_open: bad child=%p\n", me);
  259                         continue;
  260                 }
error = wsevsrc_open(me, evar);
  262                 if (error) {
DPRINTF(("wsmuxopen: open failed %d\n", error));
  264                 }
  265 #else
  266                 /* ignore errors, failing children will not be marked open */
  267                 (void)wsevsrc_open(me, evar);
  268 #endif
  269         }
  270 }
  272 /*
  273  * close() of the pseudo device from device table.
  274  */
  275 int
  276 wsmuxclose(dev_t dev, int flags, int mode, struct proc *p)
  277 {
  278         struct wsmux_softc *sc =
  279             (struct wsmux_softc *)wsmuxdevs[minor(dev)];
  280         struct wseventvar *evar = sc->sc_base.me_evp;
  282         if (evar == NULL)
  283                 /* Not open for read */
  284                 return (0);
wsmux_do_close(sc);
sc->sc_base.me_evp = NULL;
wsevent_fini(evar);
  289         return (0);
  290 }
  292 /*
  293  * Close of a mux via the parent mux.
  294  */
  295 int
wsmux_mux_close(struct wsevsrc *me)
  297 {
me->me_evp = NULL;
wsmux_do_close((struct wsmux_softc *)me);
  300         return (0);
  301 }
  303 /* Common part of closing a mux. */
  304 void
wsmux_do_close(struct wsmux_softc *sc)
  306 {
  307         struct wsevsrc *me;
DPRINTF(("wsmuxclose: %s: sc=%p\n", sc->sc_base.me_dv.dv_xname, sc));
  311         /* Close all the children. */
CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
DPRINTF(("wsmuxclose %s: m=%p dev=%s\n",
sc->sc_base.me_dv.dv_xname, me, me->me_dv.dv_xname));
  315 #ifdef DIAGNOSTIC
  316                 if (me->me_parent != sc) {
printf("wsmuxclose: bad child=%p\n", me);
  318                         continue;
  319                 }
  320 #endif
  321                 (void)wsevsrc_close(me);
me->me_evp = NULL;
  323         }
  324 }
  326 /*
  327  * read() of the pseudo device from device table.
  328  */
  329 int
  330 wsmuxread(dev_t dev, struct uio *uio, int flags)
  331 {
  332         struct wsmux_softc *sc = wsmuxdevs[minor(dev)];
  333         struct wseventvar *evar;
  334         int error;
evar = sc->sc_base.me_evp;
  337         if (evar == NULL) {
  338 #ifdef DIAGNOSTIC
  339                 /* XXX can we get here? */
printf("wsmuxread: not open\n");
  341 #endif
  342                 return (EINVAL);
  343         }
DPRINTFN(5,("wsmuxread: %s event read evar=%p\n",
sc->sc_base.me_dv.dv_xname, evar));
error = wsevent_read(evar, uio, flags);
DPRINTFN(5,("wsmuxread: %s event read ==> error=%d\n",
sc->sc_base.me_dv.dv_xname, error));
  350         return (error);
  351 }
  353 /*
  354  * ioctl of the pseudo device from device table.
  355  */
  356 int
  357 wsmuxioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
  358 {
  359         return wsmux_do_ioctl(&wsmuxdevs[minor(dev)]->sc_base.me_dv, cmd, data, flag, p);
  360 }
  362 /*
  363  * ioctl of a mux via the parent mux, continuation of wsmuxioctl().
  364  */
  365 int
wsmux_do_ioctl(struct device *dv, u_long cmd, caddr_t data, int flag,
  367     struct proc *p)
  368 {
  369         struct wsmux_softc *sc = (struct wsmux_softc *)dv;
  370         struct wsevsrc *me;
  371         int error, ok;
  372         int s, put, get, n;
  373         struct wseventvar *evar;
  374         struct wscons_event *ev;
  375         struct wsmux_device_list *l;
DPRINTF(("wsmux_do_ioctl: %s: enter sc=%p, cmd=%08lx\n",
sc->sc_base.me_dv.dv_xname, sc, cmd));
  380         switch (cmd) {
  381         case WSMUXIO_INJECTEVENT:
  382         case WSMUXIO_ADD_DEVICE:
  383         case WSMUXIO_REMOVE_DEVICE:
  384 #ifdef WSDISPLAY_COMPAT_RAWKBD
  385         case WSKBDIO_SETMODE:
  386 #endif
  387                 if ((flag & FWRITE) == 0)
  388                         return (EACCES);
  389         }
  391         switch (cmd) {
  392         case WSMUXIO_INJECTEVENT:
  393                 /* Inject an event, e.g., from moused. */
DPRINTF(("%s: inject\n", sc->sc_base.me_dv.dv_xname));
evar = sc->sc_base.me_evp;
  396                 if (evar == NULL) {
  397                         /* No event sink, so ignore it. */
DPRINTF(("wsmux_do_ioctl: event ignored\n"));
  399                         return (0);
  400                 }
s = spltty();
get = evar->get;
put = evar->put;
ev = &evar->q[put];
  406                 if (++put % WSEVENT_QSIZE == get) {
put--;
splx(s);
  409                         return (ENOSPC);
  410                 }
  411                 if (put >= WSEVENT_QSIZE)
put = 0;
  413                 *ev = *(struct wscons_event *)data;
nanotime(&ev->time);
evar->put = put;
WSEVENT_WAKEUP(evar);
splx(s);
  418                 return (0);
  419         case WSMUXIO_ADD_DEVICE:
  420 #define d ((struct wsmux_device *)data)
DPRINTF(("%s: add type=%d, no=%d\n", sc->sc_base.me_dv.dv_xname,
d->type, d->idx));
  423                 switch (d->type) {
  424 #if NWSMOUSE > 0
  425                 case WSMUX_MOUSE:
  426                         return (wsmouse_add_mux(d->idx, sc));
  427 #endif
  428 #if NWSKBD > 0
  429                 case WSMUX_KBD:
  430                         return (wskbd_add_mux(d->idx, sc));
  431 #endif
  432                 case WSMUX_MUX:
  433                         return (wsmux_add_mux(d->idx, sc));
  434                 default:
  435                         return (EINVAL);
  436                 }
  437         case WSMUXIO_REMOVE_DEVICE:
DPRINTF(("%s: rem type=%d, no=%d\n", sc->sc_base.me_dv.dv_xname,
d->type, d->idx));
  440                 /* Locate the device */
CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
  442                         if (me->me_ops->type == d->type &&
me->me_dv.dv_unit == d->idx) {
DPRINTF(("wsmux_do_ioctl: detach\n"));
wsmux_detach_sc(me);
  446                                 return (0);
  447                         }
  448                 }
  449                 return (EINVAL);
  450 #undef d
  452         case WSMUXIO_LIST_DEVICES:
DPRINTF(("%s: list\n", sc->sc_base.me_dv.dv_xname));
l = (struct wsmux_device_list *)data;
n = 0;
CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
  457                         if (n >= WSMUX_MAXDEV)
  458                                 break;
l->devices[n].type = me->me_ops->type;
l->devices[n].idx = me->me_dv.dv_unit;
n++;
  462                 }
l->ndevices = n;
  464                 return (0);
  465 #ifdef WSDISPLAY_COMPAT_RAWKBD
  466         case WSKBDIO_SETMODE:
sc->sc_rawkbd = *(int *)data;
DPRINTF(("wsmux_do_ioctl: save rawkbd = %d\n", sc->sc_rawkbd));
  469                 break;
  470 #endif
  471         case FIONBIO:
DPRINTF(("%s: FIONBIO\n", sc->sc_base.me_dv.dv_xname));
  473                 return (0);
  475         case FIOASYNC:
DPRINTF(("%s: FIOASYNC\n", sc->sc_base.me_dv.dv_xname));
evar = sc->sc_base.me_evp;
  478                 if (evar == NULL)
  479                         return (EINVAL);
evar->async = *(int *)data != 0;
  481                 return (0);
  482         case FIOSETOWN:
DPRINTF(("%s: FIOSETOWN\n", sc->sc_base.me_dv.dv_xname));
evar = sc->sc_base.me_evp;
  485                 if (evar == NULL)
  486                         return (EINVAL);
  487                 if (-*(int *)data != evar->io->p_pgid
  488                     && *(int *)data != evar->io->p_pid)
  489                         return (EPERM);
  490                 return (0);
  491         case TIOCSPGRP:
DPRINTF(("%s: TIOCSPGRP\n", sc->sc_base.me_dv.dv_xname));
evar = sc->sc_base.me_evp;
  494                 if (evar == NULL)
  495                         return (EINVAL);
  496                 if (*(int *)data != evar->io->p_pgid)
  497                         return (EPERM);
  498                 return (0);
  499         default:
DPRINTF(("%s: unknown\n", sc->sc_base.me_dv.dv_xname));
  501                 break;
  502         }
  504         if (sc->sc_base.me_evp == NULL
  505 #if NWSDISPLAY > 0
  506             && sc->sc_displaydv == NULL
  507 #endif
  508             )
  509                 return (EACCES);
  511         /* Return 0 if any of the ioctl() succeeds, otherwise the last error */
error = 0;
ok = 0;
CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
  515 #ifdef DIAGNOSTIC
  516                 /* XXX check evp? */
  517                 if (me->me_parent != sc) {
printf("wsmux_do_ioctl: bad child %p\n", me);
  519                         continue;
  520                 }
  521 #endif
error = wsevsrc_ioctl(me, cmd, data, flag, p);
DPRINTF(("wsmux_do_ioctl: %s: me=%p dev=%s ==> %d\n",
sc->sc_base.me_dv.dv_xname, me, me->me_dv.dv_xname,
error));
  526                 if (!error)
ok = 1;
  528         }
  529         if (ok) {
error = 0;
  531                 if (cmd == WSKBDIO_SETENCODING) {
sc->sc_kbd_layout = *((kbd_t *)data);
  533                 }
  535         }
  537         return (error);
  538 }
  540 /*
  541  * poll() of the pseudo device from device table.
  542  */
  543 int
  544 wsmuxpoll(dev_t dev, int events, struct proc *p)
  545 {
  546         struct wsmux_softc *sc = wsmuxdevs[minor(dev)];
  548         if (sc->sc_base.me_evp == NULL) {
  549 #ifdef DIAGNOSTIC
printf("wsmuxpoll: not open\n");
  551 #endif
  552                 return (POLLERR);
  553         }
  555         return (wsevent_poll(sc->sc_base.me_evp, events, p));
  556 }
  558 /*
  559  * Add mux unit as a child to muxsc.
  560  */
  561 int
wsmux_add_mux(int unit, struct wsmux_softc *muxsc)
  563 {
  564         struct wsmux_softc *sc, *m;
sc = wsmux_getmux(unit);
  567         if (sc == NULL)
  568                 return (ENXIO);
DPRINTF(("wsmux_add_mux: %s(%p) to %s(%p)\n",
sc->sc_base.me_dv.dv_xname, sc, muxsc->sc_base.me_dv.dv_xname,
muxsc));
  574         if (sc->sc_base.me_parent != NULL || sc->sc_base.me_evp != NULL)
  575                 return (EBUSY);
  577         /* The mux we are adding must not be an ancestor of itself. */
  578         for (m = muxsc; m != NULL ; m = m->sc_base.me_parent)
  579                 if (m == sc)
  580                         return (EINVAL);
  582         return (wsmux_attach_sc(muxsc, &sc->sc_base));
  583 }
  585 /* Create a new mux softc. */
  586 struct wsmux_softc *
wsmux_create(const char *name, int unit)
  588 {
  589         struct wsmux_softc *sc;
DPRINTF(("wsmux_create: allocating\n"));
sc = malloc(sizeof *sc, M_DEVBUF, M_NOWAIT);
  593         if (sc == NULL)
  594                 return (NULL);
bzero(sc, sizeof *sc);
CIRCLEQ_INIT(&sc->sc_cld);
snprintf(sc->sc_base.me_dv.dv_xname, sizeof sc->sc_base.me_dv.dv_xname,
  598                  "%s%d", name, unit);
sc->sc_base.me_dv.dv_unit = unit;
sc->sc_base.me_ops = &wsmux_srcops;
sc->sc_kbd_layout = KB_NONE;
  602         return (sc);
  603 }
  605 /* Attach me as a child to sc. */
  606 int
wsmux_attach_sc(struct wsmux_softc *sc, struct wsevsrc *me)
  608 {
  609         int error;
  611         if (sc == NULL)
  612                 return (EINVAL);
DPRINTF(("wsmux_attach_sc: %s(%p): type=%d\n",
sc->sc_base.me_dv.dv_xname, sc, me->me_ops->type));
  617 #ifdef DIAGNOSTIC
  618         if (me->me_parent != NULL) {
printf("wsmux_attach_sc: busy\n");
  620                 return (EBUSY);
  621         }
  622 #endif
me->me_parent = sc;
CIRCLEQ_INSERT_TAIL(&sc->sc_cld, me, me_next);
error = 0;
  627 #if NWSDISPLAY > 0
  628         if (sc->sc_displaydv != NULL) {
  629                 /* This is a display mux, so attach the new device to it. */
DPRINTF(("wsmux_attach_sc: %s: set display %p\n",
sc->sc_base.me_dv.dv_xname, sc->sc_displaydv));
  632                 if (me->me_ops->dsetdisplay != NULL) {
error = wsevsrc_set_display(me, sc->sc_displaydv);
  634                         /* Ignore that the console already has a display. */
  635                         if (error == EBUSY)
error = 0;
  637                         if (!error) {
  638 #ifdef WSDISPLAY_COMPAT_RAWKBD
DPRINTF(("wsmux_attach_sc: %s set rawkbd=%d\n",
me->me_dv.dv_xname, sc->sc_rawkbd));
  641                                 (void)wsevsrc_ioctl(me, WSKBDIO_SETMODE,
  642                                                     &sc->sc_rawkbd, FWRITE, 0);
  643 #endif
  644                                 if (sc->sc_kbd_layout != KB_NONE)
  645                                         (void)wsevsrc_ioctl(me,
WSKBDIO_SETENCODING,
  647                                             &sc->sc_kbd_layout, FWRITE, 0);
  648                         }
  649                 }
  650         }
  651 #endif
  652         if (sc->sc_base.me_evp != NULL) {
  653                 /* Mux is open, so open the new subdevice */
DPRINTF(("wsmux_attach_sc: %s: calling open of %s\n",
sc->sc_base.me_dv.dv_xname, me->me_dv.dv_xname));
error = wsevsrc_open(me, sc->sc_base.me_evp);
  657         } else {
DPRINTF(("wsmux_attach_sc: %s not open\n",
sc->sc_base.me_dv.dv_xname));
  660         }
  662         if (error) {
me->me_parent = NULL;
CIRCLEQ_REMOVE(&sc->sc_cld, me, me_next);
  665         }
DPRINTF(("wsmux_attach_sc: %s(%p) done, error=%d\n",
sc->sc_base.me_dv.dv_xname, sc, error));
  669         return (error);
  670 }
  672 /* Remove me from the parent. */
  673 void
wsmux_detach_sc(struct wsevsrc *me)
  675 {
  676         struct wsmux_softc *sc = me->me_parent;
DPRINTF(("wsmux_detach_sc: %s(%p) parent=%p\n",
me->me_dv.dv_xname, me, sc));
  681 #ifdef DIAGNOSTIC
  682         if (sc == NULL) {
printf("wsmux_detach_sc: %s has no parent\n",
me->me_dv.dv_xname);
  685                 return;
  686         }
  687 #endif
  689 #if NWSDISPLAY > 0
  690         if (sc->sc_displaydv != NULL) {
  691                 if (me->me_ops->dsetdisplay != NULL)
  692                         /* ignore error, there's nothing we can do */
  693                         (void)wsevsrc_set_display(me, NULL);
  694         } else
  695 #endif
  696                 if (me->me_evp != NULL) {
DPRINTF(("wsmux_detach_sc: close\n"));
  698                 /* mux device is open, so close multiplexee */
  699                 (void)wsevsrc_close(me);
  700         }
CIRCLEQ_REMOVE(&sc->sc_cld, me, me_next);
me->me_parent = NULL;
DPRINTF(("wsmux_detach_sc: done sc=%p\n", sc));
  706 }
  708 /*
  709  * Display ioctl() of a mux via the parent mux.
  710  */
  711 int
wsmux_do_displayioctl(struct device *dv, u_long cmd, caddr_t data, int flag,
  713     struct proc *p)
  714 {
  715         struct wsmux_softc *sc = (struct wsmux_softc *)dv;
  716         struct wsevsrc *me;
  717         int error, ok;
DPRINTF(("wsmux_displayioctl: %s: sc=%p, cmd=%08lx\n",
sc->sc_base.me_dv.dv_xname, sc, cmd));
  722 #ifdef WSDISPLAY_COMPAT_RAWKBD
  723         if (cmd == WSKBDIO_SETMODE) {
sc->sc_rawkbd = *(int *)data;
DPRINTF(("wsmux_displayioctl: rawkbd = %d\n", sc->sc_rawkbd));
  726         }
  727 #endif
  729         /*
  730          * Return 0 if any of the ioctl() succeeds, otherwise the last error.
  731          * Return -1 if no mux component accepts the ioctl.
  732          */
error = -1;
ok = 0;
CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
DPRINTF(("wsmux_displayioctl: me=%p\n", me));
  737 #ifdef DIAGNOSTIC
  738                 if (me->me_parent != sc) {
printf("wsmux_displayioctl: bad child %p\n", me);
  740                         continue;
  741                 }
  742 #endif
  743                 if (me->me_ops->ddispioctl != NULL) {
error = wsevsrc_display_ioctl(me, cmd, data, flag, p);
DPRINTF(("wsmux_displayioctl: me=%p dev=%s ==> %d\n",
me, me->me_dv.dv_xname, error));
  747                         if (!error)
ok = 1;
  749                 }
  750         }
  751         if (ok)
error = 0;
  754         return (error);
  755 }
  757 #if NWSDISPLAY > 0
  758 /*
  759  * Set display of a mux via the parent mux.
  760  */
  761 int
wsmux_evsrc_set_display(struct device *dv, struct device *displaydv)
  763 {
  764         struct wsmux_softc *sc = (struct wsmux_softc *)dv;
DPRINTF(("wsmux_set_display: %s: displaydv=%p\n",
sc->sc_base.me_dv.dv_xname, displaydv));
  769         if (displaydv != NULL) {
  770                 if (sc->sc_displaydv != NULL)
  771                         return (EBUSY);
  772         } else {
  773                 if (sc->sc_displaydv == NULL)
  774                         return (ENXIO);
  775         }
  777         return wsmux_set_display(sc, displaydv);
  778 }
  780 int
wsmux_set_display(struct wsmux_softc *sc, struct device *displaydv)
  782 {
  783         struct device *odisplaydv;
  784         struct wsevsrc *me;
  785         struct wsmux_softc *nsc = displaydv ? sc : NULL;
  786         int error, ok;
odisplaydv = sc->sc_displaydv;
sc->sc_displaydv = displaydv;
  791         if (displaydv) {
DPRINTF(("%s: connecting to %s\n",
sc->sc_base.me_dv.dv_xname, displaydv->dv_xname));
  794         }
ok = 0;
error = 0;
CIRCLEQ_FOREACH(me, &sc->sc_cld,me_next) {
  798 #ifdef DIAGNOSTIC
  799                 if (me->me_parent != sc) {
printf("wsmux_set_display: bad child parent %p\n", me);
  801                         continue;
  802                 }
  803 #endif
  804                 if (me->me_ops->dsetdisplay != NULL) {
error = wsevsrc_set_display(me, nsc->sc_displaydv);
DPRINTF(("wsmux_set_display: m=%p dev=%s error=%d\n",
me, me->me_dv.dv_xname, error));
  808                         if (!error) {
ok = 1;
  810 #ifdef WSDISPLAY_COMPAT_RAWKBD
DPRINTF(("wsmux_set_display: %s set rawkbd=%d\n"
  812 ,
me->me_dv.dv_xname, sc->sc_rawkbd));
  814                                 (void)wsevsrc_ioctl(me, WSKBDIO_SETMODE,
  815                                                     &sc->sc_rawkbd, FWRITE, 0);
  816 #endif
  817                         }
  818                 }
  819         }
  820         if (ok)
error = 0;
  823         if (displaydv == NULL) {
DPRINTF(("%s: disconnecting from %s\n",
sc->sc_base.me_dv.dv_xname, odisplaydv->dv_xname));
  826         }
  828         return (error);
  829 }
  830 #endif /* NWSDISPLAY > 0 */