[libsigrok.git] / src / hardware / hantek-4032l / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2016 Andreas Zschunke <andreas.zschunke@gmx.net>
 * Copyright (C) 2017 Andrej Valek <andy@skyrain.eu>
 * Copyright (C) 2017 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
 * 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 <config.h>
#include "protocol.h"

#define H4032L_USB_TIMEOUT 500

enum h4032l_cmd {
	CMD_RESET = 0x00b3, /* Also arms the logic analyzer. */
	CMD_CONFIGURE = 0x2b1a,
	CMD_STATUS = 0x4b3a,
	CMD_GET = 0x6b5a
};

struct h4032l_status_packet {
	uint32_t magic;
	uint32_t values;
	uint32_t status;
	uint32_t usbxi_data;
	uint32_t fpga_version;
};

static void abort_acquisition(struct dev_context *devc)
{
	int i;

	devc->acq_aborted = TRUE;

	for (i = devc->num_transfers - 1; i >= 0; i--) {
		if (devc->transfers[i])
			libusb_cancel_transfer(devc->transfers[i]);
	}

	devc->status = H4032L_STATUS_IDLE;
}

static void finish_acquisition(struct sr_dev_inst *sdi)
{
	struct dev_context *devc = sdi->priv;
	struct drv_context *drvc = sdi->driver->context;

	std_session_send_df_end(sdi);
	usb_source_remove(sdi->session, drvc->sr_ctx);

	devc->num_transfers = 0;
	g_free(devc->transfers);
}

static void free_transfer(struct libusb_transfer *transfer)
{
	struct sr_dev_inst *sdi = transfer->user_data;
	struct dev_context *devc = sdi->priv;
	unsigned int i;

	if ((transfer->buffer != (unsigned char *)&devc->cmd_pkt) &&
	    (transfer->buffer != devc->buf)) {
		g_free(transfer->buffer);
	}

	transfer->buffer = NULL;
	libusb_free_transfer(transfer);

	for (i = 0; i < devc->num_transfers; i++) {
		if (devc->transfers[i] == transfer) {
			devc->transfers[i] = NULL;
			break;
		}
	}

	if (--devc->submitted_transfers == 0)
		finish_acquisition(sdi);
}

static void resubmit_transfer(struct libusb_transfer *transfer)
{
	int ret;

	if ((ret = libusb_submit_transfer(transfer)) == LIBUSB_SUCCESS)
		return;

	sr_err("%s: %s", __func__, libusb_error_name(ret));
	free_transfer(transfer);
}

static void send_data(struct sr_dev_inst *sdi,
	uint32_t *data, size_t sample_count)
{
	struct dev_context *devc = sdi->priv;
	struct sr_datafeed_logic logic = {
		.length = sample_count * sizeof(uint32_t),
		.unitsize = sizeof(uint32_t),
		.data = data
	};
	const struct sr_datafeed_packet packet = {
		.type = SR_DF_LOGIC,
		.payload = &logic
	};
	const struct sr_datafeed_packet trig = {
		.type = SR_DF_TRIGGER,
		.payload = NULL
	};
	size_t trigger_offset;

	if (devc->trigger_pos >= devc->sent_samples &&
		devc->trigger_pos < (devc->sent_samples + sample_count)) {
		/* Get trigger position. */
		trigger_offset = devc->trigger_pos - devc->sent_samples;
		logic.length = trigger_offset * sizeof(uint32_t);
		if (logic.length)
			sr_session_send(sdi, &packet);

		/* Send trigger position. */
		sr_session_send(sdi, &trig);

		/* Send rest of data. */
		logic.length = (sample_count-trigger_offset) * sizeof(uint32_t);
		logic.data = data + trigger_offset;
		if (logic.length)
			sr_session_send(sdi, &packet);
	} else {
		sr_session_send(sdi, &packet);
	}

	devc->sent_samples += sample_count;
}

SR_PRIV int h4032l_receive_data(int fd, int revents, void *cb_data)
{
	struct timeval tv;
	struct drv_context *drvc;

	(void)fd;
	(void)revents;

	drvc = (struct drv_context *)cb_data;

	tv.tv_sec = tv.tv_usec = 0;
	libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);

	return TRUE;
}

void LIBUSB_CALL h4032l_data_transfer_callback(struct libusb_transfer *transfer)
{
	struct sr_dev_inst *const sdi = transfer->user_data;
	struct dev_context *const devc = sdi->priv;
	uint32_t max_samples = transfer->actual_length / sizeof(uint32_t);
	uint32_t *buf;
	uint32_t num_samples;

	/*
	 * If acquisition has already ended, just free any queued up
	 * transfer that come in.
	 */
	if (devc->acq_aborted) {
		free_transfer(transfer);
		return;
	}

	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
		sr_dbg("%s error: %d.", __func__, transfer->status);

	/* Cancel pending transfers. */
	if (transfer->actual_length == 0) {
		resubmit_transfer(transfer);
		return;
	}

	buf = (uint32_t *)transfer->buffer;

	num_samples = MIN(devc->remaining_samples, max_samples);
	devc->remaining_samples -= num_samples;
	send_data(sdi, buf, num_samples);
	sr_dbg("Remaining: %d %08X %08X.", devc->remaining_samples,
		buf[0], buf[1]);

	/* Close data receiving. */
	if (devc->remaining_samples == 0) {
		if (buf[num_samples] != H4032L_END_PACKET_MAGIC)
			sr_err("Mismatch magic number of end poll.");

		abort_acquisition(devc);
		free_transfer(transfer);
	} else {
		if (((devc->submitted_transfers - 1) * H4032L_DATA_BUFFER_SIZE) <
		    (int32_t)(devc->remaining_samples * sizeof(uint32_t)))
			resubmit_transfer(transfer);
		else
			free_transfer(transfer);
	}
}

void LIBUSB_CALL h4032l_usb_callback(struct libusb_transfer *transfer)
{
	struct sr_dev_inst *const sdi = transfer->user_data;
	struct dev_context *const devc = sdi->priv;
	struct sr_usb_dev_inst *usb = sdi->conn;
	gboolean cmd = FALSE;
	uint32_t max_samples = transfer->actual_length / sizeof(uint32_t);
	uint32_t *buf;
	struct h4032l_status_packet *status;
	uint32_t num_samples;
	int ret;

	/*
	 * If acquisition has already ended, just free any queued up
	 * transfers that come in.
	 */
	if (devc->acq_aborted) {
		free_transfer(transfer);
		return;
	}

	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
		sr_dbg("%s error: %d.", __func__, transfer->status);

	buf = (uint32_t *)transfer->buffer;

	switch (devc->status) {
	case H4032L_STATUS_IDLE:
		sr_err("USB callback called in idle.");
		break;
	case H4032L_STATUS_CMD_CONFIGURE:
		/* Select status request as next. */
		cmd = TRUE;
		devc->cmd_pkt.cmd = CMD_STATUS;
		devc->status = H4032L_STATUS_CMD_STATUS;
		break;
	case H4032L_STATUS_CMD_STATUS:
		/* Select status request as next. */
		devc->status = H4032L_STATUS_RESPONSE_STATUS;
		break;
	case H4032L_STATUS_RESPONSE_STATUS:
		/*
		 * Check magic and if status is complete, then select
		 * First Transfer as next.
		 */
		status = (struct h4032l_status_packet *)transfer->buffer;
		if (status->magic != H4032L_STATUS_PACKET_MAGIC)
			devc->status = H4032L_STATUS_RESPONSE_STATUS;
		else if (status->status == 2)
			devc->status = H4032L_STATUS_RESPONSE_STATUS_CONTINUE;
		else
			devc->status = H4032L_STATUS_RESPONSE_STATUS_RETRY;
		break;
	case H4032L_STATUS_RESPONSE_STATUS_RETRY:
		devc->status = H4032L_STATUS_CMD_STATUS;
		devc->cmd_pkt.cmd = CMD_STATUS;
		cmd = TRUE;
		break;
	case H4032L_STATUS_RESPONSE_STATUS_CONTINUE:
		devc->status = H4032L_STATUS_CMD_GET;
		devc->cmd_pkt.cmd = CMD_GET;
		cmd = TRUE;
		break;
	case H4032L_STATUS_CMD_GET:
		devc->status = H4032L_STATUS_FIRST_TRANSFER;
		/* Trigger has been captured. */
		std_session_send_df_header(sdi);
		break;
	case H4032L_STATUS_FIRST_TRANSFER:
		/* Drop packets until H4032L_START_PACKET_MAGIC. */
		if (buf[0] != H4032L_START_PACKET_MAGIC) {
			sr_dbg("Mismatch magic number of start poll.");
			break;
		}
		devc->status = H4032L_STATUS_TRANSFER;
		max_samples--;
		buf++;
		/* Fallthrough. */
	case H4032L_STATUS_TRANSFER:
		num_samples = MIN(devc->remaining_samples, max_samples);
		devc->remaining_samples -= num_samples;
		send_data(sdi, buf, num_samples);
		sr_dbg("Remaining: %d %08X %08X.", devc->remaining_samples,
		       buf[0], buf[1]);
		break;
	}

	/* Start data receiving. */
	if (devc->status == H4032L_STATUS_TRANSFER) {
		if ((ret = h4032l_start_data_transfers(sdi)) != SR_OK) {
			sr_err("Can not start data transfers: %d", ret);
			devc->status = H4032L_STATUS_IDLE;
		}
	} else if (devc->status != H4032L_STATUS_IDLE) {
		if (cmd) {
			/* Setup new USB cmd packet, reuse transfer object. */
			sr_dbg("New command: %d.", devc->status);
			libusb_fill_bulk_transfer(transfer, usb->devhdl,
				2 | LIBUSB_ENDPOINT_OUT,
				(unsigned char *)&devc->cmd_pkt,
				sizeof(struct h4032l_cmd_pkt),
				h4032l_usb_callback,
				(void *)sdi, H4032L_USB_TIMEOUT);
		} else {
			/* Setup new USB poll packet, reuse transfer object. */
			sr_dbg("Poll: %d.", devc->status);
			libusb_fill_bulk_transfer(transfer, usb->devhdl,
				6 | LIBUSB_ENDPOINT_IN,
				devc->buf, ARRAY_SIZE(devc->buf),
				h4032l_usb_callback,
				(void *)sdi, H4032L_USB_TIMEOUT);
		}
		/* Send prepared USB packet. */
		if ((ret = libusb_submit_transfer(transfer)) != 0) {
			sr_err("Failed to submit transfer: %s.",
			       libusb_error_name(ret));
			devc->status = H4032L_STATUS_IDLE;
		}
	} else {
		sr_dbg("Now idle.");
	}

	if (devc->status == H4032L_STATUS_IDLE)
		free_transfer(transfer);
}

uint16_t h4032l_voltage2pwm(double voltage)
{
	/*
	 * word PwmA - channel A Vref PWM value, pseudocode:
	 * -6V < ThresholdVoltage < +6V
	 * Vref = 1.8 - ThresholdVoltage
	 * if Vref > 10.0
	 * 	Vref = 10.0
	 * if Vref < -5.0
	 * 	Vref = -5.0
	 * pwm = ToInt((Vref + 5.0) / 15.0 * 4096.0)
	 * if pwm > 4095
	 * 	pwm = 4095
	 */
	voltage = 1.8 - voltage;
	if (voltage > 10.0)
		voltage = 10.0;
	else if (voltage < -5.0)
		voltage = -5.0;

	return (uint16_t) ((voltage + 5.0) * (4096.0 / 15.0));
}

SR_PRIV int h4032l_start_data_transfers(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc = sdi->priv;
	struct sr_usb_dev_inst *usb = sdi->conn;
	struct libusb_transfer *transfer;
	uint8_t *buf;
	unsigned int num_transfers;
	unsigned int i;
	int ret;

	devc->submitted_transfers = 0;

	/*
	 * Set number of data transfers regarding to size of buffer.
	 * FPGA version 0 can't transfer multiple transfers at once.
	 */
	if ((num_transfers = MIN(devc->remaining_samples * sizeof(uint32_t) /
	    H4032L_DATA_BUFFER_SIZE, devc->fpga_version ?
	    H4032L_DATA_TRANSFER_MAX_NUM : 1)) == 0)
		num_transfers = 1;

	g_free(devc->transfers);
	devc->transfers = g_malloc(sizeof(*devc->transfers) * num_transfers);
	devc->num_transfers = num_transfers;

	for (i = 0; i < num_transfers; i++) {
		buf = g_malloc(H4032L_DATA_BUFFER_SIZE);
		transfer = libusb_alloc_transfer(0);

		libusb_fill_bulk_transfer(transfer, usb->devhdl,
			6 | LIBUSB_ENDPOINT_IN,
			buf, H4032L_DATA_BUFFER_SIZE,
			h4032l_data_transfer_callback,
			(void *)sdi, H4032L_USB_TIMEOUT);

		/* Send prepared usb packet. */
		if ((ret = libusb_submit_transfer(transfer)) != 0) {
			sr_err("Failed to submit transfer: %s.",
			       libusb_error_name(ret));
			libusb_free_transfer(transfer);
			g_free(buf);
			abort_acquisition(devc);
			return SR_ERR;
		}
		devc->transfers[i] = transfer;
		devc->submitted_transfers++;
	}

	return SR_OK;
}

SR_PRIV int h4032l_start(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc = sdi->priv;
	struct sr_usb_dev_inst *usb = sdi->conn;
	struct libusb_transfer *transfer;
	unsigned char buf[] = {0x0f, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	int ret;

	/* Send reset command to arm the logic analyzer. */
	if ((ret = libusb_control_transfer(usb->devhdl,
		LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT, CMD_RESET,
		0x00, 0x00, buf, ARRAY_SIZE(buf), H4032L_USB_TIMEOUT)) < 0) {
		sr_err("Failed to send vendor request %s.",
		       libusb_error_name(ret));
		return SR_ERR;
	}

	/* Wait for reset vendor request. */
	g_usleep(20 * 1000);

	/* Send configure command. */
	devc->cmd_pkt.cmd = CMD_CONFIGURE;
	devc->status = H4032L_STATUS_CMD_CONFIGURE;
	devc->remaining_samples = devc->cmd_pkt.sample_size;

	transfer = libusb_alloc_transfer(0);

	libusb_fill_bulk_transfer(transfer, usb->devhdl,
		2 | LIBUSB_ENDPOINT_OUT, (unsigned char *)&devc->cmd_pkt,
		sizeof(struct h4032l_cmd_pkt), h4032l_usb_callback,
		(void *)sdi, H4032L_USB_TIMEOUT);

	if ((ret = libusb_submit_transfer(transfer)) != 0) {
		sr_err("Failed to submit transfer: %s.",
		       libusb_error_name(ret));
		libusb_free_transfer(transfer);
		return SR_ERR;
	}

	devc->transfers = g_malloc0(sizeof(*devc->transfers));
	devc->submitted_transfers++;
	devc->num_transfers = 1;
	devc->transfers[0] = transfer;

	return SR_OK;
}

SR_PRIV int h4032l_stop(struct sr_dev_inst *sdi)
{
	abort_acquisition(sdi->priv);

	return SR_OK;
}

SR_PRIV int h4032l_dev_open(struct sr_dev_inst *sdi)
{
	struct drv_context *drvc = sdi->driver->context;
	struct sr_usb_dev_inst *usb = sdi->conn;
	struct libusb_device_descriptor des;
	libusb_device **devlist;
	int ret = SR_ERR, i, device_count;
	char connection_id[64];

	device_count = libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
	if (device_count < 0) {
		sr_err("Failed to get device list: %s.",
		       libusb_error_name(device_count));
		return SR_ERR;
	}

	for (i = 0; i < device_count; i++) {
		libusb_get_device_descriptor(devlist[i], &des);

		if (des.idVendor != H4032L_USB_VENDOR ||
		    des.idProduct != H4032L_USB_PRODUCT)
			continue;

		if ((sdi->status == SR_ST_INITIALIZING) ||
		    (sdi->status == SR_ST_INACTIVE)) {
			/* Check device by its physical USB bus/port address. */
			if (usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)) < 0)
				continue;

			if (strcmp(sdi->connection_id, connection_id))
				/* This is not the one. */
				continue;
		}

		if (!(ret = libusb_open(devlist[i], &usb->devhdl))) {
			if (usb->address == 0xff)
				/*
				 * First time we touch this device after FW
				 * upload, so we don't know the address yet.
				 */
				usb->address =
					libusb_get_device_address(devlist[i]);
		} else {
			sr_err("Failed to open device: %s.",
			       libusb_error_name(ret));
			ret = SR_ERR;
			break;
		}

		ret = SR_OK;
		break;
	}

	libusb_free_device_list(devlist, 1);
	return ret;
}

SR_PRIV int h4032l_get_fpga_version(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc = sdi->priv;
	struct sr_usb_dev_inst *usb = sdi->conn;
	struct h4032l_status_packet *status;
	int transferred;
	int i, ret;

	/* Set command to status. */
	devc->cmd_pkt.magic = H4032L_CMD_PKT_MAGIC;
	devc->cmd_pkt.cmd = CMD_STATUS;

	/* Send status request. */
	if ((ret = libusb_bulk_transfer(usb->devhdl,
		2 | LIBUSB_ENDPOINT_OUT, (unsigned char *)&devc->cmd_pkt,
		sizeof(struct h4032l_cmd_pkt), &transferred, H4032L_USB_TIMEOUT)) < 0) {
		sr_err("Unable to send FPGA version request: %s.",
		       libusb_error_name(ret));
		return SR_ERR;
	}

	/* Attempt to get FGPA version. */
	for (i = 0; i < 10; i++) {
		if ((ret = libusb_bulk_transfer(usb->devhdl,
			6 | LIBUSB_ENDPOINT_IN, devc->buf,
			ARRAY_SIZE(devc->buf), &transferred, H4032L_USB_TIMEOUT)) < 0) {
			sr_err("Unable to receive FPGA version: %s.",
			       libusb_error_name(ret));
			return SR_ERR;
		}
		status = (struct h4032l_status_packet *)devc->buf;
		if (status->magic == H4032L_STATUS_PACKET_MAGIC) {
			sr_dbg("FPGA version: 0x%x.", status->fpga_version);
			devc->fpga_version = status->fpga_version;
			return SR_OK;
		}
	}

	sr_err("Unable to get FPGA version.");

	return SR_ERR;
}
Commit	Line	Data
6a25fa42 AZ	1	/*
	2	* This file is part of the libsigrok project.
	3	*
5089a143 AZ	4	* Copyright (C) 2016 Andreas Zschunke <andreas.zschunke@gmx.net>
	5	* Copyright (C) 2017 Andrej Valek <andy@skyrain.eu>
	6	* Copyright (C) 2017 Uwe Hermann <uwe@hermann-uwe.de>
6a25fa42 AZ	7	*
	8	* This program is free software: you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation, either version 3 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	20	*/
	21
	22	#include <config.h>
	23	#include "protocol.h"
	24
5089a143 AZ	25	#define H4032L_USB_TIMEOUT 500
	26
	27	enum h4032l_cmd {
74c4c174 AV	28	CMD_RESET = 0x00b3, /* Also arms the logic analyzer. */
74c4c174 AV	29	CMD_CONFIGURE = 0x2b1a,
5089a143 AZ	30	CMD_STATUS = 0x4b3a,
	31	CMD_GET = 0x6b5a
	32	};
	33
e80e1858	34	struct h4032l_status_packet {
5089a143 AZ	35	uint32_t magic;
	36	uint32_t values;
	37	uint32_t status;
2bd5d17c UH	38	uint32_t usbxi_data;
2bd5d17c UH	39	uint32_t fpga_version;
5089a143 AZ	40	};
5089a143 AZ	41
2958315d AV	42	static void abort_acquisition(struct dev_context *devc)
	43	{
	44	int i;
	45
	46	devc->acq_aborted = TRUE;
	47
	48	for (i = devc->num_transfers - 1; i >= 0; i--) {
	49	if (devc->transfers[i])
	50	libusb_cancel_transfer(devc->transfers[i]);
	51	}
	52
	53	devc->status = H4032L_STATUS_IDLE;
	54	}
	55
a5b9880e AV	56	static void finish_acquisition(struct sr_dev_inst *sdi)
a5b9880e AV	57	{
2958315d	58	struct dev_context *devc = sdi->priv;
a5b9880e AV	59	struct drv_context *drvc = sdi->driver->context;
	60
	61	std_session_send_df_end(sdi);
	62	usb_source_remove(sdi->session, drvc->sr_ctx);
2958315d AV	63
	64	devc->num_transfers = 0;
	65	g_free(devc->transfers);
a5b9880e AV	66	}
	67
	68	static void free_transfer(struct libusb_transfer *transfer)
	69	{
	70	struct sr_dev_inst *sdi = transfer->user_data;
	71	struct dev_context *devc = sdi->priv;
2958315d AV	72	unsigned int i;
	73
	74	if ((transfer->buffer != (unsigned char *)&devc->cmd_pkt) &&
c7b5c358	75	(transfer->buffer != devc->buf)) {
2958315d AV	76	g_free(transfer->buffer);
2958315d AV	77	}
a5b9880e AV	78
	79	transfer->buffer = NULL;
	80	libusb_free_transfer(transfer);
a5b9880e	81
2958315d AV	82	for (i = 0; i < devc->num_transfers; i++) {
	83	if (devc->transfers[i] == transfer) {
	84	devc->transfers[i] = NULL;
	85	break;
	86	}
	87	}
	88
	89	if (--devc->submitted_transfers == 0)
	90	finish_acquisition(sdi);
a5b9880e AV	91	}
a5b9880e AV	92
43d86035 AV	93	static void resubmit_transfer(struct libusb_transfer *transfer)
	94	{
	95	int ret;
	96
	97	if ((ret = libusb_submit_transfer(transfer)) == LIBUSB_SUCCESS)
	98	return;
	99
	100	sr_err("%s: %s", __func__, libusb_error_name(ret));
	101	free_transfer(transfer);
	102	}
	103
3dc976fe AV	104	static void send_data(struct sr_dev_inst *sdi,
	105	uint32_t *data, size_t sample_count)
	106	{
	107	struct dev_context *devc = sdi->priv;
	108	struct sr_datafeed_logic logic = {
	109	.length = sample_count * sizeof(uint32_t),
	110	.unitsize = sizeof(uint32_t),
	111	.data = data
	112	};
	113	const struct sr_datafeed_packet packet = {
	114	.type = SR_DF_LOGIC,
	115	.payload = &logic
	116	};
	117	const struct sr_datafeed_packet trig = {
	118	.type = SR_DF_TRIGGER,
	119	.payload = NULL
	120	};
	121	size_t trigger_offset;
	122
	123	if (devc->trigger_pos >= devc->sent_samples &&
	124	devc->trigger_pos < (devc->sent_samples + sample_count)) {
	125	/* Get trigger position. */
	126	trigger_offset = devc->trigger_pos - devc->sent_samples;
	127	logic.length = trigger_offset * sizeof(uint32_t);
	128	if (logic.length)
	129	sr_session_send(sdi, &packet);
	130
	131	/* Send trigger position. */
	132	sr_session_send(sdi, &trig);
	133
	134	/* Send rest of data. */
	135	logic.length = (sample_count-trigger_offset) * sizeof(uint32_t);
	136	logic.data = data + trigger_offset;
	137	if (logic.length)
	138	sr_session_send(sdi, &packet);
	139	} else {
	140	sr_session_send(sdi, &packet);
	141	}
	142
	143	devc->sent_samples += sample_count;
	144	}
	145
5089a143	146	SR_PRIV int h4032l_receive_data(int fd, int revents, void *cb_data)
6a25fa42	147	{
5089a143 AZ	148	struct timeval tv;
5089a143 AZ	149	struct drv_context *drvc;
6a25fa42 AZ	150
6a25fa42 AZ	151	(void)fd;
5089a143 AZ	152	(void)revents;
	153
	154	drvc = (struct drv_context *)cb_data;
	155
	156	tv.tv_sec = tv.tv_usec = 0;
	157	libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
6a25fa42	158
5089a143 AZ	159	return TRUE;
5089a143 AZ	160	}
6a25fa42	161
43d86035	162	void LIBUSB_CALL h4032l_data_transfer_callback(struct libusb_transfer *transfer)
5089a143	163	{
3dc976fe AV	164	struct sr_dev_inst *const sdi = transfer->user_data;
3dc976fe AV	165	struct dev_context *const devc = sdi->priv;
43d86035	166	uint32_t max_samples = transfer->actual_length / sizeof(uint32_t);
c7b5c358	167	uint32_t *buf;
7b9387b8	168	uint32_t num_samples;
43d86035 AV	169
	170	/*
	171	* If acquisition has already ended, just free any queued up
	172	* transfer that come in.
	173	*/
	174	if (devc->acq_aborted) {
	175	free_transfer(transfer);
	176	return;
	177	}
	178
	179	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
	180	sr_dbg("%s error: %d.", __func__, transfer->status);
	181
	182	/* Cancel pending transfers. */
	183	if (transfer->actual_length == 0) {
	184	resubmit_transfer(transfer);
	185	return;
	186	}
	187
c7b5c358	188	buf = (uint32_t *)transfer->buffer;
43d86035	189
7b9387b8 UH	190	num_samples = MIN(devc->remaining_samples, max_samples);
7b9387b8 UH	191	devc->remaining_samples -= num_samples;
c7b5c358	192	send_data(sdi, buf, num_samples);
43d86035	193	sr_dbg("Remaining: %d %08X %08X.", devc->remaining_samples,
c7b5c358	194	buf[0], buf[1]);
43d86035 AV	195
	196	/* Close data receiving. */
	197	if (devc->remaining_samples == 0) {
c7b5c358	198	if (buf[num_samples] != H4032L_END_PACKET_MAGIC)
43d86035	199	sr_err("Mismatch magic number of end poll.");
2958315d AV	200
	201	abort_acquisition(devc);
	202	free_transfer(transfer);
43d86035	203	} else {
2958315d AV	204	if (((devc->submitted_transfers - 1) * H4032L_DATA_BUFFER_SIZE) <
	205	(int32_t)(devc->remaining_samples * sizeof(uint32_t)))
	206	resubmit_transfer(transfer);
	207	else
	208	free_transfer(transfer);
43d86035 AV	209	}
	210	}
	211
	212	void LIBUSB_CALL h4032l_usb_callback(struct libusb_transfer *transfer)
	213	{
3dc976fe AV	214	struct sr_dev_inst *const sdi = transfer->user_data;
3dc976fe AV	215	struct dev_context *const devc = sdi->priv;
5089a143 AZ	216	struct sr_usb_dev_inst *usb = sdi->conn;
5089a143 AZ	217	gboolean cmd = FALSE;
43d86035	218	uint32_t max_samples = transfer->actual_length / sizeof(uint32_t);
c7b5c358	219	uint32_t *buf;
5089a143	220	struct h4032l_status_packet *status;
7b9387b8	221	uint32_t num_samples;
5089a143	222	int ret;
6a25fa42	223
a5b9880e AV	224	/*
	225	* If acquisition has already ended, just free any queued up
	226	* transfers that come in.
	227	*/
	228	if (devc->acq_aborted) {
	229	free_transfer(transfer);
	230	return;
	231	}
	232
74c4c174 AV	233	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
74c4c174 AV	234	sr_dbg("%s error: %d.", __func__, transfer->status);
6a25fa42	235
c7b5c358	236	buf = (uint32_t *)transfer->buffer;
5089a143 AZ	237
	238	switch (devc->status) {
	239	case H4032L_STATUS_IDLE:
	240	sr_err("USB callback called in idle.");
	241	break;
	242	case H4032L_STATUS_CMD_CONFIGURE:
	243	/* Select status request as next. */
	244	cmd = TRUE;
	245	devc->cmd_pkt.cmd = CMD_STATUS;
	246	devc->status = H4032L_STATUS_CMD_STATUS;
	247	break;
	248	case H4032L_STATUS_CMD_STATUS:
	249	/* Select status request as next. */
	250	devc->status = H4032L_STATUS_RESPONSE_STATUS;
	251	break;
	252	case H4032L_STATUS_RESPONSE_STATUS:
	253	/*
	254	* Check magic and if status is complete, then select
	255	* First Transfer as next.
	256	*/
	257	status = (struct h4032l_status_packet *)transfer->buffer;
28f2d07f	258	if (status->magic != H4032L_STATUS_PACKET_MAGIC)
74c4c174	259	devc->status = H4032L_STATUS_RESPONSE_STATUS;
28f2d07f	260	else if (status->status == 2)
5089a143	261	devc->status = H4032L_STATUS_RESPONSE_STATUS_CONTINUE;
28f2d07f	262	else
5089a143	263	devc->status = H4032L_STATUS_RESPONSE_STATUS_RETRY;
5089a143 AZ	264	break;
	265	case H4032L_STATUS_RESPONSE_STATUS_RETRY:
	266	devc->status = H4032L_STATUS_CMD_STATUS;
	267	devc->cmd_pkt.cmd = CMD_STATUS;
	268	cmd = TRUE;
	269	break;
	270	case H4032L_STATUS_RESPONSE_STATUS_CONTINUE:
	271	devc->status = H4032L_STATUS_CMD_GET;
	272	devc->cmd_pkt.cmd = CMD_GET;
	273	cmd = TRUE;
	274	break;
	275	case H4032L_STATUS_CMD_GET:
	276	devc->status = H4032L_STATUS_FIRST_TRANSFER;
43d86035 AV	277	/* Trigger has been captured. */
43d86035 AV	278	std_session_send_df_header(sdi);
5089a143 AZ	279	break;
5089a143 AZ	280	case H4032L_STATUS_FIRST_TRANSFER:
74c4c174	281	/* Drop packets until H4032L_START_PACKET_MAGIC. */
c7b5c358	282	if (buf[0] != H4032L_START_PACKET_MAGIC) {
74c4c174	283	sr_dbg("Mismatch magic number of start poll.");
5089a143 AZ	284	break;
	285	}
	286	devc->status = H4032L_STATUS_TRANSFER;
	287	max_samples--;
c7b5c358	288	buf++;
97200156	289	/* Fallthrough. */
5089a143	290	case H4032L_STATUS_TRANSFER:
7b9387b8 UH	291	num_samples = MIN(devc->remaining_samples, max_samples);
7b9387b8 UH	292	devc->remaining_samples -= num_samples;
c7b5c358	293	send_data(sdi, buf, num_samples);
5089a143	294	sr_dbg("Remaining: %d %08X %08X.", devc->remaining_samples,
c7b5c358	295	buf[0], buf[1]);
5089a143 AZ	296	break;
	297	}
	298
43d86035 AV	299	/* Start data receiving. */
	300	if (devc->status == H4032L_STATUS_TRANSFER) {
	301	if ((ret = h4032l_start_data_transfers(sdi)) != SR_OK) {
	302	sr_err("Can not start data transfers: %d", ret);
	303	devc->status = H4032L_STATUS_IDLE;
	304	}
	305	} else if (devc->status != H4032L_STATUS_IDLE) {
5089a143 AZ	306	if (cmd) {
	307	/* Setup new USB cmd packet, reuse transfer object. */
	308	sr_dbg("New command: %d.", devc->status);
	309	libusb_fill_bulk_transfer(transfer, usb->devhdl,
	310	2 \| LIBUSB_ENDPOINT_OUT,
	311	(unsigned char *)&devc->cmd_pkt,
	312	sizeof(struct h4032l_cmd_pkt),
28f2d07f AV	313	h4032l_usb_callback,
28f2d07f AV	314	(void *)sdi, H4032L_USB_TIMEOUT);
5089a143 AZ	315	} else {
	316	/* Setup new USB poll packet, reuse transfer object. */
	317	sr_dbg("Poll: %d.", devc->status);
	318	libusb_fill_bulk_transfer(transfer, usb->devhdl,
	319	6 \| LIBUSB_ENDPOINT_IN,
c7b5c358	320	devc->buf, ARRAY_SIZE(devc->buf),
5089a143 AZ	321	h4032l_usb_callback,
	322	(void *)sdi, H4032L_USB_TIMEOUT);
	323	}
4868f15a	324	/* Send prepared USB packet. */
5089a143 AZ	325	if ((ret = libusb_submit_transfer(transfer)) != 0) {
	326	sr_err("Failed to submit transfer: %s.",
	327	libusb_error_name(ret));
	328	devc->status = H4032L_STATUS_IDLE;
	329	}
	330	} else {
	331	sr_dbg("Now idle.");
	332	}
	333
	334	if (devc->status == H4032L_STATUS_IDLE)
a5b9880e	335	free_transfer(transfer);
5089a143 AZ	336	}
	337
	338	uint16_t h4032l_voltage2pwm(double voltage)
	339	{
	340	/*
	341	* word PwmA - channel A Vref PWM value, pseudocode:
	342	* -6V < ThresholdVoltage < +6V
	343	* Vref = 1.8 - ThresholdVoltage
	344	* if Vref > 10.0
	345	* Vref = 10.0
	346	* if Vref < -5.0
	347	* Vref = -5.0
	348	* pwm = ToInt((Vref + 5.0) / 15.0 * 4096.0)
	349	* if pwm > 4095
	350	* pwm = 4095
	351	*/
	352	voltage = 1.8 - voltage;
	353	if (voltage > 10.0)
	354	voltage = 10.0;
	355	else if (voltage < -5.0)
	356	voltage = -5.0;
	357
	358	return (uint16_t) ((voltage + 5.0) * (4096.0 / 15.0));
	359	}
	360
43d86035 AV	361	SR_PRIV int h4032l_start_data_transfers(const struct sr_dev_inst *sdi)
	362	{
	363	struct dev_context *devc = sdi->priv;
	364	struct sr_usb_dev_inst *usb = sdi->conn;
	365	struct libusb_transfer *transfer;
c7b5c358	366	uint8_t *buf;
2958315d AV	367	unsigned int num_transfers;
2958315d AV	368	unsigned int i;
43d86035 AV	369	int ret;
43d86035 AV	370
2958315d	371	devc->submitted_transfers = 0;
43d86035	372
2958315d AV	373	/*
	374	* Set number of data transfers regarding to size of buffer.
	375	* FPGA version 0 can't transfer multiple transfers at once.
	376	*/
	377	if ((num_transfers = MIN(devc->remaining_samples * sizeof(uint32_t) /
	378	H4032L_DATA_BUFFER_SIZE, devc->fpga_version ?
	379	H4032L_DATA_TRANSFER_MAX_NUM : 1)) == 0)
	380	num_transfers = 1;
	381
	382	g_free(devc->transfers);
2dcd904c	383	devc->transfers = g_malloc(sizeof(devc->transfers) num_transfers);
2958315d	384	devc->num_transfers = num_transfers;
2dcd904c	385
2958315d	386	for (i = 0; i < num_transfers; i++) {
c7b5c358	387	buf = g_malloc(H4032L_DATA_BUFFER_SIZE);
2958315d AV	388	transfer = libusb_alloc_transfer(0);
	389
	390	libusb_fill_bulk_transfer(transfer, usb->devhdl,
	391	6 \| LIBUSB_ENDPOINT_IN,
c7b5c358	392	buf, H4032L_DATA_BUFFER_SIZE,
2958315d AV	393	h4032l_data_transfer_callback,
	394	(void *)sdi, H4032L_USB_TIMEOUT);
	395
	396	/* Send prepared usb packet. */
	397	if ((ret = libusb_submit_transfer(transfer)) != 0) {
	398	sr_err("Failed to submit transfer: %s.",
	399	libusb_error_name(ret));
	400	libusb_free_transfer(transfer);
c7b5c358	401	g_free(buf);
2958315d AV	402	abort_acquisition(devc);
	403	return SR_ERR;
	404	}
	405	devc->transfers[i] = transfer;
	406	devc->submitted_transfers++;
	407	}
43d86035	408
2958315d	409	return SR_OK;
43d86035 AV	410	}
43d86035 AV	411
5089a143 AZ	412	SR_PRIV int h4032l_start(const struct sr_dev_inst *sdi)
	413	{
	414	struct dev_context *devc = sdi->priv;
	415	struct sr_usb_dev_inst *usb = sdi->conn;
	416	struct libusb_transfer *transfer;
c7b5c358	417	unsigned char buf[] = {0x0f, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
5089a143 AZ	418	int ret;
5089a143 AZ	419
74c4c174 AV	420	/* Send reset command to arm the logic analyzer. */
	421	if ((ret = libusb_control_transfer(usb->devhdl,
	422	LIBUSB_REQUEST_TYPE_VENDOR \| LIBUSB_ENDPOINT_OUT, CMD_RESET,
c7b5c358	423	0x00, 0x00, buf, ARRAY_SIZE(buf), H4032L_USB_TIMEOUT)) < 0) {
28f2d07f AV	424	sr_err("Failed to send vendor request %s.",
28f2d07f AV	425	libusb_error_name(ret));
74c4c174 AV	426	return SR_ERR;
	427	}
	428
	429	/* Wait for reset vendor request. */
	430	g_usleep(20 * 1000);
	431
	432	/* Send configure command. */
5089a143 AZ	433	devc->cmd_pkt.cmd = CMD_CONFIGURE;
	434	devc->status = H4032L_STATUS_CMD_CONFIGURE;
	435	devc->remaining_samples = devc->cmd_pkt.sample_size;
	436
	437	transfer = libusb_alloc_transfer(0);
	438
	439	libusb_fill_bulk_transfer(transfer, usb->devhdl,
	440	2 \| LIBUSB_ENDPOINT_OUT, (unsigned char *)&devc->cmd_pkt,
	441	sizeof(struct h4032l_cmd_pkt), h4032l_usb_callback,
	442	(void *)sdi, H4032L_USB_TIMEOUT);
	443
	444	if ((ret = libusb_submit_transfer(transfer)) != 0) {
28f2d07f AV	445	sr_err("Failed to submit transfer: %s.",
28f2d07f AV	446	libusb_error_name(ret));
5089a143 AZ	447	libusb_free_transfer(transfer);
	448	return SR_ERR;
	449	}
	450
2958315d	451	devc->transfers = g_malloc0(sizeof(*devc->transfers));
2958315d AV	452	devc->submitted_transfers++;
	453	devc->num_transfers = 1;
	454	devc->transfers[0] = transfer;
	455
	456	return SR_OK;
	457	}
	458
	459	SR_PRIV int h4032l_stop(struct sr_dev_inst *sdi)
	460	{
	461	abort_acquisition(sdi->priv);
	462
5089a143 AZ	463	return SR_OK;
	464	}
	465
	466	SR_PRIV int h4032l_dev_open(struct sr_dev_inst *sdi)
	467	{
	468	struct drv_context *drvc = sdi->driver->context;
	469	struct sr_usb_dev_inst *usb = sdi->conn;
	470	struct libusb_device_descriptor des;
	471	libusb_device **devlist;
	472	int ret = SR_ERR, i, device_count;
	473	char connection_id[64];
	474
	475	device_count = libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
	476	if (device_count < 0) {
	477	sr_err("Failed to get device list: %s.",
	478	libusb_error_name(device_count));
	479	return SR_ERR;
	480	}
	481
	482	for (i = 0; i < device_count; i++) {
	483	libusb_get_device_descriptor(devlist[i], &des);
	484
	485	if (des.idVendor != H4032L_USB_VENDOR \|\|
	486	des.idProduct != H4032L_USB_PRODUCT)
	487	continue;
	488
	489	if ((sdi->status == SR_ST_INITIALIZING) \|\|
	490	(sdi->status == SR_ST_INACTIVE)) {
	491	/* Check device by its physical USB bus/port address. */
28f2d07f AV	492	if (usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)) < 0)
	493	continue;
	494
5089a143 AZ	495	if (strcmp(sdi->connection_id, connection_id))
	496	/* This is not the one. */
	497	continue;
	498	}
	499
	500	if (!(ret = libusb_open(devlist[i], &usb->devhdl))) {
	501	if (usb->address == 0xff)
	502	/*
	503	* First time we touch this device after FW
	504	* upload, so we don't know the address yet.
	505	*/
	506	usb->address =
28f2d07f	507	libusb_get_device_address(devlist[i]);
5089a143 AZ	508	} else {
	509	sr_err("Failed to open device: %s.",
	510	libusb_error_name(ret));
	511	ret = SR_ERR;
	512	break;
	513	}
	514
	515	ret = SR_OK;
	516	break;
	517	}
	518
	519	libusb_free_device_list(devlist, 1);
	520	return ret;
6a25fa42	521	}
7a7afc00 AV	522
	523	SR_PRIV int h4032l_get_fpga_version(const struct sr_dev_inst *sdi)
	524	{
	525	struct dev_context *devc = sdi->priv;
	526	struct sr_usb_dev_inst *usb = sdi->conn;
	527	struct h4032l_status_packet *status;
	528	int transferred;
	529	int i, ret;
	530
	531	/* Set command to status. */
	532	devc->cmd_pkt.magic = H4032L_CMD_PKT_MAGIC;
	533	devc->cmd_pkt.cmd = CMD_STATUS;
	534
	535	/* Send status request. */
	536	if ((ret = libusb_bulk_transfer(usb->devhdl,
	537	2 \| LIBUSB_ENDPOINT_OUT, (unsigned char *)&devc->cmd_pkt,
	538	sizeof(struct h4032l_cmd_pkt), &transferred, H4032L_USB_TIMEOUT)) < 0) {
	539	sr_err("Unable to send FPGA version request: %s.",
	540	libusb_error_name(ret));
	541	return SR_ERR;
	542	}
	543
	544	/* Attempt to get FGPA version. */
	545	for (i = 0; i < 10; i++) {
	546	if ((ret = libusb_bulk_transfer(usb->devhdl,
c7b5c358 UH	547	6 \| LIBUSB_ENDPOINT_IN, devc->buf,
c7b5c358 UH	548	ARRAY_SIZE(devc->buf), &transferred, H4032L_USB_TIMEOUT)) < 0) {
7a7afc00 AV	549	sr_err("Unable to receive FPGA version: %s.",
	550	libusb_error_name(ret));
	551	return SR_ERR;
	552	}
c7b5c358	553	status = (struct h4032l_status_packet *)devc->buf;
7a7afc00 AV	554	if (status->magic == H4032L_STATUS_PACKET_MAGIC) {
	555	sr_dbg("FPGA version: 0x%x.", status->fpga_version);
	556	devc->fpga_version = status->fpga_version;
	557	return SR_OK;
	558	}
	559	}
	560
	561	sr_err("Unable to get FPGA version.");
	562
	563	return SR_ERR;
	564	}