[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_HWCAP_LOGIC_ANALYZER,
	SR_HWCAP_DEMO_DEV,
	SR_HWCAP_SAMPLERATE,
	SR_HWCAP_PATTERN_MODE,
	SR_HWCAP_LIMIT_SAMPLES,
	SR_HWCAP_LIMIT_MSEC,
	SR_HWCAP_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 *ddi = &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;
	}
	ddi->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 = ddi->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 = ddi;

	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 = ddi->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 hw_info_get(int info_id, const void **data,
       const struct sr_dev_inst *sdi)
{
	(void)sdi;

	switch (info_id) {
	case SR_DI_HWCAPS:
		*data = hwcaps;
		break;
	case SR_DI_NUM_PROBES:
		*data = GINT_TO_POINTER(NUM_PROBES);
		break;
	case SR_DI_PROBE_NAMES:
		*data = probe_names;
		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 hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
		const void *value)
{
	int ret;
	const char *stropt;

	(void)sdi;

	if (hwcap == SR_HWCAP_SAMPLERATE) {
		cur_samplerate = *(const uint64_t *)value;
		sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
		       cur_samplerate);
		ret = SR_OK;
	} else if (hwcap == SR_HWCAP_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 (hwcap == SR_HWCAP_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 (hwcap == SR_HWCAP_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 (devc->samples_counter >= limit_samples) {
		sr_spew("We sent a total of %" PRIu64 " samples.",
			devc->samples_counter);
		/* Make sure we don't receive more packets. */
		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 sr_datafeed_meta_logic meta;
	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);

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