Home | History | Annotate | Line # | Download | only in sun
event.c revision 1.2 
      1 /*	$NetBSD: event.c,v 1.2 1996/05/29 21:24:41 pk 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. All advertising materials mentioning features or use of this software
     25  *    must display the following acknowledgement:
     26  *	This product includes software developed by the University of
     27  *	California, Berkeley and its contributors.
     28  * 4. Neither the name of the University nor the names of its contributors
     29  *    may be used to endorse or promote products derived from this software
     30  *    without specific prior written permission.
     31  *
     32  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     33  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     34  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     35  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     36  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     40  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     41  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     42  * SUCH DAMAGE.
     43  *
     44  *	@(#)event.c	8.1 (Berkeley) 6/11/93
     45  */
     46 
     47 /*
     48  * Internal `Firm_event' interface for the keyboard and mouse drivers.
     49  */
     50 
     51 #include <sys/param.h>
     52 #include <sys/fcntl.h>
     53 #include <sys/malloc.h>
     54 #include <sys/proc.h>
     55 #include <sys/systm.h>
     56 #include <sys/vnode.h>
     57 
     58 #include <machine/vuid_event.h>
     59 #include <dev/sun/event_var.h>
     60 
     61 /*
     62  * Initialize a firm_event queue.
     63  */
     64 void
     65 ev_init(ev)
     66 	register struct evvar *ev;
     67 {
     68 
     69 	ev->ev_get = ev->ev_put = 0;
     70 	ev->ev_q = malloc((u_long)EV_QSIZE * sizeof(struct firm_event),
     71 	    M_DEVBUF, M_WAITOK);
     72 	bzero((caddr_t)ev->ev_q, EV_QSIZE * sizeof(struct firm_event));
     73 }
     74 
     75 /*
     76  * Tear down a firm_event queue.
     77  */
     78 void
     79 ev_fini(ev)
     80 	register struct evvar *ev;
     81 {
     82 
     83 	free(ev->ev_q, M_DEVBUF);
     84 }
     85 
     86 /*
     87  * User-level interface: read, select.
     88  * (User cannot write an event queue.)
     89  */
     90 int
     91 ev_read(ev, uio, flags)
     92 	register struct evvar *ev;
     93 	struct uio *uio;
     94 	int flags;
     95 {
     96 	int s, n, cnt, error;
     97 
     98 	/*
     99 	 * Make sure we can return at least 1.
    100 	 */
    101 	if (uio->uio_resid < sizeof(struct firm_event))
    102 		return (EMSGSIZE);	/* ??? */
    103 	s = splev();
    104 	while (ev->ev_get == ev->ev_put) {
    105 		if (flags & IO_NDELAY) {
    106 			splx(s);
    107 			return (EWOULDBLOCK);
    108 		}
    109 		ev->ev_wanted = 1;
    110 		error = tsleep((caddr_t)ev, PEVENT | PCATCH, "firm_event", 0);
    111 		if (error) {
    112 			splx(s);
    113 			return (error);
    114 		}
    115 	}
    116 	/*
    117 	 * Move firm_events from tail end of queue (there is at least one
    118 	 * there).
    119 	 */
    120 	if (ev->ev_put < ev->ev_get)
    121 		cnt = EV_QSIZE - ev->ev_get;	/* events in [get..QSIZE) */
    122 	else
    123 		cnt = ev->ev_put - ev->ev_get;	/* events in [get..put) */
    124 	splx(s);
    125 	n = howmany(uio->uio_resid, sizeof(struct firm_event));
    126 	if (cnt > n)
    127 		cnt = n;
    128 	error = uiomove((caddr_t)&ev->ev_q[ev->ev_get],
    129 	    cnt * sizeof(struct firm_event), uio);
    130 	n -= cnt;
    131 	/*
    132 	 * If we do not wrap to 0, used up all our space, or had an error,
    133 	 * stop.  Otherwise move from front of queue to put index, if there
    134 	 * is anything there to move.
    135 	 */
    136 	if ((ev->ev_get = (ev->ev_get + cnt) % EV_QSIZE) != 0 ||
    137 	    n == 0 || error || (cnt = ev->ev_put) == 0)
    138 		return (error);
    139 	if (cnt > n)
    140 		cnt = n;
    141 	error = uiomove((caddr_t)&ev->ev_q[0],
    142 	    cnt * sizeof(struct firm_event), uio);
    143 	ev->ev_get = cnt;
    144 	return (error);
    145 }
    146 
    147 int
    148 ev_select(ev, rw, p)
    149 	register struct evvar *ev;
    150 	int rw;
    151 	struct proc *p;
    152 {
    153 	int s = splev();
    154 
    155 	switch (rw) {
    156 
    157 	case FREAD:
    158 		/* succeed if there is something to read */
    159 		if (ev->ev_get != ev->ev_put) {
    160 			splx(s);
    161 			return (1);
    162 		}
    163 		selrecord(p, &ev->ev_sel);
    164 		break;
    165 
    166 	case FWRITE:
    167 		splx(s);
    168 		return (1);	/* always fails => never blocks */
    169 	}
    170 	splx(s);
    171 	return (0);
    172 }
    173