[rigol] / usbtmc.c

#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <usb.h>
#include <arpa/inet.h>

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

#define USB_TIMEOUT 10000

#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()); usbtmc_clear(sc); return 0; } } while(0)

/* This routine locates a scope by VID/PID and returns a struct scope* for it */
static struct scope* usbtmc_find_scope() {
	struct usb_bus *bus;
	struct usb_device *dev=NULL;
	struct usb_dev_handle *devh;

	struct scope *sc;

	usb_find_busses();
	usb_find_devices();

	for (bus=usb_busses; bus; bus=bus->next) {
		for (dev=bus->devices; dev; dev=dev->next) {
			if (dev->descriptor.idVendor == 0x400 && dev->descriptor.idProduct == 0x5dc) {
				devh = usb_open(dev);
				if (devh == NULL)
					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 = usb_control_msg(sc->usb.dev, 0xA1,
		USB488_CTL_READ_STATUS_BYTE,
		(sc->usb.bTag & 0x7f), 0, (char*)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 = usb_control_msg(sc->usb.dev, 0xA1, 
		USBTMC_CTL_GET_CAPABILITIES,
		0, 0, (char*)&res, sizeof(struct usbtmc_capabilities),
		USB_TIMEOUT);
	if (r != sizeof(struct usbtmc_capabilities)) {
		printf("GET_CAPABILITIES failed: %s\n", usb_strerror());
		return NULL;
	}

	printf("USBTMC Version %x.%x 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 %x.%x 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;
}

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

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

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

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

		if (r != 2) {
			printf("CHECK_CLEAR failed: %s\n", usb_strerror());
			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 cmdlen = strlen(cmd);
	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=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
			(char*)req, sizeof(struct usbtmc_header),
			USB_TIMEOUT);
		USB_ERROR("USBTMC_DEV_DEP_MSG_OUT1", r);

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

	free(req);

	if (resp != NULL && resplen != 0) {
		unsigned char *buff;
		struct usbtmc_header *res;
		int bytes_read;

		sc->usb.bTag++;

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

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

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

		free(req);

		buff=malloc(sc->usb.wMaxPacketSize_in);
		if (buff == NULL) {
			perror("malloc");
			exit(EXIT_FAILURE);
		}

		r=usb_bulk_read(sc->usb.dev, sc->usb.ep_bulk_in,
			(char*)buff, sc->usb.wMaxPacketSize_in, USB_TIMEOUT);
		USB_ERROR("USBTMC_DEV_DEP_MSG_IN1", r);

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

		bytes_read = r - sizeof(struct usbtmc_header);
		
		res = (struct usbtmc_header*)buff;
		len = LE32(res->TransferSize);

		memmove(buff, buff + sizeof(struct usbtmc_header), bytes_read);

		buff = realloc(buff, len);
		if (buff == NULL) {
			perror("realloc");
			exit(EXIT_FAILURE);
		}

		while ((len - bytes_read) > 0) {
			r=usb_bulk_read(sc->usb.dev, sc->usb.ep_bulk_in,
				(char*)buff + bytes_read, len - bytes_read,
				USB_TIMEOUT);
			USB_ERROR("USBTMC_DEV_DEP_MSG_INx", r);

			bytes_read += r;
		}

		/* 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)
{
	usb_claim_interface(sc->usb.dev, 0);
}

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

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

	/* Init libusb */
	usb_init();
	/* 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=usb_control_msg(sc->usb.dev, 0xC8, 9, 0, 0, (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 */
	usb_close(sc->usb.dev);
}
Commit	Line	Data
58a9e276 MG	1	#include <string.h>
	2	#include <stdio.h>
	3	#include <stdint.h>
	4	#include <usb.h>
	5	#include <arpa/inet.h>
	6
7906b395	7	#include "scope.h"
58a9e276 MG	8	#include "usbtmc.h"
58a9e276 MG	9
f3ecdd6a	10	#define USB_TIMEOUT 10000
165abe62	11
ddf9f28b MG	12	#if BYTE_ORDER == LITTLE_ENDIAN
	13	#define LE32(x) x
	14	#elif BYTE_ORDER == BIG_ENDIAN
	15	#define LE32(x) ((uint32_t)((((uint32_t)x)>>24) \| ((((uint32_t)x)>>8) & 0xff00) \| ((((uint32_t)x)<<8) & 0xff0000) \| (((uint32_t)x)<<24)))
	16	#else
	17	#error BYTE_ORDER not defined/known!
	18	#endif
	19
483a564b	20	/* TODO: fix memory leak here: */
f3ecdd6a	21	#define USB_ERROR(s, x) do { if (x < 0) { fprintf(stderr, "usb %s: %s\n", s, usb_strerror()); usbtmc_clear(sc); return 0; } } while(0)
58a9e276	22
7b575069 MG	23	/* This routine locates a scope by VID/PID and returns a struct scope* for it */
7b575069 MG	24	static struct scope* usbtmc_find_scope() {
58a9e276 MG	25	struct usb_bus *bus;
58a9e276 MG	26	struct usb_device *dev=NULL;
7b575069 MG	27	struct usb_dev_handle *devh;
	28
	29	struct scope *sc;
	30
58a9e276 MG	31	usb_find_busses();
58a9e276 MG	32	usb_find_devices();
7b575069	33
58a9e276 MG	34	for (bus=usb_busses; bus; bus=bus->next) {
58a9e276 MG	35	for (dev=bus->devices; dev; dev=dev->next) {
7b575069 MG	36	if (dev->descriptor.idVendor == 0x400 && dev->descriptor.idProduct == 0x5dc) {
	37	devh = usb_open(dev);
	38	if (devh == NULL)
	39	return NULL;
	40
	41	sc = calloc(1, sizeof(struct scope));
	42	if (sc == NULL) {
	43	perror("calloc");
	44	exit(EXIT_FAILURE);
	45	}
	46
	47	sc->usb.dev = devh;
	48
	49	/* TODO: FIXME */
	50	sc->usb.brokenRigol = 1;
c399a457 MG	51	sc->usb.ep_bulk_out = 0x01;
c399a457 MG	52	sc->usb.ep_bulk_in = 0x82;
7b575069 MG	53	sc->usb.wMaxPacketSize_in = 0x40;
	54
	55	return sc;
58a9e276 MG	56	}
	57	}
	58	}
7b575069	59
58a9e276 MG	60	return NULL;
	61	}
	62
07a45f03	63	static unsigned char usb488_status(struct scope *sc)
121b4233 MG	64	{
	65	int r;
	66	unsigned char status[3];
	67
	68	sc->usb.bTag++;
	69
483a564b MG	70	r = usb_control_msg(sc->usb.dev, 0xA1,
	71	USB488_CTL_READ_STATUS_BYTE,
	72	(sc->usb.bTag & 0x7f), 0, (char*)status, 3,
	73	USB_TIMEOUT);
	74
07a45f03	75	if ((r != 3) \|\| (status[0] != USBTMC_STATUS_SUCCESS) \|\| (status[1] != (sc->usb.bTag & 0x7f))) {
121b4233 MG	76	printf("READ_STATUS_BYTE failed: %d 0x%x 0x%x 0x%x\n", r, status[0], status[1], status[2]);
	77	return 0xff;
	78	}
	79
	80	return status[2];
	81	}
	82
483a564b MG	83	static struct usbtmc_capabilities* usbtmc_get_capabilities(struct scope *sc)
	84	{
	85	int r;
	86	static struct usbtmc_capabilities res;
	87
	88	r = usb_control_msg(sc->usb.dev, 0xA1,
	89	USBTMC_CTL_GET_CAPABILITIES,
	90	0, 0, (char*)&res, sizeof(struct usbtmc_capabilities),
	91	USB_TIMEOUT);
	92	if (r != sizeof(struct usbtmc_capabilities)) {
	93	printf("GET_CAPABILITIES failed: %s\n", usb_strerror());
	94	return NULL;
	95	}
	96
	97	printf("USBTMC Version %x.%x Capabilities:\n", res.bcdUSBTMC[0], res.bcdUSBTMC[1]);
	98	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_INDICATOR_PULSE)
	99	printf("\tInterface supports indicator pulse\n");
	100
	101	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_TALKONLY)
	102	printf("\tInterface is talk only\n");
	103
	104	if (res.USBTMCIFcapabilities & USBTMC_CAP_IF_LISTENONLY)
	105	printf("\tInterface is listen only\n");
	106
	107	if (res.USBTMCDEVcapabilities & USBTMC_CAP_DEV_TERMCHAR_SUPP)
	108	printf("\tDevice supports Termchar\n");
	109
	110	printf("USB488 Version %x.%x Capabilities:\n", res.bcdUSB488[0], res.bcdUSB488[1]);
	111
	112	if (res.USB488IFcapabilities & USB488_CAP_IF_4882)
	113	printf("\tInterface is 488.2 compliant\n");
	114
	115	if (res.USB488IFcapabilities & USB488_CAP_IF_LOCKOUT)
	116	printf("\tInterface supports local lockout\n");
	117
	118	if (res.USB488IFcapabilities & USB488_CAP_IF_TRIGGER)
	119	printf("\tInterface supports TRIGGER\n");
	120
	121	if (res.USB488DEVcapabilities & USB488_CAP_DEV_SCPI)
	122	printf("\tDevice is SCPI compliant\n");
	123
	124	if (res.USB488DEVcapabilities & USB488_CAP_DEV_SR1)
	125	printf("\tDevice is SR1 capable\n");
	126
	127	if (res.USB488DEVcapabilities & USB488_CAP_DEV_RL1)
	128	printf("\tDevice is RL1 capable\n");
	129
	130	if (res.USB488DEVcapabilities & USB488_CAP_DEV_DT1)
	131	printf("\tDevice is DT1 capable\n");
	132
	133	return &res;
	134	}
	135
f3ecdd6a MG	136	static void usbtmc_clear(struct scope *sc)
	137	{
	138	int r;
	139	unsigned char status[2];
	140
	141	printf("Initiating clear...\n");
	142	r = usb_control_msg(sc->usb.dev, 0xA1,
	143	USBTMC_CTL_INITIATE_CLEAR,
	144	0, 0, (char*)status, 1,
	145	USB_TIMEOUT);
	146
07a45f03 MG	147	if ((r != 1) \|\| status[0] != USBTMC_STATUS_SUCCESS) {
07a45f03 MG	148	printf("INITIATE_CLEAR failed (0x%x): %s\n", status[0], usb_strerror());
f3ecdd6a MG	149	return;
	150	}
	151
	152	while(1) {
	153	usleep(100000);
	154	printf("Waiting for clear to complete...\n");
	155
	156	r = usb_control_msg(sc->usb.dev, 0xA1,
	157	USBTMC_CTL_CHECK_CLEAR_STAT,
	158	0, 0, (char*)status, 2,
	159	USB_TIMEOUT);
	160
07a45f03	161	if (r != 2) {
f3ecdd6a MG	162	printf("CHECK_CLEAR failed: %s\n", usb_strerror());
	163	return;
	164	}
	165
07a45f03 MG	166	if (USBTMC_STATUS_FAIL(status[0])) {
	167	printf("CHECK_CLEAR failed: 0x%x\n", status[0]);
	168	return;
	169	}
	170
	171	if ((status[0] == USBTMC_STATUS_SUCCESS) && (status[1] == 0)) {
f3ecdd6a MG	172	printf("Success!\n");
	173	break;
	174	}
	175	}
	176	}
	177
7b575069 MG	178	/*
	179	* Send a scpi-command to the scope. The response goes into the buffer
	180	* called resp, with a size of resplen. If resp==NULL, no response
	181	* is requested.
	182	*/
7906b395	183	int usbtmc_sendscpi(struct scope sc, char cmd,
58a9e276	184	unsigned char *resp, int resplen) {
7b575069	185	int len,r;
58a9e276	186	int cmdlen = strlen(cmd);
7b575069 MG	187	struct usbtmc_header *req;
	188
	189	sc->usb.bTag++;
	190
	191	len = sizeof(struct usbtmc_header) + cmdlen;
	192	if (len%4)
	193	len += 4 - (len%4);
	194
	195	req = calloc(1, len);
	196	if (req == NULL) {
	197	perror("calloc");
	198	exit(EXIT_FAILURE);
	199	}
	200
	201	req->MsgID = USBTMC_DEV_DEP_MSG_OUT;
	202	req->bTag = sc->usb.bTag;
	203	req->bTagInverse = ~sc->usb.bTag;
	204	req->TransferSize = LE32(cmdlen);
	205	req->bmTransferAttributes = USBTMC_TRANSFERATTRIB_EOM;
	206	memcpy(req->msg, cmd, cmdlen);
	207
	208	if (sc->usb.brokenRigol) {
	209	r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
	210	(char*)req, sizeof(struct usbtmc_header),
	211	USB_TIMEOUT);
0aa0b761	212	USB_ERROR("USBTMC_DEV_DEP_MSG_OUT1", r);
7b575069 MG	213
	214	r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
	215	(char*)&(req->msg), len - sizeof(struct usbtmc_header),
	216	USB_TIMEOUT);
0aa0b761	217	USB_ERROR("USBTMC_DEV_DEP_MSG_OUT2", r);
7b575069 MG	218	} else {
	219	r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
	220	(char*)req, len, USB_TIMEOUT);
0aa0b761	221	USB_ERROR("USBTMC_DEV_DEP_MSG_OUT", r);
7b575069 MG	222	}
	223
	224	free(req);
	225
58a9e276	226	if (resp != NULL && resplen != 0) {
7b575069 MG	227	unsigned char *buff;
	228	struct usbtmc_header *res;
	229	int bytes_read;
	230
	231	sc->usb.bTag++;
	232
	233	req = calloc(1, sizeof(struct usbtmc_header));
	234	if (req == NULL) {
	235	perror("calloc");
	236	exit(EXIT_FAILURE);
	237	}
	238
	239	req->MsgID = USBTMC_REQUEST_DEV_DEP_MSG_IN;
	240	req->bTag = sc->usb.bTag;
	241	req->bTagInverse = ~sc->usb.bTag;
	242	req->TransferSize = LE32(sc->usb.wMaxPacketSize_in);
a163d2fb	243	req->bmTransferAttributes = 0;
7b575069 MG	244	req->TermChar = 0;
	245
	246	/* send read command */
	247	r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
	248	(char*)req, sizeof(struct usbtmc_header), USB_TIMEOUT);
0aa0b761	249	USB_ERROR("USBTMC_REQUEST_DEV_DEP_MSG_IN", r);
7b575069 MG	250
	251	free(req);
	252
	253	buff=malloc(sc->usb.wMaxPacketSize_in);
	254	if (buff == NULL) {
	255	perror("malloc");
	256	exit(EXIT_FAILURE);
58a9e276	257	}
7b575069 MG	258
	259	r=usb_bulk_read(sc->usb.dev, sc->usb.ep_bulk_in,
	260	(char*)buff, sc->usb.wMaxPacketSize_in, USB_TIMEOUT);
0aa0b761	261	USB_ERROR("USBTMC_DEV_DEP_MSG_IN1", r);
7b575069 MG	262
	263	if (r < sizeof(struct usbtmc_header)) {
	264	fprintf(stderr, "Short read!\n");
	265	return 0;
58a9e276	266	}
7b575069 MG	267
	268	bytes_read = r - sizeof(struct usbtmc_header);
	269
	270	res = (struct usbtmc_header*)buff;
	271	len = LE32(res->TransferSize);
	272
	273	memmove(buff, buff + sizeof(struct usbtmc_header), bytes_read);
	274
	275	buff = realloc(buff, len);
	276	if (buff == NULL) {
	277	perror("realloc");
	278	exit(EXIT_FAILURE);
	279	}
	280
	281	while ((len - bytes_read) > 0) {
	282	r=usb_bulk_read(sc->usb.dev, sc->usb.ep_bulk_in,
	283	(char*)buff + bytes_read, len - bytes_read,
	284	USB_TIMEOUT);
0aa0b761	285	USB_ERROR("USBTMC_DEV_DEP_MSG_INx", r);
7b575069 MG	286
	287	bytes_read += r;
	288	}
	289
	290	/* TODO: FIXME */
	291	if (bytes_read > resplen) {
	292	fprintf(stderr, "Response buffer to small: %d instead of %d bytes!\n",
	293	resplen, bytes_read);
	294	bytes_read = resplen;
	295	}
	296
	297	memcpy(resp, buff, bytes_read);
	298	free(buff);
	299
	300	return bytes_read;
58a9e276 MG	301	}
	302	return 0;
	303	}
	304
7906b395	305	void usbtmc_claim(struct scope *sc)
ad9fbc05	306	{
7906b395	307	usb_claim_interface(sc->usb.dev, 0);
ad9fbc05 MG	308	}
ad9fbc05 MG	309
7906b395	310	void usbtmc_release(struct scope *sc)
ad9fbc05	311	{
7906b395	312	usb_release_interface(sc->usb.dev, 0);
ad9fbc05 MG	313	}
ad9fbc05 MG	314
483a564b	315	/* Initialize the scope. */
7906b395	316	struct scope* usbtmc_initscope(void) {
58a9e276	317	int r;
80564ddb	318	uint32_t vidpid;
7906b395	319	struct scope *sc;
58a9e276	320
7b575069	321	/* Init libusb */
58a9e276	322	usb_init();
7b575069 MG	323	/* Locate and open the scope */
	324	sc = usbtmc_find_scope();
	325	if (!sc) {
2999345d	326	return NULL;
58a9e276	327	}
7906b395	328
7906b395	329	usbtmc_claim(sc);
90e416c4	330	sc->usb.cap = usbtmc_get_capabilities(sc);
07a45f03	331	printf("Device status: 0x%x\n", usb488_status(sc));
7b575069 MG	332	/* The following code isn't really necessary, the program works
7b575069 MG	333	OK without it too. */
80564ddb	334	r=usb_control_msg(sc->usb.dev, 0xC8, 9, 0, 0, (char*)&vidpid, 4, USB_TIMEOUT);
7906b395	335	usbtmc_release(sc);
58a9e276 MG	336	if (r < 0) {
	337	fprintf (stderr, "Error %d sending init message: %s\n",
	338	r, strerror (-r));
	339	fprintf (stderr, "Do you have permission on the USB device?\n");
	340	exit (1);
	341	}
80564ddb MG	342	if (LE32(vidpid)!=0x40005dc) {
80564ddb MG	343	fprintf(stderr,"Init: buff[%i]=%x\n",r,LE32(vidpid));
58a9e276	344	}
7906b395	345	return sc;
58a9e276	346	}
b74fea90	347
7906b395	348	void usbtmc_close(struct scope *sc)
b74fea90	349	{
7b575069	350	/* Free up and exit */
7906b395	351	usb_close(sc->usb.dev);
b74fea90	352	}