#define TICK 1
static const int hwcaps[] = {
- SR_HWCAP_OSCILLOSCOPE,
- SR_HWCAP_LIMIT_SAMPLES,
- SR_HWCAP_CONTINUOUS,
- SR_HWCAP_TIMEBASE,
- SR_HWCAP_BUFFERSIZE,
- SR_HWCAP_TRIGGER_SOURCE,
- SR_HWCAP_TRIGGER_SLOPE,
- SR_HWCAP_HORIZ_TRIGGERPOS,
- SR_HWCAP_FILTER,
- SR_HWCAP_VDIV,
- SR_HWCAP_COUPLING,
+ SR_CONF_OSCILLOSCOPE,
+ SR_CONF_LIMIT_SAMPLES,
+ SR_CONF_CONTINUOUS,
+ SR_CONF_TIMEBASE,
+ SR_CONF_BUFFERSIZE,
+ SR_CONF_TRIGGER_SOURCE,
+ SR_CONF_TRIGGER_SLOPE,
+ SR_CONF_HORIZ_TRIGGERPOS,
+ SR_CONF_FILTER,
+ SR_CONF_VDIV,
+ SR_CONF_COUPLING,
0,
};
static int configure_probes(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- const struct sr_probe *probe;
+ struct sr_probe *probe;
const GSList *l;
+ int p;
devc = sdi->priv;
+ g_slist_free(devc->enabled_probes);
devc->ch1_enabled = devc->ch2_enabled = FALSE;
- for (l = sdi->probes; l; l = l->next) {
- probe = (struct sr_probe *)l->data;
- if (probe->index == 0)
+ for (l = sdi->probes, p = 0; l; l = l->next, p++) {
+ probe = l->data;
+ if (p == 0)
devc->ch1_enabled = probe->enabled;
- else if (probe->index == 1)
+ else
devc->ch2_enabled = probe->enabled;
+ if (probe->enabled)
+ devc->enabled_probes = g_slist_append(devc->enabled_probes, probe);
}
return SR_OK;
dso_close(sdi);
sr_usb_dev_inst_free(devc->usb);
g_free(devc->triggersource);
+ g_slist_free(devc->enabled_probes);
sr_dev_inst_free(sdi);
}
static int hw_init(struct sr_context *sr_ctx)
{
- struct drv_context *drvc;
-
- if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
- sr_err("Driver context malloc failed.");
- return SR_ERR_MALLOC;
- }
-
- drvc->sr_ctx = sr_ctx;
- di->priv = drvc;
-
- return SR_OK;
+ return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
}
static GSList *hw_scan(GSList *options)
(void)options;
- devcnt = 0;
- devices = 0;
drvc = di->priv;
drvc->instances = NULL;
+ devcnt = 0;
+ devices = 0;
+
clear_instances();
/* Find all Hantek DSO devices and upload firmware to all of them. */
static GSList *hw_dev_list(void)
{
- struct drv_context *drvc;
-
- drvc = di->priv;
-
- return drvc->instances;
+ return ((struct drv_context *)(di->priv))->instances;
}
static int hw_dev_open(struct sr_dev_inst *sdi)
return SR_OK;
}
-static int hw_info_get(int info_id, const void **data,
- const struct sr_dev_inst *sdi)
-{
- uint64_t tmp;
-
- (void)sdi;
-
- switch (info_id) {
- case SR_DI_HWCAPS:
- *data = hwcaps;
- break;
- case SR_DI_BUFFERSIZES:
- *data = buffersizes;
- break;
- case SR_DI_TIMEBASES:
- *data = timebases;
- break;
- case SR_DI_TRIGGER_SOURCES:
- *data = trigger_sources;
- break;
- case SR_DI_FILTERS:
- *data = filter_targets;
- break;
- case SR_DI_VDIVS:
- *data = vdivs;
- break;
- case SR_DI_COUPLING:
- *data = coupling;
- break;
- /* TODO remove this */
- case SR_DI_CUR_SAMPLERATE:
- *data = &tmp;
- break;
- default:
- return SR_ERR_ARG;
- }
-
- return SR_OK;
-}
-
-static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
- const void *value)
+static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_rational tmp_rat;
ret = SR_OK;
devc = sdi->priv;
- switch (hwcap) {
- case SR_HWCAP_LIMIT_FRAMES:
+ switch (id) {
+ case SR_CONF_LIMIT_FRAMES:
devc->limit_frames = *(const uint64_t *)value;
break;
- case SR_HWCAP_TRIGGER_SLOPE:
+ case SR_CONF_TRIGGER_SLOPE:
tmp_u64 = *(const int *)value;
if (tmp_u64 != SLOPE_NEGATIVE && tmp_u64 != SLOPE_POSITIVE)
ret = SR_ERR_ARG;
devc->triggerslope = tmp_u64;
break;
- case SR_HWCAP_HORIZ_TRIGGERPOS:
+ case SR_CONF_HORIZ_TRIGGERPOS:
tmp_float = *(const float *)value;
if (tmp_float < 0.0 || tmp_float > 1.0) {
sr_err("Trigger position should be between 0.0 and 1.0.");
} else
devc->triggerposition = tmp_float;
break;
- case SR_HWCAP_BUFFERSIZE:
+ case SR_CONF_BUFFERSIZE:
tmp_u64 = *(const int *)value;
for (i = 0; buffersizes[i]; i++) {
if (buffersizes[i] == tmp_u64) {
if (buffersizes[i] == 0)
ret = SR_ERR_ARG;
break;
- case SR_HWCAP_TIMEBASE:
+ case SR_CONF_TIMEBASE:
tmp_rat = *(const struct sr_rational *)value;
for (i = 0; timebases[i].p && timebases[i].q; i++) {
if (timebases[i].p == tmp_rat.p
if (timebases[i].p == 0 && timebases[i].q == 0)
ret = SR_ERR_ARG;
break;
- case SR_HWCAP_TRIGGER_SOURCE:
+ case SR_CONF_TRIGGER_SOURCE:
for (i = 0; trigger_sources[i]; i++) {
if (!strcmp(value, trigger_sources[i])) {
devc->triggersource = g_strdup(value);
if (trigger_sources[i] == 0)
ret = SR_ERR_ARG;
break;
- case SR_HWCAP_FILTER:
+ case SR_CONF_FILTER:
devc->filter_ch1 = devc->filter_ch2 = devc->filter_trigger = 0;
targets = g_strsplit(value, ",", 0);
for (i = 0; targets[i]; i++) {
}
g_strfreev(targets);
break;
- case SR_HWCAP_VDIV:
+ case SR_CONF_VDIV:
/* TODO: Not supporting vdiv per channel yet. */
tmp_rat = *(const struct sr_rational *)value;
for (i = 0; vdivs[i].p && vdivs[i].q; i++) {
if (vdivs[i].p == 0 && vdivs[i].q == 0)
ret = SR_ERR_ARG;
break;
- case SR_HWCAP_COUPLING:
+ case SR_CONF_COUPLING:
/* TODO: Not supporting coupling per channel yet. */
for (i = 0; coupling[i]; i++) {
if (!strcmp(value, coupling[i])) {
return ret;
}
-static void send_chunk(struct dev_context *devc, unsigned char *buf,
+static int config_list(int key, const void **data, const struct sr_dev_inst *sdi)
+{
+
+ (void)sdi;
+
+ switch (key) {
+ case SR_CONF_DEVICE_OPTIONS:
+ *data = hwcaps;
+ break;
+ case SR_CONF_BUFFERSIZE:
+ *data = buffersizes;
+ break;
+ case SR_CONF_COUPLING:
+ *data = coupling;
+ break;
+ case SR_CONF_VDIV:
+ *data = vdivs;
+ break;
+ case SR_CONF_FILTER:
+ *data = filter_targets;
+ break;
+ case SR_CONF_TIMEBASE:
+ *data = timebases;
+ break;
+ case SR_CONF_TRIGGER_SOURCE:
+ *data = trigger_sources;
+ break;
+ default:
+ return SR_ERR_ARG;
+ }
+
+ return SR_OK;
+}
+
+static void send_chunk(struct sr_dev_inst *sdi, unsigned char *buf,
int num_samples)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_analog analog;
+ struct dev_context *devc;
float ch1, ch2, range;
int num_probes, data_offset, i;
+ devc = sdi->priv;
num_probes = (devc->ch1_enabled && devc->ch2_enabled) ? 2 : 1;
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
/* TODO: support for 5xxx series 9-bit samples */
+ analog.probes = devc->enabled_probes;
analog.num_samples = num_samples;
analog.mq = SR_MQ_VOLTAGE;
analog.unit = SR_UNIT_VOLT;
static void receive_transfer(struct libusb_transfer *transfer)
{
struct sr_datafeed_packet packet;
+ struct sr_dev_inst *sdi;
struct dev_context *devc;
int num_samples, pre;
- devc = transfer->user_data;
+ sdi = transfer->user_data;
+ devc = sdi->priv;
sr_dbg("receive_transfer(): status %d received %d bytes.",
transfer->status, transfer->actual_length);
/* Avoid the corner case where the chunk ended at
* exactly the trigger point. */
if (num_samples > pre)
- send_chunk(devc, transfer->buffer + pre * 2,
+ send_chunk(sdi, transfer->buffer + pre * 2,
num_samples - pre);
}
} else {
/* Already past the trigger point, just send it all out. */
- send_chunk(devc, transfer->buffer,
+ send_chunk(sdi, transfer->buffer,
num_samples);
}
* pre-trigger samples out now, in one big chunk. */
sr_dbg("End of frame, sending %d pre-trigger buffered samples.",
devc->samp_buffered);
- send_chunk(devc, devc->framebuf, devc->samp_buffered);
+ send_chunk(sdi, devc->framebuf, devc->samp_buffered);
/* Mark the end of this frame. */
packet.type = SR_DF_FRAME_END;
devc->samp_buffered = devc->samp_received = 0;
/* Tell the scope to send us the first frame. */
- if (dso_get_channeldata(devc, receive_transfer) != SR_OK)
+ if (dso_get_channeldata(sdi, receive_transfer) != SR_OK)
break;
/*
void *cb_data)
{
const struct libusb_pollfd **lupfd;
- struct sr_datafeed_packet packet;
- struct sr_datafeed_header header;
struct dev_context *devc;
struct drv_context *drvc = di->priv;
int i;
free(lupfd);
/* Send header packet to the session bus. */
- packet.type = SR_DF_HEADER;
- packet.payload = (unsigned char *)&header;
- header.feed_version = 1;
- gettimeofday(&header.starttime, NULL);
- sr_session_send(cb_data, &packet);
+ std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
return SR_OK;
}
.scan = hw_scan,
.dev_list = hw_dev_list,
.dev_clear = clear_instances,
+ .config_set = config_set,
+ .config_list = config_list,
.dev_open = hw_dev_open,
.dev_close = hw_dev_close,
- .info_get = hw_info_get,
- .dev_config_set = hw_dev_config_set,
.dev_acquisition_start = hw_dev_acquisition_start,
.dev_acquisition_stop = hw_dev_acquisition_stop,
.priv = NULL,
projects / libsigrok.git / blobdiff