X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fsaleae-logic%2Fsaleae-logic.c;h=81ef3e8c7a96188d3457e308e7afa60e22dcd2df;hb=6f1be0a2d40b3998abd8d10b5479e4538bc4ff1e;hp=8a74332e615266ad40abba5a83b9afe4bbb82167;hpb=6c29007211e3a35bb90db53cd22042f04fbe4e44;p=libsigrok.git

diff --git a/hardware/saleae-logic/saleae-logic.c b/hardware/saleae-logic/saleae-logic.c
index 8a74332e..81ef3e8c 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>
@@ -25,7 +26,6 @@
 #include <libusb.h>
 #include <sigrok.h>
 #include <sigrok-internal.h>
-#include "config.h"
 
 #define USB_VENDOR	            0x0925
 #define USB_PRODUCT			0x3881
@@ -50,12 +50,12 @@
 
 /* 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,
-	HWCAP_CONTINUOUS,
+	SR_HWCAP_LIMIT_SAMPLES,
+	SR_HWCAP_CONTINUOUS,
 	0,
 };
 
@@ -68,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;
 
@@ -86,7 +86,7 @@ static uint64_t supported_samplerates[] = {
 	0,
 };
 
-static struct samplerates samplerates = {
+static struct sr_samplerates samplerates = {
 	KHZ(200),
 	MHZ(24),
 	0,
@@ -101,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);
@@ -112,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;
@@ -166,7 +166,7 @@ int check_conf_profile(libusb_device *dev)
 	return ret;
 }
 
-struct sr_device_instance *sl_open_device(int device_index)
+static struct sr_device_instance *sl_open_device(int device_index)
 {
 	struct sr_device_instance *sdi;
 	libusb_device **devlist;
@@ -177,7 +177,7 @@ struct sr_device_instance *sl_open_device(int 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
@@ -191,7 +191,7 @@ struct sr_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.
@@ -203,18 +203,18 @@ struct sr_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;
 
@@ -238,12 +238,12 @@ static void close_device(struct sr_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;
@@ -256,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);
@@ -319,7 +319,7 @@ static int hw_init(char *deviceinfo)
 		if (des.idVendor != USB_VENDOR || des.idProduct != USB_PRODUCT)
 			continue; /* Not a Saleae Logic... */
 
-		sdi = sr_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;
@@ -386,7 +386,7 @@ static int hw_opendev(int device_index)
 
 	if (cur_samplerate == 0) {
 		/* Samplerate hasn't been set; default to the slowest one. */
-		if (hw_set_configuration(device_index, HWCAP_SAMPLERATE,
+		if (hw_set_configuration(device_index, SR_HWCAP_SAMPLERATE,
 		    &supported_samplerates[0]) == SR_ERR)
 			return SR_ERR;
 	}
@@ -430,19 +430,19 @@ static void *hw_get_device_info(int device_index, int device_info_id)
 		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;
 	}
@@ -458,7 +458,7 @@ static int hw_get_status(int device_index)
 	if (sdi)
 		return sdi->status;
 	else
-		return ST_NOT_FOUND;
+		return SR_ST_NOT_FOUND;
 }
 
 static int *hw_get_capabilities(void)
@@ -506,12 +506,12 @@ static int hw_set_configuration(int device_index, int capability, void *value)
 	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 = SR_OK;
@@ -607,19 +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_LOGIC;
+					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;
@@ -648,11 +648,11 @@ void receive_transfer(struct libusb_transfer *transfer)
 
 	if (trigger_stage == TRIGGER_FIRED) {
 		/* Send the incoming transfer to the session bus. */
-		packet.type = DF_LOGIC;
+		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;
@@ -704,20 +704,20 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
 
 	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->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->protocol_id = SR_PROTO_RAW;
 	header->num_logic_probes = NUM_PROBES;
 	header->num_analog_probes = 0;
-	session_bus(session_device_id, packet);
+	sr_session_bus(session_device_id, packet);
 	g_free(header);
 	g_free(packet);
 
@@ -732,8 +732,8 @@ static void hw_stop_acquisition(int device_index, gpointer session_device_id)
 	/* 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);