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 557