BLAHAJ
/
libsigrok
10
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Adjust to GVariant-based sr_config_* functions

This commit is contained in:
Bert Vermeulen 2013-03-25 20:21:10 +01:00
parent bc1c2f001a
commit 003595ac37
4 changed files with 49 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
device.c
View File

@ -192,22 +192,28 @@ SR_API int sr_dev_trigger_set(const struct sr_dev_inst *sdi, int probenum,
*/ */
SR_API gboolean sr_dev_has_option(const struct sr_dev_inst *sdi, int key) SR_API gboolean sr_dev_has_option(const struct sr_dev_inst *sdi, int key)
{ {
GVariant *gvar;
const int *devopts; const int *devopts;
int i; gsize num_opts, i;
int ret;
if (!sdi || !sdi->driver) if (!sdi || !sdi->driver || !sdi->driver->config_list)
return FALSE; return FALSE;
if (sdi->driver->config_list(SR_CONF_DEVICE_OPTIONS, if (sdi->driver->config_list(SR_CONF_DEVICE_OPTIONS, &gvar, NULL) != SR_OK)
(const void **)&devopts, NULL) != SR_OK)
return FALSE; return FALSE;
for (i = 0; devopts[i]; i++) { ret = FALSE;
if (devopts[i] == key) devopts = g_variant_get_fixed_array(gvar, &num_opts, sizeof(int32_t));
return TRUE; for (i = 0; i < num_opts; i++) {
if (devopts[i] == key) {
ret = TRUE;
break;
}
} }
g_variant_unref(gvar);
return FALSE; return ret;
} }
/** @private */ /** @private */

25
session_driver.c
View File

@ -148,7 +148,7 @@ static int hw_dev_open(struct sr_dev_inst *sdi)
return SR_OK; return SR_OK;
} }
static int config_get(int id, const void **data, const struct sr_dev_inst *sdi) static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
{ {
struct session_vdev *vdev; struct session_vdev *vdev;
@ -156,7 +156,7 @@ static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
case SR_CONF_SAMPLERATE: case SR_CONF_SAMPLERATE:
if (sdi) { if (sdi) {
vdev = sdi->priv; vdev = sdi->priv;
*data = &vdev->samplerate; *data = g_variant_new_uint64(vdev->samplerate);
} else } else
return SR_ERR; return SR_ERR;
break; break;
@ -167,34 +167,30 @@ static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
return SR_OK; return SR_OK;
} }
static int config_set(int id, const void *value, const struct sr_dev_inst *sdi) static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
{ {
struct session_vdev *vdev; struct session_vdev *vdev;
const uint64_t *tmp_u64;
vdev = sdi->priv; vdev = sdi->priv;
switch (id) { switch (id) {
case SR_CONF_SAMPLERATE: case SR_CONF_SAMPLERATE:
tmp_u64 = value; vdev->samplerate = g_variant_get_uint64(data);
vdev->samplerate = *tmp_u64;
sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate); sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate);
break; break;
case SR_CONF_SESSIONFILE: case SR_CONF_SESSIONFILE:
vdev->sessionfile = g_strdup(value); vdev->sessionfile = g_strdup(g_variant_get_string(data, NULL));
sr_info("Setting sessionfile to '%s'.", vdev->sessionfile); sr_info("Setting sessionfile to '%s'.", vdev->sessionfile);
break; break;
case SR_CONF_CAPTUREFILE: case SR_CONF_CAPTUREFILE:
vdev->capturefile = g_strdup(value); vdev->capturefile = g_strdup(g_variant_get_string(data, NULL));
sr_info("Setting capturefile to '%s'.", vdev->capturefile); sr_info("Setting capturefile to '%s'.", vdev->capturefile);
break; break;
case SR_CONF_CAPTURE_UNITSIZE: case SR_CONF_CAPTURE_UNITSIZE:
tmp_u64 = value; vdev->unitsize = g_variant_get_uint64(data);
vdev->unitsize = *tmp_u64;
break; break;
case SR_CONF_CAPTURE_NUM_PROBES: case SR_CONF_CAPTURE_NUM_PROBES:
tmp_u64 = value; vdev->num_probes = g_variant_get_uint64(data);
vdev->num_probes = *tmp_u64;
break; break;
default: default:
sr_err("Unknown capability: %d.", id); sr_err("Unknown capability: %d.", id);
@ -204,14 +200,15 @@ static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
return SR_OK; return SR_OK;
} }
static int config_list(int key, const void **data, const struct sr_dev_inst *sdi) static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
{ {
(void)sdi; (void)sdi;
switch (key) { switch (key) {
case SR_CONF_DEVICE_OPTIONS: case SR_CONF_DEVICE_OPTIONS:
*data = hwcaps; *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
break; break;
default: default:
return SR_ERR_ARG; return SR_ERR_ARG;

31
session_file.c
View File

@ -135,7 +135,7 @@ SR_API int sr_session_load(const char *filename)
if (!strncmp(sections[i], "device ", 7)) { if (!strncmp(sections[i], "device ", 7)) {
/* device section */ /* device section */
sdi = NULL; sdi = NULL;
enabled_probes = 0; enabled_probes = total_probes = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL); keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) { for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL); val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
@ -146,18 +146,23 @@ SR_API int sr_session_load(const char *filename)
/* first device, init the driver */ /* first device, init the driver */
sdi->driver->init(NULL); sdi->driver->init(NULL);
sr_session_dev_add(sdi); sr_session_dev_add(sdi);
sdi->driver->config_set(SR_CONF_SESSIONFILE, filename, sdi); sdi->driver->config_set(SR_CONF_SESSIONFILE,
sdi->driver->config_set(SR_CONF_CAPTUREFILE, val, sdi); g_variant_new_string(filename), sdi);
sdi->driver->config_set(SR_CONF_CAPTUREFILE,
g_variant_new_string(val), sdi);
g_ptr_array_add(capturefiles, val); g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) { } else if (!strcmp(keys[j], "samplerate")) {
sr_parse_sizestring(val, &tmp_u64); sr_parse_sizestring(val, &tmp_u64);
sdi->driver->config_set(SR_CONF_SAMPLERATE, &tmp_u64, sdi); sdi->driver->config_set(SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64), sdi);
} else if (!strcmp(keys[j], "unitsize")) { } else if (!strcmp(keys[j], "unitsize")) {
tmp_u64 = strtoull(val, NULL, 10); tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE, &tmp_u64, sdi); sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(tmp_u64), sdi);
} else if (!strcmp(keys[j], "total probes")) { } else if (!strcmp(keys[j], "total probes")) {
total_probes = strtoull(val, NULL, 10); total_probes = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES, &total_probes, sdi); sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES,
g_variant_new_uint64(total_probes), sdi);
for (p = 0; p < total_probes; p++) { for (p = 0; p < total_probes; p++) {
snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p); snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
if (!(probe = sr_probe_new(p, SR_PROBE_LOGIC, TRUE, if (!(probe = sr_probe_new(p, SR_PROBE_LOGIC, TRUE,
@ -179,8 +184,9 @@ SR_API int sr_session_load(const char *filename)
} }
g_strfreev(keys); g_strfreev(keys);
/* Disable probes not specifically listed. */ /* Disable probes not specifically listed. */
for (p = enabled_probes; p < total_probes; p++) if (total_probes)
sr_dev_probe_enable(sdi, p, FALSE); for (p = enabled_probes; p < total_probes; p++)
sr_dev_probe_enable(sdi, p, FALSE);
} }
devcnt++; devcnt++;
} }
@ -207,12 +213,13 @@ SR_API int sr_session_save(const char *filename, const struct sr_dev_inst *sdi,
unsigned char *buf, int unitsize, int units) unsigned char *buf, int unitsize, int units)
{ {
GSList *l; GSList *l;
GVariant *gvar;
FILE *meta; FILE *meta;
struct sr_probe *probe; struct sr_probe *probe;
struct zip *zipfile; struct zip *zipfile;
struct zip_source *versrc, *metasrc, *logicsrc; struct zip_source *versrc, *metasrc, *logicsrc;
int tmpfile, ret, probecnt; int tmpfile, ret, probecnt;
uint64_t *samplerate; uint64_t samplerate;
char version[1], rawname[16], metafile[32], *s; char version[1], rawname[16], metafile[32], *s;
if (!filename) { if (!filename) {
@ -255,10 +262,12 @@ SR_API int sr_session_save(const char *filename, const struct sr_dev_inst *sdi,
fprintf(meta, "total probes = %d\n", g_slist_length(sdi->probes)); fprintf(meta, "total probes = %d\n", g_slist_length(sdi->probes));
if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) { if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) {
if (sr_config_get(sdi->driver, SR_CONF_SAMPLERATE, if (sr_config_get(sdi->driver, SR_CONF_SAMPLERATE,
(const void **)&samplerate, sdi) == SR_OK) { &gvar, sdi) == SR_OK) {
s = sr_samplerate_string(*samplerate); samplerate = g_variant_get_uint64(gvar);
s = sr_samplerate_string(samplerate);
fprintf(meta, "samplerate = %s\n", s); fprintf(meta, "samplerate = %s\n", s);
g_free(s); g_free(s);
g_variant_unref(gvar);
} }
} }
probecnt = 1; probecnt = 1;

6
strutil.c
View File

@ -216,6 +216,7 @@ SR_API char **sr_parse_triggerstring(const struct sr_dev_inst *sdi,
const char *triggerstring) const char *triggerstring)
{ {
GSList *l; GSList *l;
GVariant *gvar;
struct sr_probe *probe; struct sr_probe *probe;
int max_probes, probenum, i; int max_probes, probenum, i;
char **tokens, **triggerlist, *trigger, *tc; char **tokens, **triggerlist, *trigger, *tc;
@ -230,11 +231,11 @@ SR_API char **sr_parse_triggerstring(const struct sr_dev_inst *sdi,
return NULL; return NULL;
} }
if (sdi->driver->config_list(SR_CONF_TRIGGER_TYPE, if (sdi->driver->config_list(SR_CONF_TRIGGER_TYPE, &gvar, sdi) != SR_OK) {
(const void **)&trigger_types, sdi) != SR_OK) {
sr_err("%s: Device doesn't support any triggers.", __func__); sr_err("%s: Device doesn't support any triggers.", __func__);
return NULL; return NULL;
} }
trigger_types = g_variant_get_string(gvar, NULL);
tokens = g_strsplit(triggerstring, ",", max_probes); tokens = g_strsplit(triggerstring, ",", max_probes);
for (i = 0; tokens[i]; i++) { for (i = 0; tokens[i]; i++) {
@ -269,6 +270,7 @@ SR_API char **sr_parse_triggerstring(const struct sr_dev_inst *sdi,
} }
} }
g_strfreev(tokens); g_strfreev(tokens);
g_variant_unref(gvar);
if (error) { if (error) {
for (i = 0; i < max_probes; i++) for (i = 0; i < max_probes; i++)