X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fsaleae-logic%2Fsaleae-logic.c;h=eff4cf9e994edc4712694beaae7738b9a1a77479;hb=54ac5277c5e462f1778300b9bc3fdd4709ecb2dc;hp=58f31acfaef37c191b8d4d7d4ecba436cff1a3b1;hpb=e6ac9ac808b900287a80ea44d9c661703e3a101c;p=libsigrok.git

diff --git a/hardware/saleae-logic/saleae-logic.c b/hardware/saleae-logic/saleae-logic.c
index 58f31acf..eff4cf9e 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;
 
 /*
@@ -66,7 +68,7 @@ static GSList *device_instances = NULL;
  * upgrade -- this is like a global lock. No device will open until a proper
  * delay after the last device was upgraded.
  */
-GTimeVal firmware_updated = { 0, 0 };
+static GTimeVal firmware_updated = { 0, 0 };
 
 static libusb_context *usb_context = NULL;
 
@@ -84,7 +86,7 @@ static uint64_t supported_samplerates[] = {
 	0,
 };
 
-static struct samplerates samplerates = {
+static struct sr_samplerates samplerates = {
 	KHZ(200),
 	MHZ(24),
 	0,
@@ -99,7 +101,7 @@ static uint8_t trigger_mask[NUM_TRIGGER_STAGES] = { 0 };
 static uint8_t trigger_value[NUM_TRIGGER_STAGES] = { 0 };
 static uint8_t trigger_buffer[NUM_TRIGGER_STAGES] = { 0 };
 
-int trigger_stage = TRIGGER_FIRED;
+static int trigger_stage = TRIGGER_FIRED;
 
 static int hw_set_configuration(int device_index, int capability, void *value);
 static void hw_stop_acquisition(int device_index, gpointer session_device_id);
@@ -110,7 +112,7 @@ static void hw_stop_acquisition(int device_index, gpointer session_device_id);
  * @return 1 if the device's configuration profile match the Logic firmware's
  *         configuration, 0 otherwise.
  */
-int check_conf_profile(libusb_device *dev)
+static int check_conf_profile(libusb_device *dev)
 {
 	struct libusb_device_descriptor des;
 	struct libusb_config_descriptor *conf_dsc = NULL;
@@ -164,18 +166,18 @@ int check_conf_profile(libusb_device *dev)
 	return ret;
 }
 
-struct sigrok_device_instance *sl_open_device(int device_index)
+static 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,18 +203,18 @@ 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;
 }
 
-int upload_firmware(libusb_device *dev)
+static int upload_firmware(libusb_device *dev)
 {
 	int ret;
 
@@ -226,7 +228,7 @@ 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;
@@ -236,12 +238,12 @@ static void close_device(struct sigrok_device_instance *sdi)
 	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)
 {
-	struct probe *probe;
+	struct sr_probe *probe;
 	GSList *l;
 	int probe_bit, stage, i;
 	char *tc;
@@ -254,7 +256,7 @@ static int configure_probes(GSList *probes)
 
 	stage = -1;
 	for (l = probes; l; l = l->next) {
-		probe = (struct probe *)l->data;
+		probe = (struct sr_probe *)l->data;
 		if (probe->enabled == FALSE)
 			continue;
 		probe_bit = 1 << (probe->index - 1);
@@ -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,21 +284,21 @@ static int configure_probes(GSList *probes)
 	else
 		trigger_stage = 0;
 
-	return SIGROK_OK;
+	return SR_OK;
 }
 
 /*
  * API callbacks
  */
 
-static int hw_init(char *deviceinfo)
+static int hw_init(const 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) {
@@ -317,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;
@@ -333,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);
 		}
@@ -351,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;
 
@@ -373,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);
 }
 
@@ -406,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)
@@ -421,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;
 	}
@@ -450,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)
@@ -464,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;
@@ -476,7 +478,7 @@ 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;
 
@@ -488,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;
@@ -524,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;
@@ -539,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;
@@ -605,18 +607,19 @@ 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);
+					sr_session_bus(user_data, &packet);
 
 					/*
 					 * 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);
+					sr_session_bus(user_data, &packet);
 
 					trigger_stage = TRIGGER_FIRED;
 					break;
@@ -645,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);
+		sr_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 {
@@ -665,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;
@@ -693,54 +697,55 @@ 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;
 	}
 
 	lupfd = libusb_get_pollfds(usb_context);
 	for (i = 0; lupfd[i]; i++)
-		source_add(lupfd[i]->fd, lupfd[i]->events, 40, receive_data,
-			   NULL);
+		sr_source_add(lupfd[i]->fd, lupfd[i]->events, 40, receive_data,
+			      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;
-	session_bus(session_device_id, packet);
+	header->protocol_id = SR_PROTO_RAW;
+	header->num_logic_probes = NUM_PROBES;
+	header->num_analog_probes = 0;
+	sr_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;
-	session_bus(session_device_id, &packet);
+	packet.type = SR_DF_END;
+	sr_session_bus(session_device_id, &packet);
 
 	receive_transfer(NULL);
 
 	/* 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,