[libsigrok.git] / hardware / genericdmm / api.c

/*
 * This file is part of the sigrok project.
 *
 * Copyright (C) 2012 Uwe Hermann <uwe@hermann-uwe.de>
 * 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 2 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
 */

#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include "libsigrok.h"
#include "libsigrok-internal.h"
#include "genericdmm.h"


extern SR_PRIV struct dmmchip dmmchip_fs9922;

static struct sr_hwopt victor_70c_vidpid[] = {
	{ SR_HWOPT_CONN, "1244.d237" },
	{ 0, NULL }
};
static struct dev_profile dev_profiles[] = {
	{ "victor-70c", "Victor", "70C", &dmmchip_fs9922,
		DMM_TRANSPORT_USBHID, victor_70c_vidpid
	},
	{ "mastech-va18b", "Mastech", "VA18B", NULL, DMM_TRANSPORT_SERIAL, NULL},
	{ NULL, NULL, NULL, NULL, 0, NULL }
};

static const int hwcaps[] = {
	SR_HWCAP_MULTIMETER,
	SR_HWCAP_LIMIT_SAMPLES,
	SR_HWCAP_LIMIT_MSEC,
	SR_HWCAP_CONTINUOUS,
	SR_HWOPT_MODEL,
	SR_HWOPT_CONN,
	SR_HWOPT_SERIALCOMM,
	0,
};

static const char *probe_names[] = {
	"Probe",
	NULL,
};

SR_PRIV struct sr_dev_driver genericdmm_driver_info;
static struct sr_dev_driver *gdi = &genericdmm_driver_info;
/* TODO need a way to keep this local to the static library */
SR_PRIV libusb_context *genericdmm_usb_context = NULL;


static GSList *connect_usb(const char *conn)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;
	libusb_device **devlist;
	struct libusb_device_descriptor des;
	GSList *devices;
	GRegex *reg;
	GMatchInfo *match;
	int vid, pid, bus, addr, devcnt, err, i;
	char *mstr;

	vid = pid = bus = addr = 0;
	reg = g_regex_new(DMM_CONN_USB_VIDPID, 0, 0, NULL);
	if (g_regex_match(reg, conn, 0, &match)) {
		/* Extract VID. */
		if ((mstr = g_match_info_fetch(match, 1)))
			vid = strtoul(mstr, NULL, 16);
		g_free(mstr);

		/* Extract PID. */
		if ((mstr = g_match_info_fetch(match, 2)))
			pid = strtoul(mstr, NULL, 16);
		g_free(mstr);
	} else {
		g_match_info_unref(match);
		g_regex_unref(reg);
		reg = g_regex_new(DMM_CONN_USB_BUSADDR, 0, 0, NULL);
		if (g_regex_match(reg, conn, 0, &match)) {
			/* Extract bus. */
			if ((mstr = g_match_info_fetch(match, 0)))
				bus = strtoul(mstr, NULL, 16);
			g_free(mstr);

			/* Extract address. */
			if ((mstr = g_match_info_fetch(match, 0)))
				addr = strtoul(mstr, NULL, 16);
			g_free(mstr);
		}
	}
	g_match_info_unref(match);
	g_regex_unref(reg);

	if (vid + pid + bus + addr == 0)
		return NULL;

	if (bus > 64) {
		sr_err("invalid bus");
		return NULL;
	}

	if (addr > 127) {
		sr_err("invalid address");
		return NULL;
	}

	/* Looks like a valid USB device specification, but is it connected? */
	devices = NULL;
	libusb_get_device_list(genericdmm_usb_context, &devlist);
	for (i = 0; devlist[i]; i++) {
		if ((err = libusb_get_device_descriptor(devlist[i], &des))) {
			sr_err("genericdmm: failed to get device descriptor: %d", err);
			continue;
		}

		if (vid + pid && (des.idVendor != vid || des.idProduct != pid))
			/* VID/PID specified, but no match. */
			continue;

		if (bus + addr && (
				libusb_get_bus_number(devlist[i]) != bus
				|| libusb_get_device_address(devlist[i]) != addr))
			/* Bus/address specified, but no match. */
			continue;

		/* Found one. */
		if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
			sr_err("genericdmm: ctx malloc failed.");
			return 0;
		}

		devcnt = g_slist_length(gdi->instances);
		if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE,
				"Generic DMM", NULL, NULL))) {
			sr_err("genericdmm: sr_dev_inst_new returned NULL.");
			return NULL;
		}
		sdi->priv = ctx;
		ctx->usb = sr_usb_dev_inst_new(
				libusb_get_bus_number(devlist[i]),
				libusb_get_device_address(devlist[i]), NULL);
		devices = g_slist_append(devices, sdi);
	}
	libusb_free_device_list(devlist, 1);

	return devices;
}

static GSList *connect_serial(const char *conn, const char *serialcomm)
{
	GSList *devices;

	devices = NULL;

	/* TODO */
	sr_dbg("not yet implemented");

	return devices;
}

GSList *genericdmm_connect(const char *conn, const char *serialcomm)
{
	GSList *devices;

	if (serialcomm)
		/* Must be a serial port. */
		return connect_serial(conn, serialcomm);

	if ((devices = connect_usb(conn)))
		return devices;

	return NULL;
}

static int hw_init(void)
{

	if (libusb_init(&genericdmm_usb_context) != 0) {
		sr_err("genericdmm: Failed to initialize USB.");
		return SR_ERR;
	}


	return SR_OK;
}

static int hw_scan(void)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;
	int devcnt = 0;

	if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
		sr_err("genericdmm: ctx malloc failed.");
		return 0;
	}

	devcnt = g_slist_length(genericdmm_dev_insts);
	if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, "Generic DMM",
			NULL, NULL))) {
		sr_err("genericdmm: sr_dev_inst_new returned NULL.");
		return 0;
	}
	sdi->priv = ctx;
	genericdmm_dev_insts = g_slist_append(genericdmm_dev_insts, sdi);

	/* Always initialized just one device instance. */
	return 0;
}

static int hw_dev_open(int dev_index)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;

	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
		sr_err("genericdmm: sdi was NULL.");
		return SR_ERR_BUG;
	}

	if (!(ctx = sdi->priv)) {
		sr_err("genericdmm: sdi->priv was NULL.");
		return SR_ERR_BUG;
	}

	sr_dbg("genericdmm: Opening serial port '%s'.", ctx->serial->port);

	switch (ctx->profile->transport) {
	case DMM_TRANSPORT_USBHID:
		/* TODO */
		break;
	case DMM_TRANSPORT_SERIAL:
		/* TODO: O_NONBLOCK? */
		ctx->serial->fd = serial_open(ctx->serial->port, O_RDWR | O_NONBLOCK);
		if (ctx->serial->fd == -1) {
			sr_err("genericdmm: Couldn't open serial port '%s'.",
			       ctx->serial->port);
			return SR_ERR;
		}
		//	serial_set_params(ctx->serial->fd, 2400, 8, 0, 1, 2);
		break;
	default:
		sr_err("No transport set.");
	}

	return SR_OK;
}

static int hw_dev_close(int dev_index)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;

	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
		sr_err("genericdmm: %s: sdi was NULL.", __func__);
		return SR_ERR_BUG;
	}

	if (!(ctx = sdi->priv)) {
		sr_err("genericdmm: %s: sdi->priv was NULL.", __func__);
		return SR_ERR_BUG;
	}

	/* TODO: Check for != NULL. */

	switch (ctx->profile->transport) {
	case DMM_TRANSPORT_USBHID:
		/* TODO */
		break;
	case DMM_TRANSPORT_SERIAL:
		if (ctx->serial && ctx->serial->fd != -1) {
			serial_close(ctx->serial->fd);
			ctx->serial->fd = -1;
			sdi->status = SR_ST_INACTIVE;
		}
		break;
	}

	return SR_OK;
}

static int hw_cleanup(void)
{
	GSList *l;
	struct sr_dev_inst *sdi;
	struct context *ctx;

	/* Properly close and free all devices. */
	for (l = gdi->instances; l; l = l->next) {
		if (!(sdi = l->data)) {
			/* Log error, but continue cleaning up the rest. */
			sr_err("genericdmm: sdi was NULL, continuing.");
			continue;
		}
		if (!(ctx = sdi->priv)) {
			/* Log error, but continue cleaning up the rest. */
			sr_err("genericdmm: sdi->priv was NULL, continuing.");
			continue;
		}

		if (ctx->profile) {
			switch (ctx->profile->transport) {
			case DMM_TRANSPORT_USBHID:
				/* TODO */
				break;
			case DMM_TRANSPORT_SERIAL:
				if (ctx->serial && ctx->serial->fd != -1)
					serial_close(ctx->serial->fd);
				sr_serial_dev_inst_free(ctx->serial);
				break;
			}
		}

		sr_dev_inst_free(sdi);
	}

	g_slist_free(gdi->instances);
	gdi->instances = NULL;

	if (genericdmm_usb_context)
		libusb_exit(genericdmm_usb_context);

	return SR_OK;
}

static const void *hw_dev_info_get(int dev_index, int dev_info_id)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;
	const void *info;

	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
		sr_err("genericdmm: sdi was NULL.");
		return NULL;
	}

	if (!(ctx = sdi->priv)) {
		sr_err("genericdmm: sdi->priv was NULL.");
		return NULL;
	}

		sr_spew("genericdmm: dev_index %d, dev_info_id %d.",
				dev_index, dev_info_id);

	switch (dev_info_id) {
	case SR_DI_INST:
		info = sdi;
		sr_spew("genericdmm: Returning sdi.");
		break;
	case SR_DI_NUM_PROBES:
		info = GINT_TO_POINTER(1);
		sr_spew("genericdmm: Returning number of probes: 1.");
		break;
	case SR_DI_PROBE_NAMES:
		info = probe_names;
		sr_spew("genericdmm: Returning probenames.");
		break;
	case SR_DI_CUR_SAMPLERATE:
		/* TODO get rid of this */
		info = NULL;
		sr_spew("genericdmm: Returning samplerate: 0.");
		break;
	default:
		/* Unknown device info ID. */
		sr_err("genericdmm: Unknown device info ID: %d.", dev_info_id);
		info = NULL;
		break;
	}

	return info;
}

static int hw_dev_status_get(int dev_index)
{
	struct sr_dev_inst *sdi;

	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
		sr_err("genericdmm: sdi was NULL, device not found.");
		return SR_ST_NOT_FOUND;
	}

	sr_dbg("genericdmm: Returning status: %d.", sdi->status);

	return sdi->status;
}

static const int *hw_hwcap_get_all(void)
{
	sr_spew("genericdmm: Returning list of device capabilities.");

	return hwcaps;
}

static int hw_dev_config_set(int dev_index, int hwcap, const void *value)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;

	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
		sr_err("genericdmm: sdi was NULL.");
		return SR_ERR_BUG;
	}

	if (!(ctx = sdi->priv)) {
		sr_err("genericdmm: sdi->priv was NULL.");
		return SR_ERR_BUG;
	}

	sr_spew("genericdmm: dev_index %d, hwcap %d.", dev_index, hwcap);

	switch (hwcap) {
	case SR_HWCAP_LIMIT_MSEC:
		if (*(const uint64_t *)value == 0) {
			sr_err("genericdmm: LIMIT_MSEC can't be 0.");
			return SR_ERR;
		}
		ctx->limit_msec = *(const uint64_t *)value;
		sr_dbg("genericdmm: Setting LIMIT_MSEC to %" PRIu64 ".",
		       ctx->limit_msec);
		break;
	case SR_HWCAP_LIMIT_SAMPLES:
		ctx->limit_samples = *(const uint64_t *)value;
		sr_dbg("genericdmm: Setting LIMIT_SAMPLES to %" PRIu64 ".",
		       ctx->limit_samples);
		break;
	default:
		sr_err("genericdmm: Unknown capability: %d.", hwcap);
		return SR_ERR;
		break;
	}

	return SR_OK;
}

static int receive_data(int fd, int revents, void *cb_data)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;

	if (!(sdi = cb_data))
		return FALSE;

	if (!(ctx = sdi->priv))
		return FALSE;

	if (revents != G_IO_IN) {
		sr_err("genericdmm: No data?");
		return FALSE;
	}

	switch (ctx->profile->transport) {
	case DMM_TRANSPORT_USBHID:
		/* TODO */
		break;
	case DMM_TRANSPORT_SERIAL:
		/* TODO */
		break;
	}

	return TRUE;
}

static int hw_dev_acquisition_start(int dev_index, void *cb_data)
{
	struct sr_datafeed_packet packet;
	struct sr_datafeed_header header;
	struct sr_datafeed_meta_analog meta;
	struct sr_dev_inst *sdi;
	struct context *ctx;

	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
		sr_err("genericdmm: sdi was NULL.");
		return SR_ERR_BUG;
	}

	if (!(ctx = sdi->priv)) {
		sr_err("genericdmm: sdi->priv was NULL.");
		return SR_ERR_BUG;
	}

	sr_dbg("genericdmm: Starting acquisition.");

	ctx->cb_data = cb_data;

	/* Send header packet to the session bus. */
	sr_dbg("genericdmm: Sending SR_DF_HEADER.");
	packet.type = SR_DF_HEADER;
	packet.payload = (uint8_t *)&header;
	header.feed_version = 1;
	gettimeofday(&header.starttime, NULL);
	sr_session_send(ctx->cb_data, &packet);

	/* Send metadata about the SR_DF_ANALOG packets to come. */
	sr_dbg("genericdmm: Sending SR_DF_META_ANALOG.");
	packet.type = SR_DF_META_ANALOG;
	packet.payload = &meta;
	meta.num_probes = 1;
	sr_session_send(ctx->cb_data, &packet);

	/* Hook up a proxy handler to receive data from the device. */
	switch (ctx->profile->transport) {
	case DMM_TRANSPORT_USBHID:
		/* TODO libusb FD setup */
		break;
	case DMM_TRANSPORT_SERIAL:
		/* TODO serial FD setup */
		// sr_source_add(ctx->serial->fd, G_IO_IN, -1, receive_data, sdi);
		break;
	}

	return SR_OK;
}

static int hw_dev_acquisition_stop(int dev_index, void *cb_data)
{
	struct sr_datafeed_packet packet;

	/* Avoid compiler warnings. */
	(void)dev_index;

	sr_dbg("genericdmm: Stopping acquisition.");

	/* Send end packet to the session bus. */
	sr_dbg("genericdmm: Sending SR_DF_END.");
	packet.type = SR_DF_END;
	sr_session_send(cb_data, &packet);

	return SR_OK;
}

SR_PRIV struct sr_dev_driver genericdmm_driver_info = {
	.name = "genericdmm",
	.longname = "Generic DMM",
	.api_version = 1,
	.init = hw_init,
	.cleanup = hw_cleanup,
	.scan = hw_scan,
	.dev_open = hw_dev_open,
	.dev_close = hw_dev_close,
	.dev_info_get = hw_dev_info_get,
	.dev_status_get = hw_dev_status_get,
	.hwcap_get_all = hw_hwcap_get_all,
	.dev_config_set = hw_dev_config_set,
	.dev_acquisition_start = hw_dev_acquisition_start,
	.dev_acquisition_stop = hw_dev_acquisition_stop,
	.instances = NULL,
};
Commit	Line	Data
ca3d84cc BV	1	/*
	2	* This file is part of the sigrok project.
	3	*
	4	* Copyright (C) 2012 Uwe Hermann <uwe@hermann-uwe.de>
	5	* Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include <stdlib.h>
	23	#include <string.h>
	24	#include <fcntl.h>
45c59c8b BV	25	#include "libsigrok.h"
45c59c8b BV	26	#include "libsigrok-internal.h"
ca3d84cc BV	27	#include "genericdmm.h"
	28
	29
	30	extern SR_PRIV struct dmmchip dmmchip_fs9922;
	31
7fc754a0 BV	32	static struct sr_hwopt victor_70c_vidpid[] = {
	33	{ SR_HWOPT_CONN, "1244.d237" },
	34	{ 0, NULL }
	35	};
ca3d84cc BV	36	static struct dev_profile dev_profiles[] = {
ca3d84cc BV	37	{ "victor-70c", "Victor", "70C", &dmmchip_fs9922,
7fc754a0 BV	38	DMM_TRANSPORT_USBHID, victor_70c_vidpid
	39	},
	40	{ "mastech-va18b", "Mastech", "VA18B", NULL, DMM_TRANSPORT_SERIAL, NULL},
	41	{ NULL, NULL, NULL, NULL, 0, NULL }
ca3d84cc BV	42	};
	43
	44	static const int hwcaps[] = {
	45	SR_HWCAP_MULTIMETER,
	46	SR_HWCAP_LIMIT_SAMPLES,
	47	SR_HWCAP_LIMIT_MSEC,
	48	SR_HWCAP_CONTINUOUS,
bbb40871 BV	49	SR_HWOPT_MODEL,
	50	SR_HWOPT_CONN,
	51	SR_HWOPT_SERIALCOMM,
ca3d84cc BV	52	0,
	53	};
	54
	55	static const char *probe_names[] = {
	56	"Probe",
	57	NULL,
	58	};
	59
75337758 BV	60	SR_PRIV struct sr_dev_driver genericdmm_driver_info;
	61	static struct sr_dev_driver *gdi = &genericdmm_driver_info;
	62	/* TODO need a way to keep this local to the static library */
ca3d84cc BV	63	SR_PRIV libusb_context *genericdmm_usb_context = NULL;
	64
	65
bbb40871 BV	66	static GSList connect_usb(const char conn)
	67	{
	68	struct sr_dev_inst *sdi;
	69	struct context *ctx;
	70	libusb_device **devlist;
	71	struct libusb_device_descriptor des;
	72	GSList *devices;
	73	GRegex *reg;
	74	GMatchInfo *match;
	75	int vid, pid, bus, addr, devcnt, err, i;
	76	char *mstr;
	77
	78	vid = pid = bus = addr = 0;
	79	reg = g_regex_new(DMM_CONN_USB_VIDPID, 0, 0, NULL);
	80	if (g_regex_match(reg, conn, 0, &match)) {
	81	/* Extract VID. */
	82	if ((mstr = g_match_info_fetch(match, 1)))
	83	vid = strtoul(mstr, NULL, 16);
	84	g_free(mstr);
	85
	86	/* Extract PID. */
	87	if ((mstr = g_match_info_fetch(match, 2)))
	88	pid = strtoul(mstr, NULL, 16);
	89	g_free(mstr);
	90	} else {
	91	g_match_info_unref(match);
	92	g_regex_unref(reg);
	93	reg = g_regex_new(DMM_CONN_USB_BUSADDR, 0, 0, NULL);
	94	if (g_regex_match(reg, conn, 0, &match)) {
	95	/* Extract bus. */
	96	if ((mstr = g_match_info_fetch(match, 0)))
	97	bus = strtoul(mstr, NULL, 16);
	98	g_free(mstr);
	99
	100	/* Extract address. */
	101	if ((mstr = g_match_info_fetch(match, 0)))
	102	addr = strtoul(mstr, NULL, 16);
	103	g_free(mstr);
	104	}
	105	}
	106	g_match_info_unref(match);
	107	g_regex_unref(reg);
	108
	109	if (vid + pid + bus + addr == 0)
	110	return NULL;
	111
	112	if (bus > 64) {
	113	sr_err("invalid bus");
	114	return NULL;
	115	}
	116
	117	if (addr > 127) {
	118	sr_err("invalid address");
	119	return NULL;
	120	}
	121
	122	/* Looks like a valid USB device specification, but is it connected? */
	123	devices = NULL;
	124	libusb_get_device_list(genericdmm_usb_context, &devlist);
	125	for (i = 0; devlist[i]; i++) {
	126	if ((err = libusb_get_device_descriptor(devlist[i], &des))) {
	127	sr_err("genericdmm: failed to get device descriptor: %d", err);
	128	continue;
	129	}
130
131	if (vid + pid && (des.idVendor != vid \|\| des.idProduct != pid))
132	/* VID/PID specified, but no match. */
133	continue;
134
135	if (bus + addr && (
136	libusb_get_bus_number(devlist[i]) != bus
137	\|\| libusb_get_device_address(devlist[i]) != addr))
138	/* Bus/address specified, but no match. */
139	continue;
140
141	/* Found one. */
142	if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
143	sr_err("genericdmm: ctx malloc failed.");
144	return 0;
145	}
146
147	devcnt = g_slist_length(gdi->instances);
148	if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE,
149	"Generic DMM", NULL, NULL))) {
150	sr_err("genericdmm: sr_dev_inst_new returned NULL.");
151	return NULL;
152	}
153	sdi->priv = ctx;
154	ctx->usb = sr_usb_dev_inst_new(
155	libusb_get_bus_number(devlist[i]),
156	libusb_get_device_address(devlist[i]), NULL);
157	devices = g_slist_append(devices, sdi);
158	}
159	libusb_free_device_list(devlist, 1);
160
161	return devices;
162	}
163
164	static GSList connect_serial(const char conn, const char *serialcomm)
165	{
166	GSList *devices;
167
168	devices = NULL;
169
170	/* TODO */
171	sr_dbg("not yet implemented");
172
173	return devices;
174	}
175
176	GSList genericdmm_connect(const char conn, const char *serialcomm)
177	{
178	GSList *devices;
179
180	if (serialcomm)
181	/* Must be a serial port. */
182	return connect_serial(conn, serialcomm);
183
184	if ((devices = connect_usb(conn)))
185	return devices;
186
187	return NULL;
188	}
189
40dda2c3	190	static int hw_init(void)
ca3d84cc	191	{
ca3d84cc	192
ca3d84cc BV	193	if (libusb_init(&genericdmm_usb_context) != 0) {
ca3d84cc BV	194	sr_err("genericdmm: Failed to initialize USB.");
61136ea6	195	return SR_ERR;
ca3d84cc BV	196	}
ca3d84cc BV	197
61136ea6 BV	198
	199	return SR_OK;
	200	}
	201
	202	static int hw_scan(void)
	203	{
	204	struct sr_dev_inst *sdi;
	205	struct context *ctx;
	206	int devcnt = 0;
	207
ca3d84cc BV	208	if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
	209	sr_err("genericdmm: ctx malloc failed.");
	210	return 0;
	211	}
	212
	213	devcnt = g_slist_length(genericdmm_dev_insts);
	214	if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, "Generic DMM",
	215	NULL, NULL))) {
	216	sr_err("genericdmm: sr_dev_inst_new returned NULL.");
	217	return 0;
	218	}
	219	sdi->priv = ctx;
	220	genericdmm_dev_insts = g_slist_append(genericdmm_dev_insts, sdi);
	221
	222	/* Always initialized just one device instance. */
	223	return 0;
	224	}
	225
	226	static int hw_dev_open(int dev_index)
	227	{
	228	struct sr_dev_inst *sdi;
	229	struct context *ctx;
	230
75337758	231	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
ca3d84cc BV	232	sr_err("genericdmm: sdi was NULL.");
	233	return SR_ERR_BUG;
	234	}
	235
	236	if (!(ctx = sdi->priv)) {
	237	sr_err("genericdmm: sdi->priv was NULL.");
	238	return SR_ERR_BUG;
	239	}
	240
	241	sr_dbg("genericdmm: Opening serial port '%s'.", ctx->serial->port);
	242
	243	switch (ctx->profile->transport) {
	244	case DMM_TRANSPORT_USBHID:
	245	/* TODO */
	246	break;
	247	case DMM_TRANSPORT_SERIAL:
	248	/* TODO: O_NONBLOCK? */
	249	ctx->serial->fd = serial_open(ctx->serial->port, O_RDWR \| O_NONBLOCK);
	250	if (ctx->serial->fd == -1) {
	251	sr_err("genericdmm: Couldn't open serial port '%s'.",
	252	ctx->serial->port);
	253	return SR_ERR;
	254	}
	255	// serial_set_params(ctx->serial->fd, 2400, 8, 0, 1, 2);
	256	break;
	257	default:
	258	sr_err("No transport set.");
	259	}
	260
	261	return SR_OK;
	262	}
	263
	264	static int hw_dev_close(int dev_index)
	265	{
	266	struct sr_dev_inst *sdi;
	267	struct context *ctx;
	268
75337758	269	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
ca3d84cc BV	270	sr_err("genericdmm: %s: sdi was NULL.", __func__);
	271	return SR_ERR_BUG;
	272	}
	273
	274	if (!(ctx = sdi->priv)) {
	275	sr_err("genericdmm: %s: sdi->priv was NULL.", __func__);
	276	return SR_ERR_BUG;
	277	}
	278
	279	/* TODO: Check for != NULL. */
	280
	281	switch (ctx->profile->transport) {
	282	case DMM_TRANSPORT_USBHID:
	283	/* TODO */
	284	break;
	285	case DMM_TRANSPORT_SERIAL:
	286	if (ctx->serial && ctx->serial->fd != -1) {
	287	serial_close(ctx->serial->fd);
	288	ctx->serial->fd = -1;
	289	sdi->status = SR_ST_INACTIVE;
	290	}
	291	break;
	292	}
	293
	294	return SR_OK;
	295	}
	296
	297	static int hw_cleanup(void)
	298	{
	299	GSList *l;
	300	struct sr_dev_inst *sdi;
	301	struct context *ctx;
	302
	303	/* Properly close and free all devices. */
75337758	304	for (l = gdi->instances; l; l = l->next) {
ca3d84cc BV	305	if (!(sdi = l->data)) {
	306	/* Log error, but continue cleaning up the rest. */
	307	sr_err("genericdmm: sdi was NULL, continuing.");
	308	continue;
	309	}
	310	if (!(ctx = sdi->priv)) {
	311	/* Log error, but continue cleaning up the rest. */
	312	sr_err("genericdmm: sdi->priv was NULL, continuing.");
	313	continue;
	314	}
	315
	316	if (ctx->profile) {
	317	switch (ctx->profile->transport) {
	318	case DMM_TRANSPORT_USBHID:
	319	/* TODO */
	320	break;
	321	case DMM_TRANSPORT_SERIAL:
	322	if (ctx->serial && ctx->serial->fd != -1)
	323	serial_close(ctx->serial->fd);
	324	sr_serial_dev_inst_free(ctx->serial);
	325	break;
	326	}
	327	}
	328
	329	sr_dev_inst_free(sdi);
	330	}
	331
75337758 BV	332	g_slist_free(gdi->instances);
75337758 BV	333	gdi->instances = NULL;
ca3d84cc BV	334
	335	if (genericdmm_usb_context)
	336	libusb_exit(genericdmm_usb_context);
	337
	338	return SR_OK;
	339	}
	340
	341	static const void *hw_dev_info_get(int dev_index, int dev_info_id)
	342	{
	343	struct sr_dev_inst *sdi;
	344	struct context *ctx;
	345	const void *info;
	346
75337758	347	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
ca3d84cc BV	348	sr_err("genericdmm: sdi was NULL.");
	349	return NULL;
	350	}
	351
	352	if (!(ctx = sdi->priv)) {
	353	sr_err("genericdmm: sdi->priv was NULL.");
	354	return NULL;
	355	}
	356
	357	sr_spew("genericdmm: dev_index %d, dev_info_id %d.",
	358	dev_index, dev_info_id);
	359
	360	switch (dev_info_id) {
	361	case SR_DI_INST:
	362	info = sdi;
	363	sr_spew("genericdmm: Returning sdi.");
	364	break;
	365	case SR_DI_NUM_PROBES:
	366	info = GINT_TO_POINTER(1);
	367	sr_spew("genericdmm: Returning number of probes: 1.");
	368	break;
	369	case SR_DI_PROBE_NAMES:
	370	info = probe_names;
	371	sr_spew("genericdmm: Returning probenames.");
	372	break;
	373	case SR_DI_CUR_SAMPLERATE:
	374	/* TODO get rid of this */
	375	info = NULL;
	376	sr_spew("genericdmm: Returning samplerate: 0.");
	377	break;
	378	default:
	379	/* Unknown device info ID. */
	380	sr_err("genericdmm: Unknown device info ID: %d.", dev_info_id);
	381	info = NULL;
	382	break;
	383	}
	384
	385	return info;
	386	}
	387
	388	static int hw_dev_status_get(int dev_index)
	389	{
	390	struct sr_dev_inst *sdi;
	391
75337758	392	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
ca3d84cc BV	393	sr_err("genericdmm: sdi was NULL, device not found.");
	394	return SR_ST_NOT_FOUND;
	395	}
	396
	397	sr_dbg("genericdmm: Returning status: %d.", sdi->status);
	398
	399	return sdi->status;
	400	}
	401
	402	static const int *hw_hwcap_get_all(void)
	403	{
	404	sr_spew("genericdmm: Returning list of device capabilities.");
	405
	406	return hwcaps;
	407	}
	408
ca3d84cc BV	409	static int hw_dev_config_set(int dev_index, int hwcap, const void *value)
	410	{
	411	struct sr_dev_inst *sdi;
	412	struct context *ctx;
ca3d84cc	413
75337758	414	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
ca3d84cc BV	415	sr_err("genericdmm: sdi was NULL.");
	416	return SR_ERR_BUG;
	417	}
	418
	419	if (!(ctx = sdi->priv)) {
	420	sr_err("genericdmm: sdi->priv was NULL.");
	421	return SR_ERR_BUG;
	422	}
	423
	424	sr_spew("genericdmm: dev_index %d, hwcap %d.", dev_index, hwcap);
	425
	426	switch (hwcap) {
	427	case SR_HWCAP_LIMIT_MSEC:
	428	if ((const uint64_t )value == 0) {
	429	sr_err("genericdmm: LIMIT_MSEC can't be 0.");
	430	return SR_ERR;
	431	}
	432	ctx->limit_msec = (const uint64_t )value;
	433	sr_dbg("genericdmm: Setting LIMIT_MSEC to %" PRIu64 ".",
	434	ctx->limit_msec);
	435	break;
	436	case SR_HWCAP_LIMIT_SAMPLES:
	437	ctx->limit_samples = (const uint64_t )value;
	438	sr_dbg("genericdmm: Setting LIMIT_SAMPLES to %" PRIu64 ".",
	439	ctx->limit_samples);
	440	break;
ca3d84cc BV	441	default:
	442	sr_err("genericdmm: Unknown capability: %d.", hwcap);
	443	return SR_ERR;
	444	break;
	445	}
	446
	447	return SR_OK;
	448	}
	449
	450	static int receive_data(int fd, int revents, void *cb_data)
	451	{
	452	struct sr_dev_inst *sdi;
	453	struct context *ctx;
	454
	455	if (!(sdi = cb_data))
	456	return FALSE;
	457
	458	if (!(ctx = sdi->priv))
	459	return FALSE;
	460
	461	if (revents != G_IO_IN) {
	462	sr_err("genericdmm: No data?");
	463	return FALSE;
	464	}
	465
	466	switch (ctx->profile->transport) {
	467	case DMM_TRANSPORT_USBHID:
	468	/* TODO */
	469	break;
	470	case DMM_TRANSPORT_SERIAL:
	471	/* TODO */
	472	break;
	473	}
	474
	475	return TRUE;
	476	}
	477
	478	static int hw_dev_acquisition_start(int dev_index, void *cb_data)
	479	{
	480	struct sr_datafeed_packet packet;
	481	struct sr_datafeed_header header;
	482	struct sr_datafeed_meta_analog meta;
	483	struct sr_dev_inst *sdi;
	484	struct context *ctx;
	485
75337758	486	if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
ca3d84cc BV	487	sr_err("genericdmm: sdi was NULL.");
	488	return SR_ERR_BUG;
	489	}
	490
	491	if (!(ctx = sdi->priv)) {
	492	sr_err("genericdmm: sdi->priv was NULL.");
	493	return SR_ERR_BUG;
	494	}
	495
	496	sr_dbg("genericdmm: Starting acquisition.");
	497
	498	ctx->cb_data = cb_data;
	499
	500	/* Send header packet to the session bus. */
	501	sr_dbg("genericdmm: Sending SR_DF_HEADER.");
	502	packet.type = SR_DF_HEADER;
	503	packet.payload = (uint8_t *)&header;
	504	header.feed_version = 1;
	505	gettimeofday(&header.starttime, NULL);
	506	sr_session_send(ctx->cb_data, &packet);
	507
	508	/* Send metadata about the SR_DF_ANALOG packets to come. */
	509	sr_dbg("genericdmm: Sending SR_DF_META_ANALOG.");
	510	packet.type = SR_DF_META_ANALOG;
	511	packet.payload = &meta;
	512	meta.num_probes = 1;
	513	sr_session_send(ctx->cb_data, &packet);
	514
	515	/* Hook up a proxy handler to receive data from the device. */
	516	switch (ctx->profile->transport) {
	517	case DMM_TRANSPORT_USBHID:
	518	/* TODO libusb FD setup */
	519	break;
	520	case DMM_TRANSPORT_SERIAL:
	521	/* TODO serial FD setup */
	522	// sr_source_add(ctx->serial->fd, G_IO_IN, -1, receive_data, sdi);
	523	break;
	524	}
	525
	526	return SR_OK;
	527	}
	528
	529	static int hw_dev_acquisition_stop(int dev_index, void *cb_data)
	530	{
	531	struct sr_datafeed_packet packet;
	532
	533	/* Avoid compiler warnings. */
	534	(void)dev_index;
	535
	536	sr_dbg("genericdmm: Stopping acquisition.");
	537
	538	/* Send end packet to the session bus. */
	539	sr_dbg("genericdmm: Sending SR_DF_END.");
	540	packet.type = SR_DF_END;
	541	sr_session_send(cb_data, &packet);
	542
	543	return SR_OK;
	544	}
	545
	546	SR_PRIV struct sr_dev_driver genericdmm_driver_info = {
	547	.name = "genericdmm",
	548	.longname = "Generic DMM",
	549	.api_version = 1,
	550	.init = hw_init,
551	.cleanup = hw_cleanup,
61136ea6	552	.scan = hw_scan,
ca3d84cc BV	553	.dev_open = hw_dev_open,
	554	.dev_close = hw_dev_close,
	555	.dev_info_get = hw_dev_info_get,
	556	.dev_status_get = hw_dev_status_get,
	557	.hwcap_get_all = hw_hwcap_get_all,
	558	.dev_config_set = hw_dev_config_set,
	559	.dev_acquisition_start = hw_dev_acquisition_start,
	560	.dev_acquisition_stop = hw_dev_acquisition_stop,
75337758	561	.instances = NULL,
ca3d84cc	562	};