[libsigrok.git] / hardware / lascar-el-usb / protocol.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
 *
 * 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 <stdlib.h>
#include <sys/time.h>
#include <string.h>
#include <math.h>
#include <glib.h>
#include "libsigrok.h"
#include "libsigrok-internal.h"
#include "protocol.h"

extern struct sr_dev_driver lascar_el_usb_driver_info;
static struct sr_dev_driver *di = &lascar_el_usb_driver_info;

static const struct elusb_profile profiles[] = {
	{ 1, "EL-USB-1", LOG_UNSUPPORTED },
	{ 2, "EL-USB-1", LOG_UNSUPPORTED },
	{ 3, "EL-USB-2", LOG_TEMP_RH },
	{ 4, "EL-USB-3", LOG_UNSUPPORTED },
	{ 5, "EL-USB-4", LOG_UNSUPPORTED },
	{ 6, "EL-USB-3", LOG_UNSUPPORTED },
	{ 7, "EL-USB-4", LOG_UNSUPPORTED },
	{ 8, "EL-USB-LITE", LOG_UNSUPPORTED },
	{ 9, "EL-USB-CO", LOG_CO },
	{ 10, "EL-USB-TC", LOG_UNSUPPORTED },
	{ 11, "EL-USB-CO300", LOG_UNSUPPORTED },
	{ 12, "EL-USB-2-LCD", LOG_UNSUPPORTED },
	{ 13, "EL-USB-2+", LOG_UNSUPPORTED },
	{ 14, "EL-USB-1-PRO", LOG_UNSUPPORTED },
	{ 15, "EL-USB-TC-LCD", LOG_UNSUPPORTED },
	{ 16, "EL-USB-2-LCD+", LOG_UNSUPPORTED },
	{ 17, "EL-USB-5", LOG_UNSUPPORTED },
	{ 18, "EL-USB-1-RCG", LOG_UNSUPPORTED },
	{ 19, "EL-USB-1-LCD", LOG_UNSUPPORTED },
	{ 20, "EL-OEM-3", LOG_UNSUPPORTED },
	{ 21, "EL-USB-1-LCD", LOG_UNSUPPORTED },
	{ 0, NULL, 0 }
};


SR_PRIV libusb_device_handle *lascar_open(struct libusb_device *dev)
{
	libusb_device_handle *dev_hdl;
	int ret;

	if ((ret = libusb_open(dev, &dev_hdl)) != 0) {
		sr_dbg("failed to open device for scan: %s",
				libusb_error_name(ret));
		return NULL;
	}

	/* Some of these fail, but it needs doing -- some sort of mode
	 * setup for the SILabs F32x. */
	libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
			0x00, 0xffff, 0x00, NULL, 0, 50);
	libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
			0x02, 0x0002, 0x00, NULL, 0, 50);
	libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
			0x02, 0x0001, 0x00, NULL, 0, 50);

	return dev_hdl;
}

static void mark_xfer(struct libusb_transfer *xfer)
{

	xfer->user_data = GINT_TO_POINTER(1);

}

SR_PRIV unsigned char *lascar_get_config(libusb_device_handle *dev_hdl)
{
	struct drv_context *drvc;
	struct libusb_transfer *xfer_in, *xfer_out;
	struct timeval tv;
	int64_t start;
	int buflen;
	unsigned char cmd[3], buf[256], *config;

	drvc = di->priv;
	config = NULL;

	if (!(xfer_in = libusb_alloc_transfer(0)) ||
			!(xfer_out = libusb_alloc_transfer(0)))
		return NULL;

	/* Flush anything the F321 still has queued. */
	while (libusb_bulk_transfer(dev_hdl, LASCAR_EP_IN, buf, 256, &buflen,
			5) == 0 && buflen > 0)
		;

	/* Keep a read request waiting in the wings, ready to pounce
	 * the moment the device sends something. */
	libusb_fill_bulk_transfer(xfer_in, dev_hdl, LASCAR_EP_IN,
			buf, 256, mark_xfer, 0, 10000);
	if (libusb_submit_transfer(xfer_in) != 0)
		goto cleanup;

	/* Request device configuration structure. */
	cmd[0] = 0x00;
	cmd[1] = 0xff;
	cmd[2] = 0xff;
	libusb_fill_bulk_transfer(xfer_out, dev_hdl, LASCAR_EP_OUT,
			cmd, 3, mark_xfer, 0, 100);
	if (libusb_submit_transfer(xfer_out) != 0)
		goto cleanup;

	tv.tv_sec = 0;
	tv.tv_usec = 0;
	start = g_get_monotonic_time();
	while (!xfer_in->user_data || !xfer_out->user_data) {
		if (g_get_monotonic_time() - start > SCAN_TIMEOUT) {
			start = 0;
			break;
		}
		g_usleep(5000);
		libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
	}
	if (!start) {
		sr_dbg("no response");
		goto cleanup;
	}
	if (xfer_in->actual_length != 3) {
		sr_dbg("expected 3-byte header, got %d bytes", xfer_in->actual_length);
		goto cleanup;
	}

	/* Got configuration structure header. */
	sr_dbg("response to config request: 0x%.2x 0x%.2x 0x%.2x ",
			buf[0], buf[1], buf[2]);
	buflen = buf[1] | (buf[2] << 8);
	if (buf[0] != 0x02 || buflen > 256) {
		sr_dbg("Invalid response to config request: "
				"0x%.2x 0x%.2x 0x%.2x ", buf[0], buf[1], buf[2]);
		libusb_close(dev_hdl);
		goto cleanup;
	}

	/* Get configuration structure. */
	xfer_in->length = buflen;
	xfer_in->user_data = 0;
	if (libusb_submit_transfer(xfer_in) != 0)
		goto cleanup;
	while (!xfer_in->user_data) {
		if (g_get_monotonic_time() - start > SCAN_TIMEOUT) {
			start = 0;
			break;
		}
		g_usleep(5000);
		libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
	}
	if (!start) {
		sr_dbg("Timeout waiting for configuration structure.");
		goto cleanup;
	}
	if (xfer_in->actual_length != buflen) {
		sr_dbg("expected %d-byte structure, got %d bytes", buflen,
				xfer_in->actual_length);
		goto cleanup;
	}

	if (!(config = g_try_malloc(256)))
		return NULL;
	memcpy(config, buf, buflen);

cleanup:
	if (!xfer_in->user_data || !xfer_in->user_data) {
		if (!xfer_in->user_data)
			libusb_cancel_transfer(xfer_in);
		if (!xfer_out->user_data)
			libusb_cancel_transfer(xfer_out);
		start = g_get_monotonic_time();
		while (!xfer_in->user_data || !xfer_out->user_data) {
			if (g_get_monotonic_time() - start > 10000)
				break;
			g_usleep(1000);
			libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
		}
	}
	libusb_free_transfer(xfer_in);
	libusb_free_transfer(xfer_out);

	return config;
}

static struct sr_dev_inst *lascar_identify(unsigned char *config)
{
	struct dev_context *devc;
	const struct elusb_profile *profile;
	struct sr_dev_inst *sdi;
	struct sr_probe *probe;
	int modelid, i;
	char firmware[5];

	modelid = config[0];
	sdi = NULL;
	if (modelid) {
		profile = NULL;
		for (i = 0; profiles[i].modelid; i++) {
			if (profiles[i].modelid == modelid) {
				profile = &profiles[i];
				break;
			}
		}
		if (!profile) {
			sr_dbg("unknown EL-USB modelid %d", modelid);
			return NULL;
		}

		i = config[52] | (config[53] << 8);
		memcpy(firmware, config + 0x30, 4);
		firmware[4] = '\0';
		sr_dbg("found %s with firmware version %s serial %d",
				profile->modelname, firmware, i);

		if (profile->logformat == LOG_UNSUPPORTED) {
			sr_dbg("unsupported EL-USB logformat for %s", profile->modelname);
			return NULL;
		}

		if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, LASCAR_VENDOR,
				profile->modelname, firmware)))
			return NULL;
		sdi->driver = di;

		if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
			return NULL;
		sdi->probes = g_slist_append(NULL, probe);

		if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
			return NULL;
		sdi->priv = devc;
		devc->profile = profile;
	}

	return sdi;
}

SR_PRIV struct sr_dev_inst *lascar_scan(int bus, int address)
{
	struct drv_context *drvc;
	struct sr_dev_inst *sdi;
	struct libusb_device **devlist;
	struct libusb_device_descriptor des;
	libusb_device_handle *dev_hdl;
	int ret, i;
	unsigned char *config;

	drvc = di->priv;
	sdi = NULL;

	libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
	for (i = 0; devlist[i]; i++) {
		if ((ret = libusb_get_device_descriptor(devlist[i], &des))) {
			sr_err("Failed to get device descriptor: %d.", ret);
			continue;
		}

		if (libusb_get_bus_number(devlist[i]) != bus ||
				libusb_get_device_address(devlist[i]) != address)
			continue;

		if (!(dev_hdl = lascar_open(devlist[i])))
			continue;

		if (!(config = lascar_get_config(dev_hdl)))
			continue;

		libusb_close(dev_hdl);
		sdi = lascar_identify(config);
		g_free(config);
	}

	return sdi;
}

static void lascar_el_usb_dispatch(struct sr_dev_inst *sdi, unsigned char *buf,
		int buflen)
{
	struct dev_context *devc;
	struct sr_datafeed_packet packet;
	struct sr_datafeed_analog analog;
	uint16_t s;
	int samples, samples_left, i;

	devc = sdi->priv;
	samples = buflen / devc->sample_size;
	samples_left = devc->logged_samples - devc->rcvd_samples;
	if (samples_left < samples)
		samples = samples_left;
	switch (devc->profile->logformat) {
	case LOG_TEMP_RH:
		/* TODO */
		break;
	case LOG_CO:
		packet.type = SR_DF_ANALOG;
		packet.payload = &analog;
		analog.num_samples = samples;
		analog.mq = 0;
		analog.unit = 0;
		analog.mqflags = 0;
		if (!(analog.data = g_try_malloc(sizeof(float) * samples)))
			break;
		for (i = 0; i < samples; i++) {
			s = (buf[i * 2] << 8) | buf[i * 2 + 1];
			analog.data[i] = s * devc->co_high + devc->co_low;
			if (analog.data[i] < 0.0)
				analog.data[i] = 0.0;
		}
		sr_session_send(devc->cb_data, &packet);
		g_free(analog.data);
		break;
	default:
		/* How did we even get this far? */
		break;
	}
	devc->rcvd_samples += samples;

}

SR_PRIV int lascar_el_usb_handle_events(int fd, int revents, void *cb_data)
{
	struct dev_context *devc;
	struct drv_context *drvc = di->priv;
	struct sr_datafeed_packet packet;
	struct sr_dev_inst *sdi;
	struct timeval tv;
	int i;

	(void)fd;
	(void)revents;

	sdi = cb_data;
	devc = sdi->priv;

	if (sdi->status == SR_ST_STOPPING) {
		for (i = 0; devc->usbfd[i] != -1; i++)
			sr_source_remove(devc->usbfd[i]);

		sdi->driver->dev_close(sdi);

		packet.type = SR_DF_END;
		sr_session_send(cb_data, &packet);
	}

	memset(&tv, 0, sizeof(struct timeval));
	libusb_handle_events_timeout_completed(drvc->sr_ctx->libusb_ctx, &tv,
					       NULL);

	return TRUE;
}

SR_PRIV void lascar_el_usb_receive_transfer(struct libusb_transfer *transfer)
{
	struct dev_context *devc;
	struct sr_dev_inst *sdi;
	int ret;
	gboolean packet_has_error;

	sdi = transfer->user_data;
	devc = sdi->priv;

	packet_has_error = FALSE;
	switch (transfer->status) {
	case LIBUSB_TRANSFER_NO_DEVICE:
		/* USB device was unplugged. */
		hw_dev_acquisition_stop(sdi, sdi);
		return;
	case LIBUSB_TRANSFER_COMPLETED:
	case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though */
		break;
	default:
		packet_has_error = TRUE;
		break;
	}

	if (!packet_has_error) {
		if (devc->rcvd_samples < devc->logged_samples)
			lascar_el_usb_dispatch(sdi, transfer->buffer,
					transfer->actual_length);
		devc->rcvd_bytes += transfer->actual_length;
		sr_spew("received %d/%d bytes (%d/%d samples)",
				devc->rcvd_bytes, devc->log_size,
				devc->rcvd_samples, devc->logged_samples);
		if (devc->rcvd_bytes >= devc->log_size)
			hw_dev_acquisition_stop(sdi, sdi);
	}

	if (sdi->status == SR_ST_ACTIVE) {
		/* Send the same request again. */
		if ((ret = libusb_submit_transfer(transfer) != 0)) {
			sr_err("Unable to resubmit transfer: %s.",
			       libusb_error_name(ret));
			g_free(transfer->buffer);
			libusb_free_transfer(transfer);
			hw_dev_acquisition_stop(sdi, sdi);
		}
	} else {
		/* This was the last transfer we're going to receive, so
		 * clean up now. */
		g_free(transfer->buffer);
		libusb_free_transfer(transfer);
	}

}
Commit	Line	Data
46697e38 BV	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <stdlib.h>
851d5b22 BV	21	#include <sys/time.h>
851d5b22 BV	22	#include <string.h>
6aa1eb4e	23	#include <math.h>
46697e38 BV	24	#include <glib.h>
	25	#include "libsigrok.h"
	26	#include "libsigrok-internal.h"
	27	#include "protocol.h"
	28
851d5b22 BV	29	extern struct sr_dev_driver lascar_el_usb_driver_info;
	30	static struct sr_dev_driver *di = &lascar_el_usb_driver_info;
	31
	32	static const struct elusb_profile profiles[] = {
	33	{ 1, "EL-USB-1", LOG_UNSUPPORTED },
	34	{ 2, "EL-USB-1", LOG_UNSUPPORTED },
	35	{ 3, "EL-USB-2", LOG_TEMP_RH },
	36	{ 4, "EL-USB-3", LOG_UNSUPPORTED },
	37	{ 5, "EL-USB-4", LOG_UNSUPPORTED },
	38	{ 6, "EL-USB-3", LOG_UNSUPPORTED },
	39	{ 7, "EL-USB-4", LOG_UNSUPPORTED },
	40	{ 8, "EL-USB-LITE", LOG_UNSUPPORTED },
	41	{ 9, "EL-USB-CO", LOG_CO },
	42	{ 10, "EL-USB-TC", LOG_UNSUPPORTED },
	43	{ 11, "EL-USB-CO300", LOG_UNSUPPORTED },
	44	{ 12, "EL-USB-2-LCD", LOG_UNSUPPORTED },
	45	{ 13, "EL-USB-2+", LOG_UNSUPPORTED },
	46	{ 14, "EL-USB-1-PRO", LOG_UNSUPPORTED },
	47	{ 15, "EL-USB-TC-LCD", LOG_UNSUPPORTED },
	48	{ 16, "EL-USB-2-LCD+", LOG_UNSUPPORTED },
	49	{ 17, "EL-USB-5", LOG_UNSUPPORTED },
	50	{ 18, "EL-USB-1-RCG", LOG_UNSUPPORTED },
	51	{ 19, "EL-USB-1-LCD", LOG_UNSUPPORTED },
	52	{ 20, "EL-OEM-3", LOG_UNSUPPORTED },
	53	{ 21, "EL-USB-1-LCD", LOG_UNSUPPORTED },
	54	{ 0, NULL, 0 }
	55	};
	56
	57
6aa1eb4e BV	58	SR_PRIV libusb_device_handle lascar_open(struct libusb_device dev)
	59	{
	60	libusb_device_handle *dev_hdl;
	61	int ret;
	62
	63	if ((ret = libusb_open(dev, &dev_hdl)) != 0) {
	64	sr_dbg("failed to open device for scan: %s",
	65	libusb_error_name(ret));
	66	return NULL;
	67	}
	68
	69	/* Some of these fail, but it needs doing -- some sort of mode
	70	* setup for the SILabs F32x. */
	71	libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
	72	0x00, 0xffff, 0x00, NULL, 0, 50);
	73	libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
	74	0x02, 0x0002, 0x00, NULL, 0, 50);
	75	libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
	76	0x02, 0x0001, 0x00, NULL, 0, 50);
	77
	78	return dev_hdl;
	79	}
	80
	81	static void mark_xfer(struct libusb_transfer *xfer)
851d5b22 BV	82	{
	83
	84	xfer->user_data = GINT_TO_POINTER(1);
	85
	86	}
	87
6aa1eb4e	88	SR_PRIV unsigned char lascar_get_config(libusb_device_handle dev_hdl)
851d5b22 BV	89	{
851d5b22 BV	90	struct drv_context *drvc;
851d5b22 BV	91	struct libusb_transfer xfer_in, xfer_out;
	92	struct timeval tv;
	93	int64_t start;
6aa1eb4e BV	94	int buflen;
6aa1eb4e BV	95	unsigned char cmd[3], buf[256], *config;
851d5b22 BV	96
851d5b22 BV	97	drvc = di->priv;
6aa1eb4e	98	config = NULL;
851d5b22 BV	99
	100	if (!(xfer_in = libusb_alloc_transfer(0)) \|\|
	101	!(xfer_out = libusb_alloc_transfer(0)))
6aa1eb4e	102	return NULL;
851d5b22 BV	103
	104	/* Flush anything the F321 still has queued. */
	105	while (libusb_bulk_transfer(dev_hdl, LASCAR_EP_IN, buf, 256, &buflen,
	106	5) == 0 && buflen > 0)
	107	;
	108
	109	/* Keep a read request waiting in the wings, ready to pounce
	110	* the moment the device sends something. */
	111	libusb_fill_bulk_transfer(xfer_in, dev_hdl, LASCAR_EP_IN,
6aa1eb4e	112	buf, 256, mark_xfer, 0, 10000);
851d5b22 BV	113	if (libusb_submit_transfer(xfer_in) != 0)
	114	goto cleanup;
	115
	116	/* Request device configuration structure. */
	117	cmd[0] = 0x00;
	118	cmd[1] = 0xff;
	119	cmd[2] = 0xff;
	120	libusb_fill_bulk_transfer(xfer_out, dev_hdl, LASCAR_EP_OUT,
6aa1eb4e	121	cmd, 3, mark_xfer, 0, 100);
851d5b22 BV	122	if (libusb_submit_transfer(xfer_out) != 0)
	123	goto cleanup;
	124
	125	tv.tv_sec = 0;
	126	tv.tv_usec = 0;
	127	start = g_get_monotonic_time();
	128	while (!xfer_in->user_data \|\| !xfer_out->user_data) {
	129	if (g_get_monotonic_time() - start > SCAN_TIMEOUT) {
	130	start = 0;
	131	break;
	132	}
	133	g_usleep(5000);
	134	libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
	135	}
	136	if (!start) {
	137	sr_dbg("no response");
	138	goto cleanup;
	139	}
	140	if (xfer_in->actual_length != 3) {
	141	sr_dbg("expected 3-byte header, got %d bytes", xfer_in->actual_length);
	142	goto cleanup;
	143	}
	144
	145	/* Got configuration structure header. */
6aa1eb4e	146	sr_dbg("response to config request: 0x%.2x 0x%.2x 0x%.2x ",
851d5b22 BV	147	buf[0], buf[1], buf[2]);
	148	buflen = buf[1] \| (buf[2] << 8);
	149	if (buf[0] != 0x02 \|\| buflen > 256) {
	150	sr_dbg("Invalid response to config request: "
	151	"0x%.2x 0x%.2x 0x%.2x ", buf[0], buf[1], buf[2]);
	152	libusb_close(dev_hdl);
	153	goto cleanup;
	154	}
	155
	156	/* Get configuration structure. */
	157	xfer_in->length = buflen;
	158	xfer_in->user_data = 0;
	159	if (libusb_submit_transfer(xfer_in) != 0)
	160	goto cleanup;
	161	while (!xfer_in->user_data) {
	162	if (g_get_monotonic_time() - start > SCAN_TIMEOUT) {
	163	start = 0;
	164	break;
	165	}
	166	g_usleep(5000);
	167	libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
	168	}
	169	if (!start) {
	170	sr_dbg("Timeout waiting for configuration structure.");
	171	goto cleanup;
	172	}
	173	if (xfer_in->actual_length != buflen) {
	174	sr_dbg("expected %d-byte structure, got %d bytes", buflen,
	175	xfer_in->actual_length);
	176	goto cleanup;
	177	}
6aa1eb4e BV	178
	179	if (!(config = g_try_malloc(256)))
	180	return NULL;
	181	memcpy(config, buf, buflen);
851d5b22 BV	182
	183	cleanup:
	184	if (!xfer_in->user_data \|\| !xfer_in->user_data) {
	185	if (!xfer_in->user_data)
	186	libusb_cancel_transfer(xfer_in);
	187	if (!xfer_out->user_data)
	188	libusb_cancel_transfer(xfer_out);
	189	start = g_get_monotonic_time();
	190	while (!xfer_in->user_data \|\| !xfer_out->user_data) {
	191	if (g_get_monotonic_time() - start > 10000)
	192	break;
	193	g_usleep(1000);
	194	libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
	195	}
	196	}
	197	libusb_free_transfer(xfer_in);
	198	libusb_free_transfer(xfer_out);
	199
6aa1eb4e BV	200	return config;
	201	}
	202
	203	static struct sr_dev_inst lascar_identify(unsigned char config)
	204	{
	205	struct dev_context *devc;
	206	const struct elusb_profile *profile;
	207	struct sr_dev_inst *sdi;
	208	struct sr_probe *probe;
	209	int modelid, i;
	210	char firmware[5];
	211
	212	modelid = config[0];
851d5b22 BV	213	sdi = NULL;
	214	if (modelid) {
	215	profile = NULL;
	216	for (i = 0; profiles[i].modelid; i++) {
	217	if (profiles[i].modelid == modelid) {
	218	profile = &profiles[i];
	219	break;
	220	}
	221	}
	222	if (!profile) {
	223	sr_dbg("unknown EL-USB modelid %d", modelid);
	224	return NULL;
	225	}
	226
6aa1eb4e BV	227	i = config[52] \| (config[53] << 8);
6aa1eb4e BV	228	memcpy(firmware, config + 0x30, 4);
851d5b22 BV	229	firmware[4] = '\0';
	230	sr_dbg("found %s with firmware version %s serial %d",
	231	profile->modelname, firmware, i);
	232
	233	if (profile->logformat == LOG_UNSUPPORTED) {
	234	sr_dbg("unsupported EL-USB logformat for %s", profile->modelname);
	235	return NULL;
	236	}
	237
	238	if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, LASCAR_VENDOR,
	239	profile->modelname, firmware)))
	240	return NULL;
	241	sdi->driver = di;
6aa1eb4e BV	242
	243	if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
	244	return NULL;
	245	sdi->probes = g_slist_append(NULL, probe);
	246
	247	if (!(devc = g_try_malloc0(sizeof(struct dev_context))))
	248	return NULL;
	249	sdi->priv = devc;
	250	devc->profile = profile;
851d5b22 BV	251	}
	252
	253	return sdi;
	254	}
	255
	256	SR_PRIV struct sr_dev_inst *lascar_scan(int bus, int address)
	257	{
	258	struct drv_context *drvc;
	259	struct sr_dev_inst *sdi;
	260	struct libusb_device **devlist;
	261	struct libusb_device_descriptor des;
	262	libusb_device_handle *dev_hdl;
	263	int ret, i;
6aa1eb4e	264	unsigned char *config;
851d5b22 BV	265
	266	drvc = di->priv;
	267	sdi = NULL;
	268
	269	libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
	270	for (i = 0; devlist[i]; i++) {
	271	if ((ret = libusb_get_device_descriptor(devlist[i], &des))) {
	272	sr_err("Failed to get device descriptor: %d.", ret);
	273	continue;
	274	}
	275
	276	if (libusb_get_bus_number(devlist[i]) != bus \|\|
	277	libusb_get_device_address(devlist[i]) != address)
	278	continue;
	279
6aa1eb4e BV	280	if (!(dev_hdl = lascar_open(devlist[i])))
	281	continue;
	282
	283	if (!(config = lascar_get_config(dev_hdl)))
851d5b22	284	continue;
851d5b22	285
851d5b22	286	libusb_close(dev_hdl);
6aa1eb4e BV	287	sdi = lascar_identify(config);
6aa1eb4e BV	288	g_free(config);
851d5b22 BV	289	}
	290
	291	return sdi;
	292	}
	293
6aa1eb4e BV	294	static void lascar_el_usb_dispatch(struct sr_dev_inst sdi, unsigned char buf,
	295	int buflen)
	296	{
	297	struct dev_context *devc;
	298	struct sr_datafeed_packet packet;
	299	struct sr_datafeed_analog analog;
	300	uint16_t s;
	301	int samples, samples_left, i;
	302
	303	devc = sdi->priv;
	304	samples = buflen / devc->sample_size;
	305	samples_left = devc->logged_samples - devc->rcvd_samples;
	306	if (samples_left < samples)
	307	samples = samples_left;
	308	switch (devc->profile->logformat) {
	309	case LOG_TEMP_RH:
	310	/* TODO */
	311	break;
	312	case LOG_CO:
	313	packet.type = SR_DF_ANALOG;
	314	packet.payload = &analog;
	315	analog.num_samples = samples;
	316	analog.mq = 0;
	317	analog.unit = 0;
	318	analog.mqflags = 0;
	319	if (!(analog.data = g_try_malloc(sizeof(float) * samples)))
	320	break;
	321	for (i = 0; i < samples; i++) {
	322	s = (buf[i * 2] << 8) \| buf[i * 2 + 1];
	323	analog.data[i] = s * devc->co_high + devc->co_low;
	324	if (analog.data[i] < 0.0)
	325	analog.data[i] = 0.0;
	326	}
	327	sr_session_send(devc->cb_data, &packet);
	328	g_free(analog.data);
	329	break;
	330	default:
	331	/* How did we even get this far? */
	332	break;
	333	}
	334	devc->rcvd_samples += samples;
	335
	336	}
851d5b22	337
6aa1eb4e	338	SR_PRIV int lascar_el_usb_handle_events(int fd, int revents, void *cb_data)
46697e38	339	{
46697e38	340	struct dev_context *devc;
6aa1eb4e BV	341	struct drv_context *drvc = di->priv;
	342	struct sr_datafeed_packet packet;
	343	struct sr_dev_inst *sdi;
	344	struct timeval tv;
	345	int i;
46697e38	346
6aa1eb4e BV	347	(void)fd;
6aa1eb4e BV	348	(void)revents;
46697e38	349
6aa1eb4e BV	350	sdi = cb_data;
6aa1eb4e BV	351	devc = sdi->priv;
46697e38	352
6aa1eb4e BV	353	if (sdi->status == SR_ST_STOPPING) {
	354	for (i = 0; devc->usbfd[i] != -1; i++)
	355	sr_source_remove(devc->usbfd[i]);
	356
	357	sdi->driver->dev_close(sdi);
	358
	359	packet.type = SR_DF_END;
	360	sr_session_send(cb_data, &packet);
46697e38 BV	361	}
46697e38 BV	362
6aa1eb4e BV	363	memset(&tv, 0, sizeof(struct timeval));
	364	libusb_handle_events_timeout_completed(drvc->sr_ctx->libusb_ctx, &tv,
	365	NULL);
	366
46697e38 BV	367	return TRUE;
46697e38 BV	368	}
6aa1eb4e BV	369
	370	SR_PRIV void lascar_el_usb_receive_transfer(struct libusb_transfer *transfer)
	371	{
	372	struct dev_context *devc;
	373	struct sr_dev_inst *sdi;
	374	int ret;
	375	gboolean packet_has_error;
	376
	377	sdi = transfer->user_data;
	378	devc = sdi->priv;
	379
	380	packet_has_error = FALSE;
	381	switch (transfer->status) {
	382	case LIBUSB_TRANSFER_NO_DEVICE:
	383	/* USB device was unplugged. */
	384	hw_dev_acquisition_stop(sdi, sdi);
	385	return;
	386	case LIBUSB_TRANSFER_COMPLETED:
	387	case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though */
	388	break;
	389	default:
	390	packet_has_error = TRUE;
	391	break;
	392	}
	393
	394	if (!packet_has_error) {
	395	if (devc->rcvd_samples < devc->logged_samples)
	396	lascar_el_usb_dispatch(sdi, transfer->buffer,
	397	transfer->actual_length);
	398	devc->rcvd_bytes += transfer->actual_length;
	399	sr_spew("received %d/%d bytes (%d/%d samples)",
	400	devc->rcvd_bytes, devc->log_size,
	401	devc->rcvd_samples, devc->logged_samples);
	402	if (devc->rcvd_bytes >= devc->log_size)
	403	hw_dev_acquisition_stop(sdi, sdi);
	404	}
	405
	406	if (sdi->status == SR_ST_ACTIVE) {
	407	/* Send the same request again. */
	408	if ((ret = libusb_submit_transfer(transfer) != 0)) {
	409	sr_err("Unable to resubmit transfer: %s.",
	410	libusb_error_name(ret));
	411	g_free(transfer->buffer);
	412	libusb_free_transfer(transfer);
	413	hw_dev_acquisition_stop(sdi, sdi);
	414	}
	415	} else {
	416	/* This was the last transfer we're going to receive, so
	417	* clean up now. */
	418	g_free(transfer->buffer);
	419	libusb_free_transfer(transfer);
	420	}
	421
	422	}