1 /* 2 * Copyright (c) 2014 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> and was subsequently ported, 6 * modified and enhanced for FreeBSD by Michael Gmelin <freebsd@grem.de>. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in 16 * the documentation and/or other materials provided with the 17 * distribution. 18 * 3. Neither the name of The DragonFly Project nor the names of its 19 * contributors may be used to endorse or promote products derived 20 * from this software without specific, prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 25 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 26 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 27 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 28 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 29 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 30 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 31 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 32 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 33 * SUCH DAMAGE. 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 /* 40 * CYAPA - Cypress APA trackpad with I2C Interface driver 41 * 42 * Based on DragonFlyBSD's cyapa driver, which referenced the linux 43 * cyapa.c driver to figure out the bootstrapping and commands. 44 * 45 * Unable to locate any datasheet for the device. 46 * 47 * 48 * Trackpad layout: 49 * 50 * 2/3 1/3 51 * +--------------------+------------+ 52 * | | Middle | 53 * | | Button | 54 * | Left | | 55 * | Button +------------+ 56 * | | Right | 57 * | | Button | 58 * +--------------------+............| 59 * | Thumb/Button Area | 15% 60 * +---------------------------------+ 61 * 62 * 63 * FEATURES 64 * 65 * IMPS/2 emulation - Emulates the IntelliMouse protocol. 66 * 67 * Jitter supression - Implements 2-pixel hysteresis with memory. 68 * 69 * Jump detecion - Detect jumps caused by touchpad. 70 * 71 * Two finger scrolling - Use two fingers for Z axis scrolling. 72 * 73 * Button down/2nd finger - While one finger clicks and holds down the 74 * touchpad, the second one can be used to move 75 * the mouse cursor. Useful for drawing or 76 * selecting text. 77 * 78 * Thumb/Button Area - The lower 15%* of the trackpad will not affect 79 * the mouse cursor position. This allows for high 80 * precision clicking, by controlling the cursor 81 * with the index finger and pushing/holding the 82 * pad down with the thumb. 83 * * can be changed using sysctl 84 * 85 * Track-pad button - Push physical button. Left 2/3rds of the pad 86 * will issue a LEFT button event, upper right 87 * corner will issue a MIDDLE button event, 88 * lower right corner will issue a RIGHT button 89 * event. Optional tap support can be enabled 90 * and configured using sysctl. 91 * 92 * WARNINGS 93 * 94 * These trackpads get confused when three or more fingers are down on the 95 * same horizontal axis and will start to glitch the finger detection. 96 * Removing your hand for a few seconds will allow the trackpad to 97 * recalibrate. Generally speaking, when using three or more fingers 98 * please try to place at least one finger off-axis (a little above or 99 * below) the other two. 100 */ 101 102 #include <sys/param.h> 103 #include <sys/bus.h> 104 #include <sys/conf.h> 105 #include <sys/event.h> 106 #include <sys/fcntl.h> 107 #include <sys/kernel.h> 108 #include <sys/kthread.h> 109 #include <sys/lock.h> 110 #include <sys/lockmgr.h> 111 #include <sys/malloc.h> 112 #include <sys/mbuf.h> 113 #include <sys/module.h> 114 #include <sys/mouse.h> 115 #include <sys/mutex.h> 116 #include <sys/poll.h> 117 #include <sys/selinfo.h> 118 #include <sys/sysctl.h> 119 #include <sys/sysctl.h> 120 #include <sys/systm.h> 121 #include <sys/systm.h> 122 #include <sys/uio.h> 123 #include <sys/vnode.h> 124 125 #include <dev/smbus/smbconf.h> 126 #include <dev/smbus/smbus.h> 127 #include <dev/cyapa/cyapa.h> 128 129 #include "smbus_if.h" 130 #include "bus_if.h" 131 #include "device_if.h" 132 133 #define CYAPA_BUFSIZE 128 /* power of 2 */ 134 #define CYAPA_BUFMASK (CYAPA_BUFSIZE - 1) 135 136 #define ZSCALE 15 137 138 #define TIME_TO_IDLE (hz * 10) 139 #define TIME_TO_RESET (hz * 3) 140 141 static MALLOC_DEFINE(M_CYAPA, "cyapa", "CYAPA device data"); 142 143 struct cyapa_fifo { 144 int rindex; 145 int windex; 146 char buf[CYAPA_BUFSIZE]; 147 }; 148 149 struct cyapa_softc { 150 device_t dev; 151 int count; /* >0 if device opened */ 152 int unit; 153 int addr; 154 struct cdev *devnode; 155 struct selinfo selinfo; 156 struct mtx mutex; 157 158 int cap_resx; 159 int cap_resy; 160 int cap_phyx; 161 int cap_phyy; 162 uint8_t cap_buttons; 163 164 int detaching; /* driver is detaching */ 165 int poll_thread_running; /* poll thread is running */ 166 167 /* PS/2 mouse emulation */ 168 int track_x; /* current tracking */ 169 int track_y; 170 int track_z; 171 int track_z_ticks; 172 uint16_t track_but; 173 char track_id; /* first finger id */ 174 int track_nfingers; 175 int delta_x; /* accumulation -> report */ 176 int delta_y; 177 int delta_z; 178 int fuzz_x; 179 int fuzz_y; 180 int fuzz_z; 181 int touch_x; /* touch down coordinates */ 182 int touch_y; 183 int touch_z; 184 int finger1_ticks; 185 int finger2_ticks; 186 int finger3_ticks; 187 uint16_t reported_but; 188 189 struct cyapa_fifo rfifo; /* device->host */ 190 struct cyapa_fifo wfifo; /* host->device */ 191 uint8_t ps2_cmd; /* active p2_cmd waiting for data */ 192 uint8_t ps2_acked; 193 int active_tick; 194 int data_signal; 195 int blocked; 196 int isselect; 197 int reporting_mode; /* 0=disabled 1=enabled */ 198 int scaling_mode; /* 0=1:1 1=2:1 */ 199 int remote_mode; /* 0 for streaming mode */ 200 int zenabled; /* z-axis enabled (mode 1 or 2) */ 201 mousehw_t hw; /* hardware information */ 202 mousemode_t mode; /* mode */ 203 int poll_ticks; 204 }; 205 206 struct cyapa_cdevpriv { 207 struct cyapa_softc *sc; 208 }; 209 210 #define CYPOLL_SHUTDOWN 0x0001 211 212 static void cyapa_poll_thread(void *arg); 213 static int cyapa_raw_input(struct cyapa_softc *sc, struct cyapa_regs *regs, 214 int freq); 215 static void cyapa_set_power_mode(struct cyapa_softc *sc, int mode); 216 217 static int fifo_empty(struct cyapa_softc *sc, struct cyapa_fifo *fifo); 218 static size_t fifo_ready(struct cyapa_softc *sc, struct cyapa_fifo *fifo); 219 static char *fifo_read(struct cyapa_softc *sc, struct cyapa_fifo *fifo, 220 size_t n); 221 static char *fifo_write(struct cyapa_softc *sc, struct cyapa_fifo *fifo, 222 size_t n); 223 static uint8_t fifo_read_char(struct cyapa_softc *sc, 224 struct cyapa_fifo *fifo); 225 static void fifo_write_char(struct cyapa_softc *sc, struct cyapa_fifo *fifo, 226 uint8_t c); 227 static size_t fifo_space(struct cyapa_softc *sc, struct cyapa_fifo *fifo); 228 static void fifo_reset(struct cyapa_softc *sc, struct cyapa_fifo *fifo); 229 230 static int cyapa_fuzz(int delta, int *fuzz); 231 232 static int cyapa_idle_freq = 1; 233 SYSCTL_INT(_debug, OID_AUTO, cyapa_idle_freq, CTLFLAG_RW, 234 &cyapa_idle_freq, 0, "Scan frequency in idle mode"); 235 static int cyapa_slow_freq = 20; 236 SYSCTL_INT(_debug, OID_AUTO, cyapa_slow_freq, CTLFLAG_RW, 237 &cyapa_slow_freq, 0, "Scan frequency in slow mode "); 238 static int cyapa_norm_freq = 100; 239 SYSCTL_INT(_debug, OID_AUTO, cyapa_norm_freq, CTLFLAG_RW, 240 &cyapa_norm_freq, 0, "Normal scan frequency"); 241 static int cyapa_minpressure = 12; 242 SYSCTL_INT(_debug, OID_AUTO, cyapa_minpressure, CTLFLAG_RW, 243 &cyapa_minpressure, 0, "Minimum pressure to detect finger"); 244 static int cyapa_enable_tapclick = 0; 245 SYSCTL_INT(_debug, OID_AUTO, cyapa_enable_tapclick, CTLFLAG_RW, 246 &cyapa_enable_tapclick, 0, "Enable tap to click"); 247 static int cyapa_tapclick_min_ticks = 1; 248 SYSCTL_INT(_debug, OID_AUTO, cyapa_tapclick_min_ticks, CTLFLAG_RW, 249 &cyapa_tapclick_min_ticks, 0, "Minimum tap duration for click"); 250 static int cyapa_tapclick_max_ticks = 8; 251 SYSCTL_INT(_debug, OID_AUTO, cyapa_tapclick_max_ticks, CTLFLAG_RW, 252 &cyapa_tapclick_max_ticks, 0, "Maximum tap duration for click"); 253 static int cyapa_move_min_ticks = 4; 254 SYSCTL_INT(_debug, OID_AUTO, cyapa_move_min_ticks, CTLFLAG_RW, 255 &cyapa_move_min_ticks, 0, 256 "Minimum ticks before cursor position is changed"); 257 static int cyapa_scroll_wait_ticks = 0; 258 SYSCTL_INT(_debug, OID_AUTO, cyapa_scroll_wait_ticks, CTLFLAG_RW, 259 &cyapa_scroll_wait_ticks, 0, 260 "Wait N ticks before starting to scroll"); 261 static int cyapa_scroll_stick_ticks = 15; 262 SYSCTL_INT(_debug, OID_AUTO, cyapa_scroll_stick_ticks, CTLFLAG_RW, 263 &cyapa_scroll_stick_ticks, 0, 264 "Prevent cursor move on single finger for N ticks after scroll"); 265 static int cyapa_thumbarea_percent = 15; 266 SYSCTL_INT(_debug, OID_AUTO, cyapa_thumbarea_percent, CTLFLAG_RW, 267 &cyapa_thumbarea_percent, 0, 268 "Size of bottom thumb area in percent"); 269 270 static int cyapa_debug = 0; 271 SYSCTL_INT(_debug, OID_AUTO, cyapa_debug, CTLFLAG_RW, 272 &cyapa_debug, 0, "Enable debugging"); 273 static int cyapa_reset = 0; 274 SYSCTL_INT(_debug, OID_AUTO, cyapa_reset, CTLFLAG_RW, 275 &cyapa_reset, 0, "Reset track pad"); 276 277 static void 278 cyapa_lock(struct cyapa_softc *sc) 279 { 280 281 mtx_lock(&sc->mutex); 282 } 283 284 static void 285 cyapa_unlock(struct cyapa_softc *sc) 286 { 287 288 mtx_unlock(&sc->mutex); 289 } 290 291 #define CYAPA_LOCK_ASSERT(sc) mtx_assert(&(sc)->mutex, MA_OWNED); 292 293 /* 294 * Notify if possible receive data ready. Must be called 295 * with sc->mutex held (cyapa_lock(sc)). 296 */ 297 static void 298 cyapa_notify(struct cyapa_softc *sc) 299 { 300 301 CYAPA_LOCK_ASSERT(sc); 302 303 if (sc->data_signal || !fifo_empty(sc, &sc->rfifo)) { 304 KNOTE_LOCKED(&sc->selinfo.si_note, 0); 305 if (sc->blocked || sc->isselect) { 306 if (sc->blocked) { 307 sc->blocked = 0; 308 wakeup(&sc->blocked); 309 } 310 if (sc->isselect) { 311 sc->isselect = 0; 312 selwakeup(&sc->selinfo); 313 } 314 } 315 } 316 } 317 318 /* 319 * Initialize the device 320 */ 321 static int 322 init_device(device_t dev, struct cyapa_cap *cap, int addr, int probe) 323 { 324 static char bl_exit[] = { 325 0x00, 0xff, 0xa5, 0x00, 0x01, 326 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 }; 327 static char bl_deactivate[] = { 328 0x00, 0xff, 0x3b, 0x00, 0x01, 329 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 }; 330 device_t bus; 331 struct cyapa_boot_regs boot; 332 int error; 333 int retries; 334 335 bus = device_get_parent(dev); /* smbus */ 336 337 /* Get status */ 338 error = smbus_trans(bus, addr, CMD_BOOT_STATUS, 339 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 340 NULL, 0, (void *)&boot, sizeof(boot), NULL); 341 if (error) 342 goto done; 343 344 /* 345 * Bootstrap the device if necessary. It can take up to 2 seconds 346 * for the device to fully initialize. 347 */ 348 retries = 20; 349 while ((boot.stat & CYAPA_STAT_RUNNING) == 0 && retries > 0) { 350 if (boot.boot & CYAPA_BOOT_BUSY) { 351 /* Busy, wait loop. */ 352 } else if (boot.error & CYAPA_ERROR_BOOTLOADER) { 353 /* Magic */ 354 error = smbus_trans(bus, addr, CMD_BOOT_STATUS, 355 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 356 bl_deactivate, sizeof(bl_deactivate), 357 NULL, 0, NULL); 358 if (error) 359 goto done; 360 } else { 361 /* Magic */ 362 error = smbus_trans(bus, addr, CMD_BOOT_STATUS, 363 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 364 bl_exit, sizeof(bl_exit), NULL, 0, NULL); 365 if (error) 366 goto done; 367 } 368 pause("cyapab1", (hz * 2) / 10); 369 --retries; 370 error = smbus_trans(bus, addr, CMD_BOOT_STATUS, 371 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 372 NULL, 0, (void *)&boot, sizeof(boot), NULL); 373 if (error) 374 goto done; 375 } 376 377 if (retries == 0) { 378 device_printf(dev, "Unable to bring device out of bootstrap\n"); 379 error = ENXIO; 380 goto done; 381 } 382 383 /* Check identity */ 384 if (cap) { 385 error = smbus_trans(bus, addr, CMD_QUERY_CAPABILITIES, 386 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 387 NULL, 0, (void *)cap, sizeof(*cap), NULL); 388 389 if (strncmp(cap->prod_ida, "CYTRA", 5) != 0) { 390 device_printf(dev, "Product ID \"%5.5s\" mismatch\n", 391 cap->prod_ida); 392 error = ENXIO; 393 } 394 } 395 error = smbus_trans(bus, addr, CMD_BOOT_STATUS, 396 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 397 NULL, 0, (void *)&boot, sizeof(boot), NULL); 398 399 if (probe == 0) /* official init */ 400 device_printf(dev, "cyapa init status %02x\n", boot.stat); 401 else if (probe == 2) 402 device_printf(dev, "cyapa reset status %02x\n", boot.stat); 403 404 done: 405 if (error) 406 device_printf(dev, "Unable to initialize\n"); 407 return (error); 408 } 409 410 static int cyapa_probe(device_t); 411 static int cyapa_attach(device_t); 412 static int cyapa_detach(device_t); 413 static void cyapa_cdevpriv_dtor(void*); 414 415 static devclass_t cyapa_devclass; 416 417 static device_method_t cyapa_methods[] = { 418 /* device interface */ 419 DEVMETHOD(device_probe, cyapa_probe), 420 DEVMETHOD(device_attach, cyapa_attach), 421 DEVMETHOD(device_detach, cyapa_detach), 422 423 DEVMETHOD_END 424 }; 425 426 static driver_t cyapa_driver = { 427 "cyapa", 428 cyapa_methods, 429 sizeof(struct cyapa_softc), 430 }; 431 432 static d_open_t cyapaopen; 433 static d_ioctl_t cyapaioctl; 434 static d_read_t cyaparead; 435 static d_write_t cyapawrite; 436 static d_kqfilter_t cyapakqfilter; 437 static d_poll_t cyapapoll; 438 439 static struct cdevsw cyapa_cdevsw = { 440 .d_version = D_VERSION, 441 .d_open = cyapaopen, 442 .d_ioctl = cyapaioctl, 443 .d_read = cyaparead, 444 .d_write = cyapawrite, 445 .d_kqfilter = cyapakqfilter, 446 .d_poll = cyapapoll, 447 }; 448 449 static int 450 cyapa_probe(device_t dev) 451 { 452 struct cyapa_cap cap; 453 int unit; 454 int addr; 455 int error; 456 457 addr = smbus_get_addr(dev); 458 459 /* 460 * 0x67 - cypress trackpad on the acer c720 461 * (other devices might use other ids). 462 */ 463 if (addr != 0x67) 464 return (ENXIO); 465 466 unit = device_get_unit(dev); 467 468 error = init_device(dev, &cap, addr, 1); 469 if (error != 0) 470 return (ENXIO); 471 472 device_set_desc(dev, "Cypress APA I2C Trackpad"); 473 474 return (BUS_PROBE_VENDOR); 475 } 476 477 static int 478 cyapa_attach(device_t dev) 479 { 480 struct cyapa_softc *sc; 481 struct cyapa_cap cap; 482 int unit; 483 int addr; 484 485 sc = device_get_softc(dev); 486 sc->reporting_mode = 1; 487 488 unit = device_get_unit(dev); 489 addr = *((unsigned char*) device_get_ivars(dev)); 490 491 if (init_device(dev, &cap, addr, 0)) 492 return (ENXIO); 493 494 mtx_init(&sc->mutex, "cyapa", NULL, MTX_DEF); 495 496 sc->dev = dev; 497 sc->unit = unit; 498 sc->addr = addr; 499 500 knlist_init_mtx(&sc->selinfo.si_note, &sc->mutex); 501 502 sc->cap_resx = ((cap.max_abs_xy_high << 4) & 0x0F00) | 503 cap.max_abs_x_low; 504 sc->cap_resy = ((cap.max_abs_xy_high << 8) & 0x0F00) | 505 cap.max_abs_y_low; 506 sc->cap_phyx = ((cap.phy_siz_xy_high << 4) & 0x0F00) | 507 cap.phy_siz_x_low; 508 sc->cap_phyy = ((cap.phy_siz_xy_high << 8) & 0x0F00) | 509 cap.phy_siz_y_low; 510 sc->cap_buttons = cap.buttons; 511 512 device_printf(dev, "%5.5s-%6.6s-%2.2s buttons=%c%c%c res=%dx%d\n", 513 cap.prod_ida, cap.prod_idb, cap.prod_idc, 514 ((cap.buttons & CYAPA_FNGR_LEFT) ? 'L' : '-'), 515 ((cap.buttons & CYAPA_FNGR_MIDDLE) ? 'M' : '-'), 516 ((cap.buttons & CYAPA_FNGR_RIGHT) ? 'R' : '-'), 517 sc->cap_resx, sc->cap_resy); 518 519 sc->hw.buttons = 5; 520 sc->hw.iftype = MOUSE_IF_PS2; 521 sc->hw.type = MOUSE_MOUSE; 522 sc->hw.model = MOUSE_MODEL_INTELLI; 523 sc->hw.hwid = addr; 524 525 sc->mode.protocol = MOUSE_PROTO_PS2; 526 sc->mode.rate = 100; 527 sc->mode.resolution = 4; 528 sc->mode.accelfactor = 1; 529 sc->mode.level = 0; 530 sc->mode.packetsize = MOUSE_PS2_PACKETSIZE; 531 532 /* Setup input event tracking */ 533 cyapa_set_power_mode(sc, CMD_POWER_MODE_IDLE); 534 535 /* Start the polling thread */ 536 kthread_add(cyapa_poll_thread, sc, NULL, NULL, 537 0, 0, "cyapa-poll"); 538 539 sc->devnode = make_dev(&cyapa_cdevsw, unit, 540 UID_ROOT, GID_WHEEL, 0600, "cyapa%d", unit); 541 542 sc->devnode->si_drv1 = sc; 543 544 return (0); 545 } 546 547 static int 548 cyapa_detach(device_t dev) 549 { 550 struct cyapa_softc *sc; 551 552 sc = device_get_softc(dev); 553 554 /* Cleanup poller thread */ 555 cyapa_lock(sc); 556 while (sc->poll_thread_running) { 557 sc->detaching = 1; 558 mtx_sleep(&sc->detaching, &sc->mutex, PCATCH, "cyapadet", hz); 559 } 560 cyapa_unlock(sc); 561 562 destroy_dev(sc->devnode); 563 564 knlist_clear(&sc->selinfo.si_note, 0); 565 seldrain(&sc->selinfo); 566 knlist_destroy(&sc->selinfo.si_note); 567 568 mtx_destroy(&sc->mutex); 569 570 return (0); 571 } 572 573 /* 574 * USER DEVICE I/O FUNCTIONS 575 */ 576 static int 577 cyapaopen(struct cdev *dev, int oflags, int devtype, struct thread *td) 578 { 579 struct cyapa_cdevpriv *priv; 580 int error; 581 582 priv = malloc(sizeof(*priv), M_CYAPA, M_WAITOK | M_ZERO); 583 priv->sc = dev->si_drv1; 584 585 error = devfs_set_cdevpriv(priv, cyapa_cdevpriv_dtor); 586 if (error == 0) { 587 cyapa_lock(priv->sc); 588 priv->sc->count++; 589 cyapa_unlock(priv->sc); 590 } 591 else 592 free(priv, M_CYAPA); 593 594 return (error); 595 } 596 597 static void 598 cyapa_cdevpriv_dtor(void *data) 599 { 600 struct cyapa_cdevpriv *priv; 601 602 priv = data; 603 KASSERT(priv != NULL, ("cyapa cdevpriv should not be NULL!")); 604 605 cyapa_lock(priv->sc); 606 priv->sc->count--; 607 cyapa_unlock(priv->sc); 608 609 free(priv, M_CYAPA); 610 } 611 612 static int 613 cyaparead(struct cdev *dev, struct uio *uio, int ioflag) 614 { 615 struct cyapa_softc *sc; 616 int error; 617 int didread; 618 size_t n; 619 char* ptr; 620 621 sc = dev->si_drv1; 622 /* If buffer is empty, load a new event if it is ready */ 623 cyapa_lock(sc); 624 again: 625 if (fifo_empty(sc, &sc->rfifo) && 626 (sc->data_signal || sc->delta_x || sc->delta_y || 627 sc->track_but != sc->reported_but)) { 628 uint8_t c0; 629 uint16_t but; 630 int delta_x; 631 int delta_y; 632 int delta_z; 633 634 /* Accumulate delta_x, delta_y */ 635 sc->data_signal = 0; 636 delta_x = sc->delta_x; 637 delta_y = sc->delta_y; 638 delta_z = sc->delta_z; 639 if (delta_x > 255) { 640 delta_x = 255; 641 sc->data_signal = 1; 642 } 643 if (delta_x < -256) { 644 delta_x = -256; 645 sc->data_signal = 1; 646 } 647 if (delta_y > 255) { 648 delta_y = 255; 649 sc->data_signal = 1; 650 } 651 if (delta_y < -256) { 652 delta_y = -256; 653 sc->data_signal = 1; 654 } 655 if (delta_z > 255) { 656 delta_z = 255; 657 sc->data_signal = 1; 658 } 659 if (delta_z < -256) { 660 delta_z = -256; 661 sc->data_signal = 1; 662 } 663 but = sc->track_but; 664 665 /* Adjust baseline for next calculation */ 666 sc->delta_x -= delta_x; 667 sc->delta_y -= delta_y; 668 sc->delta_z -= delta_z; 669 sc->reported_but = but; 670 671 /* 672 * Fuzz reduces movement jitter by introducing some 673 * hysteresis. It operates without cumulative error so 674 * if you swish around quickly and return your finger to 675 * where it started, so to will the mouse. 676 */ 677 delta_x = cyapa_fuzz(delta_x, &sc->fuzz_x); 678 delta_y = cyapa_fuzz(delta_y, &sc->fuzz_y); 679 delta_z = cyapa_fuzz(delta_z, &sc->fuzz_z); 680 681 /* 682 * Generate report 683 */ 684 c0 = 0; 685 if (delta_x < 0) 686 c0 |= 0x10; 687 if (delta_y < 0) 688 c0 |= 0x20; 689 c0 |= 0x08; 690 if (but & CYAPA_FNGR_LEFT) 691 c0 |= 0x01; 692 if (but & CYAPA_FNGR_MIDDLE) 693 c0 |= 0x04; 694 if (but & CYAPA_FNGR_RIGHT) 695 c0 |= 0x02; 696 697 fifo_write_char(sc, &sc->rfifo, c0); 698 fifo_write_char(sc, &sc->rfifo, (uint8_t)delta_x); 699 fifo_write_char(sc, &sc->rfifo, (uint8_t)delta_y); 700 switch(sc->zenabled) { 701 case 1: 702 /* Z axis all 8 bits */ 703 fifo_write_char(sc, &sc->rfifo, (uint8_t)delta_z); 704 break; 705 case 2: 706 /* 707 * Z axis low 4 bits + 4th button and 5th button 708 * (high 2 bits must be left 0). Auto-scale 709 * delta_z to fit to avoid a wrong-direction 710 * overflow (don't try to retain the remainder). 711 */ 712 while (delta_z > 7 || delta_z < -8) 713 delta_z >>= 1; 714 c0 = (uint8_t)delta_z & 0x0F; 715 fifo_write_char(sc, &sc->rfifo, c0); 716 break; 717 default: 718 /* basic PS/2 */ 719 break; 720 } 721 cyapa_notify(sc); 722 } 723 724 /* Blocking / Non-blocking */ 725 error = 0; 726 didread = (uio->uio_resid == 0); 727 728 while ((ioflag & IO_NDELAY) == 0 && fifo_empty(sc, &sc->rfifo)) { 729 if (sc->data_signal) 730 goto again; 731 sc->blocked = 1; 732 error = mtx_sleep(&sc->blocked, &sc->mutex, PCATCH, "cyablk", 0); 733 if (error) 734 break; 735 } 736 737 /* Return any buffered data */ 738 while (error == 0 && uio->uio_resid && 739 (n = fifo_ready(sc, &sc->rfifo)) > 0) { 740 if (n > uio->uio_resid) 741 n = uio->uio_resid; 742 ptr = fifo_read(sc, &sc->rfifo, 0); 743 cyapa_unlock(sc); 744 error = uiomove(ptr, n, uio); 745 cyapa_lock(sc); 746 if (error) 747 break; 748 fifo_read(sc, &sc->rfifo, n); 749 didread = 1; 750 } 751 cyapa_unlock(sc); 752 753 if (error == 0 && didread == 0) { 754 error = EWOULDBLOCK; 755 } 756 return (didread ? 0 : error); 757 } 758 759 static int 760 cyapawrite(struct cdev *dev, struct uio *uio, int ioflag) 761 { 762 struct cyapa_softc *sc; 763 int error; 764 int cmd_completed; 765 size_t n; 766 uint8_t c0; 767 char* ptr; 768 769 sc = dev->si_drv1; 770 again: 771 /* 772 * Copy data from userland. This will also cross-over the end 773 * of the fifo and keep filling. 774 */ 775 cyapa_lock(sc); 776 while ((n = fifo_space(sc, &sc->wfifo)) > 0 && uio->uio_resid) { 777 if (n > uio->uio_resid) 778 n = uio->uio_resid; 779 ptr = fifo_write(sc, &sc->wfifo, 0); 780 cyapa_unlock(sc); 781 error = uiomove(ptr, n, uio); 782 cyapa_lock(sc); 783 if (error) 784 break; 785 fifo_write(sc, &sc->wfifo, n); 786 } 787 788 /* Handle commands */ 789 cmd_completed = (fifo_ready(sc, &sc->wfifo) != 0); 790 while (fifo_ready(sc, &sc->wfifo) && cmd_completed && error == 0) { 791 if (sc->ps2_cmd == 0) 792 sc->ps2_cmd = fifo_read_char(sc, &sc->wfifo); 793 switch(sc->ps2_cmd) { 794 case 0xE6: 795 /* SET SCALING 1:1 */ 796 sc->scaling_mode = 0; 797 fifo_write_char(sc, &sc->rfifo, 0xFA); 798 break; 799 case 0xE7: 800 /* SET SCALING 2:1 */ 801 sc->scaling_mode = 1; 802 fifo_write_char(sc, &sc->rfifo, 0xFA); 803 break; 804 case 0xE8: 805 /* SET RESOLUTION +1 byte */ 806 if (sc->ps2_acked == 0) { 807 sc->ps2_acked = 1; 808 fifo_write_char(sc, &sc->rfifo, 0xFA); 809 } 810 if (fifo_ready(sc, &sc->wfifo) == 0) { 811 cmd_completed = 0; 812 break; 813 } 814 sc->mode.resolution = fifo_read_char(sc, &sc->wfifo); 815 fifo_write_char(sc, &sc->rfifo, 0xFA); 816 break; 817 case 0xE9: 818 /* 819 * STATUS REQUEST 820 * 821 * byte1: 822 * bit 7 0 823 * bit 6 Mode (1=remote mode, 0=stream mode) 824 * bit 5 Enable (data reporting enabled) 825 * bit 4 Scaling (0=1:1 1=2:1) 826 * bit 3 0 827 * bit 2 LEFT BUTTON (1 if pressed) 828 * bit 1 MIDDLE BUTTON (1 if pressed) 829 * bit 0 RIGHT BUTTON (1 if pressed) 830 * 831 * byte2: resolution counts/mm 832 * byte3: sample rate 833 */ 834 c0 = 0; 835 if (sc->remote_mode) 836 c0 |= 0x40; 837 if (sc->reporting_mode) 838 c0 |= 0x20; 839 if (sc->scaling_mode) 840 c0 |= 0x10; 841 if (sc->track_but & CYAPA_FNGR_LEFT) 842 c0 |= 0x04; 843 if (sc->track_but & CYAPA_FNGR_MIDDLE) 844 c0 |= 0x02; 845 if (sc->track_but & CYAPA_FNGR_RIGHT) 846 c0 |= 0x01; 847 fifo_write_char(sc, &sc->rfifo, 0xFA); 848 fifo_write_char(sc, &sc->rfifo, c0); 849 fifo_write_char(sc, &sc->rfifo, 0x00); 850 fifo_write_char(sc, &sc->rfifo, 100); 851 break; 852 case 0xEA: 853 /* Set stream mode and reset movement counters */ 854 sc->remote_mode = 0; 855 fifo_write_char(sc, &sc->rfifo, 0xFA); 856 sc->delta_x = 0; 857 sc->delta_y = 0; 858 sc->delta_z = 0; 859 break; 860 case 0xEB: 861 /* 862 * Read Data (if in remote mode). If not in remote 863 * mode force an event. 864 */ 865 fifo_write_char(sc, &sc->rfifo, 0xFA); 866 sc->data_signal = 1; 867 break; 868 case 0xEC: 869 /* Reset Wrap Mode (ignored) */ 870 fifo_write_char(sc, &sc->rfifo, 0xFA); 871 break; 872 case 0xEE: 873 /* Set Wrap Mode (ignored) */ 874 fifo_write_char(sc, &sc->rfifo, 0xFA); 875 break; 876 case 0xF0: 877 /* Set Remote Mode */ 878 sc->remote_mode = 1; 879 fifo_write_char(sc, &sc->rfifo, 0xFA); 880 sc->delta_x = 0; 881 sc->delta_y = 0; 882 sc->delta_z = 0; 883 break; 884 case 0xF2: 885 /* 886 * Get Device ID 887 * 888 * If we send 0x00 - normal PS/2 mouse, no Z-axis 889 * 890 * If we send 0x03 - Intellimouse, data packet has 891 * an additional Z movement byte (8 bits signed). 892 * (also reset movement counters) 893 * 894 * If we send 0x04 - Now includes z-axis and the 895 * 4th and 5th mouse buttons. 896 */ 897 fifo_write_char(sc, &sc->rfifo, 0xFA); 898 switch(sc->zenabled) { 899 case 1: 900 fifo_write_char(sc, &sc->rfifo, 0x03); 901 break; 902 case 2: 903 fifo_write_char(sc, &sc->rfifo, 0x04); 904 break; 905 default: 906 fifo_write_char(sc, &sc->rfifo, 0x00); 907 break; 908 } 909 sc->delta_x = 0; 910 sc->delta_y = 0; 911 sc->delta_z = 0; 912 break; 913 case 0xF3: 914 /* 915 * Set Sample Rate 916 * 917 * byte1: the sample rate 918 */ 919 if (sc->ps2_acked == 0) { 920 sc->ps2_acked = 1; 921 fifo_write_char(sc, &sc->rfifo, 0xFA); 922 } 923 if (fifo_ready(sc, &sc->wfifo) == 0) { 924 cmd_completed = 0; 925 break; 926 } 927 sc->mode.rate = fifo_read_char(sc, &sc->wfifo); 928 fifo_write_char(sc, &sc->rfifo, 0xFA); 929 930 /* 931 * zenabling sequence: 200,100,80 (device id 0x03) 932 * 200,200,80 (device id 0x04) 933 * 934 * We support id 0x03 (no 4th or 5th button). 935 * We support id 0x04 (w/ 4th and 5th button). 936 */ 937 if (sc->zenabled == 0 && sc->mode.rate == 200) 938 sc->zenabled = -1; 939 else if (sc->zenabled == -1 && sc->mode.rate == 100) 940 sc->zenabled = -2; 941 else if (sc->zenabled == -1 && sc->mode.rate == 200) 942 sc->zenabled = -3; 943 else if (sc->zenabled == -2 && sc->mode.rate == 80) 944 sc->zenabled = 1; /* z-axis mode */ 945 else if (sc->zenabled == -3 && sc->mode.rate == 80) 946 sc->zenabled = 2; /* z-axis+but4/5 */ 947 if (sc->mode.level) 948 sc->zenabled = 1; 949 break; 950 case 0xF4: 951 /* Enable data reporting. Only effects stream mode. */ 952 fifo_write_char(sc, &sc->rfifo, 0xFA); 953 sc->reporting_mode = 1; 954 break; 955 case 0xF5: 956 /* 957 * Disable data reporting. Only effects stream mode 958 * and is ignored right now. 959 */ 960 fifo_write_char(sc, &sc->rfifo, 0xFA); 961 sc->reporting_mode = 1; 962 break; 963 case 0xF6: 964 /* 965 * SET DEFAULTS 966 * 967 * (reset sampling rate, resolution, scaling and 968 * enter stream mode) 969 */ 970 fifo_write_char(sc, &sc->rfifo, 0xFA); 971 sc->mode.rate = 100; 972 sc->mode.resolution = 4; 973 sc->scaling_mode = 0; 974 sc->reporting_mode = 1; 975 sc->remote_mode = 0; 976 sc->delta_x = 0; 977 sc->delta_y = 0; 978 sc->delta_z = 0; 979 /* signal */ 980 break; 981 case 0xFE: 982 /* 983 * RESEND 984 * 985 * Force a resend by guaranteeing that reported_but 986 * differs from track_but. 987 */ 988 fifo_write_char(sc, &sc->rfifo, 0xFA); 989 sc->data_signal = 1; 990 break; 991 case 0xFF: 992 /* 993 * RESET 994 */ 995 fifo_reset(sc, &sc->rfifo); /* should we do this? */ 996 fifo_reset(sc, &sc->wfifo); /* should we do this? */ 997 fifo_write_char(sc, &sc->rfifo, 0xFA); 998 sc->delta_x = 0; 999 sc->delta_y = 0; 1000 sc->delta_z = 0; 1001 sc->zenabled = 0; 1002 sc->mode.level = 0; 1003 break; 1004 default: 1005 printf("unknown command %02x\n", sc->ps2_cmd); 1006 break; 1007 } 1008 if (cmd_completed) { 1009 sc->ps2_cmd = 0; 1010 sc->ps2_acked = 0; 1011 } 1012 cyapa_notify(sc); 1013 } 1014 cyapa_unlock(sc); 1015 if (error == 0 && (cmd_completed || uio->uio_resid)) 1016 goto again; 1017 return (error); 1018 } 1019 1020 static void cyapafiltdetach(struct knote *); 1021 static int cyapafilt(struct knote *, long); 1022 1023 static struct filterops cyapa_filtops = { 1024 .f_isfd = 1, 1025 .f_detach = cyapafiltdetach, 1026 .f_event = cyapafilt 1027 }; 1028 1029 static int 1030 cyapakqfilter(struct cdev *dev, struct knote *kn) 1031 { 1032 struct cyapa_softc *sc; 1033 struct knlist *knlist; 1034 1035 sc = dev->si_drv1; 1036 1037 switch(kn->kn_filter) { 1038 case EVFILT_READ: 1039 kn->kn_fop = &cyapa_filtops; 1040 kn->kn_hook = (void *)sc; 1041 break; 1042 default: 1043 return (EOPNOTSUPP); 1044 } 1045 knlist = &sc->selinfo.si_note; 1046 knlist_add(knlist, kn, 0); 1047 1048 return (0); 1049 } 1050 1051 static int 1052 cyapapoll(struct cdev *dev, int events, struct thread *td) 1053 { 1054 struct cyapa_softc *sc; 1055 int revents; 1056 1057 sc = dev->si_drv1; 1058 revents = 0; 1059 1060 cyapa_lock(sc); 1061 if (events & (POLLIN | POLLRDNORM)) { 1062 if (sc->data_signal || !fifo_empty(sc, &sc->rfifo)) 1063 revents = events & (POLLIN | POLLRDNORM); 1064 else { 1065 sc->isselect = 1; 1066 selrecord(td, &sc->selinfo); 1067 } 1068 } 1069 cyapa_unlock(sc); 1070 1071 return (revents); 1072 } 1073 1074 static void 1075 cyapafiltdetach(struct knote *kn) 1076 { 1077 struct cyapa_softc *sc; 1078 struct knlist *knlist; 1079 1080 sc = (struct cyapa_softc *)kn->kn_hook; 1081 1082 knlist = &sc->selinfo.si_note; 1083 knlist_remove(knlist, kn, 0); 1084 } 1085 1086 static int 1087 cyapafilt(struct knote *kn, long hint) 1088 { 1089 struct cyapa_softc *sc; 1090 int ready; 1091 1092 sc = (struct cyapa_softc *)kn->kn_hook; 1093 1094 cyapa_lock(sc); 1095 ready = fifo_ready(sc, &sc->rfifo) || sc->data_signal; 1096 cyapa_unlock(sc); 1097 1098 return (ready); 1099 } 1100 1101 static int 1102 cyapaioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td) 1103 { 1104 struct cyapa_softc *sc; 1105 int error; 1106 1107 sc = dev->si_drv1; 1108 error = 0; 1109 1110 cyapa_lock(sc); 1111 switch (cmd) { 1112 case MOUSE_GETHWINFO: 1113 *(mousehw_t *)data = sc->hw; 1114 if (sc->mode.level == 0) 1115 ((mousehw_t *)data)->model = MOUSE_MODEL_GENERIC; 1116 break; 1117 1118 case MOUSE_GETMODE: 1119 *(mousemode_t *)data = sc->mode; 1120 ((mousemode_t *)data)->resolution = 1121 MOUSE_RES_LOW - sc->mode.resolution; 1122 switch (sc->mode.level) { 1123 case 0: 1124 ((mousemode_t *)data)->protocol = MOUSE_PROTO_PS2; 1125 ((mousemode_t *)data)->packetsize = 1126 MOUSE_PS2_PACKETSIZE; 1127 break; 1128 case 2: 1129 ((mousemode_t *)data)->protocol = MOUSE_PROTO_PS2; 1130 ((mousemode_t *)data)->packetsize = 1131 MOUSE_PS2_PACKETSIZE + 1; 1132 break; 1133 } 1134 break; 1135 1136 case MOUSE_GETLEVEL: 1137 *(int *)data = sc->mode.level; 1138 break; 1139 1140 case MOUSE_SETLEVEL: 1141 if ((*(int *)data < 0) && 1142 (*(int *)data > 2)) { 1143 error = EINVAL; 1144 break; 1145 } 1146 sc->mode.level = *(int *)data ? 2 : 0; 1147 sc->zenabled = sc->mode.level ? 1 : 0; 1148 break; 1149 1150 default: 1151 error = ENOTTY; 1152 break; 1153 } 1154 cyapa_unlock(sc); 1155 1156 return (error); 1157 } 1158 1159 /* 1160 * MAJOR SUPPORT FUNCTIONS 1161 */ 1162 static void 1163 cyapa_poll_thread(void *arg) 1164 { 1165 struct cyapa_softc *sc; 1166 struct cyapa_regs regs; 1167 device_t bus; /* smbus */ 1168 int error; 1169 int freq; 1170 int isidle; 1171 int pstate; 1172 int npstate; 1173 int last_reset; 1174 1175 sc = arg; 1176 freq = cyapa_norm_freq; 1177 isidle = 0; 1178 pstate = CMD_POWER_MODE_IDLE; 1179 last_reset = ticks; 1180 1181 bus = device_get_parent(sc->dev); 1182 1183 cyapa_lock(sc); 1184 sc->poll_thread_running = 1; 1185 1186 while (!sc->detaching) { 1187 cyapa_unlock(sc); 1188 error = smbus_request_bus(bus, sc->dev, SMB_WAIT); 1189 if (error == 0) { 1190 error = smbus_trans(bus, sc->addr, CMD_DEV_STATUS, 1191 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 1192 NULL, 0, 1193 (void *)®s, sizeof(regs), NULL); 1194 if (error == 0) { 1195 isidle = cyapa_raw_input(sc, ®s, freq); 1196 } 1197 1198 /* 1199 * For some reason the device can crap-out. If it 1200 * drops back into bootstrap mode try to reinitialize 1201 * it. 1202 */ 1203 if (cyapa_reset || 1204 ((regs.stat & CYAPA_STAT_RUNNING) == 0 && 1205 (unsigned)(ticks - last_reset) > TIME_TO_RESET)) { 1206 cyapa_reset = 0; 1207 last_reset = ticks; 1208 init_device(sc->dev, NULL, sc->addr, 2); 1209 } 1210 smbus_release_bus(bus, sc->dev); 1211 } 1212 pause("cyapw", hz / freq); 1213 ++sc->poll_ticks; 1214 1215 if (sc->count == 0) { 1216 freq = cyapa_idle_freq; 1217 npstate = CMD_POWER_MODE_IDLE; 1218 } else if (isidle) { 1219 freq = cyapa_slow_freq; 1220 npstate = CMD_POWER_MODE_IDLE; 1221 } else { 1222 freq = cyapa_norm_freq; 1223 npstate = CMD_POWER_MODE_FULL; 1224 } 1225 if (pstate != npstate) { 1226 pstate = npstate; 1227 cyapa_set_power_mode(sc, pstate); 1228 if (cyapa_debug) { 1229 switch(pstate) { 1230 case CMD_POWER_MODE_OFF: 1231 printf("cyapa: power off\n"); 1232 break; 1233 case CMD_POWER_MODE_IDLE: 1234 printf("cyapa: power idle\n"); 1235 break; 1236 case CMD_POWER_MODE_FULL: 1237 printf("cyapa: power full\n"); 1238 break; 1239 } 1240 } 1241 } 1242 1243 cyapa_lock(sc); 1244 } 1245 sc->poll_thread_running = 0; 1246 cyapa_unlock(sc); 1247 kthread_exit(); 1248 } 1249 1250 static int 1251 cyapa_raw_input(struct cyapa_softc *sc, struct cyapa_regs *regs, int freq) 1252 { 1253 int nfingers; 1254 int afingers; /* actual fingers after culling */ 1255 int i; 1256 int j; 1257 int k; 1258 int isidle; 1259 int thumbarea_begin; 1260 int seen_thumb; 1261 int x; 1262 int y; 1263 int z; 1264 int newfinger; 1265 int lessfingers; 1266 int click_x; 1267 int click_y; 1268 uint16_t but; /* high bits used for simulated but4/but5 */ 1269 1270 thumbarea_begin = sc->cap_resy - 1271 ((sc->cap_resy * cyapa_thumbarea_percent) / 100); 1272 click_x = click_y = 0; 1273 1274 /* 1275 * If the device is not running the rest of the status 1276 * means something else, set fingers to 0. 1277 */ 1278 if ((regs->stat & CYAPA_STAT_RUNNING) == 0) { 1279 regs->fngr = 0; 1280 } 1281 1282 /* Process fingers/movement */ 1283 nfingers = CYAPA_FNGR_NUMFINGERS(regs->fngr); 1284 afingers = nfingers; 1285 1286 if (cyapa_debug) { 1287 printf("stat %02x buttons %c%c%c nfngrs=%d ", 1288 regs->stat, 1289 ((regs->fngr & CYAPA_FNGR_LEFT) ? 'L' : '-'), 1290 ((regs->fngr & CYAPA_FNGR_MIDDLE) ? 'M' : '-'), 1291 ((regs->fngr & CYAPA_FNGR_RIGHT) ? 'R' : '-'), 1292 nfingers); 1293 } 1294 1295 seen_thumb = 0; 1296 for (i = 0; i < afingers; ) { 1297 if (cyapa_debug) { 1298 printf(" [x=%04d y=%04d p=%d i=%d]", 1299 CYAPA_TOUCH_X(regs, i), 1300 CYAPA_TOUCH_Y(regs, i), 1301 CYAPA_TOUCH_P(regs, i), 1302 regs->touch[i].id); 1303 } 1304 if ((CYAPA_TOUCH_Y(regs, i) > thumbarea_begin && seen_thumb) || 1305 CYAPA_TOUCH_P(regs, i) < cyapa_minpressure) { 1306 --afingers; 1307 if (i < afingers) { 1308 regs->touch[i] = regs->touch[i+1]; 1309 continue; 1310 } 1311 } else { 1312 if (CYAPA_TOUCH_Y(regs, i) > thumbarea_begin) 1313 seen_thumb = 1; 1314 } 1315 ++i; 1316 } 1317 nfingers = afingers; 1318 1319 /* Tracking for local solutions */ 1320 cyapa_lock(sc); 1321 1322 /* 1323 * Track timing for finger-downs. Used to detect false-3-finger 1324 * button-down. 1325 */ 1326 switch(afingers) { 1327 case 0: 1328 break; 1329 case 1: 1330 if (sc->track_nfingers == 0) 1331 sc->finger1_ticks = sc->poll_ticks; 1332 break; 1333 case 2: 1334 if (sc->track_nfingers <= 0) 1335 sc->finger1_ticks = sc->poll_ticks; 1336 if (sc->track_nfingers <= 1) 1337 sc->finger2_ticks = sc->poll_ticks; 1338 break; 1339 case 3: 1340 default: 1341 if (sc->track_nfingers <= 0) 1342 sc->finger1_ticks = sc->poll_ticks; 1343 if (sc->track_nfingers <= 1) 1344 sc->finger2_ticks = sc->poll_ticks; 1345 if (sc->track_nfingers <= 2) 1346 sc->finger3_ticks = sc->poll_ticks; 1347 break; 1348 } 1349 newfinger = sc->track_nfingers < afingers; 1350 lessfingers = sc->track_nfingers > afingers; 1351 sc->track_nfingers = afingers; 1352 1353 /* 1354 * Lookup and track finger indexes in the touch[] array. 1355 */ 1356 if (afingers == 0) { 1357 click_x = sc->track_x; 1358 click_y = sc->track_y; 1359 sc->track_x = -1; 1360 sc->track_y = -1; 1361 sc->track_z = -1; 1362 sc->fuzz_x = 0; 1363 sc->fuzz_y = 0; 1364 sc->fuzz_z = 0; 1365 sc->touch_x = -1; 1366 sc->touch_y = -1; 1367 sc->touch_z = -1; 1368 sc->track_id = -1; 1369 sc->track_but = 0; 1370 i = 0; 1371 j = 0; 1372 k = 0; 1373 } else { 1374 /* 1375 * The id assigned on touch can move around in the array, 1376 * find it. If that finger is lifted up, assign some other 1377 * finger for mouse tracking and reset track_x and track_y 1378 * to avoid a mouse jump. 1379 * 1380 * If >= 2 fingers are down be sure not to assign i and 1381 * j to the same index. 1382 */ 1383 for (i = 0; i < nfingers; ++i) { 1384 if (sc->track_id == regs->touch[i].id) 1385 break; 1386 } 1387 if (i == nfingers) { 1388 i = 0; 1389 sc->track_x = -1; 1390 sc->track_y = -1; 1391 sc->track_z = -1; 1392 while (CYAPA_TOUCH_Y(regs, i) >= thumbarea_begin && 1393 i < nfingers) ++i; 1394 if (i == nfingers) { 1395 i = 0; 1396 } 1397 sc->track_id = regs->touch[i].id; 1398 } 1399 else if ((sc->track_but || 1400 CYAPA_TOUCH_Y(regs, i) >= thumbarea_begin) && 1401 newfinger && afingers == 2) { 1402 j = regs->touch[0].id == sc->track_id ? 1 : 0; 1403 if (CYAPA_TOUCH_Y(regs, j) < thumbarea_begin) { 1404 i = j; 1405 sc->track_x = -1; 1406 sc->track_y = -1; 1407 sc->track_z = -1; 1408 sc->track_id = regs->touch[i].id; 1409 } 1410 } 1411 } 1412 1413 /* Two finger scrolling - reset after timeout */ 1414 if (sc->track_z != -1 && afingers != 2 && 1415 (sc->poll_ticks - sc->track_z_ticks) > cyapa_scroll_stick_ticks) { 1416 sc->track_z = -1; 1417 sc->track_z_ticks = 0; 1418 } 1419 1420 /* Initiate two finger scrolling */ 1421 if (!(regs->fngr & CYAPA_FNGR_LEFT) && 1422 ((afingers && sc->track_z != -1) || 1423 (afingers == 2 && CYAPA_TOUCH_Y(regs, 0) < thumbarea_begin && 1424 CYAPA_TOUCH_Y(regs, 1) < thumbarea_begin))) { 1425 if (afingers == 2 && (sc->poll_ticks - sc->finger2_ticks) 1426 > cyapa_scroll_wait_ticks) { 1427 z = (CYAPA_TOUCH_Y(regs, 0) + 1428 CYAPA_TOUCH_Y(regs, 1)) >> 1; 1429 sc->delta_z += z / ZSCALE - sc->track_z; 1430 if (sc->track_z == -1) { 1431 sc->delta_z = 0; 1432 } 1433 if (sc->touch_z == -1) 1434 sc->touch_z = z; /* not used atm */ 1435 sc->track_z = z / ZSCALE; 1436 sc->track_z_ticks = sc->poll_ticks; 1437 } 1438 } else if (afingers) { 1439 /* Normal pad position reporting */ 1440 x = CYAPA_TOUCH_X(regs, i); 1441 y = CYAPA_TOUCH_Y(regs, i); 1442 click_x = x; 1443 click_y = y; 1444 if (sc->track_x != -1 && sc->track_y < thumbarea_begin && 1445 (afingers > 1 || (sc->poll_ticks - sc->finger1_ticks) 1446 >= cyapa_move_min_ticks || freq < cyapa_norm_freq)) { 1447 sc->delta_x += x - sc->track_x; 1448 sc->delta_y -= y - sc->track_y; 1449 if (sc->delta_x > sc->cap_resx) 1450 sc->delta_x = sc->cap_resx; 1451 if (sc->delta_x < -sc->cap_resx) 1452 sc->delta_x = -sc->cap_resx; 1453 if (sc->delta_y > sc->cap_resx) 1454 sc->delta_y = sc->cap_resy; 1455 if (sc->delta_y < -sc->cap_resy) 1456 sc->delta_y = -sc->cap_resy; 1457 1458 if (abs(sc->delta_y) > sc->cap_resy / 2 || 1459 abs(sc->delta_x) > sc->cap_resx / 2) { 1460 if (cyapa_debug) 1461 printf("Detected jump by %i %i\n", 1462 sc->delta_x, sc->delta_y); 1463 sc->delta_x = sc->delta_y = 0; 1464 } 1465 } 1466 if (sc->touch_x == -1) { 1467 sc->touch_x = x; 1468 sc->touch_y = y; 1469 } 1470 sc->track_x = x; 1471 sc->track_y = y; 1472 } 1473 1474 /* Select finger (L = 2/3x, M = 1/3u, R = 1/3d) */ 1475 int is_tapclick = (cyapa_enable_tapclick && lessfingers && 1476 afingers == 0 && sc->poll_ticks - sc->finger1_ticks 1477 >= cyapa_tapclick_min_ticks && 1478 sc->poll_ticks - sc->finger1_ticks < cyapa_tapclick_max_ticks); 1479 1480 if (regs->fngr & CYAPA_FNGR_LEFT || is_tapclick) { 1481 if (sc->track_but) { 1482 but = sc->track_but; 1483 } else if (afingers == 1) { 1484 if (click_x < sc->cap_resx * 2 / 3) 1485 but = CYAPA_FNGR_LEFT; 1486 else if (click_y < sc->cap_resy / 2) 1487 but = CYAPA_FNGR_MIDDLE; 1488 else 1489 but = CYAPA_FNGR_RIGHT; 1490 } else if (is_tapclick) { 1491 if (click_x < sc->cap_resx * 2 / 3 || 1492 cyapa_enable_tapclick < 2) 1493 but = CYAPA_FNGR_LEFT; 1494 else if (click_y < sc->cap_resy / 2 && 1495 cyapa_enable_tapclick > 2) 1496 but = CYAPA_FNGR_MIDDLE; 1497 else 1498 but = CYAPA_FNGR_RIGHT; 1499 } else { 1500 but = CYAPA_FNGR_LEFT; 1501 } 1502 } else { 1503 but = 0; 1504 } 1505 1506 /* 1507 * Detect state change from last reported state and 1508 * determine if we have gone idle. 1509 */ 1510 sc->track_but = but; 1511 if (sc->delta_x || sc->delta_y || sc->delta_z || 1512 sc->track_but != sc->reported_but) { 1513 sc->active_tick = ticks; 1514 if (sc->remote_mode == 0 && sc->reporting_mode) 1515 sc->data_signal = 1; 1516 isidle = 0; 1517 } else if ((unsigned)(ticks - sc->active_tick) >= TIME_TO_IDLE) { 1518 sc->active_tick = ticks - TIME_TO_IDLE; /* prevent overflow */ 1519 isidle = 1; 1520 } else { 1521 isidle = 0; 1522 } 1523 cyapa_notify(sc); 1524 cyapa_unlock(sc); 1525 1526 if (cyapa_debug) 1527 printf("%i >> %i << %i\n", isidle, sc->track_id, sc->delta_y); 1528 return (isidle); 1529 } 1530 1531 static void 1532 cyapa_set_power_mode(struct cyapa_softc *sc, int mode) 1533 { 1534 uint8_t data; 1535 device_t bus; 1536 int error; 1537 1538 bus = device_get_parent(sc->dev); 1539 error = smbus_request_bus(bus, sc->dev, SMB_WAIT); 1540 if (error == 0) { 1541 error = smbus_trans(bus, sc->addr, CMD_POWER_MODE, 1542 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 1543 NULL, 0, (void *)&data, 1, NULL); 1544 data = (data & ~0xFC) | mode; 1545 if (error == 0) { 1546 error = smbus_trans(bus, sc->addr, CMD_POWER_MODE, 1547 SMB_TRANS_NOCNT | SMB_TRANS_7BIT, 1548 (void *)&data, 1, NULL, 0, NULL); 1549 } 1550 smbus_release_bus(bus, sc->dev); 1551 } 1552 } 1553 1554 /* 1555 * FIFO FUNCTIONS 1556 */ 1557 1558 /* 1559 * Returns non-zero if the fifo is empty 1560 */ 1561 static int 1562 fifo_empty(struct cyapa_softc *sc, struct cyapa_fifo *fifo) 1563 { 1564 1565 CYAPA_LOCK_ASSERT(sc); 1566 1567 return (fifo->rindex == fifo->windex); 1568 } 1569 1570 /* 1571 * Returns the number of characters available for reading from 1572 * the fifo without wrapping the fifo buffer. 1573 */ 1574 static size_t 1575 fifo_ready(struct cyapa_softc *sc, struct cyapa_fifo *fifo) 1576 { 1577 size_t n; 1578 1579 CYAPA_LOCK_ASSERT(sc); 1580 1581 n = CYAPA_BUFSIZE - (fifo->rindex & CYAPA_BUFMASK); 1582 if (n > (size_t)(fifo->windex - fifo->rindex)) 1583 n = (size_t)(fifo->windex - fifo->rindex); 1584 return (n); 1585 } 1586 1587 /* 1588 * Returns a read pointer into the fifo and then bumps 1589 * rindex. The FIFO must have at least 'n' characters in 1590 * it. The value (n) can cause the index to wrap but users 1591 * of the buffer should never supply a value for (n) that wraps 1592 * the buffer. 1593 */ 1594 static char * 1595 fifo_read(struct cyapa_softc *sc, struct cyapa_fifo *fifo, size_t n) 1596 { 1597 char *ptr; 1598 1599 CYAPA_LOCK_ASSERT(sc); 1600 if (n > (CYAPA_BUFSIZE - (fifo->rindex & CYAPA_BUFMASK))) { 1601 printf("fifo_read: overflow\n"); 1602 return (fifo->buf); 1603 } 1604 ptr = fifo->buf + (fifo->rindex & CYAPA_BUFMASK); 1605 fifo->rindex += n; 1606 1607 return (ptr); 1608 } 1609 1610 static uint8_t 1611 fifo_read_char(struct cyapa_softc *sc, struct cyapa_fifo *fifo) 1612 { 1613 uint8_t c; 1614 1615 CYAPA_LOCK_ASSERT(sc); 1616 1617 if (fifo->rindex == fifo->windex) { 1618 printf("fifo_read_char: overflow\n"); 1619 c = 0; 1620 } else { 1621 c = fifo->buf[fifo->rindex & CYAPA_BUFMASK]; 1622 ++fifo->rindex; 1623 } 1624 return (c); 1625 } 1626 1627 1628 /* 1629 * Write a character to the FIFO. The character will be discarded 1630 * if the FIFO is full. 1631 */ 1632 static void 1633 fifo_write_char(struct cyapa_softc *sc, struct cyapa_fifo *fifo, uint8_t c) 1634 { 1635 1636 CYAPA_LOCK_ASSERT(sc); 1637 1638 if (fifo->windex - fifo->rindex < CYAPA_BUFSIZE) { 1639 fifo->buf[fifo->windex & CYAPA_BUFMASK] = c; 1640 ++fifo->windex; 1641 } 1642 } 1643 1644 /* 1645 * Return the amount of space available for writing without wrapping 1646 * the fifo. 1647 */ 1648 static size_t 1649 fifo_space(struct cyapa_softc *sc, struct cyapa_fifo *fifo) 1650 { 1651 size_t n; 1652 1653 CYAPA_LOCK_ASSERT(sc); 1654 1655 n = CYAPA_BUFSIZE - (fifo->windex & CYAPA_BUFMASK); 1656 if (n > (size_t)(CYAPA_BUFSIZE - (fifo->windex - fifo->rindex))) 1657 n = (size_t)(CYAPA_BUFSIZE - (fifo->windex - fifo->rindex)); 1658 return (n); 1659 } 1660 1661 static char * 1662 fifo_write(struct cyapa_softc *sc, struct cyapa_fifo *fifo, size_t n) 1663 { 1664 char *ptr; 1665 1666 CYAPA_LOCK_ASSERT(sc); 1667 1668 ptr = fifo->buf + (fifo->windex & CYAPA_BUFMASK); 1669 fifo->windex += n; 1670 1671 return (ptr); 1672 } 1673 1674 static void 1675 fifo_reset(struct cyapa_softc *sc, struct cyapa_fifo *fifo) 1676 { 1677 1678 CYAPA_LOCK_ASSERT(sc); 1679 1680 fifo->rindex = 0; 1681 fifo->windex = 0; 1682 } 1683 1684 /* 1685 * Fuzz handling 1686 */ 1687 static int 1688 cyapa_fuzz(int delta, int *fuzzp) 1689 { 1690 int fuzz; 1691 1692 fuzz = *fuzzp; 1693 if (fuzz >= 0 && delta < 0) { 1694 ++delta; 1695 --fuzz; 1696 } else if (fuzz <= 0 && delta > 0) { 1697 --delta; 1698 ++fuzz; 1699 } 1700 *fuzzp = fuzz; 1701 1702 return (delta); 1703 } 1704 1705 DRIVER_MODULE(cyapa, smbus, cyapa_driver, cyapa_devclass, NULL, NULL); 1706 MODULE_DEPEND(cyapa, smbus, SMBUS_MINVER, SMBUS_PREFVER, SMBUS_MAXVER); 1707 MODULE_VERSION(cyapa, 1); 1708