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