X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=hardware%2Fsaleae-logic%2Fsaleae-logic.c;h=12ede4e168fb69d7053e4ba9bab07b1ddf35d987;hb=a7d05fcb388f142012035a0ed31bcf74d42bbe73;hp=98b9aad134c8f1832ddd0e44d0e6e733bf896181;hpb=57ab7d9f925c0f93ec711c4e6914881e5ff5dfd9;p=libsigrok.git

diff --git a/hardware/saleae-logic/saleae-logic.c b/hardware/saleae-logic/saleae-logic.c
index 98b9aad1..12ede4e1 100644
--- a/hardware/saleae-logic/saleae-logic.c
+++ b/hardware/saleae-logic/saleae-logic.c
@@ -36,7 +36,7 @@ static struct fx2_profile supported_fx2[] = {
 	{ 0, 0, 0, 0, 0, 0, 0, 0 }
 };
 
-static int capabilities[] = {
+static int hwcaps[] = {
 	SR_HWCAP_LOGIC_ANALYZER,
 	SR_HWCAP_SAMPLERATE,
 
@@ -87,14 +87,14 @@ static struct sr_samplerates samplerates = {
 	supported_samplerates,
 };
 
-/* List of struct sr_device_instance, maintained by opendev()/closedev(). */
-static GSList *device_instances = NULL;
+/* List of struct sr_dev_inst, maintained by opendev()/closedev(). */
+static GSList *dev_insts = NULL;
 static libusb_context *usb_context = NULL;
 
 static int new_saleae_logic_firmware = 0;
 
-static int hw_set_configuration(int device_index, int capability, void *value);
-static int hw_stop_acquisition(int device_index, gpointer session_device_id);
+static int hw_config_set(int dev_index, int hwcap, void *value);
+static int hw_stop_acquisition(int dev_index, gpointer session_dev_id);
 
 /**
  * Check the USB configuration to determine if this is a Saleae Logic.
@@ -165,15 +165,15 @@ static int check_conf_profile(libusb_device *dev)
 	return ret;
 }
 
-static int sl_open_device(int device_index)
+static int sl_open_dev(int dev_index)
 {
 	libusb_device **devlist;
 	struct libusb_device_descriptor des;
-	struct sr_device_instance *sdi;
-	struct fx2_device *fx2;
+	struct sr_dev_inst *sdi;
+	struct fx2_dev *fx2;
 	int err, skip, i;
 
-	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
+	if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
 		return SR_ERR;
 	fx2 = sdi->priv;
 
@@ -185,23 +185,24 @@ static int sl_open_device(int device_index)
 	libusb_get_device_list(usb_context, &devlist);
 	for (i = 0; devlist[i]; i++) {
 		if ((err = libusb_get_device_descriptor(devlist[i], &des))) {
-			sr_err("failed to get device descriptor: %d", err);
+			sr_err("logic: failed to get device descriptor: %d", err);
 			continue;
 		}
 
-		if (des.idVendor != fx2->profile->fw_vid || des.idProduct != fx2->profile->fw_pid)
+		if (des.idVendor != fx2->profile->fw_vid
+		    || des.idProduct != fx2->profile->fw_pid)
 			continue;
 
 		if (sdi->status == SR_ST_INITIALIZING) {
-			if (skip != device_index) {
+			if (skip != dev_index) {
 				/* Skip devices of this type that aren't the one we want. */
 				skip += 1;
 				continue;
 			}
 		} else if (sdi->status == SR_ST_INACTIVE) {
 			/*
-			 * This device is fully enumerated, so we need to find this
-			 * device by vendor, product, bus and address.
+			 * This device is fully enumerated, so we need to find
+			 * this device by vendor, product, bus and address.
 			 */
 			if (libusb_get_bus_number(devlist[i]) != fx2->usb->bus
 				|| libusb_get_device_address(devlist[i]) != fx2->usb->address)
@@ -218,11 +219,11 @@ static int sl_open_device(int device_index)
 				fx2->usb->address = libusb_get_device_address(devlist[i]);
 
 			sdi->status = SR_ST_ACTIVE;
-			sr_info("saleae: opened device %d on %d.%d interface %d",
-				  sdi->index, fx2->usb->bus,
-				  fx2->usb->address, USB_INTERFACE);
+			sr_info("logic: opened device %d on %d.%d interface %d",
+				sdi->index, fx2->usb->bus,
+				fx2->usb->address, USB_INTERFACE);
 		} else {
-			sr_err("failed to open device: %d", err);
+			sr_err("logic: failed to open device: %d", err);
 		}
 
 		/* if we made it here, we handled the device one way or another */
@@ -236,16 +237,16 @@ static int sl_open_device(int device_index)
 	return SR_OK;
 }
 
-static void close_device(struct sr_device_instance *sdi)
+static void close_dev(struct sr_dev_inst *sdi)
 {
-	struct fx2_device *fx2;
+	struct fx2_dev *fx2;
 
 	fx2 = sdi->priv;
 
 	if (fx2->usb->devhdl == NULL)
 		return;
 
-	sr_info("saleae: closing device %d on %d.%d interface %d", sdi->index,
+	sr_info("logic: closing device %d on %d.%d interface %d", sdi->index,
 		fx2->usb->bus, fx2->usb->address, USB_INTERFACE);
 	libusb_release_interface(fx2->usb->devhdl, USB_INTERFACE);
 	libusb_close(fx2->usb->devhdl);
@@ -253,7 +254,7 @@ static void close_device(struct sr_device_instance *sdi)
 	sdi->status = SR_ST_INACTIVE;
 }
 
-static int configure_probes(struct fx2_device *fx2, GSList *probes)
+static int configure_probes(struct fx2_dev *fx2, GSList *probes)
 {
 	struct sr_probe *probe;
 	GSList *l;
@@ -299,12 +300,12 @@ static int configure_probes(struct fx2_device *fx2, GSList *probes)
 	return SR_OK;
 }
 
-static struct fx2_device *fx2_device_new(void)
+static struct fx2_dev *fx2_dev_new(void)
 {
-	struct fx2_device *fx2;
+	struct fx2_dev *fx2;
 
-	if (!(fx2 = g_try_malloc0(sizeof(struct fx2_device)))) {
-		sr_err("saleae: %s: fx2 malloc failed", __func__);
+	if (!(fx2 = g_try_malloc0(sizeof(struct fx2_dev)))) {
+		sr_err("logic: %s: fx2 malloc failed", __func__);
 		return NULL;
 	}
 	fx2->trigger_stage = TRIGGER_FIRED;
@@ -318,20 +319,20 @@ static struct fx2_device *fx2_device_new(void)
  * API callbacks
  */
 
-static int hw_init(const char *deviceinfo)
+static int hw_init(const char *devinfo)
 {
-	struct sr_device_instance *sdi;
+	struct sr_dev_inst *sdi;
 	struct libusb_device_descriptor des;
 	struct fx2_profile *fx2_prof;
-	struct fx2_device *fx2;
+	struct fx2_dev *fx2;
 	libusb_device **devlist;
 	int err, devcnt, i, j;
 
 	/* Avoid compiler warnings. */
-	(void)deviceinfo;
+	(void)devinfo;
 
 	if (libusb_init(&usb_context) != 0) {
-		sr_err("Failed to initialize USB.");
+		sr_err("logic: Failed to initialize USB.");
 		return 0;
 	}
 
@@ -342,7 +343,8 @@ static int hw_init(const char *deviceinfo)
 		fx2_prof = NULL;
 		err = libusb_get_device_descriptor(devlist[i], &des);
 		if (err != 0) {
-			sr_err("failed to get device descriptor: %d", err);
+			sr_err("logic: failed to get device descriptor: %d",
+			       err);
 			continue;
 		}
 
@@ -357,21 +359,21 @@ static int hw_init(const char *deviceinfo)
 			/* not a supported VID/PID */
 			continue;
 
-		sdi = sr_device_instance_new(devcnt, SR_ST_INITIALIZING,
+		sdi = sr_dev_inst_new(devcnt, SR_ST_INITIALIZING,
 			fx2_prof->vendor, fx2_prof->model, fx2_prof->model_version);
 		if (!sdi)
 			return 0;
-		fx2 = fx2_device_new();
+		fx2 = fx2_dev_new();
 		fx2->profile = fx2_prof;
 		sdi->priv = fx2;
-		device_instances = g_slist_append(device_instances, sdi);
+		dev_insts = g_slist_append(dev_insts, sdi);
 
 		if (check_conf_profile(devlist[i])) {
 			/* Already has the firmware, so fix the new address. */
-			sr_dbg("Found a Saleae Logic with %s firmware.",
+			sr_dbg("logic: Found a Saleae Logic with %s firmware.",
 			       new_saleae_logic_firmware ? "new" : "old");
 			sdi->status = SR_ST_INACTIVE;
-			fx2->usb = sr_usb_device_instance_new
+			fx2->usb = sr_usb_dev_inst_new
 			    (libusb_get_bus_number(devlist[i]),
 			     libusb_get_device_address(devlist[i]), NULL);
 		} else {
@@ -379,8 +381,9 @@ static int hw_init(const char *deviceinfo)
 				/* Remember when the firmware on this device was updated */
 				g_get_current_time(&fx2->fw_updated);
 			else
-				sr_err("firmware upload failed for device %d", devcnt);
-			fx2->usb = sr_usb_device_instance_new
+				sr_err("logic: firmware upload failed for "
+				       "device %d", devcnt);
+			fx2->usb = sr_usb_dev_inst_new
 				(libusb_get_bus_number(devlist[i]), 0xff, NULL);
 		}
 		devcnt++;
@@ -390,14 +393,14 @@ static int hw_init(const char *deviceinfo)
 	return devcnt;
 }
 
-static int hw_opendev(int device_index)
+static int hw_opendev(int dev_index)
 {
 	GTimeVal cur_time;
-	struct sr_device_instance *sdi;
-	struct fx2_device *fx2;
+	struct sr_dev_inst *sdi;
+	struct fx2_dev *fx2;
 	int timediff, err;
 
-	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
+	if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
 		return SR_ERR;
 	fx2 = sdi->priv;
 
@@ -407,37 +410,37 @@ static int hw_opendev(int device_index)
 	 */
 	err = 0;
 	if (GTV_TO_MSEC(fx2->fw_updated) > 0) {
-		sr_info("saleae: waiting for device to reset");
+		sr_info("logic: waiting for device to reset");
 		/* takes at least 300ms for the FX2 to be gone from the USB bus */
-		g_usleep(300*1000);
+		g_usleep(300 * 1000);
 		timediff = 0;
 		while (timediff < MAX_RENUM_DELAY) {
-			if ((err = sl_open_device(device_index)) == SR_OK)
+			if ((err = sl_open_dev(dev_index)) == SR_OK)
 				break;
-			g_usleep(100*1000);
+			g_usleep(100 * 1000);
 			g_get_current_time(&cur_time);
 			timediff = GTV_TO_MSEC(cur_time) - GTV_TO_MSEC(fx2->fw_updated);
 		}
-		sr_info("saleae: device came back after %d ms", timediff);
+		sr_info("logic: device came back after %d ms", timediff);
 	} else {
-		err = sl_open_device(device_index);
+		err = sl_open_dev(dev_index);
 	}
 
 	if (err != SR_OK) {
-		sr_err("unable to open device");
+		sr_err("logic: unable to open device");
 		return SR_ERR;
 	}
 	fx2 = sdi->priv;
 
 	err = libusb_claim_interface(fx2->usb->devhdl, USB_INTERFACE);
 	if (err != 0) {
-		sr_err("Unable to claim interface: %d", err);
+		sr_err("logic: Unable to claim interface: %d", err);
 		return SR_ERR;
 	}
 
 	if (fx2->cur_samplerate == 0) {
 		/* Samplerate hasn't been set; default to the slowest one. */
-		if (hw_set_configuration(device_index, SR_HWCAP_SAMPLERATE,
+		if (hw_config_set(dev_index, SR_HWCAP_SAMPLERATE,
 		    &supported_samplerates[0]) == SR_ERR)
 			return SR_ERR;
 	}
@@ -445,17 +448,17 @@ static int hw_opendev(int device_index)
 	return SR_OK;
 }
 
-static int hw_closedev(int device_index)
+static int hw_closedev(int dev_index)
 {
-	struct sr_device_instance *sdi;
+	struct sr_dev_inst *sdi;
 
-	if (!(sdi = sr_get_device_instance(device_instances, device_index))) {
+	if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
 		sr_err("logic: %s: sdi was NULL", __func__);
 		return SR_ERR; /* TODO: SR_ERR_ARG? */
 	}
 
 	/* TODO */
-	close_device(sdi);
+	close_dev(sdi);
 
 	return SR_OK;
 }
@@ -463,32 +466,32 @@ static int hw_closedev(int device_index)
 static int hw_cleanup(void)
 {
 	GSList *l;
-	struct sr_device_instance *sdi;
-	struct fx2_device *fx2;
+	struct sr_dev_inst *sdi;
+	struct fx2_dev *fx2;
 	int ret = SR_OK;
 
 	/* Properly close and free all devices. */
-	for (l = device_instances; l; l = l->next) {
+	for (l = dev_insts; l; l = l->next) {
 		if (!(sdi = l->data)) {
 			/* Log error, but continue cleaning up the rest. */
-			sr_err("fx2: %s: sdi was NULL, continuing", __func__);
+			sr_err("logic: %s: sdi was NULL, continuing", __func__);
 			ret = SR_ERR_BUG;
 			continue;
 		}
 		if (!(fx2 = sdi->priv)) {
 			/* Log error, but continue cleaning up the rest. */
-			sr_err("fx2: %s: sdi->priv was NULL, continuing",
+			sr_err("logic: %s: sdi->priv was NULL, continuing",
 			       __func__);
 			ret = SR_ERR_BUG;
 			continue;
 		}
-		close_device(sdi);
-		sr_usb_device_instance_free(fx2->usb);
-		sr_device_instance_free(sdi);
+		close_dev(sdi);
+		sr_usb_dev_inst_free(fx2->usb);
+		sr_dev_inst_free(sdi);
 	}
 
-	g_slist_free(device_instances);
-	device_instances = NULL;
+	g_slist_free(dev_insts);
+	dev_insts = NULL;
 
 	if (usb_context)
 		libusb_exit(usb_context);
@@ -497,18 +500,18 @@ static int hw_cleanup(void)
 	return ret;
 }
 
-static void *hw_get_device_info(int device_index, int device_info_id)
+static void *hw_get_dev_info(int dev_index, int dev_info_id)
 {
-	struct sr_device_instance *sdi;
-	struct fx2_device *fx2;
+	struct sr_dev_inst *sdi;
+	struct fx2_dev *fx2;
 	void *info = NULL;
 
-	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
+	if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
 		return NULL;
 	fx2 = sdi->priv;
 
-	switch (device_info_id) {
-	case SR_DI_INSTANCE:
+	switch (dev_info_id) {
+	case SR_DI_INST:
 		info = sdi;
 		break;
 	case SR_DI_NUM_PROBES:
@@ -531,20 +534,20 @@ static void *hw_get_device_info(int device_index, int device_info_id)
 	return info;
 }
 
-static int hw_get_status(int device_index)
+static int hw_get_status(int dev_index)
 {
-	struct sr_device_instance *sdi;
+	struct sr_dev_inst *sdi;
 
-	sdi = sr_get_device_instance(device_instances, device_index);
+	sdi = sr_dev_inst_get(dev_insts, dev_index);
 	if (sdi)
 		return sdi->status;
 	else
 		return SR_ST_NOT_FOUND;
 }
 
-static int *hw_get_capabilities(void)
+static int *hw_hwcap_get_all(void)
 {
-	return capabilities;
+	return hwcaps;
 }
 
 static uint8_t new_firmware_divider_value(uint64_t samplerate)
@@ -583,15 +586,14 @@ static uint8_t new_firmware_divider_value(uint64_t samplerate)
 	}
 
 	/* Shouldn't happen. */
-	sr_err("saleae: %s: Invalid samplerate %" PRIu64 "",
+	sr_err("logic: %s: Invalid samplerate %" PRIu64 "",
 	       __func__, samplerate);
 	return 0;
 }
 
-static int set_configuration_samplerate(struct sr_device_instance *sdi,
-					uint64_t samplerate)
+static int config_set_samplerate(struct sr_dev_inst *sdi, uint64_t samplerate)
 {
-	struct fx2_device *fx2;
+	struct fx2_dev *fx2;
 	uint8_t divider;
 	int ret, result, i;
 	unsigned char buf[2];
@@ -609,7 +611,7 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi,
 	else
 		divider = (uint8_t) (48 / (samplerate / 1000000.0)) - 1;
 
-	sr_info("saleae: setting samplerate to %" PRIu64 " Hz (divider %d)",
+	sr_info("logic: setting samplerate to %" PRIu64 " Hz (divider %d)",
 		samplerate, divider);
 
 	buf[0] = (new_saleae_logic_firmware) ? 0xd5 : 0x01;
@@ -617,7 +619,7 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi,
 	ret = libusb_bulk_transfer(fx2->usb->devhdl, 1 | LIBUSB_ENDPOINT_OUT,
 				   buf, 2, &result, 500);
 	if (ret != 0) {
-		sr_err("failed to set samplerate: %d", ret);
+		sr_err("logic: failed to set samplerate: %d", ret);
 		return SR_ERR;
 	}
 	fx2->cur_samplerate = samplerate;
@@ -625,23 +627,23 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi,
 	return SR_OK;
 }
 
-static int hw_set_configuration(int device_index, int capability, void *value)
+static int hw_config_set(int dev_index, int hwcap, void *value)
 {
-	struct sr_device_instance *sdi;
-	struct fx2_device *fx2;
+	struct sr_dev_inst *sdi;
+	struct fx2_dev *fx2;
 	int ret;
 	uint64_t *tmp_u64;
 
-	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
+	if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
 		return SR_ERR;
 	fx2 = sdi->priv;
 
-	if (capability == SR_HWCAP_SAMPLERATE) {
+	if (hwcap == SR_HWCAP_SAMPLERATE) {
 		tmp_u64 = value;
-		ret = set_configuration_samplerate(sdi, *tmp_u64);
-	} else if (capability == SR_HWCAP_PROBECONFIG) {
+		ret = config_set_samplerate(sdi, *tmp_u64);
+	} else if (hwcap == SR_HWCAP_PROBECONFIG) {
 		ret = configure_probes(fx2, (GSList *) value);
-	} else if (capability == SR_HWCAP_LIMIT_SAMPLES) {
+	} else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
 		tmp_u64 = value;
 		fx2->limit_samples = *tmp_u64;
 		ret = SR_OK;
@@ -669,12 +671,12 @@ static int receive_data(int fd, int revents, void *user_data)
 
 static void receive_transfer(struct libusb_transfer *transfer)
 {
-	/* TODO: these statics have to move to fx2_device struct */
+	/* TODO: these statics have to move to fx2_dev struct */
 	static int num_samples = 0;
 	static int empty_transfer_count = 0;
 	struct sr_datafeed_packet packet;
 	struct sr_datafeed_logic logic;
-	struct fx2_device *fx2;
+	struct fx2_dev *fx2;
 	int cur_buflen, trigger_offset, i;
 	unsigned char *cur_buf, *new_buf;
 
@@ -692,7 +694,7 @@ static void receive_transfer(struct libusb_transfer *transfer)
 		return;
 	}
 
-	sr_info("saleae: receive_transfer(): status %d received %d bytes",
+	sr_info("logic: receive_transfer(): status %d received %d bytes",
 		transfer->status, transfer->actual_length);
 
 	/* Save incoming transfer before reusing the transfer struct. */
@@ -702,7 +704,7 @@ static void receive_transfer(struct libusb_transfer *transfer)
 
 	/* Fire off a new request. */
 	if (!(new_buf = g_try_malloc(4096))) {
-		sr_err("saleae: %s: new_buf malloc failed", __func__);
+		sr_err("logic: %s: new_buf malloc failed", __func__);
 		return; /* TODO: SR_ERR_MALLOC */
 	}
 
@@ -710,7 +712,8 @@ static void receive_transfer(struct libusb_transfer *transfer)
 	transfer->length = 4096;
 	if (libusb_submit_transfer(transfer) != 0) {
 		/* TODO: Stop session? */
-		sr_err("eek");
+		/* TODO: Better error message. */
+		sr_err("logic: %s: libusb_submit_transfer error", __func__);
 	}
 
 	if (cur_buflen == 0) {
@@ -804,29 +807,29 @@ static void receive_transfer(struct libusb_transfer *transfer)
 	}
 }
 
-static int hw_start_acquisition(int device_index, gpointer session_data)
+static int hw_start_acquisition(int dev_index, gpointer session_data)
 {
-	struct sr_device_instance *sdi;
+	struct sr_dev_inst *sdi;
 	struct sr_datafeed_packet *packet;
 	struct sr_datafeed_header *header;
-	struct fx2_device *fx2;
+	struct fx2_dev *fx2;
 	struct libusb_transfer *transfer;
 	const struct libusb_pollfd **lupfd;
 	int size, i;
 	unsigned char *buf;
 
-	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
+	if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
 		return SR_ERR;
 	fx2 = sdi->priv;
 	fx2->session_data = session_data;
 
 	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
-		sr_err("saleae: %s: packet malloc failed", __func__);
+		sr_err("logic: %s: packet malloc failed", __func__);
 		return SR_ERR_MALLOC;
 	}
 
 	if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
-		sr_err("saleae: %s: header malloc failed", __func__);
+		sr_err("logic: %s: header malloc failed", __func__);
 		return SR_ERR_MALLOC;
 	}
 
@@ -834,7 +837,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
 	size = 2048;
 	for (i = 0; i < NUM_SIMUL_TRANSFERS; i++) {
 		if (!(buf = g_try_malloc(size))) {
-			sr_err("saleae: %s: buf malloc failed", __func__);
+			sr_err("logic: %s: buf malloc failed", __func__);
 			return SR_ERR_MALLOC;
 		}
 		transfer = libusb_alloc_transfer(0);
@@ -869,13 +872,13 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
 	return SR_OK;
 }
 
-/* This stops acquisition on ALL devices, ignoring device_index. */
-static int hw_stop_acquisition(int device_index, gpointer session_data)
+/* This stops acquisition on ALL devices, ignoring dev_index. */
+static int hw_stop_acquisition(int dev_index, gpointer session_data)
 {
 	struct sr_datafeed_packet packet;
 
 	/* Avoid compiler warnings. */
-	(void)device_index;
+	(void)dev_index;
 
 	packet.type = SR_DF_END;
 	sr_session_bus(session_data, &packet);
@@ -887,7 +890,7 @@ static int hw_stop_acquisition(int device_index, gpointer session_data)
 	return SR_OK;
 }
 
-SR_PRIV struct sr_device_plugin saleae_logic_plugin_info = {
+SR_PRIV struct sr_dev_plugin saleae_logic_plugin_info = {
 	.name = "saleae-logic",
 	.longname = "Saleae Logic",
 	.api_version = 1,
@@ -895,10 +898,10 @@ SR_PRIV struct sr_device_plugin saleae_logic_plugin_info = {
 	.cleanup = hw_cleanup,
 	.opendev = hw_opendev,
 	.closedev = hw_closedev,
-	.get_device_info = hw_get_device_info,
+	.get_dev_info = hw_get_dev_info,
 	.get_status = hw_get_status,
-	.get_capabilities = hw_get_capabilities,
-	.set_configuration = hw_set_configuration,
+	.hwcap_get_all = hw_hwcap_get_all,
+	.config_set = hw_config_set,
 	.start_acquisition = hw_start_acquisition,
 	.stop_acquisition = hw_stop_acquisition,
 };