2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (C) 2008 Nathan Whitehorn
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 #include <sys/cdefs.h>
31 #include <sys/param.h>
32 #include <sys/systm.h>
34 #include <sys/module.h>
35 #include <sys/mutex.h>
38 #include <sys/mouse.h>
40 #include <sys/condvar.h>
41 #include <sys/selinfo.h>
42 #include <sys/sysctl.h>
44 #include <sys/fcntl.h>
45 #include <sys/kernel.h>
47 #include <machine/bus.h>
54 #define CDEV_GET_SOFTC(x) (x)->si_drv1
56 static int adb_mouse_probe(device_t dev);
57 static int adb_mouse_attach(device_t dev);
58 static int adb_mouse_detach(device_t dev);
59 static void adb_init_trackpad(device_t dev);
60 static int adb_tapping_sysctl(SYSCTL_HANDLER_ARGS);
62 static d_open_t ams_open;
63 static d_close_t ams_close;
64 static d_read_t ams_read;
65 static d_ioctl_t ams_ioctl;
66 static d_poll_t ams_poll;
68 static u_int adb_mouse_receive_packet(device_t dev, u_char status,
69 u_char command, u_char reg, int len, u_char *data);
71 struct adb_mouse_softc {
78 #define AMS_EXTENDED 0x1
79 #define AMS_TOUCHPAD 0x2
93 size_t packet_read_len;
99 static device_method_t adb_mouse_methods[] = {
100 /* Device interface */
101 DEVMETHOD(device_probe, adb_mouse_probe),
102 DEVMETHOD(device_attach, adb_mouse_attach),
103 DEVMETHOD(device_detach, adb_mouse_detach),
104 DEVMETHOD(device_shutdown, bus_generic_shutdown),
105 DEVMETHOD(device_suspend, bus_generic_suspend),
106 DEVMETHOD(device_resume, bus_generic_resume),
109 DEVMETHOD(adb_receive_packet, adb_mouse_receive_packet),
114 static driver_t adb_mouse_driver = {
117 sizeof(struct adb_mouse_softc),
120 static devclass_t adb_mouse_devclass;
122 DRIVER_MODULE(ams, adb, adb_mouse_driver, adb_mouse_devclass, 0, 0);
124 static struct cdevsw ams_cdevsw = {
125 .d_version = D_VERSION,
128 .d_close = ams_close,
130 .d_ioctl = ams_ioctl,
136 adb_mouse_probe(device_t dev)
140 type = adb_get_device_type(dev);
142 if (type != ADB_DEVICE_MOUSE)
145 device_set_desc(dev,"ADB Mouse");
150 adb_mouse_attach(device_t dev)
152 struct adb_mouse_softc *sc;
153 char *description = "Unknown Pointing Device";
158 sc = device_get_softc(dev);
161 mtx_init(&sc->sc_mtx, "ams", NULL, MTX_DEF);
162 cv_init(&sc->sc_cv,"ams");
167 sc->hw.iftype = MOUSE_IF_UNKNOWN;
168 sc->hw.type = MOUSE_UNKNOWN;
169 sc->hw.model = sc->hw.hwid = 0;
171 sc->mode.protocol = MOUSE_PROTO_SYSMOUSE;
173 sc->mode.resolution = 100;
174 sc->mode.accelfactor = 0;
176 sc->mode.packetsize = 5;
181 sc->last_buttons = 0;
182 sc->packet_read_len = 0;
184 /* Try to switch to extended protocol */
185 adb_set_device_handler(dev,4);
187 switch(adb_get_device_handler(dev)) {
189 sc->mode.resolution = 100;
192 sc->mode.resolution = 200;
195 r1_len = adb_read_register(dev,1,r1);
199 sc->flags |= AMS_EXTENDED;
200 memcpy(&sc->hw.hwid,r1,4);
201 sc->mode.resolution = (r1[4] << 8) | r1[5];
205 sc->hw.type = MOUSE_PAD;
206 description = "Tablet";
209 sc->hw.type = MOUSE_MOUSE;
210 description = "Mouse";
213 sc->hw.type = MOUSE_TRACKBALL;
214 description = "Trackball";
217 sc->flags |= AMS_TOUCHPAD;
218 sc->hw.type = MOUSE_PAD;
219 adb_init_trackpad(dev);
220 description = "Touchpad";
224 sc->hw.buttons = r1[7];
226 device_printf(dev,"%d-button %d-dpi %s\n",
227 sc->hw.buttons, sc->mode.resolution,description);
230 * Check for one of MacAlly's non-compliant 2-button mice.
231 * These claim to speak the extended mouse protocol, but
232 * instead speak the standard protocol and only when their
233 * handler is set to 0x42.
236 if (sc->hw.hwid == 0x4b4f4954) {
237 adb_set_device_handler(dev,0x42);
239 if (adb_get_device_handler(dev) == 0x42) {
240 device_printf(dev, "MacAlly 2-Button Mouse\n");
241 sc->flags &= ~AMS_EXTENDED;
248 sc->cdev = make_dev(&ams_cdevsw, device_get_unit(dev),
249 UID_ROOT, GID_OPERATOR, 0644, "ams%d",
250 device_get_unit(dev));
251 sc->cdev->si_drv1 = sc;
253 adb_set_autopoll(dev,1);
259 adb_mouse_detach(device_t dev)
261 struct adb_mouse_softc *sc;
263 adb_set_autopoll(dev,0);
265 sc = device_get_softc(dev);
266 destroy_dev(sc->cdev);
268 mtx_destroy(&sc->sc_mtx);
269 cv_destroy(&sc->sc_cv);
275 adb_init_trackpad(device_t dev)
277 struct adb_mouse_softc *sc;
278 struct sysctl_ctx_list *ctx;
279 struct sysctl_oid *tree;
285 sc = device_get_softc(dev);
287 r1_len = adb_read_register(dev, 1, r1);
289 /* An Extended Mouse register1 must return 8 bytes. */
297 adb_write_register(dev, 1, 8, r1);
299 r1_len = adb_read_register(dev, 1, r1);
303 device_printf(dev, "ADB Mouse = 0x%x "
304 "(non-Extended Mode)\n", r1[6]);
307 device_printf(dev, "ADB Mouse = 0x%x "
308 "(Extended Mode)\n", r1[6]);
310 /* Set ADB Extended Features to default values,
312 r2[0] = 0x19; /* Clicking: 0x19 disabled 0x99 enabled */
313 r2[1] = 0x94; /* Dragging: 0x14 disabled 0x94 enabled */
315 r2[3] = 0xff; /* DragLock: 0xff disabled 0xb2 enabled */
320 r2[7] = 0x57; /* 0x57 bits 3:0 for W mode */
322 adb_write_register(dev, 2, 8, r2);
330 ctx = device_get_sysctl_ctx(dev);
331 tree = device_get_sysctl_tree(dev);
332 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "tapping",
333 CTLTYPE_INT | CTLFLAG_RW, sc, 0, adb_tapping_sysctl,
334 "I", "Tapping the pad causes button events");
339 adb_mouse_receive_packet(device_t dev, u_char status, u_char command,
340 u_char reg, int len, u_char *data)
342 struct adb_mouse_softc *sc;
345 int buttons, tmp_buttons;
347 sc = device_get_softc(dev);
349 if (command != ADB_COMMAND_TALK || reg != 0 || len < 2)
352 ydelta = data[0] & 0x7f;
353 xdelta = data[1] & 0x7f;
356 buttons |= !(data[0] & 0x80);
357 buttons |= !(data[1] & 0x80) << 1;
359 if (sc->flags & AMS_EXTENDED) {
360 for (i = 2; i < len && i < 5; i++) {
361 xdelta |= (data[i] & 0x07) << (3*i + 1);
362 ydelta |= (data[i] & 0x70) << (3*i - 3);
364 buttons |= !(data[i] & 0x08) << (2*i - 2);
365 buttons |= !(data[i] & 0x80) << (2*i - 1);
368 len = 2; /* Ignore extra data */
371 /* Do sign extension as necessary */
372 if (xdelta & (0x40 << 3*(len-2)))
373 xdelta |= 0xffffffc0 << 3*(len - 2);
374 if (ydelta & (0x40 << 3*(len-2)))
375 ydelta |= 0xffffffc0 << 3*(len - 2);
377 if ((sc->flags & AMS_TOUCHPAD) && (sc->sc_tapping == 1)) {
378 tmp_buttons = buttons;
379 if (buttons == 0x12) {
380 /* Map a double tap on button 3.
381 Keep the button state for the next sequence.
382 A double tap sequence is followed by a single tap
386 sc->button_buf = tmp_buttons;
387 } else if (buttons == 0x2) {
388 /* Map a single tap on button 2. But only if it is
389 not a successor from a double tap.
391 if (sc->button_buf != 0x3)
398 buttons = tmp_buttons;
402 * Some mice report high-numbered buttons on the wrong button number,
403 * so set the highest-numbered real button as pressed if there are
404 * mysterious high-numbered ones set.
406 * Don't do this for touchpads, because touchpads also trigger
407 * high button events when they are touched.
410 if (rounddown2(buttons, 1 << sc->hw.buttons)
411 && !(sc->flags & AMS_TOUCHPAD)) {
412 buttons |= 1 << (sc->hw.buttons - 1);
414 buttons &= (1 << sc->hw.buttons) - 1;
416 mtx_lock(&sc->sc_mtx);
418 /* Add in our new deltas, and take into account
419 Apple's opposite meaning for Y axis motion */
421 sc->xdelta += xdelta;
422 sc->ydelta -= ydelta;
424 sc->buttons = buttons;
426 mtx_unlock(&sc->sc_mtx);
428 cv_broadcast(&sc->sc_cv);
429 selwakeuppri(&sc->rsel, PZERO);
435 ams_open(struct cdev *dev, int flag, int fmt, struct thread *p)
437 struct adb_mouse_softc *sc;
439 sc = CDEV_GET_SOFTC(dev);
443 mtx_lock(&sc->sc_mtx);
444 sc->packet_read_len = 0;
448 mtx_unlock(&sc->sc_mtx);
454 ams_close(struct cdev *dev, int flag, int fmt, struct thread *p)
456 struct adb_mouse_softc *sc;
458 sc = CDEV_GET_SOFTC(dev);
460 cv_broadcast(&sc->sc_cv);
461 selwakeuppri(&sc->rsel, PZERO);
466 ams_poll(struct cdev *dev, int events, struct thread *p)
468 struct adb_mouse_softc *sc;
470 sc = CDEV_GET_SOFTC(dev);
474 if (events & (POLLIN | POLLRDNORM)) {
475 mtx_lock(&sc->sc_mtx);
477 if (sc->xdelta == 0 && sc->ydelta == 0 &&
478 sc->buttons == sc->last_buttons &&
479 sc->packet_read_len == 0) {
480 selrecord(p, &sc->rsel);
483 events &= (POLLIN | POLLRDNORM);
486 mtx_unlock(&sc->sc_mtx);
493 ams_read(struct cdev *dev, struct uio *uio, int flag)
495 struct adb_mouse_softc *sc;
500 sc = CDEV_GET_SOFTC(dev);
504 if (uio->uio_resid <= 0)
507 mtx_lock(&sc->sc_mtx);
509 if (!sc->packet_read_len) {
510 if (sc->xdelta == 0 && sc->ydelta == 0 &&
511 sc->buttons == sc->last_buttons) {
513 if (flag & O_NONBLOCK) {
514 mtx_unlock(&sc->sc_mtx);
519 /* Otherwise, block on new data */
520 error = cv_wait_sig(&sc->sc_cv, &sc->sc_mtx);
522 mtx_unlock(&sc->sc_mtx);
527 sc->packet[0] = 1U << 7;
528 sc->packet[0] |= (!(sc->buttons & 1)) << 2;
529 sc->packet[0] |= (!(sc->buttons & 4)) << 1;
530 sc->packet[0] |= (!(sc->buttons & 2));
532 if (sc->xdelta > 127) {
534 sc->packet[3] = sc->xdelta - 127;
535 } else if (sc->xdelta < -127) {
536 sc->packet[1] = -127;
537 sc->packet[3] = sc->xdelta + 127;
539 sc->packet[1] = sc->xdelta;
543 if (sc->ydelta > 127) {
545 sc->packet[4] = sc->ydelta - 127;
546 } else if (sc->ydelta < -127) {
547 sc->packet[2] = -127;
548 sc->packet[4] = sc->ydelta + 127;
550 sc->packet[2] = sc->ydelta;
558 sc->packet[7] = ~((uint8_t)(sc->buttons >> 3)) & 0x7f;
561 sc->last_buttons = sc->buttons;
565 sc->packet_read_len = sc->mode.packetsize;
568 len = (sc->packet_read_len > uio->uio_resid) ?
569 uio->uio_resid : sc->packet_read_len;
571 memcpy(outpacket,sc->packet +
572 (sc->mode.packetsize - sc->packet_read_len),len);
573 sc->packet_read_len -= len;
575 mtx_unlock(&sc->sc_mtx);
577 error = uiomove(outpacket,len,uio);
584 ams_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag,
587 struct adb_mouse_softc *sc;
590 sc = CDEV_GET_SOFTC(dev);
595 case MOUSE_GETHWINFO:
596 *(mousehw_t *)addr = sc->hw;
599 *(mousemode_t *)addr = sc->mode;
602 mode = *(mousemode_t *)addr;
603 addr = (caddr_t)&mode.level;
608 if (*(int *)addr == -1)
610 else if (*(int *)addr == 1) {
612 sc->mode.packetsize = 8;
614 } else if (*(int *)addr == 0) {
616 sc->mode.packetsize = 5;
622 *(int *)addr = sc->mode.level;
625 case MOUSE_GETSTATUS: {
626 mousestatus_t *status = (mousestatus_t *) addr;
628 mtx_lock(&sc->sc_mtx);
630 status->button = sc->buttons;
631 status->obutton = sc->last_buttons;
633 status->flags = status->button ^ status->obutton;
635 if (sc->xdelta != 0 || sc->ydelta)
636 status->flags |= MOUSE_POSCHANGED;
637 if (status->button != status->obutton)
638 status->flags |= MOUSE_BUTTONSCHANGED;
640 status->dx = sc->xdelta;
641 status->dy = sc->ydelta;
646 sc->last_buttons = sc->buttons;
648 mtx_unlock(&sc->sc_mtx);
659 adb_tapping_sysctl(SYSCTL_HANDLER_ARGS)
661 struct adb_mouse_softc *sc = arg1;
668 tapping = sc->sc_tapping;
670 error = sysctl_handle_int(oidp, &tapping, 0, req);
672 if (error || !req->newptr)
676 adb_read_register(dev, 2, r2);
677 r2[0] = 0x99; /* enable tapping. */
678 adb_write_register(dev, 2, 8, r2);
680 } else if (tapping == 0) {
681 adb_read_register(dev, 2, r2);
682 r2[0] = 0x19; /* disable tapping. */
683 adb_write_register(dev, 2, 8, r2);