[libsigrok.git] / src / scpi / scpi_tcp.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2013 Martin Ling <martin-sigrok@earth.li>
 *
 * 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 "config.h"

#include <errno.h>
#include <glib.h>
#include <libsigrok/libsigrok.h>
#include <string.h>

#include "libsigrok-internal.h"
#include "scpi.h"

#define LOG_PREFIX "scpi_tcp"

#define LENGTH_BYTES sizeof(uint32_t)

struct scpi_tcp {
	struct sr_tcp_dev_inst *tcp_dev;
	uint8_t length_buf[LENGTH_BYTES];
	size_t length_bytes_read;
	size_t response_length;
	size_t response_bytes_read;
};

static int scpi_tcp_dev_inst_new(void *priv, struct drv_context *drvc,
		const char *resource, char **params, const char *serialcomm)
{
	struct scpi_tcp *tcp = priv;

	(void)drvc;
	(void)resource;
	(void)serialcomm;

	if (!params || !params[1] || !params[2]) {
		sr_err("Invalid parameters.");
		return SR_ERR;
	}

	tcp->tcp_dev = sr_tcp_dev_inst_new(params[1], params[2]);
	if (!tcp->tcp_dev)
		return SR_ERR;

	return SR_OK;
}

static int scpi_tcp_open(struct sr_scpi_dev_inst *scpi)
{
	struct scpi_tcp *tcp = scpi->priv;
	int ret;

	ret = sr_tcp_connect(tcp->tcp_dev);
	if (ret != SR_OK)
		return ret;

	return SR_OK;
}

static int scpi_tcp_connection_id(struct sr_scpi_dev_inst *scpi,
		char **connection_id)
{
	struct scpi_tcp *tcp = scpi->priv;
	char conn_text[128];
	int ret;

	ret = sr_tcp_get_port_path(tcp->tcp_dev, scpi->prefix, '/',
		conn_text, sizeof(conn_text));
	if (ret != SR_OK)
		return ret;

	*connection_id = g_strdup(conn_text);
	return SR_OK;
}

static int scpi_tcp_source_add(struct sr_session *session, void *priv,
		int events, int timeout, sr_receive_data_callback cb, void *cb_data)
{
	struct scpi_tcp *tcp = priv;

	return sr_tcp_source_add(session, tcp->tcp_dev,
		events, timeout, cb, cb_data);
}

static int scpi_tcp_source_remove(struct sr_session *session, void *priv)
{
	struct scpi_tcp *tcp = priv;

	return sr_tcp_source_remove(session, tcp->tcp_dev);
}

/* Transmit text, usually a command. tcp-raw and tcp-rigol modes. */
static int scpi_tcp_send(void *priv, const char *command)
{
	struct scpi_tcp *tcp = priv;
	const uint8_t *wrptr;
	size_t wrlen, written;
	int ret;

	wrptr = (const uint8_t *)command;
	wrlen = strlen(command);
	ret = sr_tcp_write_bytes(tcp->tcp_dev, wrptr, wrlen);
	if (ret < 0) {
		sr_err("Send error: %s", g_strerror(errno));
		return SR_ERR;
	}
	written = (size_t)ret;
	if (written < wrlen) {
		sr_dbg("Only sent %zu/%zu bytes of SCPI command: '%s'.",
			written, wrlen, command);
	}

	sr_spew("Successfully sent SCPI command: '%s'.", command);

	return SR_OK;
}

/* Start reception across multiple read calls. tcp-raw and tcp-rigol modes. */
static int scpi_tcp_read_begin(void *priv)
{
	struct scpi_tcp *tcp = priv;

	tcp->response_bytes_read = 0;
	tcp->length_bytes_read = 0;

	return SR_OK;
}

/* Receive response data. tcp-raw mode. */
static int scpi_tcp_raw_read_data(void *priv, char *buf, int maxlen)
{
	struct scpi_tcp *tcp = priv;
	uint8_t *rdptr;
	size_t rdlen, rcvd;
	int ret;

	/* Get another chunk of receive data. */
	rdptr = (uint8_t *)buf;
	rdlen = maxlen;
	ret = sr_tcp_read_bytes(tcp->tcp_dev, rdptr, rdlen, FALSE);
	if (ret < 0) {
		sr_err("Receive error: %s", g_strerror(errno));
		return SR_ERR;
	}
	rcvd = (size_t)ret;

	/*
	 * Raw data mode (in contrast to Rigol mode). Prepare to answer
	 * the "completed" condition while the payload's length is not
	 * known. Pretend that the length buffer had been received.
	 * Assume that short reads correspond to the end of a response,
	 * while full reads of the caller specified size suggest that
	 * more data can follow.
	 */
	tcp->length_bytes_read = LENGTH_BYTES;
	tcp->response_length = rcvd < rdlen ? rcvd : rdlen + 1;
	tcp->response_bytes_read = rcvd;

	return rcvd;
}

/* Transmit data of given length. tcp-raw mode. */
static int scpi_tcp_raw_write_data(void *priv, char *buf, int len)
{
	struct scpi_tcp *tcp = priv;
	const uint8_t *wrptr;
	size_t wrlen, sent;
	int ret;

	wrptr = (const uint8_t *)buf;
	wrlen = len;
	ret = sr_tcp_write_bytes(tcp->tcp_dev, wrptr, wrlen);
	if (ret < 0) {
		sr_err("Send error: %s.", g_strerror(errno));
		return SR_ERR;
	}
	sent = (size_t)ret;

	return sent;
}

/* Receive response data. tcp-rigol mode. */
static int scpi_tcp_rigol_read_data(void *priv, char *buf, int maxlen)
{
	struct scpi_tcp *tcp = priv;
	uint8_t *rdptr;
	size_t rdlen, rcvd;
	int ret;

	/*
	 * Rigol mode, chunks are prefixed by a length spec.
	 * Get more length bytes when we haven't read them before.
	 * Return "zero length read" if length has yet to get received.
	 * Otherwise get chunk length from length bytes buffer.
	 */
	if (tcp->length_bytes_read < sizeof(tcp->length_buf)) {
		rdptr = &tcp->length_buf[tcp->length_bytes_read];
		rdlen = sizeof(tcp->length_buf) - tcp->length_bytes_read;
		ret = sr_tcp_read_bytes(tcp->tcp_dev, rdptr, rdlen, FALSE);
		if (ret < 0) {
			sr_err("Receive error: %s", g_strerror(errno));
			return SR_ERR;
		}
		rcvd = (size_t)ret;
		tcp->length_bytes_read += rcvd;
		if (tcp->length_bytes_read < sizeof(tcp->length_buf))
			return 0;
		tcp->response_length = read_u32le(tcp->length_buf);
	}

	/* Received more chunk data than announced size? Fatal. */
	if (tcp->response_bytes_read >= tcp->response_length)
		return SR_ERR;

	/* Read another chunk of the receive data. */
	rdptr = (uint8_t *)buf;
	rdlen = maxlen;
	ret = sr_tcp_read_bytes(tcp->tcp_dev, rdptr, rdlen, FALSE);
	if (ret < 0) {
		sr_err("Receive error: %s", g_strerror(errno));
		return SR_ERR;
	}
	rcvd = (size_t)ret;
	tcp->response_bytes_read += rcvd;

	return rcvd;
}

/* Check reception completion. tcp-raw and tcp-rigol modes. */
static int scpi_tcp_read_complete(void *priv)
{
	struct scpi_tcp *tcp = priv;
	gboolean have_length, have_response;

	have_length = tcp->length_bytes_read == LENGTH_BYTES;
	have_response = tcp->response_bytes_read >= tcp->response_length;

	return have_length && have_response;
}

static int scpi_tcp_close(struct sr_scpi_dev_inst *scpi)
{
	struct scpi_tcp *tcp = scpi->priv;
	int ret;

	ret = sr_tcp_disconnect(tcp->tcp_dev);
	if (ret != SR_OK)
		return ret;

	return SR_OK;
}

static void scpi_tcp_free(void *priv)
{
	struct scpi_tcp *tcp = priv;

	sr_tcp_dev_inst_free(tcp->tcp_dev);
}

SR_PRIV const struct sr_scpi_dev_inst scpi_tcp_raw_dev = {
	.name          = "RAW TCP",
	.prefix        = "tcp-raw",
	.transport     = SCPI_TRANSPORT_RAW_TCP,
	.priv_size     = sizeof(struct scpi_tcp),
	.dev_inst_new  = scpi_tcp_dev_inst_new,
	.open          = scpi_tcp_open,
	.connection_id = scpi_tcp_connection_id,
	.source_add    = scpi_tcp_source_add,
	.source_remove = scpi_tcp_source_remove,
	.send          = scpi_tcp_send,
	.read_begin    = scpi_tcp_read_begin,
	.read_data     = scpi_tcp_raw_read_data,
	.write_data    = scpi_tcp_raw_write_data,
	.read_complete = scpi_tcp_read_complete,
	.close         = scpi_tcp_close,
	.free          = scpi_tcp_free,
};

SR_PRIV const struct sr_scpi_dev_inst scpi_tcp_rigol_dev = {
	.name          = "RIGOL TCP",
	.prefix        = "tcp-rigol",
	.transport     = SCPI_TRANSPORT_RIGOL_TCP,
	.priv_size     = sizeof(struct scpi_tcp),
	.dev_inst_new  = scpi_tcp_dev_inst_new,
	.open          = scpi_tcp_open,
	.connection_id = scpi_tcp_connection_id,
	.source_add    = scpi_tcp_source_add,
	.source_remove = scpi_tcp_source_remove,
	.send          = scpi_tcp_send,
	.read_begin    = scpi_tcp_read_begin,
	.read_data     = scpi_tcp_rigol_read_data,
	.read_complete = scpi_tcp_read_complete,
	.close         = scpi_tcp_close,
	.free          = scpi_tcp_free,
};
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2013 Martin Ling <martin-sigrok@earth.li>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include "config.h"
	21
	22	#include <errno.h>
	23	#include <glib.h>
	24	#include <libsigrok/libsigrok.h>
	25	#include <string.h>
	26
	27	#include "libsigrok-internal.h"
	28	#include "scpi.h"
	29
	30	#define LOG_PREFIX "scpi_tcp"
	31
	32	#define LENGTH_BYTES sizeof(uint32_t)
	33
	34	struct scpi_tcp {
	35	struct sr_tcp_dev_inst *tcp_dev;
	36	uint8_t length_buf[LENGTH_BYTES];
	37	size_t length_bytes_read;
	38	size_t response_length;
	39	size_t response_bytes_read;
	40	};
	41
	42	static int scpi_tcp_dev_inst_new(void priv, struct drv_context drvc,
	43	const char resource, char params, const char serialcomm)
	44	{
	45	struct scpi_tcp *tcp = priv;
	46
	47	(void)drvc;
	48	(void)resource;
	49	(void)serialcomm;
	50
	51	if (!params \|\| !params[1] \|\| !params[2]) {
	52	sr_err("Invalid parameters.");
	53	return SR_ERR;
	54	}
	55
	56	tcp->tcp_dev = sr_tcp_dev_inst_new(params[1], params[2]);
	57	if (!tcp->tcp_dev)
	58	return SR_ERR;
	59
	60	return SR_OK;
	61	}
	62
	63	static int scpi_tcp_open(struct sr_scpi_dev_inst *scpi)
	64	{
	65	struct scpi_tcp *tcp = scpi->priv;
	66	int ret;
	67
	68	ret = sr_tcp_connect(tcp->tcp_dev);
	69	if (ret != SR_OK)
	70	return ret;
	71
	72	return SR_OK;
	73	}
	74
	75	static int scpi_tcp_connection_id(struct sr_scpi_dev_inst *scpi,
	76	char **connection_id)
	77	{
	78	struct scpi_tcp *tcp = scpi->priv;
	79	char conn_text[128];
	80	int ret;
	81
	82	ret = sr_tcp_get_port_path(tcp->tcp_dev, scpi->prefix, '/',
	83	conn_text, sizeof(conn_text));
	84	if (ret != SR_OK)
	85	return ret;
	86
	87	*connection_id = g_strdup(conn_text);
	88	return SR_OK;
	89	}
	90
	91	static int scpi_tcp_source_add(struct sr_session session, void priv,
	92	int events, int timeout, sr_receive_data_callback cb, void *cb_data)
	93	{
	94	struct scpi_tcp *tcp = priv;
	95
	96	return sr_tcp_source_add(session, tcp->tcp_dev,
	97	events, timeout, cb, cb_data);
	98	}
	99
	100	static int scpi_tcp_source_remove(struct sr_session session, void priv)
	101	{
	102	struct scpi_tcp *tcp = priv;
	103
	104	return sr_tcp_source_remove(session, tcp->tcp_dev);
	105	}
	106
	107	/* Transmit text, usually a command. tcp-raw and tcp-rigol modes. */
	108	static int scpi_tcp_send(void priv, const char command)
	109	{
	110	struct scpi_tcp *tcp = priv;
	111	const uint8_t *wrptr;
	112	size_t wrlen, written;
	113	int ret;
	114
	115	wrptr = (const uint8_t *)command;
	116	wrlen = strlen(command);
	117	ret = sr_tcp_write_bytes(tcp->tcp_dev, wrptr, wrlen);
	118	if (ret < 0) {
	119	sr_err("Send error: %s", g_strerror(errno));
	120	return SR_ERR;
	121	}
	122	written = (size_t)ret;
	123	if (written < wrlen) {
	124	sr_dbg("Only sent %zu/%zu bytes of SCPI command: '%s'.",
	125	written, wrlen, command);
	126	}
	127
	128	sr_spew("Successfully sent SCPI command: '%s'.", command);
	129
	130	return SR_OK;
	131	}
	132
	133	/* Start reception across multiple read calls. tcp-raw and tcp-rigol modes. */
	134	static int scpi_tcp_read_begin(void *priv)
	135	{
	136	struct scpi_tcp *tcp = priv;
	137
	138	tcp->response_bytes_read = 0;
	139	tcp->length_bytes_read = 0;
	140
	141	return SR_OK;
	142	}
	143
	144	/* Receive response data. tcp-raw mode. */
	145	static int scpi_tcp_raw_read_data(void priv, char buf, int maxlen)
	146	{
	147	struct scpi_tcp *tcp = priv;
	148	uint8_t *rdptr;
	149	size_t rdlen, rcvd;
	150	int ret;
	151
	152	/* Get another chunk of receive data. */
	153	rdptr = (uint8_t *)buf;
	154	rdlen = maxlen;
	155	ret = sr_tcp_read_bytes(tcp->tcp_dev, rdptr, rdlen, FALSE);
	156	if (ret < 0) {
	157	sr_err("Receive error: %s", g_strerror(errno));
	158	return SR_ERR;
	159	}
	160	rcvd = (size_t)ret;
	161
	162	/*
	163	* Raw data mode (in contrast to Rigol mode). Prepare to answer
	164	* the "completed" condition while the payload's length is not
	165	* known. Pretend that the length buffer had been received.
	166	* Assume that short reads correspond to the end of a response,
	167	* while full reads of the caller specified size suggest that
	168	* more data can follow.
	169	*/
	170	tcp->length_bytes_read = LENGTH_BYTES;
	171	tcp->response_length = rcvd < rdlen ? rcvd : rdlen + 1;
	172	tcp->response_bytes_read = rcvd;
	173
	174	return rcvd;
	175	}
	176
	177	/* Transmit data of given length. tcp-raw mode. */
	178	static int scpi_tcp_raw_write_data(void priv, char buf, int len)
	179	{
	180	struct scpi_tcp *tcp = priv;
	181	const uint8_t *wrptr;
	182	size_t wrlen, sent;
	183	int ret;
	184
	185	wrptr = (const uint8_t *)buf;
	186	wrlen = len;
	187	ret = sr_tcp_write_bytes(tcp->tcp_dev, wrptr, wrlen);
	188	if (ret < 0) {
	189	sr_err("Send error: %s.", g_strerror(errno));
	190	return SR_ERR;
	191	}
	192	sent = (size_t)ret;
	193
	194	return sent;
	195	}
	196
	197	/* Receive response data. tcp-rigol mode. */
	198	static int scpi_tcp_rigol_read_data(void priv, char buf, int maxlen)
	199	{
	200	struct scpi_tcp *tcp = priv;
	201	uint8_t *rdptr;
	202	size_t rdlen, rcvd;
	203	int ret;
	204
	205	/*
	206	* Rigol mode, chunks are prefixed by a length spec.
	207	* Get more length bytes when we haven't read them before.
	208	* Return "zero length read" if length has yet to get received.
	209	* Otherwise get chunk length from length bytes buffer.
	210	*/
	211	if (tcp->length_bytes_read < sizeof(tcp->length_buf)) {
	212	rdptr = &tcp->length_buf[tcp->length_bytes_read];
	213	rdlen = sizeof(tcp->length_buf) - tcp->length_bytes_read;
	214	ret = sr_tcp_read_bytes(tcp->tcp_dev, rdptr, rdlen, FALSE);
	215	if (ret < 0) {
	216	sr_err("Receive error: %s", g_strerror(errno));
	217	return SR_ERR;
	218	}
	219	rcvd = (size_t)ret;
	220	tcp->length_bytes_read += rcvd;
	221	if (tcp->length_bytes_read < sizeof(tcp->length_buf))
	222	return 0;
	223	tcp->response_length = read_u32le(tcp->length_buf);
	224	}
	225
	226	/* Received more chunk data than announced size? Fatal. */
	227	if (tcp->response_bytes_read >= tcp->response_length)
	228	return SR_ERR;
	229
	230	/* Read another chunk of the receive data. */
	231	rdptr = (uint8_t *)buf;
	232	rdlen = maxlen;
	233	ret = sr_tcp_read_bytes(tcp->tcp_dev, rdptr, rdlen, FALSE);
	234	if (ret < 0) {
	235	sr_err("Receive error: %s", g_strerror(errno));
	236	return SR_ERR;
	237	}
	238	rcvd = (size_t)ret;
	239	tcp->response_bytes_read += rcvd;
	240
	241	return rcvd;
	242	}
	243
	244	/* Check reception completion. tcp-raw and tcp-rigol modes. */
	245	static int scpi_tcp_read_complete(void *priv)
	246	{
	247	struct scpi_tcp *tcp = priv;
	248	gboolean have_length, have_response;
	249
	250	have_length = tcp->length_bytes_read == LENGTH_BYTES;
	251	have_response = tcp->response_bytes_read >= tcp->response_length;
	252
	253	return have_length && have_response;
	254	}
	255
	256	static int scpi_tcp_close(struct sr_scpi_dev_inst *scpi)
	257	{
	258	struct scpi_tcp *tcp = scpi->priv;
	259	int ret;
	260
	261	ret = sr_tcp_disconnect(tcp->tcp_dev);
	262	if (ret != SR_OK)
	263	return ret;
	264
	265	return SR_OK;
	266	}
	267
	268	static void scpi_tcp_free(void *priv)
	269	{
	270	struct scpi_tcp *tcp = priv;
	271
	272	sr_tcp_dev_inst_free(tcp->tcp_dev);
	273	}
	274
	275	SR_PRIV const struct sr_scpi_dev_inst scpi_tcp_raw_dev = {
	276	.name = "RAW TCP",
	277	.prefix = "tcp-raw",
	278	.transport = SCPI_TRANSPORT_RAW_TCP,
	279	.priv_size = sizeof(struct scpi_tcp),
	280	.dev_inst_new = scpi_tcp_dev_inst_new,
	281	.open = scpi_tcp_open,
	282	.connection_id = scpi_tcp_connection_id,
	283	.source_add = scpi_tcp_source_add,
	284	.source_remove = scpi_tcp_source_remove,
	285	.send = scpi_tcp_send,
	286	.read_begin = scpi_tcp_read_begin,
	287	.read_data = scpi_tcp_raw_read_data,
	288	.write_data = scpi_tcp_raw_write_data,
	289	.read_complete = scpi_tcp_read_complete,
	290	.close = scpi_tcp_close,
	291	.free = scpi_tcp_free,
	292	};
	293
	294	SR_PRIV const struct sr_scpi_dev_inst scpi_tcp_rigol_dev = {
	295	.name = "RIGOL TCP",
	296	.prefix = "tcp-rigol",
	297	.transport = SCPI_TRANSPORT_RIGOL_TCP,
	298	.priv_size = sizeof(struct scpi_tcp),
	299	.dev_inst_new = scpi_tcp_dev_inst_new,
	300	.open = scpi_tcp_open,
	301	.connection_id = scpi_tcp_connection_id,
	302	.source_add = scpi_tcp_source_add,
	303	.source_remove = scpi_tcp_source_remove,
	304	.send = scpi_tcp_send,
	305	.read_begin = scpi_tcp_read_begin,
	306	.read_data = scpi_tcp_rigol_read_data,
	307	.read_complete = scpi_tcp_read_complete,
	308	.close = scpi_tcp_close,
	309	.free = scpi_tcp_free,
	310	};