X-Git-Url: http://cvs.zerfleddert.de/cgi-bin/gitweb.cgi/rigol/blobdiff_plain/483a564bf0578b64b25c68ffabdfdc0fb9f0f2b7..f416d675a06903504d86cab1e7b1065b98ab5705:/usbtmc.c?ds=sidebyside

diff --git a/usbtmc.c b/usbtmc.c
index 332cbda..5f15d72 100644
--- a/usbtmc.c
+++ b/usbtmc.c
@@ -1,13 +1,19 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdint.h>
-#include <usb.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 50000
+#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
@@ -18,61 +24,113 @@
 #endif
 
 /* TODO: fix memory leak here: */
-#define USB_ERROR(s, x) do { if (x < 0) { fprintf(stderr, "usb %s: %s\n", s, usb_strerror()); usb_reset(sc->usb.dev); return 0; } } while(0)
+#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() {
-	struct usb_bus *bus;
-	struct usb_device *dev=NULL;
-	struct usb_dev_handle *devh;
-
+	libusb_device_handle *devh = NULL;
+	libusb_device **list;
+	ssize_t cnt;
+	ssize_t i;
+	int err;
 	struct scope *sc;
 
-	usb_find_busses();
-	usb_find_devices();
+	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;
 
-	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;
+		err = libusb_get_device_descriptor(list[i], &desc);
+		if (err)
+			continue;
 
-				sc = calloc(1, sizeof(struct scope));
-				if (sc == NULL) {
-					perror("calloc");
-					exit(EXIT_FAILURE);
-				}
+		if ((desc.idVendor == ID_VENDOR) && (desc.idProduct == ID_PRODUCT)) {
+			libusb_device *dev = list[i];
 
-				sc->usb.dev = devh;
+			err = libusb_open(dev, &devh);
+			if (err) {
+				fprintf(stderr, "Can't open device: %d\n", err);
+				return NULL;
+			}
 
-				/* 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;
+			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 usbtmc_status(struct scope *sc)
+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,
+	r = libusb_control_transfer(sc->usb.dev, 0xA1,
 		USB488_CTL_READ_STATUS_BYTE,
-		(sc->usb.bTag & 0x7f), 0, (char*)status, 3,
+		(sc->usb.bTag & 0x7f), 0, status, 3,
 		USB_TIMEOUT);
 
-	if ((r != 3) || (status[0] != 0x01) || (status[1] != (sc->usb.bTag & 0x7f))) {
+	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;
 	}
@@ -85,16 +143,16 @@ 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, 
+	r = libusb_control_transfer(sc->usb.dev, 0xA1, 
 		USBTMC_CTL_GET_CAPABILITIES,
-		0, 0, (char*)&res, sizeof(struct usbtmc_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());
+		printf("GET_CAPABILITIES failed: %s\n", usb_strerror(r));
 		return NULL;
 	}
 
-	printf("USBTMC Version %x.%x Capabilities:\n", res.bcdUSBTMC[0], res.bcdUSBTMC[1]);
+	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");
 
@@ -107,7 +165,7 @@ static struct usbtmc_capabilities* usbtmc_get_capabilities(struct scope *sc)
 	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]);
+	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");
@@ -133,6 +191,55 @@ static struct usbtmc_capabilities* usbtmc_get_capabilities(struct scope *sc)
 	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
@@ -141,7 +248,9 @@ static struct usbtmc_capabilities* usbtmc_get_capabilities(struct scope *sc)
 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++;
@@ -164,29 +273,32 @@ int usbtmc_sendscpi(struct scope *sc, char* cmd,
 	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),
+		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=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
-			(char*)&(req->msg), len - sizeof(struct usbtmc_header),
+		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=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
-			(char*)req, len, USB_TIMEOUT);
+		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;
+		unsigned char *buff = NULL;
+		unsigned char rxbuff[USBTMC_IN_TRANSFERSIZE];
 		struct usbtmc_header *res;
 		int bytes_read;
-
-		sc->usb.bTag++;
+		unsigned int read_size = USBTMC_IN_TRANSFERSIZE;
+		unsigned int headerlen;
 
 		req = calloc(1, sizeof(struct usbtmc_header));
 		if (req == NULL) {
@@ -194,56 +306,74 @@ int usbtmc_sendscpi(struct scope *sc, char* cmd,
 			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 = USBTMC_TRANSFERATTRIB_EOM;
-		req->TermChar = 0;
+		if (sc->usb.brokenRigol == 1) {
+			read_size = sc->usb.wMaxPacketSize_in;
+		}
 
-		/* 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);
+		bytes_read = 0;
+		do {
+			headerlen = 0;
 
-		free(req);
+			if ((sc->usb.brokenRigol == 0) || (bytes_read == 0)) {
+				sc->usb.bTag++;
 
-		buff=malloc(sc->usb.wMaxPacketSize_in);
-		if (buff == NULL) {
-			perror("malloc");
-			exit(EXIT_FAILURE);
-		}
+				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;
 
-		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);
+				/* 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);
 
-		if (r < sizeof(struct usbtmc_header)) {
-			fprintf(stderr, "Short read!\n");
-			return 0;
-		}
+				headerlen = sizeof(struct usbtmc_header);
+			}
 
-		bytes_read = r - sizeof(struct usbtmc_header);
-		
-		res = (struct usbtmc_header*)buff;
-		len = LE32(res->TransferSize);
+			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);
 
-		memmove(buff, buff + sizeof(struct usbtmc_header), bytes_read);
+			if (r < headerlen) {
+				fprintf(stderr, "Short read!\n");
+				return 0;
+			}
 
-		buff = realloc(buff, len);
-		if (buff == NULL) {
-			perror("realloc");
-			exit(EXIT_FAILURE);
-		}
+			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;
+				}
 
-		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);
+				if (buff == NULL) {
+					len = LE32(res->TransferSize);
+					buff=malloc(len);
+					if (buff == NULL) {
+						perror("malloc");
+						exit(EXIT_FAILURE);
+					}
+				}
+			}
 
-			bytes_read += r;
-		}
+			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) {
@@ -262,12 +392,12 @@ int usbtmc_sendscpi(struct scope *sc, char* cmd,
 
 void usbtmc_claim(struct scope *sc)
 {
-	usb_claim_interface(sc->usb.dev, 0);
+	libusb_claim_interface(sc->usb.dev, 0);
 }
 
 void usbtmc_release(struct scope *sc)
 {
-	usb_release_interface(sc->usb.dev, 0);
+	libusb_release_interface(sc->usb.dev, 0);
 }
 
 /* Initialize the scope. */
@@ -277,7 +407,7 @@ struct scope* usbtmc_initscope(void) {
 	struct scope *sc;
 
 	/* Init libusb */
-	usb_init();
+	libusb_init(NULL);
 	/* Locate and open the scope */
 	sc = usbtmc_find_scope();
 	if (!sc) {
@@ -285,11 +415,11 @@ struct scope* usbtmc_initscope(void) {
 	}
 
 	usbtmc_claim(sc);
-	usbtmc_get_capabilities(sc);
-	printf("Device status: 0x%x\n", usbtmc_status(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);
+	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", 
@@ -306,5 +436,5 @@ struct scope* usbtmc_initscope(void) {
 void usbtmc_close(struct scope *sc)
 {
 	/* Free up and exit */
-	usb_close(sc->usb.dev);
+	libusb_close(sc->usb.dev);
 }