X-Git-Url: https://sigrok.org/gitweb/?p=sigrok-cli.git;a=blobdiff_plain;f=sigrok-cli.c;h=6feabd4df3838e281dda077a76007537f2976a7f;hp=b88250f1dae1df7e6bf5ba4b0c382ab532c9d1ad;hb=1cf6a109935a29127f6df954da2defdc73bdedaf;hpb=a210c4ccc2a730c8e02e3f330fbff36b7f81e2da diff --git a/sigrok-cli.c b/sigrok-cli.c index b88250f..6feabd4 100644 --- a/sigrok-cli.c +++ b/sigrok-cli.c @@ -30,21 +30,21 @@ #include #include #include -#include +#include #include "sigrok-cli.h" #include "config.h" #define DEFAULT_OUTPUT_FORMAT "bits:width=64" -extern struct sr_hwcap_option sr_hwcap_options[]; +static struct sr_context *sr_ctx = NULL; -static gboolean debug = 0; static uint64_t limit_samples = 0; +static uint64_t limit_frames = 0; static struct sr_output_format *output_format = NULL; static int default_output_format = FALSE; static char *output_format_param = NULL; -static char *input_format_param = NULL; -static GData *pd_ann_visible = NULL; +static GHashTable *pd_ann_visible = NULL; +static GByteArray *savebuf; static gboolean opt_version = FALSE; static gint opt_loglevel = SR_LOG_WARN; /* Show errors+warnings per default. */ @@ -52,40 +52,158 @@ static gboolean opt_list_devs = FALSE; static gboolean opt_wait_trigger = FALSE; static gchar *opt_input_file = NULL; static gchar *opt_output_file = NULL; +static gchar *opt_drv = NULL; static gchar *opt_dev = NULL; static gchar *opt_probes = NULL; static gchar *opt_triggers = NULL; static gchar *opt_pds = NULL; static gchar *opt_pd_stack = NULL; +static gchar *opt_pd_annotations = NULL; static gchar *opt_input_format = NULL; -static gchar *opt_format = NULL; +static gchar *opt_output_format = NULL; +static gchar *opt_show = NULL; static gchar *opt_time = NULL; static gchar *opt_samples = NULL; +static gchar *opt_frames = NULL; static gchar *opt_continuous = NULL; static GOptionEntry optargs[] = { - {"version", 'V', 0, G_OPTION_ARG_NONE, &opt_version, "Show version and support list", NULL}, - {"loglevel", 'l', 0, G_OPTION_ARG_INT, &opt_loglevel, "Select libsigrok loglevel", NULL}, - {"list-devices", 'D', 0, G_OPTION_ARG_NONE, &opt_list_devs, "List devices", NULL}, - {"input-file", 'i', 0, G_OPTION_ARG_FILENAME, &opt_input_file, "Load input from file", NULL}, - {"output-file", 'o', 0, G_OPTION_ARG_FILENAME, &opt_output_file, "Save output to file", NULL}, - {"device", 'd', 0, G_OPTION_ARG_STRING, &opt_dev, "Use device ID", NULL}, - {"probes", 'p', 0, G_OPTION_ARG_STRING, &opt_probes, "Probes to use", NULL}, - {"triggers", 't', 0, G_OPTION_ARG_STRING, &opt_triggers, "Trigger configuration", NULL}, - {"wait-trigger", 'w', 0, G_OPTION_ARG_NONE, &opt_wait_trigger, "Wait for trigger", NULL}, - {"protocol-decoders", 'a', 0, G_OPTION_ARG_STRING, &opt_pds, "Protocol decoder sequence", NULL}, - {"protocol-decoder-stack", 's', 0, G_OPTION_ARG_STRING, &opt_pd_stack, "Protocol decoder stack", NULL}, - {"input-format", 'I', 0, G_OPTION_ARG_STRING, &opt_input_format, "Input format", NULL}, - {"format", 'f', 0, G_OPTION_ARG_STRING, &opt_format, "Output format", NULL}, - {"time", 0, 0, G_OPTION_ARG_STRING, &opt_time, "How long to sample (ms)", NULL}, - {"samples", 0, 0, G_OPTION_ARG_STRING, &opt_samples, "Number of samples to acquire", NULL}, - {"continuous", 0, 0, G_OPTION_ARG_NONE, &opt_continuous, "Sample continuously", NULL}, + {"version", 'V', 0, G_OPTION_ARG_NONE, &opt_version, + "Show version and support list", NULL}, + {"loglevel", 'l', 0, G_OPTION_ARG_INT, &opt_loglevel, + "Set libsigrok/libsigrokdecode loglevel", NULL}, + {"list-devices", 'D', 0, G_OPTION_ARG_NONE, &opt_list_devs, + "Scan for devices", NULL}, + {"driver", 0, 0, G_OPTION_ARG_STRING, &opt_drv, + "Use only this driver", NULL}, + {"device", 'd', 0, G_OPTION_ARG_STRING, &opt_dev, + "Use specified device", NULL}, + {"input-file", 'i', 0, G_OPTION_ARG_FILENAME, &opt_input_file, + "Load input from file", NULL}, + {"input-format", 'I', 0, G_OPTION_ARG_STRING, &opt_input_format, + "Input format", NULL}, + {"output-file", 'o', 0, G_OPTION_ARG_FILENAME, &opt_output_file, + "Save output to file", NULL}, + {"output-format", 'O', 0, G_OPTION_ARG_STRING, &opt_output_format, + "Output format", NULL}, + {"probes", 'p', 0, G_OPTION_ARG_STRING, &opt_probes, + "Probes to use", NULL}, + {"triggers", 't', 0, G_OPTION_ARG_STRING, &opt_triggers, + "Trigger configuration", NULL}, + {"wait-trigger", 'w', 0, G_OPTION_ARG_NONE, &opt_wait_trigger, + "Wait for trigger", NULL}, + {"protocol-decoders", 'a', 0, G_OPTION_ARG_STRING, &opt_pds, + "Protocol decoders to run", NULL}, + {"protocol-decoder-stack", 's', 0, G_OPTION_ARG_STRING, &opt_pd_stack, + "Protocol decoder stack", NULL}, + {"protocol-decoder-annotations", 'A', 0, G_OPTION_ARG_STRING, &opt_pd_annotations, + "Protocol decoder annotation(s) to show", NULL}, + {"show", 0, 0, G_OPTION_ARG_NONE, &opt_show, + "Show device detail", NULL}, + {"time", 0, 0, G_OPTION_ARG_STRING, &opt_time, + "How long to sample (ms)", NULL}, + {"samples", 0, 0, G_OPTION_ARG_STRING, &opt_samples, + "Number of samples to acquire", NULL}, + {"frames", 0, 0, G_OPTION_ARG_STRING, &opt_frames, + "Number of frames to acquire", NULL}, + {"continuous", 0, 0, G_OPTION_ARG_NONE, &opt_continuous, + "Sample continuously", NULL}, {NULL, 0, 0, 0, NULL, NULL, NULL} }; + +/* Convert driver options hash to GSList of struct sr_config. */ +static GSList *hash_to_hwopt(GHashTable *hash) +{ + const struct sr_config_info *srci; + struct sr_config *src; + GList *gl, *keys; + GSList *opts; + char *key, *value; + + keys = g_hash_table_get_keys(hash); + opts = NULL; + for (gl = keys; gl; gl = gl->next) { + key = gl->data; + if (!(srci = sr_config_info_name_get(key))) { + g_critical("Unknown option %s", key); + return NULL; + } + src = g_try_malloc(sizeof(struct sr_config)); + src->key = srci->key; + value = g_hash_table_lookup(hash, key); + src->value = g_strdup(value); + opts = g_slist_append(opts, src); + } + g_list_free(keys); + + return opts; +} + +static void free_drvopts(struct sr_config *src) +{ + g_free((void *)src->value); + g_free(src); +} + +static GSList *device_scan(void) +{ + struct sr_dev_driver **drivers, *driver; + GHashTable *drvargs; + GSList *drvopts, *devices, *tmpdevs, *l; + int i; + char *drvname; + + if (opt_drv) { + drvargs = parse_generic_arg(opt_drv, TRUE); + drvname = g_strdup(g_hash_table_lookup(drvargs, "sigrok_key")); + g_hash_table_remove(drvargs, "sigrok_key"); + driver = NULL; + drivers = sr_driver_list(); + for (i = 0; drivers[i]; i++) { + if (strcmp(drivers[i]->name, drvname)) + continue; + driver = drivers[i]; + } + if (!driver) { + g_critical("Driver %s not found.", drvname); + return NULL; + } + g_free(drvname); + if (sr_driver_init(sr_ctx, driver) != SR_OK) { + g_critical("Failed to initialize driver."); + return NULL; + } + drvopts = NULL; + if (g_hash_table_size(drvargs) > 0) + if (!(drvopts = hash_to_hwopt(drvargs))) + /* Unknown options, already logged. */ + return NULL; + devices = sr_driver_scan(driver, drvopts); + g_slist_free_full(drvopts, (GDestroyNotify)free_drvopts); + } else { + /* No driver specified, let them all scan on their own. */ + devices = NULL; + drivers = sr_driver_list(); + for (i = 0; drivers[i]; i++) { + driver = drivers[i]; + if (sr_driver_init(sr_ctx, driver) != SR_OK) { + g_critical("Failed to initialize driver."); + return NULL; + } + tmpdevs = sr_driver_scan(driver, NULL); + for (l = tmpdevs; l; l = l->next) + devices = g_slist_append(devices, l->data); + g_slist_free(tmpdevs); + } + } + + return devices; +} + static void show_version(void) { - GSList *l; + const GSList *l; struct sr_dev_driver **drivers; struct sr_input_format **inputs; struct sr_output_format **outputs; @@ -94,8 +212,13 @@ static void show_version(void) printf("sigrok-cli %s\n\n", VERSION); + printf("Using libsigrok %s (lib version %s).\n", + sr_package_version_string_get(), sr_lib_version_string_get()); + printf("Using libsigrokdecode %s (lib version %s).\n\n", + srd_package_version_string_get(), srd_lib_version_string_get()); + printf("Supported hardware drivers:\n"); - drivers = sr_hw_list(); + drivers = sr_driver_list(); for (i = 0; drivers[i]; i++) { printf(" %-20s %s\n", drivers[i]->name, drivers[i]->longname); } @@ -115,22 +238,23 @@ static void show_version(void) if (srd_init(NULL) == SRD_OK) { printf("Supported protocol decoders:\n"); - srd_decoders_load_all(); - for (l = srd_decoders_list(); l; l = l->next) { + srd_decoder_load_all(); + for (l = srd_decoder_list(); l; l = l->next) { dec = l->data; printf(" %-20s %s\n", dec->id, dec->longname); + /* Print protocol description upon "-l 3" or higher. */ + if (opt_loglevel >= SR_LOG_INFO) + printf(" %-20s %s\n", "", dec->desc); } srd_exit(); } printf("\n"); - } -static void print_dev_line(const struct sr_dev *dev) +static void print_dev_line(const struct sr_dev_inst *sdi) { - const struct sr_dev_inst *sdi; - - sr_dev_info_get(dev, SR_DI_INST, (const void **)&sdi); + struct sr_probe *probe; + GSList *l; if (sdi->vendor && sdi->vendor[0]) printf("%s ", sdi->vendor); @@ -138,59 +262,78 @@ static void print_dev_line(const struct sr_dev *dev) printf("%s ", sdi->model); if (sdi->version && sdi->version[0]) printf("%s ", sdi->version); - if (dev->probes) - printf("with %d probes", g_slist_length(dev->probes)); + if (sdi->probes) { + if (g_slist_length(sdi->probes) == 1) { + probe = sdi->probes->data; + printf("with 1 probe: %s", probe->name); + } else { + printf("with %d probes:", g_slist_length(sdi->probes)); + for (l = sdi->probes; l; l = l->next) { + probe = l->data; + printf(" %s", probe->name); + } + } + } printf("\n"); } static void show_dev_list(void) { - struct sr_dev *dev, *demo_dev; - GSList *devs, *l; - int devcnt; - - devcnt = 0; - devs = sr_dev_list(); + struct sr_dev_inst *sdi; + GSList *devices, *l; - if (g_slist_length(devs) == 0) + if (!(devices = device_scan())) return; - printf("The following devices were found:\nID Device\n"); - demo_dev = NULL; - for (l = devs; l; l = l->next) { - dev = l->data; - if (sr_dev_has_hwcap(dev, SR_HWCAP_DEMO_DEV)) { - demo_dev = dev; - continue; - } - printf("%-3d ", devcnt++); - print_dev_line(dev); - } - if (demo_dev) { - printf("demo "); - print_dev_line(demo_dev); + printf("The following devices were found:\n"); + for (l = devices; l; l = l->next) { + sdi = l->data; + print_dev_line(sdi); } + g_slist_free(devices); + } static void show_dev_detail(void) { - struct sr_dev *dev; - struct sr_hwcap_option *hwo; + struct sr_dev_inst *sdi; + const struct sr_config_info *srci; const struct sr_samplerates *samplerates; - int cap, *hwcaps, i; + struct sr_rational *rationals; + GSList *devices; + uint64_t *integers; + const int *hwopts, *hwcaps; + int cap, num_devices, n, i; char *s, *title; const char *charopts, **stropts; - dev = parse_devstring(opt_dev); - if (!dev) { - printf("No such device. Use -D to list all devices.\n"); + if (!(devices = device_scan())) { + g_critical("No devices found."); return; } - print_dev_line(dev); + num_devices = g_slist_length(devices); + if (num_devices > 1) { + if (!opt_dev) { + g_critical("%d devices found. Use --list-devices to show them, " + "and --device to select one.", num_devices); + return; + } + /* opt_dev is NULL if not specified, which is fine. */ + n = strtol(opt_dev, NULL, 10); + if (n >= num_devices) { + g_critical("%d devices found, numbered starting from 0.", + num_devices); + return; + } + sdi = g_slist_nth_data(devices, n); + } else + sdi = g_slist_nth_data(devices, 0); - if (sr_dev_info_get(dev, SR_DI_TRIGGER_TYPES, - (const void **)&charopts) == SR_OK) { + print_dev_line(sdi); + + if (sr_config_list(sdi->driver, SR_CONF_TRIGGER_TYPE, (const void **)&charopts, + sdi) == SR_OK && charopts) { printf("Supported triggers: "); while (*charopts) { printf("%c ", *charopts); @@ -199,10 +342,24 @@ static void show_dev_detail(void) printf("\n"); } - title = "Supported options:\n"; - hwcaps = dev->driver->hwcap_get_all(); + if ((sr_info_get(sdi->driver, SR_DI_HWOPTS, (const void **)&hwopts, + NULL) == SR_OK) && hwopts) { + printf("Supported driver options:\n"); + for (i = 0; hwopts[i]; i++) { + if (!(srci = sr_config_info_get(hwopts[i]))) + continue; + printf(" %s\n", srci->id); + } + } + + title = "Supported device options:\n"; + if ((sr_config_list(sdi->driver, SR_CONF_DEVICE_OPTIONS, (const void **)&hwcaps, + NULL) != SR_OK) || !hwcaps) + /* Driver supports no device instance options. */ + return; + for (cap = 0; hwcaps[cap]; cap++) { - if (!(hwo = sr_hw_hwcap_get(hwcaps[cap]))) + if (!(srci = sr_config_info_get(hwcaps[cap]))) continue; if (title) { @@ -210,25 +367,26 @@ static void show_dev_detail(void) title = NULL; } - if (hwo->hwcap == SR_HWCAP_PATTERN_MODE) { - printf(" %s", hwo->shortname); - if (sr_dev_info_get(dev, SR_DI_PATTERNMODES, - (const void **)&stropts) == SR_OK) { - printf(" - supported modes:\n"); + if (srci->key == SR_CONF_PATTERN_MODE) { + /* Pattern generator modes */ + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_PATTERN_MODE, + (const void **)&stropts, sdi) == SR_OK) { + printf(" - supported patterns:\n"); for (i = 0; stropts[i]; i++) printf(" %s\n", stropts[i]); } else { printf("\n"); } - } else if (hwo->hwcap == SR_HWCAP_SAMPLERATE) { - printf(" %s", hwo->shortname); + + } else if (srci->key == SR_CONF_SAMPLERATE) { /* Supported samplerates */ - if (sr_dev_info_get(dev, SR_DI_SAMPLERATES, - (const void **)&samplerates) != SR_OK) { + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_SAMPLERATE, + (const void **)&samplerates, sdi) != SR_OK) { printf("\n"); continue; } - if (samplerates->step) { /* low */ if (!(s = sr_samplerate_string(samplerates->low))) @@ -247,14 +405,89 @@ static void show_dev_detail(void) g_free(s); } else { printf(" - supported samplerates:\n"); - for (i = 0; samplerates->list[i]; i++) { + for (i = 0; samplerates->list[i]; i++) printf(" %s\n", sr_samplerate_string(samplerates->list[i])); - } } + + } else if (srci->key == SR_CONF_BUFFERSIZE) { + /* Supported buffer sizes */ + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_BUFFERSIZE, + (const void **)&integers, sdi) != SR_OK) { + printf("\n"); + continue; + } + printf(" - supported buffer sizes:\n"); + for (i = 0; integers[i]; i++) + printf(" %"PRIu64"\n", integers[i]); + + } else if (srci->key == SR_CONF_TIMEBASE) { + /* Supported time bases */ + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_TIMEBASE, + (const void **)&rationals, sdi) != SR_OK) { + printf("\n"); + continue; + } + printf(" - supported time bases:\n"); + for (i = 0; rationals[i].p && rationals[i].q; i++) + printf(" %s\n", sr_period_string( + rationals[i].p * rationals[i].q)); + + } else if (srci->key == SR_CONF_TRIGGER_SOURCE) { + /* Supported trigger sources */ + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_TRIGGER_SOURCE, + (const void **)&stropts, sdi) != SR_OK) { + printf("\n"); + continue; + } + printf(" - supported trigger sources:\n"); + for (i = 0; stropts[i]; i++) + printf(" %s\n", stropts[i]); + + } else if (srci->key == SR_CONF_FILTER) { + /* Supported filters */ + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_FILTER, + (const void **)&stropts, sdi) != SR_OK) { + printf("\n"); + continue; + } + printf(" - supported filter targets:\n"); + for (i = 0; stropts[i]; i++) + printf(" %s\n", stropts[i]); + + } else if (srci->key == SR_CONF_VDIV) { + /* Supported volts/div values */ + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_VDIV, + (const void **)&rationals, sdi) != SR_OK) { + printf("\n"); + continue; + } + printf(" - supported volts/div:\n"); + for (i = 0; rationals[i].p && rationals[i].q; i++) + printf(" %s\n", sr_voltage_string( &rationals[i])); + + } else if (srci->key == SR_CONF_COUPLING) { + /* Supported coupling settings */ + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_COUPLING, + (const void **)&stropts, sdi) != SR_OK) { + printf("\n"); + continue; + } + printf(" - supported coupling options:\n"); + for (i = 0; stropts[i]; i++) + printf(" %s\n", stropts[i]); + } else { - printf(" %s\n", hwo->shortname); + /* Everything else */ + printf(" %s\n", srci->id); } } + } static void show_pd_detail(void) @@ -262,47 +495,94 @@ static void show_pd_detail(void) GSList *l; struct srd_decoder *dec; char **pdtokens, **pdtok, **ann, *doc; + struct srd_probe *p; pdtokens = g_strsplit(opt_pds, ",", -1); for (pdtok = pdtokens; *pdtok; pdtok++) { if (!(dec = srd_decoder_get_by_id(*pdtok))) { - printf("Protocol decoder %s not found.", *pdtok); + g_critical("Protocol decoder %s not found.", *pdtok); return; } printf("ID: %s\nName: %s\nLong name: %s\nDescription: %s\n", dec->id, dec->name, dec->longname, dec->desc); printf("License: %s\n", dec->license); + printf("Annotations:\n"); if (dec->annotations) { - printf("Annotations:\n"); for (l = dec->annotations; l; l = l->next) { ann = l->data; printf("- %s\n %s\n", ann[0], ann[1]); } + } else { + printf("None.\n"); } - if ((doc = srd_decoder_doc(dec))) { - printf("Documentation:\n%s\n", doc[0] == '\n' ? doc+1 : doc); + /* TODO: Print supported decoder options. */ + printf("Required probes:\n"); + if (dec->probes) { + for (l = dec->probes; l; l = l->next) { + p = l->data; + printf("- %s (%s): %s\n", + p->name, p->id, p->desc); + } + } else { + printf("None.\n"); + } + printf("Optional probes:\n"); + if (dec->opt_probes) { + for (l = dec->opt_probes; l; l = l->next) { + p = l->data; + printf("- %s (%s): %s\n", + p->name, p->id, p->desc); + } + } else { + printf("None.\n"); + } + if ((doc = srd_decoder_doc_get(dec))) { + printf("Documentation:\n%s\n", + doc[0] == '\n' ? doc + 1 : doc); g_free(doc); } } g_strfreev(pdtokens); +} + +static GArray *get_enabled_logic_probes(const struct sr_dev_inst *sdi) +{ + struct sr_probe *probe; + GArray *probes; + GSList *l; + + probes = g_array_new(FALSE, FALSE, sizeof(int)); + for (l = sdi->probes; l; l = l->next) { + probe = l->data; + if (probe->type != SR_PROBE_LOGIC) + continue; + if (probe->enabled != TRUE) + continue; + g_array_append_val(probes, probe->index); + } + return probes; } -static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet) +static void datafeed_in(const struct sr_dev_inst *sdi, + const struct sr_datafeed_packet *packet) { + const struct sr_datafeed_meta *meta; + const struct sr_datafeed_logic *logic; + const struct sr_datafeed_analog *analog; + struct sr_config *src; static struct sr_output *o = NULL; - static int probelist[SR_MAX_NUM_PROBES] = { 0 }; + static GArray *logic_probelist = NULL; static uint64_t received_samples = 0; static int unitsize = 0; static int triggered = 0; static FILE *outfile = NULL; - struct sr_probe *probe; - struct sr_datafeed_header *header; - struct sr_datafeed_logic *logic; - int num_enabled_probes, sample_size, ret, i; - uint64_t output_len, filter_out_len; - char *output_buf, *filter_out; + int sample_size, ret; + uint64_t *samplerate, output_len, filter_out_len; + uint8_t *output_buf, *filter_out; + GString *out; + GSList *l; /* If the first packet to come in isn't a header, don't even try. */ if (packet->type != SR_DF_HEADER && o == NULL) @@ -311,63 +591,64 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet) sample_size = -1; switch (packet->type) { case SR_DF_HEADER: - g_message("cli: Received SR_DF_HEADER"); + g_debug("cli: Received SR_DF_HEADER"); /* Initialize the output module. */ if (!(o = g_try_malloc(sizeof(struct sr_output)))) { - printf("Output module malloc failed.\n"); + g_critical("Output module malloc failed."); exit(1); } o->format = output_format; - o->dev = dev; + o->sdi = (struct sr_dev_inst *)sdi; o->param = output_format_param; if (o->format->init) { if (o->format->init(o) != SR_OK) { - printf("Output format initialization failed.\n"); + g_critical("Output format initialization failed."); exit(1); } } - header = packet->payload; - num_enabled_probes = 0; - for (i = 0; i < header->num_logic_probes; i++) { - probe = g_slist_nth_data(dev->probes, i); - if (probe->enabled) - probelist[num_enabled_probes++] = probe->index; - } - /* How many bytes we need to store num_enabled_probes bits */ - unitsize = (num_enabled_probes + 7) / 8; - + /* Prepare non-stdout output. */ outfile = stdout; if (opt_output_file) { if (default_output_format) { - /* output file is in session format, which means we'll - * dump everything in the datastore as it comes in, + /* output file is in session format, so we'll + * keep a copy of everything as it comes in * and save from there after the session. */ outfile = NULL; - ret = sr_datastore_new(unitsize, &(dev->datastore)); - if (ret != SR_OK) { - printf("Failed to create datastore.\n"); - exit(1); - } + savebuf = g_byte_array_new(); } else { /* saving to a file in whatever format was set * with --format, so all we need is a filehandle */ outfile = g_fopen(opt_output_file, "wb"); } } - if (opt_pds) - srd_session_start(num_enabled_probes, unitsize, - header->samplerate); + + /* Prepare for logic data. */ + logic_probelist = get_enabled_logic_probes(sdi); + /* How many bytes we need to store the packed samples. */ + unitsize = (logic_probelist->len + 7) / 8; + + if (opt_pds && logic_probelist->len) { + if (sr_info_get(sdi->driver, SR_CONF_SAMPLERATE, + (const void **)&samplerate, sdi) != SR_OK) { + g_critical("Unable to initialize protocol " + "decoders: no samplerate found."); + break; + } + srd_session_start(logic_probelist->len, unitsize, + *samplerate); + } break; + case SR_DF_END: - g_message("cli: Received SR_DF_END"); + g_debug("cli: Received SR_DF_END"); if (!o) { - g_message("cli: double end!"); + g_debug("cli: double end!"); break; } if (o->format->event) { o->format->event(o, SR_DF_END, &output_buf, &output_len); - if (output_len) { + if (output_buf) { if (outfile) fwrite(output_buf, 1, output_len, outfile); g_free(output_buf); @@ -375,85 +656,168 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet) } } if (limit_samples && received_samples < limit_samples) - printf("Device only sent %" PRIu64 " samples.\n", + g_warning("Device only sent %" PRIu64 " samples.", received_samples); if (opt_continuous) - printf("Device stopped after %" PRIu64 " samples.\n", + g_warning("Device stopped after %" PRIu64 " samples.", received_samples); - sr_session_halt(); + if (outfile && outfile != stdout) fclose(outfile); + + if (opt_output_file && default_output_format) { + if (sr_session_save(opt_output_file, sdi, savebuf->data, + unitsize, savebuf->len / unitsize) != SR_OK) + g_critical("Failed to save session."); + g_byte_array_free(savebuf, FALSE); + } + + g_array_free(logic_probelist, TRUE); + if (o->format->cleanup) + o->format->cleanup(o); g_free(o); o = NULL; break; + + case SR_DF_META: + g_debug("cli: received SR_DF_META"); + meta = packet->payload; + for (l = meta->config; l; l = l->next) { + src = l->data; + switch (src->key) { + case SR_CONF_SAMPLERATE: + samplerate = (uint64_t *)src->value; + g_debug("cli: got samplerate %"PRIu64, *samplerate); + break; + default: + /* Unknown metadata is not an error. */ + break; + } + } + break; + case SR_DF_TRIGGER: - g_message("cli: received SR_DF_TRIGGER"); + g_debug("cli: received SR_DF_TRIGGER"); if (o->format->event) o->format->event(o, SR_DF_TRIGGER, &output_buf, &output_len); triggered = 1; break; + case SR_DF_LOGIC: logic = packet->payload; - sample_size = logic->unitsize; g_message("cli: received SR_DF_LOGIC, %"PRIu64" bytes", logic->length); - break; - } + sample_size = logic->unitsize; + if (logic->length == 0) + break; - /* not supporting anything but SR_DF_LOGIC for now */ + /* Don't store any samples until triggered. */ + if (opt_wait_trigger && !triggered) + break; - if (sample_size == -1 || logic->length == 0) - return; + if (limit_samples && received_samples >= limit_samples) + break; - /* Don't store any samples until triggered. */ - if (opt_wait_trigger && !triggered) - return; + ret = sr_filter_probes(sample_size, unitsize, logic_probelist, + logic->data, logic->length, + &filter_out, &filter_out_len); + if (ret != SR_OK) + break; - if (limit_samples && received_samples >= limit_samples) - return; + /* What comes out of the filter is guaranteed to be packed into the + * minimum size needed to support the number of samples at this sample + * size. however, the driver may have submitted too much -- cut off + * the buffer of the last packet according to the sample limit. + */ + if (limit_samples && (received_samples + logic->length / sample_size > + limit_samples * sample_size)) + filter_out_len = limit_samples * sample_size - received_samples; - /* TODO: filters only support SR_DF_LOGIC */ - ret = sr_filter_probes(sample_size, unitsize, probelist, - logic->data, logic->length, - &filter_out, &filter_out_len); - if (ret != SR_OK) - return; + if (opt_output_file && default_output_format) { + /* Saving to a session file. */ + g_byte_array_append(savebuf, filter_out, filter_out_len); + } else { + if (opt_pds) { + if (srd_session_send(received_samples, (uint8_t*)filter_out, + filter_out_len) != SRD_OK) + sr_session_stop(); + } else { + output_len = 0; + if (o->format->data && packet->type == o->format->df_type) + o->format->data(o, filter_out, filter_out_len, + &output_buf, &output_len); + if (output_buf) { + fwrite(output_buf, 1, output_len, outfile); + fflush(outfile); + g_free(output_buf); + } + } + } + g_free(filter_out); - /* what comes out of the filter is guaranteed to be packed into the - * minimum size needed to support the number of samples at this sample - * size. however, the driver may have submitted too much -- cut off - * the buffer of the last packet according to the sample limit. - */ - if (limit_samples && (received_samples + logic->length / sample_size > - limit_samples * sample_size)) - filter_out_len = limit_samples * sample_size - received_samples; + received_samples += logic->length / sample_size; + break; - if (dev->datastore) - sr_datastore_put(dev->datastore, filter_out, - filter_out_len, sample_size, probelist); + case SR_DF_ANALOG: + analog = packet->payload; + g_message("cli: received SR_DF_ANALOG, %d samples", analog->num_samples); + if (analog->num_samples == 0) + break; - if (opt_output_file && default_output_format) - /* saving to a session file, don't need to do anything else - * to this data for now. */ - goto cleanup; + if (limit_samples && received_samples >= limit_samples) + break; - if (opt_pds) { - if (srd_session_feed(received_samples, (uint8_t*)filter_out, - filter_out_len) != SRD_OK) - sr_session_halt(); - } else { - output_len = 0; - if (o->format->data && packet->type == o->format->df_type) - o->format->data(o, filter_out, filter_out_len, &output_buf, &output_len); - if (output_len) { - fwrite(output_buf, 1, output_len, outfile); - g_free(output_buf); + if (o->format->data && packet->type == o->format->df_type) { + o->format->data(o, (const uint8_t *)analog->data, + analog->num_samples * sizeof(float), + &output_buf, &output_len); + if (output_buf) { + fwrite(output_buf, 1, output_len, outfile); + fflush(outfile); + g_free(output_buf); + } + } + + received_samples += analog->num_samples; + break; + + case SR_DF_FRAME_BEGIN: + g_debug("cli: received SR_DF_FRAME_BEGIN"); + if (o->format->event) { + o->format->event(o, SR_DF_FRAME_BEGIN, &output_buf, + &output_len); + if (output_buf) { + fwrite(output_buf, 1, output_len, outfile); + fflush(outfile); + g_free(output_buf); + } } + break; + + case SR_DF_FRAME_END: + g_debug("cli: received SR_DF_FRAME_END"); + if (o->format->event) { + o->format->event(o, SR_DF_FRAME_END, &output_buf, + &output_len); + if (output_buf) { + fwrite(output_buf, 1, output_len, outfile); + fflush(outfile); + g_free(output_buf); + } + } + break; + + default: + break; } -cleanup: - g_free(filter_out); - received_samples += logic->length / sample_size; + if (o && o->format->recv) { + out = o->format->recv(o, sdi, packet); + if (out && out->len) { + fwrite(out->str, 1, out->len, outfile); + fflush(outfile); + } + } } @@ -466,40 +830,52 @@ static int register_pds(struct sr_dev *dev, const char *pdstring) { GHashTable *pd_opthash; struct srd_decoder_inst *di; + int ret; char **pdtokens, **pdtok, *pd_name; - /* Avoid compiler warnings. */ (void)dev; - g_datalist_init(&pd_ann_visible); - pdtokens = g_strsplit(pdstring, ",", -1); - pd_opthash = NULL; + ret = 0; + pd_ann_visible = g_hash_table_new_full(g_str_hash, g_int_equal, + g_free, NULL); pd_name = NULL; - + pd_opthash = NULL; + pdtokens = g_strsplit(pdstring, ",", 0); for (pdtok = pdtokens; *pdtok; pdtok++) { - if (!(pd_opthash = parse_generic_arg(*pdtok))) { - fprintf(stderr, "Invalid protocol decoder option '%s'.\n", *pdtok); + if (!(pd_opthash = parse_generic_arg(*pdtok, TRUE))) { + g_critical("Invalid protocol decoder option '%s'.", *pdtok); goto err_out; } pd_name = g_strdup(g_hash_table_lookup(pd_opthash, "sigrok_key")); g_hash_table_remove(pd_opthash, "sigrok_key"); if (srd_decoder_load(pd_name) != SRD_OK) { - fprintf(stderr, "Failed to load protocol decoder %s\n", pd_name); + g_critical("Failed to load protocol decoder %s.", pd_name); + ret = 1; goto err_out; } if (!(di = srd_inst_new(pd_name, pd_opthash))) { - fprintf(stderr, "Failed to instantiate protocol decoder %s\n", pd_name); + g_critical("Failed to instantiate protocol decoder %s.", pd_name); + ret = 1; goto err_out; } - g_datalist_set_data(&pd_ann_visible, di->inst_id, pd_name); + + /* If no annotation list was specified, add them all in now. + * This will be pared down later to leave only the last PD + * in the stack. + */ + if (!opt_pd_annotations) + g_hash_table_insert(pd_ann_visible, + g_strdup(di->inst_id), NULL); /* Any keys left in the options hash are probes, where the key * is the probe name as specified in the decoder class, and the * value is the probe number i.e. the order in which the PD's * incoming samples are arranged. */ - if (srd_inst_probes_set(di, pd_opthash) != SRD_OK) + if (srd_inst_probe_set_all(di, pd_opthash) != SRD_OK) { + ret = 1; goto err_out; + } g_hash_table_destroy(pd_opthash); pd_opthash = NULL; } @@ -511,26 +887,179 @@ err_out: if (pd_name) g_free(pd_name); + return ret; +} + +int setup_pd_stack(void) +{ + struct srd_decoder_inst *di_from, *di_to; + int ret, i; + char **pds, **ids; + + /* Set up the protocol decoder stack. */ + pds = g_strsplit(opt_pds, ",", 0); + if (g_strv_length(pds) > 1) { + if (opt_pd_stack) { + /* A stack setup was specified, use that. */ + g_strfreev(pds); + pds = g_strsplit(opt_pd_stack, ",", 0); + if (g_strv_length(pds) < 2) { + g_strfreev(pds); + g_critical("Specify at least two protocol decoders to stack."); + return 1; + } + } + + /* First PD goes at the bottom of the stack. */ + ids = g_strsplit(pds[0], ":", 0); + if (!(di_from = srd_inst_find_by_id(ids[0]))) { + g_strfreev(ids); + g_critical("Cannot stack protocol decoder '%s': " + "instance not found.", pds[0]); + return 1; + } + g_strfreev(ids); + + /* Every subsequent PD goes on top. */ + for (i = 1; pds[i]; i++) { + ids = g_strsplit(pds[i], ":", 0); + if (!(di_to = srd_inst_find_by_id(ids[0]))) { + g_strfreev(ids); + g_critical("Cannot stack protocol decoder '%s': " + "instance not found.", pds[i]); + return 1; + } + g_strfreev(ids); + if ((ret = srd_inst_stack(di_from, di_to)) != SRD_OK) + return 1; + + /* Don't show annotation from this PD. Only the last PD in + * the stack will be left on the annotation list (unless + * the annotation list was specifically provided). + */ + if (!opt_pd_annotations) + g_hash_table_remove(pd_ann_visible, + di_from->inst_id); + + di_from = di_to; + } + } + g_strfreev(pds); + + return 0; +} + +int setup_pd_annotations(void) +{ + GSList *l; + struct srd_decoder *dec; + int ann; + char **pds, **pdtok, **keyval, **ann_descr; + + /* Set up custom list of PDs and annotations to show. */ + if (opt_pd_annotations) { + pds = g_strsplit(opt_pd_annotations, ",", 0); + for (pdtok = pds; *pdtok && **pdtok; pdtok++) { + ann = 0; + keyval = g_strsplit(*pdtok, "=", 0); + if (!(dec = srd_decoder_get_by_id(keyval[0]))) { + g_critical("Protocol decoder '%s' not found.", keyval[0]); + return 1; + } + if (!dec->annotations) { + g_critical("Protocol decoder '%s' has no annotations.", keyval[0]); + return 1; + } + if (g_strv_length(keyval) == 2) { + for (l = dec->annotations; l; l = l->next, ann++) { + ann_descr = l->data; + if (!canon_cmp(ann_descr[0], keyval[1])) + /* Found it. */ + break; + } + if (!l) { + g_critical("Annotation '%s' not found " + "for protocol decoder '%s'.", keyval[1], keyval[0]); + return 1; + } + } + g_debug("cli: showing protocol decoder annotation %d from '%s'", ann, keyval[0]); + g_hash_table_insert(pd_ann_visible, g_strdup(keyval[0]), GINT_TO_POINTER(ann)); + g_strfreev(keyval); + } + g_strfreev(pds); + } + + return 0; +} + +int setup_output_format(void) +{ + GHashTable *fmtargs; + GHashTableIter iter; + gpointer key, value; + struct sr_output_format **outputs; + int i; + char *fmtspec; + + if (!opt_output_format) { + opt_output_format = DEFAULT_OUTPUT_FORMAT; + /* we'll need to remember this so when saving to a file + * later, sigrok session format will be used. + */ + default_output_format = TRUE; + } + + fmtargs = parse_generic_arg(opt_output_format, TRUE); + fmtspec = g_hash_table_lookup(fmtargs, "sigrok_key"); + if (!fmtspec) { + g_critical("Invalid output format."); + return 1; + } + outputs = sr_output_list(); + for (i = 0; outputs[i]; i++) { + if (strcmp(outputs[i]->id, fmtspec)) + continue; + g_hash_table_remove(fmtargs, "sigrok_key"); + output_format = outputs[i]; + g_hash_table_iter_init(&iter, fmtargs); + while (g_hash_table_iter_next(&iter, &key, &value)) { + /* only supporting one parameter per output module + * for now, and only its value */ + output_format_param = g_strdup(value); + break; + } + break; + } + if (!output_format) { + g_critical("Invalid output format %s.", opt_output_format); + return 1; + } + g_hash_table_destroy(fmtargs); + return 0; } -void show_pd_annotation(struct srd_proto_data *pdata, void *user_data) +void show_pd_annotations(struct srd_proto_data *pdata, void *cb_data) { int i; char **annotations; + gpointer ann_format; - /* 'user_data' is not used in this specific callback. */ - (void)user_data; + /* 'cb_data' is not used in this specific callback. */ + (void)cb_data; - if (pdata->ann_format != 0) { - /* CLI only shows the default annotation format. */ + if (!pd_ann_visible) return; - } - if (!g_datalist_get_data(&pd_ann_visible, pdata->pdo->di->inst_id)) { + if (!g_hash_table_lookup_extended(pd_ann_visible, pdata->pdo->di->inst_id, + NULL, &ann_format)) /* Not in the list of PDs whose annotations we're showing. */ return; - } + + if (pdata->ann_format != GPOINTER_TO_INT(ann_format)) + /* We don't want this particular format from the PD. */ + return; annotations = pdata->data; if (opt_loglevel > SR_LOG_WARN) @@ -539,38 +1068,28 @@ void show_pd_annotation(struct srd_proto_data *pdata, void *user_data) for (i = 0; annotations[i]; i++) printf("\"%s\" ", annotations[i]); printf("\n"); - + fflush(stdout); } -static int select_probes(struct sr_dev *dev) +static int select_probes(struct sr_dev_inst *sdi) { struct sr_probe *probe; - char **probelist; - int max_probes, i; + GSList *selected_probes, *l; if (!opt_probes) return SR_OK; - /* - * This only works because a device by default initializes - * and enables all its probes. - */ - max_probes = g_slist_length(dev->probes); - probelist = parse_probestring(max_probes, opt_probes); - if (!probelist) { + if (!(selected_probes = parse_probestring(sdi, opt_probes))) return SR_ERR; - } - for (i = 0; i < max_probes; i++) { - if (probelist[i]) { - sr_dev_probe_name(dev, i + 1, probelist[i]); - g_free(probelist[i]); - } else { - probe = sr_dev_probe_find(dev, i + 1); + for (l = sdi->probes; l; l = l->next) { + probe = l->data; + if (g_slist_find(selected_probes, probe)) + probe->enabled = TRUE; + else probe->enabled = FALSE; - } } - g_free(probelist); + g_slist_free(selected_probes); return SR_OK; } @@ -596,24 +1115,23 @@ static struct sr_input_format *determine_input_file_format( /* If there are no input formats, return NULL right away. */ inputs = sr_input_list(); if (!inputs) { - fprintf(stderr, "cli: %s: no supported input formats " - "available", __func__); + g_critical("No supported input formats available."); return NULL; } /* If the user specified -I / --input-format, use that one. */ if (opt) { for (i = 0; inputs[i]; i++) { - if (strcasecmp(inputs[i]->id, opt_input_format)) + if (strcasecmp(inputs[i]->id, opt)) continue; - printf("Using user-specified input file format" - " '%s'.\n", inputs[i]->id); + g_debug("Using user-specified input file format '%s'.", + inputs[i]->id); return inputs[i]; } /* The user specified an unknown input format, return NULL. */ - fprintf(stderr, "Error: Specified input file format '%s' is " - "unknown.\n", opt_input_format); + g_critical("Error: specified input file format '%s' is " + "unknown.", opt); return NULL; } @@ -625,65 +1143,75 @@ static struct sr_input_format *determine_input_file_format( /* Return NULL if no input module wanted to touch this. */ if (!inputs[i]) { - fprintf(stderr, "Error: No matching input module found.\n"); + g_critical("Error: no matching input module found."); return NULL; } + + g_debug("cli: Autodetected '%s' input format for file '%s'.", + inputs[i]->id, filename); - printf("Using input file format '%s'.\n", inputs[i]->id); return inputs[i]; } static void load_input_file_format(void) { + GHashTable *fmtargs = NULL; struct stat st; struct sr_input *in; struct sr_input_format *input_format; + char *fmtspec = NULL; - input_format = determine_input_file_format(opt_input_file, - opt_input_format); - if (!input_format) { - fprintf(stderr, "Error: Couldn't detect input file format.\n"); + if (opt_input_format) { + fmtargs = parse_generic_arg(opt_input_format, TRUE); + fmtspec = g_hash_table_lookup(fmtargs, "sigrok_key"); + } + + if (!(input_format = determine_input_file_format(opt_input_file, + fmtspec))) { + /* The exact cause was already logged. */ return; } + if (fmtargs) + g_hash_table_remove(fmtargs, "sigrok_key"); + if (stat(opt_input_file, &st) == -1) { - printf("Failed to load %s: %s\n", opt_input_file, + g_critical("Failed to load %s: %s", opt_input_file, strerror(errno)); exit(1); } /* Initialize the input module. */ if (!(in = g_try_malloc(sizeof(struct sr_input)))) { - printf("Failed to allocate input module.\n"); + g_critical("Failed to allocate input module."); exit(1); } in->format = input_format; - in->param = input_format_param; + in->param = fmtargs; if (in->format->init) { if (in->format->init(in) != SR_OK) { - printf("Input format init failed.\n"); + g_critical("Input format init failed."); exit(1); } } - if (select_probes(in->vdev) > 0) - return; + if (select_probes(in->sdi) > 0) + return; sr_session_new(); sr_session_datafeed_callback_add(datafeed_in); - if (sr_session_dev_add(in->vdev) != SR_OK) { - printf("Failed to use device.\n"); + if (sr_session_dev_add(in->sdi) != SR_OK) { + g_critical("Failed to use device."); sr_session_destroy(); return; } input_format->loadfile(in, opt_input_file); - if (opt_output_file && default_output_format) { - if (sr_session_save(opt_output_file) != SR_OK) - printf("Failed to save session.\n"); - } + sr_session_destroy(); + if (fmtargs) + g_hash_table_destroy(fmtargs); } static void load_input_file(void) @@ -700,81 +1228,117 @@ static void load_input_file(void) /* fall back on input modules */ load_input_file_format(); } - -} - -int num_real_devs(void) -{ - struct sr_dev *dev; - GSList *devs, *l; - int num_devs; - - num_devs = 0; - devs = sr_dev_list(); - for (l = devs; l; l = l->next) { - dev = l->data; - if (!sr_dev_has_hwcap(dev, SR_HWCAP_DEMO_DEV)) - num_devs++; - } - - return num_devs; } -static int set_dev_options(struct sr_dev *dev, GHashTable *args) +static int set_dev_options(struct sr_dev_inst *sdi, GHashTable *args) { + const struct sr_config_info *srci; GHashTableIter iter; gpointer key, value; - int ret, i; + int ret; + float tmp_float; uint64_t tmp_u64; - gboolean found; + struct sr_rational tmp_rat; gboolean tmp_bool; + void *val; g_hash_table_iter_init(&iter, args); while (g_hash_table_iter_next(&iter, &key, &value)) { - found = FALSE; - for (i = 0; sr_hwcap_options[i].hwcap; i++) { - if (strcmp(sr_hwcap_options[i].shortname, key)) - continue; - if ((value == NULL) && - (sr_hwcap_options[i].type != SR_T_BOOL)) { - printf("Option '%s' needs a value.\n", (char *)key); - return SR_ERR; - } - found = TRUE; - switch (sr_hwcap_options[i].type) { - case SR_T_UINT64: - ret = sr_parse_sizestring(value, &tmp_u64); - if (ret != SR_OK) - break; - ret = dev->driver->dev_config_set(dev->driver_index, - sr_hwcap_options[i].hwcap, &tmp_u64); + if (!(srci = sr_config_info_name_get(key))) { + g_critical("Unknown device option '%s'.", (char *) key); + return SR_ERR; + } + + if ((value == NULL) && + (srci->datatype != SR_T_BOOL)) { + g_critical("Option '%s' needs a value.", (char *)key); + return SR_ERR; + } + val = NULL; + switch (srci->datatype) { + case SR_T_UINT64: + ret = sr_parse_sizestring(value, &tmp_u64); + if (ret != SR_OK) break; - case SR_T_CHAR: - ret = dev->driver->dev_config_set(dev->driver_index, - sr_hwcap_options[i].hwcap, value); + val = &tmp_u64; + break; + case SR_T_CHAR: + val = value; + break; + case SR_T_BOOL: + if (!value) + tmp_bool = TRUE; + else + tmp_bool = sr_parse_boolstring(value); + val = &tmp_bool; + break; + case SR_T_FLOAT: + tmp_float = strtof(value, NULL); + val = &tmp_float; + break; + case SR_T_RATIONAL_PERIOD: + if ((ret = sr_parse_period(value, &tmp_rat)) != SR_OK) break; - case SR_T_BOOL: - if (!value) - tmp_bool = TRUE; - else - tmp_bool = sr_parse_boolstring(value); - ret = dev->driver->dev_config_set(dev->driver_index, - sr_hwcap_options[i].hwcap, - GINT_TO_POINTER(tmp_bool)); + val = &tmp_rat; + break; + case SR_T_RATIONAL_VOLT: + if ((ret = sr_parse_voltage(value, &tmp_rat)) != SR_OK) break; - default: - ret = SR_ERR; - } + val = &tmp_rat; + break; + default: + ret = SR_ERR; + } + if (val) + ret = sr_dev_config_set(sdi, srci->key, val); + if (ret != SR_OK) { + g_critical("Failed to set device option '%s'.", (char *)key); + return ret; + } + } - if (ret != SR_OK) { - printf("Failed to set device option '%s'.\n", (char *)key); - return ret; - } - else - break; + return SR_OK; +} + +static int set_limit_time(const struct sr_dev_inst *sdi) +{ + uint64_t time_msec; + uint64_t *samplerate; + + time_msec = sr_parse_timestring(opt_time); + if (time_msec == 0) { + g_critical("Invalid time '%s'", opt_time); + sr_session_destroy(); + return SR_ERR; + } + + if (sr_driver_hwcap_exists(sdi->driver, SR_CONF_LIMIT_MSEC)) { + if (sr_dev_config_set(sdi, SR_CONF_LIMIT_MSEC, &time_msec) != SR_OK) { + g_critical("Failed to configure time limit."); + sr_session_destroy(); + return SR_ERR; } - if (!found) { - printf("Unknown device option '%s'.\n", (char *) key); + } + else { + /* time limit set, but device doesn't support this... + * convert to samples based on the samplerate. + */ + limit_samples = 0; + if (sr_dev_has_hwcap(sdi, SR_CONF_SAMPLERATE)) { + sr_info_get(sdi->driver, SR_CONF_SAMPLERATE, + (const void **)&samplerate, sdi); + limit_samples = (*samplerate) * time_msec / (uint64_t)1000; + } + if (limit_samples == 0) { + g_critical("Not enough time at this samplerate."); + sr_session_destroy(); + return SR_ERR; + } + + if (sr_dev_config_set(sdi, SR_CONF_LIMIT_SAMPLES, + &limit_samples) != SR_OK) { + g_critical("Failed to configure time-based sample limit."); + sr_session_destroy(); return SR_ERR; } } @@ -784,144 +1348,98 @@ static int set_dev_options(struct sr_dev *dev, GHashTable *args) static void run_session(void) { - struct sr_dev *dev; + GSList *devices; GHashTable *devargs; - int num_devs, max_probes, i; - uint64_t time_msec; - char **probelist, *devspec; + struct sr_dev_inst *sdi; + int max_probes, i; + char **triggerlist; - devargs = NULL; - if (opt_dev) { - devargs = parse_generic_arg(opt_dev); - devspec = g_hash_table_lookup(devargs, "sigrok_key"); - dev = parse_devstring(devspec); - if (!dev) { - g_warning("Device not found."); - return; - } - g_hash_table_remove(devargs, "sigrok_key"); - } else { - num_devs = num_real_devs(); - if (num_devs == 1) { - /* No device specified, but there is only one. */ - devargs = NULL; - dev = parse_devstring("0"); - } else if (num_devs == 0) { - printf("No devices found.\n"); - return; - } else { - printf("%d devices found, please select one.\n", num_devs); - return; - } + devices = device_scan(); + if (!devices) { + g_critical("No devices found."); + return; + } + if (g_slist_length(devices) > 1) { + g_critical("sigrok-cli only supports one device for capturing."); + return; } + sdi = devices->data; sr_session_new(); sr_session_datafeed_callback_add(datafeed_in); - if (sr_session_dev_add(dev) != SR_OK) { - printf("Failed to use device.\n"); + if (sr_session_dev_add(sdi) != SR_OK) { + g_critical("Failed to use device."); sr_session_destroy(); return; } - if (devargs) { - if (set_dev_options(dev, devargs) != SR_OK) { - sr_session_destroy(); - return; + if (opt_dev) { + if ((devargs = parse_generic_arg(opt_dev, FALSE))) { + if (set_dev_options(sdi, devargs) != SR_OK) + return; + g_hash_table_destroy(devargs); } - g_hash_table_destroy(devargs); } - if (select_probes(dev) != SR_OK) - return; - - if (opt_continuous) { - if (!sr_hw_has_hwcap(dev->driver, SR_HWCAP_CONTINUOUS)) { - printf("This device does not support continuous sampling."); - sr_session_destroy(); - return; - } + if (select_probes(sdi) != SR_OK) { + g_critical("Failed to set probes."); + sr_session_destroy(); + return; } if (opt_triggers) { - probelist = sr_parse_triggerstring(dev, opt_triggers); - if (!probelist) { + if (!(triggerlist = sr_parse_triggerstring(sdi, opt_triggers))) { sr_session_destroy(); return; } - - max_probes = g_slist_length(dev->probes); + max_probes = g_slist_length(sdi->probes); for (i = 0; i < max_probes; i++) { - if (probelist[i]) { - sr_dev_trigger_set(dev, i + 1, probelist[i]); - g_free(probelist[i]); + if (triggerlist[i]) { + sr_dev_trigger_set(sdi, i, triggerlist[i]); + g_free(triggerlist[i]); } } - g_free(probelist); + g_free(triggerlist); } - if (opt_time) { - time_msec = sr_parse_timestring(opt_time); - if (time_msec == 0) { - printf("Invalid time '%s'\n", opt_time); + if (opt_continuous) { + if (!sr_driver_hwcap_exists(sdi->driver, SR_CONF_CONTINUOUS)) { + g_critical("This device does not support continuous sampling."); sr_session_destroy(); return; } + } - if (sr_hw_has_hwcap(dev->driver, SR_HWCAP_LIMIT_MSEC)) { - if (dev->driver->dev_config_set(dev->driver_index, - SR_HWCAP_LIMIT_MSEC, &time_msec) != SR_OK) { - printf("Failed to configure time limit.\n"); - sr_session_destroy(); - return; - } - } - else { - /* time limit set, but device doesn't support this... - * convert to samples based on the samplerate. - */ - limit_samples = 0; - if (sr_dev_has_hwcap(dev, SR_HWCAP_SAMPLERATE)) { - const uint64_t *samplerate; - - sr_dev_info_get(dev, SR_DI_CUR_SAMPLERATE, - (const void **)&samplerate); - limit_samples = (*samplerate) * time_msec / (uint64_t)1000; - } - if (limit_samples == 0) { - printf("Not enough time at this samplerate.\n"); - sr_session_destroy(); - return; - } - - if (dev->driver->dev_config_set(dev->driver_index, - SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK) { - printf("Failed to configure time-based sample limit.\n"); - sr_session_destroy(); - return; - } + if (opt_time) { + if (set_limit_time(sdi) != SR_OK) { + sr_session_destroy(); + return; } } if (opt_samples) { if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK) - || (dev->driver->dev_config_set(dev->driver_index, - SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK)) { - printf("Failed to configure sample limit.\n"); + || (sr_dev_config_set(sdi, SR_CONF_LIMIT_SAMPLES, + &limit_samples) != SR_OK)) { + g_critical("Failed to configure sample limit."); sr_session_destroy(); return; } } - if (dev->driver->dev_config_set(dev->driver_index, - SR_HWCAP_PROBECONFIG, (char *)dev->probes) != SR_OK) { - printf("Failed to configure probes.\n"); - sr_session_destroy(); - return; + if (opt_frames) { + if ((sr_parse_sizestring(opt_frames, &limit_frames) != SR_OK) + || (sr_dev_config_set(sdi, SR_CONF_LIMIT_FRAMES, + &limit_frames) != SR_OK)) { + g_critical("Failed to configure frame limit."); + sr_session_destroy(); + return; + } } if (sr_session_start() != SR_OK) { - printf("Failed to start session.\n"); + g_critical("Failed to start session."); sr_session_destroy(); return; } @@ -934,178 +1452,98 @@ static void run_session(void) if (opt_continuous) clear_anykey(); - if (opt_output_file && default_output_format) { - if (sr_session_save(opt_output_file) != SR_OK) - printf("Failed to save session.\n"); - } sr_session_destroy(); + g_slist_free(devices); } static void logger(const gchar *log_domain, GLogLevelFlags log_level, - const gchar *message, gpointer user_data) + const gchar *message, gpointer cb_data) { - /* Avoid compiler warnings. */ (void)log_domain; - (void)user_data; + (void)cb_data; /* * All messages, warnings, errors etc. go to stderr (not stdout) in * order to not mess up the CLI tool data output, e.g. VCD output. */ - if (log_level & (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_WARNING)) { + if (log_level & (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING) + || opt_loglevel > SR_LOG_WARN) { fprintf(stderr, "%s\n", message); fflush(stderr); - } else { - if ((log_level & G_LOG_LEVEL_MESSAGE && debug == 1) - || debug == 2) { - printf("%s\n", message); - fflush(stderr); - } } } int main(int argc, char **argv) { + int ret = 1; GOptionContext *context; GError *error; - GHashTable *fmtargs; - GHashTableIter iter; - gpointer key, value; - struct sr_output_format **outputs; - struct srd_decoder_inst *di_from, *di_to; - int i, ret; - char *fmtspec, **pds; g_log_set_default_handler(logger, NULL); - if (getenv("SIGROK_DEBUG")) - debug = strtol(getenv("SIGROK_DEBUG"), NULL, 10); error = NULL; context = g_option_context_new(NULL); g_option_context_add_main_entries(context, optargs, NULL); if (!g_option_context_parse(context, &argc, &argv, &error)) { - g_warning("%s", error->message); - return 1; + g_critical("%s", error->message); + goto done; } /* Set the loglevel (amount of messages to output) for libsigrok. */ - if (sr_log_loglevel_set(opt_loglevel) != SR_OK) { - fprintf(stderr, "cli: %s: sr_log_loglevel_set(%d) failed\n", - __func__, opt_loglevel); - return 1; - } + if (sr_log_loglevel_set(opt_loglevel) != SR_OK) + goto done; /* Set the loglevel (amount of messages to output) for libsigrokdecode. */ - if (srd_log_loglevel_set(opt_loglevel) != SRD_OK) { - fprintf(stderr, "cli: %s: srd_log_loglevel_set(%d) failed\n", - __func__, opt_loglevel); - return 1; - } + if (srd_log_loglevel_set(opt_loglevel) != SRD_OK) + goto done; - if (sr_init() != SR_OK) - return 1; + if (sr_init(&sr_ctx) != SR_OK) + goto done; if (opt_pds) { - if (srd_init(NULL) != SRD_OK) { - printf("Failed to initialize sigrokdecode\n"); - return 1; - } - if (register_pds(NULL, opt_pds) != 0) { - printf("Failed to register protocol decoders\n"); - return 1; - } - if (srd_register_callback(SRD_OUTPUT_ANN, - show_pd_annotation, NULL) != SRD_OK) { - printf("Failed to register protocol decoder callback\n"); - return 1; - } + if (srd_init(NULL) != SRD_OK) + goto done; + if (register_pds(NULL, opt_pds) != 0) + goto done; + if (srd_pd_output_callback_add(SRD_OUTPUT_ANN, + show_pd_annotations, NULL) != SRD_OK) + goto done; + if (setup_pd_stack() != 0) + goto done; + if (setup_pd_annotations() != 0) + goto done; } - if (opt_pd_stack) { - pds = g_strsplit(opt_pd_stack, ",", 0); - if (g_strv_length(pds) < 2) { - printf("Specify at least two protocol decoders to stack.\n"); - return 1; - } - - if (!(di_from = srd_inst_find_by_id(pds[0]))) { - printf("Cannot stack protocol decoder '%s': instance not found.\n", pds[0]); - return 1; - } - for (i = 1; pds[i]; i++) { - if (!(di_to = srd_inst_find_by_id(pds[i]))) { - printf("Cannot stack protocol decoder '%s': instance not found.\n", pds[i]); - return 1; - } - if ((ret = srd_inst_stack(di_from, di_to) != SRD_OK)) - return ret; - - /* Don't show annotation from this PD. Only the last PD in - * the stack will be left on the annotation list. - */ - g_datalist_remove_data(&pd_ann_visible, di_from->inst_id); - - di_from = di_to; - } - g_strfreev(pds); - } - - if (!opt_format) { - opt_format = DEFAULT_OUTPUT_FORMAT; - /* we'll need to remember this so when saving to a file - * later, sigrok session format will be used. - */ - default_output_format = TRUE; - } - fmtargs = parse_generic_arg(opt_format); - fmtspec = g_hash_table_lookup(fmtargs, "sigrok_key"); - if (!fmtspec) { - printf("Invalid output format.\n"); - return 1; - } - outputs = sr_output_list(); - for (i = 0; outputs[i]; i++) { - if (strcmp(outputs[i]->id, fmtspec)) - continue; - g_hash_table_remove(fmtargs, "sigrok_key"); - output_format = outputs[i]; - g_hash_table_iter_init(&iter, fmtargs); - while (g_hash_table_iter_next(&iter, &key, &value)) { - /* only supporting one parameter per output module - * for now, and only its value */ - output_format_param = g_strdup(value); - break; - } - break; - } - if (!output_format) { - printf("invalid output format %s\n", opt_format); - return 1; - } + if (setup_output_format() != 0) + goto done; if (opt_version) show_version(); else if (opt_list_devs) show_dev_list(); + else if (opt_pds && opt_show) + show_pd_detail(); + else if (opt_show) + show_dev_detail(); else if (opt_input_file) load_input_file(); - else if (opt_samples || opt_time || opt_continuous) + else if (opt_samples || opt_time || opt_frames || opt_continuous) run_session(); - else if (opt_dev) - show_dev_detail(); - else if (opt_pds) - show_pd_detail(); else printf("%s", g_option_context_get_help(context, TRUE, NULL)); if (opt_pds) srd_exit(); + ret = 0; + +done: + if (sr_ctx) + sr_exit(sr_ctx); + g_option_context_free(context); - g_hash_table_destroy(fmtargs); - sr_exit(); - return 0; + return ret; }