[libsigrok.git] / src / hardware / microchip-pickit2 / api.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2018 Gerhard Sittig <gerhard.sittig@gmx.net>
 *
 * 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/>.
 */

/*
 * TODO
 * - Data acquisition works, but triggers either seem to not take effect,
 *   or the trigger position is not in the expected spot according to the
 *   user provided acquisition parameters. More research is required. The
 *   bitmasks for enable/level/edge as well as the magic 16bit values for
 *   position may need adjustment.
 * - The trigger position logic assumes that capture ratio specs are in
 *   the range of 0-6%, which gets mapped to none/10%/50%/90%/+1W/+2W/+3W
 *   choices. This avoids issues with applications which lack support for
 *   non-contiguous discrete supported values, and values outside of the
 *   0-100% range. This is considered acceptable, to avoid the necessity
 *   to extend common infrastructure to an unusual feature of a single
 *   device of limited popularity. Just needs to get communicated to users.
 * - When a formula for the trigger position values in the SETUP packet
 *   is found, the driver may accept arbitrary values between 0-100%, but
 *   still could not express the "plus N windows" settings. Though that'd
 *   be a rather useful feature considering the very short memory depth.
 * - The current implementation assumes externally provided Vdd, without
 *   which input levels won't get detected. A future implementation could
 *   optionally power Vdd from the PICkit2 itself, according to a user
 *   provided configuration value.
 * - The current implementation silently accepts sample count limits beyond
 *   1024, just won't provide more than 1024 samples to the session. A
 *   future implementation could cap the settings upon reception. Apps
 *   like PulseView may not be able to specify 1024, and pass 1000 or
 *   2000 instead (the latter results in 1024 getting used).
 * - The manual suggests that users can assign names to devices. The
 *   current implementation supports conn= specs with USB VID:PID pairs
 *   or bus/address numbers. A future implementation could scan for user
 *   assigned names as well (when the opcode to query the name was found).
 * - The "attach kernel driver" support code probably should move to a
 *   common location, instead of getting repeated across several drivers.
 * - Diagnostics may benefit from cleanup.
 */

#include <config.h>
#include <libusb.h>
#include <string.h>
#include "protocol.h"

#define PICKIT2_VENDOR_NAME	"Microchip"
#define PICKIT2_PRODUCT_NAME	"PICkit2"

#define PICKIT2_DEFAULT_ADDRESS	"04d8.0033"
#define PICKIT2_USB_INTERFACE	0

static struct sr_dev_driver microchip_pickit2_driver_info;

static const char *pickit2_channel_names[] = {
	"pin4", "pin5", "pin6",
};

static const uint32_t scanopts[] = {
	SR_CONF_CONN,
};

static const uint32_t drvopts[] = {
	SR_CONF_LOGIC_ANALYZER,
};

static const uint32_t devopts[] = {
	SR_CONF_CONN | SR_CONF_GET,
	SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
	SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
	SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
	SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
};

static const int32_t trigger_matches[] = {
	SR_TRIGGER_ZERO,
	SR_TRIGGER_ONE,
	SR_TRIGGER_RISING,
	SR_TRIGGER_FALLING,
};

/*
 * Note that a list of 0, 10, 50, 90, 91, 92, 93, would have been nicer
 * from a user's perspective, but applications may not support a set of
 * discrete supported values, and 91+ is as much of a hack to work around
 * the "0-100%" limitation. So let's map those 0-6 "percent" to the vendor
 * app's 10/50/90/1W/2W/3W locations.
 */
static const uint64_t captureratios[] = {
	0, 1, 2, 3, 4, 5, 6,
};

static const uint64_t samplerates[] = {
	SR_KHZ(5),
	SR_KHZ(10),
	SR_KHZ(25),
	SR_KHZ(50),
	SR_KHZ(100),
	SR_KHZ(250),
	SR_KHZ(500),
	SR_MHZ(1),
};

static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
	struct drv_context *drvc;
	const char *conn;
	GSList *l, *devices, *usb_devices;
	struct sr_config *cfg;
	struct sr_usb_dev_inst *usb;
	struct sr_dev_inst *sdi;
	struct sr_channel_group *cg;
	size_t ch_count, ch_idx;
	struct sr_channel *ch;
	struct dev_context *devc;

	drvc = di->context;

	conn = PICKIT2_DEFAULT_ADDRESS;
	for (l = options; l; l = l->next) {
		cfg = l->data;
		switch (cfg->key) {
		case SR_CONF_CONN:
			conn = g_variant_get_string(cfg->data, NULL);
			break;
		}
	}

	devices = NULL;
	usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
	if (!usb_devices)
		return NULL;

	for (l = usb_devices; l; l = l->next) {
		usb = l->data;

		/* Create the device instance. */
		sdi = g_malloc0(sizeof(*sdi));
		devices = g_slist_append(devices, sdi);
		sdi->status = SR_ST_INACTIVE;
		sdi->vendor = g_strdup(PICKIT2_VENDOR_NAME);
		sdi->model = g_strdup(PICKIT2_PRODUCT_NAME);
		sdi->inst_type = SR_INST_USB;
		sdi->conn = usb;
		sdi->connection_id = g_strdup(conn);

		/* Create the logic channels group. */
		cg = g_malloc0(sizeof(*cg));
		sdi->channel_groups = g_slist_append(NULL, cg);
		cg->name = g_strdup("Logic");
		ch_count = ARRAY_SIZE(pickit2_channel_names);
		for (ch_idx = 0; ch_idx < ch_count; ch_idx++) {
			ch = sr_channel_new(sdi, ch_idx, SR_CHANNEL_LOGIC,
				TRUE, pickit2_channel_names[ch_idx]);
			cg->channels = g_slist_append(cg->channels, ch);
		}

		/*
		 * Create the device context. Pre-select the highest
		 * samplerate and the deepest sample count available.
		 */
		devc = g_malloc0(sizeof(*devc));
		sdi->priv = devc;
		devc->samplerates = samplerates;
		devc->num_samplerates = ARRAY_SIZE(samplerates);
		devc->curr_samplerate_idx = devc->num_samplerates - 1;
		devc->captureratios = captureratios;
		devc->num_captureratios = ARRAY_SIZE(captureratios);
		devc->curr_captureratio_idx = 0;
		devc->sw_limits.limit_samples = PICKIT2_SAMPLE_COUNT;
	}

	return std_scan_complete(di, devices);
}

static int dev_open(struct sr_dev_inst *sdi)
{
	struct sr_usb_dev_inst *usb;
	struct dev_context *devc;
	struct sr_dev_driver *di;
	struct drv_context *drvc;
	int ret;

	usb = sdi->conn;
	devc = sdi->priv;
	di = sdi->driver;
	drvc = di->context;

	ret = sr_usb_open(drvc->sr_ctx->libusb_ctx, usb);
	if (ret < 0)
		return SR_ERR;

	if (libusb_kernel_driver_active(usb->devhdl, PICKIT2_USB_INTERFACE) == 1) {
		ret = libusb_detach_kernel_driver(usb->devhdl, PICKIT2_USB_INTERFACE);
		if (ret < 0) {
			sr_err("Canot detach kernel driver: %s.",
				libusb_error_name(ret));
			return SR_ERR;
		}
		devc->detached_kernel_driver = TRUE;
	}

	ret = libusb_claim_interface(usb->devhdl, PICKIT2_USB_INTERFACE);
	if (ret < 0) {
		sr_err("Cannot claim interface: %s.", libusb_error_name(ret));
		return SR_ERR;
	}

	return SR_OK;
}

static int dev_close(struct sr_dev_inst *sdi)
{
	struct sr_usb_dev_inst *usb;
	struct dev_context *devc;
	int ret;

	usb = sdi->conn;
	devc = sdi->priv;

	if (!usb->devhdl)
		return SR_OK;

	ret = libusb_release_interface(usb->devhdl, PICKIT2_USB_INTERFACE);
	if (ret) {
		sr_err("Cannot release interface: %s.", libusb_error_name(ret));
		return SR_ERR;
	}

	if (devc->detached_kernel_driver) {
		ret = libusb_attach_kernel_driver(usb->devhdl, PICKIT2_USB_INTERFACE);
		if (ret) {
			sr_err("Cannot attach kernel driver: %s.",
				libusb_error_name(ret));
			return SR_ERR;
		}
		devc->detached_kernel_driver = FALSE;
	}

	libusb_close(usb->devhdl);
	sdi->conn = NULL;

	return SR_OK;
}

static int config_get(uint32_t key, GVariant **data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	struct dev_context *devc;
	struct sr_usb_dev_inst *usb;
	uint64_t rate, ratio;

	(void)cg;

	devc = sdi ? sdi->priv : NULL;

	switch (key) {
	case SR_CONF_CONN:
		if (!sdi->conn)
			return SR_ERR_ARG;
		usb = sdi->conn;
		*data = g_variant_new_printf("%d.%d", usb->bus, usb->address);
		return SR_OK;
	case SR_CONF_SAMPLERATE:
		rate = devc->samplerates[devc->curr_samplerate_idx];
		*data = g_variant_new_uint64(rate);
		return SR_OK;
	case SR_CONF_LIMIT_SAMPLES:
		return sr_sw_limits_config_get(&devc->sw_limits, key, data);
	case SR_CONF_CAPTURE_RATIO:
		ratio = devc->captureratios[devc->curr_captureratio_idx];
		*data = g_variant_new_uint64(ratio);
		return SR_OK;
	default:
		return SR_ERR_NA;
	}
}

static int config_set(uint32_t key, GVariant *data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	struct dev_context *devc;
	int idx;

	(void)cg;

	devc = sdi ? sdi->priv : NULL;

	switch (key) {
	case SR_CONF_SAMPLERATE:
		if (!devc)
			return SR_ERR_ARG;
		idx = std_u64_idx(data, devc->samplerates, devc->num_samplerates);
		if (idx < 0)
			return SR_ERR_ARG;
		devc->curr_samplerate_idx = idx;
		return SR_OK;
	case SR_CONF_CAPTURE_RATIO:
		if (!devc)
			return SR_ERR_ARG;
		idx = std_u64_idx(data, devc->captureratios, devc->num_captureratios);
		if (idx >= 0)
			devc->curr_captureratio_idx = idx;
		return SR_OK;
	case SR_CONF_LIMIT_SAMPLES:
		return sr_sw_limits_config_set(&devc->sw_limits, key, data);
	default:
		return SR_ERR_NA;
	}
}

static int config_list(uint32_t key, GVariant **data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	struct dev_context *devc;

	devc = sdi ? sdi->priv : NULL;

	switch (key) {
	case SR_CONF_SCAN_OPTIONS:
	case SR_CONF_DEVICE_OPTIONS:
		return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
	case SR_CONF_SAMPLERATE:
		if (!devc)
			return SR_ERR_NA;
		*data = std_gvar_samplerates(devc->samplerates, devc->num_samplerates);
		return SR_OK;
	case SR_CONF_TRIGGER_MATCH:
		*data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches));
		return SR_OK;
	case SR_CONF_CAPTURE_RATIO:
		*data = std_gvar_array_u64(ARRAY_AND_SIZE(captureratios));
		return SR_OK;
	default:
		return SR_ERR_NA;
	}
}

static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	struct sr_trigger *trigger;
	struct sr_trigger_stage *stage;
	struct sr_trigger_match *match;
	GSList *l;
	size_t idx;
	int ret;

	devc = sdi->priv;

	/*
	 * Query triggers, translate the more complex caller spec to
	 * "flat" internal variables, to simplify the construction of
	 * the SETUP packet elsewhere. This driver supports a single
	 * stage, with match conditions for one or multiple channels.
	 */
	memset(&devc->triggers, 0, sizeof(devc->triggers));
	trigger = sr_session_trigger_get(sdi->session);
	if (trigger) {
		if (g_slist_length(trigger->stages) > 1)
			return SR_ERR_NA;
		stage = g_slist_nth_data(trigger->stages, 0);
		if (!stage)
			return SR_ERR_ARG;
		for (l = stage->matches; l; l = l->next) {
			match = l->data;
			if (!match->match)
				continue;
			if (!match->channel->enabled)
				continue;
			idx = match->channel->index;
			devc->triggers[idx] = match->match;
		}
		sr_dbg("acq start: trigger specs: %x/%x/%x",
			devc->triggers[0], devc->triggers[1],
			devc->triggers[2]);
	}
	devc->trigpos = trigger ? devc->curr_captureratio_idx : 0;

	/* Have the SETUP packet sent, then poll for the status. */
	devc->state = STATE_CONF;
	ret = microchip_pickit2_setup_trigger(sdi);
	if (ret) {
		devc->state = STATE_IDLE;
		return ret;
	}
	devc->state = STATE_WAIT;

	std_session_send_df_header(sdi);
	sr_session_source_add(sdi->session, -1, 0, 20,
		microchip_pickit2_receive_data, (void *)sdi);

	return SR_OK;
}

static int dev_acquisition_stop(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;

	devc = sdi->priv;
	if (devc->state < STATE_CONF)
		return SR_OK;

	/*
	 * Keep up the acquisition until either data becomes available
	 * (according to the previously configured trigger condition),
	 * or until the user cancels the acquisition by pressing the
	 * device's button. This is a firmware limitation which the
	 * vendor software "suffers from" as well.
	 */
	if (devc->state == STATE_WAIT) {
		sr_err("Cannot terminate by software, need either data trigger or cancel button.");
		return SR_OK;
	}

	if (devc->state > STATE_CONF) {
		std_session_send_df_end(sdi);
	}
	sr_session_source_remove(sdi->session, -1);
	devc->state = STATE_IDLE;

	return SR_OK;
}

static struct sr_dev_driver microchip_pickit2_driver_info = {
	.name = "microchip-pickit2",
	.longname = PICKIT2_VENDOR_NAME " " PICKIT2_PRODUCT_NAME,
	.api_version = 1,
	.init = std_init,
	.cleanup = std_cleanup,
	.scan = scan,
	.dev_list = std_dev_list,
	.dev_clear = std_dev_clear,
	.config_get = config_get,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = dev_open,
	.dev_close = dev_close,
	.dev_acquisition_start = dev_acquisition_start,
	.dev_acquisition_stop = dev_acquisition_stop,
	.context = NULL,
};
SR_REGISTER_DEV_DRIVER(microchip_pickit2_driver_info);
Commit	Line	Data
a5c0259c GS	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2018 Gerhard Sittig <gerhard.sittig@gmx.net>
	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
bde6a99b GS	20	/*
	21	* TODO
	22	* - Data acquisition works, but triggers either seem to not take effect,
	23	* or the trigger position is not in the expected spot according to the
	24	* user provided acquisition parameters. More research is required. The
	25	* bitmasks for enable/level/edge as well as the magic 16bit values for
	26	* position may need adjustment.
	27	* - The trigger position logic assumes that capture ratio specs are in
	28	* the range of 0-6%, which gets mapped to none/10%/50%/90%/+1W/+2W/+3W
	29	* choices. This avoids issues with applications which lack support for
	30	* non-contiguous discrete supported values, and values outside of the
	31	* 0-100% range. This is considered acceptable, to avoid the necessity
	32	* to extend common infrastructure to an unusual feature of a single
	33	* device of limited popularity. Just needs to get communicated to users.
	34	* - When a formula for the trigger position values in the SETUP packet
	35	* is found, the driver may accept arbitrary values between 0-100%, but
	36	* still could not express the "plus N windows" settings. Though that'd
	37	* be a rather useful feature considering the very short memory depth.
	38	* - The current implementation assumes externally provided Vdd, without
	39	* which input levels won't get detected. A future implementation could
	40	* optionally power Vdd from the PICkit2 itself, according to a user
	41	* provided configuration value.
	42	* - The current implementation silently accepts sample count limits beyond
	43	* 1024, just won't provide more than 1024 samples to the session. A
	44	* future implementation could cap the settings upon reception. Apps
e760f2cd	45	* like PulseView may not be able to specify 1024, and pass 1000 or
bde6a99b GS	46	* 2000 instead (the latter results in 1024 getting used).
	47	* - The manual suggests that users can assign names to devices. The
	48	* current implementation supports conn= specs with USB VID:PID pairs
	49	* or bus/address numbers. A future implementation could scan for user
	50	* assigned names as well (when the opcode to query the name was found).
	51	* - The "attach kernel driver" support code probably should move to a
	52	* common location, instead of getting repeated across several drivers.
	53	* - Diagnostics may benefit from cleanup.
	54	*/
	55
a5c0259c	56	#include <config.h>
bde6a99b GS	57	#include <libusb.h>
bde6a99b GS	58	#include <string.h>
a5c0259c GS	59	#include "protocol.h"
a5c0259c GS	60
bde6a99b GS	61	#define PICKIT2_VENDOR_NAME "Microchip"
	62	#define PICKIT2_PRODUCT_NAME "PICkit2"
	63
	64	#define PICKIT2_DEFAULT_ADDRESS "04d8.0033"
	65	#define PICKIT2_USB_INTERFACE 0
	66
a5c0259c GS	67	static struct sr_dev_driver microchip_pickit2_driver_info;
a5c0259c GS	68
bde6a99b GS	69	static const char *pickit2_channel_names[] = {
	70	"pin4", "pin5", "pin6",
	71	};
	72
	73	static const uint32_t scanopts[] = {
	74	SR_CONF_CONN,
	75	};
	76
	77	static const uint32_t drvopts[] = {
	78	SR_CONF_LOGIC_ANALYZER,
	79	};
	80
	81	static const uint32_t devopts[] = {
	82	SR_CONF_CONN \| SR_CONF_GET,
	83	SR_CONF_SAMPLERATE \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	84	SR_CONF_LIMIT_SAMPLES \| SR_CONF_GET \| SR_CONF_SET,
	85	SR_CONF_TRIGGER_MATCH \| SR_CONF_LIST,
	86	SR_CONF_CAPTURE_RATIO \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	87	};
	88
	89	static const int32_t trigger_matches[] = {
	90	SR_TRIGGER_ZERO,
	91	SR_TRIGGER_ONE,
	92	SR_TRIGGER_RISING,
	93	SR_TRIGGER_FALLING,
	94	};
	95
	96	/*
	97	* Note that a list of 0, 10, 50, 90, 91, 92, 93, would have been nicer
	98	* from a user's perspective, but applications may not support a set of
	99	* discrete supported values, and 91+ is as much of a hack to work around
	100	* the "0-100%" limitation. So let's map those 0-6 "percent" to the vendor
	101	* app's 10/50/90/1W/2W/3W locations.
	102	*/
	103	static const uint64_t captureratios[] = {
	104	0, 1, 2, 3, 4, 5, 6,
	105	};
	106
	107	static const uint64_t samplerates[] = {
	108	SR_KHZ(5),
	109	SR_KHZ(10),
	110	SR_KHZ(25),
	111	SR_KHZ(50),
	112	SR_KHZ(100),
	113	SR_KHZ(250),
	114	SR_KHZ(500),
	115	SR_MHZ(1),
	116	};
	117
a5c0259c GS	118	static GSList scan(struct sr_dev_driver di, GSList *options)
	119	{
	120	struct drv_context *drvc;
bde6a99b GS	121	const char *conn;
	122	GSList l, devices, *usb_devices;
	123	struct sr_config *cfg;
	124	struct sr_usb_dev_inst *usb;
	125	struct sr_dev_inst *sdi;
	126	struct sr_channel_group *cg;
	127	size_t ch_count, ch_idx;
	128	struct sr_channel *ch;
	129	struct dev_context *devc;
a5c0259c	130
a5c0259c	131	drvc = di->context;
a5c0259c	132
bde6a99b GS	133	conn = PICKIT2_DEFAULT_ADDRESS;
	134	for (l = options; l; l = l->next) {
	135	cfg = l->data;
	136	switch (cfg->key) {
	137	case SR_CONF_CONN:
	138	conn = g_variant_get_string(cfg->data, NULL);
	139	break;
	140	}
	141	}
a5c0259c	142
bde6a99b GS	143	devices = NULL;
	144	usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
	145	if (!usb_devices)
	146	return NULL;
	147
	148	for (l = usb_devices; l; l = l->next) {
	149	usb = l->data;
	150
	151	/* Create the device instance. */
	152	sdi = g_malloc0(sizeof(*sdi));
	153	devices = g_slist_append(devices, sdi);
	154	sdi->status = SR_ST_INACTIVE;
	155	sdi->vendor = g_strdup(PICKIT2_VENDOR_NAME);
	156	sdi->model = g_strdup(PICKIT2_PRODUCT_NAME);
	157	sdi->inst_type = SR_INST_USB;
	158	sdi->conn = usb;
	159	sdi->connection_id = g_strdup(conn);
	160
	161	/* Create the logic channels group. */
	162	cg = g_malloc0(sizeof(*cg));
	163	sdi->channel_groups = g_slist_append(NULL, cg);
	164	cg->name = g_strdup("Logic");
	165	ch_count = ARRAY_SIZE(pickit2_channel_names);
	166	for (ch_idx = 0; ch_idx < ch_count; ch_idx++) {
	167	ch = sr_channel_new(sdi, ch_idx, SR_CHANNEL_LOGIC,
	168	TRUE, pickit2_channel_names[ch_idx]);
	169	cg->channels = g_slist_append(cg->channels, ch);
	170	}
	171
	172	/*
	173	* Create the device context. Pre-select the highest
	174	* samplerate and the deepest sample count available.
	175	*/
	176	devc = g_malloc0(sizeof(*devc));
	177	sdi->priv = devc;
	178	devc->samplerates = samplerates;
	179	devc->num_samplerates = ARRAY_SIZE(samplerates);
	180	devc->curr_samplerate_idx = devc->num_samplerates - 1;
	181	devc->captureratios = captureratios;
	182	devc->num_captureratios = ARRAY_SIZE(captureratios);
	183	devc->curr_captureratio_idx = 0;
	184	devc->sw_limits.limit_samples = PICKIT2_SAMPLE_COUNT;
	185	}
	186
	187	return std_scan_complete(di, devices);
a5c0259c GS	188	}
	189
	190	static int dev_open(struct sr_dev_inst *sdi)
	191	{
bde6a99b GS	192	struct sr_usb_dev_inst *usb;
	193	struct dev_context *devc;
	194	struct sr_dev_driver *di;
	195	struct drv_context *drvc;
	196	int ret;
	197
	198	usb = sdi->conn;
	199	devc = sdi->priv;
	200	di = sdi->driver;
	201	drvc = di->context;
a5c0259c	202
bde6a99b GS	203	ret = sr_usb_open(drvc->sr_ctx->libusb_ctx, usb);
	204	if (ret < 0)
	205	return SR_ERR;
	206
	207	if (libusb_kernel_driver_active(usb->devhdl, PICKIT2_USB_INTERFACE) == 1) {
	208	ret = libusb_detach_kernel_driver(usb->devhdl, PICKIT2_USB_INTERFACE);
	209	if (ret < 0) {
	210	sr_err("Canot detach kernel driver: %s.",
	211	libusb_error_name(ret));
	212	return SR_ERR;
	213	}
	214	devc->detached_kernel_driver = TRUE;
	215	}
	216
	217	ret = libusb_claim_interface(usb->devhdl, PICKIT2_USB_INTERFACE);
	218	if (ret < 0) {
	219	sr_err("Cannot claim interface: %s.", libusb_error_name(ret));
	220	return SR_ERR;
	221	}
a5c0259c GS	222
	223	return SR_OK;
	224	}
	225
	226	static int dev_close(struct sr_dev_inst *sdi)
	227	{
bde6a99b GS	228	struct sr_usb_dev_inst *usb;
	229	struct dev_context *devc;
	230	int ret;
a5c0259c	231
bde6a99b GS	232	usb = sdi->conn;
	233	devc = sdi->priv;
	234
	235	if (!usb->devhdl)
	236	return SR_OK;
	237
	238	ret = libusb_release_interface(usb->devhdl, PICKIT2_USB_INTERFACE);
	239	if (ret) {
	240	sr_err("Cannot release interface: %s.", libusb_error_name(ret));
	241	return SR_ERR;
	242	}
	243
	244	if (devc->detached_kernel_driver) {
	245	ret = libusb_attach_kernel_driver(usb->devhdl, PICKIT2_USB_INTERFACE);
	246	if (ret) {
	247	sr_err("Cannot attach kernel driver: %s.",
	248	libusb_error_name(ret));
	249	return SR_ERR;
	250	}
	251	devc->detached_kernel_driver = FALSE;
	252	}
	253
	254	libusb_close(usb->devhdl);
	255	sdi->conn = NULL;
a5c0259c GS	256
	257	return SR_OK;
	258	}
	259
	260	static int config_get(uint32_t key, GVariant **data,
	261	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	262	{
bde6a99b GS	263	struct dev_context *devc;
	264	struct sr_usb_dev_inst *usb;
	265	uint64_t rate, ratio;
a5c0259c	266
a5c0259c GS	267	(void)cg;
a5c0259c GS	268
e760f2cd UH	269	devc = sdi ? sdi->priv : NULL;
e760f2cd UH	270
a5c0259c	271	switch (key) {
bde6a99b GS	272	case SR_CONF_CONN:
	273	if (!sdi->conn)
	274	return SR_ERR_ARG;
	275	usb = sdi->conn;
	276	*data = g_variant_new_printf("%d.%d", usb->bus, usb->address);
	277	return SR_OK;
	278	case SR_CONF_SAMPLERATE:
	279	rate = devc->samplerates[devc->curr_samplerate_idx];
	280	*data = g_variant_new_uint64(rate);
	281	return SR_OK;
	282	case SR_CONF_LIMIT_SAMPLES:
	283	return sr_sw_limits_config_get(&devc->sw_limits, key, data);
	284	case SR_CONF_CAPTURE_RATIO:
	285	ratio = devc->captureratios[devc->curr_captureratio_idx];
	286	*data = g_variant_new_uint64(ratio);
	287	return SR_OK;
a5c0259c GS	288	default:
	289	return SR_ERR_NA;
	290	}
a5c0259c GS	291	}
	292
	293	static int config_set(uint32_t key, GVariant *data,
	294	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	295	{
bde6a99b GS	296	struct dev_context *devc;
	297	int idx;
	298
a5c0259c GS	299	(void)cg;
a5c0259c GS	300
e760f2cd UH	301	devc = sdi ? sdi->priv : NULL;
e760f2cd UH	302
a5c0259c	303	switch (key) {
bde6a99b GS	304	case SR_CONF_SAMPLERATE:
	305	if (!devc)
	306	return SR_ERR_ARG;
	307	idx = std_u64_idx(data, devc->samplerates, devc->num_samplerates);
	308	if (idx < 0)
	309	return SR_ERR_ARG;
	310	devc->curr_samplerate_idx = idx;
	311	return SR_OK;
	312	case SR_CONF_CAPTURE_RATIO:
	313	if (!devc)
	314	return SR_ERR_ARG;
	315	idx = std_u64_idx(data, devc->captureratios, devc->num_captureratios);
	316	if (idx >= 0)
	317	devc->curr_captureratio_idx = idx;
	318	return SR_OK;
	319	case SR_CONF_LIMIT_SAMPLES:
	320	return sr_sw_limits_config_set(&devc->sw_limits, key, data);
a5c0259c	321	default:
bde6a99b	322	return SR_ERR_NA;
a5c0259c	323	}
a5c0259c GS	324	}
	325
	326	static int config_list(uint32_t key, GVariant **data,
	327	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	328	{
bde6a99b	329	struct dev_context *devc;
a5c0259c	330
bde6a99b	331	devc = sdi ? sdi->priv : NULL;
a5c0259c	332
a5c0259c	333	switch (key) {
bde6a99b GS	334	case SR_CONF_SCAN_OPTIONS:
	335	case SR_CONF_DEVICE_OPTIONS:
	336	return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
	337	case SR_CONF_SAMPLERATE:
	338	if (!devc)
	339	return SR_ERR_NA;
	340	*data = std_gvar_samplerates(devc->samplerates, devc->num_samplerates);
	341	return SR_OK;
	342	case SR_CONF_TRIGGER_MATCH:
	343	*data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches));
	344	return SR_OK;
	345	case SR_CONF_CAPTURE_RATIO:
	346	*data = std_gvar_array_u64(ARRAY_AND_SIZE(captureratios));
	347	return SR_OK;
a5c0259c GS	348	default:
	349	return SR_ERR_NA;
	350	}
a5c0259c GS	351	}
	352
	353	static int dev_acquisition_start(const struct sr_dev_inst *sdi)
	354	{
bde6a99b GS	355	struct dev_context *devc;
	356	struct sr_trigger *trigger;
	357	struct sr_trigger_stage *stage;
	358	struct sr_trigger_match *match;
	359	GSList *l;
	360	size_t idx;
	361	int ret;
a5c0259c	362
bde6a99b GS	363	devc = sdi->priv;
	364
	365	/*
	366	* Query triggers, translate the more complex caller spec to
	367	* "flat" internal variables, to simplify the construction of
	368	* the SETUP packet elsewhere. This driver supports a single
	369	* stage, with match conditions for one or multiple channels.
	370	*/
	371	memset(&devc->triggers, 0, sizeof(devc->triggers));
	372	trigger = sr_session_trigger_get(sdi->session);
	373	if (trigger) {
	374	if (g_slist_length(trigger->stages) > 1)
	375	return SR_ERR_NA;
	376	stage = g_slist_nth_data(trigger->stages, 0);
	377	if (!stage)
	378	return SR_ERR_ARG;
	379	for (l = stage->matches; l; l = l->next) {
	380	match = l->data;
	381	if (!match->match)
	382	continue;
	383	if (!match->channel->enabled)
	384	continue;
	385	idx = match->channel->index;
	386	devc->triggers[idx] = match->match;
	387	}
	388	sr_dbg("acq start: trigger specs: %x/%x/%x",
	389	devc->triggers[0], devc->triggers[1],
	390	devc->triggers[2]);
	391	}
	392	devc->trigpos = trigger ? devc->curr_captureratio_idx : 0;
	393
	394	/* Have the SETUP packet sent, then poll for the status. */
	395	devc->state = STATE_CONF;
	396	ret = microchip_pickit2_setup_trigger(sdi);
	397	if (ret) {
	398	devc->state = STATE_IDLE;
	399	return ret;
	400	}
	401	devc->state = STATE_WAIT;
	402
	403	std_session_send_df_header(sdi);
	404	sr_session_source_add(sdi->session, -1, 0, 20,
	405	microchip_pickit2_receive_data, (void *)sdi);
a5c0259c GS	406
	407	return SR_OK;
	408	}
	409
	410	static int dev_acquisition_stop(struct sr_dev_inst *sdi)
	411	{
bde6a99b GS	412	struct dev_context *devc;
	413
	414	devc = sdi->priv;
	415	if (devc->state < STATE_CONF)
	416	return SR_OK;
	417
	418	/*
	419	* Keep up the acquisition until either data becomes available
	420	* (according to the previously configured trigger condition),
	421	* or until the user cancels the acquisition by pressing the
	422	* device's button. This is a firmware limitation which the
	423	* vendor software "suffers from" as well.
	424	*/
	425	if (devc->state == STATE_WAIT) {
	426	sr_err("Cannot terminate by software, need either data trigger or cancel button.");
	427	return SR_OK;
	428	}
a5c0259c	429
bde6a99b GS	430	if (devc->state > STATE_CONF) {
	431	std_session_send_df_end(sdi);
	432	}
	433	sr_session_source_remove(sdi->session, -1);
	434	devc->state = STATE_IDLE;
a5c0259c GS	435
	436	return SR_OK;
	437	}
	438
	439	static struct sr_dev_driver microchip_pickit2_driver_info = {
	440	.name = "microchip-pickit2",
bde6a99b	441	.longname = PICKIT2_VENDOR_NAME " " PICKIT2_PRODUCT_NAME,
a5c0259c GS	442	.api_version = 1,
	443	.init = std_init,
	444	.cleanup = std_cleanup,
	445	.scan = scan,
	446	.dev_list = std_dev_list,
	447	.dev_clear = std_dev_clear,
	448	.config_get = config_get,
	449	.config_set = config_set,
	450	.config_list = config_list,
	451	.dev_open = dev_open,
	452	.dev_close = dev_close,
	453	.dev_acquisition_start = dev_acquisition_start,
	454	.dev_acquisition_stop = dev_acquisition_stop,
	455	.context = NULL,
	456	};
a5c0259c	457	SR_REGISTER_DEV_DRIVER(microchip_pickit2_driver_info);