sys/dev/sun/event.c

   1 /*      $NetBSD: event.c,v 1.22 2008/03/01 14:16:51 rmind Exp $ */
   2
   3 /*
   4  * Copyright (c) 1992, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This software was developed by the Computer Systems Engineering group
   8  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   9  * contributed to Berkeley.
  10  *
  11  * All advertising materials mentioning features or use of this software
  12  * must display the following acknowledgement:
  13  *      This product includes software developed by the University of
  14  *      California, Lawrence Berkeley Laboratory.
  15  *
  16  * Redistribution and use in source and binary forms, with or without
  17  * modification, are permitted provided that the following conditions
  18  * are met:
  19  * 1. Redistributions of source code must retain the above copyright
  20  *    notice, this list of conditions and the following disclaimer.
  21  * 2. Redistributions in binary form must reproduce the above copyright
  22  *    notice, this list of conditions and the following disclaimer in the
  23  *    documentation and/or other materials provided with the distribution.
  24  * 3. Neither the name of the University nor the names of its contributors
  25  *    may be used to endorse or promote products derived from this software
  26  *    without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  38  * SUCH DAMAGE.
  39  *
  40  *      @(#)event.c     8.1 (Berkeley) 6/11/93
  41  */
  42
  43 /*
  44  * Internal `Firm_event' interface for the keyboard and mouse drivers.
  45  */
  46
  47 #include <sys/cdefs.h>
  48 __KERNEL_RCSID(0, "$NetBSD: event.c,v 1.22 2008/03/01 14:16:51 rmind Exp $");
  49
  50 #include <sys/param.h>
  51 #include <sys/fcntl.h>
  52 #include <sys/malloc.h>
  53 #include <sys/proc.h>
  54 #include <sys/systm.h>
  55 #include <sys/vnode.h>
  56 #include <sys/select.h>
  57 #include <sys/poll.h>
  58
  59 #include <dev/sun/vuid_event.h>
  60 #include <dev/sun/event_var.h>
  61
  62 int (*ev_out32_hook)(struct firm_event *, int, struct uio *);
  63
  64 /*
  65  * Initialize a firm_event queue.
  66  */
  67 void
  68 ev_init(struct evvar *ev)
  69 {
  70
  71         ev->ev_get = ev->ev_put = 0;
  72         ev->ev_q = malloc((u_long)EV_QSIZE * sizeof(struct firm_event),
  73             M_DEVBUF, M_WAITOK|M_ZERO);
  74         selinit(&ev->ev_sel);
  75 }
  76
  77 /*
  78  * Tear down a firm_event queue.
  79  */
  80 void
  81 ev_fini(struct evvar *ev)
  82 {
  83
  84         seldestroy(&ev->ev_sel);
  85         free(ev->ev_q, M_DEVBUF);
  86 }
  87
  88 /*
  89  * User-level interface: read, select.
  90  * (User cannot write an event queue.)
  91  */
  92 int
  93 ev_read(struct evvar *ev, struct uio *uio, int flags)
  94 {
  95         int s, n, cnt, error;
  96
  97         /*
  98          * Make sure we can return at least 1.
  99          */
 100         if (uio->uio_resid < sizeof(struct firm_event))
 101                 return (EMSGSIZE);      /* ??? */
 102         s = splev();
 103         while (ev->ev_get == ev->ev_put) {
 104                 if (flags & IO_NDELAY) {
 105                         splx(s);
 106                         return (EWOULDBLOCK);
 107                 }
 108                 ev->ev_wanted = 1;
 109                 error = tsleep((void *)ev, PEVENT | PCATCH, "firm_event", 0);
 110                 if (error) {
 111                         splx(s);
 112                         return (error);
 113                 }
 114         }
 115         /*
 116          * Move firm_events from tail end of queue (there is at least one
 117          * there).
 118          */
 119         if (ev->ev_put < ev->ev_get)
 120                 cnt = EV_QSIZE - ev->ev_get;    /* events in [get..QSIZE) */
 121         else
 122                 cnt = ev->ev_put - ev->ev_get;  /* events in [get..put) */
 123         splx(s);
 124         n = howmany(uio->uio_resid, sizeof(struct firm_event));
 125         if (cnt > n)
 126                 cnt = n;
 127         if ((curproc->p_flag & PK_32) && ev_out32_hook != NULL)
 128                 error = (*ev_out32_hook)(&ev->ev_q[ev->ev_get], cnt, uio);
 129         else
 130                 error = uiomove((void *)&ev->ev_q[ev->ev_get],
 131                     cnt * sizeof(struct firm_event), uio);
 132         n -= cnt;
 133         /*
 134          * If we do not wrap to 0, used up all our space, or had an error,
 135          * stop.  Otherwise move from front of queue to put index, if there
 136          * is anything there to move.
 137          */
 138         if ((ev->ev_get = (ev->ev_get + cnt) % EV_QSIZE) != 0 ||
 139             n == 0 || error || (cnt = ev->ev_put) == 0)
 140                 return (error);
 141         if (cnt > n)
 142                 cnt = n;
 143         if ((curproc->p_flag & PK_32) && ev_out32_hook != NULL)
 144                 error = (*ev_out32_hook)(&ev->ev_q[0], cnt, uio);
 145         else
 146                 error = uiomove((void *)&ev->ev_q[0],
 147             cnt * sizeof(struct firm_event), uio);
 148         ev->ev_get = cnt;
 149         return (error);
 150 }
 151
 152 int
 153 ev_poll(struct evvar *ev, int events, struct lwp *l)
 154 {
 155         int s = splev(), revents = 0;
 156
 157         if (events & (POLLIN | POLLRDNORM)) {
 158                 if (ev->ev_get == ev->ev_put)
 159                         selrecord(l, &ev->ev_sel);
 160                 else
 161                         revents |= events & (POLLIN | POLLRDNORM);
 162         }
 163         revents |= events & (POLLOUT | POLLWRNORM);
 164
 165         splx(s);
 166         return (revents);
 167 }
 168
 169 static void
 170 filt_evrdetach(struct knote *kn)
 171 {
 172         struct evvar *ev = kn->kn_hook;
 173         int s;
 174
 175         s = splev();
 176         SLIST_REMOVE(&ev->ev_sel.sel_klist, kn, knote, kn_selnext);
 177         splx(s);
 178 }
 179
 180 static int
 181 filt_evread(struct knote *kn, long hint)
 182 {
 183         struct evvar *ev = kn->kn_hook;
 184
 185         if (ev->ev_get == ev->ev_put)
 186                 return (0);
 187
 188         if (ev->ev_get < ev->ev_put)
 189                 kn->kn_data = ev->ev_put - ev->ev_get;
 190         else
 191                 kn->kn_data = (EV_QSIZE - ev->ev_get) +
 192                     ev->ev_put;
 193
 194         kn->kn_data *= sizeof(struct firm_event);
 195
 196         return (1);
 197 }
 198
 199 static const struct filterops ev_filtops =
 200         { 1, NULL, filt_evrdetach, filt_evread };
 201
 202 int
 203 ev_kqfilter(struct evvar *ev, struct knote *kn)
 204 {
 205         struct klist *klist;
 206         int s;
 207
 208         switch (kn->kn_filter) {
 209         case EVFILT_READ:
 210                 klist = &ev->ev_sel.sel_klist;
 211                 kn->kn_fop = &ev_filtops;
 212                 break;
 213
 214         default:
 215                 return (EINVAL);
 216         }
 217
 218         kn->kn_hook = ev;
 219
 220         s = splev();
 221         SLIST_INSERT_HEAD(klist, kn, kn_selnext);
 222         splx(s);
 223
 224         return (0);
 225 }