libsigrok  0.3.0
sigrok hardware access and backend library
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
session.c
Go to the documentation of this file.
1 /*
2  * This file is part of the libsigrok 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 /** @cond PRIVATE */
29 #define LOG_PREFIX "session"
30 /** @endcond */
31 
32 /**
33  * @file
34  *
35  * Creating, using, or destroying libsigrok sessions.
36  */
37 
38 /**
39  * @defgroup grp_session Session handling
40  *
41  * Creating, using, or destroying libsigrok sessions.
42  *
43  * @{
44  */
45 
46 struct source {
47  int timeout;
49  void *cb_data;
50 
51  /* This is used to keep track of the object (fd, pollfd or channel) which is
52  * being polled and will be used to match the source when removing it again.
53  */
54  gintptr poll_object;
55 };
56 
57 struct datafeed_callback {
59  void *cb_data;
60 };
61 
62 /* There can only be one session at a time. */
63 /* 'session' is not static, it's used elsewhere (via 'extern'). */
65 
66 /**
67  * Create a new session.
68  *
69  * @todo Should it use the file-global "session" variable or take an argument?
70  * The same question applies to all the other session functions.
71  *
72  * @retval NULL Error.
73  * @retval other A pointer to the newly allocated session.
74  *
75  * @since 0.1.0
76  */
78 {
79  if (!(session = g_try_malloc0(sizeof(struct sr_session)))) {
80  sr_err("Session malloc failed.");
81  return NULL;
82  }
83 
84  session->source_timeout = -1;
85  session->running = FALSE;
86  session->abort_session = FALSE;
87  g_mutex_init(&session->stop_mutex);
88 
89  return session;
90 }
91 
92 /**
93  * Destroy the current session.
94  * This frees up all memory used by the session.
95  *
96  * @retval SR_OK Success.
97  * @retval SR_ERR_BUG No session exists.
98  *
99  * @since 0.1.0
100  */
102 {
103  if (!session) {
104  sr_err("%s: session was NULL", __func__);
105  return SR_ERR_BUG;
106  }
107 
109 
110  /* TODO: Error checks needed? */
111 
112  g_mutex_clear(&session->stop_mutex);
113 
114  g_free(session);
115  session = NULL;
116 
117  return SR_OK;
118 }
119 
120 /**
121  * Remove all the devices from the current session.
122  *
123  * The session itself (i.e., the struct sr_session) is not free'd and still
124  * exists after this function returns.
125  *
126  * @retval SR_OK Success.
127  * @retval SR_ERR_BUG No session exists.
128  *
129  * @since 0.1.0
130  */
132 {
133  if (!session) {
134  sr_err("%s: session was NULL", __func__);
135  return SR_ERR_BUG;
136  }
137 
138  g_slist_free(session->devs);
139  session->devs = NULL;
140 
141  return SR_OK;
142 }
143 
144 /**
145  * Add a device instance to the current session.
146  *
147  * @param sdi The device instance to add to the current session. Must not
148  * be NULL. Also, sdi->driver and sdi->driver->dev_open must
149  * not be NULL.
150  *
151  * @retval SR_OK Success.
152  * @retval SR_ERR_ARG Invalid argument.
153  * @retval SR_ERR_BUG No session exists.
154  *
155  * @since 0.2.0
156  */
157 SR_API int sr_session_dev_add(const struct sr_dev_inst *sdi)
158 {
159  int ret;
160 
161  if (!sdi) {
162  sr_err("%s: sdi was NULL", __func__);
163  return SR_ERR_ARG;
164  }
165 
166  if (!session) {
167  sr_err("%s: session was NULL", __func__);
168  return SR_ERR_BUG;
169  }
170 
171  /* If sdi->driver is NULL, this is a virtual device. */
172  if (!sdi->driver) {
173  sr_dbg("%s: sdi->driver was NULL, this seems to be "
174  "a virtual device; continuing", __func__);
175  /* Just add the device, don't run dev_open(). */
176  session->devs = g_slist_append(session->devs, (gpointer)sdi);
177  return SR_OK;
178  }
179 
180  /* sdi->driver is non-NULL (i.e. we have a real device). */
181  if (!sdi->driver->dev_open) {
182  sr_err("%s: sdi->driver->dev_open was NULL", __func__);
183  return SR_ERR_BUG;
184  }
185 
186  session->devs = g_slist_append(session->devs, (gpointer)sdi);
187 
188  if (session->running) {
189  /* Adding a device to a running session. Commit settings
190  * and start acquisition on that device now. */
191  if ((ret = sr_config_commit(sdi)) != SR_OK) {
192  sr_err("Failed to commit device settings before "
193  "starting acquisition in running session (%s)",
194  sr_strerror(ret));
195  return ret;
196  }
197  if ((ret = sdi->driver->dev_acquisition_start(sdi,
198  (void *)sdi)) != SR_OK) {
199  sr_err("Failed to start acquisition of device in "
200  "running session (%s)", sr_strerror(ret));
201  return ret;
202  }
203  }
204 
205  return SR_OK;
206 }
207 
208 /**
209  * List all device instances attached to the current session.
210  *
211  * @param devlist A pointer where the device instance list will be
212  * stored on return. If no devices are in the session,
213  * this will be NULL. Each element in the list points
214  * to a struct sr_dev_inst *.
215  * The list must be freed by the caller, but not the
216  * elements pointed to.
217  *
218  * @retval SR_OK Success.
219  * @retval SR_ERR Invalid argument.
220  *
221  * @since 0.3.0
222  */
223 SR_API int sr_session_dev_list(GSList **devlist)
224 {
225 
226  *devlist = NULL;
227 
228  if (!session)
229  return SR_ERR;
230 
231  *devlist = g_slist_copy(session->devs);
232 
233  return SR_OK;
234 }
235 
236 /**
237  * Remove all datafeed callbacks in the current session.
238  *
239  * @retval SR_OK Success.
240  * @retval SR_ERR_BUG No session exists.
241  *
242  * @since 0.1.0
243  */
245 {
246  if (!session) {
247  sr_err("%s: session was NULL", __func__);
248  return SR_ERR_BUG;
249  }
250 
251  g_slist_free_full(session->datafeed_callbacks, g_free);
252  session->datafeed_callbacks = NULL;
253 
254  return SR_OK;
255 }
256 
257 /**
258  * Add a datafeed callback to the current session.
259  *
260  * @param cb Function to call when a chunk of data is received.
261  * Must not be NULL.
262  * @param cb_data Opaque pointer passed in by the caller.
263  *
264  * @retval SR_OK Success.
265  * @retval SR_ERR_BUG No session exists.
266  *
267  * @since 0.3.0
268  */
270 {
271  struct datafeed_callback *cb_struct;
272 
273  if (!session) {
274  sr_err("%s: session was NULL", __func__);
275  return SR_ERR_BUG;
276  }
277 
278  if (!cb) {
279  sr_err("%s: cb was NULL", __func__);
280  return SR_ERR_ARG;
281  }
282 
283  if (!(cb_struct = g_try_malloc0(sizeof(struct datafeed_callback))))
284  return SR_ERR_MALLOC;
285 
286  cb_struct->cb = cb;
287  cb_struct->cb_data = cb_data;
288 
289  session->datafeed_callbacks =
290  g_slist_append(session->datafeed_callbacks, cb_struct);
291 
292  return SR_OK;
293 }
294 
295 /**
296  * Call every device in the session's callback.
297  *
298  * For sessions not driven by select loops such as sr_session_run(),
299  * but driven by another scheduler, this can be used to poll the devices
300  * from within that scheduler.
301  *
302  * @param block If TRUE, this call will wait for any of the session's
303  * sources to fire an event on the file descriptors, or
304  * any of their timeouts to activate. In other words, this
305  * can be used as a select loop.
306  * If FALSE, all sources have their callback run, regardless
307  * of file descriptor or timeout status.
308  *
309  * @retval SR_OK Success.
310  * @retval SR_ERR Error occured.
311  */
312 static int sr_session_iteration(gboolean block)
313 {
314  unsigned int i;
315  int ret;
316 
317  ret = g_poll(session->pollfds, session->num_sources,
318  block ? session->source_timeout : 0);
319  for (i = 0; i < session->num_sources; i++) {
320  if (session->pollfds[i].revents > 0 || (ret == 0
321  && session->source_timeout == session->sources[i].timeout)) {
322  /*
323  * Invoke the source's callback on an event,
324  * or if the poll timed out and this source
325  * asked for that timeout.
326  */
327  if (!session->sources[i].cb(session->pollfds[i].fd,
328  session->pollfds[i].revents,
329  session->sources[i].cb_data))
330  sr_session_source_remove(session->sources[i].poll_object);
331  }
332  /*
333  * We want to take as little time as possible to stop
334  * the session if we have been told to do so. Therefore,
335  * we check the flag after processing every source, not
336  * just once per main event loop.
337  */
338  g_mutex_lock(&session->stop_mutex);
339  if (session->abort_session) {
340  sr_session_stop_sync();
341  /* But once is enough. */
342  session->abort_session = FALSE;
343  }
344  g_mutex_unlock(&session->stop_mutex);
345  }
346 
347  return SR_OK;
348 }
349 
350 /**
351  * Start a session.
352  *
353  * There can only be one session at a time.
354  *
355  * @retval SR_OK Success.
356  * @retval SR_ERR Error occured.
357  *
358  * @since 0.1.0
359  */
361 {
362  struct sr_dev_inst *sdi;
363  GSList *l;
364  int ret;
365 
366  if (!session) {
367  sr_err("%s: session was NULL; a session must be "
368  "created before starting it.", __func__);
369  return SR_ERR_BUG;
370  }
371 
372  if (!session->devs) {
373  sr_err("%s: session->devs was NULL; a session "
374  "cannot be started without devices.", __func__);
375  return SR_ERR_BUG;
376  }
377 
378  sr_info("Starting.");
379 
380  ret = SR_OK;
381  for (l = session->devs; l; l = l->next) {
382  sdi = l->data;
383  if ((ret = sr_config_commit(sdi)) != SR_OK) {
384  sr_err("Failed to commit device settings before "
385  "starting acquisition (%s)", sr_strerror(ret));
386  break;
387  }
388  if ((ret = sdi->driver->dev_acquisition_start(sdi, sdi)) != SR_OK) {
389  sr_err("%s: could not start an acquisition "
390  "(%s)", __func__, sr_strerror(ret));
391  break;
392  }
393  }
394 
395  /* TODO: What if there are multiple devices? Which return code? */
396 
397  return ret;
398 }
399 
400 /**
401  * Run the session.
402  *
403  * @retval SR_OK Success.
404  * @retval SR_ERR_BUG Error occured.
405  *
406  * @since 0.1.0
407  */
409 {
410  if (!session) {
411  sr_err("%s: session was NULL; a session must be "
412  "created first, before running it.", __func__);
413  return SR_ERR_BUG;
414  }
415 
416  if (!session->devs) {
417  /* TODO: Actually the case? */
418  sr_err("%s: session->devs was NULL; a session "
419  "cannot be run without devices.", __func__);
420  return SR_ERR_BUG;
421  }
422  session->running = TRUE;
423 
424  sr_info("Running.");
425 
426  /* Do we have real sources? */
427  if (session->num_sources == 1 && session->pollfds[0].fd == -1) {
428  /* Dummy source, freewheel over it. */
429  while (session->num_sources)
430  session->sources[0].cb(-1, 0, session->sources[0].cb_data);
431  } else {
432  /* Real sources, use g_poll() main loop. */
433  while (session->num_sources)
434  sr_session_iteration(TRUE);
435  }
436 
437  return SR_OK;
438 }
439 
440 /**
441  * Stop the current session.
442  *
443  * The current session is stopped immediately, with all acquisition sessions
444  * being stopped and hardware drivers cleaned up.
445  *
446  * This must be called from within the session thread, to prevent freeing
447  * resources that the session thread will try to use.
448  *
449  * @retval SR_OK Success.
450  * @retval SR_ERR_BUG No session exists.
451  *
452  * @private
453  */
454 SR_PRIV int sr_session_stop_sync(void)
455 {
456  struct sr_dev_inst *sdi;
457  GSList *l;
458 
459  if (!session) {
460  sr_err("%s: session was NULL", __func__);
461  return SR_ERR_BUG;
462  }
463 
464  sr_info("Stopping.");
465 
466  for (l = session->devs; l; l = l->next) {
467  sdi = l->data;
468  if (sdi->driver) {
469  if (sdi->driver->dev_acquisition_stop)
470  sdi->driver->dev_acquisition_stop(sdi, sdi);
471  }
472  }
473  session->running = FALSE;
474 
475  return SR_OK;
476 }
477 
478 /**
479  * Stop the current session.
480  *
481  * The current session is stopped immediately, with all acquisition sessions
482  * being stopped and hardware drivers cleaned up.
483  *
484  * If the session is run in a separate thread, this function will not block
485  * until the session is finished executing. It is the caller's responsibility
486  * to wait for the session thread to return before assuming that the session is
487  * completely decommissioned.
488  *
489  * @retval SR_OK Success.
490  * @retval SR_ERR_BUG No session exists.
491  *
492  * @since 0.1.0
493  */
495 {
496  if (!session) {
497  sr_err("%s: session was NULL", __func__);
498  return SR_ERR_BUG;
499  }
500 
501  g_mutex_lock(&session->stop_mutex);
502  session->abort_session = TRUE;
503  g_mutex_unlock(&session->stop_mutex);
504 
505  return SR_OK;
506 }
507 
508 /**
509  * Debug helper.
510  *
511  * @param packet The packet to show debugging information for.
512  */
513 static void datafeed_dump(const struct sr_datafeed_packet *packet)
514 {
515  const struct sr_datafeed_logic *logic;
516  const struct sr_datafeed_analog *analog;
517 
518  switch (packet->type) {
519  case SR_DF_HEADER:
520  sr_dbg("bus: Received SR_DF_HEADER packet.");
521  break;
522  case SR_DF_TRIGGER:
523  sr_dbg("bus: Received SR_DF_TRIGGER packet.");
524  break;
525  case SR_DF_META:
526  sr_dbg("bus: Received SR_DF_META packet.");
527  break;
528  case SR_DF_LOGIC:
529  logic = packet->payload;
530  sr_dbg("bus: Received SR_DF_LOGIC packet (%" PRIu64 " bytes, "
531  "unitsize = %d).", logic->length, logic->unitsize);
532  break;
533  case SR_DF_ANALOG:
534  analog = packet->payload;
535  sr_dbg("bus: Received SR_DF_ANALOG packet (%d samples).",
536  analog->num_samples);
537  break;
538  case SR_DF_END:
539  sr_dbg("bus: Received SR_DF_END packet.");
540  break;
541  case SR_DF_FRAME_BEGIN:
542  sr_dbg("bus: Received SR_DF_FRAME_BEGIN packet.");
543  break;
544  case SR_DF_FRAME_END:
545  sr_dbg("bus: Received SR_DF_FRAME_END packet.");
546  break;
547  default:
548  sr_dbg("bus: Received unknown packet type: %d.", packet->type);
549  break;
550  }
551 }
552 
553 /**
554  * Send a packet to whatever is listening on the datafeed bus.
555  *
556  * Hardware drivers use this to send a data packet to the frontend.
557  *
558  * @param sdi TODO.
559  * @param packet The datafeed packet to send to the session bus.
560  *
561  * @retval SR_OK Success.
562  * @retval SR_ERR_ARG Invalid argument.
563  *
564  * @private
565  */
566 SR_PRIV int sr_session_send(const struct sr_dev_inst *sdi,
567  const struct sr_datafeed_packet *packet)
568 {
569  GSList *l;
570  struct datafeed_callback *cb_struct;
571 
572  if (!sdi) {
573  sr_err("%s: sdi was NULL", __func__);
574  return SR_ERR_ARG;
575  }
576 
577  if (!packet) {
578  sr_err("%s: packet was NULL", __func__);
579  return SR_ERR_ARG;
580  }
581 
582  for (l = session->datafeed_callbacks; l; l = l->next) {
584  datafeed_dump(packet);
585  cb_struct = l->data;
586  cb_struct->cb(sdi, packet, cb_struct->cb_data);
587  }
588 
589  return SR_OK;
590 }
591 
592 /**
593  * Add an event source for a file descriptor.
594  *
595  * @param pollfd The GPollFD.
596  * @param[in] timeout Max time to wait before the callback is called,
597  * ignored if 0.
598  * @param cb Callback function to add. Must not be NULL.
599  * @param cb_data Data for the callback function. Can be NULL.
600  * @param poll_object TODO.
601  *
602  * @retval SR_OK Success.
603  * @retval SR_ERR_ARG Invalid argument.
604  * @retval SR_ERR_MALLOC Memory allocation error.
605  */
606 static int _sr_session_source_add(GPollFD *pollfd, int timeout,
607  sr_receive_data_callback cb, void *cb_data, gintptr poll_object)
608 {
609  struct source *new_sources, *s;
610  GPollFD *new_pollfds;
611 
612  if (!cb) {
613  sr_err("%s: cb was NULL", __func__);
614  return SR_ERR_ARG;
615  }
616 
617  /* Note: cb_data can be NULL, that's not a bug. */
618 
619  new_pollfds = g_try_realloc(session->pollfds,
620  sizeof(GPollFD) * (session->num_sources + 1));
621  if (!new_pollfds) {
622  sr_err("%s: new_pollfds malloc failed", __func__);
623  return SR_ERR_MALLOC;
624  }
625 
626  new_sources = g_try_realloc(session->sources, sizeof(struct source) *
627  (session->num_sources + 1));
628  if (!new_sources) {
629  sr_err("%s: new_sources malloc failed", __func__);
630  return SR_ERR_MALLOC;
631  }
632 
633  new_pollfds[session->num_sources] = *pollfd;
634  s = &new_sources[session->num_sources++];
635  s->timeout = timeout;
636  s->cb = cb;
637  s->cb_data = cb_data;
638  s->poll_object = poll_object;
639  session->pollfds = new_pollfds;
640  session->sources = new_sources;
641 
642  if (timeout != session->source_timeout && timeout > 0
643  && (session->source_timeout == -1 || timeout < session->source_timeout))
644  session->source_timeout = timeout;
645 
646  return SR_OK;
647 }
648 
649 /**
650  * Add an event source for a file descriptor.
651  *
652  * @param fd The file descriptor.
653  * @param events Events to check for.
654  * @param timeout Max time to wait before the callback is called, ignored if 0.
655  * @param cb Callback function to add. Must not be NULL.
656  * @param cb_data Data for the callback function. Can be NULL.
657  *
658  * @retval SR_OK Success.
659  * @retval SR_ERR_ARG Invalid argument.
660  * @retval SR_ERR_MALLOC Memory allocation error.
661  *
662  * @since 0.3.0
663  */
664 SR_API int sr_session_source_add(int fd, int events, int timeout,
665  sr_receive_data_callback cb, void *cb_data)
666 {
667  GPollFD p;
668 
669  p.fd = fd;
670  p.events = events;
671 
672  return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)fd);
673 }
674 
675 /**
676  * Add an event source for a GPollFD.
677  *
678  * @param pollfd The GPollFD.
679  * @param timeout Max time to wait before the callback is called, ignored if 0.
680  * @param cb Callback function to add. Must not be NULL.
681  * @param cb_data Data for the callback function. Can be NULL.
682  *
683  * @retval SR_OK Success.
684  * @retval SR_ERR_ARG Invalid argument.
685  * @retval SR_ERR_MALLOC Memory allocation error.
686  *
687  * @since 0.3.0
688  */
689 SR_API int sr_session_source_add_pollfd(GPollFD *pollfd, int timeout,
690  sr_receive_data_callback cb, void *cb_data)
691 {
692  return _sr_session_source_add(pollfd, timeout, cb,
693  cb_data, (gintptr)pollfd);
694 }
695 
696 /**
697  * Add an event source for a GIOChannel.
698  *
699  * @param channel The GIOChannel.
700  * @param events Events to poll on.
701  * @param timeout Max time to wait before the callback is called, ignored if 0.
702  * @param cb Callback function to add. Must not be NULL.
703  * @param cb_data Data for the callback function. Can be NULL.
704  *
705  * @retval SR_OK Success.
706  * @retval SR_ERR_ARG Invalid argument.
707  * @retval SR_ERR_MALLOC Memory allocation error.
708  *
709  * @since 0.3.0
710  */
711 SR_API int sr_session_source_add_channel(GIOChannel *channel, int events,
712  int timeout, sr_receive_data_callback cb, void *cb_data)
713 {
714  GPollFD p;
715 
716 #ifdef _WIN32
717  g_io_channel_win32_make_pollfd(channel, events, &p);
718 #else
719  p.fd = g_io_channel_unix_get_fd(channel);
720  p.events = events;
721 #endif
722 
723  return _sr_session_source_add(&p, timeout, cb, cb_data, (gintptr)channel);
724 }
725 
726 /**
727  * Remove the source belonging to the specified channel.
728  *
729  * @todo Add more error checks and logging.
730  *
731  * @param poll_object The channel for which the source should be removed.
732  *
733  * @retval SR_OK Success
734  * @retval SR_ERR_ARG Invalid arguments
735  * @retval SR_ERR_MALLOC Memory allocation error
736  * @retval SR_ERR_BUG Internal error
737  */
738 static int _sr_session_source_remove(gintptr poll_object)
739 {
740  struct source *new_sources;
741  GPollFD *new_pollfds;
742  unsigned int old;
743 
744  if (!session->sources || !session->num_sources) {
745  sr_err("%s: sources was NULL", __func__);
746  return SR_ERR_BUG;
747  }
748 
749  for (old = 0; old < session->num_sources; old++) {
750  if (session->sources[old].poll_object == poll_object)
751  break;
752  }
753 
754  /* fd not found, nothing to do */
755  if (old == session->num_sources)
756  return SR_OK;
757 
758  session->num_sources -= 1;
759 
760  if (old != session->num_sources) {
761  memmove(&session->pollfds[old], &session->pollfds[old+1],
762  (session->num_sources - old) * sizeof(GPollFD));
763  memmove(&session->sources[old], &session->sources[old+1],
764  (session->num_sources - old) * sizeof(struct source));
765  }
766 
767  new_pollfds = g_try_realloc(session->pollfds, sizeof(GPollFD) * session->num_sources);
768  if (!new_pollfds && session->num_sources > 0) {
769  sr_err("%s: new_pollfds malloc failed", __func__);
770  return SR_ERR_MALLOC;
771  }
772 
773  new_sources = g_try_realloc(session->sources, sizeof(struct source) * session->num_sources);
774  if (!new_sources && session->num_sources > 0) {
775  sr_err("%s: new_sources malloc failed", __func__);
776  return SR_ERR_MALLOC;
777  }
778 
779  session->pollfds = new_pollfds;
780  session->sources = new_sources;
781 
782  return SR_OK;
783 }
784 
785 /**
786  * Remove the source belonging to the specified file descriptor.
787  *
788  * @param fd The file descriptor for which the source should be removed.
789  *
790  * @retval SR_OK Success
791  * @retval SR_ERR_ARG Invalid argument
792  * @retval SR_ERR_MALLOC Memory allocation error.
793  * @retval SR_ERR_BUG Internal error.
794  *
795  * @since 0.3.0
796  */
798 {
799  return _sr_session_source_remove((gintptr)fd);
800 }
801 
802 /**
803  * Remove the source belonging to the specified poll descriptor.
804  *
805  * @param pollfd The poll descriptor for which the source should be removed.
806  *
807  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
808  * SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
809  * internal errors.
810  *
811  * @since 0.2.0
812  */
814 {
815  return _sr_session_source_remove((gintptr)pollfd);
816 }
817 
818 /**
819  * Remove the source belonging to the specified channel.
820  *
821  * @param channel The channel for which the source should be removed.
822  *
823  * @retval SR_OK Success.
824  * @retval SR_ERR_ARG Invalid argument.
825  * @retval SR_ERR_MALLOC Memory allocation error.
826  * @return SR_ERR_BUG Internal error.
827  *
828  * @since 0.2.0
829  */
830 SR_API int sr_session_source_remove_channel(GIOChannel *channel)
831 {
832  return _sr_session_source_remove((gintptr)channel);
833 }
834 
835 /** @} */
Generic/unspecified error.
Definition: libsigrok.h:68
struct sr_session * session
Definition: session.c:64
End of frame.
Definition: libsigrok.h:168
Packet in a sigrok data feed.
Definition: libsigrok.h:318
Payload is struct sr_datafeed_meta.
Definition: libsigrok.h:158
int sr_session_dev_add(const struct sr_dev_inst *sdi)
Add a device instance to the current session.
Definition: session.c:157
Payload is struct sr_datafeed_analog.
Definition: libsigrok.h:164
Payload is struct sr_datafeed_logic.
Definition: libsigrok.h:162
No error.
Definition: libsigrok.h:67
int(* dev_open)(struct sr_dev_inst *sdi)
Open device.
Definition: libsigrok.h:945
int sr_session_stop(void)
Stop the current session.
Definition: session.c:494
The public libsigrok header file to be used by frontends.
int sr_session_start(void)
Start a session.
Definition: session.c:360
int sr_session_destroy(void)
Destroy the current session.
Definition: session.c:101
End of stream (no further data).
Definition: libsigrok.h:156
int sr_session_run(void)
Run the session.
Definition: session.c:408
Analog datafeed payload for type SR_DF_ANALOG.
Definition: libsigrok.h:342
The trigger matched at this point in the data feed.
Definition: libsigrok.h:160
int num_samples
Number of samples in data.
Definition: libsigrok.h:346
int sr_config_commit(const struct sr_dev_inst *sdi)
Apply configuration settings to the device hardware.
Definition: hwdriver.c:679
int sr_session_datafeed_callback_add(sr_datafeed_callback cb, void *cb_data)
Add a datafeed callback to the current session.
Definition: session.c:269
uint16_t unitsize
Definition: libsigrok.h:337
int(* dev_acquisition_stop)(struct sr_dev_inst *sdi, void *cb_data)
End data acquisition on the specified device.
Definition: libsigrok.h:952
Device instance data.
Definition: libsigrok.h:841
int sr_session_source_add_pollfd(GPollFD *pollfd, int timeout, sr_receive_data_callback cb, void *cb_data)
Add an event source for a GPollFD.
Definition: session.c:689
int sr_log_loglevel_get(void)
Get the libsigrok loglevel.
Definition: log.c:104
Opaque data structure representing a libsigrok session.
int(* dev_acquisition_start)(const struct sr_dev_inst *sdi, void *cb_data)
Begin data acquisition on the specified device.
Definition: libsigrok.h:949
int(* sr_receive_data_callback)(int fd, int revents, void *cb_data)
Type definition for callback function for data reception.
Definition: libsigrok.h:135
int sr_session_source_add_channel(GIOChannel *channel, int events, int timeout, sr_receive_data_callback cb, void *cb_data)
Add an event source for a GIOChannel.
Definition: session.c:711
Malloc/calloc/realloc error.
Definition: libsigrok.h:69
#define SR_PRIV
Definition: libsigrok.h:129
int sr_session_source_remove_pollfd(GPollFD *pollfd)
Remove the source belonging to the specified poll descriptor.
Definition: session.c:813
void(* sr_datafeed_callback)(const struct sr_dev_inst *sdi, const struct sr_datafeed_packet *packet, void *cb_data)
Definition: proto.h:83
Payload is sr_datafeed_header.
Definition: libsigrok.h:154
uint64_t length
Definition: libsigrok.h:336
int sr_session_source_remove_channel(GIOChannel *channel)
Remove the source belonging to the specified channel.
Definition: session.c:830
Output debug messages.
Definition: libsigrok.h:100
Logic datafeed payload for type SR_DF_LOGIC.
Definition: libsigrok.h:335
Function argument error.
Definition: libsigrok.h:70
int sr_session_source_remove(int fd)
Remove the source belonging to the specified file descriptor.
Definition: session.c:797
const void * payload
Definition: libsigrok.h:320
struct sr_dev_driver * driver
Device driver.
Definition: libsigrok.h:843
const char * sr_strerror(int error_code)
Return a human-readable error string for the given libsigrok error code.
Definition: error.c:53
struct sr_session * sr_session_new(void)
Create a new session.
Definition: session.c:77
int sr_session_datafeed_callback_remove_all(void)
Remove all datafeed callbacks in the current session.
Definition: session.c:244
Beginning of frame.
Definition: libsigrok.h:166
int sr_session_dev_list(GSList **devlist)
List all device instances attached to the current session.
Definition: session.c:223
Errors hinting at internal bugs.
Definition: libsigrok.h:71
int sr_session_source_add(int fd, int events, int timeout, sr_receive_data_callback cb, void *cb_data)
Add an event source for a file descriptor.
Definition: session.c:664
int sr_session_dev_remove_all(void)
Remove all the devices from the current session.
Definition: session.c:131
#define SR_API
Definition: libsigrok.h:122