[rigol] / usbtmc.c

#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <libusb-1.0/libusb.h>
#include <arpa/inet.h>

#include "scope.h"
#include "usbtmc.h"

#define USB_TIMEOUT		10000
#define USBTMC_IN_TRANSFERSIZE	0x800

#define ID_VENDOR	0x400
#define ID_PRODUCT	0x5dc

#if BYTE_ORDER == LITTLE_ENDIAN
#define LE32(x) x
#elif BYTE_ORDER == BIG_ENDIAN
#define LE32(x) ((uint32_t)((((uint32_t)x)>>24) | ((((uint32_t)x)>>8) & 0xff00) | ((((uint32_t)x)<<8) & 0xff0000) | (((uint32_t)x)<<24)))
#else
#error BYTE_ORDER not defined/known!
#endif

/* TODO: fix memory leak here: */
#define USB_ERROR(s, x) do { if (x < 0) { fprintf(stderr, "usb %s: %s\n", s, usb_strerror(x)); usbtmc_clear(sc); return 0; } } while(0)

/* Not in all libusb-1.0 versions, so we have to roll our own :-( */
static char * usb_strerror(int e)
{
	static char unknerr[256];

	switch (e) {
		case LIBUSB_SUCCESS:
			return "Success";
		case LIBUSB_ERROR_IO:
			return "Input/output error";
		case LIBUSB_ERROR_INVALID_PARAM:
			return "Invalid parameter";
		case LIBUSB_ERROR_ACCESS:
			return "Access denied (insufficient permissions)";
		case LIBUSB_ERROR_NO_DEVICE:
			return "No such device (it may have been disconnected)";
		case LIBUSB_ERROR_NOT_FOUND:
			return "Entity not found";
		case LIBUSB_ERROR_BUSY:
			return "Resource busy";
		case LIBUSB_ERROR_TIMEOUT:
			return "Operation timed out";
		case LIBUSB_ERROR_OVERFLOW:
			return "Overflow";
		case LIBUSB_ERROR_PIPE:
			return "Pipe error";
		case LIBUSB_ERROR_INTERRUPTED:
			return "System call interrupted (perhaps due to signal)";
		case LIBUSB_ERROR_NO_MEM:
			return "Insufficient memory";
		case LIBUSB_ERROR_NOT_SUPPORTED:
			return "Operation not supported or unimplemented on this platform";
		case LIBUSB_ERROR_OTHER:
			return "Other error";
	};
	snprintf(unknerr, sizeof(unknerr), "Unknown error code %d / 0x%02x", e, e);
	return unknerr;
}

/* This routine locates a scope by VID/PID and returns a struct scope* for it */
static struct scope* usbtmc_find_scope() {
	libusb_device_handle *devh = NULL;
	libusb_device **list;
	ssize_t cnt;
	ssize_t i;
	int err;
	struct scope *sc;

	cnt = libusb_get_device_list(NULL, &list);
	if (cnt < 0) {
		fprintf(stderr, "Can't get USB device list: %d\n", (int)cnt);
		return NULL;
	}

	for (i = 0; i < cnt; i++){
		struct libusb_device_descriptor desc;

		err = libusb_get_device_descriptor(list[i], &desc);
		if (err)
			continue;

		if ((desc.idVendor == ID_VENDOR) && (desc.idProduct == ID_PRODUCT)) {
			libusb_device *dev = list[i];

			err = libusb_open(dev, &devh);
			if (err) {
				fprintf(stderr, "Can't open device: %d\n", err);
				return NULL;
			}

			sc = calloc(1, sizeof(struct scope));
			if (sc == NULL) {
				perror("calloc");
				exit(EXIT_FAILURE);
			}

			sc->usb.dev = devh;

			/* TODO: FIXME */
			sc->usb.brokenRigol = 1;
			sc->usb.ep_bulk_out = 0x01;
			sc->usb.ep_bulk_in = 0x82;
			sc->usb.wMaxPacketSize_in = 0x40;

			return sc;
		}

	}

	return NULL;
}

static unsigned char usb488_status(struct scope *sc)
{
	int r;
	unsigned char status[3];

	sc->usb.bTag++;

	r = libusb_control_transfer(sc->usb.dev, 0xA1,
		USB488_CTL_READ_STATUS_BYTE,
		(sc->usb.bTag & 0x7f), 0, status, 3,
		USB_TIMEOUT);

	if ((r != 3) || (status[0] != USBTMC_STATUS_SUCCESS) || (status[1] != (sc->usb.bTag & 0x7f))) {
		printf("READ_STATUS_BYTE failed: %d 0x%x 0x%x 0x%x\n", r, status[0], status[1], status[2]);
		return 0xff;
	}

	return status[2];
}

static struct usbtmc_capabilities* usbtmc_get_capabilities(struct scope *sc)
{
	int r;
	static struct usbtmc_capabilities res;

	r = libusb_control_transfer(sc->usb.dev, 0xA1, 
		USBTMC_CTL_GET_CAPABILITIES,
		0, 0, (unsigned char*)&res, sizeof(struct usbtmc_capabilities),
		USB_TIMEOUT);
	if (r != sizeof(struct usbtmc_capabilities)) {
		printf("GET_CAPABILITIES failed: %s\n", usb_strerror(r));
		return NULL;
	}

	printf("USBTMC Version %02x.%02x Capabilities:\n", res.bcdUSBTMC[0], res.bcdUSBTMC[1]);
	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_INDICATOR_PULSE)
		printf("\tInterface supports indicator pulse\n");

	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_TALKONLY)
		printf("\tInterface is talk only\n");

	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_LISTENONLY)
		printf("\tInterface is listen only\n");

	if (res.USBTMCDEVcapabilities & USBTMC_CAP_DEV_TERMCHAR_SUPP)
		printf("\tDevice supports Termchar\n");

	printf("USB488 Version %02x.%02x Capabilities:\n", res.bcdUSB488[0], res.bcdUSB488[1]);

	if (res.USB488IFcapabilities & USB488_CAP_IF_4882)
		printf("\tInterface is 488.2 compliant\n");

	if (res.USB488IFcapabilities & USB488_CAP_IF_LOCKOUT)
		printf("\tInterface supports local lockout\n");

	if (res.USB488IFcapabilities & USB488_CAP_IF_TRIGGER)
		printf("\tInterface supports TRIGGER\n");

	if (res.USB488DEVcapabilities & USB488_CAP_DEV_SCPI)
		printf("\tDevice is SCPI compliant\n");

	if (res.USB488DEVcapabilities & USB488_CAP_DEV_SR1)
		printf("\tDevice is SR1 capable\n");

	if (res.USB488DEVcapabilities & USB488_CAP_DEV_RL1)
		printf("\tDevice is RL1 capable\n");

	if (res.USB488DEVcapabilities & USB488_CAP_DEV_DT1)
		printf("\tDevice is DT1 capable\n");

	return &res;
}

void usbtmc_reset(struct scope *sc)
{
	libusb_reset_device(sc->usb.dev);
	usbtmc_claim(sc);
}

static void usbtmc_clear(struct scope *sc)
{
	int r;
	unsigned char status[2];

	printf("Initiating clear...\n");
	r = libusb_control_transfer(sc->usb.dev, 0xA1,
		USBTMC_CTL_INITIATE_CLEAR,
		0, 0, status, 1,
		USB_TIMEOUT);
	
	if ((r != 1) || status[0] != USBTMC_STATUS_SUCCESS) {
		printf("INITIATE_CLEAR failed (0x%x): %s\n", status[0], usb_strerror(r));
		usbtmc_reset(sc);
		return;
	}

	while(1) {
		usleep(100000);
		printf("Waiting for clear to complete...\n");

		r = libusb_control_transfer(sc->usb.dev, 0xA1,
			USBTMC_CTL_CHECK_CLEAR_STAT,
			0, 0, status, 2,
			USB_TIMEOUT);

		if (r != 2) {
			printf("CHECK_CLEAR failed: %s\n", usb_strerror(r));
			return;
		}

		if (USBTMC_STATUS_FAIL(status[0])) {
			printf("CHECK_CLEAR failed: 0x%x\n", status[0]);
			return;
		}

		if ((status[0] == USBTMC_STATUS_SUCCESS) && (status[1] == 0)) {
			printf("Success!\n");
			break;
		}
	}
}

/*
 * Send a scpi-command to the scope. The response goes into the buffer
 * called resp, with a size of resplen. If resp==NULL, no response
 * is requested.
 */
int usbtmc_sendscpi(struct scope *sc, char* cmd, 
		unsigned char *resp, int resplen) {
	int len,r;
	int err;
	int cmdlen = strlen(cmd);
	int transferred;
	struct usbtmc_header *req;

	sc->usb.bTag++;

	len = sizeof(struct usbtmc_header) + cmdlen;
	if (len%4)
		len += 4 - (len%4);
	
	req = calloc(1, len);
	if (req == NULL) {
		perror("calloc");
		exit(EXIT_FAILURE);
	}

	req->MsgID = USBTMC_DEV_DEP_MSG_OUT;
	req->bTag = sc->usb.bTag;
	req->bTagInverse = ~sc->usb.bTag;
	req->TransferSize = LE32(cmdlen);
	req->bmTransferAttributes = USBTMC_TRANSFERATTRIB_EOM;
	memcpy(req->msg, cmd, cmdlen);

	if (sc->usb.brokenRigol) {
		r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
			(unsigned char*)req, sizeof(struct usbtmc_header),
			&transferred,
			USB_TIMEOUT);
		USB_ERROR("USBTMC_DEV_DEP_MSG_OUT1", r);

		r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
			(unsigned char*)&(req->msg), len - sizeof(struct usbtmc_header),
			&transferred,
			USB_TIMEOUT);
		USB_ERROR("USBTMC_DEV_DEP_MSG_OUT2", r);
	} else {
		r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
			(unsigned char*)req, len, &transferred, USB_TIMEOUT);
		USB_ERROR("USBTMC_DEV_DEP_MSG_OUT", r);
	}

	free(req);

	if (resp != NULL && resplen != 0) {
		unsigned char *buff = NULL;
		unsigned char rxbuff[USBTMC_IN_TRANSFERSIZE];
		struct usbtmc_header *res;
		int bytes_read;
		unsigned int read_size = USBTMC_IN_TRANSFERSIZE;
		unsigned int headerlen;

		req = calloc(1, sizeof(struct usbtmc_header));
		if (req == NULL) {
			perror("calloc");
			exit(EXIT_FAILURE);
		}

		if (sc->usb.brokenRigol == 1) {
			read_size = sc->usb.wMaxPacketSize_in;
		}

		bytes_read = 0;
		do {
			headerlen = 0;

			if ((sc->usb.brokenRigol == 0) || (bytes_read == 0)) {
				sc->usb.bTag++;

				req->MsgID = USBTMC_REQUEST_DEV_DEP_MSG_IN;
				req->bTag = sc->usb.bTag;
				req->bTagInverse = ~sc->usb.bTag;
				req->TransferSize = LE32(USBTMC_IN_TRANSFERSIZE);
				req->bmTransferAttributes = 0;
				req->TermChar = 0;

				/* send read command */
				r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
						(unsigned char*)req, sizeof(struct usbtmc_header), &transferred, USB_TIMEOUT);
				USB_ERROR("USBTMC_REQUEST_DEV_DEP_MSG_IN", r);

				headerlen = sizeof(struct usbtmc_header);
			}

			err=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_in,
					(unsigned char*)rxbuff, read_size, &r, USB_TIMEOUT);
			USB_ERROR("USBTMC_DEV_DEP_MSG_IN", err);

			if (r < headerlen) {
				fprintf(stderr, "Short read!\n");
				return 0;
			}

			if (headerlen > 0) {
				res = (struct usbtmc_header*)rxbuff;

				if ((res->bTag != sc->usb.bTag) ||
						(res->bTagInverse != (unsigned char)(~sc->usb.bTag))) {
					fprintf(stderr, "Wrong TAG received! We: 0x%02x, Scope: 0x%02x\n", sc->usb.bTag, res->bTag);
					if (sc->usb.brokenRigol == 1) {
						fprintf(stderr, "Tying to restart transfer...\n");
						bytes_read = 0;
						continue;
					}
					return 0;
				}

				if (buff == NULL) {
					len = LE32(res->TransferSize);
					buff=malloc(len);
					if (buff == NULL) {
						perror("malloc");
						exit(EXIT_FAILURE);
					}
				}
			}

			if ((r - headerlen) > 0) {
				memcpy(buff + bytes_read, rxbuff + headerlen, r - headerlen);
				bytes_read += r - headerlen;
			}

			read_size = USBTMC_IN_TRANSFERSIZE;
		} while(bytes_read < len);

		free(req);

		/* TODO: FIXME */
		if (bytes_read > resplen) {
			fprintf(stderr, "Response buffer to small: %d instead of %d bytes!\n",
				resplen, bytes_read);
			bytes_read = resplen;
		}

		memcpy(resp, buff, bytes_read);
		free(buff);

		return bytes_read;
	}
	return 0;
}

void usbtmc_claim(struct scope *sc)
{
	libusb_claim_interface(sc->usb.dev, 0);
}

void usbtmc_release(struct scope *sc)
{
	libusb_release_interface(sc->usb.dev, 0);
}

/* Initialize the scope. */
struct scope* usbtmc_initscope(void) {
	int r;
	uint32_t vidpid;
	struct scope *sc;

	/* Init libusb */
	libusb_init(NULL);
	/* Locate and open the scope */
	sc = usbtmc_find_scope();
	if (!sc) {
		return NULL;
	}

	usbtmc_claim(sc);
	sc->usb.cap = usbtmc_get_capabilities(sc);
	printf("Device status: 0x%x\n", usb488_status(sc));
	/* The following code isn't really necessary, the program works
	   OK without it too. */
	r=libusb_control_transfer(sc->usb.dev, 0xC8, 9, 0, 0, (unsigned char*)&vidpid, 4, USB_TIMEOUT);
	usbtmc_release(sc);
	if (r < 0) {
		fprintf (stderr, "Error %d sending init message: %s\n", 
				r, strerror (-r));
		fprintf (stderr, "Do you have permission on the USB device?\n");
		exit (1);
	}
	if (LE32(vidpid)!=0x40005dc) {
		fprintf(stderr,"Init: buff[%i]=%x\n",r,LE32(vidpid));
	}
	return sc;
}

void usbtmc_close(struct scope *sc)
{
	/* Free up and exit */
	libusb_close(sc->usb.dev);
}
Commit	Line	Data
58a9e276 MG	1	#include <string.h>
	2	#include <stdio.h>
	3	#include <stdint.h>
f416d675 MG	4	#include <unistd.h>
	5	#include <stdlib.h>
	6	#include <libusb-1.0/libusb.h>
58a9e276 MG	7	#include <arpa/inet.h>
58a9e276 MG	8
7906b395	9	#include "scope.h"
58a9e276 MG	10	#include "usbtmc.h"
58a9e276 MG	11
f7de0831 MG	12	#define USB_TIMEOUT 10000
f7de0831 MG	13	#define USBTMC_IN_TRANSFERSIZE 0x800
165abe62	14
f416d675 MG	15	#define ID_VENDOR 0x400
	16	#define ID_PRODUCT 0x5dc
	17
ddf9f28b MG	18	#if BYTE_ORDER == LITTLE_ENDIAN
	19	#define LE32(x) x
	20	#elif BYTE_ORDER == BIG_ENDIAN
	21	#define LE32(x) ((uint32_t)((((uint32_t)x)>>24) \| ((((uint32_t)x)>>8) & 0xff00) \| ((((uint32_t)x)<<8) & 0xff0000) \| (((uint32_t)x)<<24)))
	22	#else
	23	#error BYTE_ORDER not defined/known!
	24	#endif
	25
483a564b	26	/* TODO: fix memory leak here: */
f416d675 MG	27	#define USB_ERROR(s, x) do { if (x < 0) { fprintf(stderr, "usb %s: %s\n", s, usb_strerror(x)); usbtmc_clear(sc); return 0; } } while(0)
	28
	29	/* Not in all libusb-1.0 versions, so we have to roll our own :-( */
	30	static char * usb_strerror(int e)
	31	{
	32	static char unknerr[256];
	33
	34	switch (e) {
	35	case LIBUSB_SUCCESS:
	36	return "Success";
	37	case LIBUSB_ERROR_IO:
	38	return "Input/output error";
	39	case LIBUSB_ERROR_INVALID_PARAM:
	40	return "Invalid parameter";
	41	case LIBUSB_ERROR_ACCESS:
	42	return "Access denied (insufficient permissions)";
	43	case LIBUSB_ERROR_NO_DEVICE:
	44	return "No such device (it may have been disconnected)";
	45	case LIBUSB_ERROR_NOT_FOUND:
	46	return "Entity not found";
	47	case LIBUSB_ERROR_BUSY:
	48	return "Resource busy";
	49	case LIBUSB_ERROR_TIMEOUT:
	50	return "Operation timed out";
	51	case LIBUSB_ERROR_OVERFLOW:
	52	return "Overflow";
	53	case LIBUSB_ERROR_PIPE:
	54	return "Pipe error";
	55	case LIBUSB_ERROR_INTERRUPTED:
	56	return "System call interrupted (perhaps due to signal)";
	57	case LIBUSB_ERROR_NO_MEM:
	58	return "Insufficient memory";
	59	case LIBUSB_ERROR_NOT_SUPPORTED:
	60	return "Operation not supported or unimplemented on this platform";
	61	case LIBUSB_ERROR_OTHER:
	62	return "Other error";
	63	};
	64	snprintf(unknerr, sizeof(unknerr), "Unknown error code %d / 0x%02x", e, e);
	65	return unknerr;
	66	}
58a9e276	67
7b575069 MG	68	/* This routine locates a scope by VID/PID and returns a struct scope* for it */
7b575069 MG	69	static struct scope* usbtmc_find_scope() {
f416d675 MG	70	libusb_device_handle *devh = NULL;
	71	libusb_device **list;
	72	ssize_t cnt;
	73	ssize_t i;
	74	int err;
7b575069 MG	75	struct scope *sc;
7b575069 MG	76
f416d675 MG	77	cnt = libusb_get_device_list(NULL, &list);
	78	if (cnt < 0) {
	79	fprintf(stderr, "Can't get USB device list: %d\n", (int)cnt);
	80	return NULL;
	81	}
	82
	83	for (i = 0; i < cnt; i++){
	84	struct libusb_device_descriptor desc;
7b575069	85
f416d675 MG	86	err = libusb_get_device_descriptor(list[i], &desc);
	87	if (err)
	88	continue;
7b575069	89
f416d675 MG	90	if ((desc.idVendor == ID_VENDOR) && (desc.idProduct == ID_PRODUCT)) {
f416d675 MG	91	libusb_device *dev = list[i];
7b575069	92
f416d675 MG	93	err = libusb_open(dev, &devh);
	94	if (err) {
	95	fprintf(stderr, "Can't open device: %d\n", err);
	96	return NULL;
	97	}
7b575069	98
f416d675 MG	99	sc = calloc(1, sizeof(struct scope));
	100	if (sc == NULL) {
	101	perror("calloc");
	102	exit(EXIT_FAILURE);
58a9e276	103	}
f416d675 MG	104
	105	sc->usb.dev = devh;
	106
	107	/* TODO: FIXME */
	108	sc->usb.brokenRigol = 1;
	109	sc->usb.ep_bulk_out = 0x01;
	110	sc->usb.ep_bulk_in = 0x82;
	111	sc->usb.wMaxPacketSize_in = 0x40;
	112
	113	return sc;
58a9e276	114	}
f416d675	115
58a9e276	116	}
7b575069	117
58a9e276 MG	118	return NULL;
	119	}
	120
07a45f03	121	static unsigned char usb488_status(struct scope *sc)
121b4233 MG	122	{
	123	int r;
	124	unsigned char status[3];
	125
	126	sc->usb.bTag++;
	127
f416d675	128	r = libusb_control_transfer(sc->usb.dev, 0xA1,
483a564b	129	USB488_CTL_READ_STATUS_BYTE,
f416d675	130	(sc->usb.bTag & 0x7f), 0, status, 3,
483a564b MG	131	USB_TIMEOUT);
483a564b MG	132
07a45f03	133	if ((r != 3) \|\| (status[0] != USBTMC_STATUS_SUCCESS) \|\| (status[1] != (sc->usb.bTag & 0x7f))) {
121b4233 MG	134	printf("READ_STATUS_BYTE failed: %d 0x%x 0x%x 0x%x\n", r, status[0], status[1], status[2]);
	135	return 0xff;
	136	}
	137
	138	return status[2];
	139	}
	140
483a564b MG	141	static struct usbtmc_capabilities* usbtmc_get_capabilities(struct scope *sc)
	142	{
	143	int r;
	144	static struct usbtmc_capabilities res;
	145
f416d675	146	r = libusb_control_transfer(sc->usb.dev, 0xA1,
483a564b	147	USBTMC_CTL_GET_CAPABILITIES,
f416d675	148	0, 0, (unsigned char*)&res, sizeof(struct usbtmc_capabilities),
483a564b MG	149	USB_TIMEOUT);
483a564b MG	150	if (r != sizeof(struct usbtmc_capabilities)) {
f416d675	151	printf("GET_CAPABILITIES failed: %s\n", usb_strerror(r));
483a564b MG	152	return NULL;
	153	}
	154
f7de0831	155	printf("USBTMC Version %02x.%02x Capabilities:\n", res.bcdUSBTMC[0], res.bcdUSBTMC[1]);
483a564b MG	156	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_INDICATOR_PULSE)
	157	printf("\tInterface supports indicator pulse\n");
	158
	159	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_TALKONLY)
	160	printf("\tInterface is talk only\n");
	161
	162	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_LISTENONLY)
	163	printf("\tInterface is listen only\n");
	164
	165	if (res.USBTMCDEVcapabilities & USBTMC_CAP_DEV_TERMCHAR_SUPP)
	166	printf("\tDevice supports Termchar\n");
	167
f7de0831	168	printf("USB488 Version %02x.%02x Capabilities:\n", res.bcdUSB488[0], res.bcdUSB488[1]);
483a564b MG	169
	170	if (res.USB488IFcapabilities & USB488_CAP_IF_4882)
	171	printf("\tInterface is 488.2 compliant\n");
	172
	173	if (res.USB488IFcapabilities & USB488_CAP_IF_LOCKOUT)
	174	printf("\tInterface supports local lockout\n");
	175
	176	if (res.USB488IFcapabilities & USB488_CAP_IF_TRIGGER)
	177	printf("\tInterface supports TRIGGER\n");
	178
	179	if (res.USB488DEVcapabilities & USB488_CAP_DEV_SCPI)
	180	printf("\tDevice is SCPI compliant\n");
	181
	182	if (res.USB488DEVcapabilities & USB488_CAP_DEV_SR1)
	183	printf("\tDevice is SR1 capable\n");
	184
	185	if (res.USB488DEVcapabilities & USB488_CAP_DEV_RL1)
	186	printf("\tDevice is RL1 capable\n");
	187
	188	if (res.USB488DEVcapabilities & USB488_CAP_DEV_DT1)
	189	printf("\tDevice is DT1 capable\n");
	190
	191	return &res;
	192	}
	193
10ca7ea8 MG	194	void usbtmc_reset(struct scope *sc)
10ca7ea8 MG	195	{
f416d675	196	libusb_reset_device(sc->usb.dev);
10ca7ea8 MG	197	usbtmc_claim(sc);
	198	}
	199
f3ecdd6a MG	200	static void usbtmc_clear(struct scope *sc)
	201	{
	202	int r;
	203	unsigned char status[2];
	204
	205	printf("Initiating clear...\n");
f416d675	206	r = libusb_control_transfer(sc->usb.dev, 0xA1,
f3ecdd6a	207	USBTMC_CTL_INITIATE_CLEAR,
f416d675	208	0, 0, status, 1,
f3ecdd6a MG	209	USB_TIMEOUT);
f3ecdd6a MG	210
07a45f03	211	if ((r != 1) \|\| status[0] != USBTMC_STATUS_SUCCESS) {
f416d675	212	printf("INITIATE_CLEAR failed (0x%x): %s\n", status[0], usb_strerror(r));
10ca7ea8	213	usbtmc_reset(sc);
f3ecdd6a MG	214	return;
	215	}
	216
	217	while(1) {
	218	usleep(100000);
	219	printf("Waiting for clear to complete...\n");
	220
f416d675	221	r = libusb_control_transfer(sc->usb.dev, 0xA1,
f3ecdd6a	222	USBTMC_CTL_CHECK_CLEAR_STAT,
f416d675	223	0, 0, status, 2,
f3ecdd6a MG	224	USB_TIMEOUT);
f3ecdd6a MG	225
07a45f03	226	if (r != 2) {
f416d675	227	printf("CHECK_CLEAR failed: %s\n", usb_strerror(r));
f3ecdd6a MG	228	return;
	229	}
	230
07a45f03 MG	231	if (USBTMC_STATUS_FAIL(status[0])) {
	232	printf("CHECK_CLEAR failed: 0x%x\n", status[0]);
	233	return;
	234	}
	235
	236	if ((status[0] == USBTMC_STATUS_SUCCESS) && (status[1] == 0)) {
f3ecdd6a MG	237	printf("Success!\n");
	238	break;
	239	}
	240	}
	241	}
	242
7b575069 MG	243	/*
	244	* Send a scpi-command to the scope. The response goes into the buffer
	245	* called resp, with a size of resplen. If resp==NULL, no response
	246	* is requested.
	247	*/
7906b395	248	int usbtmc_sendscpi(struct scope sc, char cmd,
58a9e276	249	unsigned char *resp, int resplen) {
7b575069	250	int len,r;
f416d675	251	int err;
58a9e276	252	int cmdlen = strlen(cmd);
f416d675	253	int transferred;
7b575069 MG	254	struct usbtmc_header *req;
	255
	256	sc->usb.bTag++;
	257
	258	len = sizeof(struct usbtmc_header) + cmdlen;
	259	if (len%4)
	260	len += 4 - (len%4);
	261
	262	req = calloc(1, len);
	263	if (req == NULL) {
	264	perror("calloc");
	265	exit(EXIT_FAILURE);
	266	}
	267
	268	req->MsgID = USBTMC_DEV_DEP_MSG_OUT;
	269	req->bTag = sc->usb.bTag;
	270	req->bTagInverse = ~sc->usb.bTag;
	271	req->TransferSize = LE32(cmdlen);
	272	req->bmTransferAttributes = USBTMC_TRANSFERATTRIB_EOM;
	273	memcpy(req->msg, cmd, cmdlen);
	274
	275	if (sc->usb.brokenRigol) {
f416d675 MG	276	r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
	277	(unsigned char*)req, sizeof(struct usbtmc_header),
	278	&transferred,
7b575069	279	USB_TIMEOUT);
0aa0b761	280	USB_ERROR("USBTMC_DEV_DEP_MSG_OUT1", r);
7b575069	281
f416d675 MG	282	r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
	283	(unsigned char*)&(req->msg), len - sizeof(struct usbtmc_header),
	284	&transferred,
7b575069	285	USB_TIMEOUT);
0aa0b761	286	USB_ERROR("USBTMC_DEV_DEP_MSG_OUT2", r);
7b575069	287	} else {
f416d675 MG	288	r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
f416d675 MG	289	(unsigned char*)req, len, &transferred, USB_TIMEOUT);
0aa0b761	290	USB_ERROR("USBTMC_DEV_DEP_MSG_OUT", r);
7b575069 MG	291	}
	292
	293	free(req);
	294
58a9e276	295	if (resp != NULL && resplen != 0) {
f7de0831 MG	296	unsigned char *buff = NULL;
f7de0831 MG	297	unsigned char rxbuff[USBTMC_IN_TRANSFERSIZE];
7b575069 MG	298	struct usbtmc_header *res;
7b575069 MG	299	int bytes_read;
7d42ad7e	300	unsigned int read_size = USBTMC_IN_TRANSFERSIZE;
f7de0831	301	unsigned int headerlen;
7b575069 MG	302
	303	req = calloc(1, sizeof(struct usbtmc_header));
	304	if (req == NULL) {
	305	perror("calloc");
	306	exit(EXIT_FAILURE);
	307	}
	308
f7de0831	309	if (sc->usb.brokenRigol == 1) {
7d42ad7e	310	read_size = sc->usb.wMaxPacketSize_in;
f7de0831	311	}
7b575069	312
f7de0831 MG	313	bytes_read = 0;
	314	do {
	315	headerlen = 0;
7b575069	316
f7de0831 MG	317	if ((sc->usb.brokenRigol == 0) \|\| (bytes_read == 0)) {
f7de0831 MG	318	sc->usb.bTag++;
7b575069	319
f7de0831 MG	320	req->MsgID = USBTMC_REQUEST_DEV_DEP_MSG_IN;
	321	req->bTag = sc->usb.bTag;
	322	req->bTagInverse = ~sc->usb.bTag;
7d42ad7e	323	req->TransferSize = LE32(USBTMC_IN_TRANSFERSIZE);
f7de0831 MG	324	req->bmTransferAttributes = 0;
f7de0831 MG	325	req->TermChar = 0;
7b575069	326
f7de0831	327	/* send read command */
f416d675 MG	328	r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
f416d675 MG	329	(unsigned char*)req, sizeof(struct usbtmc_header), &transferred, USB_TIMEOUT);
f7de0831	330	USB_ERROR("USBTMC_REQUEST_DEV_DEP_MSG_IN", r);
7b575069	331
f7de0831 MG	332	headerlen = sizeof(struct usbtmc_header);
f7de0831 MG	333	}
7b575069	334
f416d675 MG	335	err=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_in,
	336	(unsigned char*)rxbuff, read_size, &r, USB_TIMEOUT);
	337	USB_ERROR("USBTMC_DEV_DEP_MSG_IN", err);
7b575069	338
f7de0831 MG	339	if (r < headerlen) {
	340	fprintf(stderr, "Short read!\n");
	341	return 0;
	342	}
7b575069	343
f7de0831 MG	344	if (headerlen > 0) {
f7de0831 MG	345	res = (struct usbtmc_header*)rxbuff;
7b575069	346
f7de0831 MG	347	if ((res->bTag != sc->usb.bTag) \|\|
	348	(res->bTagInverse != (unsigned char)(~sc->usb.bTag))) {
	349	fprintf(stderr, "Wrong TAG received! We: 0x%02x, Scope: 0x%02x\n", sc->usb.bTag, res->bTag);
	350	if (sc->usb.brokenRigol == 1) {
	351	fprintf(stderr, "Tying to restart transfer...\n");
	352	bytes_read = 0;
	353	continue;
	354	}
	355	return 0;
	356	}
	357
	358	if (buff == NULL) {
	359	len = LE32(res->TransferSize);
	360	buff=malloc(len);
	361	if (buff == NULL) {
	362	perror("malloc");
	363	exit(EXIT_FAILURE);
	364	}
	365	}
	366	}
	367
7d42ad7e	368	if ((r - headerlen) > 0) {
f7de0831 MG	369	memcpy(buff + bytes_read, rxbuff + headerlen, r - headerlen);
	370	bytes_read += r - headerlen;
	371	}
	372
7d42ad7e	373	read_size = USBTMC_IN_TRANSFERSIZE;
f7de0831 MG	374	} while(bytes_read < len);
	375
	376	free(req);
7b575069 MG	377
	378	/* TODO: FIXME */
	379	if (bytes_read > resplen) {
	380	fprintf(stderr, "Response buffer to small: %d instead of %d bytes!\n",
	381	resplen, bytes_read);
	382	bytes_read = resplen;
	383	}
	384
	385	memcpy(resp, buff, bytes_read);
	386	free(buff);
	387
	388	return bytes_read;
58a9e276 MG	389	}
	390	return 0;
	391	}
	392
7906b395	393	void usbtmc_claim(struct scope *sc)
ad9fbc05	394	{
f416d675	395	libusb_claim_interface(sc->usb.dev, 0);
ad9fbc05 MG	396	}
ad9fbc05 MG	397
7906b395	398	void usbtmc_release(struct scope *sc)
ad9fbc05	399	{
f416d675	400	libusb_release_interface(sc->usb.dev, 0);
ad9fbc05 MG	401	}
ad9fbc05 MG	402
483a564b	403	/* Initialize the scope. */
7906b395	404	struct scope* usbtmc_initscope(void) {
58a9e276	405	int r;
80564ddb	406	uint32_t vidpid;
7906b395	407	struct scope *sc;
58a9e276	408
7b575069	409	/* Init libusb */
f416d675	410	libusb_init(NULL);
7b575069 MG	411	/* Locate and open the scope */
	412	sc = usbtmc_find_scope();
	413	if (!sc) {
2999345d	414	return NULL;
58a9e276	415	}
7906b395	416
7906b395	417	usbtmc_claim(sc);
90e416c4	418	sc->usb.cap = usbtmc_get_capabilities(sc);
07a45f03	419	printf("Device status: 0x%x\n", usb488_status(sc));
7b575069 MG	420	/* The following code isn't really necessary, the program works
7b575069 MG	421	OK without it too. */
f416d675	422	r=libusb_control_transfer(sc->usb.dev, 0xC8, 9, 0, 0, (unsigned char*)&vidpid, 4, USB_TIMEOUT);
7906b395	423	usbtmc_release(sc);
58a9e276 MG	424	if (r < 0) {
	425	fprintf (stderr, "Error %d sending init message: %s\n",
	426	r, strerror (-r));
	427	fprintf (stderr, "Do you have permission on the USB device?\n");
	428	exit (1);
	429	}
80564ddb MG	430	if (LE32(vidpid)!=0x40005dc) {
80564ddb MG	431	fprintf(stderr,"Init: buff[%i]=%x\n",r,LE32(vidpid));
58a9e276	432	}
7906b395	433	return sc;
58a9e276	434	}
b74fea90	435
7906b395	436	void usbtmc_close(struct scope *sc)
b74fea90	437	{
7b575069	438	/* Free up and exit */
f416d675	439	libusb_close(sc->usb.dev);
b74fea90	440	}