#endif
#include <glib.h>
#include <sigrok.h>
+#include <sigrok-internal.h>
#ifdef _WIN32
#define O_NONBLOCK FIONBIO
#endif
-#define NUM_PROBES 32
-#define NUM_TRIGGER_STAGES 4
-#define TRIGGER_TYPES "01"
-#define SERIAL_SPEED B115200
-#define CLOCK_RATE 100000000
+#define NUM_PROBES 32
+#define NUM_TRIGGER_STAGES 4
+#define TRIGGER_TYPES "01"
+#define SERIAL_SPEED B115200
+#define CLOCK_RATE MHZ(100)
+#define MIN_NUM_SAMPLES 4
/* Command opcodes */
-#define CMD_RESET 0x00
-#define CMD_ID 0x02
-#define CMD_SET_FLAGS 0x82
-#define CMD_SET_DIVIDER 0x80
-#define CMD_RUN 0x01
-#define CMD_CAPTURE_SIZE 0x81
-#define CMD_SET_TRIGGER_MASK_0 0xc0
-#define CMD_SET_TRIGGER_MASK_1 0xc4
-#define CMD_SET_TRIGGER_MASK_2 0xc8
-#define CMD_SET_TRIGGER_MASK_3 0xcc
-#define CMD_SET_TRIGGER_VALUE_0 0xc1
-#define CMD_SET_TRIGGER_VALUE_1 0xc5
-#define CMD_SET_TRIGGER_VALUE_2 0xc9
-#define CMD_SET_TRIGGER_VALUE_3 0xcd
-#define CMD_SET_TRIGGER_CONFIG_0 0xc2
-#define CMD_SET_TRIGGER_CONFIG_1 0xc6
-#define CMD_SET_TRIGGER_CONFIG_2 0xca
-#define CMD_SET_TRIGGER_CONFIG_3 0xce
+#define CMD_RESET 0x00
+#define CMD_ID 0x02
+#define CMD_SET_FLAGS 0x82
+#define CMD_SET_DIVIDER 0x80
+#define CMD_RUN 0x01
+#define CMD_CAPTURE_SIZE 0x81
+#define CMD_SET_TRIGGER_MASK_0 0xc0
+#define CMD_SET_TRIGGER_MASK_1 0xc4
+#define CMD_SET_TRIGGER_MASK_2 0xc8
+#define CMD_SET_TRIGGER_MASK_3 0xcc
+#define CMD_SET_TRIGGER_VALUE_0 0xc1
+#define CMD_SET_TRIGGER_VALUE_1 0xc5
+#define CMD_SET_TRIGGER_VALUE_2 0xc9
+#define CMD_SET_TRIGGER_VALUE_3 0xcd
+#define CMD_SET_TRIGGER_CONFIG_0 0xc2
+#define CMD_SET_TRIGGER_CONFIG_1 0xc6
+#define CMD_SET_TRIGGER_CONFIG_2 0xca
+#define CMD_SET_TRIGGER_CONFIG_3 0xce
/* Bitmasks for CMD_FLAGS */
-#define FLAG_DEMUX 0x01
-#define FLAG_FILTER 0x02
-#define FLAG_CHANNELGROUP_1 0x04
-#define FLAG_CHANNELGROUP_2 0x08
-#define FLAG_CHANNELGROUP_3 0x10
-#define FLAG_CHANNELGROUP_4 0x20
-#define FLAG_CLOCK_EXTERNAL 0x40
-#define FLAG_CLOCK_INVERTED 0x80
-#define FLAG_RLE 0x0100
+#define FLAG_DEMUX 0x01
+#define FLAG_FILTER 0x02
+#define FLAG_CHANNELGROUP_1 0x04
+#define FLAG_CHANNELGROUP_2 0x08
+#define FLAG_CHANNELGROUP_3 0x10
+#define FLAG_CHANNELGROUP_4 0x20
+#define FLAG_CLOCK_EXTERNAL 0x40
+#define FLAG_CLOCK_INVERTED 0x80
+#define FLAG_RLE 0x0100
static int capabilities[] = {
HWCAP_LOGIC_ANALYZER,
g_debug("ols: sending cmd 0x%.2x", command);
buf[0] = command;
if (serial_write(fd, buf, 1) != 1)
- return SIGROK_ERR;
+ return SR_ERR;
- return SIGROK_OK;
+ return SR_OK;
}
static int send_longcommand(int fd, uint8_t command, uint32_t data)
buf[3] = (data & 0xff00) >> 8;
buf[4] = data & 0xff;
if (serial_write(fd, buf, 5) != 5)
- return SIGROK_ERR;
+ return SR_ERR;
- return SIGROK_OK;
+ return SR_OK;
}
static int configure_probes(GSList *probes)
* TODO: Only supporting parallel mode, with
* up to 4 stages.
*/
- return SIGROK_ERR;
+ return SR_ERR;
}
if (stage > num_stages)
num_stages = stage;
}
- return SIGROK_OK;
+ return SR_OK;
}
static uint32_t reverse16(uint32_t in)
static int hw_init(char *deviceinfo)
{
- struct sigrok_device_instance *sdi;
+ struct sr_device_instance *sdi;
GSList *ports, *l;
GPollFD *fds;
int devcnt, final_devcnt, num_ports, fd, ret, i;
if (fd != -1) {
serial_params[devcnt] = serial_backup_params(fd);
serial_set_params(fd, 115200, 8, 0, 1, 2);
- ret = SIGROK_OK;
+ ret = SR_OK;
for (i = 0; i < 5; i++) {
if ((ret = send_shortcommand(fd,
- CMD_RESET)) != SIGROK_OK) {
+ CMD_RESET)) != SR_OK) {
/* Serial port is not writable. */
break;
}
}
- if (ret != SIGROK_OK) {
+ if (ret != SR_OK) {
serial_restore_params(fd,
serial_params[devcnt]);
serial_close(fd);
if (!strncmp(buf, "1SLO", 4)
|| !strncmp(buf, "1ALS", 4)) {
if (!strncmp(buf, "1SLO", 4))
- sdi = sigrok_device_instance_new
+ sdi = sr_device_instance_new
(final_devcnt, ST_INACTIVE,
"Openbench",
"Logic Sniffer", "v1.0");
else
- sdi = sigrok_device_instance_new
+ sdi = sr_device_instance_new
(final_devcnt, ST_INACTIVE,
"Openbench", "Logic Sniffer",
"v1.0");
static int hw_opendev(int device_index)
{
- struct sigrok_device_instance *sdi;
+ struct sr_device_instance *sdi;
- if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
- return SIGROK_ERR;
+ if (!(sdi = get_sr_device_instance(device_instances, device_index)))
+ return SR_ERR;
sdi->serial->fd = serial_open(sdi->serial->port, O_RDWR);
if (sdi->serial->fd == -1)
- return SIGROK_ERR;
+ return SR_ERR;
sdi->status = ST_ACTIVE;
- 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 = get_sr_device_instance(device_instances, device_index)))
return;
if (sdi->serial->fd != -1) {
static void hw_cleanup(void)
{
GSList *l;
- struct sigrok_device_instance *sdi;
+ struct sr_device_instance *sdi;
/* Properly close all devices. */
for (l = device_instances; l; l = l->next) {
sdi = l->data;
if (sdi->serial->fd != -1)
serial_close(sdi->serial->fd);
- sigrok_device_instance_free(sdi);
+ sr_device_instance_free(sdi);
}
g_slist_free(device_instances);
device_instances = NULL;
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;
- if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
+ if (!(sdi = get_sr_device_instance(device_instances, device_index)))
return NULL;
info = NULL;
static int hw_get_status(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 = get_sr_device_instance(device_instances, device_index)))
return ST_NOT_FOUND;
return sdi->status;
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)
{
uint32_t divider;
if (samplerate < samplerates.low || samplerate > samplerates.high)
- return SIGROK_ERR_SAMPLERATE;
+ return SR_ERR_SAMPLERATE;
if (samplerate > CLOCK_RATE) {
flag_reg |= FLAG_DEMUX;
g_message("ols: setting samplerate to %" PRIu64 " Hz (divider %u, demux %s)",
samplerate, divider, flag_reg & FLAG_DEMUX ? "on" : "off");
- if (send_longcommand(sdi->serial->fd, CMD_SET_DIVIDER, reverse32(divider)) != SIGROK_OK)
- return SIGROK_ERR;
+ if (send_longcommand(sdi->serial->fd, CMD_SET_DIVIDER, reverse32(divider)) != SR_OK)
+ 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 = get_sr_device_instance(device_instances, device_index)))
+ return SR_ERR;
if (sdi->status != ST_ACTIVE)
- return SIGROK_ERR;
+ return SR_ERR;
switch (capability) {
case HWCAP_SAMPLERATE:
break;
case HWCAP_LIMIT_SAMPLES:
tmp_u64 = value;
+ if (*tmp_u64 < MIN_NUM_SAMPLES)
+ return SR_ERR;
limit_samples = *tmp_u64;
g_message("ols: sample limit %" PRIu64, limit_samples);
- ret = SIGROK_OK;
+ ret = SR_OK;
break;
case HWCAP_CAPTURE_RATIO:
tmp_u64 = value;
capture_ratio = *tmp_u64;
if (capture_ratio < 0 || capture_ratio > 100) {
capture_ratio = 0;
- ret = SIGROK_ERR;
+ ret = SR_ERR;
} else
- ret = SIGROK_OK;
+ ret = SR_OK;
break;
default:
- ret = SIGROK_ERR;
+ ret = SR_ERR;
}
return ret;
int i;
struct datafeed_packet *packet;
struct datafeed_header *header;
- struct sigrok_device_instance *sdi;
+ struct sr_device_instance *sdi;
uint32_t trigger_config[4];
uint32_t data;
uint16_t readcount, delaycount;
uint8_t changrp_mask;
- if (!(sdi = get_sigrok_device_instance(device_instances, device_index)))
- return SIGROK_ERR;
+ if (!(sdi = get_sr_device_instance(device_instances, device_index)))
+ return SR_ERR;
if (sdi->status != ST_ACTIVE)
- return SIGROK_ERR;
+ return SR_ERR;
readcount = limit_samples / 4;
trigger_at = (readcount - delaycount) * 4 - num_stages;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
- reverse32(trigger_mask[0])) != SIGROK_OK)
- return SIGROK_ERR;
+ reverse32(trigger_mask[0])) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0,
- reverse32(trigger_value[0])) != SIGROK_OK)
- return SIGROK_ERR;
+ reverse32(trigger_value[0])) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
- trigger_config[0]) != SIGROK_OK)
- return SIGROK_ERR;
+ trigger_config[0]) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_1,
- reverse32(trigger_mask[1])) != SIGROK_OK)
- return SIGROK_ERR;
+ reverse32(trigger_mask[1])) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_1,
- reverse32(trigger_value[1])) != SIGROK_OK)
- return SIGROK_ERR;
+ reverse32(trigger_value[1])) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_1,
- trigger_config[1]) != SIGROK_OK)
- return SIGROK_ERR;
+ trigger_config[1]) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_2,
- reverse32(trigger_mask[2])) != SIGROK_OK)
- return SIGROK_ERR;
+ reverse32(trigger_mask[2])) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_2,
- reverse32(trigger_value[2])) != SIGROK_OK)
- return SIGROK_ERR;
+ reverse32(trigger_value[2])) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_2,
- trigger_config[2]) != SIGROK_OK)
- return SIGROK_ERR;
+ trigger_config[2]) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_3,
- reverse32(trigger_mask[3])) != SIGROK_OK)
- return SIGROK_ERR;
+ reverse32(trigger_mask[3])) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_3,
- reverse32(trigger_value[3])) != SIGROK_OK)
- return SIGROK_ERR;
+ reverse32(trigger_value[3])) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_3,
- trigger_config[3]) != SIGROK_OK)
- return SIGROK_ERR;
+ trigger_config[3]) != SR_OK)
+ return SR_ERR;
} else {
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
- trigger_mask[0]) != SIGROK_OK)
- return SIGROK_ERR;
+ trigger_mask[0]) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0,
- trigger_value[0]) != SIGROK_OK)
- return SIGROK_ERR;
+ trigger_value[0]) != SR_OK)
+ return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
- 0x00000008) != SIGROK_OK)
- return SIGROK_ERR;
+ 0x00000008) != SR_OK)
+ return SR_ERR;
delaycount = readcount;
}
/* Send sample limit and pre/post-trigger capture ratio. */
data = ((readcount - 1) & 0xffff) << 16;
data |= (delaycount - 1) & 0xffff;
- if (send_longcommand(sdi->serial->fd, CMD_CAPTURE_SIZE, reverse16(data)) != SIGROK_OK)
- return SIGROK_ERR;
+ 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
flag_reg |= ~(changrp_mask << 2) & 0x3c;
flag_reg |= FLAG_FILTER;
data = flag_reg << 24;
- if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SIGROK_OK)
- return SIGROK_ERR;
+ if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SR_OK)
+ return SR_ERR;
/* Start acquisition on the device. */
- if (send_shortcommand(sdi->serial->fd, CMD_RUN) != SIGROK_OK)
- return SIGROK_ERR;
+ if (send_shortcommand(sdi->serial->fd, CMD_RUN) != SR_OK)
+ return SR_ERR;
source_add(sdi->serial->fd, G_IO_IN, -1, receive_data,
session_device_id);
packet = g_malloc(sizeof(struct datafeed_packet));
header = g_malloc(sizeof(struct datafeed_header));
if (!packet || !header)
- return SIGROK_ERR;
+ return SR_ERR;
packet->type = DF_HEADER;
packet->length = sizeof(struct datafeed_header);
packet->payload = (unsigned char *)header;
g_free(header);
g_free(packet);
- return SIGROK_OK;
+ return SR_OK;
}
static void hw_stop_acquisition(int device_index, gpointer session_device_id)
{
struct datafeed_packet packet;
- /* QUICK HACK */
+ /* Avoid compiler warnings. */
device_index = device_index;
packet.type = DF_END;
projects / libsigrok.git / blobdiff