BLAHAJ
/
libsigrok
10
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

OLS driver overhaul 

support for metadata in recent versions of the FPGA code
moved constants and structs out to separate header file
got rid of all device instance-specific globals
This commit is contained in:
Bert Vermeulen 2011-04-03 06:15:45 +02:00
parent f437ea3fe2
commit 4fe9a6da79
4 changed files with 383 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
hardware/openbench-logic-sniffer/Makefile.am
View File

@ -23,7 +23,8 @@ if LA_OLS
noinst_LTLIBRARIES = libsigrokhwols.la noinst_LTLIBRARIES = libsigrokhwols.la
libsigrokhwols_la_SOURCES = \ libsigrokhwols_la_SOURCES = \
ols.c ols.c \
ols.h
libsigrokhwols_la_CFLAGS = \ libsigrokhwols_la_CFLAGS = \
-I$(top_srcdir)/libsigrok -I$(top_srcdir)/libsigrok

450
hardware/openbench-logic-sniffer/ols.c
View File

@ -40,48 +40,12 @@
#include <glib.h> #include <glib.h>
#include <sigrok.h> #include <sigrok.h>
#include <sigrok-internal.h> #include <sigrok-internal.h>
#include "ols.h"
#ifdef _WIN32 #ifdef _WIN32
#define O_NONBLOCK FIONBIO #define O_NONBLOCK FIONBIO
#endif #endif
#define NUM_PROBES 32
#define NUM_TRIGGER_STAGES 4
#define TRIGGER_TYPES "01"
#define SERIAL_SPEED B115200
#define CLOCK_RATE SR_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
/* 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
static int capabilities[] = { static int capabilities[] = {
SR_HWCAP_LOGIC_ANALYZER, SR_HWCAP_LOGIC_ANALYZER,
@ -91,6 +55,7 @@ static int capabilities[] = {
0, 0,
}; };
/* default supported samplerates, can be overridden by device metadata */
static struct sr_samplerates samplerates = { static struct sr_samplerates samplerates = {
SR_HZ(10), SR_HZ(10),
SR_MHZ(200), SR_MHZ(200),
@ -101,21 +66,7 @@ static struct sr_samplerates samplerates = {
/* List of struct sr_serial_device_instance */ /* List of struct sr_serial_device_instance */
static GSList *device_instances = NULL; static GSList *device_instances = NULL;
/* Current state of the flag register */
static uint32_t flag_reg = 0;
static uint64_t cur_samplerate = 0;
static uint64_t limit_samples = 0;
/*
* Pre/post trigger capture ratio, in percentage.
* 0 means no pre-trigger data.
*/
static int capture_ratio = 0;
static int trigger_at = -1;
static uint32_t probe_mask = 0xffffffff;
static uint32_t trigger_mask[4] = { 0, 0, 0, 0 };
static uint32_t trigger_value[4] = { 0, 0, 0, 0 };
static int num_stages = 0;
static int send_shortcommand(int fd, uint8_t command) static int send_shortcommand(int fd, uint8_t command)
{ {
@ -145,20 +96,20 @@ static int send_longcommand(int fd, uint8_t command, uint32_t data)
return SR_OK; return SR_OK;
} }
static int configure_probes(GSList *probes) static int configure_probes(struct ols_device *ols, GSList *probes)
{ {
struct sr_probe *probe; struct sr_probe *probe;
GSList *l; GSList *l;
int probe_bit, stage, i; int probe_bit, stage, i;
char *tc; char *tc;
probe_mask = 0; ols->probe_mask = 0;
for (i = 0; i < NUM_TRIGGER_STAGES; i++) { for (i = 0; i < NUM_TRIGGER_STAGES; i++) {
trigger_mask[i] = 0; ols->trigger_mask[i] = 0;
trigger_value[i] = 0; ols->trigger_value[i] = 0;
} }
num_stages = 0; ols->num_stages = 0;
for (l = probes; l; l = l->next) { for (l = probes; l; l = l->next) {
probe = (struct sr_probe *)l->data; probe = (struct sr_probe *)l->data;
if (!probe->enabled) if (!probe->enabled)
@ -169,7 +120,7 @@ static int configure_probes(GSList *probes)
* flag register. * flag register.
*/ */
probe_bit = 1 << (probe->index - 1); probe_bit = 1 << (probe->index - 1);
probe_mask |= probe_bit; ols->probe_mask |= probe_bit;
if (!probe->trigger) if (!probe->trigger)
continue; continue;
@ -177,9 +128,9 @@ static int configure_probes(GSList *probes)
/* Configure trigger mask and value. */ /* Configure trigger mask and value. */
stage = 0; stage = 0;
for (tc = probe->trigger; tc && *tc; tc++) { for (tc = probe->trigger; tc && *tc; tc++) {
trigger_mask[stage] |= probe_bit; ols->trigger_mask[stage] |= probe_bit;
if (*tc == '1') if (*tc == '1')
trigger_value[stage] |= probe_bit; ols->trigger_value[stage] |= probe_bit;
stage++; stage++;
if (stage > 3) if (stage > 3)
/* /*
@ -188,8 +139,8 @@ static int configure_probes(GSList *probes)
*/ */
return SR_ERR; return SR_ERR;
} }
if (stage > num_stages) if (stage > ols->num_stages)
num_stages = stage; ols->num_stages = stage;
} }
return SR_OK; return SR_OK;
@ -219,11 +170,144 @@ static uint32_t reverse32(uint32_t in)
return out; return out;
} }
static struct ols_device *ols_device_new(void)
{
struct ols_device *ols;
ols = g_malloc0(sizeof(struct ols_device));
ols->trigger_at = -1;
ols->probe_mask = 0xffffffff;
ols->cur_samplerate = SR_KHZ(200);
return ols;
}
static struct sr_device_instance *get_metadata(int fd)
{
struct sr_device_instance *sdi;
struct ols_device *ols;
uint32_t tmp_int;
uint8_t key, type, token;
GString *tmp_str, *devicename, *version;
gchar tmp_c;
sdi = sr_device_instance_new(0, SR_ST_INACTIVE, NULL, NULL, NULL);
ols = ols_device_new();
sdi->priv = ols;
devicename = g_string_new("");
version = g_string_new("");
key = 0xff;
while (key) {
if (serial_read(fd, &key, 1) != 1 || key == 0x00)
break;
type = key >> 5;
token = key & 0x1f;
switch (type) {
case 0:
/* NULL-terminated string */
tmp_str = g_string_new("");
while (serial_read(fd, &tmp_c, 1) == 1 && tmp_c != '\0')
g_string_append_c(tmp_str, tmp_c);
g_debug("ols: got metadata key 0x%.2x value '%s'", key, tmp_str->str);
switch (token) {
case 0x01:
/* Device name */
devicename = g_string_append(devicename, tmp_str->str);
break;
case 0x02:
/* FPGA firmware version */
if (version->len)
g_string_append(version, ", ");
g_string_append(version, "FPGA version ");
g_string_append(version, tmp_str->str);
break;
case 0x03:
/* Ancillary version */
if (version->len)
g_string_append(version, ", ");
g_string_append(version, "Ancillary version ");
g_string_append(version, tmp_str->str);
break;
default:
g_message("ols: unknown token 0x%.2x: '%s'", token, tmp_str->str);
break;
}
g_string_free(tmp_str, TRUE);
break;
case 1:
/* 32-bit unsigned integer */
if (serial_read(fd, &tmp_int, 4) != 4)
break;
tmp_int = reverse32(tmp_int);
g_debug("ols: got metadata key 0x%.2x value 0x%.8x", key, tmp_int);
switch (token) {
case 0x00:
/* Number of usable probes */
ols->num_probes = tmp_int;
break;
case 0x01:
/* Amount of sample memory available (bytes) */
ols->max_samples = tmp_int;
break;
case 0x02:
/* Amount of dynamic memory available (bytes) */
/* what is this for? */
break;
case 0x03:
/* Maximum sample rate (hz) */
ols->max_samplerate = tmp_int;
break;
case 0x04:
/* protocol version */
ols->protocol_version = tmp_int;
break;
default:
g_message("ols: unknown token 0x%.2x: 0x%.8x", token, tmp_int);
break;
}
break;
case 2:
/* 8-bit unsigned integer */
if (serial_read(fd, &tmp_c, 1) != 1)
break;
g_debug("ols: got metadata key 0x%.2x value 0x%.2x", key, tmp_c);
switch (token) {
case 0x00:
/* Number of usable probes */
ols->num_probes = tmp_c;
break;
case 0x01:
/* protocol version */
ols->protocol_version = tmp_c;
break;
default:
g_message("ols: unknown token 0x%.2x: 0x%.2x", token, tmp_c);
break;
}
break;
default:
/* unknown type */
break;
}
}
sdi->model = devicename->str;
sdi->version = version->str;
g_string_free(devicename, FALSE);
g_string_free(version, FALSE);
return sdi;
}
static int hw_init(const char *deviceinfo) static int hw_init(const char *deviceinfo)
{ {
struct sr_device_instance *sdi; struct sr_device_instance *sdi;
struct ols_device *ols;
GSList *ports, *l; GSList *ports, *l;
GPollFD *fds; GPollFD *fds, probefd;
int devcnt, final_devcnt, num_ports, fd, ret, i; int devcnt, final_devcnt, num_ports, fd, ret, i;
char buf[8], **device_names, **serial_params; char buf[8], **device_names, **serial_params;
@ -282,38 +366,49 @@ static int hw_init(const char *deviceinfo)
final_devcnt = 0; final_devcnt = 0;
g_poll(fds, devcnt, 1); g_poll(fds, devcnt, 1);
for (i = 0; i < devcnt; i++) { for (i = 0; i < devcnt; i++) {
if (fds[i].revents == G_IO_IN) { if (fds[i].revents != G_IO_IN)
if (serial_read(fds[i].fd, buf, 4) == 4) { continue;
if (!strncmp(buf, "1SLO", 4) if (serial_read(fds[i].fd, buf, 4) != 4)
|| !strncmp(buf, "1ALS", 4)) { continue;
if (!strncmp(buf, "1SLO", 4)) if (strncmp(buf, "1SLO", 4) && strncmp(buf, "1ALS", 4))
sdi = sr_device_instance_new continue;
(final_devcnt, SR_ST_INACTIVE,
"Openbench", /* definitely using the OLS protocol, check if it supports
"Logic Sniffer", "v1.0"); * the metadata command
else */
sdi = sr_device_instance_new send_shortcommand(fds[i].fd, CMD_METADATA);
(final_devcnt, SR_ST_INACTIVE, probefd.fd = fds[i].fd;
"Openbench", "Logic Sniffer", probefd.events = G_IO_IN;
"v1.0"); if (g_poll(&probefd, 1, 10) > 0) {
sdi->serial = sr_serial_device_instance_new /* got metadata */
(device_names[i], -1); sdi = get_metadata(fds[i].fd);
device_instances = sdi->index = final_devcnt;
g_slist_append(device_instances, sdi); } else {
/* not an OLS -- some other board that uses the sump protocol */
sdi = sr_device_instance_new(final_devcnt, SR_ST_INACTIVE,
"Sump", "Logic Analyzer", "v1.0");
ols = ols_device_new();
ols->num_probes = 32;
sdi->priv = ols;
}
sdi->serial = sr_serial_device_instance_new(device_names[i], -1);
device_instances = g_slist_append(device_instances, sdi);
final_devcnt++; final_devcnt++;
serial_close(fds[i].fd); serial_close(fds[i].fd);
fds[i].fd = 0; fds[i].fd = 0;
}
}
free(device_names[i]);
} }
/* clean up after all the probing */
for (i = 0; i < devcnt; i++) {
if (fds[i].fd != 0) { if (fds[i].fd != 0) {
serial_restore_params(fds[i].fd, serial_params[i]); serial_restore_params(fds[i].fd, serial_params[i]);
serial_close(fds[i].fd); serial_close(fds[i].fd);
} }
free(serial_params[i]); free(serial_params[i]);
free(device_names[i]);
} }
free(fds); free(fds);
@ -321,8 +416,6 @@ static int hw_init(const char *deviceinfo)
free(serial_params); free(serial_params);
g_slist_free(ports); g_slist_free(ports);
cur_samplerate = SR_KHZ(200);
return final_devcnt; return final_devcnt;
} }
@ -375,10 +468,12 @@ static void hw_cleanup(void)
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_device_info(int device_index, int device_info_id)
{ {
struct sr_device_instance *sdi; struct sr_device_instance *sdi;
struct ols_device *ols;
void *info; void *info;
if (!(sdi = sr_get_device_instance(device_instances, device_index))) if (!(sdi = sr_get_device_instance(device_instances, device_index)))
return NULL; return NULL;
ols = sdi->priv;
info = NULL; info = NULL;
switch (device_info_id) { switch (device_info_id) {
@ -395,7 +490,7 @@ static void *hw_get_device_info(int device_index, int device_info_id)
info = (char *)TRIGGER_TYPES; info = (char *)TRIGGER_TYPES;
break; break;
case SR_DI_CUR_SAMPLERATE: case SR_DI_CUR_SAMPLERATE:
info = &cur_samplerate; info = &ols->cur_samplerate;
break; break;
} }
@ -420,37 +515,37 @@ static int *hw_get_capabilities(void)
static int set_configuration_samplerate(struct sr_device_instance *sdi, static int set_configuration_samplerate(struct sr_device_instance *sdi,
uint64_t samplerate) uint64_t samplerate)
{ {
uint32_t divider; struct ols_device *ols;
if (samplerate < samplerates.low || samplerate > samplerates.high) ols = sdi->priv;
if (ols->max_samplerate) {
if (samplerate > ols->max_samplerate)
return SR_ERR_SAMPLERATE;
} else if (samplerate < samplerates.low || samplerate > samplerates.high)
return SR_ERR_SAMPLERATE; return SR_ERR_SAMPLERATE;
ols->cur_samplerate = samplerate;
if (samplerate > CLOCK_RATE) { if (samplerate > CLOCK_RATE) {
flag_reg |= FLAG_DEMUX; ols->flag_reg |= FLAG_DEMUX;
divider = (CLOCK_RATE * 2 / samplerate) - 1; ols->cur_samplerate_divider = (CLOCK_RATE * 2 / samplerate) - 1;
} else { } else {
flag_reg &= ~FLAG_DEMUX; ols->flag_reg &= ~FLAG_DEMUX;
divider = (CLOCK_RATE / samplerate) - 1; ols->cur_samplerate_divider = (CLOCK_RATE / samplerate) - 1;
} }
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)) != SR_OK)
return SR_ERR;
cur_samplerate = samplerate;
return SR_OK; return SR_OK;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int device_index, int capability, void *value)
{ {
struct sr_device_instance *sdi; struct sr_device_instance *sdi;
struct ols_device *ols;
int ret; int ret;
uint64_t *tmp_u64; uint64_t *tmp_u64;
if (!(sdi = sr_get_device_instance(device_instances, device_index))) if (!(sdi = sr_get_device_instance(device_instances, device_index)))
return SR_ERR; return SR_ERR;
ols = sdi->priv;
if (sdi->status != SR_ST_ACTIVE) if (sdi->status != SR_ST_ACTIVE)
return SR_ERR; return SR_ERR;
@ -461,21 +556,21 @@ static int hw_set_configuration(int device_index, int capability, void *value)
ret = set_configuration_samplerate(sdi, *tmp_u64); ret = set_configuration_samplerate(sdi, *tmp_u64);
break; break;
case SR_HWCAP_PROBECONFIG: case SR_HWCAP_PROBECONFIG:
ret = configure_probes((GSList *) value); ret = configure_probes(ols, (GSList *) value);
break; break;
case SR_HWCAP_LIMIT_SAMPLES: case SR_HWCAP_LIMIT_SAMPLES:
tmp_u64 = value; tmp_u64 = value;
if (*tmp_u64 < MIN_NUM_SAMPLES) if (*tmp_u64 < MIN_NUM_SAMPLES)
return SR_ERR; return SR_ERR;
limit_samples = *tmp_u64; ols->limit_samples = *tmp_u64;
g_message("ols: sample limit %" PRIu64, limit_samples); g_message("ols: sample limit %" PRIu64, ols->limit_samples);
ret = SR_OK; ret = SR_OK;
break; break;
case SR_HWCAP_CAPTURE_RATIO: case SR_HWCAP_CAPTURE_RATIO:
tmp_u64 = value; tmp_u64 = value;
capture_ratio = *tmp_u64; ols->capture_ratio = *tmp_u64;
if (capture_ratio < 0 || capture_ratio > 100) { if (ols->capture_ratio < 0 || ols->capture_ratio > 100) {
capture_ratio = 0; ols->capture_ratio = 0;
ret = SR_ERR; ret = SR_ERR;
} else } else
ret = SR_OK; ret = SR_OK;
@ -489,17 +584,27 @@ static int hw_set_configuration(int device_index, int capability, void *value)
static int receive_data(int fd, int revents, void *user_data) static int receive_data(int fd, int revents, void *user_data)
{ {
static unsigned int num_transfers = 0;
static int num_bytes = 0;
static char last_sample[4] = { 0xff, 0xff, 0xff, 0xff };
static unsigned char sample[4] = { 0, 0, 0, 0 };
static unsigned char tmp_sample[4];
static unsigned char *raw_sample_buf = NULL;
int count, buflen, num_channels, offset, i, j;
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
struct sr_device_instance *sdi;
struct ols_device *ols;
GSList *l;
int count, buflen, num_channels, offset, i, j;
unsigned char byte, *buffer; unsigned char byte, *buffer;
if (num_transfers++ == 0) { /* find this device's ols_device struct by its fd */
ols = NULL;
for (l = device_instances; l; l = l->next) {
sdi = l->data;
if (sdi->serial->fd == fd) {
ols = sdi->priv;
break;
}
}
if (!ols)
/* shouldn't happen */
return TRUE;
if (ols->num_transfers++ == 0) {
/* /*
* First time round, means the device started sending data, * First time round, means the device started sending data,
* and will not stop until done. If it stops sending for * and will not stop until done. If it stops sending for
@ -508,41 +613,41 @@ static int receive_data(int fd, int revents, void *user_data)
*/ */
sr_source_remove(fd); sr_source_remove(fd);
sr_source_add(fd, G_IO_IN, 30, receive_data, user_data); sr_source_add(fd, G_IO_IN, 30, receive_data, user_data);
raw_sample_buf = malloc(limit_samples * 4); ols->raw_sample_buf = malloc(ols->limit_samples * 4);
/* fill with 1010... for debugging */ /* fill with 1010... for debugging */
memset(raw_sample_buf, 0x82, limit_samples * 4); memset(ols->raw_sample_buf, 0x82, ols->limit_samples * 4);
} }
num_channels = 0; num_channels = 0;
for (i = 0x20; i > 0x02; i /= 2) { for (i = 0x20; i > 0x02; i /= 2) {
if ((flag_reg & i) == 0) if ((ols->flag_reg & i) == 0)
num_channels++; num_channels++;
} }
if (revents == G_IO_IN if (revents == G_IO_IN
&& num_transfers / num_channels <= limit_samples) { && ols->num_transfers / num_channels <= ols->limit_samples) {
if (serial_read(fd, &byte, 1) != 1) if (serial_read(fd, &byte, 1) != 1)
return FALSE; return FALSE;
sample[num_bytes++] = byte; ols->sample[ols->num_bytes++] = byte;
g_debug("ols: received byte 0x%.2x", byte); g_debug("ols: received byte 0x%.2x", byte);
if (num_bytes == num_channels) { if (ols->num_bytes == num_channels) {
g_debug("ols: received sample 0x%.*x", num_bytes * 2, (int) *sample);
/* Got a full sample. */ /* Got a full sample. */
if (flag_reg & FLAG_RLE) { g_debug("ols: received sample 0x%.*x", ols->num_bytes * 2, (int) *ols->sample);
if (ols->flag_reg & FLAG_RLE) {
/* /*
* In RLE mode -1 should never come in as a * In RLE mode -1 should never come in as a
* sample, because bit 31 is the "count" flag. * sample, because bit 31 is the "count" flag.
* TODO: Endianness may be wrong here, could be * TODO: Endianness may be wrong here, could be
* sample[3]. * sample[3].
*/ */
if (sample[0] & 0x80 if (ols->sample[0] & 0x80
&& !(last_sample[0] & 0x80)) { && !(ols->last_sample[0] & 0x80)) {
count = (int)(*sample) & 0x7fffffff; count = (int)(*ols->sample) & 0x7fffffff;
buffer = g_malloc(count); buffer = g_malloc(count);
buflen = 0; buflen = 0;
for (i = 0; i < count; i++) { for (i = 0; i < count; i++) {
memcpy(buffer + buflen, last_sample, 4); memcpy(buffer + buflen, ols->last_sample, 4);
buflen += 4; buflen += 4;
} }
} else { } else {
@ -552,12 +657,12 @@ static int receive_data(int fd, int revents, void *user_data)
* to this -- but this one is still a * to this -- but this one is still a
* part of the stream. * part of the stream.
*/ */
buffer = sample; buffer = ols->sample;
buflen = 4; buflen = 4;
} }
} else { } else {
/* No compression. */ /* No compression. */
buffer = sample; buffer = ols->sample;
buflen = 4; buflen = 4;
} }
@ -572,35 +677,35 @@ static int receive_data(int fd, int revents, void *user_data)
* the number of probes. * the number of probes.
*/ */
j = 0; j = 0;
memset(tmp_sample, 0, 4); memset(ols->tmp_sample, 0, 4);
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (((flag_reg >> 2) & (1 << i)) == 0) { if (((ols->flag_reg >> 2) & (1 << i)) == 0) {
/* /*
* This channel group was * This channel group was
* enabled, copy from received * enabled, copy from received
* sample. * sample.
*/ */
tmp_sample[i] = sample[j++]; ols->tmp_sample[i] = ols->sample[j++];
} }
} }
memcpy(sample, tmp_sample, 4); memcpy(ols->sample, ols->tmp_sample, 4);
g_debug("ols: full sample 0x%.8x", (int) *sample); g_debug("ols: full sample 0x%.8x", (int) *ols->sample);
} }
/* the OLS sends its sample buffer backwards. /* the OLS sends its sample buffer backwards.
* store it in reverse order here, so we can dump * store it in reverse order here, so we can dump
* this on the session bus later. * this on the session bus later.
*/ */
offset = (limit_samples - num_transfers / num_channels) * 4; offset = (ols->limit_samples - ols->num_transfers / num_channels) * 4;
memcpy(raw_sample_buf + offset, sample, 4); memcpy(ols->raw_sample_buf + offset, ols->sample, 4);
if (buffer == sample) if (buffer == ols->sample)
memcpy(last_sample, buffer, num_channels); memcpy(ols->last_sample, buffer, num_channels);
else else
g_free(buffer); g_free(buffer);
memset(sample, 0, 4); memset(ols->sample, 0, 4);
num_bytes = 0; ols->num_bytes = 0;
} }
} else { } else {
/* /*
@ -608,16 +713,16 @@ static int receive_data(int fd, int revents, void *user_data)
* we've acquired all the samples we asked for -- we're done. * we've acquired all the samples we asked for -- we're done.
* Send the (properly-ordered) buffer to the frontend. * Send the (properly-ordered) buffer to the frontend.
*/ */
if (trigger_at != -1) { if (ols->trigger_at != -1) {
/* a trigger was set up, so we need to tell the frontend /* a trigger was set up, so we need to tell the frontend
* about it. * about it.
*/ */
if (trigger_at > 0) { if (ols->trigger_at > 0) {
/* there are pre-trigger samples, send those first */ /* there are pre-trigger samples, send those first */
packet.type = SR_DF_LOGIC; packet.type = SR_DF_LOGIC;
packet.length = trigger_at * 4; packet.length = ols->trigger_at * 4;
packet.unitsize = 4; packet.unitsize = 4;
packet.payload = raw_sample_buf; packet.payload = ols->raw_sample_buf;
sr_session_bus(user_data, &packet); sr_session_bus(user_data, &packet);
} }
@ -626,18 +731,18 @@ static int receive_data(int fd, int revents, void *user_data)
sr_session_bus(user_data, &packet); sr_session_bus(user_data, &packet);
packet.type = SR_DF_LOGIC; packet.type = SR_DF_LOGIC;
packet.length = (limit_samples * 4) - (trigger_at * 4); packet.length = (ols->limit_samples * 4) - (ols->trigger_at * 4);
packet.unitsize = 4; packet.unitsize = 4;
packet.payload = raw_sample_buf + trigger_at * 4; packet.payload = ols->raw_sample_buf + ols->trigger_at * 4;
sr_session_bus(user_data, &packet); sr_session_bus(user_data, &packet);
} else { } else {
packet.type = SR_DF_LOGIC; packet.type = SR_DF_LOGIC;
packet.length = limit_samples * 4; packet.length = ols->limit_samples * 4;
packet.unitsize = 4; packet.unitsize = 4;
packet.payload = raw_sample_buf; packet.payload = ols->raw_sample_buf;
sr_session_bus(user_data, &packet); sr_session_bus(user_data, &packet);
} }
free(raw_sample_buf); free(ols->raw_sample_buf);
serial_flush(fd); serial_flush(fd);
serial_close(fd); serial_close(fd);
@ -651,74 +756,76 @@ static int receive_data(int fd, int revents, void *user_data)
static int hw_start_acquisition(int device_index, gpointer session_device_id) static int hw_start_acquisition(int device_index, gpointer session_device_id)
{ {
int i;
struct sr_datafeed_packet *packet; struct sr_datafeed_packet *packet;
struct sr_datafeed_header *header; struct sr_datafeed_header *header;
struct sr_device_instance *sdi; struct sr_device_instance *sdi;
struct ols_device *ols;
uint32_t trigger_config[4]; uint32_t trigger_config[4];
uint32_t data; uint32_t data;
uint16_t readcount, delaycount; uint16_t readcount, delaycount;
uint8_t changrp_mask; uint8_t changrp_mask;
int i;
if (!(sdi = sr_get_device_instance(device_instances, device_index))) if (!(sdi = sr_get_device_instance(device_instances, device_index)))
return SR_ERR; return SR_ERR;
ols = sdi->priv;
if (sdi->status != SR_ST_ACTIVE) if (sdi->status != SR_ST_ACTIVE)
return SR_ERR; return SR_ERR;
readcount = limit_samples / 4; readcount = ols->limit_samples / 4;
memset(trigger_config, 0, 16); memset(trigger_config, 0, 16);
trigger_config[num_stages-1] |= 0x08; trigger_config[ols->num_stages - 1] |= 0x08;
if (trigger_mask[0]) { if (ols->trigger_mask[0]) {
delaycount = readcount * (1 - capture_ratio / 100.0); delaycount = readcount * (1 - ols->capture_ratio / 100.0);
trigger_at = (readcount - delaycount) * 4 - num_stages; ols->trigger_at = (readcount - delaycount) * 4 - ols->num_stages;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
reverse32(trigger_mask[0])) != SR_OK) reverse32(ols->trigger_mask[0])) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0,
reverse32(trigger_value[0])) != SR_OK) reverse32(ols->trigger_value[0])) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
trigger_config[0]) != SR_OK) trigger_config[0]) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_1, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_1,
reverse32(trigger_mask[1])) != SR_OK) reverse32(ols->trigger_mask[1])) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_1, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_1,
reverse32(trigger_value[1])) != SR_OK) reverse32(ols->trigger_value[1])) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_1, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_1,
trigger_config[1]) != SR_OK) trigger_config[1]) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_2, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_2,
reverse32(trigger_mask[2])) != SR_OK) reverse32(ols->trigger_mask[2])) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_2, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_2,
reverse32(trigger_value[2])) != SR_OK) reverse32(ols->trigger_value[2])) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_2, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_2,
trigger_config[2]) != SR_OK) trigger_config[2]) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_3, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_3,
reverse32(trigger_mask[3])) != SR_OK) reverse32(ols->trigger_mask[3])) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_3, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_3,
reverse32(trigger_value[3])) != SR_OK) reverse32(ols->trigger_value[3])) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_3, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_3,
trigger_config[3]) != SR_OK) trigger_config[3]) != SR_OK)
return SR_ERR; return SR_ERR;
} else { } else {
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0,
trigger_mask[0]) != SR_OK) ols->trigger_mask[0]) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0,
trigger_value[0]) != SR_OK) ols->trigger_value[0]) != SR_OK)
return SR_ERR; return SR_ERR;
if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0, if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0,
0x00000008) != SR_OK) 0x00000008) != SR_OK)
@ -726,7 +833,12 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
delaycount = readcount; delaycount = readcount;
} }
set_configuration_samplerate(sdi, cur_samplerate); g_message("ols: setting samplerate to %" PRIu64 " Hz (divider %u, demux %s)",
ols->cur_samplerate, ols->cur_samplerate_divider,
ols->flag_reg & FLAG_DEMUX ? "on" : "off");
if (send_longcommand(sdi->serial->fd, CMD_SET_DIVIDER,
reverse32(ols->cur_samplerate_divider)) != SR_OK)
return SR_ERR;
/* Send sample limit and pre/post-trigger capture ratio. */ /* Send sample limit and pre/post-trigger capture ratio. */
data = ((readcount - 1) & 0xffff) << 16; data = ((readcount - 1) & 0xffff) << 16;
@ -740,14 +852,14 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
*/ */
changrp_mask = 0; changrp_mask = 0;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
if (probe_mask & (0xff << (i * 8))) if (ols->probe_mask & (0xff << (i * 8)))
changrp_mask |= (1 << i); changrp_mask |= (1 << i);
} }
/* The flag register wants them here, and 1 means "disable channel". */ /* The flag register wants them here, and 1 means "disable channel". */
flag_reg |= ~(changrp_mask << 2) & 0x3c; ols->flag_reg |= ~(changrp_mask << 2) & 0x3c;
flag_reg |= FLAG_FILTER; ols->flag_reg |= FLAG_FILTER;
data = flag_reg << 24; data = ols->flag_reg << 24;
if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SR_OK) if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SR_OK)
return SR_ERR; return SR_ERR;
@ -768,7 +880,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
packet->payload = (unsigned char *)header; packet->payload = (unsigned char *)header;
header->feed_version = 1; header->feed_version = 1;
gettimeofday(&header->starttime, NULL); gettimeofday(&header->starttime, NULL);
header->samplerate = cur_samplerate; header->samplerate = ols->cur_samplerate;
header->protocol_id = SR_PROTO_RAW; header->protocol_id = SR_PROTO_RAW;
header->num_logic_probes = NUM_PROBES; header->num_logic_probes = NUM_PROBES;
header->num_analog_probes = 0; header->num_analog_probes = 0;

93
hardware/openbench-logic-sniffer/ols.h Normal file
View File

@ -0,0 +1,93 @@
/*
* This file is part of the sigrok project.
*
* Copyright (C) 2011 Bert Vermeulen <bert@biot.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OLS_H_
#define OLS_H_
#define NUM_PROBES 32
#define NUM_TRIGGER_STAGES 4
#define TRIGGER_TYPES "01"
#define SERIAL_SPEED B115200
#define CLOCK_RATE SR_MHZ(100)
#define MIN_NUM_SAMPLES 4
/* Command opcodes */
#define CMD_RESET 0x00
#define CMD_RUN 0x01
#define CMD_ID 0x02
#define CMD_METADATA 0x04
#define CMD_SET_FLAGS 0x82
#define CMD_SET_DIVIDER 0x80
#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
struct ols_device {
uint32_t max_samplerate;
uint32_t max_samples;
uint32_t protocol_version;
int num_probes;
uint64_t cur_samplerate;
uint32_t cur_samplerate_divider;
uint64_t limit_samples;
/* Current state of the flag register */
uint32_t flag_reg;
/* Pre/post trigger capture ratio, in percentage.
* 0 means no pre-trigger data. */
int capture_ratio;
int trigger_at;
uint32_t probe_mask;
uint32_t trigger_mask[4];
uint32_t trigger_value[4];
int num_stages;
unsigned int num_transfers;
int num_bytes;
char last_sample[4];
unsigned char sample[4];
unsigned char tmp_sample[4];
unsigned char *raw_sample_buf;
};
#endif /* OLS_H_ */

4
hwplugin.c
View File

@ -111,8 +111,8 @@ struct sr_device_instance *sr_device_instance_new(int index, int status,
sdi->index = index; sdi->index = index;
sdi->status = status; sdi->status = status;
sdi->instance_type = -1; sdi->instance_type = -1;
sdi->vendor = vendor ? strdup(vendor) : strdup("(unknown)"); sdi->vendor = vendor ? strdup(vendor) : NULL;
sdi->model = model ? strdup(model) : NULL; sdi->model = model ? strdup(model) : strdup("(unknown)");
sdi->version = version ? strdup(version) : NULL; sdi->version = version ? strdup(version) : NULL;
sdi->priv = NULL; sdi->priv = NULL;
sdi->usb = NULL; sdi->usb = NULL;