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

/*
 * This file is part of the sigrok 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 driver-specific prefix string. */
#define DRIVER_LOG_DOMAIN "demo: "
#define sr_log(l, s, args...) sr_log(l, DRIVER_LOG_DOMAIN s, ## args)
#define sr_spew(s, args...) sr_spew(DRIVER_LOG_DOMAIN s, ## args)
#define sr_dbg(s, args...) sr_dbg(DRIVER_LOG_DOMAIN s, ## args)
#define sr_info(s, args...) sr_info(DRIVER_LOG_DOMAIN s, ## args)
#define sr_warn(s, args...) sr_warn(DRIVER_LOG_DOMAIN s, ## args)
#define sr_err(s, args...) sr_err(DRIVER_LOG_DOMAIN s, ## args)

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

#define DEMONAME               "Demo device"

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

/* Supported patterns which we can generate */
enum {
	/**
	 * Pattern which spells "sigrok" using '0's (with '1's as "background")
	 * when displayed using the 'bits' output format.
	 */
	PATTERN_SIGROK,

	/** Pattern which consists of (pseudo-)random values on all probes. */
	PATTERN_RANDOM,

	/**
	 * Pattern which consists of incrementing numbers.
	 * TODO: Better description.
	 */
	PATTERN_INC,

	/** Pattern where all probes have a low logic state. */
	PATTERN_ALL_LOW,

	/** Pattern where all probes have a high logic state. */
	PATTERN_ALL_HIGH,
};

/* Private, per-device-instance driver context. */
struct dev_context {
	int pipe_fds[2];
	GIOChannel *channels[2];
	uint8_t sample_generator;
	uint64_t samples_counter;
	void *session_dev_id;
	int64_t starttime;
};

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 struct sr_samplerates samplerates = {
	.low  = SR_HZ(1),
	.high = SR_GHZ(1),
	.step = SR_HZ(1),
	.list = NULL,
};

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

/* We name the probes 0-7 on our demo driver. */
static const char *probe_names[NUM_PROBES + 1] = {
	"0", "1", "2", "3", "4", "5", "6", "7",
	NULL,
};

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 uint64_t cur_samplerate = SR_KHZ(200);
static uint64_t limit_samples = 0;
static uint64_t limit_msec = 0;
static int default_pattern = PATTERN_SIGROK;

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

static int clear_instances(void)
{
	/* Nothing needed so far. */

	return SR_OK;
}

static int hw_init(struct sr_context *sr_ctx)
{
	return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
}

static GSList *hw_scan(GSList *options)
{
	struct sr_dev_inst *sdi;
	struct sr_probe *probe;
	struct drv_context *drvc;
	GSList *devices;
	int i;

	(void)options;

	drvc = di->priv;

	devices = NULL;

	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	if (!sdi) {
		sr_err("%s: sr_dev_inst_new failed", __func__);
		return 0;
	}
	sdi->driver = di;

	for (i = 0; probe_names[i]; i++) {
		if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
				probe_names[i])))
			return NULL;
		sdi->probes = g_slist_append(sdi->probes, probe);
	}

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

	return devices;
}

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

static int hw_dev_open(struct sr_dev_inst *sdi)
{
	(void)sdi;

	/* Nothing needed so far. */

	return SR_OK;
}

static int hw_dev_close(struct sr_dev_inst *sdi)
{
	(void)sdi;

	/* Nothing needed so far. */

	return SR_OK;
}

static int hw_cleanup(void)
{
	/* Nothing needed so far. */
	return SR_OK;
}

static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
{
	(void)sdi;

	switch (id) {
	case SR_CONF_SAMPLERATE:
		*data = &cur_samplerate;
		break;
	default:
		return SR_ERR_ARG;
	}

	return SR_OK;
}

static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
{
	int ret;
	const char *stropt;

	(void)sdi;

	if (id == SR_CONF_SAMPLERATE) {
		cur_samplerate = *(const uint64_t *)value;
		sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
		       cur_samplerate);
		ret = SR_OK;
	} else if (id == SR_CONF_LIMIT_SAMPLES) {
		limit_msec = 0;
		limit_samples = *(const uint64_t *)value;
		sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
		       limit_samples);
		ret = SR_OK;
	} else if (id == SR_CONF_LIMIT_MSEC) {
		limit_msec = *(const uint64_t *)value;
		limit_samples = 0;
		sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
		       limit_msec);
		ret = SR_OK;
	} else if (id == SR_CONF_PATTERN_MODE) {
		stropt = value;
		ret = SR_OK;
		if (!strcmp(stropt, "sigrok")) {
			default_pattern = PATTERN_SIGROK;
		} else if (!strcmp(stropt, "random")) {
			default_pattern = PATTERN_RANDOM;
		} else if (!strcmp(stropt, "incremental")) {
			default_pattern = PATTERN_INC;
		} else if (!strcmp(stropt, "all-low")) {
			default_pattern = PATTERN_ALL_LOW;
		} else if (!strcmp(stropt, "all-high")) {
			default_pattern = PATTERN_ALL_HIGH;
		} else {
			ret = SR_ERR;
		}
		sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
	} else {
		ret = SR_ERR;
	}

	return ret;
}

static int config_list(int key, const void **data, const struct sr_dev_inst *sdi)
{

	(void)sdi;

	switch (key) {
	case SR_CONF_DEVICE_OPTIONS:
		*data = hwcaps;
		break;
	case SR_CONF_SAMPLERATE:
		*data = &samplerates;
		break;
	case SR_CONF_PATTERN_MODE:
		*data = &pattern_strings;
		break;
	default:
		return SR_ERR_ARG;
	}

	return SR_OK;
}

static void samples_generator(uint8_t *buf, uint64_t size,
			      struct dev_context *devc)
{
	static uint64_t p = 0;
	uint64_t i;

	/* TODO: Needed? */
	memset(buf, 0, size);

	switch (devc->sample_generator) {
	case PATTERN_SIGROK: /* sigrok pattern */
		for (i = 0; i < size; i++) {
			*(buf + i) = ~(pattern_sigrok[p] >> 1);
			if (++p == 64)
				p = 0;
		}
		break;
	case PATTERN_RANDOM: /* Random */
		for (i = 0; i < size; i++)
			*(buf + i) = (uint8_t)(rand() & 0xff);
		break;
	case PATTERN_INC: /* Simple increment */
		for (i = 0; i < size; i++)
			*(buf + i) = i;
		break;
	case PATTERN_ALL_LOW: /* All probes are low */
		memset(buf, 0x00, size);
		break;
	case PATTERN_ALL_HIGH: /* All probes are high */
		memset(buf, 0xff, size);
		break;
	default:
		sr_err("Unknown pattern: %d.", devc->sample_generator);
		break;
	}
}

/* Callback handling data */
static int receive_data(int fd, int revents, void *cb_data)
{
	struct dev_context *devc = cb_data;
	struct sr_datafeed_packet packet;
	struct sr_datafeed_logic logic;
	uint8_t buf[BUFSIZE];
	static uint64_t samples_to_send, expected_samplenum, sending_now;
	int64_t time, elapsed;

	(void)fd;
	(void)revents;

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

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

	while (samples_to_send > 0) {
		sending_now = MIN(samples_to_send, sizeof(buf));
		samples_to_send -= sending_now;
		samples_generator(buf, sending_now, devc);

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

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

	return TRUE;
}

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

	(void)sdi;

	/* TODO: 'devc' is never g_free()'d? */
	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
		sr_err("%s: devc malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	devc->sample_generator = default_pattern;
	devc->session_dev_id = 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)) {
		/* TODO: Better error message. */
		sr_err("%s: pipe() failed", __func__);
		return SR_ERR;
	}

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

	g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);

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

	/* Make channels to unbuffered. */
	g_io_channel_set_buffered(devc->channels[0], FALSE);
	g_io_channel_set_buffered(devc->channels[1], FALSE);

	sr_session_source_add_channel(devc->channels[0], G_IO_IN | G_IO_ERR,
		    40, receive_data, devc);

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

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

	return SR_OK;
}

static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
{
	struct dev_context *devc;
	struct sr_datafeed_packet packet;

	(void)sdi;

	devc = cb_data;

	sr_dbg("Stopping aquisition.");

	sr_session_source_remove_channel(devc->channels[0]);
	g_io_channel_shutdown(devc->channels[0], FALSE, NULL);

	/* Send last packet. */
	packet.type = SR_DF_END;
	sr_session_send(devc->session_dev_id, &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 = hw_init,
	.cleanup = hw_cleanup,
	.scan = hw_scan,
	.dev_list = hw_dev_list,
	.dev_clear = clear_instances,
	.config_get = config_get,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = hw_dev_open,
	.dev_close = hw_dev_close,
	.dev_acquisition_start = hw_dev_acquisition_start,
	.dev_acquisition_stop = hw_dev_acquisition_stop,
	.priv = NULL,
};
Commit	Line	Data
	1	/*
	2	* This file is part of the sigrok project.
	3	*
	4	* Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
	5	* Copyright (C) 2011 Olivier Fauchon <olivier@aixmarseille.com>
	6	* Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
	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>
	24	#include <unistd.h>
	25	#include <string.h>
	26	#ifdef _WIN32
	27	#include <io.h>
	28	#include <fcntl.h>
	29	#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
	30	#endif
	31	#include "libsigrok.h"
	32	#include "libsigrok-internal.h"
	33
	34	/* Message logging helpers with driver-specific prefix string. */
	35	#define DRIVER_LOG_DOMAIN "demo: "
	36	#define sr_log(l, s, args...) sr_log(l, DRIVER_LOG_DOMAIN s, ## args)
	37	#define sr_spew(s, args...) sr_spew(DRIVER_LOG_DOMAIN s, ## args)
	38	#define sr_dbg(s, args...) sr_dbg(DRIVER_LOG_DOMAIN s, ## args)
	39	#define sr_info(s, args...) sr_info(DRIVER_LOG_DOMAIN s, ## args)
	40	#define sr_warn(s, args...) sr_warn(DRIVER_LOG_DOMAIN s, ## args)
	41	#define sr_err(s, args...) sr_err(DRIVER_LOG_DOMAIN s, ## args)
	42
	43	/* TODO: Number of probes should be configurable. */
	44	#define NUM_PROBES 8
	45
	46	#define DEMONAME "Demo device"
	47
	48	/* The size of chunks to send through the session bus. */
	49	/* TODO: Should be configurable. */
	50	#define BUFSIZE 4096
	51
	52	/* Supported patterns which we can generate */
	53	enum {
	54	/**
	55	* Pattern which spells "sigrok" using '0's (with '1's as "background")
	56	* when displayed using the 'bits' output format.
	57	*/
	58	PATTERN_SIGROK,
	59
	60	/** Pattern which consists of (pseudo-)random values on all probes. */
	61	PATTERN_RANDOM,
	62
	63	/**
	64	* Pattern which consists of incrementing numbers.
	65	* TODO: Better description.
	66	*/
	67	PATTERN_INC,
	68
	69	/** Pattern where all probes have a low logic state. */
	70	PATTERN_ALL_LOW,
	71
	72	/** Pattern where all probes have a high logic state. */
	73	PATTERN_ALL_HIGH,
	74	};
	75
	76	/* Private, per-device-instance driver context. */
	77	struct dev_context {
	78	int pipe_fds[2];
	79	GIOChannel *channels[2];
	80	uint8_t sample_generator;
	81	uint64_t samples_counter;
	82	void *session_dev_id;
	83	int64_t starttime;
	84	};
	85
	86	static const int hwcaps[] = {
	87	SR_CONF_LOGIC_ANALYZER,
	88	SR_CONF_DEMO_DEV,
	89	SR_CONF_SAMPLERATE,
	90	SR_CONF_PATTERN_MODE,
	91	SR_CONF_LIMIT_SAMPLES,
	92	SR_CONF_LIMIT_MSEC,
	93	SR_CONF_CONTINUOUS,
	94	};
	95
	96	static const struct sr_samplerates samplerates = {
	97	.low = SR_HZ(1),
	98	.high = SR_GHZ(1),
	99	.step = SR_HZ(1),
	100	.list = NULL,
	101	};
	102
	103	static const char *pattern_strings[] = {
	104	"sigrok",
	105	"random",
	106	"incremental",
	107	"all-low",
	108	"all-high",
	109	NULL,
	110	};
	111
	112	/* We name the probes 0-7 on our demo driver. */
	113	static const char *probe_names[NUM_PROBES + 1] = {
	114	"0", "1", "2", "3", "4", "5", "6", "7",
	115	NULL,
	116	};
	117
	118	static uint8_t pattern_sigrok[] = {
	119	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
	120	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
	121	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
	122	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
	123	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
	124	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
	125	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	126	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	127	};
	128
	129	/* Private, per-device-instance driver context. */
	130	/* TODO: struct context as with the other drivers. */
	131
	132	/* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
	133	SR_PRIV struct sr_dev_driver demo_driver_info;
	134	static struct sr_dev_driver *di = &demo_driver_info;
	135	static uint64_t cur_samplerate = SR_KHZ(200);
	136	static uint64_t limit_samples = 0;
	137	static uint64_t limit_msec = 0;
	138	static int default_pattern = PATTERN_SIGROK;
	139
	140	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data);
	141
	142	static int clear_instances(void)
	143	{
	144	/* Nothing needed so far. */
	145
	146	return SR_OK;
	147	}
	148
	149	static int hw_init(struct sr_context *sr_ctx)
	150	{
	151	return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
	152	}
	153
	154	static GSList hw_scan(GSList options)
	155	{
	156	struct sr_dev_inst *sdi;
	157	struct sr_probe *probe;
	158	struct drv_context *drvc;
	159	GSList *devices;
	160	int i;
	161
	162	(void)options;
	163
	164	drvc = di->priv;
	165
	166	devices = NULL;
	167
	168	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	169	if (!sdi) {
	170	sr_err("%s: sr_dev_inst_new failed", __func__);
	171	return 0;
	172	}
	173	sdi->driver = di;
	174
	175	for (i = 0; probe_names[i]; i++) {
	176	if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
	177	probe_names[i])))
	178	return NULL;
	179	sdi->probes = g_slist_append(sdi->probes, probe);
	180	}
	181
	182	devices = g_slist_append(devices, sdi);
	183	drvc->instances = g_slist_append(drvc->instances, sdi);
	184
	185	return devices;
	186	}
	187
	188	static GSList *hw_dev_list(void)
	189	{
	190	return ((struct drv_context *)(di->priv))->instances;
	191	}
	192
	193	static int hw_dev_open(struct sr_dev_inst *sdi)
	194	{
	195	(void)sdi;
	196
	197	/* Nothing needed so far. */
	198
	199	return SR_OK;
	200	}
	201
	202	static int hw_dev_close(struct sr_dev_inst *sdi)
	203	{
	204	(void)sdi;
	205
	206	/* Nothing needed so far. */
	207
	208	return SR_OK;
	209	}
	210
	211	static int hw_cleanup(void)
	212	{
	213	/* Nothing needed so far. */
	214	return SR_OK;
	215	}
	216
	217	static int config_get(int id, const void *data, const struct sr_dev_inst sdi)
	218	{
	219	(void)sdi;
	220
	221	switch (id) {
	222	case SR_CONF_SAMPLERATE:
	223	*data = &cur_samplerate;
	224	break;
	225	default:
	226	return SR_ERR_ARG;
	227	}
	228
	229	return SR_OK;
	230	}
	231
	232	static int config_set(int id, const void value, const struct sr_dev_inst sdi)
	233	{
	234	int ret;
	235	const char *stropt;
	236
	237	(void)sdi;
	238
	239	if (id == SR_CONF_SAMPLERATE) {
	240	cur_samplerate = (const uint64_t )value;
	241	sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
	242	cur_samplerate);
	243	ret = SR_OK;
	244	} else if (id == SR_CONF_LIMIT_SAMPLES) {
	245	limit_msec = 0;
	246	limit_samples = (const uint64_t )value;
	247	sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
	248	limit_samples);
	249	ret = SR_OK;
	250	} else if (id == SR_CONF_LIMIT_MSEC) {
	251	limit_msec = (const uint64_t )value;
	252	limit_samples = 0;
	253	sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
	254	limit_msec);
	255	ret = SR_OK;
	256	} else if (id == SR_CONF_PATTERN_MODE) {
	257	stropt = value;
	258	ret = SR_OK;
	259	if (!strcmp(stropt, "sigrok")) {
	260	default_pattern = PATTERN_SIGROK;
	261	} else if (!strcmp(stropt, "random")) {
	262	default_pattern = PATTERN_RANDOM;
	263	} else if (!strcmp(stropt, "incremental")) {
	264	default_pattern = PATTERN_INC;
	265	} else if (!strcmp(stropt, "all-low")) {
	266	default_pattern = PATTERN_ALL_LOW;
	267	} else if (!strcmp(stropt, "all-high")) {
	268	default_pattern = PATTERN_ALL_HIGH;
	269	} else {
	270	ret = SR_ERR;
	271	}
	272	sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
	273	} else {
	274	ret = SR_ERR;
	275	}
	276
	277	return ret;
	278	}
	279
	280	static int config_list(int key, const void *data, const struct sr_dev_inst sdi)
	281	{
	282
	283	(void)sdi;
	284
	285	switch (key) {
	286	case SR_CONF_DEVICE_OPTIONS:
	287	*data = hwcaps;
	288	break;
	289	case SR_CONF_SAMPLERATE:
	290	*data = &samplerates;
	291	break;
	292	case SR_CONF_PATTERN_MODE:
	293	*data = &pattern_strings;
	294	break;
	295	default:
	296	return SR_ERR_ARG;
	297	}
	298
	299	return SR_OK;
	300	}
	301
	302	static void samples_generator(uint8_t *buf, uint64_t size,
	303	struct dev_context *devc)
	304	{
	305	static uint64_t p = 0;
	306	uint64_t i;
	307
	308	/* TODO: Needed? */
	309	memset(buf, 0, size);
	310
	311	switch (devc->sample_generator) {
	312	case PATTERN_SIGROK: /* sigrok pattern */
	313	for (i = 0; i < size; i++) {
	314	*(buf + i) = ~(pattern_sigrok[p] >> 1);
	315	if (++p == 64)
	316	p = 0;
	317	}
	318	break;
	319	case PATTERN_RANDOM: /* Random */
	320	for (i = 0; i < size; i++)
	321	*(buf + i) = (uint8_t)(rand() & 0xff);
	322	break;
	323	case PATTERN_INC: /* Simple increment */
	324	for (i = 0; i < size; i++)
	325	*(buf + i) = i;
	326	break;
	327	case PATTERN_ALL_LOW: /* All probes are low */
	328	memset(buf, 0x00, size);
	329	break;
	330	case PATTERN_ALL_HIGH: /* All probes are high */
	331	memset(buf, 0xff, size);
	332	break;
	333	default:
	334	sr_err("Unknown pattern: %d.", devc->sample_generator);
	335	break;
	336	}
	337	}
	338
	339	/* Callback handling data */
	340	static int receive_data(int fd, int revents, void *cb_data)
	341	{
	342	struct dev_context *devc = cb_data;
	343	struct sr_datafeed_packet packet;
	344	struct sr_datafeed_logic logic;
	345	uint8_t buf[BUFSIZE];
	346	static uint64_t samples_to_send, expected_samplenum, sending_now;
	347	int64_t time, elapsed;
	348
	349	(void)fd;
	350	(void)revents;
	351
	352	/* How many "virtual" samples should we have collected by now? */
	353	time = g_get_monotonic_time();
	354	elapsed = time - devc->starttime;
	355	expected_samplenum = elapsed * cur_samplerate / 1000000;
	356	/* Of those, how many do we still have to send? */
	357	samples_to_send = expected_samplenum - devc->samples_counter;
	358
	359	if (limit_samples) {
	360	samples_to_send = MIN(samples_to_send,
	361	limit_samples - devc->samples_counter);
	362	}
	363
	364	while (samples_to_send > 0) {
	365	sending_now = MIN(samples_to_send, sizeof(buf));
	366	samples_to_send -= sending_now;
	367	samples_generator(buf, sending_now, devc);
	368
	369	packet.type = SR_DF_LOGIC;
	370	packet.payload = &logic;
	371	logic.length = sending_now;
	372	logic.unitsize = 1;
	373	logic.data = buf;
	374	sr_session_send(devc->session_dev_id, &packet);
	375	devc->samples_counter += sending_now;
	376	}
	377
	378	if (limit_samples && devc->samples_counter >= limit_samples) {
	379	sr_info("Requested number of samples reached.");
	380	hw_dev_acquisition_stop(NULL, cb_data);
	381	return TRUE;
	382	}
	383
	384	return TRUE;
	385	}
	386
	387	static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
	388	void *cb_data)
	389	{
	390	struct dev_context *devc;
	391
	392	(void)sdi;
	393
	394	/* TODO: 'devc' is never g_free()'d? */
	395	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
	396	sr_err("%s: devc malloc failed", __func__);
	397	return SR_ERR_MALLOC;
	398	}
	399
	400	devc->sample_generator = default_pattern;
	401	devc->session_dev_id = cb_data;
	402	devc->samples_counter = 0;
	403
	404	/*
	405	* Setting two channels connected by a pipe is a remnant from when the
	406	* demo driver generated data in a thread, and collected and sent the
	407	* data in the main program loop.
	408	* They are kept here because it provides a convenient way of setting
	409	* up a timeout-based polling mechanism.
	410	*/
	411	if (pipe(devc->pipe_fds)) {
	412	/* TODO: Better error message. */
	413	sr_err("%s: pipe() failed", __func__);
	414	return SR_ERR;
	415	}
	416
	417	devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
	418	devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
	419
	420	g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
	421
	422	/* Set channel encoding to binary (default is UTF-8). */
	423	g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
	424	g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
	425
	426	/* Make channels to unbuffered. */
	427	g_io_channel_set_buffered(devc->channels[0], FALSE);
	428	g_io_channel_set_buffered(devc->channels[1], FALSE);
	429
	430	sr_session_source_add_channel(devc->channels[0], G_IO_IN \| G_IO_ERR,
	431	40, receive_data, devc);
	432
	433	/* Send header packet to the session bus. */
	434	std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
	435
	436	/* We use this timestamp to decide how many more samples to send. */
	437	devc->starttime = g_get_monotonic_time();
	438
	439	return SR_OK;
	440	}
	441
	442	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
	443	{
	444	struct dev_context *devc;
	445	struct sr_datafeed_packet packet;
	446
	447	(void)sdi;
	448
	449	devc = cb_data;
	450
	451	sr_dbg("Stopping aquisition.");
	452
	453	sr_session_source_remove_channel(devc->channels[0]);
	454	g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
	455
	456	/* Send last packet. */
	457	packet.type = SR_DF_END;
	458	sr_session_send(devc->session_dev_id, &packet);
	459
	460	return SR_OK;
	461	}
	462
	463	SR_PRIV struct sr_dev_driver demo_driver_info = {
	464	.name = "demo",
	465	.longname = "Demo driver and pattern generator",
	466	.api_version = 1,
	467	.init = hw_init,
	468	.cleanup = hw_cleanup,
	469	.scan = hw_scan,
	470	.dev_list = hw_dev_list,
	471	.dev_clear = clear_instances,
	472	.config_get = config_get,
	473	.config_set = config_set,
	474	.config_list = config_list,
	475	.dev_open = hw_dev_open,
	476	.dev_close = hw_dev_close,
	477	.dev_acquisition_start = hw_dev_acquisition_start,
	478	.dev_acquisition_stop = hw_dev_acquisition_stop,
	479	.priv = NULL,
	480	};