/*
 * Copyright 2008, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              François Revol, revol@free.fr
 * 
 * Copyright 2005, François Revol.
 */

/*
        Description: Implements a tty on top of the parallel port, 
                                 using PLIP-like byte-by-byte protocol.
                                 Low level stuff.
*/


#include <Drivers.h>
//#include <parallel_driver.h>
#include <KernelExport.h>
#include <driver_settings.h>
#include <OS.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <ISA.h>

//XXX: move to Jamfile when adding driver
#define _BUILDING_kernel 1

#if _BUILDING_kernel
#include <debug.h>
#endif

#include "laplinkll.h"

enum {
        st_sync = 0, // syncing...
        st_lsb,
        st_msb,
        st_error
};

static isa_module_info *sISAModule;

#pragma mark // raw access

static inline uint8 read_status(uint32 port)
{
        uint8 val;
        val = sISAModule->read_io_8(port+1);
        return val;
}

static inline void write_control(uint32 port, uint8 val)
{
        sISAModule->write_io_8(port+2, val);
}

static inline void write_data(uint32 port, uint8 val)
{
        sISAModule->write_io_8(port, val);
}

#pragma mark // framing

status_t ll_send_sof(laplink_state *st)
{
        uint8 v;
        int tries = LPTSOFTRIES;
        if (st->rstate != st_sync || st->wstate != st_sync)
                return B_TIMED_OUT;
        // check for idle bus
        if ((read_status(st->port) & 0xf8) != 0x80)
                return B_TIMED_OUT;
        // raise ACK
        write_data(st->port, 0x08);
        do {
                spin(LPTSPIN);
                v = read_status(st->port);
                if (st->rstate != st_sync)
                        return B_TIMED_OUT;
                if (tries-- == 0)
                        return B_TIMED_OUT;
        } while (!(v & 0x08));
        st->wstate = st_lsb;
        return B_OK;
}

status_t ll_check_sof(laplink_state *st)
{
        uint8 v;
        if (st->rstate != st_sync || st->wstate != st_sync)
                return EINTR;
        v = read_status(st->port);
        if ((v & 0xf8) != 0xc0)
                return EINTR;
        return B_OK;
}

status_t ll_ack_sof(laplink_state *st)
{
        write_data(st->port, 0x01); // ack the sof
        st->rstate = st_lsb;
        return B_OK;
}

status_t ll_send_eof(laplink_state *st)
{
        /*
        if (st->rstate != st_sync || st->wstate != st_sync)
                return B_TIMED_OUT;
        */
        st->rstate = st_sync;
        st->wstate = st_sync;
        write_data(st->port, 0x00);
        return B_OK;
}

#pragma mark // nibbles

status_t ll_send_lnibble(laplink_state *st, uint8 v)
{
        int tries = LPTNIBTRIES;
        uint8 s;
        if (st->rstate != st_sync)
                goto err;
        if (st->wstate != st_lsb)
                goto err;
        write_data(st->port, v & 0x0f);
        spin(10);
        write_data(st->port, (v & 0x0f) | 0x10);
        // wait for ack
        do {
                s = read_status(st->port);
                if (tries-- == 0)
                        goto err;
                spin(LPTSPIN);
        } while (s & 0x80);
        st->wstate = st_msb;
        return B_OK;
err:
        st->wstate = st_sync;
        return B_TIMED_OUT;
}

status_t ll_send_mnibble(laplink_state *st, uint8 v)
{
        int tries = LPTNIBTRIES;
        uint8 s;
        if (st->rstate != st_sync)
                goto err;
        if (st->wstate != st_msb)
                goto err;
        write_data(st->port, (v >> 4) | 0x10);
        spin(10);
        write_data(st->port, (v >> 4));
        // wait for ack
        do {
                s = read_status(st->port);
                if (tries-- == 0)
                        goto err;
                spin(LPTSPIN);
        } while (!(s & 0x80));
        st->wstate = st_lsb;//st_sync;
        return B_OK;
err:
        st->wstate = st_sync;
        return B_TIMED_OUT;
}

status_t ll_wait_lnibble(laplink_state *st, uint8 *v)
{
        int tries = LPTNIBTRIES;
        uint8 s;
        // wait for data
        do {
                s = read_status(st->port);
                if (tries-- == 0)
                        goto err;
                spin(LPTSPIN);
        } while ((s & 0x80) || (s != read_status(st->port)));
        // get the nibble
        *v = (s >> 3) & 0x0f;
        st->rstate = st_msb;
        // tell we got that one
        write_data(st->port, 0x10);
        return B_OK;
err:
        st->rstate = st_sync;
        return B_TIMED_OUT;
}

status_t ll_wait_mnibble(laplink_state *st, uint8 *v)
{
        int tries = LPTNIBTRIES;
        uint8 s;
        // wait for data
        do {
                s = read_status(st->port);
                if (tries-- == 0)
                        goto err;
                spin(LPTSPIN);
        } while (!(s & 0x80) || (s != read_status(st->port)));
        // get the nibble
        *v |= (s << (4-3)) & 0xf0;
        st->rstate = st_sync;
        // tell we got that one
        write_data(st->port, 0x00);
        return B_OK;
err:
        st->rstate = st_sync;
        return B_TIMED_OUT;
}

#pragma mark // byte mode

status_t ll_send_byte(laplink_state *st, uint8 v)
{
        status_t err;
        err = ll_send_sof(st);
        if (!err)
                err = ll_send_lnibble(st, v);
        if (!err)
                err = ll_send_mnibble(st, v);
        if (!err)
                err = ll_send_eof(st);
        return err;
}

status_t ll_check_byte(laplink_state *st, uint8 *v)
{
        status_t err;
        *v = 0;
        err = ll_check_sof(st);
        if (err)
                return err;
        err = ll_ack_sof(st);
        if (!err)
                err = ll_wait_lnibble(st, v);
        if (!err)
                err = ll_wait_mnibble(st, v);
        if (!err)
                err = ll_send_eof(st);
        return err;
}

status_t ll_wait_byte(laplink_state *st, uint8 *v)
{
        status_t err;
        do {
                spin(LPTSPIN);
                err = ll_check_byte(st, v);
        } while (err < B_OK);// } while (err == B_TIMED_OUT);
        return err;
}

#pragma mark // frame mode

// unframed
static inline status_t ll_send_byte_uf(laplink_state *st, uint8 v)
{
        status_t err;
        err = ll_send_lnibble(st, v);
        if (!err)
                err = ll_send_mnibble(st, v);
        return err;
}

status_t ll_get_byte_uf(laplink_state *st, uint8 *v)
{
        status_t err;
        *v = 0;
        err = ll_wait_lnibble(st, v);
        if (!err)
                err = ll_wait_mnibble(st, v);
        return err;
}

status_t ll_send_frame(laplink_state *st, const uint8 *buff, size_t *len)
{
        status_t err;
        uint16 pktlen = *len;
        uint8 cksum = 0;
        *len = 0;
        err = ll_send_sof(st);
        if (err)
                return err;
        err = ll_send_byte_uf(st, pktlen & 0xff);
        if (err)
                goto err;
        err = ll_send_byte_uf(st, pktlen >> 8);
        if (err)
                goto err;
        for (*len = 0; *len < pktlen; (*len)++) {
                err = ll_send_byte_uf(st, buff[*len]);
                if (err)
                        goto err;
                cksum += buff[*len];
        }
        err = ll_send_byte_uf(st, cksum);
        if (err)
                goto err;
        
        /*err =*/ ll_send_eof(st);
err:
        
        if (err) { // back to idle
                *len = 0;
                ll_send_eof(st);
        }
        return err;
}

status_t ll_check_frame(laplink_state *st, uint8 *buff, size_t *len)
{
        status_t err;
        uint16 pktlen = 0;
        uint16 wanted;
        uint8 cksum = 0;
        uint8 byte;
        int i;
        err = ll_check_sof(st);
        if (err)
                goto err;
        err = ll_ack_sof(st);
        if (err)
                goto err;
        // pktlen
        err = ll_get_byte_uf(st, &byte);
        if (err)
                goto err;
        pktlen = byte;
        err = ll_get_byte_uf(st, &byte);
        if (err)
                goto err;
        pktlen |= byte << 8;
        cksum = 0;
        /*if (pktlen > *len) {
                dprintf("laplink: check_frame: packet truncated from %d to %d\n", pktlen, *len);
        }*/
        wanted = MIN(pktlen, *len);
        for (*len = 0; (*len < pktlen); (*len)++) {
                err = ll_get_byte_uf(st, &byte);
                if (err)
                        goto err;
                if (*len < wanted)
                        buff[*len] = byte;
                cksum += byte;
        }
        err = ll_get_byte_uf(st, &byte);
        if (err)
                goto err;
        /*
        if (cksum != byte) {
                dprintf("laplink: check_frame: wrong cksum\n");
        }*/
err:
        ll_send_eof(st);
        return err;
}

status_t ll_wait_frame(laplink_state *st, uint8 *buff, size_t *len)
{
        status_t err;
        do {
                spin(LPTSPIN);
                err = ll_check_frame(st, buff, len);
        } while (err < B_OK);// } while (err == B_TIMED_OUT);
        return err;
}

#pragma mark // kdebug io handler

#if _BUILDING_kernel
#define BUFFSZ 256

static laplink_state llst;
static char laplink_in_buf[BUFFSZ];
static char *laplink_in_ptr;
static size_t laplink_in_avail;
static char laplink_out_buf[BUFFSZ];

//XXX: cleanup
static status_t debug_init_laplink(void *kernel_settings)
{
        (void)kernel_settings;
        llst.port = LPTBASE;
        llst.rstate = st_sync;
        llst.wstate = st_sync;
        laplink_in_ptr = laplink_in_buf;
        laplink_in_avail = 0;
        return B_OK;
}

static int debug_write_laplink(int f, const char *buf, int count)
{
        status_t err;
        size_t len;
        int tries;
        int i, prev = 0;
        
        // fix up CR LF issues... to a local buffer (which will get truncated)
        if (count > 1) {
                for (i = 0; (i < BUFFSZ-1) && count; i++, buf++, count--) {
                        if ((*buf == '\n') && (prev != '\r'))
                                laplink_out_buf[i++] = '\r';
                        laplink_out_buf[i] = *buf;
                        prev = *buf;
                }
                count = i;
                buf = laplink_out_buf;
        }
        
        tries = 5;
        do {
                len = count;
                err = ll_send_frame(&llst, (const uint8 *)buf, &len);
        } while (err && tries--);
        if (err)
                return 0;
        return len;
}

static int debug_read_laplink(void)
{
        status_t err = B_OK;
        while (laplink_in_avail < 1) {
                laplink_in_avail = BUFFSZ;
                laplink_in_ptr = laplink_in_buf;
                err = ll_wait_frame(&llst, (uint8 *)laplink_in_buf, &laplink_in_avail);
                if (err)
                        laplink_in_avail = 0;
        }
        laplink_in_avail--;
        return *laplink_in_ptr++;
}


static int
debugger_puts(const char *s, int32 length)
{
        return debug_write_laplink(0, s, (int)length);
}


static status_t
std_ops(int32 op, ...)
{
        void *handle;
        bool load = true;//false;

        switch (op) {
        case B_MODULE_INIT:
                handle = load_driver_settings("kernel");
                if (handle) {
                        load = get_driver_boolean_parameter(handle,
                                "laplinkll_debug_output", load, true);
                        unload_driver_settings(handle);
                }
                if (load) {
                        if (get_module(B_ISA_MODULE_NAME, (module_info **)&sISAModule) < B_OK)
                                return B_ERROR;
                        debug_init_laplink(NULL);
                }
                return load ? B_OK : B_ERROR;
        case B_MODULE_UNINIT:
                put_module(B_ISA_MODULE_NAME);
                return B_OK;
        }
        return B_BAD_VALUE;
}


static struct debugger_module_info sModuleInfo = {
        {
                "debugger/laplinkll/v1",
                0,
                &std_ops
        },
        NULL,
        NULL,
        debugger_puts,
        NULL
};

module_info *modules[] = { 
        (module_info *)&sModuleInfo,
        NULL
};


#endif