blob: 266207259ca3c82e9c42c76208af3ae8afb88880 [file] [log] [blame]
Uwe Hermanna1bb33a2010-04-02 20:18:27 +02001/*
Uwe Hermann50985c22013-04-23 22:24:30 +02002 * This file is part of the libsigrok project.
Uwe Hermanna1bb33a2010-04-02 20:18:27 +02003 *
Bert Vermeulenc73d2ea2012-02-13 14:31:51 +01004 * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
Uwe Hermanna1bb33a2010-04-02 20:18:27 +02005 *
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>
Bert Vermeulen544a4582011-01-30 02:40:55 +010024#include <glib.h>
Bert Vermeulen45c59c82012-07-05 00:55:07 +020025#include "libsigrok.h"
26#include "libsigrok-internal.h"
Bert Vermeulenaa4b1102011-01-24 07:46:16 +010027
Uwe Hermanna421dc12013-01-29 12:55:00 +010028/* Message logging helpers with driver-specific prefix string. */
29#define DRIVER_LOG_DOMAIN "session: "
30#define sr_log(l, s, args...) sr_log(l, DRIVER_LOG_DOMAIN s, ## args)
31#define sr_spew(s, args...) sr_spew(DRIVER_LOG_DOMAIN s, ## args)
32#define sr_dbg(s, args...) sr_dbg(DRIVER_LOG_DOMAIN s, ## args)
33#define sr_info(s, args...) sr_info(DRIVER_LOG_DOMAIN s, ## args)
34#define sr_warn(s, args...) sr_warn(DRIVER_LOG_DOMAIN s, ## args)
35#define sr_err(s, args...) sr_err(DRIVER_LOG_DOMAIN s, ## args)
36
Uwe Hermann7b870c32012-10-21 16:13:36 +020037/**
Uwe Hermann393fb9c2012-10-22 00:30:12 +020038 * @file
39 *
40 * Creating, using, or destroying libsigrok sessions.
41 */
42
43/**
Uwe Hermann7b870c32012-10-21 16:13:36 +020044 * @defgroup grp_session Session handling
45 *
46 * Creating, using, or destroying libsigrok sessions.
47 *
48 * @{
49 */
50
Bert Vermeulen544a4582011-01-30 02:40:55 +010051struct source {
Bert Vermeulen544a4582011-01-30 02:40:55 +010052 int timeout;
Uwe Hermannd08490a2012-02-29 21:56:24 +010053 sr_receive_data_callback_t cb;
Uwe Hermann1f9813e2012-02-29 22:32:34 +010054 void *cb_data;
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +020055
56 /* This is used to keep track of the object (fd, pollfd or channel) which is
57 * being polled and will be used to match the source when removing it again.
58 */
59 gintptr poll_object;
Bert Vermeulen544a4582011-01-30 02:40:55 +010060};
61
Martin Ling27264742013-04-15 21:08:55 +010062struct datafeed_callback {
63 sr_datafeed_callback_t cb;
64 void *cb_data;
65};
66
Bert Vermeulen7d658872011-01-31 22:34:14 +010067/* There can only be one session at a time. */
Uwe Hermanna0ecd832011-12-28 22:55:21 +010068/* 'session' is not static, it's used elsewhere (via 'extern'). */
Uwe Hermann2872d212011-02-08 17:50:29 +010069struct sr_session *session;
Bert Vermeulen544a4582011-01-30 02:40:55 +010070
Uwe Hermann9f45fb32012-01-02 14:15:25 +010071/**
72 * Create a new session.
73 *
Uwe Hermann6b2d8d32012-10-21 23:24:42 +020074 * @todo Should it use the file-global "session" variable or take an argument?
Uwe Hermann9f45fb32012-01-02 14:15:25 +010075 * The same question applies to all the other session functions.
76 *
77 * @return A pointer to the newly allocated session, or NULL upon errors.
78 */
Uwe Hermann1a081ca2012-02-01 23:40:35 +010079SR_API struct sr_session *sr_session_new(void)
Uwe Hermanna1bb33a2010-04-02 20:18:27 +020080{
Uwe Hermann133a37b2012-02-11 20:06:46 +010081 if (!(session = g_try_malloc0(sizeof(struct sr_session)))) {
Uwe Hermanna421dc12013-01-29 12:55:00 +010082 sr_err("Session malloc failed.");
83 return NULL;
Uwe Hermann9f45fb32012-01-02 14:15:25 +010084 }
Uwe Hermanna1bb33a2010-04-02 20:18:27 +020085
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +020086 session->source_timeout = -1;
Alexandru Gagniuc33c6e4c2013-02-02 00:50:00 -060087 session->abort_session = FALSE;
88 g_mutex_init(&session->stop_mutex);
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +020089
Uwe Hermanna1bb33a2010-04-02 20:18:27 +020090 return session;
91}
92
Uwe Hermann9f45fb32012-01-02 14:15:25 +010093/**
94 * Destroy the current session.
95 *
96 * This frees up all memory used by the session.
97 *
Uwe Hermanne0508e62012-01-07 17:08:54 +010098 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
Uwe Hermann9f45fb32012-01-02 14:15:25 +010099 */
Uwe Hermann1a081ca2012-02-01 23:40:35 +0100100SR_API int sr_session_destroy(void)
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200101{
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100102 if (!session) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100103 sr_err("%s: session was NULL", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100104 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100105 }
106
Lars-Peter Clausened229aa2012-07-05 21:15:07 +0200107 sr_session_dev_remove_all();
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200108
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100109 /* TODO: Error checks needed? */
110
Alexandru Gagniuc33c6e4c2013-02-02 00:50:00 -0600111 g_mutex_clear(&session->stop_mutex);
112
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200113 g_free(session);
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100114 session = NULL;
Uwe Hermanne0508e62012-01-07 17:08:54 +0100115
116 return SR_OK;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200117}
118
Uwe Hermann961009b2013-02-01 22:58:54 +0100119/**
Uwe Hermann6b2d8d32012-10-21 23:24:42 +0200120 * Remove all the devices from the current session.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100121 *
122 * The session itself (i.e., the struct sr_session) is not free'd and still
123 * exists after this function returns.
124 *
Uwe Hermanne0508e62012-01-07 17:08:54 +0100125 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100126 */
Uwe Hermann01c3e9d2012-03-28 21:55:48 +0200127SR_API int sr_session_dev_remove_all(void)
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200128{
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100129 if (!session) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100130 sr_err("%s: session was NULL", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100131 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100132 }
133
Bert Vermeulen681803d2013-04-28 22:35:42 +0200134 g_slist_free(session->devs);
Uwe Hermannbb7ef792012-02-17 22:25:01 +0100135 session->devs = NULL;
Uwe Hermanne0508e62012-01-07 17:08:54 +0100136
137 return SR_OK;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200138}
139
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100140/**
Uwe Hermann9c5332d2012-10-21 16:52:56 +0200141 * Add a device instance to the current session.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100142 *
Uwe Hermann9c5332d2012-10-21 16:52:56 +0200143 * @param sdi The device instance to add to the current session. Must not
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200144 * be NULL. Also, sdi->driver and sdi->driver->dev_open must
145 * not be NULL.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100146 *
147 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
148 */
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200149SR_API int sr_session_dev_add(const struct sr_dev_inst *sdi)
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200150{
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200151
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200152 if (!sdi) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100153 sr_err("%s: sdi was NULL", __func__);
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100154 return SR_ERR_ARG;
155 }
156
Uwe Hermannd6eb0c32012-03-18 12:57:34 +0100157 if (!session) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100158 sr_err("%s: session was NULL", __func__);
Uwe Hermannd6eb0c32012-03-18 12:57:34 +0100159 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100160 }
161
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200162 /* If sdi->driver is NULL, this is a virtual device. */
163 if (!sdi->driver) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100164 sr_dbg("%s: sdi->driver was NULL, this seems to be "
Uwe Hermannd6eb0c32012-03-18 12:57:34 +0100165 "a virtual device; continuing", __func__);
166 /* Just add the device, don't run dev_open(). */
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200167 session->devs = g_slist_append(session->devs, (gpointer)sdi);
Uwe Hermannd6eb0c32012-03-18 12:57:34 +0100168 return SR_OK;
169 }
170
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200171 /* sdi->driver is non-NULL (i.e. we have a real device). */
172 if (!sdi->driver->dev_open) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100173 sr_err("%s: sdi->driver->dev_open was NULL", __func__);
Uwe Hermann8ec95d22012-03-21 19:28:43 +0100174 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100175 }
176
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200177 session->devs = g_slist_append(session->devs, (gpointer)sdi);
Bert Vermeulenaa4b1102011-01-24 07:46:16 +0100178
Uwe Hermanne46b8fb2011-01-29 16:23:12 +0100179 return SR_OK;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200180}
181
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100182/**
Uwe Hermann01c3e9d2012-03-28 21:55:48 +0200183 * Remove all datafeed callbacks in the current session.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100184 *
Uwe Hermanne0508e62012-01-07 17:08:54 +0100185 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100186 */
Uwe Hermann01c3e9d2012-03-28 21:55:48 +0200187SR_API int sr_session_datafeed_callback_remove_all(void)
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200188{
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100189 if (!session) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100190 sr_err("%s: session was NULL", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100191 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100192 }
193
Martin Ling27264742013-04-15 21:08:55 +0100194 g_slist_free_full(session->datafeed_callbacks, g_free);
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200195 session->datafeed_callbacks = NULL;
Uwe Hermanne0508e62012-01-07 17:08:54 +0100196
197 return SR_OK;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200198}
199
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100200/**
201 * Add a datafeed callback to the current session.
202 *
Uwe Hermannd08490a2012-02-29 21:56:24 +0100203 * @param cb Function to call when a chunk of data is received.
Uwe Hermann0abee502012-03-04 15:08:11 +0100204 * Must not be NULL.
Uwe Hermann85222792013-04-16 12:48:58 +0200205 * @param cb_data Opaque pointer passed in by the caller.
Bert Vermeulena1645fc2012-02-13 03:36:32 +0100206 *
Uwe Hermanne0508e62012-01-07 17:08:54 +0100207 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100208 */
Martin Ling27264742013-04-15 21:08:55 +0100209SR_API int sr_session_datafeed_callback_add(sr_datafeed_callback_t cb, void *cb_data)
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200210{
Martin Ling27264742013-04-15 21:08:55 +0100211 struct datafeed_callback *cb_struct;
212
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100213 if (!session) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100214 sr_err("%s: session was NULL", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100215 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100216 }
217
Uwe Hermann0abee502012-03-04 15:08:11 +0100218 if (!cb) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100219 sr_err("%s: cb was NULL", __func__);
Uwe Hermann0abee502012-03-04 15:08:11 +0100220 return SR_ERR_ARG;
221 }
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100222
Martin Ling27264742013-04-15 21:08:55 +0100223 if (!(cb_struct = g_try_malloc0(sizeof(struct datafeed_callback))))
224 return SR_ERR_MALLOC;
225
226 cb_struct->cb = cb;
227 cb_struct->cb_data = cb_data;
228
Uwe Hermann62c82022010-04-15 20:16:53 +0200229 session->datafeed_callbacks =
Martin Ling27264742013-04-15 21:08:55 +0100230 g_slist_append(session->datafeed_callbacks, cb_struct);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100231
232 return SR_OK;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200233}
234
Uwe Hermanne0508e62012-01-07 17:08:54 +0100235static int sr_session_run_poll(void)
Bert Vermeulen544a4582011-01-30 02:40:55 +0100236{
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200237 unsigned int i;
238 int ret;
Bert Vermeulen544a4582011-01-30 02:40:55 +0100239
Bert Vermeulen2cbeb2b2012-08-03 01:04:05 +0200240 while (session->num_sources > 0) {
241 ret = g_poll(session->pollfds, session->num_sources,
242 session->source_timeout);
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200243 for (i = 0; i < session->num_sources; i++) {
244 if (session->pollfds[i].revents > 0 || (ret == 0
245 && session->source_timeout == session->sources[i].timeout)) {
Bert Vermeulen544a4582011-01-30 02:40:55 +0100246 /*
247 * Invoke the source's callback on an event,
Bert Vermeulen2cbeb2b2012-08-03 01:04:05 +0200248 * or if the poll timed out and this source
Bert Vermeulen544a4582011-01-30 02:40:55 +0100249 * asked for that timeout.
250 */
Bert Vermeulen2cbeb2b2012-08-03 01:04:05 +0200251 if (!session->sources[i].cb(session->pollfds[i].fd,
252 session->pollfds[i].revents,
253 session->sources[i].cb_data))
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200254 sr_session_source_remove(session->sources[i].poll_object);
Bert Vermeulen544a4582011-01-30 02:40:55 +0100255 }
Alexandru Gagniuc33c6e4c2013-02-02 00:50:00 -0600256 /*
257 * We want to take as little time as possible to stop
258 * the session if we have been told to do so. Therefore,
259 * we check the flag after processing every source, not
260 * just once per main event loop.
261 */
262 g_mutex_lock(&session->stop_mutex);
263 if (session->abort_session)
264 sr_session_stop_sync();
265 g_mutex_unlock(&session->stop_mutex);
Bert Vermeulen544a4582011-01-30 02:40:55 +0100266 }
267 }
Uwe Hermanne0508e62012-01-07 17:08:54 +0100268
269 return SR_OK;
Bert Vermeulen544a4582011-01-30 02:40:55 +0100270}
271
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100272/**
273 * Start a session.
274 *
Bert Vermeulena1645fc2012-02-13 03:36:32 +0100275 * There can only be one session at a time.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100276 *
277 * @return SR_OK upon success, SR_ERR upon errors.
278 */
Uwe Hermann1a081ca2012-02-01 23:40:35 +0100279SR_API int sr_session_start(void)
Bert Vermeulen7d658872011-01-31 22:34:14 +0100280{
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200281 struct sr_dev_inst *sdi;
Bert Vermeulen7d658872011-01-31 22:34:14 +0100282 GSList *l;
283 int ret;
284
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100285 if (!session) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100286 sr_err("%s: session was NULL; a session must be "
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200287 "created before starting it.", __func__);
Uwe Hermann0abee502012-03-04 15:08:11 +0100288 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100289 }
290
Uwe Hermannbb7ef792012-02-17 22:25:01 +0100291 if (!session->devs) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100292 sr_err("%s: session->devs was NULL; a session "
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100293 "cannot be started without devices.", __func__);
Uwe Hermann0abee502012-03-04 15:08:11 +0100294 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100295 }
296
Uwe Hermannc7142602013-02-07 09:16:28 +0100297 sr_info("Starting.");
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100298
Uwe Hermannb7c3e842012-12-31 21:05:11 +0100299 ret = SR_OK;
Uwe Hermannbb7ef792012-02-17 22:25:01 +0100300 for (l = session->devs; l; l = l->next) {
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200301 sdi = l->data;
302 if ((ret = sdi->driver->dev_acquisition_start(sdi, sdi)) != SR_OK) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100303 sr_err("%s: could not start an acquisition "
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100304 "(%d)", __func__, ret);
Bert Vermeulen7d658872011-01-31 22:34:14 +0100305 break;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100306 }
Bert Vermeulen7d658872011-01-31 22:34:14 +0100307 }
308
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100309 /* TODO: What if there are multiple devices? Which return code? */
310
Bert Vermeulen7d658872011-01-31 22:34:14 +0100311 return ret;
312}
313
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100314/**
315 * Run the session.
316 *
Uwe Hermanne0508e62012-01-07 17:08:54 +0100317 * @return SR_OK upon success, SR_ERR_BUG upon errors.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100318 */
Uwe Hermann1a081ca2012-02-01 23:40:35 +0100319SR_API int sr_session_run(void)
Bert Vermeulen7d658872011-01-31 22:34:14 +0100320{
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100321 if (!session) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100322 sr_err("%s: session was NULL; a session must be "
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100323 "created first, before running it.", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100324 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100325 }
326
Uwe Hermannbb7ef792012-02-17 22:25:01 +0100327 if (!session->devs) {
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100328 /* TODO: Actually the case? */
Uwe Hermanna421dc12013-01-29 12:55:00 +0100329 sr_err("%s: session->devs was NULL; a session "
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100330 "cannot be run without devices.", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100331 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100332 }
333
Uwe Hermanna421dc12013-01-29 12:55:00 +0100334 sr_info("Running.");
Bert Vermeulen7d658872011-01-31 22:34:14 +0100335
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100336 /* Do we have real sources? */
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200337 if (session->num_sources == 1 && session->pollfds[0].fd == -1) {
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100338 /* Dummy source, freewheel over it. */
Bert Vermeulen2cbeb2b2012-08-03 01:04:05 +0200339 while (session->num_sources)
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200340 session->sources[0].cb(-1, 0, session->sources[0].cb_data);
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100341 } else {
342 /* Real sources, use g_poll() main loop. */
Uwe Hermann8a2efef2011-02-08 18:00:49 +0100343 sr_session_run_poll();
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100344 }
345
Uwe Hermanne0508e62012-01-07 17:08:54 +0100346 return SR_OK;
Bert Vermeulen7d658872011-01-31 22:34:14 +0100347}
348
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100349/**
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100350 * Stop the current session.
351 *
Bert Vermeulena1645fc2012-02-13 03:36:32 +0100352 * The current session is stopped immediately, with all acquisition sessions
Uwe Hermannc09f0b52012-02-28 23:52:30 +0100353 * being stopped and hardware drivers cleaned up.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100354 *
Alexandru Gagniuc33c6e4c2013-02-02 00:50:00 -0600355 * This must be called from within the session thread, to prevent freeing
356 * resources that the session thread will try to use.
357 *
Uwe Hermanne0508e62012-01-07 17:08:54 +0100358 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100359 */
Alexandru Gagniuc33c6e4c2013-02-02 00:50:00 -0600360SR_PRIV int sr_session_stop_sync(void)
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200361{
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200362 struct sr_dev_inst *sdi;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200363 GSList *l;
364
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100365 if (!session) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100366 sr_err("%s: session was NULL", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100367 return SR_ERR_BUG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100368 }
369
Uwe Hermanna421dc12013-01-29 12:55:00 +0100370 sr_info("Stopping.");
Uwe Hermanne0508e62012-01-07 17:08:54 +0100371
Uwe Hermannbb7ef792012-02-17 22:25:01 +0100372 for (l = session->devs; l; l = l->next) {
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200373 sdi = l->data;
374 if (sdi->driver) {
375 if (sdi->driver->dev_acquisition_stop)
376 sdi->driver->dev_acquisition_stop(sdi, sdi);
Bert Vermeulen8c76be52012-01-08 22:05:00 +0100377 }
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200378 }
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100379
Alexandru Gagniucf1f7e622012-12-19 04:15:18 -0600380 /*
381 * Some sources may not be necessarily associated with a device.
382 * Those sources may still be present even after stopping all devices.
383 * We need to make sure all sources are removed, or we risk running the
384 * session in an infinite loop.
385 */
386 while (session->num_sources)
387 sr_session_source_remove(session->sources[0].poll_object);
388
Uwe Hermanne0508e62012-01-07 17:08:54 +0100389 return SR_OK;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200390}
391
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100392/**
Alexandru Gagniuc33c6e4c2013-02-02 00:50:00 -0600393 * Stop the current session.
394 *
395 * The current session is stopped immediately, with all acquisition sessions
396 * being stopped and hardware drivers cleaned up.
397 *
398 * If the session is run in a separate thread, this function will not block
399 * until the session is finished executing. It is the caller's responsibility
400 * to wait for the session thread to return before assuming that the session is
401 * completely decommissioned.
402 *
403 * @return SR_OK upon success, SR_ERR_BUG if no session exists.
404 */
405SR_API int sr_session_stop(void)
406{
407 if (!session) {
408 sr_err("%s: session was NULL", __func__);
409 return SR_ERR_BUG;
410 }
411
412 g_mutex_lock(&session->stop_mutex);
413 session->abort_session = TRUE;
414 g_mutex_unlock(&session->stop_mutex);
415
416 return SR_OK;
417}
418
419/**
Bert Vermeulena1645fc2012-02-13 03:36:32 +0100420 * Debug helper.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100421 *
Bert Vermeulen996b0c72012-02-13 02:13:51 +0100422 * @param packet The packet to show debugging information for.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100423 */
Joel Holdsworthbf534572012-12-13 21:07:53 +0000424static void datafeed_dump(const struct sr_datafeed_packet *packet)
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200425{
Joel Holdsworthbf534572012-12-13 21:07:53 +0000426 const struct sr_datafeed_logic *logic;
427 const struct sr_datafeed_analog *analog;
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200428
429 switch (packet->type) {
430 case SR_DF_HEADER:
Uwe Hermanna421dc12013-01-29 12:55:00 +0100431 sr_dbg("bus: Received SR_DF_HEADER packet.");
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200432 break;
433 case SR_DF_TRIGGER:
Uwe Hermanna421dc12013-01-29 12:55:00 +0100434 sr_dbg("bus: Received SR_DF_TRIGGER packet.");
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200435 break;
Bert Vermeulenc71bac32013-01-20 16:37:23 +0100436 case SR_DF_META:
Uwe Hermanna421dc12013-01-29 12:55:00 +0100437 sr_dbg("bus: Received SR_DF_META packet.");
Bert Vermeulenee7489d2012-04-22 18:11:31 +0200438 break;
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200439 case SR_DF_LOGIC:
440 logic = packet->payload;
Uwe Hermanna421dc12013-01-29 12:55:00 +0100441 sr_dbg("bus: Received SR_DF_LOGIC packet (%" PRIu64 " bytes).",
442 logic->length);
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200443 break;
Bert Vermeulenee7489d2012-04-22 18:11:31 +0200444 case SR_DF_ANALOG:
445 analog = packet->payload;
Uwe Hermanna421dc12013-01-29 12:55:00 +0100446 sr_dbg("bus: Received SR_DF_ANALOG packet (%d samples).",
447 analog->num_samples);
Bert Vermeulenee7489d2012-04-22 18:11:31 +0200448 break;
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200449 case SR_DF_END:
Uwe Hermanna421dc12013-01-29 12:55:00 +0100450 sr_dbg("bus: Received SR_DF_END packet.");
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200451 break;
Bert Vermeulen6ea76692012-04-30 19:55:06 +0200452 case SR_DF_FRAME_BEGIN:
Uwe Hermanna421dc12013-01-29 12:55:00 +0100453 sr_dbg("bus: Received SR_DF_FRAME_BEGIN packet.");
Bert Vermeulen6ea76692012-04-30 19:55:06 +0200454 break;
455 case SR_DF_FRAME_END:
Uwe Hermanna421dc12013-01-29 12:55:00 +0100456 sr_dbg("bus: Received SR_DF_FRAME_END packet.");
Bert Vermeulen6ea76692012-04-30 19:55:06 +0200457 break;
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200458 default:
Uwe Hermanna421dc12013-01-29 12:55:00 +0100459 sr_dbg("bus: Received unknown packet type: %d.", packet->type);
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100460 break;
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200461 }
Bert Vermeulen7d2afd62011-06-20 11:42:43 +0200462}
463
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100464/**
Bert Vermeulena1645fc2012-02-13 03:36:32 +0100465 * Send a packet to whatever is listening on the datafeed bus.
466 *
467 * Hardware drivers use this to send a data packet to the frontend.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100468 *
Uwe Hermann6b2d8d32012-10-21 23:24:42 +0200469 * @param sdi TODO.
Uwe Hermann31ccebc2012-02-29 22:08:45 +0100470 * @param packet The datafeed packet to send to the session bus.
Uwe Hermann44dae532012-02-17 20:44:19 +0100471 *
Uwe Hermanne0508e62012-01-07 17:08:54 +0100472 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
Uwe Hermannb4bd7082012-10-19 10:07:22 +0200473 *
474 * @private
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100475 */
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200476SR_PRIV int sr_session_send(const struct sr_dev_inst *sdi,
Joel Holdsworthbf534572012-12-13 21:07:53 +0000477 const struct sr_datafeed_packet *packet)
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200478{
479 GSList *l;
Martin Ling27264742013-04-15 21:08:55 +0100480 struct datafeed_callback *cb_struct;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200481
Bert Vermeulende4d3f92012-07-22 15:31:56 +0200482 if (!sdi) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100483 sr_err("%s: sdi was NULL", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100484 return SR_ERR_ARG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100485 }
486
Uwe Hermanne0508e62012-01-07 17:08:54 +0100487 if (!packet) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100488 sr_err("%s: packet was NULL", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100489 return SR_ERR_ARG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100490 }
491
Uwe Hermann62c82022010-04-15 20:16:53 +0200492 for (l = session->datafeed_callbacks; l; l = l->next) {
Bert Vermeulen18beaef2012-02-13 00:08:23 +0100493 if (sr_log_loglevel_get() >= SR_LOG_DBG)
494 datafeed_dump(packet);
Martin Ling27264742013-04-15 21:08:55 +0100495 cb_struct = l->data;
496 cb_struct->cb(sdi, packet, cb_struct->cb_data);
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200497 }
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100498
Uwe Hermanne0508e62012-01-07 17:08:54 +0100499 return SR_OK;
Uwe Hermanna1bb33a2010-04-02 20:18:27 +0200500}
501
Uwe Hermann6b2d8d32012-10-21 23:24:42 +0200502/**
503 * Add an event source for a file descriptor.
504 *
505 * @param pollfd The GPollFD.
506 * @param timeout Max time to wait before the callback is called, ignored if 0.
507 * @param cb Callback function to add. Must not be NULL.
508 * @param cb_data Data for the callback function. Can be NULL.
509 * @param poll_object TODO.
510 *
511 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
512 * SR_ERR_MALLOC upon memory allocation errors.
513 */
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200514static int _sr_session_source_add(GPollFD *pollfd, int timeout,
Uwe Hermann1a895c62012-07-05 01:47:44 +0200515 sr_receive_data_callback_t cb, void *cb_data, gintptr poll_object)
Bert Vermeulen544a4582011-01-30 02:40:55 +0100516{
517 struct source *new_sources, *s;
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200518 GPollFD *new_pollfds;
Bert Vermeulen544a4582011-01-30 02:40:55 +0100519
Uwe Hermannd08490a2012-02-29 21:56:24 +0100520 if (!cb) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100521 sr_err("%s: cb was NULL", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100522 return SR_ERR_ARG;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100523 }
524
Uwe Hermann1f9813e2012-02-29 22:32:34 +0100525 /* Note: cb_data can be NULL, that's not a bug. */
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100526
Bert Vermeulen2ac2e622012-07-22 15:32:35 +0200527 new_pollfds = g_try_realloc(session->pollfds,
528 sizeof(GPollFD) * (session->num_sources + 1));
Lars-Peter Clausen0687dfc2012-06-30 20:54:43 +0200529 if (!new_pollfds) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100530 sr_err("%s: new_pollfds malloc failed", __func__);
Lars-Peter Clausen0687dfc2012-06-30 20:54:43 +0200531 return SR_ERR_MALLOC;
532 }
533
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200534 new_sources = g_try_realloc(session->sources, sizeof(struct source) *
Bert Vermeulen2ac2e622012-07-22 15:32:35 +0200535 (session->num_sources + 1));
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100536 if (!new_sources) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100537 sr_err("%s: new_sources malloc failed", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100538 return SR_ERR_MALLOC;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100539 }
Bert Vermeulen544a4582011-01-30 02:40:55 +0100540
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200541 new_pollfds[session->num_sources] = *pollfd;
542 s = &new_sources[session->num_sources++];
Bert Vermeulen544a4582011-01-30 02:40:55 +0100543 s->timeout = timeout;
Uwe Hermannd08490a2012-02-29 21:56:24 +0100544 s->cb = cb;
Uwe Hermann1f9813e2012-02-29 22:32:34 +0100545 s->cb_data = cb_data;
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200546 s->poll_object = poll_object;
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200547 session->pollfds = new_pollfds;
548 session->sources = new_sources;
Bert Vermeulen544a4582011-01-30 02:40:55 +0100549
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200550 if (timeout != session->source_timeout && timeout > 0
551 && (session->source_timeout == -1 || timeout < session->source_timeout))
552 session->source_timeout = timeout;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100553
Uwe Hermanne0508e62012-01-07 17:08:54 +0100554 return SR_OK;
Bert Vermeulen544a4582011-01-30 02:40:55 +0100555}
556
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100557/**
Uwe Hermann6b2d8d32012-10-21 23:24:42 +0200558 * Add an event source for a file descriptor.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100559 *
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200560 * @param fd The file descriptor.
561 * @param events Events to check for.
562 * @param timeout Max time to wait before the callback is called, ignored if 0.
563 * @param cb Callback function to add. Must not be NULL.
564 * @param cb_data Data for the callback function. Can be NULL.
Uwe Hermann44dae532012-02-17 20:44:19 +0100565 *
Uwe Hermanne0508e62012-01-07 17:08:54 +0100566 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200567 * SR_ERR_MALLOC upon memory allocation errors.
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100568 */
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200569SR_API int sr_session_source_add(int fd, int events, int timeout,
570 sr_receive_data_callback_t cb, void *cb_data)
571{
572 GPollFD p;
573
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200574 p.fd = fd;
575 p.events = events;
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200576
577 return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)fd);
578}
579
580/**
Uwe Hermann1a895c62012-07-05 01:47:44 +0200581 * Add an event source for a GPollFD.
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200582 *
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200583 * @param pollfd The GPollFD.
584 * @param timeout Max time to wait before the callback is called, ignored if 0.
585 * @param cb Callback function to add. Must not be NULL.
586 * @param cb_data Data for the callback function. Can be NULL.
587 *
588 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
589 * SR_ERR_MALLOC upon memory allocation errors.
590 */
591SR_API int sr_session_source_add_pollfd(GPollFD *pollfd, int timeout,
592 sr_receive_data_callback_t cb, void *cb_data)
593{
Uwe Hermann1a895c62012-07-05 01:47:44 +0200594 return _sr_session_source_add(pollfd, timeout, cb,
595 cb_data, (gintptr)pollfd);
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200596}
597
598/**
Uwe Hermann1a895c62012-07-05 01:47:44 +0200599 * Add an event source for a GIOChannel.
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200600 *
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200601 * @param channel The GIOChannel.
602 * @param events Events to poll on.
603 * @param timeout Max time to wait before the callback is called, ignored if 0.
604 * @param cb Callback function to add. Must not be NULL.
605 * @param cb_data Data for the callback function. Can be NULL.
606 *
607 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
608 * SR_ERR_MALLOC upon memory allocation errors.
609 */
Uwe Hermann1a895c62012-07-05 01:47:44 +0200610SR_API int sr_session_source_add_channel(GIOChannel *channel, int events,
611 int timeout, sr_receive_data_callback_t cb, void *cb_data)
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200612{
613 GPollFD p;
614
615#ifdef _WIN32
Uwe Hermann6b2d8d32012-10-21 23:24:42 +0200616 g_io_channel_win32_make_pollfd(channel, events, &p);
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200617#else
618 p.fd = g_io_channel_unix_get_fd(channel);
619 p.events = events;
620#endif
621
622 return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)channel);
623}
624
Uwe Hermann6b2d8d32012-10-21 23:24:42 +0200625/**
626 * Remove the source belonging to the specified channel.
627 *
628 * @todo Add more error checks and logging.
629 *
630 * @param channel The channel for which the source should be removed.
631 *
632 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
633 * SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
634 * internal errors.
635 */
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200636static int _sr_session_source_remove(gintptr poll_object)
Bert Vermeulen544a4582011-01-30 02:40:55 +0100637{
638 struct source *new_sources;
Lars-Peter Clausen0687dfc2012-06-30 20:54:43 +0200639 GPollFD *new_pollfds;
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200640 unsigned int old;
Bert Vermeulen544a4582011-01-30 02:40:55 +0100641
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200642 if (!session->sources || !session->num_sources) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100643 sr_err("%s: sources was NULL", __func__);
Uwe Hermann0abee502012-03-04 15:08:11 +0100644 return SR_ERR_BUG;
Uwe Hermanne0508e62012-01-07 17:08:54 +0100645 }
646
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200647 for (old = 0; old < session->num_sources; old++) {
648 if (session->sources[old].poll_object == poll_object)
Lars-Peter Clausen2bccd322012-06-30 20:54:42 +0200649 break;
650 }
Bert Vermeulen544a4582011-01-30 02:40:55 +0100651
Lars-Peter Clausen2bccd322012-06-30 20:54:42 +0200652 /* fd not found, nothing to do */
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200653 if (old == session->num_sources)
Lars-Peter Clausen2bccd322012-06-30 20:54:42 +0200654 return SR_OK;
655
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200656 session->num_sources -= 1;
Lars-Peter Clausen2bccd322012-06-30 20:54:42 +0200657
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200658 if (old != session->num_sources) {
659 memmove(&session->pollfds[old], &session->pollfds[old+1],
660 (session->num_sources - old) * sizeof(GPollFD));
661 memmove(&session->sources[old], &session->sources[old+1],
662 (session->num_sources - old) * sizeof(struct source));
Lars-Peter Clausen2bccd322012-06-30 20:54:42 +0200663 }
664
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200665 new_pollfds = g_try_realloc(session->pollfds, sizeof(GPollFD) * session->num_sources);
666 if (!new_pollfds && session->num_sources > 0) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100667 sr_err("%s: new_pollfds malloc failed", __func__);
Lars-Peter Clausen0687dfc2012-06-30 20:54:43 +0200668 return SR_ERR_MALLOC;
669 }
670
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200671 new_sources = g_try_realloc(session->sources, sizeof(struct source) * session->num_sources);
672 if (!new_sources && session->num_sources > 0) {
Uwe Hermanna421dc12013-01-29 12:55:00 +0100673 sr_err("%s: new_sources malloc failed", __func__);
Uwe Hermanne0508e62012-01-07 17:08:54 +0100674 return SR_ERR_MALLOC;
Uwe Hermann9f45fb32012-01-02 14:15:25 +0100675 }
676
Lars-Peter Clausenb7e94112012-07-06 23:23:31 +0200677 session->pollfds = new_pollfds;
678 session->sources = new_sources;
Uwe Hermanne0508e62012-01-07 17:08:54 +0100679
680 return SR_OK;
Bert Vermeulen544a4582011-01-30 02:40:55 +0100681}
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200682
Uwe Hermann6b2d8d32012-10-21 23:24:42 +0200683/**
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200684 * Remove the source belonging to the specified file descriptor.
685 *
Uwe Hermann1a895c62012-07-05 01:47:44 +0200686 * @param fd The file descriptor for which the source should be removed.
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200687 *
688 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
689 * SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
690 * internal errors.
691 */
692SR_API int sr_session_source_remove(int fd)
693{
694 return _sr_session_source_remove((gintptr)fd);
695}
696
697/**
698 * Remove the source belonging to the specified poll descriptor.
699 *
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200700 * @param pollfd The poll descriptor for which the source should be removed.
701 *
702 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
703 * SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
704 * internal errors.
705 */
706SR_API int sr_session_source_remove_pollfd(GPollFD *pollfd)
707{
708 return _sr_session_source_remove((gintptr)pollfd);
709}
710
Uwe Hermann6b2d8d32012-10-21 23:24:42 +0200711/**
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200712 * Remove the source belonging to the specified channel.
713 *
Uwe Hermann1a895c62012-07-05 01:47:44 +0200714 * @param channel The channel for which the source should be removed.
Lars-Peter Clausenaac0ea22012-06-30 20:54:44 +0200715 *
716 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
717 * SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
718 * internal errors.
719 */
720SR_API int sr_session_source_remove_channel(GIOChannel *channel)
721{
722 return _sr_session_source_remove((gintptr)channel);
723}
Uwe Hermann7b870c32012-10-21 16:13:36 +0200724
725/** @} */