[libsigrok.git] / hardware / rigol-ds / api.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2012 Martin Ling <martin-git@earth.li>
 * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "libsigrok.h"
#include "libsigrok-internal.h"
#include "protocol.h"

#define NUM_TIMEBASE  12
#define NUM_VDIV      8

static const int32_t hwopts[] = {
	SR_CONF_CONN,
};

static const int32_t hwcaps[] = {
	SR_CONF_OSCILLOSCOPE,
	SR_CONF_TIMEBASE,
	SR_CONF_TRIGGER_SOURCE,
	SR_CONF_TRIGGER_SLOPE,
	SR_CONF_HORIZ_TRIGGERPOS,
	SR_CONF_NUM_TIMEBASE,
};

static const int32_t analog_hwcaps[] = {
	SR_CONF_NUM_VDIV,
	SR_CONF_VDIV,
	SR_CONF_COUPLING,
};

static const uint64_t timebases[][2] = {
	/* nanoseconds */
	{ 2, 1000000000 },
	{ 5, 1000000000 },
	{ 10, 1000000000 },
	{ 20, 1000000000 },
	{ 50, 1000000000 },
	{ 100, 1000000000 },
	{ 500, 1000000000 },
	/* microseconds */
	{ 1, 1000000 },
	{ 2, 1000000 },
	{ 5, 1000000 },
	{ 10, 1000000 },
	{ 20, 1000000 },
	{ 50, 1000000 },
	{ 100, 1000000 },
	{ 200, 1000000 },
	{ 500, 1000000 },
	/* milliseconds */
	{ 1, 1000 },
	{ 2, 1000 },
	{ 5, 1000 },
	{ 10, 1000 },
	{ 20, 1000 },
	{ 50, 1000 },
	{ 100, 1000 },
	{ 200, 1000 },
	{ 500, 1000 },
	/* seconds */
	{ 1, 1 },
	{ 2, 1 },
	{ 5, 1 },
	{ 10, 1 },
	{ 20, 1 },
	{ 50, 1 },
};

static const uint64_t vdivs[][2] = {
	/* millivolts */
	{ 2, 1000 },
	{ 5, 1000 },
	{ 10, 1000 },
	{ 20, 1000 },
	{ 50, 1000 },
	{ 100, 1000 },
	{ 200, 1000 },
	{ 500, 1000 },
	/* volts */
	{ 1, 1 },
	{ 2, 1 },
	{ 5, 1 },
	{ 10, 1 },
};

static const char *trigger_sources[] = {
	"CH1",
	"CH2",
	"EXT",
	"AC Line",
	"D0",
	"D1",
	"D2",
	"D3",
	"D4",
	"D5",
	"D6",
	"D7",
	"D8",
	"D9",
	"D10",
	"D11",
	"D12",
	"D13",
	"D14",
	"D15",
};

static const char *coupling[] = {
	"AC",
	"DC",
	"GND",
};

static const char *supported_models[] = {
	"DS1052E",
	"DS1102E",
	"DS1152E",
	"DS1052D",
	"DS1102D",
	"DS1152D",
};

SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
static struct sr_dev_driver *di = &rigol_ds_driver_info;

static void clear_helper(void *priv)
{
	struct dev_context *devc;

	devc = priv;
	g_free(devc->coupling[0]);
	g_free(devc->coupling[1]);
	g_free(devc->trigger_source);
	g_free(devc->trigger_slope);
	g_slist_free(devc->analog_groups[0].probes);
	g_slist_free(devc->analog_groups[1].probes);
	g_slist_free(devc->digital_group.probes);
}

static int dev_clear(void)
{
	return std_dev_clear(di, clear_helper);
}

static int set_cfg(const struct sr_dev_inst *sdi, const char *format, ...)
{
	va_list args;
	char buf[256];

	va_start(args, format);
	vsnprintf(buf, 255, format, args);
	va_end(args);
	if (rigol_ds_send(sdi, buf) != SR_OK)
		return SR_ERR;

	/* When setting a bunch of parameters in a row, the DS1052E scrambles
	 * some of them unless there is at least 100ms delay in between. */
	sr_spew("delay %dms", 100);
	g_usleep(100000);

	return SR_OK;
}

static int init(struct sr_context *sr_ctx)
{
	return std_init(sr_ctx, di, LOG_PREFIX);
}

static int probe_port(const char *port, GSList **devices)
{
	struct dev_context *devc;
	struct sr_dev_inst *sdi;
	struct sr_serial_dev_inst *serial;
	struct sr_probe *probe;
	unsigned int i;
	int len, num_tokens;
	gboolean matched, has_digital;
	const char *manufacturer, *model, *version;
	char buf[256];
	gchar **tokens, *channel_name;

	*devices = NULL;
	if (!(serial = sr_serial_dev_inst_new(port, NULL)))
		return SR_ERR_MALLOC;

	if (serial_open(serial, SERIAL_RDWR) != SR_OK)
		return SR_ERR;
	len = serial_write(serial, "*IDN?", 5);
	len = serial_read(serial, buf, sizeof(buf));
	if (serial_close(serial) != SR_OK)
		return SR_ERR;

	sr_serial_dev_inst_free(serial);

	if (len == 0)
		return SR_ERR_NA;

	buf[len] = 0;
	tokens = g_strsplit(buf, ",", 0);
	sr_dbg("response: %s [%s]", port, buf);

	for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++);

	if (num_tokens < 4) {
		g_strfreev(tokens);
		return SR_ERR_NA;
	}

	manufacturer = tokens[0];
	model = tokens[1];
	version = tokens[3];

	if (strcmp(manufacturer, "Rigol Technologies")) {
		g_strfreev(tokens);
		return SR_ERR_NA;
	}

	matched = has_digital = FALSE;
	for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
		if (!strcmp(model, supported_models[i])) {
			matched = TRUE;
			has_digital = g_str_has_suffix(model, "D");
			break;
		}
	}

	if (!matched || !(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE,
		manufacturer, model, version))) {
		g_strfreev(tokens);
		return SR_ERR_NA;
	}

	g_strfreev(tokens);

	if (!(sdi->conn = sr_serial_dev_inst_new(port, NULL)))
		return SR_ERR_MALLOC;
	sdi->driver = di;
	sdi->inst_type = SR_INST_SERIAL;

	if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
		return SR_ERR_MALLOC;
	devc->limit_frames = 0;
	devc->has_digital = has_digital;

	for (i = 0; i < 2; i++) {
		channel_name = (i == 0 ? "CH1" : "CH2");
		if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel_name)))
			return SR_ERR_MALLOC;
		sdi->probes = g_slist_append(sdi->probes, probe);
		devc->analog_groups[i].name = channel_name;
		devc->analog_groups[i].probes = g_slist_append(NULL, probe);
		sdi->probe_groups = g_slist_append(sdi->probe_groups,
				&devc->analog_groups[i]);
	}

	if (devc->has_digital) {
		for (i = 0; i < 16; i++) {
			if (!(channel_name = g_strdup_printf("D%d", i)))
				return SR_ERR_MALLOC;
			probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name);
			g_free(channel_name);
			if (!probe)
				return SR_ERR_MALLOC;
			sdi->probes = g_slist_append(sdi->probes, probe);
			devc->digital_group.probes = g_slist_append(
					devc->digital_group.probes, probe);
			devc->digital_group.name = "LA";
			sdi->probe_groups = g_slist_append(sdi->probe_groups,
					&devc->digital_group);
		}
	}
	sdi->priv = devc;

	*devices = g_slist_append(NULL, sdi);

	return SR_OK;
}

static GSList *scan(GSList *options)
{
	struct drv_context *drvc;
	struct sr_config *src;
	GSList *l, *devices;
	GDir *dir;
	int ret;
	const gchar *dev_name;
	gchar *port = NULL;

	drvc = di->priv;

	for (l = options; l; l = l->next) {
		src = l->data;
		if (src->key == SR_CONF_CONN) {
			port = (char *)g_variant_get_string(src->data, NULL);
			break;
		}
	}

	devices = NULL;
	if (port) {
		if (probe_port(port, &devices) == SR_ERR_MALLOC)
			return NULL;
	} else {
		if (!(dir = g_dir_open("/sys/class/usbmisc/", 0, NULL)))
			if (!(dir = g_dir_open("/sys/class/usb/", 0, NULL)))
				return NULL;
		while ((dev_name = g_dir_read_name(dir))) {
			if (strncmp(dev_name, "usbtmc", 6))
				continue;
			port = g_strconcat("/dev/", dev_name, NULL);
			ret = probe_port(port, &devices);
			g_free(port);
			if (ret == SR_ERR_MALLOC) {
				g_dir_close(dir);
				return NULL;
			}
		}
		g_dir_close(dir);
	}

	/* Tack a copy of the newly found devices onto the driver list. */
	l = g_slist_copy(devices);
	drvc->instances = g_slist_concat(drvc->instances, l);

	return devices;
}

static GSList *dev_list(void)
{
	return ((struct drv_context *)(di->priv))->instances;
}

static int dev_open(struct sr_dev_inst *sdi)
{

	if (serial_open(sdi->conn, SERIAL_RDWR) != SR_OK)
		return SR_ERR;

	if (rigol_ds_get_dev_cfg(sdi) != SR_OK)
		return SR_ERR;

	sdi->status = SR_ST_ACTIVE;

	return SR_OK;
}

static int dev_close(struct sr_dev_inst *sdi)
{
	struct sr_serial_dev_inst *serial;

	serial = sdi->conn;
	if (serial && serial->fd != -1) {
		serial_close(serial);
		sdi->status = SR_ST_INACTIVE;
	}

	return SR_OK;
}

static int cleanup(void)
{
	return dev_clear();
}

static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
		const struct sr_probe_group *probe_group)
{
	struct dev_context *devc;
	unsigned int i;

	if (!sdi || !(devc = sdi->priv))
		return SR_ERR_ARG;

	/* If a probe group is specified, it must be a valid one. */
	if (probe_group) {
		if (probe_group != &devc->analog_groups[0]
				&& probe_group != &devc->analog_groups[1]) {
			sr_err("Invalid probe group specified.");
			return SR_ERR;
		}
	}

	switch (id) {
	case SR_CONF_NUM_TIMEBASE:
		*data = g_variant_new_int32(NUM_TIMEBASE);
		break;
	case SR_CONF_NUM_VDIV:
		if (!probe_group) {
			sr_err("No probe group specified.");
			return SR_ERR_PROBE_GROUP;
		}
		for (i = 0; i < 2; i++) {
			if (probe_group == &devc->analog_groups[i]) {
				*data = g_variant_new_int32(NUM_VDIV);
				return SR_OK;
			}
		}
		return SR_ERR_NA;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
		const struct sr_probe_group *probe_group)
{
	struct dev_context *devc;
	uint64_t tmp_u64, p, q;
	double t_dbl;
	unsigned int i, j;
	int ret;
	const char *tmp_str;

	if (!(devc = sdi->priv))
		return SR_ERR_ARG;

	if (sdi->status != SR_ST_ACTIVE)
		return SR_ERR_DEV_CLOSED;

	/* If a probe group is specified, it must be a valid one. */
	if (probe_group) {
		if (probe_group != &devc->analog_groups[0]
				&& probe_group != &devc->analog_groups[1]) {
			sr_err("Invalid probe group specified.");
			return SR_ERR;
		}
	}

	ret = SR_OK;
	switch (id) {
	case SR_CONF_LIMIT_FRAMES:
		devc->limit_frames = g_variant_get_uint64(data);
		break;
	case SR_CONF_TRIGGER_SLOPE:
		tmp_u64 = g_variant_get_uint64(data);
		if (tmp_u64 != 0 && tmp_u64 != 1)
			return SR_ERR;
		g_free(devc->trigger_slope);
		devc->trigger_slope = g_strdup(tmp_u64 ? "POS" : "NEG");
		ret = set_cfg(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
		break;
	case SR_CONF_HORIZ_TRIGGERPOS:
		t_dbl = g_variant_get_double(data);
		if (t_dbl < 0.0 || t_dbl > 1.0)
			return SR_ERR;
		devc->horiz_triggerpos = t_dbl;
		/* We have the trigger offset as a percentage of the frame, but
		 * need to express this in seconds. */
		t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * NUM_TIMEBASE;
		ret = set_cfg(sdi, ":TIM:OFFS %.6f", t_dbl);
		break;
	case SR_CONF_TIMEBASE:
		g_variant_get(data, "(tt)", &p, &q);
		for (i = 0; i < ARRAY_SIZE(timebases); i++) {
			if (timebases[i][0] == p && timebases[i][1] == q) {
				devc->timebase = (float)p / q;
				ret = set_cfg(sdi, ":TIM:SCAL %.9f", devc->timebase);
				break;
			}
		}
		if (i == ARRAY_SIZE(timebases))
			ret = SR_ERR_ARG;
		break;
	case SR_CONF_TRIGGER_SOURCE:
		tmp_str = g_variant_get_string(data, NULL);
		for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
			if (!strcmp(trigger_sources[i], tmp_str)) {
				g_free(devc->trigger_source);
				devc->trigger_source = g_strdup(trigger_sources[i]);
				if (!strcmp(devc->trigger_source, "AC Line"))
					tmp_str = "ACL";
				else if (!strcmp(devc->trigger_source, "CH1"))
					tmp_str = "CHAN1";
				else if (!strcmp(devc->trigger_source, "CH2"))
					tmp_str = "CHAN2";
				else
					tmp_str = (char *)devc->trigger_source;
				ret = set_cfg(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
				break;
			}
		}
		if (i == ARRAY_SIZE(trigger_sources))
			ret = SR_ERR_ARG;
		break;
	case SR_CONF_VDIV:
		if (!probe_group) {
			sr_err("No probe group specified.");
			return SR_ERR_PROBE_GROUP;
		}
		g_variant_get(data, "(tt)", &p, &q);
		for (i = 0; i < 2; i++) {
			if (probe_group == &devc->analog_groups[i]) {
				for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
					if (vdivs[j][0] != p || vdivs[j][1] != q)
						continue;
					devc->vdiv[i] = (float)p / q;
					return set_cfg(sdi, ":CHAN%d:SCAL %.3f", i + 1,
							devc->vdiv[i]);
				}
				return SR_ERR_ARG;
			}
		}
		return SR_ERR_NA;
	case SR_CONF_COUPLING:
		if (!probe_group) {
			sr_err("No probe group specified.");
			return SR_ERR_PROBE_GROUP;
		}
		tmp_str = g_variant_get_string(data, NULL);
		for (i = 0; i < 2; i++) {
			if (probe_group == &devc->analog_groups[i]) {
				for (j = 0; j < ARRAY_SIZE(coupling); j++) {
					if (!strcmp(tmp_str, coupling[j])) {
						g_free(devc->coupling[i]);
						devc->coupling[i] = g_strdup(coupling[j]);
						return set_cfg(sdi, ":CHAN%d:COUP %s", i + 1,
								devc->coupling[i]);
					}
				}
				return SR_ERR_ARG;
			}
		}
		return SR_ERR_NA;
	default:
		ret = SR_ERR_NA;
		break;
	}

	return ret;
}

static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
		const struct sr_probe_group *probe_group)
{
	GVariant *tuple, *rational[2];
	GVariantBuilder gvb;
	unsigned int i;
	struct dev_context *devc;

	if (key == SR_CONF_SCAN_OPTIONS) {
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
				hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
		return SR_OK;
	} else if (key == SR_CONF_DEVICE_OPTIONS && probe_group == NULL) {
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
			hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
		return SR_OK;
	}

	/* Every other option requires a valid device instance. */
	if (!sdi || !(devc = sdi->priv))
		return SR_ERR_ARG;

	/* If a probe group is specified, it must be a valid one. */
	if (probe_group) {
		if (probe_group != &devc->analog_groups[0]
				&& probe_group != &devc->analog_groups[1]) {
			sr_err("Invalid probe group specified.");
			return SR_ERR;
		}
	}

	switch (key) {
		break;
	case SR_CONF_DEVICE_OPTIONS:
		if (!probe_group) {
			sr_err("No probe group specified.");
			return SR_ERR_PROBE_GROUP;
		}
		if (probe_group == &devc->digital_group) {
			*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
				NULL, 0, sizeof(int32_t));
			return SR_OK;
		} else {
			for (i = 0; i < 2; i++) {
				if (probe_group == &devc->analog_groups[i]) {
					*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
						analog_hwcaps, ARRAY_SIZE(analog_hwcaps), sizeof(int32_t));
					return SR_OK;
				}
			}
			return SR_ERR_NA;
		}
		break;
	case SR_CONF_COUPLING:
		if (!probe_group) {
			sr_err("No probe group specified.");
			return SR_ERR_PROBE_GROUP;
		}
		*data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
		break;
	case SR_CONF_VDIV:
		if (!probe_group) {
			sr_err("No probe group specified.");
			return SR_ERR_PROBE_GROUP;
		}
		g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
		for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
			rational[0] = g_variant_new_uint64(vdivs[i][0]);
			rational[1] = g_variant_new_uint64(vdivs[i][1]);
			tuple = g_variant_new_tuple(rational, 2);
			g_variant_builder_add_value(&gvb, tuple);
		}
		*data = g_variant_builder_end(&gvb);
		break;
	case SR_CONF_TIMEBASE:
		g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
		for (i = 0; i < ARRAY_SIZE(timebases); i++) {
			rational[0] = g_variant_new_uint64(timebases[i][0]);
			rational[1] = g_variant_new_uint64(timebases[i][1]);
			tuple = g_variant_new_tuple(rational, 2);
			g_variant_builder_add_value(&gvb, tuple);
		}
		*data = g_variant_builder_end(&gvb);
		break;
	case SR_CONF_TRIGGER_SOURCE:
		*data = g_variant_new_strv(trigger_sources,
				devc->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
	struct sr_serial_dev_inst *serial;
	struct dev_context *devc;
	struct sr_probe *probe;
	GSList *l;
	char cmd[256];

	if (sdi->status != SR_ST_ACTIVE)
		return SR_ERR_DEV_CLOSED;

	serial = sdi->conn;
	devc = sdi->priv;

	for (l = sdi->probes; l; l = l->next) {
		probe = l->data;
		sr_dbg("handling probe %s", probe->name);
		if (probe->type == SR_PROBE_ANALOG) {
			if (probe->enabled)
				devc->enabled_analog_probes = g_slist_append(
						devc->enabled_analog_probes, probe);
			if (probe->enabled != devc->analog_channels[probe->index]) {
				/* Enabled channel is currently disabled, or vice versa. */
				sprintf(cmd, ":CHAN%d:DISP %s", probe->index + 1,
						probe->enabled ? "ON" : "OFF");
				if (rigol_ds_send(sdi, cmd) != SR_OK)
					return SR_ERR;
			}
		} else if (probe->type == SR_PROBE_LOGIC) {
			if (probe->enabled)
				devc->enabled_digital_probes = g_slist_append(
						devc->enabled_digital_probes, probe);
			if (probe->enabled != devc->digital_channels[probe->index]) {
				/* Enabled channel is currently disabled, or vice versa. */
				sprintf(cmd, ":DIG%d:TURN %s", probe->index,
						probe->enabled ? "ON" : "OFF");
				if (rigol_ds_send(sdi, cmd) != SR_OK)
					return SR_ERR;
			}
		}
	}
	if (!devc->enabled_analog_probes && !devc->enabled_digital_probes)
		return SR_ERR;

	sr_source_add(serial->fd, G_IO_IN, 50, rigol_ds_receive, (void *)sdi);

	/* Send header packet to the session bus. */
	std_session_send_df_header(cb_data, LOG_PREFIX);

	/* Fetch the first frame. */
	if (devc->enabled_analog_probes) {
		devc->channel_frame = devc->enabled_analog_probes->data;
		if (rigol_ds_send(sdi, ":WAV:DATA? CHAN%d",
				devc->channel_frame->index + 1) != SR_OK)
			return SR_ERR;
	} else {
		devc->channel_frame = devc->enabled_digital_probes->data;
		if (rigol_ds_send(sdi, ":WAV:DATA? DIG") != SR_OK)
			return SR_ERR;
	}

	devc->num_frame_bytes = 0;

	return SR_OK;
}

static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
{
	struct dev_context *devc;
	struct sr_serial_dev_inst *serial;

	(void)cb_data;

	devc = sdi->priv;

	if (sdi->status != SR_ST_ACTIVE) {
		sr_err("Device inactive, can't stop acquisition.");
		return SR_ERR;
	}

	g_slist_free(devc->enabled_analog_probes);
	g_slist_free(devc->enabled_digital_probes);
	devc->enabled_analog_probes = NULL;
	devc->enabled_digital_probes = NULL;
	serial = sdi->conn;
	sr_source_remove(serial->fd);

	return SR_OK;
}

SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
	.name = "rigol-ds",
	.longname = "Rigol DS",
	.api_version = 1,
	.init = init,
	.cleanup = cleanup,
	.scan = scan,
	.dev_list = dev_list,
	.dev_clear = dev_clear,
	.config_get = config_get,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = dev_open,
	.dev_close = dev_close,
	.dev_acquisition_start = dev_acquisition_start,
	.dev_acquisition_stop = dev_acquisition_stop,
	.priv = NULL,
};
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2012 Martin Ling <martin-git@earth.li>
	5	* Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
	6	*
	7	* This program is free software: you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation, either version 3 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include <fcntl.h>
	22	#include <unistd.h>
	23	#include <stdlib.h>
	24	#include <string.h>
	25	#include <glib.h>
	26	#include "libsigrok.h"
	27	#include "libsigrok-internal.h"
	28	#include "protocol.h"
	29
	30	#define NUM_TIMEBASE 12
	31	#define NUM_VDIV 8
	32
	33	static const int32_t hwopts[] = {
	34	SR_CONF_CONN,
	35	};
	36
	37	static const int32_t hwcaps[] = {
	38	SR_CONF_OSCILLOSCOPE,
	39	SR_CONF_TIMEBASE,
	40	SR_CONF_TRIGGER_SOURCE,
	41	SR_CONF_TRIGGER_SLOPE,
	42	SR_CONF_HORIZ_TRIGGERPOS,
	43	SR_CONF_NUM_TIMEBASE,
	44	};
	45
	46	static const int32_t analog_hwcaps[] = {
	47	SR_CONF_NUM_VDIV,
	48	SR_CONF_VDIV,
	49	SR_CONF_COUPLING,
	50	};
	51
	52	static const uint64_t timebases[][2] = {
	53	/* nanoseconds */
	54	{ 2, 1000000000 },
	55	{ 5, 1000000000 },
	56	{ 10, 1000000000 },
	57	{ 20, 1000000000 },
	58	{ 50, 1000000000 },
	59	{ 100, 1000000000 },
	60	{ 500, 1000000000 },
	61	/* microseconds */
	62	{ 1, 1000000 },
	63	{ 2, 1000000 },
	64	{ 5, 1000000 },
	65	{ 10, 1000000 },
	66	{ 20, 1000000 },
	67	{ 50, 1000000 },
	68	{ 100, 1000000 },
	69	{ 200, 1000000 },
	70	{ 500, 1000000 },
	71	/* milliseconds */
	72	{ 1, 1000 },
	73	{ 2, 1000 },
	74	{ 5, 1000 },
	75	{ 10, 1000 },
	76	{ 20, 1000 },
	77	{ 50, 1000 },
	78	{ 100, 1000 },
	79	{ 200, 1000 },
	80	{ 500, 1000 },
	81	/* seconds */
	82	{ 1, 1 },
	83	{ 2, 1 },
	84	{ 5, 1 },
	85	{ 10, 1 },
	86	{ 20, 1 },
	87	{ 50, 1 },
	88	};
	89
	90	static const uint64_t vdivs[][2] = {
	91	/* millivolts */
	92	{ 2, 1000 },
	93	{ 5, 1000 },
	94	{ 10, 1000 },
	95	{ 20, 1000 },
	96	{ 50, 1000 },
	97	{ 100, 1000 },
	98	{ 200, 1000 },
	99	{ 500, 1000 },
	100	/* volts */
	101	{ 1, 1 },
	102	{ 2, 1 },
	103	{ 5, 1 },
	104	{ 10, 1 },
	105	};
	106
	107	static const char *trigger_sources[] = {
	108	"CH1",
	109	"CH2",
	110	"EXT",
	111	"AC Line",
	112	"D0",
	113	"D1",
	114	"D2",
	115	"D3",
	116	"D4",
	117	"D5",
	118	"D6",
	119	"D7",
	120	"D8",
	121	"D9",
	122	"D10",
	123	"D11",
	124	"D12",
	125	"D13",
	126	"D14",
	127	"D15",
	128	};
	129
	130	static const char *coupling[] = {
	131	"AC",
	132	"DC",
	133	"GND",
	134	};
	135
	136	static const char *supported_models[] = {
	137	"DS1052E",
	138	"DS1102E",
	139	"DS1152E",
	140	"DS1052D",
	141	"DS1102D",
	142	"DS1152D",
	143	};
	144
	145	SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
	146	static struct sr_dev_driver *di = &rigol_ds_driver_info;
	147
	148	static void clear_helper(void *priv)
	149	{
	150	struct dev_context *devc;
	151
	152	devc = priv;
	153	g_free(devc->coupling[0]);
	154	g_free(devc->coupling[1]);
	155	g_free(devc->trigger_source);
	156	g_free(devc->trigger_slope);
	157	g_slist_free(devc->analog_groups[0].probes);
	158	g_slist_free(devc->analog_groups[1].probes);
	159	g_slist_free(devc->digital_group.probes);
	160	}
	161
	162	static int dev_clear(void)
	163	{
	164	return std_dev_clear(di, clear_helper);
	165	}
	166
	167	static int set_cfg(const struct sr_dev_inst sdi, const char format, ...)
	168	{
	169	va_list args;
	170	char buf[256];
	171
	172	va_start(args, format);
	173	vsnprintf(buf, 255, format, args);
	174	va_end(args);
	175	if (rigol_ds_send(sdi, buf) != SR_OK)
	176	return SR_ERR;
	177
	178	/* When setting a bunch of parameters in a row, the DS1052E scrambles
	179	* some of them unless there is at least 100ms delay in between. */
	180	sr_spew("delay %dms", 100);
	181	g_usleep(100000);
	182
	183	return SR_OK;
	184	}
	185
	186	static int init(struct sr_context *sr_ctx)
	187	{
	188	return std_init(sr_ctx, di, LOG_PREFIX);
	189	}
	190
	191	static int probe_port(const char port, GSList *devices)
	192	{
	193	struct dev_context *devc;
	194	struct sr_dev_inst *sdi;
	195	struct sr_serial_dev_inst *serial;
	196	struct sr_probe *probe;
	197	unsigned int i;
	198	int len, num_tokens;
	199	gboolean matched, has_digital;
	200	const char manufacturer, model, *version;
	201	char buf[256];
	202	gchar *tokens, channel_name;
	203
	204	*devices = NULL;
	205	if (!(serial = sr_serial_dev_inst_new(port, NULL)))
	206	return SR_ERR_MALLOC;
	207
	208	if (serial_open(serial, SERIAL_RDWR) != SR_OK)
	209	return SR_ERR;
	210	len = serial_write(serial, "*IDN?", 5);
	211	len = serial_read(serial, buf, sizeof(buf));
	212	if (serial_close(serial) != SR_OK)
	213	return SR_ERR;
	214
	215	sr_serial_dev_inst_free(serial);
	216
	217	if (len == 0)
	218	return SR_ERR_NA;
	219
	220	buf[len] = 0;
	221	tokens = g_strsplit(buf, ",", 0);
	222	sr_dbg("response: %s [%s]", port, buf);
	223
	224	for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++);
	225
	226	if (num_tokens < 4) {
	227	g_strfreev(tokens);
	228	return SR_ERR_NA;
	229	}
	230
	231	manufacturer = tokens[0];
	232	model = tokens[1];
	233	version = tokens[3];
	234
	235	if (strcmp(manufacturer, "Rigol Technologies")) {
	236	g_strfreev(tokens);
	237	return SR_ERR_NA;
	238	}
	239
	240	matched = has_digital = FALSE;
	241	for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
	242	if (!strcmp(model, supported_models[i])) {
	243	matched = TRUE;
	244	has_digital = g_str_has_suffix(model, "D");
	245	break;
	246	}
	247	}
	248
	249	if (!matched \|\| !(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE,
	250	manufacturer, model, version))) {
	251	g_strfreev(tokens);
	252	return SR_ERR_NA;
	253	}
	254
	255	g_strfreev(tokens);
	256
	257	if (!(sdi->conn = sr_serial_dev_inst_new(port, NULL)))
	258	return SR_ERR_MALLOC;
	259	sdi->driver = di;
	260	sdi->inst_type = SR_INST_SERIAL;
	261
	262	if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
	263	return SR_ERR_MALLOC;
	264	devc->limit_frames = 0;
	265	devc->has_digital = has_digital;
	266
	267	for (i = 0; i < 2; i++) {
	268	channel_name = (i == 0 ? "CH1" : "CH2");
	269	if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, channel_name)))
	270	return SR_ERR_MALLOC;
	271	sdi->probes = g_slist_append(sdi->probes, probe);
	272	devc->analog_groups[i].name = channel_name;
	273	devc->analog_groups[i].probes = g_slist_append(NULL, probe);
	274	sdi->probe_groups = g_slist_append(sdi->probe_groups,
	275	&devc->analog_groups[i]);
	276	}
	277
	278	if (devc->has_digital) {
	279	for (i = 0; i < 16; i++) {
	280	if (!(channel_name = g_strdup_printf("D%d", i)))
	281	return SR_ERR_MALLOC;
	282	probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name);
	283	g_free(channel_name);
	284	if (!probe)
	285	return SR_ERR_MALLOC;
	286	sdi->probes = g_slist_append(sdi->probes, probe);
	287	devc->digital_group.probes = g_slist_append(
	288	devc->digital_group.probes, probe);
	289	devc->digital_group.name = "LA";
	290	sdi->probe_groups = g_slist_append(sdi->probe_groups,
	291	&devc->digital_group);
	292	}
	293	}
	294	sdi->priv = devc;
	295
	296	*devices = g_slist_append(NULL, sdi);
	297
	298	return SR_OK;
	299	}
	300
	301	static GSList scan(GSList options)
	302	{
	303	struct drv_context *drvc;
	304	struct sr_config *src;
	305	GSList l, devices;
	306	GDir *dir;
	307	int ret;
	308	const gchar *dev_name;
	309	gchar *port = NULL;
	310
	311	drvc = di->priv;
	312
	313	for (l = options; l; l = l->next) {
	314	src = l->data;
	315	if (src->key == SR_CONF_CONN) {
	316	port = (char *)g_variant_get_string(src->data, NULL);
	317	break;
	318	}
	319	}
	320
	321	devices = NULL;
	322	if (port) {
	323	if (probe_port(port, &devices) == SR_ERR_MALLOC)
	324	return NULL;
	325	} else {
	326	if (!(dir = g_dir_open("/sys/class/usbmisc/", 0, NULL)))
	327	if (!(dir = g_dir_open("/sys/class/usb/", 0, NULL)))
	328	return NULL;
	329	while ((dev_name = g_dir_read_name(dir))) {
	330	if (strncmp(dev_name, "usbtmc", 6))
	331	continue;
	332	port = g_strconcat("/dev/", dev_name, NULL);
	333	ret = probe_port(port, &devices);
	334	g_free(port);
	335	if (ret == SR_ERR_MALLOC) {
	336	g_dir_close(dir);
	337	return NULL;
	338	}
	339	}
	340	g_dir_close(dir);
	341	}
	342
	343	/* Tack a copy of the newly found devices onto the driver list. */
	344	l = g_slist_copy(devices);
	345	drvc->instances = g_slist_concat(drvc->instances, l);
	346
	347	return devices;
	348	}
	349
	350	static GSList *dev_list(void)
	351	{
	352	return ((struct drv_context *)(di->priv))->instances;
	353	}
	354
	355	static int dev_open(struct sr_dev_inst *sdi)
	356	{
	357
	358	if (serial_open(sdi->conn, SERIAL_RDWR) != SR_OK)
	359	return SR_ERR;
	360
	361	if (rigol_ds_get_dev_cfg(sdi) != SR_OK)
	362	return SR_ERR;
	363
	364	sdi->status = SR_ST_ACTIVE;
	365
	366	return SR_OK;
	367	}
	368
	369	static int dev_close(struct sr_dev_inst *sdi)
	370	{
	371	struct sr_serial_dev_inst *serial;
	372
	373	serial = sdi->conn;
	374	if (serial && serial->fd != -1) {
	375	serial_close(serial);
	376	sdi->status = SR_ST_INACTIVE;
	377	}
	378
	379	return SR_OK;
	380	}
	381
	382	static int cleanup(void)
	383	{
	384	return dev_clear();
	385	}
	386
	387	static int config_get(int id, GVariant *data, const struct sr_dev_inst sdi,
	388	const struct sr_probe_group *probe_group)
	389	{
	390	struct dev_context *devc;
	391	unsigned int i;
	392
	393	if (!sdi \|\| !(devc = sdi->priv))
	394	return SR_ERR_ARG;
	395
	396	/* If a probe group is specified, it must be a valid one. */
	397	if (probe_group) {
	398	if (probe_group != &devc->analog_groups[0]
	399	&& probe_group != &devc->analog_groups[1]) {
	400	sr_err("Invalid probe group specified.");
	401	return SR_ERR;
	402	}
	403	}
	404
	405	switch (id) {
	406	case SR_CONF_NUM_TIMEBASE:
	407	*data = g_variant_new_int32(NUM_TIMEBASE);
	408	break;
	409	case SR_CONF_NUM_VDIV:
	410	if (!probe_group) {
	411	sr_err("No probe group specified.");
	412	return SR_ERR_PROBE_GROUP;
	413	}
	414	for (i = 0; i < 2; i++) {
	415	if (probe_group == &devc->analog_groups[i]) {
	416	*data = g_variant_new_int32(NUM_VDIV);
	417	return SR_OK;
	418	}
	419	}
	420	return SR_ERR_NA;
	421	default:
	422	return SR_ERR_NA;
	423	}
	424
	425	return SR_OK;
	426	}
	427
	428	static int config_set(int id, GVariant data, const struct sr_dev_inst sdi,
	429	const struct sr_probe_group *probe_group)
	430	{
	431	struct dev_context *devc;
	432	uint64_t tmp_u64, p, q;
	433	double t_dbl;
	434	unsigned int i, j;
	435	int ret;
	436	const char *tmp_str;
	437
	438	if (!(devc = sdi->priv))
	439	return SR_ERR_ARG;
	440
	441	if (sdi->status != SR_ST_ACTIVE)
	442	return SR_ERR_DEV_CLOSED;
	443
	444	/* If a probe group is specified, it must be a valid one. */
	445	if (probe_group) {
	446	if (probe_group != &devc->analog_groups[0]
	447	&& probe_group != &devc->analog_groups[1]) {
	448	sr_err("Invalid probe group specified.");
	449	return SR_ERR;
	450	}
	451	}
	452
	453	ret = SR_OK;
	454	switch (id) {
	455	case SR_CONF_LIMIT_FRAMES:
	456	devc->limit_frames = g_variant_get_uint64(data);
	457	break;
	458	case SR_CONF_TRIGGER_SLOPE:
	459	tmp_u64 = g_variant_get_uint64(data);
	460	if (tmp_u64 != 0 && tmp_u64 != 1)
	461	return SR_ERR;
	462	g_free(devc->trigger_slope);
	463	devc->trigger_slope = g_strdup(tmp_u64 ? "POS" : "NEG");
	464	ret = set_cfg(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
	465	break;
	466	case SR_CONF_HORIZ_TRIGGERPOS:
	467	t_dbl = g_variant_get_double(data);
	468	if (t_dbl < 0.0 \|\| t_dbl > 1.0)
	469	return SR_ERR;
	470	devc->horiz_triggerpos = t_dbl;
	471	/* We have the trigger offset as a percentage of the frame, but
	472	* need to express this in seconds. */
	473	t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * NUM_TIMEBASE;
	474	ret = set_cfg(sdi, ":TIM:OFFS %.6f", t_dbl);
	475	break;
	476	case SR_CONF_TIMEBASE:
	477	g_variant_get(data, "(tt)", &p, &q);
	478	for (i = 0; i < ARRAY_SIZE(timebases); i++) {
	479	if (timebases[i][0] == p && timebases[i][1] == q) {
	480	devc->timebase = (float)p / q;
	481	ret = set_cfg(sdi, ":TIM:SCAL %.9f", devc->timebase);
	482	break;
	483	}
	484	}
	485	if (i == ARRAY_SIZE(timebases))
	486	ret = SR_ERR_ARG;
	487	break;
	488	case SR_CONF_TRIGGER_SOURCE:
	489	tmp_str = g_variant_get_string(data, NULL);
	490	for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
	491	if (!strcmp(trigger_sources[i], tmp_str)) {
	492	g_free(devc->trigger_source);
	493	devc->trigger_source = g_strdup(trigger_sources[i]);
	494	if (!strcmp(devc->trigger_source, "AC Line"))
	495	tmp_str = "ACL";
	496	else if (!strcmp(devc->trigger_source, "CH1"))
	497	tmp_str = "CHAN1";
	498	else if (!strcmp(devc->trigger_source, "CH2"))
	499	tmp_str = "CHAN2";
	500	else
	501	tmp_str = (char *)devc->trigger_source;
	502	ret = set_cfg(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
	503	break;
	504	}
	505	}
	506	if (i == ARRAY_SIZE(trigger_sources))
	507	ret = SR_ERR_ARG;
	508	break;
	509	case SR_CONF_VDIV:
	510	if (!probe_group) {
	511	sr_err("No probe group specified.");
	512	return SR_ERR_PROBE_GROUP;
	513	}
	514	g_variant_get(data, "(tt)", &p, &q);
	515	for (i = 0; i < 2; i++) {
	516	if (probe_group == &devc->analog_groups[i]) {
	517	for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
	518	if (vdivs[j][0] != p \|\| vdivs[j][1] != q)
	519	continue;
	520	devc->vdiv[i] = (float)p / q;
	521	return set_cfg(sdi, ":CHAN%d:SCAL %.3f", i + 1,
	522	devc->vdiv[i]);
	523	}
	524	return SR_ERR_ARG;
	525	}
	526	}
	527	return SR_ERR_NA;
	528	case SR_CONF_COUPLING:
	529	if (!probe_group) {
	530	sr_err("No probe group specified.");
	531	return SR_ERR_PROBE_GROUP;
	532	}
	533	tmp_str = g_variant_get_string(data, NULL);
	534	for (i = 0; i < 2; i++) {
	535	if (probe_group == &devc->analog_groups[i]) {
	536	for (j = 0; j < ARRAY_SIZE(coupling); j++) {
	537	if (!strcmp(tmp_str, coupling[j])) {
	538	g_free(devc->coupling[i]);
	539	devc->coupling[i] = g_strdup(coupling[j]);
	540	return set_cfg(sdi, ":CHAN%d:COUP %s", i + 1,
	541	devc->coupling[i]);
	542	}
	543	}
	544	return SR_ERR_ARG;
	545	}
	546	}
	547	return SR_ERR_NA;
	548	default:
	549	ret = SR_ERR_NA;
	550	break;
	551	}
	552
	553	return ret;
	554	}
	555
	556	static int config_list(int key, GVariant *data, const struct sr_dev_inst sdi,
	557	const struct sr_probe_group *probe_group)
	558	{
	559	GVariant tuple, rational[2];
	560	GVariantBuilder gvb;
	561	unsigned int i;
	562	struct dev_context *devc;
	563
	564	if (key == SR_CONF_SCAN_OPTIONS) {
	565	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
	566	hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
	567	return SR_OK;
	568	} else if (key == SR_CONF_DEVICE_OPTIONS && probe_group == NULL) {
	569	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
	570	hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
	571	return SR_OK;
	572	}
	573
	574	/* Every other option requires a valid device instance. */
	575	if (!sdi \|\| !(devc = sdi->priv))
	576	return SR_ERR_ARG;
	577
	578	/* If a probe group is specified, it must be a valid one. */
	579	if (probe_group) {
	580	if (probe_group != &devc->analog_groups[0]
	581	&& probe_group != &devc->analog_groups[1]) {
	582	sr_err("Invalid probe group specified.");
	583	return SR_ERR;
	584	}
	585	}
	586
	587	switch (key) {
	588	break;
	589	case SR_CONF_DEVICE_OPTIONS:
	590	if (!probe_group) {
	591	sr_err("No probe group specified.");
	592	return SR_ERR_PROBE_GROUP;
	593	}
	594	if (probe_group == &devc->digital_group) {
	595	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
	596	NULL, 0, sizeof(int32_t));
	597	return SR_OK;
	598	} else {
	599	for (i = 0; i < 2; i++) {
	600	if (probe_group == &devc->analog_groups[i]) {
	601	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
	602	analog_hwcaps, ARRAY_SIZE(analog_hwcaps), sizeof(int32_t));
	603	return SR_OK;
	604	}
	605	}
	606	return SR_ERR_NA;
	607	}
	608	break;
	609	case SR_CONF_COUPLING:
	610	if (!probe_group) {
	611	sr_err("No probe group specified.");
	612	return SR_ERR_PROBE_GROUP;
	613	}
	614	*data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
	615	break;
	616	case SR_CONF_VDIV:
	617	if (!probe_group) {
	618	sr_err("No probe group specified.");
	619	return SR_ERR_PROBE_GROUP;
	620	}
	621	g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
	622	for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
	623	rational[0] = g_variant_new_uint64(vdivs[i][0]);
	624	rational[1] = g_variant_new_uint64(vdivs[i][1]);
	625	tuple = g_variant_new_tuple(rational, 2);
	626	g_variant_builder_add_value(&gvb, tuple);
	627	}
	628	*data = g_variant_builder_end(&gvb);
	629	break;
	630	case SR_CONF_TIMEBASE:
	631	g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
	632	for (i = 0; i < ARRAY_SIZE(timebases); i++) {
	633	rational[0] = g_variant_new_uint64(timebases[i][0]);
	634	rational[1] = g_variant_new_uint64(timebases[i][1]);
	635	tuple = g_variant_new_tuple(rational, 2);
	636	g_variant_builder_add_value(&gvb, tuple);
	637	}
	638	*data = g_variant_builder_end(&gvb);
	639	break;
	640	case SR_CONF_TRIGGER_SOURCE:
	641	*data = g_variant_new_strv(trigger_sources,
	642	devc->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
	643	break;
	644	default:
	645	return SR_ERR_NA;
	646	}
	647
	648	return SR_OK;
	649	}
	650
	651	static int dev_acquisition_start(const struct sr_dev_inst sdi, void cb_data)
	652	{
	653	struct sr_serial_dev_inst *serial;
	654	struct dev_context *devc;
	655	struct sr_probe *probe;
	656	GSList *l;
	657	char cmd[256];
	658
	659	if (sdi->status != SR_ST_ACTIVE)
	660	return SR_ERR_DEV_CLOSED;
	661
	662	serial = sdi->conn;
	663	devc = sdi->priv;
	664
	665	for (l = sdi->probes; l; l = l->next) {
	666	probe = l->data;
	667	sr_dbg("handling probe %s", probe->name);
	668	if (probe->type == SR_PROBE_ANALOG) {
	669	if (probe->enabled)
	670	devc->enabled_analog_probes = g_slist_append(
	671	devc->enabled_analog_probes, probe);
	672	if (probe->enabled != devc->analog_channels[probe->index]) {
	673	/* Enabled channel is currently disabled, or vice versa. */
	674	sprintf(cmd, ":CHAN%d:DISP %s", probe->index + 1,
	675	probe->enabled ? "ON" : "OFF");
	676	if (rigol_ds_send(sdi, cmd) != SR_OK)
	677	return SR_ERR;
	678	}
	679	} else if (probe->type == SR_PROBE_LOGIC) {
	680	if (probe->enabled)
	681	devc->enabled_digital_probes = g_slist_append(
	682	devc->enabled_digital_probes, probe);
	683	if (probe->enabled != devc->digital_channels[probe->index]) {
	684	/* Enabled channel is currently disabled, or vice versa. */
	685	sprintf(cmd, ":DIG%d:TURN %s", probe->index,
	686	probe->enabled ? "ON" : "OFF");
	687	if (rigol_ds_send(sdi, cmd) != SR_OK)
	688	return SR_ERR;
	689	}
	690	}
	691	}
	692	if (!devc->enabled_analog_probes && !devc->enabled_digital_probes)
	693	return SR_ERR;
	694
	695	sr_source_add(serial->fd, G_IO_IN, 50, rigol_ds_receive, (void *)sdi);
	696
	697	/* Send header packet to the session bus. */
	698	std_session_send_df_header(cb_data, LOG_PREFIX);
	699
	700	/* Fetch the first frame. */
	701	if (devc->enabled_analog_probes) {
	702	devc->channel_frame = devc->enabled_analog_probes->data;
	703	if (rigol_ds_send(sdi, ":WAV:DATA? CHAN%d",
	704	devc->channel_frame->index + 1) != SR_OK)
	705	return SR_ERR;
	706	} else {
	707	devc->channel_frame = devc->enabled_digital_probes->data;
	708	if (rigol_ds_send(sdi, ":WAV:DATA? DIG") != SR_OK)
	709	return SR_ERR;
	710	}
	711
	712	devc->num_frame_bytes = 0;
	713
	714	return SR_OK;
	715	}
	716
	717	static int dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
	718	{
	719	struct dev_context *devc;
	720	struct sr_serial_dev_inst *serial;
	721
	722	(void)cb_data;
	723
	724	devc = sdi->priv;
	725
	726	if (sdi->status != SR_ST_ACTIVE) {
	727	sr_err("Device inactive, can't stop acquisition.");
	728	return SR_ERR;
	729	}
	730
	731	g_slist_free(devc->enabled_analog_probes);
	732	g_slist_free(devc->enabled_digital_probes);
	733	devc->enabled_analog_probes = NULL;
	734	devc->enabled_digital_probes = NULL;
	735	serial = sdi->conn;
	736	sr_source_remove(serial->fd);
	737
	738	return SR_OK;
	739	}
	740
	741	SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
	742	.name = "rigol-ds",
	743	.longname = "Rigol DS",
	744	.api_version = 1,
	745	.init = init,
	746	.cleanup = cleanup,
	747	.scan = scan,
	748	.dev_list = dev_list,
	749	.dev_clear = dev_clear,
	750	.config_get = config_get,
	751	.config_set = config_set,
	752	.config_list = config_list,
	753	.dev_open = dev_open,
	754	.dev_close = dev_close,
	755	.dev_acquisition_start = dev_acquisition_start,
	756	.dev_acquisition_stop = dev_acquisition_stop,
	757	.priv = NULL,
	758	};