src/hardware/kingst-la2016/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2020 Florian Schmidt <schmidt_florian@gmx.de>
   5  * Copyright (C) 2013 Marcus Comstedt <marcus@mc.pp.se>
   6  * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
   7  * Copyright (C) 2012 Joel Holdsworth <joel@airwebreathe.org.uk>
   8  *
   9  * This program is free software: you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation, either version 3 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include <config.h>
  24
  25 #include <libsigrok/libsigrok.h>
  26 #include <string.h>
  27
  28 #include "libsigrok-internal.h"
  29 #include "protocol.h"
  30
  31 #define UC_FIRMWARE     "kingst-la-%04x.fw"
  32 #define FPGA_FW_LA2016  "kingst-la2016-fpga.bitstream"
  33 #define FPGA_FW_LA2016A "kingst-la2016a1-fpga.bitstream"
  34 #define FPGA_FW_LA1016  "kingst-la1016-fpga.bitstream"
  35 #define FPGA_FW_LA1016A "kingst-la1016a1-fpga.bitstream"
  36
  37 /* Maximum device capabilities. May differ between models. */
  38 #define MAX_SAMPLE_RATE_LA2016  SR_MHZ(200)
  39 #define MAX_SAMPLE_RATE_LA1016  SR_MHZ(100)
  40 #define MAX_SAMPLE_DEPTH        10e9
  41 #define MAX_PWM_FREQ            SR_MHZ(20)
  42 #define PWM_CLOCK               SR_MHZ(200)     /* 200MHz for both LA2016 and LA1016 */
  43
  44 /*
  45  * Default device configuration. Must be applicable to any of the
  46  * supported devices (no model specific default values yet). Specific
  47  * firmware implementation details unfortunately won't let us detect
  48  * and keep using previously configured values.
  49  */
  50 #define LA2016_DFLT_SAMPLERATE  SR_MHZ(100)
  51 #define LA2016_DFLT_SAMPLEDEPTH (5 * 1000 * 1000)
  52 #define LA2016_DFLT_CAPT_RATIO  5 /* Capture ratio, in percent. */
  53
  54 /* TODO
  55  * What is the origin and motivation of that 128Mi literal? What is its
  56  * unit? How does it relate to a device's hardware capabilities? How to
  57  * map the 1GiB of RAM of an LA2016 (at 16 channels) to the 128Mi value?
  58  * It cannot be sample count. Is it memory size in bytes perhaps?
  59  */
  60 #define LA2016_PRE_MEM_LIMIT_BASE       (128 * 1024 * 1024)
  61
  62 /* USB vendor class control requests, executed by the Cypress FX2 MCU. */
  63 #define CMD_FPGA_ENABLE 0x10
  64 #define CMD_FPGA_SPI    0x20    /* R/W access to FPGA registers via SPI. */
  65 #define CMD_BULK_START  0x30    /* Start sample data download via USB EP6 IN. */
  66 #define CMD_BULK_RESET  0x38    /* Flush FIFO of FX2 USB EP6 IN. */
  67 #define CMD_FPGA_INIT   0x50    /* Used before and after FPGA bitstream upload. */
  68 #define CMD_KAUTH       0x60    /* Communicate to auth IC (U10). Not used. */
  69 #define CMD_EEPROM      0xa2    /* R/W access to EEPROM content. */
  70
  71 /*
  72  * FPGA register addresses (base addresses when registers span multiple
  73  * bytes, in that case data is kept in little endian format). Passed to
  74  * CMD_FPGA_SPI requests. The FX2 MCU transparently handles the detail
  75  * of SPI transfers encoding the read (1) or write (0) direction in the
  76  * MSB of the address field. There are some 60 byte-wide FPGA registers.
  77  *
  78  * Unfortunately the FPGA registers change their meaning between the
  79  * read and write directions of access, or exclusively provide one of
  80  * these directions and not the other. This is an arbitrary vendor's
  81  * choice, there is nothing which the sigrok driver could do about it.
  82  * Values written to registers typically cannot get read back, neither
  83  * verified after writing a configuration, nor queried upon startup for
  84  * automatic detection of the current configuration. Neither appear to
  85  * be there echo registers for presence and communication checks, nor
  86  * version identifying registers, as far as we know.
  87  */
  88 #define REG_RUN         0x00    /* Read capture status, write start capture. */
  89 #define REG_PWM_EN      0x02    /* User PWM channels on/off. */
  90 #define REG_CAPT_MODE   0x03    /* Write 0x00 capture to SDRAM, 0x01 streaming. */
  91 #define REG_BULK        0x08    /* Write start addr, byte count to download samples. */
  92 #define REG_SAMPLING    0x10    /* Write capture config, read capture SDRAM location. */
  93 #define REG_TRIGGER     0x20    /* write level and edge trigger config. */
  94 #define REG_THRESHOLD   0x68    /* Write PWM config to setup input threshold DAC. */
  95 #define REG_PWM1        0x70    /* Write config for user PWM1. */
  96 #define REG_PWM2        0x78    /* Write config for user PWM2. */
  97
  98 /* Bit patterns to write to REG_RUN, setup run mode. */
  99 #define RUNMODE_HALT    0x00
 100 #define RUNMODE_RUN     0x03
 101
 102 /* Bit patterns when reading from REG_RUN, get run state. */
 103 #define RUNSTATE_IDLE_BIT       (1UL << 0)
 104 #define RUNSTATE_DRAM_BIT       (1UL << 1)
 105 #define RUNSTATE_TRGD_BIT       (1UL << 2)
 106 #define RUNSTATE_POST_BIT       (1UL << 3)
 107
 108 static int ctrl_in(const struct sr_dev_inst *sdi,
 109         uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
 110         void *data, uint16_t wLength)
 111 {
 112         struct sr_usb_dev_inst *usb;
 113         int ret;
 114
 115         usb = sdi->conn;
 116
 117         if ((ret = libusb_control_transfer(usb->devhdl,
 118                      LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN,
 119                      bRequest, wValue, wIndex, (unsigned char *)data, wLength,
 120                      DEFAULT_TIMEOUT_MS)) != wLength) {
 121                 sr_dbg("USB ctrl in: %d bytes, req %d val %#x idx %d: %s.",
 122                         wLength, bRequest, wValue, wIndex,
 123                         libusb_error_name(ret));
 124                 sr_err("Cannot read %d bytes from USB: %s.",
 125                         wLength, libusb_error_name(ret));
 126                 return SR_ERR;
 127         }
 128
 129         return SR_OK;
 130 }
 131
 132 static int ctrl_out(const struct sr_dev_inst *sdi,
 133         uint8_t bRequest, uint16_t wValue, uint16_t wIndex,
 134         void *data, uint16_t wLength)
 135 {
 136         struct sr_usb_dev_inst *usb;
 137         int ret;
 138
 139         usb = sdi->conn;
 140
 141         if ((ret = libusb_control_transfer(usb->devhdl,
 142                      LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT,
 143                      bRequest, wValue, wIndex, (unsigned char*)data, wLength,
 144                      DEFAULT_TIMEOUT_MS)) != wLength) {
 145                 sr_dbg("USB ctrl out: %d bytes, req %d val %#x idx %d: %s.",
 146                         wLength, bRequest, wValue, wIndex,
 147                         libusb_error_name(ret));
 148                 sr_err("Cannot write %d bytes to USB: %s.",
 149                         wLength, libusb_error_name(ret));
 150                 return SR_ERR;
 151         }
 152
 153         return SR_OK;
 154 }
 155
 156 /*
 157  * Check the necessity for FPGA bitstream upload, because another upload
 158  * would take some 600ms which is undesirable after program startup. Try
 159  * to access some FPGA registers and check the values' plausibility. The
 160  * check should fail on the safe side, request another upload when in
 161  * doubt. A positive response (the request to continue operation with the
 162  * currently active bitstream) should be conservative. Accessing multiple
 163  * registers is considered cheap compared to the cost of bitstream upload.
 164  *
 165  * It helps though that both the vendor software and the sigrok driver
 166  * use the same bundle of MCU firmware and FPGA bitstream for any of the
 167  * supported models. We don't expect to successfully communicate to the
 168  * device yet disagree on its protocol. Ideally we would access version
 169  * identifying registers for improved robustness, but are not aware of
 170  * any. A bitstream reload can always be forced by a power cycle.
 171  */
 172 static int check_fpga_bitstream(const struct sr_dev_inst *sdi)
 173 {
 174         uint8_t init_rsp;
 175         int ret;
 176         uint16_t run_state;
 177         uint8_t pwm_en;
 178         size_t read_len;
 179         uint8_t buff[sizeof(run_state)];
 180         const uint8_t *rdptr;
 181
 182         sr_dbg("Checking operation of the FPGA bitstream.");
 183
 184         init_rsp = ~0;
 185         ret = ctrl_in(sdi, CMD_FPGA_INIT, 0x00, 0, &init_rsp, sizeof(init_rsp));
 186         if (ret != SR_OK || init_rsp != 0) {
 187                 sr_dbg("FPGA init query failed, or unexpected response.");
 188                 return SR_ERR_IO;
 189         }
 190
 191         read_len = sizeof(run_state);
 192         ret = ctrl_in(sdi, CMD_FPGA_SPI, REG_RUN, 0, buff, read_len);
 193         if (ret != SR_OK) {
 194                 sr_dbg("FPGA register access failed (run state).");
 195                 return SR_ERR_IO;
 196         }
 197         rdptr = buff;
 198         run_state = read_u16le_inc(&rdptr);
 199         sr_spew("FPGA register: run state 0x%04x.", run_state);
 200         if (run_state && (run_state & 0x3) != 0x1) {
 201                 sr_dbg("Unexpected FPGA register content (run state).");
 202                 return SR_ERR_DATA;
 203         }
 204         if (run_state && (run_state & ~0xf) != 0x85e0) {
 205                 sr_dbg("Unexpected FPGA register content (run state).");
 206                 return SR_ERR_DATA;
 207         }
 208
 209         read_len = sizeof(pwm_en);
 210         ret = ctrl_in(sdi, CMD_FPGA_SPI, REG_PWM_EN, 0, buff, read_len);
 211         if (ret != SR_OK) {
 212                 sr_dbg("FPGA register access failed (PWM enable).");
 213                 return SR_ERR_IO;
 214         }
 215         rdptr = buff;
 216         pwm_en = read_u8_inc(&rdptr);
 217         sr_spew("FPGA register: PWM enable 0x%02x.", pwm_en);
 218         if ((pwm_en & 0x3) != 0x0) {
 219                 sr_dbg("Unexpected FPGA register content (PWM enable).");
 220                 return SR_ERR_DATA;
 221         }
 222
 223         sr_info("Could re-use current FPGA bitstream. No upload required.");
 224         return SR_OK;
 225 }
 226
 227 static int upload_fpga_bitstream(const struct sr_dev_inst *sdi,
 228         const char *bitstream_fname)
 229 {
 230         struct drv_context *drvc;
 231         struct sr_usb_dev_inst *usb;
 232         struct sr_resource bitstream;
 233         uint32_t bitstream_size;
 234         uint8_t buffer[sizeof(uint32_t)];
 235         uint8_t *wrptr;
 236         uint8_t block[4096];
 237         int len, act_len;
 238         unsigned int pos;
 239         int ret;
 240         unsigned int zero_pad_to;
 241
 242         drvc = sdi->driver->context;
 243         usb = sdi->conn;
 244
 245         sr_info("Uploading FPGA bitstream '%s'.", bitstream_fname);
 246
 247         ret = sr_resource_open(drvc->sr_ctx, &bitstream, SR_RESOURCE_FIRMWARE, bitstream_fname);
 248         if (ret != SR_OK) {
 249                 sr_err("Cannot find FPGA bitstream %s.", bitstream_fname);
 250                 return ret;
 251         }
 252
 253         bitstream_size = (uint32_t)bitstream.size;
 254         wrptr = buffer;
 255         write_u32le_inc(&wrptr, bitstream_size);
 256         if ((ret = ctrl_out(sdi, CMD_FPGA_INIT, 0x00, 0, buffer, wrptr - buffer)) != SR_OK) {
 257                 sr_err("Cannot initiate FPGA bitstream upload.");
 258                 sr_resource_close(drvc->sr_ctx, &bitstream);
 259                 return ret;
 260         }
 261         zero_pad_to = bitstream_size;
 262         zero_pad_to += LA2016_EP2_PADDING - 1;
 263         zero_pad_to /= LA2016_EP2_PADDING;
 264         zero_pad_to *= LA2016_EP2_PADDING;
 265
 266         pos = 0;
 267         while (1) {
 268                 if (pos < bitstream.size) {
 269                         len = (int)sr_resource_read(drvc->sr_ctx, &bitstream, &block, sizeof(block));
 270                         if (len < 0) {
 271                                 sr_err("Cannot read FPGA bitstream.");
 272                                 sr_resource_close(drvc->sr_ctx, &bitstream);
 273                                 return SR_ERR;
 274                         }
 275                 } else {
 276                         /*  Zero-pad until 'zero_pad_to'. */
 277                         len = zero_pad_to - pos;
 278                         if ((unsigned)len > sizeof(block))
 279                                 len = sizeof(block);
 280                         memset(&block, 0, len);
 281                 }
 282                 if (len == 0)
 283                         break;
 284
 285                 ret = libusb_bulk_transfer(usb->devhdl, USB_EP_FPGA_BITSTREAM,
 286                         &block[0], len, &act_len, DEFAULT_TIMEOUT_MS);
 287                 if (ret != 0) {
 288                         sr_dbg("Cannot write FPGA bitstream, block %#x len %d: %s.",
 289                                 pos, (int)len, libusb_error_name(ret));
 290                         ret = SR_ERR;
 291                         break;
 292                 }
 293                 if (act_len != len) {
 294                         sr_dbg("Short write for FPGA bitstream, block %#x len %d: got %d.",
 295                                 pos, (int)len, act_len);
 296                         ret = SR_ERR;
 297                         break;
 298                 }
 299                 pos += len;
 300         }
 301         sr_resource_close(drvc->sr_ctx, &bitstream);
 302         if (ret != 0)
 303                 return ret;
 304         sr_info("FPGA bitstream upload (%" PRIu64 " bytes) done.",
 305                 bitstream.size);
 306
 307         return SR_OK;
 308 }
 309
 310 static int enable_fpga_bitstream(const struct sr_dev_inst *sdi)
 311 {
 312         int ret;
 313         uint8_t cmd_resp;
 314
 315         if ((ret = ctrl_in(sdi, CMD_FPGA_INIT, 0x00, 0, &cmd_resp, sizeof(cmd_resp))) != SR_OK) {
 316                 sr_err("Cannot read response after FPGA bitstream upload.");
 317                 return ret;
 318         }
 319         if (cmd_resp != 0) {
 320                 sr_err("Unexpected FPGA bitstream upload response, got 0x%02x, want 0.",
 321                         cmd_resp);
 322                 return SR_ERR;
 323         }
 324         g_usleep(30 * 1000);
 325
 326         if ((ret = ctrl_out(sdi, CMD_FPGA_ENABLE, 0x01, 0, NULL, 0)) != SR_OK) {
 327                 sr_err("Cannot enable FPGA after bitstream upload.");
 328                 return ret;
 329         }
 330         g_usleep(40 * 1000);
 331
 332         return SR_OK;
 333 }
 334
 335 static int set_threshold_voltage(const struct sr_dev_inst *sdi, float voltage)
 336 {
 337         struct dev_context *devc;
 338         int ret;
 339
 340         devc = sdi->priv;
 341
 342         uint16_t duty_R79, duty_R56;
 343         uint8_t buf[2 * sizeof(uint16_t)];
 344         uint8_t *wrptr;
 345
 346         /* Clamp threshold setting to valid range for LA2016. */
 347         if (voltage > 4.0) {
 348                 voltage = 4.0;
 349         } else if (voltage < -4.0) {
 350                 voltage = -4.0;
 351         }
 352
 353         /*
 354          * Two PWM output channels feed one DAC which generates a bias
 355          * voltage, which offsets the input probe's voltage level, and
 356          * in combination with the FPGA pins' fixed threshold result in
 357          * a programmable input threshold from the user's perspective.
 358          * The PWM outputs can be seen on R79 and R56 respectively, the
 359          * frequency is 100kHz and the duty cycle varies. The R79 PWM
 360          * uses three discrete settings. The R56 PWM varies with desired
 361          * thresholds and depends on the R79 PWM configuration. See the
 362          * schematics comments which discuss the formulae.
 363          */
 364         if (voltage >= 2.9) {
 365                 duty_R79 = 0;           /* PWM off (0V). */
 366                 duty_R56 = (uint16_t)(302 * voltage - 363);
 367         } else if (voltage > -0.4) {
 368                 duty_R79 = 0x00f2;      /* 25% duty cycle. */
 369                 duty_R56 = (uint16_t)(302 * voltage + 121);
 370         } else {
 371                 duty_R79 = 0x02d7;      /* 72% duty cycle. */
 372                 duty_R56 = (uint16_t)(302 * voltage + 1090);
 373         }
 374
 375         /* Clamp duty register values to sensible limits. */
 376         if (duty_R56 < 10) {
 377                 duty_R56 = 10;
 378         } else if (duty_R56 > 1100) {
 379                 duty_R56 = 1100;
 380         }
 381
 382         sr_dbg("Set threshold voltage %.2fV.", voltage);
 383         sr_dbg("Duty cycle values: R56 0x%04x, R79 0x%04x.", duty_R56, duty_R79);
 384
 385         wrptr = buf;
 386         write_u16le_inc(&wrptr, duty_R56);
 387         write_u16le_inc(&wrptr, duty_R79);
 388
 389         ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_THRESHOLD, 0, buf, wrptr - buf);
 390         if (ret != SR_OK) {
 391                 sr_err("Cannot set threshold voltage %.2fV.", voltage);
 392                 return ret;
 393         }
 394         devc->threshold_voltage = voltage;
 395
 396         return SR_OK;
 397 }
 398
 399 static int enable_pwm(const struct sr_dev_inst *sdi, uint8_t p1, uint8_t p2)
 400 {
 401         struct dev_context *devc;
 402         uint8_t cfg;
 403         int ret;
 404
 405         devc = sdi->priv;
 406         cfg = 0;
 407
 408         if (p1) cfg |= 1 << 0;
 409         if (p2) cfg |= 1 << 1;
 410
 411         sr_dbg("Set PWM enable %d %d. Config 0x%02x.", p1, p2, cfg);
 412         ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_PWM_EN, 0, &cfg, sizeof(cfg));
 413         if (ret != SR_OK) {
 414                 sr_err("Cannot setup PWM enabled state.");
 415                 return ret;
 416         }
 417         devc->pwm_setting[0].enabled = (p1) ? 1 : 0;
 418         devc->pwm_setting[1].enabled = (p2) ? 1 : 0;
 419
 420         return SR_OK;
 421 }
 422
 423 static int set_pwm(const struct sr_dev_inst *sdi, uint8_t which,
 424         float freq, float duty)
 425 {
 426         int CTRL_PWM[] = { REG_PWM1, REG_PWM2 };
 427         struct dev_context *devc;
 428         pwm_setting_dev_t cfg;
 429         pwm_setting_t *setting;
 430         int ret;
 431         uint8_t buf[2 * sizeof(uint32_t)];
 432         uint8_t *wrptr;
 433
 434         devc = sdi->priv;
 435
 436         if (which < 1 || which > ARRAY_SIZE(CTRL_PWM)) {
 437                 sr_err("Invalid PWM channel: %d.", which);
 438                 return SR_ERR;
 439         }
 440         if (freq > MAX_PWM_FREQ) {
 441                 sr_err("Too high a PWM frequency: %.1f.", freq);
 442                 return SR_ERR;
 443         }
 444         if (duty > 100 || duty < 0) {
 445                 sr_err("Invalid PWM duty cycle: %f.", duty);
 446                 return SR_ERR;
 447         }
 448
 449         cfg.period = (uint32_t)(PWM_CLOCK / freq);
 450         cfg.duty = (uint32_t)(0.5f + (cfg.period * duty / 100.));
 451         sr_dbg("Set PWM%d period %d, duty %d.", which, cfg.period, cfg.duty);
 452
 453         wrptr = buf;
 454         write_u32le_inc(&wrptr, cfg.period);
 455         write_u32le_inc(&wrptr, cfg.duty);
 456         ret = ctrl_out(sdi, CMD_FPGA_SPI, CTRL_PWM[which - 1], 0, buf, wrptr - buf);
 457         if (ret != SR_OK) {
 458                 sr_err("Cannot setup PWM%d configuration %d %d.",
 459                         which, cfg.period, cfg.duty);
 460                 return ret;
 461         }
 462         setting = &devc->pwm_setting[which - 1];
 463         setting->freq = freq;
 464         setting->duty = duty;
 465
 466         return SR_OK;
 467 }
 468
 469 static int set_defaults(const struct sr_dev_inst *sdi)
 470 {
 471         struct dev_context *devc;
 472         int ret;
 473
 474         devc = sdi->priv;
 475
 476         devc->capture_ratio = LA2016_DFLT_CAPT_RATIO;
 477         devc->cur_channels = 0xffff;
 478         devc->limit_samples = LA2016_DFLT_SAMPLEDEPTH;
 479         devc->cur_samplerate = LA2016_DFLT_SAMPLERATE;
 480
 481         ret = set_threshold_voltage(sdi, devc->threshold_voltage);
 482         if (ret)
 483                 return ret;
 484
 485         ret = enable_pwm(sdi, 0, 0);
 486         if (ret)
 487                 return ret;
 488
 489         ret = set_pwm(sdi, 1, SR_KHZ(1), 50);
 490         if (ret)
 491                 return ret;
 492
 493         ret = set_pwm(sdi, 2, SR_KHZ(100), 50);
 494         if (ret)
 495                 return ret;
 496
 497         ret = enable_pwm(sdi, 1, 1);
 498         if (ret)
 499                 return ret;
 500
 501         return SR_OK;
 502 }
 503
 504 static int set_trigger_config(const struct sr_dev_inst *sdi)
 505 {
 506         struct dev_context *devc;
 507         struct sr_trigger *trigger;
 508         trigger_cfg_t cfg;
 509         GSList *stages;
 510         GSList *channel;
 511         struct sr_trigger_stage *stage1;
 512         struct sr_trigger_match *match;
 513         uint16_t ch_mask;
 514         int ret;
 515         uint8_t buf[4 * sizeof(uint32_t)];
 516         uint8_t *wrptr;
 517
 518         devc = sdi->priv;
 519         trigger = sr_session_trigger_get(sdi->session);
 520
 521         memset(&cfg, 0, sizeof(cfg));
 522
 523         cfg.channels = devc->cur_channels;
 524
 525         if (trigger && trigger->stages) {
 526                 stages = trigger->stages;
 527                 stage1 = stages->data;
 528                 if (stages->next) {
 529                         sr_err("Only one trigger stage supported for now.");
 530                         return SR_ERR;
 531                 }
 532                 channel = stage1->matches;
 533                 while (channel) {
 534                         match = channel->data;
 535                         ch_mask = 1 << match->channel->index;
 536
 537                         switch (match->match) {
 538                         case SR_TRIGGER_ZERO:
 539                                 cfg.level |= ch_mask;
 540                                 cfg.high_or_falling &= ~ch_mask;
 541                                 break;
 542                         case SR_TRIGGER_ONE:
 543                                 cfg.level |= ch_mask;
 544                                 cfg.high_or_falling |= ch_mask;
 545                                 break;
 546                         case SR_TRIGGER_RISING:
 547                                 if ((cfg.enabled & ~cfg.level)) {
 548                                         sr_err("Device only supports one edge trigger.");
 549                                         return SR_ERR;
 550                                 }
 551                                 cfg.level &= ~ch_mask;
 552                                 cfg.high_or_falling &= ~ch_mask;
 553                                 break;
 554                         case SR_TRIGGER_FALLING:
 555                                 if ((cfg.enabled & ~cfg.level)) {
 556                                         sr_err("Device only supports one edge trigger.");
 557                                         return SR_ERR;
 558                                 }
 559                                 cfg.level &= ~ch_mask;
 560                                 cfg.high_or_falling |= ch_mask;
 561                                 break;
 562                         default:
 563                                 sr_err("Unknown trigger condition.");
 564                                 return SR_ERR;
 565                         }
 566                         cfg.enabled |= ch_mask;
 567                         channel = channel->next;
 568                 }
 569         }
 570         sr_dbg("Set trigger config: "
 571                 "channels 0x%04x, trigger-enabled 0x%04x, "
 572                 "level-triggered 0x%04x, high/falling 0x%04x.",
 573                 cfg.channels, cfg.enabled, cfg.level, cfg.high_or_falling);
 574
 575         devc->had_triggers_configured = cfg.enabled != 0;
 576
 577         wrptr = buf;
 578         write_u32le_inc(&wrptr, cfg.channels);
 579         write_u32le_inc(&wrptr, cfg.enabled);
 580         write_u32le_inc(&wrptr, cfg.level);
 581         write_u32le_inc(&wrptr, cfg.high_or_falling);
 582         /* TODO
 583          * Comment on this literal 16. Origin, meaning? Cannot be the
 584          * register offset, nor the transfer length. Is it a channels
 585          * count that is relevant for 16 and 32 channel models? Is it
 586          * an obsolete experiment?
 587          */
 588         ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_TRIGGER, 16, buf, wrptr - buf);
 589         if (ret != SR_OK) {
 590                 sr_err("Cannot setup trigger configuration.");
 591                 return ret;
 592         }
 593
 594         return SR_OK;
 595 }
 596
 597 static int set_sample_config(const struct sr_dev_inst *sdi)
 598 {
 599         struct dev_context *devc;
 600         double clock_divisor;
 601         uint16_t divider_u16;
 602         uint64_t pre_trigger_samples;
 603         uint64_t pre_trigger_memory;
 604         uint8_t buf[REG_TRIGGER - REG_SAMPLING]; /* Width of REG_SAMPLING. */
 605         uint8_t *wrptr;
 606         int ret;
 607
 608         devc = sdi->priv;
 609
 610         if (devc->cur_samplerate > devc->max_samplerate) {
 611                 sr_err("Too high a sample rate: %" PRIu64 ".",
 612                         devc->cur_samplerate);
 613                 return SR_ERR;
 614         }
 615
 616         clock_divisor = devc->max_samplerate / (double)devc->cur_samplerate;
 617         if (clock_divisor > 65535)
 618                 return SR_ERR_ARG;
 619         divider_u16 = (uint16_t)(clock_divisor + 0.5);
 620         devc->cur_samplerate = devc->max_samplerate / divider_u16;
 621
 622         if (devc->limit_samples > MAX_SAMPLE_DEPTH) {
 623                 sr_err("Too high a sample depth: %" PRIu64 ".",
 624                         devc->limit_samples);
 625                 return SR_ERR;
 626         }
 627
 628         /*
 629          * The acquisition configuration communicates "pre-trigger"
 630          * specs in several formats. sigrok users provide a percentage
 631          * (0-100%), which translates to a pre-trigger samples count
 632          * (assuming that a total samples count limit was specified).
 633          * The device supports hardware compression, which depends on
 634          * slowly changing input data to be effective. Fast changing
 635          * input data may occupy more space in sample memory than its
 636          * uncompressed form would. This is why a third parameter can
 637          * limit the amount of sample memory to use for pre-trigger
 638          * data. Only the upper 24 bits of that memory size spec get
 639          * communicated to the device (written to its FPGA register).
 640          */
 641         pre_trigger_samples = devc->limit_samples * devc->capture_ratio / 100;
 642         pre_trigger_memory = LA2016_PRE_MEM_LIMIT_BASE;
 643         pre_trigger_memory *= devc->capture_ratio;
 644         pre_trigger_memory /= 100;
 645
 646         sr_dbg("Set sample config: %" PRIu64 "kHz, %" PRIu64 " samples.",
 647                 devc->cur_samplerate / 1000, devc->limit_samples);
 648         sr_dbg("Capture ratio %" PRIu64 "%%, count %" PRIu64 ", mem %" PRIu64 ".",
 649                 devc->capture_ratio, pre_trigger_samples, pre_trigger_memory);
 650
 651         /*
 652          * The acquisition configuration occupies a total of 16 bytes:
 653          * - A 34bit total samples count limit (up to 10 billions) that
 654          *   is kept in a 40bit register.
 655          * - A 34bit pre-trigger samples count limit (up to 10 billions)
 656          *   in another 40bit register.
 657          * - A 32bit pre-trigger memory space limit (in bytes) of which
 658          *   the upper 24bits are kept in an FPGA register.
 659          * - A 16bit clock divider which gets applied to the maximum
 660          *   samplerate of the device.
 661          * - An 8bit register of unknown meaning. Currently always 0.
 662          */
 663         wrptr = buf;
 664         write_u40le_inc(&wrptr, devc->limit_samples);
 665         write_u40le_inc(&wrptr, pre_trigger_samples);
 666         write_u24le_inc(&wrptr, pre_trigger_memory >> 8);
 667         write_u16le_inc(&wrptr, divider_u16);
 668         write_u8_inc(&wrptr, 0);
 669         ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_SAMPLING, 0, buf, wrptr - buf);
 670         if (ret != SR_OK) {
 671                 sr_err("Cannot setup acquisition configuration.");
 672                 return ret;
 673         }
 674
 675         return SR_OK;
 676 }
 677
 678 /*
 679  * FPGA register REG_RUN holds the run state (u16le format). Bit fields
 680  * of interest:
 681  *   bit 0: value 1 = idle
 682  *   bit 1: value 1 = writing to SDRAM
 683  *   bit 2: value 0 = waiting for trigger, 1 = trigger seen
 684  *   bit 3: value 0 = pretrigger sampling, 1 = posttrigger sampling
 685  * The meaning of other bit fields is unknown.
 686  *
 687  * Typical values in order of appearance during execution:
 688  *   0x85e1: idle, no acquisition pending
 689  *     IDLE set, TRGD don't care, POST don't care; DRAM don't care
 690  *     "In idle state." Takes precedence over all others.
 691  *   0x85e2: pre-sampling, samples before the trigger position,
 692  *     when capture ratio > 0%
 693  *     IDLE clear, TRGD clear, POST clear; DRAM don't care
 694  *     "Not idle any more, no post yet, not triggered yet."
 695  *   0x85ea: pre-sampling complete, now waiting for the trigger
 696  *     (whilst sampling continuously)
 697  *     IDLE clear, TRGD clear, POST set; DRAM don't care
 698  *     "Post set thus after pre, not triggered yet"
 699  *   0x85ee: trigger seen, capturing post-trigger samples, running
 700  *     IDLE clear, TRGD set, POST set; DRAM don't care
 701  *     "Triggered and in post, not idle yet."
 702  *   0x85ed: idle
 703  *     IDLE set, TRGD don't care, POST don't care; DRAM don't care
 704  *     "In idle state." TRGD/POST don't care, same meaning as above.
 705  */
 706 static const uint16_t runstate_mask_idle = RUNSTATE_IDLE_BIT;
 707 static const uint16_t runstate_patt_idle = RUNSTATE_IDLE_BIT;
 708 static const uint16_t runstate_mask_step =
 709         RUNSTATE_IDLE_BIT | RUNSTATE_TRGD_BIT | RUNSTATE_POST_BIT;
 710 static const uint16_t runstate_patt_pre_trig = 0;
 711 static const uint16_t runstate_patt_wait_trig = RUNSTATE_POST_BIT;
 712 static const uint16_t runstate_patt_post_trig =
 713         RUNSTATE_TRGD_BIT | RUNSTATE_POST_BIT;
 714
 715 static uint16_t run_state(const struct sr_dev_inst *sdi)
 716 {
 717         static uint16_t previous_state;
 718
 719         int ret;
 720         uint16_t state;
 721         uint8_t buff[sizeof(state)];
 722         const uint8_t *rdptr;
 723         const char *label;
 724
 725         if ((ret = ctrl_in(sdi, CMD_FPGA_SPI, REG_RUN, 0, buff, sizeof(state))) != SR_OK) {
 726                 sr_err("Cannot read run state.");
 727                 return ret;
 728         }
 729         rdptr = buff;
 730         state = read_u16le_inc(&rdptr);
 731
 732         /*
 733          * Avoid flooding the log, only dump values as they change.
 734          * The routine is called about every 50ms.
 735          */
 736         if (state == previous_state)
 737                 return state;
 738
 739         previous_state = state;
 740         label = NULL;
 741         if ((state & runstate_mask_idle) == runstate_patt_idle)
 742                 label = "idle";
 743         if ((state & runstate_mask_step) == runstate_patt_pre_trig)
 744                 label = "pre-trigger sampling";
 745         if ((state & runstate_mask_step) == runstate_patt_wait_trig)
 746                 label = "sampling, waiting for trigger";
 747         if ((state & runstate_mask_step) == runstate_patt_post_trig)
 748                 label = "post-trigger sampling";
 749         if (label && *label)
 750                 sr_dbg("Run state: 0x%04x (%s).", state, label);
 751         else
 752                 sr_dbg("Run state: 0x%04x.", state);
 753
 754         return state;
 755 }
 756
 757 static int la2016_has_triggered(const struct sr_dev_inst *sdi)
 758 {
 759         uint16_t state;
 760
 761         state = run_state(sdi);
 762         if ((state & runstate_mask_idle) == runstate_patt_idle)
 763                 return 1;
 764
 765         return 0;
 766 }
 767
 768 static int set_run_mode(const struct sr_dev_inst *sdi, uint8_t mode)
 769 {
 770         int ret;
 771
 772         if ((ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_RUN, 0, &mode, sizeof(mode))) != SR_OK) {
 773                 sr_err("Cannot configure run mode %d.", mode);
 774                 return ret;
 775         }
 776
 777         return SR_OK;
 778 }
 779
 780 static int get_capture_info(const struct sr_dev_inst *sdi)
 781 {
 782         struct dev_context *devc;
 783         int ret;
 784         uint8_t buf[3 * sizeof(uint32_t)];
 785         const uint8_t *rdptr;
 786
 787         devc = sdi->priv;
 788
 789         if ((ret = ctrl_in(sdi, CMD_FPGA_SPI, REG_SAMPLING, 0, buf, sizeof(buf))) != SR_OK) {
 790                 sr_err("Cannot read capture info.");
 791                 return ret;
 792         }
 793
 794         rdptr = buf;
 795         devc->info.n_rep_packets = read_u32le_inc(&rdptr);
 796         devc->info.n_rep_packets_before_trigger = read_u32le_inc(&rdptr);
 797         devc->info.write_pos = read_u32le_inc(&rdptr);
 798
 799         sr_dbg("Capture info: n_rep_packets: 0x%08x/%d, before_trigger: 0x%08x/%d, write_pos: 0x%08x%d.",
 800                 devc->info.n_rep_packets, devc->info.n_rep_packets,
 801                 devc->info.n_rep_packets_before_trigger,
 802                 devc->info.n_rep_packets_before_trigger,
 803                 devc->info.write_pos, devc->info.write_pos);
 804
 805         if (devc->info.n_rep_packets % NUM_PACKETS_IN_CHUNK) {
 806                 sr_warn("Unexpected packets count %lu, not a multiple of %d.",
 807                         (unsigned long)devc->info.n_rep_packets,
 808                         NUM_PACKETS_IN_CHUNK);
 809         }
 810
 811         return SR_OK;
 812 }
 813
 814 SR_PRIV int la2016_upload_firmware(struct sr_context *sr_ctx,
 815         libusb_device *dev, uint16_t product_id)
 816 {
 817         char fw_file[1024];
 818         snprintf(fw_file, sizeof(fw_file) - 1, UC_FIRMWARE, product_id);
 819         return ezusb_upload_firmware(sr_ctx, dev, USB_CONFIGURATION, fw_file);
 820 }
 821
 822 SR_PRIV int la2016_setup_acquisition(const struct sr_dev_inst *sdi)
 823 {
 824         struct dev_context *devc;
 825         int ret;
 826         uint8_t cmd;
 827
 828         devc = sdi->priv;
 829
 830         ret = set_threshold_voltage(sdi, devc->threshold_voltage);
 831         if (ret != SR_OK)
 832                 return ret;
 833
 834         cmd = 0;
 835         if ((ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_CAPT_MODE, 0, &cmd, sizeof(cmd))) != SR_OK) {
 836                 sr_err("Cannot send command to stop sampling.");
 837                 return ret;
 838         }
 839
 840         ret = set_trigger_config(sdi);
 841         if (ret != SR_OK)
 842                 return ret;
 843
 844         ret = set_sample_config(sdi);
 845         if (ret != SR_OK)
 846                 return ret;
 847
 848         return SR_OK;
 849 }
 850
 851 SR_PRIV int la2016_start_acquisition(const struct sr_dev_inst *sdi)
 852 {
 853         int ret;
 854
 855         ret = set_run_mode(sdi, RUNMODE_RUN);
 856         if (ret != SR_OK)
 857                 return ret;
 858
 859         return SR_OK;
 860 }
 861
 862 static int la2016_stop_acquisition(const struct sr_dev_inst *sdi)
 863 {
 864         int ret;
 865
 866         ret = set_run_mode(sdi, RUNMODE_HALT);
 867         if (ret != SR_OK)
 868                 return ret;
 869
 870         return SR_OK;
 871 }
 872
 873 SR_PRIV int la2016_abort_acquisition(const struct sr_dev_inst *sdi)
 874 {
 875         int ret;
 876         struct dev_context *devc;
 877
 878         ret = la2016_stop_acquisition(sdi);
 879         if (ret != SR_OK)
 880                 return ret;
 881
 882         devc = sdi ? sdi->priv : NULL;
 883         if (devc && devc->transfer)
 884                 libusb_cancel_transfer(devc->transfer);
 885
 886         return SR_OK;
 887 }
 888
 889 static int la2016_start_retrieval(const struct sr_dev_inst *sdi,
 890         libusb_transfer_cb_fn cb)
 891 {
 892         struct dev_context *devc;
 893         struct sr_usb_dev_inst *usb;
 894         int ret;
 895         uint8_t wrbuf[2 * sizeof(uint32_t)];
 896         uint8_t *wrptr;
 897         uint32_t to_read;
 898         uint8_t *buffer;
 899
 900         devc = sdi->priv;
 901         usb = sdi->conn;
 902
 903         if ((ret = get_capture_info(sdi)) != SR_OK)
 904                 return ret;
 905
 906         devc->n_transfer_packets_to_read = devc->info.n_rep_packets / NUM_PACKETS_IN_CHUNK;
 907         devc->n_bytes_to_read = devc->n_transfer_packets_to_read * TRANSFER_PACKET_LENGTH;
 908         devc->read_pos = devc->info.write_pos - devc->n_bytes_to_read;
 909         devc->n_reps_until_trigger = devc->info.n_rep_packets_before_trigger;
 910
 911         sr_dbg("Want to read %u xfer-packets starting from pos %" PRIu32 ".",
 912                 devc->n_transfer_packets_to_read, devc->read_pos);
 913
 914         if ((ret = ctrl_out(sdi, CMD_BULK_RESET, 0x00, 0, NULL, 0)) != SR_OK) {
 915                 sr_err("Cannot reset USB bulk state.");
 916                 return ret;
 917         }
 918         sr_dbg("Will read from 0x%08lx, 0x%08x bytes.",
 919                 (unsigned long)devc->read_pos, devc->n_bytes_to_read);
 920         wrptr = wrbuf;
 921         write_u32le_inc(&wrptr, devc->read_pos);
 922         write_u32le_inc(&wrptr, devc->n_bytes_to_read);
 923         if ((ret = ctrl_out(sdi, CMD_FPGA_SPI, REG_BULK, 0, wrbuf, wrptr - wrbuf)) != SR_OK) {
 924                 sr_err("Cannot send USB bulk config.");
 925                 return ret;
 926         }
 927         if ((ret = ctrl_out(sdi, CMD_BULK_START, 0x00, 0, NULL, 0)) != SR_OK) {
 928                 sr_err("Cannot unblock USB bulk transfers.");
 929                 return ret;
 930         }
 931
 932         /*
 933          * Pick a buffer size for all USB transfers. The buffer size
 934          * must be a multiple of the endpoint packet size. And cannot
 935          * exceed a maximum value.
 936          */
 937         to_read = devc->n_bytes_to_read;
 938         if (to_read >= LA2016_USB_BUFSZ) /* Multiple transfers. */
 939                 to_read = LA2016_USB_BUFSZ;
 940         else /* One transfer. */
 941                 to_read = (to_read + (LA2016_EP6_PKTSZ-1)) & ~(LA2016_EP6_PKTSZ-1);
 942         buffer = g_try_malloc(to_read);
 943         if (!buffer) {
 944                 sr_dbg("USB bulk transfer size %d bytes.", (int)to_read);
 945                 sr_err("Cannot allocate buffer for USB bulk transfer.");
 946                 return SR_ERR_MALLOC;
 947         }
 948
 949         devc->transfer = libusb_alloc_transfer(0);
 950         libusb_fill_bulk_transfer(devc->transfer,
 951                 usb->devhdl, USB_EP_CAPTURE_DATA | LIBUSB_ENDPOINT_IN,
 952                 buffer, to_read,
 953                 cb, (void *)sdi, DEFAULT_TIMEOUT_MS);
 954
 955         if ((ret = libusb_submit_transfer(devc->transfer)) != 0) {
 956                 sr_err("Cannot submit USB transfer: %s.", libusb_error_name(ret));
 957                 libusb_free_transfer(devc->transfer);
 958                 devc->transfer = NULL;
 959                 g_free(buffer);
 960                 return SR_ERR;
 961         }
 962
 963         return SR_OK;
 964 }
 965
 966 static void send_chunk(struct sr_dev_inst *sdi,
 967         const uint8_t *packets, unsigned int num_tfers)
 968 {
 969         struct dev_context *devc;
 970         struct sr_datafeed_logic logic;
 971         struct sr_datafeed_packet sr_packet;
 972         unsigned int max_samples, n_samples, total_samples, free_n_samples;
 973         unsigned int i, j, k;
 974         int do_signal_trigger;
 975         uint8_t *wp;
 976         const uint8_t *rp;
 977         uint16_t state;
 978         uint8_t repetitions;
 979         uint8_t sample_buff[sizeof(state)];
 980
 981         devc = sdi->priv;
 982
 983         logic.unitsize = sizeof(sample_buff);
 984         logic.data = devc->convbuffer;
 985
 986         sr_packet.type = SR_DF_LOGIC;
 987         sr_packet.payload = &logic;
 988
 989         max_samples = devc->convbuffer_size / sizeof(sample_buff);
 990         n_samples = 0;
 991         wp = devc->convbuffer;
 992         total_samples = 0;
 993         do_signal_trigger = 0;
 994
 995         if (devc->had_triggers_configured && devc->reading_behind_trigger == 0 && devc->info.n_rep_packets_before_trigger == 0) {
 996                 std_session_send_df_trigger(sdi);
 997                 devc->reading_behind_trigger = 1;
 998         }
 999
1000         rp = packets;
1001         for (i = 0; i < num_tfers; i++) {
1002                 for (k = 0; k < NUM_PACKETS_IN_CHUNK; k++) {
1003                         free_n_samples = max_samples - n_samples;
1004                         if (free_n_samples < 256 || do_signal_trigger) {
1005                                 logic.length = n_samples * 2;
1006                                 sr_session_send(sdi, &sr_packet);
1007                                 n_samples = 0;
1008                                 wp = devc->convbuffer;
1009                                 if (do_signal_trigger) {
1010                                         std_session_send_df_trigger(sdi);
1011                                         do_signal_trigger = 0;
1012                                 }
1013                         }
1014
1015                         state = read_u16le_inc(&rp);
1016                         repetitions = read_u8_inc(&rp);
1017                         write_u16le((void *)&sample_buff, state);
1018                         for (j = 0; j < repetitions; j++) {
1019                                 memcpy(wp, sample_buff, logic.unitsize);
1020                                 wp += logic.unitsize;
1021                         }
1022
1023                         n_samples += repetitions;
1024                         total_samples += repetitions;
1025                         devc->total_samples += repetitions;
1026                         if (!devc->reading_behind_trigger) {
1027                                 devc->n_reps_until_trigger--;
1028                                 if (devc->n_reps_until_trigger == 0) {
1029                                         devc->reading_behind_trigger = 1;
1030                                         do_signal_trigger = 1;
1031                                         sr_dbg("Trigger position after %" PRIu64 " samples, %.6fms.",
1032                                                 devc->total_samples,
1033                                                 (double)devc->total_samples / devc->cur_samplerate * 1e3);
1034                                 }
1035                         }
1036                 }
1037                 (void)read_u8_inc(&rp); /* Skip sequence number. */
1038         }
1039         if (n_samples) {
1040                 logic.length = n_samples * logic.unitsize;
1041                 sr_session_send(sdi, &sr_packet);
1042                 if (do_signal_trigger) {
1043                         std_session_send_df_trigger(sdi);
1044                 }
1045         }
1046         sr_dbg("Send_chunk done after %u samples.", total_samples);
1047 }
1048
1049 static void LIBUSB_CALL receive_transfer(struct libusb_transfer *transfer)
1050 {
1051         struct sr_dev_inst *sdi;
1052         struct dev_context *devc;
1053         struct sr_usb_dev_inst *usb;
1054         int ret;
1055
1056         sdi = transfer->user_data;
1057         devc = sdi->priv;
1058         usb = sdi->conn;
1059
1060         sr_dbg("receive_transfer(): status %s received %d bytes.",
1061                 libusb_error_name(transfer->status), transfer->actual_length);
1062
1063         if (transfer->status == LIBUSB_TRANSFER_TIMED_OUT) {
1064                 sr_err("USB bulk transfer timeout.");
1065                 devc->transfer_finished = 1;
1066         }
1067         send_chunk(sdi, transfer->buffer, transfer->actual_length / TRANSFER_PACKET_LENGTH);
1068
1069         devc->n_bytes_to_read -= transfer->actual_length;
1070         if (devc->n_bytes_to_read) {
1071                 uint32_t to_read = devc->n_bytes_to_read;
1072                 /*
1073                  * Determine read size for the next USB transfer. Make
1074                  * the buffer size a multiple of the endpoint packet
1075                  * size. Don't exceed a maximum value.
1076                  */
1077                 if (to_read >= LA2016_USB_BUFSZ)
1078                         to_read = LA2016_USB_BUFSZ;
1079                 else
1080                         to_read = (to_read + (LA2016_EP6_PKTSZ-1)) & ~(LA2016_EP6_PKTSZ-1);
1081                 libusb_fill_bulk_transfer(transfer,
1082                         usb->devhdl, USB_EP_CAPTURE_DATA | LIBUSB_ENDPOINT_IN,
1083                         transfer->buffer, to_read,
1084                         receive_transfer, (void *)sdi, DEFAULT_TIMEOUT_MS);
1085
1086                 if ((ret = libusb_submit_transfer(transfer)) == 0)
1087                         return;
1088                 sr_err("Cannot submit another USB transfer: %s.",
1089                         libusb_error_name(ret));
1090         }
1091
1092         g_free(transfer->buffer);
1093         libusb_free_transfer(transfer);
1094         devc->transfer_finished = 1;
1095 }
1096
1097 SR_PRIV int la2016_receive_data(int fd, int revents, void *cb_data)
1098 {
1099         const struct sr_dev_inst *sdi;
1100         struct dev_context *devc;
1101         struct drv_context *drvc;
1102         struct timeval tv;
1103
1104         (void)fd;
1105         (void)revents;
1106
1107         sdi = cb_data;
1108         devc = sdi->priv;
1109         drvc = sdi->driver->context;
1110
1111         if (devc->have_trigger == 0) {
1112                 if (la2016_has_triggered(sdi) == 0) {
1113                         /* Not yet ready for sample data download. */
1114                         return TRUE;
1115                 }
1116                 devc->have_trigger = 1;
1117                 devc->transfer_finished = 0;
1118                 devc->reading_behind_trigger = 0;
1119                 devc->total_samples = 0;
1120                 /* We can start downloading sample data. */
1121                 if (la2016_start_retrieval(sdi, receive_transfer) != SR_OK) {
1122                         sr_err("Cannot start acquisition data download.");
1123                         return FALSE;
1124                 }
1125                 sr_dbg("Acquisition data download started.");
1126                 std_session_send_df_frame_begin(sdi);
1127
1128                 return TRUE;
1129         }
1130
1131         tv.tv_sec = tv.tv_usec = 0;
1132         libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
1133
1134         if (devc->transfer_finished) {
1135                 sr_dbg("Download finished, post processing.");
1136                 std_session_send_df_frame_end(sdi);
1137
1138                 usb_source_remove(sdi->session, drvc->sr_ctx);
1139                 std_session_send_df_end(sdi);
1140
1141                 la2016_stop_acquisition(sdi);
1142
1143                 g_free(devc->convbuffer);
1144                 devc->convbuffer = NULL;
1145
1146                 devc->transfer = NULL;
1147
1148                 sr_dbg("Download finished, done post processing.");
1149         }
1150
1151         return TRUE;
1152 }
1153
1154 SR_PRIV int la2016_init_device(const struct sr_dev_inst *sdi)
1155 {
1156         struct dev_context *devc;
1157         uint16_t state;
1158         uint8_t buf[8];
1159         const uint8_t *rdptr;
1160         uint8_t date_yy, date_mm;
1161         uint8_t dinv_yy, dinv_mm;
1162         uint8_t magic;
1163         const char *bitstream_fn;
1164         int ret;
1165
1166         devc = sdi->priv;
1167
1168         /*
1169          * Four EEPROM bytes at offset 0x20 are the manufacturing date,
1170          * year and month in BCD format, followed by inverted values for
1171          * consistency checks. For example bytes 20 04 df fb translate
1172          * to 2020-04. This information can help identify the vintage of
1173          * devices when unknown magic numbers are seen.
1174          */
1175         ret = ctrl_in(sdi, CMD_EEPROM, 0x20, 0, buf, 4 * sizeof(uint8_t));
1176         if (ret != SR_OK) {
1177                 sr_err("Cannot read manufacture date in EEPROM.");
1178         } else {
1179                 rdptr = &buf[0];
1180                 date_yy = read_u8_inc(&rdptr);
1181                 date_mm = read_u8_inc(&rdptr);
1182                 dinv_yy = read_u8_inc(&rdptr);
1183                 dinv_mm = read_u8_inc(&rdptr);
1184                 sr_info("Manufacture date: 20%02hx-%02hx.", date_yy, date_mm);
1185                 if ((date_mm ^ dinv_mm) != 0xff || (date_yy ^ dinv_yy) != 0xff)
1186                         sr_warn("Manufacture date fails checksum test.");
1187         }
1188
1189         /*
1190          * Several Kingst logic analyzer devices share the same USB VID
1191          * and PID. The product ID determines which MCU firmware to load.
1192          * The MCU firmware provides access to EEPROM content which then
1193          * allows to identify the device model. Which in turn determines
1194          * which FPGA bitstream to load. Eight bytes at offset 0x08 are
1195          * to get inspected.
1196          *
1197          * EEPROM content for model identification is kept redundantly
1198          * in memory. The values are stored in verbatim and in inverted
1199          * form, multiple copies are kept at different offsets. Example
1200          * data:
1201          *
1202          *   magic 0x08
1203          *    | ~magic 0xf7
1204          *    | |
1205          *   08f7000008f710ef
1206          *            | |
1207          *            | ~magic backup
1208          *            magic backup
1209          *
1210          * Exclusively inspecting the magic byte appears to be sufficient,
1211          * other fields seem to be 'don't care'.
1212          *
1213          *   magic 2 == LA2016 using "kingst-la2016-fpga.bitstream"
1214          *   magic 3 == LA1016 using "kingst-la1016-fpga.bitstream"
1215          *   magic 8 == LA2016a using "kingst-la2016a1-fpga.bitstream"
1216          *              (latest v1.3.0 PCB, perhaps others)
1217          *   magic 9 == LA1016a using "kingst-la1016a1-fpga.bitstream"
1218          *              (latest v1.3.0 PCB, perhaps others)
1219          *
1220          * When EEPROM content does not match the hardware configuration
1221          * (the board layout), the software may load but yield incorrect
1222          * results (like swapped channels). The FPGA bitstream itself
1223          * will authenticate with IC U10 and fail when its capabilities
1224          * do not match the hardware model. An LA1016 won't become a
1225          * LA2016 by faking its EEPROM content.
1226          */
1227         if ((ret = ctrl_in(sdi, CMD_EEPROM, 0x08, 0, &buf, sizeof(buf))) != SR_OK) {
1228                 sr_err("Cannot read EEPROM device identifier bytes.");
1229                 return ret;
1230         }
1231         if ((buf[0] ^ buf[1]) == 0xff) {
1232                 /* Primary copy of magic passes complement check. */
1233                 sr_dbg("Using primary copy of device type magic number.");
1234                 magic = buf[0];
1235         } else if ((buf[4] ^ buf[5]) == 0xff) {
1236                 /* Backup copy of magic passes complement check. */
1237                 sr_dbg("Using backup copy of device type magic number.");
1238                 magic = buf[4];
1239         } else {
1240                 sr_err("Cannot find consistent device type identification.");
1241                 magic = 0;
1242         }
1243         sr_dbg("Device type: magic number is %hhu.", magic);
1244
1245         /* Select the FPGA bitstream depending on the model. */
1246         switch (magic) {
1247         case 2:
1248                 bitstream_fn = FPGA_FW_LA2016;
1249                 devc->max_samplerate = MAX_SAMPLE_RATE_LA2016;
1250                 break;
1251         case 3:
1252                 bitstream_fn = FPGA_FW_LA1016;
1253                 devc->max_samplerate = MAX_SAMPLE_RATE_LA1016;
1254                 break;
1255         case 8:
1256                 bitstream_fn = FPGA_FW_LA2016A;
1257                 devc->max_samplerate = MAX_SAMPLE_RATE_LA2016;
1258                 break;
1259         case 9:
1260                 bitstream_fn = FPGA_FW_LA1016A;
1261                 devc->max_samplerate = MAX_SAMPLE_RATE_LA1016;
1262                 break;
1263         default:
1264                 bitstream_fn = NULL;
1265                 break;
1266         }
1267         if (!bitstream_fn || !*bitstream_fn) {
1268                 sr_err("Cannot identify as one of the supported models.");
1269                 return SR_ERR;
1270         }
1271
1272         if (check_fpga_bitstream(sdi) != SR_OK) {
1273                 ret = upload_fpga_bitstream(sdi, bitstream_fn);
1274                 if (ret != SR_OK) {
1275                         sr_err("Cannot upload FPGA bitstream.");
1276                         return ret;
1277                 }
1278         }
1279         ret = enable_fpga_bitstream(sdi);
1280         if (ret != SR_OK) {
1281                 sr_err("Cannot enable FPGA bitstream after upload.");
1282                 return ret;
1283         }
1284
1285         state = run_state(sdi);
1286         if (state != 0x85e9) {
1287                 sr_warn("Unexpected run state, want 0x85e9, got 0x%04x.", state);
1288         }
1289
1290         if ((ret = ctrl_out(sdi, CMD_BULK_RESET, 0x00, 0, NULL, 0)) != SR_OK) {
1291                 sr_err("Cannot reset USB bulk transfer.");
1292                 return ret;
1293         }
1294
1295         sr_dbg("Device should be initialized.");
1296
1297         ret = set_defaults(sdi);
1298         if (ret != SR_OK)
1299                 return ret;
1300
1301         return SR_OK;
1302 }
1303
1304 SR_PRIV int la2016_deinit_device(const struct sr_dev_inst *sdi)
1305 {
1306         int ret;
1307
1308         if ((ret = ctrl_out(sdi, CMD_FPGA_ENABLE, 0x00, 0, NULL, 0)) != SR_OK) {
1309                 sr_err("Cannot deinitialize device's FPGA.");
1310                 return ret;
1311         }
1312
1313         return SR_OK;
1314 }