X-Git-Url: http://git.zerfleddert.de/cgi-bin/gitweb.cgi/rigol/blobdiff_plain/90e416c4df00269ab86d349ff677d0a2c0b0bd40..f416d675a06903504d86cab1e7b1065b98ab5705:/usbtmc.c diff --git a/usbtmc.c b/usbtmc.c index e1366ae..5f15d72 100644 --- a/usbtmc.c +++ b/usbtmc.c @@ -1,13 +1,19 @@ #include #include #include -#include +#include +#include +#include #include #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) { @@ -286,10 +416,10 @@ struct scope* usbtmc_initscope(void) { usbtmc_claim(sc); sc->usb.cap = usbtmc_get_capabilities(sc); - printf("Device status: 0x%x\n", usbtmc_status(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); }