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