1 /* $NetBSD: button.c,v 1.15 2021/09/29 15:17:01 thorpej 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.15 2021/09/29 15:17:01 thorpej Exp $"); 40 41 #include <sys/param.h> 42 #include <sys/conf.h> 43 #include <sys/systm.h> 44 #include <sys/queue.h> 45 #include <sys/mutex.h> 46 #include <sys/errno.h> 47 #include <sys/fcntl.h> 48 #include <sys/callout.h> 49 #include <sys/kernel.h> 50 #include <sys/once.h> 51 #include <sys/poll.h> 52 #include <sys/select.h> 53 #include <sys/vnode.h> 54 55 #include <machine/button.h> 56 57 #include <landisk/dev/buttonvar.h> 58 59 /* 60 * event handler 61 */ 62 static LIST_HEAD(, btn_event) btn_event_list; 63 static kmutex_t btn_event_list_lock; 64 65 static struct lwp *btn_daemon; 66 67 #define BTN_MAX_EVENTS 32 68 69 static kmutex_t btn_event_queue_lock; 70 static kcondvar_t btn_event_queue_cv; 71 72 static button_event_t btn_event_queue[BTN_MAX_EVENTS]; 73 static int btn_event_queue_head; 74 static int btn_event_queue_tail; 75 static int btn_event_queue_count; 76 static int btn_event_queue_flags; 77 static struct selinfo btn_event_queue_selinfo; 78 79 static char btn_type[32]; 80 81 #define BEVQ_F_WAITING 0x01 /* daemon waiting for event */ 82 83 #define BTN_NEXT_EVENT(x) (((x) + 1) / BTN_MAX_EVENTS) 84 85 dev_type_open(btnopen); 86 dev_type_close(btnclose); 87 dev_type_ioctl(btnioctl); 88 dev_type_read(btnread); 89 dev_type_poll(btnpoll); 90 dev_type_kqfilter(btnkqfilter); 91 92 const struct cdevsw button_cdevsw = { 93 .d_open = btnopen, 94 .d_close = btnclose, 95 .d_read = btnread, 96 .d_write = nowrite, 97 .d_ioctl = btnioctl, 98 .d_stop = nostop, 99 .d_tty = notty, 100 .d_poll = btnpoll, 101 .d_mmap = nommap, 102 .d_kqfilter = btnkqfilter, 103 .d_discard = nodiscard, 104 .d_flag = 0 105 }; 106 107 int 108 btn_init(void) 109 { 110 111 LIST_INIT(&btn_event_list); 112 mutex_init(&btn_event_list_lock, MUTEX_DEFAULT, IPL_NONE); 113 mutex_init(&btn_event_queue_lock, MUTEX_DEFAULT, IPL_NONE); 114 cv_init(&btn_event_queue_cv, "btncv"); 115 selinit(&btn_event_queue_selinfo); 116 117 return 0; 118 } 119 120 static int 121 btn_queue_event(button_event_t *bev) 122 { 123 124 if (btn_event_queue_count == BTN_MAX_EVENTS) 125 return (0); 126 127 btn_event_queue[btn_event_queue_head] = *bev; 128 btn_event_queue_head = BTN_NEXT_EVENT(btn_event_queue_head); 129 btn_event_queue_count++; 130 131 return (1); 132 } 133 134 static int 135 btn_get_event(button_event_t *bev) 136 { 137 138 if (btn_event_queue_count == 0) 139 return (0); 140 141 *bev = btn_event_queue[btn_event_queue_tail]; 142 btn_event_queue_tail = BTN_NEXT_EVENT(btn_event_queue_tail); 143 btn_event_queue_count--; 144 145 return (1); 146 } 147 148 static void 149 btn_event_queue_flush(void) 150 { 151 152 btn_event_queue_head = 0; 153 btn_event_queue_tail = 0; 154 btn_event_queue_count = 0; 155 btn_event_queue_flags = 0; 156 } 157 158 int 159 btnopen(dev_t dev, int flag, int mode, struct lwp *l) 160 { 161 int error; 162 163 if (minor(dev) != 0) { 164 return (ENODEV); 165 } 166 167 mutex_enter(&btn_event_queue_lock); 168 if (btn_daemon != NULL) { 169 error = EBUSY; 170 } else { 171 error = 0; 172 btn_daemon = l; 173 btn_event_queue_flush(); 174 } 175 mutex_exit(&btn_event_queue_lock); 176 177 return (error); 178 } 179 180 int 181 btnclose(dev_t dev, int flag, int mode, struct lwp *l) 182 { 183 int count; 184 185 if (minor(dev) != 0) { 186 return (ENODEV); 187 } 188 189 mutex_enter(&btn_event_queue_lock); 190 count = btn_event_queue_count; 191 btn_daemon = NULL; 192 btn_event_queue_flush(); 193 mutex_exit(&btn_event_queue_lock); 194 195 if (count) { 196 printf("WARNING: %d events lost by exiting daemon\n", count); 197 } 198 199 return (0); 200 } 201 202 int 203 btnioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 204 { 205 int error = 0; 206 207 if (minor(dev) != 0) { 208 return (ENODEV); 209 } 210 211 switch (cmd) { 212 case BUTTON_IOC_GET_TYPE: 213 { 214 struct button_type *button_type = (void *)data; 215 strcpy(button_type->button_type, btn_type); 216 break; 217 } 218 219 default: 220 error = ENOTTY; 221 break; 222 } 223 224 return (error); 225 } 226 227 int 228 btnread(dev_t dev, struct uio *uio, int flags) 229 { 230 button_event_t bev; 231 int error; 232 233 if (minor(dev) != 0) { 234 return (ENODEV); 235 } 236 237 if (uio->uio_resid != BUTTON_EVENT_MSG_SIZE) { 238 return (EINVAL); 239 } 240 241 mutex_enter(&btn_event_queue_lock); 242 for (;;) { 243 if (btn_get_event(&bev)) { 244 mutex_exit(&btn_event_queue_lock); 245 return (uiomove(&bev, BUTTON_EVENT_MSG_SIZE, uio)); 246 } 247 248 if (flags & IO_NDELAY) { 249 mutex_exit(&btn_event_queue_lock); 250 return (EWOULDBLOCK); 251 } 252 253 btn_event_queue_flags |= BEVQ_F_WAITING; 254 error = cv_wait_sig(&btn_event_queue_cv, &btn_event_queue_lock); 255 if (error) { 256 mutex_exit(&btn_event_queue_lock); 257 return (error); 258 } 259 } 260 } 261 262 int 263 btnpoll(dev_t dev, int events, struct lwp *l) 264 { 265 int revents; 266 267 if (minor(dev) != 0) { 268 return (ENODEV); 269 } 270 271 revents = events & (POLLOUT | POLLWRNORM); 272 273 /* Attempt to save some work. */ 274 if ((events & (POLLIN | POLLRDNORM)) == 0) 275 return (revents); 276 277 mutex_enter(&btn_event_queue_lock); 278 if (btn_event_queue_count) { 279 revents |= events & (POLLIN | POLLRDNORM); 280 } else { 281 selrecord(l, &btn_event_queue_selinfo); 282 } 283 mutex_exit(&btn_event_queue_lock); 284 285 return (revents); 286 } 287 288 static void 289 filt_btn_rdetach(struct knote *kn) 290 { 291 292 mutex_enter(&btn_event_queue_lock); 293 selremove_knote(&btn_event_queue_selinfo, kn); 294 mutex_exit(&btn_event_queue_lock); 295 } 296 297 static int 298 filt_btn_read(struct knote *kn, long hint) 299 { 300 int rv; 301 302 if (hint & NOTE_SUBMIT) { 303 KASSERT(mutex_owned(&btn_event_queue_lock)); 304 } else { 305 mutex_enter(&btn_event_queue_lock); 306 } 307 308 kn->kn_data = btn_event_queue_count; 309 rv = kn->kn_data > 0; 310 311 if ((hint & NOTE_SUBMIT) == 0) { 312 mutex_exit(&btn_event_queue_lock); 313 } 314 315 return rv; 316 } 317 318 static const struct filterops btn_read_filtops = { 319 .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE, 320 .f_attach = NULL, 321 .f_detach = filt_btn_rdetach, 322 .f_event = filt_btn_read, 323 }; 324 325 int 326 btnkqfilter(dev_t dev, struct knote *kn) 327 { 328 329 if (minor(dev) != 0) { 330 return (ENODEV); 331 } 332 333 switch (kn->kn_filter) { 334 case EVFILT_READ: 335 kn->kn_fop = &btn_read_filtops; 336 mutex_enter(&btn_event_queue_lock); 337 selrecord_knote(&btn_event_queue_selinfo, kn); 338 mutex_exit(&btn_event_queue_lock); 339 break; 340 341 case EVFILT_WRITE: 342 kn->kn_fop = &seltrue_filtops; 343 break; 344 345 default: 346 return (EINVAL); 347 } 348 349 return (0); 350 } 351 352 void 353 btn_settype(const char *type) 354 { 355 356 /* 357 * Don't bother locking this; it's going to be set 358 * during autoconfiguration, and then only read from 359 * then on. 360 */ 361 strlcpy(btn_type, type, sizeof(btn_type)); 362 } 363 364 int 365 btn_event_register(struct btn_event *bev) 366 { 367 368 mutex_enter(&btn_event_list_lock); 369 LIST_INSERT_HEAD(&btn_event_list, bev, bev_list); 370 mutex_exit(&btn_event_list_lock); 371 372 return (0); 373 } 374 375 void 376 btn_event_unregister(struct btn_event *bev) 377 { 378 379 mutex_enter(&btn_event_list_lock); 380 LIST_REMOVE(bev, bev_list); 381 mutex_exit(&btn_event_list_lock); 382 } 383 384 void 385 btn_event_send(struct btn_event *bev, int event) 386 { 387 button_event_t btnev; 388 int rv; 389 390 mutex_enter(&btn_event_queue_lock); 391 if (btn_daemon == NULL) { 392 mutex_exit(&btn_event_queue_lock); 393 printf("%s: btn_event_send can't handle me.\n", bev->bev_name); 394 return; 395 } 396 397 btnev.bev_type = BUTTON_EVENT_STATE_CHANGE; 398 btnev.bev_event.bs_state = event; 399 strcpy(btnev.bev_event.bs_name, bev->bev_name); 400 401 rv = btn_queue_event(&btnev); 402 if (rv == 0) { 403 mutex_exit(&btn_event_queue_lock); 404 printf("%s: WARNING: state change event %d lost; " 405 "queue full\n", bev->bev_name, btnev.bev_type); 406 return; 407 } 408 if (btn_event_queue_flags & BEVQ_F_WAITING) { 409 btn_event_queue_flags &= ~BEVQ_F_WAITING; 410 cv_broadcast(&btn_event_queue_cv); 411 } 412 selnotify(&btn_event_queue_selinfo, POLLIN | POLLRDNORM, NOTE_SUBMIT); 413 mutex_exit(&btn_event_queue_lock); 414 } 415
Indexes created Sun Sep 21 16:09:51 GMT 2025