[libsigrok.git] / src / hardware / atten-pps3xxx / api.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2014 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 <string.h>
#include "protocol.h"

/*
 * The default serial communication settings on the device are 9600
 * baud, 9 data bits. The 9th bit isn't actually used, and the vendor
 * software uses Mark parity to absorb the extra bit.
 *
 * Since 9 data bits is not a standard available in POSIX, we use two
 * stop bits to skip over the extra bit instead.
 */
#define SERIALCOMM "9600/8n2"

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

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

static const uint32_t devopts[] = {
	SR_CONF_CONTINUOUS | SR_CONF_SET,
	SR_CONF_CHANNEL_CONFIG | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
	SR_CONF_OVER_CURRENT_PROTECTION_ENABLED | SR_CONF_GET | SR_CONF_SET,
};

static const uint32_t devopts_cg[] = {
	SR_CONF_VOLTAGE | SR_CONF_GET,
	SR_CONF_VOLTAGE_TARGET | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
	SR_CONF_CURRENT | SR_CONF_GET,
	SR_CONF_CURRENT_LIMIT | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
	SR_CONF_ENABLED | SR_CONF_GET | SR_CONF_SET,
};

static const char *channel_modes[] = {
	"Independent",
	"Series",
	"Parallel",
};

static const struct pps_model models[] = {
	{ PPS_3203T_3S, "PPS3203T-3S",
		CHANMODE_INDEPENDENT | CHANMODE_SERIES | CHANMODE_PARALLEL,
		3,
		{
			/* Channel 1 */
			{ { 0, 32, 0.01 }, { 0, 3, 0.001 } },
			/* Channel 2 */
			{ { 0, 32, 0.01 }, { 0, 3, 0.001 } },
			/* Channel 3 */
			{ { 0, 6, 0.01 }, { 0, 3, 0.001 } },
		},
	},
};

SR_PRIV struct sr_dev_driver atten_pps3203_driver_info;

static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
{
	return std_init(sr_ctx, di, LOG_PREFIX);
}

static GSList *scan(struct sr_dev_driver *di, GSList *options, int modelid)
{
	struct sr_dev_inst *sdi;
	struct drv_context *drvc;
	struct dev_context *devc;
	struct sr_config *src;
	struct sr_channel *ch;
	struct sr_channel_group *cg;
	struct sr_serial_dev_inst *serial;
	GSList *l, *devices;
	const struct pps_model *model;
	uint8_t packet[PACKET_SIZE];
	unsigned int i;
	int delay_ms, ret;
	const char *conn, *serialcomm;
	char channel[10];

	devices = NULL;
	drvc = di->context;
	drvc->instances = NULL;

	conn = serialcomm = NULL;
	for (l = options; l; l = l->next) {
		src = l->data;
		switch (src->key) {
		case SR_CONF_CONN:
			conn = g_variant_get_string(src->data, NULL);
			break;
		case SR_CONF_SERIALCOMM:
			serialcomm = g_variant_get_string(src->data, NULL);
			break;
		}
	}
	if (!conn)
		return NULL;
	if (!serialcomm)
		serialcomm = SERIALCOMM;

	serial = sr_serial_dev_inst_new(conn, serialcomm);

	if (serial_open(serial, SERIAL_RDWR) != SR_OK)
		return NULL;

	serial_flush(serial);

	/* This is how the vendor software scans for hardware. */
	memset(packet, 0, PACKET_SIZE);
	packet[0] = 0xaa;
	packet[1] = 0xaa;
	delay_ms = serial_timeout(serial, PACKET_SIZE);
	if (serial_write_blocking(serial, packet, PACKET_SIZE, delay_ms) < PACKET_SIZE) {
		sr_err("Unable to write while probing for hardware.");
		return NULL;
	}
	/* The device responds with a 24-byte packet when it receives a packet.
	 * At 9600 baud, 300ms is long enough for it to have arrived. */
	g_usleep(300 * 1000);
	memset(packet, 0, PACKET_SIZE);
	if ((ret = serial_read_nonblocking(serial, packet, PACKET_SIZE)) < 0) {
		sr_err("Unable to read while probing for hardware: %s",
				sr_strerror(ret));
		return NULL;
	}
	if (ret != PACKET_SIZE || packet[0] != 0xaa || packet[1] != 0xaa) {
		/* Doesn't look like an Atten PPS. */
		return NULL;
	}

	model = NULL;
	for (i = 0; i < ARRAY_SIZE(models); i++) {
		if (models[i].modelid == modelid) {
			model = &models[i];
			break;
		}
	}
	if (!model) {
		sr_err("Unknown modelid %d", modelid);
		return NULL;
	}

	sdi = g_malloc0(sizeof(struct sr_dev_inst));
	sdi->status = SR_ST_INACTIVE;
	sdi->vendor = g_strdup("Atten");
	sdi->model = g_strdup(model->name);
	sdi->driver = di;
	sdi->inst_type = SR_INST_SERIAL;
	sdi->conn = serial;
	for (i = 0; i < MAX_CHANNELS; i++) {
		snprintf(channel, 10, "CH%d", i + 1);
		ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel);
		cg = g_malloc(sizeof(struct sr_channel_group));
		cg->name = g_strdup(channel);
		cg->channels = g_slist_append(NULL, ch);
		cg->priv = NULL;
		sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
	}

	devc = g_malloc0(sizeof(struct dev_context));
	devc->model = model;
	devc->config = g_malloc0(sizeof(struct per_channel_config) * model->num_channels);
	devc->delay_ms = delay_ms;
	sdi->priv = devc;
	drvc->instances = g_slist_append(drvc->instances, sdi);
	devices = g_slist_append(devices, sdi);

	serial_close(serial);
	if (!devices)
		sr_serial_dev_inst_free(serial);

	return devices;
}

static GSList *scan_3203(struct sr_dev_driver *di, GSList *options)
{
	return scan(di, options, PPS_3203T_3S);
}

static GSList *dev_list(const struct sr_dev_driver *di)
{
	return ((struct drv_context *)(di->context))->instances;
}

static int cleanup(const struct sr_dev_driver *di)
{
	return std_dev_clear(di, NULL);
}

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_channel *ch;
	int channel, ret;

	if (!sdi)
		return SR_ERR_ARG;

	devc = sdi->priv;

	ret = SR_OK;
	if (!cg) {
		/* No channel group: global options. */
		switch (key) {
		case SR_CONF_CHANNEL_CONFIG:
			*data = g_variant_new_string(channel_modes[devc->channel_mode]);
			break;
		case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
			*data = g_variant_new_boolean(devc->over_current_protection);
			break;
		default:
			return SR_ERR_NA;
		}
	} else {
		/* We only ever have one channel per channel group in this driver. */
		ch = cg->channels->data;
		channel = ch->index;

		switch (key) {
		case SR_CONF_VOLTAGE:
			*data = g_variant_new_double(devc->config[channel].output_voltage_last);
			break;
		case SR_CONF_VOLTAGE_TARGET:
			*data = g_variant_new_double(devc->config[channel].output_voltage_max);
			break;
		case SR_CONF_CURRENT:
			*data = g_variant_new_double(devc->config[channel].output_current_last);
			break;
		case SR_CONF_CURRENT_LIMIT:
			*data = g_variant_new_double(devc->config[channel].output_current_max);
			break;
		case SR_CONF_ENABLED:
			*data = g_variant_new_boolean(devc->config[channel].output_enabled);
			break;
		default:
			return SR_ERR_NA;
		}
	}

	return ret;
}

static int find_str(const char *str, const char **strings, int array_size)
{
	int idx, i;

	idx = -1;
	for (i = 0; i < array_size; i++) {
		if (!strcmp(str, strings[i])) {
			idx = i;
			break;
		}
	}

	return idx;
}

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;
	struct sr_channel *ch;
	gdouble dval;
	int channel, ret, ival;
	const char *sval;
	gboolean bval;

	if (sdi->status != SR_ST_ACTIVE)
		return SR_ERR_DEV_CLOSED;

	ret = SR_OK;
	devc = sdi->priv;
	if (!cg) {
		/* No channel group: global options. */
		switch (key) {
		case SR_CONF_CHANNEL_CONFIG:
			sval = g_variant_get_string(data, NULL);
			if ((ival = find_str(sval, channel_modes,
							ARRAY_SIZE(channel_modes))) == -1) {
				ret = SR_ERR_ARG;
				break;
			}
			if (devc->model->channel_modes && (1 << ival) == 0) {
				/* Not supported on this model. */
				ret = SR_ERR_ARG;
			}
			if (ival == devc->channel_mode_set)
				/* Nothing to do. */
				break;
			devc->channel_mode_set = ival;
			devc->config_dirty = TRUE;
			break;
		case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
			bval = g_variant_get_boolean(data);
			if (bval == devc->over_current_protection_set)
				/* Nothing to do. */
				break;
			devc->over_current_protection_set = bval;
			devc->config_dirty = TRUE;
			break;
		default:
			return SR_ERR_NA;
		}
	} else {
		/* Channel group specified: per-channel options. */
		/* We only ever have one channel per channel group in this driver. */
		ch = cg->channels->data;
		channel = ch->index;

		switch (key) {
		case SR_CONF_VOLTAGE_TARGET:
			dval = g_variant_get_double(data);
			if (dval < 0 || dval > devc->model->channels[channel].voltage[1])
				ret = SR_ERR_ARG;
			devc->config[channel].output_voltage_max = dval;
			devc->config_dirty = TRUE;
			break;
		case SR_CONF_CURRENT_LIMIT:
			dval = g_variant_get_double(data);
			if (dval < 0 || dval > devc->model->channels[channel].current[1])
				ret = SR_ERR_ARG;
			devc->config[channel].output_current_max = dval;
			devc->config_dirty = TRUE;
			break;
		case SR_CONF_ENABLED:
			bval = g_variant_get_boolean(data);
			if (bval == devc->config[channel].output_enabled_set)
				/* Nothing to do. */
				break;
			devc->config[channel].output_enabled_set = bval;
			devc->config_dirty = TRUE;
			break;
		default:
			ret = SR_ERR_NA;
		}
	}

	return ret;
}

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;
	struct sr_channel *ch;
	GVariant *gvar;
	GVariantBuilder gvb;
	int channel, ret, i;

	/* Always available. */
	if (key == SR_CONF_SCAN_OPTIONS) {
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
				scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
		return SR_OK;
	}

	if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
				drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
		return SR_OK;
	}

	if (!sdi)
		return SR_ERR_ARG;

	devc = sdi->priv;
	ret = SR_OK;
	if (!cg) {
		/* No channel group: global options. */
		switch (key) {
		case SR_CONF_DEVICE_OPTIONS:
			*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
					devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
			break;
		case SR_CONF_CHANNEL_CONFIG:
			if (devc->model->channel_modes == CHANMODE_INDEPENDENT) {
				/* The 1-channel models. */
				*data = g_variant_new_strv(channel_modes, 1);
			} else {
				/* The other models support all modes. */
				*data = g_variant_new_strv(channel_modes, ARRAY_SIZE(channel_modes));
			}
			break;
		default:
			return SR_ERR_NA;
		}
	} else {
		/* Channel group specified: per-channel options. */
		if (!sdi)
			return SR_ERR_ARG;
		/* We only ever have one channel per channel group in this driver. */
		ch = cg->channels->data;
		channel = ch->index;

		switch (key) {
		case SR_CONF_DEVICE_OPTIONS:
			*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
					devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(uint32_t));
			break;
		case SR_CONF_VOLTAGE_TARGET:
			g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
			/* Min, max, step. */
			for (i = 0; i < 3; i++) {
				gvar = g_variant_new_double(devc->model->channels[channel].voltage[i]);
				g_variant_builder_add_value(&gvb, gvar);
			}
			*data = g_variant_builder_end(&gvb);
			break;
		case SR_CONF_CURRENT_LIMIT:
			g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
			/* Min, max, step. */
			for (i = 0; i < 3; i++) {
				gvar = g_variant_new_double(devc->model->channels[channel].current[i]);
				g_variant_builder_add_value(&gvb, gvar);
			}
			*data = g_variant_builder_end(&gvb);
			break;
		default:
			return SR_ERR_NA;
		}
	}

	return ret;
}

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

	devc = sdi->priv;
	if (devc->config_dirty)
		/* Some configuration changes were queued up but didn't
		 * get sent to the device, likely because we were never
		 * in acquisition mode. Send them out now. */
		send_config(sdi);

	return std_serial_dev_close(sdi);
}

static int dev_acquisition_start(const struct sr_dev_inst *sdi,
		void *cb_data)
{
	struct dev_context *devc;
	struct sr_serial_dev_inst *serial;
	uint8_t packet[PACKET_SIZE];

	(void)cb_data;

	if (sdi->status != SR_ST_ACTIVE)
		return SR_ERR_DEV_CLOSED;

	devc = sdi->priv;
	memset(devc->packet, 0x44, PACKET_SIZE);
	devc->packet_size = 0;

	devc->acquisition_running = TRUE;

	serial = sdi->conn;
	serial_source_add(sdi->session, serial, G_IO_IN, 50,
			atten_pps3xxx_receive_data, (void *)sdi);
	std_session_send_df_header(cb_data, LOG_PREFIX);

	/* Send a "channel" configuration packet now. */
	memset(packet, 0, PACKET_SIZE);
	packet[0] = 0xaa;
	packet[1] = 0xaa;
	send_packet(sdi, packet);

	return SR_OK;
}

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

	(void)cb_data;

	if (sdi->status != SR_ST_ACTIVE)
		return SR_ERR_DEV_CLOSED;

	devc = sdi->priv;
	devc->acquisition_running = FALSE;

	return SR_OK;
}

SR_PRIV struct sr_dev_driver atten_pps3203_driver_info = {
	.name = "atten-pps3203",
	.longname = "Atten PPS3203T-3S",
	.api_version = 1,
	.init = init,
	.cleanup = cleanup,
	.scan = scan_3203,
	.dev_list = dev_list,
	.dev_clear = NULL,
	.config_get = config_get,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = std_serial_dev_open,
	.dev_close = dev_close,
	.dev_acquisition_start = dev_acquisition_start,
	.dev_acquisition_stop = dev_acquisition_stop,
	.context = NULL,
};
Commit	Line	Data
fa0d6afe BV	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2014 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
33c40990	20	#include <string.h>
fa0d6afe BV	21	#include "protocol.h"
fa0d6afe BV	22
33c40990 BV	23	/*
	24	* The default serial communication settings on the device are 9600
	25	* baud, 9 data bits. The 9th bit isn't actually used, and the vendor
	26	* software uses Mark parity to absorb the extra bit.
	27	*
	28	* Since 9 data bits is not a standard available in POSIX, we use two
	29	* stop bits to skip over the extra bit instead.
	30	*/
	31	#define SERIALCOMM "9600/8n2"
	32
584560f1	33	static const uint32_t scanopts[] = {
33c40990 BV	34	SR_CONF_CONN,
	35	SR_CONF_SERIALCOMM,
	36	};
	37
1f889afd	38	static const uint32_t drvopts[] = {
33c40990	39	SR_CONF_POWER_SUPPLY,
d6fa8ace BV	40	};
d6fa8ace BV	41
1f889afd BV	42	static const uint32_t devopts[] = {
1f889afd BV	43	SR_CONF_CONTINUOUS \| SR_CONF_SET,
7a0b98b5	44	SR_CONF_CHANNEL_CONFIG \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
5827f61b	45	SR_CONF_OVER_CURRENT_PROTECTION_ENABLED \| SR_CONF_GET \| SR_CONF_SET,
33c40990 BV	46	};
33c40990 BV	47
584560f1	48	static const uint32_t devopts_cg[] = {
7a0b98b5 AJ	49	SR_CONF_VOLTAGE \| SR_CONF_GET,
	50	SR_CONF_VOLTAGE_TARGET \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	51	SR_CONF_CURRENT \| SR_CONF_GET,
	52	SR_CONF_CURRENT_LIMIT \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	53	SR_CONF_ENABLED \| SR_CONF_GET \| SR_CONF_SET,
33c40990 BV	54	};
	55
	56	static const char *channel_modes[] = {
	57	"Independent",
	58	"Series",
	59	"Parallel",
	60	};
	61
329733d9	62	static const struct pps_model models[] = {
33c40990 BV	63	{ PPS_3203T_3S, "PPS3203T-3S",
	64	CHANMODE_INDEPENDENT \| CHANMODE_SERIES \| CHANMODE_PARALLEL,
	65	3,
	66	{
	67	/* Channel 1 */
	68	{ { 0, 32, 0.01 }, { 0, 3, 0.001 } },
	69	/* Channel 2 */
	70	{ { 0, 32, 0.01 }, { 0, 3, 0.001 } },
	71	/* Channel 3 */
	72	{ { 0, 6, 0.01 }, { 0, 3, 0.001 } },
	73	},
	74	},
	75	};
	76
33c40990	77	SR_PRIV struct sr_dev_driver atten_pps3203_driver_info;
fa0d6afe	78
4f840ce9	79	static int init(struct sr_dev_driver di, struct sr_context sr_ctx)
fa0d6afe BV	80	{
	81	return std_init(sr_ctx, di, LOG_PREFIX);
	82	}
	83
4f840ce9	84	static GSList scan(struct sr_dev_driver di, GSList *options, int modelid)
fa0d6afe	85	{
33c40990	86	struct sr_dev_inst *sdi;
fa0d6afe	87	struct drv_context *drvc;
33c40990 BV	88	struct dev_context *devc;
33c40990 BV	89	struct sr_config *src;
ba7dd8bb	90	struct sr_channel *ch;
40fd0264	91	struct sr_channel_group *cg;
33c40990 BV	92	struct sr_serial_dev_inst *serial;
33c40990 BV	93	GSList l, devices;
329733d9	94	const struct pps_model *model;
33c40990 BV	95	uint8_t packet[PACKET_SIZE];
33c40990 BV	96	unsigned int i;
2eb1612d	97	int delay_ms, ret;
33c40990 BV	98	const char conn, serialcomm;
33c40990 BV	99	char channel[10];
fa0d6afe BV	100
fa0d6afe BV	101	devices = NULL;
41812aca	102	drvc = di->context;
fa0d6afe BV	103	drvc->instances = NULL;
fa0d6afe BV	104
33c40990 BV	105	conn = serialcomm = NULL;
	106	for (l = options; l; l = l->next) {
	107	src = l->data;
	108	switch (src->key) {
	109	case SR_CONF_CONN:
	110	conn = g_variant_get_string(src->data, NULL);
	111	break;
	112	case SR_CONF_SERIALCOMM:
	113	serialcomm = g_variant_get_string(src->data, NULL);
	114	break;
	115	}
	116	}
	117	if (!conn)
	118	return NULL;
	119	if (!serialcomm)
	120	serialcomm = SERIALCOMM;
	121
91219afc	122	serial = sr_serial_dev_inst_new(conn, serialcomm);
33c40990	123
5305266a	124	if (serial_open(serial, SERIAL_RDWR) != SR_OK)
33c40990	125	return NULL;
91219afc	126
33c40990 BV	127	serial_flush(serial);
33c40990 BV	128
945cfd4f	129	/* This is how the vendor software scans for hardware. */
33c40990 BV	130	memset(packet, 0, PACKET_SIZE);
	131	packet[0] = 0xaa;
	132	packet[1] = 0xaa;
2eb1612d BV	133	delay_ms = serial_timeout(serial, PACKET_SIZE);
2eb1612d BV	134	if (serial_write_blocking(serial, packet, PACKET_SIZE, delay_ms) < PACKET_SIZE) {
081c214e	135	sr_err("Unable to write while probing for hardware.");
33c40990 BV	136	return NULL;
	137	}
	138	/* The device responds with a 24-byte packet when it receives a packet.
	139	* At 9600 baud, 300ms is long enough for it to have arrived. */
	140	g_usleep(300 * 1000);
	141	memset(packet, 0, PACKET_SIZE);
	142	if ((ret = serial_read_nonblocking(serial, packet, PACKET_SIZE)) < 0) {
	143	sr_err("Unable to read while probing for hardware: %s",
8d522801	144	sr_strerror(ret));
33c40990 BV	145	return NULL;
	146	}
	147	if (ret != PACKET_SIZE \|\| packet[0] != 0xaa \|\| packet[1] != 0xaa) {
	148	/* Doesn't look like an Atten PPS. */
	149	return NULL;
	150	}
	151
	152	model = NULL;
	153	for (i = 0; i < ARRAY_SIZE(models); i++) {
	154	if (models[i].modelid == modelid) {
	155	model = &models[i];
	156	break;
	157	}
	158	}
	159	if (!model) {
	160	sr_err("Unknown modelid %d", modelid);
	161	return NULL;
	162	}
	163
aac29cc1	164	sdi = g_malloc0(sizeof(struct sr_dev_inst));
0af636be UH	165	sdi->status = SR_ST_INACTIVE;
	166	sdi->vendor = g_strdup("Atten");
	167	sdi->model = g_strdup(model->name);
33c40990 BV	168	sdi->driver = di;
	169	sdi->inst_type = SR_INST_SERIAL;
	170	sdi->conn = serial;
	171	for (i = 0; i < MAX_CHANNELS; i++) {
	172	snprintf(channel, 10, "CH%d", i + 1);
5e23fcab	173	ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel);
40fd0264 UH	174	cg = g_malloc(sizeof(struct sr_channel_group));
40fd0264 UH	175	cg->name = g_strdup(channel);
ba7dd8bb	176	cg->channels = g_slist_append(NULL, ch);
40fd0264 UH	177	cg->priv = NULL;
40fd0264 UH	178	sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
33c40990 BV	179	}
	180
	181	devc = g_malloc0(sizeof(struct dev_context));
	182	devc->model = model;
	183	devc->config = g_malloc0(sizeof(struct per_channel_config) * model->num_channels);
2eb1612d	184	devc->delay_ms = delay_ms;
33c40990 BV	185	sdi->priv = devc;
	186	drvc->instances = g_slist_append(drvc->instances, sdi);
	187	devices = g_slist_append(devices, sdi);
	188
	189	serial_close(serial);
	190	if (!devices)
	191	sr_serial_dev_inst_free(serial);
fa0d6afe BV	192
	193	return devices;
	194	}
	195
4f840ce9	196	static GSList scan_3203(struct sr_dev_driver di, GSList *options)
33c40990	197	{
4f840ce9	198	return scan(di, options, PPS_3203T_3S);
33c40990 BV	199	}
33c40990 BV	200
4f840ce9	201	static GSList dev_list(const struct sr_dev_driver di)
fa0d6afe	202	{
41812aca	203	return ((struct drv_context *)(di->context))->instances;
fa0d6afe BV	204	}
fa0d6afe BV	205
4f840ce9	206	static int cleanup(const struct sr_dev_driver *di)
fa0d6afe	207	{
a6630742	208	return std_dev_clear(di, NULL);
fa0d6afe BV	209	}
fa0d6afe BV	210
584560f1	211	static int config_get(uint32_t key, GVariant *data, const struct sr_dev_inst sdi,
53b4680f	212	const struct sr_channel_group *cg)
fa0d6afe	213	{
33c40990	214	struct dev_context *devc;
ba7dd8bb	215	struct sr_channel *ch;
33c40990 BV	216	int channel, ret;
	217
	218	if (!sdi)
	219	return SR_ERR_ARG;
fa0d6afe	220
33c40990	221	devc = sdi->priv;
fa0d6afe BV	222
fa0d6afe BV	223	ret = SR_OK;
53b4680f	224	if (!cg) {
660e398f	225	/* No channel group: global options. */
33c40990	226	switch (key) {
7a0b98b5	227	case SR_CONF_CHANNEL_CONFIG:
fe997353	228	*data = g_variant_new_string(channel_modes[devc->channel_mode]);
33c40990	229	break;
a1eaa9e0	230	case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
33c40990 BV	231	*data = g_variant_new_boolean(devc->over_current_protection);
	232	break;
	233	default:
	234	return SR_ERR_NA;
	235	}
	236	} else {
660e398f	237	/* We only ever have one channel per channel group in this driver. */
ba7dd8bb UH	238	ch = cg->channels->data;
ba7dd8bb UH	239	channel = ch->index;
33c40990 BV	240
33c40990 BV	241	switch (key) {
7a0b98b5	242	case SR_CONF_VOLTAGE:
33c40990 BV	243	*data = g_variant_new_double(devc->config[channel].output_voltage_last);
33c40990 BV	244	break;
7a0b98b5	245	case SR_CONF_VOLTAGE_TARGET:
33c40990 BV	246	*data = g_variant_new_double(devc->config[channel].output_voltage_max);
33c40990 BV	247	break;
7a0b98b5	248	case SR_CONF_CURRENT:
33c40990 BV	249	*data = g_variant_new_double(devc->config[channel].output_current_last);
33c40990 BV	250	break;
7a0b98b5	251	case SR_CONF_CURRENT_LIMIT:
33c40990 BV	252	*data = g_variant_new_double(devc->config[channel].output_current_max);
33c40990 BV	253	break;
7a0b98b5	254	case SR_CONF_ENABLED:
33c40990 BV	255	*data = g_variant_new_boolean(devc->config[channel].output_enabled);
	256	break;
	257	default:
	258	return SR_ERR_NA;
	259	}
fa0d6afe BV	260	}
	261
	262	return ret;
	263	}
	264
33c40990 BV	265	static int find_str(const char str, const char *strings, int array_size)
	266	{
	267	int idx, i;
	268
	269	idx = -1;
	270	for (i = 0; i < array_size; i++) {
	271	if (!strcmp(str, strings[i])) {
	272	idx = i;
	273	break;
	274	}
	275	}
	276
	277	return idx;
	278	}
	279
584560f1	280	static int config_set(uint32_t key, GVariant data, const struct sr_dev_inst sdi,
53b4680f	281	const struct sr_channel_group *cg)
fa0d6afe	282	{
33c40990	283	struct dev_context *devc;
ba7dd8bb	284	struct sr_channel *ch;
33c40990 BV	285	gdouble dval;
	286	int channel, ret, ival;
	287	const char *sval;
	288	gboolean bval;
fa0d6afe BV	289
	290	if (sdi->status != SR_ST_ACTIVE)
	291	return SR_ERR_DEV_CLOSED;
	292
	293	ret = SR_OK;
33c40990	294	devc = sdi->priv;
53b4680f	295	if (!cg) {
660e398f	296	/* No channel group: global options. */
33c40990	297	switch (key) {
7a0b98b5	298	case SR_CONF_CHANNEL_CONFIG:
33c40990 BV	299	sval = g_variant_get_string(data, NULL);
	300	if ((ival = find_str(sval, channel_modes,
	301	ARRAY_SIZE(channel_modes))) == -1) {
	302	ret = SR_ERR_ARG;
	303	break;
	304	}
	305	if (devc->model->channel_modes && (1 << ival) == 0) {
	306	/* Not supported on this model. */
	307	ret = SR_ERR_ARG;
	308	}
	309	if (ival == devc->channel_mode_set)
	310	/* Nothing to do. */
	311	break;
	312	devc->channel_mode_set = ival;
ab988ecb	313	devc->config_dirty = TRUE;
33c40990	314	break;
a1eaa9e0	315	case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
33c40990 BV	316	bval = g_variant_get_boolean(data);
	317	if (bval == devc->over_current_protection_set)
	318	/* Nothing to do. */
	319	break;
	320	devc->over_current_protection_set = bval;
ab988ecb	321	devc->config_dirty = TRUE;
33c40990 BV	322	break;
	323	default:
	324	return SR_ERR_NA;
	325	}
	326	} else {
660e398f UH	327	/* Channel group specified: per-channel options. */
660e398f UH	328	/* We only ever have one channel per channel group in this driver. */
ba7dd8bb UH	329	ch = cg->channels->data;
ba7dd8bb UH	330	channel = ch->index;
33c40990 BV	331
33c40990 BV	332	switch (key) {
7a0b98b5	333	case SR_CONF_VOLTAGE_TARGET:
33c40990 BV	334	dval = g_variant_get_double(data);
	335	if (dval < 0 \|\| dval > devc->model->channels[channel].voltage[1])
	336	ret = SR_ERR_ARG;
	337	devc->config[channel].output_voltage_max = dval;
ab988ecb	338	devc->config_dirty = TRUE;
33c40990	339	break;
7a0b98b5	340	case SR_CONF_CURRENT_LIMIT:
33c40990 BV	341	dval = g_variant_get_double(data);
	342	if (dval < 0 \|\| dval > devc->model->channels[channel].current[1])
	343	ret = SR_ERR_ARG;
	344	devc->config[channel].output_current_max = dval;
ab988ecb	345	devc->config_dirty = TRUE;
33c40990	346	break;
7a0b98b5	347	case SR_CONF_ENABLED:
33c40990 BV	348	bval = g_variant_get_boolean(data);
	349	if (bval == devc->config[channel].output_enabled_set)
	350	/* Nothing to do. */
	351	break;
	352	devc->config[channel].output_enabled_set = bval;
ab988ecb	353	devc->config_dirty = TRUE;
33c40990 BV	354	break;
	355	default:
	356	ret = SR_ERR_NA;
	357	}
fa0d6afe BV	358	}
	359
	360	return ret;
	361	}
	362
584560f1	363	static int config_list(uint32_t key, GVariant *data, const struct sr_dev_inst sdi,
53b4680f	364	const struct sr_channel_group *cg)
fa0d6afe	365	{
33c40990	366	struct dev_context *devc;
ba7dd8bb	367	struct sr_channel *ch;
33c40990 BV	368	GVariant *gvar;
	369	GVariantBuilder gvb;
	370	int channel, ret, i;
	371
d6fa8ace	372	/* Always available. */
33c40990	373	if (key == SR_CONF_SCAN_OPTIONS) {
584560f1 BV	374	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
584560f1 BV	375	scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
33c40990 BV	376	return SR_OK;
	377	}
	378
d6fa8ace BV	379	if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
d6fa8ace BV	380	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
1f889afd	381	drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
d6fa8ace BV	382	return SR_OK;
	383	}
	384
e22aa878 BV	385	if (!sdi)
e22aa878 BV	386	return SR_ERR_ARG;
fa0d6afe	387
d6fa8ace	388	devc = sdi->priv;
fa0d6afe	389	ret = SR_OK;
53b4680f	390	if (!cg) {
660e398f	391	/* No channel group: global options. */
33c40990 BV	392	switch (key) {
33c40990 BV	393	case SR_CONF_DEVICE_OPTIONS:
584560f1	394	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
1f889afd	395	devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
33c40990	396	break;
7a0b98b5	397	case SR_CONF_CHANNEL_CONFIG:
33c40990 BV	398	if (devc->model->channel_modes == CHANMODE_INDEPENDENT) {
	399	/* The 1-channel models. */
	400	*data = g_variant_new_strv(channel_modes, 1);
	401	} else {
	402	/* The other models support all modes. */
	403	*data = g_variant_new_strv(channel_modes, ARRAY_SIZE(channel_modes));
	404	}
	405	break;
	406	default:
	407	return SR_ERR_NA;
	408	}
	409	} else {
660e398f	410	/* Channel group specified: per-channel options. */
33c40990 BV	411	if (!sdi)
33c40990 BV	412	return SR_ERR_ARG;
660e398f	413	/* We only ever have one channel per channel group in this driver. */
ba7dd8bb UH	414	ch = cg->channels->data;
ba7dd8bb UH	415	channel = ch->index;
33c40990 BV	416
	417	switch (key) {
	418	case SR_CONF_DEVICE_OPTIONS:
584560f1 BV	419	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
584560f1 BV	420	devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(uint32_t));
33c40990	421	break;
7a0b98b5	422	case SR_CONF_VOLTAGE_TARGET:
33c40990 BV	423	g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
	424	/* Min, max, step. */
	425	for (i = 0; i < 3; i++) {
	426	gvar = g_variant_new_double(devc->model->channels[channel].voltage[i]);
	427	g_variant_builder_add_value(&gvb, gvar);
	428	}
	429	*data = g_variant_builder_end(&gvb);
	430	break;
7a0b98b5	431	case SR_CONF_CURRENT_LIMIT:
33c40990 BV	432	g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
	433	/* Min, max, step. */
	434	for (i = 0; i < 3; i++) {
	435	gvar = g_variant_new_double(devc->model->channels[channel].current[i]);
	436	g_variant_builder_add_value(&gvb, gvar);
	437	}
	438	*data = g_variant_builder_end(&gvb);
	439	break;
	440	default:
	441	return SR_ERR_NA;
	442	}
fa0d6afe BV	443	}
	444
	445	return ret;
	446	}
	447
ab988ecb BV	448	static int dev_close(struct sr_dev_inst *sdi)
	449	{
	450	struct dev_context *devc;
	451
	452	devc = sdi->priv;
	453	if (devc->config_dirty)
	454	/* Some configuration changes were queued up but didn't
	455	* get sent to the device, likely because we were never
	456	* in acquisition mode. Send them out now. */
	457	send_config(sdi);
	458
	459	return std_serial_dev_close(sdi);
	460	}
	461
fa0d6afe	462	static int dev_acquisition_start(const struct sr_dev_inst *sdi,
33c40990	463	void *cb_data)
fa0d6afe	464	{
33c40990 BV	465	struct dev_context *devc;
	466	struct sr_serial_dev_inst *serial;
	467	uint8_t packet[PACKET_SIZE];
	468
fa0d6afe BV	469	(void)cb_data;
	470
	471	if (sdi->status != SR_ST_ACTIVE)
	472	return SR_ERR_DEV_CLOSED;
	473
33c40990 BV	474	devc = sdi->priv;
	475	memset(devc->packet, 0x44, PACKET_SIZE);
	476	devc->packet_size = 0;
	477
	478	devc->acquisition_running = TRUE;
	479
	480	serial = sdi->conn;
102f1239 BV	481	serial_source_add(sdi->session, serial, G_IO_IN, 50,
102f1239 BV	482	atten_pps3xxx_receive_data, (void *)sdi);
33c40990 BV	483	std_session_send_df_header(cb_data, LOG_PREFIX);
33c40990 BV	484
ba7dd8bb	485	/* Send a "channel" configuration packet now. */
33c40990 BV	486	memset(packet, 0, PACKET_SIZE);
	487	packet[0] = 0xaa;
	488	packet[1] = 0xaa;
	489	send_packet(sdi, packet);
fa0d6afe BV	490
	491	return SR_OK;
	492	}
	493
	494	static int dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
	495	{
33c40990 BV	496	struct dev_context *devc;
33c40990 BV	497
fa0d6afe BV	498	(void)cb_data;
	499
	500	if (sdi->status != SR_ST_ACTIVE)
	501	return SR_ERR_DEV_CLOSED;
	502
33c40990 BV	503	devc = sdi->priv;
33c40990 BV	504	devc->acquisition_running = FALSE;
fa0d6afe BV	505
	506	return SR_OK;
	507	}
	508
33c40990 BV	509	SR_PRIV struct sr_dev_driver atten_pps3203_driver_info = {
	510	.name = "atten-pps3203",
	511	.longname = "Atten PPS3203T-3S",
fa0d6afe BV	512	.api_version = 1,
	513	.init = init,
	514	.cleanup = cleanup,
33c40990	515	.scan = scan_3203,
fa0d6afe	516	.dev_list = dev_list,
a6630742	517	.dev_clear = NULL,
fa0d6afe BV	518	.config_get = config_get,
	519	.config_set = config_set,
	520	.config_list = config_list,
33c40990	521	.dev_open = std_serial_dev_open,
ab988ecb	522	.dev_close = dev_close,
fa0d6afe BV	523	.dev_acquisition_start = dev_acquisition_start,
fa0d6afe BV	524	.dev_acquisition_stop = dev_acquisition_stop,
41812aca	525	.context = NULL,
fa0d6afe	526	};