1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (C) 2008 Nathan Whitehorn
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.
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.
15 *
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.
26 */
27
28 #include <sys/param.h>
29 #include <sys/systm.h>
30 #include <sys/lock.h>
31 #include <sys/module.h>
32 #include <sys/mutex.h>
33 #include <sys/bus.h>
34 #include <sys/conf.h>
35 #include <sys/mouse.h>
36 #include <sys/poll.h>
37 #include <sys/condvar.h>
38 #include <sys/selinfo.h>
39 #include <sys/sysctl.h>
40 #include <sys/uio.h>
41 #include <sys/fcntl.h>
42 #include <sys/kernel.h>
43
44 #include <machine/bus.h>
45
46 #include <vm/vm.h>
47 #include <vm/pmap.h>
48
49 #include "adb.h"
50
51 #define CDEV_GET_SOFTC(x) (x)->si_drv1
52
53 static int adb_mouse_probe(device_t dev);
54 static int adb_mouse_attach(device_t dev);
55 static int adb_mouse_detach(device_t dev);
56 static void adb_init_trackpad(device_t dev);
57 static int adb_tapping_sysctl(SYSCTL_HANDLER_ARGS);
58
59 static d_open_t ams_open;
60 static d_close_t ams_close;
61 static d_read_t ams_read;
62 static d_ioctl_t ams_ioctl;
63 static d_poll_t ams_poll;
64
65 static u_int adb_mouse_receive_packet(device_t dev, u_char status,
66 u_char command, u_char reg, int len, u_char *data);
67
68 struct adb_mouse_softc {
69 device_t sc_dev;
70
71 struct mtx sc_mtx;
72 struct cv sc_cv;
73
74 int flags;
75 #define AMS_EXTENDED 0x1
76 #define AMS_TOUCHPAD 0x2
77 uint16_t dpi;
78
79 mousehw_t hw;
80 mousemode_t mode;
81 u_char id[4];
82
83 int buttons;
84 u_int sc_tapping;
85 int button_buf;
86 int last_buttons;
87 int xdelta, ydelta;
88
89 int8_t packet[8];
90 size_t packet_read_len;
91
92 struct cdev *cdev;
93 struct selinfo rsel;
94 };
95
96 static device_method_t adb_mouse_methods[] = {
97 /* Device interface */
98 DEVMETHOD(device_probe, adb_mouse_probe),
99 DEVMETHOD(device_attach, adb_mouse_attach),
100 DEVMETHOD(device_detach, adb_mouse_detach),
101 DEVMETHOD(device_shutdown, bus_generic_shutdown),
102 DEVMETHOD(device_suspend, bus_generic_suspend),
103 DEVMETHOD(device_resume, bus_generic_resume),
104
105 /* ADB interface */
106 DEVMETHOD(adb_receive_packet, adb_mouse_receive_packet),
107 { 0, 0 }
108 };
109
110 static driver_t adb_mouse_driver = {
111 "ams",
112 adb_mouse_methods,
113 sizeof(struct adb_mouse_softc),
114 };
115
116 DRIVER_MODULE(ams, adb, adb_mouse_driver, 0, 0);
117
118 static struct cdevsw ams_cdevsw = {
119 .d_version = D_VERSION,
120 .d_flags = 0,
121 .d_open = ams_open,
122 .d_close = ams_close,
123 .d_read = ams_read,
124 .d_ioctl = ams_ioctl,
125 .d_poll = ams_poll,
126 .d_name = "ams",
127 };
128
129 static int
adb_mouse_probe(device_t dev)130 adb_mouse_probe(device_t dev)
131 {
132 uint8_t type;
133
134 type = adb_get_device_type(dev);
135
136 if (type != ADB_DEVICE_MOUSE)
137 return (ENXIO);
138
139 device_set_desc(dev,"ADB Mouse");
140 return (0);
141 }
142
143 static int
adb_mouse_attach(device_t dev)144 adb_mouse_attach(device_t dev)
145 {
146 struct adb_mouse_softc *sc;
147 char *description = "Unknown Pointing Device";
148
149 size_t r1_len;
150 u_char r1[8];
151
152 sc = device_get_softc(dev);
153 sc->sc_dev = dev;
154
155 mtx_init(&sc->sc_mtx, "ams", NULL, MTX_DEF);
156 cv_init(&sc->sc_cv,"ams");
157
158 sc->flags = 0;
159
160 sc->hw.buttons = 2;
161 sc->hw.iftype = MOUSE_IF_UNKNOWN;
162 sc->hw.type = MOUSE_UNKNOWN;
163 sc->hw.model = sc->hw.hwid = 0;
164
165 sc->mode.protocol = MOUSE_PROTO_SYSMOUSE;
166 sc->mode.rate = -1;
167 sc->mode.resolution = 100;
168 sc->mode.accelfactor = 0;
169 sc->mode.level = 0;
170 sc->mode.packetsize = 5;
171
172 sc->buttons = 0;
173 sc->sc_tapping = 0;
174 sc->button_buf = 0;
175 sc->last_buttons = 0;
176 sc->packet_read_len = 0;
177
178 /* Try to switch to extended protocol */
179 adb_set_device_handler(dev,4);
180
181 switch(adb_get_device_handler(dev)) {
182 case 1:
183 sc->mode.resolution = 100;
184 break;
185 case 2:
186 sc->mode.resolution = 200;
187 break;
188 case 4:
189 r1_len = adb_read_register(dev,1,r1);
190 if (r1_len < 8)
191 break;
192
193 sc->flags |= AMS_EXTENDED;
194 memcpy(&sc->hw.hwid,r1,4);
195 sc->mode.resolution = (r1[4] << 8) | r1[5];
196
197 switch (r1[6]) {
198 case 0:
199 sc->hw.type = MOUSE_PAD;
200 description = "Tablet";
201 break;
202 case 1:
203 sc->hw.type = MOUSE_MOUSE;
204 description = "Mouse";
205 break;
206 case 2:
207 sc->hw.type = MOUSE_TRACKBALL;
208 description = "Trackball";
209 break;
210 case 3:
211 sc->flags |= AMS_TOUCHPAD;
212 sc->hw.type = MOUSE_PAD;
213 adb_init_trackpad(dev);
214 description = "Touchpad";
215 break;
216 }
217
218 sc->hw.buttons = r1[7];
219
220 device_printf(dev,"%d-button %d-dpi %s\n",
221 sc->hw.buttons, sc->mode.resolution,description);
222
223 /*
224 * Check for one of MacAlly's non-compliant 2-button mice.
225 * These claim to speak the extended mouse protocol, but
226 * instead speak the standard protocol and only when their
227 * handler is set to 0x42.
228 */
229
230 if (sc->hw.hwid == 0x4b4f4954) {
231 adb_set_device_handler(dev,0x42);
232
233 if (adb_get_device_handler(dev) == 0x42) {
234 device_printf(dev, "MacAlly 2-Button Mouse\n");
235 sc->flags &= ~AMS_EXTENDED;
236 }
237 }
238
239 break;
240 }
241
242 sc->cdev = make_dev(&ams_cdevsw, device_get_unit(dev),
243 UID_ROOT, GID_OPERATOR, 0644, "ams%d",
244 device_get_unit(dev));
245 sc->cdev->si_drv1 = sc;
246
247 adb_set_autopoll(dev,1);
248
249 return (0);
250 }
251
252 static int
adb_mouse_detach(device_t dev)253 adb_mouse_detach(device_t dev)
254 {
255 struct adb_mouse_softc *sc;
256
257 adb_set_autopoll(dev,0);
258
259 sc = device_get_softc(dev);
260 destroy_dev(sc->cdev);
261
262 mtx_destroy(&sc->sc_mtx);
263 cv_destroy(&sc->sc_cv);
264
265 return (0);
266 }
267
268 static void
adb_init_trackpad(device_t dev)269 adb_init_trackpad(device_t dev)
270 {
271 struct adb_mouse_softc *sc;
272 struct sysctl_ctx_list *ctx;
273 struct sysctl_oid *tree;
274
275 size_t r1_len;
276 u_char r1[8];
277 u_char r2[8];
278
279 sc = device_get_softc(dev);
280
281 r1_len = adb_read_register(dev, 1, r1);
282
283 /* An Extended Mouse register1 must return 8 bytes. */
284 if (r1_len != 8)
285 return;
286
287 if((r1[6] != 0x0d))
288 {
289 r1[6] = 0x0d;
290
291 adb_write_register(dev, 1, 8, r1);
292
293 r1_len = adb_read_register(dev, 1, r1);
294
295 if (r1[6] != 0x0d)
296 {
297 device_printf(dev, "ADB Mouse = 0x%x "
298 "(non-Extended Mode)\n", r1[6]);
299 return;
300 } else {
301 device_printf(dev, "ADB Mouse = 0x%x "
302 "(Extended Mode)\n", r1[6]);
303
304 /* Set ADB Extended Features to default values,
305 enabled. */
306 r2[0] = 0x19; /* Clicking: 0x19 disabled 0x99 enabled */
307 r2[1] = 0x94; /* Dragging: 0x14 disabled 0x94 enabled */
308 r2[2] = 0x19;
309 r2[3] = 0xff; /* DragLock: 0xff disabled 0xb2 enabled */
310 r2[4] = 0xb2;
311 r2[5] = 0x8a;
312 r2[6] = 0x1b;
313
314 r2[7] = 0x57; /* 0x57 bits 3:0 for W mode */
315
316 adb_write_register(dev, 2, 8, r2);
317
318 }
319 }
320
321 /*
322 * Set up sysctl
323 */
324 ctx = device_get_sysctl_ctx(dev);
325 tree = device_get_sysctl_tree(dev);
326 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "tapping",
327 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_NEEDGIANT, sc, 0,
328 adb_tapping_sysctl, "I", "Tapping the pad causes button events");
329 return;
330 }
331
332 static u_int
adb_mouse_receive_packet(device_t dev,u_char status,u_char command,u_char reg,int len,u_char * data)333 adb_mouse_receive_packet(device_t dev, u_char status, u_char command,
334 u_char reg, int len, u_char *data)
335 {
336 struct adb_mouse_softc *sc;
337 int i = 0;
338 int xdelta, ydelta;
339 int buttons, tmp_buttons;
340
341 sc = device_get_softc(dev);
342
343 if (command != ADB_COMMAND_TALK || reg != 0 || len < 2)
344 return (0);
345
346 ydelta = data[0] & 0x7f;
347 xdelta = data[1] & 0x7f;
348
349 buttons = 0;
350 buttons |= !(data[0] & 0x80);
351 buttons |= !(data[1] & 0x80) << 1;
352
353 if (sc->flags & AMS_EXTENDED) {
354 for (i = 2; i < len && i < 5; i++) {
355 xdelta |= (data[i] & 0x07) << (3*i + 1);
356 ydelta |= (data[i] & 0x70) << (3*i - 3);
357
358 buttons |= !(data[i] & 0x08) << (2*i - 2);
359 buttons |= !(data[i] & 0x80) << (2*i - 1);
360 }
361 } else {
362 len = 2; /* Ignore extra data */
363 }
364
365 /* Do sign extension as necessary */
366 if (xdelta & (0x40 << 3*(len-2)))
367 xdelta |= 0xffffffc0 << 3*(len - 2);
368 if (ydelta & (0x40 << 3*(len-2)))
369 ydelta |= 0xffffffc0 << 3*(len - 2);
370
371 if ((sc->flags & AMS_TOUCHPAD) && (sc->sc_tapping == 1)) {
372 tmp_buttons = buttons;
373 if (buttons == 0x12) {
374 /* Map a double tap on button 3.
375 Keep the button state for the next sequence.
376 A double tap sequence is followed by a single tap
377 sequence.
378 */
379 tmp_buttons = 0x3;
380 sc->button_buf = tmp_buttons;
381 } else if (buttons == 0x2) {
382 /* Map a single tap on button 2. But only if it is
383 not a successor from a double tap.
384 */
385 if (sc->button_buf != 0x3)
386 tmp_buttons = 0x2;
387 else
388 tmp_buttons = 0;
389
390 sc->button_buf = 0;
391 }
392 buttons = tmp_buttons;
393 }
394
395 /*
396 * Some mice report high-numbered buttons on the wrong button number,
397 * so set the highest-numbered real button as pressed if there are
398 * mysterious high-numbered ones set.
399 *
400 * Don't do this for touchpads, because touchpads also trigger
401 * high button events when they are touched.
402 */
403
404 if (rounddown2(buttons, 1 << sc->hw.buttons)
405 && !(sc->flags & AMS_TOUCHPAD)) {
406 buttons |= 1 << (sc->hw.buttons - 1);
407 }
408 buttons &= (1 << sc->hw.buttons) - 1;
409
410 mtx_lock(&sc->sc_mtx);
411
412 /* Add in our new deltas, and take into account
413 Apple's opposite meaning for Y axis motion */
414
415 sc->xdelta += xdelta;
416 sc->ydelta -= ydelta;
417
418 sc->buttons = buttons;
419
420 mtx_unlock(&sc->sc_mtx);
421
422 cv_broadcast(&sc->sc_cv);
423 selwakeuppri(&sc->rsel, PZERO);
424
425 return (0);
426 }
427
428 static int
ams_open(struct cdev * dev,int flag,int fmt,struct thread * p)429 ams_open(struct cdev *dev, int flag, int fmt, struct thread *p)
430 {
431 struct adb_mouse_softc *sc;
432
433 sc = CDEV_GET_SOFTC(dev);
434 if (sc == NULL)
435 return (ENXIO);
436
437 mtx_lock(&sc->sc_mtx);
438 sc->packet_read_len = 0;
439 sc->xdelta = 0;
440 sc->ydelta = 0;
441 sc->buttons = 0;
442 mtx_unlock(&sc->sc_mtx);
443
444 return (0);
445 }
446
447 static int
ams_close(struct cdev * dev,int flag,int fmt,struct thread * p)448 ams_close(struct cdev *dev, int flag, int fmt, struct thread *p)
449 {
450 struct adb_mouse_softc *sc;
451
452 sc = CDEV_GET_SOFTC(dev);
453
454 cv_broadcast(&sc->sc_cv);
455 selwakeuppri(&sc->rsel, PZERO);
456 return (0);
457 }
458
459 static int
ams_poll(struct cdev * dev,int events,struct thread * p)460 ams_poll(struct cdev *dev, int events, struct thread *p)
461 {
462 struct adb_mouse_softc *sc;
463
464 sc = CDEV_GET_SOFTC(dev);
465 if (sc == NULL)
466 return (EIO);
467
468 if (events & (POLLIN | POLLRDNORM)) {
469 mtx_lock(&sc->sc_mtx);
470
471 if (sc->xdelta == 0 && sc->ydelta == 0 &&
472 sc->buttons == sc->last_buttons &&
473 sc->packet_read_len == 0) {
474 selrecord(p, &sc->rsel);
475 events = 0;
476 } else {
477 events &= (POLLIN | POLLRDNORM);
478 }
479
480 mtx_unlock(&sc->sc_mtx);
481 }
482
483 return events;
484 }
485
486 static int
ams_read(struct cdev * dev,struct uio * uio,int flag)487 ams_read(struct cdev *dev, struct uio *uio, int flag)
488 {
489 struct adb_mouse_softc *sc;
490 size_t len;
491 int8_t outpacket[8];
492 int error;
493
494 sc = CDEV_GET_SOFTC(dev);
495 if (sc == NULL)
496 return (EIO);
497
498 if (uio->uio_resid <= 0)
499 return (0);
500
501 mtx_lock(&sc->sc_mtx);
502
503 if (!sc->packet_read_len) {
504 if (sc->xdelta == 0 && sc->ydelta == 0 &&
505 sc->buttons == sc->last_buttons) {
506 if (flag & O_NONBLOCK) {
507 mtx_unlock(&sc->sc_mtx);
508 return EWOULDBLOCK;
509 }
510
511 /* Otherwise, block on new data */
512 error = cv_wait_sig(&sc->sc_cv, &sc->sc_mtx);
513 if (error) {
514 mtx_unlock(&sc->sc_mtx);
515 return (error);
516 }
517 }
518
519 sc->packet[0] = 1U << 7;
520 sc->packet[0] |= (!(sc->buttons & 1)) << 2;
521 sc->packet[0] |= (!(sc->buttons & 4)) << 1;
522 sc->packet[0] |= (!(sc->buttons & 2));
523
524 if (sc->xdelta > 127) {
525 sc->packet[1] = 127;
526 sc->packet[3] = sc->xdelta - 127;
527 } else if (sc->xdelta < -127) {
528 sc->packet[1] = -127;
529 sc->packet[3] = sc->xdelta + 127;
530 } else {
531 sc->packet[1] = sc->xdelta;
532 sc->packet[3] = 0;
533 }
534
535 if (sc->ydelta > 127) {
536 sc->packet[2] = 127;
537 sc->packet[4] = sc->ydelta - 127;
538 } else if (sc->ydelta < -127) {
539 sc->packet[2] = -127;
540 sc->packet[4] = sc->ydelta + 127;
541 } else {
542 sc->packet[2] = sc->ydelta;
543 sc->packet[4] = 0;
544 }
545
546 /* No Z movement */
547 sc->packet[5] = 0;
548 sc->packet[6] = 0;
549
550 sc->packet[7] = ~((uint8_t)(sc->buttons >> 3)) & 0x7f;
551
552 sc->last_buttons = sc->buttons;
553 sc->xdelta = 0;
554 sc->ydelta = 0;
555
556 sc->packet_read_len = sc->mode.packetsize;
557 }
558
559 len = (sc->packet_read_len > uio->uio_resid) ?
560 uio->uio_resid : sc->packet_read_len;
561
562 memcpy(outpacket,sc->packet +
563 (sc->mode.packetsize - sc->packet_read_len),len);
564 sc->packet_read_len -= len;
565
566 mtx_unlock(&sc->sc_mtx);
567
568 error = uiomove(outpacket,len,uio);
569
570 return (error);
571 }
572
573 static int
ams_ioctl(struct cdev * dev,u_long cmd,caddr_t addr,int flag,struct thread * p)574 ams_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag,
575 struct thread *p)
576 {
577 struct adb_mouse_softc *sc;
578 mousemode_t mode;
579
580 sc = CDEV_GET_SOFTC(dev);
581 if (sc == NULL)
582 return (EIO);
583
584 switch (cmd) {
585 case MOUSE_GETHWINFO:
586 *(mousehw_t *)addr = sc->hw;
587 break;
588 case MOUSE_GETMODE:
589 *(mousemode_t *)addr = sc->mode;
590 break;
591 case MOUSE_SETMODE:
592 mode = *(mousemode_t *)addr;
593 addr = (caddr_t)&mode.level;
594
595 /* Fallthrough */
596
597 case MOUSE_SETLEVEL:
598 if (*(int *)addr == -1)
599 break;
600 else if (*(int *)addr == 1) {
601 sc->mode.level = 1;
602 sc->mode.packetsize = 8;
603 break;
604 } else if (*(int *)addr == 0) {
605 sc->mode.level = 0;
606 sc->mode.packetsize = 5;
607 break;
608 }
609
610 return EINVAL;
611 case MOUSE_GETLEVEL:
612 *(int *)addr = sc->mode.level;
613 break;
614
615 case MOUSE_GETSTATUS: {
616 mousestatus_t *status = (mousestatus_t *) addr;
617
618 mtx_lock(&sc->sc_mtx);
619
620 status->button = sc->buttons;
621 status->obutton = sc->last_buttons;
622
623 status->flags = status->button ^ status->obutton;
624
625 if (sc->xdelta != 0 || sc->ydelta)
626 status->flags |= MOUSE_POSCHANGED;
627 if (status->button != status->obutton)
628 status->flags |= MOUSE_BUTTONSCHANGED;
629
630 status->dx = sc->xdelta;
631 status->dy = sc->ydelta;
632 status->dz = 0;
633
634 sc->xdelta = 0;
635 sc->ydelta = 0;
636 sc->last_buttons = sc->buttons;
637
638 mtx_unlock(&sc->sc_mtx);
639 break; }
640 default:
641 return ENOTTY;
642 }
643
644 return (0);
645 }
646
647 static int
adb_tapping_sysctl(SYSCTL_HANDLER_ARGS)648 adb_tapping_sysctl(SYSCTL_HANDLER_ARGS)
649 {
650 struct adb_mouse_softc *sc = arg1;
651 device_t dev;
652 int error;
653 u_char r2[8];
654 u_int tapping;
655
656 dev = sc->sc_dev;
657 tapping = sc->sc_tapping;
658
659 error = sysctl_handle_int(oidp, &tapping, 0, req);
660
661 if (error || !req->newptr)
662 return (error);
663
664 if (tapping == 1) {
665 adb_read_register(dev, 2, r2);
666 r2[0] = 0x99; /* enable tapping. */
667 adb_write_register(dev, 2, 8, r2);
668 sc->sc_tapping = 1;
669 } else if (tapping == 0) {
670 adb_read_register(dev, 2, r2);
671 r2[0] = 0x19; /* disable tapping. */
672 adb_write_register(dev, 2, 8, r2);
673 sc->sc_tapping = 0;
674 }
675 else
676 return (EINVAL);
677
678 return (0);
679 }
680