[libsigrok.git] / src / hardware / ipdbg-logic-analyser / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2016 danselmi <da@da>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#ifdef _WIN32
#define _WIN32_WINNT 0x0501
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
//#include <glib.h>
#include <string.h>
#include <unistd.h>
#ifndef _WIN32
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#endif
#include <errno.h>
#include "protocol.h"

#define BUFFER_SIZE 4


#define Start                      0xFE
#define reset                      0xEE
#define IPDBG_LA_ID                0xBB
#define Escape                     0x55


/* Command opcodes */
#define set_trigger                0x00

#define Trigger                    0xF0
#define LA                         0x0F

#define Masks                      0xF1
#define Mask                       0xF3

#define Value                      0xF7

#define Last_Masks                 0xF9
#define Mask_last                  0xFB

#define Value_last                 0xFF

#define Select_Edge_Mask           0xF5
#define Set_Edge_Mask              0xF6

#define delay                      0x1F
#define K_Mauslesen                0xAA


SR_PRIV int sendEscaping(struct ipdbg_org_la_tcp *tcp, char *dataToSend, int length);

SR_PRIV struct ipdbg_org_la_tcp *ipdbg_org_la_new_tcp(void)
{
    struct ipdbg_org_la_tcp *tcp;

    tcp = g_malloc0(sizeof(struct ipdbg_org_la_tcp));

    tcp->address = NULL;
    tcp->port = NULL;
    tcp->socket = -1;

    return tcp;
}

SR_PRIV int ipdbg_org_la_tcp_open(struct ipdbg_org_la_tcp *tcp)
{
    struct addrinfo hints;
    struct addrinfo *results, *res;
    int err;

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    err = getaddrinfo(tcp->address, tcp->port, &hints, &results);

    if (err) {
        sr_err("Address lookup failed: %s:%s: %s", tcp->address, tcp->port,
            gai_strerror(err));
        return SR_ERR;
    }

    for (res = results; res; res = res->ai_next) {
        if ((tcp->socket = socket(res->ai_family, res->ai_socktype,
                        res->ai_protocol)) < 0)
            continue;
        if (connect(tcp->socket, res->ai_addr, res->ai_addrlen) != 0) {
            close(tcp->socket);
            tcp->socket = -1;
            continue;
        }
        break;
    }

    freeaddrinfo(results);

    if (tcp->socket < 0) {
        sr_err("Failed to connect to %s:%s: %s", tcp->address, tcp->port,
                g_strerror(errno));
        return SR_ERR;
    }

    return SR_OK;
}

SR_PRIV int ipdbg_org_la_tcp_send(struct ipdbg_org_la_tcp *tcp, const uint8_t *buf, size_t len)
{
    int out;
    out = send(tcp->socket, (char*)buf, len, 0);

    if (out < 0) {
        sr_err("Send error: %s", g_strerror(errno));
        return SR_ERR;
    }

    if ((unsigned int)out < len) {
        sr_dbg("Only sent %d/%d bytes of data.", out, (int)len);
    }

    return SR_OK;
}

SR_PRIV int ipdbg_org_la_tcp_receive(struct ipdbg_org_la_tcp *tcp, uint8_t *buf, int bufsize)
{
    int received = 0;

    while(received < bufsize)
    {
        int len;

        len = recv(tcp->socket, (char*)(buf+received), bufsize-received, 0);

        if (len < 0) {
            sr_err("Receive error: %s", g_strerror(errno));
            return SR_ERR;
        }
        else
        {
            received += len;
        }
    }

    return received;
}

SR_PRIV int ipdbg_org_la_tcp_close(struct ipdbg_org_la_tcp *tcp)
{
    int ret = SR_ERR;
    if (close(tcp->socket) >= 0)
        ret = SR_OK;

    tcp->socket = -1;

    return ret;
}

SR_PRIV void ipdbg_org_la_tcp_free(struct ipdbg_org_la_tcp *tcp)
{
    g_free(tcp->address);
    g_free(tcp->port);
}

SR_PRIV int ipdbg_org_la_convert_trigger(const struct sr_dev_inst *sdi)
{
    struct ipdbg_org_la_dev_context *devc;
    struct sr_trigger *trigger;
    struct sr_trigger_stage *stage;
    struct sr_trigger_match *match;
    const GSList *l, *m;

    devc = sdi->priv;

    devc->num_stages = 0;
    devc->num_transfers = 0;
    devc->raw_sample_buf = NULL; /// name convert_trigger to init acquisition...
    for (unsigned int i = 0; i < devc->DATA_WIDTH_BYTES; i++) // Hier werden die Trigger-Variabeln 0 gesetzt!
    {
        devc->trigger_mask[i] = 0;
        devc->trigger_value[i] = 0;
        devc->trigger_mask_last[i] = 0;
        devc->trigger_value_last[i] = 0;
        devc->trigger_edge_mask[i] = 0;
    }

    if (!(trigger = sr_session_trigger_get(sdi->session))) //
    {
        return SR_OK;
    }

    for (l = trigger->stages; l; l = l->next)
    {
            stage = l->data;
        for (m = stage->matches; m; m = m->next)
        {
            match = m->data;
            unsigned int byteIndex = (match->channel->index) /8;
            unsigned char matchPattern = 1 << (match->channel->index - 8* byteIndex);
            //zeroTrigger |= matchPattern;
            //sr_err("\n\nzerotrigger:%x\n\n",zeroTrigger);
            //sr_err("\nbyteIndex:%i",byteIndex);
            //sr_err("\nmatch Pattern:%i\n",matchPattern);

            if (!match->channel->enabled)
                /* Ignore disabled channels with a trigger. */
                continue;
            if (match->match == SR_TRIGGER_ONE )
            {
                devc->trigger_value[byteIndex] |= matchPattern;
                devc->trigger_mask[byteIndex] |= matchPattern;
                devc->trigger_mask_last[byteIndex] &= ~matchPattern;
                devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
                //sr_err("\n========ONE MASK===========");

            }
            else if (match->match == SR_TRIGGER_ZERO)
            {
                devc->trigger_value[byteIndex] &= ~matchPattern;
                devc->trigger_mask[byteIndex] |= matchPattern;
                devc->trigger_mask_last[byteIndex] &= ~matchPattern;
                devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
                //sr_err("\n========ZERO MASK===========");
            }
            else if ( match->match == SR_TRIGGER_RISING)
            {
                devc->trigger_value[byteIndex] |= matchPattern;
                devc->trigger_value_last[byteIndex] &= ~matchPattern;
                devc->trigger_mask[byteIndex] |= matchPattern;
                devc->trigger_mask_last[byteIndex] |= matchPattern;
                devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
                //sr_err("\n==========RISING===========");

            }
            else if (match->match == SR_TRIGGER_FALLING )
            {
                devc->trigger_value[byteIndex] &= ~matchPattern;
                devc->trigger_value_last[byteIndex] |= matchPattern;
                devc->trigger_mask[byteIndex] |= matchPattern;
                devc->trigger_mask_last[byteIndex] |= matchPattern;
                devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
                //sr_err("\n========FALlING===========");
            }
            else if (match->match == SR_TRIGGER_EDGE)
            {
                devc->trigger_mask[byteIndex] &= ~matchPattern;
                devc->trigger_mask_last[byteIndex] &= ~matchPattern;
                devc->trigger_edge_mask[byteIndex] |= matchPattern;
            }

        }

    }

    return SR_OK;
}

SR_PRIV int ipdbg_org_la_receive_data(int fd, int revents, void *cb_data)
{
    //sr_err("receive Data0\n");


    const struct sr_dev_inst *sdi;
    struct ipdbg_org_la_dev_context *devc;


    (void)fd;
    (void)revents;

    sdi = (const struct sr_dev_inst *)cb_data;
    if (!sdi)
    {
        return FALSE;
    }
    //sr_err("receive Data1\n");

    if (!(devc = sdi->priv))
    {
        return FALSE;

    }
    //sr_err("receive Data2\n");


    struct ipdbg_org_la_tcp *tcp = sdi->conn;
    struct sr_datafeed_packet packet;
    struct sr_datafeed_logic logic;


    /*sr_warn("---");
    if (devc->num_transfers == 0 && revents == 0)
    { //
        sr_warn("warten auf Eingangsdaten");
        // Ignore timeouts as long as we haven't received anything
        return TRUE;
    }*/

    if (!devc->raw_sample_buf)
    {
        //sr_warn("allocating buffer");
        devc->raw_sample_buf = g_try_malloc(devc->limit_samples*devc->DATA_WIDTH_BYTES);

        if (!devc->raw_sample_buf) {
            sr_warn("Sample buffer malloc failed.");
            return FALSE;
        }

    }


    if (devc->num_transfers < devc->limit_samples_max*devc->DATA_WIDTH_BYTES)
    {
        //sr_err("1");
        unsigned char byte;


        if (ipdbg_org_la_tcp_receive(tcp, &byte, 1) == 1)
        {
            if(devc->num_transfers < devc->limit_samples*devc->DATA_WIDTH_BYTES)
                devc->raw_sample_buf[devc->num_transfers] = byte;
            devc->num_transfers++;
        }

    }
    else
    {
        //sr_err("Received %d bytes", devc->num_transfers);

        //sr_dbg("Received %d bytes.", devc->num_transfers);

        if (devc->delay_value > 0) {
            /* There are pre-trigger samples, send those first. */
            packet.type = SR_DF_LOGIC;
            packet.payload = &logic;
            //logic.length = devc->delay_value-1;
            logic.length = devc->delay_value*devc->DATA_WIDTH_BYTES;
            logic.unitsize = devc->DATA_WIDTH_BYTES;
            logic.data = devc->raw_sample_buf;
            sr_session_send(cb_data, &packet);
        }

        /* Send the trigger. */
        packet.type = SR_DF_TRIGGER;
        sr_session_send(cb_data, &packet);

        /* Send post-trigger samples. */
        packet.type = SR_DF_LOGIC;
        packet.payload = &logic;
        //logic.length = devc->limit_samples - devc->delay_value+1;
        logic.length = (devc->limit_samples - devc->delay_value)*devc->DATA_WIDTH_BYTES;
        logic.unitsize = devc->DATA_WIDTH_BYTES;
        logic.data = devc->raw_sample_buf + devc->delay_value*devc->DATA_WIDTH_BYTES;
        //logic.data = devc->raw_sample_buf + devc->delay_value-1;
        sr_session_send(cb_data, &packet);

        g_free(devc->raw_sample_buf);
        devc->raw_sample_buf = NULL;

        //serial_flush(serial);
        ipdbg_org_la_abort_acquisition(sdi);//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    }

    return TRUE;
}

SR_PRIV int ipdbg_org_la_sendDelay(struct ipdbg_org_la_dev_context *devc, struct ipdbg_org_la_tcp *tcp)
{

    int maxSample;

    maxSample = devc->limit_samples;

    devc->delay_value = (maxSample/100.0) * devc->capture_ratio;
    uint8_t Befehl[1];
    Befehl[0] = LA;
    ipdbg_org_la_tcp_send(tcp, Befehl, 1);
    Befehl[0] = delay;
    ipdbg_org_la_tcp_send(tcp, Befehl, 1);

    //sr_warn("delay 2");


    char buf[4] = { devc->delay_value        & 0x000000ff,
                   (devc->delay_value >>  8) & 0x000000ff,
                   (devc->delay_value >> 16) & 0x000000ff,
                   (devc->delay_value >> 24) & 0x000000ff};

    for(size_t i = 0 ; i < devc->ADDR_WIDTH_BYTES ; ++i)
        sendEscaping(tcp, &(buf[devc->ADDR_WIDTH_BYTES-1-i]), 1);

    return SR_OK;
}

SR_PRIV int ipdbg_org_la_sendTrigger(struct ipdbg_org_la_dev_context *devc, struct ipdbg_org_la_tcp *tcp)
{
    /////////////////////////////////////////////Mask////////////////////////////////////////////////////////////
    uint8_t buf[1];
    buf[0] = Trigger;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0] = Masks;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0] = Mask;
    ipdbg_org_la_tcp_send(tcp, buf, 1);

    for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
        sendEscaping(tcp, devc->trigger_mask + devc->DATA_WIDTH_BYTES -1-k, 1);


     /////////////////////////////////////////////Value////////////////////////////////////////////////////////////
    buf[0]= Trigger;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0] = Masks;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0] = Value;
    ipdbg_org_la_tcp_send(tcp, buf, 1);


    for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
        sendEscaping(tcp, devc->trigger_value + devc->DATA_WIDTH_BYTES -1-k, 1);

    /////////////////////////////////////////////Mask_last////////////////////////////////////////////////////////////
    buf[0] = Trigger;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0] = Last_Masks;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0] = Mask_last;
    ipdbg_org_la_tcp_send(tcp, buf, 1);


    for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
        sendEscaping(tcp, devc->trigger_mask_last + devc->DATA_WIDTH_BYTES -1-k, 1);


    /////////////////////////////////////////////Value_last////////////////////////////////////////////////////////////
    buf[0] = Trigger;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0]= Last_Masks;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0]= Value_last;
    ipdbg_org_la_tcp_send(tcp, buf, 1);


    for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
        sendEscaping(tcp, devc->trigger_value_last + devc->DATA_WIDTH_BYTES -1-k, 1);

    /////////////////////////////////////////////edge_mask////////////////////////////////////////////////////////////
    buf[0] = Trigger;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0] = Select_Edge_Mask;
    ipdbg_org_la_tcp_send(tcp, buf, 1);
    buf[0] = Set_Edge_Mask;
    ipdbg_org_la_tcp_send(tcp, buf, 1);

    for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
        sendEscaping(tcp, devc->trigger_edge_mask + devc->DATA_WIDTH_BYTES -1-k, 1);


    return SR_OK;
}

SR_PRIV int sendEscaping(struct ipdbg_org_la_tcp *tcp, char *dataToSend, int length)
{
    while(length--)
    {
        uint8_t payload = *dataToSend++;
        //sr_warn("payload %d", payload);

        //sr_warn("send really");

        if ( payload == (uint8_t)reset )
        {
            uint8_t escapeSymbol = Escape;
            sr_warn("Escape");

            if(ipdbg_org_la_tcp_send(tcp, &escapeSymbol, 1) != SR_OK)
                sr_warn("can't send escape");


        }

        if ( payload == (char)Escape )
        {
            uint8_t escapeSymbol = Escape;
            sr_warn("Escape");

            if(ipdbg_org_la_tcp_send(tcp, &escapeSymbol, 1) != SR_OK)
                sr_warn("can't send escape");
        }

        if (ipdbg_org_la_tcp_send(tcp, &payload, 1) != SR_OK)
        {
            sr_warn("Can't send data");
        }
         //sr_warn("length %d", length);

    }
    return SR_OK;
}

SR_PRIV void ipdbg_org_la_get_addrwidth_and_datawidth(struct ipdbg_org_la_tcp *tcp, struct ipdbg_org_la_dev_context *devc)
{
    //sr_err("getAddrAndDataWidth\n");
    uint8_t buf[8];
    uint8_t auslesen[1];
    auslesen[0]= K_Mauslesen;

    if(ipdbg_org_la_tcp_send(tcp, auslesen, 1) != SR_OK)
        sr_warn("Can't send K_Mauslesen");
    //g_usleep(RESPONSE_DELAY_US);


    /// delay
    if(ipdbg_org_la_tcp_receive(tcp, buf, 8) != 8)
        sr_warn("getAddrAndDataWidth failed");

    //sr_warn("getAddrAndDataWidth 0x%x:0x%x:0x%x:0x%x 0x%x:0x%x:0x%x:0x%x", buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]);

    devc->DATA_WIDTH  =  buf[0]        & 0x000000FF;
    devc->DATA_WIDTH |= (buf[1] <<  8) & 0x0000FF00;
    devc->DATA_WIDTH |= (buf[2] << 16) & 0x00FF0000;
    devc->DATA_WIDTH |= (buf[3] << 24) & 0xFF000000;

    devc->ADDR_WIDTH  =  buf[4]        & 0x000000FF;
    devc->ADDR_WIDTH |= (buf[5] <<  8) & 0x0000FF00;
    devc->ADDR_WIDTH |= (buf[6] << 16) & 0x00FF0000;
    devc->ADDR_WIDTH |= (buf[7] << 24) & 0xFF000000;


    //sr_warn("Datawidth: %d  Addrwdth : %d", devc->DATA_WIDTH, devc->ADDR_WIDTH);

    int HOST_WORD_SIZE = 8; // bits/ word

    devc->DATA_WIDTH_BYTES = (devc->DATA_WIDTH+HOST_WORD_SIZE -1)/HOST_WORD_SIZE;
    devc->ADDR_WIDTH_BYTES = (devc->ADDR_WIDTH+HOST_WORD_SIZE -1)/HOST_WORD_SIZE;
    devc->limit_samples_max = (0x01 << devc->ADDR_WIDTH);
    devc->limit_samples = devc->limit_samples_max;// (0x01 << HOST_WORD_SIZE);
    //sr_err("DATA_WIDTH_BYTES: %d  ADDR_WIDTH_BYTES : %d LIMIT_SAMPLES: %d", devc->DATA_WIDTH_BYTES, devc->ADDR_WIDTH_BYTES, devc->limit_samples );


    devc->trigger_mask       = g_malloc0(devc->DATA_WIDTH_BYTES);
    devc->trigger_value      = g_malloc0(devc->DATA_WIDTH_BYTES);
    devc->trigger_mask_last  = g_malloc0(devc->DATA_WIDTH_BYTES);
    devc->trigger_value_last = g_malloc0(devc->DATA_WIDTH_BYTES);
    devc->trigger_edge_mask  = g_malloc0(devc->DATA_WIDTH_BYTES);

    // TODO add missing free for trigger_mask, trigger_value, trigger_mask_last, trigger_value_last and trigger_edge_mask

}

SR_PRIV struct ipdbg_org_la_dev_context *ipdbg_org_la_dev_new(void)
{
    struct ipdbg_org_la_dev_context *devc;

    devc = g_malloc0(sizeof(struct ipdbg_org_la_dev_context));


    devc->capture_ratio = 50;
    ///devc->num_bytes = 0;

    return devc;
}

SR_PRIV int ipdbg_org_la_sendReset(struct ipdbg_org_la_tcp *tcp)
{
    uint8_t buf[1];
    buf[0]= reset;
    if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
        sr_warn("Reset can't send");
    return SR_OK;
}

SR_PRIV int ipdbg_org_la_requestID(struct ipdbg_org_la_tcp *tcp)
{
    uint8_t buf[1];
    buf[0]= IPDBG_LA_ID;
    if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
        sr_warn("IDBG can't send");

    char ID[4];
    if(ipdbg_org_la_tcp_receive(tcp, (uint8_t*)ID, 4) != 4)
    {
        sr_warn("IDBG can't read");
    }


    if (strncmp(ID, "IDBG", 4)) {
        sr_err("Invalid reply (expected 'IDBG' '%c%c%c%c').", ID[0], ID[1], ID[2], ID[3]);
        return SR_ERR;
    }

    return SR_OK;
}

SR_PRIV void ipdbg_org_la_abort_acquisition(const struct sr_dev_inst *sdi)
{
    struct sr_datafeed_packet packet;

    struct ipdbg_org_la_tcp *tcp = sdi->conn;

    sr_session_source_remove(sdi->session, tcp->socket);

    /* Terminate session */
    packet.type = SR_DF_END;
    sr_session_send(sdi, &packet);
}

SR_PRIV int ipdbg_org_la_sendStart(struct ipdbg_org_la_tcp *tcp)
{
    uint8_t buf[1];
    buf[0] = Start;

   if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
        sr_warn("Reset can't send");
    return SR_OK;
}
Commit	Line	Data
a4210e18 EK	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2016 danselmi <da@da>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <config.h>
	21	#ifdef _WIN32
	22	#define _WIN32_WINNT 0x0501
	23	#include <winsock2.h>
	24	#include <ws2tcpip.h>
	25	#endif
	26	//#include <glib.h>
	27	#include <string.h>
	28	#include <unistd.h>
	29	#ifndef _WIN32
	30	#include <sys/socket.h>
	31	#include <netinet/in.h>
	32	#include <arpa/inet.h>
	33	#include <netdb.h>
	34	#endif
	35	#include <errno.h>
	36	#include "protocol.h"
	37
	38	#define BUFFER_SIZE 4
	39
	40
	41	#define Start 0xFE
2f15f5bf	42	#define reset 0xEE
a4210e18 EK	43	#define IPDBG_LA_ID 0xBB
	44	#define Escape 0x55
	45
	46
	47	/* Command opcodes */
	48	#define set_trigger 0x00
2f15f5bf	49
a4210e18 EK	50	#define Trigger 0xF0
a4210e18 EK	51	#define LA 0x0F
2f15f5bf	52
a4210e18 EK	53	#define Masks 0xF1
a4210e18 EK	54	#define Mask 0xF3
2f15f5bf	55
a4210e18	56	#define Value 0xF7
2f15f5bf	57
a4210e18 EK	58	#define Last_Masks 0xF9
a4210e18 EK	59	#define Mask_last 0xFB
2f15f5bf	60
a4210e18	61	#define Value_last 0xFF
2f15f5bf	62
a66099c6 EK	63	#define Select_Edge_Mask 0xF5
	64	#define Set_Edge_Mask 0xF6
	65
a4210e18 EK	66	#define delay 0x1F
	67	#define K_Mauslesen 0xAA
	68
	69
	70	SR_PRIV int sendEscaping(struct ipdbg_org_la_tcp tcp, char dataToSend, int length);
	71
	72	SR_PRIV struct ipdbg_org_la_tcp *ipdbg_org_la_new_tcp(void)
	73	{
	74	struct ipdbg_org_la_tcp *tcp;
	75
	76	tcp = g_malloc0(sizeof(struct ipdbg_org_la_tcp));
	77
	78	tcp->address = NULL;
	79	tcp->port = NULL;
	80	tcp->socket = -1;
	81
	82	return tcp;
	83	}
	84
	85	SR_PRIV int ipdbg_org_la_tcp_open(struct ipdbg_org_la_tcp *tcp)
	86	{
2f15f5bf EK	87	struct addrinfo hints;
	88	struct addrinfo results, res;
	89	int err;
	90
	91	memset(&hints, 0, sizeof(hints));
	92	hints.ai_family = AF_UNSPEC;
	93	hints.ai_socktype = SOCK_STREAM;
	94	hints.ai_protocol = IPPROTO_TCP;
	95
	96	err = getaddrinfo(tcp->address, tcp->port, &hints, &results);
	97
	98	if (err) {
	99	sr_err("Address lookup failed: %s:%s: %s", tcp->address, tcp->port,
	100	gai_strerror(err));
	101	return SR_ERR;
	102	}
	103
	104	for (res = results; res; res = res->ai_next) {
	105	if ((tcp->socket = socket(res->ai_family, res->ai_socktype,
	106	res->ai_protocol)) < 0)
	107	continue;
	108	if (connect(tcp->socket, res->ai_addr, res->ai_addrlen) != 0) {
	109	close(tcp->socket);
	110	tcp->socket = -1;
	111	continue;
	112	}
	113	break;
	114	}
	115
	116	freeaddrinfo(results);
	117
	118	if (tcp->socket < 0) {
	119	sr_err("Failed to connect to %s:%s: %s", tcp->address, tcp->port,
	120	g_strerror(errno));
	121	return SR_ERR;
	122	}
	123
	124	return SR_OK;
a4210e18 EK	125	}
	126
	127	SR_PRIV int ipdbg_org_la_tcp_send(struct ipdbg_org_la_tcp tcp, const uint8_t buf, size_t len)
	128	{
2f15f5bf EK	129	int out;
2f15f5bf EK	130	out = send(tcp->socket, (char*)buf, len, 0);
a4210e18	131
2f15f5bf EK	132	if (out < 0) {
	133	sr_err("Send error: %s", g_strerror(errno));
	134	return SR_ERR;
	135	}
a4210e18	136
2f15f5bf EK	137	if ((unsigned int)out < len) {
	138	sr_dbg("Only sent %d/%d bytes of data.", out, (int)len);
	139	}
a4210e18	140
2f15f5bf	141	return SR_OK;
a4210e18 EK	142	}
	143
	144	SR_PRIV int ipdbg_org_la_tcp_receive(struct ipdbg_org_la_tcp tcp, uint8_t buf, int bufsize)
	145	{
	146	int received = 0;
	147
	148	while(received < bufsize)
	149	{
a4210e18 EK	150	int len;
a4210e18 EK	151
d37c6daa	152	len = recv(tcp->socket, (char*)(buf+received), bufsize-received, 0);
a4210e18 EK	153
	154	if (len < 0) {
	155	sr_err("Receive error: %s", g_strerror(errno));
	156	return SR_ERR;
	157	}
	158	else
	159	{
	160	received += len;
	161	}
	162	}
	163
2f15f5bf	164	return received;
a4210e18 EK	165	}
	166
	167	SR_PRIV int ipdbg_org_la_tcp_close(struct ipdbg_org_la_tcp *tcp)
	168	{
	169	int ret = SR_ERR;
2f15f5bf	170	if (close(tcp->socket) >= 0)
a4210e18 EK	171	ret = SR_OK;
	172
	173	tcp->socket = -1;
	174
	175	return ret;
	176	}
	177
	178	SR_PRIV void ipdbg_org_la_tcp_free(struct ipdbg_org_la_tcp *tcp)
	179	{
2f15f5bf EK	180	g_free(tcp->address);
2f15f5bf EK	181	g_free(tcp->port);
a4210e18 EK	182	}
	183
	184	SR_PRIV int ipdbg_org_la_convert_trigger(const struct sr_dev_inst *sdi)
	185	{
	186	struct ipdbg_org_la_dev_context *devc;
	187	struct sr_trigger *trigger;
	188	struct sr_trigger_stage *stage;
	189	struct sr_trigger_match *match;
	190	const GSList l, m;
	191
	192	devc = sdi->priv;
	193
	194	devc->num_stages = 0;
	195	devc->num_transfers = 0;
	196	devc->raw_sample_buf = NULL; /// name convert_trigger to init acquisition...
2f15f5bf	197	for (unsigned int i = 0; i < devc->DATA_WIDTH_BYTES; i++) // Hier werden die Trigger-Variabeln 0 gesetzt!
a4210e18 EK	198	{
	199	devc->trigger_mask[i] = 0;
	200	devc->trigger_value[i] = 0;
	201	devc->trigger_mask_last[i] = 0;
	202	devc->trigger_value_last[i] = 0;
a66099c6	203	devc->trigger_edge_mask[i] = 0;
a4210e18	204	}
a4210e18 EK	205
	206	if (!(trigger = sr_session_trigger_get(sdi->session))) //
	207	{
	208	return SR_OK;
	209	}
	210
a4210e18 EK	211	for (l = trigger->stages; l; l = l->next)
	212	{
	213	stage = l->data;
	214	for (m = stage->matches; m; m = m->next)
	215	{
	216	match = m->data;
	217	unsigned int byteIndex = (match->channel->index) /8;
	218	unsigned char matchPattern = 1 << (match->channel->index - 8* byteIndex);
	219	//zeroTrigger \|= matchPattern;
	220	//sr_err("\n\nzerotrigger:%x\n\n",zeroTrigger);
	221	//sr_err("\nbyteIndex:%i",byteIndex);
	222	//sr_err("\nmatch Pattern:%i\n",matchPattern);
	223
	224	if (!match->channel->enabled)
	225	/* Ignore disabled channels with a trigger. */
	226	continue;
	227	if (match->match == SR_TRIGGER_ONE )
	228	{
	229	devc->trigger_value[byteIndex] \|= matchPattern;
	230	devc->trigger_mask[byteIndex] \|= matchPattern;
	231	devc->trigger_mask_last[byteIndex] &= ~matchPattern;
a66099c6	232	devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
a4210e18 EK	233	//sr_err("\n========ONE MASK===========");
	234
	235	}
	236	else if (match->match == SR_TRIGGER_ZERO)
	237	{
	238	devc->trigger_value[byteIndex] &= ~matchPattern;
	239	devc->trigger_mask[byteIndex] \|= matchPattern;
	240	devc->trigger_mask_last[byteIndex] &= ~matchPattern;
a66099c6	241	devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
a4210e18 EK	242	//sr_err("\n========ZERO MASK===========");
	243	}
	244	else if ( match->match == SR_TRIGGER_RISING)
	245	{
	246	devc->trigger_value[byteIndex] \|= matchPattern;
	247	devc->trigger_value_last[byteIndex] &= ~matchPattern;
	248	devc->trigger_mask[byteIndex] \|= matchPattern;
	249	devc->trigger_mask_last[byteIndex] \|= matchPattern;
a66099c6	250	devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
a4210e18 EK	251	//sr_err("\n==========RISING===========");
	252
	253	}
	254	else if (match->match == SR_TRIGGER_FALLING )
	255	{
	256	devc->trigger_value[byteIndex] &= ~matchPattern;
	257	devc->trigger_value_last[byteIndex] \|= matchPattern;
	258	devc->trigger_mask[byteIndex] \|= matchPattern;
	259	devc->trigger_mask_last[byteIndex] \|= matchPattern;
a66099c6	260	devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
a4210e18 EK	261	//sr_err("\n========FALlING===========");
a4210e18 EK	262	}
a66099c6 EK	263	else if (match->match == SR_TRIGGER_EDGE)
	264	{
	265	devc->trigger_mask[byteIndex] &= ~matchPattern;
	266	devc->trigger_mask_last[byteIndex] &= ~matchPattern;
	267	devc->trigger_edge_mask[byteIndex] \|= matchPattern;
	268	}
a4210e18 EK	269
	270	}
	271
	272	}
	273
a4210e18 EK	274	return SR_OK;
	275	}
	276
	277	SR_PRIV int ipdbg_org_la_receive_data(int fd, int revents, void *cb_data)
	278	{
	279	//sr_err("receive Data0\n");
	280
	281
	282	const struct sr_dev_inst *sdi;
	283	struct ipdbg_org_la_dev_context *devc;
	284
	285
	286
	287	(void)fd;
2f15f5bf	288	(void)revents;
a4210e18 EK	289
	290	sdi = (const struct sr_dev_inst *)cb_data;
	291	if (!sdi)
	292	{
	293	return FALSE;
	294	}
	295	//sr_err("receive Data1\n");
	296
	297	if (!(devc = sdi->priv))
	298	{
	299	return FALSE;
	300
	301	}
	302	//sr_err("receive Data2\n");
	303
	304
	305	struct ipdbg_org_la_tcp *tcp = sdi->conn;
	306	struct sr_datafeed_packet packet;
	307	struct sr_datafeed_logic logic;
	308
	309
	310
	311	/*sr_warn("---");
	312	if (devc->num_transfers == 0 && revents == 0)
	313	{ //
	314	sr_warn("warten auf Eingangsdaten");
	315	// Ignore timeouts as long as we haven't received anything
	316	return TRUE;
	317	}*/
	318
	319	if (!devc->raw_sample_buf)
	320	{
	321	//sr_warn("allocating buffer");
	322	devc->raw_sample_buf = g_try_malloc(devc->limit_samples*devc->DATA_WIDTH_BYTES);
	323
	324	if (!devc->raw_sample_buf) {
	325	sr_warn("Sample buffer malloc failed.");
	326	return FALSE;
	327	}
	328
	329	}
	330
	331
	332	if (devc->num_transfers < devc->limit_samples_max*devc->DATA_WIDTH_BYTES)
	333	{
8f6b0eb1	334	//sr_err("1");
a4210e18 EK	335	unsigned char byte;
	336
	337
	338	if (ipdbg_org_la_tcp_receive(tcp, &byte, 1) == 1)
	339	{
	340	if(devc->num_transfers < devc->limit_samples*devc->DATA_WIDTH_BYTES)
	341	devc->raw_sample_buf[devc->num_transfers] = byte;
	342	devc->num_transfers++;
	343	}
	344
	345	}
	346	else
	347	{
8f6b0eb1	348	//sr_err("Received %d bytes", devc->num_transfers);
a4210e18	349
8f6b0eb1	350	//sr_dbg("Received %d bytes.", devc->num_transfers);
a4210e18 EK	351
	352	if (devc->delay_value > 0) {
	353	/* There are pre-trigger samples, send those first. */
	354	packet.type = SR_DF_LOGIC;
	355	packet.payload = &logic;
	356	//logic.length = devc->delay_value-1;
	357	logic.length = devc->delay_value*devc->DATA_WIDTH_BYTES;
	358	logic.unitsize = devc->DATA_WIDTH_BYTES;
	359	logic.data = devc->raw_sample_buf;
	360	sr_session_send(cb_data, &packet);
	361	}
	362
	363	/* Send the trigger. */
	364	packet.type = SR_DF_TRIGGER;
	365	sr_session_send(cb_data, &packet);
	366
	367	/* Send post-trigger samples. */
	368	packet.type = SR_DF_LOGIC;
	369	packet.payload = &logic;
	370	//logic.length = devc->limit_samples - devc->delay_value+1;
	371	logic.length = (devc->limit_samples - devc->delay_value)*devc->DATA_WIDTH_BYTES;
	372	logic.unitsize = devc->DATA_WIDTH_BYTES;
	373	logic.data = devc->raw_sample_buf + devc->delay_value*devc->DATA_WIDTH_BYTES;
	374	//logic.data = devc->raw_sample_buf + devc->delay_value-1;
	375	sr_session_send(cb_data, &packet);
	376
	377	g_free(devc->raw_sample_buf);
	378	devc->raw_sample_buf = NULL;
	379
	380	//serial_flush(serial);
	381	ipdbg_org_la_abort_acquisition(sdi);//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	382	}
	383
	384	return TRUE;
	385	}
	386
	387	SR_PRIV int ipdbg_org_la_sendDelay(struct ipdbg_org_la_dev_context devc, struct ipdbg_org_la_tcp tcp)
	388	{
a4210e18 EK	389
	390	int maxSample;
	391
2f15f5bf	392	maxSample = devc->limit_samples;
a4210e18 EK	393
	394	devc->delay_value = (maxSample/100.0) * devc->capture_ratio;
	395	uint8_t Befehl[1];
	396	Befehl[0] = LA;
	397	ipdbg_org_la_tcp_send(tcp, Befehl, 1);
	398	Befehl[0] = delay;
	399	ipdbg_org_la_tcp_send(tcp, Befehl, 1);
	400
	401	//sr_warn("delay 2");
	402
	403
	404	char buf[4] = { devc->delay_value & 0x000000ff,
	405	(devc->delay_value >> 8) & 0x000000ff,
	406	(devc->delay_value >> 16) & 0x000000ff,
	407	(devc->delay_value >> 24) & 0x000000ff};
	408
2f15f5bf EK	409	for(size_t i = 0 ; i < devc->ADDR_WIDTH_BYTES ; ++i)
2f15f5bf EK	410	sendEscaping(tcp, &(buf[devc->ADDR_WIDTH_BYTES-1-i]), 1);
a4210e18 EK	411
	412	return SR_OK;
	413	}
	414
	415	SR_PRIV int ipdbg_org_la_sendTrigger(struct ipdbg_org_la_dev_context devc, struct ipdbg_org_la_tcp tcp)
	416	{
	417	/////////////////////////////////////////////Mask////////////////////////////////////////////////////////////
	418	uint8_t buf[1];
	419	buf[0] = Trigger;
	420	ipdbg_org_la_tcp_send(tcp, buf, 1);
	421	buf[0] = Masks;
	422	ipdbg_org_la_tcp_send(tcp, buf, 1);
	423	buf[0] = Mask;
	424	ipdbg_org_la_tcp_send(tcp, buf, 1);
	425
2f15f5bf EK	426	for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
2f15f5bf EK	427	sendEscaping(tcp, devc->trigger_mask + devc->DATA_WIDTH_BYTES -1-k, 1);
a4210e18 EK	428
	429
	430	/////////////////////////////////////////////Value////////////////////////////////////////////////////////////
	431	buf[0]= Trigger;
	432	ipdbg_org_la_tcp_send(tcp, buf, 1);
	433	buf[0] = Masks;
	434	ipdbg_org_la_tcp_send(tcp, buf, 1);
	435	buf[0] = Value;
	436	ipdbg_org_la_tcp_send(tcp, buf, 1);
	437
	438
2f15f5bf EK	439	for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
2f15f5bf EK	440	sendEscaping(tcp, devc->trigger_value + devc->DATA_WIDTH_BYTES -1-k, 1);
a4210e18 EK	441
	442	/////////////////////////////////////////////Mask_last////////////////////////////////////////////////////////////
	443	buf[0] = Trigger;
	444	ipdbg_org_la_tcp_send(tcp, buf, 1);
	445	buf[0] = Last_Masks;
	446	ipdbg_org_la_tcp_send(tcp, buf, 1);
	447	buf[0] = Mask_last;
	448	ipdbg_org_la_tcp_send(tcp, buf, 1);
	449
	450
2f15f5bf EK	451	for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
2f15f5bf EK	452	sendEscaping(tcp, devc->trigger_mask_last + devc->DATA_WIDTH_BYTES -1-k, 1);
a4210e18 EK	453
	454
	455	/////////////////////////////////////////////Value_last////////////////////////////////////////////////////////////
	456	buf[0] = Trigger;
	457	ipdbg_org_la_tcp_send(tcp, buf, 1);
	458	buf[0]= Last_Masks;
	459	ipdbg_org_la_tcp_send(tcp, buf, 1);
	460	buf[0]= Value_last;
	461	ipdbg_org_la_tcp_send(tcp, buf, 1);
	462
	463
2f15f5bf EK	464	for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
2f15f5bf EK	465	sendEscaping(tcp, devc->trigger_value_last + devc->DATA_WIDTH_BYTES -1-k, 1);
a4210e18	466
a66099c6 EK	467	/////////////////////////////////////////////edge_mask////////////////////////////////////////////////////////////
	468	buf[0] = Trigger;
	469	ipdbg_org_la_tcp_send(tcp, buf, 1);
	470	buf[0] = Select_Edge_Mask;
	471	ipdbg_org_la_tcp_send(tcp, buf, 1);
	472	buf[0] = Set_Edge_Mask;
	473	ipdbg_org_la_tcp_send(tcp, buf, 1);
	474
	475	for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
	476	sendEscaping(tcp, devc->trigger_edge_mask + devc->DATA_WIDTH_BYTES -1-k, 1);
	477
	478
a4210e18 EK	479	return SR_OK;
	480	}
	481
	482	SR_PRIV int sendEscaping(struct ipdbg_org_la_tcp tcp, char dataToSend, int length)
	483	{
a4210e18 EK	484	while(length--)
	485	{
	486	uint8_t payload = *dataToSend++;
	487	//sr_warn("payload %d", payload);
	488
	489	//sr_warn("send really");
	490
	491	if ( payload == (uint8_t)reset )
	492	{
	493	uint8_t escapeSymbol = Escape;
	494	sr_warn("Escape");
	495
	496	if(ipdbg_org_la_tcp_send(tcp, &escapeSymbol, 1) != SR_OK)
	497	sr_warn("can't send escape");
	498
	499
	500	}
	501
	502	if ( payload == (char)Escape )
	503	{
	504	uint8_t escapeSymbol = Escape;
	505	sr_warn("Escape");
	506
	507	if(ipdbg_org_la_tcp_send(tcp, &escapeSymbol, 1) != SR_OK)
	508	sr_warn("can't send escape");
	509	}
	510
	511	if (ipdbg_org_la_tcp_send(tcp, &payload, 1) != SR_OK)
	512	{
	513	sr_warn("Can't send data");
	514	}
	515	//sr_warn("length %d", length);
	516
	517	}
	518	return SR_OK;
	519	}
	520
	521	SR_PRIV void ipdbg_org_la_get_addrwidth_and_datawidth(struct ipdbg_org_la_tcp tcp, struct ipdbg_org_la_dev_context devc)
	522	{
	523	//sr_err("getAddrAndDataWidth\n");
	524	uint8_t buf[8];
	525	uint8_t auslesen[1];
	526	auslesen[0]= K_Mauslesen;
	527
	528	if(ipdbg_org_la_tcp_send(tcp, auslesen, 1) != SR_OK)
	529	sr_warn("Can't send K_Mauslesen");
	530	//g_usleep(RESPONSE_DELAY_US);
	531
	532
	533
	534	/// delay
	535	if(ipdbg_org_la_tcp_receive(tcp, buf, 8) != 8)
	536	sr_warn("getAddrAndDataWidth failed");
	537
	538	//sr_warn("getAddrAndDataWidth 0x%x:0x%x:0x%x:0x%x 0x%x:0x%x:0x%x:0x%x", buf[0],buf[1],buf[2],buf[3],buf[4],buf[5],buf[6],buf[7]);
	539
	540	devc->DATA_WIDTH = buf[0] & 0x000000FF;
	541	devc->DATA_WIDTH \|= (buf[1] << 8) & 0x0000FF00;
	542	devc->DATA_WIDTH \|= (buf[2] << 16) & 0x00FF0000;
	543	devc->DATA_WIDTH \|= (buf[3] << 24) & 0xFF000000;
	544
	545	devc->ADDR_WIDTH = buf[4] & 0x000000FF;
	546	devc->ADDR_WIDTH \|= (buf[5] << 8) & 0x0000FF00;
	547	devc->ADDR_WIDTH \|= (buf[6] << 16) & 0x00FF0000;
548	devc->ADDR_WIDTH \|= (buf[7] << 24) & 0xFF000000;
549
550
551
552	//sr_warn("Datawidth: %d Addrwdth : %d", devc->DATA_WIDTH, devc->ADDR_WIDTH);
553
554	int HOST_WORD_SIZE = 8; // bits/ word
555
556	devc->DATA_WIDTH_BYTES = (devc->DATA_WIDTH+HOST_WORD_SIZE -1)/HOST_WORD_SIZE;
557	devc->ADDR_WIDTH_BYTES = (devc->ADDR_WIDTH+HOST_WORD_SIZE -1)/HOST_WORD_SIZE;
558	devc->limit_samples_max = (0x01 << devc->ADDR_WIDTH);
2f15f5bf	559	devc->limit_samples = devc->limit_samples_max;// (0x01 << HOST_WORD_SIZE);
8f6b0eb1	560	//sr_err("DATA_WIDTH_BYTES: %d ADDR_WIDTH_BYTES : %d LIMIT_SAMPLES: %d", devc->DATA_WIDTH_BYTES, devc->ADDR_WIDTH_BYTES, devc->limit_samples );
a4210e18 EK	561
	562
	563
	564	devc->trigger_mask = g_malloc0(devc->DATA_WIDTH_BYTES);
	565	devc->trigger_value = g_malloc0(devc->DATA_WIDTH_BYTES);
	566	devc->trigger_mask_last = g_malloc0(devc->DATA_WIDTH_BYTES);
	567	devc->trigger_value_last = g_malloc0(devc->DATA_WIDTH_BYTES);
a66099c6	568	devc->trigger_edge_mask = g_malloc0(devc->DATA_WIDTH_BYTES);
a4210e18	569
a66099c6	570	// TODO add missing free for trigger_mask, trigger_value, trigger_mask_last, trigger_value_last and trigger_edge_mask
a4210e18 EK	571
	572	}
	573
	574	SR_PRIV struct ipdbg_org_la_dev_context *ipdbg_org_la_dev_new(void)
	575	{
	576	struct ipdbg_org_la_dev_context *devc;
	577
	578	devc = g_malloc0(sizeof(struct ipdbg_org_la_dev_context));
	579
	580
	581	devc->capture_ratio = 50;
	582	///devc->num_bytes = 0;
	583
	584	return devc;
	585	}
	586
	587	SR_PRIV int ipdbg_org_la_sendReset(struct ipdbg_org_la_tcp *tcp)
	588	{
	589	uint8_t buf[1];
	590	buf[0]= reset;
	591	if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
	592	sr_warn("Reset can't send");
	593	return SR_OK;
	594	}
	595
	596	SR_PRIV int ipdbg_org_la_requestID(struct ipdbg_org_la_tcp *tcp)
	597	{
	598	uint8_t buf[1];
	599	buf[0]= IPDBG_LA_ID;
	600	if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
	601	sr_warn("IDBG can't send");
	602
	603	char ID[4];
	604	if(ipdbg_org_la_tcp_receive(tcp, (uint8_t*)ID, 4) != 4)
	605	{
	606	sr_warn("IDBG can't read");
	607	}
	608
	609
	610	if (strncmp(ID, "IDBG", 4)) {
	611	sr_err("Invalid reply (expected 'IDBG' '%c%c%c%c').", ID[0], ID[1], ID[2], ID[3]);
	612	return SR_ERR;
	613	}
	614
	615	return SR_OK;
	616	}
	617
	618	SR_PRIV void ipdbg_org_la_abort_acquisition(const struct sr_dev_inst *sdi)
	619	{
	620	struct sr_datafeed_packet packet;
	621
	622	struct ipdbg_org_la_tcp *tcp = sdi->conn;
	623
2f15f5bf	624	sr_session_source_remove(sdi->session, tcp->socket);
a4210e18 EK	625
	626	/* Terminate session */
	627	packet.type = SR_DF_END;
	628	sr_session_send(sdi, &packet);
	629	}
	630
	631	SR_PRIV int ipdbg_org_la_sendStart(struct ipdbg_org_la_tcp *tcp)
	632	{
	633	uint8_t buf[1];
	634	buf[0] = Start;
	635
	636	if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
	637	sr_warn("Reset can't send");
	638	return SR_OK;
	639	}
	640