defines for STATUS bytes
[rigol] / usbtmc.c
CommitLineData
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"
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 */
24static struct scope* usbtmc_find_scope() {
58a9e276
MG
25 struct usb_bus *bus;
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();
32 usb_find_devices();
7b575069 33
58a9e276
MG
34 for (bus=usb_busses; bus; bus=bus->next) {
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;
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 63static 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
83static 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
136static 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) {
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 183int 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 305void usbtmc_claim(struct scope *sc)
ad9fbc05 306{
7906b395 307 usb_claim_interface(sc->usb.dev, 0);
ad9fbc05
MG
308}
309
7906b395 310void usbtmc_release(struct scope *sc)
ad9fbc05 311{
7906b395 312 usb_release_interface(sc->usb.dev, 0);
ad9fbc05
MG
313}
314
483a564b 315/* Initialize the scope. */
7906b395 316struct 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
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) {
343 fprintf(stderr,"Init: buff[%i]=%x\n",r,LE32(vidpid));
58a9e276 344 }
7906b395 345 return sc;
58a9e276 346}
b74fea90 347
7906b395 348void usbtmc_close(struct scope *sc)
b74fea90 349{
7b575069 350 /* Free up and exit */
7906b395 351 usb_close(sc->usb.dev);
b74fea90 352}
Impressum, Datenschutz