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 <sys/param.h>
37 #include <sys/condvar.h>
38 #include <sys/consio.h>
39 #include <sys/fcntl.h>
40 #include <sys/filio.h>
41 #include <sys/kernel.h>
42 #include <sys/malloc.h>
43 #include <sys/poll.h>
44 #include <sys/random.h>
45 #include <sys/selinfo.h>
46 #include <sys/sigio.h>
47 #include <sys/signalvar.h>
48 #include <sys/systm.h>
49 #include <sys/uio.h>
50
51 #include <dev/vt/vt.h>
52
53 static d_open_t sysmouse_open;
54 static d_close_t sysmouse_close;
55 static d_read_t sysmouse_read;
56 static d_ioctl_t sysmouse_ioctl;
57 static d_poll_t sysmouse_poll;
58
59 static struct cdevsw sysmouse_cdevsw = {
60 .d_version = D_VERSION,
61 .d_open = sysmouse_open,
62 .d_close = sysmouse_close,
63 .d_read = sysmouse_read,
64 .d_ioctl = sysmouse_ioctl,
65 .d_poll = sysmouse_poll,
66 .d_name = "sysmouse",
67 };
68
69 static struct mtx sysmouse_lock;
70 static struct cv sysmouse_sleep;
71 static struct selinfo sysmouse_bufpoll;
72
73 static int sysmouse_level;
74 static mousestatus_t sysmouse_status;
75 static int sysmouse_flags;
76 #define SM_ASYNC 0x1
77 static struct sigio *sysmouse_sigio;
78
79 #define SYSMOUSE_MAXFRAMES 250 /* 2 KB */
80 static MALLOC_DEFINE(M_SYSMOUSE, "sysmouse", "sysmouse device");
81 static unsigned char *sysmouse_buffer;
82 static unsigned int sysmouse_start, sysmouse_length;
83
84 static int
sysmouse_buf_read(struct uio * uio,unsigned int length)85 sysmouse_buf_read(struct uio *uio, unsigned int length)
86 {
87 unsigned char buf[MOUSE_SYS_PACKETSIZE];
88 int error;
89
90 if (sysmouse_buffer == NULL)
91 return (ENXIO);
92 else if (sysmouse_length == 0)
93 return (EWOULDBLOCK);
94
95 memcpy(buf, sysmouse_buffer +
96 sysmouse_start * MOUSE_SYS_PACKETSIZE, MOUSE_SYS_PACKETSIZE);
97 sysmouse_start = (sysmouse_start + 1) % SYSMOUSE_MAXFRAMES;
98 sysmouse_length--;
99
100 mtx_unlock(&sysmouse_lock);
101 error = uiomove(buf, length, uio);
102 mtx_lock(&sysmouse_lock);
103
104 return (error);
105 }
106
107 static void
sysmouse_buf_store(const unsigned char buf[MOUSE_SYS_PACKETSIZE])108 sysmouse_buf_store(const unsigned char buf[MOUSE_SYS_PACKETSIZE])
109 {
110 unsigned int idx;
111
112 if (sysmouse_buffer == NULL || sysmouse_length == SYSMOUSE_MAXFRAMES)
113 return;
114
115 idx = (sysmouse_start + sysmouse_length) % SYSMOUSE_MAXFRAMES;
116 memcpy(sysmouse_buffer + idx * MOUSE_SYS_PACKETSIZE, buf,
117 MOUSE_SYS_PACKETSIZE);
118 sysmouse_length++;
119 cv_broadcast(&sysmouse_sleep);
120 selwakeup(&sysmouse_bufpoll);
121 if (sysmouse_flags & SM_ASYNC && sysmouse_sigio != NULL)
122 pgsigio(&sysmouse_sigio, SIGIO, 0);
123 }
124
125 void
sysmouse_process_event(mouse_info_t * mi)126 sysmouse_process_event(mouse_info_t *mi)
127 {
128 /* MOUSE_BUTTON?DOWN -> MOUSE_MSC_BUTTON?UP */
129 static const int buttonmap[8] = {
130 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON3UP,
131 MOUSE_MSC_BUTTON2UP | MOUSE_MSC_BUTTON3UP,
132 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON3UP,
133 MOUSE_MSC_BUTTON3UP,
134 MOUSE_MSC_BUTTON1UP | MOUSE_MSC_BUTTON2UP,
135 MOUSE_MSC_BUTTON2UP,
136 MOUSE_MSC_BUTTON1UP,
137 0,
138 };
139 unsigned char buf[MOUSE_SYS_PACKETSIZE];
140 int x, y, iy, z;
141
142 random_harvest_queue(mi, sizeof *mi, 2, RANDOM_MOUSE);
143
144 mtx_lock(&sysmouse_lock);
145 switch (mi->operation) {
146 case MOUSE_ACTION:
147 sysmouse_status.button = mi->u.data.buttons;
148 /* FALLTHROUGH */
149 case MOUSE_MOTION_EVENT:
150 x = mi->u.data.x;
151 y = mi->u.data.y;
152 z = mi->u.data.z;
153 break;
154 case MOUSE_BUTTON_EVENT:
155 x = y = z = 0;
156 if (mi->u.event.value > 0)
157 sysmouse_status.button |= mi->u.event.id;
158 else
159 sysmouse_status.button &= ~mi->u.event.id;
160 break;
161 default:
162 goto done;
163 }
164
165 sysmouse_status.dx += x;
166 sysmouse_status.dy += y;
167 sysmouse_status.dz += z;
168 sysmouse_status.flags |= ((x || y || z) ? MOUSE_POSCHANGED : 0) |
169 (sysmouse_status.obutton ^ sysmouse_status.button);
170 if (sysmouse_status.flags == 0)
171 goto done;
172
173
174 /* The first five bytes are compatible with MouseSystems. */
175 buf[0] = MOUSE_MSC_SYNC |
176 buttonmap[sysmouse_status.button & MOUSE_STDBUTTONS];
177 x = imax(imin(x, 255), -256);
178 buf[1] = x >> 1;
179 buf[3] = x - buf[1];
180 iy = -imax(imin(y, 255), -256);
181 buf[2] = iy >> 1;
182 buf[4] = iy - buf[2];
183 /* Extended part. */
184 z = imax(imin(z, 127), -128);
185 buf[5] = (z >> 1) & 0x7f;
186 buf[6] = (z - (z >> 1)) & 0x7f;
187 /* Buttons 4-10. */
188 buf[7] = (~sysmouse_status.button >> 3) & 0x7f;
189
190 sysmouse_buf_store(buf);
191
192 #ifndef SC_NO_CUTPASTE
193 mtx_unlock(&sysmouse_lock);
194 vt_mouse_event(mi->operation, x, y, mi->u.event.id, mi->u.event.value,
195 sysmouse_level);
196 return;
197 #endif
198
199 done: mtx_unlock(&sysmouse_lock);
200 }
201
202 static int
sysmouse_open(struct cdev * dev,int oflags,int devtype,struct thread * td)203 sysmouse_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
204 {
205 void *buf;
206
207 buf = malloc(MOUSE_SYS_PACKETSIZE * SYSMOUSE_MAXFRAMES,
208 M_SYSMOUSE, M_WAITOK);
209 mtx_lock(&sysmouse_lock);
210 if (sysmouse_buffer == NULL) {
211 sysmouse_buffer = buf;
212 sysmouse_start = sysmouse_length = 0;
213 sysmouse_level = 0;
214 } else {
215 free(buf, M_SYSMOUSE);
216 }
217 mtx_unlock(&sysmouse_lock);
218
219 return (0);
220 }
221
222 static int
sysmouse_close(struct cdev * dev,int fflag,int devtype,struct thread * td)223 sysmouse_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
224 {
225
226 mtx_lock(&sysmouse_lock);
227 free(sysmouse_buffer, M_SYSMOUSE);
228 sysmouse_buffer = NULL;
229 sysmouse_level = 0;
230 mtx_unlock(&sysmouse_lock);
231
232 return (0);
233 }
234
235 static int
sysmouse_read(struct cdev * dev,struct uio * uio,int ioflag)236 sysmouse_read(struct cdev *dev, struct uio *uio, int ioflag)
237 {
238 unsigned int length;
239 ssize_t oresid;
240 int error = 0;
241
242 oresid = uio->uio_resid;
243
244 mtx_lock(&sysmouse_lock);
245 length = sysmouse_level >= 1 ? MOUSE_SYS_PACKETSIZE :
246 MOUSE_MSC_PACKETSIZE;
247
248 while (uio->uio_resid >= length) {
249 error = sysmouse_buf_read(uio, length);
250 if (error == 0) {
251 /* Process the next frame. */
252 continue;
253 } else if (error != EWOULDBLOCK) {
254 /* Error (e.g. EFAULT). */
255 break;
256 } else {
257 /* Block. */
258 if (oresid != uio->uio_resid || ioflag & O_NONBLOCK)
259 break;
260 error = cv_wait_sig(&sysmouse_sleep, &sysmouse_lock);
261 if (error != 0)
262 break;
263 }
264 }
265 mtx_unlock(&sysmouse_lock);
266
267 return (error);
268 }
269
270 static int
sysmouse_ioctl(struct cdev * dev,u_long cmd,caddr_t data,int flag,struct thread * td)271 sysmouse_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag,
272 struct thread *td)
273 {
274
275 switch (cmd) {
276 case FIOASYNC:
277 mtx_lock(&sysmouse_lock);
278 if (*(int *)data)
279 sysmouse_flags |= SM_ASYNC;
280 else
281 sysmouse_flags &= ~SM_ASYNC;
282 mtx_unlock(&sysmouse_lock);
283 return (0);
284 case FIONBIO:
285 return (0);
286 case FIOGETOWN:
287 *(int *)data = fgetown(&sysmouse_sigio);
288 return (0);
289 case FIOSETOWN:
290 return (fsetown(*(int *)data, &sysmouse_sigio));
291 case MOUSE_GETHWINFO: {
292 mousehw_t *hw = (mousehw_t *)data;
293
294 hw->buttons = 10;
295 hw->iftype = MOUSE_IF_SYSMOUSE;
296 hw->type = MOUSE_MOUSE;
297 hw->model = MOUSE_MODEL_GENERIC;
298 hw->hwid = 0;
299
300 return (0);
301 }
302 case MOUSE_GETLEVEL:
303 *(int *)data = sysmouse_level;
304 return (0);
305 case MOUSE_GETMODE: {
306 mousemode_t *mode = (mousemode_t *)data;
307
308 mode->rate = -1;
309 mode->resolution = -1;
310 mode->accelfactor = 0;
311 mode->level = sysmouse_level;
312
313 switch (mode->level) {
314 case 0:
315 mode->protocol = MOUSE_PROTO_MSC;
316 mode->packetsize = MOUSE_MSC_PACKETSIZE;
317 mode->syncmask[0] = MOUSE_MSC_SYNCMASK;
318 mode->syncmask[1] = MOUSE_MSC_SYNC;
319 break;
320 case 1:
321 mode->protocol = MOUSE_PROTO_SYSMOUSE;
322 mode->packetsize = MOUSE_SYS_PACKETSIZE;
323 mode->syncmask[0] = MOUSE_SYS_SYNCMASK;
324 mode->syncmask[1] = MOUSE_SYS_SYNC;
325 break;
326 }
327
328 return (0);
329 }
330 case MOUSE_GETSTATUS:
331 mtx_lock(&sysmouse_lock);
332 *(mousestatus_t *)data = sysmouse_status;
333
334 sysmouse_status.flags = 0;
335 sysmouse_status.obutton = sysmouse_status.button;
336 sysmouse_status.dx = 0;
337 sysmouse_status.dy = 0;
338 sysmouse_status.dz = 0;
339 mtx_unlock(&sysmouse_lock);
340
341 return (0);
342 case MOUSE_SETLEVEL: {
343 int level;
344
345 level = *(int *)data;
346 if (level != 0 && level != 1)
347 return (EINVAL);
348
349 sysmouse_level = level;
350 return (0);
351 }
352 case MOUSE_SETMODE: {
353 mousemode_t *mode = (mousemode_t *)data;
354
355 switch (mode->level) {
356 case -1:
357 /* Do nothing. */
358 break;
359 case 0:
360 case 1:
361 sysmouse_level = mode->level;
362 break;
363 default:
364 return (EINVAL);
365 }
366
367 return (0);
368 }
369 case MOUSE_MOUSECHAR:
370 return (0);
371 default:
372 #ifdef VT_SYSMOUSE_DEBUG
373 printf("sysmouse: unknown ioctl: %c:%lx\n",
374 (char)IOCGROUP(cmd), IOCBASECMD(cmd));
375 #endif
376 return (ENOIOCTL);
377 }
378 }
379
380 static int
sysmouse_poll(struct cdev * dev,int events,struct thread * td)381 sysmouse_poll(struct cdev *dev, int events, struct thread *td)
382 {
383 int revents = 0;
384
385 mtx_lock(&sysmouse_lock);
386 if (events & (POLLIN|POLLRDNORM)) {
387 if (sysmouse_length > 0)
388 revents = events & (POLLIN|POLLRDNORM);
389 else
390 selrecord(td, &sysmouse_bufpoll);
391 }
392 mtx_unlock(&sysmouse_lock);
393
394 return (revents);
395 }
396
397 static void
sysmouse_drvinit(void * unused)398 sysmouse_drvinit(void *unused)
399 {
400
401 if (!vty_enabled(VTY_VT))
402 return;
403 mtx_init(&sysmouse_lock, "sysmouse", NULL, MTX_DEF);
404 cv_init(&sysmouse_sleep, "sysmrd");
405 make_dev(&sysmouse_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
406 "sysmouse");
407 }
408
409 SYSINIT(sysmouse, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, sysmouse_drvinit, NULL);
410