/*
cblsrv is covered by the LGPL:

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.

Copyright (c) 2006 Zoltan Csizmadia <zoltan_csizmadia@yahoo.com>
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
   derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "cblsrv.h"
#include "utils.h"
#include "parport.h"
#include "bits.h"
#include "ft2232jtag.h"

#define SOCK_RECV_RET(s, p, l) \
    if (sock_recv((s), (p), (l)) != (int)(l)) \
        return -1;

#define SOCK_RECV_GOTO(s, p, l) \
    if (sock_recv((s), (p), (l)) != (int)(l)) \
        goto cleanup;

#define SOCK_SEND_RET(s, p, l) \
    if (sock_send((s), (p), (l)) != (int)(l)) \
        return -1;

#define SOCK_SEND_GOTO(s, p, l) \
    if (sock_send((s), (p), (l)) != (int)(l)) \
        goto cleanup;

Globals g;

int client_send_ack(int ack)
{
    return sock_send(g.client, ack ? &yes8 : &no8, 1) != 1 ? -1 : 0;
}

int do_cmd_done()
{
    tracef(3, "CMD_DONE\n");
    return client_send_ack(ACK_OK);
}

int do_cmd_set_cable_option()
{
    unsigned int len;
    int ack;
    char option_name[128];
    char option_value[128];

    tracef(3, "CMD_SET_CABLE_OPTION\n");

    // Option name length
    SOCK_RECV_RET(g.client, &len, sizeof(len));
    if (len)
    {
        // Option name
        if (len > sizeof(option_name))
            return -1;
        SOCK_RECV_RET(g.client, option_name, len);
        option_name[len] = 0;
    }
    
    // Option value length
    SOCK_RECV_RET(g.client, &len, sizeof(len));
    if (len)
    {
        // Option name
        if (len > sizeof(option_value))
            return -1;
        SOCK_RECV_RET(g.client, option_value, len);
        option_value[len] = 0;
    }

    ack = (g.current_cable->set_option(option_name, option_value) == cable::res_success) ? ACK_OK : ACK_ERR;
    
    return client_send_ack(ack);
}

int do_cmd_get_cable_option()
{
    unsigned int len;
    char option_name[128];
    char option_value[128];

    tracef(3, "CMD_GET_CABLE_OPTION\n");

    // Option name length
    SOCK_RECV_RET(g.client, &len, sizeof(len));
    if (len)
    {
        // Option name
        if (len > sizeof(option_name))
            return -1;
        SOCK_RECV_RET(g.client, option_name, len);
        option_name[len] = 0;
    }

    if (g.current_cable->get_option(option_name, option_value, sizeof(option_value)) != cable::res_success)
        strcpy(option_value, "not_supported");
    
    len = strlen(option_value);
    SOCK_SEND_RET(g.client, &len, sizeof(len));
    if (len)
        SOCK_SEND_RET(g.client, option_value, len);

    return 0;
}

int do_cmd_is_connected()
{
    u8 val8;
    tracef(3, "CMD_IS_CONNECTED\n");
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    return client_send_ack(ACK_OK);
}

int do_cmd_read()
{
    u32 val;
    u8 val8;
    int mode, rlen_bits;
    bits& last_rbuff = g.current_cable->get_last_rbuff();
    
    // Mode
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    mode = val8;
    
    // Number of bits
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    rlen_bits = val;

    tracef(3, "CMD_READ mode=0x%02X read=%d\n", mode, rlen_bits);

    if (rlen_bits != last_rbuff.get_len())
    {
        tracef(2, "rlen mismatch (%d!=%d)!\n", rlen_bits, last_rbuff.get_len());
        client_send_ack(ACK_ERR);
        return -1;
    }

    if (client_send_ack(ACK_OK) < 0)
        return -1;

    SOCK_SEND_RET(
        g.client, 
        last_rbuff.get_data(), 
        last_rbuff.get_len_bytes());

    // Clear current read buffer
    last_rbuff.clear();
    
    return 0;
}

int do_cmd_write()
{
    int rc = -1;
    u32 val;
    u8 val8;
    int mode;
    int wlen_bits, rlen_bits, wlen_bytes, rlen_bytes;
    bits wbuff, wmask;
    bits rbuff, rmask;


    // Mode
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    mode = val8;

    // Number of bits to write
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    wlen_bits = val;
    wlen_bytes = (wlen_bits + 7) / 8;

    if (wbuff.init(wlen_bits) < 0 ||
        wmask.init(wlen_bits) < 0)
    {
        tracef(1, "wbuff alloc failed!\n");
        goto cleanup;
    }

    // Write buffer
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    if (val8)
        SOCK_RECV_RET(g.client, wbuff.get_data(), wlen_bytes);
    
    // Write mask
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    if (val8)
        SOCK_RECV_RET(g.client, wmask.get_data(), wlen_bytes);
    
    // Number of bits to read
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    rlen_bits = val;
    rlen_bytes = (rlen_bits + 7) / 8;

    if (rbuff.init(rlen_bits) < 0 ||
        rmask.init(rlen_bits) < 0)
    {
        tracef(1, "rbuff alloc failed!\n");
        goto cleanup;
    }

    // Read buffer
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    if (val8)
        SOCK_RECV_RET(g.client, rbuff.get_data(), rlen_bytes);
    
    // Read mask
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    if (val8)
        SOCK_RECV_RET(g.client, rmask.get_data(), rlen_bytes);
    tracef(3, "CMD_WRITE mode=0x%02X write=%d read=%d\n", mode, wlen_bits, rlen_bits);

    if (rlen_bits && wlen_bits != rlen_bits)
    {
        tracef(1, "??? wlen_bits != rlen_bits (%d != %d)???\n", wlen_bits, rlen_bits);
        goto cleanup;
    }

    rc = g.current_cable->write(mode, wbuff, wmask, rbuff, rmask);
    
cleanup:

    client_send_ack(rc < 0 ? ACK_ERR : ACK_OK);

    return rc;
}

int do_cmd_set_pin()
{
    u32 val;
    int pin, value;

    // Pin
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    pin = val;
    
    // Value
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    value = val;

    tracef(3, "CMD_SET_PIN pin=%d count=%d\n", pin, value);

    switch (pin)
    {
    // TCK
    case 12:
        g.current_cable->set_tck(value);
        break;

    // TMS
    case 13:
        g.current_cable->set_tms(value);
        break;

    // Unknown
    default:
        return client_send_ack(ACK_ERR);
    }

    return client_send_ack(ACK_OK);
}

int do_cmd_pulse_pin()
{
    u32 val;
    int pin, value;
    
    // Pin
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    pin = val;

    // Count
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    value = val;

    tracef(3, "CMD_PULSE_PIN pin=%d count=%d\n", pin, value);

    switch (pin)
    {
    // TCK
    case 12:
        g.current_cable->pulse_tck(value);
        break;

    // Unknown
    default:
        return client_send_ack(ACK_ERR);
    }

    return client_send_ack(ACK_OK);
}

int do_cmd_start_operation()
{
    u32 val;
    tracef(3, "CMD_START_OPERATION\n");
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    return client_send_ack(ACK_OK);
}

int do_cmd_navigate_tap()
{
    u8 val8;
    int from, to;

    // From
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    from = val8;
    
    // To
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    to = val8;

    tracef(3, "CMD_NAVIGATE_TAP from=%d to=%d\n", from, to);

    return client_send_ack((g.current_cable->state_transit(from, to) == cable::res_success) ? ACK_OK : ACK_ERR);
}

int do_cmd_wait_time()
{
    u32 val;
    u8 val8;
    int us, flush;
    
    // Time in us
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    us = val;
    // Flush
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    flush = val;
    
    tracef(3, "CMD_WAIT_TIME us=%d flush=%d\n", us, flush);
    
    sleep_us(us);
    
    return client_send_ack(ACK_OK);
}

int do_cmd_wait_tck()
{
    u32 val;
    int count;
    
    // Count
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    count = val;
    
    tracef(3, "CMD_WAIT_TCK count=%d\n", count);
    
    g.current_cable->pulse_tck(count);
    
    return client_send_ack(ACK_OK);
}

int do_msg_commands()
{
    u8 cmd;
    u32 val;
    
    tracef(3, "MSG_COMMANDS\n");

    SOCK_RECV_RET(g.client, &val, sizeof(val)); // ?
    SOCK_RECV_RET(g.client, &val, sizeof(val)); // ?

    if (g.current_cable->open() < 0)
    {
        tracef(1, "Failed to open cable!\n");
        client_send_ack(ACK_ERR); 
        return -1;
    }

    if (client_send_ack(ACK_OK) < 0)
        return -1;
    
    do
    {
        // Command
        SOCK_RECV_GOTO(g.client, &cmd, sizeof(cmd));

        switch (cmd)
        {
        case CMD_DONE:
            do_cmd_done();
            break;

        case CMD_SET_CABLE_OPTION:
            do_cmd_set_cable_option();
            break;

        case CMD_GET_CABLE_OPTION:
            do_cmd_get_cable_option();
            break;

        case CMD_IS_CONNECTED:
            do_cmd_is_connected();
            break;

        case CMD_READ:
            do_cmd_read();
            break;

        case CMD_WRITE:
            do_cmd_write();
            break;

        case CMD_SET_PIN:
            do_cmd_set_pin();
            break;

        case CMD_PULSE_PIN:
            do_cmd_pulse_pin();
            break;

        case CMD_START_OPERATION:
            do_cmd_start_operation();
            break;

        case CMD_NAVIGATE_TAP:
            do_cmd_navigate_tap();
            break;

        case CMD_WAIT_TIME:
            do_cmd_wait_time();
            break;

        case CMD_WAIT_TCK:
            do_cmd_wait_tck();
            break;
                    
        default:
            tracef(3, "??? CMD_0x%X ???\n", cmd);

        }
    } while (cmd != CMD_DONE);

cleanup:

    g.current_cable->close();
    
    return 0;
}

int do_msg_close_cable()
{
    u8 val8;
    tracef(3, "MSG_CLOSE_CABLE\n");
    SOCK_RECV_RET(g.client, &val8, sizeof(val8));
    return client_send_ack(ACK_OK);
}

int do_msg_get_info()
{
    u32 val;

    tracef(3, "MSG_GET_INFO name=\"%s\" port=%d speed=%d type=\"%s\"\n",
        g.cable_name, g.cable_port, g.cable_speed, g.cable_type);

    SOCK_SEND_RET(g.client, &yes8, sizeof(yes8));

    val = strlen(g.cable_name);
    SOCK_SEND_RET(g.client, &val, sizeof(val));
    if (val)
        SOCK_SEND_RET(g.client, g.cable_name, val);
    
    SOCK_SEND_RET(g.client, &g.cable_port, sizeof(g.cable_port));
    SOCK_SEND_RET(g.client, &g.cable_speed, sizeof(g.cable_speed));
    
    val = strlen(g.cable_type);
    SOCK_SEND_RET(g.client, &val, sizeof(val));
    if (val)
        SOCK_SEND_RET(g.client, g.cable_type, val);
    
    u32 trailer[4] = {0};
    SOCK_SEND_RET(g.client, trailer, sizeof(trailer));

    return 0;
}

int do_msg_check_server()
{
    tracef(3, "MSG_CHECK_SERVER\n");
    return client_send_ack(ACK_OK);
}

int do_msg_set_cable_mode()
{
    u32 val;
    u8 val8;

    SOCK_RECV_RET(g.client, &val, sizeof(val));
    if (val)
        SOCK_RECV_RET(g.client, g.cable_name, val);
    g.cable_name[val] = 0;

    SOCK_RECV_RET(g.client, &g.cable_port, sizeof(g.cable_port));
    SOCK_RECV_RET(g.client, &g.cable_speed, sizeof(g.cable_speed));
    
    SOCK_RECV_RET(g.client, &val, sizeof(val));
    if (val){
      SOCK_RECV_RET(g.client, g.cable_type, val);
      g.cable_type[val] = 0;
    }
    
    SOCK_RECV_RET(g.client, &val8, sizeof(val8)); //?

    tracef(3, "MSG_SET_CABLE_MODE name=\"%s\" port=%d speed=%d type=\"%s\"\n",
        g.cable_name, g.cable_port, g.cable_speed, g.cable_type);

    return client_send_ack(ACK_OK);

}

//[[nakatomo]]
int do_msg_0x06()
{
	tracef( 3, "MSG_0x06\n" );

	// MSG 0x06 is followed by some parameter bytes
	// I will skip them...
	//sock_recv( ... );

	return client_send_ack( ACK_OK );
}

int client_connection()
{
    u8 msg;
    int rc = -1;

    // Set timeout
    // It may be useful to  comment this out when debugging
    if (sock_set_timeout(2000, 2000) < 0)
        goto cleanup;
    
    // MessageID
    SOCK_RECV_GOTO(g.client, (char*)&msg, 1);

    tracef(3, "Message ID = 0x%02X\n", msg);

    // Cable Mode
    SOCK_RECV_GOTO(g.client, &g.cable_mode, 1);
    
    tracef(3, "Cable Mode = 0x%02X\n", g.cable_mode);

    // Process Message
    switch (msg)
    {
    case MSG_COMMANDS:
        do_msg_commands();
        break;

    case MSG_CLOSE_CABLE:
        do_msg_close_cable();
        break;

    case MSG_GET_INFO:
        do_msg_get_info();
        break;

    case MSG_CHECK_SERVER:
        do_msg_check_server();
        break;

    case MSG_SET_CABLE_MODE:
        do_msg_set_cable_mode();
        break;
    
    case MSG_0x06: //[[nakatomo]]
      // unknown message; only send ack
      do_msg_0x06();
      break;

    default:
        tracef(0, "??? MSG_0x%X ???\n", msg);
        goto cleanup;
    }

    rc = 0;

cleanup:

    closesocket(g.client);
    g.client = -1;
    
    return rc;
}

cable* create_cable(const char* addr)
{
    cable* cbl = NULL;
    unsigned int i;
    char name[256];
    const char* param;

    // Name
    for (i = 0; i < sizeof(name) - 1 && *addr && *addr != ':'; i++)
        name[i] = *addr++;
    name[i] = 0;

    // Param
    param = *addr == ':' ? addr + 1 : NULL;
    
    // Xilinx Parallel III
    if (strcmp(name, "dlc5") == 0)
        cbl = new dlc5(param);
    else
    // Altera Byte Blaster
    if (strcmp(name, "bb") == 0)
        cbl = new byte_blaster(param);
#ifdef USE_FT2232JTAG
    else
    // FT2232 Based JTAG cable
    if (strcmp(name, "amontec") == 0){
      cbl = new AmontecJTAGKey(param);
//#if defined(IMPACT_VERSION) && (IMPACT_VERSION < 100102)
      strcpy(g.cable_type, "Parallel III");
    
      //g.cable_speed = 0;
//#endif
    }
#endif

    return cbl;
}

void usage()
{
    printf("Usage: cblsrv [-d level] [-p port] [-c type[:addr]]\n");
    printf("    level     Debug level (0-3). (Default=1)\n");
    printf("    port      Server port (default=2000)\n");
    printf("    type      Cable type:\n");
    printf("                  dlc5     Xilinx Parallel III\n");
    printf("                  bb       Altera ByteBlaster\n");
#ifdef USE_FT2232JTAG
    printf("                  amontec  Amontec JTAGKey (FT2232C)\n");
#endif
    printf("\n");
    printf("E.g: cblsrv -d 3 -c dlc5:0x378\n");
#if !defined(WIN32) && !defined(__CYGWIN__)
    printf("     cblsrv -d 3 -p 2000 -c bb:/dev/parport0\n");
#endif
}

int init(int argc, char** argv)
{
    int i;
    char* cable_addr = "dlc5";
    char cable_desc[256];
    char* tmp;
    
    // Default
    memset(&g, 0, sizeof(g));
    g.trace_level = 1;
    g.server = -1;
    g.client = -1;
    g.cable_port = -1;
    g.server_port = CBLSRV_DEFAULT_PORT;
    strcpy(g.cable_name, "NONE");

    if (sock_init() < 0)
        return -1;
    
    for (i = 0; i < argc; i++)
    {
#ifdef WIN32
        if (argv[i][0] == '-' || argv[i][0] == '/')
#else
        if (argv[i][0] == '-')
#endif
        {
            // Debug Level
            if (strcmp(argv[i] + 1, "d") == 0)
            {
                g.trace_level = strtol(argv[++i], &tmp, 0);
                if (*tmp != 0 || g.trace_level < 0)
                {
                    printf("Invalid debug level!\n");
                    return -1;
                }
            }
            // Server port
            if (strcmp(argv[i] + 1, "p") == 0)
            {
                g.server_port = (u16)strtol(argv[++i], NULL, 0);
                if (g.server_port == 0)
                {
                    printf("Invalid port!\n");
                    return -1;
                }
            }
            // Cable definition
            if (strcmp(argv[i] + 1, "c") == 0)
                cable_addr = argv[++i];
            else
            // Help
            if (strcmp(argv[i] + 1, "?") == 0 ||
                strcmp(argv[i] + 1, "h") == 0 ||
                strcmp(argv[i] + 1, "help") == 0)
            {
                usage();
                return -1;
            }
        }
    }

    // Create cable
    g.current_cable = create_cable(cable_addr);
    if (g.current_cable == NULL)
    {
        printf("Invalid cable definition!\n");
        return -1;
    }
    g.current_cable->get_desc(cable_desc, sizeof(cable_desc));
    printf("Cable is \'%s\'\n", cable_desc);
    
    return 0;
}

int deinit()
{
    if (g.server >= 0)
    {
        closesocket(g.server);
        g.server = -1;
    }

    if (g.current_cable)
    {
        g.current_cable->close();
        delete g.current_cable;
        g.current_cable = NULL;
    }

    sock_deinit();
    return 0;
}

int main(int argc, char** argv)
{
    int rc = -1;
    struct sockaddr_in client_addr;
    socklen_t addr_len;

    printf("Cable Server %d.%d for Xilinx Impact 8.2i (%s, %s)\n", 
        VERSION_MAJOR, VERSION_MINOR, __DATE__, __TIME__);
    printf("Copyright (c) 2006, Zoltan Csizmadia (zoltan_csizmadia@yahoo.com)\n\n");
    printf("and modified by fenrir for amontec JTAGKey support.\n\n");
    
    if (init(argc, argv) < 0)
        goto cleanup;

    tracef(1, "\nHit CTRL+C to exit program.\n");
    tracef(1, "Be sure to disconnect cable from Impact (Output/Cable disconnect),\n");
    tracef(1, "otherwise Impact will crash!\n");
    
    // Create server socket
    g.server = sock_create_tcp_server(g.server_port);
    if (g.server < 0)
        goto cleanup;

    // Listen for incoming connections
    rc = listen(g.server, SOMAXCONN); 
    if (rc < 0)
    {
        tracef(1, "listen() failed!\n");
        goto cleanup;
    }

    while(!g.exit_program)
    {
        tracef(2, "Waiting for a connection ...\n");
        
        addr_len = sizeof(client_addr);
        g.client = accept(g.server, (struct sockaddr *)&client_addr, &addr_len);
        if (g.client < 0)
        {
            tracef(1, "accept() failed!\n");
            continue;
        }

        tracef(2, "Accepted client: %s:%d\n", 
            inet_ntoa(client_addr.sin_addr), 
            ntohs(client_addr.sin_port));

        // Handle connection
        client_connection();
    }

    rc = 0;

cleanup:

    deinit();

    return rc;
}