[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 *channel_names[] = {
	"pin4", "pin5", "pin6",
};

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

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;
	const char *probe_names;
	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;
	probe_names = NULL;
	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;
		case SR_CONF_PROBE_NAMES:
			probe_names = 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 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;
		devc->channel_names = sr_parse_probe_names(probe_names,
			channel_names, ARRAY_SIZE(channel_names),
			ARRAY_SIZE(channel_names), &ch_count);

		/* Create the logic channels group. */
		cg = sr_channel_group_new(sdi, "Logic", NULL);
		for (ch_idx = 0; ch_idx < ch_count; ch_idx++) {
			ch = sr_channel_new(sdi, ch_idx, SR_CHANNEL_LOGIC,
				TRUE, devc->channel_names[ch_idx]);
			cg->channels = g_slist_append(cg->channels, ch);
		}
	}

	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)
		return SR_OK;
	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;
	usb = sdi ? sdi->conn : NULL;

	switch (key) {
	case SR_CONF_CONN:
		if (!usb)
			return SR_ERR_ARG;
		*data = g_variant_new_printf("%d.%d", usb->bus, usb->address);
		return SR_OK;
	case SR_CONF_SAMPLERATE:
		if (!devc)
			return SR_ERR_ARG;
		rate = devc->samplerates[devc->curr_samplerate_idx];
		*data = g_variant_new_uint64(rate);
		return SR_OK;
	case SR_CONF_LIMIT_SAMPLES:
		if (!devc)
			return SR_ERR_ARG;
		return sr_sw_limits_config_get(&devc->sw_limits, key, data);
	case SR_CONF_CAPTURE_RATIO:
		if (!devc)
			return SR_ERR_ARG;
		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
3aadf5c4	69	static const char *channel_names[] = {
bde6a99b GS	70	"pin4", "pin5", "pin6",
	71	};
	72
	73	static const uint32_t scanopts[] = {
	74	SR_CONF_CONN,
44f0adb6	75	SR_CONF_PROBE_NAMES,
bde6a99b GS	76	};
	77
	78	static const uint32_t drvopts[] = {
	79	SR_CONF_LOGIC_ANALYZER,
	80	};
	81
	82	static const uint32_t devopts[] = {
	83	SR_CONF_CONN \| SR_CONF_GET,
	84	SR_CONF_SAMPLERATE \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	85	SR_CONF_LIMIT_SAMPLES \| SR_CONF_GET \| SR_CONF_SET,
	86	SR_CONF_TRIGGER_MATCH \| SR_CONF_LIST,
	87	SR_CONF_CAPTURE_RATIO \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	88	};
	89
	90	static const int32_t trigger_matches[] = {
	91	SR_TRIGGER_ZERO,
	92	SR_TRIGGER_ONE,
	93	SR_TRIGGER_RISING,
	94	SR_TRIGGER_FALLING,
	95	};
	96
	97	/*
	98	* Note that a list of 0, 10, 50, 90, 91, 92, 93, would have been nicer
	99	* from a user's perspective, but applications may not support a set of
	100	* discrete supported values, and 91+ is as much of a hack to work around
	101	* the "0-100%" limitation. So let's map those 0-6 "percent" to the vendor
	102	* app's 10/50/90/1W/2W/3W locations.
	103	*/
	104	static const uint64_t captureratios[] = {
	105	0, 1, 2, 3, 4, 5, 6,
	106	};
	107
	108	static const uint64_t samplerates[] = {
	109	SR_KHZ(5),
	110	SR_KHZ(10),
	111	SR_KHZ(25),
	112	SR_KHZ(50),
	113	SR_KHZ(100),
	114	SR_KHZ(250),
	115	SR_KHZ(500),
	116	SR_MHZ(1),
	117	};
	118
a5c0259c GS	119	static GSList scan(struct sr_dev_driver di, GSList *options)
	120	{
	121	struct drv_context *drvc;
bde6a99b	122	const char *conn;
44f0adb6	123	const char *probe_names;
bde6a99b GS	124	GSList l, devices, *usb_devices;
	125	struct sr_config *cfg;
	126	struct sr_usb_dev_inst *usb;
	127	struct sr_dev_inst *sdi;
	128	struct sr_channel_group *cg;
	129	size_t ch_count, ch_idx;
	130	struct sr_channel *ch;
	131	struct dev_context *devc;
a5c0259c	132
a5c0259c	133	drvc = di->context;
a5c0259c	134
bde6a99b	135	conn = PICKIT2_DEFAULT_ADDRESS;
44f0adb6	136	probe_names = NULL;
bde6a99b GS	137	for (l = options; l; l = l->next) {
	138	cfg = l->data;
	139	switch (cfg->key) {
	140	case SR_CONF_CONN:
	141	conn = g_variant_get_string(cfg->data, NULL);
	142	break;
44f0adb6 GS	143	case SR_CONF_PROBE_NAMES:
	144	probe_names = g_variant_get_string(cfg->data, NULL);
	145	break;
bde6a99b GS	146	}
bde6a99b GS	147	}
a5c0259c	148
bde6a99b GS	149	devices = NULL;
	150	usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
	151	if (!usb_devices)
	152	return NULL;
	153
	154	for (l = usb_devices; l; l = l->next) {
	155	usb = l->data;
	156
	157	/* Create the device instance. */
	158	sdi = g_malloc0(sizeof(*sdi));
	159	devices = g_slist_append(devices, sdi);
	160	sdi->status = SR_ST_INACTIVE;
	161	sdi->vendor = g_strdup(PICKIT2_VENDOR_NAME);
	162	sdi->model = g_strdup(PICKIT2_PRODUCT_NAME);
	163	sdi->inst_type = SR_INST_USB;
	164	sdi->conn = usb;
	165	sdi->connection_id = g_strdup(conn);
	166
bde6a99b GS	167	/*
	168	* Create the device context. Pre-select the highest
	169	* samplerate and the deepest sample count available.
	170	*/
	171	devc = g_malloc0(sizeof(*devc));
	172	sdi->priv = devc;
	173	devc->samplerates = samplerates;
	174	devc->num_samplerates = ARRAY_SIZE(samplerates);
	175	devc->curr_samplerate_idx = devc->num_samplerates - 1;
	176	devc->captureratios = captureratios;
	177	devc->num_captureratios = ARRAY_SIZE(captureratios);
	178	devc->curr_captureratio_idx = 0;
	179	devc->sw_limits.limit_samples = PICKIT2_SAMPLE_COUNT;
44f0adb6 GS	180	devc->channel_names = sr_parse_probe_names(probe_names,
	181	channel_names, ARRAY_SIZE(channel_names),
	182	ARRAY_SIZE(channel_names), &ch_count);
4d9c2b77 GS	183
	184	/* Create the logic channels group. */
	185	cg = sr_channel_group_new(sdi, "Logic", NULL);
4d9c2b77 GS	186	for (ch_idx = 0; ch_idx < ch_count; ch_idx++) {
4d9c2b77 GS	187	ch = sr_channel_new(sdi, ch_idx, SR_CHANNEL_LOGIC,
44f0adb6	188	TRUE, devc->channel_names[ch_idx]);
4d9c2b77 GS	189	cg->channels = g_slist_append(cg->channels, ch);
4d9c2b77 GS	190	}
bde6a99b GS	191	}
	192
	193	return std_scan_complete(di, devices);
a5c0259c GS	194	}
	195
	196	static int dev_open(struct sr_dev_inst *sdi)
	197	{
bde6a99b GS	198	struct sr_usb_dev_inst *usb;
	199	struct dev_context *devc;
	200	struct sr_dev_driver *di;
	201	struct drv_context *drvc;
	202	int ret;
	203
	204	usb = sdi->conn;
	205	devc = sdi->priv;
	206	di = sdi->driver;
	207	drvc = di->context;
a5c0259c	208
bde6a99b GS	209	ret = sr_usb_open(drvc->sr_ctx->libusb_ctx, usb);
	210	if (ret < 0)
	211	return SR_ERR;
	212
	213	if (libusb_kernel_driver_active(usb->devhdl, PICKIT2_USB_INTERFACE) == 1) {
	214	ret = libusb_detach_kernel_driver(usb->devhdl, PICKIT2_USB_INTERFACE);
	215	if (ret < 0) {
	216	sr_err("Canot detach kernel driver: %s.",
	217	libusb_error_name(ret));
	218	return SR_ERR;
	219	}
	220	devc->detached_kernel_driver = TRUE;
	221	}
	222
	223	ret = libusb_claim_interface(usb->devhdl, PICKIT2_USB_INTERFACE);
	224	if (ret < 0) {
	225	sr_err("Cannot claim interface: %s.", libusb_error_name(ret));
	226	return SR_ERR;
	227	}
a5c0259c GS	228
	229	return SR_OK;
	230	}
	231
	232	static int dev_close(struct sr_dev_inst *sdi)
	233	{
bde6a99b GS	234	struct sr_usb_dev_inst *usb;
	235	struct dev_context *devc;
	236	int ret;
a5c0259c	237
bde6a99b GS	238	usb = sdi->conn;
	239	devc = sdi->priv;
	240
fbbf21dc GS	241	if (!usb)
fbbf21dc GS	242	return SR_OK;
bde6a99b GS	243	if (!usb->devhdl)
	244	return SR_OK;
	245
	246	ret = libusb_release_interface(usb->devhdl, PICKIT2_USB_INTERFACE);
	247	if (ret) {
	248	sr_err("Cannot release interface: %s.", libusb_error_name(ret));
	249	return SR_ERR;
	250	}
	251
	252	if (devc->detached_kernel_driver) {
	253	ret = libusb_attach_kernel_driver(usb->devhdl, PICKIT2_USB_INTERFACE);
	254	if (ret) {
	255	sr_err("Cannot attach kernel driver: %s.",
	256	libusb_error_name(ret));
	257	return SR_ERR;
	258	}
	259	devc->detached_kernel_driver = FALSE;
	260	}
	261
	262	libusb_close(usb->devhdl);
	263	sdi->conn = NULL;
a5c0259c GS	264
	265	return SR_OK;
	266	}
	267
	268	static int config_get(uint32_t key, GVariant **data,
	269	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	270	{
bde6a99b GS	271	struct dev_context *devc;
	272	struct sr_usb_dev_inst *usb;
	273	uint64_t rate, ratio;
a5c0259c	274
a5c0259c GS	275	(void)cg;
a5c0259c GS	276
e760f2cd	277	devc = sdi ? sdi->priv : NULL;
fbe1481a	278	usb = sdi ? sdi->conn : NULL;
e760f2cd	279
a5c0259c	280	switch (key) {
bde6a99b	281	case SR_CONF_CONN:
fbe1481a	282	if (!usb)
bde6a99b	283	return SR_ERR_ARG;
bde6a99b GS	284	*data = g_variant_new_printf("%d.%d", usb->bus, usb->address);
	285	return SR_OK;
	286	case SR_CONF_SAMPLERATE:
fbe1481a GS	287	if (!devc)
fbe1481a GS	288	return SR_ERR_ARG;
bde6a99b GS	289	rate = devc->samplerates[devc->curr_samplerate_idx];
	290	*data = g_variant_new_uint64(rate);
	291	return SR_OK;
	292	case SR_CONF_LIMIT_SAMPLES:
fbe1481a GS	293	if (!devc)
fbe1481a GS	294	return SR_ERR_ARG;
bde6a99b GS	295	return sr_sw_limits_config_get(&devc->sw_limits, key, data);
bde6a99b GS	296	case SR_CONF_CAPTURE_RATIO:
fbe1481a GS	297	if (!devc)
fbe1481a GS	298	return SR_ERR_ARG;
bde6a99b GS	299	ratio = devc->captureratios[devc->curr_captureratio_idx];
	300	*data = g_variant_new_uint64(ratio);
	301	return SR_OK;
a5c0259c GS	302	default:
	303	return SR_ERR_NA;
	304	}
a5c0259c GS	305	}
	306
	307	static int config_set(uint32_t key, GVariant *data,
	308	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	309	{
bde6a99b GS	310	struct dev_context *devc;
	311	int idx;
	312
a5c0259c GS	313	(void)cg;
a5c0259c GS	314
e760f2cd UH	315	devc = sdi ? sdi->priv : NULL;
e760f2cd UH	316
a5c0259c	317	switch (key) {
bde6a99b GS	318	case SR_CONF_SAMPLERATE:
	319	if (!devc)
	320	return SR_ERR_ARG;
	321	idx = std_u64_idx(data, devc->samplerates, devc->num_samplerates);
	322	if (idx < 0)
	323	return SR_ERR_ARG;
	324	devc->curr_samplerate_idx = idx;
	325	return SR_OK;
	326	case SR_CONF_CAPTURE_RATIO:
	327	if (!devc)
	328	return SR_ERR_ARG;
	329	idx = std_u64_idx(data, devc->captureratios, devc->num_captureratios);
	330	if (idx >= 0)
	331	devc->curr_captureratio_idx = idx;
	332	return SR_OK;
	333	case SR_CONF_LIMIT_SAMPLES:
	334	return sr_sw_limits_config_set(&devc->sw_limits, key, data);
a5c0259c	335	default:
bde6a99b	336	return SR_ERR_NA;
a5c0259c	337	}
a5c0259c GS	338	}
	339
	340	static int config_list(uint32_t key, GVariant **data,
	341	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	342	{
bde6a99b	343	struct dev_context *devc;
a5c0259c	344
bde6a99b	345	devc = sdi ? sdi->priv : NULL;
a5c0259c	346
a5c0259c	347	switch (key) {
bde6a99b GS	348	case SR_CONF_SCAN_OPTIONS:
	349	case SR_CONF_DEVICE_OPTIONS:
	350	return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
	351	case SR_CONF_SAMPLERATE:
	352	if (!devc)
	353	return SR_ERR_NA;
	354	*data = std_gvar_samplerates(devc->samplerates, devc->num_samplerates);
	355	return SR_OK;
	356	case SR_CONF_TRIGGER_MATCH:
	357	*data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches));
	358	return SR_OK;
	359	case SR_CONF_CAPTURE_RATIO:
	360	*data = std_gvar_array_u64(ARRAY_AND_SIZE(captureratios));
	361	return SR_OK;
a5c0259c GS	362	default:
	363	return SR_ERR_NA;
	364	}
a5c0259c GS	365	}
	366
	367	static int dev_acquisition_start(const struct sr_dev_inst *sdi)
	368	{
bde6a99b GS	369	struct dev_context *devc;
	370	struct sr_trigger *trigger;
	371	struct sr_trigger_stage *stage;
	372	struct sr_trigger_match *match;
	373	GSList *l;
	374	size_t idx;
	375	int ret;
a5c0259c	376
bde6a99b GS	377	devc = sdi->priv;
	378
	379	/*
	380	* Query triggers, translate the more complex caller spec to
	381	* "flat" internal variables, to simplify the construction of
	382	* the SETUP packet elsewhere. This driver supports a single
	383	* stage, with match conditions for one or multiple channels.
	384	*/
	385	memset(&devc->triggers, 0, sizeof(devc->triggers));
	386	trigger = sr_session_trigger_get(sdi->session);
	387	if (trigger) {
	388	if (g_slist_length(trigger->stages) > 1)
	389	return SR_ERR_NA;
	390	stage = g_slist_nth_data(trigger->stages, 0);
	391	if (!stage)
	392	return SR_ERR_ARG;
	393	for (l = stage->matches; l; l = l->next) {
	394	match = l->data;
	395	if (!match->match)
	396	continue;
	397	if (!match->channel->enabled)
	398	continue;
	399	idx = match->channel->index;
	400	devc->triggers[idx] = match->match;
	401	}
	402	sr_dbg("acq start: trigger specs: %x/%x/%x",
	403	devc->triggers[0], devc->triggers[1],
	404	devc->triggers[2]);
	405	}
	406	devc->trigpos = trigger ? devc->curr_captureratio_idx : 0;
	407
	408	/* Have the SETUP packet sent, then poll for the status. */
	409	devc->state = STATE_CONF;
	410	ret = microchip_pickit2_setup_trigger(sdi);
	411	if (ret) {
	412	devc->state = STATE_IDLE;
	413	return ret;
	414	}
	415	devc->state = STATE_WAIT;
	416
	417	std_session_send_df_header(sdi);
	418	sr_session_source_add(sdi->session, -1, 0, 20,
	419	microchip_pickit2_receive_data, (void *)sdi);
a5c0259c GS	420
	421	return SR_OK;
	422	}
	423
	424	static int dev_acquisition_stop(struct sr_dev_inst *sdi)
	425	{
bde6a99b GS	426	struct dev_context *devc;
	427
	428	devc = sdi->priv;
	429	if (devc->state < STATE_CONF)
	430	return SR_OK;
	431
	432	/*
	433	* Keep up the acquisition until either data becomes available
	434	* (according to the previously configured trigger condition),
	435	* or until the user cancels the acquisition by pressing the
	436	* device's button. This is a firmware limitation which the
	437	* vendor software "suffers from" as well.
	438	*/
	439	if (devc->state == STATE_WAIT) {
	440	sr_err("Cannot terminate by software, need either data trigger or cancel button.");
	441	return SR_OK;
	442	}
a5c0259c	443
bde6a99b GS	444	if (devc->state > STATE_CONF) {
	445	std_session_send_df_end(sdi);
	446	}
	447	sr_session_source_remove(sdi->session, -1);
	448	devc->state = STATE_IDLE;
a5c0259c GS	449
	450	return SR_OK;
	451	}
	452
	453	static struct sr_dev_driver microchip_pickit2_driver_info = {
	454	.name = "microchip-pickit2",
bde6a99b	455	.longname = PICKIT2_VENDOR_NAME " " PICKIT2_PRODUCT_NAME,
a5c0259c GS	456	.api_version = 1,
	457	.init = std_init,
	458	.cleanup = std_cleanup,
	459	.scan = scan,
	460	.dev_list = std_dev_list,
	461	.dev_clear = std_dev_clear,
	462	.config_get = config_get,
	463	.config_set = config_set,
	464	.config_list = config_list,
	465	.dev_open = dev_open,
	466	.dev_close = dev_close,
	467	.dev_acquisition_start = dev_acquisition_start,
	468	.dev_acquisition_stop = dev_acquisition_stop,
	469	.context = NULL,
	470	};
a5c0259c	471	SR_REGISTER_DEV_DRIVER(microchip_pickit2_driver_info);