1/* $NetBSD: wsmux.c,v 1.61 2016/07/07 06:55:42 msaitoh Exp $ */
2
3/*
4 * Copyright (c) 1998, 2005 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Author: Lennart Augustsson <lennart@augustsson.net>
8 * Carlstedt Research & Technology
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/*
33 * wscons mux device.
34 *
35 * The mux device is a collection of real mice and keyboards and acts as
36 * a merge point for all the events from the different real devices.
37 */
38
39#include <sys/cdefs.h>
40__KERNEL_RCSID(0, "$NetBSD: wsmux.c,v 1.61 2016/07/07 06:55:42 msaitoh Exp $");
41
42#ifdef _KERNEL_OPT
43#include "opt_compat_netbsd.h"
44#include "opt_modular.h"
45#endif
46
47#include "wsdisplay.h"
48#include "wsmux.h"
49#include "wskbd.h"
50#include "wsmouse.h"
51
52#include <sys/param.h>
53#include <sys/conf.h>
54#include <sys/ioctl.h>
55#include <sys/poll.h>
56#include <sys/fcntl.h>
57#include <sys/kernel.h>
58#include <sys/malloc.h>
59#include <sys/proc.h>
60#include <sys/queue.h>
61#include <sys/syslog.h>
62#include <sys/systm.h>
63#include <sys/tty.h>
64#include <sys/signalvar.h>
65#include <sys/device.h>
66
67#include "opt_wsdisplay_compat.h"
68
69#include <dev/wscons/wsconsio.h>
70#include <dev/wscons/wsksymdef.h>
71#include <dev/wscons/wseventvar.h>
72#include <dev/wscons/wscons_callbacks.h>
73#include <dev/wscons/wsmuxvar.h>
74
75#include "ioconf.h"
76
77#ifdef WSMUX_DEBUG
78#define DPRINTF(x) if (wsmuxdebug) printf x
79#define DPRINTFN(n,x) if (wsmuxdebug > (n)) printf x
80int wsmuxdebug = 0;
81#else
82#define DPRINTF(x)
83#define DPRINTFN(n,x)
84#endif
85
86/*
87 * The wsmux pseudo device is used to multiplex events from several wsmouse,
88 * wskbd, and/or wsmux devices together.
89 * The devices connected together form a tree with muxes in the interior
90 * and real devices (mouse and kbd) at the leaves. The special case of
91 * a tree with one node (mux or other) is supported as well.
92 * Only the device at the root of the tree can be opened (if a non-root
93 * device is opened the subtree rooted at that point is severed from the
94 * containing tree). When the root is opened it allocates a wseventvar
95 * struct which all the nodes in the tree will send their events too.
96 * An ioctl() performed on the root is propagated to all the nodes.
97 * There are also ioctl() operations to add and remove nodes from a tree.
98 */
99
100static int wsmux_mux_open(struct wsevsrc *, struct wseventvar *);
101static int wsmux_mux_close(struct wsevsrc *);
102
103static void wsmux_do_open(struct wsmux_softc *, struct wseventvar *);
104
105static void wsmux_do_close(struct wsmux_softc *);
106#if NWSDISPLAY > 0
107static int wsmux_evsrc_set_display(device_t, struct wsevsrc *);
108#else
109#define wsmux_evsrc_set_display NULL
110#endif
111
112static int wsmux_do_displayioctl(device_t dev, u_long cmd,
113 void *data, int flag, struct lwp *l);
114static int wsmux_do_ioctl(device_t, u_long, void *,int,struct lwp *);
115
116static int wsmux_add_mux(int, struct wsmux_softc *);
117
118#define WSMUXDEV(n) ((n) & 0x7f)
119#define WSMUXCTL(n) ((n) & 0x80)
120
121dev_type_open(wsmuxopen);
122dev_type_close(wsmuxclose);
123dev_type_read(wsmuxread);
124dev_type_ioctl(wsmuxioctl);
125dev_type_poll(wsmuxpoll);
126dev_type_kqfilter(wsmuxkqfilter);
127
128const struct cdevsw wsmux_cdevsw = {
129 .d_open = wsmuxopen,
130 .d_close = wsmuxclose,
131 .d_read = wsmuxread,
132 .d_write = nowrite,
133 .d_ioctl = wsmuxioctl,
134 .d_stop = nostop,
135 .d_tty = notty,
136 .d_poll = wsmuxpoll,
137 .d_mmap = nommap,
138 .d_kqfilter = wsmuxkqfilter,
139 .d_discard = nodiscard,
140 .d_flag = D_OTHER
141};
142
143struct wssrcops wsmux_srcops = {
144 WSMUX_MUX,
145 wsmux_mux_open, wsmux_mux_close, wsmux_do_ioctl, wsmux_do_displayioctl,
146 wsmux_evsrc_set_display
147};
148
149/* From upper level */
150void
151wsmuxattach(int n)
152{
153}
154
155/* Keep track of all muxes that have been allocated */
156static struct wsmux_softc **wsmuxdevs = NULL;
157static int nwsmux = 0;
158
159/* Return mux n, create if necessary */
160struct wsmux_softc *
161wsmux_getmux(int n)
162{
163 struct wsmux_softc *sc;
164
165 n = WSMUXDEV(n); /* limit range */
166
167 /* Make sure there is room for mux n in the table */
168 if (n >= nwsmux) {
169 void *new;
170
171 new = realloc(wsmuxdevs, (n + 1) * sizeof(*wsmuxdevs),
172 M_DEVBUF, M_ZERO | M_NOWAIT);
173 if (new == NULL) {
174 printf("wsmux_getmux: no memory for mux %d\n", n);
175 return NULL;
176 }
177 wsmuxdevs = new;
178 nwsmux = n + 1;
179 }
180
181 sc = wsmuxdevs[n];
182 if (sc == NULL) {
183 sc = wsmux_create("wsmux", n);
184 if (sc == NULL)
185 printf("wsmux: attach out of memory\n");
186 wsmuxdevs[n] = sc;
187 }
188 return (sc);
189}
190
191/*
192 * open() of the pseudo device from device table.
193 */
194int
195wsmuxopen(dev_t dev, int flags, int mode, struct lwp *l)
196{
197 struct wsmux_softc *sc;
198 struct wseventvar *evar;
199 int minr, unit;
200
201 minr = minor(dev);
202 unit = WSMUXDEV(minr);
203 sc = wsmux_getmux(unit);
204 if (sc == NULL)
205 return (ENXIO);
206
207 DPRINTF(("wsmuxopen: %s: sc=%p l=%p\n",
208 device_xname(sc->sc_base.me_dv), sc, l));
209
210 if (WSMUXCTL(minr)) {
211 /* This is the control device which does not allow reads. */
212 if (flags & FREAD)
213 return (EINVAL);
214 return (0);
215 }
216 if ((flags & (FREAD | FWRITE)) == FWRITE)
217 /* Allow write only open */
218 return (0);
219
220 if (sc->sc_base.me_parent != NULL) {
221 /* Grab the mux out of the greedy hands of the parent mux. */
222 DPRINTF(("wsmuxopen: detach\n"));
223 wsmux_detach_sc(&sc->sc_base);
224 }
225
226 if (sc->sc_base.me_evp != NULL)
227 /* Already open. */
228 return (EBUSY);
229
230 evar = &sc->sc_base.me_evar;
231 wsevent_init(evar, l->l_proc);
232#ifdef WSDISPLAY_COMPAT_RAWKBD
233 sc->sc_rawkbd = 0;
234#endif
235
236 wsmux_do_open(sc, evar);
237
238 return (0);
239}
240
241/*
242 * Open of a mux via the parent mux.
243 */
244int
245wsmux_mux_open(struct wsevsrc *me, struct wseventvar *evar)
246{
247 struct wsmux_softc *sc = (struct wsmux_softc *)me;
248
249#ifdef DIAGNOSTIC
250 if (sc->sc_base.me_evp != NULL) {
251 printf("wsmux_mux_open: busy\n");
252 return (EBUSY);
253 }
254 if (sc->sc_base.me_parent == NULL) {
255 printf("wsmux_mux_open: no parent\n");
256 return (EINVAL);
257 }
258#endif
259
260 wsmux_do_open(sc, evar);
261
262 return (0);
263}
264
265/* Common part of opening a mux. */
266void
267wsmux_do_open(struct wsmux_softc *sc, struct wseventvar *evar)
268{
269 struct wsevsrc *me;
270
271 sc->sc_base.me_evp = evar; /* remember event variable, mark as open */
272
273 /* Open all children. */
274 TAILQ_FOREACH(me, &sc->sc_cld, me_next) {
275 DPRINTF(("wsmuxopen: %s: m=%p dev=%s\n",
276 device_xname(sc->sc_base.me_dv), me,
277 device_xname(me->me_dv)));
278#ifdef DIAGNOSTIC
279 if (me->me_evp != NULL) {
280 printf("wsmuxopen: dev already in use\n");
281 continue;
282 }
283 if (me->me_parent != sc) {
284 printf("wsmux_do_open: bad child=%p\n", me);
285 continue;
286 }
287 {
288 int error = wsevsrc_open(me, evar);
289 if (error) {
290 DPRINTF(("wsmuxopen: open failed %d\n", error));
291 }
292 }
293#else
294 /* ignore errors, failing children will not be marked open */
295 (void)wsevsrc_open(me, evar);
296#endif
297 }
298}
299
300/*
301 * close() of the pseudo device from device table.
302 */
303int
304wsmuxclose(dev_t dev, int flags, int mode,
305 struct lwp *l)
306{
307 int minr = minor(dev);
308 struct wsmux_softc *sc = wsmuxdevs[WSMUXDEV(minr)];
309 struct wseventvar *evar = sc->sc_base.me_evp;
310
311 if (WSMUXCTL(minr))
312 /* control device */
313 return (0);
314 if (evar == NULL)
315 /* Not open for read */
316 return (0);
317
318 wsmux_do_close(sc);
319 sc->sc_base.me_evp = NULL;
320 wsevent_fini(evar);
321 return (0);
322}
323
324/*
325 * Close of a mux via the parent mux.
326 */
327int
328wsmux_mux_close(struct wsevsrc *me)
329{
330 me->me_evp = NULL;
331 wsmux_do_close((struct wsmux_softc *)me);
332 return (0);
333}
334
335/* Common part of closing a mux. */
336void
337wsmux_do_close(struct wsmux_softc *sc)
338{
339 struct wsevsrc *me;
340
341 DPRINTF(("wsmuxclose: %s: sc=%p\n",
342 device_xname(sc->sc_base.me_dv), sc));
343
344 /* Close all the children. */
345 TAILQ_FOREACH(me, &sc->sc_cld, me_next) {
346 DPRINTF(("wsmuxclose %s: m=%p dev=%s\n",
347 device_xname(sc->sc_base.me_dv), me,
348 device_xname(me->me_dv)));
349#ifdef DIAGNOSTIC
350 if (me->me_parent != sc) {
351 printf("wsmuxclose: bad child=%p\n", me);
352 continue;
353 }
354#endif
355 (void)wsevsrc_close(me);
356 me->me_evp = NULL;
357 }
358}
359
360/*
361 * read() of the pseudo device from device table.
362 */
363int
364wsmuxread(dev_t dev, struct uio *uio, int flags)
365{
366 int minr = minor(dev);
367 struct wsmux_softc *sc = wsmuxdevs[WSMUXDEV(minr)];
368 struct wseventvar *evar;
369 int error;
370
371 if (WSMUXCTL(minr)) {
372 /* control device */
373 return (EINVAL);
374 }
375
376 evar = sc->sc_base.me_evp;
377 if (evar == NULL) {
378#ifdef DIAGNOSTIC
379 /* XXX can we get here? */
380 printf("wsmuxread: not open\n");
381#endif
382 return (EINVAL);
383 }
384
385 DPRINTFN(5,("wsmuxread: %s event read evar=%p\n",
386 device_xname(sc->sc_base.me_dv), evar));
387 error = wsevent_read(evar, uio, flags);
388 DPRINTFN(5,("wsmuxread: %s event read ==> error=%d\n",
389 device_xname(sc->sc_base.me_dv), error));
390 return (error);
391}
392
393/*
394 * ioctl of the pseudo device from device table.
395 */
396int
397wsmuxioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
398{
399 int u = WSMUXDEV(minor(dev));
400
401 return wsmux_do_ioctl(wsmuxdevs[u]->sc_base.me_dv, cmd, data, flag, l);
402}
403
404/*
405 * ioctl of a mux via the parent mux, continuation of wsmuxioctl().
406 */
407int
408wsmux_do_ioctl(device_t dv, u_long cmd, void *data, int flag,
409 struct lwp *lwp)
410{
411 struct wsmux_softc *sc = device_private(dv);
412 struct wsevsrc *me;
413 int error, ok;
414 int s, n;
415 struct wseventvar *evar;
416 struct wscons_event event;
417 struct wsmux_device_list *l;
418
419 DPRINTF(("wsmux_do_ioctl: %s: enter sc=%p, cmd=%08lx\n",
420 device_xname(sc->sc_base.me_dv), sc, cmd));
421
422 switch (cmd) {
423#if defined(COMPAT_50) || defined(MODULAR)
424 case WSMUXIO_OINJECTEVENT:
425#endif /* defined(COMPAT_50) || defined(MODULAR) */
426 case WSMUXIO_INJECTEVENT:
427 /* Inject an event, e.g., from moused. */
428 DPRINTF(("%s: inject\n", device_xname(sc->sc_base.me_dv)));
429
430 evar = sc->sc_base.me_evp;
431 if (evar == NULL) {
432 /* No event sink, so ignore it. */
433 DPRINTF(("wsmux_do_ioctl: event ignored\n"));
434 return (0);
435 }
436
437 s = spltty();
438 event.type = ((struct wscons_event *)data)->type;
439 event.value = ((struct wscons_event *)data)->value;
440 error = wsevent_inject(evar, &event, 1);
441 splx(s);
442
443 return error;
444 case WSMUXIO_ADD_DEVICE:
445#define d ((struct wsmux_device *)data)
446 DPRINTF(("%s: add type=%d, no=%d\n",
447 device_xname(sc->sc_base.me_dv), d->type, d->idx));
448 switch (d->type) {
449#if NWSMOUSE > 0
450 case WSMUX_MOUSE:
451 return (wsmouse_add_mux(d->idx, sc));
452#endif
453#if NWSKBD > 0
454 case WSMUX_KBD:
455 return (wskbd_add_mux(d->idx, sc));
456#endif
457 case WSMUX_MUX:
458 return (wsmux_add_mux(d->idx, sc));
459 default:
460 return (EINVAL);
461 }
462 case WSMUXIO_REMOVE_DEVICE:
463 DPRINTF(("%s: rem type=%d, no=%d\n",
464 device_xname(sc->sc_base.me_dv), d->type, d->idx));
465 /* Locate the device */
466 TAILQ_FOREACH(me, &sc->sc_cld, me_next) {
467 if (me->me_ops->type == d->type &&
468 device_unit(me->me_dv) == d->idx) {
469 DPRINTF(("wsmux_do_ioctl: detach\n"));
470 wsmux_detach_sc(me);
471 return (0);
472 }
473 }
474 return (EINVAL);
475#undef d
476
477 case WSMUXIO_LIST_DEVICES:
478 DPRINTF(("%s: list\n", device_xname(sc->sc_base.me_dv)));
479 l = (struct wsmux_device_list *)data;
480 n = 0;
481 TAILQ_FOREACH(me, &sc->sc_cld, me_next) {
482 if (n >= WSMUX_MAXDEV)
483 break;
484 l->devices[n].type = me->me_ops->type;
485 l->devices[n].idx = device_unit(me->me_dv);
486 n++;
487 }
488 l->ndevices = n;
489 return (0);
490#ifdef WSDISPLAY_COMPAT_RAWKBD
491 case WSKBDIO_SETMODE:
492 sc->sc_rawkbd = *(int *)data;
493 DPRINTF(("wsmux_do_ioctl: save rawkbd = %d\n", sc->sc_rawkbd));
494 break;
495#endif
496
497 case WSKBDIO_SETVERSION:
498 case WSMOUSEIO_SETVERSION:
499 case WSDISPLAYIO_SETVERSION:
500 DPRINTF(("%s: WSxxxIO_SETVERSION\n",
501 device_xname(sc->sc_base.me_dv)));
502 evar = sc->sc_base.me_evp;
503 if (evar == NULL)
504 return (EINVAL);
505 return wsevent_setversion(evar, *(int *)data);
506
507 case FIONBIO:
508 DPRINTF(("%s: FIONBIO\n", device_xname(sc->sc_base.me_dv)));
509 return (0);
510
511 case FIOASYNC:
512 DPRINTF(("%s: FIOASYNC\n", device_xname(sc->sc_base.me_dv)));
513 evar = sc->sc_base.me_evp;
514 if (evar == NULL)
515 return (EINVAL);
516 evar->async = *(int *)data != 0;
517 return (0);
518 case FIOSETOWN:
519 DPRINTF(("%s: FIOSETOWN\n", device_xname(sc->sc_base.me_dv)));
520 evar = sc->sc_base.me_evp;
521 if (evar == NULL)
522 return (EINVAL);
523 if (-*(int *)data != evar->io->p_pgid
524 && *(int *)data != evar->io->p_pid)
525 return (EPERM);
526 return (0);
527 case TIOCSPGRP:
528 DPRINTF(("%s: TIOCSPGRP\n", device_xname(sc->sc_base.me_dv)));
529 evar = sc->sc_base.me_evp;
530 if (evar == NULL)
531 return (EINVAL);
532 if (*(int *)data != evar->io->p_pgid)
533 return (EPERM);
534 return (0);
535 default:
536 DPRINTF(("%s: unknown\n", device_xname(sc->sc_base.me_dv)));
537 break;
538 }
539
540 if (sc->sc_base.me_evp == NULL
541#if NWSDISPLAY > 0
542 && sc->sc_base.me_dispdv == NULL
543#endif
544 )
545 return (EACCES);
546
547 /* Return 0 if any of the ioctl() succeeds, otherwise the last error */
548 error = 0;
549 ok = 0;
550 TAILQ_FOREACH(me, &sc->sc_cld, me_next) {
551#ifdef DIAGNOSTIC
552 /* XXX check evp? */
553 if (me->me_parent != sc) {
554 printf("wsmux_do_ioctl: bad child %p\n", me);
555 continue;
556 }
557#endif
558 error = wsevsrc_ioctl(me, cmd, data, flag, lwp);
559 DPRINTF(("wsmux_do_ioctl: %s: me=%p dev=%s ==> %d\n",
560 device_xname(sc->sc_base.me_dv), me,
561 device_xname(me->me_dv), error));
562 if (!error)
563 ok = 1;
564 }
565 if (ok) {
566 error = 0;
567 if (cmd == WSKBDIO_SETENCODING) {
568 sc->sc_kbd_layout = *((kbd_t *)data);
569 }
570
571 }
572
573 return (error);
574}
575
576/*
577 * poll() of the pseudo device from device table.
578 */
579int
580wsmuxpoll(dev_t dev, int events, struct lwp *l)
581{
582 int minr = minor(dev);
583 struct wsmux_softc *sc = wsmuxdevs[WSMUXDEV(minr)];
584
585 if (WSMUXCTL(minr)) {
586 /* control device */
587 return (0);
588 }
589
590 if (sc->sc_base.me_evp == NULL) {
591#ifdef DIAGNOSTIC
592 printf("wsmuxpoll: not open\n");
593#endif
594 return (POLLHUP);
595 }
596
597 return (wsevent_poll(sc->sc_base.me_evp, events, l));
598}
599
600/*
601 * kqfilter() of the pseudo device from device table.
602 */
603int
604wsmuxkqfilter(dev_t dev, struct knote *kn)
605{
606 int minr = minor(dev);
607 struct wsmux_softc *sc = wsmuxdevs[WSMUXDEV(minr)];
608
609 if (WSMUXCTL(minr)) {
610 /* control device */
611 return (1);
612 }
613
614 if (sc->sc_base.me_evp == NULL) {
615#ifdef DIAGNOSTIC
616 printf("wsmuxkqfilter: not open\n");
617#endif
618 return (1);
619 }
620
621 return (wsevent_kqfilter(sc->sc_base.me_evp, kn));
622}
623
624/*
625 * Add mux unit as a child to muxsc.
626 */
627int
628wsmux_add_mux(int unit, struct wsmux_softc *muxsc)
629{
630 struct wsmux_softc *sc, *m;
631
632 sc = wsmux_getmux(unit);
633 if (sc == NULL)
634 return (ENXIO);
635
636 DPRINTF(("wsmux_add_mux: %s(%p) to %s(%p)\n",
637 device_xname(sc->sc_base.me_dv), sc,
638 device_xname(muxsc->sc_base.me_dv), muxsc));
639
640 if (sc->sc_base.me_parent != NULL || sc->sc_base.me_evp != NULL)
641 return (EBUSY);
642
643 /* The mux we are adding must not be an ancestor of itself. */
644 for (m = muxsc; m != NULL ; m = m->sc_base.me_parent)
645 if (m == sc)
646 return (EINVAL);
647
648 return (wsmux_attach_sc(muxsc, &sc->sc_base));
649}
650
651/* Create a new mux softc. */
652struct wsmux_softc *
653wsmux_create(const char *name, int unit)
654{
655 struct wsmux_softc *sc;
656
657 /* XXX This is wrong -- should use autoconfiguraiton framework */
658
659 DPRINTF(("wsmux_create: allocating\n"));
660 sc = malloc(sizeof *sc, M_DEVBUF, M_NOWAIT|M_ZERO);
661 if (sc == NULL)
662 return (NULL);
663 sc->sc_base.me_dv = malloc(sizeof(struct device), M_DEVBUF,
664 M_NOWAIT|M_ZERO);
665 if (sc->sc_base.me_dv == NULL) {
666 free(sc, M_DEVBUF);
667 return NULL;
668 }
669 TAILQ_INIT(&sc->sc_cld);
670 snprintf(sc->sc_base.me_dv->dv_xname,
671 sizeof sc->sc_base.me_dv->dv_xname, "%s%d", name, unit);
672 sc->sc_base.me_dv->dv_private = sc;
673 sc->sc_base.me_dv->dv_unit = unit;
674 sc->sc_base.me_ops = &wsmux_srcops;
675 sc->sc_kbd_layout = KB_NONE;
676 return (sc);
677}
678
679/* Attach me as a child to sc. */
680int
681wsmux_attach_sc(struct wsmux_softc *sc, struct wsevsrc *me)
682{
683 int error;
684
685 if (sc == NULL)
686 return (EINVAL);
687
688 DPRINTF(("wsmux_attach_sc: %s(%p): type=%d\n",
689 device_xname(sc->sc_base.me_dv), sc, me->me_ops->type));
690
691#ifdef DIAGNOSTIC
692 if (me->me_parent != NULL) {
693 printf("wsmux_attach_sc: busy\n");
694 return (EBUSY);
695 }
696#endif
697 me->me_parent = sc;
698 TAILQ_INSERT_TAIL(&sc->sc_cld, me, me_next);
699
700 error = 0;
701#if NWSDISPLAY > 0
702 if (sc->sc_base.me_dispdv != NULL) {
703 /* This is a display mux, so attach the new device to it. */
704 DPRINTF(("wsmux_attach_sc: %s: set display %p\n",
705 device_xname(sc->sc_base.me_dv),
706 sc->sc_base.me_dispdv));
707 if (me->me_ops->dsetdisplay != NULL) {
708 error = wsevsrc_set_display(me, &sc->sc_base);
709 /* Ignore that the console already has a display. */
710 if (error == EBUSY)
711 error = 0;
712 if (!error) {
713#ifdef WSDISPLAY_COMPAT_RAWKBD
714 DPRINTF(("wsmux_attach_sc: %s set rawkbd=%d\n",
715 device_xname(me->me_dv),
716 sc->sc_rawkbd));
717 (void)wsevsrc_ioctl(me, WSKBDIO_SETMODE,
718 &sc->sc_rawkbd, 0, 0);
719#endif
720 if (sc->sc_kbd_layout != KB_NONE)
721 (void)wsevsrc_ioctl(me,
722 WSKBDIO_SETENCODING,
723 &sc->sc_kbd_layout, FWRITE, 0);
724 }
725 }
726 }
727#endif
728 if (sc->sc_base.me_evp != NULL) {
729 /* Mux is open, so open the new subdevice */
730 DPRINTF(("wsmux_attach_sc: %s: calling open of %s\n",
731 device_xname(sc->sc_base.me_dv),
732 device_xname(me->me_dv)));
733 error = wsevsrc_open(me, sc->sc_base.me_evp);
734 } else {
735 DPRINTF(("wsmux_attach_sc: %s not open\n",
736 device_xname(sc->sc_base.me_dv)));
737 }
738
739 if (error) {
740 me->me_parent = NULL;
741 TAILQ_REMOVE(&sc->sc_cld, me, me_next);
742 }
743
744 DPRINTF(("wsmux_attach_sc: %s(%p) done, error=%d\n",
745 device_xname(sc->sc_base.me_dv), sc, error));
746 return (error);
747}
748
749/* Remove me from the parent. */
750void
751wsmux_detach_sc(struct wsevsrc *me)
752{
753 struct wsmux_softc *sc = me->me_parent;
754
755 DPRINTF(("wsmux_detach_sc: %s(%p) parent=%p\n",
756 device_xname(me->me_dv), me, sc));
757
758#ifdef DIAGNOSTIC
759 if (sc == NULL) {
760 printf("wsmux_detach_sc: %s has no parent\n",
761 device_xname(me->me_dv));
762 return;
763 }
764#endif
765
766#if NWSDISPLAY > 0
767 if (sc->sc_base.me_dispdv != NULL) {
768 if (me->me_ops->dsetdisplay != NULL)
769 /* ignore error, there's nothing we can do */
770 (void)wsevsrc_set_display(me, NULL);
771 } else
772#endif
773 if (me->me_evp != NULL) {
774 DPRINTF(("wsmux_detach_sc: close\n"));
775 /* mux device is open, so close multiplexee */
776 (void)wsevsrc_close(me);
777 }
778
779 TAILQ_REMOVE(&sc->sc_cld, me, me_next);
780 me->me_parent = NULL;
781
782 DPRINTF(("wsmux_detach_sc: done sc=%p\n", sc));
783}
784
785/*
786 * Display ioctl() of a mux via the parent mux.
787 */
788int
789wsmux_do_displayioctl(device_t dv, u_long cmd, void *data, int flag,
790 struct lwp *l)
791{
792 struct wsmux_softc *sc = device_private(dv);
793 struct wsevsrc *me;
794 int error, ok;
795
796 DPRINTF(("wsmux_displayioctl: %s: sc=%p, cmd=%08lx\n",
797 device_xname(sc->sc_base.me_dv), sc, cmd));
798
799#ifdef WSDISPLAY_COMPAT_RAWKBD
800 if (cmd == WSKBDIO_SETMODE) {
801 sc->sc_rawkbd = *(int *)data;
802 DPRINTF(("wsmux_displayioctl: rawkbd = %d\n", sc->sc_rawkbd));
803 }
804#endif
805
806 /*
807 * Return 0 if any of the ioctl() succeeds, otherwise the last error.
808 * Return EPASSTHROUGH if no mux component accepts the ioctl.
809 */
810 error = EPASSTHROUGH;
811 ok = 0;
812 TAILQ_FOREACH(me, &sc->sc_cld, me_next) {
813 DPRINTF(("wsmux_displayioctl: me=%p\n", me));
814#ifdef DIAGNOSTIC
815 if (me->me_parent != sc) {
816 printf("wsmux_displayioctl: bad child %p\n", me);
817 continue;
818 }
819#endif
820 if (me->me_ops->ddispioctl != NULL) {
821 error = wsevsrc_display_ioctl(me, cmd, data, flag, l);
822 DPRINTF(("wsmux_displayioctl: me=%p dev=%s ==> %d\n",
823 me, device_xname(me->me_dv), error));
824 if (!error)
825 ok = 1;
826 }
827 }
828 if (ok)
829 error = 0;
830
831 return (error);
832}
833
834#if NWSDISPLAY > 0
835/*
836 * Set display of a mux via the parent mux.
837 */
838int
839wsmux_evsrc_set_display(device_t dv, struct wsevsrc *ame)
840{
841 struct wsmux_softc *muxsc = (struct wsmux_softc *)ame;
842 struct wsmux_softc *sc = device_private(dv);
843 device_t displaydv = muxsc ? muxsc->sc_base.me_dispdv : NULL;
844
845 DPRINTF(("wsmux_set_display: %s: displaydv=%p\n",
846 device_xname(sc->sc_base.me_dv), displaydv));
847
848 if (displaydv != NULL) {
849 if (sc->sc_base.me_dispdv != NULL)
850 return (EBUSY);
851 } else {
852 if (sc->sc_base.me_dispdv == NULL)
853 return (ENXIO);
854 }
855
856 return wsmux_set_display(sc, displaydv);
857}
858
859int
860wsmux_set_display(struct wsmux_softc *sc, device_t displaydv)
861{
862 device_t odisplaydv;
863 struct wsevsrc *me;
864 struct wsmux_softc *nsc = displaydv ? sc : NULL;
865 int error, ok;
866
867 odisplaydv = sc->sc_base.me_dispdv;
868 sc->sc_base.me_dispdv = displaydv;
869
870 if (displaydv)
871 aprint_verbose_dev(sc->sc_base.me_dv, "connecting to %s\n",
872 device_xname(displaydv));
873 ok = 0;
874 error = 0;
875 TAILQ_FOREACH(me, &sc->sc_cld,me_next) {
876#ifdef DIAGNOSTIC
877 if (me->me_parent != sc) {
878 printf("wsmux_set_display: bad child parent %p\n", me);
879 continue;
880 }
881#endif
882 if (me->me_ops->dsetdisplay != NULL) {
883 error = wsevsrc_set_display(me, &nsc->sc_base);
884 DPRINTF(("wsmux_set_display: m=%p dev=%s error=%d\n",
885 me, device_xname(me->me_dv), error));
886 if (!error) {
887 ok = 1;
888#ifdef WSDISPLAY_COMPAT_RAWKBD
889 DPRINTF(("wsmux_set_display: %s set rawkbd=%d\n",
890 device_xname(me->me_dv), sc->sc_rawkbd));
891 (void)wsevsrc_ioctl(me, WSKBDIO_SETMODE,
892 &sc->sc_rawkbd, 0, 0);
893#endif
894 }
895 }
896 }
897 if (ok)
898 error = 0;
899
900 if (displaydv == NULL)
901 aprint_verbose("%s: disconnecting from %s\n",
902 device_xname(sc->sc_base.me_dv),
903 device_xname(odisplaydv));
904
905 return (error);
906}
907#endif /* NWSDISPLAY > 0 */
908