2 * This file is part of the libsigrok project.
4 * Copyright (C) 2012 Petteri Aimonen <jpa@sr.mail.kapsi.fi>
5 * Copyright (C) 2014 Bert Vermeulen <bert@biot.com>
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 /* The VCD input module has the following options:
23 * numchannels: Maximum number of channels to use. The channels are
24 * detected in the same order as they are listed
25 * in the $var sections of the VCD file.
27 * skip: Allows skipping until given timestamp in the file.
28 * This can speed up analyzing of long captures.
30 * Value < 0: Skip until first timestamp listed in
33 * Value = 0: Do not skip, instead generate samples
34 * beginning from timestamp 0.
36 * Value > 0: Start at the given timestamp.
38 * downsample: Divide the samplerate by the given factor.
39 * This can speed up analyzing of long captures.
41 * compress: Compress idle periods longer than this value.
42 * This can speed up analyzing of long captures.
43 * Default 0 = don't compress.
45 * Based on Verilog standard IEEE Std 1364-2001 Version C
48 * - $var with 'wire' and 'reg' types of scalar variables
49 * - $timescale definition for samplerate
50 * - multiple character variable identifiers
52 * Most important unsupported features:
53 * - vector variables (bit vectors etc.)
54 * - analog, integer and real number variables
55 * - $dumpvars initial value declaration
57 * - more than 64 channels
64 #include "libsigrok.h"
65 #include "libsigrok-internal.h"
67 #define LOG_PREFIX "input/vcd"
69 #define DEFAULT_NUM_CHANNELS 8
70 #define CHUNKSIZE 1024
76 unsigned int maxchannels;
77 unsigned int channelcount;
81 gboolean skip_until_end;
92 * Reads a single VCD section from input file and parses it to name/contents.
93 * e.g. $timescale 1ps $end => "timescale" "1ps"
95 static gboolean parse_section(GString *buf, gchar **name, gchar **contents)
97 GString *sname, *scontent;
101 *name = *contents = NULL;
105 /* Skip any initial white-space. */
106 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
109 /* Section tag should start with $. */
110 if (buf->str[pos++] != '$')
113 sname = g_string_sized_new(32);
114 scontent = g_string_sized_new(128);
116 /* Read the section tag. */
117 while (pos < buf->len && !g_ascii_isspace(buf->str[pos]))
118 g_string_append_c(sname, buf->str[pos++]);
120 /* Skip whitespace before content. */
121 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
124 /* Read the content. */
125 while (pos < buf->len - 4 && strncmp(buf->str + pos, "$end", 4))
126 g_string_append_c(scontent, buf->str[pos++]);
128 if (sname->len && pos < buf->len - 4 && !strncmp(buf->str + pos, "$end", 4)) {
131 while (pos < buf->len && g_ascii_isspace(buf->str[pos]))
133 g_string_erase(buf, 0, pos);
136 *name = g_string_free(sname, !status);
137 *contents = g_string_free(scontent, !status);
139 g_strchomp(*contents);
144 static void free_channel(void *data)
146 struct vcd_channel *vcd_ch = data;
147 g_free(vcd_ch->name);
148 g_free(vcd_ch->identifier);
152 /* Remove empty parts from an array returned by g_strsplit. */
153 static void remove_empty_parts(gchar **parts)
156 gchar **dest = parts;
157 while (*src != NULL) {
167 * Parse VCD header to get values for context structure.
168 * The context structure should be zeroed before calling this.
170 static gboolean parse_header(const struct sr_input *in, GString *buf)
172 struct vcd_channel *vcd_ch;
176 gchar *name, *contents, **parts;
179 name = contents = NULL;
181 while (parse_section(buf, &name, &contents)) {
182 sr_dbg("Section '%s', contents '%s'.", name, contents);
184 if (g_strcmp0(name, "enddefinitions") == 0) {
187 } else if (g_strcmp0(name, "timescale") == 0) {
189 * The standard allows for values 1, 10 or 100
190 * and units s, ms, us, ns, ps and fs.
192 if (sr_parse_period(contents, &p, &q) == SR_OK) {
193 inc->samplerate = q / p;
195 /* Does not happen unless time value is non-standard */
196 sr_warn("Inexact rounding of samplerate, %" PRIu64 " / %" PRIu64 " to %" PRIu64 " Hz.",
197 q, p, inc->samplerate);
200 sr_dbg("Samplerate: %" PRIu64, inc->samplerate);
202 sr_err("Parsing timescale failed.");
204 } else if (g_strcmp0(name, "var") == 0) {
205 /* Format: $var type size identifier reference $end */
206 parts = g_strsplit_set(contents, " \r\n\t", 0);
207 remove_empty_parts(parts);
209 if (g_strv_length(parts) != 4)
210 sr_warn("$var section should have 4 items");
211 else if (g_strcmp0(parts[0], "reg") != 0 && g_strcmp0(parts[0], "wire") != 0)
212 sr_info("Unsupported signal type: '%s'", parts[0]);
213 else if (strtol(parts[1], NULL, 10) != 1)
214 sr_info("Unsupported signal size: '%s'", parts[1]);
215 else if (inc->channelcount >= inc->maxchannels)
216 sr_warn("Skipping '%s' because only %d channels requested.",
217 parts[3], inc->maxchannels);
219 sr_info("Channel %d is '%s' identified by '%s'.",
220 inc->channelcount, parts[3], parts[2]);
221 vcd_ch = g_malloc(sizeof(struct vcd_channel));
222 vcd_ch->identifier = g_strdup(parts[2]);
223 vcd_ch->name = g_strdup(parts[3]);
224 inc->channels = g_slist_append(inc->channels, vcd_ch);
231 g_free(name); name = NULL;
232 g_free(contents); contents = NULL;
237 inc->got_header = status;
242 static int format_match(GHashTable *metadata)
244 GString *buf, *tmpbuf;
246 gchar *name, *contents;
248 buf = g_hash_table_lookup(metadata, GINT_TO_POINTER(SR_INPUT_META_HEADER));
249 tmpbuf = g_string_new_len(buf->str, buf->len);
252 * If we can parse the first section correctly,
253 * then it is assumed to be a VCD file.
255 status = parse_section(tmpbuf, &name, &contents);
256 g_string_free(tmpbuf, TRUE);
260 return status ? SR_OK : SR_ERR;
263 /* Send N samples of the given value. */
264 static void send_samples(const struct sr_dev_inst *sdi, uint64_t sample, uint64_t count)
266 struct sr_datafeed_packet packet;
267 struct sr_datafeed_logic logic;
268 uint64_t buffer[CHUNKSIZE];
270 unsigned chunksize = CHUNKSIZE;
272 if (count < chunksize)
275 for (i = 0; i < chunksize; i++)
278 packet.type = SR_DF_LOGIC;
279 packet.payload = &logic;
280 logic.unitsize = sizeof(uint64_t);
284 if (count < chunksize)
287 logic.length = sizeof(uint64_t) * chunksize;
289 sr_session_send(sdi, &packet);
294 /* Parse a set of lines from the data section. */
295 static void parse_contents(const struct sr_input *in, char *data)
298 struct vcd_channel *vcd_ch;
300 uint64_t timestamp, prev_timestamp, prev_values;
301 unsigned int bit, i, j;
305 prev_timestamp = prev_values = 0;
307 /* Read one space-delimited token at a time. */
308 tokens = g_strsplit_set(data, " \t\r\n", 0);
309 remove_empty_parts(tokens);
310 for (i = 0; tokens[i]; i++) {
311 if (inc->skip_until_end) {
312 if (!strcmp(tokens[i], "$end")) {
313 /* Done with unhandled/unknown section. */
314 inc->skip_until_end = FALSE;
318 if (tokens[i][0] == '#' && g_ascii_isdigit(tokens[i][1])) {
319 /* Numeric value beginning with # is a new timestamp value */
320 timestamp = strtoull(tokens[i] + 1, NULL, 10);
322 if (inc->downsample > 1)
323 timestamp /= inc->downsample;
326 * Skip < 0 => skip until first timestamp.
327 * Skip = 0 => don't skip
328 * Skip > 0 => skip until timestamp >= skip.
331 inc->skip = timestamp;
332 prev_timestamp = timestamp;
333 } else if (inc->skip > 0 && timestamp < (uint64_t)inc->skip) {
334 prev_timestamp = inc->skip;
335 } else if (timestamp == prev_timestamp) {
336 /* Ignore repeated timestamps (e.g. sigrok outputs these) */
338 if (inc->compress != 0 && timestamp - prev_timestamp > inc->compress) {
339 /* Compress long idle periods */
340 prev_timestamp = timestamp - inc->compress;
343 sr_dbg("New timestamp: %" PRIu64, timestamp);
345 /* Generate samples from prev_timestamp up to timestamp - 1. */
346 send_samples(in->sdi, prev_values, timestamp - prev_timestamp);
347 prev_timestamp = timestamp;
349 } else if (tokens[i][0] == '$' && tokens[i][1] != '\0') {
351 * This is probably a $dumpvars, $comment or similar.
352 * $dump* contain useful data.
354 if (g_strcmp0(tokens[i], "$dumpvars") == 0
355 || g_strcmp0(tokens[i], "$dumpon") == 0
356 || g_strcmp0(tokens[i], "$dumpoff") == 0
357 || g_strcmp0(tokens[i], "$end") == 0) {
358 /* Ignore, parse contents as normally. */
360 /* Ignore this and future lines until $end. */
361 inc->skip_until_end = TRUE;
364 } else if (strchr("bBrR", tokens[i][0]) != NULL) {
365 /* A vector value, not supported yet. */
367 } else if (strchr("01xXzZ", tokens[i][0]) != NULL) {
368 /* A new 1-bit sample value */
369 bit = (tokens[i][0] == '1');
372 * The identifier is either the next character, or, if
373 * there was whitespace after the bit, the next token.
375 if (tokens[i][1] == '\0') {
377 /* Missing identifier */
380 for (j = 1; tokens[i][j]; j++)
381 tokens[i][j - 1] = tokens[i][j];
382 tokens[i][j - 1] = '\0';
385 for (j = 0, l = inc->channels; j < inc->channelcount && l; j++, l = l->next) {
387 if (g_strcmp0(tokens[i], vcd_ch->identifier) == 0) {
388 /* Found our channel */
390 prev_values |= (uint64_t)1 << j;
392 prev_values &= ~((uint64_t)1 << j);
396 if (j == inc->channelcount)
397 sr_dbg("Did not find channel for identifier '%s'.", tokens[i]);
399 sr_warn("Skipping unknown token '%s'.", tokens[i]);
405 static int init(struct sr_input *in, GHashTable *options)
407 struct sr_channel *ch;
412 inc = g_malloc0(sizeof(struct context));
414 num_channels = g_variant_get_int32(g_hash_table_lookup(options, "numchannels"));
415 if (num_channels < 1) {
416 sr_err("Invalid value for numchannels: must be at least 1.");
419 if (num_channels > 64) {
420 sr_err("No more than 64 channels supported.");
423 inc->maxchannels = num_channels;
425 inc->downsample = g_variant_get_int32(g_hash_table_lookup(options, "downsample"));
426 if (inc->downsample < 1)
429 inc->compress = g_variant_get_int32(g_hash_table_lookup(options, "compress"));
430 inc->skip = g_variant_get_int32(g_hash_table_lookup(options, "skip"));
431 inc->skip /= inc->downsample;
433 in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL);
436 for (i = 0; i < num_channels; i++) {
437 snprintf(name, 16, "%d", i);
438 ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, name);
439 in->sdi->channels = g_slist_append(in->sdi->channels, ch);
445 static gboolean have_header(GString *buf)
450 if (!(p = g_strstr_len(buf->str, buf->len, "$enddefinitions")))
452 pos = p - buf->str + 15;
453 while (pos < buf->len - 4 && g_ascii_isspace(buf->str[pos]))
455 if (!strncmp(buf->str + pos, "$end", 4))
461 static int receive(const struct sr_input *in, GString *buf)
463 struct sr_datafeed_packet packet;
464 struct sr_datafeed_meta meta;
465 struct sr_config *src;
470 g_string_append_len(in->buf, buf->str, buf->len);
473 if (!inc->got_header) {
474 if (!have_header(in->buf))
476 if (!parse_header(in, in->buf) != SR_OK)
477 /* There was a header in there, but it was malformed. */
480 std_session_send_df_header(in->sdi, LOG_PREFIX);
483 packet.type = SR_DF_META;
484 packet.payload = &meta;
485 samplerate = inc->samplerate / inc->downsample;
486 src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(samplerate));
487 meta.config = g_slist_append(NULL, src);
488 sr_session_send(in->sdi, &packet);
492 while ((p = g_strrstr_len(in->buf->str, in->buf->len, "\n"))) {
494 g_strstrip(in->buf->str);
495 if (in->buf->str[0] != '\0')
496 parse_contents(in, in->buf->str);
497 g_string_erase(in->buf, 0, p - in->buf->str + 1);
503 static int cleanup(struct sr_input *in)
505 struct sr_datafeed_packet packet;
511 packet.type = SR_DF_END;
512 sr_session_send(in->sdi, &packet);
515 g_slist_free_full(inc->channels, free_channel);
522 static struct sr_option options[] = {
523 { "numchannels", "Number of channels", "Number of channels", NULL, NULL },
524 { "skip", "Skip", "Skip until timestamp", NULL, NULL },
525 { "downsample", "Downsample", "Divide samplerate by factor", NULL, NULL },
526 { "compress", "Compress", "Compress idle periods longer than this value", NULL, NULL },
530 static struct sr_option *get_options(void)
532 if (!options[0].def) {
533 options[0].def = g_variant_ref_sink(g_variant_new_int32(DEFAULT_NUM_CHANNELS));
534 options[1].def = g_variant_ref_sink(g_variant_new_int32(-1));
535 options[2].def = g_variant_ref_sink(g_variant_new_int32(1));
536 options[3].def = g_variant_ref_sink(g_variant_new_int32(0));
542 SR_PRIV struct sr_input_module input_vcd = {
545 .desc = "Value Change Dump",
546 .metadata = { SR_INPUT_META_HEADER | SR_INPUT_META_REQUIRED },
547 .options = get_options,
548 .format_match = format_match,