/*
 * Copyright 2008-2010, Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors (in chronological order):
 *              Clemens Zeidler (haiku@Clemens-Zeidler.de)
 *              Axel Dörfler, axeld@pinc-software.de
 */


//!     PS/2 synaptics touchpad


#include "ps2_synaptics.h"

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

#include <keyboard_mouse_driver.h>

#include "ps2_service.h"


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

/*! The raw movement calculation is calibrated on ths synaptics touchpad. */
// increase the touchpad size a little bit
#define SYN_AREA_TOP_LEFT_OFFSET        40
#define SYN_AREA_BOTTOM_RIGHT_OFFSET    60
#define SYN_AREA_START_X                (1472 - SYN_AREA_TOP_LEFT_OFFSET)
#define SYN_AREA_END_X                  (5472 + SYN_AREA_BOTTOM_RIGHT_OFFSET)
#define SYN_AREA_START_Y                (1408 - SYN_AREA_TOP_LEFT_OFFSET)
#define SYN_AREA_END_Y                  (4448 + SYN_AREA_BOTTOM_RIGHT_OFFSET)

// synaptics touchpad proportions
#define SYN_EDGE_MOTION_WIDTH   50
#define SYN_AREA_OFFSET                 40

#define MIN_PRESSURE                    30
#define REAL_MAX_PRESSURE               100
#define MAX_PRESSURE                    200

enum {
        kIdentify = 0x00,
        kReadModes = 0x01,
        kReadCapabilities = 0x02,
        kReadModelId = 0x03,
        kReadSerialNumberPrefix = 0x06,
        kReadSerialModelSuffix = 0x07,
        kReadResolutions = 0x08,
        kExtendedModelId = 0x09,
        kContinuedCapabilities = 0x0C,
        kMaximumCoordinates = 0x0D,
        kDeluxeLedInfo = 0x0E,
        kMinimumCoordinates = 0x0F,
        kTrackpointQuirk = 0x10
};

static touchpad_specs gHardwareSpecs;


typedef struct {
        uint8 majorVersion;
        uint8 minorVersion;

        uint8 nExtendedButtons;
        uint8 firstExtendedButton;
        uint8 extendedButtonsState;

        bool capExtended : 1;
        bool capMiddleButton : 1;
        bool capSleep : 1;
        bool capFourButtons : 1;
        bool capMultiFinger : 1;
        bool capMultiFingerReport : 1;
        bool capPalmDetection : 1;
        bool capPassThrough : 1;
        bool capAdvancedGestures : 1;
        bool capExtendedWMode : 1;
        bool capClickPadUniform : 1;
        int  capClickPadButtonCount : 2;
} touchpad_info;


const char* kSynapticsPath[4] = {
        "input/touchpad/ps2/synaptics_0",
        "input/touchpad/ps2/synaptics_1",
        "input/touchpad/ps2/synaptics_2",
        "input/touchpad/ps2/synaptics_3"
};


static touchpad_info sTouchpadInfo;
static ps2_dev *sPassthroughDevice = &ps2_device[PS2_DEVICE_SYN_PASSTHROUGH];


static status_t
send_touchpad_arg_timeout(ps2_dev *dev, uint8 arg, bigtime_t timeout)
{
        int8 i;
        uint8 val[8];

        for (i = 0; i < 4; i++) {
                val[2 * i] = (arg >> (6 - 2 * i)) & 3;
                val[2 * i + 1] = 0xE8;
        }
        return ps2_dev_command_timeout(dev, 0xE8, val, 7, NULL, 0, timeout);
}


static status_t
send_touchpad_arg(ps2_dev *dev, uint8 arg)
{
        return send_touchpad_arg_timeout(dev, arg, 4000000);
}


static status_t
set_touchpad_mode(ps2_dev *dev, uint8 mode)
{
        uint8 sample_rate = SYN_CHANGE_MODE;
        send_touchpad_arg(dev, mode);
        return ps2_dev_command(dev, PS2_CMD_SET_SAMPLE_RATE, &sample_rate, 1,
                NULL, 0);
}


static status_t
get_information_query(ps2_dev *dev, uint8 extendedQueries, uint8 query,
        uint8 val[3])
{
        if (query == kTrackpointQuirk) {
                // Special case: this information query is not reported in the
                // "extended queries", but is still supported when the touchpad has
                // a pass-through port.
                if (!sTouchpadInfo.capPassThrough)
                        return B_NOT_SUPPORTED;
        } else if (query > extendedQueries + 8)
                return B_NOT_SUPPORTED;

        status_t error = send_touchpad_arg(dev, query);
        if (error != B_OK)
                return error;
        return ps2_dev_command(dev, 0xE9, NULL, 0, val, 3);
}


static status_t
get_synaptics_movment(synaptics_cookie *cookie, touchpad_movement *_event, bigtime_t timeout)
{
        status_t status;
        touchpad_movement event = {};
        uint8 event_buffer[PS2_MAX_PACKET_SIZE];
        uint8 wValue0, wValue1, wValue2, wValue3, wValue;
        uint32 val32;
        uint32 xTwelfBit, yTwelfBit;

        status = acquire_sem_etc(cookie->synaptics_sem, 1, B_CAN_INTERRUPT | B_RELATIVE_TIMEOUT,
                timeout);
        if (status < B_OK)
                return status;

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

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

        event.buttons = event_buffer[0] & 3;
        event.zPressure = event_buffer[2];
        bool isExtended = false;

        if (sTouchpadInfo.capExtended) {
                wValue0 = event_buffer[3] >> 2 & 1;
                wValue1 = event_buffer[0] >> 2 & 1;
                wValue2 = event_buffer[0] >> 4 & 1;
                wValue3 = event_buffer[0] >> 5 & 1;

                wValue = wValue0;
                wValue = wValue | (wValue1 << 1);
                wValue = wValue | (wValue2 << 2);
                wValue = wValue | (wValue3 << 3);


                TRACE("SYNAPTICS: received packet %02x %02x %02x %02x %02x %02x -> W = %d\n",
                        event_buffer[0], event_buffer[1], event_buffer[2], event_buffer[3], event_buffer[4],
                        event_buffer[5], wValue);

                if (wValue <= 1) {
                        // Multiple fingers detected, report the finger count.
                        event.fingers = 2 + wValue;

                        // There is a separate "v" value indicating the finger width
                        wValue0 = event_buffer[3] >> 1 & 1;
                        wValue1 = event_buffer[4] >> 1 & 1;
                        wValue2 = event_buffer[2] >> 0 & 1;

                        wValue = wValue0;
                        wValue = wValue | (wValue1 << 1);
                        wValue = wValue | (wValue2 << 2);

                        event.fingerWidth = wValue * 2;
                } else if (wValue >= 4) {
                        // wValue = 4 to 15 corresponds to a finger width report for a single finger
                        event.fingerWidth = wValue;
                        event.fingers = 1;
                }
                // wValue = 2 - Extended W mode
                // wValue = 3 - Packet from pass-through device
                event.gesture = false;

                if (sTouchpadInfo.capExtendedWMode && wValue == 2) {
                        // The extended W can be encoded on 4 bits (values 0-7) or 8 bits (80-FF)
                        uint8_t extendedWValue = event_buffer[5] >> 4;
                        if (extendedWValue >= 8)
                                extendedWValue = event_buffer[5];
                        isExtended = true;

                        // Extended W = 0 - Scroll wheels
                        if (extendedWValue == 0) {
                                event.wheel_ydelta = event_buffer[2];
                                event.wheel_xdelta = event_buffer[3];
                                event.wheel_zdelta = event_buffer[4];
                                event.wheel_wdelta = (event_buffer[5] & 0x0f) | (event_buffer[3] & 0x30);
                                // Sign extend wdelta if needed
                                if (event.wheel_wdelta & 0x20)
                                        event.wheel_wdelta |= 0xffffffc0;
                        }

                        // Extended W = 1 - Secondary finger
                        if (extendedWValue == 1) {
                                event.xPosition = event_buffer[1];
                                event.yPosition = event_buffer[2];

                                val32 = event_buffer[4] & 0x0F;
                                event.xPosition += val32 << 8;
                                val32 = event_buffer[4] & 0xF0;
                                event.yPosition += val32 << 4;

                                event.xPosition *= 2;
                                event.yPosition *= 2;

                                event.zPressure = event_buffer[5] & 0x0F;
                                event.zPressure += event_buffer[3] & 0x30;

                                // There is a separate "v" value indicating the finger width
                                wValue0 = event_buffer[1] >> 0 & 1;
                                wValue1 = event_buffer[2] >> 0 & 1;
                                wValue2 = event_buffer[5] >> 0 & 1;

                                wValue = wValue0;
                                wValue = wValue | (wValue1 << 1);
                                wValue = wValue | (wValue2 << 2);

                                event.fingerWidth = wValue * 2;
                        }

                        // Extended W = 2 - Finger state info
                        if (extendedWValue == 2) {
                                event.fingers = event_buffer[1] & 0x0F;
                                // TODO this event also provides primary and secondary finger indexes, what do
                                // these mean?
                        }

                        // Other values are reserved for other uses (usually enabled with special commands)


                        *_event = event;

                        return status;
                }

                // Clickpad pretends that all clicks on the touchpad are middle clicks.
                // Pass them to userspace as left clicks instead.
                if (sTouchpadInfo.capClickPadButtonCount == 1)
                        event.buttons |= ((event_buffer[0] ^ event_buffer[3]) & 0x01);

                if (sTouchpadInfo.capMiddleButton || sTouchpadInfo.capFourButtons)
                        event.buttons |= ((event_buffer[0] ^ event_buffer[3]) & 0x01) << 2;

                if (sTouchpadInfo.nExtendedButtons > 0) {
                        if (((event_buffer[0] ^ event_buffer[3]) & 0x02) != 0) {
                                // This packet includes extended buttons state. The state is
                                // only reported once when one of the buttons is pressed or
                                // released, so we must keep track of the buttons state.

                                // The values replace the lowest bits of the X and Y coordinates
                                // in the packet, we need to extract them from there.

                                bool pressed;
                                for (int button = 0; button < sTouchpadInfo.nExtendedButtons;
                                                button++) {
                                        // Even buttons are in the X byte
                                        pressed = event_buffer[4 + button % 2] >> button / 2 & 0x1;
                                        if (pressed) {
                                                sTouchpadInfo.extendedButtonsState |= 1 << button;
                                        } else {
                                                sTouchpadInfo.extendedButtonsState &= ~(1 << button);
                                        }
                                }
                        }

                        event.buttons |= sTouchpadInfo.extendedButtonsState
                                << sTouchpadInfo.firstExtendedButton;
                }
        } else {
                bool finger = event_buffer[0] >> 5 & 1;
                if (finger) {
                        // finger with normal width
                        event.fingerWidth = 4;
                }
                event.gesture = event_buffer[0] >> 2 & 1;
        }

        if (!isExtended) {
                event.xPosition = event_buffer[4];
                event.yPosition = event_buffer[5];

                val32 = event_buffer[1] & 0x0F;
                event.xPosition += val32 << 8;
                val32 = event_buffer[1] >> 4 & 0x0F;
                event.yPosition += val32 << 8;

                xTwelfBit = event_buffer[3] >> 4 & 1;
                event.xPosition += xTwelfBit << 12;
                yTwelfBit = event_buffer[3] >> 5 & 1;
                event.yPosition += yTwelfBit << 12;
        }

        *_event = event;
        return B_OK;
}


static void
query_capability(ps2_dev *dev)
{
        uint8 val[3];
        uint8 nExtendedQueries = 0;

        get_information_query(dev, nExtendedQueries, kReadCapabilities, val);

        TRACE("SYNAPTICS: extended mode %2x\n", val[0] >> 7 & 1);
        sTouchpadInfo.capExtended = val[0] >> 7 & 1;
        TRACE("SYNAPTICS: extended queries %2x\n", val[0] >> 4 & 7);
        nExtendedQueries = val[0] >> 4 & 7;
        TRACE("SYNAPTICS: middle button %2x\n", val[0] >> 2 & 1);
        sTouchpadInfo.capMiddleButton = val[0] >> 2 & 1;

        TRACE("SYNAPTICS: pass through %2x\n", val[2] >> 7 & 1);
        sTouchpadInfo.capPassThrough = val[2] >> 7 & 1;

        // bit 6, low power, is only informative (touchpad has an automatic powersave mode)

        TRACE("SYNAPTICS: multi finger report %2x\n", val[2] >> 5 & 1);
        sTouchpadInfo.capMultiFingerReport = val[2] >> 5 & 1;

        TRACE("SYNAPTICS: sleep mode %2x\n", val[2] >> 4 & 1);
        sTouchpadInfo.capSleep = val[2] >> 4 & 1;

        TRACE("SYNAPTICS: four buttons %2x\n", val[2] >> 3 & 1);
        sTouchpadInfo.capFourButtons = val[2] >> 3 & 1;

        // bit 2, TouchStyk ballistics, not further documented in the documents I have

        TRACE("SYNAPTICS: multi finger %2x\n", val[2] >> 1 & 1);
        sTouchpadInfo.capMultiFinger = val[2] >> 1 & 1;

        TRACE("SYNAPTICS: palm detection %2x\n", val[2] & 1);
        sTouchpadInfo.capPalmDetection = val[2] & 1;

        if (get_information_query(dev, nExtendedQueries, kContinuedCapabilities,
                        val) == B_OK) {
                sTouchpadInfo.capAdvancedGestures = val[0] >> 3 & 1;
                TRACE("SYNAPTICS: advanced gestures %x\n", sTouchpadInfo.capAdvancedGestures);

                sTouchpadInfo.capClickPadButtonCount = (val[0] >> 4 & 1) | ((val[1] >> 0 & 1) << 1);
                sTouchpadInfo.capClickPadUniform = val[1] >> 4 & 1;
                TRACE("SYNAPTICS: clickpad buttons: %x\n", sTouchpadInfo.capClickPadButtonCount);
                TRACE("SYNAPTICS: clickpad type: %s\n",
                        sTouchpadInfo.capClickPadUniform ? "uniform" : "hinged");

        } else {
                sTouchpadInfo.capAdvancedGestures = 0;
                sTouchpadInfo.capClickPadButtonCount = 0;
                sTouchpadInfo.capClickPadUniform = 0;
                sTouchpadInfo.capAdvancedGestures = 0;
        }

        if (get_information_query(dev, nExtendedQueries, kExtendedModelId, val)
                        != B_OK) {
                // "Extended Model ID" is not supported, so there cannot be extra
                // buttons.
                sTouchpadInfo.nExtendedButtons = 0;
                sTouchpadInfo.firstExtendedButton = 0;
                sTouchpadInfo.capExtendedWMode = 0;
                return;
        }

        TRACE("SYNAPTICS: extended buttons %2x\n", val[1] >> 4 & 15);
        sTouchpadInfo.nExtendedButtons = val[1] >> 4 & 15;
        sTouchpadInfo.extendedButtonsState = 0;

        sTouchpadInfo.capExtendedWMode = val[0] >> 2 & 1;
        TRACE("SYNAPTICS: extended wmode %2x\n", sTouchpadInfo.capExtendedWMode);

        if (sTouchpadInfo.capFourButtons)
                sTouchpadInfo.firstExtendedButton = 4;
        else if (sTouchpadInfo.capMiddleButton)
                sTouchpadInfo.firstExtendedButton = 3;
        else
                sTouchpadInfo.firstExtendedButton = 2;

        // Capability 0x10 is not documented in the Synaptics Touchpad interfacing
        // guide (at least the versions I could find), but we got the information
        // from Linux patches: https://lkml.org/lkml/2015/2/6/621
        if (get_information_query(dev, nExtendedQueries, kTrackpointQuirk, val)
                        != B_OK)
                return;

        // Workaround for Thinkpad use of the extended buttons: they are
        // used as buttons for the trackpoint, so they should be reported
        // as buttons 0, 1, 2 rather than 3, 4, 5.
        TRACE("SYNAPTICS: alternate buttons %2x\n", val[0] >> 0 & 1);
        if (val[0] >> 0 & 1)
                sTouchpadInfo.firstExtendedButton = 0;
}


//      #pragma mark - exported functions


status_t
synaptics_pass_through_set_packet_size(ps2_dev *dev, uint8 size)
{
        synaptics_cookie *synapticsCookie
                = (synaptics_cookie*)dev->parent_dev->cookie;

        status_t status = ps2_dev_command(dev->parent_dev, PS2_CMD_DISABLE, NULL,
                0, NULL, 0);
        if (status < B_OK) {
                INFO("SYNAPTICS: cannot disable touchpad %s\n", dev->parent_dev->name);
                return B_ERROR;
        }

        synapticsCookie->packet_index = 0;

        if (size == 4)
                synapticsCookie->mode |= SYN_FOUR_BYTE_CHILD;
        else
                synapticsCookie->mode &= ~SYN_FOUR_BYTE_CHILD;

        set_touchpad_mode(dev->parent_dev, synapticsCookie->mode);

        status = ps2_dev_command(dev->parent_dev, PS2_CMD_ENABLE, NULL, 0, NULL, 0);
        if (status < B_OK) {
                INFO("SYNAPTICS: cannot enable touchpad %s\n", dev->parent_dev->name);
                return B_ERROR;
        }
        return status;
}


status_t
passthrough_command(ps2_dev *dev, uint8 cmd, const uint8 *out, int outCount,
        uint8 *in, int inCount, bigtime_t timeout)
{
        status_t status;
        uint8 passThroughCmd = SYN_PASSTHROUGH_CMD;
        uint8 val;
        uint32 passThroughInCount = (inCount + 1) * 6;
        uint8 passThroughIn[passThroughInCount];
        int8 i;

        TRACE("SYNAPTICS: passthrough command 0x%x\n", cmd);

        status = ps2_dev_command(dev->parent_dev, PS2_CMD_DISABLE, NULL, 0,
                NULL, 0);
        if (status != B_OK)
                return status;

        for (i = -1; i < outCount; i++) {
                if (i == -1)
                        val = cmd;
                else
                        val = out[i];
                status = send_touchpad_arg_timeout(dev->parent_dev, val, timeout);
                if (status != B_OK)
                        goto finalize;
                if (i != outCount -1) {
                        status = ps2_dev_command_timeout(dev->parent_dev,
                                PS2_CMD_SET_SAMPLE_RATE, &passThroughCmd, 1, NULL, 0, timeout);
                        if (status != B_OK)
                                goto finalize;
                }
        }
        status = ps2_dev_command_timeout(dev->parent_dev, PS2_CMD_SET_SAMPLE_RATE,
                &passThroughCmd, 1, passThroughIn, passThroughInCount, timeout);
        if (status != B_OK)
                goto finalize;

        for (i = 0; i < inCount + 1; i++) {
                uint8 *inPointer = &passThroughIn[i * 6];
                if (!IS_SYN_PT_PACKAGE(inPointer)) {
                        TRACE("SYNAPTICS: not a pass throught package\n");
                        goto finalize;
                }
                if (i == 0)
                        continue;

                in[i - 1] = passThroughIn[i * 6 + 1];
        }

finalize:       
        status_t statusOfEnable = ps2_dev_command(dev->parent_dev, PS2_CMD_ENABLE,
                        NULL, 0, NULL, 0);
        if (statusOfEnable != B_OK) {
                TRACE("SYNAPTICS: enabling of parent failed: 0x%" B_PRIx32 ".\n",
                        statusOfEnable);
        }

        return status != B_OK ? status : statusOfEnable;
}


status_t
probe_synaptics(ps2_dev *dev)
{
        uint8 val[3];
        uint8 deviceId;
        status_t status;
        TRACE("SYNAPTICS: probe\n");

        // We reset the device here because it may have been left in a confused
        // state by a previous probing attempt. Some synaptics touchpads are known
        // to lockup when we attempt to detect them as IBM trackpoints.
        ps2_reset_mouse(dev);

        // Request "Identify touchpad"
        // The touchpad will delay this, until it's ready and calibrated.
        status = get_information_query(dev, 0, kIdentify, val);
        if (status != B_OK)
                return status;

        sTouchpadInfo.minorVersion = val[0];
        deviceId = val[1];
        if (deviceId != SYN_TOUCHPAD) {
                TRACE("SYNAPTICS: not found\n");
                return B_ERROR;
        }

        TRACE("SYNAPTICS: Touchpad found id:l %2x\n", deviceId);
        sTouchpadInfo.majorVersion = val[2] & 0x0F;
        TRACE("SYNAPTICS: version %d.%d\n", sTouchpadInfo.majorVersion,
                sTouchpadInfo.minorVersion);
        // version >= 4.0?
        if (sTouchpadInfo.minorVersion <= 2
                && sTouchpadInfo.majorVersion <= 3) {
                TRACE("SYNAPTICS: too old touchpad not supported\n");
                return B_ERROR;
        }
        dev->name = kSynapticsPath[dev->idx];
        return B_OK;
}


//      #pragma mark - Device functions


status_t
synaptics_open(const char *name, uint32 flags, void **_cookie)
{
        status_t status;
        synaptics_cookie *cookie;
        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;

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

        *_cookie = cookie;

        cookie->dev = dev;
        dev->cookie = cookie;
        dev->disconnect = &synaptics_disconnect;
        dev->handle_int = &synaptics_handle_int;

        gHardwareSpecs.edgeMotionWidth = SYN_EDGE_MOTION_WIDTH;

        gHardwareSpecs.areaStartX = SYN_AREA_START_X;
        gHardwareSpecs.areaEndX = SYN_AREA_END_X;
        gHardwareSpecs.areaStartY = SYN_AREA_START_Y;
        gHardwareSpecs.areaEndY = SYN_AREA_END_Y;

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

        dev->packet_size = PS2_PACKET_SYNAPTICS;

        cookie->synaptics_ring_buffer
                = create_packet_buffer(SYNAPTICS_HISTORY_SIZE * dev->packet_size);
        if (cookie->synaptics_ring_buffer == NULL) {
                TRACE("ps2: 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->synaptics_sem = create_sem(0, "ps2_synaptics_sem");
        if (cookie->synaptics_sem < 0) {
                TRACE("SYNAPTICS: failed creating semaphore!\n");
                goto err3;
        }
        query_capability(dev);

        // create pass through dev
        if (sTouchpadInfo.capPassThrough) {
                TRACE("SYNAPTICS: pass through detected\n");
                sPassthroughDevice->parent_dev = dev;
                sPassthroughDevice->idx = dev->idx;
                ps2_service_notify_device_added(sPassthroughDevice);
        }

        // Set Mode
        if (sTouchpadInfo.capExtendedWMode)
                cookie->mode = SYN_MODE_ABSOLUTE | SYN_MODE_W | SYN_MODE_EXTENDED_W;
        else if (sTouchpadInfo.capExtended)
                cookie->mode = SYN_MODE_ABSOLUTE | SYN_MODE_W;
        else
                cookie->mode = SYN_MODE_ABSOLUTE;

        status = set_touchpad_mode(dev, cookie->mode);
        if (status < B_OK) {
                INFO("SYNAPTICS: cannot set mode %s\n", name);
                goto err4;
        }

        status = ps2_dev_command(dev, PS2_CMD_ENABLE, NULL, 0, NULL, 0);
        if (status < B_OK) {
                INFO("SYNAPTICS: cannot enable touchpad %s\n", name);
                goto err4;
        }

        atomic_or(&dev->flags, PS2_FLAG_ENABLED);

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

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

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


status_t
synaptics_close(void *_cookie)
{
        status_t status;
        synaptics_cookie *cookie = (synaptics_cookie*)_cookie;

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

        delete_packet_buffer(cookie->synaptics_ring_buffer);
        delete_sem(cookie->synaptics_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 = ps2_reset_mouse(cookie->dev);
        if (status != B_OK) {
                INFO("ps2_synaptics: reset failed\n");
                return B_ERROR;
        }

        if (sTouchpadInfo.capPassThrough)
                ps2_service_notify_device_removed(sPassthroughDevice);

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


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


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


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


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

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

                case MS_READ_TOUCHPAD:
                        TRACE("SYNAPTICS: MS_READ get event\n");
                        if (user_memcpy(&read.timeout, &(((touchpad_read*)buffer)->timeout),
                                        sizeof(bigtime_t)) != B_OK)
                                return B_BAD_ADDRESS;
                        if ((status = get_synaptics_movment(cookie, &read.u.touchpad, read.timeout)) != B_OK)
                                return status;
                        read.event = MS_READ_TOUCHPAD;
                        return user_memcpy(buffer, &read, sizeof(read));

                default:
                        TRACE("SYNAPTICS: unknown opcode: %" B_PRIu32 "\n", op);
                        return B_DEV_INVALID_IOCTL;
        }
}


int32
synaptics_handle_int(ps2_dev *dev)
{
        synaptics_cookie *cookie = (synaptics_cookie*)dev->cookie;
        uint8 val;

        val = cookie->dev->history[0].data;

        if ((cookie->packet_index == 0 || cookie->packet_index == 3) && (val & 8) != 0) {
                INFO("SYNAPTICS: bad mouse data %#02x, trying resync\n", val);
                cookie->packet_index = 0;
                return B_UNHANDLED_INTERRUPT;
        }
        if (cookie->packet_index == 0 && val >> 6 != 0x02) {
                TRACE("SYNAPTICS: first package %#02x begins not with bit 1, 0\n", val);
                return B_UNHANDLED_INTERRUPT;
        }
        if (cookie->packet_index == 3 && val >> 6 != 0x03) {
                TRACE("SYNAPTICS: third package %#02x begins not with bit 1, 1\n", val);
                cookie->packet_index = 0;
                return B_UNHANDLED_INTERRUPT;
        }
        cookie->buffer[cookie->packet_index] = val;

        cookie->packet_index++;
        if (cookie->packet_index >= 6) {
                cookie->packet_index = 0;

                // check if package is a pass through package if true pass it
                // too the pass through interrupt handle
                if (sPassthroughDevice->active
                        && sPassthroughDevice->handle_int != NULL
                        && IS_SYN_PT_PACKAGE(cookie->buffer)) {
                        TRACE("SYNAPTICS: forward packet to passthrough device\n");
                        status_t status;

                        sPassthroughDevice->history[0].data = cookie->buffer[1];
                        sPassthroughDevice->handle_int(sPassthroughDevice);
                        sPassthroughDevice->history[0].data = cookie->buffer[4];
                        sPassthroughDevice->handle_int(sPassthroughDevice);
                        sPassthroughDevice->history[0].data = cookie->buffer[5];
                        status = sPassthroughDevice->handle_int(sPassthroughDevice);

                        if (cookie->dev->packet_size == 4) {
                                sPassthroughDevice->history[0].data = cookie->buffer[2];
                                status = sPassthroughDevice->handle_int(sPassthroughDevice);
                        }
                        return status;
                }

                if (packet_buffer_write(cookie->synaptics_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->synaptics_sem, 1, B_DO_NOT_RESCHEDULE);

                return B_INVOKE_SCHEDULER;
        }

        return B_HANDLED_INTERRUPT;
}


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


device_hooks gSynapticsDeviceHooks = {
        synaptics_open,
        synaptics_close,
        synaptics_freecookie,
        synaptics_ioctl,
        synaptics_read,
        synaptics_write,
};