[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 = {
	SR_HZ(1),
	SR_GHZ(1),
	SR_HZ(1),
	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)
{
	struct drv_context *drvc;

	if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
		sr_err("Driver context malloc failed.");
		return SR_ERR_MALLOC;
	}
	drvc->sr_ctx = sr_ctx;
	di->priv = drvc;

	return SR_OK;
}

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