[libsigrok.git] / session.c

/*
 * This file is part of the sigrok project.
 *
 * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.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 3 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, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <glib.h>
#include "libsigrok.h"
#include "libsigrok-internal.h"

struct source {
	int timeout;
	sr_receive_data_callback_t cb;
	void *cb_data;

	/* This is used to keep track of the object (fd, pollfd or channel) which is
	 * being polled and will be used to match the source when removing it again.
	 */
	gintptr poll_object;
};

/* There can only be one session at a time. */
/* 'session' is not static, it's used elsewhere (via 'extern'). */
struct sr_session *session;

/**
 * Create a new session.
 *
 * TODO: Should it use the file-global "session" variable or take an argument?
 *       The same question applies to all the other session functions.
 *
 * @return A pointer to the newly allocated session, or NULL upon errors.
 */
SR_API struct sr_session *sr_session_new(void)
{
	if (!(session = g_try_malloc0(sizeof(struct sr_session)))) {
		sr_err("session: %s: session malloc failed", __func__);
		return NULL; /* TODO: SR_ERR_MALLOC? */
	}

	session->source_timeout = -1;

	return session;
}

/**
 * Destroy the current session.
 *
 * This frees up all memory used by the session.
 *
 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 */
SR_API int sr_session_destroy(void)
{
	if (!session) {
		sr_err("session: %s: session was NULL", __func__);
		return SR_ERR_BUG;
	}

	sr_session_dev_remove_all();

	/* TODO: Error checks needed? */

	/* TODO: Loop over protocol decoders and free them. */

	g_free(session);
	session = NULL;

	return SR_OK;
}

static void sr_dev_close(struct sr_dev *dev)
{
	if (dev->driver->dev_close)
		dev->driver->dev_close(dev->driver_index);
}

/**
 * Remove all the devices from the current session. TODO?
 *
 * The session itself (i.e., the struct sr_session) is not free'd and still
 * exists after this function returns.
 *
 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 */
SR_API int sr_session_dev_remove_all(void)
{
	if (!session) {
		sr_err("session: %s: session was NULL", __func__);
		return SR_ERR_BUG;
	}

	g_slist_free_full(session->devs, (GDestroyNotify)sr_dev_close);
	session->devs = NULL;

	return SR_OK;
}

/**
 * Add a device to the current session.
 *
 * @param dev The device to add to the current session. Must not be NULL.
 *            Also, dev->driver and dev->driver->dev_open must not be NULL.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
 */
SR_API int sr_session_dev_add(struct sr_dev *dev)
{
	int ret;

	if (!dev) {
		sr_err("session: %s: dev was NULL", __func__);
		return SR_ERR_ARG;
	}

	if (!session) {
		sr_err("session: %s: session was NULL", __func__);
		return SR_ERR_BUG;
	}

	/* If dev->driver is NULL, this is a virtual device. */
	if (!dev->driver) {
		sr_dbg("session: %s: dev->driver was NULL, this seems to be "
		       "a virtual device; continuing", __func__);
		/* Just add the device, don't run dev_open(). */
		session->devs = g_slist_append(session->devs, dev);
		return SR_OK;
	}

	/* dev->driver is non-NULL (i.e. we have a real device). */
	if (!dev->driver->dev_open) {
		sr_err("session: %s: dev->driver->dev_open was NULL",
		       __func__);
		return SR_ERR_BUG;
	}

	if ((ret = dev->driver->dev_open(dev->driver_index)) != SR_OK) {
		sr_err("session: %s: dev_open failed (%d)", __func__, ret);
		return ret;
	}

	session->devs = g_slist_append(session->devs, dev);

	return SR_OK;
}

/**
 * Remove all datafeed callbacks in the current session.
 *
 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 */
SR_API int sr_session_datafeed_callback_remove_all(void)
{
	if (!session) {
		sr_err("session: %s: session was NULL", __func__);
		return SR_ERR_BUG;
	}

	g_slist_free(session->datafeed_callbacks);
	session->datafeed_callbacks = NULL;

	return SR_OK;
}

/**
 * Add a datafeed callback to the current session.
 *
 * @param cb Function to call when a chunk of data is received.
 *           Must not be NULL.
 *
 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 */
SR_API int sr_session_datafeed_callback_add(sr_datafeed_callback_t cb)
{
	if (!session) {
		sr_err("session: %s: session was NULL", __func__);
		return SR_ERR_BUG;
	}

	if (!cb) {
		sr_err("session: %s: cb was NULL", __func__);
		return SR_ERR_ARG;
	}

	session->datafeed_callbacks =
	    g_slist_append(session->datafeed_callbacks, cb);

	return SR_OK;
}

/**
 * TODO.
 */
static int sr_session_run_poll(void)
{
	unsigned int i;
	int ret;

	while (session->running) {
		ret = g_poll(session->pollfds, session->num_sources, session->source_timeout);

		for (i = 0; i < session->num_sources; i++) {
			if (session->pollfds[i].revents > 0 || (ret == 0
				&& session->source_timeout == session->sources[i].timeout)) {
				/*
				 * Invoke the source's callback on an event,
				 * or if the poll timeout out and this source
				 * asked for that timeout.
				 */
				if (!session->sources[i].cb(session->pollfds[i].fd, session->pollfds[i].revents,
						  session->sources[i].cb_data))
					sr_session_source_remove(session->sources[i].poll_object);
			}
		}
	}

	return SR_OK;
}

/**
 * Start a session.
 *
 * There can only be one session at a time.
 *
 * @return SR_OK upon success, SR_ERR upon errors.
 */
SR_API int sr_session_start(void)
{
	struct sr_dev *dev;
	GSList *l;
	int ret;

	if (!session) {
		sr_err("session: %s: session was NULL; a session must be "
		       "created first, before starting it.", __func__);
		return SR_ERR_BUG;
	}

	if (!session->devs) {
		/* TODO: Actually the case? */
		sr_err("session: %s: session->devs was NULL; a session "
		       "cannot be started without devices.", __func__);
		return SR_ERR_BUG;
	}

	/* TODO: Check driver_index validity? */

	sr_info("session: starting");

	for (l = session->devs; l; l = l->next) {
		dev = l->data;
		/* TODO: Check for dev != NULL. */
		if ((ret = dev->driver->dev_acquisition_start(
				dev->driver_index, dev)) != SR_OK) {
			sr_err("session: %s: could not start an acquisition "
			       "(%d)", __func__, ret);
			break;
		}
	}

	/* TODO: What if there are multiple devices? Which return code? */

	return ret;
}

/**
 * Run the session.
 *
 * TODO: Various error checks etc.
 *
 * @return SR_OK upon success, SR_ERR_BUG upon errors.
 */
SR_API int sr_session_run(void)
{
	if (!session) {
		sr_err("session: %s: session was NULL; a session must be "
		       "created first, before running it.", __func__);
		return SR_ERR_BUG;
	}

	if (!session->devs) {
		/* TODO: Actually the case? */
		sr_err("session: %s: session->devs was NULL; a session "
		       "cannot be run without devices.", __func__);
		return SR_ERR_BUG;
	}

	sr_info("session: running");
	session->running = TRUE;

	/* Do we have real sources? */
	if (session->num_sources == 1 && session->pollfds[0].fd == -1) {
		/* Dummy source, freewheel over it. */
		while (session->running)
			session->sources[0].cb(-1, 0, session->sources[0].cb_data);
	} else {
		/* Real sources, use g_poll() main loop. */
		sr_session_run_poll();
	}

	return SR_OK;
}

/**
 * Halt the current session.
 *
 * This requests the current session be stopped as soon as possible, for
 * example on receiving an SR_DF_END packet.
 *
 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 */
SR_API int sr_session_halt(void)
{
	if (!session) {
		sr_err("session: %s: session was NULL", __func__);
		return SR_ERR_BUG;
	}

	sr_info("session: halting");
	session->running = FALSE;

	return SR_OK;
}

/**
 * Stop the current session.
 *
 * The current session is stopped immediately, with all acquisition sessions
 * being stopped and hardware drivers cleaned up.
 *
 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 */
SR_API int sr_session_stop(void)
{
	struct sr_dev *dev;
	GSList *l;

	if (!session) {
		sr_err("session: %s: session was NULL", __func__);
		return SR_ERR_BUG;
	}

	sr_info("session: stopping");
	session->running = FALSE;

	for (l = session->devs; l; l = l->next) {
		dev = l->data;
		/* Check for dev != NULL. */
		if (dev->driver) {
			if (dev->driver->dev_acquisition_stop)
				dev->driver->dev_acquisition_stop(dev->driver_index, dev);
		}
	}

	return SR_OK;
}

/**
 * Debug helper.
 *
 * @param packet The packet to show debugging information for.
 */
static void datafeed_dump(struct sr_datafeed_packet *packet)
{
	struct sr_datafeed_logic *logic;
	struct sr_datafeed_analog *analog;

	switch (packet->type) {
	case SR_DF_HEADER:
		sr_dbg("bus: received SR_DF_HEADER");
		break;
	case SR_DF_TRIGGER:
		sr_dbg("bus: received SR_DF_TRIGGER");
		break;
	case SR_DF_META_LOGIC:
		sr_dbg("bus: received SR_DF_META_LOGIC");
		break;
	case SR_DF_LOGIC:
		logic = packet->payload;
		/* TODO: Check for logic != NULL. */
		sr_dbg("bus: received SR_DF_LOGIC %" PRIu64 " bytes", logic->length);
		break;
	case SR_DF_META_ANALOG:
		sr_dbg("bus: received SR_DF_META_LOGIC");
		break;
	case SR_DF_ANALOG:
		analog = packet->payload;
		/* TODO: Check for analog != NULL. */
		sr_dbg("bus: received SR_DF_ANALOG %d samples", analog->num_samples);
		break;
	case SR_DF_END:
		sr_dbg("bus: received SR_DF_END");
		break;
	case SR_DF_FRAME_BEGIN:
		sr_dbg("bus: received SR_DF_FRAME_BEGIN");
		break;
	case SR_DF_FRAME_END:
		sr_dbg("bus: received SR_DF_FRAME_END");
		break;
	default:
		sr_dbg("bus: received unknown packet type %d", packet->type);
		break;
	}
}

/**
 * Send a packet to whatever is listening on the datafeed bus.
 *
 * Hardware drivers use this to send a data packet to the frontend.
 *
 * @param dev TODO.
 * @param packet The datafeed packet to send to the session bus.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
 */
SR_PRIV int sr_session_send(struct sr_dev *dev,
			    struct sr_datafeed_packet *packet)
{
	GSList *l;
	sr_datafeed_callback_t cb;

	if (!dev) {
		sr_err("session: %s: dev was NULL", __func__);
		return SR_ERR_ARG;
	}

	if (!packet) {
		sr_err("session: %s: packet was NULL", __func__);
		return SR_ERR_ARG;
	}

	for (l = session->datafeed_callbacks; l; l = l->next) {
		if (sr_log_loglevel_get() >= SR_LOG_DBG)
			datafeed_dump(packet);
		cb = l->data;
		/* TODO: Check for cb != NULL. */
		cb(dev, packet);
	}

	return SR_OK;
}

static int _sr_session_source_add(GPollFD *pollfd, int timeout,
	sr_receive_data_callback_t cb, void *cb_data, gintptr poll_object)
{
	struct source *new_sources, *s;
	GPollFD *new_pollfds;

	if (!cb) {
		sr_err("session: %s: cb was NULL", __func__);
		return SR_ERR_ARG;
	}

	/* Note: cb_data can be NULL, that's not a bug. */

	new_pollfds = g_try_realloc(session->pollfds, sizeof(GPollFD) * (session->num_sources + 1));
	if (!new_pollfds) {
		sr_err("session: %s: new_pollfds malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	new_sources = g_try_realloc(session->sources, sizeof(struct source) *
	(session->num_sources + 1));
	if (!new_sources) {
		sr_err("session: %s: new_sources malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	new_pollfds[session->num_sources] = *pollfd;
	s = &new_sources[session->num_sources++];
	s->timeout = timeout;
	s->cb = cb;
	s->cb_data = cb_data;
	s->poll_object = poll_object;
	session->pollfds = new_pollfds;
	session->sources = new_sources;

	if (timeout != session->source_timeout && timeout > 0
	    && (session->source_timeout == -1 || timeout < session->source_timeout))
		session->source_timeout = timeout;

	return SR_OK;
}

/**
 * Add a event source for a file descriptor.
 *
 * @param fd The file descriptor.
 * @param events Events to check for.
 * @param timeout Max time to wait before the callback is called, ignored if 0.
 * @param cb Callback function to add. Must not be NULL.
 * @param cb_data Data for the callback function. Can be NULL.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 *         SR_ERR_MALLOC upon memory allocation errors.
 */
SR_API int sr_session_source_add(int fd, int events, int timeout,
		sr_receive_data_callback_t cb, void *cb_data)
{
	GPollFD p;

	p.fd = fd;
	p.events = events;

	return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)fd);
}

/**
 * Add an event source for a GPollFD.
 *
 * TODO: More error checks etc.
 *
 * @param pollfd The GPollFD.
 * @param timeout Max time to wait before the callback is called, ignored if 0.
 * @param cb Callback function to add. Must not be NULL.
 * @param cb_data Data for the callback function. Can be NULL.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 *         SR_ERR_MALLOC upon memory allocation errors.
 */
SR_API int sr_session_source_add_pollfd(GPollFD *pollfd, int timeout,
		sr_receive_data_callback_t cb, void *cb_data)
{
	return _sr_session_source_add(pollfd, timeout, cb,
				      cb_data, (gintptr)pollfd);
}

/**
 * Add an event source for a GIOChannel.
 *
 * TODO: More error checks etc.
 *
 * @param channel The GIOChannel.
 * @param events Events to poll on.
 * @param timeout Max time to wait before the callback is called, ignored if 0.
 * @param cb Callback function to add. Must not be NULL.
 * @param cb_data Data for the callback function. Can be NULL.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 *         SR_ERR_MALLOC upon memory allocation errors.
 */
SR_API int sr_session_source_add_channel(GIOChannel *channel, int events,
		int timeout, sr_receive_data_callback_t cb, void *cb_data)
{
	GPollFD p;

#ifdef _WIN32
	g_io_channel_win32_make_pollfd(channel,
			events, &p);
#else
	p.fd = g_io_channel_unix_get_fd(channel);
	p.events = events;
#endif

	return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)channel);
}


static int _sr_session_source_remove(gintptr poll_object)
{
	struct source *new_sources;
	GPollFD *new_pollfds;
	unsigned int old;

	if (!session->sources || !session->num_sources) {
		sr_err("session: %s: sources was NULL", __func__);
		return SR_ERR_BUG;
	}

	for (old = 0; old < session->num_sources; old++) {
		if (session->sources[old].poll_object == poll_object)
			break;
	}

	/* fd not found, nothing to do */
	if (old == session->num_sources)
		return SR_OK;

	session->num_sources -= 1;

	if (old != session->num_sources) {
		memmove(&session->pollfds[old], &session->pollfds[old+1],
			(session->num_sources - old) * sizeof(GPollFD));
		memmove(&session->sources[old], &session->sources[old+1],
			(session->num_sources - old) * sizeof(struct source));
	}

	new_pollfds = g_try_realloc(session->pollfds, sizeof(GPollFD) * session->num_sources);
	if (!new_pollfds && session->num_sources > 0) {
		sr_err("session: %s: new_pollfds malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	new_sources = g_try_realloc(session->sources, sizeof(struct source) * session->num_sources);
	if (!new_sources && session->num_sources > 0) {
		sr_err("session: %s: new_sources malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	session->pollfds = new_pollfds;
	session->sources = new_sources;

	return SR_OK;
}

/*
 * Remove the source belonging to the specified file descriptor.
 *
 * TODO: More error checks.
 *
 * @param fd The file descriptor for which the source should be removed.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 *         SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
 *         internal errors.
 */
SR_API int sr_session_source_remove(int fd)
{
	return _sr_session_source_remove((gintptr)fd);
}

/**
 * Remove the source belonging to the specified poll descriptor.
 *
 * TODO: More error checks.
 *
 * @param pollfd The poll descriptor for which the source should be removed.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 *         SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
 *         internal errors.
 */
SR_API int sr_session_source_remove_pollfd(GPollFD *pollfd)
{
	return _sr_session_source_remove((gintptr)pollfd);
}

/*
 * Remove the source belonging to the specified channel.
 *
 * TODO: More error checks.
 *
 * @param channel The channel for which the source should be removed.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 *         SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
 *         internal errors.
 */
SR_API int sr_session_source_remove_channel(GIOChannel *channel)
{
	return _sr_session_source_remove((gintptr)channel);
}
Commit	Line	Data
	1	/*
	2	* This file is part of the sigrok project.
	3	*
	4	* Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <stdio.h>
	21	#include <stdlib.h>
	22	#include <unistd.h>
	23	#include <string.h>
	24	#include <glib.h>
	25	#include "libsigrok.h"
	26	#include "libsigrok-internal.h"
	27
	28	struct source {
	29	int timeout;
	30	sr_receive_data_callback_t cb;
	31	void *cb_data;
	32
	33	/* This is used to keep track of the object (fd, pollfd or channel) which is
	34	* being polled and will be used to match the source when removing it again.
	35	*/
	36	gintptr poll_object;
	37	};
	38
	39	/* There can only be one session at a time. */
	40	/* 'session' is not static, it's used elsewhere (via 'extern'). */
	41	struct sr_session *session;
	42
	43	/**
	44	* Create a new session.
	45	*
	46	* TODO: Should it use the file-global "session" variable or take an argument?
	47	* The same question applies to all the other session functions.
	48	*
	49	* @return A pointer to the newly allocated session, or NULL upon errors.
	50	*/
	51	SR_API struct sr_session *sr_session_new(void)
	52	{
	53	if (!(session = g_try_malloc0(sizeof(struct sr_session)))) {
	54	sr_err("session: %s: session malloc failed", __func__);
	55	return NULL; /* TODO: SR_ERR_MALLOC? */
	56	}
	57
	58	session->source_timeout = -1;
	59
	60	return session;
	61	}
	62
	63	/**
	64	* Destroy the current session.
	65	*
	66	* This frees up all memory used by the session.
	67	*
	68	* @return SR_OK upon success, SR_ERR_BUG if no session exists.
	69	*/
	70	SR_API int sr_session_destroy(void)
	71	{
	72	if (!session) {
	73	sr_err("session: %s: session was NULL", __func__);
	74	return SR_ERR_BUG;
	75	}
	76
	77	sr_session_dev_remove_all();
	78
	79	/* TODO: Error checks needed? */
	80
	81	/* TODO: Loop over protocol decoders and free them. */
	82
	83	g_free(session);
	84	session = NULL;
	85
	86	return SR_OK;
	87	}
	88
	89	static void sr_dev_close(struct sr_dev *dev)
	90	{
	91	if (dev->driver->dev_close)
	92	dev->driver->dev_close(dev->driver_index);
	93	}
	94
	95	/**
	96	* Remove all the devices from the current session. TODO?
	97	*
	98	* The session itself (i.e., the struct sr_session) is not free'd and still
	99	* exists after this function returns.
	100	*
	101	* @return SR_OK upon success, SR_ERR_BUG if no session exists.
	102	*/
	103	SR_API int sr_session_dev_remove_all(void)
	104	{
	105	if (!session) {
	106	sr_err("session: %s: session was NULL", __func__);
	107	return SR_ERR_BUG;
	108	}
	109
	110	g_slist_free_full(session->devs, (GDestroyNotify)sr_dev_close);
	111	session->devs = NULL;
	112
	113	return SR_OK;
	114	}
	115
	116	/**
	117	* Add a device to the current session.
	118	*
	119	* @param dev The device to add to the current session. Must not be NULL.
	120	* Also, dev->driver and dev->driver->dev_open must not be NULL.
	121	*
	122	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
	123	*/
	124	SR_API int sr_session_dev_add(struct sr_dev *dev)
	125	{
	126	int ret;
	127
	128	if (!dev) {
	129	sr_err("session: %s: dev was NULL", __func__);
	130	return SR_ERR_ARG;
	131	}
	132
	133	if (!session) {
	134	sr_err("session: %s: session was NULL", __func__);
	135	return SR_ERR_BUG;
	136	}
	137
	138	/* If dev->driver is NULL, this is a virtual device. */
	139	if (!dev->driver) {
	140	sr_dbg("session: %s: dev->driver was NULL, this seems to be "
	141	"a virtual device; continuing", __func__);
	142	/* Just add the device, don't run dev_open(). */
	143	session->devs = g_slist_append(session->devs, dev);
	144	return SR_OK;
	145	}
	146
	147	/* dev->driver is non-NULL (i.e. we have a real device). */
	148	if (!dev->driver->dev_open) {
	149	sr_err("session: %s: dev->driver->dev_open was NULL",
	150	__func__);
	151	return SR_ERR_BUG;
	152	}
	153
	154	if ((ret = dev->driver->dev_open(dev->driver_index)) != SR_OK) {
	155	sr_err("session: %s: dev_open failed (%d)", __func__, ret);
	156	return ret;
	157	}
	158
	159	session->devs = g_slist_append(session->devs, dev);
	160
	161	return SR_OK;
	162	}
	163
	164	/**
	165	* Remove all datafeed callbacks in the current session.
	166	*
	167	* @return SR_OK upon success, SR_ERR_BUG if no session exists.
	168	*/
	169	SR_API int sr_session_datafeed_callback_remove_all(void)
	170	{
	171	if (!session) {
	172	sr_err("session: %s: session was NULL", __func__);
	173	return SR_ERR_BUG;
	174	}
	175
	176	g_slist_free(session->datafeed_callbacks);
	177	session->datafeed_callbacks = NULL;
	178
	179	return SR_OK;
	180	}
	181
	182	/**
	183	* Add a datafeed callback to the current session.
	184	*
	185	* @param cb Function to call when a chunk of data is received.
	186	* Must not be NULL.
	187	*
	188	* @return SR_OK upon success, SR_ERR_BUG if no session exists.
	189	*/
	190	SR_API int sr_session_datafeed_callback_add(sr_datafeed_callback_t cb)
	191	{
	192	if (!session) {
	193	sr_err("session: %s: session was NULL", __func__);
	194	return SR_ERR_BUG;
	195	}
	196
	197	if (!cb) {
	198	sr_err("session: %s: cb was NULL", __func__);
	199	return SR_ERR_ARG;
	200	}
	201
	202	session->datafeed_callbacks =
	203	g_slist_append(session->datafeed_callbacks, cb);
	204
	205	return SR_OK;
	206	}
	207
	208	/**
	209	* TODO.
	210	*/
	211	static int sr_session_run_poll(void)
	212	{
	213	unsigned int i;
	214	int ret;
	215
	216	while (session->running) {
	217	ret = g_poll(session->pollfds, session->num_sources, session->source_timeout);
	218
	219	for (i = 0; i < session->num_sources; i++) {
	220	if (session->pollfds[i].revents > 0 \|\| (ret == 0
	221	&& session->source_timeout == session->sources[i].timeout)) {
	222	/*
	223	* Invoke the source's callback on an event,
	224	* or if the poll timeout out and this source
	225	* asked for that timeout.
	226	*/
	227	if (!session->sources[i].cb(session->pollfds[i].fd, session->pollfds[i].revents,
	228	session->sources[i].cb_data))
	229	sr_session_source_remove(session->sources[i].poll_object);
	230	}
	231	}
	232	}
	233
	234	return SR_OK;
	235	}
	236
	237	/**
	238	* Start a session.
	239	*
	240	* There can only be one session at a time.
	241	*
	242	* @return SR_OK upon success, SR_ERR upon errors.
	243	*/
	244	SR_API int sr_session_start(void)
	245	{
	246	struct sr_dev *dev;
	247	GSList *l;
	248	int ret;
	249
	250	if (!session) {
	251	sr_err("session: %s: session was NULL; a session must be "
	252	"created first, before starting it.", __func__);
	253	return SR_ERR_BUG;
	254	}
	255
	256	if (!session->devs) {
	257	/* TODO: Actually the case? */
	258	sr_err("session: %s: session->devs was NULL; a session "
	259	"cannot be started without devices.", __func__);
	260	return SR_ERR_BUG;
	261	}
	262
	263	/* TODO: Check driver_index validity? */
	264
	265	sr_info("session: starting");
	266
	267	for (l = session->devs; l; l = l->next) {
	268	dev = l->data;
	269	/* TODO: Check for dev != NULL. */
	270	if ((ret = dev->driver->dev_acquisition_start(
	271	dev->driver_index, dev)) != SR_OK) {
	272	sr_err("session: %s: could not start an acquisition "
	273	"(%d)", __func__, ret);
	274	break;
	275	}
	276	}
	277
	278	/* TODO: What if there are multiple devices? Which return code? */
	279
	280	return ret;
	281	}
	282
	283	/**
	284	* Run the session.
	285	*
	286	* TODO: Various error checks etc.
	287	*
	288	* @return SR_OK upon success, SR_ERR_BUG upon errors.
	289	*/
	290	SR_API int sr_session_run(void)
	291	{
	292	if (!session) {
	293	sr_err("session: %s: session was NULL; a session must be "
	294	"created first, before running it.", __func__);
	295	return SR_ERR_BUG;
	296	}
	297
	298	if (!session->devs) {
	299	/* TODO: Actually the case? */
	300	sr_err("session: %s: session->devs was NULL; a session "
	301	"cannot be run without devices.", __func__);
	302	return SR_ERR_BUG;
	303	}
	304
	305	sr_info("session: running");
	306	session->running = TRUE;
	307
	308	/* Do we have real sources? */
	309	if (session->num_sources == 1 && session->pollfds[0].fd == -1) {
	310	/* Dummy source, freewheel over it. */
	311	while (session->running)
	312	session->sources[0].cb(-1, 0, session->sources[0].cb_data);
	313	} else {
	314	/* Real sources, use g_poll() main loop. */
	315	sr_session_run_poll();
	316	}
	317
	318	return SR_OK;
	319	}
	320
	321	/**
	322	* Halt the current session.
	323	*
	324	* This requests the current session be stopped as soon as possible, for
	325	* example on receiving an SR_DF_END packet.
	326	*
	327	* @return SR_OK upon success, SR_ERR_BUG if no session exists.
	328	*/
	329	SR_API int sr_session_halt(void)
	330	{
	331	if (!session) {
	332	sr_err("session: %s: session was NULL", __func__);
	333	return SR_ERR_BUG;
	334	}
	335
	336	sr_info("session: halting");
	337	session->running = FALSE;
	338
	339	return SR_OK;
	340	}
	341
	342	/**
	343	* Stop the current session.
	344	*
	345	* The current session is stopped immediately, with all acquisition sessions
	346	* being stopped and hardware drivers cleaned up.
	347	*
	348	* @return SR_OK upon success, SR_ERR_BUG if no session exists.
	349	*/
	350	SR_API int sr_session_stop(void)
	351	{
	352	struct sr_dev *dev;
	353	GSList *l;
	354
	355	if (!session) {
	356	sr_err("session: %s: session was NULL", __func__);
	357	return SR_ERR_BUG;
	358	}
	359
	360	sr_info("session: stopping");
	361	session->running = FALSE;
	362
	363	for (l = session->devs; l; l = l->next) {
	364	dev = l->data;
	365	/* Check for dev != NULL. */
	366	if (dev->driver) {
	367	if (dev->driver->dev_acquisition_stop)
	368	dev->driver->dev_acquisition_stop(dev->driver_index, dev);
	369	}
	370	}
	371
	372	return SR_OK;
	373	}
	374
	375	/**
	376	* Debug helper.
	377	*
	378	* @param packet The packet to show debugging information for.
	379	*/
	380	static void datafeed_dump(struct sr_datafeed_packet *packet)
	381	{
	382	struct sr_datafeed_logic *logic;
	383	struct sr_datafeed_analog *analog;
	384
	385	switch (packet->type) {
	386	case SR_DF_HEADER:
	387	sr_dbg("bus: received SR_DF_HEADER");
	388	break;
	389	case SR_DF_TRIGGER:
	390	sr_dbg("bus: received SR_DF_TRIGGER");
	391	break;
	392	case SR_DF_META_LOGIC:
	393	sr_dbg("bus: received SR_DF_META_LOGIC");
	394	break;
	395	case SR_DF_LOGIC:
	396	logic = packet->payload;
	397	/* TODO: Check for logic != NULL. */
	398	sr_dbg("bus: received SR_DF_LOGIC %" PRIu64 " bytes", logic->length);
	399	break;
	400	case SR_DF_META_ANALOG:
	401	sr_dbg("bus: received SR_DF_META_LOGIC");
	402	break;
	403	case SR_DF_ANALOG:
	404	analog = packet->payload;
	405	/* TODO: Check for analog != NULL. */
	406	sr_dbg("bus: received SR_DF_ANALOG %d samples", analog->num_samples);
	407	break;
	408	case SR_DF_END:
	409	sr_dbg("bus: received SR_DF_END");
	410	break;
	411	case SR_DF_FRAME_BEGIN:
	412	sr_dbg("bus: received SR_DF_FRAME_BEGIN");
	413	break;
	414	case SR_DF_FRAME_END:
	415	sr_dbg("bus: received SR_DF_FRAME_END");
	416	break;
	417	default:
	418	sr_dbg("bus: received unknown packet type %d", packet->type);
	419	break;
	420	}
	421	}
	422
	423	/**
	424	* Send a packet to whatever is listening on the datafeed bus.
	425	*
	426	* Hardware drivers use this to send a data packet to the frontend.
	427	*
	428	* @param dev TODO.
	429	* @param packet The datafeed packet to send to the session bus.
	430	*
	431	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
	432	*/
	433	SR_PRIV int sr_session_send(struct sr_dev *dev,
	434	struct sr_datafeed_packet *packet)
	435	{
	436	GSList *l;
	437	sr_datafeed_callback_t cb;
	438
	439	if (!dev) {
	440	sr_err("session: %s: dev was NULL", __func__);
	441	return SR_ERR_ARG;
	442	}
	443
	444	if (!packet) {
	445	sr_err("session: %s: packet was NULL", __func__);
	446	return SR_ERR_ARG;
	447	}
	448
	449	for (l = session->datafeed_callbacks; l; l = l->next) {
	450	if (sr_log_loglevel_get() >= SR_LOG_DBG)
	451	datafeed_dump(packet);
	452	cb = l->data;
	453	/* TODO: Check for cb != NULL. */
	454	cb(dev, packet);
	455	}
	456
	457	return SR_OK;
	458	}
	459
	460	static int _sr_session_source_add(GPollFD *pollfd, int timeout,
	461	sr_receive_data_callback_t cb, void *cb_data, gintptr poll_object)
	462	{
	463	struct source new_sources, s;
	464	GPollFD *new_pollfds;
	465
	466	if (!cb) {
	467	sr_err("session: %s: cb was NULL", __func__);
	468	return SR_ERR_ARG;
	469	}
	470
	471	/* Note: cb_data can be NULL, that's not a bug. */
	472
	473	new_pollfds = g_try_realloc(session->pollfds, sizeof(GPollFD) * (session->num_sources + 1));
	474	if (!new_pollfds) {
	475	sr_err("session: %s: new_pollfds malloc failed", __func__);
	476	return SR_ERR_MALLOC;
	477	}
	478
	479	new_sources = g_try_realloc(session->sources, sizeof(struct source) *
	480	(session->num_sources + 1));
	481	if (!new_sources) {
	482	sr_err("session: %s: new_sources malloc failed", __func__);
	483	return SR_ERR_MALLOC;
	484	}
	485
	486	new_pollfds[session->num_sources] = *pollfd;
	487	s = &new_sources[session->num_sources++];
	488	s->timeout = timeout;
	489	s->cb = cb;
	490	s->cb_data = cb_data;
	491	s->poll_object = poll_object;
	492	session->pollfds = new_pollfds;
	493	session->sources = new_sources;
	494
	495	if (timeout != session->source_timeout && timeout > 0
	496	&& (session->source_timeout == -1 \|\| timeout < session->source_timeout))
	497	session->source_timeout = timeout;
	498
	499	return SR_OK;
	500	}
	501
	502	/**
	503	* Add a event source for a file descriptor.
	504	*
	505	* @param fd The file descriptor.
	506	* @param events Events to check for.
	507	* @param timeout Max time to wait before the callback is called, ignored if 0.
	508	* @param cb Callback function to add. Must not be NULL.
	509	* @param cb_data Data for the callback function. Can be NULL.
	510	*
	511	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
	512	* SR_ERR_MALLOC upon memory allocation errors.
	513	*/
	514	SR_API int sr_session_source_add(int fd, int events, int timeout,
	515	sr_receive_data_callback_t cb, void *cb_data)
	516	{
	517	GPollFD p;
	518
	519	p.fd = fd;
	520	p.events = events;
	521
	522	return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)fd);
	523	}
	524
	525	/**
	526	* Add an event source for a GPollFD.
	527	*
	528	* TODO: More error checks etc.
	529	*
	530	* @param pollfd The GPollFD.
	531	* @param timeout Max time to wait before the callback is called, ignored if 0.
	532	* @param cb Callback function to add. Must not be NULL.
	533	* @param cb_data Data for the callback function. Can be NULL.
	534	*
	535	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
	536	* SR_ERR_MALLOC upon memory allocation errors.
	537	*/
	538	SR_API int sr_session_source_add_pollfd(GPollFD *pollfd, int timeout,
	539	sr_receive_data_callback_t cb, void *cb_data)
	540	{
	541	return _sr_session_source_add(pollfd, timeout, cb,
	542	cb_data, (gintptr)pollfd);
	543	}
	544
	545	/**
	546	* Add an event source for a GIOChannel.
	547	*
	548	* TODO: More error checks etc.
	549	*
	550	* @param channel The GIOChannel.
	551	* @param events Events to poll on.
	552	* @param timeout Max time to wait before the callback is called, ignored if 0.
	553	* @param cb Callback function to add. Must not be NULL.
	554	* @param cb_data Data for the callback function. Can be NULL.
	555	*
	556	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
	557	* SR_ERR_MALLOC upon memory allocation errors.
	558	*/
	559	SR_API int sr_session_source_add_channel(GIOChannel *channel, int events,
	560	int timeout, sr_receive_data_callback_t cb, void *cb_data)
	561	{
	562	GPollFD p;
	563
	564	#ifdef _WIN32
	565	g_io_channel_win32_make_pollfd(channel,
	566	events, &p);
	567	#else
	568	p.fd = g_io_channel_unix_get_fd(channel);
	569	p.events = events;
	570	#endif
	571
	572	return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)channel);
	573	}
	574
	575
	576	static int _sr_session_source_remove(gintptr poll_object)
	577	{
	578	struct source *new_sources;
	579	GPollFD *new_pollfds;
	580	unsigned int old;
	581
	582	if (!session->sources \|\| !session->num_sources) {
	583	sr_err("session: %s: sources was NULL", __func__);
	584	return SR_ERR_BUG;
	585	}
	586
	587	for (old = 0; old < session->num_sources; old++) {
	588	if (session->sources[old].poll_object == poll_object)
	589	break;
	590	}
	591
	592	/* fd not found, nothing to do */
	593	if (old == session->num_sources)
	594	return SR_OK;
	595
	596	session->num_sources -= 1;
	597
	598	if (old != session->num_sources) {
	599	memmove(&session->pollfds[old], &session->pollfds[old+1],
	600	(session->num_sources - old) * sizeof(GPollFD));
	601	memmove(&session->sources[old], &session->sources[old+1],
	602	(session->num_sources - old) * sizeof(struct source));
	603	}
	604
	605	new_pollfds = g_try_realloc(session->pollfds, sizeof(GPollFD) * session->num_sources);
	606	if (!new_pollfds && session->num_sources > 0) {
	607	sr_err("session: %s: new_pollfds malloc failed", __func__);
	608	return SR_ERR_MALLOC;
	609	}
	610
	611	new_sources = g_try_realloc(session->sources, sizeof(struct source) * session->num_sources);
	612	if (!new_sources && session->num_sources > 0) {
	613	sr_err("session: %s: new_sources malloc failed", __func__);
	614	return SR_ERR_MALLOC;
	615	}
	616
	617	session->pollfds = new_pollfds;
	618	session->sources = new_sources;
	619
	620	return SR_OK;
	621	}
	622
	623	/*
	624	* Remove the source belonging to the specified file descriptor.
	625	*
	626	* TODO: More error checks.
	627	*
	628	* @param fd The file descriptor for which the source should be removed.
	629	*
	630	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
	631	* SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
	632	* internal errors.
	633	*/
	634	SR_API int sr_session_source_remove(int fd)
	635	{
	636	return _sr_session_source_remove((gintptr)fd);
	637	}
	638
	639	/**
	640	* Remove the source belonging to the specified poll descriptor.
	641	*
	642	* TODO: More error checks.
	643	*
	644	* @param pollfd The poll descriptor for which the source should be removed.
	645	*
	646	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
	647	* SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
	648	* internal errors.
	649	*/
	650	SR_API int sr_session_source_remove_pollfd(GPollFD *pollfd)
	651	{
	652	return _sr_session_source_remove((gintptr)pollfd);
	653	}
	654
	655	/*
	656	* Remove the source belonging to the specified channel.
	657	*
	658	* TODO: More error checks.
	659	*
	660	* @param channel The channel for which the source should be removed.
	661	*
	662	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
	663	* SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
	664	* internal errors.
	665	*/
	666	SR_API int sr_session_source_remove_channel(GIOChannel *channel)
	667	{
	668	return _sr_session_source_remove((gintptr)channel);
	669	}