/*
 * Copyright 2004-2009 Haiku, Inc.
 * Distributed under the terms of the MIT License.
 *
 * Authors (in chronological order):
 *              Stefano Ceccherini (burton666@libero.it)
 *              Axel Dörfler, axeld@pinc-software.de
 *      Marcus Overhagen <marcus@overhagen.de>
 */

/*! PS/2 bus manager */


#include <string.h>

#include "ps2_common.h"
#include "ps2_service.h"
#include "ps2_dev.h"


//#define TRACE_PS2_COMMON
#ifdef TRACE_PS2_COMMON
#       define TRACE(x...) dprintf(x)
#       define TRACE_ONLY
#else
#       define TRACE(x...)
#       define TRACE_ONLY __attribute__((unused))
#endif


isa_module_info *gIsa = NULL;
bool gActiveMultiplexingEnabled = false;
bool gSetupComplete = false;
mutex gControllerLock;

static int32 sIgnoreInterrupts = 0;


uint8
ps2_read_ctrl(void)
{
        return gIsa->read_io_8(PS2_PORT_CTRL);
}


uint8
ps2_read_data(void)
{
        return gIsa->read_io_8(PS2_PORT_DATA);
}


void
ps2_write_ctrl(uint8 ctrl)
{
        TRACE("ps2: ps2_write_ctrl 0x%02x\n", ctrl);

        gIsa->write_io_8(PS2_PORT_CTRL, ctrl);
}


void
ps2_write_data(uint8 data)
{
        TRACE("ps2: ps2_write_data 0x%02x\n", data);

        gIsa->write_io_8(PS2_PORT_DATA, data);
}


status_t
ps2_wait_read(void)
{
        int i;
        for (i = 0; i < PS2_CTRL_WAIT_TIMEOUT / 50; i++) {
                if (ps2_read_ctrl() & PS2_STATUS_OUTPUT_BUFFER_FULL)
                        return B_OK;
                snooze(50);
        }
        return B_ERROR;
}


status_t
ps2_wait_write(void)
{
        int i;
        for (i = 0; i < PS2_CTRL_WAIT_TIMEOUT / 50; i++) {
                if (!(ps2_read_ctrl() & PS2_STATUS_INPUT_BUFFER_FULL))
                        return B_OK;
                snooze(50);
        }
        return B_ERROR;
}


//      #pragma mark -


void
ps2_flush(void)
{
        int i;

        mutex_lock(&gControllerLock);
        atomic_add(&sIgnoreInterrupts, 1);

        for (i = 0; i < 64; i++) {
                uint8 ctrl;
                uint8 data TRACE_ONLY;
                ctrl = ps2_read_ctrl();
                if (!(ctrl & PS2_STATUS_OUTPUT_BUFFER_FULL))
                        break;
                data = ps2_read_data();
                TRACE("ps2: ps2_flush: ctrl 0x%02x, data 0x%02x (%s)\n", ctrl, data, (ctrl & PS2_STATUS_AUX_DATA) ? "aux" : "keyb");
                snooze(100);
        }

        atomic_add(&sIgnoreInterrupts, -1);
        mutex_unlock(&gControllerLock);
}


static status_t
ps2_selftest()
{
        status_t res;
        uint8 in;
        res = ps2_command(PS2_CTRL_SELF_TEST, NULL, 0, &in, 1);
        if (res != B_OK || in != 0x55) {
                INFO("ps2: controller self test failed, status 0x%08" B_PRIx32 ", data "
                        "0x%02x\n", res, in);
                return B_ERROR;
        }
        return B_OK;
}


static status_t
ps2_setup_command_byte(bool interruptsEnabled)
{
        status_t res;
        uint8 cmdbyte;

        res = ps2_command(PS2_CTRL_READ_CMD, NULL, 0, &cmdbyte, 1);
        TRACE("ps2: get command byte: res 0x%08" B_PRIx32 ", cmdbyte 0x%02x\n",
                res, cmdbyte);
        if (res != B_OK)
                cmdbyte = 0x47;

        cmdbyte |= PS2_BITS_TRANSLATE_SCANCODES;
        cmdbyte &= ~(PS2_BITS_KEYBOARD_DISABLED | PS2_BITS_MOUSE_DISABLED);

        if (interruptsEnabled)
                cmdbyte |= PS2_BITS_KEYBOARD_INTERRUPT | PS2_BITS_AUX_INTERRUPT;
        else
                cmdbyte &= ~(PS2_BITS_KEYBOARD_INTERRUPT | PS2_BITS_AUX_INTERRUPT);

        res = ps2_command(PS2_CTRL_WRITE_CMD, &cmdbyte, 1, NULL, 0);
        TRACE("ps2: set command byte: res 0x%08" B_PRIx32 ", cmdbyte 0x%02x\n",
                res, cmdbyte);

        return res;
}


static status_t
ps2_setup_active_multiplexing(bool *enabled)
{
        status_t res;
        uint8 in, out;

        // Disable the keyboard port to avoid any interference with the keyboard
        ps2_command(PS2_CTRL_KEYBOARD_DISABLE, NULL, 0, NULL, 0);

        out = 0xf0;
        res = ps2_command(PS2_CTRL_AUX_LOOPBACK, &out, 1, &in, 1);
        if (res)
                goto fail;
        // Step 1, if controller is good, in does match out.
        // This test failes with MS Virtual PC.
        if (in != out)
                goto no_support;

        out = 0x56;
        res = ps2_command(PS2_CTRL_AUX_LOOPBACK, &out, 1, &in, 1);
        if (res)
                goto fail;
        // Step 2, if controller is good, in does match out.
        if (in != out)
                goto no_support;

        out = 0xa4;
        res = ps2_command(PS2_CTRL_AUX_LOOPBACK, &out, 1, &in, 1);
        if (res)
                goto fail;
        // Step 3, if the controller doesn't support active multiplexing,
        // then in data does match out data (0xa4), else it's version number.
        if (in == out)
                goto no_support;

        // With some broken USB legacy emulation, it's 0xac, and with
        // MS Virtual PC, it's 0xa6. Since current active multiplexing
        // specification version is 1.1 (0x11), we validate the data.
        if (in > 0x9f) {
                TRACE("ps2: active multiplexing v%d.%d detected, but ignored!\n", (in >> 4), in & 0xf);
                goto no_support;
        }

        INFO("ps2: active multiplexing v%d.%d detected\n", (in >> 4), in & 0xf);

        // Additional check to make sure multiplexing is actually working:
        // Send a byte using the local loopback feature. When the byteis read back, it should have the
        // system/error bit set to 0 if active multiplexing is enabled and working.
        // The flow is similar to a ps2_command, but we need to check this specific bit in the middle
        // of the operation (before reading the data byte).
        mutex_lock(&gControllerLock);
        atomic_add(&sIgnoreInterrupts, 1);

        res = ps2_wait_write();
        if (res != B_OK) {
                INFO("ps2: active multiplexing command write check fail: %s\n", strerror(res));
                goto no_support_unlock;
        }
        ps2_write_ctrl(PS2_CTRL_AUX_LOOPBACK);

        res = ps2_wait_write();
        if (res != B_OK) {
                INFO("ps2: active multiplexing data write check fail: %s\n", strerror(res));
                goto no_support_unlock;
        }

        ps2_write_data(0xf0);

        res = ps2_wait_read();

        if (res != B_OK) {
                INFO("ps2: active multiplexing data read check fail: %s\n", strerror(res));
                goto no_support_unlock;
        }

        res = ps2_read_ctrl();
        in = ps2_read_data();

        if (in != 0xf0) {
                INFO("ps2: active multiplexing loopback check fail: %s\n", strerror(res));
                goto no_support_unlock;
        }

        if ((res & 0x25) == 0x25) {
                INFO("ps2: active multiplexing error bit is stuck\n");
                goto no_support_unlock;
        }

        atomic_add(&sIgnoreInterrupts, -1);
        mutex_unlock(&gControllerLock);
        *enabled = true;
        goto done;

no_support_unlock:
        atomic_add(&sIgnoreInterrupts, -1);
        mutex_unlock(&gControllerLock);
no_support:
        TRACE("ps2: active multiplexing not supported\n");
        *enabled = false;

done:
        // Some controllers get upset by the d3 command and will continue data
        // loopback, thus we need to send a harmless command (enable keyboard
        // interface) next.
        // This fixes bug report #1175
        res = ps2_command(PS2_CTRL_KEYBOARD_ENABLE, NULL, 0, NULL, 0);
        if (res != B_OK) {
                INFO("ps2: active multiplexing d3 workaround failed, status 0x%08"
                        B_PRIx32 "\n", res);
        }
        return B_OK;

fail:
        TRACE("ps2: testing for active multiplexing failed\n");
        *enabled = false;
        // this should revert the controller into legacy mode,
        // just in case it has switched to multiplexed mode
        return ps2_selftest();
}


status_t
ps2_command(uint8 cmd, const uint8 *out, int outCount, uint8 *in, int inCount)
{
        status_t res;
        int i;

        mutex_lock(&gControllerLock);
        atomic_add(&sIgnoreInterrupts, 1);

#ifdef TRACE_PS2_COMMON
        TRACE("ps2: ps2_command cmd 0x%02x, out %d, in %d\n", cmd, outCount, inCount);
        for (i = 0; i < outCount; i++)
                TRACE("ps2: ps2_command out 0x%02x\n", out[i]);
#endif

        res = ps2_wait_write();
        if (res == B_OK)
                ps2_write_ctrl(cmd);

        for (i = 0; res == B_OK && i < outCount; i++) {
                res = ps2_wait_write();
                if (res == B_OK)
                        ps2_write_data(out[i]);
                else
                        TRACE("ps2: ps2_command out byte %d failed\n", i);
        }

        for (i = 0; res == B_OK && i < inCount; i++) {
                res = ps2_wait_read();
                if (res == B_OK)
                        in[i] = ps2_read_data();
                else
                        TRACE("ps2: ps2_command in byte %d failed\n", i);
        }

#ifdef TRACE_PS2_COMMON
        for (i = 0; i < inCount; i++)
                TRACE("ps2: ps2_command in 0x%02x\n", in[i]);
        TRACE("ps2: ps2_command result 0x%08" B_PRIx32 "\n", res);
#endif

        atomic_add(&sIgnoreInterrupts, -1);
        mutex_unlock(&gControllerLock);

        return res;
}


//      #pragma mark -


static int32
ps2_interrupt(void* cookie)
{
        uint8 ctrl;
        uint8 data;
        bool error;
        ps2_dev *dev;

        ctrl = ps2_read_ctrl();
        if (!(ctrl & PS2_STATUS_OUTPUT_BUFFER_FULL)) {
                TRACE("ps2: ps2_interrupt unhandled, OBF bit unset, ctrl 0x%02x (%s)\n",
                                ctrl, (ctrl & PS2_STATUS_AUX_DATA) ? "aux" : "keyb");
                return B_UNHANDLED_INTERRUPT;
        }

        if (atomic_get(&sIgnoreInterrupts)) {
                TRACE("ps2: ps2_interrupt ignoring, ctrl 0x%02x (%s)\n", ctrl,
                        (ctrl & PS2_STATUS_AUX_DATA) ? "aux" : "keyb");
                return B_HANDLED_INTERRUPT;
        }

        data = ps2_read_data();

        if ((ctrl & PS2_STATUS_AUX_DATA) != 0) {
                uint8 idx;
                if (gActiveMultiplexingEnabled) {
                        idx = ctrl >> 6;
                        error = (ctrl & 0x04) != 0;
                        TRACE("ps2: ps2_interrupt ctrl 0x%02x, data 0x%02x (mouse %d)\n",
                                ctrl, data, idx);
                } else {
                        idx = 0;
                        error = (ctrl & 0xC0) != 0;
                        TRACE("ps2: ps2_interrupt ctrl 0x%02x, data 0x%02x (aux)\n", ctrl,
                                data);
                }
                dev = &ps2_device[PS2_DEVICE_MOUSE + idx];
        } else {
                TRACE("ps2: ps2_interrupt ctrl 0x%02x, data 0x%02x (keyb)\n", ctrl,
                        data);

                dev = &ps2_device[PS2_DEVICE_KEYB];
                error = (ctrl & 0xC0) != 0;
        }

        dev->history[1] = dev->history[0];
        dev->history[0].time = system_time();
        dev->history[0].data = data;
        dev->history[0].error = error;

        return ps2_dev_handle_int(dev);
}


//      #pragma mark - driver interface


status_t
ps2_init(void)
{
        status_t status;

        TRACE("ps2: init\n");

        status = get_module(B_ISA_MODULE_NAME, (module_info **)&gIsa);
        if (status < B_OK)
                return status;

        mutex_init(&gControllerLock, "ps/2 keyb ctrl");

        ps2_flush();

        status = ps2_dev_init();
        if (status < B_OK)
                goto err1;

        status = ps2_service_init();
        if (status < B_OK)
                goto err2;

        status = install_io_interrupt_handler(INT_PS2_KEYBOARD, &ps2_interrupt,
                NULL, 0);
        if (status)
                goto err3;

        status = install_io_interrupt_handler(INT_PS2_MOUSE, &ps2_interrupt, NULL,
                0);
        if (status)
                goto err4;

        // While this might have fixed bug #1185, we can't do this unconditionally
        // as it obviously messes up many controllers which couldn't reboot anymore
        // after that
        //ps2_selftest();

        // Setup the command byte with disabled keyboard and AUX interrupts
        // to prevent interrupts storm on some KBCs during active multiplexing
        // activation procedure. Fixes #7635.
        status = ps2_setup_command_byte(false);
        if (status) {
                INFO("ps2: initial setup of command byte failed\n");
                goto err5;
        }

        ps2_flush();
        status = ps2_setup_active_multiplexing(&gActiveMultiplexingEnabled);
        if (status) {
                INFO("ps2: setting up active multiplexing failed\n");
                goto err5;
        }

        status = ps2_setup_command_byte(true);
        if (status) {
                INFO("ps2: setting up command byte with enabled interrupts failed\n");
                goto err5;
        }

        if (gActiveMultiplexingEnabled) {
                // The multiplexing spec recommends to leave device 0 unconnected because it saves some
                // confusion with the use of the D3 command which appears as if the replied data was
                // coming from device 0. So we enable it only if it really looks like there is a device
                // connected there.
                if (ps2_dev_command_timeout(&ps2_device[PS2_DEVICE_MOUSE],
                                PS2_CMD_MOUSE_SET_SCALE11, NULL, 0, NULL, 0, 100000) == B_TIMED_OUT) {
                        INFO("ps2: accessing multiplexed mouse port 0 timed out, ignoring it!\n");
                } else {
                        ps2_service_notify_device_added(&ps2_device[PS2_DEVICE_MOUSE]);
                }

                for (int idx = 1; idx <= 3; idx++) {
                        ps2_service_notify_device_added(&ps2_device[PS2_DEVICE_MOUSE + idx]);
                }
                ps2_service_notify_device_added(&ps2_device[PS2_DEVICE_KEYB]);
        } else {
                ps2_service_notify_device_added(&ps2_device[PS2_DEVICE_MOUSE]);
                ps2_service_notify_device_added(&ps2_device[PS2_DEVICE_KEYB]);
        }

        gSetupComplete = true;

        TRACE("ps2: init done!\n");
        return B_OK;

err5:
        remove_io_interrupt_handler(INT_PS2_MOUSE, &ps2_interrupt, NULL);
err4:
        remove_io_interrupt_handler(INT_PS2_KEYBOARD, &ps2_interrupt, NULL);
err3:
        ps2_service_exit();
err2:
        ps2_dev_exit();
err1:
        mutex_destroy(&gControllerLock);
        put_module(B_ISA_MODULE_NAME);
        TRACE("ps2: init failed!\n");
        return B_ERROR;
}


void
ps2_uninit(void)
{
        TRACE("ps2: uninit\n");
        remove_io_interrupt_handler(INT_PS2_MOUSE,    &ps2_interrupt, NULL);
        remove_io_interrupt_handler(INT_PS2_KEYBOARD, &ps2_interrupt, NULL);
        ps2_service_exit();
        ps2_dev_exit();
        mutex_destroy(&gControllerLock);
        put_module(B_ISA_MODULE_NAME);
}