]>
Commit | Line | Data |
---|---|---|
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 | ||
7a226bb8 | 10 | #define USB_TIMEOUT 50000 |
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: */ |
0aa0b761 | 21 | #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) |
58a9e276 | 22 | |
7b575069 MG |
23 | /* This routine locates a scope by VID/PID and returns a struct scope* for it */ |
24 | static 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 | ||
483a564b | 63 | static unsigned char usbtmc_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 | ||
121b4233 MG |
75 | if ((r != 3) || (status[0] != 0x01) || (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 | ||
483a564b MG |
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 | ||
7b575069 MG |
136 | /* |
137 | * Send a scpi-command to the scope. The response goes into the buffer | |
138 | * called resp, with a size of resplen. If resp==NULL, no response | |
139 | * is requested. | |
140 | */ | |
7906b395 | 141 | int usbtmc_sendscpi(struct scope *sc, char* cmd, |
58a9e276 | 142 | unsigned char *resp, int resplen) { |
7b575069 | 143 | int len,r; |
58a9e276 | 144 | int cmdlen = strlen(cmd); |
7b575069 MG |
145 | struct usbtmc_header *req; |
146 | ||
147 | sc->usb.bTag++; | |
148 | ||
149 | len = sizeof(struct usbtmc_header) + cmdlen; | |
150 | if (len%4) | |
151 | len += 4 - (len%4); | |
152 | ||
153 | req = calloc(1, len); | |
154 | if (req == NULL) { | |
155 | perror("calloc"); | |
156 | exit(EXIT_FAILURE); | |
157 | } | |
158 | ||
159 | req->MsgID = USBTMC_DEV_DEP_MSG_OUT; | |
160 | req->bTag = sc->usb.bTag; | |
161 | req->bTagInverse = ~sc->usb.bTag; | |
162 | req->TransferSize = LE32(cmdlen); | |
163 | req->bmTransferAttributes = USBTMC_TRANSFERATTRIB_EOM; | |
164 | memcpy(req->msg, cmd, cmdlen); | |
165 | ||
166 | if (sc->usb.brokenRigol) { | |
167 | r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out, | |
168 | (char*)req, sizeof(struct usbtmc_header), | |
169 | USB_TIMEOUT); | |
0aa0b761 | 170 | USB_ERROR("USBTMC_DEV_DEP_MSG_OUT1", r); |
7b575069 MG |
171 | |
172 | r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out, | |
173 | (char*)&(req->msg), len - sizeof(struct usbtmc_header), | |
174 | USB_TIMEOUT); | |
0aa0b761 | 175 | USB_ERROR("USBTMC_DEV_DEP_MSG_OUT2", r); |
7b575069 MG |
176 | } else { |
177 | r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out, | |
178 | (char*)req, len, USB_TIMEOUT); | |
0aa0b761 | 179 | USB_ERROR("USBTMC_DEV_DEP_MSG_OUT", r); |
7b575069 MG |
180 | } |
181 | ||
182 | free(req); | |
183 | ||
58a9e276 | 184 | if (resp != NULL && resplen != 0) { |
7b575069 MG |
185 | unsigned char *buff; |
186 | struct usbtmc_header *res; | |
187 | int bytes_read; | |
188 | ||
189 | sc->usb.bTag++; | |
190 | ||
191 | req = calloc(1, sizeof(struct usbtmc_header)); | |
192 | if (req == NULL) { | |
193 | perror("calloc"); | |
194 | exit(EXIT_FAILURE); | |
195 | } | |
196 | ||
197 | req->MsgID = USBTMC_REQUEST_DEV_DEP_MSG_IN; | |
198 | req->bTag = sc->usb.bTag; | |
199 | req->bTagInverse = ~sc->usb.bTag; | |
200 | req->TransferSize = LE32(sc->usb.wMaxPacketSize_in); | |
0aa0b761 | 201 | req->bmTransferAttributes = USBTMC_TRANSFERATTRIB_EOM; |
7b575069 MG |
202 | req->TermChar = 0; |
203 | ||
204 | /* send read command */ | |
205 | r=usb_bulk_write(sc->usb.dev, sc->usb.ep_bulk_out, | |
206 | (char*)req, sizeof(struct usbtmc_header), USB_TIMEOUT); | |
0aa0b761 | 207 | USB_ERROR("USBTMC_REQUEST_DEV_DEP_MSG_IN", r); |
7b575069 MG |
208 | |
209 | free(req); | |
210 | ||
211 | buff=malloc(sc->usb.wMaxPacketSize_in); | |
212 | if (buff == NULL) { | |
213 | perror("malloc"); | |
214 | exit(EXIT_FAILURE); | |
58a9e276 | 215 | } |
7b575069 MG |
216 | |
217 | r=usb_bulk_read(sc->usb.dev, sc->usb.ep_bulk_in, | |
218 | (char*)buff, sc->usb.wMaxPacketSize_in, USB_TIMEOUT); | |
0aa0b761 | 219 | USB_ERROR("USBTMC_DEV_DEP_MSG_IN1", r); |
7b575069 MG |
220 | |
221 | if (r < sizeof(struct usbtmc_header)) { | |
222 | fprintf(stderr, "Short read!\n"); | |
223 | return 0; | |
58a9e276 | 224 | } |
7b575069 MG |
225 | |
226 | bytes_read = r - sizeof(struct usbtmc_header); | |
227 | ||
228 | res = (struct usbtmc_header*)buff; | |
229 | len = LE32(res->TransferSize); | |
230 | ||
231 | memmove(buff, buff + sizeof(struct usbtmc_header), bytes_read); | |
232 | ||
233 | buff = realloc(buff, len); | |
234 | if (buff == NULL) { | |
235 | perror("realloc"); | |
236 | exit(EXIT_FAILURE); | |
237 | } | |
238 | ||
239 | while ((len - bytes_read) > 0) { | |
240 | r=usb_bulk_read(sc->usb.dev, sc->usb.ep_bulk_in, | |
241 | (char*)buff + bytes_read, len - bytes_read, | |
242 | USB_TIMEOUT); | |
0aa0b761 | 243 | USB_ERROR("USBTMC_DEV_DEP_MSG_INx", r); |
7b575069 MG |
244 | |
245 | bytes_read += r; | |
246 | } | |
247 | ||
248 | /* TODO: FIXME */ | |
249 | if (bytes_read > resplen) { | |
250 | fprintf(stderr, "Response buffer to small: %d instead of %d bytes!\n", | |
251 | resplen, bytes_read); | |
252 | bytes_read = resplen; | |
253 | } | |
254 | ||
255 | memcpy(resp, buff, bytes_read); | |
256 | free(buff); | |
257 | ||
258 | return bytes_read; | |
58a9e276 MG |
259 | } |
260 | return 0; | |
261 | } | |
262 | ||
7906b395 | 263 | void usbtmc_claim(struct scope *sc) |
ad9fbc05 | 264 | { |
7906b395 | 265 | usb_claim_interface(sc->usb.dev, 0); |
ad9fbc05 MG |
266 | } |
267 | ||
7906b395 | 268 | void usbtmc_release(struct scope *sc) |
ad9fbc05 | 269 | { |
7906b395 | 270 | usb_release_interface(sc->usb.dev, 0); |
ad9fbc05 MG |
271 | } |
272 | ||
483a564b | 273 | /* Initialize the scope. */ |
7906b395 | 274 | struct scope* usbtmc_initscope(void) { |
58a9e276 | 275 | int r; |
80564ddb | 276 | uint32_t vidpid; |
7906b395 | 277 | struct scope *sc; |
58a9e276 | 278 | |
7b575069 | 279 | /* Init libusb */ |
58a9e276 | 280 | usb_init(); |
7b575069 MG |
281 | /* Locate and open the scope */ |
282 | sc = usbtmc_find_scope(); | |
283 | if (!sc) { | |
2999345d | 284 | return NULL; |
58a9e276 | 285 | } |
7906b395 | 286 | |
7906b395 | 287 | usbtmc_claim(sc); |
90e416c4 | 288 | sc->usb.cap = usbtmc_get_capabilities(sc); |
483a564b | 289 | printf("Device status: 0x%x\n", usbtmc_status(sc)); |
7b575069 MG |
290 | /* The following code isn't really necessary, the program works |
291 | OK without it too. */ | |
80564ddb | 292 | r=usb_control_msg(sc->usb.dev, 0xC8, 9, 0, 0, (char*)&vidpid, 4, USB_TIMEOUT); |
7906b395 | 293 | usbtmc_release(sc); |
58a9e276 MG |
294 | if (r < 0) { |
295 | fprintf (stderr, "Error %d sending init message: %s\n", | |
296 | r, strerror (-r)); | |
297 | fprintf (stderr, "Do you have permission on the USB device?\n"); | |
298 | exit (1); | |
299 | } | |
80564ddb MG |
300 | if (LE32(vidpid)!=0x40005dc) { |
301 | fprintf(stderr,"Init: buff[%i]=%x\n",r,LE32(vidpid)); | |
58a9e276 | 302 | } |
7906b395 | 303 | return sc; |
58a9e276 | 304 | } |
b74fea90 | 305 | |
7906b395 | 306 | void usbtmc_close(struct scope *sc) |
b74fea90 | 307 | { |
7b575069 | 308 | /* Free up and exit */ |
7906b395 | 309 | usb_close(sc->usb.dev); |
b74fea90 | 310 | } |