hardware/fx2lafw/fx2lafw.c

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