X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fopenbench-logic-sniffer%2Fols.c;h=2edb6acbb0aaf93b8ba5059aad28c05b70ba2e4d;hb=cb93f8a927e6fb2cb1d89176766c5c9c398db5c3;hp=bae3f0f48d02c3defddbe221b4dd45a5259ab9e6;hpb=c0a4b9716d32811d9b2320884d3bd0e599feedcf;p=libsigrok.git

diff --git a/hardware/openbench-logic-sniffer/ols.c b/hardware/openbench-logic-sniffer/ols.c
index bae3f0f4..2edb6acb 100644
--- a/hardware/openbench-logic-sniffer/ols.c
+++ b/hardware/openbench-logic-sniffer/ols.c
@@ -51,6 +51,7 @@ static int capabilities[] = {
 	SR_HWCAP_SAMPLERATE,
 	SR_HWCAP_CAPTURE_RATIO,
 	SR_HWCAP_LIMIT_SAMPLES,
+	SR_HWCAP_RLE,
 	0,
 };
 
@@ -180,6 +181,7 @@ static struct ols_device *ols_device_new(void)
 	ols->trigger_at = -1;
 	ols->probe_mask = 0xffffffff;
 	ols->cur_samplerate = SR_KHZ(200);
+	ols->period_ps = 5000000;
 
 	return ols;
 }
@@ -431,7 +433,6 @@ static int hw_init(const char *deviceinfo)
 		free(device_names[i]);
 	}
 
-hw_init_free_serial_params:
 	g_free(serial_params);
 hw_init_free_device_names:
 	g_free(device_names);
@@ -459,18 +460,23 @@ 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;
 
-	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? */
+	}
 
+	/* TODO */
 	if (sdi->serial->fd != -1) {
 		serial_close(sdi->serial->fd);
 		sdi->serial->fd = -1;
 		sdi->status = SR_ST_INACTIVE;
 	}
+
+	return SR_OK;
 }
 
 static void hw_cleanup(void)
@@ -478,7 +484,7 @@ static void hw_cleanup(void)
 	GSList *l;
 	struct sr_device_instance *sdi;
 
-	/* 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)
@@ -548,7 +554,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;
@@ -557,6 +562,17 @@ 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;
+	ols->period_ps = 1000000000000 / ols->cur_samplerate;
+	if(ols->cur_samplerate != samplerate)
+		sr_warn("ols: can't match samplerate %" PRIu64 ", using %" PRIu64, 
+			samplerate, ols->cur_samplerate);
+
 	return SR_OK;
 }
 
@@ -586,6 +602,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_warn("ols: sample limit exceeds hw max");
 		ols->limit_samples = *tmp_u64;
 		sr_info("ols: sample limit %" PRIu64, ols->limit_samples);
 		ret = SR_OK;
@@ -599,6 +617,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;
 	}
@@ -606,14 +631,15 @@ 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;
@@ -636,7 +662,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",
@@ -653,52 +679,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) {
@@ -724,23 +740,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 {
 		/*
@@ -755,41 +769,58 @@ 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.timeoffset = 0;
+				packet.duration = ols->trigger_at * ols->period_ps;
+				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);
+			packet.timeoffset = ols->trigger_at * ols->period_ps;
+			packet.duration = 0;
+			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.timeoffset = ols->trigger_at * ols->period_ps;
+			packet.duration = (ols->num_samples - ols->trigger_at) * ols->period_ps;
+			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.timeoffset = 0;
+			packet.duration = ols->num_samples * ols->period_ps;
+			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);
+		packet.timeoffset = ols->num_samples * ols->period_ps;
+		packet.duration = 0;
+		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;
@@ -799,6 +830,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)))
@@ -809,7 +841,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;
@@ -882,20 +932,11 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 	if (send_longcommand(sdi->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;
+	ols->rle_count = 0;
+	data = (ols->flag_reg << 24) | ((ols->flag_reg << 8) & 0xff0000);
 	if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SR_OK)
 		return SR_ERR;
 
@@ -904,7 +945,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 		return SR_ERR;
 
 	sr_source_add(sdi->serial->fd, G_IO_IN, -1, receive_data,
-		      session_device_id);
+		      session_data);
 
 	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
 		sr_err("ols: %s: packet malloc failed", __func__);
@@ -919,15 +960,13 @@ 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);
@@ -940,25 +979,24 @@ 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 = {
-	"ols",
-	"Openbench Logic Sniffer",
-	1,
-	hw_init,
-	hw_cleanup,
-	hw_opendev,
-	hw_closedev,
-	hw_get_device_info,
-	hw_get_status,
-	hw_get_capabilities,
-	hw_set_configuration,
-	hw_start_acquisition,
-	hw_stop_acquisition,
+	.name = "ols",
+	.longname = "Openbench Logic Sniffer",
+	.api_version = 1,
+	.init = hw_init,
+	.cleanup = hw_cleanup,
+	.opendev = hw_opendev,
+	.closedev = hw_closedev,
+	.get_device_info = hw_get_device_info,
+	.get_status = hw_get_status,
+	.get_capabilities = hw_get_capabilities,
+	.set_configuration = hw_set_configuration,
+	.start_acquisition = hw_start_acquisition,
+	.stop_acquisition = hw_stop_acquisition,
 };