Annotation of sys/dev/wscons/wsmux.c, Revision 1.1.1.1
1.1 nbrk 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 $ */
3:
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: */
39:
40: #include "wsmux.h"
41: #include "wsdisplay.h"
42: #include "wskbd.h"
43: #include "wsmouse.h"
44:
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: */
51:
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>
66:
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>
72:
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
81:
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: */
95:
96: int wsmux_mux_open(struct wsevsrc *, struct wseventvar *);
97: int wsmux_mux_close(struct wsevsrc *);
98:
99: void wsmux_do_open(struct wsmux_softc *, struct wseventvar *);
100:
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
107:
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 *);
111:
112: int wsmux_add_mux(int, struct wsmux_softc *);
113:
114: void wsmuxattach(int);
115:
116: struct wssrcops wsmux_srcops = {
117: WSMUX_MUX,
118: wsmux_mux_open, wsmux_mux_close, wsmux_do_ioctl, wsmux_do_displayioctl,
119: wsmux_evsrc_set_display
120: };
121:
122: /* From upper level */
123: void
124: wsmuxattach(int n)
125: {
126: }
127:
128: /* Keep track of all muxes that have been allocated */
129: int nwsmux = 0;
130: struct wsmux_softc **wsmuxdevs = NULL;
131:
132: /* Return mux n, create if necessary */
133: struct wsmux_softc *
134: wsmux_getmux(int n)
135: {
136: struct wsmux_softc *sc;
137: struct wsmux_softc **new, **old;
138: int i;
139:
140: /* Make sure there is room for mux n in the table */
141: if (n >= nwsmux) {
142: old = wsmuxdevs;
143: new = (struct wsmux_softc **)
144: malloc((n + 1) * sizeof (*wsmuxdevs), M_DEVBUF, M_NOWAIT);
145: if (new == NULL) {
146: printf("wsmux_getmux: no memory for mux %d\n", n);
147: return (NULL);
148: }
149: if (old != NULL)
150: bcopy(old, new, nwsmux * sizeof(*wsmuxdevs));
151: for (i = nwsmux; i < (n + 1); i++)
152: new[i] = NULL;
153: wsmuxdevs = new;
154: nwsmux = n + 1;
155: if (old != NULL)
156: free(old, M_DEVBUF);
157: }
158:
159: sc = wsmuxdevs[n];
160: if (sc == NULL) {
161: sc = wsmux_create("wsmux", n);
162: if (sc == NULL)
163: printf("wsmux: attach out of memory\n");
164: wsmuxdevs[n] = sc;
165: }
166: return (sc);
167: }
168:
169: /*
170: * open() of the pseudo device from device table.
171: */
172: int
173: wsmuxopen(dev_t dev, int flags, int mode, struct proc *p)
174: {
175: struct wsmux_softc *sc;
176: struct wseventvar *evar;
177: int unit;
178:
179: unit = minor(dev);
180: sc = wsmux_getmux(unit);
181: if (sc == NULL)
182: return (ENXIO);
183:
184: DPRINTF(("wsmuxopen: %s: sc=%p p=%p\n", sc->sc_base.me_dv.dv_xname, sc, p));
185:
186: if ((flags & (FREAD | FWRITE)) == FWRITE) {
187: /* Not opening for read, only ioctl is available. */
188: return (0);
189: }
190:
191: if (sc->sc_base.me_parent != NULL) {
192: /* Grab the mux out of the greedy hands of the parent mux. */
193: DPRINTF(("wsmuxopen: detach\n"));
194: wsmux_detach_sc(&sc->sc_base);
195: }
196:
197: if (sc->sc_base.me_evp != NULL)
198: /* Already open. */
199: return (EBUSY);
200:
201: evar = &sc->sc_base.me_evar;
202: wsevent_init(evar);
203: evar->io = p;
204: #ifdef WSDISPLAY_COMPAT_RAWKBD
205: sc->sc_rawkbd = 0;
206: #endif
207:
208: wsmux_do_open(sc, evar);
209:
210: return (0);
211: }
212:
213: /*
214: * Open of a mux via the parent mux.
215: */
216: int
217: wsmux_mux_open(struct wsevsrc *me, struct wseventvar *evar)
218: {
219: struct wsmux_softc *sc = (struct wsmux_softc *)me;
220:
221: #ifdef DIAGNOSTIC
222: if (sc->sc_base.me_evp != NULL) {
223: printf("wsmux_mux_open: busy\n");
224: return (EBUSY);
225: }
226: if (sc->sc_base.me_parent == NULL) {
227: printf("wsmux_mux_open: no parent\n");
228: return (EINVAL);
229: }
230: #endif
231:
232: wsmux_do_open(sc, evar);
233:
234: return (0);
235: }
236:
237: /* Common part of opening a mux. */
238: void
239: wsmux_do_open(struct wsmux_softc *sc, struct wseventvar *evar)
240: {
241: struct wsevsrc *me;
242: #ifdef DIAGNOSTIC
243: int error;
244: #endif
245:
246: sc->sc_base.me_evp = evar; /* remember event variable, mark as open */
247:
248: /* Open all children. */
249: CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
250: DPRINTF(("wsmuxopen: %s: m=%p dev=%s\n",
251: sc->sc_base.me_dv.dv_xname, me, me->me_dv.dv_xname));
252: #ifdef DIAGNOSTIC
253: if (me->me_evp != NULL) {
254: printf("wsmuxopen: dev already in use\n");
255: continue;
256: }
257: if (me->me_parent != sc) {
258: printf("wsmux_do_open: bad child=%p\n", me);
259: continue;
260: }
261: error = wsevsrc_open(me, evar);
262: if (error) {
263: 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: }
271:
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;
281:
282: if (evar == NULL)
283: /* Not open for read */
284: return (0);
285:
286: wsmux_do_close(sc);
287: sc->sc_base.me_evp = NULL;
288: wsevent_fini(evar);
289: return (0);
290: }
291:
292: /*
293: * Close of a mux via the parent mux.
294: */
295: int
296: wsmux_mux_close(struct wsevsrc *me)
297: {
298: me->me_evp = NULL;
299: wsmux_do_close((struct wsmux_softc *)me);
300: return (0);
301: }
302:
303: /* Common part of closing a mux. */
304: void
305: wsmux_do_close(struct wsmux_softc *sc)
306: {
307: struct wsevsrc *me;
308:
309: DPRINTF(("wsmuxclose: %s: sc=%p\n", sc->sc_base.me_dv.dv_xname, sc));
310:
311: /* Close all the children. */
312: CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
313: DPRINTF(("wsmuxclose %s: m=%p dev=%s\n",
314: sc->sc_base.me_dv.dv_xname, me, me->me_dv.dv_xname));
315: #ifdef DIAGNOSTIC
316: if (me->me_parent != sc) {
317: printf("wsmuxclose: bad child=%p\n", me);
318: continue;
319: }
320: #endif
321: (void)wsevsrc_close(me);
322: me->me_evp = NULL;
323: }
324: }
325:
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;
335:
336: evar = sc->sc_base.me_evp;
337: if (evar == NULL) {
338: #ifdef DIAGNOSTIC
339: /* XXX can we get here? */
340: printf("wsmuxread: not open\n");
341: #endif
342: return (EINVAL);
343: }
344:
345: DPRINTFN(5,("wsmuxread: %s event read evar=%p\n",
346: sc->sc_base.me_dv.dv_xname, evar));
347: error = wsevent_read(evar, uio, flags);
348: DPRINTFN(5,("wsmuxread: %s event read ==> error=%d\n",
349: sc->sc_base.me_dv.dv_xname, error));
350: return (error);
351: }
352:
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: }
361:
362: /*
363: * ioctl of a mux via the parent mux, continuation of wsmuxioctl().
364: */
365: int
366: 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;
376:
377: DPRINTF(("wsmux_do_ioctl: %s: enter sc=%p, cmd=%08lx\n",
378: sc->sc_base.me_dv.dv_xname, sc, cmd));
379:
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: }
390:
391: switch (cmd) {
392: case WSMUXIO_INJECTEVENT:
393: /* Inject an event, e.g., from moused. */
394: DPRINTF(("%s: inject\n", sc->sc_base.me_dv.dv_xname));
395: evar = sc->sc_base.me_evp;
396: if (evar == NULL) {
397: /* No event sink, so ignore it. */
398: DPRINTF(("wsmux_do_ioctl: event ignored\n"));
399: return (0);
400: }
401:
402: s = spltty();
403: get = evar->get;
404: put = evar->put;
405: ev = &evar->q[put];
406: if (++put % WSEVENT_QSIZE == get) {
407: put--;
408: splx(s);
409: return (ENOSPC);
410: }
411: if (put >= WSEVENT_QSIZE)
412: put = 0;
413: *ev = *(struct wscons_event *)data;
414: nanotime(&ev->time);
415: evar->put = put;
416: WSEVENT_WAKEUP(evar);
417: splx(s);
418: return (0);
419: case WSMUXIO_ADD_DEVICE:
420: #define d ((struct wsmux_device *)data)
421: DPRINTF(("%s: add type=%d, no=%d\n", sc->sc_base.me_dv.dv_xname,
422: 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:
438: DPRINTF(("%s: rem type=%d, no=%d\n", sc->sc_base.me_dv.dv_xname,
439: d->type, d->idx));
440: /* Locate the device */
441: CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
442: if (me->me_ops->type == d->type &&
443: me->me_dv.dv_unit == d->idx) {
444: DPRINTF(("wsmux_do_ioctl: detach\n"));
445: wsmux_detach_sc(me);
446: return (0);
447: }
448: }
449: return (EINVAL);
450: #undef d
451:
452: case WSMUXIO_LIST_DEVICES:
453: DPRINTF(("%s: list\n", sc->sc_base.me_dv.dv_xname));
454: l = (struct wsmux_device_list *)data;
455: n = 0;
456: CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
457: if (n >= WSMUX_MAXDEV)
458: break;
459: l->devices[n].type = me->me_ops->type;
460: l->devices[n].idx = me->me_dv.dv_unit;
461: n++;
462: }
463: l->ndevices = n;
464: return (0);
465: #ifdef WSDISPLAY_COMPAT_RAWKBD
466: case WSKBDIO_SETMODE:
467: sc->sc_rawkbd = *(int *)data;
468: DPRINTF(("wsmux_do_ioctl: save rawkbd = %d\n", sc->sc_rawkbd));
469: break;
470: #endif
471: case FIONBIO:
472: DPRINTF(("%s: FIONBIO\n", sc->sc_base.me_dv.dv_xname));
473: return (0);
474:
475: case FIOASYNC:
476: DPRINTF(("%s: FIOASYNC\n", sc->sc_base.me_dv.dv_xname));
477: evar = sc->sc_base.me_evp;
478: if (evar == NULL)
479: return (EINVAL);
480: evar->async = *(int *)data != 0;
481: return (0);
482: case FIOSETOWN:
483: DPRINTF(("%s: FIOSETOWN\n", sc->sc_base.me_dv.dv_xname));
484: 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:
492: DPRINTF(("%s: TIOCSPGRP\n", sc->sc_base.me_dv.dv_xname));
493: 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:
500: DPRINTF(("%s: unknown\n", sc->sc_base.me_dv.dv_xname));
501: break;
502: }
503:
504: if (sc->sc_base.me_evp == NULL
505: #if NWSDISPLAY > 0
506: && sc->sc_displaydv == NULL
507: #endif
508: )
509: return (EACCES);
510:
511: /* Return 0 if any of the ioctl() succeeds, otherwise the last error */
512: error = 0;
513: ok = 0;
514: CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
515: #ifdef DIAGNOSTIC
516: /* XXX check evp? */
517: if (me->me_parent != sc) {
518: printf("wsmux_do_ioctl: bad child %p\n", me);
519: continue;
520: }
521: #endif
522: error = wsevsrc_ioctl(me, cmd, data, flag, p);
523: DPRINTF(("wsmux_do_ioctl: %s: me=%p dev=%s ==> %d\n",
524: sc->sc_base.me_dv.dv_xname, me, me->me_dv.dv_xname,
525: error));
526: if (!error)
527: ok = 1;
528: }
529: if (ok) {
530: error = 0;
531: if (cmd == WSKBDIO_SETENCODING) {
532: sc->sc_kbd_layout = *((kbd_t *)data);
533: }
534:
535: }
536:
537: return (error);
538: }
539:
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)];
547:
548: if (sc->sc_base.me_evp == NULL) {
549: #ifdef DIAGNOSTIC
550: printf("wsmuxpoll: not open\n");
551: #endif
552: return (POLLERR);
553: }
554:
555: return (wsevent_poll(sc->sc_base.me_evp, events, p));
556: }
557:
558: /*
559: * Add mux unit as a child to muxsc.
560: */
561: int
562: wsmux_add_mux(int unit, struct wsmux_softc *muxsc)
563: {
564: struct wsmux_softc *sc, *m;
565:
566: sc = wsmux_getmux(unit);
567: if (sc == NULL)
568: return (ENXIO);
569:
570: DPRINTF(("wsmux_add_mux: %s(%p) to %s(%p)\n",
571: sc->sc_base.me_dv.dv_xname, sc, muxsc->sc_base.me_dv.dv_xname,
572: muxsc));
573:
574: if (sc->sc_base.me_parent != NULL || sc->sc_base.me_evp != NULL)
575: return (EBUSY);
576:
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);
581:
582: return (wsmux_attach_sc(muxsc, &sc->sc_base));
583: }
584:
585: /* Create a new mux softc. */
586: struct wsmux_softc *
587: wsmux_create(const char *name, int unit)
588: {
589: struct wsmux_softc *sc;
590:
591: DPRINTF(("wsmux_create: allocating\n"));
592: sc = malloc(sizeof *sc, M_DEVBUF, M_NOWAIT);
593: if (sc == NULL)
594: return (NULL);
595: bzero(sc, sizeof *sc);
596: CIRCLEQ_INIT(&sc->sc_cld);
597: snprintf(sc->sc_base.me_dv.dv_xname, sizeof sc->sc_base.me_dv.dv_xname,
598: "%s%d", name, unit);
599: sc->sc_base.me_dv.dv_unit = unit;
600: sc->sc_base.me_ops = &wsmux_srcops;
601: sc->sc_kbd_layout = KB_NONE;
602: return (sc);
603: }
604:
605: /* Attach me as a child to sc. */
606: int
607: wsmux_attach_sc(struct wsmux_softc *sc, struct wsevsrc *me)
608: {
609: int error;
610:
611: if (sc == NULL)
612: return (EINVAL);
613:
614: DPRINTF(("wsmux_attach_sc: %s(%p): type=%d\n",
615: sc->sc_base.me_dv.dv_xname, sc, me->me_ops->type));
616:
617: #ifdef DIAGNOSTIC
618: if (me->me_parent != NULL) {
619: printf("wsmux_attach_sc: busy\n");
620: return (EBUSY);
621: }
622: #endif
623: me->me_parent = sc;
624: CIRCLEQ_INSERT_TAIL(&sc->sc_cld, me, me_next);
625:
626: 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. */
630: DPRINTF(("wsmux_attach_sc: %s: set display %p\n",
631: sc->sc_base.me_dv.dv_xname, sc->sc_displaydv));
632: if (me->me_ops->dsetdisplay != NULL) {
633: error = wsevsrc_set_display(me, sc->sc_displaydv);
634: /* Ignore that the console already has a display. */
635: if (error == EBUSY)
636: error = 0;
637: if (!error) {
638: #ifdef WSDISPLAY_COMPAT_RAWKBD
639: DPRINTF(("wsmux_attach_sc: %s set rawkbd=%d\n",
640: 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,
646: 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 */
654: DPRINTF(("wsmux_attach_sc: %s: calling open of %s\n",
655: sc->sc_base.me_dv.dv_xname, me->me_dv.dv_xname));
656: error = wsevsrc_open(me, sc->sc_base.me_evp);
657: } else {
658: DPRINTF(("wsmux_attach_sc: %s not open\n",
659: sc->sc_base.me_dv.dv_xname));
660: }
661:
662: if (error) {
663: me->me_parent = NULL;
664: CIRCLEQ_REMOVE(&sc->sc_cld, me, me_next);
665: }
666:
667: DPRINTF(("wsmux_attach_sc: %s(%p) done, error=%d\n",
668: sc->sc_base.me_dv.dv_xname, sc, error));
669: return (error);
670: }
671:
672: /* Remove me from the parent. */
673: void
674: wsmux_detach_sc(struct wsevsrc *me)
675: {
676: struct wsmux_softc *sc = me->me_parent;
677:
678: DPRINTF(("wsmux_detach_sc: %s(%p) parent=%p\n",
679: me->me_dv.dv_xname, me, sc));
680:
681: #ifdef DIAGNOSTIC
682: if (sc == NULL) {
683: printf("wsmux_detach_sc: %s has no parent\n",
684: me->me_dv.dv_xname);
685: return;
686: }
687: #endif
688:
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) {
697: DPRINTF(("wsmux_detach_sc: close\n"));
698: /* mux device is open, so close multiplexee */
699: (void)wsevsrc_close(me);
700: }
701:
702: CIRCLEQ_REMOVE(&sc->sc_cld, me, me_next);
703: me->me_parent = NULL;
704:
705: DPRINTF(("wsmux_detach_sc: done sc=%p\n", sc));
706: }
707:
708: /*
709: * Display ioctl() of a mux via the parent mux.
710: */
711: int
712: 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;
718:
719: DPRINTF(("wsmux_displayioctl: %s: sc=%p, cmd=%08lx\n",
720: sc->sc_base.me_dv.dv_xname, sc, cmd));
721:
722: #ifdef WSDISPLAY_COMPAT_RAWKBD
723: if (cmd == WSKBDIO_SETMODE) {
724: sc->sc_rawkbd = *(int *)data;
725: DPRINTF(("wsmux_displayioctl: rawkbd = %d\n", sc->sc_rawkbd));
726: }
727: #endif
728:
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: */
733: error = -1;
734: ok = 0;
735: CIRCLEQ_FOREACH(me, &sc->sc_cld, me_next) {
736: DPRINTF(("wsmux_displayioctl: me=%p\n", me));
737: #ifdef DIAGNOSTIC
738: if (me->me_parent != sc) {
739: printf("wsmux_displayioctl: bad child %p\n", me);
740: continue;
741: }
742: #endif
743: if (me->me_ops->ddispioctl != NULL) {
744: error = wsevsrc_display_ioctl(me, cmd, data, flag, p);
745: DPRINTF(("wsmux_displayioctl: me=%p dev=%s ==> %d\n",
746: me, me->me_dv.dv_xname, error));
747: if (!error)
748: ok = 1;
749: }
750: }
751: if (ok)
752: error = 0;
753:
754: return (error);
755: }
756:
757: #if NWSDISPLAY > 0
758: /*
759: * Set display of a mux via the parent mux.
760: */
761: int
762: wsmux_evsrc_set_display(struct device *dv, struct device *displaydv)
763: {
764: struct wsmux_softc *sc = (struct wsmux_softc *)dv;
765:
766: DPRINTF(("wsmux_set_display: %s: displaydv=%p\n",
767: sc->sc_base.me_dv.dv_xname, displaydv));
768:
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: }
776:
777: return wsmux_set_display(sc, displaydv);
778: }
779:
780: int
781: 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;
787:
788: odisplaydv = sc->sc_displaydv;
789: sc->sc_displaydv = displaydv;
790:
791: if (displaydv) {
792: DPRINTF(("%s: connecting to %s\n",
793: sc->sc_base.me_dv.dv_xname, displaydv->dv_xname));
794: }
795: ok = 0;
796: error = 0;
797: CIRCLEQ_FOREACH(me, &sc->sc_cld,me_next) {
798: #ifdef DIAGNOSTIC
799: if (me->me_parent != sc) {
800: printf("wsmux_set_display: bad child parent %p\n", me);
801: continue;
802: }
803: #endif
804: if (me->me_ops->dsetdisplay != NULL) {
805: error = wsevsrc_set_display(me, nsc->sc_displaydv);
806: DPRINTF(("wsmux_set_display: m=%p dev=%s error=%d\n",
807: me, me->me_dv.dv_xname, error));
808: if (!error) {
809: ok = 1;
810: #ifdef WSDISPLAY_COMPAT_RAWKBD
811: DPRINTF(("wsmux_set_display: %s set rawkbd=%d\n"
812: ,
813: 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)
821: error = 0;
822:
823: if (displaydv == NULL) {
824: DPRINTF(("%s: disconnecting from %s\n",
825: sc->sc_base.me_dv.dv_xname, odisplaydv->dv_xname));
826: }
827:
828: return (error);
829: }
830: #endif /* NWSDISPLAY > 0 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to wsmux.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / wscons