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 #define BUFFER_SIZE 4
  39
  40
  41 #define Start                      0xFE
  42 #define reset                      0xEE
  43 #define IPDBG_LA_ID                0xBB
  44 #define Escape                     0x55
  45
  46
  47 /* Command opcodes */
  48 #define set_trigger                0x00
  49
  50 #define Trigger                    0xF0
  51 #define LA                         0x0F
  52
  53 #define Masks                      0xF1
  54 #define Mask                       0xF3
  55
  56 #define Value                      0xF7
  57
  58 #define Last_Masks                 0xF9
  59 #define Mask_last                  0xFB
  60
  61 #define Value_last                 0xFF
  62
  63 #define Select_Edge_Mask           0xF5
  64 #define Set_Edge_Mask              0xF6
  65
  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 {
  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;
 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 {
 129     int out;
 130     out = send(tcp->socket, (char*)buf, len, 0);
 131
 132     if (out < 0) {
 133         sr_err("Send error: %s", g_strerror(errno));
 134         return SR_ERR;
 135     }
 136
 137     if ((unsigned int)out < len) {
 138         sr_dbg("Only sent %d/%d bytes of data.", out, (int)len);
 139     }
 140
 141     return SR_OK;
 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     {
 150         int len;
 151
 152         len = recv(tcp->socket, (char*)(buf+received), bufsize-received, 0);
 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
 164     return received;
 165 }
 166
 167 SR_PRIV int ipdbg_org_la_tcp_close(struct ipdbg_org_la_tcp *tcp)
 168 {
 169     int ret = SR_ERR;
 170     if (close(tcp->socket) >= 0)
 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 {
 180     g_free(tcp->address);
 181     g_free(tcp->port);
 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...
 197     for (unsigned int i = 0; i < devc->DATA_WIDTH_BYTES; i++) // Hier werden die Trigger-Variabeln 0 gesetzt!
 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;
 203         devc->trigger_edge_mask[i] = 0;
 204     }
 205
 206     if (!(trigger = sr_session_trigger_get(sdi->session))) //
 207     {
 208         return SR_OK;
 209     }
 210
 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;
 232                 devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
 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;
 241                 devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
 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;
 250                 devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
 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;
 260                 devc->trigger_edge_mask[byteIndex] &= ~matchPattern;
 261                 //sr_err("\n========FALlING===========");
 262             }
 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             }
 269
 270         }
 271
 272     }
 273
 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;
 288     (void)revents;
 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     {
 334         //sr_err("1");
 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     {
 348         //sr_err("Received %d bytes", devc->num_transfers);
 349
 350         //sr_dbg("Received %d bytes.", devc->num_transfers);
 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 {
 389
 390     int maxSample;
 391
 392     maxSample = devc->limit_samples;
 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
 409     for(size_t i = 0 ; i < devc->ADDR_WIDTH_BYTES ; ++i)
 410         sendEscaping(tcp, &(buf[devc->ADDR_WIDTH_BYTES-1-i]), 1);
 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
 426     for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
 427         sendEscaping(tcp, devc->trigger_mask + devc->DATA_WIDTH_BYTES -1-k, 1);
 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
 439     for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
 440         sendEscaping(tcp, devc->trigger_value + devc->DATA_WIDTH_BYTES -1-k, 1);
 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
 451     for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
 452         sendEscaping(tcp, devc->trigger_mask_last + devc->DATA_WIDTH_BYTES -1-k, 1);
 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
 464     for(size_t k = 0 ; k < devc->DATA_WIDTH_BYTES ; ++k)
 465         sendEscaping(tcp, devc->trigger_value_last + devc->DATA_WIDTH_BYTES -1-k, 1);
 466
 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
 479     return SR_OK;
 480 }
 481
 482 SR_PRIV int sendEscaping(struct ipdbg_org_la_tcp *tcp, char *dataToSend, int length)
 483 {
 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);
 559     devc->limit_samples = devc->limit_samples_max;// (0x01 << HOST_WORD_SIZE);
 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 );
 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);
 568     devc->trigger_edge_mask  = g_malloc0(devc->DATA_WIDTH_BYTES);
 569
 570     // TODO add missing free for trigger_mask, trigger_value, trigger_mask_last, trigger_value_last and trigger_edge_mask
 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
 624     sr_session_source_remove(sdi->session, tcp->socket);
 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