#include <arpa/inet.h>
#endif
#include <glib.h>
-#include "sigrok.h"
-#include "sigrok-internal.h"
+#include "libsigrok.h"
+#include "libsigrok-internal.h"
#include "ols.h"
#ifdef _WIN32
#define O_NONBLOCK FIONBIO
#endif
-static int hwcaps[] = {
+static const int hwcaps[] = {
SR_HWCAP_LOGIC_ANALYZER,
SR_HWCAP_SAMPLERATE,
SR_HWCAP_CAPTURE_RATIO,
0,
};
+/* Probes are numbered 0-31 (on the PCB silkscreen). */
static const char *probe_names[NUM_PROBES + 1] = {
"0",
"1",
};
/* default supported samplerates, can be overridden by device metadata */
-static struct sr_samplerates samplerates = {
+static const struct sr_samplerates samplerates = {
SR_HZ(10),
SR_MHZ(200),
SR_HZ(1),
NULL,
};
-/* List of struct sr_serial_dev_inst */
+/* List of struct sr_dev_inst. */
static GSList *dev_insts = NULL;
static int send_shortcommand(int fd, uint8_t command)
return SR_OK;
}
-static int configure_probes(struct context *ctx, GSList *probes)
+static int configure_probes(struct context *ctx, const GSList *probes)
{
- struct sr_probe *probe;
- GSList *l;
+ const struct sr_probe *probe;
+ const GSList *l;
int probe_bit, stage, i;
char *tc;
ctx->num_stages = 0;
for (l = probes; l; l = l->next) {
- probe = (struct sr_probe *)l->data;
+ probe = (const struct sr_probe *)l->data;
if (!probe->enabled)
continue;
return sdi;
}
-static int hw_init(const char *devinfo)
+static int hw_init(void)
{
struct sr_dev_inst *sdi;
struct context *ctx;
final_devcnt = 0;
- if (devinfo)
- ports = g_slist_append(NULL, g_strdup(devinfo));
- else
- /* No specific device given, so scan all serial ports. */
- ports = list_serial_ports();
-
+ /* Scan all serial ports. */
+ ports = list_serial_ports();
num_ports = g_slist_length(ports);
if (!(fds = g_try_malloc0(num_ports * sizeof(GPollFD)))) {
fd = serial_open(l->data, O_RDWR | O_NONBLOCK);
if (fd != -1) {
serial_params[devcnt] = serial_backup_params(fd);
- serial_set_params(fd, 115200, 8, 0, 1, 2);
+ serial_set_params(fd, 115200, 8, SERIAL_PARITY_NONE, 1, 2);
ret = SR_OK;
for (i = 0; i < 5; i++) {
if ((ret = send_shortcommand(fd,
/* got metadata */
sdi = get_metadata(fds[i].fd);
sdi->index = final_devcnt;
+ ctx = sdi->priv;
} else {
/* not an OLS -- some other board that uses the sump protocol */
sdi = sr_dev_inst_new(final_devcnt, SR_ST_INACTIVE,
if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("ols: %s: sdi was NULL", __func__);
- return SR_ERR; /* TODO: SR_ERR_ARG? */
+ return SR_ERR_BUG;
}
ctx = sdi->priv;
return ret;
}
-static void *hw_dev_info_get(int dev_index, int dev_info_id)
+static const void *hw_dev_info_get(int dev_index, int dev_info_id)
{
struct sr_dev_inst *sdi;
struct context *ctx;
- void *info;
+ const void *info;
if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return NULL;
return sdi->status;
}
-static int *hw_hwcap_get_all(void)
+static const int *hw_hwcap_get_all(void)
{
return hwcaps;
}
return SR_OK;
}
-static int hw_dev_config_set(int dev_index, int hwcap, void *value)
+static int hw_dev_config_set(int dev_index, int hwcap, const void *value)
{
struct sr_dev_inst *sdi;
struct context *ctx;
int ret;
- uint64_t *tmp_u64;
+ const uint64_t *tmp_u64;
if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR;
switch (hwcap) {
case SR_HWCAP_SAMPLERATE:
- ret = set_samplerate(sdi, *(uint64_t *)value);
+ ret = set_samplerate(sdi, *(const uint64_t *)value);
break;
case SR_HWCAP_PROBECONFIG:
- ret = configure_probes(ctx, (GSList *)value);
+ ret = configure_probes(ctx, (const GSList *)value);
break;
case SR_HWCAP_LIMIT_SAMPLES:
tmp_u64 = value;
ret = SR_OK;
break;
case SR_HWCAP_CAPTURE_RATIO:
- ctx->capture_ratio = *(uint64_t *)value;
+ ctx->capture_ratio = *(const uint64_t *)value;
if (ctx->capture_ratio < 0 || ctx->capture_ratio > 100) {
ctx->capture_ratio = 0;
ret = SR_ERR;
return ret;
}
-static int receive_data(int fd, int revents, void *session_data)
+static int receive_data(int fd, int revents, void *cb_data)
{
struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic;
ctx = NULL;
for (l = dev_insts; l; l = l->next) {
sdi = l->data;
+ ctx = sdi->priv;
if (ctx->serial->fd == fd) {
- ctx = sdi->priv;
break;
}
+ ctx = NULL;
}
if (!ctx)
/* Shouldn't happen. */
* finished. We'll double that to 30ms to be sure...
*/
sr_source_remove(fd);
- sr_source_add(fd, G_IO_IN, 30, receive_data, session_data);
+ sr_source_add(fd, G_IO_IN, 30, receive_data, cb_data);
ctx->raw_sample_buf = g_try_malloc(ctx->limit_samples * 4);
if (!ctx->raw_sample_buf) {
sr_err("ols: %s: ctx->raw_sample_buf malloc failed",
logic.unitsize = 4;
logic.data = ctx->raw_sample_buf +
(ctx->limit_samples - ctx->num_samples) * 4;
- sr_session_bus(session_data, &packet);
+ sr_session_send(cb_data, &packet);
}
/* send the trigger */
packet.type = SR_DF_TRIGGER;
- sr_session_bus(session_data, &packet);
+ sr_session_send(cb_data, &packet);
/* send post-trigger samples */
packet.type = SR_DF_LOGIC;
logic.unitsize = 4;
logic.data = ctx->raw_sample_buf + ctx->trigger_at * 4 +
(ctx->limit_samples - ctx->num_samples) * 4;
- sr_session_bus(session_data, &packet);
+ sr_session_send(cb_data, &packet);
} else {
/* no trigger was used */
packet.type = SR_DF_LOGIC;
logic.unitsize = 4;
logic.data = ctx->raw_sample_buf +
(ctx->limit_samples - ctx->num_samples) * 4;
- sr_session_bus(session_data, &packet);
+ sr_session_send(cb_data, &packet);
}
g_free(ctx->raw_sample_buf);
serial_flush(fd);
serial_close(fd);
packet.type = SR_DF_END;
- sr_session_bus(session_data, &packet);
+ sr_session_send(cb_data, &packet);
}
return TRUE;
}
-static int hw_dev_acquisition_start(int dev_index, gpointer session_data)
+static int hw_dev_acquisition_start(int dev_index, void *cb_data)
{
struct sr_datafeed_packet *packet;
struct sr_datafeed_header *header;
+ struct sr_datafeed_meta_logic meta;
struct sr_dev_inst *sdi;
struct context *ctx;
uint32_t trigger_config[4];
return SR_ERR;
sr_source_add(ctx->serial->fd, G_IO_IN, -1, receive_data,
- session_data);
+ cb_data);
if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
sr_err("ols: %s: packet malloc failed", __func__);
packet->payload = (unsigned char *)header;
header->feed_version = 1;
gettimeofday(&header->starttime, NULL);
- header->samplerate = ctx->cur_samplerate;
- header->num_logic_probes = NUM_PROBES;
- sr_session_bus(session_data, packet);
+ sr_session_send(cb_data, packet);
+
+ /* Send metadata about the SR_DF_LOGIC packets to come. */
+ packet->type = SR_DF_META_LOGIC;
+ packet->payload = &meta;
+ meta.samplerate = ctx->cur_samplerate;
+ meta.num_probes = NUM_PROBES;
+ sr_session_send(cb_data, packet);
g_free(header);
g_free(packet);
return SR_OK;
}
-static int hw_dev_acquisition_stop(int dev_index, gpointer session_dev_id)
+/* TODO: This stops acquisition on ALL devices, ignoring dev_index. */
+static int hw_dev_acquisition_stop(int dev_index, void *cb_data)
{
struct sr_datafeed_packet packet;
(void)dev_index;
packet.type = SR_DF_END;
- sr_session_bus(session_dev_id, &packet);
+ sr_session_send(cb_data, &packet);
return SR_OK;
}
-SR_PRIV struct sr_dev_plugin ols_plugin_info = {
+SR_PRIV struct sr_dev_driver ols_driver_info = {
.name = "ols",
.longname = "Openbench Logic Sniffer",
.api_version = 1,
projects / libsigrok.git / blobdiff