#define FLAG_RLE 0x0100
static int capabilities[] = {
- HWCAP_LOGIC_ANALYZER,
- HWCAP_SAMPLERATE,
- HWCAP_CAPTURE_RATIO,
- HWCAP_LIMIT_SAMPLES,
+ SR_HWCAP_LOGIC_ANALYZER,
+ SR_HWCAP_SAMPLERATE,
+ SR_HWCAP_CAPTURE_RATIO,
+ SR_HWCAP_LIMIT_SAMPLES,
0,
};
0,
};
-/* List of struct serial_device_instance */
+/* List of struct sr_serial_device_instance */
static GSList *device_instances = NULL;
/* Current state of the flag register */
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 (!strncmp(buf, "1SLO", 4)
|| !strncmp(buf, "1ALS", 4)) {
if (!strncmp(buf, "1SLO", 4))
- sdi = sigrok_device_instance_new
- (final_devcnt, ST_INACTIVE,
+ sdi = sr_device_instance_new
+ (final_devcnt, SR_ST_INACTIVE,
"Openbench",
"Logic Sniffer", "v1.0");
else
- sdi = sigrok_device_instance_new
- (final_devcnt, ST_INACTIVE,
+ sdi = sr_device_instance_new
+ (final_devcnt, SR_ST_INACTIVE,
"Openbench", "Logic Sniffer",
"v1.0");
- sdi->serial = serial_device_instance_new
+ sdi->serial = sr_serial_device_instance_new
(device_names[i], -1);
device_instances =
g_slist_append(device_instances, sdi);
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)))
+ if (!(sdi = sr_get_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 SR_ERR;
- sdi->status = ST_ACTIVE;
+ sdi->status = SR_ST_ACTIVE;
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)))
return;
if (sdi->serial->fd != -1) {
serial_close(sdi->serial->fd);
sdi->serial->fd = -1;
- sdi->status = ST_INACTIVE;
+ sdi->status = SR_ST_INACTIVE;
}
}
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 = sr_get_device_instance(device_instances, device_index)))
return NULL;
info = 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 = (char *)TRIGGER_TYPES;
break;
- case DI_CUR_SAMPLERATE:
+ case SR_DI_CUR_SAMPLERATE:
info = &cur_samplerate;
break;
}
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)))
- return ST_NOT_FOUND;
+ if (!(sdi = sr_get_device_instance(device_instances, device_index)))
+ return SR_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;
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)))
+ if (!(sdi = sr_get_device_instance(device_instances, device_index)))
return SR_ERR;
- if (sdi->status != ST_ACTIVE)
+ if (sdi->status != SR_ST_ACTIVE)
return SR_ERR;
switch (capability) {
- case HWCAP_SAMPLERATE:
+ case SR_HWCAP_SAMPLERATE:
tmp_u64 = value;
ret = set_configuration_samplerate(sdi, *tmp_u64);
break;
- case HWCAP_PROBECONFIG:
+ case SR_HWCAP_PROBECONFIG:
ret = configure_probes((GSList *) value);
break;
- case HWCAP_LIMIT_SAMPLES:
+ case SR_HWCAP_LIMIT_SAMPLES:
tmp_u64 = value;
if (*tmp_u64 < MIN_NUM_SAMPLES)
return SR_ERR;
g_message("ols: sample limit %" PRIu64, limit_samples);
ret = SR_OK;
break;
- case HWCAP_CAPTURE_RATIO:
+ case SR_HWCAP_CAPTURE_RATIO:
tmp_u64 = value;
capture_ratio = *tmp_u64;
if (capture_ratio < 0 || capture_ratio > 100) {
static unsigned char tmp_sample[4];
static unsigned char *raw_sample_buf = NULL;
int count, buflen, num_channels, offset, i, j;
- struct datafeed_packet packet;
+ struct sr_datafeed_packet packet;
unsigned char byte, *buffer;
if (num_transfers++ == 0) {
*/
if (trigger_at > 0) {
/* there are pre-trigger samples, send those first */
- packet.type = DF_LOGIC;
+ packet.type = SR_DF_LOGIC;
packet.length = trigger_at * 4;
packet.unitsize = 4;
packet.payload = raw_sample_buf;
session_bus(user_data, &packet);
}
- packet.type = DF_TRIGGER;
+ packet.type = SR_DF_TRIGGER;
packet.length = 0;
session_bus(user_data, &packet);
- packet.type = DF_LOGIC;
+ packet.type = SR_DF_LOGIC;
packet.length = (limit_samples * 4) - (trigger_at * 4);
packet.unitsize = 4;
packet.payload = raw_sample_buf + trigger_at * 4;
session_bus(user_data, &packet);
} else {
- packet.type = DF_LOGIC;
+ packet.type = SR_DF_LOGIC;
packet.length = limit_samples * 4;
packet.unitsize = 4;
packet.payload = raw_sample_buf;
serial_flush(fd);
serial_close(fd);
- packet.type = DF_END;
+ packet.type = SR_DF_END;
packet.length = 0;
session_bus(user_data, &packet);
}
static int hw_start_acquisition(int device_index, gpointer session_device_id)
{
int i;
- struct datafeed_packet *packet;
- struct datafeed_header *header;
- struct sigrok_device_instance *sdi;
+ struct sr_datafeed_packet *packet;
+ struct sr_datafeed_header *header;
+ 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)))
+ if (!(sdi = sr_get_device_instance(device_instances, device_index)))
return SR_ERR;
- if (sdi->status != ST_ACTIVE)
+ if (sdi->status != SR_ST_ACTIVE)
return SR_ERR;
readcount = limit_samples / 4;
session_device_id);
/* Send header packet to the session bus. */
- 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 SR_ERR;
- 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->protocol_id = SR_PROTO_RAW;
header->num_logic_probes = NUM_PROBES;
header->num_analog_probes = 0;
session_bus(session_device_id, packet);
static void hw_stop_acquisition(int device_index, gpointer session_device_id)
{
- struct datafeed_packet packet;
+ struct sr_datafeed_packet packet;
/* Avoid compiler warnings. */
device_index = device_index;
- packet.type = DF_END;
+ packet.type = SR_DF_END;
packet.length = 0;
session_bus(session_device_id, &packet);
}
-struct device_plugin ols_plugin_info = {
+struct sr_device_plugin ols_plugin_info = {
"ols",
+ "Openbench Logic Sniffer",
1,
hw_init,
hw_cleanup,