[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 *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 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 (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 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
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[] = {
5a2326a7	87	SR_HWCAP_LOGIC_ANALYZER,
bb7ef793	88	SR_HWCAP_DEMO_DEV,
4bfbf9fc	89	SR_HWCAP_SAMPLERATE,
5a2326a7 UH	90	SR_HWCAP_PATTERN_MODE,
	91	SR_HWCAP_LIMIT_SAMPLES,
	92	SR_HWCAP_LIMIT_MSEC,
	93	SR_HWCAP_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
dfb0fa1a BV	229	static int hw_info_get(int info_id, const void **data,
dfb0fa1a BV	230	const struct sr_dev_inst *sdi)
6239c175	231	{
6f57fd96 BV	232	(void)sdi;
6f57fd96 BV	233
dfb0fa1a	234	switch (info_id) {
46c7a4da BV	235	case SR_DI_HWCAPS:
	236	*data = hwcaps;
	237	break;
5a2326a7	238	case SR_DI_NUM_PROBES:
dfb0fa1a	239	*data = GINT_TO_POINTER(NUM_PROBES);
6239c175	240	break;
464d12c7	241	case SR_DI_PROBE_NAMES:
dfb0fa1a	242	*data = probe_names;
464d12c7	243	break;
4bfbf9fc	244	case SR_DI_SAMPLERATES:
dfb0fa1a	245	*data = &samplerates;
4bfbf9fc	246	break;
5a2326a7	247	case SR_DI_CUR_SAMPLERATE:
dfb0fa1a	248	*data = &cur_samplerate;
6239c175	249	break;
eb0a3731	250	case SR_DI_PATTERNS:
dfb0fa1a	251	*data = &pattern_strings;
e15f48c2	252	break;
7dfcf010 BV	253	default:
7dfcf010 BV	254	return SR_ERR_ARG;
6239c175 UH	255	}
6239c175 UH	256
dfb0fa1a	257	return SR_OK;
6239c175 UH	258	}
6239c175 UH	259
6f4b1868 BV	260	static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
6f4b1868 BV	261	const void *value)
6239c175 UH	262	{
6239c175 UH	263	int ret;
1b79df2f	264	const char *stropt;
6239c175	265
6f4b1868	266	(void)sdi;
6239c175	267
014359e3	268	if (hwcap == SR_HWCAP_SAMPLERATE) {
1b79df2f	269	cur_samplerate = (const uint64_t )value;
92bcedf6	270	sr_dbg("%s: setting samplerate to %" PRIu64, __func__,
6f422264	271	cur_samplerate);
e46b8fb1	272	ret = SR_OK;
ffedd0bf	273	} else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
8489264f	274	limit_msec = 0;
1b79df2f	275	limit_samples = (const uint64_t )value;
92bcedf6	276	sr_dbg("%s: setting limit_samples to %" PRIu64, __func__,
6f422264	277	limit_samples);
e46b8fb1	278	ret = SR_OK;
ffedd0bf	279	} else if (hwcap == SR_HWCAP_LIMIT_MSEC) {
1b79df2f	280	limit_msec = (const uint64_t )value;
8489264f	281	limit_samples = 0;
92bcedf6	282	sr_dbg("%s: setting limit_msec to %" PRIu64, __func__,
6f422264	283	limit_msec);
e46b8fb1	284	ret = SR_OK;
ffedd0bf	285	} else if (hwcap == SR_HWCAP_PATTERN_MODE) {
e15f48c2	286	stropt = value;
c03ed397 UH	287	ret = SR_OK;
	288	if (!strcmp(stropt, "sigrok")) {
	289	default_pattern = PATTERN_SIGROK;
	290	} else if (!strcmp(stropt, "random")) {
c8f4624d	291	default_pattern = PATTERN_RANDOM;
e15f48c2	292	} else if (!strcmp(stropt, "incremental")) {
c8f4624d	293	default_pattern = PATTERN_INC;
c03ed397 UH	294	} else if (!strcmp(stropt, "all-low")) {
	295	default_pattern = PATTERN_ALL_LOW;
	296	} else if (!strcmp(stropt, "all-high")) {
	297	default_pattern = PATTERN_ALL_HIGH;
e15f48c2	298	} else {
e46b8fb1	299	ret = SR_ERR;
e15f48c2	300	}
92bcedf6	301	sr_dbg("%s: setting pattern to %d", __func__, default_pattern);
6239c175	302	} else {
e46b8fb1	303	ret = SR_ERR;
6239c175 UH	304	}
	305
	306	return ret;
	307	}
	308
3b203673 AG	309	static void samples_generator(uint8_t *buf, uint64_t size,
3b203673 AG	310	struct dev_context *devc)
85b5af06	311	{
cddd1c5f	312	static uint64_t p = 0;
cddd1c5f	313	uint64_t i;
85b5af06	314
c03ed397	315	/* TODO: Needed? */
5096c6a6	316	memset(buf, 0, size);
85b5af06	317
b4750a3a	318	switch (devc->sample_generator) {
c03ed397	319	case PATTERN_SIGROK: /* sigrok pattern */
917e0e71	320	for (i = 0; i < size; i++) {
c8f4624d	321	*(buf + i) = ~(pattern_sigrok[p] >> 1);
917e0e71 BV	322	if (++p == 64)
	323	p = 0;
	324	}
	325	break;
c8f4624d	326	case PATTERN_RANDOM: /* Random */
5096c6a6 UH	327	for (i = 0; i < size; i++)
5096c6a6 UH	328	*(buf + i) = (uint8_t)(rand() & 0xff);
85b5af06	329	break;
c8f4624d	330	case PATTERN_INC: /* Simple increment */
5096c6a6	331	for (i = 0; i < size; i++)
85b5af06 UH	332	*(buf + i) = i;
85b5af06 UH	333	break;
c03ed397	334	case PATTERN_ALL_LOW: /* All probes are low */
5a9660dd	335	memset(buf, 0x00, size);
c03ed397 UH	336	break;
c03ed397 UH	337	case PATTERN_ALL_HIGH: /* All probes are high */
5a9660dd	338	memset(buf, 0xff, size);
c03ed397 UH	339	break;
c03ed397 UH	340	default:
92bcedf6	341	sr_err("Unknown pattern: %d.", devc->sample_generator);
c03ed397	342	break;
85b5af06 UH	343	}
	344	}
	345
85b5af06	346	/* Callback handling data */
1f9813eb	347	static int receive_data(int fd, int revents, void *cb_data)
85b5af06	348	{
b4750a3a	349	struct dev_context *devc = cb_data;
b9c735a2	350	struct sr_datafeed_packet packet;
9c939c51	351	struct sr_datafeed_logic logic;
3b203673 AG	352	uint8_t buf[BUFSIZE];
	353	static uint64_t samples_to_send, expected_samplenum, sending_now;
	354	int64_t time, elapsed;
1924f59f	355
cb93f8a9 UH	356	(void)fd;
cb93f8a9 UH	357	(void)revents;
1924f59f	358
3b203673 AG	359	/* How many "virtual" samples should we have collected by now? */
	360	time = g_get_monotonic_time();
	361	elapsed = time - devc->starttime;
	362	expected_samplenum = elapsed * cur_samplerate / 1000000;
	363	/* Of those, how many do we still have to send? */
	364	samples_to_send = expected_samplenum - devc->samples_counter;
	365
	366	if (limit_samples) {
	367	samples_to_send = MIN(samples_to_send,
	368	limit_samples - devc->samples_counter);
	369	}
85b5af06	370
3b203673 AG	371	while (samples_to_send > 0) {
	372	sending_now = MIN(samples_to_send, sizeof(buf));
	373	samples_to_send -= sending_now;
	374	samples_generator(buf, sending_now, devc);
	375
	376	packet.type = SR_DF_LOGIC;
	377	packet.payload = &logic;
	378	logic.length = sending_now;
	379	logic.unitsize = 1;
	380	logic.data = buf;
	381	sr_session_send(devc->session_dev_id, &packet);
	382	devc->samples_counter += sending_now;
	383	}
	384
35e199da UH	385	if (limit_samples && devc->samples_counter >= limit_samples) {
35e199da UH	386	sr_info("Requested number of samples reached.");
c216d623 AG	387	hw_dev_acquisition_stop(NULL, cb_data);
c216d623 AG	388	return TRUE;
85b5af06	389	}
1924f59f	390
85b5af06 UH	391	return TRUE;
	392	}
	393
3ffb6964 BV	394	static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
3ffb6964 BV	395	void *cb_data)
6239c175	396	{
b9c735a2 UH	397	struct sr_datafeed_packet *packet;
b9c735a2 UH	398	struct sr_datafeed_header *header;
f366e86c	399	struct sr_datafeed_meta_logic meta;
b4750a3a	400	struct dev_context *devc;
6239c175	401
3ffb6964 BV	402	(void)sdi;
3ffb6964 BV	403
49145a63 AG	404	sr_dbg("Starting acquisition.");
49145a63 AG	405
b4750a3a BV	406	/* TODO: 'devc' is never g_free()'d? */
b4750a3a BV	407	if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
92bcedf6	408	sr_err("%s: devc malloc failed", __func__);
e46b8fb1	409	return SR_ERR_MALLOC;
27a3a6fe	410	}
85b5af06	411
b4750a3a BV	412	devc->sample_generator = default_pattern;
	413	devc->session_dev_id = cb_data;
	414	devc->samples_counter = 0;
85b5af06	415
3b203673 AG	416	/*
	417	* Setting two channels connected by a pipe is a remnant from when the
	418	* demo driver generated data in a thread, and collected and sent the
	419	* data in the main program loop.
	420	* They are kept here because it provides a convenient way of setting
	421	* up a timeout-based polling mechanism.
	422	*/
b4750a3a	423	if (pipe(devc->pipe_fds)) {
c03ed397	424	/* TODO: Better error message. */
92bcedf6	425	sr_err("%s: pipe() failed", __func__);
e46b8fb1	426	return SR_ERR;
c03ed397	427	}
85b5af06	428
b4750a3a BV	429	devc->channels[0] = g_io_channel_unix_new(devc->pipe_fds[0]);
b4750a3a BV	430	devc->channels[1] = g_io_channel_unix_new(devc->pipe_fds[1]);
d35aaf02	431
b4750a3a	432	g_io_channel_set_flags(devc->channels[0], G_IO_FLAG_NONBLOCK, NULL);
e6e8f8e0	433
d35aaf02	434	/* Set channel encoding to binary (default is UTF-8). */
b4750a3a BV	435	g_io_channel_set_encoding(devc->channels[0], NULL, NULL);
b4750a3a BV	436	g_io_channel_set_encoding(devc->channels[1], NULL, NULL);
d35aaf02 UH	437
d35aaf02 UH	438	/* Make channels to unbuffered. */
b4750a3a BV	439	g_io_channel_set_buffered(devc->channels[0], FALSE);
b4750a3a BV	440	g_io_channel_set_buffered(devc->channels[1], FALSE);
d35aaf02	441
b4750a3a BV	442	sr_session_source_add_channel(devc->channels[0], G_IO_IN \| G_IO_ERR,
b4750a3a BV	443	40, receive_data, devc);
85b5af06	444
27a3a6fe	445	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
92bcedf6	446	sr_err("%s: packet malloc failed", __func__);
e46b8fb1	447	return SR_ERR_MALLOC;
27a3a6fe UH	448	}
	449
	450	if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
92bcedf6	451	sr_err("%s: header malloc failed", __func__);
27a3a6fe UH	452	return SR_ERR_MALLOC;
27a3a6fe UH	453	}
6239c175	454
5a2326a7	455	packet->type = SR_DF_HEADER;
9c939c51	456	packet->payload = header;
6239c175 UH	457	header->feed_version = 1;
6239c175 UH	458	gettimeofday(&header->starttime, NULL);
b4750a3a	459	sr_session_send(devc->session_dev_id, packet);
f366e86c BV	460
	461	/* Send metadata about the SR_DF_LOGIC packets to come. */
	462	packet->type = SR_DF_META_LOGIC;
	463	packet->payload = &meta;
	464	meta.samplerate = cur_samplerate;
	465	meta.num_probes = NUM_PROBES;
b4750a3a	466	sr_session_send(devc->session_dev_id, packet);
f366e86c	467
3b203673 AG	468	/* We use this timestamp to decide how many more samples to send. */
	469	devc->starttime = g_get_monotonic_time();
	470
27a3a6fe UH	471	g_free(header);
27a3a6fe UH	472	g_free(packet);
6239c175	473
e46b8fb1	474	return SR_OK;
6239c175 UH	475	}
6239c175 UH	476
69b07d14	477	static int hw_dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
6239c175	478	{
7fd3e859	479	struct dev_context *devc;
c216d623	480	struct sr_datafeed_packet packet;
7fd3e859	481
c216d623	482	(void)sdi;
6239c175	483
c216d623	484	devc = cb_data;
7fd3e859	485
49145a63 AG	486	sr_dbg("Stopping aquisition.");
49145a63 AG	487
7fd3e859	488	sr_session_source_remove_channel(devc->channels[0]);
c216d623 AG	489	g_io_channel_shutdown(devc->channels[0], FALSE, NULL);
	490
	491	/* Send last packet. */
	492	packet.type = SR_DF_END;
	493	sr_session_send(devc->session_dev_id, &packet);
7fd3e859	494
3010f21c	495	return SR_OK;
6239c175 UH	496	}
6239c175 UH	497
c09f0b57	498	SR_PRIV struct sr_dev_driver demo_driver_info = {
e519ba86 UH	499	.name = "demo",
	500	.longname = "Demo driver and pattern generator",
	501	.api_version = 1,
	502	.init = hw_init,
	503	.cleanup = hw_cleanup,
61136ea6	504	.scan = hw_scan,
811deee4	505	.dev_list = hw_dev_list,
eebb6067	506	.dev_clear = clear_instances,
e7eb703f UH	507	.dev_open = hw_dev_open,
e7eb703f UH	508	.dev_close = hw_dev_close,
dfb0fa1a	509	.info_get = hw_info_get,
a9a245b4	510	.dev_config_set = hw_dev_config_set,
69040b7c UH	511	.dev_acquisition_start = hw_dev_acquisition_start,
69040b7c UH	512	.dev_acquisition_stop = hw_dev_acquisition_stop,
b4750a3a	513	.priv = NULL,
6239c175	514	};