2 * This file is part of the libsigrok project.
4 * Copyright (C) 2016 danselmi <da@da>
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.
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.
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/>.
22 #define _WIN32_WINNT 0x0501
30 #include <sys/socket.h>
31 #include <netinet/in.h>
32 #include <arpa/inet.h>
38 #include <sys/ioctl.h>
45 #define IPDBG_LA_ID 0xBB
50 #define set_trigger 0x00
60 #define Last_Masks 0xF9
61 #define Mask_last 0xFB
63 #define Value_last 0xFF
65 #define Select_Edge_Mask 0xF5
66 #define Set_Edge_Mask 0xF6
69 #define K_Mauslesen 0xAA
71 int hasData(struct ipdbg_org_la_tcp *tcp)
74 ioctlsocket(tcp->socket,FIONREAD,&bytes_available);
76 //ioctl(fd,FIONREAD,&bytes_available);
79 //fd = open("/dev/ttyS0", O_RDONLY);
80 if (ioctl(tcp->socket, FIONREAD, &status) < 0) //TIOCMGET
82 sr_err("FIONREAD failed: %s\n",
102 SR_PRIV int sendEscaping(struct ipdbg_org_la_tcp *tcp, char *dataToSend, int length);
104 SR_PRIV struct ipdbg_org_la_tcp *ipdbg_org_la_new_tcp(void)
106 struct ipdbg_org_la_tcp *tcp;
108 tcp = g_malloc0(sizeof(struct ipdbg_org_la_tcp));
117 SR_PRIV int ipdbg_org_la_tcp_open(struct ipdbg_org_la_tcp *tcp)
119 struct addrinfo hints;
120 struct addrinfo *results, *res;
123 memset(&hints, 0, sizeof(hints));
124 hints.ai_family = AF_UNSPEC;
125 hints.ai_socktype = SOCK_STREAM;
126 hints.ai_protocol = IPPROTO_TCP;
128 err = getaddrinfo(tcp->address, tcp->port, &hints, &results);
131 sr_err("Address lookup failed: %s:%s: %s", tcp->address, tcp->port,
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)
140 if (connect(tcp->socket, res->ai_addr, res->ai_addrlen) != 0) {
148 freeaddrinfo(results);
150 if (tcp->socket < 0) {
151 sr_err("Failed to connect to %s:%s: %s", tcp->address, tcp->port,
159 SR_PRIV int ipdbg_org_la_tcp_send(struct ipdbg_org_la_tcp *tcp, const uint8_t *buf, size_t len)
162 out = send(tcp->socket, (char*)buf, len, 0);
165 sr_err("Send error: %s", g_strerror(errno));
169 if ((unsigned int)out < len) {
170 sr_dbg("Only sent %d/%d bytes of data.", out, (int)len);
176 SR_PRIV int ipdbg_org_la_tcp_receive_blocking(struct ipdbg_org_la_tcp *tcp, uint8_t *buf, int bufsize)
179 while (received < bufsize)
181 int valid = ipdbg_org_la_tcp_receive(tcp, buf);
190 SR_PRIV int ipdbg_org_la_tcp_receive(struct ipdbg_org_la_tcp *tcp, uint8_t *buf)
194 if (hasData(tcp) == 1)
198 int len = recv(tcp->socket, buf, 1, 0);
202 sr_err("Receive error: %s", g_strerror(errno));
219 SR_PRIV int ipdbg_org_la_tcp_close(struct ipdbg_org_la_tcp *tcp)
222 if (close(tcp->socket) >= 0)
230 SR_PRIV void ipdbg_org_la_tcp_free(struct ipdbg_org_la_tcp *tcp)
232 g_free(tcp->address);
236 SR_PRIV int ipdbg_org_la_convert_trigger(const struct sr_dev_inst *sdi)
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;
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++)
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;
258 if (!(trigger = sr_session_trigger_get(sdi->session)))
263 for (l = trigger->stages; l; l = l->next)
266 for (m = stage->matches; m; m = m->next)
269 unsigned int byteIndex = (match->channel->index) /8;
270 unsigned char matchPattern = 1 << (match->channel->index - 8* byteIndex);
272 if (!match->channel->enabled)
273 /* Ignore disabled channels with a trigger. */
275 if (match->match == SR_TRIGGER_ONE )
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===========");
284 else if (match->match == SR_TRIGGER_ZERO)
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===========");
292 else if ( match->match == SR_TRIGGER_RISING)
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===========");
302 else if (match->match == SR_TRIGGER_FALLING )
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===========");
311 else if (match->match == SR_TRIGGER_EDGE)
313 devc->trigger_mask[byteIndex] &= ~matchPattern;
314 devc->trigger_mask_last[byteIndex] &= ~matchPattern;
315 devc->trigger_edge_mask[byteIndex] |= matchPattern;
325 SR_PRIV int ipdbg_org_la_receive_data(int fd, int revents, void *cb_data)
329 const struct sr_dev_inst *sdi;
330 struct ipdbg_org_la_dev_context *devc;
337 sdi = (const struct sr_dev_inst *)cb_data;
343 if (!(devc = sdi->priv))
350 struct ipdbg_org_la_tcp *tcp = sdi->conn;
351 struct sr_datafeed_packet packet;
352 struct sr_datafeed_logic logic;
355 if (!devc->raw_sample_buf)
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.");
366 if (devc->num_transfers < devc->limit_samples_max*devc->DATA_WIDTH_BYTES)
370 if (ipdbg_org_la_tcp_receive(tcp, &byte) == 1)
372 if(devc->num_transfers < devc->limit_samples*devc->DATA_WIDTH_BYTES)
373 devc->raw_sample_buf[devc->num_transfers] = byte;
375 devc->num_transfers++;
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);
393 /* Send the trigger. */
394 packet.type = SR_DF_TRIGGER;
395 sr_session_send(cb_data, &packet);
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);
407 g_free(devc->raw_sample_buf);
408 devc->raw_sample_buf = NULL;
410 //serial_flush(serial);
411 ipdbg_org_la_abort_acquisition(sdi);
417 SR_PRIV int ipdbg_org_la_sendDelay(struct ipdbg_org_la_dev_context *devc, struct ipdbg_org_la_tcp *tcp)
422 maxSample = devc->limit_samples;
424 devc->delay_value = (maxSample/100.0) * devc->capture_ratio;
427 ipdbg_org_la_tcp_send(tcp, Befehl, 1);
429 ipdbg_org_la_tcp_send(tcp, Befehl, 1);
431 //sr_warn("delay 2");
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};
439 for(size_t i = 0 ; i < devc->ADDR_WIDTH_BYTES ; ++i)
440 sendEscaping(tcp, &(buf[devc->ADDR_WIDTH_BYTES-1-i]), 1);
445 SR_PRIV int ipdbg_org_la_sendTrigger(struct ipdbg_org_la_dev_context *devc, struct ipdbg_org_la_tcp *tcp)
447 /////////////////////////////////////////////Mask////////////////////////////////////////////////////////////
450 ipdbg_org_la_tcp_send(tcp, buf, 1);
452 ipdbg_org_la_tcp_send(tcp, buf, 1);
454 ipdbg_org_la_tcp_send(tcp, buf, 1);
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);
460 /////////////////////////////////////////////Value////////////////////////////////////////////////////////////
462 ipdbg_org_la_tcp_send(tcp, buf, 1);
464 ipdbg_org_la_tcp_send(tcp, buf, 1);
466 ipdbg_org_la_tcp_send(tcp, buf, 1);
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);
473 /////////////////////////////////////////////Mask_last////////////////////////////////////////////////////////////
475 ipdbg_org_la_tcp_send(tcp, buf, 1);
477 ipdbg_org_la_tcp_send(tcp, buf, 1);
479 ipdbg_org_la_tcp_send(tcp, buf, 1);
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);
486 /////////////////////////////////////////////Value_last////////////////////////////////////////////////////////////
488 ipdbg_org_la_tcp_send(tcp, buf, 1);
490 ipdbg_org_la_tcp_send(tcp, buf, 1);
492 ipdbg_org_la_tcp_send(tcp, buf, 1);
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);
498 /////////////////////////////////////////////edge_mask////////////////////////////////////////////////////////////
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);
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);
514 SR_PRIV int sendEscaping(struct ipdbg_org_la_tcp *tcp, char *dataToSend, int length)
518 uint8_t payload = *dataToSend++;
520 if ( payload == (uint8_t)reset )
522 uint8_t escapeSymbol = Escape;
525 if(ipdbg_org_la_tcp_send(tcp, &escapeSymbol, 1) != SR_OK)
526 sr_warn("can't send escape");
531 if ( payload == (char)Escape )
533 uint8_t escapeSymbol = Escape;
536 if(ipdbg_org_la_tcp_send(tcp, &escapeSymbol, 1) != SR_OK)
537 sr_warn("can't send escape");
540 if (ipdbg_org_la_tcp_send(tcp, &payload, 1) != SR_OK)
542 sr_warn("Can't send data");
549 SR_PRIV void ipdbg_org_la_get_addrwidth_and_datawidth(struct ipdbg_org_la_tcp *tcp, struct ipdbg_org_la_dev_context *devc)
553 auslesen[0]= K_Mauslesen;
555 if(ipdbg_org_la_tcp_send(tcp, auslesen, 1) != SR_OK)
556 sr_warn("Can't send K_Mauslesen");
558 if (ipdbg_org_la_tcp_receive_blocking(tcp, buf,8)!=8)
559 sr_warn("getAddrAndDataWidth failed");
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;
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;
573 int HOST_WORD_SIZE = 8; // bits/ word
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;
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);
591 SR_PRIV struct ipdbg_org_la_dev_context *ipdbg_org_la_dev_new(void)
593 struct ipdbg_org_la_dev_context *devc;
595 devc = g_malloc0(sizeof(struct ipdbg_org_la_dev_context));
598 devc->capture_ratio = 50;
599 ///devc->num_bytes = 0;
604 SR_PRIV int ipdbg_org_la_sendReset(struct ipdbg_org_la_tcp *tcp)
608 if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
609 sr_warn("Reset can't send");
613 SR_PRIV int ipdbg_org_la_requestID(struct ipdbg_org_la_tcp *tcp)
617 if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
618 sr_warn("IDBG can't send");
621 if(ipdbg_org_la_tcp_receive_blocking(tcp, (uint8_t*)ID, 4) != 4)
623 sr_warn("IDBG can't read");
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]);
635 SR_PRIV void ipdbg_org_la_abort_acquisition(const struct sr_dev_inst *sdi)
638 struct ipdbg_org_la_tcp *tcp = sdi->conn;
640 sr_session_source_remove(sdi->session, tcp->socket);
642 std_session_send_df_end(sdi);
645 SR_PRIV int ipdbg_org_la_sendStart(struct ipdbg_org_la_tcp *tcp)
650 if(ipdbg_org_la_tcp_send(tcp, buf, 1) != SR_OK)
651 sr_warn("Reset can't send");