[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

#define DEMONAME               "Demo device"

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

#define STR_PATTERN_SIGROK   "sigrok"
#define STR_PATTERN_RANDOM   "random"
#define STR_PATTERN_INC      "incremental"
#define STR_PATTERN_ALL_LOW  "all-low"
#define STR_PATTERN_ALL_HIGH "all-high"

/* 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 {
	struct sr_dev_inst *sdi;
	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;
};

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 const char *pattern_strings[] = {
	"sigrok",
	"random",
	"incremental",
	"all-low",
	"all-high",
};

/* 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 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;

	(void)options;

	drvc = di->priv;

	devices = NULL;

	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	if (!sdi) {
		sr_err("Device instance creation failed.");
		return NULL;
	}
	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);

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

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

	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)
{
	struct dev_context *const devc = sdi->priv;

	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:
		switch (devc->sample_generator) {
		case PATTERN_SIGROK:
			*data = g_variant_new_string(STR_PATTERN_SIGROK);
			break;
		case PATTERN_RANDOM:
			*data = g_variant_new_string(STR_PATTERN_RANDOM);
			break;
		case PATTERN_INC:
			*data = g_variant_new_string(STR_PATTERN_INC);
			break;
		case PATTERN_ALL_LOW:
			*data = g_variant_new_string(STR_PATTERN_ALL_LOW);
			break;
		case PATTERN_ALL_HIGH:
			*data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
			break;
		}
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

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

	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("%s: setting samplerate to %" PRIu64, __func__,
		       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("%s: setting limit_samples to %" PRIu64, __func__,
		       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("%s: setting limit_msec to %" PRIu64, __func__,
		       devc->limit_msec);
		ret = SR_OK;
	} else if (id == SR_CONF_PATTERN_MODE) {
		stropt = g_variant_get_string(data, NULL);
		ret = SR_OK;
		if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
			devc->sample_generator = PATTERN_SIGROK;
		} else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
			devc->sample_generator = PATTERN_RANDOM;
		} else if (!strcmp(stropt, STR_PATTERN_INC)) {
			devc->sample_generator = PATTERN_INC;
		} else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
			devc->sample_generator = PATTERN_ALL_LOW;
		} else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
			devc->sample_generator = PATTERN_ALL_HIGH;
		} else {
			ret = SR_ERR;
		}
		sr_dbg("%s: setting pattern to %d",
			__func__, devc->sample_generator);
	} else {
		ret = SR_ERR_NA;
	}

	return ret;
}

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

	(void)sdi;

	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 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++ % sizeof(pattern_sigrok)] >> 1);
		}
		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) = p++;
		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 * 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, 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->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(devc->sdi, cb_data);
		return TRUE;
	}

	return TRUE;
}

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

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

	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)) {
		/* TODO: Better error message. */
		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, receive_data, devc);

	/* 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
	1	/*
	2	* This file is part of the libsigrok 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 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)
	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	#define STR_PATTERN_SIGROK "sigrok"
	53	#define STR_PATTERN_RANDOM "random"
	54	#define STR_PATTERN_INC "incremental"
	55	#define STR_PATTERN_ALL_LOW "all-low"
	56	#define STR_PATTERN_ALL_HIGH "all-high"
	57
	58	/* Supported patterns which we can generate */
	59	enum {
	60	/**
	61	* Pattern which spells "sigrok" using '0's (with '1's as "background")
	62	* when displayed using the 'bits' output format.
	63	*/
	64	PATTERN_SIGROK,
	65
	66	/** Pattern which consists of (pseudo-)random values on all probes. */
	67	PATTERN_RANDOM,
	68
	69	/**
	70	* Pattern which consists of incrementing numbers.
	71	* TODO: Better description.
	72	*/
	73	PATTERN_INC,
	74
	75	/** Pattern where all probes have a low logic state. */
	76	PATTERN_ALL_LOW,
	77
	78	/** Pattern where all probes have a high logic state. */
	79	PATTERN_ALL_HIGH,
	80	};
	81
	82	/* Private, per-device-instance driver context. */
	83	struct dev_context {
	84	struct sr_dev_inst *sdi;
	85	int pipe_fds[2];
	86	GIOChannel *channel;
	87	uint64_t cur_samplerate;
	88	uint64_t limit_samples;
	89	uint64_t limit_msec;
	90	uint8_t sample_generator;
	91	uint64_t samples_counter;
	92	void *cb_data;
	93	int64_t starttime;
	94	};
	95
	96	static const int hwcaps[] = {
	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,
	104	};
	105
	106	static const uint64_t samplerates[] = {
	107	SR_HZ(1),
	108	SR_GHZ(1),
	109	SR_HZ(1),
	110	};
	111
	112	static const char *pattern_strings[] = {
	113	"sigrok",
	114	"random",
	115	"incremental",
	116	"all-low",
	117	"all-high",
	118	};
	119
	120	/* We name the probes 0-7 on our demo driver. */
	121	static const char *probe_names[NUM_PROBES + 1] = {
	122	"0", "1", "2", "3", "4", "5", "6", "7",
	123	NULL,
	124	};
	125
	126	static uint8_t pattern_sigrok[] = {
	127	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
	128	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
	129	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
	130	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
	131	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
	132	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
	133	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	134	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	135	};
	136
	137	/* Private, per-device-instance driver context. */
	138	/* TODO: struct context as with the other drivers. */
	139
	140	/* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
	141	SR_PRIV struct sr_dev_driver demo_driver_info;
	142	static struct sr_dev_driver *di = &demo_driver_info;
	143
	144	static int dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data);
	145
	146	static int dev_clear(void)
	147	{
	148	return std_dev_clear(di, NULL);
	149	}
	150
	151	static int init(struct sr_context *sr_ctx)
	152	{
	153	return std_init(sr_ctx, di, LOG_PREFIX);
	154	}
	155
	156	static GSList scan(GSList options)
	157	{
	158	struct sr_dev_inst *sdi;
	159	struct sr_probe *probe;
	160	struct drv_context *drvc;
	161	struct dev_context *devc;
	162	GSList *devices;
	163	int i;
	164
	165	(void)options;
	166
	167	drvc = di->priv;
	168
	169	devices = NULL;
	170
	171	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	172	if (!sdi) {
	173	sr_err("Device instance creation failed.");
	174	return NULL;
	175	}
	176	sdi->driver = di;
	177
	178	for (i = 0; probe_names[i]; i++) {
	179	if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
	180	probe_names[i])))
	181	return NULL;
	182	sdi->probes = g_slist_append(sdi->probes, probe);
	183	}
	184
	185	devices = g_slist_append(devices, sdi);
	186	drvc->instances = g_slist_append(drvc->instances, sdi);
	187
	188	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
	189	sr_err("Device context malloc failed.");
	190	return NULL;
	191	}
	192
	193	devc->sdi = sdi;
	194	devc->cur_samplerate = SR_KHZ(200);
	195	devc->limit_samples = 0;
	196	devc->limit_msec = 0;
	197	devc->sample_generator = PATTERN_SIGROK;
	198
	199	sdi->priv = devc;
	200
	201	return devices;
	202	}
	203
	204	static GSList *dev_list(void)
	205	{
	206	return ((struct drv_context *)(di->priv))->instances;
	207	}
	208
	209	static int dev_open(struct sr_dev_inst *sdi)
	210	{
	211	sdi->status = SR_ST_ACTIVE;
	212
	213	return SR_OK;
	214	}
	215
	216	static int dev_close(struct sr_dev_inst *sdi)
	217	{
	218	sdi->status = SR_ST_INACTIVE;
	219
	220	return SR_OK;
	221	}
	222
	223	static int cleanup(void)
	224	{
	225	return dev_clear();
	226	}
	227
	228	static int config_get(int id, GVariant *data, const struct sr_dev_inst sdi)
	229	{
	230	struct dev_context *const devc = sdi->priv;
	231
	232	switch (id) {
	233	case SR_CONF_SAMPLERATE:
	234	*data = g_variant_new_uint64(devc->cur_samplerate);
	235	break;
	236	case SR_CONF_LIMIT_SAMPLES:
	237	*data = g_variant_new_uint64(devc->limit_samples);
	238	break;
	239	case SR_CONF_LIMIT_MSEC:
	240	*data = g_variant_new_uint64(devc->limit_msec);
	241	break;
	242	case SR_CONF_PATTERN_MODE:
	243	switch (devc->sample_generator) {
	244	case PATTERN_SIGROK:
	245	*data = g_variant_new_string(STR_PATTERN_SIGROK);
	246	break;
	247	case PATTERN_RANDOM:
	248	*data = g_variant_new_string(STR_PATTERN_RANDOM);
	249	break;
	250	case PATTERN_INC:
	251	*data = g_variant_new_string(STR_PATTERN_INC);
	252	break;
	253	case PATTERN_ALL_LOW:
	254	*data = g_variant_new_string(STR_PATTERN_ALL_LOW);
	255	break;
	256	case PATTERN_ALL_HIGH:
	257	*data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
	258	break;
	259	}
	260	break;
	261	default:
	262	return SR_ERR_NA;
	263	}
	264
	265	return SR_OK;
	266	}
	267
	268	static int config_set(int id, GVariant data, const struct sr_dev_inst sdi)
	269	{
	270	int ret;
	271	const char *stropt;
	272
	273	struct dev_context *const devc = sdi->priv;
	274
	275	if (sdi->status != SR_ST_ACTIVE)
	276	return SR_ERR_DEV_CLOSED;
	277
	278	if (id == SR_CONF_SAMPLERATE) {
	279	devc->cur_samplerate = g_variant_get_uint64(data);
	280	sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
	281	devc->cur_samplerate);
	282	ret = SR_OK;
	283	} else if (id == SR_CONF_LIMIT_SAMPLES) {
	284	devc->limit_msec = 0;
	285	devc->limit_samples = g_variant_get_uint64(data);
	286	sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
	287	devc->limit_samples);
	288	ret = SR_OK;
	289	} else if (id == SR_CONF_LIMIT_MSEC) {
	290	devc->limit_msec = g_variant_get_uint64(data);
	291	devc->limit_samples = 0;
	292	sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
	293	devc->limit_msec);
	294	ret = SR_OK;
	295	} else if (id == SR_CONF_PATTERN_MODE) {
	296	stropt = g_variant_get_string(data, NULL);
	297	ret = SR_OK;
	298	if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
	299	devc->sample_generator = PATTERN_SIGROK;
	300	} else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
	301	devc->sample_generator = PATTERN_RANDOM;
	302	} else if (!strcmp(stropt, STR_PATTERN_INC)) {
	303	devc->sample_generator = PATTERN_INC;
	304	} else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
	305	devc->sample_generator = PATTERN_ALL_LOW;
	306	} else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
	307	devc->sample_generator = PATTERN_ALL_HIGH;
	308	} else {
	309	ret = SR_ERR;
	310	}
	311	sr_dbg("%s: setting pattern to %d",
	312	__func__, devc->sample_generator);
	313	} else {
	314	ret = SR_ERR_NA;
	315	}
	316
	317	return ret;
	318	}
	319
	320	static int config_list(int key, GVariant *data, const struct sr_dev_inst sdi)
	321	{
	322	GVariant *gvar;
	323	GVariantBuilder gvb;
	324
	325	(void)sdi;
	326
	327	switch (key) {
	328	case SR_CONF_DEVICE_OPTIONS:
	329	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
	330	hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
	331	break;
	332	case SR_CONF_SAMPLERATE:
	333	g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
	334	gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
	335	ARRAY_SIZE(samplerates), sizeof(uint64_t));
	336	g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
	337	*data = g_variant_builder_end(&gvb);
	338	break;
	339	case SR_CONF_PATTERN_MODE:
	340	*data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
	341	break;
	342	default:
	343	return SR_ERR_NA;
	344	}
	345
	346	return SR_OK;
	347	}
	348
	349	static void samples_generator(uint8_t *buf, uint64_t size,
	350	struct dev_context *devc)
	351	{
	352	static uint64_t p = 0;
	353	uint64_t i;
	354
	355	/* TODO: Needed? */
	356	memset(buf, 0, size);
	357
	358	switch (devc->sample_generator) {
	359	case PATTERN_SIGROK: /* sigrok pattern */
	360	for (i = 0; i < size; i++) {
	361	*(buf + i) = ~(pattern_sigrok[
	362	p++ % sizeof(pattern_sigrok)] >> 1);
	363	}
	364	break;
	365	case PATTERN_RANDOM: /* Random */
	366	for (i = 0; i < size; i++)
	367	*(buf + i) = (uint8_t)(rand() & 0xff);
	368	break;
	369	case PATTERN_INC: /* Simple increment */
	370	for (i = 0; i < size; i++)
	371	*(buf + i) = p++;
	372	break;
	373	case PATTERN_ALL_LOW: /* All probes are low */
	374	memset(buf, 0x00, size);
	375	break;
	376	case PATTERN_ALL_HIGH: /* All probes are high */
	377	memset(buf, 0xff, size);
	378	break;
	379	default:
	380	sr_err("Unknown pattern: %d.", devc->sample_generator);
	381	break;
	382	}
	383	}
	384
	385	/* Callback handling data */
	386	static int receive_data(int fd, int revents, void *cb_data)
	387	{
	388	struct dev_context *devc = cb_data;
	389	struct sr_datafeed_packet packet;
	390	struct sr_datafeed_logic logic;
	391	uint8_t buf[BUFSIZE];
	392	static uint64_t samples_to_send, expected_samplenum, sending_now;
	393	int64_t time, elapsed;
	394
	395	(void)fd;
	396	(void)revents;
	397
	398	/* How many "virtual" samples should we have collected by now? */
	399	time = g_get_monotonic_time();
	400	elapsed = time - devc->starttime;
	401	expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
	402	/* Of those, how many do we still have to send? */
	403	samples_to_send = expected_samplenum - devc->samples_counter;
	404
	405	if (devc->limit_samples) {
	406	samples_to_send = MIN(samples_to_send,
	407	devc->limit_samples - devc->samples_counter);
	408	}
	409
	410	while (samples_to_send > 0) {
	411	sending_now = MIN(samples_to_send, sizeof(buf));
	412	samples_to_send -= sending_now;
	413	samples_generator(buf, sending_now, devc);
	414
	415	packet.type = SR_DF_LOGIC;
	416	packet.payload = &logic;
	417	logic.length = sending_now;
	418	logic.unitsize = 1;
	419	logic.data = buf;
	420	sr_session_send(devc->cb_data, &packet);
	421	devc->samples_counter += sending_now;
	422	}
	423
	424	if (devc->limit_samples &&
	425	devc->samples_counter >= devc->limit_samples) {
	426	sr_info("Requested number of samples reached.");
	427	dev_acquisition_stop(devc->sdi, cb_data);
	428	return TRUE;
	429	}
	430
	431	return TRUE;
	432	}
	433
	434	static int dev_acquisition_start(const struct sr_dev_inst sdi, void cb_data)
	435	{
	436	struct dev_context *const devc = sdi->priv;
	437
	438	if (sdi->status != SR_ST_ACTIVE)
	439	return SR_ERR_DEV_CLOSED;
	440
	441	devc->cb_data = cb_data;
	442	devc->samples_counter = 0;
	443
	444	/*
	445	* Setting two channels connected by a pipe is a remnant from when the
	446	* demo driver generated data in a thread, and collected and sent the
	447	* data in the main program loop.
	448	* They are kept here because it provides a convenient way of setting
	449	* up a timeout-based polling mechanism.
	450	*/
	451	if (pipe(devc->pipe_fds)) {
	452	/* TODO: Better error message. */
	453	sr_err("%s: pipe() failed", __func__);
	454	return SR_ERR;
	455	}
	456
	457	devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
	458
	459	g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
	460
	461	/* Set channel encoding to binary (default is UTF-8). */
	462	g_io_channel_set_encoding(devc->channel, NULL, NULL);
	463
	464	/* Make channels to unbuffered. */
	465	g_io_channel_set_buffered(devc->channel, FALSE);
	466
	467	sr_session_source_add_channel(devc->channel, G_IO_IN \| G_IO_ERR,
	468	40, receive_data, devc);
	469
	470	/* Send header packet to the session bus. */
	471	std_session_send_df_header(cb_data, LOG_PREFIX);
	472
	473	/* We use this timestamp to decide how many more samples to send. */
	474	devc->starttime = g_get_monotonic_time();
	475
	476	return SR_OK;
	477	}
	478
	479	static int dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
	480	{
	481	struct dev_context *const devc = sdi->priv;
	482	struct sr_datafeed_packet packet;
	483
	484	(void)cb_data;
	485
	486	sr_dbg("Stopping aquisition.");
	487
	488	sr_session_source_remove_channel(devc->channel);
	489	g_io_channel_shutdown(devc->channel, FALSE, NULL);
	490	g_io_channel_unref(devc->channel);
	491	devc->channel = NULL;
	492
	493	/* Send last packet. */
	494	packet.type = SR_DF_END;
	495	sr_session_send(devc->cb_data, &packet);
	496
	497	return SR_OK;
	498	}
	499
	500	SR_PRIV struct sr_dev_driver demo_driver_info = {
	501	.name = "demo",
	502	.longname = "Demo driver and pattern generator",
	503	.api_version = 1,
	504	.init = init,
	505	.cleanup = cleanup,
	506	.scan = scan,
	507	.dev_list = dev_list,
	508	.dev_clear = dev_clear,
	509	.config_get = config_get,
	510	.config_set = config_set,
	511	.config_list = config_list,
	512	.dev_open = dev_open,
	513	.dev_close = dev_close,
	514	.dev_acquisition_start = dev_acquisition_start,
	515	.dev_acquisition_stop = dev_acquisition_stop,
	516	.priv = NULL,
	517	};