X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fopenbench-logic-sniffer%2Fols.c;h=d71c025123cc6446a3b1918a3dd55404a7a03922;hb=c73d2ea421c2b425c3f0ae33bce2bfd0c448ca5f;hp=d2d49768eb0e93397862a68c1d290d10082918e1;hpb=86f5e3d826fc9059e110f07221cb1a30652ceac2;p=libsigrok.git

diff --git a/hardware/openbench-logic-sniffer/ols.c b/hardware/openbench-logic-sniffer/ols.c
index d2d49768..d71c0251 100644
--- a/hardware/openbench-logic-sniffer/ols.c
+++ b/hardware/openbench-logic-sniffer/ols.c
@@ -1,7 +1,7 @@
 /*
  * This file is part of the sigrok project.
  *
- * Copyright (C) 2010 Bert Vermeulen <bert@biot.com>
+ * 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
@@ -38,8 +38,8 @@
 #include <arpa/inet.h>
 #endif
 #include <glib.h>
-#include <sigrok.h>
-#include <sigrok-internal.h>
+#include "sigrok.h"
+#include "sigrok-internal.h"
 #include "ols.h"
 
 #ifdef _WIN32
@@ -51,9 +51,46 @@ static int capabilities[] = {
 	SR_HWCAP_SAMPLERATE,
 	SR_HWCAP_CAPTURE_RATIO,
 	SR_HWCAP_LIMIT_SAMPLES,
+	SR_HWCAP_RLE,
 	0,
 };
 
+static const char *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 struct sr_samplerates samplerates = {
 	SR_HZ(10),
@@ -180,6 +217,7 @@ static struct ols_device *ols_device_new(void)
 	ols->trigger_at = -1;
 	ols->probe_mask = 0xffffffff;
 	ols->cur_samplerate = SR_KHZ(200);
+	ols->serial = NULL;
 
 	return ols;
 }
@@ -321,7 +359,7 @@ static int hw_init(const char *deviceinfo)
 	final_devcnt = 0;
 
 	if (deviceinfo)
-		ports = g_slist_append(NULL, strdup(deviceinfo));
+		ports = g_slist_append(NULL, g_strdup(deviceinfo));
 	else
 		/* No specific device given, so scan all serial ports. */
 		ports = list_serial_ports();
@@ -377,10 +415,10 @@ static int hw_init(const char *deviceinfo)
 			send_shortcommand(fd, CMD_ID);
 			fds[devcnt].fd = fd;
 			fds[devcnt].events = G_IO_IN;
-			device_names[devcnt] = strdup(l->data);
+			device_names[devcnt] = g_strdup(l->data);
 			devcnt++;
 		}
-		free(l->data);
+		g_free(l->data);
 	}
 
 	/* 2ms isn't enough for reliable transfer with pl2303, let's try 10 */
@@ -414,7 +452,7 @@ static int hw_init(const char *deviceinfo)
 			ols->num_probes = 32;
 			sdi->priv = ols;
 		}
-		sdi->serial = sr_serial_device_instance_new(device_names[i], -1);
+		ols->serial = sr_serial_device_instance_new(device_names[i], -1);
 		device_instances = g_slist_append(device_instances, sdi);
 		final_devcnt++;
 		serial_close(fds[i].fd);
@@ -427,8 +465,8 @@ static int hw_init(const char *deviceinfo)
 			serial_restore_params(fds[i].fd, serial_params[i]);
 			serial_close(fds[i].fd);
 		}
-		free(serial_params[i]);
-		free(device_names[i]);
+		g_free(serial_params[i]);
+		g_free(device_names[i]);
 	}
 
 	g_free(serial_params);
@@ -445,12 +483,15 @@ hw_init_free_ports:
 static int hw_opendev(int device_index)
 {
 	struct sr_device_instance *sdi;
+	struct ols_device *ols;
 
 	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
 		return SR_ERR;
 
-	sdi->serial->fd = serial_open(sdi->serial->port, O_RDWR);
-	if (sdi->serial->fd == -1)
+	ols = sdi->priv;
+
+	ols->serial->fd = serial_open(ols->serial->port, O_RDWR);
+	if (ols->serial->fd == -1)
 		return SR_ERR;
 
 	sdi->status = SR_ST_ACTIVE;
@@ -458,30 +499,41 @@ static int hw_opendev(int device_index)
 	return SR_OK;
 }
 
-static void hw_closedev(int device_index)
+static int hw_closedev(int device_index)
 {
 	struct sr_device_instance *sdi;
+	struct ols_device *ols;
 
-	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
-		return;
+	if (!(sdi = sr_get_device_instance(device_instances, device_index))) {
+		sr_err("ols: %s: sdi was NULL", __func__);
+		return SR_ERR; /* TODO: SR_ERR_ARG? */
+	}
+
+	ols = sdi->priv;
 
-	if (sdi->serial->fd != -1) {
-		serial_close(sdi->serial->fd);
-		sdi->serial->fd = -1;
+	/* TODO */
+	if (ols->serial->fd != -1) {
+		serial_close(ols->serial->fd);
+		ols->serial->fd = -1;
 		sdi->status = SR_ST_INACTIVE;
 	}
+
+	return SR_OK;
 }
 
 static void hw_cleanup(void)
 {
 	GSList *l;
 	struct sr_device_instance *sdi;
+	struct ols_device *ols;
 
-	/* Properly close all devices. */
+	/* Properly close and free all devices. */
 	for (l = device_instances; l; l = l->next) {
 		sdi = l->data;
-		if (sdi->serial->fd != -1)
-			serial_close(sdi->serial->fd);
+		ols = sdi->priv;
+		if (ols->serial->fd != -1)
+			serial_close(ols->serial->fd);
+		sr_serial_device_instance_free(ols->serial);
 		sr_device_instance_free(sdi);
 	}
 	g_slist_free(device_instances);
@@ -506,6 +558,9 @@ static void *hw_get_device_info(int device_index, int device_info_id)
 	case SR_DI_NUM_PROBES:
 		info = GINT_TO_POINTER(NUM_PROBES);
 		break;
+	case SR_DI_PROBE_NAMES:
+		info = probe_names;
+		break;
 	case SR_DI_SAMPLERATES:
 		info = &samplerates;
 		break;
@@ -547,7 +602,6 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi,
 	} else if (samplerate < samplerates.low || samplerate > samplerates.high)
 		return SR_ERR_SAMPLERATE;
 
-	ols->cur_samplerate = samplerate;
 	if (samplerate > CLOCK_RATE) {
 		ols->flag_reg |= FLAG_DEMUX;
 		ols->cur_samplerate_divider = (CLOCK_RATE * 2 / samplerate) - 1;
@@ -556,6 +610,16 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi,
 		ols->cur_samplerate_divider = (CLOCK_RATE / samplerate) - 1;
 	}
 
+	/* Calculate actual samplerate used and complain if it is different
+	 * from the requested.
+	 */
+	ols->cur_samplerate = CLOCK_RATE / (ols->cur_samplerate_divider + 1);
+	if (ols->flag_reg & FLAG_DEMUX)
+		ols->cur_samplerate *= 2;
+	if (ols->cur_samplerate != samplerate)
+		sr_err("ols: can't match samplerate %" PRIu64 ", using %"
+		       PRIu64, samplerate, ols->cur_samplerate);
+
 	return SR_OK;
 }
 
@@ -585,6 +649,8 @@ static int hw_set_configuration(int device_index, int capability, void *value)
 		tmp_u64 = value;
 		if (*tmp_u64 < MIN_NUM_SAMPLES)
 			return SR_ERR;
+		if (*tmp_u64 > ols->max_samples)
+			sr_err("ols: sample limit exceeds hw max");
 		ols->limit_samples = *tmp_u64;
 		sr_info("ols: sample limit %" PRIu64, ols->limit_samples);
 		ret = SR_OK;
@@ -598,6 +664,13 @@ static int hw_set_configuration(int device_index, int capability, void *value)
 		} else
 			ret = SR_OK;
 		break;
+	case SR_HWCAP_RLE:
+		if (GPOINTER_TO_INT(value)) {
+			sr_info("ols: enabling RLE");
+			ols->flag_reg |= FLAG_RLE;
+		}
+		ret = SR_OK;
+		break;
 	default:
 		ret = SR_ERR;
 	}
@@ -605,20 +678,21 @@ static int hw_set_configuration(int device_index, int capability, void *value)
 	return ret;
 }
 
-static int receive_data(int fd, int revents, void *user_data)
+static int receive_data(int fd, int revents, void *session_data)
 {
 	struct sr_datafeed_packet packet;
+	struct sr_datafeed_logic logic;
 	struct sr_device_instance *sdi;
 	struct ols_device *ols;
 	GSList *l;
-	int count, buflen, num_channels, offset, i, j;
-	unsigned char byte, *buffer;
+	int num_channels, offset, i, j;
+	unsigned char byte;
 
 	/* find this device's ols_device struct by its fd */
 	ols = NULL;
 	for (l = device_instances; l; l = l->next) {
 		sdi = l->data;
-		if (sdi->serial->fd == fd) {
+		if (ols->serial->fd == fd) {
 			ols = sdi->priv;
 			break;
 		}
@@ -635,7 +709,7 @@ static int receive_data(int fd, int revents, void *user_data)
 		 * finished. We'll double that to 30ms to be sure...
 		 */
 		sr_source_remove(fd);
-		sr_source_add(fd, G_IO_IN, 30, receive_data, user_data);
+		sr_source_add(fd, G_IO_IN, 30, receive_data, session_data);
 		ols->raw_sample_buf = g_try_malloc(ols->limit_samples * 4);
 		if (!ols->raw_sample_buf) {
 			sr_err("ols: %s: ols->raw_sample_buf malloc failed",
@@ -652,52 +726,42 @@ static int receive_data(int fd, int revents, void *user_data)
 			num_channels++;
 	}
 
-	if (revents == G_IO_IN
-	    && ols->num_transfers / num_channels <= ols->limit_samples) {
+	if (revents == G_IO_IN) {
 		if (serial_read(fd, &byte, 1) != 1)
 			return FALSE;
 
+		/* Ignore it if we've read enough. */
+		if (ols->num_samples >= ols->limit_samples)
+			return TRUE;
+
 		ols->sample[ols->num_bytes++] = byte;
 		sr_dbg("ols: received byte 0x%.2x", byte);
 		if (ols->num_bytes == num_channels) {
 			/* Got a full sample. */
 			sr_dbg("ols: received sample 0x%.*x",
-			       ols->num_bytes * 2, (int) *ols->sample);
+			       ols->num_bytes * 2, *(int *)ols->sample);
 			if (ols->flag_reg & FLAG_RLE) {
 				/*
 				 * In RLE mode -1 should never come in as a
 				 * sample, because bit 31 is the "count" flag.
-				 * TODO: Endianness may be wrong here, could be
-				 * sample[3].
 				 */
-				if (ols->sample[0] & 0x80
-				    && !(ols->last_sample[0] & 0x80)) {
-					count = (int)(*ols->sample) & 0x7fffffff;
-					if (!(buffer = g_try_malloc(count))) {
-						sr_err("ols: %s: buffer malloc "
-						       "failed", __func__);
-						return FALSE;
-					}
-
-					buflen = 0;
-					for (i = 0; i < count; i++) {
-						memcpy(buffer + buflen, ols->last_sample, 4);
-						buflen += 4;
-					}
-				} else {
+				if (ols->sample[ols->num_bytes - 1] & 0x80) {
+					ols->sample[ols->num_bytes - 1] &= 0x7f;
 					/*
-					 * Just a single sample, next sample
-					 * will probably be a count referring
-					 * to this -- but this one is still a
-					 * part of the stream.
+					 * FIXME: This will only work on
+					 * little-endian systems.
 					 */
-					buffer = ols->sample;
-					buflen = 4;
+					ols->rle_count = *(int *)(ols->sample);
+					sr_dbg("ols: RLE count = %d", ols->rle_count);
+					ols->num_bytes = 0;
+					return TRUE;
 				}
-			} else {
-				/* No compression. */
-				buffer = ols->sample;
-				buflen = 4;
+			}
+			ols->num_samples += ols->rle_count + 1;
+			if (ols->num_samples > ols->limit_samples) {
+				/* Save us from overrunning the buffer. */
+				ols->rle_count -= ols->num_samples - ols->limit_samples;
+				ols->num_samples = ols->limit_samples;
 			}
 
 			if (num_channels < 4) {
@@ -723,23 +787,21 @@ static int receive_data(int fd, int revents, void *user_data)
 					}
 				}
 				memcpy(ols->sample, ols->tmp_sample, 4);
-				sr_dbg("ols: full sample 0x%.8x", (int) *ols->sample);
+				sr_dbg("ols: full sample 0x%.8x", *(int *)ols->sample);
 			}
 
 			/* the OLS sends its sample buffer backwards.
 			 * store it in reverse order here, so we can dump
 			 * this on the session bus later.
 			 */
-			offset = (ols->limit_samples - ols->num_transfers / num_channels) * 4;
-			memcpy(ols->raw_sample_buf + offset, ols->sample, 4);
-
-			if (buffer == ols->sample)
-				memcpy(ols->last_sample, buffer, num_channels);
-			else
-				g_free(buffer);
-
+			offset = (ols->limit_samples - ols->num_samples) * 4;
+			for (i = 0; i <= ols->rle_count; i++) {
+				memcpy(ols->raw_sample_buf + offset + (i * 4),
+				       ols->sample, 4);
+			}
 			memset(ols->sample, 0, 4);
 			ols->num_bytes = 0;
+			ols->rle_count = 0;
 		}
 	} else {
 		/*
@@ -754,41 +816,48 @@ static int receive_data(int fd, int revents, void *user_data)
 			if (ols->trigger_at > 0) {
 				/* there are pre-trigger samples, send those first */
 				packet.type = SR_DF_LOGIC;
-				packet.length = ols->trigger_at * 4;
-				packet.unitsize = 4;
-				packet.payload = ols->raw_sample_buf;
-				sr_session_bus(user_data, &packet);
+				packet.payload = &logic;
+				logic.length = ols->trigger_at * 4;
+				logic.unitsize = 4;
+				logic.data = ols->raw_sample_buf +
+					(ols->limit_samples - ols->num_samples) * 4;
+				sr_session_bus(session_data, &packet);
 			}
 
+			/* send the trigger */
 			packet.type = SR_DF_TRIGGER;
-			packet.length = 0;
-			sr_session_bus(user_data, &packet);
+			sr_session_bus(session_data, &packet);
 
+			/* send post-trigger samples */
 			packet.type = SR_DF_LOGIC;
-			packet.length = (ols->limit_samples * 4) - (ols->trigger_at * 4);
-			packet.unitsize = 4;
-			packet.payload = ols->raw_sample_buf + ols->trigger_at * 4;
-			sr_session_bus(user_data, &packet);
+			packet.payload = &logic;
+			logic.length = (ols->num_samples * 4) - (ols->trigger_at * 4);
+			logic.unitsize = 4;
+			logic.data = ols->raw_sample_buf + ols->trigger_at * 4 +
+				(ols->limit_samples - ols->num_samples) * 4;
+			sr_session_bus(session_data, &packet);
 		} else {
+			/* no trigger was used */
 			packet.type = SR_DF_LOGIC;
-			packet.length = ols->limit_samples * 4;
-			packet.unitsize = 4;
-			packet.payload = ols->raw_sample_buf;
-			sr_session_bus(user_data, &packet);
+			packet.payload = &logic;
+			logic.length = ols->num_samples * 4;
+			logic.unitsize = 4;
+			logic.data = ols->raw_sample_buf +
+				(ols->limit_samples - ols->num_samples) * 4;
+			sr_session_bus(session_data, &packet);
 		}
 		g_free(ols->raw_sample_buf);
 
 		serial_flush(fd);
 		serial_close(fd);
 		packet.type = SR_DF_END;
-		packet.length = 0;
-		sr_session_bus(user_data, &packet);
+		sr_session_bus(session_data, &packet);
 	}
 
 	return TRUE;
 }
 
-static int hw_start_acquisition(int device_index, gpointer session_device_id)
+static int hw_start_acquisition(int device_index, gpointer session_data)
 {
 	struct sr_datafeed_packet *packet;
 	struct sr_datafeed_header *header;
@@ -798,6 +867,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	uint32_t data;
 	uint16_t readcount, delaycount;
 	uint8_t changrp_mask;
+	int num_channels;
 	int i;
 
 	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
@@ -808,7 +878,25 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	if (sdi->status != SR_ST_ACTIVE)
 		return SR_ERR;
 
-	readcount = ols->limit_samples / 4;
+	/*
+	 * 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 (ols->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(ols->max_samples / num_channels, ols->limit_samples) / 4;
 
 	memset(trigger_config, 0, 16);
 	trigger_config[ols->num_stages - 1] |= 0x08;
@@ -816,53 +904,53 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 		delaycount = readcount * (1 - ols->capture_ratio / 100.0);
 		ols->trigger_at = (readcount - delaycount) * 4 - ols->num_stages;
 
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_0,
 			reverse32(ols->trigger_mask[0])) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_0,
 			reverse32(ols->trigger_value[0])) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
 			trigger_config[0]) != SR_OK)
 			return SR_ERR;
 
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_1,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_1,
 			reverse32(ols->trigger_mask[1])) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_1,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_1,
 			reverse32(ols->trigger_value[1])) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_1,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_1,
 			trigger_config[1]) != SR_OK)
 			return SR_ERR;
 
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_2,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_2,
 			reverse32(ols->trigger_mask[2])) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_2,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_2,
 			reverse32(ols->trigger_value[2])) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_2,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_2,
 			trigger_config[2]) != SR_OK)
 			return SR_ERR;
 
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_3,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_3,
 			reverse32(ols->trigger_mask[3])) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_3,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_3,
 			reverse32(ols->trigger_value[3])) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_3,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_3,
 			trigger_config[3]) != SR_OK)
 			return SR_ERR;
 	} else {
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_0,
 				ols->trigger_mask[0]) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_0,
 				ols->trigger_value[0]) != SR_OK)
 			return SR_ERR;
-		if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
+		if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
 		     0x00000008) != SR_OK)
 			return SR_ERR;
 		delaycount = readcount;
@@ -871,39 +959,30 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	sr_info("ols: setting samplerate to %" PRIu64 " Hz (divider %u, "
 		"demux %s)", ols->cur_samplerate, ols->cur_samplerate_divider,
 		ols->flag_reg & FLAG_DEMUX ? "on" : "off");
-	if (send_longcommand(sdi->serial->fd, CMD_SET_DIVIDER,
+	if (send_longcommand(ols->serial->fd, CMD_SET_DIVIDER,
 			reverse32(ols->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(sdi->serial->fd, CMD_CAPTURE_SIZE, reverse16(data)) != SR_OK)
+	if (send_longcommand(ols->serial->fd, CMD_CAPTURE_SIZE, reverse16(data)) != SR_OK)
 		return SR_ERR;
 
-	/*
-	 * Enable/disable channel groups in the flag register according to the
-	 * probe mask.
-	 */
-	changrp_mask = 0;
-	for (i = 0; i < 4; i++) {
-		if (ols->probe_mask & (0xff << (i * 8)))
-			changrp_mask |= (1 << i);
-	}
-
 	/* The flag register wants them here, and 1 means "disable channel". */
 	ols->flag_reg |= ~(changrp_mask << 2) & 0x3c;
 	ols->flag_reg |= FLAG_FILTER;
-	data = ols->flag_reg << 24;
-	if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SR_OK)
+	ols->rle_count = 0;
+	data = (ols->flag_reg << 24) | ((ols->flag_reg << 8) & 0xff0000);
+	if (send_longcommand(ols->serial->fd, CMD_SET_FLAGS, data) != SR_OK)
 		return SR_ERR;
 
 	/* Start acquisition on the device. */
-	if (send_shortcommand(sdi->serial->fd, CMD_RUN) != SR_OK)
+	if (send_shortcommand(ols->serial->fd, CMD_RUN) != SR_OK)
 		return SR_ERR;
 
-	sr_source_add(sdi->serial->fd, G_IO_IN, -1, receive_data,
-		      session_device_id);
+	sr_source_add(ols->serial->fd, G_IO_IN, -1, receive_data,
+		      session_data);
 
 	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
 		sr_err("ols: %s: packet malloc failed", __func__);
@@ -918,15 +997,12 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 
 	/* Send header packet to the session bus. */
 	packet->type = SR_DF_HEADER;
-	packet->length = sizeof(struct sr_datafeed_header);
 	packet->payload = (unsigned char *)header;
 	header->feed_version = 1;
 	gettimeofday(&header->starttime, NULL);
 	header->samplerate = ols->cur_samplerate;
-	header->protocol_id = SR_PROTO_RAW;
 	header->num_logic_probes = NUM_PROBES;
-	header->num_analog_probes = 0;
-	sr_session_bus(session_device_id, packet);
+	sr_session_bus(session_data, packet);
 
 	g_free(header);
 	g_free(packet);
@@ -939,14 +1015,13 @@ static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 	struct sr_datafeed_packet packet;
 
 	/* Avoid compiler warnings. */
-	device_index = device_index;
+	(void)device_index;
 
 	packet.type = SR_DF_END;
-	packet.length = 0;
 	sr_session_bus(session_device_id, &packet);
 }
 
-struct sr_device_plugin ols_plugin_info = {
+SR_PRIV struct sr_device_plugin ols_plugin_info = {
 	.name = "ols",
 	.longname = "Openbench Logic Sniffer",
 	.api_version = 1,