[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>
#include <sigrok.h>
#include <sigrok-internal.h>
#ifdef _WIN32
#include <io.h>
#include <fcntl.h>
#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
#endif
#include "config.h"

#define NUM_PROBES             8
#define DEMONAME               "Demo device"
/* size of chunks to send through the session bus */
#define BUFSIZE                4096

enum {
	GENMODE_DEFAULT,
	GENMODE_RANDOM,
	GENMODE_INC,
};

/* 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_device_id;
	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 *patternmodes[] = {
	"random",
	"incremental",
	NULL,
};

static uint8_t genmode_default[] = {
	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 limit_samples = 0;
static uint64_t limit_msec = 0;
static int default_genmode = GENMODE_DEFAULT;
static GThread *my_thread;
static int thread_running;

static void hw_stop_acquisition(int device_index, gpointer session_device_id);

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

	/* Avoid compiler warnings. */
	deviceinfo = deviceinfo;

	sdi = sr_device_instance_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	if (!sdi)
		return 0;

	device_instances = g_slist_append(device_instances, sdi);

	return 1;
}

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

	/* Nothing needed so far. */

	return SR_OK;
}

static int hw_closedev(int device_index)
{
	/* Avoid compiler warnings. */
	device_index = 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)))
		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 = &patternmodes;
		break;
	}

	return info;
}

static int hw_get_status(int device_index)
{
	/* Avoid compiler warnings. */
	device_index = 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. */
	device_index = 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;
		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;
		if (!strcmp(stropt, "random")) {
			default_genmode = GENMODE_RANDOM;
			ret = SR_OK;
		} else if (!strcmp(stropt, "incremental")) {
			default_genmode = GENMODE_INC;
			ret = SR_OK;
		} else {
			ret = SR_ERR;
		}
		sr_dbg("demo: %s: setting patternmode to %d", __func__,
		       default_genmode);
	} 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;

	memset(buf, 0, size);

	switch (mydata->sample_generator) {
	case GENMODE_DEFAULT:
		for (i = 0; i < size; i++) {
			*(buf + i) = ~(genmode_default[p] >> 1);
			if (++p == 64)
				p = 0;
		}
		break;
	case GENMODE_RANDOM: /* Random */
		for (i = 0; i < size; i++)
			*(buf + i) = (uint8_t)(rand() & 0xff);
		break;
	case GENMODE_INC: /* Simple increment */
		for (i = 0; i < size; i++)
			*(buf + i) = i;
		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 *user_data)
{
	struct sr_datafeed_packet packet;
	char c[BUFSIZE];
	gsize z;

	/* Avoid compiler warnings. */
	fd = fd;
	revents = revents;

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

		if (z > 0) {
			packet.type = SR_DF_LOGIC;
			packet.length = z;
			packet.unitsize = 1;
			packet.payload = c;
			sr_session_bus(user_data, &packet);
		}
	} 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(user_data, &packet);

		return FALSE;
	}

	return TRUE;
}

static int hw_start_acquisition(int device_index, gpointer session_device_id)
{
	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_genmode;
	mydata->session_device_id = session_device_id;
	mydata->device_index = device_index;
	mydata->samples_counter = 0;

	if (pipe(mydata->pipe_fds))
		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_device_id);

	/* Run the demo thread. */
	g_thread_init(NULL);
	/* this needs to be done between g_thread_init() and 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)
		return SR_ERR;

	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->length = sizeof(struct sr_datafeed_header);
	packet->payload = (unsigned char *)header;
	header->feed_version = 1;
	gettimeofday(&header->starttime, NULL);
	header->samplerate = cur_samplerate;
	header->protocol_id = SR_PROTO_RAW;
	header->num_logic_probes = NUM_PROBES;
	header->num_analog_probes = 0;
	sr_session_bus(session_device_id, packet);
	g_free(header);
	g_free(packet);

	return SR_OK;
}

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

	/* 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	#include <sigrok.h>
	26	#include <sigrok-internal.h>
	27	#ifdef _WIN32
	28	#include <io.h>
	29	#include <fcntl.h>
	30	#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
	31	#endif
	32	#include "config.h"
	33
	34	#define NUM_PROBES 8
	35	#define DEMONAME "Demo device"
	36	/* size of chunks to send through the session bus */
	37	#define BUFSIZE 4096
	38
	39	enum {
	40	GENMODE_DEFAULT,
	41	GENMODE_RANDOM,
	42	GENMODE_INC,
	43	};
	44
	45	/* FIXME: Should not be global. */
	46	GIOChannel *channels[2];
	47
	48	struct databag {
	49	int pipe_fds[2];
	50	uint8_t sample_generator;
	51	uint8_t thread_running;
	52	uint64_t samples_counter;
	53	int device_index;
	54	gpointer session_device_id;
	55	GTimer *timer;
	56	};
	57
	58	static int capabilities[] = {
	59	SR_HWCAP_LOGIC_ANALYZER,
	60	SR_HWCAP_SAMPLERATE,
	61	SR_HWCAP_PATTERN_MODE,
	62	SR_HWCAP_LIMIT_SAMPLES,
	63	SR_HWCAP_LIMIT_MSEC,
	64	SR_HWCAP_CONTINUOUS,
	65	};
	66
	67	static struct sr_samplerates samplerates = {
	68	SR_HZ(1),
	69	SR_GHZ(1),
	70	SR_HZ(1),
	71	NULL,
	72	};
	73
	74	static const char *patternmodes[] = {
	75	"random",
	76	"incremental",
	77	NULL,
	78	};
	79
	80	static uint8_t genmode_default[] = {
	81	0x4c, 0x92, 0x92, 0x92, 0x64, 0x00, 0x00, 0x00,
	82	0x82, 0xfe, 0xfe, 0x82, 0x00, 0x00, 0x00, 0x00,
	83	0x7c, 0x82, 0x82, 0x92, 0x74, 0x00, 0x00, 0x00,
	84	0xfe, 0x12, 0x12, 0x32, 0xcc, 0x00, 0x00, 0x00,
	85	0x7c, 0x82, 0x82, 0x82, 0x7c, 0x00, 0x00, 0x00,
	86	0xfe, 0x10, 0x28, 0x44, 0x82, 0x00, 0x00, 0x00,
	87	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	88	0xbe, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	89	};
	90
	91	/* List of struct sr_device_instance, maintained by opendev()/closedev(). */
	92	static GSList *device_instances = NULL;
	93	static uint64_t cur_samplerate = SR_KHZ(200);
	94	static uint64_t limit_samples = 0;
	95	static uint64_t limit_msec = 0;
	96	static int default_genmode = GENMODE_DEFAULT;
	97	static GThread *my_thread;
	98	static int thread_running;
	99
	100	static void hw_stop_acquisition(int device_index, gpointer session_device_id);
	101
	102	static int hw_init(const char *deviceinfo)
	103	{
	104	struct sr_device_instance *sdi;
	105
	106	/* Avoid compiler warnings. */
	107	deviceinfo = deviceinfo;
	108
	109	sdi = sr_device_instance_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
	110	if (!sdi)
	111	return 0;
	112
	113	device_instances = g_slist_append(device_instances, sdi);
	114
	115	return 1;
	116	}
	117
	118	static int hw_opendev(int device_index)
	119	{
	120	/* Avoid compiler warnings. */
	121	device_index = device_index;
	122
	123	/* Nothing needed so far. */
	124
	125	return SR_OK;
	126	}
	127
	128	static int hw_closedev(int device_index)
	129	{
	130	/* Avoid compiler warnings. */
	131	device_index = device_index;
	132
	133	/* Nothing needed so far. */
	134
	135	return SR_OK;
	136	}
	137
	138	static void hw_cleanup(void)
	139	{
	140	/* Nothing needed so far. */
	141	}
	142
	143	static void *hw_get_device_info(int device_index, int device_info_id)
	144	{
	145	struct sr_device_instance *sdi;
	146	void *info = NULL;
	147
	148	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
	149	return NULL;
	150
	151	switch (device_info_id) {
	152	case SR_DI_INSTANCE:
	153	info = sdi;
	154	break;
	155	case SR_DI_NUM_PROBES:
	156	info = GINT_TO_POINTER(NUM_PROBES);
	157	break;
	158	case SR_DI_SAMPLERATES:
	159	info = &samplerates;
	160	break;
	161	case SR_DI_CUR_SAMPLERATE:
	162	info = &cur_samplerate;
	163	break;
	164	case SR_DI_PATTERNMODES:
	165	info = &patternmodes;
	166	break;
	167	}
	168
	169	return info;
	170	}
	171
	172	static int hw_get_status(int device_index)
	173	{
	174	/* Avoid compiler warnings. */
	175	device_index = device_index;
	176
	177	return SR_ST_ACTIVE;
	178	}
	179
	180	static int *hw_get_capabilities(void)
	181	{
	182	return capabilities;
	183	}
	184
	185	static int hw_set_configuration(int device_index, int capability, void *value)
	186	{
	187	int ret;
	188	char *stropt;
	189
	190	/* Avoid compiler warnings. */
	191	device_index = device_index;
	192
	193	if (capability == SR_HWCAP_PROBECONFIG) {
	194	/* Nothing to do, but must be supported */
	195	ret = SR_OK;
	196	} else if (capability == SR_HWCAP_SAMPLERATE) {
	197	cur_samplerate = (uint64_t )value;
	198	sr_dbg("demo: %s: setting samplerate to %" PRIu64, __func__,
	199	cur_samplerate);
	200	ret = SR_OK;
	201	} else if (capability == SR_HWCAP_LIMIT_SAMPLES) {
	202	limit_samples = (uint64_t )value;
	203	sr_dbg("demo: %s: setting limit_samples to %" PRIu64, __func__,
	204	limit_samples);
	205	ret = SR_OK;
	206	} else if (capability == SR_HWCAP_LIMIT_MSEC) {
	207	limit_msec = (uint64_t )value;
	208	sr_dbg("demo: %s: setting limit_msec to %" PRIu64, __func__,
	209	limit_msec);
	210	ret = SR_OK;
	211	} else if (capability == SR_HWCAP_PATTERN_MODE) {
	212	stropt = value;
	213	if (!strcmp(stropt, "random")) {
	214	default_genmode = GENMODE_RANDOM;
	215	ret = SR_OK;
	216	} else if (!strcmp(stropt, "incremental")) {
	217	default_genmode = GENMODE_INC;
	218	ret = SR_OK;
	219	} else {
	220	ret = SR_ERR;
	221	}
	222	sr_dbg("demo: %s: setting patternmode to %d", __func__,
	223	default_genmode);
	224	} else {
	225	ret = SR_ERR;
	226	}
	227
	228	return ret;
	229	}
	230
	231	static void samples_generator(uint8_t buf, uint64_t size, void data)
	232	{
	233	static uint64_t p = 0;
	234	struct databag *mydata = data;
	235	uint64_t i;
	236
	237	memset(buf, 0, size);
	238
	239	switch (mydata->sample_generator) {
	240	case GENMODE_DEFAULT:
	241	for (i = 0; i < size; i++) {
	242	*(buf + i) = ~(genmode_default[p] >> 1);
	243	if (++p == 64)
	244	p = 0;
	245	}
	246	break;
	247	case GENMODE_RANDOM: /* Random */
	248	for (i = 0; i < size; i++)
	249	*(buf + i) = (uint8_t)(rand() & 0xff);
	250	break;
	251	case GENMODE_INC: /* Simple increment */
	252	for (i = 0; i < size; i++)
	253	*(buf + i) = i;
	254	break;
	255	}
	256	}
	257
	258	/* Thread function */
	259	static void thread_func(void *data)
	260	{
	261	struct databag *mydata = data;
	262	uint8_t buf[BUFSIZE];
	263	uint64_t nb_to_send = 0;
	264	int bytes_written;
	265
	266	double time_cur, time_last, time_diff;
	267
	268	time_last = g_timer_elapsed(mydata->timer, NULL);
	269
	270	while (thread_running) {
	271	/* Rate control */
	272	time_cur = g_timer_elapsed(mydata->timer, NULL);
	273
	274	time_diff = time_cur - time_last;
	275	time_last = time_cur;
	276
	277	nb_to_send = cur_samplerate * time_diff;
	278
	279	if (limit_samples)
	280	nb_to_send = MIN(nb_to_send,
	281	limit_samples - mydata->samples_counter);
	282
	283	/* Make sure we don't overflow. */
	284	nb_to_send = MIN(nb_to_send, BUFSIZE);
	285
	286	if (nb_to_send) {
	287	samples_generator(buf, nb_to_send, data);
	288	mydata->samples_counter += nb_to_send;
	289
	290	g_io_channel_write_chars(channels[1], (gchar *)&buf,
	291	nb_to_send, (gsize *)&bytes_written, NULL);
	292	}
	293
	294	/* Check if we're done. */
	295	if ((limit_msec && time_cur * 1000 > limit_msec) \|\|
	296	(limit_samples && mydata->samples_counter >= limit_samples))
	297	{
	298	close(mydata->pipe_fds[1]);
	299	thread_running = 0;
	300	}
	301
	302	g_usleep(10);
	303	}
	304	}
	305
	306	/* Callback handling data */
	307	static int receive_data(int fd, int revents, void *user_data)
	308	{
	309	struct sr_datafeed_packet packet;
	310	char c[BUFSIZE];
	311	gsize z;
	312
	313	/* Avoid compiler warnings. */
	314	fd = fd;
	315	revents = revents;
	316
	317	do {
	318	g_io_channel_read_chars(channels[0],
	319	(gchar *)&c, BUFSIZE, &z, NULL);
	320
	321	if (z > 0) {
	322	packet.type = SR_DF_LOGIC;
	323	packet.length = z;
	324	packet.unitsize = 1;
	325	packet.payload = c;
	326	sr_session_bus(user_data, &packet);
	327	}
	328	} while (z > 0);
	329
	330	if (!thread_running && z <= 0)
	331	{
	332	/* Make sure we don't receive more packets */
	333	g_io_channel_close(channels[0]);
	334
	335	/* Send last packet. */
	336	packet.type = SR_DF_END;
	337	sr_session_bus(user_data, &packet);
	338
	339	return FALSE;
	340	}
	341
	342	return TRUE;
	343	}
	344
	345	static int hw_start_acquisition(int device_index, gpointer session_device_id)
	346	{
	347	struct sr_datafeed_packet *packet;
	348	struct sr_datafeed_header *header;
	349	struct databag *mydata;
	350
	351	/* TODO: 'mydata' is never g_free()'d? */
	352	if (!(mydata = g_try_malloc(sizeof(struct databag)))) {
	353	sr_err("demo: %s: mydata malloc failed", __func__);
	354	return SR_ERR_MALLOC;
	355	}
	356
	357	mydata->sample_generator = default_genmode;
	358	mydata->session_device_id = session_device_id;
	359	mydata->device_index = device_index;
	360	mydata->samples_counter = 0;
	361
	362	if (pipe(mydata->pipe_fds))
	363	return SR_ERR;
	364
	365	channels[0] = g_io_channel_unix_new(mydata->pipe_fds[0]);
	366	channels[1] = g_io_channel_unix_new(mydata->pipe_fds[1]);
	367
	368	/* Set channel encoding to binary (default is UTF-8). */
	369	g_io_channel_set_encoding(channels[0], NULL, NULL);
	370	g_io_channel_set_encoding(channels[1], NULL, NULL);
	371
	372	/* Make channels to unbuffered. */
	373	g_io_channel_set_buffered(channels[0], FALSE);
	374	g_io_channel_set_buffered(channels[1], FALSE);
	375
	376	sr_source_add(mydata->pipe_fds[0], G_IO_IN \| G_IO_ERR, 40,
	377	receive_data, session_device_id);
	378
	379	/* Run the demo thread. */
	380	g_thread_init(NULL);
	381	/* this needs to be done between g_thread_init() and g_thread_create() */
	382	mydata->timer = g_timer_new();
	383	thread_running = 1;
	384	my_thread =
	385	g_thread_create((GThreadFunc)thread_func, mydata, TRUE, NULL);
	386	if (!my_thread)
	387	return SR_ERR;
	388
	389	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
	390	sr_err("demo: %s: packet malloc failed", __func__);
	391	return SR_ERR_MALLOC;
	392	}
	393
	394	if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
	395	sr_err("demo: %s: header malloc failed", __func__);
	396	return SR_ERR_MALLOC;
	397	}
	398
	399	packet->type = SR_DF_HEADER;
	400	packet->length = sizeof(struct sr_datafeed_header);
	401	packet->payload = (unsigned char *)header;
	402	header->feed_version = 1;
	403	gettimeofday(&header->starttime, NULL);
	404	header->samplerate = cur_samplerate;
	405	header->protocol_id = SR_PROTO_RAW;
	406	header->num_logic_probes = NUM_PROBES;
	407	header->num_analog_probes = 0;
	408	sr_session_bus(session_device_id, packet);
	409	g_free(header);
	410	g_free(packet);
	411
	412	return SR_OK;
	413	}
	414
	415	static void hw_stop_acquisition(int device_index, gpointer session_device_id)
	416	{
	417	/* Avoid compiler warnings. */
	418	device_index = device_index;
	419	session_device_id = session_device_id;
	420
	421	/* Stop generate thread. */
	422	thread_running = 0;
	423	}
	424
	425	struct sr_device_plugin demo_plugin_info = {
	426	.name = "demo",
	427	.longname = "Demo driver and pattern generator",
	428	.api_version = 1,
	429	.init = hw_init,
	430	.cleanup = hw_cleanup,
	431	.opendev = hw_opendev,
	432	.closedev = hw_closedev,
	433	.get_device_info = hw_get_device_info,
	434	.get_status = hw_get_status,
	435	.get_capabilities = hw_get_capabilities,
	436	.set_configuration = hw_set_configuration,
	437	.start_acquisition = hw_start_acquisition,
	438	.stop_acquisition = hw_stop_acquisition,
	439	};