/*
 * Copyright 2013-2025, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Hardware specs taken from the linux and BSDs drivers, thanks a lot!
 *
 * References:
 *      - https://cgit.freebsd.org/src/tree/sys/dev/atkbdc/psm.c?h=releng/14.3
 *      - https://cvsweb.openbsd.org/cgi-bin/cvsweb/src/sys/dev/pckbc/?only_with_tag=OPENBSD_7_8_BASE
 *      - https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/drivers/input/mouse/elantech.c?h=v6.17
 *      - https://www.kernel.org/doc/html/v4.16/input/devices/elantech.html
 *
 * Authors:
 *              Jérôme Duval <korli@users.berlios.de>
 *              Samuel Rodríguez Pérez <samuelrp84@gmail.com>
 */


#include "ps2_elantech.h"

#include <stdlib.h>
#include <string.h>

#include <keyboard_mouse_driver.h>

#include <util/BitUtils.h>

#include "ps2_service.h"


//#define TRACE_PS2_ELANTECH
#ifdef TRACE_PS2_ELANTECH
#       define TRACE(x...) dprintf(x)
#else
#       define TRACE(x...)
#endif

const char* kElantechPath[4] = {
        "input/touchpad/ps2/elantech_0",
        "input/touchpad/ps2/elantech_1",
        "input/touchpad/ps2/elantech_2",
        "input/touchpad/ps2/elantech_3"
};


#define ELANTECH_CMD_GET_ID                             0x00
#define ELANTECH_CMD_GET_VERSION                0x01
#define ELANTECH_CMD_GET_CAPABILITIES   0x02
#define ELANTECH_CMD_GET_SAMPLE                 0x03
#define ELANTECH_CMD_GET_RESOLUTION             0x04
#define ELANTECH_CMD_GET_ICBODY                 0x05


#define ELANTECH_CMD_REGISTER_READ              0x10
#define ELANTECH_CMD_REGISTER_WRITE             0x11
#define ELANTECH_CMD_REGISTER_READWRITE 0x00
#define ELANTECH_CMD_PS2_CUSTOM_CMD             0xf8

// touchpad proportions
#define EDGE_MOTION_WIDTH       55

#define MIN_PRESSURE            0
#define REAL_MAX_PRESSURE       50
#define MAX_PRESSURE            255

#define DEFAULT_PRESSURE                30
#define DEFAULT_FINGER_WIDTH    4

#define ELANTECH_HISTORY_SIZE   256

#define STATUS_PACKET   0x0
#define HEAD_PACKET             0x1
#define MOTION_PACKET   0x2

#define ELANTECH_XMIN_V2        0
#define ELANTECH_XMAX_V2        1152
#define ELANTECH_YMIN_V2        0
#define ELANTECH_YMAX_V2        768

#define ELANTECH_MAX_FINGERS    5

#define ELANTECH_CAP_HAS_ROCKER                 4
#define ELANTECH_CAP_TRACKPOINT                 0x80

// Error code used by MouseDevice::_ControlThread() in MouseInputDevice.cpp to reuse previous
// event, basically ignoring the packet.
#define IGNORE_EVENT B_BAD_DATA

static touchpad_specs gHardwareSpecs;


static status_t
elantech_process_packet_v1(elantech_cookie *cookie, touchpad_movement *_event,
        uint8 packet[PS2_PACKET_ELANTECH]);
static status_t
elantech_process_packet_v2(elantech_cookie *cookie, touchpad_movement *_event,
        uint8 packet[PS2_PACKET_ELANTECH]);
static status_t
elantech_process_packet_v3(elantech_cookie *cookie, touchpad_movement *_event,
        uint8 packet[PS2_PACKET_ELANTECH]);
static status_t
elantech_process_packet_v4(elantech_cookie *cookie, touchpad_movement *_event,
        uint8 packet[PS2_PACKET_ELANTECH]);
static status_t
elantech_process_packet_trackpoint(elantech_cookie *cookie, mouse_movement *_movement,
        uint8 packet[PS2_PACKET_ELANTECH]);


static inline void
finger_width_hack(touchpad_movement *event)
{
        // TODO: Improve fingerWidth computation by removing hack and updating other drivers.
        // FingerWidth values as per Synaptic driver "Finger width value".
        // This is currently used that way by movement_maker.cpp so keep this hack as of now.
        // Comments from FreeBSD psm.c driver for Synaptic protocol below:
        /*
         * Pressure value.
         * Interpretation:
         *   z = 0      No finger contact
         *   z = 10     Finger hovering near the pad
         *   z = 30     Very light finger contact
         *   z = 80     Normal finger contact
         *   z = 110    Very heavy finger contact
         *   z = 200    Finger lying flat on pad surface
         *   z = 255    Maximum reportable Z
         */
        /*
         * Finger width value
         * Interpretation:
         *   w = 0      Two finger on the pad (capMultiFinger needed)
         *   w = 1      Three or more fingers (capMultiFinger needed)
         *   w = 2      Pen (instead of finger) (capPen needed)
         *   w = 3      Reserved (passthrough?)
         *   w = 4-7    Finger of normal width (capPalmDetect needed)
         *   w = 8-14   Very wide finger or palm (capPalmDetect needed)
         *   w = 15     Maximum reportable width (capPalmDetect needed)
         */
        if (event->fingerWidth < 4)
                event->fingerWidth = 4;
        if (count_set_bits(event->fingers) == 2)
                event->fingerWidth = 0;
        else if (count_set_bits(event->fingers) > 2)
                event->fingerWidth = 1;
}


/* Common legend
 * L: Left mouse button pressed
 * R: Right mouse button pressed
 * N: number of fingers on touchpad
 * X: absolute x value (horizontal)
 * Y: absolute y value (vertical)
 * W; width of the finger touch
 * P: pressure
 */
static status_t
get_elantech_movement(elantech_cookie *cookie, touchpad_read *_read)
{
        touchpad_movement event = {};
        mouse_movement movement {};
        uint8 packet[PS2_PACKET_ELANTECH];

        status_t status = acquire_sem_etc(cookie->sem, 1, B_CAN_INTERRUPT | B_RELATIVE_TIMEOUT,
                _read->timeout);
        if (status < B_OK) {
                TRACE("ELANTECH: acquire_sem_etc err or timeout.\n");
                return status;
        }

        if (!cookie->dev->active) {
                TRACE("ELANTECH: read_event: Error device no longer active\n");
                return B_ERROR;
        }

        if (packet_buffer_read(cookie->ring_buffer, packet,
                        cookie->dev->packet_size) != cookie->dev->packet_size) {
                TRACE("ELANTECH: error copying buffer\n");
                return B_ERROR;
        }

        if ((cookie->capabilities[0] & 0x80) != 0 && (packet[3] & 0x0f) == 0x06) {
                status = elantech_process_packet_trackpoint(cookie, &movement, packet);
                if (status == B_OK) {
                        _read->event = MS_READ;
                        _read->u.mouse = movement;
                }
        } else {
                switch (cookie->version) {
                        case 1:
                                status = elantech_process_packet_v1(cookie, &event, packet);
                                break;
                        case 2:
                                status = elantech_process_packet_v2(cookie, &event, packet);
                                break;
                        case 3:
                                status = elantech_process_packet_v3(cookie, &event, packet);
                                break;
                        case 4:
                                status = elantech_process_packet_v4(cookie, &event, packet);
                                break;
                        default:
                                TRACE("ELANTECH: Unknown version %d.\n", cookie->version);
                                return B_ERROR;
                }
                if (status == B_OK) {
                        _read->event = MS_READ_TOUCHPAD;
                        // TODO: remove this hack
                        finger_width_hack(&event);
                        _read->u.touchpad = event;
                }
        }
        return status;
}


static status_t
elantech_process_packet_v1(elantech_cookie *cookie, touchpad_movement *_event,
        uint8 packet[PS2_PACKET_ELANTECH_V1])
{
        /* HW V1. FW V1.x .*/
        /*               7   6   5   4   3   2   1   0 (LSB)
         * -------------------------------------------
         * ipacket[0]:  RD  RU  p1  p2   1  p3   R   L
         * ipacket[1]:   f   0  3f  2f  X9  X8  X9  X8
         * ipacket[2]:  X7  X6  X5  X4  X3  X2  X1  X0
         * ipacket[3]:  Y7  Y6  Y5  Y4  Y3  Y2  Y1  Y0
         * -------------------------------------------
         * RD: Rocker switch pressed Down.
         * RU: Rocker switch pressed Up.
         * pn: Odd parity bit for byte n.
         * f: 1 when finger touch.
         * 2f: 1 when 2 finger touch.
         * 3f: 1 when 3 finger touch.
         */

        /* HW V1. FW V2.x .*/
        /*               7   6   5   4   3   2   1   0 (LSB)
         * -------------------------------------------
         * ipacket[0]:  N1  N0  p2  p1   1  p3   R   L
         * ipacket[1]:   .   .   .   .  X9  X8  X9  X8
         * ipacket[2]:  X7  X6  X5  X4  X3  X2  X1  X0
         * ipacket[3]:  Y7  Y6  Y5  Y4  Y3  Y2  Y1  Y0
         * -------------------------------------------
         * pn: Odd parity bit for byte n.
         */

        const bool kOddParityMap[256] = {
                0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
                1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
                1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
                0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
                1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
                0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
                1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
                1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
                0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0
        };

        uint8 p1, p2, p3;
        if (cookie->fwVersion < 0x020000) {
                p1 = (packet[0] & 0x20) >> 5;
                p2 = (packet[0] & 0x10) >> 4;
        } else {
                p1 = (packet[0] & 0x10) >> 4;
                p2 = (packet[0] & 0x20) >> 5;
        }
        p3 = (packet[0] & 0x04) >> 2;
        if (kOddParityMap[packet[1]] != p1
                || kOddParityMap[packet[2]] != p2
                || kOddParityMap[packet[3]] != p3)
                return IGNORE_EVENT;

        uint32 x, y;
        uint8 n, z;
        uint8 buttons;

        buttons = packet[0] & 3;

        if (cookie->capabilities[0] & ELANTECH_CAP_HAS_ROCKER) {
                if (packet[0] & 0x40) /* up */
                        buttons |= 1 << 4;
                if (packet[0] & 0x80) /* down */
                        buttons |= 1 << 5;
        }

        if (cookie->fwVersion < 0x20000 || cookie->fwVersion == 0x20600)
                n = ((packet[1] & 0x80) >> 7) + ((packet[1] & 0x30) >> 4);
        else
                n = (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 (cookie->fwVersion == 0x20022 || cookie->fwVersion == 0x20600) {
                if (n == 1) {
                        if (cookie->quirkInitialPacketForV1 < 2) {
                                cookie->quirkInitialPacketForV1++;
                                return IGNORE_EVENT;
                        }
                } else if (cookie->quirkInitialPacketForV1) {
                        cookie->quirkInitialPacketForV1 = 0;
                }
        }

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

        touchpad_movement event = {
                .buttons = buttons,
                .xPosition = x,
                .yPosition = y,
                .zPressure = z,
                //.nFingers = n,
                .fingers = (uint8)((1 << n) - 1),
                .fingerWidth = DEFAULT_FINGER_WIDTH,
        };

        *_event = event;

        return B_OK;
}

static status_t
elantech_process_packet_v2(elantech_cookie *cookie, touchpad_movement *_event,
        uint8 packet[PS2_PACKET_ELANTECH])
{
        const uint8 debounce_pkt[] = { 0x84, 0xff, 0xff, 0x02, 0xff, 0xff };
        uint32 x, y;
        uint8 n, w, z;
        uint8 buttons;

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

        // Constant bit checks based on FreeBSD psm.c and Linux drivers.
        bool valid = false;
        if (cookie->fwVersion >= 0x020800)
                if ((packet[0] & 0x0c) == 0x04 && (packet[3] & 0x0f) == 0x02)
                        valid = true;

        if (!valid && ((packet[0] & 0xc0) == 0x80))
                if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0x0e) == 0x08)
                        valid = true;

        if (!valid && ((packet[0] & 0x3c) == 0x3c && (packet[1] & 0xf0) == 0x00
                && (packet[3] & 0x3e) == 0x38 && (packet[4] & 0xf0) == 0x00))
                valid = true;

        if (!valid)
                return IGNORE_EVENT;

        buttons = packet[0] & 3;

        n = (packet[0] & 0xc0) >> 6;
        if (n == 1 || n == 3) {
                /* HW V2. One/Three finger touch */
                /*               7   6   5   4   3   2   1   0 (LSB)
                 * -------------------------------------------
                 * ipacket[0]:  N1  N0  W3  W2   .   .   R   L
                 * ipacket[1]:  P7  P6  P5  P4 X11 X10  X9  X8
                 * ipacket[2]:  X7  X6  X5  X4  X3  X2  X1  X0
                 * ipacket[3]:  N4  VF  W1  W0   .   .   .  B2
                 * ipacket[4]:  P3  P1  P2  P0 Y11 Y10  Y9  Y8
                 * ipacket[5]:  Y7  Y6  Y5  Y4  Y3  Y2  Y1  Y0
                 * -------------------------------------------
                 * N4: set if more than 3 fingers (only in 3 fingers mode)
                 * VF: a kind of flag? (only on EF123, 0 when finger
                 *     is over one of the buttons, 1 otherwise)
                 * B2: (on EF113 only, 0 otherwise), one button pressed
                 * P & W is not reported on EF113 touchpads
                 */

                if (n == 3 && (packet[3] & 0x80))
                        n = 4;

#if ELANTECH_EF113_MORE_THAN_TWO_BUTTONS
                // According to Linux and BSDs documentation, EF113 does not support multiple buttons
                // to be clicked at the same time but it's unclear to me that this is the case for left,
                // right and middle button as the implementation of their drivers differs here.
                //
                // For whatever reason neither Linux or any of the BSDs implement the documented
                // logic perhaps to be consistent with "HW V2. Two finger touch" packet handling
                // which only has 2 bits to provide button information.
                // So those drivers implementations threats L and R flags as independent left and right
                // buttons that can be pressed at the same time. That clashes with middle button mapping.
                if (cookie->fwVersion == 0x20800) {
                        const int8 buttonsMap[] {
                                0x00,   // 0 = none
                                0x01,   // 1 = Left
                                0x02,   // 2 = Right
#if ELANTECH_EF113_MIDDLE_BUTTON_IS_LEFT_AND_RIGTH
                                0x04,   // 3 = Middle or (Left and Right)
                                                // - Reports middle button
                                                // - Unable to report left and right buttons pressed at the same time
#else
                                0x03,   // 3 = Middle or (Left and Right)
                                                // - Reports left and right buttons pressed at the same time
                                                // - No middle button supported
#endif
                                0x08,   // 4 = Forward
                                0x10,   // 5 = Back
                                0x20,   // 6 = Another one
                                0x40,   // 7 = Another one
                        };
                        buttons = buttonsMap[((packet[3] & 1) << 3 ) + (packet[0] & 3)];
                }
#endif
                x = ((packet[1] & 0x0f) << 8) | packet[2];
                y = ((packet[4] & 0x0f) << 8) | packet[5];
                if (cookie->fwVersion >= 0x20800) {
                        z = ((packet[1] & 0xf0) | (packet[4] & 0xf0) >> 4);
                        w = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
                } else {
                        z = DEFAULT_PRESSURE;
                        w = DEFAULT_FINGER_WIDTH;
                }
        } else if (n == 2) {
                /* HW V2. Two finger touch */
                /*               7   6   5   4   3   2   1   0 (LSB)
                 * -------------------------------------------
                 * ipacket[0]:  N1  N0 AY8 AX8   .   .   R   L
                 * ipacket[1]: AX7 AX6 AX5 AX4 AX3 AX2 AX1 AX0
                 * ipacket[2]: AY7 AY6 AY5 AY4 AY3 AY2 AY1 AY0
                 * ipacket[3]:   .   . BY8 BX8   .   .   .   .
                 * ipacket[4]: BX7 BX6 BX5 BX4 BX3 BX2 BX1 BX0
                 * ipacket[5]: BY7 BY6 BY5 BY4 BY3 BY2 BY1 BY0
                 * -------------------------------------------
                 * AX: lower-left finger absolute x value
                 * AY: lower-left finger absolute y value
                 * BX: upper-right finger absolute x value
                 * BY: upper-right finger absolute y value
                 */
#if ELANTECH_EF113_MORE_THAN_TWO_BUTTONS && ELANTECH_EF113_MIDDLE_BUTTON_IS_LEFT_AND_RIGTH
                if ((buttons & 3) == 3)
                        buttons = 4;
#endif
                x = (((packet[0] & 0x10) << 4) | packet[1]) << 2;
                y = (((packet[0] & 0x20) << 3) | packet[2]) << 2;
                z = DEFAULT_PRESSURE;
                w = DEFAULT_FINGER_WIDTH;
        } else {
                x = y = z = 0;
                w = DEFAULT_FINGER_WIDTH;
        }

        touchpad_movement event = {
                .buttons = buttons,
                .xPosition = x,
                .yPosition = y,
                .zPressure = z,
                //.nFingers = n,
                .fingers = (uint8)((1 << n) - 1),
                .fingerWidth = w,
        };

        *_event = event;

        return B_OK;
}

static status_t
elantech_process_packet_v3(elantech_cookie *cookie, touchpad_movement *_event,
        uint8 packet[PS2_PACKET_ELANTECH])
{
        /*               7   6   5   4   3   2   1   0 (LSB)
         * -------------------------------------------
         * ipacket[0]:  N1  N0  W3  W2   0   1   R   L
         * ipacket[1]:  P7  P6  P5  P4 X11 X10  X9  X8
         * ipacket[2]:  X7  X6  X5  X4  X3  X2  X1  X0
         * ipacket[3]:   0   0  W1  W0   0   0   1   0
         * ipacket[4]:  P3  P1  P2  P0 Y11 Y10  Y9  Y8
         * ipacket[5]:  Y7  Y6  Y5  Y4  Y3  Y2  Y1  Y0
         * -------------------------------------------
         */

        // Validation based on FreeBSD psm.c driver.
        bool valid;
        valid = false;
        if (cookie->crcEnabled) {
                if ((packet[3] & 0x09) == 0x08 || (packet[3] & 0xcf) == 0x02)
                        valid = true;
        } else if (((packet[0] & 0x0c) == 0x04 && (packet[3] & 0xcf) == 0x02)
                                || ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c))
                valid = true;

        if (!valid)
                return IGNORE_EVENT;

        const uint8 debounce_pkt[] = { 0xc4, 0xff, 0xff, 0x02, 0xff, 0xff };
        uint32 x, y;
        uint8 n, w, z;
        uint8 buttons;

        buttons = packet[0] & 3;

        x = ((packet[1] & 0x0f) << 8 | packet[2]);
        y = ((packet[4] & 0x0f) << 8 | packet[5]);
        z = 0;
        n = (packet[0] & 0xc0) >> 6;
        if (n == 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 (cookie->crcEnabled) {
                        if ((packet[3] & 0x09) != 0x08)
                                return IGNORE_EVENT;
                } else {
                        /* The hardware sends this packet when in debounce state.
                         * The packet should be ignored. */
                        if (!memcmp(packet, debounce_pkt, sizeof(debounce_pkt)))
                                return IGNORE_EVENT;
                        if ((packet[0] & 0x0c) != 0x04 &&
                                (packet[3] & 0xcf) != 0x02) {
                                /* not the head packet -- ignore */
                                return IGNORE_EVENT;
                        }
                }
        }

        /* Prevent jumping cursor if pad isn't touched or reports garbage. */
        if (n == 0 ||
                ((x == 0 || y == 0 || x == gHardwareSpecs.areaEndX || y == gHardwareSpecs.areaEndY)
                && (x != cookie->x || y != cookie->y))) {
                x = cookie->x;
                y = cookie->y;
        }

        if (cookie->fwVersion >= 0x020800)
                z = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
        else if (n)
                z = DEFAULT_PRESSURE;

        w = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);

        cookie->x = x;
        cookie->y = y;

        touchpad_movement event = {
                .buttons = buttons,
                .xPosition = x,
                .yPosition = y,
                .zPressure = z,
                //.nFingers = n,
                .fingers = (uint8)((1 << n) - 1),
                .fingerWidth = w,
        };

        *_event = event;

        return B_OK;
}


static status_t
elantech_process_packet_v4(elantech_cookie *cookie, touchpad_movement *_event,
        uint8 packet[PS2_PACKET_ELANTECH])
{
        touchpad_movement event = {};

        int invalidAt = 0;

        if (cookie->crcEnabled) {
                if ((packet[3] & 0x08) != 0x00)
                        invalidAt = 1;
        } else if (cookie->icVersion == 7 && cookie->samples[1] == 0x2A) {
                if ((packet[3] & 0x1c) != 0x10)
                        invalidAt = 2;
        } else {
                if (!((packet[0] & 0x08) == 0x00 && (packet[3] & 0x1c) == 0x10))
                        invalidAt = 3;
        }

        if (invalidAt != 0) {
                TRACE("ELANTECH: Failed v4 sanity check at %d.\n", invalidAt);
                return IGNORE_EVENT;
        }

        uint8 packet_type = packet[3] & 3;
        TRACE("ELANTECH: packet type %d\n", packet_type);
        TRACE("ELANTECH: packet content 0x%02x%02x%02x%02x%02x%02x\n",
                packet[0], packet[1], packet[2], packet[3],
                packet[4], packet[5]);
        switch (packet_type) {
                case STATUS_PACKET:
                        /*               7   6   5   4   3   2   1   0 (LSB)
                         * -------------------------------------------
                         * ipacket[0]:   .   .   .   .   0   1   R   L
                         * ipacket[1]:   .   .   .  F4  F3  F2  F1  F0
                         * ipacket[2]:   .   .   .   .   .   .   .   .
                         * ipacket[3]:   .   .   .   1   0   0   0   0
                         * ipacket[4]:  PL   .   .   .   .   .   .   .
                         * ipacket[5]:   .   .   .   .   .   .   .   .
                         * -------------------------------------------
                         * Fn: finger n is on touchpad
                         * PL: palm
                         * HV ver4 sends a status packet to indicate that the numbers
                         * or identities of the fingers has been changed
                         */
                        event.buttons = (packet[0] & 0x3);

#ifdef ELANTECH_ENABLE_HARDWARE_PALM_DETECTION
                        cookie->palm = (packet[4] & 0x80) != 0;
                        if (cookie->palm) {
                                TRACE("ELANTECH: Hardware palm detected (HEAD)\n");
                                return IGNORE_EVENT;
                        }
#endif

                        // Event fingers contains a bitmap of fingers.
                        event.fingers = packet[1] & 0x1f;
                        TRACE("ELANTECH: Fingers bitmap %" B_PRId32 ", raw %x (STATUS)\n",
                                event.fingers, packet[1]);

                        // This is required for the mouse to not disapear after first iteration.
                        event.xPosition = 0;
                        event.yPosition = 0;

                        // Pressure is not provided on this packet, so make it up with sensible values
                        if (event.fingers == 0)
                                event.zPressure = 0;
                        else
                                event.zPressure = DEFAULT_PRESSURE;

                        TRACE("ELANTECH: Pos: %" B_PRId32 ":%" B_PRId32 " (STATUS)\n",
                                cookie->x, cookie->y);

                        break;
                case HEAD_PACKET:
                        /*               7   6   5   4   3   2   1   0 (LSB)
                         * -------------------------------------------
                         * ipacket[0]:  W3  W2  W1  W0   0   1   R   L
                         * ipacket[1]:  P7  P6  P5  P4 X11 X10  X9  X8
                         * ipacket[2]:  X7  X6  X5  X4  X3  X2  X1  X0
                         * ipacket[3]: ID2 ID1 ID0   1   0   0   0   1
                         * ipacket[4]:  P3  P1  P2  P0 Y11 Y10  Y9  Y8
                         * ipacket[5]:  Y7  Y6  Y5  Y4  Y3  Y2  Y1  Y0
                         * -------------------------------------------
                         * ID: finger id
                         * HW ver 4 sends head packets in two cases:
                         * 1. One finger touch and movement.
                         * 2. Next after status packet to tell new finger positions.
                         */
                        event.buttons = (packet[0] & 0x3);

                        TRACE("ELANTECH: Finger id %d, raw %x (HEAD)\n", (packet[3] & 0xe0) >>5, packet[3]);
                        int id;
                        id = ((packet[3] & 0xe0) >> 5) - 1;
                        if (id < 0 || id >= ELANTECH_MAX_FINGERS) {
                                TRACE("ELANTECH: Not right fingers (HEAD)");
                                return IGNORE_EVENT;
                        }

#ifdef ELANTECH_ENABLE_HARDWARE_PALM_DETECTION
                        if (cookie->palm) {
                                TRACE("ELANTECH: Hardware palm detected (HEAD)\n");
                                return IGNORE_EVENT;
                        }
#endif

                        // Head packet processes 1 finger only. Question is if the id is different than
                        // the one provided by STATUS packet, is this a new finger or a replacement of
                        // the previous ones?
                        // As per testing let's assume a new finger is added.
                        // That's in sync with the logic on BSDs and Linux drivers providing MT events.
                        //event.fingers = cookie->fingers;
                        event.fingers = cookie->fingers | (1 << id);
                        //event.fingers = (1 << id);

                        // only process first finger
                        if (id != 0) {
                                TRACE("ELANTECH: RET Only process first finger. (HEAD)\n");
                                return IGNORE_EVENT;
                        }

                        event.zPressure = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);

                        cookie->previousZ = event.zPressure;

                        event.xPosition = ((packet[1] & 0xf) << 8) | packet[2];
                        event.yPosition = ((packet[4] & 0xf) << 8) | packet[5];

                        TRACE("ELANTECH: dx: %d dy: %d (HEAD)\n",
                                (int)event.xPosition - (int)cookie->x,
                                (int)event.yPosition - (int)cookie->y);

                        cookie->x = event.xPosition;
                        cookie->y = event.yPosition;
                        TRACE("ELANTECH: Pos: %" B_PRId32 ":%" B_PRId32 " (HEAD)\n",
                                cookie->x, cookie->y);
                        TRACE("ELANTECH: buttons 0x%x x %" B_PRIu32 " y %" B_PRIu32
                                " z %d (HEAD)\n", event.buttons, event.xPosition, event.yPosition,
                                event.zPressure);
                        break;
                case MOTION_PACKET:
                        /*               7   6   5   4   3   2   1   0 (LSB)
                         * -------------------------------------------
                         * ipacket[0]: ID2 ID1 ID0  OF   0   1   R   L
                         * ipacket[1]: DX7 DX6 DX5 DX4 DX3 DX2 DX1 DX0
                         * ipacket[2]: DY7 DY6 DY5 DY4 DY3 DY2 DY1 DY0
                         * ipacket[3]: ID2 ID1 ID0   1   0   0   1   0
                         * ipacket[4]: DX7 DX6 DX5 DX4 DX3 DX2 DX1 DX0
                         * ipacket[5]: DY7 DY6 DY5 DY4 DY3 DY2 DY1 DY0
                         * -------------------------------------------
                         * OF: delta overflows (> 127 or < -128), in this case
                         *     firmware sends us (delta x / 5) and (delta y / 5)
                         * ID: finger id
                         * DX: delta x (two's complement)
                         * XY: delta y (two's complement)
                         * byte 0 ~ 2 for one finger
                         * byte 3 ~ 5 for another finger
                         */

                        event.buttons = (packet[0] & 0x3);

                        // Pressure is not provided on this packet, so make it up with sensible values
                        event.zPressure = DEFAULT_PRESSURE;

                        TRACE("ELANTECH: Finger %d, raw %x (MOTION id)\n", (packet[0] & 0xe0) >>5, packet[0]);
                        TRACE("ELANTECH: Finger %d, raw %x (MOTION sid)\n", (packet[3] & 0xe0) >>5, packet[3]);

                        id = ((packet[0] & 0xe0) >> 5) - 1;
                        int sid;
                        sid = ((packet[3] & 0xe0) >> 5) - 1;

                        // Motion packet processes 2 fingers only. Question is if the id is different than
                        // the one provided by STATUS packet, are the fingers of these packet new fingers
                        // or a replacement of the previous ones?
                        // As per testing let's assume a new fingers are added.
                        // That's in sync with the logic BSDs and Linux drivers providing MT events.
                        //event.fingers = cookie->fingers;
                        event.fingers = cookie->fingers | (1 << id) | (1 << sid);
                        //event.fingers = (1 << id) | (1 << sid);

                        if ((id < 0 || id >= ELANTECH_MAX_FINGERS)
                                && (sid < 0 || sid >= ELANTECH_MAX_FINGERS)) {
                                TRACE("ELANTECH: Not right fingers (MOTION)");
                                return IGNORE_EVENT;
                        }

#ifdef ELANTECH_ENABLE_HARDWARE_PALM_DETECTION
                        if (cookie->palm) {
                                TRACE("ELANTECH: Hardware palm detected (MOTION)\n");
                                return IGNORE_EVENT;
                        }
#endif

                        int deltaX;
                        int deltaY;

                        deltaX = 0;
                        deltaY = 0;

                        int weight;
                        weight = (packet[0] & 0x10) ? 5 : 1;

                        // Only take care for finger id 0 for now.
                        // TODO: Change this when support for Multi-finger is available on Haiku
                        if (id == 0 || sid ==0) {
                                if (id < 0 || id >= ELANTECH_MAX_FINGERS)
                                        event.fingers |= 1 << id;
                                if (sid < 0 || sid >= ELANTECH_MAX_FINGERS)
                                        event.fingers |= 1 << sid;

                                if (id == 0) {
                                        deltaX += weight * (int8)packet[1];
                                        deltaY += weight * (int8)packet[2];
                                } else if (sid == 0) {
                                        deltaX += weight * (int8)packet[4];
                                        deltaY += weight * (int8)packet[5];
                                }

                                TRACE("ELANTECH: dx: %d dy: %d (MOTION)\n", deltaX, deltaY);
                        } else {
                                TRACE("ELANTECH: Ignore invalid or non 0 finger ids (MOTION)\n");
                                return IGNORE_EVENT;
                        }

                        // TODO: Avoid this conversion from rel to abs coordinates when Haiku supports both
                        // type of coordinate systems for touchpads. Do the conversion as part of the driver
                        // and pretend the device always provide absolute coordinates for the time being.
                        // BEGIN: Conversion and tracking of abs coordinates:
                        // Avoid underoverflow
                        if (deltaX < 0 && (int)cookie->x < abs(deltaX))
                                deltaX = -cookie->x;
                        if (deltaY < 0 && (int)cookie->y < abs(deltaY))
                                deltaY = -cookie->y;

                        event.xPosition = cookie->x + deltaX;
                        event.yPosition = cookie->y + deltaY;

                        // Adjust to area boundaries
                        if (event.xPosition < gHardwareSpecs.areaStartX)
                                event.xPosition = gHardwareSpecs.areaStartX;
                        if (event.xPosition > gHardwareSpecs.areaEndX)
                                event.xPosition = gHardwareSpecs.areaEndX;
                        if (event.yPosition < gHardwareSpecs.areaStartY)
                                event.yPosition = gHardwareSpecs.areaStartY;
                        if (event.yPosition > gHardwareSpecs.areaEndY)
                                event.yPosition = gHardwareSpecs.areaEndY;

                        cookie->x = event.xPosition;
                        cookie->y = event.yPosition;
                        // END: Conversion and tracking of abs coordinates

                        TRACE("ELANTECH: Pos: %" B_PRId32 ":%" B_PRId32 " (MOTION)\n",
                                cookie->x, cookie->y);

                        break;
                default:
                        dprintf("ELANTECH: unknown packet type %d\n", packet_type);
                        return IGNORE_EVENT;
        }

        cookie->fingers = event.fingers;
        TRACE("ELANTECH: buttons %d\n", event.buttons);
        TRACE("ELANTECH: zPressure %d\n", event.zPressure);

        event.fingerWidth = DEFAULT_FINGER_WIDTH;

        *_event = event;
        return B_OK;
}


static status_t
elantech_process_packet_trackpoint(elantech_cookie *cookie, mouse_movement *_movement,
        uint8 packet[PS2_PACKET_ELANTECH])
{
        /*               7   6   5   4   3   2   1   0 (LSB)
         * -------------------------------------------
         * ipacket[0]:   0   0  SY  SX   0   M   R   L
         * ipacket[1]: ~SX   0   0   0   0   0   0   0
         * ipacket[2]: ~SY   0   0   0   0   0   0   0
         * ipacket[3]:   0   0 ~SY ~SX   0   1   1   0
         * ipacket[4]:  X7  X6  X5  X4  X3  X2  X1  X0
         * ipacket[5]:  Y7  Y6  Y5  Y4  Y3  Y2  Y1  Y0
         * -------------------------------------------
         * X and Y are written in two's complement spread
         * over 9 bits with SX/SY the relative top bit and
         * X7..X0 and Y7..Y0 the lower bits.
         */
        int32 x, y;
        uint8 buttons;

        if (!(!(packet[0] & 0xC8) && !(packet[1] & 0x7F)
                        && !(packet[2] & 0x7F) && !(packet[3] & 0xC9)
                        && !(packet[0] & 0x10) != !(packet[1] & 0x80)
                        && !(packet[0] & 0x10) != !(packet[3] & 0x10)
                        && !(packet[0] & 0x20) != !(packet[2] & 0x80)
                        && !(packet[0] & 0x20) != !(packet[3] & 0x20)))
                return IGNORE_EVENT;

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

        x = packet[4] - 0x100 + (packet[1] << 1);
        y = packet[5] - 0x100 + (packet[2] << 1);

        buttons = packet[0] & 7;

        mouse_movement movement = {
                .buttons = buttons,
                .xdelta = x,
                .ydelta = y,
                .timestamp = system_time(),
                .wheel_ydelta = 0,
                .wheel_xdelta = 0,
        };

        *_movement = movement;

        return B_OK;
}


static status_t
synaptics_dev_send_command(ps2_dev* dev, uint8 cmd, uint8 *in, int in_count)
{
        if (ps2_dev_sliced_command(dev, cmd) != B_OK
                || ps2_dev_command(dev, PS2_CMD_MOUSE_GET_INFO, NULL, 0, in, in_count)
                != B_OK) {
                TRACE("ELANTECH: synaptics_dev_send_command failed\n");
                return B_ERROR;
        }
        return B_OK;
}


static status_t
elantech_dev_send_command(ps2_dev* dev, uint8 cmd, uint8 *in, int in_count)
{
        if (ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                || ps2_dev_command(dev, cmd) != B_OK
                || ps2_dev_command(dev, PS2_CMD_MOUSE_GET_INFO, NULL, 0, in, in_count)
                != B_OK) {
                TRACE("ELANTECH: elantech_dev_send_command failed\n");
                return B_ERROR;
        }
        return B_OK;
}


//      #pragma mark - exported functions


status_t
probe_elantech(ps2_dev* dev)
{
        uint8 val[3];
        TRACE("ELANTECH: probe\n");

        ps2_dev_command(dev, PS2_CMD_MOUSE_RESET_DIS);

        if (ps2_dev_command(dev, PS2_CMD_DISABLE) != B_OK
                || ps2_dev_command(dev, PS2_CMD_MOUSE_SET_SCALE11) != B_OK
                || ps2_dev_command(dev, PS2_CMD_MOUSE_SET_SCALE11) != B_OK
                || ps2_dev_command(dev, PS2_CMD_MOUSE_SET_SCALE11) != B_OK) {
                TRACE("ELANTECH: not found (1)\n");
                return B_ERROR;
        }

        if (ps2_dev_command(dev, PS2_CMD_MOUSE_GET_INFO, NULL, 0, val, 3)
                != B_OK) {
                TRACE("ELANTECH: not found (2)\n");
                return B_ERROR;
        }

        if (val[0] != 0x3c || val[1] != 0x3 || (val[2] != 0xc8 && val[2] != 0x0)) {
                TRACE("ELANTECH: not found (3)\n");
                return B_ERROR;
        }

        val[0] = 0;
        if (synaptics_dev_send_command(dev, ELANTECH_CMD_GET_VERSION, val, 3)
                != B_OK) {
                TRACE("ELANTECH: not found (4)\n");
                return B_ERROR;
        }

        uint32 fwVersion = ((val[0] << 16) | (val[1] << 8) | val[2]);
        bool v1 = fwVersion < 0x020030 || fwVersion == 0x020600;
        bool v2 = (val[0] & 0xf) == 4 || ((val[0] & 0xf) == 2 && !v1);
        bool v3 = (val[0] & 0xf) == 5;
        bool v4 = (val[0] & 0xf) >= 6 && (val[0] & 0xf) <= 15;

        if (val[0] == 0x0 || val[2] == 10 || val[2] == 20 || val[2] == 40
                || val[2] == 60 || val[2] == 80 || val[2] == 100 || val[2] == 200) {
                TRACE("ELANTECH: not found (5)\n");
                return B_ERROR;
        }

        // TODO: Update supported after testing all versions.
        // Only hardware version 4 devices are known to be supported as of now.
        // v2 is known to be broken, see #19874.
        (void)v2;
        bool supported = v4 || v3 || v1;

        if (supported && v3) {
                uint8 samples[3];
                if (elantech_dev_send_command(dev, ELANTECH_CMD_GET_SAMPLE, samples, 3) != B_OK) {
                        TRACE("ELANTECH: failed to query sample data\n");
                        return B_ERROR;
                }

                if (samples[1] == 0x74) {
                        TRACE("ELANTECH: Absolute mode broken, forcing standard PS/2 protocol\n");
                        supported = false;
                }
        }

        if (supported) {
                INFO("Elantech version %02X%02X%02X detected.\n",
                        val[0], val[1], val[2]);
        } else {
                INFO("Elantech version %02X%02X%02X, under developement! Using fallback.\n",
                        val[0], val[1], val[2]);
        }

        dev->name = kElantechPath[dev->idx];
        dev->packet_size = v1 ? PS2_PACKET_ELANTECH_V1 : PS2_PACKET_ELANTECH;

        return supported ? B_OK : B_ERROR;
}


//      #pragma mark - Setup functions


static status_t
elantech_write_reg(elantech_cookie* cookie, uint8 reg, uint8 value)
{
        if (reg < 0x7 || reg > 0x26)
                return B_BAD_VALUE;
        if (reg > 0x11 && reg < 0x20)
                return B_BAD_VALUE;

        ps2_dev* dev = cookie->dev;
        switch (cookie->version) {
                case 1:
                        if (ps2_dev_sliced_command(dev, ELANTECH_CMD_REGISTER_WRITE) != B_OK
                                || ps2_dev_sliced_command(dev, reg) != B_OK
                                || ps2_dev_sliced_command(dev, value) != B_OK
                                || ps2_dev_command(dev, PS2_CMD_MOUSE_SET_SCALE11))
                                return B_ERROR;
                        break;
                case 2:
                        if (ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_REGISTER_WRITE) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, reg) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, value) != B_OK
                                || ps2_dev_command(dev, PS2_CMD_MOUSE_SET_SCALE11) != B_OK)
                                return B_ERROR;
                        break;
                case 3:
                        if (ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_REGISTER_READWRITE) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, reg) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, value) != B_OK
                                || ps2_dev_command(dev, PS2_CMD_MOUSE_SET_SCALE11) != B_OK)
                                return B_ERROR;
                        break;
                case 4:
                        if (ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_REGISTER_READWRITE) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, reg) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_REGISTER_READWRITE) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, value) != B_OK
                                || ps2_dev_command(dev, PS2_CMD_MOUSE_SET_SCALE11) != B_OK)
                                return B_ERROR;
                        break;
                default:
                        TRACE("ELANTECH: read_write_reg: unknown version\n");
                        return B_ERROR;
        }
        return B_OK;
}


static status_t
elantech_read_reg(elantech_cookie* cookie, uint8 reg, uint8 *value)
{
        if (reg < 0x7 || reg > 0x26)
                return B_BAD_VALUE;
        if (reg > 0x11 && reg < 0x20)
                return B_BAD_VALUE;

        ps2_dev* dev = cookie->dev;
        uint8 val[3];
        switch (cookie->version) {
                case 1:
                        if (ps2_dev_sliced_command(dev, ELANTECH_CMD_REGISTER_READ) != B_OK
                                || ps2_dev_sliced_command(dev, reg) != B_OK
                                || ps2_dev_command(dev, PS2_CMD_MOUSE_GET_INFO, NULL, 0, val,
                                        3) != B_OK)
                                return B_ERROR;
                        break;
                case 2:
                        if (ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_REGISTER_READ) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, reg) != B_OK
                                || ps2_dev_command(dev, PS2_CMD_MOUSE_GET_INFO, NULL, 0, val,
                                        3) != B_OK)
                                return B_ERROR;
                        break;
                case 3:
                case 4:
                        if (ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_REGISTER_READWRITE)
                                        != B_OK
                                || ps2_dev_command(dev, ELANTECH_CMD_PS2_CUSTOM_CMD) != B_OK
                                || ps2_dev_command(dev, reg) != B_OK
                                || ps2_dev_command(dev, PS2_CMD_MOUSE_GET_INFO, NULL, 0, val,
                                        3) != B_OK)
                                return B_ERROR;
                        break;
                default:
                        TRACE("ELANTECH: read_write_reg: unknown version\n");
                        return B_ERROR;
        }
        if (cookie->version == 4)
                *value = val[1];
        else
                *value = val[0];

        return B_OK;
}


static status_t
get_resolution_v4(elantech_cookie* cookie, uint32* x, uint32* y)
{
        uint8 val[3];
        if (elantech_dev_send_command(cookie->dev, ELANTECH_CMD_GET_RESOLUTION,
                val, 3) != B_OK)
                return B_ERROR;
        *x = ((val[1] & 0xf) * 10 + 790) * 10 / 254;
        *y = (((val[1] & 0xf) >> 4) * 10 + 790) * 10 / 254;
        return B_OK;
}


static status_t
get_range(elantech_cookie* cookie, uint32* x_min, uint32* y_min, uint32* x_max,
        uint32* y_max, uint32 *width)
{
        uint8 val[3];
        switch (cookie->version) {
                case 1:
                        *x_min = 32;
                        *y_min = 32;
                        *x_max = 544;
                        *y_max = 344;
                        *width = 0;
                        break;
                case 2:
                        if (cookie->fwVersion == 0x020800
                                || cookie->fwVersion == 0x020b00
                                || cookie->fwVersion == 0x020030) {
                                *x_min = ELANTECH_XMIN_V2;
                                *y_min = ELANTECH_YMIN_V2;
                                *x_max = ELANTECH_XMAX_V2;
                                *y_max = ELANTECH_YMAX_V2;
                        } else {
                                int i;
                                int fixed_dpi;

                                i = (cookie->fwVersion > 0x020800
                                        && cookie->fwVersion < 0x020900) ? 1 : 2;

                                if ((cookie->send_command)(cookie->dev, ELANTECH_CMD_GET_ID, val, 3)
                                        != B_OK)
                                        return B_ERROR;

                                fixed_dpi = val[1] & 0x10;

                                if (((cookie->fwVersion >> 16) == 0x14) && fixed_dpi) {
                                        if ((cookie->send_command)(cookie->dev, ELANTECH_CMD_GET_SAMPLE, val, 3)
                                                != B_OK)
                                                return -EINVAL;

                                        *x_max = (cookie->capabilities[1] - i) * val[1] / 2;
                                        *y_max = (cookie->capabilities[2] - i) * val[2] / 2;
                                } else if (cookie->fwVersion == 0x040216) {
                                        *x_max = 819;
                                        *y_max = 405;
                                } else if (cookie->fwVersion == 0x040219 || cookie->fwVersion == 0x040215) {
                                        *x_max = 900;
                                        *y_max = 500;
                                } else {
                                        *x_max = (cookie->capabilities[1] - i) * 64;
                                        *y_max = (cookie->capabilities[2] - i) * 64;
                                }
                        }
                        break;
                case 3:
                        if ((cookie->send_command)(cookie->dev, ELANTECH_CMD_GET_ID, val, 3)
                                != B_OK) {
                                return B_ERROR;
                        }
                        *x_min = 0;
                        *y_min = 0;
                        *x_max = ((val[0] & 0xf) << 8) | val[1];
                        *y_max = ((val[0] & 0xf0) << 4) | val[2];
                        *width = 0;
                        break;
                case 4:
                        if ((cookie->send_command)(cookie->dev, ELANTECH_CMD_GET_ID, val, 3)
                                != B_OK) {
                                return B_ERROR;
                        }
                        *x_min = 0;
                        *y_min = 0;
                        *x_max = ((val[0] & 0xf) << 8) | val[1];
                        *y_max = ((val[0] & 0xf0) << 4) | val[2];
                        if (cookie->capabilities[1] < 2 || cookie->capabilities[1] > *x_max)
                                return B_ERROR;
                        *width = *x_max / (cookie->capabilities[1] - 1);
                        break;
        }
        return B_OK;
}


static status_t
enable_absolute_mode(elantech_cookie* cookie)
{
        status_t status = B_OK;
        switch (cookie->version) {
                case 1:
                        status = elantech_write_reg(cookie, 0x10, 0x16);
                        if (status == B_OK)
                                status = elantech_write_reg(cookie, 0x11, 0x8f);
                        break;
                case 2:
                        status = elantech_write_reg(cookie, 0x10, 0x54);
                        if (status == B_OK)
                                status = elantech_write_reg(cookie, 0x11, 0x88);
                        if (status == B_OK)
                                status = elantech_write_reg(cookie, 0x12, 0x60);
                        break;
                case 3:
                        status = elantech_write_reg(cookie, 0x10, 0xb);
                        break;
                case 4:
                        status = elantech_write_reg(cookie, 0x7, 0x1);
                        break;

        }

        if (status == B_OK && cookie->version < 4) {
                uint8 val;

                for (uint8 retry = 0; retry < 5; retry++) {
                        status = elantech_read_reg(cookie, 0x10, &val);
                        if (status != B_OK)
                                break;
                        snooze(2000);
                }
        }

        return status;
}


//      #pragma mark - Device functions


status_t
elantech_open(const char *name, uint32 flags, void **_cookie)
{
        TRACE("ELANTECH: open %s\n", name);
        ps2_dev* dev;
        int i;
        for (dev = NULL, i = 0; i < PS2_DEVICE_COUNT; i++) {
                if (0 == strcmp(ps2_device[i].name, name)) {
                        dev = &ps2_device[i];
                        break;
                }
        }

        if (dev == NULL) {
                TRACE("ps2: dev = NULL\n");
                return B_ERROR;
        }

        if (atomic_or(&dev->flags, PS2_FLAG_OPEN) & PS2_FLAG_OPEN)
                return B_BUSY;

        uint32 x_min = 0, x_max = 0, y_min = 0, y_max = 0, width = 0;

        elantech_cookie* cookie = (elantech_cookie*)malloc(
                sizeof(elantech_cookie));
        if (cookie == NULL)
                goto err1;
        memset(cookie, 0, sizeof(*cookie));

        cookie->previousZ = 0;
        *_cookie = cookie;

        cookie->dev = dev;
        dev->cookie = cookie;
        dev->disconnect = &elantech_disconnect;
        dev->handle_int = &elantech_handle_int;

        dev->packet_size = PS2_PACKET_ELANTECH;

        cookie->ring_buffer = create_packet_buffer(
                ELANTECH_HISTORY_SIZE * dev->packet_size);
        if (cookie->ring_buffer == NULL) {
                TRACE("ELANTECH: can't allocate mouse actions buffer\n");
                goto err2;
        }
        // create the mouse semaphore, used for synchronization between
        // the interrupt handler and the read operation
        cookie->sem = create_sem(0, "ps2_elantech_sem");
        if (cookie->sem < 0) {
                TRACE("ELANTECH: failed creating semaphore!\n");
                goto err3;
        }

        uint8 val[3];
        if (synaptics_dev_send_command(dev, ELANTECH_CMD_GET_VERSION, val, 3)
                != B_OK) {
                TRACE("ELANTECH: get version failed!\n");
                goto err4;
        }

        cookie->fwVersion = (val[0] << 16) | (val[1] << 8) | val[2];
        if (cookie->fwVersion < 0x020030 || cookie->fwVersion == 0x020600)
                cookie->version = 1;
        else {
                switch (val[0] & 0xf) {
                        case 2:
                        case 4:
                                cookie->version = 2;
                                break;
                        case 5:
                                cookie->version = 3;
                                break;
                        case 6 ... 15:
                                cookie->version = 4;
                                break;
                        default:
                                TRACE("ELANTECH: unknown version!\n");
                                goto err4;
                }
        }
        INFO("ELANTECH: version 0x%" B_PRIu32 " (0x%" B_PRIu32 ")\n",
                cookie->version, cookie->fwVersion);

        cookie->icVersion = (cookie->fwVersion & 0x0f0000) >> 16;

        if (cookie->version >= 3)
                cookie->send_command = &elantech_dev_send_command;
        else
                cookie->send_command = &synaptics_dev_send_command;

        cookie->crcEnabled = (cookie->fwVersion & 0x4000) == 0x4000;

        if ((cookie->send_command)(cookie->dev, ELANTECH_CMD_GET_CAPABILITIES,
                cookie->capabilities, 3) != B_OK) {
                TRACE("ELANTECH: get capabilities failed!\n");
                return B_ERROR;
        }

        if (cookie->version != 1) {
                if (cookie->send_command(cookie->dev, ELANTECH_CMD_GET_SAMPLE, cookie->samples, 3)
                        != B_OK) {
                        TRACE("ELANTECH: failed to query sample data\n");
                        return B_ERROR;
                }

                if (cookie->samples[1] == 0x74 && cookie->version == 3) {
                        TRACE("ELANTECH: absolute mode broken, forcing standard PS/2 protocol\n");
                        return B_ERROR;
                }
        }

        if (enable_absolute_mode(cookie) != B_OK) {
                TRACE("ELANTECH: failed enabling absolute mode!\n");
                goto err4;
        }
        TRACE("ELANTECH: enabled absolute mode!\n");

        if (get_range(cookie, &x_min, &y_min, &x_max, &y_max, &width) != B_OK) {
                TRACE("ELANTECH: get range failed!\n");
                goto err4;
        }

        TRACE("ELANTECH: range x %" B_PRIu32 "-%" B_PRIu32 " y %" B_PRIu32
                "-%" B_PRIu32 " (%" B_PRIu32 ")\n", x_min, x_max, y_min, y_max, width);

        uint32 x_res, y_res;
        x_res = 31;
        y_res = 31;
        if (cookie->version == 4) {
                if (get_resolution_v4(cookie, &x_res, &y_res) != B_OK) {
                        TRACE("ELANTECH: get resolution failed!\n");
                }
        }

        TRACE("ELANTECH: resolution x %" B_PRIu32 " y %" B_PRIu32 " (dpi)\n",
                x_res, y_res);

        gHardwareSpecs.edgeMotionWidth = EDGE_MOTION_WIDTH;

        gHardwareSpecs.areaStartX = x_min;
        gHardwareSpecs.areaEndX = x_max;
        gHardwareSpecs.areaStartY = y_min;
        gHardwareSpecs.areaEndY = y_max;

        gHardwareSpecs.minPressure = MIN_PRESSURE;
        gHardwareSpecs.realMaxPressure = REAL_MAX_PRESSURE;
        gHardwareSpecs.maxPressure = MAX_PRESSURE;

        if (ps2_dev_command(dev, PS2_CMD_ENABLE, NULL, 0, NULL, 0) != B_OK)
                goto err4;

        atomic_or(&dev->flags, PS2_FLAG_ENABLED);

        TRACE("ELANTECH: open %s success\n", name);
        return B_OK;

err4:
        delete_sem(cookie->sem);
err3:
        delete_packet_buffer(cookie->ring_buffer);
err2:
        free(cookie);
err1:
        atomic_and(&dev->flags, ~PS2_FLAG_OPEN);

        TRACE("ELANTECH: open %s failed\n", name);
        return B_ERROR;
}


status_t
elantech_close(void *_cookie)
{
        elantech_cookie *cookie = (elantech_cookie*)_cookie;

        ps2_dev_command_timeout(cookie->dev, PS2_CMD_DISABLE, NULL, 0, NULL, 0,
                150000);

        delete_packet_buffer(cookie->ring_buffer);
        delete_sem(cookie->sem);

        atomic_and(&cookie->dev->flags, ~PS2_FLAG_OPEN);
        atomic_and(&cookie->dev->flags, ~PS2_FLAG_ENABLED);

        // Reset the touchpad so it generate standard ps2 packets instead of
        // extended ones. If not, BeOS is confused with such packets when rebooting
        // without a complete shutdown.
        status_t status = ps2_reset_mouse(cookie->dev);
        if (status != B_OK) {
                INFO("ps2_elantech: reset failed\n");
                return B_ERROR;
        }

        TRACE("ELANTECH: close %s done\n", cookie->dev->name);
        return B_OK;
}


status_t
elantech_freecookie(void *_cookie)
{
        free(_cookie);
        return B_OK;
}


status_t
elantech_ioctl(void *_cookie, uint32 op, void *buffer, size_t length)
{
        elantech_cookie *cookie = (elantech_cookie*)_cookie;
        touchpad_read read;
        status_t status;

        switch (op) {
                case MS_IS_TOUCHPAD:
                        TRACE("ELANTECH: MS_IS_TOUCHPAD\n");
                        if (buffer == NULL)
                                return B_OK;
                        return user_memcpy(buffer, &gHardwareSpecs, sizeof(gHardwareSpecs));

                case MS_READ_TOUCHPAD:
                        TRACE("ELANTECH: MS_READ_TOUCHPAD get event\n");
                        if (user_memcpy(&read.timeout, &(((touchpad_read*)buffer)->timeout),
                                        sizeof(bigtime_t)) != B_OK)
                                return B_BAD_ADDRESS;
                        if ((status = get_elantech_movement(cookie, &read)) != B_OK) {
                                TRACE("ELANTECH: ioctl error with status: %s\n", strerror(status));
                                return status;
                        }
#ifdef TRACE_PS2_ELANTECH
                        if (read.event = MS_READ_TOUCHPAD) {
                                TRACE("ELANTECH: ioctl touchpad fingers: 0x%x\n", (int)read.u.touchpad.fingers);
                                TRACE("ELANTECH: ioctl touchpad buttons: %d\n", (int)read.u.touchpad.buttons);
                        } else if (read.event = MS_READ) {
                                TRACE("ELANTECH: ioctl mouse buttons: %d\n", (int)read.u.mouse.buttons);
                        }
#endif
                        return user_memcpy(buffer, &read, sizeof(read));

                default:
                        INFO("ELANTECH: unknown opcode: 0x%" B_PRIx32 "\n", op);
                        return B_BAD_VALUE;
        }
}


static status_t
elantech_read(void* cookie, off_t pos, void* buffer, size_t* _length)
{
        *_length = 0;
        return B_NOT_ALLOWED;
}


static status_t
elantech_write(void* cookie, off_t pos, const void* buffer, size_t* _length)
{
        *_length = 0;
        return B_NOT_ALLOWED;
}


int32
elantech_handle_int(ps2_dev* dev)
{
        elantech_cookie* cookie = (elantech_cookie*)dev->cookie;

        uint8 val;
        val = cookie->dev->history[0].data;
        cookie->buffer[cookie->packet_index] = val;
        cookie->packet_index++;

        if (cookie->packet_index < PS2_PACKET_ELANTECH)
                return B_HANDLED_INTERRUPT;

        cookie->packet_index = 0;
        if (packet_buffer_write(cookie->ring_buffer,
                                cookie->buffer, cookie->dev->packet_size)
                        != cookie->dev->packet_size) {
                // buffer is full, drop new data
                return B_HANDLED_INTERRUPT;
        }
        release_sem_etc(cookie->sem, 1, B_DO_NOT_RESCHEDULE);
        return B_INVOKE_SCHEDULER;
}


void
elantech_disconnect(ps2_dev *dev)
{
        elantech_cookie *cookie = (elantech_cookie*)dev->cookie;
        // the mouse device might not be opened at this point
        INFO("ELANTECH: elantech_disconnect %s\n", dev->name);
        if ((dev->flags & PS2_FLAG_OPEN) != 0)
                release_sem(cookie->sem);
}


device_hooks gElantechDeviceHooks = {
        elantech_open,
        elantech_close,
        elantech_freecookie,
        elantech_ioctl,
        elantech_read,
        elantech_write,
};