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

/*
 * This file is part of the sigrok project.
 *
 * Copyright (C) 2010-2012 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 int hwopts[] = {
	SR_HWOPT_CONN,
	SR_HWOPT_SERIALCOMM,
	0,
};

static const int hwcaps[] = {
	SR_HWCAP_LOGIC_ANALYZER,
	SR_HWCAP_SAMPLERATE,
	SR_HWCAP_CAPTURE_RATIO,
	SR_HWCAP_LIMIT_SAMPLES,
	SR_HWCAP_RLE,
	0,
};

/* 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 struct sr_samplerates samplerates = {
	SR_HZ(10),
	SR_MHZ(200),
	SR_HZ(1),
	NULL,
};

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)
{
	struct drv_context *drvc;

	if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
		sr_err("Driver context malloc failed.");
		return SR_ERR_MALLOC;
	}
	drvc->sr_ctx = sr_ctx;
	di->priv = drvc;

	return SR_OK;
}

static GSList *hw_scan(GSList *options)
{
	struct sr_hwopt *opt;
	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) {
		opt = l->data;
		switch (opt->hwopt) {
		case SR_HWOPT_CONN:
			conn = opt->value;
			break;
		case SR_HWOPT_SERIALCOMM:
			serialcomm = opt->value;
			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. */
		sdi = sr_dev_inst_new(0, SR_ST_INACTIVE,
				"Sump", "Logic Analyzer", "v1.0");
		sdi->driver = di;
		devc = ols_dev_new();
		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);
		}
		sdi->priv = devc;
	}
	devc->serial = 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)
{
	struct drv_context *drvc;

	drvc = di->priv;

	return drvc->instances;
}

static int hw_dev_open(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;

	devc = sdi->priv;

	if (serial_open(devc->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 dev_context *devc;

	devc = sdi->priv;

	if (devc->serial && devc->serial->fd != -1) {
		serial_close(devc->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;
	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);
		sr_serial_dev_inst_free(devc->serial);
		sr_dev_inst_free(sdi);
	}
	g_slist_free(drvc->instances);
	drvc->instances = NULL;

	return ret;
}

static int hw_info_get(int info_id, const void **data,
       const struct sr_dev_inst *sdi)
{
	struct dev_context *devc;

	switch (info_id) {
	case SR_DI_HWOPTS:
		*data = hwopts;
		break;
	case SR_DI_HWCAPS:
		*data = hwcaps;
		break;
	case SR_DI_SAMPLERATES:
		*data = &samplerates;
		break;
	case SR_DI_TRIGGER_TYPES:
		*data = (char *)TRIGGER_TYPES;
		break;
	case SR_DI_CUR_SAMPLERATE:
		if (sdi) {
			devc = sdi->priv;
			*data = &devc->cur_samplerate;
		} else
			return SR_ERR;
		break;
	default:
		return SR_ERR_ARG;
	}

	return SR_OK;
}

static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
		const void *value)
{
	struct dev_context *devc;
	int ret;
	const uint64_t *tmp_u64;

	devc = sdi->priv;

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

	switch (hwcap) {
	case SR_HWCAP_SAMPLERATE:
		ret = ols_set_samplerate(sdi, *(const uint64_t *)value,
					 &samplerates);
		break;
	case SR_HWCAP_LIMIT_SAMPLES:
		tmp_u64 = value;
		if (*tmp_u64 < MIN_NUM_SAMPLES)
			return SR_ERR;
		if (*tmp_u64 > devc->max_samples)
			sr_err("Sample limit exceeds hardware maximum.");
		devc->limit_samples = *tmp_u64;
		sr_info("Sample limit is %" PRIu64 ".", devc->limit_samples);
		ret = SR_OK;
		break;
	case SR_HWCAP_CAPTURE_RATIO:
		devc->capture_ratio = *(const uint64_t *)value;
		if (devc->capture_ratio < 0 || devc->capture_ratio > 100) {
			devc->capture_ratio = 0;
			ret = SR_ERR;
		} else
			ret = SR_OK;
		break;
	case SR_HWCAP_RLE:
		if (GPOINTER_TO_INT(value)) {
			sr_info("Enabling RLE.");
			devc->flag_reg |= FLAG_RLE;
		}
		ret = SR_OK;
		break;
	default:
		ret = SR_ERR;
	}

	return ret;
}

static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
		void *cb_data)
{
	struct sr_datafeed_packet *packet;
	struct sr_datafeed_header *header;
	struct sr_datafeed_meta_logic meta;
	struct dev_context *devc;
	uint32_t trigger_config[4];
	uint32_t data;
	uint16_t readcount, delaycount;
	uint8_t changrp_mask;
	int num_channels;
	int i;

	devc = sdi->priv;

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

	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 - 1] |= 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(devc->serial, CMD_SET_TRIGGER_MASK_0,
			reverse32(devc->trigger_mask[0])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(devc->serial, CMD_SET_TRIGGER_VALUE_0,
			reverse32(devc->trigger_value[0])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(devc->serial, CMD_SET_TRIGGER_CONFIG_0,
			trigger_config[0]) != SR_OK)
			return SR_ERR;

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

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

		if (send_longcommand(devc->serial, CMD_SET_TRIGGER_MASK_3,
			reverse32(devc->trigger_mask[3])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(devc->serial, CMD_SET_TRIGGER_VALUE_3,
			reverse32(devc->trigger_value[3])) != SR_OK)
			return SR_ERR;
		if (send_longcommand(devc->serial, CMD_SET_TRIGGER_CONFIG_3,
			trigger_config[3]) != SR_OK)
			return SR_ERR;
	} else {
		if (send_longcommand(devc->serial, CMD_SET_TRIGGER_MASK_0,
				devc->trigger_mask[0]) != SR_OK)
			return SR_ERR;
		if (send_longcommand(devc->serial, CMD_SET_TRIGGER_VALUE_0,
				devc->trigger_value[0]) != SR_OK)
			return SR_ERR;
		if (send_longcommand(devc->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(devc->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(devc->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(devc->serial, CMD_SET_FLAGS, data) != SR_OK)
		return SR_ERR;

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

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

	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
		sr_err("Datafeed packet malloc failed.");
		return SR_ERR_MALLOC;
	}

	if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
		sr_err("Datafeed header malloc failed.");
		g_free(packet);
		return SR_ERR_MALLOC;
	}

	/* Send header packet to the session bus. */
	packet->type = SR_DF_HEADER;
	packet->payload = (unsigned char *)header;
	header->feed_version = 1;
	gettimeofday(&header->starttime, NULL);
	sr_session_send(cb_data, packet);

	/* Send metadata about the SR_DF_LOGIC packets to come. */
	packet->type = SR_DF_META_LOGIC;
	packet->payload = &meta;
	meta.samplerate = devc->cur_samplerate;
	meta.num_probes = NUM_PROBES;
	sr_session_send(cb_data, packet);

	g_free(header);
	g_free(packet);

	return SR_OK;
}

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