hardware/zeroplus-logic-cube/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "protocol.h"
  21
  22 #define VENDOR_NAME                     "ZEROPLUS"
  23 #define USB_INTERFACE                   0
  24 #define USB_CONFIGURATION               1
  25 #define NUM_TRIGGER_STAGES              4
  26 #define TRIGGER_TYPE                    "01"
  27 #define PACKET_SIZE                     2048    /* ?? */
  28
  29 //#define ZP_EXPERIMENTAL
  30
  31 struct zp_model {
  32         uint16_t vid;
  33         uint16_t pid;
  34         char *model_name;
  35         unsigned int channels;
  36         unsigned int sample_depth;      /* In Ksamples/channel */
  37         unsigned int max_sampling_freq;
  38 };
  39
  40 /*
  41  * Note -- 16032, 16064 and 16128 *usually* -- but not always -- have the
  42  * same 128K sample depth.
  43  */
  44 static const struct zp_model zeroplus_models[] = {
  45         {0x0c12, 0x7002, "LAP-16128U",    16, 128,  200},
  46         {0x0c12, 0x7009, "LAP-C(16064)",  16, 64,   100},
  47         {0x0c12, 0x700a, "LAP-C(16128)",  16, 128,  200},
  48         {0x0c12, 0x700b, "LAP-C(32128)",  32, 128,  200},
  49         {0x0c12, 0x700c, "LAP-C(321000)", 32, 1024, 200},
  50         {0x0c12, 0x700d, "LAP-C(322000)", 32, 2048, 200},
  51         {0x0c12, 0x700e, "LAP-C(16032)",  16, 32,   100},
  52         {0x0c12, 0x7016, "LAP-C(162000)", 16, 2048, 200},
  53         { 0, 0, 0, 0, 0, 0 }
  54 };
  55
  56 static const int32_t hwcaps[] = {
  57         SR_CONF_LOGIC_ANALYZER,
  58         SR_CONF_SAMPLERATE,
  59         SR_CONF_CAPTURE_RATIO,
  60         SR_CONF_VOLTAGE_THRESHOLD,
  61         SR_CONF_LIMIT_SAMPLES,
  62 };
  63
  64 /*
  65  * ZEROPLUS LAP-C (16032) numbers the 16 channels A0-A7 and B0-B7.
  66  * We currently ignore other untested/unsupported devices here.
  67  */
  68 static const char *channel_names[] = {
  69         "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
  70         "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7",
  71         "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7",
  72         "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
  73         NULL,
  74 };
  75
  76 SR_PRIV struct sr_dev_driver zeroplus_logic_cube_driver_info;
  77 static struct sr_dev_driver *di = &zeroplus_logic_cube_driver_info;
  78
  79 /*
  80  * The hardware supports more samplerates than these, but these are the
  81  * options hardcoded into the vendor's Windows GUI.
  82  */
  83
  84 static const uint64_t samplerates_100[] = {
  85         SR_HZ(100),
  86         SR_HZ(500),
  87         SR_KHZ(1),
  88         SR_KHZ(5),
  89         SR_KHZ(25),
  90         SR_KHZ(50),
  91         SR_KHZ(100),
  92         SR_KHZ(200),
  93         SR_KHZ(400),
  94         SR_KHZ(800),
  95         SR_MHZ(1),
  96         SR_MHZ(10),
  97         SR_MHZ(25),
  98         SR_MHZ(50),
  99         SR_MHZ(80),
 100         SR_MHZ(100),
 101 };
 102
 103 const uint64_t samplerates_200[] = {
 104         SR_HZ(100),
 105         SR_HZ(500),
 106         SR_KHZ(1),
 107         SR_KHZ(5),
 108         SR_KHZ(25),
 109         SR_KHZ(50),
 110         SR_KHZ(100),
 111         SR_KHZ(200),
 112         SR_KHZ(400),
 113         SR_KHZ(800),
 114         SR_MHZ(1),
 115         SR_MHZ(10),
 116         SR_MHZ(25),
 117         SR_MHZ(50),
 118         SR_MHZ(80),
 119         SR_MHZ(100),
 120         SR_MHZ(150),
 121         SR_MHZ(200),
 122 };
 123
 124 static int dev_close(struct sr_dev_inst *sdi);
 125
 126 #if 0
 127 static int configure_channels(const struct sr_dev_inst *sdi)
 128 {
 129         struct dev_context *devc;
 130         const struct sr_channel *ch;
 131         const GSList *l;
 132         int channel_bit, stage, i;
 133         char *tc;
 134
 135         /* Note: sdi and sdi->priv are non-NULL, the caller checked this. */
 136         devc = sdi->priv;
 137
 138         devc->channel_mask = 0;
 139         for (i = 0; i < NUM_TRIGGER_STAGES; i++) {
 140                 devc->trigger_mask[i] = 0;
 141                 devc->trigger_value[i] = 0;
 142         }
 143
 144         stage = -1;
 145         for (l = sdi->channels; l; l = l->next) {
 146                 ch = (struct sr_channel *)l->data;
 147                 if (ch->enabled == FALSE)
 148                         continue;
 149                 channel_bit = 1 << (ch->index);
 150                 devc->channel_mask |= channel_bit;
 151
 152                 if (ch->trigger) {
 153                         stage = 0;
 154                         for (tc = ch->trigger; *tc; tc++) {
 155                                 devc->trigger_mask[stage] |= channel_bit;
 156                                 if (*tc == '1')
 157                                         devc->trigger_value[stage] |= channel_bit;
 158                                 stage++;
 159                                 if (stage > NUM_TRIGGER_STAGES)
 160                                         return SR_ERR;
 161                         }
 162                 }
 163         }
 164
 165         return SR_OK;
 166 }
 167 #endif
 168
 169 static int configure_channels(const struct sr_dev_inst *sdi)
 170 {
 171         struct dev_context *devc;
 172         const GSList *l;
 173         const struct sr_channel *ch;
 174         char *tc;
 175         int type;
 176
 177         /* Note: sdi and sdi->priv are non-NULL, the caller checked this. */
 178         devc = sdi->priv;
 179
 180         for (l = sdi->channels; l; l = l->next) {
 181                 ch = (struct sr_channel *)l->data;
 182                 if (ch->enabled == FALSE)
 183                         continue;
 184
 185                 if ((tc = ch->trigger)) {
 186                         switch (*tc) {
 187                         case '1':
 188                                 type = TRIGGER_HIGH;
 189                                 break;
 190                         case '0':
 191                                 type = TRIGGER_LOW;
 192                                 break;
 193 #if 0
 194                         case 'r':
 195                                 type = TRIGGER_POSEDGE;
 196                                 break;
 197                         case 'f':
 198                                 type = TRIGGER_NEGEDGE;
 199                                 break;
 200                         case 'c':
 201                                 type = TRIGGER_ANYEDGE;
 202                                 break;
 203 #endif
 204                         default:
 205                                 return SR_ERR;
 206                         }
 207                         analyzer_add_trigger(ch->index, type);
 208                         devc->trigger = 1;
 209                 }
 210         }
 211
 212         return SR_OK;
 213 }
 214
 215 SR_PRIV int zp_set_samplerate(struct dev_context *devc, uint64_t samplerate)
 216 {
 217         int i;
 218
 219         for (i = 0; ARRAY_SIZE(samplerates_200); i++)
 220                 if (samplerate == samplerates_200[i])
 221                         break;
 222
 223         if (i == ARRAY_SIZE(samplerates_200) || samplerate > devc->max_samplerate) {
 224                 sr_err("Unsupported samplerate: %" PRIu64 "Hz.", samplerate);
 225                 return SR_ERR_ARG;
 226         }
 227
 228         sr_info("Setting samplerate to %" PRIu64 "Hz.", samplerate);
 229
 230         if (samplerate >= SR_MHZ(1))
 231                 analyzer_set_freq(samplerate / SR_MHZ(1), FREQ_SCALE_MHZ);
 232         else if (samplerate >= SR_KHZ(1))
 233                 analyzer_set_freq(samplerate / SR_KHZ(1), FREQ_SCALE_KHZ);
 234         else
 235                 analyzer_set_freq(samplerate, FREQ_SCALE_HZ);
 236
 237         devc->cur_samplerate = samplerate;
 238
 239         return SR_OK;
 240 }
 241
 242 static int init(struct sr_context *sr_ctx)
 243 {
 244         return std_init(sr_ctx, di, LOG_PREFIX);
 245 }
 246
 247 static GSList *scan(GSList *options)
 248 {
 249         struct sr_dev_inst *sdi;
 250         struct sr_channel *ch;
 251         struct drv_context *drvc;
 252         struct dev_context *devc;
 253         const struct zp_model *prof;
 254         struct libusb_device_descriptor des;
 255         libusb_device **devlist;
 256         GSList *devices;
 257         int ret, devcnt, i, j;
 258
 259         (void)options;
 260
 261         drvc = di->priv;
 262
 263         devices = NULL;
 264
 265         /* Find all ZEROPLUS analyzers and add them to device list. */
 266         devcnt = 0;
 267         libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist); /* TODO: Errors. */
 268
 269         for (i = 0; devlist[i]; i++) {
 270                 ret = libusb_get_device_descriptor(devlist[i], &des);
 271                 if (ret != 0) {
 272                         sr_err("Failed to get device descriptor: %s.",
 273                                libusb_error_name(ret));
 274                         continue;
 275                 }
 276
 277                 prof = NULL;
 278                 for (j = 0; j < zeroplus_models[j].vid; j++) {
 279                         if (des.idVendor == zeroplus_models[j].vid &&
 280                                 des.idProduct == zeroplus_models[j].pid) {
 281                                 prof = &zeroplus_models[j];
 282                         }
 283                 }
 284                 /* Skip if the device was not found. */
 285                 if (!prof)
 286                         continue;
 287                 sr_info("Found ZEROPLUS %s.", prof->model_name);
 288
 289                 /* Register the device with libsigrok. */
 290                 if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_INACTIVE,
 291                                 VENDOR_NAME, prof->model_name, NULL))) {
 292                         sr_err("%s: sr_dev_inst_new failed", __func__);
 293                         return NULL;
 294                 }
 295                 sdi->driver = di;
 296
 297                 /* Allocate memory for our private driver context. */
 298                 if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
 299                         sr_err("Device context malloc failed.");
 300                         return NULL;
 301                 }
 302
 303                 sdi->priv = devc;
 304                 devc->prof = prof;
 305                 devc->num_channels = prof->channels;
 306 #ifdef ZP_EXPERIMENTAL
 307                 devc->max_sample_depth = 128 * 1024;
 308                 devc->max_samplerate = 200;
 309 #else
 310                 devc->max_sample_depth = prof->sample_depth * 1024;
 311                 devc->max_samplerate = prof->max_sampling_freq;
 312 #endif
 313                 devc->max_samplerate *= SR_MHZ(1);
 314                 devc->memory_size = MEMORY_SIZE_8K;
 315                 // memset(devc->trigger_buffer, 0, NUM_TRIGGER_STAGES);
 316
 317                 /* Fill in channellist according to this device's profile. */
 318                 for (j = 0; j < devc->num_channels; j++) {
 319                         if (!(ch = sr_probe_new(j, SR_PROBE_LOGIC, TRUE,
 320                                         channel_names[j])))
 321                                 return NULL;
 322                         sdi->channels = g_slist_append(sdi->channels, ch);
 323                 }
 324
 325                 devices = g_slist_append(devices, sdi);
 326                 drvc->instances = g_slist_append(drvc->instances, sdi);
 327                 sdi->inst_type = SR_INST_USB;
 328                 sdi->conn = sr_usb_dev_inst_new(
 329                         libusb_get_bus_number(devlist[i]),
 330                         libusb_get_device_address(devlist[i]), NULL);
 331                 devcnt++;
 332
 333         }
 334         libusb_free_device_list(devlist, 1);
 335
 336         return devices;
 337 }
 338
 339 static GSList *dev_list(void)
 340 {
 341         return ((struct drv_context *)(di->priv))->instances;
 342 }
 343
 344 static int dev_open(struct sr_dev_inst *sdi)
 345 {
 346         struct dev_context *devc;
 347         struct drv_context *drvc;
 348         struct sr_usb_dev_inst *usb;
 349         libusb_device **devlist, *dev;
 350         struct libusb_device_descriptor des;
 351         int device_count, ret, i;
 352
 353         drvc = di->priv;
 354         usb = sdi->conn;
 355
 356         if (!(devc = sdi->priv)) {
 357                 sr_err("%s: sdi->priv was NULL", __func__);
 358                 return SR_ERR_ARG;
 359         }
 360
 361         device_count = libusb_get_device_list(drvc->sr_ctx->libusb_ctx,
 362                                               &devlist);
 363         if (device_count < 0) {
 364                 sr_err("Failed to retrieve device list.");
 365                 return SR_ERR;
 366         }
 367
 368         dev = NULL;
 369         for (i = 0; i < device_count; i++) {
 370                 if ((ret = libusb_get_device_descriptor(devlist[i], &des))) {
 371                         sr_err("Failed to get device descriptor: %s.",
 372                                libusb_error_name(ret));
 373                         continue;
 374                 }
 375                 if (libusb_get_bus_number(devlist[i]) == usb->bus
 376                     && libusb_get_device_address(devlist[i]) == usb->address) {
 377                         dev = devlist[i];
 378                         break;
 379                 }
 380         }
 381         if (!dev) {
 382                 sr_err("Device on bus %d address %d disappeared!",
 383                        usb->bus, usb->address);
 384                 return SR_ERR;
 385         }
 386
 387         if (!(ret = libusb_open(dev, &(usb->devhdl)))) {
 388                 sdi->status = SR_ST_ACTIVE;
 389                 sr_info("Opened device %d on %d.%d interface %d.",
 390                         sdi->index, usb->bus, usb->address, USB_INTERFACE);
 391         } else {
 392                 sr_err("Failed to open device: %s.", libusb_error_name(ret));
 393                 return SR_ERR;
 394         }
 395
 396         ret = libusb_set_configuration(usb->devhdl, USB_CONFIGURATION);
 397         if (ret < 0) {
 398                 sr_err("Unable to set USB configuration %d: %s.",
 399                        USB_CONFIGURATION, libusb_error_name(ret));
 400                 return SR_ERR;
 401         }
 402
 403         ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE);
 404         if (ret != 0) {
 405                 sr_err("Unable to claim interface: %s.",
 406                        libusb_error_name(ret));
 407                 return SR_ERR;
 408         }
 409
 410         /* Set default configuration after power on. */
 411         if (analyzer_read_status(usb->devhdl) == 0)
 412                 analyzer_configure(usb->devhdl);
 413
 414         analyzer_reset(usb->devhdl);
 415         analyzer_initialize(usb->devhdl);
 416
 417         //analyzer_set_memory_size(MEMORY_SIZE_512K);
 418         // analyzer_set_freq(g_freq, g_freq_scale);
 419         analyzer_set_trigger_count(1);
 420         // analyzer_set_ramsize_trigger_address((((100 - g_pre_trigger)
 421         // * get_memory_size(g_memory_size)) / 100) >> 2);
 422
 423 #if 0
 424         if (g_double_mode == 1)
 425                 analyzer_set_compression(COMPRESSION_DOUBLE);
 426         else if (g_compression == 1)
 427                 analyzer_set_compression(COMPRESSION_ENABLE);
 428         else
 429 #endif
 430         analyzer_set_compression(COMPRESSION_NONE);
 431
 432         if (devc->cur_samplerate == 0) {
 433                 /* Samplerate hasn't been set. Default to 1MHz. */
 434                 analyzer_set_freq(1, FREQ_SCALE_MHZ);
 435                 devc->cur_samplerate = SR_MHZ(1);
 436         }
 437
 438         if (devc->cur_threshold == 0)
 439                 set_voltage_threshold(devc, 1.5);
 440
 441         return SR_OK;
 442 }
 443
 444 static int dev_close(struct sr_dev_inst *sdi)
 445 {
 446         struct sr_usb_dev_inst *usb;
 447
 448         usb = sdi->conn;
 449
 450         if (!usb->devhdl)
 451                 return SR_ERR;
 452
 453         sr_info("Closing device %d on %d.%d interface %d.", sdi->index,
 454                 usb->bus, usb->address, USB_INTERFACE);
 455         libusb_release_interface(usb->devhdl, USB_INTERFACE);
 456         libusb_reset_device(usb->devhdl);
 457         libusb_close(usb->devhdl);
 458         usb->devhdl = NULL;
 459         sdi->status = SR_ST_INACTIVE;
 460
 461         return SR_OK;
 462 }
 463
 464 static int cleanup(void)
 465 {
 466         return std_dev_clear(di, NULL);
 467 }
 468
 469 static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
 470                 const struct sr_channel_group *cg)
 471 {
 472         struct dev_context *devc;
 473
 474         (void)cg;
 475
 476         switch (id) {
 477         case SR_CONF_SAMPLERATE:
 478                 if (sdi) {
 479                         devc = sdi->priv;
 480                         *data = g_variant_new_uint64(devc->cur_samplerate);
 481                         sr_spew("Returning samplerate: %" PRIu64 "Hz.",
 482                                 devc->cur_samplerate);
 483                 } else
 484                         return SR_ERR_ARG;
 485                 break;
 486         case SR_CONF_CAPTURE_RATIO:
 487                 if (sdi) {
 488                         devc = sdi->priv;
 489                         *data = g_variant_new_uint64(devc->capture_ratio);
 490                 } else
 491                         return SR_ERR_ARG;
 492                 break;
 493         case SR_CONF_VOLTAGE_THRESHOLD:
 494                 if (sdi) {
 495                         GVariant *range[2];
 496                         devc = sdi->priv;
 497                         range[0] = g_variant_new_double(devc->cur_threshold);
 498                         range[1] = g_variant_new_double(devc->cur_threshold);
 499                         *data = g_variant_new_tuple(range, 2);
 500                 } else
 501                         return SR_ERR_ARG;
 502                 break;
 503         default:
 504                 return SR_ERR_NA;
 505         }
 506
 507         return SR_OK;
 508 }
 509
 510 static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
 511                 const struct sr_channel_group *cg)
 512 {
 513         struct dev_context *devc;
 514         gdouble low, high;
 515
 516         (void)cg;
 517
 518         if (sdi->status != SR_ST_ACTIVE)
 519                 return SR_ERR_DEV_CLOSED;
 520
 521         if (!(devc = sdi->priv)) {
 522                 sr_err("%s: sdi->priv was NULL", __func__);
 523                 return SR_ERR_ARG;
 524         }
 525
 526         switch (id) {
 527         case SR_CONF_SAMPLERATE:
 528                 return zp_set_samplerate(devc, g_variant_get_uint64(data));
 529         case SR_CONF_LIMIT_SAMPLES:
 530                 return set_limit_samples(devc, g_variant_get_uint64(data));
 531         case SR_CONF_CAPTURE_RATIO:
 532                 return set_capture_ratio(devc, g_variant_get_uint64(data));
 533         case SR_CONF_VOLTAGE_THRESHOLD:
 534                 g_variant_get(data, "(dd)", &low, &high);
 535                 return set_voltage_threshold(devc, (low + high) / 2.0);
 536         default:
 537                 return SR_ERR_NA;
 538         }
 539
 540         return SR_OK;
 541 }
 542
 543 static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
 544                 const struct sr_channel_group *cg)
 545 {
 546         struct dev_context *devc;
 547         GVariant *gvar, *grange[2];
 548         GVariantBuilder gvb;
 549         double v;
 550         GVariant *range[2];
 551
 552         (void)cg;
 553
 554         switch (key) {
 555         case SR_CONF_DEVICE_OPTIONS:
 556                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 557                                 hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
 558                 break;
 559         case SR_CONF_SAMPLERATE:
 560                 devc = sdi->priv;
 561                 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 562                 if (devc->prof->max_sampling_freq == 100) {
 563                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
 564                                         samplerates_100, ARRAY_SIZE(samplerates_100),
 565                                         sizeof(uint64_t));
 566                 } else if (devc->prof->max_sampling_freq == 200) {
 567                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
 568                                         samplerates_200, ARRAY_SIZE(samplerates_200),
 569                                         sizeof(uint64_t));
 570                 } else {
 571                         sr_err("Internal error: Unknown max. samplerate: %d.",
 572                                devc->prof->max_sampling_freq);
 573                         return SR_ERR_ARG;
 574                 }
 575                 g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
 576                 *data = g_variant_builder_end(&gvb);
 577                 break;
 578         case SR_CONF_TRIGGER_TYPE:
 579                 *data = g_variant_new_string(TRIGGER_TYPE);
 580                 break;
 581         case SR_CONF_VOLTAGE_THRESHOLD:
 582                 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 583                 for (v = -6.0; v <= 6.0; v += 0.1) {
 584                         range[0] = g_variant_new_double(v);
 585                         range[1] = g_variant_new_double(v);
 586                         gvar = g_variant_new_tuple(range, 2);
 587                         g_variant_builder_add_value(&gvb, gvar);
 588                 }
 589                 *data = g_variant_builder_end(&gvb);
 590                 break;
 591         case SR_CONF_LIMIT_SAMPLES:
 592                 if (!sdi)
 593                         return SR_ERR_ARG;
 594                 devc = sdi->priv;
 595                 grange[0] = g_variant_new_uint64(0);
 596                 grange[1] = g_variant_new_uint64(devc->max_sample_depth);
 597                 *data = g_variant_new_tuple(grange, 2);
 598                 break;
 599         default:
 600                 return SR_ERR_NA;
 601         }
 602
 603         return SR_OK;
 604 }
 605
 606 static int dev_acquisition_start(const struct sr_dev_inst *sdi,
 607                 void *cb_data)
 608 {
 609         struct dev_context *devc;
 610         struct sr_usb_dev_inst *usb;
 611         struct sr_datafeed_packet packet;
 612         struct sr_datafeed_logic logic;
 613         unsigned int samples_read;
 614         int res;
 615         unsigned int packet_num, n;
 616         unsigned char *buf;
 617         unsigned int status;
 618         unsigned int stop_address;
 619         unsigned int now_address;
 620         unsigned int trigger_address;
 621         unsigned int trigger_offset;
 622         unsigned int triggerbar;
 623         unsigned int ramsize_trigger;
 624         unsigned int memory_size;
 625         unsigned int valid_samples;
 626         unsigned int discard;
 627         int trigger_now;
 628
 629         if (sdi->status != SR_ST_ACTIVE)
 630                 return SR_ERR_DEV_CLOSED;
 631
 632         if (!(devc = sdi->priv)) {
 633                 sr_err("%s: sdi->priv was NULL", __func__);
 634                 return SR_ERR_ARG;
 635         }
 636
 637         if (configure_channels(sdi) != SR_OK) {
 638                 sr_err("Failed to configure channels.");
 639                 return SR_ERR;
 640         }
 641
 642         usb = sdi->conn;
 643
 644         set_triggerbar(devc);
 645
 646         /* Push configured settings to device. */
 647         analyzer_configure(usb->devhdl);
 648
 649         analyzer_start(usb->devhdl);
 650         sr_info("Waiting for data.");
 651         analyzer_wait_data(usb->devhdl);
 652
 653         status = analyzer_read_status(usb->devhdl);
 654         stop_address = analyzer_get_stop_address(usb->devhdl);
 655         now_address = analyzer_get_now_address(usb->devhdl);
 656         trigger_address = analyzer_get_trigger_address(usb->devhdl);
 657
 658         triggerbar = analyzer_get_triggerbar_address();
 659         ramsize_trigger = analyzer_get_ramsize_trigger_address();
 660
 661         n = get_memory_size(devc->memory_size);
 662         memory_size = n / 4;
 663
 664         sr_info("Status = 0x%x.", status);
 665         sr_info("Stop address       = 0x%x.", stop_address);
 666         sr_info("Now address        = 0x%x.", now_address);
 667         sr_info("Trigger address    = 0x%x.", trigger_address);
 668         sr_info("Triggerbar address = 0x%x.", triggerbar);
 669         sr_info("Ramsize trigger    = 0x%x.", ramsize_trigger);
 670         sr_info("Memory size        = 0x%x.", memory_size);
 671
 672         /* Send header packet to the session bus. */
 673         std_session_send_df_header(cb_data, LOG_PREFIX);
 674
 675         /* Check for empty capture */
 676         if ((status & STATUS_READY) && !stop_address) {
 677                 packet.type = SR_DF_END;
 678                 sr_session_send(cb_data, &packet);
 679                 return SR_OK;
 680         }
 681
 682         if (!(buf = g_try_malloc(PACKET_SIZE))) {
 683                 sr_err("Packet buffer malloc failed.");
 684                 return SR_ERR_MALLOC;
 685         }
 686
 687         /* Check if the trigger is in the samples we are throwing away */
 688         trigger_now = now_address == trigger_address ||
 689                 ((now_address + 1) % memory_size) == trigger_address;
 690
 691         /*
 692          * STATUS_READY doesn't clear until now_address advances past
 693          * addr 0, but for our logic, clear it in that case
 694          */
 695         if (!now_address)
 696                 status &= ~STATUS_READY;
 697
 698         analyzer_read_start(usb->devhdl);
 699
 700         /* Calculate how much data to discard */
 701         discard = 0;
 702         if (status & STATUS_READY) {
 703                 /*
 704                  * We haven't wrapped around, we need to throw away data from
 705                  * our current position to the end of the buffer.
 706                  * Additionally, the first two samples captured are always
 707                  * bogus.
 708                  */
 709                 discard += memory_size - now_address + 2;
 710                 now_address = 2;
 711         }
 712
 713         /* If we have more samples than we need, discard them */
 714         valid_samples = (stop_address - now_address) % memory_size;
 715         if (valid_samples > ramsize_trigger + triggerbar) {
 716                 discard += valid_samples - (ramsize_trigger + triggerbar);
 717                 now_address += valid_samples - (ramsize_trigger + triggerbar);
 718         }
 719
 720         sr_info("Need to discard %d samples.", discard);
 721
 722         /* Calculate how far in the trigger is */
 723         if (trigger_now)
 724                 trigger_offset = 0;
 725         else
 726                 trigger_offset = (trigger_address - now_address) % memory_size;
 727
 728         /* Recalculate the number of samples available */
 729         valid_samples = (stop_address - now_address) % memory_size;
 730
 731         /* Send the incoming transfer to the session bus. */
 732         samples_read = 0;
 733         for (packet_num = 0; packet_num < n / PACKET_SIZE; packet_num++) {
 734                 unsigned int len;
 735                 unsigned int buf_offset;
 736
 737                 res = analyzer_read_data(usb->devhdl, buf, PACKET_SIZE);
 738                 sr_info("Tried to read %d bytes, actually read %d bytes.",
 739                         PACKET_SIZE, res);
 740
 741                 if (discard >= PACKET_SIZE / 4) {
 742                         discard -= PACKET_SIZE / 4;
 743                         continue;
 744                 }
 745
 746                 len = PACKET_SIZE - discard * 4;
 747                 buf_offset = discard * 4;
 748                 discard = 0;
 749
 750                 /* Check if we've read all the samples */
 751                 if (samples_read + len / 4 >= valid_samples)
 752                         len = (valid_samples - samples_read) * 4;
 753                 if (!len)
 754                         break;
 755
 756                 if (samples_read < trigger_offset &&
 757                     samples_read + len / 4 > trigger_offset) {
 758                         /* Send out samples remaining before trigger */
 759                         packet.type = SR_DF_LOGIC;
 760                         packet.payload = &logic;
 761                         logic.length = (trigger_offset - samples_read) * 4;
 762                         logic.unitsize = 4;
 763                         logic.data = buf + buf_offset;
 764                         sr_session_send(cb_data, &packet);
 765                         len -= logic.length;
 766                         samples_read += logic.length / 4;
 767                         buf_offset += logic.length;
 768                 }
 769
 770                 if (samples_read == trigger_offset) {
 771                         /* Send out trigger */
 772                         packet.type = SR_DF_TRIGGER;
 773                         packet.payload = NULL;
 774                         sr_session_send(cb_data, &packet);
 775                 }
 776
 777                 /* Send out data (or data after trigger) */
 778                 packet.type = SR_DF_LOGIC;
 779                 packet.payload = &logic;
 780                 logic.length = len;
 781                 logic.unitsize = 4;
 782                 logic.data = buf + buf_offset;
 783                 sr_session_send(cb_data, &packet);
 784                 samples_read += len / 4;
 785         }
 786         analyzer_read_stop(usb->devhdl);
 787         g_free(buf);
 788
 789         packet.type = SR_DF_END;
 790         sr_session_send(cb_data, &packet);
 791
 792         return SR_OK;
 793 }
 794
 795 /* TODO: This stops acquisition on ALL devices, ignoring dev_index. */
 796 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 797 {
 798         struct dev_context *devc;
 799         struct sr_usb_dev_inst *usb;
 800         struct sr_datafeed_packet packet;
 801
 802         packet.type = SR_DF_END;
 803         sr_session_send(cb_data, &packet);
 804
 805         if (!(devc = sdi->priv)) {
 806                 sr_err("%s: sdi->priv was NULL", __func__);
 807                 return SR_ERR_BUG;
 808         }
 809
 810         usb = sdi->conn;
 811         analyzer_reset(usb->devhdl);
 812         /* TODO: Need to cancel and free any queued up transfers. */
 813
 814         return SR_OK;
 815 }
 816
 817 SR_PRIV struct sr_dev_driver zeroplus_logic_cube_driver_info = {
 818         .name = "zeroplus-logic-cube",
 819         .longname = "ZEROPLUS Logic Cube LAP-C series",
 820         .api_version = 1,
 821         .init = init,
 822         .cleanup = cleanup,
 823         .scan = scan,
 824         .dev_list = dev_list,
 825         .dev_clear = NULL,
 826         .config_get = config_get,
 827         .config_set = config_set,
 828         .config_list = config_list,
 829         .dev_open = dev_open,
 830         .dev_close = dev_close,
 831         .dev_acquisition_start = dev_acquisition_start,
 832         .dev_acquisition_stop = dev_acquisition_stop,
 833         .priv = NULL,
 834 };