1819 lines
44 KiB
C
1819 lines
44 KiB
C
/*
|
|
* Copyright (c) 2014 The DragonFly Project. All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The DragonFly Project
|
|
* by Matthew Dillon <dillon@backplane.com> and was subsequently ported,
|
|
* modified and enhanced for FreeBSD by Michael Gmelin <freebsd@grem.de>.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* 3. Neither the name of The DragonFly Project nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific, prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
/*
|
|
* CYAPA - Cypress APA trackpad with I2C Interface driver
|
|
*
|
|
* Based on DragonFlyBSD's cyapa driver, which referenced the linux
|
|
* cyapa.c driver to figure out the bootstrapping and commands.
|
|
*
|
|
* Unable to locate any datasheet for the device.
|
|
*
|
|
*
|
|
* Trackpad layout:
|
|
*
|
|
* 2/3 1/3
|
|
* +--------------------+------------+
|
|
* | | Middle |
|
|
* | | Button |
|
|
* | Left | |
|
|
* | Button +------------+
|
|
* | | Right |
|
|
* | | Button |
|
|
* +--------------------+............|
|
|
* | Thumb/Button Area | 15%
|
|
* +---------------------------------+
|
|
*
|
|
*
|
|
* FEATURES
|
|
*
|
|
* IMPS/2 emulation - Emulates the IntelliMouse protocol.
|
|
*
|
|
* Jitter supression - Implements 2-pixel hysteresis with memory.
|
|
*
|
|
* Jump detecion - Detect jumps caused by touchpad.
|
|
*
|
|
* Two finger scrolling - Use two fingers for Z axis scrolling.
|
|
*
|
|
* Button down/2nd finger - While one finger clicks and holds down the
|
|
* touchpad, the second one can be used to move
|
|
* the mouse cursor. Useful for drawing or
|
|
* selecting text.
|
|
*
|
|
* Thumb/Button Area - The lower 15%* of the trackpad will not affect
|
|
* the mouse cursor position. This allows for high
|
|
* precision clicking, by controlling the cursor
|
|
* with the index finger and pushing/holding the
|
|
* pad down with the thumb.
|
|
* * can be changed using sysctl
|
|
*
|
|
* Track-pad button - Push physical button. Left 2/3rds of the pad
|
|
* will issue a LEFT button event, upper right
|
|
* corner will issue a MIDDLE button event,
|
|
* lower right corner will issue a RIGHT button
|
|
* event. Optional tap support can be enabled
|
|
* and configured using sysctl.
|
|
*
|
|
* WARNINGS
|
|
*
|
|
* These trackpads get confused when three or more fingers are down on the
|
|
* same horizontal axis and will start to glitch the finger detection.
|
|
* Removing your hand for a few seconds will allow the trackpad to
|
|
* recalibrate. Generally speaking, when using three or more fingers
|
|
* please try to place at least one finger off-axis (a little above or
|
|
* below) the other two.
|
|
*/
|
|
|
|
#include "opt_evdev.h"
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/conf.h>
|
|
#include <sys/event.h>
|
|
#include <sys/fcntl.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/kthread.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/lockmgr.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/mbuf.h>
|
|
#include <sys/module.h>
|
|
#include <sys/mouse.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/poll.h>
|
|
#include <sys/selinfo.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/vnode.h>
|
|
|
|
#include <dev/iicbus/iiconf.h>
|
|
#include <dev/iicbus/iicbus.h>
|
|
#include <dev/cyapa/cyapa.h>
|
|
|
|
#ifdef EVDEV_SUPPORT
|
|
#include <dev/evdev/input.h>
|
|
#include <dev/evdev/evdev.h>
|
|
#endif
|
|
|
|
#include "iicbus_if.h"
|
|
#include "bus_if.h"
|
|
#include "device_if.h"
|
|
|
|
#define CYAPA_BUFSIZE 128 /* power of 2 */
|
|
#define CYAPA_BUFMASK (CYAPA_BUFSIZE - 1)
|
|
|
|
#define ZSCALE 15
|
|
|
|
#define TIME_TO_IDLE (hz * 10)
|
|
#define TIME_TO_RESET (hz * 3)
|
|
|
|
static MALLOC_DEFINE(M_CYAPA, "cyapa", "CYAPA device data");
|
|
|
|
struct cyapa_fifo {
|
|
int rindex;
|
|
int windex;
|
|
char buf[CYAPA_BUFSIZE];
|
|
};
|
|
|
|
struct cyapa_softc {
|
|
device_t dev;
|
|
int count; /* >0 if device opened */
|
|
struct cdev *devnode;
|
|
struct selinfo selinfo;
|
|
struct mtx mutex;
|
|
struct intr_config_hook intr_hook;
|
|
#ifdef EVDEV_SUPPORT
|
|
struct evdev_dev *evdev;
|
|
#endif
|
|
|
|
int cap_resx;
|
|
int cap_resy;
|
|
int cap_phyx;
|
|
int cap_phyy;
|
|
uint8_t cap_buttons;
|
|
|
|
int detaching; /* driver is detaching */
|
|
int poll_thread_running; /* poll thread is running */
|
|
|
|
/* PS/2 mouse emulation */
|
|
int track_x; /* current tracking */
|
|
int track_y;
|
|
int track_z;
|
|
int track_z_ticks;
|
|
uint16_t track_but;
|
|
char track_id; /* first finger id */
|
|
int track_nfingers;
|
|
int delta_x; /* accumulation -> report */
|
|
int delta_y;
|
|
int delta_z;
|
|
int fuzz_x;
|
|
int fuzz_y;
|
|
int fuzz_z;
|
|
int touch_x; /* touch down coordinates */
|
|
int touch_y;
|
|
int touch_z;
|
|
int finger1_ticks;
|
|
int finger2_ticks;
|
|
int finger3_ticks;
|
|
uint16_t reported_but;
|
|
|
|
struct cyapa_fifo rfifo; /* device->host */
|
|
struct cyapa_fifo wfifo; /* host->device */
|
|
uint8_t ps2_cmd; /* active p2_cmd waiting for data */
|
|
uint8_t ps2_acked;
|
|
int active_tick;
|
|
int data_signal;
|
|
int blocked;
|
|
int isselect;
|
|
int reporting_mode; /* 0=disabled 1=enabled */
|
|
int scaling_mode; /* 0=1:1 1=2:1 */
|
|
int remote_mode; /* 0 for streaming mode */
|
|
int zenabled; /* z-axis enabled (mode 1 or 2) */
|
|
mousehw_t hw; /* hardware information */
|
|
mousemode_t mode; /* mode */
|
|
int poll_ticks;
|
|
};
|
|
|
|
struct cyapa_cdevpriv {
|
|
struct cyapa_softc *sc;
|
|
};
|
|
|
|
#define CYPOLL_SHUTDOWN 0x0001
|
|
|
|
static void cyapa_poll_thread(void *arg);
|
|
static int cyapa_raw_input(struct cyapa_softc *sc, struct cyapa_regs *regs,
|
|
int freq);
|
|
static void cyapa_set_power_mode(struct cyapa_softc *sc, int mode);
|
|
|
|
static int fifo_empty(struct cyapa_softc *sc, struct cyapa_fifo *fifo);
|
|
static size_t fifo_ready(struct cyapa_softc *sc, struct cyapa_fifo *fifo);
|
|
static char *fifo_read(struct cyapa_softc *sc, struct cyapa_fifo *fifo,
|
|
size_t n);
|
|
static char *fifo_write(struct cyapa_softc *sc, struct cyapa_fifo *fifo,
|
|
size_t n);
|
|
static uint8_t fifo_read_char(struct cyapa_softc *sc,
|
|
struct cyapa_fifo *fifo);
|
|
static void fifo_write_char(struct cyapa_softc *sc, struct cyapa_fifo *fifo,
|
|
uint8_t c);
|
|
static size_t fifo_space(struct cyapa_softc *sc, struct cyapa_fifo *fifo);
|
|
static void fifo_reset(struct cyapa_softc *sc, struct cyapa_fifo *fifo);
|
|
|
|
static int cyapa_fuzz(int delta, int *fuzz);
|
|
|
|
static int cyapa_idle_freq = 1;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_idle_freq, CTLFLAG_RW,
|
|
&cyapa_idle_freq, 0, "Scan frequency in idle mode");
|
|
static int cyapa_slow_freq = 20;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_slow_freq, CTLFLAG_RW,
|
|
&cyapa_slow_freq, 0, "Scan frequency in slow mode ");
|
|
static int cyapa_norm_freq = 100;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_norm_freq, CTLFLAG_RW,
|
|
&cyapa_norm_freq, 0, "Normal scan frequency");
|
|
static int cyapa_minpressure = 12;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_minpressure, CTLFLAG_RW,
|
|
&cyapa_minpressure, 0, "Minimum pressure to detect finger");
|
|
static int cyapa_enable_tapclick = 0;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_enable_tapclick, CTLFLAG_RW,
|
|
&cyapa_enable_tapclick, 0, "Enable tap to click");
|
|
static int cyapa_tapclick_min_ticks = 1;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_tapclick_min_ticks, CTLFLAG_RW,
|
|
&cyapa_tapclick_min_ticks, 0, "Minimum tap duration for click");
|
|
static int cyapa_tapclick_max_ticks = 8;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_tapclick_max_ticks, CTLFLAG_RW,
|
|
&cyapa_tapclick_max_ticks, 0, "Maximum tap duration for click");
|
|
static int cyapa_move_min_ticks = 4;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_move_min_ticks, CTLFLAG_RW,
|
|
&cyapa_move_min_ticks, 0,
|
|
"Minimum ticks before cursor position is changed");
|
|
static int cyapa_scroll_wait_ticks = 0;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_scroll_wait_ticks, CTLFLAG_RW,
|
|
&cyapa_scroll_wait_ticks, 0,
|
|
"Wait N ticks before starting to scroll");
|
|
static int cyapa_scroll_stick_ticks = 15;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_scroll_stick_ticks, CTLFLAG_RW,
|
|
&cyapa_scroll_stick_ticks, 0,
|
|
"Prevent cursor move on single finger for N ticks after scroll");
|
|
static int cyapa_thumbarea_percent = 15;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_thumbarea_percent, CTLFLAG_RW,
|
|
&cyapa_thumbarea_percent, 0,
|
|
"Size of bottom thumb area in percent");
|
|
|
|
static int cyapa_debug = 0;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_debug, CTLFLAG_RW,
|
|
&cyapa_debug, 0, "Enable debugging");
|
|
static int cyapa_reset = 0;
|
|
SYSCTL_INT(_debug, OID_AUTO, cyapa_reset, CTLFLAG_RW,
|
|
&cyapa_reset, 0, "Reset track pad");
|
|
|
|
static int
|
|
cyapa_read_bytes(device_t dev, uint8_t reg, uint8_t *val, int cnt)
|
|
{
|
|
uint16_t addr = iicbus_get_addr(dev);
|
|
struct iic_msg msgs[] = {
|
|
{ addr, IIC_M_WR | IIC_M_NOSTOP, 1, ® },
|
|
{ addr, IIC_M_RD, cnt, val },
|
|
};
|
|
|
|
return (iicbus_transfer(dev, msgs, nitems(msgs)));
|
|
}
|
|
|
|
static int
|
|
cyapa_write_bytes(device_t dev, uint8_t reg, const uint8_t *val, int cnt)
|
|
{
|
|
uint16_t addr = iicbus_get_addr(dev);
|
|
struct iic_msg msgs[] = {
|
|
{ addr, IIC_M_WR | IIC_M_NOSTOP, 1, ® },
|
|
{ addr, IIC_M_WR | IIC_M_NOSTART, cnt, __DECONST(uint8_t *, val) },
|
|
};
|
|
|
|
return (iicbus_transfer(dev, msgs, nitems(msgs)));
|
|
}
|
|
|
|
static void
|
|
cyapa_lock(struct cyapa_softc *sc)
|
|
{
|
|
|
|
mtx_lock(&sc->mutex);
|
|
}
|
|
|
|
static void
|
|
cyapa_unlock(struct cyapa_softc *sc)
|
|
{
|
|
|
|
mtx_unlock(&sc->mutex);
|
|
}
|
|
|
|
#define CYAPA_LOCK_ASSERT(sc) mtx_assert(&(sc)->mutex, MA_OWNED);
|
|
|
|
/*
|
|
* Notify if possible receive data ready. Must be called
|
|
* with sc->mutex held (cyapa_lock(sc)).
|
|
*/
|
|
static void
|
|
cyapa_notify(struct cyapa_softc *sc)
|
|
{
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
|
|
if (sc->data_signal || !fifo_empty(sc, &sc->rfifo)) {
|
|
KNOTE_LOCKED(&sc->selinfo.si_note, 0);
|
|
if (sc->blocked || sc->isselect) {
|
|
if (sc->blocked) {
|
|
sc->blocked = 0;
|
|
wakeup(&sc->blocked);
|
|
}
|
|
if (sc->isselect) {
|
|
sc->isselect = 0;
|
|
selwakeup(&sc->selinfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Initialize the device
|
|
*/
|
|
static int
|
|
init_device(device_t dev, struct cyapa_cap *cap, int probe)
|
|
{
|
|
static char bl_exit[] = {
|
|
0x00, 0xff, 0xa5, 0x00, 0x01,
|
|
0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
|
static char bl_deactivate[] = {
|
|
0x00, 0xff, 0x3b, 0x00, 0x01,
|
|
0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
|
struct cyapa_boot_regs boot;
|
|
int error;
|
|
int retries;
|
|
|
|
/* Get status */
|
|
error = cyapa_read_bytes(dev, CMD_BOOT_STATUS,
|
|
(void *)&boot, sizeof(boot));
|
|
if (error)
|
|
goto done;
|
|
|
|
/*
|
|
* Bootstrap the device if necessary. It can take up to 2 seconds
|
|
* for the device to fully initialize.
|
|
*/
|
|
retries = 20;
|
|
while ((boot.stat & CYAPA_STAT_RUNNING) == 0 && retries > 0) {
|
|
if (boot.boot & CYAPA_BOOT_BUSY) {
|
|
/* Busy, wait loop. */
|
|
} else if (boot.error & CYAPA_ERROR_BOOTLOADER) {
|
|
/* Magic */
|
|
error = cyapa_write_bytes(dev, CMD_BOOT_STATUS,
|
|
bl_deactivate, sizeof(bl_deactivate));
|
|
if (error)
|
|
goto done;
|
|
} else {
|
|
/* Magic */
|
|
error = cyapa_write_bytes(dev, CMD_BOOT_STATUS,
|
|
bl_exit, sizeof(bl_exit));
|
|
if (error)
|
|
goto done;
|
|
}
|
|
pause("cyapab1", (hz * 2) / 10);
|
|
--retries;
|
|
error = cyapa_read_bytes(dev, CMD_BOOT_STATUS,
|
|
(void *)&boot, sizeof(boot));
|
|
if (error)
|
|
goto done;
|
|
}
|
|
|
|
if (retries == 0) {
|
|
device_printf(dev, "Unable to bring device out of bootstrap\n");
|
|
error = ENXIO;
|
|
goto done;
|
|
}
|
|
|
|
/* Check identity */
|
|
if (cap) {
|
|
error = cyapa_read_bytes(dev, CMD_QUERY_CAPABILITIES,
|
|
(void *)cap, sizeof(*cap));
|
|
|
|
if (strncmp(cap->prod_ida, "CYTRA", 5) != 0) {
|
|
device_printf(dev, "Product ID \"%5.5s\" mismatch\n",
|
|
cap->prod_ida);
|
|
error = ENXIO;
|
|
}
|
|
}
|
|
error = cyapa_read_bytes(dev, CMD_BOOT_STATUS,
|
|
(void *)&boot, sizeof(boot));
|
|
|
|
if (probe == 0) /* official init */
|
|
device_printf(dev, "cyapa init status %02x\n", boot.stat);
|
|
else if (probe == 2)
|
|
device_printf(dev, "cyapa reset status %02x\n", boot.stat);
|
|
|
|
done:
|
|
if (error)
|
|
device_printf(dev, "Unable to initialize\n");
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* Start the polling thread
|
|
*/
|
|
static void
|
|
cyapa_start(void *xdev)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
device_t dev = xdev;
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
config_intrhook_disestablish(&sc->intr_hook);
|
|
|
|
/* Setup input event tracking */
|
|
cyapa_set_power_mode(sc, CMD_POWER_MODE_IDLE);
|
|
|
|
/* Start the polling thread */
|
|
kthread_add(cyapa_poll_thread, sc, NULL, NULL,
|
|
0, 0, "cyapa-poll");
|
|
}
|
|
|
|
static int cyapa_probe(device_t);
|
|
static int cyapa_attach(device_t);
|
|
static int cyapa_detach(device_t);
|
|
static void cyapa_cdevpriv_dtor(void*);
|
|
|
|
static device_method_t cyapa_methods[] = {
|
|
/* device interface */
|
|
DEVMETHOD(device_probe, cyapa_probe),
|
|
DEVMETHOD(device_attach, cyapa_attach),
|
|
DEVMETHOD(device_detach, cyapa_detach),
|
|
|
|
DEVMETHOD_END
|
|
};
|
|
|
|
static driver_t cyapa_driver = {
|
|
"cyapa",
|
|
cyapa_methods,
|
|
sizeof(struct cyapa_softc),
|
|
};
|
|
|
|
static d_open_t cyapaopen;
|
|
static d_ioctl_t cyapaioctl;
|
|
static d_read_t cyaparead;
|
|
static d_write_t cyapawrite;
|
|
static d_kqfilter_t cyapakqfilter;
|
|
static d_poll_t cyapapoll;
|
|
|
|
static struct cdevsw cyapa_cdevsw = {
|
|
.d_version = D_VERSION,
|
|
.d_open = cyapaopen,
|
|
.d_ioctl = cyapaioctl,
|
|
.d_read = cyaparead,
|
|
.d_write = cyapawrite,
|
|
.d_kqfilter = cyapakqfilter,
|
|
.d_poll = cyapapoll,
|
|
};
|
|
|
|
static int
|
|
cyapa_probe(device_t dev)
|
|
{
|
|
struct cyapa_cap cap;
|
|
int addr;
|
|
int error;
|
|
|
|
addr = iicbus_get_addr(dev);
|
|
|
|
/*
|
|
* 0x67 - cypress trackpad on the acer c720
|
|
* (other devices might use other ids).
|
|
*/
|
|
if (addr != 0xce)
|
|
return (ENXIO);
|
|
|
|
error = init_device(dev, &cap, 1);
|
|
if (error != 0)
|
|
return (ENXIO);
|
|
|
|
device_set_desc(dev, "Cypress APA I2C Trackpad");
|
|
|
|
return (BUS_PROBE_VENDOR);
|
|
}
|
|
|
|
static int
|
|
cyapa_attach(device_t dev)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
struct cyapa_cap cap;
|
|
int unit;
|
|
int addr;
|
|
|
|
sc = device_get_softc(dev);
|
|
sc->reporting_mode = 1;
|
|
|
|
unit = device_get_unit(dev);
|
|
addr = iicbus_get_addr(dev);
|
|
|
|
if (init_device(dev, &cap, 0))
|
|
return (ENXIO);
|
|
|
|
mtx_init(&sc->mutex, "cyapa", NULL, MTX_DEF);
|
|
|
|
sc->dev = dev;
|
|
|
|
knlist_init_mtx(&sc->selinfo.si_note, &sc->mutex);
|
|
|
|
sc->cap_resx = ((cap.max_abs_xy_high << 4) & 0x0F00) |
|
|
cap.max_abs_x_low;
|
|
sc->cap_resy = ((cap.max_abs_xy_high << 8) & 0x0F00) |
|
|
cap.max_abs_y_low;
|
|
sc->cap_phyx = ((cap.phy_siz_xy_high << 4) & 0x0F00) |
|
|
cap.phy_siz_x_low;
|
|
sc->cap_phyy = ((cap.phy_siz_xy_high << 8) & 0x0F00) |
|
|
cap.phy_siz_y_low;
|
|
sc->cap_buttons = cap.buttons >> 3 &
|
|
(CYAPA_FNGR_LEFT | CYAPA_FNGR_RIGHT | CYAPA_FNGR_MIDDLE);
|
|
|
|
device_printf(dev, "%5.5s-%6.6s-%2.2s buttons=%c%c%c res=%dx%d\n",
|
|
cap.prod_ida, cap.prod_idb, cap.prod_idc,
|
|
((sc->cap_buttons & CYAPA_FNGR_LEFT) ? 'L' : '-'),
|
|
((sc->cap_buttons & CYAPA_FNGR_MIDDLE) ? 'M' : '-'),
|
|
((sc->cap_buttons & CYAPA_FNGR_RIGHT) ? 'R' : '-'),
|
|
sc->cap_resx, sc->cap_resy);
|
|
|
|
sc->hw.buttons = 5;
|
|
sc->hw.iftype = MOUSE_IF_PS2;
|
|
sc->hw.type = MOUSE_MOUSE;
|
|
sc->hw.model = MOUSE_MODEL_INTELLI;
|
|
sc->hw.hwid = addr;
|
|
|
|
sc->mode.protocol = MOUSE_PROTO_PS2;
|
|
sc->mode.rate = 100;
|
|
sc->mode.resolution = 4;
|
|
sc->mode.accelfactor = 1;
|
|
sc->mode.level = 0;
|
|
sc->mode.packetsize = MOUSE_PS2_PACKETSIZE;
|
|
|
|
sc->intr_hook.ich_func = cyapa_start;
|
|
sc->intr_hook.ich_arg = sc->dev;
|
|
|
|
#ifdef EVDEV_SUPPORT
|
|
sc->evdev = evdev_alloc();
|
|
evdev_set_name(sc->evdev, device_get_desc(sc->dev));
|
|
evdev_set_phys(sc->evdev, device_get_nameunit(sc->dev));
|
|
evdev_set_id(sc->evdev, BUS_I2C, 0, 0, 1);
|
|
evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_STCOMPAT);
|
|
evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_AUTOREL);
|
|
|
|
evdev_support_event(sc->evdev, EV_SYN);
|
|
evdev_support_event(sc->evdev, EV_ABS);
|
|
evdev_support_event(sc->evdev, EV_KEY);
|
|
evdev_support_prop(sc->evdev, INPUT_PROP_POINTER);
|
|
if (sc->cap_buttons & CYAPA_FNGR_LEFT)
|
|
evdev_support_key(sc->evdev, BTN_LEFT);
|
|
if (sc->cap_buttons & CYAPA_FNGR_RIGHT)
|
|
evdev_support_key(sc->evdev, BTN_RIGHT);
|
|
if (sc->cap_buttons & CYAPA_FNGR_MIDDLE)
|
|
evdev_support_key(sc->evdev, BTN_MIDDLE);
|
|
if (sc->cap_buttons == CYAPA_FNGR_LEFT)
|
|
evdev_support_prop(sc->evdev, INPUT_PROP_BUTTONPAD);
|
|
|
|
evdev_support_abs(sc->evdev, ABS_MT_SLOT,
|
|
0, CYAPA_MAX_MT - 1, 0, 0, 0);
|
|
evdev_support_abs(sc->evdev, ABS_MT_TRACKING_ID, -1, 15, 0, 0, 0);
|
|
evdev_support_abs(sc->evdev, ABS_MT_POSITION_X, 0, sc->cap_resx, 0, 0,
|
|
sc->cap_phyx != 0 ? sc->cap_resx / sc->cap_phyx : 0);
|
|
evdev_support_abs(sc->evdev, ABS_MT_POSITION_Y, 0, sc->cap_resy, 0, 0,
|
|
sc->cap_phyy != 0 ? sc->cap_resy / sc->cap_phyy : 0);
|
|
evdev_support_abs(sc->evdev, ABS_MT_PRESSURE, 0, 255, 0, 0, 0);
|
|
|
|
if (evdev_register(sc->evdev) != 0) {
|
|
mtx_destroy(&sc->mutex);
|
|
return (ENOMEM);
|
|
}
|
|
#endif
|
|
|
|
/* Postpone start of the polling thread until sleep is available */
|
|
if (config_intrhook_establish(&sc->intr_hook) != 0) {
|
|
#ifdef EVDEV_SUPPORT
|
|
evdev_free(sc->evdev);
|
|
#endif
|
|
mtx_destroy(&sc->mutex);
|
|
return (ENOMEM);
|
|
}
|
|
|
|
sc->devnode = make_dev(&cyapa_cdevsw, unit,
|
|
UID_ROOT, GID_WHEEL, 0600, "cyapa%d", unit);
|
|
|
|
sc->devnode->si_drv1 = sc;
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
cyapa_detach(device_t dev)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
/* Cleanup poller thread */
|
|
cyapa_lock(sc);
|
|
while (sc->poll_thread_running) {
|
|
sc->detaching = 1;
|
|
mtx_sleep(&sc->detaching, &sc->mutex, PCATCH, "cyapadet", hz);
|
|
}
|
|
cyapa_unlock(sc);
|
|
|
|
destroy_dev(sc->devnode);
|
|
|
|
knlist_clear(&sc->selinfo.si_note, 0);
|
|
seldrain(&sc->selinfo);
|
|
knlist_destroy(&sc->selinfo.si_note);
|
|
#ifdef EVDEV_SUPPORT
|
|
evdev_free(sc->evdev);
|
|
#endif
|
|
|
|
mtx_destroy(&sc->mutex);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* USER DEVICE I/O FUNCTIONS
|
|
*/
|
|
static int
|
|
cyapaopen(struct cdev *dev, int oflags, int devtype, struct thread *td)
|
|
{
|
|
struct cyapa_cdevpriv *priv;
|
|
int error;
|
|
|
|
priv = malloc(sizeof(*priv), M_CYAPA, M_WAITOK | M_ZERO);
|
|
priv->sc = dev->si_drv1;
|
|
|
|
error = devfs_set_cdevpriv(priv, cyapa_cdevpriv_dtor);
|
|
if (error == 0) {
|
|
cyapa_lock(priv->sc);
|
|
priv->sc->count++;
|
|
cyapa_unlock(priv->sc);
|
|
}
|
|
else
|
|
free(priv, M_CYAPA);
|
|
|
|
return (error);
|
|
}
|
|
|
|
static void
|
|
cyapa_cdevpriv_dtor(void *data)
|
|
{
|
|
struct cyapa_cdevpriv *priv;
|
|
|
|
priv = data;
|
|
KASSERT(priv != NULL, ("cyapa cdevpriv should not be NULL!"));
|
|
|
|
cyapa_lock(priv->sc);
|
|
priv->sc->count--;
|
|
cyapa_unlock(priv->sc);
|
|
|
|
free(priv, M_CYAPA);
|
|
}
|
|
|
|
static int
|
|
cyaparead(struct cdev *dev, struct uio *uio, int ioflag)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
int error;
|
|
int didread;
|
|
size_t n;
|
|
char* ptr;
|
|
|
|
sc = dev->si_drv1;
|
|
/* If buffer is empty, load a new event if it is ready */
|
|
cyapa_lock(sc);
|
|
again:
|
|
if (fifo_empty(sc, &sc->rfifo) &&
|
|
(sc->data_signal || sc->delta_x || sc->delta_y ||
|
|
sc->track_but != sc->reported_but)) {
|
|
uint8_t c0;
|
|
uint16_t but;
|
|
int delta_x;
|
|
int delta_y;
|
|
int delta_z;
|
|
|
|
/* Accumulate delta_x, delta_y */
|
|
sc->data_signal = 0;
|
|
delta_x = sc->delta_x;
|
|
delta_y = sc->delta_y;
|
|
delta_z = sc->delta_z;
|
|
if (delta_x > 255) {
|
|
delta_x = 255;
|
|
sc->data_signal = 1;
|
|
}
|
|
if (delta_x < -256) {
|
|
delta_x = -256;
|
|
sc->data_signal = 1;
|
|
}
|
|
if (delta_y > 255) {
|
|
delta_y = 255;
|
|
sc->data_signal = 1;
|
|
}
|
|
if (delta_y < -256) {
|
|
delta_y = -256;
|
|
sc->data_signal = 1;
|
|
}
|
|
if (delta_z > 255) {
|
|
delta_z = 255;
|
|
sc->data_signal = 1;
|
|
}
|
|
if (delta_z < -256) {
|
|
delta_z = -256;
|
|
sc->data_signal = 1;
|
|
}
|
|
but = sc->track_but;
|
|
|
|
/* Adjust baseline for next calculation */
|
|
sc->delta_x -= delta_x;
|
|
sc->delta_y -= delta_y;
|
|
sc->delta_z -= delta_z;
|
|
sc->reported_but = but;
|
|
|
|
/*
|
|
* Fuzz reduces movement jitter by introducing some
|
|
* hysteresis. It operates without cumulative error so
|
|
* if you swish around quickly and return your finger to
|
|
* where it started, so to will the mouse.
|
|
*/
|
|
delta_x = cyapa_fuzz(delta_x, &sc->fuzz_x);
|
|
delta_y = cyapa_fuzz(delta_y, &sc->fuzz_y);
|
|
delta_z = cyapa_fuzz(delta_z, &sc->fuzz_z);
|
|
|
|
/*
|
|
* Generate report
|
|
*/
|
|
c0 = 0;
|
|
if (delta_x < 0)
|
|
c0 |= 0x10;
|
|
if (delta_y < 0)
|
|
c0 |= 0x20;
|
|
c0 |= 0x08;
|
|
if (but & CYAPA_FNGR_LEFT)
|
|
c0 |= 0x01;
|
|
if (but & CYAPA_FNGR_MIDDLE)
|
|
c0 |= 0x04;
|
|
if (but & CYAPA_FNGR_RIGHT)
|
|
c0 |= 0x02;
|
|
|
|
fifo_write_char(sc, &sc->rfifo, c0);
|
|
fifo_write_char(sc, &sc->rfifo, (uint8_t)delta_x);
|
|
fifo_write_char(sc, &sc->rfifo, (uint8_t)delta_y);
|
|
switch(sc->zenabled) {
|
|
case 1:
|
|
/* Z axis all 8 bits */
|
|
fifo_write_char(sc, &sc->rfifo, (uint8_t)delta_z);
|
|
break;
|
|
case 2:
|
|
/*
|
|
* Z axis low 4 bits + 4th button and 5th button
|
|
* (high 2 bits must be left 0). Auto-scale
|
|
* delta_z to fit to avoid a wrong-direction
|
|
* overflow (don't try to retain the remainder).
|
|
*/
|
|
while (delta_z > 7 || delta_z < -8)
|
|
delta_z >>= 1;
|
|
c0 = (uint8_t)delta_z & 0x0F;
|
|
fifo_write_char(sc, &sc->rfifo, c0);
|
|
break;
|
|
default:
|
|
/* basic PS/2 */
|
|
break;
|
|
}
|
|
cyapa_notify(sc);
|
|
}
|
|
|
|
/* Blocking / Non-blocking */
|
|
error = 0;
|
|
didread = (uio->uio_resid == 0);
|
|
|
|
while ((ioflag & IO_NDELAY) == 0 && fifo_empty(sc, &sc->rfifo)) {
|
|
if (sc->data_signal)
|
|
goto again;
|
|
sc->blocked = 1;
|
|
error = mtx_sleep(&sc->blocked, &sc->mutex, PCATCH, "cyablk", 0);
|
|
if (error)
|
|
break;
|
|
}
|
|
|
|
/* Return any buffered data */
|
|
while (error == 0 && uio->uio_resid &&
|
|
(n = fifo_ready(sc, &sc->rfifo)) > 0) {
|
|
if (n > uio->uio_resid)
|
|
n = uio->uio_resid;
|
|
ptr = fifo_read(sc, &sc->rfifo, 0);
|
|
cyapa_unlock(sc);
|
|
error = uiomove(ptr, n, uio);
|
|
cyapa_lock(sc);
|
|
if (error)
|
|
break;
|
|
fifo_read(sc, &sc->rfifo, n);
|
|
didread = 1;
|
|
}
|
|
cyapa_unlock(sc);
|
|
|
|
if (error == 0 && didread == 0) {
|
|
error = EWOULDBLOCK;
|
|
}
|
|
return (didread ? 0 : error);
|
|
}
|
|
|
|
static int
|
|
cyapawrite(struct cdev *dev, struct uio *uio, int ioflag)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
int error;
|
|
int cmd_completed;
|
|
size_t n;
|
|
uint8_t c0;
|
|
char* ptr;
|
|
|
|
sc = dev->si_drv1;
|
|
again:
|
|
/*
|
|
* Copy data from userland. This will also cross-over the end
|
|
* of the fifo and keep filling.
|
|
*/
|
|
cyapa_lock(sc);
|
|
while ((n = fifo_space(sc, &sc->wfifo)) > 0 && uio->uio_resid) {
|
|
if (n > uio->uio_resid)
|
|
n = uio->uio_resid;
|
|
ptr = fifo_write(sc, &sc->wfifo, 0);
|
|
cyapa_unlock(sc);
|
|
error = uiomove(ptr, n, uio);
|
|
cyapa_lock(sc);
|
|
if (error)
|
|
break;
|
|
fifo_write(sc, &sc->wfifo, n);
|
|
}
|
|
|
|
/* Handle commands */
|
|
cmd_completed = (fifo_ready(sc, &sc->wfifo) != 0);
|
|
while (fifo_ready(sc, &sc->wfifo) && cmd_completed && error == 0) {
|
|
if (sc->ps2_cmd == 0)
|
|
sc->ps2_cmd = fifo_read_char(sc, &sc->wfifo);
|
|
switch(sc->ps2_cmd) {
|
|
case 0xE6:
|
|
/* SET SCALING 1:1 */
|
|
sc->scaling_mode = 0;
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
break;
|
|
case 0xE7:
|
|
/* SET SCALING 2:1 */
|
|
sc->scaling_mode = 1;
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
break;
|
|
case 0xE8:
|
|
/* SET RESOLUTION +1 byte */
|
|
if (sc->ps2_acked == 0) {
|
|
sc->ps2_acked = 1;
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
}
|
|
if (fifo_ready(sc, &sc->wfifo) == 0) {
|
|
cmd_completed = 0;
|
|
break;
|
|
}
|
|
sc->mode.resolution = fifo_read_char(sc, &sc->wfifo);
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
break;
|
|
case 0xE9:
|
|
/*
|
|
* STATUS REQUEST
|
|
*
|
|
* byte1:
|
|
* bit 7 0
|
|
* bit 6 Mode (1=remote mode, 0=stream mode)
|
|
* bit 5 Enable (data reporting enabled)
|
|
* bit 4 Scaling (0=1:1 1=2:1)
|
|
* bit 3 0
|
|
* bit 2 LEFT BUTTON (1 if pressed)
|
|
* bit 1 MIDDLE BUTTON (1 if pressed)
|
|
* bit 0 RIGHT BUTTON (1 if pressed)
|
|
*
|
|
* byte2: resolution counts/mm
|
|
* byte3: sample rate
|
|
*/
|
|
c0 = 0;
|
|
if (sc->remote_mode)
|
|
c0 |= 0x40;
|
|
if (sc->reporting_mode)
|
|
c0 |= 0x20;
|
|
if (sc->scaling_mode)
|
|
c0 |= 0x10;
|
|
if (sc->track_but & CYAPA_FNGR_LEFT)
|
|
c0 |= 0x04;
|
|
if (sc->track_but & CYAPA_FNGR_MIDDLE)
|
|
c0 |= 0x02;
|
|
if (sc->track_but & CYAPA_FNGR_RIGHT)
|
|
c0 |= 0x01;
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
fifo_write_char(sc, &sc->rfifo, c0);
|
|
fifo_write_char(sc, &sc->rfifo, 0x00);
|
|
fifo_write_char(sc, &sc->rfifo, 100);
|
|
break;
|
|
case 0xEA:
|
|
/* Set stream mode and reset movement counters */
|
|
sc->remote_mode = 0;
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
sc->delta_x = 0;
|
|
sc->delta_y = 0;
|
|
sc->delta_z = 0;
|
|
break;
|
|
case 0xEB:
|
|
/*
|
|
* Read Data (if in remote mode). If not in remote
|
|
* mode force an event.
|
|
*/
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
sc->data_signal = 1;
|
|
break;
|
|
case 0xEC:
|
|
/* Reset Wrap Mode (ignored) */
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
break;
|
|
case 0xEE:
|
|
/* Set Wrap Mode (ignored) */
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
break;
|
|
case 0xF0:
|
|
/* Set Remote Mode */
|
|
sc->remote_mode = 1;
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
sc->delta_x = 0;
|
|
sc->delta_y = 0;
|
|
sc->delta_z = 0;
|
|
break;
|
|
case 0xF2:
|
|
/*
|
|
* Get Device ID
|
|
*
|
|
* If we send 0x00 - normal PS/2 mouse, no Z-axis
|
|
*
|
|
* If we send 0x03 - Intellimouse, data packet has
|
|
* an additional Z movement byte (8 bits signed).
|
|
* (also reset movement counters)
|
|
*
|
|
* If we send 0x04 - Now includes z-axis and the
|
|
* 4th and 5th mouse buttons.
|
|
*/
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
switch(sc->zenabled) {
|
|
case 1:
|
|
fifo_write_char(sc, &sc->rfifo, 0x03);
|
|
break;
|
|
case 2:
|
|
fifo_write_char(sc, &sc->rfifo, 0x04);
|
|
break;
|
|
default:
|
|
fifo_write_char(sc, &sc->rfifo, 0x00);
|
|
break;
|
|
}
|
|
sc->delta_x = 0;
|
|
sc->delta_y = 0;
|
|
sc->delta_z = 0;
|
|
break;
|
|
case 0xF3:
|
|
/*
|
|
* Set Sample Rate
|
|
*
|
|
* byte1: the sample rate
|
|
*/
|
|
if (sc->ps2_acked == 0) {
|
|
sc->ps2_acked = 1;
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
}
|
|
if (fifo_ready(sc, &sc->wfifo) == 0) {
|
|
cmd_completed = 0;
|
|
break;
|
|
}
|
|
sc->mode.rate = fifo_read_char(sc, &sc->wfifo);
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
|
|
/*
|
|
* zenabling sequence: 200,100,80 (device id 0x03)
|
|
* 200,200,80 (device id 0x04)
|
|
*
|
|
* We support id 0x03 (no 4th or 5th button).
|
|
* We support id 0x04 (w/ 4th and 5th button).
|
|
*/
|
|
if (sc->zenabled == 0 && sc->mode.rate == 200)
|
|
sc->zenabled = -1;
|
|
else if (sc->zenabled == -1 && sc->mode.rate == 100)
|
|
sc->zenabled = -2;
|
|
else if (sc->zenabled == -1 && sc->mode.rate == 200)
|
|
sc->zenabled = -3;
|
|
else if (sc->zenabled == -2 && sc->mode.rate == 80)
|
|
sc->zenabled = 1; /* z-axis mode */
|
|
else if (sc->zenabled == -3 && sc->mode.rate == 80)
|
|
sc->zenabled = 2; /* z-axis+but4/5 */
|
|
if (sc->mode.level)
|
|
sc->zenabled = 1;
|
|
break;
|
|
case 0xF4:
|
|
/* Enable data reporting. Only effects stream mode. */
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
sc->reporting_mode = 1;
|
|
break;
|
|
case 0xF5:
|
|
/*
|
|
* Disable data reporting. Only effects stream mode
|
|
* and is ignored right now.
|
|
*/
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
sc->reporting_mode = 1;
|
|
break;
|
|
case 0xF6:
|
|
/*
|
|
* SET DEFAULTS
|
|
*
|
|
* (reset sampling rate, resolution, scaling and
|
|
* enter stream mode)
|
|
*/
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
sc->mode.rate = 100;
|
|
sc->mode.resolution = 4;
|
|
sc->scaling_mode = 0;
|
|
sc->reporting_mode = 1;
|
|
sc->remote_mode = 0;
|
|
sc->delta_x = 0;
|
|
sc->delta_y = 0;
|
|
sc->delta_z = 0;
|
|
/* signal */
|
|
break;
|
|
case 0xFE:
|
|
/*
|
|
* RESEND
|
|
*
|
|
* Force a resend by guaranteeing that reported_but
|
|
* differs from track_but.
|
|
*/
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
sc->data_signal = 1;
|
|
break;
|
|
case 0xFF:
|
|
/*
|
|
* RESET
|
|
*/
|
|
fifo_reset(sc, &sc->rfifo); /* should we do this? */
|
|
fifo_reset(sc, &sc->wfifo); /* should we do this? */
|
|
fifo_write_char(sc, &sc->rfifo, 0xFA);
|
|
sc->delta_x = 0;
|
|
sc->delta_y = 0;
|
|
sc->delta_z = 0;
|
|
sc->zenabled = 0;
|
|
sc->mode.level = 0;
|
|
break;
|
|
default:
|
|
printf("unknown command %02x\n", sc->ps2_cmd);
|
|
break;
|
|
}
|
|
if (cmd_completed) {
|
|
sc->ps2_cmd = 0;
|
|
sc->ps2_acked = 0;
|
|
}
|
|
cyapa_notify(sc);
|
|
}
|
|
cyapa_unlock(sc);
|
|
if (error == 0 && (cmd_completed || uio->uio_resid))
|
|
goto again;
|
|
return (error);
|
|
}
|
|
|
|
static void cyapafiltdetach(struct knote *);
|
|
static int cyapafilt(struct knote *, long);
|
|
|
|
static struct filterops cyapa_filtops = {
|
|
.f_isfd = 1,
|
|
.f_detach = cyapafiltdetach,
|
|
.f_event = cyapafilt
|
|
};
|
|
|
|
static int
|
|
cyapakqfilter(struct cdev *dev, struct knote *kn)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
struct knlist *knlist;
|
|
|
|
sc = dev->si_drv1;
|
|
|
|
switch(kn->kn_filter) {
|
|
case EVFILT_READ:
|
|
kn->kn_fop = &cyapa_filtops;
|
|
kn->kn_hook = (void *)sc;
|
|
break;
|
|
default:
|
|
return (EOPNOTSUPP);
|
|
}
|
|
knlist = &sc->selinfo.si_note;
|
|
knlist_add(knlist, kn, 0);
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
cyapapoll(struct cdev *dev, int events, struct thread *td)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
int revents;
|
|
|
|
sc = dev->si_drv1;
|
|
revents = 0;
|
|
|
|
cyapa_lock(sc);
|
|
if (events & (POLLIN | POLLRDNORM)) {
|
|
if (sc->data_signal || !fifo_empty(sc, &sc->rfifo))
|
|
revents = events & (POLLIN | POLLRDNORM);
|
|
else {
|
|
sc->isselect = 1;
|
|
selrecord(td, &sc->selinfo);
|
|
}
|
|
}
|
|
cyapa_unlock(sc);
|
|
|
|
return (revents);
|
|
}
|
|
|
|
static void
|
|
cyapafiltdetach(struct knote *kn)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
struct knlist *knlist;
|
|
|
|
sc = (struct cyapa_softc *)kn->kn_hook;
|
|
|
|
knlist = &sc->selinfo.si_note;
|
|
knlist_remove(knlist, kn, 0);
|
|
}
|
|
|
|
static int
|
|
cyapafilt(struct knote *kn, long hint)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
int ready;
|
|
|
|
sc = (struct cyapa_softc *)kn->kn_hook;
|
|
|
|
cyapa_lock(sc);
|
|
ready = fifo_ready(sc, &sc->rfifo) || sc->data_signal;
|
|
cyapa_unlock(sc);
|
|
|
|
return (ready);
|
|
}
|
|
|
|
static int
|
|
cyapaioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
int error;
|
|
|
|
sc = dev->si_drv1;
|
|
error = 0;
|
|
|
|
cyapa_lock(sc);
|
|
switch (cmd) {
|
|
case MOUSE_GETHWINFO:
|
|
*(mousehw_t *)data = sc->hw;
|
|
if (sc->mode.level == 0)
|
|
((mousehw_t *)data)->model = MOUSE_MODEL_GENERIC;
|
|
break;
|
|
|
|
case MOUSE_GETMODE:
|
|
*(mousemode_t *)data = sc->mode;
|
|
((mousemode_t *)data)->resolution =
|
|
MOUSE_RES_LOW - sc->mode.resolution;
|
|
switch (sc->mode.level) {
|
|
case 0:
|
|
((mousemode_t *)data)->protocol = MOUSE_PROTO_PS2;
|
|
((mousemode_t *)data)->packetsize =
|
|
MOUSE_PS2_PACKETSIZE;
|
|
break;
|
|
case 2:
|
|
((mousemode_t *)data)->protocol = MOUSE_PROTO_PS2;
|
|
((mousemode_t *)data)->packetsize =
|
|
MOUSE_PS2_PACKETSIZE + 1;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case MOUSE_GETLEVEL:
|
|
*(int *)data = sc->mode.level;
|
|
break;
|
|
|
|
case MOUSE_SETLEVEL:
|
|
if ((*(int *)data < 0) &&
|
|
(*(int *)data > 2)) {
|
|
error = EINVAL;
|
|
break;
|
|
}
|
|
sc->mode.level = *(int *)data ? 2 : 0;
|
|
sc->zenabled = sc->mode.level ? 1 : 0;
|
|
break;
|
|
|
|
default:
|
|
error = ENOTTY;
|
|
break;
|
|
}
|
|
cyapa_unlock(sc);
|
|
|
|
return (error);
|
|
}
|
|
|
|
/*
|
|
* MAJOR SUPPORT FUNCTIONS
|
|
*/
|
|
static void
|
|
cyapa_poll_thread(void *arg)
|
|
{
|
|
struct cyapa_softc *sc;
|
|
struct cyapa_regs regs;
|
|
device_t bus; /* iicbus */
|
|
int error;
|
|
int freq;
|
|
int isidle;
|
|
int pstate;
|
|
int npstate;
|
|
int last_reset;
|
|
|
|
sc = arg;
|
|
freq = cyapa_norm_freq;
|
|
isidle = 0;
|
|
pstate = CMD_POWER_MODE_IDLE;
|
|
last_reset = ticks;
|
|
|
|
bus = device_get_parent(sc->dev);
|
|
|
|
cyapa_lock(sc);
|
|
sc->poll_thread_running = 1;
|
|
|
|
while (!sc->detaching) {
|
|
cyapa_unlock(sc);
|
|
error = iicbus_request_bus(bus, sc->dev, IIC_WAIT);
|
|
if (error == 0) {
|
|
error = cyapa_read_bytes(sc->dev, CMD_DEV_STATUS,
|
|
(void *)®s, sizeof(regs));
|
|
if (error == 0) {
|
|
isidle = cyapa_raw_input(sc, ®s, freq);
|
|
}
|
|
|
|
/*
|
|
* For some reason the device can crap-out. If it
|
|
* drops back into bootstrap mode try to reinitialize
|
|
* it.
|
|
*/
|
|
if (cyapa_reset ||
|
|
((regs.stat & CYAPA_STAT_RUNNING) == 0 &&
|
|
(unsigned)(ticks - last_reset) > TIME_TO_RESET)) {
|
|
cyapa_reset = 0;
|
|
last_reset = ticks;
|
|
init_device(sc->dev, NULL, 2);
|
|
}
|
|
iicbus_release_bus(bus, sc->dev);
|
|
}
|
|
pause("cyapw", hz / freq);
|
|
++sc->poll_ticks;
|
|
|
|
if (sc->count == 0) {
|
|
freq = cyapa_idle_freq;
|
|
npstate = CMD_POWER_MODE_IDLE;
|
|
} else if (isidle) {
|
|
freq = cyapa_slow_freq;
|
|
npstate = CMD_POWER_MODE_IDLE;
|
|
} else {
|
|
freq = cyapa_norm_freq;
|
|
npstate = CMD_POWER_MODE_FULL;
|
|
}
|
|
if (pstate != npstate) {
|
|
pstate = npstate;
|
|
cyapa_set_power_mode(sc, pstate);
|
|
if (cyapa_debug) {
|
|
switch(pstate) {
|
|
case CMD_POWER_MODE_OFF:
|
|
printf("cyapa: power off\n");
|
|
break;
|
|
case CMD_POWER_MODE_IDLE:
|
|
printf("cyapa: power idle\n");
|
|
break;
|
|
case CMD_POWER_MODE_FULL:
|
|
printf("cyapa: power full\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
cyapa_lock(sc);
|
|
}
|
|
sc->poll_thread_running = 0;
|
|
cyapa_unlock(sc);
|
|
kthread_exit();
|
|
}
|
|
|
|
static int
|
|
cyapa_raw_input(struct cyapa_softc *sc, struct cyapa_regs *regs, int freq)
|
|
{
|
|
int nfingers;
|
|
int afingers; /* actual fingers after culling */
|
|
int i;
|
|
int j;
|
|
int isidle;
|
|
int thumbarea_begin;
|
|
int seen_thumb;
|
|
int x;
|
|
int y;
|
|
int z;
|
|
int newfinger;
|
|
int lessfingers;
|
|
int click_x;
|
|
int click_y;
|
|
uint16_t but; /* high bits used for simulated but4/but5 */
|
|
|
|
thumbarea_begin = sc->cap_resy -
|
|
((sc->cap_resy * cyapa_thumbarea_percent) / 100);
|
|
click_x = click_y = 0;
|
|
|
|
/*
|
|
* If the device is not running the rest of the status
|
|
* means something else, set fingers to 0.
|
|
*/
|
|
if ((regs->stat & CYAPA_STAT_RUNNING) == 0) {
|
|
regs->fngr = 0;
|
|
}
|
|
|
|
/* Process fingers/movement */
|
|
nfingers = CYAPA_FNGR_NUMFINGERS(regs->fngr);
|
|
afingers = nfingers;
|
|
|
|
if (cyapa_debug) {
|
|
printf("stat %02x buttons %c%c%c nfngrs=%d ",
|
|
regs->stat,
|
|
((regs->fngr & CYAPA_FNGR_LEFT) ? 'L' : '-'),
|
|
((regs->fngr & CYAPA_FNGR_MIDDLE) ? 'M' : '-'),
|
|
((regs->fngr & CYAPA_FNGR_RIGHT) ? 'R' : '-'),
|
|
nfingers);
|
|
}
|
|
|
|
#ifdef EVDEV_SUPPORT
|
|
if (evdev_rcpt_mask & EVDEV_RCPT_HW_MOUSE) {
|
|
for (i = 0; i < nfingers; ++i) {
|
|
int slot = evdev_mt_id_to_slot(
|
|
sc->evdev, regs->touch[i].id);
|
|
if (slot == -1) {
|
|
if (cyapa_debug)
|
|
printf("Slot overflow for i=%d\n",
|
|
regs->touch[i].id);
|
|
continue;
|
|
}
|
|
evdev_push_abs(sc->evdev, ABS_MT_SLOT, slot);
|
|
evdev_push_abs(sc->evdev, ABS_MT_TRACKING_ID,
|
|
regs->touch[i].id);
|
|
evdev_push_abs(sc->evdev, ABS_MT_POSITION_X,
|
|
CYAPA_TOUCH_X(regs, i));
|
|
evdev_push_abs(sc->evdev, ABS_MT_POSITION_Y,
|
|
CYAPA_TOUCH_Y(regs, i));
|
|
evdev_push_abs(sc->evdev, ABS_MT_PRESSURE,
|
|
CYAPA_TOUCH_P(regs, i));
|
|
}
|
|
if (sc->cap_buttons & CYAPA_FNGR_LEFT)
|
|
evdev_push_key(sc->evdev, BTN_LEFT,
|
|
regs->fngr & CYAPA_FNGR_LEFT);
|
|
if (sc->cap_buttons & CYAPA_FNGR_RIGHT)
|
|
evdev_push_key(sc->evdev, BTN_RIGHT,
|
|
regs->fngr & CYAPA_FNGR_RIGHT);
|
|
if (sc->cap_buttons & CYAPA_FNGR_MIDDLE)
|
|
evdev_push_key(sc->evdev, BTN_MIDDLE,
|
|
regs->fngr & CYAPA_FNGR_MIDDLE);
|
|
evdev_sync(sc->evdev);
|
|
}
|
|
#endif
|
|
|
|
seen_thumb = 0;
|
|
for (i = 0; i < afingers; ) {
|
|
if (cyapa_debug) {
|
|
printf(" [x=%04d y=%04d p=%d i=%d]",
|
|
CYAPA_TOUCH_X(regs, i),
|
|
CYAPA_TOUCH_Y(regs, i),
|
|
CYAPA_TOUCH_P(regs, i),
|
|
regs->touch[i].id);
|
|
}
|
|
if ((CYAPA_TOUCH_Y(regs, i) > thumbarea_begin && seen_thumb) ||
|
|
CYAPA_TOUCH_P(regs, i) < cyapa_minpressure) {
|
|
--afingers;
|
|
if (i < afingers) {
|
|
regs->touch[i] = regs->touch[i+1];
|
|
continue;
|
|
}
|
|
} else {
|
|
if (CYAPA_TOUCH_Y(regs, i) > thumbarea_begin)
|
|
seen_thumb = 1;
|
|
}
|
|
++i;
|
|
}
|
|
nfingers = afingers;
|
|
|
|
/* Tracking for local solutions */
|
|
cyapa_lock(sc);
|
|
|
|
/*
|
|
* Track timing for finger-downs. Used to detect false-3-finger
|
|
* button-down.
|
|
*/
|
|
switch(afingers) {
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
if (sc->track_nfingers == 0)
|
|
sc->finger1_ticks = sc->poll_ticks;
|
|
break;
|
|
case 2:
|
|
if (sc->track_nfingers <= 0)
|
|
sc->finger1_ticks = sc->poll_ticks;
|
|
if (sc->track_nfingers <= 1)
|
|
sc->finger2_ticks = sc->poll_ticks;
|
|
break;
|
|
case 3:
|
|
default:
|
|
if (sc->track_nfingers <= 0)
|
|
sc->finger1_ticks = sc->poll_ticks;
|
|
if (sc->track_nfingers <= 1)
|
|
sc->finger2_ticks = sc->poll_ticks;
|
|
if (sc->track_nfingers <= 2)
|
|
sc->finger3_ticks = sc->poll_ticks;
|
|
break;
|
|
}
|
|
newfinger = sc->track_nfingers < afingers;
|
|
lessfingers = sc->track_nfingers > afingers;
|
|
sc->track_nfingers = afingers;
|
|
|
|
/*
|
|
* Lookup and track finger indexes in the touch[] array.
|
|
*/
|
|
if (afingers == 0) {
|
|
click_x = sc->track_x;
|
|
click_y = sc->track_y;
|
|
sc->track_x = -1;
|
|
sc->track_y = -1;
|
|
sc->track_z = -1;
|
|
sc->fuzz_x = 0;
|
|
sc->fuzz_y = 0;
|
|
sc->fuzz_z = 0;
|
|
sc->touch_x = -1;
|
|
sc->touch_y = -1;
|
|
sc->touch_z = -1;
|
|
sc->track_id = -1;
|
|
sc->track_but = 0;
|
|
i = 0;
|
|
j = 0;
|
|
} else {
|
|
/*
|
|
* The id assigned on touch can move around in the array,
|
|
* find it. If that finger is lifted up, assign some other
|
|
* finger for mouse tracking and reset track_x and track_y
|
|
* to avoid a mouse jump.
|
|
*
|
|
* If >= 2 fingers are down be sure not to assign i and
|
|
* j to the same index.
|
|
*/
|
|
for (i = 0; i < nfingers; ++i) {
|
|
if (sc->track_id == regs->touch[i].id)
|
|
break;
|
|
}
|
|
if (i == nfingers) {
|
|
i = 0;
|
|
sc->track_x = -1;
|
|
sc->track_y = -1;
|
|
sc->track_z = -1;
|
|
while (CYAPA_TOUCH_Y(regs, i) >= thumbarea_begin &&
|
|
i < nfingers) ++i;
|
|
if (i == nfingers) {
|
|
i = 0;
|
|
}
|
|
sc->track_id = regs->touch[i].id;
|
|
}
|
|
else if ((sc->track_but ||
|
|
CYAPA_TOUCH_Y(regs, i) >= thumbarea_begin) &&
|
|
newfinger && afingers == 2) {
|
|
j = regs->touch[0].id == sc->track_id ? 1 : 0;
|
|
if (CYAPA_TOUCH_Y(regs, j) < thumbarea_begin) {
|
|
i = j;
|
|
sc->track_x = -1;
|
|
sc->track_y = -1;
|
|
sc->track_z = -1;
|
|
sc->track_id = regs->touch[i].id;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Two finger scrolling - reset after timeout */
|
|
if (sc->track_z != -1 && afingers != 2 &&
|
|
(sc->poll_ticks - sc->track_z_ticks) > cyapa_scroll_stick_ticks) {
|
|
sc->track_z = -1;
|
|
sc->track_z_ticks = 0;
|
|
}
|
|
|
|
/* Initiate two finger scrolling */
|
|
if (!(regs->fngr & CYAPA_FNGR_LEFT) &&
|
|
((afingers && sc->track_z != -1) ||
|
|
(afingers == 2 && CYAPA_TOUCH_Y(regs, 0) < thumbarea_begin &&
|
|
CYAPA_TOUCH_Y(regs, 1) < thumbarea_begin))) {
|
|
if (afingers == 2 && (sc->poll_ticks - sc->finger2_ticks)
|
|
> cyapa_scroll_wait_ticks) {
|
|
z = (CYAPA_TOUCH_Y(regs, 0) +
|
|
CYAPA_TOUCH_Y(regs, 1)) >> 1;
|
|
sc->delta_z += z / ZSCALE - sc->track_z;
|
|
if (sc->track_z == -1) {
|
|
sc->delta_z = 0;
|
|
}
|
|
if (sc->touch_z == -1)
|
|
sc->touch_z = z; /* not used atm */
|
|
sc->track_z = z / ZSCALE;
|
|
sc->track_z_ticks = sc->poll_ticks;
|
|
}
|
|
} else if (afingers) {
|
|
/* Normal pad position reporting */
|
|
x = CYAPA_TOUCH_X(regs, i);
|
|
y = CYAPA_TOUCH_Y(regs, i);
|
|
click_x = x;
|
|
click_y = y;
|
|
if (sc->track_x != -1 && sc->track_y < thumbarea_begin &&
|
|
(afingers > 1 || (sc->poll_ticks - sc->finger1_ticks)
|
|
>= cyapa_move_min_ticks || freq < cyapa_norm_freq)) {
|
|
sc->delta_x += x - sc->track_x;
|
|
sc->delta_y -= y - sc->track_y;
|
|
if (sc->delta_x > sc->cap_resx)
|
|
sc->delta_x = sc->cap_resx;
|
|
if (sc->delta_x < -sc->cap_resx)
|
|
sc->delta_x = -sc->cap_resx;
|
|
if (sc->delta_y > sc->cap_resy)
|
|
sc->delta_y = sc->cap_resy;
|
|
if (sc->delta_y < -sc->cap_resy)
|
|
sc->delta_y = -sc->cap_resy;
|
|
|
|
if (abs(sc->delta_y) > sc->cap_resy / 2 ||
|
|
abs(sc->delta_x) > sc->cap_resx / 2) {
|
|
if (cyapa_debug)
|
|
printf("Detected jump by %i %i\n",
|
|
sc->delta_x, sc->delta_y);
|
|
sc->delta_x = sc->delta_y = 0;
|
|
}
|
|
}
|
|
if (sc->touch_x == -1) {
|
|
sc->touch_x = x;
|
|
sc->touch_y = y;
|
|
}
|
|
sc->track_x = x;
|
|
sc->track_y = y;
|
|
}
|
|
|
|
/* Select finger (L = 2/3x, M = 1/3u, R = 1/3d) */
|
|
int is_tapclick = (cyapa_enable_tapclick && lessfingers &&
|
|
afingers == 0 && sc->poll_ticks - sc->finger1_ticks
|
|
>= cyapa_tapclick_min_ticks &&
|
|
sc->poll_ticks - sc->finger1_ticks < cyapa_tapclick_max_ticks);
|
|
|
|
if (regs->fngr & CYAPA_FNGR_LEFT || is_tapclick) {
|
|
if (sc->track_but) {
|
|
but = sc->track_but;
|
|
} else if (afingers == 1) {
|
|
if (click_x < sc->cap_resx * 2 / 3)
|
|
but = CYAPA_FNGR_LEFT;
|
|
else if (click_y < sc->cap_resy / 2)
|
|
but = CYAPA_FNGR_MIDDLE;
|
|
else
|
|
but = CYAPA_FNGR_RIGHT;
|
|
} else if (is_tapclick) {
|
|
if (click_x < sc->cap_resx * 2 / 3 ||
|
|
cyapa_enable_tapclick < 2)
|
|
but = CYAPA_FNGR_LEFT;
|
|
else if (click_y < sc->cap_resy / 2 &&
|
|
cyapa_enable_tapclick > 2)
|
|
but = CYAPA_FNGR_MIDDLE;
|
|
else
|
|
but = CYAPA_FNGR_RIGHT;
|
|
} else {
|
|
but = CYAPA_FNGR_LEFT;
|
|
}
|
|
} else {
|
|
but = 0;
|
|
}
|
|
|
|
/*
|
|
* Detect state change from last reported state and
|
|
* determine if we have gone idle.
|
|
*/
|
|
sc->track_but = but;
|
|
if (sc->delta_x || sc->delta_y || sc->delta_z ||
|
|
sc->track_but != sc->reported_but) {
|
|
sc->active_tick = ticks;
|
|
if (sc->remote_mode == 0 && sc->reporting_mode)
|
|
sc->data_signal = 1;
|
|
isidle = 0;
|
|
} else if ((unsigned)(ticks - sc->active_tick) >= TIME_TO_IDLE) {
|
|
sc->active_tick = ticks - TIME_TO_IDLE; /* prevent overflow */
|
|
isidle = 1;
|
|
} else {
|
|
isidle = 0;
|
|
}
|
|
cyapa_notify(sc);
|
|
cyapa_unlock(sc);
|
|
|
|
if (cyapa_debug)
|
|
printf("%i >> %i << %i\n", isidle, sc->track_id, sc->delta_y);
|
|
return (isidle);
|
|
}
|
|
|
|
static void
|
|
cyapa_set_power_mode(struct cyapa_softc *sc, int mode)
|
|
{
|
|
uint8_t data;
|
|
device_t bus;
|
|
int error;
|
|
|
|
bus = device_get_parent(sc->dev);
|
|
error = iicbus_request_bus(bus, sc->dev, IIC_WAIT);
|
|
if (error == 0) {
|
|
error = cyapa_read_bytes(sc->dev, CMD_POWER_MODE,
|
|
&data, 1);
|
|
data = (data & ~0xFC) | mode;
|
|
if (error == 0) {
|
|
error = cyapa_write_bytes(sc->dev, CMD_POWER_MODE,
|
|
&data, 1);
|
|
}
|
|
iicbus_release_bus(bus, sc->dev);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* FIFO FUNCTIONS
|
|
*/
|
|
|
|
/*
|
|
* Returns non-zero if the fifo is empty
|
|
*/
|
|
static int
|
|
fifo_empty(struct cyapa_softc *sc, struct cyapa_fifo *fifo)
|
|
{
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
|
|
return (fifo->rindex == fifo->windex);
|
|
}
|
|
|
|
/*
|
|
* Returns the number of characters available for reading from
|
|
* the fifo without wrapping the fifo buffer.
|
|
*/
|
|
static size_t
|
|
fifo_ready(struct cyapa_softc *sc, struct cyapa_fifo *fifo)
|
|
{
|
|
size_t n;
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
|
|
n = CYAPA_BUFSIZE - (fifo->rindex & CYAPA_BUFMASK);
|
|
if (n > (size_t)(fifo->windex - fifo->rindex))
|
|
n = (size_t)(fifo->windex - fifo->rindex);
|
|
return (n);
|
|
}
|
|
|
|
/*
|
|
* Returns a read pointer into the fifo and then bumps
|
|
* rindex. The FIFO must have at least 'n' characters in
|
|
* it. The value (n) can cause the index to wrap but users
|
|
* of the buffer should never supply a value for (n) that wraps
|
|
* the buffer.
|
|
*/
|
|
static char *
|
|
fifo_read(struct cyapa_softc *sc, struct cyapa_fifo *fifo, size_t n)
|
|
{
|
|
char *ptr;
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
if (n > (CYAPA_BUFSIZE - (fifo->rindex & CYAPA_BUFMASK))) {
|
|
printf("fifo_read: overflow\n");
|
|
return (fifo->buf);
|
|
}
|
|
ptr = fifo->buf + (fifo->rindex & CYAPA_BUFMASK);
|
|
fifo->rindex += n;
|
|
|
|
return (ptr);
|
|
}
|
|
|
|
static uint8_t
|
|
fifo_read_char(struct cyapa_softc *sc, struct cyapa_fifo *fifo)
|
|
{
|
|
uint8_t c;
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
|
|
if (fifo->rindex == fifo->windex) {
|
|
printf("fifo_read_char: overflow\n");
|
|
c = 0;
|
|
} else {
|
|
c = fifo->buf[fifo->rindex & CYAPA_BUFMASK];
|
|
++fifo->rindex;
|
|
}
|
|
return (c);
|
|
}
|
|
|
|
|
|
/*
|
|
* Write a character to the FIFO. The character will be discarded
|
|
* if the FIFO is full.
|
|
*/
|
|
static void
|
|
fifo_write_char(struct cyapa_softc *sc, struct cyapa_fifo *fifo, uint8_t c)
|
|
{
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
|
|
if (fifo->windex - fifo->rindex < CYAPA_BUFSIZE) {
|
|
fifo->buf[fifo->windex & CYAPA_BUFMASK] = c;
|
|
++fifo->windex;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Return the amount of space available for writing without wrapping
|
|
* the fifo.
|
|
*/
|
|
static size_t
|
|
fifo_space(struct cyapa_softc *sc, struct cyapa_fifo *fifo)
|
|
{
|
|
size_t n;
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
|
|
n = CYAPA_BUFSIZE - (fifo->windex & CYAPA_BUFMASK);
|
|
if (n > (size_t)(CYAPA_BUFSIZE - (fifo->windex - fifo->rindex)))
|
|
n = (size_t)(CYAPA_BUFSIZE - (fifo->windex - fifo->rindex));
|
|
return (n);
|
|
}
|
|
|
|
static char *
|
|
fifo_write(struct cyapa_softc *sc, struct cyapa_fifo *fifo, size_t n)
|
|
{
|
|
char *ptr;
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
|
|
ptr = fifo->buf + (fifo->windex & CYAPA_BUFMASK);
|
|
fifo->windex += n;
|
|
|
|
return (ptr);
|
|
}
|
|
|
|
static void
|
|
fifo_reset(struct cyapa_softc *sc, struct cyapa_fifo *fifo)
|
|
{
|
|
|
|
CYAPA_LOCK_ASSERT(sc);
|
|
|
|
fifo->rindex = 0;
|
|
fifo->windex = 0;
|
|
}
|
|
|
|
/*
|
|
* Fuzz handling
|
|
*/
|
|
static int
|
|
cyapa_fuzz(int delta, int *fuzzp)
|
|
{
|
|
int fuzz;
|
|
|
|
fuzz = *fuzzp;
|
|
if (fuzz >= 0 && delta < 0) {
|
|
++delta;
|
|
--fuzz;
|
|
} else if (fuzz <= 0 && delta > 0) {
|
|
--delta;
|
|
++fuzz;
|
|
}
|
|
*fuzzp = fuzz;
|
|
|
|
return (delta);
|
|
}
|
|
|
|
DRIVER_MODULE(cyapa, iicbus, cyapa_driver, NULL, NULL);
|
|
MODULE_DEPEND(cyapa, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
|
|
#ifdef EVDEV_SUPPORT
|
|
MODULE_DEPEND(cyapa, evdev, 1, 1, 1);
|
|
#endif
|
|
MODULE_VERSION(cyapa, 1);
|