X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fsaleae-logic%2Fsaleae-logic.c;h=a270e0b4850ca27a3aff4fa6404b9210085916de;hb=22b02383442ec55a11cc6dd2b4c467d1de0b5bd2;hp=75bf6c13889267e041aa234b4f47b4b86a595e62;hpb=b5698bd71e96561ba08a481abaa9c64ee687bda2;p=libsigrok.git

diff --git a/hardware/saleae-logic/saleae-logic.c b/hardware/saleae-logic/saleae-logic.c
index 75bf6c13..a270e0b4 100644
--- a/hardware/saleae-logic/saleae-logic.c
+++ b/hardware/saleae-logic/saleae-logic.c
@@ -17,6 +17,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "config.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/time.h>
@@ -24,40 +25,41 @@
 #include <glib.h>
 #include <libusb.h>
 #include <sigrok.h>
-#include "config.h"
+#include <sigrok-internal.h>
 
-#define USB_VENDOR			0x0925
+#define USB_VENDOR	            0x0925
 #define USB_PRODUCT			0x3881
-#define USB_VENDOR_NAME			"Saleae"
-#define USB_MODEL_NAME			"Logic"
-#define USB_MODEL_VERSION		""
+#define USB_VENDOR_NAME        "Saleae"
+#define USB_MODEL_NAME         "Logic"
+#define USB_MODEL_VERSION      ""
 
-#define USB_INTERFACE			0
-#define USB_CONFIGURATION		1
-#define NUM_PROBES			8
-#define NUM_TRIGGER_STAGES		4
-#define TRIGGER_TYPES			"01"
-#define FIRMWARE			FIRMWARE_DIR "/saleae-logic.fw"
+#define USB_INTERFACE          0
+#define USB_CONFIGURATION      1
+#define NUM_PROBES             8
+#define NUM_TRIGGER_STAGES     4
+#define TRIGGER_TYPES          "01"
+#define FIRMWARE               FIRMWARE_DIR "/saleae-logic.fw"
 
 /* delay in ms */
-#define FIRMWARE_RENUM_DELAY		2000
-#define NUM_SIMUL_TRANSFERS		10
-#define MAX_EMPTY_TRANSFERS		(NUM_SIMUL_TRANSFERS * 2)
+#define FIRMWARE_RENUM_DELAY   2000
+#define NUM_SIMUL_TRANSFERS    10
+#define MAX_EMPTY_TRANSFERS    (NUM_SIMUL_TRANSFERS * 2)
 
 /* Software trigger implementation: positive values indicate trigger stage. */
-#define TRIGGER_FIRED			-1
+#define TRIGGER_FIRED          -1
 
 /* There is only one model Saleae Logic, and this is what it supports: */
 static int capabilities[] = {
-	HWCAP_LOGIC_ANALYZER,
-	HWCAP_SAMPLERATE,
+	SR_HWCAP_LOGIC_ANALYZER,
+	SR_HWCAP_SAMPLERATE,
 
 	/* These are really implemented in the driver, not the hardware. */
-	HWCAP_LIMIT_SAMPLES,
+	SR_HWCAP_LIMIT_SAMPLES,
+	SR_HWCAP_CONTINUOUS,
 	0,
 };
 
-/* List of struct sigrok_device_instance, maintained by opendev()/closedev(). */
+/* List of struct sr_device_instance, maintained by opendev()/closedev(). */
 static GSList *device_instances = NULL;
 
 /*
@@ -164,18 +166,18 @@ int check_conf_profile(libusb_device *dev)
 	return ret;
 }
 
-struct sigrok_device_instance *sl_open_device(int device_index)
+struct sr_device_instance *sl_open_device(int device_index)
 {
-	struct sigrok_device_instance *sdi;
+	struct sr_device_instance *sdi;
 	libusb_device **devlist;
 	struct libusb_device_descriptor des;
 	int err, skip, i;
 
-	if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
+	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
 		return NULL;
 
 	libusb_get_device_list(usb_context, &devlist);
-	if (sdi->status == ST_INITIALIZING) {
+	if (sdi->status == SR_ST_INITIALIZING) {
 		/*
 		 * This device was renumerating last time we touched it.
 		 * opendev() guarantees we've waited long enough for it to
@@ -189,7 +191,7 @@ struct sigrok_device_instance *sl_open_device(int device_index)
 				       &skip, USB_VENDOR, USB_PRODUCT,
 				       USB_INTERFACE);
 		}
-	} else if (sdi->status == ST_INACTIVE) {
+	} else if (sdi->status == SR_ST_INACTIVE) {
 		/*
 		 * This device is fully enumerated, so we need to find this
 		 * device by vendor, product, bus and address.
@@ -201,12 +203,12 @@ struct sigrok_device_instance *sl_open_device(int device_index)
 				       USB_PRODUCT, USB_INTERFACE);
 		}
 	} else {
-		/* Status must be ST_ACTIVE, i.e. already in use... */
+		/* Status must be SR_ST_ACTIVE, i.e. already in use... */
 		sdi = NULL;
 	}
 	libusb_free_device_list(devlist, 1);
 
-	if (sdi && sdi->status != ST_ACTIVE)
+	if (sdi && sdi->status != SR_ST_ACTIVE)
 		sdi = NULL;
 
 	return sdi;
@@ -226,17 +228,17 @@ int upload_firmware(libusb_device *dev)
 	return 0;
 }
 
-static void close_device(struct sigrok_device_instance *sdi)
+static void close_device(struct sr_device_instance *sdi)
 {
 	if (sdi->usb->devhdl == NULL)
 		return;
 
-	g_message("closing device %d on %d.%d interface %d", sdi->index,
+	g_message("saleae: closing device %d on %d.%d interface %d", sdi->index,
 		  sdi->usb->bus, sdi->usb->address, USB_INTERFACE);
 	libusb_release_interface(sdi->usb->devhdl, USB_INTERFACE);
 	libusb_close(sdi->usb->devhdl);
 	sdi->usb->devhdl = NULL;
-	sdi->status = ST_INACTIVE;
+	sdi->status = SR_ST_INACTIVE;
 }
 
 static int configure_probes(GSList *probes)
@@ -269,7 +271,7 @@ static int configure_probes(GSList *probes)
 				trigger_value[stage] |= probe_bit;
 			stage++;
 			if (stage > NUM_TRIGGER_STAGES)
-				return SIGROK_ERR;
+				return SR_ERR;
 		}
 	}
 
@@ -282,7 +284,7 @@ static int configure_probes(GSList *probes)
 	else
 		trigger_stage = 0;
 
-	return SIGROK_OK;
+	return SR_OK;
 }
 
 /*
@@ -291,19 +293,18 @@ static int configure_probes(GSList *probes)
 
 static int hw_init(char *deviceinfo)
 {
-	struct sigrok_device_instance *sdi;
+	struct sr_device_instance *sdi;
 	struct libusb_device_descriptor des;
 	libusb_device **devlist;
 	int err, devcnt, i;
 
-	/* QUICK HACK */
+	/* Avoid compiler warnings. */
 	deviceinfo = deviceinfo;
 
 	if (libusb_init(&usb_context) != 0) {
 		g_warning("Failed to initialize USB.");
 		return 0;
 	}
-	libusb_set_debug(usb_context, 3);
 
 	/* Find all Saleae Logic devices and upload firmware to all of them. */
 	devcnt = 0;
@@ -318,7 +319,7 @@ static int hw_init(char *deviceinfo)
 		if (des.idVendor != USB_VENDOR || des.idProduct != USB_PRODUCT)
 			continue; /* Not a Saleae Logic... */
 
-		sdi = sigrok_device_instance_new(devcnt, ST_INITIALIZING,
+		sdi = sr_device_instance_new(devcnt, SR_ST_INITIALIZING,
 			USB_VENDOR_NAME, USB_MODEL_NAME, USB_MODEL_VERSION);
 		if (!sdi)
 			return 0;
@@ -334,11 +335,11 @@ static int hw_init(char *deviceinfo)
 				g_warning("firmware upload failed for "
 					  "device %d", devcnt);
 
-			sdi->usb = usb_device_instance_new
+			sdi->usb = sr_usb_device_instance_new
 				(libusb_get_bus_number(devlist[i]), 0, NULL);
 		} else {
 			/* Already has the firmware, so fix the new address. */
-			sdi->usb = usb_device_instance_new
+			sdi->usb = sr_usb_device_instance_new
 			    (libusb_get_bus_number(devlist[i]),
 			     libusb_get_device_address(devlist[i]), NULL);
 		}
@@ -352,7 +353,7 @@ static int hw_init(char *deviceinfo)
 static int hw_opendev(int device_index)
 {
 	GTimeVal cur_time;
-	struct sigrok_device_instance *sdi;
+	struct sr_device_instance *sdi;
 	int timediff, err;
 	unsigned int cur, upd;
 
@@ -365,7 +366,7 @@ static int hw_opendev(int device_index)
 		timediff = cur - upd;
 		if (timediff < FIRMWARE_RENUM_DELAY) {
 			timediff = FIRMWARE_RENUM_DELAY - timediff;
-			g_message("waiting %d ms for device to reset",
+			g_message("saleae: waiting %d ms for device to reset",
 				  timediff);
 			g_usleep(timediff * 1000);
 			firmware_updated.tv_sec = 0;
@@ -374,30 +375,30 @@ static int hw_opendev(int device_index)
 
 	if (!(sdi = sl_open_device(device_index))) {
 		g_warning("unable to open device");
-		return SIGROK_ERR;
+		return SR_ERR;
 	}
 
 	err = libusb_claim_interface(sdi->usb->devhdl, USB_INTERFACE);
 	if (err != 0) {
 		g_warning("Unable to claim interface: %d", err);
-		return SIGROK_ERR;
+		return SR_ERR;
 	}
 
 	if (cur_samplerate == 0) {
 		/* Samplerate hasn't been set; default to the slowest one. */
-		if (hw_set_configuration(device_index, HWCAP_SAMPLERATE,
-		    &supported_samplerates[0]) == SIGROK_ERR)
-			return SIGROK_ERR;
+		if (hw_set_configuration(device_index, SR_HWCAP_SAMPLERATE,
+		    &supported_samplerates[0]) == SR_ERR)
+			return SR_ERR;
 	}
 
-	return SIGROK_OK;
+	return SR_OK;
 }
 
 static void hw_closedev(int device_index)
 {
-	struct sigrok_device_instance *sdi;
+	struct sr_device_instance *sdi;
 
-	if ((sdi = get_sigrok_device_instance(device_instances, device_index)))
+	if ((sdi = sr_get_device_instance(device_instances, device_index)))
 		close_device(sdi);
 }
 
@@ -407,7 +408,7 @@ static void hw_cleanup(void)
 
 	/* Properly close all devices... */
 	for (l = device_instances; l; l = l->next)
-		close_device((struct sigrok_device_instance *)l->data);
+		close_device((struct sr_device_instance *)l->data);
 
 	/* ...and free all their memory. */
 	for (l = device_instances; l; l = l->next)
@@ -422,26 +423,26 @@ static void hw_cleanup(void)
 
 static void *hw_get_device_info(int device_index, int device_info_id)
 {
-	struct sigrok_device_instance *sdi;
+	struct sr_device_instance *sdi;
 	void *info = NULL;
 
-	if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
+	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
 		return NULL;
 
 	switch (device_info_id) {
-	case DI_INSTANCE:
+	case SR_DI_INSTANCE:
 		info = sdi;
 		break;
-	case DI_NUM_PROBES:
+	case SR_DI_NUM_PROBES:
 		info = GINT_TO_POINTER(NUM_PROBES);
 		break;
-	case DI_SAMPLERATES:
+	case SR_DI_SAMPLERATES:
 		info = &samplerates;
 		break;
-	case DI_TRIGGER_TYPES:
+	case SR_DI_TRIGGER_TYPES:
 		info = TRIGGER_TYPES;
 		break;
-	case DI_CUR_SAMPLERATE:
+	case SR_DI_CUR_SAMPLERATE:
 		info = &cur_samplerate;
 		break;
 	}
@@ -451,13 +452,13 @@ static void *hw_get_device_info(int device_index, int device_info_id)
 
 static int hw_get_status(int device_index)
 {
-	struct sigrok_device_instance *sdi;
+	struct sr_device_instance *sdi;
 
-	sdi = get_sigrok_device_instance(device_instances, device_index);
+	sdi = sr_get_device_instance(device_instances, device_index);
 	if (sdi)
 		return sdi->status;
 	else
-		return ST_NOT_FOUND;
+		return SR_ST_NOT_FOUND;
 }
 
 static int *hw_get_capabilities(void)
@@ -465,7 +466,7 @@ static int *hw_get_capabilities(void)
 	return capabilities;
 }
 
-static int set_configuration_samplerate(struct sigrok_device_instance *sdi,
+static int set_configuration_samplerate(struct sr_device_instance *sdi,
 					uint64_t samplerate)
 {
 	uint8_t divider;
@@ -477,11 +478,11 @@ static int set_configuration_samplerate(struct sigrok_device_instance *sdi,
 			break;
 	}
 	if (supported_samplerates[i] == 0)
-		return SIGROK_ERR_SAMPLERATE;
+		return SR_ERR_SAMPLERATE;
 
 	divider = (uint8_t) (48 / (samplerate / 1000000.0)) - 1;
 
-	g_message("setting samplerate to %" PRIu64 " Hz (divider %d)",
+	g_message("saleae: setting samplerate to %" PRIu64 " Hz (divider %d)",
 		  samplerate, divider);
 	buf[0] = 0x01;
 	buf[1] = divider;
@@ -489,33 +490,33 @@ static int set_configuration_samplerate(struct sigrok_device_instance *sdi,
 				   buf, 2, &result, 500);
 	if (ret != 0) {
 		g_warning("failed to set samplerate: %d", ret);
-		return SIGROK_ERR;
+		return SR_ERR;
 	}
 	cur_samplerate = samplerate;
 
-	return SIGROK_OK;
+	return SR_OK;
 }
 
 static int hw_set_configuration(int device_index, int capability, void *value)
 {
-	struct sigrok_device_instance *sdi;
+	struct sr_device_instance *sdi;
 	int ret;
 	uint64_t *tmp_u64;
 
-	if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-		return SIGROK_ERR;
+	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
+		return SR_ERR;
 
-	if (capability == HWCAP_SAMPLERATE) {
+	if (capability == SR_HWCAP_SAMPLERATE) {
 		tmp_u64 = value;
 		ret = set_configuration_samplerate(sdi, *tmp_u64);
-	} else if (capability == HWCAP_PROBECONFIG) {
+	} else if (capability == SR_HWCAP_PROBECONFIG) {
 		ret = configure_probes((GSList *) value);
-	} else if (capability == HWCAP_LIMIT_SAMPLES) {
+	} else if (capability == SR_HWCAP_LIMIT_SAMPLES) {
 		tmp_u64 = value;
 		limit_samples = *tmp_u64;
-		ret = SIGROK_OK;
+		ret = SR_OK;
 	} else {
-		ret = SIGROK_ERR;
+		ret = SR_ERR;
 	}
 
 	return ret;
@@ -525,7 +526,7 @@ static int receive_data(int fd, int revents, void *user_data)
 {
 	struct timeval tv;
 
-	/* QUICK HACK */
+	/* Avoid compiler warnings. */
 	fd = fd;
 	revents = revents;
 	user_data = user_data;
@@ -540,7 +541,7 @@ void receive_transfer(struct libusb_transfer *transfer)
 {
 	static int num_samples = 0;
 	static int empty_transfer_count = 0;
-	struct datafeed_packet packet;
+	struct sr_datafeed_packet packet;
 	void *user_data;
 	int cur_buflen, trigger_offset, i;
 	unsigned char *cur_buf, *new_buf;
@@ -559,7 +560,7 @@ void receive_transfer(struct libusb_transfer *transfer)
 		return;
 	}
 
-	g_message("receive_transfer(): status %d received %d bytes",
+	g_message("saleae: receive_transfer(): status %d received %d bytes",
 		  transfer->status, transfer->actual_length);
 
 	/* Save incoming transfer before reusing the transfer struct. */
@@ -606,7 +607,7 @@ void receive_transfer(struct libusb_transfer *transfer)
 					 * TODO: Send pre-trigger buffer to session bus.
 					 * Tell the frontend we hit the trigger here.
 					 */
-					packet.type = DF_TRIGGER;
+					packet.type = SR_DF_TRIGGER;
 					packet.length = 0;
 					session_bus(user_data, &packet);
 
@@ -614,8 +615,9 @@ void receive_transfer(struct libusb_transfer *transfer)
 					 * Send the samples that triggered it, since we're
 					 * skipping past them.
 					 */
-					packet.type = DF_LOGIC8;
+					packet.type = SR_DF_LOGIC;
 					packet.length = trigger_stage;
+					packet.unitsize = 1;
 					packet.payload = trigger_buffer;
 					session_bus(user_data, &packet);
 
@@ -646,14 +648,15 @@ void receive_transfer(struct libusb_transfer *transfer)
 
 	if (trigger_stage == TRIGGER_FIRED) {
 		/* Send the incoming transfer to the session bus. */
-		packet.type = DF_LOGIC8;
+		packet.type = SR_DF_LOGIC;
 		packet.length = cur_buflen - trigger_offset;
+		packet.unitsize = 1;
 		packet.payload = cur_buf + trigger_offset;
 		session_bus(user_data, &packet);
 		g_free(cur_buf);
 
 		num_samples += cur_buflen;
-		if ((unsigned int)num_samples > limit_samples) {
+		if (limit_samples && (unsigned int) num_samples > limit_samples) {
 			hw_stop_acquisition(-1, user_data);
 		}
 	} else {
@@ -666,21 +669,21 @@ void receive_transfer(struct libusb_transfer *transfer)
 
 static int hw_start_acquisition(int device_index, gpointer session_device_id)
 {
-	struct sigrok_device_instance *sdi;
-	struct datafeed_packet *packet;
-	struct datafeed_header *header;
+	struct sr_device_instance *sdi;
+	struct sr_datafeed_packet *packet;
+	struct sr_datafeed_header *header;
 	struct libusb_transfer *transfer;
 	const struct libusb_pollfd **lupfd;
 	int size, i;
 	unsigned char *buf;
 
-	if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
-		return SIGROK_ERR;
+	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
+		return SR_ERR;
 
-	packet = g_malloc(sizeof(struct datafeed_packet));
-	header = g_malloc(sizeof(struct datafeed_header));
+	packet = g_malloc(sizeof(struct sr_datafeed_packet));
+	header = g_malloc(sizeof(struct sr_datafeed_header));
 	if (!packet || !header)
-		return SIGROK_ERR;
+		return SR_ERR;
 
 	/* Start with 2K transfer, subsequently increased to 4K. */
 	size = 2048;
@@ -694,7 +697,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 			/* TODO: Free them all. */
 			libusb_free_transfer(transfer);
 			g_free(buf);
-			return SIGROK_ERR;
+			return SR_ERR;
 		}
 		size = 4096;
 	}
@@ -705,30 +708,31 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 			   NULL);
 	free(lupfd);
 
-	packet->type = DF_HEADER;
-	packet->length = sizeof(struct datafeed_header);
+	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 = cur_samplerate;
-	header->protocol_id = PROTO_RAW;
-	header->num_probes = NUM_PROBES;
+	header->protocol_id = SR_PROTO_RAW;
+	header->num_logic_probes = NUM_PROBES;
+	header->num_analog_probes = 0;
 	session_bus(session_device_id, packet);
 	g_free(header);
 	g_free(packet);
 
-	return SIGROK_OK;
+	return SR_OK;
 }
 
 /* This stops acquisition on ALL devices, ignoring device_index. */
 static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 {
-	struct datafeed_packet packet;
+	struct sr_datafeed_packet packet;
 
-	/* QUICK HACK */
+	/* Avoid compiler warnings. */
 	device_index = device_index;
 
-	packet.type = DF_END;
+	packet.type = SR_DF_END;
 	session_bus(session_device_id, &packet);
 
 	receive_transfer(NULL);
@@ -736,12 +740,12 @@ static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 	/* TODO: Need to cancel and free any queued up transfers. */
 }
 
-struct device_plugin saleae_logic_plugin_info = {
+struct sr_device_plugin saleae_logic_plugin_info = {
 	"saleae-logic",
+	"Saleae Logic",
 	1,
 	hw_init,
 	hw_cleanup,
-
 	hw_opendev,
 	hw_closedev,
 	hw_get_device_info,