src/hardware/ipdbg-logic-analyser/protocol.c

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