Annotation of sys/dev/wscons/wsmouse.c, Revision 1.1.1.1
1.1 nbrk 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 $ */
3:
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: */
33:
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: */
73:
74: /*
75: * Mouse driver.
76: */
77:
78: #ifndef SMALL_KERNEL
79: #define BURNER_SUPPORT
80: #endif
81:
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>
95:
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>
101:
102: #include "wsmux.h"
103: #include "wsdisplay.h"
104: #include "wskbd.h"
105:
106: #include <dev/wscons/wsmuxvar.h>
107:
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
116:
117: #define INVALID_X INT_MAX
118: #define INVALID_Y INT_MAX
119: #define INVALID_Z INT_MAX
120: #define INVALID_W INT_MAX
121:
122: struct wsmouse_softc {
123: struct wsevsrc sc_base;
124:
125: const struct wsmouse_accessops *sc_accessops;
126: void *sc_accesscookie;
127:
128: u_int sc_mb; /* mouse button state */
129: 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 */
138:
139: int sc_refcnt;
140: u_char sc_dying; /* device is being detached */
141: };
142:
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);
147:
148: int wsmouse_do_ioctl(struct wsmouse_softc *, u_long, caddr_t,
149: int, struct proc *);
150:
151: #if NWSMUX > 0
152: int wsmouse_mux_open(struct wsevsrc *, struct wseventvar *);
153: int wsmouse_mux_close(struct wsevsrc *);
154: #endif
155:
156: int wsmousedoioctl(struct device *, u_long, caddr_t, int,
157: struct proc *);
158: int wsmousedoopen(struct wsmouse_softc *, struct wseventvar *);
159:
160: struct cfdriver wsmouse_cd = {
161: NULL, "wsmouse", DV_TTY
162: };
163:
164: struct cfattach wsmouse_ca = {
165: sizeof (struct wsmouse_softc), wsmouse_match, wsmouse_attach,
166: wsmouse_detach, wsmouse_activate
167: };
168:
169: #if NWSMUX > 0
170: struct wssrcops wsmouse_srcops = {
171: WSMUX_MOUSE,
172: wsmouse_mux_open, wsmouse_mux_close, wsmousedoioctl, NULL, NULL
173: };
174: #endif
175:
176: /*
177: * Print function (for parent devices).
178: */
179: int
180: wsmousedevprint(void *aux, const char *pnp)
181: {
182:
183: if (pnp)
184: printf("wsmouse at %s", pnp);
185: return (UNCONF);
186: }
187:
188: int
189: wsmouse_match(struct device *parent, void *match, void *aux)
190: {
191: return (1);
192: }
193:
194: void
195: 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
202:
203: sc->sc_accessops = ap->accessops;
204: sc->sc_accesscookie = ap->accesscookie;
205:
206: #if NWSMUX > 0
207: sc->sc_base.me_ops = &wsmouse_srcops;
208: mux = sc->sc_base.me_dv.dv_cfdata->wsmousedevcf_mux;
209: if (mux >= 0) {
210: error = wsmux_attach_sc(wsmux_getmux(mux), &sc->sc_base);
211: if (error)
212: printf(" attach error=%d", error);
213: else
214: 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)
219: printf(" (mux ignored)");
220: #endif
221: #endif /* NWSMUX > 0 */
222:
223: printf("\n");
224: }
225:
226: int
227: wsmouse_activate(struct device *self, enum devact act)
228: {
229: struct wsmouse_softc *sc = (struct wsmouse_softc *)self;
230:
231: if (act == DVACT_DEACTIVATE)
232: sc->sc_dying = 1;
233: return (0);
234: }
235:
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
245: 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;
251:
252: #if NWSMUX > 0
253: /* Tell parent mux we're leaving. */
254: if (sc->sc_base.me_parent != NULL) {
255: DPRINTF(("wsmouse_detach:\n"));
256: wsmux_detach_sc(&sc->sc_base);
257: }
258: #endif
259:
260: /* If we're open ... */
261: evar = sc->sc_base.me_evp;
262: if (evar != NULL && evar->io != NULL) {
263: s = spltty();
264: if (--sc->sc_refcnt >= 0) {
265: /* Wake everyone by generating a dummy event. */
266: if (++evar->put >= WSEVENT_QSIZE)
267: evar->put = 0;
268: WSEVENT_WAKEUP(evar);
269: /* Wait for processes to go away. */
270: if (tsleep(sc, PZERO, "wsmdet", hz * 60))
271: printf("wsmouse_detach: %s didn't detach\n",
272: sc->sc_base.me_dv.dv_xname);
273: }
274: splx(s);
275: }
276:
277: /* locate the major number */
278: for (maj = 0; maj < nchrdev; maj++)
279: if (cdevsw[maj].d_open == wsmouseopen)
280: break;
281:
282: /* Nuke the vnodes for any open instances (calls close). */
283: mn = self->dv_unit;
284: vdevgone(maj, mn, mn, VCHR);
285:
286: return (0);
287: }
288:
289: void
290: 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;
297:
298: add_mouse_randomness(x ^ y ^ z ^ w ^ btns);
299:
300: /*
301: * Discard input if not ready.
302: */
303: evar = sc->sc_base.me_evp;
304: if (evar == NULL)
305: return;
306:
307: #ifdef DIAGNOSTIC
308: if (evar->q == NULL) {
309: printf("wsmouse_input: evar->q=NULL\n");
310: return;
311: }
312: #endif
313:
314: #if NWSMUX > 0
315: DPRINTFN(5,("wsmouse_input: %s mux=%p, evar=%p\n",
316: sc->sc_base.me_dv.dv_xname, sc->sc_base.me_parent, evar));
317: #endif
318:
319: sc->sc_mb = btns;
320: if (!(flags & WSMOUSE_INPUT_ABSOLUTE_X))
321: sc->sc_dx += x;
322: if (!(flags & WSMOUSE_INPUT_ABSOLUTE_Y))
323: sc->sc_dy += y;
324: if (!(flags & WSMOUSE_INPUT_ABSOLUTE_Z))
325: sc->sc_dz += z;
326: if (!(flags & WSMOUSE_INPUT_ABSOLUTE_W))
327: sc->sc_dw += w;
328:
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: */
336: ub = sc->sc_ub;
337: any = 0;
338: get = evar->get;
339: put = evar->put;
340: ev = &evar->q[put];
341:
342: /* NEXT prepares to put the next event, backing off if necessary */
343: #define NEXT \
344: if ((++put) % WSEVENT_QSIZE == get) { \
345: put--; \
346: goto out; \
347: }
348: /* ADVANCE completes the `put' of the event */
349: #define ADVANCE \
350: ev++; \
351: if (put >= WSEVENT_QSIZE) { \
352: put = 0; \
353: ev = &evar->q[0]; \
354: } \
355: any = 1
356: /* TIMESTAMP sets `time' field of the event to the current time */
357: #define TIMESTAMP \
358: do { \
359: getnanotime(&ev->time); \
360: } while (0)
361:
362: if (flags & WSMOUSE_INPUT_ABSOLUTE_X) {
363: if (sc->sc_x != x) {
364: NEXT;
365: ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_X;
366: ev->value = x;
367: TIMESTAMP;
368: ADVANCE;
369: sc->sc_x = x;
370: }
371: } else {
372: if (sc->sc_dx) {
373: NEXT;
374: ev->type = WSCONS_EVENT_MOUSE_DELTA_X;
375: ev->value = sc->sc_dx;
376: TIMESTAMP;
377: ADVANCE;
378: sc->sc_dx = 0;
379: }
380: }
381: if (flags & WSMOUSE_INPUT_ABSOLUTE_Y) {
382: if (sc->sc_y != y) {
383: NEXT;
384: ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_Y;
385: ev->value = y;
386: TIMESTAMP;
387: ADVANCE;
388: sc->sc_y = y;
389: }
390: } else {
391: if (sc->sc_dy) {
392: NEXT;
393: ev->type = WSCONS_EVENT_MOUSE_DELTA_Y;
394: ev->value = sc->sc_dy;
395: TIMESTAMP;
396: ADVANCE;
397: sc->sc_dy = 0;
398: }
399: }
400: if (flags & WSMOUSE_INPUT_ABSOLUTE_Z) {
401: if (sc->sc_z != z) {
402: NEXT;
403: ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_Z;
404: ev->value = z;
405: TIMESTAMP;
406: ADVANCE;
407: sc->sc_z = z;
408: }
409: } else {
410: if (sc->sc_dz) {
411: NEXT;
412: ev->type = WSCONS_EVENT_MOUSE_DELTA_Z;
413: ev->value = sc->sc_dz;
414: TIMESTAMP;
415: ADVANCE;
416: sc->sc_dz = 0;
417: }
418: }
419: if (flags & WSMOUSE_INPUT_ABSOLUTE_W) {
420: if (sc->sc_w != w) {
421: NEXT;
422: ev->type = WSCONS_EVENT_MOUSE_ABSOLUTE_W;
423: ev->value = w;
424: TIMESTAMP;
425: ADVANCE;
426: sc->sc_w = w;
427: }
428: } else {
429: if (sc->sc_dw) {
430: NEXT;
431: ev->type = WSCONS_EVENT_MOUSE_DELTA_W;
432: ev->value = sc->sc_dw;
433: TIMESTAMP;
434: ADVANCE;
435: sc->sc_dw = 0;
436: }
437: }
438:
439: 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: */
445: NEXT;
446: ev->value = ffs(d) - 1;
447:
448: KASSERT(ev->value >= 0);
449:
450: d = 1 << ev->value;
451: ev->type =
452: (mb & d) ? WSCONS_EVENT_MOUSE_DOWN : WSCONS_EVENT_MOUSE_UP;
453: TIMESTAMP;
454: ADVANCE;
455: ub ^= d;
456: }
457:
458: /* XXX fake wscons_event notifying wsmoused(8) to close mouse device */
459: if (flags & WSMOUSE_INPUT_WSMOUSED_CLOSE) {
460: NEXT;
461: ev->type = WSCONS_EVENT_WSMOUSED_CLOSE;
462: ev->value = 0;
463: TIMESTAMP;
464: ADVANCE;
465: }
466:
467: #undef TIMESTAMP
468: #undef ADVANCE
469: #undef NEXT
470:
471: out:
472: if (any) {
473: sc->sc_ub = ub;
474: evar->put = put;
475: WSEVENT_WAKEUP(evar);
476: #ifdef BURNER_SUPPORT
477: /* wsdisplay_burn(sc->sc_displaydv, WSDISPLAY_BURN_MOUSE); */
478: #endif
479: #if NWSMUX > 0
480: DPRINTFN(5,("wsmouse_input: %s wakeup evar=%p\n",
481: sc->sc_base.me_dv.dv_xname, evar));
482: #endif
483: }
484: }
485:
486: int
487: 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;
492:
493: 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);
497:
498: #if NWSMUX > 0
499: DPRINTF(("wsmouseopen: %s mux=%p p=%p\n", sc->sc_base.me_dv.dv_xname,
500: sc->sc_base.me_parent, p));
501: #endif
502:
503: if (sc->sc_dying)
504: return (EIO);
505:
506: if ((flags & (FREAD | FWRITE)) == FWRITE)
507: return (0); /* always allow open for write
508: so ioctl() is possible. */
509:
510: if (sc->sc_base.me_evp != NULL)
511: return (EBUSY);
512:
513: evar = &sc->sc_base.me_evar;
514: wsevent_init(evar);
515: evar->io = p;
516:
517: error = wsmousedoopen(sc, evar);
518: if (error) {
519: DPRINTF(("wsmouseopen: %s open failed\n",
520: sc->sc_base.me_dv.dv_xname));
521: sc->sc_base.me_evp = NULL;
522: wsevent_fini(evar);
523: }
524: return (error);
525: }
526:
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;
533:
534: if ((flags & (FREAD | FWRITE)) == FWRITE)
535: return (0); /* see wsmouseopen() */
536:
537: if (evar == NULL)
538: /* not open for read */
539: return (0);
540: sc->sc_base.me_evp = NULL;
541: (*sc->sc_accessops->disable)(sc->sc_accesscookie);
542: wsevent_fini(evar);
543:
544: return (0);
545: }
546:
547: int
548: wsmousedoopen(struct wsmouse_softc *sc, struct wseventvar *evp)
549: {
550: sc->sc_base.me_evp = evp;
551: sc->sc_x = INVALID_X;
552: sc->sc_y = INVALID_Y;
553: sc->sc_z = INVALID_Z;
554: sc->sc_w = INVALID_W;
555:
556: /* enable the device, and punt if that's not possible */
557: return (*sc->sc_accessops->enable)(sc->sc_accesscookie);
558: }
559:
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;
565:
566: if (sc->sc_dying)
567: return (EIO);
568:
569: #ifdef DIAGNOSTIC
570: if (sc->sc_base.me_evp == NULL) {
571: printf("wsmouseread: evp == NULL\n");
572: return (EINVAL);
573: }
574: #endif
575:
576: sc->sc_refcnt++;
577: error = wsevent_read(sc->sc_base.me_evp, uio, flags);
578: if (--sc->sc_refcnt < 0) {
579: wakeup(sc);
580: error = EIO;
581: }
582: return (error);
583: }
584:
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)],
589: cmd, data, flag, p));
590: }
591:
592: /* A wrapper around the ioctl() workhorse to make reference counting easy. */
593: int
594: 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;
599:
600: sc->sc_refcnt++;
601: error = wsmouse_do_ioctl(sc, cmd, data, flag, p);
602: if (--sc->sc_refcnt < 0)
603: wakeup(sc);
604: return (error);
605: }
606:
607: int
608: wsmouse_do_ioctl(struct wsmouse_softc *sc, u_long cmd, caddr_t data, int flag,
609: struct proc *p)
610: {
611: int error;
612:
613: if (sc->sc_dying)
614: return (EIO);
615:
616: /*
617: * Try the generic ioctls that the wsmouse interface supports.
618: */
619:
620: switch (cmd) {
621: case FIOASYNC:
622: case FIOSETOWN:
623: case TIOCSPGRP:
624: if ((flag & FWRITE) == 0)
625: return (EACCES);
626: }
627:
628: switch (cmd) {
629: case FIONBIO: /* we will remove this someday (soon???) */
630: return (0);
631:
632: case FIOASYNC:
633: if (sc->sc_base.me_evp == NULL)
634: return (EINVAL);
635: sc->sc_base.me_evp->async = *(int *)data != 0;
636: return (0);
637:
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);
645:
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: }
653:
654: /*
655: * Try the mouse driver for WSMOUSEIO ioctls. It returns -1
656: * if it didn't recognize the request.
657: */
658: error = (*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd,
659: data, flag, p);
660: return (error != -1 ? error : ENOTTY);
661: }
662:
663: int
664: wsmousepoll(dev_t dev, int events, struct proc *p)
665: {
666: struct wsmouse_softc *sc = wsmouse_cd.cd_devs[minor(dev)];
667:
668: if (sc->sc_base.me_evp == NULL)
669: return (POLLERR);
670: return (wsevent_poll(sc->sc_base.me_evp, events, p));
671: }
672:
673: #if NWSMUX > 0
674: int
675: wsmouse_mux_open(struct wsevsrc *me, struct wseventvar *evp)
676: {
677: struct wsmouse_softc *sc = (struct wsmouse_softc *)me;
678:
679: if (sc->sc_base.me_evp != NULL)
680: return (EBUSY);
681:
682: return wsmousedoopen(sc, evp);
683: }
684:
685: int
686: wsmouse_mux_close(struct wsevsrc *me)
687: {
688: struct wsmouse_softc *sc = (struct wsmouse_softc *)me;
689:
690: sc->sc_base.me_evp = NULL;
691: (*sc->sc_accessops->disable)(sc->sc_accesscookie);
692:
693: return (0);
694: }
695:
696: int
697: wsmouse_add_mux(int unit, struct wsmux_softc *muxsc)
698: {
699: struct wsmouse_softc *sc;
700:
701: if (unit < 0 || unit >= wsmouse_cd.cd_ndevs ||
702: (sc = wsmouse_cd.cd_devs[unit]) == NULL)
703: return (ENXIO);
704:
705: if (sc->sc_base.me_parent != NULL || sc->sc_base.me_evp != NULL)
706: return (EBUSY);
707:
708: return (wsmux_attach_sc(muxsc, &sc->sc_base));
709: }
710: #endif /* NWSMUX > 0 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to wsmouse.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / wscons