X-Git-Url: https://sigrok.org/gitweb/?p=sigrok-cli.git;a=blobdiff_plain;f=sigrok-cli.c;h=dbe0b2cdecd3c2d297c0b7686ddece50dbd23bd4;hp=bcdeb3e9fb7151771f6376383b1329eb0b89116c;hb=49dbdb782e21dda3e9be242ddcc37f0bcd06f4a7;hpb=37d5ccc11cb29dd65c9a550eb5c5dea55006bc74 diff --git a/sigrok-cli.c b/sigrok-cli.c index bcdeb3e..dbe0b2c 100644 --- a/sigrok-cli.c +++ b/sigrok-cli.c @@ -1,5 +1,5 @@ /* - * This file is part of the sigrok project. + * This file is part of the sigrok-cli project. * * Copyright (C) 2012 Bert Vermeulen * @@ -17,7 +17,10 @@ * along with this program. If not, see . */ -#include /* First, so we avoid a _POSIX_C_SOURCE warning. */ +#include "config.h" +#ifdef HAVE_SRD +#include /* First, so we avoid a _POSIX_C_SOURCE warning. */ +#endif #include #include #include @@ -32,33 +35,37 @@ #include #include #include "sigrok-cli.h" -#include "config.h" #define DEFAULT_OUTPUT_FORMAT "bits:width=64" -extern struct sr_hwcap_option sr_drvopts[]; -extern struct sr_hwcap_option sr_hwcap_options[]; +static struct sr_context *sr_ctx = NULL; 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; +#ifdef HAVE_SRD +static struct srd_session *srd_sess = NULL; static GHashTable *pd_ann_visible = NULL; +#endif +static GByteArray *savebuf; static gboolean opt_version = FALSE; static gint opt_loglevel = SR_LOG_WARN; /* Show errors+warnings per default. */ -static gboolean opt_list_devs = FALSE; +static gboolean opt_scan_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_config = NULL; static gchar *opt_probes = NULL; static gchar *opt_triggers = NULL; static gchar *opt_pds = NULL; +#ifdef HAVE_SRD static gchar *opt_pd_stack = NULL; static gchar *opt_pd_annotations = NULL; +#endif static gchar *opt_input_format = NULL; static gchar *opt_output_format = NULL; static gchar *opt_show = NULL; @@ -66,18 +73,17 @@ static gchar *opt_time = NULL; static gchar *opt_samples = NULL; static gchar *opt_frames = NULL; static gchar *opt_continuous = NULL; +static gchar *opt_set = 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, - "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}, + "Set loglevel (5 is most verbose)", NULL}, + {"driver", 'd', 0, G_OPTION_ARG_STRING, &opt_drv, + "The driver to use", NULL}, + {"config", 'c', 0, G_OPTION_ARG_STRING, &opt_config, + "Specify device configuration options", 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, @@ -92,12 +98,16 @@ static GOptionEntry optargs[] = { "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, +#ifdef HAVE_SRD + {"protocol-decoders", 'P', 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", '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}, +#endif + {"scan", 0, 0, G_OPTION_ARG_NONE, &opt_scan_devs, + "Scan for devices", NULL}, {"show", 0, 0, G_OPTION_ARG_NONE, &opt_show, "Show device detail", NULL}, {"time", 0, 0, G_OPTION_ARG_STRING, &opt_time, @@ -108,15 +118,16 @@ static GOptionEntry optargs[] = { "Number of frames to acquire", NULL}, {"continuous", 0, 0, G_OPTION_ARG_NONE, &opt_continuous, "Sample continuously", NULL}, + {"set", 0, 0, G_OPTION_ARG_NONE, &opt_set, "Set device options only", NULL}, {NULL, 0, 0, 0, NULL, NULL, NULL} }; -/* Convert driver options hash to GSList of struct sr_hwopt. */ +/* Convert driver options hash to GSList of struct sr_config. */ static GSList *hash_to_hwopt(GHashTable *hash) { - struct sr_hwcap_option *ho; - struct sr_hwopt *hwopt; + const struct sr_config_info *srci; + struct sr_config *src; GList *gl, *keys; GSList *opts; char *key, *value; @@ -125,26 +136,27 @@ static GSList *hash_to_hwopt(GHashTable *hash) opts = NULL; for (gl = keys; gl; gl = gl->next) { key = gl->data; - for (ho = sr_drvopts; ho->shortname; ho++) { - if (!strcmp(key, ho->shortname)) { - hwopt = g_try_malloc(sizeof(struct sr_hwopt)); - hwopt->hwopt = ho->hwcap; - value = g_hash_table_lookup(hash, key); - hwopt->value = g_strdup(value); - opts = g_slist_append(opts, hwopt); - break; - } - } - if (!ho->shortname) { + 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->data = g_variant_new_string(value); + opts = g_slist_append(opts, src); } g_list_free(keys); return opts; } +static void free_drvopts(struct sr_config *src) +{ + g_variant_unref(src->data); + g_free(src); +} + static GSList *device_scan(void) { struct sr_dev_driver **drivers, *driver; @@ -166,26 +178,34 @@ static GSList *device_scan(void) } if (!driver) { g_critical("Driver %s not found.", drvname); + g_hash_table_destroy(drvargs); + g_free(drvname); return NULL; } g_free(drvname); - if (sr_driver_init(driver) != SR_OK) { + if (sr_driver_init(sr_ctx, driver) != SR_OK) { g_critical("Failed to initialize driver."); + g_hash_table_destroy(drvargs); return NULL; } drvopts = NULL; - if (g_hash_table_size(drvargs) > 0) - if (!(drvopts = hash_to_hwopt(drvargs))) + if (g_hash_table_size(drvargs) > 0) { + if (!(drvopts = hash_to_hwopt(drvargs))) { /* Unknown options, already logged. */ + g_hash_table_destroy(drvargs); return NULL; + } + } + g_hash_table_destroy(drvargs); 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(driver) != SR_OK) { + if (sr_driver_init(sr_ctx, driver) != SR_OK) { g_critical("Failed to initialize driver."); return NULL; } @@ -201,19 +221,23 @@ static GSList *device_scan(void) static void show_version(void) { - GSList *l; struct sr_dev_driver **drivers; struct sr_input_format **inputs; struct sr_output_format **outputs; - struct srd_decoder *dec; int i; +#ifdef HAVE_SRD + struct srd_decoder *dec; + const GSList *l; +#endif 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()); +#ifdef HAVE_SRD printf("Using libsigrokdecode %s (lib version %s).\n\n", srd_package_version_string_get(), srd_lib_version_string_get()); +#endif printf("Supported hardware drivers:\n"); drivers = sr_driver_list(); @@ -232,8 +256,10 @@ static void show_version(void) outputs = sr_output_list(); for (i = 0; outputs[i]; i++) printf(" %-20s %s\n", outputs[i]->id, outputs[i]->description); + printf(" %-20s %s\n", "sigrok", "Default file output format"); printf("\n"); +#ifdef HAVE_SRD if (srd_init(NULL) == SRD_OK) { printf("Supported protocol decoders:\n"); srd_decoder_load_all(); @@ -247,20 +273,46 @@ static void show_version(void) srd_exit(); } printf("\n"); +#endif } static void print_dev_line(const struct sr_dev_inst *sdi) { - + struct sr_probe *probe; + GSList *l; + GString *s; + GVariant *gvar; + + s = g_string_sized_new(128); + g_string_assign(s, sdi->driver->name); + if (sr_config_get(sdi->driver, SR_CONF_CONN, &gvar, sdi) == SR_OK) { + g_string_append(s, ":conn="); + g_string_append(s, g_variant_get_string(gvar, NULL)); + g_variant_unref(gvar); + } + g_string_append(s, " - "); if (sdi->vendor && sdi->vendor[0]) - printf("%s ", sdi->vendor); + g_string_append_printf(s, "%s ", sdi->vendor); if (sdi->model && sdi->model[0]) - printf("%s ", sdi->model); + g_string_append_printf(s, "%s ", sdi->model); if (sdi->version && sdi->version[0]) - printf("%s ", sdi->version); - if (sdi->probes) - printf("with %d probes", g_slist_length(sdi->probes)); - printf("\n"); + g_string_append_printf(s, "%s ", sdi->version); + if (sdi->probes) { + if (g_slist_length(sdi->probes) == 1) { + probe = sdi->probes->data; + g_string_append_printf(s, "with 1 probe: %s", probe->name); + } else { + g_string_append_printf(s, "with %d probes:", g_slist_length(sdi->probes)); + for (l = sdi->probes; l; l = l->next) { + probe = l->data; + g_string_append_printf(s, " %s", probe->name); + } + } + } + g_string_append_printf(s, "\n"); + printf("%s", s->str); + g_string_free(s, TRUE); + } static void show_dev_list(void) @@ -283,14 +335,16 @@ static void show_dev_list(void) static void show_dev_detail(void) { struct sr_dev_inst *sdi; - const struct sr_hwcap_option *hwo; - const struct sr_samplerates *samplerates; - struct sr_rational *rationals; + const struct sr_config_info *srci; GSList *devices; - uint64_t *integers; - const int *hwopts, *hwcaps; - int cap, num_devices, n, i; - char *s, *title; + GVariant *gvar_opts, *gvar_dict, *gvar_list, *gvar; + gsize num_opts, num_elements; + const uint64_t *uint64, p, q, low, high; + uint64_t cur_low, cur_high; + const int32_t *opts; + unsigned int num_devices, o, i; + char *tmp_str; + char *s; const char *charopts, **stropts; if (!(devices = device_scan())) { @@ -300,193 +354,267 @@ static void show_dev_detail(void) 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); + g_critical("%d devices found. Use --scan to show them, " + "and select one to show.", num_devices); + return; + } + sdi = devices->data; print_dev_line(sdi); - if (sr_info_get(sdi->driver, SR_DI_TRIGGER_TYPES, (const void **)&charopts, - sdi) == SR_OK && charopts) { - printf("Supported triggers: "); - while (*charopts) { - printf("%c ", *charopts); - charopts++; - } - printf("\n"); + if (sr_dev_open(sdi) != SR_OK) { + g_critical("Failed to open device."); + return; } - if ((sr_info_get(sdi->driver, SR_DI_HWOPTS, (const void **)&hwopts, - NULL) == SR_OK) && hwopts) { + if ((sr_config_list(sdi->driver, SR_CONF_SCAN_OPTIONS, &gvar_opts, + NULL) == SR_OK)) { + opts = g_variant_get_fixed_array(gvar_opts, &num_elements, + sizeof(int32_t)); printf("Supported driver options:\n"); - for (i = 0; hwopts[i]; i++) { - if (!(hwo = sr_drvopt_get(hwopts[i]))) + for (i = 0; i < num_elements; i++) { + if (!(srci = sr_config_info_get(opts[i]))) continue; - printf(" %s\n", hwo->shortname); + printf(" %s\n", srci->id); } + g_variant_unref(gvar_opts); } - title = "Supported device options:\n"; - if ((sr_info_get(sdi->driver, SR_DI_HWCAPS, (const void **)&hwcaps, - NULL) != SR_OK) || !hwcaps) + if ((sr_config_list(sdi->driver, SR_CONF_DEVICE_OPTIONS, &gvar_opts, + sdi) != SR_OK)) /* Driver supports no device instance options. */ return; - for (cap = 0; hwcaps[cap]; cap++) { - if (!(hwo = sr_hw_hwcap_get(hwcaps[cap]))) + printf("Supported configuration options:\n"); + opts = g_variant_get_fixed_array(gvar_opts, &num_opts, sizeof(int32_t)); + for (o = 0; o < num_opts; o++) { + if (!(srci = sr_config_info_get(opts[o]))) continue; - if (title) { - printf("%s", title); - title = NULL; - } + if (srci->key == SR_CONF_TRIGGER_TYPE) { + if (sr_config_list(sdi->driver, srci->key, &gvar, + sdi) != SR_OK) { + printf("\n"); + continue; + } + charopts = g_variant_get_string(gvar, NULL); + printf(" Supported triggers: "); + while (*charopts) { + printf("%c ", *charopts); + charopts++; + } + printf("\n"); + g_variant_unref(gvar); - if (hwo->hwcap == SR_HWCAP_PATTERN_MODE) { + } else if (srci->key == SR_CONF_PATTERN_MODE) { /* Pattern generator modes */ - printf(" %s", hwo->shortname); - if (sr_info_get(sdi->driver, SR_DI_PATTERNS, - (const void **)&stropts, sdi) == SR_OK) { + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, srci->key, &gvar, + sdi) == SR_OK) { printf(" - supported patterns:\n"); - for (i = 0; stropts[i]; i++) + stropts = g_variant_get_strv(gvar, &num_elements); + for (i = 0; i < num_elements; i++) printf(" %s\n", stropts[i]); + g_variant_unref(gvar); } else { printf("\n"); } - } else if (hwo->hwcap == SR_HWCAP_SAMPLERATE) { + } else if (srci->key == SR_CONF_SAMPLERATE) { /* Supported samplerates */ - printf(" %s", hwo->shortname); - if (sr_info_get(sdi->driver, SR_DI_SAMPLERATES, - (const void **)&samplerates, sdi) != SR_OK) { + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_SAMPLERATE, + &gvar_dict, sdi) != SR_OK) { printf("\n"); continue; } - if (samplerates->step) { + if ((gvar_list = g_variant_lookup_value(gvar_dict, + "samplerates", G_VARIANT_TYPE("at")))) { + uint64 = g_variant_get_fixed_array(gvar_list, + &num_elements, sizeof(uint64_t)); + printf(" - supported samplerates:\n"); + for (i = 0; i < num_elements; i++) { + if (!(s = sr_samplerate_string(uint64[i]))) + continue; + printf(" %s\n", s); + g_free(s); + } + g_variant_unref(gvar_list); + } else if ((gvar_list = g_variant_lookup_value(gvar_dict, + "samplerate-steps", G_VARIANT_TYPE("at")))) { + uint64 = g_variant_get_fixed_array(gvar_list, + &num_elements, sizeof(uint64_t)); /* low */ - if (!(s = sr_samplerate_string(samplerates->low))) + if (!(s = sr_samplerate_string(uint64[0]))) continue; printf(" (%s", s); g_free(s); /* high */ - if (!(s = sr_samplerate_string(samplerates->high))) + if (!(s = sr_samplerate_string(uint64[1]))) continue; printf(" - %s", s); g_free(s); /* step */ - if (!(s = sr_samplerate_string(samplerates->step))) + if (!(s = sr_samplerate_string(uint64[2]))) continue; printf(" in steps of %s)\n", s); g_free(s); - } else { - printf(" - supported samplerates:\n"); - for (i = 0; samplerates->list[i]; i++) - printf(" %s\n", sr_samplerate_string(samplerates->list[i])); + g_variant_unref(gvar_list); } + g_variant_unref(gvar_dict); - } else if (hwo->hwcap == SR_HWCAP_BUFFERSIZE) { + } else if (srci->key == SR_CONF_BUFFERSIZE) { /* Supported buffer sizes */ - printf(" %s", hwo->shortname); - if (sr_info_get(sdi->driver, SR_DI_BUFFERSIZES, - (const void **)&integers, sdi) != SR_OK) { + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_BUFFERSIZE, + &gvar_list, sdi) != SR_OK) { printf("\n"); continue; } + uint64 = g_variant_get_fixed_array(gvar_list, + &num_elements, sizeof(uint64_t)); printf(" - supported buffer sizes:\n"); - for (i = 0; integers[i]; i++) - printf(" %"PRIu64"\n", integers[i]); + for (i = 0; i < num_elements; i++) + printf(" %"PRIu64"\n", uint64[i]); + g_variant_unref(gvar_list); - } else if (hwo->hwcap == SR_HWCAP_TIMEBASE) { + } else if (srci->key == SR_CONF_TIMEBASE) { /* Supported time bases */ - printf(" %s", hwo->shortname); - if (sr_info_get(sdi->driver, SR_DI_TIMEBASES, - (const void **)&rationals, sdi) != SR_OK) { + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_TIMEBASE, + &gvar_list, 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 (hwo->hwcap == SR_HWCAP_TRIGGER_SOURCE) { - /* Supported trigger sources */ - printf(" %s", hwo->shortname); - if (sr_info_get(sdi->driver, SR_DI_TRIGGER_SOURCES, - (const void **)&stropts, sdi) != SR_OK) { + num_elements = g_variant_n_children(gvar_list); + for (i = 0; i < num_elements; i++) { + gvar = g_variant_get_child_value(gvar_list, i); + g_variant_get(gvar, "(tt)", &p, &q); + s = sr_period_string(p * q); + printf(" %s\n", s); + g_free(s); + } + g_variant_unref(gvar_list); + + } else if (srci->key == SR_CONF_VDIV) { + /* Supported volts/div values */ + printf(" %s", srci->id); + if (sr_config_list(sdi->driver, SR_CONF_VDIV, + &gvar_list, sdi) != SR_OK) { printf("\n"); continue; } - printf(" - supported trigger sources:\n"); - for (i = 0; stropts[i]; i++) - printf(" %s\n", stropts[i]); - - } else if (hwo->hwcap == SR_HWCAP_FILTER) { - /* Supported trigger sources */ - printf(" %s", hwo->shortname); - if (sr_info_get(sdi->driver, SR_DI_FILTERS, - (const void **)&stropts, sdi) != SR_OK) { + printf(" - supported volts/div:\n"); + num_elements = g_variant_n_children(gvar_list); + for (i = 0; i < num_elements; i++) { + gvar = g_variant_get_child_value(gvar_list, i); + g_variant_get(gvar, "(tt)", &p, &q); + s = sr_voltage_string(p, q); + printf(" %s\n", s); + g_free(s); + } + g_variant_unref(gvar_list); + + } else if (srci->datatype == SR_T_CHAR) { + printf(" %s: ", srci->id); + if (sr_config_get(sdi->driver, srci->key, + &gvar, sdi) == SR_OK) { + tmp_str = g_strdup(g_variant_get_string(gvar, NULL)); + g_variant_unref(gvar); + } else + tmp_str = NULL; + + if (sr_config_list(sdi->driver, srci->key, + &gvar, sdi) != SR_OK) { printf("\n"); continue; } - printf(" - supported filter targets:\n"); - for (i = 0; stropts[i]; i++) - printf(" %s\n", stropts[i]); - } else if (hwo->hwcap == SR_HWCAP_VDIV) { - /* Supported volts/div values */ - printf(" %s", hwo->shortname); - if (sr_info_get(sdi->driver, SR_DI_VDIVS, - (const void **)&rationals, sdi) != SR_OK) { - printf("\n"); - continue; + stropts = g_variant_get_strv(gvar, &num_elements); + for (i = 0; i < num_elements; i++) { + if (i) + printf(", "); + printf("%s", stropts[i]); + if (tmp_str && !strcmp(tmp_str, stropts[i])) + printf(" (current)"); } - 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 (hwo->hwcap == SR_HWCAP_COUPLING) { - /* Supported coupling settings */ - printf(" %s", hwo->shortname); - if (sr_info_get(sdi->driver, SR_DI_COUPLING, - (const void **)&stropts, sdi) != SR_OK) { + printf("\n"); + g_free(stropts); + g_free(tmp_str); + g_variant_unref(gvar); + + } else if (srci->datatype == SR_T_UINT64_RANGE) { + printf(" %s: ", srci->id); + if (sr_config_list(sdi->driver, srci->key, + &gvar_list, sdi) != SR_OK) { printf("\n"); continue; } - printf(" - supported coupling options:\n"); - for (i = 0; stropts[i]; i++) - printf(" %s\n", stropts[i]); + + if (sr_config_get(sdi->driver, srci->key, &gvar, sdi) == SR_OK) { + g_variant_get(gvar, "(tt)", &cur_low, &cur_high); + g_variant_unref(gvar); + } else { + cur_low = 0; + cur_high = 0; + } + + num_elements = g_variant_n_children(gvar_list); + for (i = 0; i < num_elements; i++) { + gvar = g_variant_get_child_value(gvar_list, i); + g_variant_get(gvar, "(tt)", &low, &high); + g_variant_unref(gvar); + if (i) + printf(", "); + printf("%"PRIu64"-%"PRIu64, low, high); + if (low == cur_low && high == cur_high) + printf(" (current)"); + } + printf("\n"); + g_variant_unref(gvar_list); + + } else if (srci->datatype == SR_T_BOOL) { + printf(" %s: ", srci->id); + if (sr_config_get(sdi->driver, srci->key, + &gvar, sdi) == SR_OK) { + if (g_variant_get_boolean(gvar)) + printf("on (current), off\n"); + else + printf("on, off (current)\n"); + g_variant_unref(gvar); + } else + printf("on, off\n"); } else { + /* Everything else */ - printf(" %s\n", hwo->shortname); + printf(" %s\n", srci->id); } } + g_variant_unref(gvar_opts); + + sr_dev_close(sdi); + g_slist_free(devices); } +#ifdef HAVE_SRD static void show_pd_detail(void) { GSList *l; struct srd_decoder *dec; - char **pdtokens, **pdtok, **ann, *doc; + struct srd_decoder_option *o; + char **pdtokens, **pdtok, *optsep, **ann, *val, *doc; struct srd_probe *p; pdtokens = g_strsplit(opt_pds, ",", -1); for (pdtok = pdtokens; *pdtok; pdtok++) { + /* Strip options. */ + if ((optsep = strchr(*pdtok, ':'))) + *optsep = '\0'; if (!(dec = srd_decoder_get_by_id(*pdtok))) { - printf("Protocol decoder %s not found.\n", *pdtok); + g_critical("Protocol decoder %s not found.", *pdtok); return; } printf("ID: %s\nName: %s\nLong name: %s\nDescription: %s\n", @@ -501,7 +629,6 @@ static void show_pd_detail(void) } else { printf("None.\n"); } - /* TODO: Print supported decoder options. */ printf("Required probes:\n"); if (dec->probes) { for (l = dec->probes; l; l = l->next) { @@ -522,6 +649,15 @@ static void show_pd_detail(void) } else { printf("None.\n"); } + if (dec->options) { + printf("Options:\n"); + for (l = dec->options; l; l = l->next) { + o = l->data; + val = g_variant_print(o->def, FALSE); + printf("- %s: %s (default %s)\n", o->id, o->desc, val); + g_free(val); + } + } if ((doc = srd_decoder_doc_get(dec))) { printf("Documentation:\n%s\n", doc[0] == '\n' ? doc + 1 : doc); @@ -531,28 +667,48 @@ static void show_pd_detail(void) g_strfreev(pdtokens); } +#endif + +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(const struct sr_dev_inst *sdi, - struct sr_datafeed_packet *packet) + const struct sr_datafeed_packet *packet, void *cb_data) { + 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 logic_probelist[SR_MAX_NUM_PROBES] = { 0 }; - static struct sr_probe *analog_probelist[SR_MAX_NUM_PROBES]; + static GArray *logic_probelist = NULL; static uint64_t received_samples = 0; static int unitsize = 0; static int triggered = 0; static FILE *outfile = NULL; - static int num_analog_probes = 0; - struct sr_probe *probe; - struct sr_datafeed_logic *logic; - struct sr_datafeed_meta_logic *meta_logic; - struct sr_datafeed_analog *analog; - struct sr_datafeed_meta_analog *meta_analog; - static int num_enabled_analog_probes = 0; - int num_enabled_probes, sample_size, ret, i; - uint64_t output_len, filter_out_len; + GSList *l; + GString *out; + int sample_size, ret; + uint64_t samplerate, output_len, filter_out_len, end_sample; uint8_t *output_buf, *filter_out; + (void) cb_data; + /* If the first packet to come in isn't a header, don't even try. */ if (packet->type != SR_DF_HEADER && o == NULL) return; @@ -575,77 +731,84 @@ static void datafeed_in(const struct sr_dev_inst *sdi, exit(1); } } - break; - - case SR_DF_END: - g_debug("cli: Received SR_DF_END"); - if (!o) { - g_debug("cli: double end!"); - break; - } - if (o->format->event) { - o->format->event(o, SR_DF_END, &output_buf, &output_len); - if (output_buf) { - if (outfile) - fwrite(output_buf, 1, output_len, outfile); - g_free(output_buf); - output_len = 0; - } - } - if (limit_samples && received_samples < limit_samples) - g_warning("Device only sent %" PRIu64 " samples.", - received_samples); - if (opt_continuous) - g_warning("Device stopped after %" PRIu64 " samples.", - received_samples); - sr_session_stop(); - if (outfile && outfile != stdout) - fclose(outfile); - g_free(o); - o = NULL; - break; - - case 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_META_LOGIC: - g_message("cli: Received SR_DF_META_LOGIC"); - meta_logic = packet->payload; - num_enabled_probes = 0; - for (i = 0; i < meta_logic->num_probes; i++) { - probe = g_slist_nth_data(sdi->probes, i); - if (probe->enabled) - logic_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, - meta_logic->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; + +#ifdef HAVE_SRD + GVariant *gvar; + if (opt_pds && logic_probelist->len) { + if (sr_config_get(sdi->driver, SR_CONF_SAMPLERATE, + &gvar, sdi) == SR_OK) { + samplerate = g_variant_get_uint64(gvar); + g_variant_unref(gvar); + if (srd_session_metadata_set(srd_sess, SRD_CONF_SAMPLERATE, + g_variant_new_uint64(samplerate)) != SRD_OK) { + g_critical("Failed to configure decode session."); + break; + } + } + if (srd_session_start(srd_sess) != SRD_OK) { + g_critical("Failed to start decode session."); + break; + } + } +#endif + 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 = g_variant_get_uint64(src->data); + g_debug("cli: got samplerate %"PRIu64" Hz", samplerate); +#ifdef HAVE_SRD + if (opt_pds) { + if (srd_session_metadata_set(srd_sess, SRD_CONF_SAMPLERATE, + g_variant_new_uint64(samplerate)) != SRD_OK) { + g_critical("Failed to pass samplerate to decoder."); + } + } +#endif + break; + case SR_CONF_SAMPLE_INTERVAL: + samplerate = g_variant_get_uint64(src->data); + g_debug("cli: got sample interval %"PRIu64" ms", samplerate); + break; + default: + /* Unknown metadata is not an error. */ + break; + } + } + break; + + case 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: @@ -663,78 +826,47 @@ static void datafeed_in(const struct sr_dev_inst *sdi, break; ret = sr_filter_probes(sample_size, unitsize, logic_probelist, - logic->data, logic->length, - &filter_out, &filter_out_len); + logic->data, logic->length, + &filter_out, &filter_out_len); if (ret != SR_OK) break; - /* what comes out of the filter is guaranteed to be packed into the + /* + * 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 + * 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; - if (dev->datastore) - sr_datastore_put(dev->datastore, filter_out, - filter_out_len, sample_size, logic_probelist); - - 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 (opt_pds) { - if (srd_session_send(received_samples, (uint8_t*)filter_out, - filter_out_len) != SRD_OK) - sr_session_stop(); + if (opt_output_file && default_output_format) { + /* Saving to a session file. */ + g_byte_array_append(savebuf, filter_out, filter_out_len); } 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); + if (opt_pds) { +#ifdef HAVE_SRD + end_sample = received_samples + filter_out_len / unitsize; + if (srd_session_send(srd_sess, received_samples, end_sample, + (uint8_t*)filter_out, filter_out_len) != SRD_OK) + sr_session_stop(); +#endif + } 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); + fflush(outfile); + g_free(output_buf); + } } } - - cleanup: g_free(filter_out); - received_samples += logic->length / sample_size; - break; - case SR_DF_META_ANALOG: - g_message("cli: Received SR_DF_META_ANALOG"); - meta_analog = packet->payload; - num_analog_probes = meta_analog->num_probes; - num_enabled_analog_probes = 0; - for (i = 0; i < num_analog_probes; i++) { - probe = g_slist_nth_data(sdi->probes, i); - if (probe->enabled) - analog_probelist[num_enabled_analog_probes++] = probe; - } - - 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, - * 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); - } - } 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"); - } - } + received_samples += logic->length / sample_size; break; case SR_DF_ANALOG: @@ -787,11 +919,143 @@ static void datafeed_in(const struct sr_dev_inst *sdi, break; default: - g_message("received unknown packet type %d", packet->type); + break; + } + + if (o && o->format->receive) { + if (o->format->receive(o, sdi, packet, &out) == SR_OK && out) { + fwrite(out->str, 1, out->len, outfile); + fflush(outfile); + g_string_free(out, TRUE); + } + } + + /* SR_DF_END needs to be handled after the output module's receive() + * is called, so it can properly clean up that module etc. */ + if (packet->type == SR_DF_END) { + g_debug("cli: Received SR_DF_END"); + + if (o->format->event) { + o->format->event(o, SR_DF_END, &output_buf, &output_len); + if (output_buf) { + if (outfile) + fwrite(output_buf, 1, output_len, outfile); + g_free(output_buf); + output_len = 0; + } + } + + if (limit_samples && received_samples < limit_samples) + g_warning("Device only sent %" PRIu64 " samples.", + received_samples); + + if (opt_continuous) + g_warning("Device stopped after %" PRIu64 " samples.", + received_samples); + + g_array_free(logic_probelist, TRUE); + + if (o->format->cleanup) + o->format->cleanup(o); + g_free(o); + o = NULL; + + if (outfile && outfile != stdout) + fclose(outfile); + + if (opt_output_file && default_output_format && savebuf->len) { + 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); + } } } +#ifdef HAVE_SRD +static int opts_to_gvar(struct srd_decoder *dec, GHashTable *hash, + GHashTable **options) +{ + struct srd_decoder_option *o; + GSList *optl; + GVariant *gvar; + gint64 val_int; + int ret; + char *val_str, *conv; + + ret = TRUE; + *options = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, + (GDestroyNotify)g_variant_unref); + + for (optl = dec->options; optl; optl = optl->next) { + o = optl->data; + if (!(val_str = g_hash_table_lookup(hash, o->id))) + /* Not specified. */ + continue; + if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_STRING)) { + gvar = g_variant_new_string(val_str); + } else if (g_variant_is_of_type(o->def, G_VARIANT_TYPE_INT64)) { + val_int = strtoll(val_str, &conv, 0); + if (!conv || conv == val_str) { + g_critical("Protocol decoder '%s' option '%s' " + "requires a number.", dec->name, o->id); + ret = FALSE; + break; + } + gvar = g_variant_new_int64(val_int); + } else { + g_critical("Unsupported type for option '%s' (%s)", + o->id, g_variant_get_type_string(o->def)); + ret = FALSE; + break; + } + g_variant_ref_sink(gvar); + g_hash_table_insert(*options, g_strdup(o->id), gvar); + g_hash_table_remove(hash, o->id); + } + + return ret; +} + +static int probes_to_gvar(struct srd_decoder *dec, GHashTable *hash, + GHashTable **probes) +{ + struct srd_probe *p; + GSList *all_probes, *l; + GVariant *gvar; + gint32 val_int; + int ret; + char *val_str, *conv; + + ret = TRUE; + *probes = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, + (GDestroyNotify)g_variant_unref); + + all_probes = g_slist_copy(dec->probes); + all_probes = g_slist_concat(all_probes, g_slist_copy(dec->opt_probes)); + for (l = all_probes; l; l = l->next) { + p = l->data; + if (!(val_str = g_hash_table_lookup(hash, p->id))) + /* Not specified. */ + continue; + val_int = strtoll(val_str, &conv, 10); + if (!conv || conv == val_str) { + g_critical("Protocol decoder '%s' probes '%s' " + "is not a number.", dec->name, p->id); + ret = FALSE; + break; + } + gvar = g_variant_new_int32(val_int); + g_variant_ref_sink(gvar); + g_hash_table_insert(*probes, g_strdup(p->id), gvar); + g_hash_table_remove(hash, p->id); + } + g_slist_free(all_probes); + + return ret; +} + /* Register the given PDs for this session. * Accepts a string of the form: "spi:sck=3:sdata=4,spi:sck=3:sdata=5" * That will instantiate two SPI decoders on the clock but different data @@ -799,24 +1063,25 @@ static void datafeed_in(const struct sr_dev_inst *sdi, */ static int register_pds(struct sr_dev *dev, const char *pdstring) { - GHashTable *pd_opthash; + struct srd_decoder *dec; + GHashTable *pd_opthash, *options, *probes; + GList *leftover, *l; struct srd_decoder_inst *di; int ret; char **pdtokens, **pdtok, *pd_name; - /* Avoid compiler warnings. */ (void)dev; 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; + pd_opthash = options = probes = NULL; pdtokens = g_strsplit(pdstring, ",", 0); for (pdtok = pdtokens; *pdtok; pdtok++) { if (!(pd_opthash = parse_generic_arg(*pdtok, TRUE))) { g_critical("Invalid protocol decoder option '%s'.", *pdtok); - goto err_out; + break; } pd_name = g_strdup(g_hash_table_lookup(pd_opthash, "sigrok_key")); @@ -824,12 +1089,31 @@ static int register_pds(struct sr_dev *dev, const char *pdstring) if (srd_decoder_load(pd_name) != SRD_OK) { g_critical("Failed to load protocol decoder %s.", pd_name); ret = 1; - goto err_out; + break; } - if (!(di = srd_inst_new(pd_name, pd_opthash))) { + dec = srd_decoder_get_by_id(pd_name); + + /* Convert decoder option and probe values to GVariant. */ + if (!opts_to_gvar(dec, pd_opthash, &options)) { + ret = 1; + break; + } + if (!probes_to_gvar(dec, pd_opthash, &probes)) { + ret = 1; + break; + } + if (g_hash_table_size(pd_opthash) > 0) { + leftover = g_hash_table_get_keys(pd_opthash); + for (l = leftover; l; l = l->next) + g_critical("Unknown option or probe '%s'", (char *)l->data); + g_list_free(leftover); + break; + } + + if (!(di = srd_inst_new(srd_sess, pd_name, options))) { g_critical("Failed to instantiate protocol decoder %s.", pd_name); ret = 1; - goto err_out; + break; } /* If no annotation list was specified, add them all in now. @@ -840,22 +1124,20 @@ static int register_pds(struct sr_dev *dev, const char *pdstring) 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_probe_set_all(di, pd_opthash) != SRD_OK) { + /* Remap the probes if needed. */ + if (srd_inst_probe_set_all(di, probes) != SRD_OK) { ret = 1; - goto err_out; + break; } - g_hash_table_destroy(pd_opthash); - pd_opthash = NULL; } -err_out: g_strfreev(pdtokens); if (pd_opthash) g_hash_table_destroy(pd_opthash); + if (options) + g_hash_table_destroy(options); + if (probes) + g_hash_table_destroy(probes); if (pd_name) g_free(pd_name); @@ -884,7 +1166,7 @@ int setup_pd_stack(void) /* 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]))) { + if (!(di_from = srd_inst_find_by_id(srd_sess, ids[0]))) { g_strfreev(ids); g_critical("Cannot stack protocol decoder '%s': " "instance not found.", pds[0]); @@ -895,14 +1177,14 @@ int setup_pd_stack(void) /* 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]))) { + if (!(di_to = srd_inst_find_by_id(srd_sess, 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) + if ((ret = srd_inst_stack(srd_sess, di_from, di_to)) != SRD_OK) return 1; /* Don't show annotation from this PD. Only the last PD in @@ -965,6 +1247,38 @@ int setup_pd_annotations(void) return 0; } +void show_pd_annotations(struct srd_proto_data *pdata, void *cb_data) +{ + int i; + char **annotations; + gpointer ann_format; + + /* 'cb_data' is not used in this specific callback. */ + (void)cb_data; + + if (!pd_ann_visible) + return; + + 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) + printf("%"PRIu64"-%"PRIu64" ", pdata->start_sample, pdata->end_sample); + printf("%s: ", pdata->pdo->proto_id); + for (i = 0; annotations[i]; i++) + printf("\"%s\" ", annotations[i]); + printf("\n"); + fflush(stdout); +} +#endif + int setup_output_format(void) { GHashTable *fmtargs; @@ -974,6 +1288,13 @@ int setup_output_format(void) int i; char *fmtspec; + if (opt_output_format && !strcmp(opt_output_format, "sigrok")) { + /* Doesn't really exist as an output module - this is + * the session save mode. */ + g_free(opt_output_format); + opt_output_format = NULL; + } + if (!opt_output_format) { opt_output_format = DEFAULT_OUTPUT_FORMAT; /* we'll need to remember this so when saving to a file @@ -1012,64 +1333,25 @@ int setup_output_format(void) return 0; } -void show_pd_annotations(struct srd_proto_data *pdata, void *cb_data) -{ - int i; - char **annotations; - gpointer ann_format; - - /* 'cb_data' is not used in this specific callback. */ - (void)cb_data; - - if (!pd_ann_visible) - return; - - 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) - printf("%"PRIu64"-%"PRIu64" ", pdata->start_sample, pdata->end_sample); - printf("%s: ", pdata->pdo->proto_id); - for (i = 0; annotations[i]; i++) - printf("\"%s\" ", annotations[i]); - printf("\n"); - fflush(stdout); -} - static int select_probes(struct sr_dev_inst *sdi) { - char **probelist; - int max_probes, i; + struct sr_probe *probe; + 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(sdi->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_set(sdi, i, probelist[i]); - g_free(probelist[i]); - } else { - sr_dev_probe_enable(sdi, i, FALSE); - } + 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; } @@ -1142,7 +1424,7 @@ static void load_input_file_format(void) char *fmtspec = NULL; if (opt_input_format) { - fmtargs = parse_generic_arg(opt_input_format); + fmtargs = parse_generic_arg(opt_input_format, TRUE); fmtspec = g_hash_table_lookup(fmtargs, "sigrok_key"); } @@ -1151,7 +1433,7 @@ static void load_input_file_format(void) /* The exact cause was already logged. */ return; } -; + if (fmtargs) g_hash_table_remove(fmtargs, "sigrok_key"); @@ -1169,17 +1451,17 @@ static void load_input_file_format(void) in->format = input_format; in->param = fmtargs; if (in->format->init) { - if (in->format->init(in) != SR_OK) { + if (in->format->init(in, opt_input_file) != SR_OK) { g_critical("Input format init failed."); exit(1); } } if (select_probes(in->sdi) > 0) - return; + return; sr_session_new(); - sr_session_datafeed_callback_add(datafeed_in); + sr_session_datafeed_callback_add(datafeed_in, NULL); if (sr_session_dev_add(in->sdi) != SR_OK) { g_critical("Failed to use device."); sr_session_destroy(); @@ -1187,10 +1469,7 @@ static void load_input_file_format(void) } input_format->loadfile(in, opt_input_file); - if (opt_output_file && default_output_format) { - if (sr_session_save(opt_output_file) != SR_OK) - g_critical("Failed to save session."); - } + sr_session_destroy(); if (fmtargs) @@ -1202,7 +1481,7 @@ static void load_input_file(void) if (sr_session_load(opt_input_file) == SR_OK) { /* sigrok session file */ - sr_session_datafeed_callback_add(datafeed_in); + sr_session_datafeed_callback_add(datafeed_in, NULL); sr_session_start(); sr_session_run(); sr_session_stop(); @@ -1215,124 +1494,155 @@ static void load_input_file(void) 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; - float tmp_float; - uint64_t tmp_u64; - struct sr_rational tmp_rat; + int ret; + double tmp_double; + uint64_t tmp_u64, p, q, low, high; gboolean tmp_bool; - gboolean found; - void *val; + GVariant *val, *rational[2], *range[2]; 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)) { - g_critical("Option '%s' needs a value.", (char *)key); - return SR_ERR; - } - found = TRUE; - val = NULL; - switch (sr_hwcap_options[i].type) { - case SR_T_UINT64: - ret = sr_parse_sizestring(value, &tmp_u64); - if (ret != SR_OK) - break; - 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; + 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_RATIONAL_PERIOD: - if ((ret = sr_parse_period(value, &tmp_rat)) != SR_OK) - break; - val = &tmp_rat; + val = g_variant_new_uint64(tmp_u64); + break; + case SR_T_CHAR: + val = g_variant_new_string(value); + break; + case SR_T_BOOL: + if (!value) + tmp_bool = TRUE; + else + tmp_bool = sr_parse_boolstring(value); + val = g_variant_new_boolean(tmp_bool); + break; + case SR_T_FLOAT: + tmp_double = strtof(value, NULL); + val = g_variant_new_double(tmp_double); + break; + case SR_T_RATIONAL_PERIOD: + if ((ret = sr_parse_period(value, &p, &q)) != SR_OK) break; - case SR_T_RATIONAL_VOLT: - if ((ret = sr_parse_voltage(value, &tmp_rat)) != SR_OK) - break; - val = &tmp_rat; + rational[0] = g_variant_new_uint64(p); + rational[1] = g_variant_new_uint64(q); + val = g_variant_new_tuple(rational, 2); + break; + case SR_T_RATIONAL_VOLT: + if ((ret = sr_parse_voltage(value, &p, &q)) != SR_OK) break; - default: + rational[0] = g_variant_new_uint64(p); + rational[1] = g_variant_new_uint64(q); + val = g_variant_new_tuple(rational, 2); + break; + case SR_T_UINT64_RANGE: + if (sscanf(value, "%"PRIu64"-%"PRIu64, &low, &high) != 2) { ret = SR_ERR; - } - if (val) - ret = sdi->driver->dev_config_set(sdi, - sr_hwcap_options[i].hwcap, val); - if (ret != SR_OK) { - g_critical("Failed to set device option '%s'.", (char *)key); - return ret; - } - else break; + } else { + range[0] = g_variant_new_uint64(low); + range[1] = g_variant_new_uint64(high); + val = g_variant_new_tuple(range, 2); + } + break; + default: + ret = SR_ERR; } - if (!found) { - g_critical("Unknown device option '%s'.", (char *) key); - return SR_ERR; + if (val) + ret = sr_config_set(sdi, srci->key, val); + if (ret != SR_OK) { + g_critical("Failed to set device option '%s'.", (char *)key); + return ret; } } return SR_OK; } +static void set_options(void) +{ + struct sr_dev_inst *sdi; + GSList *devices; + GHashTable *devargs; + + if (!opt_config) { + g_critical("No setting specified."); + return; + } + + if (!(devargs = parse_generic_arg(opt_config, FALSE))) + return; + + if (!(devices = device_scan())) { + g_critical("No devices found."); + return; + } + sdi = devices->data; + + if (sr_dev_open(sdi) != SR_OK) { + g_critical("Failed to open device."); + return; + } + + set_dev_options(sdi, devargs); + + sr_dev_close(sdi); + g_slist_free(devices); + g_hash_table_destroy(devargs); + +} + static int set_limit_time(const struct sr_dev_inst *sdi) { + GVariant *gvar; uint64_t time_msec; - uint64_t *samplerate; + uint64_t samplerate; - time_msec = sr_parse_timestring(opt_time); - if (time_msec == 0) { + if (!(time_msec = sr_parse_timestring(opt_time))) { g_critical("Invalid time '%s'", opt_time); - sr_session_destroy(); return SR_ERR; } - if (sr_driver_hwcap_exists(sdi->driver, SR_HWCAP_LIMIT_MSEC)) { - if (sdi->driver->dev_config_set(sdi, - SR_HWCAP_LIMIT_MSEC, &time_msec) != SR_OK) { + if (sr_dev_has_option(sdi, SR_CONF_LIMIT_MSEC)) { + gvar = g_variant_new_uint64(time_msec); + if (sr_config_set(sdi, SR_CONF_LIMIT_MSEC, gvar) != SR_OK) { g_critical("Failed to configure time limit."); - sr_session_destroy(); return SR_ERR; } - } - 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_HWCAP_SAMPLERATE)) { - sr_info_get(sdi->driver, SR_DI_CUR_SAMPLERATE, - (const void **)&samplerate, sdi); - limit_samples = (*samplerate) * time_msec / (uint64_t)1000; - } + } else if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) { + /* Convert to samples based on the samplerate. */ + sr_config_get(sdi->driver, SR_CONF_SAMPLERATE, &gvar, sdi); + samplerate = g_variant_get_uint64(gvar); + g_variant_unref(gvar); + 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 (sdi->driver->dev_config_set(sdi, - SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK) { + gvar = g_variant_new_uint64(limit_samples); + if (sr_config_set(sdi, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) { g_critical("Failed to configure time-based sample limit."); - sr_session_destroy(); return SR_ERR; } + } else { + g_critical("This device does not support time limits."); + return SR_ERR; } return SR_OK; @@ -1340,73 +1650,73 @@ static int set_limit_time(const struct sr_dev_inst *sdi) static void run_session(void) { - GSList *devices, *l; + GSList *devices; GHashTable *devargs; + GVariant *gvar; struct sr_dev_inst *sdi; int max_probes, i; - char **probelist; - - sr_session_new(); - sr_session_datafeed_callback_add(datafeed_in); + char **triggerlist; devices = device_scan(); - for (l = devices; l; l = l->next) { - sdi = l->data; - printf("found %s %s\n", sdi->vendor, sdi->model); - - devargs = NULL; - if (opt_dev) { - /* TODO: this applies the same options to every device */ - devargs = parse_generic_arg(opt_dev, FALSE); - if (devargs) { - if (set_dev_options(sdi, devargs) != SR_OK) { - return; - } - g_hash_table_destroy(devargs); - } - } + 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; - if (sr_session_dev_add(sdi) != SR_OK) { - g_critical("Failed to use device."); - sr_session_destroy(); - return; - } + sr_session_new(); + sr_session_datafeed_callback_add(datafeed_in, NULL); - if (select_probes(sdi) != SR_OK) - return; + if (sr_dev_open(sdi) != SR_OK) { + g_critical("Failed to open device."); + return; + } + + if (sr_session_dev_add(sdi) != SR_OK) { + g_critical("Failed to add device to session."); + sr_session_destroy(); + return; + } - if (opt_continuous) { - if (!sr_driver_hwcap_exists(sdi->driver, SR_HWCAP_CONTINUOUS)) { - g_critical("This device does not support continuous sampling."); - sr_session_destroy(); + if (opt_config) { + if ((devargs = parse_generic_arg(opt_config, FALSE))) { + if (set_dev_options(sdi, devargs) != SR_OK) return; - } + g_hash_table_destroy(devargs); } + } - if (opt_triggers) { - probelist = sr_parse_triggerstring(sdi, opt_triggers); - if (!probelist) { - sr_session_destroy(); - return; - } + if (select_probes(sdi) != SR_OK) { + g_critical("Failed to set probes."); + sr_session_destroy(); + return; + } - max_probes = g_slist_length(sdi->probes); - for (i = 0; i < max_probes; i++) { - if (probelist[i]) { - sr_dev_trigger_set(sdi, i, probelist[i]); - g_free(probelist[i]); - } + if (opt_triggers) { + if (!(triggerlist = sr_parse_triggerstring(sdi, opt_triggers))) { + sr_session_destroy(); + return; + } + max_probes = g_slist_length(sdi->probes); + for (i = 0; i < max_probes; i++) { + if (triggerlist[i]) { + sr_dev_trigger_set(sdi, i, triggerlist[i]); + g_free(triggerlist[i]); } - g_free(probelist); } + g_free(triggerlist); + } - if (sdi->driver->dev_config_set(sdi, SR_HWCAP_PROBECONFIG, - (char *)sdi->probes) != SR_OK) { - g_critical("Failed to configure probes."); + if (opt_continuous) { + if (!sr_dev_has_option(sdi, SR_CONF_CONTINUOUS)) { + g_critical("This device does not support continuous sampling."); sr_session_destroy(); return; } - } if (opt_time) { @@ -1417,9 +1727,13 @@ static void run_session(void) } if (opt_samples) { - if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK) - || (sdi->driver->dev_config_set(sdi, SR_HWCAP_LIMIT_SAMPLES, - &limit_samples) != SR_OK)) { + if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK)) { + g_critical("Invalid sample limit '%s'.", opt_samples); + sr_session_destroy(); + return; + } + gvar = g_variant_new_uint64(limit_samples); + if (sr_config_set(sdi, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) { g_critical("Failed to configure sample limit."); sr_session_destroy(); return; @@ -1427,10 +1741,14 @@ static void run_session(void) } if (opt_frames) { - if ((sr_parse_sizestring(opt_frames, &limit_frames) != SR_OK) - || (sdi->driver->dev_config_set(sdi, - SR_HWCAP_LIMIT_FRAMES, &limit_frames) != SR_OK)) { - printf("Failed to configure frame limit.\n"); + if ((sr_parse_sizestring(opt_frames, &limit_frames) != SR_OK)) { + g_critical("Invalid sample limit '%s'.", opt_samples); + sr_session_destroy(); + return; + } + gvar = g_variant_new_uint64(limit_frames); + if (sr_config_set(sdi, SR_CONF_LIMIT_FRAMES, gvar) != SR_OK) { + g_critical("Failed to configure frame limit."); sr_session_destroy(); return; } @@ -1450,10 +1768,7 @@ 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) - g_critical("Failed to save session."); - } + sr_session_datafeed_callback_remove_all(); sr_session_destroy(); g_slist_free(devices); @@ -1462,7 +1777,6 @@ static void run_session(void) static void logger(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer cb_data) { - /* Avoid compiler warnings. */ (void)log_domain; (void)cb_data; @@ -1475,72 +1789,99 @@ static void logger(const gchar *log_domain, GLogLevelFlags log_level, fprintf(stderr, "%s\n", message); fflush(stderr); } + + if (log_level & (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL)) + exit(1); + } int main(int argc, char **argv) { GOptionContext *context; GError *error; + int ret; + char *help; g_log_set_default_handler(logger, NULL); - error = NULL; context = g_option_context_new(NULL); g_option_context_add_main_entries(context, optargs, NULL); + ret = 1; + error = NULL; if (!g_option_context_parse(context, &argc, &argv, &error)) { g_critical("%s", error->message); - return 1; + goto done; } /* Set the loglevel (amount of messages to output) for libsigrok. */ if (sr_log_loglevel_set(opt_loglevel) != SR_OK) - return 1; + goto done; + + if (sr_init(&sr_ctx) != SR_OK) + goto done; +#ifdef HAVE_SRD /* Set the loglevel (amount of messages to output) for libsigrokdecode. */ if (srd_log_loglevel_set(opt_loglevel) != SRD_OK) - return 1; - - if (sr_init() != SR_OK) - return 1; + goto done; if (opt_pds) { if (srd_init(NULL) != SRD_OK) - return 1; + goto done; + if (srd_session_new(&srd_sess) != SRD_OK) { + g_critical("Failed to create new decode session."); + goto done; + } if (register_pds(NULL, opt_pds) != 0) - return 1; - if (srd_pd_output_callback_add(SRD_OUTPUT_ANN, + goto done; + if (srd_pd_output_callback_add(srd_sess, SRD_OUTPUT_ANN, show_pd_annotations, NULL) != SRD_OK) - return 1; + goto done; if (setup_pd_stack() != 0) - return 1; + goto done; if (setup_pd_annotations() != 0) - return 1; + goto done; } +#endif if (setup_output_format() != 0) - return 1; + goto done; if (opt_version) show_version(); - else if (opt_list_devs) + else if (opt_scan_devs) show_dev_list(); +#ifdef HAVE_SRD + else if (opt_pds && opt_show) + show_pd_detail(); +#endif else if (opt_show) show_dev_detail(); - else if (opt_pds) - show_pd_detail(); else if (opt_input_file) load_input_file(); + else if (opt_set) + set_options(); else if (opt_samples || opt_time || opt_frames || opt_continuous) run_session(); - else - printf("%s", g_option_context_get_help(context, TRUE, NULL)); + else { + help = g_option_context_get_help(context, TRUE, NULL); + printf("%s", help); + g_free(help); + } +#ifdef HAVE_SRD if (opt_pds) srd_exit(); +#endif + + ret = 0; + +done: + if (sr_ctx) + sr_exit(sr_ctx); g_option_context_free(context); - sr_exit(); - return 0; + return ret; }