[libsigrok.git] / hardware / openbench-logic-sniffer / api.c

/*
 * This file is part of the libsigrok project.
 *
 * 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 "protocol.h"

#define SERIALCOMM "115200/8n1"

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

static const int32_t hwcaps[] = {
	SR_CONF_LOGIC_ANALYZER,
	SR_CONF_SAMPLERATE,
	SR_CONF_TRIGGER_TYPE,
	SR_CONF_CAPTURE_RATIO,
	SR_CONF_LIMIT_SAMPLES,
	SR_CONF_RLE,
};

/* Probes are numbered 0-31 (on the PCB silkscreen). */
SR_PRIV const char *ols_probe_names[NUM_PROBES + 1] = {
	"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
	"13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23",
	"24", "25", "26", "27", "28", "29", "30", "31",
	NULL,
};

/* Default supported samplerates, can be overridden by device metadata. */
static const uint64_t samplerates[] = {
	SR_HZ(10),
	SR_MHZ(200),
	SR_HZ(1),
};

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

static int hw_init(struct sr_context *sr_ctx)
{
	return std_hw_init(sr_ctx, di, LOG_PREFIX);
}

static GSList *hw_scan(GSList *options)
{
	struct sr_config *src;
	struct sr_dev_inst *sdi;
	struct drv_context *drvc;
	struct dev_context *devc;
	struct sr_probe *probe;
	struct sr_serial_dev_inst *serial;
	GPollFD probefd;
	GSList *l, *devices;
	int ret, i;
	const char *conn, *serialcomm;
	char buf[8];

	(void)options;

	drvc = di->priv;

	devices = NULL;

	conn = serialcomm = 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_SERIALCOMM:
			serialcomm = g_variant_get_string(src->data, NULL);
			break;
		}
	}
	if (!conn)
		return NULL;

	if (serialcomm == NULL)
		serialcomm = SERIALCOMM;

	if (!(serial = sr_serial_dev_inst_new(conn, serialcomm)))
		return NULL;

	/* The discovery procedure is like this: first send the Reset
	 * command (0x00) 5 times, since the device could be anywhere
	 * in a 5-byte command. Then send the ID command (0x02).
	 * If the device responds with 4 bytes ("OLS1" or "SLA1"), we
	 * have a match.
	 */
	sr_info("Probing %s.", conn);
	if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
		return NULL;

	ret = SR_OK;
	for (i = 0; i < 5; i++) {
		if ((ret = send_shortcommand(serial, CMD_RESET)) != SR_OK) {
			sr_err("Port %s is not writable.", conn);
			break;
		}
	}
	if (ret != SR_OK) {
		serial_close(serial);
		sr_err("Could not use port %s. Quitting.", conn);
		return NULL;
	}
	send_shortcommand(serial, CMD_ID);

	/* Wait 10ms for a response. */
	g_usleep(10000);

	probefd.fd = serial->fd;
	probefd.events = G_IO_IN;
	g_poll(&probefd, 1, 1);

	if (probefd.revents != G_IO_IN)
		return NULL;
	if (serial_read(serial, buf, 4) != 4)
		return NULL;
	if (strncmp(buf, "1SLO", 4) && strncmp(buf, "1ALS", 4))
		return NULL;

	/* Definitely using the OLS protocol, check if it supports
	 * the metadata command.
	 */
	send_shortcommand(serial, CMD_METADATA);
	if (g_poll(&probefd, 1, 10) > 0) {
		/* Got metadata. */
		sdi = get_metadata(serial);
		sdi->index = 0;
		devc = sdi->priv;
	} else {
		/* Not an OLS -- some other board that uses the sump protocol. */
		sr_info("Device does not support metadata.");
		sdi = sr_dev_inst_new(0, SR_ST_INACTIVE,
				"Sump", "Logic Analyzer", "v1.0");
		sdi->driver = di;
		for (i = 0; i < 32; i++) {
			if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
					ols_probe_names[i])))
				return 0;
			sdi->probes = g_slist_append(sdi->probes, probe);
		}
		devc = ols_dev_new();
		sdi->priv = devc;
	}
	/* Configure samplerate and divider. */
	if (ols_set_samplerate(sdi, DEFAULT_SAMPLERATE) != SR_OK)
		sr_dbg("Failed to set default samplerate (%"PRIu64").",
				DEFAULT_SAMPLERATE);
	/* Clear trigger masks, values and stages. */
	ols_configure_probes(sdi);
	sdi->inst_type = SR_INST_SERIAL;
	sdi->conn = serial;

	drvc->instances = g_slist_append(drvc->instances, sdi);
	devices = g_slist_append(devices, sdi);

	serial_close(serial);

	return devices;
}

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

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

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

	sdi->status = SR_ST_ACTIVE;

	return SR_OK;
}

static int hw_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 hw_cleanup(void)
{
	GSList *l;
	struct sr_dev_inst *sdi;
	struct drv_context *drvc;
	struct dev_context *devc;
	struct sr_serial_dev_inst *serial;
	int ret = SR_OK;

	if (!(drvc = di->priv))
		return SR_OK;

	/* Properly close and free all devices. */
	for (l = drvc->instances; l; l = l->next) {
		if (!(sdi = l->data)) {
			/* Log error, but continue cleaning up the rest. */
			sr_err("%s: sdi was NULL, continuing", __func__);
			ret = SR_ERR_BUG;
			continue;
		}
		if (!(devc = sdi->priv)) {
			/* Log error, but continue cleaning up the rest. */
			sr_err("%s: sdi->priv was NULL, continuing", __func__);
			ret = SR_ERR_BUG;
			continue;
		}
		hw_dev_close(sdi);
		serial = sdi->conn;
		sr_serial_dev_inst_free(serial);
		sr_dev_inst_free(sdi);
	}
	g_slist_free(drvc->instances);
	drvc->instances = NULL;

	return ret;
}

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

	if (!sdi)
		return SR_ERR_ARG;

	devc = sdi->priv;
	switch (id) {
	case SR_CONF_SAMPLERATE:
		*data = g_variant_new_uint64(devc->cur_samplerate);
		break;
	case SR_CONF_CAPTURE_RATIO:
		*data = g_variant_new_uint64(devc->capture_ratio);
		break;
	case SR_CONF_LIMIT_SAMPLES:
		*data = g_variant_new_uint64(devc->limit_samples);
		break;
	case SR_CONF_RLE:
		*data = g_variant_new_boolean(devc->flag_reg & FLAG_RLE ? TRUE : FALSE);
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	int ret;
	uint64_t tmp_u64;

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

	devc = sdi->priv;

	switch (id) {
	case SR_CONF_SAMPLERATE:
		tmp_u64 = g_variant_get_uint64(data);
		if (tmp_u64 < samplerates[0] || tmp_u64 > samplerates[1])
			return SR_ERR_SAMPLERATE;
		ret = ols_set_samplerate(sdi, g_variant_get_uint64(data));
		break;
	case SR_CONF_LIMIT_SAMPLES:
		tmp_u64 = g_variant_get_uint64(data);
		if (tmp_u64 < MIN_NUM_SAMPLES)
			return SR_ERR;
		devc->limit_samples = tmp_u64;
		ret = SR_OK;
		break;
	case SR_CONF_CAPTURE_RATIO:
		devc->capture_ratio = g_variant_get_uint64(data);
		if (devc->capture_ratio < 0 || devc->capture_ratio > 100) {
			devc->capture_ratio = 0;
			ret = SR_ERR;
		} else
			ret = SR_OK;
		break;
	case SR_CONF_RLE:
		if (g_variant_get_boolean(data)) {
			sr_info("Enabling RLE.");
			devc->flag_reg |= FLAG_RLE;
		} else {
			sr_info("Disabling RLE.");
			devc->flag_reg &= ~FLAG_RLE;
		}
		ret = SR_OK;
		break;
	default:
		ret = SR_ERR_NA;
	}

	return ret;
}

static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
{
	GVariant *gvar;
	GVariantBuilder gvb;

	(void)sdi;

	switch (key) {
	case SR_CONF_SCAN_OPTIONS:
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
				hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
		break;
	case SR_CONF_DEVICE_OPTIONS:
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
				hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
		break;
	case SR_CONF_SAMPLERATE:
		g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
		gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
				ARRAY_SIZE(samplerates), sizeof(uint64_t));
		g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
		*data = g_variant_builder_end(&gvb);
		break;
	case SR_CONF_TRIGGER_TYPE:
		*data = g_variant_new_string(TRIGGER_TYPE);
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
		void *cb_data)
{
	struct dev_context *devc;
	struct sr_serial_dev_inst *serial;
	uint32_t trigger_config[4];
	uint32_t data;
	uint16_t readcount, delaycount;
	uint8_t changrp_mask;
	int num_channels;
	int i;

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

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

	if (ols_configure_probes(sdi) != SR_OK) {
		sr_err("Failed to configure probes.");
		return SR_ERR;
	}

	/*
	 * Enable/disable channel groups in the flag register according to the
	 * probe mask. Calculate this here, because num_channels is needed
	 * to limit readcount.
	 */
	changrp_mask = 0;
	num_channels = 0;
	for (i = 0; i < 4; i++) {
		if (devc->probe_mask & (0xff << (i * 8))) {
			changrp_mask |= (1 << i);
			num_channels++;
		}
	}

	/*
	 * Limit readcount to prevent reading past the end of the hardware
	 * buffer.
	 */
	readcount = MIN(devc->max_samples / num_channels, devc->limit_samples) / 4;

	memset(trigger_config, 0, 16);
	trigger_config[devc->num_stages] |= 0x08;
	if (devc->trigger_mask[0]) {
		delaycount = readcount * (1 - devc->capture_ratio / 100.0);
		devc->trigger_at = (readcount - delaycount) * 4 - devc->num_stages;

		if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_0,
			reverse32(devc->trigger_mask[0])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_0,
			reverse32(devc->trigger_value[0])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_0,
			trigger_config[0]) != SR_OK)
			return SR_ERR;

		if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_1,
			reverse32(devc->trigger_mask[1])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_1,
			reverse32(devc->trigger_value[1])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_1,
			trigger_config[1]) != SR_OK)
			return SR_ERR;

		if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_2,
			reverse32(devc->trigger_mask[2])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_2,
			reverse32(devc->trigger_value[2])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_2,
			trigger_config[2]) != SR_OK)
			return SR_ERR;

		if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_3,
			reverse32(devc->trigger_mask[3])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_3,
			reverse32(devc->trigger_value[3])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_3,
			trigger_config[3]) != SR_OK)
			return SR_ERR;
	} else {
		if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_0,
				devc->trigger_mask[0]) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_0,
				devc->trigger_value[0]) != SR_OK)
			return SR_ERR;
		if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_0,
		     0x00000008) != SR_OK)
			return SR_ERR;
		delaycount = readcount;
	}

	sr_info("Setting samplerate to %" PRIu64 "Hz (divider %u, "
		"demux %s)", devc->cur_samplerate, devc->cur_samplerate_divider,
		devc->flag_reg & FLAG_DEMUX ? "on" : "off");
	if (send_longcommand(serial, CMD_SET_DIVIDER,
			reverse32(devc->cur_samplerate_divider)) != SR_OK)
		return SR_ERR;

	/* Send sample limit and pre/post-trigger capture ratio. */
	data = ((readcount - 1) & 0xffff) << 16;
	data |= (delaycount - 1) & 0xffff;
	if (send_longcommand(serial, CMD_CAPTURE_SIZE, reverse16(data)) != SR_OK)
		return SR_ERR;

	/* The flag register wants them here, and 1 means "disable channel". */
	devc->flag_reg |= ~(changrp_mask << 2) & 0x3c;
	devc->flag_reg |= FLAG_FILTER;
	devc->rle_count = 0;
	data = (devc->flag_reg << 24) | ((devc->flag_reg << 8) & 0xff0000);
	if (send_longcommand(serial, CMD_SET_FLAGS, data) != SR_OK)
		return SR_ERR;

	/* Start acquisition on the device. */
	if (send_shortcommand(serial, CMD_RUN) != SR_OK)
		return SR_ERR;

	/* Reset all operational states. */
	devc->num_transfers = devc->num_samples = devc->num_bytes = 0;

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

	sr_source_add(serial->fd, G_IO_IN, -1, ols_receive_data, cb_data);

	return SR_OK;
}

static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
{
	/* Avoid compiler warnings. */
	(void)cb_data;

	abort_acquisition(sdi);

	return SR_OK;
}

SR_PRIV struct sr_dev_driver ols_driver_info = {
	.name = "ols",
	.longname = "Openbench Logic Sniffer",
	.api_version = 1,
	.init = hw_init,
	.cleanup = hw_cleanup,
	.scan = hw_scan,
	.dev_list = hw_dev_list,
	.dev_clear = hw_cleanup,
	.config_get = config_get,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = hw_dev_open,
	.dev_close = hw_dev_close,
	.dev_acquisition_start = hw_dev_acquisition_start,
	.dev_acquisition_stop = hw_dev_acquisition_stop,
	.priv = NULL,
};
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include "protocol.h"
	21
	22	#define SERIALCOMM "115200/8n1"
	23
	24	static const int32_t hwopts[] = {
	25	SR_CONF_CONN,
	26	SR_CONF_SERIALCOMM,
	27	};
	28
	29	static const int32_t hwcaps[] = {
	30	SR_CONF_LOGIC_ANALYZER,
	31	SR_CONF_SAMPLERATE,
	32	SR_CONF_TRIGGER_TYPE,
	33	SR_CONF_CAPTURE_RATIO,
	34	SR_CONF_LIMIT_SAMPLES,
	35	SR_CONF_RLE,
	36	};
	37
	38	/* Probes are numbered 0-31 (on the PCB silkscreen). */
	39	SR_PRIV const char *ols_probe_names[NUM_PROBES + 1] = {
	40	"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12",
	41	"13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23",
	42	"24", "25", "26", "27", "28", "29", "30", "31",
	43	NULL,
	44	};
	45
	46	/* Default supported samplerates, can be overridden by device metadata. */
	47	static const uint64_t samplerates[] = {
	48	SR_HZ(10),
	49	SR_MHZ(200),
	50	SR_HZ(1),
	51	};
	52
	53	SR_PRIV struct sr_dev_driver ols_driver_info;
	54	static struct sr_dev_driver *di = &ols_driver_info;
	55
	56	static int hw_init(struct sr_context *sr_ctx)
	57	{
	58	return std_hw_init(sr_ctx, di, LOG_PREFIX);
	59	}
	60
	61	static GSList hw_scan(GSList options)
	62	{
	63	struct sr_config *src;
	64	struct sr_dev_inst *sdi;
	65	struct drv_context *drvc;
	66	struct dev_context *devc;
	67	struct sr_probe *probe;
	68	struct sr_serial_dev_inst *serial;
	69	GPollFD probefd;
	70	GSList l, devices;
	71	int ret, i;
	72	const char conn, serialcomm;
	73	char buf[8];
	74
	75	(void)options;
	76
	77	drvc = di->priv;
	78
	79	devices = NULL;
	80
	81	conn = serialcomm = NULL;
	82	for (l = options; l; l = l->next) {
	83	src = l->data;
	84	switch (src->key) {
	85	case SR_CONF_CONN:
	86	conn = g_variant_get_string(src->data, NULL);
	87	break;
	88	case SR_CONF_SERIALCOMM:
	89	serialcomm = g_variant_get_string(src->data, NULL);
	90	break;
	91	}
	92	}
	93	if (!conn)
	94	return NULL;
	95
	96	if (serialcomm == NULL)
	97	serialcomm = SERIALCOMM;
	98
	99	if (!(serial = sr_serial_dev_inst_new(conn, serialcomm)))
	100	return NULL;
	101
	102	/* The discovery procedure is like this: first send the Reset
	103	* command (0x00) 5 times, since the device could be anywhere
	104	* in a 5-byte command. Then send the ID command (0x02).
	105	* If the device responds with 4 bytes ("OLS1" or "SLA1"), we
	106	* have a match.
	107	*/
	108	sr_info("Probing %s.", conn);
	109	if (serial_open(serial, SERIAL_RDWR \| SERIAL_NONBLOCK) != SR_OK)
	110	return NULL;
	111
	112	ret = SR_OK;
	113	for (i = 0; i < 5; i++) {
	114	if ((ret = send_shortcommand(serial, CMD_RESET)) != SR_OK) {
	115	sr_err("Port %s is not writable.", conn);
	116	break;
	117	}
	118	}
	119	if (ret != SR_OK) {
	120	serial_close(serial);
	121	sr_err("Could not use port %s. Quitting.", conn);
	122	return NULL;
	123	}
	124	send_shortcommand(serial, CMD_ID);
	125
	126	/* Wait 10ms for a response. */
	127	g_usleep(10000);
	128
	129	probefd.fd = serial->fd;
	130	probefd.events = G_IO_IN;
	131	g_poll(&probefd, 1, 1);
	132
	133	if (probefd.revents != G_IO_IN)
	134	return NULL;
	135	if (serial_read(serial, buf, 4) != 4)
	136	return NULL;
	137	if (strncmp(buf, "1SLO", 4) && strncmp(buf, "1ALS", 4))
	138	return NULL;
	139
	140	/* Definitely using the OLS protocol, check if it supports
	141	* the metadata command.
	142	*/
	143	send_shortcommand(serial, CMD_METADATA);
	144	if (g_poll(&probefd, 1, 10) > 0) {
	145	/* Got metadata. */
	146	sdi = get_metadata(serial);
	147	sdi->index = 0;
	148	devc = sdi->priv;
	149	} else {
	150	/* Not an OLS -- some other board that uses the sump protocol. */
	151	sr_info("Device does not support metadata.");
	152	sdi = sr_dev_inst_new(0, SR_ST_INACTIVE,
	153	"Sump", "Logic Analyzer", "v1.0");
	154	sdi->driver = di;
	155	for (i = 0; i < 32; i++) {
	156	if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
	157	ols_probe_names[i])))
	158	return 0;
	159	sdi->probes = g_slist_append(sdi->probes, probe);
	160	}
	161	devc = ols_dev_new();
	162	sdi->priv = devc;
	163	}
	164	/* Configure samplerate and divider. */
	165	if (ols_set_samplerate(sdi, DEFAULT_SAMPLERATE) != SR_OK)
	166	sr_dbg("Failed to set default samplerate (%"PRIu64").",
	167	DEFAULT_SAMPLERATE);
	168	/* Clear trigger masks, values and stages. */
	169	ols_configure_probes(sdi);
	170	sdi->inst_type = SR_INST_SERIAL;
	171	sdi->conn = serial;
	172
	173	drvc->instances = g_slist_append(drvc->instances, sdi);
	174	devices = g_slist_append(devices, sdi);
	175
	176	serial_close(serial);
	177
	178	return devices;
	179	}
	180
	181	static GSList *hw_dev_list(void)
	182	{
	183	return ((struct drv_context *)(di->priv))->instances;
	184	}
	185
	186	static int hw_dev_open(struct sr_dev_inst *sdi)
	187	{
	188	struct sr_serial_dev_inst *serial;
	189
	190	serial = sdi->conn;
	191	if (serial_open(serial, SERIAL_RDWR) != SR_OK)
	192	return SR_ERR;
	193
	194	sdi->status = SR_ST_ACTIVE;
	195
	196	return SR_OK;
	197	}
	198
	199	static int hw_dev_close(struct sr_dev_inst *sdi)
	200	{
	201	struct sr_serial_dev_inst *serial;
	202
	203	serial = sdi->conn;
	204	if (serial && serial->fd != -1) {
	205	serial_close(serial);
	206	sdi->status = SR_ST_INACTIVE;
	207	}
	208
	209	return SR_OK;
	210	}
	211
	212	static int hw_cleanup(void)
	213	{
	214	GSList *l;
	215	struct sr_dev_inst *sdi;
	216	struct drv_context *drvc;
	217	struct dev_context *devc;
	218	struct sr_serial_dev_inst *serial;
	219	int ret = SR_OK;
	220
	221	if (!(drvc = di->priv))
	222	return SR_OK;
	223
	224	/* Properly close and free all devices. */
	225	for (l = drvc->instances; l; l = l->next) {
	226	if (!(sdi = l->data)) {
	227	/* Log error, but continue cleaning up the rest. */
	228	sr_err("%s: sdi was NULL, continuing", __func__);
	229	ret = SR_ERR_BUG;
	230	continue;
	231	}
	232	if (!(devc = sdi->priv)) {
	233	/* Log error, but continue cleaning up the rest. */
	234	sr_err("%s: sdi->priv was NULL, continuing", __func__);
	235	ret = SR_ERR_BUG;
	236	continue;
	237	}
	238	hw_dev_close(sdi);
	239	serial = sdi->conn;
	240	sr_serial_dev_inst_free(serial);
	241	sr_dev_inst_free(sdi);
	242	}
	243	g_slist_free(drvc->instances);
	244	drvc->instances = NULL;
	245
	246	return ret;
	247	}
	248
	249	static int config_get(int id, GVariant *data, const struct sr_dev_inst sdi)
	250	{
	251	struct dev_context *devc;
	252
	253	if (!sdi)
	254	return SR_ERR_ARG;
	255
	256	devc = sdi->priv;
	257	switch (id) {
	258	case SR_CONF_SAMPLERATE:
	259	*data = g_variant_new_uint64(devc->cur_samplerate);
	260	break;
	261	case SR_CONF_CAPTURE_RATIO:
	262	*data = g_variant_new_uint64(devc->capture_ratio);
	263	break;
	264	case SR_CONF_LIMIT_SAMPLES:
	265	*data = g_variant_new_uint64(devc->limit_samples);
	266	break;
	267	case SR_CONF_RLE:
	268	*data = g_variant_new_boolean(devc->flag_reg & FLAG_RLE ? TRUE : FALSE);
	269	break;
	270	default:
	271	return SR_ERR_NA;
	272	}
	273
	274	return SR_OK;
	275	}
	276
	277	static int config_set(int id, GVariant data, const struct sr_dev_inst sdi)
	278	{
	279	struct dev_context *devc;
	280	int ret;
	281	uint64_t tmp_u64;
	282
	283	if (sdi->status != SR_ST_ACTIVE)
	284	return SR_ERR_DEV_CLOSED;
	285
	286	devc = sdi->priv;
	287
	288	switch (id) {
	289	case SR_CONF_SAMPLERATE:
	290	tmp_u64 = g_variant_get_uint64(data);
	291	if (tmp_u64 < samplerates[0] \|\| tmp_u64 > samplerates[1])
	292	return SR_ERR_SAMPLERATE;
	293	ret = ols_set_samplerate(sdi, g_variant_get_uint64(data));
	294	break;
	295	case SR_CONF_LIMIT_SAMPLES:
	296	tmp_u64 = g_variant_get_uint64(data);
	297	if (tmp_u64 < MIN_NUM_SAMPLES)
	298	return SR_ERR;
	299	devc->limit_samples = tmp_u64;
	300	ret = SR_OK;
	301	break;
	302	case SR_CONF_CAPTURE_RATIO:
	303	devc->capture_ratio = g_variant_get_uint64(data);
	304	if (devc->capture_ratio < 0 \|\| devc->capture_ratio > 100) {
	305	devc->capture_ratio = 0;
	306	ret = SR_ERR;
	307	} else
	308	ret = SR_OK;
	309	break;
	310	case SR_CONF_RLE:
	311	if (g_variant_get_boolean(data)) {
	312	sr_info("Enabling RLE.");
	313	devc->flag_reg \|= FLAG_RLE;
	314	} else {
	315	sr_info("Disabling RLE.");
	316	devc->flag_reg &= ~FLAG_RLE;
	317	}
	318	ret = SR_OK;
	319	break;
	320	default:
	321	ret = SR_ERR_NA;
	322	}
	323
	324	return ret;
	325	}
	326
	327	static int config_list(int key, GVariant *data, const struct sr_dev_inst sdi)
	328	{
	329	GVariant *gvar;
	330	GVariantBuilder gvb;
	331
	332	(void)sdi;
	333
	334	switch (key) {
	335	case SR_CONF_SCAN_OPTIONS:
	336	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
	337	hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
	338	break;
	339	case SR_CONF_DEVICE_OPTIONS:
	340	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
	341	hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
	342	break;
	343	case SR_CONF_SAMPLERATE:
	344	g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
	345	gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
	346	ARRAY_SIZE(samplerates), sizeof(uint64_t));
	347	g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
	348	*data = g_variant_builder_end(&gvb);
	349	break;
	350	case SR_CONF_TRIGGER_TYPE:
	351	*data = g_variant_new_string(TRIGGER_TYPE);
	352	break;
	353	default:
	354	return SR_ERR_NA;
	355	}
	356
	357	return SR_OK;
	358	}
	359
	360	static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
	361	void *cb_data)
	362	{
	363	struct dev_context *devc;
	364	struct sr_serial_dev_inst *serial;
	365	uint32_t trigger_config[4];
	366	uint32_t data;
	367	uint16_t readcount, delaycount;
	368	uint8_t changrp_mask;
	369	int num_channels;
	370	int i;
	371
	372	if (sdi->status != SR_ST_ACTIVE)
	373	return SR_ERR_DEV_CLOSED;
	374
	375	devc = sdi->priv;
	376	serial = sdi->conn;
	377
	378	if (ols_configure_probes(sdi) != SR_OK) {
	379	sr_err("Failed to configure probes.");
	380	return SR_ERR;
	381	}
	382
	383	/*
	384	* Enable/disable channel groups in the flag register according to the
	385	* probe mask. Calculate this here, because num_channels is needed
	386	* to limit readcount.
	387	*/
	388	changrp_mask = 0;
	389	num_channels = 0;
	390	for (i = 0; i < 4; i++) {
	391	if (devc->probe_mask & (0xff << (i * 8))) {
	392	changrp_mask \|= (1 << i);
	393	num_channels++;
	394	}
	395	}
	396
	397	/*
	398	* Limit readcount to prevent reading past the end of the hardware
	399	* buffer.
	400	*/
	401	readcount = MIN(devc->max_samples / num_channels, devc->limit_samples) / 4;
	402
	403	memset(trigger_config, 0, 16);
	404	trigger_config[devc->num_stages] \|= 0x08;
	405	if (devc->trigger_mask[0]) {
	406	delaycount = readcount * (1 - devc->capture_ratio / 100.0);
	407	devc->trigger_at = (readcount - delaycount) * 4 - devc->num_stages;
	408
	409	if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_0,
	410	reverse32(devc->trigger_mask[0])) != SR_OK)
	411	return SR_ERR;
	412	if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_0,
	413	reverse32(devc->trigger_value[0])) != SR_OK)
	414	return SR_ERR;
	415	if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_0,
	416	trigger_config[0]) != SR_OK)
	417	return SR_ERR;
	418
	419	if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_1,
	420	reverse32(devc->trigger_mask[1])) != SR_OK)
	421	return SR_ERR;
	422	if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_1,
	423	reverse32(devc->trigger_value[1])) != SR_OK)
	424	return SR_ERR;
	425	if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_1,
	426	trigger_config[1]) != SR_OK)
	427	return SR_ERR;
	428
	429	if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_2,
	430	reverse32(devc->trigger_mask[2])) != SR_OK)
	431	return SR_ERR;
	432	if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_2,
	433	reverse32(devc->trigger_value[2])) != SR_OK)
	434	return SR_ERR;
	435	if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_2,
	436	trigger_config[2]) != SR_OK)
	437	return SR_ERR;
	438
	439	if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_3,
	440	reverse32(devc->trigger_mask[3])) != SR_OK)
	441	return SR_ERR;
	442	if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_3,
	443	reverse32(devc->trigger_value[3])) != SR_OK)
	444	return SR_ERR;
	445	if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_3,
	446	trigger_config[3]) != SR_OK)
	447	return SR_ERR;
	448	} else {
	449	if (send_longcommand(serial, CMD_SET_TRIGGER_MASK_0,
	450	devc->trigger_mask[0]) != SR_OK)
	451	return SR_ERR;
	452	if (send_longcommand(serial, CMD_SET_TRIGGER_VALUE_0,
	453	devc->trigger_value[0]) != SR_OK)
	454	return SR_ERR;
	455	if (send_longcommand(serial, CMD_SET_TRIGGER_CONFIG_0,
	456	0x00000008) != SR_OK)
	457	return SR_ERR;
	458	delaycount = readcount;
	459	}
	460
	461	sr_info("Setting samplerate to %" PRIu64 "Hz (divider %u, "
	462	"demux %s)", devc->cur_samplerate, devc->cur_samplerate_divider,
	463	devc->flag_reg & FLAG_DEMUX ? "on" : "off");
	464	if (send_longcommand(serial, CMD_SET_DIVIDER,
	465	reverse32(devc->cur_samplerate_divider)) != SR_OK)
	466	return SR_ERR;
	467
	468	/* Send sample limit and pre/post-trigger capture ratio. */
	469	data = ((readcount - 1) & 0xffff) << 16;
	470	data \|= (delaycount - 1) & 0xffff;
	471	if (send_longcommand(serial, CMD_CAPTURE_SIZE, reverse16(data)) != SR_OK)
	472	return SR_ERR;
	473
	474	/* The flag register wants them here, and 1 means "disable channel". */
	475	devc->flag_reg \|= ~(changrp_mask << 2) & 0x3c;
	476	devc->flag_reg \|= FLAG_FILTER;
	477	devc->rle_count = 0;
	478	data = (devc->flag_reg << 24) \| ((devc->flag_reg << 8) & 0xff0000);
	479	if (send_longcommand(serial, CMD_SET_FLAGS, data) != SR_OK)
	480	return SR_ERR;
	481
	482	/* Start acquisition on the device. */
	483	if (send_shortcommand(serial, CMD_RUN) != SR_OK)
	484	return SR_ERR;
	485
	486	/* Reset all operational states. */
	487	devc->num_transfers = devc->num_samples = devc->num_bytes = 0;
	488
	489	/* Send header packet to the session bus. */
	490	std_session_send_df_header(cb_data, LOG_PREFIX);
	491
	492	sr_source_add(serial->fd, G_IO_IN, -1, ols_receive_data, cb_data);
	493
	494	return SR_OK;
	495	}
	496
	497	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
	498	{
	499	/* Avoid compiler warnings. */
	500	(void)cb_data;
	501
	502	abort_acquisition(sdi);
	503
	504	return SR_OK;
	505	}
	506
	507	SR_PRIV struct sr_dev_driver ols_driver_info = {
	508	.name = "ols",
	509	.longname = "Openbench Logic Sniffer",
	510	.api_version = 1,
	511	.init = hw_init,
	512	.cleanup = hw_cleanup,
	513	.scan = hw_scan,
	514	.dev_list = hw_dev_list,
	515	.dev_clear = hw_cleanup,
	516	.config_get = config_get,
	517	.config_set = config_set,
	518	.config_list = config_list,
	519	.dev_open = hw_dev_open,
	520	.dev_close = hw_dev_close,
	521	.dev_acquisition_start = hw_dev_acquisition_start,
	522	.dev_acquisition_stop = hw_dev_acquisition_stop,
	523	.priv = NULL,
	524	};