ALL_ZERO
};
-static const uint32_t devopts[] = {
+static const uint32_t drvopts[] = {
SR_CONF_LOGIC_ANALYZER,
+};
+
+static const uint32_t devopts[] = {
SR_CONF_LIMIT_SAMPLES | SR_CONF_SET | SR_CONF_LIST,
SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
SR_MHZ(200),
};
-static int dev_close(struct sr_dev_inst *sdi);
-
SR_PRIV int zp_set_samplerate(struct dev_context *devc, uint64_t samplerate)
{
int i;
prof = &zeroplus_models[j];
}
}
- /* Skip if the device was not found. */
+
if (!prof)
continue;
sr_info("Found ZEROPLUS %s.", prof->model_name);
- /* Register the device with libsigrok. */
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->status = SR_ST_INACTIVE;
sdi->vendor = g_strdup(VENDOR_NAME);
sdi->serial_num = g_strdup(serial_num);
sdi->connection_id = g_strdup(connection_id);
- /* Allocate memory for our private driver context. */
devc = g_malloc0(sizeof(struct dev_context));
sdi->priv = devc;
devc->prof = prof;
devc->memory_size = MEMORY_SIZE_8K;
// memset(devc->trigger_buffer, 0, NUM_TRIGGER_STAGES);
- /* Fill in channellist according to this device's profile. */
for (j = 0; j < devc->num_channels; j++)
sr_channel_new(sdi, j, SR_CHANNEL_LOGIC, TRUE,
channel_names[j]);
if (ret != SR_OK)
return ret;
- sdi->status = SR_ST_ACTIVE;
-
ret = libusb_set_configuration(usb->devhdl, USB_CONFIGURATION);
if (ret < 0) {
sr_err("Unable to set USB configuration %d: %s.",
usb = sdi->conn;
if (!usb->devhdl)
- return SR_ERR;
+ return SR_ERR_BUG;
sr_info("Closing device on %d.%d (logical) / %s (physical) interface %d.",
usb->bus, usb->address, sdi->connection_id, USB_INTERFACE);
libusb_reset_device(usb->devhdl);
libusb_close(usb->devhdl);
usb->devhdl = NULL;
- sdi->status = SR_ST_INACTIVE;
return SR_OK;
}
(void)cg;
- if (sdi->status != SR_ST_ACTIVE)
- return SR_ERR_DEV_CLOSED;
-
devc = sdi->priv;
switch (key) {
const struct sr_channel_group *cg)
{
struct dev_context *devc;
- GVariant *gvar, *grange[2];
- GVariantBuilder gvb;
- double v;
- GVariant *range[2];
-
- (void)cg;
+ GVariant *grange[2];
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
- *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
- devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
- break;
+ return STD_CONFIG_LIST(key, data, sdi, cg, NULL, drvopts, devopts);
case SR_CONF_SAMPLERATE:
devc = sdi->priv;
- g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
- if (devc->prof->max_sampling_freq == 100) {
- gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
- samplerates_100, ARRAY_SIZE(samplerates_100),
- sizeof(uint64_t));
- } else if (devc->prof->max_sampling_freq == 200) {
- gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
- samplerates_200, ARRAY_SIZE(samplerates_200),
- sizeof(uint64_t));
- } else {
+ if (devc->prof->max_sampling_freq == 100)
+ *data = std_gvar_samplerates(ARRAY_AND_SIZE(samplerates_100));
+ else if (devc->prof->max_sampling_freq == 200)
+ *data = std_gvar_samplerates(ARRAY_AND_SIZE(samplerates_200));
+ else {
sr_err("Internal error: Unknown max. samplerate: %d.",
devc->prof->max_sampling_freq);
return SR_ERR_ARG;
}
- g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
- *data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_MATCH:
- *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
- trigger_matches, ARRAY_SIZE(trigger_matches),
- sizeof(int32_t));
+ *data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches));
break;
case SR_CONF_VOLTAGE_THRESHOLD:
- g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
- for (v = -6.0; v <= 6.0; v += 0.1) {
- range[0] = g_variant_new_double(v);
- range[1] = g_variant_new_double(v);
- gvar = g_variant_new_tuple(range, 2);
- g_variant_builder_add_value(&gvb, gvar);
- }
- *data = g_variant_builder_end(&gvb);
+ *data = std_gvar_min_max_step_thresholds(-6.0, 6.0, 0.1);
break;
case SR_CONF_LIMIT_SAMPLES:
if (!sdi)
unsigned int discard;
int trigger_now;
- if (sdi->status != SR_ST_ACTIVE)
- return SR_ERR_DEV_CLOSED;
-
devc = sdi->priv;
if (analyzer_add_triggers(sdi) != SR_OK) {
sr_info("Ramsize trigger = 0x%x.", ramsize_trigger);
sr_info("Memory size = 0x%x.", memory_size);
- std_session_send_df_header(sdi, LOG_PREFIX);
+ std_session_send_df_header(sdi);
/* Check for empty capture */
if ((status & STATUS_READY) && !stop_address) {
- std_session_send_df_end(sdi, LOG_PREFIX);
+ std_session_send_df_end(sdi);
return SR_OK;
}
analyzer_read_stop(usb->devhdl);
g_free(buf);
- std_session_send_df_end(sdi, LOG_PREFIX);
+ std_session_send_df_end(sdi);
return SR_OK;
}
-/* TODO: This stops acquisition on ALL devices, ignoring dev_index. */
static int dev_acquisition_stop(struct sr_dev_inst *sdi)
{
struct sr_usb_dev_inst *usb;
- std_session_send_df_end(sdi, LOG_PREFIX);
+ std_session_send_df_end(sdi);
usb = sdi->conn;
analyzer_reset(usb->devhdl);
.cleanup = std_cleanup,
.scan = scan,
.dev_list = std_dev_list,
- .dev_clear = NULL,
+ .dev_clear = std_dev_clear,
.config_get = config_get,
.config_set = config_set,
.config_list = config_list,