[libsigrok.git] / device.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 <glib.h>
#include "sigrok.h"
#include "sigrok-internal.h"

static GSList *devs = NULL;

/**
 * Scan the system for attached logic analyzers / devices.
 *
 * This will try to autodetect all supported logic analyzer devices:
 *
 *  - Those attached via USB (can be reliably detected via USB VID/PID).
 *
 *  - Those using a (real or virtual) serial port (detected by sending
 *    device-specific commands to all OS-specific serial port devices such
 *    as /dev/ttyS*, /dev/ttyUSB*, /dev/ttyACM*, and others).
 *    The autodetection for this kind of devices can potentially be unreliable.
 *
 *    Also, sending various bytes/commands to (all!) devices which happen to
 *    be attached to the system via a (real or virtual) serial port can be
 *    problematic. There is no way for libsigrok to know how unknown devices
 *    react to the bytes libsigrok sends. Potentially they could lead to the
 *    device getting into invalid/error states, losing/overwriting data, or...
 *
 * In addition to the detection, the devices that are found are also
 * initialized automatically. On some devices, this involves a firmware upload,
 * or other such measures.
 *
 * The order in which the system is scanned for devices is not specified. The
 * caller should not assume or rely on any specific order.
 *
 * After the system has been scanned for devices, the list of detected (and
 * supported) devices can be acquired via sr_dev_list().
 *
 * TODO: Error checks?
 * TODO: Option to only scan for specific devices or device classes.
 *
 * @return SR_OK upon success, SR_ERR_BUG upon internal errors.
 */
SR_API int sr_dev_scan(void)
{
	int i;
	struct sr_dev_driver **drivers;

	drivers = sr_driver_list();
	if (!drivers[0]) {
		sr_err("dev: %s: no supported hardware drivers", __func__);
		return SR_ERR_BUG;
	}

	/*
	 * Initialize all drivers first. Since the init() call may involve
	 * a firmware upload and associated delay, we may as well get all
	 * of these out of the way first.
	 */
	for (i = 0; drivers[i]; i++)
		sr_driver_init(drivers[i]);

	return SR_OK;
}

/**
 * Return the list of logic analyzer devices libsigrok has detected.
 *
 * If the libsigrok-internal device list is empty, a scan for attached
 * devices -- via a call to sr_dev_scan() -- is performed first.
 *
 * TODO: Error handling?
 *
 * @return The list (GSList) of detected devices, or NULL if none were found.
 */
SR_API GSList *sr_dev_list(void)
{
	if (!devs)
		sr_dev_scan();

	return devs;
}

/**
 * Create a new device.
 *
 * The device is added to the (libsigrok-internal) list of devices, but
 * additionally a pointer to the newly created device is also returned.
 *
 * The device has no probes attached to it yet after this call. You can
 * use sr_dev_probe_add() to add one or more probes.
 *
 * TODO: Should return int, so that we can return SR_OK, SR_ERR_* etc.
 *
 * It is the caller's responsibility to g_free() the allocated memory when
 * no longer needed. TODO: Using which API function?
 *
 * @param driver TODO.
 *               If 'driver' is NULL, the created device is a "virtual" one.
 * @param driver_index TODO
 *
 * @return Pointer to the newly allocated device, or NULL upon errors.
 */
SR_API struct sr_dev *sr_dev_new(const struct sr_dev_driver *driver,
				 int driver_index)
{
	struct sr_dev *dev;

	/* TODO: Check if driver_index valid? */

	if (!(dev = g_try_malloc0(sizeof(struct sr_dev)))) {
		sr_err("dev: %s: dev malloc failed", __func__);
		return NULL;
	}

	dev->driver = (struct sr_dev_driver *)driver;
	dev->driver_index = driver_index;
	devs = g_slist_append(devs, dev);

	return dev;
}

/**
 * Add a probe with the specified name to the specified device.
 *
 * The added probe is automatically enabled (the 'enabled' field is TRUE).
 *
 * The 'trigger' field of the added probe is set to NULL. A trigger can be
 * added via sr_dev_trigger_set().
 *
 * TODO: Are duplicate names allowed?
 * TODO: Do we enforce a maximum probe number for a device?
 * TODO: Error if the max. probe number for the specific LA is reached, e.g.
 *       if the caller tries to add more probes than the device actually has.
 *
 * @param dev The device to which to add a probe with the specified name.
 *            Must not be NULL.
 * @param name The name of the probe to add to this device. Must not be NULL.
 *             TODO: Maximum length, allowed characters, etc.
 *
 * @return SR_OK upon success, SR_ERR_MALLOC upon memory allocation errors,
 *         or SR_ERR_ARG upon invalid arguments.
 *         If something other than SR_OK is returned, 'dev' is unchanged.
 */
SR_API int sr_dev_probe_add(struct sr_dev *dev, const char *name)
{
	struct sr_probe *p;
	int probenum;

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

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

	/* TODO: Further checks to ensure name is valid. */

	probenum = g_slist_length(dev->probes) + 1;

	if (!(p = g_try_malloc0(sizeof(struct sr_probe)))) {
		sr_err("dev: %s: p malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	p->index = probenum;
	p->enabled = TRUE;
	p->name = g_strdup(name);
	p->trigger = NULL;
	dev->probes = g_slist_append(dev->probes, p);

	return SR_OK;
}

/**
 * Find the probe with the specified number in the specified device.
 *
 * TODO
 *
 * @param dev TODO. Must not be NULL.
 * @param probenum The number of the probe whose 'struct sr_probe' we want.
 *                 Note that the probe numbers start at 1 (not 0!).
 *
 * TODO: Should return int.
 * TODO: probenum should be unsigned.
 *
 * @return A pointer to the requested probe's 'struct sr_probe', or NULL
 *         if the probe could not be found.
 */
SR_API struct sr_probe *sr_dev_probe_find(const struct sr_dev *dev,
					  int probenum)
{
	GSList *l;
	struct sr_probe *p, *found_probe;

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

	/* TODO: Sanity check on probenum. */

	found_probe = NULL;
	for (l = dev->probes; l; l = l->next) {
		p = l->data;
		/* TODO: Check for p != NULL. */
		if (p->index == probenum) {
			found_probe = p;
			break;
		}
	}

	return found_probe;
}

/**
 * Set the name of the specified probe in the specified device.
 *
 * If the probe already has a different name assigned to it, it will be
 * removed, and the new name will be saved instead.
 *
 * @param dev TODO
 * @param probenum The number of the probe whose name to set.
 *                 Note that the probe numbers start at 1 (not 0!).
 * @param name The new name that the specified probe should get.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
 *         upon other errors.
 *         If something other than SR_OK is returned, 'dev' is unchanged.
 */
SR_API int sr_dev_probe_name_set(struct sr_dev *dev, int probenum,
				 const char *name)
{
	struct sr_probe *p;

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

	p = sr_dev_probe_find(dev, probenum);
	if (!p) {
		sr_err("dev: %s: probe %d not found", __func__, probenum);
		return SR_ERR; /* TODO: More specific error? */
	}

	/* TODO: Sanity check on 'name'. */

	/* If the probe already has a name, kill it first. */
	g_free(p->name);

	p->name = g_strdup(name);

	return SR_OK;
}

/**
 * Remove all triggers set up for the specified device.
 *
 * TODO: Better description.
 *
 * @param dev TODO
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
 *         If something other than SR_OK is returned, 'dev' is unchanged.
 */
SR_API int sr_dev_trigger_clear(struct sr_dev *dev)
{
	struct sr_probe *p;
	unsigned int pnum; /* TODO: uint16_t? */

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

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

	for (pnum = 1; pnum <= g_slist_length(dev->probes); pnum++) {
		p = sr_dev_probe_find(dev, pnum);
		/* TODO: Silently ignore probes which cannot be found? */
		if (p) {
			g_free(p->trigger);
			p->trigger = NULL;
		}
	}

	return SR_OK;
}

/**
 * Add a trigger to the specified device.
 *
 * TODO: Better description.
 * TODO: Describe valid format of the 'trigger' string.
 *
 * @param dev TODO. Must not be NULL.
 * @param probenum The number of the probe. TODO.
 *                 Note that the probe numbers start at 1 (not 0!).
 * @param trigger TODO.
 *                TODO: Is NULL allowed?
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
 *         upon other errors.
 *         If something other than SR_OK is returned, 'dev' is unchanged.
 */
SR_API int sr_dev_trigger_set(struct sr_dev *dev, int probenum,
			      const char *trigger)
{
	struct sr_probe *p;

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

	/* TODO: Sanity check on 'probenum'. */

	/* TODO: Sanity check on 'trigger'. */

	p = sr_dev_probe_find(dev, probenum);
	if (!p) {
		sr_err("dev: %s: probe %d not found", __func__, probenum);
		return SR_ERR; /* TODO: More specific error? */
	}

	/* If the probe already has a trigger, kill it first. */
	g_free(p->trigger);

	p->trigger = g_strdup(trigger);

	return SR_OK;
}

/**
 * Determine whether the specified device has the specified capability.
 *
 * @param dev Pointer to the device to be checked. Must not be NULL.
 *            If the device's 'driver' field is NULL (virtual device), this
 *            function will always return FALSE (virtual devices don't have
 *            a hardware capabilities list).
 * @param hwcap The capability that should be checked (whether it's supported
 *              by the specified device).
 *
 * @return TRUE, if the device has the specified capability, FALSE otherwise.
 *         FALSE is also returned upon invalid input parameters or other
 *         error conditions.
 */
SR_API gboolean sr_dev_has_hwcap(const struct sr_dev *dev, int hwcap)
{
	int *hwcaps, i;

	sr_spew("dev: %s: requesting hwcap %d", __func__, hwcap);

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

	/*
	 * Virtual devices (which have dev->driver set to NULL) always say that
	 * they don't have the capability (they can't call hwcap_get_all()).
	 */
	if (!dev->driver) {
		sr_dbg("dev: %s: dev->driver was NULL, this seems to be "
		       "a virtual device without capabilities", __func__);
		return FALSE;
	}

	/* TODO: Sanity check on 'hwcap'. */

	if (!(hwcaps = dev->driver->hwcap_get_all())) {
		sr_err("dev: %s: dev has no capabilities", __func__);
		return FALSE;
	}

	for (i = 0; hwcaps[i]; i++) {
		if (hwcaps[i] != hwcap)
			continue;
		sr_spew("dev: %s: found hwcap %d", __func__, hwcap);
		return TRUE;
	}

	sr_spew("dev: %s: hwcap %d not found", __func__, hwcap);

	return FALSE;
}

/**
 * Returns information about the given device.
 *
 * @param dev Pointer to the device to be checked. Must not be NULL.
 *            The device's 'driver' field must not be NULL either.
 * @param id The type of information.
 * @param data The return value. Must not be NULL.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
 *         upon other errors.
 */
SR_API int sr_dev_info_get(const struct sr_dev *dev, int id, const void **data)
{
	if ((dev == NULL) || (dev->driver == NULL))
		return SR_ERR_ARG;

	if (data == NULL)
		return SR_ERR_ARG;

	*data = dev->driver->dev_info_get(dev->driver_index, id);

	if (*data == NULL)
		return SR_ERR;

	return SR_OK;
}
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 <glib.h>
	22	#include "sigrok.h"
	23	#include "sigrok-internal.h"
	24
	25	static GSList *devs = NULL;
	26
	27	/**
	28	* Scan the system for attached logic analyzers / devices.
	29	*
	30	* This will try to autodetect all supported logic analyzer devices:
	31	*
	32	* - Those attached via USB (can be reliably detected via USB VID/PID).
	33	*
	34	* - Those using a (real or virtual) serial port (detected by sending
	35	* device-specific commands to all OS-specific serial port devices such
	36	* as /dev/ttyS, /dev/ttyUSB, /dev/ttyACM*, and others).
	37	* The autodetection for this kind of devices can potentially be unreliable.
	38	*
	39	* Also, sending various bytes/commands to (all!) devices which happen to
	40	* be attached to the system via a (real or virtual) serial port can be
	41	* problematic. There is no way for libsigrok to know how unknown devices
	42	* react to the bytes libsigrok sends. Potentially they could lead to the
	43	* device getting into invalid/error states, losing/overwriting data, or...
	44	*
	45	* In addition to the detection, the devices that are found are also
	46	* initialized automatically. On some devices, this involves a firmware upload,
	47	* or other such measures.
	48	*
	49	* The order in which the system is scanned for devices is not specified. The
	50	* caller should not assume or rely on any specific order.
	51	*
	52	* After the system has been scanned for devices, the list of detected (and
	53	* supported) devices can be acquired via sr_dev_list().
	54	*
	55	* TODO: Error checks?
	56	* TODO: Option to only scan for specific devices or device classes.
	57	*
	58	* @return SR_OK upon success, SR_ERR_BUG upon internal errors.
	59	*/
	60	SR_API int sr_dev_scan(void)
	61	{
	62	int i;
	63	struct sr_dev_driver **drivers;
	64
	65	drivers = sr_driver_list();
	66	if (!drivers[0]) {
	67	sr_err("dev: %s: no supported hardware drivers", __func__);
	68	return SR_ERR_BUG;
	69	}
	70
	71	/*
	72	* Initialize all drivers first. Since the init() call may involve
	73	* a firmware upload and associated delay, we may as well get all
	74	* of these out of the way first.
	75	*/
	76	for (i = 0; drivers[i]; i++)
	77	sr_driver_init(drivers[i]);
	78
	79	return SR_OK;
	80	}
	81
	82	/**
	83	* Return the list of logic analyzer devices libsigrok has detected.
	84	*
	85	* If the libsigrok-internal device list is empty, a scan for attached
	86	* devices -- via a call to sr_dev_scan() -- is performed first.
	87	*
	88	* TODO: Error handling?
	89	*
	90	* @return The list (GSList) of detected devices, or NULL if none were found.
	91	*/
	92	SR_API GSList *sr_dev_list(void)
	93	{
	94	if (!devs)
	95	sr_dev_scan();
	96
	97	return devs;
	98	}
	99
	100	/**
	101	* Create a new device.
	102	*
	103	* The device is added to the (libsigrok-internal) list of devices, but
	104	* additionally a pointer to the newly created device is also returned.
	105	*
	106	* The device has no probes attached to it yet after this call. You can
	107	* use sr_dev_probe_add() to add one or more probes.
	108	*
	109	* TODO: Should return int, so that we can return SR_OK, SR_ERR_* etc.
	110	*
	111	* It is the caller's responsibility to g_free() the allocated memory when
	112	* no longer needed. TODO: Using which API function?
	113	*
	114	* @param driver TODO.
	115	* If 'driver' is NULL, the created device is a "virtual" one.
	116	* @param driver_index TODO
	117	*
	118	* @return Pointer to the newly allocated device, or NULL upon errors.
	119	*/
	120	SR_API struct sr_dev sr_dev_new(const struct sr_dev_driver driver,
	121	int driver_index)
	122	{
	123	struct sr_dev *dev;
	124
	125	/* TODO: Check if driver_index valid? */
	126
	127	if (!(dev = g_try_malloc0(sizeof(struct sr_dev)))) {
	128	sr_err("dev: %s: dev malloc failed", __func__);
	129	return NULL;
	130	}
	131
	132	dev->driver = (struct sr_dev_driver *)driver;
	133	dev->driver_index = driver_index;
	134	devs = g_slist_append(devs, dev);
	135
	136	return dev;
	137	}
	138
	139	/**
	140	* Add a probe with the specified name to the specified device.
	141	*
	142	* The added probe is automatically enabled (the 'enabled' field is TRUE).
	143	*
	144	* The 'trigger' field of the added probe is set to NULL. A trigger can be
	145	* added via sr_dev_trigger_set().
	146	*
	147	* TODO: Are duplicate names allowed?
	148	* TODO: Do we enforce a maximum probe number for a device?
	149	* TODO: Error if the max. probe number for the specific LA is reached, e.g.
	150	* if the caller tries to add more probes than the device actually has.
	151	*
	152	* @param dev The device to which to add a probe with the specified name.
	153	* Must not be NULL.
	154	* @param name The name of the probe to add to this device. Must not be NULL.
	155	* TODO: Maximum length, allowed characters, etc.
	156	*
	157	* @return SR_OK upon success, SR_ERR_MALLOC upon memory allocation errors,
	158	* or SR_ERR_ARG upon invalid arguments.
	159	* If something other than SR_OK is returned, 'dev' is unchanged.
	160	*/
	161	SR_API int sr_dev_probe_add(struct sr_dev dev, const char name)
	162	{
	163	struct sr_probe *p;
	164	int probenum;
	165
	166	if (!dev) {
	167	sr_err("dev: %s: dev was NULL", __func__);
	168	return SR_ERR_ARG;
	169	}
	170
	171	if (!name) {
	172	sr_err("dev: %s: name was NULL", __func__);
	173	return SR_ERR_ARG;
	174	}
	175
	176	/* TODO: Further checks to ensure name is valid. */
	177
	178	probenum = g_slist_length(dev->probes) + 1;
	179
	180	if (!(p = g_try_malloc0(sizeof(struct sr_probe)))) {
	181	sr_err("dev: %s: p malloc failed", __func__);
	182	return SR_ERR_MALLOC;
	183	}
	184
	185	p->index = probenum;
	186	p->enabled = TRUE;
	187	p->name = g_strdup(name);
	188	p->trigger = NULL;
	189	dev->probes = g_slist_append(dev->probes, p);
	190
	191	return SR_OK;
	192	}
	193
	194	/**
	195	* Find the probe with the specified number in the specified device.
	196	*
	197	* TODO
	198	*
	199	* @param dev TODO. Must not be NULL.
	200	* @param probenum The number of the probe whose 'struct sr_probe' we want.
	201	* Note that the probe numbers start at 1 (not 0!).
	202	*
	203	* TODO: Should return int.
	204	* TODO: probenum should be unsigned.
	205	*
	206	* @return A pointer to the requested probe's 'struct sr_probe', or NULL
	207	* if the probe could not be found.
	208	*/
	209	SR_API struct sr_probe sr_dev_probe_find(const struct sr_dev dev,
	210	int probenum)
	211	{
	212	GSList *l;
	213	struct sr_probe p, found_probe;
	214
	215	if (!dev) {
	216	sr_err("dev: %s: dev was NULL", __func__);
	217	return NULL; /* TODO: SR_ERR_ARG */
	218	}
	219
	220	/* TODO: Sanity check on probenum. */
	221
	222	found_probe = NULL;
	223	for (l = dev->probes; l; l = l->next) {
	224	p = l->data;
	225	/* TODO: Check for p != NULL. */
	226	if (p->index == probenum) {
	227	found_probe = p;
	228	break;
	229	}
	230	}
	231
	232	return found_probe;
	233	}
	234
	235	/**
	236	* Set the name of the specified probe in the specified device.
	237	*
	238	* If the probe already has a different name assigned to it, it will be
	239	* removed, and the new name will be saved instead.
	240	*
	241	* @param dev TODO
	242	* @param probenum The number of the probe whose name to set.
	243	* Note that the probe numbers start at 1 (not 0!).
	244	* @param name The new name that the specified probe should get.
	245	*
	246	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
	247	* upon other errors.
	248	* If something other than SR_OK is returned, 'dev' is unchanged.
	249	*/
	250	SR_API int sr_dev_probe_name_set(struct sr_dev *dev, int probenum,
	251	const char *name)
	252	{
	253	struct sr_probe *p;
	254
	255	if (!dev) {
	256	sr_err("dev: %s: dev was NULL", __func__);
	257	return SR_ERR_ARG;
	258	}
	259
	260	p = sr_dev_probe_find(dev, probenum);
	261	if (!p) {
	262	sr_err("dev: %s: probe %d not found", __func__, probenum);
	263	return SR_ERR; /* TODO: More specific error? */
	264	}
	265
	266	/* TODO: Sanity check on 'name'. */
	267
	268	/* If the probe already has a name, kill it first. */
	269	g_free(p->name);
	270
	271	p->name = g_strdup(name);
	272
	273	return SR_OK;
	274	}
	275
	276	/**
	277	* Remove all triggers set up for the specified device.
	278	*
	279	* TODO: Better description.
	280	*
	281	* @param dev TODO
	282	*
	283	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
	284	* If something other than SR_OK is returned, 'dev' is unchanged.
	285	*/
	286	SR_API int sr_dev_trigger_clear(struct sr_dev *dev)
	287	{
	288	struct sr_probe *p;
	289	unsigned int pnum; /* TODO: uint16_t? */
	290
	291	if (!dev) {
	292	sr_err("dev: %s: dev was NULL", __func__);
	293	return SR_ERR_ARG;
	294	}
	295
	296	if (!dev->probes) {
	297	sr_err("dev: %s: dev->probes was NULL", __func__);
	298	return SR_ERR_ARG;
	299	}
	300
	301	for (pnum = 1; pnum <= g_slist_length(dev->probes); pnum++) {
	302	p = sr_dev_probe_find(dev, pnum);
	303	/* TODO: Silently ignore probes which cannot be found? */
	304	if (p) {
	305	g_free(p->trigger);
	306	p->trigger = NULL;
	307	}
	308	}
	309
	310	return SR_OK;
	311	}
	312
	313	/**
	314	* Add a trigger to the specified device.
	315	*
	316	* TODO: Better description.
	317	* TODO: Describe valid format of the 'trigger' string.
	318	*
	319	* @param dev TODO. Must not be NULL.
	320	* @param probenum The number of the probe. TODO.
	321	* Note that the probe numbers start at 1 (not 0!).
	322	* @param trigger TODO.
	323	* TODO: Is NULL allowed?
	324	*
	325	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
	326	* upon other errors.
	327	* If something other than SR_OK is returned, 'dev' is unchanged.
	328	*/
	329	SR_API int sr_dev_trigger_set(struct sr_dev *dev, int probenum,
	330	const char *trigger)
	331	{
	332	struct sr_probe *p;
	333
	334	if (!dev) {
	335	sr_err("dev: %s: dev was NULL", __func__);
	336	return SR_ERR_ARG;
	337	}
	338
	339	/* TODO: Sanity check on 'probenum'. */
	340
	341	/* TODO: Sanity check on 'trigger'. */
	342
	343	p = sr_dev_probe_find(dev, probenum);
	344	if (!p) {
	345	sr_err("dev: %s: probe %d not found", __func__, probenum);
	346	return SR_ERR; /* TODO: More specific error? */
	347	}
	348
	349	/* If the probe already has a trigger, kill it first. */
	350	g_free(p->trigger);
	351
	352	p->trigger = g_strdup(trigger);
	353
	354	return SR_OK;
	355	}
	356
	357	/**
	358	* Determine whether the specified device has the specified capability.
	359	*
	360	* @param dev Pointer to the device to be checked. Must not be NULL.
	361	* If the device's 'driver' field is NULL (virtual device), this
	362	* function will always return FALSE (virtual devices don't have
	363	* a hardware capabilities list).
	364	* @param hwcap The capability that should be checked (whether it's supported
	365	* by the specified device).
	366	*
	367	* @return TRUE, if the device has the specified capability, FALSE otherwise.
	368	* FALSE is also returned upon invalid input parameters or other
	369	* error conditions.
	370	*/
	371	SR_API gboolean sr_dev_has_hwcap(const struct sr_dev *dev, int hwcap)
	372	{
	373	int *hwcaps, i;
	374
	375	sr_spew("dev: %s: requesting hwcap %d", __func__, hwcap);
	376
	377	if (!dev) {
	378	sr_err("dev: %s: dev was NULL", __func__);
	379	return FALSE;
	380	}
	381
	382	/*
	383	* Virtual devices (which have dev->driver set to NULL) always say that
	384	* they don't have the capability (they can't call hwcap_get_all()).
	385	*/
	386	if (!dev->driver) {
	387	sr_dbg("dev: %s: dev->driver was NULL, this seems to be "
	388	"a virtual device without capabilities", __func__);
	389	return FALSE;
	390	}
	391
	392	/* TODO: Sanity check on 'hwcap'. */
	393
	394	if (!(hwcaps = dev->driver->hwcap_get_all())) {
	395	sr_err("dev: %s: dev has no capabilities", __func__);
	396	return FALSE;
	397	}
	398
	399	for (i = 0; hwcaps[i]; i++) {
	400	if (hwcaps[i] != hwcap)
	401	continue;
	402	sr_spew("dev: %s: found hwcap %d", __func__, hwcap);
	403	return TRUE;
	404	}
	405
	406	sr_spew("dev: %s: hwcap %d not found", __func__, hwcap);
	407
	408	return FALSE;
	409	}
	410
	411	/**
	412	* Returns information about the given device.
	413	*
	414	* @param dev Pointer to the device to be checked. Must not be NULL.
	415	* The device's 'driver' field must not be NULL either.
	416	* @param id The type of information.
	417	* @param data The return value. Must not be NULL.
	418	*
	419	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
	420	* upon other errors.
	421	*/
	422	SR_API int sr_dev_info_get(const struct sr_dev dev, int id, const void *data)
	423	{
	424	if ((dev == NULL) \|\| (dev->driver == NULL))
	425	return SR_ERR_ARG;
	426
	427	if (data == NULL)
	428	return SR_ERR_ARG;
	429
	430	*data = dev->driver->dev_info_get(dev->driver_index, id);
	431
	432	if (*data == NULL)
	433	return SR_ERR;
	434
	435	return SR_OK;
	436	}