* same 128K sample depth.
*/
static const struct zp_model zeroplus_models[] = {
+ {0x0c12, 0x7002, "LAP-16128U", 16, 128, 200},
{0x0c12, 0x7009, "LAP-C(16064)", 16, 64, 100},
{0x0c12, 0x700a, "LAP-C(16128)", 16, 128, 200},
/* TODO: We don't know anything about these.
{ 0, 0, 0, 0, 0, 0 }
};
-static const int hwcaps[] = {
+static const int32_t hwcaps[] = {
SR_CONF_LOGIC_ANALYZER,
SR_CONF_SAMPLERATE,
SR_CONF_CAPTURE_RATIO,
SR_CONF_LIMIT_SAMPLES,
- 0,
};
/*
* options hardcoded into the vendor's Windows GUI.
*/
-/*
- * TODO: We shouldn't support 150MHz and 200MHz on devices that don't go up
- * that high.
- */
-const uint64_t zp_supported_samplerates[] = {
+static const uint64_t samplerates_100[] = {
SR_HZ(100),
SR_HZ(500),
SR_KHZ(1),
SR_MHZ(50),
SR_MHZ(80),
SR_MHZ(100),
- SR_MHZ(150),
- SR_MHZ(200),
- 0,
};
-static const struct sr_samplerates samplerates = {
- .low = 0,
- .high = 0,
- .step = 0,
- .list = zp_supported_samplerates,
+const uint64_t samplerates_200[] = {
+ SR_HZ(100),
+ SR_HZ(500),
+ SR_KHZ(1),
+ SR_KHZ(5),
+ SR_KHZ(25),
+ SR_KHZ(50),
+ SR_KHZ(100),
+ SR_KHZ(200),
+ SR_KHZ(400),
+ SR_KHZ(800),
+ SR_MHZ(1),
+ SR_MHZ(10),
+ SR_MHZ(25),
+ SR_MHZ(50),
+ SR_MHZ(80),
+ SR_MHZ(100),
+ SR_MHZ(150),
+ SR_MHZ(200),
};
static int hw_dev_close(struct sr_dev_inst *sdi);
return SR_OK;
}
+SR_PRIV int zp_set_samplerate(struct dev_context *devc, uint64_t samplerate)
+{
+ int i;
+
+ for (i = 0; ARRAY_SIZE(samplerates_200); i++)
+ if (samplerate == samplerates_200[i])
+ break;
+
+ if (i == ARRAY_SIZE(samplerates_200) || samplerate > devc->max_samplerate) {
+ sr_err("Unsupported samplerate: %" PRIu64 "Hz.", samplerate);
+ return SR_ERR_ARG;
+ }
+
+ sr_info("Setting samplerate to %" PRIu64 "Hz.", samplerate);
+
+ if (samplerate >= SR_MHZ(1))
+ analyzer_set_freq(samplerate / SR_MHZ(1), FREQ_SCALE_MHZ);
+ else if (samplerate >= SR_KHZ(1))
+ analyzer_set_freq(samplerate / SR_KHZ(1), FREQ_SCALE_KHZ);
+ else
+ analyzer_set_freq(samplerate, FREQ_SCALE_HZ);
+
+ devc->cur_samplerate = samplerate;
+
+ return SR_OK;
+}
+
static int clear_instances(void)
{
GSList *l;
}
sdi->priv = devc;
+ devc->prof = prof;
devc->num_channels = prof->channels;
#ifdef ZP_EXPERIMENTAL
devc->max_memory_size = 128 * 1024;
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 dev_context *devc;
case SR_CONF_SAMPLERATE:
if (sdi) {
devc = sdi->priv;
- *data = &devc->cur_samplerate;
+ *data = g_variant_new_uint64(devc->cur_samplerate);
sr_spew("Returning samplerate: %" PRIu64 "Hz.",
devc->cur_samplerate);
} else
return SR_ERR;
break;
default:
- return SR_ERR_ARG;
+ return SR_ERR_NA;
}
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 dev_context *devc;
switch (id) {
case SR_CONF_SAMPLERATE:
- return zp_set_samplerate(devc, *(const uint64_t *)value);
+ return zp_set_samplerate(devc, g_variant_get_uint64(data));
case SR_CONF_LIMIT_SAMPLES:
- return set_limit_samples(devc, *(const uint64_t *)value);
+ return set_limit_samples(devc, g_variant_get_uint64(data));
case SR_CONF_CAPTURE_RATIO:
- return set_capture_ratio(devc, *(const uint64_t *)value);
+ return set_capture_ratio(devc, g_variant_get_uint64(data));
default:
- return SR_ERR;
+ return SR_ERR_NA;
}
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;
+ struct dev_context *devc;
+ GVariant *gvar;
+ GVariantBuilder gvb;
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;
+ 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 {
+ 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_TYPE:
- *data = TRIGGER_TYPE;
+ *data = g_variant_new_string(TRIGGER_TYPE);
break;
default:
- return SR_ERR_ARG;
+ return SR_ERR_NA;
}
return SR_OK;