sys/dev/adb/adb_mouse.c

   1 /*-
   2  * Copyright (C) 2008 Nathan Whitehorn
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  18  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  20  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  21  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  22  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  23  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 #include <sys/cdefs.h>
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/module.h>
  32 #include <sys/bus.h>
  33 #include <sys/conf.h>
  34 #include <sys/mouse.h>
  35 #include <sys/poll.h>
  36 #include <sys/condvar.h>
  37 #include <sys/selinfo.h>
  38 #include <sys/uio.h>
  39 #include <sys/fcntl.h>
  40 #include <sys/kernel.h>
  41
  42 #include <machine/bus.h>
  43
  44 #include <vm/vm.h>
  45 #include <vm/pmap.h>
  46
  47 #include "adb.h"
  48
  49 #define CDEV_GET_SOFTC(x) (x)->si_drv1
  50
  51 static int adb_mouse_probe(device_t dev);
  52 static int adb_mouse_attach(device_t dev);
  53 static int adb_mouse_detach(device_t dev);
  54
  55 static d_open_t  ams_open;
  56 static d_close_t ams_close;
  57 static d_read_t  ams_read;
  58 static d_ioctl_t ams_ioctl;
  59 static d_poll_t  ams_poll;
  60
  61 static u_int adb_mouse_receive_packet(device_t dev, u_char status,
  62     u_char command, u_char reg, int len, u_char *data);
  63
  64 struct adb_mouse_softc {
  65         device_t sc_dev;
  66
  67         struct mtx sc_mtx;
  68         struct cv  sc_cv;
  69
  70         int flags;
  71 #define AMS_EXTENDED    0x1
  72 #define AMS_TOUCHPAD    0x2
  73         uint16_t dpi;
  74
  75         mousehw_t hw;
  76         mousemode_t mode;
  77         u_char id[4];
  78
  79         int buttons;
  80         int last_buttons;
  81         int xdelta, ydelta;
  82
  83         int8_t packet[8];
  84         size_t packet_read_len;
  85
  86         struct cdev *cdev;
  87         struct selinfo rsel;
  88 };
  89
  90 static device_method_t adb_mouse_methods[] = {
  91         /* Device interface */
  92         DEVMETHOD(device_probe,         adb_mouse_probe),
  93         DEVMETHOD(device_attach,        adb_mouse_attach),
  94         DEVMETHOD(device_detach,        adb_mouse_detach),
  95         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
  96         DEVMETHOD(device_suspend,       bus_generic_suspend),
  97         DEVMETHOD(device_resume,        bus_generic_resume),
  98
  99         /* ADB interface */
 100         DEVMETHOD(adb_receive_packet,   adb_mouse_receive_packet),
 101
 102         { 0, 0 }
 103 };
 104
 105 static driver_t adb_mouse_driver = {
 106         "ams",
 107         adb_mouse_methods,
 108         sizeof(struct adb_mouse_softc),
 109 };
 110
 111 static devclass_t adb_mouse_devclass;
 112
 113 DRIVER_MODULE(ams, adb, adb_mouse_driver, adb_mouse_devclass, 0, 0);
 114
 115 static struct cdevsw ams_cdevsw = {
 116         .d_version =    D_VERSION,
 117         .d_flags   =    0,
 118         .d_open    =    ams_open,
 119         .d_close   =    ams_close,
 120         .d_read    =    ams_read,
 121         .d_ioctl   =    ams_ioctl,
 122         .d_poll    =    ams_poll,
 123         .d_name    =    "ams",
 124 };
 125
 126 static int
 127 adb_mouse_probe(device_t dev)
 128 {
 129         uint8_t type;
 130
 131         type = adb_get_device_type(dev);
 132
 133         if (type != ADB_DEVICE_MOUSE)
 134                 return (ENXIO);
 135
 136         device_set_desc(dev,"ADB Mouse");
 137         return (0);
 138 }
 139
 140 static int
 141 adb_mouse_attach(device_t dev)
 142 {
 143         struct adb_mouse_softc *sc;
 144         char *description = "Unknown Pointing Device";
 145
 146         size_t r1_len;
 147         u_char r1[8];
 148
 149         sc = device_get_softc(dev);
 150         sc->sc_dev = dev;
 151
 152         mtx_init(&sc->sc_mtx,"ams",MTX_DEF,0);
 153         cv_init(&sc->sc_cv,"ams");
 154
 155         sc->flags = 0;
 156
 157         sc->hw.buttons = 2;
 158         sc->hw.iftype = MOUSE_IF_UNKNOWN;
 159         sc->hw.type = MOUSE_UNKNOWN;
 160         sc->hw.model = sc->hw.hwid = 0;
 161
 162         sc->mode.protocol = MOUSE_PROTO_SYSMOUSE;
 163         sc->mode.rate = -1;
 164         sc->mode.resolution = 100;
 165         sc->mode.accelfactor = 0;
 166         sc->mode.level = 0;
 167         sc->mode.packetsize = 5;
 168
 169         sc->buttons = 0;
 170         sc->last_buttons = 0;
 171         sc->packet_read_len = 0;
 172
 173         /* Try to switch to extended protocol */
 174         adb_set_device_handler(dev,4);
 175
 176         switch(adb_get_device_handler(dev)) {
 177         case 1:
 178                 sc->mode.resolution = 100;
 179                 break;
 180         case 2:
 181                 sc->mode.resolution = 200;
 182                 break;
 183         case 4:
 184                 r1_len = adb_read_register(dev,1,r1);
 185                 if (r1_len < 8)
 186                         break;
 187
 188                 sc->flags |= AMS_EXTENDED;
 189                 memcpy(&sc->hw.hwid,r1,4);
 190                 sc->mode.resolution = (r1[4] << 8) | r1[5];
 191
 192                 switch (r1[6]) {
 193                 case 0:
 194                         sc->hw.type = MOUSE_PAD;
 195                         description = "Tablet";
 196                         break;
 197                 case 1:
 198                         sc->hw.type = MOUSE_MOUSE;
 199                         description = "Mouse";
 200                         break;
 201                 case 2:
 202                         sc->hw.type = MOUSE_TRACKBALL;
 203                         description = "Trackball";
 204                         break;
 205                 case 3:
 206                         sc->flags |= AMS_TOUCHPAD;
 207                         sc->hw.type = MOUSE_PAD;
 208                         description = "Touchpad";
 209                         break;
 210                 }
 211
 212                 sc->hw.buttons = r1[7];
 213
 214                 device_printf(dev,"%d-button %d-dpi %s\n",
 215                     sc->hw.buttons, sc->mode.resolution,description);
 216
 217                 /*
 218                  * Check for one of MacAlly's non-compliant 2-button mice.
 219                  * These claim to speak the extended mouse protocol, but
 220                  * instead speak the standard protocol and only when their
 221                  * handler is set to 0x42.
 222                  */
 223
 224                 if (sc->hw.hwid == 0x4b4f4954) {
 225                         adb_set_device_handler(dev,0x42);
 226
 227                         if (adb_get_device_handler(dev) == 0x42) {
 228                                 device_printf(dev, "MacAlly 2-Button Mouse\n");
 229                                 sc->flags &= ~AMS_EXTENDED;
 230                         }
 231                 }
 232
 233                 break;
 234         }
 235
 236         sc->cdev = make_dev(&ams_cdevsw, device_get_unit(dev),
 237                        UID_ROOT, GID_OPERATOR, 0644, "ams%d",
 238                        device_get_unit(dev));
 239         sc->cdev->si_drv1 = sc;
 240
 241         adb_set_autopoll(dev,1);
 242
 243         return (0);
 244 }
 245
 246 static int
 247 adb_mouse_detach(device_t dev)
 248 {
 249         struct adb_mouse_softc *sc;
 250
 251         adb_set_autopoll(dev,0);
 252
 253         sc = device_get_softc(dev);
 254         destroy_dev(sc->cdev);
 255
 256         mtx_destroy(&sc->sc_mtx);
 257         cv_destroy(&sc->sc_cv);
 258
 259         return (0);
 260 }
 261
 262 static u_int
 263 adb_mouse_receive_packet(device_t dev, u_char status, u_char command,
 264     u_char reg, int len, u_char *data)
 265 {
 266         struct adb_mouse_softc *sc;
 267         int i = 0;
 268         int xdelta, ydelta;
 269         int buttons;
 270
 271         sc = device_get_softc(dev);
 272
 273         if (command != ADB_COMMAND_TALK || reg != 0 || len < 2)
 274                 return (0);
 275
 276         ydelta = data[0] & 0x7f;
 277         xdelta = data[1] & 0x7f;
 278
 279         buttons = 0;
 280         buttons |= !(data[0] & 0x80);
 281         buttons |= !(data[1] & 0x80) << 1;
 282
 283         if (sc->flags & AMS_EXTENDED) {
 284                 for (i = 2; i < len && i < 5; i++) {
 285                         xdelta |= (data[i] & 0x07) << (3*i + 1);
 286                         ydelta |= (data[i] & 0x70) << (3*i - 3);
 287
 288                         buttons |= !(data[i] & 0x08) << (2*i - 2);
 289                         buttons |= !(data[i] & 0x80) << (2*i - 1);
 290                 }
 291         } else {
 292                 len = 2; /* Ignore extra data */
 293         }
 294
 295         /* Do sign extension as necessary */
 296         if (xdelta & (0x40 << 3*(len-2)))
 297                 xdelta |= 0xffffffc0 << 3*(len - 2);
 298         if (ydelta & (0x40 << 3*(len-2)))
 299                 ydelta |= 0xffffffc0 << 3*(len - 2);
 300
 301         /*
 302          * Some mice report high-numbered buttons on the wrong button number,
 303          * so set the highest-numbered real button as pressed if there are
 304          * mysterious high-numbered ones set.
 305          *
 306          * Don't do this for touchpads, because touchpads also trigger
 307          * high button events when they are touched.
 308          */
 309
 310         if (buttons & ~((1 << sc->hw.buttons) - 1)
 311             && !(sc->flags & AMS_TOUCHPAD)) {
 312                 buttons |= 1 << (sc->hw.buttons - 1);
 313         }
 314         buttons &= (1 << sc->hw.buttons) - 1;
 315
 316         mtx_lock(&sc->sc_mtx);
 317
 318         /* Add in our new deltas, and take into account
 319            Apple's opposite meaning for Y axis motion */
 320
 321         sc->xdelta += xdelta;
 322         sc->ydelta -= ydelta;
 323
 324         sc->buttons = buttons;
 325
 326         mtx_unlock(&sc->sc_mtx);
 327
 328         cv_broadcast(&sc->sc_cv);
 329         selwakeuppri(&sc->rsel, PZERO);
 330
 331         return (0);
 332 }
 333
 334 static int
 335 ams_open(struct cdev *dev, int flag, int fmt, struct thread *p)
 336 {
 337         struct adb_mouse_softc *sc;
 338
 339         sc = CDEV_GET_SOFTC(dev);
 340         if (sc == NULL)
 341                 return (ENXIO);
 342
 343         mtx_lock(&sc->sc_mtx);
 344         sc->packet_read_len = 0;
 345         sc->xdelta = 0;
 346         sc->ydelta = 0;
 347         sc->buttons = 0;
 348         mtx_unlock(&sc->sc_mtx);
 349
 350         return (0);
 351 }
 352
 353 static int
 354 ams_close(struct cdev *dev, int flag, int fmt, struct thread *p)
 355 {
 356         struct adb_mouse_softc *sc;
 357
 358         sc = CDEV_GET_SOFTC(dev);
 359
 360         cv_broadcast(&sc->sc_cv);
 361         selwakeuppri(&sc->rsel, PZERO);
 362         return (0);
 363 }
 364
 365 static int
 366 ams_poll(struct cdev *dev, int events, struct thread *p)
 367 {
 368         struct adb_mouse_softc *sc;
 369
 370         sc = CDEV_GET_SOFTC(dev);
 371         if (sc == NULL)
 372                 return (EIO);
 373
 374         if (events & (POLLIN | POLLRDNORM)) {
 375                 mtx_lock(&sc->sc_mtx);
 376
 377                 if (sc->xdelta == 0 && sc->ydelta == 0 &&
 378                    sc->buttons == sc->last_buttons) {
 379                         selrecord(p, &sc->rsel);
 380                         events = 0;
 381                 } else {
 382                         events &= (POLLIN | POLLRDNORM);
 383                 }
 384
 385                 mtx_unlock(&sc->sc_mtx);
 386         }
 387
 388         return events;
 389 }
 390
 391 static int
 392 ams_read(struct cdev *dev, struct uio *uio, int flag)
 393 {
 394         struct adb_mouse_softc *sc;
 395         size_t len;
 396         int8_t outpacket[8];
 397         int error;
 398
 399         sc = CDEV_GET_SOFTC(dev);
 400         if (sc == NULL)
 401                 return (EIO);
 402
 403         if (uio->uio_resid <= 0)
 404                 return (0);
 405
 406         mtx_lock(&sc->sc_mtx);
 407
 408         if (!sc->packet_read_len) {
 409                 if (sc->xdelta == 0 && sc->ydelta == 0 &&
 410                    sc->buttons == sc->last_buttons) {
 411
 412                         if (flag & O_NONBLOCK) {
 413                                 mtx_unlock(&sc->sc_mtx);
 414                                 return EWOULDBLOCK;
 415                         }
 416
 417
 418                         /* Otherwise, block on new data */
 419                         error = cv_wait_sig(&sc->sc_cv, &sc->sc_mtx);
 420                         if (error) {
 421                                 mtx_unlock(&sc->sc_mtx);
 422                                 return (error);
 423                         }
 424                 }
 425
 426                 sc->packet[0] = 1 << 7;
 427                 sc->packet[0] |= (!(sc->buttons & 1)) << 2;
 428                 sc->packet[0] |= (!(sc->buttons & 4)) << 1;
 429                 sc->packet[0] |= (!(sc->buttons & 2));
 430
 431                 if (sc->xdelta > 127) {
 432                         sc->packet[1] = 127;
 433                         sc->packet[3] = sc->xdelta - 127;
 434                 } else if (sc->xdelta < -127) {
 435                         sc->packet[1] = -127;
 436                         sc->packet[3] = sc->xdelta + 127;
 437                 } else {
 438                         sc->packet[1] = sc->xdelta;
 439                         sc->packet[3] = 0;
 440                 }
 441
 442                 if (sc->ydelta > 127) {
 443                         sc->packet[2] = 127;
 444                         sc->packet[4] = sc->ydelta - 127;
 445                 } else if (sc->ydelta < -127) {
 446                         sc->packet[2] = -127;
 447                         sc->packet[4] = sc->ydelta + 127;
 448                 } else {
 449                         sc->packet[2] = sc->ydelta;
 450                         sc->packet[4] = 0;
 451                 }
 452
 453                 /* No Z movement */
 454                 sc->packet[5] = 0;
 455                 sc->packet[6] = 0;
 456
 457                 sc->packet[7] = ~((uint8_t)(sc->buttons >> 3)) & 0x7f;
 458
 459
 460                 sc->last_buttons = sc->buttons;
 461                 sc->xdelta = 0;
 462                 sc->ydelta = 0;
 463
 464                 sc->packet_read_len = sc->mode.packetsize;
 465         }
 466
 467         len = (sc->packet_read_len > uio->uio_resid) ?
 468                 uio->uio_resid : sc->packet_read_len;
 469
 470         memcpy(outpacket,sc->packet +
 471                 (sc->mode.packetsize - sc->packet_read_len),len);
 472         sc->packet_read_len -= len;
 473
 474         mtx_unlock(&sc->sc_mtx);
 475
 476         uiomove(outpacket,len,uio);
 477
 478         return (0);
 479 }
 480
 481
 482 static int
 483 ams_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag,
 484     struct thread *p)
 485 {
 486         struct adb_mouse_softc *sc;
 487         mousemode_t mode;
 488
 489         sc = CDEV_GET_SOFTC(dev);
 490         if (sc == NULL)
 491                 return (EIO);
 492
 493         switch (cmd) {
 494         case MOUSE_GETHWINFO:
 495                 *(mousehw_t *)addr = sc->hw;
 496                 break;
 497         case MOUSE_GETMODE:
 498                 *(mousemode_t *)addr = sc->mode;
 499                 break;
 500         case MOUSE_SETMODE:
 501                 mode = *(mousemode_t *)addr;
 502                 addr = (caddr_t)&mode.level;
 503
 504                 /* Fallthrough */
 505
 506         case MOUSE_SETLEVEL:
 507                 if (*(int *)addr == -1)
 508                         break;
 509                 else if (*(int *)addr == 1) {
 510                         sc->mode.level = 1;
 511                         sc->mode.packetsize = 8;
 512                         break;
 513                 } else if (*(int *)addr == 0) {
 514                         sc->mode.level = 0;
 515                         sc->mode.packetsize = 5;
 516                         break;
 517                 }
 518
 519                 return EINVAL;
 520         case MOUSE_GETLEVEL:
 521                 *(int *)addr = sc->mode.level;
 522                 break;
 523
 524         case MOUSE_GETSTATUS: {
 525                 mousestatus_t *status = (mousestatus_t *) addr;
 526
 527                 mtx_lock(&sc->sc_mtx);
 528
 529                 status->button = sc->buttons;
 530                 status->obutton = sc->last_buttons;
 531
 532                 status->flags = status->button ^ status->obutton;
 533
 534                 if (sc->xdelta != 0 || sc->ydelta)
 535                         status->flags |= MOUSE_POSCHANGED;
 536                 if (status->button != status->obutton)
 537                         status->flags |= MOUSE_BUTTONSCHANGED;
 538
 539                 status->dx = sc->xdelta;
 540                 status->dy = sc->ydelta;
 541                 status->dz = 0;
 542
 543                 sc->xdelta = 0;
 544                 sc->ydelta = 0;
 545                 sc->last_buttons = sc->buttons;
 546
 547                 mtx_unlock(&sc->sc_mtx);
 548
 549                 break; }
 550         default:
 551                 return ENOTTY;
 552         }
 553
 554         return (0);
 555 }
 556