X-Git-Url: https://sigrok.org/gitweb/?p=libsigrok.git;a=blobdiff_plain;f=src%2Fhardware%2Fchronovu-la%2Fapi.c;h=d5ca278b728d999557576d291f9720bbfe491b75;hp=d9e3cc3914edad598d79d45847afa66d17f2abce;hb=HEAD;hpb=f57d8ffe66612a1fdc20ed09c222f8ea59bd84d4

diff --git a/src/hardware/chronovu-la/api.c b/src/hardware/chronovu-la/api.c
index d9e3cc39..d5ca278b 100644
--- a/src/hardware/chronovu-la/api.c
+++ b/src/hardware/chronovu-la/api.c
@@ -1,7 +1,7 @@
 /*
  * This file is part of the libsigrok project.
  *
- * Copyright (C) 2011-2014 Uwe Hermann <uwe@hermann-uwe.de>
+ * Copyright (C) 2011-2015 Uwe Hermann <uwe@hermann-uwe.de>
  *
  * 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
@@ -14,19 +14,26 @@
  * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <config.h>
 #include "protocol.h"
 
-SR_PRIV struct sr_dev_driver chronovu_la_driver_info;
-static struct sr_dev_driver *di = &chronovu_la_driver_info;
+#define SCAN_EXPECTED_VENDOR 0x0403
 
-static const uint32_t devopts[] = {
+static const uint32_t scanopts[] = {
+	SR_CONF_CONN,
+};
+
+static const uint32_t drvopts[] = {
 	SR_CONF_LOGIC_ANALYZER,
+};
+
+static const uint32_t devopts[] = {
 	SR_CONF_LIMIT_MSEC | SR_CONF_SET,
 	SR_CONF_LIMIT_SAMPLES | SR_CONF_SET | SR_CONF_LIST,
+	SR_CONF_CONN | SR_CONF_GET,
 	SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
 	SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
 };
@@ -38,55 +45,28 @@ static const int32_t trigger_matches[] = {
 	SR_TRIGGER_FALLING,
 };
 
-/* The ChronoVu LA8/LA16 can have multiple VID/PID pairs. */
-static struct {
-	uint16_t vid;
-	uint16_t pid;
-	int model;
-	const char *iproduct;
-} vid_pid[] = {
-	{ 0x0403, 0x6001, CHRONOVU_LA8,  "ChronoVu LA8"  },
-	{ 0x0403, 0x8867, CHRONOVU_LA8,  "ChronoVu LA8"  },
-	{ 0x0403, 0x6001, CHRONOVU_LA16, "ChronoVu LA16" },
-	{ 0x0403, 0x8867, CHRONOVU_LA16, "ChronoVu LA16" },
-};
-
-static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
-
-static void clear_helper(void *priv)
+static void clear_helper(struct dev_context *devc)
 {
-	struct dev_context *devc;
-
-	devc = priv;
-
 	ftdi_free(devc->ftdic);
 	g_free(devc->final_buf);
 }
 
-static int dev_clear(void)
-{
-	return std_dev_clear(di, clear_helper);
-}
-
-static int init(struct sr_context *sr_ctx)
+static int dev_clear(const struct sr_dev_driver *di)
 {
-	return std_init(sr_ctx, di, LOG_PREFIX);
+	return std_dev_clear_with_callback(di, (std_dev_clear_callback)clear_helper);
 }
 
-static int add_device(int idx, int model, GSList **devices)
+static int add_device(int model, struct libusb_device_descriptor *des,
+	const char *serial_num, const char *connection_id, libusb_device *usbdev,
+	GSList **devices)
 {
 	int ret;
 	unsigned int i;
 	struct sr_dev_inst *sdi;
-	struct drv_context *drvc;
 	struct dev_context *devc;
-	struct sr_channel *ch;
 
 	ret = SR_OK;
 
-	drvc = di->priv;
-
-	/* Allocate memory for our private device context. */
 	devc = g_malloc0(sizeof(struct dev_context));
 
 	/* Set some sane defaults. */
@@ -95,7 +75,6 @@ static int add_device(int idx, int model, GSList **devices)
 	devc->cur_samplerate = 0; /* Set later (different for LA8/LA16). */
 	devc->limit_msec = 0;
 	devc->limit_samples = 0;
-	devc->cb_data = NULL;
 	memset(devc->mangled_buf, 0, BS);
 	devc->final_buf = NULL;
 	devc->trigger_pattern = 0x0000; /* Irrelevant, see trigger_mask. */
@@ -105,8 +84,8 @@ static int add_device(int idx, int model, GSList **devices)
 	devc->done = 0;
 	devc->block_counter = 0;
 	devc->divcount = 0;
-	devc->usb_vid = vid_pid[idx].vid;
-	devc->usb_pid = vid_pid[idx].pid;
+	devc->usb_vid = des->idVendor;
+	devc->usb_pid = des->idProduct;
 	memset(devc->samplerates, 0, sizeof(uint64_t) * 255);
 
 	/* Allocate memory where we'll store the de-mangled data. */
@@ -119,87 +98,138 @@ static int add_device(int idx, int model, GSList **devices)
 	/* We now know the device, set its max. samplerate as default. */
 	devc->cur_samplerate = devc->prof->max_samplerate;
 
-	/* Register the device with libsigrok. */
 	sdi = g_malloc0(sizeof(struct sr_dev_inst));
-	sdi->status = SR_ST_INITIALIZING;
+	sdi->status = SR_ST_INACTIVE;
 	sdi->vendor = g_strdup("ChronoVu");
 	sdi->model = g_strdup(devc->prof->modelname);
-	sdi->driver = di;
+	sdi->serial_num = g_strdup(serial_num);
+	sdi->connection_id = g_strdup(connection_id);
+	sdi->conn = sr_usb_dev_inst_new(libusb_get_bus_number(usbdev),
+		libusb_get_device_address(usbdev), NULL);
 	sdi->priv = devc;
 
-	for (i = 0; i < devc->prof->num_channels; i++) {
-		if (!(ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE,
-					  cv_channel_names[i]))) {
-			ret = SR_ERR;
-			goto err_free_dev_inst;
-		}
-		sdi->channels = g_slist_append(sdi->channels, ch);
-	}
+	for (i = 0; i < devc->prof->num_channels; i++)
+		sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE,
+				cv_channel_names[i]);
 
 	*devices = g_slist_append(*devices, sdi);
-	drvc->instances = g_slist_append(drvc->instances, sdi);
 
 	if (ret == SR_OK)
 		return SR_OK;
 
-err_free_dev_inst:
-	sr_dev_inst_free(sdi);
-	g_free(devc->final_buf);
 err_free_devc:
 	g_free(devc);
 
 	return ret;
 }
 
-static GSList *scan(GSList *options)
+static GSList *scan(struct sr_dev_driver *di, GSList *options)
 {
-	int ret;
-	unsigned int i;
+	struct drv_context *drvc;
 	GSList *devices;
-	struct ftdi_context *ftdic;
-
-	(void)options;
+	const char *conn;
+	int ret;
+	GSList *conn_devices, *l;
+	size_t i;
+	struct sr_usb_dev_inst *usb;
+	uint8_t bus, addr;
+	struct libusb_device_descriptor des;
+	libusb_device **devlist;
+	struct libusb_device_handle *hdl;
+	char product[64], serial_num[64], connection_id[64];
+	int model;
 
+	drvc = di->context;
 	devices = NULL;
 
-	/* Allocate memory for the FTDI context and initialize it. */
-	if (!(ftdic = ftdi_new())) {
-		sr_err("Failed to initialize libftdi.");
-		return NULL;
-	}
+	conn = NULL;
+	(void)sr_serial_extract_options(options, &conn, NULL);
+	conn_devices = NULL;
+	if (conn)
+		conn_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
+
+	libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
+	for (i = 0; devlist[i]; i++) {
+		bus = libusb_get_bus_number(devlist[i]);
+		addr = libusb_get_device_address(devlist[i]);
+		if (conn) {
+			/* Check if the connection matches the user spec. */
+			for (l = conn_devices; l; l = l->next) {
+				usb = l->data;
+				if (usb->bus == bus && usb->address == addr)
+					break;
+			}
+			if (!l)
+				continue;
+		}
 
-	/* Check for LA8 and/or LA16 devices with various VID/PIDs. */
-	for (i = 0; i < ARRAY_SIZE(vid_pid); i++) {
-		ret = ftdi_usb_open_desc(ftdic, vid_pid[i].vid,
-			vid_pid[i].pid, vid_pid[i].iproduct, NULL);
-		/* Show errors other than "device not found". */
-		if (ret < 0 && ret != -3)
-			sr_dbg("Error finding/opening device (%d): %s.",
-			       ret, ftdi_get_error_string(ftdic));
-		if (ret < 0)
-			continue; /* No device found, or not usable. */
-
-		sr_dbg("Found %s device (%04x:%04x).",
-		       vid_pid[i].iproduct, vid_pid[i].vid, vid_pid[i].pid);
-
-		if ((ret = add_device(i, vid_pid[i].model, &devices)) < 0)
-			sr_dbg("Failed to add device: %d.", ret);
+		libusb_get_device_descriptor(devlist[i], &des);
+
+		/*
+		 * In theory we'd accept any USB device with a matching
+		 * product string. In practice the enumeration takes a
+		 * shortcut and only inspects devices when their USB VID
+		 * matches the expectation. This avoids access to flaky
+		 * devices which are unrelated to measurement purposes
+		 * yet cause trouble when accessed including segfaults,
+		 * while libusb won't transparently handle their flaws.
+		 *
+		 * See https://sigrok.org/bugzilla/show_bug.cgi?id=1115
+		 * and https://github.com/sigrokproject/libsigrok/pull/166
+		 * for a discussion.
+		 */
+		if (des.idVendor != SCAN_EXPECTED_VENDOR)
+			continue;
+
+		if ((ret = libusb_open(devlist[i], &hdl)) < 0)
+			continue;
+
+		if (des.iProduct == 0) {
+			product[0] = '\0';
+		} else if ((ret = libusb_get_string_descriptor_ascii(hdl,
+				des.iProduct, (unsigned char *)product,
+				sizeof(product))) < 0) {
+			sr_warn("Failed to get product string descriptor: %s.",
+				libusb_error_name(ret));
+			continue;
+		}
 
-		if ((ret = ftdi_usb_close(ftdic)) < 0)
-			sr_dbg("Failed to close FTDI device (%d): %s.",
-			       ret, ftdi_get_error_string(ftdic));
-	}
+		if (des.iSerialNumber == 0) {
+			serial_num[0] = '\0';
+		} else if ((ret = libusb_get_string_descriptor_ascii(hdl,
+				des.iSerialNumber, (unsigned char *)serial_num,
+				sizeof(serial_num))) < 0) {
+			sr_warn("Failed to get serial number string descriptor: %s.",
+				libusb_error_name(ret));
+			continue;
+		}
 
-	/* Close USB device, deinitialize and free the FTDI context. */
-	ftdi_free(ftdic);
-	ftdic = NULL;
+		libusb_close(hdl);
 
-	return devices;
-}
+		if (usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)) < 0)
+			continue;
 
-static GSList *dev_list(void)
-{
-	return ((struct drv_context *)(di->priv))->instances;
+		if (!strcmp(product, "ChronoVu LA8"))
+			model = 0;
+		else if (!strcmp(product, "ChronoVu LA16"))
+			model = 1;
+		else
+			continue; /* Unknown iProduct string, ignore. */
+
+		sr_dbg("Found %s (%04x:%04x, %d.%d, %s).",
+		       product, des.idVendor, des.idProduct,
+		       libusb_get_bus_number(devlist[i]),
+		       libusb_get_device_address(devlist[i]), connection_id);
+
+		if ((ret = add_device(model, &des, serial_num, connection_id,
+					devlist[i], &devices)) < 0) {
+			sr_dbg("Failed to add device: %d.", ret);
+		}
+	}
+	libusb_free_device_list(devlist, 1);
+	g_slist_free_full(conn_devices, (GDestroyNotify)sr_usb_dev_inst_free);
+
+	return std_scan_complete(di, devices);
 }
 
 static int dev_open(struct sr_dev_inst *sdi)
@@ -207,10 +237,8 @@ static int dev_open(struct sr_dev_inst *sdi)
 	struct dev_context *devc;
 	int ret;
 
-	if (!(devc = sdi->priv))
-		return SR_ERR_BUG;
+	devc = sdi->priv;
 
-	/* Allocate memory for the FTDI context and initialize it. */
 	if (!(devc->ftdic = ftdi_new())) {
 		sr_err("Failed to initialize libftdi.");
 		return SR_ERR;
@@ -219,43 +247,33 @@ static int dev_open(struct sr_dev_inst *sdi)
 	sr_dbg("Opening %s device (%04x:%04x).", devc->prof->modelname,
 	       devc->usb_vid, devc->usb_pid);
 
-	/* Open the device. */
 	if ((ret = ftdi_usb_open_desc(devc->ftdic, devc->usb_vid,
 			devc->usb_pid, devc->prof->iproduct, NULL)) < 0) {
 		sr_err("Failed to open FTDI device (%d): %s.",
 		       ret, ftdi_get_error_string(devc->ftdic));
 		goto err_ftdi_free;
 	}
-	sr_dbg("Device opened successfully.");
 
-	/* Purge RX/TX buffers in the FTDI chip. */
-	if ((ret = ftdi_usb_purge_buffers(devc->ftdic)) < 0) {
+	if ((ret = PURGE_FTDI_BOTH(devc->ftdic)) < 0) {
 		sr_err("Failed to purge FTDI buffers (%d): %s.",
 		       ret, ftdi_get_error_string(devc->ftdic));
 		goto err_ftdi_free;
 	}
-	sr_dbg("FTDI buffers purged successfully.");
 
-	/* Enable flow control in the FTDI chip. */
 	if ((ret = ftdi_setflowctrl(devc->ftdic, SIO_RTS_CTS_HS)) < 0) {
 		sr_err("Failed to enable FTDI flow control (%d): %s.",
 		       ret, ftdi_get_error_string(devc->ftdic));
 		goto err_ftdi_free;
 	}
-	sr_dbg("FTDI flow control enabled successfully.");
 
-	/* Wait 100ms. */
 	g_usleep(100 * 1000);
 
-	sdi->status = SR_ST_ACTIVE;
-
-	if (ret == SR_OK)
-		return SR_OK;
+	return SR_OK;
 
 err_ftdi_free:
 	ftdi_free(devc->ftdic); /* Close device (if open), free FTDI context. */
 	devc->ftdic = NULL;
-	return ret;
+	return SR_ERR;
 }
 
 static int dev_close(struct sr_dev_inst *sdi)
@@ -263,35 +281,36 @@ static int dev_close(struct sr_dev_inst *sdi)
 	int ret;
 	struct dev_context *devc;
 
-	if (sdi->status != SR_ST_ACTIVE)
-		return SR_OK;
-
 	devc = sdi->priv;
 
-	if (devc->ftdic && (ret = ftdi_usb_close(devc->ftdic)) < 0)
+	if (!devc->ftdic)
+		return SR_ERR_BUG;
+
+	if ((ret = ftdi_usb_close(devc->ftdic)) < 0)
 		sr_err("Failed to close FTDI device (%d): %s.",
 		       ret, ftdi_get_error_string(devc->ftdic));
-	sdi->status = SR_ST_INACTIVE;
-
-	return SR_OK;
-}
 
-static int cleanup(void)
-{
-	return dev_clear();
+	return (ret == 0) ? SR_OK : SR_ERR;
 }
 
-static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
-		const struct sr_channel_group *cg)
+static int config_get(uint32_t key, GVariant **data,
+	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 {
 	struct dev_context *devc;
+	struct sr_usb_dev_inst *usb;
 
 	(void)cg;
 
 	switch (key) {
+	case SR_CONF_CONN:
+		if (!sdi || !(usb = sdi->conn))
+			return SR_ERR_ARG;
+		*data = g_variant_new_printf("%d.%d", usb->bus, usb->address);
+		break;
 	case SR_CONF_SAMPLERATE:
-		if (!sdi || !(devc = sdi->priv))
+		if (!sdi)
 			return SR_ERR_BUG;
+		devc = sdi->priv;
 		*data = g_variant_new_uint64(devc->cur_samplerate);
 		break;
 	default:
@@ -301,18 +320,14 @@ static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *s
 	return SR_OK;
 }
 
-static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
-		const struct sr_channel_group *cg)
+static int config_set(uint32_t key, GVariant *data,
+	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 {
 	struct dev_context *devc;
 
 	(void)cg;
 
-	if (sdi->status != SR_ST_ACTIVE)
-		return SR_ERR_DEV_CLOSED;
-
-	if (!(devc = sdi->priv))
-		return SR_ERR_BUG;
+	devc = sdi->priv;
 
 	switch (key) {
 	case SR_CONF_SAMPLERATE:
@@ -320,13 +335,9 @@ static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sd
 			return SR_ERR;
 		break;
 	case SR_CONF_LIMIT_MSEC:
-		if (g_variant_get_uint64(data) == 0)
-			return SR_ERR_ARG;
 		devc->limit_msec = g_variant_get_uint64(data);
 		break;
 	case SR_CONF_LIMIT_SAMPLES:
-		if (g_variant_get_uint64(data) == 0)
-			return SR_ERR_ARG;
 		devc->limit_samples = g_variant_get_uint64(data);
 		break;
 	default:
@@ -336,48 +347,30 @@ static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sd
 	return SR_OK;
 }
 
-static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
-		const struct sr_channel_group *cg)
+static int config_list(uint32_t key, GVariant **data,
+	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 {
-	GVariant *gvar, *grange[2];
-	GVariantBuilder gvb;
 	struct dev_context *devc;
 
-	(void)cg;
+	devc = (sdi) ? sdi->priv : NULL;
 
 	switch (key) {
+	case SR_CONF_SCAN_OPTIONS:
 	case SR_CONF_DEVICE_OPTIONS:
-		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
-				devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
-		break;
+		return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
 	case SR_CONF_SAMPLERATE:
-		if (!sdi || !sdi->priv || !(devc = sdi->priv))
-			return SR_ERR_BUG;
 		cv_fill_samplerates_if_needed(sdi);
-		g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
-		gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
-				devc->samplerates,
-				ARRAY_SIZE(devc->samplerates),
-				sizeof(uint64_t));
-		g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
-		*data = g_variant_builder_end(&gvb);
+		*data = std_gvar_samplerates(ARRAY_AND_SIZE(devc->samplerates));
 		break;
 	case SR_CONF_LIMIT_SAMPLES:
-		if (!sdi || !sdi->priv || !(devc = sdi->priv) || !devc->prof)
+		if (!devc || !devc->prof)
 			return SR_ERR_BUG;
-		grange[0] = g_variant_new_uint64(0);
-		if (devc->prof->model == CHRONOVU_LA8)
-			grange[1] = g_variant_new_uint64(MAX_NUM_SAMPLES);
-		else
-			grange[1] = g_variant_new_uint64(MAX_NUM_SAMPLES / 2);
-		*data = g_variant_new_tuple(grange, 2);
+		*data = std_gvar_tuple_u64(0, (devc->prof->model == CHRONOVU_LA8) ? MAX_NUM_SAMPLES : MAX_NUM_SAMPLES / 2);
 		break;
 	case SR_CONF_TRIGGER_MATCH:
-		if (!sdi || !sdi->priv || !(devc = sdi->priv) || !devc->prof)
+		if (!devc || !devc->prof)
 			return SR_ERR_BUG;
-		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
-				trigger_matches, devc->prof->num_trigger_matches,
-				sizeof(int32_t));
+		*data = std_gvar_array_i32(trigger_matches, devc->prof->num_trigger_matches);
 		break;
 	default:
 		return SR_ERR_NA;
@@ -413,7 +406,7 @@ static int receive_data(int fd, int revents, void *cb_data)
 	/* Get one block of data. */
 	if ((ret = cv_read_block(devc)) < 0) {
 		sr_err("Failed to read data block: %d.", ret);
-		dev_acquisition_stop(sdi, sdi);
+		sr_dev_acquisition_stop(sdi);
 		return FALSE;
 	}
 
@@ -434,26 +427,20 @@ static int receive_data(int fd, int revents, void *cb_data)
 	 * full 8MByte first, only then the whole buffer contains valid data.
 	 */
 	for (i = 0; i < NUM_BLOCKS; i++)
-		cv_send_block_to_session_bus(devc, i);
+		cv_send_block_to_session_bus(sdi, i);
 
-	dev_acquisition_stop(sdi, sdi);
+	sr_dev_acquisition_stop(sdi);
 
 	return TRUE;
 }
 
-static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
+static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 {
 	struct dev_context *devc;
 	uint8_t buf[8];
 	int bytes_to_write, bytes_written;
 
-	if (sdi->status != SR_ST_ACTIVE)
-		return SR_ERR_DEV_CLOSED;
-
-	if (!(devc = sdi->priv)) {
-		sr_err("sdi->priv was NULL.");
-		return SR_ERR_BUG;
-	}
+	devc = sdi->priv;
 
 	if (!devc->ftdic) {
 		sr_err("devc->ftdic was NULL.");
@@ -498,12 +485,7 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 		return SR_ERR;
 	}
 
-	sr_dbg("Hardware acquisition started successfully.");
-
-	devc->cb_data = cb_data;
-
-	/* Send header packet to the session bus. */
-	std_session_send_df_header(sdi, LOG_PREFIX);
+	std_session_send_df_header(sdi);
 
 	/* Time when we should be done (for detecting trigger timeouts). */
 	devc->done = (devc->divcount + 1) * devc->prof->trigger_constant +
@@ -512,36 +494,27 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 	devc->trigger_found = 0;
 
 	/* Hook up a dummy handler to receive data from the device. */
-	sr_session_source_add(sdi->session, -1, G_IO_IN, 0, receive_data, (void *)sdi);
+	sr_session_source_add(sdi->session, -1, 0, 0, receive_data, (void *)sdi);
 
 	return SR_OK;
 }
 
-static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
+static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 {
-	struct sr_datafeed_packet packet;
-
-	(void)cb_data;
-
-	sr_dbg("Stopping acquisition.");
 	sr_session_source_remove(sdi->session, -1);
-
-	/* Send end packet to the session bus. */
-	sr_dbg("Sending SR_DF_END.");
-	packet.type = SR_DF_END;
-	sr_session_send(sdi, &packet);
+	std_session_send_df_end(sdi);
 
 	return SR_OK;
 }
 
-SR_PRIV struct sr_dev_driver chronovu_la_driver_info = {
+static struct sr_dev_driver chronovu_la_driver_info = {
 	.name = "chronovu-la",
 	.longname = "ChronoVu LA8/LA16",
 	.api_version = 1,
-	.init = init,
-	.cleanup = cleanup,
+	.init = std_init,
+	.cleanup = std_cleanup,
 	.scan = scan,
-	.dev_list = dev_list,
+	.dev_list = std_dev_list,
 	.dev_clear = dev_clear,
 	.config_get = config_get,
 	.config_set = config_set,
@@ -550,5 +523,6 @@ SR_PRIV struct sr_dev_driver chronovu_la_driver_info = {
 	.dev_close = dev_close,
 	.dev_acquisition_start = dev_acquisition_start,
 	.dev_acquisition_stop = dev_acquisition_stop,
-	.priv = NULL,
+	.context = NULL,
 };
+SR_REGISTER_DEV_DRIVER(chronovu_la_driver_info);