vt_sysmouse.c revision 262861 
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: stable/10/sys/dev/vt/vt_sysmouse.c 262861 2014-03-06 18:30:56Z jhb $");
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
53static d_open_t		sysmouse_open;
54static d_close_t	sysmouse_close;
55static d_read_t		sysmouse_read;
56static d_ioctl_t	sysmouse_ioctl;
57static d_poll_t		sysmouse_poll;
58
59static 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
69static struct mtx	 sysmouse_lock;
70static struct cv	 sysmouse_sleep;
71static struct selinfo	 sysmouse_bufpoll;
72
73static int		 sysmouse_level;
74static mousestatus_t	 sysmouse_status;
75static int		 sysmouse_flags;
76#define	SM_ASYNC	0x1
77static struct sigio	*sysmouse_sigio;
78
79#define	SYSMOUSE_MAXFRAMES	250	/* 2 KB */
80static MALLOC_DEFINE(M_SYSMOUSE, "sysmouse", "sysmouse device");
81static unsigned char	*sysmouse_buffer;
82static unsigned int	 sysmouse_start, sysmouse_length;
83
84static int
85sysmouse_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
107static void
108sysmouse_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
125void
126sysmouse_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(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
199done:	mtx_unlock(&sysmouse_lock);
200}
201
202static int
203sysmouse_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
222static int
223sysmouse_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
235static int
236sysmouse_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
270static int
271sysmouse_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#ifndef SC_NO_CUTPASTE
351		vt_mouse_state((level == 0)?VT_MOUSE_SHOW:VT_MOUSE_HIDE);
352#endif
353		return (0);
354	}
355	case MOUSE_SETMODE: {
356		mousemode_t *mode = (mousemode_t *)data;
357
358		switch (mode->level) {
359		case -1:
360			/* Do nothing. */
361			break;
362		case 0:
363		case 1:
364			sysmouse_level = mode->level;
365#ifndef SC_NO_CUTPASTE
366			vt_mouse_state((mode->level == 0)?VT_MOUSE_SHOW:
367			    VT_MOUSE_HIDE);
368#endif
369			break;
370		default:
371			return (EINVAL);
372		}
373
374		return (0);
375	}
376	case MOUSE_MOUSECHAR:
377		return (0);
378	default:
379		printf("sysmouse: unknown ioctl: %c:%lx\n",
380		    (char)IOCGROUP(cmd), IOCBASECMD(cmd));
381		return (ENOIOCTL);
382	}
383}
384
385static int
386sysmouse_poll(struct cdev *dev, int events, struct thread *td)
387{
388	int revents = 0;
389
390	mtx_lock(&sysmouse_lock);
391	if (events & (POLLIN|POLLRDNORM)) {
392		if (sysmouse_length > 0)
393			revents = events & (POLLIN|POLLRDNORM);
394		else
395			selrecord(td, &sysmouse_bufpoll);
396	}
397	mtx_unlock(&sysmouse_lock);
398
399	return (revents);
400}
401
402static void
403sysmouse_drvinit(void *unused)
404{
405
406	mtx_init(&sysmouse_lock, "sysmouse", NULL, MTX_DEF);
407	cv_init(&sysmouse_sleep, "sysmrd");
408	make_dev(&sysmouse_cdevsw, 0, UID_ROOT, GID_WHEEL, 0600,
409	    "sysmouse");
410}
411
412SYSINIT(sysmouse, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, sysmouse_drvinit, NULL);
413