hardware/fx2lafw/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013 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 "protocol.h"
  22
  23 static const struct fx2lafw_profile supported_fx2[] = {
  24         /*
  25          * CWAV USBee AX
  26          * EE Electronics ESLA201A
  27          * ARMFLY AX-Pro
  28          */
  29         { 0x08a9, 0x0014, "CWAV", "USBee AX", NULL,
  30                 FIRMWARE_DIR "/fx2lafw-cwav-usbeeax.fw",
  31                 0, NULL, NULL},
  32         /*
  33          * CWAV USBee DX
  34          * XZL-Studio DX
  35          */
  36         { 0x08a9, 0x0015, "CWAV", "USBee DX", NULL,
  37                 FIRMWARE_DIR "/fx2lafw-cwav-usbeedx.fw",
  38                 DEV_CAPS_16BIT, NULL, NULL },
  39
  40         /*
  41          * CWAV USBee SX
  42          */
  43         { 0x08a9, 0x0009, "CWAV", "USBee SX", NULL,
  44                 FIRMWARE_DIR "/fx2lafw-cwav-usbeesx.fw",
  45                 0, NULL, NULL},
  46
  47         /*
  48          * Saleae Logic
  49          * EE Electronics ESLA100
  50          * Robomotic MiniLogic
  51          * Robomotic BugLogic 3
  52          */
  53         { 0x0925, 0x3881, "Saleae", "Logic", NULL,
  54                 FIRMWARE_DIR "/fx2lafw-saleae-logic.fw",
  55                 0, NULL, NULL},
  56
  57         /*
  58          * Default Cypress FX2 without EEPROM, e.g.:
  59          * Lcsoft Mini Board
  60          * Braintechnology USB Interface V2.x
  61          */
  62         { 0x04B4, 0x8613, "Cypress", "FX2", NULL,
  63                 FIRMWARE_DIR "/fx2lafw-cypress-fx2.fw",
  64                 DEV_CAPS_16BIT, NULL, NULL },
  65
  66         /*
  67          * Braintechnology USB-LPS
  68          */
  69         { 0x16d0, 0x0498, "Braintechnology", "USB-LPS", NULL,
  70                 FIRMWARE_DIR "/fx2lafw-braintechnology-usb-lps.fw",
  71                 DEV_CAPS_16BIT, NULL, NULL },
  72
  73         { 0, 0, 0, 0, 0, 0, 0, 0, 0 }
  74 };
  75
  76 static const int32_t hwopts[] = {
  77         SR_CONF_CONN,
  78 };
  79
  80 static const int32_t hwcaps[] = {
  81         SR_CONF_LOGIC_ANALYZER,
  82         SR_CONF_TRIGGER_MATCH,
  83         SR_CONF_SAMPLERATE,
  84
  85         /* These are really implemented in the driver, not the hardware. */
  86         SR_CONF_LIMIT_SAMPLES,
  87         SR_CONF_CONTINUOUS,
  88 };
  89
  90 static const char *channel_names[] = {
  91         "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
  92         "8",  "9", "10", "11", "12", "13", "14", "15",
  93         NULL,
  94 };
  95
  96 static const int32_t soft_trigger_matches[] = {
  97         SR_TRIGGER_ZERO,
  98         SR_TRIGGER_ONE,
  99 };
 100
 101 static const uint64_t samplerates[] = {
 102         SR_KHZ(20),
 103         SR_KHZ(25),
 104         SR_KHZ(50),
 105         SR_KHZ(100),
 106         SR_KHZ(200),
 107         SR_KHZ(250),
 108         SR_KHZ(500),
 109         SR_MHZ(1),
 110         SR_MHZ(2),
 111         SR_MHZ(3),
 112         SR_MHZ(4),
 113         SR_MHZ(6),
 114         SR_MHZ(8),
 115         SR_MHZ(12),
 116         SR_MHZ(16),
 117         SR_MHZ(24),
 118 };
 119
 120 SR_PRIV struct sr_dev_driver fx2lafw_driver_info;
 121 static struct sr_dev_driver *di = &fx2lafw_driver_info;
 122
 123 static int init(struct sr_context *sr_ctx)
 124 {
 125         return std_init(sr_ctx, di, LOG_PREFIX);
 126 }
 127
 128 static GSList *scan(GSList *options)
 129 {
 130         struct drv_context *drvc;
 131         struct dev_context *devc;
 132         struct sr_dev_inst *sdi;
 133         struct sr_usb_dev_inst *usb;
 134         struct sr_channel *ch;
 135         struct sr_config *src;
 136         const struct fx2lafw_profile *prof;
 137         GSList *l, *devices, *conn_devices;
 138         struct libusb_device_descriptor des;
 139         libusb_device **devlist;
 140         struct libusb_device_handle *hdl;
 141         int devcnt, num_logic_channels, ret, i, j;
 142         const char *conn;
 143         char manufacturer[64], product[64];
 144
 145         drvc = di->priv;
 146
 147         conn = NULL;
 148         for (l = options; l; l = l->next) {
 149                 src = l->data;
 150                 switch (src->key) {
 151                 case SR_CONF_CONN:
 152                         conn = g_variant_get_string(src->data, NULL);
 153                         break;
 154                 }
 155         }
 156         if (conn)
 157                 conn_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
 158         else
 159                 conn_devices = NULL;
 160
 161         /* Find all fx2lafw compatible devices and upload firmware to them. */
 162         devices = NULL;
 163         libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
 164         for (i = 0; devlist[i]; i++) {
 165                 if (conn) {
 166                         usb = NULL;
 167                         for (l = conn_devices; l; l = l->next) {
 168                                 usb = l->data;
 169                                 if (usb->bus == libusb_get_bus_number(devlist[i])
 170                                         && usb->address == libusb_get_device_address(devlist[i]))
 171                                         break;
 172                         }
 173                         if (!l)
 174                                 /* This device matched none of the ones that
 175                                  * matched the conn specification. */
 176                                 continue;
 177                 }
 178
 179                 if ((ret = libusb_get_device_descriptor( devlist[i], &des)) != 0) {
 180                         sr_warn("Failed to get device descriptor: %s.",
 181                                 libusb_error_name(ret));
 182                         continue;
 183                 }
 184
 185                 if ((ret = libusb_open(devlist[i], &hdl)) < 0)
 186                         continue;
 187
 188                 if (des.iManufacturer == 0) {
 189                         manufacturer[0] = '\0';
 190                 } else if ((ret = libusb_get_string_descriptor_ascii(hdl,
 191                                 des.iManufacturer, (unsigned char *) manufacturer,
 192                                 sizeof(manufacturer))) < 0) {
 193                         sr_warn("Failed to get manufacturer string descriptor: %s.",
 194                                 libusb_error_name(ret));
 195                         continue;
 196                 }
 197
 198                 if (des.iProduct == 0) {
 199                         product[0] = '\0';
 200                 } else if ((ret = libusb_get_string_descriptor_ascii(hdl,
 201                                 des.iProduct, (unsigned char *) product,
 202                                 sizeof(product))) < 0) {
 203                         sr_warn("Failed to get product string descriptor: %s.",
 204                                 libusb_error_name(ret));
 205                         continue;
 206                 }
 207
 208                 libusb_close(hdl);
 209
 210                 prof = NULL;
 211                 for (j = 0; supported_fx2[j].vid; j++) {
 212                         if (des.idVendor == supported_fx2[j].vid &&
 213                                         des.idProduct == supported_fx2[j].pid &&
 214                                         (!supported_fx2[j].usb_manufacturer ||
 215                                          !strcmp(manufacturer, supported_fx2[j].usb_manufacturer)) &&
 216                                         (!supported_fx2[j].usb_manufacturer ||
 217                                          !strcmp(product, supported_fx2[j].usb_product))) {
 218                                 prof = &supported_fx2[j];
 219                                 break;
 220                         }
 221                 }
 222
 223                 /* Skip if the device was not found. */
 224                 if (!prof)
 225                         continue;
 226
 227                 devcnt = g_slist_length(drvc->instances);
 228                 sdi = sr_dev_inst_new(devcnt, SR_ST_INITIALIZING,
 229                         prof->vendor, prof->model, prof->model_version);
 230                 if (!sdi)
 231                         return NULL;
 232                 sdi->driver = di;
 233
 234                 /* Fill in channellist according to this device's profile. */
 235                 num_logic_channels = prof->dev_caps & DEV_CAPS_16BIT ? 16 : 8;
 236                 for (j = 0; j < num_logic_channels; j++) {
 237                         if (!(ch = sr_channel_new(j, SR_CHANNEL_LOGIC, TRUE,
 238                                         channel_names[j])))
 239                                 return NULL;
 240                         sdi->channels = g_slist_append(sdi->channels, ch);
 241                 }
 242
 243                 devc = fx2lafw_dev_new();
 244                 devc->profile = prof;
 245                 sdi->priv = devc;
 246                 drvc->instances = g_slist_append(drvc->instances, sdi);
 247                 devices = g_slist_append(devices, sdi);
 248
 249                 if (fx2lafw_check_conf_profile(devlist[i])) {
 250                         /* Already has the firmware, so fix the new address. */
 251                         sr_dbg("Found an fx2lafw device.");
 252                         sdi->status = SR_ST_INACTIVE;
 253                         sdi->inst_type = SR_INST_USB;
 254                         sdi->conn = sr_usb_dev_inst_new(libusb_get_bus_number(devlist[i]),
 255                                         libusb_get_device_address(devlist[i]), NULL);
 256                 } else {
 257                         if (ezusb_upload_firmware(devlist[i], USB_CONFIGURATION,
 258                                 prof->firmware) == SR_OK)
 259                                 /* Store when this device's FW was updated. */
 260                                 devc->fw_updated = g_get_monotonic_time();
 261                         else
 262                                 sr_err("Firmware upload failed for "
 263                                        "device %d.", devcnt);
 264                         sdi->inst_type = SR_INST_USB;
 265                         sdi->conn = sr_usb_dev_inst_new(libusb_get_bus_number(devlist[i]),
 266                                         0xff, NULL);
 267                 }
 268         }
 269         libusb_free_device_list(devlist, 1);
 270         g_slist_free_full(conn_devices, (GDestroyNotify)sr_usb_dev_inst_free);
 271
 272         return devices;
 273 }
 274
 275 static GSList *dev_list(void)
 276 {
 277         return ((struct drv_context *)(di->priv))->instances;
 278 }
 279
 280 static int dev_open(struct sr_dev_inst *sdi)
 281 {
 282         struct sr_usb_dev_inst *usb;
 283         struct dev_context *devc;
 284         int ret;
 285         int64_t timediff_us, timediff_ms;
 286
 287         devc = sdi->priv;
 288         usb = sdi->conn;
 289
 290         /*
 291          * If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS
 292          * milliseconds for the FX2 to renumerate.
 293          */
 294         ret = SR_ERR;
 295         if (devc->fw_updated > 0) {
 296                 sr_info("Waiting for device to reset.");
 297                 /* Takes >= 300ms for the FX2 to be gone from the USB bus. */
 298                 g_usleep(300 * 1000);
 299                 timediff_ms = 0;
 300                 while (timediff_ms < MAX_RENUM_DELAY_MS) {
 301                         if ((ret = fx2lafw_dev_open(sdi, di)) == SR_OK)
 302                                 break;
 303                         g_usleep(100 * 1000);
 304
 305                         timediff_us = g_get_monotonic_time() - devc->fw_updated;
 306                         timediff_ms = timediff_us / 1000;
 307                         sr_spew("Waited %" PRIi64 "ms.", timediff_ms);
 308                 }
 309                 if (ret != SR_OK) {
 310                         sr_err("Device failed to renumerate.");
 311                         return SR_ERR;
 312                 }
 313                 sr_info("Device came back after %" PRIi64 "ms.", timediff_ms);
 314         } else {
 315                 sr_info("Firmware upload was not needed.");
 316                 ret = fx2lafw_dev_open(sdi, di);
 317         }
 318
 319         if (ret != SR_OK) {
 320                 sr_err("Unable to open device.");
 321                 return SR_ERR;
 322         }
 323
 324         ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE);
 325         if (ret != 0) {
 326                 switch (ret) {
 327                 case LIBUSB_ERROR_BUSY:
 328                         sr_err("Unable to claim USB interface. Another "
 329                                "program or driver has already claimed it.");
 330                         break;
 331                 case LIBUSB_ERROR_NO_DEVICE:
 332                         sr_err("Device has been disconnected.");
 333                         break;
 334                 default:
 335                         sr_err("Unable to claim interface: %s.",
 336                                libusb_error_name(ret));
 337                         break;
 338                 }
 339
 340                 return SR_ERR;
 341         }
 342
 343         if (devc->cur_samplerate == 0) {
 344                 /* Samplerate hasn't been set; default to the slowest one. */
 345                 devc->cur_samplerate = samplerates[0];
 346         }
 347
 348         return SR_OK;
 349 }
 350
 351 static int dev_close(struct sr_dev_inst *sdi)
 352 {
 353         struct sr_usb_dev_inst *usb;
 354
 355         usb = sdi->conn;
 356         if (usb->devhdl == NULL)
 357                 return SR_ERR;
 358
 359         sr_info("fx2lafw: Closing device %d on %d.%d interface %d.",
 360                 sdi->index, usb->bus, usb->address, USB_INTERFACE);
 361         libusb_release_interface(usb->devhdl, USB_INTERFACE);
 362         libusb_close(usb->devhdl);
 363         usb->devhdl = NULL;
 364         sdi->status = SR_ST_INACTIVE;
 365
 366         return SR_OK;
 367 }
 368
 369 static int cleanup(void)
 370 {
 371         int ret;
 372         struct drv_context *drvc;
 373
 374         if (!(drvc = di->priv))
 375                 return SR_OK;
 376
 377         ret = std_dev_clear(di, NULL);
 378
 379         g_free(drvc);
 380         di->priv = NULL;
 381
 382         return ret;
 383 }
 384
 385 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 386                 const struct sr_channel_group *cg)
 387 {
 388         struct dev_context *devc;
 389         struct sr_usb_dev_inst *usb;
 390         char str[128];
 391
 392         (void)cg;
 393
 394         if (!sdi)
 395                 return SR_ERR_ARG;
 396
 397         devc = sdi->priv;
 398
 399         switch (id) {
 400         case SR_CONF_CONN:
 401                 if (!sdi->conn)
 402                         return SR_ERR_ARG;
 403                 usb = sdi->conn;
 404                 if (usb->address == 255)
 405                         /* Device still needs to re-enumerate after firmware
 406                          * upload, so we don't know its (future) address. */
 407                         return SR_ERR;
 408                 snprintf(str, 128, "%d.%d", usb->bus, usb->address);
 409                 *data = g_variant_new_string(str);
 410                 break;
 411         case SR_CONF_LIMIT_SAMPLES:
 412                 *data = g_variant_new_uint64(devc->limit_samples);
 413                 break;
 414         case SR_CONF_SAMPLERATE:
 415                 *data = g_variant_new_uint64(devc->cur_samplerate);
 416                 break;
 417         default:
 418                 return SR_ERR_NA;
 419         }
 420
 421         return SR_OK;
 422 }
 423
 424 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 425                 const struct sr_channel_group *cg)
 426 {
 427         struct dev_context *devc;
 428         int ret;
 429
 430         (void)cg;
 431
 432         if (!sdi)
 433                 return SR_ERR_ARG;
 434
 435         if (sdi->status != SR_ST_ACTIVE)
 436                 return SR_ERR;
 437
 438         devc = sdi->priv;
 439
 440         ret = SR_OK;
 441
 442         switch (id)
 443         {
 444                 case SR_CONF_SAMPLERATE:
 445                         devc->cur_samplerate = g_variant_get_uint64(data);
 446                         break;
 447                 case SR_CONF_LIMIT_SAMPLES:
 448                         devc->limit_samples = g_variant_get_uint64(data);
 449                         break;
 450                 default:
 451                         ret = SR_ERR_NA;
 452         }
 453
 454         return ret;
 455 }
 456
 457 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 458                 const struct sr_channel_group *cg)
 459 {
 460         GVariant *gvar;
 461         GVariantBuilder gvb;
 462
 463         (void)sdi;
 464         (void)cg;
 465
 466         switch (key) {
 467         case SR_CONF_SCAN_OPTIONS:
 468                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 469                                 hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
 470                 break;
 471         case SR_CONF_DEVICE_OPTIONS:
 472                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 473                                 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 474                 break;
 475         case SR_CONF_SAMPLERATE:
 476                 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 477                 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
 478                                 ARRAY_SIZE(samplerates), sizeof(uint64_t));
 479                 g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
 480                 *data = g_variant_builder_end(&gvb);
 481                 break;
 482         case SR_CONF_TRIGGER_MATCH:
 483                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 484                                 soft_trigger_matches, ARRAY_SIZE(soft_trigger_matches),
 485                                 sizeof(int32_t));
 486                 break;
 487         default:
 488                 return SR_ERR_NA;
 489         }
 490
 491         return SR_OK;
 492 }
 493
 494 static int receive_data(int fd, int revents, void *cb_data)
 495 {
 496         struct timeval tv;
 497         struct drv_context *drvc;
 498
 499         (void)fd;
 500         (void)revents;
 501         (void)cb_data;
 502
 503         drvc = di->priv;
 504
 505         tv.tv_sec = tv.tv_usec = 0;
 506         libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
 507
 508         return TRUE;
 509 }
 510
 511 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 512 {
 513         struct dev_context *devc;
 514         struct drv_context *drvc;
 515         struct sr_usb_dev_inst *usb;
 516         struct libusb_transfer *transfer;
 517         unsigned int i, timeout, num_transfers;
 518         int ret;
 519         unsigned char *buf;
 520         size_t size;
 521
 522         if (sdi->status != SR_ST_ACTIVE)
 523                 return SR_ERR_DEV_CLOSED;
 524
 525         drvc = di->priv;
 526         devc = sdi->priv;
 527         usb = sdi->conn;
 528
 529         devc->cb_data = cb_data;
 530         devc->sent_samples = 0;
 531         devc->acq_aborted = FALSE;
 532         devc->empty_transfer_count = 0;
 533
 534         if (sr_session_trigger_get()) {
 535                 devc->trigger_fired = FALSE;
 536                 devc->cur_trigger_stage = 0;
 537                 devc->cur_trigger_step = 0;
 538         } else
 539                 devc->trigger_fired = TRUE;
 540
 541         timeout = fx2lafw_get_timeout(devc);
 542         num_transfers = fx2lafw_get_number_of_transfers(devc);
 543         size = fx2lafw_get_buffer_size(devc);
 544         devc->submitted_transfers = 0;
 545
 546         devc->transfers = g_try_malloc0(sizeof(*devc->transfers) * num_transfers);
 547         if (!devc->transfers) {
 548                 sr_err("USB transfers malloc failed.");
 549                 return SR_ERR_MALLOC;
 550         }
 551
 552         devc->num_transfers = num_transfers;
 553         for (i = 0; i < num_transfers; i++) {
 554                 if (!(buf = g_try_malloc(size))) {
 555                         sr_err("USB transfer buffer malloc failed.");
 556                         return SR_ERR_MALLOC;
 557                 }
 558                 transfer = libusb_alloc_transfer(0);
 559                 libusb_fill_bulk_transfer(transfer, usb->devhdl,
 560                                 2 | LIBUSB_ENDPOINT_IN, buf, size,
 561                                 fx2lafw_receive_transfer, (void *)sdi, timeout);
 562                 if ((ret = libusb_submit_transfer(transfer)) != 0) {
 563                         sr_err("Failed to submit transfer: %s.",
 564                                libusb_error_name(ret));
 565                         libusb_free_transfer(transfer);
 566                         g_free(buf);
 567                         fx2lafw_abort_acquisition(devc);
 568                         return SR_ERR;
 569                 }
 570                 devc->transfers[i] = transfer;
 571                 devc->submitted_transfers++;
 572         }
 573
 574         devc->ctx = drvc->sr_ctx;
 575
 576         usb_source_add(devc->ctx, timeout, receive_data, NULL);
 577
 578         /* Send header packet to the session bus. */
 579         std_session_send_df_header(cb_data, LOG_PREFIX);
 580
 581         if ((ret = fx2lafw_command_start_acquisition(sdi)) != SR_OK) {
 582                 fx2lafw_abort_acquisition(devc);
 583                 return ret;
 584         }
 585
 586         return SR_OK;
 587 }
 588
 589 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 590 {
 591         (void)cb_data;
 592
 593         fx2lafw_abort_acquisition(sdi->priv);
 594
 595         return SR_OK;
 596 }
 597
 598 SR_PRIV struct sr_dev_driver fx2lafw_driver_info = {
 599         .name = "fx2lafw",
 600         .longname = "fx2lafw (generic driver for FX2 based LAs)",
 601         .api_version = 1,
 602         .init = init,
 603         .cleanup = cleanup,
 604         .scan = scan,
 605         .dev_list = dev_list,
 606         .dev_clear = NULL,
 607         .config_get = config_get,
 608         .config_set = config_set,
 609         .config_list = config_list,
 610         .dev_open = dev_open,
 611         .dev_close = dev_close,
 612         .dev_acquisition_start = dev_acquisition_start,
 613         .dev_acquisition_stop = dev_acquisition_stop,
 614         .priv = NULL,
 615 };