/usr/src/sys/dev/pckbc/pms.c

Bug Summary

File:	dev/pckbc/pms.c
Warning:	line 1727, column 15 The left operand of '&' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name pms.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/pckbc/pms.c
1/* $OpenBSD: pms.c,v 1.98 2023/08/16 20:53:47 bru Exp $ */
2/* $NetBSD: psm.c,v 1.11 2000/06/05 22:20:57 sommerfeld Exp $ */

4/*-
* Copyright (c) 1994 Charles M. Hannum.
* Copyright (c) 1992, 1993 Erik Forsberg.
* All rights reserved.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY ``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 I 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.
*/

27#include <sys/param.h>
28#include <sys/systm.h>
29#include <sys/rwlock.h>
30#include <sys/device.h>
31#include <sys/ioctl.h>
32#include <sys/malloc.h>
33#include <sys/task.h>
34#include <sys/timeout.h>

36#include <machine/bus.h>

38#include <dev/ic/pckbcvar.h>

40#include <dev/pckbc/pmsreg.h>

42#include <dev/wscons/wsconsio.h>
43#include <dev/wscons/wsmousevar.h>

45#if defined(__i386__) || defined(__amd64__1)
46#include "acpi.h"
47#endif

49#if !defined(SMALL_KERNEL) && NACPI1 > 0
50extern int mouse_has_softbtn;
51#else
52int mouse_has_softbtn;
53#endif

55#ifdef DEBUG
56#define DPRINTF(x...)	do { printf(x); } while (0);
57#else
58#define DPRINTF(x...)
59#endif

61#define DEVNAME(sc)((sc)->sc_dev.dv_xname)	((sc)->sc_dev.dv_xname)

63#define WSMOUSE_BUTTON(x)(1 << ((x) - 1))	(1 << ((x) - 1))

65struct pms_softc;

67struct pms_protocol {
int type;
69#define PMS_STANDARD0		0
70#define PMS_INTELLI1		1
71#define PMS_SYNAPTICS2		2
72#define PMS_ALPS3		3
73#define PMS_ELANTECH_V14		4
74#define PMS_ELANTECH_V25		5
75#define PMS_ELANTECH_V36		6
76#define PMS_ELANTECH_V47		7
u_int packetsize;
int (*enable)(struct pms_softc *);
int (*ioctl)(struct pms_softc *, u_long, caddr_t, int, struct proc *);
int (*sync)(struct pms_softc *, int);
void (*proc)(struct pms_softc *);
void (*disable)(struct pms_softc *);
83};

85struct synaptics_softc {
int identify;
int capabilities, ext_capabilities, ext2_capabilities;
int model, ext_model;
int modes;

int mode;

int mask;
94#define SYNAPTICS_MASK_NEWABS_STRICT0xc8	0xc8
95#define SYNAPTICS_MASK_NEWABS_RELAXED0xc0	0xc0
96#define SYNAPTICS_VALID_NEWABS_FIRST0x80	0x80
97#define SYNAPTICS_VALID_NEWABS_NEXT0xc0	0xc0

u_int sec_buttons;

101#define SYNAPTICS_PRESSURE_HI30		30
102#define SYNAPTICS_PRESSURE_LO25		25
103#define SYNAPTICS_PRESSURE30		SYNAPTICS_PRESSURE_HI30
104#define SYNAPTICS_SCALE4			4
105#define SYNAPTICS_MAX_FINGERS3		3
106};

108struct alps_softc {
int model;
110#define ALPS_GLIDEPOINT(1 << 1)		(1 << 1)
111#define ALPS_DUALPOINT(1 << 2)		(1 << 2)
112#define ALPS_PASSTHROUGH(1 << 3)	(1 << 3)
113#define ALPS_INTERLEAVED(1 << 4)	(1 << 4)

int mask;
int version;

u_int gesture;

u_int sec_buttons;	/* trackpoint */

int old_x, old_y;
123#define ALPS_PRESSURE40		40
124};

126struct elantech_softc {
int flags;
128#define ELANTECH_F_REPORTS_PRESSURE0x01	0x01
129#define ELANTECH_F_HAS_ROCKER0x02		0x02
130#define ELANTECH_F_2FINGER_PACKET0x04	0x04
131#define ELANTECH_F_HW_V1_OLD0x08		0x08
132#define ELANTECH_F_CRC_ENABLED0x10		0x10
133#define ELANTECH_F_TRACKPOINT0x20		0x20
int fw_version;

u_int mt_slots;

int width;

u_char parity[256];
u_char p1, p2, p3;

int max_x, max_y;
int old_x, old_y;
int initial_pkt;
146};
147#define ELANTECH_IS_CLICKPAD(sc)(((sc)->elantech->fw_version & 0x1000) != 0) (((sc)->elantech->fw_version & 0x1000) != 0)

149struct pms_softc {		/* driver status information */
struct device sc_dev;

pckbc_tag_t sc_kbctag;

int sc_state;
155#define PMS_STATE_DISABLED0	0
156#define PMS_STATE_ENABLED1	1
157#define PMS_STATE_SUSPENDED2	2

struct rwlock sc_state_lock;

int sc_dev_enable;
162#define PMS_DEV_IGNORE0x00		0x00
163#define PMS_DEV_PRIMARY0x01		0x01
164#define PMS_DEV_SECONDARY0x02	0x02

struct task sc_rsttask;
struct timeout sc_rsttimo;
int sc_rststate;
169#define PMS_RST_COMMENCE0x01	0x01
170#define PMS_RST_ANNOUNCED0x02	0x02

int poll;
int inputstate;

const struct pms_protocol *protocol;
struct synaptics_softc *synaptics;
struct alps_softc *alps;
struct elantech_softc *elantech;

u_char packet[8];

struct device *sc_wsmousedev;
struct device *sc_sec_wsmousedev;
184};

186static const u_int butmap[8] = {
0,
WSMOUSE_BUTTON(1)(1 << ((1) - 1)),
WSMOUSE_BUTTON(3)(1 << ((3) - 1)),
WSMOUSE_BUTTON(1)(1 << ((1) - 1)) | WSMOUSE_BUTTON(3)(1 << ((3) - 1)),
WSMOUSE_BUTTON(2)(1 << ((2) - 1)),
WSMOUSE_BUTTON(1)(1 << ((1) - 1)) | WSMOUSE_BUTTON(2)(1 << ((2) - 1)),
WSMOUSE_BUTTON(2)(1 << ((2) - 1)) | WSMOUSE_BUTTON(3)(1 << ((3) - 1)),
WSMOUSE_BUTTON(1)(1 << ((1) - 1)) | WSMOUSE_BUTTON(2)(1 << ((2) - 1)) | WSMOUSE_BUTTON(3)(1 << ((3) - 1))
195};

197static const struct alps_model {
int version;
int mask;
int model;
201} alps_models[] = {
{ 0x2021, 0xf8, ALPS_DUALPOINT(1 << 2) | ALPS_PASSTHROUGH(1 << 3) },
{ 0x2221, 0xf8, ALPS_DUALPOINT(1 << 2) | ALPS_PASSTHROUGH(1 << 3) },
{ 0x2222, 0xff, ALPS_DUALPOINT(1 << 2) | ALPS_PASSTHROUGH(1 << 3) },
{ 0x3222, 0xf8, ALPS_DUALPOINT(1 << 2) | ALPS_PASSTHROUGH(1 << 3) },
{ 0x5212, 0xff, ALPS_DUALPOINT(1 << 2) | ALPS_PASSTHROUGH(1 << 3) | ALPS_INTERLEAVED(1 << 4) },
{ 0x5321, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x5322, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x603b, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x6222, 0xcf, ALPS_DUALPOINT(1 << 2) | ALPS_PASSTHROUGH(1 << 3) | ALPS_INTERLEAVED(1 << 4) },
{ 0x6321, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x6322, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x6323, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x6324, 0x8f, ALPS_GLIDEPOINT(1 << 1) },
{ 0x6325, 0xef, ALPS_GLIDEPOINT(1 << 1) },
{ 0x6326, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x7301, 0xf8, ALPS_DUALPOINT(1 << 2) },
{ 0x7321, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x7322, 0xf8, ALPS_GLIDEPOINT(1 << 1) },
{ 0x7325, 0xcf, ALPS_GLIDEPOINT(1 << 1) },
221#if 0
/*
* This model has a clitpad sending almost compatible PS2
* packets but not compatible enough to be used with the
* ALPS protocol.
*/
{ 0x633b, 0xf8, ALPS_DUALPOINT(1 << 2) | ALPS_PASSTHROUGH(1 << 3) },

{ 0x7326, 0, 0 },	/* XXX Uses unknown v3 protocol */

{ 0x7331, 0x8f, ALPS_DUALPOINT(1 << 2) },	/* not supported */
232#endif
233};

235static struct wsmouse_param synaptics_params[] = {
{ WSMOUSECFG_PRESSURE_LO, SYNAPTICS_PRESSURE_LO25 },
{ WSMOUSECFG_PRESSURE_HI, SYNAPTICS_PRESSURE_HI30 }
238};

240static struct wsmouse_param alps_params[] = {
{ WSMOUSECFG_SMOOTHING, 3 }
242};

244int	pmsprobe(struct device *, void *, void *);
245void	pmsattach(struct device *, struct device *, void *);
246int	pmsactivate(struct device *, int);

248void	pmsinput(void *, int);

250int	pms_change_state(struct pms_softc *, int, int);

252int	pms_ioctl(void *, u_long, caddr_t, int, struct proc *);
253int	pms_enable(void *);
254void	pms_disable(void *);

256int	pms_sec_ioctl(void *, u_long, caddr_t, int, struct proc *);
257int	pms_sec_enable(void *);
258void	pms_sec_disable(void *);

260int	pms_cmd(struct pms_softc *, u_char *, int, u_char *, int);
261int	pms_spec_cmd(struct pms_softc *, int);
262int	pms_get_devid(struct pms_softc *, u_char *);
263int	pms_get_status(struct pms_softc *, u_char *);
264int	pms_set_rate(struct pms_softc *, int);
265int	pms_set_resolution(struct pms_softc *, int);
266int	pms_set_scaling(struct pms_softc *, int);
267int	pms_reset(struct pms_softc *);
268int	pms_dev_enable(struct pms_softc *);
269int	pms_dev_disable(struct pms_softc *);
270void	pms_protocol_lookup(struct pms_softc *);
271void	pms_reset_detect(struct pms_softc *, int);
272void	pms_reset_task(void *);
273void	pms_reset_timo(void *);

275int	pms_enable_intelli(struct pms_softc *);

277int	pms_ioctl_mouse(struct pms_softc *, u_long, caddr_t, int, struct proc *);
278int	pms_sync_mouse(struct pms_softc *, int);
279void	pms_proc_mouse(struct pms_softc *);

281int	pms_enable_synaptics(struct pms_softc *);
282int	pms_ioctl_synaptics(struct pms_softc *, u_long, caddr_t, int, struct proc *);
283int	pms_sync_synaptics(struct pms_softc *, int);
284void	pms_proc_synaptics(struct pms_softc *);
285void	pms_disable_synaptics(struct pms_softc *);

287int	pms_enable_alps(struct pms_softc *);
288int	pms_ioctl_alps(struct pms_softc *, u_long, caddr_t, int, struct proc *);
289int	pms_sync_alps(struct pms_softc *, int);
290void	pms_proc_alps(struct pms_softc *);

292int	pms_enable_elantech_v1(struct pms_softc *);
293int	pms_enable_elantech_v2(struct pms_softc *);
294int	pms_enable_elantech_v3(struct pms_softc *);
295int	pms_enable_elantech_v4(struct pms_softc *);
296int	pms_ioctl_elantech(struct pms_softc *, u_long, caddr_t, int,
  struct proc *);
298int	pms_sync_elantech_v1(struct pms_softc *, int);
299int	pms_sync_elantech_v2(struct pms_softc *, int);
300int	pms_sync_elantech_v3(struct pms_softc *, int);
301int	pms_sync_elantech_v4(struct pms_softc *, int);
302void	pms_proc_elantech_v1(struct pms_softc *);
303void	pms_proc_elantech_v2(struct pms_softc *);
304void	pms_proc_elantech_v3(struct pms_softc *);
305void	pms_proc_elantech_v4(struct pms_softc *);

307int	synaptics_knock(struct pms_softc *);
308int	synaptics_set_mode(struct pms_softc *, int, int);
309int	synaptics_query(struct pms_softc *, int, int *);
310int	synaptics_get_hwinfo(struct pms_softc *);
311void	synaptics_sec_proc(struct pms_softc *);

313int	alps_sec_proc(struct pms_softc *);
314int	alps_get_hwinfo(struct pms_softc *);

316int	elantech_knock(struct pms_softc *);
317int	elantech_get_hwinfo_v1(struct pms_softc *);
318int	elantech_get_hwinfo_v2(struct pms_softc *);
319int	elantech_get_hwinfo_v3(struct pms_softc *);
320int	elantech_get_hwinfo_v4(struct pms_softc *);
321int	elantech_ps2_cmd(struct pms_softc *, u_char);
322int	elantech_set_absolute_mode_v1(struct pms_softc *);
323int	elantech_set_absolute_mode_v2(struct pms_softc *);
324int	elantech_set_absolute_mode_v3(struct pms_softc *);
325int	elantech_set_absolute_mode_v4(struct pms_softc *);

327const struct cfattach pms_ca = {
sizeof(struct pms_softc), pmsprobe, pmsattach, NULL((void *)0),
pmsactivate
330};

332struct cfdriver pms_cd = {
NULL((void *)0), "pms", DV_DULL
334};

336const struct wsmouse_accessops pms_accessops = {
pms_enable,
pms_ioctl,
pms_disable,
340};

342const struct wsmouse_accessops pms_sec_accessops = {
pms_sec_enable,
pms_sec_ioctl,
pms_sec_disable,
346};

348const struct pms_protocol pms_protocols[] = {
/* Generic PS/2 mouse */
{
PMS_STANDARD0, 3,
NULL((void *)0),
pms_ioctl_mouse,
pms_sync_mouse,
pms_proc_mouse,
NULL((void *)0)
},
/* Synaptics touchpad */
{
PMS_SYNAPTICS2, 6,
pms_enable_synaptics,
pms_ioctl_synaptics,
pms_sync_synaptics,
pms_proc_synaptics,
pms_disable_synaptics
},
/* ALPS touchpad */
{
PMS_ALPS3, 6,
pms_enable_alps,
pms_ioctl_alps,
pms_sync_alps,
pms_proc_alps,
NULL((void *)0)
},
/* Elantech touchpad (hardware version 1) */
{
PMS_ELANTECH_V14, 4,
pms_enable_elantech_v1,
pms_ioctl_elantech,
pms_sync_elantech_v1,
pms_proc_elantech_v1,
NULL((void *)0)
},
/* Elantech touchpad (hardware version 2) */
{
PMS_ELANTECH_V25, 6,
pms_enable_elantech_v2,
pms_ioctl_elantech,
pms_sync_elantech_v2,
pms_proc_elantech_v2,
NULL((void *)0)
},
/* Elantech touchpad (hardware version 3) */
{
PMS_ELANTECH_V36, 6,
pms_enable_elantech_v3,
pms_ioctl_elantech,
pms_sync_elantech_v3,
pms_proc_elantech_v3,
NULL((void *)0)
},
/* Elantech touchpad (hardware version 4) */
{
PMS_ELANTECH_V47, 6,
pms_enable_elantech_v4,
pms_ioctl_elantech,
pms_sync_elantech_v4,
pms_proc_elantech_v4,
NULL((void *)0)
},
/* Microsoft IntelliMouse */
{
PMS_INTELLI1, 4,
pms_enable_intelli,
pms_ioctl_mouse,
pms_sync_mouse,
pms_proc_mouse,
NULL((void *)0)
},
421};

423int
424pms_cmd(struct pms_softc *sc, u_char *cmd, int len, u_char *resp, int resplen)
425{
if (sc->poll) {
return pckbc_poll_cmd(sc->sc_kbctag, PCKBC_AUX_SLOT1,
    cmd, len, resplen, resp, 1);
} else {
return pckbc_enqueue_cmd(sc->sc_kbctag, PCKBC_AUX_SLOT1,
    cmd, len, resplen, 1, resp);
}
433}

435int
436pms_spec_cmd(struct pms_softc *sc, int cmd)
437{
if (pms_set_scaling(sc, 1) ||
   pms_set_resolution(sc, (cmd >> 6) & 0x03) ||
   pms_set_resolution(sc, (cmd >> 4) & 0x03) ||
   pms_set_resolution(sc, (cmd >> 2) & 0x03) ||
   pms_set_resolution(sc, (cmd >> 0) & 0x03))
return (-1);
return (0);
445}

447int
448pms_get_devid(struct pms_softc *sc, u_char *resp)
449{
u_char cmd[1];

cmd[0] = PMS_SEND_DEV_ID0xf2;
return (pms_cmd(sc, cmd, 1, resp, 1));
454}

456int
457pms_get_status(struct pms_softc *sc, u_char *resp)
458{
u_char cmd[1];

cmd[0] = PMS_SEND_DEV_STATUS0xe9;
return (pms_cmd(sc, cmd, 1, resp, 3));
463}

465int
466pms_set_rate(struct pms_softc *sc, int value)
467{
u_char cmd[2];

cmd[0] = PMS_SET_SAMPLE0xf3;
cmd[1] = value;
return (pms_cmd(sc, cmd, 2, NULL((void *)0), 0));
473}

475int
476pms_set_resolution(struct pms_softc *sc, int value)
477{
u_char cmd[2];

cmd[0] = PMS_SET_RES0xe8;
cmd[1] = value;
return (pms_cmd(sc, cmd, 2, NULL((void *)0), 0));
483}

485int
486pms_set_scaling(struct pms_softc *sc, int scale)
487{
u_char cmd[1];

switch (scale) {
case 1:
default:
cmd[0] = PMS_SET_SCALE110xe6;
break;
case 2:
cmd[0] = PMS_SET_SCALE210xe7;
break;
}
return (pms_cmd(sc, cmd, 1, NULL((void *)0), 0));
500}

502int
503pms_reset(struct pms_softc *sc)
504{
u_char cmd[1], resp[2];
int res;

cmd[0] = PMS_RESET0xff;
res = pms_cmd(sc, cmd, 1, resp, 2);
510#ifdef DEBUG
if (res || resp[0] != PMS_RSTDONE0xaa || resp[1] != 0)
printf("%s: reset error %d (response 0x%02x, type 0x%02x)\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), res, resp[0], resp[1]);
514#endif
return (res);
516}

518int
519pms_dev_enable(struct pms_softc *sc)
520{
u_char cmd[1];
int res;

cmd[0] = PMS_DEV_ENABLE0xf4;
res = pms_cmd(sc, cmd, 1, NULL((void *)0), 0);
if (res)
printf("%s: enable error\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return (res);
529}

531int
532pms_dev_disable(struct pms_softc *sc)
533{
u_char cmd[1];
int res;

cmd[0] = PMS_DEV_DISABLE0xf5;
res = pms_cmd(sc, cmd, 1, NULL((void *)0), 0);
if (res)
printf("%s: disable error\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return (res);
542}

544void
545pms_protocol_lookup(struct pms_softc *sc)
546{
int i;

sc->protocol = &pms_protocols[0];
for (i = 1; i < nitems(pms_protocols)(sizeof((pms_protocols)) / sizeof((pms_protocols)[0])); i++) {
pms_reset(sc);
if (pms_protocols[i].enable(sc)) {
	sc->protocol = &pms_protocols[i];
	break;
}
}

DPRINTF("%s: protocol type %d\n", DEVNAME(sc), sc->protocol->type);
559}

561/*
* Detect reset announcement ([0xaa, 0x0]).
* The sequence will be sent as input on rare occasions when the touchpad was
* reset due to a power failure.
*/
566void
567pms_reset_detect(struct pms_softc *sc, int data)
568{
switch (sc->sc_rststate) {
case PMS_RST_COMMENCE0x01:
if (data == 0x0) {
	sc->sc_rststate = PMS_RST_ANNOUNCED0x02;
	timeout_add_msec(&sc->sc_rsttimo, 100);
} else if (data != PMS_RSTDONE0xaa) {
	sc->sc_rststate = 0;
}
break;
default:
if (data == PMS_RSTDONE0xaa)
	sc->sc_rststate = PMS_RST_COMMENCE0x01;
else
	sc->sc_rststate = 0;
}
584}

586void
587pms_reset_timo(void *v)
588{
struct pms_softc *sc = v;
int s = spltty()splraise(0x9);

/*
* Do nothing if the reset was a false positive or if the device already
* is disabled.
*/
if (sc->sc_rststate == PMS_RST_ANNOUNCED0x02 &&
   sc->sc_state != PMS_STATE_DISABLED0)
task_add(systq, &sc->sc_rsttask);

splx(s)spllower(s);
601}

603void
604pms_reset_task(void *v)
605{
struct pms_softc *sc = v;
int s = spltty()splraise(0x9);

609#ifdef DIAGNOSTIC1
printf("%s: device reset (state = %d)\n", DEVNAME(sc)((sc)->sc_dev.dv_xname), sc->sc_rststate);
611#endif

rw_enter_write(&sc->sc_state_lock);

if (sc->sc_sec_wsmousedev != NULL((void *)0))
pms_change_state(sc, PMS_STATE_DISABLED0, PMS_DEV_SECONDARY0x02);
pms_change_state(sc, PMS_STATE_DISABLED0, PMS_DEV_PRIMARY0x01);

pms_change_state(sc, PMS_STATE_ENABLED1, PMS_DEV_PRIMARY0x01);
if (sc->sc_sec_wsmousedev != NULL((void *)0))
pms_change_state(sc, PMS_STATE_ENABLED1, PMS_DEV_SECONDARY0x02);

rw_exit_write(&sc->sc_state_lock);
splx(s)spllower(s);
625}

627int
628pms_enable_intelli(struct pms_softc *sc)
629{
u_char resp;

/* the special sequence to enable the third button and the roller */
if (pms_set_rate(sc, PMS_INTELLI_MAGIC1200) ||
   pms_set_rate(sc, PMS_INTELLI_MAGIC2100) ||
   pms_set_rate(sc, PMS_INTELLI_MAGIC380) ||
   pms_get_devid(sc, &resp) ||
   resp != PMS_INTELLI_ID0x03)
return (0);

return (1);
641}

643int
644pms_ioctl_mouse(struct pms_softc *sc, u_long cmd, caddr_t data, int flag,
  struct proc *p)
646{
int i;

switch (cmd) {
case WSMOUSEIO_GTYPE((unsigned long)0x40000000 | ((sizeof(u_int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((32))):
*(u_int *)data = WSMOUSE_TYPE_PS22;
break;
case WSMOUSEIO_SRES((unsigned long)0x80000000 | ((sizeof(u_int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((33))):
i = ((int) *(u_int *)data - 12) / 25;
/* valid values are {0,1,2,3} */
if (i < 0)
	i = 0;
if (i > 3)
	i = 3;

if (pms_set_resolution(sc, i))
	printf("%s: SET_RES command error\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
break;
default:
return (-1);
}
return (0);
668}

670int
671pms_sync_mouse(struct pms_softc *sc, int data)
672{
if (sc->inputstate != 0)
return (0);

switch (sc->protocol->type) {
case PMS_STANDARD0:
if ((data & 0xc0) != 0)
	return (-1);
break;
case PMS_INTELLI1:
if ((data & 0x08) != 0x08)
	return (-1);
break;
}

return (0);
688}

690void
691pms_proc_mouse(struct pms_softc *sc)
692{
u_int buttons;
int  dx, dy, dz;

buttons = butmap[sc->packet[0] & PMS_PS2_BUTTONSMASK0x07];
dx = (sc->packet[0] & PMS_PS2_XNEG0x10) ?
   (int)sc->packet[1] - 256 : sc->packet[1];
dy = (sc->packet[0] & PMS_PS2_YNEG0x20) ?
   (int)sc->packet[2] - 256 : sc->packet[2];

if (sc->protocol->type == PMS_INTELLI1)
dz = (signed char)sc->packet[3];
else
dz = 0;

WSMOUSE_INPUT(sc->sc_wsmousedev, buttons, dx, dy, dz, 0)do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_motion
((sc->sc_wsmousedev), (dx), (dy), (dz), (0)); wsmouse_input_sync
(sc->sc_wsmousedev); } while (0);
708}

710int
711pmsprobe(struct device *parent, void *match, void *aux)
712{
struct pckbc_attach_args *pa = aux;
u_char cmd[1], resp[2];
int res;

if (pa->pa_slot != PCKBC_AUX_SLOT1)
return (0);

/* Flush any garbage. */
pckbc_flush(pa->pa_tag, pa->pa_slot);

/* reset the device */
cmd[0] = PMS_RESET0xff;
res = pckbc_poll_cmd(pa->pa_tag, pa->pa_slot, cmd, 1, 2, resp, 1);
if (res || resp[0] != PMS_RSTDONE0xaa || resp[1] != 0) {
727#ifdef DEBUG
printf("pms: reset error %d (response 0x%02x, type 0x%02x)\n",
    res, resp[0], resp[1]);
730#endif
return (0);
}

return (1);
735}

737void
738pmsattach(struct device *parent, struct device *self, void *aux)
739{
struct pms_softc *sc = (void *)self;
struct pckbc_attach_args *pa = aux;
struct wsmousedev_attach_args a;

sc->sc_kbctag = pa->pa_tag;

pckbc_set_inputhandler(sc->sc_kbctag, PCKBC_AUX_SLOT1,
   pmsinput, sc, DEVNAME(sc)((sc)->sc_dev.dv_xname));

printf("\n");

a.accessops = &pms_accessops;
a.accesscookie = sc;

rw_init(&sc->sc_state_lock, "pmsst")_rw_init_flags(&sc->sc_state_lock, "pmsst", 0, ((void *
)0));

/*
* Attach the wsmouse, saving a handle to it.
* Note that we don't need to check this pointer against NULL
* here or in pmsintr, because if this fails pms_enable() will
* never be called, so pmsinput() will never be called.
*/
sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint)config_found_sm((self), (&a), (wsmousedevprint), ((void *
)0));

task_set(&sc->sc_rsttask, pms_reset_task, sc);
timeout_set(&sc->sc_rsttimo, pms_reset_timo, sc);

sc->poll = 1;
sc->sc_dev_enable = 0;

/* See if the device understands an extended (touchpad) protocol. */
pms_protocol_lookup(sc);

/* no interrupts until enabled */
pms_change_state(sc, PMS_STATE_DISABLED0, PMS_DEV_IGNORE0x00);
775}

777int
778pmsactivate(struct device *self, int act)
779{
struct pms_softc *sc = (struct pms_softc *)self;

switch (act) {
case DVACT_SUSPEND3:
if (sc->sc_state == PMS_STATE_ENABLED1)
	pms_change_state(sc, PMS_STATE_SUSPENDED2,
	    PMS_DEV_IGNORE0x00);
break;
case DVACT_RESUME4:
if (sc->sc_state == PMS_STATE_SUSPENDED2)
	pms_change_state(sc, PMS_STATE_ENABLED1,
	    PMS_DEV_IGNORE0x00);
break;
}
return (0);
795}

797int
798pms_change_state(struct pms_softc *sc, int newstate, int dev)
799{
if (dev != PMS_DEV_IGNORE0x00) {
switch (newstate) {
case PMS_STATE_ENABLED1:
	if (sc->sc_dev_enable & dev)
		return (EBUSY16);

	sc->sc_dev_enable |= dev;

	if (sc->sc_state == PMS_STATE_ENABLED1)
		return (0);

	break;
case PMS_STATE_DISABLED0:
	sc->sc_dev_enable &= ~dev;

	if (sc->sc_dev_enable)
		return (0);

	break;
}
}

switch (newstate) {
case PMS_STATE_ENABLED1:
sc->inputstate = 0;
sc->sc_rststate = 0;

pckbc_slot_enable(sc->sc_kbctag, PCKBC_AUX_SLOT1, 1);

if (sc->poll)
	pckbc_flush(sc->sc_kbctag, PCKBC_AUX_SLOT1);

pms_reset(sc);
if (sc->protocol->enable != NULL((void *)0) &&
    sc->protocol->enable(sc) == 0)
	pms_protocol_lookup(sc);

pms_dev_enable(sc);
break;
case PMS_STATE_DISABLED0:
case PMS_STATE_SUSPENDED2:
pms_dev_disable(sc);

if (sc->protocol->disable)
	sc->protocol->disable(sc);

pckbc_slot_enable(sc->sc_kbctag, PCKBC_AUX_SLOT1, 0);
break;
}

sc->sc_state = newstate;
sc->poll = (newstate == PMS_STATE_SUSPENDED2) ? 1 : 0;

return (0);
854}

856int
857pms_enable(void *v)
858{
struct pms_softc *sc = v;
int rv;

rw_enter_write(&sc->sc_state_lock);
rv = pms_change_state(sc, PMS_STATE_ENABLED1, PMS_DEV_PRIMARY0x01);
rw_exit_write(&sc->sc_state_lock);

return (rv);
867}

869void
870pms_disable(void *v)
871{
struct pms_softc *sc = v;

rw_enter_write(&sc->sc_state_lock);
pms_change_state(sc, PMS_STATE_DISABLED0, PMS_DEV_PRIMARY0x01);
rw_exit_write(&sc->sc_state_lock);
877}

879int
880pms_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
881{
struct pms_softc *sc = v;

if (sc->protocol->ioctl)
return (sc->protocol->ioctl(sc, cmd, data, flag, p));
else
return (-1);
888}

890int
891pms_sec_enable(void *v)
892{
struct pms_softc *sc = v;
int rv;

rw_enter_write(&sc->sc_state_lock);
rv = pms_change_state(sc, PMS_STATE_ENABLED1, PMS_DEV_SECONDARY0x02);
rw_exit_write(&sc->sc_state_lock);

return (rv);
901}

903void
904pms_sec_disable(void *v)
905{
struct pms_softc *sc = v;

rw_enter_write(&sc->sc_state_lock);
pms_change_state(sc, PMS_STATE_DISABLED0, PMS_DEV_SECONDARY0x02);
rw_exit_write(&sc->sc_state_lock);
911}

913int
914pms_sec_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *p)
915{
switch (cmd) {
case WSMOUSEIO_GTYPE((unsigned long)0x40000000 | ((sizeof(u_int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((32))):
*(u_int *)data = WSMOUSE_TYPE_PS22;
break;
default:
return (-1);
}
return (0);
924}

926#ifdef DIAGNOSTIC1
927static inline void
928pms_print_packet(struct pms_softc *sc)
929{
int i, state, size;

state = sc->inputstate;
size = sc->protocol->packetsize;
for (i = 0; i < size; i++)
printf(i == state ? " %02x |" : " %02x", sc->packet[i]);
936}
937#endif

939void
940pmsinput(void *vsc, int data)
941{
struct pms_softc *sc = vsc;

if (sc->sc_state != PMS_STATE_ENABLED1) {
/* Interrupts are not expected.  Discard the byte. */
return;
}

sc->packet[sc->inputstate] = data;
pms_reset_detect(sc, data);
if (sc->protocol->sync(sc, data)) {
952#ifdef DIAGNOSTIC1
printf("%s: not in sync yet, discard input "
    "(state = %d,",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), sc->inputstate);
pms_print_packet(sc);
printf(")\n");
958#endif

sc->inputstate = 0;
return;
}

sc->inputstate++;

if (sc->inputstate != sc->protocol->packetsize)
return;

sc->inputstate = 0;
sc->protocol->proc(sc);
971}

973int
974synaptics_set_mode(struct pms_softc *sc, int mode, int rate)
975{
struct synaptics_softc *syn = sc->synaptics;

if (pms_spec_cmd(sc, mode) ||
   pms_set_rate(sc, rate == 0 ? SYNAPTICS_CMD_SET_MODE0x14 : rate))
return (-1);

/*
* Make sure that the set mode command has finished.
* Otherwise enabling the device before that will make it fail.
*/
delay(10000)(*delay_func)(10000);

if (rate == 0)
syn->mode = mode;

return (0);
992}

994int
995synaptics_query(struct pms_softc *sc, int query, int *val)
996{
u_char resp[3];

if (pms_spec_cmd(sc, query) ||
   pms_get_status(sc, resp))
return (-1);

if (val)
*val = (resp[0] << 16) | (resp[1] << 8) | resp[2];

return (0);
1007}

1009int
1010synaptics_get_hwinfo(struct pms_softc *sc)
1011{
struct synaptics_softc *syn = sc->synaptics;
struct wsmousehw *hw;
int resolution = 0, max_coords = 0, min_coords = 0;

hw = wsmouse_get_hw(sc->sc_wsmousedev);

if (synaptics_query(sc, SYNAPTICS_QUE_IDENTIFY0x00, &syn->identify))
return (-1);
if (synaptics_query(sc, SYNAPTICS_QUE_CAPABILITIES0x02,
   &syn->capabilities))
return (-1);
if (synaptics_query(sc, SYNAPTICS_QUE_MODEL0x03, &syn->model))
return (-1);
if ((SYNAPTICS_CAP_EXTENDED_QUERIES(syn->capabilities)(((syn->capabilities) >> 20) & 0x07) >= 1) &&
   synaptics_query(sc, SYNAPTICS_QUE_EXT_MODEL0x09, &syn->ext_model))
return (-1);
if ((SYNAPTICS_CAP_EXTENDED_QUERIES(syn->capabilities)(((syn->capabilities) >> 20) & 0x07) >= 4) &&
   synaptics_query(sc, SYNAPTICS_QUE_EXT_CAPABILITIES0x0c,
&syn->ext_capabilities))
return (-1);
if ((SYNAPTICS_ID_MAJOR(syn->identify)((syn->identify) & 0x0f) >= 4) &&
   synaptics_query(sc, SYNAPTICS_QUE_RESOLUTION0x08, &resolution))
return (-1);
if ((SYNAPTICS_CAP_EXTENDED_QUERIES(syn->capabilities)(((syn->capabilities) >> 20) & 0x07) >= 5) &&
   (syn->ext_capabilities & SYNAPTICS_EXT_CAP_MAX_COORDS(1 << 17)) &&
   synaptics_query(sc, SYNAPTICS_QUE_EXT_MAX_COORDS0x0d, &max_coords))
return (-1);
if ((SYNAPTICS_CAP_EXTENDED_QUERIES(syn->capabilities)(((syn->capabilities) >> 20) & 0x07) >= 7 ||
   SYNAPTICS_ID_FULL(syn->identify)(((syn->identify) & 0x0f) << 8 | (((syn->identify
) >> 16) & 0xff)) == 0x801) &&
   (syn->ext_capabilities & SYNAPTICS_EXT_CAP_MIN_COORDS(1 << 13)) &&
   synaptics_query(sc, SYNAPTICS_QUE_EXT_MIN_COORDS0x0f, &min_coords))
return (-1);

if (SYNAPTICS_ID_FULL(syn->identify)(((syn->identify) & 0x0f) << 8 | (((syn->identify
) >> 16) & 0xff)) >= 0x705) {
if (synaptics_query(sc, SYNAPTICS_QUE_MODES0x01, &syn->modes))
	return (-1);
if ((syn->modes & SYNAPTICS_EXT2_CAP(1 << 17)) &&
    synaptics_query(sc, SYNAPTICS_QUE_EXT2_CAPABILITIES0x10,
    &syn->ext2_capabilities))
	return (-1);
}

if ((syn->ext_capabilities & SYNAPTICS_EXT_CAP_CLICKPAD(1 << 20)) &&
   !(syn->ext2_capabilities & SYNAPTICS_EXT2_CAP_BUTTONS_STICK(1 << 16))
   && mouse_has_softbtn)
hw->type = WSMOUSE_TYPE_SYNAP_SBTN19;
else
hw->type = WSMOUSE_TYPE_SYNAPTICS15;

hw->hw_type = (syn->ext_capabilities & SYNAPTICS_EXT_CAP_CLICKPAD(1 << 20))
   ? WSMOUSEHW_CLICKPAD : WSMOUSEHW_TOUCHPAD;

if (resolution & SYNAPTICS_RESOLUTION_VALID(1 << 15)) {
hw->h_res = SYNAPTICS_RESOLUTION_X(resolution)(((resolution) >> 16) & 0xff);
hw->v_res = SYNAPTICS_RESOLUTION_Y(resolution)((resolution) & 0xff);
}

hw->x_min = (min_coords ?
   SYNAPTICS_X_LIMIT(min_coords)((((min_coords) & 0xff0000) >> 11) | (((min_coords)
 & 0xf00) >> 7)) : SYNAPTICS_XMIN_BEZEL1472);
hw->y_min = (min_coords ?
   SYNAPTICS_Y_LIMIT(min_coords)((((min_coords) & 0xff) << 5) | (((min_coords) &
 0xf000) >> 11)) : SYNAPTICS_YMIN_BEZEL1408);
hw->x_max = (max_coords ?
   SYNAPTICS_X_LIMIT(max_coords)((((max_coords) & 0xff0000) >> 11) | (((max_coords)
 & 0xf00) >> 7)) : SYNAPTICS_XMAX_BEZEL5472);
hw->y_max = (max_coords ?
   SYNAPTICS_Y_LIMIT(max_coords)((((max_coords) & 0xff) << 5) | (((max_coords) &
 0xf000) >> 11)) : SYNAPTICS_YMAX_BEZEL4448);

if ((syn->capabilities & SYNAPTICS_CAP_MULTIFINGER(1 << 1)) ||
   SYNAPTICS_SUPPORTS_AGM(syn->ext_capabilities)((syn->ext_capabilities) & ((1 << 19) | (1 <<
 11))))
hw->contacts_max = SYNAPTICS_MAX_FINGERS3;
else
hw->contacts_max = 1;

syn->sec_buttons = 0;

if (SYNAPTICS_EXT_MODEL_BUTTONS(syn->ext_model)((syn->ext_model >> 12) & 0x0f) > 8)
syn->ext_model &= ~0xf000;

if ((syn->model & SYNAPTICS_MODEL_NEWABS(1 << 7)) == 0) {
printf("%s: don't support Synaptics OLDABS\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
return (-1);
}

if ((SYNAPTICS_ID_MAJOR(syn->identify)((syn->identify) & 0x0f) == 5) &&
   (SYNAPTICS_ID_MINOR(syn->identify)(((syn->identify) >> 16) & 0xff) == 9))
syn->mask = SYNAPTICS_MASK_NEWABS_RELAXED0xc0;
else
syn->mask = SYNAPTICS_MASK_NEWABS_STRICT0xc8;

return (0);
1101}

1103void
1104synaptics_sec_proc(struct pms_softc *sc)
1105{
struct synaptics_softc *syn = sc->synaptics;
u_int buttons;
int dx, dy;

if ((sc->sc_dev_enable & PMS_DEV_SECONDARY0x02) == 0)
return;

buttons = butmap[sc->packet[1] & PMS_PS2_BUTTONSMASK0x07];
buttons |= syn->sec_buttons;
dx = (sc->packet[1] & PMS_PS2_XNEG0x10) ?
   (int)sc->packet[4] - 256 : sc->packet[4];
dy = (sc->packet[1] & PMS_PS2_YNEG0x20) ?
   (int)sc->packet[5] - 256 : sc->packet[5];

WSMOUSE_INPUT(sc->sc_sec_wsmousedev, buttons, dx, dy, 0, 0)do { wsmouse_buttons((sc->sc_sec_wsmousedev), (buttons)); wsmouse_motion
((sc->sc_sec_wsmousedev), (dx), (dy), (0), (0)); wsmouse_input_sync
(sc->sc_sec_wsmousedev); } while (0);
1121}

1123int
1124synaptics_knock(struct pms_softc *sc)
1125{
u_char resp[3];

if (pms_set_resolution(sc, 0) ||
   pms_set_resolution(sc, 0) ||
   pms_set_resolution(sc, 0) ||
   pms_set_resolution(sc, 0) ||
   pms_get_status(sc, resp) ||
   resp[1] != SYNAPTICS_ID_MAGIC0x47)
return (-1);

return (0);
1137}

1139int
1140pms_enable_synaptics(struct pms_softc *sc)
1141{
struct synaptics_softc *syn = sc->synaptics;
struct wsmousedev_attach_args a;
int mode, i;

if (synaptics_knock(sc)) {
if (sc->synaptics == NULL((void *)0))
	goto err;
/*
 * Some synaptics touchpads don't resume quickly.
 * Retry a few times.
 */
for (i = 10; i > 0; --i) {
	printf("%s: device not resuming, retrying\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	pms_reset(sc);
	if (synaptics_knock(sc) == 0)
		break;
	delay(100000)(*delay_func)(100000);
}
if (i == 0) {
	printf("%s: lost device\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}
}

if (sc->synaptics == NULL((void *)0)) {
sc->synaptics = syn = malloc(sizeof(struct synaptics_softc),
    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (syn == NULL((void *)0)) {
	printf("%s: synaptics: not enough memory\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

if (synaptics_get_hwinfo(sc)) {
	free(sc->synaptics, M_DEVBUF2,
	    sizeof(struct synaptics_softc));
	sc->synaptics = NULL((void *)0);
	goto err;
}

/* enable pass-through PS/2 port if supported */
if (syn->capabilities & SYNAPTICS_CAP_PASSTHROUGH(1 << 7)) {
	a.accessops = &pms_sec_accessops;
	a.accesscookie = sc;
	sc->sc_sec_wsmousedev = config_found((void *)sc, &a,config_found_sm(((void *)sc), (&a), (wsmousedevprint), ((
void *)0))
	    wsmousedevprint)config_found_sm(((void *)sc), (&a), (wsmousedevprint), ((
void *)0));
}

if (wsmouse_configure(sc->sc_wsmousedev, synaptics_params,
    nitems(synaptics_params)(sizeof((synaptics_params)) / sizeof((synaptics_params)[0]))))
	goto err;

printf("%s: Synaptics %s, firmware %d.%d, "
    "0x%x 0x%x 0x%x 0x%x 0x%x\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname),
    (syn->ext_capabilities & SYNAPTICS_EXT_CAP_CLICKPAD(1 << 20) ?
	"clickpad" : "touchpad"),
    SYNAPTICS_ID_MAJOR(syn->identify)((syn->identify) & 0x0f),
    SYNAPTICS_ID_MINOR(syn->identify)(((syn->identify) >> 16) & 0xff),
    syn->model, syn->ext_model, syn->modes,
    syn->capabilities, syn->ext_capabilities);
}

/*
* Enable absolute mode, plain W-mode and "advanced gesture mode"
* (AGM), if possible.  AGM, which seems to be a prerequisite for the
* extended W-mode, might not always be necessary here, but at least
* some older Synaptics models do not report finger counts without it.
*/
mode = SYNAPTICS_ABSOLUTE_MODE(1 << 7) | SYNAPTICS_HIGH_RATE(1 << 6);
if (syn->capabilities & SYNAPTICS_CAP_EXTENDED(1 << 23))
mode |= SYNAPTICS_W_MODE(1 << 0);
else if (SYNAPTICS_ID_MAJOR(syn->identify)((syn->identify) & 0x0f) >= 4)
mode |= SYNAPTICS_DISABLE_GESTURE(1 << 2);
if (synaptics_set_mode(sc, mode, 0))
goto err;

if (SYNAPTICS_SUPPORTS_AGM(syn->ext_capabilities)((syn->ext_capabilities) & ((1 << 19) | (1 <<
 11))) &&
   synaptics_set_mode(sc, SYNAPTICS_QUE_MODEL0x03,
       SYNAPTICS_CMD_SET_ADV_GESTURE_MODE0xc8))
goto err;

return (1);

1227err:
pms_reset(sc);

return (0);
1231}

1233int
1234pms_ioctl_synaptics(struct pms_softc *sc, u_long cmd, caddr_t data, int flag,
  struct proc *p)
1236{
struct wsmouse_calibcoords *wsmc = (struct wsmouse_calibcoords *)data;
struct wsmousehw *hw;
int wsmode;

hw = wsmouse_get_hw(sc->sc_wsmousedev);
switch (cmd) {
case WSMOUSEIO_GTYPE((unsigned long)0x40000000 | ((sizeof(u_int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((32))):
*(u_int *)data = hw->type;
break;
case WSMOUSEIO_GCALIBCOORDS((unsigned long)0x40000000 | ((sizeof(struct wsmouse_calibcoords
) & 0x1fff) << 16) | ((('W')) << 8) | ((37))):
wsmc->minx = hw->x_min;
wsmc->maxx = hw->x_max;
wsmc->miny = hw->y_min;
wsmc->maxy = hw->y_max;
wsmc->swapxy = 0;
wsmc->resx = hw->h_res;
wsmc->resy = hw->v_res;
break;
case WSMOUSEIO_SETMODE((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((38))):
wsmode = *(u_int *)data;
if (wsmode != WSMOUSE_COMPAT0 && wsmode != WSMOUSE_NATIVE1)
	return (EINVAL22);
wsmouse_set_mode(sc->sc_wsmousedev, wsmode);
break;
default:
return (-1);
}
return (0);
1265}

1267int
1268pms_sync_synaptics(struct pms_softc *sc, int data)
1269{
struct synaptics_softc *syn = sc->synaptics;

switch (sc->inputstate) {
case 0:
if ((data & syn->mask) != SYNAPTICS_VALID_NEWABS_FIRST0x80)
	return (-1);
break;
case 3:
if ((data & syn->mask) != SYNAPTICS_VALID_NEWABS_NEXT0xc0)
	return (-1);
break;
}

return (0);
1284}

1286void
1287pms_proc_synaptics(struct pms_softc *sc)
1288{
struct synaptics_softc *syn = sc->synaptics;
u_int buttons;
int x, y, z, w, fingerwidth;

w = ((sc->packet[0] & 0x30) >> 2) | ((sc->packet[0] & 0x04) >> 1) |
   ((sc->packet[3] & 0x04) >> 2);
z = sc->packet[2];

if ((syn->capabilities & SYNAPTICS_CAP_EXTENDED(1 << 23)) == 0) {
/*
 * Emulate W mode for models that don't provide it. Bit 3
 * of the w-input signals a touch ("finger"), Bit 2 and
 * the "gesture" bits 1-0 can be ignored.
 */
if (w & 8)
	w = 4;
else
	z = w = 0;
}


if (w == 3) {
if (syn->capabilities & SYNAPTICS_CAP_PASSTHROUGH(1 << 7))
	synaptics_sec_proc(sc);
return;
}

if ((sc->sc_dev_enable & PMS_DEV_PRIMARY0x01) == 0)
return;

if (w == 2)
return;	/* EW-mode packets are not expected here. */

x = ((sc->packet[3] & 0x10) << 8) | ((sc->packet[1] & 0x0f) << 8) |
   sc->packet[4];
y = ((sc->packet[3] & 0x20) << 7) | ((sc->packet[1] & 0xf0) << 4) |
   sc->packet[5];

buttons = ((sc->packet[0] & sc->packet[3]) & 0x01) ?
   WSMOUSE_BUTTON(1)(1 << ((1) - 1)) : 0;
buttons |= ((sc->packet[0] & sc->packet[3]) & 0x02) ?
   WSMOUSE_BUTTON(3)(1 << ((3) - 1)) : 0;

if (syn->ext_capabilities & SYNAPTICS_EXT_CAP_CLICKPAD(1 << 20)) {
buttons |= ((sc->packet[0] ^ sc->packet[3]) & 0x01) ?
    WSMOUSE_BUTTON(1)(1 << ((1) - 1)) : 0;
} else if (syn->capabilities & SYNAPTICS_CAP_MIDDLE_BUTTON(1 << 18)) {
buttons |= ((sc->packet[0] ^ sc->packet[3]) & 0x01) ?
    WSMOUSE_BUTTON(2)(1 << ((2) - 1)) : 0;
}

if (syn->capabilities & SYNAPTICS_CAP_FOUR_BUTTON(1 << 3)) {
buttons |= ((sc->packet[0] ^ sc->packet[3]) & 0x01) ?
    WSMOUSE_BUTTON(4)(1 << ((4) - 1)) : 0;
buttons |= ((sc->packet[0] ^ sc->packet[3]) & 0x02) ?
    WSMOUSE_BUTTON(5)(1 << ((5) - 1)) : 0;
} else if (SYNAPTICS_EXT_MODEL_BUTTONS(syn->ext_model)((syn->ext_model >> 12) & 0x0f) &&
   ((sc->packet[0] ^ sc->packet[3]) & 0x02)) {
if (syn->ext2_capabilities & SYNAPTICS_EXT2_CAP_BUTTONS_STICK(1 << 16)) {
	/*
	 * Trackstick buttons on this machine are wired to the
	 * trackpad as extra buttons, so route the event
	 * through the trackstick interface as normal buttons
	 */
	syn->sec_buttons =
	    (sc->packet[4] & 0x01) ? WSMOUSE_BUTTON(1)(1 << ((1) - 1)) : 0;
	syn->sec_buttons |=
	    (sc->packet[5] & 0x01) ? WSMOUSE_BUTTON(3)(1 << ((3) - 1)) : 0;
	syn->sec_buttons |=
	    (sc->packet[4] & 0x02) ? WSMOUSE_BUTTON(2)(1 << ((2) - 1)) : 0;
	wsmouse_buttons(
	    sc->sc_sec_wsmousedev, syn->sec_buttons);
	wsmouse_input_sync(sc->sc_sec_wsmousedev);
	return;
}

buttons |= (sc->packet[4] & 0x01) ? WSMOUSE_BUTTON(6)(1 << ((6) - 1)) : 0;
buttons |= (sc->packet[5] & 0x01) ? WSMOUSE_BUTTON(7)(1 << ((7) - 1)) : 0;
buttons |= (sc->packet[4] & 0x02) ? WSMOUSE_BUTTON(8)(1 << ((8) - 1)) : 0;
buttons |= (sc->packet[5] & 0x02) ? WSMOUSE_BUTTON(9)(1 << ((9) - 1)) : 0;
buttons |= (sc->packet[4] & 0x04) ? WSMOUSE_BUTTON(10)(1 << ((10) - 1)) : 0;
buttons |= (sc->packet[5] & 0x04) ? WSMOUSE_BUTTON(11)(1 << ((11) - 1)) : 0;
buttons |= (sc->packet[4] & 0x08) ? WSMOUSE_BUTTON(12)(1 << ((12) - 1)) : 0;
buttons |= (sc->packet[5] & 0x08) ? WSMOUSE_BUTTON(13)(1 << ((13) - 1)) : 0;
x &= ~0x0f;
y &= ~0x0f;
}

if (z) {
fingerwidth = max(w, 4);
w = (w < 2 ? w + 2 : 1);
} else {
fingerwidth = 0;
w = 0;
}
wsmouse_set(sc->sc_wsmousedev, WSMOUSE_TOUCH_WIDTH, fingerwidth, 0);
WSMOUSE_TOUCH(sc->sc_wsmousedev, buttons, x, y, z, w)do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (x), (y)); wsmouse_touch((sc->sc_wsmousedev
), (z), (w)); wsmouse_input_sync(sc->sc_wsmousedev); } while
 (0);
1386}

1388void
1389pms_disable_synaptics(struct pms_softc *sc)
1390{
struct synaptics_softc *syn = sc->synaptics;

if (syn->capabilities & SYNAPTICS_CAP_SLEEP(1 << 4))
synaptics_set_mode(sc, SYNAPTICS_SLEEP_MODE(1 << 3) |
    SYNAPTICS_DISABLE_GESTURE(1 << 2), 0);
1396}

1398int
1399alps_sec_proc(struct pms_softc *sc)
1400{
struct alps_softc *alps = sc->alps;
int dx, dy, pos = 0;

if ((sc->packet[0] & PMS_ALPS_PS2_MASK0xc8) == PMS_ALPS_PS2_VALID0x08) {
/*
 * We need to keep buttons states because interleaved
 * packets only signalize x/y movements.
 */
alps->sec_buttons = butmap[sc->packet[0] & PMS_PS2_BUTTONSMASK0x07];
} else if ((sc->packet[3] & PMS_ALPS_INTERLEAVED_MASK0xcf) ==
   PMS_ALPS_INTERLEAVED_VALID0x0f) {
sc->inputstate = 3;
pos = 3;
} else {
return (0);
}

if ((sc->sc_dev_enable & PMS_DEV_SECONDARY0x02) == 0)
return (1);

dx = (sc->packet[pos] & PMS_PS2_XNEG0x10) ?
   (int)sc->packet[pos + 1] - 256 : sc->packet[pos + 1];
dy = (sc->packet[pos] & PMS_PS2_YNEG0x20) ?
   (int)sc->packet[pos + 2] - 256 : sc->packet[pos + 2];

WSMOUSE_INPUT(sc->sc_sec_wsmousedev, alps->sec_buttons, dx, dy, 0, 0)do { wsmouse_buttons((sc->sc_sec_wsmousedev), (alps->sec_buttons
)); wsmouse_motion((sc->sc_sec_wsmousedev), (dx), (dy), (0
), (0)); wsmouse_input_sync(sc->sc_sec_wsmousedev); } while
 (0);

return (1);
1429}

1431int
1432alps_get_hwinfo(struct pms_softc *sc)
1433{
struct alps_softc *alps = sc->alps;
u_char resp[3];
int i;
struct wsmousehw *hw;

if (pms_set_resolution(sc, 0) ||
   pms_set_scaling(sc, 2) ||
   pms_set_scaling(sc, 2) ||
   pms_set_scaling(sc, 2) ||
   pms_get_status(sc, resp)) {
DPRINTF("%s: alps: model query error\n", DEVNAME(sc));
return (-1);
}

alps->version = (resp[0] << 8) | (resp[1] << 4) | (resp[2] / 20 + 1);

for (i = 0; i < nitems(alps_models)(sizeof((alps_models)) / sizeof((alps_models)[0])); i++)
if (alps->version == alps_models[i].version) {
	alps->model = alps_models[i].model;
	alps->mask = alps_models[i].mask;

	hw = wsmouse_get_hw(sc->sc_wsmousedev);
	hw->type = WSMOUSE_TYPE_ALPS16;
	hw->hw_type = WSMOUSEHW_TOUCHPAD;
	hw->x_min = ALPS_XMIN_BEZEL0;
	hw->y_min = ALPS_YMIN_BEZEL0;
	hw->x_max = ALPS_XMAX_BEZEL1023;
	hw->y_max = ALPS_YMAX_BEZEL767;
	hw->contacts_max = 1;

	return (0);
}

return (-1);
1468}

1470int
1471pms_enable_alps(struct pms_softc *sc)
1472{
struct alps_softc *alps = sc->alps;
struct wsmousedev_attach_args a;
u_char resp[3];

if (pms_set_resolution(sc, 0) ||
   pms_set_scaling(sc, 1) ||
   pms_set_scaling(sc, 1) ||
   pms_set_scaling(sc, 1) ||
   pms_get_status(sc, resp) ||
   resp[0] != PMS_ALPS_MAGIC10 ||
   resp[1] != PMS_ALPS_MAGIC20 ||
   (resp[2] != PMS_ALPS_MAGIC3_110 && resp[2] != PMS_ALPS_MAGIC3_280 &&
   resp[2] != PMS_ALPS_MAGIC3_3100))
goto err;

if (sc->alps == NULL((void *)0)) {
sc->alps = alps = malloc(sizeof(struct alps_softc),
    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (alps == NULL((void *)0)) {
	printf("%s: alps: not enough memory\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

if (alps_get_hwinfo(sc)) {
	free(sc->alps, M_DEVBUF2, sizeof(struct alps_softc));
	sc->alps = NULL((void *)0);
	goto err;
}

if (wsmouse_configure(sc->sc_wsmousedev, alps_params,
    nitems(alps_params)(sizeof((alps_params)) / sizeof((alps_params)[0])))) {
	free(sc->alps, M_DEVBUF2, sizeof(struct alps_softc));
	sc->alps = NULL((void *)0);
	printf("%s: setup failed\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

printf("%s: ALPS %s, version 0x%04x\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
    (alps->model & ALPS_DUALPOINT(1 << 2) ? "Dualpoint" : "Glidepoint"),
    alps->version);


if (alps->model & ALPS_DUALPOINT(1 << 2)) {
	a.accessops = &pms_sec_accessops;
	a.accesscookie = sc;
	sc->sc_sec_wsmousedev = config_found((void *)sc, &a,config_found_sm(((void *)sc), (&a), (wsmousedevprint), ((
void *)0))
	    wsmousedevprint)config_found_sm(((void *)sc), (&a), (wsmousedevprint), ((
void *)0));
}
}

if (alps->model == 0)
goto err;

if ((alps->model & ALPS_PASSTHROUGH(1 << 3)) &&
  (pms_set_scaling(sc, 2) ||
   pms_set_scaling(sc, 2) ||
   pms_set_scaling(sc, 2) ||
   pms_dev_disable(sc))) {
DPRINTF("%s: alps: passthrough on error\n", DEVNAME(sc));
goto err;
}

if (pms_dev_disable(sc) ||
   pms_dev_disable(sc) ||
   pms_set_rate(sc, 0x0a)) {
DPRINTF("%s: alps: tapping error\n", DEVNAME(sc));
goto err;
}

if (pms_dev_disable(sc) ||
   pms_dev_disable(sc) ||
   pms_dev_disable(sc) ||
   pms_dev_disable(sc) ||
   pms_dev_enable(sc)) {
DPRINTF("%s: alps: absolute mode error\n", DEVNAME(sc));
goto err;
}

if ((alps->model & ALPS_PASSTHROUGH(1 << 3)) &&
  (pms_set_scaling(sc, 1) ||
   pms_set_scaling(sc, 1) ||
   pms_set_scaling(sc, 1) ||
   pms_dev_disable(sc))) {
DPRINTF("%s: alps: passthrough off error\n", DEVNAME(sc));
goto err;
}

alps->sec_buttons = 0;

return (1);

1564err:
pms_reset(sc);

return (0);
1568}

1570int
1571pms_ioctl_alps(struct pms_softc *sc, u_long cmd, caddr_t data, int flag,
  struct proc *p)
1573{
struct wsmouse_calibcoords *wsmc = (struct wsmouse_calibcoords *)data;
int wsmode;
struct wsmousehw *hw;

switch (cmd) {
case WSMOUSEIO_GTYPE((unsigned long)0x40000000 | ((sizeof(u_int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((32))):
*(u_int *)data = WSMOUSE_TYPE_ALPS16;
break;
case WSMOUSEIO_GCALIBCOORDS((unsigned long)0x40000000 | ((sizeof(struct wsmouse_calibcoords
) & 0x1fff) << 16) | ((('W')) << 8) | ((37))):
hw = wsmouse_get_hw(sc->sc_wsmousedev);
wsmc->minx = hw->x_min;
wsmc->maxx = hw->x_max;
wsmc->miny = hw->y_min;
wsmc->maxy = hw->y_max;
wsmc->swapxy = 0;
break;
case WSMOUSEIO_SETMODE((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((38))):
wsmode = *(u_int *)data;
if (wsmode != WSMOUSE_COMPAT0 && wsmode != WSMOUSE_NATIVE1)
	return (EINVAL22);
wsmouse_set_mode(sc->sc_wsmousedev, wsmode);
break;
default:
return (-1);
}
return (0);
1600}

1602int
1603pms_sync_alps(struct pms_softc *sc, int data)
1604{
struct alps_softc *alps = sc->alps;

if ((alps->model & ALPS_DUALPOINT(1 << 2)) &&
   (sc->packet[0] & PMS_ALPS_PS2_MASK0xc8) == PMS_ALPS_PS2_VALID0x08) {
if (sc->inputstate == 2)
	sc->inputstate += 3;
return (0);
}

switch (sc->inputstate) {
case 0:
if ((data & alps->mask) != alps->mask)
	return (-1);
break;
case 1:
case 2:
case 3:
if ((data & PMS_ALPS_MASK0x80) != PMS_ALPS_VALID0x00)
	return (-1);
break;
case 4:
case 5:
if ((alps->model & ALPS_INTERLEAVED(1 << 4)) == 0 &&
    (data & PMS_ALPS_MASK0x80) != PMS_ALPS_VALID0x00)
	return (-1);
break;
}

return (0);
1634}

1636void
1637pms_proc_alps(struct pms_softc *sc)
1638{
struct alps_softc *alps = sc->alps;
int x, y, z, dx, dy;
u_int buttons, gesture;

if ((alps->model & ALPS_DUALPOINT(1 << 2)) && alps_sec_proc(sc))
return;

x = sc->packet[1] | ((sc->packet[2] & 0x78) << 4);
y = sc->packet[4] | ((sc->packet[3] & 0x70) << 3);
z = sc->packet[5];

buttons = ((sc->packet[3] & 1) ? WSMOUSE_BUTTON(1)(1 << ((1) - 1)) : 0) |
   ((sc->packet[3] & 2) ? WSMOUSE_BUTTON(3)(1 << ((3) - 1)) : 0) |
   ((sc->packet[3] & 4) ? WSMOUSE_BUTTON(2)(1 << ((2) - 1)) : 0);

if ((sc->sc_dev_enable & PMS_DEV_SECONDARY0x02) && z == ALPS_Z_MAGIC127) {
dx = (x > ALPS_XSEC_BEZEL768 / 2) ? (x - ALPS_XSEC_BEZEL768) : x;
dy = (y > ALPS_YSEC_BEZEL512 / 2) ? (y - ALPS_YSEC_BEZEL512) : y;

WSMOUSE_INPUT(sc->sc_sec_wsmousedev, buttons, dx, dy, 0, 0)do { wsmouse_buttons((sc->sc_sec_wsmousedev), (buttons)); wsmouse_motion
((sc->sc_sec_wsmousedev), (dx), (dy), (0), (0)); wsmouse_input_sync
(sc->sc_sec_wsmousedev); } while (0);

return;
}

if ((sc->sc_dev_enable & PMS_DEV_PRIMARY0x01) == 0)
return;

/*
* XXX The Y-axis is in the oposit direction compared to
* Synaptics touchpads and PS/2 mouses.
* It's why we need to translate the y value here for both
* NATIVE and COMPAT modes.
*/
y = ALPS_YMAX_BEZEL767 - y + ALPS_YMIN_BEZEL0;

if (alps->gesture == ALPS_TAP0x01) {
/* Report a touch with the tap coordinates. */
WSMOUSE_TOUCH(sc->sc_wsmousedev, buttons,do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (alps->old_x), (alps->old_y));
 wsmouse_touch((sc->sc_wsmousedev), (40), (0)); wsmouse_input_sync
(sc->sc_wsmousedev); } while (0)
    alps->old_x, alps->old_y, ALPS_PRESSURE, 0)do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (alps->old_x), (alps->old_y));
 wsmouse_touch((sc->sc_wsmousedev), (40), (0)); wsmouse_input_sync
(sc->sc_wsmousedev); } while (0);
if (z > 0) {
	/*
	 * The hardware doesn't send a null pressure
	 * event when dragging starts.
	 */
	WSMOUSE_TOUCH(sc->sc_wsmousedev, buttons,do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (alps->old_x), (alps->old_y));
 wsmouse_touch((sc->sc_wsmousedev), (0), (0)); wsmouse_input_sync
(sc->sc_wsmousedev); } while (0)
	    alps->old_x, alps->old_y, 0, 0)do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (alps->old_x), (alps->old_y));
 wsmouse_touch((sc->sc_wsmousedev), (0), (0)); wsmouse_input_sync
(sc->sc_wsmousedev); } while (0);
}
}

gesture = sc->packet[2] & 0x03;
if (gesture != ALPS_TAP0x01)
WSMOUSE_TOUCH(sc->sc_wsmousedev, buttons, x, y, z, 0)do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (x), (y)); wsmouse_touch((sc->sc_wsmousedev
), (z), (0)); wsmouse_input_sync(sc->sc_wsmousedev); } while
 (0);

if (alps->gesture != ALPS_DRAG0x03 || gesture != ALPS_TAP0x01)
alps->gesture = gesture;

alps->old_x = x;
alps->old_y = y;
1697}

1699int
1700elantech_set_absolute_mode_v1(struct pms_softc *sc)
1701{
int i;
u_char resp[3];

/* Enable absolute mode. Magic numbers from Linux driver. */
if (pms_spec_cmd(sc, ELANTECH_CMD_WRITE_REG0x11) ||
7
←
Taking false branch→
   pms_spec_cmd(sc, 0x10) ||
   pms_spec_cmd(sc, 0x16) ||
   pms_set_scaling(sc, 1) ||
5
←
Assuming the condition is false→
   pms_spec_cmd(sc, ELANTECH_CMD_WRITE_REG0x11) ||
   pms_spec_cmd(sc, 0x11) ||
   pms_spec_cmd(sc, 0x8f) ||
   pms_set_scaling(sc, 1))
6
←
Assuming the condition is false→
return (-1);

/* Read back reg 0x10 to ensure hardware is ready. */
for (i = 0; i < 5; i++) {
if (pms_spec_cmd(sc, ELANTECH_CMD_READ_REG0x10) ||
    pms_spec_cmd(sc, 0x10) ||
    pms_get_status(sc, resp) == 0)
	break;
delay(2000)(*delay_func)(2000);
}
if (i8.1
'i' is not equal to 5
 == 5)
8
←
 Execution continues on line 1724→
9
←
Taking false branch→
return (-1);

if ((resp[0] & ELANTECH_ABSOLUTE_MODE0x04) == 0)
10
←
The left operand of '&' is a garbage value
return (-1);

return (0);
1731}

1733int
1734elantech_set_absolute_mode_v2(struct pms_softc *sc)
1735{
int i;
u_char resp[3];
u_char reg10 = (sc->elantech->fw_version == 0x20030 ? 0x54 : 0xc4);

/* Enable absolute mode. Magic numbers from Linux driver. */
if (elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, ELANTECH_CMD_WRITE_REG0x11) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, 0x10) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, reg10) ||
   pms_set_scaling(sc, 1) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, ELANTECH_CMD_WRITE_REG0x11) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, 0x11) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, 0x88) ||
   pms_set_scaling(sc, 1))
return (-1);

/* Read back reg 0x10 to ensure hardware is ready. */
for (i = 0; i < 5; i++) {
if (elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
    elantech_ps2_cmd(sc, ELANTECH_CMD_READ_REG0x10) ||
    elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
    elantech_ps2_cmd(sc, 0x10) ||
    pms_get_status(sc, resp) == 0)
	break;
delay(2000)(*delay_func)(2000);
}
if (i == 5)
return (-1);

return (0);
1771}

1773int
1774elantech_set_absolute_mode_v3(struct pms_softc *sc)
1775{
int i;
u_char resp[3];

/* Enable absolute mode. Magic numbers from Linux driver. */
if (elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, ELANTECH_CMD_READ_WRITE_REG0x00) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, 0x10) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, 0x0b) ||
   pms_set_scaling(sc, 1))
return (-1);

/* Read back reg 0x10 to ensure hardware is ready. */
for (i = 0; i < 5; i++) {
if (elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
    elantech_ps2_cmd(sc, ELANTECH_CMD_READ_WRITE_REG0x00) ||
    elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
    elantech_ps2_cmd(sc, 0x10) ||
    pms_get_status(sc, resp) == 0)
	break;
delay(2000)(*delay_func)(2000);
}
if (i == 5)
return (-1);

return (0);
1803}

1805int
1806elantech_set_absolute_mode_v4(struct pms_softc *sc)
1807{
/* Enable absolute mode. Magic numbers from Linux driver. */
if (elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, ELANTECH_CMD_READ_WRITE_REG0x00) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, 0x07) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, ELANTECH_CMD_READ_WRITE_REG0x00) ||
   elantech_ps2_cmd(sc, ELANTECH_PS2_CUSTOM_COMMAND0xf8) ||
   elantech_ps2_cmd(sc, 0x01) ||
   pms_set_scaling(sc, 1))
return (-1);

/* v4 has no register 0x10 to read response from */

return (0);
1823}

1825int
1826elantech_get_hwinfo_v1(struct pms_softc *sc)
1827{
struct elantech_softc *elantech = sc->elantech;
struct wsmousehw *hw;
int fw_version;
u_char capabilities[3];

if (synaptics_query(sc, ELANTECH_QUE_FW_VER1, &fw_version))
return (-1);

if (fw_version < 0x20030 || fw_version == 0x20600) {
if (fw_version < 0x20000)
	elantech->flags |= ELANTECH_F_HW_V1_OLD0x08;
} else
return (-1);

elantech->fw_version = fw_version;

if (pms_spec_cmd(sc, ELANTECH_QUE_CAPABILITIES2) ||
   pms_get_status(sc, capabilities))
return (-1);

if (capabilities[0] & ELANTECH_CAP_HAS_ROCKER4)
elantech->flags |= ELANTECH_F_HAS_ROCKER0x02;

if (elantech_set_absolute_mode_v1(sc))
return (-1);

hw = wsmouse_get_hw(sc->sc_wsmousedev);
hw->type = WSMOUSE_TYPE_ELANTECH18;
hw->hw_type = WSMOUSEHW_TOUCHPAD;
hw->x_min = ELANTECH_V1_X_MIN(0 + 32);
hw->x_max = ELANTECH_V1_X_MAX(576 - 32);
hw->y_min = ELANTECH_V1_Y_MIN(0 + 32);
hw->y_max = ELANTECH_V1_Y_MAX(384 - 32);

return (0);
1863}

1865int
1866elantech_get_hwinfo_v2(struct pms_softc *sc)
1867{
struct elantech_softc *elantech = sc->elantech;
struct wsmousehw *hw;
int fw_version, ic_ver;
u_char capabilities[3];
int i, fixed_dpi;
u_char resp[3];

if (synaptics_query(sc, ELANTECH_QUE_FW_VER1, &fw_version))
return (-1);

ic_ver = (fw_version & 0x0f0000) >> 16;
if (ic_ver != 2 && ic_ver != 4)
return (-1);

elantech->fw_version = fw_version;
if (fw_version >= 0x20800)
elantech->flags |= ELANTECH_F_REPORTS_PRESSURE0x01;

if (pms_spec_cmd(sc, ELANTECH_QUE_CAPABILITIES2) ||
   pms_get_status(sc, capabilities))
return (-1);

if (elantech_set_absolute_mode_v2(sc))
return (-1);

hw = wsmouse_get_hw(sc->sc_wsmousedev);
hw->type = WSMOUSE_TYPE_ELANTECH18;
hw->hw_type = WSMOUSEHW_TOUCHPAD;

if (fw_version == 0x20800 || fw_version == 0x20b00 ||
   fw_version == 0x20030) {
hw->x_max = ELANTECH_V2_X_MAX1152;
hw->y_max = ELANTECH_V2_Y_MAX768;
} else {
if (pms_spec_cmd(sc, ELANTECH_QUE_FW_ID0) ||
    pms_get_status(sc, resp))
	return (-1);
fixed_dpi = resp[1] & 0x10;
i = (fw_version > 0x20800 && fw_version < 0x20900) ? 1 : 2;
if ((fw_version >> 16) == 0x14 && fixed_dpi) {
	if (pms_spec_cmd(sc, ELANTECH_QUE_SAMPLE3) ||
	    pms_get_status(sc, resp))
		return (-1);
	hw->x_max = (capabilities[1] - i) * resp[1] / 2;
	hw->y_max = (capabilities[2] - i) * resp[2] / 2;
} else if (fw_version == 0x040216) {
	hw->x_max = 819;
	hw->y_max = 405;
} else if (fw_version == 0x040219 || fw_version == 0x040215) {
	hw->x_max = 900;
	hw->y_max = 500;
} else {
	hw->x_max = (capabilities[1] - i) * 64;
	hw->y_max = (capabilities[2] - i) * 64;
}
}

return (0);
1926}

1928int
1929elantech_get_hwinfo_v3(struct pms_softc *sc)
1930{
struct elantech_softc *elantech = sc->elantech;
struct wsmousehw *hw;
int fw_version;
u_char resp[3];

if (synaptics_query(sc, ELANTECH_QUE_FW_VER1, &fw_version))
return (-1);

if (((fw_version & 0x0f0000) >> 16) != 5)
return (-1);

elantech->fw_version = fw_version;
elantech->flags |= ELANTECH_F_REPORTS_PRESSURE0x01;

if ((fw_version & 0x4000) == 0x4000)
elantech->flags |= ELANTECH_F_CRC_ENABLED0x10;

if (elantech_set_absolute_mode_v3(sc))
return (-1);

if (pms_spec_cmd(sc, ELANTECH_QUE_FW_ID0) ||
   pms_get_status(sc, resp))
return (-1);

hw = wsmouse_get_hw(sc->sc_wsmousedev);
hw->x_max = elantech->max_x = (resp[0] & 0x0f) << 8 | resp[1];
hw->y_max = elantech->max_y = (resp[0] & 0xf0) << 4 | resp[2];

hw->type = WSMOUSE_TYPE_ELANTECH18;
hw->hw_type = WSMOUSEHW_TOUCHPAD;

return (0);
1963}

1965int
1966elantech_get_hwinfo_v4(struct pms_softc *sc)
1967{
struct elantech_softc *elantech = sc->elantech;
struct wsmousehw *hw;
int fw_version;
u_char capabilities[3];
u_char resp[3];

if (synaptics_query(sc, ELANTECH_QUE_FW_VER1, &fw_version))
return (-1);

if ((fw_version & 0x0f0000) >> 16 < 6)
return (-1);

elantech->fw_version = fw_version;
elantech->flags |= ELANTECH_F_REPORTS_PRESSURE0x01;

if ((fw_version & 0x4000) == 0x4000)
elantech->flags |= ELANTECH_F_CRC_ENABLED0x10;

if (elantech_set_absolute_mode_v4(sc))
return (-1);

if (pms_spec_cmd(sc, ELANTECH_QUE_CAPABILITIES2) ||
   pms_get_status(sc, capabilities))
return (-1);

if (pms_spec_cmd(sc, ELANTECH_QUE_FW_ID0) ||
   pms_get_status(sc, resp))
return (-1);

hw = wsmouse_get_hw(sc->sc_wsmousedev);
hw->x_max = (resp[0] & 0x0f) << 8 | resp[1];
hw->y_max = (resp[0] & 0xf0) << 4 | resp[2];

if ((capabilities[1] < 2) || (capabilities[1] > hw->x_max))
return (-1);

if (capabilities[0] & ELANTECH_CAP_TRACKPOINT0x80)
elantech->flags |= ELANTECH_F_TRACKPOINT0x20;

hw->type = WSMOUSE_TYPE_ELANTECH18;
hw->hw_type = (ELANTECH_IS_CLICKPAD(sc)(((sc)->elantech->fw_version & 0x1000) != 0)
   ? WSMOUSEHW_CLICKPAD : WSMOUSEHW_TOUCHPAD);
hw->mt_slots = ELANTECH_MAX_FINGERS5;

elantech->width = hw->x_max / (capabilities[1] - 1);

return (0);
2015}

2017int
2018elantech_ps2_cmd(struct pms_softc *sc, u_char command)
2019{
u_char cmd[1];

cmd[0] = command;
return (pms_cmd(sc, cmd, 1, NULL((void *)0), 0));
2024}

2026int
2027elantech_knock(struct pms_softc *sc)
2028{
u_char resp[3];

if (pms_dev_disable(sc) ||
   pms_set_scaling(sc, 1) ||
   pms_set_scaling(sc, 1) ||
   pms_set_scaling(sc, 1) ||
   pms_get_status(sc, resp) ||
   resp[0] != PMS_ELANTECH_MAGIC10x3c ||
   resp[1] != PMS_ELANTECH_MAGIC20x03 ||
   (resp[2] != PMS_ELANTECH_MAGIC3_10xc8 &&
   resp[2] != PMS_ELANTECH_MAGIC3_20x00))
return (-1);

return (0);
2043}

2045int
2046pms_enable_elantech_v1(struct pms_softc *sc)
2047{
struct elantech_softc *elantech = sc->elantech;
int i;

if (elantech_knock(sc))
1
Taking false branch→
goto err;

if (sc->elantech == NULL((void *)0)) {
2
←
Assuming field 'elantech' is not equal to NULL→
3
←
Taking false branch→
sc->elantech = elantech = malloc(sizeof(struct elantech_softc),
    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (elantech == NULL((void *)0)) {
	printf("%s: elantech: not enough memory\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

if (elantech_get_hwinfo_v1(sc)) {
	free(sc->elantech, M_DEVBUF2,
	    sizeof(struct elantech_softc));
	sc->elantech = NULL((void *)0);
	goto err;
}
if (wsmouse_configure(sc->sc_wsmousedev, NULL((void *)0), 0)) {
	free(sc->elantech, M_DEVBUF2,
	    sizeof(struct elantech_softc));
	sc->elantech = NULL((void *)0);
	printf("%s: elantech: setup failed\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

printf("%s: Elantech Touchpad, version %d, firmware 0x%x\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), 1, sc->elantech->fw_version);
} else if (elantech_set_absolute_mode_v1(sc))
4
←
Calling 'elantech_set_absolute_mode_v1'→
goto err;

for (i = 0; i < nitems(sc->elantech->parity)(sizeof((sc->elantech->parity)) / sizeof((sc->elantech
->parity)[0])); i++)
sc->elantech->parity[i] = sc->elantech->parity[i & (i - 1)] ^ 1;

return (1);

2087err:
pms_reset(sc);

return (0);
2091}

2093int
2094pms_enable_elantech_v2(struct pms_softc *sc)
2095{
struct elantech_softc *elantech = sc->elantech;

if (elantech_knock(sc))
goto err;

if (sc->elantech == NULL((void *)0)) {
sc->elantech = elantech = malloc(sizeof(struct elantech_softc),
    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (elantech == NULL((void *)0)) {
	printf("%s: elantech: not enough memory\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

if (elantech_get_hwinfo_v2(sc)) {
	free(sc->elantech, M_DEVBUF2,
	    sizeof(struct elantech_softc));
	sc->elantech = NULL((void *)0);
	goto err;
}
if (wsmouse_configure(sc->sc_wsmousedev, NULL((void *)0), 0)) {
	free(sc->elantech, M_DEVBUF2,
	    sizeof(struct elantech_softc));
	sc->elantech = NULL((void *)0);
	printf("%s: elantech: setup failed\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

printf("%s: Elantech Touchpad, version %d, firmware 0x%x\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), 2, sc->elantech->fw_version);
} else if (elantech_set_absolute_mode_v2(sc))
goto err;

return (1);

2131err:
pms_reset(sc);

return (0);
2135}

2137int
2138pms_enable_elantech_v3(struct pms_softc *sc)
2139{
struct elantech_softc *elantech = sc->elantech;

if (elantech_knock(sc))
goto err;

if (sc->elantech == NULL((void *)0)) {
sc->elantech = elantech = malloc(sizeof(struct elantech_softc),
    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (elantech == NULL((void *)0)) {
	printf("%s: elantech: not enough memory\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

if (elantech_get_hwinfo_v3(sc)) {
	free(sc->elantech, M_DEVBUF2,
	    sizeof(struct elantech_softc));
	sc->elantech = NULL((void *)0);
	goto err;
}
if (wsmouse_configure(sc->sc_wsmousedev, NULL((void *)0), 0)) {
	free(sc->elantech, M_DEVBUF2,
	    sizeof(struct elantech_softc));
	sc->elantech = NULL((void *)0);
	printf("%s: elantech: setup failed\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

printf("%s: Elantech Touchpad, version %d, firmware 0x%x\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), 3, sc->elantech->fw_version);
} else if (elantech_set_absolute_mode_v3(sc))
goto err;

return (1);

2175err:
pms_reset(sc);

return (0);
2179}

2181int
2182pms_enable_elantech_v4(struct pms_softc *sc)
2183{
struct elantech_softc *elantech = sc->elantech;
struct wsmousedev_attach_args a;

if (elantech_knock(sc))
goto err;

if (sc->elantech == NULL((void *)0)) {
sc->elantech = elantech = malloc(sizeof(struct elantech_softc),
    M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
if (elantech == NULL((void *)0)) {
	printf("%s: elantech: not enough memory\n",
	    DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

if (elantech_get_hwinfo_v4(sc)) {
	free(sc->elantech, M_DEVBUF2,
	    sizeof(struct elantech_softc));
	sc->elantech = NULL((void *)0);
	goto err;
}
if (wsmouse_configure(sc->sc_wsmousedev, NULL((void *)0), 0)) {
	free(sc->elantech, M_DEVBUF2,
	    sizeof(struct elantech_softc));
	sc->elantech = NULL((void *)0);
	printf("%s: elantech: setup failed\n", DEVNAME(sc)((sc)->sc_dev.dv_xname));
	goto err;
}

printf("%s: Elantech %s, version 4, firmware 0x%x\n",
    DEVNAME(sc)((sc)->sc_dev.dv_xname), (ELANTECH_IS_CLICKPAD(sc)(((sc)->elantech->fw_version & 0x1000) != 0) ?  "Clickpad"
    : "Touchpad"), sc->elantech->fw_version);

if (sc->elantech->flags & ELANTECH_F_TRACKPOINT0x20) {
	a.accessops = &pms_sec_accessops;
	a.accesscookie = sc;
	sc->sc_sec_wsmousedev = config_found((void *) sc, &a,config_found_sm(((void *) sc), (&a), (wsmousedevprint), (
(void *)0))
	    wsmousedevprint)config_found_sm(((void *) sc), (&a), (wsmousedevprint), (
(void *)0));
}

} else if (elantech_set_absolute_mode_v4(sc))
goto err;

return (1);

2229err:
pms_reset(sc);

return (0);
2233}

2235int
2236pms_ioctl_elantech(struct pms_softc *sc, u_long cmd, caddr_t data, int flag,
  struct proc *p)
2238{
struct wsmouse_calibcoords *wsmc = (struct wsmouse_calibcoords *)data;
struct wsmousehw *hw;
int wsmode;

switch (cmd) {
case WSMOUSEIO_GTYPE((unsigned long)0x40000000 | ((sizeof(u_int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((32))):
*(u_int *)data = WSMOUSE_TYPE_ELANTECH18;
break;
case WSMOUSEIO_GCALIBCOORDS((unsigned long)0x40000000 | ((sizeof(struct wsmouse_calibcoords
) & 0x1fff) << 16) | ((('W')) << 8) | ((37))):
hw = wsmouse_get_hw(sc->sc_wsmousedev);
wsmc->minx = hw->x_min;
wsmc->maxx = hw->x_max;
wsmc->miny = hw->y_min;
wsmc->maxy = hw->y_max;
wsmc->swapxy = 0;
wsmc->resx = hw->h_res;
wsmc->resy = hw->v_res;
break;
case WSMOUSEIO_SETMODE((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) <<
 16) | ((('W')) << 8) | ((38))):
wsmode = *(u_int *)data;
if (wsmode != WSMOUSE_COMPAT0 && wsmode != WSMOUSE_NATIVE1)
	return (EINVAL22);
wsmouse_set_mode(sc->sc_wsmousedev, wsmode);
break;
default:
return (-1);
}
return (0);
2267}

2269int
2270pms_sync_elantech_v1(struct pms_softc *sc, int data)
2271{
struct elantech_softc *elantech = sc->elantech;
u_char p;

switch (sc->inputstate) {
case 0:
if (elantech->flags & ELANTECH_F_HW_V1_OLD0x08) {
	elantech->p1 = (data & 0x20) >> 5;
	elantech->p2 = (data & 0x10) >> 4;
} else {
	elantech->p1 = (data & 0x10) >> 4;
	elantech->p2 = (data & 0x20) >> 5;
}
elantech->p3 = (data & 0x04) >> 2;
return (0);
case 1:
p = elantech->p1;
break;
case 2:
p = elantech->p2;
break;
case 3:
p = elantech->p3;
break;
default:
return (-1);
}

if (data < 0 || data >= nitems(elantech->parity)(sizeof((elantech->parity)) / sizeof((elantech->parity)
[0])) ||
/*
* FW 0x20022 sends inverted parity bits on cold boot, returning
* to normal after suspend & resume, so the parity check is
* disabled for this one.
*/
   (elantech->fw_version != 0x20022 && elantech->parity[data] != p))
return (-1);

return (0);
2309}

2311int
2312pms_sync_elantech_v2(struct pms_softc *sc, int data)
2313{
struct elantech_softc *elantech = sc->elantech;

/* Variants reporting pressure always have the same constant bits. */
if (elantech->flags & ELANTECH_F_REPORTS_PRESSURE0x01) {
if (sc->inputstate == 0 && (data & 0x0c) != 0x04)
	return (-1);
if (sc->inputstate == 3 && (data & 0x0f) != 0x02)
	return (-1);
return (0);
}

/* For variants not reporting pressure, 1 and 3 finger touch packets
* have different constant bits than 2 finger touch packets. */
switch (sc->inputstate) {
case 0:
if ((data & 0xc0) == 0x80) {
	if ((data & 0x0c) != 0x0c)
		return (-1);
	elantech->flags |= ELANTECH_F_2FINGER_PACKET0x04;
} else {
	if ((data & 0x3c) != 0x3c)
		return (-1);
	elantech->flags &= ~ELANTECH_F_2FINGER_PACKET0x04;
}
break;
case 1:
case 4:
if (elantech->flags & ELANTECH_F_2FINGER_PACKET0x04)
	break;
if ((data & 0xf0) != 0x00)
	return (-1);
break;
case 3:
if (elantech->flags & ELANTECH_F_2FINGER_PACKET0x04) {
	if ((data & 0x0e) != 0x08)
		return (-1);
} else {
	if ((data & 0x3e) != 0x38)
		return (-1);
}
break;
default:
break;
}

return (0);
2360}

2362int
2363pms_sync_elantech_v3(struct pms_softc *sc, int data)
2364{
struct elantech_softc *elantech = sc->elantech;

switch (sc->inputstate) {
case 0:
if (elantech->flags & ELANTECH_F_CRC_ENABLED0x10)
	break;
if ((data & 0x0c) != 0x04 && (data & 0x0c) != 0x0c)
	return (-1);
break;
case 3:
if (elantech->flags & ELANTECH_F_CRC_ENABLED0x10) {
	if ((data & 0x09) != 0x08 && (data & 0x09) != 0x09)
		return (-1);
} else {
	if ((data & 0xcf) != 0x02 && (data & 0xce) != 0x0c)
		return (-1);
}
break;
}

return (0);
2386}

2388/* Extract the type bits from packet[3]. */
2389static inline int
2390elantech_packet_type(struct elantech_softc *elantech, u_char b)
2391{
/*
* This looks dubious, but in the "crc-enabled" format bit 2 may
* be set even in MOTION packets.
*/
if ((elantech->flags & ELANTECH_F_TRACKPOINT0x20) && ((b & 0x0f) == 0x06))
return (ELANTECH_PKT_TRACKPOINT0x06);
else
return (b & 0x03);
2400}

2402int
2403pms_sync_elantech_v4(struct pms_softc *sc, int data)
2404{
if (sc->inputstate == 0)
return ((data & 0x08) == 0 ? 0 : -1);

if (sc->inputstate == 3) {
switch (elantech_packet_type(sc->elantech, data)) {
case ELANTECH_V4_PKT_STATUS0:
case ELANTECH_V4_PKT_HEAD0x01:
case ELANTECH_V4_PKT_MOTION0x02:
	if (sc->elantech->flags & ELANTECH_F_CRC_ENABLED0x10)
		return ((data & 0x08) == 0 ? 0 : -1);
	else
		return ((data & 0x1c) == 0x10 ? 0 : -1);
case ELANTECH_PKT_TRACKPOINT0x06:
	return ((sc->packet[0] & 0xc8) == 0
	    && sc->packet[1] == ((data & 0x10) << 3)
	    && sc->packet[2] == ((data & 0x20) << 2)
	    && (data ^ (sc->packet[0] & 0x30)) == 0x36
	    ? 0 : -1);
}
return (-1);
}
return (0);
2427}

2429void
2430pms_proc_elantech_v1(struct pms_softc *sc)
2431{
struct elantech_softc *elantech = sc->elantech;
int x, y, w, z;
u_int buttons;

buttons = butmap[sc->packet[0] & 3];

if (elantech->flags & ELANTECH_F_HAS_ROCKER0x02) {
if (sc->packet[0] & 0x40) /* up */
	buttons |= WSMOUSE_BUTTON(4)(1 << ((4) - 1));
if (sc->packet[0] & 0x80) /* down */
	buttons |= WSMOUSE_BUTTON(5)(1 << ((5) - 1));
}

if (elantech->flags & ELANTECH_F_HW_V1_OLD0x08)
w = ((sc->packet[1] & 0x80) >> 7) +
    ((sc->packet[1] & 0x30) >> 4);
else
w = (sc->packet[0] & 0xc0) >> 6;

/*
* Firmwares 0x20022 and 0x20600 have a bug, position data in the
* first two reports for single-touch contacts may be corrupt.
*/
if (elantech->fw_version == 0x20022 ||
   elantech->fw_version == 0x20600) {
if (w == 1) {
	if (elantech->initial_pkt < 2) {
		elantech->initial_pkt++;
		return;
	}
} else if (elantech->initial_pkt) {
	elantech->initial_pkt = 0;
}
}

/* Hardware version 1 doesn't report pressure. */
if (w) {
x = ((sc->packet[1] & 0x0c) << 6) | sc->packet[2];
y = ((sc->packet[1] & 0x03) << 8) | sc->packet[3];
z = SYNAPTICS_PRESSURE30;
} else {
x = y = z = 0;
}

WSMOUSE_TOUCH(sc->sc_wsmousedev, buttons, x, y, z, w)do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (x), (y)); wsmouse_touch((sc->sc_wsmousedev
), (z), (w)); wsmouse_input_sync(sc->sc_wsmousedev); } while
 (0);
2477}

2479void
2480pms_proc_elantech_v2(struct pms_softc *sc)
2481{
const u_char debounce_pkt[] = { 0x84, 0xff, 0xff, 0x02, 0xff, 0xff };
struct elantech_softc *elantech = sc->elantech;
int x, y, w, z;
u_int buttons;

/*
* The hardware sends this packet when in debounce state.
* The packet should be ignored.
*/
if (!memcmp(sc->packet, debounce_pkt, sizeof(debounce_pkt))__builtin_memcmp((sc->packet), (debounce_pkt), (sizeof(debounce_pkt
))))
return;

buttons = butmap[sc->packet[0] & 3];

w = (sc->packet[0] & 0xc0) >> 6;
if (w == 1 || w == 3) {
x = ((sc->packet[1] & 0x0f) << 8) | sc->packet[2];
y = ((sc->packet[4] & 0x0f) << 8) | sc->packet[5];
if (elantech->flags & ELANTECH_F_REPORTS_PRESSURE0x01)
	z = ((sc->packet[1] & 0xf0) |
	    (sc->packet[4] & 0xf0) >> 4);
else
	z = SYNAPTICS_PRESSURE30;
} else if (w == 2) {
x = (((sc->packet[0] & 0x10) << 4) | sc->packet[1]) << 2;
y = (((sc->packet[0] & 0x20) << 3) | sc->packet[2]) << 2;
z = SYNAPTICS_PRESSURE30;
} else {
x = y = z = 0;
}

WSMOUSE_TOUCH(sc->sc_wsmousedev, buttons, x, y, z, w)do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (x), (y)); wsmouse_touch((sc->sc_wsmousedev
), (z), (w)); wsmouse_input_sync(sc->sc_wsmousedev); } while
 (0);
2514}

2516void
2517pms_proc_elantech_v3(struct pms_softc *sc)
2518{
const u_char debounce_pkt[] = { 0xc4, 0xff, 0xff, 0x02, 0xff, 0xff };
struct elantech_softc *elantech = sc->elantech;
int x, y, w, z;
u_int buttons;

buttons = butmap[sc->packet[0] & 3];

x = ((sc->packet[1] & 0x0f) << 8 | sc->packet[2]);
y = ((sc->packet[4] & 0x0f) << 8 | sc->packet[5]);
z = 0;
w = (sc->packet[0] & 0xc0) >> 6;
if (w == 2) {
/*
 * Two-finger touch causes two packets -- a head packet
 * and a tail packet. We report a single event and ignore
 * the tail packet.
 */
if (elantech->flags & ELANTECH_F_CRC_ENABLED0x10) {
	if ((sc->packet[3] & 0x09) != 0x08)
		return;
} else {
	/* The hardware sends this packet when in debounce state.
		 * The packet should be ignored. */
	if (!memcmp(sc->packet, debounce_pkt, sizeof(debounce_pkt))__builtin_memcmp((sc->packet), (debounce_pkt), (sizeof(debounce_pkt
))))
		return;
	if ((sc->packet[0] & 0x0c) != 0x04 &&
   		(sc->packet[3] & 0xcf) != 0x02) {
		/* not the head packet -- ignore */
		return;
	}
}
}

/* Prevent jumping cursor if pad isn't touched or reports garbage. */
if (w == 0 ||
   ((x == 0 || y == 0 || x == elantech->max_x || y == elantech->max_y)
   && (x != elantech->old_x || y != elantech->old_y))) {
x = elantech->old_x;
y = elantech->old_y;
}

if (elantech->flags & ELANTECH_F_REPORTS_PRESSURE0x01)
z = (sc->packet[1] & 0xf0) | ((sc->packet[4] & 0xf0) >> 4);
else if (w)
z = SYNAPTICS_PRESSURE30;

WSMOUSE_TOUCH(sc->sc_wsmousedev, buttons, x, y, z, w)do { wsmouse_buttons((sc->sc_wsmousedev), (buttons)); wsmouse_position
((sc->sc_wsmousedev), (x), (y)); wsmouse_touch((sc->sc_wsmousedev
), (z), (w)); wsmouse_input_sync(sc->sc_wsmousedev); } while
 (0);
elantech->old_x = x;
elantech->old_y = y;
2568}

2570void
2571pms_proc_elantech_v4(struct pms_softc *sc)
2572{
struct elantech_softc *elantech = sc->elantech;
struct device *sc_wsmousedev = sc->sc_wsmousedev;
int id, weight, n, x, y, z;
u_int buttons, slots;

switch (elantech_packet_type(elantech, sc->packet[3])) {
case ELANTECH_V4_PKT_STATUS0:
slots = elantech->mt_slots;
elantech->mt_slots = sc->packet[1] & 0x1f;
slots &= ~elantech->mt_slots;
for (id = 0; slots; id++, slots >>= 1) {
	if (slots & 1)
		wsmouse_mtstate(sc_wsmousedev, id, 0, 0, 0);
}
break;

case ELANTECH_V4_PKT_HEAD0x01:
id = ((sc->packet[3] & 0xe0) >> 5) - 1;
if (id > -1 && id < ELANTECH_MAX_FINGERS5) {
	x = ((sc->packet[1] & 0x0f) << 8) | sc->packet[2];
	y = ((sc->packet[4] & 0x0f) << 8) | sc->packet[5];
	z = (sc->packet[1] & 0xf0)
	    | ((sc->packet[4] & 0xf0) >> 4);
	wsmouse_mtstate(sc_wsmousedev, id, x, y, z);
}
break;

case ELANTECH_V4_PKT_MOTION0x02:
weight = (sc->packet[0] & 0x10) ? ELANTECH_V4_WEIGHT_VALUE5 : 1;
for (n = 0; n < 6; n += 3) {
	id = ((sc->packet[n] & 0xe0) >> 5) - 1;
	if (id < 0 || id >= ELANTECH_MAX_FINGERS5)
		continue;
	x = weight * (signed char)sc->packet[n + 1];
	y = weight * (signed char)sc->packet[n + 2];
	z = WSMOUSE_DEFAULT_PRESSURE45;
	wsmouse_set(sc_wsmousedev, WSMOUSE_MT_REL_X, x, id);
	wsmouse_set(sc_wsmousedev, WSMOUSE_MT_REL_Y, y, id);
	wsmouse_set(sc_wsmousedev, WSMOUSE_MT_PRESSURE, z, id);
}
break;

case ELANTECH_PKT_TRACKPOINT0x06:
if (sc->sc_dev_enable & PMS_DEV_SECONDARY0x02) {
	/*
	* This firmware misreport coordinates for trackpoint
	* occasionally. Discard packets outside of [-127, 127] range
	* to prevent cursor jumps.
	*/
	if (sc->packet[4] == 0x80 || sc->packet[5] == 0x80 ||
	    sc->packet[1] >> 7 == sc->packet[4] >> 7 ||
	    sc->packet[2] >> 7 == sc->packet[5] >> 7)
		return;

	x = sc->packet[4] - 0x100 + (sc->packet[1] << 1);
	y = sc->packet[5] - 0x100 + (sc->packet[2] << 1);
	buttons = butmap[sc->packet[0] & 7];
	WSMOUSE_INPUT(sc->sc_sec_wsmousedev,do { wsmouse_buttons((sc->sc_sec_wsmousedev), (buttons)); wsmouse_motion
((sc->sc_sec_wsmousedev), (x), (y), (0), (0)); wsmouse_input_sync
(sc->sc_sec_wsmousedev); } while (0)
	    buttons, x, y, 0, 0)do { wsmouse_buttons((sc->sc_sec_wsmousedev), (buttons)); wsmouse_motion
((sc->sc_sec_wsmousedev), (x), (y), (0), (0)); wsmouse_input_sync
(sc->sc_sec_wsmousedev); } while (0);
}
return;

default:
printf("%s: unknown packet type 0x%x\n", DEVNAME(sc)((sc)->sc_dev.dv_xname),
    sc->packet[3] & 0x1f);
return;
}

buttons = butmap[sc->packet[0] & 3];
wsmouse_buttons(sc_wsmousedev, buttons);

wsmouse_input_sync(sc_wsmousedev);
2645}