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