update to libusb-1.0
[rigol] / usbtmc.c
1 #include <string.h>
2 #include <stdio.h>
3 #include <stdint.h>
4 #include <unistd.h>
5 #include <stdlib.h>
6 #include <libusb-1.0/libusb.h>
7 #include <arpa/inet.h>
8
9 #include "scope.h"
10 #include "usbtmc.h"
11
12 #define USB_TIMEOUT 10000
13 #define USBTMC_IN_TRANSFERSIZE 0x800
14
15 #define ID_VENDOR 0x400
16 #define ID_PRODUCT 0x5dc
17
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
26 /* TODO: fix memory leak here: */
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 }
67
68 /* This routine locates a scope by VID/PID and returns a struct scope* for it */
69 static struct scope* usbtmc_find_scope() {
70 libusb_device_handle *devh = NULL;
71 libusb_device **list;
72 ssize_t cnt;
73 ssize_t i;
74 int err;
75 struct scope *sc;
76
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;
85
86 err = libusb_get_device_descriptor(list[i], &desc);
87 if (err)
88 continue;
89
90 if ((desc.idVendor == ID_VENDOR) && (desc.idProduct == ID_PRODUCT)) {
91 libusb_device *dev = list[i];
92
93 err = libusb_open(dev, &devh);
94 if (err) {
95 fprintf(stderr, "Can't open device: %d\n", err);
96 return NULL;
97 }
98
99 sc = calloc(1, sizeof(struct scope));
100 if (sc == NULL) {
101 perror("calloc");
102 exit(EXIT_FAILURE);
103 }
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;
114 }
115
116 }
117
118 return NULL;
119 }
120
121 static unsigned char usb488_status(struct scope *sc)
122 {
123 int r;
124 unsigned char status[3];
125
126 sc->usb.bTag++;
127
128 r = libusb_control_transfer(sc->usb.dev, 0xA1,
129 USB488_CTL_READ_STATUS_BYTE,
130 (sc->usb.bTag & 0x7f), 0, status, 3,
131 USB_TIMEOUT);
132
133 if ((r != 3) || (status[0] != USBTMC_STATUS_SUCCESS) || (status[1] != (sc->usb.bTag & 0x7f))) {
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
141 static struct usbtmc_capabilities* usbtmc_get_capabilities(struct scope *sc)
142 {
143 int r;
144 static struct usbtmc_capabilities res;
145
146 r = libusb_control_transfer(sc->usb.dev, 0xA1,
147 USBTMC_CTL_GET_CAPABILITIES,
148 0, 0, (unsigned char*)&res, sizeof(struct usbtmc_capabilities),
149 USB_TIMEOUT);
150 if (r != sizeof(struct usbtmc_capabilities)) {
151 printf("GET_CAPABILITIES failed: %s\n", usb_strerror(r));
152 return NULL;
153 }
154
155 printf("USBTMC Version %02x.%02x Capabilities:\n", res.bcdUSBTMC[0], res.bcdUSBTMC[1]);
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
168 printf("USB488 Version %02x.%02x Capabilities:\n", res.bcdUSB488[0], res.bcdUSB488[1]);
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
194 void usbtmc_reset(struct scope *sc)
195 {
196 libusb_reset_device(sc->usb.dev);
197 usbtmc_claim(sc);
198 }
199
200 static void usbtmc_clear(struct scope *sc)
201 {
202 int r;
203 unsigned char status[2];
204
205 printf("Initiating clear...\n");
206 r = libusb_control_transfer(sc->usb.dev, 0xA1,
207 USBTMC_CTL_INITIATE_CLEAR,
208 0, 0, status, 1,
209 USB_TIMEOUT);
210
211 if ((r != 1) || status[0] != USBTMC_STATUS_SUCCESS) {
212 printf("INITIATE_CLEAR failed (0x%x): %s\n", status[0], usb_strerror(r));
213 usbtmc_reset(sc);
214 return;
215 }
216
217 while(1) {
218 usleep(100000);
219 printf("Waiting for clear to complete...\n");
220
221 r = libusb_control_transfer(sc->usb.dev, 0xA1,
222 USBTMC_CTL_CHECK_CLEAR_STAT,
223 0, 0, status, 2,
224 USB_TIMEOUT);
225
226 if (r != 2) {
227 printf("CHECK_CLEAR failed: %s\n", usb_strerror(r));
228 return;
229 }
230
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)) {
237 printf("Success!\n");
238 break;
239 }
240 }
241 }
242
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 */
248 int usbtmc_sendscpi(struct scope *sc, char* cmd,
249 unsigned char *resp, int resplen) {
250 int len,r;
251 int err;
252 int cmdlen = strlen(cmd);
253 int transferred;
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) {
276 r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
277 (unsigned char*)req, sizeof(struct usbtmc_header),
278 &transferred,
279 USB_TIMEOUT);
280 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT1", r);
281
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,
285 USB_TIMEOUT);
286 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT2", r);
287 } else {
288 r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
289 (unsigned char*)req, len, &transferred, USB_TIMEOUT);
290 USB_ERROR("USBTMC_DEV_DEP_MSG_OUT", r);
291 }
292
293 free(req);
294
295 if (resp != NULL && resplen != 0) {
296 unsigned char *buff = NULL;
297 unsigned char rxbuff[USBTMC_IN_TRANSFERSIZE];
298 struct usbtmc_header *res;
299 int bytes_read;
300 unsigned int read_size = USBTMC_IN_TRANSFERSIZE;
301 unsigned int headerlen;
302
303 req = calloc(1, sizeof(struct usbtmc_header));
304 if (req == NULL) {
305 perror("calloc");
306 exit(EXIT_FAILURE);
307 }
308
309 if (sc->usb.brokenRigol == 1) {
310 read_size = sc->usb.wMaxPacketSize_in;
311 }
312
313 bytes_read = 0;
314 do {
315 headerlen = 0;
316
317 if ((sc->usb.brokenRigol == 0) || (bytes_read == 0)) {
318 sc->usb.bTag++;
319
320 req->MsgID = USBTMC_REQUEST_DEV_DEP_MSG_IN;
321 req->bTag = sc->usb.bTag;
322 req->bTagInverse = ~sc->usb.bTag;
323 req->TransferSize = LE32(USBTMC_IN_TRANSFERSIZE);
324 req->bmTransferAttributes = 0;
325 req->TermChar = 0;
326
327 /* send read command */
328 r=libusb_bulk_transfer(sc->usb.dev, sc->usb.ep_bulk_out,
329 (unsigned char*)req, sizeof(struct usbtmc_header), &transferred, USB_TIMEOUT);
330 USB_ERROR("USBTMC_REQUEST_DEV_DEP_MSG_IN", r);
331
332 headerlen = sizeof(struct usbtmc_header);
333 }
334
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);
338
339 if (r < headerlen) {
340 fprintf(stderr, "Short read!\n");
341 return 0;
342 }
343
344 if (headerlen > 0) {
345 res = (struct usbtmc_header*)rxbuff;
346
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
368 if ((r - headerlen) > 0) {
369 memcpy(buff + bytes_read, rxbuff + headerlen, r - headerlen);
370 bytes_read += r - headerlen;
371 }
372
373 read_size = USBTMC_IN_TRANSFERSIZE;
374 } while(bytes_read < len);
375
376 free(req);
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;
389 }
390 return 0;
391 }
392
393 void usbtmc_claim(struct scope *sc)
394 {
395 libusb_claim_interface(sc->usb.dev, 0);
396 }
397
398 void usbtmc_release(struct scope *sc)
399 {
400 libusb_release_interface(sc->usb.dev, 0);
401 }
402
403 /* Initialize the scope. */
404 struct scope* usbtmc_initscope(void) {
405 int r;
406 uint32_t vidpid;
407 struct scope *sc;
408
409 /* Init libusb */
410 libusb_init(NULL);
411 /* Locate and open the scope */
412 sc = usbtmc_find_scope();
413 if (!sc) {
414 return NULL;
415 }
416
417 usbtmc_claim(sc);
418 sc->usb.cap = usbtmc_get_capabilities(sc);
419 printf("Device status: 0x%x\n", usb488_status(sc));
420 /* The following code isn't really necessary, the program works
421 OK without it too. */
422 r=libusb_control_transfer(sc->usb.dev, 0xC8, 9, 0, 0, (unsigned char*)&vidpid, 4, USB_TIMEOUT);
423 usbtmc_release(sc);
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 }
430 if (LE32(vidpid)!=0x40005dc) {
431 fprintf(stderr,"Init: buff[%i]=%x\n",r,LE32(vidpid));
432 }
433 return sc;
434 }
435
436 void usbtmc_close(struct scope *sc)
437 {
438 /* Free up and exit */
439 libusb_close(sc->usb.dev);
440 }
Impressum, Datenschutz