[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>
 *
 * 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 "config.h"
#include "sigrok.h"
#include "sigrok-internal.h"

/* 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,
};

/* FIXME: Should not be global. */
GIOChannel *channels[2];

struct databag {
	int pipe_fds[2];
	uint8_t sample_generator;
	uint8_t thread_running;
	uint64_t samples_counter;
	int device_index;
	gpointer session_data;
	GTimer *timer;
};

static int capabilities[] = {
	SR_HWCAP_LOGIC_ANALYZER,
	SR_HWCAP_SAMPLERATE,
	SR_HWCAP_PATTERN_MODE,
	SR_HWCAP_LIMIT_SAMPLES,
	SR_HWCAP_LIMIT_MSEC,
	SR_HWCAP_CONTINUOUS,
};

static 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,
};

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,
};

/* List of struct sr_device_instance, maintained by opendev()/closedev(). */
static GSList *device_instances = NULL;
static uint64_t cur_samplerate = SR_KHZ(200);
static uint64_t period_ps = 5000000;
static uint64_t limit_samples = 0;
static uint64_t limit_msec = 0;
static int default_pattern = PATTERN_SIGROK;
static GThread *my_thread;
static int thread_running;

static void hw_stop_acquisition(int device_index, gpointer session_data);

static int hw_init(const char *deviceinfo)
{
	struct sr_device_instance *sdi;

	/* Avoid compiler warnings. */
	(void)deviceinfo;

	sdi = sr_device_instance_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	if (!sdi) {
		sr_err("demo: %s: sr_device_instance_new failed", __func__);
		return 0;
	}

	device_instances = g_slist_append(device_instances, sdi);

	return 1;
}

static int hw_opendev(int device_index)
{
	/* Avoid compiler warnings. */
	(void)device_index;

	/* Nothing needed so far. */

	return SR_OK;
}

static int hw_closedev(int device_index)
{
	/* Avoid compiler warnings. */
	(void)device_index;

	/* Nothing needed so far. */

	return SR_OK;
}

static void hw_cleanup(void)
{
	/* Nothing needed so far. */
}

static void *hw_get_device_info(int device_index, int device_info_id)
{
	struct sr_device_instance *sdi;
	void *info = NULL;

	if (!(sdi = sr_get_device_instance(device_instances, device_index))) {
		sr_err("demo: %s: sdi was NULL", __func__);
		return NULL;
	}

	switch (device_info_id) {
	case SR_DI_INSTANCE:
		info = sdi;
		break;
	case SR_DI_NUM_PROBES:
		info = GINT_TO_POINTER(NUM_PROBES);
		break;
	case SR_DI_SAMPLERATES:
		info = &samplerates;
		break;
	case SR_DI_CUR_SAMPLERATE:
		info = &cur_samplerate;
		break;
	case SR_DI_PATTERNMODES:
		info = &pattern_strings;
		break;
	}

	return info;
}

static int hw_get_status(int device_index)
{
	/* Avoid compiler warnings. */
	(void)device_index;

	return SR_ST_ACTIVE;
}

static int *hw_get_capabilities(void)
{
	return capabilities;
}

static int hw_set_configuration(int device_index, int capability, void *value)
{
	int ret;
	char *stropt;

	/* Avoid compiler warnings. */
	(void)device_index;

	if (capability == SR_HWCAP_PROBECONFIG) {
		/* Nothing to do, but must be supported */
		ret = SR_OK;
	} else if (capability == SR_HWCAP_SAMPLERATE) {
		cur_samplerate = *(uint64_t *)value;
		period_ps = 1000000000000 / cur_samplerate;
		sr_dbg("demo: %s: setting samplerate to %" PRIu64, __func__,
		       cur_samplerate);
		ret = SR_OK;
	} else if (capability == SR_HWCAP_LIMIT_SAMPLES) {
		limit_samples = *(uint64_t *)value;
		sr_dbg("demo: %s: setting limit_samples to %" PRIu64, __func__,
		       limit_samples);
		ret = SR_OK;
	} else if (capability == SR_HWCAP_LIMIT_MSEC) {
		limit_msec = *(uint64_t *)value;
		sr_dbg("demo: %s: setting limit_msec to %" PRIu64, __func__,
		       limit_msec);
		ret = SR_OK;
	} else if (capability == 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("demo: %s: setting pattern to %d", __func__,
		       default_pattern);
	} else {
		ret = SR_ERR;
	}

	return ret;
}

static void samples_generator(uint8_t *buf, uint64_t size, void *data)
{
	static uint64_t p = 0;
	struct databag *mydata = data;
	uint64_t i;

	/* TODO: Needed? */
	memset(buf, 0, size);

	switch (mydata->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:
		/* TODO: Error handling. */
		break;
	}
}

/* Thread function */
static void thread_func(void *data)
{
	struct databag *mydata = data;
	uint8_t buf[BUFSIZE];
	uint64_t nb_to_send = 0;
	int bytes_written;
	double time_cur, time_last, time_diff;

	time_last = g_timer_elapsed(mydata->timer, NULL);

	while (thread_running) {
		/* Rate control */
		time_cur = g_timer_elapsed(mydata->timer, NULL);

		time_diff = time_cur - time_last;
		time_last = time_cur;

		nb_to_send = cur_samplerate * time_diff;

		if (limit_samples) {
			nb_to_send = MIN(nb_to_send,
				      limit_samples - mydata->samples_counter);
		}

		/* Make sure we don't overflow. */
		nb_to_send = MIN(nb_to_send, BUFSIZE);

		if (nb_to_send) {
			samples_generator(buf, nb_to_send, data);
			mydata->samples_counter += nb_to_send;

			g_io_channel_write_chars(channels[1], (gchar *)&buf,
				nb_to_send, (gsize *)&bytes_written, NULL);
		}

		/* Check if we're done. */
		if ((limit_msec && time_cur * 1000 > limit_msec) ||
		    (limit_samples && mydata->samples_counter >= limit_samples))
		{
			close(mydata->pipe_fds[1]);
			thread_running = 0;
		}

		g_usleep(10);
	}
}

/* Callback handling data */
static int receive_data(int fd, int revents, void *session_data)
{
	struct sr_datafeed_packet packet;
	struct sr_datafeed_logic logic;
	static uint64_t samples_received = 0;
	unsigned char c[BUFSIZE];
	gsize z;

	/* Avoid compiler warnings. */
	(void)fd;
	(void)revents;

	do {
		g_io_channel_read_chars(channels[0],
				        (gchar *)&c, BUFSIZE, &z, NULL);

		if (z > 0) {
			packet.type = SR_DF_LOGIC;
			packet.payload = &logic;
			packet.timeoffset =  samples_received * period_ps;
			packet.duration = z * period_ps;
			logic.length = z;
			logic.unitsize = 1;
			logic.data = c;
			sr_session_bus(session_data, &packet);
			samples_received += z;
		}
	} while (z > 0);

	if (!thread_running && z <= 0) {
		/* Make sure we don't receive more packets. */
		g_io_channel_close(channels[0]);

		/* Send last packet. */
		packet.type = SR_DF_END;
		sr_session_bus(session_data, &packet);

		return FALSE;
	}

	return TRUE;
}

static int hw_start_acquisition(int device_index, gpointer session_data)
{
	struct sr_datafeed_packet *packet;
	struct sr_datafeed_header *header;
	struct databag *mydata;

	/* TODO: 'mydata' is never g_free()'d? */
	if (!(mydata = g_try_malloc(sizeof(struct databag)))) {
		sr_err("demo: %s: mydata malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	mydata->sample_generator = default_pattern;
	mydata->session_data = session_data;
	mydata->device_index = device_index;
	mydata->samples_counter = 0;

	if (pipe(mydata->pipe_fds)) {
		/* TODO: Better error message. */
		sr_err("demo: %s: pipe() failed", __func__);
		return SR_ERR;
	}

	channels[0] = g_io_channel_unix_new(mydata->pipe_fds[0]);
	channels[1] = g_io_channel_unix_new(mydata->pipe_fds[1]);

	/* Set channel encoding to binary (default is UTF-8). */
	g_io_channel_set_encoding(channels[0], NULL, NULL);
	g_io_channel_set_encoding(channels[1], NULL, NULL);

	/* Make channels to unbuffered. */
	g_io_channel_set_buffered(channels[0], FALSE);
	g_io_channel_set_buffered(channels[1], FALSE);

	sr_source_add(mydata->pipe_fds[0], G_IO_IN | G_IO_ERR, 40,
		      receive_data, session_data);

	/* Run the demo thread. */
	g_thread_init(NULL);
	/* This must to be done between g_thread_init() & g_thread_create(). */
	mydata->timer = g_timer_new();
	thread_running = 1;
	my_thread =
	    g_thread_create((GThreadFunc)thread_func, mydata, TRUE, NULL);
	if (!my_thread) {
		sr_err("demo: %s: g_thread_create failed", __func__);
		return SR_ERR; /* TODO */
	}

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

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

	packet->type = SR_DF_HEADER;
	packet->payload = header;
	packet->timeoffset = 0;
	packet->duration = 0;
	header->feed_version = 1;
	gettimeofday(&header->starttime, NULL);
	header->samplerate = cur_samplerate;
	header->num_logic_probes = NUM_PROBES;
	header->num_analog_probes = 0;
	sr_session_bus(session_data, packet);
	g_free(header);
	g_free(packet);

	return SR_OK;
}

static void hw_stop_acquisition(int device_index, gpointer session_data)
{
	/* Avoid compiler warnings. */
	(void)device_index;
	(void)session_data;

	/* Stop generate thread. */
	thread_running = 0;
}

struct sr_device_plugin demo_plugin_info = {
	.name = "demo",
	.longname = "Demo driver and pattern generator",
	.api_version = 1,
	.init = hw_init,
	.cleanup = hw_cleanup,
	.opendev = hw_opendev,
	.closedev = hw_closedev,
	.get_device_info = hw_get_device_info,
	.get_status = hw_get_status,
	.get_capabilities = hw_get_capabilities,
	.set_configuration = hw_set_configuration,
	.start_acquisition = hw_start_acquisition,
	.stop_acquisition = hw_stop_acquisition,
};
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	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include <stdlib.h>
	23	#include <unistd.h>
	24	#include <string.h>
	25	#ifdef _WIN32
	26	#include <io.h>
	27	#include <fcntl.h>
	28	#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
	29	#endif
	30	#include "config.h"
	31	#include "sigrok.h"
	32	#include "sigrok-internal.h"
	33
	34	/* TODO: Number of probes should be configurable. */
	35	#define NUM_PROBES 8
	36
	37	#define DEMONAME "Demo device"
	38
	39	/* The size of chunks to send through the session bus. */
	40	/* TODO: Should be configurable. */
	41	#define BUFSIZE 4096
	42
	43	/* Supported patterns which we can generate */
	44	enum {
	45	/**
	46	* Pattern which spells "sigrok" using '0's (with '1's as "background")
	47	* when displayed using the 'bits' output format.
	48	*/
	49	PATTERN_SIGROK,
	50
	51	/** Pattern which consists of (pseudo-)random values on all probes. */
	52	PATTERN_RANDOM,
	53
	54	/**
	55	* Pattern which consists of incrementing numbers.
	56	* TODO: Better description.
	57	*/
	58	PATTERN_INC,
	59
	60	/** Pattern where all probes have a low logic state. */
	61	PATTERN_ALL_LOW,
	62
	63	/** Pattern where all probes have a high logic state. */
	64	PATTERN_ALL_HIGH,
	65	};
	66
	67	/* FIXME: Should not be global. */
	68	GIOChannel *channels[2];
	69
	70	struct databag {
	71	int pipe_fds[2];
	72	uint8_t sample_generator;
	73	uint8_t thread_running;
	74	uint64_t samples_counter;
	75	int device_index;
	76	gpointer session_data;
	77	GTimer *timer;
	78	};
	79
	80	static int capabilities[] = {
	81	SR_HWCAP_LOGIC_ANALYZER,
	82	SR_HWCAP_SAMPLERATE,
	83	SR_HWCAP_PATTERN_MODE,
	84	SR_HWCAP_LIMIT_SAMPLES,
	85	SR_HWCAP_LIMIT_MSEC,
	86	SR_HWCAP_CONTINUOUS,
	87	};
	88
	89	static struct sr_samplerates samplerates = {
	90	SR_HZ(1),
	91	SR_GHZ(1),
	92	SR_HZ(1),
	93	NULL,
	94	};
	95
	96	static const char *pattern_strings[] = {
	97	"sigrok",
	98	"random",
	99	"incremental",
	100	"all-low",
	101	"all-high",
	102	NULL,
	103	};
	104
	105	static uint8_t pattern_sigrok[] = {
	106	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
	107	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
	108	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
	109	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
	110	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
	111	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
	112	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	113	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	114	};
	115
	116	/* List of struct sr_device_instance, maintained by opendev()/closedev(). */
	117	static GSList *device_instances = NULL;
	118	static uint64_t cur_samplerate = SR_KHZ(200);
	119	static uint64_t period_ps = 5000000;
	120	static uint64_t limit_samples = 0;
	121	static uint64_t limit_msec = 0;
	122	static int default_pattern = PATTERN_SIGROK;
	123	static GThread *my_thread;
	124	static int thread_running;
	125
	126	static void hw_stop_acquisition(int device_index, gpointer session_data);
	127
	128	static int hw_init(const char *deviceinfo)
	129	{
	130	struct sr_device_instance *sdi;
	131
	132	/* Avoid compiler warnings. */
	133	(void)deviceinfo;
	134
	135	sdi = sr_device_instance_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	136	if (!sdi) {
	137	sr_err("demo: %s: sr_device_instance_new failed", __func__);
	138	return 0;
	139	}
	140
	141	device_instances = g_slist_append(device_instances, sdi);
	142
	143	return 1;
	144	}
	145
	146	static int hw_opendev(int device_index)
	147	{
	148	/* Avoid compiler warnings. */
	149	(void)device_index;
	150
	151	/* Nothing needed so far. */
	152
	153	return SR_OK;
	154	}
	155
	156	static int hw_closedev(int device_index)
	157	{
	158	/* Avoid compiler warnings. */
	159	(void)device_index;
	160
	161	/* Nothing needed so far. */
	162
	163	return SR_OK;
	164	}
	165
	166	static void hw_cleanup(void)
	167	{
	168	/* Nothing needed so far. */
	169	}
	170
	171	static void *hw_get_device_info(int device_index, int device_info_id)
	172	{
	173	struct sr_device_instance *sdi;
	174	void *info = NULL;
	175
	176	if (!(sdi = sr_get_device_instance(device_instances, device_index))) {
	177	sr_err("demo: %s: sdi was NULL", __func__);
	178	return NULL;
	179	}
	180
	181	switch (device_info_id) {
	182	case SR_DI_INSTANCE:
	183	info = sdi;
	184	break;
	185	case SR_DI_NUM_PROBES:
	186	info = GINT_TO_POINTER(NUM_PROBES);
	187	break;
	188	case SR_DI_SAMPLERATES:
	189	info = &samplerates;
	190	break;
	191	case SR_DI_CUR_SAMPLERATE:
	192	info = &cur_samplerate;
	193	break;
	194	case SR_DI_PATTERNMODES:
	195	info = &pattern_strings;
	196	break;
	197	}
	198
	199	return info;
	200	}
	201
	202	static int hw_get_status(int device_index)
	203	{
	204	/* Avoid compiler warnings. */
	205	(void)device_index;
	206
	207	return SR_ST_ACTIVE;
	208	}
	209
	210	static int *hw_get_capabilities(void)
	211	{
	212	return capabilities;
	213	}
	214
	215	static int hw_set_configuration(int device_index, int capability, void *value)
	216	{
	217	int ret;
	218	char *stropt;
	219
	220	/* Avoid compiler warnings. */
	221	(void)device_index;
	222
	223	if (capability == SR_HWCAP_PROBECONFIG) {
	224	/* Nothing to do, but must be supported */
	225	ret = SR_OK;
	226	} else if (capability == SR_HWCAP_SAMPLERATE) {
	227	cur_samplerate = (uint64_t )value;
	228	period_ps = 1000000000000 / cur_samplerate;
	229	sr_dbg("demo: %s: setting samplerate to %" PRIu64, __func__,
	230	cur_samplerate);
	231	ret = SR_OK;
	232	} else if (capability == SR_HWCAP_LIMIT_SAMPLES) {
	233	limit_samples = (uint64_t )value;
	234	sr_dbg("demo: %s: setting limit_samples to %" PRIu64, __func__,
	235	limit_samples);
	236	ret = SR_OK;
	237	} else if (capability == SR_HWCAP_LIMIT_MSEC) {
	238	limit_msec = (uint64_t )value;
	239	sr_dbg("demo: %s: setting limit_msec to %" PRIu64, __func__,
	240	limit_msec);
	241	ret = SR_OK;
	242	} else if (capability == SR_HWCAP_PATTERN_MODE) {
	243	stropt = value;
	244	ret = SR_OK;
	245	if (!strcmp(stropt, "sigrok")) {
	246	default_pattern = PATTERN_SIGROK;
	247	} else if (!strcmp(stropt, "random")) {
	248	default_pattern = PATTERN_RANDOM;
	249	} else if (!strcmp(stropt, "incremental")) {
	250	default_pattern = PATTERN_INC;
	251	} else if (!strcmp(stropt, "all-low")) {
	252	default_pattern = PATTERN_ALL_LOW;
	253	} else if (!strcmp(stropt, "all-high")) {
	254	default_pattern = PATTERN_ALL_HIGH;
	255	} else {
	256	ret = SR_ERR;
	257	}
	258	sr_dbg("demo: %s: setting pattern to %d", __func__,
	259	default_pattern);
	260	} else {
	261	ret = SR_ERR;
	262	}
	263
	264	return ret;
	265	}
	266
	267	static void samples_generator(uint8_t buf, uint64_t size, void data)
	268	{
	269	static uint64_t p = 0;
	270	struct databag *mydata = data;
	271	uint64_t i;
	272
	273	/* TODO: Needed? */
	274	memset(buf, 0, size);
	275
	276	switch (mydata->sample_generator) {
	277	case PATTERN_SIGROK: /* sigrok pattern */
	278	for (i = 0; i < size; i++) {
	279	*(buf + i) = ~(pattern_sigrok[p] >> 1);
	280	if (++p == 64)
	281	p = 0;
	282	}
	283	break;
	284	case PATTERN_RANDOM: /* Random */
	285	for (i = 0; i < size; i++)
	286	*(buf + i) = (uint8_t)(rand() & 0xff);
	287	break;
	288	case PATTERN_INC: /* Simple increment */
	289	for (i = 0; i < size; i++)
	290	*(buf + i) = i;
	291	break;
	292	case PATTERN_ALL_LOW: /* All probes are low */
	293	memset(buf, 0x00, size);
	294	break;
	295	case PATTERN_ALL_HIGH: /* All probes are high */
	296	memset(buf, 0xff, size);
	297	break;
	298	default:
	299	/* TODO: Error handling. */
	300	break;
	301	}
	302	}
	303
	304	/* Thread function */
	305	static void thread_func(void *data)
	306	{
	307	struct databag *mydata = data;
	308	uint8_t buf[BUFSIZE];
	309	uint64_t nb_to_send = 0;
	310	int bytes_written;
	311	double time_cur, time_last, time_diff;
	312
	313	time_last = g_timer_elapsed(mydata->timer, NULL);
	314
	315	while (thread_running) {
	316	/* Rate control */
	317	time_cur = g_timer_elapsed(mydata->timer, NULL);
	318
	319	time_diff = time_cur - time_last;
	320	time_last = time_cur;
	321
	322	nb_to_send = cur_samplerate * time_diff;
	323
	324	if (limit_samples) {
	325	nb_to_send = MIN(nb_to_send,
	326	limit_samples - mydata->samples_counter);
	327	}
	328
	329	/* Make sure we don't overflow. */
	330	nb_to_send = MIN(nb_to_send, BUFSIZE);
	331
	332	if (nb_to_send) {
	333	samples_generator(buf, nb_to_send, data);
	334	mydata->samples_counter += nb_to_send;
	335
	336	g_io_channel_write_chars(channels[1], (gchar *)&buf,
	337	nb_to_send, (gsize *)&bytes_written, NULL);
	338	}
	339
	340	/* Check if we're done. */
	341	if ((limit_msec && time_cur * 1000 > limit_msec) \|\|
	342	(limit_samples && mydata->samples_counter >= limit_samples))
	343	{
	344	close(mydata->pipe_fds[1]);
	345	thread_running = 0;
	346	}
	347
	348	g_usleep(10);
	349	}
	350	}
	351
	352	/* Callback handling data */
	353	static int receive_data(int fd, int revents, void *session_data)
	354	{
	355	struct sr_datafeed_packet packet;
	356	struct sr_datafeed_logic logic;
	357	static uint64_t samples_received = 0;
	358	unsigned char c[BUFSIZE];
	359	gsize z;
	360
	361	/* Avoid compiler warnings. */
	362	(void)fd;
	363	(void)revents;
	364
	365	do {
	366	g_io_channel_read_chars(channels[0],
	367	(gchar *)&c, BUFSIZE, &z, NULL);
	368
	369	if (z > 0) {
	370	packet.type = SR_DF_LOGIC;
	371	packet.payload = &logic;
	372	packet.timeoffset = samples_received * period_ps;
	373	packet.duration = z * period_ps;
	374	logic.length = z;
	375	logic.unitsize = 1;
	376	logic.data = c;
	377	sr_session_bus(session_data, &packet);
	378	samples_received += z;
	379	}
	380	} while (z > 0);
	381
	382	if (!thread_running && z <= 0) {
	383	/* Make sure we don't receive more packets. */
	384	g_io_channel_close(channels[0]);
	385
	386	/* Send last packet. */
	387	packet.type = SR_DF_END;
	388	sr_session_bus(session_data, &packet);
	389
	390	return FALSE;
	391	}
	392
	393	return TRUE;
	394	}
	395
	396	static int hw_start_acquisition(int device_index, gpointer session_data)
	397	{
	398	struct sr_datafeed_packet *packet;
	399	struct sr_datafeed_header *header;
	400	struct databag *mydata;
	401
	402	/* TODO: 'mydata' is never g_free()'d? */
	403	if (!(mydata = g_try_malloc(sizeof(struct databag)))) {
	404	sr_err("demo: %s: mydata malloc failed", __func__);
	405	return SR_ERR_MALLOC;
	406	}
	407
	408	mydata->sample_generator = default_pattern;
	409	mydata->session_data = session_data;
	410	mydata->device_index = device_index;
	411	mydata->samples_counter = 0;
	412
	413	if (pipe(mydata->pipe_fds)) {
	414	/* TODO: Better error message. */
	415	sr_err("demo: %s: pipe() failed", __func__);
	416	return SR_ERR;
	417	}
	418
	419	channels[0] = g_io_channel_unix_new(mydata->pipe_fds[0]);
	420	channels[1] = g_io_channel_unix_new(mydata->pipe_fds[1]);
	421
	422	/* Set channel encoding to binary (default is UTF-8). */
	423	g_io_channel_set_encoding(channels[0], NULL, NULL);
	424	g_io_channel_set_encoding(channels[1], NULL, NULL);
	425
	426	/* Make channels to unbuffered. */
	427	g_io_channel_set_buffered(channels[0], FALSE);
	428	g_io_channel_set_buffered(channels[1], FALSE);
	429
	430	sr_source_add(mydata->pipe_fds[0], G_IO_IN \| G_IO_ERR, 40,
	431	receive_data, session_data);
	432
	433	/* Run the demo thread. */
	434	g_thread_init(NULL);
	435	/* This must to be done between g_thread_init() & g_thread_create(). */
	436	mydata->timer = g_timer_new();
	437	thread_running = 1;
	438	my_thread =
	439	g_thread_create((GThreadFunc)thread_func, mydata, TRUE, NULL);
	440	if (!my_thread) {
	441	sr_err("demo: %s: g_thread_create failed", __func__);
	442	return SR_ERR; /* TODO */
	443	}
	444
	445	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
	446	sr_err("demo: %s: packet malloc failed", __func__);
	447	return SR_ERR_MALLOC;
	448	}
	449
	450	if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
	451	sr_err("demo: %s: header malloc failed", __func__);
	452	return SR_ERR_MALLOC;
	453	}
	454
	455	packet->type = SR_DF_HEADER;
	456	packet->payload = header;
	457	packet->timeoffset = 0;
	458	packet->duration = 0;
	459	header->feed_version = 1;
	460	gettimeofday(&header->starttime, NULL);
	461	header->samplerate = cur_samplerate;
	462	header->num_logic_probes = NUM_PROBES;
	463	header->num_analog_probes = 0;
	464	sr_session_bus(session_data, packet);
	465	g_free(header);
	466	g_free(packet);
	467
	468	return SR_OK;
	469	}
	470
	471	static void hw_stop_acquisition(int device_index, gpointer session_data)
	472	{
	473	/* Avoid compiler warnings. */
	474	(void)device_index;
	475	(void)session_data;
	476
	477	/* Stop generate thread. */
	478	thread_running = 0;
	479	}
	480
	481	struct sr_device_plugin demo_plugin_info = {
	482	.name = "demo",
	483	.longname = "Demo driver and pattern generator",
	484	.api_version = 1,
	485	.init = hw_init,
	486	.cleanup = hw_cleanup,
	487	.opendev = hw_opendev,
	488	.closedev = hw_closedev,
	489	.get_device_info = hw_get_device_info,
	490	.get_status = hw_get_status,
	491	.get_capabilities = hw_get_capabilities,
	492	.set_configuration = hw_set_configuration,
	493	.start_acquisition = hw_start_acquisition,
	494	.stop_acquisition = hw_stop_acquisition,
	495	};