]> sigrok.org Git - libsigrok.git/blame_incremental - hardware/fx2lafw/fx2lafw.c
projects / libsigrok.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
sr: fx2lafw: Add basic support for USBee DX and clones
[libsigrok.git] / hardware / fx2lafw / fx2lafw.c
... / ...
CommitLineData
1/*
2 * This file is part of the sigrok project.
3 *
4 * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
5 * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
6 *
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
24#include <inttypes.h>
25#include <libusb.h>
26#include "config.h"
27#include "libsigrok.h"
28#include "libsigrok-internal.h"
29#include "fx2lafw.h"
30#include "command.h"
31
32static const struct fx2lafw_profile supported_fx2[] = {
33 /*
34 * CWAV USBee DX
35 * XZL Studio DX
36 */
37 { 0x08a9, 0x0015, "CWAV", "USBee DX", NULL,
38 FIRMWARE_DIR "/fx2lafw-cwav-usbeedx.fw",
39 0 },
40 /*
41 * CWAV USBee AX
42 * EE Electronics ESLA201A
43 * ARMFLY AX-Pro
44 */
45 { 0x08a9, 0x0014, "CWAV", "USBee AX", NULL,
46 FIRMWARE_DIR "/fx2lafw-cwav-usbeeax.fw",
47 0 },
48
49 /*
50 * CWAV USBee SX
51 */
52 { 0x08a9, 0x0009, "CWAV", "USBee SX", NULL,
53 FIRMWARE_DIR "/fx2lafw-cwav-usbeesx.fw",
54 0 },
55
56 /*
57 * Saleae Logic
58 * EE Electronics ESLA100
59 * Robomotic MiniLogic
60 * Robomotic BugLogic 3
61 */
62 { 0x0925, 0x3881, "Saleae", "Logic", NULL,
63 FIRMWARE_DIR "/fx2lafw-saleae-logic.fw",
64 0 },
65
66 /*
67 * Default Cypress FX2 without EEPROM, e.g.:
68 * Lcsoft Mini Board
69 * Braintechnology USB Interface V2.x
70 */
71 { 0x04B4, 0x8613, "Cypress", "FX2", NULL,
72 FIRMWARE_DIR "/fx2lafw-cypress-fx2.fw",
73 DEV_CAPS_16BIT },
74
75 /*
76 * Braintechnology USB-LPS
77 */
78 { 0x16d0, 0x0498, "Braintechnology", "USB-LPS", NULL,
79 FIRMWARE_DIR "/fx2lafw-braintechnology-usb-lps.fw",
80 DEV_CAPS_16BIT },
81
82 { 0, 0, 0, 0, 0, 0, 0 }
83};
84
85static const int hwcaps[] = {
86 SR_HWCAP_LOGIC_ANALYZER,
87 SR_HWCAP_SAMPLERATE,
88
89 /* These are really implemented in the driver, not the hardware. */
90 SR_HWCAP_LIMIT_SAMPLES,
91 SR_HWCAP_CONTINUOUS,
92 0,
93};
94
95/*
96 * TODO: Different probe_names[] for each supported device.
97 */
98static const char *probe_names[] = {
99 "0",
100 "1",
101 "2",
102 "3",
103 "4",
104 "5",
105 "6",
106 "7",
107 "8",
108 "9",
109 "10",
110 "11",
111 "12",
112 "13",
113 "14",
114 "15",
115 NULL,
116};
117
118static const uint64_t supported_samplerates[] = {
119 SR_KHZ(20),
120 SR_KHZ(25),
121 SR_KHZ(50),
122 SR_KHZ(100),
123 SR_KHZ(200),
124 SR_KHZ(250),
125 SR_KHZ(500),
126 SR_MHZ(1),
127 SR_MHZ(2),
128 SR_MHZ(3),
129 SR_MHZ(4),
130 SR_MHZ(6),
131 SR_MHZ(8),
132 SR_MHZ(12),
133 SR_MHZ(16),
134 SR_MHZ(24),
135 0,
136};
137
138static const struct sr_samplerates samplerates = {
139 0,
140 0,
141 0,
142 supported_samplerates,
143};
144
145static GSList *dev_insts = NULL;
146static libusb_context *usb_context = NULL;
147
148static int hw_dev_config_set(int dev_index, int hwcap, const void *value);
149static int hw_dev_acquisition_stop(int dev_index, void *cb_data);
150
151/**
152 * Check the USB configuration to determine if this is an fx2lafw device.
153 *
154 * @return TRUE if the device's configuration profile match fx2lafw
155 * configuration, FALSE otherwise.
156 */
157static gboolean check_conf_profile(libusb_device *dev)
158{
159 struct libusb_device_descriptor des;
160 struct libusb_device_handle *hdl;
161 gboolean ret;
162 unsigned char strdesc[64];
163
164 hdl = NULL;
165 ret = FALSE;
166 while (!ret) {
167 /* Assume the FW has not been loaded, unless proven wrong. */
168 if (libusb_get_device_descriptor(dev, &des) != 0)
169 break;
170
171 if (libusb_open(dev, &hdl) != 0)
172 break;
173
174 if (libusb_get_string_descriptor_ascii(hdl,
175 des.iManufacturer, strdesc, sizeof(strdesc)) < 0)
176 break;
177 if (strncmp((const char *)strdesc, "sigrok", 6))
178 break;
179
180 if (libusb_get_string_descriptor_ascii(hdl,
181 des.iProduct, strdesc, sizeof(strdesc)) < 0)
182 break;
183 if (strncmp((const char *)strdesc, "fx2lafw", 7))
184 break;
185
186 /* If we made it here, it must be an fx2lafw. */
187 ret = TRUE;
188 }
189 if (hdl)
190 libusb_close(hdl);
191
192 return ret;
193}
194
195static int fx2lafw_dev_open(int dev_index)
196{
197 libusb_device **devlist;
198 struct libusb_device_descriptor des;
199 struct sr_dev_inst *sdi;
200 struct context *ctx;
201 struct version_info vi;
202 int ret, skip, i;
203 uint8_t revid;
204
205 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
206 return SR_ERR;
207 ctx = sdi->priv;
208
209 if (sdi->status == SR_ST_ACTIVE)
210 /* already in use */
211 return SR_ERR;
212
213 skip = 0;
214 const int device_count = libusb_get_device_list(usb_context, &devlist);
215 if (device_count < 0) {
216 sr_err("fx2lafw: Failed to retrieve device list (%d)",
217 device_count);
218 return SR_ERR;
219 }
220
221 for (i = 0; i < device_count; i++) {
222 if ((ret = libusb_get_device_descriptor(devlist[i], &des))) {
223 sr_err("fx2lafw: Failed to get device descriptor: %d.",
224 ret);
225 continue;
226 }
227
228 if (des.idVendor != ctx->profile->vid
229 || des.idProduct != ctx->profile->pid)
230 continue;
231
232 if (sdi->status == SR_ST_INITIALIZING) {
233 if (skip != dev_index) {
234 /* Skip devices of this type that aren't the one we want. */
235 skip += 1;
236 continue;
237 }
238 } else if (sdi->status == SR_ST_INACTIVE) {
239 /*
240 * This device is fully enumerated, so we need to find
241 * this device by vendor, product, bus and address.
242 */
243 if (libusb_get_bus_number(devlist[i]) != ctx->usb->bus
244 || libusb_get_device_address(devlist[i]) != ctx->usb->address)
245 /* this is not the one */
246 continue;
247 }
248
249 if (!(ret = libusb_open(devlist[i], &ctx->usb->devhdl))) {
250 if (ctx->usb->address == 0xff)
251 /*
252 * first time we touch this device after firmware upload,
253 * so we don't know the address yet.
254 */
255 ctx->usb->address = libusb_get_device_address(devlist[i]);
256 } else {
257 sr_err("fx2lafw: Failed to open device: %d.", ret);
258 break;
259 }
260
261 ret = command_get_fw_version(ctx->usb->devhdl, &vi);
262 if (ret != SR_OK) {
263 sr_err("fx2lafw: Failed to retrieve "
264 "firmware version information.");
265 break;
266 }
267
268 ret = command_get_revid_version(ctx->usb->devhdl, &revid);
269 if (ret != SR_OK) {
270 sr_err("fx2lafw: Failed to retrieve REVID.");
271 break;
272 }
273
274 /*
275 * Changes in major version mean incompatible/API changes, so
276 * bail out if we encounter an incompatible version.
277 * Different minor versions are OK, they should be compatible.
278 */
279 if (vi.major != FX2LAFW_REQUIRED_VERSION_MAJOR) {
280 sr_err("fx2lafw: Expected firmware version %d.x, "
281 "got %d.%d.", FX2LAFW_REQUIRED_VERSION_MAJOR,
282 vi.major, vi.minor);
283 break;
284 }
285
286 sdi->status = SR_ST_ACTIVE;
287 sr_info("fx2lafw: Opened device %d on %d.%d "
288 "interface %d, firmware %d.%d, REVID %d.",
289 sdi->index, ctx->usb->bus, ctx->usb->address,
290 USB_INTERFACE, vi.major, vi.minor, revid);
291
292 break;
293 }
294 libusb_free_device_list(devlist, 1);
295
296 if (sdi->status != SR_ST_ACTIVE)
297 return SR_ERR;
298
299 return SR_OK;
300}
301
302static void close_dev(struct sr_dev_inst *sdi)
303{
304 struct context *ctx;
305
306 ctx = sdi->priv;
307
308 if (ctx->usb->devhdl == NULL)
309 return;
310
311 sr_info("fx2lafw: Closing device %d on %d.%d interface %d.",
312 sdi->index, ctx->usb->bus, ctx->usb->address, USB_INTERFACE);
313 libusb_release_interface(ctx->usb->devhdl, USB_INTERFACE);
314 libusb_close(ctx->usb->devhdl);
315 ctx->usb->devhdl = NULL;
316 sdi->status = SR_ST_INACTIVE;
317}
318
319static int configure_probes(struct context *ctx, GSList *probes)
320{
321 struct sr_probe *probe;
322 GSList *l;
323 int probe_bit, stage, i;
324 char *tc;
325
326 for (i = 0; i < NUM_TRIGGER_STAGES; i++) {
327 ctx->trigger_mask[i] = 0;
328 ctx->trigger_value[i] = 0;
329 }
330
331 stage = -1;
332 for (l = probes; l; l = l->next) {
333 probe = (struct sr_probe *)l->data;
334 if (probe->enabled == FALSE)
335 continue;
336
337 if (probe->index > 8)
338 ctx->sample_wide = TRUE;
339
340 probe_bit = 1 << (probe->index - 1);
341 if (!(probe->trigger))
342 continue;
343
344 stage = 0;
345 for (tc = probe->trigger; *tc; tc++) {
346 ctx->trigger_mask[stage] |= probe_bit;
347 if (*tc == '1')
348 ctx->trigger_value[stage] |= probe_bit;
349 stage++;
350 if (stage > NUM_TRIGGER_STAGES)
351 return SR_ERR;
352 }
353 }
354
355 if (stage == -1)
356 /*
357 * We didn't configure any triggers, make sure acquisition
358 * doesn't wait for any.
359 */
360 ctx->trigger_stage = TRIGGER_FIRED;
361 else
362 ctx->trigger_stage = 0;
363
364 return SR_OK;
365}
366
367static struct context *fx2lafw_dev_new(void)
368{
369 struct context *ctx;
370
371 if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
372 sr_err("fx2lafw: %s: ctx malloc failed.", __func__);
373 return NULL;
374 }
375
376 ctx->trigger_stage = TRIGGER_FIRED;
377
378 return ctx;
379}
380
381/*
382 * API callbacks
383 */
384
385static int hw_init(const char *devinfo)
386{
387 struct sr_dev_inst *sdi;
388 struct libusb_device_descriptor des;
389 const struct fx2lafw_profile *prof;
390 struct context *ctx;
391 libusb_device **devlist;
392 int ret;
393 int devcnt = 0;
394 int i, j;
395
396 /* Avoid compiler warnings. */
397 (void)devinfo;
398
399 if (libusb_init(&usb_context) != 0) {
400 sr_warn("fx2lafw: Failed to initialize libusb.");
401 return 0;
402 }
403
404 /* Find all fx2lafw compatible devices and upload firmware to them. */
405 libusb_get_device_list(usb_context, &devlist);
406 for (i = 0; devlist[i]; i++) {
407
408 if ((ret = libusb_get_device_descriptor(
409 devlist[i], &des)) != 0) {
410 sr_warn("fx2lafw: Failed to get device descriptor: %d.", ret);
411 continue;
412 }
413
414 prof = NULL;
415 for (j = 0; supported_fx2[j].vid; j++) {
416 if (des.idVendor == supported_fx2[j].vid &&
417 des.idProduct == supported_fx2[j].pid) {
418 prof = &supported_fx2[j];
419 }
420 }
421
422 /* Skip if the device was not found */
423 if (!prof)
424 continue;
425
426 sdi = sr_dev_inst_new(devcnt, SR_ST_INITIALIZING,
427 prof->vendor, prof->model, prof->model_version);
428 if (!sdi)
429 return 0;
430
431 ctx = fx2lafw_dev_new();
432 ctx->profile = prof;
433 sdi->priv = ctx;
434 dev_insts = g_slist_append(dev_insts, sdi);
435
436 if (check_conf_profile(devlist[i])) {
437 /* Already has the firmware, so fix the new address. */
438 sr_dbg("fx2lafw: Found an fx2lafw device.");
439 sdi->status = SR_ST_INACTIVE;
440 ctx->usb = sr_usb_dev_inst_new
441 (libusb_get_bus_number(devlist[i]),
442 libusb_get_device_address(devlist[i]), NULL);
443 } else {
444 if (ezusb_upload_firmware(devlist[i], USB_CONFIGURATION,
445 prof->firmware) == SR_OK)
446 /* Remember when the firmware on this device was updated */
447 ctx->fw_updated = g_get_monotonic_time();
448 else
449 sr_err("fx2lafw: Firmware upload failed for "
450 "device %d.", devcnt);
451 ctx->usb = sr_usb_dev_inst_new
452 (libusb_get_bus_number(devlist[i]), 0xff, NULL);
453 }
454
455 devcnt++;
456 }
457 libusb_free_device_list(devlist, 1);
458
459 return devcnt;
460}
461
462static int hw_dev_open(int dev_index)
463{
464 struct sr_dev_inst *sdi;
465 struct context *ctx;
466 int ret;
467 int64_t timediff_us, timediff_ms;
468
469 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
470 return SR_ERR;
471 ctx = sdi->priv;
472
473 /*
474 * If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS
475 * milliseconds for the FX2 to renumerate.
476 */
477 ret = SR_ERR;
478 if (ctx->fw_updated > 0) {
479 sr_info("fx2lafw: Waiting for device to reset.");
480 /* takes at least 300ms for the FX2 to be gone from the USB bus */
481 g_usleep(300 * 1000);
482 timediff_ms = 0;
483 while (timediff_ms < MAX_RENUM_DELAY_MS) {
484 if ((ret = fx2lafw_dev_open(dev_index)) == SR_OK)
485 break;
486 g_usleep(100 * 1000);
487
488 timediff_us = g_get_monotonic_time() - ctx->fw_updated;
489 timediff_ms = timediff_us / 1000;
490 sr_spew("fx2lafw: waited %" PRIi64 " ms", timediff_ms);
491 }
492 sr_info("fx2lafw: Device came back after %d ms.", timediff_ms);
493 } else {
494 ret = fx2lafw_dev_open(dev_index);
495 }
496
497 if (ret != SR_OK) {
498 sr_err("fx2lafw: Unable to open device.");
499 return SR_ERR;
500 }
501 ctx = sdi->priv;
502
503 ret = libusb_claim_interface(ctx->usb->devhdl, USB_INTERFACE);
504 if (ret != 0) {
505 switch(ret) {
506 case LIBUSB_ERROR_BUSY:
507 sr_err("fx2lafw: Unable to claim USB interface. Another "
508 "program or driver has already claimed it.");
509 break;
510
511 case LIBUSB_ERROR_NO_DEVICE:
512 sr_err("fx2lafw: Device has been disconnected.");
513 break;
514
515 default:
516 sr_err("fx2lafw: Unable to claim interface: %d.", ret);
517 break;
518 }
519
520 return SR_ERR;
521 }
522
523 if (ctx->cur_samplerate == 0) {
524 /* Samplerate hasn't been set; default to the slowest one. */
525 if (hw_dev_config_set(dev_index, SR_HWCAP_SAMPLERATE,
526 &supported_samplerates[0]) == SR_ERR)
527 return SR_ERR;
528 }
529
530 return SR_OK;
531}
532
533static int hw_dev_close(int dev_index)
534{
535 struct sr_dev_inst *sdi;
536
537 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
538 sr_err("fx2lafw: %s: sdi was NULL.", __func__);
539 return SR_ERR_BUG;
540 }
541
542 /* TODO */
543 close_dev(sdi);
544
545 return SR_OK;
546}
547
548static int hw_cleanup(void)
549{
550 GSList *l;
551 struct sr_dev_inst *sdi;
552 struct context *ctx;
553 int ret = SR_OK;
554
555 for (l = dev_insts; l; l = l->next) {
556 if (!(sdi = l->data)) {
557 /* Log error, but continue cleaning up the rest. */
558 sr_err("fx2lafw: %s: sdi was NULL, continuing.",
559 __func__);
560 ret = SR_ERR_BUG;
561 continue;
562 }
563 if (!(ctx = sdi->priv)) {
564 /* Log error, but continue cleaning up the rest. */
565 sr_err("fx2lafw: %s: sdi->priv was NULL, continuing",
566 __func__);
567 ret = SR_ERR_BUG;
568 continue;
569 }
570 close_dev(sdi);
571 sdi = l->data;
572 sr_dev_inst_free(sdi);
573 }
574
575 g_slist_free(dev_insts);
576 dev_insts = NULL;
577
578 if (usb_context)
579 libusb_exit(usb_context);
580 usb_context = NULL;
581
582 return ret;
583}
584
585static const void *hw_dev_info_get(int dev_index, int dev_info_id)
586{
587 struct sr_dev_inst *sdi;
588 struct context *ctx;
589
590 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
591 return NULL;
592 ctx = sdi->priv;
593
594 switch (dev_info_id) {
595 case SR_DI_INST:
596 return sdi;
597 case SR_DI_NUM_PROBES:
598 return GINT_TO_POINTER(
599 (ctx->profile->dev_caps & DEV_CAPS_16BIT) ?
600 16 : 8);
601 case SR_DI_PROBE_NAMES:
602 return probe_names;
603 case SR_DI_SAMPLERATES:
604 return &samplerates;
605 case SR_DI_TRIGGER_TYPES:
606 return TRIGGER_TYPES;
607 case SR_DI_CUR_SAMPLERATE:
608 return &ctx->cur_samplerate;
609 }
610
611 return NULL;
612}
613
614static int hw_dev_status_get(int dev_index)
615{
616 const struct sr_dev_inst *const sdi =
617 sr_dev_inst_get(dev_insts, dev_index);
618
619 if (!sdi)
620 return SR_ST_NOT_FOUND;
621
622 return sdi->status;
623}
624
625static const int *hw_hwcap_get_all(void)
626{
627 return hwcaps;
628}
629
630static int hw_dev_config_set(int dev_index, int hwcap, const void *value)
631{
632 struct sr_dev_inst *sdi;
633 struct context *ctx;
634 int ret;
635
636 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
637 return SR_ERR;
638 ctx = sdi->priv;
639
640 if (hwcap == SR_HWCAP_SAMPLERATE) {
641 ctx->cur_samplerate = *(const uint64_t *)value;
642 ret = SR_OK;
643 } else if (hwcap == SR_HWCAP_PROBECONFIG) {
644 ret = configure_probes(ctx, (GSList *) value);
645 } else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
646 ctx->limit_samples = *(const uint64_t *)value;
647 ret = SR_OK;
648 } else {
649 ret = SR_ERR;
650 }
651
652 return ret;
653}
654
655static int receive_data(int fd, int revents, void *cb_data)
656{
657 struct timeval tv;
658
659 /* Avoid compiler warnings. */
660 (void)fd;
661 (void)revents;
662 (void)cb_data;
663
664 tv.tv_sec = tv.tv_usec = 0;
665 libusb_handle_events_timeout(usb_context, &tv);
666
667 return TRUE;
668}
669
670static void abort_acquisition(struct context *ctx)
671{
672 int i;
673
674 ctx->num_samples = -1;
675
676 for (i = ctx->num_transfers - 1; i >= 0; i--) {
677 if (ctx->transfers[i])
678 libusb_cancel_transfer(ctx->transfers[i]);
679 }
680}
681
682static void finish_acquisition(struct context *ctx)
683{
684 struct sr_datafeed_packet packet;
685 int i;
686
687 /* Terminate session */
688 packet.type = SR_DF_END;
689 sr_session_send(ctx->session_dev_id, &packet);
690
691 /* Remove fds from polling */
692 const struct libusb_pollfd **const lupfd =
693 libusb_get_pollfds(usb_context);
694 for (i = 0; lupfd[i]; i++)
695 sr_source_remove(lupfd[i]->fd);
696 free(lupfd); /* NOT g_free()! */
697
698 ctx->num_transfers = 0;
699 g_free(ctx->transfers);
700}
701
702static void free_transfer(struct libusb_transfer *transfer)
703{
704 struct context *ctx = transfer->user_data;
705 unsigned int i;
706
707 g_free(transfer->buffer);
708 transfer->buffer = NULL;
709 libusb_free_transfer(transfer);
710
711 for (i = 0; i < ctx->num_transfers; i++) {
712 if (ctx->transfers[i] == transfer) {
713 ctx->transfers[i] = NULL;
714 break;
715 }
716 }
717
718 ctx->submitted_transfers--;
719 if (ctx->submitted_transfers == 0)
720 finish_acquisition(ctx);
721
722}
723
724static void resubmit_transfer(struct libusb_transfer *transfer)
725{
726 if (libusb_submit_transfer(transfer) != 0) {
727 free_transfer(transfer);
728 /* TODO: Stop session? */
729 /* TODO: Better error message. */
730 sr_err("fx2lafw: %s: libusb_submit_transfer error.", __func__);
731 }
732}
733
734static void receive_transfer(struct libusb_transfer *transfer)
735{
736 gboolean packet_has_error = FALSE;
737 struct sr_datafeed_packet packet;
738 struct sr_datafeed_logic logic;
739 struct context *ctx = transfer->user_data;
740 int trigger_offset, i;
741
742 /*
743 * If acquisition has already ended, just free any queued up
744 * transfer that come in.
745 */
746 if (ctx->num_samples == -1) {
747 free_transfer(transfer);
748 return;
749 }
750
751 sr_info("fx2lafw: receive_transfer(): status %d received %d bytes.",
752 transfer->status, transfer->actual_length);
753
754 /* Save incoming transfer before reusing the transfer struct. */
755 uint8_t *const cur_buf = transfer->buffer;
756 const int sample_width = ctx->sample_wide ? 2 : 1;
757 const int cur_sample_count = transfer->actual_length / sample_width;
758
759 switch (transfer->status) {
760 case LIBUSB_TRANSFER_NO_DEVICE:
761 abort_acquisition(ctx);
762 free_transfer(transfer);
763 return;
764 case LIBUSB_TRANSFER_COMPLETED:
765 case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though */
766 break;
767 default:
768 packet_has_error = TRUE;
769 break;
770 }
771
772 if (transfer->actual_length == 0 || packet_has_error) {
773 ctx->empty_transfer_count++;
774 if (ctx->empty_transfer_count > MAX_EMPTY_TRANSFERS) {
775 /*
776 * The FX2 gave up. End the acquisition, the frontend
777 * will work out that the samplecount is short.
778 */
779 abort_acquisition(ctx);
780 free_transfer(transfer);
781 } else {
782 resubmit_transfer(transfer);
783 }
784 return;
785 } else {
786 ctx->empty_transfer_count = 0;
787 }
788
789 trigger_offset = 0;
790 if (ctx->trigger_stage >= 0) {
791 for (i = 0; i < cur_sample_count; i++) {
792
793 const uint16_t cur_sample = ctx->sample_wide ?
794 *((const uint16_t*)cur_buf + i) :
795 *((const uint8_t*)cur_buf + i);
796
797 if ((cur_sample & ctx->trigger_mask[ctx->trigger_stage]) ==
798 ctx->trigger_value[ctx->trigger_stage]) {
799 /* Match on this trigger stage. */
800 ctx->trigger_buffer[ctx->trigger_stage] = cur_sample;
801 ctx->trigger_stage++;
802
803 if (ctx->trigger_stage == NUM_TRIGGER_STAGES ||
804 ctx->trigger_mask[ctx->trigger_stage] == 0) {
805 /* Match on all trigger stages, we're done. */
806 trigger_offset = i + 1;
807
808 /*
809 * TODO: Send pre-trigger buffer to session bus.
810 * Tell the frontend we hit the trigger here.
811 */
812 packet.type = SR_DF_TRIGGER;
813 packet.payload = NULL;
814 sr_session_send(ctx->session_dev_id, &packet);
815
816 /*
817 * Send the samples that triggered it, since we're
818 * skipping past them.
819 */
820 packet.type = SR_DF_LOGIC;
821 packet.payload = &logic;
822 logic.unitsize = sizeof(*ctx->trigger_buffer);
823 logic.length = ctx->trigger_stage * logic.unitsize;
824 logic.data = ctx->trigger_buffer;
825 sr_session_send(ctx->session_dev_id, &packet);
826
827 ctx->trigger_stage = TRIGGER_FIRED;
828 break;
829 }
830 } else if (ctx->trigger_stage > 0) {
831 /*
832 * We had a match before, but not in the next sample. However, we may
833 * have a match on this stage in the next bit -- trigger on 0001 will
834 * fail on seeing 00001, so we need to go back to stage 0 -- but at
835 * the next sample from the one that matched originally, which the
836 * counter increment at the end of the loop takes care of.
837 */
838 i -= ctx->trigger_stage;
839 if (i < -1)
840 i = -1; /* Oops, went back past this buffer. */
841 /* Reset trigger stage. */
842 ctx->trigger_stage = 0;
843 }
844 }
845 }
846
847 if (ctx->trigger_stage == TRIGGER_FIRED) {
848 /* Send the incoming transfer to the session bus. */
849 const int trigger_offset_bytes = trigger_offset * sample_width;
850 packet.type = SR_DF_LOGIC;
851 packet.payload = &logic;
852 logic.length = transfer->actual_length - trigger_offset_bytes;
853 logic.unitsize = sample_width;
854 logic.data = cur_buf + trigger_offset_bytes;
855 sr_session_send(ctx->session_dev_id, &packet);
856
857 ctx->num_samples += cur_sample_count;
858 if (ctx->limit_samples &&
859 (unsigned int)ctx->num_samples > ctx->limit_samples) {
860 abort_acquisition(ctx);
861 free_transfer(transfer);
862 return;
863 }
864 } else {
865 /*
866 * TODO: Buffer pre-trigger data in capture
867 * ratio-sized buffer.
868 */
869 }
870
871 resubmit_transfer(transfer);
872}
873
874static unsigned int to_bytes_per_ms(unsigned int samplerate)
875{
876 return samplerate / 1000;
877}
878
879static size_t get_buffer_size(struct context *ctx)
880{
881 size_t s;
882
883 /* The buffer should be large enough to hold 10ms of data and a multiple
884 * of 512. */
885 s = 10 * to_bytes_per_ms(ctx->cur_samplerate);
886 return (s + 511) & ~511;
887}
888
889static unsigned int get_number_of_transfers(struct context *ctx)
890{
891 unsigned int n;
892
893 /* Total buffer size should be able to hold about 500ms of data */
894 n = 500 * to_bytes_per_ms(ctx->cur_samplerate) / get_buffer_size(ctx);
895
896 if (n > NUM_SIMUL_TRANSFERS)
897 return NUM_SIMUL_TRANSFERS;
898
899 return n;
900}
901
902static unsigned int get_timeout(struct context *ctx)
903{
904 size_t total_size;
905 unsigned int timeout;
906
907 total_size = get_buffer_size(ctx) * get_number_of_transfers(ctx);
908 timeout = total_size / to_bytes_per_ms(ctx->cur_samplerate);
909 return timeout + timeout / 4; /* Leave a headroom of 25% percent */
910}
911
912static int hw_dev_acquisition_start(int dev_index, void *cb_data)
913{
914 struct sr_dev_inst *sdi;
915 struct sr_datafeed_packet packet;
916 struct sr_datafeed_header header;
917 struct sr_datafeed_meta_logic meta;
918 struct context *ctx;
919 struct libusb_transfer *transfer;
920 const struct libusb_pollfd **lupfd;
921 unsigned int i;
922 int ret;
923 unsigned char *buf;
924
925 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
926 return SR_ERR;
927 ctx = sdi->priv;
928
929 if (ctx->submitted_transfers != 0)
930 return SR_ERR;
931
932 ctx->session_dev_id = cb_data;
933 ctx->num_samples = 0;
934 ctx->empty_transfer_count = 0;
935
936 const unsigned int timeout = get_timeout(ctx);
937 const unsigned int num_transfers = get_number_of_transfers(ctx);
938 const size_t size = get_buffer_size(ctx);
939
940 ctx->transfers = g_try_malloc0(sizeof(*ctx->transfers) * num_transfers);
941 if (!ctx->transfers)
942 return SR_ERR;
943
944 ctx->num_transfers = num_transfers;
945
946 for (i = 0; i < num_transfers; i++) {
947 if (!(buf = g_try_malloc(size))) {
948 sr_err("fx2lafw: %s: buf malloc failed.", __func__);
949 return SR_ERR_MALLOC;
950 }
951 transfer = libusb_alloc_transfer(0);
952 libusb_fill_bulk_transfer(transfer, ctx->usb->devhdl,
953 2 | LIBUSB_ENDPOINT_IN, buf, size,
954 receive_transfer, ctx, timeout);
955 if (libusb_submit_transfer(transfer) != 0) {
956 libusb_free_transfer(transfer);
957 g_free(buf);
958 abort_acquisition(ctx);
959 return SR_ERR;
960 }
961 ctx->transfers[i] = transfer;
962 ctx->submitted_transfers++;
963 }
964
965 lupfd = libusb_get_pollfds(usb_context);
966 for (i = 0; lupfd[i]; i++)
967 sr_source_add(lupfd[i]->fd, lupfd[i]->events,
968 timeout, receive_data, NULL);
969 free(lupfd); /* NOT g_free()! */
970
971 packet.type = SR_DF_HEADER;
972 packet.payload = &header;
973 header.feed_version = 1;
974 gettimeofday(&header.starttime, NULL);
975 sr_session_send(cb_data, &packet);
976
977 /* Send metadata about the SR_DF_LOGIC packets to come. */
978 packet.type = SR_DF_META_LOGIC;
979 packet.payload = &meta;
980 meta.samplerate = ctx->cur_samplerate;
981 meta.num_probes = ctx->sample_wide ? 16 : 8;
982 sr_session_send(cb_data, &packet);
983
984 if ((ret = command_start_acquisition (ctx->usb->devhdl,
985 ctx->cur_samplerate, ctx->sample_wide)) != SR_OK) {
986 abort_acquisition(ctx);
987 return ret;
988 }
989
990 return SR_OK;
991}
992
993/* TODO: This stops acquisition on ALL devices, ignoring dev_index. */
994static int hw_dev_acquisition_stop(int dev_index, void *cb_data)
995{
996 struct sr_dev_inst *sdi;
997
998 /* Avoid compiler warnings. */
999 (void)cb_data;
1000
1001 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
1002 return SR_ERR;
1003
1004 abort_acquisition(sdi->priv);
1005
1006 return SR_OK;
1007}
1008
1009SR_PRIV struct sr_dev_driver fx2lafw_driver_info = {
1010 .name = "fx2lafw",
1011 .longname = "fx2lafw (generic driver for FX2 based LAs)",
1012 .api_version = 1,
1013 .init = hw_init,
1014 .cleanup = hw_cleanup,
1015 .dev_open = hw_dev_open,
1016 .dev_close = hw_dev_close,
1017 .dev_info_get = hw_dev_info_get,
1018 .dev_status_get = hw_dev_status_get,
1019 .hwcap_get_all = hw_hwcap_get_all,
1020 .dev_config_set = hw_dev_config_set,
1021 .dev_acquisition_start = hw_dev_acquisition_start,
1022 .dev_acquisition_stop = hw_dev_acquisition_stop,
1023};
Hardware access and backend lib