1 /*-
2 * (MPSAFE)
3 *
4 * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
5 * 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 as
12 * the first lines of this file unmodified.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * $FreeBSD: src/sys/dev/syscons/sysmouse.c,v 1.2.2.2 2001/07/16 05:21:24 yokota Exp $
29 */
30
31 /* MPSAFE NOTE: Take care with locking in sysmouse_event which is called
32 * from syscons.
33 */
34 #include "opt_syscons.h"
35 #include "opt_evdev.h"
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/conf.h>
40 #include <sys/device.h>
41 #include <sys/event.h>
42 #include <sys/uio.h>
43 #include <sys/caps.h>
44 #include <sys/vnode.h>
45 #include <sys/kernel.h>
46 #include <sys/signalvar.h>
47 #include <sys/filio.h>
48
49 #include <machine/console.h>
50 #include <sys/mouse.h>
51
52 #ifdef EVDEV_SUPPORT
53 #include <dev/misc/evdev/input.h>
54 #include <dev/misc/evdev/evdev.h>
55 #endif
56
57 #include "syscons.h"
58
59 #ifndef SC_NO_SYSMOUSE
60
61 #define FIFO_SIZE 256
62
63 struct event_fifo {
64 mouse_info_t buf[FIFO_SIZE];
65 int start;
66 int fill;
67 unsigned int dropped;
68 };
69
70 struct sysmouse_state {
71 struct event_fifo *fifo;
72 int level; /* sysmouse protocol level */
73 mousestatus_t syncstatus;
74 mousestatus_t readstatus; /* Only needed for button status */
75 int opened;
76 int asyncio;
77 struct lock sm_lock;
78 struct sigio *sm_sigio;
79 struct kqinfo rkq;
80 };
81
82 static d_open_t smopen;
83 static d_close_t smclose;
84 static d_read_t smread;
85 static d_ioctl_t smioctl;
86 static d_kqfilter_t smkqfilter;
87
88 static struct dev_ops sm_ops = {
89 { "sysmouse", 0, D_MPSAFE },
90 .d_open = smopen,
91 .d_close = smclose,
92 .d_read = smread,
93 .d_ioctl = smioctl,
94 .d_kqfilter = smkqfilter,
95 };
96
97 /* local variables */
98 static struct sysmouse_state mouse_state;
99
100 static int sysmouse_evtopkt(struct sysmouse_state *sc, mouse_info_t *info,
101 u_char *buf);
102 static void smqueue(struct sysmouse_state *sc, mouse_info_t *info);
103 static int pktlen(struct sysmouse_state *sc);
104 static void smfilter_detach(struct knote *);
105 static int smfilter(struct knote *, long);
106 static void smget(struct sysmouse_state *sc, mouse_info_t *info);
107 static void smpop(struct sysmouse_state *sc);
108
109 #ifdef EVDEV_SUPPORT
110 static struct evdev_dev *sysmouse_evdev;
111
112 static void
smdev_evdev_init(void)113 smdev_evdev_init(void)
114 {
115 int i;
116
117 sysmouse_evdev = evdev_alloc();
118 evdev_set_name(sysmouse_evdev, "System mouse");
119 evdev_set_phys(sysmouse_evdev, "sysmouse");
120 evdev_set_id(sysmouse_evdev, BUS_VIRTUAL, 0, 0, 0);
121 evdev_support_prop(sysmouse_evdev, INPUT_PROP_POINTER);
122 evdev_support_event(sysmouse_evdev, EV_SYN);
123 evdev_support_event(sysmouse_evdev, EV_REL);
124 evdev_support_event(sysmouse_evdev, EV_KEY);
125 evdev_support_rel(sysmouse_evdev, REL_X);
126 evdev_support_rel(sysmouse_evdev, REL_Y);
127 evdev_support_rel(sysmouse_evdev, REL_WHEEL);
128 evdev_support_rel(sysmouse_evdev, REL_HWHEEL);
129 for (i = 0; i < 8; i++)
130 evdev_support_key(sysmouse_evdev, BTN_MOUSE + i);
131 if (evdev_register(sysmouse_evdev)) {
132 evdev_free(sysmouse_evdev);
133 sysmouse_evdev = NULL;
134 }
135 }
136
137 static void
smdev_evdev_write(int x,int y,int z,int buttons)138 smdev_evdev_write(int x, int y, int z, int buttons)
139 {
140
141 if (sysmouse_evdev == NULL || !(evdev_rcpt_mask & EVDEV_RCPT_SYSMOUSE))
142 return;
143
144 evdev_push_event(sysmouse_evdev, EV_REL, REL_X, x);
145 evdev_push_event(sysmouse_evdev, EV_REL, REL_Y, y);
146 switch (evdev_sysmouse_t_axis) {
147 case EVDEV_SYSMOUSE_T_AXIS_PSM:
148 switch (z) {
149 case 1:
150 case -1:
151 evdev_push_rel(sysmouse_evdev, REL_WHEEL, -z);
152 break;
153 case 2:
154 case -2:
155 evdev_push_rel(sysmouse_evdev, REL_HWHEEL, z / 2);
156 break;
157 }
158 break;
159 case EVDEV_SYSMOUSE_T_AXIS_UMS:
160 if (buttons & (1 << 6))
161 evdev_push_rel(sysmouse_evdev, REL_HWHEEL, 1);
162 else if (buttons & (1 << 5))
163 evdev_push_rel(sysmouse_evdev, REL_HWHEEL, -1);
164 buttons &= ~((1 << 5)|(1 << 6));
165 /* PASSTHROUGH */
166 case EVDEV_SYSMOUSE_T_AXIS_NONE:
167 default:
168 evdev_push_rel(sysmouse_evdev, REL_WHEEL, -z);
169 }
170 evdev_push_mouse_btn(sysmouse_evdev, buttons);
171 evdev_sync(sysmouse_evdev);
172 }
173 #endif
174
175 static int
pktlen(struct sysmouse_state * sc)176 pktlen(struct sysmouse_state *sc)
177 {
178 if (sc->level == 0)
179 return 5;
180 else
181 return 8;
182 }
183
184 static int
smopen(struct dev_open_args * ap)185 smopen(struct dev_open_args *ap)
186 {
187 cdev_t dev = ap->a_head.a_dev;
188 struct sysmouse_state *sc = &mouse_state;
189 int ret;
190
191 DPRINTF(5, ("smopen: dev:%d,%d\n",
192 major(dev), minor(dev)));
193
194 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
195 if (!sc->opened) {
196 sc->fifo = kmalloc(sizeof(struct event_fifo),
197 M_SYSCONS, M_WAITOK | M_ZERO);
198 sc->opened = 1;
199 sc->asyncio = 0;
200 sc->sm_sigio = NULL;
201 bzero(&sc->readstatus, sizeof(sc->readstatus));
202 bzero(&sc->syncstatus, sizeof(sc->syncstatus));
203 ret = 0;
204 } else {
205 ret = EBUSY;
206 }
207 lockmgr(&sc->sm_lock, LK_RELEASE);
208
209 return ret;
210 }
211
212 static int
smclose(struct dev_close_args * ap)213 smclose(struct dev_close_args *ap)
214 {
215 struct sysmouse_state *sc = &mouse_state;
216
217 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
218 funsetown(&sc->sm_sigio);
219 sc->opened = 0;
220 sc->asyncio = 0;
221 sc->level = 0;
222 kfree(sc->fifo, M_SYSCONS);
223 sc->fifo = NULL;
224 lockmgr(&sc->sm_lock, LK_RELEASE);
225
226 return 0;
227 }
228
229 static int
smread(struct dev_read_args * ap)230 smread(struct dev_read_args *ap)
231 {
232 struct sysmouse_state *sc = &mouse_state;
233 mousestatus_t backupstatus;
234 mouse_info_t info;
235 u_char buf[8];
236 struct uio *uio = ap->a_uio;
237 int error = 0, val, cnt = 0;
238
239 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
240 while (sc->fifo->fill <= 0) {
241 /* Buffer too small to fit a complete mouse packet */
242 if (uio->uio_resid < pktlen(sc)) {
243 error = EIO;
244 goto done;
245 }
246 if (ap->a_ioflag & IO_NDELAY) {
247 error = EAGAIN;
248 goto done;
249 }
250 error = lksleep(sc, &sc->sm_lock, PCATCH, "smread", 0);
251 if (error == EINTR || error == ERESTART) {
252 goto done;
253 }
254 }
255
256 do {
257 /* Buffer too small to fit a complete mouse packet */
258 if (uio->uio_resid < pktlen(sc)) {
259 error = EIO;
260 goto done;
261 }
262 smget(sc, &info);
263 backupstatus = sc->readstatus;
264 val = sysmouse_evtopkt(sc, &info, buf);
265 if (val > 0) {
266 error = uiomove(buf, val, uio);
267 if (error != 0) {
268 sc->readstatus = backupstatus;
269 goto done;
270 }
271 cnt++;
272 }
273 smpop(sc);
274 } while (sc->fifo->fill > 0);
275
276 done:
277 lockmgr(&sc->sm_lock, LK_RELEASE);
278 if (cnt > 0 && error != EFAULT)
279 return 0;
280 return error;
281 }
282
283 static int
smioctl(struct dev_ioctl_args * ap)284 smioctl(struct dev_ioctl_args *ap)
285 {
286 struct sysmouse_state *sc = &mouse_state;
287 mousehw_t *hw;
288 mousemode_t *mode;
289
290 switch (ap->a_cmd) {
291 case FIOSETOWN:
292 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
293 fsetown(*(int *)ap->a_data, &sc->sm_sigio);
294 lockmgr(&sc->sm_lock, LK_RELEASE);
295 return 0;
296 case FIOGETOWN:
297 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
298 *(int *)ap->a_data = fgetown(&sc->sm_sigio);
299 lockmgr(&sc->sm_lock, LK_RELEASE);
300 return 0;
301 case FIOASYNC:
302 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
303 if (*(int *)ap->a_data) {
304 sc->asyncio = 1;
305 } else {
306 sc->asyncio = 0;
307 }
308 lockmgr(&sc->sm_lock, LK_RELEASE);
309 return 0;
310 case MOUSE_GETHWINFO: /* get device information */
311 hw = (mousehw_t *)ap->a_data;
312 hw->buttons = 10; /* XXX unknown */
313 hw->iftype = MOUSE_IF_SYSMOUSE;
314 hw->type = MOUSE_MOUSE;
315 hw->model = MOUSE_MODEL_GENERIC;
316 hw->hwid = 0;
317 return 0;
318
319 case MOUSE_GETMODE: /* get protocol/mode */
320 mode = (mousemode_t *)ap->a_data;
321 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
322 mode->level = sc->level;
323 lockmgr(&sc->sm_lock, LK_RELEASE);
324 switch (mode->level) {
325 case 0: /* emulate MouseSystems protocol */
326 mode->protocol = MOUSE_PROTO_MSC;
327 mode->rate = -1; /* unknown */
328 mode->resolution = -1; /* unknown */
329 mode->accelfactor = 0; /* disabled */
330 mode->packetsize = MOUSE_MSC_PACKETSIZE;
331 mode->syncmask[0] = MOUSE_MSC_SYNCMASK;
332 mode->syncmask[1] = MOUSE_MSC_SYNC;
333 break;
334
335 case 1: /* sysmouse protocol */
336 mode->protocol = MOUSE_PROTO_SYSMOUSE;
337 mode->rate = -1;
338 mode->resolution = -1;
339 mode->accelfactor = 0;
340 mode->packetsize = MOUSE_SYS_PACKETSIZE;
341 mode->syncmask[0] = MOUSE_SYS_SYNCMASK;
342 mode->syncmask[1] = MOUSE_SYS_SYNC;
343 break;
344 }
345 return 0;
346
347 case MOUSE_SETMODE: /* set protocol/mode */
348 mode = (mousemode_t *)ap->a_data;
349 if (mode->level == -1)
350 ; /* don't change the current setting */
351 else if ((mode->level < 0) || (mode->level > 1)) {
352 return EINVAL;
353 } else {
354 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
355 sc->level = mode->level;
356 lockmgr(&sc->sm_lock, LK_RELEASE);
357 }
358 return 0;
359
360 case MOUSE_GETLEVEL: /* get operation level */
361 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
362 *(int *)ap->a_data = sc->level;
363 lockmgr(&sc->sm_lock, LK_RELEASE);
364 return 0;
365
366 case MOUSE_SETLEVEL: /* set operation level */
367 if ((*(int *)ap->a_data < 0) || (*(int *)ap->a_data > 1)) {
368 return EINVAL;
369 }
370 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
371 sc->level = *(int *)ap->a_data;
372 lockmgr(&sc->sm_lock, LK_RELEASE);
373 return 0;
374
375 case MOUSE_GETSTATUS: /* get accumulated mouse events */
376 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
377 *(mousestatus_t *)ap->a_data = sc->syncstatus;
378 sc->syncstatus.flags = 0;
379 sc->syncstatus.obutton = sc->syncstatus.button;
380 sc->syncstatus.dx = 0;
381 sc->syncstatus.dy = 0;
382 sc->syncstatus.dz = 0;
383 lockmgr(&sc->sm_lock, LK_RELEASE);
384 return 0;
385
386 case MOUSE_READSTATE: /* read status from the device */
387 case MOUSE_READDATA: /* read data from the device */
388 return ENODEV;
389 }
390
391 return ENOTTY;
392 }
393
394 static struct filterops smfiltops =
395 { FILTEROP_MPSAFE | FILTEROP_ISFD, NULL, smfilter_detach, smfilter };
396
397 static int
smkqfilter(struct dev_kqfilter_args * ap)398 smkqfilter(struct dev_kqfilter_args *ap)
399 {
400 struct sysmouse_state *sc = &mouse_state;
401 struct knote *kn = ap->a_kn;
402 struct klist *klist;
403
404 ap->a_result = 0;
405
406 switch (kn->kn_filter) {
407 case EVFILT_READ:
408 kn->kn_fop = &smfiltops;
409 kn->kn_hook = (caddr_t)sc;
410 break;
411 default:
412 ap->a_result = EOPNOTSUPP;
413 return (0);
414 }
415
416 klist = &sc->rkq.ki_note;
417 knote_insert(klist, kn);
418
419 return (0);
420 }
421
422 static void
smfilter_detach(struct knote * kn)423 smfilter_detach(struct knote *kn)
424 {
425 struct sysmouse_state *sc = &mouse_state;
426 struct klist *klist;
427
428 klist = &sc->rkq.ki_note;
429 knote_remove(klist, kn);
430 }
431
432 static int
smfilter(struct knote * kn,long hint)433 smfilter(struct knote *kn, long hint)
434 {
435 struct sysmouse_state *sc = &mouse_state;
436 int ready = 0;
437
438 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
439 if (sc->fifo->fill > 0) {
440 ready = 1;
441 kn->kn_data = 0;
442 }
443 lockmgr(&sc->sm_lock, LK_RELEASE);
444
445 return ready;
446 }
447
448 static void
smqueue(struct sysmouse_state * sc,mouse_info_t * info)449 smqueue(struct sysmouse_state *sc, mouse_info_t *info)
450 {
451 struct event_fifo *f = sc->fifo;
452
453 if (f->fill >= FIFO_SIZE) {
454 f->fill = FIFO_SIZE;
455 f->buf[f->start] = *info;
456 f->start = (f->start + 1) % FIFO_SIZE;
457 f->dropped++;
458 } else {
459 f->buf[(f->start + f->fill) % FIFO_SIZE] = *info;
460 f->fill++;
461 }
462
463 }
464
465 static void
smget(struct sysmouse_state * sc,mouse_info_t * info)466 smget(struct sysmouse_state *sc, mouse_info_t *info)
467 {
468 struct event_fifo *f = sc->fifo;
469
470 if (f->fill > 0)
471 *info = f->buf[f->start];
472 }
473
474 static void
smpop(struct sysmouse_state * sc)475 smpop(struct sysmouse_state *sc)
476 {
477 struct event_fifo *f = sc->fifo;
478
479 if (f->fill > 0) {
480 f->fill--;
481 f->start = (f->start + 1) % FIFO_SIZE;
482 }
483 }
484
485 static void
sm_attach_mouse(void * unused)486 sm_attach_mouse(void *unused)
487 {
488 struct sysmouse_state *sc = &mouse_state;
489 cdev_t dev;
490
491 lockinit(&mouse_state.sm_lock, "sysmouse", 0, LK_CANRECURSE);
492 sc->fifo = NULL;
493
494 dev = make_dev(&sm_ops, 0, UID_ROOT, GID_WHEEL, 0600, "sysmouse");
495 #ifdef EVDEV_SUPPORT
496 smdev_evdev_init();
497 #endif
498 }
499
500 SYSINIT(sysmouse, SI_SUB_DRIVERS, SI_ORDER_ANY, sm_attach_mouse, NULL);
501
502 static int
sysmouse_updatestatus(mousestatus_t * status,mouse_info_t * info)503 sysmouse_updatestatus(mousestatus_t *status, mouse_info_t *info)
504 {
505 int x, y, z;
506
507 status->obutton = status->button;
508
509 switch (info->operation) {
510 case MOUSE_ACTION:
511 status->button = info->u.data.buttons;
512 /* FALL THROUGH */
513 case MOUSE_MOTION_EVENT:
514 x = info->u.data.x;
515 y = info->u.data.y;
516 z = info->u.data.z;
517 break;
518 case MOUSE_BUTTON_EVENT:
519 x = y = z = 0;
520 if (info->u.event.value > 0)
521 status->button |= info->u.event.id;
522 else
523 status->button &= ~info->u.event.id;
524 break;
525 default:
526 return 0;
527 }
528
529 status->dx += x;
530 status->dy += y;
531 status->dz += z;
532 status->flags |= ((x || y || z) ? MOUSE_POSCHANGED : 0)
533 | (status->obutton ^ status->button);
534
535 #ifdef EVDEV_SUPPORT
536 smdev_evdev_write(x, y, z, status->button);
537 #endif
538
539 return 1;
540 }
541
542 /* Requires buf to hold at least 8 bytes, returns number of bytes written */
543 static int
sysmouse_evtopkt(struct sysmouse_state * sc,mouse_info_t * info,u_char * buf)544 sysmouse_evtopkt(struct sysmouse_state *sc, mouse_info_t *info, u_char *buf)
545 {
546 /* MOUSE_BUTTON?DOWN -> MOUSE_MSC_BUTTON?UP */
547 static int butmap[8] = {
548 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON3UP,
549 MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON3UP,
550 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON3UP,
551 MOUSE_MSC_BUTTON3UP,
552 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON2UP,
553 MOUSE_MSC_BUTTON2UP,
554 MOUSE_MSC_BUTTON1UP,
555 0,
556 };
557 int x, y, z;
558
559 sc->readstatus.dx = 0;
560 sc->readstatus.dy = 0;
561 sc->readstatus.dz = 0;
562 sc->readstatus.flags = 0;
563 if (sysmouse_updatestatus(&sc->readstatus, info) == 0)
564 return 0;
565
566 /* We aren't using the sc->readstatus.dx/dy/dz values */
567
568 if (sc->readstatus.flags == 0)
569 return 0;
570
571 x = (info->operation == MOUSE_BUTTON_EVENT ? 0 : info->u.data.x);
572 y = (info->operation == MOUSE_BUTTON_EVENT ? 0 : info->u.data.y);
573 z = (info->operation == MOUSE_BUTTON_EVENT ? 0 : info->u.data.z);
574
575 /* the first five bytes are compatible with MouseSystems' */
576 buf[0] = MOUSE_MSC_SYNC
577 | butmap[sc->readstatus.button & MOUSE_STDBUTTONS];
578 x = imax(imin(x, 255), -256);
579 buf[1] = x >> 1;
580 buf[3] = x - buf[1];
581 y = -imax(imin(y, 255), -256);
582 buf[2] = y >> 1;
583 buf[4] = y - buf[2];
584 if (sc->level >= 1) {
585 /* extended part */
586 z = imax(imin(z, 127), -128);
587 buf[5] = (z >> 1) & 0x7f;
588 buf[6] = (z - (z >> 1)) & 0x7f;
589 /* buttons 4-10 */
590 buf[7] = (~sc->readstatus.button >> 3) & 0x7f;
591 }
592
593 if (sc->level >= 1)
594 return 8;
595
596 return 5;
597 }
598
599 int
sysmouse_event(mouse_info_t * info)600 sysmouse_event(mouse_info_t *info)
601 {
602 struct sysmouse_state *sc = &mouse_state;
603 int ret;
604
605 lockmgr(&sc->sm_lock, LK_EXCLUSIVE);
606 ret = sysmouse_updatestatus(&sc->syncstatus, info);
607 if (ret != 0)
608 ret = sc->syncstatus.flags;
609 if (!sc->opened) {
610 lockmgr(&sc->sm_lock, LK_RELEASE);
611 return ret;
612 }
613
614 switch (info->operation) {
615 case MOUSE_ACTION:
616 case MOUSE_MOTION_EVENT:
617 case MOUSE_BUTTON_EVENT:
618 smqueue(sc, info);
619 if (sc->asyncio)
620 pgsigio(sc->sm_sigio, SIGIO, 0);
621 lockmgr(&sc->sm_lock, LK_RELEASE);
622 wakeup(sc);
623 KNOTE(&sc->rkq.ki_note, 0);
624 break;
625 default:
626 lockmgr(&sc->sm_lock, LK_RELEASE);
627 break;
628 }
629
630 return ret;
631 }
632
633 #endif /* !SC_NO_SYSMOUSE */
634