[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"
#include <libserialport.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_EXTERNAL_CLOCK,
	SR_CONF_PATTERN_MODE,
	SR_CONF_SWAP,
	SR_CONF_RLE,
	SR_CONF_MAX_UNCOMPRESSED_SAMPLES,
};

#define STR_PATTERN_EXTERNAL "external"
#define STR_PATTERN_INTERNAL "internal"

/* Supported methods of test pattern outputs */
enum {
	/**
	 * Capture pins 31:16 (unbuffered wing) output a test pattern
	 * that can captured on pins 0:15.
	 */
	PATTERN_EXTERNAL,

	/** Route test pattern internally to capture buffer. */
	PATTERN_INTERNAL,
};

static const char *patterns[] = {
	STR_PATTERN_EXTERNAL,
	STR_PATTERN_INTERNAL,
};

/* 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 dev_clear(void)
{
	return std_dev_clear(di, NULL);
}

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

static GSList *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];

	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);

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

	if (probefd.revents != G_IO_IN)
		return NULL;
	if (serial_read_blocking(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 *dev_list(void)
{
	return ((struct drv_context *)(di->priv))->instances;
}

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;
	int num_channels, i;

	(void)probe_group;

	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_PATTERN_MODE:
		if (devc->flag_reg & FLAG_EXTERNAL_TEST_MODE)
			*data = g_variant_new_string(STR_PATTERN_EXTERNAL);
		else if (devc->flag_reg & FLAG_INTERNAL_TEST_MODE)
			*data = g_variant_new_string(STR_PATTERN_INTERNAL);
		break;
	case SR_CONF_RLE:
		*data = g_variant_new_boolean(devc->flag_reg & FLAG_RLE ? TRUE : FALSE);
		break;
	case SR_CONF_MAX_UNCOMPRESSED_SAMPLES:
		if (devc->flag_reg & FLAG_RLE)
			return SR_ERR_NA;
		if (devc->max_samples == 0)
			/* Device didn't specify sample memory size in metadata. */
			return SR_ERR_NA;
		/*
		 * Channel groups are turned off if no probes in that group are
		 * enabled, making more room for samples for the enabled group.
		 */
		ols_configure_probes(sdi);
		num_channels = 0;
		for (i = 0; i < 4; i++) {
			if (devc->probe_mask & (0xff << (i * 8)))
				num_channels++;
		}
		*data = g_variant_new_uint64(devc->max_samples / num_channels);
		break;
	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;
	int ret;
	uint64_t tmp_u64;
	const char *stropt;

	(void)probe_group;

	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_EXTERNAL_CLOCK:
		if (g_variant_get_boolean(data)) {
			sr_info("Enabling external clock.");
			devc->flag_reg |= FLAG_CLOCK_EXTERNAL;
		} else {
			sr_info("Disabled external clock.");
			devc->flag_reg &= ~FLAG_CLOCK_EXTERNAL;
		}
		ret = SR_OK;
		break;
	case SR_CONF_PATTERN_MODE:
		stropt = g_variant_get_string(data, NULL);
		ret = SR_OK;
		if (!strcmp(stropt, STR_PATTERN_INTERNAL)) {
			sr_info("Enabling internal test mode.");
			devc->flag_reg |= FLAG_INTERNAL_TEST_MODE;
		} else if (!strcmp(stropt, STR_PATTERN_EXTERNAL)) {
			sr_info("Enabling external test mode.");
			devc->flag_reg |= FLAG_EXTERNAL_TEST_MODE;
		} else {
			ret = SR_ERR;
		}
		break;
	case SR_CONF_SWAP:
		if (g_variant_get_boolean(data)) {
			sr_info("Enabling channel swapping.");
			devc->flag_reg |= FLAG_SWAP_PROBES;
		} else {
			sr_info("Disabling channel swapping.");
			devc->flag_reg &= ~FLAG_SWAP_PROBES;
		}
		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,
		const struct sr_probe_group *probe_group)
{
	GVariant *gvar;
	GVariantBuilder gvb;

	(void)sdi;
	(void)probe_group;

	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;
	case SR_CONF_PATTERN_MODE:
		*data = g_variant_new_strv(patterns, ARRAY_SIZE(patterns));
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int 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, noise_filter %s)", devc->cur_samplerate,
		devc->cur_samplerate_divider,
		devc->flag_reg & FLAG_DEMUX ? "on" : "off",
		devc->flag_reg & FLAG_FILTER ? "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->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;
	memset(devc->sample, 0, 4);

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

	serial_source_add(serial, G_IO_IN, -1, ols_receive_data, cb_data);

	return SR_OK;
}

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