[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

#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 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;
	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("%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);

	/* 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->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 *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, 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_ARG;
	}

	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 (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;
	}

	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_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++ % 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.");
		hw_dev_acquisition_stop(devc->sdi, cb_data);
		return TRUE;
	}

	return TRUE;
}

static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
		void *cb_data)
{
	struct dev_context *const 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)) {
		/* 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, 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 *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);

	/* 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 = 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	#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 hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data);
	145
	146	static int clear_instances(void)
	147	{
	148	/* Nothing needed so far. */
	149
	150	return SR_OK;
	151	}
	152
	153	static int hw_init(struct sr_context *sr_ctx)
	154	{
	155	return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
	156	}
	157
	158	static GSList hw_scan(GSList options)
	159	{
	160	struct sr_dev_inst *sdi;
	161	struct sr_probe *probe;
	162	struct drv_context *drvc;
	163	struct dev_context *devc;
	164	GSList *devices;
	165	int i;
	166
	167	(void)options;
	168
	169	drvc = di->priv;
	170
	171	devices = NULL;
	172
	173	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	174	if (!sdi) {
	175	sr_err("%s: sr_dev_inst_new failed", __func__);
	176	return 0;
	177	}
	178	sdi->driver = di;
	179
	180	for (i = 0; probe_names[i]; i++) {
	181	if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
	182	probe_names[i])))
	183	return NULL;
	184	sdi->probes = g_slist_append(sdi->probes, probe);
	185	}
	186
	187	devices = g_slist_append(devices, sdi);
	188	drvc->instances = g_slist_append(drvc->instances, sdi);
	189
	190	/* TODO: 'devc' is never g_free()'d? */
	191	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
	192	sr_err("%s: devc malloc failed", __func__);
	193	return SR_ERR_MALLOC;
	194	}
	195
	196	devc->sdi = sdi;
	197	devc->cur_samplerate = SR_KHZ(200);
	198	devc->limit_samples = 0;
	199	devc->limit_msec = 0;
	200	devc->sample_generator = PATTERN_SIGROK;
	201
	202	sdi->priv = devc;
	203
	204	return devices;
	205	}
	206
	207	static GSList *hw_dev_list(void)
	208	{
	209	return ((struct drv_context *)(di->priv))->instances;
	210	}
	211
	212	static int hw_dev_open(struct sr_dev_inst *sdi)
	213	{
	214	(void)sdi;
	215
	216	/* Nothing needed so far. */
	217
	218	return SR_OK;
	219	}
	220
	221	static int hw_dev_close(struct sr_dev_inst *sdi)
	222	{
	223	(void)sdi;
	224
	225	/* Nothing needed so far. */
	226
	227	return SR_OK;
	228	}
	229
	230	static int hw_cleanup(void)
	231	{
	232	/* Nothing needed so far. */
	233	return SR_OK;
	234	}
	235
	236	static int config_get(int id, GVariant *data, const struct sr_dev_inst sdi)
	237	{
	238	struct dev_context *const devc = sdi->priv;
	239
	240	switch (id) {
	241	case SR_CONF_SAMPLERATE:
	242	*data = g_variant_new_uint64(devc->cur_samplerate);
	243	break;
	244	case SR_CONF_LIMIT_SAMPLES:
	245	*data = g_variant_new_uint64(devc->limit_samples);
	246	break;
	247	case SR_CONF_LIMIT_MSEC:
	248	*data = g_variant_new_uint64(devc->limit_msec);
	249	break;
	250	case SR_CONF_PATTERN_MODE:
	251	switch (devc->sample_generator) {
	252	case PATTERN_SIGROK:
	253	*data = g_variant_new_string(STR_PATTERN_SIGROK);
	254	break;
	255	case PATTERN_RANDOM:
	256	*data = g_variant_new_string(STR_PATTERN_RANDOM);
	257	break;
	258	case PATTERN_INC:
	259	*data = g_variant_new_string(STR_PATTERN_INC);
	260	break;
	261	case PATTERN_ALL_LOW:
	262	*data = g_variant_new_string(STR_PATTERN_ALL_LOW);
	263	break;
	264	case PATTERN_ALL_HIGH:
	265	*data = g_variant_new_string(STR_PATTERN_ALL_HIGH);
	266	break;
	267	}
	268	break;
	269	default:
	270	return SR_ERR_ARG;
	271	}
	272
	273	return SR_OK;
	274	}
	275
	276	static int config_set(int id, GVariant data, const struct sr_dev_inst sdi)
	277	{
	278	int ret;
	279	const char *stropt;
	280
	281	struct dev_context *const devc = sdi->priv;
	282
	283	if (id == SR_CONF_SAMPLERATE) {
	284	devc->cur_samplerate = g_variant_get_uint64(data);
	285	sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
	286	devc->cur_samplerate);
	287	ret = SR_OK;
	288	} else if (id == SR_CONF_LIMIT_SAMPLES) {
	289	devc->limit_msec = 0;
	290	devc->limit_samples = g_variant_get_uint64(data);
	291	sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
	292	devc->limit_samples);
	293	ret = SR_OK;
	294	} else if (id == SR_CONF_LIMIT_MSEC) {
	295	devc->limit_msec = g_variant_get_uint64(data);
	296	devc->limit_samples = 0;
	297	sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
	298	devc->limit_msec);
	299	ret = SR_OK;
	300	} else if (id == SR_CONF_PATTERN_MODE) {
	301	stropt = g_variant_get_string(data, NULL);
	302	ret = SR_OK;
	303	if (!strcmp(stropt, STR_PATTERN_SIGROK)) {
	304	devc->sample_generator = PATTERN_SIGROK;
	305	} else if (!strcmp(stropt, STR_PATTERN_RANDOM)) {
	306	devc->sample_generator = PATTERN_RANDOM;
	307	} else if (!strcmp(stropt, STR_PATTERN_INC)) {
	308	devc->sample_generator = PATTERN_INC;
	309	} else if (!strcmp(stropt, STR_PATTERN_ALL_LOW)) {
	310	devc->sample_generator = PATTERN_ALL_LOW;
	311	} else if (!strcmp(stropt, STR_PATTERN_ALL_HIGH)) {
	312	devc->sample_generator = PATTERN_ALL_HIGH;
	313	} else {
	314	ret = SR_ERR;
	315	}
	316	sr_dbg("%s: setting pattern to %d",
	317	__func__, devc->sample_generator);
	318	} else {
	319	ret = SR_ERR;
	320	}
	321
	322	return ret;
	323	}
	324
	325	static int config_list(int key, GVariant *data, const struct sr_dev_inst sdi)
	326	{
	327	GVariant *gvar;
	328	GVariantBuilder gvb;
	329
	330	(void)sdi;
	331
	332	switch (key) {
	333	case SR_CONF_DEVICE_OPTIONS:
	334	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
	335	hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
	336	break;
	337	case SR_CONF_SAMPLERATE:
	338	g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
	339	gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
	340	ARRAY_SIZE(samplerates), sizeof(uint64_t));
	341	g_variant_builder_add(&gvb, "{sv}", "samplerate-steps", gvar);
	342	*data = g_variant_builder_end(&gvb);
	343	break;
	344	case SR_CONF_PATTERN_MODE:
	345	*data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
	346	break;
	347	default:
	348	return SR_ERR_ARG;
	349	}
	350
	351	return SR_OK;
	352	}
	353
	354	static void samples_generator(uint8_t *buf, uint64_t size,
	355	struct dev_context *devc)
	356	{
	357	static uint64_t p = 0;
	358	uint64_t i;
	359
	360	/* TODO: Needed? */
	361	memset(buf, 0, size);
	362
	363	switch (devc->sample_generator) {
	364	case PATTERN_SIGROK: /* sigrok pattern */
	365	for (i = 0; i < size; i++) {
	366	*(buf + i) = ~(pattern_sigrok[
	367	p++ % sizeof(pattern_sigrok)] >> 1);
	368	}
	369	break;
	370	case PATTERN_RANDOM: /* Random */
	371	for (i = 0; i < size; i++)
	372	*(buf + i) = (uint8_t)(rand() & 0xff);
	373	break;
	374	case PATTERN_INC: /* Simple increment */
	375	for (i = 0; i < size; i++)
	376	*(buf + i) = p++;
	377	break;
	378	case PATTERN_ALL_LOW: /* All probes are low */
	379	memset(buf, 0x00, size);
	380	break;
	381	case PATTERN_ALL_HIGH: /* All probes are high */
	382	memset(buf, 0xff, size);
	383	break;
	384	default:
	385	sr_err("Unknown pattern: %d.", devc->sample_generator);
	386	break;
	387	}
	388	}
	389
	390	/* Callback handling data */
	391	static int receive_data(int fd, int revents, void *cb_data)
	392	{
	393	struct dev_context *devc = cb_data;
	394	struct sr_datafeed_packet packet;
	395	struct sr_datafeed_logic logic;
	396	uint8_t buf[BUFSIZE];
	397	static uint64_t samples_to_send, expected_samplenum, sending_now;
	398	int64_t time, elapsed;
	399
	400	(void)fd;
	401	(void)revents;
	402
	403	/* How many "virtual" samples should we have collected by now? */
	404	time = g_get_monotonic_time();
	405	elapsed = time - devc->starttime;
	406	expected_samplenum = elapsed * devc->cur_samplerate / 1000000;
	407	/* Of those, how many do we still have to send? */
	408	samples_to_send = expected_samplenum - devc->samples_counter;
	409
	410	if (devc->limit_samples) {
	411	samples_to_send = MIN(samples_to_send,
	412	devc->limit_samples - devc->samples_counter);
	413	}
	414
	415	while (samples_to_send > 0) {
	416	sending_now = MIN(samples_to_send, sizeof(buf));
	417	samples_to_send -= sending_now;
	418	samples_generator(buf, sending_now, devc);
	419
	420	packet.type = SR_DF_LOGIC;
	421	packet.payload = &logic;
	422	logic.length = sending_now;
	423	logic.unitsize = 1;
	424	logic.data = buf;
	425	sr_session_send(devc->cb_data, &packet);
	426	devc->samples_counter += sending_now;
	427	}
	428
	429	if (devc->limit_samples &&
	430	devc->samples_counter >= devc->limit_samples) {
	431	sr_info("Requested number of samples reached.");
	432	hw_dev_acquisition_stop(devc->sdi, cb_data);
	433	return TRUE;
	434	}
	435
	436	return TRUE;
	437	}
	438
	439	static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
	440	void *cb_data)
	441	{
	442	struct dev_context *const devc = sdi->priv;
	443
	444	devc->cb_data = cb_data;
	445	devc->samples_counter = 0;
	446
	447	/*
	448	* Setting two channels connected by a pipe is a remnant from when the
	449	* demo driver generated data in a thread, and collected and sent the
	450	* data in the main program loop.
	451	* They are kept here because it provides a convenient way of setting
	452	* up a timeout-based polling mechanism.
	453	*/
	454	if (pipe(devc->pipe_fds)) {
	455	/* TODO: Better error message. */
	456	sr_err("%s: pipe() failed", __func__);
	457	return SR_ERR;
	458	}
	459
	460	devc->channel = g_io_channel_unix_new(devc->pipe_fds[0]);
	461
	462	g_io_channel_set_flags(devc->channel, G_IO_FLAG_NONBLOCK, NULL);
	463
	464	/* Set channel encoding to binary (default is UTF-8). */
	465	g_io_channel_set_encoding(devc->channel, NULL, NULL);
	466
	467	/* Make channels to unbuffered. */
	468	g_io_channel_set_buffered(devc->channel, FALSE);
	469
	470	sr_session_source_add_channel(devc->channel, G_IO_IN \| G_IO_ERR,
	471	40, receive_data, devc);
	472
	473	/* Send header packet to the session bus. */
	474	std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
	475
	476	/* We use this timestamp to decide how many more samples to send. */
	477	devc->starttime = g_get_monotonic_time();
	478
	479	return SR_OK;
	480	}
	481
	482	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
	483	{
	484	struct dev_context *const devc = sdi->priv;
	485	struct sr_datafeed_packet packet;
	486
	487	(void)cb_data;
	488
	489	sr_dbg("Stopping aquisition.");
	490
	491	sr_session_source_remove_channel(devc->channel);
	492	g_io_channel_shutdown(devc->channel, FALSE, NULL);
	493
	494	/* Send last packet. */
	495	packet.type = SR_DF_END;
	496	sr_session_send(devc->cb_data, &packet);
	497
	498	return SR_OK;
	499	}
	500
	501	SR_PRIV struct sr_dev_driver demo_driver_info = {
	502	.name = "demo",
	503	.longname = "Demo driver and pattern generator",
	504	.api_version = 1,
	505	.init = hw_init,
	506	.cleanup = hw_cleanup,
	507	.scan = hw_scan,
	508	.dev_list = hw_dev_list,
	509	.dev_clear = clear_instances,
	510	.config_get = config_get,
	511	.config_set = config_set,
	512	.config_list = config_list,
	513	.dev_open = hw_dev_open,
	514	.dev_close = hw_dev_close,
	515	.dev_acquisition_start = hw_dev_acquisition_start,
	516	.dev_acquisition_stop = hw_dev_acquisition_stop,
	517	.priv = NULL,
	518	};