/*
* This file is part of the libsigrok project.
*
+ * Copyright (C) 2022 Gerhard Sittig <gerhard.sittig@gmx.net>
* Copyright (C) 2020 Florian Schmidt <schmidt_florian@gmx.de>
* Copyright (C) 2013 Marcus Comstedt <marcus@mc.pp.se>
* Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
static const uint32_t scanopts[] = {
SR_CONF_CONN,
+ SR_CONF_PROBE_NAMES,
};
static const uint32_t drvopts[] = {
};
static const uint32_t devopts[] = {
- /* TODO: SR_CONF_CONTINUOUS, */
SR_CONF_CONN | SR_CONF_GET,
SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
#endif
SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET,
+ SR_CONF_CONTINUOUS | SR_CONF_GET | SR_CONF_SET,
};
static const uint32_t devopts_cg_logic[] = {
};
/*
- * The hardware uses a 100/200/500MHz base clock (model dependent) and
- * a 16bit divider (common across all models). The range from 10kHz to
- * 100/200/500MHz should be applicable to all devices. High rates may
- * suffer from coarse resolution (e.g. in the "500MHz div 2" case) and
- * may not provide the desired 1/2/5 steps. Fortunately this exclusively
- * affects the 500MHz model where 250MHz is used instead of 200MHz and
- * the 166MHz and 125MHz rates are not presented to users. Deep memory
- * of these models and hardware compression reduce the necessity to let
- * users pick from a huge list of possible rates.
+ * The devices have an upper samplerate limit of 100/200/500 MHz each.
+ * But their hardware uses different base clocks (100/200/800MHz, this
+ * is _not_ a typo) and a 16bit divider. Which results in per-model ranges
+ * of supported rates which not only differ in the upper boundary, but
+ * also at the lower boundary. It's assumed that the 10kHz rate is not
+ * useful enough to provide by all means. Starting at 20kHz for all models
+ * simplfies the implementation of the config API routines, and eliminates
+ * redundancy in these samplerates tables.
*
+ * Streaming mode is constrained by the channel count and samplerate
+ * product (the bits per second which need to travel the USB connection
+ * while the acquisition is executing). Because streaming mode does not
+ * compress the capture data, a later implementation may desire a finer
+ * resolution. For now let's just stick with the 1/2/5 steps.
*/
static const uint64_t rates_500mhz[] = {
- SR_KHZ(10),
SR_KHZ(20),
SR_KHZ(50),
SR_KHZ(100),
SR_MHZ(20),
SR_MHZ(50),
SR_MHZ(100),
- SR_MHZ(250),
+ SR_MHZ(200),
SR_MHZ(500),
};
static const uint64_t rates_200mhz[] = {
- SR_KHZ(10),
SR_KHZ(20),
SR_KHZ(50),
SR_KHZ(100),
};
static const uint64_t rates_100mhz[] = {
- SR_KHZ(10),
SR_KHZ(20),
SR_KHZ(50),
SR_KHZ(100),
uint8_t bus, addr;
uint16_t pid;
const char *conn;
+ const char *probe_names;
char conn_id[64];
int ret;
size_t ch_off, ch_max;
conn = NULL;
conn_devices = NULL;
+ probe_names = NULL;
for (l = options; l; l = l->next) {
src = l->data;
switch (src->key) {
case SR_CONF_CONN:
conn = g_variant_get_string(src->data, NULL);
break;
+ case SR_CONF_PROBE_NAMES:
+ probe_names = g_variant_get_string(src->data, NULL);
+ break;
}
}
if (conn)
* this device.
*/
devc->fw_uploaded = 0;
+ devc->usb_pid = pid;
if (des.iProduct != LA2016_IPRODUCT_INDEX) {
sr_info("Uploading MCU firmware to '%s'.", conn_id);
- ret = la2016_upload_firmware(sdi, ctx, dev, pid);
+ ret = la2016_upload_firmware(sdi, ctx, dev, FALSE);
if (ret != SR_OK) {
sr_err("MCU firmware upload failed.");
kingst_la2016_free_sdi(sdi);
usb->address = 0xff;
renum_devices = g_slist_append(renum_devices, sdi);
continue;
+ } else {
+ ret = la2016_upload_firmware(sdi, NULL, NULL, TRUE);
+ if (ret != SR_OK) {
+ sr_err("MCU firmware filename check failed.");
+ kingst_la2016_free_sdi(sdi);
+ continue;
+ }
}
/*
ch_max = ARRAY_SIZE(channel_names_logic);
if (ch_max > devc->model->channel_count)
ch_max = devc->model->channel_count;
+ devc->channel_names_logic = sr_parse_probe_names(probe_names,
+ channel_names_logic, ch_max, ch_max, &ch_max);
cg = sr_channel_group_new(sdi, "Logic", NULL);
devc->cg_logic = cg;
for (ch_idx = 0; ch_idx < ch_max; ch_idx++) {
ch = sr_channel_new(sdi, ch_off,
SR_CHANNEL_LOGIC, TRUE,
- channel_names_logic[ch_idx]);
+ devc->channel_names_logic[ch_idx]);
ch_off++;
cg->channels = g_slist_append(cg->channels, ch);
}
sr_sw_limits_init(&devc->sw_limits);
devc->sw_limits.limit_samples = 0;
devc->capture_ratio = 50;
- devc->cur_samplerate = devc->model->samplerate;
+ devc->samplerate = devc->model->samplerate;
+ if (!devc->model->memory_bits)
+ devc->continuous = TRUE;
devc->threshold_voltage_idx = LOGIC_THRESHOLD_IDX_DFLT;
if (ARRAY_SIZE(devc->pwm_setting) >= 1) {
devc->pwm_setting[0].enabled = FALSE;
if (!usb->devhdl)
return SR_ERR_BUG;
- la2016_deinit_hardware(sdi);
+ la2016_release_resources(sdi);
+
+ if (WITH_DEINIT_IN_CLOSE)
+ la2016_deinit_hardware(sdi);
sr_info("Closing device on %d.%d (logical) / %s (physical) interface %d.",
usb->bus, usb->address, sdi->connection_id, USB_INTERFACE);
*data = g_variant_new_printf("%d.%d", usb->bus, usb->address);
break;
case SR_CONF_SAMPLERATE:
- *data = g_variant_new_uint64(devc->cur_samplerate);
+ *data = g_variant_new_uint64(devc->samplerate);
break;
case SR_CONF_LIMIT_SAMPLES:
case SR_CONF_LIMIT_MSEC:
*data = std_gvar_tuple_double(voltage, voltage);
break;
#endif /* WITH_THRESHOLD_DEVCFG */
+ case SR_CONF_CONTINUOUS:
+ *data = g_variant_new_boolean(devc->continuous);
+ break;
default:
return SR_ERR_NA;
}
struct pwm_setting *pwm;
double value_f;
int idx;
+ gboolean on;
devc = sdi->priv;
switch (key) {
case SR_CONF_SAMPLERATE:
- devc->cur_samplerate = g_variant_get_uint64(data);
+ devc->samplerate = g_variant_get_uint64(data);
break;
case SR_CONF_LIMIT_SAMPLES:
case SR_CONF_LIMIT_MSEC:
devc->threshold_voltage_idx = idx;
break;
#endif /* WITH_THRESHOLD_DEVCFG */
+ case SR_CONF_CONTINUOUS:
+ on = g_variant_get_boolean(data);
+ if (!devc->model->memory_bits && !on)
+ return SR_ERR_ARG;
+ devc->continuous = on;
+ break;
default:
return SR_ERR_NA;
}
*data = std_gvar_samplerates(ARRAY_AND_SIZE(rates_500mhz));
else if (devc->model->samplerate == SR_MHZ(200))
*data = std_gvar_samplerates(ARRAY_AND_SIZE(rates_200mhz));
- else
+ else if (devc->model->samplerate == SR_MHZ(100))
*data = std_gvar_samplerates(ARRAY_AND_SIZE(rates_100mhz));
+ else
+ return SR_ERR_BUG;
break;
case SR_CONF_LIMIT_SAMPLES:
*data = std_gvar_tuple_u64(0, LA2016_NUM_SAMPLES_MAX);
struct drv_context *drvc;
struct sr_context *ctx;
struct dev_context *devc;
+ size_t unitsize;
double voltage;
int ret;
devc = sdi->priv;
if (!devc->feed_queue) {
+ if (devc->model->channel_count == 32)
+ unitsize = sizeof(uint32_t);
+ else if (devc->model->channel_count == 16)
+ unitsize = sizeof(uint16_t);
+ else
+ return SR_ERR_ARG;
devc->feed_queue = feed_queue_logic_alloc(sdi,
- LA2016_CONVBUFFER_SIZE, sizeof(uint16_t));
+ LA2016_CONVBUFFER_SIZE, unitsize);
if (!devc->feed_queue) {
sr_err("Cannot allocate buffer for session feed.");
return SR_ERR_MALLOC;
}
+ devc->packets_per_chunk = TRANSFER_PACKET_LENGTH;
+ devc->packets_per_chunk--;
+ devc->packets_per_chunk /= unitsize + sizeof(uint8_t);
}
sr_sw_limits_acquisition_start(&devc->sw_limits);
projects / libsigrok.git / blobdiff