1 /*-
2 * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
3 * All rights reserved.
4 *
5 * Copyright (c) 2009 The FreeBSD Foundation
6 * All rights reserved.
7 *
8 * This software was developed by Ed Schouten under sponsorship from the
9 * FreeBSD Foundation.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35
36 #include "opt_evdev.h"
37
38 #include <sys/param.h>
39 #include <sys/condvar.h>
40 #include <sys/consio.h>
41 #include <sys/fcntl.h>
42 #include <sys/filio.h>
43 #include <sys/kernel.h>
44 #include <sys/malloc.h>
45 #include <sys/poll.h>
46 #include <sys/random.h>
47 #include <sys/selinfo.h>
48 #include <sys/sigio.h>
49 #include <sys/signalvar.h>
50 #include <sys/systm.h>
51 #include <sys/uio.h>
52
53 #include <dev/vt/vt.h>
54
55 #ifdef EVDEV_SUPPORT
56 #include <dev/evdev/input.h>
57 #include <dev/evdev/evdev.h>
58 #endif
59
60 static d_open_t sysmouse_open;
61 static d_close_t sysmouse_close;
62 static d_read_t sysmouse_read;
63 static d_ioctl_t sysmouse_ioctl;
64 static d_poll_t sysmouse_poll;
65
66 static struct cdevsw sysmouse_cdevsw = {
67 .d_version = D_VERSION,
68 .d_open = sysmouse_open,
69 .d_close = sysmouse_close,
70 .d_read = sysmouse_read,
71 .d_ioctl = sysmouse_ioctl,
72 .d_poll = sysmouse_poll,
73 .d_name = "sysmouse",
74 };
75
76 static struct mtx sysmouse_lock;
77 static struct cv sysmouse_sleep;
78 static struct selinfo sysmouse_bufpoll;
79
80 static int sysmouse_level;
81 static mousestatus_t sysmouse_status;
82 static int sysmouse_flags;
83 #define SM_ASYNC 0x1
84 static struct sigio *sysmouse_sigio;
85
86 #define SYSMOUSE_MAXFRAMES 250 /* 2 KB */
87 static MALLOC_DEFINE(M_SYSMOUSE, "sysmouse", "sysmouse device");
88 static unsigned char *sysmouse_buffer;
89 static unsigned int sysmouse_start, sysmouse_length;
90
91 #ifdef EVDEV_SUPPORT
92 static struct evdev_dev *sysmouse_evdev;
93
94 static void
sysmouse_evdev_init(void)95 sysmouse_evdev_init(void)
96 {
97 int i;
98
99 sysmouse_evdev = evdev_alloc();
100 evdev_set_name(sysmouse_evdev, "System mouse");
101 evdev_set_phys(sysmouse_evdev, "sysmouse");
102 evdev_set_id(sysmouse_evdev, BUS_VIRTUAL, 0, 0, 0);
103 evdev_support_prop(sysmouse_evdev, INPUT_PROP_POINTER);
104 evdev_support_event(sysmouse_evdev, EV_SYN);
105 evdev_support_event(sysmouse_evdev, EV_REL);
106 evdev_support_event(sysmouse_evdev, EV_KEY);
107 evdev_support_rel(sysmouse_evdev, REL_X);
108 evdev_support_rel(sysmouse_evdev, REL_Y);
109 evdev_support_rel(sysmouse_evdev, REL_WHEEL);
110 evdev_support_rel(sysmouse_evdev, REL_HWHEEL);
111 for (i = 0; i < 8; i++)
112 evdev_support_key(sysmouse_evdev, BTN_MOUSE + i);
113 if (evdev_register(sysmouse_evdev)) {
114 evdev_free(sysmouse_evdev);
115 sysmouse_evdev = NULL;
116 }
117 }
118
119 static void
sysmouse_evdev_store(int x,int y,int z,int buttons)120 sysmouse_evdev_store(int x, int y, int z, int buttons)
121 {
122
123 if (sysmouse_evdev == NULL || !(evdev_rcpt_mask & EVDEV_RCPT_SYSMOUSE))
124 return;
125
126 evdev_push_event(sysmouse_evdev, EV_REL, REL_X, x);
127 evdev_push_event(sysmouse_evdev, EV_REL, REL_Y, y);
128 switch (evdev_sysmouse_t_axis) {
129 case EVDEV_SYSMOUSE_T_AXIS_PSM:
130 switch (z) {
131 case 1:
132 case -1:
133 evdev_push_rel(sysmouse_evdev, REL_WHEEL, -z);
134 break;
135 case 2:
136 case -2:
137 evdev_push_rel(sysmouse_evdev, REL_HWHEEL, z / 2);
138 break;
139 }
140 break;
141 case EVDEV_SYSMOUSE_T_AXIS_UMS:
142 if (buttons & (1 << 6))
143 evdev_push_rel(sysmouse_evdev, REL_HWHEEL, 1);
144 else if (buttons & (1 << 5))
145 evdev_push_rel(sysmouse_evdev, REL_HWHEEL, -1);
146 buttons &= ~((1 << 5)|(1 << 6));
147 /* PASSTHROUGH */
148 case EVDEV_SYSMOUSE_T_AXIS_NONE:
149 default:
150 evdev_push_rel(sysmouse_evdev, REL_WHEEL, -z);
151 }
152 evdev_push_mouse_btn(sysmouse_evdev, buttons);
153 evdev_sync(sysmouse_evdev);
154 }
155 #endif
156
157 static int
sysmouse_buf_read(struct uio * uio,unsigned int length)158 sysmouse_buf_read(struct uio *uio, unsigned int length)
159 {
160 unsigned char buf[MOUSE_SYS_PACKETSIZE];
161 int error;
162
163 if (sysmouse_buffer == NULL)
164 return (ENXIO);
165 else if (sysmouse_length == 0)
166 return (EWOULDBLOCK);
167
168 memcpy(buf, sysmouse_buffer +
169 sysmouse_start * MOUSE_SYS_PACKETSIZE, MOUSE_SYS_PACKETSIZE);
170 sysmouse_start = (sysmouse_start + 1) % SYSMOUSE_MAXFRAMES;
171 sysmouse_length--;
172
173 mtx_unlock(&sysmouse_lock);
174 error = uiomove(buf, length, uio);
175 mtx_lock(&sysmouse_lock);
176
177 return (error);
178 }
179
180 static void
sysmouse_buf_store(const unsigned char buf[MOUSE_SYS_PACKETSIZE])181 sysmouse_buf_store(const unsigned char buf[MOUSE_SYS_PACKETSIZE])
182 {
183 unsigned int idx;
184
185 if (sysmouse_buffer == NULL || sysmouse_length == SYSMOUSE_MAXFRAMES)
186 return;
187
188 idx = (sysmouse_start + sysmouse_length) % SYSMOUSE_MAXFRAMES;
189 memcpy(sysmouse_buffer + idx * MOUSE_SYS_PACKETSIZE, buf,
190 MOUSE_SYS_PACKETSIZE);
191 sysmouse_length++;
192 cv_broadcast(&sysmouse_sleep);
193 selwakeup(&sysmouse_bufpoll);
194 if (sysmouse_flags & SM_ASYNC && sysmouse_sigio != NULL)
195 pgsigio(&sysmouse_sigio, SIGIO, 0);
196 }
197
198 void
sysmouse_process_event(mouse_info_t * mi)199 sysmouse_process_event(mouse_info_t *mi)
200 {
201 /* MOUSE_BUTTON?DOWN -> MOUSE_MSC_BUTTON?UP */
202 static const int buttonmap[8] = {
203 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON3UP,
204 MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON3UP,
205 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON3UP,
206 MOUSE_MSC_BUTTON3UP,
207 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON2UP,
208 MOUSE_MSC_BUTTON2UP,
209 MOUSE_MSC_BUTTON1UP,
210 0,
211 };
212 unsigned char buf[MOUSE_SYS_PACKETSIZE];
213 int x, y, iy, z;
214
215 random_harvest_queue(mi, sizeof *mi, 2, RANDOM_MOUSE);
216
217 mtx_lock(&sysmouse_lock);
218 switch (mi->operation) {
219 case MOUSE_ACTION:
220 sysmouse_status.button = mi->u.data.buttons;
221 /* FALLTHROUGH */
222 case MOUSE_MOTION_EVENT:
223 x = mi->u.data.x;
224 y = mi->u.data.y;
225 z = mi->u.data.z;
226 break;
227 case MOUSE_BUTTON_EVENT:
228 x = y = z = 0;
229 if (mi->u.event.value > 0)
230 sysmouse_status.button |= mi->u.event.id;
231 else
232 sysmouse_status.button &= ~mi->u.event.id;
233 break;
234 default:
235 goto done;
236 }
237
238 sysmouse_status.dx += x;
239 sysmouse_status.dy += y;
240 sysmouse_status.dz += z;
241 sysmouse_status.flags |= ((x || y || z) ? MOUSE_POSCHANGED : 0) |
242 (sysmouse_status.obutton ^ sysmouse_status.button);
243 if (sysmouse_status.flags == 0)
244 goto done;
245
246 #ifdef EVDEV_SUPPORT
247 sysmouse_evdev_store(x, y, z, sysmouse_status.button);
248 #endif
249
250 /* The first five bytes are compatible with MouseSystems. */
251 buf[0] = MOUSE_MSC_SYNC |
252 buttonmap[sysmouse_status.button & MOUSE_STDBUTTONS];
253 x = imax(imin(x, 255), -256);
254 buf[1] = x >> 1;
255 buf[3] = x - buf[1];
256 iy = -imax(imin(y, 255), -256);
257 buf[2] = iy >> 1;
258 buf[4] = iy - buf[2];
259 /* Extended part. */
260 z = imax(imin(z, 127), -128);
261 buf[5] = (z >> 1) & 0x7f;
262 buf[6] = (z - (z >> 1)) & 0x7f;
263 /* Buttons 4-10. */
264 buf[7] = (~sysmouse_status.button >> 3) & 0x7f;
265
266 sysmouse_buf_store(buf);
267
268 #ifndef SC_NO_CUTPASTE
269 mtx_unlock(&sysmouse_lock);
270 vt_mouse_event(mi->operation, x, y, mi->u.event.id, mi->u.event.value,
271 sysmouse_level);
272 return;
273 #endif
274
275 done: mtx_unlock(&sysmouse_lock);
276 }
277
278 static int
sysmouse_open(struct cdev * dev,int oflags,int devtype,struct thread * td)279 sysmouse_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
280 {
281 void *buf;
282
283 buf = malloc(MOUSE_SYS_PACKETSIZE * SYSMOUSE_MAXFRAMES,
284 M_SYSMOUSE, M_WAITOK);
285 mtx_lock(&sysmouse_lock);
286 if (sysmouse_buffer == NULL) {
287 sysmouse_buffer = buf;
288 sysmouse_start = sysmouse_length = 0;
289 sysmouse_level = 0;
290 } else {
291 free(buf, M_SYSMOUSE);
292 }
293 mtx_unlock(&sysmouse_lock);
294
295 return (0);
296 }
297
298 static int
sysmouse_close(struct cdev * dev,int fflag,int devtype,struct thread * td)299 sysmouse_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
300 {
301
302 mtx_lock(&sysmouse_lock);
303 free(sysmouse_buffer, M_SYSMOUSE);
304 sysmouse_buffer = NULL;
305 sysmouse_level = 0;
306 mtx_unlock(&sysmouse_lock);
307
308 return (0);
309 }
310
311 static int
sysmouse_read(struct cdev * dev,struct uio * uio,int ioflag)312 sysmouse_read(struct cdev *dev, struct uio *uio, int ioflag)
313 {
314 unsigned int length;
315 ssize_t oresid;
316 int error = 0;
317
318 oresid = uio->uio_resid;
319
320 mtx_lock(&sysmouse_lock);
321 length = sysmouse_level >= 1 ? MOUSE_SYS_PACKETSIZE :
322 MOUSE_MSC_PACKETSIZE;
323
324 while (uio->uio_resid >= length) {
325 error = sysmouse_buf_read(uio, length);
326 if (error == 0) {
327 /* Process the next frame. */
328 continue;
329 } else if (error != EWOULDBLOCK) {
330 /* Error (e.g. EFAULT). */
331 break;
332 } else {
333 /* Block. */
334 if (oresid != uio->uio_resid || ioflag & O_NONBLOCK)
335 break;
336 error = cv_wait_sig(&sysmouse_sleep, &sysmouse_lock);
337 if (error != 0)
338 break;
339 }
340 }
341 mtx_unlock(&sysmouse_lock);
342
343 return (error);
344 }
345
346 static int
sysmouse_ioctl(struct cdev * dev,u_long cmd,caddr_t data,int flag,struct thread * td)347 sysmouse_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag,
348 struct thread *td)
349 {
350
351 switch (cmd) {
352 case FIOASYNC:
353 mtx_lock(&sysmouse_lock);
354 if (*(int *)data)
355 sysmouse_flags |= SM_ASYNC;
356 else
357 sysmouse_flags &= ~SM_ASYNC;
358 mtx_unlock(&sysmouse_lock);
359 return (0);
360 case FIONBIO:
361 return (0);
362 case FIOGETOWN:
363 *(int *)data = fgetown(&sysmouse_sigio);
364 return (0);
365 case FIOSETOWN:
366 return (fsetown(*(int *)data, &sysmouse_sigio));
367 case MOUSE_GETHWINFO: {
368 mousehw_t *hw = (mousehw_t *)data;
369
370 hw->buttons = 10;
371 hw->iftype = MOUSE_IF_SYSMOUSE;
372 hw->type = MOUSE_MOUSE;
373 hw->model = MOUSE_MODEL_GENERIC;
374 hw->hwid = 0;
375
376 return (0);
377 }
378 case MOUSE_GETLEVEL:
379 *(int *)data = sysmouse_level;
380 return (0);
381 case MOUSE_GETMODE: {
382 mousemode_t *mode = (mousemode_t *)data;
383
384 mode->rate = -1;
385 mode->resolution = -1;
386 mode->accelfactor = 0;
387 mode->level = sysmouse_level;
388
389 switch (mode->level) {
390 case 0:
391 mode->protocol = MOUSE_PROTO_MSC;
392 mode->packetsize = MOUSE_MSC_PACKETSIZE;
393 mode->syncmask[0] = MOUSE_MSC_SYNCMASK;
394 mode->syncmask[1] = MOUSE_MSC_SYNC;
395 break;
396 case 1:
397 mode->protocol = MOUSE_PROTO_SYSMOUSE;
398 mode->packetsize = MOUSE_SYS_PACKETSIZE;
399 mode->syncmask[0] = MOUSE_SYS_SYNCMASK;
400 mode->syncmask[1] = MOUSE_SYS_SYNC;
401 break;
402 }
403
404 return (0);
405 }
406 case MOUSE_GETSTATUS:
407 mtx_lock(&sysmouse_lock);
408 *(mousestatus_t *)data = sysmouse_status;
409
410 sysmouse_status.flags = 0;
411 sysmouse_status.obutton = sysmouse_status.button;
412 sysmouse_status.dx = 0;
413 sysmouse_status.dy = 0;
414 sysmouse_status.dz = 0;
415 mtx_unlock(&sysmouse_lock);
416
417 return (0);
418 case MOUSE_SETLEVEL: {
419 int level;
420
421 level = *(int *)data;
422 if (level != 0 && level != 1)
423 return (EINVAL);
424
425 sysmouse_level = level;
426 return (0);
427 }
428 case MOUSE_SETMODE: {
429 mousemode_t *mode = (mousemode_t *)data;
430
431 switch (mode->level) {
432 case -1:
433 /* Do nothing. */
434 break;
435 case 0:
436 case 1:
437 sysmouse_level = mode->level;
438 break;
439 default:
440 return (EINVAL);
441 }
442
443 return (0);
444 }
445 case MOUSE_MOUSECHAR:
446 return (0);
447 default:
448 #ifdef VT_SYSMOUSE_DEBUG
449 printf("sysmouse: unknown ioctl: %c:%lx\n",
450 (char)IOCGROUP(cmd), IOCBASECMD(cmd));
451 #endif
452 return (ENOIOCTL);
453 }
454 }
455
456 static int
sysmouse_poll(struct cdev * dev,int events,struct thread * td)457 sysmouse_poll(struct cdev *dev, int events, struct thread *td)
458 {
459 int revents = 0;
460
461 mtx_lock(&sysmouse_lock);
462 if (events & (POLLIN|POLLRDNORM)) {
463 if (sysmouse_length > 0)
464 revents = events & (POLLIN|POLLRDNORM);
465 else
466 selrecord(td, &sysmouse_bufpoll);
467 }
468 mtx_unlock(&sysmouse_lock);
469
470 return (revents);
471 }
472
473 static void
sysmouse_drvinit(void * unused)474 sysmouse_drvinit(void *unused)
475 {
476
477 if (!vty_enabled(VTY_VT))
478 return;
479 mtx_init(&sysmouse_lock, "sysmouse", NULL, MTX_DEF);
480 cv_init(&sysmouse_sleep, "sysmrd");
481 make_dev(&sysmouse_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
482 "sysmouse");
483 #ifdef EVDEV_SUPPORT
484 sysmouse_evdev_init();
485 #endif
486 }
487
488 SYSINIT(sysmouse, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, sysmouse_drvinit, NULL);
489