libsigrok  0.5.0
sigrok hardware access and backend library
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
device.c
Go to the documentation of this file.
1 /*
2  * This file is part of the libsigrok project.
3  *
4  * Copyright (C) 2013 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 <config.h>
21 #include <stdio.h>
22 #include <glib.h>
23 #include <libsigrok/libsigrok.h>
24 #include "libsigrok-internal.h"
25 
26 /** @cond PRIVATE */
27 #define LOG_PREFIX "device"
28 /** @endcond */
29 
30 /**
31  * @file
32  *
33  * Device handling in libsigrok.
34  */
35 
36 /**
37  * @defgroup grp_devices Devices
38  *
39  * Device handling in libsigrok.
40  *
41  * @{
42  */
43 
44 /**
45  * Allocate and initialize a new struct sr_channel and add it to sdi.
46  *
47  * @param[in] sdi The device instance the channel is connected to.
48  * Must not be NULL.
49  * @param[in] index @copydoc sr_channel::index
50  * @param[in] type @copydoc sr_channel::type
51  * @param[in] enabled @copydoc sr_channel::enabled
52  * @param[in] name @copydoc sr_channel::name
53  *
54  * @return A new struct sr_channel*.
55  *
56  * @private
57  */
58 SR_PRIV struct sr_channel *sr_channel_new(struct sr_dev_inst *sdi,
59  int index, int type, gboolean enabled, const char *name)
60 {
61  struct sr_channel *ch;
62 
63  ch = g_malloc0(sizeof(struct sr_channel));
64  ch->sdi = sdi;
65  ch->index = index;
66  ch->type = type;
67  ch->enabled = enabled;
68  if (name)
69  ch->name = g_strdup(name);
70 
71  sdi->channels = g_slist_append(sdi->channels, ch);
72 
73  return ch;
74 }
75 
76 /**
77  * Set the name of the specified channel.
78  *
79  * If the channel already has a different name assigned to it, it will be
80  * removed, and the new name will be saved instead.
81  *
82  * @param[in] channel The channel whose name to set. Must not be NULL.
83  * @param[in] name The new name that the specified channel should get.
84  * A copy of the string is made.
85  *
86  * @return SR_OK on success, or SR_ERR_ARG on invalid arguments.
87  *
88  * @since 0.3.0
89  */
91  const char *name)
92 {
93  if (!channel)
94  return SR_ERR_ARG;
95 
96  g_free(channel->name);
97  channel->name = g_strdup(name);
98 
99  return SR_OK;
100 }
101 
102 /**
103  * Enable or disable a channel.
104  *
105  * @param[in] channel The channel to enable or disable. Must not be NULL.
106  * @param[in] state TRUE to enable the channel, FALSE to disable.
107  *
108  * @return SR_OK on success or SR_ERR on failure. In case of invalid
109  * arguments, SR_ERR_ARG is returned and the channel enabled state
110  * remains unchanged.
111  *
112  * @since 0.3.0
113  */
114 SR_API int sr_dev_channel_enable(struct sr_channel *channel, gboolean state)
115 {
116  int ret;
117  gboolean was_enabled;
118  struct sr_dev_inst *sdi;
119 
120  if (!channel)
121  return SR_ERR_ARG;
122 
123  sdi = channel->sdi;
124  was_enabled = channel->enabled;
125  channel->enabled = state;
126  if (!state != !was_enabled && sdi->driver
127  && sdi->driver->config_channel_set) {
128  ret = sdi->driver->config_channel_set(
129  sdi, channel, SR_CHANNEL_SET_ENABLED);
130  /* Roll back change if it wasn't applicable. */
131  if (ret != SR_OK)
132  return ret;
133  }
134 
135  return SR_OK;
136 }
137 
138 /* Returns the next enabled channel, wrapping around if necessary. */
139 /** @private */
140 SR_PRIV struct sr_channel *sr_next_enabled_channel(const struct sr_dev_inst *sdi,
141 
142  struct sr_channel *cur_channel)
143 {
144  struct sr_channel *next_channel;
145  GSList *l;
146 
147  next_channel = cur_channel;
148  do {
149  l = g_slist_find(sdi->channels, next_channel);
150  if (l && l->next)
151  next_channel = l->next->data;
152  else
153  next_channel = sdi->channels->data;
154  } while (!next_channel->enabled);
155 
156  return next_channel;
157 }
158 
159 /**
160  * Determine whether the specified device instance has the specified
161  * capability.
162  *
163  * @param sdi Pointer to the device instance to be checked. Must not be NULL.
164  * If the device's 'driver' field is NULL (virtual device), this
165  * function will always return FALSE (virtual devices don't have
166  * a hardware capabilities list).
167  * @param[in] key The option that should be checked for is supported by the
168  * specified device.
169  *
170  * @retval TRUE Device has the specified option.
171  * @retval FALSE Device does not have the specified option, invalid input
172  * parameters or other error conditions.
173  *
174  * @since 0.2.0
175  */
176 SR_API gboolean sr_dev_has_option(const struct sr_dev_inst *sdi, int key)
177 {
178  GVariant *gvar;
179  const int *devopts;
180  gsize num_opts, i;
181  int ret;
182 
183  if (!sdi || !sdi->driver || !sdi->driver->config_list)
184  return FALSE;
185 
186  if (sdi->driver->config_list(SR_CONF_DEVICE_OPTIONS,
187  &gvar, sdi, NULL) != SR_OK)
188  return FALSE;
189 
190  ret = FALSE;
191  devopts = g_variant_get_fixed_array(gvar, &num_opts, sizeof(int32_t));
192  for (i = 0; i < num_opts; i++) {
193  if ((devopts[i] & SR_CONF_MASK) == key) {
194  ret = TRUE;
195  break;
196  }
197  }
198  g_variant_unref(gvar);
199 
200  return ret;
201 }
202 
203 /**
204  * Enumerate the configuration options of the specified item.
205  *
206  * @param driver Pointer to the driver to be checked. Must not be NULL.
207  * @param sdi Pointer to the device instance to be checked. May be NULL to
208  * check driver options.
209  * @param cg Pointer to a channel group, if a specific channel group is to
210  * be checked. Must be NULL to check device-wide options.
211  *
212  * @return A GArray * of enum sr_configkey values, or NULL on invalid
213  * arguments. The array must be freed by the caller using
214  * g_array_free().
215  *
216  * @since 0.4.0
217  */
218 SR_API GArray *sr_dev_options(const struct sr_dev_driver *driver,
219  const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
220 {
221  GVariant *gvar;
222  const uint32_t *opts;
223  uint32_t opt;
224  gsize num_opts, i;
225  GArray *result;
226 
227  if (!driver || !driver->config_list)
228  return NULL;
229 
230  if (sdi && sdi->driver != driver)
231  return NULL;
232 
233  if (driver->config_list(SR_CONF_DEVICE_OPTIONS, &gvar, sdi, cg) != SR_OK)
234  return NULL;
235 
236  opts = g_variant_get_fixed_array(gvar, &num_opts, sizeof(uint32_t));
237 
238  result = g_array_sized_new(FALSE, FALSE, sizeof(uint32_t), num_opts);
239 
240  for (i = 0; i < num_opts; i++) {
241  opt = opts[i] & SR_CONF_MASK;
242  g_array_insert_val(result, i, opt);
243  }
244 
245  g_variant_unref(gvar);
246 
247  return result;
248 }
249 
250 /**
251  * Enumerate the configuration capabilities supported by a device instance
252  * for a given configuration key.
253  *
254  * @param sdi Pointer to the device instance to be checked. Must not be NULL.
255  * If the device's 'driver' field is NULL (virtual device), this
256  * function will always return FALSE (virtual devices don't have
257  * a hardware capabilities list).
258  * @param cg Pointer to a channel group, if a specific channel group is to
259  * be checked. Must be NULL to check device-wide options.
260  * @param[in] key The option that should be checked for is supported by the
261  * specified device.
262  *
263  * @retval A bitmask of enum sr_configcap values, which will be zero for
264  * invalid inputs or if the key is unsupported.
265  *
266  * @since 0.4.0
267  */
268 SR_API int sr_dev_config_capabilities_list(const struct sr_dev_inst *sdi,
269  const struct sr_channel_group *cg, const int key)
270 {
271  GVariant *gvar;
272  const int *devopts;
273  gsize num_opts, i;
274  int ret;
275 
276  if (!sdi || !sdi->driver || !sdi->driver->config_list)
277  return 0;
278 
279  if (sdi->driver->config_list(SR_CONF_DEVICE_OPTIONS,
280  &gvar, sdi, cg) != SR_OK)
281  return 0;
282 
283  ret = 0;
284  devopts = g_variant_get_fixed_array(gvar, &num_opts, sizeof(int32_t));
285  for (i = 0; i < num_opts; i++) {
286  if ((devopts[i] & SR_CONF_MASK) == key) {
287  ret = devopts[i] & ~SR_CONF_MASK;
288  break;
289  }
290  }
291  g_variant_unref(gvar);
292 
293  return ret;
294 }
295 
296 /**
297  * Allocate and init a new user-generated device instance.
298  *
299  * @param vendor Device vendor.
300  * @param model Device model.
301  * @param version Device version.
302  *
303  * @retval struct sr_dev_inst *. Dynamically allocated, free using
304  * sr_dev_inst_free().
305  */
306 SR_API struct sr_dev_inst *sr_dev_inst_user_new(const char *vendor,
307  const char *model, const char *version)
308 {
309  struct sr_dev_inst *sdi;
310 
311  sdi = g_malloc0(sizeof(struct sr_dev_inst));
312 
313  sdi->vendor = g_strdup(vendor);
314  sdi->model = g_strdup(model);
315  sdi->version = g_strdup(version);
316  sdi->inst_type = SR_INST_USER;
317 
318  return sdi;
319 }
320 
321 /**
322  * Add a new channel to the specified device instance.
323  *
324  * @param[in] index @copydoc sr_channel::index
325  * @param[in] type @copydoc sr_channel::type
326  * @param[in] name @copydoc sr_channel::name
327  *
328  * @return SR_OK Success.
329  * @return SR_OK Invalid argument.
330  */
331 SR_API int sr_dev_inst_channel_add(struct sr_dev_inst *sdi, int index, int type, const char *name)
332 {
333  if (!sdi || sdi->inst_type != SR_INST_USER || index < 0)
334  return SR_ERR_ARG;
335 
336  sr_channel_new(sdi, index, type, TRUE, name);
337 
338  return SR_OK;
339 }
340 
341 /**
342  * Free device instance struct created by sr_dev_inst().
343  *
344  * @param sdi Device instance to free. If NULL, the function will do nothing.
345  *
346  * @private
347  */
348 SR_PRIV void sr_dev_inst_free(struct sr_dev_inst *sdi)
349 {
350  struct sr_channel *ch;
351  struct sr_channel_group *cg;
352  GSList *l;
353 
354  if (!sdi)
355  return;
356 
357  for (l = sdi->channels; l; l = l->next) {
358  ch = l->data;
359  g_free(ch->name);
360  g_free(ch->priv);
361  g_free(ch);
362  }
363  g_slist_free(sdi->channels);
364 
365  for (l = sdi->channel_groups; l; l = l->next) {
366  cg = l->data;
367  g_free(cg->name);
368  g_slist_free(cg->channels);
369  g_free(cg->priv);
370  g_free(cg);
371  }
372  g_slist_free(sdi->channel_groups);
373 
374  if (sdi->session)
375  sr_session_dev_remove(sdi->session, sdi);
376 
377  g_free(sdi->vendor);
378  g_free(sdi->model);
379  g_free(sdi->version);
380  g_free(sdi->serial_num);
381  g_free(sdi->connection_id);
382  g_free(sdi);
383 }
384 
385 #ifdef HAVE_LIBUSB_1_0
386 
387 /**
388  * Allocate and init a struct for a USB device instance.
389  *
390  * @param[in] bus @copydoc sr_usb_dev_inst::bus
391  * @param[in] address @copydoc sr_usb_dev_inst::address
392  * @param[in] hdl @copydoc sr_usb_dev_inst::devhdl
393  *
394  * @return The struct sr_usb_dev_inst * for USB device instance.
395  *
396  * @private
397  */
398 SR_PRIV struct sr_usb_dev_inst *sr_usb_dev_inst_new(uint8_t bus,
399  uint8_t address, struct libusb_device_handle *hdl)
400 {
401  struct sr_usb_dev_inst *udi;
402 
403  udi = g_malloc0(sizeof(struct sr_usb_dev_inst));
404  udi->bus = bus;
405  udi->address = address;
406  udi->devhdl = hdl;
407 
408  return udi;
409 }
410 
411 /**
412  * Free struct sr_usb_dev_inst * allocated by sr_usb_dev_inst().
413  *
414  * @param usb The struct sr_usb_dev_inst * to free. If NULL, this
415  * function does nothing.
416  *
417  * @private
418  */
419 SR_PRIV void sr_usb_dev_inst_free(struct sr_usb_dev_inst *usb)
420 {
421  g_free(usb);
422 }
423 
424 #endif
425 
426 #ifdef HAVE_LIBSERIALPORT
427 
428 /**
429  * Allocate and init a struct for a serial device instance.
430  *
431  * Both parameters are copied to newly allocated strings, and freed
432  * automatically by sr_serial_dev_inst_free().
433  *
434  * @param[in] port OS-specific serial port specification. Examples:
435  * "/dev/ttyUSB0", "/dev/ttyACM1", "/dev/tty.Modem-0", "COM1".
436  * Must not be NULL.
437  * @param[in] serialcomm A serial communication parameters string, in the form
438  * of <speed>/<data bits><parity><stopbits>, for example
439  * "9600/8n1" or "600/7o2". This is an optional parameter;
440  * it may be filled in later. Can be NULL.
441  *
442  * @return A pointer to a newly initialized struct sr_serial_dev_inst,
443  * or NULL on error.
444  *
445  * @private
446  */
447 SR_PRIV struct sr_serial_dev_inst *sr_serial_dev_inst_new(const char *port,
448  const char *serialcomm)
449 {
450  struct sr_serial_dev_inst *serial;
451 
452  serial = g_malloc0(sizeof(struct sr_serial_dev_inst));
453  serial->port = g_strdup(port);
454  if (serialcomm)
455  serial->serialcomm = g_strdup(serialcomm);
456 
457  return serial;
458 }
459 
460 /**
461  * Free struct sr_serial_dev_inst * allocated by sr_serial_dev_inst().
462  *
463  * @param serial The struct sr_serial_dev_inst * to free. If NULL, this
464  * function will do nothing.
465  *
466  * @private
467  */
468 SR_PRIV void sr_serial_dev_inst_free(struct sr_serial_dev_inst *serial)
469 {
470  if (!serial)
471  return;
472 
473  g_free(serial->port);
474  g_free(serial->serialcomm);
475  g_free(serial);
476 }
477 #endif
478 
479 /** @private */
480 SR_PRIV struct sr_usbtmc_dev_inst *sr_usbtmc_dev_inst_new(const char *device)
481 {
482  struct sr_usbtmc_dev_inst *usbtmc;
483 
484  usbtmc = g_malloc0(sizeof(struct sr_usbtmc_dev_inst));
485  usbtmc->device = g_strdup(device);
486  usbtmc->fd = -1;
487 
488  return usbtmc;
489 }
490 
491 /** @private */
492 SR_PRIV void sr_usbtmc_dev_inst_free(struct sr_usbtmc_dev_inst *usbtmc)
493 {
494  if (!usbtmc)
495  return;
496 
497  g_free(usbtmc->device);
498  g_free(usbtmc);
499 }
500 
501 /**
502  * Get the list of devices/instances of the specified driver.
503  *
504  * @param driver The driver to use. Must not be NULL.
505  *
506  * @return The list of devices/instances of this driver, or NULL upon errors
507  * or if the list is empty.
508  *
509  * @since 0.2.0
510  */
511 SR_API GSList *sr_dev_list(const struct sr_dev_driver *driver)
512 {
513  if (driver && driver->dev_list)
514  return driver->dev_list(driver);
515  else
516  return NULL;
517 }
518 
519 /**
520  * Clear the list of device instances a driver knows about.
521  *
522  * @param driver The driver to use. This must be a pointer to one of
523  * the entries returned by sr_driver_list(). Must not be NULL.
524  *
525  * @retval SR_OK Success.
526  * @retval SR_ERR_ARG Invalid driver.
527  *
528  * @since 0.2.0
529  */
530 SR_API int sr_dev_clear(const struct sr_dev_driver *driver)
531 {
532  int ret;
533 
534  if (!driver) {
535  sr_err("Invalid driver.");
536  return SR_ERR_ARG;
537  }
538 
539  if (driver->dev_clear)
540  ret = driver->dev_clear(driver);
541  else
542  ret = std_dev_clear(driver, NULL);
543 
544  return ret;
545 }
546 
547 /**
548  * Open the specified device.
549  *
550  * @param sdi Device instance to use. Must not be NULL.
551  *
552  * @return SR_OK upon success, a negative error code upon errors.
553  *
554  * @since 0.2.0
555  */
556 SR_API int sr_dev_open(struct sr_dev_inst *sdi)
557 {
558  int ret;
559 
560  if (!sdi || !sdi->driver || !sdi->driver->dev_open)
561  return SR_ERR;
562 
563  ret = sdi->driver->dev_open(sdi);
564 
565  return ret;
566 }
567 
568 /**
569  * Close the specified device.
570  *
571  * @param sdi Device instance to use. Must not be NULL.
572  *
573  * @return SR_OK upon success, a negative error code upon errors.
574  *
575  * @since 0.2.0
576  */
577 SR_API int sr_dev_close(struct sr_dev_inst *sdi)
578 {
579  int ret;
580 
581  if (!sdi || !sdi->driver || !sdi->driver->dev_close)
582  return SR_ERR;
583 
584  ret = sdi->driver->dev_close(sdi);
585 
586  return ret;
587 }
588 
589 /**
590  * Queries a device instances' driver.
591  *
592  * @param sdi Device instance to use. Must not be NULL.
593  *
594  * @return The driver instance or NULL on error.
595  */
596 SR_API struct sr_dev_driver *sr_dev_inst_driver_get(const struct sr_dev_inst *sdi)
597 {
598  if (!sdi || !sdi->driver)
599  return NULL;
600 
601  return sdi->driver;
602 }
603 
604 /**
605  * Queries a device instances' vendor.
606  *
607  * @param sdi Device instance to use. Must not be NULL.
608  *
609  * @return The vendor string or NULL.
610  */
611 SR_API const char *sr_dev_inst_vendor_get(const struct sr_dev_inst *sdi)
612 {
613  if (!sdi)
614  return NULL;
615 
616  return sdi->vendor;
617 }
618 
619 /**
620  * Queries a device instances' model.
621  *
622  * @param sdi Device instance to use. Must not be NULL.
623  *
624  * @return The model string or NULL.
625  */
626 SR_API const char *sr_dev_inst_model_get(const struct sr_dev_inst *sdi)
627 {
628  if (!sdi)
629  return NULL;
630 
631  return sdi->model;
632 }
633 
634 /**
635  * Queries a device instances' version.
636  *
637  * @param sdi Device instance to use. Must not be NULL.
638  *
639  * @return The version string or NULL.
640  */
641 SR_API const char *sr_dev_inst_version_get(const struct sr_dev_inst *sdi)
642 {
643  if (!sdi)
644  return NULL;
645 
646  return sdi->version;
647 }
648 
649 /**
650  * Queries a device instances' serial number.
651  *
652  * @param sdi Device instance to use. Must not be NULL.
653  *
654  * @return The serial number string or NULL.
655  */
656 SR_API const char *sr_dev_inst_sernum_get(const struct sr_dev_inst *sdi)
657 {
658  if (!sdi)
659  return NULL;
660 
661  return sdi->serial_num;
662 }
663 
664 /**
665  * Queries a device instances' connection identifier.
666  *
667  * @param sdi Device instance to use. Must not be NULL.
668  *
669  * @return A copy of the connection ID string or NULL. The caller is responsible
670  * for g_free()ing the string when it is no longer needed.
671  */
672 SR_API const char *sr_dev_inst_connid_get(const struct sr_dev_inst *sdi)
673 {
674 #ifdef HAVE_LIBUSB_1_0
675  struct drv_context *drvc;
676  int cnt, i, a, b;
677  char connection_id[64];
678  struct sr_usb_dev_inst *usb;
679  struct libusb_device **devlist;
680 #endif
681 
682  if (!sdi)
683  return NULL;
684 
685 #ifdef HAVE_LIBSERIALPORT
686  struct sr_serial_dev_inst *serial;
687 
688  if ((!sdi->connection_id) && (sdi->inst_type == SR_INST_SERIAL)) {
689  /* connection_id isn't populated, let's do that here. */
690 
691  serial = sdi->conn;
692  ((struct sr_dev_inst *)sdi)->connection_id = g_strdup(serial->port);
693  }
694 #endif
695 
696 #ifdef HAVE_LIBUSB_1_0
697  if ((!sdi->connection_id) && (sdi->inst_type == SR_INST_USB)) {
698  /* connection_id isn't populated, let's do that here. */
699 
700  drvc = sdi->driver->context;
701  usb = sdi->conn;
702 
703  if ((cnt = libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist)) < 0) {
704  sr_err("Failed to retrieve device list: %s.",
705  libusb_error_name(cnt));
706  return NULL;
707  }
708 
709  for (i = 0; i < cnt; i++) {
710  /* Find the USB device by the logical address we know. */
711  b = libusb_get_bus_number(devlist[i]);
712  a = libusb_get_device_address(devlist[i]);
713  if (b != usb->bus || a != usb->address)
714  continue;
715 
716  usb_get_port_path(devlist[i], connection_id, sizeof(connection_id));
717  ((struct sr_dev_inst *)sdi)->connection_id = g_strdup(connection_id);
718  break;
719  }
720 
721  libusb_free_device_list(devlist, 1);
722  }
723 #endif
724 
725  return sdi->connection_id;
726 }
727 
728 /**
729  * Queries a device instances' channel list.
730  *
731  * @param sdi Device instance to use. Must not be NULL.
732  *
733  * @return The GSList of channels or NULL.
734  */
735 SR_API GSList *sr_dev_inst_channels_get(const struct sr_dev_inst *sdi)
736 {
737  if (!sdi)
738  return NULL;
739 
740  return sdi->channels;
741 }
742 
743 /**
744  * Queries a device instances' channel groups list.
745  *
746  * @param sdi Device instance to use. Must not be NULL.
747  *
748  * @return The GSList of channel groups or NULL.
749  */
750 SR_API GSList *sr_dev_inst_channel_groups_get(const struct sr_dev_inst *sdi)
751 {
752  if (!sdi)
753  return NULL;
754 
755  return sdi->channel_groups;
756 }
757 
758 /** @} */
Generic/unspecified error.
Definition: libsigrok.h:68
const char * sr_dev_inst_sernum_get(const struct sr_dev_inst *sdi)
Queries a device instances' serial number.
Definition: device.c:656
void * priv
Private data for driver use.
Definition: libsigrok.h:619
int sr_dev_open(struct sr_dev_inst *sdi)
Open the specified device.
Definition: device.c:556
int sr_dev_clear(const struct sr_dev_driver *driver)
Clear the list of device instances a driver knows about.
Definition: device.c:530
gboolean enabled
Is this channel enabled?
Definition: libsigrok.h:605
No error.
Definition: libsigrok.h:67
GSList * sr_dev_inst_channels_get(const struct sr_dev_inst *sdi)
Queries a device instances' channel list.
Definition: device.c:735
int sr_dev_channel_enable(struct sr_channel *channel, gboolean state)
Enable or disable a channel.
Definition: device.c:114
const char * sr_dev_inst_model_get(const struct sr_dev_inst *sdi)
Queries a device instances' model.
Definition: device.c:626
The public libsigrok header file to be used by frontends.
GSList * channels
List of sr_channel structs of the channels belonging to this group.
Definition: libsigrok.h:617
struct sr_dev_inst * sr_dev_inst_user_new(const char *vendor, const char *model, const char *version)
Allocate and init a new user-generated device instance.
Definition: device.c:306
GSList *(* dev_list)(const struct sr_dev_driver *driver)
Get list of device instances the driver knows about.
Definition: libsigrok.h:1124
const char * sr_dev_inst_vendor_get(const struct sr_dev_inst *sdi)
Queries a device instances' vendor.
Definition: device.c:611
int sr_dev_config_capabilities_list(const struct sr_dev_inst *sdi, const struct sr_channel_group *cg, const int key)
Enumerate the configuration capabilities supported by a device instance for a given configuration key...
Definition: device.c:268
void * priv
Private data for driver use.
Definition: libsigrok.h:609
Device-instance type for user-created "devices".
Definition: libsigrok.h:1080
int sr_dev_channel_name_set(struct sr_channel *channel, const char *name)
Set the name of the specified channel.
Definition: device.c:90
const char * sr_dev_inst_connid_get(const struct sr_dev_inst *sdi)
Queries a device instances' connection identifier.
Definition: device.c:672
int(* config_list)(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
List all possible values for a configuration key in a device instance.
Definition: libsigrok.h:1148
const char * sr_dev_inst_version_get(const struct sr_dev_inst *sdi)
Queries a device instances' version.
Definition: device.c:641
int(* dev_clear)(const struct sr_dev_driver *driver)
Clear list of devices the driver knows about.
Definition: libsigrok.h:1126
Structure for groups of channels that have common properties.
Definition: libsigrok.h:613
Device instance type for serial port devices.
Definition: libsigrok.h:1076
int type
Channel type (SR_CHANNEL_LOGIC, ...)
Definition: libsigrok.h:603
#define SR_PRIV
Definition: libsigrok.h:128
GSList * sr_dev_list(const struct sr_dev_driver *driver)
Get the list of devices/instances of the specified driver.
Definition: device.c:511
int sr_dev_inst_channel_add(struct sr_dev_inst *sdi, int index, int type, const char *name)
Add a new channel to the specified device instance.
Definition: device.c:331
char * name
Name of the channel group.
Definition: libsigrok.h:615
char * name
Name of channel.
Definition: libsigrok.h:607
GArray * sr_dev_options(const struct sr_dev_driver *driver, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
Enumerate the configuration options of the specified item.
Definition: device.c:218
struct sr_dev_driver * sr_dev_inst_driver_get(const struct sr_dev_inst *sdi)
Queries a device instances' driver.
Definition: device.c:596
Device driver data.
Definition: libsigrok.h:1100
struct sr_dev_inst * sdi
The device this channel is attached to.
Definition: libsigrok.h:598
Function argument error.
Definition: libsigrok.h:70
int index
The index of this channel, starting at 0.
Definition: libsigrok.h:601
Device instance type for USB devices.
Definition: libsigrok.h:1074
GSList * sr_dev_inst_channel_groups_get(const struct sr_dev_inst *sdi)
Queries a device instances' channel groups list.
Definition: device.c:750
Information on single channel.
Definition: libsigrok.h:596
gboolean sr_dev_has_option(const struct sr_dev_inst *sdi, int key)
Determine whether the specified device instance has the specified capability.
Definition: device.c:176
int sr_dev_close(struct sr_dev_inst *sdi)
Close the specified device.
Definition: device.c:577
int sr_session_dev_remove(struct sr_session *session, struct sr_dev_inst *sdi)
Remove a device instance from a session.
Definition: session.c:420
#define SR_API
Definition: libsigrok.h:121