[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)
{
	struct drv_context *drvc;

	drvc = di->priv;

	return drvc->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 sr_datafeed_packet *packet;
	struct sr_datafeed_header *header;
	struct dev_context *devc;

	(void)sdi;

	sr_dbg("Starting acquisition.");

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

	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
		sr_err("%s: packet malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
		sr_err("%s: header malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	packet->type = SR_DF_HEADER;
	packet->payload = header;
	header->feed_version = 1;
	gettimeofday(&header->starttime, NULL);
	sr_session_send(devc->session_dev_id, packet);

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

	g_free(header);
	g_free(packet);

	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
6239c175 UH	1	/*
	2	* This file is part of the sigrok project.
	3	*
	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
92bcedf6 UH	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
c03ed397	43	/* TODO: Number of probes should be configurable. */
e15f48c2	44	#define NUM_PROBES 8
c03ed397	45
e15f48c2	46	#define DEMONAME "Demo device"
c03ed397 UH	47
	48	/* The size of chunks to send through the session bus. */
	49	/* TODO: Should be configurable. */
e15f48c2	50	#define BUFSIZE 4096
85b5af06	51
0d31276b	52	/* Supported patterns which we can generate */
e15f48c2	53	enum {
0d31276b UH	54	/**
	55	* Pattern which spells "sigrok" using '0's (with '1's as "background")
	56	* when displayed using the 'bits' output format.
	57	*/
c8f4624d	58	PATTERN_SIGROK,
0d31276b	59
c03ed397	60	/** Pattern which consists of (pseudo-)random values on all probes. */
c8f4624d	61	PATTERN_RANDOM,
0d31276b UH	62
	63	/**
	64	* Pattern which consists of incrementing numbers.
	65	* TODO: Better description.
	66	*/
c8f4624d	67	PATTERN_INC,
c03ed397 UH	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,
e15f48c2	74	};
85b5af06	75
b4750a3a BV	76	/* Private, per-device-instance driver context. */
b4750a3a BV	77	struct dev_context {
e15f48c2	78	int pipe_fds[2];
249ae2be	79	GIOChannel *channels[2];
e15f48c2	80	uint8_t sample_generator;
e15f48c2	81	uint64_t samples_counter;
3cd3a20b	82	void *session_dev_id;
3b203673	83	int64_t starttime;
e15f48c2	84	};
85b5af06	85
915f7cc8	86	static const int hwcaps[] = {
1953564a BV	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,
6239c175 UH	94	};
6239c175 UH	95
a533743d	96	static const struct sr_samplerates samplerates = {
d3b38ad3 UH	97	.low = SR_HZ(1),
	98	.high = SR_GHZ(1),
	99	.step = SR_HZ(1),
	100	.list = NULL,
4bfbf9fc BV	101	};
4bfbf9fc BV	102
c8f4624d	103	static const char *pattern_strings[] = {
c03ed397	104	"sigrok",
e15f48c2 BV	105	"random",
e15f48c2 BV	106	"incremental",
c03ed397 UH	107	"all-low",
c03ed397 UH	108	"all-high",
02440dd8	109	NULL,
85b5af06 UH	110	};
85b5af06 UH	111
d261dbbf	112	/* We name the probes 0-7 on our demo driver. */
464d12c7	113	static const char *probe_names[NUM_PROBES + 1] = {
78693401	114	"0", "1", "2", "3", "4", "5", "6", "7",
464d12c7 KS	115	NULL,
	116	};
	117
c8f4624d	118	static uint8_t pattern_sigrok[] = {
917e0e71 BV	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
ea9cfed7 UH	129	/* Private, per-device-instance driver context. */
	130	/* TODO: struct context as with the other drivers. */
	131
e7eb703f	132	/* List of struct sr_dev_inst, maintained by dev_open()/dev_close(). */
dcf03d6d	133	SR_PRIV struct sr_dev_driver demo_driver_info;
a873c594	134	static struct sr_dev_driver *di = &demo_driver_info;
59df0c77	135	static uint64_t cur_samplerate = SR_KHZ(200);
b9cc3629 BV	136	static uint64_t limit_samples = 0;
b9cc3629 BV	137	static uint64_t limit_msec = 0;
c8f4624d	138	static int default_pattern = PATTERN_SIGROK;
6239c175	139
69b07d14	140	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data);
6239c175	141
eebb6067 UH	142	static int clear_instances(void)
	143	{
	144	/* Nothing needed so far. */
	145
	146	return SR_OK;
	147	}
	148
34f06b90	149	static int hw_init(struct sr_context *sr_ctx)
61136ea6	150	{
063e7aef	151	return std_hw_init(sr_ctx, di, DRIVER_LOG_DOMAIN);
61136ea6 BV	152	}
61136ea6 BV	153
067d0716	154	static GSList hw_scan(GSList options)
6239c175	155	{
d68e2d1a	156	struct sr_dev_inst *sdi;
87ca93c5	157	struct sr_probe *probe;
b4750a3a	158	struct drv_context *drvc;
067d0716	159	GSList *devices;
87ca93c5	160	int i;
067d0716 BV	161
067d0716 BV	162	(void)options;
64d33dc2	163
a873c594	164	drvc = di->priv;
4b97c74e	165
067d0716	166	devices = NULL;
85b5af06	167
d3683c42	168	sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
c03ed397	169	if (!sdi) {
92bcedf6	170	sr_err("%s: sr_dev_inst_new failed", __func__);
85b5af06	171	return 0;
c03ed397	172	}
a873c594	173	sdi->driver = di;
e15f48c2	174
87ca93c5	175	for (i = 0; probe_names[i]; i++) {
de6e0eca	176	if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
87ca93c5 BV	177	probe_names[i])))
	178	return NULL;
	179	sdi->probes = g_slist_append(sdi->probes, probe);
	180	}
	181
067d0716	182	devices = g_slist_append(devices, sdi);
b4750a3a	183	drvc->instances = g_slist_append(drvc->instances, sdi);
85b5af06	184
067d0716	185	return devices;
6239c175 UH	186	}
6239c175 UH	187
811deee4 BV	188	static GSList *hw_dev_list(void)
	189	{
	190	struct drv_context *drvc;
	191
a873c594	192	drvc = di->priv;
811deee4 BV	193
	194	return drvc->instances;
	195	}
	196
25a0f108	197	static int hw_dev_open(struct sr_dev_inst *sdi)
6239c175	198	{
25a0f108	199	(void)sdi;
6239c175 UH	200
6239c175 UH	201	/* Nothing needed so far. */
697785d1	202
e46b8fb1	203	return SR_OK;
6239c175 UH	204	}
6239c175 UH	205
25a0f108	206	static int hw_dev_close(struct sr_dev_inst *sdi)
6239c175	207	{
25a0f108	208	(void)sdi;
6239c175 UH	209
6239c175 UH	210	/* Nothing needed so far. */
697785d1 UH	211
697785d1 UH	212	return SR_OK;
6239c175 UH	213	}
6239c175 UH	214
57ab7d9f	215	static int hw_cleanup(void)
6239c175 UH	216	{
6239c175 UH	217	/* Nothing needed so far. */
57ab7d9f	218	return SR_OK;
6239c175 UH	219	}
6239c175 UH	220
035a1078	221	static int config_get(int id, const void *data, const struct sr_dev_inst sdi)
6239c175	222	{
6f57fd96 BV	223	(void)sdi;
6f57fd96 BV	224
035a1078	225	switch (id) {
123e1313	226	case SR_CONF_SAMPLERATE:
dfb0fa1a	227	*data = &cur_samplerate;
6239c175	228	break;
7dfcf010 BV	229	default:
7dfcf010 BV	230	return SR_ERR_ARG;
6239c175 UH	231	}
6239c175 UH	232
dfb0fa1a	233	return SR_OK;
6239c175 UH	234	}
6239c175 UH	235
035a1078	236	static int config_set(int id, const void value, const struct sr_dev_inst sdi)
6239c175 UH	237	{
6239c175 UH	238	int ret;
1b79df2f	239	const char *stropt;
6239c175	240
6f4b1868	241	(void)sdi;
6239c175	242
035a1078	243	if (id == SR_CONF_SAMPLERATE) {
1b79df2f	244	cur_samplerate = (const uint64_t )value;
92bcedf6	245	sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
6f422264	246	cur_samplerate);
e46b8fb1	247	ret = SR_OK;
035a1078	248	} else if (id == SR_CONF_LIMIT_SAMPLES) {
8489264f	249	limit_msec = 0;
1b79df2f	250	limit_samples = (const uint64_t )value;
92bcedf6	251	sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
6f422264	252	limit_samples);
e46b8fb1	253	ret = SR_OK;
035a1078	254	} else if (id == SR_CONF_LIMIT_MSEC) {
1b79df2f	255	limit_msec = (const uint64_t )value;
8489264f	256	limit_samples = 0;
92bcedf6	257	sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
6f422264	258	limit_msec);
e46b8fb1	259	ret = SR_OK;
035a1078	260	} else if (id == SR_CONF_PATTERN_MODE) {
e15f48c2	261	stropt = value;
c03ed397 UH	262	ret = SR_OK;
	263	if (!strcmp(stropt, "sigrok")) {
	264	default_pattern = PATTERN_SIGROK;
	265	} else if (!strcmp(stropt, "random")) {
c8f4624d	266	default_pattern = PATTERN_RANDOM;
e15f48c2	267	} else if (!strcmp(stropt, "incremental")) {
c8f4624d	268	default_pattern = PATTERN_INC;
c03ed397 UH	269	} else if (!strcmp(stropt, "all-low")) {
	270	default_pattern = PATTERN_ALL_LOW;
	271	} else if (!strcmp(stropt, "all-high")) {
	272	default_pattern = PATTERN_ALL_HIGH;
e15f48c2	273	} else {
e46b8fb1	274	ret = SR_ERR;
e15f48c2	275	}
92bcedf6	276	sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
6239c175	277	} else {
e46b8fb1	278	ret = SR_ERR;
6239c175 UH	279	}
	280
	281	return ret;
	282	}
	283
a1c743fc BV	284	static int config_list(int key, const void *data, const struct sr_dev_inst sdi)
	285	{
	286
	287	(void)sdi;
	288
	289	switch (key) {
9a6517d1 BV	290	case SR_CONF_DEVICE_OPTIONS:
	291	*data = hwcaps;
	292	break;
a1c743fc BV	293	case SR_CONF_SAMPLERATE:
	294	*data = &samplerates;
	295	break;
dd96ea98 BV	296	case SR_CONF_PATTERN_MODE:
	297	*data = &pattern_strings;
	298	break;
a1c743fc BV	299	default:
	300	return SR_ERR_ARG;
	301	}
	302
	303	return SR_OK;
	304	}
	305
3b203673 AG	306	static void samples_generator(uint8_t *buf, uint64_t size,
3b203673 AG	307	struct dev_context *devc)
85b5af06	308	{
cddd1c5f	309	static uint64_t p = 0;
cddd1c5f	310	uint64_t i;
85b5af06	311
c03ed397	312	/* TODO: Needed? */
5096c6a6	313	memset(buf, 0, size);
85b5af06	314
b4750a3a	315	switch (devc->sample_generator) {
c03ed397	316	case PATTERN_SIGROK: /* sigrok pattern */
917e0e71	317	for (i = 0; i < size; i++) {
c8f4624d	318	*(buf + i) = ~(pattern_sigrok[p] >> 1);
917e0e71 BV	319	if (++p == 64)
	320	p = 0;
	321	}
	322	break;
c8f4624d	323	case PATTERN_RANDOM: /* Random */
5096c6a6 UH	324	for (i = 0; i < size; i++)
5096c6a6 UH	325	*(buf + i) = (uint8_t)(rand() & 0xff);
85b5af06	326	break;
c8f4624d	327	case PATTERN_INC: /* Simple increment */
5096c6a6	328	for (i = 0; i < size; i++)
85b5af06 UH	329	*(buf + i) = i;
85b5af06 UH	330	break;
c03ed397	331	case PATTERN_ALL_LOW: /* All probes are low */
5a9660dd	332	memset(buf, 0x00, size);
c03ed397 UH	333	break;
c03ed397 UH	334	case PATTERN_ALL_HIGH: /* All probes are high */
5a9660dd	335	memset(buf, 0xff, size);
c03ed397 UH	336	break;
c03ed397 UH	337	default:
92bcedf6	338	sr_err("Unknown pattern: %d.", devc->sample_generator);
c03ed397	339	break;
85b5af06 UH	340	}
	341	}
	342
85b5af06	343	/* Callback handling data */
1f9813eb	344	static int receive_data(int fd, int revents, void *cb_data)
85b5af06	345	{
b4750a3a	346	struct dev_context *devc = cb_data;
b9c735a2	347	struct sr_datafeed_packet packet;
9c939c51	348	struct sr_datafeed_logic logic;
3b203673 AG	349	uint8_t buf[BUFSIZE];
	350	static uint64_t samples_to_send, expected_samplenum, sending_now;
	351	int64_t time, elapsed;
1924f59f	352
cb93f8a9 UH	353	(void)fd;
cb93f8a9 UH	354	(void)revents;
1924f59f	355
3b203673 AG	356	/* How many "virtual" samples should we have collected by now? */
	357	time = g_get_monotonic_time();
	358	elapsed = time - devc->starttime;
	359	expected_samplenum = elapsed * cur_samplerate / 1000000;
	360	/* Of those, how many do we still have to send? */
	361	samples_to_send = expected_samplenum - devc->samples_counter;
	362
	363	if (limit_samples) {
	364	samples_to_send = MIN(samples_to_send,
	365	limit_samples - devc->samples_counter);
	366	}
85b5af06	367
3b203673 AG	368	while (samples_to_send > 0) {
	369	sending_now = MIN(samples_to_send, sizeof(buf));
	370	samples_to_send -= sending_now;
	371	samples_generator(buf, sending_now, devc);
	372
	373	packet.type = SR_DF_LOGIC;
	374	packet.payload = &logic;
	375	logic.length = sending_now;
	376	logic.unitsize = 1;
	377	logic.data = buf;
	378	sr_session_send(devc->session_dev_id, &packet);
	379	devc->samples_counter += sending_now;
	380	}
	381
35e199da UH	382	if (limit_samples && devc->samples_counter >= limit_samples) {
35e199da UH	383	sr_info("Requested number of samples reached.");
c216d623 AG	384	hw_dev_acquisition_stop(NULL, cb_data);
c216d623 AG	385	return TRUE;
85b5af06	386	}
1924f59f	387
85b5af06 UH	388	return TRUE;
	389	}
	390
3ffb6964 BV	391	static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
3ffb6964 BV	392	void *cb_data)
6239c175	393	{
b9c735a2 UH	394	struct sr_datafeed_packet *packet;
b9c735a2 UH	395	struct sr_datafeed_header *header;
b4750a3a	396	struct dev_context *devc;
6239c175	397
3ffb6964 BV	398	(void)sdi;
3ffb6964 BV	399
49145a63 AG	400	sr_dbg("Starting acquisition.");
49145a63 AG	401
b4750a3a BV	402	/* TODO: 'devc' is never g_free()'d? */
b4750a3a BV	403	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
92bcedf6	404	sr_err("%s: devc malloc failed", __func__);
e46b8fb1	405	return SR_ERR_MALLOC;
27a3a6fe	406	}
85b5af06	407
b4750a3a BV	408	devc->sample_generator = default_pattern;
	409	devc->session_dev_id = cb_data;
	410	devc->samples_counter = 0;
85b5af06	411
3b203673 AG	412	/*
	413	* Setting two channels connected by a pipe is a remnant from when the
	414	* demo driver generated data in a thread, and collected and sent the
	415	* data in the main program loop.
	416	* They are kept here because it provides a convenient way of setting
	417	* up a timeout-based polling mechanism.
	418	*/
b4750a3a	419	if (pipe(devc->pipe_fds)) {
c03ed397	420	/* TODO: Better error message. */
92bcedf6	421	sr_err("%s: pipe() failed", __func__);
e46b8fb1	422	return SR_ERR;
c03ed397	423	}
85b5af06	424
b4750a3a BV	425	devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
b4750a3a BV	426	devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
d35aaf02	427
b4750a3a	428	g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
e6e8f8e0	429
d35aaf02	430	/* Set channel encoding to binary (default is UTF-8). */
b4750a3a BV	431	g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
b4750a3a BV	432	g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
d35aaf02 UH	433
d35aaf02 UH	434	/* Make channels to unbuffered. */
b4750a3a BV	435	g_io_channel_set_buffered(devc->channels[0], FALSE);
b4750a3a BV	436	g_io_channel_set_buffered(devc->channels[1], FALSE);
d35aaf02	437
b4750a3a BV	438	sr_session_source_add_channel(devc->channels[0], G_IO_IN \| G_IO_ERR,
b4750a3a BV	439	40, receive_data, devc);
85b5af06	440
27a3a6fe	441	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
92bcedf6	442	sr_err("%s: packet malloc failed", __func__);
e46b8fb1	443	return SR_ERR_MALLOC;
27a3a6fe UH	444	}
	445
	446	if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
92bcedf6	447	sr_err("%s: header malloc failed", __func__);
27a3a6fe UH	448	return SR_ERR_MALLOC;
27a3a6fe UH	449	}
6239c175	450
5a2326a7	451	packet->type = SR_DF_HEADER;
9c939c51	452	packet->payload = header;
6239c175 UH	453	header->feed_version = 1;
6239c175 UH	454	gettimeofday(&header->starttime, NULL);
b4750a3a	455	sr_session_send(devc->session_dev_id, packet);
f366e86c	456
3b203673 AG	457	/* We use this timestamp to decide how many more samples to send. */
	458	devc->starttime = g_get_monotonic_time();
	459
27a3a6fe UH	460	g_free(header);
27a3a6fe UH	461	g_free(packet);
6239c175	462
e46b8fb1	463	return SR_OK;
6239c175 UH	464	}
6239c175 UH	465
69b07d14	466	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
6239c175	467	{
7fd3e859	468	struct dev_context *devc;
c216d623	469	struct sr_datafeed_packet packet;
7fd3e859	470
c216d623	471	(void)sdi;
6239c175	472
c216d623	473	devc = cb_data;
7fd3e859	474
49145a63 AG	475	sr_dbg("Stopping aquisition.");
49145a63 AG	476
7fd3e859	477	sr_session_source_remove_channel(devc->channels[0]);
c216d623 AG	478	g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
	479
	480	/* Send last packet. */
	481	packet.type = SR_DF_END;
	482	sr_session_send(devc->session_dev_id, &packet);
7fd3e859	483
3010f21c	484	return SR_OK;
6239c175 UH	485	}
6239c175 UH	486
c09f0b57	487	SR_PRIV struct sr_dev_driver demo_driver_info = {
e519ba86 UH	488	.name = "demo",
	489	.longname = "Demo driver and pattern generator",
	490	.api_version = 1,
	491	.init = hw_init,
	492	.cleanup = hw_cleanup,
61136ea6	493	.scan = hw_scan,
811deee4	494	.dev_list = hw_dev_list,
eebb6067	495	.dev_clear = clear_instances,
035a1078 BV	496	.config_get = config_get,
035a1078 BV	497	.config_set = config_set,
a1c743fc	498	.config_list = config_list,
e7eb703f UH	499	.dev_open = hw_dev_open,
e7eb703f UH	500	.dev_close = hw_dev_close,
69040b7c UH	501	.dev_acquisition_start = hw_dev_acquisition_start,
69040b7c UH	502	.dev_acquisition_stop = hw_dev_acquisition_stop,
b4750a3a	503	.priv = NULL,
6239c175	504	};