git.zerfleddert.de Git - rigol/blob - usbtmc.c

   1 #include <string.h>
   2 #include <stdio.h>
   3 #include <stdint.h>
   4 #include <usb.h>
   5 #include <arpa/inet.h>
   6
   7 #include "scope.h"
   8 #include "usbtmc.h"
   9
  10 #define USB_TIMEOUT 10000
  11
  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
  20 /* TODO: fix memory leak here: */
  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)
  22
  23 /* This routine locates a scope by VID/PID and returns a struct scope* for it */
  24 static struct scope* usbtmc_find_scope() {
  25         struct usb_bus *bus;
  26         struct usb_device *dev=NULL;
  27         struct usb_dev_handle *devh;
  28
  29         struct scope *sc;
  30
  31         usb_find_busses();
  32         usb_find_devices();
  33
  34         for (bus=usb_busses; bus; bus=bus->next) {
  35                 for (dev=bus->devices; dev; dev=dev->next) {
  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;
  51                                 sc->usb.ep_bulk_out = 0x01;
  52                                 sc->usb.ep_bulk_in = 0x82;
  53                                 sc->usb.wMaxPacketSize_in = 0x40;
  54
  55                                 return sc;
  56                         }
  57                 }
  58         }
  59
  60         return NULL;
  61 }
  62
  63 static unsigned char usb488_status(struct scope *sc)
  64 {
  65         int r;
  66         unsigned char status[3];
  67
  68         sc->usb.bTag++;
  69
  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
  75         if ((r != 3) || (status[0] != USBTMC_STATUS_SUCCESS) || (status[1] != (sc->usb.bTag & 0x7f))) {
  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
  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
 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
 147         if ((r != 1) || status[0] != USBTMC_STATUS_SUCCESS) {
 148                 printf("INITIATE_CLEAR failed (0x%x): %s\n", status[0], usb_strerror());
 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
 161                 if (r != 2) {
 162                         printf("CHECK_CLEAR failed: %s\n", usb_strerror());
 163                         return;
 164                 }
 165
 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)) {
 172                         printf("Success!\n");
 173                         break;
 174                 }
 175         }
 176 }
 177
 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  */
 183 int usbtmc_sendscpi(struct scope *sc, char* cmd,
 184                 unsigned char *resp, int resplen) {
 185         int len,r;
 186         int cmdlen = strlen(cmd);
 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);
 212                 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT1", r);
 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);
 217                 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT2", r);
 218         } else {
 219                 r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out,
 220                         (char*)req, len, USB_TIMEOUT);
 221                 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT", r);
 222         }
 223
 224         free(req);
 225
 226         if (resp != NULL && resplen != 0) {
 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);
 243                 req->bmTransferAttributes = 0;
 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);
 249                 USB_ERROR("USBTMC_REQUEST_DEV_DEP_MSG_IN", r);
 250
 251                 free(req);
 252
 253                 buff=malloc(sc->usb.wMaxPacketSize_in);
 254                 if (buff == NULL) {
 255                         perror("malloc");
 256                         exit(EXIT_FAILURE);
 257                 }
 258
 259                 r=usb_bulk_read(sc->usb.dev, sc->usb.ep_bulk_in,
 260                         (char*)buff, sc->usb.wMaxPacketSize_in, USB_TIMEOUT);
 261                 USB_ERROR("USBTMC_DEV_DEP_MSG_IN1", r);
 262
 263                 if (r < sizeof(struct usbtmc_header)) {
 264                         fprintf(stderr, "Short read!\n");
 265                         return 0;
 266                 }
 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);
 285                         USB_ERROR("USBTMC_DEV_DEP_MSG_INx", r);
 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;
 301         }
 302         return 0;
 303 }
 304
 305 void usbtmc_claim(struct scope *sc)
 306 {
 307         usb_claim_interface(sc->usb.dev, 0);
 308 }
 309
 310 void usbtmc_release(struct scope *sc)
 311 {
 312         usb_release_interface(sc->usb.dev, 0);
 313 }
 314
 315 /* Initialize the scope. */
 316 struct scope* usbtmc_initscope(void) {
 317         int r;
 318         uint32_t vidpid;
 319         struct scope *sc;
 320
 321         /* Init libusb */
 322         usb_init();
 323         /* Locate and open the scope */
 324         sc = usbtmc_find_scope();
 325         if (!sc) {
 326                 return NULL;
 327         }
 328
 329         usbtmc_claim(sc);
 330         sc->usb.cap = usbtmc_get_capabilities(sc);
 331         printf("Device status: 0x%x\n", usb488_status(sc));
 332         /* The following code isn't really necessary, the program works
 333            OK without it too. */
 334         r=usb_control_msg(sc->usb.dev, 0xC8, 9, 0, 0, (char*)&vidpid, 4, USB_TIMEOUT);
 335         usbtmc_release(sc);
 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         }
 342         if (LE32(vidpid)!=0x40005dc) {
 343                 fprintf(stderr,"Init: buff[%i]=%x\n",r,LE32(vidpid));
 344         }
 345         return sc;
 346 }
 347
 348 void usbtmc_close(struct scope *sc)
 349 {
 350         /* Free up and exit */
 351         usb_close(sc->usb.dev);
 352 }