static void prop_edited(GtkCellRendererText *cel, gchar *path, gchar *text,
GtkListStore *props)
{
(void)cel;
struct sr_dev *dev = g_object_get_data(G_OBJECT(props), "dev");
GtkTreeIter iter;
int type, cap;
guint64 tmp_u64;
int ret = SR_ERR;
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(props), &iter, path);
gtk_tree_model_get(GTK_TREE_MODEL(props), &iter,
DEV_PROP_HWCAP, &cap,
DEV_PROP_TYPE, &type, -1);
switch (type) {
case SR_T_UINT64:
if (sr_parse_sizestring(text, &tmp_u64) != SR_OK)
return;
ret = dev->driver->dev_config_set(dev->driver_index,
cap, &tmp_u64);
break;
case SR_T_CHAR:
ret = dev->driver->dev_config_set(dev->driver_index, cap, text);
break;
/* SR_T_BOOL will be handled by prop_toggled */
}
if (!ret)
gtk_list_store_set(props, &iter, DEV_PROP_TEXTVALUE, text, -1);
}
static int init(struct sr_input *in, const char *filename)
{
struct sr_probe *probe;
int num_probes, i;
char name[SR_MAX_PROBENAME_LEN + 1];
char *param;
struct context *ctx;
(void)filename;
if (!(ctx = g_try_malloc0(sizeof(*ctx)))) {
sr_err("Input format context malloc failed.");
return SR_ERR_MALLOC;
}
num_probes = DEFAULT_NUM_PROBES;
ctx->samplerate = 0;
if (in->param) {
param = g_hash_table_lookup(in->param, "numprobes");
if (param) {
num_probes = strtoul(param, NULL, 10);
if (num_probes < 1)
return SR_ERR;
}
param = g_hash_table_lookup(in->param, "samplerate");
if (param) {
if (sr_parse_sizestring(param, &ctx->samplerate) != SR_OK)
return SR_ERR;
}
}
/* Create a virtual device. */
in->sdi = sr_dev_inst_new(LOGIC, 0, SR_ST_ACTIVE, NULL, NULL, NULL);
in->internal = ctx;
for (i = 0; i < num_probes; i++) {
snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i);
/* TODO: Check return value. */
if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name)))
return SR_ERR;
in->sdi->probes = g_slist_append(in->sdi->probes, probe);
}
return SR_OK;
}
Glib::VariantBase ConfigKey::parse_string(string value) const
{
GVariant *variant;
uint64_t p, q;
switch (data_type()->id())
{
case SR_T_UINT64:
check(sr_parse_sizestring(value.c_str(), &p));
variant = g_variant_new_uint64(p);
break;
case SR_T_STRING:
variant = g_variant_new_string(value.c_str());
break;
case SR_T_BOOL:
variant = g_variant_new_boolean(sr_parse_boolstring(value.c_str()));
break;
case SR_T_FLOAT:
variant = g_variant_new_double(stod(value));
break;
case SR_T_RATIONAL_PERIOD:
check(sr_parse_period(value.c_str(), &p, &q));
variant = g_variant_new("(tt)", p, q);
break;
case SR_T_RATIONAL_VOLT:
check(sr_parse_voltage(value.c_str(), &p, &q));
variant = g_variant_new("(tt)", p, q);
break;
case SR_T_INT32:
variant = g_variant_new_int32(stoi(value));
break;
default:
throw Error(SR_ERR_BUG);
}
return Glib::VariantBase(variant, false);
}
static void capture_run(GtkAction *action, GObject *parent)
{
(void)action;
struct sr_dev *dev = g_object_get_data(G_OBJECT(parent), "dev");
GtkEntry *timesamples = g_object_get_data(parent, "timesamples");
GtkComboBox *timeunit = g_object_get_data(parent, "timeunit");
gint i = gtk_combo_box_get_active(timeunit);
guint64 time_msec = 0;
guint64 limit_samples = 0;
switch (i) {
case 0: /* Samples */
sr_parse_sizestring(gtk_entry_get_text(timesamples),
&limit_samples);
break;
case 1: /* Milliseconds */
time_msec = strtoull(gtk_entry_get_text(timesamples), NULL, 10);
break;
case 2: /* Seconds */
time_msec = strtoull(gtk_entry_get_text(timesamples), NULL, 10)
* 1000;
break;
}
if (time_msec) {
if (sr_driver_hwcap_exists(dev->driver, SR_HWCAP_LIMIT_MSEC)) {
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_MSEC,
&time_msec) != SR_OK) {
g_critical("Failed to configure time limit.");
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)) {
guint64 tmp_u64;
tmp_u64 = *((uint64_t *)dev->driver->dev_info_get(
dev->driver_index,
SR_DI_CUR_SAMPLERATE));
limit_samples = tmp_u64 * time_msec / (uint64_t) 1000;
}
if (limit_samples == 0) {
g_critical("Not enough time at this samplerate.");
return;
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES,
&limit_samples) != SR_OK) {
g_critical("Failed to configure time-based sample limit.");
return;
}
}
}
if (limit_samples) {
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES,
&limit_samples) != SR_OK) {
g_critical("Failed to configure sample limit.");
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 (sr_session_start() != SR_OK) {
g_critical("Failed to start session.");
return;
}
sr_session_run();
}
static int init(struct sr_input *in, const char *filename)
{
int res;
struct context *ctx;
const char *param;
GIOStatus status;
gsize i, term_pos;
char probe_name[SR_MAX_PROBENAME_LEN + 1];
struct sr_probe *probe;
char **columns;
gsize num_columns;
char *ptr;
if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
sr_err("Context malloc failed.");
return SR_ERR_MALLOC;
}
/* Create a virtual device. */
in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL);
in->internal = ctx;
/* Set default samplerate. */
ctx->samplerate = 0;
/*
* Enable auto-detection of the number of probes in multi column mode
* and enforce the specification of the number of probes in single
* column mode.
*/
ctx->num_probes = 0;
/* Set default delimiter. */
if (!(ctx->delimiter = g_string_new(","))) {
sr_err("Delimiter malloc failed.");
free_context(ctx);
return SR_ERR_MALLOC;
}
/*
* Set default comment prefix. Note that an empty comment prefix
* disables removing of comments.
*/
if (!(ctx->comment = g_string_new(""))) {
sr_err("Comment malloc failed.");
free_context(ctx);
return SR_ERR_MALLOC;
}
/* Enable multi column mode by default. */
ctx->multi_column_mode = TRUE;
/* Use first column as default single column number. */
ctx->single_column = 0;
/*
* In multi column mode start parsing sample data at the first column
* and in single column mode at the first bit.
*/
ctx->first_probe = 0;
/* Start at the beginning of the file. */
ctx->start_line = 1;
/* Disable the usage of the first line as header by default. */
ctx->header = FALSE;
/* Set default format for single column mode. */
ctx->format = FORMAT_BIN;
if (!(ctx->buffer = g_string_new(""))) {
sr_err("Line buffer malloc failed.");
free_context(ctx);
return SR_ERR_MALLOC;
}
if (in->param) {
if ((param = g_hash_table_lookup(in->param, "samplerate"))) {
res = sr_parse_sizestring(param, &ctx->samplerate);
if (res != SR_OK) {
sr_err("Invalid samplerate: %s.", param);
free_context(ctx);
return SR_ERR_ARG;
}
}
if ((param = g_hash_table_lookup(in->param, "numprobes")))
ctx->num_probes = g_ascii_strtoull(param, NULL, 10);
if ((param = g_hash_table_lookup(in->param, "delimiter"))) {
if (!strlen(param)) {
sr_err("Delimiter must be at least one character.");
free_context(ctx);
return SR_ERR_ARG;
}
if (!g_ascii_strcasecmp(param, "\\t"))
g_string_assign(ctx->delimiter, "\t");
else
g_string_assign(ctx->delimiter, param);
}
if ((param = g_hash_table_lookup(in->param, "comment")))
g_string_assign(ctx->comment, param);
if ((param = g_hash_table_lookup(in->param, "single-column"))) {
ctx->single_column = g_ascii_strtoull(param, &ptr, 10);
ctx->multi_column_mode = FALSE;
if (param == ptr) {
sr_err("Invalid single-colum number: %s.",
param);
free_context(ctx);
return SR_ERR_ARG;
}
}
if ((param = g_hash_table_lookup(in->param, "first-probe")))
ctx->first_probe = g_ascii_strtoull(param, NULL, 10);
if ((param = g_hash_table_lookup(in->param, "startline"))) {
ctx->start_line = g_ascii_strtoull(param, NULL, 10);
if (ctx->start_line < 1) {
sr_err("Invalid start line: %s.", param);
free_context(ctx);
return SR_ERR_ARG;
}
}
if ((param = g_hash_table_lookup(in->param, "header")))
ctx->header = sr_parse_boolstring(param);
if ((param = g_hash_table_lookup(in->param, "format"))) {
if (!g_ascii_strncasecmp(param, "bin", 3)) {
ctx->format = FORMAT_BIN;
} else if (!g_ascii_strncasecmp(param, "hex", 3)) {
ctx->format = FORMAT_HEX;
} else if (!g_ascii_strncasecmp(param, "oct", 3)) {
ctx->format = FORMAT_OCT;
} else {
sr_err("Invalid format: %s.", param);
free_context(ctx);
return SR_ERR;
}
}
}
if (ctx->multi_column_mode)
ctx->first_column = ctx->first_probe;
else
ctx->first_column = ctx->single_column;
if (!ctx->multi_column_mode && !ctx->num_probes) {
sr_err("Number of probes needs to be specified in single column mode.");
free_context(ctx);
return SR_ERR;
}
if (!(ctx->channel = g_io_channel_new_file(filename, "r", NULL))) {
sr_err("Input file '%s' could not be opened.", filename);
free_context(ctx);
return SR_ERR;
}
while (TRUE) {
ctx->line_number++;
status = g_io_channel_read_line_string(ctx->channel,
ctx->buffer, &term_pos, NULL);
if (status == G_IO_STATUS_EOF) {
sr_err("Input file is empty.");
free_context(ctx);
return SR_ERR;
}
if (status != G_IO_STATUS_NORMAL) {
sr_err("Error while reading line %zu.",
ctx->line_number);
free_context(ctx);
return SR_ERR;
}
if (ctx->start_line > ctx->line_number) {
sr_spew("Line %zu skipped.", ctx->line_number);
continue;
}
/* Remove line termination character(s). */
g_string_truncate(ctx->buffer, term_pos);
if (!ctx->buffer->len) {
sr_spew("Blank line %zu skipped.", ctx->line_number);
continue;
}
/* Remove trailing comment. */
strip_comment(ctx->buffer, ctx->comment);
if (ctx->buffer->len)
break;
sr_spew("Comment-only line %zu skipped.", ctx->line_number);
}
/*
* In order to determine the number of columns parse the current line
* without limiting the number of columns.
*/
if (!(columns = parse_line(ctx, -1))) {
sr_err("Error while parsing line %zu.", ctx->line_number);
free_context(ctx);
return SR_ERR;
}
num_columns = g_strv_length(columns);
/* Ensure that the first column is not out of bounds. */
if (!num_columns) {
sr_err("Column %zu in line %zu is out of bounds.",
ctx->first_column, ctx->line_number);
g_strfreev(columns);
free_context(ctx);
return SR_ERR;
}
if (ctx->multi_column_mode) {
/*
* Detect the number of probes in multi column mode
* automatically if not specified.
*/
if (!ctx->num_probes) {
ctx->num_probes = num_columns;
sr_info("Number of auto-detected probes: %zu.",
ctx->num_probes);
}
/*
* Ensure that the number of probes does not exceed the number
* of columns in multi column mode.
*/
if (num_columns < ctx->num_probes) {
sr_err("Not enough columns for desired number of probes in line %zu.",
ctx->line_number);
g_strfreev(columns);
free_context(ctx);
return SR_ERR;
}
}
for (i = 0; i < ctx->num_probes; i++) {
if (ctx->header && ctx->multi_column_mode && strlen(columns[i]))
snprintf(probe_name, sizeof(probe_name), "%s",
columns[i]);
else
snprintf(probe_name, sizeof(probe_name), "%zu", i);
probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name);
if (!probe) {
sr_err("Probe creation failed.");
free_context(ctx);
g_strfreev(columns);
return SR_ERR;
}
in->sdi->probes = g_slist_append(in->sdi->probes, probe);
}
g_strfreev(columns);
/*
* Calculate the minimum buffer size to store the sample data of the
* probes.
*/
ctx->sample_buffer_size = (ctx->num_probes + 7) >> 3;
if (!(ctx->sample_buffer = g_try_malloc(ctx->sample_buffer_size))) {
sr_err("Sample buffer malloc failed.");
free_context(ctx);
return SR_ERR_MALLOC;
}
return SR_OK;
}
void run_session(void)
{
GSList *devices;
GHashTable *devargs;
GVariant *gvar;
struct sr_dev_inst *sdi;
uint64_t min_samples, max_samples;
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, NULL);
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_config) {
if ((devargs = parse_generic_arg(opt_config, FALSE))) {
if (set_dev_options(sdi, devargs) != SR_OK)
return;
g_hash_table_destroy(devargs);
}
}
if (select_channels(sdi) != SR_OK) {
g_critical("Failed to set channels.");
sr_session_destroy();
return;
}
if (opt_triggers) {
if (!parse_triggerstring(sdi, opt_triggers)) {
sr_session_destroy();
return;
}
}
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) {
if (set_limit_time(sdi) != SR_OK) {
sr_session_destroy();
return;
}
}
if (opt_samples) {
if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK)) {
g_critical("Invalid sample limit '%s'.", opt_samples);
sr_session_destroy();
return;
}
if (sr_config_list(sdi->driver, sdi, NULL,
SR_CONF_LIMIT_SAMPLES, &gvar) == SR_OK) {
/* The device has no compression, or compression is turned
* off, and publishes its sample memory size. */
g_variant_get(gvar, "(tt)", &min_samples, &max_samples);
g_variant_unref(gvar);
if (limit_samples < min_samples) {
g_critical("The device stores at least %"PRIu64
" samples with the current settings.", min_samples);
}
if (limit_samples > max_samples) {
g_critical("The device can store only %"PRIu64
" samples with the current settings.", max_samples);
}
}
gvar = g_variant_new_uint64(limit_samples);
if (sr_config_set(sdi, NULL, SR_CONF_LIMIT_SAMPLES, gvar) != SR_OK) {
g_critical("Failed to configure sample limit.");
sr_session_destroy();
return;
}
}
if (opt_frames) {
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, NULL, SR_CONF_LIMIT_FRAMES, gvar) != SR_OK) {
g_critical("Failed to configure frame limit.");
sr_session_destroy();
return;
}
}
if (sr_session_start() != SR_OK) {
g_critical("Failed to start session.");
sr_session_destroy();
return;
}
if (opt_continuous)
add_anykey();
sr_session_run();
if (opt_continuous)
clear_anykey();
sr_session_datafeed_callback_remove_all();
sr_session_destroy();
g_slist_free(devices);
}
int opt_to_gvar(char *key, char *value, struct sr_config *src)
{
const struct sr_config_info *srci;
double tmp_double, dlow, dhigh;
uint64_t tmp_u64, p, q, low, high;
GVariant *rational[2], *range[2];
gboolean tmp_bool;
int ret;
if (!(srci = sr_config_info_name_get(key))) {
g_critical("Unknown device option '%s'.", (char *) key);
return -1;
}
src->key = srci->key;
if ((value == NULL) &&
(srci->datatype != SR_T_BOOL)) {
g_critical("Option '%s' needs a value.", (char *)key);
return -1;
}
ret = 0;
switch (srci->datatype) {
case SR_T_UINT64:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != 0)
break;
src->data = g_variant_new_uint64(tmp_u64);
break;
case SR_T_INT32:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != 0)
break;
src->data = g_variant_new_int32(tmp_u64);
break;
case SR_T_STRING:
src->data = g_variant_new_string(value);
break;
case SR_T_BOOL:
if (!value)
tmp_bool = TRUE;
else
tmp_bool = sr_parse_boolstring(value);
src->data = g_variant_new_boolean(tmp_bool);
break;
case SR_T_FLOAT:
tmp_double = strtof(value, NULL);
src->data = g_variant_new_double(tmp_double);
break;
case SR_T_RATIONAL_PERIOD:
if ((ret = sr_parse_period(value, &p, &q)) != SR_OK)
break;
rational[0] = g_variant_new_uint64(p);
rational[1] = g_variant_new_uint64(q);
src->data = g_variant_new_tuple(rational, 2);
break;
case SR_T_RATIONAL_VOLT:
if ((ret = sr_parse_voltage(value, &p, &q)) != SR_OK)
break;
rational[0] = g_variant_new_uint64(p);
rational[1] = g_variant_new_uint64(q);
src->data = g_variant_new_tuple(rational, 2);
break;
case SR_T_UINT64_RANGE:
if (sscanf(value, "%"PRIu64"-%"PRIu64, &low, &high) != 2) {
ret = -1;
break;
} else {
range[0] = g_variant_new_uint64(low);
range[1] = g_variant_new_uint64(high);
src->data = g_variant_new_tuple(range, 2);
}
break;
case SR_T_DOUBLE_RANGE:
if (sscanf(value, "%lf-%lf", &dlow, &dhigh) != 2) {
ret = -1;
break;
} else {
range[0] = g_variant_new_double(dlow);
range[1] = g_variant_new_double(dhigh);
src->data = g_variant_new_tuple(range, 2);
}
break;
default:
ret = -1;
}
return ret;
}
/**
* Load the session from the specified filename.
*
* @param filename The name of the session file to load. Must not be NULL.
*
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments,
* SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon
* other errors.
*/
SR_API int sr_session_load(const char *filename)
{
GKeyFile *kf;
GPtrArray *capturefiles;
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *probe;
int ret, devcnt, i, j, k;
uint16_t probenum;
uint64_t tmp_u64, total_probes, enabled_probes;
uint16_t p;
char **sections, **keys, *metafile, *val, s[11];
char probename[SR_MAX_PROBENAME_LEN + 1];
int mode = LOGIC;
int channel_type = SR_CHANNEL_LOGIC;
double tmp_double;
if (!filename) {
sr_err("%s: filename was NULL", __func__);
return SR_ERR_ARG;
}
if (!(archive = zip_open(filename, 0, &ret))) {
sr_dbg("Failed to open session file: zip error %d", ret);
return SR_ERR;
}
/* read "metadata" */
if (zip_stat(archive, "header", 0, &zs) == -1) {
sr_dbg("Not a valid DSView data file.");
return SR_ERR;
}
if (!(metafile = g_try_malloc(zs.size))) {
sr_err("%s: metafile malloc failed", __func__);
return SR_ERR_MALLOC;
}
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
sr_dbg("Failed to parse metadata.");
return SR_ERR;
}
sr_session_new();
devcnt = 0;
capturefiles = g_ptr_array_new_with_free_func(g_free);
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i]; i++) {
if (!strcmp(sections[i], "version"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "header", 6)) {
/* device section */
sdi = NULL;
enabled_probes = total_probes = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "device mode")) {
mode = strtoull(val, NULL, 10);
} else if (!strcmp(keys[j], "capturefile")) {
sdi = sr_dev_inst_new(mode, devcnt, SR_ST_ACTIVE, NULL, NULL, NULL);
sdi->driver = &session_driver;
if (devcnt == 0)
/* first device, init the driver */
sdi->driver->init(NULL);
sr_dev_open(sdi);
sr_session_dev_add(sdi);
sdi->driver->config_set(SR_CONF_SESSIONFILE,
g_variant_new_bytestring(filename), sdi, NULL, NULL);
sdi->driver->config_set(SR_CONF_CAPTUREFILE,
g_variant_new_bytestring(val), sdi, NULL, NULL);
g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) {
sr_parse_sizestring(val, &tmp_u64);
sdi->driver->config_set(SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "unitsize")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "total samples")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_LIMIT_SAMPLES,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "hDiv")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_TIMEBASE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "total probes")) {
total_probes = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES,
g_variant_new_uint64(total_probes), sdi, NULL, NULL);
channel_type = (mode == DSO) ? SR_CHANNEL_DSO :
(mode == ANALOG) ? SR_CHANNEL_ANALOG : SR_CHANNEL_LOGIC;
for (p = 0; p < total_probes; p++) {
snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
if (!(probe = sr_channel_new(p, channel_type, FALSE,
probename)))
return SR_ERR;
sdi->channels = g_slist_append(sdi->channels, probe);
}
} else if (!strncmp(keys[j], "probe", 5)) {
if (!sdi)
continue;
enabled_probes++;
tmp_u64 = strtoul(keys[j]+5, NULL, 10);
/* sr_session_save() */
sr_dev_probe_name_set(sdi, tmp_u64, val);
sr_dev_probe_enable(sdi, tmp_u64, TRUE);
} else if (!strncmp(keys[j], "trigger", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
sr_dev_trigger_set(sdi, probenum, val);
} else if (!strncmp(keys[j], "enable", 6)) {
probenum = strtoul(keys[j]+6, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_EN_CH,
g_variant_new_boolean(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "coupling", 8)) {
probenum = strtoul(keys[j]+8, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_COUPLING,
g_variant_new_byte(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vDiv", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_VDIV,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vFactor", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_FACTOR,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vPos", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_double = strtod(val, NULL);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_VPOS,
g_variant_new_double(tmp_double), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "period", 6)) {
probenum = strtoul(keys[j]+6, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_PERIOD,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "pcnt", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_PCNT,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "max", 3)) {
probenum = strtoul(keys[j]+3, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_MAX,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "min", 3)) {
probenum = strtoul(keys[j]+3, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_MIN,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
}
}
g_strfreev(keys);
}
devcnt++;
}
g_strfreev(sections);
g_key_file_free(kf);
return SR_OK;
}
/**
* Load the session from the specified filename.
*
* @param ctx The context in which to load the session.
* @param filename The name of the session file to load.
* @param session The session to load the file into.
*
* @retval SR_OK Success
* @retval SR_ERR_MALLOC Memory allocation error
* @retval SR_ERR_DATA Malformed session file
* @retval SR_ERR This is not a session file
*/
SR_API int sr_session_load(struct sr_context *ctx, const char *filename,
struct sr_session **session)
{
GKeyFile *kf;
GError *error;
struct zip *archive;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *ch;
int ret, i, j;
uint64_t tmp_u64;
int total_channels, total_analog, k;
GSList *l;
int unitsize;
char **sections, **keys, *val;
char channelname[SR_MAX_CHANNELNAME_LEN + 1];
gboolean file_has_logic;
if ((ret = sr_sessionfile_check(filename)) != SR_OK)
return ret;
if (!(archive = zip_open(filename, 0, NULL)))
return SR_ERR;
if (zip_stat(archive, "metadata", 0, &zs) < 0) {
zip_discard(archive);
return SR_ERR;
}
kf = sr_sessionfile_read_metadata(archive, &zs);
zip_discard(archive);
if (!kf)
return SR_ERR_DATA;
if ((ret = sr_session_new(ctx, session)) != SR_OK) {
g_key_file_free(kf);
return ret;
}
total_channels = 0;
error = NULL;
ret = SR_OK;
file_has_logic = FALSE;
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i] && ret == SR_OK; i++) {
if (!strcmp(sections[i], "global"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
sdi = NULL;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
/* File contains analog data if there are analog channels. */
total_analog = g_key_file_get_integer(kf, sections[i],
"total analog", &error);
if (total_analog > 0 && !error)
sdi = sr_session_prepare_sdi(filename, session);
g_clear_error(&error);
/* File contains logic data if a capturefile is set. */
val = g_key_file_get_string(kf, sections[i],
"capturefile", &error);
if (val && !error) {
if (!sdi)
sdi = sr_session_prepare_sdi(filename, session);
sr_config_set(sdi, NULL, SR_CONF_CAPTUREFILE,
g_variant_new_string(val));
g_free(val);
file_has_logic = TRUE;
}
g_clear_error(&error);
for (j = 0; keys[j]; j++) {
if (!strcmp(keys[j], "samplerate")) {
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!sdi || !val || sr_parse_sizestring(val,
&tmp_u64) != SR_OK) {
g_free(val);
ret = SR_ERR_DATA;
break;
}
g_free(val);
sr_config_set(sdi, NULL, SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64));
} else if (!strcmp(keys[j], "unitsize") && file_has_logic) {
unitsize = g_key_file_get_integer(kf, sections[i],
keys[j], &error);
if (!sdi || unitsize <= 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(unitsize));
} else if (!strcmp(keys[j], "total probes")) {
total_channels = g_key_file_get_integer(kf,
sections[i], keys[j], &error);
if (!sdi || total_channels < 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_NUM_LOGIC_CHANNELS,
g_variant_new_int32(total_channels));
for (k = 0; k < total_channels; k++) {
g_snprintf(channelname, sizeof(channelname),
"%d", k);
sr_channel_new(sdi, k, SR_CHANNEL_LOGIC,
FALSE, channelname);
}
} else if (!strcmp(keys[j], "total analog")) {
total_analog = g_key_file_get_integer(kf,
sections[i], keys[j], &error);
if (!sdi || total_analog < 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_NUM_ANALOG_CHANNELS,
g_variant_new_int32(total_analog));
for (k = total_channels; k < (total_channels + total_analog); k++) {
g_snprintf(channelname, sizeof(channelname),
"%d", k);
sr_channel_new(sdi, k, SR_CHANNEL_ANALOG,
FALSE, channelname);
}
} else if (!strncmp(keys[j], "probe", 5)) {
tmp_u64 = g_ascii_strtoull(keys[j] + 5, NULL, 10);
if (!sdi || tmp_u64 == 0 || tmp_u64 > G_MAXINT) {
ret = SR_ERR_DATA;
break;
}
ch = g_slist_nth_data(sdi->channels, tmp_u64 - 1);
if (!ch) {
ret = SR_ERR_DATA;
break;
}
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!val) {
ret = SR_ERR_DATA;
break;
}
/* sr_session_save() */
sr_dev_channel_name_set(ch, val);
g_free(val);
sr_dev_channel_enable(ch, TRUE);
} else if (!strncmp(keys[j], "analog", 6)) {
tmp_u64 = g_ascii_strtoull(keys[j]+6, NULL, 10);
if (!sdi || tmp_u64 == 0 || tmp_u64 > G_MAXINT) {
ret = SR_ERR_DATA;
break;
}
ch = NULL;
for (l = sdi->channels; l; l = l->next) {
ch = l->data;
if ((guint64)ch->index == tmp_u64 - 1)
break;
else
ch = NULL;
}
if (!ch) {
ret = SR_ERR_DATA;
break;
}
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!val) {
ret = SR_ERR_DATA;
break;
}
/* sr_session_save() */
sr_dev_channel_name_set(ch, val);
g_free(val);
sr_dev_channel_enable(ch, TRUE);
}
}
g_strfreev(keys);
}
}
g_strfreev(sections);
g_key_file_free(kf);
if (error) {
sr_err("Failed to parse metadata: %s", error->message);
g_error_free(error);
}
return ret;
}
/**
* Load the session from the specified filename.
*
* @param ctx The context in which to load the session.
* @param filename The name of the session file to load.
* @param session The session to load the file into.
*
* @retval SR_OK Success
* @retval SR_ERR_MALLOC Memory allocation error
* @retval SR_ERR_DATA Malformed session file
* @retval SR_ERR This is not a session file
*/
SR_API int sr_session_load(struct sr_context *ctx, const char *filename,
struct sr_session **session)
{
GKeyFile *kf;
GPtrArray *capturefiles;
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *ch;
int ret, i, j;
uint64_t tmp_u64, total_channels, p;
char **sections, **keys, *metafile, *val;
char channelname[SR_MAX_CHANNELNAME_LEN + 1];
if ((ret = sr_sessionfile_check(filename)) != SR_OK)
return ret;
if (!(archive = zip_open(filename, 0, &ret)))
return SR_ERR;
if (zip_stat(archive, "metadata", 0, &zs) == -1)
return SR_ERR;
if (!(metafile = g_try_malloc(zs.size))) {
sr_err("%s: metafile malloc failed", __func__);
return SR_ERR_MALLOC;
}
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
sr_dbg("Failed to parse metadata.");
return SR_ERR;
}
if ((ret = sr_session_new(ctx, session)) != SR_OK)
return ret;
ret = SR_OK;
capturefiles = g_ptr_array_new_with_free_func(g_free);
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i] && ret == SR_OK; i++) {
if (!strcmp(sections[i], "global"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
sdi = NULL;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "capturefile")) {
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->driver = &session_driver;
sdi->status = SR_ST_ACTIVE;
if (!session_driver_initialized) {
/* first device, init the driver */
session_driver_initialized = 1;
sdi->driver->init(sdi->driver, NULL);
}
sr_dev_open(sdi);
sr_session_dev_add(*session, sdi);
(*session)->owned_devs = g_slist_append(
(*session)->owned_devs, sdi);
sdi->driver->config_set(SR_CONF_SESSIONFILE,
g_variant_new_string(filename), sdi, NULL);
sdi->driver->config_set(SR_CONF_CAPTUREFILE,
g_variant_new_string(val), sdi, NULL);
g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) {
if (!sdi) {
ret = SR_ERR_DATA;
break;
}
sr_parse_sizestring(val, &tmp_u64);
sdi->driver->config_set(SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64), sdi, NULL);
} else if (!strcmp(keys[j], "unitsize")) {
if (!sdi) {
ret = SR_ERR_DATA;
break;
}
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(tmp_u64), sdi, NULL);
} else if (!strcmp(keys[j], "total probes")) {
if (!sdi) {
ret = SR_ERR_DATA;
break;
}
total_channels = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_NUM_LOGIC_CHANNELS,
g_variant_new_uint64(total_channels), sdi, NULL);
for (p = 0; p < total_channels; p++) {
snprintf(channelname, SR_MAX_CHANNELNAME_LEN, "%" PRIu64, p);
sr_channel_new(sdi, p, SR_CHANNEL_LOGIC, FALSE,
channelname);
}
} else if (!strncmp(keys[j], "probe", 5)) {
if (!sdi) {
ret = SR_ERR_DATA;
break;
}
tmp_u64 = strtoul(keys[j]+5, NULL, 10) - 1;
ch = g_slist_nth_data(sdi->channels, tmp_u64);
/* sr_session_save() */
sr_dev_channel_name_set(ch, val);
sr_dev_channel_enable(ch, TRUE);
}
}
g_strfreev(keys);
}
}
g_strfreev(sections);
g_key_file_free(kf);
return ret;
}
int sr_session_load(const char *filename)
{
GKeyFile *kf;
GPtrArray *capturefiles;
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
struct sr_session *session;
struct sr_device *device;
struct sr_probe *probe;
int ret, err, probenum, devcnt, i, j;
uint64_t tmp_u64, total_probes, enabled_probes, p;
char **sections, **keys, *metafile, *val, c;
if (!(archive = zip_open(filename, 0, &err))) {
sr_dbg("Failed to open session file: zip error %d", err);
return SR_ERR;
}
/* check "version" */
if (!(zf = zip_fopen(archive, "version", 0))) {
sr_dbg("Not a sigrok session file.");
return SR_ERR;
}
ret = zip_fread(zf, &c, 1);
if (ret != 1 || c != '1') {
sr_dbg("Not a valid sigrok session file.");
return SR_ERR;
}
zip_fclose(zf);
/* read "metadata" */
if (zip_stat(archive, "metadata", 0, &zs) == -1) {
sr_dbg("Not a valid sigrok session file.");
return SR_ERR;
}
if (!(metafile = g_try_malloc(zs.size))) {
sr_err("session file: %s: metafile malloc failed", __func__);
return SR_ERR_MALLOC;
}
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
sr_dbg("Failed to parse metadata.");
return SR_ERR;
}
session = sr_session_new();
devcnt = 0;
capturefiles = g_ptr_array_new_with_free_func(g_free);
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i]; i++) {
if (!strcmp(sections[i], "global"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
device = NULL;
enabled_probes = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "capturefile")) {
device = sr_device_new(&session_driver, devcnt, 0);
if (devcnt == 0)
/* first device, init the plugin */
device->plugin->init((char *)filename);
sr_session_device_add(device);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTUREFILE, val);
g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) {
tmp_u64 = sr_parse_sizestring(val);
device->plugin->set_configuration(devcnt, SR_HWCAP_SAMPLERATE, &tmp_u64);
} else if (!strcmp(keys[j], "unitsize")) {
tmp_u64 = strtoull(val, NULL, 10);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTURE_UNITSIZE, &tmp_u64);
} else if (!strcmp(keys[j], "total probes")) {
total_probes = strtoull(val, NULL, 10);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTURE_NUM_PROBES, &total_probes);
for (p = 1; p <= total_probes; p++)
sr_device_probe_add(device, NULL);
} else if (!strncmp(keys[j], "probe", 5)) {
if (!device)
continue;
enabled_probes++;
tmp_u64 = strtoul(keys[j]+5, NULL, 10);
sr_device_probe_name(device, tmp_u64, val);
} else if (!strncmp(keys[j], "trigger", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
sr_device_trigger_set(device, probenum, val);
}
}
g_strfreev(keys);
for (p = enabled_probes; p < total_probes; p++) {
probe = g_slist_nth_data(device->probes, p);
probe->enabled = FALSE;
}
}
}
g_strfreev(sections);
g_key_file_free(kf);
return SR_OK;
}
/**
* Load the session from the specified filename.
*
* @param ctx The context in which to load the session.
* @param filename The name of the session file to load.
* @param session The session to load the file into.
*
* @retval SR_OK Success
* @retval SR_ERR_MALLOC Memory allocation error
* @retval SR_ERR_DATA Malformed session file
* @retval SR_ERR This is not a session file
*/
SR_API int sr_session_load(struct sr_context *ctx, const char *filename,
struct sr_session **session)
{
GKeyFile *kf;
GError *error;
struct zip *archive;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *ch;
int ret, i, j;
uint64_t tmp_u64;
int total_channels, k;
int unitsize;
char **sections, **keys, *val;
char channelname[SR_MAX_CHANNELNAME_LEN + 1];
if ((ret = sr_sessionfile_check(filename)) != SR_OK)
return ret;
if (!(archive = zip_open(filename, 0, NULL)))
return SR_ERR;
if (zip_stat(archive, "metadata", 0, &zs) < 0) {
zip_discard(archive);
return SR_ERR;
}
kf = sr_sessionfile_read_metadata(archive, &zs);
zip_discard(archive);
if (!kf)
return SR_ERR_DATA;
if ((ret = sr_session_new(ctx, session)) != SR_OK) {
g_key_file_free(kf);
return ret;
}
error = NULL;
ret = SR_OK;
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i] && ret == SR_OK; i++) {
if (!strcmp(sections[i], "global"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "device ", 7)) {
/* device section */
sdi = NULL;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
if (!strcmp(keys[j], "capturefile")) {
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!val) {
ret = SR_ERR_DATA;
break;
}
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->driver = &session_driver;
sdi->status = SR_ST_ACTIVE;
if (!session_driver_initialized) {
/* first device, init the driver */
session_driver_initialized = 1;
sdi->driver->init(sdi->driver, NULL);
}
sr_dev_open(sdi);
sr_session_dev_add(*session, sdi);
(*session)->owned_devs = g_slist_append(
(*session)->owned_devs, sdi);
sr_config_set(sdi, NULL, SR_CONF_SESSIONFILE,
g_variant_new_string(filename));
sr_config_set(sdi, NULL, SR_CONF_CAPTUREFILE,
g_variant_new_string(val));
g_free(val);
} else if (!strcmp(keys[j], "samplerate")) {
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!sdi || !val || sr_parse_sizestring(val,
&tmp_u64) != SR_OK) {
g_free(val);
ret = SR_ERR_DATA;
break;
}
g_free(val);
sr_config_set(sdi, NULL, SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64));
} else if (!strcmp(keys[j], "unitsize")) {
unitsize = g_key_file_get_integer(kf, sections[i],
keys[j], &error);
if (!sdi || unitsize <= 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(unitsize));
} else if (!strcmp(keys[j], "total probes")) {
total_channels = g_key_file_get_integer(kf,
sections[i], keys[j], &error);
if (!sdi || total_channels < 0 || error) {
ret = SR_ERR_DATA;
break;
}
sr_config_set(sdi, NULL, SR_CONF_NUM_LOGIC_CHANNELS,
g_variant_new_int32(total_channels));
for (k = 0; k < total_channels; k++) {
g_snprintf(channelname, sizeof channelname,
"%d", k);
sr_channel_new(sdi, k, SR_CHANNEL_LOGIC,
FALSE, channelname);
}
} else if (!strncmp(keys[j], "probe", 5)) {
tmp_u64 = g_ascii_strtoull(keys[j]+5, NULL, 10);
if (!sdi || tmp_u64 == 0 || tmp_u64 > G_MAXINT) {
ret = SR_ERR_DATA;
break;
}
ch = g_slist_nth_data(sdi->channels, tmp_u64 - 1);
if (!ch) {
ret = SR_ERR_DATA;
break;
}
val = g_key_file_get_string(kf, sections[i],
keys[j], &error);
if (!val) {
ret = SR_ERR_DATA;
break;
}
/* sr_session_save() */
sr_dev_channel_name_set(ch, val);
g_free(val);
sr_dev_channel_enable(ch, TRUE);
}
}
g_strfreev(keys);
}
}
g_strfreev(sections);
g_key_file_free(kf);
if (error) {
sr_err("Failed to parse metadata: %s", error->message);
g_error_free(error);
}
return ret;
}
static void run_session(void)
{
struct sr_dev *dev;
GHashTable *devargs;
int num_devs, max_probes, i;
uint64_t time_msec;
char **probelist, *devspec;
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_critical("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) {
g_critical("No devices found.");
return;
} else {
g_critical("%d devices found, please select one.", num_devs);
return;
}
}
sr_session_new();
sr_session_datafeed_callback_add(datafeed_in);
if (sr_session_dev_add(dev) != 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;
}
g_hash_table_destroy(devargs);
}
if (select_probes(dev) != SR_OK)
return;
if (opt_continuous) {
if (!sr_driver_hwcap_exists(dev->driver, SR_HWCAP_CONTINUOUS)) {
g_critical("This device does not support continuous sampling.");
sr_session_destroy();
return;
}
}
if (opt_triggers) {
probelist = sr_parse_triggerstring(dev, opt_triggers);
if (!probelist) {
sr_session_destroy();
return;
}
max_probes = g_slist_length(dev->probes);
for (i = 0; i < max_probes; i++) {
if (probelist[i]) {
sr_dev_trigger_set(dev, i + 1, probelist[i]);
g_free(probelist[i]);
}
}
g_free(probelist);
}
if (opt_time) {
time_msec = sr_parse_timestring(opt_time);
if (time_msec == 0) {
g_critical("Invalid time '%s'", opt_time);
sr_session_destroy();
return;
}
if (sr_driver_hwcap_exists(dev->driver, SR_HWCAP_LIMIT_MSEC)) {
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_MSEC, &time_msec) != SR_OK) {
g_critical("Failed to configure time limit.");
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) {
g_critical("Not enough time at this samplerate.");
sr_session_destroy();
return;
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK) {
g_critical("Failed to configure time-based sample limit.");
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)) {
g_critical("Failed to configure sample limit.");
sr_session_destroy();
return;
}
}
if (opt_frames) {
if ((sr_parse_sizestring(opt_frames, &limit_frames) != SR_OK)
|| (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_FRAMES, &limit_frames) != SR_OK)) {
printf("Failed to configure frame limit.\n");
sr_session_destroy();
return;
}
}
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_PROBECONFIG, (char *)dev->probes) != SR_OK) {
g_critical("Failed to configure probes.");
sr_session_destroy();
return;
}
if (sr_session_start() != SR_OK) {
g_critical("Failed to start session.");
sr_session_destroy();
return;
}
if (opt_continuous)
add_anykey();
sr_session_run();
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_destroy();
}
static int set_dev_options(struct sr_dev *dev, GHashTable *args)
{
GHashTableIter iter;
gpointer key, value;
int ret, i;
float tmp_float;
uint64_t tmp_u64;
struct sr_rational tmp_rat;
gboolean tmp_bool;
gboolean found;
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;
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);
break;
case SR_T_CHAR:
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, value);
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));
break;
case SR_T_FLOAT:
tmp_float = strtof(value, NULL);
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, &tmp_float);
break;
case SR_T_RATIONAL_PERIOD:
if ((ret = sr_parse_period(value, &tmp_rat)) != SR_OK)
break;
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, &tmp_rat);
break;
case SR_T_RATIONAL_VOLT:
if ((ret = sr_parse_voltage(value, &tmp_rat)) != SR_OK)
break;
ret = dev->driver->dev_config_set(dev->driver_index,
sr_hwcap_options[i].hwcap, &tmp_rat);
break;
default:
ret = SR_ERR;
}
if (ret != SR_OK) {
g_critical("Failed to set device option '%s'.", (char *)key);
return ret;
}
else
break;
}
if (!found) {
g_critical("Unknown device option '%s'.", (char *) key);
return SR_ERR;
}
}
return SR_OK;
}
