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         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
 459 static 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
 530 static 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
 545 static 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
 582 static 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
 611 static 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
 622 static const int *hw_hwcap_get_all(void)
 623 {
 624         return hwcaps;
 625 }
 626
 627 static 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
 652 static 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
 667 static 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
 679 static 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
 699 static 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
 721 static 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
 731 static 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
 871 static unsigned int to_bytes_per_ms(unsigned int samplerate)
 872 {
 873         return samplerate / 1000;
 874 }
 875
 876 static 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
 886 static 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
 899 static 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
 909 static 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. */
 991 static 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
1006 SR_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 };