sys/arch/landisk/dev/button.c

   1 /*      $NetBSD: button.c,v 1.4 2008/01/07 00:27:35 ad Exp $    */
   2
   3 /*
   4  * Copyright (c) 2003 Wasabi Systems, Inc.
   5  * All rights reserved.
   6  *
   7  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed for the NetBSD Project by
  20  *      Wasabi Systems, Inc.
  21  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  22  *    or promote products derived from this software without specific prior
  23  *    written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
  26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  27  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  28  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
  29  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  30  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  31  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  33  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  35  * POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __KERNEL_RCSID(0, "$NetBSD: button.c,v 1.4 2008/01/07 00:27:35 ad Exp $");
  40
  41 #include <sys/param.h>
  42 #include <sys/conf.h>
  43 #include <sys/systm.h>
  44 #include <sys/malloc.h>
  45 #include <sys/simplelock.h>
  46 #include <sys/queue.h>
  47 #include <sys/proc.h>
  48 #include <sys/kthread.h>
  49 #include <sys/errno.h>
  50 #include <sys/fcntl.h>
  51 #include <sys/callout.h>
  52 #include <sys/kernel.h>
  53 #include <sys/poll.h>
  54 #include <sys/select.h>
  55 #include <sys/vnode.h>
  56
  57 #include <machine/button.h>
  58
  59 #include <landisk/dev/buttonvar.h>
  60
  61 /*
  62  * event handler
  63  */
  64 static LIST_HEAD(, btn_event) btn_event_list =
  65     LIST_HEAD_INITIALIZER(btn_event_list);
  66 static struct simplelock btn_event_list_slock =
  67     SIMPLELOCK_INITIALIZER;
  68
  69 static struct lwp *btn_daemon;
  70
  71 #define BTN_MAX_EVENTS          32
  72
  73 static struct simplelock btn_event_queue_slock =
  74     SIMPLELOCK_INITIALIZER;
  75 static button_event_t btn_event_queue[BTN_MAX_EVENTS];
  76 static int btn_event_queue_head;
  77 static int btn_event_queue_tail;
  78 static int btn_event_queue_count;
  79 static int btn_event_queue_flags;
  80 static struct selinfo btn_event_queue_selinfo;
  81
  82 static char btn_type[32];
  83
  84 #define BEVQ_F_WAITING          0x01    /* daemon waiting for event */
  85
  86 #define BTN_NEXT_EVENT(x)       (((x) + 1) / BTN_MAX_EVENTS)
  87
  88 dev_type_open(btnopen);
  89 dev_type_close(btnclose);
  90 dev_type_ioctl(btnioctl);
  91 dev_type_read(btnread);
  92 dev_type_poll(btnpoll);
  93 dev_type_kqfilter(btnkqfilter);
  94
  95 const struct cdevsw button_cdevsw = {
  96         btnopen, btnclose, btnread, nowrite, btnioctl,
  97         nostop, notty, btnpoll, nommap, btnkqfilter,
  98 };
  99
 100 static int
 101 btn_queue_event(button_event_t *bev)
 102 {
 103
 104         if (btn_event_queue_count == BTN_MAX_EVENTS)
 105                 return (0);
 106
 107         btn_event_queue[btn_event_queue_head] = *bev;
 108         btn_event_queue_head = BTN_NEXT_EVENT(btn_event_queue_head);
 109         btn_event_queue_count++;
 110
 111         return (1);
 112 }
 113
 114 static int
 115 btn_get_event(button_event_t *bev)
 116 {
 117
 118         if (btn_event_queue_count == 0)
 119                 return (0);
 120
 121         *bev = btn_event_queue[btn_event_queue_tail];
 122         btn_event_queue_tail = BTN_NEXT_EVENT(btn_event_queue_tail);
 123         btn_event_queue_count--;
 124
 125         return (1);
 126 }
 127
 128 static void
 129 btn_event_queue_flush(void)
 130 {
 131
 132         btn_event_queue_head = 0;
 133         btn_event_queue_tail = 0;
 134         btn_event_queue_count = 0;
 135         btn_event_queue_flags = 0;
 136 }
 137
 138 int
 139 btnopen(dev_t dev, int flag, int mode, struct lwp *l)
 140 {
 141         static bool btn_event_queue_selinfo_init;       /* XXX */
 142         int error;
 143
 144         if (!btn_event_queue_selinfo_init) {
 145                 selinit(&btn_event_queue_selinfo);
 146                 btn_event_queue_selinfo_init = true;
 147         }
 148
 149         if (minor(dev) != 0) {
 150                 return (ENODEV);
 151         }
 152
 153         simple_lock(&btn_event_queue_slock);
 154         if (btn_daemon != NULL) {
 155                 error = EBUSY;
 156         } else {
 157                 error = 0;
 158                 btn_daemon = l;
 159                 btn_event_queue_flush();
 160         }
 161         simple_unlock(&btn_event_queue_slock);
 162
 163         return (error);
 164 }
 165
 166 int
 167 btnclose(dev_t dev, int flag, int mode, struct lwp *l)
 168 {
 169         int count;
 170
 171         if (minor(dev) != 0) {
 172                 return (ENODEV);
 173         }
 174
 175         simple_lock(&btn_event_queue_slock);
 176         count = btn_event_queue_count;
 177         btn_daemon = NULL;
 178         btn_event_queue_flush();
 179         simple_unlock(&btn_event_queue_slock);
 180
 181         if (count) {
 182                 printf("WARNING: %d events lost by exiting daemon\n", count);
 183         }
 184
 185         return (0);
 186 }
 187
 188 int
 189 btnioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
 190 {
 191         int error = 0;
 192
 193         if (minor(dev) != 0) {
 194                 return (ENODEV);
 195         }
 196
 197         switch (cmd) {
 198         case BUTTON_IOC_GET_TYPE:
 199             {
 200                 struct button_type *button_type = (void *)data;
 201                 strcpy(button_type->button_type, btn_type);
 202                 break;
 203             }
 204
 205         default:
 206                 error = ENOTTY;
 207                 break;
 208         }
 209
 210         return (error);
 211 }
 212
 213 int
 214 btnread(dev_t dev, struct uio *uio, int flags)
 215 {
 216         button_event_t bev;
 217         int error;
 218
 219         if (minor(dev) != 0) {
 220                 return (ENODEV);
 221         }
 222
 223         if (uio->uio_resid != BUTTON_EVENT_MSG_SIZE) {
 224                 return (EINVAL);
 225         }
 226
 227         simple_lock(&btn_event_queue_slock);
 228         for (;;) {
 229                 if (btn_get_event(&bev)) {
 230                         simple_unlock(&btn_event_queue_slock);
 231                         return (uiomove(&bev, BUTTON_EVENT_MSG_SIZE, uio));
 232                 }
 233
 234                 if (flags & IO_NDELAY) {
 235                         simple_unlock(&btn_event_queue_slock);
 236                         return (EWOULDBLOCK);
 237                 }
 238
 239                 btn_event_queue_flags |= BEVQ_F_WAITING;
 240                 error = ltsleep(&btn_event_queue_count,
 241                     (PRIBIO|PCATCH), "btnread", 0, &btn_event_queue_slock);
 242                 if (error) {
 243                         simple_unlock(&btn_event_queue_slock);
 244                         return (error);
 245                 }
 246         }
 247 }
 248
 249 int
 250 btnpoll(dev_t dev, int events, struct lwp *l)
 251 {
 252         int revents;
 253
 254         if (minor(dev) != 0) {
 255                 return (ENODEV);
 256         }
 257
 258         revents = events & (POLLOUT | POLLWRNORM);
 259
 260         /* Attempt to save some work. */
 261         if ((events & (POLLIN | POLLRDNORM)) == 0)
 262                 return (revents);
 263
 264         simple_lock(&btn_event_queue_slock);
 265         if (btn_event_queue_count) {
 266                 revents |= events & (POLLIN | POLLRDNORM);
 267         } else {
 268                 selrecord(l, &btn_event_queue_selinfo);
 269         }
 270         simple_unlock(&btn_event_queue_slock);
 271
 272         return (revents);
 273 }
 274
 275 static void
 276 filt_btn_rdetach(struct knote *kn)
 277 {
 278
 279         simple_lock(&btn_event_queue_slock);
 280         SLIST_REMOVE(&btn_event_queue_selinfo.sel_klist,
 281             kn, knote, kn_selnext);
 282         simple_unlock(&btn_event_queue_slock);
 283 }
 284
 285 static int
 286 filt_btn_read(struct knote *kn, long hint)
 287 {
 288
 289         simple_lock(&btn_event_queue_slock);
 290         kn->kn_data = btn_event_queue_count;
 291         simple_unlock(&btn_event_queue_slock);
 292
 293         return (kn->kn_data > 0);
 294 }
 295
 296 static const struct filterops btn_read_filtops =
 297     { 1, NULL, filt_btn_rdetach, filt_btn_read };
 298
 299 static const struct filterops btn_write_filtops =
 300     { 1, NULL, filt_btn_rdetach, filt_seltrue };
 301
 302 int
 303 btnkqfilter(dev_t dev, struct knote *kn)
 304 {
 305         struct klist *klist;
 306
 307         if (minor(dev) != 0) {
 308                 return (ENODEV);
 309         }
 310
 311         switch (kn->kn_filter) {
 312         case EVFILT_READ:
 313                 klist = &btn_event_queue_selinfo.sel_klist;
 314                 kn->kn_fop = &btn_read_filtops;
 315                 break;
 316
 317         case EVFILT_WRITE:
 318                 klist = &btn_event_queue_selinfo.sel_klist;
 319                 kn->kn_fop = &btn_write_filtops;
 320                 break;
 321
 322         default:
 323                 return (1);
 324         }
 325
 326         simple_lock(&btn_event_queue_slock);
 327         SLIST_INSERT_HEAD(klist, kn, kn_selnext);
 328         simple_unlock(&btn_event_queue_slock);
 329
 330         return (0);
 331 }
 332
 333 void
 334 btn_settype(const char *type)
 335 {
 336
 337         /*
 338          * Don't bother locking this; it's going to be set
 339          * during autoconfiguration, and then only read from
 340          * then on.
 341          */
 342         strlcpy(btn_type, type, sizeof(btn_type));
 343 }
 344
 345 int
 346 btn_event_register(struct btn_event *bev)
 347 {
 348
 349         simple_lock(&btn_event_list_slock);
 350         LIST_INSERT_HEAD(&btn_event_list, bev, bev_list);
 351         simple_unlock(&btn_event_list_slock);
 352
 353         return (0);
 354 }
 355
 356 void
 357 btn_event_unregister(struct btn_event *bev)
 358 {
 359
 360         simple_lock(&btn_event_list_slock);
 361         LIST_REMOVE(bev, bev_list);
 362         simple_unlock(&btn_event_list_slock);
 363 }
 364
 365 void
 366 btn_event_send(struct btn_event *bev, int event)
 367 {
 368         button_event_t btnev;
 369         int rv;
 370
 371         simple_lock(&btn_event_queue_slock);
 372         if (btn_daemon != NULL) {
 373                 btnev.bev_type = BUTTON_EVENT_STATE_CHANGE;
 374                 btnev.bev_event.bs_state = event;
 375                 strcpy(btnev.bev_event.bs_name, bev->bev_name);
 376
 377                 rv = btn_queue_event(&btnev);
 378                 if (rv == 0) {
 379                         simple_unlock(&btn_event_queue_slock);
 380                         printf("%s: WARNING: state change event %d lost; "
 381                             "queue full\n", bev->bev_name, btnev.bev_type);
 382                 } else {
 383                         if (btn_event_queue_flags & BEVQ_F_WAITING) {
 384                                 btn_event_queue_flags &= ~BEVQ_F_WAITING;
 385                                 simple_unlock(&btn_event_queue_slock);
 386                                 wakeup(&btn_event_queue_count);
 387                         } else {
 388                                 simple_unlock(&btn_event_queue_slock);
 389                         }
 390                         selnotify(&btn_event_queue_selinfo, 0, 0);
 391                 }
 392                 return;
 393         }
 394         simple_unlock(&btn_event_queue_slock);
 395
 396         printf("%s: btn_event_send can't handle me.\n", bev->bev_name);
 397 }