]>
Commit | Line | Data |
---|---|---|
f594b3b0 GS |
1 | /* |
2 | * This file is part of the libsigrok project. | |
3 | * | |
208fcedc GS |
4 | * Copyright (C) 2019 Katherine J. Temkin <k@ktemkin.com> |
5 | * Copyright (C) 2019 Mikaela Szekely <qyriad@gmail.com> | |
f594b3b0 GS |
6 | * Copyright (C) 2023 Gerhard Sittig <gerhard.sittig@gmx.net> |
7 | * | |
8 | * This program is free software: you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation, either version 3 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
20 | */ | |
21 | ||
208fcedc GS |
22 | #include "config.h" |
23 | ||
24 | #include <stdio.h> | |
25 | #include <string.h> | |
26 | ||
f594b3b0 GS |
27 | #include "protocol.h" |
28 | ||
208fcedc GS |
29 | /* |
30 | * Communicate to GreatFET firmware, especially its Logic Analyzer mode. | |
31 | * | |
32 | * Firmware communication is done by two means: Control transfers to | |
33 | * EP0 for command execution. Bulk transfer from EP1 for sample data. | |
34 | * The sample data endpoint number is also provided by firmware in | |
35 | * responses to LA configuration requests. | |
36 | * | |
37 | * Control transfers have a fixed layout: 2x u32 class and verb numbers, | |
38 | * and u8[] payload data up to 512 bytes length. Payload layout depends | |
39 | * on commands and the verb's parameters. Binary data is represented in | |
40 | * LE format (firmware executes on Cortex-M). Strings are limited to a | |
41 | * maximum of 128 bytes. | |
42 | * | |
43 | * The set of commands used by this sigrok driver is minimal: | |
44 | * - Get the GreatFET's firmware version and serial number. | |
45 | * - String queries, a core verb, individual verb codes for the | |
46 | * version and for the serial number. | |
47 | * - Configure Logic Analyzer mode, start and stop captures. | |
48 | * - Configure takes a u32 samplerate and u8 channel count. Yields | |
49 | * u32 samplerate, u32 buffer size, u8 endpoint number. | |
50 | * - Start takes a u32 samplerate (does it? depending on firmware | |
51 | * version?). Empty/no response. | |
52 | * - Stop has empty/no request and response payloads. | |
53 | * | |
54 | * Firmware implementation details, observed during sigrok driver | |
55 | * creation. | |
56 | * - Serial number "strings" in responses may carry binary data and | |
57 | * not a text presentation of the serial number. It's uncertain | |
58 | * whether that is by design or an oversight. This sigrok driver | |
59 | * copes when it happens. (Remainder from another request which | |
60 | * provided the part number as well?) | |
61 | * - The GreatFET firmware is designed for exploration by host apps. | |
62 | * The embedded classes, their methods, their in/out parameters, | |
63 | * including builtin help texts, can get enumerated. This driver | |
64 | * does not use this discovery approach, assumes a given protocol. | |
65 | * - The NXP LPC4330 chip has 16 SGPIO pins. It's assumed that the | |
66 | * GreatFET firmware currently does not support more than 8 logic | |
67 | * channels due to constraints on bitbang machinery synchronization | |
68 | * which is under construction (IIUC, it's about pin banks that | |
69 | * run independently). When firmware versions get identified which | |
70 | * transparently (from the host's perspective) support more than | |
71 | * 8 channels, this host driver may need a little adjustment. | |
72 | * - The device can sample and stream 8 channels to the host at a | |
73 | * continuous rate of 40.8MHz. Higher rates are possible assuming | |
74 | * that fewer pins get sampled. The firmware then provides sample | |
75 | * memory where data taken at several sample points reside in the | |
76 | * same byte of sample memory. It helps that power-of-two bitness | |
77 | * is applied, IOW that there are either 1, 2, 4, or 8 bits per | |
78 | * sample point. Even when say 3 or 5 channels are enabled. The | |
79 | * device firmware may assume that a "dense" list of channels gets | |
80 | * enabled, the sigrok driver supports when some disabled channels | |
81 | * preceed other enabled channels. The device is then asked to get | |
82 | * as many channels as are needed to cover all enabled channels, | |
83 | * including potentially disabled channels before them. | |
84 | * - The LA configure request returns a samplerate that is supported | |
85 | * by the hardware/firmware combination and will be used during | |
86 | * acquisition. This returned rate is at least as high as the | |
87 | * requested samplerate. But might exceed the USB bandwidth which | |
88 | * the firmware is capable to sustain. Users may not expect that | |
89 | * since numbers add up differently from their perspective. In the | |
90 | * example of 3 enabled channels and a requested 72MHz samplerate, | |
91 | * the firmware will derive that it needs to sample 4 channels at | |
92 | * a 102MHz rate. Which exceeds its capabilities while users may | |
93 | * not be aware of these constraints. This sigrok driver attempts | |
94 | * to detect the condition, and not start an acquisition. And also | |
95 | * emits diagnostics (at info level which is silent by default). | |
96 | * It's assumed that users increase verbosity when diagnosing | |
97 | * issues they may experience. | |
98 | */ | |
99 | ||
100 | /* | |
101 | * Assign a symbolic name to endpoint 0 which is used for USB control | |
102 | * transfers. Although those "or 0" phrases don't take effect from the | |
103 | * compiler's perspective, they hopefully increase readability of the | |
104 | * USB related incantations. | |
105 | * | |
106 | * Endpoint 1 for sample data reception is not declared here. Its value | |
107 | * is taken from logic analyzer configure response. Which remains more | |
108 | * portable across firmware versions and supported device models. | |
109 | */ | |
110 | #define CONTROL_ENDPOINT 0 | |
111 | ||
112 | /* Header fields for USB control requests. */ | |
113 | #define LIBGREAT_REQUEST_NUMBER 0x65 | |
114 | #define LIBGREAT_VALUE_EXECUTE 0 | |
115 | #define LIBGREAT_FLAG_SKIP_RSP (1UL << 0) | |
116 | ||
117 | /* Classes and their verbs for core and logic analyzer. */ | |
118 | #define GREATFET_CLASS_CORE 0x000 | |
119 | #define CORE_VERB_READ_VERSION 0x1 | |
120 | #define CORE_VERB_READ_SERIAL 0x3 | |
121 | ||
122 | #define GREATFET_CLASS_LA 0x10d | |
123 | #define LA_VERB_CONFIGURE 0x0 | |
70c9a254 GS |
124 | #define LA_VERB_FIRST_PIN 0x1 |
125 | #define LA_VERB_ALT_PIN_MAP 0x2 | |
208fcedc GS |
126 | #define LA_VERB_START_CAPTURE 0x3 |
127 | #define LA_VERB_STOP_CAPTURE 0x4 | |
128 | ||
129 | /* Maximum text string and binary payload sizes for control requests. */ | |
130 | #define CORE_MAX_STRING_LENGTH 128 | |
131 | #define LOGIC_MAX_PAYLOAD_DATA 512 | |
132 | ||
133 | /* USB communication parameters, pool dimensions. */ | |
134 | #define LOGIC_DEFAULT_TIMEOUT 1000 | |
135 | #define TRANSFER_POOL_SIZE 16 | |
136 | #define TRANSFER_BUFFER_SIZE (256 * 1024) | |
137 | ||
138 | static int greatfet_process_receive_data(const struct sr_dev_inst *sdi, | |
139 | const uint8_t *data, size_t dlen); | |
140 | static int greatfet_cancel_transfers(const struct sr_dev_inst *sdi); | |
141 | ||
142 | /* Communicate a GreatFET request to EP0, and get its response. */ | |
143 | static int greatfet_ctrl_out_in(const struct sr_dev_inst *sdi, | |
144 | const uint8_t *tx_data, size_t tx_size, | |
145 | uint8_t *rx_data, size_t rx_size, unsigned int timeout_ms) | |
146 | { | |
147 | struct sr_usb_dev_inst *usb; | |
148 | uint16_t flags; | |
149 | int ret; | |
150 | size_t sent, rcvd; | |
151 | ||
152 | usb = sdi->conn; | |
153 | if (!usb) | |
154 | return SR_ERR_ARG; | |
155 | ||
156 | /* Caller can request to skip transmission of a response. */ | |
157 | flags = 0; | |
158 | if (!rx_size) | |
159 | flags |= LIBGREAT_FLAG_SKIP_RSP; | |
160 | ||
161 | /* Send USB Control OUT request. */ | |
162 | if (sr_log_loglevel_get() >= SR_LOG_SPEW) { | |
163 | GString *dump = sr_hexdump_new(tx_data, tx_size); | |
164 | sr_spew("USB out data: %s", dump->str); | |
165 | sr_hexdump_free(dump); | |
166 | } | |
167 | ret = libusb_control_transfer(usb->devhdl, | |
168 | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_ENDPOINT | | |
169 | LIBUSB_ENDPOINT_OUT | CONTROL_ENDPOINT, | |
170 | LIBGREAT_REQUEST_NUMBER, LIBGREAT_VALUE_EXECUTE, | |
171 | flags, (void *)tx_data, tx_size, timeout_ms); | |
172 | if (sr_log_loglevel_get() >= SR_LOG_SPEW) { | |
173 | const char *msg; | |
2c3fadf5 | 174 | msg = ret < 0 ? libusb_error_name(ret) : "-"; |
208fcedc GS |
175 | sr_spew("USB out, rc %d, %s", ret, msg); |
176 | } | |
177 | if (ret < 0) { | |
178 | /* Rate limit error messages. Skip "please retry" kinds. */ | |
179 | if (ret != LIBUSB_ERROR_BUSY) { | |
180 | sr_err("USB out transfer failed: %s (%d)", | |
181 | libusb_error_name(ret), ret); | |
182 | } | |
183 | return SR_ERR_IO; | |
184 | } | |
185 | sent = (size_t)ret; | |
186 | if (sent != tx_size) { | |
187 | sr_err("Short USB write: want %zu, got %zu: %s.", | |
188 | tx_size, sent, libusb_error_name(ret)); | |
189 | return SR_ERR_IO; | |
190 | } | |
191 | ||
192 | /* Get the USB Control IN response. */ | |
193 | if (!rx_size) | |
194 | return SR_OK; | |
195 | ret = libusb_control_transfer(usb->devhdl, | |
196 | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_ENDPOINT | | |
197 | LIBUSB_ENDPOINT_IN | CONTROL_ENDPOINT, | |
198 | LIBGREAT_REQUEST_NUMBER, LIBGREAT_VALUE_EXECUTE, | |
199 | 0, rx_data, rx_size, timeout_ms); | |
200 | if (sr_log_loglevel_get() >= SR_LOG_SPEW) { | |
201 | const char *msg; | |
2c3fadf5 | 202 | msg = ret < 0 ? libusb_error_name(ret) : "-"; |
208fcedc GS |
203 | sr_spew("USB in, rc %d, %s", ret, msg); |
204 | } | |
205 | if (ret < 0) { | |
206 | sr_err("USB in transfer failed: %s (%d)", | |
207 | libusb_error_name(ret), ret); | |
208 | return SR_ERR_IO; | |
209 | } | |
210 | rcvd = (size_t)ret; | |
211 | if (sr_log_loglevel_get() >= SR_LOG_SPEW) { | |
212 | GString *dump = sr_hexdump_new(rx_data, rcvd); | |
213 | sr_spew("USB in data: %s", dump->str); | |
214 | sr_hexdump_free(dump); | |
215 | } | |
216 | /* Short read, including zero length, is not fatal. */ | |
217 | ||
218 | return rcvd; | |
219 | } | |
220 | ||
221 | /* | |
222 | * Use a string buffer in devc for USB transfers. This simplifies | |
223 | * resource management in error paths. | |
224 | */ | |
225 | static int greatfet_prep_usb_buffer(const struct sr_dev_inst *sdi, | |
226 | uint8_t **tx_buff, size_t *tx_size, uint8_t **rx_buff, size_t *rx_size) | |
227 | { | |
228 | struct dev_context *devc; | |
229 | size_t want_len; | |
230 | GString *s; | |
231 | ||
232 | if (tx_buff) | |
233 | *tx_buff = NULL; | |
234 | if (tx_size) | |
235 | *tx_size = 0; | |
236 | if (rx_buff) | |
237 | *rx_buff = NULL; | |
238 | if (rx_size) | |
239 | *rx_size = 0; | |
240 | ||
241 | if (!sdi) | |
242 | return SR_ERR_ARG; | |
243 | devc = sdi->priv; | |
244 | if (!devc) | |
245 | return SR_ERR_ARG; | |
246 | ||
247 | /* | |
248 | * Allocate the string buffer unless previously done. | |
249 | * Ensure sufficient allocated space for request/response use. | |
250 | * Assume that glib GString is suitable to hold uint8_t[] data. | |
251 | */ | |
252 | if (!devc->usb_comm_buffer) { | |
253 | want_len = 2 * sizeof(uint32_t) + LOGIC_MAX_PAYLOAD_DATA; | |
254 | devc->usb_comm_buffer = g_string_sized_new(want_len); | |
255 | if (!devc->usb_comm_buffer) | |
256 | return SR_ERR_MALLOC; | |
257 | } | |
258 | ||
259 | /* Pass buffer start and size to the caller if requested. */ | |
260 | s = devc->usb_comm_buffer; | |
261 | if (tx_buff) | |
262 | *tx_buff = (uint8_t *)s->str; | |
263 | if (tx_size) | |
264 | *tx_size = s->allocated_len; | |
265 | if (rx_buff) | |
266 | *rx_buff = (uint8_t *)s->str; | |
267 | if (rx_size) | |
268 | *rx_size = s->allocated_len; | |
269 | ||
270 | return SR_OK; | |
271 | } | |
272 | ||
273 | /* Retrieve a string by executing a core service. */ | |
274 | static int greatfet_get_string(const struct sr_dev_inst *sdi, | |
275 | uint32_t verb, char **value) | |
276 | { | |
277 | uint8_t *req, *rsp; | |
278 | size_t rsp_size; | |
279 | uint8_t *wrptr; | |
280 | size_t wrlen, rcvd; | |
281 | const char *text; | |
282 | int ret; | |
283 | ||
284 | if (value) | |
285 | *value = NULL; | |
286 | if (!sdi) | |
287 | return SR_ERR_ARG; | |
288 | ret = greatfet_prep_usb_buffer(sdi, &req, NULL, &rsp, &rsp_size); | |
289 | if (ret != SR_OK) | |
290 | return ret; | |
291 | ||
292 | wrptr = req; | |
293 | write_u32le_inc(&wrptr, GREATFET_CLASS_CORE); | |
294 | write_u32le_inc(&wrptr, verb); | |
295 | wrlen = wrptr - req; | |
296 | ret = greatfet_ctrl_out_in(sdi, req, wrlen, | |
297 | rsp, rsp_size, LOGIC_DEFAULT_TIMEOUT); | |
298 | if (ret < 0) { | |
299 | sr_err("Cannot get core string."); | |
300 | return ret; | |
301 | } | |
302 | rcvd = (size_t)ret; | |
303 | ||
304 | rsp[rcvd] = '\0'; | |
305 | text = (const char *)rsp; | |
306 | sr_dbg("got string, verb %u, text (%zu) %s", verb, rcvd, text); | |
307 | if (value && *text) { | |
308 | *value = g_strndup(text, rcvd); | |
309 | } else if (value) { | |
310 | /* | |
311 | * g_strndup(3) does _not_ copy 'n' bytes. Instead it | |
312 | * truncates the result at the first NUL character seen. | |
313 | * That's why we need extra logic to pass binary data | |
314 | * to callers, to not violate API layers and confuse | |
315 | * USB readers with firmware implementation details | |
316 | * (that may be version dependent). | |
317 | * The very condition to determine whether text or some | |
318 | * binary data was received is a simple check for NUL | |
319 | * in the first position, implemented above. This is | |
320 | * GoodEnough(TM) to handle the firmware version case. | |
321 | */ | |
322 | *value = g_malloc0(rcvd + 1); | |
323 | memcpy(*value, text, rcvd); | |
324 | } | |
325 | ||
326 | return rcvd; | |
327 | } | |
328 | ||
329 | SR_PRIV int greatfet_get_serial_number(const struct sr_dev_inst *sdi) | |
330 | { | |
331 | struct dev_context *devc; | |
332 | char *text; | |
333 | int ret; | |
334 | const uint8_t *rdptr; | |
335 | size_t rdlen; | |
336 | GString *snr; | |
337 | uint32_t chunk; | |
338 | ||
339 | if (!sdi) | |
340 | return SR_ERR_ARG; | |
341 | devc = sdi->priv; | |
342 | if (!devc) | |
343 | return SR_ERR_ARG; | |
344 | ||
345 | ret = greatfet_get_string(sdi, CORE_VERB_READ_SERIAL, &text); | |
346 | if (ret < 0) | |
347 | return ret; | |
348 | if (!text) | |
349 | return SR_ERR_DATA; | |
350 | ||
351 | /* | |
352 | * The simple case, we got a text string. The 2019 K.Temkin | |
353 | * implementation took the received string as is. So there | |
354 | * are firmware versions which provide this presentation. | |
355 | */ | |
356 | if (*text) { | |
357 | devc->serial_number = text; | |
358 | return SR_OK; | |
359 | } | |
360 | ||
361 | /* | |
362 | * The complex case. The received "string" looks binary. Local | |
363 | * setups with v2018.12.1 and v2021.2.1 firmware versions yield | |
364 | * response data that does not look like a text string. Instead | |
365 | * it looks like four u32 fields which carry a binary value and | |
366 | * leading padding. Try that interpreation as well. Construct a | |
367 | * twenty character text presentation from that binary content. | |
368 | * | |
369 | * Implementation detail: Is the "leader" the part number which | |
370 | * a different firmware request may yield? Are there other verbs | |
371 | * which reliably yield the serial number in text format? | |
372 | */ | |
373 | rdptr = (const uint8_t *)text; | |
374 | rdlen = (size_t)ret; | |
375 | sr_dbg("trying to read serial nr \"text\" as binary"); | |
376 | if (rdlen != 4 * sizeof(uint32_t)) { | |
377 | g_free(text); | |
378 | return SR_ERR_DATA; | |
379 | } | |
380 | snr = g_string_sized_new(20 + 1); | |
381 | chunk = read_u32le_inc(&rdptr); | |
382 | if (chunk) { | |
383 | g_free(text); | |
384 | return SR_ERR_DATA; | |
385 | } | |
386 | chunk = read_u32le_inc(&rdptr); | |
387 | if (chunk) { | |
388 | g_free(text); | |
389 | return SR_ERR_DATA; | |
390 | } | |
391 | g_string_append_printf(snr, "%04" PRIx32, chunk); | |
392 | chunk = read_u32le_inc(&rdptr); | |
393 | g_string_append_printf(snr, "%08" PRIx32, chunk); | |
394 | chunk = read_u32le_inc(&rdptr); | |
395 | g_string_append_printf(snr, "%08" PRIx32, chunk); | |
396 | sr_dbg("got serial number text %s", snr->str); | |
397 | g_free(text); | |
398 | text = g_string_free(snr, FALSE); | |
399 | devc->serial_number = text; | |
400 | return SR_OK; | |
401 | } | |
402 | ||
403 | SR_PRIV int greatfet_get_version_number(const struct sr_dev_inst *sdi) | |
404 | { | |
405 | struct dev_context *devc; | |
406 | char *text; | |
407 | int ret; | |
408 | ||
409 | if (!sdi) | |
410 | return SR_ERR_ARG; | |
411 | devc = sdi->priv; | |
412 | if (!devc) | |
413 | return SR_ERR_ARG; | |
414 | ||
415 | ret = greatfet_get_string(sdi, CORE_VERB_READ_VERSION, &text); | |
416 | if (ret < SR_OK) | |
417 | return ret; | |
418 | ||
419 | devc->firmware_version = text; | |
420 | return SR_OK; | |
421 | } | |
422 | ||
423 | /* | |
424 | * Transmit a parameter-less request that wants no response. Or a | |
425 | * request with just a few bytes worth of parameter values, still | |
426 | * not expecting a response. | |
427 | */ | |
428 | static int greatfet_trivial_request(const struct sr_dev_inst *sdi, | |
429 | uint32_t cls, uint32_t verb, const uint8_t *tx_data, size_t tx_dlen) | |
430 | { | |
431 | struct dev_context *devc; | |
432 | uint8_t *req; | |
433 | uint8_t *wrptr; | |
434 | size_t wrlen; | |
435 | int ret; | |
436 | ||
437 | if (!sdi) | |
438 | return SR_ERR_ARG; | |
439 | devc = sdi->priv; | |
440 | if (!devc) | |
441 | return SR_ERR_ARG; | |
442 | ||
443 | ret = greatfet_prep_usb_buffer(sdi, &req, NULL, NULL, NULL); | |
444 | if (ret != SR_OK) | |
445 | return ret; | |
446 | ||
447 | wrptr = req; | |
448 | write_u32le_inc(&wrptr, cls); | |
449 | write_u32le_inc(&wrptr, verb); | |
450 | while (tx_dlen--) | |
451 | write_u8_inc(&wrptr, *tx_data++); | |
452 | wrlen = wrptr - req; | |
453 | return greatfet_ctrl_out_in(sdi, req, wrlen, | |
454 | NULL, 0, LOGIC_DEFAULT_TIMEOUT); | |
455 | } | |
456 | ||
457 | /* | |
458 | * Transmit a "configure logic analyzer" request. Gets the resulting | |
459 | * samplerate (which can differ from requested values) and endpoint | |
460 | * (which is very useful for compatibility across devices/versions). | |
461 | * Also gets the device firmware's buffer size, which is only used | |
462 | * for information, while the host assumes a fixed larger buffer size | |
463 | * for its own purposes. | |
464 | */ | |
465 | static int greatfet_logic_config(const struct sr_dev_inst *sdi) | |
466 | { | |
467 | struct dev_context *devc; | |
468 | struct dev_acquisition_t *acq; | |
469 | struct sr_usb_dev_inst *usb; | |
470 | uint8_t *req, *rsp; | |
471 | size_t rsp_size; | |
472 | uint8_t *wrptr; | |
473 | size_t wrlen, rcvd, want_len; | |
474 | const uint8_t *rdptr; | |
475 | uint64_t rate, bw; | |
476 | size_t bufsize; | |
477 | uint8_t ep; | |
478 | char *print_bw; | |
479 | int ret; | |
480 | ||
481 | if (!sdi) | |
482 | return SR_ERR_ARG; | |
483 | devc = sdi->priv; | |
484 | usb = sdi->conn; | |
485 | if (!devc || !usb) | |
486 | return SR_ERR_ARG; | |
487 | acq = &devc->acquisition; | |
488 | ||
489 | ret = greatfet_prep_usb_buffer(sdi, &req, NULL, &rsp, &rsp_size); | |
490 | if (ret != SR_OK) | |
491 | return ret; | |
492 | ||
70c9a254 GS |
493 | /* |
494 | * Optionally request to capture the upper pin bank. The device | |
495 | * can sample from pins starting at number 8. We use the feature | |
496 | * transparently when the first 8 channels are disabled. | |
497 | * | |
498 | * Values different from 0 or 8 are not used here. The details | |
499 | * of the SGPIO hardware implementation degrade performance in | |
500 | * this case. Its use is not desirable for users. | |
501 | */ | |
502 | sr_dbg("about to config first pin, upper %d", acq->use_upper_pins); | |
503 | wrptr = req; | |
504 | write_u32le_inc(&wrptr, GREATFET_CLASS_LA); | |
505 | write_u32le_inc(&wrptr, LA_VERB_FIRST_PIN); | |
506 | write_u8_inc(&wrptr, acq->use_upper_pins ? 8 : 0); | |
507 | wrlen = wrptr - req; | |
508 | ret = greatfet_ctrl_out_in(sdi, req, wrlen, | |
509 | NULL, 0, LOGIC_DEFAULT_TIMEOUT); | |
510 | if (ret < 0) { | |
511 | sr_err("Cannot configure first capture pin."); | |
512 | return ret; | |
513 | } | |
514 | ||
515 | /* Disable alt pin mapping, just for good measure. */ | |
516 | sr_dbg("about to config alt pin mapping"); | |
517 | wrptr = req; | |
518 | write_u32le_inc(&wrptr, GREATFET_CLASS_LA); | |
519 | write_u32le_inc(&wrptr, LA_VERB_ALT_PIN_MAP); | |
520 | write_u8_inc(&wrptr, 0); | |
521 | wrlen = wrptr - req; | |
522 | ret = greatfet_ctrl_out_in(sdi, req, wrlen, | |
523 | NULL, 0, LOGIC_DEFAULT_TIMEOUT); | |
524 | if (ret < 0) { | |
525 | sr_err("Cannot configure alt pin mapping."); | |
526 | return ret; | |
527 | } | |
528 | ||
208fcedc GS |
529 | /* |
530 | * Prepare to get a specific amount of receive data. The logic | |
531 | * analyzer configure response is strictly binary, in contrast | |
532 | * to variable length string responses elsewhere. | |
533 | */ | |
534 | want_len = 2 * sizeof(uint32_t) + sizeof(uint8_t); | |
535 | if (rsp_size < want_len) | |
536 | return SR_ERR_BUG; | |
537 | rsp_size = want_len; | |
538 | ||
539 | sr_dbg("about to config LA, rate %" PRIu64 ", chans %zu", | |
540 | devc->samplerate, acq->capture_channels); | |
541 | wrptr = req; | |
542 | write_u32le_inc(&wrptr, GREATFET_CLASS_LA); | |
543 | write_u32le_inc(&wrptr, LA_VERB_CONFIGURE); | |
544 | write_u32le_inc(&wrptr, devc->samplerate); | |
545 | write_u8_inc(&wrptr, acq->capture_channels); | |
546 | wrlen = wrptr - req; | |
547 | ret = greatfet_ctrl_out_in(sdi, req, wrlen, | |
548 | rsp, rsp_size, LOGIC_DEFAULT_TIMEOUT); | |
549 | if (ret < 0) { | |
550 | sr_err("Cannot configure logic analyzer mode."); | |
551 | return ret; | |
552 | } | |
553 | rcvd = (size_t)ret; | |
554 | if (rcvd != want_len) { | |
555 | sr_warn("Unexpected LA configuration response length."); | |
556 | return SR_ERR_DATA; | |
557 | } | |
558 | ||
559 | rdptr = rsp; | |
560 | rate = read_u32le_inc(&rdptr); | |
561 | bufsize = read_u32le_inc(&rdptr); | |
562 | ep = read_u8_inc(&rdptr); | |
563 | sr_dbg("LA configured, rate %" PRIu64 ", buf %zu, ep %" PRIu8, | |
564 | rate, bufsize, ep); | |
565 | if (rate != devc->samplerate) { | |
566 | sr_info("Configuration feedback, want rate %" PRIu64 ", got rate %." PRIu64, | |
567 | devc->samplerate, rate); | |
568 | devc->samplerate = rate; | |
569 | } | |
570 | acq->capture_samplerate = rate; | |
571 | acq->firmware_bufsize = bufsize; | |
572 | acq->samples_endpoint = ep; | |
573 | ||
574 | /* | |
575 | * The firmware does not reject requests that would exceed | |
576 | * its capabilities. Yet the device becomes unaccessible when | |
577 | * START is sent in that situation. (Observed with v2021.2.1 | |
578 | * firmware.) | |
579 | * | |
580 | * Assume a maximum USB bandwidth that we don't want to exceed. | |
581 | * It's protecting the GreatFET's firmware. It's not a statement | |
582 | * on the host's capability of keeping up with the GreatFET's | |
583 | * firmware capabilities. :) | |
584 | */ | |
585 | print_bw = sr_samplerate_string(acq->capture_samplerate); | |
586 | sr_info("Capture configuration: %zu channels, samplerate %s.", | |
587 | acq->capture_channels, print_bw); | |
588 | g_free(print_bw); | |
589 | bw = acq->capture_samplerate * 8 / acq->points_per_byte; | |
70c9a254 GS |
590 | if (!acq->use_upper_pins) |
591 | bw *= acq->unit_size; | |
208fcedc GS |
592 | print_bw = sr_si_string_u64(bw, "bps"); |
593 | sr_info("Resulting USB bandwidth: %s.", print_bw); | |
594 | g_free(print_bw); | |
595 | if (acq->bandwidth_threshold && bw > acq->bandwidth_threshold) { | |
596 | sr_err("Configuration exceeds bandwidth limit. Aborting."); | |
597 | return SR_ERR_SAMPLERATE; | |
598 | } | |
599 | ||
600 | return SR_OK; | |
601 | } | |
602 | ||
603 | /* Transmit "start logic capture" request. */ | |
604 | static int greatfet_logic_start(const struct sr_dev_inst *sdi) | |
605 | { | |
606 | int ret; | |
607 | ||
608 | ret = greatfet_trivial_request(sdi, | |
609 | GREATFET_CLASS_LA, LA_VERB_START_CAPTURE, NULL, 0); | |
610 | sr_dbg("LA start, USB out, rc %d", ret); | |
611 | if (ret != SR_OK) | |
612 | sr_err("Cannot start logic analyzer capture."); | |
613 | ||
614 | return ret; | |
615 | } | |
616 | ||
617 | /* Transmit "stop logic capture" request. */ | |
618 | static int greatfet_logic_stop(const struct sr_dev_inst *sdi) | |
619 | { | |
620 | struct dev_context *devc; | |
621 | struct dev_acquisition_t *acq; | |
622 | int ret; | |
623 | ||
624 | devc = sdi->priv; | |
625 | if (!devc) | |
626 | return SR_ERR_ARG; | |
627 | acq = &devc->acquisition; | |
628 | ||
629 | /* Only send STOP when START was sent before. */ | |
630 | if (!acq->start_req_sent) | |
631 | return SR_OK; | |
632 | ||
633 | ret = greatfet_trivial_request(sdi, | |
634 | GREATFET_CLASS_LA, LA_VERB_STOP_CAPTURE, NULL, 0); | |
635 | sr_dbg("LA stop, USB out, rc %d", ret); | |
636 | if (ret == SR_OK) | |
637 | acq->start_req_sent = FALSE; | |
638 | else | |
639 | sr_warn("Cannot stop logic analyzer capture in the device."); | |
640 | ||
641 | return ret; | |
642 | } | |
643 | ||
644 | /* | |
645 | * Determine how many channels the device firmware needs to sample. | |
646 | * So that resulting capture data will cover all those logic channels | |
647 | * which currently are enabled on the sigrok side. We (have to) accept | |
648 | * when the sequence of enabled channels "has gaps" in them. Disabling | |
649 | * channels in the middle of the pin groups is a user's choice that we | |
650 | * need to obey. The count of enabled channels is not good enough for | |
651 | * the purpose of acquisition, it must be "a maximum index" or a total | |
652 | * to-get-sampled count. | |
653 | */ | |
654 | static int greatfet_calc_capture_chans(const struct sr_dev_inst *sdi) | |
655 | { | |
656 | struct dev_context *devc; | |
657 | struct dev_acquisition_t *acq; | |
658 | GSList *l; | |
659 | struct sr_channel *ch; | |
660 | int last_used_idx; | |
70c9a254 | 661 | uint16_t pin_map; |
208fcedc | 662 | size_t logic_ch_count, en_ch_count, fw_ch_count; |
70c9a254 | 663 | gboolean have_upper, have_lower, use_upper_pins; |
208fcedc GS |
664 | int ret; |
665 | ||
666 | if (!sdi) | |
667 | return SR_ERR_ARG; | |
668 | devc = sdi->priv; | |
669 | if (!devc) | |
670 | return SR_ERR_ARG; | |
671 | acq = &devc->acquisition; | |
672 | ||
673 | last_used_idx = -1; | |
674 | logic_ch_count = 0; | |
70c9a254 | 675 | pin_map = 0; |
208fcedc GS |
676 | for (l = sdi->channels; l; l = l->next) { |
677 | ch = l->data; | |
678 | if (ch->type != SR_CHANNEL_LOGIC) | |
679 | continue; | |
680 | logic_ch_count++; | |
681 | if (!ch->enabled) | |
682 | continue; | |
683 | if (last_used_idx < ch->index) | |
684 | last_used_idx = ch->index; | |
70c9a254 | 685 | pin_map |= 1UL << ch->index; |
208fcedc GS |
686 | } |
687 | en_ch_count = last_used_idx + 1; | |
688 | sr_dbg("channel count, logic %zu, highest enabled idx %d -> count %zu", | |
689 | logic_ch_count, last_used_idx, en_ch_count); | |
690 | if (!en_ch_count) | |
691 | return SR_ERR_ARG; | |
70c9a254 GS |
692 | have_upper = pin_map & 0xff00; |
693 | have_lower = pin_map & 0x00ff; | |
694 | use_upper_pins = have_upper && !have_lower; | |
695 | if (use_upper_pins) { | |
696 | sr_dbg("ch mask 0x%04x -> using upper pins", pin_map); | |
697 | last_used_idx -= 8; | |
698 | en_ch_count -= 8; | |
699 | } | |
700 | if (have_upper && !use_upper_pins) | |
701 | sr_warn("Multi-bank capture, check firmware support!"); | |
208fcedc GS |
702 | |
703 | acq->capture_channels = en_ch_count; | |
70c9a254 | 704 | acq->use_upper_pins = use_upper_pins; |
208fcedc GS |
705 | ret = sr_next_power_of_two(last_used_idx, NULL, &fw_ch_count); |
706 | if (ret != SR_OK) | |
707 | return ret; | |
708 | if (!fw_ch_count) | |
709 | return SR_ERR_ARG; | |
710 | if (fw_ch_count > 8) { | |
711 | acq->unit_size = sizeof(uint16_t); | |
712 | acq->points_per_byte = 1; | |
713 | } else { | |
714 | acq->unit_size = sizeof(uint8_t); | |
70c9a254 GS |
715 | if (acq->use_upper_pins) |
716 | acq->unit_size = sizeof(uint16_t); | |
208fcedc GS |
717 | acq->points_per_byte = 8 / fw_ch_count; |
718 | } | |
719 | acq->channel_shift = fw_ch_count % 8; | |
720 | sr_dbg("unit %zu, dense %d -> shift %zu, points %zu", | |
721 | acq->unit_size, !!acq->channel_shift, | |
722 | acq->channel_shift, acq->points_per_byte); | |
723 | ||
724 | return SR_OK; | |
725 | } | |
726 | ||
727 | /* | |
728 | * This is an opportunity to adapt the host's USB transfer size to | |
729 | * the value which the device firmware has provided in the LA config | |
730 | * response. | |
731 | * | |
732 | * We let the opportunity pass. Always use a fixed value for the host | |
733 | * configuration. BULK transfers will adopt, which reduces the number | |
734 | * of transfer completion events for the host. | |
735 | * | |
736 | * Notice that transfer size adjustment is _not_ a means to get user | |
737 | * feedback earlier at low samplerates. This may be done in other | |
738 | * drivers but does not take effect here. Because a buffer is used to | |
739 | * submit sample values to the session. When in doubt, the feed queue | |
740 | * needs flushing. | |
741 | * | |
742 | * TODO Consider whether sample data needs flushing when sample rates | |
743 | * are low and buffers are deep. Ideally use common feed queue support | |
744 | * if that becomes available in the future. Translate low samplerates | |
745 | * (and channel counts) to the amount of samples after which the queue | |
746 | * should get flushed. | |
747 | * | |
748 | * This implementation assumes that samplerates start at 1MHz, and | |
749 | * flushing is not necessary. | |
750 | */ | |
751 | static int greatfet_calc_submit_size(const struct sr_dev_inst *sdi) | |
752 | { | |
753 | struct dev_context *devc; | |
754 | struct dev_transfers_t *dxfer; | |
755 | ||
756 | if (!sdi) | |
757 | return SR_ERR_ARG; | |
758 | devc = sdi->priv; | |
759 | if (!devc) | |
760 | return SR_ERR_ARG; | |
761 | dxfer = &devc->transfers; | |
762 | ||
763 | dxfer->capture_bufsize = dxfer->transfer_bufsize; | |
764 | return SR_OK; | |
765 | } | |
766 | ||
767 | /* | |
768 | * This routine is local to protocol.c and does mere data manipulation | |
769 | * and a single attempt at sending "logic analyzer stop" to the device. | |
770 | * This routine gets invoked from USB transfer completion callbacks as | |
771 | * well as periodic timer or data availability callbacks. It is essential | |
772 | * to not spend extended periods of time here. | |
773 | */ | |
774 | static void greatfet_abort_acquisition_quick(const struct sr_dev_inst *sdi) | |
775 | { | |
776 | struct dev_context *devc; | |
777 | struct dev_acquisition_t *acq; | |
778 | ||
779 | if (!sdi) | |
780 | return; | |
781 | devc = sdi->priv; | |
782 | if (!devc) | |
783 | return; | |
784 | acq = &devc->acquisition; | |
785 | ||
786 | if (acq->acquisition_state == ACQ_RECEIVE) | |
787 | acq->acquisition_state = ACQ_SHUTDOWN; | |
788 | ||
789 | (void)greatfet_logic_stop(sdi); | |
790 | greatfet_cancel_transfers(sdi); | |
791 | ||
70c9a254 GS |
792 | if (acq->feed_queue) |
793 | feed_queue_logic_flush(acq->feed_queue); | |
208fcedc GS |
794 | } |
795 | ||
796 | /* Allocate USB transfers and associated receive buffers. */ | |
797 | static int greatfet_allocate_transfers(const struct sr_dev_inst *sdi) | |
798 | { | |
799 | struct dev_context *devc; | |
800 | struct dev_transfers_t *dxfer; | |
801 | size_t alloc_size, idx; | |
802 | struct libusb_transfer *xfer; | |
803 | ||
804 | if (!sdi) | |
805 | return SR_ERR_ARG; | |
806 | devc = sdi->priv; | |
807 | if (!devc) | |
808 | return SR_ERR_ARG; | |
809 | dxfer = &devc->transfers; | |
810 | ||
811 | dxfer->transfer_bufsize = TRANSFER_BUFFER_SIZE; | |
812 | dxfer->transfers_count = TRANSFER_POOL_SIZE; | |
813 | ||
814 | alloc_size = dxfer->transfers_count * dxfer->transfer_bufsize; | |
815 | dxfer->transfer_buffer = g_malloc0(alloc_size); | |
816 | if (!dxfer->transfer_buffer) | |
817 | return SR_ERR_MALLOC; | |
818 | ||
819 | alloc_size = dxfer->transfers_count; | |
820 | alloc_size *= sizeof(dxfer->transfers[0]); | |
821 | dxfer->transfers = g_malloc0(alloc_size); | |
822 | if (!dxfer->transfers) | |
823 | return SR_ERR_MALLOC; | |
824 | ||
825 | for (idx = 0; idx < dxfer->transfers_count; idx++) { | |
826 | xfer = libusb_alloc_transfer(0); | |
827 | if (!xfer) | |
828 | return SR_ERR_MALLOC; | |
829 | dxfer->transfers[idx] = xfer; | |
830 | } | |
831 | ||
832 | return SR_OK; | |
833 | } | |
834 | ||
835 | /* Submit USB transfers for reception, registers the data callback. */ | |
836 | static int greatfet_prepare_transfers(const struct sr_dev_inst *sdi, | |
837 | libusb_transfer_cb_fn callback) | |
838 | { | |
839 | struct dev_context *devc; | |
840 | struct dev_acquisition_t *acq; | |
841 | struct dev_transfers_t *dxfer; | |
842 | struct sr_usb_dev_inst *conn; | |
843 | uint8_t ep; | |
844 | size_t submit_length; | |
845 | size_t off, idx; | |
846 | struct libusb_transfer *xfer; | |
847 | int ret; | |
848 | ||
849 | if (!sdi) | |
850 | return SR_ERR_ARG; | |
851 | devc = sdi->priv; | |
852 | conn = sdi->conn; | |
853 | if (!devc || !conn) | |
854 | return SR_ERR_ARG; | |
855 | acq = &devc->acquisition; | |
856 | dxfer = &devc->transfers; | |
857 | ||
858 | ep = acq->samples_endpoint; | |
859 | ret = greatfet_calc_submit_size(sdi); | |
860 | if (ret != SR_OK) | |
861 | return ret; | |
862 | submit_length = dxfer->capture_bufsize; | |
863 | if (submit_length > dxfer->transfer_bufsize) | |
864 | submit_length = dxfer->transfer_bufsize; | |
865 | sr_dbg("prep xfer, ep %u (%u), len %zu", | |
866 | ep, ep & ~LIBUSB_ENDPOINT_IN, submit_length); | |
867 | ||
868 | dxfer->active_transfers = 0; | |
869 | off = 0; | |
870 | for (idx = 0; idx < dxfer->transfers_count; idx++) { | |
871 | xfer = dxfer->transfers[idx]; | |
872 | libusb_fill_bulk_transfer(xfer, conn->devhdl, ep, | |
873 | &dxfer->transfer_buffer[off], submit_length, | |
874 | callback, (void *)sdi, 0); | |
875 | if (!xfer->buffer) | |
876 | return SR_ERR_MALLOC; | |
877 | ret = libusb_submit_transfer(xfer); | |
878 | if (ret != 0) { | |
879 | sr_spew("submit bulk xfer failed, idx %zu, %d: %s", | |
880 | idx, ret, libusb_error_name(ret)); | |
881 | return SR_ERR_IO; | |
882 | } | |
883 | dxfer->active_transfers++; | |
884 | off += submit_length; | |
885 | } | |
886 | ||
887 | return SR_OK; | |
888 | } | |
889 | ||
890 | /* | |
891 | * Initiate the termination of an acquisition. Cancel all USB transfers. | |
892 | * Their completion will drive further progress including resource | |
893 | * release. | |
894 | */ | |
895 | static int greatfet_cancel_transfers(const struct sr_dev_inst *sdi) | |
896 | { | |
897 | struct dev_context *devc; | |
898 | struct dev_transfers_t *dxfer; | |
899 | size_t idx; | |
900 | struct libusb_transfer *xfer; | |
901 | ||
902 | if (!sdi) | |
903 | return SR_ERR_ARG; | |
904 | devc = sdi->priv; | |
905 | if (!devc) | |
906 | return SR_ERR_ARG; | |
907 | dxfer = &devc->transfers; | |
70c9a254 GS |
908 | if (!dxfer->transfers) |
909 | return SR_OK; | |
208fcedc GS |
910 | |
911 | for (idx = 0; idx < dxfer->transfers_count; idx++) { | |
912 | xfer = dxfer->transfers[idx]; | |
913 | if (!xfer) | |
914 | continue; | |
915 | (void)libusb_cancel_transfer(xfer); | |
916 | /* | |
917 | * Cancelled transfers will cause acquisitions to abort | |
918 | * in their callback. Keep the "active" count as is. | |
919 | */ | |
920 | } | |
921 | ||
922 | return SR_OK; | |
923 | } | |
924 | ||
925 | /* | |
926 | * Free an individual transfer during its callback's execution. | |
927 | * Releasing the last USB transfer also happens to drive more of | |
928 | * the shutdown path. | |
929 | */ | |
930 | static void greatfet_free_transfer(const struct sr_dev_inst *sdi, | |
931 | struct libusb_transfer *xfer) | |
932 | { | |
933 | struct drv_context *drvc; | |
934 | struct sr_usb_dev_inst *usb; | |
935 | struct dev_context *devc; | |
936 | struct dev_acquisition_t *acq; | |
937 | struct dev_transfers_t *dxfer; | |
938 | size_t idx; | |
939 | ||
940 | if (!sdi || !sdi->driver) | |
941 | return; | |
942 | drvc = sdi->driver->context; | |
943 | usb = sdi->conn; | |
944 | devc = sdi->priv; | |
945 | if (!drvc || !usb || !devc) | |
946 | return; | |
947 | acq = &devc->acquisition; | |
948 | dxfer = &devc->transfers; | |
949 | ||
950 | /* Void the transfer in the driver's list of transfers. */ | |
951 | for (idx = 0; idx < dxfer->transfers_count; idx++) { | |
952 | if (xfer != dxfer->transfers[idx]) | |
953 | continue; | |
954 | dxfer->transfers[idx] = NULL; | |
955 | dxfer->active_transfers--; | |
956 | break; | |
957 | } | |
958 | ||
959 | /* Release the transfer from libusb use. */ | |
960 | libusb_free_transfer(xfer); | |
961 | ||
962 | /* Done here when more transfers are still pending. */ | |
963 | if (!dxfer->active_transfers) | |
964 | return; | |
965 | ||
966 | /* | |
967 | * The last USB transfer has been freed after completion. | |
968 | * Post process the previous acquisition's execution. | |
969 | */ | |
970 | (void)greatfet_stop_acquisition(sdi); | |
971 | if (acq->frame_begin_sent) { | |
972 | std_session_send_df_end(sdi); | |
973 | acq->frame_begin_sent = FALSE; | |
974 | } | |
975 | usb_source_remove(sdi->session, drvc->sr_ctx); | |
976 | if (acq->samples_interface_claimed) { | |
977 | libusb_release_interface(usb->devhdl, acq->samples_interface); | |
978 | acq->samples_interface_claimed = FALSE; | |
979 | } | |
980 | feed_queue_logic_free(acq->feed_queue); | |
981 | acq->feed_queue = NULL; | |
982 | acq->acquisition_state = ACQ_IDLE; | |
983 | } | |
984 | ||
985 | /* | |
986 | * Callback for the completion of previously submitted USB transfers. | |
987 | * Processes received sample memory content. Initiates termination of | |
988 | * the current acquisition in case of failed processing or failed | |
989 | * communication to the acquisition device. Also initiates termination | |
990 | * when previously configured acquisition limits were reached. | |
991 | */ | |
992 | static void LIBUSB_CALL xfer_complete_cb(struct libusb_transfer *xfer) | |
993 | { | |
994 | struct sr_dev_inst *sdi; | |
995 | struct dev_context *devc; | |
996 | struct dev_acquisition_t *acq; | |
997 | const uint8_t *data; | |
998 | size_t dlen; | |
999 | gboolean was_completed, was_cancelled; | |
1000 | gboolean has_timedout, device_gone, is_stalled; | |
1001 | int level; | |
1002 | gboolean shall_abort; | |
1003 | int ret; | |
1004 | ||
1005 | sdi = xfer ? xfer->user_data : NULL; | |
1006 | devc = sdi ? sdi->priv : NULL; | |
1007 | if (!sdi || !devc) { | |
1008 | /* ShouldNotHappen(TM) */ | |
1009 | sr_warn("Completion of unregistered USB transfer."); | |
1010 | libusb_free_transfer(xfer); | |
1011 | return; | |
1012 | } | |
1013 | acq = &devc->acquisition; | |
1014 | ||
1015 | /* | |
1016 | * Outside of an acquisition? Or in its shutdown path? | |
1017 | * Just release the USB transfer, don't process its data. | |
1018 | */ | |
1019 | if (acq->acquisition_state != ACQ_RECEIVE) { | |
1020 | greatfet_free_transfer(sdi, xfer); | |
1021 | return; | |
1022 | } | |
1023 | ||
1024 | /* | |
1025 | * Avoid the unfortunate libusb identifiers and data types. | |
1026 | * Simplify USB transfer status checks for later code paths. | |
1027 | * Optionally log the USB transfers' completion. | |
1028 | */ | |
1029 | data = xfer->buffer; | |
1030 | dlen = xfer->actual_length; | |
1031 | was_completed = xfer->status == LIBUSB_TRANSFER_COMPLETED; | |
1032 | has_timedout = xfer->status == LIBUSB_TRANSFER_TIMED_OUT; | |
1033 | was_cancelled = xfer->status == LIBUSB_TRANSFER_CANCELLED; | |
1034 | device_gone = xfer->status == LIBUSB_TRANSFER_NO_DEVICE; | |
1035 | is_stalled = xfer->status == LIBUSB_TRANSFER_STALL; | |
1036 | level = sr_log_loglevel_get(); | |
1037 | if (level >= SR_LOG_SPEW) { | |
1038 | sr_spew("USB transfer, status %s, byte count %zu.", | |
1039 | libusb_error_name(xfer->status), dlen); | |
1040 | } else if (level >= SR_LOG_DBG && !was_completed) { | |
1041 | sr_dbg("USB transfer, status %s, byte count %zu.", | |
1042 | libusb_error_name(xfer->status), dlen); | |
1043 | } | |
1044 | ||
1045 | /* | |
1046 | * Timed out transfers may contain a little data. Warn but accept. | |
1047 | * Typical case will be completed transfers. Cancelled transfers | |
1048 | * are seen in shutdown paths, their data need not get processed. | |
1049 | * Terminate acquisition in case of communication or processing | |
1050 | * failure, or when limits were reached. | |
1051 | */ | |
1052 | shall_abort = FALSE; | |
1053 | if (has_timedout) | |
1054 | sr_warn("USB transfer timed out. Using available data."); | |
1055 | if (was_completed || has_timedout) { | |
1056 | ret = greatfet_process_receive_data(sdi, data, dlen); | |
1057 | if (ret != SR_OK) { | |
1058 | sr_err("Error processing sample data. Aborting."); | |
1059 | shall_abort = TRUE; | |
1060 | } | |
1061 | if (acq->acquisition_state != ACQ_RECEIVE) { | |
1062 | sr_dbg("Sample data processing ends acquisition."); | |
1063 | feed_queue_logic_flush(acq->feed_queue); | |
1064 | shall_abort = TRUE; | |
1065 | } | |
1066 | } else if (device_gone) { | |
1067 | sr_err("Device gone during USB transfer. Aborting."); | |
1068 | shall_abort = TRUE; | |
1069 | } else if (was_cancelled) { | |
1070 | sr_dbg("Cancelled USB transfer. Terminating acquisition."); | |
1071 | shall_abort = TRUE; | |
1072 | } else if (is_stalled) { | |
1073 | sr_err("Device firmware is stalled on USB transfer. Aborting."); | |
1074 | shall_abort = TRUE; | |
1075 | } else { | |
1076 | sr_err("USB transfer failed (%s). Aborting.", | |
1077 | libusb_error_name(xfer->status)); | |
1078 | shall_abort = TRUE; | |
1079 | } | |
1080 | ||
1081 | /* | |
1082 | * Resubmit the USB transfer for continued reception of sample | |
1083 | * data. Or release the transfer when acquisition terminates | |
1084 | * after errors were seen, or limits were reached, or the end | |
1085 | * was requested in other regular ways. | |
1086 | * | |
1087 | * In the case of error or other terminating conditions cancel | |
1088 | * the currently executing acquisition, end all USB transfers. | |
1089 | */ | |
1090 | if (!shall_abort) { | |
1091 | ret = libusb_submit_transfer(xfer); | |
1092 | if (ret < 0) { | |
1093 | sr_err("Cannot resubmit USB transfer. Aborting."); | |
1094 | shall_abort = TRUE; | |
1095 | } | |
1096 | } | |
1097 | if (shall_abort) { | |
1098 | greatfet_free_transfer(sdi, xfer); | |
1099 | greatfet_abort_acquisition_quick(sdi); | |
1100 | } | |
1101 | } | |
1102 | ||
1103 | /* The public protocol.c API to start/stop acquisitions. */ | |
1104 | ||
1105 | SR_PRIV int greatfet_setup_acquisition(const struct sr_dev_inst *sdi) | |
1106 | { | |
1107 | int ret; | |
1108 | ||
1109 | ret = greatfet_allocate_transfers(sdi); | |
1110 | if (ret != SR_OK) | |
1111 | return ret; | |
1112 | ||
1113 | ret = greatfet_calc_capture_chans(sdi); | |
1114 | if (ret != SR_OK) | |
1115 | return ret; | |
1116 | ||
1117 | return SR_OK; | |
1118 | } | |
1119 | ||
1120 | SR_PRIV int greatfet_start_acquisition(const struct sr_dev_inst *sdi) | |
1121 | { | |
1122 | struct dev_context *devc; | |
1123 | struct dev_acquisition_t *acq; | |
1124 | struct sr_usb_dev_inst *usb; | |
1125 | int ret; | |
1126 | ||
1127 | if (!sdi) | |
1128 | return SR_ERR_ARG; | |
1129 | devc = sdi->priv; | |
1130 | usb = sdi->conn; | |
1131 | if (!devc || !usb) | |
1132 | return SR_ERR_ARG; | |
1133 | acq = &devc->acquisition; | |
1134 | ||
1135 | /* | |
1136 | * Configure the logic analyzer. Claim the USB interface. This | |
1137 | * part of the sequence is not time critical. | |
1138 | */ | |
1139 | ret = greatfet_logic_config(sdi); | |
1140 | if (ret != SR_OK) | |
1141 | return ret; | |
1142 | ||
1143 | ret = libusb_claim_interface(usb->devhdl, acq->samples_interface); | |
1144 | acq->samples_interface_claimed = ret == 0; | |
1145 | ||
1146 | /* | |
1147 | * Ideally we could submit USB transfers before sending the | |
1148 | * logic analyzer start request. Experience suggests that this | |
1149 | * results in libusb IO errors. That's why we need to accept the | |
1150 | * window of blindness between sending the LA start request and | |
1151 | * initiating USB data reception. | |
1152 | */ | |
1153 | ret = greatfet_logic_start(sdi); | |
1154 | if (ret != SR_OK) | |
1155 | return ret; | |
1156 | ||
1157 | ret = greatfet_prepare_transfers(sdi, xfer_complete_cb); | |
1158 | if (ret != SR_OK) | |
1159 | return ret; | |
1160 | ||
1161 | return SR_OK; | |
1162 | } | |
1163 | ||
1164 | /* | |
1165 | * The public acquisition abort routine, invoked by api.c logic. Could | |
1166 | * optionally spend more time than the _quick() routine. | |
1167 | */ | |
1168 | SR_PRIV void greatfet_abort_acquisition(const struct sr_dev_inst *sdi) | |
1169 | { | |
1170 | struct dev_context *devc; | |
1171 | ||
1172 | if (!sdi) | |
1173 | return; | |
1174 | devc = sdi->priv; | |
1175 | if (!devc) | |
1176 | return; | |
1177 | ||
1178 | (void)greatfet_logic_stop(sdi); | |
1179 | greatfet_abort_acquisition_quick(sdi); | |
1180 | } | |
1181 | ||
1182 | SR_PRIV int greatfet_stop_acquisition(const struct sr_dev_inst *sdi) | |
1183 | { | |
1184 | struct sr_usb_dev_inst *usb; | |
1185 | int ret; | |
1186 | ||
1187 | if (!sdi) | |
1188 | return SR_ERR_ARG; | |
1189 | usb = sdi->conn; | |
1190 | if (!usb) | |
1191 | return SR_ERR_ARG; | |
1192 | ||
1193 | ret = greatfet_logic_stop(sdi); | |
1194 | if (ret != SR_OK) | |
1195 | return ret; | |
1196 | ||
1197 | return SR_OK; | |
1198 | } | |
1199 | ||
1200 | SR_PRIV void greatfet_release_resources(const struct sr_dev_inst *sdi) | |
1201 | { | |
1202 | struct dev_context *devc; | |
1203 | struct dev_transfers_t *dxfer; | |
1204 | ||
1205 | if (!sdi) | |
1206 | return; | |
1207 | devc = sdi->priv; | |
1208 | if (!devc) | |
1209 | return; | |
1210 | dxfer = &devc->transfers; | |
1211 | ||
1212 | /* | |
1213 | * Is there something that needs to be done here? Transfers' | |
1214 | * cancellation gets initiated and then happens as they keep | |
1215 | * completing. The completion handler releases their libusb | |
1216 | * resources. The last release also unregisters the periodic | |
1217 | * glib main loop callback. | |
1218 | * | |
1219 | * Can something be done here? The receive buffer still is | |
1220 | * allocated. As is the feed queue. Can we synchronize to the | |
1221 | * last release of the USB resources? Need we keep invoking | |
1222 | * the receive callback until the USB transfers pool has been | |
1223 | * released? Need we wait for the active transfers counter to | |
1224 | * drop to zero, is more checking involved? | |
1225 | */ | |
1226 | if (dxfer->active_transfers) | |
1227 | sr_warn("Got active USB transfers in release code path."); | |
1228 | } | |
1229 | ||
1230 | /* | |
1231 | * Process received sample date. There are two essential modes: | |
1232 | * - The straight forward case. The device provides 8 bits per sample | |
1233 | * point. Forward each byte as is to the sigrok session. It matches | |
1234 | * the sizeof(uint8_t) feed queue allocation parameter. | |
1235 | * - The compact presentation where a smaller number of channels is | |
1236 | * active, and their data spans only part of a byte per sample point. | |
1237 | * Multiple samples' data is sharing bytes, and bytes will carry data | |
1238 | * that was taken at different times. This requires some untangling | |
1239 | * before forwarding byte sized sample data to the sigrok session. | |
1240 | * | |
1241 | * Implementation details: | |
1242 | * - Samples taken first are found in the least significant bits of a | |
1243 | * byte. Samples taken next are found in upper bits of the byte. For | |
1244 | * example a byte containing 4x 2bit sample data is seen as 33221100. | |
1245 | * - Depending on the number of enabled channels there could be up to | |
1246 | * eight samples in one byte of sample memory. This implementation | |
1247 | * tries to accumulate one input byte's content, but not more. To | |
1248 | * simplify the implementation. Performance can get tuned later as | |
1249 | * the need gets identified. Sampling at 204MHz results in some 3% | |
1250 | * CPU load with Pulseview on the local workstation. | |
1251 | * - Samples for 16 channels transparently are handled by the simple | |
1252 | * 8 channel case above. All logic data of an individual samplepoint | |
1253 | * occupies full bytes, endianess of sample data as provided by the | |
1254 | * device firmware and the sigrok session are the same. No conversion | |
1255 | * is required. | |
1256 | */ | |
1257 | static int greatfet_process_receive_data(const struct sr_dev_inst *sdi, | |
1258 | const uint8_t *data, size_t dlen) | |
1259 | { | |
1260 | static int diag_shown; | |
1261 | ||
1262 | struct dev_context *devc; | |
1263 | struct dev_acquisition_t *acq; | |
1264 | struct feed_queue_logic *q; | |
1265 | uint64_t samples_remain; | |
1266 | gboolean exceeded; | |
70c9a254 | 1267 | gboolean full_bytes, lower_empty; |
208fcedc GS |
1268 | size_t samples_rcvd; |
1269 | uint8_t raw_mask; | |
1270 | size_t points_per_byte, points_count; | |
70c9a254 GS |
1271 | uint8_t raw_data, wr_data; |
1272 | uint8_t accum[16]; | |
208fcedc GS |
1273 | const uint8_t *rdptr; |
1274 | uint8_t *wrptr; | |
1275 | int ret; | |
1276 | ||
1277 | if (!sdi) | |
1278 | return SR_ERR_ARG; | |
1279 | devc = sdi->priv; | |
1280 | if (!devc) | |
1281 | return SR_ERR_ARG; | |
1282 | acq = &devc->acquisition; | |
1283 | q = acq->feed_queue; | |
1284 | ||
1285 | /* | |
1286 | * Check whether acquisition limits apply, and whether they | |
1287 | * were reached or exceeded before. Constrain the submission | |
1288 | * of more sample values to what's still within the limits of | |
1289 | * the current acquisition. | |
1290 | */ | |
1291 | ret = sr_sw_limits_get_remain(&devc->sw_limits, | |
1292 | &samples_remain, NULL, NULL, &exceeded); | |
1293 | if (ret != SR_OK) | |
1294 | return ret; | |
1295 | if (exceeded) | |
1296 | return SR_OK; | |
1297 | ||
1298 | /* | |
1299 | * Check for the simple case first. Where bytes carry samples | |
1300 | * of exactly one sample point. Pass memory in verbatim form. | |
70c9a254 GS |
1301 | * |
1302 | * This approach applies to two cases: Captures of the first 8 | |
1303 | * channels, and captures for 16 channels where both banks are | |
1304 | * involved (the device firmware provides all 16 bits of data | |
1305 | * for any given sample point). The 16bit case happens to work | |
1306 | * because sample data received from the device and logic data | |
1307 | * in sigrok sessions both use the little endian format. | |
1308 | * | |
1309 | * The "upper pins" case must be handled below because the | |
1310 | * device will not provide data for the lower pin bank, but the | |
1311 | * samples (all-zero values) must be sent to the sigrok session. | |
208fcedc | 1312 | */ |
70c9a254 GS |
1313 | full_bytes = !acq->channel_shift; |
1314 | lower_empty = acq->use_upper_pins; | |
1315 | if (full_bytes && !lower_empty) { | |
208fcedc GS |
1316 | samples_rcvd = dlen / acq->unit_size; |
1317 | if (samples_remain && samples_rcvd > samples_remain) | |
1318 | samples_rcvd = samples_remain; | |
1319 | ret = feed_queue_logic_submit_many(q, data, samples_rcvd); | |
1320 | if (ret != SR_OK) | |
1321 | return ret; | |
1322 | sr_sw_limits_update_samples_read(&devc->sw_limits, samples_rcvd); | |
1323 | return SR_OK; | |
1324 | } | |
1325 | ||
1326 | /* | |
70c9a254 GS |
1327 | * Handle the complex cases where one byte carries values that |
1328 | * were taken at multiple sample points, or where the firmware | |
1329 | * does not communicate the lower pin bank's data (upper pins). | |
1330 | * This involves manipulation between reception and forwarding. | |
1331 | * It helps that the firmware provides sample data in units of | |
1332 | * power-of-two bit counts per sample point. This eliminates | |
1333 | * fragments which could span several transfers. | |
208fcedc | 1334 | * |
70c9a254 GS |
1335 | * Notice that "upper pins" and "multiple samples per byte" can |
1336 | * happen in combination. The implementation transparently deals | |
1337 | * with upper pin use where bytes carry exactly one value. | |
208fcedc | 1338 | */ |
70c9a254 GS |
1339 | if (acq->channel_shift) { |
1340 | raw_mask = (1UL << acq->channel_shift) - 1; | |
1341 | points_per_byte = 8 / acq->channel_shift; | |
1342 | } else { | |
1343 | raw_mask = (1UL << 8) - 1; | |
1344 | points_per_byte = 1; | |
1345 | } | |
208fcedc | 1346 | if (!diag_shown++) { |
70c9a254 | 1347 | sr_dbg("sample mem: ch count %zu, ch shift %zu, mask 0x%x, points %zu, upper %d", |
208fcedc | 1348 | acq->capture_channels, acq->channel_shift, |
70c9a254 | 1349 | raw_mask, points_per_byte, acq->use_upper_pins); |
208fcedc GS |
1350 | } |
1351 | samples_rcvd = dlen * points_per_byte; | |
1352 | if (samples_remain && samples_rcvd > samples_remain) { | |
1353 | samples_rcvd = samples_remain; | |
1354 | dlen = samples_rcvd; | |
1355 | dlen += points_per_byte - 1; | |
1356 | dlen /= points_per_byte; | |
1357 | } | |
1358 | rdptr = data; | |
1359 | while (dlen--) { | |
1360 | raw_data = read_u8_inc(&rdptr); | |
1361 | wrptr = accum; | |
1362 | points_count = points_per_byte; | |
1363 | while (points_count--) { | |
70c9a254 GS |
1364 | wr_data = raw_data & raw_mask; |
1365 | if (acq->use_upper_pins) | |
1366 | write_u16le_inc(&wrptr, wr_data << 8); | |
1367 | else | |
1368 | write_u8_inc(&wrptr, wr_data); | |
208fcedc GS |
1369 | raw_data >>= acq->channel_shift; |
1370 | } | |
1371 | points_count = points_per_byte; | |
1372 | ret = feed_queue_logic_submit_many(q, accum, points_count); | |
1373 | if (ret != SR_OK) | |
1374 | return ret; | |
1375 | sr_sw_limits_update_samples_read(&devc->sw_limits, points_count); | |
1376 | } | |
1377 | return SR_OK; | |
1378 | } | |
1379 | ||
1380 | /* Receive callback, invoked when data is available, or periodically. */ | |
f594b3b0 GS |
1381 | SR_PRIV int greatfet_receive_data(int fd, int revents, void *cb_data) |
1382 | { | |
208fcedc | 1383 | struct sr_dev_inst *sdi; |
f594b3b0 | 1384 | struct dev_context *devc; |
208fcedc GS |
1385 | struct drv_context *drvc; |
1386 | libusb_context *ctx; | |
1387 | struct timeval tv; | |
f594b3b0 GS |
1388 | |
1389 | (void)fd; | |
208fcedc | 1390 | (void)revents; |
f594b3b0 GS |
1391 | |
1392 | sdi = cb_data; | |
208fcedc | 1393 | if (!sdi || !sdi->priv || !sdi->driver) |
f594b3b0 | 1394 | return TRUE; |
f594b3b0 GS |
1395 | devc = sdi->priv; |
1396 | if (!devc) | |
1397 | return TRUE; | |
208fcedc GS |
1398 | drvc = sdi->driver->context; |
1399 | if (!drvc || !drvc->sr_ctx) | |
1400 | return TRUE; | |
1401 | ctx = drvc->sr_ctx->libusb_ctx; | |
1402 | ||
1403 | /* | |
1404 | * Handle those USB transfers which have completed so far | |
1405 | * in a regular fashion. These carry desired sample values. | |
1406 | */ | |
1407 | tv.tv_sec = tv.tv_usec = 0; | |
1408 | libusb_handle_events_timeout(ctx, &tv); | |
f594b3b0 | 1409 | |
208fcedc GS |
1410 | /* |
1411 | * End the current acquisition when limites were reached. | |
1412 | * Process USB transfers again here before returning, because | |
1413 | * acquisition termination will unregister the receive callback, | |
1414 | * and cancel previously submitted transfers. Reap those here. | |
1415 | */ | |
1416 | if (sr_sw_limits_check(&devc->sw_limits)) { | |
1417 | greatfet_abort_acquisition_quick(sdi); | |
1418 | tv.tv_sec = tv.tv_usec = 0; | |
1419 | libusb_handle_events_timeout(ctx, &tv); | |
f594b3b0 GS |
1420 | } |
1421 | ||
1422 | return TRUE; | |
1423 | } |