2 * This file is part of the libsigrok project.
4 * Copyright (C) 2018 Gerhard Sittig <gerhard.sittig@gmx.net>
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 2 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/>.
21 * See the LA1034 vendor's http://www.pctestinstruments.com/ website.
23 * The hardware comes with (Windows only) software which uses the .lpf
24 * ("LogicPort File") filename extension for project files, which hold
25 * both the configuration as well as sample data (up to 2K samples). In
26 * the absence of an attached logic analyzer, the software provides a
27 * demo mode which generates random input signals. The software installs
28 * example project files (with samples), too.
30 * The file format is "mostly text", is line oriented, though it uses
31 * funny DC1 separator characters as well as line continuation by means
32 * of a combination of DC1 and slashes. Fortunately the last text line
33 * is terminated by means of CRLF.
35 * The software is rather complex and has features which don't easily
36 * translate to sigrok semantics (like one signal being a member of
37 * multiple groups, display format specs for groups' values).
39 * This input module implementation supports the following features:
40 * - input format auto detection
41 * - sample period to sample rate conversion
42 * - wire names, acquisition filters ("enabled") and inversion flags
43 * - decompression (repetition counters for sample data)
44 * - strict '0' and '1' levels (as well as ignoring 'U' values)
45 * - signal names (user assigned names, "aliases" for "wires")
46 * - signal groups (no support for multiple assignments, no support for
47 * display format specs)
48 * - "logic" channels (mere bits, no support for analog channels, also
49 * nothing analog "gets derived from" any signal groups) -- libsigrok
50 * using applications might provide such a feature if they want to
60 #include <libsigrok/libsigrok.h>
61 #include "libsigrok-internal.h"
63 /* TODO: Move these helpers to some library API routine group. */
64 struct sr_channel_group *sr_channel_group_new(const char *name, void *priv);
65 void sr_channel_group_free(struct sr_channel_group *cg);
67 #define LOG_PREFIX "input/logicport"
69 #define MAX_CHANNELS 34
70 #define CHUNK_SIZE (4 * 1024 * 1024)
73 #define DC1_CHR '\x11'
74 #define DC1_STR "\x11"
75 #define CONT_OPEN "/" DC1_STR
76 #define CONT_CLOSE DC1_STR "/"
79 * This is some heuristics (read: a HACK). The current implementation
80 * neither processes nor displays the user's notes, but takes their
81 * presence as a hint that all relevant input was seen, and sample data
82 * can get forwarded to the session bus.
84 #define LAST_KEYWORD "NotesString"
87 * The vendor software supports signal groups, and a single signal can
88 * be a member in multiple groups at the same time. The sigrok project
89 * does not support that configuration. Let's ignore the "All Signals"
90 * group by default, thus reducing the probability of a conflict.
92 #define SKIP_SIGNAL_GROUP "All Signals"
94 struct signal_group_desc {
101 gboolean ch_feed_prep;
102 gboolean header_sent;
107 size_t channel_count;
108 size_t sample_lines_total;
109 size_t sample_lines_read;
110 size_t sample_lines_fed;
111 uint64_t samples_got_uncomp;
114 SAMPLEDATA_OPEN_BRACE,
115 SAMPLEDATA_WIRES_COUNT,
116 SAMPLEDATA_DATA_LINES,
117 SAMPLEDATA_CLOSE_BRACE,
119 struct sample_data_entry {
122 } *sample_data_queue;
123 uint64_t sample_rate;
124 uint64_t wires_all_mask;
125 uint64_t wires_enabled;
126 uint64_t wires_inverted;
127 uint64_t wires_undefined;
128 char *wire_names[MAX_CHANNELS];
129 char *signal_names[MAX_CHANNELS];
130 uint64_t wires_grouped;
131 GSList *signal_groups;
134 size_t samples_per_chunk;
135 size_t samples_in_buffer;
136 uint8_t *feed_buffer;
139 static struct signal_group_desc *alloc_signal_group(const char *name)
141 struct signal_group_desc *desc;
143 desc = g_malloc0(sizeof(*desc));
147 desc->name = g_strdup(name);
157 static void free_signal_group(struct signal_group_desc *desc)
165 struct sr_channel_group *sr_channel_group_new(const char *name, void *priv)
167 struct sr_channel_group *cg;
169 cg = g_malloc0(sizeof(*cg));
173 cg->name = g_strdup(name);
184 void sr_channel_group_free(struct sr_channel_group *cg)
189 g_slist_free(cg->channels);
192 /* Wrapper for GDestroyNotify compatibility. */
193 static void sg_free(void *p)
195 return free_signal_group(p);
198 static int check_vers_line(char *line, int need_key,
199 gchar **version, gchar **build)
201 static const char *keyword = "Version";
202 static const char *caution = " CAUTION: Do not change the contents of this file.";
204 const char *prev_ptr;
212 /* Expect the 'Version' literal, followed by a DC1 separator. */
214 if (strncmp(read_ptr, keyword, strlen(keyword)) != 0)
216 read_ptr += strlen(keyword);
217 if (*read_ptr != DC1_CHR)
222 /* Expect some "\d+\.\d+" style version string and DC1. */
228 read_ptr += strspn(read_ptr, "0123456789.");
229 if (read_ptr == prev_ptr)
231 if (*read_ptr != DC1_CHR)
235 /* Expect some "\d+" style build number and DC1. */
241 read_ptr += strspn(read_ptr, "0123456789");
242 if (read_ptr == prev_ptr)
244 if (*read_ptr != DC1_CHR)
248 /* Expect the 'CAUTION...' text (weak test, only part of the text). */
249 if (strncmp(read_ptr, caution, strlen(caution)) != 0)
251 read_ptr += strlen(caution);
253 /* No check for CRLF, due to the weak CAUTION test. */
257 static int process_wire_names(struct context *inc, char **names)
262 * The 'names' array contains the *wire* names, plus a 'Count'
263 * label for the last column.
265 count = g_strv_length(names);
266 if (count != inc->channel_count + 1)
268 if (strcmp(names[inc->channel_count], "Count") != 0)
271 for (idx = 0; idx < inc->channel_count; idx++)
272 inc->wire_names[idx] = g_strdup(names[idx]);
277 static int process_signal_names(struct context *inc, char **names)
282 * The 'names' array contains the *signal* names (and no other
283 * entries, unlike the *wire* names).
285 count = g_strv_length(names);
286 if (count != inc->channel_count)
289 for (idx = 0; idx < inc->channel_count; idx++)
290 inc->signal_names[idx] = g_strdup(names[idx]);
295 static int process_signal_group(struct context *inc, char **args)
298 struct signal_group_desc *desc;
299 uint64_t bit_tmpl, bit_mask;
304 * List of arguments that we receive:
306 * - [1] - [5] uncertain meaning, four integers and one boolean
307 * - [6] comma separated list of wire indices (zero based)
308 * - [7] - [9] uncertain meaning, a boolean, two integers
309 * - [10] - [35] uncertain meaning, 26 empty columns
312 /* Check for the minimum amount of input data. */
315 if (g_strv_length(args) < 7)
320 /* Accept empty names and empty signal lists. Silently ignore. */
323 if (!wires || !*wires)
326 * TODO: Introduce a user configurable "ignore" option? Skip the
327 * "All Signals" group by default, and in addition whatever
328 * the user specified?
330 if (strcmp(name, SKIP_SIGNAL_GROUP) == 0) {
331 sr_info("Skipping signal group '%s'", name);
336 * Create the descriptor here to store the member list to. We
337 * cannot access signal names and sigrok channels yet, they
338 * only become avilable at a later point in time.
340 desc = alloc_signal_group(name);
342 return SR_ERR_MALLOC;
343 inc->signal_groups = g_slist_append(inc->signal_groups, desc);
346 * Determine the bit mask of the group's signals' indices.
348 * Implementation note: Use a "template" for a single bit, to
349 * avoid portability issues with upper bits. Without this 64bit
350 * intermediate variable, I would not know how to phrase e.g.
351 * (1ULL << 33) in portable, robust, and easy to maintain ways
352 * on all platforms that are supported by sigrok.
359 idx = strtoul(p, &endp, 0);
360 if (!endp || endp == p)
362 if (*endp && *endp != ',')
367 if (idx >= MAX_CHANNELS)
369 bit_mask = bit_tmpl << idx;
370 if (inc->wires_grouped & bit_mask) {
371 sr_warn("Not adding signal at index %zu to group %s (multiple assignments)",
374 desc->mask |= bit_mask;
375 inc->wires_grouped |= bit_mask;
378 sr_dbg("'Group' done, name '%s', mask 0x%" PRIx64 ".",
379 desc->name, desc->mask);
384 static int process_ungrouped_signals(struct context *inc)
387 struct signal_group_desc *desc;
390 * Only create the "ungrouped" channel group if there are any
391 * groups of other signals already.
393 if (!inc->signal_groups)
397 * Determine the bit mask of signals that are part of the
398 * acquisition and are not a member of any other group.
400 bit_mask = inc->wires_all_mask;
401 bit_mask &= inc->wires_enabled;
402 bit_mask &= ~inc->wires_grouped;
403 sr_dbg("'ungrouped' check: all 0x%" PRIx64 ", en 0x%" PRIx64 ", grp 0x%" PRIx64 " -> un 0x%" PRIx64 ".",
404 inc->wires_all_mask, inc->wires_enabled,
405 inc->wires_grouped, bit_mask);
409 /* Create a sigrok channel group without a name. */
410 desc = alloc_signal_group(NULL);
412 return SR_ERR_MALLOC;
413 inc->signal_groups = g_slist_append(inc->signal_groups, desc);
414 desc->mask = bit_mask;
419 static int process_enabled_channels(struct context *inc, char **flags)
425 * The 'flags' array contains (the textual representation of)
426 * the "enabled" state of the acquisition device's channels.
428 count = g_strv_length(flags);
429 if (count != inc->channel_count)
433 for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
434 if (strcmp(flags[idx], "True") == 0)
437 inc->wires_enabled = bits;
442 static int process_inverted_channels(struct context *inc, char **flags)
448 * The 'flags' array contains (the textual representation of)
449 * the "inverted" state of the acquisition device's channels.
451 count = g_strv_length(flags);
452 if (count != inc->channel_count)
456 for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
457 if (strcmp(flags[idx], "True") == 0)
460 inc->wires_inverted = bits;
465 static int process_sample_line(struct context *inc, char **values)
468 struct sample_data_entry *entry;
474 * The 'values' array contains '0'/'1' text representation of
475 * wire's values, as well as a (a textual representation of a)
476 * repeat counter for that set of samples.
478 count = g_strv_length(values);
479 if (count != inc->channel_count + 1)
481 entry = &inc->sample_data_queue[inc->sample_lines_read];
484 for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
485 if (strcmp(values[idx], "1") == 0)
487 if (strcmp(values[idx], "U") == 0)
488 inc->wires_undefined |= mask;
490 rc = sr_atol(values[inc->channel_count], &conv_ret);
493 entry->repeat = conv_ret;
494 inc->samples_got_uncomp += entry->repeat;
499 static int process_keyvalue_line(struct context *inc, char *line)
501 char *sep, *key, *arg;
504 char *version, *build;
508 double period, dbl_rate;
512 * Process lines of the 'SampleData' block. Inspection of the
513 * block got started below in the "regular keyword line" section.
514 * The code here handles the remaining number of lines: Opening
515 * and closing braces, wire names, and sample data sets. Note
516 * that the wire names and sample values are separated by comma,
517 * not by DC1 like other key/value pairs and argument lists.
519 switch (inc->in_sample_data) {
520 case SAMPLEDATA_OPEN_BRACE:
521 if (strcmp(line, "{") != 0)
523 inc->in_sample_data++;
525 case SAMPLEDATA_WIRES_COUNT:
526 while (isspace(*line))
528 args = g_strsplit(line, ",", 0);
529 rc = process_wire_names(inc, args);
533 inc->in_sample_data++;
534 inc->sample_lines_read = 0;
536 case SAMPLEDATA_DATA_LINES:
537 while (isspace(*line))
539 args = g_strsplit(line, ",", 0);
540 rc = process_sample_line(inc, args);
544 inc->sample_lines_read++;
545 if (inc->sample_lines_read == inc->sample_lines_total)
546 inc->in_sample_data++;
548 case SAMPLEDATA_CLOSE_BRACE:
549 if (strcmp(line, "}") != 0)
551 sr_dbg("'SampleData' done: samples count %" PRIu64 ".",
552 inc->samples_got_uncomp);
553 inc->sample_lines_fed = 0;
554 inc->in_sample_data = SAMPLEDATA_NONE;
556 case SAMPLEDATA_NONE:
557 /* EMPTY */ /* Fall through to regular keyword-line logic. */
561 /* Process regular key/value lines separated by DC1. */
563 sep = strchr(line, DC1_CHR);
568 if (strcmp(key, "Version") == 0) {
569 rc = check_vers_line(arg, 0, &version, &build);
571 inc->sw_version = g_strdup(version ? version : "?");
572 rc = sr_atol(build, &build_num);
573 inc->sw_build = build_num;
575 sr_dbg("'Version' line: version %s, build %zu.",
576 inc->sw_version, inc->sw_build);
579 if (strcmp(key, "AcquiredSamplePeriod") == 0) {
580 rc = sr_atod(arg, &period);
584 * Implementation detail: The vendor's software provides
585 * 1/2/5 choices in the 1kHz - 500MHz range. Unfortunately
586 * the choice of saving the sample _period_ as a floating
587 * point number in the text file yields inaccurate results
588 * for naive implementations of the conversion (0.1 is an
589 * "odd number" in the computer's internal representation).
590 * The below logic of rounding to integer and then rounding
591 * to full kHz works for the samplerate value's range.
592 * "Simplifying" the implementation will introduce errors.
594 dbl_rate = 1.0 / period;
595 int_rate = (uint64_t)(dbl_rate + 0.5);
599 inc->sample_rate = int_rate;
600 if (!inc->sample_rate)
602 sr_dbg("Sample rate: %" PRIu64 ".", inc->sample_rate);
605 if (strcmp(key, "AcquiredChannelList") == 0) {
606 args = g_strsplit(arg, DC1_STR, 0);
607 rc = process_enabled_channels(inc, args);
611 sr_dbg("Enabled channels: 0x%" PRIx64 ".",
615 if (strcmp(key, "InvertedChannelList") == 0) {
616 args = g_strsplit(arg, DC1_STR, 0);
617 rc = process_inverted_channels(inc, args);
619 sr_dbg("Inverted channels: 0x%" PRIx64 ".",
620 inc->wires_inverted);
623 if (strcmp(key, "Signals") == 0) {
624 args = g_strsplit(arg, DC1_STR, 0);
625 rc = process_signal_names(inc, args);
629 sr_dbg("Got signal names.");
632 if (strcmp(key, "SampleData") == 0) {
633 args = g_strsplit(arg, DC1_STR, 3);
634 if (!args || !args[0] || !args[1]) {
638 rc = sr_atoi(args[0], &wires);
643 rc = sr_atoi(args[1], &samples);
649 if (!wires || !samples)
651 inc->channel_count = wires;
652 inc->sample_lines_total = samples;
653 sr_dbg("'SampleData' start: wires %zu, sample lines %zu.",
654 inc->channel_count, inc->sample_lines_total);
655 if (inc->channel_count > MAX_CHANNELS)
657 inc->in_sample_data = SAMPLEDATA_OPEN_BRACE;
658 alloc_size = sizeof(inc->sample_data_queue[0]);
659 alloc_size *= inc->sample_lines_total;
660 inc->sample_data_queue = g_malloc0(alloc_size);
661 if (!inc->sample_data_queue)
663 inc->sample_lines_fed = 0;
666 if (strcmp(key, "Group") == 0) {
667 args = g_strsplit(arg, DC1_STR, 0);
668 rc = process_signal_group(inc, args);
674 if (strcmp(key, LAST_KEYWORD) == 0) {
675 sr_dbg("'" LAST_KEYWORD "' seen, assuming \"header done\".");
676 inc->got_header = TRUE;
680 /* Unsupported keyword, silently ignore the line. */
684 /* Check for, and isolate another line of text input. */
685 static int have_text_line(struct sr_input *in, char **line, char **next)
687 char *sol_ptr, *eol_ptr;
689 if (!in || !in->buf || !in->buf->str)
691 sol_ptr = in->buf->str;
692 eol_ptr = strstr(sol_ptr, CRLF);
698 eol_ptr += strlen(CRLF);
705 /* Handle line continuation. Have logical lines processed. */
706 static int process_text_line(struct context *inc, char *line)
713 * Handle line continuation in the input stream. Notice that
714 * continued lines can start and end on the same input line.
715 * The text between the markers can be empty, too.
717 * Make the result look like a regular line. Put a DC1 delimiter
718 * between the keyword and the right hand side. Strip the /<DC1>
719 * and <DC1>/ "braces". Put CRLF between all continued parts,
720 * this makes the data appear "most intuitive and natural"
721 * should we e.g. pass on user's notes in a future version.
724 if (!inc->cont_buff) {
725 p = strstr(line, CONT_OPEN);
727 /* Start of continuation. */
728 inc->cont_buff = g_string_new_len(line, p - line + 1);
729 inc->cont_buff->str[inc->cont_buff->len - 1] = DC1_CHR;
730 line = p + strlen(CONT_OPEN);
732 /* Regular line, fall through to below regular logic. */
734 if (inc->cont_buff) {
735 p = strstr(line, CONT_CLOSE);
736 is_cont_end = p != NULL;
739 g_string_append_len(inc->cont_buff, line, strlen(line));
741 /* Keep accumulating. */
742 g_string_append_len(inc->cont_buff, CRLF, strlen(CRLF));
745 /* End of continuation. */
746 line = inc->cont_buff->str;
750 * Process a logical line of input. It either was received from
751 * the caller, or is the result of accumulating continued lines.
753 rc = process_keyvalue_line(inc, line);
755 /* Release the accumulation buffer when a continuation ended. */
757 g_string_free(inc->cont_buff, TRUE);
758 inc->cont_buff = NULL;
764 /* Tell whether received data is sufficient for session feed preparation. */
765 static int have_header(GString *buf)
767 const char *assumed_last_key = CRLF LAST_KEYWORD CONT_OPEN;
769 if (strstr(buf->str, assumed_last_key))
775 /* Process/inspect previously received input data. Get header parameters. */
776 static int parse_header(struct sr_input *in)
783 while (have_text_line(in, &line, &next)) {
784 rc = process_text_line(inc, line);
785 g_string_erase(in->buf, 0, next - line);
793 /* Create sigrok channels and groups. Allocate the session feed buffer. */
794 static int create_channels_groups_buffer(struct sr_input *in)
801 struct sr_channel *ch;
802 struct sr_dev_inst *sdi;
804 struct signal_group_desc *desc;
805 struct sr_channel_group *cg;
810 for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
811 name = inc->signal_names[idx];
813 name = inc->wire_names[idx];
814 enabled = (inc->wires_enabled & mask) ? TRUE : FALSE;
815 ch = sr_channel_new(in->sdi, idx,
816 SR_CHANNEL_LOGIC, enabled, name);
818 return SR_ERR_MALLOC;
819 inc->channels = g_slist_append(inc->channels, ch);
823 for (l = inc->signal_groups; l; l = l->next) {
825 cg = sr_channel_group_new(desc->name, NULL);
827 return SR_ERR_MALLOC;
828 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
830 for (idx = 0; idx < inc->channel_count; idx++, mask <<= 1) {
831 if (!(desc->mask & mask))
833 ch = g_slist_nth_data(inc->channels, idx);
836 cg->channels = g_slist_append(cg->channels, ch);
840 inc->unitsize = (inc->channel_count + 7) / 8;
841 inc->samples_per_chunk = CHUNK_SIZE / inc->unitsize;
842 inc->samples_in_buffer = 0;
843 inc->feed_buffer = g_malloc0(inc->samples_per_chunk * inc->unitsize);
844 if (!inc->feed_buffer)
845 return SR_ERR_MALLOC;
850 /* Send all accumulated sample data values to the session. */
851 static int send_buffer(struct sr_input *in)
854 struct sr_datafeed_packet packet;
855 struct sr_datafeed_meta meta;
856 struct sr_config *src;
857 struct sr_datafeed_logic logic;
861 if (!inc->samples_in_buffer)
864 if (!inc->header_sent) {
865 rc = std_session_send_df_header(in->sdi);
868 inc->header_sent = TRUE;
871 if (inc->sample_rate && !inc->rate_sent) {
872 packet.type = SR_DF_META;
873 packet.payload = &meta;
874 src = sr_config_new(SR_CONF_SAMPLERATE,
875 g_variant_new_uint64(inc->sample_rate));
876 meta.config = g_slist_append(NULL, src);
877 rc = sr_session_send(in->sdi, &packet);
878 g_slist_free(meta.config);
882 inc->rate_sent = TRUE;
885 packet.type = SR_DF_LOGIC;
886 packet.payload = &logic;
887 logic.unitsize = inc->unitsize;
888 logic.data = inc->feed_buffer;
889 logic.length = inc->unitsize * inc->samples_in_buffer;
890 rc = sr_session_send(in->sdi, &packet);
892 inc->samples_in_buffer = 0;
901 * Add N copies of the current sample to the buffer. Send the buffer to
902 * the session feed when a maximum amount of data was collected.
904 static int add_samples(struct sr_input *in, uint64_t samples, size_t count)
907 uint8_t sample_buffer[sizeof(uint64_t)];
914 for (idx = 0; idx < inc->unitsize; idx++) {
915 sample_buffer[idx] = samples & 0xff;
919 copy_count = inc->samples_per_chunk - inc->samples_in_buffer;
920 if (copy_count > count)
924 p = inc->feed_buffer + inc->samples_in_buffer * inc->unitsize;
925 while (copy_count-- > 0) {
926 memcpy(p, sample_buffer, inc->unitsize);
928 inc->samples_in_buffer++;
931 if (inc->samples_in_buffer == inc->samples_per_chunk) {
932 rc = send_buffer(in);
941 /* Pass on previously received samples to the session. */
942 static int process_queued_samples(struct sr_input *in)
945 struct sample_data_entry *entry;
946 uint64_t sample_bits;
950 while (inc->sample_lines_fed < inc->sample_lines_total) {
951 entry = &inc->sample_data_queue[inc->sample_lines_fed++];
952 sample_bits = entry->bits;
953 sample_bits ^= inc->wires_inverted;
954 sample_bits &= inc->wires_enabled;
955 rc = add_samples(in, sample_bits, entry->repeat);
964 * Create required resources between having read the input file and
965 * sending sample data to the session. Send initial packets before
966 * sample data follows.
968 static int prepare_session_feed(struct sr_input *in)
974 if (inc->ch_feed_prep)
977 /* Got channel names? At least fallbacks? */
978 if (!inc->wire_names[0] || !inc->wire_names[0][0])
980 /* Samples seen? Seen them all? */
981 if (!inc->channel_count)
983 if (!inc->sample_lines_total)
985 if (inc->in_sample_data)
987 if (!inc->sample_data_queue)
989 inc->sample_lines_fed = 0;
992 * Normalize some variants of input data.
993 * - Let's create a mask for the maximum possible
994 * bit positions, it will be useful to avoid garbage
995 * in other code paths, too.
996 * - Input files _might_ specify which channels were
997 * enabled during acquisition. _Or_ not specify the
998 * enabled channels, but provide 'U' values in some
999 * columns. When neither was seen, assume that all
1000 * channels are enabled.
1001 * - If there are any signal groups, put all signals into
1002 * an anonymous group that are not part of another group.
1004 inc->wires_all_mask = 1UL << 0;
1005 inc->wires_all_mask <<= inc->channel_count;
1006 inc->wires_all_mask--;
1007 sr_dbg("all wires mask: 0x%" PRIx64 ".", inc->wires_all_mask);
1008 if (!inc->wires_enabled) {
1009 inc->wires_enabled = ~inc->wires_undefined;
1010 inc->wires_enabled &= ~inc->wires_all_mask;
1011 sr_dbg("enabled from undefined: 0x%" PRIx64 ".",
1012 inc->wires_enabled);
1014 if (!inc->wires_enabled) {
1015 inc->wires_enabled = inc->wires_all_mask;
1016 sr_dbg("enabled from total mask: 0x%" PRIx64 ".",
1017 inc->wires_enabled);
1019 sr_dbg("enabled mask: 0x%" PRIx64 ".",
1020 inc->wires_enabled);
1021 rc = process_ungrouped_signals(inc);
1026 * "Start" the session: Create channels, send the DF
1027 * header to the session. Optionally send the sample
1028 * rate before sample data will be sent.
1030 rc = create_channels_groups_buffer(in);
1034 inc->ch_feed_prep = TRUE;
1039 static int format_match(GHashTable *metadata)
1041 GString *buf, *tmpbuf;
1043 gchar *version, *build;
1045 /* Get a copy of the start of the file's content. */
1046 buf = g_hash_table_lookup(metadata, GINT_TO_POINTER(SR_INPUT_META_HEADER));
1047 if (!buf || !buf->str)
1049 tmpbuf = g_string_new_len(buf->str, buf->len);
1050 if (!tmpbuf || !tmpbuf->str)
1051 return SR_ERR_MALLOC;
1053 /* See if we can spot a typical first LPF line. */
1054 rc = check_vers_line(tmpbuf->str, 1, &version, &build);
1055 if (rc == SR_OK && version && build) {
1056 sr_dbg("Looks like a LogicProbe project, version %s, build %s.",
1059 g_string_free(tmpbuf, TRUE);
1064 static int init(struct sr_input *in, GHashTable *options)
1066 struct context *inc;
1070 in->sdi = g_malloc0(sizeof(*in->sdi));
1072 inc = g_malloc0(sizeof(*inc));
1074 return SR_ERR_MALLOC;
1080 static int receive(struct sr_input *in, GString *buf)
1082 struct context *inc;
1085 /* Accumulate another chunk of input data. */
1086 g_string_append_len(in->buf, buf->str, buf->len);
1089 * Wait for the full header's availability, then process it in a
1090 * single call, and set the "ready" flag. Make sure sample data
1091 * and the header get processed in disjoint calls to receive(),
1092 * the backend requires those separate phases.
1095 if (!inc->got_header) {
1096 if (!have_header(in->buf))
1098 rc = parse_header(in);
1101 rc = prepare_session_feed(in);
1104 in->sdi_ready = TRUE;
1108 /* Process sample data, after the header got processed. */
1109 rc = process_queued_samples(in);
1114 static int end(struct sr_input *in)
1116 struct context *inc;
1119 /* Nothing to do here if we never started feeding the session. */
1124 * Process sample data that may not have been forwarded before.
1125 * Flush any potentially queued samples.
1127 rc = process_queued_samples(in);
1130 rc = send_buffer(in);
1134 /* End the session feed if one was started. */
1136 if (inc->header_sent) {
1137 rc = std_session_send_df_end(in->sdi);
1138 inc->header_sent = FALSE;
1144 static void cleanup(struct sr_input *in)
1146 struct context *inc;
1157 * Release potentially allocated resources. Void all references
1158 * and scalars, so that re-runs start out fresh again.
1160 g_free(inc->sw_version);
1161 g_string_free(inc->cont_buff, TRUE);
1162 g_free(inc->sample_data_queue);
1163 for (idx = 0; idx < inc->channel_count; idx++)
1164 g_free(inc->wire_names[idx]);
1165 for (idx = 0; idx < inc->channel_count; idx++)
1166 g_free(inc->signal_names[idx]);
1167 g_slist_free_full(inc->signal_groups, sg_free);
1168 g_slist_free_full(inc->channels, g_free);
1169 g_free(inc->feed_buffer);
1170 memset(inc, 0, sizeof(*inc));
1173 static int reset(struct sr_input *in)
1175 struct context *inc;
1179 inc->ch_feed_prep = FALSE;
1180 inc->header_sent = FALSE;
1181 inc->rate_sent = FALSE;
1182 g_string_truncate(in->buf, 0);
1187 static struct sr_option options[] = {
1191 static const struct sr_option *get_options(void)
1196 SR_PRIV struct sr_input_module input_logicport = {
1198 .name = "LogicPort File",
1199 .desc = "Intronix LA1034 LogicPort project",
1200 .exts = (const char *[]){ "lpf", NULL },
1201 .metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
1202 .options = get_options,
1203 .format_match = format_match,