[libsigrok.git] / hardware / demo / demo.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
 * Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
 * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.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 2 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#ifdef _WIN32
#include <io.h>
#include <fcntl.h>
#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
#endif
#include "libsigrok.h"
#include "libsigrok-internal.h"

/* Message logging helpers with subsystem-specific prefix string. */
#define LOG_PREFIX "demo: "
#define sr_log(l, s, args...) sr_log(l, LOG_PREFIX s, ## args)
#define sr_spew(s, args...) sr_spew(LOG_PREFIX s, ## args)
#define sr_dbg(s, args...) sr_dbg(LOG_PREFIX s, ## args)
#define sr_info(s, args...) sr_info(LOG_PREFIX s, ## args)
#define sr_warn(s, args...) sr_warn(LOG_PREFIX s, ## args)
#define sr_err(s, args...) sr_err(LOG_PREFIX s, ## args)

/* TODO: Number of probes should be configurable. */
#define NUM_PROBES           8

/* The size of chunks to send through the session bus. */
/* TODO: Should be configurable. */
#define LOGIC_BUFSIZE        4096

/* Patterns we can generate */
enum {
	/**
	 * Spells "sigrok" across 8 probes using '0's (with '1's as
	 * "background") when displayed using the 'bits' output format.
	 */
	PATTERN_SIGROK,

	/** Pseudo-)random values on all probes. */
	PATTERN_RANDOM,

	/**
	 * Incrementing number across all probes.
	 */
	PATTERN_INC,

	/** All probes have a low logic state. */
	PATTERN_ALL_LOW,

	/** All probes have a high logic state. */
	PATTERN_ALL_HIGH,
};

static const char *pattern_strings[] = {
	"sigrok",
	"random",
	"incremental",
	"all-low",
	"all-high",
};

/* Private, per-device-instance driver context. */
struct dev_context {
	int pipe_fds[2];
	GIOChannel *channel;
	uint64_t cur_samplerate;
	uint64_t limit_samples;
	uint64_t limit_msec;
	uint8_t sample_generator;
	uint64_t samples_counter;
	void *cb_data;
	int64_t starttime;
	unsigned char logic_data[LOGIC_BUFSIZE];
	uint64_t step;
};

static const int hwcaps[] = {
	SR_CONF_LOGIC_ANALYZER,
	SR_CONF_DEMO_DEV,
	SR_CONF_SAMPLERATE,
	SR_CONF_PATTERN_MODE,
	SR_CONF_LIMIT_SAMPLES,
	SR_CONF_LIMIT_MSEC,
	SR_CONF_CONTINUOUS,
};

static const uint64_t samplerates[] = {
	SR_HZ(1),
	SR_GHZ(1),
	SR_HZ(1),
};

static uint8_t pattern_sigrok[] = {
	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};

/* Private, per-device-instance driver context. */
/* TODO: struct context as with the other drivers. */

/* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
SR_PRIV struct sr_dev_driver demo_driver_info;
static struct sr_dev_driver *di = &demo_driver_info;

static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);

static int dev_clear(void)
{
	return std_dev_clear(di, NULL);
}

static int init(struct sr_context *sr_ctx)
{
	return std_init(sr_ctx, di, LOG_PREFIX);
}

static GSList *scan(GSList *options)
{
	struct sr_dev_inst *sdi;
	struct sr_probe *probe;
	struct drv_context *drvc;
	struct dev_context *devc;
	GSList *devices;
	int i;
	char probe_name[16];

	(void)options;

	drvc = di->priv;

	devices = NULL;

	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
	if (!sdi) {
		sr_err("Device instance creation failed.");
		return NULL;
	}
	sdi->driver = di;

	for (i = 0; i < NUM_PROBES; i++) {
		sprintf(probe_name, "D%d", i);
		if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name)))
			return NULL;
		sdi->probes = g_slist_append(sdi->probes, probe);
	}

	devices = g_slist_append(devices, sdi);
	drvc->instances = g_slist_append(drvc->instances, sdi);

	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
		sr_err("Device context malloc failed.");
		return NULL;
	}

	devc->cur_samplerate = SR_KHZ(200);
	devc->limit_samples = 0;
	devc->limit_msec = 0;
	devc->sample_generator = PATTERN_SIGROK;
	devc->step =0;

	sdi->priv = devc;

	return devices;
}

static GSList *dev_list(void)
{
	return ((struct drv_context *)(di->priv))->instances;
}

static int dev_open(struct sr_dev_inst *sdi)
{
	sdi->status = SR_ST_ACTIVE;

	return SR_OK;
}

static int dev_close(struct sr_dev_inst *sdi)
{
	sdi->status = SR_ST_INACTIVE;

	return SR_OK;
}

static int cleanup(void)
{
	return dev_clear();
}

static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
		const struct sr_probe_group *probe_group)
{
	struct dev_context *const devc = sdi->priv;

	(void)probe_group;

	switch (id) {
	case SR_CONF_SAMPLERATE:
		*data = g_variant_new_uint64(devc->cur_samplerate);
		break;
	case SR_CONF_LIMIT_SAMPLES:
		*data = g_variant_new_uint64(devc->limit_samples);
		break;
	case SR_CONF_LIMIT_MSEC:
		*data = g_variant_new_uint64(devc->limit_msec);
		break;
	case SR_CONF_PATTERN_MODE:
		*data = g_variant_new_string(pattern_strings[devc->sample_generator]);
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
		const struct sr_probe_group *probe_group)
{
	unsigned int i;
	int ret;
	const char *stropt;

	(void)probe_group;
	struct dev_context *const devc = sdi->priv;

	if (sdi->status != SR_ST_ACTIVE)
		return SR_ERR_DEV_CLOSED;

	if (id == SR_CONF_SAMPLERATE) {
		devc->cur_samplerate = g_variant_get_uint64(data);
		sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
		ret = SR_OK;
	} else if (id == SR_CONF_LIMIT_SAMPLES) {
		devc->limit_msec = 0;
		devc->limit_samples = g_variant_get_uint64(data);
		sr_dbg("Setting limit_samples to %" PRIu64, devc->limit_samples);
		ret = SR_OK;
	} else if (id == SR_CONF_LIMIT_MSEC) {
		devc->limit_msec = g_variant_get_uint64(data);
		devc->limit_samples = 0;
		sr_dbg("Setting limit_msec to %" PRIu64, devc->limit_msec);
		ret = SR_OK;
	} else if (id == SR_CONF_PATTERN_MODE) {
		stropt = g_variant_get_string(data, NULL);
		ret = SR_ERR;
		for (i = 0; i < ARRAY_SIZE(pattern_strings); i++) {
			if (!strcmp(stropt, pattern_strings[i])) {
				devc->sample_generator = i;
				ret = SR_OK;
				break;
			}
		}
		/* Might as well do this now. */
		if (i == PATTERN_ALL_LOW)
			memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
		else if (i == PATTERN_ALL_HIGH)
			memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
		sr_dbg("Setting pattern to %s", pattern_strings[i]);
	} else {
		ret = SR_ERR_NA;
	}

	return ret;
}

static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
		const struct sr_probe_group *probe_group)
{
	GVariant *gvar;
	GVariantBuilder gvb;

	(void)sdi;
	(void)probe_group;

	switch (key) {
	case SR_CONF_DEVICE_OPTIONS:
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
				hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
		break;
	case SR_CONF_SAMPLERATE:
		g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
		gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
				ARRAY_SIZE(samplerates), sizeof(uint64_t));
		g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
		*data = g_variant_builder_end(&gvb);
		break;
	case SR_CONF_PATTERN_MODE:
		*data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static void sample_generator(struct sr_dev_inst *sdi, uint64_t size)
{
	struct dev_context *devc;
	uint64_t i;

	devc = sdi->priv;

	switch (devc->sample_generator) {
	case PATTERN_SIGROK:
		for (i = 0; i < size; i++) {
			devc->logic_data[i] = ~(pattern_sigrok[
				devc->step++ % sizeof(pattern_sigrok)] >> 1);
		}
		break;
	case PATTERN_RANDOM:
		for (i = 0; i < size; i++)
			devc->logic_data[i] = (uint8_t)(rand() & 0xff);
		break;
	case PATTERN_INC:
		for (i = 0; i < size; i++)
			devc->logic_data[i] = devc->step++;
		break;
	case PATTERN_ALL_LOW:
	case PATTERN_ALL_HIGH:
		/* These were set when the pattern mode was selected. */
		break;
	default:
		sr_err("Unknown pattern: %d.", devc->sample_generator);
		break;
	}
}

/* Callback handling data */
static int prepare_data(int fd, int revents, void *cb_data)
{
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	struct sr_datafeed_packet packet;
	struct sr_datafeed_logic logic;
	static uint64_t samples_to_send, expected_samplenum, sending_now;
	int64_t time, elapsed;

	(void)fd;
	(void)revents;

	sdi = cb_data;
	devc = sdi->priv;

	/* How many "virtual" samples should we have collected by now? */
	time = g_get_monotonic_time();
	elapsed = time - devc->starttime;
	expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
	/* Of those, how many do we still have to send? */
	samples_to_send = expected_samplenum - devc->samples_counter;

	if (devc->limit_samples) {
		samples_to_send = MIN(samples_to_send,
				 devc->limit_samples - devc->samples_counter);
	}

	while (samples_to_send > 0) {
		sending_now = MIN(samples_to_send, LOGIC_BUFSIZE);
		samples_to_send -= sending_now;
		sample_generator(sdi, sending_now);

		packet.type = SR_DF_LOGIC;
		packet.payload = &logic;
		logic.length = sending_now;
		logic.unitsize = 1;
		logic.data = devc->logic_data;
		sr_session_send(devc->cb_data, &packet);
		devc->samples_counter += sending_now;
	}

	if (devc->limit_samples &&
		devc->samples_counter >= devc->limit_samples) {
		sr_info("Requested number of samples reached.");
		dev_acquisition_stop(sdi, cb_data);
		return TRUE;
	}

	return TRUE;
}

static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
	struct dev_context *devc;

	if (sdi->status != SR_ST_ACTIVE)
		return SR_ERR_DEV_CLOSED;

	devc = sdi->priv;
	devc->cb_data = cb_data;
	devc->samples_counter = 0;

	/*
	 * Setting two channels connected by a pipe is a remnant from when the
	 * demo driver generated data in a thread, and collected and sent the
	 * data in the main program loop.
	 * They are kept here because it provides a convenient way of setting
	 * up a timeout-based polling mechanism.
	 */
	if (pipe(devc->pipe_fds)) {
		sr_err("%s: pipe() failed", __func__);
		return SR_ERR;
	}

	devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);

	g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);

	/* Set channel encoding to binary (default is UTF-8). */
	g_io_channel_set_encoding(devc->channel, NULL, NULL);

	/* Make channels to unbuffered. */
	g_io_channel_set_buffered(devc->channel, FALSE);

	sr_session_source_add_channel(devc->channel, G_IO_IN | G_IO_ERR,
			40, prepare_data, (void *)sdi);

	/* Send header packet to the session bus. */
	std_session_send_df_header(cb_data, LOG_PREFIX);

	/* We use this timestamp to decide how many more samples to send. */
	devc->starttime = g_get_monotonic_time();

	return SR_OK;
}

static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
{
	struct dev_context *const devc = sdi->priv;
	struct sr_datafeed_packet packet;

	(void)cb_data;

	sr_dbg("Stopping aquisition.");

	sr_session_source_remove_channel(devc->channel);
	g_io_channel_shutdown(devc->channel, FALSE, NULL);
	g_io_channel_unref(devc->channel);
	devc->channel = NULL;

	/* Send last packet. */
	packet.type = SR_DF_END;
	sr_session_send(devc->cb_data, &packet);

	return SR_OK;
}

SR_PRIV struct sr_dev_driver demo_driver_info = {
	.name = "demo",
	.longname = "Demo driver and pattern generator",
	.api_version = 1,
	.init = init,
	.cleanup = cleanup,
	.scan = scan,
	.dev_list = dev_list,
	.dev_clear = dev_clear,
	.config_get = config_get,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = dev_open,
	.dev_close = dev_close,
	.dev_acquisition_start = dev_acquisition_start,
	.dev_acquisition_stop = dev_acquisition_stop,
	.priv = NULL,
};
Commit	Line	Data
6239c175	1	/*
50985c20	2	* This file is part of the libsigrok project.
6239c175 UH	3	*
6239c175 UH	4	* Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
fc96e6f8	5	* Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
c216d623	6	* Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
6239c175 UH	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	#include <stdlib.h>
85b5af06	24	#include <unistd.h>
6239c175	25	#include <string.h>
d35aaf02 UH	26	#ifdef _WIN32
	27	#include <io.h>
	28	#include <fcntl.h>
	29	#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
	30	#endif
45c59c8b BV	31	#include "libsigrok.h"
45c59c8b BV	32	#include "libsigrok-internal.h"
6239c175	33
29a27196 UH	34	/* Message logging helpers with subsystem-specific prefix string. */
	35	#define LOG_PREFIX "demo: "
	36	#define sr_log(l, s, args...) sr_log(l, LOG_PREFIX s, ## args)
	37	#define sr_spew(s, args...) sr_spew(LOG_PREFIX s, ## args)
	38	#define sr_dbg(s, args...) sr_dbg(LOG_PREFIX s, ## args)
	39	#define sr_info(s, args...) sr_info(LOG_PREFIX s, ## args)
	40	#define sr_warn(s, args...) sr_warn(LOG_PREFIX s, ## args)
	41	#define sr_err(s, args...) sr_err(LOG_PREFIX s, ## args)
92bcedf6	42
c03ed397	43	/* TODO: Number of probes should be configurable. */
61c39f54	44	#define NUM_PROBES 8
c03ed397 UH	45
	46	/* The size of chunks to send through the session bus. */
	47	/* TODO: Should be configurable. */
61c39f54	48	#define LOGIC_BUFSIZE 4096
2474d87e	49
61c39f54	50	/* Patterns we can generate */
e15f48c2	51	enum {
0d31276b	52	/**
61c39f54 BV	53	* Spells "sigrok" across 8 probes using '0's (with '1's as
61c39f54 BV	54	* "background") when displayed using the 'bits' output format.
0d31276b	55	*/
c8f4624d	56	PATTERN_SIGROK,
0d31276b	57
61c39f54	58	/** Pseudo-)random values on all probes. */
c8f4624d	59	PATTERN_RANDOM,
0d31276b UH	60
0d31276b UH	61	/**
61c39f54	62	* Incrementing number across all probes.
0d31276b	63	*/
c8f4624d	64	PATTERN_INC,
c03ed397	65
61c39f54	66	/** All probes have a low logic state. */
c03ed397 UH	67	PATTERN_ALL_LOW,
c03ed397 UH	68
61c39f54	69	/** All probes have a high logic state. */
c03ed397	70	PATTERN_ALL_HIGH,
e15f48c2	71	};
85b5af06	72
61c39f54 BV	73	static const char *pattern_strings[] = {
	74	"sigrok",
	75	"random",
	76	"incremental",
	77	"all-low",
	78	"all-high",
	79	};
	80
b4750a3a BV	81	/* Private, per-device-instance driver context. */
b4750a3a BV	82	struct dev_context {
e15f48c2	83	int pipe_fds[2];
e0532047	84	GIOChannel *channel;
a7684294 JH	85	uint64_t cur_samplerate;
	86	uint64_t limit_samples;
	87	uint64_t limit_msec;
e15f48c2	88	uint8_t sample_generator;
e15f48c2	89	uint64_t samples_counter;
3e9b7f9c	90	void *cb_data;
3b203673	91	int64_t starttime;
61c39f54 BV	92	unsigned char logic_data[LOGIC_BUFSIZE];
61c39f54 BV	93	uint64_t step;
e15f48c2	94	};
85b5af06	95
915f7cc8	96	static const int hwcaps[] = {
1953564a BV	97	SR_CONF_LOGIC_ANALYZER,
	98	SR_CONF_DEMO_DEV,
	99	SR_CONF_SAMPLERATE,
	100	SR_CONF_PATTERN_MODE,
	101	SR_CONF_LIMIT_SAMPLES,
	102	SR_CONF_LIMIT_MSEC,
	103	SR_CONF_CONTINUOUS,
6239c175 UH	104	};
6239c175 UH	105
d00088ca BV	106	static const uint64_t samplerates[] = {
	107	SR_HZ(1),
	108	SR_GHZ(1),
	109	SR_HZ(1),
4bfbf9fc BV	110	};
4bfbf9fc BV	111
c8f4624d	112	static uint8_t pattern_sigrok[] = {
917e0e71 BV	113	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
	114	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
	115	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
	116	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
	117	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
	118	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
	119	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	120	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	121	};
	122
ea9cfed7 UH	123	/* Private, per-device-instance driver context. */
	124	/* TODO: struct context as with the other drivers. */
	125
e7eb703f	126	/* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
dcf03d6d	127	SR_PRIV struct sr_dev_driver demo_driver_info;
a873c594	128	static struct sr_dev_driver *di = &demo_driver_info;
6239c175	129
6078d2c9	130	static int dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data);
6239c175	131
3b412e3a	132	static int dev_clear(void)
eebb6067	133	{
1c2d542d	134	return std_dev_clear(di, NULL);
eebb6067 UH	135	}
eebb6067 UH	136
6078d2c9	137	static int init(struct sr_context *sr_ctx)
61136ea6	138	{
f6beaac5	139	return std_init(sr_ctx, di, LOG_PREFIX);
61136ea6 BV	140	}
61136ea6 BV	141
6078d2c9	142	static GSList scan(GSList options)
6239c175	143	{
d68e2d1a	144	struct sr_dev_inst *sdi;
87ca93c5	145	struct sr_probe *probe;
b4750a3a	146	struct drv_context *drvc;
33ef7573	147	struct dev_context *devc;
067d0716	148	GSList *devices;
87ca93c5	149	int i;
61c39f54	150	char probe_name[16];
067d0716 BV	151
067d0716 BV	152	(void)options;
64d33dc2	153
a873c594	154	drvc = di->priv;
4b97c74e	155
067d0716	156	devices = NULL;
85b5af06	157
61c39f54	158	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL);
c03ed397	159	if (!sdi) {
e45ad6e2 UH	160	sr_err("Device instance creation failed.");
e45ad6e2 UH	161	return NULL;
c03ed397	162	}
a873c594	163	sdi->driver = di;
e15f48c2	164
61c39f54 BV	165	for (i = 0; i < NUM_PROBES; i++) {
	166	sprintf(probe_name, "D%d", i);
	167	if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name)))
87ca93c5 BV	168	return NULL;
	169	sdi->probes = g_slist_append(sdi->probes, probe);
	170	}
	171
067d0716	172	devices = g_slist_append(devices, sdi);
b4750a3a	173	drvc->instances = g_slist_append(drvc->instances, sdi);
85b5af06	174
33ef7573	175	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
e45ad6e2 UH	176	sr_err("Device context malloc failed.");
e45ad6e2 UH	177	return NULL;
33ef7573 JH	178	}
33ef7573 JH	179
a7684294 JH	180	devc->cur_samplerate = SR_KHZ(200);
	181	devc->limit_samples = 0;
	182	devc->limit_msec = 0;
	183	devc->sample_generator = PATTERN_SIGROK;
61c39f54	184	devc->step =0;
33ef7573 JH	185
	186	sdi->priv = devc;
	187
067d0716	188	return devices;
6239c175 UH	189	}
6239c175 UH	190
6078d2c9	191	static GSList *dev_list(void)
811deee4	192	{
0e94d524	193	return ((struct drv_context *)(di->priv))->instances;
811deee4 BV	194	}
811deee4 BV	195
6078d2c9	196	static int dev_open(struct sr_dev_inst *sdi)
6239c175	197	{
e73ffd42	198	sdi->status = SR_ST_ACTIVE;
697785d1	199
e46b8fb1	200	return SR_OK;
6239c175 UH	201	}
6239c175 UH	202
6078d2c9	203	static int dev_close(struct sr_dev_inst *sdi)
6239c175	204	{
decfe89d	205	sdi->status = SR_ST_INACTIVE;
697785d1 UH	206
697785d1 UH	207	return SR_OK;
6239c175 UH	208	}
6239c175 UH	209
6078d2c9	210	static int cleanup(void)
6239c175	211	{
1c2d542d	212	return dev_clear();
6239c175 UH	213	}
6239c175 UH	214
8f996b89 ML	215	static int config_get(int id, GVariant *data, const struct sr_dev_inst sdi,
8f996b89 ML	216	const struct sr_probe_group *probe_group)
6239c175	217	{
a7684294	218	struct dev_context *const devc = sdi->priv;
6f57fd96	219
8f996b89 ML	220	(void)probe_group;
8f996b89 ML	221
035a1078	222	switch (id) {
123e1313	223	case SR_CONF_SAMPLERATE:
a7684294	224	*data = g_variant_new_uint64(devc->cur_samplerate);
6239c175	225	break;
2474d87e	226	case SR_CONF_LIMIT_SAMPLES:
a7684294	227	*data = g_variant_new_uint64(devc->limit_samples);
2474d87e BV	228	break;
2474d87e BV	229	case SR_CONF_LIMIT_MSEC:
a7684294	230	*data = g_variant_new_uint64(devc->limit_msec);
2474d87e BV	231	break;
2474d87e BV	232	case SR_CONF_PATTERN_MODE:
61c39f54	233	*data = g_variant_new_string(pattern_strings[devc->sample_generator]);
2474d87e	234	break;
7dfcf010	235	default:
bd6fbf62	236	return SR_ERR_NA;
6239c175 UH	237	}
6239c175 UH	238
dfb0fa1a	239	return SR_OK;
6239c175 UH	240	}
6239c175 UH	241
8f996b89 ML	242	static int config_set(int id, GVariant data, const struct sr_dev_inst sdi,
8f996b89 ML	243	const struct sr_probe_group *probe_group)
6239c175	244	{
61c39f54	245	unsigned int i;
6239c175	246	int ret;
1b79df2f	247	const char *stropt;
6239c175	248
8f996b89	249	(void)probe_group;
a7684294	250	struct dev_context *const devc = sdi->priv;
6239c175	251
e73ffd42 BV	252	if (sdi->status != SR_ST_ACTIVE)
	253	return SR_ERR_DEV_CLOSED;
	254
035a1078	255	if (id == SR_CONF_SAMPLERATE) {
a7684294	256	devc->cur_samplerate = g_variant_get_uint64(data);
61c39f54	257	sr_dbg("Setting samplerate to %" PRIu64, devc->cur_samplerate);
e46b8fb1	258	ret = SR_OK;
035a1078	259	} else if (id == SR_CONF_LIMIT_SAMPLES) {
a7684294 JH	260	devc->limit_msec = 0;
a7684294 JH	261	devc->limit_samples = g_variant_get_uint64(data);
61c39f54	262	sr_dbg("Setting limit_samples to %" PRIu64, devc->limit_samples);
e46b8fb1	263	ret = SR_OK;
035a1078	264	} else if (id == SR_CONF_LIMIT_MSEC) {
a7684294 JH	265	devc->limit_msec = g_variant_get_uint64(data);
a7684294 JH	266	devc->limit_samples = 0;
61c39f54	267	sr_dbg("Setting limit_msec to %" PRIu64, devc->limit_msec);
e46b8fb1	268	ret = SR_OK;
035a1078	269	} else if (id == SR_CONF_PATTERN_MODE) {
d00088ca	270	stropt = g_variant_get_string(data, NULL);
61c39f54 BV	271	ret = SR_ERR;
	272	for (i = 0; i < ARRAY_SIZE(pattern_strings); i++) {
	273	if (!strcmp(stropt, pattern_strings[i])) {
	274	devc->sample_generator = i;
	275	ret = SR_OK;
	276	break;
	277	}
e15f48c2	278	}
61c39f54 BV	279	/* Might as well do this now. */
	280	if (i == PATTERN_ALL_LOW)
	281	memset(devc->logic_data, 0x00, LOGIC_BUFSIZE);
	282	else if (i == PATTERN_ALL_HIGH)
	283	memset(devc->logic_data, 0xff, LOGIC_BUFSIZE);
	284	sr_dbg("Setting pattern to %s", pattern_strings[i]);
6239c175	285	} else {
bd6fbf62	286	ret = SR_ERR_NA;
6239c175 UH	287	}
	288
	289	return ret;
	290	}
	291
8f996b89 ML	292	static int config_list(int key, GVariant *data, const struct sr_dev_inst sdi,
8f996b89 ML	293	const struct sr_probe_group *probe_group)
a1c743fc	294	{
d00088ca BV	295	GVariant *gvar;
d00088ca BV	296	GVariantBuilder gvb;
a1c743fc BV	297
a1c743fc BV	298	(void)sdi;
8f996b89	299	(void)probe_group;
a1c743fc BV	300
a1c743fc BV	301	switch (key) {
9a6517d1	302	case SR_CONF_DEVICE_OPTIONS:
d00088ca BV	303	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
d00088ca BV	304	hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
9a6517d1	305	break;
a1c743fc	306	case SR_CONF_SAMPLERATE:
d00088ca BV	307	g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
	308	gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
	309	ARRAY_SIZE(samplerates), sizeof(uint64_t));
	310	g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
	311	*data = g_variant_builder_end(&gvb);
a1c743fc	312	break;
dd96ea98	313	case SR_CONF_PATTERN_MODE:
d00088ca	314	*data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
dd96ea98	315	break;
a1c743fc	316	default:
bd6fbf62	317	return SR_ERR_NA;
a1c743fc BV	318	}
	319
	320	return SR_OK;
	321	}
	322
61c39f54	323	static void sample_generator(struct sr_dev_inst *sdi, uint64_t size)
85b5af06	324	{
61c39f54	325	struct dev_context *devc;
cddd1c5f	326	uint64_t i;
85b5af06	327
61c39f54	328	devc = sdi->priv;
85b5af06	329
b4750a3a	330	switch (devc->sample_generator) {
61c39f54	331	case PATTERN_SIGROK:
917e0e71	332	for (i = 0; i < size; i++) {
61c39f54 BV	333	devc->logic_data[i] = ~(pattern_sigrok[
61c39f54 BV	334	devc->step++ % sizeof(pattern_sigrok)] >> 1);
917e0e71 BV	335	}
917e0e71 BV	336	break;
61c39f54	337	case PATTERN_RANDOM:
5096c6a6	338	for (i = 0; i < size; i++)
61c39f54	339	devc->logic_data[i] = (uint8_t)(rand() & 0xff);
85b5af06	340	break;
61c39f54	341	case PATTERN_INC:
5096c6a6	342	for (i = 0; i < size; i++)
61c39f54	343	devc->logic_data[i] = devc->step++;
c03ed397	344	break;
61c39f54 BV	345	case PATTERN_ALL_LOW:
	346	case PATTERN_ALL_HIGH:
	347	/* These were set when the pattern mode was selected. */
c03ed397 UH	348	break;
c03ed397 UH	349	default:
92bcedf6	350	sr_err("Unknown pattern: %d.", devc->sample_generator);
c03ed397	351	break;
85b5af06 UH	352	}
	353	}
	354
85b5af06	355	/* Callback handling data */
61c39f54	356	static int prepare_data(int fd, int revents, void *cb_data)
85b5af06	357	{
61c39f54 BV	358	struct sr_dev_inst *sdi;
61c39f54 BV	359	struct dev_context *devc;
b9c735a2	360	struct sr_datafeed_packet packet;
9c939c51	361	struct sr_datafeed_logic logic;
3b203673 AG	362	static uint64_t samples_to_send, expected_samplenum, sending_now;
3b203673 AG	363	int64_t time, elapsed;
1924f59f	364
cb93f8a9 UH	365	(void)fd;
cb93f8a9 UH	366	(void)revents;
1924f59f	367
61c39f54 BV	368	sdi = cb_data;
	369	devc = sdi->priv;
	370
3b203673 AG	371	/* How many "virtual" samples should we have collected by now? */
	372	time = g_get_monotonic_time();
	373	elapsed = time - devc->starttime;
a7684294	374	expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
3b203673 AG	375	/* Of those, how many do we still have to send? */
	376	samples_to_send = expected_samplenum - devc->samples_counter;
	377
a7684294	378	if (devc->limit_samples) {
3b203673	379	samples_to_send = MIN(samples_to_send,
a7684294	380	devc->limit_samples - devc->samples_counter);
3b203673	381	}
85b5af06	382
3b203673	383	while (samples_to_send > 0) {
61c39f54	384	sending_now = MIN(samples_to_send, LOGIC_BUFSIZE);
3b203673	385	samples_to_send -= sending_now;
61c39f54	386	sample_generator(sdi, sending_now);
3b203673 AG	387
	388	packet.type = SR_DF_LOGIC;
	389	packet.payload = &logic;
	390	logic.length = sending_now;
	391	logic.unitsize = 1;
61c39f54	392	logic.data = devc->logic_data;
3e9b7f9c	393	sr_session_send(devc->cb_data, &packet);
3b203673 AG	394	devc->samples_counter += sending_now;
	395	}
	396
a7684294 JH	397	if (devc->limit_samples &&
a7684294 JH	398	devc->samples_counter >= devc->limit_samples) {
35e199da	399	sr_info("Requested number of samples reached.");
61c39f54	400	dev_acquisition_stop(sdi, cb_data);
c216d623	401	return TRUE;
85b5af06	402	}
1924f59f	403
85b5af06 UH	404	return TRUE;
	405	}
	406
6078d2c9	407	static int dev_acquisition_start(const struct sr_dev_inst sdi, void cb_data)
6239c175	408	{
61c39f54	409	struct dev_context *devc;
85b5af06	410
e73ffd42 BV	411	if (sdi->status != SR_ST_ACTIVE)
	412	return SR_ERR_DEV_CLOSED;
	413
61c39f54	414	devc = sdi->priv;
3e9b7f9c	415	devc->cb_data = cb_data;
b4750a3a	416	devc->samples_counter = 0;
85b5af06	417
3b203673 AG	418	/*
	419	* Setting two channels connected by a pipe is a remnant from when the
	420	* demo driver generated data in a thread, and collected and sent the
	421	* data in the main program loop.
	422	* They are kept here because it provides a convenient way of setting
	423	* up a timeout-based polling mechanism.
	424	*/
b4750a3a	425	if (pipe(devc->pipe_fds)) {
92bcedf6	426	sr_err("%s: pipe() failed", __func__);
e46b8fb1	427	return SR_ERR;
c03ed397	428	}
85b5af06	429
e0532047	430	devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
d35aaf02	431
e0532047	432	g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
e6e8f8e0	433
d35aaf02	434	/* Set channel encoding to binary (default is UTF-8). */
e0532047	435	g_io_channel_set_encoding(devc->channel, NULL, NULL);
d35aaf02 UH	436
d35aaf02 UH	437	/* Make channels to unbuffered. */
e0532047	438	g_io_channel_set_buffered(devc->channel, FALSE);
d35aaf02	439
e0532047	440	sr_session_source_add_channel(devc->channel, G_IO_IN \| G_IO_ERR,
61c39f54	441	40, prepare_data, (void *)sdi);
85b5af06	442
4afdfd46	443	/* Send header packet to the session bus. */
29a27196	444	std_session_send_df_header(cb_data, LOG_PREFIX);
f366e86c	445
3b203673 AG	446	/* We use this timestamp to decide how many more samples to send. */
	447	devc->starttime = g_get_monotonic_time();
	448
e46b8fb1	449	return SR_OK;
6239c175 UH	450	}
6239c175 UH	451
6078d2c9	452	static int dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
6239c175	453	{
33ef7573	454	struct dev_context *const devc = sdi->priv;
c216d623	455	struct sr_datafeed_packet packet;
7fd3e859	456
33ef7573	457	(void)cb_data;
7fd3e859	458
49145a63 AG	459	sr_dbg("Stopping aquisition.");
49145a63 AG	460
e0532047 JH	461	sr_session_source_remove_channel(devc->channel);
e0532047 JH	462	g_io_channel_shutdown(devc->channel, FALSE, NULL);
2150a69b JH	463	g_io_channel_unref(devc->channel);
2150a69b JH	464	devc->channel = NULL;
c216d623 AG	465
	466	/* Send last packet. */
	467	packet.type = SR_DF_END;
3e9b7f9c	468	sr_session_send(devc->cb_data, &packet);
7fd3e859	469
3010f21c	470	return SR_OK;
6239c175 UH	471	}
6239c175 UH	472
c09f0b57	473	SR_PRIV struct sr_dev_driver demo_driver_info = {
e519ba86 UH	474	.name = "demo",
	475	.longname = "Demo driver and pattern generator",
	476	.api_version = 1,
6078d2c9 UH	477	.init = init,
	478	.cleanup = cleanup,
	479	.scan = scan,
	480	.dev_list = dev_list,
3b412e3a	481	.dev_clear = dev_clear,
035a1078 BV	482	.config_get = config_get,
035a1078 BV	483	.config_set = config_set,
a1c743fc	484	.config_list = config_list,
6078d2c9 UH	485	.dev_open = dev_open,
	486	.dev_close = dev_close,
	487	.dev_acquisition_start = dev_acquisition_start,
	488	.dev_acquisition_stop = dev_acquisition_stop,
b4750a3a	489	.priv = NULL,
6239c175	490	};