sys/dev/adb/adb_mouse.c

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