[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
	};
	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. */
		std_session_send_df_trigger(sdi);

		/* 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	};
3dc976fe AV	117	size_t trigger_offset;
	118
	119	if (devc->trigger_pos >= devc->sent_samples &&
	120	devc->trigger_pos < (devc->sent_samples + sample_count)) {
	121	/* Get trigger position. */
	122	trigger_offset = devc->trigger_pos - devc->sent_samples;
	123	logic.length = trigger_offset * sizeof(uint32_t);
	124	if (logic.length)
	125	sr_session_send(sdi, &packet);
	126
	127	/* Send trigger position. */
0fa71943	128	std_session_send_df_trigger(sdi);
3dc976fe AV	129
3dc976fe AV	130	/* Send rest of data. */
e6bb2984	131	logic.length = (sample_count - trigger_offset) * sizeof(uint32_t);
3dc976fe AV	132	logic.data = data + trigger_offset;
	133	if (logic.length)
	134	sr_session_send(sdi, &packet);
	135	} else {
	136	sr_session_send(sdi, &packet);
	137	}
	138
	139	devc->sent_samples += sample_count;
	140	}
	141
5089a143	142	SR_PRIV int h4032l_receive_data(int fd, int revents, void *cb_data)
6a25fa42	143	{
5089a143 AZ	144	struct timeval tv;
5089a143 AZ	145	struct drv_context *drvc;
6a25fa42 AZ	146
6a25fa42 AZ	147	(void)fd;
5089a143 AZ	148	(void)revents;
	149
	150	drvc = (struct drv_context *)cb_data;
	151
	152	tv.tv_sec = tv.tv_usec = 0;
	153	libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
6a25fa42	154
5089a143 AZ	155	return TRUE;
5089a143 AZ	156	}
6a25fa42	157
43d86035	158	void LIBUSB_CALL h4032l_data_transfer_callback(struct libusb_transfer *transfer)
5089a143	159	{
3dc976fe AV	160	struct sr_dev_inst *const sdi = transfer->user_data;
3dc976fe AV	161	struct dev_context *const devc = sdi->priv;
43d86035	162	uint32_t max_samples = transfer->actual_length / sizeof(uint32_t);
c7b5c358	163	uint32_t *buf;
7b9387b8	164	uint32_t num_samples;
43d86035 AV	165
	166	/*
	167	* If acquisition has already ended, just free any queued up
	168	* transfer that come in.
	169	*/
	170	if (devc->acq_aborted) {
	171	free_transfer(transfer);
	172	return;
	173	}
	174
	175	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
	176	sr_dbg("%s error: %d.", __func__, transfer->status);
	177
	178	/* Cancel pending transfers. */
	179	if (transfer->actual_length == 0) {
	180	resubmit_transfer(transfer);
	181	return;
	182	}
	183
c7b5c358	184	buf = (uint32_t *)transfer->buffer;
43d86035	185
7b9387b8 UH	186	num_samples = MIN(devc->remaining_samples, max_samples);
7b9387b8 UH	187	devc->remaining_samples -= num_samples;
c7b5c358	188	send_data(sdi, buf, num_samples);
43d86035	189	sr_dbg("Remaining: %d %08X %08X.", devc->remaining_samples,
c7b5c358	190	buf[0], buf[1]);
43d86035 AV	191
	192	/* Close data receiving. */
	193	if (devc->remaining_samples == 0) {
c7b5c358	194	if (buf[num_samples] != H4032L_END_PACKET_MAGIC)
43d86035	195	sr_err("Mismatch magic number of end poll.");
2958315d AV	196
	197	abort_acquisition(devc);
	198	free_transfer(transfer);
43d86035	199	} else {
2958315d AV	200	if (((devc->submitted_transfers - 1) * H4032L_DATA_BUFFER_SIZE) <
	201	(int32_t)(devc->remaining_samples * sizeof(uint32_t)))
	202	resubmit_transfer(transfer);
	203	else
	204	free_transfer(transfer);
43d86035 AV	205	}
	206	}
	207
	208	void LIBUSB_CALL h4032l_usb_callback(struct libusb_transfer *transfer)
	209	{
3dc976fe AV	210	struct sr_dev_inst *const sdi = transfer->user_data;
3dc976fe AV	211	struct dev_context *const devc = sdi->priv;
5089a143 AZ	212	struct sr_usb_dev_inst *usb = sdi->conn;
5089a143 AZ	213	gboolean cmd = FALSE;
43d86035	214	uint32_t max_samples = transfer->actual_length / sizeof(uint32_t);
c7b5c358	215	uint32_t *buf;
5089a143	216	struct h4032l_status_packet *status;
7b9387b8	217	uint32_t num_samples;
5089a143	218	int ret;
6a25fa42	219
a5b9880e AV	220	/*
	221	* If acquisition has already ended, just free any queued up
	222	* transfers that come in.
	223	*/
	224	if (devc->acq_aborted) {
	225	free_transfer(transfer);
	226	return;
	227	}
	228
74c4c174 AV	229	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
74c4c174 AV	230	sr_dbg("%s error: %d.", __func__, transfer->status);
6a25fa42	231
c7b5c358	232	buf = (uint32_t *)transfer->buffer;
5089a143 AZ	233
	234	switch (devc->status) {
	235	case H4032L_STATUS_IDLE:
	236	sr_err("USB callback called in idle.");
	237	break;
	238	case H4032L_STATUS_CMD_CONFIGURE:
	239	/* Select status request as next. */
	240	cmd = TRUE;
	241	devc->cmd_pkt.cmd = CMD_STATUS;
	242	devc->status = H4032L_STATUS_CMD_STATUS;
	243	break;
	244	case H4032L_STATUS_CMD_STATUS:
	245	/* Select status request as next. */
	246	devc->status = H4032L_STATUS_RESPONSE_STATUS;
	247	break;
	248	case H4032L_STATUS_RESPONSE_STATUS:
	249	/*
	250	* Check magic and if status is complete, then select
	251	* First Transfer as next.
	252	*/
	253	status = (struct h4032l_status_packet *)transfer->buffer;
28f2d07f	254	if (status->magic != H4032L_STATUS_PACKET_MAGIC)
74c4c174	255	devc->status = H4032L_STATUS_RESPONSE_STATUS;
28f2d07f	256	else if (status->status == 2)
5089a143	257	devc->status = H4032L_STATUS_RESPONSE_STATUS_CONTINUE;
28f2d07f	258	else
5089a143	259	devc->status = H4032L_STATUS_RESPONSE_STATUS_RETRY;
5089a143 AZ	260	break;
	261	case H4032L_STATUS_RESPONSE_STATUS_RETRY:
	262	devc->status = H4032L_STATUS_CMD_STATUS;
	263	devc->cmd_pkt.cmd = CMD_STATUS;
	264	cmd = TRUE;
	265	break;
	266	case H4032L_STATUS_RESPONSE_STATUS_CONTINUE:
	267	devc->status = H4032L_STATUS_CMD_GET;
	268	devc->cmd_pkt.cmd = CMD_GET;
	269	cmd = TRUE;
	270	break;
	271	case H4032L_STATUS_CMD_GET:
	272	devc->status = H4032L_STATUS_FIRST_TRANSFER;
43d86035 AV	273	/* Trigger has been captured. */
43d86035 AV	274	std_session_send_df_header(sdi);
5089a143 AZ	275	break;
5089a143 AZ	276	case H4032L_STATUS_FIRST_TRANSFER:
74c4c174	277	/* Drop packets until H4032L_START_PACKET_MAGIC. */
c7b5c358	278	if (buf[0] != H4032L_START_PACKET_MAGIC) {
74c4c174	279	sr_dbg("Mismatch magic number of start poll.");
5089a143 AZ	280	break;
	281	}
	282	devc->status = H4032L_STATUS_TRANSFER;
	283	max_samples--;
c7b5c358	284	buf++;
97200156	285	/* Fallthrough. */
5089a143	286	case H4032L_STATUS_TRANSFER:
7b9387b8 UH	287	num_samples = MIN(devc->remaining_samples, max_samples);
7b9387b8 UH	288	devc->remaining_samples -= num_samples;
c7b5c358	289	send_data(sdi, buf, num_samples);
5089a143	290	sr_dbg("Remaining: %d %08X %08X.", devc->remaining_samples,
c7b5c358	291	buf[0], buf[1]);
5089a143 AZ	292	break;
	293	}
	294
43d86035 AV	295	/* Start data receiving. */
	296	if (devc->status == H4032L_STATUS_TRANSFER) {
	297	if ((ret = h4032l_start_data_transfers(sdi)) != SR_OK) {
	298	sr_err("Can not start data transfers: %d", ret);
	299	devc->status = H4032L_STATUS_IDLE;
	300	}
	301	} else if (devc->status != H4032L_STATUS_IDLE) {
5089a143 AZ	302	if (cmd) {
	303	/* Setup new USB cmd packet, reuse transfer object. */
	304	sr_dbg("New command: %d.", devc->status);
	305	libusb_fill_bulk_transfer(transfer, usb->devhdl,
	306	2 \| LIBUSB_ENDPOINT_OUT,
	307	(unsigned char *)&devc->cmd_pkt,
	308	sizeof(struct h4032l_cmd_pkt),
28f2d07f AV	309	h4032l_usb_callback,
28f2d07f AV	310	(void *)sdi, H4032L_USB_TIMEOUT);
5089a143 AZ	311	} else {
	312	/* Setup new USB poll packet, reuse transfer object. */
	313	sr_dbg("Poll: %d.", devc->status);
	314	libusb_fill_bulk_transfer(transfer, usb->devhdl,
	315	6 \| LIBUSB_ENDPOINT_IN,
c7b5c358	316	devc->buf, ARRAY_SIZE(devc->buf),
5089a143 AZ	317	h4032l_usb_callback,
	318	(void *)sdi, H4032L_USB_TIMEOUT);
	319	}
4868f15a	320	/* Send prepared USB packet. */
5089a143 AZ	321	if ((ret = libusb_submit_transfer(transfer)) != 0) {
	322	sr_err("Failed to submit transfer: %s.",
	323	libusb_error_name(ret));
	324	devc->status = H4032L_STATUS_IDLE;
	325	}
	326	} else {
	327	sr_dbg("Now idle.");
	328	}
	329
	330	if (devc->status == H4032L_STATUS_IDLE)
a5b9880e	331	free_transfer(transfer);
5089a143 AZ	332	}
	333
	334	uint16_t h4032l_voltage2pwm(double voltage)
	335	{
	336	/*
	337	* word PwmA - channel A Vref PWM value, pseudocode:
	338	* -6V < ThresholdVoltage < +6V
	339	* Vref = 1.8 - ThresholdVoltage
	340	* if Vref > 10.0
	341	* Vref = 10.0
	342	* if Vref < -5.0
	343	* Vref = -5.0
	344	* pwm = ToInt((Vref + 5.0) / 15.0 * 4096.0)
	345	* if pwm > 4095
	346	* pwm = 4095
	347	*/
	348	voltage = 1.8 - voltage;
	349	if (voltage > 10.0)
	350	voltage = 10.0;
	351	else if (voltage < -5.0)
	352	voltage = -5.0;
	353
	354	return (uint16_t) ((voltage + 5.0) * (4096.0 / 15.0));
	355	}
	356
43d86035 AV	357	SR_PRIV int h4032l_start_data_transfers(const struct sr_dev_inst *sdi)
	358	{
	359	struct dev_context *devc = sdi->priv;
	360	struct sr_usb_dev_inst *usb = sdi->conn;
	361	struct libusb_transfer *transfer;
c7b5c358	362	uint8_t *buf;
2958315d AV	363	unsigned int num_transfers;
2958315d AV	364	unsigned int i;
43d86035 AV	365	int ret;
43d86035 AV	366
2958315d	367	devc->submitted_transfers = 0;
43d86035	368
2958315d AV	369	/*
	370	* Set number of data transfers regarding to size of buffer.
	371	* FPGA version 0 can't transfer multiple transfers at once.
	372	*/
	373	if ((num_transfers = MIN(devc->remaining_samples * sizeof(uint32_t) /
	374	H4032L_DATA_BUFFER_SIZE, devc->fpga_version ?
	375	H4032L_DATA_TRANSFER_MAX_NUM : 1)) == 0)
	376	num_transfers = 1;
	377
	378	g_free(devc->transfers);
2dcd904c	379	devc->transfers = g_malloc(sizeof(devc->transfers) num_transfers);
2958315d	380	devc->num_transfers = num_transfers;
2dcd904c	381
2958315d	382	for (i = 0; i < num_transfers; i++) {
c7b5c358	383	buf = g_malloc(H4032L_DATA_BUFFER_SIZE);
2958315d AV	384	transfer = libusb_alloc_transfer(0);
	385
	386	libusb_fill_bulk_transfer(transfer, usb->devhdl,
	387	6 \| LIBUSB_ENDPOINT_IN,
c7b5c358	388	buf, H4032L_DATA_BUFFER_SIZE,
2958315d AV	389	h4032l_data_transfer_callback,
	390	(void *)sdi, H4032L_USB_TIMEOUT);
	391
	392	/* Send prepared usb packet. */
	393	if ((ret = libusb_submit_transfer(transfer)) != 0) {
	394	sr_err("Failed to submit transfer: %s.",
	395	libusb_error_name(ret));
	396	libusb_free_transfer(transfer);
c7b5c358	397	g_free(buf);
2958315d AV	398	abort_acquisition(devc);
	399	return SR_ERR;
	400	}
	401	devc->transfers[i] = transfer;
	402	devc->submitted_transfers++;
	403	}
43d86035	404
2958315d	405	return SR_OK;
43d86035 AV	406	}
43d86035 AV	407
5089a143 AZ	408	SR_PRIV int h4032l_start(const struct sr_dev_inst *sdi)
	409	{
	410	struct dev_context *devc = sdi->priv;
	411	struct sr_usb_dev_inst *usb = sdi->conn;
	412	struct libusb_transfer *transfer;
c7b5c358	413	unsigned char buf[] = {0x0f, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
5089a143 AZ	414	int ret;
5089a143 AZ	415
74c4c174 AV	416	/* Send reset command to arm the logic analyzer. */
	417	if ((ret = libusb_control_transfer(usb->devhdl,
	418	LIBUSB_REQUEST_TYPE_VENDOR \| LIBUSB_ENDPOINT_OUT, CMD_RESET,
c7b5c358	419	0x00, 0x00, buf, ARRAY_SIZE(buf), H4032L_USB_TIMEOUT)) < 0) {
28f2d07f AV	420	sr_err("Failed to send vendor request %s.",
28f2d07f AV	421	libusb_error_name(ret));
74c4c174 AV	422	return SR_ERR;
	423	}
	424
	425	/* Wait for reset vendor request. */
	426	g_usleep(20 * 1000);
	427
	428	/* Send configure command. */
5089a143 AZ	429	devc->cmd_pkt.cmd = CMD_CONFIGURE;
	430	devc->status = H4032L_STATUS_CMD_CONFIGURE;
	431	devc->remaining_samples = devc->cmd_pkt.sample_size;
	432
	433	transfer = libusb_alloc_transfer(0);
	434
	435	libusb_fill_bulk_transfer(transfer, usb->devhdl,
	436	2 \| LIBUSB_ENDPOINT_OUT, (unsigned char *)&devc->cmd_pkt,
	437	sizeof(struct h4032l_cmd_pkt), h4032l_usb_callback,
	438	(void *)sdi, H4032L_USB_TIMEOUT);
	439
	440	if ((ret = libusb_submit_transfer(transfer)) != 0) {
28f2d07f AV	441	sr_err("Failed to submit transfer: %s.",
28f2d07f AV	442	libusb_error_name(ret));
5089a143 AZ	443	libusb_free_transfer(transfer);
	444	return SR_ERR;
	445	}
	446
2958315d	447	devc->transfers = g_malloc0(sizeof(*devc->transfers));
2958315d AV	448	devc->submitted_transfers++;
	449	devc->num_transfers = 1;
	450	devc->transfers[0] = transfer;
	451
	452	return SR_OK;
	453	}
	454
	455	SR_PRIV int h4032l_stop(struct sr_dev_inst *sdi)
	456	{
	457	abort_acquisition(sdi->priv);
	458
5089a143 AZ	459	return SR_OK;
	460	}
	461
	462	SR_PRIV int h4032l_dev_open(struct sr_dev_inst *sdi)
	463	{
	464	struct drv_context *drvc = sdi->driver->context;
	465	struct sr_usb_dev_inst *usb = sdi->conn;
	466	struct libusb_device_descriptor des;
	467	libusb_device **devlist;
	468	int ret = SR_ERR, i, device_count;
	469	char connection_id[64];
	470
	471	device_count = libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
	472	if (device_count < 0) {
	473	sr_err("Failed to get device list: %s.",
	474	libusb_error_name(device_count));
	475	return SR_ERR;
	476	}
	477
	478	for (i = 0; i < device_count; i++) {
	479	libusb_get_device_descriptor(devlist[i], &des);
	480
	481	if (des.idVendor != H4032L_USB_VENDOR \|\|
	482	des.idProduct != H4032L_USB_PRODUCT)
	483	continue;
	484
	485	if ((sdi->status == SR_ST_INITIALIZING) \|\|
	486	(sdi->status == SR_ST_INACTIVE)) {
	487	/* Check device by its physical USB bus/port address. */
28f2d07f AV	488	if (usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)) < 0)
	489	continue;
	490
5089a143 AZ	491	if (strcmp(sdi->connection_id, connection_id))
	492	/* This is not the one. */
	493	continue;
	494	}
	495
	496	if (!(ret = libusb_open(devlist[i], &usb->devhdl))) {
	497	if (usb->address == 0xff)
	498	/*
	499	* First time we touch this device after FW
	500	* upload, so we don't know the address yet.
	501	*/
	502	usb->address =
28f2d07f	503	libusb_get_device_address(devlist[i]);
5089a143 AZ	504	} else {
	505	sr_err("Failed to open device: %s.",
	506	libusb_error_name(ret));
	507	ret = SR_ERR;
	508	break;
	509	}
	510
	511	ret = SR_OK;
	512	break;
	513	}
	514
	515	libusb_free_device_list(devlist, 1);
	516	return ret;
6a25fa42	517	}
7a7afc00 AV	518
	519	SR_PRIV int h4032l_get_fpga_version(const struct sr_dev_inst *sdi)
	520	{
	521	struct dev_context *devc = sdi->priv;
	522	struct sr_usb_dev_inst *usb = sdi->conn;
	523	struct h4032l_status_packet *status;
	524	int transferred;
	525	int i, ret;
	526
	527	/* Set command to status. */
	528	devc->cmd_pkt.magic = H4032L_CMD_PKT_MAGIC;
	529	devc->cmd_pkt.cmd = CMD_STATUS;
	530
	531	/* Send status request. */
	532	if ((ret = libusb_bulk_transfer(usb->devhdl,
	533	2 \| LIBUSB_ENDPOINT_OUT, (unsigned char *)&devc->cmd_pkt,
	534	sizeof(struct h4032l_cmd_pkt), &transferred, H4032L_USB_TIMEOUT)) < 0) {
	535	sr_err("Unable to send FPGA version request: %s.",
	536	libusb_error_name(ret));
	537	return SR_ERR;
	538	}
	539
	540	/* Attempt to get FGPA version. */
	541	for (i = 0; i < 10; i++) {
	542	if ((ret = libusb_bulk_transfer(usb->devhdl,
c7b5c358 UH	543	6 \| LIBUSB_ENDPOINT_IN, devc->buf,
c7b5c358 UH	544	ARRAY_SIZE(devc->buf), &transferred, H4032L_USB_TIMEOUT)) < 0) {
7a7afc00 AV	545	sr_err("Unable to receive FPGA version: %s.",
	546	libusb_error_name(ret));
	547	return SR_ERR;
	548	}
c7b5c358	549	status = (struct h4032l_status_packet *)devc->buf;
7a7afc00 AV	550	if (status->magic == H4032L_STATUS_PACKET_MAGIC) {
	551	sr_dbg("FPGA version: 0x%x.", status->fpga_version);
	552	devc->fpga_version = status->fpga_version;
	553	return SR_OK;
	554	}
	555	}
	556
	557	sr_err("Unable to get FPGA version.");
	558
	559	return SR_ERR;
	560	}