X-Git-Url: http://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Fdevice.c;h=537c89eff2ab353c167152de2af775a4317736a0;hp=d87d2904a313f74e870a370279cbd64d42110d7a;hb=HEAD;hpb=ce375f2a396c4735a12e9105595d7c9f1a366abb diff --git a/src/device.c b/src/device.c index d87d2904..5c681378 100644 --- a/src/device.c +++ b/src/device.c @@ -18,10 +18,12 @@ */ #include -#include #include +#include +#include #include #include "libsigrok-internal.h" +#include "scpi.h" /** @cond PRIVATE */ #define LOG_PREFIX "device" @@ -60,12 +62,12 @@ SR_PRIV struct sr_channel *sr_channel_new(struct sr_dev_inst *sdi, { struct sr_channel *ch; - ch = g_malloc0(sizeof(struct sr_channel)); + ch = g_malloc0(sizeof(*ch)); ch->sdi = sdi; ch->index = index; ch->type = type; ch->enabled = enabled; - if (name) + if (name && *name) ch->name = g_strdup(name); sdi->channels = g_slist_append(sdi->channels, ch); @@ -73,6 +75,32 @@ SR_PRIV struct sr_channel *sr_channel_new(struct sr_dev_inst *sdi, return ch; } +/** + * Release a previously allocated struct sr_channel. + * + * @param[in] ch Pointer to struct sr_channel. + * + * @private + */ +SR_PRIV void sr_channel_free(struct sr_channel *ch) +{ + if (!ch) + return; + g_free(ch->name); + g_free(ch->priv); + g_free(ch); +} + +/** + * Wrapper around sr_channel_free(), suitable for glib iterators. + * + * @private + */ +SR_PRIV void sr_channel_free_cb(void *p) +{ + sr_channel_free(p); +} + /** * Set the name of the specified channel. * @@ -92,6 +120,8 @@ SR_API int sr_dev_channel_name_set(struct sr_channel *channel, { if (!channel) return SR_ERR_ARG; + if (!name || !*name) + return SR_ERR_ARG; g_free(channel->name); channel->name = g_strdup(name); @@ -135,7 +165,17 @@ SR_API int sr_dev_channel_enable(struct sr_channel *channel, gboolean state) return SR_OK; } -/* Returns the next enabled channel, wrapping around if necessary. */ +/** + * Returns the next enabled channel, wrapping around if necessary. + * + * @param[in] sdi The device instance the channel is connected to. + * Must not be NULL. + * @param[in] cur_channel The current channel. + * + * @return A pointer to the next enabled channel of this device. + * + * @private + */ SR_PRIV struct sr_channel *sr_next_enabled_channel(const struct sr_dev_inst *sdi, struct sr_channel *cur_channel) { @@ -154,6 +194,125 @@ SR_PRIV struct sr_channel *sr_next_enabled_channel(const struct sr_dev_inst *sdi return next_channel; } +/** + * Compare two channels, return whether they differ. + * + * The channels' names and types are checked. The enabled state is not + * considered a condition for difference. The test is motivated by the + * desire to detect changes in the configuration of acquisition setups + * between re-reads of an input file. + * + * @param[in] ch1 First channel. + * @param[in] ch2 Second channel. + * + * @return TRUE upon differences or unexpected input, FALSE otherwise. + * + * @private + */ +SR_PRIV gboolean sr_channels_differ(struct sr_channel *ch1, struct sr_channel *ch2) +{ + if (!ch1 || !ch2) + return TRUE; + + if (ch1->type != ch2->type) + return TRUE; + if (strcmp(ch1->name, ch2->name)) + return TRUE; + + return FALSE; +} + +/** + * Compare two channel lists, return whether they differ. + * + * Listing the same set of channels but in a different order is considered + * a difference in the lists. + * + * @param[in] l1 First channel list. + * @param[in] l2 Second channel list. + * + * @return TRUE upon differences or unexpected input, FALSE otherwise. + * + * @private + */ +SR_PRIV gboolean sr_channel_lists_differ(GSList *l1, GSList *l2) +{ + struct sr_channel *ch1, *ch2; + + while (l1 && l2) { + ch1 = l1->data; + ch2 = l2->data; + l1 = l1->next; + l2 = l2->next; + if (!ch1 || !ch2) + return TRUE; + if (sr_channels_differ(ch1, ch2)) + return TRUE; + if (ch1->index != ch2->index) + return TRUE; + } + if (l1 || l2) + return TRUE; + + return FALSE; +} + +/** + * Allocate and initialize a new channel group, and add it to sdi. + * + * @param[in] sdi The device instance the channel group is connected to. + * Optional, can be NULL. + * @param[in] name @copydoc sr_channel_group::name + * @param[in] priv @copydoc sr_channel_group::priv + * + * @return A pointer to a new struct sr_channel_group, NULL upon error. + * + * @private + */ +SR_PRIV struct sr_channel_group *sr_channel_group_new(struct sr_dev_inst *sdi, + const char *name, void *priv) +{ + struct sr_channel_group *cg; + + cg = g_malloc0(sizeof(*cg)); + if (name && *name) + cg->name = g_strdup(name); + cg->priv = priv; + + if (sdi) + sdi->channel_groups = g_slist_append(sdi->channel_groups, cg); + + return cg; +} + +/** + * Release a previously allocated struct sr_channel_group. + * + * @param[in] cg Pointer to struct sr_channel_group. + * + * @private + */ +SR_PRIV void sr_channel_group_free(struct sr_channel_group *cg) +{ + if (!cg) + return; + + g_free(cg->name); + g_slist_free(cg->channels); + g_free(cg->priv); + g_free(cg); +} + +/** + * Wrapper around sr_channel_group_free(), suitable for glib iterators. + * + * @private + */ +SR_PRIV void sr_channel_group_free_cb(void *cg) +{ + return sr_channel_group_free(cg); +} + /** * Determine whether the specified device instance has the specified * capability. @@ -306,7 +465,7 @@ SR_API struct sr_dev_inst *sr_dev_inst_user_new(const char *vendor, { struct sr_dev_inst *sdi; - sdi = g_malloc0(sizeof(struct sr_dev_inst)); + sdi = g_malloc0(sizeof(*sdi)); sdi->vendor = g_strdup(vendor); sdi->model = g_strdup(model); @@ -319,6 +478,7 @@ SR_API struct sr_dev_inst *sr_dev_inst_user_new(const char *vendor, /** * Add a new channel to the specified device instance. * + * @param[in] sdi Device instance to use. Must not be NULL. * @param[in] index @copydoc sr_channel::index * @param[in] type @copydoc sr_channel::type * @param[in] name @copydoc sr_channel::name @@ -331,7 +491,8 @@ SR_API int sr_dev_inst_channel_add(struct sr_dev_inst *sdi, int index, int type, if (!sdi || sdi->inst_type != SR_INST_USER || index < 0) return SR_ERR_ARG; - sr_channel_new(sdi, index, type, TRUE, name); + if (!sr_channel_new(sdi, index, type, TRUE, name)) + return SR_ERR_DATA; return SR_OK; } @@ -346,7 +507,6 @@ SR_API int sr_dev_inst_channel_add(struct sr_dev_inst *sdi, int index, int type, SR_PRIV void sr_dev_inst_free(struct sr_dev_inst *sdi) { struct sr_channel *ch; - struct sr_channel_group *cg; GSList *l; if (!sdi) @@ -354,20 +514,10 @@ SR_PRIV void sr_dev_inst_free(struct sr_dev_inst *sdi) for (l = sdi->channels; l; l = l->next) { ch = l->data; - g_free(ch->name); - g_free(ch->priv); - g_free(ch); + sr_channel_free(ch); } g_slist_free(sdi->channels); - - for (l = sdi->channel_groups; l; l = l->next) { - cg = l->data; - g_free(cg->name); - g_slist_free(cg->channels); - g_free(cg->priv); - g_free(cg); - } - g_slist_free(sdi->channel_groups); + g_slist_free_full(sdi->channel_groups, sr_channel_group_free_cb); if (sdi->session) sr_session_dev_remove(sdi->session, sdi); @@ -398,7 +548,7 @@ SR_PRIV struct sr_usb_dev_inst *sr_usb_dev_inst_new(uint8_t bus, { struct sr_usb_dev_inst *udi; - udi = g_malloc0(sizeof(struct sr_usb_dev_inst)); + udi = g_malloc0(sizeof(*udi)); udi->bus = bus; udi->address = address; udi->devhdl = hdl; @@ -419,9 +569,18 @@ SR_PRIV void sr_usb_dev_inst_free(struct sr_usb_dev_inst *usb) g_free(usb); } +/** + * Wrapper for g_slist_free_full() convenience. + * + * @private + */ +SR_PRIV void sr_usb_dev_inst_free_cb(gpointer p) +{ + sr_usb_dev_inst_free(p); +} #endif -#ifdef HAVE_LIBSERIALPORT +#ifdef HAVE_SERIAL_COMM /** * Allocate and init a struct for a serial device instance. @@ -447,7 +606,7 @@ SR_PRIV struct sr_serial_dev_inst *sr_serial_dev_inst_new(const char *port, { struct sr_serial_dev_inst *serial; - serial = g_malloc0(sizeof(struct sr_serial_dev_inst)); + serial = g_malloc0(sizeof(*serial)); serial->port = g_strdup(port); if (serialcomm) serial->serialcomm = g_strdup(serialcomm); @@ -479,7 +638,7 @@ SR_PRIV struct sr_usbtmc_dev_inst *sr_usbtmc_dev_inst_new(const char *device) { struct sr_usbtmc_dev_inst *usbtmc; - usbtmc = g_malloc0(sizeof(struct sr_usbtmc_dev_inst)); + usbtmc = g_malloc0(sizeof(*usbtmc)); usbtmc->device = g_strdup(device); usbtmc->fd = -1; @@ -527,27 +686,40 @@ SR_API GSList *sr_dev_list(const struct sr_dev_driver *driver) */ SR_API int sr_dev_clear(const struct sr_dev_driver *driver) { - int ret; - if (!driver) { sr_err("Invalid driver."); return SR_ERR_ARG; } - if (driver->dev_clear) - ret = driver->dev_clear(driver); - else - ret = std_dev_clear(driver, NULL); + if (!driver->context) { + /* + * Driver was never initialized, nothing to do. + * + * No log message since this usually gets called for all + * drivers, whether they were initialized or not. + */ + return SR_OK; + } - return ret; + /* No log message here, too verbose and not very useful. */ + + return driver->dev_clear(driver); } /** - * Open the specified device. + * Open the specified device instance. + * + * If the device instance is already open (sdi->status == SR_ST_ACTIVE), + * SR_ERR will be returned and no re-opening of the device will be attempted. + * + * If opening was successful, sdi->status is set to SR_ST_ACTIVE, otherwise + * it will be left unchanged. * * @param sdi Device instance to use. Must not be NULL. * - * @return SR_OK upon success, a negative error code upon errors. + * @retval SR_OK Success. + * @retval SR_ERR_ARG Invalid arguments. + * @retval SR_ERR Device instance was already active, or other error. * * @since 0.2.0 */ @@ -556,32 +728,59 @@ SR_API int sr_dev_open(struct sr_dev_inst *sdi) int ret; if (!sdi || !sdi->driver || !sdi->driver->dev_open) + return SR_ERR_ARG; + + if (sdi->status == SR_ST_ACTIVE) { + sr_err("%s: Device instance already active, can't re-open.", + sdi->driver->name); return SR_ERR; + } + + sr_dbg("%s: Opening device instance.", sdi->driver->name); ret = sdi->driver->dev_open(sdi); + if (ret == SR_OK) + sdi->status = SR_ST_ACTIVE; + return ret; } /** - * Close the specified device. + * Close the specified device instance. + * + * If the device instance is not open (sdi->status != SR_ST_ACTIVE), + * SR_ERR_DEV_CLOSED will be returned and no closing will be attempted. + * + * Note: sdi->status will be set to SR_ST_INACTIVE, regardless of whether + * there are any errors during closing of the device instance (any errors + * will be reported via error code and log message, though). * * @param sdi Device instance to use. Must not be NULL. * - * @return SR_OK upon success, a negative error code upon errors. + * @retval SR_OK Success. + * @retval SR_ERR_ARG Invalid arguments. + * @retval SR_ERR_DEV_CLOSED Device instance was not active. + * @retval SR_ERR Other error. * * @since 0.2.0 */ SR_API int sr_dev_close(struct sr_dev_inst *sdi) { - int ret; - if (!sdi || !sdi->driver || !sdi->driver->dev_close) - return SR_ERR; + return SR_ERR_ARG; - ret = sdi->driver->dev_close(sdi); + if (sdi->status != SR_ST_ACTIVE) { + sr_err("%s: Device instance not active, can't close.", + sdi->driver->name); + return SR_ERR_DEV_CLOSED; + } - return ret; + sdi->status = SR_ST_INACTIVE; + + sr_dbg("%s: Closing device instance.", sdi->driver->name); + + return sdi->driver->dev_close(sdi); } /** @@ -672,19 +871,24 @@ SR_API const char *sr_dev_inst_connid_get(const struct sr_dev_inst *sdi) #ifdef HAVE_LIBUSB_1_0 struct drv_context *drvc; int cnt, i, a, b; - char connection_id[64]; + char conn_id_usb[64]; struct sr_usb_dev_inst *usb; struct libusb_device **devlist; #endif +#ifdef HAVE_SERIAL_COMM + struct sr_serial_dev_inst *serial; +#endif + + struct sr_scpi_dev_inst *scpi; + char *conn_id_scpi; + if (!sdi) return NULL; -#ifdef HAVE_LIBSERIALPORT - struct sr_serial_dev_inst *serial; - +#ifdef HAVE_SERIAL_COMM if ((!sdi->connection_id) && (sdi->inst_type == SR_INST_SERIAL)) { - /* connection_id isn't populated, let's do that here. */ + /* connection_id isn't populated, let's do that for serial devices. */ serial = sdi->conn; ((struct sr_dev_inst *)sdi)->connection_id = g_strdup(serial->port); @@ -693,7 +897,7 @@ SR_API const char *sr_dev_inst_connid_get(const struct sr_dev_inst *sdi) #ifdef HAVE_LIBUSB_1_0 if ((!sdi->connection_id) && (sdi->inst_type == SR_INST_USB)) { - /* connection_id isn't populated, let's do that here. */ + /* connection_id isn't populated, let's do that for USB devices. */ drvc = sdi->driver->context; usb = sdi->conn; @@ -711,8 +915,10 @@ SR_API const char *sr_dev_inst_connid_get(const struct sr_dev_inst *sdi) if (b != usb->bus || a != usb->address) continue; - usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)); - ((struct sr_dev_inst *)sdi)->connection_id = g_strdup(connection_id); + if (usb_get_port_path(devlist[i], conn_id_usb, sizeof(conn_id_usb)) < 0) + continue; + + ((struct sr_dev_inst *)sdi)->connection_id = g_strdup(conn_id_usb); break; } @@ -720,6 +926,15 @@ SR_API const char *sr_dev_inst_connid_get(const struct sr_dev_inst *sdi) } #endif + if ((!sdi->connection_id) && (sdi->inst_type == SR_INST_SCPI)) { + /* connection_id isn't populated, let's do that for SCPI devices. */ + + scpi = sdi->conn; + sr_scpi_connection_id(scpi, &conn_id_scpi); + ((struct sr_dev_inst *)sdi)->connection_id = g_strdup(conn_id_scpi); + g_free(conn_id_scpi); + } + return sdi->connection_id; }