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