#include <fcntl.h>
#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
#endif
-#include "sigrok.h"
-#include "sigrok-internal.h"
+#include "libsigrok.h"
+#include "libsigrok-internal.h"
/* TODO: Number of probes should be configurable. */
#define NUM_PROBES 8
};
/* FIXME: Should not be global. */
-SR_PRIV GIOChannel *channels[2];
struct context {
int pipe_fds[2];
+ GIOChannel *channels[2];
uint8_t sample_generator;
uint8_t thread_running;
uint64_t samples_counter;
SR_HWCAP_CONTINUOUS,
};
-static struct sr_samplerates samplerates = {
+static const struct sr_samplerates samplerates = {
SR_HZ(1),
SR_GHZ(1),
SR_HZ(1),
/* TODO: struct context as with the other drivers. */
/* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
-static GSList *dev_insts = NULL;
+SR_PRIV struct sr_dev_driver demo_driver_info;
+static struct sr_dev_driver *ddi = &demo_driver_info;
static uint64_t cur_samplerate = SR_KHZ(200);
static uint64_t limit_samples = 0;
static uint64_t limit_msec = 0;
static int hw_dev_acquisition_stop(int dev_index, void *cb_data);
-static int hw_init(const char *devinfo)
+static int hw_init(void)
+{
+
+ /* Nothing to do. */
+
+ return SR_OK;
+}
+
+static GSList *hw_scan(GSList *options)
{
struct sr_dev_inst *sdi;
+ GSList *devices;
- /* Avoid compiler warnings. */
- (void)devinfo;
+ (void)options;
+ devices = NULL;
sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
if (!sdi) {
sr_err("demo: %s: sr_dev_inst_new failed", __func__);
return 0;
}
+ sdi->driver = ddi;
- dev_insts = g_slist_append(dev_insts, sdi);
+ devices = g_slist_append(devices, sdi);
+ ddi->instances = g_slist_append(ddi->instances, sdi);
- return 1;
+ return devices;
}
-static int hw_dev_open(int dev_index)
+static int hw_dev_open(struct sr_dev_inst *sdi)
{
/* Avoid compiler warnings. */
- (void)dev_index;
+ (void)sdi;
/* Nothing needed so far. */
return SR_OK;
}
-static int hw_dev_close(int dev_index)
+static int hw_dev_close(struct sr_dev_inst *sdi)
{
/* Avoid compiler warnings. */
- (void)dev_index;
+ (void)sdi;
/* Nothing needed so far. */
return SR_OK;
}
-static const void *hw_dev_info_get(int dev_index, int dev_info_id)
+static int hw_info_get(int info_id, const void **data,
+ const struct sr_dev_inst *sdi)
{
- struct sr_dev_inst *sdi;
- const void *info = NULL;
- if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
- sr_err("demo: %s: sdi was NULL", __func__);
- return NULL;
- }
-
- switch (dev_info_id) {
+ switch (info_id) {
case SR_DI_INST:
- info = sdi;
+ *data = sdi;
+ break;
+ case SR_DI_HWCAPS:
+ *data = hwcaps;
break;
case SR_DI_NUM_PROBES:
- info = GINT_TO_POINTER(NUM_PROBES);
+ *data = GINT_TO_POINTER(NUM_PROBES);
break;
case SR_DI_PROBE_NAMES:
- info = probe_names;
+ *data = probe_names;
break;
case SR_DI_SAMPLERATES:
- info = &samplerates;
+ *data = &samplerates;
break;
case SR_DI_CUR_SAMPLERATE:
- info = &cur_samplerate;
+ *data = &cur_samplerate;
break;
case SR_DI_PATTERNS:
- info = &pattern_strings;
+ *data = &pattern_strings;
break;
+ default:
+ return SR_ERR_ARG;
}
- return info;
+ return SR_OK;
}
static int hw_dev_status_get(int dev_index)
return SR_ST_ACTIVE;
}
-static const int *hw_hwcap_get_all(void)
-{
- return hwcaps;
-}
-
-static int hw_dev_config_set(int dev_index, int hwcap, void *value)
+static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
+ const void *value)
{
int ret;
- char *stropt;
+ const char *stropt;
- /* Avoid compiler warnings. */
- (void)dev_index;
+ (void)sdi;
if (hwcap == SR_HWCAP_PROBECONFIG) {
/* Nothing to do, but must be supported */
ret = SR_OK;
} else if (hwcap == SR_HWCAP_SAMPLERATE) {
- cur_samplerate = *(uint64_t *)value;
+ cur_samplerate = *(const uint64_t *)value;
sr_dbg("demo: %s: setting samplerate to %" PRIu64, __func__,
cur_samplerate);
ret = SR_OK;
} else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
- limit_samples = *(uint64_t *)value;
+ limit_msec = 0;
+ limit_samples = *(const uint64_t *)value;
sr_dbg("demo: %s: setting limit_samples to %" PRIu64, __func__,
limit_samples);
ret = SR_OK;
} else if (hwcap == SR_HWCAP_LIMIT_MSEC) {
- limit_msec = *(uint64_t *)value;
+ limit_msec = *(const uint64_t *)value;
+ limit_samples = 0;
sr_dbg("demo: %s: setting limit_msec to %" PRIu64, __func__,
limit_msec);
ret = SR_OK;
samples_generator(buf, nb_to_send, data);
ctx->samples_counter += nb_to_send;
- g_io_channel_write_chars(channels[1], (gchar *)&buf,
+ g_io_channel_write_chars(ctx->channels[1], (gchar *)&buf,
nb_to_send, (gsize *)&bytes_written, NULL);
}
/* Callback handling data */
static int receive_data(int fd, int revents, void *cb_data)
{
+ struct context *ctx = cb_data;
struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic;
static uint64_t samples_received = 0;
(void)revents;
do {
- g_io_channel_read_chars(channels[0],
+ g_io_channel_read_chars(ctx->channels[0],
(gchar *)&c, BUFSIZE, &z, NULL);
if (z > 0) {
logic.length = z;
logic.unitsize = 1;
logic.data = c;
- sr_session_send(cb_data, &packet);
+ sr_session_send(ctx->session_dev_id, &packet);
samples_received += z;
}
} while (z > 0);
if (!thread_running && z <= 0) {
/* Make sure we don't receive more packets. */
- g_io_channel_shutdown(channels[0], FALSE, NULL);
+ g_io_channel_shutdown(ctx->channels[0], FALSE, NULL);
/* Send last packet. */
packet.type = SR_DF_END;
- sr_session_send(cb_data, &packet);
+ sr_session_send(ctx->session_dev_id, &packet);
return FALSE;
}
return SR_ERR;
}
- channels[0] = g_io_channel_unix_new(ctx->pipe_fds[0]);
- channels[1] = g_io_channel_unix_new(ctx->pipe_fds[1]);
+ ctx->channels[0] = g_io_channel_unix_new(ctx->pipe_fds[0]);
+ ctx->channels[1] = g_io_channel_unix_new(ctx->pipe_fds[1]);
+
+ g_io_channel_set_flags(ctx->channels[0], G_IO_FLAG_NONBLOCK, NULL);
/* Set channel encoding to binary (default is UTF-8). */
- g_io_channel_set_encoding(channels[0], NULL, NULL);
- g_io_channel_set_encoding(channels[1], NULL, NULL);
+ g_io_channel_set_encoding(ctx->channels[0], NULL, NULL);
+ g_io_channel_set_encoding(ctx->channels[1], NULL, NULL);
/* Make channels to unbuffered. */
- g_io_channel_set_buffered(channels[0], FALSE);
- g_io_channel_set_buffered(channels[1], FALSE);
+ g_io_channel_set_buffered(ctx->channels[0], FALSE);
+ g_io_channel_set_buffered(ctx->channels[1], FALSE);
- sr_source_add(ctx->pipe_fds[0], G_IO_IN | G_IO_ERR, 40,
- receive_data, ctx->session_dev_id);
+ sr_session_source_add_channel(ctx->channels[0], G_IO_IN | G_IO_ERR,
+ 40, receive_data, ctx);
/* Run the demo thread. */
g_thread_init(NULL);
.api_version = 1,
.init = hw_init,
.cleanup = hw_cleanup,
+ .scan = hw_scan,
.dev_open = hw_dev_open,
.dev_close = hw_dev_close,
- .dev_info_get = hw_dev_info_get,
+ .info_get = hw_info_get,
.dev_status_get = hw_dev_status_get,
- .hwcap_get_all = hw_hwcap_get_all,
.dev_config_set = hw_dev_config_set,
.dev_acquisition_start = hw_dev_acquisition_start,
.dev_acquisition_stop = hw_dev_acquisition_stop,
+ .instances = NULL,
};