]> 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: remove unused argument from hardware driver function init()
[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 AX
35 * EE Electronics ESLA201A
36 * ARMFLY AX-Pro
37 */
38 { 0x08a9, 0x0014, "CWAV", "USBee AX", NULL,
39 FIRMWARE_DIR "/fx2lafw-cwav-usbeeax.fw",
40 0 },
41 /*
42 * CWAV USBee DX
43 * XZL-Studio DX
44 */
45 { 0x08a9, 0x0015, "CWAV", "USBee DX", NULL,
46 FIRMWARE_DIR "/fx2lafw-cwav-usbeedx.fw",
47 DEV_CAPS_16BIT },
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(void)
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 if (libusb_init(&usb_context) != 0) {
397 sr_warn("fx2lafw: Failed to initialize libusb.");
398 return 0;
399 }
400
401 /* Find all fx2lafw compatible devices and upload firmware to them. */
402 libusb_get_device_list(usb_context, &devlist);
403 for (i = 0; devlist[i]; i++) {
404
405 if ((ret = libusb_get_device_descriptor(
406 devlist[i], &des)) != 0) {
407 sr_warn("fx2lafw: Failed to get device descriptor: %d.", ret);
408 continue;
409 }
410
411 prof = NULL;
412 for (j = 0; supported_fx2[j].vid; j++) {
413 if (des.idVendor == supported_fx2[j].vid &&
414 des.idProduct == supported_fx2[j].pid) {
415 prof = &supported_fx2[j];
416 }
417 }
418
419 /* Skip if the device was not found */
420 if (!prof)
421 continue;
422
423 sdi = sr_dev_inst_new(devcnt, SR_ST_INITIALIZING,
424 prof->vendor, prof->model, prof->model_version);
425 if (!sdi)
426 return 0;
427
428 ctx = fx2lafw_dev_new();
429 ctx->profile = prof;
430 sdi->priv = ctx;
431 dev_insts = g_slist_append(dev_insts, sdi);
432
433 if (check_conf_profile(devlist[i])) {
434 /* Already has the firmware, so fix the new address. */
435 sr_dbg("fx2lafw: Found an fx2lafw device.");
436 sdi->status = SR_ST_INACTIVE;
437 ctx->usb = sr_usb_dev_inst_new
438 (libusb_get_bus_number(devlist[i]),
439 libusb_get_device_address(devlist[i]), NULL);
440 } else {
441 if (ezusb_upload_firmware(devlist[i], USB_CONFIGURATION,
442 prof->firmware) == SR_OK)
443 /* Remember when the firmware on this device was updated */
444 ctx->fw_updated = g_get_monotonic_time();
445 else
446 sr_err("fx2lafw: Firmware upload failed for "
447 "device %d.", devcnt);
448 ctx->usb = sr_usb_dev_inst_new
449 (libusb_get_bus_number(devlist[i]), 0xff, NULL);
450 }
451
452 devcnt++;
453 }
454 libusb_free_device_list(devlist, 1);
455
456 return devcnt;
457}
458
459static int hw_dev_open(int dev_index)
460{
461 struct sr_dev_inst *sdi;
462 struct context *ctx;
463 int ret;
464 int64_t timediff_us, timediff_ms;
465
466 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
467 return SR_ERR;
468 ctx = sdi->priv;
469
470 /*
471 * If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS
472 * milliseconds for the FX2 to renumerate.
473 */
474 ret = SR_ERR;
475 if (ctx->fw_updated > 0) {
476 sr_info("fx2lafw: Waiting for device to reset.");
477 /* takes at least 300ms for the FX2 to be gone from the USB bus */
478 g_usleep(300 * 1000);
479 timediff_ms = 0;
480 while (timediff_ms < MAX_RENUM_DELAY_MS) {
481 if ((ret = fx2lafw_dev_open(dev_index)) == SR_OK)
482 break;
483 g_usleep(100 * 1000);
484
485 timediff_us = g_get_monotonic_time() - ctx->fw_updated;
486 timediff_ms = timediff_us / 1000;
487 sr_spew("fx2lafw: waited %" PRIi64 " ms", timediff_ms);
488 }
489 sr_info("fx2lafw: Device came back after %d ms.", timediff_ms);
490 } else {
491 ret = fx2lafw_dev_open(dev_index);
492 }
493
494 if (ret != SR_OK) {
495 sr_err("fx2lafw: Unable to open device.");
496 return SR_ERR;
497 }
498 ctx = sdi->priv;
499
500 ret = libusb_claim_interface(ctx->usb->devhdl, USB_INTERFACE);
501 if (ret != 0) {
502 switch(ret) {
503 case LIBUSB_ERROR_BUSY:
504 sr_err("fx2lafw: Unable to claim USB interface. Another "
505 "program or driver has already claimed it.");
506 break;
507
508 case LIBUSB_ERROR_NO_DEVICE:
509 sr_err("fx2lafw: Device has been disconnected.");
510 break;
511
512 default:
513 sr_err("fx2lafw: Unable to claim interface: %d.", ret);
514 break;
515 }
516
517 return SR_ERR;
518 }
519
520 if (ctx->cur_samplerate == 0) {
521 /* Samplerate hasn't been set; default to the slowest one. */
522 if (hw_dev_config_set(dev_index, SR_HWCAP_SAMPLERATE,
523 &supported_samplerates[0]) == SR_ERR)
524 return SR_ERR;
525 }
526
527 return SR_OK;
528}
529
530static int hw_dev_close(int dev_index)
531{
532 struct sr_dev_inst *sdi;
533
534 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
535 sr_err("fx2lafw: %s: sdi was NULL.", __func__);
536 return SR_ERR_BUG;
537 }
538
539 /* TODO */
540 close_dev(sdi);
541
542 return SR_OK;
543}
544
545static int hw_cleanup(void)
546{
547 GSList *l;
548 struct sr_dev_inst *sdi;
549 struct context *ctx;
550 int ret = SR_OK;
551
552 for (l = dev_insts; l; l = l->next) {
553 if (!(sdi = l->data)) {
554 /* Log error, but continue cleaning up the rest. */
555 sr_err("fx2lafw: %s: sdi was NULL, continuing.",
556 __func__);
557 ret = SR_ERR_BUG;
558 continue;
559 }
560 if (!(ctx = sdi->priv)) {
561 /* Log error, but continue cleaning up the rest. */
562 sr_err("fx2lafw: %s: sdi->priv was NULL, continuing",
563 __func__);
564 ret = SR_ERR_BUG;
565 continue;
566 }
567 close_dev(sdi);
568 sdi = l->data;
569 sr_dev_inst_free(sdi);
570 }
571
572 g_slist_free(dev_insts);
573 dev_insts = NULL;
574
575 if (usb_context)
576 libusb_exit(usb_context);
577 usb_context = NULL;
578
579 return ret;
580}
581
582static const void *hw_dev_info_get(int dev_index, int dev_info_id)
583{
584 struct sr_dev_inst *sdi;
585 struct context *ctx;
586
587 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
588 return NULL;
589 ctx = sdi->priv;
590
591 switch (dev_info_id) {
592 case SR_DI_INST:
593 return sdi;
594 case SR_DI_NUM_PROBES:
595 return GINT_TO_POINTER(
596 (ctx->profile->dev_caps & DEV_CAPS_16BIT) ?
597 16 : 8);
598 case SR_DI_PROBE_NAMES:
599 return probe_names;
600 case SR_DI_SAMPLERATES:
601 return &samplerates;
602 case SR_DI_TRIGGER_TYPES:
603 return TRIGGER_TYPES;
604 case SR_DI_CUR_SAMPLERATE:
605 return &ctx->cur_samplerate;
606 }
607
608 return NULL;
609}
610
611static int hw_dev_status_get(int dev_index)
612{
613 const struct sr_dev_inst *const sdi =
614 sr_dev_inst_get(dev_insts, dev_index);
615
616 if (!sdi)
617 return SR_ST_NOT_FOUND;
618
619 return sdi->status;
620}
621
622static const int *hw_hwcap_get_all(void)
623{
624 return hwcaps;
625}
626
627static int hw_dev_config_set(int dev_index, int hwcap, const void *value)
628{
629 struct sr_dev_inst *sdi;
630 struct context *ctx;
631 int ret;
632
633 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
634 return SR_ERR;
635 ctx = sdi->priv;
636
637 if (hwcap == SR_HWCAP_SAMPLERATE) {
638 ctx->cur_samplerate = *(const uint64_t *)value;
639 ret = SR_OK;
640 } else if (hwcap == SR_HWCAP_PROBECONFIG) {
641 ret = configure_probes(ctx, (GSList *) value);
642 } else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
643 ctx->limit_samples = *(const uint64_t *)value;
644 ret = SR_OK;
645 } else {
646 ret = SR_ERR;
647 }
648
649 return ret;
650}
651
652static int receive_data(int fd, int revents, void *cb_data)
653{
654 struct timeval tv;
655
656 /* Avoid compiler warnings. */
657 (void)fd;
658 (void)revents;
659 (void)cb_data;
660
661 tv.tv_sec = tv.tv_usec = 0;
662 libusb_handle_events_timeout(usb_context, &tv);
663
664 return TRUE;
665}
666
667static void abort_acquisition(struct context *ctx)
668{
669 int i;
670
671 ctx->num_samples = -1;
672
673 for (i = ctx->num_transfers - 1; i >= 0; i--) {
674 if (ctx->transfers[i])
675 libusb_cancel_transfer(ctx->transfers[i]);
676 }
677}
678
679static void finish_acquisition(struct context *ctx)
680{
681 struct sr_datafeed_packet packet;
682 int i;
683
684 /* Terminate session */
685 packet.type = SR_DF_END;
686 sr_session_send(ctx->session_dev_id, &packet);
687
688 /* Remove fds from polling */
689 const struct libusb_pollfd **const lupfd =
690 libusb_get_pollfds(usb_context);
691 for (i = 0; lupfd[i]; i++)
692 sr_source_remove(lupfd[i]->fd);
693 free(lupfd); /* NOT g_free()! */
694
695 ctx->num_transfers = 0;
696 g_free(ctx->transfers);
697}
698
699static void free_transfer(struct libusb_transfer *transfer)
700{
701 struct context *ctx = transfer->user_data;
702 unsigned int i;
703
704 g_free(transfer->buffer);
705 transfer->buffer = NULL;
706 libusb_free_transfer(transfer);
707
708 for (i = 0; i < ctx->num_transfers; i++) {
709 if (ctx->transfers[i] == transfer) {
710 ctx->transfers[i] = NULL;
711 break;
712 }
713 }
714
715 ctx->submitted_transfers--;
716 if (ctx->submitted_transfers == 0)
717 finish_acquisition(ctx);
718
719}
720
721static void resubmit_transfer(struct libusb_transfer *transfer)
722{
723 if (libusb_submit_transfer(transfer) != 0) {
724 free_transfer(transfer);
725 /* TODO: Stop session? */
726 /* TODO: Better error message. */
727 sr_err("fx2lafw: %s: libusb_submit_transfer error.", __func__);
728 }
729}
730
731static void receive_transfer(struct libusb_transfer *transfer)
732{
733 gboolean packet_has_error = FALSE;
734 struct sr_datafeed_packet packet;
735 struct sr_datafeed_logic logic;
736 struct context *ctx = transfer->user_data;
737 int trigger_offset, i;
738
739 /*
740 * If acquisition has already ended, just free any queued up
741 * transfer that come in.
742 */
743 if (ctx->num_samples == -1) {
744 free_transfer(transfer);
745 return;
746 }
747
748 sr_info("fx2lafw: receive_transfer(): status %d received %d bytes.",
749 transfer->status, transfer->actual_length);
750
751 /* Save incoming transfer before reusing the transfer struct. */
752 uint8_t *const cur_buf = transfer->buffer;
753 const int sample_width = ctx->sample_wide ? 2 : 1;
754 const int cur_sample_count = transfer->actual_length / sample_width;
755
756 switch (transfer->status) {
757 case LIBUSB_TRANSFER_NO_DEVICE:
758 abort_acquisition(ctx);
759 free_transfer(transfer);
760 return;
761 case LIBUSB_TRANSFER_COMPLETED:
762 case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though */
763 break;
764 default:
765 packet_has_error = TRUE;
766 break;
767 }
768
769 if (transfer->actual_length == 0 || packet_has_error) {
770 ctx->empty_transfer_count++;
771 if (ctx->empty_transfer_count > MAX_EMPTY_TRANSFERS) {
772 /*
773 * The FX2 gave up. End the acquisition, the frontend
774 * will work out that the samplecount is short.
775 */
776 abort_acquisition(ctx);
777 free_transfer(transfer);
778 } else {
779 resubmit_transfer(transfer);
780 }
781 return;
782 } else {
783 ctx->empty_transfer_count = 0;
784 }
785
786 trigger_offset = 0;
787 if (ctx->trigger_stage >= 0) {
788 for (i = 0; i < cur_sample_count; i++) {
789
790 const uint16_t cur_sample = ctx->sample_wide ?
791 *((const uint16_t*)cur_buf + i) :
792 *((const uint8_t*)cur_buf + i);
793
794 if ((cur_sample & ctx->trigger_mask[ctx->trigger_stage]) ==
795 ctx->trigger_value[ctx->trigger_stage]) {
796 /* Match on this trigger stage. */
797 ctx->trigger_buffer[ctx->trigger_stage] = cur_sample;
798 ctx->trigger_stage++;
799
800 if (ctx->trigger_stage == NUM_TRIGGER_STAGES ||
801 ctx->trigger_mask[ctx->trigger_stage] == 0) {
802 /* Match on all trigger stages, we're done. */
803 trigger_offset = i + 1;
804
805 /*
806 * TODO: Send pre-trigger buffer to session bus.
807 * Tell the frontend we hit the trigger here.
808 */
809 packet.type = SR_DF_TRIGGER;
810 packet.payload = NULL;
811 sr_session_send(ctx->session_dev_id, &packet);
812
813 /*
814 * Send the samples that triggered it, since we're
815 * skipping past them.
816 */
817 packet.type = SR_DF_LOGIC;
818 packet.payload = &logic;
819 logic.unitsize = sizeof(*ctx->trigger_buffer);
820 logic.length = ctx->trigger_stage * logic.unitsize;
821 logic.data = ctx->trigger_buffer;
822 sr_session_send(ctx->session_dev_id, &packet);
823
824 ctx->trigger_stage = TRIGGER_FIRED;
825 break;
826 }
827 } else if (ctx->trigger_stage > 0) {
828 /*
829 * We had a match before, but not in the next sample. However, we may
830 * have a match on this stage in the next bit -- trigger on 0001 will
831 * fail on seeing 00001, so we need to go back to stage 0 -- but at
832 * the next sample from the one that matched originally, which the
833 * counter increment at the end of the loop takes care of.
834 */
835 i -= ctx->trigger_stage;
836 if (i < -1)
837 i = -1; /* Oops, went back past this buffer. */
838 /* Reset trigger stage. */
839 ctx->trigger_stage = 0;
840 }
841 }
842 }
843
844 if (ctx->trigger_stage == TRIGGER_FIRED) {
845 /* Send the incoming transfer to the session bus. */
846 const int trigger_offset_bytes = trigger_offset * sample_width;
847 packet.type = SR_DF_LOGIC;
848 packet.payload = &logic;
849 logic.length = transfer->actual_length - trigger_offset_bytes;
850 logic.unitsize = sample_width;
851 logic.data = cur_buf + trigger_offset_bytes;
852 sr_session_send(ctx->session_dev_id, &packet);
853
854 ctx->num_samples += cur_sample_count;
855 if (ctx->limit_samples &&
856 (unsigned int)ctx->num_samples > ctx->limit_samples) {
857 abort_acquisition(ctx);
858 free_transfer(transfer);
859 return;
860 }
861 } else {
862 /*
863 * TODO: Buffer pre-trigger data in capture
864 * ratio-sized buffer.
865 */
866 }
867
868 resubmit_transfer(transfer);
869}
870
871static unsigned int to_bytes_per_ms(unsigned int samplerate)
872{
873 return samplerate / 1000;
874}
875
876static size_t get_buffer_size(struct context *ctx)
877{
878 size_t s;
879
880 /* The buffer should be large enough to hold 10ms of data and a multiple
881 * of 512. */
882 s = 10 * to_bytes_per_ms(ctx->cur_samplerate);
883 return (s + 511) & ~511;
884}
885
886static unsigned int get_number_of_transfers(struct context *ctx)
887{
888 unsigned int n;
889
890 /* Total buffer size should be able to hold about 500ms of data */
891 n = 500 * to_bytes_per_ms(ctx->cur_samplerate) / get_buffer_size(ctx);
892
893 if (n > NUM_SIMUL_TRANSFERS)
894 return NUM_SIMUL_TRANSFERS;
895
896 return n;
897}
898
899static unsigned int get_timeout(struct context *ctx)
900{
901 size_t total_size;
902 unsigned int timeout;
903
904 total_size = get_buffer_size(ctx) * get_number_of_transfers(ctx);
905 timeout = total_size / to_bytes_per_ms(ctx->cur_samplerate);
906 return timeout + timeout / 4; /* Leave a headroom of 25% percent */
907}
908
909static int hw_dev_acquisition_start(int dev_index, void *cb_data)
910{
911 struct sr_dev_inst *sdi;
912 struct sr_datafeed_packet packet;
913 struct sr_datafeed_header header;
914 struct sr_datafeed_meta_logic meta;
915 struct context *ctx;
916 struct libusb_transfer *transfer;
917 const struct libusb_pollfd **lupfd;
918 unsigned int i;
919 int ret;
920 unsigned char *buf;
921
922 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
923 return SR_ERR;
924 ctx = sdi->priv;
925
926 if (ctx->submitted_transfers != 0)
927 return SR_ERR;
928
929 ctx->session_dev_id = cb_data;
930 ctx->num_samples = 0;
931 ctx->empty_transfer_count = 0;
932
933 const unsigned int timeout = get_timeout(ctx);
934 const unsigned int num_transfers = get_number_of_transfers(ctx);
935 const size_t size = get_buffer_size(ctx);
936
937 ctx->transfers = g_try_malloc0(sizeof(*ctx->transfers) * num_transfers);
938 if (!ctx->transfers)
939 return SR_ERR;
940
941 ctx->num_transfers = num_transfers;
942
943 for (i = 0; i < num_transfers; i++) {
944 if (!(buf = g_try_malloc(size))) {
945 sr_err("fx2lafw: %s: buf malloc failed.", __func__);
946 return SR_ERR_MALLOC;
947 }
948 transfer = libusb_alloc_transfer(0);
949 libusb_fill_bulk_transfer(transfer, ctx->usb->devhdl,
950 2 | LIBUSB_ENDPOINT_IN, buf, size,
951 receive_transfer, ctx, timeout);
952 if (libusb_submit_transfer(transfer) != 0) {
953 libusb_free_transfer(transfer);
954 g_free(buf);
955 abort_acquisition(ctx);
956 return SR_ERR;
957 }
958 ctx->transfers[i] = transfer;
959 ctx->submitted_transfers++;
960 }
961
962 lupfd = libusb_get_pollfds(usb_context);
963 for (i = 0; lupfd[i]; i++)
964 sr_source_add(lupfd[i]->fd, lupfd[i]->events,
965 timeout, receive_data, NULL);
966 free(lupfd); /* NOT g_free()! */
967
968 packet.type = SR_DF_HEADER;
969 packet.payload = &header;
970 header.feed_version = 1;
971 gettimeofday(&header.starttime, NULL);
972 sr_session_send(cb_data, &packet);
973
974 /* Send metadata about the SR_DF_LOGIC packets to come. */
975 packet.type = SR_DF_META_LOGIC;
976 packet.payload = &meta;
977 meta.samplerate = ctx->cur_samplerate;
978 meta.num_probes = ctx->sample_wide ? 16 : 8;
979 sr_session_send(cb_data, &packet);
980
981 if ((ret = command_start_acquisition (ctx->usb->devhdl,
982 ctx->cur_samplerate, ctx->sample_wide)) != SR_OK) {
983 abort_acquisition(ctx);
984 return ret;
985 }
986
987 return SR_OK;
988}
989
990/* TODO: This stops acquisition on ALL devices, ignoring dev_index. */
991static int hw_dev_acquisition_stop(int dev_index, void *cb_data)
992{
993 struct sr_dev_inst *sdi;
994
995 /* Avoid compiler warnings. */
996 (void)cb_data;
997
998 if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
999 return SR_ERR;
1000
1001 abort_acquisition(sdi->priv);
1002
1003 return SR_OK;
1004}
1005
1006SR_PRIV struct sr_dev_driver fx2lafw_driver_info = {
1007 .name = "fx2lafw",
1008 .longname = "fx2lafw (generic driver for FX2 based LAs)",
1009 .api_version = 1,
1010 .init = hw_init,
1011 .cleanup = hw_cleanup,
1012 .dev_open = hw_dev_open,
1013 .dev_close = hw_dev_close,
1014 .dev_info_get = hw_dev_info_get,
1015 .dev_status_get = hw_dev_status_get,
1016 .hwcap_get_all = hw_hwcap_get_all,
1017 .dev_config_set = hw_dev_config_set,
1018 .dev_acquisition_start = hw_dev_acquisition_start,
1019 .dev_acquisition_stop = hw_dev_acquisition_stop,
1020};
Hardware access and backend lib