[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 *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 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->cb_data, &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->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->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->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
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;
3e9b7f9c	82	void *cb_data;
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)
811deee4 BV	189	{
0e94d524	190	return ((struct drv_context *)(di->priv))->instances;
811deee4 BV	191	}
811deee4 BV	192
25a0f108	193	static int hw_dev_open(struct sr_dev_inst *sdi)
6239c175	194	{
25a0f108	195	(void)sdi;
6239c175 UH	196
6239c175 UH	197	/* Nothing needed so far. */
697785d1	198
e46b8fb1	199	return SR_OK;
6239c175 UH	200	}
6239c175 UH	201
25a0f108	202	static int hw_dev_close(struct sr_dev_inst *sdi)
6239c175	203	{
25a0f108	204	(void)sdi;
6239c175 UH	205
6239c175 UH	206	/* Nothing needed so far. */
697785d1 UH	207
697785d1 UH	208	return SR_OK;
6239c175 UH	209	}
6239c175 UH	210
57ab7d9f	211	static int hw_cleanup(void)
6239c175 UH	212	{
6239c175 UH	213	/* Nothing needed so far. */
57ab7d9f	214	return SR_OK;
6239c175 UH	215	}
6239c175 UH	216
035a1078	217	static int config_get(int id, const void *data, const struct sr_dev_inst sdi)
6239c175	218	{
6f57fd96 BV	219	(void)sdi;
6f57fd96 BV	220
035a1078	221	switch (id) {
123e1313	222	case SR_CONF_SAMPLERATE:
dfb0fa1a	223	*data = &cur_samplerate;
6239c175	224	break;
7dfcf010 BV	225	default:
7dfcf010 BV	226	return SR_ERR_ARG;
6239c175 UH	227	}
6239c175 UH	228
dfb0fa1a	229	return SR_OK;
6239c175 UH	230	}
6239c175 UH	231
035a1078	232	static int config_set(int id, const void value, const struct sr_dev_inst sdi)
6239c175 UH	233	{
6239c175 UH	234	int ret;
1b79df2f	235	const char *stropt;
6239c175	236
6f4b1868	237	(void)sdi;
6239c175	238
035a1078	239	if (id == SR_CONF_SAMPLERATE) {
1b79df2f	240	cur_samplerate = (const uint64_t )value;
92bcedf6	241	sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
6f422264	242	cur_samplerate);
e46b8fb1	243	ret = SR_OK;
035a1078	244	} else if (id == SR_CONF_LIMIT_SAMPLES) {
8489264f	245	limit_msec = 0;
1b79df2f	246	limit_samples = (const uint64_t )value;
92bcedf6	247	sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
6f422264	248	limit_samples);
e46b8fb1	249	ret = SR_OK;
035a1078	250	} else if (id == SR_CONF_LIMIT_MSEC) {
1b79df2f	251	limit_msec = (const uint64_t )value;
8489264f	252	limit_samples = 0;
92bcedf6	253	sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
6f422264	254	limit_msec);
e46b8fb1	255	ret = SR_OK;
035a1078	256	} else if (id == SR_CONF_PATTERN_MODE) {
e15f48c2	257	stropt = value;
c03ed397 UH	258	ret = SR_OK;
	259	if (!strcmp(stropt, "sigrok")) {
	260	default_pattern = PATTERN_SIGROK;
	261	} else if (!strcmp(stropt, "random")) {
c8f4624d	262	default_pattern = PATTERN_RANDOM;
e15f48c2	263	} else if (!strcmp(stropt, "incremental")) {
c8f4624d	264	default_pattern = PATTERN_INC;
c03ed397 UH	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;
e15f48c2	269	} else {
e46b8fb1	270	ret = SR_ERR;
e15f48c2	271	}
92bcedf6	272	sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
6239c175	273	} else {
e46b8fb1	274	ret = SR_ERR;
6239c175 UH	275	}
	276
	277	return ret;
	278	}
	279
a1c743fc BV	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) {
9a6517d1 BV	286	case SR_CONF_DEVICE_OPTIONS:
	287	*data = hwcaps;
	288	break;
a1c743fc BV	289	case SR_CONF_SAMPLERATE:
	290	*data = &samplerates;
	291	break;
dd96ea98 BV	292	case SR_CONF_PATTERN_MODE:
	293	*data = &pattern_strings;
	294	break;
a1c743fc BV	295	default:
	296	return SR_ERR_ARG;
	297	}
	298
	299	return SR_OK;
	300	}
	301
3b203673 AG	302	static void samples_generator(uint8_t *buf, uint64_t size,
3b203673 AG	303	struct dev_context *devc)
85b5af06	304	{
cddd1c5f	305	static uint64_t p = 0;
cddd1c5f	306	uint64_t i;
85b5af06	307
c03ed397	308	/* TODO: Needed? */
5096c6a6	309	memset(buf, 0, size);
85b5af06	310
b4750a3a	311	switch (devc->sample_generator) {
c03ed397	312	case PATTERN_SIGROK: /* sigrok pattern */
917e0e71	313	for (i = 0; i < size; i++) {
c8f4624d	314	*(buf + i) = ~(pattern_sigrok[p] >> 1);
917e0e71 BV	315	if (++p == 64)
	316	p = 0;
	317	}
	318	break;
c8f4624d	319	case PATTERN_RANDOM: /* Random */
5096c6a6 UH	320	for (i = 0; i < size; i++)
5096c6a6 UH	321	*(buf + i) = (uint8_t)(rand() & 0xff);
85b5af06	322	break;
c8f4624d	323	case PATTERN_INC: /* Simple increment */
5096c6a6	324	for (i = 0; i < size; i++)
85b5af06 UH	325	*(buf + i) = i;
85b5af06 UH	326	break;
c03ed397	327	case PATTERN_ALL_LOW: /* All probes are low */
5a9660dd	328	memset(buf, 0x00, size);
c03ed397 UH	329	break;
c03ed397 UH	330	case PATTERN_ALL_HIGH: /* All probes are high */
5a9660dd	331	memset(buf, 0xff, size);
c03ed397 UH	332	break;
c03ed397 UH	333	default:
92bcedf6	334	sr_err("Unknown pattern: %d.", devc->sample_generator);
c03ed397	335	break;
85b5af06 UH	336	}
	337	}
	338
85b5af06	339	/* Callback handling data */
1f9813eb	340	static int receive_data(int fd, int revents, void *cb_data)
85b5af06	341	{
b4750a3a	342	struct dev_context *devc = cb_data;
b9c735a2	343	struct sr_datafeed_packet packet;
9c939c51	344	struct sr_datafeed_logic logic;
3b203673 AG	345	uint8_t buf[BUFSIZE];
	346	static uint64_t samples_to_send, expected_samplenum, sending_now;
	347	int64_t time, elapsed;
1924f59f	348
cb93f8a9 UH	349	(void)fd;
cb93f8a9 UH	350	(void)revents;
1924f59f	351
3b203673 AG	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	}
85b5af06	363
3b203673 AG	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;
3e9b7f9c	374	sr_session_send(devc->cb_data, &packet);
3b203673 AG	375	devc->samples_counter += sending_now;
	376	}
	377
35e199da UH	378	if (limit_samples && devc->samples_counter >= limit_samples) {
35e199da UH	379	sr_info("Requested number of samples reached.");
c216d623 AG	380	hw_dev_acquisition_stop(NULL, cb_data);
c216d623 AG	381	return TRUE;
85b5af06	382	}
1924f59f	383
85b5af06 UH	384	return TRUE;
	385	}
	386
3ffb6964 BV	387	static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
3ffb6964 BV	388	void *cb_data)
6239c175	389	{
b4750a3a	390	struct dev_context *devc;
6239c175	391
3ffb6964 BV	392	(void)sdi;
3ffb6964 BV	393
b4750a3a BV	394	/* TODO: 'devc' is never g_free()'d? */
b4750a3a BV	395	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
92bcedf6	396	sr_err("%s: devc malloc failed", __func__);
e46b8fb1	397	return SR_ERR_MALLOC;
27a3a6fe	398	}
85b5af06	399
b4750a3a	400	devc->sample_generator = default_pattern;
3e9b7f9c	401	devc->cb_data = cb_data;
b4750a3a	402	devc->samples_counter = 0;
85b5af06	403
3b203673 AG	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	*/
b4750a3a	411	if (pipe(devc->pipe_fds)) {
c03ed397	412	/* TODO: Better error message. */
92bcedf6	413	sr_err("%s: pipe() failed", __func__);
e46b8fb1	414	return SR_ERR;
c03ed397	415	}
85b5af06	416
b4750a3a BV	417	devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
b4750a3a BV	418	devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
d35aaf02	419
b4750a3a	420	g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
e6e8f8e0	421
d35aaf02	422	/* Set channel encoding to binary (default is UTF-8). */
b4750a3a BV	423	g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
b4750a3a BV	424	g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
d35aaf02 UH	425
d35aaf02 UH	426	/* Make channels to unbuffered. */
b4750a3a BV	427	g_io_channel_set_buffered(devc->channels[0], FALSE);
b4750a3a BV	428	g_io_channel_set_buffered(devc->channels[1], FALSE);
d35aaf02	429
b4750a3a BV	430	sr_session_source_add_channel(devc->channels[0], G_IO_IN \| G_IO_ERR,
b4750a3a BV	431	40, receive_data, devc);
85b5af06	432
4afdfd46 UH	433	/* Send header packet to the session bus. */
4afdfd46 UH	434	std_session_send_df_header(cb_data, DRIVER_LOG_DOMAIN);
f366e86c	435
3b203673 AG	436	/* We use this timestamp to decide how many more samples to send. */
	437	devc->starttime = g_get_monotonic_time();
	438
e46b8fb1	439	return SR_OK;
6239c175 UH	440	}
6239c175 UH	441
69b07d14	442	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
6239c175	443	{
7fd3e859	444	struct dev_context *devc;
c216d623	445	struct sr_datafeed_packet packet;
7fd3e859	446
c216d623	447	(void)sdi;
6239c175	448
c216d623	449	devc = cb_data;
7fd3e859	450
49145a63 AG	451	sr_dbg("Stopping aquisition.");
49145a63 AG	452
7fd3e859	453	sr_session_source_remove_channel(devc->channels[0]);
c216d623 AG	454	g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
	455
	456	/* Send last packet. */
	457	packet.type = SR_DF_END;
3e9b7f9c	458	sr_session_send(devc->cb_data, &packet);
7fd3e859	459
3010f21c	460	return SR_OK;
6239c175 UH	461	}
6239c175 UH	462
c09f0b57	463	SR_PRIV struct sr_dev_driver demo_driver_info = {
e519ba86 UH	464	.name = "demo",
	465	.longname = "Demo driver and pattern generator",
	466	.api_version = 1,
	467	.init = hw_init,
	468	.cleanup = hw_cleanup,
61136ea6	469	.scan = hw_scan,
811deee4	470	.dev_list = hw_dev_list,
eebb6067	471	.dev_clear = clear_instances,
035a1078 BV	472	.config_get = config_get,
035a1078 BV	473	.config_set = config_set,
a1c743fc	474	.config_list = config_list,
e7eb703f UH	475	.dev_open = hw_dev_open,
e7eb703f UH	476	.dev_close = hw_dev_close,
69040b7c UH	477	.dev_acquisition_start = hw_dev_acquisition_start,
69040b7c UH	478	.dev_acquisition_stop = hw_dev_acquisition_stop,
b4750a3a	479	.priv = NULL,
6239c175	480	};