/* TODO: Should be configurable. */
#define BUFSIZE 4096
+#define STR_PATTERN_SIGROK "sigrok"
+#define STR_PATTERN_RANDOM "random"
+#define STR_PATTERN_INC "incremental"
+#define STR_PATTERN_ALL_LOW "all-low"
+#define STR_PATTERN_ALL_HIGH "all-high"
+
/* Supported patterns which we can generate */
enum {
/**
/* Private, per-device-instance driver context. */
struct dev_context {
int pipe_fds[2];
- GIOChannel *channels[2];
+ GIOChannel *channel;
uint8_t sample_generator;
uint64_t samples_counter;
- void *session_dev_id;
+ void *cb_data;
int64_t starttime;
};
SR_CONF_CONTINUOUS,
};
-static const struct sr_samplerates samplerates = {
- .low = SR_HZ(1),
- .high = SR_GHZ(1),
- .step = SR_HZ(1),
- .list = NULL,
+static const uint64_t samplerates[] = {
+ SR_HZ(1),
+ SR_GHZ(1),
+ SR_HZ(1),
};
static const char *pattern_strings[] = {
"incremental",
"all-low",
"all-high",
- NULL,
};
/* We name the probes 0-7 on our demo driver. */
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)
{
(void)sdi;
switch (id) {
case SR_CONF_SAMPLERATE:
- *data = &cur_samplerate;
+ *data = g_variant_new_uint64(cur_samplerate);
+ break;
+ case SR_CONF_LIMIT_SAMPLES:
+ *data = g_variant_new_uint64(limit_samples);
+ break;
+ case SR_CONF_LIMIT_MSEC:
+ *data = g_variant_new_uint64(limit_msec);
+ break;
+ case SR_CONF_PATTERN_MODE:
+ switch (default_pattern) {
+ case PATTERN_SIGROK:
+ *data = g_variant_new_string(STR_PATTERN_SIGROK);
+ break;
+ case PATTERN_RANDOM:
+ *data = g_variant_new_string(STR_PATTERN_RANDOM);
+ break;
+ case PATTERN_INC:
+ *data = g_variant_new_string(STR_PATTERN_INC);
+ break;
+ case PATTERN_ALL_LOW:
+ *data = g_variant_new_string(STR_PATTERN_ALL_LOW);
+ break;
+ case PATTERN_ALL_HIGH:
+ *data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
+ break;
+ }
break;
default:
return SR_ERR_ARG;
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)
{
int ret;
const char *stropt;
(void)sdi;
if (id == SR_CONF_SAMPLERATE) {
- cur_samplerate = *(const uint64_t *)value;
+ cur_samplerate = g_variant_get_uint64(data);
sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
cur_samplerate);
ret = SR_OK;
} else if (id == SR_CONF_LIMIT_SAMPLES) {
limit_msec = 0;
- limit_samples = *(const uint64_t *)value;
+ limit_samples = g_variant_get_uint64(data);
sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
limit_samples);
ret = SR_OK;
} else if (id == SR_CONF_LIMIT_MSEC) {
- limit_msec = *(const uint64_t *)value;
+ limit_msec = g_variant_get_uint64(data);
limit_samples = 0;
sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
limit_msec);
ret = SR_OK;
} else if (id == SR_CONF_PATTERN_MODE) {
- stropt = value;
+ stropt = g_variant_get_string(data, NULL);
ret = SR_OK;
- if (!strcmp(stropt, "sigrok")) {
+ if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
default_pattern = PATTERN_SIGROK;
- } else if (!strcmp(stropt, "random")) {
+ } else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
default_pattern = PATTERN_RANDOM;
- } else if (!strcmp(stropt, "incremental")) {
+ } else if (!strcmp(stropt, STR_PATTERN_INC)) {
default_pattern = PATTERN_INC;
- } else if (!strcmp(stropt, "all-low")) {
+ } else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
default_pattern = PATTERN_ALL_LOW;
- } else if (!strcmp(stropt, "all-high")) {
+ } else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
default_pattern = PATTERN_ALL_HIGH;
} else {
ret = SR_ERR;
return ret;
}
-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)
{
+ GVariant *gvar;
+ GVariantBuilder gvb;
(void)sdi;
switch (key) {
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;
case SR_CONF_SAMPLERATE:
- *data = &samplerates;
+ g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
+ gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
+ ARRAY_SIZE(samplerates), sizeof(uint64_t));
+ g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
+ *data = g_variant_builder_end(&gvb);
break;
case SR_CONF_PATTERN_MODE:
- *data = &pattern_strings;
+ *data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
break;
default:
return SR_ERR_ARG;
switch (devc->sample_generator) {
case PATTERN_SIGROK: /* sigrok pattern */
for (i = 0; i < size; i++) {
- *(buf + i) = ~(pattern_sigrok[p] >> 1);
- if (++p == 64)
- p = 0;
+ *(buf + i) = ~(pattern_sigrok[
+ p++ % sizeof(pattern_sigrok)] >> 1);
}
break;
case PATTERN_RANDOM: /* Random */
break;
case PATTERN_INC: /* Simple increment */
for (i = 0; i < size; i++)
- *(buf + i) = i;
+ *(buf + i) = p++;
break;
case PATTERN_ALL_LOW: /* All probes are low */
memset(buf, 0x00, size);
logic.length = sending_now;
logic.unitsize = 1;
logic.data = buf;
- sr_session_send(devc->session_dev_id, &packet);
+ sr_session_send(devc->cb_data, &packet);
devc->samples_counter += sending_now;
}
}
devc->sample_generator = default_pattern;
- devc->session_dev_id = cb_data;
+ devc->cb_data = cb_data;
devc->samples_counter = 0;
/*
return SR_ERR;
}
- devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
- devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
+ devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
- g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
+ g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
/* Set channel encoding to binary (default is UTF-8). */
- g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
- g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
+ g_io_channel_set_encoding(devc->channel, NULL, NULL);
/* Make channels to unbuffered. */
- g_io_channel_set_buffered(devc->channels[0], FALSE);
- g_io_channel_set_buffered(devc->channels[1], FALSE);
+ g_io_channel_set_buffered(devc->channel, FALSE);
- sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
+ sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
40, receive_data, devc);
/* Send header packet to the session bus. */
sr_dbg("Stopping aquisition.");
- sr_session_source_remove_channel(devc->channels[0]);
- g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
+ sr_session_source_remove_channel(devc->channel);
+ g_io_channel_shutdown(devc->channel, FALSE, NULL);
/* Send last packet. */
packet.type = SR_DF_END;
- sr_session_send(devc->session_dev_id, &packet);
+ sr_session_send(devc->cb_data, &packet);
return SR_OK;
}