#include <glib.h>
#include <libusb.h>
#include <sigrok.h>
+#include <sigrok-internal.h>
#include "config.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[] = {
/* These are really implemented in the driver, not the hardware. */
HWCAP_LIMIT_SAMPLES,
+ HWCAP_CONTINUOUS,
0,
};
trigger_value[stage] |= probe_bit;
stage++;
if (stage > NUM_TRIGGER_STAGES)
- return SIGROK_ERR;
+ return SR_ERR;
}
}
else
trigger_stage = 0;
- return SIGROK_OK;
+ return SR_OK;
}
/*
libusb_device **devlist;
int err, devcnt, i;
- /* QUICK HACK */
+ /* Avoid compiler warnings. */
deviceinfo = deviceinfo;
if (libusb_init(&usb_context) != 0) {
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;
+ &supported_samplerates[0]) == SR_ERR)
+ return SR_ERR;
}
- return SIGROK_OK;
+ return SR_OK;
}
static void hw_closedev(int device_index)
break;
}
if (supported_samplerates[i] == 0)
- return SIGROK_ERR_SAMPLERATE;
+ return SR_ERR_SAMPLERATE;
divider = (uint8_t) (48 / (samplerate / 1000000.0)) - 1;
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)
uint64_t *tmp_u64;
if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
- return SIGROK_ERR;
+ return SR_ERR;
if (capability == HWCAP_SAMPLERATE) {
tmp_u64 = value;
} else if (capability == 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;
{
struct timeval tv;
- /* QUICK HACK */
+ /* Avoid compiler warnings. */
fd = fd;
revents = revents;
user_data = user_data;
* Send the samples that triggered it, since we're
* skipping past them.
*/
- packet.type = DF_LOGIC8;
+ packet.type = DF_LOGIC;
packet.length = trigger_stage;
+ packet.unitsize = 1;
packet.payload = trigger_buffer;
session_bus(user_data, &packet);
if (trigger_stage == TRIGGER_FIRED) {
/* Send the incoming transfer to the session bus. */
- packet.type = DF_LOGIC8;
+ packet.type = 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 {
unsigned char *buf;
if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
- return SIGROK_ERR;
+ return SR_ERR;
packet = g_malloc(sizeof(struct datafeed_packet));
header = g_malloc(sizeof(struct datafeed_header));
if (!packet || !header)
- return SIGROK_ERR;
+ return SR_ERR;
/* Start with 2K transfer, subsequently increased to 4K. */
size = 2048;
/* TODO: Free them all. */
libusb_free_transfer(transfer);
g_free(buf);
- return SIGROK_ERR;
+ return SR_ERR;
}
size = 4096;
}
gettimeofday(&header->starttime, NULL);
header->samplerate = cur_samplerate;
header->protocol_id = PROTO_RAW;
- header->num_probes = NUM_PROBES;
+ 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. */
{
struct datafeed_packet packet;
- /* QUICK HACK */
+ /* Avoid compiler warnings. */
device_index = device_index;
packet.type = DF_END;